?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / vcl / source / control / field2.cxx
blobb69a1b910128ac5fda61616402bad74566548cbe
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: field2.cxx,v $
10 * $Revision: 1.27 $
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_vcl.hxx"
33 #include <tools/debug.hxx>
34
35 #ifndef _SV_RC_H
36 #include <tools/rc.h>
37 #endif
38 #include <vcl/svdata.hxx>
39 #ifndef _SV_EVENT_HXX
40 #include <vcl/field.hxx>
41 #endif
42 #include <vcl/svapp.hxx>
43 #include <vcl/sound.hxx>
44 #include <vcl/event.hxx>
45 #include <vcl/field.hxx>
46 #include <i18npool/mslangid.hxx>
47
48 #include <vcl/unohelp.hxx>
49
50 #include <com/sun/star/lang/Locale.hpp>
51 #include <com/sun/star/i18n/XCharacterClassification.hpp>
52 #include <com/sun/star/i18n/KCharacterType.hpp>
53
54
55 #include <unotools/localedatawrapper.hxx>
56 #include <unotools/calendarwrapper.hxx>
57 #include <unotools/charclass.hxx>
58
59 using namespace ::com::sun::star;
60
61 // =======================================================================
62
63 #define EDITMASK_LITERAL 'L'
64 #define EDITMASK_ALPHA 'a'
65 #define EDITMASK_UPPERALPHA 'A'
66 #define EDITMASK_ALPHANUM 'c'
67 #define EDITMASK_UPPERALPHANUM 'C'
68 #define EDITMASK_NUM 'N'
69 #define EDITMASK_NUMSPACE 'n'
70 #define EDITMASK_ALLCHAR 'x'
71 #define EDITMASK_UPPERALLCHAR 'X'
72
73 uno::Reference< i18n::XCharacterClassification > ImplGetCharClass()
74 {
75 static uno::Reference< i18n::XCharacterClassification > xCharClass;
76 if ( !xCharClass.is() )
77 xCharClass = vcl::unohelper::CreateCharacterClassification();
78
79 return xCharClass;
80 }
81
82 // -----------------------------------------------------------------------
83
84 static sal_Unicode* ImplAddString( sal_Unicode* pBuf, const String& rStr )
85 {
86 if ( rStr.Len() == 1 )
87 *pBuf++ = rStr.GetChar(0);
88 else if ( rStr.Len() == 0 )
89 ;
90 else
91 {
92 memcpy( pBuf, rStr.GetBuffer(), rStr.Len() * sizeof(sal_Unicode) );
93 pBuf += rStr.Len();
94 }
95 return pBuf;
96 }
97
98 // -----------------------------------------------------------------------
99
100 static sal_Unicode* ImplAddNum( sal_Unicode* pBuf, ULONG nNumber, int nMinLen )
101 {
102 // fill temp buffer with digits
103 sal_Unicode aTempBuf[30];
104 sal_Unicode* pTempBuf = aTempBuf;
105 do
106 {
107 *pTempBuf = (sal_Unicode)(nNumber % 10) + '0';
108 pTempBuf++;
109 nNumber /= 10;
110 if ( nMinLen )
111 nMinLen--;
112 }
113 while ( nNumber );
114
115 // fill with zeros up to the minimal length
116 while ( nMinLen > 0 )
117 {
118 *pBuf = '0';
119 pBuf++;
120 nMinLen--;
121 }
122
123 // copy temp buffer to real buffer
124 do
125 {
126 pTempBuf--;
127 *pBuf = *pTempBuf;
128 pBuf++;
129 }
130 while ( pTempBuf != aTempBuf );
131
132 return pBuf;
133 }
134
135 // -----------------------------------------------------------------------
136
137 static USHORT ImplGetNum( const sal_Unicode*& rpBuf, BOOL& rbError )
138 {
139 if ( !*rpBuf )
140 {
141 rbError = TRUE;
142 return 0;
143 }
144
145 USHORT nNumber = 0;
146 while( ( *rpBuf >= '0' ) && ( *rpBuf <= '9' ) )
147 {
148 nNumber *= 10;
149 nNumber += *rpBuf - '0';
150 rpBuf++;
151 }
152
153 return nNumber;
154 }
155
156 // -----------------------------------------------------------------------
157
158 static void ImplSkipDelimiters( const sal_Unicode*& rpBuf )
159 {
160 while( ( *rpBuf == ',' ) || ( *rpBuf == '.' ) || ( *rpBuf == ';' ) ||
161 ( *rpBuf == ':' ) || ( *rpBuf == '-' ) || ( *rpBuf == '/' ) )
162 {
163 rpBuf++;
164 }
165 }
166
167 // -----------------------------------------------------------------------
168
169 static int ImplIsPatternChar( xub_Unicode cChar, sal_Char cEditMask )
170 {
171 sal_Int32 nType = 0;
172
173 try
174 {
175 String aCharStr( cChar );
176 nType = ImplGetCharClass()->getStringType( aCharStr, 0, aCharStr.Len(), Application::GetSettings().GetLocale() );
177 }
178 catch ( ::com::sun::star::uno::Exception& )
179 {
180 DBG_ERRORFILE( "ImplIsPatternChar: Exception caught!" );
181 return FALSE;
182 }
183
184 if ( (cEditMask == EDITMASK_ALPHA) || (cEditMask == EDITMASK_UPPERALPHA) )
185 {
186 if( !CharClass::isLetterType( nType ) )
187 return FALSE;
188 }
189 else if ( cEditMask == EDITMASK_NUM )
190 {
191 if( !CharClass::isNumericType( nType ) )
192 return FALSE;
193 }
194 else if ( (cEditMask == EDITMASK_ALPHANUM) || (cEditMask == EDITMASK_UPPERALPHANUM) )
195 {
196 if( !CharClass::isLetterNumericType( nType ) )
197 return FALSE;
198 }
199 else if ( (cEditMask == EDITMASK_ALLCHAR) || (cEditMask == EDITMASK_UPPERALLCHAR) )
200 {
201 if ( cChar < 32 )
202 return FALSE;
203 }
204 else if ( cEditMask == EDITMASK_NUMSPACE )
205 {
206 if ( !CharClass::isNumericType( nType ) && ( cChar != ' ' ) )
207 return FALSE;
208 }
209 else
210 return FALSE;
211
212 return TRUE;
213 }
214
215 // -----------------------------------------------------------------------
216
217 static xub_Unicode ImplPatternChar( xub_Unicode cChar, sal_Char cEditMask )
218 {
219 if ( ImplIsPatternChar( cChar, cEditMask ) )
220 {
221 if ( (cEditMask == EDITMASK_UPPERALPHA) ||
222 (cEditMask == EDITMASK_UPPERALPHANUM) ||
223 ( cEditMask == EDITMASK_UPPERALLCHAR ) )
224 {
225 cChar = ImplGetCharClass()->toUpper( String(cChar),0,1,Application::GetSettings().GetLocale() )[0];
226 }
227 return cChar;
228 }
229 else
230 return 0;
231 }
232
233 // -----------------------------------------------------------------------
234
235 static int ImplKommaPointCharEqual( xub_Unicode c1, xub_Unicode c2 )
236 {
237 if ( c1 == c2 )
238 return TRUE;
239 else if ( ((c1 == '.') || (c1 == ',')) &&
240 ((c2 == '.') || (c2 == ',')) )
241 return TRUE;
242 else
243 return FALSE;
244 }
245
246 // -----------------------------------------------------------------------
247
248 static XubString ImplPatternReformat( const XubString& rStr,
249 const ByteString& rEditMask,
250 const XubString& rLiteralMask,
251 USHORT nFormatFlags )
252 {
253 if ( !rEditMask.Len() )
254 return rStr;
255
256 XubString aStr = rStr;
257 XubString aOutStr = rLiteralMask;
258 xub_Unicode cTempChar;
259 xub_Unicode cChar;
260 xub_Unicode cLiteral;
261 sal_Char cMask;
262 xub_StrLen nStrIndex = 0;
263 xub_StrLen i = 0;
264 xub_StrLen n;
265
266 while ( i < rEditMask.Len() )
267 {
268 if ( nStrIndex >= aStr.Len() )
269 break;
270
271 cChar = aStr.GetChar(nStrIndex);
272 cLiteral = rLiteralMask.GetChar(i);
273 cMask = rEditMask.GetChar(i);
274
275 // Aktuelle Position ein Literal
276 if ( cMask == EDITMASK_LITERAL )
277 {
278 // Wenn es das Literal-Zeichen ist, uebernehmen, ansonsten
279 // ignorieren, da es das naechste gueltige Zeichen vom String
280 // sein kann
281 if ( ImplKommaPointCharEqual( cChar, cLiteral ) )
282 nStrIndex++;
283 else
284 {
285 // Ansonsten testen wir, ob es ein ungueltiges Zeichen ist.
286 // Dies ist dann der Fall, wenn es nicht in das Muster
287 // des naechsten nicht Literal-Zeichens passt
288 n = i+1;
289 while ( n < rEditMask.Len() )
290 {
291 if ( rEditMask.GetChar(n) != EDITMASK_LITERAL )
292 {
293 if ( !ImplIsPatternChar( cChar, rEditMask.GetChar(n) ) )
294 nStrIndex++;
295 break;
296 }
297
298 n++;
299 }
300 }
301 }
302 else
303 {
304 // Gueltiges Zeichen an der Stelle
305 cTempChar = ImplPatternChar( cChar, cMask );
306 if ( cTempChar )
307 {
308 // dann Zeichen uebernehmen
309 aOutStr.SetChar( i, cTempChar );
310 nStrIndex++;
311 }
312 else
313 {
314 // Wenn es das Literalzeichen ist, uebernehmen
315 if ( cLiteral == cChar )
316 nStrIndex++;
317 else
318 {
319 // Wenn das ungueltige Zeichen das naechste Literalzeichen
320 // sein kann, dann springen wir bis dahin vor, ansonten
321 // das Zeichen ignorieren
322 // Nur machen, wenn leere Literale erlaubt sind
323 if ( nFormatFlags & PATTERN_FORMAT_EMPTYLITERALS )
324 {
325 n = i;
326 while ( n < rEditMask.Len() )
327 {
328 if ( rEditMask.GetChar( n ) == EDITMASK_LITERAL )
329 {
330 if ( ImplKommaPointCharEqual( cChar, rLiteralMask.GetChar( n ) ) )
331 i = n+1;
332
333 break;
334 }
335
336 n++;
337 }
338 }
339
340 nStrIndex++;
341 continue;
342 }
343 }
344 }
345
346 i++;
347 }
348
349 return aOutStr;
350 }
351
352 // -----------------------------------------------------------------------
353
354 static void ImplPatternMaxPos( const XubString rStr, const ByteString& rEditMask,
355 USHORT nFormatFlags, BOOL bSameMask,
356 USHORT nCursorPos, USHORT& rPos )
357 {
358
359 // Letzte Position darf nicht groesser als der enthaltene String sein
360 xub_StrLen nMaxPos = rStr.Len();
361
362 // Wenn keine leeren Literale erlaubt sind, auch Leerzeichen
363 // am Ende ignorieren
364 if ( bSameMask && !(nFormatFlags & PATTERN_FORMAT_EMPTYLITERALS) )
365 {
366 while ( nMaxPos )
367 {
368 if ( (rEditMask.GetChar(nMaxPos-1) != EDITMASK_LITERAL) &&
369 (rStr.GetChar(nMaxPos-1) != ' ') )
370 break;
371 nMaxPos--;
372 }
373
374 // Wenn wir vor einem Literal stehen, dann solange weitersuchen,
375 // bis erste Stelle nach Literal
376 xub_StrLen nTempPos = nMaxPos;
377 while ( nTempPos < rEditMask.Len() )
378 {
379 if ( rEditMask.GetChar(nTempPos) != EDITMASK_LITERAL )
380 {
381 nMaxPos = nTempPos;
382 break;
383 }
384 nTempPos++;
385 }
386 }
387
388 if ( rPos > nMaxPos )
389 rPos = nMaxPos;
390 // Zeichen sollte nicht nach links wandern
391 if ( rPos < nCursorPos )
392 rPos = nCursorPos;
393 }
394
395 // -----------------------------------------------------------------------
396
397 static void ImplPatternProcessStrictModify( Edit* pEdit,
398 const ByteString& rEditMask,
399 const XubString& rLiteralMask,
400 USHORT nFormatFlags, BOOL bSameMask )
401 {
402 XubString aText = pEdit->GetText();
403
404 // Leerzeichen am Anfang entfernen
405 if ( bSameMask && !(nFormatFlags & PATTERN_FORMAT_EMPTYLITERALS) )
406 {
407 xub_StrLen i = 0;
408 xub_StrLen nMaxLen = aText.Len();
409 while ( i < nMaxLen )
410 {
411 if ( (rEditMask.GetChar( i ) != EDITMASK_LITERAL) &&
412 (aText.GetChar( i ) != ' ') )
413 break;
414
415 i++;
416 }
417 // Alle Literalzeichen beibehalten
418 while ( i && (rEditMask.GetChar( i ) == EDITMASK_LITERAL) )
419 i--;
420 aText.Erase( 0, i );
421 }
422
423 XubString aNewText = ImplPatternReformat( aText, rEditMask, rLiteralMask, nFormatFlags );
424 if ( aNewText != aText )
425 {
426 // Selection so anpassen, das diese wenn sie vorher am Ende
427 // stand, immer noch am Ende steht
428 Selection aSel = pEdit->GetSelection();
429 ULONG nMaxSel = Max( aSel.Min(), aSel.Max() );
430 if ( nMaxSel >= aText.Len() )
431 {
432 xub_StrLen nMaxPos = aNewText.Len();
433 ImplPatternMaxPos( aNewText, rEditMask, nFormatFlags, bSameMask, (xub_StrLen)nMaxSel, nMaxPos );
434 if ( aSel.Min() == aSel.Max() )
435 {
436 aSel.Min() = nMaxPos;
437 aSel.Max() = aSel.Min();
438 }
439 else if ( aSel.Min() > aSel.Max() )
440 aSel.Min() = nMaxPos;
441 else
442 aSel.Max() = nMaxPos;
443 }
444 pEdit->SetText( aNewText, aSel );
445 }
446 }
447
448 // -----------------------------------------------------------------------
449
450 static xub_StrLen ImplPatternLeftPos( const ByteString& rEditMask, xub_StrLen nCursorPos )
451 {
452 // Vorheriges Zeichen suchen, was kein Literal ist
453 xub_StrLen nNewPos = nCursorPos;
454 xub_StrLen nTempPos = nNewPos;
455 while ( nTempPos )
456 {
457 if ( rEditMask.GetChar(nTempPos-1) != EDITMASK_LITERAL )
458 {
459 nNewPos = nTempPos-1;
460 break;
461 }
462 nTempPos--;
463 }
464 return nNewPos;
465 }
466
467 // -----------------------------------------------------------------------
468
469 static xub_StrLen ImplPatternRightPos( const XubString& rStr, const ByteString& rEditMask,
470 USHORT nFormatFlags, BOOL bSameMask,
471 xub_StrLen nCursorPos )
472 {
473 // Naechstes Zeichen suchen, was kein Literal ist
474 xub_StrLen nNewPos = nCursorPos;
475 xub_StrLen nTempPos = nNewPos;
476 while ( nTempPos < rEditMask.Len() )
477 {
478 if ( rEditMask.GetChar(nTempPos+1) != EDITMASK_LITERAL )
479 {
480 nNewPos = nTempPos+1;
481 break;
482 }
483 nTempPos++;
484 }
485 ImplPatternMaxPos( rStr, rEditMask, nFormatFlags, bSameMask, nCursorPos, nNewPos );
486 return nNewPos;
487 }
488
489 // -----------------------------------------------------------------------
490
491 static BOOL ImplPatternProcessKeyInput( Edit* pEdit, const KeyEvent& rKEvt,
492 const ByteString& rEditMask,
493 const XubString& rLiteralMask,
494 BOOL bStrictFormat,
495 USHORT nFormatFlags,
496 BOOL bSameMask,
497 BOOL& rbInKeyInput )
498 {
499 if ( !rEditMask.Len() || !bStrictFormat )
500 return FALSE;
501
502 Selection aOldSel = pEdit->GetSelection();
503 KeyCode aCode = rKEvt.GetKeyCode();
504 xub_Unicode cChar = rKEvt.GetCharCode();
505 USHORT nKeyCode = aCode.GetCode();
506 BOOL bShift = aCode.IsShift();
507 xub_StrLen nCursorPos = (xub_StrLen)aOldSel.Max();
508 xub_StrLen nNewPos;
509 xub_StrLen nTempPos;
510
511 if ( nKeyCode && !aCode.IsMod1() && !aCode.IsMod2() )
512 {
513 if ( nKeyCode == KEY_LEFT )
514 {
515 Selection aSel( ImplPatternLeftPos( rEditMask, nCursorPos ) );
516 if ( bShift )
517 aSel.Min() = aOldSel.Min();
518 pEdit->SetSelection( aSel );
519 return TRUE;
520 }
521 else if ( nKeyCode == KEY_RIGHT )
522 {
523 // Hier nehmen wir Selectionsanfang als minimum, da falls durch
524 // Focus alles selektiert ist, ist eine kleine Position schon
525 // erlaubt.
526 Selection aSel( aOldSel );
527 aSel.Justify();
528 nCursorPos = (xub_StrLen)aSel.Min();
529 aSel.Max() = ImplPatternRightPos( pEdit->GetText(), rEditMask, nFormatFlags, bSameMask, nCursorPos );
530 if ( bShift )
531 aSel.Min() = aOldSel.Min();
532 else
533 aSel.Min() = aSel.Max();
534 pEdit->SetSelection( aSel );
535 return TRUE;
536 }
537 else if ( nKeyCode == KEY_HOME )
538 {
539 // Home ist Position des ersten nicht literalen Zeichens
540 nNewPos = 0;
541 while ( (nNewPos < rEditMask.Len()) &&
542 (rEditMask.GetChar(nNewPos) == EDITMASK_LITERAL) )
543 nNewPos++;
544 // Home sollte nicht nach rechts wandern
545 if ( nCursorPos < nNewPos )
546 nNewPos = nCursorPos;
547 Selection aSel( nNewPos );
548 if ( bShift )
549 aSel.Min() = aOldSel.Min();
550 pEdit->SetSelection( aSel );
551 return TRUE;
552 }
553 else if ( nKeyCode == KEY_END )
554 {
555 // End ist die Position des letzten nicht literalen Zeichens
556 nNewPos = rEditMask.Len();
557 while ( nNewPos &&
558 (rEditMask.GetChar(nNewPos-1) == EDITMASK_LITERAL) )
559 nNewPos--;
560 // Hier nehmen wir Selectionsanfang als minimum, da falls durch
561 // Focus alles selektiert ist, ist eine kleine Position schon
562 // erlaubt.
563 Selection aSel( aOldSel );
564 aSel.Justify();
565 nCursorPos = (xub_StrLen)aSel.Min();
566 ImplPatternMaxPos( pEdit->GetText(), rEditMask, nFormatFlags, bSameMask, nCursorPos, nNewPos );
567 aSel.Max() = nNewPos;
568 if ( bShift )
569 aSel.Min() = aOldSel.Min();
570 else
571 aSel.Min() = aSel.Max();
572 pEdit->SetSelection( aSel );
573 return TRUE;
574 }
575 else if ( (nKeyCode == KEY_BACKSPACE) || (nKeyCode == KEY_DELETE) )
576 {
577 XubString aStr( pEdit->GetText() );
578 XubString aOldStr = aStr;
579 Selection aSel = aOldSel;
580
581 aSel.Justify();
582 nNewPos = (xub_StrLen)aSel.Min();
583
584 // Wenn Selection, dann diese Loeschen
585 if ( aSel.Len() )
586 {
587 if ( bSameMask )
588 aStr.Erase( (xub_StrLen)aSel.Min(), (xub_StrLen)aSel.Len() );
589 else
590 {
591 XubString aRep = rLiteralMask.Copy( (xub_StrLen)aSel.Min(), (xub_StrLen)aSel.Len() );
592 aStr.Replace( (xub_StrLen)aSel.Min(), aRep.Len(), aRep );
593 }
594 }
595 else
596 {
597 if ( nKeyCode == KEY_BACKSPACE )
598 {
599 nTempPos = nNewPos;
600 nNewPos = ImplPatternLeftPos( rEditMask, nTempPos );
601 }
602 else
603 nTempPos = ImplPatternRightPos( aStr, rEditMask, nFormatFlags, bSameMask, nNewPos );
604
605 if ( nNewPos != nTempPos )
606 {
607 if ( bSameMask )
608 {
609 if ( rEditMask.GetChar( nNewPos ) != EDITMASK_LITERAL )
610 aStr.Erase( nNewPos, 1 );
611 }
612 else
613 {
614 XubString aTempStr = rLiteralMask.Copy( nNewPos, 1 );
615 aStr.Replace( nNewPos, aTempStr.Len(), aTempStr );
616 }
617 }
618 }
619
620 if ( aOldStr != aStr )
621 {
622 if ( bSameMask )
623 aStr = ImplPatternReformat( aStr, rEditMask, rLiteralMask, nFormatFlags );
624 rbInKeyInput = TRUE;
625 pEdit->SetText( aStr, Selection( nNewPos ) );
626 pEdit->SetModifyFlag();
627 pEdit->Modify();
628 rbInKeyInput = FALSE;
629 }
630 else
631 pEdit->SetSelection( Selection( nNewPos ) );
632
633 return TRUE;
634 }
635 else if ( nKeyCode == KEY_INSERT )
636 {
637 // InsertModus kann man beim PatternField nur einstellen,
638 // wenn Maske an jeder Eingabeposition die gleiche
639 // ist
640 if ( !bSameMask )
641 {
642 Sound::Beep();
643 return TRUE;
644 }
645 }
646 }
647
648 if ( rKEvt.GetKeyCode().IsMod2() || (cChar < 32) || (cChar == 127) )
649 return FALSE;
650
651 Selection aSel = aOldSel;
652 aSel.Justify();
653 nNewPos = (xub_StrLen)aSel.Min();
654
655 if ( nNewPos < rEditMask.Len() )
656 {
657 xub_Unicode cPattChar = ImplPatternChar( cChar, rEditMask.GetChar(nNewPos) );
658 if ( cPattChar )
659 cChar = cPattChar;
660 else
661 {
662 // Wenn kein gueltiges Zeichen, dann testen wir, ob der
663 // Anwender zum naechsten Literal springen wollte. Dies machen
664 // wir nur, wenn er hinter einem Zeichen steht, damit
665 // eingebene Literale die automatisch uebersprungenen wurden
666 // nicht dazu fuehren, das der Anwender dann da steht, wo
667 // er nicht stehen wollte.
668 if ( nNewPos &&
669 (rEditMask.GetChar(nNewPos-1) != EDITMASK_LITERAL) &&
670 !aSel.Len() )
671 {
672 // Naechstes Zeichen suchen, was kein Literal ist
673 nTempPos = nNewPos;
674 while ( nTempPos < rEditMask.Len() )
675 {
676 if ( rEditMask.GetChar(nTempPos) == EDITMASK_LITERAL )
677 {
678 // Gilt nur, wenn ein Literalzeichen vorhanden
679 if ( (rEditMask.GetChar(nTempPos+1) != EDITMASK_LITERAL ) &&
680 ImplKommaPointCharEqual( cChar, rLiteralMask.GetChar(nTempPos) ) )
681 {
682 nTempPos++;
683 ImplPatternMaxPos( pEdit->GetText(), rEditMask, nFormatFlags, bSameMask, nNewPos, nTempPos );
684 if ( nTempPos > nNewPos )
685 {
686 pEdit->SetSelection( Selection( nTempPos ) );
687 return TRUE;
688 }
689 }
690 break;
691 }
692 nTempPos++;
693 }
694 }
695
696 cChar = 0;
697 }
698 }
699 else
700 cChar = 0;
701 if ( cChar )
702 {
703 XubString aStr = pEdit->GetText();
704 BOOL bError = FALSE;
705 if ( bSameMask && pEdit->IsInsertMode() )
706 {
707 // Text um Spacezeichen und Literale am Ende kuerzen, bis zur
708 // aktuellen Position
709 xub_StrLen n = aStr.Len();
710 while ( n && (n > nNewPos) )
711 {
712 if ( (aStr.GetChar( n-1 ) != ' ') &&
713 ((n > rEditMask.Len()) || (rEditMask.GetChar(n-1) != EDITMASK_LITERAL)) )
714 break;
715
716 n--;
717 }
718 aStr.Erase( n );
719
720 if ( aSel.Len() )
721 aStr.Erase( (xub_StrLen)aSel.Min(), (xub_StrLen)aSel.Len() );
722
723 if ( aStr.Len() < rEditMask.Len() )
724 {
725 // String evtl. noch bis Cursor-Position erweitern
726 if ( aStr.Len() < nNewPos )
727 aStr += rLiteralMask.Copy( aStr.Len(), nNewPos-aStr.Len() );
728 if ( nNewPos < aStr.Len() )
729 aStr.Insert( cChar, nNewPos );
730 else if ( nNewPos < rEditMask.Len() )
731 aStr += cChar;
732 aStr = ImplPatternReformat( aStr, rEditMask, rLiteralMask, nFormatFlags );
733 }
734 else
735 bError = TRUE;
736 }
737 else
738 {
739 if ( aSel.Len() )
740 {
741 // Selection loeschen
742 XubString aRep = rLiteralMask.Copy( (xub_StrLen)aSel.Min(), (xub_StrLen)aSel.Len() );
743 aStr.Replace( (xub_StrLen)aSel.Min(), aRep.Len(), aRep );
744 }
745
746 if ( nNewPos < aStr.Len() )
747 aStr.SetChar( nNewPos, cChar );
748 else if ( nNewPos < rEditMask.Len() )
749 aStr += cChar;
750 }
751
752 if ( bError )
753 Sound::Beep();
754 else
755 {
756 rbInKeyInput = TRUE;
757 Selection aNewSel( ImplPatternRightPos( aStr, rEditMask, nFormatFlags, bSameMask, nNewPos ) );
758 pEdit->SetText( aStr, aNewSel );
759 pEdit->SetModifyFlag();
760 pEdit->Modify();
761 rbInKeyInput = FALSE;
762 }
763 }
764 else
765 Sound::Beep();
766
767 return TRUE;
768 }
769
770 // -----------------------------------------------------------------------
771
772 void PatternFormatter::ImplSetMask( const ByteString& rEditMask,
773 const XubString& rLiteralMask )
774 {
775 maEditMask = rEditMask;
776 maLiteralMask = rLiteralMask;
777 mbSameMask = TRUE;
778
779 if ( maEditMask.Len() != maLiteralMask.Len() )
780 {
781 if ( maEditMask.Len() < maLiteralMask.Len() )
782 maLiteralMask.Erase( maEditMask.Len() );
783 else
784 maLiteralMask.Expand( maEditMask.Len(), ' ' );
785 }
786
787 // StrictModus erlaubt nur Input-Mode, wenn als Maske nur
788 // gleiche Zeichen zugelassen werden und als Vorgabe nur
789 // Spacezeichen vorgegeben werden, die durch die Maske
790 // nicht zugelassen sind
791 xub_StrLen i = 0;
792 sal_Char c = 0;
793 while ( i < rEditMask.Len() )
794 {
795 sal_Char cTemp = rEditMask.GetChar( i );
796 if ( cTemp != EDITMASK_LITERAL )
797 {
798 if ( (cTemp == EDITMASK_ALLCHAR) ||
799 (cTemp == EDITMASK_UPPERALLCHAR) ||
800 (cTemp == EDITMASK_NUMSPACE) )
801 {
802 mbSameMask = FALSE;
803 break;
804 }
805 if ( i < rLiteralMask.Len() )
806 {
807 if ( rLiteralMask.GetChar( i ) != ' ' )
808 {
809 mbSameMask = FALSE;
810 break;
811 }
812 }
813 if ( !c )
814 c = cTemp;
815 if ( cTemp != c )
816 {
817 mbSameMask = FALSE;
818 break;
819 }
820 }
821 i++;
822 }
823 }
824
825 // -----------------------------------------------------------------------
826
827 PatternFormatter::PatternFormatter()
828 {
829 mnFormatFlags = 0;
830 mbSameMask = TRUE;
831 mbInPattKeyInput = FALSE;
832 }
833
834 // -----------------------------------------------------------------------
835
836 void PatternFormatter::ImplLoadRes( const ResId& rResId )
837 {
838 ByteString aEditMask;
839 XubString aLiteralMask;
840 ResMgr* pMgr = rResId.GetResMgr();
841 if( pMgr )
842 {
843 ULONG nMask = pMgr->ReadLong();
844
845 if ( PATTERNFORMATTER_STRICTFORMAT & nMask )
846 SetStrictFormat( (BOOL)pMgr->ReadShort() );
847
848 if ( PATTERNFORMATTER_EDITMASK & nMask )
849 aEditMask = ByteString( pMgr->ReadString(), RTL_TEXTENCODING_ASCII_US );
850
851 if ( PATTERNFORMATTER_LITTERALMASK & nMask )
852 aLiteralMask = pMgr->ReadString();
853
854 if ( (PATTERNFORMATTER_EDITMASK | PATTERNFORMATTER_LITTERALMASK) & nMask )
855 ImplSetMask( aEditMask, aLiteralMask );
856 }
857 }
858
859 // -----------------------------------------------------------------------
860
861 PatternFormatter::~PatternFormatter()
862 {
863 }
864
865 // -----------------------------------------------------------------------
866
867 void PatternFormatter::SetMask( const ByteString& rEditMask,
868 const XubString& rLiteralMask )
869 {
870 ImplSetMask( rEditMask, rLiteralMask );
871 ReformatAll();
872 }
873
874 // -----------------------------------------------------------------------
875
876 void PatternFormatter::SetString( const XubString& rStr )
877 {
878 maFieldString = rStr;
879 if ( GetField() )
880 {
881 GetField()->SetText( rStr );
882 MarkToBeReformatted( FALSE );
883 }
884 }
885
886 // -----------------------------------------------------------------------
887
888 XubString PatternFormatter::GetString() const
889 {
890 if ( !GetField() )
891 return ImplGetSVEmptyStr();
892 else
893 return ImplPatternReformat( GetField()->GetText(), maEditMask, maLiteralMask, mnFormatFlags );
894 }
895
896 // -----------------------------------------------------------------------
897
898 void PatternFormatter::Reformat()
899 {
900 if ( GetField() )
901 {
902 ImplSetText( ImplPatternReformat( GetField()->GetText(), maEditMask, maLiteralMask, mnFormatFlags ) );
903 if ( !mbSameMask && IsStrictFormat() && !GetField()->IsReadOnly() )
904 GetField()->SetInsertMode( FALSE );
905 }
906 }
907
908 // -----------------------------------------------------------------------
909
910 void PatternFormatter::SelectFixedFont()
911 {
912 if ( GetField() )
913 {
914 Font aFont = OutputDevice::GetDefaultFont( DEFAULTFONT_FIXED, Application::GetSettings().GetLanguage(), 0 );
915 Font aControlFont;
916 aControlFont.SetName( aFont.GetName() );
917 aControlFont.SetFamily( aFont.GetFamily() );
918 aControlFont.SetPitch( aFont.GetPitch() );
919 GetField()->SetControlFont( aControlFont );
920 }
921 }
922
923 \f// -----------------------------------------------------------------------
924
925 PatternField::PatternField( Window* pParent, WinBits nWinStyle ) :
926 SpinField( pParent, nWinStyle )
927 {
928 SetField( this );
929 Reformat();
930 }
931
932 // -----------------------------------------------------------------------
933
934 PatternField::PatternField( Window* pParent, const ResId& rResId ) :
935 SpinField( WINDOW_PATTERNFIELD )
936 {
937 rResId.SetRT( RSC_PATTERNFIELD );
938 WinBits nStyle = ImplInitRes( rResId );
939 ImplInit( pParent, nStyle );
940 SetField( this );
941 SpinField::ImplLoadRes( rResId );
942 PatternFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
943 Reformat();
944
945 if ( !(nStyle & WB_HIDE ) )
946 Show();
947 }
948
949 // -----------------------------------------------------------------------
950
951 PatternField::~PatternField()
952 {
953 }
954
955 // -----------------------------------------------------------------------
956
957 long PatternField::PreNotify( NotifyEvent& rNEvt )
958 {
959 if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
960 {
961 if ( ImplPatternProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), GetEditMask(), GetLiteralMask(),
962 IsStrictFormat(), GetFormatFlags(),
963 ImplIsSameMask(), ImplGetInPattKeyInput() ) )
964 return 1;
965 }
966
967 return SpinField::PreNotify( rNEvt );
968 }
969
970 // -----------------------------------------------------------------------
971
972 long PatternField::Notify( NotifyEvent& rNEvt )
973 {
974 if ( rNEvt.GetType() == EVENT_GETFOCUS )
975 MarkToBeReformatted( FALSE );
976 else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
977 {
978 if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
979 Reformat();
980 }
981
982 return SpinField::Notify( rNEvt );
983 }
984
985 // -----------------------------------------------------------------------
986
987 void PatternField::Modify()
988 {
989 if ( !ImplGetInPattKeyInput() )
990 {
991 if ( IsStrictFormat() )
992 ImplPatternProcessStrictModify( GetField(), GetEditMask(), GetLiteralMask(), GetFormatFlags(), ImplIsSameMask() );
993 else
994 MarkToBeReformatted( TRUE );
995 }
996
997 SpinField::Modify();
998 }
999
1000 // -----------------------------------------------------------------------
1001
1002 PatternBox::PatternBox( Window* pParent, WinBits nWinStyle ) :
1003 ComboBox( pParent, nWinStyle )
1004 {
1005 SetField( this );
1006 Reformat();
1007 }
1008
1009 // -----------------------------------------------------------------------
1010
1011 PatternBox::PatternBox( Window* pParent, const ResId& rResId ) :
1012 ComboBox( WINDOW_PATTERNBOX )
1013 {
1014 rResId.SetRT( RSC_PATTERNBOX );
1015 WinBits nStyle = ImplInitRes( rResId );
1016 ImplInit( pParent, nStyle );
1017
1018 SetField( this );
1019 ComboBox::ImplLoadRes( rResId );
1020 PatternFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *rResId.GetResMgr() ) );
1021 Reformat();
1022
1023 if ( !(nStyle & WB_HIDE ) )
1024 Show();
1025 }
1026
1027 // -----------------------------------------------------------------------
1028
1029 PatternBox::~PatternBox()
1030 {
1031 }
1032
1033 // -----------------------------------------------------------------------
1034
1035 long PatternBox::PreNotify( NotifyEvent& rNEvt )
1036 {
1037 if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
1038 {
1039 if ( ImplPatternProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), GetEditMask(), GetLiteralMask(),
1040 IsStrictFormat(), GetFormatFlags(),
1041 ImplIsSameMask(), ImplGetInPattKeyInput() ) )
1042 return 1;
1043 }
1044
1045 return ComboBox::PreNotify( rNEvt );
1046 }
1047
1048 // -----------------------------------------------------------------------
1049
1050 long PatternBox::Notify( NotifyEvent& rNEvt )
1051 {
1052 if ( rNEvt.GetType() == EVENT_GETFOCUS )
1053 MarkToBeReformatted( FALSE );
1054 else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
1055 {
1056 if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
1057 Reformat();
1058 }
1059
1060 return ComboBox::Notify( rNEvt );
1061 }
1062
1063 // -----------------------------------------------------------------------
1064
1065 void PatternBox::Modify()
1066 {
1067 if ( !ImplGetInPattKeyInput() )
1068 {
1069 if ( IsStrictFormat() )
1070 ImplPatternProcessStrictModify( GetField(), GetEditMask(), GetLiteralMask(), GetFormatFlags(), ImplIsSameMask() );
1071 else
1072 MarkToBeReformatted( TRUE );
1073 }
1074
1075 ComboBox::Modify();
1076 }
1077
1078 // -----------------------------------------------------------------------
1079
1080 void PatternBox::ReformatAll()
1081 {
1082 XubString aStr;
1083 SetUpdateMode( FALSE );
1084 USHORT nEntryCount = GetEntryCount();
1085 for ( USHORT i=0; i < nEntryCount; i++ )
1086 {
1087 aStr = ImplPatternReformat( GetEntry( i ), GetEditMask(), GetLiteralMask(), GetFormatFlags() );
1088 RemoveEntry( i );
1089 InsertEntry( aStr, i );
1090 }
1091 PatternFormatter::Reformat();
1092 SetUpdateMode( TRUE );
1093 }
1094
1095 // -----------------------------------------------------------------------
1096
1097 void PatternBox::InsertString( const XubString& rStr, USHORT nPos )
1098 {
1099 ComboBox::InsertEntry( ImplPatternReformat( rStr, GetEditMask(), GetLiteralMask(), GetFormatFlags() ), nPos );
1100 }
1101
1102 // -----------------------------------------------------------------------
1103
1104 void PatternBox::RemoveString( const XubString& rStr )
1105 {
1106 ComboBox::RemoveEntry( ImplPatternReformat( rStr, GetEditMask(), GetLiteralMask(), GetFormatFlags() ) );
1107 }
1108
1109 // -----------------------------------------------------------------------
1110
1111 XubString PatternBox::GetString( USHORT nPos ) const
1112 {
1113 return ImplPatternReformat( ComboBox::GetEntry( nPos ), GetEditMask(), GetLiteralMask(), GetFormatFlags() );
1114 }
1115
1116 // -----------------------------------------------------------------------
1117
1118 USHORT PatternBox::GetStringPos( const XubString& rStr ) const
1119 {
1120 return ComboBox::GetEntryPos( ImplPatternReformat( rStr, GetEditMask(), GetLiteralMask(), GetFormatFlags() ) );
1121 }
1122
1123 // =======================================================================
1124
1125 static ExtDateFieldFormat ImplGetExtFormat( DateFormat eOld )
1126 {
1127 switch( eOld )
1128 {
1129 case DMY: return XTDATEF_SHORT_DDMMYY;
1130 case MDY: return XTDATEF_SHORT_MMDDYY;
1131 default: return XTDATEF_SHORT_YYMMDD;
1132 }
1133 }
1134
1135 // -----------------------------------------------------------------------
1136
1137 static USHORT ImplCutNumberFromString( XubString& rStr )
1138 {
1139 // Nach Zahl suchen
1140 while ( rStr.Len() && !(rStr.GetChar( 0 ) >= '0' && rStr.GetChar( 0 ) <= '9') )
1141 rStr.Erase( 0, 1 );
1142 if ( !rStr.Len() )
1143 return 0;
1144 XubString aNumStr;
1145 while ( rStr.Len() && (rStr.GetChar( 0 ) >= '0' && rStr.GetChar( 0 ) <= '9') )
1146 {
1147 aNumStr.Insert( rStr.GetChar( 0 ) );
1148 rStr.Erase( 0, 1 );
1149 }
1150 return (USHORT)aNumStr.ToInt32();
1151 }
1152
1153 // -----------------------------------------------------------------------
1154
1155 static BOOL ImplCutMonthName( XubString& rStr, const XubString& _rLookupMonthName )
1156 {
1157 USHORT nPos = rStr.Search( _rLookupMonthName );
1158 if ( nPos != STRING_NOTFOUND )
1159 {
1160 rStr.Erase( 0, nPos + _rLookupMonthName.Len() );
1161 return TRUE;
1162 }
1163 return FALSE;
1164 }
1165
1166 // -----------------------------------------------------------------------
1167
1168 static USHORT ImplCutMonthFromString( XubString& rStr, const CalendarWrapper& rCalendarWrapper )
1169 {
1170 // search for a month' name
1171 for ( USHORT i=1; i <= 12; i++ )
1172 {
1173 String aMonthName = rCalendarWrapper.getMonths()[i-1].FullName;
1174 // long month name?
1175 if ( ImplCutMonthName( rStr, aMonthName ) )
1176 return i;
1177
1178 // short month name?
1179 String aAbbrevMonthName = rCalendarWrapper.getMonths()[i-1].AbbrevName;
1180 if ( ImplCutMonthName( rStr, aAbbrevMonthName ) )
1181 return i;
1182 }
1183
1184 return ImplCutNumberFromString( rStr );
1185 }
1186
1187 // -----------------------------------------------------------------------
1188
1189 static String ImplGetDateSep( const LocaleDataWrapper& rLocaleDataWrapper, ExtDateFieldFormat eFormat )
1190 {
1191 String aDateSep = rLocaleDataWrapper.getDateSep();
1192
1193 if ( ( eFormat == XTDATEF_SHORT_YYMMDD_DIN5008 ) || ( eFormat == XTDATEF_SHORT_YYYYMMDD_DIN5008 ) )
1194 aDateSep = String( RTL_CONSTASCII_USTRINGPARAM( "-" ) );
1195
1196 return aDateSep;
1197 }
1198
1199 static BOOL ImplDateProcessKeyInput( Edit*, const KeyEvent& rKEvt, ExtDateFieldFormat eFormat,
1200 const LocaleDataWrapper& rLocaleDataWrapper )
1201 {
1202 xub_Unicode cChar = rKEvt.GetCharCode();
1203 USHORT nGroup = rKEvt.GetKeyCode().GetGroup();
1204 if ( (nGroup == KEYGROUP_FKEYS) || (nGroup == KEYGROUP_CURSOR) ||
1205 (nGroup == KEYGROUP_MISC)||
1206 ((cChar >= '0') && (cChar <= '9')) ||
1207 (cChar == ImplGetDateSep( rLocaleDataWrapper, eFormat ).GetChar(0) ) )
1208 return FALSE;
1209 else
1210 return TRUE;
1211 }
1212
1213 // -----------------------------------------------------------------------
1214
1215 static BOOL ImplDateGetValue( const XubString& rStr, Date& rDate, ExtDateFieldFormat eDateFormat,
1216 const LocaleDataWrapper& rLocaleDataWrapper, const CalendarWrapper& rCalendarWrapper,
1217 const AllSettings& rSettings )
1218 {
1219 USHORT nDay = 0;
1220 USHORT nMonth = 0;
1221 USHORT nYear = 0;
1222 BOOL bYear = TRUE;
1223 BOOL bError = FALSE;
1224 String aStr( rStr );
1225
1226 if ( eDateFormat == XTDATEF_SYSTEM_LONG )
1227 {
1228 DateFormat eFormat = rLocaleDataWrapper.getLongDateFormat();
1229 switch( eFormat )
1230 {
1231 case MDY:
1232 nMonth = ImplCutMonthFromString( aStr, rCalendarWrapper );
1233 nDay = ImplCutNumberFromString( aStr );
1234 nYear = ImplCutNumberFromString( aStr );
1235 break;
1236 case DMY:
1237 nDay = ImplCutNumberFromString( aStr );
1238 nMonth = ImplCutMonthFromString( aStr, rCalendarWrapper );
1239 nYear = ImplCutNumberFromString( aStr );
1240 break;
1241 case YMD:
1242 default:
1243 nYear = ImplCutNumberFromString( aStr );
1244 nMonth = ImplCutMonthFromString( aStr, rCalendarWrapper );
1245 nDay = ImplCutNumberFromString( aStr );
1246 break;
1247 }
1248 }
1249 else
1250 {
1251 // Check if year is present:
1252 String aDateSep = ImplGetDateSep( rLocaleDataWrapper, eDateFormat );
1253 USHORT nSepPos = aStr.Search( aDateSep );
1254 if ( nSepPos == STRING_NOTFOUND )
1255 return FALSE;
1256 nSepPos = aStr.Search( aDateSep, nSepPos+1 );
1257 if ( ( nSepPos == STRING_NOTFOUND ) || ( nSepPos == (aStr.Len()-1) ) )
1258 {
1259 bYear = FALSE;
1260 nYear = Date().GetYear();
1261 }
1262
1263 const sal_Unicode* pBuf = aStr.GetBuffer();
1264 ImplSkipDelimiters( pBuf );
1265
1266 switch ( eDateFormat )
1267 {
1268 case XTDATEF_SHORT_DDMMYY:
1269 case XTDATEF_SHORT_DDMMYYYY:
1270 {
1271 nDay = ImplGetNum( pBuf, bError );
1272 ImplSkipDelimiters( pBuf );
1273 nMonth = ImplGetNum( pBuf, bError );
1274 ImplSkipDelimiters( pBuf );
1275 if ( bYear )
1276 nYear = ImplGetNum( pBuf, bError );
1277 }
1278 break;
1279 case XTDATEF_SHORT_MMDDYY:
1280 case XTDATEF_SHORT_MMDDYYYY:
1281 {
1282 nMonth = ImplGetNum( pBuf, bError );
1283 ImplSkipDelimiters( pBuf );
1284 nDay = ImplGetNum( pBuf, bError );
1285 ImplSkipDelimiters( pBuf );
1286 if ( bYear )
1287 nYear = ImplGetNum( pBuf, bError );
1288 }
1289 break;
1290 case XTDATEF_SHORT_YYMMDD:
1291 case XTDATEF_SHORT_YYYYMMDD:
1292 case XTDATEF_SHORT_YYMMDD_DIN5008:
1293 case XTDATEF_SHORT_YYYYMMDD_DIN5008:
1294 {
1295 if ( bYear )
1296 nYear = ImplGetNum( pBuf, bError );
1297 ImplSkipDelimiters( pBuf );
1298 nMonth = ImplGetNum( pBuf, bError );
1299 ImplSkipDelimiters( pBuf );
1300 nDay = ImplGetNum( pBuf, bError );
1301 }
1302 break;
1303
1304 default:
1305 {
1306 DBG_ERROR( "DateFormat???" );
1307 }
1308 }
1309 }
1310
1311 if ( bError || !nDay || !nMonth )
1312 return FALSE;
1313
1314 Date aNewDate( nDay, nMonth, nYear );
1315 DateFormatter::ExpandCentury( aNewDate, rSettings.GetMiscSettings().GetTwoDigitYearStart() );
1316 if ( aNewDate.IsValid() )
1317 {
1318 rDate = aNewDate;
1319 return TRUE;
1320 }
1321 return FALSE;
1322 }
1323
1324 // -----------------------------------------------------------------------
1325
1326 BOOL DateFormatter::ImplDateReformat( const XubString& rStr, XubString& rOutStr, const AllSettings& rSettings )
1327 {
1328 Date aDate( 0, 0, 0 );
1329 if ( !ImplDateGetValue( rStr, aDate, GetExtDateFormat(TRUE), ImplGetLocaleDataWrapper(), GetCalendarWrapper(), GetFieldSettings() ) )
1330 return TRUE;
1331
1332 Date aTempDate = aDate;
1333 if ( aTempDate > GetMax() )
1334 aTempDate = GetMax();
1335 else if ( aTempDate < GetMin() )
1336 aTempDate = GetMin();
1337
1338 if ( GetErrorHdl().IsSet() && (aDate != aTempDate) )
1339 {
1340 maCorrectedDate = aTempDate;
1341 if( !GetErrorHdl().Call( this ) )
1342 {
1343 maCorrectedDate = Date();
1344 return FALSE;
1345 }
1346 else
1347 maCorrectedDate = Date();
1348 }
1349
1350 rOutStr = ImplGetDateAsText( aTempDate, rSettings );
1351
1352 return TRUE;
1353 }
1354
1355 // -----------------------------------------------------------------------
1356
1357 XubString DateFormatter::ImplGetDateAsText( const Date& rDate,
1358 const AllSettings& rSettings ) const
1359 {
1360 BOOL bShowCentury = FALSE;
1361 switch ( GetExtDateFormat() )
1362 {
1363 case XTDATEF_SYSTEM_SHORT_YYYY:
1364 case XTDATEF_SYSTEM_LONG:
1365 case XTDATEF_SHORT_DDMMYYYY:
1366 case XTDATEF_SHORT_MMDDYYYY:
1367 case XTDATEF_SHORT_YYYYMMDD:
1368 case XTDATEF_SHORT_YYYYMMDD_DIN5008:
1369 {
1370 bShowCentury = TRUE;
1371 }
1372 break;
1373 default:
1374 {
1375 bShowCentury = FALSE;
1376 }
1377 }
1378
1379 if ( !bShowCentury )
1380 {
1381 // Check if I have to use force showing the century
1382 USHORT nTwoDigitYearStart = rSettings.GetMiscSettings().GetTwoDigitYearStart();
1383 USHORT nYear = rDate.GetYear();
1384
1385 // Wenn Jahr nicht im 2stelligen Grenzbereich liegt,
1386 if ( (nYear < nTwoDigitYearStart) || (nYear >= nTwoDigitYearStart+100) )
1387 bShowCentury = TRUE;
1388 }
1389
1390 sal_Unicode aBuf[128];
1391 sal_Unicode* pBuf = aBuf;
1392
1393 String aDateSep = ImplGetDateSep( ImplGetLocaleDataWrapper(), GetExtDateFormat( TRUE ) );
1394 USHORT nDay = rDate.GetDay();
1395 USHORT nMonth = rDate.GetMonth();
1396 USHORT nYear = rDate.GetYear();
1397 USHORT nYearLen = bShowCentury ? 4 : 2;
1398
1399 if ( !bShowCentury )
1400 nYear %= 100;
1401
1402 switch ( GetExtDateFormat( TRUE ) )
1403 {
1404 case XTDATEF_SYSTEM_LONG:
1405 {
1406 return ImplGetLocaleDataWrapper().getLongDate( rDate, GetCalendarWrapper(), 1, FALSE, 1, !bShowCentury );
1407 }
1408 case XTDATEF_SHORT_DDMMYY:
1409 case XTDATEF_SHORT_DDMMYYYY:
1410 {
1411 pBuf = ImplAddNum( pBuf, nDay, 2 );
1412 pBuf = ImplAddString( pBuf, aDateSep );
1413 pBuf = ImplAddNum( pBuf, nMonth, 2 );
1414 pBuf = ImplAddString( pBuf, aDateSep );
1415 pBuf = ImplAddNum( pBuf, nYear, nYearLen );
1416 }
1417 break;
1418 case XTDATEF_SHORT_MMDDYY:
1419 case XTDATEF_SHORT_MMDDYYYY:
1420 {
1421 pBuf = ImplAddNum( pBuf, nMonth, 2 );
1422 pBuf = ImplAddString( pBuf, aDateSep );
1423 pBuf = ImplAddNum( pBuf, nDay, 2 );
1424 pBuf = ImplAddString( pBuf, aDateSep );
1425 pBuf = ImplAddNum( pBuf, nYear, nYearLen );
1426 }
1427 break;
1428 case XTDATEF_SHORT_YYMMDD:
1429 case XTDATEF_SHORT_YYYYMMDD:
1430 case XTDATEF_SHORT_YYMMDD_DIN5008:
1431 case XTDATEF_SHORT_YYYYMMDD_DIN5008:
1432 {
1433 pBuf = ImplAddNum( pBuf, nYear, nYearLen );
1434 pBuf = ImplAddString( pBuf, aDateSep );
1435 pBuf = ImplAddNum( pBuf, nMonth, 2 );
1436 pBuf = ImplAddString( pBuf, aDateSep );
1437 pBuf = ImplAddNum( pBuf, nDay, 2 );
1438 }
1439 break;
1440 default:
1441 {
1442 DBG_ERROR( "DateFormat???" );
1443 }
1444 }
1445
1446 return String( aBuf, (xub_StrLen)(ULONG)(pBuf-aBuf) );
1447 }
1448
1449 // -----------------------------------------------------------------------
1450
1451 static void ImplDateIncrementDay( Date& rDate, BOOL bUp )
1452 {
1453 DateFormatter::ExpandCentury( rDate );
1454
1455 if ( bUp )
1456 {
1457 if ( (rDate.GetDay() != 31) || (rDate.GetMonth() != 12) || (rDate.GetYear() != 9999) )
1458 rDate++;
1459 }
1460 else
1461 {
1462 if ( (rDate.GetDay() != 1 ) || (rDate.GetMonth() != 1) || (rDate.GetYear() != 0) )
1463 rDate--;
1464 }
1465 }
1466
1467 // -----------------------------------------------------------------------
1468
1469 static void ImplDateIncrementMonth( Date& rDate, BOOL bUp )
1470 {
1471 DateFormatter::ExpandCentury( rDate );
1472
1473 USHORT nMonth = rDate.GetMonth();
1474 USHORT nYear = rDate.GetYear();
1475 if ( bUp )
1476 {
1477 if ( (nMonth == 12) && (nYear < 9999) )
1478 {
1479 rDate.SetMonth( 1 );
1480 rDate.SetYear( nYear + 1 );
1481 }
1482 else
1483 {
1484 if ( nMonth < 12 )
1485 rDate.SetMonth( nMonth + 1 );
1486 }
1487 }
1488 else
1489 {
1490 if ( (nMonth == 1) && (nYear > 0) )
1491 {
1492 rDate.SetMonth( 12 );
1493 rDate.SetYear( nYear - 1 );
1494 }
1495 else
1496 {
1497 if ( nMonth > 1 )
1498 rDate.SetMonth( nMonth - 1 );
1499 }
1500 }
1501
1502 USHORT nDaysInMonth = rDate.GetDaysInMonth();
1503 if ( rDate.GetDay() > nDaysInMonth )
1504 rDate.SetDay( nDaysInMonth );
1505 }
1506
1507 // -----------------------------------------------------------------------
1508
1509 static void ImplDateIncrementYear( Date& rDate, BOOL bUp )
1510 {
1511 DateFormatter::ExpandCentury( rDate );
1512
1513 USHORT nYear = rDate.GetYear();
1514 if ( bUp )
1515 {
1516 if ( nYear < 9999 )
1517 rDate.SetYear( nYear + 1 );
1518 }
1519 else
1520 {
1521 if ( nYear > 0 )
1522 rDate.SetYear( nYear - 1 );
1523 }
1524 }
1525
1526 // -----------------------------------------------------------------------
1527 BOOL DateFormatter::ImplAllowMalformedInput() const
1528 {
1529 return !IsEnforceValidValue();
1530 }
1531
1532 // -----------------------------------------------------------------------
1533
1534 void DateField::ImplDateSpinArea( BOOL bUp )
1535 {
1536 // Wenn alles selektiert ist, Tage hochzaehlen
1537 if ( GetField() )
1538 {
1539 Date aDate( GetDate() );
1540 Selection aSelection = GetField()->GetSelection();
1541 aSelection.Justify();
1542 XubString aText( GetText() );
1543 if ( (xub_StrLen)aSelection.Len() == aText.Len() )
1544 ImplDateIncrementDay( aDate, bUp );
1545 else
1546 {
1547 xub_StrLen nDateArea = 0;
1548
1549 ExtDateFieldFormat eFormat = GetExtDateFormat( TRUE );
1550 if ( eFormat == XTDATEF_SYSTEM_LONG )
1551 {
1552 eFormat = ImplGetExtFormat( ImplGetLocaleDataWrapper().getLongDateFormat() );
1553 nDateArea = 1;
1554 }
1555 else
1556 {
1557 // Area suchen
1558 xub_StrLen nPos = 0;
1559 String aDateSep = ImplGetDateSep( ImplGetLocaleDataWrapper(), eFormat );
1560 for ( xub_StrLen i = 1; i <= 3; i++ )
1561 {
1562 nPos = aText.Search( aDateSep, nPos );
1563 if ( nPos >= (USHORT)aSelection.Max() )
1564 {
1565 nDateArea = i;
1566 break;
1567 }
1568 else
1569 nPos++;
1570 }
1571 }
1572
1573
1574 switch( eFormat )
1575 {
1576 case XTDATEF_SHORT_MMDDYY:
1577 case XTDATEF_SHORT_MMDDYYYY:
1578 switch( nDateArea )
1579 {
1580 case 1: ImplDateIncrementMonth( aDate, bUp );
1581 break;
1582 case 2: ImplDateIncrementDay( aDate, bUp );
1583 break;
1584 case 3: ImplDateIncrementYear( aDate, bUp );
1585 break;
1586 }
1587 break;
1588 case XTDATEF_SHORT_DDMMYY:
1589 case XTDATEF_SHORT_DDMMYYYY:
1590 switch( nDateArea )
1591 {
1592 case 1: ImplDateIncrementDay( aDate, bUp );
1593 break;
1594 case 2: ImplDateIncrementMonth( aDate, bUp );
1595 break;
1596 case 3: ImplDateIncrementYear( aDate, bUp );
1597 break;
1598 }
1599 break;
1600 case XTDATEF_SHORT_YYMMDD:
1601 case XTDATEF_SHORT_YYYYMMDD:
1602 case XTDATEF_SHORT_YYMMDD_DIN5008:
1603 case XTDATEF_SHORT_YYYYMMDD_DIN5008:
1604 switch( nDateArea )
1605 {
1606 case 1: ImplDateIncrementYear( aDate, bUp );
1607 break;
1608 case 2: ImplDateIncrementMonth( aDate, bUp );
1609 break;
1610 case 3: ImplDateIncrementDay( aDate, bUp );
1611 break;
1612 }
1613 break;
1614 default:
1615 DBG_ERROR( "invalid conversion" );
1616 break;
1617 }
1618 }
1619
1620 ImplNewFieldValue( aDate );
1621 }
1622 }
1623
1624 // -----------------------------------------------------------------------
1625
1626 void DateFormatter::ImplInit()
1627 {
1628 mbLongFormat = FALSE;
1629 mbShowDateCentury = TRUE;
1630 mpCalendarWrapper = NULL;
1631 mnDateFormat = 0xFFFF;
1632 mnExtDateFormat = XTDATEF_SYSTEM_SHORT;
1633 }
1634
1635 // -----------------------------------------------------------------------
1636
1637 DateFormatter::DateFormatter() :
1638 maFieldDate( 0 ),
1639 maLastDate( 0 ),
1640 maMin( 1, 1, 1900 ),
1641 maMax( 31, 12, 2200 ),
1642 mbEnforceValidValue( TRUE )
1643 {
1644 ImplInit();
1645 }
1646
1647 // -----------------------------------------------------------------------
1648
1649 void DateFormatter::ImplLoadRes( const ResId& rResId )
1650 {
1651 ResMgr* pMgr = rResId.GetResMgr();
1652 if( pMgr )
1653 {
1654 ULONG nMask = pMgr->ReadLong();
1655
1656 if ( DATEFORMATTER_MIN & nMask )
1657 {
1658 maMin = Date( ResId( (RSHEADER_TYPE *)pMgr->GetClass(), *pMgr ) );
1659 pMgr->Increment( pMgr->GetObjSize( (RSHEADER_TYPE*)pMgr->GetClass() ) );
1660 }
1661 if ( DATEFORMATTER_MAX & nMask )
1662 {
1663 maMax = Date( ResId( (RSHEADER_TYPE *)pMgr->GetClass(), *pMgr ) );
1664 pMgr->Increment( pMgr->GetObjSize( (RSHEADER_TYPE*)pMgr->GetClass() ) );
1665 }
1666 if ( DATEFORMATTER_LONGFORMAT & nMask )
1667 mbLongFormat = (BOOL)pMgr->ReadShort();
1668
1669 if ( DATEFORMATTER_STRICTFORMAT & nMask )
1670 SetStrictFormat( (BOOL)pMgr->ReadShort() );
1671
1672 if ( DATEFORMATTER_VALUE & nMask )
1673 {
1674 maFieldDate = Date( ResId( (RSHEADER_TYPE *)pMgr->GetClass(), *pMgr ) );
1675 pMgr->Increment( pMgr->GetObjSize( (RSHEADER_TYPE*)pMgr->GetClass() ) );
1676 if ( maFieldDate > maMax )
1677 maFieldDate = maMax;
1678 if ( maFieldDate < maMin )
1679 maFieldDate = maMin;
1680 maLastDate = maFieldDate;
1681 }
1682 }
1683 }
1684
1685 // -----------------------------------------------------------------------
1686
1687 DateFormatter::~DateFormatter()
1688 {
1689 delete mpCalendarWrapper;
1690 mpCalendarWrapper = NULL;
1691 }
1692
1693 // -----------------------------------------------------------------------
1694
1695 void DateFormatter::SetLocale( const ::com::sun::star::lang::Locale& rLocale )
1696 {
1697 delete mpCalendarWrapper;
1698 mpCalendarWrapper = NULL;
1699 FormatterBase::SetLocale( rLocale );
1700 }
1701
1702
1703 // -----------------------------------------------------------------------
1704
1705 CalendarWrapper& DateFormatter::GetCalendarWrapper() const
1706 {
1707 if ( !mpCalendarWrapper )
1708 {
1709 ((DateFormatter*)this)->mpCalendarWrapper = new CalendarWrapper( vcl::unohelper::GetMultiServiceFactory() );
1710 mpCalendarWrapper->loadDefaultCalendar( GetLocale() );
1711 }
1712
1713 return *mpCalendarWrapper;
1714 }
1715
1716 // -----------------------------------------------------------------------
1717
1718 void DateFormatter::SetExtDateFormat( ExtDateFieldFormat eFormat )
1719 {
1720 mnExtDateFormat = eFormat;
1721 ReformatAll();
1722 }
1723
1724 // -----------------------------------------------------------------------
1725
1726 ExtDateFieldFormat DateFormatter::GetExtDateFormat( BOOL bResolveSystemFormat ) const
1727 {
1728 ExtDateFieldFormat eDateFormat = (ExtDateFieldFormat)mnExtDateFormat;
1729
1730 if ( bResolveSystemFormat && ( eDateFormat <= XTDATEF_SYSTEM_SHORT_YYYY ) )
1731 {
1732 BOOL bShowCentury = (eDateFormat == XTDATEF_SYSTEM_SHORT_YYYY);
1733 switch ( ImplGetLocaleDataWrapper().getDateFormat() )
1734 {
1735 case DMY: eDateFormat = bShowCentury ? XTDATEF_SHORT_DDMMYYYY : XTDATEF_SHORT_DDMMYY;
1736 break;
1737 case MDY: eDateFormat = bShowCentury ? XTDATEF_SHORT_MMDDYYYY : XTDATEF_SHORT_MMDDYY;
1738 break;
1739 default: eDateFormat = bShowCentury ? XTDATEF_SHORT_YYYYMMDD : XTDATEF_SHORT_YYMMDD;
1740
1741 }
1742 }
1743
1744 return eDateFormat;
1745 }
1746
1747 // -----------------------------------------------------------------------
1748
1749 void DateFormatter::ReformatAll()
1750 {
1751 Reformat();
1752 }
1753
1754 // -----------------------------------------------------------------------
1755
1756 void DateFormatter::SetMin( const Date& rNewMin )
1757 {
1758 maMin = rNewMin;
1759 if ( !IsEmptyFieldValue() )
1760 ReformatAll();
1761 }
1762
1763 // -----------------------------------------------------------------------
1764
1765 void DateFormatter::SetMax( const Date& rNewMax )
1766 {
1767 maMax = rNewMax;
1768 if ( !IsEmptyFieldValue() )
1769 ReformatAll();
1770 }
1771
1772 // -----------------------------------------------------------------------
1773
1774 void DateFormatter::SetLongFormat( BOOL bLong )
1775 {
1776 mbLongFormat = bLong;
1777
1778 // #91913# Remove LongFormat and DateShowCentury - redundant
1779 if ( bLong )
1780 {
1781 SetExtDateFormat( XTDATEF_SYSTEM_LONG );
1782 }
1783 else
1784 {
1785 if( mnExtDateFormat == XTDATEF_SYSTEM_LONG )
1786 SetExtDateFormat( XTDATEF_SYSTEM_SHORT );
1787 }
1788
1789 ReformatAll();
1790 }
1791
1792 // -----------------------------------------------------------------------
1793
1794 void DateFormatter::SetShowDateCentury( BOOL bShowDateCentury )
1795 {
1796 mbShowDateCentury = bShowDateCentury;
1797
1798 // #91913# Remove LongFormat and DateShowCentury - redundant
1799 if ( bShowDateCentury )
1800 {
1801 switch ( GetExtDateFormat() )
1802 {
1803 case XTDATEF_SYSTEM_SHORT:
1804 case XTDATEF_SYSTEM_SHORT_YY:
1805 SetExtDateFormat( XTDATEF_SYSTEM_SHORT_YYYY ); break;
1806 case XTDATEF_SHORT_DDMMYY:
1807 SetExtDateFormat( XTDATEF_SHORT_DDMMYYYY ); break;
1808 case XTDATEF_SHORT_MMDDYY:
1809 SetExtDateFormat( XTDATEF_SHORT_MMDDYYYY ); break;
1810 case XTDATEF_SHORT_YYMMDD:
1811 SetExtDateFormat( XTDATEF_SHORT_YYYYMMDD ); break;
1812 case XTDATEF_SHORT_YYMMDD_DIN5008:
1813 SetExtDateFormat( XTDATEF_SHORT_YYYYMMDD_DIN5008 ); break;
1814 default:
1815 ;
1816 }
1817 }
1818 else
1819 {
1820 switch ( GetExtDateFormat() )
1821 {
1822 case XTDATEF_SYSTEM_SHORT:
1823 case XTDATEF_SYSTEM_SHORT_YYYY:
1824 SetExtDateFormat( XTDATEF_SYSTEM_SHORT_YY ); break;
1825 case XTDATEF_SHORT_DDMMYYYY:
1826 SetExtDateFormat( XTDATEF_SHORT_DDMMYY ); break;
1827 case XTDATEF_SHORT_MMDDYYYY:
1828 SetExtDateFormat( XTDATEF_SHORT_MMDDYY ); break;
1829 case XTDATEF_SHORT_YYYYMMDD:
1830 SetExtDateFormat( XTDATEF_SHORT_YYMMDD ); break;
1831 case XTDATEF_SHORT_YYYYMMDD_DIN5008:
1832 SetExtDateFormat( XTDATEF_SHORT_YYMMDD_DIN5008 ); break;
1833 default:
1834 ;
1835 }
1836 }
1837
1838 ReformatAll();
1839 }
1840
1841 // -----------------------------------------------------------------------
1842
1843 void DateFormatter::SetDate( const Date& rNewDate )
1844 {
1845 SetUserDate( rNewDate );
1846 maFieldDate = maLastDate;
1847 maLastDate = GetDate();
1848 }
1849
1850 // -----------------------------------------------------------------------
1851
1852 void DateFormatter::SetUserDate( const Date& rNewDate )
1853 {
1854 ImplSetUserDate( rNewDate );
1855 }
1856
1857 // -----------------------------------------------------------------------
1858
1859 void DateFormatter::ImplSetUserDate( const Date& rNewDate, Selection* pNewSelection )
1860 {
1861 Date aNewDate = rNewDate;
1862 if ( aNewDate > maMax )
1863 aNewDate = maMax;
1864 else if ( aNewDate < maMin )
1865 aNewDate = maMin;
1866 maLastDate = aNewDate;
1867
1868 if ( GetField() )
1869 ImplSetText( ImplGetDateAsText( aNewDate, GetFieldSettings() ), pNewSelection );
1870 }
1871
1872 // -----------------------------------------------------------------------
1873
1874 void DateFormatter::ImplNewFieldValue( const Date& rDate )
1875 {
1876 if ( GetField() )
1877 {
1878 Selection aSelection = GetField()->GetSelection();
1879 aSelection.Justify();
1880 XubString aText = GetField()->GetText();
1881 // Wenn bis ans Ende selektiert war, soll das auch so bleiben...
1882 if ( (xub_StrLen)aSelection.Max() == aText.Len() )
1883 {
1884 if ( !aSelection.Len() )
1885 aSelection.Min() = SELECTION_MAX;
1886 aSelection.Max() = SELECTION_MAX;
1887 }
1888
1889 Date aOldLastDate = maLastDate;
1890 ImplSetUserDate( rDate, &aSelection );
1891 maLastDate = aOldLastDate;
1892
1893 // Modify am Edit wird nur bei KeyInput gesetzt...
1894 if ( GetField()->GetText() != aText )
1895 {
1896 GetField()->SetModifyFlag();
1897 GetField()->Modify();
1898 }
1899 }
1900 }
1901
1902 // -----------------------------------------------------------------------
1903
1904 Date DateFormatter::GetDate() const
1905 {
1906 Date aDate( 0, 0, 0 );
1907
1908 if ( GetField() )
1909 {
1910 if ( ImplDateGetValue( GetField()->GetText(), aDate, GetExtDateFormat(TRUE), ImplGetLocaleDataWrapper(), GetCalendarWrapper(), GetFieldSettings() ) )
1911 {
1912 if ( aDate > maMax )
1913 aDate = maMax;
1914 else if ( aDate < maMin )
1915 aDate = maMin;
1916 }
1917 else
1918 {
1919 // !!! TH-18.2.99: Wenn wir Zeit haben sollte einmal
1920 // !!! geklaert werden, warum dieses beim Datum gegenueber
1921 // !!! allen anderen Feldern anders behandelt wird.
1922 // !!! Siehe dazu Bug: 52304
1923
1924 if ( !ImplAllowMalformedInput() )
1925 {
1926 if ( maLastDate.GetDate() )
1927 aDate = maLastDate;
1928 else if ( !IsEmptyFieldValueEnabled() )
1929 aDate = Date();
1930 }
1931 else
1932 aDate = GetInvalidDate();
1933 }
1934 }
1935
1936 return aDate;
1937 }
1938
1939 // -----------------------------------------------------------------------
1940
1941 Date DateFormatter::GetRealDate() const
1942 {
1943 // !!! TH-18.2.99: Wenn wir Zeit haben sollte dieses auch einmal
1944 // !!! fuer die Numeric-Klassen eingebaut werden.
1945
1946 Date aDate( 0, 0, 0 );
1947
1948 if ( GetField() )
1949 {
1950 if ( !ImplDateGetValue( GetField()->GetText(), aDate, GetExtDateFormat(TRUE), ImplGetLocaleDataWrapper(), GetCalendarWrapper(), GetFieldSettings() ) )
1951 if ( ImplAllowMalformedInput() )
1952 aDate = GetInvalidDate();
1953 }
1954
1955 return aDate;
1956 }
1957
1958 // -----------------------------------------------------------------------
1959
1960 void DateFormatter::SetEmptyDate()
1961 {
1962 FormatterBase::SetEmptyFieldValue();
1963 }
1964
1965 // -----------------------------------------------------------------------
1966
1967 BOOL DateFormatter::IsEmptyDate() const
1968 {
1969 BOOL bEmpty = FormatterBase::IsEmptyFieldValue();
1970
1971 if ( GetField() && MustBeReformatted() && IsEmptyFieldValueEnabled() )
1972 {
1973 if ( !GetField()->GetText().Len() )
1974 {
1975 bEmpty = TRUE;
1976 }
1977 else if ( !maLastDate.GetDate() )
1978 {
1979 Date aDate;
1980 bEmpty = !ImplDateGetValue( GetField()->GetText(), aDate, GetExtDateFormat(TRUE), ImplGetLocaleDataWrapper(), GetCalendarWrapper(), GetFieldSettings() );
1981 }
1982 }
1983 return bEmpty;
1984 }
1985
1986 // -----------------------------------------------------------------------
1987
1988 BOOL DateFormatter::IsDateModified() const
1989 {
1990 if ( ImplGetEmptyFieldValue() )
1991 return !IsEmptyDate();
1992 else if ( GetDate() != maFieldDate )
1993 return TRUE;
1994 else
1995 return FALSE;
1996 }
1997
1998 // -----------------------------------------------------------------------
1999
2000 void DateFormatter::Reformat()
2001 {
2002 if ( !GetField() )
2003 return;
2004
2005 if ( !GetField()->GetText().Len() && ImplGetEmptyFieldValue() )
2006 return;
2007
2008 XubString aStr;
2009 BOOL bOK = ImplDateReformat( GetField()->GetText(), aStr, GetFieldSettings() );
2010 if( !bOK )
2011 return;
2012
2013 if ( aStr.Len() )
2014 {
2015 ImplSetText( aStr );
2016 ImplDateGetValue( aStr, maLastDate, GetExtDateFormat(TRUE), ImplGetLocaleDataWrapper(), GetCalendarWrapper(), GetFieldSettings() );
2017 }
2018 else
2019 {
2020 if ( maLastDate.GetDate() )
2021 SetDate( maLastDate );
2022 else if ( !IsEmptyFieldValueEnabled() )
2023 SetDate( Date() );
2024 else
2025 {
2026 ImplSetText( ImplGetSVEmptyStr() );
2027 SetEmptyFieldValueData( TRUE );
2028 }
2029 }
2030 }
2031
2032 // -----------------------------------------------------------------------
2033
2034 void DateFormatter::ExpandCentury( Date& rDate )
2035 {
2036 ExpandCentury( rDate, Application::GetSettings().GetMiscSettings().GetTwoDigitYearStart() );
2037 }
2038
2039 // -----------------------------------------------------------------------
2040
2041 void DateFormatter::ExpandCentury( Date& rDate, USHORT nTwoDigitYearStart )
2042 {
2043 USHORT nDateYear = rDate.GetYear();
2044 if ( nDateYear < 100 )
2045 {
2046 USHORT nCentury = nTwoDigitYearStart / 100;
2047 if ( nDateYear < (nTwoDigitYearStart % 100) )
2048 nCentury++;
2049 rDate.SetYear( nDateYear + (nCentury*100) );
2050 }
2051 }
2052
2053 // -----------------------------------------------------------------------
2054
2055 DateField::DateField( Window* pParent, WinBits nWinStyle ) :
2056 SpinField( pParent, nWinStyle ),
2057 maFirst( GetMin() ),
2058 maLast( GetMax() )
2059 {
2060 SetField( this );
2061 SetText( ImplGetLocaleDataWrapper().getDate( ImplGetFieldDate() ) );
2062 Reformat();
2063 ResetLastDate();
2064 }
2065
2066 // -----------------------------------------------------------------------
2067
2068 DateField::DateField( Window* pParent, const ResId& rResId ) :
2069 SpinField( WINDOW_DATEFIELD ),
2070 maFirst( GetMin() ),
2071 maLast( GetMax() )
2072 {
2073 rResId.SetRT( RSC_DATEFIELD );
2074 WinBits nStyle = ImplInitRes( rResId );
2075 SpinField::ImplInit( pParent, nStyle );
2076 SetField( this );
2077 SetText( ImplGetLocaleDataWrapper().getDate( ImplGetFieldDate() ) );
2078 ImplLoadRes( rResId );
2079
2080 if ( !(nStyle & WB_HIDE ) )
2081 Show();
2082
2083 ResetLastDate();
2084 }
2085
2086 // -----------------------------------------------------------------------
2087
2088 void DateField::ImplLoadRes( const ResId& rResId )
2089 {
2090 SpinField::ImplLoadRes( rResId );
2091
2092 ResMgr* pMgr = rResId.GetResMgr();
2093 if( pMgr )
2094 {
2095 DateFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *pMgr ) );
2096
2097 ULONG nMask = ReadLongRes();
2098 if ( DATEFIELD_FIRST & nMask )
2099 {
2100 maFirst = Date( ResId( (RSHEADER_TYPE *)GetClassRes(), *pMgr ) );
2101 IncrementRes( GetObjSizeRes( (RSHEADER_TYPE *)GetClassRes() ) );
2102 }
2103 if ( DATEFIELD_LAST & nMask )
2104 {
2105 maLast = Date( ResId( (RSHEADER_TYPE *)GetClassRes(), *pMgr ) );
2106 IncrementRes( GetObjSizeRes( (RSHEADER_TYPE *)GetClassRes() ) );
2107 }
2108 }
2109
2110 Reformat();
2111 }
2112
2113 // -----------------------------------------------------------------------
2114
2115 DateField::~DateField()
2116 {
2117 }
2118
2119 // -----------------------------------------------------------------------
2120
2121 long DateField::PreNotify( NotifyEvent& rNEvt )
2122 {
2123 if ( (rNEvt.GetType() == EVENT_KEYINPUT) && IsStrictFormat() &&
2124 ( GetExtDateFormat() != XTDATEF_SYSTEM_LONG ) &&
2125 !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
2126 {
2127 if ( ImplDateProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), GetExtDateFormat( TRUE ), ImplGetLocaleDataWrapper() ) )
2128 return 1;
2129 }
2130
2131 return SpinField::PreNotify( rNEvt );
2132 }
2133
2134 // -----------------------------------------------------------------------
2135
2136 long DateField::Notify( NotifyEvent& rNEvt )
2137 {
2138 if ( rNEvt.GetType() == EVENT_GETFOCUS )
2139 MarkToBeReformatted( FALSE );
2140 else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
2141 {
2142 if ( MustBeReformatted() )
2143 {
2144 // !!! TH-18.2.99: Wenn wir Zeit haben sollte einmal
2145 // !!! geklaert werden, warum dieses beim Datum gegenueber
2146 // !!! allen anderen Feldern anders behandelt wird.
2147 // !!! Siehe dazu Bug: 52304
2148
2149 BOOL bTextLen = GetText().Len() != 0;
2150 if ( bTextLen || !IsEmptyFieldValueEnabled() )
2151 {
2152 if ( !ImplAllowMalformedInput() )
2153 Reformat();
2154 else
2155 {
2156 Date aDate( 0, 0, 0 );
2157 if ( ImplDateGetValue( GetText(), aDate, GetExtDateFormat(TRUE), ImplGetLocaleDataWrapper(), GetCalendarWrapper(), GetFieldSettings() ) )
2158 // even with strict text analysis, our text is a valid date -> do a complete
2159 // reformat
2160 Reformat();
2161 }
2162 }
2163 else if ( !bTextLen && IsEmptyFieldValueEnabled() )
2164 {
2165 ResetLastDate();
2166 SetEmptyFieldValueData( TRUE );
2167 }
2168 }
2169 }
2170
2171 return SpinField::Notify( rNEvt );
2172 }
2173
2174 // -----------------------------------------------------------------------
2175
2176 void DateField::DataChanged( const DataChangedEvent& rDCEvt )
2177 {
2178 SpinField::DataChanged( rDCEvt );
2179
2180 if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & (SETTINGS_LOCALE|SETTINGS_MISC)) )
2181 {
2182 if ( IsDefaultLocale() && ( rDCEvt.GetFlags() & SETTINGS_LOCALE ) )
2183 ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
2184 ReformatAll();
2185 }
2186 }
2187
2188 // -----------------------------------------------------------------------
2189
2190 void DateField::Modify()
2191 {
2192 MarkToBeReformatted( TRUE );
2193 SpinField::Modify();
2194 }
2195
2196 // -----------------------------------------------------------------------
2197
2198 void DateField::Up()
2199 {
2200 ImplDateSpinArea( TRUE );
2201 SpinField::Up();
2202 }
2203
2204 // -----------------------------------------------------------------------
2205
2206 void DateField::Down()
2207 {
2208 ImplDateSpinArea( FALSE );
2209 SpinField::Down();
2210 }
2211
2212 // -----------------------------------------------------------------------
2213
2214 void DateField::First()
2215 {
2216 ImplNewFieldValue( maFirst );
2217 SpinField::First();
2218 }
2219
2220 // -----------------------------------------------------------------------
2221
2222 void DateField::Last()
2223 {
2224 ImplNewFieldValue( maLast );
2225 SpinField::Last();
2226 }
2227
2228 // -----------------------------------------------------------------------
2229
2230 DateBox::DateBox( Window* pParent, WinBits nWinStyle ) :
2231 ComboBox( pParent, nWinStyle )
2232 {
2233 SetField( this );
2234 SetText( ImplGetLocaleDataWrapper().getDate( ImplGetFieldDate() ) );
2235 Reformat();
2236 }
2237
2238 // -----------------------------------------------------------------------
2239
2240 DateBox::DateBox( Window* pParent, const ResId& rResId ) :
2241 ComboBox( WINDOW_DATEBOX )
2242 {
2243 rResId.SetRT( RSC_DATEBOX );
2244 WinBits nStyle = ImplInitRes( rResId );
2245 ComboBox::ImplInit( pParent, nStyle );
2246 SetField( this );
2247 SetText( ImplGetLocaleDataWrapper().getDate( ImplGetFieldDate() ) );
2248 ComboBox::ImplLoadRes( rResId );
2249 ResMgr* pMgr = rResId.GetResMgr();
2250 if( pMgr )
2251 DateFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *pMgr ) );
2252 Reformat();
2253
2254 if ( !( nStyle & WB_HIDE ) )
2255 Show();
2256 }
2257
2258 // -----------------------------------------------------------------------
2259
2260 DateBox::~DateBox()
2261 {
2262 }
2263
2264 // -----------------------------------------------------------------------
2265
2266 long DateBox::PreNotify( NotifyEvent& rNEvt )
2267 {
2268 if ( (rNEvt.GetType() == EVENT_KEYINPUT) && IsStrictFormat() &&
2269 ( GetExtDateFormat() != XTDATEF_SYSTEM_LONG ) &&
2270 !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
2271 {
2272 if ( ImplDateProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), GetExtDateFormat( TRUE ), ImplGetLocaleDataWrapper() ) )
2273 return 1;
2274 }
2275
2276 return ComboBox::PreNotify( rNEvt );
2277 }
2278
2279 // -----------------------------------------------------------------------
2280
2281 void DateBox::DataChanged( const DataChangedEvent& rDCEvt )
2282 {
2283 ComboBox::DataChanged( rDCEvt );
2284
2285 if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
2286 {
2287 if ( IsDefaultLocale() )
2288 ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
2289 ReformatAll();
2290 }
2291 }
2292
2293 // -----------------------------------------------------------------------
2294
2295 long DateBox::Notify( NotifyEvent& rNEvt )
2296 {
2297 if ( rNEvt.GetType() == EVENT_GETFOCUS )
2298 MarkToBeReformatted( FALSE );
2299 else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
2300 {
2301 if ( MustBeReformatted() )
2302 {
2303 BOOL bTextLen = GetText().Len() != 0;
2304 if ( bTextLen || !IsEmptyFieldValueEnabled() )
2305 Reformat();
2306 else if ( !bTextLen && IsEmptyFieldValueEnabled() )
2307 {
2308 ResetLastDate();
2309 SetEmptyFieldValueData( TRUE );
2310 }
2311 }
2312 }
2313
2314 return ComboBox::Notify( rNEvt );
2315 }
2316
2317 // -----------------------------------------------------------------------
2318
2319 void DateBox::Modify()
2320 {
2321 MarkToBeReformatted( TRUE );
2322 ComboBox::Modify();
2323 }
2324
2325 // -----------------------------------------------------------------------
2326
2327 void DateBox::ReformatAll()
2328 {
2329 XubString aStr;
2330 SetUpdateMode( FALSE );
2331 USHORT nEntryCount = GetEntryCount();
2332 for ( USHORT i=0; i < nEntryCount; i++ )
2333 {
2334 ImplDateReformat( GetEntry( i ), aStr, GetFieldSettings() );
2335 RemoveEntry( i );
2336 InsertEntry( aStr, i );
2337 }
2338 DateFormatter::Reformat();
2339 SetUpdateMode( TRUE );
2340 }
2341
2342 // -----------------------------------------------------------------------
2343
2344 void DateBox::InsertDate( const Date& rDate, USHORT nPos )
2345 {
2346 Date aDate = rDate;
2347 if ( aDate > GetMax() )
2348 aDate = GetMax();
2349 else if ( aDate < GetMin() )
2350 aDate = GetMin();
2351
2352 ComboBox::InsertEntry( ImplGetDateAsText( aDate, GetFieldSettings() ), nPos );
2353 }
2354
2355 // -----------------------------------------------------------------------
2356
2357 void DateBox::RemoveDate( const Date& rDate )
2358 {
2359 ComboBox::RemoveEntry( ImplGetDateAsText( rDate, GetFieldSettings() ) );
2360 }
2361
2362 // -----------------------------------------------------------------------
2363
2364 Date DateBox::GetDate( USHORT nPos ) const
2365 {
2366 Date aDate( 0, 0, 0 );
2367 ImplDateGetValue( ComboBox::GetEntry( nPos ), aDate, GetExtDateFormat(TRUE), ImplGetLocaleDataWrapper(), GetCalendarWrapper(), GetSettings() );
2368 return aDate;
2369 }
2370
2371 // -----------------------------------------------------------------------
2372
2373 USHORT DateBox::GetDatePos( const Date& rDate ) const
2374 {
2375 XubString aStr;
2376 if ( IsLongFormat() )
2377 aStr = ImplGetLocaleDataWrapper().getLongDate( rDate, GetCalendarWrapper(), 1, FALSE, 1, !IsShowDateCentury() );
2378 else
2379 aStr = ImplGetLocaleDataWrapper().getDate( rDate );
2380 return ComboBox::GetEntryPos( aStr );
2381 }
2382
2383 // -----------------------------------------------------------------------
2384
2385 static BOOL ImplTimeProcessKeyInput( Edit*, const KeyEvent& rKEvt,
2386 BOOL bStrictFormat, BOOL bDuration,
2387 TimeFieldFormat eFormat,
2388 const LocaleDataWrapper& rLocaleDataWrapper )
2389 {
2390 xub_Unicode cChar = rKEvt.GetCharCode();
2391
2392 if ( !bStrictFormat )
2393 return FALSE;
2394 else
2395 {
2396 USHORT nGroup = rKEvt.GetKeyCode().GetGroup();
2397 if ( (nGroup == KEYGROUP_FKEYS) || (nGroup == KEYGROUP_CURSOR) ||
2398 (nGroup == KEYGROUP_MISC) ||
2399 ((cChar >= '0') && (cChar <= '9')) ||
2400 (cChar == rLocaleDataWrapper.getTimeSep()) ||
2401 ( ( rLocaleDataWrapper.getTimeAM().Search( cChar ) != STRING_NOTFOUND ) ) ||
2402 ( ( rLocaleDataWrapper.getTimePM().Search( cChar ) != STRING_NOTFOUND ) ) ||
2403 // Accept AM/PM:
2404 (cChar == 'a') || (cChar == 'A') || (cChar == 'm') || (cChar == 'M') || (cChar == 'p') || (cChar == 'P') ||
2405 ((eFormat == TIMEF_100TH_SEC) && (cChar == rLocaleDataWrapper.getTime100SecSep())) ||
2406 ((eFormat == TIMEF_SEC_CS) && (cChar == rLocaleDataWrapper.getTime100SecSep())) ||
2407 (bDuration && (cChar == '-')) )
2408 return FALSE;
2409 else
2410 return TRUE;
2411 }
2412 }
2413
2414 // -----------------------------------------------------------------------
2415
2416 static BOOL ImplIsOnlyDigits( const String& _rStr )
2417 {
2418 const sal_Unicode* _pChr = _rStr.GetBuffer();
2419 for ( xub_StrLen i = 0; i < _rStr.Len(); ++i, ++_pChr )
2420 {
2421 if ( *_pChr < '0' || *_pChr > '9' )
2422 return FALSE;
2423 }
2424 return TRUE;
2425 }
2426
2427 // -----------------------------------------------------------------------
2428
2429 static BOOL ImplIsValidTimePortion( BOOL _bSkipInvalidCharacters, const String& _rStr )
2430 {
2431 if ( !_bSkipInvalidCharacters )
2432 {
2433 if ( ( _rStr.Len() > 2 ) || ( _rStr.Len() < 1 ) || !ImplIsOnlyDigits( _rStr ) )
2434 return FALSE;
2435 }
2436 return TRUE;
2437 }
2438
2439 // -----------------------------------------------------------------------
2440
2441 static BOOL ImplCutTimePortion( String& _rStr, xub_StrLen _nSepPos, BOOL _bSkipInvalidCharacters, short* _pPortion )
2442 {
2443 String sPortion = _rStr.Copy( 0, _nSepPos );
2444 _rStr.Erase( 0, _nSepPos + 1 );
2445
2446 if ( !ImplIsValidTimePortion( _bSkipInvalidCharacters, sPortion ) )
2447 return FALSE;
2448 *_pPortion = (short)sPortion.ToInt32();
2449 return TRUE;
2450 }
2451
2452 // -----------------------------------------------------------------------
2453
2454 static BOOL ImplTimeGetValue( const XubString& rStr, Time& rTime,
2455 TimeFieldFormat eFormat, BOOL bDuration,
2456 const LocaleDataWrapper& rLocaleDataWrapper, BOOL _bSkipInvalidCharacters = TRUE )
2457 {
2458 XubString aStr = rStr;
2459 short nHour = 0;
2460 short nMinute = 0;
2461 short nSecond = 0;
2462 short n100Sec = 0;
2463 Time aTime( 0, 0, 0 );
2464
2465 if ( !rStr.Len() )
2466 return FALSE;
2467
2468 // Nach Separatoren suchen
2469 if ( rLocaleDataWrapper.getTimeSep().Len() )
2470 {
2471 XubString aSepStr( RTL_CONSTASCII_USTRINGPARAM( ",.;:/" ) );
2472 if ( !bDuration )
2473 aSepStr.Append( '-' );
2474
2475 // Die obigen Zeichen durch das Separatorzeichen ersetzen
2476 for ( xub_StrLen i = 0; i < aSepStr.Len(); i++ )
2477 {
2478 if ( aSepStr.GetChar( i ) == rLocaleDataWrapper.getTimeSep() )
2479 continue;
2480 for ( xub_StrLen j = 0; j < aStr.Len(); j++ )
2481 {
2482 if ( aStr.GetChar( j ) == aSepStr.GetChar( i ) )
2483 aStr.SetChar( j, rLocaleDataWrapper.getTimeSep().GetChar(0) );
2484 }
2485 }
2486 }
2487
2488 BOOL bNegative = FALSE;
2489 xub_StrLen nSepPos = aStr.Search( rLocaleDataWrapper.getTimeSep() );
2490 if ( aStr.GetChar( 0 ) == '-' )
2491 bNegative = TRUE;
2492 if ( eFormat != TIMEF_SEC_CS )
2493 {
2494 if ( nSepPos == STRING_NOTFOUND )
2495 nSepPos = aStr.Len();
2496 if ( !ImplCutTimePortion( aStr, nSepPos, _bSkipInvalidCharacters, &nHour ) )
2497 return FALSE;
2498
2499 nSepPos = aStr.Search( rLocaleDataWrapper.getTimeSep() );
2500 if ( aStr.GetChar( 0 ) == '-' )
2501 bNegative = TRUE;
2502 if ( nSepPos != STRING_NOTFOUND )
2503 {
2504 if ( !ImplCutTimePortion( aStr, nSepPos, _bSkipInvalidCharacters, &nMinute ) )
2505 return FALSE;
2506
2507 nSepPos = aStr.Search( rLocaleDataWrapper.getTimeSep() );
2508 if ( aStr.GetChar( 0 ) == '-' )
2509 bNegative = TRUE;
2510 if ( nSepPos != STRING_NOTFOUND )
2511 {
2512 if ( !ImplCutTimePortion( aStr, nSepPos, _bSkipInvalidCharacters, &nSecond ) )
2513 return FALSE;
2514 if ( aStr.GetChar( 0 ) == '-' )
2515 bNegative = TRUE;
2516 n100Sec = (short)aStr.ToInt32();
2517 }
2518 else
2519 nSecond = (short)aStr.ToInt32();
2520 }
2521 else
2522 nMinute = (short)aStr.ToInt32();
2523 }
2524 else if ( nSepPos == STRING_NOTFOUND )
2525 {
2526 nSecond = (short)aStr.ToInt32();
2527 nMinute += nSecond / 60;
2528 nSecond %= 60;
2529 nHour += nMinute / 60;
2530 nMinute %= 60;
2531 }
2532 else
2533 {
2534 nSecond = (short)aStr.Copy( 0, nSepPos ).ToInt32();
2535 aStr.Erase( 0, nSepPos+1 );
2536
2537 nSepPos = aStr.Search( rLocaleDataWrapper.getTimeSep() );
2538 if ( aStr.GetChar( 0 ) == '-' )
2539 bNegative = TRUE;
2540 if ( nSepPos != STRING_NOTFOUND )
2541 {
2542 nMinute = nSecond;
2543 nSecond = (short)aStr.Copy( 0, nSepPos ).ToInt32();
2544 aStr.Erase( 0, nSepPos+1 );
2545
2546 nSepPos = aStr.Search( rLocaleDataWrapper.getTimeSep() );
2547 if ( aStr.GetChar( 0 ) == '-' )
2548 bNegative = TRUE;
2549 if ( nSepPos != STRING_NOTFOUND )
2550 {
2551 nHour = nMinute;
2552 nMinute = nSecond;
2553 nSecond = (short)aStr.Copy( 0, nSepPos ).ToInt32();
2554 aStr.Erase( 0, nSepPos+1 );
2555 }
2556 else
2557 {
2558 nHour += nMinute / 60;
2559 nMinute %= 60;
2560 }
2561 }
2562 else
2563 {
2564 nMinute += nSecond / 60;
2565 nSecond %= 60;
2566 nHour += nMinute / 60;
2567 nMinute %= 60;
2568 }
2569 n100Sec = (short)aStr.ToInt32();
2570
2571 if ( n100Sec )
2572 {
2573 xub_StrLen nLen = 1; // mindestens eine Ziffer, weil sonst n100Sec==0
2574
2575 while ( aStr.GetChar(nLen) >= '0' && aStr.GetChar(nLen) <= '9' )
2576 nLen++;
2577
2578 if ( nLen > 2 )
2579 {
2580 while( nLen > 3 )
2581 {
2582 n100Sec = n100Sec / 10;
2583 nLen--;
2584 }
2585 // Rundung bei negativen Zahlen???
2586 n100Sec = (n100Sec + 5) / 10;
2587 }
2588 else
2589 {
2590 while( nLen < 2 )
2591 {
2592 n100Sec = n100Sec * 10;
2593 nLen++;
2594 }
2595 }
2596 }
2597 }
2598
2599 if ( (nMinute > 59) || (nSecond > 59) || (n100Sec > 100) )
2600 return FALSE;
2601
2602 if ( eFormat == TIMEF_NONE )
2603 nSecond = n100Sec = 0;
2604 else if ( eFormat == TIMEF_SEC )
2605 n100Sec = 0;
2606
2607 if ( !bDuration )
2608 {
2609 if ( bNegative || (nHour < 0) || (nMinute < 0) ||
2610 (nSecond < 0) || (n100Sec < 0) )
2611 return FALSE;
2612
2613 aStr.ToUpperAscii();
2614 XubString aAM( rLocaleDataWrapper.getTimeAM() );
2615 XubString aPM( rLocaleDataWrapper.getTimePM() );
2616 aAM.ToUpperAscii();
2617 aPM.ToUpperAscii();
2618 XubString aAM2( RTL_CONSTASCII_USTRINGPARAM( "AM" ) ); // aAM is localized
2619 XubString aPM2( RTL_CONSTASCII_USTRINGPARAM( "PM" ) ); // aPM is localized
2620
2621 if ( (nHour < 12) && ( ( aStr.Search( aPM ) != STRING_NOTFOUND ) || ( aStr.Search( aPM2 ) != STRING_NOTFOUND ) ) )
2622 nHour += 12;
2623
2624 if ( (nHour == 12) && ( ( aStr.Search( aAM ) != STRING_NOTFOUND ) || ( aStr.Search( aAM2 ) != STRING_NOTFOUND ) ) )
2625 nHour = 0;
2626
2627 aTime = Time( (USHORT)nHour, (USHORT)nMinute, (USHORT)nSecond,
2628 (USHORT)n100Sec );
2629 }
2630 else
2631 {
2632 if ( bNegative || (nHour < 0) || (nMinute < 0) ||
2633 (nSecond < 0) || (n100Sec < 0) )
2634 {
2635 bNegative = TRUE;
2636 nHour = nHour < 0 ? -nHour : nHour;
2637 nMinute = nMinute < 0 ? -nMinute : nMinute;
2638 nSecond = nSecond < 0 ? -nSecond : nSecond;
2639 n100Sec = n100Sec < 0 ? -n100Sec : n100Sec;
2640 }
2641
2642 aTime = Time( (USHORT)nHour, (USHORT)nMinute, (USHORT)nSecond,
2643 (USHORT)n100Sec );
2644 if ( bNegative )
2645 aTime = -aTime;
2646 }
2647
2648 rTime = aTime;
2649
2650 return TRUE;
2651 }
2652
2653 // -----------------------------------------------------------------------
2654
2655 BOOL TimeFormatter::ImplTimeReformat( const XubString& rStr, XubString& rOutStr )
2656 {
2657 Time aTime( 0, 0, 0 );
2658 if ( !ImplTimeGetValue( rStr, aTime, GetFormat(), IsDuration(), ImplGetLocaleDataWrapper() ) )
2659 return TRUE;
2660
2661 Time aTempTime = aTime;
2662 if ( aTempTime > GetMax() )
2663 aTempTime = GetMax() ;
2664 else if ( aTempTime < GetMin() )
2665 aTempTime = GetMin();
2666
2667 if ( GetErrorHdl().IsSet() && (aTime != aTempTime) )
2668 {
2669 maCorrectedTime = aTempTime;
2670 if ( !GetErrorHdl().Call( this ) )
2671 {
2672 maCorrectedTime = Time();
2673 return FALSE;
2674 }
2675 else
2676 maCorrectedTime = Time();
2677 }
2678
2679 BOOL bSecond = FALSE;
2680 BOOL b100Sec = FALSE;
2681 if ( meFormat != TIMEF_NONE )
2682 bSecond = TRUE;
2683 if ( meFormat == TIMEF_100TH_SEC )
2684 b100Sec = TRUE;
2685
2686 if ( meFormat == TIMEF_SEC_CS )
2687 {
2688 ULONG n = aTempTime.GetHour() * 3600L;
2689 n += aTempTime.GetMin() * 60L;
2690 n += aTempTime.GetSec();
2691 rOutStr = String::CreateFromInt32( n );
2692 rOutStr += ImplGetLocaleDataWrapper().getTime100SecSep();
2693 if ( aTempTime.Get100Sec() < 10 )
2694 rOutStr += '0';
2695 rOutStr += String::CreateFromInt32( aTempTime.Get100Sec() );
2696 }
2697 else if ( mbDuration )
2698 rOutStr = ImplGetLocaleDataWrapper().getDuration( aTempTime, bSecond, b100Sec );
2699 else
2700 {
2701 rOutStr = ImplGetLocaleDataWrapper().getTime( aTempTime, bSecond, b100Sec );
2702 if ( GetTimeFormat() == HOUR_12 )
2703 {
2704 if ( aTempTime.GetHour() > 12 )
2705 {
2706 Time aT( aTempTime );
2707 aT.SetHour( aT.GetHour() % 12 );
2708 rOutStr = ImplGetLocaleDataWrapper().getTime( aT, bSecond, b100Sec );
2709 }
2710 // Don't use LocaleDataWrapper, we want AM/PM
2711 if ( aTempTime.GetHour() < 12 )
2712 rOutStr += String( RTL_CONSTASCII_USTRINGPARAM( "AM" ) ); // ImplGetLocaleDataWrapper().getTimeAM();
2713 else
2714 rOutStr += String( RTL_CONSTASCII_USTRINGPARAM( "PM" ) ); // ImplGetLocaleDataWrapper().getTimePM();
2715 }
2716 }
2717
2718 return TRUE;
2719 }
2720
2721 // -----------------------------------------------------------------------
2722 BOOL TimeFormatter::ImplAllowMalformedInput() const
2723 {
2724 return !IsEnforceValidValue();
2725 }
2726
2727 // -----------------------------------------------------------------------
2728
2729 void TimeField::ImplTimeSpinArea( BOOL bUp )
2730 {
2731 if ( GetField() )
2732 {
2733 xub_StrLen nTimeArea = 0;
2734 Time aTime( GetTime() );
2735 XubString aText( GetText() );
2736 Selection aSelection( GetField()->GetSelection() );
2737
2738 // Area suchen
2739 if ( GetFormat() != TIMEF_SEC_CS )
2740 {
2741 for ( xub_StrLen i = 1, nPos = 0; i <= 4; i++ )
2742 {
2743 xub_StrLen nPos1 = aText.Search( ImplGetLocaleDataWrapper().getTimeSep(), nPos );
2744 xub_StrLen nPos2 = aText.Search( ImplGetLocaleDataWrapper().getTime100SecSep(), nPos );
2745 nPos = nPos1 < nPos2 ? nPos1 : nPos2;
2746 if ( nPos >= (xub_StrLen)aSelection.Max() )
2747 {
2748 nTimeArea = i;
2749 break;
2750 }
2751 else
2752 nPos++;
2753 }
2754 }
2755 else
2756 {
2757 xub_StrLen nPos = aText.Search( ImplGetLocaleDataWrapper().getTime100SecSep() );
2758 if ( nPos == STRING_NOTFOUND || nPos >= (xub_StrLen)aSelection.Max() )
2759 nTimeArea = 3;
2760 else
2761 nTimeArea = 4;
2762 }
2763
2764 if ( nTimeArea )
2765 {
2766 Time aAddTime( 0, 0, 0 );
2767 if ( nTimeArea == 1 )
2768 aAddTime = Time( 1, 0 );
2769 else if ( nTimeArea == 2 )
2770 aAddTime = Time( 0, 1 );
2771 else if ( nTimeArea == 3 )
2772 aAddTime = Time( 0, 0, 1 );
2773 else if ( nTimeArea == 4 )
2774 aAddTime = Time( 0, 0, 0, 1 );
2775
2776 if ( !bUp )
2777 aAddTime = -aAddTime;
2778
2779 aTime += aAddTime;
2780 if ( !IsDuration() )
2781 {
2782 Time aAbsMaxTime( 23, 59, 59, 99 );
2783 if ( aTime > aAbsMaxTime )
2784 aTime = aAbsMaxTime;
2785 Time aAbsMinTime( 0, 0 );
2786 if ( aTime < aAbsMinTime )
2787 aTime = aAbsMinTime;
2788 }
2789 ImplNewFieldValue( aTime );
2790 }
2791
2792 }
2793 }
2794
2795 // -----------------------------------------------------------------------
2796
2797 void TimeFormatter::ImplInit()
2798 {
2799 meFormat = TIMEF_NONE;
2800 mbDuration = FALSE;
2801 mnTimeFormat = HOUR_24; // Should become a ExtTimeFieldFormat in next implementation, merge with mbDuration and meFormat
2802 }
2803
2804 // -----------------------------------------------------------------------
2805
2806 TimeFormatter::TimeFormatter() :
2807 maLastTime( 0, 0 ),
2808 maMin( 0, 0 ),
2809 maMax( 23, 59, 59, 99 ),
2810 mbEnforceValidValue( TRUE ),
2811 maFieldTime( 0, 0 )
2812 {
2813 ImplInit();
2814 }
2815
2816 // -----------------------------------------------------------------------
2817
2818 void TimeFormatter::ImplLoadRes( const ResId& rResId )
2819 {
2820 ResMgr* pMgr = rResId.GetResMgr();
2821 if( pMgr )
2822 {
2823 ULONG nMask = pMgr->ReadLong();
2824
2825 if ( TIMEFORMATTER_MIN & nMask )
2826 {
2827 SetMin( Time( ResId( (RSHEADER_TYPE *)pMgr->GetClass(), *pMgr ) ) );
2828 pMgr->Increment( pMgr->GetObjSize( (RSHEADER_TYPE *)pMgr->GetClass() ) );
2829 }
2830
2831 if ( TIMEFORMATTER_MAX & nMask )
2832 {
2833 SetMax( Time( ResId( (RSHEADER_TYPE *)pMgr->GetClass(), *pMgr ) ) );
2834 pMgr->Increment( pMgr->GetObjSize( (RSHEADER_TYPE *)pMgr->GetClass() ) );
2835 }
2836
2837 if ( TIMEFORMATTER_TIMEFIELDFORMAT & nMask )
2838 meFormat = (TimeFieldFormat)pMgr->ReadLong();
2839
2840 if ( TIMEFORMATTER_DURATION & nMask )
2841 mbDuration = (BOOL)pMgr->ReadShort();
2842
2843 if ( TIMEFORMATTER_STRICTFORMAT & nMask )
2844 SetStrictFormat( (BOOL)pMgr->ReadShort() );
2845
2846 if ( TIMEFORMATTER_VALUE & nMask )
2847 {
2848 maFieldTime = Time( ResId( (RSHEADER_TYPE *)pMgr->GetClass(), *pMgr ) );
2849 if ( maFieldTime > GetMax() )
2850 maFieldTime = GetMax();
2851 if ( maFieldTime < GetMin() )
2852 maFieldTime = GetMin();
2853 maLastTime = maFieldTime;
2854
2855 pMgr->Increment( pMgr->GetObjSize( (RSHEADER_TYPE *)pMgr->GetClass() ) );
2856 }
2857 }
2858 }
2859
2860 // -----------------------------------------------------------------------
2861
2862 TimeFormatter::~TimeFormatter()
2863 {
2864 }
2865
2866 // -----------------------------------------------------------------------
2867
2868 void TimeFormatter::ReformatAll()
2869 {
2870 Reformat();
2871 }
2872
2873 // -----------------------------------------------------------------------
2874
2875 void TimeFormatter::SetMin( const Time& rNewMin )
2876 {
2877 maMin = rNewMin;
2878 if ( !IsEmptyFieldValue() )
2879 ReformatAll();
2880 }
2881
2882 // -----------------------------------------------------------------------
2883
2884 void TimeFormatter::SetMax( const Time& rNewMax )
2885 {
2886 maMax = rNewMax;
2887 if ( !IsEmptyFieldValue() )
2888 ReformatAll();
2889 }
2890
2891 // -----------------------------------------------------------------------
2892
2893 void TimeFormatter::SetTimeFormat( TimeFormatter::TimeFormat eNewFormat )
2894 {
2895 mnTimeFormat = sal::static_int_cast<USHORT>(eNewFormat);
2896 }
2897
2898 // -----------------------------------------------------------------------
2899
2900 TimeFormatter::TimeFormat TimeFormatter::GetTimeFormat() const
2901 {
2902 return (TimeFormat)mnTimeFormat;
2903 }
2904
2905 // -----------------------------------------------------------------------
2906
2907 void TimeFormatter::SetFormat( TimeFieldFormat eNewFormat )
2908 {
2909 meFormat = eNewFormat;
2910 ReformatAll();
2911 }
2912
2913 // -----------------------------------------------------------------------
2914
2915 void TimeFormatter::SetDuration( BOOL bNewDuration )
2916 {
2917 mbDuration = bNewDuration;
2918 ReformatAll();
2919 }
2920
2921 // -----------------------------------------------------------------------
2922
2923 void TimeFormatter::SetTime( const Time& rNewTime )
2924 {
2925 SetUserTime( rNewTime );
2926 maFieldTime = maLastTime;
2927 SetEmptyFieldValueData( FALSE );
2928 }
2929
2930 // -----------------------------------------------------------------------
2931
2932 void TimeFormatter::ImplNewFieldValue( const Time& rTime )
2933 {
2934 if ( GetField() )
2935 {
2936 Selection aSelection = GetField()->GetSelection();
2937 aSelection.Justify();
2938 XubString aText = GetField()->GetText();
2939 // Wenn bis ans Ende selektiert war, soll das auch so bleiben...
2940 if ( (xub_StrLen)aSelection.Max() == aText.Len() )
2941 {
2942 if ( !aSelection.Len() )
2943 aSelection.Min() = SELECTION_MAX;
2944 aSelection.Max() = SELECTION_MAX;
2945 }
2946
2947 Time aOldLastTime = maLastTime;
2948 ImplSetUserTime( rTime, &aSelection );
2949 maLastTime = aOldLastTime;
2950
2951 // Modify am Edit wird nur bei KeyInput gesetzt...
2952 if ( GetField()->GetText() != aText )
2953 {
2954 GetField()->SetModifyFlag();
2955 GetField()->Modify();
2956 }
2957 }
2958 }
2959
2960 // -----------------------------------------------------------------------
2961
2962 void TimeFormatter::ImplSetUserTime( const Time& rNewTime, Selection* pNewSelection )
2963 {
2964 Time aNewTime = rNewTime;
2965 if ( aNewTime > GetMax() )
2966 aNewTime = GetMax();
2967 else if ( aNewTime < GetMin() )
2968 aNewTime = GetMin();
2969 maLastTime = aNewTime;
2970
2971 if ( GetField() )
2972 {
2973 XubString aStr;
2974 BOOL bSec = FALSE;
2975 BOOL b100Sec = FALSE;
2976 if ( meFormat != TIMEF_NONE )
2977 bSec = TRUE;
2978 if ( meFormat == TIMEF_100TH_SEC || meFormat == TIMEF_SEC_CS )
2979 b100Sec = TRUE;
2980 if ( meFormat == TIMEF_SEC_CS )
2981 {
2982 ULONG n = aNewTime.GetHour() * 3600L;
2983 n += aNewTime.GetMin() * 60L;
2984 n += aNewTime.GetSec();
2985 aStr = String::CreateFromInt32( n );
2986 aStr += ImplGetLocaleDataWrapper().getTime100SecSep();
2987 if ( aNewTime.Get100Sec() < 10 )
2988 aStr += '0';
2989 aStr += String::CreateFromInt32( aNewTime.Get100Sec() );
2990 }
2991 else if ( mbDuration )
2992 {
2993 aStr = ImplGetLocaleDataWrapper().getDuration( aNewTime, bSec, b100Sec );
2994 }
2995 else
2996 {
2997 aStr = ImplGetLocaleDataWrapper().getTime( aNewTime, bSec, b100Sec );
2998 if ( GetTimeFormat() == HOUR_12 )
2999 {
3000 if ( aNewTime.GetHour() > 12 )
3001 {
3002 Time aT( aNewTime );
3003 aT.SetHour( aT.GetHour() % 12 );
3004 aStr = ImplGetLocaleDataWrapper().getTime( aT, bSec, b100Sec );
3005 }
3006 // Don't use LocaleDataWrapper, we want AM/PM
3007 if ( aNewTime.GetHour() < 12 )
3008 aStr += String( RTL_CONSTASCII_USTRINGPARAM( "AM" ) ); // ImplGetLocaleDataWrapper().getTimeAM();
3009 else
3010 aStr += String( RTL_CONSTASCII_USTRINGPARAM( "PM" ) ); // ImplGetLocaleDataWrapper().getTimePM();
3011 }
3012 }
3013
3014 ImplSetText( aStr, pNewSelection );
3015 }
3016 }
3017
3018 // -----------------------------------------------------------------------
3019
3020 void TimeFormatter::SetUserTime( const Time& rNewTime )
3021 {
3022 ImplSetUserTime( rNewTime );
3023 }
3024
3025 // -----------------------------------------------------------------------
3026
3027 Time TimeFormatter::GetTime() const
3028 {
3029 Time aTime( 0, 0, 0 );
3030
3031 if ( GetField() )
3032 {
3033 BOOL bAllowMailformed = ImplAllowMalformedInput();
3034 if ( ImplTimeGetValue( GetField()->GetText(), aTime, GetFormat(), IsDuration(), ImplGetLocaleDataWrapper(), !bAllowMailformed ) )
3035 {
3036 if ( aTime > GetMax() )
3037 aTime = GetMax();
3038 else if ( aTime < GetMin() )
3039 aTime = GetMin();
3040 }
3041 else
3042 {
3043 if ( bAllowMailformed )
3044 aTime = GetInvalidTime();
3045 else
3046 aTime = maLastTime;
3047 }
3048 }
3049
3050 return aTime;
3051 }
3052
3053 // -----------------------------------------------------------------------
3054
3055 Time TimeFormatter::GetRealTime() const
3056 {
3057 Time aTime( 0, 0, 0 );
3058
3059 if ( GetField() )
3060 {
3061 BOOL bAllowMailformed = ImplAllowMalformedInput();
3062 if ( !ImplTimeGetValue( GetField()->GetText(), aTime, GetFormat(), IsDuration(), ImplGetLocaleDataWrapper(), !bAllowMailformed ) )
3063 if ( bAllowMailformed )
3064 aTime = GetInvalidTime();
3065 }
3066
3067 return aTime;
3068 }
3069
3070 // -----------------------------------------------------------------------
3071
3072 BOOL TimeFormatter::IsTimeModified() const
3073 {
3074 if ( ImplGetEmptyFieldValue() )
3075 return !IsEmptyTime();
3076 else if ( GetTime() != maFieldTime )
3077 return TRUE;
3078 else
3079 return FALSE;
3080 }
3081
3082 // -----------------------------------------------------------------------
3083
3084 void TimeFormatter::Reformat()
3085 {
3086 if ( !GetField() )
3087 return;
3088
3089 if ( !GetField()->GetText().Len() && ImplGetEmptyFieldValue() )
3090 return;
3091
3092 XubString aStr;
3093 BOOL bOK = ImplTimeReformat( GetField()->GetText(), aStr );
3094 if ( !bOK )
3095 return;
3096
3097 if ( aStr.Len() )
3098 {
3099 ImplSetText( aStr );
3100 ImplTimeGetValue( aStr, maLastTime, GetFormat(), IsDuration(), ImplGetLocaleDataWrapper() );
3101 }
3102 else
3103 SetTime( maLastTime );
3104 }
3105
3106 // -----------------------------------------------------------------------
3107
3108 TimeField::TimeField( Window* pParent, WinBits nWinStyle ) :
3109 SpinField( pParent, nWinStyle ),
3110 maFirst( GetMin() ),
3111 maLast( GetMax() )
3112 {
3113 SetField( this );
3114 SetText( ImplGetLocaleDataWrapper().getTime( maFieldTime, FALSE, FALSE ) );
3115 Reformat();
3116 }
3117
3118 // -----------------------------------------------------------------------
3119
3120 TimeField::TimeField( Window* pParent, const ResId& rResId ) :
3121 SpinField( WINDOW_TIMEFIELD ),
3122 maFirst( GetMin() ),
3123 maLast( GetMax() )
3124 {
3125 rResId.SetRT( RSC_TIMEFIELD );
3126 WinBits nStyle = ImplInitRes( rResId );
3127 SpinField::ImplInit( pParent, nStyle );
3128 SetField( this );
3129 SetText( ImplGetLocaleDataWrapper().getTime( maFieldTime, FALSE, FALSE ) );
3130 ImplLoadRes( rResId );
3131
3132 if ( !(nStyle & WB_HIDE ) )
3133 Show();
3134 }
3135
3136 // -----------------------------------------------------------------------
3137
3138 void TimeField::ImplLoadRes( const ResId& rResId )
3139 {
3140 SpinField::ImplLoadRes( rResId );
3141 ResMgr* pMgr = rResId.GetResMgr();
3142 if( pMgr )
3143 {
3144 TimeFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *pMgr ) );
3145
3146 ULONG nMask = ReadLongRes();
3147
3148 if ( TIMEFIELD_FIRST & nMask )
3149 {
3150 maFirst = Time( ResId( (RSHEADER_TYPE *)GetClassRes(), *pMgr ) );
3151 IncrementRes( GetObjSizeRes( (RSHEADER_TYPE *)GetClassRes() ) );
3152 }
3153 if ( TIMEFIELD_LAST & nMask )
3154 {
3155 maLast = Time( ResId( (RSHEADER_TYPE *)GetClassRes(), *pMgr ) );
3156 IncrementRes( GetObjSizeRes( (RSHEADER_TYPE *)GetClassRes() ) );
3157 }
3158 }
3159
3160 Reformat();
3161 }
3162
3163 // -----------------------------------------------------------------------
3164
3165 TimeField::~TimeField()
3166 {
3167 }
3168
3169 // -----------------------------------------------------------------------
3170
3171 long TimeField::PreNotify( NotifyEvent& rNEvt )
3172 {
3173 if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
3174 {
3175 if ( ImplTimeProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsDuration(), GetFormat(), ImplGetLocaleDataWrapper() ) )
3176 return 1;
3177 }
3178
3179 return SpinField::PreNotify( rNEvt );
3180 }
3181
3182 // -----------------------------------------------------------------------
3183
3184 long TimeField::Notify( NotifyEvent& rNEvt )
3185 {
3186 if ( rNEvt.GetType() == EVENT_GETFOCUS )
3187 MarkToBeReformatted( FALSE );
3188 else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
3189 {
3190 if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
3191 {
3192 if ( !ImplAllowMalformedInput() )
3193 Reformat();
3194 else
3195 {
3196 Time aTime( 0, 0, 0 );
3197 if ( ImplTimeGetValue( GetText(), aTime, GetFormat(), IsDuration(), ImplGetLocaleDataWrapper(), FALSE ) )
3198 // even with strict text analysis, our text is a valid time -> do a complete
3199 // reformat
3200 Reformat();
3201 }
3202 }
3203 }
3204
3205 return SpinField::Notify( rNEvt );
3206 }
3207
3208 // -----------------------------------------------------------------------
3209
3210 void TimeField::DataChanged( const DataChangedEvent& rDCEvt )
3211 {
3212 SpinField::DataChanged( rDCEvt );
3213
3214 if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
3215 {
3216 if ( IsDefaultLocale() )
3217 ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
3218 ReformatAll();
3219 }
3220 }
3221
3222 // -----------------------------------------------------------------------
3223
3224 void TimeField::Modify()
3225 {
3226 MarkToBeReformatted( TRUE );
3227 SpinField::Modify();
3228 }
3229
3230 // -----------------------------------------------------------------------
3231
3232 void TimeField::Up()
3233 {
3234 ImplTimeSpinArea( TRUE );
3235 SpinField::Up();
3236 }
3237
3238 // -----------------------------------------------------------------------
3239
3240 void TimeField::Down()
3241 {
3242 ImplTimeSpinArea( FALSE );
3243 SpinField::Down();
3244 }
3245
3246 // -----------------------------------------------------------------------
3247
3248 void TimeField::First()
3249 {
3250 ImplNewFieldValue( maFirst );
3251 SpinField::First();
3252 }
3253
3254 // -----------------------------------------------------------------------
3255
3256 void TimeField::Last()
3257 {
3258 ImplNewFieldValue( maLast );
3259 SpinField::Last();
3260 }
3261
3262 // -----------------------------------------------------------------------
3263
3264 void TimeField::SetExtFormat( ExtTimeFieldFormat eFormat )
3265 {
3266 switch ( eFormat )
3267 {
3268 case EXTTIMEF_24H_SHORT:
3269 {
3270 SetTimeFormat( HOUR_24 );
3271 SetDuration( FALSE );
3272 SetFormat( TIMEF_NONE );
3273 }
3274 break;
3275 case EXTTIMEF_24H_LONG:
3276 {
3277 SetTimeFormat( HOUR_24 );
3278 SetDuration( FALSE );
3279 SetFormat( TIMEF_SEC );
3280 }
3281 break;
3282 case EXTTIMEF_12H_SHORT:
3283 {
3284 SetTimeFormat( HOUR_12 );
3285 SetDuration( FALSE );
3286 SetFormat( TIMEF_NONE );
3287 }
3288 break;
3289 case EXTTIMEF_12H_LONG:
3290 {
3291 SetTimeFormat( HOUR_12 );
3292 SetDuration( FALSE );
3293 SetFormat( TIMEF_SEC );
3294 }
3295 break;
3296 case EXTTIMEF_DURATION_SHORT:
3297 {
3298 SetDuration( TRUE );
3299 SetFormat( TIMEF_NONE );
3300 }
3301 break;
3302 case EXTTIMEF_DURATION_LONG:
3303 {
3304 SetDuration( TRUE );
3305 SetFormat( TIMEF_SEC );
3306 }
3307 break;
3308 default: DBG_ERROR( "ExtTimeFieldFormat unknown!" );
3309 }
3310
3311 if ( GetField() && GetField()->GetText().Len() )
3312 SetUserTime( GetTime() );
3313 ReformatAll();
3314 }
3315
3316 // -----------------------------------------------------------------------
3317
3318 TimeBox::TimeBox( Window* pParent, WinBits nWinStyle ) :
3319 ComboBox( pParent, nWinStyle )
3320 {
3321 SetField( this );
3322 SetText( ImplGetLocaleDataWrapper().getTime( maFieldTime, FALSE, FALSE ) );
3323 Reformat();
3324 }
3325
3326 // -----------------------------------------------------------------------
3327
3328 TimeBox::TimeBox( Window* pParent, const ResId& rResId ) :
3329 ComboBox( WINDOW_TIMEBOX )
3330 {
3331 rResId.SetRT( RSC_TIMEBOX );
3332 WinBits nStyle = ImplInitRes( rResId );
3333 ComboBox::ImplInit( pParent, nStyle );
3334 SetField( this );
3335 SetText( ImplGetLocaleDataWrapper().getTime( maFieldTime, FALSE, FALSE ) );
3336 ComboBox::ImplLoadRes( rResId );
3337 ResMgr* pMgr = rResId.GetResMgr();
3338 if( pMgr )
3339 TimeFormatter::ImplLoadRes( ResId( (RSHEADER_TYPE *)GetClassRes(), *pMgr ) );
3340 Reformat();
3341
3342 if ( !(nStyle & WB_HIDE) )
3343 Show();
3344 }
3345
3346 // -----------------------------------------------------------------------
3347
3348 TimeBox::~TimeBox()
3349 {
3350 }
3351
3352 // -----------------------------------------------------------------------
3353
3354 long TimeBox::PreNotify( NotifyEvent& rNEvt )
3355 {
3356 if ( (rNEvt.GetType() == EVENT_KEYINPUT) && !rNEvt.GetKeyEvent()->GetKeyCode().IsMod2() )
3357 {
3358 if ( ImplTimeProcessKeyInput( GetField(), *rNEvt.GetKeyEvent(), IsStrictFormat(), IsDuration(), GetFormat(), ImplGetLocaleDataWrapper() ) )
3359 return 1;
3360 }
3361
3362 return ComboBox::PreNotify( rNEvt );
3363 }
3364
3365 // -----------------------------------------------------------------------
3366
3367 long TimeBox::Notify( NotifyEvent& rNEvt )
3368 {
3369 if ( rNEvt.GetType() == EVENT_GETFOCUS )
3370 MarkToBeReformatted( FALSE );
3371 else if ( rNEvt.GetType() == EVENT_LOSEFOCUS )
3372 {
3373 if ( MustBeReformatted() && (GetText().Len() || !IsEmptyFieldValueEnabled()) )
3374 Reformat();
3375 }
3376
3377 return ComboBox::Notify( rNEvt );
3378 }
3379
3380 // -----------------------------------------------------------------------
3381
3382 void TimeBox::DataChanged( const DataChangedEvent& rDCEvt )
3383 {
3384 ComboBox::DataChanged( rDCEvt );
3385
3386 if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_LOCALE) )
3387 {
3388 if ( IsDefaultLocale() )
3389 ImplGetLocaleDataWrapper().setLocale( GetSettings().GetLocale() );
3390 ReformatAll();
3391 }
3392 }
3393
3394 // -----------------------------------------------------------------------
3395
3396 void TimeBox::Modify()
3397 {
3398 MarkToBeReformatted( TRUE );
3399 ComboBox::Modify();
3400 }
3401
3402 // -----------------------------------------------------------------------
3403
3404 void TimeBox::ReformatAll()
3405 {
3406 XubString aStr;
3407 SetUpdateMode( FALSE );
3408 USHORT nEntryCount = GetEntryCount();
3409 for ( USHORT i=0; i < nEntryCount; i++ )
3410 {
3411 ImplTimeReformat( GetEntry( i ), aStr );
3412 RemoveEntry( i );
3413 InsertEntry( aStr, i );
3414 }
3415 TimeFormatter::Reformat();
3416 SetUpdateMode( TRUE );
3417 }
3418
3419 // -----------------------------------------------------------------------
3420
3421 void TimeBox::InsertTime( const Time& rTime, USHORT nPos )
3422 {
3423 Time aTime = rTime;
3424 if ( aTime > GetMax() )
3425 aTime = GetMax();
3426 else if ( aTime < GetMin() )
3427 aTime = GetMin();
3428
3429 BOOL bSec = FALSE;
3430 BOOL b100Sec = FALSE;
3431 if ( GetFormat() == TIMEF_SEC )
3432 bSec = TRUE;
3433 if ( GetFormat() == TIMEF_100TH_SEC || GetFormat() == TIMEF_SEC_CS )
3434 bSec = b100Sec = TRUE;
3435 ComboBox::InsertEntry( ImplGetLocaleDataWrapper().getTime( aTime, bSec, b100Sec ), nPos );
3436 }
3437
3438 // -----------------------------------------------------------------------
3439
3440 void TimeBox::RemoveTime( const Time& rTime )
3441 {
3442 BOOL bSec = FALSE;
3443 BOOL b100Sec = FALSE;
3444 if ( GetFormat() == TIMEF_SEC )
3445 bSec = TRUE;
3446 if ( GetFormat() == TIMEF_100TH_SEC || TIMEF_SEC_CS )
3447 bSec = b100Sec = TRUE;
3448 ComboBox::RemoveEntry( ImplGetLocaleDataWrapper().getTime( rTime, bSec, b100Sec ) );
3449 }
3450
3451 // -----------------------------------------------------------------------
3452
3453 Time TimeBox::GetTime( USHORT nPos ) const
3454 {
3455 Time aTime( 0, 0, 0 );
3456 ImplTimeGetValue( ComboBox::GetEntry( nPos ), aTime, GetFormat(), IsDuration(), ImplGetLocaleDataWrapper() );
3457 return aTime;
3458 }
3459
3460 // -----------------------------------------------------------------------
3461
3462 USHORT TimeBox::GetTimePos( const Time& rTime ) const
3463 {
3464 BOOL bSec = FALSE;
3465 BOOL b100Sec = FALSE;
3466 if ( GetFormat() == TIMEF_SEC )
3467 bSec = TRUE;
3468 if ( GetFormat() == TIMEF_100TH_SEC || TIMEF_SEC_CS )
3469 bSec = b100Sec = TRUE;
3470 return ComboBox::GetEntryPos( ImplGetLocaleDataWrapper().getTime( rTime, bSec, b100Sec ) );
3471 }
vba interoperability for OOo