OpLayerGalChange Class Reference

#include <layergal.h>

Inheritance diagram for OpLayerGalChange:

List of all members.

Public Member Functions
	OpLayerGalChange ()
	OpLayerGalChange constructor (Creates an undoable operation).
void	DoWithParam (OpDescriptor *, OpParam *pOpParam)
	Performs the layer change operation defined by ((OpLayerGalParam*)pOpParam)->Reason. It handles the creation, deletion, changing, and moving of the layer provided.
void	GetOpName (String_256 *OpName)
	The GetOpName fn is overridden so that we return back a description appropriate to the type of attribute that the operation applies.
BOOL	DoInvalidateLayerRegion (Layer *pLayer)
	This invalidates the areas of the screen covered by the given layer This copes with guidelines if the given layer is a guides layer.
virtual BOOL	Undo ()
	The overloaded Undo operation refreshes the layer details in the layer manager.
virtual BOOL	Redo ()
	The overloaded Redo operation refreshes the layer details in the layer manager.
virtual BOOL	MayChangeNodeBounds () const
Static Public Member Functions
static BOOL	Init ()
	OpLayerGalChange initialiser method.
static OpState	GetState (String_256 *, OpDescriptor *)
	For finding the OpLayerGalChange's state.
static BOOL	IsFrameMode ()
Private Member Functions
	CC_DECLARE_DYNCREATE (OpLayerGalChange)
Private Attributes
OpLayerGalReason	Reason
Spread *	pSpread
Layer *	pOpUndoLayer
Layer *	pOpRedoLayer
UINT32	UndoIDS
BOOL	BroadcastLayerChanges

---

Detailed Description

Definition at line 277 of file layergal.h.

---

Constructor & Destructor Documentation

OpLayerGalChange::OpLayerGalChange (   )

OpLayerGalChange constructor (Creates an undoable operation). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 286 of file layergal.cpp. : UndoableOperation() { pSpread = NULL; UndoIDS = _R(IDS_NOTYPE); BroadcastLayerChanges = TRUE; pOpUndoLayer = NULL; pOpRedoLayer = NULL; }

---

Member Function Documentation

OpLayerGalChange::CC_DECLARE_DYNCREATE (  OpLayerGalChange   )  [private]

BOOL OpLayerGalChange::DoInvalidateLayerRegion (  Layer *  pLayer  )

This invalidates the areas of the screen covered by the given layer This copes with guidelines if the given layer is a guides layer. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 21/9/95 Parameters: pLayer  = ptr to layer [INPUTS] -  [OUTPUTS] Returns: TRUE for success, FALSE otherwise We have to do guidelines separately, because guidelines don't get included in the bounding rect of the layer, hence DoInvalidateNodeRegion(pLayer) won't work Returns: Errors: - See also: - Definition at line 1066 of file layergal.cpp. { ERROR2IF(pLayer == NULL,FALSE, "pLayer is NULL"); ERROR2IF(pSpread == NULL,FALSE,"pSpread is NULL"); BOOL ok = TRUE; if (pLayer->IsGuide()) { Node* pNode = pLayer->FindFirstChild(CC_RUNTIME_CLASS(NodeGuideline)); while (pNode != NULL && ok) { DocRect Rect = ((NodeGuideline*)pNode)->GetRenderRect(); ok = DoInvalidateRegion(pSpread,Rect); pNode = pNode->FindNext(CC_RUNTIME_CLASS(NodeGuideline)); } } if (ok) ok = DoInvalidateNodeRegion(pLayer, TRUE); return ok; }

void OpLayerGalChange::DoWithParam (  OpDescriptor *  , OpParam *  pOpParam )  [virtual]

Performs the layer change operation defined by ((OpLayerGalParam*)pOpParam)->Reason. It handles the creation, deletion, changing, and moving of the layer provided. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/8/94 Parameters: OpDescriptor  (unused) [INPUTS] pOpParam - this is really a ptr to an OpLayerGalParam -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from Operation. Definition at line 517 of file layergal.cpp. { OpLayerGalParam* pOpLayerGalParam = (OpLayerGalParam*)pOpParam; pSpread = pOpLayerGalParam->GetParentSpread(); Reason = pOpLayerGalParam->GetReason(); Layer* pLayer = pOpLayerGalParam->pLayer; Node* pContextNode= pOpLayerGalParam->pContextNode; AttachNodeDirection AttDir = pOpLayerGalParam->AttDir; LayerStatus NewStatus = pOpLayerGalParam->Status; BOOL FrameLayer = FALSE; switch (Reason) { //-------------------------------------------------------------------------------------------- // Select a Frame layer case (FRAME_SELECT): // Check for being given a null layer or an already active layer if (pLayer == NULL || pLayer->IsActive()) goto EndOperation; PORTNOTE("galleries", "disabled frame gallery") #ifndef EXCLUDE_FROM_XARALX // Make the layer we have been passed the active one FrameSGallery::MakeActiveLayer(pLayer); #endif UndoIDS = _R(IDS_FRAME_UNDO_SELECTNEW); break; //-------------------------------------------------------------------------------------------- // Create a new layer case (FRAME_NEW): FrameLayer = TRUE; case (LAYER_NEW): { // Attempt to create a new layer node ALLOC_WITH_FAIL(pLayer, (new Layer()), this); if (pLayer == NULL) goto EndOperation; // We were unable to create a new layer so // abort the operation // Set the new layer's status pLayer->SetLayerStatus(NewStatus); // Set the frame layer flag according to the operation type i.e FRAME_NEW = set flag if (FrameLayer) { pLayer->SetFrame(TRUE); pLayer->SetEdited(TRUE); } // Insert new layer in the tree // Rule: if there is a guide layer at the top, then place the new layer // beneath this layer, otherwise, put the new layer at the top. Layer* pLastLayer = pSpread->FindLastLayer(); if(pLastLayer && pLastLayer->IsGuide()) { // this layer is a guide layer - get the next one pLastLayer = pLastLayer->FindPrevLayer(); } Node* pNodeToInsert; if(pLastLayer) { pNodeToInsert = pLastLayer; } else { // what?! can't find a Last Layer to use? pNodeToInsert = pContextNode; } if (DoInsertNewNode(pLayer, pLastLayer, NEXT, FALSE)) { PORTNOTE("galleries", "Disabled frame gallery") #ifndef EXCLUDE_FROM_XARALX if (FrameLayer) FrameSGallery::MakeActiveLayer(pLayer); else #endif LayerSGallery::MakeActiveLayer(pLayer); // Note the layer inserted so we can clear any selection on the layer when this op is undone pOpUndoLayer = pLayer; pLayer->EnsureUniqueLayerID(); } } if (FrameLayer) UndoIDS = _R(IDS_FRAME_UNDO_NEW); else UndoIDS = _R(IDS_LAYER_UNDO_NEW); break; //-------------------------------------------------------------------------------------------- // Delete a layer case (FRAME_DELETE): FrameLayer = TRUE; case (LAYER_DELETE): case (PAGEBACKGROUND_DEFAULT): { // This doesn't seem to be an important ensure as it works when the layer // is not active // Disabled 10/4/97 //ERROR3IF(pLayer->IsActive(),"Deleting layer, yet it is not active"); // We need to find 'prev' and 'next' before we delete the layer Layer* pPrevLayer = pLayer->FindPrevLayer(); Layer* pNextLayer = pLayer->FindNextLayer(); if (pLayer->IsVisible()) { if (!DoInvalidateLayerRegion(pLayer)) goto EndOperation; } NodeRenderableInk::DeselectAllOnLayer(pLayer); if (!DoHideNode(pLayer,TRUE)) // Hide the node goto EndOperation; // Note the layer inserted so we can clear any selection on the layer when this op is redone // i.e. deleted again after a redo pOpRedoLayer = pLayer; // If the last layer has been deleted, create a new one and make it the active layer if (pSpread->FindFirstLayer() == NULL) { Layer* pFirstLayer; ALLOC_WITH_FAIL(pFirstLayer, (new Layer()), this); if (pFirstLayer == NULL) goto EndOperation; // We were unable to create a new layer so // abort the operation // Set the new layer's status and ID pFirstLayer->SetActive(TRUE); pFirstLayer->GetLayerStatus().StringLayerID = LayerSGallery::CreateUniqueLayerID(pSpread); // Make it the last child of the spread if (DoInsertNewNode(pFirstLayer,pSpread,LASTCHILD,FALSE,TRUE,TRUE,TRUE)) { // Note the layer inserted so we can clear any selection on the layer when this op is undone // i.e. deleted after an undo pOpUndoLayer = pLayer; } } else { // if we've deleted the active layer, make one of the others active if (pLayer->IsActive()) { Layer* pNewActiveLayer = pNextLayer; if (pNewActiveLayer == NULL) pNewActiveLayer = pPrevLayer; if (pNewActiveLayer != NULL) { PORTNOTE("galleries", "disabled frame gallery") #ifndef EXCLUDE_FROM_XARALX if (FrameLayer) FrameSGallery::MakeActiveLayer(pNewActiveLayer); else #endif LayerSGallery::MakeActiveLayer(pNewActiveLayer); } ERROR3IF(pNewActiveLayer == NULL,"Can't find another layer to make active"); // Make sure that when it comes back (through an undo) it is not flagged as active pLayer->SetActive(FALSE); } } } if (FrameLayer) UndoIDS = _R(IDS_FRAME_UNDO_DELETE); else { if (Reason == LAYER_DELETE) UndoIDS = _R(IDS_LAYER_UNDO_DELETE); else UndoIDS = _R(IDS_UNDO_DEFAULTBACKGROUND); } break; //-------------------------------------------------------------------------------------------- // Change a layer's status (i.e. it's layer attributes) case (LAYER_CHANGE_NAME): UndoIDS = _R(IDS_LAYER_UNDO_CHANGENAME); // Fall through!!!! // case (LAYER_CHANGE): { // if UndoIDS has not been changed via the LAYER_CHANGE_NAME entry point, // change it to something relevent if (UndoIDS == _R(IDS_NOTYPE)) UndoIDS = _R(IDS_LAYER_UNDO_CHANGE); // Try to create an action to restore the attribute changes we // are about to make ChangeLyrAttribAction* UndoAttribChngAction; if ( ChangeLyrAttribAction::Init(this, &UndoActions, sizeof(InvalidateRegionAction), pLayer->GetLayerStatus(), pLayer, ( Action**)(&UndoAttribChngAction)) != AC_FAIL) { LayerStatus OldStatus = pLayer->GetLayerStatus(); // Get the state of the layer before the change BOOL PrevVisible = pLayer->IsVisible(); BOOL PrevLocked = pLayer->IsLocked(); BOOL PrevOutline = pLayer->IsOutline(); // This is the real state of the visible flag before the change BOOL PrevVisibleReal = pLayer->GetVisibleFlagState(); // change the layer's status info pLayer->SetLayerStatus(NewStatus); // Get the state of the layer after the change BOOL PostVisible = pLayer->IsVisible(); BOOL PostLocked = pLayer->IsLocked(); BOOL PostOutline = pLayer->IsOutline(); // This is the real state of the visible flag after the change BOOL PostVisibleReal = pLayer->GetVisibleFlagState(); // If the visibility flag has changed, or if visible and the outline state has changed, // then do a redraw. if ((PrevVisibleReal != PostVisibleReal) || (PostVisible && (PrevOutline != PostOutline))) { if (!DoInvalidateLayerRegion(pLayer)) goto EndOperation; } // If become invisible or become locked, then remove the selections on the layer if ( ((PrevVisible != PostVisible) && !PostVisible) || ((PrevLocked != PostLocked) && PostLocked) ) { NodeRenderableInk::DeselectAllOnLayer(pLayer); } pLayer->EnsureUniqueLayerID(); } else goto EndOperation; // We have failed } break; //-------------------------------------------------------------------------------------------- // Move the layer somewhere else case (FRAME_MOVE): FrameLayer = TRUE; case (LAYER_MOVE): // Move the layer to the new pos if(!DoMoveNode(pLayer, pContextNode, AttDir)) goto EndOperation; GetApplication()->UpdateSelection(); // Horrible bodge that ensures that the layer that moves remains the active layer. // The DoMoveNode() call above causes a hidden node to be generated that references a layer. // This in turn generates a LAYERSCHANGED spread message that causes the layer gallery to do // a validity check to ensure that there's an active layer on the spread. // If there isn't an active layer (which there isn't in this case because it's just been // hidden) the check selects the first layer in the spread. // Not easy to fix properly, but easy to bodge it. if (FrameLayer) { // Ensure that the frame layer flag is on pLayer->SetFrame(TRUE); pLayer->SetEdited(TRUE); PORTNOTE("galleries", "Disabled frame gallery") #ifndef EXCLUDE_FROM_XARALX FrameSGallery::MakeActiveLayer(pLayer); #endif } else LayerSGallery::MakeActiveLayer(pLayer); pOpUndoLayer = pLayer; pOpRedoLayer = pLayer; // Invalidate the region if the layer is visible if (pOpLayerGalParam->MoveRedraw) { if (!DoInvalidateLayerRegion(pLayer)) goto EndOperation; } if (pOpLayerGalParam->ToggleBackground) LayerStateAction::Init(this,&UndoActions,*pOpLayerGalParam); if (FrameLayer) UndoIDS = _R(IDS_FRAME_UNDO_MOVE); else UndoIDS = _R(IDS_LAYER_UNDO_MOVE); break; //-------------------------------------------------------------------------------------------- // Copy the layer case (FRAME_COPY): FrameLayer = TRUE; case (LAYER_COPY): { BOOL ok = TRUE; Layer* pCopyOfLayer = NULL; if (pLayer == NULL) goto EndOperation; // The following lump of code makes sure that the layer being copied does not // contain the insertion node, otherwise it will be copied in the new layer, // resulting in the doc having two insertion nodes. (Markn 17/10/96) /* { BaseDocument* pBaseDoc = pLayer->FindOwnerDoc(); if (pBaseDoc != NULL && IS_A(pBaseDoc,Document)) { Document* pDoc = (Document*)pBaseDoc; InsertionNode* pInsertNode = pDoc->GetInsertionPosition(); if (pInsertNode != NULL) { Layer* pInsertLayer = (Layer*)pInsertNode->FindParent(CC_RUNTIME_CLASS(Layer)); if (pInsertLayer == pLayer) { pInsertNode->UnlinkNodeFromTree(); delete pInsertNode; pInsertNode = NULL; } } } } */ // Copy the layer and all its children, without placing the copy in the tree CALL_WITH_FAIL(pLayer->NodeCopy((Node**)&pCopyOfLayer), this, ok); if (!ok) goto EndOperation; //Graham 1/8/97: Clear the text tool's internal record of the focus story //This is a bug fix TextStory::SetFocusStory(NULL); // Set the new layer's status pCopyOfLayer->SetLayerStatus(NewStatus); // Set the frame layer flag according to the operation type i.e FRAME_NEW = set flag if (FrameLayer) { pCopyOfLayer->SetFrame(TRUE); pCopyOfLayer->SetEdited(TRUE); } // Insert layer and its children in the tree somewhere // Rule: if there is a guide layer at the top, then place the new layer // beneath this layer, otherwise, put the new layer at the top. Layer* pLastLayer = pSpread->FindLastLayer(); if(pLastLayer && pLastLayer->IsGuide()) { // this layer is a guide layer - get the next one // (there will (ought to be) only one guide layer...) pLastLayer = pLastLayer->FindPrevLayer(); } Node* pNodeToInsert; if(pLastLayer) { pNodeToInsert = pLastLayer; } else { // what?! can't find a Last Layer to use? pNodeToInsert = pContextNode; } if (!DoInsertNewNode(pCopyOfLayer, pNodeToInsert, NEXT, FALSE)) { // Tidy up if we fail pCopyOfLayer->CascadeDelete(); delete pCopyOfLayer; goto EndOperation; } // Call PostDuplicate so things sort their lives out. Node* pCurrent = pCopyOfLayer->FindFirstDepthFirst(); while (pCurrent!=NULL && ok) { ok = pCurrent->PostDuplicate(this); pCurrent = pCurrent->FindNextDepthFirst(pCopyOfLayer); } if (!ok) goto EndOperation; if (!DoInvalidateLayerRegion(pCopyOfLayer)) goto EndOperation; // Note the layer inserted so we can clear any selection on the layer when this op is undone // i.e. when the copied layer is removed after an undo pOpUndoLayer = pCopyOfLayer; // Make it the active layer PORTNOTE("galleries", "Disabled frame gallery") #ifndef EXCLUDE_FROM_XARALX if (FrameLayer) FrameSGallery::MakeActiveLayer(pCopyOfLayer); else #endif LayerSGallery::MakeActiveLayer(pCopyOfLayer); NodeRenderableInk::DeselectAllOnLayer(pLayer); pCopyOfLayer->EnsureUniqueLayerID(); } if (FrameLayer) UndoIDS = _R(IDS_FRAME_UNDO_COPY); else UndoIDS = _R(IDS_LAYER_UNDO_COPY); break; //-------------------------------------------------------------------------------------------- // Toggle the layer's background flag case (LAYER_TOGGLEBACKGROUND): LayerStateAction::Init(this, &UndoActions, *pOpLayerGalParam); BroadcastLayerChanges = FALSE; UndoIDS = _R(IDS_LAYER_UNDO_MOVE); break; //-------------------------------------------------------------------------------------------- // Change the layer's visibility case (LAYER_VISIBLE): LayerStateAction::Init(this, &UndoActions, *pOpLayerGalParam); BroadcastLayerChanges = FALSE; UndoIDS = _R(IDS_LAYER_UNDO_VISIBLE); break; //-------------------------------------------------------------------------------------------- // Change the layer's locked state case (LAYER_LOCKED): LayerStateAction::Init(this, &UndoActions, *pOpLayerGalParam); BroadcastLayerChanges = FALSE; UndoIDS = _R(IDS_LAYER_UNDO_LOCKED); break; //-------------------------------------------------------------------------------------------- // Change the layer's doc's 'all visible' state case (FRAME_ALLVISIBLE): FrameLayer = TRUE; case (LAYER_ALLVISIBLE): LayerStateAction::Init(this, &UndoActions, *pOpLayerGalParam); BroadcastLayerChanges = FALSE; if (FrameLayer) UndoIDS = _R(IDS_FRAME_UNDO_ALLVISIBLE); else UndoIDS = _R(IDS_LAYER_UNDO_ALLVISIBLE); break; //-------------------------------------------------------------------------------------------- // Change the layer's doc's 'multilayer' state case (FRAME_MULTILAYER): FrameLayer = TRUE; case (LAYER_MULTILAYER): LayerStateAction::Init(this, &UndoActions, *pOpLayerGalParam); BroadcastLayerChanges = FALSE; if (FrameLayer) UndoIDS = _R(IDS_FRAME_UNDO_MULTILAYER); else UndoIDS = _R(IDS_LAYER_UNDO_MULTILAYER); break; //-------------------------------------------------------------------------------------------- // Change the layer's name, visibility & editability, all on one go case (LAYER_CHANGE): LayerStateAction::Init(this, &UndoActions, *pOpLayerGalParam); //BroadcastLayerChanges = FALSE; UndoIDS = _R(IDS_OPCHANGELAYERPROPERTIES); break; //-------------------------------------------------------------------------------------------- // Change the layer's solid state case (LAYER_SOLID): // Cannot do this as this causes the gallery items to be destructed whilst handling // clicks on one of the items. // // Check that all visible layers are actually frame layers // FrameSGallery::EnsureFrameLayerIntegrity(pSpread); // Set up the action LayerStateAction::Init(this, &UndoActions, *pOpLayerGalParam); BroadcastLayerChanges = FALSE; UndoIDS = _R(IDS_LAYER_UNDO_SOLID); break; //-------------------------------------------------------------------------------------------- // Change the layer's solid state case (LAYER_OVERLAY): // // Check that all visible layers are actually frame layers // FrameSGallery::EnsureFrameLayerIntegrity(pSpread); // Set up the action LayerStateAction::Init(this, &UndoActions, *pOpLayerGalParam); BroadcastLayerChanges = FALSE; UndoIDS = _R(IDS_LAYER_UNDO_OVERLAY); break; //-------------------------------------------------------------------------------------------- // Change the layer's active state case (LAYER_ACTIVE): // Set up the action LayerStateAction::Init(this, &UndoActions, *pOpLayerGalParam); BroadcastLayerChanges = FALSE; UndoIDS = _R(IDS_LAYER_UNDO_ACTIVE); break; // Trap any other reasons here default: ERROR3("Unknown OpLayerGalChange reason code"); break; } if (BroadcastLayerChanges) { BROADCAST_TO_ALL(SpreadMsg(pSpread,SpreadMsg::LAYERCHANGES)); } EndOperation: ERROR3IF(UndoIDS == 0,"The undo ID string is zero. No too useful!"); End(); }

void OpLayerGalChange::GetOpName (  String_256 *  OpName  )  [virtual]

The GetOpName fn is overridden so that we return back a description appropriate to the type of attribute that the operation applies. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/8/94 Parameters: -  [INPUTS] The  undo string for the operation [OUTPUTS] Returns: Errors: - See also: - Reimplemented from Operation. Definition at line 1107 of file layergal.cpp. { *OpName = String_256(UndoIDS); }

OpState OpLayerGalChange::GetState (  String_256 *  UIDescription, OpDescriptor *  )  [static]

For finding the OpLayerGalChange's state. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The state of the OpLayerGalChange operation Errors: - See also: - Reimplemented in OpSelectStartFrame, OpSelectEndFrame, OpSelectPrevFrame, OpSelectNextFrame, OpCreateNewFrame, OpCopyFrame, OpDeleteFrame, and OpDeletePageBackground. Definition at line 486 of file layergal.cpp. { OpState OpSt; return(OpSt); }

BOOL OpLayerGalChange::Init (  void   )  [static]

OpLayerGalChange initialiser method. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the operation could be successfully initialised FALSE if no more memory could be allocated Errors: ERROR will be called if there was insufficient memory to allocate the operation. See also: - Reimplemented from SimpleCCObject. Definition at line 313 of file layergal.cpp. { return ( RegisterOpDescriptor( 0, _R(IDS_LAYERCHANGEOP), CC_RUNTIME_CLASS(OpLayerGalChange), OPTOKEN_LAYERGALCHANGE, OpLayerGalChange::GetState, 0, /* help ID */ _R(IDBBL_LAYERCHANGEOP), 0 /* bitmap ID */ ) && RegisterOpDescriptor( 0, _R(IDS_DELETEPAGEBACKGROUND), CC_RUNTIME_CLASS(OpDeletePageBackground), OPTOKEN_DELETEPAGEBACKGROUND, OpDeletePageBackground::GetState, 0, // help ID 0, // bubble help id 0 // bitmap ID ) // special frame operations && PORTNOTE("galleries", "Disabled frame stuff") #ifndef EXCLUDE_FROM_XARALX RegisterOpDescriptor( 0, // Tool ID _R(IDS_SELECTSTARTFRAME), // String resource ID CC_RUNTIME_CLASS(OpSelectStartFrame), // Runtime class OPTOKEN_FRAME_STARTFRAME, // Token string OpSelectStartFrame::GetState, // GetState function 0, // help ID _R(IDBBL_SELECTSTARTFRAME), // bubble help _R(IDD_ANIMATIONBAR), // resource ID _R(IDC_PREVIEW_STARTFRAME), // control ID SYSTEMBAR_ANIMATION, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation NULL, // String for one copy only error (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC) // Auto state flags ) && RegisterOpDescriptor( 0, // Tool ID _R(IDS_SELECTENDFRAME), // String resource ID CC_RUNTIME_CLASS(OpSelectEndFrame), // Runtime class OPTOKEN_FRAME_ENDFRAME, // Token string OpSelectEndFrame::GetState, // GetState function 0, // help ID _R(IDBBL_SELECTENDFRAME), // bubble help _R(IDD_ANIMATIONBAR), // resource ID _R(IDC_PREVIEW_ENDFRAME), // control ID SYSTEMBAR_ANIMATION, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation NULL, // String for one copy only error (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC) // Auto state flags ) && RegisterOpDescriptor( 0, // Tool ID _R(IDS_SELECTPREVFRAME), // String resource ID CC_RUNTIME_CLASS(OpSelectPrevFrame), // Runtime class OPTOKEN_FRAME_PREVFRAME, // Token string OpSelectPrevFrame::GetState, // GetState function 0, // help ID _R(IDBBL_SELECTPREVFRAME), // bubble help _R(IDD_ANIMATIONBAR), // resource ID _R(IDC_PREVIEW_PREVFRAME), // control ID SYSTEMBAR_ANIMATION, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation NULL, // String for one copy only error (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC) // Auto state flags ) && RegisterOpDescriptor( 0, // Tool ID _R(IDS_SELECTNEXTFRAME), // String resource ID CC_RUNTIME_CLASS(OpSelectNextFrame), // Runtime class OPTOKEN_FRAME_NEXTFRAME, // Token string OpSelectNextFrame::GetState, // GetState function 0, // help ID _R(IDBBL_SELECTNEXTFRAME), // bubble help _R(IDD_ANIMATIONBAR), // resource ID _R(IDC_PREVIEW_NEXTFRAME), // control ID SYSTEMBAR_ANIMATION, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation NULL, // String for one copy only error (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC) // Auto state flags ) && RegisterOpDescriptor( 0, // Tool ID _R(IDS_NEWFRAME), // String resource ID CC_RUNTIME_CLASS(OpCreateNewFrame), // Runtime class OPTOKEN_FRAME_NEWFRAME, // Token string OpCreateNewFrame::GetState, // GetState function 0, // help ID _R(IDBBL_NEWFRAME), // bubble help _R(IDD_ANIMATIONBAR), // resource ID _R(IDC_FRAME_NEWFRAME), // control ID SYSTEMBAR_ANIMATION, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation NULL, // String for one copy only error (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC) // Auto state flags ) && RegisterOpDescriptor( 0, // Tool ID _R(IDS_COPYFRAME), // String resource ID CC_RUNTIME_CLASS(OpCopyFrame), // Runtime class OPTOKEN_FRAME_COPYFRAME, // Token string OpCopyFrame::GetState, // GetState function 0, // help ID _R(IDBBL_COPYFRAME), // bubble help _R(IDD_ANIMATIONBAR), // resource ID _R(IDC_FRAME_COPYFRAME), // control ID SYSTEMBAR_ANIMATION, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation NULL, // String for one copy only error (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC) // Auto state flags ) && RegisterOpDescriptor( 0, // Tool ID _R(IDS_DELETEFRAME), // String resource ID CC_RUNTIME_CLASS(OpDeleteFrame),// Runtime class OPTOKEN_FRAME_DELETEFRAME, // Token string OpDeleteFrame::GetState, // GetState function 0, // help ID _R(IDBBL_DELETEFRAME), // bubble help _R(IDD_ANIMATIONBAR), // resource ID _R(IDC_FRAME_DELETEFRAME), // control ID SYSTEMBAR_ANIMATION, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation NULL, // String for one copy only error (DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC) // Auto state flags ) && #endif // EXCLUDE_FROM_XARALX TRUE ); }

BOOL OpLayerGalChange::IsFrameMode (   )  [static]

Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 21/10/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the document is frame based, else FALSE. Definition at line 1302 of file layergal.cpp. { // Flag variables. BOOL FramedDoc = FALSE; // Flag to determine the document type. // Get a ptr to the selected spread Spread* pSpread = Document::GetSelectedSpread(); // Ensure a valid spread ptr. if(pSpread) { // Are there any frame layers? Layer* pFrameLayer = pSpread->FindFirstFrameLayer(); //If a frame layer exists, then this is an animation doc. if (pFrameLayer) FramedDoc = TRUE; } return FramedDoc; }

virtual BOOL OpLayerGalChange::MayChangeNodeBounds (   )  const [inline, virtual]

Reimplemented from UndoableOperation. Definition at line 296 of file layergal.h. { return TRUE; }

BOOL OpLayerGalChange::Redo (   )  [virtual]

The overloaded Redo operation refreshes the layer details in the layer manager. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 4/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from Operation. Definition at line 1220 of file layergal.cpp. { // Do some stuff before the redo takes place, relevent to the operation being redone switch (Reason) { case FRAME_DELETE: case LAYER_DELETE: case PAGEBACKGROUND_DEFAULT: ERROR3IF(pOpRedoLayer == NULL,"The op's redo layer ptr is NULL"); // If redoing a layer delete, make sure there are no selected nodes on the layer before // it disappears if (pOpRedoLayer != NULL && pOpRedoLayer->FindParent() != NULL) NodeRenderableInk::DeselectAllOnLayer(pOpRedoLayer); // **** Fall through... case FRAME_NEW: case FRAME_COPY: case FRAME_MOVE: case LAYER_NEW: case LAYER_COPY: case LAYER_MOVE: // All the above reasons generate hidden nodes, so the HideNode and ShowNode code // will broadcast layer changes on undo and redo (hopefully!) BroadcastLayerChanges = FALSE; break; default: break; } BOOL Result = Operation::Redo(); if (Result) { // Do some stuff after the redo takes place, relevent to the operation being redone switch (Reason) { // When moving layers about, we need to make sure the layer moved remains the active layer case FRAME_MOVE: case LAYER_MOVE: GetApplication()->UpdateSelection(); if (pOpRedoLayer != NULL) { PORTNOTE("galleries", "Disabled frame gallery") #ifndef EXCLUDE_FROM_XARALX if (Reason == FRAME_MOVE) FrameSGallery::MakeActiveLayer(pOpRedoLayer); else #endif LayerSGallery::MakeActiveLayer(pOpRedoLayer); BroadcastLayerChanges = TRUE; } break; default: break; } if (BroadcastLayerChanges) { BROADCAST_TO_ALL(SpreadMsg(pSpread,SpreadMsg::LAYERCHANGES)); } } return (Result); }

BOOL OpLayerGalChange::Undo (   )  [virtual]

The overloaded Undo operation refreshes the layer details in the layer manager. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 4/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from Operation. Definition at line 1129 of file layergal.cpp. { // Do some stuff before the undo takes place, relevent to the operation being undone switch (Reason) { // Only LAYER_NEW and LAYER_COPY need to worry if pOpUndoLayer is NULL // LAYER_DELETE op only creates a pOpUndoLayer ptr after the last layer is deleted and // automatically replaced by a new blank layer. case FRAME_NEW: case FRAME_COPY: case LAYER_NEW: case LAYER_COPY: ERROR3IF(pOpUndoLayer == NULL,"The op's undo layer ptr is NULL"); // **** Fall through... case FRAME_DELETE: case LAYER_DELETE: case PAGEBACKGROUND_DEFAULT: // If undoing, make sure there are no selected nodes on the layer before // it disappears if (pOpUndoLayer != NULL && pOpUndoLayer->FindParent() != NULL) NodeRenderableInk::DeselectAllOnLayer(pOpUndoLayer); // **** Fall through... case FRAME_MOVE: case LAYER_MOVE: // All the above reasons generate hidden nodes, so the HideNode and ShowNode code // will broadcast layer changes on undo and redo (hopefully!) BroadcastLayerChanges = FALSE; break; default: break; } BOOL Result = Operation::Undo(); if (Result) { // Do some stuff after the undo takes place, relevent to the operation being undone switch (Reason) { // When moving layers about, we need to make sure the layer moved remains the active layer case FRAME_MOVE: case LAYER_MOVE: GetApplication()->UpdateSelection(); if (pOpUndoLayer != NULL) { PORTNOTE("galleries", "Disabled frame gallery") #ifndef EXCLUDE_FROM_XARALX if (Reason == FRAME_MOVE) FrameSGallery::MakeActiveLayer(pOpUndoLayer); else #endif LayerSGallery::MakeActiveLayer(pOpUndoLayer); BroadcastLayerChanges = TRUE; } break; default: break; } if (BroadcastLayerChanges) { BROADCAST_TO_ALL(SpreadMsg(pSpread,SpreadMsg::LAYERCHANGES)); } } return (Result); }

---

Member Data Documentation

BOOL OpLayerGalChange::BroadcastLayerChanges [private]

Definition at line 304 of file layergal.h.

Layer* OpLayerGalChange::pOpRedoLayer [private]

Definition at line 302 of file layergal.h.

Layer* OpLayerGalChange::pOpUndoLayer [private]

Definition at line 301 of file layergal.h.

Spread* OpLayerGalChange::pSpread [private]

Definition at line 300 of file layergal.h.

OpLayerGalReason OpLayerGalChange::Reason [private]

Definition at line 299 of file layergal.h.

UINT32 OpLayerGalChange::UndoIDS [private]

Definition at line 303 of file layergal.h.

---

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

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

---