LayerSGallery Class Reference

The Layer SuperGallery class. More...

#include <sglayer.h>

Inheritance diagram for LayerSGallery:

List of all members.

Public Member Functions
	LayerSGallery ()
	LayerSGallery default constructor.
	~LayerSGallery ()
	LayerSGallery destructor.
virtual MsgResult	Message (Msg *Message)
	A standard message handler, really.
virtual BOOL	InitMenuCommands (void)
	Initialises any menu commands that this gallery needs.
virtual BOOL	BuildCommandMenu (GalleryContextMenu *TheMenu, SGMenuID MenuID)
	To build a menu of commands to be popped up over the gallery.
virtual OpState	GetCommandState (StringBase *CommandID, String_256 *ShadeReason)
	To determine the state of a given menu item. This method is an exact parallel to an Op's GetState method (in fact, it is called by an Op's GetState).
virtual void	DoCommand (StringBase *CommandID)
	To apply a given command when it is chosen from the menu.
virtual void	CreateNewSubtree (Document *ParentDoc, SGDisplayGroup *ExistingGroup=NULL)
	Internal call. This takes the Layer list of the given document and creates a DisplayTree subtree from it. This subtree is then added to the DisplayTree. Note that this does not force a redraw of the list - after making this call, you should also call ForceRedrawOfList.
Spread *	GetSelectedSpread (void)
	To find the current layer gallery spread.
virtual void	DoChangeAllVisible (BOOL AllVisible)
	Called when the AllVisible button is clicked in the layers gallery. Effects the visibility of all layers, regardless of their visibility.
virtual void	DoChangeMultilayer (BOOL Multilayer)
	Called when the Multilayer button is clicked in the layers gallery. Effects the locked state of all layers, regardless of their individual locked state.
virtual void	DoChangeLayerState (Layer *pLayer, OpLayerGalReason Reason, BOOL NewState)
	Undoable way of changing the layer's state.
Static Public Member Functions
static void	ForceRedrawLayer (Document *pDoc, Layer *pLayer)
	Does a ForceRedraw on the layer in the given doc.
static void	MakeActiveLayer (Layer *pNewActiveLayer, BOOL TellAll=TRUE)
	Makes the layer active. Firstly it will inactivate any other active layers, forcing it to redraw if necessary Then it will set this layer to be active, again forcing a redraw if necessary.
static void	EnsureActiveLayerIntegrity (Spread *pSpread, Layer **ppActiveLayer=NULL)
	This checks that there is one and only one active layer in the given spread. If there isn't an active layer, the first layer is made active. If there is more than on active layer, all but the first active layer are made inactive.
static void	SetActive (Document *pDoc, Layer *pLayer, BOOL state)
	Calls pLayer->SetActive(state), redrawing and changing the layer's selection if necessary. DON'T CALL THIS FUNC!! USE MakeActiveLayer() INSTEAD!!!!
static void	MakeTopLayerActive (Spread *pSpread)
	Makes the layer active. Firstly it will inactivate any other active layers, forcing it to redraw if necessary If the new layer is already active, nothing else happens Then it will set this layer to be active, again forcing a redraw if necessary.
static String_256	CreateUniqueLayerID (Spread *pSpread)
	Used to generate a LayerID which is unique for the spread. The name generated is normally of the form "Layer n", where n is the number of layers in the spread + 1. If "Layer n" already exists on the spread then "Layer m" is generated where m is the smallest integer greater than n such that the id is unique.
static void	DoChangeVisible (Layer *pLayer, BOOL Visible)
	Called when the visible button is clicked in a layer gallery item. Changes the visibility of the displayed layer.
static void	DoChangeLocked (Layer *pLayer, BOOL Locked)
	Called when the Locked button is clicked in a layer gallery item. Changes the lockedness of the displayed layer.
static BOOL	DoMoveSelectionToActiveLayer ()
Protected Member Functions
virtual BOOL	PreCreate (void)
	Layer SuperGallery PreCreate handler.
virtual BOOL	PostCreate (void)
	The LayerSGallery PostCreate handler. This overrides the base class PostCreate function. It is called at the very end of the SuperGallery::Create method, after the window has been created and opened.
virtual BOOL	ApplyAction (SGActionType Action)
	Applies certain conventional gallery actions (usually associated with gallery buttons, for new, edit, delete, etc).
virtual void	DoShadeGallery (BOOL ShadeIt)
	Called by the base class whenever the shaded status of the gallery is changed, to allow derived galleries to shade/unshade any extra controls that they provide in the window. ONLY called if the gallery is actually open/visible.
virtual SGDisplayItem *	CopyDisplayItem (SGDisplayItem *SourceItem, SGDisplayGroup *DestGroup, SGDisplayItem *TargetPosition=NULL)
	"Copies" the existing node in the tree in an appropriate fashion.
virtual void	NewSelectedSpread (Spread *pNewSelSpread=NULL)
	Central place for setting the layer gal's selected spread. Also takes a copy of the selected document.
virtual void	EnsureSelSpreadSelectionIntegrity ()
	This makes sure that all the invisible and/or locked layers in the spread have no selection. It calls NodeRenderableInk::DeselectAllOnLayer() on each layer that should NOT have a selection, just in case. Currently only called after an undo or redo op, because it could be quite slow.
virtual void	EnsureActiveLayerIntegrity ()
	This checks that there is one and only one active layer in the gallery's spread.
virtual BOOL	CheckVarsAreValid ()
	A routine that checks to see if critical vars are OK. All it does at the mo is check that pSpread and pDoc are not NULL. In debug builds, an ENSURE will go off if something goes wrong.
virtual SGDisplayLayer *	GetSelectedLayerGalItem ()
	Gets the selected layer gallery item In debug builds, an ENSURE will go off if there is no selected gal item.
virtual BOOL	HasLayerGotChildren (Layer *pLayer)
	Scans the layer for children that render something on the screen. It ignores attributes, hidden nodes, etc - nodes that don't render anything themselves.
virtual BOOL	PrepareToDelete (void)
	Scans the current Gallery selection. Possibly asks the user for confirmation about the delete. Possibly adjusts the selection as appropriate. Then returns a value to indicate whether the remaining selection should be deleted.
virtual BOOL	DoDeleteSelection (void)
	FORCIBLY deletes the current gallery selection. By the time this function is called, PrepareToDelete has made sure that it is safe to continue. This must simply invoke a forced delete upon the selection. Deletion of colours occurs by hiding (with undo).
virtual void	DoCreateNewItem (void)
	This function is meant to be overridden in derived classes It creates a new item and adds it to the Gallery DisplayList The item may be created by cloning/deriving/basing-on the selected item, depending on the type of Gallery concerned.
virtual void	DoChangeName ()
	Pops up the name changing dialog for the selected layer.
virtual void	DoCopyLayer ()
	Pops up the name changing dialog for the selected layer, and if OK is clicked a copy of the layer is made with the new name.
virtual void	DoLayerProperties ()
	Opens the layer properties dlg.
virtual void	DoCreateGuideLayer ()
	Creates a guide layer.
virtual void	DoChangeLayerStatus (Layer *pLayer, const LayerStatus &NewStatus)
	General undoable way of changing the selected layer's status.
virtual void	DoMoveLayer (MoveLayerType Reason)
	Called when the Locked button is clicked in the layers gallery. Changes the lockedness of the selected layer, if there is one.
virtual INT32	GetGuideLayerState (DocView *pDocView)
	This returns the current state of the guide layer. It is used to determine whether we need to recreate and redraw the layer gallery when the selected view changes.
virtual BOOL	IsSelectedItemGuideLayer ()
	General function for finding out if the selected item is a guide layer Notes: Need not be overridden - the default action is to do nothing extra to the normal shade/unshade operation.
BOOL	IsLayerMode (Document *pDoc)
BOOL	CloseLayerGallery ()
BOOL	OpenFrameGallery ()
void	SetNewDocBorn (BOOL Val)
BOOL	GetNewDocBorn ()
Protected Attributes
Spread *	pSpread
Document *	pDoc
SGDisplayGroup *	DisplayForeground
SGDisplayGroup *	DisplayBackground
BOOL	m_NewDocBorn
INT32	OldGuideLayerState
INT32	NewGuideLayerState

---

Detailed Description

The Layer SuperGallery class.

Author:

Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> (Based on template code by Jason)

Date:

27/1/95 (Based on the Colour SGallery code)

Notes: SuperGalleries are specced in a number of docs including specs.doc ("super" gallery extensions) specs.doc (gallery basic ui) There is also howtouse.doc which describes creating a supergallery

See also:

SuperGallery; SGDisplayLayer

Definition at line 267 of file sglayer.h.

---

Constructor & Destructor Documentation

LayerSGallery::LayerSGallery (   )

LayerSGallery default constructor. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/95 (base generated in sgbase.cpp) Definition at line 1290 of file sglayer.cpp. { #ifndef EXCLUDE_GALS DlgResID = _R(IDD_LAYERSGALLERY); pSpread = NULL; pDoc = NULL; DisplayForeground = NULL; // Group of foreground layers DisplayBackground = NULL; // Group of background layers OldGuideLayerState = -1; NewGuideLayerState = -1; m_NewDocBorn = FALSE; #endif }

LayerSGallery::~LayerSGallery (   )

LayerSGallery destructor. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/95 (base generated in sgbase.cpp) Definition at line 1317 of file sglayer.cpp. { }

---

Member Function Documentation

BOOL LayerSGallery::ApplyAction (  SGActionType  Action  )  [protected, virtual]

Applies certain conventional gallery actions (usually associated with gallery buttons, for new, edit, delete, etc). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/95 (base generated in sgbase.cpp) Parameters: Action  - Indicates what action to apply [INPUTS] Returns: TRUE to indicate successful handling of the action, or FALSE to indicate failure See also: SGActionType Reimplemented from SuperGallery. Reimplemented in FrameSGallery. Definition at line 1527 of file sglayer.cpp. { // No display tree? Better forget about it then! if (DisplayTree == NULL) return(FALSE); // Determine useful info - this is usually needed for most actions, so always get it Document *SelectedDoc = Document::GetSelected(); SGDisplayGroup *DocumentGroup = DisplayTree->FindSubtree(this, SelectedDoc, NULL); SGDisplayLayer *FirstSelected = NULL; if (DocumentGroup != NULL) FirstSelected = (SGDisplayLayer *) DocumentGroup->FindNextSelectedItem(NULL); // Now, process the action TO DO! - see Colour gallery for examples switch(Action) { case SGACTION_CREATE: DoCreateNewItem(); break; case SGACTION_EDIT: DoChangeName(); break; case SGACTION_DELETE: if (PrepareToDelete()) DoDeleteSelection(); break; // case SGACTION_APPLY: // case SGACTION_REDEFINE: // case SGACTION_DISPLAYMODECHANGED: // These operations are not provided by the layer gallery // break; default: return(SuperGallery::ApplyAction(Action)); } return(TRUE); }

BOOL LayerSGallery::BuildCommandMenu (  GalleryContextMenu *  TheMenu, SGMenuID  MenuID )  [virtual]

To build a menu of commands to be popped up over the gallery. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/95 Parameters: TheMenu  - The menu to add commands to [INPUTS] MenuID - The type of menu (over-list or from-options-button) to create Returns: TRUE if it succeeded Notes: The Layer gallery provides only a simple item-pop-up menu Reimplemented from SuperGallery. Reimplemented in FrameSGallery. Definition at line 3279 of file sglayer.cpp. { BOOL ok = TRUE; if (MenuID == SGMENU_OVERITEM) { // Over-list menu SGDisplayLayer* pLayerGalItem = GetSelectedLayerGalItem(); #ifndef STANDALONE // no layer properties tab present on standalone version if (pLayerGalItem != NULL) { // Changed for Frame/Layer integration. //#ifdef WEBSTER // GIFAnimationPropertyTabs * pTabHandler = GIFAnimationPropertyTabsDlg::GetGIFAnimationPropertiesTabs(); //#else LayerPropertyTabs * pTabHandler = LayerPropertyTabsDlg::GetLayerPropertiesTabs(); //#endif //webster if (pTabHandler) { pTabHandler->SetCurrentLayer(pLayerGalItem->GetDisplayedLayer()); } } #endif ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_New); ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Copy); ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Delete,TRUE); ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Create); #ifndef STANDALONE ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Properties); #endif } return(ok); }

BOOL LayerSGallery::CheckVarsAreValid (   )  [protected, virtual]

A routine that checks to see if critical vars are OK. All it does at the mo is check that pSpread and pDoc are not NULL. In debug builds, an ENSURE will go off if something goes wrong. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE - the vars are ok FALSE - one or more of the vars is invalid Definition at line 2395 of file sglayer.cpp. { return ((pSpread != NULL) && (pDoc != NULL)); }

BOOL LayerSGallery::CloseLayerGallery (   )  [protected]

Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 21/10/97 Parameters: -  [INPUTS] Returns: TRUE if sucessful, else FALSE. Definition at line 3454 of file sglayer.cpp. { SuperGallery* pSuperGallery = SuperGallery::FindSuperGallery(_R(IDD_LAYERSGALLERY)); // Ensure a valid ptr. if (pSuperGallery == NULL) return FALSE; if (pSuperGallery->GetRuntimeClass() == CC_RUNTIME_CLASS(LayerSGallery)) { PORTNOTE("galleries", "Disabled frame gallery") #ifndef EXCLUDE_FROM_XARALX GIFAnimationPropertyTabs::SetFrameGalleryOpen(FALSE); #endif // Toggle the visible state of the gallery window pSuperGallery->SetVisibility( FALSE ); } else { ERROR3("Got the frame gallery but it's not of the LayerSGallery class"); } SGInit::UpdateGalleryButton(_R(OPTOKEN_DISPLAYLAYERGALLERY), FALSE); // Everything ok. return TRUE; }

SGDisplayItem * LayerSGallery::CopyDisplayItem (  SGDisplayItem *  SourceItem, SGDisplayGroup *  DestGroup, SGDisplayItem *  TargetPosition = NULL )  [protected, virtual]

"Copies" the existing node in the tree in an appropriate fashion. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> (from a Jason func) Date: 21/3/95 Parameters: SourceItem  - The item to copy elsewhere in the tree (see below) [INPUTS] DestGroup - The group into which the item should be inserted TargetPosition - NULL (to add to the end of the sibling list), or points to the item BEFORE which the SourceItem will be copied. Returns: NULL (failed) or a pointer to the new (copied) display item This method is normally called when a gallery-organising drag completes, and it is discovered that the dragged item(s) have been dragged to a different display group. Notes: This method should be overridden by derived galleries to provide appropriate behaviour (some galleries (e.g colour) will copy the real-item that the given display-item references to the new group (document), while other galleries (layer) may just move the item after all). Note the handy InsertCopiedItem and MoveBefore/After methods which are available to take all of the hard work out of copying/moving items! See the body of this method in the source code for example pseudocode. For real code, see the Colour Gallery (sgcolour.cpp) See also: SuperGallery::InsertCopiedItem; SGDisplayItem::MoveBefore; SGDisplayItem::MoveAfter; SGColour::CopyDisplayItem Reimplemented from SuperGallery. Definition at line 3147 of file sglayer.cpp. { ERROR3IF(SourceItem == NULL || DestGroup == NULL, "Illegal NULL param"); if (SourceItem == NULL || DestGroup == NULL) return(NULL); ERROR3IF(!IS_A(DestGroup,SGLayerGroup),"DestGroup is not a SGLayerGroup"); ERROR3IF(!IS_A(SourceItem,SGDisplayLayer),"SourceItem is not a SGDisplayLayer"); if (!IS_A(DestGroup,SGLayerGroup) || !IS_A(SourceItem,SGDisplayLayer)) return(NULL); SGLayerGroup* pDestLayerGroup = (SGLayerGroup*)DestGroup; SGDisplayLayer* pSourceLayerItem = (SGDisplayLayer*)SourceItem; SGDisplayItem* pDestItem = TargetPosition; BOOL Before = TRUE; if (pDestItem == NULL) { pDestItem = (SGDisplayItem*) pDestLayerGroup->GetChild(); Before = TRUE; if (pDestItem == NULL) { SGDisplayNode* pNode = SourceItem; while (pNode != NULL) { pDestItem = (SGDisplayItem*) pNode; if (pDestLayerGroup->IsForeground()) pNode = pNode->GetPrevious(); else pNode = pNode->GetNext(); } Before = pDestLayerGroup->IsForeground(); } else { SGDisplayItem* pLastDestItem = NULL; while (pDestItem != NULL) { pLastDestItem = pDestItem; pDestItem = (SGDisplayItem*)(pDestItem->GetNext()); } pDestItem = pLastDestItem; Before = FALSE; } } ERROR3IF(pDestItem == NULL,"pDestItem is still NULL"); if (pDestItem == NULL) return(NULL); // Move the display item around SourceItem->RemoveFromTree(); // Delink from current displaytree position SuperGallery::InsertCopiedItem(SourceItem, DestGroup, TargetPosition); if (pDestItem != NULL) { ERROR3IF(!IS_A(pDestItem,SGDisplayLayer),"SourceItem is not a SGDisplayLayer"); if (!IS_A(pDestItem,SGDisplayLayer)) return(NULL); SGDisplayLayer* pDestLayerItem = (SGDisplayLayer*)pDestItem; pDestLayerItem->MoveLayer(pSourceLayerItem,Before,TRUE); } return(SourceItem); }

void LayerSGallery::CreateNewSubtree (  Document *  ParentDoc, SGDisplayGroup *  ExistingGroup = NULL )  [virtual]

Internal call. This takes the Layer list of the given document and creates a DisplayTree subtree from it. This subtree is then added to the DisplayTree. Note that this does not force a redraw of the list - after making this call, you should also call ForceRedrawOfList. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/95 (base generated in sgbase.cpp) Parameters: ParentDoc  - The document to create a display subtree for [INPUTS] ExistingGroup - NULL (creates a new group for this document), or a pointer to the existing group-node for this document (in which case it clears all displayitems from the group and rebuilds it in place - this stops the display group moving around the tree at random!) Notes: Passing in a NULL parent document pointer results in an ERROR3 - the function returns without doing anything in retail builds See also: SuperGallery::ForceRedrawOfList Reimplemented in FrameSGallery. Definition at line 1348 of file sglayer.cpp. { if (DisplayTree == NULL) return; TRACEUSER( "Neville", _T("LayerSGallery::CreateNewSubtree Just about to DestroySubtree\n")); // The layer gallery only ever shows one document, so destroy the entire tree // and start again from scratch (note that this doesn't destroy the root node) DisplayTree->DestroySubtree(); // All groups will be destroyed by DestroySubtree(), so we'd better forget them DisplayForeground = NULL; DisplayBackground = NULL; TRACEUSER( "Neville", _T("LayerSGallery::CreateNewSubtree completed DestroySubtree\n")); if (ParentDoc == NULL) return; SGDisplayLayer *DisplayLayer = NULL; EnsureActiveLayerIntegrity(); // Create the foreground layer group DisplayForeground = new SGLayerGroup(this, ParentDoc,NULL,TRUE); // Create new Group if (DisplayForeground == NULL) // Total failure - abort return; DisplayTree->AddItem(DisplayForeground); // Add new group to tree // Create the background layer group DisplayBackground = new SGLayerGroup(this, ParentDoc,NULL,FALSE); // Create new Group if (DisplayBackground == NULL) // Total failure - abort return; DisplayTree->AddItem(DisplayBackground); // Add new group to tree Spread* pSelSpread = GetSelectedSpread(); ERROR3IF(pSelSpread == NULL,"No selected spread in LayerSGallery"); if (pSelSpread == NULL) return; Layer* pLayer = pSelSpread->FindLastLayer(); Layer* pActiveLayer = NULL; Layer* pGuideLayer = NULL; while (pLayer != NULL) { // Keep a ptr to the guide layer, if there is one if (pLayer->IsGuide()) pGuideLayer = pLayer; DisplayLayer = new SGDisplayLayer(pLayer); if (DisplayLayer != NULL) { if (pLayer->IsBackground()) DisplayBackground->AddItem(DisplayLayer); else DisplayForeground->AddItem(DisplayLayer); } if (pLayer->IsActive()) { ERROR3IF(pActiveLayer != NULL, "Found more than one active layer in the selected spread"); pActiveLayer = pLayer; DisplayLayer->SetSelected(TRUE); // Make the active layer selected } pLayer = pLayer->FindPrevLayer(); } // The new state of the Guide Layer is now the old state OldGuideLayerState = NewGuideLayerState; if (pGuideLayer == NULL) NewGuideLayerState = -1; // If there's no guide layer, set new state to be -1 else NewGuideLayerState = pGuideLayer->IsVisible(); // New state is based on the guide layer's visibility if (IsVisible()) { SetBoolGadgetSelected(_R(IDC_BTN_MULTILAYER),!(ParentDoc->IsMultilayer() == 0)); SetBoolGadgetSelected(_R(IDC_BTN_ALLVISIBLE),!(ParentDoc->IsAllVisible() == 0)); } TRACEUSER( "Neville", _T("LayerSGallery::CreateNewSubtree exit\n")); }

String_256 LayerSGallery::CreateUniqueLayerID (  Spread *  pSpread  )  [static]

Used to generate a LayerID which is unique for the spread. The name generated is normally of the form "Layer n", where n is the number of layers in the spread + 1. If "Layer n" already exists on the spread then "Layer m" is generated where m is the smallest integer greater than n such that the id is unique. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> (based on a Simon routine) Date: 4/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: A LayerID which is unique for the layer galleries spread. Errors: - See also: - Definition at line 2327 of file sglayer.cpp. { if (pSpread == NULL) return String_256(""); String_256 UniqueLayerID; INT32 NumLayers = 0; Layer* pLayer = pSpread->FindFirstLayer(); // Calculate how many layers are on the current spread while (pLayer != NULL) { // Don't cound the guide layer - it's LayerID (aka Name) is "Guides" if(!pLayer->IsGuide()) { NumLayers++; } pLayer = pLayer->FindNextLayer(); } INT32 NewLayerNum = NumLayers+1; BOOL Unique; // Flag used to indicate if the id generated is unique or not do { // Construct a first attempt at a unique layer id 'Layer n' // where n = the number of layers on the current spread + 1 UniqueLayerID.MakeMsg(_R(IDS_SGLAYER_LAYER_NUM), /*TEXT("Layer #1%ld"),*/NewLayerNum); // Check that UniqueLayerID is indeed unique Unique = TRUE; // Until we know better pLayer = pSpread->FindFirstLayer(); while (pLayer != NULL) { if (UniqueLayerID == pLayer->GetLayerID()) { Unique = FALSE; // UniqueLayerID is not unique so increment NewLayerNum and try again NewLayerNum++; break; } pLayer = pLayer->FindNextLayer(); } } while (!Unique); return(UniqueLayerID); }

void LayerSGallery::DoChangeAllVisible (  BOOL  AllVisible  )  [virtual]

Called when the AllVisible button is clicked in the layers gallery. Effects the visibility of all layers, regardless of their visibility. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/8/94 Parameters: AllVisible  - TRUE means all layers become visible [INPUTS] FALSE means only visible layers are visible Returns: - Definition at line 2736 of file sglayer.cpp. { if (!CheckVarsAreValid()) return; // Get the state prior to the change BOOL PrevAllVisible = pDoc->IsAllVisible(); // If no change, return if (PrevAllVisible == AllVisible) return; Layer* pLayer = pSpread->FindFirstLayer(); while (pLayer != NULL) { // Do not include the page background layer in this process as this is very bad! if (!pLayer->IsPageBackground()) { pDoc->SetAllVisible(PrevAllVisible); BOOL PrevVisible = pLayer->IsVisible(); // BOOL PrevLocked = pLayer->IsLocked(); pDoc->SetAllVisible(AllVisible); BOOL PostVisible = pLayer->IsVisible(); // BOOL PostLocked = pLayer->IsLocked(); if (PrevVisible != PostVisible) { LayerSGallery::ForceRedrawLayer(pDoc,pLayer); if (!PostVisible) NodeRenderableInk::DeselectAllOnLayer(pLayer); } } pLayer = pLayer->FindNextLayer(); } pDoc->SetAllVisible(AllVisible); // inform that visible layers have changed BROADCAST_TO_ALL(LayerMsg(pLayer, LayerMsg::LAYER_VISIBILITY_CHANGED)); }

void LayerSGallery::DoChangeLayerState (  Layer *  pLayer, OpLayerGalReason  Reason, BOOL  NewState )  [virtual]

Undoable way of changing the layer's state. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 7/3/95 Parameters: pLayer  = ptr to the layer to change [INPUTS] Reason = the flag which to change NewState = The new state of the flag to change Returns: - Definition at line 2951 of file sglayer.cpp. { if (!CheckVarsAreValid()) return; OpLayerGalParam Param(Reason, pSpread); Param.pLayer = pLayer; Param.NewState = NewState; Param.pLayerSGal= this; OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_LAYERGALCHANGE); if (pOpDesc != NULL) pOpDesc->Invoke((OpParam*)&Param); else { ERROR3("Couldn't find OPTOKEN_LAYERGALCHANGE op descriptor"); } }

void LayerSGallery::DoChangeLayerStatus (  Layer *  pLayer, const LayerStatus &  NewStatus )  [protected, virtual]

General undoable way of changing the selected layer's status. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/8/94 Parameters: pLayer  = ptr to the layer to change [INPUTS] NewStatus = reference to the status that the selected layer should take on board. Returns: - Definition at line 2919 of file sglayer.cpp. { if (!CheckVarsAreValid()) return; OpLayerGalParam Param(LAYER_CHANGE, pSpread); Param.pLayer = pLayer; Param.Status = NewStatus; OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_LAYERGALCHANGE); if (pOpDesc != NULL) pOpDesc->Invoke((OpParam*)&Param); else { ENSURE(FALSE,"Couldn't find OPTOKEN_LAYERGALCHANGE op descriptor"); } }

void LayerSGallery::DoChangeLocked (  Layer *  pLayer, BOOL  Locked )  [static]

Called when the Locked button is clicked in a layer gallery item. Changes the lockedness of the displayed layer. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> (Jason, ripped from the LayerGallery, 1/2/95) Date: 8/8/94 Parameters: pLayer  = the layer to change [INPUTS] Locked - TRUE means make the displayed layer locked FALSE means unlock Returns: - Notes: Does not redraw the layer in the display list Definition at line 2891 of file sglayer.cpp. { ERROR3IF(pLayer == NULL,"pLayer == NULL"); if (pLayer == NULL) return; BOOL PrevLocked = pLayer->IsLocked(); pLayer->SetLocked(Locked); BOOL PostLocked = pLayer->IsLocked(); if (PrevLocked != PostLocked) NodeRenderableInk::DeselectAllOnLayer(pLayer); }

void LayerSGallery::DoChangeMultilayer (  BOOL  Multilayer  )  [virtual]

Called when the Multilayer button is clicked in the layers gallery. Effects the locked state of all layers, regardless of their individual locked state. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 11/8/94 Parameters: Multilayer  - TRUE means all layers become unlocked [INPUTS] FALSE means only locked layers are locked Returns: - Definition at line 2796 of file sglayer.cpp. { if (!CheckVarsAreValid()) return; // Get the state prior to the change BOOL PrevMultilayer = pDoc->IsMultilayer(); // If no change, return if (PrevMultilayer == Multilayer) return; Layer* pLayer = pSpread->FindFirstLayer(); BOOL PrevLocked; BOOL PostLocked; while (pLayer != NULL) { // Do not include the page background layer in this process as this is very bad! if (!pLayer->IsPageBackground()) { pDoc->SetMultilayer(PrevMultilayer); PrevLocked = pLayer->IsLocked(); pDoc->SetMultilayer(Multilayer); PostLocked = pLayer->IsLocked(); if ((PrevLocked != PostLocked) && PostLocked) NodeRenderableInk::DeselectAllOnLayer(pLayer); } pLayer = pLayer->FindNextLayer(); } pDoc->SetMultilayer(Multilayer); }

void LayerSGallery::DoChangeName (   )  [protected, virtual]

Pops up the name changing dialog for the selected layer. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/8/94 Parameters: -  [INPUTS] Returns: - Definition at line 2610 of file sglayer.cpp. { SGDisplayLayer* pLayerGalItem = GetSelectedLayerGalItem(); if (pLayerGalItem != NULL) { LayerDlgParam Param(LAYER_CHANGE_NAME,NULL,pLayerGalItem->GetDisplayedLayer()); LayerNameDlg::StartUp(&Param); } }

void LayerSGallery::DoChangeVisible (  Layer *  pLayer, BOOL  Visible )  [static]

Called when the visible button is clicked in a layer gallery item. Changes the visibility of the displayed layer. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> (Jason, ripped from the LayerGallery, 1/2/95) Date: 8/8/94 Parameters: pLayer  = the layer to change [INPUTS] Visible - TRUE means make the displayed layer visible FALSE means make invisiblr Returns: - Notes: Does not redraw the layer in the display list Definition at line 2850 of file sglayer.cpp. { ERROR3IF(pLayer == NULL,"pLayer == NULL"); if (pLayer == NULL) return; BOOL PrevVisible = pLayer->IsVisible(); pLayer->SetVisible(Visible); BOOL PostVisible = pLayer->IsVisible(); if (PrevVisible != PostVisible) { // Force a redraw if the layer's visibility has changed LayerSGallery::ForceRedrawLayer(pLayer->FindDocument(), pLayer); // inform that visible layers have changed BROADCAST_TO_ALL(LayerMsg(pLayer, LayerMsg::LAYER_VISIBILITY_CHANGED)); // If layer has just become invisible, remove the selections on the layer if (!PostVisible) NodeRenderableInk::DeselectAllOnLayer(pLayer); } }

void LayerSGallery::DoCommand (  StringBase *  CommandID  )  [virtual]

To apply a given command when it is chosen from the menu. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/95 Parameters: CommandID  - The String ID of the command [INPUTS] Notes: Override this method to provide handling for your special commands. Call the base class if you don't recognise the command, so that it can handle standard commands. The base class handles all of these (maybe more - see the base class help) Properties, Sort, Find; New, Edit, Delete, Redefine; (it calls ApplyAction as appropriate) NextGroup, PrevGroup, FoldGroup, UnfoldGroup; Reimplemented from SuperGallery. Reimplemented in FrameSGallery. Definition at line 3424 of file sglayer.cpp. { if (*CommandID == SGCmd_Copy) DoCopyLayer(); else if (*CommandID == SGCmd_New) DoCreateNewItem(); else if (*CommandID == SGCmd_Delete) { if (PrepareToDelete()) DoDeleteSelection(); } else if (*CommandID == SGCmd_Properties) DoLayerProperties(); else if (*CommandID == SGCmd_Create) DoCreateGuideLayer(); // Don't call the base class 'cos we don't want any other commands }

void LayerSGallery::DoCopyLayer (   )  [protected, virtual]

Pops up the name changing dialog for the selected layer, and if OK is clicked a copy of the layer is made with the new name. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/8/94 Parameters: -  [INPUTS] Returns: - Reimplemented in FrameSGallery. Definition at line 2637 of file sglayer.cpp. { SGDisplayLayer* pLayerGalItem = GetSelectedLayerGalItem(); if (pLayerGalItem != NULL) { LayerDlgParam Param(LAYER_COPY,NULL,pLayerGalItem->GetDisplayedLayer()); LayerNameDlg::StartUp(&Param); } }

void LayerSGallery::DoCreateGuideLayer (   )  [protected, virtual]

Creates a guide layer. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/10/95 Parameters: -  [INPUTS] Returns: - Definition at line 2704 of file sglayer.cpp. { #ifndef WEBSTER OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_GUIDELINE); ERROR3IF(pOpDesc == NULL,"FindOpDescriptor(OPTOKEN_GUIDELINE) failed"); if (pOpDesc != NULL) { OpGuidelineParam GuidelineParam; GuidelineParam.Method = GUIDELINEOPMETHOD_CREATE_GUIDE_LAYER; pOpDesc->Invoke(&GuidelineParam); } #endif // WEBSTER }

void LayerSGallery::DoCreateNewItem (  void   )  [protected, virtual]

This function is meant to be overridden in derived classes It creates a new item and adds it to the Gallery DisplayList The item may be created by cloning/deriving/basing-on the selected item, depending on the type of Gallery concerned. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 2/8/94 Reimplemented in FrameSGallery. Definition at line 2589 of file sglayer.cpp. { if (!CheckVarsAreValid()) return; LayerDlgParam Param(LAYER_NEW,pSpread,NULL); LayerNameDlg::StartUp(&Param); }

BOOL LayerSGallery::DoDeleteSelection (  void   )  [protected, virtual]

FORCIBLY deletes the current gallery selection. By the time this function is called, PrepareToDelete has made sure that it is safe to continue. This must simply invoke a forced delete upon the selection. Deletion of colours occurs by hiding (with undo). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 2/8/94 Returns: FALSE if it couldn't delete the selection. (This should, if at all possible leave the entire selection undeleted in this case) See also: LayerSGallery::PrepareToDelete; ColourManager::HideColours Reimplemented in FrameSGallery. Definition at line 2549 of file sglayer.cpp. { SGDisplayLayer* pLayerGalItem = GetSelectedLayerGalItem(); if (pLayerGalItem != NULL) { OpLayerGalParam Param(LAYER_DELETE,pSpread); Param.pLayer = pLayerGalItem->GetDisplayedLayer(); OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_LAYERGALCHANGE); if (pOpDesc != NULL) pOpDesc->Invoke((OpParam*)&Param); else { ERROR3("Couldn't find OPTOKEN_LAYERGALCHANGE op descriptor"); } return (TRUE); } return (pLayerGalItem != NULL); }

void LayerSGallery::DoLayerProperties (   )  [protected, virtual]

Opens the layer properties dlg. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 3/10/95 Parameters: -  [INPUTS] Returns: - Definition at line 2661 of file sglayer.cpp. { #ifndef STANDALONE // layer property tabs not present in viewer OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_LAYERPROPERTYTABS); if (pOpDesc != NULL) { String_256 Str; OpState State = pOpDesc->GetOpsState(&Str); if (!State.Greyed) pOpDesc->Invoke(); else { // Changed for Frame/Layer integration - RanbirR //#ifdef WEBSTER // GIFAnimationPropertyTabs * pTabHandler = GIFAnimationPropertyTabsDlg::GetGIFAnimationPropertiesTabs(); //#else LayerPropertyTabs * pTabHandler = LayerPropertyTabsDlg::GetLayerPropertiesTabs(); //#endif // webster -RanbirR if (pTabHandler) { DialogTabOp* pDlg = pTabHandler->GetTabbedDlg(); if (pDlg != NULL) pDlg->Open(); } } } #endif }

void LayerSGallery::DoMoveLayer (  MoveLayerType  Reason  )  [protected, virtual]

Called when the Locked button is clicked in the layers gallery. Changes the lockedness of the selected layer, if there is one. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/8/94 Parameters: Reason  = how the layer should be moved [INPUTS] Returns: - Reimplemented in FrameSGallery. Definition at line 2986 of file sglayer.cpp. { SGDisplayLayer* pLayerGalItem = GetSelectedLayerGalItem(); if (pLayerGalItem != NULL) { OpLayerGalParam Param(LAYER_MOVE, pSpread); Param.pLayer = pLayerGalItem->GetDisplayedLayer(); switch (Reason) { case (MOVELAYER_UPONE) : Param.pContextNode = Param.pLayer->FindNextLayer(); Param.AttDir = NEXT; break; case (MOVELAYER_DOWNONE) : Param.pContextNode = Param.pLayer->FindPrevLayer(); Param.AttDir = PREV; break; default: ENSURE(FALSE,"Unrecognised MoveLayer reason"); break; } if (Param.pContextNode != NULL) { // Redraw after the op if both this layer and the one it's moving in front/behind // is also visible Param.MoveRedraw = ((Layer*)Param.pContextNode)->IsVisible() && Param.pLayer->IsVisible(); // The above won't work in an undo or redo, so always redraw Param.MoveRedraw = TRUE; OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_LAYERGALCHANGE); if (pOpDesc != NULL) pOpDesc->Invoke((OpParam*)&Param); else { ENSURE(FALSE,"Couldn't find OPTOKEN_LAYERGALCHANGE op descriptor"); } } } }

BOOL LayerSGallery::DoMoveSelectionToActiveLayer (   )  [static]

Author: Simon_Knight (Xara Group Ltd) <camelotdev@xara.com> Date: 3/5/00 Parameters: -  [INPUTS] Returns: TRUE if op exists Definition at line 3562 of file sglayer.cpp. { // Find the OP. for the Layer gallery. OpDescriptor* OpDesc; OpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_MOVE_SEL_TO_ACTIVE_LAYER); // Ensure we get a ptr to the OP. if(!OpDesc) return FALSE; // ok, now open the layergallery. OpDesc->Invoke(); // Lets go back. return TRUE; }

void LayerSGallery::DoShadeGallery (  BOOL  ShadeIt  )  [protected, virtual]

Called by the base class whenever the shaded status of the gallery is changed, to allow derived galleries to shade/unshade any extra controls that they provide in the window. ONLY called if the gallery is actually open/visible. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/94 Parameters: ShadeIt  - TRUE if the gallery is being shaded [INPUTS] FALSE if the gallery is being unshaded Notes: Need not be overridden - the default action is to do nothing extra to the normal shade/unshade operation. See also: Gallery::ShadeGallery; Gallery::UnshadeGallery Reimplemented from SuperGallery. Reimplemented in FrameSGallery. Definition at line 3083 of file sglayer.cpp. { BOOL fEnableMove = FALSE; OpDescriptor* pDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_MOVE_SEL_TO_ACTIVE_LAYER); if (pDesc != 0) { String_256 str; OpState os = pDesc->GetOpsState(&str); fEnableMove = !os.Greyed; } EnableGadget(_R(IDC_LAYER_MOVE_TO_ACTIVE), !ShadeIt && fEnableMove); EnableGadget(_R(IDC_GALLERY_UPONE), !ShadeIt); EnableGadget(_R(IDC_GALLERY_DOWNONE), !ShadeIt); EnableGadget(_R(IDC_GALLERY_PROPERTIES), !ShadeIt); EnableGadget(_R(IDC_GALLERY_COPY), !ShadeIt && !IsSelectedItemGuideLayer()); EnableGadget(_R(IDC_BTN_MULTILAYER), !ShadeIt); EnableGadget(_R(IDC_BTN_ALLVISIBLE), !ShadeIt); //EnableGadget(_R(IDC_GALLERY_NAME), !ShadeIt); }

void LayerSGallery::EnsureActiveLayerIntegrity (   )  [protected, virtual]

This checks that there is one and only one active layer in the gallery's spread. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: LayerSGallery::EnsureActiveLayerIntegrity(Spread* pSpread) Definition at line 2415 of file sglayer.cpp. { LayerSGallery::EnsureActiveLayerIntegrity(pSpread); }

void LayerSGallery::EnsureActiveLayerIntegrity (  Spread *  pSpread, Layer **  ppActiveLayer = NULL )  [static]

This checks that there is one and only one active layer in the given spread. If there isn't an active layer, the first layer is made active. If there is more than on active layer, all but the first active layer are made inactive. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 22/3/95 Parameters: pSpread  = ptr to spread [INPUTS] -  [OUTPUTS] Returns: - Definition at line 2231 of file sglayer.cpp. { if (pSpread == NULL) return; // Get the first layer in the spread Layer* pFirstLayer = pSpread->FindFirstLayer(); // Not found an active layer yet Layer* pActiveLayer = NULL; // Start the search from the first layer Layer* pLayer = pFirstLayer; INT32 ActiveLayers = 0; while (pLayer != NULL && pActiveLayer == NULL) { if (pLayer->IsActive()) { ActiveLayers++; pActiveLayer = pLayer; // Found the active layer, so make a note of it } pLayer = pLayer->FindNextLayer(); } // If we haven't found any active layers, make the last (top) one active // WEBSTER - markn 23/1/97 // In Webster, always pick the top layer to be the active layer //#ifndef WEBSTER if (pActiveLayer == NULL) //#endif // WEBSTER pActiveLayer = pSpread->FindLastLayer(); // In this instance ActiveLayers must be 0 // If we have an active layer, ensure that it really is the one and only active layer // AMB20060416 - only make the call if did not have exactly one active layer before // to save an unnecessary layer change message when the layer gallery is brought up if ((pActiveLayer != NULL) /*&& (ActiveLayers != 1)*/) LayerSGallery::MakeActiveLayer(pActiveLayer); // If caller wants the ptr to the active layer if (ppActiveLayer != NULL) *ppActiveLayer = pActiveLayer; }

void LayerSGallery::EnsureSelSpreadSelectionIntegrity (   )  [protected, virtual]

This makes sure that all the invisible and/or locked layers in the spread have no selection. It calls NodeRenderableInk::DeselectAllOnLayer() on each layer that should NOT have a selection, just in case. Currently only called after an undo or redo op, because it could be quite slow. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Reimplemented in FrameSGallery. Definition at line 2050 of file sglayer.cpp. { if (pSpread == NULL) return; // Get the first layer in the spread Layer* pLayer = pSpread->FindFirstLayer(); while (pLayer != NULL) { // If the layer is not visible OR the layer is locked, make sure there is no selection if (!pLayer->IsVisible() || pLayer->IsLocked()) NodeRenderableInk::DeselectAllOnLayer(pLayer); pLayer = pLayer->FindNextLayer(); } }

void LayerSGallery::ForceRedrawLayer (  Document *  pDoc, Layer *  pLayer )  [static]

Does a ForceRedraw on the layer in the given doc. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/94 Parameters: pDoc  = ptr that contains this layer [INPUTS] pLayer = ptr to the layer you want to redraw -  [OUTPUTS] Returns: - Definition at line 2083 of file sglayer.cpp. { Spread* pSpread = pLayer->FindParentSpread(); if (pSpread != NULL) { DocRect rect = pLayer->GetUnionBlobBoundingRect(); pDoc->ForceRedraw(pSpread, rect, FALSE, pLayer); // Don't allow caches to retain backgrounds if (pLayer->IsGuide()) { Node* pNode = pLayer->FindFirstChild(CC_RUNTIME_CLASS(NodeGuideline)); while (pNode != NULL) { rect = ((NodeGuideline*)pNode)->GetRenderRect(); pDoc->ForceRedraw(pSpread, rect, FALSE, pLayer); // Don't allow caches to retain backgrounds pNode = pNode->FindNext(CC_RUNTIME_CLASS(NodeGuideline)); } } } }

OpState LayerSGallery::GetCommandState (  StringBase *  CommandID, String_256 *  ShadeReason )  [virtual]

To determine the state of a given menu item. This method is an exact parallel to an Op's GetState method (in fact, it is called by an Op's GetState). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/95 Parameters: CommandID  - TheString ID of the command [INPUTS] ShadeReason  - If you return (OpState.Greyed == TRUE) then this should be filled [OUTPUTS] ion with the reason that the item is shaded/greyed. Returns: An OpState indicating the current menu item state. Notes: Override this method to provide state info for your special commands Call the base class for unknown commands to allow it to handle them for you The base class handles all of these (maybe more - see the base class help) Properties, Sort, Find; New, Edit, Delete, Redefine; NextGroup, PrevGroup, FoldGroup, UnfoldGroup; Reimplemented from SuperGallery. Reimplemented in FrameSGallery. Definition at line 3344 of file sglayer.cpp. { OpState State; if (AmShaded) // No commands available while the gallery is shaded { State.Greyed = TRUE; return(State); } if (*CommandID == SGCmd_Copy || // --- Copy/Delete/Properties *CommandID == SGCmd_Delete || *CommandID == SGCmd_Properties) { SGDisplayLayer* pItem = GetSelectedLayerGalItem(); if (pItem == NULL) { State.Greyed = TRUE; ShadeReason->MakeMsg(_R(IDS_SGSHADE_SINGLECOL)); } else if (*CommandID == SGCmd_Copy) // Can't copy Guide layers State.Greyed = IsSelectedItemGuideLayer(); #ifndef STANDALONE else if (*CommandID == SGCmd_Properties) // Shade when dlg is open { //State.Greyed = (LayerPropertyTabs::GetTabbedDlg() != NULL); //#ifdef WEBSTR // GIFAnimationPropertyTabs * pTabHandler = GIFAnimationPropertyTabsDlg::GetGIFAnimationPropertiesTabs(); //#else LayerPropertyTabs * pTabHandler = LayerPropertyTabsDlg::GetLayerPropertiesTabs(); //#endif //webster RanbirR if (pTabHandler) State.Greyed = (pTabHandler->GetTabbedDlg() != NULL); else State.Greyed = TRUE; } #endif } else if (*CommandID == SGCmd_Create) { Spread* pSpread = Document::GetSelectedSpread(); Layer* pGuideLayer = NULL; if (pSpread != NULL) pGuideLayer = pSpread->FindFirstGuideLayer(); State.Greyed = (pGuideLayer != NULL); } // Don't call the base class 'cos we don't want any other commands return(State); }

INT32 LayerSGallery::GetGuideLayerState (  DocView *  pDocView  )  [protected, virtual]

This returns the current state of the guide layer. It is used to determine whether we need to recreate and redraw the layer gallery when the selected view changes. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 28/9/95 Parameters: pDocView  = ptr to docview (This holds visibility info for guide layers) [INPUTS] -  [OUTPUTS] Returns: 0 = Guide layer is invisible 1 = Guide layer is visible -1 = Guide layer doesn't exist Definition at line 1990 of file sglayer.cpp. { Spread* pSelSpread = GetSelectedSpread(); if (pSelSpread != NULL) { Layer* pLayer = pSelSpread->FindFirstGuideLayer(); if (pLayer != NULL) return (pLayer->IsVisible(pDocView)); } return -1; }

BOOL LayerSGallery::GetNewDocBorn (   )  [inline, protected]

Reimplemented in FrameSGallery. Definition at line 392 of file sglayer.h. { return m_NewDocBorn; }

SGDisplayLayer * LayerSGallery::GetSelectedLayerGalItem (   )  [protected, virtual]

Gets the selected layer gallery item In debug builds, an ENSURE will go off if there is no selected gal item. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: A ptr to the selected layer gallery item. NULL if there is no selectet item Reimplemented in FrameSGallery. Definition at line 2436 of file sglayer.cpp. { SGDisplayLayer* pDispLayer = NULL; if (CheckVarsAreValid()) { ERROR3IF(DisplayForeground == NULL || DisplayBackground == NULL,"Fore and/or background group(s) are/is NULL"); if (DisplayForeground == NULL || DisplayBackground == NULL) return NULL; // Look in the foreground group first pDispLayer = ((SGDisplayLayer *) DisplayForeground->FindNextSelectedItem(NULL)); // If no joy, have a look in the background group if (pDispLayer == NULL) pDispLayer = ((SGDisplayLayer *) DisplayBackground->FindNextSelectedItem(NULL)); ERROR3IF(pDispLayer == NULL,"Can't find the selected layer item in the layer gallery"); // SGDisplayGroup *DocumentGroup = DisplayTree->FindSubtree(this, pDoc, NULL); // if (DocumentGroup != NULL) // return((SGDisplayLayer *) DocumentGroup->FindNextSelectedItem(NULL)); } return(pDispLayer); }

Spread * LayerSGallery::GetSelectedSpread (  void   )  [inline]

To find the current layer gallery spread. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/1/95 Returns: A pointer to the spread that the layer gallery regards as 'current' Definition at line 414 of file sglayer.h. { return(pSpread); }

BOOL LayerSGallery::HasLayerGotChildren (  Layer *  pLayer  )  [protected, virtual]

Scans the layer for children that render something on the screen. It ignores attributes, hidden nodes, etc - nodes that don't render anything themselves. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/8/94 Parameters: pLayer  = the layer you want to check [INPUTS] -  [OUTPUTS] Returns: TRUE - The layer has children the user may be interested in - i.e. children that actually render something. FALSE - The layer has no rendering children Code moved into Layer::HasLayerGotRenderableChildren 21/7/97 Definition at line 2483 of file sglayer.cpp. { ERROR2IF(pLayer == NULL,FALSE,"HasLayerGotChildren bad param!"); return pLayer->HasLayerGotRenderableChildren(); }

BOOL LayerSGallery::InitMenuCommands (  void   )  [virtual]

Initialises any menu commands that this gallery needs. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 18/9/95 Returns: TRUE for success Notes: Will only create the menu commands once - further calls in the future will return TRUE immediately wihtout doing anything. Reimplemented from SuperGallery. Reimplemented in FrameSGallery. Definition at line 3237 of file sglayer.cpp. { static BOOL MenusInitialised = FALSE; BOOL ok = TRUE; if (!MenusInitialised) { // Initialise menu command Ops // "Special" entries for over-list menu ok = ok && InitMenuCommand((StringBase *) &SGCmd_Copy, _R(IDS_SGMENU_COPY)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Delete, _R(IDS_SGMENU_DELETE)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_New, _R(IDS_NEW_LAYER)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Create, _R(IDS_CREATE_GUIDE_LAYER)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Properties,_R(IDS_SGMENU_PROPERTIES)); MenusInitialised = TRUE; } return(ok); }

BOOL LayerSGallery::IsLayerMode (  Document *  pDoc  )  [protected]

Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 21/10/97 Parameters: Pointer  to the document. [INPUTS] Returns: TRUE if the document is Frame based, else FALSE. Definition at line 3522 of file sglayer.cpp. { ERROR3IF(pDoc == NULL,"pDoc == NULL"); // flag to determine the document mode. BOOL LayerMode = TRUE; // Get a ptr to the selected spread Spread* pSpread = pDoc->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) LayerMode = FALSE; } // return the document mode. return LayerMode; }

BOOL LayerSGallery::IsSelectedItemGuideLayer (   )  [protected, virtual]

General function for finding out if the selected item is a guide layer Notes: Need not be overridden - the default action is to do nothing extra to the normal shade/unshade operation. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/95 Parameters: -  [INPUTS] Returns: TRUE if the selected layer is a guide layer or no selected layer, FALSE otherwise See also: Gallery::ShadeGallery; Gallery::UnshadeGallery Definition at line 3050 of file sglayer.cpp. { SGDisplayLayer* pItem = GetSelectedLayerGalItem(); Layer* pLayer = NULL; if (pItem != NULL) pLayer = pItem->GetDisplayedLayer(); if (pLayer != NULL) return (pLayer->IsGuide()); return TRUE; }

void LayerSGallery::MakeActiveLayer (  Layer *  pNewActiveLayer, BOOL  TellAll = TRUE )  [static]

Makes the layer active. Firstly it will inactivate any other active layers, forcing it to redraw if necessary Then it will set this layer to be active, again forcing a redraw if necessary. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/8/94 Parameters: pNewActiveLayer  = ptr to the layer you want to be active [INPUTS] -  [OUTPUTS] Returns: - If the given new layer is already active, nothing happens Note: pNewActiveLayer must be in the currect doc Definition at line 2179 of file sglayer.cpp. { Spread* pSpread = pNewActiveLayer->FindParentSpread(); ERROR3IF(pSpread == NULL,"Eh up, the layer has no parent spread"); if (pSpread == NULL) return; Document *pDoc = pSpread->FindParentDocument(); if (pDoc == NULL) return; { // Remove any other active layers, redrawing if necessary. Layer* pLayer = pSpread->FindFirstLayer(); while (pLayer != NULL) { if (pLayer->IsActive() && pLayer != pNewActiveLayer) LayerSGallery::SetActive(pDoc,pLayer,FALSE); pLayer = pLayer->FindNextLayer(); } } // Make sure the new layer is active, redrawing if necessary if (!pNewActiveLayer->IsActive()) LayerSGallery::SetActive(pDoc,pNewActiveLayer,TRUE); #if defined(EXCLUDE_FROM_RALPH) //ERROR3("LayerSGallery::MakeActiveLayer supressed broadcast - bad !"); #else if (TellAll) BROADCAST_TO_ALL(LayerMsg(pNewActiveLayer,LayerMsg::ACTIVE_LAYER_CHANGED)); #endif }

void LayerSGallery::MakeTopLayerActive (  Spread *  pSpread  )  [static]

Makes the layer active. Firstly it will inactivate any other active layers, forcing it to redraw if necessary If the new layer is already active, nothing else happens Then it will set this layer to be active, again forcing a redraw if necessary. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 9/1/95 Parameters: pSpread  = Spread which should have its top layer made active [INPUTS] -  [OUTPUTS] Returns: - Definition at line 2294 of file sglayer.cpp. { // Check for NULL spread if (pSpread == NULL) return; // The top layer is the last layer in the spread's child list // so find the last layer and make it active Layer* pLayer = pSpread->FindLastLayer(); if (pLayer != NULL) MakeActiveLayer(pLayer); }

MsgResult LayerSGallery::Message (  Msg *  Message  )  [virtual]

A standard message handler, really. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/95 (base generated in sgbase.cpp) Parameters: Message  - The message to handle [INPUTS] Notes: Any messages that this does not handle must be passed down to the SuperGallery base class message handler. NOTE WELL that the SuperGallery base class handler does some funky things for us - see SuperGallery::Message - such as deleting our display subtree for any document which dies (which, uncannily, would explain why they go away like that when you close documents ;-), and shading the gallery when there are no documents present. [To override this behaviour in these cases, you should respond to the message, and return OK rather than calling the base class message handler] See also: SuperGallery::Message Reimplemented from SuperGallery. Reimplemented in FrameSGallery. Definition at line 1597 of file sglayer.cpp. { if (IS_OUR_DIALOG_MSG(Message)) { DialogMsg* Msg = (DialogMsg*)Message; switch (Msg->DlgMsg) { case DIM_CREATE: SGInit::UpdateGalleryButton(_R(OPTOKEN_DISPLAYLAYERGALLERY), TRUE); break; case DIM_CANCEL: SGInit::UpdateGalleryButton(_R(OPTOKEN_DISPLAYLAYERGALLERY), FALSE); break; default: break; } } // If we have no displaytree, then we have not been shown, or something terrible has // happened, so we don't bother handling any of these messages. if (DisplayTree == NULL) return(SuperGallery::Message(Message)); if (IS_OUR_DIALOG_MSG(Message)) { DialogMsg* Msg = (DialogMsg*)Message; INT32 state; switch (Msg->DlgMsg) { case DIM_LFT_BN_CLICKED: { //TRACE( _T("Gadget %d clicked\n"),Msg->GadgetID); if (FALSE) {} else if (Msg->GadgetID == _R(IDC_BTN_MULTILAYER)) { state = GetLongGadgetValue(_R(IDC_BTN_MULTILAYER),0,1); DoChangeLayerState(NULL,LAYER_MULTILAYER,state); //DoChangeMultilayer(state); //ForceRedrawOfList(); } else if (Msg->GadgetID == _R(IDC_BTN_ALLVISIBLE)) { state = GetLongGadgetValue(_R(IDC_BTN_ALLVISIBLE),0,1); DoChangeLayerState(NULL,LAYER_ALLVISIBLE,state); //DoChangeAllVisible(state); //ForceRedrawOfList(); } else if (Msg->GadgetID == _R(IDC_GALLERY_UPONE)) { DoMoveLayer(MOVELAYER_UPONE); } else if (Msg->GadgetID == _R(IDC_GALLERY_DOWNONE)) { DoMoveLayer(MOVELAYER_DOWNONE); } else if (Msg->GadgetID == _R(IDC_GALLERY_NAME)) { //DoChangeName(); //break; } else if (Msg->GadgetID == _R(IDC_GALLERY_PROPERTIES)) { DoLayerProperties(); } else if (Msg->GadgetID == _R(IDC_GALLERY_COPY)) { DoCopyLayer(); } else if (Msg->GadgetID == _R(IDC_LAYER_MOVE_TO_ACTIVE)) { DoMoveSelectionToActiveLayer(); } #ifndef WEBSTER else if (Msg->GadgetID == _R(IDC_GALLERY_HELP)) { HelpUserTopic(_R(IDS_HELPPATH_Gallery_Layer)); } #endif } default: break; } } else if (MESSAGE_IS_A(Message, OpMsg)) { switch (((OpMsg*)Message)->MsgType) { case OpMsg::AFTER_UNDO: case OpMsg::AFTER_REDO: EnsureSelSpreadSelectionIntegrity(); break; default: break; } } else if (MESSAGE_IS_A(Message, SpreadMsg)) { SpreadMsg* pSpreadMsg = (SpreadMsg*) Message; switch (pSpreadMsg->Reason) { case SpreadMsg::SELCHANGED: NewSelectedSpread(pSpreadMsg->pNewSpread); // gets selected doc too if (pDoc != NULL && IsVisible()) { TRACEUSER( "Neville", _T("SpreadMsg::SELCHANGED CreateNewSubtree\n")); CreateNewSubtree(pDoc); ForceRedrawOfList(); } break; case SpreadMsg::LAYERCHANGES: if (IsVisible()) { if (pSpreadMsg->pNewSpread == pSpread) { if (pSpread->FindFirstLayer() != NULL) { EnsureActiveLayerIntegrity(); if (pDoc != NULL && IsVisible()) { TRACEUSER( "Neville", _T("SpreadMsg::LAYERCHANGES CreateNewSubtree\n")); CreateNewSubtree(pDoc); ForceRedrawOfList(); } } } } else { if (pSpreadMsg->pNewSpread->FindFirstLayer() != NULL) { pSpread = pSpreadMsg->pNewSpread; EnsureActiveLayerIntegrity(); } } break; default: break; } } else if (MESSAGE_IS_A(Message, DocChangingMsg)) { DocChangingMsg *Msg = (DocChangingMsg *) Message; switch (Msg->State) { case DocChangingMsg::TITLECHANGED: // Showstopper removed, Jason, 28/3/96 // When the doc title changes, we simply need to redraw to update the group titles. // Calling CreateNewSubtree will destroy the existing tree - this is really really bad // when the document title changed as a result of us (e.g.) locking a layer, because the // message broadcats hits us while we're still in the middle of traversing the tree, // we then delete the tree out from under ourselves, and are then in a highly dodgy state! // CreateNewSubtree(Msg->pChangingDoc); ForceRedrawOfList(); break; // This message is sent when a new or just opened document is stable. case DocChangingMsg::SELCHANGED: { if (Msg->pNewDoc == NULL) { // No documents around any more, so we must wipe the display tree // The base class will shade the gallery for us. TRACEUSER( "Neville", _T("DocChangingMsg::SELCHANGED CreateNewSubtree\n")); CreateNewSubtree(NULL); ForceRedrawOfList(); } else { #ifdef WEBSTER // There is an active document, so ensure the gallery is unshaded ShadeGallery(FALSE); #else //Do not process the message if it has been sent due to the creation of a new document. if ( !GetNewDocBorn() ) { // flag variables. BOOL LayerMode = FALSE; // Get the changing document pointer. Document* pDoc = Msg->pNewDoc; if(pDoc) { // Determine the document mode. LayerMode = IsLayerMode(pDoc); // If we are no longer in Layer mode then // close the Layer gallery and open the Frame gallery. if( !LayerMode && IsVisible() ) { // Close the layer gallery. if( CloseLayerGallery() ) { // Open the frame gallery. OpenFrameGallery(); } } } } // If the gallery is visible, then ensure the gallery is unshaded. if(IsVisible()) { // There is an active document, so ensure the gallery is unshaded ShadeGallery(FALSE); } #endif } break; } #ifndef WEBSTER case DocChangingMsg::BORN: { // When a new document is created, a SELCHANGED // message is broadcasted, for Camelot2 frame/layer integration // we do not wish to process the message. // We therefore set this flag to notify us when a new document // is born. // Ensure we are no longer in Frame mode and the frame gallery is open. if( IsVisible() ) { // Set the flag to true. // This is set to false in BORNANDSTABLE. SetNewDocBorn(TRUE); } break; } case DocChangingMsg::BORNANDSTABLE: { // flag variables. BOOL LayerMode = FALSE; // BOOL GalleryClosed = FALSE; // Get the changing document pointer. Document* pChangingDoc = Msg->pChangingDoc; if(pChangingDoc) { // Determine the document mode. LayerMode = IsLayerMode(pChangingDoc); // If we are no longer in Layer mode then // close the Layer gallery and open the Frame gallery. if( !LayerMode && IsVisible() ) { // Close the layer gallery. if(CloseLayerGallery()) { // Open the frame gallery. OpenFrameGallery(); // Now we have processed this message, it is safe to process SELCHANGED messages. SetNewDocBorn(FALSE); } } } break; } case DocChangingMsg::KILLED: case DocChangingMsg::ABOUTTODIE: { // The doc. is about to die, therefore, set this falg to false. SetNewDocBorn(FALSE); break; } #endif } } else if (MESSAGE_IS_A(Message, DocViewMsg)) { DocViewMsg *Msg = (DocViewMsg *) Message; switch (Msg->State) { case DocViewMsg::SELABOUTTOCHANGE: OldGuideLayerState = GetGuideLayerState(Msg->pNewDocView); break; case DocViewMsg::SELCHANGED: { if (IsVisible()) { NewGuideLayerState = GetGuideLayerState(Msg->pNewDocView); if (OldGuideLayerState != NewGuideLayerState) { TRACEUSER( "Neville", _T("DocViewMsg::SELCHANGED CreateNewSubtree\n")); CreateNewSubtree(Msg->pNewDocView ? Msg->pNewDocView->GetDoc() : NULL); ForceRedrawOfList(); } } } break; default: break; } } else if (MESSAGE_IS_A(Message, LayerMsg)) { LayerMsg *pMsg = (LayerMsg *) Message; switch ( pMsg->Reason ) { // The active layer has changed. case LayerMsg::ACTIVE_LAYER_CHANGED: { EnableGadget(_R(IDC_GALLERY_COPY),pMsg->pNewLayer != NULL && !pMsg->pNewLayer->IsGuide()); } break; // The visibility of a layer has changed, probably by an external source // so update the display case LayerMsg::LAYER_VISIBILITY_CHANGED: { ForceRedrawOfList(); } break; // The active layer has been changed externally to the gallery. case LayerMsg::UPDATE_ACTIVE_LAYER: { // We must now check whether the selected layer has been changed externally // to us. May happen if an animated GIF is being loaded onto layers SGDisplayLayer *pDisplayItem = NULL; if (DisplayForeground != NULL) pDisplayItem = GetSelectedLayerGalItem(); if (pDisplayItem != NULL) { if (pDisplayItem->GetDisplayedLayer() != pMsg->pNewLayer) { Layer* pNewActiveLayer = pMsg->pNewLayer; // Search for the new display item to match this new active layer SGDisplayLayer *pWantedDispLayer = NULL; SGDisplayLayer *pDispLayer = ((SGDisplayLayer *) DisplayForeground->GetChild()); while (pDispLayer != NULL) { if (pDispLayer->GetDisplayedLayer() == pNewActiveLayer) pWantedDispLayer = pDispLayer; pDispLayer = (SGDisplayLayer *) pDispLayer->GetNext(); } // If we found the required display item then go and select it if (pWantedDispLayer) { // Now update the selection states... SelectItems(FALSE); // Deselect everything else // Something has changed so we must go and select this new item pWantedDispLayer->SetSelected(TRUE); } } } } break; default: break; } } return(SuperGallery::Message(Message)); }

void LayerSGallery::NewSelectedSpread (  Spread *  pNewSelSpread = NULL  )  [protected, virtual]

Central place for setting the layer gal's selected spread. Also takes a copy of the selected document. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 4/8/94 Parameters: pNewSelSpread  = ptr to the spread the layer gal should take as the [INPUTS] selected one; NULL will read the global Selected spread value. -  [OUTPUTS] Returns: - Definition at line 2021 of file sglayer.cpp. { if (pNewSelSpread == NULL) pSpread = Document::GetSelectedSpread(); else pSpread = pNewSelSpread; pDoc = Document::GetSelected(); }

BOOL LayerSGallery::OpenFrameGallery (   )  [protected]

Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 21/10/97 Parameters: -  [INPUTS] Returns: TRUE if the document is Frame based, else FALSE. Definition at line 3493 of file sglayer.cpp. { // Find the OP. for the Layer gallery. OpDescriptor* OpDesc; OpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_DISPLAYFRAMEGALLERY); // Ensure we get a ptr to the OP. if(!OpDesc) return FALSE; // ok, now open the layergallery. OpDesc->Invoke(); // Lets go back. return TRUE; }

BOOL LayerSGallery::PostCreate (  void   )  [protected, virtual]

The LayerSGallery PostCreate handler. This overrides the base class PostCreate function. It is called at the very end of the SuperGallery::Create method, after the window has been created and opened. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/95 (base generated in sgbase.cpp) Returns: TRUE if the Gallery initialised successfully FALSE if it should not be opened due to a failure to initialise Reimplemented from SuperGallery. Reimplemented in FrameSGallery. Definition at line 1492 of file sglayer.cpp. { Document *ParentDoc = Document::GetSelected(); if (ParentDoc != NULL) { SetBoolGadgetSelected(_R(IDC_BTN_MULTILAYER),!(ParentDoc->IsMultilayer() == 0)); SetBoolGadgetSelected(_R(IDC_BTN_ALLVISIBLE),!(ParentDoc->IsAllVisible() == 0)); } EnableGadget(_R(IDC_GALLERY_COPY),ParentDoc != NULL && !IsSelectedItemGuideLayer()); return(TRUE); }

BOOL LayerSGallery::PreCreate (  void   )  [protected, virtual]

Layer SuperGallery PreCreate handler. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> (Jason) Date: 2/8/94 Returns: TRUE if it is successful; FALSE to abort creation of the window Notes: This method is called whenever the gallery window is about to be created. Reimplemented from SuperGallery. Definition at line 1454 of file sglayer.cpp. { NewSelectedSpread(); // Cache the selected spread info // If there isn't already one, create a DisplayTree if (DisplayTree == NULL) { DisplayTree = new SGDisplayRootScroll(this); // New root node, with a scrollbar if (DisplayTree == NULL) return(FALSE); } // The layer sgallery is a splitter, in that it only ever shows information for the // selected document, so there is no point trying to call this method for loads of // documents as the other galleries do. CreateNewSubtree(Document::GetSelected()); return(TRUE); }

BOOL LayerSGallery::PrepareToDelete (  void   )  [protected, virtual]

Scans the current Gallery selection. Possibly asks the user for confirmation about the delete. Possibly adjusts the selection as appropriate. Then returns a value to indicate whether the remaining selection should be deleted. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 2/8/94 See also: LayerSGallery::DoDeleteSelection Definition at line 2503 of file sglayer.cpp. { SGDisplayLayer* pLayerGalItem = GetSelectedLayerGalItem(); if (pLayerGalItem != NULL) { if (HasLayerGotChildren(pLayerGalItem->GetDisplayedLayer()) != FALSE) { // If some are in use, determine if the user really wants to delete them INT32 ButtonPressed = AskQuestion(_R(IDS_LAYER_CONSTAINSOBJECTS), _R(IDS_LAYER_DELETE), _R(IDB_CANCEL), 0, 0, 2, 2); if (ButtonPressed == 1) // Force-delete all items, so go ahead and delete return(TRUE); // Delete was cancelled (or Help pressed) - return FALSE return(FALSE); } else return(TRUE); } return (pLayerGalItem != NULL); }

void LayerSGallery::SetActive (  Document *  pDoc, Layer *  pLayer, BOOL  state )  [static]

Calls pLayer->SetActive(state), redrawing and changing the layer's selection if necessary. DON'T CALL THIS FUNC!! USE MakeActiveLayer() INSTEAD!!!! Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 12/8/94 Parameters: pDoc  = ptr to doc containing layer [INPUTS] pLayer = ptr that contains this layer state = TRUE means make active, FALSE means make inactive -  [OUTPUTS] Returns: - Reimplemented in FrameSGallery. Definition at line 2124 of file sglayer.cpp. { // This flag is TRUE if the selection on the layer should be cleared BOOL ClearSelection = FALSE; // get state before active change BOOL PrevVisibleState = pLayer->IsVisible(); BOOL PrevLockedState = pLayer->IsLocked(); // Change active state pLayer->SetActive(state); // get state after active change BOOL PostVisibleState = pLayer->IsVisible(); BOOL PostLockedState = pLayer->IsLocked(); if (PrevVisibleState != PostVisibleState) { // If the visible state has changed, redraw the layer LayerSGallery::ForceRedrawLayer(pDoc,pLayer); // If it has just become invisible, clear the selection ClearSelection = (ClearSelection || !PostVisibleState); } // if it has just become locked, clear the selection if (PrevLockedState != PostLockedState) ClearSelection = (ClearSelection || PostLockedState); // Clear the selection if needed if (ClearSelection) NodeRenderableInk::DeselectAllOnLayer(pLayer); }

void LayerSGallery::SetNewDocBorn (  BOOL  Val  )  [inline, protected]

Reimplemented in FrameSGallery. Definition at line 391 of file sglayer.h. { m_NewDocBorn = Val; }

---

Member Data Documentation

SGDisplayGroup* LayerSGallery::DisplayBackground [protected]

Definition at line 325 of file sglayer.h.

SGDisplayGroup* LayerSGallery::DisplayForeground [protected]

Definition at line 324 of file sglayer.h.

BOOL LayerSGallery::m_NewDocBorn [protected]

Reimplemented in FrameSGallery. Definition at line 326 of file sglayer.h.

INT32 LayerSGallery::NewGuideLayerState [protected]

Definition at line 366 of file sglayer.h.

INT32 LayerSGallery::OldGuideLayerState [protected]

Definition at line 365 of file sglayer.h.

Document* LayerSGallery::pDoc [protected]

Definition at line 323 of file sglayer.h.

Spread* LayerSGallery::pSpread [protected]

Definition at line 322 of file sglayer.h.

---

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

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

---