HelpSource/Classes/ObjectGui.schelp

   1 CLASS:: ObjectGui
   2 summary:: Controller class for MVC architecture, superclass for all XYZGui classes
   3 related:: Reference/gui
   4 categories:: GUI
   5
   6 DESCRIPTION::
   7 In the MVC architecture this is the Controller, which creates Views for manipulating the properties of your Model, and receives messages from the View and enacts the changes on the Model.
   8
   9 Each class specifies its Gui class via the guiClass method.
  10
  11 The default guiClass for an Object is ObjectGui.  So if a class does not implement guiClass at all, then at least there is a default ObjectGui that will display the name.
  12
  13 Many subclasses overide the guiClass method to specify a different class, one that subclasses ObjectGui.
  14
  15 It is the simplest display, it is just the object asString.
  16
  17 The .gui method is called on your model:
  18
  19 code::
  20 // standard usage
  21 theModel.gui( parent, bounds )
  22
  23 // this results in these steps:
  24 guiClass = theModel.guiClass;
  25 gui = guiClass.new( theModel );
  26 gui.gui( parent, bounds );
  27 ::
  28
  29 In addition to those steps the model/gui dependencies are managed, defaults (nil parent or nil bounds) are managed and when the window or parent view is closed then dependencies are safely managed.
  30
  31
  32 CLASSMETHODS::
  33
  34 METHOD:: new
  35 Create a gui controller object but does not yet create the views / window.  Call .gui to create the views.
  36
  37 argument:: model
  38 The model is the object that the GUI is a graphical interface for.
  39
  40 returns:: the ObjectGui or subclass object
  41
  42
  43 INSTANCEMETHODS::
  44
  45 METHOD:: guiBody
  46 When implementing subclasses this is the primary and often the only method that needs to be implemented.  The ObjectGui parent class takes care of setting up all windows and dependencies and then the guiBody method adds views to the layout.  It is normal to declare instance variables in the ObjectGui subclass that are used to store the widgets so they can be updated later.
  47
  48 argument:: layout
  49 Usually a FlowView : a parent view with a FlowLayout to add views to.
  50
  51 returns:: this
  52
  53 METHOD:: update
  54 When the model is changed and the .changed method is called then .update is called on all dependants including this gui object.  Update the views you have placed in the guiBody.
  55
  56 argument:: changed
  57 The model.  Within your gui class the model is already in the instance variable 'model'.
  58
  59 argument:: changer
  60 Depends on the conventions of how .changed was called.  If an object called someModel.changed(this) then it is supplying itself as the changer and will be passed through here.  Sometimes a flag is used: someModel.changed('points') and the gui may know of and particpate in that convention.  Sometimes no changer is passed in.
  61
  62
  63 METHOD:: gui
  64 The standard method to create a view / window.  Usually you call yourModel.gui(parent,bounds) and this creates the gui (of the related ObjectGui subclass) and then theObjectGui.gui(parent,bounds) is called, forwarding the arguments.  So this method is what receives the forwarded (parent,bounds) from the initial call to theModel.gui(parent,bounds). Usually you do not call this manually and would avoid reimplementing it.
  65
  66 argument:: parent
  67 parent view : nil, a Window, a FlowView or any other usable container view.
  68
  69 argument:: bounds
  70 nil or a Rect.  The default of nil will offer the entire bounds to the guiBody method and then shrink the view size afterwards to the exact size of the contents that were actually added.
  71
  72 argument::  ... args
  73 More args may be passed into theModel.gui(parent,bounds,anArg,moreArg) and will be forwarded to guiBody.
  74
  75 returns:: this
  76
  77 METHOD:: guify
  78 This converts a supplied parent and bounds into a usable parent container view on a window.  It creates a window if needed.
  79
  80 argument:: parent
  81 parent view or nil
  82
  83 argument:: bounds
  84 desired bounds or nil
  85
  86 argument:: title
  87 window title IF a new window is being created.  if there is a parent view then title is ignored.
  88
  89 returns:: converted parent
  90
  91
  92 METHOD:: model
  93 set a new model. This allows to use a single gui and dynamically swap in a different model of the same class.  The old model releases the gui as a dependant and the new model adds the gui as a dependent.  Then the views are updated.
  94
  95 argument:: newModel
  96 The new object
  97
  98 returns:: (returnvalue)
  99
 100 METHOD:: dragSource
 101 The default implementation of writeName places a nameplate on the gui that is draggable.  This method is an accessor for that dragSource object.
 102
 103 returns:: a GUi.dragSource
 104
 105 METHOD:: viewDidClose
 106 This is called when the parent view closes. It releases dependants.
 107
 108 returns:: this
 109
 110 METHOD:: background
 111 Each ObjectGui subclass may implement a default background color.
 112
 113 returns:: a color
 114
 115 METHOD:: writeName
 116 ObjectGui by default makes a nameplate with the name of the model.  Implement this in subclasses if a different name style or no nameplate is desired.  Note: this may change in the near future.  So many classes overide this to shut off the name.
 117
 118 argument:: layout
 119 The layout to place the nameplate on.  Probably the same as is being passed to guiBody
 120
 121 METHOD:: prWriteName
 122 The default write name implementation.  You could call this from a subclass if you are primarily implementing writeName to customize what name is shown or to add other items to that area.
 123
 124 argument:: layout
 125 the layout
 126
 127 argument:: name
 128 the string to display
 129
 130
 131 EXAMPLES::
 132
 133 code::
 134
 135 YourSimpleGuiClass : ObjectGui {
 136
 137         guiBody { arg layout;
 138
 139                 // we refer to the model and
 140                 // access its variable howFast.
 141                 // if its a simple number, it will display
 142                 // using the default ObjectGui class, which
 143                 // will simply show its value as a string.
 144                 model.howFast.gui(layout);
 145         }
 146 }
 147
 148
 149 // more complex
 150 YourGuiClass : ObjectGui {
 151
 152         var numberEditor;
 153
 154         //for example
 155         guiBody { arg layout;
 156                 var r;
 157                 // the object you are making a gui for is referred to as the model
 158
 159                 // display some param on screen.
 160                 // here we assume that someParam is something that
 161                 //  has a suitable gui class
 162                 // implemented, or that the default ObjectGui is sufficient.
 163                 model.someParam.gui(layout);
 164
 165                 // using non 'gui' objects
 166                 r = layout.layRight(300,300); // allocate yourself some space
 167                 Button(layout.win,r)
 168                         .action_({ arg butt;
 169                                 model.goApeShit;
 170                         });
 171
 172                 // note: NumberEditor is a cruciallib class
 173                 // which is itself a model (its an editor of a value)
 174                 // and has its own gui class that creates and manages the NumberBox view
 175                 numberEditor = NumberEditor(model.howFast,[0,100])
 176                         .action_({ arg val;
 177                                 model.howFast = val;
 178                                 model.changed(this);
 179                                 // tell the model that this gui changed it
 180                         });
 181                 numberEditor.gui(layout);
 182         }
 183
 184         // your gui object will have update called any time the .changed message
 185         // is sent to your model
 186         update { arg changed,changer;
 187
 188                 if(changer !== this,{
 189                         /* if it is this gui object that changed the value
 190                                 using the numberEditor, then we already have a correct
 191                                 display and don't need to waste cpu to update it.
 192                                 if anyone else changed anything about the model,
 193                                 we will update ourselves here.
 194                         */
 195                         numberEditor.value = model.howFast;
 196                         /*
 197                                 note that
 198                                         numberEditor.value = model.howFast;
 199                                 is passive, and does not fire the numberEditor's action.
 200
 201                                 numberEditor.activeValue = model.howFast
 202                                 would fire the action as well, resulting in a loop that would
 203                                 probably crash your machine.
 204                         */
 205                 }
 206         }
 207
 208 }
 209 ::