workbench/libs/muimaster/classes/popstring.c

   1 /*
   2     Copyright © 2002-2003, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <graphics/gfx.h>
   7 #include <graphics/view.h>
   8 #include <clib/alib_protos.h>
   9 #include <proto/exec.h>
  10 #include <proto/graphics.h>
  11 #include <proto/utility.h>
  12 #include <proto/intuition.h>
  13 #include <proto/muimaster.h>
  14
  15 #include "mui.h"
  16 #include "muimaster_intern.h"
  17 #include "support.h"
  18
  19 /*  #define MYDEBUG 0 */
  20 #include "debug.h"
  21
  22 extern struct Library *MUIMasterBase;
  23
  24 struct Popstring_DATA
  25 {
  26     struct Hook *close_hook;
  27     struct Hook *open_hook;
  28     Object *string;
  29     Object *button;
  30     int open;
  31     int toggle;
  32     struct MUI_EventHandlerNode ehn;
  33 };
  34
  35
  36 IPTR Popstring__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
  37 {
  38     struct Popstring_DATA *data;
  39     struct TagItem *tag, *tags;
  40     Object *string, *button;
  41
  42     button =
  43         (Object *) GetTagData(MUIA_Popstring_Button, 0, msg->ops_AttrList);
  44     string =
  45         (Object *) GetTagData(MUIA_Popstring_String, 0, msg->ops_AttrList);
  46
  47     obj = (Object *) DoSuperNewTags(cl, obj, 0,
  48         MUIA_Group_Horiz, TRUE,
  49         MUIA_Group_Spacing, 0,
  50         (string ? Child : TAG_IGNORE), (IPTR) string,
  51         Child, (IPTR) button,
  52         TAG_MORE, (IPTR) msg->ops_AttrList);
  53     if (!obj)
  54         return FALSE;
  55
  56     data = INST_DATA(cl, obj);
  57     data->button = button;
  58     data->string = string;
  59
  60     data->ehn.ehn_Events = IDCMP_RAWKEY;
  61     data->ehn.ehn_Priority = 0;
  62     data->ehn.ehn_Flags = 0;
  63     data->ehn.ehn_Object = obj;
  64     data->ehn.ehn_Class = cl;
  65
  66     /* parse initial taglist */
  67
  68     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
  69     {
  70         switch (tag->ti_Tag)
  71         {
  72         case MUIA_Popstring_Toggle:
  73             data->toggle = tag->ti_Data;
  74             break;
  75         case MUIA_Popstring_CloseHook:
  76             data->close_hook = (struct Hook *)tag->ti_Data;
  77             break;
  78         case MUIA_Popstring_OpenHook:
  79             data->open_hook = (struct Hook *)tag->ti_Data;
  80             break;
  81         }
  82     }
  83
  84     DoMethod(button, MUIM_Notify, MUIA_Pressed, FALSE, (IPTR) obj, 1,
  85         MUIM_Popstring_Open);
  86
  87     return (IPTR) obj;
  88 }
  89
  90 IPTR Popstring__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
  91 {
  92     struct TagItem *tags, *tag;
  93     struct Popstring_DATA *data = INST_DATA(cl, obj);
  94
  95     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
  96     {
  97         switch (tag->ti_Tag)
  98         {
  99         case MUIA_Popstring_Toggle:
 100             data->toggle = tag->ti_Data;
 101             break;
 102         case MUIA_Popstring_CloseHook:
 103             data->close_hook = (struct Hook *)tag->ti_Data;
 104             break;
 105         case MUIA_Popstring_OpenHook:
 106             data->open_hook = (struct Hook *)tag->ti_Data;
 107             break;
 108         }
 109     }
 110
 111     return DoSuperMethodA(cl, obj, (Msg) msg);
 112 }
 113
 114 #define STORE *(msg->opg_Storage)
 115 IPTR Popstring__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 116 {
 117     struct Popstring_DATA *data = INST_DATA(cl, obj);
 118
 119     switch (msg->opg_AttrID)
 120     {
 121     case MUIA_Popstring_String:
 122         STORE = (IPTR) data->string;
 123         return 1;
 124     }
 125     return DoSuperMethodA(cl, obj, (Msg) msg);
 126 }
 127 #undef STORE
 128
 129 IPTR Popstring__MUIM_Setup(struct IClass *cl, Object *obj,
 130     struct MUIP_Setup *msg)
 131 {
 132     struct Popstring_DATA *data = INST_DATA(cl, obj);
 133
 134     if (!(DoSuperMethodA(cl, obj, (Msg) msg)))
 135         return FALSE;
 136
 137     DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR) & data->ehn);
 138
 139     return TRUE;
 140 }
 141
 142 IPTR Popstring__MUIM_Cleanup(struct IClass *cl, Object *obj,
 143     struct MUIP_Cleanup *msg)
 144 {
 145     struct Popstring_DATA *data = INST_DATA(cl, obj);
 146
 147     DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR) & data->ehn);
 148
 149     return DoSuperMethodA(cl, obj, (Msg) msg);
 150 }
 151
 152 IPTR Popstring__MUIM_HandleEvent(struct IClass *cl, Object *obj,
 153     struct MUIP_HandleEvent *msg)
 154 {
 155     if (msg->muikey == MUIKEY_POPUP)
 156     {
 157         D(bug("Popstring__MUIM_HandleEvent %p got MUIKEY_POPUP\n", obj));
 158         DoMethod(obj, MUIM_Popstring_Open);
 159         return MUI_EventHandlerRC_Eat;
 160     }
 161     return 0;
 162 }
 163
 164 IPTR Popstring__MUIM_Popstring_Close(struct IClass *cl, Object *obj,
 165     struct MUIP_Popstring_Close *msg)
 166 {
 167     struct Popstring_DATA *data = INST_DATA(cl, obj);
 168     if (data->close_hook && data->open)
 169     {
 170         DoMethod(_app(obj), MUIM_Application_PushMethod, (IPTR) obj, 4,
 171             MUIM_CallHook, (IPTR) data->close_hook, (IPTR) data->string,
 172             msg->result);
 173         data->open = 0;
 174         set(data->button, MUIA_Disabled, FALSE);
 175     }
 176     return 0;
 177 }
 178
 179 IPTR Popstring__MUIM_Popstring_Open(struct IClass *cl, Object *obj,
 180     struct MUIP_Popstring_Open *msg)
 181 {
 182     struct Popstring_DATA *data = INST_DATA(cl, obj);
 183     if (data->open_hook)
 184     {
 185         if (data->open && data->toggle)
 186         {
 187             DoMethod(obj, MUIM_Popstring_Close, FALSE);
 188             return 0;
 189         }
 190
 191         if (!data->open)
 192         {
 193             if (DoMethod(obj, MUIM_CallHook, (IPTR) data->open_hook,
 194                     (IPTR) data->string))
 195             {
 196                 /* Opening the popup window was successful */
 197                 data->open = 1;
 198                 if (!data->toggle)
 199                     set(data->button, MUIA_Disabled, TRUE);
 200             }
 201         }
 202     }
 203     return 0;
 204 }
 205
 206
 207 BOOPSI_DISPATCHER(IPTR, Popstring_Dispatcher, cl, obj, msg)
 208 {
 209     switch (msg->MethodID)
 210     {
 211     case OM_NEW:
 212         return Popstring__OM_NEW(cl, obj, (APTR) msg);
 213     case OM_SET:
 214         return Popstring__OM_SET(cl, obj, (APTR) msg);
 215     case OM_GET:
 216         return Popstring__OM_GET(cl, obj, (APTR) msg);
 217     case MUIM_Setup:
 218         return Popstring__MUIM_Setup(cl, obj, (APTR) msg);
 219     case MUIM_Cleanup:
 220         return Popstring__MUIM_Cleanup(cl, obj, (APTR) msg);
 221     case MUIM_HandleEvent:
 222         return Popstring__MUIM_HandleEvent(cl, obj, (APTR) msg);
 223     case MUIM_Popstring_Close:
 224         return Popstring__MUIM_Popstring_Close(cl, obj, (APTR) msg);
 225     case MUIM_Popstring_Open:
 226         return Popstring__MUIM_Popstring_Open(cl, obj, (APTR) msg);
 227     }
 228
 229     return DoSuperMethodA(cl, obj, msg);
 230 }
 231 BOOPSI_DISPATCHER_END
 232
 233 const struct __MUIBuiltinClass _MUI_Popstring_desc =
 234 {
 235     MUIC_Popstring,
 236     MUIC_Group,
 237     sizeof(struct Popstring_DATA),
 238     (void *) Popstring_Dispatcher
 239 };