#include <referencemgr.h>
Public Member Functions |
|
RefMgrAddDeleteRestore (RefMgr< T > *mgr, int which, RefTargetHandle ref) | |
~RefMgrAddDeleteRestore () | |
virtual Class_ID | ClassID () |
Retrieves a constant that uniquely
identifies the plugin class. |
|
void | Restore (int isUndo) |
void | Redo () |
MSTR | Description () |
virtual RefResult | NotifyRefChanged (Interval changeInt, RefTargetHandle hTarget, PartID &partID, RefMessage message) |
Receives and responds to messages. |
|
virtual int | NumRefs () |
Returns the total number of references this
ReferenceMaker can hold. |
|
virtual RefTargetHandle | GetReference (int i) |
Returns the 'i-th' reference. |
|
virtual BOOL | CanTransferReference (int i) |
Tells whether this reference can be
transfered. |
|
Protected Member Functions |
|
virtual void | SetReference (int i, RefTargetHandle rtarg) |
Stores a
ReferenceTarget as its 'i-th' reference`. |
RefMgrAddDeleteRestore | ( | RefMgr< T > * | mgr, |
int | which, | ||
RefTargetHandle | ref | ||
) | [inline] |
: mMgr(NULL), mRefTarg(which < 0 ? NULL : mgr->GetRefTarget(which)), mRef(ref), undone(FALSE) { ReplaceReference(0, mgr); if (mRefTarg != NULL) mRefTarg->SetHeld(true); }
~RefMgrAddDeleteRestore | ( | ) | [inline] |
{ if (mRefTarg != NULL) { if (mMgr != NULL) mMgr->RemoveRef(mRefTarg); delete mRefTarg; } DeleteAllRefs(); }
virtual Class_ID ClassID | ( | ) | [inline, virtual] |
Retrieves a constant that uniquely identifies the plugin class.
This method must return the unique ID for the plugin class. If two ClassIDs conflict, the system will only load the first conflicting one it finds. A program (gencid.exe) is provided to generate unique class id values.
Reimplemented from Animatable.
{ return Class_ID(0x102f266c, 0x23492667); }
void Restore | ( | int | isUndo | ) | [inline, virtual] |
isUndo | Nonzero if Restore() is being called in response to the Undo command; otherwise zero. If isUndo is nonzero, the developer needs to save whatever data they need to allow the user to redo the operation. |
Implements RestoreObj.
{ int isUndo2; BOOL isInRestore = theHold.Restoring(isUndo2); if (isInRestore) // really doing a restore { if (undone) return; undone = TRUE; } else // really doing a redo { if (!undone) return; undone = FALSE; } if (mMgr != NULL) { if (mRefTarg == NULL) { int i = mMgr->FindRefTargetHandleIndex(mRef); if (i >= 0) { mRefTarg = mMgr->mRefTargetPtrs[i]; mRefTarg->SetHeld(true); mMgr->mRefTargetPtrs.Delete(i, 1); } } else { mMgr->RemoveRef(mRefTarg); mRefTarg->SetRefTargetHandle(mRef); mMgr->mRefTargetPtrs.Append(1, &mRefTarg, 3); mRefTarg->SetHeld(false); mRefTarg = NULL; } } }
void Redo | ( | ) | [inline, virtual] |
Implements RestoreObj.
{ Restore(false); }
MSTR Description | ( | ) | [inline, virtual] |
Reimplemented from RestoreObj.
{ return _M("RefMgrAddDeleteRestore"); }
virtual RefResult NotifyRefChanged | ( | Interval | changeInt, |
RefTargetHandle | hTarget, | ||
PartID & | partID, | ||
RefMessage | message | ||
) | [inline, virtual] |
Receives and responds to messages.
A plugin which makes references must implement a method to receive and respond to messages broadcast by its dependents. This is done by implementing NotifyRefChanged(). The plugin developer usually implements this method as a switch statement where each case is one of the messages the plugin needs to respond to. The Method StdNotifyRefChanged calls this, which can change the partID to new value. If it doesn't depend on the particular message& partID, it should return REF_DONTCARE.
changeInt | - This is the interval of time over which the message is active. Currently, all plug-ins will receive FOREVER for this interval. |
hTarget | - This is the handle of the reference target the message was sent by. The reference maker uses this handle to know specifically which reference target sent the message. |
partID | - This contains information specific to the message passed in. Some messages don't use the partID at all. See the section List of Reference Messages for more information about the meaning of the partID for some common messages. |
message | - The message parameters passed into this method is the specific message which needs to be handled. |
Implements ReferenceMaker.
{ switch (message) { case REFMSG_TARGET_DELETED: mMgr = NULL; break; } return REF_SUCCEED; }
virtual int NumRefs | ( | ) | [inline, virtual] |
Returns the total number of references this ReferenceMaker can hold.
The plugin implements this method to indicate the total number of of references it can make. This includes all references whether they are NULL (inactive) or non-NULL (active) at the time when this method is called. A plugin can hold a variable number of references, thus the return value of this method is not to be cached and reused by client code.
Reimplemented from ReferenceMaker.
{ return 1; }
virtual RefTargetHandle GetReference | ( | int | i | ) | [inline, virtual] |
Returns the 'i-th' reference.
The plugin implements this method to return its 'i-th' reference. The plug-in simply keeps track of its references using an integer index for each one. This method is normally called by the system.
i | - The index of the reference to retrieve. Valid values are from 0 to NumRefs()-1. |
Reimplemented from ReferenceMaker.
{ return i == 0 ? mMgr : NULL; }
virtual void SetReference | ( | int | i, |
RefTargetHandle | rtarg | ||
) | [inline, protected, virtual] |
Stores a ReferenceTarget as its 'i-th' reference`.
The plugin implements this method to store the reference handle passed to it as its 'i-th' reference. In its implementation of this method, the plugin should simply assign the reference handle passed in as a parameter to the member variable that holds the 'i-th' reference. Other reference handling methods such as ReferenceMaker::DeleteReference(), or ReferenceMaker::ReplaceReference() should not be called from within this method. The plugin itself or other plugins should not call this method directly. The system will call this method when a new reference is created or an existing one is replaced by calling ReferenceMaker::ReplaceReference().
i | - The index of the reference to store. Valid values are from 0 to NumRefs()-1. |
rtarg | - The reference handle to store. |
Reimplemented from ReferenceMaker.
{ if (i == 0) mMgr = static_cast<RefMgr<T>*>(rtarg); }
virtual BOOL CanTransferReference | ( | int | i | ) | [inline, virtual] |
Tells whether this reference can be transfered.
A ReferenceMaker can choose not to let ReferenceTarget::TransferReferences() affect it. Note that plugins probably should not use this. It is used by certain system objects that have references.
i | - Currently not used. |
Reimplemented from ReferenceMaker.
{ return FALSE; }