development/gui/chocolatecastle/source/muigenerator.c

   1 /* MuiGenerator class body */
   2
   3 /* Code generated with ChocolateCastle 0.1 */
   4 /* written by Grzegorz "Krashan" Kraszewski <krashan@teleinfo.pb.bialystok.pl> */
   5
   6 /// includes
   7
   8 #include <proto/intuition.h>
   9 #include <proto/utility.h>
  10 #include <proto/muimaster.h>
  11 #include <clib/alib_protos.h>
  12 #include <libraries/asl.h>
  13 #include <libraries/mui.h>
  14 #include <libvstring.h>
  15 #include <string.h>
  16
  17 #include "muigenerator.h"
  18 #include "generator.h"
  19 #include "support.h"
  20 #include "methodlist.h"
  21 #include "methodeditor.h"
  22 #include "locale.h"
  23
  24 ///
  25 /// instance data
  26
  27 struct MuiGeneratorData
  28 {
  29         Object *SuperclassTypeRadio;
  30         Object *SuperclassNameString;
  31         Object *SuperclassPointerString;
  32         Object *SuperclassPageGroup;
  33         Object *MethodList;
  34         Object *MethodDelete;
  35         Object *MethodEdit;
  36         Object *MethodAdd;
  37 };
  38
  39
  40 ///
  41 /// tables
  42
  43 const char* PopularMuiSuperclasses[] =
  44 {
  45         "Application",
  46         "Area",
  47         "Dataspace",
  48         "Family",
  49         "Gauge",
  50         "Group",
  51         "List",
  52         "Notify",
  53         "Numeric",
  54         "Numericbutton",
  55         "Poplist",
  56         "Popobject",
  57         "Popstring",
  58         "Process",
  59         "Prop",
  60         "Register",
  61         "Scrollgroup",
  62         "Semaphore",
  63         "Slider",
  64         "String",
  65         "Text",
  66         "Virtgroup",
  67         "Window",
  68         NULL
  69 };
  70
  71 #ifdef __AROS__
  72 const struct MethodEntry DefaultMethods[] = {
  73         { (STRPTR)"OM_NEW", (STRPTR)"OM_NEW", (STRPTR)"opSet", (STRPTR)"00000101", TRUE },
  74         { (STRPTR)"OM_DISPOSE", (STRPTR)"OM_DISPOSE", (STRPTR)"", (STRPTR)"00000102", TRUE },
  75         { (STRPTR)"OM_SET", (STRPTR)"OM_SET", (STRPTR)"opSet", (STRPTR)"00000103", TRUE },
  76         { (STRPTR)"OM_GET", (STRPTR)"OM_GET", (STRPTR)"opGet", (STRPTR)"00000104", TRUE },
  77         { NULL, NULL, NULL, NULL, 0 }
  78 };
  79 #else
  80 const struct MethodEntry DefaultMethods[] = {
  81         { (STRPTR)"OM_NEW", (STRPTR)"New", (STRPTR)"opSet", (STRPTR)"00000101", TRUE },
  82         { (STRPTR)"OM_DISPOSE", (STRPTR)"Dispose", (STRPTR)"", (STRPTR)"00000102", TRUE },
  83         { (STRPTR)"OM_SET", (STRPTR)"Set", (STRPTR)"opSet", (STRPTR)"00000103", TRUE },
  84         { (STRPTR)"OM_GET", (STRPTR)"Get", (STRPTR)"opGet", (STRPTR)"00000104", TRUE },
  85         { NULL, NULL, NULL, NULL, 0 }
  86 };
  87 #endif
  88
  89 #define SUPERCLASS_TYPE_PRIVATE  0
  90 #define SUPERCLASS_TYPE_PUBLIC   1
  91
  92
  93 ///
  94 /// global vars, prototypes
  95
  96 struct MUI_CustomClass *MuiGeneratorClass;
  97
  98 #ifdef __AROS__
  99 AROS_UFP3(IPTR, g_MuiGenerator,
 100 AROS_UFPA(Class  *, cl,  A0),
 101 AROS_UFPA(Object *, obj, A2),
 102 AROS_UFPA(Msg     , msg, A1));
 103 #else
 104 IPTR d_MuiGenerator(void);
 105
 106 static struct EmulLibEntry g_MuiGenerator = {TRAP_LIB, 0, (void(*)(void))d_MuiGenerator};
 107 #endif
 108
 109
 110 ///
 111 /// CreateMuiGeneratorClass()
 112
 113 struct MUI_CustomClass *CreateMuiGeneratorClass(void)
 114 {
 115         struct MUI_CustomClass *cl;
 116
 117         cl = MUI_CreateCustomClass(NULL, NULL, GeneratorClass,  sizeof(struct MuiGeneratorData), &g_MuiGenerator);
 118
 119         MuiGeneratorClass = cl;
 120         return cl;
 121 }
 122
 123
 124 ///
 125 /// DeleteMuiGeneratorClass()
 126
 127 void DeleteMuiGeneratorClass(void)
 128 {
 129          MUI_DeleteCustomClass(MuiGeneratorClass);
 130 }
 131
 132
 133 ///
 134
 135 /// create_my_group()
 136
 137 static Object *create_my_group(Object *obj, struct MuiGeneratorData *d)
 138 {
 139         Object *o;
 140
 141         o = MUI_NewObjectM(MUIC_Group,
 142                 MUIA_Group_Child, MUI_NewObjectM(MUIC_Group,
 143                         MUIA_Frame, MUIV_Frame_Group,
 144                         MUIA_FrameTitle, LS(MSG_MUI_GENERATOR_SUPERCLASS_LABEL, "Superclass"),
 145                         MUIA_Background, MUII_GroupBack,
 146                         MUIA_Group_Child, MUI_NewObjectM(MUIC_Group,
 147                                 MUIA_Group_Horiz, TRUE,
 148                                 MUIA_Group_Child, MUI_NewObjectM(MUIC_Rectangle,
 149                                 TAG_END),
 150                                 MUIA_Group_Child, d->SuperclassTypeRadio = MUI_NewObjectM(MUIC_Radio,
 151                                         MUIA_Radio_Entries, SuperclassRadioEntries,
 152                                         MUIA_CycleChain, TRUE,
 153                                 TAG_END),
 154                                 MUIA_Group_Child, RectangleObject,
 155                                 TAG_END),
 156                         TAG_END),
 157                         MUIA_Group_Child, d->SuperclassPageGroup = MUI_NewObjectM(MUIC_Group,
 158                                 MUIA_Group_PageMode, TRUE,
 159                                 MUIA_Group_Child, MUI_NewObjectM(MUIC_Group,
 160                                         MUIA_Group_Horiz, TRUE,
 161                                         MUIA_Group_Child, MUI_NewObjectM(MUIC_Text,
 162                                                 MUIA_Text_Contents, LS(MSG_MUI_GENERATOR_SUPERCLASS_PTRNAME_LABEL, "Pointer Name:"),
 163                                                 MUIA_Frame, MUIV_Frame_String,
 164                                                 MUIA_FramePhantomHoriz, TRUE,
 165                                                 MUIA_HorizWeight, 0,
 166                                         TAG_END),
 167                                         MUIA_Group_Child, d->SuperclassPointerString = MUI_NewObjectM(MUIC_String,
 168                                                 MUIA_Frame, MUIV_Frame_String,
 169                                                 MUIA_String_MaxLen, 50,
 170                                                 MUIA_String_Accept, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_",
 171                                                 MUIA_CycleChain, TRUE,
 172                                         TAG_END),
 173                                 TAG_END),
 174                                 MUIA_Group_Child, MUI_NewObjectM(MUIC_Group,
 175                                         MUIA_Group_Horiz, TRUE,
 176                                         MUIA_Group_Child, MUI_NewObjectM(MUIC_Text,
 177                                                 MUIA_Text_Contents, LS(MSG_MUI_GENERATOR_SUPERCLASS_CNAME_LABEL, "Superclass Name:"),
 178                                                 MUIA_Frame, MUIV_Frame_String,
 179                                                 MUIA_FramePhantomHoriz, TRUE,
 180                                                 MUIA_HorizWeight, 0,
 181                                         TAG_END),
 182                                         MUIA_Group_Child, d->SuperclassNameString = MUI_NewObjectM(MUIC_Poplist,
 183                                                 MUIA_Popstring_String, MUI_NewObjectM(MUIC_String,
 184                                                         MUIA_Frame, MUIV_Frame_String,
 185                                                         MUIA_String_MaxLen, 50,
 186                                                         MUIA_String_Accept, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_",
 187                                                 TAG_END),
 188                                                 MUIA_Popstring_Button, MUI_NewObjectM(MUIC_Image,
 189                                                         MUIA_Image_Spec, "6:18",
 190                                                         MUIA_InputMode, MUIV_InputMode_RelVerify,
 191                                                         MUIA_Frame, MUIV_Frame_ImageButton,
 192                                                         MUIA_Image_FreeVert, TRUE,
 193                                                 TAG_END),
 194                                                 MUIA_Poplist_Array, PopularMuiSuperclasses,
 195                                                 MUIA_CycleChain, TRUE,
 196                                         TAG_END),
 197                                 TAG_END),
 198                         TAG_END),
 199                 TAG_END),
 200                 MUIA_Group_Child, MUI_NewObjectM(MUIC_Group,
 201                         MUIA_Frame, MUIV_Frame_Group,
 202                         MUIA_FrameTitle, LS(MSG_MUI_GENERATOR_METHODS_FRAME_TITLE, "Methods"),
 203                         MUIA_Background, MUII_GroupBack,
 204                         MUIA_Group_Child, NewObjectM(MethodEditorClass->mcc_Class, NULL,
 205                                 EDLA_List, d->MethodList = NewObjectM(MethodListClass->mcc_Class, NULL,
 206                                 TAG_END),
 207                                 EDLA_Generator, obj,
 208                         TAG_END),
 209                 TAG_END),
 210
 211                 /*
 212                 MUIA_Group_Child, MUI_NewObjectM(MUIC_Group,
 213                         MUIA_Frame, MUIV_Frame_Group,
 214                         MUIA_FrameTitle, "Options",
 215                         MUIA_Background, MUII_GroupBack,
 216                 TAG_END),
 217                 */
 218         TAG_END);
 219
 220         return o;
 221 }
 222
 223
 224 ///
 225 /// load_super_data()
 226
 227 int load_super_data(Class *cl, Object *obj, struct GENP_Load *msg)
 228 {
 229         UBYTE line[512];
 230         int result = FALSE;
 231         struct MuiGeneratorData *d = INST_DATA(cl, obj);
 232
 233         if (FGets((BPTR)msg->Handle, (STRPTR)line, 512))
 234         {
 235                 msg->Parser->line++;
 236
 237                 if (check_pattern(line, (STRPTR)"SUPERTYPE/K/N/A,SUPERNAME/K/A", msg->Parser))
 238                 {
 239                         ULONG type = *(ULONG*)msg->Parser->params[0];
 240
 241                         if (type < 2) xset(d->SuperclassTypeRadio, MUIA_Radio_Active, type);
 242
 243                         switch (type)
 244                         {
 245                                 case 0:
 246                                         xset(d->SuperclassPointerString, MUIA_String_Contents, msg->Parser->params[1]);
 247                                         result = TRUE;
 248                                 break;
 249
 250                                 case 1:
 251                                         xset(d->SuperclassNameString, MUIA_String_Contents, msg->Parser->params[1]);
 252                                         result = TRUE;
 253                                 break;
 254
 255                                 default: syntax_error(obj, msg->Parser);
 256                         }
 257                 }
 258                 else syntax_error(obj, msg->Parser);
 259         }
 260         else unexpected_eof(obj, msg->Parser);
 261
 262  return result;
 263 }
 264
 265
 266 ///
 267 /// load_method()
 268
 269 static BOOL load_method(Class *cl, Object *obj, struct GENP_Load *msg)
 270 {
 271         UBYTE line[512];
 272         int result = FALSE;
 273         struct MuiGeneratorData *d = INST_DATA(cl, obj);
 274
 275         if (FGets((BPTR)msg->Handle, (STRPTR)line, 512))
 276         {
 277                 msg->Parser->line++;
 278
 279                 if (check_pattern(line, (STRPTR)"METHOD/K/A,FUNCTION/K/A,STRUCTURE/K/A,ID/K/A,STD/K/N/A", msg->Parser))
 280                 {
 281                         struct MethodEntry me;
 282
 283                         me.Name = (STRPTR)msg->Parser->params[0];
 284                         me.Function = (STRPTR)msg->Parser->params[1];
 285                         me.Structure = (STRPTR)msg->Parser->params[2];
 286                         me.Identifier = (STRPTR)msg->Parser->params[3];
 287                         me.Standard = *(LONG*)msg->Parser->params[4];
 288                         DoMethod(d->MethodList, MUIM_List_InsertSingle, (intptr_t)&me, MUIV_List_Insert_Bottom);
 289                         result = TRUE;
 290                 }
 291                 else syntax_error(obj, msg->Parser);
 292         }
 293         return result;
 294 }
 295
 296
 297 ///
 298 /// generate_set_contents()
 299
 300 static void generate_set_contents(Object *obj)
 301 {
 302         I; T("int tagcount = 0;\n");
 303         I; T("struct TagItem *tag, *tagptr = msg->ops_AttrList;\n\n");
 304         I; T("while (tag = NextTagItem(&tagptr))\n");
 305         I; T("{\n");
 306         II; TODO("attributes in OM_SET.");
 307         IO; I; T("}\n\n");
 308         I; T("tagcount += DoSuperMethodA(cl, obj, (Msg)msg);\n");
 309         I; T("return tagcount;\n");
 310 }
 311
 312 ///
 313 /// generate_get_contents()
 314
 315 static void generate_get_contents(Object *obj)
 316 {
 317         I; T("int rv = FALSE;\n\n");
 318         I; T("switch (msg->opg_AttrID)\n"); I; T("{\n"); II;
 319         TODO("attributes in OM_GET.");
 320         I; T("default: rv = (DoSuperMethodA(cl, obj, (Msg)msg));\n");
 321         IO; I; T("}\n\n");
 322         I; T("return rv;\n");
 323 }
 324
 325 ///
 326
 327 #ifdef __AROS__
 328 static void generate_aros_dispatcher(Object *obj, Object *method_list, struct MuiGeneratorData *d)
 329 {
 330         char *s;
 331         int32_t superclass_type;
 332         ULONG method_count, method_number;
 333         char buffer[10];
 334
 335         method_count = xget(method_list, MUIA_List_Entries);
 336         FmtNPut(buffer, "%u", sizeof buffer, method_count);
 337
 338         T("/*** Setup ************************************************************************/\n");
 339         T("ZUNE_CUSTOMCLASS_");
 340         T(buffer);
 341         T("\n(\n");
 342         II; I;
 343         TC("%s, NULL, ");
 344
 345         superclass_type = xget(d->SuperclassTypeRadio, MUIA_Radio_Active);
 346
 347         if (superclass_type == SUPERCLASS_TYPE_PRIVATE)
 348         {
 349                 s = (char*)xget(d->SuperclassPointerString, MUIA_String_Contents);
 350                 T("NULL, "); T(s); T(",");
 351         }
 352         else
 353         {
 354                 s = (char*)xget(d->SuperclassNameString, MUIA_String_Contents);
 355                 T("MUIC_"); T(s); T(", NULL,");
 356         }
 357
 358         T("\n");
 359
 360         for (method_number = 0;; method_number++)
 361         {
 362                 struct MethodEntry *me;
 363
 364                 DoMethod(method_list, MUIM_List_GetEntry, method_number, (intptr_t)&me);
 365                 if (!me) break;
 366
 367                 I; T(me->Name); T(",     ");
 368
 369                 if (*me->Structure)
 370                 {
 371                         T("struct "); T(me->Structure); T(" *");
 372                 }
 373                 else
 374                 {
 375                         T("Msg");
 376                 }
 377
 378                 if (method_number < method_count - 1)
 379                 {
 380                         T(",");
 381                 }
 382
 383                 T("\n");
 384         }
 385
 386         IO; T(");\n\n");
 387 }
 388 #endif
 389
 390
 391 /// MuiGeneratorNew()
 392
 393 IPTR MuiGeneratorNew(Class *cl, Object *obj, struct opSet *msg)
 394 {
 395         Object *newobj = NULL;
 396
 397         if (obj = (Object*)DoSuperMethodA(cl, obj, (Msg)msg))
 398         {
 399                 struct MuiGeneratorData *d = INST_DATA(cl, obj);
 400                 Object *my_group;
 401
 402                 if (my_group = create_my_group(obj, d))
 403                 {
 404                         Object *parent;
 405
 406                         GetAttr(GENA_SubclassSpace, obj, (IPTR*)&parent);
 407
 408                         if (parent)
 409                         {
 410                                 DoMethod(parent, OM_ADDMEMBER, (intptr_t)my_group);
 411                                 SetAttrs(obj, MUIA_Window_Title,
 412                                  (IPTR)LS(MSG_MUI_GENERATOR_WINDOW_TITLE, "MUI Custom Class"), TAG_END);
 413                                 DoMethod(d->SuperclassTypeRadio, MUIM_Notify, MUIA_Radio_Active, MUIV_EveryTime,
 414                                         (intptr_t)d->SuperclassPageGroup, 3, MUIM_Set, MUIA_Group_ActivePage, MUIV_TriggerValue);
 415                                 DoMethod(d->MethodList, MTLM_InsertMethodTable, (IPTR)DefaultMethods);
 416
 417                                 newobj = obj;
 418                         }
 419                         else MUI_DisposeObject(my_group);
 420                 }
 421
 422                 if (!newobj) CoerceMethod(cl, obj, OM_DISPOSE);
 423         }
 424         return (IPTR)newobj;
 425 }
 426
 427
 428 ///
 429 /// MuiGeneratorDispose()
 430
 431 IPTR MuiGeneratorDispose(Class *cl, Object *obj, Msg msg)
 432 {
 433         return DoSuperMethodA(cl, obj, msg);
 434 }
 435
 436
 437 ///
 438 /// MuiGeneratorGet()
 439
 440 IPTR MuiGeneratorGet(Class *cl, Object *obj, struct opGet *msg)
 441 {
 442         switch (msg->opg_AttrID)
 443         {
 444                 case GENA_ProjectType:
 445                  *(STRPTR*)msg->opg_Storage = (STRPTR)"MUI Class";
 446                 return TRUE;
 447         }
 448         return DoSuperMethodA(cl, obj, (Msg)msg);
 449 }
 450
 451
 452 ///
 453 /// MuiGeneratorGenerate()
 454
 455 intptr_t MuiGeneratorGenerate(Class *cl, Object *obj, Msg msg)
 456 {
 457         struct MuiGeneratorData *d = INST_DATA(cl, obj);
 458         int entry_number;
 459
 460         msg = msg;
 461
 462         /* === Class code. === */
 463
 464         if (DoMethod(obj, GENM_Setup, (intptr_t)"%s.c"))
 465         {
 466
 467 #ifdef __AROS__
 468                 T("/*\n");
 469                 T("    Copyright © 2012, The AROS Development Team. All rights reserved.\n");
 470                 T("    $Id$\n");
 471                 T("*/\n\n");
 472                 TCS("#include \"%s.h\"\n\n");
 473
 474                 TC("/// %s_DATA\n\n");
 475                 TC("struct %s_DATA\n{\n"); II; I; T("// Insert object instance data here.\n"); IO; T("};\n\n\n");
 476                 T("///\n");
 477
 478                 /*------------------------------------------------------------------------*/
 479                 /* methods                                                                */
 480                 /*------------------------------------------------------------------------*/
 481
 482                 for (entry_number = 0;; entry_number++)
 483                 {
 484                         struct MethodEntry *me;
 485                         BOOL return_zero = TRUE;
 486
 487                         DoMethod(d->MethodList, MUIM_List_GetEntry, entry_number, (intptr_t)&me);
 488                         if (!me) break;
 489                         DoMethod(obj, GENM_MethodHeader, (IPTR)me->Name, (IPTR)me->Function,
 490                          (IPTR)me->Structure, (IPTR)me->Identifier, TRUE, FALSE);
 491
 492                         if (strcmp((char*)me->Name, "OM_GET") == 0)
 493                         {
 494                                 generate_get_contents(obj);
 495                                 return_zero = FALSE;
 496                         }
 497                         else if (strcmp((char*)me->Name, "OM_SET") == 0)
 498                         {
 499                                 generate_set_contents(obj);
 500                                 return_zero = FALSE;
 501                         }
 502
 503                         DoMethod(obj, GENM_MethodFooter, return_zero);
 504                 }
 505
 506                 generate_aros_dispatcher(obj, d->MethodList, d);
 507
 508 #else
 509
 510                 char *s;
 511                 int32_t superclass_type;
 512
 513                 DoMethod(obj, GENM_Signature);
 514                 TC("/* %sClass code. */\n\n");
 515                 TCS("#include \"%s.h\"\n\n");
 516                 TC("struct MUI_CustomClass *%sClass;\n\n");
 517
 518                 T("/// dispatcher prototype\n\n");
 519                 TC("IPTR %sDispatcher(void);\n");
 520                 TC("const struct EmulLibEntry %sGate = ");
 521                 TC("{TRAP_LIB, 0, (void(*)(void))%sDispatcher};\n");
 522                 T("\n\n///\n");
 523
 524                 TC("/// %sData\n\n");
 525                 TC("struct %sData\n{\n"); II; I; T("// Insert object instance data here.\n"); IO; T("};\n\n\n");
 526                 T("///\n");
 527
 528                 /*------------------------------------------------------------------------*/
 529                 /* create class                                                           */
 530                 /*------------------------------------------------------------------------*/
 531
 532                 TC("/// Create%sClass()\n\n");
 533                 TC("struct MUI_CustomClass *Create%sClass(void)\n{\n");
 534                 II; I; T("struct MUI_CustomClass *cl;\n\n");
 535                 I; T("cl = MUI_CreateCustomClass(NULL, ");
 536                 superclass_type = xget(d->SuperclassTypeRadio, MUIA_Radio_Active);
 537
 538                 if (superclass_type == SUPERCLASS_TYPE_PRIVATE)
 539                 {
 540                         s = (char*)xget(d->SuperclassPointerString, MUIA_String_Contents);
 541                         T("NULL, "); T(s); T(", ");
 542                 }
 543                 else
 544                 {
 545                         s = (char*)xget(d->SuperclassNameString, MUIA_String_Contents);
 546                         T("MUIC_"); T(s); T(", NULL, ");
 547                 }
 548
 549                 TC("sizeof(struct %sData), ");
 550                 TC("(APTR)&%sGate);\n");
 551                 I; TC("%sClass = cl;\n"); I; T("return cl;\n"); IO; T("}\n\n\n");
 552                 T("///\n");
 553
 554                 /*------------------------------------------------------------------------*/
 555                 /* delete class                                                           */
 556                 /*------------------------------------------------------------------------*/
 557
 558                 TC("/// Delete%sClass()\n\n");
 559                 TC("void Delete%sClass(void)\n{\n");
 560                 II; I; TC("if (%sClass) "); TC("MUI_DeleteCustomClass(%sClass);\n");
 561                 IO; T("}\n\n\n///\n");
 562
 563                 /*------------------------------------------------------------------------*/
 564                 /* methods                                                                */
 565                 /*------------------------------------------------------------------------*/
 566
 567                 for (entry_number = 0;; entry_number++)
 568                 {
 569                         struct MethodEntry *me;
 570                         BOOL return_zero = TRUE;
 571
 572                         DoMethod(d->MethodList, MUIM_List_GetEntry, entry_number, (intptr_t)&me);
 573                         if (!me) break;
 574                         DoMethod(obj, GENM_MethodHeader, (IPTR)me->Name, (IPTR)me->Function,
 575                          (IPTR)me->Structure, (IPTR)me->Identifier, TRUE, FALSE);
 576
 577                         if (strcmp((char*)me->Name, "OM_GET") == 0)
 578                         {
 579                                 generate_get_contents(obj);
 580                                 return_zero = FALSE;
 581                         }
 582                         else if (strcmp((char*)me->Name, "OM_SET") == 0)
 583                         {
 584                                 generate_set_contents(obj);
 585                                 return_zero = FALSE;
 586                         }
 587
 588                         DoMethod(obj, GENM_MethodFooter, return_zero);
 589                 }
 590
 591                 generate_dispatcher(obj, d->MethodList);
 592
 593 #endif
 594
 595         }
 596         DoMethod(obj, GENM_Cleanup);
 597
 598         /* === Class header. === */
 599
 600         if (DoMethod(obj, GENM_Setup, (intptr_t)"%s.h"))
 601         {
 602
 603 #ifdef __AROS__
 604
 605                 TC("#ifndef %s_H\n");
 606                 TC("#define %s_H\n\n");
 607                 T("/*\n");
 608                 T("    Copyright © 2012, The AROS Development Team. All rights reserved.\n");
 609                 T("    $Id$\n");
 610                 T("*/\n\n");
 611                 T("#include <exec/types.h>\n");
 612                 T("#include <libraries/mui.h>\n\n");
 613                 T("/*** Identifier base ********************************************************/\n");
 614                 TC("#define MUIB_%s           (TAG_USER|0x00000000)\n\n");
 615
 616                 /*----------------*/
 617                 /* custom methods */
 618                 /*----------------*/
 619
 620                 T("/*** Attributes *************************************************************/\n");
 621                 for (entry_number = 0;; entry_number++)
 622                 {
 623                         struct MethodEntry *me;
 624
 625                         DoMethod(d->MethodList, MUIM_List_GetEntry, entry_number, (intptr_t)&me);
 626                         if (!me) break;
 627
 628                         if (!me->Standard)
 629                         {
 630                                 T("#define "); T(me->Name); TC("       (MUIB_%s | 0x"); T(me->Identifier); T(")\n");
 631                         }
 632                 }
 633                 T("\n/*** Variables **************************************************************/\n");
 634                 TC("extern struct MUI_CustomClass *%s_CLASS;\n\n");
 635
 636                 T("/*** Macros *****************************************************************/\n");
 637                 TC("#define %sObject ");
 638                 TC("BOOPSIOBJMACRO_START(%s_CLASS->mcc_Class)\n\n");
 639                 T("#endif\n");
 640
 641 #else
 642
 643                 DoMethod(obj, GENM_Signature);
 644                 TC("/* %sClass header. */\n\n");
 645                 T("#include <proto/intuition.h>\n");
 646                 T("#include <proto/utility.h>\n");
 647                 T("#include <proto/muimaster.h>\n");
 648                 T("#include <clib/alib_protos.h>\n\n");
 649                 TC("extern struct MUI_CustomClass *%sClass;\n\n");
 650                 TC("struct MUI_CustomClass *Create%sClass(void);\n");
 651                 TC("void Delete%sClass(void);\n\n\n");
 652
 653                 /*----------------*/
 654                 /* custom methods */
 655                 /*----------------*/
 656
 657                 for (entry_number = 0;; entry_number++)
 658                 {
 659                         struct MethodEntry *me;
 660
 661                         DoMethod(d->MethodList, MUIM_List_GetEntry, entry_number, (intptr_t)&me);
 662                         if (!me) break;
 663
 664                         if (!me->Standard)
 665                         {
 666                                 T("#define "); T(me->Name); T(" 0x"); T(me->Identifier); T("\n");
 667                         }
 668                 }
 669
 670 #endif
 671
 672         }
 673         DoMethod(obj, GENM_Cleanup);
 674         DoSuperMethodA(cl, obj, msg);   // displays info requester
 675         return 0;
 676 }
 677
 678
 679 ///
 680 /// MuiGeneratorSave()
 681
 682 IPTR MuiGeneratorSave(Class *cl, Object *obj, struct GENP_Save *msg)
 683 {
 684         struct MuiGeneratorData *d = INST_DATA(cl, obj);
 685
 686         if (DoSuperMethodA(cl, obj, msg))
 687         {
 688                 ULONG supertype, e;
 689
 690                 supertype = xget(d->SuperclassTypeRadio, MUIA_Radio_Active);
 691
 692                 if (supertype == 0) FPrintf((BPTR)msg->Handle, (STRPTR)"SUPERTYPE=0 SUPERNAME=%s\n", xget(d->SuperclassPointerString, MUIA_String_Contents));
 693                 else FPrintf((BPTR)msg->Handle, (STRPTR)"SUPERTYPE=1 SUPERNAME=%s\n", xget(d->SuperclassNameString, MUIA_String_Contents));
 694
 695                 // dumping methods
 696
 697                 for (e = 0; ; e++)
 698                 {
 699                         struct MethodEntry *me;
 700                         STRPTR s;
 701
 702                         DoMethod(d->MethodList, MUIM_List_GetEntry, e, (intptr_t)&me);
 703                         if (!me) break;
 704                         if (*me->Structure == 0x00) s = (STRPTR)"\"\"";
 705                         else s = me->Structure;
 706                         FPrintf((BPTR)msg->Handle, (STRPTR)"METHOD=%s FUNCTION=%s STRUCTURE=%s ID=%s STD=%ld\n", (intptr_t)me->Name,
 707                          (intptr_t)me->Function, (intptr_t)s, (intptr_t)me->Identifier, me->Standard);
 708                 }
 709         }
 710
 711         return TRUE;
 712 }
 713
 714
 715 ///
 716 /// MuiGeneratorLoad()
 717
 718 IPTR MuiGeneratorLoad(Class *cl, Object *obj, struct GENP_Load *msg)
 719 {
 720         struct MuiGeneratorData *d = INST_DATA(cl, obj);
 721         BOOL rv = FALSE;
 722
 723         if (DoSuperMethodA(cl, obj, (Msg)msg))
 724         {
 725                 if (load_super_data(cl, obj, msg))
 726                 {
 727                         DoMethod(d->MethodList, MUIM_List_Clear);
 728                         while (load_method(cl, obj, msg));
 729                         rv = TRUE;
 730                 }
 731         }
 732
 733         return rv;
 734 }
 735
 736
 737 ///
 738 /// d_MuiGenerator()
 739
 740 #ifdef __AROS__
 741 BOOPSI_DISPATCHER(IPTR, g_MuiGenerator, cl, obj, msg)
 742 {
 743 #else
 744 IPTR d_MuiGenerator(void)
 745 {
 746         Class *cl = (Class*)REG_A0;
 747         Object *obj = (Object*)REG_A2;
 748         Msg msg = (Msg)REG_A1;
 749 #endif
 750
 751         switch (msg->MethodID)
 752         {
 753                 case OM_NEW:  return (MuiGeneratorNew(cl, obj, (struct opSet*)msg));
 754                 case OM_DISPOSE:  return (MuiGeneratorDispose(cl, obj, msg));
 755                 case OM_GET:  return (MuiGeneratorGet(cl, obj, (struct opGet*)msg));
 756                 case GENM_Generate:  return (MuiGeneratorGenerate(cl, obj, msg));
 757                 case GENM_Save:  return (MuiGeneratorSave(cl, obj, (struct GENP_Save*)msg));
 758                 case GENM_Load:  return (MuiGeneratorLoad(cl, obj, (struct GENP_Load*)msg));
 759                 default:  return (DoSuperMethodA(cl, obj, msg));
 760         }
 761 }
 762 #ifdef __AROS__
 763 BOOPSI_DISPATCHER_END
 764 #endif
 765
 766 ///
 767