mui/classes/thebar/mcp/backgroundadjust.c

   1 /***************************************************************************
   2
   3  TheBar.mcc - Next Generation Toolbar MUI Custom Class
   4  Copyright (C) 2003-2005 Alfonso Ranieri
   5  Copyright (C) 2005-2013 by TheBar.mcc 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  TheBar class Support Site:  http://www.sf.net/projects/thebar
  18
  19  $Id$
  20
  21 ***************************************************************************/
  22
  23 #include "class.h"
  24 #include <proto/datatypes.h>
  25 #include <datatypes/pictureclass.h>
  26 #include <libraries/asl.h>
  27
  28 /***********************************************************************/
  29
  30 static struct MUI_CustomClass *patterns = NULL;
  31 #define patternsObject NewObject(patterns->mcc_Class,NULL
  32
  33 static struct MUI_CustomClass *dtpic = NULL;
  34 #define dtpicObject NewObject(dtpic->mcc_Class,NULL
  35
  36 static struct MUI_CustomClass *bitmap = NULL;
  37 #define bitmapObject NewObject(bitmap->mcc_Class,NULL
  38
  39 static struct MUI_CustomClass *gradientfield;
  40 #define gradientfieldObject NewObject(gradientfield->mcc_Class,NULL
  41
  42 static struct MUI_CustomClass *gradient = NULL;
  43 #define gradientObject NewObject(gradient->mcc_Class,NULL
  44
  45 /***********************************************************************/
  46
  47 struct patternsData
  48 {
  49     Object                      *pop;
  50     Object                      *back;
  51     Object                      *patterns[16];
  52     char                        specs[18][16];
  53     LONG                        pattern;
  54     struct MUI_EventHandlerNode eh;
  55     ULONG                       secs;
  56     ULONG                       micros;
  57 };
  58
  59 /***********************************************************************/
  60
  61 static IPTR
  62 mPatternsNew(struct IClass *cl,Object *obj,struct opSet *msg)
  63 {
  64     Object *pgroup;
  65
  66     if((obj = (Object *)DoSuperNew(cl,obj,
  67             Child, owspace(1),
  68             Child, HGroup,
  69                 Child, owspace(1),
  70                 Child, (IPTR)(pgroup = (Object *)RowGroup(3), End),
  71                 Child, owspace(1),
  72             End,
  73             Child, owspace(1),
  74             TAG_MORE, msg->ops_AttrList)))
  75     {
  76         struct patternsData *data = INST_DATA(cl,obj);
  77         int                 i;
  78
  79         for (i = 0; i<18; i++)
  80         {
  81             snprintf(data->specs[i], sizeof(data->specs[i]), (STRPTR)"0:%d", (int)(i+MUII_BACKGROUND));
  82
  83             data->patterns[i] = (Object *)ImageObject,
  84                 ButtonFrame,
  85                 MUIA_Background,      MUII_ButtonBack,
  86                 MUIA_InputMode,       MUIV_InputMode_Immediate,
  87                 MUIA_InnerLeft,       4,
  88                 MUIA_InnerTop,        4,
  89                 MUIA_InnerRight,      4,
  90                 MUIA_InnerBottom,     4,
  91                 MUIA_FixWidth,        24,
  92                 MUIA_FixHeight,       24,
  93                 MUIA_Image_FreeHoriz, TRUE,
  94                 MUIA_Image_FreeVert,  TRUE,
  95                 MUIA_Image_Spec,      (IPTR)data->specs[i],
  96             End;
  97
  98             if (data->patterns[i])
  99             {
 100                 DoMethod(pgroup,OM_ADDMEMBER,data->patterns[i]);
 101                 DoMethod(data->patterns[i],MUIM_Notify,MUIA_Selected,TRUE,obj,2,MUIM_Popbackground_SelectPattern,i);
 102             }
 103             else
 104             {
 105                 CoerceMethod(cl->cl_Super,obj,OM_DISPOSE);
 106                 return 0;
 107             }
 108         }
 109
 110         data->pop  = (Object *)GetTagData(MUIA_Popbackground_PopObj, 0, msg->ops_AttrList);
 111         data->back = (Object *)GetTagData(MUIA_Popbackground_BackObj, 0, msg->ops_AttrList);
 112         data->pattern = -1;
 113     }
 114
 115     return (IPTR)obj;
 116 }
 117
 118 /***********************************************************************/
 119
 120 static IPTR
 121 mPatternsShow(struct IClass *cl,Object *obj,Msg msg)
 122 {
 123     struct patternsData *data = INST_DATA(cl,obj);
 124
 125     if (!DoSuperMethodA(cl,obj,msg)) return FALSE;
 126
 127     memset(&data->eh,0,sizeof(data->eh));
 128     data->eh.ehn_Class  = cl;
 129     data->eh.ehn_Object = obj;
 130     data->eh.ehn_Events = IDCMP_MOUSEBUTTONS|IDCMP_RAWKEY;
 131     data->eh.ehn_Flags  = MUI_EHF_ALWAYSKEYS;
 132     DoMethod(_win(obj),MUIM_Window_AddEventHandler,&data->eh);
 133
 134     return TRUE;
 135 }
 136
 137 /***********************************************************************/
 138
 139 static IPTR
 140 mPatternsHide(struct IClass *cl,Object *obj,Msg msg)
 141 {
 142     struct patternsData *data = INST_DATA(cl,obj);
 143
 144     DoMethod(_win(obj),MUIM_Window_RemEventHandler,&data->eh);
 145
 146     return DoSuperMethodA(cl,obj,msg);
 147 }
 148
 149 /***********************************************************************/
 150
 151 static IPTR
 152 mPatternsHandleEvent(struct IClass *cl,Object *obj,struct MUIP_HandleEvent *msg)
 153 {
 154     if (msg->imsg)
 155     {
 156         struct patternsData *data = INST_DATA(cl,obj);
 157         LONG                p = data->pattern;
 158
 159         if (msg->imsg->Class==IDCMP_MOUSEBUTTONS)
 160         {
 161             Object *o = data->patterns[p];
 162             UWORD  mx = msg->imsg->MouseX, my = msg->imsg->MouseY;
 163
 164             if ((p>=0) &&
 165                  msg->imsg->Qualifier==0xc000 &&
 166                 _left(o)<mx && _right(o)>mx && _top(o)<my && _bottom(o)>my &&
 167                 DoubleClick(data->secs,data->micros,msg->imsg->Seconds,msg->imsg->Micros))
 168                 {
 169                     DoMethod(_app(obj),MUIM_Application_PushMethod,data->pop,2,MUIM_Popbackground_Close,TRUE);
 170                 }
 171         }
 172         else
 173         {
 174             Object *o;
 175
 176             get(_win(obj),MUIA_Window_ActiveObject,&o);
 177             if (o) return DoSuperMethodA(cl,obj,(Msg)msg);
 178
 179             switch (msg->muikey)
 180             {
 181                 case MUIKEY_UP:
 182                     if (p<0) p = 0;
 183                     else if (p-6>=0) p -= 6;
 184                          else if (p==0) p = 17;
 185                               else p += 11;
 186                     break;
 187
 188                 case MUIKEY_DOWN:
 189                     if (p<0) p = 0;
 190                     else if (p+6<=17) p += 6;
 191                          else if (p==17) p = 0;
 192                               else p -= 11;
 193                     break;
 194
 195                 case MUIKEY_LEFT:
 196                     if (p<0) p = 0;
 197                     else if (p-1>=0) p -= 1;
 198                          else p = 17;
 199                     break;
 200
 201                 case MUIKEY_RIGHT:
 202                     if (p<0) p = 0;
 203                     else if (p+1<=17) p += 1;
 204                          else p = 0;
 205                     break;
 206
 207                 case MUIKEY_PRESS:
 208                     if (p>=0)
 209                     {
 210                         DoMethod(_app(obj),MUIM_Application_PushMethod,data->pop,2,MUIM_Popbackground_Close,TRUE);
 211                     }
 212                     break;
 213             }
 214
 215             if (p!=data->pattern)
 216             {
 217                 set(data->patterns[p],MUIA_Selected,TRUE);
 218             }
 219         }
 220
 221         data->secs   = msg->imsg->Seconds;
 222         data->micros = msg->imsg->Micros;
 223     }
 224
 225     return DoSuperMethodA(cl,obj,(Msg)msg);
 226 }
 227
 228 /***********************************************************************/
 229
 230 static IPTR
 231 mPatternsSetSpec(struct IClass *cl,Object *obj,struct MUIP_Popbackground_SetSpec *msg)
 232 {
 233     struct patternsData *data = INST_DATA(cl,obj);
 234     char                *spec = msg->spec;
 235     LONG        v;
 236
 237     if (!spec || (*spec++!='0') || (!*spec++==':') || !*spec) return MUIV_Popbackground_SetSpec_Fail;
 238
 239     v = atoi(spec)-MUII_BACKGROUND;
 240     if (v<0 || v>17) return FALSE;
 241
 242     set(data->patterns[v],MUIA_Selected,TRUE);
 243
 244     return MUIV_Popbackground_SetSpec_Spec;
 245 }
 246
 247 /***********************************************************************/
 248
 249 static IPTR
 250 mPatternsGetSpec(struct IClass *cl,Object *obj,struct MUIP_Popbackground_GetSpec *msg)
 251 {
 252     struct patternsData *data = INST_DATA(cl,obj);
 253
 254     if (data->pattern>=0)
 255     {
 256         sprintf(msg->spec, (STRPTR)"0:%ld", data->pattern+MUII_BACKGROUND);
 257         return MUIV_Popbackground_GetSpec_Spec;
 258     }
 259
 260     *msg->spec = 0;
 261     return MUIV_Popbackground_GetSpec_Fail;
 262 }
 263
 264 /***********************************************************************/
 265
 266 static IPTR
 267 mPatternsSelectPattern(struct IClass *cl,Object *obj,struct MUIP_Popbackground_SelectPattern *msg)
 268 {
 269     struct patternsData *data = INST_DATA(cl,obj);
 270     IPTR x;
 271
 272     if((data->pattern >= 0) && (data->pattern != (LONG)msg->id))
 273         set(data->patterns[data->pattern],MUIA_Selected,FALSE);
 274
 275     get(data->patterns[msg->id],MUIA_Selected,&x);
 276     if (!x) nnset(data->patterns[msg->id],MUIA_Selected,TRUE);
 277
 278     data->pattern = msg->id;
 279
 280     return 0;
 281 }
 282
 283 /***********************************************************************/
 284
 285 DISPATCHER(patternsDispatcher)
 286 {
 287   switch (msg->MethodID)
 288   {
 289     case OM_NEW:                           return mPatternsNew(cl,obj,(APTR)msg);
 290     case MUIM_Show:                        return mPatternsShow(cl,obj,(APTR)msg);
 291     case MUIM_Hide:                        return mPatternsHide(cl,obj,(APTR)msg);
 292     case MUIM_HandleEvent:                 return mPatternsHandleEvent(cl,obj,(APTR)msg);
 293     case MUIM_Popbackground_SetSpec:       return mPatternsSetSpec(cl,obj,(APTR)msg);
 294     case MUIM_Popbackground_GetSpec:       return mPatternsGetSpec(cl,obj,(APTR)msg);
 295     case MUIM_Popbackground_SelectPattern: return mPatternsSelectPattern(cl,obj,(APTR)msg);
 296     default:                               return DoSuperMethodA(cl,obj,msg);
 297   }
 298 }
 299
 300 /***********************************************************************/
 301
 302 static void
 303 freePatterns(void)
 304 {
 305     if (patterns)
 306     {
 307         MUI_DeleteCustomClass(patterns);
 308         patterns = NULL;
 309     }
 310 }
 311
 312 /***********************************************************************/
 313
 314 static ULONG
 315 initPatterns(void)
 316 {
 317   if((patterns = MUI_CreateCustomClass(NULL, MUIC_Group, NULL, sizeof(struct patternsData), ENTRY(patternsDispatcher))))
 318   {
 319     if(lib_flags & BASEFLG_MUI20)
 320       patterns->mcc_Class->cl_ID = (STRPTR)"Backgroundadjust_Patterns";
 321
 322     return TRUE;
 323   }
 324
 325   return FALSE;
 326 }
 327
 328 /***********************************************************************/
 329
 330 struct dtpicData
 331 {
 332     char                file[256];
 333     Object              *dto;
 334     struct BitMapHeader *bmhd;
 335     struct BitMap       *bitmap;
 336     APTR                plane;
 337     ULONG               flags;
 338 };
 339
 340 enum
 341 {
 342     FLG_Setup       = 1<<0,
 343 };
 344
 345 /***********************************************************************/
 346
 347 static void
 348 freeDTO(struct dtpicData *data)
 349 {
 350     data->bitmap = NULL;
 351     data->bmhd   = NULL;
 352
 353     if (data->dto)
 354     {
 355         DisposeDTObject(data->dto);
 356         data->dto = NULL;
 357     }
 358 }
 359
 360 /***********************************************************************/
 361
 362 static BOOL
 363 build(UNUSED struct IClass *cl,Object *obj,struct dtpicData *data)
 364 {
 365     freeDTO(data);
 366
 367     if ((data->flags & FLG_Setup) && *data->file)
 368     {
 369         struct Process *me = (struct Process *)FindTask(NULL);
 370         APTR           win = me->pr_WindowPtr;
 371         ULONG          cyber = CyberGfxBase && IsCyberModeID(GetVPModeID(&_screen(obj)->ViewPort));
 372
 373         me->pr_WindowPtr = (APTR)-1;
 374
 375         data->dto = NewDTObject(data->file,DTA_GroupID,                        GID_PICTURE,
 376                                            PDTA_Screen,                        _screen(obj),
 377                                            PDTA_FreeSourceBitMap,              TRUE,
 378                                            PDTA_UseFriendBitMap,               cyber,
 379                                            cyber ? PDTA_DestMode : TAG_IGNORE, PMODE_V43,
 380                                            TAG_DONE);
 381
 382         me->pr_WindowPtr = win;
 383
 384         if (data->dto)
 385         {
 386             struct FrameInfo fri;
 387
 388             memset(&fri, 0, sizeof(struct FrameInfo));
 389
 390             DoMethod(data->dto,DTM_FRAMEBOX,NULL,&fri,&fri,sizeof(struct FrameInfo),0);
 391
 392             if (fri.fri_Dimensions.Depth>0)
 393             {
 394                 if (DoMethod(data->dto,DTM_PROCLAYOUT,NULL,TRUE))
 395                 {
 396                     get(data->dto,PDTA_BitMapHeader,&data->bmhd);
 397
 398                     if (data->bmhd)
 399                     {
 400                         GetDTAttrs(data->dto,PDTA_DestBitMap,&data->bitmap,TAG_DONE);
 401                         if (!data->bitmap) GetDTAttrs(data->dto,PDTA_BitMap,&data->bitmap,TAG_DONE);
 402                         if (data->bitmap)
 403                         {
 404                             IPTR storage;
 405
 406                             GetDTAttrs(data->dto,PDTA_MaskPlane,&storage,TAG_DONE);
 407                             data->plane = (APTR)storage;
 408
 409                             return TRUE;
 410                         }
 411                     }
 412                 }
 413             }
 414         }
 415     }
 416
 417     freeDTO(data);
 418
 419     return FALSE;
 420 }
 421
 422 /***********************************************************************/
 423
 424 static IPTR
 425 mDTPicNew(struct IClass *cl,Object *obj,struct opSet *msg)
 426 {
 427     if((obj = (Object *)DoSuperMethodA(cl,obj,(Msg)msg)))
 428     {
 429         msg->MethodID = OM_SET;
 430         DoMethodA(obj,(Msg)msg);
 431         msg->MethodID = OM_NEW;
 432     }
 433
 434     return (IPTR)obj;
 435 }
 436
 437 /***********************************************************************/
 438
 439 static IPTR
 440 mDTPicDispose(struct IClass *cl,Object *obj,Msg msg)
 441 {
 442     struct dtpicData *data = INST_DATA(cl, obj);
 443
 444     if (data->dto) DisposeDTObject(data->dto);
 445
 446     return DoSuperMethodA(cl,obj,msg);
 447 }
 448
 449 /***********************************************************************/
 450
 451 static IPTR
 452 mDTPicSets(struct IClass *cl,Object *obj,struct opSet *msg)
 453 {
 454     struct dtpicData *data = INST_DATA(cl, obj);
 455     struct TagItem *tags;
 456     struct TagItem *tag;
 457     BOOL rebuild, redraw;
 458     IPTR  res;
 459
 460     rebuild = redraw = FALSE;
 461
 462     for(tags = msg->ops_AttrList; (tag = NextTagItem((APTR)&tags)); )
 463     {
 464         IPTR tidata = tag->ti_Data;
 465
 466         switch (tag->ti_Tag)
 467         {
 468             case MUIA_Popbackground_File:
 469             {
 470                 if(tidata)
 471                   strlcpy(data->file, (STRPTR)tidata, sizeof(data->file));
 472                 else
 473                   *data->file = '\0';
 474
 475                 rebuild = TRUE;
 476             }
 477             break;
 478         }
 479     }
 480
 481     res = DoSuperMethodA(cl,obj,(Msg)msg);
 482
 483     if (data->flags & FLG_Setup)
 484     {
 485         if (rebuild)
 486         {
 487             Object                 *parent;
 488             struct BitMap *bm = data->bitmap;
 489
 490             set(_app(obj),MUIA_Application_Sleep,TRUE);
 491
 492             if (bm)
 493             {
 494                 data->bitmap = NULL;
 495                 MUI_Redraw(obj,MADF_DRAWOBJECT);
 496                 data->bitmap = bm;
 497             }
 498
 499             superget(cl,obj,MUIA_Parent,&parent);
 500             if (parent) DoMethod(parent,MUIM_Group_InitChange);
 501
 502             build(cl,obj,data);
 503
 504             if (parent) DoMethod(parent,MUIM_Group_ExitChange);
 505
 506             MUI_Redraw(obj,MADF_DRAWOBJECT);
 507
 508             set(_app(obj),MUIA_Application_Sleep,FALSE);
 509         }
 510         else
 511             if (redraw) MUI_Redraw(obj,MADF_DRAWOBJECT);
 512     }
 513
 514     return res;
 515 }
 516
 517 /***************************************************************************/
 518
 519 static IPTR
 520 mDTPicSetup(struct IClass *cl,Object *obj,Msg msg)
 521 {
 522     struct dtpicData *data = INST_DATA(cl,obj);
 523
 524     if (!DoSuperMethodA(cl,obj,(Msg)msg)) return FALSE;
 525
 526     data->flags |= FLG_Setup;
 527     build(cl,obj,data);
 528
 529     return TRUE;
 530 }
 531
 532 /***********************************************************************/
 533
 534 static IPTR
 535 mDTPicCleanup(struct IClass *cl,Object *obj,Msg msg)
 536 {
 537     struct dtpicData *data = INST_DATA(cl,obj);
 538
 539     freeDTO(data);
 540     data->flags &= ~FLG_Setup;
 541
 542     return DoSuperMethodA(cl,obj,(Msg)msg);
 543 }
 544
 545 /***********************************************************************/
 546
 547 static IPTR
 548 mDTPicAskMinMax(struct IClass *cl,Object *obj,struct MUIP_AskMinMax *msg)
 549 {
 550     struct dtpicData    *data = INST_DATA(cl,obj);
 551     struct MUI_MinMax *mi;
 552
 553     DoSuperMethodA(cl,obj,(Msg)msg);
 554
 555     mi = msg->MinMaxInfo;
 556
 557     if (data->bitmap)
 558     {
 559         mi->MinWidth  += data->bmhd->bmh_Width;
 560         mi->MinHeight += data->bmhd->bmh_Height;
 561         mi->DefWidth  += data->bmhd->bmh_Width;
 562         mi->DefHeight += data->bmhd->bmh_Height;
 563     }
 564
 565     mi->MaxWidth  += MUI_MAXMAX;
 566     mi->MaxHeight += MUI_MAXMAX;
 567
 568     return 0;
 569 }
 570
 571 /***********************************************************************/
 572
 573 static IPTR
 574 mDTPicDraw(struct IClass *cl,Object *obj,struct MUIP_Draw *msg)
 575 {
 576     struct dtpicData *data = INST_DATA(cl,obj);
 577
 578     DoSuperMethodA(cl,obj,(Msg)msg);
 579
 580     if ((msg->flags & MADF_DRAWOBJECT) && data->bitmap)
 581     {
 582         WORD l, t, w, h, bw, bh;
 583
 584         w = _mwidth(obj);
 585         h = _mheight(obj);
 586         l = _mleft(obj);
 587         t = _mtop(obj);
 588
 589         bw = data->bmhd->bmh_Width;
 590         bh = data->bmhd->bmh_Height;
 591
 592         if (bw<w) w = bw;
 593         if (bh<h) h = bh;
 594
 595         BltBitMapRastPort(data->bitmap,0,0,_rp(obj),l,t,w,h,0xc0);
 596     }
 597
 598     return 0;
 599 }
 600
 601 /***********************************************************************/
 602
 603 DISPATCHER(dtpicDispatcher)
 604 {
 605   switch(msg->MethodID)
 606   {
 607     case OM_NEW:         return mDTPicNew(cl,obj,(APTR)msg);
 608     case OM_DISPOSE:     return mDTPicDispose(cl,obj,(APTR)msg);
 609     case OM_SET:         return mDTPicSets(cl,obj,(APTR)msg);
 610     case MUIM_Draw:      return mDTPicDraw(cl,obj,(APTR)msg);
 611     case MUIM_AskMinMax: return mDTPicAskMinMax(cl,obj,(APTR)msg);
 612     case MUIM_Setup:     return mDTPicSetup(cl,obj,(APTR)msg);
 613     case MUIM_Cleanup:   return mDTPicCleanup(cl,obj,(APTR)msg);
 614     default:             return DoSuperMethodA(cl,obj,msg);
 615   }
 616 }
 617
 618 /***********************************************************************/
 619
 620 static void
 621 freeDTPic(void)
 622 {
 623     if (dtpic)
 624     {
 625         MUI_DeleteCustomClass(dtpic);
 626         dtpic = NULL;
 627     }
 628
 629 }
 630
 631 /***********************************************************************/
 632
 633 static ULONG
 634 initDTPic(void)
 635 {
 636   if((dtpic = MUI_CreateCustomClass(NULL, MUIC_Area, NULL, sizeof(struct dtpicData), ENTRY(dtpicDispatcher))))
 637   {
 638     if(lib_flags & BASEFLG_MUI20)
 639       dtpic->mcc_Class->cl_ID = (STRPTR)"Backgroundadjust_dtpic";
 640
 641     return TRUE;
 642   }
 643
 644   return FALSE;
 645 }
 646
 647 /***********************************************************************/
 648
 649 struct bitmapData
 650 {
 651     Object *bitmap;
 652     Object *pic;
 653 };
 654
 655 /***********************************************************************/
 656
 657 static IPTR
 658 mBitmapNew(struct IClass *cl,Object *obj,struct opSet *msg)
 659 {
 660     Object *pic, *bitmap, *abt, *pbt;
 661
 662     if((obj = (Object *)DoSuperNew(cl,obj,
 663             Child, ScrollgroupObject,
 664                 MUIA_Scrollgroup_Contents, VirtgroupObject,
 665                     MUIA_Frame, MUIV_Frame_Virtual,
 666                     Child, (IPTR)(pic = (Object *)dtpicObject, End),
 667                 End,
 668             End,
 669             Child, HGroup,
 670                 MUIA_Group_HorizSpacing, 1,
 671                 Child, PopaslObject,
 672                     MUIA_Popstring_String, (IPTR)(bitmap = (Object *)StringObject,
 673                         MUIA_CycleChain,   TRUE,
 674                         StringFrame,
 675                         MUIA_String_MaxLen, 256,
 676                     End),
 677                     MUIA_Popstring_Button, (IPTR)(abt = PopButton(MUII_PopFile)),
 678                     MUIA_Popasl_Type,      ASL_FileRequest,
 679                 End,
 680                 Child, (IPTR)(pbt = PopButton(MUII_PopUp)),
 681             End,
 682             TAG_MORE, msg->ops_AttrList)))
 683     {
 684         struct bitmapData *data = INST_DATA(cl,obj);
 685
 686         data->pic    = pic;
 687         data->bitmap = bitmap;
 688
 689         DoSuperMethod(cl,obj,MUIM_MultiSet,MUIA_CycleChain,TRUE,abt,pbt,NULL);
 690         DoMethod(pbt,MUIM_Notify,MUIA_Pressed,FALSE,obj,1,MUIM_Popbackground_ShowBitmap);
 691     }
 692
 693     return (IPTR)obj;
 694 }
 695
 696 /***********************************************************************/
 697
 698 static IPTR
 699 mBitmapSetSpec(struct IClass *cl,Object *obj,struct MUIP_Popbackground_SetSpec *msg)
 700 {
 701     struct bitmapData *data = INST_DATA(cl,obj);
 702     char              *spec = msg->spec;
 703
 704     if (!spec || (*spec++!='5') || (!*spec++==':') || !*spec) return MUIV_Popbackground_SetSpec_Fail;
 705
 706     set(data->pic,MUIA_Popbackground_File,NULL);
 707     set(data->bitmap,MUIA_String_Contents,spec);
 708     return MUIV_Popbackground_SetSpec_Spec;
 709 }
 710
 711 /***********************************************************************/
 712
 713 static IPTR
 714 mBitmapGetSpec(struct IClass *cl,Object *obj,struct MUIP_Popbackground_GetSpec *msg)
 715 {
 716     struct bitmapData *data = INST_DATA(cl,obj);
 717     STRPTR                      x;
 718
 719     get(data->bitmap,MUIA_String_Contents,&x);
 720     sprintf(msg->spec,(STRPTR)"5:%s",x);
 721     return MUIV_Popbackground_GetSpec_Spec;
 722 }
 723
 724 /***********************************************************************/
 725
 726 static IPTR
 727 mBitmapShowBitmap(struct IClass *cl,Object *obj, UNUSED Msg msg)
 728 {
 729     struct bitmapData *data = INST_DATA(cl,obj);
 730     STRPTR                     x;
 731
 732     get(data->bitmap,MUIA_String_Contents,&x);
 733     set(data->pic,MUIA_Popbackground_File,x);
 734
 735     return 0;
 736 }
 737
 738 /***********************************************************************/
 739
 740 DISPATCHER(bitmapDispatcher)
 741 {
 742     switch (msg->MethodID)
 743     {
 744         case OM_NEW:                        return mBitmapNew(cl,obj,(APTR)msg);
 745         case MUIM_Popbackground_SetSpec:    return mBitmapSetSpec(cl,obj,(APTR)msg);
 746         case MUIM_Popbackground_GetSpec:    return mBitmapGetSpec(cl,obj,(APTR)msg);
 747         case MUIM_Popbackground_ShowBitmap: return mBitmapShowBitmap(cl,obj,(APTR)msg);
 748         default:                            return DoSuperMethodA(cl,obj,msg);
 749     }
 750 }
 751
 752 /***********************************************************************/
 753
 754 static void
 755 freeBitmap(void)
 756 {
 757     freeDTPic();
 758
 759     if (bitmap)
 760     {
 761         MUI_DeleteCustomClass(bitmap);
 762         bitmap = NULL;
 763     }
 764 }
 765
 766 /***********************************************************************/
 767
 768 static ULONG
 769 initBitmap(void)
 770 {
 771     if (initDTPic() &&
 772         (bitmap = MUI_CreateCustomClass(NULL,MUIC_Group,NULL,sizeof(struct bitmapData),ENTRY(bitmapDispatcher))))
 773     {
 774         if (lib_flags & BASEFLG_MUI20)
 775             bitmap->mcc_Class->cl_ID = (STRPTR)"Backgroundadjust_Bitmap";
 776
 777         return TRUE;
 778     }
 779
 780     freeBitmap();
 781
 782     return FALSE;
 783 }
 784
 785 /***********************************************************************/
 786
 787 struct gradientFieldData
 788 {
 789     struct MUIS_TheBar_Gradient grad;
 790     ULONG                       flags;
 791 };
 792
 793 enum
 794 {
 795     FLG_CyberDeep  = 1<<0,
 796 };
 797
 798 /***********************************************************************/
 799
 800 static IPTR
 801 mGradientFieldNew(struct IClass *cl,Object *obj,struct opSet *msg)
 802 {
 803     if((obj = (Object *)DoSuperNew(cl,obj,
 804             MUIA_InnerLeft,   2,
 805             MUIA_InnerTop,    2,
 806             MUIA_InnerRight,  2,
 807             MUIA_InnerBottom, 2,
 808             TAG_MORE,msg->ops_AttrList)))
 809     {
 810         struct gradientFieldData *data = INST_DATA(cl,obj);
 811
 812         if (GetTagData(MUIA_Popbackground_Horiz,TRUE,msg->ops_AttrList))
 813             data->grad.flags |= MUIV_TheBar_Gradient_Horiz;
 814
 815         data->grad.from = 0xffffff;
 816         data->grad.to   = 0xffffff;
 817     }
 818
 819     return (IPTR)obj;
 820 }
 821
 822 /***********************************************************************/
 823
 824 static IPTR
 825 mGradientFieldSets(struct IClass *cl,Object *obj,struct opSet *msg)
 826 {
 827     struct gradientFieldData *data = INST_DATA(cl,obj);
 828     struct TagItem *tag;
 829     struct TagItem *tstate;
 830     BOOL redraw = FALSE;
 831
 832     for(tstate = msg->ops_AttrList; (tag = NextTagItem((APTR)&tstate)); )
 833     {
 834         IPTR tidata = tag->ti_Data;
 835
 836         switch(tag->ti_Tag)
 837         {
 838             case MUIA_Popbackground_From:
 839                 if (data->grad.from!=tidata)
 840                 {
 841                     data->grad.from = tidata;
 842                     redraw = TRUE;
 843                 }
 844                 break;
 845
 846             case MUIA_Popbackground_To:
 847                 if (data->grad.to!=tidata)
 848                 {
 849                     data->grad.to = tidata;
 850                     redraw = TRUE;
 851                 }
 852                 break;
 853         }
 854     }
 855
 856     if (redraw) MUI_Redraw(obj,MADF_DRAWUPDATE);
 857
 858     return DoSuperMethodA(cl,obj,(Msg)msg);
 859 }
 860
 861 /***********************************************************************/
 862
 863 static IPTR
 864 mGradientFieldSetup(struct IClass *cl,Object *obj,Msg msg)
 865 {
 866     struct gradientFieldData *data = INST_DATA(cl,obj);
 867
 868     if (!DoSuperMethodA(cl,obj,(Msg)msg)) return FALSE;
 869
 870     if ((GetBitMapAttr(_screen(obj)->RastPort.BitMap,BMA_DEPTH)>8) &&
 871         CyberGfxBase && IsCyberModeID(GetVPModeID(&_screen(obj)->ViewPort)))
 872         data->flags |= FLG_CyberDeep;
 873     else data->flags &= ~FLG_CyberDeep;
 874
 875     return TRUE;
 876 }
 877
 878 /***********************************************************************/
 879
 880 static IPTR
 881 mGradientFieldDraw(struct IClass *cl,Object *obj,struct MUIP_Draw *msg)
 882 {
 883     struct gradientFieldData *data = INST_DATA(cl,obj);
 884
 885     DoSuperMethodA(cl,obj,(Msg)msg);
 886
 887     if ((data->flags & FLG_CyberDeep) && (msg->flags & (MADF_DRAWUPDATE|MADF_DRAWOBJECT)))
 888         drawGradient(obj,&data->grad);
 889
 890     return 0;
 891 }
 892
 893 /***********************************************************************/
 894
 895 DISPATCHER(gradientFieldDispatcher)
 896 {
 897   switch (msg->MethodID)
 898   {
 899     case OM_NEW:     return mGradientFieldNew(cl,obj,(APTR)msg);
 900     case OM_SET:     return mGradientFieldSets(cl,obj,(APTR)msg);
 901     case MUIM_Setup: return mGradientFieldSetup(cl,obj,(APTR)msg);
 902     case MUIM_Draw:  return mGradientFieldDraw(cl,obj,(APTR)msg);
 903     default:         return DoSuperMethodA(cl,obj,msg);
 904   }
 905 }
 906
 907 /***********************************************************************/
 908
 909 static void
 910 freeGradientfield(void)
 911 {
 912     if (gradientfield)
 913     {
 914         MUI_DeleteCustomClass(gradientfield);
 915         gradientfield = NULL;
 916     }
 917 }
 918
 919 /***********************************************************************/
 920
 921 static ULONG
 922 initGradientfield(void)
 923 {
 924   if((gradientfield = MUI_CreateCustomClass(NULL, MUIC_Rectangle, NULL, sizeof(struct gradientFieldData), ENTRY(gradientFieldDispatcher))))
 925   {
 926     if(lib_flags & BASEFLG_MUI20)
 927       gradientfield->mcc_Class->cl_ID = (STRPTR)"Gradientfield";
 928
 929     return TRUE;
 930   }
 931
 932   return FALSE;
 933 }
 934
 935 /***********************************************************************/
 936
 937 struct gradientData
 938 {
 939     Object *from;
 940     Object *to;
 941     Object *hgrad;
 942     Object *vgrad;
 943 };
 944
 945 /***********************************************************************/
 946
 947 static IPTR
 948 mGradientNew(struct IClass *cl,Object *obj,struct opSet *msg)
 949 {
 950     Object *vgrad, *hgrad, *from, *to, *swap;
 951
 952     if((obj = (Object *)DoSuperNew(cl,obj,
 953             MUIA_Group_Horiz, TRUE,
 954
 955             Child, vgrad = (Object *)gradientfieldObject,
 956                 MUIA_ShortHelp,           (IPTR)tr(Msg_Popback_VertGradientHelp),
 957                 ButtonFrame,
 958                 MUIA_Background,          MUII_ButtonBack,
 959                 MUIA_InputMode,           MUIV_InputMode_Immediate,
 960                 MUIA_FixWidth,            24,
 961                 MUIA_Popbackground_Horiz, FALSE,
 962             End,
 963
 964             Child, VGroup,
 965                 Child, hgrad = (Object *)gradientfieldObject,
 966                     MUIA_ShortHelp,  (IPTR)tr(Msg_Popback_HorizGradientHelp),
 967                     ButtonFrame,
 968                     MUIA_Background, MUII_ButtonBack,
 969                     MUIA_InputMode,  MUIV_InputMode_Immediate,
 970                     MUIA_FixHeight,  24,
 971                     MUIA_Selected,   TRUE,
 972                 End,
 973
 974                 Child, HGroup,
 975                     Child, from = coloradjustObject, MUIA_Coloradj_Colorfield, NULL, End,
 976                     Child, RectangleObject, MUIA_Weight, 0, MUIA_Rectangle_VBar, TRUE, End,
 977                     Child, to = coloradjustObject, MUIA_Coloradj_Colorfield, NULL, End,
 978                 End,
 979
 980                 Child, HGroup,
 981                     Child, HSpace(0),
 982                     Child, oclabel(Msg_Popback_From),
 983                     Child, HSpace(0),
 984                     Child, swap = obutton(Msg_Popback_Swap,Msg_Popback_SwapHelp),
 985                     Child, HSpace(0),
 986                     Child, oclabel(Msg_Popback_To),
 987                     Child, HSpace(0),
 988                 End,
 989             End,
 990             TAG_MORE, msg->ops_AttrList)))
 991     {
 992         struct gradientData *data = INST_DATA(cl,obj);
 993
 994         data->from  = from;
 995         data->to    = to;
 996         data->hgrad = hgrad;
 997         data->vgrad = vgrad;
 998
 999         set(swap,MUIA_Weight,20);
1000         DoMethod(swap,MUIM_Notify,MUIA_Pressed,FALSE,obj,1,MUIM_Popbackground_Swap);
1001         DoMethod(from,MUIM_Notify,MUIA_Coloradjust_RGB,MUIV_EveryTime,obj,2,MUIM_Popbackground_GradientCol,TRUE);
1002         DoMethod(to,MUIM_Notify,MUIA_Coloradjust_RGB,MUIV_EveryTime,obj,2,MUIM_Popbackground_GradientCol,FALSE);
1003
1004         DoMethod(hgrad,MUIM_Notify,MUIA_Selected,TRUE,vgrad,3,MUIM_Set,MUIA_Selected,FALSE);
1005         DoMethod(vgrad,MUIM_Notify,MUIA_Selected,TRUE,hgrad,3,MUIM_Set,MUIA_Selected,FALSE);
1006     }
1007
1008     return (IPTR)obj;
1009 }
1010
1011 /***********************************************************************/
1012
1013 static IPTR
1014 mGradientSetSpec(struct IClass *cl,Object *obj,struct MUIP_Popbackground_SetSpec *msg)
1015 {
1016     struct gradientData *data = INST_DATA(cl,obj);
1017     struct MUIS_TheBar_Gradient  *grad = msg->grad;
1018     struct MUI_RGBcolor          rgb1, rgb2;
1019                         ULONG x;
1020
1021     if (!grad) return MUIV_Popbackground_SetSpec_Fail;
1022
1023     x = grad->from>>16;
1024     rgb1.red = (x<<24)|(x<<16)|(x<<8)|x;
1025     x = (grad->from>>8) & 0xff;
1026     rgb1.green = (x<<24)|(x<<16)|(x<<8)|x;
1027     x = grad->from & 0xff;
1028     rgb1.blue = (x<<24)|(x<<16)|(x<<8)|x;
1029
1030     x = grad->to>>16;
1031     rgb2.red = (x<<24)|(x<<16)|(x<<8)|x;
1032     x = (grad->to>>8) & 0xff;
1033     rgb2.green = (x<<24)|(x<<16)|(x<<8)|x;
1034     x = grad->to & 0xff;
1035     rgb2.blue = (x<<24)|(x<<16)|(x<<8)|x;
1036
1037     set(data->from,MUIA_Coloradjust_RGB,&rgb1);
1038     set(data->to,MUIA_Coloradjust_RGB,&rgb2);
1039
1040     if (grad->flags & MUIV_TheBar_Gradient_Horiz) set(data->hgrad,MUIA_Selected,TRUE);
1041     else set(data->vgrad,MUIA_Selected,TRUE);
1042
1043     return MUIV_Popbackground_SetSpec_Grad;
1044 }
1045
1046 /***********************************************************************/
1047
1048 static IPTR
1049 mGradientGetSpec(struct IClass *cl,Object *obj,struct MUIP_Popbackground_GetSpec *msg)
1050 {
1051     struct gradientData *data = INST_DATA(cl,obj);
1052     struct MUIS_TheBar_Gradient  *grad = msg->grad;
1053     struct MUI_RGBcolor          *rgb1, *rgb2;
1054     IPTR                          x;
1055
1056     get(data->from,MUIA_Coloradjust_RGB,&rgb1);
1057     get(data->to,MUIA_Coloradjust_RGB,&rgb2);
1058
1059     grad->from = ((rgb1->red>>24)<<16)|((rgb1->green>>24)<<8)|(rgb1->blue>>24);
1060     grad->to   = ((rgb2->red>>24)<<16)|((rgb2->green>>24)<<8)|(rgb2->blue>>24);
1061
1062     get(data->hgrad,MUIA_Selected,&x);
1063     if (x) grad->flags |= MUIV_TheBar_Gradient_Horiz;
1064     else grad->flags &= ~MUIV_TheBar_Gradient_Horiz;
1065
1066     return MUIV_Popbackground_GetSpec_Grad;
1067 }
1068
1069 /***********************************************************************/
1070
1071 static IPTR
1072 mGradientGradientCol(struct IClass *cl,Object *obj,struct MUIP_Popbackground_GradientCol *msg)
1073 {
1074     struct gradientData *data = INST_DATA(cl,obj);
1075     struct MUI_RGBcolor          *rgb;
1076     Object              *c;
1077     Tag                 tag;
1078     ULONG               col;
1079
1080     if (msg->from)
1081     {
1082         c   = data->from;
1083         tag = MUIA_Popbackground_From;
1084     }
1085     else
1086     {
1087         c   = data->to;
1088         tag = MUIA_Popbackground_To;
1089     }
1090
1091     get(c,MUIA_Coloradjust_RGB,&rgb);
1092     col = ((rgb->red>>24)<<16)|((rgb->green>>24)<<8)|(rgb->blue>>24);
1093
1094     set(data->hgrad,tag,col);
1095     set(data->vgrad,tag,col);
1096
1097     return 0;
1098 }
1099
1100 /***********************************************************************/
1101
1102 static IPTR
1103 mGradientSwap(struct IClass *cl,Object *obj, UNUSED Msg msg)
1104 {
1105     struct gradientData *data = INST_DATA(cl,obj);
1106     struct MUI_RGBcolor          *rgb1, *rgb2, rgb;
1107
1108     get(data->from,MUIA_Coloradjust_RGB,&rgb1);
1109     get(data->to,MUIA_Coloradjust_RGB,&rgb2);
1110
1111     memcpy(&rgb,rgb1,sizeof(rgb));
1112
1113     set(data->from,MUIA_Coloradjust_RGB,rgb2);
1114     set(data->to,MUIA_Coloradjust_RGB,&rgb);
1115
1116     return 0;
1117 }
1118
1119 /***********************************************************************/
1120
1121 DISPATCHER(gradientDispatcher)
1122 {
1123   switch (msg->MethodID)
1124   {
1125     case OM_NEW:                         return mGradientNew(cl,obj,(APTR)msg);
1126     case MUIM_Popbackground_GradientCol: return mGradientGradientCol(cl,obj,(APTR)msg);
1127     case MUIM_Popbackground_Swap:        return mGradientSwap(cl,obj,(APTR)msg);
1128     case MUIM_Popbackground_SetSpec:     return mGradientSetSpec(cl,obj,(APTR)msg);
1129     case MUIM_Popbackground_GetSpec:     return mGradientGetSpec(cl,obj,(APTR)msg);
1130     default:                             return DoSuperMethodA(cl,obj,msg);
1131   }
1132 }
1133
1134 /***********************************************************************/
1135
1136 static void
1137 freeGradient(void)
1138 {
1139     freeGradientfield();
1140
1141     if (gradient)
1142     {
1143         MUI_DeleteCustomClass(gradient);
1144         gradient = NULL;
1145     }
1146 }
1147
1148 /***********************************************************************/
1149
1150 static ULONG
1151 initGradient(void)
1152 {
1153     if (initGradientfield() &&
1154         (gradient = MUI_CreateCustomClass(NULL,MUIC_Group,NULL,sizeof(struct gradientData), ENTRY(gradientDispatcher))))
1155     {
1156         if (lib_flags & BASEFLG_MUI20)
1157             gradient->mcc_Class->cl_ID = (STRPTR)"Gradient";
1158
1159         return TRUE;
1160     }
1161
1162     freeGradient();
1163
1164     return FALSE;
1165 }
1166
1167 /***********************************************************************/
1168
1169 enum
1170 {
1171     PAGE_Pattern,
1172     PAGE_Color,
1173     PAGE_Bitmap,
1174     PAGE_Gradient,
1175 };
1176
1177 /***********************************************************************/
1178
1179 struct backData
1180 {
1181     Object                      *pages[8];
1182     ULONG                       page;
1183     char                        spec[POPBACKGROUNDSPECSIZE];
1184     struct MUIS_TheBar_Gradient grad;
1185     ULONG                       flags;
1186 };
1187
1188 enum
1189 {
1190     FLG_Gradient     = 1<<0,
1191     FLG_GradientMode = 1<<1,
1192 };
1193
1194 /***********************************************************************/
1195
1196 static IPTR
1197 mBackNew(struct IClass *cl,Object *obj,struct opSet *msg)
1198 {
1199     struct backData *data;
1200     Object          *pop;
1201     const char **t;
1202     ULONG           useGradient;
1203
1204     if (GetTagData(MUIA_Popbackground_Gradient,FALSE,msg->ops_AttrList))
1205     {
1206       static const char *titles[5];
1207
1208       titles[0] = tr(Msg_Popback_Pattern);
1209       titles[1] = tr(Msg_Popback_Color);
1210       titles[2] = tr(Msg_Popback_Bitmap);
1211       titles[3] = tr(Msg_Popback_Gradient);
1212       titles[4] = NULL;
1213
1214       useGradient = TRUE;
1215       t = titles;
1216     }
1217     else
1218     {
1219       static const char *ngtitles[4];
1220
1221       ngtitles[0] = tr(Msg_Popback_Pattern);
1222       ngtitles[1] = tr(Msg_Popback_Color);
1223       ngtitles[2] = tr(Msg_Popback_Bitmap);
1224       ngtitles[3] = NULL;
1225
1226       useGradient = FALSE;
1227       t = ngtitles;
1228     }
1229
1230     if (!(obj = (Object *)DoSuperNew(cl,obj,MUIA_Register_Titles,t,MUIA_CycleChain,TRUE,TAG_MORE,msg->ops_AttrList)))
1231         return 0;
1232
1233     data = INST_DATA(cl,obj);
1234
1235     pop = (Object *)GetTagData(MUIA_Popbackground_PopObj, (IPTR)NULL, msg->ops_AttrList);
1236
1237     if (!(data->pages[0] = patternsObject, MUIA_Popbackground_PopObj, pop, MUIA_Popbackground_BackObj, obj, End))
1238     {
1239         CoerceMethod(cl->cl_Super,obj,OM_DISPOSE);
1240         return 0;
1241     }
1242     DoMethod(obj,OM_ADDMEMBER,data->pages[0]);
1243
1244     if (!(data->pages[1] = penadjustObject, MUIA_Popbackground_PopObj, pop, MUIA_Popbackground_BackObj, obj, End))
1245     {
1246         CoerceMethod(cl->cl_Super,obj,OM_DISPOSE);
1247         return 0;
1248     }
1249     DoMethod(obj,OM_ADDMEMBER,data->pages[1]);
1250
1251     if (!(data->pages[2] = bitmapObject, MUIA_Popbackground_PopObj, pop, MUIA_Popbackground_BackObj, obj, End))
1252     {
1253         CoerceMethod(cl->cl_Super,obj,OM_DISPOSE);
1254         return 0;
1255     }
1256     DoMethod(obj,OM_ADDMEMBER,data->pages[2]);
1257
1258     if (useGradient)
1259     {
1260         if (!(data->pages[3] = gradientObject, MUIA_Popbackground_PopObj, pop, MUIA_Popbackground_BackObj, obj, End))
1261         {
1262             CoerceMethod(cl->cl_Super,obj,OM_DISPOSE);
1263             return 0;
1264         }
1265         DoMethod(obj,OM_ADDMEMBER,data->pages[3]);
1266
1267         data->flags |= FLG_Gradient;
1268     }
1269
1270     data->page = 0;
1271
1272     msg->MethodID = OM_SET;
1273     DoMethodA(obj,(Msg)msg);
1274     msg->MethodID = OM_NEW;
1275
1276     return (IPTR)obj;
1277 }
1278
1279 /***********************************************************************/
1280
1281 static ULONG
1282 specToGadgets(struct IClass *cl,Object *obj,STRPTR spec,struct MUIS_TheBar_Gradient *grad)
1283 {
1284     struct backData *data = INST_DATA(cl,obj);
1285     int i;
1286
1287     for (i = 0; data->pages[i]; i++)
1288     {
1289         switch(DoMethod(data->pages[i],MUIM_Popbackground_SetSpec,spec,grad,MUIV_Popbackground_SetSpec_Image))
1290         {
1291             case MUIV_Popbackground_SetSpec_Fail:
1292                 continue;
1293
1294             case MUIV_Popbackground_SetSpec_Spec:
1295             {
1296                 strlcpy(data->spec, spec, sizeof(data->spec));
1297                 set(obj,MUIA_Group_ActivePage,i);
1298                 data->flags &= ~FLG_GradientMode;
1299
1300                 return TRUE;
1301             }
1302
1303             case MUIV_Popbackground_SetSpec_Grad:
1304             {
1305                 memcpy(&data->grad,grad,sizeof(data->grad));
1306                 set(obj,MUIA_Group_ActivePage,i);
1307                 data->flags |= FLG_GradientMode;
1308
1309                 return TRUE;
1310             }
1311         }
1312     }
1313
1314     return FALSE;
1315 }
1316
1317 /***********************************************************************/
1318
1319 static void
1320 gadgetsToSpec(struct backData *data)
1321 {
1322     switch(DoMethod(data->pages[data->page],MUIM_Popbackground_GetSpec,&data->spec,&data->grad,MUIV_Popbackground_GetSpec_Image))
1323     {
1324         case MUIV_Popbackground_GetSpec_Fail:
1325             data->flags &= ~FLG_GradientMode;
1326             break;
1327
1328         case MUIV_Popbackground_GetSpec_Spec:
1329             data->flags &= ~FLG_GradientMode;
1330             break;
1331
1332         case MUIV_Popbackground_GetSpec_Grad:
1333             data->flags |= FLG_GradientMode;
1334             break;
1335     }
1336 }
1337
1338 /***********************************************************************/
1339
1340 static IPTR
1341 mBackGet(struct IClass *cl,Object *obj,struct opGet *msg)
1342 {
1343     struct backData *data = INST_DATA(cl,obj);
1344
1345     switch (msg->opg_AttrID)
1346     {
1347         case MUIA_Imagedisplay_Spec:
1348             gadgetsToSpec(data);
1349             if (data->flags & FLG_GradientMode) return FALSE;
1350             *msg->opg_Storage = (IPTR)data->spec;
1351             return TRUE;
1352
1353         case MUIA_Popbackground_Grad:
1354             gadgetsToSpec(data);
1355             if (!(data->flags & FLG_GradientMode)) return FALSE;
1356             *msg->opg_Storage = (IPTR)&data->grad;
1357             return TRUE;
1358
1359         default:
1360             return DoSuperMethodA(cl,obj,(Msg)msg);
1361     }
1362 }
1363
1364 /***********************************************************************/
1365
1366 static IPTR
1367 mBackSets(struct IClass *cl,Object *obj,struct opSet *msg)
1368 {
1369     struct backData *data = INST_DATA(cl,obj);
1370     struct TagItem *tag;
1371     struct TagItem *tstate;
1372
1373     for(tstate = msg->ops_AttrList; (tag = NextTagItem((APTR)&tstate)); )
1374     {
1375         IPTR tidata = tag->ti_Data;
1376
1377         switch(tag->ti_Tag)
1378         {
1379             case MUIA_Group_ActivePage:
1380                 data->page = tidata;
1381                 break;
1382
1383             case MUIA_Imagedisplay_Spec:
1384                 specToGadgets(cl,obj,(STRPTR)tidata,NULL);
1385                 break;
1386
1387             case MUIA_Popbackground_Grad:
1388                 specToGadgets(cl,obj,NULL,(struct MUIS_TheBar_Gradient *)tidata);
1389                 break;
1390         }
1391     }
1392
1393     return DoSuperMethodA(cl,obj,(Msg)msg);
1394 }
1395
1396 /***********************************************************************/
1397
1398 static IPTR
1399 mBackDragQuery(UNUSED struct IClass *cl,Object *obj,struct MUIP_DragQuery *msg)
1400 {
1401     STRPTR x;
1402
1403     if (obj==msg->obj) return MUIV_DragQuery_Refuse;
1404
1405     if (((get(msg->obj,MUIA_Imagedisplay_Spec,&x) || get(msg->obj,MUIA_Pendisplay_Spec,&x)) && x && *x) ||
1406         get(msg->obj,MUIA_Popbackground_Grad,&x))
1407         return MUIV_DragQuery_Accept;
1408
1409     return MUIV_DragQuery_Refuse;
1410 }
1411
1412 /***********************************************************************/
1413
1414 static IPTR
1415 mBackDragDrop(struct IClass *cl,Object *obj,struct MUIP_DragDrop *msg)
1416 {
1417     struct backData *data = INST_DATA(cl,obj);
1418     IPTR x = 0;
1419
1420     if ((data->flags & FLG_Gradient) && get(msg->obj,MUIA_Popbackground_Grad,&x))
1421         set(obj,MUIA_Popbackground_Grad,x);
1422     else
1423         if (get(msg->obj,MUIA_Imagedisplay_Spec,&x)) set(obj,MUIA_Imagedisplay_Spec,x);
1424         else
1425             if (get(msg->obj,MUIA_Pendisplay_Spec,&x))
1426             {
1427                 char buf[32];
1428
1429                 snprintf(buf,sizeof(buf),(STRPTR)"2:%s",(char *)x);
1430                 set(obj,MUIA_Imagedisplay_Spec,buf);
1431             }
1432
1433     return 0;
1434 }
1435
1436 /***********************************************************************/
1437
1438 DISPATCHER(backDispatcher)
1439 {
1440     switch (msg->MethodID)
1441     {
1442         case OM_NEW:         return mBackNew(cl,obj,(APTR)msg);
1443         case OM_GET:         return mBackGet(cl,obj,(APTR)msg);
1444         case OM_SET:         return mBackSets(cl,obj,(APTR)msg);
1445         case MUIM_DragQuery: return mBackDragQuery(cl,obj,(APTR)msg);
1446         case MUIM_DragDrop:  return mBackDragDrop(cl,obj,(APTR)msg);
1447         default:             return DoSuperMethodA(cl,obj,msg);
1448     }
1449 }
1450
1451 /***********************************************************************/
1452
1453 void
1454 freeBackgroundadjust(void)
1455 {
1456     freePatterns();
1457     freeBitmap();
1458     freeGradient();
1459
1460     if (lib_backgroundadjust)
1461     {
1462         MUI_DeleteCustomClass(lib_backgroundadjust);
1463         lib_backgroundadjust = NULL;
1464     }
1465 }
1466
1467 /***********************************************************************/
1468
1469 ULONG
1470 initBackgroundadjust(void)
1471 {
1472     if (initPatterns() &&
1473         initBitmap() &&
1474         initGradient() &&
1475         (lib_backgroundadjust = MUI_CreateCustomClass(NULL,MUIC_Register,NULL,sizeof(struct backData),ENTRY(backDispatcher))))
1476     {
1477         if (lib_flags & BASEFLG_MUI20)
1478             lib_backgroundadjust->mcc_Class->cl_ID = (STRPTR)"Backgroundadjust";
1479
1480         return TRUE;
1481     }
1482
1483     freeBackgroundadjust();
1484
1485     return FALSE;
1486 }
1487
1488 /***********************************************************************/