FreeCalypso > hg > fc-tourmaline

comparison src/ui/bmi/mmiTimeDate.c @ 179:d0a2eaf41733

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
mmiTimeDate.c: formatting fixes and dead code elimination
author Mychaela Falconia <falcon@freecalypso.org>
date Tue, 19 Jan 2021 04:26:17 +0000
parents c0052fe355d3
children
comparison
equal deleted inserted replaced
178:053ff6a94961 179:d0a2eaf41733
1 /******************************************************************************* 1 /*******************************************************************************
2 2
3 CONDAT (UK) 3 CONDAT (UK)
4 4
5 ******************************************************************************** 5 ********************************************************************************
6 6
7 This software product is the property of Condat (UK) Ltd and may not be 7 This software product is the property of Condat (UK) Ltd and may not be
8 disclosed to any third party without the express permission of the owner. 8 disclosed to any third party without the express permission of the owner.
9 9
10 ******************************************************************************** 10 ********************************************************************************
11 11
12 $Project name: Basic MMI 12 $Project name: Basic MMI
13 $Project code: BMI (6349) 13 $Project code: BMI (6349)
14 $Module: MMI 14 $Module: MMI
15 $File: MmiTimeDate.c 15 $File: MmiTimeDate.c
16 $Revision: 1.0 16 $Revision: 1.0
17 17
18 $Author: Condat(UK) 18 $Author: Condat(UK)
19 $Date: 22/02/01 19 $Date: 22/02/01
20 20
21 ******************************************************************************** 21 ********************************************************************************
22 22
23 Description: 23 Description:
24
25 24
26 25
27 ******************************************************************************** 26 ********************************************************************************
28 27
29 $History: MmiTimeDate.c 28 $History: MmiTimeDate.c
65 Description: Alarm setting not allowed 64 Description: Alarm setting not allowed
66 Solution: We are checking the time format (12/24 Hour) and accordingly setting the 65 Solution: We are checking the time format (12/24 Hour) and accordingly setting the
67 format flag. Also the conversion of time from 24 to 12 or 12 to 24 hour format is done 66 format flag. Also the conversion of time from 24 to 12 or 12 to 24 hour format is done
68 before displaying it on the alarm editor screen. 67 before displaying it on the alarm editor screen.
69 68
70 25/10/00 Original Condat(UK) BMI version. 69 25/10/00 Original Condat(UK) BMI version.
71 70
72 $End 71 $End
73 72
74 *******************************************************************************/ 73 *******************************************************************************/
75 74
138 #endif /* FF_PHONE_LOCK */ 137 #endif /* FF_PHONE_LOCK */
139 138
140 #include "dspl.h" 139 #include "dspl.h"
141 140
142 141
143
144 #include "MmiMmi.h" 142 #include "MmiMmi.h"
145 #include "MmiDummy.h" 143 #include "MmiDummy.h"
146 #include "MmiDialogs.h" 144 #include "MmiDialogs.h"
147 #include "MmiLists.h" 145 #include "MmiLists.h"
148 146
218 216
219 typedef struct 217 typedef struct
220 { 218 {
221 T_MMI_CONTROL mmi_control; 219 T_MMI_CONTROL mmi_control;
222 T_MFW_HND parent_win; 220 T_MFW_HND parent_win;
223 T_MFW_HND win; /* The main time/date window */ 221 T_MFW_HND win; /* The main time/date window */
224 T_MFW_HND edit_win; /* The editor window */ 222 T_MFW_HND edit_win; /* The editor window */
225 char buffer[MAX_DIG_TIDA]; /* Buffer to store currently edited time/date */ 223 char buffer[MAX_DIG_TIDA]; /* Buffer to store currently edited time/date */
226 } T_tida; 224 } T_tida;
227 225
228 #else /* NEW_EDITOR */ 226 #else /* NEW_EDITOR */
229 227
230 /* OLD VERSION */ 228 /* OLD VERSION */
231 229 /* removed in FreeCalypso */
232 static int tida_edt_kbd_long_cb (MfwEvt e, MfwKbd *kc); 230
233 static void tida_edt_tim_out_cb(T_MFW_EVENT event,T_MFW_TIM * t);
234 static int check_time (T_MFW_HND win, void * edt_dat);
235 static int check_date (T_MFW_HND win, void * edt_dat);
236 static int tida_edt_kbd_cb (MfwEvt e, MfwKbd *kc);
237 static void tida_editor(T_MFW_HND win, USHORT event, SHORT value, void * parameter);
238 static int tida_edt_win_cb (T_MFW_EVENT event,T_MFW_WIN * win);
239 static int tida_win_cb (T_MFW_EVENT event, T_MFW_WIN * win);
240 static void tida_main(T_MFW_HND win, USHORT event, SHORT value, void * parameter);
241 static void reset_edt_attr_sett(int editZone, U32 colIndex, U8 font,U8 mode,
242 U8 *controls, char *text,U16 size,MfwEdtAttr* attr);
243
244 static MfwHnd win; /* our window */
245 static DisplayData DisplayInfo;
246
247 #define MAX_DIG_TIDA 20 /* size of buffer (??) */
248 #define MAX_LEN_DATE 11 /* maximum number of digits date*/
249 #define MAX_LEN_TIME 6 /* maximum number of digits time*/
250 #define DATE_TEXT_X 0
251 #define DATE_TEXT_Y 0
252
253 typedef enum
254 {
255 ALARM,
256 SETTING
257 } timeDateMode;
258
259 typedef struct
260 {
261 T_MMI_CONTROL mmi_control;
262 T_MFW_HND parent_win;
263 T_MFW_HND tida_win;
264 USHORT display_id1;
265 USHORT display_id2;
266 DAT_TIME_CASE state; /* setting state */
267 } T_tida;
268
269 typedef struct
270 {
271 T_MMI_CONTROL mmi_control;
272 T_MFW_HND parent_win;
273 T_MFW_HND tida_edt_win;
274 T_MFW_HND kbd_handle;
275 T_MFW_HND kbd_long_handle;
276 T_MFW_HND editor_handle;
277 T_MFW_HND tim_out_handle;
278 DAT_TIME_CASE state; /* setting state */
279 char edtbuf1[MAX_DIG_TIDA];
280 MfwEdtAttr edit1Attr;
281 UBYTE index;
282 }T_tida_edt;
283
284
285
286 /*
287 * Settings menu subs:
288 */
289
290 #define TIMERCLEAR 2500
291
292 //Flag to indicate whether we're setting the current or alarm date/time.
293 static UBYTE DateTimeEntryMode;
294
295 extern UBYTE getcurrentAlarmTone(void); //mmisounds
296 #endif /* NEW_EDITOR */ 231 #endif /* NEW_EDITOR */
297 232
298 T_MFW_HND td_handle; 233 T_MFW_HND td_handle;
299 /* FUNCTIONS BELOW ARE COMMON TO OLD AND NEW VERSION */ 234 /* FUNCTIONS BELOW ARE COMMON TO OLD AND NEW VERSION */
300 235
303 238
304 /******************************************************************************* 239 /*******************************************************************************
305 240
306 $Function: time_date_init 241 $Function: time_date_init
307 242
308 $Description: initialises time and date 243 $Description: initialises time and date
309 244
310 $Returns: none. 245 $Returns: none.
311 246
312 $Arguments: none 247 $Arguments: none
313 248
314 *******************************************************************************/ 249 *******************************************************************************/
315 void time_date_init() 250 void time_date_init()
319 } 254 }
320 /******************************************************************************* 255 /*******************************************************************************
321 256
322 $Function: time_date_init 257 $Function: time_date_init
323 258
324 $Description: deletes mfw td 259 $Description: deletes mfw td
325 260
326 $Returns: none. 261 $Returns: none.
327 262
328 $Arguments: none 263 $Arguments: none
329 264
330 *******************************************************************************/ 265 *******************************************************************************/
331 void time_date_delete() 266 void time_date_delete()
335 } 270 }
336 /******************************************************************************* 271 /*******************************************************************************
337 272
338 $Function: time_date_cb 273 $Function: time_date_cb
339 274
340 $Description: handles alarm event from MFW 275 $Description: handles alarm event from MFW
341 276
342 $Returns: none. 277 $Returns: none.
343 278
344 $Arguments: none 279 $Arguments: none
345 280
346 *******************************************************************************/ 281 *******************************************************************************/
347 int time_date_cb(T_MFW_EVENT event,void* para) 282 int time_date_cb(T_MFW_EVENT event,void* para)
354 289
355 /******************************************************************************* 290 /*******************************************************************************
356 291
357 $Function: alarm_screen_cb added for SPR 2184 292 $Function: alarm_screen_cb added for SPR 2184
358 293
359 $Description: Handles alarm screen keypresses 294 $Description: Handles alarm screen keypresses
360 295
361 $Returns: none. 296 $Returns: none.
362 297
363 $Arguments: window handle, identifier, reason(key pressed) 298 $Arguments: window handle, identifier, reason(key pressed)
364 299
365 *******************************************************************************/ 300 *******************************************************************************/
366 void alarm_screen_cb(T_MFW_HND win, USHORT identifier, UBYTE reason) 301 void alarm_screen_cb(T_MFW_HND win, USHORT identifier, UBYTE reason)
407 342
408 /******************************************************************************* 343 /*******************************************************************************
409 344
410 $Function: alarm_screen 345 $Function: alarm_screen
411 346
412 $Description: displays alarm screen 347 $Description: displays alarm screen
413 348
414 $Returns: none. 349 $Returns: none.
415 350
416 $Arguments: none 351 $Arguments: none
417 352
418 *******************************************************************************/ 353 *******************************************************************************/
419 void alarm_screen(void) 354 void alarm_screen(void)
420 { 355 {
421 T_MFW_HND idle_win = idle_get_window(); 356 T_MFW_HND idle_win = idle_get_window();
422 T_DISPLAY_DATA display_info; 357 T_DISPLAY_DATA display_info;
423 T_MFW_TIME* time; 358 T_MFW_TIME* time;
424 static char text[25]; 359 static char text[25];
425 360
426
427 TRACE_FUNCTION("alarm_screen()"); 361 TRACE_FUNCTION("alarm_screen()");
428 362
429 /*SPR 2639, convert function to use new MFW functions*/ 363 /*SPR 2639, convert function to use new MFW functions*/
430 time = mfw_td_get_time(); 364 time = mfw_td_get_time();
431 365
432 sprintf(text, "%02d:%02d", time->hour, time->minute); 366 sprintf(text, "%02d:%02d", time->hour, time->minute);
433 // Apr 05, 2005 REF: ENH 29994 xdeepadh 367 // Apr 05, 2005 REF: ENH 29994 xdeepadh
434 /*SPR 2639 get current alarm id and play it*/ 368 /*SPR 2639 get current alarm id and play it*/
435 //Nov 02, 2005 REF:ER OMAPS00039044 xdeepadh 369 //Nov 02, 2005 REF:ER OMAPS00039044 xdeepadh
436 //If Alarm is recieved , while in call screen,dont play the tone. 370 //If Alarm is recieved , while in call screen,dont play the tone.
437 #ifdef FF_MIDI_RINGER 371 #ifdef FF_MIDI_RINGER
481 else 415 else
482 #endif //FF_PHONE_LOCK 416 #endif //FF_PHONE_LOCK
483 /* Call Info Screen 417 /* Call Info Screen
484 */ 418 */
485 info_dialog( idle_win, &display_info ); 419 info_dialog( idle_win, &display_info );
486 420 }
487
488 }
489
490
491 421
492 422
493 /******************************************************************************* 423 /*******************************************************************************
494 424
495 $Function: clear_alarm 425 $Function: clear_alarm
496 426
497 $Description: handles menu option to cancel any existing alarm setting 427 $Description: handles menu option to cancel any existing alarm setting
498 428
499 $Returns: status int 429 $Returns: status int
500 430
501 $Arguments: menu and item (not used) 431 $Arguments: menu and item (not used)
502 432
503 *******************************************************************************/ 433 *******************************************************************************/
504 int clear_alarm(MfwMnu* m, MfwMnuItem* i) 434 int clear_alarm(MfwMnu* m, MfwMnuItem* i)
505 { T_MFW_HND win = mfwParent( mfw_header() ); 435 { T_MFW_HND win = mfwParent( mfw_header() );
506 T_DISPLAY_DATA display_info; 436 T_DISPLAY_DATA display_info;
507 437
508
509 /*SPR 2639, changed to use new MFW functions*/ 438 /*SPR 2639, changed to use new MFW functions*/
510 mfw_td_cancel_alarm(); 439 mfw_td_cancel_alarm();
511 440
512 dlg_initDisplayData_TextId( &display_info, TxtSoftOK, TxtNull, TxtAlarm, TxtCancelled , COLOUR_STATUS); 441 dlg_initDisplayData_TextId( &display_info, TxtSoftOK, TxtNull, TxtAlarm, TxtCancelled , COLOUR_STATUS);
513 dlg_initDisplayData_events( &display_info, NULL, THREE_SECS, KEY_CLEAR|KEY_LEFT|KEY_RIGHT ); 442 dlg_initDisplayData_events( &display_info, NULL, THREE_SECS, KEY_CLEAR|KEY_LEFT|KEY_RIGHT );
514 443
515 /* Call Info Screen 444 /* Call Info Screen
516 */ 445 */
517 info_dialog( win, &display_info ); 446 info_dialog( win, &display_info );
518 447
519
520 return MFW_EVENT_CONSUMED; 448 return MFW_EVENT_CONSUMED;
521
522 } 449 }
523 450
524 451
525 /******************************************************************************* 452 /*******************************************************************************
526 453
527 $Function: twelve_hour_clock 454 $Function: twelve_hour_clock
528 455
529 $Description: handles selection of twleve hour clock in menu 456 $Description: handles selection of twleve hour clock in menu
530 457
531 $Returns: status int 458 $Returns: status int
532 459
533 $Arguments: menu and item (not used) 460 $Arguments: menu and item (not used)
534 461
535 *******************************************************************************/ 462 *******************************************************************************/
536 int twelve_hour_clock(MfwMnu* m, MfwMnuItem* i) 463 int twelve_hour_clock(MfwMnu* m, MfwMnuItem* i)
554 481
555 $Function: twentyfour_hour_clock 482 $Function: twentyfour_hour_clock
556 483
557 $Description: handles selection of twleve hour clock in menu 484 $Description: handles selection of twleve hour clock in menu
558 485
559 $Returns: status int 486 $Returns: status int
560 487
561 $Arguments: menu and item (not used) 488 $Arguments: menu and item (not used)
562 *******************************************************************************/ 489 *******************************************************************************/
563 int twentyfour_hour_clock(MfwMnu* m, MfwMnuItem* i) 490 int twentyfour_hour_clock(MfwMnu* m, MfwMnuItem* i)
564 { T_MFW_HND win = mfwParent( mfw_header() ); 491 { T_MFW_HND win = mfwParent( mfw_header() );
573 /* Call Info Screen 500 /* Call Info Screen
574 */ 501 */
575 502
576 info_dialog( win, &display_info ); 503 info_dialog( win, &display_info );
577 return MFW_EVENT_CONSUMED; 504 return MFW_EVENT_CONSUMED;
578
579 } 505 }
580 506
581 507
582 /******************************************************************************* 508 /*******************************************************************************
583 509
584 $Function: alarmTimeDate 510 $Function: alarmTimeDate
585 511
586 $Description: Called when user selects alarm in menu. Begins editor to enter 512 $Description: Called when user selects alarm in menu. Begins editor to enter
587 desired alarm time and date. 513 desired alarm time and date.
588 514
589 $Returns: status int 515 $Returns: status int
590 516
591 $Arguments: menu and item (not used) 517 $Arguments: menu and item (not used)
592 518
593 *******************************************************************************/ 519 *******************************************************************************/
594 int alarmTimeDate(MfwMnu* m, MfwMnuItem* i) 520 int alarmTimeDate(MfwMnu* m, MfwMnuItem* i)
595 { 521 {
596 /* SPR#1428 - SH - New Editor changes */ 522 /* SPR#1428 - SH - New Editor changes */
597 #ifdef NEW_EDITOR 523 #ifdef NEW_EDITOR
598 T_MFW_HND idle_win = idle_get_window(); 524 T_MFW_HND idle_win = idle_get_window();
599 T_MFW_HND win = tida_create(idle_win); /* Parent_window is idle */ 525 T_MFW_HND win = tida_create(idle_win); /* Parent_window is idle */
600 526
601 T_MFW_WIN *win_data = ((T_MFW_HDR *)win)->data; 527 T_MFW_WIN *win_data = ((T_MFW_HDR *)win)->data;
602 T_tida *data = (T_tida *)win_data->user; 528 T_tida *data = (T_tida *)win_data->user;
603 529
604 TRACE_FUNCTION ("MmiTimeDate:alarmTimeDate()"); 530 TRACE_FUNCTION ("MmiTimeDate:alarmTimeDate()");
605 531
606 if(data->win) 532 if(data->win)
607 { 533 {
608 SEND_EVENT(data->win, TIDA_ALARMDATE,0,0); 534 SEND_EVENT(data->win, TIDA_ALARMDATE,0,0);
609
610 } 535 }
611 #else /* NEW_EDITOR */ 536 #else /* NEW_EDITOR */
612 T_MFW_HND idle_win = idle_get_window(); 537 T_MFW_HND idle_win = idle_get_window();
613 T_MFW_HND win = date_time_create(idle_win);// parent_window is idle 538 T_MFW_HND win = date_time_create(idle_win);// parent_window is idle
614 539
631 556
632 /******************************************************************************* 557 /*******************************************************************************
633 558
634 $Function: settingsTimeDate 559 $Function: settingsTimeDate
635 560
636 $Description: settings date and time menu function 561 $Description: settings date and time menu function
637 562
638 $Returns: none. 563 $Returns: none.
639 564
640 $Arguments: 565 $Arguments:
641 566
642 *******************************************************************************/ 567 *******************************************************************************/
643 int settingsTimeDate(MfwMnu* m, MfwMnuItem* i) 568 int settingsTimeDate(MfwMnu* m, MfwMnuItem* i)
644 { 569 {
645 /* SPR#1428 - SH - New Editor changes */ 570 /* SPR#1428 - SH - New Editor changes */
646 #ifdef NEW_EDITOR 571 #ifdef NEW_EDITOR
647 T_MFW_HND idle_win = idle_get_window(); 572 T_MFW_HND idle_win = idle_get_window();
648 T_MFW_HND win = tida_create(idle_win); /* Parent_window is idle */ 573 T_MFW_HND win = tida_create(idle_win); /* Parent_window is idle */
649 574
650 T_MFW_WIN *win_data = ((T_MFW_HDR *)win)->data; 575 T_MFW_WIN *win_data = ((T_MFW_HDR *)win)->data;
651 T_tida *data = (T_tida *)win_data->user; 576 T_tida *data = (T_tida *)win_data->user;
652 577
653 TRACE_FUNCTION ("MmiTimeDate:settingsTimeDate()"); 578 TRACE_FUNCTION ("MmiTimeDate:settingsTimeDate()");
654 579
655 if(data->win) 580 if(data->win)
656 { 581 {
657 SEND_EVENT(data->win, TIDA_DATE,0,0); 582 SEND_EVENT(data->win, TIDA_DATE,0,0);
658
659 } 583 }
660 #else /* NEW_EDITOR */ 584 #else /* NEW_EDITOR */
661 T_MFW_HND idle_win = idle_get_window(); 585 T_MFW_HND idle_win = idle_get_window();
662 T_MFW_HND win = date_time_create(idle_win);// parent_window is idle 586 T_MFW_HND win = date_time_create(idle_win);// parent_window is idle
663 587
685 609
686 #ifdef NEW_EDITOR 610 #ifdef NEW_EDITOR
687 611
688 /******************************************************************************* 612 /*******************************************************************************
689 613
690 $Function: tida_create 614 $Function: tida_create
691 615
692 $Description: Create the main time/date window 616 $Description: Create the main time/date window
693 617
694 $Returns: The window handle 618 $Returns: The window handle
695 619
696 $Arguments: parent_win - The parent window 620 $Arguments: parent_win - The parent window
697 621
698 *******************************************************************************/ 622 *******************************************************************************/
699 623
727 } 651 }
728 652
729 653
730 /******************************************************************************* 654 /*******************************************************************************
731 655
732 $Function: tida_destroy 656 $Function: tida_destroy
733 657
734 $Description: Destroy the main time/date window 658 $Description: Destroy the main time/date window
735 659
736 $Returns: None 660 $Returns: None
737 661
738 $Arguments: win - The main time/date window 662 $Arguments: win - The main time/date window
739 663
740 *******************************************************************************/ 664 *******************************************************************************/
741 665
764 } 688 }
765 689
766 690
767 /******************************************************************************* 691 /*******************************************************************************
768 692
769 $Function: tida_win_cb 693 $Function: tida_win_cb
770 694
771 $Description: Window callback function for time and date. This is a non-displaying 695 $Description: Window callback function for time and date. This is a non-displaying
772 window, so does nothing! 696 window, so does nothing!
773 697
774 $Returns: None. 698 $Returns: None.
775 699
776 $Arguments: 700 $Arguments:
777 701
778 *******************************************************************************/ 702 *******************************************************************************/
779 703
785 } 709 }
786 710
787 711
788 /******************************************************************************* 712 /*******************************************************************************
789 713
790 $Function: tida_exec_cb 714 $Function: tida_exec_cb
791 715
792 $Description: Main dialog function for time and date 716 $Description: Main dialog function for time and date
793 717
794 $Returns: None. 718 $Returns: None.
795 719
796 $Arguments: 720 $Arguments:
797 721
798 *******************************************************************************/ 722 *******************************************************************************/
799 723
804 728
805 T_MFW_TIME* currclock; /*SPR 2639*/ 729 T_MFW_TIME* currclock; /*SPR 2639*/
806 T_MFW_DATE* currdate; 730 T_MFW_DATE* currdate;
807 731
808 TRACE_FUNCTION("MmiTimeDate:tida_main"); 732 TRACE_FUNCTION("MmiTimeDate:tida_main");
809
810
811
812 733
813 switch(event) 734 switch(event)
814 { 735 {
815 case TIDA_INIT: 736 case TIDA_INIT:
816 break; 737 break;
956 return; 877 return;
957 } 878 }
958 879
959 /******************************************************************************* 880 /*******************************************************************************
960 881
961 $Function: tida_edit_create 882 $Function: tida_edit_create
962 883
963 $Description: Creates an editor with the supplied properties 884 $Description: Creates an editor with the supplied properties
964 885
965 $Returns: The editor window. 886 $Returns: The editor window.
966 887
967 $Arguments: parent - The parent window 888 $Arguments: parent - The parent window
968 Identifier - ID used in callback to identify type of editor 889 Identifier - ID used in callback to identify type of editor
969 TitleId - The title of the editor 890 TitleId - The title of the editor
970 buffer - The text buffer 891 buffer - The text buffer
971 formatString - The formatting that governs the input 892 formatString - The formatting that governs the input
972 893
973 *******************************************************************************/ 894 *******************************************************************************/
974 895
975 T_MFW_HND tida_edit_create(T_MFW_HND parent, USHORT Identifier, USHORT TitleId, char *buffer, char *formatString) 896 T_MFW_HND tida_edit_create(T_MFW_HND parent, USHORT Identifier, USHORT TitleId, char *buffer, char *formatString)
976 { 897 {
986 } 907 }
987 908
988 909
989 /******************************************************************************* 910 /*******************************************************************************
990 911
991 $Function: tida_edit_cb 912 $Function: tida_edit_cb
992 913
993 $Description: Callback function for editor 914 $Description: Callback function for editor
994 915
995 $Returns: None 916 $Returns: None
996 917
997 $Arguments: win - The main time/date window 918 $Arguments: win - The main time/date window
998 Identifier - ID used in callback to identify type of editor 919 Identifier - ID used in callback to identify type of editor
999 value - What prompted the callback 920 value - What prompted the callback
1000 921
1001 *******************************************************************************/ 922 *******************************************************************************/
1002 923
1003 void tida_edit_cb(T_MFW_HND win, USHORT Identifier, SHORT value) 924 void tida_edit_cb(T_MFW_HND win, USHORT Identifier, SHORT value)
1004 { 925 {
1008 T_MFW_TIME_FORMAT current_format; 929 T_MFW_TIME_FORMAT current_format;
1009 char pmFlag = '\0'; /* x0039928 - Lint warning fix */ 930 char pmFlag = '\0'; /* x0039928 - Lint warning fix */
1010 931
1011 T_MFW_TIME* currclock; /*SPR 2639*/ //, *tempclock; // RAVI 932 T_MFW_TIME* currclock; /*SPR 2639*/ //, *tempclock; // RAVI
1012 T_MFW_DATE* currdate; 933 T_MFW_DATE* currdate;
1013
1014
1015
1016 934
1017 switch(value) 935 switch(value)
1018 { 936 {
1019 /* Terminate editor */ 937 /* Terminate editor */
1020 case INFO_KCD_HUP: 938 case INFO_KCD_HUP:
1188 1106
1189 $Function: tida_show_dlg 1107 $Function: tida_show_dlg
1190 1108
1191 $Description: Displays a dialog 1109 $Description: Displays a dialog
1192 1110
1193 $Returns: None. 1111 $Returns: None.
1194 1112
1195 $Arguments: win - The parent window 1113 $Arguments: win - The parent window
1196 textId - Will display "<textId> Not Allowed" 1114 textId - Will display "<textId> Not Allowed"
1197 *******************************************************************************/ 1115 *******************************************************************************/
1198 1116
1199 void tida_show_dlg(T_MFW_HND win, USHORT textId1, USHORT textId2) 1117 void tida_show_dlg(T_MFW_HND win, USHORT textId1, USHORT textId2)
1200 { 1118 {
1201 T_DISPLAY_DATA display_info; 1119 T_DISPLAY_DATA display_info;
1202 dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull, textId1, textId2, COLOUR_STATUS); 1120 dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull, textId1, textId2, COLOUR_STATUS);
1203 dlg_initDisplayData_events( &display_info, (T_VOID_FUNC)NULL, THREE_SECS, KEY_CLEAR|KEY_LEFT|KEY_RIGHT ); 1121 dlg_initDisplayData_events( &display_info, (T_VOID_FUNC)NULL, THREE_SECS, KEY_CLEAR|KEY_LEFT|KEY_RIGHT );
1204 1122
1205 /* Call Info Screen 1123 /* Call Info Screen
1206 */ 1124 */
1207 1125
1208 info_dialog( win, &display_info ); 1126 info_dialog( win, &display_info );
1215 1133
1216 $Function: tida_check_date 1134 $Function: tida_check_date
1217 1135
1218 $Description: Checks a date to see if it's valid 1136 $Description: Checks a date to see if it's valid
1219 1137
1220 $Returns: TRUE if it's valid, FALSE otherwise 1138 $Returns: TRUE if it's valid, FALSE otherwise
1221 1139
1222 $Arguments: datestring - The date string 1140 $Arguments: datestring - The date string
1223 1141
1224 *******************************************************************************/ 1142 *******************************************************************************/
1225 1143
1280 1198
1281 $Function: tida_check_time 1199 $Function: tida_check_time
1282 1200
1283 $Description: Checks a time to see if it's valid 1201 $Description: Checks a time to see if it's valid
1284 1202
1285 $Returns: TRUE if it's valid, FALSE otherwise 1203 $Returns: TRUE if it's valid, FALSE otherwise
1286 1204
1287 $Arguments: timestring - The time string 1205 $Arguments: timestring - The time string
1288 1206
1289 *******************************************************************************/ 1207 *******************************************************************************/
1290 1208
1320 } 1238 }
1321 1239
1322 #else /* NEW_EDITOR */ 1240 #else /* NEW_EDITOR */
1323 1241
1324 /* OLD VERSION */ 1242 /* OLD VERSION */
1325 1243 /* removed in FreeCalypso */
1326 /******************************************************************************* 1244
1327
1328 $Function: date_time_create
1329
1330 $Description: create main dialog for time and date (SINGLE_DYNAMIC)
1331
1332 $Returns: none.
1333
1334 $Arguments:
1335
1336 *******************************************************************************/
1337 T_MFW_HND date_time_create (T_MFW_HND parent_window)
1338 {
1339 T_MFW_WIN * win;
1340
1341 T_tida * data = (T_tida *)ALLOC_MEMORY (sizeof (T_tida));
1342 data->tida_win = win_create (parent_window, 0, MfwWinVisible, (T_MFW_CB)tida_win_cb);
1343
1344 TRACE_FUNCTION("MmiTimeDate:date_time_create");
1345
1346 if (data->tida_win EQ 0)
1347 return 0;
1348
1349 /*
1350 * Create window handler
1351 */
1352 data->mmi_control.dialog = (T_DIALOG_FUNC)tida_main;/* dialog main function */
1353 data->mmi_control.data = data;
1354 data->parent_win = parent_window;
1355 win = ((T_MFW_HDR *)data->tida_win)->data;
1356 win->user = (void *) data;
1357
1358
1359 /*
1360 * return window handle
1361 */
1362
1363 mfwSetSignallingMethod(1);
1364 winShow(data->tida_win);
1365
1366
1367 return data->tida_win;
1368 }
1369 /*******************************************************************************
1370
1371 $Function: date_time_destroy
1372
1373 $Description: destroy main dialog for time and date
1374
1375 $Returns: none.
1376
1377 $Arguments:
1378
1379 *******************************************************************************/
1380 void date_time_destroy (T_MFW_HND own_window)
1381 {
1382 T_tida * data;
1383 T_MFW_WIN * win;
1384
1385 if (own_window)
1386 {
1387 TRACE_EVENT("MmiTimeDate:date_time_destroy");
1388 win = ((T_MFW_HDR *)own_window)->data;
1389 data = (T_tida *)win->user;
1390
1391 if(data)
1392 {
1393 win_delete (data->tida_win);
1394 FREE_MEMORY((void *)data,(sizeof(T_tida)));
1395 }
1396 }
1397 }
1398 /*******************************************************************************
1399
1400 $Function: date_time_edt_create
1401
1402 $Description: create editor dialog for time and date(SINGLE_DYNAMIC)
1403
1404 $Returns: none.
1405
1406 $Arguments:
1407
1408 *******************************************************************************/
1409 T_MFW_HND date_time_edt_create(T_MFW_HND parent_window)
1410 {
1411 T_tida_edt * data = (T_tida_edt *)ALLOC_MEMORY (sizeof (T_tida_edt));
1412
1413 T_MFW_WIN * win;
1414
1415 data->tida_edt_win = win_create (parent_window, 0, MfwWinVisible, (T_MFW_CB)tida_edt_win_cb);
1416
1417 TRACE_FUNCTION("MmiTimeDate:date_time_edt_create");
1418
1419 if (data->tida_edt_win EQ 0)
1420 return 0;
1421
1422 /*
1423 * Create window handler
1424 */
1425 data->mmi_control.dialog = (T_DIALOG_FUNC)tida_editor;
1426 data->mmi_control.data = data;
1427 data->parent_win = parent_window;
1428 win = ((T_MFW_HDR *)data->tida_edt_win)->data;
1429 win->user = (void *) data;
1430 /*
1431 * Create any other handler
1432 */
1433 editor_attr_init(&data->edit1Attr, TIMEDATE_EDITOR_AREA, edtCurBar1 | edtModOverWr, 0, (char*)data->edtbuf1,MAX_DIG_TIDA,COLOUR_EDITOR_XX );
1434
1435 data->tim_out_handle = tim_create(data->tida_edt_win,TIMERCLEAR,(T_MFW_CB)tida_edt_tim_out_cb);
1436 data->editor_handle = edt_create(data->tida_edt_win,&data->edit1Attr,0,0);
1437 data->kbd_handle = kbd_create(data->tida_edt_win,KEY_ALL,(T_MFW_CB)tida_edt_kbd_cb);
1438 data->kbd_long_handle = kbd_create(data->tida_edt_win,KEY_ALL | KEY_LONG,(T_MFW_CB)tida_edt_kbd_long_cb);
1439 /*
1440 * return window handle
1441 */
1442 return data->tida_edt_win;
1443 }
1444 /*******************************************************************************
1445
1446 $Function: date_time_edt_destroy
1447
1448 $Description: destroy editor dialog for time and date
1449
1450 $Returns: none.
1451
1452 $Arguments:
1453
1454 *******************************************************************************/
1455 void date_time_edt_destroy (T_MFW_HND own_window)
1456 {
1457 T_tida_edt * data ;
1458 T_MFW_WIN * win;
1459
1460
1461 if (own_window)
1462 {
1463 TRACE_FUNCTION ("MmiTimeDate:date_time_edt_destroy");
1464
1465 win = ((T_MFW_HDR *)own_window)->data;
1466 data = (T_tida_edt *)win->user;
1467
1468 if(data)
1469 {
1470 win_delete (data->tida_edt_win);
1471 FREE_MEMORY((void *)data,(sizeof(T_tida_edt)));
1472 }
1473 }
1474 }
1475 /*******************************************************************************
1476
1477 $Function: tida_main
1478
1479 $Description: main dialog function for time and date
1480
1481 $Returns: none.
1482
1483 $Arguments:
1484
1485 *******************************************************************************/
1486 static void tida_main(T_MFW_HND win, USHORT event, SHORT value, void * parameter)
1487 {
1488 T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
1489 T_tida * tida_data = (T_tida *)win_data->user;//tida main data
1490 T_tida_edt * tida_edt_data = (T_tida_edt *) parameter;//tida editor data
1491 T_MFW_HND tida_edt_win;
1492 T_DISPLAY_DATA display_info;
1493
1494 TRACE_FUNCTION("MmiTimeDate:tida_main");
1495
1496 switch(event)
1497 {
1498 case DATE_SHOW:
1499 tida_data->state = DATE_SHOW;
1500 tida_data->display_id1 = TxtEnterDate;
1501 tida_edt_win = date_time_edt_create(tida_data->tida_win);
1502 if(tida_edt_win)
1503 {
1504 SEND_EVENT(tida_edt_win,event,0,tida_data);
1505 }
1506 break;
1507 case DATE_ENTRY:
1508 tida_data->state = DATE_ENTRY;
1509 tida_data->display_id1 = TxtEnterDate;
1510 tida_edt_win = date_time_edt_create(tida_data->tida_win);
1511 {
1512 SEND_EVENT(tida_edt_win,event,0,tida_data);
1513 }
1514 break;
1515 case TIME_ENTRY:
1516 tida_data->state = TIME_ENTRY;
1517 tida_data->display_id1 = TxtEnterTime;
1518 tida_edt_win = date_time_edt_create(tida_data->tida_win);
1519 {
1520 SEND_EVENT(tida_edt_win,event,0,tida_data);
1521 }
1522 break;
1523 case TIME_SHOW:
1524 tida_data->state = TIME_SHOW;
1525 tida_data->display_id1 = TxtEnterTime;
1526 tida_edt_win = date_time_edt_create(tida_data->tida_win);
1527 if(tida_edt_win)
1528 {
1529 SEND_EVENT(tida_edt_win,event,0,tida_data);
1530 }
1531 break;
1532 case ENTRY_OK:
1533 dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull, TxtSaved, TxtNull, COLOUR_STATUS);
1534 dlg_initDisplayData_events( &display_info, (T_VOID_FUNC)tida_info_cb, THREE_SECS, KEY_ALL );
1535 display_info.Identifier = SAVED;
1536 info_dialog(tida_data->tida_win,&display_info); /* information screen "Saved" */
1537 break;
1538 case SAVED:
1539 case TIDA_ABORT:
1540 case TIDA_CLEAR:
1541 case TIDA_TO_IDLE:
1542 date_time_destroy(tida_data->tida_win);
1543 break;
1544 default:
1545 break;
1546 }
1547 }
1548 /*******************************************************************************
1549
1550 $Function: tida_info_cb
1551
1552 $Description: callback function from info dialog for time and date
1553
1554 $Returns: none.
1555
1556 $Arguments:
1557
1558 *******************************************************************************/
1559 void tida_info_cb(T_MFW_HND win, USHORT identifier, UBYTE reasons)
1560 {
1561 T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
1562 T_tida * tida_data = (T_tida *)win_data->user;
1563
1564 TRACE_FUNCTION ("MmiTimeDate: tida_info_cb");
1565
1566 switch(identifier)
1567 {
1568 case SAVED:
1569 SEND_EVENT(tida_data->tida_win,identifier,0,NULL);
1570 break;
1571 default:
1572 break;
1573 }
1574 }
1575
1576 /*******************************************************************************
1577
1578 $Function: tida_win_cb
1579
1580 $Description: windows main callback function for time and date
1581
1582 $Returns: none.
1583
1584 $Arguments:
1585
1586 *******************************************************************************/
1587 static int tida_win_cb (T_MFW_EVENT event, T_MFW_WIN * win)
1588 {
1589 TRACE_FUNCTION ("MmiTimeDate: tida_win_cb");
1590 if (event EQ MfwWinVisible)
1591 {
1592 /*
1593 * Top Window has no output
1594 */
1595 dspl_ClearAll();
1596 return 1;
1597 }
1598 return 0;
1599 }
1600 /*******************************************************************************
1601
1602 $Function: tida_edt_win_cb
1603
1604 $Description: windows callback function for editor for time and date
1605
1606 $Returns: none.
1607
1608 $Arguments:
1609
1610 *******************************************************************************/
1611 static int tida_edt_win_cb (T_MFW_EVENT event,T_MFW_WIN * win)
1612 {
1613
1614
1615 T_tida_edt * edt_data = (T_tida_edt *)win->user;//tida edt data
1616 T_MFW_WIN * win_tida =((T_MFW_HDR *)edt_data->parent_win)->data;
1617 T_tida * tida_data = (T_tida *)win_tida->user; // tida main data
1618 char lin1[MAX_LEN_DATE];
1619 char lin2[MAX_LEN_TIME];
1620 T_MFW_TIME* currclock; /*SPR 2639*/
1621 T_MFW_DATE* currdate;
1622 //T_MFW_TIME alarmTime; /*SPR 2639*/
1623
1624
1625 currclock = mfw_td_get_time(&currclock);/*SPR 2639*/
1626 currdate = mfw_td_get_date(&currdate);
1627
1628
1629 TRACE_FUNCTION ("MmiTimeDate:tida_edt_win_cb");
1630
1631 if (event EQ MfwWinVisible)
1632 {
1633 dspl_ClearAll();
1634 PROMPT(DATE_TEXT_X,DATE_TEXT_Y,0,tida_data->display_id1);
1635 softKeys_displayId(TxtSoftOK,TxtSoftBack,0,COLOUR_EDITOR_XX);
1636
1637
1638 if(tida_data->state EQ DATE_SHOW)
1639 {
1640 if ((DateTimeEntryMode == SETTING) || (alarmDate.day == 0))
1641 { if (currdate->day == 0) //if no date set
1642 sprintf(lin1,"dd/mm/yyyy");
1643 else
1644 sprintf(lin1,"%02d/%02d/%04d",currdate->day,currdate->month,currdate->year);
1645 }
1646 else
1647 sprintf(lin1,"%02d/%02d/%04d",alarmDate.day,alarmDate.month,alarmDate.year);
1648
1649 strncpy(edt_data->edtbuf1,lin1,MAX_LEN_DATE);
1650 edtShow(edt_data->editor_handle);
1651 }
1652 else if(tida_data->state EQ DATE_ENTRY)
1653 {
1654 if ((DateTimeEntryMode == SETTING) || (alarmDate.day == 0))
1655 { if (currdate->day == 0)
1656 sprintf(lin1,"dd/mm/yyyy");//if no date set
1657 else
1658 sprintf(lin1,"%02d/%02d/%04d",currdate->day,currdate->month,currdate->year);
1659 }
1660 else
1661 {
1662 sprintf(lin1,"%02d/%02d/%04d",alarmDate.day,alarmDate.month,alarmDate.year);
1663 }
1664 strncpy(edt_data->edtbuf1,lin1,MAX_LEN_DATE);
1665 edt_data->index = 0;
1666 edtShow(edt_data->editor_handle);
1667 softKeys_displayId(TxtSoftOK,TxtSoftBack,0,COLOUR_EDITOR_XX);
1668 }
1669 else if(tida_data->state EQ TIME_ENTRY)
1670 {
1671 if ((DateTimeEntryMode == SETTING) || (alarmDate.day==0))
1672 sprintf(lin2,"%02d:%02d",mfw_td_convert_to_24_hour(currclock), currclock->minute);
1673 else
1674 sprintf(lin2,"%02d:%02d",alarmTime.hour, alarmTime.minute);
1675 strncpy(edt_data->edtbuf1,lin2,MAX_LEN_TIME);
1676 edt_data->index = 0;
1677 edtShow(edt_data->editor_handle);
1678 softKeys_displayId(TxtSoftOK,TxtSoftBack,0,COLOUR_EDITOR_XX);
1679 }
1680 else if(tida_data->state EQ TIME_SHOW)
1681 { if ((DateTimeEntryMode == SETTING) || (alarmDate.day == 0))
1682 sprintf(lin2,"%02d:%02d",mfw_td_convert_to_24_hour(currclock), currclock->minute);
1683 else
1684 sprintf(lin2,"%02d:%02d",alarmTime.hour, alarmTime.minute);
1685 strncpy(edt_data->edtbuf1,lin2,MAX_LEN_TIME);
1686 edtShow(edt_data->editor_handle);
1687 }
1688 return 1;
1689 }
1690 return 0;
1691
1692 }
1693 /*******************************************************************************
1694
1695 $Function: tida_editor
1696
1697 $Description: dialog function for editor for time and date
1698
1699 $Returns: none.
1700
1701 $Arguments:
1702
1703 *******************************************************************************/
1704 static void tida_editor(T_MFW_HND win, USHORT event, SHORT value, void * parameter)
1705 {
1706 T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
1707 T_tida_edt * edt_data = (T_tida_edt *)win_data->user;
1708
1709
1710 T_tida * tida_data = (T_tida *)parameter;//tida main data
1711
1712 edt_data->state = tida_data->state;
1713
1714 TRACE_FUNCTION("MmiTimeDate:tida_editor");
1715
1716 /*
1717 * depending on event
1718 */
1719 switch (event)
1720 {
1721 case DATE_SHOW:
1722 case TIME_SHOW:
1723 memset(edt_data->edtbuf1, '\0', sizeof(edt_data->edtbuf1));/* initial buffer */
1724 edt_data->index = 0;
1725 winShow(edt_data->tida_edt_win);
1726 break;
1727 case DATE_ENTRY:
1728 case TIME_ENTRY:
1729 winShow(edt_data->tida_edt_win);
1730 break;
1731 default:
1732 break;
1733 }
1734 }
1735 /*******************************************************************************
1736
1737 $Function: tida_edt_kbd_cb
1738
1739 $Description: keyboard event handler for time and date
1740
1741 $Returns: none.
1742
1743 $Arguments:
1744
1745 *******************************************************************************/
1746 static int tida_edt_kbd_cb (MfwEvt e, MfwKbd *kc)
1747 {
1748
1749 T_MFW_HND win = mfw_parent(mfw_header());
1750
1751 T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
1752 T_tida_edt * edt_data = (T_tida_edt *)win_data->user;//tida edt data
1753
1754 T_MFW_WIN * win_tida =((T_MFW_HDR *)edt_data->parent_win)->data;
1755 T_tida * tida_data = (T_tida *)win_tida->user; // tida main data
1756
1757 char lin1[MAX_LEN_DATE];
1758 char lin2[MAX_LEN_TIME];
1759 T_MFW_TIME* currclock; /*SPR 2639*/
1760 currclock = mfw_td_get_time();/*SPR 2639*/
1761
1762 TRACE_FUNCTION ("MmiTimeDate: tida_edt_kbd_cb");
1763
1764 switch(kc->code)
1765 {
1766 case KCD_0:
1767 case KCD_1:
1768 case KCD_2:
1769 case KCD_3:
1770 case KCD_4:
1771 case KCD_5:
1772 case KCD_6:
1773 case KCD_7:
1774 case KCD_8:
1775 case KCD_9:
1776 if(edt_data->state EQ DATE_ENTRY) /* date entering */
1777 {
1778 if(edt_data->index < (MAX_LEN_DATE - 1))
1779 {
1780 if((edt_data->index NEQ 2) && (edt_data->index NEQ 5))
1781 {
1782 edt_data->edtbuf1[edt_data->index] = '0' + kc->code;
1783 edtChar(edt_data->editor_handle,edt_data->edtbuf1[edt_data->index]);
1784 edt_data->index++;
1785 }
1786
1787 if((edt_data->index EQ 2) || (edt_data->index EQ 5))
1788 {
1789 edtChar(edt_data->editor_handle,'/');
1790 edt_data->edtbuf1[edt_data->index] = '/';
1791 edt_data->index++;
1792 }
1793 }
1794 }
1795 else if(edt_data->state EQ TIME_ENTRY) /* time entering */
1796 {
1797 if(edt_data->index < (MAX_LEN_TIME -1))
1798 {
1799 if(edt_data->index NEQ 2)
1800 {
1801 edt_data->edtbuf1[edt_data->index] = '0' + kc->code;
1802 edtChar(edt_data->editor_handle,edt_data->edtbuf1[edt_data->index]);
1803 edt_data->index++;
1804 }
1805 if(edt_data->index EQ 2)
1806 {
1807 edtChar(edt_data->editor_handle,':');
1808 edt_data->edtbuf1[edt_data->index] = ':';
1809 edt_data->index++;
1810 }
1811 }
1812 }
1813 break;
1814 case KCD_MNUSELECT:
1815 case KCD_LEFT: /* select and ok button */
1816 if(edt_data->state EQ DATE_ENTRY)
1817 {
1818 if(check_date(win,edt_data))
1819 {
1820
1821 TRACE_EVENT("datecheck ok");
1822 edtClear(edt_data->editor_handle);
1823 edtHide(edt_data->editor_handle); /* verification date successfull */
1824 date_time_edt_destroy(edt_data->tida_edt_win);
1825 SEND_EVENT(tida_data->tida_win,TIME_ENTRY,0,tida_data);
1826
1827 }
1828 else
1829 {
1830 memset(edt_data->edtbuf1, '\0', sizeof(edt_data->edtbuf1));/* initial buffer */
1831 edt_data->index = 0;
1832
1833 sprintf(lin1,"dd/mm/yyyy");
1834 strncpy(edt_data->edtbuf1,lin1,MAX_LEN_DATE);
1835 edtReset(edt_data->editor_handle);
1836 edtShow(edt_data->editor_handle);
1837 }
1838 }
1839 else if(edt_data->state EQ TIME_ENTRY)
1840 {
1841 if(check_time(win,edt_data))
1842 {
1843 TRACE_EVENT("timecheck ok");
1844 edtClear(edt_data->editor_handle);
1845 edtHide(edt_data->editor_handle); /* verification date successfull */
1846 date_time_edt_destroy(edt_data->tida_edt_win);
1847 SEND_EVENT(tida_data->tida_win,ENTRY_OK,0,tida_data);
1848 }
1849 else
1850 {
1851 memset(edt_data->edtbuf1, '\0', sizeof(edt_data->edtbuf1));/* initial buffer */
1852 edt_data->index = 0;
1853
1854 sprintf(lin2,"%02d:%02d",mfw_td_convert_to_24_hour(currclock), currclock->minute);
1855 strncpy(edt_data->edtbuf1,lin2,MAX_LEN_TIME);
1856 edtReset(edt_data->editor_handle);
1857 edtShow(edt_data->editor_handle);
1858 }
1859 }
1860 else if(edt_data->state EQ DATE_SHOW)
1861 {
1862 date_time_edt_destroy(edt_data->tida_edt_win);
1863 SEND_EVENT(tida_data->tida_win,DATE_ENTRY,0,tida_data);
1864 } /* start date entering */
1865
1866 else if(edt_data->state EQ TIME_SHOW)
1867 {
1868 date_time_edt_destroy(edt_data->tida_edt_win);
1869 SEND_EVENT(tida_data->tida_win,TIME_ENTRY,0,tida_data); /* start time entering */
1870 }
1871 break;
1872 case KCD_RIGHT: /* back to previous menu */
1873 date_time_edt_destroy(edt_data->tida_edt_win);
1874 SEND_EVENT(tida_data->tida_win,TIDA_ABORT,0,tida_data);
1875 break;
1876 case KCD_MNUUP: /* cursor to right */
1877 if((edt_data->state EQ DATE_ENTRY) || (edt_data->state EQ TIME_ENTRY)) /* cursor to rigt */
1878 {
1879 edt_data->index++;
1880 edtChar(edt_data->editor_handle,ecRight);
1881
1882 if(((edt_data->state EQ DATE_ENTRY) && ((edt_data->index EQ 2)||(edt_data->index EQ 5))) || ((edt_data->state EQ TIME_ENTRY) && (edt_data->index EQ 2)))
1883 {
1884 edt_data->index++;
1885 edtChar(edt_data->editor_handle,ecRight);
1886 }
1887
1888 }
1889 break;
1890 case KCD_HUP:
1891 case KCD_MNUDOWN: /* cursor to left or clear */
1892 if((!(edt_data->state EQ DATE_SHOW)) && (!(edt_data->state EQ TIME_SHOW)))
1893 {
1894 if(edt_data->state EQ DATE_ENTRY)
1895 {
1896 if(edt_data->index EQ 0)
1897 ;
1898 else
1899 edt_data->index--;
1900
1901 if((edt_data->index EQ 2)||(edt_data->index EQ 5))
1902 {
1903 if(edt_data->index EQ 0)
1904 ;
1905 else
1906 edt_data->index--;
1907
1908 edtChar(edt_data->editor_handle,ecLeft);
1909 edtChar(edt_data->editor_handle,ecLeft);
1910 }
1911 else
1912 edtChar(edt_data->editor_handle,ecLeft);
1913 }
1914 if(edt_data->state EQ TIME_ENTRY)
1915 {
1916 if(edt_data->index EQ 0)
1917 ;
1918 else
1919 edt_data->index--;
1920
1921 if(edt_data->index EQ 2)
1922 {
1923 if(edt_data->index EQ 0)
1924 ;
1925 else
1926 edt_data->index--;
1927
1928 edtChar(edt_data->editor_handle,ecLeft);
1929 edtChar(edt_data->editor_handle,ecLeft);
1930 }
1931 else
1932 edtChar(edt_data->editor_handle,ecLeft);
1933 }
1934 }
1935 else
1936 timStart(edt_data->tim_out_handle); /* waiting for release clear otherwise to previous screen */
1937 break;
1938 default:
1939 return MFW_EVENT_CONSUMED;
1940 }
1941 return MFW_EVENT_CONSUMED;
1942 }
1943
1944 /*******************************************************************************
1945
1946 $Function: check_date
1947
1948 $Description: check date after date entering
1949
1950 $Returns: none.
1951
1952 $Arguments:
1953
1954 *******************************************************************************/
1955 static int check_date (T_MFW_HND win, void * edt_dat)
1956 {
1957 U8 i;
1958 T_tida_edt * edt_data = (T_tida_edt *)edt_dat;
1959 T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
1960 T_tida * tida_data = (T_tida *)win_data->user;
1961 T_MFW_DATE tempdate;
1962
1963 char internday[3];
1964 char internmonth[3];
1965 char internyear[5];
1966
1967 char debug[20];
1968 T_MFW_TIME* currclock; /*SPR 2639*/
1969 T_MFW_DATE* currdate;
1970 //T_MFW_TIME alarmTime; /*SPR 2639*/
1971
1972
1973 currclock= mfw_td_get_time();/*SPR 2639*/
1974 currdate =mfw_td_get_date();
1975
1976 TRACE_FUNCTION ("MmiTimeDate:check_date");
1977
1978 memset(internday, '\0', sizeof(internday));/* initial string */
1979 memset(internmonth, '\0', sizeof(internmonth));
1980 memset(internyear, '\0', sizeof(internyear));
1981
1982 internday[0] = edt_data->edtbuf1[0];
1983 internday[1] = edt_data->edtbuf1[1];
1984 internmonth[0] = edt_data->edtbuf1[3];
1985 internmonth[1] = edt_data->edtbuf1[4];
1986 for(i = 0;i<4;i++)
1987 {
1988 internyear[i] = edt_data->edtbuf1[6+i];
1989 }
1990
1991 tempdate.month = atoi(internmonth);
1992 if((tempdate.month > 12) || (tempdate.month < 1))
1993 return FALSE;
1994
1995 tempdate.day = atoi(internday);
1996 if((tempdate.day > 30) || (tempdate.day < 1))
1997 {
1998 if(tempdate.day EQ 31)
1999 {
2000 switch(tempdate.month)
2001 {
2002 case 1:
2003 case 3:
2004 case 5:
2005 case 7:
2006 case 8:
2007 case 10:
2008 case 12:
2009 break;
2010 default:
2011 return FALSE;
2012
2013 }
2014 }
2015 else
2016 return FALSE;
2017 }
2018
2019 tempdate.year = atoi(internyear);
2020
2021 if(tempdate.year < 2000)
2022 return FALSE;
2023
2024 if((tempdate.month EQ 2) && (tempdate.day EQ 29))
2025 {
2026 if(!(tempdate.year%4) || (tempdate.year EQ 2000))
2027 {
2028 if(DateTimeEntryMode == ALARM)
2029 {
2030 alarmDate.day = tempdate.day;
2031 alarmDate.month = tempdate.month;
2032 alarmDate.year = tempdate.year;
2033 }
2034 else
2035 {
2036
2037 currdate->day = tempdate.day;
2038 currdate->month = tempdate.month;
2039 currdate->year = tempdate.year;
2040 mfw_td_set_date(currdate);/*SPR 2639*/
2041 }
2042 return TRUE;
2043 }
2044 else
2045 return FALSE;
2046 }
2047 else
2048 {
2049 if(DateTimeEntryMode == ALARM)
2050 {
2051
2052
2053 alarmDate.day = tempdate.day;
2054 alarmDate.month = tempdate.month;
2055 alarmDate.year = tempdate.year;
2056
2057 }
2058 else
2059 {
2060 currdate->day = tempdate.day;
2061 currdate->month = tempdate.month;
2062 currdate->year = tempdate.year;
2063 }
2064 mfw_td_set_date(currdate);/*SPR 2639*/
2065 return TRUE;
2066 }
2067 }
2068 /*******************************************************************************
2069
2070 $Function: check_time
2071
2072 $Description: check time after time entering
2073
2074 $Returns: none.
2075
2076 $Arguments:
2077
2078 *******************************************************************************/
2079 static int check_time (T_MFW_HND win, void * edt_dat)
2080 {
2081 T_tida_edt * edt_data = (T_tida_edt *)edt_dat;
2082 T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
2083 T_tida * tida_data = (T_tida *)win_data->user;
2084 T_MFW_TIME tempclock;
2085 char debug[50];
2086 char internmin[3];
2087 char internhour[3];
2088 T_MFW_TIME* currclock; /*SPR 2639*/
2089 T_MFW_DATE* currdate;
2090 T_MFW_TIME_FORMAT current_format;
2091 //T_MFW_TIME alarmTime; /*SPR 2639*/
2092
2093 currclock = mfw_td_get_time();/*SPR 2639*/
2094 currdate = mfw_td_get_date();
2095
2096 current_format = currclock->format;
2097 memset(internmin, '\0', sizeof(internmin));/* initial string */
2098 memset(internhour, '\0', sizeof(internhour));
2099
2100 internhour[0] = edt_data->edtbuf1[0];
2101 internhour[1] = edt_data->edtbuf1[1];
2102 internmin[0] = edt_data->edtbuf1[3];
2103 internmin[1] = edt_data->edtbuf1[4];
2104
2105 tempclock.hour = atoi(internhour);
2106 if(tempclock.hour > 23)
2107 return FALSE;
2108
2109 tempclock.minute = atoi(internmin);
2110 if(tempclock.minute >59)
2111 return FALSE;
2112 if (DateTimeEntryMode == ALARM)
2113 {
2114 alarmTime.hour = tempclock.hour; /*SPR 2639*/
2115 alarmTime.minute = tempclock.minute;
2116 alarmTime.format = MFW_TIME_FORMAT_24HOUR;
2117 mfw_td_set_alarm(&alarmTime, &alarmDate);
2118 }
2119 else
2120 {
2121
2122
2123 currclock->hour = tempclock.hour;
2124 currclock->minute = tempclock.minute;
2125 currclock->format = MFW_TIME_FORMAT_24HOUR;
2126 mfw_td_set_time(currclock);/*SPR 2639*/
2127 mfw_td_set_time_format(current_format);
2128 }
2129
2130 return TRUE;
2131 }
2132 /*******************************************************************************
2133
2134 $Function: tida_edt_tim_out_cb
2135
2136 $Description: Callback function for timer for time and date
2137
2138 $Returns: none.
2139
2140 $Arguments:
2141
2142 *******************************************************************************/
2143 static void tida_edt_tim_out_cb(T_MFW_EVENT event,T_MFW_TIM * t)
2144 {
2145 T_MFW_HND win = mfw_parent(mfw_header());
2146
2147 T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
2148 T_tida_edt * tida_edt_data = (T_tida_edt *)win_data->user;
2149
2150 T_MFW_WIN * win_tida =((T_MFW_HDR *)tida_edt_data->parent_win)->data;
2151 T_tida * tida_data = (T_tida *)win_tida->user; // tida main data
2152
2153 date_time_edt_destroy(tida_edt_data->tida_edt_win);
2154 SEND_EVENT(tida_data->tida_win,TIDA_CLEAR,0,tida_data);
2155
2156 }
2157 /*******************************************************************************
2158
2159 $Function: tida_edt_kbd_long_cb
2160
2161 $Description: keyboard long event handler for time and date
2162
2163 $Returns: none.
2164
2165 $Arguments:
2166
2167 *******************************************************************************/
2168 static int tida_edt_kbd_long_cb (MfwEvt e, MfwKbd *kc)
2169 {
2170 T_MFW_HND win = mfw_parent(mfw_header());
2171
2172 T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
2173 T_tida_edt * edt_data = (T_tida_edt *)win_data->user;//tida edt data
2174
2175 T_MFW_WIN * win_tida =((T_MFW_HDR *)edt_data->parent_win)->data;
2176 T_tida * tida_data = (T_tida *)win_tida->user; // tida main data
2177
2178 TRACE_FUNCTION("MmiTimeDate:tida_edt_kbd_long_cb");
2179
2180 if ((e & KEY_CLEAR) && (e & KEY_LONG))
2181 {
2182
2183 if((!(edt_data->state EQ DATE_SHOW)) && (!(edt_data->state EQ TIME_SHOW)))
2184 {
2185
2186 if(edt_data->state EQ DATE_ENTRY)
2187 {
2188 date_time_edt_destroy(edt_data->tida_edt_win);
2189 SEND_EVENT(tida_data->tida_win,DATE_SHOW,0,tida_data);
2190 }
2191 else if(edt_data->state EQ TIME_ENTRY)
2192 {
2193 date_time_edt_destroy(edt_data->tida_edt_win);
2194
2195 SEND_EVENT(tida_data->tida_win,TIME_ENTRY,0,tida_data);
2196
2197 }
2198 return MFW_EVENT_CONSUMED;
2199
2200 }
2201 else
2202 {
2203 timStop(edt_data->tim_out_handle);
2204 date_time_edt_destroy(edt_data->tida_edt_win);
2205 SEND_EVENT(tida_data->tida_win,TIDA_TO_IDLE,0,tida_data);
2206 return MFW_EVENT_CONSUMED;
2207 }
2208 }
2209 else
2210 return MFW_EVENT_CONSUMED;
2211 }
2212 #endif /* NEW_EDITOR */ 1245 #endif /* NEW_EDITOR */
2213