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-2009 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 /*
  36 struct NewMenu PopupMenuData[] =
  37 {
  38   NM_TITLE, "Stringgadget",       NULL, 0L, 0, (APTR)0,
  39   NM_ITEM,  "Cut",                NULL, 0L, 0, (APTR)1,
  40   NM_ITEM,  "Copy",               NULL, 0L, 0, (APTR)2,
  41   NM_ITEM,  "Paste",              NULL, 0L, 0, (APTR)3,
  42   NM_ITEM,  NM_BARLABEL,          NULL, 0L, 0, (APTR)0,
  43   NM_ITEM,  "Undo",               NULL, 0L, 0, (APTR)4,
  44   NM_ITEM,  "Redo",               NULL, 0L, 0, (APTR)5,
  45   NM_ITEM,  "Original",           NULL, 0L, 0, (APTR)6,
  46   NM_ITEM,  NM_BARLABEL,          NULL, 0L, 0, (APTR)0,
  47   NM_ITEM,  "Complete path",      NULL, 0L, 0, (APTR)7,
  48   NM_ITEM,  "Toggle case",        NULL, 0L, 0, (APTR)0,
  49   NM_SUB,   "Character",          NULL, 0L, 0, (APTR)8,
  50   NM_SUB,   "Word",               NULL, 0L, 0, (APTR)9,
  51   NM_ITEM,  "Arithmetic",         NULL, 0L, 0, (APTR)0,
  52   NM_SUB,   "Increase",           NULL, 0L, 0, (APTR)10,
  53   NM_SUB,   "Decrease",           NULL, 0L, 0, (APTR)11,
  54   NM_SUB,   "To decimal",         NULL, 0L, 0, (APTR)12,
  55   NM_SUB,   "To hexadecimal",     NULL, 0L, 0, (APTR)13,
  56   NM_END,   NULL,                 NULL, 0L, 0, (APTR)0
  57 };
  58 */
  59
  60 //#ifndef MUIM_Backfill
  61 //#define MUIA_CustomBackfill                 0x80420a63
  62 //#define MUIM_Backfill                       0x80428d73
  63 //struct  MUIP_Backfill { ULONG MethodID; LONG left; LONG top; LONG right; LONG bottom; LONG xoffset; LONG yoffset; };
  64 //#endif
  65
  66 IPTR New(struct IClass *cl, Object *obj, struct opSet *msg)
  67 {
  68   if((obj = (Object *)DoSuperMethodA(cl, obj, (Msg)msg)))
  69   {
  70     struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
  71
  72 //    kprintf("OM_NEW by %s\n", FindTask(NULL)->tc_Node.ln_Name);
  73
  74     data->locale = OpenLocale(NULL);
  75     data->Contents = (STRPTR)SharedPoolAlloc(40);
  76     *data->Contents = '\0';
  77
  78 //    data->PopupMenu = MUI_MakeObject(MUIO_MenustripNM, PopupMenuData, NULL);
  79     SetAttrs(obj,  MUIA_FillArea,    FALSE,
  80 //              MUIA_ContextMenu,  data->PopupMenu,
  81 //              MUIA_CustomBackfill, TRUE,
  82               TAG_DONE );
  83
  84     if(FindTagItem(MUIA_Font, msg->ops_AttrList))
  85       setFlag(data->Flags, FLG_OwnFont);
  86
  87     if(FindTagItem(MUIA_Background, msg->ops_AttrList))
  88       setFlag(data->Flags, FLG_OwnBackground);
  89
  90     {
  91       struct TagItem *tag;
  92
  93       if((tag = FindTagItem(MUIA_Frame, msg->ops_AttrList)))
  94       {
  95         if(tag->ti_Data == MUIV_Frame_String)
  96           setFlag(data->Flags, FLG_SetFrame);
  97       }
  98     }
  99
 100     msg->MethodID = OM_SET;
 101     Set(cl, obj, (struct opSet *)msg);
 102     msg->MethodID = OM_NEW;
 103     data->BufferPos = 0;
 104
 105     return((IPTR)obj);
 106   }
 107   CoerceMethod(cl, obj, OM_DISPOSE);
 108
 109   return(FALSE);
 110 }
 111
 112 IPTR Dispose(struct IClass *cl, Object *obj, Msg msg)
 113 {
 114   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 115
 116 //  kprintf("OM_DISPOSE by %s\n", FindTask(NULL)->tc_Node.ln_Name);
 117 /*  if(data->PopupMenu)
 118     MUI_DisposeObject(data->PopupMenu);
 119 */
 120
 121   if(data->locale != NULL)
 122   {
 123     CloseLocale(data->locale);
 124     data->locale = NULL;
 125   }
 126
 127   return(DoSuperMethodA(cl, obj, msg));
 128 }
 129
 130 IPTR Export(struct IClass *cl, Object *obj, struct MUIP_Export *msg)
 131 {
 132   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 133   ULONG id;
 134
 135   if((id = (muiNotifyData(obj)->mnd_ObjectID)) != 0)
 136     DoMethod(msg->dataspace, MUIM_Dataspace_Add, data->Contents, strlen(data->Contents)+1, id);
 137
 138   return 0;
 139 }
 140
 141 IPTR Import(UNUSED struct IClass *cl, Object *obj, struct MUIP_Import *msg)
 142 {
 143   ULONG id;
 144
 145   if((id = (muiNotifyData(obj)->mnd_ObjectID)) != 0)
 146   {
 147       STRPTR contents = (STRPTR)DoMethod(msg->dataspace, MUIM_Dataspace_Find, id);
 148
 149 //  if(contents)
 150       set(obj, MUIA_String_Contents, contents);
 151   }
 152
 153   return 0;
 154 }
 155
 156 IPTR Setup(struct IClass *cl, Object *obj, struct MUI_RenderInfo *rinfo)
 157 {
 158   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 159
 160   ENTER();
 161
 162   InitConfig(obj, data);
 163
 164   if(DoSuperMethodA(cl, obj, (Msg)rinfo))
 165   {
 166 /*      ULONG color;
 167     if(DoMethod(obj, MUIM_GetConfigItem, 132, &color))
 168     {
 169         UBYTE image[6];
 170
 171       strcpy(image, "2:");
 172       strcat(image, (STRPTR)color);
 173       set(obj, MUIA_Background, image);
 174     }
 175 */
 176
 177     _flags(obj) |= (1<<7);
 178
 179     data->ehnode.ehn_Priority = 0;
 180     data->ehnode.ehn_Flags    = MUI_EHF_GUIMODE;
 181     data->ehnode.ehn_Object   = obj;
 182     data->ehnode.ehn_Class    = cl;
 183     data->ehnode.ehn_Events   = IDCMP_MOUSEBUTTONS | IDCMP_RAWKEY;
 184
 185     // setup the selection pointer
 186     if(data->SelectPointer == TRUE)
 187     {
 188       data->ehnode.ehn_Events |= IDCMP_MOUSEMOVE;
 189       SetupSelectPointer(data);
 190     }
 191
 192     DoMethod(_win(obj), MUIM_Window_AddEventHandler, &data->ehnode);
 193
 194     RETURN(TRUE);
 195     return(TRUE);
 196   }
 197
 198   RETURN(FALSE);
 199   return(FALSE);
 200 }
 201
 202 IPTR Cleanup(struct IClass *cl, Object *obj, Msg msg)
 203 {
 204   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 205
 206   // cleanup the selection pointer
 207   CleanupSelectPointer(data);
 208
 209   DoMethod(_win(obj), MUIM_Window_RemEventHandler, &data->ehnode);
 210
 211   // make sure the gadget is being set to inactive state
 212 /*
 213   if(isFlagSet(data->Flags, FLG_Active))
 214   {
 215     clearFlag(data->Flags, FLG_Active);
 216     clearFlag(data->ehnode.ehn_Events, IDCMP_MOUSEMOVE);
 217
 218     if(isFlagClear(data->Flags, FLG_OwnBackground))
 219       set(obj, MUIA_Background, data->InactiveBackground);
 220   }
 221 */
 222   FreeConfig(muiRenderInfo(obj), data);
 223
 224   return(DoSuperMethodA(cl, obj, msg));
 225 }
 226
 227 IPTR AskMinMax(struct IClass *cl, Object *obj, struct MUIP_AskMinMax *msg)
 228 {
 229   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 230   struct TextFont *font;
 231   WORD Height;
 232
 233   DoSuperMethodA(cl, obj, (Msg)msg);
 234
 235   font = data->Font ? data->Font : muiAreaData(obj)->mad_Font;
 236   Height = font->tf_YSize;
 237   msg->MinMaxInfo->MinHeight += Height;
 238   msg->MinMaxInfo->DefHeight += Height;
 239   msg->MinMaxInfo->MaxHeight += Height;
 240
 241   if(data->Width)
 242   {
 243     ULONG width;
 244
 245     SetFont(&data->rport, font);
 246     width = data->Width * TextLength(&data->rport, "n", 1);
 247
 248     msg->MinMaxInfo->MinWidth  += width;
 249     msg->MinMaxInfo->DefWidth  += width;
 250     msg->MinMaxInfo->MaxWidth  += width;
 251   }
 252   else
 253   {
 254     msg->MinMaxInfo->MinWidth  += 10;
 255     msg->MinMaxInfo->DefWidth  += 100;
 256     msg->MinMaxInfo->MaxWidth  += MBQ_MUI_MAXMAX;
 257   }
 258
 259   return(0);
 260 }
 261
 262 IPTR Show(struct IClass *cl, Object *obj, Msg msg)
 263 {
 264   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 265   struct MUI_AreaData *ad = muiAreaData(obj);
 266   struct BitMap *friendBMp = muiRenderInfo(obj)->mri_RastPort->BitMap;
 267   WORD  width, height, depth;
 268   struct TextFont *font = data->Font ? data->Font : ad->mad_Font;
 269
 270   DoSuperMethodA(cl, obj, msg);
 271
 272   width = ad->mad_Box.Width - ad->mad_subwidth;
 273   height = font->tf_YSize;
 274   depth = ((struct Library *)GfxBase)->lib_Version >= 39 ? GetBitMapAttr(friendBMp, BMA_DEPTH) : friendBMp->Depth;
 275
 276   InitRastPort(&data->rport);
 277   data->rport.BitMap = MUIG_AllocBitMap(width+40, height, depth, (IPTR)NULL, friendBMp);
 278   SetFont(&data->rport, font);
 279   SetDrMd(&data->rport, JAM1);
 280
 281   setFlag(data->Flags, FLG_Shown);
 282
 283   return(TRUE);
 284 }
 285
 286 IPTR Hide(struct IClass *cl, Object *obj, Msg msg)
 287 {
 288   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 289
 290 #ifdef __AROS__
 291   if(isFlagSet(data->Flags, FLG_Shown))
 292     DeinitRastPort(&data->rport);
 293 #endif
 294
 295   clearFlag(data->Flags, FLG_Shown);
 296
 297   // hide the selection pointer
 298   HideSelectPointer(obj, data);
 299
 300   MUIG_FreeBitMap(data->rport.BitMap);
 301
 302   return(DoSuperMethodA(cl, obj, msg));
 303 }
 304
 305 IPTR mDraw(struct IClass *cl, Object *obj, struct MUIP_Draw *msg)
 306 {
 307   DoSuperMethodA(cl, obj, (Msg)msg);
 308
 309   if(isFlagSet(msg->flags, MADF_DRAWUPDATE) || isFlagSet(msg->flags, MADF_DRAWOBJECT))
 310   {
 311     PrintString(cl, obj);
 312   }
 313
 314   return(0);
 315 }
 316
 317 IPTR HandleEvent(struct IClass *cl, Object *obj, struct MUIP_HandleEvent *msg)
 318 {
 319   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 320   IPTR result;
 321
 322   if(isFlagSet(data->Flags, FLG_Ghosted) || isFlagClear(data->Flags, FLG_Shown))
 323   {
 324     result = 0;
 325   }
 326   else
 327   {
 328     ULONG display_pos = data->DisplayPos;
 329
 330     result = HandleInput(cl, obj, msg);
 331     if(display_pos != data->DisplayPos)
 332       set(obj, MUIA_String_DisplayPos, data->DisplayPos);
 333
 334     if(!result && data->ForwardObject != NULL)
 335     {
 336       ULONG attr = 0;
 337
 338       switch(msg->muikey)
 339       {
 340         case MUIKEY_TOP:
 341           attr = MUIV_List_Active_Top;
 342         break;
 343
 344         case MUIKEY_BOTTOM:
 345           attr = MUIV_List_Active_Bottom;
 346         break;
 347
 348         case MUIKEY_UP:
 349           attr = MUIV_List_Active_Up;
 350         break;
 351
 352         case MUIKEY_DOWN:
 353           attr = MUIV_List_Active_Down;
 354         break;
 355
 356         case MUIKEY_PAGEUP:
 357           attr = MUIV_List_Active_PageUp;
 358         break;
 359
 360         case MUIKEY_PAGEDOWN:
 361           attr = MUIV_List_Active_PageDown;
 362         break;
 363       }
 364
 365       if(attr != 0)
 366       {
 367         set(data->ForwardObject, MUIA_List_Active, attr);
 368         result = MUI_EventHandlerRC_Eat;
 369       }
 370     }
 371   }
 372
 373   return result;
 374 }
 375
 376 IPTR GoActive(struct IClass *cl, Object *obj, UNUSED Msg msg)
 377 {
 378   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 379
 380   D(DBF_INPUT, "GoActive: %08lx", obj);
 381
 382   setFlag(data->Flags, FLG_Active);
 383   setFlag(data->Flags, FLG_FreshActive);
 384 /*
 385   DoMethod(_win(obj), MUIM_Window_RemEventHandler, &data->ehnode);
 386   setFlag(data->ehnode.ehn_Events, IDCMP_RAWKEY);
 387   DoMethod(_win(obj), MUIM_Window_AddEventHandler, &data->ehnode);
 388 */
 389   if(data->Original != NULL)
 390     SharedPoolFree(data->Original);
 391
 392   if((data->Original = (STRPTR)SharedPoolAlloc(strlen(data->Contents)+1)) != NULL)
 393     strlcpy(data->Original, data->Contents, strlen(data->Contents+1));
 394
 395   // select everything if this is necessary or requested
 396   if((data->SelectOnActive == TRUE && isFlagClear(data->Flags, FLG_MouseButtonDown) && isFlagClear(data->Flags, FLG_ForceSelectOff)) ||
 397      isFlagSet(data->Flags, FLG_ForceSelectOn))
 398   {
 399     data->BlockStart = 0;
 400     data->BlockStop = strlen(data->Contents);
 401     setFlag(data->Flags, FLG_BlockEnabled);
 402   }
 403
 404   if(isFlagClear(data->Flags, FLG_OwnBackground))
 405     set(obj, MUIA_Background, data->ActiveBackground);
 406   else
 407     MUI_Redraw(obj, MADF_DRAWUPDATE);
 408
 409   return TRUE;
 410 }
 411
 412 IPTR GoInactive(struct IClass *cl, Object *obj, UNUSED Msg msg)
 413 {
 414   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 415
 416   D(DBF_INPUT, "GoInActive: %08lx", obj);
 417
 418   // clean an eventually marked block and the
 419   // active state flag of the gadget
 420   clearFlag(data->Flags, FLG_BlockEnabled);
 421   clearFlag(data->Flags, FLG_Active);
 422   clearFlag(data->Flags, FLG_FreshActive);
 423 /*
 424   DoMethod(_win(obj), MUIM_Window_RemEventHandler, &data->ehnode);
 425   clearFlag(data->ehnode.ehn_Events, IDCMP_MOUSEMOVE);
 426   DoMethod(_win(obj), MUIM_Window_AddEventHandler, &data->ehnode);
 427 */
 428
 429   if(isFlagClear(data->Flags, FLG_OwnBackground))
 430     set(obj, MUIA_Background, data->InactiveBackground);
 431   else
 432     MUI_Redraw(obj, MADF_DRAWUPDATE);
 433
 434   return TRUE;
 435 }
 436
 437 DISPATCHER(_Dispatcher)
 438 {
 439   IPTR result = TRUE;
 440
 441   ENTER();
 442
 443   switch(msg->MethodID)
 444   {
 445     case OM_NEW:
 446       result = New(cl, obj, (struct opSet *)msg);
 447     break;
 448
 449     case MUIM_Setup:
 450       result = Setup(cl, obj, (struct MUI_RenderInfo *)msg);
 451     break;
 452
 453     case MUIM_Show:
 454       result = Show(cl, obj, msg);
 455     break;
 456
 457     case MUIM_AskMinMax:
 458       result = AskMinMax(cl, obj, (struct MUIP_AskMinMax *)msg);
 459     break;
 460
 461     case MUIM_Draw:
 462       result = mDraw(cl, obj, (struct MUIP_Draw *)msg);
 463     break;
 464
 465     case OM_GET:
 466       result = Get(cl, obj, (struct opGet *)msg);
 467     break;
 468
 469     case OM_SET:
 470       Set(cl, obj, (struct opSet *)msg);
 471       result = DoSuperMethodA(cl, obj, msg);
 472     break;
 473
 474     case MUIM_HandleEvent:
 475       result = HandleEvent(cl, obj, (struct MUIP_HandleEvent *)msg);
 476     break;
 477
 478     case MUIM_GoActive:
 479       result = GoActive(cl, obj, msg);
 480     break;
 481
 482     case MUIM_GoInactive:
 483       result = GoInactive(cl, obj, msg);
 484     break;
 485
 486     case MUIM_Hide:
 487       result = Hide(cl, obj, msg);
 488     break;
 489
 490     case MUIM_Cleanup:
 491       result = Cleanup(cl, obj, msg);
 492     break;
 493
 494     case OM_DISPOSE:
 495       result = Dispose(cl, obj, msg);
 496     break;
 497
 498     case MUIM_Export:
 499       result = Export(cl, obj, (struct MUIP_Export *)msg);
 500     break;
 501
 502     case MUIM_Import:
 503       result = Import(cl, obj, (struct MUIP_Import *)msg);
 504     break;
 505
 506     case MUIM_BetterString_ClearSelected:
 507     {
 508       // forward the clear request to our new DoAction method
 509       // which in fact will do the very same, but a bit more clever
 510       DoMethod(obj, MUIM_BetterString_DoAction, MUIV_BetterString_DoAction_Delete);
 511     }
 512     break;
 513
 514     case MUIM_BetterString_Insert:
 515     {
 516       struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 517       struct MUIP_BetterString_Insert *ins_msg = (struct MUIP_BetterString_Insert *)msg;
 518       UWORD pos;
 519
 520       switch(ins_msg->pos)
 521       {
 522 /*        case MUIV_BetterString_Insert_StartOfString:
 523           pos = 0;
 524           break;
 525 */
 526         case MUIV_BetterString_Insert_EndOfString:
 527           pos = strlen(data->Contents);
 528           break;
 529
 530         case MUIV_BetterString_Insert_BufferPos:
 531           pos = data->BufferPos;
 532           break;
 533
 534         default:
 535           pos = ins_msg->pos;
 536           break;
 537       }
 538       Overwrite(ins_msg->text, pos, 0, data);
 539       clearFlag(data->Flags, FLG_BlockEnabled);
 540       MUI_Redraw(obj, MADF_DRAWUPDATE);
 541     }
 542     break;
 543
 544     case MUIM_BetterString_DoAction:
 545       result = mDoAction(cl, obj, (struct MUIP_BetterString_DoAction *)msg);
 546     break;
 547
 548
 549 /*
 550     case MUIM_Backfill:
 551     {
 552       struct MUIP_Backfill *fill_msg = (struct MUIP_Backfill *)msg;
 553
 554       if(isFlagClear(data->Flags, FLG_Active))
 555         DoMethod(obj, MUIM_DrawBackground, fill_msg->left, fill_msg->top, fill_msg->right-fill_msg->left+1, fill_msg->bottom-fill_msg->top+1, fill_msg->xoffset, fill_msg->yoffset);
 556 //      printf("%ld, %ld, %ld, %ld\n%ld, %ld\n", fill_msg->left, fill_msg->top, fill_msg->right, fill_msg->bottom, fill_msg->xoffset, fill_msg->yoffset);
 557     }
 558 */
 559     case MUIM_BetterString_FileNameStart:
 560       result = FileNameStart((struct MUIP_BetterString_FileNameStart *)msg);
 561     break;
 562
 563     default:
 564       result = DoSuperMethodA(cl, obj, msg);
 565     break;
 566   }
 567
 568   RETURN(result);
 569   return(result);
 570 }