workbench/classes/zune/clock/clock.c

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