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