home *** CD-ROM | disk | FTP | other *** search
/ Multimedia Producer's Bible / Multimedia Producer's Bible.iso / mac / mTropolis / mTropolis Sampler Files / mFactory Object Model Examples / Source / Interfac / Interfac.c next >
Encoding:
C/C++ Source or Header  |  1996-01-04  |  14.0 KB  |  471 lines  |  [TEXT/MMCC]
  1. /*    Interfac.c
  2. **
  3. **    Copyright 1995, mFactory, Inc.
  4. **    All rights reserved.
  5. */
  6.  
  7. #include "Interfac.h"
  8.  
  9. #define kActivatePopup        14        // DITL indices
  10. #define kSoundPopup            16
  11. #define kScenePopup            18
  12.  
  13. #define kStaticPopup        20
  14. #define kDynamicPopup        22
  15. #define kSubmenuPopup        24
  16.  
  17. #define kBeepButton            25
  18. #define kIconButton            26
  19.  
  20. #define kYesRadioButton        27
  21. #define kNoRadioButton        28
  22. #define kMaybeRadioButton    29
  23.  
  24. #define kShowCheckbox        30
  25. #define kPlayCheckbox        31
  26. #define kBackwardCheckbox    32
  27.  
  28. #define kIntegerField        34
  29. #define kDoubleField        36
  30. #define kTimeField            38
  31. #define kStringField        40
  32.  
  33. #define kTextBlock            41
  34.  
  35. #define kYes                0        // radio button values
  36. #define kNo                    1
  37. #define kMaybe                2
  38.  
  39. #define    kStrMaxLen            256        // maximum string length
  40.  
  41. const kTimePeriod =            10;        // milliseconds
  42.  
  43.  
  44. /*    Initial entry point
  45. */
  46.  
  47. MCompMainFuncDcl MCompMainName(MInitInfo *initInfo)
  48. {
  49.     MDefineComponent(InterfacComp, kMCanDragOff);
  50.     MInheritClass(MComponent, kMCompNumProcs, kMBaseCompSlot);
  51.  
  52.     // MComponent methods we must override
  53.  
  54.     MDefineMethod(kInterfacSlot, kMBaseCompSlot, kMCompConstructor, MCompConstructor);
  55.     MDefineMethod(kInterfacSlot, kMBaseCompSlot, kMCompCopy, MCompCopy);
  56.     MDefineMethod(kInterfacSlot, kMBaseCompSlot, kMCompCopyConstructor, MCompCopyConstructor);
  57.     MDefineMethod(kInterfacSlot, kMBaseCompSlot, kMCompDestructor, MCompDestructor);
  58.  
  59.     // MComponent methods we choose to override
  60.  
  61.     MDefineMethod(kInterfacSlot, kMBaseCompSlot, kMCompEditorOpen, MCompEditorOpen);
  62.     MDefineMethod(kInterfacSlot, kMBaseCompSlot, kMCompEditorItemChanged, MCompEditorItemChanged);
  63.     MDefineMethod(kInterfacSlot, kMBaseCompSlot, kMCompEditorAccept, MCompEditorAccept);
  64.     MDefineMethod(kInterfacSlot, kMBaseCompSlot, kMCompEditorDecline, MCompEditorDecline);
  65.  
  66.     MDefineMethod(kInterfacSlot, kMBaseCompSlot, kMCompGetSaveInfo, MCompGetSaveInfo);
  67.     MDefineMethod(kInterfacSlot, kMBaseCompSlot, kMCompSaveComponent, MCompSaveComponent);
  68.     MDefineMethod(kInterfacSlot, kMBaseCompSlot, kMCompRestoreComponent, MCompRestoreComponent);
  69.  
  70.     MConnectCommonServices(initInfo);
  71.  
  72.     MEndComponentDef;
  73. }
  74.  
  75.  
  76. /*    Initialize component
  77. */
  78.  
  79. static MErr MCompConstructor(InterfacComp *self, MObjectRef *mRef)
  80. {
  81.     MInitEvent(self->f_activate, kMMouseDown, 0);
  82.     MInitSymbol(self->f_sound, -1,0);
  83.     MInitIDPath(self->f_scene, 3, self->f_sceneIDs);
  84.     self->f_sceneIDs[0] = self->f_sceneIDs[1] = self->f_sceneIDs[2] = 0;
  85.  
  86.     MInitSymbol(self->f_static, 1, 0);
  87.     MInitSymbol(self->f_dynamic, 1, 0);
  88.     MInitSymbol(self->f_submenu, 11, 0);
  89.  
  90.     MInitInteger(self->f_yesNoMaybe, kYes);
  91.  
  92.     MInitBoolean(self->f_show, false);
  93.     MInitBoolean(self->f_play, false);
  94.     MInitBoolean(self->f_backward, false);
  95.  
  96.     MInitInteger(self->f_integer, 0);
  97.     MInitDouble(self->f_double, 0.0);
  98.     MInitTime(self->f_time, 0, 1, 600);
  99.     MInitSizedString(self->f_string, kStrMaxLen);
  100.     if ( !self->f_string.f_ptr )
  101.         return kMUnableToComplyCompErr;
  102.  
  103.     MInitSizedString(self->f_block, 0);
  104.     return kMNoCompErr;
  105. }
  106.  
  107.  
  108. /*    Copy component data
  109. */
  110.  
  111. static MErr MCompCopy(InterfacComp *self, InterfacComp *previousSelf)
  112. {
  113.     MCopyEvent(self->f_activate, previousSelf->f_activate);
  114.     MCopySymbol(self->f_sound, previousSelf->f_sound);
  115.     MCopyIDPath(self->f_scene, previousSelf->f_scene);
  116.     
  117.     MCopySymbol(self->f_static, previousSelf->f_static);
  118.     MCopySymbol(self->f_dynamic, previousSelf->f_dynamic);
  119.     MCopySymbol(self->f_submenu, previousSelf->f_submenu);
  120.  
  121.     MCopyInteger(self->f_yesNoMaybe, previousSelf->f_yesNoMaybe);
  122.  
  123.     MCopyBoolean(self->f_show, previousSelf->f_show);
  124.     MCopyBoolean(self->f_play, previousSelf->f_play);
  125.     MCopyBoolean(self->f_backward, previousSelf->f_backward);
  126.  
  127.     MCopyInteger(self->f_integer, previousSelf->f_integer);
  128.     MCopyDouble(self->f_double, previousSelf->f_double);
  129.     MCopyTime(self->f_time, previousSelf->f_time);
  130.     MCopyString(self, self->f_string, previousSelf->f_string);
  131.     
  132.     MCopyString(self, self->f_block, previousSelf->f_block);
  133.     return kMNoCompErr;
  134. }
  135.  
  136.  
  137. /*    Copy component
  138. */
  139.  
  140. static MErr MCompCopyConstructor(InterfacComp *self, InterfacComp *previousSelf, MObjectRef *mRef)
  141. {
  142.     MCompConstructor(self, mRef);
  143.     return MCompCopy(self, previousSelf);
  144. }
  145.  
  146.  
  147. /*    Dispose component
  148. */
  149.  
  150. static MErr MCompDestructor(InterfacComp *self)
  151. {
  152.     MDisposeEvent(self->f_activate);
  153.     MDisposeSymbol(self->f_sound);
  154.     MDisposeIDPath(self->f_scene);
  155.  
  156.     MDisposeSymbol(self->f_static);
  157.     MDisposeSymbol(self->f_dynamic);
  158.     MDisposeSymbol(self->f_submenu);
  159.  
  160.     MDisposeInteger(self->f_yesNoMaybe);
  161.  
  162.     MDisposeBoolean(self->f_show);
  163.     MDisposeBoolean(self->f_play);
  164.     MDisposeBoolean(self->f_backward);
  165.  
  166.     MDisposeInteger(self->f_integer);
  167.     MDisposeDouble(self->f_double);
  168.     MDisposeTime(self->f_time);
  169.     MDisposeString(self->f_string);
  170.  
  171.     MDisposeString(self->f_block);
  172.     return kMNoCompErr;
  173. }
  174.  
  175.  
  176. /*    Open component dialog
  177. */
  178.  
  179. static MErr MCompEditorOpen(InterfacComp *self, void *editor, short editorType)
  180. {
  181.     if ( editorType == kMDialogEditorType ) {
  182.         MBoolean    bool;
  183.  
  184.         MAddSymbol(editor, kDynamicPopup, "California", kMEnabledItem, 1, 0);
  185.         MAddSymbol(editor, kDynamicPopup, "New York", kMEnabledItem, 2, 0);
  186.         MAddSymbol(editor, kDynamicPopup, "Illinois", kMEnabledItem, 3, 0);
  187.         MAddSymbol(editor, kDynamicPopup, "Louisiana", kMEnabledItem, 4, 0);
  188.         MAddSymbol(editor, kDynamicPopup, "-", kMDisabledItem, -1, 0);
  189.         MAddSymbol(editor, kDynamicPopup, "British Columbia", kMEnabledItem, 5, 0);
  190.         MAddSymbol(editor, kDynamicPopup, "Ontario", kMEnabledItem, 6, 0);
  191.  
  192.         MSetEditorItem(editor, kActivatePopup, (MDataType *) &self->f_activate);
  193.         MSetEditorItem(editor, kSoundPopup, (MDataType *) &self->f_sound);
  194.         MSetEditorItem(editor, kScenePopup, (MDataType *) &self->f_scene);
  195.  
  196.         MSetEditorItem(editor, kStaticPopup, (MDataType *) &self->f_static);
  197.         MSetEditorItem(editor, kDynamicPopup, (MDataType *) &self->f_dynamic);
  198.         
  199.         MAddSymbol(editor, kSubmenuPopup, "California", kMEnabledItem, 1, 0);
  200.         MAddSubSymbolItem(editor, kSubmenuPopup, 1, 0, "California", 11, 0, "San Mateo County");
  201.         MAddSubSymbolItem(editor, kSubmenuPopup, 1, 0, "California", 12, 0, "Santa Clara County");
  202.         MAddSubSymbolItem(editor, kSubmenuPopup, 1, 0, "California", 13, 0, "Marin County");
  203.         
  204.         MAddSymbol(editor, kSubmenuPopup, "Pennsylvania", kMEnabledItem, 2, 0);
  205.         MAddSubSymbolItem(editor, kSubmenuPopup, 2, 0, "Pennsylvania", 21, 0, "Allegheny County");
  206.         MAddSubSymbolItem(editor, kSubmenuPopup, 2, 0, "Pennsylvania", 22, 0, "Westchester County");
  207.         MAddSubSymbolItem(editor, kSubmenuPopup, 2, 0, "Pennsylvania", 23, 0, "Latrobe County");                
  208.         
  209.         MAddSymbol(editor, kSubmenuPopup, "-", kMDisabledItem, -1, 0);
  210.         
  211.         MAddSymbol(editor, kSubmenuPopup, "Ontario", kMEnabledItem, 3, 0);
  212.         MAddSubSymbolItem(editor, kSubmenuPopup, 3, 0, "Ontario", 31, 0, "Waterloo County");
  213.         MAddSubSymbolItem(editor, kSubmenuPopup, 3, 0, "Ontario", 32, 0, "Lanark County");
  214.         MAddSubSymbolItem(editor, kSubmenuPopup, 3, 0, "Ontario", 33, 0, "Wellington County");
  215.                         
  216.         MSetEditorItem(editor, kSubmenuPopup, (MDataType *) &self->f_submenu);
  217.  
  218.         MInitBoolean(bool, true);
  219.         MSetEditorItem(editor, kYesRadioButton + self->f_yesNoMaybe.f_value, (MDataType *) &bool);
  220.  
  221.         MSetEditorItem(editor, kShowCheckbox, (MDataType *) &self->f_show);
  222.         MSetEditorItem(editor, kPlayCheckbox, (MDataType *) &self->f_play);
  223.         if ( self->f_play.f_value ) {
  224.             MSetEditorItem(editor, kBackwardCheckbox, (MDataType *) &self->f_backward);
  225.         }
  226.         else {
  227.             MSetEditorItemState(editor, kBackwardCheckbox, kMDisabledItem);
  228.         }
  229.  
  230.         MSetEditorItem(editor, kIntegerField, (MDataType *) &self->f_integer);
  231.         MSetEditorItem(editor, kDoubleField, (MDataType *) &self->f_double);
  232.         MSetEditorItem(editor, kTimeField, (MDataType *) &self->f_time);
  233.         MSetEditorItem(editor, kStringField, (MDataType *) &self->f_string);
  234.  
  235.         MSetEditorItem(editor, kTextBlock, (MDataType *) &self->f_block);
  236.         return kMNoCompErr;
  237.     }
  238.     else
  239.         return kMUnableToComplyCompErr;
  240. }
  241.  
  242.  
  243. /*    Item changed in dialog
  244. */
  245.  
  246. static MErr MCompEditorItemChanged(InterfacComp *self, void *editor, short editorType, short item, short part)
  247. {
  248.     static int    selected = false;
  249.     MBoolean    bool;
  250.  
  251.     switch (item) {
  252.         case kBeepButton:
  253.             SysBeep(1);
  254.             break;
  255.  
  256.         case kIconButton:
  257.             if ( part == kMMouseUpPart ) {
  258.                 MControl cicns;
  259.  
  260.                 if ( selected ) {
  261.                     MInitControl(cicns, 1310, 1311, 0);
  262.                 }
  263.                 else {
  264.                     MInitControl(cicns, 1311, 1310, 0);
  265.                 }
  266.                 MSetItemSpec(editor, item, kMInteger, &cicns);
  267.                 selected = !selected;
  268.             }
  269.             break;
  270.  
  271.         case kPlayCheckbox:
  272.             MInitBoolean(bool, false);
  273.             MGetEditorItem(editor, kPlayCheckbox, (MDataType *) &bool);
  274.             if ( bool.f_value ) {
  275.                 MSetEditorItemState(editor, kBackwardCheckbox, kMEnabledItem);
  276.             }
  277.             else {
  278.                 bool.f_value = false;
  279.                 MSetEditorItem(editor, kBackwardCheckbox, (MDataType *) &bool);
  280.                 MSetEditorItemState(editor, kBackwardCheckbox, kMDisabledItem);
  281.             }
  282.             break;
  283.     }
  284.     return kMNoCompErr;
  285. }
  286.  
  287.  
  288. /*    Close component dialog
  289. */
  290.  
  291. static MErr MCompEditorAccept(InterfacComp *self, void *editor)
  292. {
  293.     MBoolean    bool;
  294.     MControl    spec;
  295.     long        strLen;
  296.  
  297.     MGetEditorItem(editor, kActivatePopup, (MDataType *) &self->f_activate);
  298.     MGetEditorItem(editor, kSoundPopup, (MDataType *) &self->f_sound);
  299.     MGetEditorItem(editor, kScenePopup, (MDataType *) &self->f_scene);
  300.  
  301.     MGetEditorItem(editor, kStaticPopup, (MDataType *) &self->f_static);
  302.     MGetEditorItem(editor, kDynamicPopup, (MDataType *) &self->f_dynamic);
  303.     MGetEditorItem(editor, kSubmenuPopup, (MDataType *) &self->f_submenu);
  304.     MForgetSymbols(editor, kDynamicPopup);
  305.     MForgetSymbols(editor, kSubmenuPopup);
  306.  
  307.     MInitBoolean(bool, false);
  308.     MGetEditorItem(editor, kYesRadioButton, (MDataType *) &bool);
  309.     self->f_yesNoMaybe.f_value = (bool.f_value) ? kYes : self->f_yesNoMaybe.f_value;
  310.     MGetEditorItem(editor, kNoRadioButton, (MDataType *) &bool);
  311.     self->f_yesNoMaybe.f_value = (bool.f_value) ? kNo : self->f_yesNoMaybe.f_value;
  312.     MGetEditorItem(editor, kMaybeRadioButton, (MDataType *) &bool);
  313.     self->f_yesNoMaybe.f_value = (bool.f_value) ? kMaybe : self->f_yesNoMaybe.f_value;
  314.  
  315.     MGetEditorItem(editor, kShowCheckbox, (MDataType *) &self->f_show);
  316.     MGetEditorItem(editor, kPlayCheckbox, (MDataType *) &self->f_play);
  317.     MGetEditorItem(editor, kBackwardCheckbox, (MDataType *) &self->f_backward);
  318.  
  319.     MGetEditorItem(editor, kIntegerField, (MDataType *) &self->f_integer);
  320.     MGetEditorItem(editor, kDoubleField, (MDataType *) &self->f_double);
  321.     MGetEditorItem(editor, kTimeField, (MDataType *) &self->f_time);
  322.  
  323.     MGetEditorItem(editor, kStringField, (MDataType *) &self->f_string);
  324.     MStrlen((size_t *) &self->f_string.f_strLen, self->f_string.f_ptr);
  325.  
  326.     MGetItemSpec(editor, kTextBlock, kMInteger, &spec);
  327.     strLen = (long) spec.f_value + 1;    // add one for null terminator
  328.     if ( strLen > self->f_block.f_strLen || strLen < self->f_block.f_strLen / 2 ) {
  329.         MDisposeString(self->f_block);
  330.         MInitSizedString(self->f_block, strLen);
  331.         if ( !self->f_block.f_ptr )
  332.             return kMUnableToComplyCompErr;
  333.     }
  334.     MGetEditorItem(editor, kTextBlock, (MDataType *) &self->f_block);
  335.     self->f_block.f_ptr[strLen - 1] = '\0';
  336.     MStrlen((size_t *) &self->f_block.f_strLen, self->f_block.f_ptr);
  337.     return kMNoCompErr;
  338. }
  339.  
  340.  
  341. /*    Cancel component dialog
  342. */
  343.  
  344. static MErr MCompEditorDecline(InterfacComp *self, void *editor)
  345. {
  346.     MForgetSymbols(editor, kDynamicPopup);
  347.     MForgetSymbols(editor, kSubmenuPopup);
  348.     return kMNoCompErr;
  349. }    
  350.  
  351.  
  352. /*    Provide save information
  353. */
  354.  
  355. static MErr MCompGetSaveInfo(InterfacComp *self, MFileIOServ *file, long saveInfo, short *rev, long *len)
  356. {
  357.     long    valueSize;
  358.  
  359.     MSizeOfValue(file, &self->f_activate, &valueSize);
  360.     *len = valueSize;
  361.     MSizeOfValue(file, &self->f_sound, &valueSize);
  362.     *len += valueSize;
  363.     MSizeOfValue(file, &self->f_scene, &valueSize);
  364.     *len += valueSize;
  365.     
  366.     MSizeOfValue(file, &self->f_static, &valueSize);
  367.     *len += valueSize;
  368.     MSizeOfValue(file, &self->f_dynamic, &valueSize);
  369.     *len += valueSize;
  370.     MSizeOfValue(file, &self->f_submenu, &valueSize);
  371.     *len += valueSize;
  372.     
  373.     MSizeOfValue(file, &self->f_yesNoMaybe, &valueSize);
  374.     *len += valueSize;
  375.     
  376.     MSizeOfValue(file, &self->f_show, &valueSize);
  377.     *len += valueSize;
  378.     MSizeOfValue(file, &self->f_play, &valueSize);
  379.     *len += valueSize;
  380.     MSizeOfValue(file, &self->f_backward, &valueSize);
  381.     *len += valueSize;
  382.     
  383.     MSizeOfValue(file, &self->f_integer, &valueSize);
  384.     *len += valueSize;
  385.     MSizeOfValue(file, &self->f_double, &valueSize);
  386.     *len += valueSize;
  387.     MSizeOfValue(file, &self->f_time, &valueSize);
  388.     *len += valueSize;
  389.     MSizeOfValue(file, &self->f_string, &valueSize);
  390.     *len += valueSize;
  391.     
  392.     MSizeOfValue(file, &self->f_block, &valueSize);
  393.     *len += valueSize;
  394.     
  395.     *rev = kInterfacRev;
  396.     return kMNoCompErr;
  397. }
  398.  
  399.  
  400. /*    Save component
  401. */
  402.  
  403. static MErr MCompSaveComponent(InterfacComp *self, MFileIOServ *file, long saveInfo)
  404. {
  405.     MWriteValue(file, &self->f_activate);
  406.     MWriteValue(file, &self->f_sound);
  407.     MWriteValue(file, &self->f_scene);
  408.     
  409.     MWriteValue(file, &self->f_static);
  410.     MWriteValue(file, &self->f_dynamic);
  411.     MWriteValue(file, &self->f_submenu);
  412.     
  413.     MWriteValue(file, &self->f_yesNoMaybe);
  414.     
  415.     MWriteValue(file, &self->f_show);
  416.     MWriteValue(file, &self->f_play);
  417.     MWriteValue(file, &self->f_backward);
  418.     
  419.     MWriteValue(file, &self->f_integer);
  420.     MWriteValue(file, &self->f_double);
  421.     MWriteValue(file, &self->f_time);
  422.     MWriteValue(file, &self->f_string);
  423.     
  424.     MWriteValue(file, &self->f_block);
  425.     return kMNoCompErr;
  426. }
  427.  
  428.  
  429. /*    Restore component
  430. */
  431.  
  432. static MErr MCompRestoreComponent(InterfacComp *self, MFileIOServ *file, long saveInfo, short rev)
  433. {
  434.     if ( rev == kInterfacRev ) {
  435.         MString    tempString;
  436.  
  437.         MReadValue(file, &self->f_activate);
  438.         MReadValue(file, &self->f_sound);
  439.         MReadValue(file, &self->f_scene);
  440.  
  441.         MReadValue(file, &self->f_static);
  442.         MReadValue(file, &self->f_dynamic);
  443.         MReadValue(file, &self->f_submenu);
  444.  
  445.         MReadValue(file, &self->f_yesNoMaybe);
  446.  
  447.         MReadValue(file, &self->f_show);
  448.         MReadValue(file, &self->f_play);
  449.         MReadValue(file, &self->f_backward);
  450.  
  451.         MReadValue(file, &self->f_integer);
  452.         MReadValue(file, &self->f_double);
  453.         MReadValue(file, &self->f_time);
  454.  
  455.         MInitSizedString(tempString, 0);
  456.         MReadValue(file, &tempString);
  457.         MCopyString(self, self->f_string, tempString);
  458.         self->f_string.f_ptr[self->f_string.f_strLen] = '\0';
  459.         MDisposeString(tempString);
  460.  
  461.         MInitSizedString(tempString, 0);
  462.         MReadValue(file, &tempString);
  463.         MCopyString(self, self->f_block, tempString);
  464.         self->f_block.f_ptr[self->f_block.f_strLen] = '\0';
  465.         MDisposeString(tempString);
  466.         return kMNoCompErr;
  467.     }
  468.     else
  469.         return kMUnableToComplyCompErr;
  470. }
  471.