workbench/prefs/locale/page_country.c

   1 /*
   2     Copyright  2003-2008, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 // #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #include <exec/types.h>
   9 #include <utility/tagitem.h>
  10 #include <libraries/asl.h>
  11 #include <libraries/mui.h>
  12 #include <prefs/locale.h>
  13 #include <prefs/prefhdr.h>
  14 //#define DEBUG 1
  15 #include <zune/customclasses.h>
  16 #include <zune/prefseditor.h>
  17
  18 #include <proto/exec.h>
  19 #include <proto/intuition.h>
  20 #include <proto/utility.h>
  21 #include <proto/muimaster.h>
  22 #include <proto/dos.h>
  23 #include <proto/iffparse.h>
  24
  25 #include <string.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28
  29 #include <aros/debug.h>
  30
  31 #include "global.h"
  32 #include "page_country.h"
  33 #include "registertab.h"
  34
  35 /*** String Data ************************************************************/
  36
  37 /*** Instance Data **********************************************************/
  38
  39 typedef struct MUI_CountryPic
  40 {
  41   char          *strings_country;
  42   Object        *pic;
  43   Object        *list_pic;
  44 } MUI_CountryPic;
  45
  46 struct MUI_CountryData
  47 {
  48   Object         *me;
  49   Object         *child;
  50   Object         *prefs;
  51   ULONG           active;
  52   unsigned int    nr_countries;
  53   unsigned int    filled;
  54   MUI_CountryPic **pic;
  55 };
  56
  57 struct MUI_CustomClass     *Country_CLASS;
  58
  59 /*** Helpers *****************************************************************/
  60
  61 #define MAX_COUNTRY_LEN 256
  62
  63 /*******************************
  64  * prepare for fill_country_list
  65  *******************************/
  66
  67 STATIC VOID init_country_list(struct MUI_CountryData *data) {
  68
  69     struct CountryEntry *entry;
  70     BPTR                 lock;
  71     int                  i;
  72     char                 filename[MAX_COUNTRY_LEN];
  73
  74     if(data->filled)
  75     {
  76         return;
  77     }
  78
  79     data->filled=1;
  80
  81     /* count countries */
  82     data->nr_countries=0;
  83     ForeachNode(&country_list, entry)
  84     {
  85         data->nr_countries++;
  86     }
  87
  88     D(bug("[country class] nr of countries: %d\n",data->nr_countries));
  89
  90     data->pic=AllocVec(sizeof(struct MUI_CountryPic *) * (data->nr_countries+1),MEMF_CLEAR);
  91
  92     i=0;
  93     ForeachNode(&country_list, entry)
  94     {
  95         data->pic[i]=AllocVec(sizeof(struct MUI_CountryPic),MEMF_CLEAR);
  96
  97         snprintf(filename,MAX_COUNTRY_LEN-1,
  98                     "LOCALE:Flags/Countries/%s",entry->lve.realname);
  99
 100         if ((lock = Lock(filename, ACCESS_READ)) != NULL) {
 101             data->pic[i]->pic=(APTR) MUI_NewObject("Dtpic.mui",
 102                                        MUIA_Dtpic_Name,(ULONG) filename,
 103                                        TAG_DONE);
 104
 105             UnLock(lock);
 106             if(!data->pic[i]->pic)
 107             {
 108                 D(bug("[country class] Picture %s failed to load\n",filename));
 109             }
 110             else
 111             {
 112                 D(bug("[country class] Picture %s loaded: %lx\n",filename,data->pic[i]->pic));
 113             }
 114         }
 115
 116         if(data->pic[i]->pic)
 117         {
 118             data->pic[i]->list_pic=(Object *) DoMethod(data->child,
 119                           MUIM_List_CreateImage,data->pic[i]->pic,
 120                           0);
 121         }
 122         else
 123         {
 124             data->pic[i]->list_pic=NULL; /* should be ok */
 125             D(bug("ERROR: [country class] data->pic[%d]->pic is NULL!\n",i));
 126         }
 127         data->pic[i]->strings_country=AllocVec(sizeof(char) * MAX_COUNTRY_LEN,MEMF_CLEAR);
 128         snprintf(data->pic[i]->strings_country,
 129                  MAX_COUNTRY_LEN,"\33O[%08lx] %s",
 130                  (long unsigned int) data->pic[i]->list_pic,
 131                  entry->lve.name); /* 64-bit !? */
 132
 133         DoMethod(data->child,
 134                       MUIM_List_InsertSingle, data->pic[i]->strings_country,
 135                       MUIV_List_Insert_Bottom);
 136
 137         i++;
 138     }
 139
 140     /* we did remember that */
 141     nnset(data->child, MUIA_List_Active, data->active);
 142 }
 143
 144 /*** Methods ****************************************************************
 145  *
 146  */
 147
 148 Object *Country_New(struct IClass *cl, Object *obj, struct opSet *msg)
 149 {
 150     struct MUI_CountryData *data;
 151     struct TagItem *tstate, *tag;
 152
 153     D(bug("[country class] Country Class New\n"));
 154
 155     /*
 156      * country flags are at the moment 17 pixels high
 157      * MUIA_List_MinLineHeight, 18 leaves at least one
 158      * pixel space between the images
 159      * If images ever get bigger, this should be
 160      * no problem.
 161      */
 162
 163     obj = (Object *) DoSuperNewTags(
 164                           cl, obj, NULL,
 165                           InputListFrame,
 166                           MUIA_List_MinLineHeight, 18,
 167                           TAG_DONE
 168                       );
 169
 170     if (obj == NULL)
 171     {
 172         D(bug("ERROR: [country class] DoSuperNewTags failed!\n"));
 173         return NULL;
 174     }
 175
 176     data = INST_DATA(cl, obj);
 177
 178     tstate=((struct opSet *)msg)->ops_AttrList;
 179     while ((tag = (struct TagItem *) NextTagItem((APTR) &tstate)))
 180     {
 181         switch (tag->ti_Tag)
 182         {
 183             case MA_PrefsObject:
 184                 data->prefs = (Object *) tag->ti_Data;
 185                 break;
 186         }
 187     }
 188
 189     data->filled=0;
 190     data->child=obj;
 191
 192     /* changed hook */
 193     DoMethod(obj, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime, (IPTR) data->prefs, 3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE);
 194
 195     data->me=obj;
 196     return obj;
 197 }
 198
 199 /**************************************************************
 200  * seems like you can only call CreateImage after the list
 201  * is setup, which is quite late. So we do it, after
 202  * the list is shown. Nice? Not really. Maybe I did
 203  * not understand, why this needs to be.
 204  **************************************************************/
 205 static IPTR Country_Fill(struct IClass *cl, Object *obj, struct MUIP_Show *msg)
 206 {
 207     struct MUI_CountryData *data = INST_DATA(cl, obj);
 208
 209     IPTR         ret;
 210
 211     ret=DoSuperMethodA(cl, obj, (Msg)msg);
 212
 213     init_country_list(data);
 214
 215     return ret;
 216 }
 217
 218 /******************************************
 219  * According to the MUI docs, you should
 220  * call DeleteImage and Dispose during
 221  * Cleanup.
 222  ******************************************/
 223 static IPTR Country_Cleanup(struct IClass *cl, Object *obj, struct MUIP_Cleanup *msg)
 224 {
 225     struct MUI_CountryData *data = INST_DATA(cl, obj);
 226     unsigned int i;
 227
 228     D(bug("[country class] Country_Cleanup\n"));
 229
 230     if(data->filled)
 231     {
 232         for(i=0; i<data->nr_countries; i++)
 233         {
 234             if(data->pic[i])
 235             {
 236                 if(data->pic[i]->list_pic)
 237                 {
 238                     DoMethod(data->child,
 239                               MUIM_List_DeleteImage,data->pic[i]->list_pic);
 240                     data->pic[i]->list_pic=NULL;
 241                 }
 242                 if(data->pic[i]->pic)
 243                 {
 244                     DoMethod(data->pic[i]->pic,OM_DISPOSE);
 245                     data->pic[i]->pic=NULL;
 246                 }
 247             }
 248         }
 249     }
 250     else
 251     {
 252         D(bug("[country class] Country_Cleanup and !data->filled!?\n"));
 253     }
 254
 255     return DoSuperMethodA(cl,obj,(Msg)msg);
 256 }
 257
 258 static IPTR Country_Dispose(struct IClass *cl, Object *obj, Msg msg)
 259 {
 260     struct MUI_CountryData *data = INST_DATA(cl, obj);
 261     unsigned int i;
 262
 263     D(bug("[country class] Country_Dispose\n"));
 264
 265     if(!data->pic)
 266         return DoSuperMethodA(cl, obj, msg);
 267
 268     for(i=0;i<data->nr_countries;i++)
 269     {
 270         if(data->pic[i])
 271         {
 272             if(data->pic[i]->strings_country)
 273             {
 274                 FreeVec(data->pic[i]->strings_country);
 275             }
 276             FreeVec(data->pic[i]);
 277         }
 278     }
 279     FreeVec(data->pic);
 280     return DoSuperMethodA(cl, obj, msg);
 281 }
 282
 283 /*** Get ******************************************************************/
 284 static IPTR Country_Get(struct IClass *cl, Object *obj, struct opGet *msg)
 285 {
 286     struct MUI_CountryData *data = INST_DATA(cl, obj);
 287     struct CountryEntry    *entry;
 288     ULONG rc;
 289     ULONG nr;
 290     ULONG i;
 291
 292
 293     switch (msg->opg_AttrID)
 294     {
 295         case MA_CountryName:
 296             get(data->child, MUIA_List_Active, &nr);
 297             rc = -1;
 298             i  = 0;
 299             ForeachNode(&country_list, entry) {
 300                 if(i==nr)
 301                 {
 302                     rc = (ULONG)entry->lve.realname;
 303                 }
 304                 i++;
 305             }
 306
 307             if(rc == -1)
 308             {
 309                 *msg->opg_Storage = 0;
 310                 return FALSE;
 311             }
 312             break;
 313
 314         default:
 315             return DoSuperMethodA(cl, obj, (Msg)msg);
 316     }
 317
 318     *msg->opg_Storage = rc;
 319     return TRUE;
 320 }
 321
 322 /*** Set ******************************************************************/
 323 static IPTR Country_Set(struct IClass *cl, Object *obj, struct opSet *msg)
 324 {
 325     struct MUI_CountryData *data = INST_DATA(cl, obj);
 326     struct TagItem *tstate, *tag;
 327     struct CountryEntry    *entry;
 328     ULONG update;
 329     ULONG nr;
 330     ULONG i;
 331
 332     tstate = msg->ops_AttrList;
 333     update = FALSE;
 334
 335     while ((tag = (struct TagItem *) NextTagItem((APTR) &tstate)))
 336     {
 337         switch (tag->ti_Tag)
 338         {
 339             case MA_CountryName:
 340
 341                 nr = -1;
 342                 i  = 0;
 343                 ForeachNode(&country_list, entry) {
 344                     if(!stricmp(entry->lve.realname, (STRPTR)tag->ti_Data))
 345                     {
 346                         nr=i;
 347                     }
 348                     i++;
 349                 }
 350
 351                 if(nr < 0)
 352                 {
 353                     D(bug("ERROR: [country class] could not find >%s< !?\n",tag->ti_Data));
 354                 }
 355                 else
 356                 {
 357                     if(data->filled)
 358                     {
 359                         nnset(data->child, MUIA_List_Active, nr);
 360                         update=TRUE;
 361                     }
 362                     else
 363                     {
 364                         /* remember */
 365                         data->active=nr;
 366                     }
 367                 }
 368                 break;
 369
 370             default:
 371                 return DoSuperMethodA(cl, obj, (Msg)msg);
 372         }
 373     }
 374
 375     if(update)
 376     {
 377         MUI_Redraw(obj, MADF_DRAWOBJECT);
 378     }
 379
 380     return TRUE;
 381 }
 382
 383 /*** Setup ******************************************************************/
 384
 385 BOOPSI_DISPATCHER(IPTR, Country_Dispatcher, cl, obj, msg)
 386 {
 387     switch (msg->MethodID)
 388     {
 389         case OM_NEW:       return (IPTR) Country_New(cl, obj, (struct opSet *)msg);
 390         case MUIM_Show:    return Country_Fill(cl, obj, (struct MUIP_Show *)msg);
 391         case OM_GET:       return Country_Get(cl, obj, (APTR)msg);
 392         case OM_SET:       return Country_Set(cl, obj, (APTR)msg);
 393         case MUIM_Cleanup: return Country_Cleanup(cl, obj, (struct MUIP_Cleanup *)msg);
 394         case OM_DISPOSE:   return Country_Dispose(cl, obj, msg);
 395     }
 396
 397     return DoSuperMethodA(cl, obj, msg);
 398 }
 399 BOOPSI_DISPATCHER_END
 400
 401 /*
 402  * Class descriptor.
 403  */
 404 const struct __MUIBuiltinClass _MUIP_Country_desc =
 405 {
 406     "Country",
 407     MUIC_List,
 408     sizeof(struct MUI_CountryData),
 409     (void*)Country_Dispatcher
 410 };
 411
 412 void InitCountry()
 413 {
 414     Country_CLASS=MUI_CreateCustomClass(NULL,MUIC_List,NULL,sizeof(struct MUI_CountryData), &Country_Dispatcher);
 415 }
 416
 417 void CleanCountry()
 418 {
 419     if(Country_CLASS)
 420     {
 421         MUI_DeleteCustomClass(Country_CLASS);
 422         Country_CLASS=NULL;
 423     }
 424 }