workbench/classes/zune/clock/clock.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 #include <math.h>
  23
  24 #include "clock.h"
  25 #include "clock_private.h"
  26
  27 #define SHADOW_OFFX 4
  28 #define SHADOW_OFFY 4
  29
  30
  31 /*** Methods ****************************************************************/
  32 IPTR Clock__OM_NEW(Class *cl, Object *obj, struct opSet *msg)
  33 {
  34     struct Clock_DATA *data;
  35     struct TagItem      *ti;
  36
  37     obj = (Object *) DoSuperNewTags
  38     (
  39         cl, obj, NULL,
  40
  41         MUIA_InnerLeft,   4,
  42         MUIA_InnerTop,    4,
  43         MUIA_InnerRight,  4,
  44         MUIA_InnerBottom, 4,
  45
  46         TAG_MORE, (IPTR) msg->ops_AttrList
  47     );
  48
  49     if (!obj) return 0;
  50
  51     data = INST_DATA(cl, obj);
  52     data->frozen = GetTagData(MUIA_Clock_Frozen, FALSE, msg->ops_AttrList) ? TRUE : FALSE;
  53     data->edithand = (WORD)GetTagData(MUIA_Clock_EditHand, (IPTR)-1, msg->ops_AttrList);
  54     data->editpen = -1;
  55
  56     if ((ti = FindTagItem(MUIA_Clock_Time, msg->ops_AttrList)))
  57     {
  58         struct ClockData *cd = (struct ClockData *)ti->ti_Data;
  59
  60         data->clockdata = *cd;
  61     }
  62     else
  63     {
  64         struct timeval tv;
  65
  66         GetSysTime(&tv);
  67         Amiga2Date(tv.tv_secs, &data->clockdata);
  68     }
  69
  70     data->ihn.ihn_Flags  = MUIIHNF_TIMER;
  71     data->ihn.ihn_Method = MUIM_Clock_Timer;
  72     data->ihn.ihn_Object = obj;
  73     data->ihn.ihn_Millis = 1000;
  74
  75     return (IPTR)obj;
  76 }
  77
  78
  79 IPTR Clock__OM_DISPOSE(Class *cl, Object *obj, Msg msg)
  80 {
  81     return DoSuperMethodA(cl, obj, msg);
  82 }
  83
  84
  85 IPTR Clock__OM_SET(Class *cl, Object *obj, struct opSet *msg)
  86 {
  87     struct Clock_DATA *data = INST_DATA(cl, obj);
  88     struct ClockData      old_clockdata;
  89     const struct TagItem *tags  = msg->ops_AttrList;
  90     struct TagItem       *tag;
  91     BOOL                  redraw = FALSE;
  92
  93     old_clockdata = data->clockdata;
  94
  95     while ((tag = NextTagItem(&tags)) != NULL)
  96     {
  97         switch(tag->ti_Tag)
  98         {
  99             case MUIA_Clock_Time:
 100                 data->clockdata = *(struct ClockData *)tag->ti_Data;
 101                 redraw = TRUE;
 102                 break;
 103
 104             case MUIA_Clock_Hour:
 105                 data->clockdata.hour = tag->ti_Data;
 106                 redraw = TRUE;
 107                 break;
 108
 109             case MUIA_Clock_Min:
 110                 data->clockdata.min = tag->ti_Data;
 111                 redraw = TRUE;
 112                 break;
 113
 114             case MUIA_Clock_Sec:
 115                 data->clockdata.sec = tag->ti_Data;
 116                 redraw = TRUE;
 117                 break;
 118
 119             case MUIA_Clock_Frozen:
 120                 data->frozen = tag->ti_Data ? TRUE : FALSE;
 121                 break;
 122
 123             case MUIA_Clock_EditHand:
 124                 data->edithand = tag->ti_Data;
 125                 redraw = TRUE;
 126                 break;
 127
 128         } /* switch(tag->ti_Tag) */
 129
 130     } /* while ((tag = NextTagItem(&tags)) != NULL) */
 131
 132     if (redraw)
 133     {
 134          MUI_Redraw(obj, MADF_DRAWUPDATE);
 135     }
 136
 137     return DoSuperMethodA(cl, obj, (Msg)msg);
 138 }
 139
 140
 141 IPTR Clock__OM_GET(Class *cl, Object *obj, struct opGet *msg)
 142 {
 143     struct Clock_DATA *data = INST_DATA(cl, obj);
 144     IPTR              retval = TRUE;
 145
 146     switch(msg->opg_AttrID)
 147     {
 148         case MUIA_Clock_Time:
 149             *(struct ClockData **)msg->opg_Storage = &data->clockdata;
 150             break;
 151
 152         case MUIA_Clock_Hour:
 153             *msg->opg_Storage = data->clockdata.hour;
 154             break;
 155
 156         case MUIA_Clock_Min:
 157             *msg->opg_Storage = data->clockdata.min;
 158             break;
 159
 160         case MUIA_Clock_Sec:
 161             *msg->opg_Storage = data->clockdata.sec;
 162             break;
 163
 164         case MUIA_Clock_Frozen:
 165             *msg->opg_Storage = data->frozen;
 166             break;
 167
 168         case MUIA_Clock_EditHand:
 169             *msg->opg_Storage = data->edithand;
 170             break;
 171
 172         default:
 173             retval = DoSuperMethodA(cl, obj, (Msg)msg);
 174             break;
 175     }
 176
 177     return retval;
 178 }
 179
 180
 181 IPTR Clock__MUIM_Setup(Class *cl, Object *obj, struct MUIP_Setup *msg)
 182 {
 183     struct Clock_DATA *data = INST_DATA(cl, obj);
 184
 185     if (!DoSuperMethodA(cl, obj, (Msg)msg)) return FALSE;
 186
 187     DoMethod(_app(obj), MUIM_Application_AddInputHandler, (IPTR) &data->ihn);
 188
 189     data->editpen = ObtainBestPen(_screen(obj)->ViewPort.ColorMap,
 190                                   0xFFFFFFFF,
 191                                   0xD8D8D8D8,
 192                                   0x00000000,
 193                                   OBP_Precision, PRECISION_GUI,
 194                                   OBP_FailIfBad, FALSE,
 195                                   TAG_DONE);
 196     return TRUE;
 197 }
 198
 199
 200 IPTR Clock__MUIM_Cleanup(Class *cl, Object *obj, struct MUIP_Cleanup *msg)
 201 {
 202     struct Clock_DATA *data = INST_DATA(cl, obj);
 203
 204     if (data->editpen != -1)
 205     {
 206         ReleasePen(_screen(obj)->ViewPort.ColorMap, data->editpen);
 207         data->editpen = -1;
 208     }
 209
 210     if (data->clockbm)
 211     {
 212         DeinitRastPort(&data->clockrp);
 213         FreeBitMap(data->clockbm);
 214         FreeRaster(data->clockraster, data->clockbmw, data->clockbmh);
 215         data->clockbm = NULL;
 216         data->clockraster = NULL;
 217     }
 218     DoMethod(_app(obj), MUIM_Application_RemInputHandler, (IPTR) &data->ihn);
 219
 220     return DoSuperMethodA(cl, obj, (Msg)msg);
 221 }
 222
 223
 224 IPTR Clock__MUIM_AskMinMax(Class *cl, Object *obj, struct MUIP_AskMinMax *msg)
 225 {
 226     DoSuperMethodA(cl, obj, (Msg)msg);
 227
 228     msg->MinMaxInfo->MinWidth  += 31;
 229     msg->MinMaxInfo->MinHeight += 31;
 230     msg->MinMaxInfo->DefWidth  += 31;
 231     msg->MinMaxInfo->DefHeight += 31;
 232     msg->MinMaxInfo->MaxWidth   = MUI_MAXMAX;
 233     msg->MinMaxInfo->MaxHeight  = MUI_MAXMAX;
 234
 235     return TRUE;
 236 }
 237
 238
 239 #define MY_PI 3.14159265358979323846
 240
 241 static void DrawHand
 242 (
 243     struct RastPort *rp, WORD cx, WORD cy, DOUBLE angle,
 244     WORD radius1, WORD radius2
 245 )
 246 {
 247     WORD x, y;
 248
 249     x = cx + (WORD)(cos(angle + MY_PI) * radius1);
 250     y = cy - (WORD)(sin(angle + MY_PI) * radius1);
 251
 252     AreaMove(rp, x, y);
 253
 254     x = cx + (WORD)(cos(angle + MY_PI / 2.0) * radius1);
 255     y = cy - (WORD)(sin(angle + MY_PI / 2.0) * radius1);
 256
 257     AreaDraw(rp, x, y);
 258
 259     x = cx + (WORD)(cos(angle) * radius2);
 260     y = cy - (WORD)(sin(angle) * radius2);
 261
 262     AreaDraw(rp, x, y);
 263
 264     x = cx + (WORD)(cos(angle - MY_PI / 2.0) * radius1);
 265     y = cy - (WORD)(sin(angle - MY_PI / 2.0) * radius1);
 266
 267     AreaDraw(rp, x, y);
 268
 269     x = cx + (WORD)(cos(angle + MY_PI) * radius1);
 270     y = cy - (WORD)(sin(angle + MY_PI) * radius1);
 271
 272     AreaDraw(rp, x, y);
 273
 274     AreaEnd(rp);
 275 }
 276
 277
 278 static void DrawThinHand(struct RastPort *rp, WORD cx, WORD cy, DOUBLE angle, WORD radius)
 279 {
 280     WORD x, y;
 281
 282     Move(rp, cx, cy);
 283
 284     x = cx + (WORD)(cos(angle) * radius);
 285     y = cy - (WORD)(sin(angle) * radius);
 286
 287     Draw(rp, x, y);
 288 }
 289
 290 IPTR Clock__MUIM_Draw(Class *cl, Object *obj, struct MUIP_Draw *msg)
 291 {
 292     struct Clock_DATA *data = INST_DATA(cl, obj);
 293     struct RastPort      *obj_rp;
 294     struct Region        *region;
 295     struct Rectangle     rect;
 296     APTR                 clip = NULL;
 297     WORD                 r, x, y, x2, y2, i, cx, cy, c;
 298     WORD                 new_clockbmw, new_clockbmh;
 299     WORD                 clock_posx, clock_posy;
 300     DOUBLE               angle;
 301
 302     r = (_mwidth(obj) - SHADOW_OFFX) / 2;
 303     y = (_mheight(obj) - SHADOW_OFFY) / 2;
 304
 305     r = (r < y) ? r : y;
 306
 307     new_clockbmw = r * 2 + 1 + SHADOW_OFFX;
 308     new_clockbmh = r * 2 + 1 + SHADOW_OFFY;
 309
 310     clock_posx = _mleft(obj) + (_mwidth(obj) - new_clockbmw) / 2;
 311     clock_posy = _mtop(obj) + (_mheight(obj) - new_clockbmh) / 2;
 312
 313     region = NewRegion();
 314     if (region)
 315     {
 316         rect.MinX = _left(obj);
 317         rect.MinY = _top(obj);
 318         rect.MaxX = _right(obj);
 319         rect.MaxY = _bottom(obj);
 320
 321         OrRectRegion(region, &rect);
 322
 323         rect.MinX = clock_posx;
 324         rect.MinY = clock_posy;
 325         rect.MaxX = clock_posx + new_clockbmw - 1;
 326         rect.MaxY = clock_posy + new_clockbmh - 1;
 327
 328         ClearRectRegion(region, &rect);
 329
 330         clip = MUI_AddClipRegion(muiRenderInfo(obj), region);
 331     }
 332
 333     DoSuperMethodA(cl, obj, (Msg)msg);
 334
 335     if (region)
 336     {
 337         MUI_RemoveClipRegion(muiRenderInfo(obj), clip);
 338     }
 339
 340     if (!(msg->flags & (MADF_DRAWOBJECT | MADF_DRAWUPDATE))) return 0;
 341
 342     if (!data->clockbm || (data->clockbmr != r))
 343     {
 344         if (data->clockbm)
 345         {
 346             DeinitRastPort(&data->clockrp);
 347             FreeBitMap(data->clockbm);
 348             FreeRaster(data->clockraster, data->clockbmw, data->clockbmh);
 349             data->clockraster = NULL;
 350         }
 351
 352         data->clockbmw = new_clockbmw;
 353         data->clockbmh = new_clockbmh;
 354
 355         data->clockbm = AllocBitMap(data->clockbmw,
 356                                     data->clockbmh,
 357                                     GetBitMapAttr(_rp(obj)->BitMap, BMA_DEPTH),
 358                                     BMF_MINPLANES,
 359                                     _rp(obj)->BitMap);
 360
 361         if (!data->clockbm) return 0;
 362
 363         data->clockraster = AllocRaster(data->clockbmw, data->clockbmh);
 364         if (!data->clockraster)
 365         {
 366             FreeBitMap(data->clockbm);
 367             data->clockbm = 0;
 368             return 0;
 369         }
 370
 371         InitRastPort(&data->clockrp);
 372         data->clockrp.BitMap = data->clockbm;
 373
 374         InitArea(&data->clockai, data->areabuf, sizeof(data->areabuf) / 5);
 375         data->clockrp.AreaInfo = &data->clockai;
 376
 377         InitTmpRas(&data->clocktr, data->clockraster, RASSIZE(data->clockbmw, data->clockbmh));
 378         data->clockrp.TmpRas = &data->clocktr;
 379
 380         data->clockbmr = r;
 381     }
 382
 383     obj_rp = _rp(obj);
 384     _rp(obj) = &data->clockrp;
 385
 386     DoMethod(obj, MUIM_DrawBackground, 0, 0, data->clockbmw , data->clockbmh, clock_posx, clock_posy, 0);
 387
 388     cx = r + SHADOW_OFFX;
 389     cy = r + SHADOW_OFFY;
 390
 391     SetDrMd(_rp(obj), JAM1);
 392     SetAPen(_rp(obj), _pens(obj)[MPEN_HALFSHADOW]);
 393
 394     for(c = 0; c < 2; c++)
 395     {
 396         for(angle = 0.0, i = 0; angle < 2.0 * MY_PI; angle += 2 * MY_PI / 60.0, i++)
 397         {
 398             x = cx + (WORD)(cos(angle) * r);
 399             y = cy - (WORD)(sin(angle) * r);
 400
 401             if ((i % 5) == 0)
 402             {
 403                 x2 = cx + (WORD)(cos(angle) * (r * 90 / 100));
 404                 y2 = cy - (WORD)(sin(angle) * (r * 90 / 100));
 405                 Move(_rp(obj), x, y); Draw(_rp(obj), x2, y2);
 406             }
 407             else
 408             {
 409                 WritePixel(_rp(obj), x, y);
 410             }
 411         }
 412
 413         cx -= SHADOW_OFFX;
 414         cy -= SHADOW_OFFY;
 415         SetAPen(_rp(obj), _dri(obj)->dri_Pens[SHADOWPEN]);
 416     }
 417
 418     cx += SHADOW_OFFX * 2;
 419     cy += SHADOW_OFFY * 2;
 420
 421     SetAPen(_rp(obj), _pens(obj)[MPEN_HALFSHADOW]);
 422
 423     for(c = 0; c < 2; c++)
 424     {
 425         DOUBLE angle, h;
 426
 427         h = data->clockdata.hour + (data->clockdata.min / 60.0);
 428         if (h > 12.0) h -= 12.0;
 429
 430         angle = MY_PI / 2.0 + MY_PI * 2.0 * (12.0 - h) / 12.0;
 431
 432         if (c == 1)
 433         {
 434             if ((data->edithand == MUIV_Clock_EditHand_Hour) && data->frozen)
 435             {
 436                 SetAPen(_rp(obj), (data->editpen == -1) ? _dri(obj)->dri_Pens[SHINEPEN] : data->editpen);
 437             }
 438             else
 439             {
 440                 SetAPen(_rp(obj), _dri(obj)->dri_Pens[SHADOWPEN]);
 441             }
 442         }
 443
 444         DrawHand(_rp(obj),
 445                  cx,
 446                  cy,
 447                  angle,
 448                  r * 6 / 100,
 449                  r * 60 / 100);
 450
 451         angle = MY_PI / 2.0 + MY_PI * 2.0 * ((double)60 - data->clockdata.min) / 60.0;
 452
 453         if (c == 1)
 454         {
 455             if ((data->edithand == MUIV_Clock_EditHand_Minute) && data->frozen)
 456             {
 457                 SetAPen(_rp(obj), (data->editpen == -1) ? _dri(obj)->dri_Pens[SHINEPEN] : data->editpen);
 458             }
 459             else
 460             {
 461                 SetAPen(_rp(obj), _dri(obj)->dri_Pens[SHADOWPEN]);
 462             }
 463         }
 464
 465         DrawHand(_rp(obj),
 466                  cx,
 467                  cy,
 468                  angle,
 469                  r * 4 / 100,
 470                  r * 85 / 100);
 471
 472         angle = MY_PI / 2.0 + MY_PI * 2.0 * ((double)60 - data->clockdata.sec) / 60.0;
 473
 474         if (c == 1)
 475         {
 476             if ((data->edithand == MUIV_Clock_EditHand_Second) && data->frozen)
 477             {
 478                 SetAPen(_rp(obj), (data->editpen == -1) ? _dri(obj)->dri_Pens[SHINEPEN] : data->editpen);
 479             }
 480             else
 481             {
 482                 SetAPen(_rp(obj), _dri(obj)->dri_Pens[SHADOWPEN]);
 483             }
 484         }
 485
 486         DrawThinHand(_rp(obj), cx, cy, angle, r * 85 / 100);
 487
 488         cx -= SHADOW_OFFX;
 489         cy -= SHADOW_OFFY;
 490
 491     }
 492
 493     _rp(obj) = obj_rp;
 494
 495     BltBitMapRastPort(data->clockbm,
 496                       0,
 497                       0,
 498                       _rp(obj),
 499                       clock_posx,
 500                       clock_posy,
 501                       data->clockbmw,
 502                       data->clockbmh, 192);
 503
 504     return 0;
 505 }
 506
 507
 508 IPTR Clock__MUIM_Clock_Timer(Class *cl, Object *obj, Msg msg)
 509 {
 510     struct Clock_DATA *data;
 511     struct ClockData      cd;
 512     struct timeval        tv;
 513
 514     data = INST_DATA(cl, obj);
 515
 516     if (!data->frozen)
 517     {
 518         GetSysTime(&tv);
 519         Amiga2Date(tv.tv_secs, &cd);
 520
 521         set(obj, MUIA_Clock_Time, &cd);
 522         set(obj, MUIA_Clock_Ticked, TRUE);
 523     }
 524
 525     return 0;
 526 }