workbench/demos/Zune/mui_notify2.c

   1 /*
   2     Copyright © 1999, David Le Corfec.
   3     Copyright © 2002, The AROS Development Team.
   4     All rights reserved.
   5
   6     $Id$
   7 */
   8
   9 /*
  10  * notify2.c : Test the MUI_Notify class, and show how to connect actions
  11  * to attributes changes.
  12  * Copied from a MUI2C example. Greetings to Jason Birch, MUI2C author.
  13  */
  14
  15 #include <exec/types.h>
  16
  17 //#include <libraries/mui.h>
  18 #include <clib/alib_protos.h>
  19 #include <proto/exec.h>
  20 #include <proto/intuition.h>
  21 #include <proto/muimaster.h>
  22 #ifdef __AROS__
  23 #include <libraries/mui.h>
  24 #endif
  25 #include <proto/utility.h>
  26 #include <stdio.h>
  27
  28 struct Library       *MUIMasterBase;
  29
  30 #ifndef __AROS__
  31
  32 #include <mui.h>
  33 #undef SysBase
  34
  35 /* On AmigaOS we build a fake library base, because it's not compiled as sharedlibrary yet */
  36 #include "muimaster_intern.h"
  37
  38 int openmuimaster(void)
  39 {
  40     static struct MUIMasterBase_intern MUIMasterBase_instance;
  41     MUIMasterBase = (struct Library*)&MUIMasterBase_instance;
  42
  43     MUIMasterBase_instance.sysbase = *((struct ExecBase **)4);
  44     MUIMasterBase_instance.dosbase = OpenLibrary("dos.library",37);
  45     MUIMasterBase_instance.utilitybase = OpenLibrary("utility.library",37);
  46     MUIMasterBase_instance.aslbase = OpenLibrary("asl.library",37);
  47     MUIMasterBase_instance.gfxbase = OpenLibrary("graphics.library",37);
  48     MUIMasterBase_instance.layersbase = OpenLibrary("layers.library",37);
  49     MUIMasterBase_instance.intuibase = OpenLibrary("intuition.library",37);
  50     MUIMasterBase_instance.cxbase = OpenLibrary("commodities.library",37);
  51     MUIMasterBase_instance.keymapbase = OpenLibrary("keymap.library",37);
  52     __zune_prefs_init(&__zprefs);
  53
  54     return 1;
  55 }
  56
  57 void closemuimaster(void)
  58 {
  59 }
  60
  61 #else
  62
  63 int openmuimaster(void)
  64 {
  65     if ((MUIMasterBase = OpenLibrary("muimaster.library", 0))) return 1;
  66     return 0;
  67 }
  68
  69 void closemuimaster(void)
  70 {
  71     if (MUIMasterBase) CloseLibrary(MUIMasterBase);
  72 }
  73
  74 #endif
  75
  76 #ifndef TAGBASE
  77 #define TAGBASE (TAG_USER | (9853 << 16))
  78 #endif
  79
  80 /*
  81  * This example uses 2 custom classes, Test and ExtendedTest.
  82  * Hierarchy : MUIC_Notify <-- Test <-- ExtendedTest.
  83  * Setting public attributes of these classes will trigger notifications.
  84  */
  85
  86
  87 /* Test : This is a simple class with 2 numeric attributes A and B. */
  88
  89 /*
  90  * Private data structure for instances of class Test.
  91  */
  92 struct TestData {
  93     int a;
  94     int b;
  95 };
  96
  97 /*
  98  * Public attributes of class Test
  99  * i : init
 100  * s : set
 101  * g : get
 102  */
 103 enum {
 104     MUIA_Test_A = TAGBASE,  /* isg */
 105     MUIA_Test_B,            /* isg */
 106 };
 107
 108 /*
 109  * Public methods of class Test
 110  */
 111 enum {
 112     MUIM_Test_Print = TAGBASE,
 113     MUIM_Test_GetBoth,
 114 };
 115
 116 /*
 117  * Special parameter structures for Test methods.
 118  */
 119 struct MUIP_Test_Print   { ULONG MsgID; };
 120 struct MUIP_Test_GetBoth { ULONG MsgID; int *x; int *y;};
 121
 122
 123
 124 /*
 125  * Constructor of Test object.
 126  */
 127 static IPTR
 128 Test_New(struct IClass *cl, Object *obj, struct opSet *msg)
 129 {
 130     struct TestData *data;
 131     struct TagItem  *tag;
 132     /*
 133      * Call constructor of superclass.
 134      */
 135     obj = (Object *)DoSuperMethodA(cl, obj, (Msg)msg);
 136     if (!obj)
 137         return 0;
 138     /*
 139      * Set default values to attributes.
 140      */
 141     data = INST_DATA(cl, obj);
 142     data->a = 0;
 143     data->b = 0;
 144     /*
 145      * Init attributes.
 146      */
 147     if ((tag = FindTagItem(MUIA_Test_A, msg->ops_AttrList)))
 148         data->a = tag->ti_Data;
 149     if ((tag = FindTagItem(MUIA_Test_B, msg->ops_AttrList)))
 150         data->b = tag->ti_Data;
 151     /*
 152      * Return newly constructed object.
 153      */
 154     return (IPTR)obj;
 155 }
 156
 157
 158 /*
 159  * Setting public attributes. The tags in the message may not be ours,
 160  * so do't forget to pass them to the super class.
 161  */
 162 static IPTR
 163 Test_Set(struct IClass *cl, Object *obj, struct opSet *msg)
 164 {
 165     struct TestData       *data = INST_DATA(cl, obj);
 166     struct TagItem        *tags = msg->ops_AttrList;
 167     struct TagItem        *tag;
 168
 169     /* There are many ways to find out what tag items provided by set()
 170     ** we do know. The best way should be using NextTagItem() and simply
 171     ** browsing through the list.
 172     */
 173     while ((tag = NextTagItem(&tags)) != NULL)
 174     {
 175         switch (tag->ti_Tag)
 176         {
 177         case MUIA_Test_A:
 178             data->a = tag->ti_Data;
 179             break;
 180         case MUIA_Test_B:
 181             data->b = tag->ti_Data;
 182             break;
 183         }
 184     }
 185     /*
 186      * To handle unkown attributes and notifications.
 187      */
 188     return(DoSuperMethodA(cl, obj, (Msg) msg));
 189 }
 190
 191
 192 /*
 193  * Getting public attributes.
 194  */
 195 static IPTR
 196 Test_Get(struct IClass *cl, Object *obj, struct opGet *msg)
 197 {
 198     struct TestData *data = INST_DATA(cl, obj);
 199 #define STORE *(msg->opg_Storage)
 200
 201     switch(msg->opg_AttrID)
 202     {
 203     case MUIA_Test_A:
 204         STORE = (ULONG) data->a;
 205         return(TRUE);
 206     case MUIA_Test_B:
 207         STORE = (ULONG) data->b;
 208         return(TRUE);
 209     }
 210
 211     /* Our handler didn't understand the attribute, we simply pass
 212     ** it to our superclass now.
 213     */
 214     return(DoSuperMethodA(cl, obj, (Msg) msg));
 215 #undef STORE
 216 }
 217
 218
 219 /*
 220  * Special get method to get both attributes.
 221  */
 222 static IPTR
 223 Test_GetBoth(struct IClass *cl, Object *obj, struct MUIP_Test_GetBoth *msg)
 224 {
 225     struct TestData *data = INST_DATA(cl, obj);
 226
 227     *(msg->x) = data->a;
 228     *(msg->y) = data->b;
 229     return TRUE;
 230 }
 231
 232
 233 /*
 234  * Print attributes value.
 235  */
 236 static IPTR
 237 Test_Print(struct IClass *cl, Object *obj, struct MUIP_Test_Print *msg)
 238 {
 239     struct TestData *data = INST_DATA(cl, obj);
 240     printf("A value: %d. B value: %d.\n", data->a, data->b);
 241     return TRUE;
 242 }
 243
 244
 245 /*
 246  * Test class method dispatcher.
 247  */
 248 #ifndef __AROS__
 249 __asm IPTR Test_Dispatcher(register __a0 Class *cl, register __a2 Object *obj, register __a1 Msg msg)
 250 #else
 251 AROS_UFH3S(IPTR, Test_Dispatcher,
 252         AROS_UFHA(Class  *, cl,  A0),
 253         AROS_UFHA(Object *, obj, A2),
 254         AROS_UFHA(Msg     , msg, A1))
 255 #endif
 256 {
 257     AROS_USERFUNC_INIT
 258
 259     /*
 260      * Watch out for methods we do understand.
 261      */
 262     switch (msg->MethodID)
 263     {
 264         /* Whenever an object shall be created using NewObject(), it will be
 265         ** sent a OM_NEW method.
 266         */
 267         case OM_NEW:
 268             return(Test_New(cl, obj, (struct opSet *) msg));
 269         case OM_SET:
 270             return(Test_Set(cl, obj, (struct opSet *)msg));
 271         case OM_GET:
 272             return(Test_Get(cl, obj, (struct opGet *)msg));
 273         case MUIM_Test_Print:
 274             return(Test_Print(cl, obj, (APTR)msg));
 275         case MUIM_Test_GetBoth:
 276             return(Test_GetBoth(cl, obj, (APTR)msg));
 277     }
 278     /*
 279      * We didn't understand the last method, so call our superclass.
 280      */
 281     return(DoSuperMethodA(cl, obj, msg));
 282
 283     AROS_USERFUNC_EXIT
 284 }
 285
 286
 287 /******************************************************************************/
 288 /* Extended Test : holds statistics about Test attributes, and update them    */
 289 /* automatically when they change.                                            */
 290 /******************************************************************************/
 291
 292 /*
 293  * Public methods of class ExtendedTest
 294  */
 295 enum {
 296     MUIM_ExtendedTest_Update = TAGBASE+11,
 297     MUIM_ExtendedTest_Print,
 298 };
 299
 300 struct MUIP_ExtendedTest_Update   { ULONG MsgID; };
 301 struct MUIP_ExtendedTest_Print    { ULONG MsgID; };
 302
 303 /*
 304  * Internal attributes of class ExtendedTest
 305  */
 306 struct ExtendedTestData {
 307     int sum;
 308     int average;
 309     int usecount;
 310 };
 311
 312 /*
 313  * Constructor of ExtendedTest object.
 314  */
 315 static IPTR
 316 ExtendedTest_New(struct IClass *cl, Object *obj, struct opSet *msg)
 317 {
 318     struct ExtendedTestData *data;
 319     /*
 320      * Call constructor of superclass.
 321      */
 322     obj = (Object *)DoSuperMethodA(cl, obj, (Msg)msg);
 323     if (!obj)
 324         return 0;
 325     /*
 326      * Set default values to attributes.
 327      */
 328     data = INST_DATA(cl, obj);
 329     DoMethod(obj, MUIM_ExtendedTest_Update);
 330     data->usecount = 0;
 331     /*
 332      * Setup notifications on our attributes.
 333      */
 334     DoMethod(obj, MUIM_Notify,
 335              MUIA_Test_A,                /* attribute to watch */
 336              MUIV_EveryTime,             /* notify when setting to everything */
 337              (IPTR)obj,                  /* object to call on notification */
 338              1,                          /* number of parameters following */
 339              MUIM_ExtendedTest_Update);  /* method to invoke */
 340
 341     DoMethod(obj, MUIM_Notify,
 342              MUIA_Test_B,
 343              MUIV_EveryTime,
 344              (IPTR)obj,
 345              1,
 346              MUIM_ExtendedTest_Update);
 347     /*
 348      * Return newly constructed object.
 349      */
 350     return (IPTR)obj;
 351 }
 352
 353
 354 /*
 355  * Recalculate sum and average.
 356  */
 357 static IPTR
 358 ExtendedTest_Update(struct IClass *cl, Object *obj,
 359                     struct MUIP_ExtendedTest_Update *noMsg)
 360 {
 361     struct ExtendedTestData *data = INST_DATA(cl, obj);
 362     int a;
 363     int b;
 364
 365     DoMethod(obj, MUIM_Test_GetBoth, (IPTR)&a, (IPTR)&b);
 366     data->sum = a + b;
 367     data->average = (a + b) / 2;
 368     data->usecount++;
 369     return TRUE;
 370 }
 371
 372
 373 /*
 374  * Print values.
 375  */
 376 static IPTR
 377 ExtendedTest_Print(struct IClass *cl, Object *obj,
 378                    struct MUIP_ExtendedTest_Print *noMsg)
 379 {
 380     struct ExtendedTestData *data = INST_DATA(cl, obj);
 381
 382     DoMethod(obj, MUIM_Test_Print);
 383     printf("Sum: %d. Average: %d. Usecount: %d.\n",
 384            data->sum,
 385            data->average,
 386            data->usecount);
 387
 388     return FALSE;
 389 }
 390
 391
 392 /*
 393  * ExtendedTest class method dispatcher.
 394  */
 395 #ifndef __AROS__
 396 __asm IPTR ExtendedTest_Dispatcher(register __a0 Class *cl, register __a2 Object *obj, register __a1 Msg msg)
 397 #else
 398 AROS_UFH3S(IPTR, ExtendedTest_Dispatcher,
 399         AROS_UFHA(Class  *, cl,  A0),
 400         AROS_UFHA(Object *, obj, A2),
 401         AROS_UFHA(Msg     , msg, A1))
 402 #endif
 403 {
 404     AROS_USERFUNC_INIT
 405
 406     /*
 407      * Watch out for methods we do understand.
 408      */
 409     switch (msg->MethodID)
 410     {
 411         /* Whenever an object shall be created using NewObject(), it will be
 412         ** sent a OM_NEW method.
 413         */
 414     case OM_NEW:
 415         return(ExtendedTest_New(cl, obj, (struct opSet *) msg));
 416     case MUIM_ExtendedTest_Print:
 417         return(ExtendedTest_Print(cl, obj, (APTR)msg));
 418     case MUIM_ExtendedTest_Update:
 419         return(ExtendedTest_Update(cl, obj, (APTR)msg));
 420     }
 421     /*
 422      * We didn't understand the last method, so call our superclass.
 423      */
 424     return(DoSuperMethodA(cl, obj, msg));
 425
 426     AROS_USERFUNC_EXIT
 427 }
 428
 429
 430 /*
 431  * Create both classes, create an ExtendedTest object,
 432  * changes attributes and print values.
 433  */
 434 int main (void)
 435 {
 436     Object                 *obj;
 437     struct MUI_CustomClass *testClass;
 438     struct MUI_CustomClass *extendedTestClass;
 439     int result = 0;
 440
 441     if (!openmuimaster()) return 20;
 442
 443     testClass = MUI_CreateCustomClass(NULL, MUIC_Notify, NULL,
 444                                       sizeof(struct TestData),
 445                                       Test_Dispatcher);
 446     if (!testClass)
 447     {
 448         printf("cannot create Test class\n");
 449         result = 5;
 450         goto error;
 451     }
 452     extendedTestClass = MUI_CreateCustomClass(NULL, NULL, testClass,
 453                                               sizeof(struct ExtendedTestData),
 454                                               ExtendedTest_Dispatcher);
 455     if (!extendedTestClass)
 456     {
 457         MUI_DeleteCustomClass(testClass);
 458         printf("cannot create ExtendedTest class\n");
 459         result = 5;
 460         goto error;
 461     }
 462
 463     obj = NewObject(extendedTestClass->mcc_Class, NULL,
 464                     MUIA_Test_A, 10,
 465                     MUIA_Test_B, 20,
 466                     TAG_DONE);
 467     if (obj)
 468     {
 469         int x;
 470         int y;
 471
 472         printf("\nSum and Average will be automatically calculated"
 473             " after each change of A and B values.\n\n");
 474         printf("- Show the contents of the object:\n");
 475         DoMethod(obj, MUIM_ExtendedTest_Print);
 476
 477         printf("\n- Set the A attribute of the object to 5 and check its new contents:\n");
 478         set(obj, MUIA_Test_A, 5);
 479         DoMethod(obj, MUIM_ExtendedTest_Print);
 480
 481         printf("\n- Set the B attribute of the object to 10 and check its new contents:\n");
 482         set(obj, MUIA_Test_B, 10);
 483         DoMethod(obj, MUIM_ExtendedTest_Print);
 484
 485         printf("\n- Get the A and B attributes using MUIP structure:\n");
 486         DoMethod(obj, MUIM_Test_GetBoth, (IPTR)&x, (IPTR)&y);
 487         printf("Values returned: %d %d.\n", x, y);
 488         DisposeObject(obj);
 489     }
 490     MUI_DeleteCustomClass(extendedTestClass);
 491     MUI_DeleteCustomClass(testClass);
 492
 493 error:
 494
 495     closemuimaster();
 496
 497     return result;
 498 }