workbench/libs/muimaster/classes/notify.c

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