workbench/libs/muimaster/classes/notify.c

   1 /*
   2     Copyright © 2002-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <stdlib.h>
   7 #include <string.h>
   8
   9 #include <exec/types.h>
  10 #include <clib/alib_protos.h>
  11 #include <libraries/commodities.h>
  12 #include <proto/commodities.h>
  13 #include <proto/exec.h>
  14 #include <proto/intuition.h>
  15 #include <proto/utility.h>
  16 #include <proto/muimaster.h>
  17
  18 #include "muimaster_intern.h"
  19 #include "mui.h"
  20 #include "support.h"
  21
  22 #include "notify.h"
  23
  24 #define MYDEBUG
  25 #include "debug.h"
  26
  27 extern struct Library *MUIMasterBase;
  28
  29 AROS_UFH2S(void, cpy_func,
  30     AROS_UFHA(UBYTE, chr, D0),
  31     AROS_UFHA(STRPTR *, strPtrPtr, A3))
  32 {
  33     AROS_USERFUNC_INIT
  34
  35     *(*strPtrPtr)++ = chr;
  36
  37     AROS_USERFUNC_EXIT
  38 }
  39
  40 AROS_UFH2S(void, len_func,
  41     AROS_UFHA(UBYTE, chr, D0),
  42     AROS_UFHA(LONG *, lenPtr, A3))
  43 {
  44     AROS_USERFUNC_INIT
  45
  46     (*lenPtr)++;
  47
  48     AROS_USERFUNC_EXIT
  49 }
  50
  51
  52 /*
  53  * Notify class is superclass of all other MUI classes.
  54  */
  55
  56 /*
  57 MUIA_ApplicationObject [..G]   done
  58 MUIA_AppMessage [..G]          done
  59 MUIA_HelpLine [ISG]            done
  60 MUIA_HelpNode [ISG]            done
  61 MUIA_NoNotify [.S.]            done
  62 MUIA_ObjectID [ISG]            done
  63 MUIA_Parent [..G]              done
  64 MUIA_Revision [..G]            done
  65 MUIA_UserData [ISG]            done
  66 MUIA_Version [..G]             done
  67
  68 MUIM_CallHook                  done
  69 MUIM_Export                    dummy & redefine in subclasses w/ children
  70 MUIM_FindUData                 redefine in subclasses w/ children
  71 MUIM_GetConfigItem
  72 MUIM_GetUData                  redefine in subclasses w/ children
  73 MUIM_Import                    dummy & redefine in subclasses w/ children
  74 MUIM_KillNotify                done
  75 MUIM_KillNotifyObj             done (semantic ?)
  76 MUIM_MultiSet                  done
  77 MUIM_NoNotifySet               done
  78 MUIM_Notify                    done
  79 MUIM_Set                       done
  80 MUIM_SetAsString               done
  81 MUIM_SetUData                  redefine in subclasses w/ children
  82 MUIM_SetUDataOnce              redefine in subclasses w/ children
  83 MUIM_WriteLong                 done
  84 MUIM_WriteString               done
  85 */
  86
  87 static const int __version = 1;
  88 static const int __revision = 1;
  89
  90 struct MUI_NotifyAttributes
  91 {
  92     STRPTR                 na_HelpNode;
  93     LONG                   na_HelpLine;
  94     struct AppMessage     *na_AppMessage;
  95 };
  96
  97 /*
  98  * Notification handler
  99  */
 100 typedef struct NotifyNode
 101 {
 102     struct MinNode nn_Node;
 103     BOOL nn_Active;     /* TRUE if notification is currently being handled */
 104                         /* It's used to prevent loops */
 105     ULONG nn_TrigAttr;
 106     IPTR nn_TrigVal;
 107     APTR nn_DestObj;
 108     ULONG nn_NumParams;
 109     IPTR *nn_Params;    /* FIXME: use nn_Params[1] and tweak stuff below */
 110     IPTR *nn_NewParams; /* For MUIV_EveryTime */
 111 } *NNode;
 112
 113 typedef struct NotifyNodeIX
 114 {
 115     struct NotifyNode nn;
 116     IX ix;
 117 } *NNodeIX;
 118
 119 static struct NotifyNode *CreateNNode(struct MUI_NotifyData *data,
 120     struct MUIP_Notify *msg)
 121 {
 122     ULONG i, paramsize;
 123
 124     struct NotifyNode *nnode;
 125
 126     if ((msg->TrigAttr == MUIA_Window_InputEvent)
 127         && (msg->TrigVal != MUIV_EveryTime))
 128     {
 129         IX ix = { IX_VERSION };
 130
 131         if (ParseIX((CONST_STRPTR) msg->TrigVal, &ix) != 0)
 132             return NULL;
 133
 134         if ((nnode =
 135                 (struct NotifyNode *)mui_alloc_struct(struct NotifyNodeIX)))
 136         {
 137             ((struct NotifyNodeIX *)nnode)->ix = ix;
 138         }
 139     }
 140     else
 141     {
 142         nnode = mui_alloc_struct(struct NotifyNode);
 143     }
 144
 145     if (!nnode)
 146         return NULL;
 147
 148     nnode->nn_Active = FALSE;
 149     nnode->nn_TrigAttr = msg->TrigAttr;
 150     nnode->nn_TrigVal = msg->TrigVal;
 151     nnode->nn_DestObj = msg->DestObj;
 152     nnode->nn_NumParams = msg->FollowParams;
 153
 154     /* Allocate one more IPTR (FollowParams + 1) as some ext apps/classes
 155        forget trailing NULLs in methods like MUIM_MultiSet and MUI seems
 156        like it can live with that (without crashing) */
 157
 158     paramsize = (msg->FollowParams + 1);
 159     if (msg->TrigVal == MUIV_EveryTime)
 160     {
 161         paramsize *= 2;
 162     }
 163
 164     if ((nnode->nn_Params = (IPTR *) mui_alloc(paramsize * sizeof(IPTR))))
 165     {
 166         IPTR *par = (IPTR *) & msg->FollowParams;
 167
 168         for (i = 0; i < msg->FollowParams; i++)
 169         {
 170             nnode->nn_Params[i] = *(par + i + 1);
 171         }
 172
 173         if (msg->TrigVal == MUIV_EveryTime)
 174         {
 175             nnode->nn_NewParams = nnode->nn_Params + msg->FollowParams + 1;
 176             for (i = 0; i < msg->FollowParams; i++)
 177             {
 178                 nnode->nn_NewParams[i] = *(par + i + 1);
 179             }
 180         }
 181
 182         return nnode;
 183     }
 184
 185     mui_free(nnode);
 186
 187     return NULL;
 188 }
 189
 190 static void DeleteNNode(struct MUI_NotifyData *data,
 191     struct NotifyNode *nnode)
 192 {
 193     mui_free(nnode->nn_Params);
 194     mui_free(nnode);
 195 }
 196
 197
 198 IPTR Notify__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg);
 199
 200 /*
 201  * OM_NEW
 202  */
 203 IPTR Notify__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 204 {
 205     struct MUI_NotifyData *data;
 206     struct TagItem *tags = msg->ops_AttrList;
 207     struct TagItem *tag;
 208
 209     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
 210     if (!obj)
 211         return FALSE;
 212
 213     data = INST_DATA(cl, obj);
 214
 215     data->mnd_Attributes = mui_alloc_struct(struct MUI_NotifyAttributes);
 216     if (data->mnd_Attributes == NULL)
 217     {
 218         CoerceMethod(cl, obj, OM_DISPOSE);
 219         return FALSE;
 220     }
 221
 222     while ((tag = NextTagItem(&tags)) != NULL)
 223     {
 224         switch (tag->ti_Tag)
 225         {
 226         case MUIA_HelpLine:
 227             data->mnd_Attributes->na_HelpLine = (LONG) tag->ti_Data;
 228             break;
 229
 230         case MUIA_HelpNode:
 231             data->mnd_Attributes->na_HelpNode = (STRPTR) tag->ti_Data;
 232             break;
 233
 234         case MUIA_ObjectID:
 235             data->mnd_ObjectID = (ULONG) tag->ti_Data;
 236             break;
 237
 238         case MUIA_UserData:
 239             data->mnd_UserData = (IPTR) tag->ti_Data;
 240             break;
 241         }
 242     }
 243
 244     return (IPTR) obj;
 245 }
 246
 247
 248 /*
 249  * OM_DISPOSE
 250  */
 251 IPTR Notify__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 252 {
 253     struct MinNode *node, *tmp;
 254     struct MUI_NotifyData *data = INST_DATA(cl, obj);
 255
 256     mui_free(data->mnd_Attributes);
 257
 258     if (data->mnd_NotifyList)
 259     {
 260         for (node = data->mnd_NotifyList->mlh_Head; node->mln_Succ;
 261             node = tmp)
 262         {
 263             tmp = node->mln_Succ;
 264             DeleteNNode(data, (struct NotifyNode *)node);
 265         }
 266         mui_free(data->mnd_NotifyList);
 267     }
 268
 269     return DoSuperMethodA(cl, obj, msg);
 270 }
 271
 272 static void check_notify(NNode nnode, Object *obj, struct TagItem *tag)
 273 {
 274     IPTR *params;
 275     APTR destobj;
 276     int i;
 277     BOOL donotify = FALSE;
 278
 279     /* is it the good attribute ? */
 280     if (tag->ti_Tag != nnode->nn_TrigAttr)
 281         return;
 282
 283     /* Is the notification already being performed? */
 284     if (nnode->nn_Active)
 285     {
 286 #if DEBUG
 287         static int counter;
 288
 289         D(bug("Notifyloop detected! (#%d)\n", counter++));
 290         D(bug("  Source object: 0x%x", obj));
 291
 292         switch ((IPTR) nnode->nn_DestObj)
 293         {
 294         case MUIV_Notify_Application:
 295             D(bug("  Dest object: 0x%x (MUIV_Notify_Application)\n",
 296                     _app(obj)));
 297             break;
 298         case MUIV_Notify_Self:
 299             D(bug("  Dest object: 0x%x (MUIV_Notify_Self)\n", obj));
 300             destobj = obj;
 301             break;
 302         case MUIV_Notify_Window:
 303             if (muiRenderInfo(obj)) /* otherwise _win(obj) does NULL access! */
 304             {
 305                 D(bug("  Dest object: 0x%x (MUIV_Notify_Window)\n",
 306                         _win(obj)));
 307             }
 308             else
 309             {
 310                 D(bug("  Dest object: INVALID "
 311                     "(MUIV_Notify_Window, but no muiRenderInfo)\n"));
 312             }
 313             break;
 314         default:
 315             D(bug("  Dest object: 0x%x\n", nnode->nn_DestObj));
 316             break;
 317         }
 318         D(bug("  Attribute: 0x%x   Value: 0x%x\n", tag->ti_Tag,
 319                 tag->ti_Data));
 320
 321 #endif
 322         return;
 323     }
 324
 325     if (nnode->nn_TrigVal == MUIV_EveryTime)
 326     {
 327         donotify = TRUE;
 328     }
 329     else if (nnode->nn_TrigAttr == MUIA_Window_InputEvent)
 330     {
 331         if (MatchIX((struct InputEvent *)tag->ti_Data,
 332                 &((struct NotifyNodeIX *)nnode)->ix))
 333         {
 334             donotify = TRUE;
 335         }
 336     }
 337     else if (nnode->nn_TrigVal == tag->ti_Data)
 338     {
 339         donotify = TRUE;
 340     }
 341
 342     if (donotify)
 343     {
 344         switch ((IPTR) nnode->nn_DestObj)
 345         {
 346         case MUIV_Notify_Application:
 347             destobj = _app(obj);
 348             break;
 349         case MUIV_Notify_Self:
 350             destobj = obj;
 351             break;
 352         case MUIV_Notify_Window:
 353             if (muiRenderInfo(obj)) /* otherwise _win(obj) does NULL access! */
 354             {
 355                 destobj = _win(obj);
 356             }
 357             else
 358             {
 359                 return;
 360             }
 361             break;
 362         default:
 363             destobj = nnode->nn_DestObj;
 364         }
 365
 366         params = nnode->nn_Params;
 367         if (nnode->nn_TrigVal == MUIV_EveryTime)
 368         {
 369             params = nnode->nn_NewParams;
 370
 371             for (i = 1; i < nnode->nn_NumParams; i++)
 372             {
 373                 switch (nnode->nn_Params[i])
 374                 {
 375                 case MUIV_TriggerValue:
 376                     params[i] = tag->ti_Data;
 377                     break;
 378
 379                 case MUIV_NotTriggerValue:
 380                     params[i] = !tag->ti_Data;
 381                     break;
 382                 }
 383             }
 384         }
 385
 386         nnode->nn_Active = TRUE;
 387
 388         /* call method */
 389         DoMethodA(destobj, (Msg) params);
 390
 391         nnode->nn_Active = FALSE;
 392     }
 393 }
 394
 395 /*
 396  * OM_SET
 397  */
 398 IPTR Notify__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 399 {
 400     struct MUI_NotifyData *data = INST_DATA(cl, obj);
 401     struct TagItem *tags = msg->ops_AttrList;
 402     BOOL no_notify = FALSE;
 403     struct TagItem *tag;
 404     struct MinNode *node;
 405
 406     /* There are many ways to find out what tag items provided by set()
 407      ** we do know. The best way should be using NextTagItem() and simply
 408      ** browsing through the list.
 409      */
 410     while ((tag = NextTagItem(&tags)) != NULL)
 411     {
 412         switch (tag->ti_Tag)
 413         {
 414       case MUIA_AppMessage:
 415           data->mnd_Attributes->na_AppMessage = (struct AppMessage *)tag->ti_Data;
 416           break;
 417
 418         case MUIA_HelpLine:
 419             data->mnd_Attributes->na_HelpLine = (LONG) tag->ti_Data;
 420             break;
 421
 422         case MUIA_HelpNode:
 423             data->mnd_Attributes->na_HelpNode = (STRPTR) tag->ti_Data;
 424             break;
 425
 426         case MUIA_NoNotify:
 427             if (tag->ti_Data == TRUE)
 428                 no_notify = TRUE;
 429             break;
 430
 431         case MUIA_ObjectID:
 432             data->mnd_ObjectID = (ULONG) tag->ti_Data;
 433             break;
 434
 435         case MUIA_UserData:
 436             data->mnd_UserData = tag->ti_Data;
 437             break;
 438         }
 439     }
 440
 441     /*
 442      * check for notifications
 443      */
 444     if (!data->mnd_NotifyList || no_notify)
 445         return 0;
 446
 447     tags = msg->ops_AttrList;
 448     while ((tag = NextTagItem(&tags)))
 449     {
 450         for (node = data->mnd_NotifyList->mlh_Head;
 451             node->mln_Succ; node = node->mln_Succ)
 452         {
 453             check_notify((NNode) node, obj, tag);
 454         }
 455     }
 456
 457     return 0;
 458 }
 459
 460
 461 /*
 462  * OM_GET
 463  */
 464 IPTR Notify__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 465 {
 466 /* small macro to simplify return value storage */
 467 #define STORE *(msg->opg_Storage)
 468
 469     struct MUI_NotifyData *data = INST_DATA(cl, obj);
 470
 471 //kprintf("*** Notify->GET\n");
 472     switch (msg->opg_AttrID)
 473     {
 474     case MUIA_ApplicationObject:
 475         if (data->mnd_GlobalInfo)
 476             STORE = (IPTR) data->mnd_GlobalInfo->mgi_ApplicationObject;
 477         else
 478             STORE = 0;
 479         return TRUE;
 480
 481     case MUIA_AppMessage:
 482         STORE = (IPTR) data->mnd_Attributes->na_AppMessage;
 483         return TRUE;
 484
 485     case MUIA_HelpLine:
 486         STORE = (IPTR) data->mnd_Attributes->na_HelpLine;
 487         return TRUE;
 488
 489     case MUIA_HelpNode:
 490         STORE = (IPTR) data->mnd_Attributes->na_HelpNode;
 491         return TRUE;
 492
 493     case MUIA_ObjectID:
 494         STORE = (IPTR) data->mnd_ObjectID;
 495         return TRUE;
 496
 497     case MUIA_Parent:
 498         STORE = (IPTR) data->mnd_ParentObject;
 499         return TRUE;
 500
 501     case MUIA_Revision:
 502         STORE = __revision;
 503         return TRUE;
 504
 505     case MUIA_UserData:
 506         STORE = data->mnd_UserData;
 507         return TRUE;
 508
 509     case MUIA_Version:
 510         STORE = __version;
 511         return TRUE;
 512     }
 513
 514     return DoSuperMethodA(cl, obj, (Msg) msg);
 515 }
 516
 517
 518 /*
 519  * MUIM_CallHook : Call a standard amiga callback hook, defined by a Hook
 520  * structure.
 521  */
 522 IPTR Notify__MUIM_CallHook(struct IClass *cl, Object *obj,
 523     struct MUIP_CallHook *msg)
 524 {
 525     if (msg->Hook->h_Entry)
 526         return CallHookPkt(msg->Hook, obj, &msg->param1);
 527     else
 528         return FALSE;
 529 }
 530
 531
 532 /*
 533  * MUIM_Export : to export an object's "contents" to a dataspace object.
 534  */
 535 /* nothing to export */
 536
 537 /*
 538  * MUIM_FindUData : tests if the MUIA_UserData of the object
 539  * contains the given <udata> and returns the object pointer in this case.
 540  */
 541 IPTR Notify__MUIM_FindUData(struct IClass *cl, Object *obj,
 542     struct MUIP_FindUData *msg)
 543 {
 544     struct MUI_NotifyData *data = INST_DATA(cl, obj);
 545
 546     if (data->mnd_UserData == msg->udata)
 547     {
 548         return (IPTR) obj;
 549     }
 550     return 0L;
 551 }
 552
 553
 554 /*
 555  * MUIM_GetUData : This method tests if the MUIA_UserData of the object
 556  * contains the given <udata> and gets <attr> to <storage> for itself
 557  * in this case.
 558  */
 559 IPTR Notify__MUIM_GetUData(struct IClass *cl, Object *obj,
 560     struct MUIP_GetUData *msg)
 561 {
 562     struct MUI_NotifyData *data = INST_DATA(cl, obj);
 563
 564     if (data->mnd_UserData == msg->udata)
 565     {
 566         get(obj, msg->attr, msg->storage);
 567         return TRUE;
 568     }
 569     return FALSE;
 570 }
 571
 572
 573 /*
 574  * MUIM_Import : to import an object's "contents" from a dataspace object.
 575  */
 576 /* nothing to import */
 577
 578 /*
 579  * MUIM_KillNotify : kills previously given notifications on specific attributes.
 580  */
 581 IPTR Notify__MUIM_KillNotify(struct IClass *cl, Object *obj,
 582     struct MUIP_KillNotify *msg)
 583 {
 584     struct MUI_NotifyData *data = INST_DATA(cl, obj);
 585     struct MinNode *node;
 586     struct NotifyNode *nnode;
 587
 588     if (!data->mnd_NotifyList)
 589         return 0;
 590
 591     for (node = data->mnd_NotifyList->mlh_Head; node->mln_Succ;
 592         node = node->mln_Succ)
 593     {
 594         nnode = (NNode) node;
 595         if (msg->TrigAttr == nnode->nn_TrigAttr)
 596         {
 597             Remove((struct Node *)node);
 598             DeleteNNode(data, nnode);
 599             return 1;
 600         }
 601     }
 602     return 0;
 603 }
 604
 605
 606 /*
 607  * MUIM_KillNotifyObj : originally undocumented !
 608  * Supposed to kill a notification with a given attr and a given dest.
 609  */
 610 IPTR Notify__MUIM_KillNotifyObj(struct IClass *cl, Object *obj,
 611     struct MUIP_KillNotifyObj *msg)
 612 {
 613     struct MUI_NotifyData *data = INST_DATA(cl, obj);
 614     struct MinNode *node;
 615     struct NotifyNode *nnode;
 616
 617     if (!data->mnd_NotifyList)
 618         return 0;
 619
 620     for (node = data->mnd_NotifyList->mlh_Head; node->mln_Succ;
 621         node = node->mln_Succ)
 622     {
 623         nnode = (NNode) node;
 624         if ((msg->TrigAttr == nnode->nn_TrigAttr)
 625             && (msg->dest == nnode->nn_DestObj))
 626         {
 627             Remove((struct Node *)node);
 628             DeleteNNode(data, nnode);
 629             return 1;
 630         }
 631     }
 632     return 0;
 633 }
 634
 635
 636 /*
 637  * MUIM_MultiSet : Set an attribute for multiple objects.
 638  */
 639 IPTR Notify__MUIM_MultiSet(struct IClass *cl, Object *obj,
 640     struct MUIP_MultiSet *msg)
 641 {
 642     IPTR *destobj_p;
 643     for (destobj_p = (IPTR *) & msg->obj; (*destobj_p) != 0; destobj_p++)
 644     {
 645         set((APTR) *destobj_p, msg->attr, msg->val);
 646     }
 647     return TRUE;
 648 }
 649
 650
 651 /*
 652  * MUIM_NoNotifySet : Acts like MUIM_Set but doesn't trigger any notification.
 653  */
 654 IPTR Notify__MUIM_NoNotifySet(struct IClass *cl, Object *obj,
 655     struct MUIP_NoNotifySet *msg)
 656 {
 657     return SetAttrs(obj, MUIA_NoNotify, TRUE, msg->attr, msg->val,
 658         TAG_DONE);
 659 }
 660
 661
 662 /*
 663  * MUIM_Notify : Add a notification event handler to an object.
 664  */
 665 IPTR Notify__MUIM_Notify(struct IClass *cl, Object *obj,
 666     struct MUIP_Notify *msg)
 667 {
 668     struct MUI_NotifyData *data = INST_DATA(cl, obj);
 669     struct NotifyNode *nnode;
 670
 671     if (msg->FollowParams < 1)
 672         return FALSE;
 673
 674     if (data->mnd_NotifyList == NULL)
 675     {
 676         if (!(data->mnd_NotifyList = mui_alloc_struct(struct MinList)))
 677               return FALSE;
 678         NewList((struct List *)data->mnd_NotifyList);
 679     }
 680
 681     nnode = CreateNNode(data, msg);
 682     if (NULL == nnode)
 683         return FALSE;
 684
 685     AddTail((struct List *)data->mnd_NotifyList, (struct Node *)nnode);
 686     return TRUE;
 687 }
 688
 689
 690 /*
 691  * MUIM_Set : Set an attribute to a value, useful within a MUIM_Notify method.
 692  */
 693 IPTR Notify__MUIM_Set(struct IClass *cl, Object *obj,
 694     struct MUIP_Set *msg)
 695 {
 696     return set(obj, msg->attr, msg->val);
 697 }
 698
 699 /*
 700  * MUIM_SetAsString : Set a (text kind) attribute to a string.
 701  */
 702 IPTR Notify__MUIM_SetAsString(struct IClass *cl, Object *obj,
 703     struct MUIP_SetAsString *msg)
 704 {
 705     STRPTR txt;
 706     LONG txt_len;
 707
 708     txt_len = 0;
 709     RawDoFmt(msg->format, (RAWARG)&msg->val,
 710         (VOID_FUNC) AROS_ASMSYMNAME(len_func), &txt_len);
 711
 712 /*  D(bug("Notify_SetAsString: fmt=%s, txtlen=%d\n", msg->format, txt_len)); */
 713     txt = AllocVec(txt_len + 1, 0);
 714     if (NULL == txt)
 715         return FALSE;
 716
 717     {
 718         STRPTR txtptr = txt;
 719         RawDoFmt(msg->format, (RAWARG)&msg->val,
 720             (VOID_FUNC) AROS_ASMSYMNAME(cpy_func), &txtptr);
 721     }
 722
 723     set(obj, msg->attr, (IPTR) txt);
 724     FreeVec(txt);
 725
 726     return TRUE;
 727 }
 728
 729
 730 /*
 731  * MUIM_SetUData : This method tests if the MUIA_UserData of the object
 732  * contains the given <udata> and sets <attr> to <val> for itself in this case.
 733  */
 734 IPTR Notify__MUIM_SetUData(struct IClass *cl, Object *obj,
 735     struct MUIP_SetUData *msg)
 736 {
 737     struct MUI_NotifyData *data = INST_DATA(cl, obj);
 738
 739     if (data->mnd_UserData == msg->udata)
 740     {
 741         set(obj, msg->attr, msg->val);
 742         return TRUE;
 743     }
 744     return FALSE;
 745 }
 746
 747
 748 /*
 749  * MUIM_WriteLong : This method simply writes a longword somewhere to memory.
 750  */
 751 IPTR Notify__MUIM_WriteLong(struct IClass *cl, Object *obj,
 752     struct MUIP_WriteLong *msg)
 753 {
 754     *(msg->memory) = msg->val;
 755     return TRUE;
 756 }
 757
 758
 759 /*
 760  * MUIM_WriteString : This method simply copies a string somewhere to memory.
 761  */
 762 IPTR Notify__MUIM_WriteString(struct IClass *cl, Object *obj,
 763     struct MUIP_WriteString *msg)
 764 {
 765     strcpy(msg->memory, msg->str);
 766     return TRUE;
 767 }
 768
 769 /**************************************************************************
 770  MUIM_ConnectParent
 771 **************************************************************************/
 772 IPTR Notify__MUIM_ConnectParent(struct IClass *cl, Object *obj,
 773     struct MUIP_ConnectParent *msg)
 774 {
 775     //struct MUI_NotifyData *data = INST_DATA(cl, obj);
 776
 777     /* Objects only have parents if they are inside a group or family object;
 778      ** no idea why MUIA_Parent belongs to the notify class then
 779      */
 780 /*    data->mnd_ParentObject = msg->parent;*/
 781     muiGlobalInfo(obj) = muiGlobalInfo(msg->parent);
 782     return TRUE;
 783 }
 784
 785 /**************************************************************************
 786  MUIM_DisconnectParent
 787 **************************************************************************/
 788 IPTR Notify__MUIM_DisconnectParent(struct IClass *cl, Object *obj,
 789     struct MUIP_DisconnectParent *msg)
 790 {
 791     //struct MUI_NotifyData *data = INST_DATA(cl, obj);
 792 /*    data->mnd_ParentObject = NULL;*/
 793 #if 0
 794     /* Some apps (YAM) seem to access this even after disconnection */
 795     muiGlobalInfo(obj) = NULL;
 796 #endif
 797     return 0;
 798 }
 799
 800 /**************************************************************************
 801  MUIM_GetConfigItem
 802 **************************************************************************/
 803 IPTR Notify__MUIM_GetConfigItem(struct IClass *cl, Object *obj,
 804     struct MUIP_GetConfigItem *msg)
 805 {
 806     IPTR found =
 807         DoMethod(muiGlobalInfo(obj)->mgi_Configdata, MUIM_Dataspace_Find,
 808         msg->id);
 809
 810     if (found)
 811     {
 812         *msg->storage = found;
 813         return TRUE;
 814     }
 815     else
 816     {
 817         return FALSE;
 818     }
 819 }
 820
 821
 822 BOOPSI_DISPATCHER(IPTR, Notify_Dispatcher, cl, obj, msg)
 823 {
 824     switch (msg->MethodID)
 825     {
 826     case OM_NEW:
 827         return Notify__OM_NEW(cl, obj, (struct opSet *)msg);
 828     case OM_DISPOSE:
 829         return Notify__OM_DISPOSE(cl, obj, msg);
 830     case OM_SET:
 831         return Notify__OM_SET(cl, obj, (struct opSet *)msg);
 832     case OM_GET:
 833         return Notify__OM_GET(cl, obj, (struct opGet *)msg);
 834     case MUIM_CallHook:
 835         return Notify__MUIM_CallHook(cl, obj, (APTR) msg);
 836     case MUIM_Export:
 837         return TRUE;
 838     case MUIM_FindUData:
 839         return Notify__MUIM_FindUData(cl, obj, (APTR) msg);
 840     case MUIM_GetUData:
 841         return Notify__MUIM_GetUData(cl, obj, (APTR) msg);
 842     case MUIM_Import:
 843         return TRUE;
 844     case MUIM_KillNotify:
 845         return Notify__MUIM_KillNotify(cl, obj, (APTR) msg);
 846     case MUIM_KillNotifyObj:
 847         return Notify__MUIM_KillNotifyObj(cl, obj, (APTR) msg);
 848     case MUIM_MultiSet:
 849         return Notify__MUIM_MultiSet(cl, obj, (APTR) msg);
 850     case MUIM_NoNotifySet:
 851         return Notify__MUIM_NoNotifySet(cl, obj, (APTR) msg);
 852     case MUIM_Notify:
 853         return Notify__MUIM_Notify(cl, obj, (APTR) msg);
 854     case MUIM_Set:
 855         return Notify__MUIM_Set(cl, obj, (APTR) msg);
 856     case MUIM_SetAsString:
 857         return Notify__MUIM_SetAsString(cl, obj, (APTR) msg);
 858     case MUIM_SetUData:
 859         return Notify__MUIM_SetUData(cl, obj, (APTR) msg);
 860     case MUIM_SetUDataOnce:
 861         return Notify__MUIM_SetUData(cl, obj, (APTR) msg);
 862             /* use Notify_SetUData */
 863     case MUIM_WriteLong:
 864         return Notify__MUIM_WriteLong(cl, obj, (APTR) msg);
 865     case MUIM_WriteString:
 866         return Notify__MUIM_WriteString(cl, obj, (APTR) msg);
 867     case MUIM_ConnectParent:
 868         return Notify__MUIM_ConnectParent(cl, obj, (APTR) msg);
 869     case MUIM_DisconnectParent:
 870         return Notify__MUIM_DisconnectParent(cl, obj, (APTR) msg);
 871     case MUIM_GetConfigItem:
 872         return Notify__MUIM_GetConfigItem(cl, obj, (APTR) msg);
 873     }
 874
 875     return DoSuperMethodA(cl, obj, msg);
 876 }
 877 BOOPSI_DISPATCHER_END
 878
 879 /*
 880  * Class descriptor.
 881  */
 882 const struct __MUIBuiltinClass _MUI_Notify_desc =
 883 {
 884     MUIC_Notify,                /* Class name */
 885     ROOTCLASS,                  /* super class name */
 886     sizeof(struct MUI_NotifyData),      /* size of class's own data */
 887     (void *) Notify_Dispatcher   /* class dispatcher */
 888 };