workbench/prefs/PSI/screenlist_class.c

   1 /*
   2     Copyright © 1995-1997 Stefan Stuntz.
   3     Copyright © 2009-2011, The AROS Development Team.
   4     All rights reserved.
   5
   6     $Id$
   7 */
   8
   9 #include <proto/muiscreen.h>
  10 #include <proto/graphics.h>
  11 #include <proto/alib.h>
  12 #include <proto/intuition.h>
  13 #include <proto/muimaster.h>
  14
  15 #include <datatypes/pictureclass.h>
  16
  17 #include <string.h>
  18 #include <stdio.h>
  19
  20 #include "screenlist_class.h"
  21
  22 #define USE_PSI_SCREENON_HEADER
  23 #define USE_PSI_SCREENON_BODY
  24 #define USE_PSI_SCREENON_COLORS
  25 #include "psi_screenon.bh"
  26
  27 /*
  28 #define USE_PSI_SCREENOF_BODY
  29 #include "psi_screenof.bh"
  30 */
  31
  32 #define USE_PSI_SCREENCN_BODY
  33 #include "psi_screencn.bh"
  34
  35 /*
  36 #define USE_PSI_SCREENCF_BODY
  37 #include "psi_screencf.bh"
  38 */
  39
  40 /****************************************************************************************/
  41
  42 struct ScreenList_Data
  43 {
  44     Object *list;
  45     Object *onormal[2];
  46     /*
  47     Object *oforeign[2];
  48     */
  49     APTR inormal[2];
  50     /*
  51     APTR iforeign[2];
  52     */
  53     struct Hook DisplayHook;
  54 };
  55
  56 /****************************************************************************************/
  57
  58 IPTR ScreenList_ConstructFunc(struct Hook *hook, APTR pool, struct MUI_PubScreenDesc *src)
  59 {
  60     struct MUI_PubScreenDesc *desc;
  61
  62     if ((desc = MUIS_AllocPubScreenDesc(src)))
  63     {
  64         desc->Changed  = FALSE;
  65         desc->UserData = NULL;
  66     }
  67
  68     return (IPTR)desc;
  69 }
  70
  71 /****************************************************************************************/
  72
  73 VOID ScreenList_DestructFunc(struct Hook *hook, APTR pool, struct MUI_PubScreenDesc *desc)
  74 {
  75     MUIS_FreePubScreenDesc(desc);
  76 }
  77
  78 /****************************************************************************************/
  79
  80 LONG ScreenList_CompareFunc(struct Hook *hook, struct MUI_PubScreenDesc *d2, struct MUI_PubScreenDesc *d1)
  81 {
  82     if (!strcmp(d1->Name, PSD_INITIAL_NAME))
  83         return strcmp(d2->Name, PSD_INITIAL_NAME) ? 1 : 0;
  84     else if (!strcmp(d2->Name, PSD_INITIAL_NAME))
  85         return -1;
  86     else
  87         return stricmp(d1->Name, d2->Name);
  88 }
  89
  90 /****************************************************************************************/
  91
  92 LONG ScreenList_DisplayFunc(struct Hook *hook, char **array, struct MUI_PubScreenDesc *desc)
  93 {
  94     struct ScreenList_Data *data = (APTR)hook->h_Data;
  95
  96     *array++ = "";
  97
  98     if (!desc)
  99     {
 100         static char buf1[30], buf2[30];
 101         strcpy(buf1, "\33b\33u");
 102         strcpy(buf2, "\33b\33u");
 103         strcat(buf1, GetStr(MSG_LIST_SCREENNAME));
 104         strcat(buf2, GetStr(MSG_LIST_SCREENMODE));
 105         *array++ = "";
 106         *array++ = buf1;
 107         *array   = buf2;
 108     }
 109     else
 110     {
 111         static struct NameInfo ni;
 112         static char buf1[PSD_MAXLEN_NAME+2];
 113         static char buf2[50];
 114
 115         strcpy(buf1, desc->UserData ? "\33b" : desc->Changed ? "\33u" : "");
 116         strcat(buf1, desc->Name);
 117
 118         /*
 119         if (desc->Foreign)
 120         {
 121             strcpy(ni.Name,GetStr(MSG_LIST_FOREIGNSCREEN));
 122             sprintf(buf2,"\33O[%08lx]",data->iforeign[TestPubScreen(desc->Name) ? 1 : 0]);
 123         }
 124         else
 125         */
 126         {
 127             if (!GetDisplayInfoData(0, (UBYTE *)&ni, sizeof(ni), DTAG_NAME, desc->DisplayID))
 128                 strcpy(ni.Name, GetStr(MSG_LIST_UNKNOWNMODE));
 129
 130             sprintf(buf2, "\33O[%08lx]", (unsigned long)(IPTR)data->inormal[TestPubScreen(desc->Name) ? 1 : 0]);
 131         }
 132
 133         *array++ = buf2;
 134         *array++ = buf1;
 135         *array   = ni.Name;
 136     }
 137
 138     return 0;
 139 }
 140
 141 /****************************************************************************************/
 142
 143 IPTR ScreenList_Load(struct IClass *cl, Object *obj, struct MUIP_ScreenList_Load *msg)
 144 {
 145     IPTR result = FALSE;
 146     struct MUI_PubScreenDesc *desc;
 147     APTR pfh;
 148
 149     if ((pfh = MUIS_OpenPubFile(msg->name,MODE_OLDFILE)))
 150     {
 151         result = TRUE;
 152
 153         if (msg->clear)
 154             DoMethod(obj, MUIM_List_Clear);
 155
 156         set(obj, MUIA_List_Quiet, TRUE);
 157
 158         while ((desc = MUIS_ReadPubFile(pfh)))
 159         {
 160             DoMethod(obj, MUIM_List_InsertSingle, desc, MUIV_List_Insert_Sorted);
 161         }
 162
 163         set(obj, MUIA_List_Quiet, FALSE);
 164
 165         MUIS_ClosePubFile(pfh);
 166     }
 167
 168     return result;
 169 }
 170
 171 /****************************************************************************************/
 172
 173 IPTR ScreenList_Save(struct IClass *cl, Object *obj, struct MUIP_ScreenList_Save *msg)
 174 {
 175     IPTR result = FALSE;
 176     struct MUI_PubScreenDesc *desc;
 177     APTR pfh;
 178     int i;
 179
 180     DoMethod(obj, MUIM_List_Sort);
 181
 182     if ((pfh = MUIS_OpenPubFile(msg->name, MODE_NEWFILE)))
 183     {
 184         result = TRUE;
 185
 186         for (i=0; result; i++)
 187         {
 188             DoMethod(obj, MUIM_List_GetEntry, i, &desc);
 189             if (!desc)
 190                 break;
 191
 192             desc->Changed  = FALSE;
 193             desc->UserData = NULL;
 194
 195             if (!MUIS_WritePubFile(pfh, desc))
 196                 result = FALSE;
 197         }
 198         MUIS_ClosePubFile(pfh);
 199     }
 200
 201     return result;
 202 }
 203
 204 /****************************************************************************************/
 205
 206 IPTR ScreenList_Find(struct IClass *cl, Object *obj, struct MUIP_ScreenList_Find *msg)
 207 {
 208     int i;
 209     struct MUI_PubScreenDesc *desc;
 210
 211     *(msg->desc) = NULL;
 212
 213     for (i = 0; ; i++)
 214     {
 215         DoMethod(obj, MUIM_List_GetEntry, i, &desc);
 216         if (!desc)
 217             break;
 218         if (!stricmp(desc->Name, msg->name))
 219         {
 220             *(msg->desc) = desc;
 221             set(obj, MUIA_List_Active, i);
 222             break;
 223         }
 224     }
 225
 226     return 0;
 227 }
 228
 229 /****************************************************************************************/
 230
 231 static Object *makescreenimage(UBYTE *body)
 232 {
 233     Object *obj = BodychunkObject,
 234         MUIA_FixWidth             , PSI_SCREENON_WIDTH ,
 235         MUIA_FixHeight            , PSI_SCREENON_HEIGHT,
 236         MUIA_Bitmap_Width         , PSI_SCREENON_WIDTH ,
 237         MUIA_Bitmap_Height        , PSI_SCREENON_HEIGHT,
 238         MUIA_Bodychunk_Depth      , PSI_SCREENON_DEPTH ,
 239         MUIA_Bodychunk_Body       , (UBYTE *)body,
 240         MUIA_Bodychunk_Compression, PSI_SCREENON_COMPRESSION,
 241         MUIA_Bodychunk_Masking    , PSI_SCREENON_MASKING,
 242         MUIA_Bitmap_SourceColors  , (ULONG *)psi_screenon_colors,
 243         MUIA_Bitmap_Transparent   , 0,
 244     End;
 245
 246     return obj;
 247 }
 248
 249 /****************************************************************************************/
 250
 251 IPTR ScreenList_Setup(struct IClass *cl, Object *obj, Msg msg)
 252 {
 253     struct ScreenList_Data *data = INST_DATA(cl, obj);
 254
 255     if (!DoSuperMethodA(cl, obj, msg))
 256         return FALSE;
 257
 258     data->onormal[0] = makescreenimage((UBYTE *)psi_screencn_body);
 259     data->onormal[1] = makescreenimage((UBYTE *)psi_screenon_body);
 260     /*
 261     data->oforeign[0] = makescreenimage((UBYTE *)psi_screencf_body);
 262     data->oforeign[1] = makescreenimage((UBYTE *)psi_screenof_body);
 263     */
 264
 265     data->inormal[0] = (APTR)DoMethod(obj, MUIM_List_CreateImage, data->onormal[0], 0);
 266     data->inormal[1] = (APTR)DoMethod(obj, MUIM_List_CreateImage, data->onormal[1], 0);
 267     /*
 268     data->iforeign[0] = (APTR)DoMethod(obj,MUIM_List_CreateImage,data->oforeign[0],0);
 269     data->iforeign[1] = (APTR)DoMethod(obj,MUIM_List_CreateImage,data->oforeign[1],0);
 270     */
 271
 272     MUI_RequestIDCMP(obj, IDCMP_MOUSEBUTTONS | IDCMP_RAWKEY);
 273
 274     return TRUE;
 275 }
 276
 277 /****************************************************************************************/
 278
 279 IPTR ScreenList_Cleanup(struct IClass *cl, Object *obj, Msg msg)
 280 {
 281     struct ScreenList_Data *data = INST_DATA(cl, obj);
 282
 283     DoMethod(obj, MUIM_List_DeleteImage, data->inormal[0]);
 284     DoMethod(obj, MUIM_List_DeleteImage, data->inormal[1]);
 285     /*
 286     DoMethod(obj,MUIM_List_DeleteImage,data->iforeign[0]);
 287     DoMethod(obj,MUIM_List_DeleteImage,data->iforeign[1]);
 288     */
 289
 290     if (data->onormal[0])
 291         MUI_DisposeObject(data->onormal[0]);
 292     if (data->onormal[1])
 293         MUI_DisposeObject(data->onormal[1]);
 294     /*
 295     if (data->oforeign[0]) MUI_DisposeObject(data->oforeign[0]);
 296     if (data->oforeign[1]) MUI_DisposeObject(data->oforeign[1]);
 297     */
 298
 299     MUI_RejectIDCMP(obj, IDCMP_MOUSEBUTTONS | IDCMP_RAWKEY);
 300
 301     return DoSuperMethodA(cl, obj, msg);
 302 }
 303
 304 /****************************************************************************************/
 305
 306 IPTR ScreenList_New(struct IClass *cl, Object *obj, struct opSet *msg)
 307 {
 308     static struct Hook ScreenList_ConstructHook;
 309     ScreenList_ConstructHook.h_Entry = HookEntry;
 310     ScreenList_ConstructHook.h_SubEntry = ScreenList_ConstructFunc;
 311     static struct Hook ScreenList_DestructHook;
 312     ScreenList_DestructHook.h_Entry = HookEntry;
 313     ScreenList_DestructHook.h_SubEntry = (HOOKFUNC)ScreenList_DestructFunc;
 314     static struct Hook ScreenList_CompareHook;
 315     ScreenList_CompareHook.h_Entry = HookEntry;
 316     ScreenList_CompareHook.h_SubEntry = (HOOKFUNC)ScreenList_CompareFunc;
 317
 318     obj=(Object *)DoSuperNewTags(cl, obj, NULL,
 319         MUIA_List_ConstructHook, &ScreenList_ConstructHook,
 320         MUIA_List_DestructHook , &ScreenList_DestructHook,
 321         MUIA_List_CompareHook  , &ScreenList_CompareHook,
 322         MUIA_List_Format       , "DELTA=2,,,",
 323         MUIA_List_Title        , TRUE,
 324         MUIA_List_MinLineHeight, 14,
 325         TAG_MORE, msg->ops_AttrList);
 326
 327     if (obj)
 328     {
 329         struct ScreenList_Data *data = INST_DATA(cl, obj);
 330
 331         data->DisplayHook.h_Entry = HookEntry;
 332         data->DisplayHook.h_SubEntry = (HOOKFUNC)ScreenList_DisplayFunc;
 333         data->DisplayHook.h_Data  = (APTR)data;
 334
 335         set(obj, MUIA_List_DisplayHook, &data->DisplayHook);
 336     }
 337
 338     return (IPTR)obj;
 339 }
 340
 341 /****************************************************************************************/
 342
 343 BOOPSI_DISPATCHER(IPTR, ScreenList_Dispatcher, cl, obj, msg)
 344 {
 345     switch (msg->MethodID)
 346     {
 347         case OM_NEW              : return ScreenList_New    (cl,obj,(APTR)msg);
 348         case MUIM_Setup          : return ScreenList_Setup  (cl,obj,(APTR)msg);
 349         case MUIM_Cleanup        : return ScreenList_Cleanup(cl,obj,(APTR)msg);
 350         case MUIM_ScreenList_Save: return ScreenList_Save   (cl,obj,(APTR)msg);
 351         case MUIM_ScreenList_Load: return ScreenList_Load   (cl,obj,(APTR)msg);
 352         case MUIM_ScreenList_Find: return ScreenList_Find   (cl,obj,(APTR)msg);
 353     }
 354
 355     return DoSuperMethodA(cl,obj,msg);
 356 }
 357 BOOPSI_DISPATCHER_END
 358
 359 /****************************************************************************************/
 360
 361 VOID ScreenList_Init(VOID)
 362 {
 363     CL_ScreenList = MUI_CreateCustomClass
 364     (
 365         NULL, MUIC_List, NULL, sizeof(struct ScreenList_Data), ScreenList_Dispatcher
 366     );
 367 }
 368
 369 /****************************************************************************************/
 370
 371 VOID ScreenList_Exit(VOID)
 372 {
 373     if (CL_ScreenList)
 374         MUI_DeleteCustomClass(CL_ScreenList);
 375 }