workbench/prefs/screenmode/smselector.c

   1 /*
   2     Copyright © 2003-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7 #define DEBUG 0
   8
   9 #include <exec/rawfmt.h>
  10 #include <libraries/mui.h>
  11 #include <utility/hooks.h>
  12
  13 #include <proto/alib.h>
  14 #include <proto/dos.h>
  15 #include <proto/exec.h>
  16 #include <proto/muimaster.h>
  17 #include <proto/intuition.h>
  18 #include <proto/graphics.h>
  19 #include <proto/dos.h>
  20 #include <proto/utility.h>
  21
  22 #include <zune/customclasses.h>
  23
  24 #include <string.h>
  25
  26 #include "locale.h"
  27
  28 #include "smselector.h"
  29
  30 struct ScreenModeSelector_DATA
  31 {
  32     STRPTR *modes_array;
  33     ULONG  *ids_array;
  34 };
  35
  36 #define HOOK(name) \
  37 struct Hook
  38
  39 #define HOOKFUNC(name) IPTR name ## Func(struct Hook *hook, APTR obj, APTR msg)
  40
  41 AROS_UFH3(IPTR, SelectFunc,
  42 AROS_UFHA(struct Hook *, hook, A0),
  43 AROS_UFHA(APTR         , obj , A2),
  44 AROS_UFHA(APTR         , msg , A1))
  45 {
  46     AROS_USERFUNC_INIT
  47
  48     struct ScreenModeSelector_DATA *data = INST_DATA(OCLASS(obj), obj);
  49
  50     /* Note: the value used to set MUIA_List_Active may not be an index */
  51     return set(obj, MUIA_ScreenModeSelector_Active,
  52         data->ids_array[XGET(obj, MUIA_List_Active)]);
  53
  54     AROS_USERFUNC_EXIT;
  55 }
  56 static struct Hook SelectHook = { .h_Entry = SelectFunc };
  57
  58 AROS_UFH3(IPTR, DisplayFunc,
  59 AROS_UFHA(struct Hook *, hook, A0),
  60 AROS_UFHA(CONST_STRPTR *, array, A2),
  61 AROS_UFHA(STRPTR, entry, A1))
  62 {
  63     AROS_USERFUNC_INIT
  64
  65     if (entry)
  66     {
  67         ULONG *ids_array = hook->h_Data;
  68         ULONG num = (ULONG)(IPTR)array[-1];
  69         ULONG modeid = ids_array[num];
  70         static char modeid_str[9];
  71
  72         RawDoFmt("%08lx", (RAWARG)&modeid, RAWFMTFUNC_STRING, modeid_str);
  73         array[0] = modeid_str;
  74         array[1] = entry;
  75     }
  76     else
  77     {
  78         array[0] = _(MSG_MODE_ID);
  79         array[1] = _(MSG_DESCRIPTION);
  80     }
  81     return 0;
  82
  83     AROS_USERFUNC_EXIT
  84 }
  85
  86 static struct Hook DisplayHook = { .h_Entry = DisplayFunc };
  87
  88 Object *ScreenModeSelector__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
  89 {
  90     STRPTR *modes_array;
  91     ULONG  *ids_array;
  92     ULONG   id, num_modes, cur_mode;
  93     Object *list;
  94
  95     struct DisplayInfo    DisplayInfo;
  96     struct DimensionInfo  DimensionInfo;
  97     struct NameInfo       NameInfo;
  98     APTR handle;
  99
 100     struct ScreenModeSelector_DATA *data;
 101
 102     num_modes = 0; id = INVALID_ID;
 103     while ((id = NextDisplayInfo(id)) != INVALID_ID) num_modes++;
 104
 105     modes_array = AllocVec(sizeof(STRPTR) * (num_modes + 1), MEMF_CLEAR);
 106     if (!modes_array)
 107         goto err;
 108
 109     ids_array   = AllocVec(sizeof(ULONG) * (num_modes + 1), MEMF_ANY);
 110     if (!ids_array)
 111         goto err;
 112
 113     ids_array[num_modes] = INVALID_ID;
 114
 115     cur_mode = 0;
 116     while ((id = NextDisplayInfo(id)) != INVALID_ID)
 117     {
 118         if ((id & MONITOR_ID_MASK) == DEFAULT_MONITOR_ID)
 119             continue;
 120
 121         if (!(handle = FindDisplayInfo(id)))
 122             continue;
 123
 124         if (!GetDisplayInfoData(handle, (UBYTE *)&NameInfo, sizeof(struct NameInfo), DTAG_NAME, 0))
 125             continue;
 126
 127         if (!GetDisplayInfoData(handle, (UBYTE *)&DisplayInfo, sizeof(struct DisplayInfo), DTAG_DISP, 0))
 128             continue;
 129
 130         if (!(DisplayInfo.PropertyFlags & DIPF_IS_WB) || DisplayInfo.NotAvailable)
 131             continue;
 132
 133         if (!GetDisplayInfoData(handle, (UBYTE *)&DimensionInfo, sizeof(struct DimensionInfo), DTAG_DIMS, 0))
 134             continue;
 135
 136         modes_array[cur_mode] = AllocVec(sizeof(NameInfo.Name), MEMF_ANY);
 137         if (!modes_array[cur_mode])
 138            continue;
 139
 140         CopyMem(NameInfo.Name, modes_array[cur_mode], sizeof(NameInfo.Name));
 141         ids_array[cur_mode] = id;
 142
 143         cur_mode++;
 144     }
 145
 146     DisplayHook.h_Data = ids_array;
 147
 148     list = (Object *)ListObject,
 149         InputListFrame,
 150         MUIA_List_DisplayHook, (IPTR)&DisplayHook,
 151         MUIA_List_Format, (IPTR)"BAR,",
 152         MUIA_List_SourceArray, (IPTR)modes_array,
 153         MUIA_List_Title, TRUE,
 154         MUIA_CycleChain, TRUE,
 155     End;
 156
 157     self = (Object *)DoSuperNewTags
 158     (
 159         CLASS, self, NULL,
 160         MUIA_Listview_List, (IPTR)list,
 161         TAG_MORE,           (IPTR)message->ops_AttrList
 162     );
 163
 164     if (!self)
 165         goto err;
 166
 167     DoMethod(self, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime,
 168              (IPTR)self, 3, MUIM_CallHook, (IPTR)&SelectHook, MUIV_TriggerValue);
 169
 170     data = INST_DATA(CLASS, self);
 171     data->modes_array = modes_array;
 172     data->ids_array   = ids_array;
 173
 174     return self;
 175
 176 err:
 177     CoerceMethod(CLASS, self, OM_DISPOSE);
 178     return NULL;
 179 }
 180
 181 IPTR ScreenModeSelector__OM_DISPOSE(Class *CLASS, Object *self, Msg message)
 182 {
 183     struct ScreenModeSelector_DATA *data;
 184     ULONG cur_mode;
 185
 186     data = INST_DATA(CLASS, self);
 187
 188     if (data->modes_array)
 189     {
 190         for (cur_mode = 0; data->modes_array[cur_mode]; cur_mode++)
 191             FreeVec(data->modes_array[cur_mode]);
 192
 193         FreeVec(data->modes_array);
 194     }
 195
 196     FreeVec(data->ids_array);
 197
 198     return DoSuperMethodA(CLASS, self, message);
 199 }
 200
 201
 202 IPTR ScreenModeSelector__OM_SET(Class *CLASS, Object *self, struct opSet *message)
 203 {
 204     struct ScreenModeSelector_DATA *data = INST_DATA(CLASS, self);
 205     struct TagItem *tags;
 206     struct TagItem *tag;
 207     struct TagItem noforward_tags[] =
 208     {
 209         {MUIA_Group_Forward , FALSE                       },
 210         {TAG_MORE           , (IPTR)message->ops_AttrList }
 211     };
 212     struct opSet noforward_message = *message;
 213     noforward_message.ops_AttrList = noforward_tags;
 214
 215     for (tags = message->ops_AttrList; (tag = NextTagItem(&tags)); )
 216     {
 217         switch (tag->ti_Tag)
 218         {
 219             case MUIA_ScreenModeSelector_Active:
 220             {
 221                 int i;
 222
 223                 D(bug("[smselector] Set Active ID 0x%08lX\n", tag->ti_Data));
 224                 for
 225                 (
 226                     i = 0;
 227                     data->ids_array[i] != tag->ti_Data && data->ids_array[i] != INVALID_ID;
 228                     i++
 229                 );
 230
 231                 if (data->ids_array[i] == INVALID_ID)
 232                     tag->ti_Data = INVALID_ID;
 233                 else
 234                 {
 235                     if (XGET(self, MUIA_List_Active) != i)
 236                     {
 237                         D(bug("[smselector] Set active item %lu\n", i));
 238                         NNFSET(self, MUIA_List_Active, i);
 239                     }
 240                 }
 241                 break;
 242             }
 243         }
 244     }
 245
 246     return DoSuperMethodA(CLASS, self, (Msg)&noforward_message);
 247 }
 248
 249 IPTR ScreenModeSelector__OM_GET(Class *CLASS, Object *self, struct opGet *message)
 250 {
 251     struct ScreenModeSelector_DATA *data = INST_DATA(CLASS, self);
 252
 253     switch (message->opg_AttrID)
 254     {
 255         case MUIA_ScreenModeSelector_Active:
 256             *message->opg_Storage =
 257                 data->ids_array[XGET(self, MUIA_List_Active)];
 258             break;
 259         default:
 260             return DoSuperMethodA(CLASS, self, (Msg)message);
 261     }
 262
 263     return TRUE;
 264 }
 265
 266
 267 ZUNE_CUSTOMCLASS_4
 268 (
 269     ScreenModeSelector, NULL, MUIC_Listview, NULL,
 270     OM_NEW,     struct opSet *,
 271     OM_DISPOSE, Msg,
 272     OM_GET,     struct opGet *,
 273     OM_SET,     struct opSet *
 274 );