workbench/libs/muimaster/classes/scrollbutton.c

   1 /*
   2     Copyright © 2002-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <string.h>
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9
  10 #include <intuition/intuitionbase.h>
  11
  12 #include <clib/alib_protos.h>
  13 #include <proto/exec.h>
  14 #include <proto/utility.h>
  15 #include <proto/intuition.h>
  16 #include <proto/muimaster.h>
  17
  18 #include "mui.h"
  19 #include "muimaster_intern.h"
  20 #include "support.h"
  21
  22 extern struct Library *MUIMasterBase;
  23
  24 struct Scrollbutton_DATA
  25 {
  26     WORD mx, my;
  27     WORD cx, cy;
  28     ULONG pos;
  29     Object *horiz_prop;
  30     Object *vert_prop;
  31     struct MUI_EventHandlerNode ehn;
  32 };
  33
  34
  35 IPTR Scrollbutton__OM_NEW(struct IClass *cl, Object *o, struct opSet *msg)
  36 {
  37     return DoSuperNewTags(cl, o, NULL,
  38         ButtonFrame,
  39         MUIA_InputMode, MUIV_InputMode_RelVerify,
  40         MUIA_Background, MUII_ButtonBack,
  41         TAG_MORE, (IPTR) msg->ops_AttrList);
  42 }
  43
  44 IPTR Scrollbutton__OM_GET(struct IClass *cl, Object *o,
  45     struct opGet *msg)
  46 {
  47     struct Scrollbutton_DATA *data =
  48         (struct Scrollbutton_DATA *)INST_DATA(cl, o);
  49     switch (msg->opg_AttrID)
  50     {
  51     case MUIA_Scrollbutton_NewPosition:
  52         *msg->opg_Storage = data->pos;
  53         return TRUE;
  54
  55     case MUIA_Scrollbutton_HorizProp:
  56         *msg->opg_Storage = (IPTR) data->horiz_prop;
  57         return TRUE;
  58
  59     case MUIA_Scrollbutton_VertProp:
  60         *msg->opg_Storage = (IPTR) data->horiz_prop;
  61         return TRUE;
  62
  63     default:
  64         return DoSuperMethodA(cl, o, (Msg) msg);
  65     }
  66 }
  67
  68 IPTR Scrollbutton__OM_SET(struct IClass *cl, Object *o,
  69     struct opSet *msg)
  70 {
  71     struct Scrollbutton_DATA *data =
  72         (struct Scrollbutton_DATA *)INST_DATA(cl, o);
  73     struct TagItem *tl = msg->ops_AttrList;
  74     struct TagItem *ti;
  75
  76     while ((ti = NextTagItem(&tl)))
  77     {
  78         switch (ti->ti_Tag)
  79         {
  80         case MUIA_Scrollbutton_Horiz:
  81             data->cx = ti->ti_Data;
  82             break;
  83
  84         case MUIA_Scrollbutton_Vert:
  85             data->cy = ti->ti_Data;
  86             break;
  87         }
  88     }
  89     return DoSuperMethodA(cl, o, (Msg) msg);
  90 }
  91
  92 IPTR Scrollbutton__MUIM_AskMinMax(struct IClass *cl, Object *o,
  93     struct MUIP_AskMinMax *msg)
  94 {
  95     DoSuperMethodA(cl, o, (Msg) msg);
  96
  97     msg->MinMaxInfo->MinWidth += 2;
  98     msg->MinMaxInfo->DefWidth += 2;
  99     msg->MinMaxInfo->MaxWidth += MUI_MAXMAX;
 100
 101     msg->MinMaxInfo->MinHeight += 2;
 102     msg->MinMaxInfo->DefHeight += 2;
 103     msg->MinMaxInfo->MaxHeight += MUI_MAXMAX;
 104     return 0;
 105 }
 106
 107 IPTR Scrollbutton__MUIM_Setup(struct IClass *cl, Object *o, Msg msg)
 108 {
 109     struct Scrollbutton_DATA *data =
 110         (struct Scrollbutton_DATA *)INST_DATA(cl, o);
 111     if (!DoSuperMethodA(cl, o, msg))
 112         return FALSE;
 113
 114     data->ehn.ehn_Events = IDCMP_MOUSEBUTTONS;
 115     data->ehn.ehn_Priority = 0;
 116     data->ehn.ehn_Flags = 0;
 117     data->ehn.ehn_Object = o;
 118     data->ehn.ehn_Class = cl;
 119
 120     DoMethod(_win(o), MUIM_Window_AddEventHandler, (IPTR) & data->ehn);
 121
 122     return TRUE;
 123 }
 124
 125 IPTR Scrollbutton__MUIM_Cleanup(struct IClass *cl, Object *o, Msg msg)
 126 {
 127     struct Scrollbutton_DATA *data =
 128         (struct Scrollbutton_DATA *)INST_DATA(cl, o);
 129     DoMethod(_win(o), MUIM_Window_RemEventHandler, (IPTR) & data->ehn);
 130     DoSuperMethodA(cl, o, msg);
 131     return 0;
 132 }
 133
 134 IPTR Scrollbutton__MUIM_HandleEvent(struct IClass *cl, Object *o,
 135     struct MUIP_HandleEvent *msg)
 136 {
 137     struct Scrollbutton_DATA *data =
 138         (struct Scrollbutton_DATA *)INST_DATA(cl, o);
 139     if (msg->imsg)
 140     {
 141         switch (msg->imsg->Class)
 142         {
 143         case IDCMP_MOUSEBUTTONS:
 144             if (msg->imsg->Code == SELECTDOWN)
 145             {
 146                 if (msg->imsg->MouseX >= _left(o)
 147                     && msg->imsg->MouseX <= _right(o)
 148                     && msg->imsg->MouseY >= _top(o)
 149                     && msg->imsg->MouseY <= _bottom(o))
 150                 {
 151                     DoMethod(_win(o), MUIM_Window_RemEventHandler,
 152                         (IPTR) & data->ehn);
 153                     data->ehn.ehn_Events |= IDCMP_MOUSEMOVE;
 154                     DoMethod(_win(o), MUIM_Window_AddEventHandler,
 155                         (IPTR) & data->ehn);
 156
 157                     set(o, MUIA_Selected, TRUE);
 158                     data->mx = msg->imsg->MouseX;
 159                     data->my = msg->imsg->MouseY;
 160
 161                 }
 162             }
 163             else
 164             {
 165                 if (data->ehn.ehn_Events & IDCMP_MOUSEMOVE)
 166                 {
 167                     DoMethod(_win(o), MUIM_Window_RemEventHandler,
 168                         (IPTR) & data->ehn);
 169                     data->ehn.ehn_Events &= ~IDCMP_MOUSEMOVE;
 170                     DoMethod(_win(o), MUIM_Window_AddEventHandler,
 171                         (IPTR) & data->ehn);
 172
 173                     set(o, MUIA_Selected, FALSE);
 174                 }
 175             }
 176             break;
 177
 178         case IDCMP_MOUSEMOVE:
 179             {
 180                 IPTR sel = 0;
 181
 182                 get(o, MUIA_Selected, &sel);
 183                 if (sel)
 184                 {
 185                     UWORD x = (msg->imsg->MouseX - data->mx) + data->cx;
 186                     UWORD y = (msg->imsg->MouseY - data->my) + data->cy;
 187                     ULONG pos = x << 16 | y;
 188
 189                     data->pos = pos;
 190                     set(o, MUIA_Scrollbutton_NewPosition, pos);
 191                 }
 192                 break;
 193             }
 194         }
 195     }
 196     return 0;
 197 }
 198
 199
 200 BOOPSI_DISPATCHER(IPTR, Scrollbutton_Dispatcher, cl, obj, msg)
 201 {
 202     switch (msg->MethodID)
 203     {
 204     case OM_NEW:
 205         return Scrollbutton__OM_NEW(cl, obj, (struct opSet *)msg);
 206     case OM_GET:
 207         return Scrollbutton__OM_GET(cl, obj, (struct opGet *)msg);
 208     case OM_SET:
 209         return Scrollbutton__OM_SET(cl, obj, (struct opSet *)msg);
 210     case MUIM_AskMinMax:
 211         return Scrollbutton__MUIM_AskMinMax(cl, obj,
 212             (struct MUIP_AskMinMax *)msg);
 213     case MUIM_Setup:
 214         return Scrollbutton__MUIM_Setup(cl, obj, msg);
 215     case MUIM_Cleanup:
 216         return Scrollbutton__MUIM_Cleanup(cl, obj, msg);
 217     case MUIM_HandleEvent:
 218         return Scrollbutton__MUIM_HandleEvent(cl, obj,
 219             (struct MUIP_HandleEvent *)msg);
 220     default:
 221         return DoSuperMethodA(cl, obj, msg);
 222     }
 223 }
 224 BOOPSI_DISPATCHER_END
 225
 226 const struct __MUIBuiltinClass _MUI_Scrollbutton_desc =
 227 {
 228     MUIC_Scrollbutton,
 229     MUIC_Area,
 230     sizeof(struct Scrollbutton_DATA),
 231     (void *) Scrollbutton_Dispatcher
 232 };