workbench/libs/gadtools/cycleclass.c

   1 /*
   2     Copyright © 1995-2005, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Internal GadTools cycle class.
   6     Lang: English
   7 */
   8
   9
  10 #include <proto/exec.h>
  11 #include <exec/libraries.h>
  12 #include <exec/memory.h>
  13 #include <proto/dos.h>
  14 #include <intuition/classes.h>
  15 #include <intuition/classusr.h>
  16 #include <intuition/gadgetclass.h>
  17 #include <intuition/imageclass.h>
  18 #include <intuition/intuition.h>
  19 #include <intuition/cghooks.h>
  20 #include <graphics/rastport.h>
  21 #include <graphics/text.h>
  22 #include <utility/tagitem.h>
  23 #include <devices/inputevent.h>
  24 #include <proto/alib.h>
  25 #include <proto/utility.h>
  26
  27 #include <string.h> /* memset() */
  28
  29 #define SDEBUG 0
  30 #define DEBUG 0
  31 #include <aros/debug.h>
  32
  33 #include "gadtools_intern.h"
  34
  35 /**********************************************************************************************/
  36
  37 #define CYCLEIMAGEWIDTH     19
  38
  39 #define GadToolsBase        ((struct GadToolsBase_intern *)cl->cl_UserData)
  40
  41 /**********************************************************************************************/
  42
  43 STATIC VOID rendercyclelabel(Class *cl, struct Gadget *gad, STRPTR string,
  44                              struct RastPort *rp, struct GadgetInfo *ginfo)
  45 {
  46     UWORD   *pens = ginfo->gi_DrInfo->dri_Pens;
  47     WORD    x,y,h;
  48     int     len = strlen(string);
  49
  50     SetABPenDrMd(rp, pens[TEXTPEN], pens[BACKGROUNDPEN], JAM1);
  51     Move(rp,
  52          gad->LeftEdge + (gad->Width - CYCLEIMAGEWIDTH - TextLength(rp, string, len)) / 2,
  53          gad->TopEdge + (gad->Height - rp->Font->tf_YSize) / 2 + rp->Font->tf_Baseline);
  54     Text(rp, string, len);
  55
  56     x = gad->LeftEdge + gad->Width - CYCLEIMAGEWIDTH;
  57
  58     /* separator bar */
  59
  60     SetAPen(rp, pens[SHINEPEN]);
  61     RectFill(rp, x + 1, gad->TopEdge + 2, x + 1, gad->TopEdge + gad->Height - 1 - 2);
  62     SetAPen(rp, pens[SHADOWPEN]);
  63     RectFill(rp, x, gad->TopEdge + 2, x, gad->TopEdge + gad->Height - 1 - 2);
  64
  65     /* cycle image */
  66
  67     h = gad->Height / 2;
  68
  69     x += 6;
  70
  71     for(y = 0; y < 4; y++)
  72     {
  73         RectFill(rp,x + y,
  74                        gad->TopEdge + gad->Height - 1 - h - y - 1,
  75                        x + 6 - y,
  76                        gad->TopEdge + gad->Height - 1 - h - y - 1);
  77
  78         RectFill(rp,x + y,
  79                        gad->TopEdge + h + y + 1,
  80                        x + 6 - y,
  81                        gad->TopEdge + h + y + 1);
  82     }
  83 }
  84
  85 /**********************************************************************************************/
  86
  87 BOOL pointingadget(struct Gadget *gad, struct GadgetInfo *gi, WORD x, WORD y)
  88 {
  89     WORD gadw, gadh;
  90
  91     gadw = gad->Width;
  92     if (gad->Flags & GFLG_RELWIDTH) gadw += gi->gi_Domain.Width;
  93
  94     gadh = gad->Height;
  95     if (gad->Flags & GFLG_RELHEIGHT) gadh += gi->gi_Domain.Height;
  96
  97     return ((x >= 0) && (y >= 0) && (x < gadw) && (y < gadh)) ? TRUE : FALSE;
  98 }
  99
 100 /**********************************************************************************************/
 101
 102 IPTR GTCycle__OM_NEW(Class *cl, Object *objcl, struct opSet *msg)
 103 {
 104     struct CycleData    *data;
 105     struct TextAttr     *tattr;
 106     struct TagItem      imgtags[] =
 107     {
 108         { IA_Width      , 0             },
 109         { IA_Height     , 0             },
 110         { IA_EdgesOnly  , FALSE         },
 111         { IA_FrameType  , FRAME_BUTTON  },
 112         { TAG_DONE      , 0UL           }
 113     };
 114     STRPTR              *labels;
 115     struct Gadget       *g;
 116
 117     g = (struct Gadget *)DoSuperMethodA(cl, objcl, (Msg)msg);
 118     if (!g)
 119         return (IPTR)NULL;
 120
 121     data = INST_DATA(cl, g);
 122
 123     data->active     = GetTagData(GTCY_Active, 0, msg->ops_AttrList);
 124     data->labels     = (STRPTR *)GetTagData(GTCY_Labels, (IPTR)NULL, msg->ops_AttrList);
 125     data->labelplace = GetTagData(GA_LabelPlace, GV_LabelPlace_Left, msg->ops_AttrList);
 126
 127     data->numlabels = 0;
 128
 129     labels = data->labels;
 130     if (labels)
 131     {
 132         while (labels[0])
 133         {
 134             data->numlabels++;
 135             labels++;
 136         }
 137     }
 138
 139     tattr = (struct TextAttr *)GetTagData(GA_TextAttr, (IPTR)NULL, msg->ops_AttrList);
 140     if (tattr) data->font = OpenFont(tattr);
 141
 142     imgtags[0].ti_Data = (IPTR)g->Width;
 143     imgtags[1].ti_Data = (IPTR)g->Height;
 144
 145     g->GadgetRender = NewObjectA(NULL, FRAMEICLASS, imgtags);
 146     if (!(g->GadgetRender))
 147     {
 148         CoerceMethod(cl, (Object *)g, OM_DISPOSE);
 149         g = NULL;
 150     }
 151
 152     return (IPTR)g;
 153 }
 154
 155 /**********************************************************************************************/
 156
 157 IPTR GTCycle__OM_DISPOSE(Class *cl, struct Gadget * g, Msg msg)
 158 {
 159     struct CycleData *data = INST_DATA(cl, g);
 160
 161     if (g->GadgetRender)
 162         DisposeObject(g->GadgetRender);
 163
 164     if (data->font) CloseFont(data->font);
 165
 166     return DoSuperMethodA(cl,(Object *)g,msg);
 167 }
 168
 169 /**********************************************************************************************/
 170
 171 IPTR GTCycle__OM_SET(Class *cl, Object *o, struct opSet *msg)
 172 {
 173     struct CycleData    *data = INST_DATA(cl, o);
 174     struct TagItem      *tag;
 175     struct TagItem *taglist = msg->ops_AttrList;
 176     STRPTR              *mylabels;
 177     BOOL                rerender = FALSE;
 178     IPTR                result;
 179
 180     result = DoSuperMethodA(cl, o, (Msg)msg);
 181
 182     while((tag = NextTagItem(&taglist)))
 183     {
 184         switch(tag->ti_Tag)
 185         {
 186             case GTCY_Labels:
 187                 data->labels = (STRPTR *)tag->ti_Data;
 188                 data->numlabels = 0;
 189                 data->active = 0;
 190                 mylabels = data->labels;
 191                 if (mylabels)
 192                 {
 193                     while (mylabels[0])
 194                     {
 195                         data->numlabels++;
 196                         mylabels++;
 197                     }
 198                 }
 199                 rerender = TRUE;
 200                 break;
 201
 202             case GTCY_Active:
 203                 data->active = tag->ti_Data;
 204                 rerender = TRUE;
 205                 break;
 206
 207             case GA_Disabled:
 208                 rerender = TRUE;
 209                 break;
 210         }
 211     }
 212
 213     /* SDuvan: Removed test (cl == OCLASS(o)) */
 214
 215     if(rerender)
 216     {
 217         struct RastPort *rp;
 218
 219         if(data->active > data->numlabels-1)
 220             data->active = 0;
 221
 222         //kprintf("Rerendering\n");
 223
 224         rp = ObtainGIRPort(msg->ops_GInfo);
 225         if(rp)
 226         {
 227             DoMethod(o, GM_RENDER, (IPTR)msg->ops_GInfo, (IPTR)rp, GREDRAW_UPDATE);
 228             ReleaseGIRPort(rp);
 229             result = FALSE;
 230         }
 231     }
 232
 233     return result;
 234 }
 235
 236 /**********************************************************************************************/
 237
 238 IPTR GTCycle__OM_GET(Class *cl, Object *o, struct opGet *msg)
 239 {
 240     struct CycleData *data   = INST_DATA(cl, o);
 241     IPTR              retval = FALSE;
 242
 243     switch (msg->opg_AttrID)
 244     {
 245         case GTA_GadgetKind:
 246         case GTA_ChildGadgetKind:
 247             *(msg->opg_Storage) = CYCLE_KIND;
 248             retval = 1UL;
 249             break;
 250
 251         case GTCY_Active:
 252             *(msg->opg_Storage) = (IPTR)data->active;
 253             break;
 254
 255         case GTCY_Labels:
 256             *(msg->opg_Storage) = (IPTR)data->labels;
 257             break;
 258
 259         default:
 260             retval = DoSuperMethodA(cl, o, (Msg)msg);
 261             break;
 262     }
 263
 264     return retval;
 265 }
 266
 267 /**********************************************************************************************/
 268
 269 IPTR GTCycle__GM_RENDER(Class *cl, struct Gadget *g, struct gpRender *msg)
 270 {
 271     struct CycleData *data = INST_DATA(cl, g);
 272
 273     /* Full redraw: clear and draw border */
 274     DrawImageState(msg->gpr_RPort,(struct Image *)g->GadgetRender,
 275                    g->LeftEdge, g->TopEdge,
 276                    (g->Flags & GFLG_SELECTED)? IDS_SELECTED : IDS_NORMAL,
 277                    msg->gpr_GInfo->gi_DrInfo);
 278
 279     if (data->font)
 280         SetFont(msg->gpr_RPort, data->font);
 281     else
 282         SetFont(msg->gpr_RPort, msg->gpr_GInfo->gi_DrInfo->dri_Font);
 283
 284     if (data->labels)
 285     {
 286         rendercyclelabel(cl, g, data->labels[data->active], msg->gpr_RPort, msg->gpr_GInfo);
 287     }
 288
 289     /* Draw disabled pattern */
 290     if (g->Flags & GFLG_DISABLED)
 291     {
 292         DoDisabledPattern(msg->gpr_RPort,
 293                           g->LeftEdge,
 294                           g->TopEdge,
 295                           g->LeftEdge + g->Width - 1,
 296                           g->TopEdge + g->Height - 1,
 297                           msg->gpr_GInfo->gi_DrInfo->dri_Pens[SHADOWPEN],
 298                           GadToolsBase);
 299     }
 300
 301     if (msg->gpr_Redraw == GREDRAW_REDRAW)
 302     {
 303        renderlabel(GadToolsBase, g, msg->gpr_RPort, data->labelplace);
 304     }
 305
 306     return 0;
 307 }
 308
 309 /**********************************************************************************************/
 310
 311 IPTR GTCycle__GM_HITTEST(Class *cl, struct Gadget *g, struct gpHitTest *msg)
 312 {
 313     return pointingadget(g,
 314                          msg->gpht_GInfo,
 315                          msg->gpht_Mouse.X,
 316                          msg->gpht_Mouse.Y) ? GMR_GADGETHIT : 0;
 317 }
 318
 319 /**********************************************************************************************/
 320
 321 IPTR GTCycle__GM_GOACTIVE(Class *cl, struct Gadget *g, struct gpInput *msg)
 322 {
 323     struct RastPort     *rp;
 324     IPTR                retval;
 325
 326     g->Flags |= GFLG_SELECTED;
 327
 328     rp = ObtainGIRPort(msg->gpi_GInfo);
 329     if (rp)
 330     {
 331         struct gpRender rmsg =
 332         {
 333             GM_RENDER,
 334             msg->gpi_GInfo,
 335             rp,
 336             GREDRAW_UPDATE
 337         };
 338         DoMethodA((Object *)g, (Msg)&rmsg);
 339         ReleaseGIRPort(rp);
 340         retval = GMR_MEACTIVE;
 341     }
 342     else
 343     {
 344         retval = GMR_NOREUSE;
 345     }
 346
 347     return retval;
 348 }
 349
 350 /**********************************************************************************************/
 351
 352 IPTR GTCycle__GM_HANDLEINPUT(Class *cl, struct Gadget *g, struct gpInput *msg)
 353 {
 354     struct RastPort     *rp;
 355     struct CycleData    *data;
 356     IPTR                retval = GMR_MEACTIVE;
 357
 358     data = INST_DATA(cl, g);
 359
 360     if (msg->gpi_IEvent->ie_Class == IECLASS_RAWMOUSE)
 361     {
 362         if (msg->gpi_IEvent->ie_Code == SELECTUP)
 363         {
 364             if (g->Flags & GFLG_SELECTED)
 365             {
 366                 /* mouse is over gadget */
 367
 368                 data->active++;
 369                 if (data->active == data->numlabels)
 370                     data->active = 0;
 371
 372
 373                 *msg->gpi_Termination = data->active;
 374                 retval = GMR_NOREUSE | GMR_VERIFY;
 375             }
 376             else
 377             {
 378                 /* mouse is not over gadget */
 379                 retval = GMR_NOREUSE;
 380             }
 381
 382         }
 383         else if (msg->gpi_IEvent->ie_Code == IECODE_NOBUTTON)
 384         {
 385             struct gpHitTest htmsg =
 386             {
 387                 GM_HITTEST,
 388                 msg->gpi_GInfo,
 389                 { msg->gpi_Mouse.X, msg->gpi_Mouse.Y },
 390             };
 391
 392             if (DoMethodA((Object *)g, (Msg)&htmsg) != GMR_GADGETHIT)
 393             {
 394                 if (g->Flags & GFLG_SELECTED)
 395                 {
 396                     g->Flags &= ~GFLG_SELECTED;
 397                     rp = ObtainGIRPort(msg->gpi_GInfo);
 398                     if (rp)
 399                     {
 400                         struct gpRender rmsg =
 401                         {
 402                             GM_RENDER,
 403                             msg->gpi_GInfo,
 404                             rp,
 405                             GREDRAW_UPDATE
 406                         };
 407
 408                         DoMethodA((Object *)g, (Msg)&rmsg);
 409                         ReleaseGIRPort(rp);
 410                     }
 411                 }
 412             }
 413             else
 414             {
 415                 if (!(g->Flags & GFLG_SELECTED))
 416                 {
 417                     g->Flags |= GFLG_SELECTED;
 418                     rp = ObtainGIRPort(msg->gpi_GInfo);
 419                     if (rp)
 420                     {
 421                         struct gpRender rmsg =
 422                         {
 423                             GM_RENDER,
 424                             msg->gpi_GInfo,
 425                             rp,
 426                             GREDRAW_UPDATE
 427                         };
 428
 429                         DoMethodA((Object *)g, (Msg)&rmsg);
 430                         ReleaseGIRPort(rp);
 431                     }
 432                 }
 433             }
 434         }
 435         else if (msg->gpi_IEvent->ie_Code == MENUDOWN)
 436         {
 437             retval = GMR_REUSE;
 438         }
 439     }
 440
 441     return retval;
 442 }
 443
 444 /**********************************************************************************************/
 445
 446 IPTR GTCycle__GM_GOINACTIVE(Class *cl, struct Gadget *g, struct gpGoInactive *msg)
 447 {
 448     struct RastPort *rp;
 449
 450     g->Flags &= ~GFLG_SELECTED;
 451
 452     rp = ObtainGIRPort(msg->gpgi_GInfo);
 453     if (rp)
 454     {
 455         struct gpRender rmsg =
 456         {
 457             GM_RENDER,
 458             msg->gpgi_GInfo,
 459             rp,
 460             GREDRAW_UPDATE
 461         };
 462
 463         DoMethodA((Object *)g, (Msg)&rmsg);
 464         ReleaseGIRPort(rp);
 465     }
 466
 467     return 0;
 468 }
 469
 470 /**********************************************************************************************/