workbench/libs/muimaster/classes/popobject.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 #include "debug.h"
  19
  20 extern struct Library *MUIMasterBase;
  21
  22 struct Popobject_DATA
  23 {
  24     struct MUI_EventHandlerNode ehn;
  25     int light;
  26     int vol;
  27     int follow;
  28     struct Hook *strobj_hook;
  29     struct Hook *objstr_hook;
  30     struct Hook *window_hook;
  31     struct Hook open_hook;
  32     struct Hook close_hook;
  33     Object *object;
  34     Object *wnd;
  35 };
  36
  37 AROS_UFH3(ULONG, Popobject_Open_Function,
  38     AROS_UFHA(struct Hook *, hook, A0),
  39     AROS_UFHA(Object *, obj, A2),
  40     AROS_UFHA(void **, msg, A1))
  41 {
  42     AROS_USERFUNC_INIT
  43
  44     struct Popobject_DATA *data = (struct Popobject_DATA *)hook->h_Data;
  45     Object *string = (Object *) msg[0];
  46
  47     if (!data->wnd)
  48     {
  49         static struct TagItem light_tags[] =
  50         {
  51             {MUIA_Window_Borderless, TRUE},
  52             {MUIA_Window_CloseGadget, FALSE},
  53             {MUIA_Window_SizeGadget, FALSE},
  54             {MUIA_Window_DepthGadget, FALSE},
  55             {MUIA_Window_DragBar, FALSE},
  56             {TAG_DONE}
  57         };
  58
  59         data->wnd = WindowObject,
  60             WindowContents, data->object,
  61             data->light ? TAG_MORE : TAG_IGNORE, (IPTR) light_tags, End;
  62
  63         if (!data->wnd)
  64             return 0;
  65
  66         DoMethod(_app(obj), OM_ADDMEMBER, (IPTR) data->wnd);
  67
  68         DoMethod(data->wnd, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
  69             (IPTR) obj, 2, MUIM_Popstring_Close, FALSE);
  70     }
  71
  72     if (data->strobj_hook)
  73     {
  74         if (!(CallHookPkt(data->strobj_hook, data->object, string)))
  75             return 0;
  76     }
  77
  78     if (data->window_hook)
  79     {
  80         CallHookPkt(data->window_hook, data->object, data->wnd);
  81     }
  82
  83     SetAttrs(data->wnd,
  84         MUIA_Window_LeftEdge, _left(obj) + _window(obj)->LeftEdge,
  85         MUIA_Window_TopEdge, _bottom(obj) + 1 + _window(obj)->TopEdge,
  86         MUIA_Window_Width, _width(obj), MUIA_Window_Open, TRUE, TAG_DONE);
  87
  88     if (!(data->ehn.ehn_Events & IDCMP_CHANGEWINDOW))
  89     {
  90         data->ehn.ehn_Events |= IDCMP_CHANGEWINDOW;
  91         DoMethod(_win(obj), MUIM_Window_AddEventHandler,
  92             (IPTR) & data->ehn);
  93     }
  94
  95     return 1;
  96
  97     AROS_USERFUNC_EXIT
  98 }
  99
 100
 101 AROS_UFH3(ULONG, Popobject_Close_Function,
 102     AROS_UFHA(struct Hook *, hook, A0),
 103     AROS_UFHA(Object *, obj, A2),
 104     AROS_UFHA(void **, msg, A1))
 105 {
 106     AROS_USERFUNC_INIT
 107
 108     struct Popobject_DATA *data = (struct Popobject_DATA *)hook->h_Data;
 109     Object *string = (Object *) msg[0];
 110     SIPTR suc = (SIPTR) msg[1];
 111
 112     if (data->wnd)
 113     {
 114         set(data->wnd, MUIA_Window_Open, FALSE);
 115
 116         if (data->objstr_hook && suc)
 117             CallHookPkt(data->objstr_hook, data->object, string);
 118
 119         if (data->ehn.ehn_Events & IDCMP_CHANGEWINDOW)
 120         {
 121             DoMethod(_win(obj), MUIM_Window_RemEventHandler,
 122                 (IPTR) & data->ehn);
 123             data->ehn.ehn_Events &= ~IDCMP_CHANGEWINDOW;
 124         }
 125
 126     }
 127     return 0;
 128
 129     AROS_USERFUNC_EXIT
 130 }
 131
 132 IPTR Popobject__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 133 {
 134     struct Popobject_DATA *data;
 135     struct TagItem *tags;
 136     struct TagItem *tag;
 137
 138     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
 139     if (!obj)
 140         return FALSE;
 141
 142     data = INST_DATA(cl, obj);
 143     data->follow = 1;
 144     data->vol = 1;
 145     data->light = 1;
 146
 147     data->ehn.ehn_Events = 0;
 148     data->ehn.ehn_Priority = 0;
 149     data->ehn.ehn_Flags = 0;
 150     data->ehn.ehn_Object = obj;
 151     data->ehn.ehn_Class = cl;
 152
 153     data->open_hook.h_Entry = (HOOKFUNC) Popobject_Open_Function;
 154     data->open_hook.h_Data = data;
 155     data->close_hook.h_Entry = (HOOKFUNC) Popobject_Close_Function;
 156     data->close_hook.h_Data = data;
 157
 158     /* parse initial taglist */
 159
 160     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 161     {
 162         switch (tag->ti_Tag)
 163         {
 164         case MUIA_Popobject_Follow:
 165             data->follow = tag->ti_Data;
 166             break;
 167
 168         case MUIA_Popobject_Light:
 169             data->light = tag->ti_Data;
 170             break;
 171
 172         case MUIA_Popobject_Object:
 173             data->object = (Object *) tag->ti_Data;
 174             break;
 175
 176         case MUIA_Popobject_ObjStrHook:
 177             data->objstr_hook = (struct Hook *)tag->ti_Data;
 178             break;
 179
 180         case MUIA_Popobject_StrObjHook:
 181             data->strobj_hook = (struct Hook *)tag->ti_Data;
 182             break;
 183
 184         case MUIA_Popobject_Volatile:
 185             data->vol = tag->ti_Data;
 186             break;
 187
 188         case MUIA_Popobject_WindowHook:
 189             data->window_hook = (struct Hook *)tag->ti_Data;
 190             break;
 191         }
 192     }
 193
 194     SetAttrs(obj,
 195         MUIA_Popstring_OpenHook, (IPTR) & data->open_hook,
 196         MUIA_Popstring_CloseHook, (IPTR) & data->close_hook,
 197         MUIA_Popstring_Toggle, TRUE,
 198         TAG_DONE);
 199
 200     return (IPTR) obj;
 201 }
 202
 203 IPTR Popobject__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 204 {
 205     struct Popobject_DATA *data = INST_DATA(cl, obj);
 206
 207     if (!data->wnd && data->object)
 208         MUI_DisposeObject(data->object);
 209
 210     return DoSuperMethodA(cl, obj, msg);
 211 }
 212
 213 IPTR Popobject__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 214 {
 215     struct Popobject_DATA *data = INST_DATA(cl, obj);
 216     struct TagItem *tags;
 217     struct TagItem *tag;
 218
 219     /* parse initial taglist */
 220
 221     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 222     {
 223         switch (tag->ti_Tag)
 224         {
 225         case MUIA_Popobject_Follow:
 226             data->follow = tag->ti_Data;
 227             break;
 228
 229         case MUIA_Popobject_ObjStrHook:
 230             data->objstr_hook = (struct Hook *)tag->ti_Data;
 231             break;
 232
 233         case MUIA_Popobject_StrObjHook:
 234             data->strobj_hook = (struct Hook *)tag->ti_Data;
 235             break;
 236
 237         case MUIA_Popobject_Volatile:
 238             data->vol = tag->ti_Data;
 239             break;
 240
 241         case MUIA_Popobject_WindowHook:
 242             data->window_hook = (struct Hook *)tag->ti_Data;
 243             break;
 244         }
 245     }
 246     return DoSuperMethodA(cl, obj, (Msg) msg);
 247 }
 248
 249
 250 IPTR Popobject__MUIM_Get(struct IClass *cl, Object *obj,
 251     struct opGet *msg)
 252 {
 253     struct Popobject_DATA *data = INST_DATA(cl, obj);
 254
 255     switch (msg->opg_AttrID)
 256     {
 257     case MUIA_Popobject_Follow:
 258         *msg->opg_Storage = data->follow;
 259         return TRUE;
 260
 261     case MUIA_Popobject_Light:
 262         *msg->opg_Storage = data->light;
 263         return TRUE;
 264
 265     case MUIA_Popobject_Object:
 266         *msg->opg_Storage = (IPTR) data->object;
 267         return TRUE;
 268
 269     case MUIA_Popobject_ObjStrHook:
 270         *msg->opg_Storage = (IPTR) data->objstr_hook;
 271         return TRUE;
 272
 273     case MUIA_Popobject_StrObjHook:
 274         *msg->opg_Storage = (IPTR) data->strobj_hook;
 275         return TRUE;
 276
 277     case MUIA_Popobject_Volatile:
 278         *msg->opg_Storage = data->vol;
 279         return TRUE;
 280
 281     case MUIA_Popobject_WindowHook:
 282         *msg->opg_Storage = (IPTR) data->window_hook;
 283         return TRUE;
 284     }
 285
 286     return DoSuperMethodA(cl, obj, (Msg) msg);
 287 }
 288
 289
 290 IPTR Popobject__MUIM_Cleanup(struct IClass *cl, Object *obj,
 291     struct MUIP_Cleanup *msg)
 292 {
 293     struct Popobject_DATA *data = INST_DATA(cl, obj);
 294
 295     if (data->ehn.ehn_Events & IDCMP_CHANGEWINDOW)
 296     {
 297         DoMethod(_win(obj), MUIM_Window_RemEventHandler,
 298             (IPTR) & data->ehn);
 299         data->ehn.ehn_Events &= ~IDCMP_CHANGEWINDOW;
 300     }
 301
 302     return DoSuperMethodA(cl, obj, (Msg) msg);
 303 }
 304
 305 IPTR Popobject__MUIM_Show(struct IClass *cl, Object *obj,
 306     struct MUIP_Show *msg)
 307 {
 308     IPTR rc = DoSuperMethodA(cl, obj, (Msg) msg);
 309     if (!rc)
 310         return 0;
 311     return rc;
 312 }
 313
 314 IPTR Popobject__MUIM_Hide(struct IClass *cl, Object *obj,
 315     struct MUIP_Hide *msg)
 316 {
 317     return DoSuperMethodA(cl, obj, (Msg) msg);
 318 }
 319
 320 IPTR Popobject__MUIM_HandleEvent(struct IClass *cl, Object *obj,
 321     struct MUIP_HandleEvent *msg)
 322 {
 323     struct Popobject_DATA *data = INST_DATA(cl, obj);
 324
 325     if (data->follow && msg->imsg && data->wnd)
 326     {
 327         if (msg->imsg->Class == IDCMP_CHANGEWINDOW)
 328         {
 329             struct Window *popwin = NULL;
 330             struct Window *parentwin = _window(obj);
 331
 332             get(data->wnd, MUIA_Window_Window, &popwin);
 333
 334             if (popwin && parentwin)
 335             {
 336                 ChangeWindowBox(popwin, _left(obj) + parentwin->LeftEdge,
 337                     _bottom(obj) + parentwin->TopEdge + 1,
 338                     popwin->Width, popwin->Height);
 339             }
 340         }
 341     }
 342
 343     return DoSuperMethodA(cl, obj, (Msg) msg);
 344 }
 345
 346 BOOPSI_DISPATCHER(IPTR, Popobject_Dispatcher, cl, obj, msg)
 347 {
 348     switch (msg->MethodID)
 349     {
 350     case OM_NEW:
 351         return Popobject__OM_NEW(cl, obj, (struct opSet *)msg);
 352     case OM_DISPOSE:
 353         return Popobject__OM_DISPOSE(cl, obj, msg);
 354     case OM_SET:
 355         return Popobject__OM_SET(cl, obj, (struct opSet *)msg);
 356     case OM_GET:
 357         return Popobject__MUIM_Get(cl, obj, (struct opGet *)msg);
 358     case MUIM_Cleanup:
 359         return Popobject__MUIM_Cleanup(cl, obj, (struct MUIP_Cleanup *)msg);
 360     case MUIM_Show:
 361         return Popobject__MUIM_Show(cl, obj, (struct MUIP_Show *)msg);
 362     case MUIM_Hide:
 363         return Popobject__MUIM_Hide(cl, obj, (struct MUIP_Hide *)msg);
 364     case MUIM_HandleEvent:
 365         return Popobject__MUIM_HandleEvent(cl, obj,
 366             (struct MUIP_HandleEvent *)msg);
 367     }
 368
 369     return DoSuperMethodA(cl, obj, msg);
 370 }
 371 BOOPSI_DISPATCHER_END
 372
 373 const struct __MUIBuiltinClass _MUI_Popobject_desc =
 374 {
 375     MUIC_Popobject,
 376     MUIC_Popstring,
 377     sizeof(struct Popobject_DATA),
 378     (void *) Popobject_Dispatcher
 379 };