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     const 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 CycleData    *data;
 324     struct RastPort     *rp;
 325     IPTR                retval;
 326
 327     data = INST_DATA(cl, g);
 328
 329     g->Flags |= GFLG_SELECTED;
 330
 331     rp = ObtainGIRPort(msg->gpi_GInfo);
 332     if (rp)
 333     {
 334         struct gpRender rmsg =
 335         {
 336             GM_RENDER,
 337             msg->gpi_GInfo,
 338             rp,
 339             GREDRAW_UPDATE
 340         };
 341         DoMethodA((Object *)g, (Msg)&rmsg);
 342         ReleaseGIRPort(rp);
 343         retval = GMR_MEACTIVE;
 344     }
 345     else
 346     {
 347         retval = GMR_NOREUSE;
 348     }
 349
 350     return retval;
 351 }
 352
 353 /**********************************************************************************************/
 354
 355 IPTR GTCycle__GM_HANDLEINPUT(Class *cl, struct Gadget *g, struct gpInput *msg)
 356 {
 357     struct RastPort     *rp;
 358     struct CycleData    *data;
 359     IPTR                retval = GMR_MEACTIVE;
 360
 361     data = INST_DATA(cl, g);
 362
 363     if (msg->gpi_IEvent->ie_Class == IECLASS_RAWMOUSE)
 364     {
 365         if (msg->gpi_IEvent->ie_Code == SELECTUP)
 366         {
 367             if (g->Flags & GFLG_SELECTED)
 368             {
 369                 /* mouse is over gadget */
 370
 371                 data->active++;
 372                 if (data->active == data->numlabels)
 373                     data->active = 0;
 374
 375
 376                 *msg->gpi_Termination = data->active;
 377                 retval = GMR_NOREUSE | GMR_VERIFY;
 378             }
 379             else
 380             {
 381                 /* mouse is not over gadget */
 382                 retval = GMR_NOREUSE;
 383             }
 384
 385         }
 386         else if (msg->gpi_IEvent->ie_Code == IECODE_NOBUTTON)
 387         {
 388             struct gpHitTest htmsg =
 389             {
 390                 GM_HITTEST,
 391                 msg->gpi_GInfo,
 392                 { msg->gpi_Mouse.X, msg->gpi_Mouse.Y },
 393             };
 394
 395             if (DoMethodA((Object *)g, (Msg)&htmsg) != GMR_GADGETHIT)
 396             {
 397                 if (g->Flags & GFLG_SELECTED)
 398                 {
 399                     g->Flags &= ~GFLG_SELECTED;
 400                     rp = ObtainGIRPort(msg->gpi_GInfo);
 401                     if (rp)
 402                     {
 403                         struct gpRender rmsg =
 404                         {
 405                             GM_RENDER,
 406                             msg->gpi_GInfo,
 407                             rp,
 408                             GREDRAW_UPDATE
 409                         };
 410
 411                         DoMethodA((Object *)g, (Msg)&rmsg);
 412                         ReleaseGIRPort(rp);
 413                     }
 414                 }
 415             }
 416             else
 417             {
 418                 if (!(g->Flags & GFLG_SELECTED))
 419                 {
 420                     g->Flags |= GFLG_SELECTED;
 421                     rp = ObtainGIRPort(msg->gpi_GInfo);
 422                     if (rp)
 423                     {
 424                         struct gpRender rmsg =
 425                         {
 426                             GM_RENDER,
 427                             msg->gpi_GInfo,
 428                             rp,
 429                             GREDRAW_UPDATE
 430                         };
 431
 432                         DoMethodA((Object *)g, (Msg)&rmsg);
 433                         ReleaseGIRPort(rp);
 434                     }
 435                 }
 436             }
 437         }
 438         else if (msg->gpi_IEvent->ie_Code == MENUDOWN)
 439         {
 440             retval = GMR_REUSE;
 441         }
 442     }
 443
 444     return retval;
 445 }
 446
 447 /**********************************************************************************************/
 448
 449 IPTR GTCycle__GM_GOINACTIVE(Class *cl, struct Gadget *g, struct gpGoInactive *msg)
 450 {
 451     struct RastPort *rp;
 452
 453     g->Flags &= ~GFLG_SELECTED;
 454
 455     rp = ObtainGIRPort(msg->gpgi_GInfo);
 456     if (rp)
 457     {
 458         struct gpRender rmsg =
 459         {
 460             GM_RENDER,
 461             msg->gpgi_GInfo,
 462             rp,
 463             GREDRAW_UPDATE
 464         };
 465
 466         DoMethodA((Object *)g, (Msg)&rmsg);
 467         ReleaseGIRPort(rp);
 468     }
 469
 470     return 0;
 471 }
 472
 473 /**********************************************************************************************/