workbench/classes/zune/betterstring/mcc/Dispatcher.c

   1 /***************************************************************************
   2
   3  BetterString.mcc - A better String gadget MUI Custom Class
   4  Copyright (C) 1997-2000 Allan Odgaard
   5  Copyright (C) 2005-2013 by BetterString.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  BetterString class Support Site:  http://www.sf.net/projects/bstring-mcc/
  18
  19  $Id$
  20
  21 ***************************************************************************/
  22
  23 #include <string.h>
  24
  25 #include <clib/alib_protos.h>
  26 #include <proto/exec.h>
  27 #include <proto/intuition.h>
  28 #include <proto/muimaster.h>
  29 #include <proto/graphics.h>
  30 #include <proto/utility.h>
  31 #include <proto/locale.h>
  32
  33 #include "private.h"
  34
  35 static IPTR mNew(struct IClass *cl, Object *obj, struct opSet *msg)
  36 {
  37   ENTER();
  38
  39   if((obj = (Object *)DoSuperMethodA(cl, obj, (Msg)msg)) != NULL)
  40   {
  41     struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
  42
  43     if((data->Contents = AllocContentString(40)) != NULL)
  44     {
  45       struct TagItem *tag;
  46
  47       set(obj, MUIA_FillArea, FALSE);
  48
  49       // muimaster V20 is MUI 3.9
  50       data->mui39 = LIB_VERSION_IS_AT_LEAST(MUIMasterBase, 20, 0);
  51       // everything beyond muimaster 20.5500 is considered to be MUI4
  52       data->mui4x = LIB_VERSION_IS_AT_LEAST(MUIMasterBase, 20, 5500);
  53
  54       data->locale = OpenLocale(NULL);
  55
  56       if((tag = FindTagItem(MUIA_Background, msg->ops_AttrList)) != NULL)
  57       {
  58         setFlag(data->Flags, FLG_OwnBackground);
  59         data->OwnBackground = (STRPTR)tag->ti_Data;
  60       }
  61
  62       mSet(cl, obj, (struct opSet *)msg);
  63
  64       data->BufferPos = 0;
  65     }
  66     else
  67     {
  68       CoerceMethod(cl, obj, OM_DISPOSE);
  69       obj = NULL;
  70     }
  71   }
  72
  73   RETURN(obj);
  74   return((IPTR)obj);
  75 }
  76
  77 static IPTR mDispose(struct IClass *cl, Object *obj, Msg msg)
  78 {
  79   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
  80
  81   ENTER();
  82
  83   if(isFlagSet(data->Flags, FLG_WindowSleepNotifyAdded))
  84   {
  85     E(DBF_INPUT, "MUIA_Window_Sleep notify still active at OM_DISPOSE!!");
  86   }
  87
  88   FreeContentString(data->Contents);
  89   data->Contents = NULL;
  90
  91   FreeContentString(data->Original);
  92   data->Original = NULL;
  93
  94   FreeContentString(data->Undo);
  95   data->Undo = NULL;
  96
  97   if(data->FNCBuffer != NULL)
  98   {
  99     SharedPoolFree(data->FNCBuffer);
 100     data->FNCBuffer = NULL;
 101   }
 102
 103   if(data->locale != NULL)
 104   {
 105     CloseLocale(data->locale);
 106     data->locale = NULL;
 107   }
 108
 109   LEAVE();
 110   return DoSuperMethodA(cl, obj, msg);
 111 }
 112
 113 static IPTR mExport(struct IClass *cl, Object *obj, struct MUIP_Export *msg)
 114 {
 115   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 116   ULONG id;
 117
 118   ENTER();
 119
 120   if((id = (muiNotifyData(obj)->mnd_ObjectID)) != 0)
 121     DoMethod(msg->dataspace, MUIM_Dataspace_Add, data->Contents, strlen(data->Contents)+1, id);
 122
 123   LEAVE();
 124   return 0;
 125 }
 126
 127 static IPTR mImport(UNUSED struct IClass *cl, Object *obj, struct MUIP_Import *msg)
 128 {
 129   ULONG id;
 130
 131   ENTER();
 132
 133   if((id = (muiNotifyData(obj)->mnd_ObjectID)) != 0)
 134   {
 135       STRPTR contents = (STRPTR)DoMethod(msg->dataspace, MUIM_Dataspace_Find, id);
 136
 137 //  if(contents)
 138       set(obj, MUIA_String_Contents, contents);
 139   }
 140
 141   LEAVE();
 142   return 0;
 143 }
 144
 145 void AddWindowSleepNotify(struct IClass *cl, Object *obj)
 146 {
 147   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 148
 149   ENTER();
 150
 151   // we must check for a successful MUIM_Setup, because this function might be called during
 152   // OM_NEW and _win(obj) is not yet valid at that time
 153   if(isFlagClear(data->Flags, FLG_WindowSleepNotifyAdded) && isFlagSet(data->Flags, FLG_Setup) && _win(obj) != NULL)
 154   {
 155     if(data->SelectOnActive == TRUE || isFlagSet(data->Flags, FLG_ForceSelectOn))
 156     {
 157       // !!! CAUTION !!!
 158       // Ugly workaround for an ancient bug in MUI
 159       // MUIbase <= 2.11 adds some notifies for certain attributes which in turn
 160       // modify MUIA_Window_Sleep and hence trigger our own notify for this
 161       // attribute.
 162       // Removing our own notify will not remove it immediately but mark it as
 163       // "killed" only by MUI. The removal happens when the notifies are checked
 164       // for triggers. The problem arises if executing one notify triggers yet
 165       // another notification handling on the same object. In this case the nested
 166       // call will do the same removal as the first call is about to do next. This
 167       // will cause a double Remove() and double free of memory later in the first
 168       // call as here the pointer to the next notify to be handled has already been
 169       // obtained and will be used without further checks in the next iteration.
 170       // All this only happens if the removed notify directly follows the notify
 171       // which causes the removal. Thus we add a dummy notify to produce a "hole"
 172       // in the notify list and to let the nested notification check do its
 173       // removal work without causing a bad impact on the first check. This "hole"
 174       // just consists of another notify which never gets triggered. And even if
 175       // it would get triggered it will not cause a nested notify check. Thus the
 176       // first check will see this "hole" first before finally skipping the just
 177       // removed notify.
 178       // NOTE: this is neither a bug in MUIbase nor in BetterString but an ancient
 179       // bug in MUI itself as it does not take into account that a set() may cause
 180       // nested notifications which in turn may be removed inbetween!
 181       BOOL safeNotifies;
 182
 183       #if defined(__amigaos3__) || defined(__amigaos4__)
 184       if(LIB_VERSION_IS_AT_LEAST(MUIMasterBase, 20, 5824))
 185       {
 186         // MUI4 for AmigaOS is safe for V20.5824+
 187         safeNotifies = TRUE;
 188       }
 189       else if(LIB_VERSION_IS_AT_LEAST(MUIMasterBase, 20, 2346) && LIBREV(MUIMasterBase) < 5000)
 190       {
 191         // MUI3.9 for AmigaOS is safe for V20.2346+
 192         safeNotifies = TRUE;
 193       }
 194       else
 195       {
 196         // MUI 3.8 and older version of MUI 3.9 or MUI4 are definitely unsafe
 197         safeNotifies = FALSE;
 198       }
 199       #else
 200       // MorphOS and AROS must be considered unsafe unless someone from the
 201       // MorphOS/AROS team confirms that removing notifies in nested OM_SET
 202       // calls is safe.
 203       safeNotifies = FALSE;
 204       #endif
 205
 206       // add the dummy notify only once
 207       if(safeNotifies == FALSE && isFlagClear(data->Flags, FLG_DummyNotifyAdded))
 208       {
 209         // add a notify for an attribute which will *NEVER* be modified, thus the
 210         // trigger action will never be executed as well
 211         DoMethod(_win(obj), MUIM_Notify, MUIA_BetterString_Nop, MUIV_EveryTime, obj, 5, MUIM_Set, MUIA_NoNotify, TRUE, MUIA_BetterString_Nop, MUIV_TriggerValue);
 212         setFlag(data->Flags, FLG_DummyNotifyAdded);
 213         D(DBF_INPUT, "added dummy notify");
 214           }
 215
 216       // If the "select on active" feature is active we must be notified in case our
 217       // window is put to sleep to be able to deactivate the feature, because waking
 218       // the window up again will let ourself go active again and we will select the
 219       // complete content, even if it was not selected before. See YAM ticket #360
 220       // for details.
 221       // We must use a private attribute here, because the public attribute will remove
 222       // the notify again as soon as it is triggered.
 223       DoMethod(_win(obj), MUIM_Notify, MUIA_Window_Sleep, MUIV_EveryTime, obj, 3, MUIM_Set, MUIA_BetterString_InternalSelectOnActive, MUIV_NotTriggerValue);
 224       setFlag(data->Flags, FLG_WindowSleepNotifyAdded);
 225       D(DBF_INPUT, "added MUIA_Window_Sleep notify");
 226     }
 227   }
 228
 229   LEAVE();
 230 }
 231
 232 void RemWindowSleepNotify(struct IClass *cl, Object *obj)
 233 {
 234   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 235
 236   ENTER();
 237
 238   // we must check for a successful MUIM_Setup, because this function might be called during
 239   // OM_NEW and _win(obj) is not yet valid at that time
 240   if(isFlagSet(data->Flags, FLG_WindowSleepNotifyAdded) && isFlagSet(data->Flags, FLG_Setup) && _win(obj) != NULL)
 241   {
 242     // remove the notify again
 243     D(DBF_INPUT, "remove MUIA_Window_Sleep notify");
 244     if(DoMethod(_win(obj), MUIM_KillNotifyObj, MUIA_Window_Sleep, obj) == 0)
 245       E(DBF_INPUT, "removing MUIA_Window_Sleep notify failed?");
 246     clearFlag(data->Flags, FLG_WindowSleepNotifyAdded);
 247   }
 248
 249   LEAVE();
 250 }
 251
 252 static IPTR mSetup(struct IClass *cl, Object *obj, struct MUI_RenderInfo *rinfo)
 253 {
 254   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 255   IPTR rc = FALSE;
 256
 257   ENTER();
 258
 259   InitConfig(obj, data);
 260
 261   if(DoSuperMethodA(cl, obj, (Msg)rinfo))
 262   {
 263     // tell MUI we know how to indicate the active state
 264     _flags(obj) |= (1<<7);
 265
 266     // remember that we went through MUIM_Setup
 267     setFlag(data->Flags, FLG_Setup);
 268
 269     data->ehnode.ehn_Priority = 0;
 270     data->ehnode.ehn_Flags    = MUI_EHF_GUIMODE;
 271     data->ehnode.ehn_Object   = obj;
 272     data->ehnode.ehn_Class    = cl;
 273     data->ehnode.ehn_Events   = IDCMP_MOUSEBUTTONS | IDCMP_RAWKEY;
 274
 275     // setup the selection pointer
 276     if(data->SelectPointer == TRUE)
 277     {
 278       data->ehnode.ehn_Events |= IDCMP_MOUSEMOVE;
 279       SetupSelectPointer(data);
 280     }
 281
 282     DoMethod(_win(obj), MUIM_Window_AddEventHandler, &data->ehnode);
 283
 284     AddWindowSleepNotify(cl, obj);
 285
 286     rc = TRUE;
 287   }
 288   else
 289   {
 290     FreeConfig(muiRenderInfo(obj), data);
 291   }
 292
 293   RETURN(rc);
 294   return rc;
 295 }
 296
 297 static IPTR mCleanup(struct IClass *cl, Object *obj, Msg msg)
 298 {
 299   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 300
 301   ENTER();
 302
 303   // cleanup the selection pointer
 304   CleanupSelectPointer(data);
 305
 306   RemWindowSleepNotify(cl, obj);
 307
 308   DoMethod(_win(obj), MUIM_Window_RemEventHandler, &data->ehnode);
 309
 310   FreeConfig(muiRenderInfo(obj), data);
 311
 312   // forget that we went through MUIM_Setup
 313   clearFlag(data->Flags, FLG_Setup);
 314
 315   LEAVE();
 316   return DoSuperMethodA(cl, obj, msg);
 317 }
 318
 319 static IPTR mAskMinMax(struct IClass *cl, Object *obj, struct MUIP_AskMinMax *msg)
 320 {
 321   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 322   LONG Height;
 323
 324   ENTER();
 325
 326   DoSuperMethodA(cl, obj, (Msg)msg);
 327
 328   Height = _font(obj)->tf_YSize;
 329   msg->MinMaxInfo->MinHeight += Height;
 330   msg->MinMaxInfo->DefHeight += Height;
 331   msg->MinMaxInfo->MaxHeight += Height;
 332
 333   if(data->Width)
 334   {
 335     ULONG width;
 336
 337     SetFont(&data->rport, _font(obj));
 338     width = data->Width * TextLength(&data->rport, "n", 1);
 339
 340     msg->MinMaxInfo->MinWidth  += width;
 341     msg->MinMaxInfo->DefWidth  += width;
 342     msg->MinMaxInfo->MaxWidth  += width;
 343   }
 344   else
 345   {
 346     msg->MinMaxInfo->MinWidth  += 10;
 347     msg->MinMaxInfo->DefWidth  += 100;
 348     msg->MinMaxInfo->MaxWidth  += MBQ_MUI_MAXMAX;
 349   }
 350
 351   LEAVE();
 352   return 0;
 353 }
 354
 355 static IPTR mShow(struct IClass *cl, Object *obj, Msg msg)
 356 {
 357   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 358   struct BitMap *friendBMp = _rp(obj)->BitMap;
 359   WORD  width, height, depth;
 360
 361   ENTER();
 362
 363   DoSuperMethodA(cl, obj, msg);
 364
 365   width = _mwidth(obj);
 366   height = _font(obj)->tf_YSize;
 367   depth = ((struct Library *)GfxBase)->lib_Version >= 39 ? GetBitMapAttr(friendBMp, BMA_DEPTH) : friendBMp->Depth;
 368
 369   InitRastPort(&data->rport);
 370   data->rport.BitMap = MUIG_AllocBitMap(width+40, height, depth, 0, friendBMp);
 371   SetFont(&data->rport, _font(obj));
 372   SetDrMd(&data->rport, JAM1);
 373
 374   setFlag(data->Flags, FLG_Shown);
 375
 376   RETURN(TRUE);
 377   return TRUE;
 378 }
 379
 380 static IPTR mHide(struct IClass *cl, Object *obj, Msg msg)
 381 {
 382   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 383
 384   ENTER();
 385
 386   clearFlag(data->Flags, FLG_Shown);
 387
 388   // hide the selection pointer
 389   HideSelectPointer(obj, data);
 390
 391   MUIG_FreeBitMap(data->rport.BitMap);
 392
 393   LEAVE();
 394   return DoSuperMethodA(cl, obj, msg);
 395 }
 396
 397 static IPTR mDraw(struct IClass *cl, Object *obj, struct MUIP_Draw *msg)
 398 {
 399   ENTER();
 400
 401   DoSuperMethodA(cl, obj, (Msg)msg);
 402
 403   if(isFlagSet(msg->flags, MADF_DRAWUPDATE) || isFlagSet(msg->flags, MADF_DRAWOBJECT))
 404   {
 405     PrintString(cl, obj);
 406   }
 407
 408   LEAVE();
 409   return 0;
 410 }
 411
 412 static IPTR mHandleEvent(struct IClass *cl, Object *obj, struct MUIP_HandleEvent *msg)
 413 {
 414   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 415   IPTR result;
 416
 417   ENTER();
 418
 419   if(isFlagSet(data->Flags, FLG_Ghosted) || isFlagClear(data->Flags, FLG_Shown))
 420   {
 421     result = 0;
 422   }
 423   else
 424   {
 425     ULONG display_pos = data->DisplayPos;
 426
 427     result = mHandleInput(cl, obj, msg);
 428     if(display_pos != data->DisplayPos)
 429       set(obj, MUIA_String_DisplayPos, data->DisplayPos);
 430
 431     if(!result && data->ForwardObject != NULL)
 432     {
 433       ULONG attr = 0;
 434
 435       switch(msg->muikey)
 436       {
 437         case MUIKEY_TOP:
 438           attr = MUIV_List_Active_Top;
 439         break;
 440
 441         case MUIKEY_BOTTOM:
 442           attr = MUIV_List_Active_Bottom;
 443         break;
 444
 445         case MUIKEY_UP:
 446           attr = MUIV_List_Active_Up;
 447         break;
 448
 449         case MUIKEY_DOWN:
 450           attr = MUIV_List_Active_Down;
 451         break;
 452
 453         case MUIKEY_PAGEUP:
 454           attr = MUIV_List_Active_PageUp;
 455         break;
 456
 457         case MUIKEY_PAGEDOWN:
 458           attr = MUIV_List_Active_PageDown;
 459         break;
 460       }
 461
 462       if(attr != 0)
 463       {
 464         set(data->ForwardObject, MUIA_List_Active, attr);
 465         result = MUI_EventHandlerRC_Eat;
 466       }
 467     }
 468   }
 469
 470   RETURN(result);
 471   return result;
 472 }
 473
 474 static IPTR mGoActive(struct IClass *cl, Object *obj, UNUSED Msg msg)
 475 {
 476   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 477
 478   ENTER();
 479
 480   D(DBF_INPUT, "GoActive: %08lx %08lx", obj, data->Flags);
 481
 482   FreeContentString(data->Original);
 483   if((data->Original = AllocContentString(strlen(data->Contents)+1)) != NULL)
 484     strlcpy(data->Original, data->Contents, strlen(data->Contents+1));
 485
 486   // select everything if this is necessary or requested
 487   if((data->SelectOnActive == TRUE && isFlagClear(data->Flags, FLG_ForceSelectOff)) ||
 488      isFlagSet(data->Flags, FLG_ForceSelectOn))
 489   {
 490     // If the active flag is still clear we have been activated by keyboard or by
 491     // the application. Otherwise this method is called due to activation by mouse
 492     // and we must skip the "select on active" stuff as this has been done already.
 493     if(isFlagClear(data->Flags, FLG_Active))
 494     {
 495       DoMethod(obj, MUIM_BetterString_DoAction, MUIV_BetterString_DoAction_SelectAll);
 496     }
 497   }
 498
 499   //  now declare ourself as active
 500   setFlag(data->Flags, FLG_Active);
 501   setFlag(data->Flags, FLG_FreshActive);
 502
 503   if(isFlagClear(data->Flags, FLG_OwnBackground) && data->mui4x == FALSE)
 504     set(obj, MUIA_Background, data->ActiveBackground);
 505   else if(data->mui4x == TRUE)
 506     set(obj, MUIA_Background, MUII_StringActiveBack);
 507   else
 508     MUI_Redraw(obj, MADF_DRAWUPDATE);
 509
 510   RETURN(TRUE);
 511   return TRUE;
 512 }
 513
 514 static IPTR mGoInactive(struct IClass *cl, Object *obj, UNUSED Msg msg)
 515 {
 516   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 517
 518   ENTER();
 519
 520   D(DBF_INPUT, "GoInActive: %08lx", obj);
 521
 522   // clean an eventually marked block and the
 523   // active state flag of the gadget
 524   clearFlag(data->Flags, FLG_BlockEnabled);
 525   clearFlag(data->Flags, FLG_Active);
 526   clearFlag(data->Flags, FLG_FreshActive);
 527
 528   if(isFlagSet(data->Flags, FLG_OwnBackground))
 529   {
 530     set(obj, MUIA_Background, data->OwnBackground);
 531     // MUI 3.8 needs an explicit refresh
 532     if(data->mui39 == FALSE && data->mui4x == FALSE)
 533       MUI_Redraw(obj, MADF_DRAWUPDATE);
 534   }
 535   else if(data->mui4x == TRUE)
 536     set(obj, MUIA_Background, MUII_StringBack);
 537   else
 538     set(obj, MUIA_Background, data->InactiveBackground);
 539
 540   RETURN(TRUE);
 541   return TRUE;
 542 }
 543
 544 DISPATCHER(_Dispatcher)
 545 {
 546   IPTR result;
 547
 548   ENTER();
 549
 550   switch(msg->MethodID)
 551   {
 552     case OM_NEW:
 553       result = mNew(cl, obj, (struct opSet *)msg);
 554     break;
 555
 556     case MUIM_Setup:
 557       result = mSetup(cl, obj, (struct MUI_RenderInfo *)msg);
 558     break;
 559
 560     case MUIM_Show:
 561       result = mShow(cl, obj, msg);
 562     break;
 563
 564     case MUIM_AskMinMax:
 565       result = mAskMinMax(cl, obj, (struct MUIP_AskMinMax *)msg);
 566     break;
 567
 568     case MUIM_Draw:
 569       result = mDraw(cl, obj, (struct MUIP_Draw *)msg);
 570     break;
 571
 572     case OM_GET:
 573       result = mGet(cl, obj, (struct opGet *)msg);
 574     break;
 575
 576     case OM_SET:
 577       mSet(cl, obj, (struct opSet *)msg);
 578       result = DoSuperMethodA(cl, obj, msg);
 579     break;
 580
 581     case MUIM_HandleEvent:
 582       result = mHandleEvent(cl, obj, (struct MUIP_HandleEvent *)msg);
 583     break;
 584
 585     case MUIM_GoActive:
 586       result = mGoActive(cl, obj, msg);
 587     break;
 588
 589     case MUIM_GoInactive:
 590       result = mGoInactive(cl, obj, msg);
 591     break;
 592
 593     case MUIM_Hide:
 594       result = mHide(cl, obj, msg);
 595     break;
 596
 597     case MUIM_Cleanup:
 598       result = mCleanup(cl, obj, msg);
 599     break;
 600
 601     case OM_DISPOSE:
 602       result = mDispose(cl, obj, msg);
 603     break;
 604
 605     case MUIM_Export:
 606       result = mExport(cl, obj, (struct MUIP_Export *)msg);
 607     break;
 608
 609     case MUIM_Import:
 610       result = mImport(cl, obj, (struct MUIP_Import *)msg);
 611     break;
 612
 613     case MUIM_BetterString_ClearSelected:
 614     {
 615       // forward the clear request to our new DoAction method
 616       // which in fact will do the very same, but a bit more clever
 617       DoMethod(obj, MUIM_BetterString_DoAction, MUIV_BetterString_DoAction_Delete);
 618       result = TRUE;
 619     }
 620     break;
 621
 622     case MUIM_BetterString_Insert:
 623       result = mInsert(cl, obj, (struct MUIP_BetterString_Insert *)msg);
 624     break;
 625
 626     case MUIM_BetterString_DoAction:
 627       result = mDoAction(cl, obj, (struct MUIP_BetterString_DoAction *)msg);
 628     break;
 629
 630     case MUIM_BetterString_FileNameStart:
 631       result = mFileNameStart((struct MUIP_BetterString_FileNameStart *)msg);
 632     break;
 633
 634     default:
 635       result = DoSuperMethodA(cl, obj, msg);
 636     break;
 637   }
 638
 639   RETURN(result);
 640   return(result);
 641 }