workbench/libs/muimaster/classes/scale.c

   1 /*
   2     Copyright © 2002-2018, 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
 156     DoSuperMethodA(cl, obj, (Msg) msg);
 157     D(bug("muimaster.library/scale.c: Draw Scale Object "
 158         "at 0x%lx %ldx%ldx%ldx%ld\n",
 159         obj, _left(obj), _top(obj), _right(obj), _bottom(obj)));
 160
 161     if (data->horiz)
 162     {
 163         int i;
 164         //int  subdiv;
 165         char buf[255];
 166         int k;
 167         BOOL drawpct;
 168
 169         /* main horizontal bar */
 170         SetAPen(_rp(obj), _pens(obj)[MPEN_TEXT]);
 171         Move(_rp(obj), _mleft(obj), _mtop(obj) + 3);
 172         Draw(_rp(obj), _mright(obj), _mtop(obj) + 3);
 173
 174         /* testing possible layouts: 1 = 0...100 ; 2 = 0...50..100 ; etc ... */
 175         for (i = 2; i < _mwidth(obj); i *= 2)
 176         {
 177             int j;
 178             int total_width = 0;
 179             int too_big = 0;
 180
 181             for (j = 0; j <= i; j++)
 182             {
 183                 //int pct = j * 100 / i;
 184
 185                 snprintf(buf, 255, "%d%%", (int)j);
 186                 total_width += TextLength(_rp(obj), buf, strlen(buf));
 187                 if (total_width > (3 * _mwidth(obj) / 8))
 188                 {
 189                     too_big = 1;
 190                     break;
 191                 }
 192             }
 193             if (too_big)
 194                 break;
 195         }
 196
 197         for (k = 0, drawpct = TRUE; k <= i; k++)
 198         {
 199             /* draw 0% */
 200             if (k == 0)
 201             {
 202                 ZText *ztext = zune_text_new(NULL, "0%", ZTEXT_ARG_NONE, 0);
 203                 if (ztext)
 204                 {
 205                     zune_text_get_bounds(ztext, obj);
 206                     zune_text_draw(ztext, obj, _mleft(obj), _mright(obj),
 207                         _mtop(obj) + 4);
 208                     zune_text_destroy(ztext);
 209                 }
 210                 Move(_rp(obj), _mleft(obj), _mtop(obj));
 211                 Draw(_rp(obj), _mleft(obj), _mtop(obj) + 3);
 212                 drawpct = FALSE;
 213             }
 214             else if (k == i)    /* draw 100% */
 215             {
 216                 ZText *ztext =
 217                     zune_text_new("\33r", "100%", ZTEXT_ARG_NONE, 0);
 218                 if (ztext)
 219                 {
 220                     zune_text_get_bounds(ztext, obj);
 221                     zune_text_draw(ztext, obj, _mleft(obj), _mright(obj),
 222                         _mtop(obj) + 4);
 223                     zune_text_destroy(ztext);
 224                 }
 225                 Move(_rp(obj), _mright(obj), _mtop(obj));
 226                 Draw(_rp(obj), _mright(obj), _mtop(obj) + 3);
 227                 drawpct = FALSE;
 228             }
 229             else if (drawpct)   /* draw intermediate values and lines */
 230             {
 231                 ZText *ztext;
 232                 int val = k * 100 / i;
 233
 234                 snprintf(buf, 255, "%d%%", (int)val);
 235                 ztext = zune_text_new(NULL, buf, ZTEXT_ARG_NONE, 0);
 236                 if (ztext)
 237                 {
 238                     int width;
 239                     zune_text_get_bounds(ztext, obj);
 240                     width = TextLength(_rp(obj), buf, strlen(buf));
 241                     zune_text_draw(ztext, obj,
 242                         _mleft(obj) + _mwidth(obj) * k / i - width / 2,
 243                         _mright(obj), _mtop(obj) + 4);
 244                     zune_text_destroy(ztext);
 245                 }
 246                 Move(_rp(obj), _mleft(obj) + _mwidth(obj) * k / i,
 247                     _mtop(obj));
 248                 Draw(_rp(obj), _mleft(obj) + _mwidth(obj) * k / i,
 249                     _mtop(obj) + 3);
 250                 drawpct = FALSE;
 251             }
 252             else                /* draw intermediate lines */
 253             {
 254                 Move(_rp(obj), _mleft(obj) + _mwidth(obj) * k / i,
 255                     _mtop(obj) + 1);
 256                 Draw(_rp(obj), _mleft(obj) + _mwidth(obj) * k / i,
 257                     _mtop(obj) + 3);
 258                 drawpct = TRUE;
 259             }
 260         }
 261     }
 262     else
 263     {
 264     }
 265     return 0;
 266 }
 267
 268 #if ZUNE_BUILTIN_SCALE
 269 BOOPSI_DISPATCHER(IPTR, Scale_Dispatcher, cl, obj, msg)
 270 {
 271     switch (msg->MethodID)
 272     {
 273     case OM_NEW:
 274         return Scale__OM_NEW(cl, obj, (struct opSet *)msg);
 275     case OM_SET:
 276         return Scale__OM_SET(cl, obj, (struct opSet *)msg);
 277     case OM_GET:
 278         return Scale__OM_GET(cl, obj, (struct opGet *)msg);
 279     case MUIM_Setup:
 280         return Scale__MUIM_Setup(cl, obj, (struct MUIP_Setup *)msg);
 281     case MUIM_AskMinMax:
 282         return Scale__MUIM_AskMinMax(cl, obj, (struct MUIP_AskMinMax *)msg);
 283     case MUIM_Draw:
 284         return Scale__MUIM_Draw(cl, obj, (struct MUIP_Draw *)msg);
 285     default:
 286         return DoSuperMethodA(cl, obj, msg);
 287     }
 288 }
 289 BOOPSI_DISPATCHER_END
 290
 291 const struct __MUIBuiltinClass _MUI_Scale_desc =
 292 {
 293     MUIC_Scale,
 294     MUIC_Area,
 295     sizeof(struct Scale_DATA),
 296     (void *) Scale_Dispatcher
 297 };
 298 #endif /* ZUNE_BUILTIN_SCALE */