home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1996 November / VPR9611B.ISO / vabasic / ntclnt.exe / DISK8 / data.8 / datab / INCLUDE / VWINTMIX.HH < prev    next >
Text File  |  1996-07-29  |  22KB  |  587 lines
  1. //------------------------------------------------------------------------
  2. // $Source: /rcs/vwrcs/engine/vwintmix.hh,v $
  3. // Checked in by: $Author: fulvio $
  4. // $Date: 1996/07/25 15:18:48 $             $Revision: 1.2 $
  5. //------------------------------------------------------------------------
  6. //       Copyright(c) 1993, Visual Edge Software Ltd.
  7. //
  8. // ALL RIGHTS RESERVED. This notice is intended as a precaution
  9. // against inadvertent publication, and shall not be deemed to
  10. // constitute an acknowledgment that publication has occurred
  11. // nor to imply any waiver of confidentiality. The year included
  12. // in the notice is the year of the creation of the work.
  13. //------------------------------------------------------------------------
  14. // DESCRIPTION:    Mixins providing class specific data
  15. //
  16. //------------------------------------------------------------------------
  17. // NOTE: This is a public API file
  18. //------------------------------------------------------------------------
  19.  
  20. #ifndef VWINTMIX_HH
  21. #define VWINTMIX_HH
  22.  
  23. #include <intmixin.hh>
  24.  
  25. //--------------------------------------------------------------------------
  26. // The VwToolData mixin provides the data necessary to represent a class
  27. // in the Toolbox.
  28. //--------------------------------------------------------------------------
  29.  
  30. VCLASS VwMixToolData : public VeMixToolData, public VeDelegateMixin
  31. {
  32. public:
  33.     VOPERDECL VwMixToolData(VePrimary *obj);
  34.  
  35.     static VMETHODDECL(void *) Creator(VePrimary *obj);
  36.  
  37.     //------------------------------------------------------------------
  38.     // Returns the visible class name to be seen by the user. Used
  39.     // in the builder for the lable in the Toolbox. If not specified
  40.     // the class name is used.
  41.     //------------------------------------------------------------------
  42.  
  43.     VMETHODDECL(VeString) IconLabel();
  44.  
  45.     //------------------------------------------------------------------
  46.     // Returns a filename containing a icon. Used in the builder for
  47.     // the icon in the Toolbox, and for a default visual representation
  48.     // for instances of non-visual classes. A default icon is provided.
  49.     //------------------------------------------------------------------
  50.  
  51.     VMETHODDECL(VeString) IconFilename();
  52.     VMETHODDECL(VTPixmap) Icon();
  53. };
  54.  
  55. //--------------------------------------------------------------------------
  56. // The VwHelpData mixin provides information for displaying context 
  57. // sensitive help about a class.
  58. //--------------------------------------------------------------------------
  59.  
  60. VCLASS VwMixHelpData : public VeMixHelpData, public VeDelegateMixin
  61. {
  62. public:
  63.     VOPERDECL VwMixHelpData(VePrimary *);
  64.  
  65.     static VMETHODDECL(void *) Creator(VePrimary *obj);
  66.  
  67.     //------------------------------------------------------------------
  68.     // Returns the help context ID for the class. 
  69.     //------------------------------------------------------------------
  70.  
  71.     VMETHODDECL(VTHelpContextId) ContextID();
  72.  
  73.     //------------------------------------------------------------------
  74.     // Returns the help file name where the help text is located.
  75.     // The default implementation returns the system help file.
  76.     //------------------------------------------------------------------
  77.  
  78.     VMETHODDECL(VeString) HelpFile(); 
  79. };
  80.  
  81. //--------------------------------------------------------------------------
  82. // The VwVisualData mixin is used to specify configurable information
  83. // for visual classes and for visuals of non-visual classes.
  84. //--------------------------------------------------------------------------
  85.  
  86. VCLASS VwMixVisualData : public VeMixVisualData, public VeDelegateMixin
  87. {
  88. public:
  89.     VOPERDECL VwMixVisualData(VePrimary *obj);
  90.  
  91.     static VMETHODDECL(void *) Creator(VePrimary *obj);
  92.  
  93.     //------------------------------------------------------------------
  94.     // Returns the class name for a visual design time representation
  95.     // of non-visual objects. By default, non-visual instances are 
  96.     // represented by an icon class.
  97.     // For a visual class it returns the visual class name.
  98.     //------------------------------------------------------------------
  99.  
  100.     VMETHODDECL(VeString) VisualClass();
  101.  
  102.     //------------------------------------------------------------------
  103.     // Returns whether objects of this class can have children. The
  104.     // default implementation returns False.
  105.     //------------------------------------------------------------------
  106.  
  107.     VMETHODDECL(bool_t) IsManager();
  108.  
  109.     //------------------------------------------------------------------
  110.     // Returns whether the object is graphically drawn on its parent
  111.     // i.e., has no window. The default implementation returns false.
  112.     //------------------------------------------------------------------
  113.  
  114.     VMETHODDECL(bool_t) IsDrawnOnParent();
  115.  
  116.     //------------------------------------------------------------------
  117.     // Returns whether the object can be constructed on the desktop.
  118.     // The default implementation returns false. If true, the 
  119.     // VToplevelIface must be supplied.
  120.     //------------------------------------------------------------------
  121.  
  122.     VMETHODDECL(bool_t) IsToplevel();
  123.  
  124.     //------------------------------------------------------------------
  125.     // True if object can be interactively resized. True by default.
  126.     //------------------------------------------------------------------
  127.  
  128.     VMETHODDECL(bool_t) IsResizable();
  129.  
  130.     //------------------------------------------------------------------
  131.     // True if object can be interactively moved. True by default.
  132.     //------------------------------------------------------------------
  133.  
  134.     VMETHODDECL(bool_t) IsMoveable();
  135.  
  136.     //------------------------------------------------------------------
  137.     // Returns default width/height for instances. In pixels. 50x50
  138.     // pixels by default.
  139.     //------------------------------------------------------------------
  140.  
  141.     VMETHODDECL(VTDimension) DefaultWidth();
  142.  
  143.     VMETHODDECL(VTDimension) DefaultHeight();
  144.  
  145.     //------------------------------------------------------------------
  146.     // True if object must be reconstructed when going to run mode
  147.     // Default is FALSE.
  148.     //------------------------------------------------------------------
  149.  
  150.     VMETHODDECL(bool_t) ReconstructToRun();
  151.  
  152.     VMETHODDECL(VTDimension)    VerticalTolerance();
  153.     VMETHODDECL(VTDimension)    HorizontalTolerance();
  154. };
  155.  
  156. //--------------------------------------------------------------------------
  157. // The VwVisualIface mixin  is used to compute configurable information
  158. // for visual classes (outline of a visual class) 
  159. //--------------------------------------------------------------------------
  160.  
  161. VCLASS VwMixVisualIface : public VeMixVisualIface, public VeDelegateMixin
  162. {
  163. public:
  164.     VOPERDECL VwMixVisualIface(VePrimary *obj);
  165.  
  166.     static VMETHODDECL(void *) Creator(VePrimary *obj);
  167.  
  168.     //------------------------------------------------------------------
  169.     // Returns the undelying toolkit gui for the object instance.
  170.     // An implementation for this method must be supplied.
  171.     //------------------------------------------------------------------
  172.  
  173.     VMETHODDECL(VTGui) NativeGui(VeObjectRef object);
  174.  
  175.     //------------------------------------------------------------------
  176.     // Called by the builder during a direct manipulation operation
  177.     // to set the new geometry for the instance. It is passed the
  178.     // bounding box measured in pixels. Returns a property value pairs
  179.     // list of the geometric properties of the object. 
  180.     //------------------------------------------------------------------
  181.  
  182.     VMETHODDECL(VePropertyList) SetGeometry(VeObjectRef obj,
  183.                     VTPosition x, VTPosition y,
  184.                     VTDimension width, 
  185.                     VTDimension height);
  186.  
  187.     VMETHODDECL(VePropertyList) SetDimension(VeObjectRef parent,
  188.                     VTDimension width, 
  189.                     VTDimension height);
  190.  
  191.     VMETHODDECL(VePropertyList) SetPosition(VeObjectRef parent,
  192.                     VTPosition x, 
  193.                     VTPosition y);
  194.  
  195.         //-----------------------------------------------------------------
  196.         // Called by builder just after creation (and right before
  197.         // PostRealize) to set initial values for properties. Integration
  198.         // code returns a list of property-value pairs which will be set
  199.         // be the builder. A fragment will also be forced on each of these
  200.         // properties.
  201.         //------------------------------------------------------------------
  202.         VMETHODDECL(VePropertyList) ForcedValues(VeObjectRef obj);
  203.  
  204.     //------------------------------------------------------------------
  205.     // Returns the bounding box area for the object, measured in
  206.     // pixels. X, and Y should be specified relative to its parent
  207.     // object.
  208.     //------------------------------------------------------------------
  209.  
  210.     VMETHODDECL(status_t) GetGeometry(VeObjectRef obj, VTPosition &x, 
  211.                  VTPosition &y, VTDimension &width, 
  212.                  VTDimension &height);
  213.  
  214.     //------------------------------------------------------------------
  215.     // Called before the underlying object is created. 
  216.     //------------------------------------------------------------------
  217.  
  218.     VMETHODDECL(void) PreRealize();
  219.  
  220.     //-----------------------------------------------------------------
  221.     // Called after the underlying object is created. 
  222.     //------------------------------------------------------------------
  223.  
  224.     VMETHODDECL(void) PostRealize(VeObjectRef object);
  225.  
  226.     //-----------------------------------------------------------------
  227.     // Called before the underlying object is destroyed. 
  228.     //------------------------------------------------------------------
  229.  
  230.     VMETHODDECL(void) PreDestroy(VeObjectRef object);
  231.     
  232. };
  233.  
  234. //--------------------------------------------------------------------------
  235. // The VwManagerData mixin provides information for deciding what kind
  236. // of children can be added to a manager.
  237. //--------------------------------------------------------------------------
  238.  
  239. VCLASS VwMixManagerIface : public VeMixManagerIface, public VeDelegateMixin
  240. {
  241. public:
  242.     VOPERDECL VwMixManagerIface(VePrimary *obj);
  243.  
  244.     static VMETHODDECL(void *) Creator(VePrimary *obj);
  245.  
  246.     //------------------------------------------------------------------
  247.     // Returns true if the class of child specified in classname
  248.     // can be created on the object associated with this mixin. 
  249.     //------------------------------------------------------------------
  250.  
  251.     VMETHODDECL(bool_t) CanAcceptChild(VeString classname);
  252.  
  253.     //------------------------------------------------------------------
  254.     // Returns true if the class of child specified in classname
  255.     // can be removed from the object associated with this mixin.
  256.     //------------------------------------------------------------------
  257.  
  258.     VMETHODDECL(bool_t) CanLoseChild(VeString classname);
  259.  
  260.     //------------------------------------------------------------------
  261.     // Returns the cursor to display during creation. 
  262.     //------------------------------------------------------------------
  263.  
  264.     VMETHODDECL(VTCursor) CreationCursor();
  265.  
  266.     //------------------------------------------------------------------
  267.     // Returns the undelying toolkit gui which takes children for
  268.     // the object instance.
  269.     //------------------------------------------------------------------
  270.  
  271.     VMETHODDECL(VTGui    ) NativeChildSite(VeObjectRef object); 
  272.     
  273. };
  274.  
  275. //--------------------------------------------------------------------------
  276. // Provides class data for customizing Code Window presentation of
  277. // objects
  278. //-------------------------------------------------------------------------
  279.  
  280. VCLASS VwMixClassEventData : public VeMixClassEventData, 
  281.                  public VeDelegateMixin
  282. {
  283. public:
  284.  
  285.     VOPERDECL            VwMixClassEventData(VePrimary *);
  286.  
  287.     //----------------------------------------------------------
  288.     // Get default event. If this mixin is not specified,
  289.     // the first event registered is assumed to be the default
  290.     // event.
  291.     //----------------------------------------------------------
  292.  
  293.     VVIRTUALDECL(VeString)        DefaultEvent();
  294.  
  295.     //----------------------------------------------------------
  296.     // Get name of the method that will trigger the load
  297.     // event. Default is "Load".
  298.     //----------------------------------------------------------
  299.  
  300.     VVIRTUALDECL(VeString)        LoadEventTrigger();
  301.  
  302. protected:
  303.     
  304. };
  305.  
  306.  
  307. //--------------------------------------------------------------------------
  308. // Provides class data for customizing Property Editor presentation of
  309. // objects
  310. //-------------------------------------------------------------------------
  311.  
  312. VCLASS VwMixClassEditData : public VeMixClassEditData,
  313.                             public VeDelegateMixin
  314. {
  315. public:
  316.     VOPERDECL VwMixClassEditData(VePrimary *obj);
  317.  
  318.     //---------------------------------------------------------
  319.     // Determines whether objects of this class can be loaded
  320.     // into an editor, and be modified.
  321.     //----------------------------------------------------------
  322.  
  323.     VMETHODDECL(VTEditorAccess) EditorAccess();
  324.  
  325.     //----------------------------------------------------------
  326.     // Provides list of property categories for use by property
  327.     // editor.
  328.     //----------------------------------------------------------
  329.  
  330.     VMETHODDECL(VTStringList) Categories();
  331.  
  332.     //----------------------------------------------------------
  333.     // Provides list of properties for which setting order is
  334.     // relevant in the order that they must be set within a same
  335.     // pass number.
  336.     //----------------------------------------------------------
  337.  
  338.     VVIRTUALDECL(VTStringList) PropsByPrecedence();
  339.  
  340. };
  341.  
  342. //---------------------------------------------------------------------
  343. // This mixin is used to provide a specialized editor for a class
  344. //---------------------------------------------------------------------
  345.  
  346. VCLASS VwMixClassEditIface : public VeMixClassEditIface, 
  347.                  public VeDelegateMixin
  348. {
  349. public:
  350.     VOPERDECL VwMixClassEditIface(VePrimary *obj);
  351.  
  352.     //------------------------------------------------------------------
  353.     // Open a specialized object editor
  354.     //------------------------------------------------------------------
  355.  
  356.     VMETHODDECL(VeObjectEditor *) OpenEditor(VeSupervisor *,
  357.                             VEditorAdaptor *);
  358. };
  359.  
  360. //-------------------------------------------------------------------------
  361. // This mixin  and the onew that follow are used to provide property 
  362. // editing information for an object editor.
  363. //------------------------------------------------------------------------
  364.  
  365. VCLASS VwMixPropEditData : public VeMixPropEditData,
  366.                public VeDelegateMixin
  367. {
  368. public:
  369.     VOPERDECL VwMixPropEditData(VePrimary *obj);
  370.  
  371.     //---------------------------------------------------------
  372.     // Determines whether property can be seen and modified
  373.     // in object editor
  374.     //----------------------------------------------------------
  375.  
  376.     VMETHODDECL(VTEditorAccess) EditorAccess();
  377.  
  378.     //-------------------------------------------------------------
  379.     // Determines if property values are only set when the builder
  380.     // switches to run mode. The default implementation returns
  381.     // False.
  382.     //-------------------------------------------------------------
  383.  
  384.     VMETHODDECL(bool_t)    DelayedSet();
  385.  
  386.     //-------------------------------------------------------------
  387.     // Determines whether property can be edited when multiple
  388.     // objects are being edited.
  389.     //-------------------------------------------------------------
  390.  
  391.     VMETHODDECL(bool_t)    MultiEdit();
  392.  
  393.     //-------------------------------------------------------------
  394.     // Determines whether property can be an expression or not
  395.     //-------------------------------------------------------------
  396.  
  397.     VMETHODDECL(bool_t)    CannotBeExpression();
  398.  
  399.     //-------------------------------------------------------------
  400.     // Determines whether property is volatile or not.
  401.     //-------------------------------------------------------------
  402.  
  403.     VMETHODDECL(bool_t)    Volatile();
  404.  
  405.     //-------------------------------------------------------------
  406.     // Provides the list of allowable values.
  407.     //-------------------------------------------------------------
  408.  
  409.     VMETHODDECL(VTStringList)    ValuesList(VeObjectRef);
  410.  
  411.     //-------------------------------------------------------------
  412.     // Determines it the ValuesList is fixed or if the use can
  413.     // supply his own value.
  414.     //-------------------------------------------------------------
  415.  
  416.     VMETHODDECL(bool_t)        FixedList(VeObjectRef);
  417.  
  418.     //-------------------------------------------------------------
  419.     // Provides the list of allowable constants when above values
  420.     // represent enumeration constants.  If this list is not empty,
  421.     // make sure that it has the same number of items as ValuesList.
  422.     //-------------------------------------------------------------
  423.  
  424.     VMETHODDECL(VeEnumTable)        ValuesConstsList(VeObjectRef);
  425.     
  426.     //---------------------------------------------------------------
  427.     // When an object editor applies a batch of changes, it will
  428.     // submit changes for all properties of pass n before any of
  429.     // pass n+1. Pass zero properties are constructor arguments
  430.     //---------------------------------------------------------------
  431.  
  432.     VMETHODDECL(int)    Pass();
  433.  
  434.     //---------------------------------------------------------
  435.     // List categories this properties can appear in.
  436.     //---------------------------------------------------------
  437.  
  438.     VMETHODDECL(VTStringList) Categories();
  439.  
  440.     //------------------------------------------------------------------
  441.     // Returns the help context ID for a property
  442.     //------------------------------------------------------------------
  443.  
  444.     VMETHODDECL(VTHelpContextId) ContextID();
  445.  
  446. };
  447.  
  448. //------------------------------------------------------------------------
  449. // This mixin should be provided when default value for a property
  450. // needs to be specified.
  451. //------------------------------------------------------------------------
  452.  
  453. VCLASS VwMixPropDefaultData : public VeMixPropDefaultData, 
  454.                   public VeDelegateMixin
  455. {
  456. public:
  457.  
  458.     VOPERDECL VwMixPropDefaultData(VePrimary *obj);
  459.  
  460.     //------------------------------------------------------------------
  461.     // Returns the default value for property. Value is returned
  462.     // as a string, It is converted to the right type internally.
  463.     // Method should be used for property that are also default
  464.     // constructor arguments.
  465.     //------------------------------------------------------------------
  466.  
  467.     VMETHODDECL(VeSourceText) DefaultValue();
  468. };
  469.  
  470. //-------------------------------------------------------------------------
  471. // This mixin  and the one that follow are used to provide property 
  472. // editing behavior for an object editor.
  473. //------------------------------------------------------------------------
  474.  
  475. VCLASS VwMixPropEditIface : public VeMixPropEditIface, 
  476.                 public VeDelegateMixin
  477. {
  478. public:
  479.  
  480.     VOPERDECL VwMixPropEditIface(VePrimary *obj);
  481.  
  482.     //-------------------------------------------------------------
  483.     // Allows two values to be compared for equality.
  484.     //-------------------------------------------------------------
  485.  
  486.     VMETHODDECL(bool_t)    Equal(VeObjectRef, VeValue&, VeValue&);
  487.  
  488.     //-------------------------------------------------------------
  489.     // Allows the editor string value to be retreived from the object.
  490.     //-------------------------------------------------------------
  491.  
  492.     VMETHODDECL(char *)    Value(VeObjectRef);
  493.  
  494.         //-----------------------------------------------------
  495.         // Provides the displayable string for a property value
  496.         //-----------------------------------------------------
  497.         
  498.         VMETHODDECL(VeString)    FormatForDisplay(VeString);
  499.        
  500. }; 
  501.  
  502. //------------------------------------------------------------------------
  503. // This mixin should be provided when a property tool is available for
  504. // this property.
  505. //------------------------------------------------------------------------
  506.  
  507. VCLASS VwMixPropToolIface : public VeMixPropToolIface,
  508.                 public VeDelegateMixin
  509. {
  510. public:
  511.     VOPERDECL VwMixPropToolIface(VePrimary *obj);
  512.  
  513.     //--------------------------------------------------------------
  514.     // Popup a property tool for this property.
  515.     //-------------------------------------------------------------
  516.  
  517.     VMETHODDECL(VePropertyTool *)     OpenPropTool(VeObjectEditor *parent,
  518.                         VTGeometry *geom);
  519. };
  520.  
  521. //------------------------------------------------------------------------
  522. // This mixin should be provided when a type editor is available for
  523. // this property.
  524. //------------------------------------------------------------------------
  525.  
  526. VCLASS VwMixTypeEditorIface : public VeMixTypeEditorIface,
  527.                   public VeDelegateMixin
  528. {
  529. public:    
  530.     VOPERDECL VwMixTypeEditorIface(VePrimary *obj);
  531.  
  532.     //--------------------------------------------------------------
  533.     // Popup a type editor for this propety.
  534.     //-------------------------------------------------------------
  535.  
  536.     VMETHODDECL(VeTypeEditor *)     OpenTypeEditor(VeSupervisor *,
  537.                         VTypeEditorAdaptor *);
  538.                         
  539. };
  540.  
  541. VCLASS VwMixValidationIface : public VeMixValidationIface,
  542.                   public VeDelegateMixin
  543. {
  544. public:
  545.     VOPERDECL VwMixValidationIface(VePrimary *obj);
  546.  
  547.     //-----------------------------------------------------------------
  548.     // Validates given property value. Default is OKStatus.
  549.     //-----------------------------------------------------------------
  550.  
  551.     VMETHODDECL(status_t)    Validate(VeObjectRef, VeValue);
  552.  
  553.     //------------------------------------------------------------------
  554.     // A converter can be used to convert default property values into 
  555.     // more presentable form.
  556.     //------------------------------------------------------------------
  557.  
  558.     VMETHODDECL(VeValue)    Convert(VeObjectRef, VeValue);
  559.  
  560. };
  561.  
  562. VCLASS VwMixCopyValueIface : public VeMixCopyValueIface,
  563.                  public VeDelegateMixin
  564. {
  565. public:
  566.     VOPERDECL VwMixCopyValueIface(VePrimary *obj);
  567.     static VMETHODDECL(VeMixin *) Creator(VePrimary *obj);
  568.  
  569.     //----------------------------------------------------------------
  570.     // Returns a new copy of the given property value. Values that
  571.     // are pointers to memory should use this to allocate a copy.
  572.     //----------------------------------------------------------------
  573.  
  574.     VMETHODDECL(VeSourceText) CopyValue(VeObjectRef,
  575.                     VeValue,
  576.                     VeMultiStream&);
  577.  
  578.     //----------------------------------------------------------------
  579.     // Frees a copied property value
  580.     //----------------------------------------------------------------
  581.  
  582.     VMETHODDECL(void)    FreeValue(VeObjectRef, VeValue);
  583.     
  584. };
  585.  
  586. #endif // VWINTMIX_HH
  587.