workbench/classes/zune/nlist/nbitmap_mcc/dispatcher.c

   1 /***************************************************************************
   2
   3  NBitmap.mcc - New Bitmap MUI Custom Class
   4  Copyright (C) 2006 by Daniel Allsopp
   5  Copyright (C) 2007-2013 by NList Open Source Team
   6
   7  This library is free software; you can redistribute it and/or
   8  modify it under the terms of the GNU Lesser General Public
   9  License as published by the Free Software Foundation; either
  10  version 2.1 of the License, or (at your option) any later version.
  11
  12  This library is distributed in the hope that it will be useful,
  13  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  Lesser General Public License for more details.
  16
  17  NList classes Support Site:  http://www.sf.net/projects/nlist-classes
  18
  19  $Id$
  20
  21 ***************************************************************************/
  22
  23 /* ansi includes */
  24 #include <string.h>
  25
  26 /* system includes */
  27 #include <clib/alib_protos.h>
  28 #include <proto/exec.h>
  29 #include <proto/intuition.h>
  30 #include <proto/muimaster.h>
  31 #include <proto/graphics.h>
  32 #include <proto/utility.h>
  33 #include <proto/locale.h>
  34 #include <mui/NBitmap_mcc.h>
  35
  36 /* local includes */
  37 #include "NBitmap.h"
  38 #include "private.h"
  39
  40 #include "Debug.h"
  41
  42 /* Object *DoSuperNew() */
  43 #if !defined(__MORPHOS__)
  44 #ifdef __AROS__
  45 static __attribute__ ((noinline)) Object * VARARGS68K DoSuperNew(struct IClass *cl, Object *obj, Tag tag1, ...)
  46 {
  47     AROS_SLOWSTACKTAGS_PRE_AS(tag1, Object *)
  48     retval = (Object *)DoSuperMethod(cl, obj, OM_NEW, AROS_SLOWSTACKTAGS_ARG(tag1), NULL);
  49     AROS_SLOWSTACKTAGS_POST
  50 }
  51 #else
  52 static Object * VARARGS68K DoSuperNew(struct IClass *cl, Object *obj, ...)
  53 {
  54   Object *rc;
  55   VA_LIST args;
  56
  57   ENTER();
  58
  59   VA_START(args, obj);
  60   rc = (Object *)DoSuperMethod(cl, obj, OM_NEW, VA_ARG(args, ULONG), NULL);
  61   VA_END(args);
  62
  63   RETURN(rc);
  64   return rc;
  65 }
  66 #endif
  67 #endif // !__MORPHOS__
  68
  69 /* VOID setstr() */
  70 static VOID setstr(STRPTR *dest, STRPTR str)
  71 {
  72   ENTER();
  73
  74   if(*dest != NULL)
  75   {
  76     FreeVec(*dest);
  77     *dest = NULL;
  78   }
  79
  80   if(str != NULL)
  81   {
  82     ULONG len;
  83
  84     len = strlen(str) + 1;
  85     if((*dest = AllocVecShared(len, MEMF_ANY)) != NULL)
  86       strlcpy(*dest, str, len);
  87   }
  88
  89   LEAVE();
  90 }
  91
  92 /* ULONG NBitmap_New() */
  93 static IPTR NBitmap_New(struct IClass *cl, Object *obj, struct opSet *msg)
  94 {
  95   if((obj = (Object *)DoSuperNew(cl, obj,
  96     MUIA_CycleChain, TRUE,
  97     //MUIA_FillArea, FALSE,
  98     MUIA_Font, MUIV_Font_Tiny,
  99     TAG_MORE, msg->ops_AttrList)) != NULL)
 100   {
 101     struct InstData *data = NULL;
 102
 103     if((data = INST_DATA(cl, obj)) != NULL)
 104     {
 105       // assume a valid data type for the moment
 106       BOOL typeOk = TRUE;
 107       uint32 i;
 108       struct TagItem *tags = NULL, *tag = NULL;
 109
 110       memset(data, 0, sizeof(struct InstData));
 111
 112       data->type = MUIV_NBitmap_Type_File;
 113       data->alpha = 0xffffffffUL;
 114
 115       // passed tags
 116       for(tags = ((struct opSet *)msg)->ops_AttrList; (tag = NextTagItem((APTR)&tags)) != NULL; )
 117       {
 118         switch(tag->ti_Tag)
 119         {
 120           case MUIA_NBitmap_Type:
 121             data->type = tag->ti_Data;
 122           break;
 123
 124           case MUIA_NBitmap_Normal:
 125             data->data[0] = (uint32*)tag->ti_Data;
 126           break;
 127
 128           case MUIA_NBitmap_Ghosted:
 129             data->data[1] = (uint32*)tag->ti_Data;
 130           break;
 131
 132           case MUIA_NBitmap_Selected:
 133             data->data[2] = (uint32*)tag->ti_Data;
 134           break;
 135
 136           case MUIA_NBitmap_Button:
 137             data->button = (BOOL)tag->ti_Data;
 138           break;
 139
 140           case MUIA_NBitmap_Label:
 141             setstr(&data->label, (STRPTR)tag->ti_Data);
 142           break;
 143
 144           case MUIA_NBitmap_Width:
 145             data->width = tag->ti_Data;
 146           break;
 147
 148           case MUIA_NBitmap_Height:
 149             data->height = tag->ti_Data;
 150           break;
 151
 152           case MUIA_NBitmap_CLUT:
 153             data->clut = (const uint32 *)tag->ti_Data;
 154           break;
 155
 156           case MUIA_NBitmap_Alpha:
 157             data->alpha = tag->ti_Data;
 158           break;
 159         }
 160       }
 161
 162       // load files
 163       switch(data->type)
 164       {
 165         case MUIV_NBitmap_Type_File:
 166         {
 167           for(i=0; i<3; i++)
 168           {
 169             if(data->data[i] != NULL)
 170               NBitmap_LoadImage((STRPTR)data->data[i], i, cl, obj);
 171           }
 172         }
 173         break;
 174
 175         case MUIV_NBitmap_Type_DTObject:
 176         {
 177           for(i=0; i<3; i++)
 178           {
 179             if(data->data[i] != NULL)
 180               data->dt_obj[i] = (Object *)data->data[i];
 181           }
 182         }
 183         break;
 184
 185         case MUIV_NBitmap_Type_CLUT8:
 186         case MUIV_NBitmap_Type_RGB24:
 187         case MUIV_NBitmap_Type_ARGB32:
 188         {
 189           // nothing to do here
 190         }
 191         break;
 192
 193         default:
 194         {
 195           // this is an invalid type
 196           typeOk = FALSE;
 197         }
 198         break;
 199       }
 200
 201       // setup images
 202       if(typeOk == TRUE && NBitmap_NewImage(cl, obj) == TRUE)
 203         return (IPTR)obj;
 204     }
 205   }
 206
 207   CoerceMethod(cl, obj, OM_DISPOSE);
 208   return (IPTR)NULL;;
 209 }
 210
 211 /* ULONG NBitmap_Get() */
 212 static ULONG NBitmap_Get(struct IClass *cl, Object *obj, struct opGet *msg)
 213 {
 214   ULONG result = FALSE;
 215   IPTR *store = msg->opg_Storage;
 216   struct InstData *data = INST_DATA(cl, obj);
 217
 218   ENTER();
 219
 220   switch (((struct opGet *)msg)->opg_AttrID)
 221   {
 222     case MUIA_NBitmap_Width:
 223       *store = (LONG) data->width;
 224       result = TRUE;
 225     break;
 226
 227     case MUIA_NBitmap_Height:
 228       *store = (LONG) data->height;
 229       result = TRUE;
 230     break;
 231
 232     case MUIA_NBitmap_MaxWidth:
 233       *store = (LONG) data->maxwidth;
 234       result = TRUE;
 235     break;
 236
 237     case MUIA_NBitmap_MaxHeight:
 238       *store = (LONG) data->maxheight;
 239       result = TRUE;
 240     break;
 241   }
 242
 243   if(result == FALSE)
 244     result = DoSuperMethodA(cl, obj, (Msg)msg);
 245
 246   RETURN(result);
 247   return result;
 248 }
 249
 250 /* ULONG NBitmap_Set() */
 251 static IPTR NBitmap_Set(struct IClass *cl,Object *obj, struct opSet *msg)
 252 {
 253   struct InstData *data = INST_DATA(cl, obj);
 254   struct TagItem *tags, *tag;
 255   IPTR result;
 256
 257   ENTER();
 258
 259   for(tags = msg->ops_AttrList; (tag = NextTagItem((APTR)&tags)) != NULL; )
 260   {
 261     switch(tag->ti_Tag)
 262     {
 263       case MUIA_NBitmap_Normal:
 264       {
 265         if(data->type == MUIV_NBitmap_Type_File)
 266         {
 267           data->data[0] = (uint32*)tag->ti_Data;
 268           NBitmap_UpdateImage(0, (STRPTR)data->data[0], cl, obj);
 269           MUI_Redraw(obj, MADF_DRAWOBJECT);
 270         }
 271
 272         tag->ti_Tag = TAG_IGNORE;
 273       }
 274       break;
 275
 276       case MUIA_NBitmap_Ghosted:
 277       {
 278         if(data->type == MUIV_NBitmap_Type_File)
 279         {
 280           data->data[1] = (uint32*)tag->ti_Data;
 281           NBitmap_UpdateImage(1, (STRPTR)data->data[1], cl, obj);
 282           MUI_Redraw(obj, MADF_DRAWOBJECT);
 283         }
 284
 285         tag->ti_Tag = TAG_IGNORE;
 286       }
 287       break;
 288
 289       case MUIA_NBitmap_Selected:
 290       {
 291         if(data->type == MUIV_NBitmap_Type_File)
 292         {
 293           data->data[2] = (uint32*)tag->ti_Data;
 294           NBitmap_UpdateImage(2, (STRPTR)data->data[2], cl, obj);
 295           MUI_Redraw(obj, MADF_DRAWOBJECT);
 296         }
 297
 298         tag->ti_Tag = TAG_IGNORE;
 299       }
 300       break;
 301
 302       case MUIA_NBitmap_MaxWidth:
 303         data->maxwidth = (uint32)tag->ti_Data;
 304         tag->ti_Tag = TAG_IGNORE;
 305       break;
 306
 307       case MUIA_NBitmap_MaxHeight:
 308         data->maxheight = (uint32)tag->ti_Data;
 309         tag->ti_Tag = TAG_IGNORE;
 310       break;
 311     }
 312   }
 313
 314   result = DoSuperMethodA(cl, obj, (Msg)msg);
 315
 316   RETURN(result);
 317   return result;
 318 }
 319
 320 /* ULONG NBitmap_Dispose() */
 321 static IPTR NBitmap_Dispose(struct IClass *cl, Object *obj, Msg msg)
 322 {
 323   IPTR result;
 324
 325   ENTER();
 326
 327   NBitmap_DisposeImage(cl, obj);
 328
 329   result = DoSuperMethodA(cl, obj, msg);
 330
 331   RETURN(result);
 332   return result;
 333 }
 334
 335 /* ULONG NBitmap_Setup() */
 336 static IPTR NBitmap_Setup(struct IClass *cl, Object *obj, Msg msg)
 337 {
 338   IPTR result;
 339
 340   ENTER();
 341
 342   if((result = DoSuperMethodA(cl, obj, msg)) != 0)
 343   {
 344     result = NBitmap_SetupImage(cl, obj);
 345   }
 346
 347   RETURN(result);
 348   return result;
 349 }
 350
 351 /* ULONG NBitmap_Cleanup() */
 352 static IPTR NBitmap_Cleanup(struct IClass *cl, Object *obj, Msg msg)
 353 {
 354   IPTR result;
 355
 356   ENTER();
 357
 358   NBitmap_CleanupImage(cl, obj);
 359
 360   result = DoSuperMethodA(cl, obj, msg);
 361
 362   RETURN(result);
 363   return(result);
 364 }
 365
 366 /* ULONG NBitmap_HandleEvent() */
 367 static IPTR NBitmap_HandleEvent(struct IClass *cl, Object *obj, struct MUIP_HandleEvent *msg)
 368 {
 369   struct InstData *data;
 370   IPTR result;
 371
 372   //ENTER();
 373
 374   result = 0;
 375
 376   if((data = INST_DATA(cl, obj)) != NULL)
 377   {
 378     if(msg->imsg != NULL)
 379     {
 380       switch(msg->imsg->Class)
 381       {
 382         case IDCMP_MOUSEBUTTONS:
 383         {
 384           if(_isinobject(msg->imsg->MouseX, msg->imsg->MouseY))
 385           {
 386             if(msg->imsg->Code == SELECTDOWN)
 387             {
 388               if(data->pressed == FALSE)
 389               {
 390                 data->pressed = TRUE;
 391
 392                 MUI_Redraw(obj, MADF_DRAWUPDATE);
 393                 SetAttrs(obj, MUIA_Pressed, TRUE, TAG_DONE);
 394               }
 395             }
 396             else if(msg->imsg->Code == SELECTUP)
 397             {
 398               if(data->overlay && data->pressed)
 399               {
 400                 data->pressed = FALSE;
 401                 data->overlay = FALSE;
 402
 403                 MUI_Redraw(obj, MADF_DRAWUPDATE);
 404                 SetAttrs(obj, MUIA_Pressed, FALSE, TAG_DONE);
 405               }
 406             }
 407
 408             result = MUI_EventHandlerRC_Eat;
 409           }
 410           else
 411           {
 412             if(msg->imsg->Code==SELECTUP)
 413             {
 414               data->pressed = FALSE;
 415             }
 416           }
 417         }
 418         break;
 419
 420         case IDCMP_MOUSEMOVE:
 421         {
 422           if(_isinobject(msg->imsg->MouseX, msg->imsg->MouseY))
 423           {
 424             if(data->overlay == FALSE)
 425             {
 426               data->overlay = TRUE;
 427
 428               MUI_Redraw(obj, MADF_DRAWUPDATE);
 429             }
 430
 431             //result = MUI_EventHandlerRC_Eat;
 432           }
 433           else
 434           {
 435             if(data->overlay)
 436             {
 437               data->overlay = FALSE;
 438
 439               MUI_Redraw(obj, MADF_DRAWUPDATE);
 440             }
 441           }
 442         }
 443         break;
 444       }
 445     }
 446   }
 447
 448   if(result == 0)
 449     result = DoSuperMethodA(cl, obj, (Msg)msg);
 450
 451   //RETURN(result);
 452   return result;
 453 }
 454
 455 /* ULONG  NBitmap_AskMinMax() */
 456 static IPTR NBitmap_AskMinMax(struct IClass *cl, Object *obj, struct MUIP_AskMinMax *msg)
 457 {
 458   struct InstData *data;
 459
 460   ENTER();
 461
 462   DoSuperMethodA(cl, obj, (Msg)msg);
 463
 464   if((data = INST_DATA(cl, obj)) != NULL)
 465   {
 466     uint32 oldBorderHoriz = data->border_horiz;
 467     uint32 oldBorderVert = data->border_vert;
 468
 469     // spacing
 470     data->border_horiz = 0;
 471     data->border_vert = 0;
 472
 473     if(data->button)
 474     {
 475       data->border_horiz += 4;
 476       data->border_horiz += data->prefs.spacing_horiz * 2;
 477
 478       data->border_vert += 4;
 479       data->border_vert += data->prefs.spacing_vert * 2;
 480     }
 481
 482     /* label */
 483     data->label_horiz = 0;
 484     data->label_vert = 0;
 485
 486     if(data->label != NULL && data->button != FALSE)
 487     {
 488       struct RastPort rp;
 489
 490       memcpy(&rp, &_screen(obj)->RastPort, sizeof(rp));
 491
 492       SetFont(&rp, _font(obj));
 493       TextExtent(&rp, (STRPTR)data->label, strlen(data->label), &data->labelte);
 494
 495       if(data->width < (uint32)data->labelte.te_Width)
 496         data->border_horiz += (data->labelte.te_Width - data->width);
 497
 498       data->label_vert = data->labelte.te_Height;
 499       data->border_vert += data->labelte.te_Height;
 500       data->border_vert += 2;
 501     }
 502
 503     // standard width & height
 504     msg->MinMaxInfo->MinWidth = data->width + data->border_horiz;
 505     msg->MinMaxInfo->DefWidth = data->width + data->border_horiz;
 506     msg->MinMaxInfo->MaxWidth = data->width + data->border_horiz;
 507
 508     msg->MinMaxInfo->MinHeight = data->height + data->border_vert;
 509     msg->MinMaxInfo->DefHeight = data->height + data->border_vert;
 510     msg->MinMaxInfo->MaxHeight = data->height + data->border_vert;
 511
 512     if(data->border_horiz != oldBorderHoriz || data->border_vert != oldBorderVert)
 513     {
 514       if(data->depth > 8) {
 515         // the border size has changed and we must recalculate the shade arrays
 516         NBitmap_CleanupShades(data);
 517         NBitmap_SetupShades(data);
 518       }
 519     }
 520   }
 521
 522   RETURN(0);
 523   return 0;
 524 }
 525
 526 /* ULONG NBitmap_Draw() */
 527 static IPTR NBitmap_Draw(struct IClass *cl, Object *obj, struct MUIP_Draw *msg)
 528 {
 529   IPTR result;
 530
 531   ENTER();
 532
 533   result = DoSuperMethodA(cl, obj, (Msg)msg);
 534
 535   if((msg->flags & MADF_DRAWUPDATE) || (msg->flags & MADF_DRAWOBJECT))
 536   {
 537     NBitmap_DrawImage(cl, obj);
 538   }
 539
 540   RETURN(result);
 541   return result;
 542 }
 543
 544 /* DISPATCHER() */
 545 DISPATCHER(_Dispatcher)
 546 {
 547   IPTR result;
 548
 549   //ENTER();
 550
 551   switch(msg->MethodID)
 552   {
 553     case OM_NEW:
 554       result = NBitmap_New(cl, obj, (struct opSet *)msg);
 555     break;
 556
 557     case OM_SET:
 558       result = NBitmap_Set(cl, obj, (struct opSet *)msg);
 559     break;
 560
 561     case OM_GET:
 562       result = NBitmap_Get(cl, obj, (struct opGet *)msg);
 563     break;
 564
 565     case OM_DISPOSE:
 566       result = NBitmap_Dispose(cl, obj, msg);
 567     break;
 568
 569     case MUIM_Setup:
 570       result = NBitmap_Setup(cl, obj, msg);
 571     break;
 572
 573     case MUIM_HandleEvent:
 574       result = NBitmap_HandleEvent(cl, obj, (struct MUIP_HandleEvent *)msg);
 575     break;
 576
 577     case MUIM_Cleanup:
 578       result = NBitmap_Cleanup(cl, obj, msg);
 579     break;
 580
 581     case MUIM_AskMinMax:
 582       result = NBitmap_AskMinMax(cl, obj, (struct MUIP_AskMinMax *)msg);
 583     break;
 584
 585     case MUIM_Draw:
 586       result = NBitmap_Draw(cl, obj, (struct MUIP_Draw *)msg);
 587     break;
 588
 589     default:
 590       result = DoSuperMethodA(cl, obj, msg);
 591     break;
 592   }
 593
 594   //RETURN(result);
 595   return result;
 596 }