workbench/classes/zune/busy/busy.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #include <exec/types.h>
   9 #include <utility/date.h>
  10
  11 #include <aros/debug.h>
  12 #include <aros/asmcall.h>
  13
  14 #include <proto/muimaster.h>
  15 #include <proto/graphics.h>
  16 #include <proto/intuition.h>
  17 #include <proto/utility.h>
  18 #include <proto/timer.h>
  19
  20 #include <string.h>
  21 #include <stdio.h>
  22
  23 #include "Busy_mcc.h"
  24 #include "busy_private.h"
  25
  26 /*** Methods ****************************************************************/
  27 IPTR Busy__OM_NEW(Class *cl, Object *obj, struct opSet *msg)
  28 {
  29     struct Busy_DATA *data;
  30
  31     obj = (Object *) DoSuperMethodA(cl, obj, (Msg)msg);
  32     if (!obj) return 0;
  33
  34     data = INST_DATA(cl, obj);
  35     if (GetTagData(MUIA_Busy_ShowHideIH, FALSE, msg->ops_AttrList))
  36     {
  37         data->flags |= FLG_SHOWHIDEIH;
  38     }
  39     data->speed = 50;
  40
  41     data->ihn.ihn_Flags  = MUIIHNF_TIMER;
  42     data->ihn.ihn_Method = MUIM_Busy_Move;
  43     data->ihn.ihn_Object = obj;
  44     data->ihn.ihn_Millis = 0;
  45
  46     return (IPTR)obj;
  47 }
  48
  49 IPTR Busy__OM_SET(Class *cl, Object *obj, struct opSet *msg)
  50 {
  51     struct Busy_DATA *data = INST_DATA(cl, obj);
  52     struct TagItem       *tags  = msg->ops_AttrList;
  53     struct TagItem       *tag;
  54     BOOL                  redraw = FALSE;
  55
  56     while ((tag = NextTagItem((const struct TagItem **)&tags)) != NULL)
  57     {
  58         switch(tag->ti_Tag)
  59         {
  60             case MUIA_Busy_Speed:
  61                 if ((LONG)tag->ti_Data == MUIV_Busy_Speed_User)
  62                 {
  63                     data->speed = 50;
  64                 }
  65                 else
  66                 {
  67                     data->speed = tag->ti_Data;
  68                 }
  69
  70                 if ((data->flags & FLG_SHOWN) ||
  71                     ((data->flags & FLG_SETUP) && !(data->flags & FLG_SHOWHIDEIH)))
  72                 {
  73                     if (data->ihn.ihn_Millis)
  74                     {
  75                         DoMethod(_app(obj), MUIM_Application_RemInputHandler, (IPTR) &data->ihn);
  76                     }
  77
  78                     data->ihn.ihn_Millis = data->speed;
  79
  80                     if (data->ihn.ihn_Millis)
  81                     {
  82                         DoMethod(_app(obj), MUIM_Application_AddInputHandler, (IPTR) &data->ihn);
  83                     }
  84                 }
  85                 break;
  86
  87         } /* switch(tag->ti_Tag) */
  88
  89     } /* while ((tag = NextTagItem(&tags)) != NULL) */
  90
  91     if (redraw)
  92     {
  93          MUI_Redraw(obj, MADF_DRAWUPDATE);
  94     }
  95
  96     return DoSuperMethodA(cl, obj, (Msg)msg);
  97 }
  98
  99
 100 IPTR Busy__OM_GET(Class *cl, Object *obj, struct opGet *msg)
 101 {
 102     struct Busy_DATA *data = INST_DATA(cl, obj);
 103     IPTR              retval = TRUE;
 104
 105     switch(msg->opg_AttrID)
 106     {
 107         case MUIA_Busy_Speed:
 108             *msg->opg_Storage = data->speed;
 109             break;
 110
 111         default:
 112             retval = DoSuperMethodA(cl, obj, (Msg)msg);
 113             break;
 114     }
 115
 116     return retval;
 117 }
 118
 119
 120 IPTR Busy__MUIM_Setup(Class *cl, Object *obj, struct MUIP_Setup *msg)
 121 {
 122     struct Busy_DATA *data = INST_DATA(cl, obj);
 123
 124     if (!DoSuperMethodA(cl, obj, (Msg)msg)) return FALSE;
 125
 126     if (data->speed && !(data->flags & FLG_SHOWHIDEIH))
 127     {
 128         data->ihn.ihn_Millis = data->speed;
 129         DoMethod(_app(obj), MUIM_Application_AddInputHandler, (IPTR) &data->ihn);
 130     }
 131
 132     data->flags |= FLG_SETUP;
 133
 134     return TRUE;
 135 }
 136
 137
 138 IPTR Busy__MUIM_Cleanup(Class *cl, Object *obj, struct MUIP_Cleanup *msg)
 139 {
 140     struct Busy_DATA *data = INST_DATA(cl, obj);
 141
 142     if (data->ihn.ihn_Millis && !(data->flags & FLG_SHOWHIDEIH))
 143     {
 144         DoMethod(_app(obj), MUIM_Application_RemInputHandler, (IPTR) &data->ihn);
 145         data->ihn.ihn_Millis = 0;
 146     }
 147
 148     data->flags &= ~FLG_SETUP;
 149
 150     return DoSuperMethodA(cl, obj, (Msg)msg);
 151 }
 152
 153 IPTR Busy__MUIM_Show(Class *cl, Object *obj, struct MUIP_Show *msg)
 154 {
 155     struct Busy_DATA *data = INST_DATA(cl, obj);
 156     IPTR              retval;
 157
 158     retval = DoSuperMethodA(cl, obj, (Msg)msg);
 159
 160     if (data->speed && (data->flags & FLG_SHOWHIDEIH))
 161     {
 162         data->ihn.ihn_Millis = data->speed;
 163         DoMethod(_app(obj), MUIM_Application_AddInputHandler, (IPTR) &data->ihn);
 164     }
 165
 166     data->flags |= FLG_SHOWN;
 167
 168     return retval;
 169 }
 170
 171
 172 IPTR Busy__MUIM_Hide(Class *cl, Object *obj, struct MUIP_Hide *msg)
 173 {
 174     struct Busy_DATA *data = INST_DATA(cl, obj);
 175
 176     if (data->ihn.ihn_Millis && (data->flags & FLG_SHOWHIDEIH))
 177     {
 178         DoMethod(_app(obj), MUIM_Application_RemInputHandler, (IPTR) &data->ihn);
 179         data->ihn.ihn_Millis = 0;
 180     }
 181
 182     data->flags &= ~FLG_SHOWN;
 183
 184     return DoSuperMethodA(cl, obj, (Msg)msg);
 185 }
 186
 187 IPTR Busy__MUIM_AskMinMax(Class *cl, Object *obj, struct MUIP_AskMinMax *msg)
 188 {
 189     DoSuperMethodA(cl, obj, (Msg)msg);
 190
 191     msg->MinMaxInfo->MinWidth  += 50;
 192     msg->MinMaxInfo->MinHeight += 4;
 193     msg->MinMaxInfo->DefWidth  += 50;
 194     msg->MinMaxInfo->DefHeight += 4;
 195     msg->MinMaxInfo->MaxWidth   = MUI_MAXMAX;
 196     msg->MinMaxInfo->MaxHeight  = MUI_MAXMAX;
 197
 198     return TRUE;
 199 }
 200
 201
 202 IPTR Busy__MUIM_Draw(Class *cl, Object *obj, struct MUIP_Draw *msg)
 203 {
 204     struct Busy_DATA *data = INST_DATA(cl, obj);
 205     WORD              x;
 206     IPTR              retval;
 207
 208     retval = DoSuperMethodA(cl, obj, (Msg)msg);
 209
 210     if (!(msg->flags & (MADF_DRAWOBJECT | MADF_DRAWUPDATE))) return 0;
 211
 212     for(x = 0; x < _mwidth(obj); x++)
 213     {
 214         WORD col;
 215
 216         col = ((x + data->pos) / 8) % 2;
 217         SetAPen(_rp(obj), _pens(obj)[col ? MPEN_SHADOW : MPEN_SHINE]);
 218         RectFill(_rp(obj), _mleft(obj) + x, _mtop(obj), _mleft(obj) + x, _mbottom(obj));
 219     }
 220
 221     return retval;
 222 }
 223
 224
 225 IPTR Busy__MUIM_Busy_Move(Class *cl, Object *obj, Msg msg)
 226 {
 227     struct Busy_DATA *data;
 228
 229     data = INST_DATA(cl, obj);
 230     data->pos++;
 231
 232     MUI_Redraw(obj, MADF_DRAWUPDATE);
 233
 234     return 0;
 235 }
 236