workbench/libs/muimaster/classes/radio.c

   1 /*
   2     Copyright © 2002-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <clib/alib_protos.h>
   7 #include <proto/exec.h>
   8 #include <proto/utility.h>
   9 #include <proto/intuition.h>
  10 #include <proto/muimaster.h>
  11
  12 #include <string.h>
  13
  14 /*  #define MYDEBUG 1 */
  15 #include "debug.h"
  16
  17 #include "mui.h"
  18 #include "muimaster_intern.h"
  19 #include "prefs.h"
  20 #include "support.h"
  21 #include "support_classes.h"
  22 #include "radio_private.h"
  23
  24 extern struct Library *MUIMasterBase;
  25
  26 IPTR Radio__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
  27 {
  28     struct Radio_DATA *data;
  29     struct TagItem *tags;
  30     struct TagItem *tag;
  31     int i;
  32     const char **entries = NULL;
  33     int entries_active = 0;
  34     int entries_num;
  35     struct TagItem *grouptags;
  36     Object **buttons, **imgobjs, **textobjs;
  37     int state;
  38
  39     /* parse initial taglist */
  40
  41     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
  42     {
  43         switch (tag->ti_Tag)
  44         {
  45         case MUIA_Radio_Entries:
  46             entries = (const char **)tag->ti_Data;
  47             break;
  48         case MUIA_Radio_Active:
  49             entries_active = tag->ti_Data;
  50             break;
  51         }
  52     }
  53
  54     if (!entries)
  55     {
  56         D(bug("Radio_New: No Entries specified!\n"));
  57         CoerceMethod(cl, obj, OM_DISPOSE);
  58         return 0;
  59     }
  60
  61     /* Count the number of entries */
  62     for (i = 0; entries[i]; i++);
  63
  64     entries_num = i;
  65
  66     if ((entries_active < 0) || (entries_active > entries_num - 1))
  67         entries_active = 0;
  68
  69     grouptags = AllocateTagItems(entries_num + 1);
  70     if (!grouptags)
  71         return FALSE;
  72     buttons = AllocVec(i * sizeof(Object *) * 3, MEMF_PUBLIC);
  73     if (!buttons)
  74     {
  75         FreeVec(grouptags);
  76         return FALSE;
  77     }
  78     imgobjs = buttons + i;
  79     textobjs = imgobjs + i;
  80
  81     for (i = 0; i < entries_num; i++)
  82     {
  83         state = (entries_active == i) ? TRUE : FALSE;
  84
  85         buttons[i] = HGroup,
  86             Child, (IPTR)(imgobjs[i] = ImageObject,
  87                 MUIA_Image_FontMatch, TRUE,
  88                 MUIA_InputMode, MUIV_InputMode_Immediate,
  89                 MUIA_Selected, state,
  90                 MUIA_ShowSelState, FALSE,
  91                 MUIA_Image_Spec, MUII_RadioButton,
  92                 MUIA_Frame, MUIV_Frame_None,
  93                    End),
  94             Child, (IPTR)(textobjs[i] = TextObject,
  95                 MUIA_InputMode, MUIV_InputMode_Immediate,
  96                 MUIA_ShowSelState, FALSE,
  97                 MUIA_Selected, state,
  98                 MUIA_Text_Contents, entries[i],
  99                 MUIA_Frame, MUIV_Frame_None,
 100                 MUIA_Text_PreParse, (IPTR)"\33l",
 101                 End),
 102             End;
 103
 104         grouptags[i].ti_Tag = MUIA_Group_Child;
 105         grouptags[i].ti_Data = (IPTR) buttons[i];
 106     }
 107
 108     grouptags[i].ti_Tag = TAG_MORE;
 109     grouptags[i].ti_Data = (IPTR) msg->ops_AttrList;
 110
 111     obj = (Object *) DoSuperNewTags(cl, obj, NULL,
 112         TAG_MORE, (IPTR) grouptags);
 113     FreeTagItems(grouptags);
 114     if (!obj)
 115     {
 116         FreeVec(buttons);
 117         return FALSE;
 118     }
 119     data = INST_DATA(cl, obj);
 120     data->entries_active = entries_active;
 121     data->entries_num = entries_num;
 122     data->buttons = buttons;
 123
 124     for (i = 0; i < entries_num; i++)
 125     {
 126         DoMethod(imgobjs[i], MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
 127             (IPTR) obj, 3, MUIM_Set, MUIA_Radio_Active, i);
 128         DoMethod(textobjs[i], MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
 129             (IPTR) obj, 3, MUIM_Set, MUIA_Radio_Active, i);
 130     }
 131
 132     return (IPTR) obj;
 133 }
 134
 135 IPTR Radio__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 136 {
 137     struct Radio_DATA *data = INST_DATA(cl, obj);
 138     if (data->buttons)
 139         FreeVec(data->buttons);
 140     return DoSuperMethodA(cl, obj, msg);
 141 }
 142
 143 IPTR Radio__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 144 {
 145     struct Radio_DATA *data;
 146     struct TagItem *tags;
 147     struct TagItem *tag;
 148
 149     data = INST_DATA(cl, obj);
 150
 151     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 152     {
 153         switch (tag->ti_Tag)
 154         {
 155         case MUIA_Radio_Active:
 156             D(bug("Radio_Set(%p) MUIA_Radio_Active %ld\n",
 157                     obj, tag->ti_Data));
 158             if (tag->ti_Data >= 0 && tag->ti_Data < data->entries_num &&
 159                 tag->ti_Data != data->entries_active)
 160             {
 161                 DoMethod(data->buttons[data->entries_active],
 162                     MUIM_NoNotifySet, MUIA_Selected, FALSE);
 163                 DoMethod(data->buttons[tag->ti_Data],
 164                     MUIM_NoNotifySet, MUIA_Selected, TRUE);
 165                 data->entries_active = tag->ti_Data;
 166             }
 167             break;
 168         }
 169     }
 170     return DoSuperMethodA(cl, obj, (Msg) msg);
 171 }
 172
 173 IPTR Radio__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 174 {
 175     struct Radio_DATA *data = INST_DATA(cl, obj);
 176 #define STORE *(msg->opg_Storage)
 177
 178     switch (msg->opg_AttrID)
 179     {
 180     case MUIA_Radio_Active:
 181         STORE = data->entries_active;
 182         return 1;
 183     }
 184
 185     return DoSuperMethodA(cl, obj, (Msg) msg);
 186 }
 187
 188 IPTR Radio__MUIM_Setup(struct IClass *cl, Object *obj, Msg msg)
 189 {
 190     if (!DoSuperMethodA(cl, obj, msg))
 191         return FALSE;
 192
 193     set(obj, MUIA_Group_HorizSpacing,
 194         muiGlobalInfo(obj)->mgi_Prefs->radiobutton_hspacing);
 195     set(obj, MUIA_Group_VertSpacing,
 196         muiGlobalInfo(obj)->mgi_Prefs->radiobutton_vspacing);
 197
 198     return TRUE;
 199 }
 200
 201 /**************************************************************************
 202  MUIM_Export - to export an object's "contents" to a dataspace object.
 203 **************************************************************************/
 204 IPTR Radio__MUIM_Export(struct IClass *cl, Object *obj,
 205     struct MUIP_Export *msg)
 206 {
 207     struct Radio_DATA *data = INST_DATA(cl, obj);
 208     ULONG id;
 209
 210     if ((id = muiNotifyData(obj)->mnd_ObjectID))
 211     {
 212         LONG value = data->entries_active;
 213         DoMethod(msg->dataspace, MUIM_Dataspace_Add,
 214             (IPTR) & value, sizeof(value), (IPTR) id);
 215     }
 216     return 0;
 217 }
 218
 219 /**************************************************************************
 220  MUIM_Import - to import an object's "contents" from a dataspace object.
 221 **************************************************************************/
 222 IPTR Radio__MUIM_Import(struct IClass *cl, Object *obj,
 223     struct MUIP_Import *msg)
 224 {
 225     ULONG id;
 226     LONG *s;
 227
 228     if ((id = muiNotifyData(obj)->mnd_ObjectID))
 229     {
 230         if ((s = (LONG *) DoMethod(msg->dataspace, MUIM_Dataspace_Find,
 231                     (IPTR) id)))
 232         {
 233             set(obj, MUIA_Radio_Active, *s);
 234         }
 235     }
 236     return 0;
 237 }
 238
 239 #if ZUNE_BUILTIN_RADIO
 240 BOOPSI_DISPATCHER(IPTR, Radio_Dispatcher, cl, obj, msg)
 241 {
 242     switch (msg->MethodID)
 243     {
 244     case OM_NEW:
 245         return Radio__OM_NEW(cl, obj, (struct opSet *)msg);
 246     case OM_DISPOSE:
 247         return Radio__OM_DISPOSE(cl, obj, (Msg) msg);
 248     case OM_SET:
 249         return Radio__OM_SET(cl, obj, (struct opSet *)msg);
 250     case OM_GET:
 251         return Radio__OM_GET(cl, obj, (struct opGet *)msg);
 252     case MUIM_Setup:
 253         return Radio__MUIM_Setup(cl, obj, msg);
 254     case MUIM_Export:
 255         return Radio__MUIM_Export(cl, obj, (struct MUIP_Export *) msg);
 256     case MUIM_Import:
 257         return Radio__MUIM_Import(cl, obj, (struct MUIP_Import *) msg);
 258     default:
 259         return DoSuperMethodA(cl, obj, msg);
 260     }
 261 }
 262 BOOPSI_DISPATCHER_END
 263
 264 const struct __MUIBuiltinClass _MUI_Radio_desc =
 265 {
 266     MUIC_Radio,
 267     MUIC_Group,
 268     sizeof(struct Radio_DATA),
 269     (void *) Radio_Dispatcher
 270 };
 271 #endif /* ZUNE_BUILTIN_RADIO */