workbench/libs/muimaster/classes/numeric.c

   1 /*
   2     Copyright © 2002-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <stdio.h>
   7
   8 #include <clib/alib_protos.h>
   9 #include <proto/exec.h>
  10 #include <proto/intuition.h>
  11 #include <proto/graphics.h>
  12 #include <proto/utility.h>
  13 #include <proto/muimaster.h>
  14
  15 #include "debug.h"
  16 #include "mui.h"
  17 #include "muimaster_intern.h"
  18 #include "support.h"
  19
  20 struct MUI_NumericData
  21 {
  22     STRPTR format;
  23     LONG   defvalue;
  24     LONG   max;
  25     LONG   min;
  26     LONG   value;
  27     ULONG  flags;
  28     struct MUI_EventHandlerNode ehn;
  29     char buf[50];
  30 };
  31
  32 enum numeric_flags {
  33     NUMERIC_REVERSE = (1<<0),
  34     NUMERIC_REVLEFTRIGHT = (1<<1),
  35     NUMERIC_REVUPDOWN = (1<<2),
  36     NUMERIC_CHECKALLSIZES = (1<<3),
  37 };
  38
  39 extern struct Library *MUIMasterBase;
  40
  41 /**************************************************************************
  42  OM_NEW
  43 **************************************************************************/
  44 IPTR Numeric__OM_NEW(struct IClass *cl, Object * obj, struct opSet *msg)
  45 {
  46     struct MUI_NumericData *data;
  47     struct TagItem *tags, *tag;
  48
  49     BOOL value_set = FALSE;
  50
  51     obj = (Object *)DoSuperMethodA(cl, obj, (Msg)msg);
  52     if (!obj)
  53         return 0;
  54
  55     data = INST_DATA(cl, obj);
  56     data->format = "%ld";
  57     data->max    = 100;
  58     data->min    =   0;
  59     data->flags  =   0;
  60
  61     for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem **)&tags));)
  62     {
  63         switch (tag->ti_Tag)
  64         {
  65         case MUIA_Numeric_CheckAllSizes:
  66           _handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_CHECKALLSIZES);
  67           break;
  68         case MUIA_Numeric_Default:
  69           /* data->defvalue = CLAMP(tag->ti_Data, data->min, data->max); */
  70           data->defvalue = tag->ti_Data;
  71           break;
  72         case MUIA_Numeric_Format:
  73           data->format = (STRPTR)tag->ti_Data;
  74           break;
  75         case MUIA_Numeric_Max:
  76           data->max = tag->ti_Data;
  77           break;
  78         case MUIA_Numeric_Min:
  79           data->min = tag->ti_Data;
  80           break;
  81         case MUIA_Numeric_Reverse:
  82           _handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_REVERSE);
  83           break;
  84         case MUIA_Numeric_RevLeftRight:
  85           _handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_REVLEFTRIGHT);
  86           break;
  87         case MUIA_Numeric_RevUpDown:
  88           _handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_REVUPDOWN);
  89           break;
  90         case MUIA_Numeric_Value:
  91           value_set   = TRUE;
  92           data->value = (LONG)tag->ti_Data;
  93           break;
  94         }
  95     }
  96
  97     data->value = CLAMP(value_set ? data->value : data->defvalue, data->min, data->max);
  98
  99     return (IPTR)obj;
 100 }
 101
 102 /**************************************************************************
 103  OM_SET
 104 **************************************************************************/
 105 IPTR Numeric__OM_SET(struct IClass *cl, Object * obj, struct opSet *msg)
 106 {
 107     struct MUI_NumericData *data = INST_DATA(cl, obj);
 108     struct TagItem *tags, *tag;
 109     LONG oldval, oldmin, oldmax;
 110     STRPTR oldfmt;
 111     IPTR ret;
 112     BOOL values_changed = FALSE;
 113
 114     oldval = data->value;
 115     oldfmt = data->format;
 116     oldmin = data->min;
 117     oldmax = data->max;
 118
 119     for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem **)&tags));)
 120     {
 121         switch (tag->ti_Tag)
 122         {
 123             case MUIA_Numeric_CheckAllSizes:
 124                 _handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_CHECKALLSIZES);
 125                 break;
 126             case MUIA_Numeric_Default:
 127                 /* data->defvalue = CLAMP(tag->ti_Data, data->min, data->max); */
 128                 data->defvalue = tag->ti_Data;
 129                 break;
 130             case MUIA_Numeric_Format:
 131                 data->format = (STRPTR)tag->ti_Data;
 132                 break;
 133             case MUIA_Numeric_Max:
 134                 data->max = tag->ti_Data;
 135                 break;
 136             case MUIA_Numeric_Min:
 137                 data->min = tag->ti_Data;
 138                 break;
 139             case MUIA_Numeric_Reverse:
 140                 _handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_REVERSE);
 141                 break;
 142             case MUIA_Numeric_RevLeftRight:
 143                 _handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_REVLEFTRIGHT);
 144                 break;
 145             case MUIA_Numeric_RevUpDown:
 146                 _handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_REVUPDOWN);
 147                 break;
 148             case MUIA_Numeric_Value:
 149                 tag->ti_Data = CLAMP((LONG)tag->ti_Data, data->min, data->max);
 150
 151                 if (data->value == (LONG)tag->ti_Data)
 152                     tag->ti_Tag = TAG_IGNORE;
 153                 else
 154                     data->value = (LONG)tag->ti_Data;
 155
 156                 break;
 157         }
 158     }
 159
 160     /* If the max, min or format values changed, then the minimum and maximum sizes
 161        of the string output by MUIM_Numeric_Strigify maye have changed, so
 162        give the subclass a chance to recalculate them and relayout the group
 163        accordingly. Basically, the subclass will have to react on changes to
 164        these values as well (by setting a notification on them, or by overriding
 165        OM_SET) and then recalculate the minimum and maximum sizes for the object.  */
 166     if (data->format != oldfmt || data->min != oldmin || data->max != oldmax)
 167     {
 168         values_changed = TRUE;
 169         DoMethod(_parent(obj), MUIM_Group_InitChange);
 170         DoMethod(_parent(obj), MUIM_Group_ExitChange);
 171     }
 172
 173
 174     ret = DoSuperMethodA(cl, obj, (Msg)msg);
 175
 176     if (data->value != oldval || values_changed)
 177     {
 178         MUI_Redraw(obj, MADF_DRAWUPDATE);
 179     }
 180
 181     return ret;
 182 }
 183
 184 /**************************************************************************
 185  OM_GET
 186 **************************************************************************/
 187 IPTR Numeric__OM_GET(struct IClass *cl, Object * obj, struct opGet *msg)
 188 {
 189     struct MUI_NumericData *data = INST_DATA(cl, obj);
 190     IPTR *store = msg->opg_Storage;
 191     ULONG    tag = msg->opg_AttrID;
 192
 193     switch (tag)
 194     {
 195         case MUIA_Numeric_CheckAllSizes:
 196             *store = ((data->flags & NUMERIC_CHECKALLSIZES) != 0);
 197             return TRUE;
 198
 199         case MUIA_Numeric_Default:
 200             *store = data->defvalue;
 201             return TRUE;
 202
 203         case MUIA_Numeric_Format:
 204             *store = (IPTR)data->format;
 205             return TRUE;
 206
 207         case MUIA_Numeric_Max:
 208             *store = data->max;
 209             return TRUE;
 210
 211         case MUIA_Numeric_Min:
 212             *store = data->min;
 213             return TRUE;
 214
 215         case MUIA_Numeric_Reverse:
 216             *store = ((data->flags & NUMERIC_REVERSE) != 0);
 217             return TRUE;
 218
 219         case MUIA_Numeric_RevLeftRight:
 220             *store = ((data->flags & NUMERIC_REVLEFTRIGHT) != 0);
 221             return TRUE;
 222
 223         case MUIA_Numeric_RevUpDown:
 224             *store = ((data->flags & NUMERIC_REVUPDOWN) != 0);
 225             return TRUE;
 226
 227         case MUIA_Numeric_Value:
 228             *store = data->value;
 229             return TRUE;
 230     }
 231
 232     return DoSuperMethodA(cl, obj, (Msg)msg);
 233 }
 234
 235 /**************************************************************************
 236  MUIM_Setup
 237 **************************************************************************/
 238 IPTR Numeric__MUIM_Setup(struct IClass *cl, Object *obj, struct MUIP_Setup *msg)
 239 {
 240     struct MUI_NumericData *data = INST_DATA(cl, obj);
 241
 242     if (!DoSuperMethodA(cl,obj,(Msg)msg))
 243         return FALSE;
 244
 245     data->ehn.ehn_Events = IDCMP_RAWKEY;
 246     data->ehn.ehn_Priority = 0;
 247     data->ehn.ehn_Flags    = 0;
 248     data->ehn.ehn_Object   = obj;
 249     data->ehn.ehn_Class    = cl;
 250     DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR)(&data->ehn));
 251
 252     return TRUE;
 253 }
 254
 255 /**************************************************************************
 256  MUIM_Cleanup
 257 **************************************************************************/
 258 IPTR Numeric__MUIM_Cleanup(struct IClass *cl, Object *obj, struct MUIP_Cleanup *msg)
 259 {
 260     struct MUI_NumericData *data = INST_DATA(cl, obj);
 261
 262     DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR)(&data->ehn));
 263     return DoSuperMethodA(cl,obj,(Msg)msg);
 264 }
 265
 266 /**************************************************************************
 267  MUIM_HandleEvent
 268 **************************************************************************/
 269 IPTR Numeric__MUIM_HandleEvent(struct IClass *cl, Object *obj, struct MUIP_HandleEvent *msg)
 270 {
 271     struct MUI_NumericData *data = INST_DATA(cl, obj);
 272
 273     if (msg->muikey != MUIKEY_NONE)
 274     {
 275         LONG step;
 276
 277         if (data->max - data->min < 10)
 278             step = 1;
 279         else
 280             step = 10;
 281
 282         switch(msg->muikey)
 283         {
 284             case    MUIKEY_PRESS:
 285                     return MUI_EventHandlerRC_Eat;
 286
 287             case    MUIKEY_TOGGLE:
 288                     DoMethod(obj, MUIM_Numeric_SetDefault);
 289                     return MUI_EventHandlerRC_Eat;
 290
 291             case    MUIKEY_RELEASE:
 292                     return MUI_EventHandlerRC_Eat;
 293
 294             case    MUIKEY_BOTTOM:
 295             case    MUIKEY_LINEEND:
 296                     if (data->flags & NUMERIC_REVUPDOWN)
 297                         set(obj, MUIA_Numeric_Value, data->min);
 298                     else
 299                         set(obj, MUIA_Numeric_Value, data->max);
 300                     return MUI_EventHandlerRC_Eat;
 301
 302             case    MUIKEY_TOP:
 303             case    MUIKEY_LINESTART:
 304                     if (data->flags & NUMERIC_REVUPDOWN)
 305                         set(obj, MUIA_Numeric_Value, data->max);
 306                     else
 307                         set(obj, MUIA_Numeric_Value, data->min);
 308                     return MUI_EventHandlerRC_Eat;
 309
 310             case    MUIKEY_LEFT:
 311                     if (data->flags & NUMERIC_REVLEFTRIGHT)
 312                         DoMethod(obj, MUIM_Numeric_Increase, 1);
 313                     else
 314                         DoMethod(obj, MUIM_Numeric_Decrease, 1);
 315                     return MUI_EventHandlerRC_Eat;
 316
 317             case    MUIKEY_RIGHT:
 318                     if (data->flags & NUMERIC_REVLEFTRIGHT)
 319                         DoMethod(obj, MUIM_Numeric_Decrease, 1);
 320                     else
 321                         DoMethod(obj, MUIM_Numeric_Increase, 1);
 322                     return MUI_EventHandlerRC_Eat;
 323
 324             case    MUIKEY_UP:
 325                     if (data->flags & NUMERIC_REVUPDOWN)
 326                         DoMethod(obj, MUIM_Numeric_Increase, 1);
 327                     else
 328                         DoMethod(obj, MUIM_Numeric_Decrease, 1);
 329                     return MUI_EventHandlerRC_Eat;
 330
 331             case    MUIKEY_DOWN:
 332                     if (data->flags & NUMERIC_REVUPDOWN)
 333                         DoMethod(obj, MUIM_Numeric_Decrease, 1);
 334                     else
 335                         DoMethod(obj, MUIM_Numeric_Increase, 1);
 336                     return MUI_EventHandlerRC_Eat;
 337
 338             case MUIKEY_PAGEDOWN:
 339             case MUIKEY_WORDRIGHT:
 340                 if (data->flags & NUMERIC_REVUPDOWN)
 341                     DoMethod(obj, MUIM_Numeric_Decrease, step);
 342                 else
 343                     DoMethod(obj, MUIM_Numeric_Increase, step);
 344                 return MUI_EventHandlerRC_Eat;
 345
 346             case MUIKEY_PAGEUP:
 347             case MUIKEY_WORDLEFT:
 348                 if (data->flags & NUMERIC_REVUPDOWN)
 349                     DoMethod(obj, MUIM_Numeric_Increase, step);
 350                 else
 351                     DoMethod(obj, MUIM_Numeric_Decrease, step);
 352                 return MUI_EventHandlerRC_Eat;
 353
 354             default:
 355                     return 0;
 356         }
 357     }
 358
 359     return 0;
 360 }
 361
 362
 363 /**************************************************************************
 364  MUIM_Numeric_Decrease
 365 **************************************************************************/
 366 IPTR Numeric__MUIM_Decrease(struct IClass *cl, Object * obj, struct MUIP_Numeric_Decrease *msg)
 367 {
 368     struct MUI_NumericData *data = INST_DATA(cl, obj);
 369     LONG newval = CLAMP(data->value - msg->amount, data->min, data->max);
 370     if (newval != data->value) set(obj,MUIA_Numeric_Value, newval);
 371     return 1;
 372 }
 373
 374 /**************************************************************************
 375  MUIM_Numeric_Increase
 376 **************************************************************************/
 377 IPTR Numeric__MUIM_Increase(struct IClass *cl, Object * obj, struct MUIP_Numeric_Increase *msg)
 378 {
 379     struct MUI_NumericData *data = INST_DATA(cl, obj);
 380     LONG newval = CLAMP(data->value + msg->amount, data->min, data->max);
 381
 382     if (newval != data->value) set(obj,MUIA_Numeric_Value, newval);
 383     return 1;
 384 }
 385
 386
 387 /**************************************************************************
 388  MUIM_Numeric_ScaleToValue
 389 **************************************************************************/
 390 IPTR Numeric__MUIM_ScaleToValue(struct IClass *cl, Object * obj, struct MUIP_Numeric_ScaleToValue *msg)
 391 {
 392     struct MUI_NumericData *data = INST_DATA(cl, obj);
 393     LONG min, max;
 394     LONG val;
 395     LONG d;
 396
 397     min = (data->flags & NUMERIC_REVERSE) ? data->max : data->min;
 398     max = (data->flags & NUMERIC_REVERSE) ? data->min : data->max;
 399
 400     val  = CLAMP(msg->scale - msg->scalemin, msg->scalemin, msg->scalemax);
 401     d    = msg->scalemax -  msg->scalemin;
 402
 403 #warning FIXME: watch out for overflow here.
 404     val  = val * (max - min);
 405
 406     if (d)
 407         val /= d;
 408
 409     val += min;
 410
 411     return val;
 412 }
 413
 414 /**************************************************************************
 415  MUIM_Numeric_SetDefault
 416 **************************************************************************/
 417 IPTR Numeric__MUIM_SetDefault(struct IClass *cl, Object * obj, Msg msg)
 418 {
 419     struct MUI_NumericData *data = INST_DATA(cl, obj);
 420
 421     set(obj, MUIA_Numeric_Value, CLAMP(data->defvalue, data->min, data->max));
 422
 423     return 0;
 424 }
 425
 426 /**************************************************************************
 427  MUIM_Numeric_Stringify
 428 **************************************************************************/
 429 IPTR Numeric__MUIM_Stringify(struct IClass *cl, Object * obj, struct MUIP_Numeric_Stringify *msg)
 430 {
 431     struct MUI_NumericData *data = INST_DATA(cl, obj);
 432
 433     /* TODO: use RawDoFmt() and buffer overrun */
 434     snprintf(data->buf, 49, data->format, msg->value);
 435     data->buf[49] = 0;
 436
 437     return (IPTR)data->buf;
 438 }
 439
 440 /**************************************************************************
 441  MUIM_Numeric_ValueToScale
 442 **************************************************************************/
 443 IPTR Numeric__MUIM_ValueToScale(struct IClass *cl, Object * obj, struct MUIP_Numeric_ValueToScale *msg)
 444 {
 445     LONG val;
 446     struct MUI_NumericData *data = INST_DATA(cl, obj);
 447     LONG min, max;
 448
 449     min = (data->flags & NUMERIC_REVERSE) ? msg->scalemax : msg->scalemin;
 450     max = (data->flags & NUMERIC_REVERSE) ? msg->scalemin : msg->scalemax;
 451
 452     if (data->max != data->min)
 453     {
 454         val = min + ((data->value - data->min) * (max - min) +  (data->max - data->min)/2) / (data->max - data->min);
 455     }
 456     else
 457     {
 458         val = min;
 459     }
 460
 461     val = CLAMP(val, min, max);
 462
 463     return val;
 464 }
 465
 466 /**************************************************************************
 467  MUIM_Numeric_ValueToScaleExt
 468 **************************************************************************/
 469 IPTR Numeric__MUIM_ValueToScaleExt(struct IClass *cl, Object * obj, struct MUIP_Numeric_ValueToScaleExt *msg)
 470 {
 471     LONG scale;
 472     LONG value;
 473     struct MUI_NumericData *data = INST_DATA(cl, obj);
 474     LONG min, max;
 475
 476     value = CLAMP(msg->value,data->min,data->max);
 477     min = (data->flags & NUMERIC_REVERSE) ? msg->scalemax : msg->scalemin;
 478     max = (data->flags & NUMERIC_REVERSE) ? msg->scalemin : msg->scalemax;
 479
 480     if (data->max != data->min)
 481     {
 482         scale = min + ((value - data->min) * (max - min) +  (data->max - data->min)/2) / (data->max - data->min);
 483     }
 484     else
 485     {
 486         scale = min;
 487     }
 488
 489     scale = CLAMP(scale, min, max);
 490
 491     return scale;
 492 }
 493
 494 /**************************************************************************
 495  MUIM_Export - to export an objects "contents" to a dataspace object.
 496 **************************************************************************/
 497 IPTR Numeric__MUIM_Export(struct IClass *cl, Object *obj, struct MUIP_Export *msg)
 498 {
 499     struct MUI_NumericData *data = INST_DATA(cl, obj);
 500     ULONG id;
 501
 502     if ((id = muiNotifyData(obj)->mnd_ObjectID))
 503     {
 504         LONG value = data->value;
 505         DoMethod(msg->dataspace, MUIM_Dataspace_Add,
 506                 (IPTR) &value,
 507                 sizeof(value),
 508                 (IPTR) id);
 509     }
 510     return 0;
 511 }
 512
 513 /**************************************************************************
 514  MUIM_Import - to import an objects "contents" from a dataspace object.
 515 **************************************************************************/
 516 IPTR Numeric__MUIM_Import(struct IClass *cl, Object *obj, struct MUIP_Import *msg)
 517 {
 518     ULONG id;
 519     LONG *s;
 520
 521     if ((id = muiNotifyData(obj)->mnd_ObjectID))
 522     {
 523         if ((s = (LONG*) DoMethod(msg->dataspace, MUIM_Dataspace_Find, (IPTR) id)))
 524         {
 525             set(obj, MUIA_Numeric_Value, *s);
 526         }
 527     }
 528     return 0;
 529 }
 530
 531
 532 BOOPSI_DISPATCHER(IPTR, Numeric_Dispatcher, cl, obj, msg)
 533 {
 534     switch (msg->MethodID)
 535     {
 536         case OM_NEW:                       return Numeric__OM_NEW(cl, obj, (APTR)msg);
 537         case OM_SET:                       return Numeric__OM_SET(cl, obj, (APTR)msg);
 538         case OM_GET:                       return Numeric__OM_GET(cl, obj, (APTR)msg);
 539
 540         case MUIM_Setup:                   return Numeric__MUIM_Setup(cl, obj, (APTR)msg);
 541         case MUIM_Cleanup:                 return Numeric__MUIM_Cleanup(cl, obj, (APTR)msg);
 542         case MUIM_HandleEvent:             return Numeric__MUIM_HandleEvent(cl, obj, (APTR)msg);
 543         case MUIM_Numeric_Decrease:        return Numeric__MUIM_Decrease(cl, obj, (APTR)msg);
 544         case MUIM_Numeric_Increase:        return Numeric__MUIM_Increase(cl, obj, (APTR)msg);
 545         case MUIM_Numeric_ScaleToValue:    return Numeric__MUIM_ScaleToValue(cl, obj, (APTR)msg);
 546         case MUIM_Numeric_SetDefault:      return Numeric__MUIM_SetDefault(cl, obj, (APTR)msg);
 547         case MUIM_Numeric_Stringify:       return Numeric__MUIM_Stringify(cl, obj, (APTR)msg);
 548         case MUIM_Numeric_ValueToScale:    return Numeric__MUIM_ValueToScale(cl, obj, (APTR)msg);
 549         case MUIM_Numeric_ValueToScaleExt: return Numeric__MUIM_ValueToScaleExt(cl, obj, (APTR)msg);
 550         case MUIM_Export:                  return Numeric__MUIM_Export(cl, obj, (APTR)msg);
 551         case MUIM_Import:                  return Numeric__MUIM_Import(cl, obj, (APTR)msg);
 552     }
 553
 554     return DoSuperMethodA(cl, obj, msg);
 555 }
 556 BOOPSI_DISPATCHER_END
 557
 558
 559 /*
 560  * Class descriptor.
 561  */
 562 const struct __MUIBuiltinClass _MUI_Numeric_desc = {
 563     MUIC_Numeric,
 564     MUIC_Area,
 565     sizeof(struct MUI_NumericData),
 566     (void*)Numeric_Dispatcher
 567 };
 568