int RingMasterClassDesc::BeginCreate(Interface *i)
{
   IObjCreate *iob = i->GetIObjCreate();
 
   // This creates a new ring master object and starts the editing
   // of the objects parameters.
   theRingMasterCreateMode.Begin( iob, this );
 
   // This sets the creation command mode as the active mode
   // at the top of the command stack.
   iob->PushCommandMode( &theRingMasterCreateMode );
 
   return1;
}

// This is the command mode that manages the overall process when
// the system is created.
class RingMasterCreateMode : publicCommandMode
{
   // This instance of RingMasterCreationMangaer handles the user/mouse
   // interaction as the Ring Array is created.
   RingMasterCreationManager proc;
   public:
 
   // These two methods just call the creation proc method of
   // the same name.
   // This creates a new ring master object and starts the editing
   // of the objects parameters. This is called just before the
   // command mode is pushed on the stack to begin the creation
   // process.
   voidBegin( IObjCreate *ioc, ClassDesc *desc )
   { proc.Begin( ioc, desc ); }
 
   // This terminates the editing of the ring masters parameters.
   // This is called just before the command mode is removed from
   // the command stack.
   voidEnd() { proc.End(); }
 
   // This returns the type of command mode this is. See the online
   // help under this method for a list of the available choices.
   // In this case we are a creation command mode.
   intClass() { returnCREATE_COMMAND; }
 
   // Returns the ID of the command mode. This value should be the
   // constant CID_USER plus some random value chosen
   // by the developer.
   intID() { returnCID_RINGCREATE; }
 
   // This method returns a pointer to the mouse proc that will
   // handle the user/mouse interaction. It also establishes
   // the number of points that may be accepted by the mouse proc.
   // In this case we set the number of points to 100000. The user
   // process will terminate prior to this many points being
   // entered when the mouse proc returns FALSE.
   // The mouse proc returned from this method is an instance of
   // RingMasterCreationManager. Note that that class is derived
   // from MouseCallBack.
   MouseCallBack *MouseProc(int *numPoints)
   { *numPoints = 100000; return &proc; }
 
   // This method is called to flag nodes in the foreground plane.
   // We just return the standard CHANGE_FG_SELECTED value
   // to indicate that selected nodes will go into the foreground.
   // This allows the system to speed up screen redraws. See the
   // Advanced Topics section on Foreground / Background planes
   // for more details.
    ChangeForegroundCallback *ChangeFGProc()
   { return CHANGE_FG_SELECTED; }
 
   // This method returns TRUE if the command mode needs to
   // change the foreground proc (using ChangeFGProc()) and FALSE
   // if it does not.
   BOOLChangeFG( CommandMode *oldMode )
   { return (oldMode->ChangeFGProc() != CHANGE_FG_SELECTED); }
 
   // This method is called when a command mode becomes active. We
   // don't need to do anything at this time so our implementation
   // is NULL
   voidEnterMode() {}
 
   // This method is called when the command mode is replaced by
   // another mode. Again, we don't need to do anything special here.
   voidExitMode() {}
};

// Snap the inital mouse point
mat.IdentityMatrix();
center = vpx->SnapPoint(m,m,NULL,SNAP_IN_PLANE);
mat.SetTrans(center);
 
// This method creates an instance of a plug-in object
// given its SuperClassID and ClassID. Here we create
// a dummy object at the center of the Ring Array system.
DummyObject *dumObj = (DummyObject *)createInterface->
CreateInstance(HELPER_CLASS_ID,Class_ID(DUMMY_CLASS_ID,0));
assert(dumObj);
 
// This method creates a node given the instance.
dummyNode = createInterface->CreateObjectNode(dumObj);
 
// This sets the size of the dummy object
// box representation
dumObj->SetBox(Box3(Point3(-DUMSZ,-DUMSZ,-DUMSZ),
Point3(DUMSZ,DUMSZ,DUMSZ)));

// These are the instances that surround the center of
// the Ring Array
GenBoxObject *ob = ( GenBoxObject *)createInterface->
CreateInstance(GEOMOBJECT_CLASS_ID,Class_ID(BOXOBJ_CLASS_ID,0));
ob->SetParams(BOXSZ,BOXSZ,BOXSZ,1,1,1,FALSE);

// This is the loop that creates the nodes in the ring
// array, sets their controller, and attaches them to
// the parent node.
for (int i=0; i<theMaster-> GetNum(createInterface->GetTime()); i++)
{
   // Create a new node given the instance.
   newNode = createInterface->CreateObjectNode(ob);
 
   // Create a new slave controller of the master control.
   // This constructor creates a reference from the slave
   // controller to the master. This is done so the
   // system is aware of the dependency between the
   // slave controller and the RingMaster object.
   SlaveControl* slave = new SlaveControl(theMaster,i);
 
   // Set the transform controller used by the node.
   newNode->SetTMController(slave);
 
   // Attach the new node as a child of the central node.
   dummyNode->AttachChild(newNode);
 
   // Set the new node as the 'i-th' slave node
   // of the master object.
   theMaster->SetSlaveNode(i,newNode);
}

case MOUSE_MOVE:
   if (node0)
   {
     r = (float)fabs(vpx->SnapLength(vpx->GetCPDisp(center,Point3(0,1,0),pt0,m)));
     theMaster->SetRad(0,r);
     theMaster->radSpin->SetValue(r, FALSE );
     createInterface->RedrawViews(createInterface->GetTime(),REDRAW_NORMAL,theMaster);
   }
   res = TRUE;
   break;

else
{
   // The mouse has been released - finish the creation
   // process. Select the first node so if we go into
   // the motion branch we'll see its parameters.
   // We set the flag to ignore the selection change
   // because the NotifyRefChanged() method receives
   // a message when the node is selected or deselected
   // and terminates the parameter editing process. This
   // flag causes it to ignore the selection change.
   ignoreSelectionChange = TRUE;
   createInterface->SelectNode( theMaster->GetSlaveNode(0) );
   ignoreSelectionChange = FALSE;
 
   // This registers the undo object with the system so
   // the user may undo the creation.
   theHold.Accept(IDS_CREATE);
 
   // Set the return value to FALSE to indicate the
   // creation process is finished. This mouse proc will
   // no longer be called until the user creates another
   // Ring Array.
   res = FALSE;
}