workbench/prefs/locale/page_language.c

   1 /*
   2    Copyright © 2003-2011, The AROS Development Team. All rights reserved.
   3    $Id$
   4  */
   5
   6 // #define MUIMASTER_YES_INLINE_STDARG
   7
   8 //#define DEBUG 1
   9 #include <zune/customclasses.h>
  10 #include <zune/prefseditor.h>
  11
  12 #include <proto/alib.h>
  13 #include <proto/codesets.h>
  14 #include <proto/intuition.h>
  15 #include <proto/utility.h>
  16 #include <proto/muimaster.h>
  17
  18 #include <aros/debug.h>
  19
  20 #include "locale.h"
  21 #include "prefs.h"
  22 #include "misc.h"
  23 #include "registertab.h"
  24 #include "page_language.h"
  25
  26 /*** Instance Data **********************************************************/
  27
  28 struct Language_DATA
  29 {
  30     int nr_languages;
  31     int nr_preferred;
  32
  33     Object *child;
  34     Object *available;
  35     Object *preferred;
  36     Object *charset;
  37     Object *cslist;
  38     Object *cslistview;
  39     Object *popup;
  40     Object *clear;
  41     Object *prefs;
  42
  43     char  **strings_available;
  44     char  **strings_preferred;
  45     STRPTR *strings_charsets;
  46
  47     char  *result[10]; /* result array for Gadget2Prefs */
  48 };
  49
  50 struct MUI_CustomClass     *Language_CLASS;
  51
  52 static struct Hook hook_available;
  53 static struct Hook hook_preferred;
  54 static struct Hook hook_clear;
  55
  56 /*** Helpers *****************************************************************/
  57
  58 STATIC VOID update_language_lists(struct Language_DATA *data)
  59 {
  60     struct LanguageEntry *entry;
  61     int a;
  62     int p;
  63
  64     a=0;
  65     p=0;
  66     ForeachNode(&language_list, entry)
  67     {
  68         if(entry->preferred)
  69         {
  70             data->strings_preferred[p] = entry->lve.name;
  71             p++;
  72         }
  73         else
  74         {
  75             data->strings_available[a] = entry->lve.name;
  76             a++;
  77         }
  78     }
  79     data->strings_available[a] = NULL;
  80     data->strings_preferred[p] = NULL;
  81 }
  82
  83 STATIC VOID init_language_lists(struct Language_DATA *data)
  84 {
  85
  86     struct LanguageEntry *entry;
  87     int i;
  88
  89     data->nr_languages = 0;
  90     ForeachNode(&language_list, entry)
  91     {
  92         D(bug("entry->lve.name: %s\n",entry->lve.name));
  93         entry->preferred = FALSE;
  94         i = 0;
  95         D(bug("[language class]   language %s\n",entry->lve.name));
  96         while (i < 10 &&           /* max 10 preferred langs, see prefs/locale.h */
  97                 entry->preferred == FALSE &&
  98                 localeprefs.lp_PreferredLanguages[i][0])
  99         {
 100
 101             if (Stricmp(localeprefs.lp_PreferredLanguages[i], entry->lve.name) == 0)
 102             {
 103                 D(bug("[language class]            %s is preferred\n",
 104                             entry->lve.name));
 105                 entry->preferred = TRUE;
 106             }
 107             i++;
 108         }
 109         data->nr_languages++;
 110     }
 111
 112     D(bug("[language class]: nr of languages: %d\n",data->nr_languages));
 113
 114     data->strings_available = AllocVec(sizeof(char *) * (data->nr_languages+1), MEMF_CLEAR);
 115     data->strings_preferred = AllocVec(sizeof(char *) * (data->nr_languages+1), MEMF_CLEAR);
 116
 117     update_language_lists(data);
 118 }
 119
 120 /*** Hooks ******************************************************************
 121  *
 122  * hook_func_available
 123  *   handles double clicks on the available languages
 124  *
 125  * hook_func_preferred
 126  *   handles double clicks on the preferred languages
 127  *
 128  * hook_func_clear
 129  *   handles clearing of preferred languages
 130  *
 131  ****************************************************************************/
 132
 133 STATIC VOID func_move_to_selected(char* selstr, struct Language_DATA *data)
 134 {
 135     struct LanguageEntry *entry;
 136     unsigned int i = 0;
 137     char *test;
 138
 139     D(bug("func_move_to_selected(%s,..)\n",selstr));
 140
 141     if(selstr) {
 142         ForeachNode(&language_list, entry)
 143         {
 144             if (stricmp(selstr, entry->lve.name) == 0)
 145             {
 146                 DoMethod(data->preferred,
 147                         MUIM_List_InsertSingle, entry->lve.name,
 148                         MUIV_List_Insert_Bottom);
 149
 150                 entry->preferred = TRUE;
 151             }
 152         }
 153     }
 154
 155     /* we could use
 156      * DoMethod(data->available,MUIM_List_Remove, MUIV_List_Remove_Active);
 157      * of course, but I also want to be able to use that for
 158      * the Set method.
 159      */
 160
 161     GET(data->available,MUIA_List_Entries,&i);
 162     while(i)
 163     {
 164         i--;
 165         DoMethod(data->available, MUIM_List_GetEntry, i, &test);
 166         if (stricmp(selstr, test) == 0)
 167         {
 168             DoMethod(data->available, MUIM_List_Remove, i);
 169             i = 0;
 170         }
 171     }
 172 }
 173
 174 AROS_UFH2
 175 (
 176     void, hook_func_available,
 177     AROS_UFHA(struct Hook *,    hook,   A0),
 178     AROS_UFHA(APTR,             obj,    A2)
 179 )
 180 {
 181     AROS_USERFUNC_INIT
 182
 183         struct Language_DATA *data= hook->h_Data;
 184     char  *selstr;
 185
 186     D(bug("[register class] hook_func_available\n"));
 187
 188     DoMethod(obj,MUIM_List_GetEntry,
 189             MUIV_List_GetEntry_Active, &selstr);
 190
 191     func_move_to_selected(selstr, data);
 192
 193     AROS_USERFUNC_EXIT
 194 }
 195
 196 AROS_UFH2
 197 (
 198     void, hook_func_preferred,
 199     AROS_UFHA(struct Hook *,    hook,   A0),
 200     AROS_UFHA(APTR,             obj,    A2)
 201 )
 202 {
 203     AROS_USERFUNC_INIT
 204
 205     struct Language_DATA *data= hook->h_Data;
 206     char  *selstr;
 207     struct LanguageEntry *entry;
 208
 209     D(bug("[register class] hook_func_preferred\n"));
 210
 211     DoMethod(obj,MUIM_List_GetEntry,
 212             MUIV_List_GetEntry_Active, &selstr);
 213
 214     if(selstr)
 215     {
 216         D(bug("move: %s\n",selstr));
 217
 218         ForeachNode(&language_list, entry)
 219         {
 220             if (strcmp(selstr, entry->lve.name) == 0)
 221             {
 222                 DoMethod(data->available,
 223                         MUIM_List_InsertSingle, entry->lve.name,
 224                         MUIV_List_Insert_Sorted);
 225                 entry->preferred = FALSE;
 226             }
 227         }
 228         DoMethod(obj, MUIM_List_Remove, MUIV_List_Remove_Active);
 229     }
 230
 231     AROS_USERFUNC_EXIT
 232 }
 233
 234 STATIC VOID func_clear(struct Language_DATA *data)
 235 {
 236     struct LanguageEntry *entry;
 237
 238     D(bug("[register class] func_clear\n"));
 239
 240     /* clear it */
 241     DoMethod(data->preferred, MUIM_List_Clear);
 242
 243     /* add all old preferred languages again */
 244     DoMethod(data->available, MUIM_Group_InitChange);
 245     ForeachNode(&language_list, entry)
 246     {
 247         if(entry->preferred)
 248         {
 249             entry->preferred = FALSE;
 250             DoMethod(data->available,
 251                     MUIM_List_InsertSingle, entry->lve.name,
 252                     MUIV_List_Insert_Bottom);
 253         }
 254     }
 255     DoMethod(data->available, MUIM_List_Sort);
 256     DoMethod(data->available, MUIM_Group_ExitChange);
 257
 258 }
 259
 260 AROS_UFH2(
 261         void, hook_func_clear,
 262         AROS_UFHA(struct Hook *,    hook,   A0),
 263         AROS_UFHA(APTR *,           obj,    A2)
 264         )
 265 {
 266     AROS_USERFUNC_INIT
 267
 268     struct Language_DATA *data = hook->h_Data;
 269
 270     func_clear(data);
 271
 272     AROS_USERFUNC_EXIT
 273 }
 274
 275 AROS_UFH3
 276 (
 277     void, charset_popup_to_string,
 278     AROS_UFHA(struct Hook*, hook, A0),
 279     AROS_UFHA(Object *, list, A2),
 280     AROS_UFHA(Object *, string, A1)
 281 )
 282 {
 283     AROS_USERFUNC_INIT
 284
 285     STRPTR listentry;
 286     STRPTR oldentry;
 287
 288     GetAttr(MUIA_Text_Contents, string, (IPTR *)&oldentry);
 289     DoMethod(list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, (IPTR)&listentry);
 290     if (strcmp(listentry, oldentry))
 291     {
 292         SetAttrs(string, MUIA_Text_Contents, listentry, TAG_DONE);
 293         SetAttrs(hook->h_Data, MUIA_PrefsEditor_Changed, TRUE, TAG_DONE);
 294     }
 295
 296     AROS_USERFUNC_EXIT
 297 }
 298
 299 AROS_UFH3
 300 (
 301     ULONG, charset_string_to_popup,
 302     AROS_UFHA(struct Hook*, hook, A0),
 303     AROS_UFHA(Object *, list, A2),
 304     AROS_UFHA(Object *, str, A1)
 305 )
 306 {
 307     AROS_USERFUNC_INIT
 308
 309     STRPTR strtext, listentry;
 310     LONG index;
 311
 312     GetAttr(MUIA_Text_Contents, str, (IPTR *)&strtext);
 313
 314     for(index = 0; ; index++)
 315     {
 316         DoMethod(list, MUIM_List_GetEntry, index, (IPTR)&listentry);
 317
 318         if (!listentry)
 319         {
 320             SET(list, MUIA_List_Active, MUIV_List_Active_Off);
 321             break;
 322         }
 323
 324         if (stricmp(strtext, listentry) == 0)
 325         {
 326             SET(list, MUIA_List_Active, index);
 327             break;
 328         }
 329     }
 330
 331     return TRUE;
 332
 333     AROS_USERFUNC_EXIT
 334 }
 335
 336 static struct Hook charset_popup_to_string_hook =
 337 {
 338     {NULL, NULL},
 339     (HOOKFUNC)AROS_ASMSYMNAME(charset_popup_to_string),
 340     NULL,
 341     NULL
 342 };
 343
 344 static struct Hook charset_string_to_popup_hook =
 345 {
 346     {NULL, NULL},
 347     (HOOKFUNC)AROS_ASMSYMNAME(charset_string_to_popup),
 348     NULL,
 349     NULL
 350 };
 351
 352 /*** Methods ****************************************************************
 353  *
 354  */
 355
 356 static void free_strings(struct Language_DATA *data)
 357 {
 358     if (data->strings_charsets)
 359     {
 360         CodesetsFreeA(data->strings_charsets, NULL);
 361         data->strings_charsets = NULL;
 362     }
 363     if(data->strings_available)
 364     {
 365         FreeVec(data->strings_available);
 366         data->strings_available = NULL;
 367     }
 368
 369     if(data->strings_preferred)
 370     {
 371         FreeVec(data->strings_preferred);
 372         data->strings_preferred = NULL;
 373     }
 374
 375 }
 376
 377 static Object *handle_New_error(Object *obj, struct IClass *cl, char *error)
 378 {
 379     struct Language_DATA *data;
 380
 381     ShowMessage(error);
 382     D(bug("[Language class] %s\n"));
 383
 384     if(!obj)
 385         return NULL;
 386
 387     data = INST_DATA(cl, obj);
 388
 389     if(data->clear)
 390     {
 391         DisposeObject(data->clear);
 392         data->clear=NULL;
 393     }
 394
 395     if(data->available)
 396     {
 397         DisposeObject(data->available);
 398         data->available=NULL;
 399     }
 400
 401     if(data->preferred)
 402     {
 403         DisposeObject(data->preferred);
 404         data->preferred = NULL;
 405     }
 406
 407     if(data->child)
 408     {
 409         DisposeObject(data->child);
 410         data->child = NULL;
 411     }
 412
 413     if (data->charset) {
 414         DisposeObject(data->charset);
 415         data->charset = NULL;
 416     }
 417
 418     if (data->cslist) {
 419         DisposeObject(data->cslist);
 420         data->cslist = NULL;
 421     }
 422
 423     if (data->cslistview) {
 424         DisposeObject(data->cslistview);
 425         data->cslist = NULL;
 426     }
 427
 428     if (data->popup) {
 429         DisposeObject(data->popup);
 430         data->popup = NULL;
 431     }
 432
 433     free_strings(data);
 434
 435     CoerceMethod(cl, obj, OM_DISPOSE);
 436     return NULL;
 437 }
 438
 439 Object *Language__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 440 {
 441     struct Language_DATA *data;
 442     struct TagItem *tstate, *tag;
 443
 444     D(bug("[language class] Language Class New\n"));
 445
 446     /*
 447      * we create self first and then create the child,
 448      * so we have self->data available already
 449      */
 450
 451     obj = (Object *) DoSuperNewTags
 452     (
 453         cl, obj, NULL,
 454         TAG_DONE
 455     );
 456
 457     if (obj == NULL)
 458     {
 459         return handle_New_error(obj, cl, "ERROR: Unable to create object!\n");
 460     }
 461
 462     data = INST_DATA(cl, obj);
 463
 464     tstate=((struct opSet *)msg)->ops_AttrList;
 465     while ((tag = (struct TagItem *) NextTagItem((APTR) &tstate)))
 466     {
 467         switch (tag->ti_Tag)
 468         {
 469             case MUIA_UserData:
 470                 data->prefs = (Object *) tag->ti_Data;
 471                 break;
 472         }
 473     }
 474
 475     if(!data->prefs)
 476         return handle_New_error(obj, cl, "ERROR: MA_PrefsObject not supplied!\n");
 477
 478     init_language_lists(data);
 479     data->strings_charsets = CodesetsSupportedA(NULL);
 480
 481     data->clear = MUI_MakeObject(MUIO_Button, __(MSG_GAD_CLEAR_LANGUAGES));
 482
 483     data->available = ListviewObject, MUIA_Listview_List,
 484         ListObject,
 485             InputListFrame,
 486             MUIA_List_SourceArray, data->strings_available,
 487         End,
 488     End;
 489
 490     data->preferred = ListviewObject, MUIA_Listview_List,
 491         ListObject,
 492             InputListFrame,
 493             MUIA_List_SourceArray, data->strings_preferred,
 494         End,
 495     End;
 496
 497     data->charset = TextObject,
 498         TextFrame,
 499         MUIA_Background, MUII_TextBack,
 500     End;
 501
 502     data->cslist = ListObject,
 503         MUIA_Frame, MUIV_Frame_InputList,
 504         MUIA_Background, MUII_ListBack,
 505         MUIA_List_AutoVisible, TRUE,
 506         MUIA_List_SourceArray, data->strings_charsets,
 507     End;
 508
 509     data->cslistview = ListviewObject,
 510         MUIA_Listview_List, data->cslist,
 511     End;
 512
 513     charset_popup_to_string_hook.h_Data = data->prefs;
 514
 515     data->popup = PopobjectObject,
 516         MUIA_Popobject_Object, data->cslistview,
 517         MUIA_Popobject_StrObjHook, &charset_string_to_popup_hook,
 518         MUIA_Popobject_ObjStrHook, &charset_popup_to_string_hook,
 519         MUIA_Popstring_Button, PopButton(MUII_PopUp),
 520         MUIA_Popstring_String, data->charset,
 521     End;
 522
 523     if(!data->clear || !data->available || !data->preferred || !data->charset || !data->cslist ||
 524             !data->cslistview || !data->popup)
 525         return handle_New_error(obj,cl,"ERROR: MakeObject failed\n");
 526
 527     DoMethod(data->cslist, MUIM_List_Sort);
 528     DoMethod(data->cslist, MUIM_List_InsertSingle, _(MSG_NOT_SPECIFIED), MUIV_List_Insert_Top);
 529
 530     data->child = VGroup,
 531         Child, HGroup,
 532             Child, VGroup, /* Available Languages */
 533                 Child, CLabel1(_(MSG_GAD_AVAIL_LANGUAGES)),
 534                 Child, data->available,
 535             End,
 536             Child, VGroup, /* Preferred Languages */
 537                 Child, CLabel1(_(MSG_GAD_PREF_LANGUAGES)),
 538                 Child, data->preferred,
 539             End,
 540         End,
 541         Child, data->clear,
 542         Child, HGroup,
 543             Child, CLabel1(_(MSG_CHARACTER_SET)),
 544             Child, data->popup,
 545         End,
 546     End;
 547
 548     if(!data->child)
 549         return handle_New_error(obj, cl, "ERROR: create child failed\n");
 550
 551     /* add to self */
 552     DoMethod(obj, OM_ADDMEMBER, data->child);
 553
 554     /* setup hooks */
 555     DoMethod(data->cslistview, MUIM_Notify, MUIA_Listview_DoubleClick, TRUE, data->popup, 2, MUIM_Popstring_Close, TRUE);
 556
 557     /* move hooks */
 558     hook_available.h_Entry    = (HOOKFUNC) hook_func_available;
 559     hook_available.h_Data     = data ;
 560     DoMethod
 561     (
 562         data->available, MUIM_Notify, MUIA_Listview_DoubleClick, MUIV_EveryTime, data->available,
 563         2, MUIM_CallHook, (IPTR) &hook_available
 564     );
 565
 566     hook_preferred.h_Entry    = (HOOKFUNC) hook_func_preferred;
 567     hook_preferred.h_Data     = data ;
 568     DoMethod
 569     (
 570         data->preferred, MUIM_Notify, MUIA_Listview_DoubleClick, MUIV_EveryTime, data->preferred,
 571         2, MUIM_CallHook, (IPTR) &hook_preferred
 572     );
 573
 574     /* clear hook */
 575     hook_clear.h_Entry    = (HOOKFUNC) hook_func_clear;
 576     hook_clear.h_Data     = data ;
 577     DoMethod
 578     (
 579         data->clear, MUIM_Notify, MUIA_Selected, MUIV_EveryTime, data->preferred,
 580         2, MUIM_CallHook, (IPTR) &hook_clear
 581     );
 582
 583     /* changed hooks */
 584     DoMethod
 585     (
 586         data->preferred, MUIM_Notify, MUIA_Listview_DoubleClick, MUIV_EveryTime, (IPTR) data->prefs,
 587         3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE
 588     );
 589     DoMethod
 590     (
 591         data->available, MUIM_Notify, MUIA_Listview_DoubleClick, MUIV_EveryTime, (IPTR) data->prefs,
 592         3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE
 593     );
 594
 595     return obj;
 596 }
 597
 598 /*** Get ******************************************************************/
 599
 600 static IPTR Language__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 601 {
 602     struct Language_DATA *data = INST_DATA(cl, obj);
 603     IPTR rc;
 604     IPTR i;
 605
 606     switch (msg->opg_AttrID)
 607     {
 608         case MUIA_Language_Preferred: /* return array of preferred language strings */
 609             for (i = 0; i < 10; i++)
 610             {
 611                 DoMethod(data->preferred, MUIM_List_GetEntry, i, &data->result[i]);
 612             }
 613             rc = (IPTR) data->result;
 614             break;
 615         case MUIA_Language_Characterset:
 616             GetAttr(MUIA_List_Active, data->cslist, (IPTR *)&i);
 617             D(bug("[Language::Get] Active character set entry is %d\n", i));
 618             if ((i == 0) || (i == MUIV_List_Active_Off))
 619                 *msg->opg_Storage = 0;
 620             else
 621                 GetAttr(MUIA_Text_Contents, data->charset, msg->opg_Storage);
 622             return TRUE;
 623         default:
 624             return DoSuperMethodA(cl, obj, (Msg)msg);
 625     }
 626
 627     *msg->opg_Storage = rc;
 628     return TRUE;
 629 }
 630
 631 /*** Set ******************************************************************/
 632 static IPTR Language__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 633 {
 634     struct Language_DATA *data = INST_DATA(cl, obj);
 635     struct TagItem *tstate, *tag;
 636     ULONG update;
 637     ULONG i;
 638
 639     tstate = msg->ops_AttrList;
 640     update = FALSE;
 641
 642     while ((tag = (struct TagItem *) NextTagItem((APTR) &tstate)))
 643     {
 644         switch (tag->ti_Tag)
 645         {
 646             case MUIA_Language_Preferred:
 647                 /* clear preferred */
 648                 func_clear(data);
 649                 for (i = 0; i < 10; i++)
 650                 {
 651                     if(localeprefs.lp_PreferredLanguages[i][0] != '\0')
 652                     {
 653                         func_move_to_selected(localeprefs.lp_PreferredLanguages[i], data);
 654                     }
 655                 }
 656
 657                 update = TRUE;
 658                 break;
 659             case MUIA_Language_Characterset:
 660                 {
 661                     char *charset = (char *)tag->ti_Data;
 662
 663                     if (!charset || !*charset)
 664                         DoMethod(data->cslist, MUIM_List_GetEntry, 0, (IPTR *)&charset);
 665                     SetAttrs(data->charset, MUIA_Text_Contents, charset, TAG_DONE);
 666                 }
 667                 break;
 668
 669             default:
 670                 return DoSuperMethodA(cl, obj, (Msg)msg);
 671         }
 672     }
 673
 674     if(update)
 675     {
 676         MUI_Redraw(obj, MADF_DRAWOBJECT);
 677     }
 678
 679     return TRUE;
 680 }
 681
 682 static IPTR Language__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 683 {
 684     struct Language_DATA *data = INST_DATA(cl, obj);
 685
 686     D(bug("Language_Dispose\n"));
 687
 688     free_strings(data);
 689
 690     return DoSuperMethodA(cl, obj, msg);
 691 }
 692
 693 /*** Setup ******************************************************************/
 694 ZUNE_CUSTOMCLASS_4
 695 (
 696     Language, NULL, MUIC_Group, NULL,
 697     OM_NEW, struct opSet *,
 698     OM_SET, struct opSet *,
 699     OM_GET, struct opGet *,
 700     OM_DISPOSE, Msg
 701 );