BrushComponent Class Reference

A document component for handling Brush definitions. More...

#include <brshcomp.h>

Inheritance diagram for BrushComponent:

List of all members.

Public Member Functions
	BrushComponent ()
	Constructor.
virtual	~BrushComponent ()
	Destructor.
AttrBrushType *	CreateAttributeNode (BrushHandle Handle)
virtual LineHandle	AddNewItem (LineDefinition *pLine, BOOL AskName=FALSE)
	Adds the given Line to the global Line list.
BOOL	CopyInkObjectsToClipboard (BrushHandle Handle)
	copies the ink objects of this brush definition to the clipboard so they can be used elsewhere
virtual BOOL	NameIsUnique (const String_32 &NameString)
	To find out if someone has already gotten this name.
virtual String_32	GetUniqueName (String_32 *pName=NULL)
	When naming a new brush we want to give it the name supplied, however this may well be taken in which case we want to add a number to the default name.
virtual BOOL	StartExport (BaseCamelotFilter *pFilter)
	Called before an export is started.
BOOL	StartImportBrush (CamelotRecordHandler *pHandler, CXaraFileRecord *pRecord, UINT32 ImportHandle)
	To import a vector Line definition.
BOOL	EndImportBrush (CamelotRecordHandler *pHandler)
	To import a vector brush definition.
BOOL	ExportLine (BaseCamelotFilter *pFilter, BrushHandle Handle)
	To export a vector Brush definition.
BrushHandle	FindImportedBrush (UINT32 ImportedHandle)
	To match up a handle from the currently importing file to the real internal BrushHandle of the imported BrushDefinition.
BrushDefinition *	GetImportBrushDefinition ()
	As above, note that this function is only useful in the period between StartImportBrush and EndImportBrush being called. At all other times m_pImportBrushDef should be NULL.
void	CleanUpAfterImport ()
	Deletes the objects we created for import. Goes without saying that calling this function before you have added the brushdef to the component is pretty silly.
Static Public Member Functions
static BOOL	BeginLoadingDefaultFiles ()
	Lets the component know that we are starting to load default brushes Notes: What happens here is that every brush added to the component whilst m_CurrentDefaultBrush != BRUSHFILE_NONE will be assigned m_CurrentDefaultBrush as its default file ID. Note again, as you can tell from the code this can only be done once.
static BOOL	LoadNextDefaultFile ()
	Increments our default file counter.
static void	EndLoadingDefaults ()
	Finishes loading default files.
static AttrBrushType *	CreateNode (BrushHandle Handle)
	static version of above
static UINT32	GetNumberOfBrushes ()
static BrushDefinition *	FindBrushDefinition (UINT32 Handle, BOOL IncludeDeactivated=FALSE)
static void	CancelNewBrush ()
static void	SetNewName (String_32 NewName)
Private Member Functions
virtual BOOL	ExpandArray (void)
	(Internal method) Expands the storage structure of the Brush list to allow more entries to be used. Called automatically by AddNewBrush as necessary.
Private Attributes
BrushDefinition *	m_pImportBrushDef
MILLIPOINT	m_StoreSpacing
BOOL	m_StoreTile
BOOL	m_StoreRotate
double	m_StoreRotateAngle
PathOffset	m_StorePathOffsetType
MILLIPOINT	m_StoreOffsetValue
Static Private Attributes
static String_32	m_NewName = TEXT("Unnamed brush")
static BOOL	m_bCancelNewBrush = FALSE
static UINT32	m_CurrentDefaultFile = BRUSHFILE_NONE

---

Detailed Description

A document component for handling Brush definitions.

Author:

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

Date:

22/2/97

BrushComponents share a global cache of available Brush types. Individual instances serve as managers for the list, mainly providing import/export facilities for Brush definitions.

See also:

DocComponent

Definition at line 503 of file brshcomp.h.

---

Constructor & Destructor Documentation

BrushComponent::BrushComponent (   )

Constructor. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Definition at line 3730 of file brshcomp.cpp. : LineComponent() { m_pImportBrushDef = NULL; }

BrushComponent::~BrushComponent (   )  [virtual]

Destructor. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Definition at line 3749 of file brshcomp.cpp. { if (m_pImportBrushDef != NULL) delete m_pImportBrushDef; }

---

Member Function Documentation

LineHandle BrushComponent::AddNewItem (  LineDefinition *  pItem, BOOL  AskName = FALSE )  [virtual]

Adds the given Line to the global Line list. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pLine  - (may not be NULL) A Line definition to add, which now [INPUTS] belongs to the LineComponent, so you mustn't delete it! AskName - a flag saying whether or not we should prompt the user for a name, defaults to FALSE Returns: A handle which uniquely identifies the new Line, or LineHandle_NoLine if we ran out of memory for storing Lines Notes: Also read the notes in LineComponent::AddNewItem This function overrides the base class but actually uses it to do the actual adding. functinality added here is that it works out whether or not the brush has actually been added and if so adds it to the line gallery Reimplemented from LineComponent. Definition at line 4458 of file brshcomp.cpp. { // just make sure its the right type ERROR2IF(!pItem->IsKindOf(CC_RUNTIME_CLASS(BrushDefinition)), BrushHandle_NoBrush, "Attempting to pass in wrong definition"); String_32 DefaultName(_R(IDS_BRUSH_DEFAULT_NAME)); m_NewName = DefaultName; m_bCancelNewBrush = FALSE; if (AskName == TRUE) { // launch the naming dialog, it will either set m_NewName or tell us to cancel OpDescriptor* pDesc = OpDescriptor::FindOpDescriptor( OPTOKEN_INITNAME_BRUSH_DLG ); if (pDesc != NULL) { pDesc->Invoke(); } // did they cancel it? if (m_bCancelNewBrush) { m_bCancelNewBrush = FALSE; return BrushHandle_NoBrush; } pItem->SetLineName(&m_NewName); } // stash the old number of brushes, which will be incremented if we make a new one UINT32 OldNumBrushes = m_Used; // item is added in the base class LineHandle NewHandle = LineComponent::AddNewItem(pItem); // have we actually added a new brush? if (NewHandle >= OldNumBrushes && NewHandle != BrushHandle_NoBrush) { // tell it the filename ID ((BrushDefinition*)pItem)->SetBrushFileID(m_CurrentDefaultFile); // make a new atttibute to add to the line gallery PathProcessorBrush* pNewPathProc = new PathProcessorBrush; if (pNewPathProc == NULL) { ERROR3("Failed to allocate path processor"); return NewHandle; } // tell it which brush definition to use pNewPathProc->SetBrushDefinition(NewHandle); // transfer all the data ((BrushDefinition*)pItem)->CopyDataToProcessor(pNewPathProc); // make a new attribute value for use by the line gallery BrushAttrValue* pVal = new BrushAttrValue(pNewPathProc); if (pVal == NULL) { ERROR3("Unable to allocate new BrushAttrVal"); return NewHandle; } // add it to the line gallery LineGallery::AddNewBrushItem(pVal); // get the freehand tool ToolListItem* pToolItem = Tool::Find(TOOLID_FREEHAND); ERROR2IF(pToolItem == NULL, NewHandle, "Unable to get tool item in DeactivateBrushDefAction::Init"); FreeHandTool* pTool = (FreeHandTool*)pToolItem->m_pTool; ERROR2IF(pTool == NULL, NewHandle, "Unable to get tool in DeactivateBrushDefAction::Init"); // get the infobar FreeHandInfoBarOp* pInfoBar = ((FreeHandTool*)pTool)->GetInfoBar(); ERROR2IF(pInfoBar == NULL, NewHandle, "Unable to get InfoBar in DeactivateBrushDefAction::Init"); // add to the freehand infobar pInfoBar->AddBrush(NewHandle); } return NewHandle; }

BOOL BrushComponent::BeginLoadingDefaultFiles (   )  [static]

Lets the component know that we are starting to load default brushes Notes: What happens here is that every brush added to the component whilst m_CurrentDefaultBrush != BRUSHFILE_NONE will be assigned m_CurrentDefaultBrush as its default file ID. Note again, as you can tell from the code this can only be done once. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: TRUE Definition at line 3771 of file brshcomp.cpp. { m_CurrentDefaultFile = BRUSHFILE_NONE; return TRUE; }

void BrushComponent::CancelNewBrush (   )  [static]

Definition at line 4663 of file brshcomp.cpp. { m_bCancelNewBrush = TRUE; }

void BrushComponent::CleanUpAfterImport (   )

Deletes the objects we created for import. Goes without saying that calling this function before you have added the brushdef to the component is pretty silly. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Returns: - Definition at line 4344 of file brshcomp.cpp. { // don't delete the brushdef as it is now being used in the component if (m_pImportBrushDef != NULL) m_pImportBrushDef = NULL; if (m_pImportNewLine != NULL) m_pImportNewLine = NULL; }

BOOL BrushComponent::CopyInkObjectsToClipboard (  BrushHandle  Handle  )

copies the ink objects of this brush definition to the clipboard so they can be used elsewhere Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Handle  to the brush definition which we want to send to the clipboard [INPUTS] Returns: TRUE if successful, FALSE otherwise See also: - Definition at line 3875 of file brshcomp.cpp. { if (Handle == BrushHandle_NoBrush || Handle >= m_Used) { ERROR3("Invalid brush handle"); return FALSE; } BrushDefinition* pBrushDef = (BrushDefinition*)m_pLineArray[Handle]; if (pBrushDef == NULL) { ERROR3("Brush definition is NULL"); return FALSE; } return pBrushDef->CopyInkTreeToClipboard(); }

AttrBrushType * BrushComponent::CreateAttributeNode (  BrushHandle  Handle  )

Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Handle  to the brush definition which we want to base this brush on [INPUTS] Returns: Attribute node based on this definition See also: - Definition at line 3835 of file brshcomp.cpp. { BrushDefinition* pBrushDef = FindBrushDefinition(Handle); if (pBrushDef == NULL) return NULL; AttrBrushType* pNewNode = new AttrBrushType; if (pNewNode == NULL) return NULL; BrushAttrValue* pVal = (BrushAttrValue*)pNewNode->GetAttributeValue(); if (pVal == NULL) return NULL; PathProcessorBrush* pPathProc = new PathProcessorBrush; if (pPathProc == NULL) return NULL; pBrushDef->CopyDataToProcessor(pPathProc); pVal->SetPathProcessor(pPathProc); // tell it which brush definition to use pPathProc->SetBrushDefinition(Handle); return pNewNode; }

AttrBrushType * BrushComponent::CreateNode (  BrushHandle  Handle  )  [static]

static version of above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: Handle  to the brush definition which we want to base this brush on [INPUTS] Returns: Attribute node based on this definition See also: - Definition at line 3906 of file brshcomp.cpp. { BrushDefinition* pBrushDef = FindBrushDefinition(Handle); if (pBrushDef == NULL) return NULL; AttrBrushType* pNewNode = new AttrBrushType; if (pNewNode == NULL) return NULL; BrushAttrValue* pVal = (BrushAttrValue*)pNewNode->GetAttributeValue(); if (pVal == NULL) return NULL; PathProcessorBrush* pPathProc = new PathProcessorBrush; if (pPathProc == NULL) return NULL; pBrushDef->CopyDataToProcessor(pPathProc); pVal->SetPathProcessor(pPathProc); // tell it which brush definition to use pPathProc->SetBrushDefinition(Handle); return pNewNode; }

BOOL BrushComponent::EndImportBrush (  CamelotRecordHandler *  pHandler  )

To import a vector brush definition. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pRecord  - The TAG_BRUSHDEFINITION record to import [INPUTS] Returns: TRUE if Import was successful Definition at line 4081 of file brshcomp.cpp. { ERROR2IF(m_pImportPreviousContext == NULL,FALSE, "EndImportBrush - something hasn't gone too well"); ERROR2IF(m_pImportBrushDef == NULL, FALSE, "ImportBrushDef is NULL at EndImportBrush"); // Restore the previous import context node pHandler->RestoreInsertContext(m_pImportPreviousContext); delete m_pImportPreviousContext; m_pImportPreviousContext = NULL; // --- Now, convert all IndexedColours (which are document-dependent) into standalone DocColours // This wouldn't be necessary, except that the DocColours we saved have magically been turned // back into local Indexedcolours by the export/import process. // BLOCK LineDefinition::ConvertIndexedColours((Spread*)m_pImportNewLine); // Create a new Brush definition from the imported brush if (m_pImportBrushDef->GenerateBrush() != TRUE) return FALSE; m_pImportBrushDef->CalculateMaxScaling(); // add the item, /*BrushHandle NewHandle =*/ AddNewItem(m_pImportBrushDef); CleanUpAfterImport(); return TRUE; }

void BrushComponent::EndLoadingDefaults (   )  [static]

Finishes loading default files. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: - See also: - Definition at line 3817 of file brshcomp.cpp. { m_CurrentDefaultFile = BRUSHFILE_NONE; }

BOOL BrushComponent::ExpandArray (  void   )  [private, virtual]

(Internal method) Expands the storage structure of the Brush list to allow more entries to be used. Called automatically by AddNewBrush as necessary. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 28/2/97 Parameters: On  succesful exit, the member array of BrushDefinition pointers will be bigger [OUTPUTS] Returns: FALSE if it failed to allocate memory Notes: Internal storage is an array of pointers to BrushDefinitions NULL pointers beyond (& including) "Used" indicate free slots. NULL pointers before "Used" indicate deleted Brushs - these slots should NOT be re-used, as there may still be references to them in the system. Implements LineComponent. Definition at line 4268 of file brshcomp.cpp. { // ****!!!!TODO - if we're multi-threading, this probably needs to be a critical section // because the list is global const INT32 AllocSize = m_CurrentSize + 64; if (m_pLineArray == NULL) { m_pLineArray = (LineDefinition **) CCMalloc(AllocSize * sizeof(LineDefinition *)); if (m_pLineArray == NULL) return(FALSE); } else { // We have an array - we must make it larger LineDefinition **pNewBuf = (LineDefinition **) CCRealloc(m_pLineArray, AllocSize * sizeof(LineDefinition *)); if (pNewBuf == NULL) return(FALSE); m_pLineArray = pNewBuf; } // Success. Initalise all the new pointers to NULL for (UINT32 i = m_Used; i < m_CurrentSize; i++) m_pLineArray[i] = NULL; // Update the current size value, and return success m_CurrentSize = (UINT32)AllocSize; return(TRUE); }

BOOL BrushComponent::ExportLine (  BaseCamelotFilter *  pFilter, BrushHandle  Handle )  [virtual]

To export a vector Brush definition. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 22/12/99 Parameters: pFilter  - the BaseCamelotFilter filter that is being used to export a file. [INPUTS] Handle - The Brush to be exported Returns: TRUE if export was successful FALSE if export was aborted - no error is set, as in this case, it usually means that the Brush has been deleted, and is being treated as an old-style line. In this case, the caller should simply not bother exporting the attribute using the Brush definition. Notes: Brush definitions (like colours) are only saved out when a node in the tree is found which makes use of the Brush. You should call this function before exporting any attribute which uses the Brush definition. It automatically checks if the Brush has already been saved, and will not save the definition more than once. When saving your reference to the Brush, save out the Brush's Handle as it's unique ID word. Implements LineComponent. Definition at line 4148 of file brshcomp.cpp. { ERROR3IF(pFilter == NULL, "Illegal NULL params"); // Find the stroke, and baulk if it's all gone wrong BrushDefinition *pBrush = FindBrushDefinition(Handle); if (pBrush == NULL) { ERROR3("Attempt to save a deleted or non-existent stroke"); return(FALSE); } // Check if the definition has already been saved, in which case we don't need to do anything more if (pBrush->ReadIOStore()) return(TRUE); // We've got a stroke definition now, get it to write itself to the file return pBrush->ExportBrush(pFilter, Handle); }

static BrushDefinition* BrushComponent::FindBrushDefinition (  UINT32  Handle, BOOL  IncludeDeactivated = FALSE )  [static]

BrushHandle BrushComponent::FindImportedBrush (  UINT32  ImportedHandle  )

To match up a handle from the currently importing file to the real internal BrushHandle of the imported BrushDefinition. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 22/12/99 Parameters: Importedhandle  - The handle which is used in the file being imported [INPUTS] to reference the stroke. Returns: The BrushHandle of the loaded stroke, or BrushHandle_NoBrush if the stroke could not be found. Definition at line 4188 of file brshcomp.cpp. { ImportedHandle &= 0x00ffffff; // Only the bottom 24 bits are relevant for (UINT32 Index = 0; Index < m_Used; Index++) { if (m_pLineArray[Index] != NULL && m_pLineArray[Index]->ReadIOStore() == ImportedHandle) return((BrushHandle)Index); } return(BrushHandle_NoBrush); }

BrushDefinition * BrushComponent::GetImportBrushDefinition (   )

As above, note that this function is only useful in the period between StartImportBrush and EndImportBrush being called. At all other times m_pImportBrushDef should be NULL. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: -  [INPUTS] Returns: A pointer to the brush definition that is currently in the process of being imported. Definition at line 4322 of file brshcomp.cpp. { return m_pImportBrushDef; }

static UINT32 BrushComponent::GetNumberOfBrushes (   )  [inline, static]

Definition at line 525 of file brshcomp.h. {return m_Used;}

String_32 BrushComponent::GetUniqueName (  String_32 *  pName = NULL  )  [virtual]

When naming a new brush we want to give it the name supplied, however this may well be taken in which case we want to add a number to the default name. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pName  - the name that we wish to use, defaults to NULL in which [INPUTS] case we use the default name Returns: A unique name which can be given to the brush Implements LineComponent. Definition at line 4555 of file brshcomp.cpp. { // essentially what we're doing is going through all the brush definitions and // retrieving the portion of name that will could be equal to the default name. // We count the number of default names that we find and once we're finished // we use this as the suffix for the new name // Get the default name from the resources String_32 DefaultName(_R(IDS_BRUSH_DEFAULT_NAME)); if (pName == NULL) pName = &DefaultName; INT32 DefaultSize = pName->Length(); BrushDefinition* pDef = NULL; String_32* pDefName = NULL; String_32 LeftMost; UINT32 Counter = 0; INT32 DefaultCounter = 0; // loop though the definitions while (Counter < m_Used) { pDef = FindBrushDefinition(Counter); if (pDef != NULL) { pDefName = pDef->GetLineName(); if (pDefName == NULL) { ERROR3("Brush definition with no name in BrushComponent::GetUniqueName"); break; } // test to see if the leftmost portion of the name is the same as our default pDefName->Left(&LeftMost, DefaultSize); if (LeftMost.IsIdentical(*pName)) DefaultCounter++; LeftMost.Empty(); // wipe the default } Counter++; } String_32 UniqueName(*pName); // do we have to concatenate a number? if (DefaultCounter > 0) { String_32 Concat; Convert::LongToString(DefaultCounter, &Concat); UniqueName+=Concat; } return UniqueName; }

BOOL BrushComponent::LoadNextDefaultFile (   )  [static]

Increments our default file counter. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 6/10/99 Parameters: -  [INPUTS] Returns: TRUE if all goes well See also: - Definition at line 3791 of file brshcomp.cpp. { // is this the first file? if (m_CurrentDefaultFile == BRUSHFILE_NONE) m_CurrentDefaultFile = 0; else m_CurrentDefaultFile++; return TRUE; }

BOOL BrushComponent::NameIsUnique (  const String_32 &  NameString  )  [virtual]

To find out if someone has already gotten this name. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 3/7/2000 Parameters: NameString  - the string to test [INPUTS] Returns: TRUE if none of the definitions in the component have this string as their name, FALSE if one of them does Reimplemented from LineComponent. Definition at line 4628 of file brshcomp.cpp. { if (NameString.IsEmpty()) ERROR3("Empty string in BrushComponent::NameIsUnique"); BOOL Unique = TRUE; UINT32 Counter = 0; String_32* pDefName = NULL; BrushDefinition* pDef = NULL; while (Counter < m_Used) { pDef = FindBrushDefinition(Counter); if (pDef != NULL) { pDefName = pDef->GetLineName(); if( pDefName != NULL ) { if (NameString == *pDefName) { Unique = FALSE; break; } } } Counter++; } return Unique; }

void BrushComponent::SetNewName (  String_32  NewName  )  [static]

Definition at line 4658 of file brshcomp.cpp. { m_NewName = NewName; }

BOOL BrushComponent::StartExport (  BaseCamelotFilter *  pFilter  )  [virtual]

Called before an export is started. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pFilter  - the BaseCamelotFilter filter that is being used to export a file. [INPUTS] Returns: TRUE if the component was able to prepare for exporting; FALSE if not (e.g. out of memory) Implements LineComponent. Definition at line 3947 of file brshcomp.cpp. { // return TRUE; // for now #if !defined(EXCLUDE_FROM_RALPH) if (pFilter == NULL) { ERROR3("BrushComponent::StartExport filter is null!"); return(TRUE); } // ****!!!!TODO - if we're multi-threadig, this probably needs to be a critical section // because the list is global // Flag all Brushs as not having been saved. When we save one, we set its flag so that // we don't try to save it a second time. if (m_pLineArray != NULL) { for (UINT32 Index = 0; Index < m_Used; Index++) { if (m_pLineArray[Index] != NULL) m_pLineArray[Index]->SetIOStore(FALSE); } // Write out an atomic tag definition in front of the vector Brush definition. // ****!!!!TODO - This should really only be done just before we export the first // BrushDEFINITION tag, but it is not properly supported by the export system as yet. //TODO : Make tags for brush components!! BOOL ok = TRUE; CXaraFileRecord Rec(TAG_ATOMICTAGS, TAG_ATOMICTAGS_SIZE); if (ok) ok = Rec.Init(); if (ok) ok = Rec.WriteUINT32(TAG_BRUSHDEFINITION); if (ok) pFilter->Write(&Rec); // And write out the record } #endif return(TRUE); }

BOOL BrushComponent::StartImportBrush (  CamelotRecordHandler *  pHandler, CXaraFileRecord *  pRecord, UINT32  ImportHandle )

To import a vector Line definition. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/99 Parameters: pRecord  - The TAG_BRUSHDEFINITION record to import [INPUTS] Returns: TRUE if Import was successful Definition at line 4004 of file brshcomp.cpp. { m_ImportHandle = 0xffffffff; if (m_pImportPreviousContext != NULL) { // delete m_pImportPreviousContext; m_pImportPreviousContext = NULL; } if (m_pImportNewLine != NULL) { m_pImportNewLine->CascadeDelete(); m_pImportNewLine = NULL; } // Create a spread and set up the import system to import the brush into it // If this fails, then it'll just find somewhere "sensible" to import into m_pImportNewLine = new Spread; if (m_pImportNewLine == NULL) return(FALSE); Layer *pLineLayer = new Layer(m_pImportNewLine, FIRSTCHILD, String_256(TEXT("Jason did this"))); if (pLineLayer == NULL) { delete m_pImportNewLine; m_pImportNewLine = NULL; return(FALSE); } // Now, remember where we were importing into, and point the importer at our brush tree m_pImportPreviousContext = pHandler->GetInsertContext(); pHandler->SetInsertContextNode(pLineLayer); // check to see if our import brushdef already exists, if so delete it if (m_pImportBrushDef != NULL) delete m_pImportBrushDef; // make the new brush definition m_pImportBrushDef = new BrushDefinition(m_pImportNewLine); if (m_pImportBrushDef == NULL) return(FALSE); // Remember the handle used for the Brush in the file with the Brush so that // we can map any incoming handles into the real handles we are using internally. m_pImportBrushDef->SetIOStore(ImportHandle & 0x00ffffff); /* in case you were wondering, after this function the import goes as follows: - Ink nodes etc. are imported into m_pImportNewLine - Brush data is imported - EndImportBrush is called, where the new brush definition is inserted */ return(TRUE); }

---

Member Data Documentation

BOOL BrushComponent::m_bCancelNewBrush = FALSE [static, private]

Definition at line 575 of file brshcomp.h.

UINT32 BrushComponent::m_CurrentDefaultFile = BRUSHFILE_NONE [static, private]

Definition at line 576 of file brshcomp.h.

String_32 BrushComponent::m_NewName = TEXT("Unnamed brush") [static, private]

Definition at line 574 of file brshcomp.h.

BrushDefinition* BrushComponent::m_pImportBrushDef [private]

Definition at line 565 of file brshcomp.h.

MILLIPOINT BrushComponent::m_StoreOffsetValue [private]

Definition at line 572 of file brshcomp.h.

PathOffset BrushComponent::m_StorePathOffsetType [private]

Definition at line 571 of file brshcomp.h.

BOOL BrushComponent::m_StoreRotate [private]

Definition at line 569 of file brshcomp.h.

double BrushComponent::m_StoreRotateAngle [private]

Definition at line 570 of file brshcomp.h.

MILLIPOINT BrushComponent::m_StoreSpacing [private]

Definition at line 567 of file brshcomp.h.

BOOL BrushComponent::m_StoreTile [private]

Definition at line 568 of file brshcomp.h.

---

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

• Kernel/brshcomp.h (r1785/r1282)
• Kernel/brshcomp.cpp (r1785/r1732)

---