rom/intuition/strgclass.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     Copyright © 2001-2003, The MorphOS Development Team. All Rights Reserved.
   4     $Id$
   5 */
   6
   7 #include <proto/graphics.h>
   8 #include <proto/intuition.h>
   9 #include <proto/utility.h>
  10 #include <proto/exec.h>
  11 #include <exec/memory.h>
  12 #include <intuition/gadgetclass.h>
  13 #include <intuition/imageclass.h>
  14 #include <intuition/intuition.h>
  15 #include <intuition/cghooks.h>
  16 #include <intuition/sghooks.h>
  17 #include <aros/asmcall.h>
  18 #include <string.h>
  19 #include <stdio.h>
  20
  21 #include "intuition_intern.h"
  22 #include "strgadgets.h"
  23
  24 #undef DEBUG
  25 #define DEBUG 0
  26 #include <aros/debug.h>
  27
  28 #define SFLG_BUFFER_ALLOCATED   (1 << 2)
  29 #define SFLG_WORKBUF_ALLOCATED  (1 << 3)
  30 #define SFLG_UNDOBUF_ALLOCATED  (1 << 4)
  31
  32 static void set_buffer_str(struct StringInfo *StrInfo)
  33 {
  34     char  buf[64];
  35     char *ptr = buf + sizeof(buf);
  36     LONG  value = StrInfo->LongInt;
  37     int   len;
  38
  39     if (value < 0)
  40         value = -value;
  41
  42     do
  43     {
  44         *--ptr = '0' + value % 10;
  45         value /= 10;
  46     }
  47     while (value != 0);
  48
  49     if (StrInfo->LongInt < 0)
  50         *--ptr = '-';
  51
  52     len = buf + sizeof(buf) - ptr;
  53
  54     if (len >= StrInfo->MaxChars)
  55         len = StrInfo->MaxChars - 1;
  56
  57     StrInfo->Buffer[len] = '\0';
  58     memcpy(StrInfo->Buffer, ptr, len);
  59 }
  60
  61 /*****************
  62 ** StrG::Set()  **
  63 *****************/
  64 #define SETFLAG(flagvar, boolvar, flag) \
  65 if (boolvar)                        \
  66 flagvar |= flag;        \
  67 else                \
  68 flagvar &= ~flag;
  69
  70
  71 STATIC IPTR strg_set(Class *cl, struct Gadget * g, struct opSet *msg)
  72 {
  73     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
  74     struct Library *UtilityBase = GetPrivIBase(IntuitionBase)->UtilityBase;
  75     struct TagItem  *tag, *tstate;
  76     struct StrGData *data = INST_DATA(cl, g);
  77     IPTR             retval = (IPTR)0;
  78
  79     for (tstate = msg->ops_AttrList; (tag = NextTagItem(&tstate)); )
  80     {
  81         IPTR tidata = tag->ti_Data;
  82         BOOL notify = FALSE;
  83
  84         switch (tag->ti_Tag)
  85         {
  86
  87             case STRINGA_LongVal:       /* [ISGNU] */
  88                 if (msg->MethodID != OM_NEW)
  89                 {
  90
  91                     /* OM_NEW STRINGA_LongVal is handled in strg_new! */
  92
  93                     data->StrInfo.LongInt = (LONG)tidata;
  94
  95                     set_buffer_str(&data->StrInfo);
  96                     //snprintf(data->StrInfo.Buffer, data->StrInfo.MaxChars, "%d", data->StrInfo.LongInt);
  97
  98                     g->Activation |= GACT_LONGINT;
  99                     retval = 1UL;
 100                     notify = TRUE;
 101                 }
 102                 break;
 103
 104             case STRINGA_TextVal:       /* [ISGNU] */
 105                 if (msg->MethodID != OM_NEW)
 106                 {
 107                     /* OM_NEW STRINGA_TextVal is handled in strg_new! */
 108
 109                     strcpy(data->StrInfo.Buffer, (STRPTR)tidata ? (STRPTR)tidata : (STRPTR)"");
 110                     g->Activation &= ~GACT_LONGINT;
 111                     retval = 1UL;
 112                     notify = TRUE;
 113                 }
 114                 break;
 115
 116             case STRINGA_MaxChars:      /* [I] */
 117                 data->StrInfo.MaxChars = (WORD)tidata;
 118                 break;
 119
 120             case STRINGA_Buffer:        /* [I] */
 121                 data->StrInfo.Buffer = (STRPTR)tidata;
 122                 break;
 123
 124             case STRINGA_UndoBuffer:    /* [I] */
 125                 data->StrInfo.UndoBuffer = (STRPTR)tidata;
 126                 break;
 127
 128             case STRINGA_WorkBuffer:    /* [I] */
 129                 data->StrExtend.WorkBuffer = (STRPTR)tidata;
 130                 break;
 131
 132             case STRINGA_BufferPos:     /* [ISU] */
 133                 data->StrInfo.BufferPos = (WORD)tidata;
 134                 retval = 1UL;
 135                 break;
 136
 137             case STRINGA_DispPos:       /* [ISU] */
 138                 data->StrInfo.DispPos = (WORD)tidata;
 139                 retval = 1UL;
 140                 break;
 141
 142             case STRINGA_AltKeyMap:     /* [IS] */
 143                 data->StrInfo.AltKeyMap = (struct KeyMap *)tidata;
 144                 break;
 145
 146             case STRINGA_Font:      /* [IS] */
 147                 data->StrExtend.Font = (struct TextFont *)tidata;
 148                 retval = 1UL;
 149                 break;
 150
 151             case STRINGA_Pens:      /* [IS] */
 152                 data->StrExtend.Pens[0] = ((LONG)tidata) & 0x0000FFFF;
 153                 data->StrExtend.Pens[1] = (((LONG)tidata) & 0xFFFF0000) >> 16;
 154                 retval = 1UL;
 155                 break;
 156
 157             case STRINGA_ActivePens:    /* [IS] */
 158                 data->StrExtend.ActivePens[0] = ((LONG)tidata) & 0x0000FFFF;
 159                 data->StrExtend.ActivePens[1] = (((LONG)tidata) & 0xFFFF0000) >> 16;
 160                 retval = 1UL;
 161                 break;
 162
 163             case STRINGA_EditHook:      /* [I] */
 164                 data->StrExtend.EditHook = (struct Hook *)tidata;
 165                 break;
 166
 167             case STRINGA_EditModes:     /* [IS] */
 168                 data->StrExtend.InitialModes = (ULONG)tidata;
 169                 break;
 170
 171             case STRINGA_ReplaceMode:   /* [IS] */
 172                 SETFLAG(data->StrExtend.InitialModes, (ULONG)tidata, SGM_REPLACE);
 173                 break;
 174
 175             case STRINGA_FixedFieldMode:    /* [IS] */
 176                 SETFLAG(data->StrExtend.InitialModes, (ULONG)tidata, SGM_FIXEDFIELD);
 177                 break;
 178
 179             case STRINGA_NoFilterMode:  /* [IS] */
 180                 SETFLAG(data->StrExtend.InitialModes, (ULONG)tidata, SGM_NOFILTER);
 181                 break;
 182
 183             case STRINGA_Justification: /* [IS] */
 184                 g->Activation |= (UWORD)tidata;
 185                 retval = 1UL;
 186                 break;
 187
 188             case STRINGA_ExitHelp:
 189                 SETFLAG(data->StrExtend.InitialModes, (ULONG)tidata, SGM_EXITHELP);
 190                 break;
 191
 192
 193         } /* switch (currently parsed tag) */
 194
 195         if (notify && (msg->MethodID != OM_NEW))
 196         {
 197 #if 0 /* FIXME: Why don't we support notification? */
 198             struct TagItem notify_tags[] =
 199             {
 200                 { 0UL       , 0UL               },
 201                 { GA_ID     , g->GadgetID       },
 202                 { TAG_END                       }
 203             };
 204             struct opUpdate nmsg =
 205             {
 206                 OM_NOTIFY, notify_tags, msg->ops_GInfo, 0
 207             };
 208             notify_tags[0].ti_Tag  = tag->ti_Tag;
 209             notify_tags[0].ti_Data = tidata;
 210
 211             DoSuperMethodA(cl, (Object *)g, (Msg)&nmsg);
 212
 213 #endif
 214         } /* if (the currently parsed attr supports notification) */
 215     } /* for (each tag in taglist) */
 216
 217     return (retval);
 218 } /* strg_set() */
 219
 220 /******************
 221 **  StrG::Get()  **
 222 ******************/
 223
 224 IPTR StrGClass__OM_GET(Class *cl, struct Gadget * g, struct opGet *msg)
 225 {
 226     struct StrGData *data = INST_DATA(cl, g);
 227     IPTR             retval = 1UL;
 228
 229     switch (msg->opg_AttrID)
 230     {
 231         case STRINGA_LongVal:   /* [ISGNU] */
 232             if (g->Activation & GACT_LONGINT)
 233                 *(msg->opg_Storage) = (IPTR)data->StrInfo.LongInt;
 234             else
 235                 *(msg->opg_Storage) = 0UL;
 236             break;
 237
 238         case STRINGA_TextVal:   /* [ISGNU] */
 239             if (!(g->Activation & GACT_LONGINT))
 240                 *(msg->opg_Storage) = (IPTR)data->StrInfo.Buffer;
 241             else
 242                 *(msg->opg_Storage) = 0UL;
 243             break;
 244
 245         default:
 246             retval = DoSuperMethodA(cl, (Object *)g, (Msg)msg);
 247             break;
 248     }
 249     return (retval);
 250 }
 251
 252 /******************
 253 **  StrG::New()  **
 254 ******************/
 255
 256 IPTR StrGClass__OM_NEW(Class *cl, Object * o, struct opSet *msg)
 257 {
 258     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 259     struct Library *UtilityBase = GetPrivIBase(IntuitionBase)->UtilityBase;
 260     struct Gadget *g = (struct Gadget *)DoSuperMethodA(cl, o, (Msg)msg);
 261     if (g)
 262     {
 263         struct TagItem  *ti;
 264         struct StrGData *data = INST_DATA(cl, g);
 265         STRPTR           textval;
 266         WORD             maxchars;
 267
 268         /*
 269
 270           The instance object is cleared memory!
 271           memset(data, 0, sizeof (struct StrGData));
 272         */
 273
 274         /* Set some defaults */
 275         data->StrInfo.MaxChars = 80;
 276         data->StrExtend.Pens[0] = data->StrExtend.ActivePens[0] = 1;
 277
 278         strg_set(cl, g, msg);
 279
 280         /* If no buffers have been supplied, then allocate them */
 281         maxchars = data->StrInfo.MaxChars;
 282
 283         if (!data->StrInfo.Buffer)
 284         {
 285             data->StrInfo.Buffer = (STRPTR)AllocVec(maxchars, MEMF_ANY);
 286             if (!data->StrInfo.Buffer)
 287                 goto failure;
 288             data->StrInfo.Buffer[0] = '\0';
 289             data->Flags |= SFLG_BUFFER_ALLOCATED;
 290         }
 291
 292         if (!data->StrInfo.UndoBuffer)
 293         {
 294             data->StrInfo.UndoBuffer = (STRPTR)AllocVec(maxchars, MEMF_ANY);
 295             if (!data->StrInfo.UndoBuffer)
 296                 goto failure;
 297             data->StrInfo.UndoBuffer[0] = '\0';
 298             data->Flags |= SFLG_UNDOBUF_ALLOCATED;
 299         }
 300
 301         if (!data->StrExtend.WorkBuffer)
 302         {
 303             data->StrExtend.WorkBuffer = (STRPTR)AllocVec(maxchars, MEMF_ANY);
 304             if (!data->StrExtend.WorkBuffer)
 305                 goto failure;
 306             data->StrExtend.WorkBuffer[0] = '\0';
 307             data->Flags |= SFLG_WORKBUF_ALLOCATED;
 308         }
 309
 310         /* Get inital string contents */
 311         textval = (STRPTR)GetTagData(STRINGA_TextVal, 0, msg->ops_AttrList);
 312         if (textval)
 313         {
 314             strcpy(data->StrInfo.Buffer, textval);
 315             D(bug("strgclass:Initializing string gadget to text value %s\n", textval));
 316             g->Activation &= ~GACT_LONGINT;
 317         }
 318
 319         ti = FindTagItem(STRINGA_LongVal, msg->ops_AttrList);
 320         if (ti != NULL)
 321         {
 322             LONG val = (LONG)ti->ti_Data;
 323
 324             data->StrInfo.LongInt = val;
 325             set_buffer_str(&data->StrInfo);
 326             //snprintf(data->StrInfo.Buffer, data->StrInfo.MaxChars, "%d", val);
 327
 328             D(bug("strgclass:Initializing string gadget to integer value %d\n", val));
 329             g->Activation |= GACT_LONGINT;
 330         }
 331
 332         g->SpecialInfo = &(data->StrInfo);
 333         g->Flags |= GFLG_STRINGEXTEND;
 334         data->StrInfo.Extension = &(data->StrExtend);
 335     }
 336     return (IPTR)g;
 337
 338 failure:
 339     {
 340         STACKULONG method = OM_DISPOSE;
 341         CoerceMethodA(cl, (Object *)g, (Msg)&method);
 342     }
 343     return (IPTR)NULL;
 344 }
 345
 346 /**********************
 347 **  StrG::Dispose()  **
 348 **********************/
 349 IPTR StrGClass__OM_DISPOSE(Class *cl, Object *o, Msg msg)
 350 {
 351     struct StrGData *data = INST_DATA(cl, o);
 352
 353     if ((data->StrInfo.Buffer) && (data->Flags & SFLG_BUFFER_ALLOCATED))
 354         FreeVec(data->StrInfo.Buffer);
 355
 356     if ((data->StrInfo.UndoBuffer) && (data->Flags & SFLG_UNDOBUF_ALLOCATED))
 357         FreeVec(data->StrInfo.UndoBuffer);
 358
 359     if ((data->StrExtend.WorkBuffer) && (data->Flags & SFLG_WORKBUF_ALLOCATED))
 360         FreeVec(data->StrExtend.WorkBuffer);
 361
 362     return DoSuperMethodA(cl, o, msg);
 363 }
 364
 365 /*********************
 366 **  Strg::Render()  **
 367 *********************/
 368 IPTR StrGClass__GM_RENDER(Class *cl, struct Gadget *g, struct gpRender *msg)
 369 {
 370     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 371     UpdateStrGadget(g,
 372                     msg->gpr_GInfo->gi_Window,
 373                     msg->gpr_GInfo->gi_Requester,
 374                     IntuitionBase);
 375
 376     return (IPTR)0;
 377 }
 378
 379
 380 /**************************
 381 **  StrG::HandleInput()  **
 382 **************************/
 383 IPTR StrGClass__GM_HANDLEINPUT(Class *cl, struct Gadget *g, struct gpInput *msg)
 384 {
 385     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 386     IPTR                 ret;
 387     IPTR                 retval = GMR_MEACTIVE;
 388     UWORD                imsgcode;
 389     struct InputEvent   *ie = msg->gpi_IEvent;
 390
 391     if (ie->ie_Class == IECLASS_RAWMOUSE)
 392     {
 393         if (ie->ie_Code == SELECTDOWN)
 394         {
 395             struct IBox container;
 396
 397             GetGadgetIBox(g, msg->gpi_GInfo, &container);
 398
 399             D(bug("*** click: mouse = %d,%d (%d %d) box = %d,%d - %d %d (%d x %d)\n ***\n",
 400                   ie->ie_X,
 401                   ie->ie_Y,
 402                   msg->gpi_Mouse.X,
 403                   msg->gpi_Mouse.Y,
 404                   container.Left,
 405                   container.Top,
 406                   container.Left + container.Width - 1,
 407                   container.Top + container.Height - 1,
 408                   container.Width,
 409                   container.Height));
 410
 411             /* Click outside gadget ? */
 412             if (    (msg->gpi_Mouse.X >= container.Width)
 413                 || (msg->gpi_Mouse.X < 0)
 414                 || (msg->gpi_Mouse.Y >= container.Height)
 415                 || (msg->gpi_Mouse.Y < 0))
 416
 417             {
 418                 retval = GMR_REUSE;
 419             }
 420         }
 421         else if (ie->ie_Code == MENUDOWN)
 422         {
 423             retval = GMR_REUSE;
 424         }
 425         /* Just to prevent a whole lot of MOUSE_MOVE messages being passed */
 426         else if (ie->ie_Code == IECODE_NOBUTTON)
 427         {
 428             return (retval);
 429         }
 430     }
 431
 432
 433     if (retval == GMR_MEACTIVE)
 434     {
 435
 436         ret = HandleStrInput(g
 437                      ,msg->gpi_GInfo
 438                      ,ie
 439                      ,&imsgcode
 440                      ,IntuitionBase
 441         );
 442
 443
 444         if (ret & (SGA_END|SGA_PREVACTIVE|SGA_NEXTACTIVE))
 445         {
 446             if (ret & SGA_REUSE)
 447                 retval = GMR_REUSE;
 448             else
 449                 retval = GMR_NOREUSE;
 450
 451             if (ret & SGA_PREVACTIVE)
 452                 retval |= GMR_PREVACTIVE;
 453             else if (ret & SGA_NEXTACTIVE)
 454                 retval |= GMR_NEXTACTIVE;
 455
 456             retval |= GMR_VERIFY;
 457             *(msg->gpi_Termination) = (LONG)imsgcode;
 458         }
 459         else
 460         {
 461             retval = GMR_MEACTIVE;
 462         }
 463     } /* if (retval hasn't allreay been set) */
 464
 465     return (retval);
 466 }
 467
 468 /*************************
 469 **  Strg::GoInactive()  **
 470 *************************/
 471 IPTR StrGClass__GM_GOINACTIVE(Class *cl, struct Gadget *g, struct gpGoInactive *msg)
 472 {
 473     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 474     struct RastPort *rp;
 475     struct opUpdate  nmsg;
 476     struct TagItem   tags[3];
 477     struct StrGData *data = INST_DATA(cl, g);
 478
 479     g->Flags &= ~GFLG_SELECTED;
 480
 481     /* Rerender gadget in inactive state */
 482     rp = ObtainGIRPort(msg->gpgi_GInfo);
 483     if (rp)
 484     {
 485         struct gpRender method;
 486
 487         method.MethodID   = GM_RENDER;
 488         method.gpr_GInfo  = msg->gpgi_GInfo;
 489         method.gpr_RPort  = rp;
 490         method.gpr_Redraw = GREDRAW_REDRAW;
 491         DoMethodA((Object *)g, (Msg)&method);
 492
 493         ReleaseGIRPort(rp);
 494     }
 495
 496     /* Notify evt. change of string gadget contents */
 497
 498     if (g->Activation & GACT_LONGINT)
 499     {
 500         tags[0].ti_Tag  = STRINGA_LongVal;
 501         tags[0].ti_Data = (IPTR)data->StrInfo.LongInt;
 502     }
 503     else
 504     {
 505         tags[0].ti_Tag  = STRINGA_TextVal;
 506         tags[0].ti_Data = (IPTR)data->StrInfo.Buffer;
 507     }
 508
 509     tags[1].ti_Tag  = GA_ID;
 510     tags[1].ti_Data = g->GadgetID;
 511     tags[2].ti_Tag  = TAG_END;
 512
 513     nmsg.MethodID       = OM_NOTIFY;
 514     nmsg.opu_AttrList   = tags;
 515     nmsg.opu_GInfo      = msg->gpgi_GInfo;
 516     nmsg.opu_Flags      = 0;
 517
 518     DoSuperMethodA(cl, (Object *)g, (Msg)&nmsg);
 519
 520     return (IPTR)0;
 521 }
 522
 523 /***********************
 524 **  Strg::GoActive()  **
 525 ***********************/
 526 IPTR StrGClass__GM_GOACTIVE(Class *cl, struct Gadget *g, struct gpInput *msg)
 527 {
 528     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 529     if (msg->gpi_IEvent)
 530     {
 531         UWORD imsgcode;
 532
 533         HandleStrInput(g, msg->gpi_GInfo,
 534                        msg->gpi_IEvent, &imsgcode, IntuitionBase
 535         );
 536
 537     }
 538     else
 539     {
 540         struct StrGData   *data = INST_DATA(cl, g);
 541         struct RastPort   *rp;
 542         struct GadgetInfo *gi = msg->gpi_GInfo;
 543
 544         g->Flags |= GFLG_SELECTED;
 545         if (data->StrInfo.UndoBuffer)
 546         {
 547             strcpy(data->StrInfo.UndoBuffer, data->StrInfo.Buffer);
 548         }
 549
 550         if ((rp = ObtainGIRPort(gi)))
 551         {
 552             struct gpRender method;
 553
 554             method.MethodID   = GM_RENDER;
 555             method.gpr_GInfo  = gi;
 556             method.gpr_RPort  = rp;
 557             method.gpr_Redraw = GREDRAW_REDRAW;
 558
 559             DoMethodA((Object *)g, (Msg)&method);
 560
 561             ReleaseGIRPort(rp);
 562         }
 563     }
 564     return (IPTR)GMR_MEACTIVE;
 565 }
 566
 567 /******************
 568 **  Strg::Set()  **
 569 ******************/
 570 IPTR StrGClass__OM_SET(Class *cl, struct Gadget *g, struct opSet *msg)
 571 {
 572     struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
 573     IPTR retval;
 574
 575     retval = DoSuperMethodA(cl, (Object *)g, (Msg)msg);
 576     retval += (IPTR)strg_set(cl, g, msg);
 577
 578     /* If we have been subclassed, OM_UPDATE should not cause a GM_RENDER
 579      * because it would circumvent the subclass from fully overriding it.
 580      * The check of cl == OCLASS(o) should fail if we have been
 581      * subclassed, and we have gotten here via DoSuperMethodA().
 582      */
 583     if ( retval && ( (msg->MethodID != OM_UPDATE) || (cl == OCLASS(g)) ) )
 584     {
 585         struct GadgetInfo *gi = msg->ops_GInfo;
 586
 587         if (gi)
 588         {
 589             struct RastPort *rp = ObtainGIRPort(gi);
 590
 591             if (rp)
 592             {
 593                 struct gpRender method;
 594
 595                 method.MethodID   = GM_RENDER;
 596                 method.gpr_GInfo  = gi;
 597                 method.gpr_RPort  = rp;
 598                 method.gpr_Redraw = GREDRAW_REDRAW;
 599
 600                 DoMethodA((Object *)g, (Msg)&method);
 601
 602                 ReleaseGIRPort(rp);
 603             } /* if */
 604         } /* if */
 605     } /* if */
 606
 607     return retval;
 608 }