SavePathArraysAction Class Reference

Given a path, save the paths array data, ie all its verbs, coords and flags on the undo. Use DoRecord(Operation*, ActionList*,Path*) to save the path. More...

#include <pathedit.h>

Inheritance diagram for SavePathArraysAction:

List of all members.

Public Member Functions
	SavePathArraysAction ()
	Constructor for the action to store a path on the undo.
	~SavePathArraysAction ()
	destructor for the action to store a path on the undo
virtual ActionCode	Execute ()
	This function executes the SavePath action which will create an opposite action record dependent on whether we're undoing or redoing. It will swap the saved information about the path between the executing action record and the arrays of the path.
Static Public Member Functions
static ActionCode	DoRecord (Operation *pOp, ActionList *pActionList, Path *pPath)
	Use this function to get the SavePathArraysAction going. It is far simpler and less error prone than calling SavePathArraysAction::Init directly.
static ActionCode	Init (Operation *pOp, ActionList *pActionList, Path *Path, Action **NewAction, BOOL CreateArrays=TRUE)
	The actions static init function. The purpose of this function is to create instances of SavePathsArrayAction. Hence it static nature. It seems strange that you can call a function inside a class to create another instance of that class, but thats what really happens here. We pass back a pointer to the action if we've succeeded in creating it. This particular action init function also creates some external arrays to save a paths data in. You need to call the function with CreateArrays set to TRUE, to get it to save the paths arrays. It needs this parameter because the very same function is called within the execution of a previously created savepath action which incidently sets CreateArrays to FALSE. (You can get a serious headache thinking about this one). The idea is really to create the save arrays once, when this init function is called and swap them between undo and redo actions, killing them off only when the last thread is destructed.
Private Member Functions
ActionCode	SetUpArrays (Path *pPath, Operation *pOp)
BOOL	SavePathArrays (Path *pPath, Operation *pOp, PathFlags **pFlags, PathVerb **pVerbs, DocCoord **pCoords)
	Creates three arrays and copies the input paths verbs, coords and flags into these. If successfull it will return pointers to these arrays in pFlags, pVerbs and pCoords.
void	SwapPathArrays ()
	Swaps the path array data with that saved in the action record.
Private Attributes
Path *	ChangedPath
PathVerb *	ChangedVerbs
PathFlags *	ChangedFlags
DocCoord *	ChangedCoords

---

Detailed Description

Given a path, save the paths array data, ie all its verbs, coords and flags on the undo. Use DoRecord(Operation*, ActionList*,Path*) to save the path.

Author:

Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com>

Date:

27/01/95

Definition at line 936 of file pathedit.h.

---

Constructor & Destructor Documentation

SavePathArraysAction::SavePathArraysAction (   )

Constructor for the action to store a path on the undo. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Definition at line 10039 of file pathedit.cpp. { ChangedPath = NULL; ChangedVerbs = NULL; ChangedFlags = NULL; ChangedCoords = NULL; }

SavePathArraysAction::~SavePathArraysAction (   )

destructor for the action to store a path on the undo Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Definition at line 10058 of file pathedit.cpp. { if (ChangedVerbs) CCFree(ChangedVerbs); if (ChangedCoords) CCFree(ChangedCoords); if (ChangedFlags) CCFree(ChangedFlags); }

---

Member Function Documentation

ActionCode SavePathArraysAction::DoRecord (  Operation *  pOp, ActionList *  pActionList, Path *  pPath )  [static]

Use this function to get the SavePathArraysAction going. It is far simpler and less error prone than calling SavePathArraysAction::Init directly. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: pOp  is the currently running operation [INPUTS] pActionList = a pointer ot the action list to which the action should be appended pPath = a pointer to the path whose data will be saved. NewAction  = a pointer to a pointer to an action, allowing the function [OUTPUTS] to return a pointer to the created action Returns: ActionCode, one of AC_OK, AC_NO_RECORD or AC_FAIL Errors: - See also: For a full explanation of this action see SavePathArraysAction::Init() Definition at line 10090 of file pathedit.cpp. { SavePathArraysAction* SaveAction; ActionCode Act = SavePathArraysAction::Init(pOp, pActionList, pPath, (Action**)&SaveAction, TRUE); return Act; }

ActionCode SavePathArraysAction::Execute (   )  [virtual]

This function executes the SavePath action which will create an opposite action record dependent on whether we're undoing or redoing. It will swap the saved information about the path between the executing action record and the arrays of the path. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: -  [INPUTS] Returns: one of AC_OK, AC_NORECORD, AC_FAIL Reimplemented from Action. Definition at line 10207 of file pathedit.cpp. { // first try to create an opposite action SavePathArraysAction* SaveAction; ActionCode Act; Act = SavePathArraysAction::Init(pOperation, pOppositeActLst, ChangedPath, (Action**)(&SaveAction), FALSE); if (Act == AC_FAIL) return AC_FAIL; // swap over the path data between this action record and the path. SwapPathArrays(); // and update the new actions array pointers if (SaveAction!=NULL) { SaveAction->ChangedFlags = ChangedFlags; SaveAction->ChangedVerbs = ChangedVerbs; SaveAction->ChangedCoords = ChangedCoords; // make sure we clear these pointer vals before the destructor does // as we're sharing the arrays. ChangedVerbs = NULL; ChangedCoords = NULL; ChangedFlags = NULL; } return Act; }

ActionCode SavePathArraysAction::Init (  Operation *  pOp, ActionList *  pActionList, Path *  pPath, Action **  NewAction, BOOL  CreateArrays = TRUE )  [static]

The actions static init function. The purpose of this function is to create instances of SavePathsArrayAction. Hence it static nature. It seems strange that you can call a function inside a class to create another instance of that class, but thats what really happens here. We pass back a pointer to the action if we've succeeded in creating it. This particular action init function also creates some external arrays to save a paths data in. You need to call the function with CreateArrays set to TRUE, to get it to save the paths arrays. It needs this parameter because the very same function is called within the execution of a previously created savepath action which incidently sets CreateArrays to FALSE. (You can get a serious headache thinking about this one). The idea is really to create the save arrays once, when this init function is called and swap them between undo and redo actions, killing them off only when the last thread is destructed. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: pOp  = a pointer to the operation to which this action belongs [INPUTS] pActionList = the action list to which this action should be added pPath = a pointer to the path whose data will be saved. CreateArrays= a boolean which should always be TRUE except for when this action is being executed by the undo/redo system. NewAction  = a pointer to a pointer to an action, allowing the function [OUTPUTS] to return a pointer to the created action Returns: ActionCode, one of AC_OK, AC_NO_RECORD or AC_FAIL See also: SavePathArraysAction::DoRecord() Definition at line 10136 of file pathedit.cpp. { ERROR1IF(pPath==NULL,AC_FAIL,"SavePathArraysAction::Init() passed a NULL path pointer"); UINT32 NumElements = pPath->GetNumCoords(); UINT32 ActSize = sizeof(SavePathArraysAction) + NumElements*(sizeof(PathVerb) + sizeof(PathFlags) + sizeof(DocCoord) ); ActionCode Ac = Action::Init( pOp, pActionList, ActSize, CC_RUNTIME_CLASS(SavePathArraysAction), NewAction); SavePathArraysAction* CreatedAction = (SavePathArraysAction*)(*NewAction); if (CreatedAction!=NULL) { CreatedAction->ChangedPath = pPath; if (CreateArrays) CreatedAction->SetUpArrays(pPath,pOp); } return Ac; }

BOOL SavePathArraysAction::SavePathArrays (  Path *  pPath, Operation *  pOp, PathFlags **  pFlags, PathVerb **  pVerbs, DocCoord **  pCoords )  [private]

Creates three arrays and copies the input paths verbs, coords and flags into these. If successfull it will return pointers to these arrays in pFlags, pVerbs and pCoords. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: pPath  = a pointer to the path to save [INPUTS] pOp = the current operation pointer Outputs pFlags points to a copied flags array, set to NULL if failed pVerbs points to a copied verb array, set to NULL if failed pCoords points to a copied coord array, set to NULL if failed Returns: TRUE if the paths arrays have been saved FALSE if not Definition at line 10261 of file pathedit.cpp. { UINT32 NumElements = pPath->GetNumCoords(); PathFlags* DFlags; PathVerb* DVerbs; DocCoord* DCoords; ALLOC_WITH_FAIL(DVerbs,(PathVerb*) CCMalloc(NumElements * sizeof(PathVerb)),pOp); ALLOC_WITH_FAIL(DCoords,(DocCoord*) CCMalloc(NumElements * sizeof(DocCoord)),pOp); ALLOC_WITH_FAIL(DFlags,(PathFlags*) CCMalloc(NumElements * sizeof(PathFlags)),pOp); if (!DVerbs || !DCoords || !DFlags) { if (DVerbs) CCFree(DVerbs); if (DCoords) CCFree(DCoords); if (DFlags) CCFree(DFlags); *pFlags=NULL; *pVerbs=NULL; *pCoords=NULL; return FALSE; } // Now copy the data from the path into the arrays DocCoord* SCoords = pPath->GetCoordArray(); PathFlags* SFlags = pPath->GetFlagArray(); PathVerb* SVerbs = pPath->GetVerbArray(); // Copy all the data memmove((void*)(DCoords), (void*)(SCoords), NumElements*sizeof(DocCoord)); memmove((void*)(DVerbs), (void*)(SVerbs), NumElements*sizeof(PathVerb)); memmove((void*)(DFlags), (void*)(SFlags), NumElements*sizeof(PathFlags)); *pFlags = DFlags; *pVerbs = DVerbs; *pCoords = DCoords; return TRUE; }

ActionCode SavePathArraysAction::SetUpArrays (  Path *  pPath, Operation *  pOp )  [private]

Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: pPath  = pointer to the path to save [INPUTS] pOp = pointer to the current operation Returns: one of AC_OK, AC_NORECORD, AC_FAIL Definition at line 10176 of file pathedit.cpp. { if (ChangedFlags!=NULL || ChangedVerbs!=NULL || ChangedCoords!=NULL) { ENSURE(TRUE,"SavePathArraysAction::SetUpArrays() failed"); return AC_FAIL; } if (!SavePathArrays(pPath, pOp, &ChangedFlags, &ChangedVerbs, &ChangedCoords)) return AC_FAIL; return AC_OK; }

void SavePathArraysAction::SwapPathArrays (   )  [private]

Swaps the path array data with that saved in the action record. Author: Mike_Kenny (Xara Group Ltd) <camelotdev@xara.com> Date: 27/01/95 Parameters: -  [INPUTS] Returns: - Definition at line 10319 of file pathedit.cpp. { INT32 NumElements = ChangedPath->GetNumCoords(); PathVerb* Verbs = ChangedPath->GetVerbArray(); DocCoord* Coords = ChangedPath->GetCoordArray(); PathFlags* Flags = ChangedPath->GetFlagArray(); PathVerb TempVerb; DocCoord TempCoord; PathFlags TempFlag; for (INT32 i=0; i<NumElements; i++) { TempVerb=Verbs[i]; Verbs[i]=ChangedVerbs[i]; ChangedVerbs[i]=TempVerb; TempCoord=Coords[i]; Coords[i]=ChangedCoords[i]; ChangedCoords[i]=TempCoord; TempFlag=Flags[i]; Flags[i]=ChangedFlags[i]; ChangedFlags[i]=TempFlag; } }

---

Member Data Documentation

DocCoord* SavePathArraysAction::ChangedCoords [private]

Definition at line 968 of file pathedit.h.

PathFlags* SavePathArraysAction::ChangedFlags [private]

Definition at line 967 of file pathedit.h.

Path* SavePathArraysAction::ChangedPath [private]

Definition at line 965 of file pathedit.h.

PathVerb* SavePathArraysAction::ChangedVerbs [private]

Definition at line 966 of file pathedit.h.

---

The documentation for this class was generated from the following files:

• Kernel/pathedit.h (r1785/r1282)
• Kernel/pathedit.cpp (r1785/r1282)

---