LineGallery Class Reference

The Line SuperGallery class 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. More...

#include <sgline.h>

Inheritance diagram for LineGallery:

List of all members.

Public Member Functions
	LineGallery ()
	LineGallery default constructor. Sets a global instance pointer to this object.
virtual	~LineGallery ()
	Destroys a line gallery, resetting the global instance pointer to NULL.
virtual MsgResult	Message (Msg *pMessage)
	A standard message handler, really. 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].
BOOL	MakeSureGroupsHaveBeenCreated ()
BOOL	DeleteBrushItem (BrushHandle Handle)
	Deletes the brush with the given handle.
CBrushGadget *	GetBrushGadget ()
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.
void	UpdateBrushItem (BrushHandle Handle)
	Searches for a brush item with the same handle as Handle, and asks it to update itself.
MILLIPOINT	SetPreviousLineWidth ()
	queries AttributeManager to get the current default,sets it as the member variable and returns it
MILLIPOINT	GetPreviousLineWidth ()
	as above
Static Public Member Functions
static BOOL	Init ()
	Called when the program starts, loading .INI file settings.
static LineGallery *	GetInstance ()
	Public access function to the line gallery.
static BOOL	IsActive ()
	Used by the message-handlers of gadgets within the line gallery to determine if they should update themselves or not.
static void	AddNewStrokeItem (StrokeTypeAttrValue *pNewStroke)
	Finds the line gallery, and adds the given stroke type attribute to the end of the stroke type display.
static void	AddNewBrushItem (BrushAttrValue *pNewBrush)
	Goes through the line gallery to find out which group to add the new brush to. Basically if the brushes fileID == BRUSHFILE_NONE then it belongs in the default folder, otherwise we find the folder name from our array.
Private Member Functions
virtual BOOL	PreCreate ()
	The LineGallery PreCreate handler. This overrides the base class PreCreate function. It is called at the very beginning of the SuperGallery::Create method, before the window has been created.
virtual BOOL	PostCreate ()
	Called after the LineGallery is created. Forces an update of the "current attribute" status of all items.
virtual BOOL	ApplyAction (SGActionType Action)
	Applies certain conventional gallery actions (usually associated with gallery buttons, for new, edit, delete, etc).
virtual void	SelectionHasChanged ()
	Called by the base-class SuperGallery whenever the user clicks on an item. This version overrides the default bahaviour so that selecting more than one item does NOT grey the "Apply" button.
virtual BOOL	OnCommonAttrsChangedMsg ()
	Responds to the selection state changing by updating the "current attribute" status of the gallery's items. Responds to the the common attributes changing.
virtual BOOL	OnApplyButton (BOOL fIsAdjust)
	Called by the line gallery when the user clicks the "Apply" button. Iterates over each group within the gallery trying to apply any selected attributes within the group to the current selection.
void	SetStatusText ()
	Works out what the status text should be from which items are selected in the gallery, and updates it on-screen.
virtual RenderRegion *	CreateRenderRegion (DocRect *pSize, ReDrawInfoType *pInfo)
	An overridable veneer to the DialogOp CreateOSRenderRegion method. This can be overriden to use a different type of renderregion for all of your rendering.
virtual void	DestroyRenderRegion (RenderRegion *pRegion)
	Destroys the given render-region (in this case a GDraw version).
BOOL	CreateDashGroup ()
	Creates a new "dash pattern" Group with all its associated items.
BOOL	CreateWidthGroup ()
	Creates a new "line width" Group with its associated items.
BOOL	CreateArrowGroup ()
	Creates a new "arrowhead/tail" Group with its associated items.
BOOL	CreateCapGroup ()
	Creates a new "line cap" Group with its associated items.
BOOL	CreateJoinTypeGroup ()
	Creates a new "join type" Group with its associated items.
BOOL	CreateVarWidthGroup ()
	Creates a new "variable width" Group with its associated items.
BOOL	CreateStrokeTypeGroup ()
	Creates a new "Stroke type" Group with its associated items.
LineAttrGroup *	CreateBrushAttrGroup (String_256 GroupName)
BOOL	CreateBrushGroups ()
	Creates groups to hold brushes in the line gallery. Basically we create folders for each of the default files that are loaded during start-up, plus one extra folder where all subsequent brushes will be put. Note that PrepareBrushFolders must have been called at some point prior to this.
LineAttrGroup *	CreateGroup (const String_256 &strTitle, BOOL fOpen)
	Creates a new group (heading) within the line-attributes super-gallery.
BOOL	CreateItem (LineAttrGroup *pGroup, LineAttrItem *pItem)
Static Private Member Functions
static BOOL	PrepareBrushFolders ()
	Prepares tp create folders in which to put brushes that are loaded in as part of the load default brushes process. Basically scans for .xar files in the /Templates/Brushes/ folders and stores each filename found. These filenames are subsequently used to create folders in CreateBrushGroups.
Private Attributes
MILLIPOINT	m_PreviousLineWidth
CBrushGadget	BrushGadget
Static Private Attributes
static LineGallery *	m_pTheGallery = NULL
static double	m_anArrowScales [4] = { 3.0, 8.0, 13.0, 18.0 }
static String_256 *	m_pFileNameArray = NULL
static UINT32	m_NumDefaultFiles = 0

---

Detailed Description

The Line SuperGallery class 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.

Author:

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

Date:

15/2/95 (Based on the Colour SGallery code)

See also:

SuperGallery; SGDisplayLine

Definition at line 271 of file sgline.h.

---

Constructor & Destructor Documentation

LineGallery::LineGallery (   )

LineGallery default constructor. Sets a global instance pointer to this object. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 15/2/95 (base generated in sgbase.cpp) Definition at line 1168 of file sgline.cpp. { // Remember a pointer to the global instance of this gallery. ERROR3IF(m_pTheGallery != NULL, "Gallery already exists in LineGallery::LineGallery?"); m_pTheGallery = this; DlgResID=_R(IDD_LINESGALLERY); // set to the normal default m_PreviousLineWidth = 500; }

LineGallery::~LineGallery (   )  [virtual]

Destroys a line gallery, resetting the global instance pointer to NULL. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 17/4/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1195 of file sgline.cpp. { // Make sure nothing is seriously screwed-up. ERROR3IF(m_pTheGallery == NULL, "No gallery in LineGallery::~LineGallery?"); m_pTheGallery = NULL; // delete the string array if (m_pFileNameArray != NULL) { for (UINT32 i = 0; i < m_NumDefaultFiles; i++) m_pFileNameArray[i].Empty(); // don't forget that we allocated it with malloc.. free((void*)m_pFileNameArray); m_pFileNameArray = NULL; } }

---

Member Function Documentation

void LineGallery::AddNewBrushItem (  BrushAttrValue *  pNewBrush  )  [static]

Goes through the line gallery to find out which group to add the new brush to. Basically if the brushes fileID == BRUSHFILE_NONE then it belongs in the default folder, otherwise we find the folder name from our array. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 9/1/2000 Definition at line 2355 of file sgline.cpp. { if (pNewBrush == NULL) { ERROR3("Illegal NULL param"); return; } // find the string for title of the folder from the definition String_256 GroupString(_R(IDS_BRUSHGROUP_DEFAULT)); // initialise to default string BrushDefinition* pDef = pNewBrush->GetBrushDefinition(); if (pDef == NULL) { ERROR3("No brush definition in LineGallery::AddNewBrushItem"); return; } UINT32 FileID = pDef->GetBrushFileID(); if (FileID != BRUSHFILE_NONE && FileID <= m_NumDefaultFiles) { if (m_pFileNameArray != NULL) GroupString = m_pFileNameArray[FileID]; } // now search through the line gallery to find the group with that title LineGallery *pGallery = (LineGallery *) LineGallery::GetInstance(); if (pGallery == NULL) return; // This will create the groups if they're not there yet pGallery->MakeSureGroupsHaveBeenCreated(); SGDisplayRoot *pRoot = pGallery->GetDisplayTree(); if (pRoot == NULL) return; LineAttrGroup *pGroup = (LineAttrGroup *) pRoot->GetChild(); if (pGroup == NULL) return; LineAttrGroup* pCopyGroup = pGroup; // loop through until we find our group. String_256 NameString; while (pCopyGroup != NULL) { NameString = (String_256)(pCopyGroup->GetTitle()); if (NameString.IsIdentical(GroupString)) { pGroup = pCopyGroup; break; } pCopyGroup = (LineAttrGroup*)pCopyGroup->GetNext(); } // Find the stroke's name, if it has one String_64 Name = TEXT(" "); String_32* pName = pDef->GetLineName(); if (pName != NULL) Name = *pName; BrushAttrItem* pBrushAttrItem = new BrushAttrItem(pNewBrush, Name); if (pBrushAttrItem == NULL) return; /* #ifdef _DEBUG pBrushAttrItem->CheckMemory(TRUE); #endif */ pGallery->CreateItem(pGroup, pBrushAttrItem); // we must invalidate so that brushes are scaled correctly the first // time they are drawn pGallery->InvalidateCachedFormat(); pGallery->ReformatAndRedrawIfNecessary(); }

void LineGallery::AddNewStrokeItem (  StrokeTypeAttrValue *  pNewStroke  )  [static]

Finds the line gallery, and adds the given stroke type attribute to the end of the stroke type display. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 3/3/97 Definition at line 2292 of file sgline.cpp. { // Removed from non-stroking builds 2/10/97 #ifdef VECTOR_STROKING ERROR3IF(pNewStroke == NULL, "Illegal NULL param"); LineGallery *pGallery = (LineGallery *) LineGallery::GetInstance(); if (pGallery == NULL) return; // This will create the groups if they're not there yet pGallery->MakeSureGroupsHaveBeenCreated(); SGDisplayRoot *pRoot = pGallery->GetDisplayTree(); if (pRoot == NULL) return; LineAttrGroup *pGroup = (LineAttrGroup *) pRoot->GetChild(); if (pGroup == NULL) return; #if _DEBUG SGDisplayItem *pItem = (SGDisplayItem *) pGroup->GetChild(); ERROR3IF(pItem == NULL || !pItem->IsKindOf(CC_RUNTIME_CLASS(StrokeTypeItem)), "LineGallery::AddNewStrokeItem - I seem to be adding to the wrong group!"); #endif // Find the stroke's name, if it has one String_64 Name(TEXT("Custom brush")); PathProcessorStroke *pProcessor = pNewStroke->GetPathProcessor(); if (pProcessor != NULL && pProcessor->IsKindOf(CC_RUNTIME_CLASS(PathProcessorStrokeVector))) { StrokeHandle Handle = ((PathProcessorStrokeVector *)pProcessor)->GetStrokeDefinition(); StrokeDefinition *pStroke = StrokeComponent::FindStroke(Handle); if (pStroke != NULL) Name = *pStroke->GetStrokeName(); } StrokeTypeItem * pStrokeTypeItem = new StrokeTypeItem(pNewStroke, Name); if (pStrokeTypeItem == NULL) return; pGallery->CreateItem(pGroup, pStrokeTypeItem); pGallery->ReformatAndRedrawIfNecessary(); #endif // VECTOR_STROKING }

BOOL LineGallery::ApplyAction (  SGActionType  Action  )  [private, virtual]

Applies certain conventional gallery actions (usually associated with gallery buttons, for new, edit, delete, etc). Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 15/2/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 (NOTE that this is not necessarily an error, but may simply be that we don't support the given action. e.g. if we don't handle APPLYADJUST, we'll be called again with a normal APPLY call) See also: SGActionType Reimplemented from SuperGallery. Definition at line 1864 of file sgline.cpp. { // No display tree? Better forget about it then! if (DisplayTree == NULL) return FALSE; // Now, process the action TO DO! - see Colour gallery for examples switch (Action) { case SGACTION_APPLY: return OnApplyButton(FALSE); case SGACTION_APPLYADJUST: return OnApplyButton(TRUE); case SGACTION_SETLINEPROPERTIES: return TRUE; case SGACTION_SETOPTIONS: case SGACTION_CREATE: case SGACTION_REDEFINE: case SGACTION_EDIT: case SGACTION_DELETE: case SGACTION_DISPLAYMODECHANGED: TRACEUSER( "JustinF", _T("Unimplemented feature executed in Line gallery\n")); // Drop through to default handler (return FALSE) default: ERROR3("Unexpected action in LineGallery::ApplyAction"); return FALSE; } // Successful processing. return TRUE; }

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

To build a menu of commands to be popped up over the gallery. Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> Date: 07/03/97 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 Reimplemented from SuperGallery. Definition at line 2492 of file sgline.cpp. { BOOL ok = FALSE; SGDisplayNode *pItem = DisplayTree->FindNextSelectedItem(NULL); // Only pop the properties menu up for Custom Brushes if(pItem != NULL && pItem->IsKindOf(CC_RUNTIME_CLASS(StrokeTypeItem))) { StrokeTypeAttrValue *pAttrType = ((StrokeTypeItem *)pItem)->GetStrokeTypeAttrValue(); if(pAttrType != NULL) { PathProcessor *pPP = pAttrType->GetPathProcessor(); if(pPP != NULL && pPP->AllowsPropertiesDialog()) { ok = AddCommand(TheMenu, (StringBase *) &SGCmd_Properties); } } } // we want to launch our new edit dialog for the new style brushes, its all new baby if (pItem != NULL && pItem->IsKindOf(CC_RUNTIME_CLASS(BrushAttrItem))) { // make sure its not the default 'no brush' BrushDefinition* pDef = ((BrushAttrItem*)pItem)->GetBrushDefinition(); if ( pDef != NULL) { ok = AddCommand(TheMenu, (StringBase *) &SGCmd_RenameBrush); if (ok) ok = AddCommand(TheMenu, (StringBase *) &SGCmd_ExportBrush); // check to see that this is not a default brush before adding delete option UINT32 FileID = pDef->GetBrushFileID(); if (FileID == BRUSHFILE_NONE && ok) ok = AddCommand(TheMenu, (StringBase *) &SGCmd_Delete); } } return(ok); }

BOOL LineGallery::CreateArrowGroup (   )  [private]

Creates a new "arrowhead/tail" Group with its associated items. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 28/3/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if successful. Errors: - See also: LineGallery::CreateGroup; LineGallery::CreateItem; LineStartArrowItem::LineStartArrowItem Definition at line 1429 of file sgline.cpp. { // Create the group. LineAttrGroup* pGroup = CreateGroup(String_256(_R(IDS_LINEGAL_CREATEARROW)), TRUE); if (pGroup != NULL) pGroup->Flags.Folded = TRUE; // Create each item. First the "no-arrowhead" item. if (!CreateItem(pGroup, new LineNoEndArrowItem(String_64(_R(IDS_LINEGAL_NOHEAD)))) || !CreateItem(pGroup, new LineNoStartArrowItem(String_64(_R(IDS_LINEGAL_NOTAIL))))) { return FALSE; } // Now do the real ones. INT32 nTypes = (INT32) ArrowRec::GetNumStockArrows(); for (INT32 i = (INT32) SA_STRAIGHTARROW; i < nTypes; i++) { for (INT32 j = 0; j < 4; j++) { // Get the text description for this kind of arrowhead. String_256 str = ArrowRec::GetStockArrowName((StockArrow) i); LineArrowItem* pItem = new LineArrowItem((StockArrow) i, m_anArrowScales[j], str); if (!CreateItem(pGroup, pItem)) return FALSE; } } // Success! return TRUE; }

LineAttrGroup* LineGallery::CreateBrushAttrGroup (  String_256  GroupName  )  [private]

BOOL LineGallery::CreateBrushGroups (   )  [private]

Creates groups to hold brushes in the line gallery. Basically we create folders for each of the default files that are loaded during start-up, plus one extra folder where all subsequent brushes will be put. Note that PrepareBrushFolders must have been called at some point prior to this. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 9/1/2000 Returns: TRUE if successful. See also: LineGallery::CreateGroup; LineGallery::CreateItem Definition at line 1800 of file sgline.cpp. { // Create the default folder, which will contain the default stroke LineAttrGroup *pGroup = CreateGroup(String_256(_R(IDS_BRUSHGROUP_DEFAULT)), TRUE); if (pGroup == NULL) return(FALSE); // Create a default 'no brush' brush BrushAttrValue *pAttr; // --- Simple old-style line ----------------------------------------------- pAttr = new BrushAttrValue; if (pAttr == NULL || !CreateItem(pGroup, new BrushAttrItem(pAttr, String_64(_R(IDS_BRUSHITEM_DEFAULT))))) return(FALSE); //For this release, force the brush group to be invisible and non-selectable // pGroup->Flags.Folded = true; // pGroup->Flags.Invisible = true; // pGroup->Flags.CanSelect = false; // make groups for all the filenames we stored if (m_pFileNameArray != NULL) { UINT32 Counter = 0; String_256 GroupName; pGroup = NULL; while (Counter < m_NumDefaultFiles) { GroupName = m_pFileNameArray[Counter++]; // create the group pGroup = CreateGroup(GroupName, TRUE); if (pGroup == NULL) return(FALSE); //For this release, force the brush group to be invisible and non-selectable // pGroup->Flags.Folded = true; // pGroup->Flags.Invisible = true; // pGroup->Flags.CanSelect = false; } } return TRUE; }

BOOL LineGallery::CreateCapGroup (   )  [private]

Creates a new "line cap" Group with its associated items. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 28/3/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if successful. Errors: - See also: LineGallery::CreateGroup; LineGallery::CreateItem; LineCapItem::LineCapItem Definition at line 1476 of file sgline.cpp. { // Create the group. LineAttrGroup* pGroup = CreateGroup(String_256(_R(IDS_LINEGAL_CREATECAP)), TRUE); if (pGroup != NULL) pGroup->Flags.Folded = TRUE; // Create each item. return CreateItem(pGroup, new LineCapItem(LineCapButt, String_64(_R(IDS_LINEGAL_BUTT)))) && CreateItem(pGroup, new LineCapItem(LineCapRound, String_64(_R(IDS_LINEGAL_ROUND)))) && CreateItem(pGroup, new LineCapItem(LineCapButt, String_64(_R(IDS_LINEGAL_SQUARE)))); }

BOOL LineGallery::CreateDashGroup (   )  [private]

Creates a new "dash pattern" Group with all its associated items. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 28/3/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if successful. Errors: - See also: LineGallery::CreateGroup; LineGallery::CreateItem; LineDashItem::LineDashItem Definition at line 1393 of file sgline.cpp. { // Create the group (heading). LineAttrGroup* pGroup = CreateGroup(String_256(_R(IDS_LINEGAL_CREATEDASH)), TRUE); if (pGroup != NULL) pGroup->Flags.Folded = TRUE; // Create each item. INT32 n = (INT32) DashRec::GetNumStockDashes(); for (INT32 i = (INT32) SD_SOLID; i < n; i++) { // If we fail then quit now. String_256 str = DashRec::GetStockDashName((StockDash) i); if (!CreateItem(pGroup, new LineDashItem((StockDash) i, str))) return FALSE; } // Success! return TRUE; }

LineAttrGroup * LineGallery::CreateGroup (  const String_256 &  strTitle, BOOL  fOpen )  [private]

Creates a new group (heading) within the line-attributes super-gallery. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 28/3/95 Parameters: strTitle  the title (heading) of the group to create [INPUTS] fOpen whether the group "folder" is initially "open" -  [OUTPUTS] Returns: A pointer to the newly created group, or NULL if it can't be created. Errors: - See also: LineAttrGroup::LineAttrGroup Definition at line 1291 of file sgline.cpp. { // Make sure the tree has been initialised. ERROR3IF(DisplayTree == NULL, "Root node not allocated in LineGallery::CreateGroup"); // Try to create and set a new group. LineAttrGroup* pGroup = new LineAttrGroup(strTitle, this); if (pGroup != NULL) { // NB. note that the "folded" flag is inverted. // pGroup->Flags.Folded = (fOpen) ? FALSE : TRUE; pGroup->Flags.Folded = true; pGroup->Flags.Invisible = false; pGroup->Flags.CanSelect = true; DisplayTree->AddItem(pGroup); } // Return a pointer to the new group. return pGroup; }

BOOL LineGallery::CreateItem (  LineAttrGroup *  pGroup, LineAttrItem *  pItem )  [private]

Definition at line 1329 of file sgline.cpp. { // If we were passed a genuine item insert it into the group. if (pGroup != NULL && pItem != NULL) { // Success. pGroup->AddItem(pItem); return TRUE; } // You failed to allocate your item or group! return FALSE; }

BOOL LineGallery::CreateJoinTypeGroup (   )  [private]

Creates a new "join type" Group with its associated items. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 28/3/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if successful. Errors: - See also: LineGallery::CreateGroup; LineGallery::CreateItem; LineJoinTypeItem::LineJoinTypeItem Definition at line 1505 of file sgline.cpp. { // Create the group. LineAttrGroup* pGroup = CreateGroup(String_256(_R(IDS_LINEGAL_CREATEJOIN)), TRUE); if (pGroup != NULL) pGroup->Flags.Folded = TRUE; // Create each item. return CreateItem(pGroup, new LineJoinTypeItem(MitreJoin, String_64(_R(IDS_LINEGAL_MITRE)))) && CreateItem(pGroup, new LineJoinTypeItem(RoundJoin, String_64(_R(IDS_LINEGAL_ROUND)))) && CreateItem(pGroup, new LineJoinTypeItem(BevelledJoin, String_64(_R(IDS_LINEGAL_BEVEL)))); }

RenderRegion * LineGallery::CreateRenderRegion (  DocRect *  pSize, ReDrawInfoType *  pInfo )  [private, virtual]

An overridable veneer to the DialogOp CreateOSRenderRegion method. This can be overriden to use a different type of renderregion for all of your rendering. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 29/3/95 If you override this, you MUST also override DestroyRenderRegion! See also: SuperGallery::DestroyRenderRegion Reimplemented from SuperGallery. Definition at line 2085 of file sgline.cpp. { // Try to create a GDraw render-region. RenderRegion* pRegion = CreateGRenderRegion(pSize, pInfo); if (pRegion != NULL) { // Try to create a display quality attribute. QualityAttribute* pAttr = new QualityAttribute; if (pAttr != NULL) { // If all that worked then turn on anti-aliasing when drawing in the gallery. pAttr->QualityValue = Quality::QualityMax; pRegion->SetQuality(pAttr, TRUE); } } return pRegion; }

BOOL LineGallery::CreateStrokeTypeGroup (   )  [private]

Creates a new "Stroke type" Group with its associated items. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 3/3/97 Returns: TRUE if successful. See also: LineGallery::CreateGroup; LineGallery::CreateItem Definition at line 1733 of file sgline.cpp. { // Removed from non-stroking builds 2/10/97 #ifdef VECTOR_STROKING // Create the group. LineAttrGroup *pGroup = CreateGroup(String_256(_R(IDS_LINEGAL_GROUP_STROKETYPE)), TRUE); if (pGroup == NULL) return(FALSE); // Create each item. StrokeTypeAttrValue *pAttr; // --- Simple old-style line ----------------------------------------------- pAttr = new StrokeTypeAttrValue(NULL); if (pAttr == NULL || !CreateItem(pGroup, new StrokeTypeItem(pAttr, String_64(_R(IDS_LINEGAL_STROKETYPE_LINE))))) return(FALSE); // --- Simple flat-filled stroke -------------------------------------------- pAttr = new StrokeTypeAttrValue(new PathProcessorStroke); if (pAttr == NULL || !CreateItem(pGroup, new StrokeTypeItem(pAttr, String_64(_R(IDS_LINEGAL_STROKETYPE_STROKE))))) return(FALSE); /* // --- Airbrush (L) --------------------------------------------------------- PathProcessorStrokeAirbrush *pAirbrush = new PathProcessorStrokeAirbrush; if (pAirbrush == NULL) return(FALSE); pAirbrush->SetIntensityFunction(new ValueFunctionRampL); pAttr = new StrokeTypeAttrValue(pAirbrush); if (pAttr == NULL || !CreateItem(pGroup, new StrokeTypeItem(pAttr, String_64(TEXT("Thin airbrush"))))) return(FALSE); // --- Airbrush (S) --------------------------------------------------------- pAirbrush = new PathProcessorStrokeAirbrush; if (pAirbrush == NULL) return(FALSE); pAirbrush->SetIntensityFunction(new ValueFunctionRampS); pAttr = new StrokeTypeAttrValue(pAirbrush); if (pAttr == NULL || !CreateItem(pGroup, new StrokeTypeItem(pAttr, String_64(TEXT("Thick airbrush"))))) return(FALSE); */ #endif // VECTOR_STROKING return(TRUE); }

BOOL LineGallery::CreateVarWidthGroup (   )  [private]

Creates a new "variable width" Group with its associated items. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 3/3/97 Returns: TRUE if successful. See also: LineGallery::CreateGroup; LineGallery::CreateItem Definition at line 1535 of file sgline.cpp. { // Removed from non-stroking builds 2/10/97 #ifdef VECTOR_STROKING // Create the group. LineAttrGroup *pGroup = CreateGroup(String_256(_R(IDS_LINEGAL_GROUP_VARWIDTH)), TRUE); if (pGroup == NULL) return(FALSE); // --- Simple constant-width line ------------------------------------------ VariableWidthAttrValue *pAttr; pAttr = new VariableWidthAttrValue(NULL); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_CONSTANT))))) return(FALSE); // --- SmoothStroke SS_Fallout ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Fallout); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_FALLOUT))))) return(FALSE); // --- SmoothStroke SS_Iron ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Iron); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_IRON))))) return(FALSE); // --- Ellipse ------------------------------------------------------------- pAttr = new VariableWidthAttrValue(new ValueFunctionEllipse); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_ELLIPSE))))) return(FALSE); // --- SmoothStroke SS_SlimBlip ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_SlimBlip); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_SLIMBLIP))))) return(FALSE); // --- Blip ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionBlip); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_BLIP))))) return(FALSE); // --- SmoothStroke SS_Cigar ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Cigar); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_CIGAR))))) return(FALSE); // --- SmoothStroke SS_Cigar2 ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Cigar2); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_CIGAR_2))))) return(FALSE); // --- SmoothStroke SS_Cigar3 ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Cigar3); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_CIGAR_3))))) return(FALSE); // --- SmoothStroke SS_Convex ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Convex); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_CONVEX))))) return(FALSE); // --- Simple S-shaped ramp with none-zero end width------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionRampS2); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_CONVEX_2))))) return(FALSE); // --- Simple S-shaped ramp ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionRampS); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_CONVEX_3))))) return(FALSE); // --- SmoothStroke SS_Concave ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Concave); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_CONCAVE))))) return(FALSE); // --- Simple linear ramp with non-zero end width -------------------------------------------------- pAttr = new VariableWidthAttrValue(new ValueFunctionRampL2); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_CONCAVE_2))))) return(FALSE); // --- Simple linear ramp -------------------------------------------------- pAttr = new VariableWidthAttrValue(new ValueFunctionRampL); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_CONCAVE_3))))) return(FALSE); // --- Teardrop CurvedEnd ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionTeardropCurvedEnd); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_DAB))))) return(FALSE); // --- Teardrop ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionTeardrop); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_RAINDROP))))) return(FALSE); // --- SmoothStroke SS_Comet ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Comet); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_COMET))))) return(FALSE); // --- SmoothStroke SS_Petal ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Petal); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_PETAL))))) return(FALSE); // --- SmoothStroke SS_Reed ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Reed); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_REED))))) return(FALSE); // --- SmoothStroke SS_Meteor ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Meteor); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_METEOR))))) return(FALSE); // --- SmoothStroke SS_Torpedo ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Torpedo); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_TORPEDO))))) return(FALSE); // --- SmoothStroke SS_Missile ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Missile); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_MISSILE))))) return(FALSE); // --- SmoothStroke SS_Goldfish ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Goldfish); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_GOLDFISH))))) return(FALSE); // --- SmoothStroke SS_Yacht ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Yacht); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_YACHT))))) return(FALSE); // --- SmoothStroke SS_Barb ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Barb); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_BARB))))) return(FALSE); // --- SmoothStroke SS_Ocean Liner ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_OceanLiner); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_OCEAN_LINER))))) return(FALSE); // --- Propeller ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionPropeller); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_PROPELLER))))) return(FALSE); // --- DoubleRampS ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionDoubleRampS); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_BOW_TIE))))) return(FALSE); // --- BevelEnds ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionBevelEnds); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_BEVELLED_ENDS))))) return(FALSE); // --- SawTooth ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSawTooth); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_SAW_TOOTH))))) return(FALSE); // --- Intestine ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionIntestine); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_INTESTINE))))) return(FALSE); // --- Decay ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionDecay); if (pAttr == NULL || !CreateItem(pGroup, new VarWidthItem(pAttr, String_64(_R(IDS_LINEGAL_VARWIDTH_DECAY))))) return(FALSE); #endif // VECTOR_STROKING return(TRUE); }

BOOL LineGallery::CreateWidthGroup (   )  [private]

Creates a new "line width" Group with its associated items. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 28/3/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if successful. Errors: - See also: LineGallery::CreateGroup; LineGallery::CreateItem; LineWidthItem::LineWidthItem Definition at line 1359 of file sgline.cpp. { // Create the group (heading). LineAttrGroup* pGroup = CreateGroup(String_256(_R(IDS_LINEGAL_CREATELINE)), TRUE); if (pGroup != NULL) pGroup->Flags.Folded = TRUE; // Create each item. return CreateItem(pGroup, new LineWidthItem(0.25, String_64(_R(IDS_LINEGAL_025PT)))) && CreateItem(pGroup, new LineWidthItem(0.5, String_64(_R(IDS_LINEGAL_05PT)))) && CreateItem(pGroup, new LineWidthItem(1.0, String_64(_R(IDS_LINEGAL_1PT)))) && CreateItem(pGroup, new LineWidthItem(2.0, String_64(_R(IDS_LINEGAL_2PT)))) && CreateItem(pGroup, new LineWidthItem(4.0, String_64(_R(IDS_LINEGAL_4PT)))) && CreateItem(pGroup, new LineWidthItem(8.0, String_64(_R(IDS_LINEGAL_8PT)))) && CreateItem(pGroup, new LineWidthItem(12.0, String_64(_R(IDS_LINEGAL_12PT)))) && CreateItem(pGroup, new LineWidthItem(16.0, String_64(_R(IDS_LINEGAL_16PT)))); }

BOOL LineGallery::DeleteBrushItem (  BrushHandle  Handle  )

Deletes the brush with the given handle. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 17/7/2000 Parameters: Handle  - the handle of the brush to delete [INPUTS] -  [OUTPUTS] Returns: TRUE if all went well, FALSE if not Errors: - See also: - Definition at line 2796 of file sgline.cpp. { LineGallery *pGallery = (LineGallery *) LineGallery::GetInstance(); if (pGallery == NULL) return FALSE; // Iterate over each group. for (LineAttrGroup* pGroup = (LineAttrGroup*) GetDisplayTree()->GetChild(); pGroup != NULL; pGroup = (LineAttrGroup*) pGroup->GetNext()) { // Iterate over each item within the group. LineAttrItem* pNextItem; LineAttrItem* pItem = (LineAttrItem*) pGroup->GetChild(); // if its not a brush we're not interested if (!pItem->IsKindOf(CC_RUNTIME_CLASS(BrushAttrItem))) pItem = NULL; while (pItem != NULL) { // get the next item before we delete anything pNextItem = (LineAttrItem*) pItem->GetNext(); // If the item is selected then remove it from the tree before deleting if (((BrushAttrItem*)pItem)->GetBrushHandle() == Handle) { pItem->RemoveFromTree(); pItem->DestroySubtree(TRUE); } pItem = pNextItem; } } SelectionHasChanged(); pGallery->ReformatAndRedrawIfNecessary(); return TRUE; }

void LineGallery::DestroyRenderRegion (  RenderRegion *  pRegion  )  [private, virtual]

Destroys the given render-region (in this case a GDraw version). Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 29/3/95 Parameters: pRegion  pointer to the RenderRegion to destroy [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: DialogOp::DestroyGRenderRegion Reimplemented from SuperGallery. Definition at line 2118 of file sgline.cpp. { DestroyGRenderRegion(pRegion); }

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

To apply a given command when it is chosen from the menu. Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> Date: 07/03/97 Parameters: CommandID  - The String ID of the command [INPUTS] Reimplemented from SuperGallery. Definition at line 2581 of file sgline.cpp. { // Taken out by vector stroking code Neville 2/10/97 #ifdef VECTOR_STROKING // if (*CommandID == SGCmd_Properties) // { // SGalleryLinePropertiesDlg::InvokeDialog(this); // } // else #endif // VECTOR_STROKING // we are now launching the brush edit dialog from here SGDisplayNode *pItem = DisplayTree->FindNextSelectedItem(NULL); // we want to launch our new edit dialog for the new style brushes, its all new baby if (pItem != NULL && pItem->IsKindOf(CC_RUNTIME_CLASS(BrushAttrItem))) { // get the brush component from the document Document* pDoc = Document::GetCurrent(); if (pDoc == NULL) { return; // not necessarily an error, but we don't wish to proceed } BrushComponent* pBrushComp = (BrushComponent*)pDoc->GetDocComponent(CC_RUNTIME_CLASS(BrushComponent)); if (pBrushComp == NULL) { ERROR3("We've got a document with no brush component"); return; } BrushHandle Handle = ((BrushAttrItem*)pItem)->GetBrushHandle(); if (Handle != BrushHandle_NoBrush) { if (*CommandID == SGCmd_RenameBrush) { // launch the naming dialog OpDescriptor* pDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_NAME_BRUSH_DLG); if (pDesc != NULL) { // provide the new brush handle as a parameter OpParam Param(static_cast<INT32>(Handle), 0); pDesc->Invoke(&Param); } } else if (*CommandID == SGCmd_ExportBrush) { pBrushComp->CopyInkObjectsToClipboard(Handle); } else if (*CommandID == SGCmd_Delete) { OpDescriptor* pDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_DELETEBRUSH); if (pDesc != NULL) { // provide the new brush handle as a parameter OpParam Param(static_cast<INT32>(Handle), 0); pDesc->Invoke(&Param); } } } } // SuperGallery::DoCommand(CommandID); // Unknown command- pass to the base class }

CBrushGadget* LineGallery::GetBrushGadget (   )  [inline]

Definition at line 304 of file sgline.h. { return &BrushGadget;}

OpState LineGallery::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: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> Date: 07/03/97 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. Reimplemented from SuperGallery. Definition at line 2556 of file sgline.cpp. { OpState State; if (*CommandID == SGCmd_Properties) return(State); return(State); }

LineGallery * LineGallery::GetInstance (   )  [static]

Public access function to the line gallery. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 17/4/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: A pointer to the program's line gallery if it exists, or NULL. Errors: - See also: - Definition at line 1131 of file sgline.cpp. { return m_pTheGallery; }

MILLIPOINT LineGallery::GetPreviousLineWidth (   )

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 9/1/2000 Returns: the previous line width member Definition at line 2777 of file sgline.cpp. { return m_PreviousLineWidth; }

BOOL LineGallery::Init (  void   )  [static]

Called when the program starts, loading .INI file settings. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 28/3/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if gallery initialisation is successful. Errors: - See also: - Reimplemented from SimpleCCObject. Definition at line 1102 of file sgline.cpp. { return Camelot.DeclareSection(TEXT("Displays"), 20) && Camelot.DeclarePref(TEXT("Displays"), TEXT("ArrowScale1"), &m_anArrowScales[0], 0.1, 50.0) && Camelot.DeclarePref(TEXT("Displays"), TEXT("ArrowScale2"), &m_anArrowScales[1], 0.1, 50.0) && Camelot.DeclarePref(TEXT("Displays"), TEXT("ArrowScale3"), &m_anArrowScales[2], 0.1, 50.0) && Camelot.DeclarePref(TEXT("Displays"), TEXT("ArrowScale4"), &m_anArrowScales[3], 0.1, 50.0) && PrepareBrushFolders(); }

BOOL LineGallery::InitMenuCommands (  void   )  [virtual]

Initialises any menu commands that this gallery needs. Author: Richard_Millican (Xara Group Ltd) <camelotdev@xara.com> Date: 07/03/97 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. Definition at line 2455 of file sgline.cpp. { static BOOL MenusInitialised = FALSE; BOOL ok = TRUE; if (!MenusInitialised) { // Initialise menu command Ops //ok = ok && InitMenuCommand((StringBase *) &SGCmd_Properties, _R(IDS_SGMENU_PROPERTIES)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_RenameBrush, _R(IDS_SGMENU_RENAMEBRUSH)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_ExportBrush, _R(IDS_SGMENU_EXPORTBRUSH)); ok = ok && InitMenuCommand((StringBase *) &SGCmd_Delete, _R(IDS_SGMENU_DELETE)); MenusInitialised = TRUE; } return(ok); }

BOOL LineGallery::IsActive (   )  [static]

Used by the message-handlers of gadgets within the line gallery to determine if they should update themselves or not. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 17/4/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the line gallery is currently visible on-screen, FALSE otherwise. Errors: - See also: - Definition at line 1152 of file sgline.cpp. { return m_pTheGallery != NULL && m_pTheGallery->IsVisible(); }

BOOL LineGallery::MakeSureGroupsHaveBeenCreated (   )  [inline]

Definition at line 291 of file sgline.h. {return(PreCreate());};

MsgResult LineGallery::Message (  Msg *  pMessage  )  [virtual]

A standard message handler, really. 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]. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 15/2/95 (base generated in sgbase.cpp) Parameters: Message  - The message to handle [INPUTS] See also: SuperGallery::Message Reimplemented from SuperGallery. Definition at line 1920 of file sgline.cpp. { // Do we need to update our display of the current attributes. if (MESSAGE_IS_A(pMessage, CurrentAttrChangedMsg)) { LineAttrItem::UpdateCurrentAttribStatus(); } // A dialogue box message? else if (IS_OUR_DIALOG_MSG(pMessage)) { DialogMsg* pMsg = (DialogMsg*) pMessage; switch (pMsg->DlgMsg) { // Gallery being created. case DIM_CREATE: SGInit::UpdateGalleryButton(_R(OPTOKEN_DISPLAY_LINE_GALLERY), TRUE); break; // Gallery being closed. case DIM_CANCEL: SGInit::UpdateGalleryButton(_R(OPTOKEN_DISPLAY_LINE_GALLERY), FALSE); break; case DIM_LFT_BN_CLICKED: if (pMsg->GadgetID == _R(IDC_GALLERY_HELP)) // Show help page { HelpUserTopic(_R(IDS_HELPPATH_Gallery_Line)); } break; default: break; } } // A document state message? else if (MESSAGE_IS_A(pMessage, DocChangingMsg)) { DocChangingMsg* pMsg = (DocChangingMsg*) pMessage; if (pMsg->State == DocChangingMsg::SELCHANGED) { if (pMsg->pNewDoc != NULL) { // A new document is selected, so update our selection state. SuperGallery::ShadeGallery(FALSE); SelectionHasChanged(); } else { // There is no selected doc, so grey the gallery for now. SuperGallery::ShadeGallery(TRUE); } } } else if (MESSAGE_IS_A(pMessage, BrushDefMsg)) { UpdateBrushItem(((BrushDefMsg*)pMessage)->m_BrushEdited); } // Pass on to the base-class for any more handling. return SuperGallery::Message(pMessage); }

BOOL LineGallery::OnApplyButton (  BOOL  fIsAdjust  )  [private, virtual]

Called by the line gallery when the user clicks the "Apply" button. Iterates over each group within the gallery trying to apply any selected attributes within the group to the current selection. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 6/4/95 Parameters: fIsAdjust  if TRUE then modify action to "adjust" apply [INPUTS] -  [OUTPUTS] Returns: TRUE if the application is successful (i.e. did something) FALSE if we failed to do anything useful (not necessarily an error) Errors: Out of memory. See also: LineGallery::ApplyAction Definition at line 2170 of file sgline.cpp. { BOOL ActuallyDidSomething = FALSE; // Iterate over each group. for (LineAttrGroup* pGroup = (LineAttrGroup*) GetDisplayTree()->GetChild(); pGroup != NULL; pGroup = (LineAttrGroup*) pGroup->GetNext()) { // Iterate over each item within the group. for (LineAttrItem* pItem = (LineAttrItem*) pGroup->GetChild(); pItem != NULL; pItem = (LineAttrItem*) pItem->GetNext()) { // If the item is selected then try to apply the attribute it represents // to the current selection. if (pItem->IsSelected()) { // Ask the item to create a new attribute of the required kind. NodeAttribute* pNewAttr = pItem->CreateNewAttribute(fIsAdjust); ERRORIF(pNewAttr == NULL, _R(IDE_NOMORE_MEMORY), FALSE); // ask items if they need to do anything before they become selected // Note that if this returns FALSE it means we no longer want to apply // the attribute here if (pItem->ItemSelected(pNewAttr)) AttributeManager::AttributeSelected(pNewAttr); // deselect the item pItem->SetSelected(FALSE); ActuallyDidSomething = TRUE; } } } // Success. return(ActuallyDidSomething); }

BOOL LineGallery::OnCommonAttrsChangedMsg (  void   )  [private, virtual]

Responds to the selection state changing by updating the "current attribute" status of the gallery's items. Responds to the the common attributes changing. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 09/02/95 Returns: TRUE if the message is processed successfully. Reimplemented from MessageHandler. Definition at line 2063 of file sgline.cpp. { return SuperGallery::OnCommonAttrsChangedMsg() && LineAttrItem::UpdateCurrentAttribStatus(); }

BOOL LineGallery::PostCreate (  void   )  [private, virtual]

Called after the LineGallery is created. Forces an update of the "current attribute" status of all items. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 17/4/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Whatever the base class SuperGallery returns for this function. Errors: - See also: LineAttrItem::UpdateCurrentAttribStatus Reimplemented from SuperGallery. Definition at line 1269 of file sgline.cpp. { // Prime the current attribute status flags of each item. return SuperGallery::PostCreate() && LineAttrItem::UpdateCurrentAttribStatus(); }

BOOL LineGallery::PreCreate (  void   )  [private, virtual]

The LineGallery PreCreate handler. This overrides the base class PreCreate function. It is called at the very beginning of the SuperGallery::Create method, before the window has been created. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 15/2/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. Definition at line 1229 of file sgline.cpp. { // If there isn't already one, create a DisplayTree if (DisplayTree != NULL) return TRUE; // New root node, with a scrollbar. DisplayTree = new SGDisplayRootScroll(this); ERRORIF(DisplayTree == NULL, _R(IDE_NOMORE_MEMORY), FALSE); // Try to create a title sub-tree for each kind of line attribute. BOOL ok = CreateBrushGroups() && #ifdef VECTOR_STROKING //CreateStrokeTypeGroup() && CreateVarWidthGroup() && #endif // VECTOR_STROKING // CreateWidthGroup() && CreateDashGroup() && CreateArrowGroup(); // CreateCapGroup() && // CreateJoinTypeGroup(); return ok; }

BOOL LineGallery::PrepareBrushFolders (   )  [static, private]

Prepares tp create folders in which to put brushes that are loaded in as part of the load default brushes process. Basically scans for .xar files in the /Templates/Brushes/ folders and stores each filename found. These filenames are subsequently used to create folders in CreateBrushGroups. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 9/1/2000 Returns: TRUE if successful. See also: Definition at line 2701 of file sgline.cpp. { // find all .xar files in the /templates/brushes directory and put them in a temp array PORTNOTE("other", "Disabled loading of line gallery templates") #ifndef EXCLUDE_FROM_XARALX // allocate a stupidly large array String_256 TempString[1000]; // surely can't be 1000 files! // set up the path to our .xar files String_256 SearchPath; CResDll::GetExecutablePath((TCHAR*)SearchPath); String_256 Path = TEXT("\\Templates\\Brushes\\"); SearchPath += Path; String_256 FileSpecifier = SearchPath; FileSpecifier += TEXT("*.xar"); UINT32 Counter = 0; // use file util to find the file for us, we need only pass the searchpath BOOL ok = FileUtil::StartFindingFiles(&FileSpecifier); String_256 Filename; INT32 StringLength; String_256 ShortName; while (ok) { // FileUtil will put our filename string into Filename ok = FileUtil::FindNextFile(&Filename); if (ok && Counter < 1000) { // strip the .xar from the string StringLength = Filename.Length(); Filename.Left(&ShortName, StringLength - 4); // //Special case - when Xara default brushes are loaded, change the folder group // //text to something prettier than "defbrush" - bit of a bodge but it works... // if (ShortName == String_256("defbrush")) // { // ShortName = String_256("Default brushes"); // } TempString[Counter++] = ShortName; } } FileUtil::StopFindingFiles(); // Now allocate our member string array, MFC seems to get very upset when // we try to delete an array of String_256's so use malloc m_pFileNameArray = (String_256*)malloc(sizeof(String_256) * Counter); if (m_pFileNameArray == NULL) return FALSE; // copy the strings over INT32 size = sizeof(String_256); memcpy(m_pFileNameArray, &TempString, size * Counter); m_NumDefaultFiles = Counter; // remember how many we got #endif return TRUE; }

void LineGallery::SelectionHasChanged (  void   )  [private, virtual]

Called by the base-class SuperGallery whenever the user clicks on an item. This version overrides the default bahaviour so that selecting more than one item does NOT grey the "Apply" button. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 7/4/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from SuperGallery. Definition at line 2140 of file sgline.cpp. { // Nothing to do if we are unavailable. if (GetDisplayTree() == NULL || AmShaded || !IsVisible()) return; // Only grey the "Apply" button when NO items are selected. EnableGadget(_R(IDC_GALLERY_APPLY), (GetDisplayTree()->GetSelectedItemCount() > 0)); // Update the status text to reflect the new selection. SetStatusText(); }

MILLIPOINT LineGallery::SetPreviousLineWidth (   )

queries AttributeManager to get the current default,sets it as the member variable and returns it Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 9/1/2000 Returns: the current default line width Definition at line 2657 of file sgline.cpp. { Document* pDoc = Document::GetCurrent(); if (pDoc == NULL) { ERROR3("No document"); return -1; } AttributeManager* pAttrMgr = &(pDoc->GetAttributeMgr()); if (pAttrMgr == NULL) { ERROR3("No attribute manager"); return -1; } NodeAttribute* pAttr = pAttrMgr->GetCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), CC_RUNTIME_CLASS(AttrLineWidth)); if (pAttr == NULL) return -1; LineWidthAttribute* pVal = (LineWidthAttribute*)pAttr->GetAttributeValue(); if (pVal == NULL) return -1; m_PreviousLineWidth = pVal->LineWidth; return m_PreviousLineWidth; }

void LineGallery::SetStatusText (   )  [private]

Works out what the status text should be from which items are selected in the gallery, and updates it on-screen. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/95 See also: LineGallery::SelectionHasChanged Definition at line 2222 of file sgline.cpp. { /* THIS CODE HAS BEEN COMMENTED OUT BECAUSE, ALTHOUGH IT WORKS, THE GALLERY STATUS-LINE CODE PROVIDES ITS OWN STATUS-LINE HELP TEXT FOR THE APPLY BUTTON. // Update the status line text, according to what is selected in the gallery. String_256 strAttribs; strAttribs.Empty(); // Ask each selected item in each group to provide a description of its attribute. INT32 nSelected = 0; for (LineAttrGroup* pGroup = (LineAttrGroup*) GetDisplayTree()->GetChild(); pGroup != NULL; pGroup = (LineAttrGroup*) pGroup->GetNext()) { for (LineAttrItem* pItem = (LineAttrItem*) pGroup->GetChild(); pItem != NULL; pItem = (LineAttrItem*) pItem->GetNext()) { // Does this item have something to contribute? if (pItem->IsSelected()) { // It does, so if it isn't the first add some punctuation. if (nSelected > 0) strAttribs += TEXT(", "); strAttribs += pItem->GetDescription(); nSelected++; } } } // Did we find any selected attributes? if (nSelected > 0) { // If there's only one attribute then prepend a singular indefinite article and don't // pluralize the "attribute" word. If not then vice versa. String strPlural = TEXT("s"); // Commented out if (nSelected == 1) { String_256 s = TEXT("a "); // Commented out strAttribs = (s += strAttribs); strPlural.Empty(); } // Format the attribute text into a meaningful sentence and if successful set the // status line text with the information. String_256 strStatus; if (strStatus.MakeMsg(_R(IDS_LINEGAL_STATUS_TEXT_MASK), &strAttribs, &strPlural) != 0) { // Write the new text. // GetApplication()->UpdateStatusBarText(&strStatus); TRACEUSER( "JustinF", _T("%s\n"), (LPCTSTR) strStatus); } } */ }

void LineGallery::UpdateBrushItem (  BrushHandle  Handle  )

Searches for a brush item with the same handle as Handle, and asks it to update itself. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 3/4/2000 Parameters: Handle  - identifier for the brush that needs updating [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1999 of file sgline.cpp. { // we need to make sure the groups have been created if (!MakeSureGroupsHaveBeenCreated()) return; // Iterate over each group. for (LineAttrGroup* pGroup = (LineAttrGroup*) GetDisplayTree()->GetChild(); pGroup != NULL; pGroup = (LineAttrGroup*) pGroup->GetNext()) { // Iterate over each item within the group. LineAttrItem* pNextItem; LineAttrItem* pItem = (LineAttrItem*) pGroup->GetChild(); // if its not a brush we're not interested if (!pItem->IsKindOf(CC_RUNTIME_CLASS(BrushAttrItem))) pItem = NULL; while (pItem != NULL) { // get the next item before we delete anything pNextItem = (LineAttrItem*) pItem->GetNext(); // If the item is selected then remove it from the tree before deleting if (((BrushAttrItem*)pItem)->GetBrushHandle() == Handle) ((BrushAttrItem*)pItem)->UpdateGalleryItem(); pItem = pNextItem; } } }

---

Member Data Documentation

CBrushGadget LineGallery::BrushGadget [private]

Definition at line 386 of file sgline.h.

double LineGallery::m_anArrowScales = { 3.0, 8.0, 13.0, 18.0 } [static, private]

Definition at line 378 of file sgline.h.

UINT32 LineGallery::m_NumDefaultFiles = 0 [static, private]

Definition at line 390 of file sgline.h.

String_256 * LineGallery::m_pFileNameArray = NULL [static, private]

Definition at line 389 of file sgline.h.

MILLIPOINT LineGallery::m_PreviousLineWidth [private]

Definition at line 382 of file sgline.h.

LineGallery * LineGallery::m_pTheGallery = NULL [static, private]

Definition at line 377 of file sgline.h.

---

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

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

---