workbench/prefs/locale/registertab.c

   1 /*
   2    Copyright © 2003-2013, The AROS Development Team. All rights reserved.
   3    $Id$
   4  */
   5
   6 #include <aros/debug.h>
   7
   8 #include <proto/alib.h>
   9 #include <proto/battclock.h>
  10 #include <proto/intuition.h>
  11 #include <proto/muimaster.h>
  12
  13 #include <devices/timer.h>
  14 #include <libraries/locale.h>
  15 #include <zune/customclasses.h>
  16 #include <zune/prefseditor.h>
  17
  18 #include <stdio.h>
  19
  20 #include "locale.h"
  21 #include "registertab.h"
  22 #include "misc.h"
  23 #include "prefs.h"
  24 #include "page_language.h"
  25 #include "page_region.h"
  26 #include "page_timezone.h"
  27
  28 /*** Instance Data **********************************************************/
  29
  30 struct LocaleRegister_DATA
  31 {
  32     int i;
  33
  34     Object *child;
  35     Object *language;
  36     Object *region;
  37     Object *timezone;
  38
  39     const char *LocaleRegisterLabels[3];
  40     char *tab_label;
  41
  42     BOOL save;
  43 };
  44
  45 STATIC VOID LocalePrefs2Gadgets(struct LocaleRegister_DATA *data);
  46 STATIC VOID Gadgets2LocalePrefs(struct LocaleRegister_DATA *data);
  47
  48 /*** Macros *****************************************************************/
  49 #define SETUP_INST_DATA struct LocaleRegister_DATA *data = INST_DATA(CLASS, self)
  50
  51 /*** Methods ****************************************************************/
  52
  53
  54 static Object *handle_New_error(Object *obj, struct IClass *cl, char *error)
  55 {
  56     struct LocaleRegister_DATA *data;
  57
  58     ShowMessage(error);
  59     D(bug("[Register class] %s\n", error));
  60
  61     if(!obj)
  62         return NULL;
  63
  64     data = INST_DATA(cl, obj);
  65
  66     if(data->language)
  67     {
  68         D(bug("[Register class] DisposeObject(data->language);\n"));
  69         DisposeObject(data->language);
  70         data->language = NULL;
  71     }
  72
  73     if(data->region)
  74     {
  75         D(bug("[Register class] DisposeObject(data->region);\n"));
  76         DisposeObject(data->region);
  77         data->region = NULL;
  78     }
  79
  80     if(data->timezone)
  81     {
  82         D(bug("[Register class] DisposeObject(data->timezone);\n"));
  83         DisposeObject(data->timezone);
  84         data->timezone = NULL;
  85     }
  86
  87     if(data->tab_label)
  88     {
  89         FreeVec(data->tab_label);
  90         data->tab_label = NULL;
  91     }
  92
  93     CoerceMethod(cl, obj, OM_DISPOSE);
  94     return NULL;
  95 }
  96
  97 Object *LocaleRegister__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
  98 {
  99     D(bug("[register class] LocaleRegister Class New\n"));
 100
 101     /*
 102      * we create self first and then create the child,
 103      * so we have self->data available already
 104      */
 105
 106     self = (Object *) DoSuperNewTags
 107     (
 108         CLASS, self, NULL,
 109         MUIA_PrefsEditor_Name, _(MSG_WINTITLE),
 110         MUIA_PrefsEditor_Path, (IPTR) "SYS/locale.prefs",
 111         MUIA_PrefsEditor_IconTool, (IPTR) "SYS:Prefs/Locale",
 112         TAG_DONE
 113     );
 114     if (self == NULL)
 115     {
 116         return handle_New_error(self, CLASS, "ERROR: Unable to create register object!\n");
 117     }
 118
 119     SETUP_INST_DATA;
 120
 121     data->language = NewObject(Language_CLASS->mcc_Class, NULL,
 122             MUIA_UserData, self,
 123             TAG_DONE);
 124
 125     if(!data->language)
 126         return handle_New_error(self, CLASS, "ERROR: Unable to create language object!\n");
 127
 128     data->region = ListviewObject, MUIA_Listview_List,
 129         NewObject(Region_CLASS->mcc_Class, 0,
 130                 MUIA_UserData, self,
 131                 TAG_DONE),
 132         End;
 133
 134     if(!data->region)
 135         return handle_New_error(self, CLASS, "ERROR: Unable to create region object!\n");
 136
 137     data->timezone = NewObject(Timezone_CLASS->mcc_Class, NULL,
 138             MUIA_UserData, self,
 139             TAG_DONE);
 140
 141     if(!data->timezone)
 142     {
 143         D(bug("icall register handle error\n"));
 144         return handle_New_error(self, CLASS,"ERROR: Unable to create timezone object!\n");
 145     }
 146
 147
 148     /*
 149      * Maybe, it would be easier to change the catalog,
 150      * but for me it's easier this way ;)
 151      */
 152     data->tab_label = AllocVec( strlen(_(MSG_GAD_TAB_LANGUAGE)) +
 153             strlen(_(MSG_GAD_TAB_REGION)) +
 154             strlen(" / ") + 1,
 155             MEMF_ANY);
 156
 157     if(!data->tab_label)
 158         return handle_New_error(self, CLASS, "ERROR: Unable to allocate tab_label!\n");
 159
 160     sprintf(data->tab_label, "%s / %s", _(MSG_GAD_TAB_REGION),
 161             _(MSG_GAD_TAB_LANGUAGE));
 162
 163     data->LocaleRegisterLabels[0] = data->tab_label;
 164     data->LocaleRegisterLabels[1] = _(MSG_GAD_TAB_TIMEZONE);
 165     data->LocaleRegisterLabels[2] = NULL;
 166
 167     data->child = RegisterGroup(data->LocaleRegisterLabels),
 168         MUIA_Register_Frame, TRUE,
 169         Child, HGroup,
 170             MUIA_Group_SameSize, TRUE,
 171             Child, HGroup,
 172                 MUIA_Frame, MUIV_Frame_Group,
 173                 MUIA_FrameTitle, _(MSG_GAD_TAB_REGION),
 174                 Child, data->region,
 175             End,
 176             Child, HGroup,
 177                 MUIA_Frame, MUIV_Frame_Group,
 178                 MUIA_FrameTitle, _(MSG_GAD_TAB_LANGUAGE),
 179                 Child, data->language,
 180             End,
 181         End,
 182         Child, data->timezone,
 183     End;
 184
 185     if(!data->child)
 186         return handle_New_error(self, CLASS, "ERROR: unable to create registergroup\n");
 187
 188     DoMethod(self, OM_ADDMEMBER, data->child);
 189
 190     DoMethod(data->region, MUIM_Region_Fill);
 191
 192     LocalePrefs2Gadgets(data);
 193
 194     return self;
 195 }
 196
 197 /*
 198  * update struct localprefs with actual data selected in gadgets:
 199  *
 200  * see prefs/locale.h
 201  *
 202  * struct LocalePrefs {
 203  *     char  lp_CountryName[32];
 204  *     char  lp_PreferredLanguages[10][30];
 205  *     LONG  lp_GMTOffset;
 206  *     ULONG lp_Flags;
 207  *
 208  *     struct CountryPrefs lp_CountryData;
 209  * };
 210  *
 211  */
 212 STATIC VOID Gadgets2LocalePrefs (struct LocaleRegister_DATA *data)
 213 {
 214     char *tmp;
 215     IPTR newtz;
 216     IPTR gmtclock;
 217     char **preferred = NULL;
 218     ULONG i;
 219     ULONG newflags;
 220     BOOL sync_clock = FALSE;
 221
 222     if (GetAttr(MUIA_Region_Regionname, data->region, (IPTR *)&tmp))
 223     {
 224         strncpy(localeprefs.lp_CountryName, tmp, 32);
 225         Prefs_LoadRegion(localeprefs.lp_CountryName, &localeprefs.lp_CountryData);
 226     }
 227
 228     if(GET(data->language, MUIA_Language_Preferred, &preferred))
 229     {
 230         for(i = 0; i < 10; i++)
 231         {
 232             if(preferred[i])
 233             {
 234                 strncpy(localeprefs.lp_PreferredLanguages[i], preferred[i], 30);
 235             }
 236             else
 237             {
 238                 localeprefs.lp_PreferredLanguages[i][0] = 0;
 239             }
 240         }
 241     }
 242     GetAttr(MUIA_Language_Characterset, data->language, (IPTR *)&tmp);
 243     if (tmp)
 244         strcpy(character_set, tmp);
 245     else
 246         character_set[0] = 0;
 247     D(bug("[locale prefs] New character set is %s\n", character_set));
 248
 249     GetAttr(MUIA_Timezone_Timeoffset, data->timezone, &newtz);
 250
 251     newflags = localeprefs.lp_Flags;
 252     GetAttr(MUIA_Timezone_GMTClock, data->timezone, &gmtclock);
 253     if (gmtclock)
 254         newflags |= LOCF_GMT_CLOCK;
 255     else
 256         newflags &= ~LOCF_GMT_CLOCK;
 257
 258     /*
 259      * If we change "GMT clock" setting, update system time from hardware clock.
 260      * We do it in order to prevent time de-synchronization and clobbering
 261      * hardware clock.
 262      */
 263     if ((newflags ^ localeprefs.lp_Flags) & LOCF_GMT_CLOCK)
 264         sync_clock = TRUE;
 265
 266     /* Do the same if 'GMT clock' is active and we change the time zone */
 267     if (gmtclock && (newtz != localeprefs.lp_GMTOffset))
 268         sync_clock = TRUE;
 269
 270     if (sync_clock)
 271     {
 272         struct Library *BattClockBase = OpenResource("battclock.resource");
 273
 274         if (BattClockBase)
 275         {
 276             struct MsgPort *mp = CreateMsgPort();
 277
 278             if (mp)
 279             {
 280                 struct timerequest *tr = (struct timerequest *)CreateIORequest(mp, sizeof(struct timerequest));
 281
 282                 if (tr)
 283                 {
 284                     if (OpenDevice("timer.device", UNIT_VBLANK, &tr->tr_node, 0) == 0)
 285                     {
 286                         ULONG time = ReadBattClock();
 287
 288                         if (tmp)
 289                         {
 290                             /* loc_GMTOffset actually expresses difference from local time to GMT */
 291                             time -= localeprefs.lp_GMTOffset * 60;
 292                         }
 293
 294                         /* Set timer.device clock */
 295                         tr->tr_node.io_Command = TR_SETSYSTIME;
 296                         tr->tr_time.tv_secs    = time;
 297                         tr->tr_time.tv_micro   = 0;
 298                         tr->tr_node.io_Flags   = IOF_QUICK;
 299                         DoIO(&tr->tr_node);
 300
 301                         CloseDevice(&tr->tr_node);
 302                     }
 303                     DeleteIORequest(&tr->tr_node);
 304                 }
 305                 DeleteMsgPort(mp);
 306             }
 307         }
 308     }
 309     localeprefs.lp_GMTOffset = newtz;
 310     localeprefs.lp_Flags = newflags;
 311 }
 312
 313 /*
 314  * update gadgets with values of struct localeprefs
 315  */
 316 STATIC VOID LocalePrefs2Gadgets(struct LocaleRegister_DATA *data)
 317 {
 318
 319     SET(data->region, MUIA_Region_Regionname, localeprefs.lp_CountryName);
 320
 321     SET(data->language, MUIA_Language_Preferred, TRUE);
 322     SET(data->language, MUIA_Language_Characterset, character_set);
 323
 324     SET(data->timezone, MUIA_Timezone_Timeoffset, -localeprefs.lp_GMTOffset);
 325     SET(data->timezone, MUIA_Timezone_GMTClock, localeprefs.lp_Flags & LOCF_GMT_CLOCK);
 326 }
 327
 328 IPTR LocaleRegister__MUIM_PrefsEditor_ImportFH
 329 (
 330     Class *CLASS, Object *self,
 331     struct MUIP_PrefsEditor_ImportFH *message
 332 )
 333 {
 334     SETUP_INST_DATA;
 335     BOOL success = TRUE;
 336
 337     D(bug("[localeregister class] LocaleRegister Class Import\n"));
 338
 339     success = Prefs_ImportFH(message->fh);
 340     if (success) LocalePrefs2Gadgets(data);
 341
 342     return success;
 343 }
 344
 345 IPTR LocaleRegister__MUIM_PrefsEditor_ExportFH
 346 (
 347     Class *CLASS, Object *self,
 348     struct MUIP_PrefsEditor_ExportFH *message
 349 )
 350 {
 351     SETUP_INST_DATA;
 352     BOOL success = TRUE;
 353
 354     D(bug("[localeregister class] LocaleRegister Class Export\n"));
 355
 356     Gadgets2LocalePrefs(data);
 357     success = Prefs_ExportFH(message->fh);
 358
 359     return success;
 360 }
 361
 362 IPTR LocaleRegister__MUIM_PrefsEditor_SetDefaults
 363 (
 364     Class *CLASS, Object *self, Msg message
 365 )
 366 {
 367     SETUP_INST_DATA;
 368     BOOL success = TRUE;
 369
 370     D(bug("[localeregister class] LocaleRegister Class SetDefaults\n"));
 371
 372     success = Prefs_Default();
 373     if (success) LocalePrefs2Gadgets(data);
 374
 375     return success;
 376 }
 377
 378 IPTR LocaleRegister__OM_DISPOSE(Class *CLASS, Object *self, Msg message)
 379 {
 380     SETUP_INST_DATA;
 381
 382     if(data->tab_label)
 383     {
 384         FreeVec(data->tab_label);
 385         data->tab_label = NULL;
 386     }
 387
 388     return DoSuperMethodA(CLASS, self, message);
 389 }
 390
 391 IPTR LocaleRegister__MUIM_PrefsEditor_Save(Class *cl, Object *obj, Msg msg)
 392 {
 393     IPTR res;
 394     struct LocaleRegister_DATA *data = INST_DATA(cl, obj);
 395
 396     /* We set this flag in order not to call Prefs_SaveCharset() twice */
 397     data->save = TRUE;
 398     res = DoSuperMethodA(cl, obj, msg);
 399     data->save = FALSE;
 400
 401     return res && Prefs_SaveCharset(TRUE);
 402 }
 403
 404 IPTR LocaleRegister__MUIM_PrefsEditor_Use(Class *cl, Object *obj, Msg msg)
 405 {
 406     struct LocaleRegister_DATA *data = INST_DATA(cl, obj);
 407
 408     if (!DoSuperMethodA(cl, obj, msg))
 409         return FALSE;
 410
 411     if (data->save)
 412         return TRUE;
 413
 414     return Prefs_SaveCharset(FALSE);
 415 }
 416
 417 /*** Setup ******************************************************************/
 418 ZUNE_CUSTOMCLASS_7
 419 (
 420     LocaleRegister, NULL, MUIC_PrefsEditor, NULL,
 421     OM_NEW,                       struct opSet *,
 422     OM_DISPOSE,                   Msg,
 423     MUIM_PrefsEditor_ImportFH,    struct MUIP_PrefsEditor_ImportFH *,
 424     MUIM_PrefsEditor_ExportFH,    struct MUIP_PrefsEditor_ExportFH *,
 425     MUIM_PrefsEditor_SetDefaults, Msg,
 426     MUIM_PrefsEditor_Save,        Msg,
 427     MUIM_PrefsEditor_Use,         Msg
 428 );