?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merge the formfield patch from ooo-build
[ooovba.git] / svtools / source / control / calendar.cxx
blobb9a2c8b54fb4c028a9f7dd5426933b7ad5e33f35
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: calendar.cxx,v $
10 * $Revision: 1.14 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_svtools.hxx"
33
34 #ifndef _APP_HXX
35 #include <vcl/svapp.hxx>
36 #endif
37 #ifndef _TABLE_HXX
38 #include <tools/table.hxx>
39 #endif
40 #ifndef _HELP_HXX
41 #include <vcl/help.hxx>
42 #endif
43 #ifndef _MENU_HXX
44 #include <vcl/menu.hxx>
45 #endif
46 #ifndef _DECOVIEW_HXX
47 #include <vcl/decoview.hxx>
48 #endif
49 #ifndef _FLOATWIN_HXX
50 #include <vcl/floatwin.hxx>
51 #endif
52 #ifndef _BUTTON_HXX
53 #include <vcl/button.hxx>
54 #endif
55 #ifndef _FIXED_HXX
56 #include <vcl/fixed.hxx>
57 #endif
58 #include <unotools/calendarwrapper.hxx>
59 #include <unotools/localedatawrapper.hxx>
60 #include <com/sun/star/i18n/Weekdays.hpp>
61 #include <com/sun/star/i18n/CalendarDisplayIndex.hpp>
62 #include <com/sun/star/i18n/CalendarFieldIndex.hpp>
63
64 #define _SV_CALENDAR_CXX
65 #include <svtools/svtools.hrc>
66 #include <svtools/svtdata.hxx>
67 #include <calendar.hxx>
68
69 // =======================================================================
70
71 #define DAY_OFFX 4
72 #define DAY_OFFY 2
73 #define MONTH_BORDERX 4
74 #define MONTH_OFFY 3
75 #define WEEKNUMBER_OFFX 4
76 #define WEEKDAY_OFFY 3
77 #define TITLE_OFFY 3
78 #define TITLE_BORDERY 2
79 #define SPIN_OFFX 4
80 #define SPIN_OFFY TITLE_BORDERY
81
82 #define WEEKNUMBER_HEIGHT 85
83
84 #define CALENDAR_HITTEST_DAY ((USHORT)0x0001)
85 #define CALENDAR_HITTEST_WEEK ((USHORT)0x0002)
86 #define CALENDAR_HITTEST_MONTHTITLE ((USHORT)0x0004)
87 #define CALENDAR_HITTEST_PREV ((USHORT)0x0008)
88 #define CALENDAR_HITTEST_NEXT ((USHORT)0x0010)
89 #define CALENDAR_HITTEST_OUTSIDE ((USHORT)0x1000)
90
91 #define MENU_YEAR_COUNT 3
92
93 #define TABLE_DATE_SELECTED ((void*)0x00000001)
94
95 using namespace ::com::sun::star;
96
97 // =======================================================================
98
99 struct ImplDateInfo
100 {
101 XubString maText;
102 Color* mpTextColor;
103 Color* mpFrameColor;
104 USHORT mnFlags;
105
106 ImplDateInfo( const XubString& rText ) :
107 maText( rText )
108 { mpTextColor = mpFrameColor = NULL; mnFlags = 0; }
109 ~ImplDateInfo() { delete mpTextColor; delete mpFrameColor; }
110 };
111
112 DECLARE_TABLE( ImplDateTable, ImplDateInfo* )
113
114 // =======================================================================
115
116 static void ImplCalendarSelectDate( Table* pTable, const Date& rDate, BOOL bSelect )
117 {
118 if ( bSelect )
119 pTable->Insert( rDate.GetDate(), TABLE_DATE_SELECTED );
120 else
121 pTable->Remove( rDate.GetDate() );
122 }
123
124 // -----------------------------------------------------------------------
125
126 static void ImplCalendarSelectDateRange( Table* pTable,
127 const Date& rStartDate,
128 const Date& rEndDate,
129 BOOL bSelect )
130 {
131 Date aStartDate = rStartDate;
132 Date aEndDate = rEndDate;
133 if ( aStartDate > aEndDate )
134 {
135 Date aTempDate = aStartDate;
136 aStartDate = aEndDate;
137 aEndDate = aTempDate;
138 }
139
140 if ( bSelect )
141 {
142 while ( aStartDate <= aEndDate )
143 {
144 pTable->Insert( aStartDate.GetDate(), TABLE_DATE_SELECTED );
145 aStartDate++;
146 }
147 }
148 else
149 {
150 void* p = pTable->First();
151 while ( p )
152 {
153 Date aDate( pTable->GetCurKey() );
154 if ( aDate > aEndDate )
155 break;
156
157 if ( aDate >= aStartDate )
158 pTable->Remove( aDate.GetDate() );
159 else
160 p = pTable->Next();
161 }
162 }
163 }
164
165 // -----------------------------------------------------------------------
166
167 static void ImplCalendarUnSelectDateRange( Table* pTable,
168 Table* pOldTable,
169 const Date& rStartDate,
170 const Date& rEndDate )
171 {
172 Date aStartDate = rStartDate;
173 Date aEndDate = rEndDate;
174 if ( aStartDate > aEndDate )
175 {
176 Date aTempDate = aStartDate;
177 aStartDate = aEndDate;
178 aEndDate = aTempDate;
179 }
180
181 void* p = pTable->First();
182 while ( p )
183 {
184 Date aDate( pTable->GetCurKey() );
185 if ( aDate > aEndDate )
186 break;
187
188 if ( aDate >= aStartDate )
189 pTable->Remove( aDate.GetDate() );
190 else
191 p = pTable->Next();
192 }
193
194 p = pOldTable->First();
195 while ( p )
196 {
197 Date aDate( pOldTable->GetCurKey() );
198 if ( aDate > aEndDate )
199 break;
200 if ( aDate >= aStartDate )
201 pTable->Insert( aDate.GetDate(), TABLE_DATE_SELECTED );
202
203 p = pOldTable->Next();
204 }
205 }
206
207 // -----------------------------------------------------------------------
208
209 inline void ImplCalendarClearSelectDate( Table* pTable )
210 {
211 pTable->Clear();
212 }
213
214 // =======================================================================
215
216 void Calendar::ImplInit( WinBits nWinStyle )
217 {
218 mpDateTable = NULL;
219 mpSelectTable = new Table;
220 mpOldSelectTable = NULL;
221 mpRestoreSelectTable = NULL;
222 mpStandardColor = NULL;
223 mpSaturdayColor = NULL;
224 mpSundayColor = NULL;
225 mnDayCount = 0;
226 mnWinStyle = nWinStyle;
227 mnFirstYear = 0;
228 mnLastYear = 0;
229 mnRequestYear = 0;
230 mbCalc = TRUE;
231 mbFormat = TRUE;
232 mbDrag = FALSE;
233 mbSelection = FALSE;
234 mbMultiSelection = FALSE;
235 mbWeekSel = FALSE;
236 mbUnSel = FALSE;
237 mbMenuDown = FALSE;
238 mbSpinDown = FALSE;
239 mbPrevIn = FALSE;
240 mbNextIn = FALSE;
241 mbDirect = FALSE;
242 mbInSelChange = FALSE;
243 mbTravelSelect = FALSE;
244 mbScrollDateRange = FALSE;
245 mbSelLeft = FALSE;
246 mbAllSel = FALSE;
247 mbDropPos = FALSE;
248
249 ::rtl::OUString aGregorian( RTL_CONSTASCII_USTRINGPARAM( "gregorian"));
250 maCalendarWrapper.loadCalendar( aGregorian,
251 Application::GetAppLocaleDataWrapper().getLocale());
252 if (maCalendarWrapper.getUniqueID() != aGregorian)
253 {
254 #ifdef DBG_UTIL
255 ByteString aMsg( "Calendar::ImplInit: No ``gregorian'' calendar available for locale ``");
256 lang::Locale aLoc( Application::GetAppLocaleDataWrapper().getLocale());
257 aMsg += ByteString( String( aLoc.Language), RTL_TEXTENCODING_UTF8);
258 aMsg += '-';
259 aMsg += ByteString( String( aLoc.Country), RTL_TEXTENCODING_UTF8);
260 aMsg += "'' and other calendars aren't supported. Using en-US fallback.";
261 DBG_ERRORFILE( aMsg.GetBuffer());
262 #endif
263 /* If we ever wanted to support other calendars than Gregorian a lot of
264 * rewrite would be necessary to internally replace use of class Date
265 * with proper class CalendarWrapper methods, get rid of fixed 12
266 * months, fixed 7 days, ... */
267 maCalendarWrapper.loadCalendar( aGregorian, lang::Locale(
268 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "en")),
269 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "US")),
270 ::rtl::OUString()));
271 }
272
273 SetFirstDate( maCurDate );
274 ImplCalendarSelectDate( mpSelectTable, maCurDate, TRUE );
275
276 // Sonstige Strings erzeugen
277 maDayText = XubString( SvtResId( STR_SVT_CALENDAR_DAY ) );
278 maWeekText = XubString( SvtResId( STR_SVT_CALENDAR_WEEK ) );
279
280 // Tagestexte anlegen
281 for ( USHORT i = 0; i < 31; i++ )
282 mpDayText[i] = new UniString( UniString::CreateFromInt32( i+1 ) );
283
284 maDragScrollTimer.SetTimeoutHdl( STATIC_LINK( this, Calendar, ScrollHdl ) );
285 maDragScrollTimer.SetTimeout( GetSettings().GetMouseSettings().GetScrollRepeat() );
286 mnDragScrollHitTest = 0;
287
288 ImplInitSettings();
289 }
290
291 // -----------------------------------------------------------------------
292
293 void Calendar::ImplInitSettings()
294 {
295 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
296 maSelColor = rStyleSettings.GetHighlightTextColor();
297 SetPointFont( rStyleSettings.GetToolFont() );
298 SetTextColor( rStyleSettings.GetFieldTextColor() );
299 SetBackground( Wallpaper( rStyleSettings.GetFieldColor() ) );
300 }
301
302 // -----------------------------------------------------------------------
303
304 Calendar::Calendar( Window* pParent, WinBits nWinStyle ) :
305 Control( pParent, nWinStyle & (WB_TABSTOP | WB_GROUP | WB_BORDER | WB_3DLOOK | WB_RANGESELECT | WB_MULTISELECT) ),
306 maCalendarWrapper( Application::GetAppLocaleDataWrapper().getServiceFactory() ),
307 maOldFormatFirstDate( 0, 0, 1900 ),
308 maOldFormatLastDate( 0, 0, 1900 ),
309 maFirstDate( 0, 0, 1900 ),
310 maOldFirstDate( 0, 0, 1900 ),
311 maOldCurDate( 0, 0, 1900 ),
312 maAnchorDate( maCurDate ),
313 maDropDate( 0, 0, 1900 )
314 {
315 ImplInit( nWinStyle );
316 }
317
318 // -----------------------------------------------------------------------
319
320 Calendar::Calendar( Window* pParent, const ResId& rResId ) :
321 Control( pParent, rResId ),
322 maCalendarWrapper( Application::GetAppLocaleDataWrapper().getServiceFactory() ),
323 maOldFormatFirstDate( 0, 0, 1900 ),
324 maOldFormatLastDate( 0, 0, 1900 ),
325 maFirstDate( 0, 0, 1900 ),
326 maOldFirstDate( 0, 0, 1900 ),
327 maOldCurDate( 0, 0, 1900 ),
328 maAnchorDate( maCurDate ),
329 maDropDate( 0, 0, 1900 )
330 {
331 ImplInit( rResId.GetWinBits() );
332 }
333
334 // -----------------------------------------------------------------------
335
336 Calendar::~Calendar()
337 {
338 delete mpStandardColor;
339 delete mpSaturdayColor;
340 delete mpSundayColor;
341
342 if ( mpDateTable )
343 {
344 ImplDateInfo* pDateInfo = mpDateTable->First();
345 while ( pDateInfo )
346 {
347 delete pDateInfo;
348 pDateInfo = mpDateTable->Next();
349 }
350
351 delete mpDateTable;
352 }
353
354 delete mpSelectTable;
355 if ( mpOldSelectTable )
356 delete mpOldSelectTable;
357 if ( mpRestoreSelectTable )
358 delete mpRestoreSelectTable;
359
360 for ( USHORT i = 0; i < 31; i++ )
361 delete mpDayText[i];
362 }
363
364 // -----------------------------------------------------------------------
365
366 void Calendar::SetMinimumNumberOfDaysInWeek( sal_Int16 nDays )
367 {
368 ImplUpdate( TRUE );
369 maCalendarWrapper.setMinimumNumberOfDaysForFirstWeek( nDays);
370 }
371
372 // -----------------------------------------------------------------------
373
374 void Calendar::SetWeekStart( sal_Int16 nDay )
375 {
376 ImplUpdate( TRUE );
377 switch (nDay)
378 {
379 case i18n::Weekdays::SUNDAY :
380 case i18n::Weekdays::MONDAY :
381 case i18n::Weekdays::TUESDAY :
382 case i18n::Weekdays::WEDNESDAY :
383 case i18n::Weekdays::THURSDAY :
384 case i18n::Weekdays::FRIDAY :
385 case i18n::Weekdays::SATURDAY :
386 ; // nothing
387 default:
388 DBG_ERRORFILE("Calendar::SetWeekStart: unknown value for setFirstDayOfWeek() of a Gregorian calendar");
389 nDay = i18n::Weekdays::SUNDAY;
390 }
391 maCalendarWrapper.setFirstDayOfWeek( nDay);
392 }
393
394 // -----------------------------------------------------------------------
395
396 DayOfWeek Calendar::ImplGetWeekStart() const
397 {
398 // Map i18n::Weekdays to Date DayOfWeek
399 DayOfWeek eDay;
400 sal_Int16 nDay = maCalendarWrapper.getFirstDayOfWeek();
401 switch (nDay)
402 {
403 case i18n::Weekdays::SUNDAY :
404 eDay = SUNDAY;
405 break;
406 case i18n::Weekdays::MONDAY :
407 eDay = MONDAY;
408 break;
409 case i18n::Weekdays::TUESDAY :
410 eDay = TUESDAY;
411 break;
412 case i18n::Weekdays::WEDNESDAY :
413 eDay = WEDNESDAY;
414 break;
415 case i18n::Weekdays::THURSDAY :
416 eDay = THURSDAY;
417 break;
418 case i18n::Weekdays::FRIDAY :
419 eDay = FRIDAY;
420 break;
421 case i18n::Weekdays::SATURDAY :
422 eDay = SATURDAY;
423 break;
424 default:
425 DBG_ERRORFILE("Calendar::ImplGetWeekStart: broken i18n Gregorian calendar (getFirstDayOfWeek())");
426 eDay = SUNDAY;
427 }
428 return eDay;
429 }
430
431 // -----------------------------------------------------------------------
432
433 void Calendar::ImplGetWeekFont( Font& rFont ) const
434 {
435 // Wochennummer geben wir in WEEKNUMBER_HEIGHT%-Fonthoehe aus
436 Size aFontSize = rFont.GetSize();
437 aFontSize.Height() *= WEEKNUMBER_HEIGHT;
438 aFontSize.Height() /= 100;
439 rFont.SetSize( aFontSize );
440 rFont.SetWeight( WEIGHT_NORMAL );
441 }
442
443 // -----------------------------------------------------------------------
444
445 void Calendar::ImplFormat()
446 {
447 if ( !mbFormat )
448 return;
449
450 if ( mbCalc )
451 {
452 Size aOutSize = GetOutputSizePixel();
453
454 if ( (aOutSize.Width() <= 1) || (aOutSize.Height() <= 1) )
455 return;
456
457 XubString a99Text( XubString( RTL_CONSTASCII_USTRINGPARAM( "99" ) ) );
458
459 Font aOldFont = GetFont();
460
461 // Wochenanzeige beruecksichtigen
462 if ( mnWinStyle & WB_WEEKNUMBER )
463 {
464 Font aTempFont = aOldFont;
465 ImplGetWeekFont( aTempFont );
466 SetFont( aTempFont );
467 mnWeekWidth = GetTextWidth( a99Text )+WEEKNUMBER_OFFX;
468 SetFont( aOldFont );
469 }
470 else
471 mnWeekWidth = 0;
472
473 if ( mnWinStyle & WB_BOLDTEXT )
474 {
475 Font aFont = aOldFont;
476 if ( aFont.GetWeight() < WEIGHT_BOLD )
477 aFont.SetWeight( WEIGHT_BOLD );
478 else
479 aFont.SetWeight( WEIGHT_NORMAL );
480 SetFont( aFont );
481 }
482
483 long n99TextWidth = GetTextWidth( a99Text );
484 long nTextHeight = GetTextHeight();
485
486 // Breiten und X-Positionen berechnen
487 mnDayWidth = n99TextWidth+DAY_OFFX;
488 mnMonthWidth = mnDayWidth*7;
489 mnMonthWidth += mnWeekWidth;
490 mnMonthWidth += MONTH_BORDERX*2;
491 mnMonthPerLine = aOutSize.Width() / mnMonthWidth;
492 if ( !mnMonthPerLine )
493 mnMonthPerLine = 1;
494 long nOver = ((aOutSize.Width()-(mnMonthPerLine*mnMonthWidth)) / mnMonthPerLine);
495 mnMonthWidth += nOver;
496 mnDaysOffX = MONTH_BORDERX;
497 mnDaysOffX += nOver/2;
498 mnDaysOffX += mnWeekWidth;
499
500 // Hoehen und Y-Positionen berechnen
501 mnDayHeight = nTextHeight + DAY_OFFY;
502 mnWeekDayOffY = nTextHeight + TITLE_OFFY + (TITLE_BORDERY*2);
503 mnDaysOffY = mnWeekDayOffY + nTextHeight + WEEKDAY_OFFY;
504 mnMonthHeight = (mnDayHeight*6) + mnDaysOffY;
505 mnMonthHeight += MONTH_OFFY;
506 mnLines = aOutSize.Height() / mnMonthHeight;
507 if ( !mnLines )
508 mnLines = 1;
509 mnMonthHeight += (aOutSize.Height()-(mnLines*mnMonthHeight)) / mnLines;
510
511 // Spinfelder berechnen
512 long nSpinSize = nTextHeight+TITLE_BORDERY-SPIN_OFFY;
513 maPrevRect.Left() = SPIN_OFFX;
514 maPrevRect.Top() = SPIN_OFFY;
515 maPrevRect.Right() = maPrevRect.Left()+nSpinSize;
516 maPrevRect.Bottom() = maPrevRect.Top()+nSpinSize;
517 maNextRect.Left() = aOutSize.Width()-SPIN_OFFX-nSpinSize-1;
518 maNextRect.Top() = SPIN_OFFY;
519 maNextRect.Right() = maNextRect.Left()+nSpinSize;
520 maNextRect.Bottom() = maNextRect.Top()+nSpinSize;
521
522 if ( mnWinStyle & WB_BOLDTEXT )
523 SetFont( aOldFont );
524
525 // Calculate DayOfWeekText (gets displayed in a narrow font)
526 maDayOfWeekText.Erase();
527 long nStartOffX = 0;
528 sal_Int16 nDay = maCalendarWrapper.getFirstDayOfWeek();
529 for ( sal_Int16 nDayOfWeek = 0; nDayOfWeek < 7; nDayOfWeek++ )
530 {
531 // Use first character of full name, since the abbreviated name may
532 // be roman digits or similar in some locales. Proper
533 // implementation would need narrow one letter month names defined
534 // in locale data.
535 String aDayOfWeek( maCalendarWrapper.getDisplayName(
536 i18n::CalendarDisplayIndex::DAY, nDay, 1).GetChar(0));
537 long nOffX = (mnDayWidth-GetTextWidth( aDayOfWeek ))/2;
538 if ( mnWinStyle & WB_BOLDTEXT )
539 nOffX++;
540 if ( !nDayOfWeek )
541 nStartOffX = nOffX;
542 else
543 nOffX -= nStartOffX;
544 nOffX += nDayOfWeek * mnDayWidth;
545 mnDayOfWeekAry[nDayOfWeek] = nOffX;
546 maDayOfWeekText += aDayOfWeek;
547 nDay++;
548 nDay %= 7;
549 }
550
551 mbCalc = FALSE;
552 }
553
554 // Anzahl Tage berechnen
555
556 DayOfWeek eStartDay = ImplGetWeekStart();
557
558 USHORT nWeekDay;
559 Date aTempDate = GetFirstMonth();
560 maFirstDate = aTempDate;
561 nWeekDay = (USHORT)aTempDate.GetDayOfWeek();
562 nWeekDay = (nWeekDay+(7-(USHORT)eStartDay)) % 7;
563 maFirstDate -= (ULONG)nWeekDay;
564 mnDayCount = nWeekDay;
565 USHORT nDaysInMonth;
566 USHORT nMonthCount = (USHORT)(mnMonthPerLine*mnLines);
567 for ( USHORT i = 0; i < nMonthCount; i++ )
568 {
569 nDaysInMonth = aTempDate.GetDaysInMonth();
570 mnDayCount += nDaysInMonth;
571 aTempDate += nDaysInMonth;
572 }
573 Date aTempDate2 = aTempDate;
574 aTempDate2--;
575 nDaysInMonth = aTempDate2.GetDaysInMonth();
576 aTempDate2 -= nDaysInMonth-1;
577 nWeekDay = (USHORT)aTempDate2.GetDayOfWeek();
578 nWeekDay = (nWeekDay+(7-(USHORT)eStartDay)) % 7;
579 mnDayCount += 42-nDaysInMonth-nWeekDay;
580
581 // Farben festlegen
582 maOtherColor = Color( COL_LIGHTGRAY );
583 if ( maOtherColor.IsRGBEqual( GetBackground().GetColor() ) )
584 maOtherColor.SetColor( COL_GRAY );
585
586 Date aLastDate = GetLastDate();
587 if ( (maOldFormatLastDate != aLastDate) ||
588 (maOldFormatFirstDate != maFirstDate) )
589 {
590 maOldFormatFirstDate = maFirstDate;
591 maOldFormatLastDate = aLastDate;
592 DateRangeChanged();
593 }
594
595 // DateInfo besorgen
596 USHORT nNewFirstYear = maFirstDate.GetYear();
597 USHORT nNewLastYear = GetLastDate().GetYear();
598 if ( mnFirstYear )
599 {
600 if ( nNewFirstYear < mnFirstYear )
601 {
602 for ( mnRequestYear = nNewFirstYear; mnRequestYear < mnFirstYear; mnRequestYear++ )
603 RequestDateInfo();
604 mnFirstYear = nNewFirstYear;
605 }
606 if ( nNewLastYear > mnLastYear )
607 {
608 for ( mnRequestYear = mnLastYear; mnRequestYear < nNewLastYear; mnRequestYear++ )
609 RequestDateInfo();
610 mnLastYear = nNewLastYear;
611 }
612 }
613 else
614 {
615 for ( mnRequestYear = nNewFirstYear; mnRequestYear < nNewLastYear; mnRequestYear++ )
616 RequestDateInfo();
617 mnFirstYear = nNewFirstYear;
618 mnLastYear = nNewLastYear;
619 }
620 mnRequestYear = 0;
621
622 mbFormat = FALSE;
623 }
624
625 // -----------------------------------------------------------------------
626
627 USHORT Calendar::ImplHitTest( const Point& rPos, Date& rDate ) const
628 {
629 if ( mbFormat )
630 return 0;
631
632 if ( maPrevRect.IsInside( rPos ) )
633 return CALENDAR_HITTEST_PREV;
634 else if ( maNextRect.IsInside( rPos ) )
635 return CALENDAR_HITTEST_NEXT;
636
637 long nX;
638 long nY;
639 long nOffX;
640 long nYMonth;
641 USHORT nDay;
642 DayOfWeek eStartDay = ImplGetWeekStart();
643
644 rDate = GetFirstMonth();
645 nY = 0;
646 for ( long i = 0; i < mnLines; i++ )
647 {
648 if ( rPos.Y() < nY )
649 return 0;
650
651 nX = 0;
652 nYMonth = nY+mnMonthHeight;
653 for ( long j = 0; j < mnMonthPerLine; j++ )
654 {
655 if ( (rPos.X() < nX) && (rPos.Y() < nYMonth) )
656 return 0;
657
658 USHORT nDaysInMonth = rDate.GetDaysInMonth();
659
660 // Entsprechender Monat gefunden
661 if ( (rPos.X() > nX) && (rPos.Y() < nYMonth) &&
662 (rPos.X() < nX+mnMonthWidth) )
663 {
664 if ( rPos.Y() < (nY+(TITLE_BORDERY*2)+mnDayHeight))
665 return CALENDAR_HITTEST_MONTHTITLE;
666 else
667 {
668 long nDayX = nX+mnDaysOffX;
669 long nDayY = nY+mnDaysOffY;
670 if ( rPos.Y() < nDayY )
671 return 0;
672 USHORT nDayIndex = (USHORT)rDate.GetDayOfWeek();
673 nDayIndex = (nDayIndex+(7-(USHORT)eStartDay)) % 7;
674 if ( (i == 0) && (j == 0) )
675 {
676 Date aTempDate = rDate;
677 aTempDate -= nDayIndex;
678 for ( nDay = 0; nDay < nDayIndex; nDay++ )
679 {
680 nOffX = nDayX + (nDay*mnDayWidth);
681 if ( (rPos.Y() >= nDayY) && (rPos.Y() < nDayY+mnDayHeight) &&
682 (rPos.X() >= nOffX) && (rPos.X() < nOffX+mnDayWidth) )
683 {
684 rDate = aTempDate;
685 rDate += nDay;
686 return CALENDAR_HITTEST_DAY;
687 }
688 }
689 }
690 for ( nDay = 1; nDay <= nDaysInMonth; nDay++ )
691 {
692 if ( rPos.Y() < nDayY )
693 {
694 rDate += nDayIndex;
695 return 0;
696 }
697 nOffX = nDayX + (nDayIndex*mnDayWidth);
698 if ( (rPos.Y() >= nDayY) && (rPos.Y() < nDayY+mnDayHeight) &&
699 (rPos.X() >= nOffX) && (rPos.X() < nOffX+mnDayWidth) )
700 {
701 rDate += nDay-1;
702 return CALENDAR_HITTEST_DAY;
703 }
704 if ( nDayIndex == 6 )
705 {
706 nDayIndex = 0;
707 nDayY += mnDayHeight;
708 }
709 else
710 nDayIndex++;
711 }
712 if ( (i == mnLines-1) && (j == mnMonthPerLine-1) )
713 {
714 USHORT nWeekDay = (USHORT)rDate.GetDayOfWeek();
715 nWeekDay = (nWeekDay+(7-(USHORT)eStartDay)) % 7;
716 USHORT nDayCount = 42-nDaysInMonth-nWeekDay;
717 Date aTempDate = rDate;
718 aTempDate += nDaysInMonth;
719 for ( nDay = 1; nDay <= nDayCount; nDay++ )
720 {
721 if ( rPos.Y() < nDayY )
722 {
723 rDate += nDayIndex;
724 return 0;
725 }
726 nOffX = nDayX + (nDayIndex*mnDayWidth);
727 if ( (rPos.Y() >= nDayY) && (rPos.Y() < nDayY+mnDayHeight) &&
728 (rPos.X() >= nOffX) && (rPos.X() < nOffX+mnDayWidth) )
729 {
730 rDate = aTempDate;
731 rDate += nDay-1;
732 return CALENDAR_HITTEST_DAY;
733 }
734 if ( nDayIndex == 6 )
735 {
736 nDayIndex = 0;
737 nDayY += mnDayHeight;
738 }
739 else
740 nDayIndex++;
741 }
742 }
743 }
744 }
745
746 rDate += nDaysInMonth;
747 nX += mnMonthWidth;
748 }
749
750 nY += mnMonthHeight;
751 }
752
753 return 0;
754 }
755
756 // -----------------------------------------------------------------------
757
758 static void ImplDrawSpinArrow( OutputDevice* pDev, const Rectangle& rRect,
759 BOOL bPrev )
760 {
761 long i;
762 long n;
763 long nLines;
764 long nHeight = rRect.GetHeight();
765 long nWidth = rRect.GetWidth();
766 if ( nWidth < nHeight )
767 n = nWidth;
768 else
769 n = nHeight;
770 if ( !(n & 0x01) )
771 n--;
772 nLines = n/2;
773
774 Rectangle aRect( Point( rRect.Left()+(nWidth/2)-(nLines/2),
775 rRect.Top()+(nHeight/2) ),
776 Size( 1, 1 ) );
777 if ( !bPrev )
778 {
779 aRect.Left() += nLines;
780 aRect.Right() += nLines;
781 }
782
783 pDev->DrawRect( aRect );
784 for ( i = 0; i < nLines; i++ )
785 {
786 if ( bPrev )
787 {
788 aRect.Left()++;
789 aRect.Right()++;
790 }
791 else
792 {
793 aRect.Left()--;
794 aRect.Right()--;
795 }
796 aRect.Top()--;
797 aRect.Bottom()++;
798 pDev->DrawRect( aRect );
799 }
800 }
801
802 // -----------------------------------------------------------------------
803
804 void Calendar::ImplDrawSpin( BOOL bDrawPrev, BOOL bDrawNext )
805 {
806 if ( !bDrawPrev && !bDrawNext )
807 return;
808
809 SetLineColor();
810 SetFillColor( GetSettings().GetStyleSettings().GetButtonTextColor() );
811 if ( bDrawPrev )
812 {
813 Rectangle aOutRect = maPrevRect;
814 aOutRect.Left() += 3;
815 aOutRect.Top() += 3;
816 aOutRect.Right() -= 3;
817 aOutRect.Bottom() -= 3;
818 ImplDrawSpinArrow( this, aOutRect, TRUE );
819 }
820 if ( bDrawNext )
821 {
822 Rectangle aOutRect = maNextRect;
823 aOutRect.Left() += 3;
824 aOutRect.Top() += 3;
825 aOutRect.Right() -= 3;
826 aOutRect.Bottom() -= 3;
827 ImplDrawSpinArrow( this, aOutRect, FALSE );
828 }
829 }
830
831 // -----------------------------------------------------------------------
832
833 void Calendar::ImplDrawDate( long nX, long nY,
834 USHORT nDay, USHORT nMonth, USHORT nYear,
835 DayOfWeek eDayOfWeek,
836 BOOL bBack, BOOL bOther, ULONG nToday )
837 {
838 ImplDateInfo* pDateInfo;
839 Color* pTextColor = NULL;
840 const String& rDay = *(mpDayText[nDay-1]);
841 Rectangle aDateRect( nX, nY, nX+mnDayWidth-1, nY+mnDayHeight-1 );
842
843 BOOL bSel = FALSE;
844 BOOL bFocus = FALSE;
845 // Aktueller Tag
846 if ( (nDay == maCurDate.GetDay()) &&
847 (nMonth == maCurDate.GetMonth()) &&
848 (nYear == maCurDate.GetYear()) )
849 bFocus = TRUE;
850 if ( mpSelectTable )
851 {
852 if ( mpSelectTable->IsKeyValid( Date( nDay, nMonth, nYear ).GetDate() ) )
853 bSel = TRUE;
854 }
855
856 // Dateinfo ermitteln
857 if ( mpDateTable )
858 {
859 pDateInfo = mpDateTable->Get( Date( nDay, nMonth, nYear ).GetDate() );
860 if ( !pDateInfo )
861 pDateInfo = mpDateTable->Get( Date( nDay, nMonth, 0 ).GetDate() );
862 }
863 else
864 pDateInfo = NULL;
865
866 // Textfarbe ermitteln
867 if ( bSel )
868 pTextColor = &maSelColor;
869 else if ( bOther )
870 pTextColor = &maOtherColor;
871 else
872 {
873 if ( pDateInfo && pDateInfo->mpTextColor )
874 pTextColor = pDateInfo->mpTextColor;
875 else
876 {
877 if ( eDayOfWeek == SATURDAY )
878 pTextColor = mpSaturdayColor;
879 else if ( eDayOfWeek == SUNDAY )
880 pTextColor = mpSundayColor;
881 if ( !pTextColor )
882 pTextColor = mpStandardColor;
883 }
884 }
885
886 if ( bFocus )
887 HideFocus();
888
889 // Font ermitteln
890 Font aOldFont = GetFont();
891 BOOL bBoldFont = FALSE;
892 if ( (mnWinStyle & WB_BOLDTEXT) &&
893 pDateInfo && (pDateInfo->mnFlags & DIB_BOLD) )
894 {
895 bBoldFont = TRUE;
896 Font aFont = aOldFont;
897 if ( aFont.GetWeight() < WEIGHT_BOLD )
898 aFont.SetWeight( WEIGHT_BOLD );
899 else
900 aFont.SetWeight( WEIGHT_NORMAL );
901 SetFont( aFont );
902 }
903
904 // Hintergrund ausgeben
905 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
906 if ( bSel || bBack )
907 {
908 if ( bSel )
909 {
910 SetLineColor();
911 SetFillColor( rStyleSettings.GetHighlightColor() );
912 DrawRect( aDateRect );
913 }
914 else
915 Erase( aDateRect );
916 }
917
918 // Text ausgeben
919 long nTextX = nX+(mnDayWidth-GetTextWidth( rDay ))-(DAY_OFFX/2);
920 long nTextY = nY+(mnDayHeight-GetTextHeight())/2;
921 if ( pTextColor )
922 {
923 Color aOldColor = GetTextColor();
924 SetTextColor( *pTextColor );
925 DrawText( Point( nTextX, nTextY ), rDay );
926 SetTextColor( aOldColor );
927 }
928 else
929 DrawText( Point( nTextX, nTextY ), rDay );
930
931 // Heute
932 Date aTodayDate( maCurDate );
933 if ( nToday )
934 aTodayDate.SetDate( nToday );
935 else
936 aTodayDate = Date();
937 if ( (nDay == aTodayDate.GetDay()) &&
938 (nMonth == aTodayDate.GetMonth()) &&
939 (nYear == aTodayDate.GetYear()) )
940 {
941 SetLineColor( rStyleSettings.GetWindowTextColor() );
942 SetFillColor();
943 DrawRect( aDateRect );
944 }
945
946 // Evt. DateInfo ausgeben
947 if ( (mnWinStyle & WB_FRAMEINFO) && pDateInfo && pDateInfo->mpFrameColor )
948 {
949 SetLineColor( *(pDateInfo->mpFrameColor) );
950 SetFillColor();
951 Rectangle aFrameRect( aDateRect );
952 aFrameRect.Left()++;
953 aFrameRect.Top()++;
954 long nFrameWidth = aFrameRect.GetWidth();
955 long nFrameHeight = aFrameRect.GetHeight();
956 long nFrameOff;
957 if ( nFrameWidth < nFrameHeight )
958 {
959 nFrameOff = nFrameHeight-nFrameWidth;
960 aFrameRect.Top() += nFrameOff/2;
961 nFrameOff %= 2;
962 aFrameRect.Bottom() -= nFrameOff;
963 }
964 else if ( nFrameWidth > nFrameHeight )
965 {
966 nFrameOff = nFrameWidth-nFrameHeight;
967 aFrameRect.Left() += nFrameOff/2;
968 nFrameOff %= 2;
969 aFrameRect.Right() -= nFrameOff;
970 }
971 DrawEllipse( aFrameRect );
972 }
973
974 // Evt. noch FocusRect
975 if ( bFocus && HasFocus() )
976 ShowFocus( aDateRect );
977
978 if( mbDropPos && maDropDate == Date( nDay, nMonth, nYear ) )
979 ImplInvertDropPos();
980
981 if ( bBoldFont )
982 SetFont( aOldFont );
983 }
984
985 // -----------------------------------------------------------------------
986
987 void Calendar::ImplDraw( BOOL bPaint )
988 {
989 ImplFormat();
990
991 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
992 Size aOutSize = GetOutputSizePixel();
993 long i;
994 long j;
995 long nX;
996 long nY;
997 long nDeltaX;
998 long nDeltaY;
999 long nDayX;
1000 long nDayY;
1001 ULONG nToday = Date().GetDate();
1002 USHORT nDay;
1003 USHORT nMonth;
1004 USHORT nYear;
1005 Date aDate = GetFirstMonth();
1006 DayOfWeek eStartDay = ImplGetWeekStart();
1007
1008 HideFocus();
1009
1010 nY = 0;
1011 for ( i = 0; i < mnLines; i++ )
1012 {
1013 // Titleleiste ausgeben
1014 SetLineColor();
1015 SetFillColor( rStyleSettings.GetFaceColor() );
1016 Rectangle aTitleRect( 0, nY, aOutSize.Width()-1, nY+mnDayHeight-DAY_OFFY+TITLE_BORDERY*2 );
1017 if ( !bPaint )
1018 {
1019 Rectangle aTempRect( 1, aTitleRect.Top()+TITLE_BORDERY,
1020 aOutSize.Width()-2,
1021 aTitleRect.Bottom()-TITLE_BORDERY );
1022 if ( !i )
1023 {
1024 aTempRect.Left() = maPrevRect.Right()+1;
1025 aTempRect.Right() = maNextRect.Left()-1;
1026 }
1027 DrawRect( aTempRect );
1028 }
1029 else
1030 {
1031 DrawRect( aTitleRect );
1032 Point aTopLeft1( aTitleRect.Left(), aTitleRect.Top() );
1033 Point aTopLeft2( aTitleRect.Left(), aTitleRect.Top()+1 );
1034 Point aBottomRight1( aTitleRect.Right(), aTitleRect.Bottom() );
1035 Point aBottomRight2( aTitleRect.Right(), aTitleRect.Bottom()-1 );
1036 SetLineColor( rStyleSettings.GetDarkShadowColor() );
1037 DrawLine( aTopLeft1, Point( aBottomRight1.X(), aTopLeft1.Y() ) );
1038 SetLineColor( rStyleSettings.GetLightColor() );
1039 DrawLine( aTopLeft2, Point( aBottomRight2.X(), aTopLeft2.Y() ) );
1040 DrawLine( aTopLeft2, Point( aTopLeft2.X(), aBottomRight2.Y() ) );
1041 SetLineColor( rStyleSettings.GetShadowColor() );
1042 DrawLine( Point( aTopLeft2.X(), aBottomRight2.Y() ), aBottomRight2 );
1043 DrawLine( Point( aBottomRight2.X(), aTopLeft2.Y() ), aBottomRight2 );
1044 SetLineColor( rStyleSettings.GetDarkShadowColor() );
1045 DrawLine( Point( aTopLeft1.X(), aBottomRight1.Y() ), aBottomRight1 );
1046 }
1047 Point aSepPos1( 0, aTitleRect.Top()+TITLE_BORDERY );
1048 Point aSepPos2( 0, aTitleRect.Bottom()-TITLE_BORDERY );
1049 for ( j = 0; j < mnMonthPerLine-1; j++ )
1050 {
1051 aSepPos1.X() += mnMonthWidth-1;
1052 aSepPos2.X() = aSepPos1.X();
1053 SetLineColor( rStyleSettings.GetShadowColor() );
1054 DrawLine( aSepPos1, aSepPos2 );
1055 aSepPos1.X()++;
1056 aSepPos2.X() = aSepPos1.X();
1057 SetLineColor( rStyleSettings.GetLightColor() );
1058 DrawLine( aSepPos1, aSepPos2 );
1059 }
1060
1061 nX = 0;
1062 for ( j = 0; j < mnMonthPerLine; j++ )
1063 {
1064 nMonth = aDate.GetMonth();
1065 nYear = aDate.GetYear();
1066
1067 // Monat in der Titleleiste ausgeben
1068 nDeltaX = nX;
1069 nDeltaY = nY+TITLE_BORDERY;
1070 String aMonthText( maCalendarWrapper.getDisplayName(
1071 i18n::CalendarDisplayIndex::MONTH, nMonth-1, 1));
1072 aMonthText += ' ';
1073 aMonthText += String::CreateFromInt64( nYear );
1074 long nMonthTextWidth = GetTextWidth( aMonthText );
1075 long nMonthOffX1 = 0;
1076 long nMonthOffX2 = 0;
1077 if ( i == 0 )
1078 {
1079 if ( j == 0 )
1080 nMonthOffX1 = maPrevRect.Right()+1;
1081 if ( j == mnMonthPerLine-1 )
1082 nMonthOffX2 = aOutSize.Width()-maNextRect.Left()+1;
1083 }
1084 long nMaxMonthWidth = mnMonthWidth-nMonthOffX1-nMonthOffX2-4;
1085 if ( nMonthTextWidth > nMaxMonthWidth )
1086 {
1087 // Abbreviated month name.
1088 aMonthText = maCalendarWrapper.getDisplayName(
1089 i18n::CalendarDisplayIndex::MONTH, nMonth-1, 0);
1090 aMonthText += ' ';
1091 aMonthText += String::CreateFromInt64( nYear );
1092 nMonthTextWidth = GetTextWidth( aMonthText );
1093 }
1094 long nTempOff = (mnMonthWidth-nMonthTextWidth+1)/2;
1095 if ( nTempOff < nMonthOffX1 )
1096 nDeltaX += nMonthOffX1+1;
1097 else
1098 {
1099 if ( nTempOff+nMonthTextWidth > mnMonthWidth-nMonthOffX2 )
1100 nDeltaX += mnMonthWidth-nMonthOffX2-nMonthTextWidth;
1101 else
1102 nDeltaX += nTempOff;
1103 }
1104 SetTextColor( rStyleSettings.GetButtonTextColor() );
1105 DrawText( Point( nDeltaX, nDeltaY ), aMonthText );
1106 SetTextColor( rStyleSettings.GetWindowTextColor() );
1107
1108 // Weekleiste ausgeben
1109 if ( bPaint )
1110 {
1111 nDayX = nX+mnDaysOffX;
1112 nDayY = nY+mnWeekDayOffY;
1113 nDeltaY = nDayY + mnDayHeight;
1114 SetLineColor( rStyleSettings.GetWindowTextColor() );
1115 Point aStartPos( nDayX, nDeltaY );
1116 if ( mnWinStyle & WB_WEEKNUMBER )
1117 aStartPos.X() -= WEEKNUMBER_OFFX-2;
1118 DrawLine( aStartPos, Point( nDayX+(7*mnDayWidth), nDeltaY ) );
1119 DrawTextArray( Point( nDayX+mnDayOfWeekAry[0], nDayY ), maDayOfWeekText, &(mnDayOfWeekAry[1]) );
1120 }
1121
1122 // Week-Numbers ausgeben
1123 if ( mnWinStyle & WB_WEEKNUMBER )
1124 {
1125 nDayX = nX+mnDaysOffX;
1126 nDayY = nY+mnWeekDayOffY;
1127 nDeltaY = nDayY + mnDayHeight;
1128 long nMonthHeight = mnDayHeight*6;
1129 if ( bPaint )
1130 DrawLine( Point( nDayX-WEEKNUMBER_OFFX+2, nDeltaY ), Point( nDayX-WEEKNUMBER_OFFX+2, nDeltaY+nMonthHeight ) );
1131 else
1132 Erase( Rectangle( nDayX-mnWeekWidth-WEEKNUMBER_OFFX, nDeltaY, nDayX-WEEKNUMBER_OFFX-1, nDeltaY+nMonthHeight ) );
1133
1134 Font aOldFont = GetFont();
1135 Font aTempFont = aOldFont;
1136 ImplGetWeekFont( aTempFont );
1137 SetFont( aTempFont );
1138 nDayX -= mnWeekWidth;
1139 nDayY = nY+mnDaysOffY;
1140 maCalendarWrapper.setGregorianDateTime( aDate);
1141 for ( USHORT nWeekCount = 0; nWeekCount < 6; nWeekCount++ )
1142 {
1143 sal_Int16 nWeek = maCalendarWrapper.getValue( i18n::CalendarFieldIndex::WEEK_OF_YEAR);
1144 String aWeekText( String::CreateFromInt32( nWeek));
1145 long nOffX = (mnWeekWidth-WEEKNUMBER_OFFX)-GetTextWidth( aWeekText );
1146 long nOffY = (mnDayHeight-GetTextHeight())/2;
1147 DrawText( Point( nDayX+nOffX, nDayY+nOffY ), aWeekText );
1148 nDayY += mnDayHeight;
1149 maCalendarWrapper.addValue( i18n::CalendarFieldIndex::DAY_OF_MONTH, 7);
1150 }
1151 SetFont( aOldFont );
1152 }
1153
1154 // Tage ausgeben
1155 USHORT nDaysInMonth = aDate.GetDaysInMonth();
1156 nDayX = nX+mnDaysOffX;
1157 nDayY = nY+mnDaysOffY;
1158 if ( !bPaint )
1159 {
1160 Rectangle aClearRect( nDayX, nDayY,
1161 nDayX+(7*mnDayWidth)-1, nDayY+(6*mnDayHeight)-1 );
1162 Erase( aClearRect );
1163 }
1164 USHORT nDayIndex = (USHORT)aDate.GetDayOfWeek();
1165 nDayIndex = (nDayIndex+(7-(USHORT)eStartDay)) % 7;
1166 if ( (i == 0) && (j == 0) )
1167 {
1168 Date aTempDate = aDate;
1169 aTempDate -= nDayIndex;
1170 for ( nDay = 0; nDay < nDayIndex; nDay++ )
1171 {
1172 nDeltaX = nDayX + (nDay*mnDayWidth);
1173 ImplDrawDate( nDeltaX, nDayY, nDay+aTempDate.GetDay(),
1174 aTempDate.GetMonth(), aTempDate.GetYear(),
1175 (DayOfWeek)((nDay+(USHORT)eStartDay)%7), FALSE, TRUE, nToday );
1176 }
1177 }
1178 for ( nDay = 1; nDay <= nDaysInMonth; nDay++ )
1179 {
1180 nDeltaX = nDayX + (nDayIndex*mnDayWidth);
1181 ImplDrawDate( nDeltaX, nDayY, nDay, nMonth, nYear,
1182 (DayOfWeek)((nDayIndex+(USHORT)eStartDay)%7),
1183 FALSE, FALSE, nToday );
1184 if ( nDayIndex == 6 )
1185 {
1186 nDayIndex = 0;
1187 nDayY += mnDayHeight;
1188 }
1189 else
1190 nDayIndex++;
1191 }
1192 if ( (i == mnLines-1) && (j == mnMonthPerLine-1) )
1193 {
1194 USHORT nWeekDay = (USHORT)aDate.GetDayOfWeek();
1195 nWeekDay = (nWeekDay+(7-(USHORT)eStartDay)) % 7;
1196 USHORT nDayCount = 42-nDaysInMonth-nWeekDay;
1197 Date aTempDate = aDate;
1198 aTempDate += nDaysInMonth;
1199 for ( nDay = 1; nDay <= nDayCount; nDay++ )
1200 {
1201 nDeltaX = nDayX + (nDayIndex*mnDayWidth);
1202 ImplDrawDate( nDeltaX, nDayY, nDay,
1203 aTempDate.GetMonth(), aTempDate.GetYear(),
1204 (DayOfWeek)((nDayIndex+(USHORT)eStartDay)%7),
1205 FALSE, TRUE, nToday );
1206 if ( nDayIndex == 6 )
1207 {
1208 nDayIndex = 0;
1209 nDayY += mnDayHeight;
1210 }
1211 else
1212 nDayIndex++;
1213 }
1214 }
1215
1216 aDate += nDaysInMonth;
1217 nX += mnMonthWidth;
1218 }
1219
1220 nY += mnMonthHeight;
1221 }
1222
1223 // Spin-Buttons zeichnen
1224 if ( bPaint )
1225 ImplDrawSpin();
1226 }
1227
1228 // -----------------------------------------------------------------------
1229
1230 void Calendar::ImplUpdateDate( const Date& rDate )
1231 {
1232 if ( IsReallyVisible() && IsUpdateMode() )
1233 {
1234 Rectangle aDateRect( GetDateRect( rDate ) );
1235 if ( !aDateRect.IsEmpty() )
1236 {
1237 BOOL bOther = (rDate < GetFirstMonth()) || (rDate > GetLastMonth());
1238 ImplDrawDate( aDateRect.Left(), aDateRect.Top(),
1239 rDate.GetDay(), rDate.GetMonth(), rDate.GetYear(),
1240 rDate.GetDayOfWeek(), TRUE, bOther );
1241 }
1242 }
1243 }
1244
1245 // -----------------------------------------------------------------------
1246
1247 void Calendar::ImplUpdateSelection( Table* pOld )
1248 {
1249 Table* pNew = mpSelectTable;
1250 void* p;
1251 ULONG nKey;
1252
1253 p = pOld->First();
1254 while ( p )
1255 {
1256 nKey = pOld->GetCurKey();
1257 if ( !pNew->Get( nKey ) )
1258 {
1259 Date aTempDate( nKey );
1260 ImplUpdateDate( aTempDate );
1261 }
1262
1263 p = pOld->Next();
1264 }
1265
1266 p = pNew->First();
1267 while ( p )
1268 {
1269 nKey = pNew->GetCurKey();
1270 if ( !pOld->Get( nKey ) )
1271 {
1272 Date aTempDate( nKey );
1273 ImplUpdateDate( aTempDate );
1274 }
1275
1276 p = pNew->Next();
1277 }
1278 }
1279
1280 // -----------------------------------------------------------------------
1281
1282 void Calendar::ImplMouseSelect( const Date& rDate, USHORT nHitTest,
1283 BOOL bMove, BOOL bExpand, BOOL bExtended )
1284 {
1285 Table* pOldSel = new Table( *mpSelectTable );
1286 Date aOldDate = maCurDate;
1287 Date aTempDate = rDate;
1288
1289 if ( !(nHitTest & CALENDAR_HITTEST_DAY) )
1290 aTempDate--;
1291
1292 if ( mbMultiSelection )
1293 {
1294 maCurDate = aTempDate;
1295 mbSelLeft = aTempDate < maAnchorDate;
1296
1297 if ( bMove )
1298 {
1299 if ( mbSelLeft )
1300 {
1301 ImplCalendarUnSelectDateRange( mpSelectTable, mpRestoreSelectTable, Date( 1, 1, 0 ), aTempDate );
1302 ImplCalendarUnSelectDateRange( mpSelectTable, mpRestoreSelectTable, maAnchorDate, Date( 31, 12, 9999 ) );
1303 }
1304 else
1305 {
1306 ImplCalendarUnSelectDateRange( mpSelectTable, mpRestoreSelectTable, Date( 1, 1, 0 ), maAnchorDate );
1307 ImplCalendarUnSelectDateRange( mpSelectTable, mpRestoreSelectTable, aTempDate, Date( 31, 12, 9999 ) );
1308 }
1309 ImplCalendarSelectDateRange( mpSelectTable, aTempDate, maAnchorDate, !mbUnSel );
1310 }
1311 else
1312 {
1313 if ( bExpand )
1314 {
1315 if ( !bExtended )
1316 {
1317 if ( mbSelLeft )
1318 {
1319 ImplCalendarSelectDateRange( mpSelectTable, Date( 1, 1, 0 ), aTempDate, FALSE );
1320 ImplCalendarSelectDateRange( mpSelectTable, maAnchorDate, Date( 31, 12, 9999 ), FALSE );
1321 }
1322 else
1323 {
1324 ImplCalendarSelectDateRange( mpSelectTable, Date( 1, 1, 0 ), maAnchorDate, FALSE );
1325 ImplCalendarSelectDateRange( mpSelectTable, aTempDate, Date( 31, 12, 9999 ), FALSE );
1326 }
1327 }
1328 ImplCalendarSelectDateRange( mpSelectTable, aTempDate, maAnchorDate, TRUE );
1329 }
1330 else if ( bExtended && !(mnWinStyle & WB_RANGESELECT) )
1331 {
1332 maAnchorDate = aTempDate;
1333 if ( IsDateSelected( aTempDate ) )
1334 {
1335 mbUnSel = TRUE;
1336 ImplCalendarSelectDate( mpSelectTable, aTempDate, FALSE );
1337 }
1338 else
1339 {
1340 ImplCalendarSelectDate( mpSelectTable, aTempDate, TRUE );
1341 }
1342 }
1343 else
1344 {
1345 maAnchorDate = aTempDate;
1346 ImplCalendarClearSelectDate( mpSelectTable );
1347 ImplCalendarSelectDate( mpSelectTable, aTempDate, TRUE );
1348 }
1349
1350 mpRestoreSelectTable = new Table( *mpSelectTable );
1351 }
1352 }
1353 else
1354 {
1355 if ( aTempDate < maCurDate )
1356 mbSelLeft = TRUE;
1357 else
1358 mbSelLeft = FALSE;
1359 if ( !(nHitTest & CALENDAR_HITTEST_DAY) )
1360 aTempDate = maOldCurDate;
1361 if ( !bMove )
1362 maAnchorDate = aTempDate;
1363 if ( aTempDate != maCurDate )
1364 {
1365 maCurDate = aTempDate;
1366 ImplCalendarSelectDate( mpSelectTable, aOldDate, FALSE );
1367 ImplCalendarSelectDate( mpSelectTable, maCurDate, TRUE );
1368 }
1369 }
1370
1371 BOOL bNewSel = *pOldSel != *mpSelectTable;
1372 if ( (maCurDate != aOldDate) || bNewSel )
1373 {
1374 if ( bNewSel )
1375 {
1376 mbInSelChange = TRUE;
1377 SelectionChanging();
1378 mbInSelChange = FALSE;
1379 }
1380 HideFocus();
1381 if ( bNewSel )
1382 ImplUpdateSelection( pOldSel );
1383 if ( !bNewSel || !pOldSel->Get( aOldDate.GetDate() ) )
1384 ImplUpdateDate( aOldDate );
1385 // Damit Focus-Rechteck auch wieder neu ausgegeben wird
1386 if ( HasFocus() || !bNewSel || !mpSelectTable->Get( maCurDate.GetDate() ) )
1387 ImplUpdateDate( maCurDate );
1388 }
1389 delete pOldSel;
1390 }
1391
1392 // -----------------------------------------------------------------------
1393
1394 void Calendar::ImplUpdate( BOOL bCalcNew )
1395 {
1396 if ( IsReallyVisible() && IsUpdateMode() )
1397 {
1398 if ( bCalcNew && !mbCalc )
1399 Invalidate();
1400 else if ( !mbFormat && !mbCalc )
1401 {
1402 if ( mbDirect )
1403 {
1404 mbFormat = TRUE;
1405 ImplDraw( FALSE );
1406 return;
1407 }
1408 else
1409 Invalidate();
1410 }
1411 }
1412
1413 if ( bCalcNew )
1414 mbCalc = TRUE;
1415 mbFormat = TRUE;
1416 }
1417
1418 // -----------------------------------------------------------------------
1419
1420 void Calendar::ImplInvertDropPos()
1421 {
1422 Rectangle aRect = GetDateRect( maDropDate );//this is one Pixel to width and one to heigh
1423 aRect.Bottom() = aRect.Top()+mnDayHeight-1;
1424 aRect.Right() = aRect.Left()+mnDayWidth-1;
1425 Invert( aRect );
1426 }
1427
1428 // -----------------------------------------------------------------------
1429
1430 void Calendar::ImplScroll( BOOL bPrev )
1431 {
1432 Date aNewFirstMonth = GetFirstMonth();
1433 if ( bPrev )
1434 {
1435 aNewFirstMonth--;
1436 aNewFirstMonth -= aNewFirstMonth.GetDaysInMonth()-1;
1437 }
1438 else
1439 aNewFirstMonth += aNewFirstMonth.GetDaysInMonth();
1440 mbDirect = TRUE;
1441 SetFirstDate( aNewFirstMonth );
1442 mbDirect = FALSE;
1443 }
1444
1445 // -----------------------------------------------------------------------
1446
1447 void Calendar::ImplShowMenu( const Point& rPos, const Date& rDate )
1448 {
1449 EndSelection();
1450
1451 Date aOldFirstDate = GetFirstMonth();
1452 PopupMenu aPopupMenu;
1453 PopupMenu* pYearPopupMenus[MENU_YEAR_COUNT];
1454 USHORT nMonthOff;
1455 USHORT nCurItemId;
1456 USHORT nYear = rDate.GetYear()-1;
1457 USHORT i;
1458 USHORT j;
1459 USHORT nYearIdCount = 1000;
1460
1461 nMonthOff = (rDate.GetYear()-aOldFirstDate.GetYear())*12;
1462 if ( aOldFirstDate.GetMonth() < rDate.GetMonth() )
1463 nMonthOff += rDate.GetMonth()-aOldFirstDate.GetMonth();
1464 else
1465 nMonthOff -= aOldFirstDate.GetMonth()-rDate.GetMonth();
1466
1467 // Menu aufbauen (Jahre mit verschiedenen Monaten aufnehmen)
1468 for ( i = 0; i < MENU_YEAR_COUNT; i++ )
1469 {
1470 pYearPopupMenus[i] = new PopupMenu;
1471 for ( j = 1; j <= 12; j++ )
1472 pYearPopupMenus[i]->InsertItem( nYearIdCount+j,
1473 maCalendarWrapper.getDisplayName(
1474 i18n::CalendarDisplayIndex::MONTH, j-1, 1));
1475 aPopupMenu.InsertItem( 10+i, UniString::CreateFromInt32( nYear+i ) );
1476 aPopupMenu.SetPopupMenu( 10+i, pYearPopupMenus[i] );
1477 nYearIdCount += 1000;
1478 }
1479
1480 mbMenuDown = TRUE;
1481 nCurItemId = aPopupMenu.Execute( this, rPos );
1482 mbMenuDown = FALSE;
1483
1484 // Menu zerstoeren
1485 aPopupMenu.SetPopupMenu( 2, NULL );
1486 for ( i = 0; i < MENU_YEAR_COUNT; i++ )
1487 {
1488 aPopupMenu.SetPopupMenu( 10+i, NULL );
1489 delete pYearPopupMenus[i];
1490 }
1491
1492 if ( nCurItemId )
1493 {
1494 USHORT nTempMonthOff = nMonthOff % 12;
1495 USHORT nTempYearOff = nMonthOff / 12;
1496 USHORT nNewMonth = nCurItemId % 1000;
1497 USHORT nNewYear = nYear+((nCurItemId-1000)/1000);
1498 if ( nTempMonthOff < nNewMonth )
1499 nNewMonth = nNewMonth - nTempMonthOff;
1500 else
1501 {
1502 nNewYear--;
1503 nNewMonth = 12-(nTempMonthOff-nNewMonth);
1504 }
1505 nNewYear = nNewYear - nTempYearOff;
1506 SetFirstDate( Date( 1, nNewMonth, nNewYear ) );
1507 }
1508 }
1509
1510 // -----------------------------------------------------------------------
1511
1512 void Calendar::ImplTracking( const Point& rPos, BOOL bRepeat )
1513 {
1514 Date aTempDate = maCurDate;
1515 USHORT nHitTest = ImplHitTest( rPos, aTempDate );
1516
1517 if ( mbSpinDown )
1518 {
1519 mbPrevIn = (nHitTest & CALENDAR_HITTEST_PREV) != 0;
1520 mbNextIn = (nHitTest & CALENDAR_HITTEST_NEXT) != 0;
1521
1522 if ( bRepeat && (mbPrevIn || mbNextIn) )
1523 {
1524 mbScrollDateRange = TRUE;
1525 ImplScroll( mbPrevIn );
1526 mbScrollDateRange = FALSE;
1527 }
1528 }
1529 else
1530 ImplMouseSelect( aTempDate, nHitTest, TRUE, FALSE, FALSE );
1531 }
1532
1533 // -----------------------------------------------------------------------
1534
1535 void Calendar::ImplEndTracking( BOOL bCancel )
1536 {
1537 BOOL bSelection = mbSelection;
1538 BOOL bSpinDown = mbSpinDown;
1539
1540 mbDrag = FALSE;
1541 mbSelection = FALSE;
1542 mbMultiSelection = FALSE;
1543 mbUnSel = FALSE;
1544 mbSpinDown = FALSE;
1545 mbPrevIn = FALSE;
1546 mbNextIn = FALSE;
1547
1548 if ( bCancel )
1549 {
1550 if ( maOldFirstDate != maFirstDate )
1551 SetFirstDate( maOldFirstDate );
1552
1553 if ( !bSpinDown )
1554 {
1555 Table* pOldSel = new Table( *mpSelectTable );
1556 Date aOldDate = maCurDate;
1557 maCurDate = maOldCurDate;
1558 *mpSelectTable = *mpOldSelectTable;
1559 HideFocus();
1560 ImplUpdateSelection( pOldSel );
1561 if ( !pOldSel->Get( aOldDate.GetDate() ) )
1562 ImplUpdateDate( aOldDate );
1563 // Damit Focus-Rechteck auch wieder neu ausgegeben wird
1564 if ( HasFocus() || !mpSelectTable->Get( maCurDate.GetDate() ) )
1565 ImplUpdateDate( maCurDate );
1566 delete pOldSel;
1567 }
1568 }
1569
1570 if ( !bSpinDown )
1571 {
1572 if ( !bCancel )
1573 {
1574 // Feststellen, ob wir sichtbaren Bereich scrollen sollen
1575 ULONG nSelCount = mpSelectTable->Count();
1576 if ( nSelCount )
1577 {
1578 Date aFirstSelDate( mpSelectTable->GetObjectKey( 0 ) );
1579 Date aLastSelDate( mpSelectTable->GetObjectKey( nSelCount-1 ) );
1580 if ( aLastSelDate < GetFirstMonth() )
1581 ImplScroll( TRUE );
1582 else if ( GetLastMonth() < aFirstSelDate )
1583 ImplScroll( FALSE );
1584 }
1585 }
1586
1587 if ( mbAllSel ||
1588 (!bCancel && ((maCurDate != maOldCurDate) || (*mpOldSelectTable != *mpSelectTable))) )
1589 Select();
1590
1591 if ( !bSelection && (mnWinStyle & WB_TABSTOP) && !bCancel )
1592 GrabFocus();
1593
1594 delete mpOldSelectTable;
1595 mpOldSelectTable = NULL;
1596 delete mpRestoreSelectTable;
1597 mpRestoreSelectTable = NULL;
1598 }
1599 }
1600
1601 // -----------------------------------------------------------------------
1602
1603 IMPL_STATIC_LINK( Calendar, ScrollHdl, Timer*, EMPTYARG )
1604 {
1605 BOOL bPrevIn = (pThis->mnDragScrollHitTest & CALENDAR_HITTEST_PREV) != 0;
1606 BOOL bNextIn = (pThis->mnDragScrollHitTest & CALENDAR_HITTEST_NEXT) != 0;
1607 if( bNextIn || bPrevIn )
1608 {
1609 pThis->mbScrollDateRange = TRUE;
1610 pThis->ImplScroll( bPrevIn );
1611 pThis->mbScrollDateRange = FALSE;
1612 }
1613 return 0;
1614 }
1615
1616 // -----------------------------------------------------------------------
1617
1618 void Calendar::MouseButtonDown( const MouseEvent& rMEvt )
1619 {
1620 if ( rMEvt.IsLeft() && !mbMenuDown )
1621 {
1622 Date aTempDate = maCurDate;
1623 USHORT nHitTest = ImplHitTest( rMEvt.GetPosPixel(), aTempDate );
1624 if ( nHitTest )
1625 {
1626 if ( nHitTest & CALENDAR_HITTEST_MONTHTITLE )
1627 ImplShowMenu( rMEvt.GetPosPixel(), aTempDate );
1628 else
1629 {
1630 maOldFirstDate = maFirstDate;
1631
1632 mbPrevIn = (nHitTest & CALENDAR_HITTEST_PREV) != 0;
1633 mbNextIn = (nHitTest & CALENDAR_HITTEST_NEXT) != 0;
1634 if ( mbPrevIn || mbNextIn )
1635 {
1636 mbSpinDown = TRUE;
1637 mbScrollDateRange = TRUE;
1638 ImplScroll( mbPrevIn );
1639 mbScrollDateRange = FALSE;
1640 // Hier muss BUTTONREPEAT stehen, also nicht wieder
1641 // auf SCROLLREPEAT aendern, sondern mit TH abklaeren,
1642 // warum es evtl. anders sein sollte (71775)
1643 StartTracking( STARTTRACK_BUTTONREPEAT );
1644 }
1645 else
1646 {
1647 if ( (rMEvt.GetClicks() == 2) && (nHitTest & CALENDAR_HITTEST_DAY) )
1648 DoubleClick();
1649 else
1650 {
1651 if ( mpOldSelectTable )
1652 delete mpOldSelectTable;
1653 maOldCurDate = maCurDate;
1654 mpOldSelectTable = new Table( *mpSelectTable );
1655
1656 if ( !mbSelection )
1657 {
1658 mbDrag = TRUE;
1659 StartTracking();
1660 }
1661
1662 mbMultiSelection = (mnWinStyle & (WB_MULTISELECT | WB_RANGESELECT)) != 0;
1663 if ( (nHitTest & CALENDAR_HITTEST_DAY) && mbMultiSelection )
1664 mbWeekSel = TRUE;
1665 else
1666 mbWeekSel = FALSE;
1667 ImplMouseSelect( aTempDate, nHitTest, FALSE, rMEvt.IsShift(), rMEvt.IsMod1() );
1668 }
1669 }
1670 }
1671 }
1672
1673 return;
1674 }
1675
1676 Control::MouseButtonDown( rMEvt );
1677 }
1678
1679 // -----------------------------------------------------------------------
1680
1681 void Calendar::MouseButtonUp( const MouseEvent& rMEvt )
1682 {
1683 if ( rMEvt.IsLeft() && mbSelection )
1684 ImplEndTracking( FALSE );
1685 else
1686 Control::MouseButtonUp( rMEvt );
1687 }
1688
1689 // -----------------------------------------------------------------------
1690
1691 void Calendar::MouseMove( const MouseEvent& rMEvt )
1692 {
1693 if ( mbSelection && rMEvt.GetButtons() )
1694 ImplTracking( rMEvt.GetPosPixel(), FALSE );
1695 else
1696 Control::MouseMove( rMEvt );
1697 }
1698
1699 // -----------------------------------------------------------------------
1700
1701 void Calendar::Tracking( const TrackingEvent& rTEvt )
1702 {
1703 Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel();
1704
1705 if ( rTEvt.IsTrackingEnded() )
1706 ImplEndTracking( rTEvt.IsTrackingCanceled() );
1707 else
1708 ImplTracking( aMousePos, rTEvt.IsTrackingRepeat() );
1709 }
1710
1711 // -----------------------------------------------------------------------
1712
1713 void Calendar::KeyInput( const KeyEvent& rKEvt )
1714 {
1715 Date aNewDate = maCurDate;
1716 BOOL bMultiSel = (mnWinStyle & (WB_RANGESELECT | WB_MULTISELECT)) != 0;
1717 BOOL bExpand = rKEvt.GetKeyCode().IsShift();
1718 BOOL bExtended = rKEvt.GetKeyCode().IsMod1();
1719
1720 switch ( rKEvt.GetKeyCode().GetCode() )
1721 {
1722 case KEY_HOME:
1723 aNewDate.SetDay( 1 );
1724 break;
1725
1726 case KEY_END:
1727 aNewDate.SetDay( aNewDate.GetDaysInMonth() );
1728 break;
1729
1730 case KEY_LEFT:
1731 aNewDate--;
1732 break;
1733
1734 case KEY_RIGHT:
1735 aNewDate++;
1736 break;
1737
1738 case KEY_UP:
1739 aNewDate -= 7;
1740 break;
1741
1742 case KEY_DOWN:
1743 aNewDate += 7;
1744 break;
1745
1746 case KEY_PAGEUP:
1747 {
1748 Date aTempDate = aNewDate;
1749 aTempDate -= aNewDate.GetDay()+1;
1750 aNewDate -= aTempDate.GetDaysInMonth();
1751 }
1752 break;
1753
1754 case KEY_PAGEDOWN:
1755 aNewDate += aNewDate.GetDaysInMonth();
1756 break;
1757
1758 case KEY_SPACE:
1759 if ( bMultiSel && !(mnWinStyle & WB_RANGESELECT) )
1760 {
1761 if ( !bExpand )
1762 {
1763 BOOL bDateSel = IsDateSelected( maCurDate );
1764 SelectDate( maCurDate, !bDateSel );
1765 mbSelLeft = FALSE;
1766 SelectionChanging();
1767 mbTravelSelect = TRUE;
1768 Select();
1769 mbTravelSelect = FALSE;
1770 }
1771 }
1772 else
1773 Control::KeyInput( rKEvt );
1774 break;
1775
1776 default:
1777 Control::KeyInput( rKEvt );
1778 break;
1779 }
1780
1781 if ( aNewDate != maCurDate )
1782 {
1783 if ( bMultiSel && bExpand )
1784 {
1785 Table* pOldSel = new Table( *mpSelectTable );
1786 Date aOldAnchorDate = maAnchorDate;
1787 mbSelLeft = aNewDate < maAnchorDate;
1788 if ( !bExtended )
1789 {
1790 if ( mbSelLeft )
1791 {
1792 ImplCalendarSelectDateRange( mpSelectTable, Date( 1, 1, 0 ), aNewDate, FALSE );
1793 ImplCalendarSelectDateRange( mpSelectTable, maAnchorDate, Date( 31, 12, 9999 ), FALSE );
1794 }
1795 else
1796 {
1797 ImplCalendarSelectDateRange( mpSelectTable, Date( 1, 1, 0 ), maAnchorDate, FALSE );
1798 ImplCalendarSelectDateRange( mpSelectTable, aNewDate, Date( 31, 12, 9999 ), FALSE );
1799 }
1800 }
1801 ImplCalendarSelectDateRange( mpSelectTable, aNewDate, maAnchorDate, TRUE );
1802 mbDirect = TRUE;
1803 SetCurDate( aNewDate );
1804 mbDirect = FALSE;
1805 maAnchorDate = aOldAnchorDate;
1806 mbInSelChange = TRUE;
1807 SelectionChanging();
1808 mbInSelChange = FALSE;
1809 ImplUpdateSelection( pOldSel );
1810 delete pOldSel;
1811 }
1812 else
1813 {
1814 if ( mnWinStyle & WB_RANGESELECT )
1815 {
1816 SetNoSelection();
1817 SelectDate( aNewDate, TRUE );
1818 }
1819 mbDirect = TRUE;
1820 SetCurDate( aNewDate );
1821 mbDirect = FALSE;
1822 }
1823 mbTravelSelect = TRUE;
1824 Select();
1825 mbTravelSelect = FALSE;
1826 }
1827 }
1828
1829 // -----------------------------------------------------------------------
1830
1831 void Calendar::Paint( const Rectangle& )
1832 {
1833 ImplDraw( TRUE );
1834 }
1835
1836 // -----------------------------------------------------------------------
1837
1838 void Calendar::GetFocus()
1839 {
1840 ImplUpdateDate( maCurDate );
1841 Control::GetFocus();
1842 }
1843
1844 // -----------------------------------------------------------------------
1845
1846 void Calendar::LoseFocus()
1847 {
1848 HideFocus();
1849 Control::LoseFocus();
1850 }
1851
1852 // -----------------------------------------------------------------------
1853
1854 void Calendar::Resize()
1855 {
1856 ImplUpdate( TRUE );
1857 Control::Resize();
1858 }
1859
1860 // -----------------------------------------------------------------------
1861
1862 void Calendar::RequestHelp( const HelpEvent& rHEvt )
1863 {
1864 if ( rHEvt.GetMode() & (HELPMODE_QUICK | HELPMODE_BALLOON) )
1865 {
1866 Date aDate = maCurDate;
1867 if ( GetDate( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ), aDate ) )
1868 {
1869 Rectangle aDateRect = GetDateRect( aDate );
1870 Point aPt = OutputToScreenPixel( aDateRect.TopLeft() );
1871 aDateRect.Left() = aPt.X();
1872 aDateRect.Top() = aPt.Y();
1873 aPt = OutputToScreenPixel( aDateRect.BottomRight() );
1874 aDateRect.Right() = aPt.X();
1875 aDateRect.Bottom() = aPt.Y();
1876
1877 if ( (rHEvt.GetMode() & HELPMODE_BALLOON) || (mnWinStyle & WB_QUICKHELPSHOWSDATEINFO) )
1878 {
1879 ImplDateInfo* pInfo;
1880 if ( mpDateTable )
1881 {
1882 pInfo = mpDateTable->Get( aDate.GetDate() );
1883 if ( !pInfo )
1884 pInfo = mpDateTable->Get( Date( aDate.GetDay(), aDate.GetMonth(), 0 ).GetDate() );
1885 }
1886 else
1887 pInfo = NULL;
1888 if ( pInfo )
1889 {
1890 XubString aStr = pInfo->maText;
1891 if ( aStr.Len() )
1892 {
1893 Help::ShowBalloon( this, rHEvt.GetMousePosPixel(), aDateRect, aStr );
1894 return;
1895 }
1896 }
1897 }
1898
1899 if ( rHEvt.GetMode() & HELPMODE_QUICK )
1900 {
1901 maCalendarWrapper.setGregorianDateTime( aDate);
1902 USHORT nWeek = (USHORT) maCalendarWrapper.getValue( i18n::CalendarFieldIndex::WEEK_OF_YEAR);
1903 USHORT nMonth = aDate.GetMonth();
1904 XubString aStr( maDayText );
1905 aStr.AppendAscii( ": " );
1906 aStr.Append( XubString::CreateFromInt32( aDate.GetDayOfYear() ) );
1907 aStr.AppendAscii( " / " );
1908 aStr.Append( maWeekText );
1909 aStr.AppendAscii( ": " );
1910 aStr.Append( XubString::CreateFromInt32( nWeek ) );
1911 // Evt. noch Jahr hinzufuegen, wenn es nicht das gleiche ist
1912 if ( (nMonth == 12) && (nWeek == 1) )
1913 {
1914 aStr.AppendAscii( ", " );
1915 aStr.Append( XubString::CreateFromInt32( aDate.GetYear()+1 ) );
1916 }
1917 else if ( (nMonth == 1) && (nWeek > 50) )
1918 {
1919 aStr.AppendAscii( ", " );
1920 aStr.Append( XubString::CreateFromInt32( aDate.GetYear()-1 ) );
1921 }
1922 Help::ShowQuickHelp( this, aDateRect, aStr );
1923 return;
1924 }
1925 }
1926 }
1927
1928 Control::RequestHelp( rHEvt );
1929 }
1930
1931 // -----------------------------------------------------------------------
1932
1933 void Calendar::Command( const CommandEvent& rCEvt )
1934 {
1935 if ( rCEvt.GetCommand() == COMMAND_CONTEXTMENU )
1936 {
1937 if ( !mbSelection && rCEvt.IsMouseEvent() )
1938 {
1939 Date aTempDate = maCurDate;
1940 USHORT nHitTest = ImplHitTest( rCEvt.GetMousePosPixel(), aTempDate );
1941 if ( nHitTest & CALENDAR_HITTEST_MONTHTITLE )
1942 {
1943 ImplShowMenu( rCEvt.GetMousePosPixel(), aTempDate );
1944 return;
1945 }
1946 }
1947 }
1948 else if ( rCEvt.GetCommand() == COMMAND_WHEEL )
1949 {
1950 const CommandWheelData* pData = rCEvt.GetWheelData();
1951 if ( pData->GetMode() == COMMAND_WHEEL_SCROLL )
1952 {
1953 long nNotchDelta = pData->GetNotchDelta();
1954 if ( nNotchDelta < 0 )
1955 {
1956 while ( nNotchDelta < 0 )
1957 {
1958 ImplScroll( TRUE );
1959 nNotchDelta++;
1960 }
1961 }
1962 else
1963 {
1964 while ( nNotchDelta > 0 )
1965 {
1966 ImplScroll( FALSE );
1967 nNotchDelta--;
1968 }
1969 }
1970
1971 return;
1972 }
1973 }
1974
1975 Control::Command( rCEvt );
1976 }
1977
1978 // -----------------------------------------------------------------------
1979
1980 void Calendar::StateChanged( StateChangedType nType )
1981 {
1982 Control::StateChanged( nType );
1983
1984 if ( nType == STATE_CHANGE_INITSHOW )
1985 ImplFormat();
1986 }
1987
1988 // -----------------------------------------------------------------------
1989
1990 void Calendar::DataChanged( const DataChangedEvent& rDCEvt )
1991 {
1992 Control::DataChanged( rDCEvt );
1993
1994 if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
1995 (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
1996 ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
1997 (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
1998 {
1999 ImplInitSettings();
2000 Invalidate();
2001 }
2002 }
2003
2004 // -----------------------------------------------------------------------
2005
2006 void Calendar::SelectionChanging()
2007 {
2008 maSelectionChangingHdl.Call( this );
2009 }
2010
2011 // -----------------------------------------------------------------------
2012
2013 void Calendar::DateRangeChanged()
2014 {
2015 maDateRangeChangedHdl.Call( this );
2016 }
2017
2018 // -----------------------------------------------------------------------
2019
2020 void Calendar::RequestDateInfo()
2021 {
2022 maRequestDateInfoHdl.Call( this );
2023 }
2024
2025 // -----------------------------------------------------------------------
2026
2027 void Calendar::DoubleClick()
2028 {
2029 maDoubleClickHdl.Call( this );
2030 }
2031
2032 // -----------------------------------------------------------------------
2033
2034 void Calendar::Select()
2035 {
2036 maSelectHdl.Call( this );
2037 }
2038
2039 // -----------------------------------------------------------------------
2040
2041 void Calendar::SelectDate( const Date& rDate, BOOL bSelect )
2042 {
2043 if ( !rDate.IsValid() )
2044 return;
2045
2046 Table* pOldSel;
2047
2048 if ( !mbInSelChange )
2049 pOldSel = new Table( *mpSelectTable );
2050 else
2051 pOldSel = NULL;
2052
2053 ImplCalendarSelectDate( mpSelectTable, rDate, bSelect );
2054
2055 if ( pOldSel )
2056 {
2057 ImplUpdateSelection( pOldSel );
2058 delete pOldSel;
2059 }
2060 }
2061
2062 // -----------------------------------------------------------------------
2063
2064 void Calendar::SelectDateRange( const Date& rStartDate, const Date& rEndDate,
2065 BOOL bSelect )
2066 {
2067 if ( !rStartDate.IsValid() || !rEndDate.IsValid() )
2068 return;
2069
2070 Table* pOldSel;
2071
2072 if ( !mbInSelChange )
2073 pOldSel = new Table( *mpSelectTable );
2074 else
2075 pOldSel = NULL;
2076
2077 ImplCalendarSelectDateRange( mpSelectTable, rStartDate, rEndDate, bSelect );
2078
2079 if ( pOldSel )
2080 {
2081 ImplUpdateSelection( pOldSel );
2082 delete pOldSel;
2083 }
2084 }
2085
2086 // -----------------------------------------------------------------------
2087
2088 void Calendar::SetNoSelection()
2089 {
2090 Table* pOldSel;
2091
2092 if ( !mbInSelChange )
2093 pOldSel = new Table( *mpSelectTable );
2094 else
2095 pOldSel = NULL;
2096
2097 ImplCalendarClearSelectDate( mpSelectTable );
2098
2099 if ( pOldSel )
2100 {
2101 ImplUpdateSelection( pOldSel );
2102 delete pOldSel;
2103 }
2104 }
2105
2106 // -----------------------------------------------------------------------
2107
2108 BOOL Calendar::IsDateSelected( const Date& rDate ) const
2109 {
2110 return mpSelectTable->IsKeyValid( rDate.GetDate() );
2111 }
2112
2113 // -----------------------------------------------------------------------
2114
2115 ULONG Calendar::GetSelectDateCount() const
2116 {
2117 return mpSelectTable->Count();
2118 }
2119
2120 // -----------------------------------------------------------------------
2121
2122 Date Calendar::GetSelectDate( ULONG nIndex ) const
2123 {
2124 if ( nIndex < mpSelectTable->Count() )
2125 return Date( mpSelectTable->GetObjectKey( nIndex ) );
2126 else
2127 {
2128 Date aDate( 0, 0, 0 );
2129 return aDate;
2130 }
2131 }
2132
2133 // -----------------------------------------------------------------------
2134
2135 void Calendar::SetCurDate( const Date& rNewDate )
2136 {
2137 if ( !rNewDate.IsValid() )
2138 return;
2139
2140 if ( maCurDate != rNewDate )
2141 {
2142 BOOL bUpdate = IsVisible() && IsUpdateMode();
2143 Date aOldDate = maCurDate;
2144 maCurDate = rNewDate;
2145 maAnchorDate = maCurDate;
2146
2147 if ( !(mnWinStyle & (WB_RANGESELECT | WB_MULTISELECT)) )
2148 {
2149 ImplCalendarSelectDate( mpSelectTable, aOldDate, FALSE );
2150 ImplCalendarSelectDate( mpSelectTable, maCurDate, TRUE );
2151 }
2152 else if ( !HasFocus() )
2153 bUpdate = FALSE;
2154
2155 // Aktuelles Datum noch in den sichtbaren Bereich verschieben
2156 if ( mbFormat || (maCurDate < GetFirstMonth()) )
2157 SetFirstDate( maCurDate );
2158 else if ( maCurDate > GetLastMonth() )
2159 {
2160 Date aTempDate = GetLastMonth();
2161 long nDateOff = maCurDate-aTempDate;
2162 if ( nDateOff < 365 )
2163 {
2164 Date aFirstDate = GetFirstMonth();
2165 aFirstDate += aFirstDate.GetDaysInMonth();
2166 aTempDate++;
2167 while ( nDateOff > aTempDate.GetDaysInMonth() )
2168 {
2169 aFirstDate += aFirstDate.GetDaysInMonth();
2170 long nDaysInMonth = aTempDate.GetDaysInMonth();
2171 aTempDate += nDaysInMonth;
2172 nDateOff -= nDaysInMonth;
2173 }
2174 SetFirstDate( aFirstDate );
2175 }
2176 else
2177 SetFirstDate( maCurDate );
2178 }
2179 else
2180 {
2181 if ( bUpdate )
2182 {
2183 HideFocus();
2184 ImplUpdateDate( aOldDate );
2185 ImplUpdateDate( maCurDate );
2186 }
2187 }
2188 }
2189 }
2190
2191 // -----------------------------------------------------------------------
2192
2193 void Calendar::SetFirstDate( const Date& rNewFirstDate )
2194 {
2195 if ( maFirstDate != rNewFirstDate )
2196 {
2197 maFirstDate = Date( 1, rNewFirstDate.GetMonth(), rNewFirstDate.GetYear() );
2198 mbDropPos = FALSE;
2199 ImplUpdate();
2200 }
2201 }
2202
2203 // -----------------------------------------------------------------------
2204
2205 Date Calendar::GetFirstMonth() const
2206 {
2207 if ( maFirstDate.GetDay() > 1 )
2208 {
2209 if ( maFirstDate.GetMonth() == 12 )
2210 return Date( 1, 1, maFirstDate.GetYear()+1 );
2211 else
2212 return Date( 1, maFirstDate.GetMonth()+1, maFirstDate.GetYear() );
2213 }
2214 else
2215 return maFirstDate;
2216 }
2217
2218 // -----------------------------------------------------------------------
2219
2220 Date Calendar::GetLastMonth() const
2221 {
2222 Date aDate = GetFirstMonth();
2223 USHORT nMonthCount = GetMonthCount();
2224 for ( USHORT i = 0; i < nMonthCount; i++ )
2225 aDate += aDate.GetDaysInMonth();
2226 aDate--;
2227 return aDate;
2228 }
2229
2230 // -----------------------------------------------------------------------
2231
2232 USHORT Calendar::GetMonthCount() const
2233 {
2234 if ( mbFormat )
2235 return 1;
2236 else
2237 return (USHORT)(mnMonthPerLine*mnLines);
2238 }
2239
2240 // -----------------------------------------------------------------------
2241
2242 BOOL Calendar::GetDropDate( Date& rDate ) const
2243 {
2244 if( mbDropPos )
2245 {
2246 rDate = maDropDate;
2247 return TRUE;
2248 }
2249 return FALSE;
2250 }
2251
2252 // -----------------------------------------------------------------------
2253
2254 BOOL Calendar::GetDate( const Point& rPos, Date& rDate ) const
2255 {
2256 Date aDate = maCurDate;
2257 USHORT nHitTest = ImplHitTest( rPos, aDate );
2258 if ( nHitTest & CALENDAR_HITTEST_DAY )
2259 {
2260 rDate = aDate;
2261 return TRUE;
2262 }
2263 else
2264 return FALSE;
2265 }
2266
2267 // -----------------------------------------------------------------------
2268
2269 Rectangle Calendar::GetDateRect( const Date& rDate ) const
2270 {
2271 Rectangle aRect;
2272
2273 if ( mbFormat || (rDate < maFirstDate) || (rDate > (maFirstDate+mnDayCount)) )
2274 return aRect;
2275
2276 long nX;
2277 long nY;
2278 ULONG nDaysOff;
2279 USHORT nDayIndex;
2280 Date aDate = GetFirstMonth();
2281
2282 if ( rDate < aDate )
2283 {
2284 aRect = GetDateRect( aDate );
2285 nDaysOff = aDate-rDate;
2286 nX = (long)(nDaysOff*mnDayWidth);
2287 aRect.Left() -= nX;
2288 aRect.Right() -= nX;
2289 return aRect;
2290 }
2291 else
2292 {
2293 Date aLastDate = GetLastMonth();
2294 if ( rDate > aLastDate )
2295 {
2296 USHORT nWeekDay = (USHORT)aLastDate.GetDayOfWeek();
2297 nWeekDay = (nWeekDay+(7-(USHORT)ImplGetWeekStart())) % 7;
2298 aLastDate -= nWeekDay;
2299 aRect = GetDateRect( aLastDate );
2300 nDaysOff = rDate-aLastDate;
2301 nDayIndex = 0;
2302 for ( USHORT i = 0; i <= nDaysOff; i++ )
2303 {
2304 if ( aLastDate == rDate )
2305 {
2306 aRect.Left() += nDayIndex*mnDayWidth;
2307 aRect.Right() = aRect.Left()+mnDayWidth;
2308 return aRect;
2309 }
2310 if ( nDayIndex == 6 )
2311 {
2312 nDayIndex = 0;
2313 aRect.Top() += mnDayHeight;
2314 aRect.Bottom() += mnDayHeight;
2315 }
2316 else
2317 nDayIndex++;
2318 aLastDate++;
2319 }
2320 }
2321 }
2322
2323 nY = 0;
2324 for ( long i = 0; i < mnLines; i++ )
2325 {
2326 nX = 0;
2327 for ( long j = 0; j < mnMonthPerLine; j++ )
2328 {
2329 USHORT nDaysInMonth = aDate.GetDaysInMonth();
2330
2331 // Monat gerufen
2332 if ( (aDate.GetMonth() == rDate.GetMonth()) &&
2333 (aDate.GetYear() == rDate.GetYear()) )
2334 {
2335 long nDayX = nX+mnDaysOffX;
2336 long nDayY = nY+mnDaysOffY;
2337 nDayIndex = (USHORT)aDate.GetDayOfWeek();
2338 nDayIndex = (nDayIndex+(7-(USHORT)ImplGetWeekStart())) % 7;
2339 for ( USHORT nDay = 1; nDay <= nDaysInMonth; nDay++ )
2340 {
2341 if ( nDay == rDate.GetDay() )
2342 {
2343 aRect.Left() = nDayX + (nDayIndex*mnDayWidth);
2344 aRect.Top() = nDayY;
2345 aRect.Right() = aRect.Left()+mnDayWidth;
2346 aRect.Bottom() = aRect.Top()+mnDayHeight;
2347 break;
2348 }
2349 if ( nDayIndex == 6 )
2350 {
2351 nDayIndex = 0;
2352 nDayY += mnDayHeight;
2353 }
2354 else
2355 nDayIndex++;
2356 }
2357 }
2358
2359 aDate += nDaysInMonth;
2360 nX += mnMonthWidth;
2361 }
2362
2363 nY += mnMonthHeight;
2364 }
2365
2366 return aRect;
2367 }
2368
2369 // -----------------------------------------------------------------------
2370
2371 void Calendar::SetStandardColor( const Color& rColor )
2372 {
2373 if ( mpStandardColor )
2374 *mpStandardColor = rColor;
2375 else
2376 mpStandardColor = new Color( rColor );
2377 ImplUpdate();
2378 }
2379
2380 // -----------------------------------------------------------------------
2381
2382 void Calendar::SetSaturdayColor( const Color& rColor )
2383 {
2384 if ( mpSaturdayColor )
2385 *mpSaturdayColor = rColor;
2386 else
2387 mpSaturdayColor = new Color( rColor );
2388 ImplUpdate();
2389 }
2390
2391 // -----------------------------------------------------------------------
2392
2393 void Calendar::SetSundayColor( const Color& rColor )
2394 {
2395 if ( mpSundayColor )
2396 *mpSundayColor = rColor;
2397 else
2398 mpSundayColor = new Color( rColor );
2399 ImplUpdate();
2400 }
2401
2402 // -----------------------------------------------------------------------
2403
2404 void Calendar::AddDateInfo( const Date& rDate, const String& rText,
2405 const Color* pTextColor, const Color* pFrameColor,
2406 USHORT nFlags )
2407 {
2408 if ( !mpDateTable )
2409 mpDateTable = new ImplDateTable( 256, 256 );
2410
2411 BOOL bChanged = FALSE;
2412 ULONG nKey = rDate.GetDate();
2413 ImplDateInfo* pDateInfo = mpDateTable->Get( nKey );
2414 if ( pDateInfo )
2415 pDateInfo->maText = rText;
2416 else
2417 {
2418 pDateInfo = new ImplDateInfo( rText );
2419 mpDateTable->Insert( nKey, pDateInfo );
2420 }
2421 if ( pTextColor )
2422 {
2423 if ( pDateInfo->mpTextColor )
2424 {
2425 if ( *(pDateInfo->mpTextColor) != *pTextColor )
2426 {
2427 *(pDateInfo->mpTextColor) = *pTextColor;
2428 bChanged = TRUE;
2429 }
2430 }
2431 else
2432 {
2433 pDateInfo->mpTextColor = new Color( *pTextColor );
2434 bChanged = TRUE;
2435 }
2436 }
2437 else
2438 {
2439 if ( pDateInfo->mpTextColor )
2440 {
2441 delete pDateInfo->mpTextColor;
2442 pDateInfo->mpTextColor = NULL;
2443 bChanged = TRUE;
2444 }
2445 }
2446 if ( pFrameColor )
2447 {
2448 if ( pDateInfo->mpFrameColor )
2449 {
2450 if ( *(pDateInfo->mpFrameColor) != *pFrameColor )
2451 {
2452 *(pDateInfo->mpFrameColor) = *pFrameColor;
2453 bChanged = TRUE;
2454 }
2455 }
2456 else
2457 {
2458 pDateInfo->mpFrameColor = new Color( *pFrameColor );
2459 bChanged = TRUE;
2460 }
2461 }
2462 else
2463 {
2464 if ( pDateInfo->mpFrameColor )
2465 {
2466 delete pDateInfo->mpFrameColor;
2467 pDateInfo->mpFrameColor = NULL;
2468 bChanged = TRUE;
2469 }
2470 }
2471 if ( pDateInfo->mnFlags != nFlags )
2472 {
2473 pDateInfo->mnFlags = nFlags;
2474 bChanged = TRUE;
2475 }
2476
2477 if ( bChanged )
2478 ImplUpdateDate( rDate );
2479 }
2480
2481 // -----------------------------------------------------------------------
2482
2483 void Calendar::RemoveDateInfo( const Date& rDate )
2484 {
2485 if ( mpDateTable )
2486 {
2487 ImplDateInfo* pDateInfo = mpDateTable->Remove( rDate.GetDate() );
2488 if ( pDateInfo )
2489 {
2490 delete pDateInfo;
2491 ImplUpdateDate( rDate );
2492 }
2493 }
2494 }
2495
2496 // -----------------------------------------------------------------------
2497
2498 void Calendar::ClearDateInfo()
2499 {
2500 if ( mpDateTable )
2501 {
2502 ImplDateInfo* pDateInfo = mpDateTable->First();
2503 while ( pDateInfo )
2504 {
2505 ULONG nKey = mpDateTable->GetCurKey();
2506 mpDateTable->Remove( nKey );
2507 Date aDate( nKey );
2508 ImplUpdateDate( aDate );
2509 delete pDateInfo;
2510 pDateInfo = mpDateTable->First();
2511 }
2512 delete mpDateTable;
2513 mpDateTable = NULL;
2514 }
2515 }
2516
2517 // -----------------------------------------------------------------------
2518
2519 XubString Calendar::GetDateInfoText( const Date& rDate )
2520 {
2521 XubString aRet;
2522 if ( mpDateTable )
2523 {
2524 ULONG nKey = rDate.GetDate();
2525 ImplDateInfo* pDateInfo = mpDateTable->Get( nKey );
2526 if ( pDateInfo )
2527 aRet = pDateInfo->maText;
2528 }
2529 return aRet;
2530 }
2531
2532 // -----------------------------------------------------------------------
2533
2534 BOOL Calendar::ShowDropPos( const Point& rPos, Date& rDate )
2535 {
2536 Date aTempDate = maCurDate;
2537 mnDragScrollHitTest = ImplHitTest( rPos, aTempDate );
2538
2539 if ( mnDragScrollHitTest )
2540 {
2541 if ( mnDragScrollHitTest & (CALENDAR_HITTEST_PREV | CALENDAR_HITTEST_NEXT) )
2542 {
2543 if ( !maDragScrollTimer.IsActive() )
2544 maDragScrollTimer.Start();
2545 }
2546 else
2547 {
2548 maDragScrollTimer.Stop();
2549 if ( mnDragScrollHitTest & CALENDAR_HITTEST_DAY )
2550 {
2551 if ( !mbDropPos || (aTempDate != maDropDate) )
2552 {
2553 if( mbDropPos )
2554 ImplInvertDropPos();
2555 maDropDate = aTempDate;
2556 mbDropPos = TRUE;
2557 ImplInvertDropPos();
2558 }
2559
2560 rDate = maDropDate;
2561 return TRUE;
2562 }
2563 }
2564 }
2565 else
2566 maDragScrollTimer.Stop();
2567
2568 HideDropPos();
2569 return FALSE;
2570 }
2571
2572 // -----------------------------------------------------------------------
2573
2574 void Calendar::HideDropPos()
2575 {
2576 if ( mbDropPos )
2577 {
2578 ImplInvertDropPos();
2579 mbDropPos = FALSE;
2580 }
2581 }
2582
2583 // -----------------------------------------------------------------------
2584
2585 void Calendar::StartSelection()
2586 {
2587 if ( mpOldSelectTable )
2588 delete mpOldSelectTable;
2589 maOldCurDate = maCurDate;
2590 mpOldSelectTable = new Table( *mpSelectTable );
2591
2592 mbSelection = TRUE;
2593 }
2594
2595 // -----------------------------------------------------------------------
2596
2597 void Calendar::EndSelection()
2598 {
2599 if ( mbDrag || mbSpinDown || mbSelection )
2600 {
2601 if ( !mbSelection )
2602 ReleaseMouse();
2603
2604 mbDrag = FALSE;
2605 mbSelection = FALSE;
2606 mbMultiSelection = FALSE;
2607 mbSpinDown = FALSE;
2608 mbPrevIn = FALSE;
2609 mbNextIn = FALSE;
2610 }
2611 }
2612
2613 // -----------------------------------------------------------------------
2614
2615 Size Calendar::CalcWindowSizePixel( long nCalcMonthPerLine,
2616 long nCalcLines ) const
2617 {
2618 XubString a99Text( XubString( RTL_CONSTASCII_USTRINGPARAM( "99" ) ) );
2619 Font aOldFont = GetFont();
2620
2621 // Wochenanzeige beruecksichtigen
2622 long nWeekWidth;
2623 if ( mnWinStyle & WB_WEEKNUMBER )
2624 {
2625 Font aTempFont = aOldFont;
2626 ImplGetWeekFont( aTempFont );
2627 ((Calendar*)this)->SetFont( aTempFont );
2628 nWeekWidth = GetTextWidth( a99Text )+WEEKNUMBER_OFFX;
2629 ((Calendar*)this)->SetFont( aOldFont );
2630 }
2631 else
2632 nWeekWidth = 0;
2633
2634 if ( mnWinStyle & WB_BOLDTEXT )
2635 {
2636 Font aFont = aOldFont;
2637 if ( aFont.GetWeight() < WEIGHT_BOLD )
2638 aFont.SetWeight( WEIGHT_BOLD );
2639 else
2640 aFont.SetWeight( WEIGHT_NORMAL );
2641 ((Calendar*)this)->SetFont( aFont );
2642 }
2643
2644 Size aSize;
2645 long n99TextWidth = GetTextWidth( a99Text );
2646 long nTextHeight = GetTextHeight();
2647
2648 if ( mnWinStyle & WB_BOLDTEXT )
2649 ((Calendar*)this)->SetFont( aOldFont );
2650
2651 aSize.Width() += ((n99TextWidth+DAY_OFFX)*7) + nWeekWidth;
2652 aSize.Width() += MONTH_BORDERX*2;
2653 aSize.Width() *= nCalcMonthPerLine;
2654
2655 aSize.Height() = nTextHeight + TITLE_OFFY + (TITLE_BORDERY*2);
2656 aSize.Height() += nTextHeight + WEEKDAY_OFFY;
2657 aSize.Height() += ((nTextHeight+DAY_OFFY)*6);
2658 aSize.Height() += MONTH_OFFY;
2659 aSize.Height() *= nCalcLines;
2660
2661 return aSize;
2662 }
2663
2664 // =======================================================================
2665
2666 #define CALFIELD_EXTRA_BUTTON_WIDTH 14
2667 #define CALFIELD_EXTRA_BUTTON_HEIGHT 8
2668 #define CALFIELD_SEP_X 6
2669 #define CALFIELD_BORDERLINE_X 5
2670 #define CALFIELD_BORDER_YTOP 4
2671 #define CALFIELD_BORDER_Y 5
2672
2673 // =======================================================================
2674
2675 class ImplCFieldFloatWin : public FloatingWindow
2676 {
2677 private:
2678 Calendar* mpCalendar;
2679 PushButton* mpTodayBtn;
2680 PushButton* mpNoneBtn;
2681 FixedLine* mpFixedLine;
2682
2683 public:
2684 ImplCFieldFloatWin( Window* pParent );
2685 ~ImplCFieldFloatWin();
2686
2687 void SetCalendar( Calendar* pCalendar )
2688 { mpCalendar = pCalendar; }
2689
2690 PushButton* EnableTodayBtn( BOOL bEnable );
2691 PushButton* EnableNoneBtn( BOOL bEnable );
2692 void ArrangeButtons();
2693
2694 long Notify( NotifyEvent& rNEvt );
2695 };
2696
2697 // -----------------------------------------------------------------------
2698
2699 ImplCFieldFloatWin::ImplCFieldFloatWin( Window* pParent ) :
2700 FloatingWindow( pParent, WB_BORDER | WB_SYSTEMWINDOW | WB_NOSHADOW )
2701 {
2702 mpCalendar = NULL;
2703 mpTodayBtn = NULL;
2704 mpNoneBtn = NULL;
2705 mpFixedLine = NULL;
2706 }
2707
2708 // -----------------------------------------------------------------------
2709
2710 ImplCFieldFloatWin::~ImplCFieldFloatWin()
2711 {
2712 delete mpTodayBtn;
2713 delete mpNoneBtn;
2714 delete mpFixedLine;
2715 }
2716
2717 // -----------------------------------------------------------------------
2718
2719 PushButton* ImplCFieldFloatWin::EnableTodayBtn( BOOL bEnable )
2720 {
2721 if ( bEnable )
2722 {
2723 if ( !mpTodayBtn )
2724 {
2725 mpTodayBtn = new PushButton( this, WB_NOPOINTERFOCUS );
2726 XubString aTodayText( SvtResId( STR_SVT_CALENDAR_TODAY ) );
2727 mpTodayBtn->SetText( aTodayText );
2728 Size aSize;
2729 aSize.Width() = mpTodayBtn->GetCtrlTextWidth( mpTodayBtn->GetText() );
2730 aSize.Height() = mpTodayBtn->GetTextHeight();
2731 aSize.Width() += CALFIELD_EXTRA_BUTTON_WIDTH;
2732 aSize.Height() += CALFIELD_EXTRA_BUTTON_HEIGHT;
2733 mpTodayBtn->SetSizePixel( aSize );
2734 mpTodayBtn->Show();
2735 }
2736 }
2737 else
2738 {
2739 if ( mpTodayBtn )
2740 {
2741 delete mpTodayBtn;
2742 mpTodayBtn = NULL;
2743 }
2744 }
2745
2746 return mpTodayBtn;
2747 }
2748
2749 // -----------------------------------------------------------------------
2750
2751 PushButton* ImplCFieldFloatWin::EnableNoneBtn( BOOL bEnable )
2752 {
2753 if ( bEnable )
2754 {
2755 if ( !mpNoneBtn )
2756 {
2757 mpNoneBtn = new PushButton( this, WB_NOPOINTERFOCUS );
2758 XubString aNoneText( SvtResId( STR_SVT_CALENDAR_NONE ) );
2759 mpNoneBtn->SetText( aNoneText );
2760 Size aSize;
2761 aSize.Width() = mpNoneBtn->GetCtrlTextWidth( mpNoneBtn->GetText() );
2762 aSize.Height() = mpNoneBtn->GetTextHeight();
2763 aSize.Width() += CALFIELD_EXTRA_BUTTON_WIDTH;
2764 aSize.Height() += CALFIELD_EXTRA_BUTTON_HEIGHT;
2765 mpNoneBtn->SetSizePixel( aSize );
2766 mpNoneBtn->Show();
2767 }
2768 }
2769 else
2770 {
2771 if ( mpNoneBtn )
2772 {
2773 delete mpNoneBtn;
2774 mpNoneBtn = NULL;
2775 }
2776 }
2777
2778 return mpNoneBtn;
2779 }
2780
2781 // -----------------------------------------------------------------------
2782
2783 void ImplCFieldFloatWin::ArrangeButtons()
2784 {
2785 long nBtnHeight = 0;
2786 long nBtnWidth = 0;
2787 Size aOutSize = GetOutputSizePixel();
2788 if ( mpTodayBtn && mpNoneBtn )
2789 {
2790 Size aTodayBtnSize = mpTodayBtn->GetSizePixel();
2791 Size aNoneBtnSize = mpNoneBtn->GetSizePixel();
2792 if ( aTodayBtnSize.Width() < aNoneBtnSize.Width() )
2793 aTodayBtnSize.Width() = aNoneBtnSize.Width();
2794 else
2795 aNoneBtnSize.Width() = aTodayBtnSize.Width();
2796 if ( aTodayBtnSize.Height() < aNoneBtnSize.Height() )
2797 aTodayBtnSize.Height() = aNoneBtnSize.Height();
2798 else
2799 aNoneBtnSize.Height() = aTodayBtnSize.Height();
2800
2801 nBtnWidth = aTodayBtnSize.Width() + aNoneBtnSize.Width() + CALFIELD_SEP_X;
2802 nBtnHeight = aTodayBtnSize.Height();
2803 long nX = (aOutSize.Width()-nBtnWidth)/2;
2804 long nY = aOutSize.Height()+CALFIELD_BORDER_Y+CALFIELD_BORDER_YTOP;
2805 mpTodayBtn->SetPosSizePixel( Point( nX, nY ), aTodayBtnSize );
2806 nX += aTodayBtnSize.Width() + CALFIELD_SEP_X;
2807 mpNoneBtn->SetPosSizePixel( Point( nX, nY ), aNoneBtnSize );
2808 }
2809 else if ( mpTodayBtn )
2810 {
2811 Size aTodayBtnSize = mpTodayBtn->GetSizePixel();
2812 nBtnWidth = aTodayBtnSize.Width();
2813 nBtnHeight = aTodayBtnSize.Height();
2814 mpTodayBtn->SetPosPixel( Point( (aOutSize.Width()-nBtnWidth)/2, aOutSize.Height()+CALFIELD_BORDER_Y+CALFIELD_BORDER_YTOP ) );
2815 }
2816 else if ( mpNoneBtn )
2817 {
2818 Size aNoneBtnSize = mpNoneBtn->GetSizePixel();
2819 nBtnWidth = aNoneBtnSize.Width();
2820 nBtnHeight = aNoneBtnSize.Height();
2821 mpNoneBtn->SetPosPixel( Point( (aOutSize.Width()-nBtnWidth)/2, aOutSize.Height()+CALFIELD_BORDER_Y+CALFIELD_BORDER_YTOP ) );
2822 }
2823
2824 if ( nBtnHeight )
2825 {
2826 if ( !mpFixedLine )
2827 {
2828 mpFixedLine = new FixedLine( this );
2829 mpFixedLine->Show();
2830 }
2831 long nLineWidth = aOutSize.Width()-(CALFIELD_BORDERLINE_X*2);
2832 mpFixedLine->SetPosSizePixel( (aOutSize.Width()-nLineWidth)/2, aOutSize.Height()+((CALFIELD_BORDER_YTOP-2)/2),
2833 nLineWidth, 2, WINDOW_POSSIZE_POSSIZE );
2834 aOutSize.Height() += nBtnHeight + (CALFIELD_BORDER_Y*2) + CALFIELD_BORDER_YTOP;
2835 SetOutputSizePixel( aOutSize );
2836 }
2837 else
2838 {
2839 if ( mpFixedLine )
2840 {
2841 delete mpFixedLine;
2842 mpFixedLine = NULL;
2843 }
2844 }
2845 }
2846
2847 // -----------------------------------------------------------------------
2848
2849 long ImplCFieldFloatWin::Notify( NotifyEvent& rNEvt )
2850 {
2851 if ( rNEvt.GetType() == EVENT_KEYINPUT )
2852 {
2853 const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
2854 if ( pKEvt->GetKeyCode().GetCode() == KEY_RETURN )
2855 mpCalendar->Select();
2856 }
2857
2858 return FloatingWindow::Notify( rNEvt );
2859 }
2860
2861 // =======================================================================
2862
2863 CalendarField::CalendarField( Window* pParent, WinBits nWinStyle ) :
2864 DateField( pParent, nWinStyle ),
2865 maDefaultDate( 0, 0, 0 )
2866 {
2867 mpFloatWin = NULL;
2868 mpCalendar = NULL;
2869 mnCalendarStyle = 0;
2870 mbToday = FALSE;
2871 mbNone = FALSE;
2872 }
2873
2874 // -----------------------------------------------------------------------
2875
2876 CalendarField::CalendarField( Window* pParent, const ResId& rResId ) :
2877 DateField( pParent, rResId ),
2878 maDefaultDate( 0, 0, 0 )
2879 {
2880 mpFloatWin = NULL;
2881 mpCalendar = NULL;
2882 mnCalendarStyle = 0;
2883 mbToday = FALSE;
2884 mbNone = FALSE;
2885 }
2886
2887 // -----------------------------------------------------------------------
2888
2889 CalendarField::~CalendarField()
2890 {
2891 if ( mpFloatWin )
2892 {
2893 delete mpCalendar;
2894 delete mpFloatWin;
2895 }
2896 }
2897
2898 // -----------------------------------------------------------------------
2899
2900 IMPL_LINK( CalendarField, ImplSelectHdl, Calendar*, pCalendar )
2901 {
2902 if ( !pCalendar->IsTravelSelect() )
2903 {
2904 mpFloatWin->EndPopupMode();
2905 EndDropDown();
2906 GrabFocus();
2907 Date aNewDate = mpCalendar->GetSelectDate( 0 );
2908 if ( IsEmptyDate() || ( aNewDate != GetDate() ) )
2909 {
2910 SetDate( aNewDate );
2911 SetModifyFlag();
2912 Modify();
2913 }
2914 Select();
2915 }
2916 return 0;
2917 }
2918
2919 // -----------------------------------------------------------------------
2920
2921 IMPL_LINK( CalendarField, ImplClickHdl, PushButton*, pBtn )
2922 {
2923 mpFloatWin->EndPopupMode();
2924 EndDropDown();
2925 GrabFocus();
2926
2927 if ( pBtn == mpTodayBtn )
2928 {
2929 Date aToday;
2930 if ( (aToday != GetDate()) || IsEmptyDate() )
2931 {
2932 SetDate( aToday );
2933 SetModifyFlag();
2934 Modify();
2935 }
2936 }
2937 else if ( pBtn == mpNoneBtn )
2938 {
2939 if ( !IsEmptyDate() )
2940 {
2941 SetEmptyDate();
2942 SetModifyFlag();
2943 Modify();
2944 }
2945 }
2946 Select();
2947
2948 return 0;
2949 }
2950
2951 // -----------------------------------------------------------------------
2952
2953 IMPL_LINK( CalendarField, ImplPopupModeEndHdl, FloatingWindow*, EMPTYARG )
2954 {
2955 EndDropDown();
2956 GrabFocus();
2957 mpCalendar->EndSelection();
2958 return 0;
2959 }
2960
2961 // -----------------------------------------------------------------------
2962
2963 void CalendarField::Select()
2964 {
2965 maSelectHdl.Call( this );
2966 }
2967
2968 // -----------------------------------------------------------------------
2969
2970 BOOL CalendarField::ShowDropDown( BOOL bShow )
2971 {
2972 if ( bShow )
2973 {
2974 Calendar* pCalendar = GetCalendar();
2975
2976 Date aDate = GetDate();
2977 if ( IsEmptyDate() || !aDate.IsValid() )
2978 {
2979 if ( maDefaultDate.IsValid() )
2980 aDate = maDefaultDate;
2981 else
2982 aDate = Date();
2983 }
2984 if ( pCalendar->GetStyle() & (WB_RANGESELECT | WB_MULTISELECT) )
2985 {
2986 pCalendar->SetNoSelection();
2987 pCalendar->SelectDate( aDate );
2988 }
2989 pCalendar->SetCurDate( aDate );
2990 Point aPos( GetParent()->OutputToScreenPixel( GetPosPixel() ) );
2991 Rectangle aRect( aPos, GetSizePixel() );
2992 aRect.Bottom() -= 1;
2993 mpCalendar->SetOutputSizePixel( mpCalendar->CalcWindowSizePixel() );
2994 mpFloatWin->SetOutputSizePixel( mpCalendar->GetSizePixel() );
2995 mpFloatWin->SetCalendar( mpCalendar );
2996 mpTodayBtn = mpFloatWin->EnableTodayBtn( mbToday );
2997 mpNoneBtn = mpFloatWin->EnableNoneBtn( mbNone );
2998 if ( mpTodayBtn )
2999 mpTodayBtn->SetClickHdl( LINK( this, CalendarField, ImplClickHdl ) );
3000 if ( mpNoneBtn )
3001 mpNoneBtn->SetClickHdl( LINK( this, CalendarField, ImplClickHdl ) );
3002 mpFloatWin->ArrangeButtons();
3003 mpCalendar->EnableCallEverySelect();
3004 mpCalendar->StartSelection();
3005 mpCalendar->GrabFocus();
3006 mpCalendar->Show();
3007 mpFloatWin->StartPopupMode( aRect, FLOATWIN_POPUPMODE_NOFOCUSCLOSE|FLOATWIN_POPUPMODE_DOWN );
3008 }
3009 else
3010 {
3011 mpFloatWin->EndPopupMode( FLOATWIN_POPUPMODEEND_CANCEL );
3012 mpCalendar->EndSelection();
3013 EndDropDown();
3014 }
3015 return TRUE;
3016 }
3017
3018 // -----------------------------------------------------------------------
3019
3020 Calendar* CalendarField::CreateCalendar( Window* pParent )
3021 {
3022 return new Calendar( pParent, mnCalendarStyle | WB_TABSTOP );
3023 }
3024
3025 // -----------------------------------------------------------------------
3026
3027 Calendar* CalendarField::GetCalendar()
3028 {
3029 if ( !mpFloatWin )
3030 {
3031 mpFloatWin = new ImplCFieldFloatWin( this );
3032 mpFloatWin->SetPopupModeEndHdl( LINK( this, CalendarField, ImplPopupModeEndHdl ) );
3033 mpCalendar = CreateCalendar( mpFloatWin );
3034 mpCalendar->SetPosPixel( Point() );
3035 mpCalendar->SetSelectHdl( LINK( this, CalendarField, ImplSelectHdl ) );
3036 }
3037
3038 return mpCalendar;
3039 }
3040
3041 // -----------------------------------------------------------------------
3042
3043 void CalendarField::StateChanged( StateChangedType nStateChange )
3044 {
3045 DateField::StateChanged( nStateChange );
3046
3047 if ( ( nStateChange == STATE_CHANGE_STYLE ) && GetSubEdit() )
3048 {
3049 WinBits nAllAlignmentBits = ( WB_LEFT | WB_CENTER | WB_RIGHT | WB_TOP | WB_VCENTER | WB_BOTTOM );
3050 WinBits nMyAlignment = GetStyle() & nAllAlignmentBits;
3051 GetSubEdit()->SetStyle( ( GetSubEdit()->GetStyle() & ~nAllAlignmentBits ) | nMyAlignment );
3052 }
3053 }
3054
vba interoperability for OOo