FrameSGallery Class Reference

The Layer SuperGallery class. More...

#include <sgframe.h>

Inheritance diagram for FrameSGallery:

List of all members.

Public Member Functions
	FrameSGallery ()
	FrameSGallery default constructor.
	~FrameSGallery ()
	FrameSGallery 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.
Static Public Member Functions
static void	MakeActiveLayer (Layer *pNewActiveLayer, UndoableOperation *pUndoOp=NULL)
	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	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 String_256	CreateUniqueLayerID (Spread *pSpread, const String_256 *pBaseName=NULL)
	This function tries to hide the specified node. Copy of the undoable operation version as we are not undoable and don't have an op. Hide it as it may be mentioned in the undo history. Note: This would be safer than deleting the layer nodes but if we use this, which should be the same as the DoHideNode in undoable operation does, then it leaks the hidden nodes and layers that are being hidden. So there must be something sneaky going on.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 BOOL	EnsureFrameLayerIntegrity (Spread *pSpread)
	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.This function should be called before any frame related actions are carried out It will ensure that all the visible layers are frame layers.
static BOOL	DoHideNode (Node *pNodeToHide)
static void	DoChangeSolid (Layer *pLayer, BOOL Solid)
	Called when the Solid button is clicked in a layer gallery item. Changes the Solidness of the displayed layer.
static void	DoChangeOverlay (Layer *pLayer, BOOL Overlay)
	Called when the Overlay button is clicked in a layer gallery item. Changes the Overlayness of the displayed layer.
static void	FixOtherLayers (Spread *pSpread)
	A layer flag such as overlay or solid has been changed and so we need to go and find the active layer and ensure that the other layers above and below this have the correct visibility and locked settings.
static void	FixOtherLayersFromActive (Layer *pActiveLayer, UndoableOperation *pUndoOp=NULL)
	A layer flag such as overlay or solid has been changed and so we need take the passed in current active layer and then ensure that the other layers above and below this have the correct visibility and locked settings.
Protected Member Functions
virtual BOOL	PostCreate (void)
	The FrameSGallery 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 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 SGDisplayLayer *	GetSelectedLayerGalItem ()
	Gets the selected layer gallery item In debug builds, an ENSURE will go off if there is no selected gal item.
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 BOOL	DoDeleteSelection (void)
	FORCIBLY deletes the active layer/frame.
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	DoCopyLayer ()
	Copies the active layer creating a new one with a default frame name.
virtual BOOL	DoSaveAnimation ()
	Saves out the current animation to file.
virtual BOOL	DoPreviewAnimation ()
	Previews the current animation.
virtual BOOL	DoFrameProperties ()
	Opens the frame properties dlg.
virtual BOOL	DoRegenerateFrames ()
	While previewing an animation, if the spread properties are changed we neeed to regenerate the frame layers. This function invokes the correct Op.
virtual BOOL	DoRegenerateSingleFrame ()
	While previewing an animation, if the frame layer properties are changed we neeed to regenerate the active frame. This function invokes the correct Op.
BOOL	UpdateFrameRelatedButtons ()
	Ensures that they buttons on the gallery up to date in their greying/ungreying status.
BOOL	IsFrameMode (Document *pDoc)
BOOL	CloseFrameGallery ()
BOOL	OpenLayerGallery ()
void	SetNewDocBorn (BOOL Val)
BOOL	GetNewDocBorn ()
Protected Attributes
BOOL	m_NewDocBorn

---

Detailed Description

The Layer SuperGallery class.

Author:

Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Jason's Layer gallery code)

Date:

16/4/97 (Based on Jason's Layer gallery 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; SGDisplayFrame

Definition at line 224 of file sgframe.h.

---

Constructor & Destructor Documentation

FrameSGallery::FrameSGallery (   )

FrameSGallery default constructor. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Jason's Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) Definition at line 1006 of file sgframe.cpp. { #ifndef EXCLUDE_GALS pSpread = NULL; pDoc = NULL; DisplayForeground = NULL; // Group of foreground layers DisplayBackground = NULL; // Group of background layers OldGuideLayerState = -1; NewGuideLayerState = -1; m_NewDocBorn = FALSE; #endif }

FrameSGallery::~FrameSGallery (   )

FrameSGallery destructor. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Jason's Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) Definition at line 1032 of file sgframe.cpp. { }

---

Member Function Documentation

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

Applies certain conventional gallery actions (usually associated with gallery buttons, for new, edit, delete, etc). Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Jason's Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) 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 LayerSGallery. Definition at line 1265 of file sgframe.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); SGDisplayFrame *FirstSelected = NULL; if (DocumentGroup != NULL) FirstSelected = (SGDisplayFrame *) 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()) // No warning on Frame gallery 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 FrameSGallery::BuildCommandMenu (  GalleryContextMenu *  TheMenu, SGMenuID  MenuID )  [virtual]

To build a menu of commands to be popped up over the gallery. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Jason's Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) 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 LayerSGallery. Definition at line 2854 of file sgframe.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) { GIFAnimationPropertyTabs * pTabHandler = GIFAnimationPropertyTabsDlg::GetGIFAnimationPropertiesTabs(); //LayerPropertyTabs * pTabHandler = LayerPropertyTabsDlg::GetLayerPropertiesTabs(); 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); #ifndef STANDALONE // ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Animation); // ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Save); ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Preview); ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Properties); // ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_FrameProps); // ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Browser); ok = ok && AddCommand(TheMenu, (StringBase *) &SGCmd_Show); #endif } return(ok); }

BOOL FrameSGallery::CloseFrameGallery (   )  [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 3273 of file sgframe.cpp. { String_32 Name(_R(IDS_FRAMEGAL_GALLNAME)); DialogBarOp* pDialogBarOp = DialogBarOp::FindDialogBarOp(Name); // Ensure a valid ptr. if (pDialogBarOp == NULL) return FALSE; if (pDialogBarOp->GetRuntimeClass() == CC_RUNTIME_CLASS(FrameSGallery)) { GIFAnimationPropertyTabs::SetFrameGalleryOpen(FALSE); // Toggle the visible state of the gallery window pDialogBarOp->SetVisibility( FALSE ); } else { ERROR3("Got the frame gallery but it's not of the LayerSGallery class"); } SGInit::UpdateGalleryButton(OPTOKEN_DISPLAYFRAMEGALLERY, FALSE); GIFAnimationPropertyTabs::SetFrameGalleryOpen(FALSE); // Everything ok. return TRUE; }

void FrameSGallery::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: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Jason's Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) 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 from LayerSGallery. Definition at line 1063 of file sgframe.cpp. { if (DisplayTree == NULL) return; TRACEUSER( "Neville", _T("FrameSGallery::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; TRACEUSER( "Neville", _T("FrameSGallery::CreateNewSubtree completed DestroySubtree\n")); if (ParentDoc == NULL) return; SGDisplayFrame *DisplayLayer = NULL; EnsureActiveLayerIntegrity(); // Create the foreground layer group DisplayForeground = new SGFrameGroup(this, ParentDoc,NULL,TRUE); // Create new Group if (DisplayForeground == NULL) // Total failure - abort return; DisplayTree->AddItem(DisplayForeground); // Add new group to tree Spread* pSelSpread = GetSelectedSpread(); ERROR3IF(pSelSpread == NULL,"No selected spread in FrameSGallery"); if (pSelSpread == NULL) return; Layer* pLayer = pSelSpread->FindLastLayer(); Layer* pActiveLayer = NULL; Layer* pGuideLayer = NULL; BOOL SetActiveLayer = FALSE; // Only Webster needs to show a dummy frame layer #ifdef WEBSTER Layer* pSingleNonFrameLayer = NULL; BOOL ShownSingleNonFrameLayer = FALSE; #endif // WEBSTER while (pLayer != NULL) { // If we find a guide layer then note that for future use if (pLayer->IsGuide()) { pGuideLayer = pLayer; } else if ( (pLayer->IsPseudoFrame() && pLayer->IsFrame()) // its a proper frame layer #ifdef WEBSTER || (pLayer->IsPseudoFrame() && !ShownSingleNonFrameLayer) // its a potential frame layer #endif // WEBSTER ) { #ifdef WEBSTER // If its not a frame layer then note that we have added our single // non-frame layer in. if (!pLayer->IsFrame()) { ShownSingleNonFrameLayer = TRUE; pSingleNonFrameLayer = pLayer; } #endif // WEBSTER // Only add foreground layers and non-guide layers DisplayLayer = new SGDisplayFrame(pLayer); if (DisplayLayer != NULL) { // Always add to the foreground layers 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 SetActiveLayer = TRUE; // Note this fact } } } pLayer = pLayer->FindPrevLayer(); } // If we have not set a selected layer then this is very bad if (!SetActiveLayer) { TRACEUSER( "Neville", _T("Active layer is not a frame layer so force it!\n")); Layer * pNewActiveLayer = pSpread->FindLastFrameLayer(); #ifdef WEBSTER if (pNewActiveLayer == NULL && pSingleNonFrameLayer != NULL) pNewActiveLayer = pSingleNonFrameLayer; #else // ERROR3IF(pNewActiveLayer == NULL,"No current active frame layer"); #endif // WEBSTER // If we have an active layer, ensure that it really is the one and only active layer if (pNewActiveLayer != NULL) { // 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); } // As this can only happen when we have a frame layer which is not active // e.g. import a non-frame xar/web document into a non-frame document // we must use the layer form of MakeActiveLayer so that the visibility of // layers is not affected. LayerSGallery::MakeActiveLayer(pNewActiveLayer); //FrameSGallery::MakeActiveLayer(pNewActiveLayer); } } // 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("FrameSGallery::CreateNewSubtree exit\n")); }

String_256 FrameSGallery::CreateUniqueLayerID (  Spread *  pSpread, const String_256 *  pBaseName = NULL )  [static]

This function tries to hide the specified node. Copy of the undoable operation version as we are not undoable and don't have an op. Hide it as it may be mentioned in the undo history. Note: This would be safer than deleting the layer nodes but if we use this, which should be the same as the DoHideNode in undoable operation does, then it leaks the hidden nodes and layers that are being hidden. So there must be something sneaky going on.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: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Mark N's function in the Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) Parameters: pSpread  - the spread to use when checking [INPUTS] pBaseName - the name to use as the basis of the layer name, defaults to just 'Frame' Returns: A LayerID which is unique for the layer galleries spread. Errors: - See also: - Definition at line 2425 of file sgframe.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) { NumLayers++; pLayer = pLayer->FindNextLayer(); } INT32 NewLayerNum = NumLayers; if (NewLayerNum == 0) NewLayerNum = 1; // Always start at one BOOL Unique; // Flag used to indicate if the id generated is unique or not String_256 LayerName(_R(IDS_DEFAULTFRAMENAME)); // If the caller suggested a base name then use this instead. if (pBaseName != NULL) LayerName = *pBaseName; 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_FRAMENAMEUNIQUEFORM), (TCHAR *)LayerName, NewLayerNum); //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 FrameSGallery::DoChangeOverlay (  Layer *  pLayer, BOOL  Overlay )  [static]

Called when the Overlay button is clicked in a layer gallery item. Changes the Overlayness of the displayed layer. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Mark N's function in the Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) Parameters: pLayer  = the layer to change [INPUTS] Overlay - TRUE means make the displayed layer Overlayed FALSE means make the displayed layer non-Overlayed Returns: - Notes: Does not redraw the layer in the display list Definition at line 2667 of file sgframe.cpp. { ERROR3IF(pLayer == NULL,"pLayer == NULL"); if (pLayer == NULL) return; BOOL PrevOverlay = pLayer->IsOverlay(); pLayer->SetOverlay(Overlay); BOOL PostOverlay = pLayer->IsOverlay(); //if (PrevOverlay != PostOverlay) // NodeRenderableInk::DeselectAllOnLayer(pLayer); if (PrevOverlay != PostOverlay) { Spread* pSpread = pLayer->FindParentSpread(); // Go and fix the status of other layers according to this new setting FixOtherLayers(pSpread); // Ensure that the buttons are in the correct state BROADCAST_TO_ALL(LayerMsg(pLayer, LayerMsg::LayerReason::ACTIVE_LAYER_CHANGED)); } }

void FrameSGallery::DoChangeSolid (  Layer *  pLayer, BOOL  Solid )  [static]

Called when the Solid button is clicked in a layer gallery item. Changes the Solidness of the displayed layer. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Mark N's function in the Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) Parameters: pLayer  = the layer to change [INPUTS] Solid - TRUE means make the displayed layer Solid FALSE means make Solid Returns: - Notes: Does not redraw the layer in the display list Definition at line 2607 of file sgframe.cpp. { ERROR3IF(pLayer == NULL,"pLayer == NULL"); if (pLayer == NULL) return; BOOL PrevSolid = pLayer->IsSolid(); pLayer->SetSolid(Solid); BOOL PostSolid = pLayer->IsSolid(); /* if (PrevSolid != PostSolid) { // Force a redraw if the layer's visibility has changed FrameSGallery::ForceRedrawLayer(pLayer->FindDocument(), pLayer); // If layer has just become invisible, remove the selections on the layer if (!PostSolid) NodeRenderableInk::DeselectAllOnLayer(pLayer); } */ if (PrevSolid != PostSolid) { // Mark all frames above this as edited until we reach the last frame // OR we hit a solid/background layer. // Previewing all the frames copes with dependent frames // Previwing single frames does not if you preview the solid frame. Layer * pFrame = pLayer->FindNextFrameLayer(); while (pFrame != NULL && !pFrame->IsSolid()) { // Mark that frame as edited pFrame->SetEdited(TRUE); pFrame = pFrame->FindNextFrameLayer(); } Spread* pSpread = pLayer->FindParentSpread(); // Go and fix the status of other layers according to this new setting FixOtherLayers(pSpread); // Ensure that the buttons are in the correct state BROADCAST_TO_ALL(LayerMsg(pLayer, LayerMsg::LayerReason::ACTIVE_LAYER_CHANGED)); } }

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

To apply a given command when it is chosen from the menu. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Jason's Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) 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 LayerSGallery. Definition at line 3021 of file sgframe.cpp. { if (*CommandID == SGCmd_Copy) DoCopyLayer(); else if (*CommandID == SGCmd_New) DoCreateNewItem(); else if (*CommandID == SGCmd_Delete) { //if (PrepareToDelete()) // No warning on Frame gallery DoDeleteSelection(); } // else if (*CommandID == SGCmd_Properties) // DoFrameProperties(); else if (*CommandID == SGCmd_Preview) { DoPreviewAnimation(); } else if (*CommandID == SGCmd_FrameProps || *CommandID == SGCmd_Properties) { // Open the Animation properties dlg with the "Frame properties" page selected. DoFrameProperties(); } else if (*CommandID == SGCmd_Show) { // Toggle the state of the show frame in animation flag SGDisplayLayer* pItem = GetSelectedLayerGalItem(); Layer * pLayer = NULL; if (pItem) pLayer = pItem->GetDisplayedLayer(); if (pLayer) { BOOL CurrentState = pLayer->IsHiddenFrame(); pLayer->SetHiddenFrame(!CurrentState); if (pItem) pItem->ForceRedrawOfMyself(); // Ensure that the buttons are in the correct state BROADCAST_TO_ALL(LayerMsg(pLayer, LayerMsg::LayerReason::ACTIVE_LAYER_CHANGED)); } } // else if (*CommandID == SGCmd_Save) // DoSaveAnimation(); // Implement **** // *CommandID == SGCmd_Animation // *CommandID == SGCmd_Browser // Don't call the base class 'cos we don't want any other commands }

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

Copies the active layer creating a new one with a default frame name. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Mark N's function in the Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) Parameters: -  [INPUTS] Returns: - Reimplemented from LayerSGallery. Definition at line 2578 of file sgframe.cpp. { OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_FRAME_COPYFRAME); if (pOpDesc != NULL) pOpDesc->Invoke(); else { ERROR3("Couldn't find OPTOKEN_FRAME_COPYFRAME op descriptor"); } }

void FrameSGallery::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: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Mark N's function in the Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) Reimplemented from LayerSGallery. Definition at line 2555 of file sgframe.cpp. { OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_FRAME_NEWFRAME); if (pOpDesc != NULL) pOpDesc->Invoke(); else { ERROR3("Couldn't find OPTOKEN_FRAME_NEWFRAME op descriptor"); } }

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

FORCIBLY deletes the active layer/frame. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Mark N's function in the Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) 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: FrameSGallery::PrepareToDelete; ColourManager::HideColours Reimplemented from LayerSGallery. Definition at line 2528 of file sgframe.cpp. { OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_FRAME_DELETEFRAME); if (pOpDesc != NULL) pOpDesc->Invoke(); else { ERROR3("Couldn't find OPTOKEN_FRAME_DELETEFRAME op descriptor"); } return TRUE; }

BOOL FrameSGallery::DoFrameProperties (   )  [protected, virtual]

Opens the frame properties dlg. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 22/5/97 Parameters: -  [INPUTS] Returns: True if worked ok, False otherwise Definition at line 3205 of file sgframe.cpp. { OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_GIFANIMPROPERTYTABS); if (pOpDesc != NULL) { // Select the "Frame properties tab". GIFAnimationPropertyTabsDlg::SetPageToOpen(GIFAnimationPropertyTabs::FramePropertiesTabNumber); String_256 Str; OpState State = pOpDesc->GetOpsState(&Str); if (!State.Greyed) pOpDesc->Invoke(); else { GIFAnimationPropertyTabs * pTabHandler = GIFAnimationPropertyTabsDlg::GetGIFAnimationPropertiesTabs(); if (pTabHandler) { DialogTabOp* pDlg = pTabHandler->GetTabbedDlg(); if (pDlg != NULL) pDlg->Open(); } } } return TRUE; }

static BOOL FrameSGallery::DoHideNode (  Node *  pNodeToHide  )  [static]

void FrameSGallery::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: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Mark N's function in the Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) Parameters: Reason  = how the layer should be moved [INPUTS] Returns: - Note: Same as LayerSGallery version but uses FRAME_MOVE Reimplemented from LayerSGallery. Definition at line 2706 of file sgframe.cpp. { SGDisplayLayer* pLayerGalItem = GetSelectedLayerGalItem(); if (pLayerGalItem != NULL) { OpLayerGalParam Param(FRAME_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: ERROR3("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 { ERROR3("Couldn't find OPTOKEN_LAYERGALCHANGE op descriptor"); } } } }

BOOL FrameSGallery::DoPreviewAnimation (   )  [protected, virtual]

Previews the current animation. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 30/4/97 Parameters: -  [INPUTS] Returns: True if worked ok, False otherwise Definition at line 3108 of file sgframe.cpp. { // Check to see if the operation is available // No longer required as the button is hooked into the real op //String_256 ShadeReason; //OpState State; //State = OpGrabAllFrames::GetState(&ShadeReason, NULL); //if (State.Greyed) // return FALSE; // Normally we want to invoke the grab frame, but we will sneak in that // if the shift key is pressed then we will grab all frames. OpDescriptor* pOpDesc = NULL; // Is the shift key pressed? if (KeyPress::IsAdjustPressed()) pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_FRAME_GRABALLFRAMES); else pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_FRAME_GRABFRAME); if (pOpDesc != NULL) pOpDesc->Invoke(); else { ERROR3("Couldn't find OPTOKEN_FRAME_GRABFRAME/_GRABALLFRAMES op descriptor"); } return TRUE; }

BOOL FrameSGallery::DoRegenerateFrames (   )  [protected, virtual]

While previewing an animation, if the spread properties are changed we neeed to regenerate the frame layers. This function invokes the correct Op. Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 14/05/97 Parameters: -  [INPUTS] Returns: True if worked ok, False otherwise Definition at line 3179 of file sgframe.cpp. { OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_FRAME_GRABALLFRAMES); if (pOpDesc != NULL) pOpDesc->Invoke(); else { ERROR3("Couldn't find OPTOKEN_FRAME_GRABALLFRAMES op descriptor"); } return TRUE; }

BOOL FrameSGallery::DoRegenerateSingleFrame (   )  [protected, virtual]

While previewing an animation, if the frame layer properties are changed we neeed to regenerate the active frame. This function invokes the correct Op. Author: Ranbir_Rana (Xara Group Ltd) <camelotdev@xara.com> Date: 14/05/97 Parameters: -  [INPUTS] Returns: True if worked ok, False otherwise Definition at line 3151 of file sgframe.cpp. { OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_FRAME_GRABFRAME); GIFAnimationExportParam Param; if (pOpDesc != NULL) pOpDesc->Invoke(&Param); else { ERROR3("Couldn't find OPTOKEN_FRAME_GRABALLFRAMES op descriptor"); } return TRUE; }

BOOL FrameSGallery::DoSaveAnimation (   )  [protected, virtual]

Saves out the current animation to file. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 30/4/97 Parameters: -  [INPUTS] Returns: True if worked ok, False otherwise Definition at line 3082 of file sgframe.cpp. { // Not required at present /* OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_SAVEANIMATEDGIF); if (pOpDesc != NULL) pOpDesc->Invoke(); else { ERROR3("Couldn't find OPTOKEN_FRAME_COPYFRAME op descriptor"); } */ return TRUE; }

void FrameSGallery::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: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Jason's Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) 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 LayerSGallery. Definition at line 2773 of file sgframe.cpp. { 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_FRAME_DELETE), !ShadeIt); EnableGadget(_R(IDC_BTN_MULTILAYER), !ShadeIt); EnableGadget(_R(IDC_BTN_ALLVISIBLE), !ShadeIt); //EnableGadget(_R(IDC_GALLERY_NAME), !ShadeIt); EnableGadget(_R(IDC_GALLERY_COPY), !ShadeIt && !IsSelectedItemGuideLayer()); UpdateFrameRelatedButtons(); }

BOOL FrameSGallery::EnsureFrameLayerIntegrity (  Spread *  pSpread  )  [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.This function should be called before any frame related actions are carried out It will ensure that all the visible layers are frame layers. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 21/5/97 Returns: True if worked ok, False otherwise. Errors: - See also: - Definition at line 2199 of file sgframe.cpp. { ERROR2IF(pSpread == NULL,FALSE,"EnsureFrameLayerIntegrity null spread passed in"); // For the present moment just ensure that the active layer is a frame layer //Layer * pActiveLayer = pSpread->FindActiveLayer(); //if (pActiveLayer) // pActiveLayer->SetFrame(TRUE); /* #if _DEBUG // Find out whether the operation thinks it is required or not String_256 ShadeReason; OpState State; State = OpCombineLayersToFrameLayer::GetState(&ShadeReason, NULL); if (!State.Greyed) { // Try and find the operation we want to use OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_COMBINELAYERSTOFRAMELAYER); if (pOpDesc != NULL) { // We found it, so invoke it with the spread we were given OpParam Param; Param.Param1 = (INT32)pSpread; pOpDesc->Invoke(&Param); } else { ERROR3("Couldn't find OPTOKEN_COMBINELAYERSTOFRAMELAYER op descriptor"); } } */ /* #if 0 //_DEBUG // WARNING only do this in Webster builds as otherwise may be corrupting layers that are in the // undo buffer which could lead to immense problems. // This leads to problems in the undo e.g. draw object, import doc with layers and undo back to start // can mean no layers in doc. // In Camelot do nothing #ifdef WEBSTER // Ensure that all other non-guide and non-background layers are frame layers UINT32 NonFrameLayersFound = 0; Layer* pCurrentLayer = pSpread->FindFirstLayer(); Layer* pNonFrameLayer = NULL; while (pCurrentLayer != NULL) { if (!pCurrentLayer->IsBackground() && !pCurrentLayer->IsGuide() && !pCurrentLayer->IsPageBackground() && !pCurrentLayer->IsFrame()) { // Note that we have found a non-frame layer. pNonFrameLayer = pCurrentLayer; NonFrameLayersFound++; } pCurrentLayer = pCurrentLayer->FindNextLayer(); } if (NonFrameLayersFound > 0 && pNonFrameLayer != NULL) { TRACEUSER( "Neville", _T("++++++++++EnsureFrameLayerIntegrity found %d non-frame layers\n"),NonFrameLayersFound); // Right, we need to move all the nodes from the all non-frame layers and move them // to one of the non-frame layers and make this one a frame layer. The user should // therefore notice no difference in appearance of the document as they would have // been seeing one frame representing all the non-frame layers in the frame gallery. // First, mark the non-frame layer found in the above search as a frame layer as this // is the one that we are going to use as out destination. Then all other non-frame // searches will not find it. Also, mark it as edited. pNonFrameLayer->SetFrame(TRUE); pNonFrameLayer->SetEdited(TRUE); // Start a progress bar Progress CombiningProgress(_R(IDS_COMBINING_LAYERS)); CombiningProgress.Update(); BOOL UpdateSelection = FALSE; Layer* pLayer = pSpread->FindFirstLayer(); while (pLayer != NULL) { if (!pLayer->IsBackground() && !pLayer->IsGuide() && !pLayer->IsPageBackground() && !pLayer->IsFrame()) { // Move all the top level nodes to the new layer // We MUST include hidden nodes as these will be in undo records Node * pNode = pLayer->FindFirstChild(); while (pNode) { // Note the node to move Node* pNodeToMove = pNode; // and the next node in the tree pNode = pNode->FindNext(); // Now move hide the node (should hide it but we are not undoable) UpdateSelection = pNodeToMove->IsSelected(); //if (!DoHideNode(pNodeToMove, FALSE, NULL, FALSE)) // Find the insertion point, which will be after the last child but // BEFORE the insertion node, if present. Node * pInsertPoint = pNonFrameLayer->FindLastChild(TRUE); if (pInsertPoint) pNodeToMove->MoveNode(pInsertPoint, NEXT); else pNodeToMove->MoveNode(pNonFrameLayer, LASTCHILD); // Update the progress display to show we have done something CombiningProgress.Update(); } // Finally, go and hide that layer Layer * pLayerToHide = pLayer; // First, invalidate the bounding rect pLayerToHide->InvalidateBoundingRect(); // note the next layer pLayer = pLayer->FindNextLayer(); // and hide the layer itself. // Have to do this ourselves as we are not undoable pLayerToHide->CascadeDelete(); delete pLayerToHide; pLayerToHide = NULL; } else pLayer = pLayer->FindNextLayer(); // Update the progress display to show we have done something CombiningProgress.Update(); } // Make sure that our new frame layer is up to date pNonFrameLayer->InvalidateBoundingRect(); // If we have changed a selected node then update the selection if (UpdateSelection) { // Update the selection range Camelot.UpdateSelection(); } // We need to update the display as one or more layer items have changed status // So tell ourselves about the change. (We are static and so cannot do it directly!) BROADCAST_TO_ALL(SpreadMsg(pSpread, SpreadMsg::SpreadReason::LAYERCHANGES)); // Update the progress display to show we have done something CombiningProgress.Update(); } #endif // WEBSTER #endif // DEBUG */ // In Webster ensure that all layers are actually frames // In Camelot do nothing #ifdef WEBSTER // Ensure that all other non-guide and non-background layers are frame layers UINT32 NonFrameLayersFound = 0; Layer* pCurrentLayer = pSpread->FindFirstLayer(); while (pCurrentLayer != NULL) { if (pCurrentLayer->IsPseudoFrame() && !pCurrentLayer->IsFrame()) { pCurrentLayer->SetFrame(TRUE); NonFrameLayersFound++; } pCurrentLayer = pCurrentLayer->FindNextLayer(); } if (NonFrameLayersFound > 0) { TRACEUSER( "Neville", _T("++++++++++EnsureFrameLayerIntegrity found %d non-frame layers\n"),NonFrameLayersFound); // We need to update the display as one or more layer items have changed status // So tell ourselves about the change. (We are static and so cannot do it directly!) BROADCAST_TO_ALL(SpreadMsg(pSpread, SpreadMsg::SpreadReason::LAYERCHANGES)); } #endif // WEBSTER return TRUE; }

void FrameSGallery::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: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Mark N's function in the Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) Reimplemented from LayerSGallery. Definition at line 1735 of file sgframe.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 FrameSGallery::FixOtherLayers (  Spread *  pSpread  )  [static]

A layer flag such as overlay or solid has been changed and so we need to go and find the active layer and ensure that the other layers above and below this have the correct visibility and locked settings. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 17/4/97 Parameters: pSpread  = ptr to spread [INPUTS] -  [OUTPUTS] Returns: - Definition at line 1915 of file sgframe.cpp. { // Check that the class variable storing the current/selected spread is ok 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; while (pLayer != NULL && pActiveLayer == NULL) { if (pLayer->IsActive()) pActiveLayer = pLayer; // Found the active layer, so make a note of it pLayer = pLayer->FindNextLayer(); } if (pActiveLayer) FixOtherLayersFromActive(pActiveLayer); }

void FrameSGallery::FixOtherLayersFromActive (  Layer *  pActiveLayer, UndoableOperation *  pUndoOp = NULL )  [static]

A layer flag such as overlay or solid has been changed and so we need take the passed in current active layer and then ensure that the other layers above and below this have the correct visibility and locked settings. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 17/4/97 Parameters: pActiveLayer  = the current active layer [INPUTS] pUndoOp = if non null, the default, will do the change undoably Definition at line 1955 of file sgframe.cpp. { // This might be the new active layer that we are setting and so // it might not have been made active yet! if (pActiveLayer == NULL) // || !pActiveLayer->IsActive()) { ERROR3("FixOtherLayersFromActive has been given a bad active layer!"); return; } // Only need a spread pointer in the undoable case Spread * pSpread = NULL; if (pUndoOp != NULL) pSpread = pActiveLayer->FindParentSpread(); // Ensure that the new active layer is going to be visible and unlocked // Assume code is called from make active code which will force the redraw // and selection changes as required. So do it the simple way if (pUndoOp == NULL || pSpread == NULL) { LayerSGallery::DoChangeVisible(pActiveLayer,TRUE); LayerSGallery::DoChangeLocked(pActiveLayer,FALSE); } else { // Make visible and locked // Only change if required as otherwise we will get an unwanted undo step // if (!pActiveLayer->IsVisible()) { OpLayerGalParam Param(LAYER_VISIBLE, pSpread); Param.NewState = TRUE; Param.pLayer = pActiveLayer; LayerStateAction::Init(pUndoOp, pUndoOp->GetUndoActions(), Param); } // Only change if required as otherwise we will get an unwanted undo step // if (pActiveLayer->IsLocked()) { OpLayerGalParam LockedParam(LAYER_LOCKED, pSpread); LockedParam.NewState = FALSE; LockedParam.pLayer = pActiveLayer; LayerStateAction::Init(pUndoOp, pUndoOp->GetUndoActions(), LockedParam); } } // Go though the layers from the new active layer downwards and set // all previous layers non-visible and non-selected Layer* pLayer = pActiveLayer->FindPrevLayer(); BOOL FoundSolid = pActiveLayer->IsSolid(); BOOL OverlayPrevious = FALSE; // Solid flag overrides the overlay flag if (!FoundSolid) OverlayPrevious = pActiveLayer->IsOverlay(); while (pLayer != NULL) { if (pLayer->IsPseudoFrame()) { if (pLayer->IsSolid() && !FoundSolid) { // Stop any later solid frames having any effect FoundSolid = TRUE; // Stop any overlay having an effect OverlayPrevious = FALSE; if (pUndoOp == NULL || pSpread == NULL) { LayerSGallery::DoChangeVisible(pLayer,TRUE); LayerSGallery::DoChangeLocked(pLayer,TRUE); } else { // Only change if required as otherwise we will get an unwanted undo step // if (!pLayer->IsVisible()) { OpLayerGalParam Param(LAYER_VISIBLE, pSpread); Param.NewState = TRUE; Param.pLayer = pLayer; LayerStateAction::Init(pUndoOp, pUndoOp->GetUndoActions(), Param); } // Only change if required as otherwise we will get an unwanted undo step // if (!pLayer->IsLocked()) { OpLayerGalParam LockedParam(LAYER_LOCKED, pSpread); LockedParam.NewState = TRUE; LockedParam.pLayer = pLayer; LayerStateAction::Init(pUndoOp, pUndoOp->GetUndoActions(), LockedParam); } } } else { BOOL NewVisibleState = TRUE; if (OverlayPrevious) NewVisibleState = TRUE; else NewVisibleState = FALSE; if (pUndoOp == NULL || pSpread == NULL) { LayerSGallery::DoChangeVisible(pLayer,NewVisibleState); LayerSGallery::DoChangeLocked(pLayer,TRUE); } else { // Only change if required as otherwise we will get an unwanted undo step // if (pLayer->IsVisible() != NewVisibleState) { OpLayerGalParam Param(LAYER_VISIBLE, pSpread); Param.NewState = NewVisibleState; Param.pLayer = pLayer; LayerStateAction::Init(pUndoOp, pUndoOp->GetUndoActions(), Param); } // Only change if required as otherwise we will get an unwanted undo step // if (!pLayer->IsLocked()) { OpLayerGalParam LockedParam(LAYER_LOCKED, pSpread); LockedParam.NewState = TRUE; LockedParam.pLayer = pLayer; LayerStateAction::Init(pUndoOp, pUndoOp->GetUndoActions(), LockedParam); } } // If we are currently overlaying and this frame // is overlay as well then keep overlay on, otherwise // turn it off. if (OverlayPrevious && pLayer->IsOverlay()) OverlayPrevious = TRUE; else OverlayPrevious = FALSE; } // Overlay should only affect the previous frame //if (!pLayer->IsSolid() && pLayer->IsOverlay()) // OverlayPrevious = TRUE; //else // OverlayPrevious = FALSE; } pLayer = pLayer->FindPrevLayer(); } // Go though the layers from the new active layer upwards and set // all layers above to be non-visible and non-selected pLayer = pActiveLayer->FindNextLayer(); while (pLayer != NULL) { if (pLayer->IsPseudoFrame()) { if (pUndoOp == NULL || pSpread == NULL) { LayerSGallery::DoChangeVisible(pLayer,FALSE); LayerSGallery::DoChangeLocked(pLayer,TRUE); } else { // Only change if required as otherwise we will get an unwanted undo step // if (pLayer->IsVisible()) { OpLayerGalParam Param(LAYER_VISIBLE, pSpread); Param.NewState = FALSE; Param.pLayer = pLayer; LayerStateAction::Init(pUndoOp, pUndoOp->GetUndoActions(), Param); } // Only change if required as otherwise we will get an unwanted undo step // if (!pLayer->IsLocked()) { OpLayerGalParam LockedParam(LAYER_LOCKED, pSpread); LockedParam.NewState = TRUE; LockedParam.pLayer = pLayer; LayerStateAction::Init(pUndoOp, pUndoOp->GetUndoActions(), LockedParam); } } } pLayer = pLayer->FindNextLayer(); } }

OpState FrameSGallery::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: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Jason's Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) 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 LayerSGallery. Definition at line 2920 of file sgframe.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_Show // *CommandID == SGCmd_Properties || // *CommandID == SGCmd_Animation || // *CommandID == SGCmd_Browser || // *CommandID == SGCmd_FrameProps ) { 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(); else if (*CommandID == SGCmd_Show) // Can't hide Guide layers { State.Greyed = IsSelectedItemGuideLayer(); Layer * pLayer = pItem->GetDisplayedLayer(); if (pLayer) State.Ticked = !pLayer->IsHiddenFrame(); else State.Greyed = TRUE; } /* #ifndef STANDALONE else if (*CommandID == SGCmd_Properties) // Shade when dlg is open { //State.Greyed = (LayerPropertyTabs::GetTabbedDlg() != NULL); LayerPropertyTabs * pTabHandler = LayerPropertyTabsDlg::GetLayerPropertiesTabs(); if (pTabHandler) State.Greyed = (pTabHandler->GetTabbedDlg() != NULL); else State.Greyed = TRUE; } #endif */ } /* #if _DEBUG else if (*CommandID == SGCmd_Save) { // Just call the GetState function for the op directly return OpSaveAnimatedGIF::GetState(ShadeReason, NULL); } #endif */ else if (*CommandID == SGCmd_Preview) { // Just call the GetState function for the op directly return OpGrabAllFrames::GetState(ShadeReason, NULL); } else if (*CommandID == SGCmd_FrameProps || *CommandID == SGCmd_Properties) { // Call the GetState function for the frame properties op. return OpFrameProperties::GetState(ShadeReason, NULL); } else if (*CommandID == SGCmd_Delete) { // Call the GetState function for the frame delete op. return OpDeleteFrame::GetState(ShadeReason, NULL); } // Don't call the base class 'cos we don't want any other commands return(State); }

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

Reimplemented from LayerSGallery. Definition at line 313 of file sgframe.h. { return m_NewDocBorn; }

SGDisplayLayer * FrameSGallery::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: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Mark N's function in the Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) Returns: A ptr to the selected layer gallery item. NULL if there is no selectet item Reimplemented from LayerSGallery. Definition at line 2494 of file sgframe.cpp. { SGDisplayFrame* pDispLayer = NULL; if (CheckVarsAreValid()) { ERROR3IF(DisplayForeground == NULL,"Foreground group is NULL"); if (DisplayForeground == NULL) return NULL; // Look in the foreground group first pDispLayer = ((SGDisplayFrame *) DisplayForeground->FindNextSelectedItem(NULL)); ERROR3IF(pDispLayer == NULL,"Can't find the selected layer item in the layer gallery"); } return(pDispLayer); }

BOOL FrameSGallery::InitMenuCommands (  void   )  [virtual]

Initialises any menu commands that this gallery needs. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Jason's Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) 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 LayerSGallery. Definition at line 2808 of file sgframe.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_COPYFRAME)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Delete, _R(IDS_DELETEFRAME)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_New, _R(IDS_NEWFRAME)); // _R(IDS_SGMENU_NEW) // ok = ok && InitMenuCommand((StringBase *) &SGCmd_Animation, _R(IDS_SGMENU_ANIMATION)); // ok = ok && InitMenuCommand((StringBase *) &SGCmd_Save, _R(IDS_SGMENU_SAVE)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Preview, _R(IDS_GRABFRAME)); // _R(IDS_SGMENU_PREVIEW)); // ok = ok && InitMenuCommand((StringBase *) &SGCmd_Browser, _R(IDS_SGMENU_BROWSER)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Properties,_R(IDS_FRAMEPROPERTIES)); //_R(IDS_SGMENU_FRAMEPROPS)); // ok = ok && InitMenuCommand((StringBase *) &SGCmd_FrameProps,_R(IDS_SGMENU_FRAMEPROPS)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Show, _R(IDS_SGMENU_SHOWFRAME)); MenusInitialised = TRUE; } return(ok); }

BOOL FrameSGallery::IsFrameMode (  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 3342 of file sgframe.cpp. { ERROR3IF(pDoc == NULL,"pDoc == NULL"); // flag to determine the document mode. BOOL FrameMode = FALSE; // 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) FrameMode = TRUE; } // return the document mode. return FrameMode; }

void FrameSGallery::MakeActiveLayer (  Layer *  pNewActiveLayer, UndoableOperation *  pUndoOp = NULL )  [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: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Mark N's function in the Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) Parameters: pNewActiveLayer  = ptr to the layer you want to be active [INPUTS] pUndoOp = if non null, the default, will do the change undoably -  [OUTPUTS] Returns: - If the given new layer is already active, nothing happens Note: pNewActiveLayer must be in the currect doc Definition at line 1828 of file sgframe.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) { if (pUndoOp == NULL) FrameSGallery::SetActive(pDoc,pLayer,FALSE); else { // Make layer active undoably OpLayerGalParam Param(LAYER_ACTIVE, pSpread); Param.NewState = FALSE; Param.pLayer = pLayer; LayerStateAction::Init(pUndoOp, pUndoOp->GetUndoActions(), Param); } } pLayer = pLayer->FindNextLayer(); } } // Go though the layers from the new active layer downwards and set // all previous layers non-visible and non-selected FixOtherLayersFromActive(pNewActiveLayer, pUndoOp); // Make sure the new layer is active, redrawing if necessary /* if (!pNewActiveLayer->IsActive()) { if (pUndoOp == NULL) FrameSGallery::SetActive(pDoc,pNewActiveLayer,TRUE); else { // Make layer active undoably OpLayerGalParam Param(LAYER_ACTIVE, pSpread); Param.NewState = TRUE; Param.pLayer = pNewActiveLayer; LayerStateAction::Init(pUndoOp, pUndoOp->GetUndoActions(), Param); } } */ if (pUndoOp == NULL) { if (!pNewActiveLayer->IsActive()) FrameSGallery::SetActive(pDoc,pNewActiveLayer,TRUE); } else { // Make layer active undoably OpLayerGalParam Param(LAYER_ACTIVE, pSpread); Param.NewState = TRUE; Param.pLayer = pNewActiveLayer; LayerStateAction::Init(pUndoOp, pUndoOp->GetUndoActions(), Param); } #if defined(EXCLUDE_FROM_RALPH) //ERROR3("FrameSGallery::MakeActiveLayer supressed broadcast - bad !"); #else BROADCAST_TO_ALL(LayerMsg(pNewActiveLayer,LayerMsg::LayerReason::ACTIVE_LAYER_CHANGED)); #endif }

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

A standard message handler, really. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Jason's Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) 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 LayerSGallery. Definition at line 1335 of file sgframe.cpp. { if (IS_OUR_DIALOG_MSG(Message)) { DialogMsg* Msg = (DialogMsg*)Message; switch (Msg->DlgMsg) { case DIM_CREATE: SGInit::UpdateGalleryButton(OPTOKEN_DISPLAYFRAMEGALLERY, TRUE); break; case DIM_CANCEL: SGInit::UpdateGalleryButton(OPTOKEN_DISPLAYFRAMEGALLERY, FALSE); 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); switch(Msg->GadgetID) { case _R(IDC_BTN_MULTILAYER): state = GetLongGadgetValue(_R(IDC_BTN_MULTILAYER),0,1); DoChangeLayerState(NULL,FRAME_MULTILAYER,state); break; case _R(IDC_BTN_ALLVISIBLE): state = GetLongGadgetValue(_R(IDC_BTN_ALLVISIBLE),0,1); DoChangeLayerState(NULL,FRAME_ALLVISIBLE,state); break; case _R(IDC_GALLERY_UPONE): DoMoveLayer(MOVELAYER_UPONE); break; case _R(IDC_GALLERY_DOWNONE): DoMoveLayer(MOVELAYER_DOWNONE); break; case _R(IDC_GALLERY_NEW_NODLG): DoCreateNewItem(); break; case _R(IDC_GALLERY_COPY_NODLG): DoCopyLayer(); break; case _R(IDC_GALLERY_HELP): // Show help page HelpUserTopic(_R(IDS_HELPPATH_Gallery_Frame)); break; /* case _R(IDC_GALLERY_PROPERTIES): // Handled by optoken DoFrameProperties(); break; */ /* case _R(IDC_BMPGAL_SAVE): // Handled by optoken DoSaveAnimation(); break; */ /* case _R(IDC_BMPGAL_PREVIEW): // Handled by optoken DoPreviewAnimation(); break; */ /* case _R(IDC_FRAME_ANIMATION): // Handled by optoken // Implement **** break; */ } break; } } else if (MESSAGE_IS_A(Message, OpMsg)) { switch (((OpMsg*)Message)->MsgType) { case OpMsg::AFTER_UNDO: case OpMsg::AFTER_REDO: EnsureSelSpreadSelectionIntegrity(); 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("frame 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("frame SpreadMsg::LAYERCHANGES CreateNewSubtree\n")); CreateNewSubtree(pDoc); ForceRedrawOfList(); } } } } else { if (pSpreadMsg->pNewSpread->FindFirstLayer() != NULL) { pSpread = pSpreadMsg->pNewSpread; EnsureActiveLayerIntegrity(); } } break; } } else if (MESSAGE_IS_A(Message, DocChangingMsg)) { DocChangingMsg *Msg = (DocChangingMsg *) Message; switch (Msg->State) { case DocChangingMsg::DocState::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::DocState::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("frame DocChangingMsg 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()) { // The document has changed, do we detect any non-frame layers? BOOL FrameMode = FALSE; // Get a ptr to the document. Document* pDoc = Msg->pNewDoc; // Ensure a valid ptr. if(pDoc) { // Determine the document mode. FrameMode = IsFrameMode(pDoc); // If we are no longer in Frame mode and the frame gallery is open, // then close the frame gallery and open the layer gallery. if( !FrameMode && IsVisible() ) { // Close the frame gallery. if(CloseFrameGallery()) { // Open the the layer gallery. OpenLayerGallery(); } } } } // 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::DocState::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 the frame gallery is open. if( IsVisible() ) { // Set the flag to true. // This is set to false in BORNANDSTABLE. SetNewDocBorn(TRUE); } break; } case DocChangingMsg::DocState::BORNANDSTABLE: { // The document has changed, do we detect any non-frame layers? BOOL FrameMode = FALSE; BOOL GalleryClosed = FALSE; // Get a ptr to the document. Document* pChangingDoc = Msg->pChangingDoc; // Ensure a valid ptr. if(pChangingDoc) { // Determine the document mode. FrameMode = IsFrameMode(pChangingDoc); // If we are no longer in Frame mode then // close the frame gallery and open the layer gallery. if( !FrameMode && IsVisible() ) { // Close the frame gallery. if(CloseFrameGallery()) { // Open the Layer gallery. OpenLayerGallery(); // Now we have processed this message, it is safe to process SELCHANGED messages. SetNewDocBorn(FALSE); } } } break; } case DocChangingMsg::DocState::KILLED: case DocChangingMsg::DocState::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::DocViewState::SELABOUTTOCHANGE: OldGuideLayerState = GetGuideLayerState(Msg->pNewDocView); break; case DocViewMsg::DocViewState::SELCHANGED: { if (IsVisible()) { NewGuideLayerState = GetGuideLayerState(Msg->pNewDocView); if (OldGuideLayerState != NewGuideLayerState) { TRACEUSER( "Neville", _T("frame DocViewMsg::DocViewState::SELCHANGED CreateNewSubtree\n")); CreateNewSubtree(Msg->pNewDocView->GetDoc()); ForceRedrawOfList(); } } } break; } } else if (MESSAGE_IS_A(Message, LayerMsg)) { LayerMsg *pMsg = (LayerMsg *) Message; switch ( pMsg->Reason ) { // The active layer has changed. case LayerMsg::LayerReason::ACTIVE_LAYER_CHANGED: { EnableGadget(_R(IDC_GALLERY_COPY),pMsg->pNewLayer != NULL && !pMsg->pNewLayer->IsGuide()); UpdateFrameRelatedButtons(); } break; // The active layer has been changed externally to the gallery. case LayerMsg::LayerReason::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 && IsVisible()) pDisplayItem = GetSelectedLayerGalItem(); if (pDisplayItem != NULL) { if (pMsg->pNewLayer != NULL && 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; // The specified layer has been changed externally to the gallery. // So redraw the name. case LayerMsg::LayerReason::REDRAW_LAYER: { TRACEUSER( "Neville", _T("frame LayerMsg::LayerReason::REDRAW_LAYER\n")); Layer * pWantedLayer = pMsg->pNewLayer; if (pWantedLayer != NULL && DisplayForeground != NULL && IsVisible()) { // 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() == pWantedLayer) pWantedDispLayer = pDispLayer; pDispLayer = ((SGDisplayLayer *)pDispLayer->GetNext()); } // If we found it then force a redraw if (pWantedDispLayer) pWantedDispLayer->ForceRedrawOfMyself(); } } break; } } return(SuperGallery::Message(Message)); }

BOOL FrameSGallery::OpenLayerGallery (   )  [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 3313 of file sgframe.cpp. { // Find the OP. for the Layer gallery. OpDescriptor* OpDesc; OpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_DISPLAYLAYERGALLERY); // 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 FrameSGallery::PostCreate (  void   )  [protected, virtual]

The FrameSGallery 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: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Jason's Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) Returns: TRUE if the Gallery initialised successfully FALSE if it should not be opened due to a failure to initialise Reimplemented from LayerSGallery. Definition at line 1228 of file sgframe.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()); UpdateFrameRelatedButtons(); return(TRUE); }

void FrameSGallery::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: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> (Based on Mark N's function in the Layer gallery code) Date: 16/4/97 (Based on Jason's Layer gallery code) 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 from LayerSGallery. Definition at line 1772 of file sgframe.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 FrameSGallery::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 FrameSGallery::SetNewDocBorn (  BOOL  Val  )  [inline, protected]

Reimplemented from LayerSGallery. Definition at line 312 of file sgframe.h. { m_NewDocBorn = Val; }

BOOL FrameSGallery::UpdateFrameRelatedButtons (   )  [protected]

Ensures that they buttons on the gallery up to date in their greying/ungreying status. Author: Neville_Humphrys (Xara Group Ltd) <camelotdev@xara.com> Date: 29/5/97 Parameters: -  [INPUTS] Returns: True if worked ok, False otherwise Definition at line 3245 of file sgframe.cpp. { // This is no longer required for the present as we have hooked the buttons // into the real ops that we have. // String_256 ShadeReason; // OpState State; // State = OpGrabAllFrames::GetState(&ShadeReason, NULL); // EnableGadget(_R(IDC_BMPGAL_PREVIEW), !State.Greyed); // State = OpFrameProperties::GetState(&ShadeReason, NULL); // EnableGadget(_R(IDC_GALLERY_PROPERTIES), !State.Greyed); return TRUE; }

---

Member Data Documentation

BOOL FrameSGallery::m_NewDocBorn [protected]

Reimplemented from LayerSGallery. Definition at line 325 of file sgframe.h.

---

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

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

---