workbench/prefs/time/main.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 /*********************************************************************************************/
   7
   8 #include "global.h"
   9 #include "version.h"
  10
  11 #include <stdlib.h>
  12
  13 #include <aros/debug.h>
  14
  15 #include <zune/clock.h>
  16 #include <zune/calendar.h>
  17
  18 /*********************************************************************************************/
  19
  20 #define ARG_TEMPLATE    "FROM,EDIT/S,USE/S,SAVE/S,PUBSCREEN/K"
  21
  22 #define ARG_FROM        0
  23 #define ARG_EDIT        1
  24 #define ARG_USE         2
  25 #define ARG_SAVE        3
  26 #define ARG_PUBSCREEN   4
  27
  28 #define NUM_ARGS        5
  29
  30 #define DO_SPECIAL_BUTTON_LAYOUT 1 /* all button get same width, but as small as possible,
  31                                       and spread along whole parent group */
  32
  33 #define SPACING_BUTTONGROUP 4
  34
  35 #define RETURNID_USE    1
  36 #define RETURNID_SAVE   2
  37
  38 /*********************************************************************************************/
  39
  40 static struct Hook              yearhook, clockhook, activehook, restorehook;
  41 #if DO_SPECIAL_BUTTON_LAYOUT
  42 static struct Hook              buttonlayouthook;
  43 #endif
  44 static struct RDArgs            *myargs;
  45 static Object                   *activetimestrobj = NULL;
  46 static IPTR                     args[NUM_ARGS];
  47
  48 static CONST_STRPTR monthlabels[] =
  49 {
  50     (STRPTR)"January",
  51     (STRPTR)"February",
  52     (STRPTR)"March",
  53     (STRPTR)"April",
  54     (STRPTR)"May",
  55     (STRPTR)"June",
  56     (STRPTR)"July",
  57     (STRPTR)"August",
  58     (STRPTR)"September",
  59     (STRPTR)"October",
  60     (STRPTR)"November",
  61     (STRPTR)"December",
  62     NULL
  63 };
  64
  65 /*********************************************************************************************/
  66
  67 static void CloseTimerDev(void);
  68 static void FreeArguments(void);
  69 static void KillGUI(void);
  70
  71 /*********************************************************************************************/
  72
  73 WORD ShowMessage(STRPTR title, STRPTR text, STRPTR gadtext)
  74 {
  75     struct EasyStruct es;
  76
  77     es.es_StructSize   = sizeof(es);
  78     es.es_Flags        = 0;
  79     es.es_Title        = title;
  80     es.es_TextFormat   = text;
  81     es.es_GadgetFormat = gadtext;
  82
  83     return EasyRequestArgs(NULL, &es, NULL, NULL);
  84 }
  85
  86 /*********************************************************************************************/
  87
  88 void Cleanup(STRPTR msg)
  89 {
  90     if (msg)
  91     {
  92         if (IntuitionBase && !((struct Process *)FindTask(NULL))->pr_CLI)
  93         {
  94             ShowMessage((STRPTR)"Time", msg, MSG(MSG_OK));
  95         }
  96         else
  97         {
  98             Printf((STRPTR)"Time: %s\n", msg);
  99         }
 100     }
 101
 102     KillGUI();
 103     FreeArguments();
 104     CloseTimerDev();
 105     CleanupLocale();
 106
 107     exit(prog_exitcode);
 108 }
 109
 110 /*********************************************************************************************/
 111
 112 static void OpenTimerDev(void)
 113 {
 114     if ((TimerMP = CreateMsgPort()))
 115     {
 116         if ((TimerIO = (struct timerequest *)CreateIORequest(TimerMP, sizeof(struct timerequest))))
 117         {
 118             if (!OpenDevice("timer.device", UNIT_VBLANK, (struct IORequest *)TimerIO, 0))
 119             {
 120                 TimerBase = (struct Device *)TimerIO->tr_node.io_Device;
 121             }
 122         }
 123     }
 124
 125     if (!TimerBase)
 126     {
 127         my_sprintf(s,(UBYTE *)MSG(MSG_CANT_OPEN_LIB),"timer.device", 0);
 128         Cleanup(s);
 129     }
 130 }
 131
 132 /*********************************************************************************************/
 133
 134 static void CloseTimerDev(void)
 135 {
 136     if (TimerIO)
 137     {
 138         CloseDevice((struct IORequest *)TimerIO);
 139         DeleteIORequest((struct IORequest *)TimerIO);
 140     }
 141
 142     if (TimerMP)
 143     {
 144         DeleteMsgPort(TimerMP);
 145     }
 146 }
 147
 148 /*********************************************************************************************/
 149
 150 static void OpenBattClockRes(void)
 151 {
 152     BattClockBase = OpenResource("battclock.resource");
 153
 154     if (!BattClockBase)
 155     {
 156         my_sprintf(s,(UBYTE *)MSG(MSG_CANT_OPEN_LIB),"battclock.resource", 0);
 157         Cleanup(s);
 158     }
 159 }
 160
 161 /*********************************************************************************************/
 162
 163 static void GetArguments(int argc, char **argv)
 164 {
 165
 166     if (argc) // started from CLI
 167     {
 168         if (!(myargs = ReadArgs(ARG_TEMPLATE, args, NULL)))
 169         {
 170             Fault(IoErr(), 0, s, 256);
 171             Cleanup(s);
 172         }
 173     }
 174
 175     // if (!args[ARG_FROM]) args[ARG_FROM] = (IPTR)CONFIGNAME_ENV;
 176 }
 177
 178 /*********************************************************************************************/
 179
 180 static void FreeArguments(void)
 181 {
 182     if (myargs) FreeArgs(myargs);
 183 }
 184
 185 /*********************************************************************************************/
 186
 187 #if DO_SPECIAL_BUTTON_LAYOUT
 188
 189 /*********************************************************************************************/
 190
 191 static ULONG ButtonLayoutFunc(struct Hook *hook, Object *obj, struct MUI_LayoutMsg *msg)
 192 {
 193     IPTR retval = MUILM_UNKNOWN;
 194
 195     switch(msg->lm_Type)
 196     {
 197         case MUILM_MINMAX:
 198             {
 199                 Object *cstate = (Object *)msg->lm_Children->mlh_Head;
 200             Object *child;
 201
 202             WORD maxminwidth = 0;
 203             WORD maxminheight = 0;
 204             WORD numchilds = 0;
 205
 206             while((child = NextObject(&cstate)))
 207             {
 208                 if (_minwidth(child)  > maxminwidth) maxminwidth = _minwidth(child);
 209                 if (_minheight(child) > maxminheight) maxminheight = _minheight(child);
 210                 numchilds++;
 211             }
 212
 213             msg->lm_MinMax.MinWidth =
 214             msg->lm_MinMax.DefWidth = numchilds * maxminwidth + SPACING_BUTTONGROUP * (numchilds - 1);
 215             msg->lm_MinMax.MaxWidth = MUI_MAXMAX;
 216
 217             msg->lm_MinMax.MinHeight =
 218             msg->lm_MinMax.DefHeight =
 219             msg->lm_MinMax.MaxHeight = maxminheight;
 220             }
 221             retval = 0;
 222             break;
 223
 224         case MUILM_LAYOUT:
 225             {
 226                 Object *cstate = (Object *)msg->lm_Children->mlh_Head;
 227             Object *child;
 228
 229             WORD maxminwidth = 0;
 230             WORD maxminheight = 0;
 231             WORD numchilds = 0;
 232             WORD x = 0, i = 0;
 233
 234             while((child = NextObject(&cstate)))
 235             {
 236                 if (_minwidth(child)  > maxminwidth) maxminwidth = _minwidth(child);
 237                 if (_minheight(child) > maxminheight) maxminheight = _minheight(child);
 238                 numchilds++;
 239             }
 240
 241             cstate = (Object *)msg->lm_Children->mlh_Head;
 242             while((child = NextObject(&cstate)))
 243             {
 244                 if (i == numchilds -1)
 245                 {
 246                     x = msg->lm_Layout.Width - maxminwidth;
 247                 }
 248                 else
 249                 {
 250                     x = maxminwidth + (msg->lm_Layout.Width - numchilds * maxminwidth) / (numchilds - 1);
 251                     x *= i;
 252                 }
 253                 MUI_Layout(child, x, 0, maxminwidth, maxminheight, 0);
 254
 255                 i++;
 256             }
 257             }
 258             retval = TRUE;
 259             break;
 260
 261     } /* switch(msg->lm_Type) */
 262
 263     return retval;
 264 }
 265
 266 /*********************************************************************************************/
 267
 268 #endif /* DO_SPECIAL_BUTTON_LAYOUT */
 269
 270 /*********************************************************************************************/
 271
 272 static void YearFunc(struct Hook *hook, Object *obj, IPTR *param)
 273 {
 274     IPTR year=1978;
 275
 276     get(obj, MUIA_String_Integer, &year);
 277
 278     if ((LONG)*param == -1)
 279     {
 280         year--;
 281     }
 282     else if ((LONG)*param == 1)
 283     {
 284         year++;
 285     }
 286
 287     if (year < 1978)
 288     {
 289         year = 1978;
 290         nnset(obj, MUIA_String_Integer, year);
 291     }
 292     else if (year > 2099)
 293     {
 294         year = 2099;
 295         nnset(obj, MUIA_String_Integer, year);
 296     }
 297     else if (*param)
 298     {
 299         nnset(obj, MUIA_String_Integer, year);
 300     }
 301
 302     nnset(calobj, MUIA_Calendar_Year, year);
 303
 304 }
 305
 306 /*********************************************************************************************/
 307
 308 static void ActiveFunc(struct Hook *hook, Object *obj, IPTR *param)
 309 {
 310     Object *active;
 311     WORD hand = -1;
 312
 313     active = *(Object **)param;
 314
 315     if (active == hourobj)
 316     {
 317         hand = MUIV_Clock_EditHand_Hour;
 318     }
 319     else if (active == minobj)
 320     {
 321         hand = MUIV_Clock_EditHand_Minute;
 322     }
 323     else if (active == secobj)
 324     {
 325         hand = MUIV_Clock_EditHand_Second;
 326     }
 327
 328     if (hand != -1)
 329     {
 330         activetimestrobj = active;
 331         set(clockobj, MUIA_Clock_EditHand, hand);
 332     }
 333 }
 334
 335 /*********************************************************************************************/
 336
 337 static void ClockFunc(struct Hook *hook, Object *obj, IPTR *param)
 338 {
 339     struct ClockData *cd=NULL;
 340     UBYTE s[3];
 341
 342     get(obj, MUIA_Clock_Time, &cd);
 343
 344     if (*param == 0)
 345     {
 346         if (activetimestrobj == NULL)
 347         {
 348             my_sprintf(s,(UBYTE *)"%02d",cd->hour);
 349             nnset(hourobj, MUIA_String_Contents, s);
 350
 351             my_sprintf(s,(UBYTE *)"%02d",cd->min);
 352             nnset(minobj, MUIA_String_Contents, s);
 353
 354             my_sprintf(s,(UBYTE *)"%02d",cd->sec);
 355             nnset(secobj, MUIA_String_Contents, s);
 356         }
 357     }
 358     else
 359     {
 360         struct ClockData  cd2;
 361         LONG              diff = (LONG)*param;
 362         LONG              max = 0;
 363         UWORD            *cd2_member = NULL;
 364
 365         if (diff == 100) diff = 0; /* 100 means string gadget acknowledge */
 366
 367         if (activetimestrobj == hourobj)
 368         {
 369             max = 23;
 370             cd2_member = &cd2.hour;
 371         }
 372         else if (activetimestrobj == minobj)
 373         {
 374             max = 59;
 375             cd2_member = &cd2.min;
 376
 377         }
 378         else if (activetimestrobj == secobj)
 379         {
 380             max = 59;
 381             cd2_member = &cd2.sec;
 382         }
 383
 384         if (max)
 385         {
 386             IPTR number = 0;
 387
 388             set(obj, MUIA_Clock_Frozen, TRUE);
 389             get(obj, MUIA_Clock_Time, &cd);
 390
 391             cd2 = *cd;
 392
 393             get(activetimestrobj, MUIA_String_Integer, &number);
 394
 395             number += diff;
 396
 397             if ((LONG)number < 0)
 398             {
 399                 number = max;
 400             }
 401             else if ((LONG)number > max)
 402             {
 403                 number = 0;
 404             }
 405             *cd2_member = number;
 406
 407             my_sprintf(s,(UBYTE *)"%02ld",number);
 408
 409             nnset(activetimestrobj, MUIA_String_Contents, s);
 410
 411             set(obj, MUIA_Clock_Time, (IPTR)&cd2);
 412         }
 413     }
 414
 415 }
 416
 417 /*********************************************************************************************/
 418
 419 static void RestoreFunc(struct Hook *hook, Object *obj, APTR msg)
 420 {
 421     RestorePrefs();
 422
 423     set(calobj, MUIA_Calendar_Date, (IPTR)&clockdata);
 424     set(monthobj, MUIA_Cycle_Active, clockdata.month - 1);
 425     set(yearobj, MUIA_String_Integer, clockdata.year);
 426     set(clockobj, MUIA_Clock_Frozen, FALSE);
 427 }
 428
 429 /*********************************************************************************************/
 430
 431 static void MakeGUI(void)
 432 {
 433     extern struct NewMenu nm;
 434
 435     Object *menu, *yearaddobj, *yearsubobj, *timeaddobj, *timesubobj;
 436     Object *saveobj, *useobj, *cancelobj;
 437
 438 #if DO_SPECIAL_BUTTON_LAYOUT
 439     buttonlayouthook.h_Entry = HookEntry;
 440     buttonlayouthook.h_SubEntry = (HOOKFUNC)ButtonLayoutFunc;
 441 #endif
 442     yearhook.h_Entry = HookEntry;
 443     yearhook.h_SubEntry = (HOOKFUNC)YearFunc;
 444
 445     clockhook.h_Entry = HookEntry;
 446     clockhook.h_SubEntry = (HOOKFUNC)ClockFunc;
 447
 448     activehook.h_Entry = HookEntry;
 449     activehook.h_SubEntry = (HOOKFUNC)ActiveFunc;
 450
 451     restorehook.h_Entry = HookEntry;
 452     restorehook.h_SubEntry = (HOOKFUNC)RestoreFunc;
 453
 454     if (LocaleBase)
 455     {
 456         struct Locale *locale = OpenLocale(NULL);
 457
 458         if (locale)
 459         {
 460             WORD i;
 461
 462             for(i = 0; i < 12; i++)
 463             {
 464                 monthlabels[i] = GetLocaleStr(locale, MON_1 + i);
 465             }
 466
 467             CloseLocale(locale);
 468         }
 469
 470     }
 471
 472     menu = MUI_MakeObject(MUIO_MenustripNM, &nm, 0);
 473
 474     app = ApplicationObject,
 475         MUIA_Application_Title, (IPTR)"Time",
 476         MUIA_Application_Version, (IPTR)VERSIONSTR,
 477         MUIA_Application_Copyright, (IPTR)"Copyright © 1995-2011, The AROS Development Team",
 478         MUIA_Application_Author, (IPTR)"The AROS Development Team",
 479         MUIA_Application_Description, (IPTR)MSG(MSG_WINTITLE),
 480         MUIA_Application_Base, (IPTR)"Time",
 481         menu ? MUIA_Application_Menustrip : TAG_IGNORE, menu,
 482
 483         SubWindow, wnd = WindowObject,
 484             MUIA_Window_Title, (IPTR)MSG(MSG_WINTITLE),
 485             MUIA_Window_ID, MAKE_ID('T','W','I','N'),
 486             MUIA_Window_CloseGadget, FALSE,
 487
 488             WindowContents, VGroup,
 489                 Child, HGroup, /* Group containing calendar box and clock box */
 490                     MUIA_Group_SameWidth, TRUE,
 491
 492                     Child, VGroup, /* Calendar box */
 493                         GroupFrame,
 494                         MUIA_Background, MUII_GroupBack,
 495                         Child, HGroup, /* Month/year row */
 496                             Child, monthobj = MUI_MakeObject(MUIO_Cycle, NULL, monthlabels),
 497                             Child, HVSpace,
 498                             Child, yearsubobj = TextObject, /* year [-] gadget */
 499                                 ButtonFrame,
 500                                 MUIA_Background, MUII_ButtonBack,
 501                                 MUIA_CycleChain, TRUE,
 502                                 MUIA_Font, MUIV_Font_Button,
 503                                 MUIA_InputMode, MUIV_InputMode_RelVerify,
 504                                 MUIA_Text_Contents, "\033c-",
 505                                 MUIA_FixWidthTxt, (IPTR)"+",
 506                             End,
 507                             Child, yearobj = StringObject, /* year gadget */
 508                                 StringFrame,
 509                                 MUIA_CycleChain, TRUE,
 510                                 MUIA_String_Accept, (IPTR)"0123456789",
 511                                 MUIA_FixWidthTxt, (IPTR)"55555",
 512                             End,
 513                             Child, yearaddobj = TextObject, /* year [+] gadget */
 514                                 ButtonFrame,
 515                                 MUIA_Background, MUII_ButtonBack,
 516                                 MUIA_CycleChain, TRUE,
 517                                 MUIA_Font, MUIV_Font_Button,
 518                                 MUIA_InputMode, MUIV_InputMode_RelVerify,
 519                                 MUIA_Text_Contents, "\033c+",
 520                                 MUIA_FixWidthTxt, (IPTR)"-",
 521                             End,
 522                         End,
 523                         Child, calobj = CalendarObject,
 524                             MUIA_CycleChain, TRUE,
 525                         End,
 526                     End,
 527
 528                     Child, VGroup, /* Clock box */
 529                         GroupFrame,
 530                         MUIA_Background, MUII_GroupBack,
 531
 532                         Child, clockobj = ClockObject,
 533                         End,
 534
 535                         Child, HGroup,
 536                             Child, HVSpace,
 537                             Child, PageGroup,
 538                             Child, HVSpace,
 539                             Child, HGroup,
 540                                 MUIA_Group_Spacing, 0,
 541                                 Child,  TextObject, /* phantom time [-] gadget */
 542                                     ButtonFrame,
 543                                     MUIA_Background, MUII_ButtonBack,
 544                                     MUIA_Font, MUIV_Font_Button,
 545                                     MUIA_InputMode, MUIV_InputMode_RelVerify,
 546                                     MUIA_Text_Contents, "\033c-",
 547                                     MUIA_FixWidthTxt, (IPTR)"+",
 548                                 End,
 549                                 Child,  TextObject, /* phantom time [+] gadget */
 550                                     ButtonFrame,
 551                                     MUIA_Background, MUII_ButtonBack,
 552                                     MUIA_Font, MUIV_Font_Button,
 553                                     MUIA_InputMode, MUIV_InputMode_RelVerify,
 554                                     MUIA_Text_Contents, "\033c+",
 555                                     MUIA_FixWidthTxt, (IPTR)"-",
 556                                 End,
 557                             End,
 558                         End,
 559
 560                         Child, hourobj = StringObject, /* hour gadget */
 561                             StringFrame,
 562                             MUIA_CycleChain, TRUE,
 563                             MUIA_String_Accept, (IPTR)"0123456789",
 564                             MUIA_FixWidthTxt, (IPTR)"555",
 565                         End,
 566                         Child, CLabel2(":"),
 567                         Child, minobj = StringObject, /* min gadget */
 568                             StringFrame,
 569                             MUIA_CycleChain, TRUE,
 570                             MUIA_String_Accept, (IPTR)"0123456789",
 571                             MUIA_FixWidthTxt, (IPTR)"555",
 572                         End,
 573                         Child, CLabel2(":"),
 574                         Child, secobj = StringObject, /* sec gadget */
 575                             StringFrame,
 576                             MUIA_CycleChain, TRUE,
 577                             MUIA_String_Accept, (IPTR)"0123456789",
 578                             MUIA_FixWidthTxt, (IPTR)"555",
 579                         End,
 580
 581                         Child, HGroup,
 582                             MUIA_Group_Spacing, 0,
 583                             Child,  timesubobj = TextObject, /* time [-] gadget */
 584                                 ButtonFrame,
 585                                 MUIA_Background, MUII_ButtonBack,
 586                                 MUIA_CycleChain, TRUE,
 587                                 MUIA_Font, MUIV_Font_Button,
 588                                 MUIA_InputMode, MUIV_InputMode_RelVerify,
 589                                 MUIA_Text_Contents, "\033c-",
 590                                 MUIA_FixWidthTxt, (IPTR)"+",
 591                             End,
 592                             Child,  timeaddobj = TextObject, /* time [+] gadget */
 593                                 ButtonFrame,
 594                                 MUIA_Background, MUII_ButtonBack,
 595                                 MUIA_CycleChain, TRUE,
 596                                 MUIA_Font, MUIV_Font_Button,
 597                                 MUIA_InputMode, MUIV_InputMode_RelVerify,
 598                                 MUIA_Text_Contents, "\033c+",
 599                                 MUIA_FixWidthTxt, (IPTR)"-",
 600                             End,
 601                         End,
 602
 603                         Child, HVSpace,
 604                         End,
 605                     End,
 606                 End,
 607                 Child, HGroup, /* save/use/cancel button row */
 608 #if DO_SPECIAL_BUTTON_LAYOUT
 609                     MUIA_Group_LayoutHook, (IPTR)&buttonlayouthook,
 610 #else
 611                     MUIA_FixHeight, 1,
 612                     MUIA_Group_SameWidth, TRUE,
 613 #endif
 614                     Child, saveobj = ImageButton(MSG(MSG_GAD_SAVE), "THEME:Images/Gadgets/Save"),
 615                     Child, useobj = ImageButton(MSG(MSG_GAD_USE), "THEME:Images/Gadgets/Use"),
 616                     Child, cancelobj = ImageButton(MSG(MSG_GAD_CANCEL), "THEME:Images/Gadgets/Cancel"),
 617                 End,
 618             End,
 619             End,
 620         End;
 621
 622     if (!app) Cleanup(MSG(MSG_CANT_CREATE_APP));
 623
 624     DoMethod(cancelobj, MUIM_Notify, MUIA_Pressed, FALSE, (IPTR) app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 625     DoMethod(saveobj, MUIM_Notify, MUIA_Pressed, FALSE, (IPTR) app, 2, MUIM_Application_ReturnID, RETURNID_SAVE);
 626     DoMethod(useobj, MUIM_Notify, MUIA_Pressed, FALSE, (IPTR) app, 2, MUIM_Application_ReturnID, RETURNID_USE);
 627
 628     DoMethod(wnd, MUIM_Notify, MUIA_Window_MenuAction, MSG_MEN_PROJECT_QUIT, (IPTR) app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
 629     DoMethod(wnd, MUIM_Notify, MUIA_Window_MenuAction, MSG_MEN_EDIT_RESTORE, (IPTR) app, 2, MUIM_CallHook, (IPTR)&restorehook);
 630
 631     DoMethod(wnd, MUIM_Notify, MUIA_Window_ActiveObject, MUIV_EveryTime, (IPTR) app, 3, MUIM_CallHook, (IPTR)&activehook, MUIV_TriggerValue);
 632     DoMethod(monthobj, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, (IPTR) calobj, 3, MUIM_NoNotifySet, MUIA_Calendar_Month0, MUIV_TriggerValue);
 633     DoMethod(yearobj, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, (IPTR) yearobj, 3, MUIM_CallHook, (IPTR)&yearhook, 0);
 634     DoMethod(yearaddobj, MUIM_Notify, MUIA_Timer, MUIV_EveryTime, (IPTR) yearobj, 3, MUIM_CallHook, (IPTR)&yearhook, 1);
 635     DoMethod(yearsubobj, MUIM_Notify, MUIA_Timer, MUIV_EveryTime, (IPTR) yearobj, 3, MUIM_CallHook, (IPTR)&yearhook, -1);
 636     DoMethod(timeaddobj, MUIM_Notify, MUIA_Timer, MUIV_EveryTime, (IPTR) clockobj, 3, MUIM_CallHook, (IPTR)&clockhook, 1);
 637     DoMethod(timesubobj, MUIM_Notify, MUIA_Timer, MUIV_EveryTime, (IPTR) clockobj, 3, MUIM_CallHook, (IPTR)&clockhook, -1);
 638     DoMethod(clockobj, MUIM_Notify, MUIA_Clock_Ticked, TRUE, (IPTR) clockobj, 3, MUIM_CallHook, (IPTR)&clockhook, 0);
 639     DoMethod(hourobj, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, (IPTR) clockobj, 3, MUIM_CallHook, (IPTR)&clockhook, 100);
 640     DoMethod(minobj, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, (IPTR) clockobj, 3, MUIM_CallHook, (IPTR)&clockhook, 100);
 641     DoMethod(secobj, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, (IPTR) clockobj, 3, MUIM_CallHook, (IPTR)&clockhook, 100);
 642
 643     set(calobj, MUIA_Calendar_Date, &clockdata);
 644     set(monthobj, MUIA_Cycle_Active, clockdata.month - 1);
 645     set(yearobj, MUIA_String_Integer, clockdata.year);
 646
 647     CallHook(&clockhook, clockobj, 0);
 648 }
 649
 650 /*********************************************************************************************/
 651
 652 static void KillGUI(void)
 653 {
 654     DisposeObject(app);
 655 }
 656
 657 /*********************************************************************************************/
 658
 659 static void HandleAll(void)
 660 {
 661     ULONG sigs = 0;
 662     LONG returnid;
 663
 664     set (wnd, MUIA_Window_Open, TRUE);
 665
 666     for(;;)
 667     {
 668         returnid = (LONG) DoMethod(app, MUIM_Application_NewInput, (IPTR) &sigs);
 669
 670         if ((returnid == MUIV_Application_ReturnID_Quit) ||
 671             (returnid == RETURNID_SAVE) || (returnid == RETURNID_USE)) break;
 672
 673         if (sigs)
 674         {
 675             sigs = Wait(sigs | SIGBREAKF_CTRL_C);
 676             if (sigs & SIGBREAKF_CTRL_C) break;
 677         }
 678     }
 679
 680     switch(returnid)
 681     {
 682         case RETURNID_SAVE:
 683         case RETURNID_USE:
 684             {
 685                 struct ClockData cal_date, clock_time, *dateptr=NULL;
 686             IPTR frozen = 0;
 687
 688                 get(calobj, MUIA_Calendar_Date, &dateptr);
 689             cal_date = *dateptr;
 690
 691             get(clockobj, MUIA_Clock_Frozen, &frozen);
 692             if (frozen)
 693             {
 694                 get(clockobj, MUIA_Clock_Time, &dateptr);
 695                 clock_time = *dateptr;
 696             }
 697             else
 698             {
 699                 struct timeval tv;
 700
 701                 GetSysTime(&tv);
 702                 Amiga2Date(tv.tv_secs, &clock_time);
 703             }
 704
 705             clockdata.sec   = clock_time.sec;
 706             clockdata.min   = clock_time.min;
 707             clockdata.hour  = clock_time.hour;
 708             clockdata.mday  = cal_date.mday;
 709             clockdata.month = cal_date.month;
 710             clockdata.year  = cal_date.year;
 711             clockdata.wday  = cal_date.wday;
 712
 713             if (returnid == RETURNID_SAVE)
 714             {
 715                 SavePrefs();
 716             }
 717             else
 718             {
 719                 UsePrefs();
 720             }
 721             }
 722             break;
 723
 724     }
 725 }
 726
 727 /*********************************************************************************************/
 728
 729 int main(int argc, char **argv)
 730 {
 731     InitLocale("System/Prefs/Time.catalog", 1);
 732     InitMenus();
 733     OpenTimerDev();
 734     OpenBattClockRes();
 735     GetArguments(argc, argv);
 736     InitPrefs((args[ARG_USE] ? TRUE : FALSE), (args[ARG_SAVE] ? TRUE : FALSE));
 737     MakeGUI();
 738     HandleAll();
 739     Cleanup(NULL);
 740
 741     return 0;
 742 }
 743
 744 /*********************************************************************************************/
 745
 746