workbench/libs/muimaster/classes/scale.c

   1 /*
   2     Copyright © 2002-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #include <stdio.h>
   9
  10 #include <graphics/gfx.h>
  11 #include <graphics/view.h>
  12 #include <clib/alib_protos.h>
  13 #include <proto/exec.h>
  14 #include <proto/graphics.h>
  15 #include <proto/utility.h>
  16 #include <proto/intuition.h>
  17 #include <proto/muimaster.h>
  18
  19 #include <string.h>
  20
  21 #include "mui.h"
  22 #include "muimaster_intern.h"
  23 #include "textengine.h"
  24 #include "support.h"
  25 #include "support_classes.h"
  26 #include "scale_private.h"
  27
  28 /*  #define MYDEBUG 1 */
  29 #include "debug.h"
  30
  31 extern struct Library *MUIMasterBase;
  32
  33
  34 IPTR Scale__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
  35 {
  36     struct Scale_DATA *data;
  37     struct TagItem *tag, *tags;
  38
  39     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
  40     if (!obj)
  41         return FALSE;
  42
  43     data = INST_DATA(cl, obj);
  44
  45     data->horiz = TRUE;
  46
  47     /* parse initial taglist */
  48
  49     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
  50     {
  51         switch (tag->ti_Tag)
  52         {
  53         case MUIA_Scale_Horiz:
  54             data->horiz = tag->ti_Data;
  55             break;
  56         }
  57     }
  58
  59     D(bug("muimaster.library/scale.c: Scale Object created at 0x%lx\n",
  60             obj));
  61
  62     return (IPTR) obj;
  63 }
  64
  65 IPTR Scale__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
  66 {
  67     struct Scale_DATA *data;
  68     struct TagItem *tag, *tags;
  69     int need_redraw = 0;
  70
  71     data = INST_DATA(cl, obj);
  72
  73     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
  74     {
  75         switch (tag->ti_Tag)
  76         {
  77         case MUIA_Scale_Horiz:
  78             if (data->horiz != tag->ti_Data)
  79                 need_redraw = 1;
  80             data->horiz = tag->ti_Data;
  81             break;
  82         }
  83     }
  84
  85     if (need_redraw)
  86     {
  87         MUI_Redraw(obj, MADF_DRAWOBJECT);
  88     }
  89     return DoSuperMethodA(cl, obj, (Msg) msg);
  90 }
  91
  92 IPTR Scale__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
  93 {
  94     struct Scale_DATA *data = INST_DATA(cl, obj);
  95     IPTR *store = msg->opg_Storage;
  96     IPTR tag = msg->opg_AttrID;
  97
  98     switch (tag)
  99     {
 100     case MUIA_Scale_Horiz:
 101         *store = (IPTR) data->horiz;
 102         return TRUE;
 103     }
 104
 105     return DoSuperMethodA(cl, obj, (Msg) msg);
 106 }
 107
 108 IPTR Scale__MUIM_Setup(struct IClass *cl, Object *obj,
 109     struct MUIP_Setup *msg)
 110 {
 111     struct Scale_DATA *data = INST_DATA(cl, obj);
 112
 113     if (!(DoSuperMethodA(cl, obj, (Msg) msg)))
 114         return 0;
 115
 116     {
 117         char *minlabel = "0% 100%";
 118         struct RastPort rp;
 119
 120         InitRastPort(&rp);
 121         SetFont(&rp, _font(obj));
 122
 123         data->label_minwidth = TextLength(&rp, minlabel, strlen(minlabel));
 124         data->label_height = _font(obj)->tf_YSize;
 125     }
 126
 127     return 1;
 128 }
 129
 130 IPTR Scale__MUIM_AskMinMax(struct IClass *cl, Object *obj,
 131     struct MUIP_AskMinMax *msg)
 132 {
 133     struct Scale_DATA *data = INST_DATA(cl, obj);
 134     DoSuperMethodA(cl, obj, (Msg) msg);
 135
 136     if (data->horiz)
 137     {
 138         msg->MinMaxInfo->MinWidth += data->label_minwidth;
 139         msg->MinMaxInfo->MinHeight += data->label_height + 4;
 140         msg->MinMaxInfo->DefWidth += data->label_minwidth;
 141         msg->MinMaxInfo->DefHeight += data->label_height + 4;
 142         msg->MinMaxInfo->MaxWidth = MUI_MAXMAX;
 143         msg->MinMaxInfo->MaxHeight += data->label_height + 4;
 144     }
 145     else
 146     {
 147     }
 148     return 0;
 149 }
 150
 151 IPTR Scale__MUIM_Draw(struct IClass *cl, Object *obj,
 152     struct MUIP_Draw *msg)
 153 {
 154     struct Scale_DATA *data = INST_DATA(cl, obj);
 155     //ULONG val;
 156
 157     DoSuperMethodA(cl, obj, (Msg) msg);
 158     D(bug("muimaster.library/scale.c: Draw Scale Object "
 159         "at 0x%lx %ldx%ldx%ldx%ld\n",
 160         obj, _left(obj), _top(obj), _right(obj), _bottom(obj)));
 161
 162     if (data->horiz)
 163     {
 164         int i;
 165         //int  subdiv;
 166         char buf[255];
 167         int k;
 168         BOOL drawpct;
 169
 170         /* main horizontal bar */
 171         SetAPen(_rp(obj), _pens(obj)[MPEN_TEXT]);
 172         Move(_rp(obj), _mleft(obj), _mtop(obj) + 3);
 173         Draw(_rp(obj), _mright(obj), _mtop(obj) + 3);
 174
 175         /* testing possible layouts: 1 = 0...100 ; 2 = 0...50..100 ; etc ... */
 176         for (i = 2; i < _mwidth(obj); i *= 2)
 177         {
 178             int j;
 179             int total_width = 0;
 180             int too_big = 0;
 181
 182             for (j = 0; j <= i; j++)
 183             {
 184                 //int pct = j * 100 / i;
 185
 186                 snprintf(buf, 255, "%d%%", (int)j);
 187                 total_width += TextLength(_rp(obj), buf, strlen(buf));
 188                 if (total_width > (3 * _mwidth(obj) / 8))
 189                 {
 190                     too_big = 1;
 191                     break;
 192                 }
 193             }
 194             if (too_big)
 195                 break;
 196         }
 197
 198         for (k = 0, drawpct = TRUE; k <= i; k++)
 199         {
 200             /* draw 0% */
 201             if (k == 0)
 202             {
 203                 ZText *ztext = zune_text_new(NULL, "0%", ZTEXT_ARG_NONE, 0);
 204                 if (ztext)
 205                 {
 206                     zune_text_get_bounds(ztext, obj);
 207                     zune_text_draw(ztext, obj, _mleft(obj), _mright(obj),
 208                         _mtop(obj) + 4);
 209                     zune_text_destroy(ztext);
 210                 }
 211                 Move(_rp(obj), _mleft(obj), _mtop(obj));
 212                 Draw(_rp(obj), _mleft(obj), _mtop(obj) + 3);
 213                 drawpct = FALSE;
 214             }
 215             else if (k == i)    /* draw 100% */
 216             {
 217                 ZText *ztext =
 218                     zune_text_new("\33r", "100%", ZTEXT_ARG_NONE, 0);
 219                 if (ztext)
 220                 {
 221                     zune_text_get_bounds(ztext, obj);
 222                     zune_text_draw(ztext, obj, _mleft(obj), _mright(obj),
 223                         _mtop(obj) + 4);
 224                     zune_text_destroy(ztext);
 225                 }
 226                 Move(_rp(obj), _mright(obj), _mtop(obj));
 227                 Draw(_rp(obj), _mright(obj), _mtop(obj) + 3);
 228                 drawpct = FALSE;
 229             }
 230             else if (drawpct == TRUE)   /* draw intermediate values and lines */
 231             {
 232                 ZText *ztext;
 233                 int val = k * 100 / i;
 234
 235                 snprintf(buf, 255, "%d%%", (int)val);
 236                 ztext = zune_text_new(NULL, buf, ZTEXT_ARG_NONE, 0);
 237                 if (ztext)
 238                 {
 239                     int width;
 240                     zune_text_get_bounds(ztext, obj);
 241                     width = TextLength(_rp(obj), buf, strlen(buf));
 242                     zune_text_draw(ztext, obj,
 243                         _mleft(obj) + _mwidth(obj) * k / i - width / 2,
 244                         _mright(obj), _mtop(obj) + 4);
 245                     zune_text_destroy(ztext);
 246                 }
 247                 Move(_rp(obj), _mleft(obj) + _mwidth(obj) * k / i,
 248                     _mtop(obj));
 249                 Draw(_rp(obj), _mleft(obj) + _mwidth(obj) * k / i,
 250                     _mtop(obj) + 3);
 251                 drawpct = FALSE;
 252             }
 253             else                /* draw intermediate lines */
 254             {
 255                 Move(_rp(obj), _mleft(obj) + _mwidth(obj) * k / i,
 256                     _mtop(obj) + 1);
 257                 Draw(_rp(obj), _mleft(obj) + _mwidth(obj) * k / i,
 258                     _mtop(obj) + 3);
 259                 drawpct = TRUE;
 260             }
 261         }
 262     }
 263     else
 264     {
 265     }
 266     return 0;
 267 }
 268
 269 #if ZUNE_BUILTIN_SCALE
 270 BOOPSI_DISPATCHER(IPTR, Scale_Dispatcher, cl, obj, msg)
 271 {
 272     switch (msg->MethodID)
 273     {
 274     case OM_NEW:
 275         return Scale__OM_NEW(cl, obj, (struct opSet *)msg);
 276     case OM_SET:
 277         return Scale__OM_SET(cl, obj, (struct opSet *)msg);
 278     case OM_GET:
 279         return Scale__OM_GET(cl, obj, (struct opGet *)msg);
 280     case MUIM_Setup:
 281         return Scale__MUIM_Setup(cl, obj, (struct MUIP_Setup *)msg);
 282     case MUIM_AskMinMax:
 283         return Scale__MUIM_AskMinMax(cl, obj, (struct MUIP_AskMinMax *)msg);
 284     case MUIM_Draw:
 285         return Scale__MUIM_Draw(cl, obj, (struct MUIP_Draw *)msg);
 286     default:
 287         return DoSuperMethodA(cl, obj, msg);
 288     }
 289 }
 290 BOOPSI_DISPATCHER_END
 291
 292 const struct __MUIBuiltinClass _MUI_Scale_desc =
 293 {
 294     MUIC_Scale,
 295     MUIC_Area,
 296     sizeof(struct Scale_DATA),
 297     (void *) Scale_Dispatcher
 298 };
 299 #endif /* ZUNE_BUILTIN_SCALE */