BrushAttrItem Class Reference

Represents a brush attribute user-interface item within the line gallery. More...

#include <sgbrush.h>

Inheritance diagram for BrushAttrItem:

List of all members.

Public Member Functions
	BrushAttrItem (BrushAttrValue *pBrush, const String &strDescription)
	Constructs a user-interface item representing a stroke type.
	~BrushAttrItem ()
	Destructor.
virtual BrushAttrValue *	GetBrushAttrValue ()
virtual BrushDefinition *	GetBrushDefinition ()
	Get the BrushDefinition for this item.
virtual BrushHandle	GetBrushHandle ()
	Get the BrushHandle for this item.
virtual void	RenderItem (RenderRegion *pRender, DocRect *pDocRect, INT32 Width=c_nDefaultLineWidth)
	Renders a representation of the stroke into the given renderregion. This is used by the line properties dialog since all the stuff needed seems to be private...
virtual void	UpdateGalleryItem ()
	Updates the gallery item's cached data to represent any changes this Stoke might have had done to it. Also redraw the gallery if necessary.
virtual BOOL	ItemSelected (NodeAttribute *pNewAttr)
	Sets the default line width to be that of the brush, or the previous line width if the brush doesn't have one. Also broadcasts a message saying that it has been selected, for the benefit of the freehand tool.
BOOL	IsEqualValueToAny (NodeAttribute **ppOtherAttribs) const
	Used when searching for display items representing the selection's current attributes.
BOOL	UpdateProcessor ()
Protected Member Functions
virtual void	SetAttributes (RenderRegion *pRegion) const
	Sets the brush attributes in the given render-region to render this item correctly.
void	DrawItem (RenderRegion *pRegion, const DocRect &drBounds) const
	Draws this item within the bounding box. The aim is to work out what scaling we need in order to fit the brush into the FormatRect. Therefore we draw a line through the bounding box, get its bounding box with the brush applied and work out the scaling that will fit this into the formatrect.
virtual NodeAttribute *	CreateNewAttribute (BOOL fIsAdjust) const
	Create a NodeAttribute representing the attribute this item applies.
virtual CCRuntimeClass **	GetAttribRuntimeClasses () const
	Used when searching for display items representing the selection's current attributes.
BrushHandle	GetCurrentDefaultBrushHandle ()
	as above
Private Member Functions
	CC_DECLARE_DYNAMIC (BrushAttrItem)
Private Attributes
BrushAttrValue *	m_pBrushAttrVal

---

Detailed Description

Represents a brush attribute user-interface item within the line gallery.

Author:

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

Date:

7/1/2000

Definition at line 118 of file sgbrush.h.

---

Constructor & Destructor Documentation

BrushAttrItem::BrushAttrItem (  BrushAttrValue *  pBrush, const String &  strDescription )

Constructs a user-interface item representing a stroke type. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 3/3/97 Parameters: pBrush  - a pointer to an attribute to be used for this [INPUTS] brush item. This now belongs to the BrushAttrItem, so you must not delete it strDescription - a text description of this user-interface item -  [OUTPUTS] Returns: - Definition at line 137 of file sgbrush.cpp. : LineAttrItem(strDescription, BELOW) { ERROR3IF(pBrush == NULL, "Illegal NULL param"); m_pBrushAttrVal = pBrush; }

BrushAttrItem::~BrushAttrItem (   )

Destructor. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 3/3/97 Definition at line 157 of file sgbrush.cpp. { if (m_pBrushAttrVal != NULL) { m_pBrushAttrVal->FlushCache(); m_pBrushAttrVal->SetPathProcessor(NULL); delete m_pBrushAttrVal; } }

---

Member Function Documentation

BrushAttrItem::CC_DECLARE_DYNAMIC (  BrushAttrItem   )  [private]

NodeAttribute * BrushAttrItem::CreateNewAttribute (  BOOL  fIsAdjust  )  const [protected, virtual]

Create a NodeAttribute representing the attribute this item applies. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 3/3/97 Returns: A pointer to a NodeAttribute-derivative that this user-interface item represents, ie. a line-width attribute that can be passed to the attribute manager. Implements LineAttrItem. Definition at line 212 of file sgbrush.cpp. { // because we may have changed some of the attribute data to render the brush objects // in the line gallery we really want to make sure the new path processor takes all // its data from the original brush definition. // This is a bit long winded but safer than just taking the local data AttrBrushType* pAttrBrushType = (AttrBrushType*)m_pBrushAttrVal->MakeNode(); if (pAttrBrushType == NULL) { ERROR3("Failed to make node"); return NULL; } BrushAttrValue* pNewBrushAttrVal = (BrushAttrValue*)pAttrBrushType->GetAttributeValue(); if (pNewBrushAttrVal == NULL) { ERROR3("No BrushAttrVal"); return NULL; } // now get the brush definition BrushDefinition* pBrush = m_pBrushAttrVal->GetBrushDefinition(); if (pBrush == NULL) { // not an error return pAttrBrushType; } PathProcessorBrush* pPathProc = pNewBrushAttrVal->GetPathProcessor(); if (pPathProc == NULL) { // not actually an error, as this could be a default 'normal line' brush return pAttrBrushType; } // copy the data to the new processor pBrush->CopyDataToProcessor(pPathProc); // tell the processor which attribute value it belongs to pPathProc->SetParentAttribute(pAttrBrushType); return pAttrBrushType; }

void BrushAttrItem::DrawItem (  RenderRegion *  pRegion, const DocRect &  drBounds )  const [protected, virtual]

Draws this item within the bounding box. The aim is to work out what scaling we need in order to fit the brush into the FormatRect. Therefore we draw a line through the bounding box, get its bounding box with the brush applied and work out the scaling that will fit this into the formatrect. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/1/2000 Parameters: pRegion  pointer to the RenderRegion to draw into [INPUTS] drBounds reference to the bounding box rectangle to draw within -  [OUTPUTS] Returns: - Errors: - See also: LineAttrItem::Render Reimplemented from LineAttrItem. Definition at line 500 of file sgbrush.cpp. { if (m_pBrushAttrVal == NULL) { ERROR3("Wheres the AttrVal gone?"); return; } // Calculate the mid-point of the vertical sides of the bounding box. INT32 yMid = ((drBounds.lo.y + drBounds.hi.y) / 2) - (drBounds.Height() / 3); // Draw a line at this height from the left to the right edge. Path pthLinePath; if (pthLinePath.Initialise()) { pthLinePath.InsertMoveTo(DocCoord(drBounds.lo.x, yMid)); pthLinePath.InsertLineTo(DocCoord(drBounds.hi.x, yMid)); pthLinePath.IsFilled = FALSE; pthLinePath.IsStroked = TRUE; // Get the brush definition and the local path processor BrushDefinition* pBrushDef = m_pBrushAttrVal->GetBrushDefinition(); if (pBrushDef != NULL) { PathProcessorBrush* pPathProc = m_pBrushAttrVal->GetPathProcessor(); if (pPathProc == NULL) { ERROR3("No brush definition"); return; } MILLIPOINT LineWidth = 18000; pPathProc->ScaleToValue(LineWidth); pRegion->SetLineWidth(LineWidth); // render the attribute, i.e. push the path processor m_pBrushAttrVal->Render(pRegion, FALSE); // draw the line pRegion->DrawPath(&pthLinePath); } else // no actual brush - just draw the line pRegion->DrawPath(&pthLinePath); } else ERROR3("Failed to initialise path"); }

CCRuntimeClass ** BrushAttrItem::GetAttribRuntimeClasses (   )  const [protected, virtual]

Used when searching for display items representing the selection's current attributes. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 3/3/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: The run-time class of the line attribute this type of display item represents. Implements LineAttrItem. Definition at line 470 of file sgbrush.cpp. { static CCRuntimeClass* aprtc[] = { CC_RUNTIME_CLASS(AttrBrushType), NULL }; return aprtc; }

virtual BrushAttrValue* BrushAttrItem::GetBrushAttrValue (   )  [inline, virtual]

Definition at line 129 of file sgbrush.h. { return m_pBrushAttrVal;}

BrushDefinition * BrushAttrItem::GetBrushDefinition (  void   )  [virtual]

Get the BrushDefinition for this item. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/2000 Returns: The BrushDefinition for this item Definition at line 309 of file sgbrush.cpp. { BrushHandle Handle = GetBrushHandle(); if(Handle != BrushHandle(-1)) { // get the brush component Document* pDoc = Document::GetCurrent(); ERROR2IF(pDoc == NULL, NULL, "Wheres the document?"); BrushComponent* pBrushComp = (BrushComponent*)pDoc->GetDocComponent(CC_RUNTIME_CLASS(BrushComponent)); ERROR2IF(pBrushComp == NULL, NULL, "No brush component"); return pBrushComp->FindBrushDefinition(Handle); } return NULL; }

BrushHandle BrushAttrItem::GetBrushHandle (  void   )  [virtual]

Get the BrushHandle for this item. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/2000 Returns: The BrushHandle for this item, or BrushHandle_NoBrush if strife Definition at line 337 of file sgbrush.cpp. { BrushAttrValue *pAttrValue = GetBrushAttrValue(); if(pAttrValue != NULL) { PathProcessorBrush *pProcessor = pAttrValue->GetPathProcessor(); if (pProcessor != NULL && pProcessor->IsKindOf(CC_RUNTIME_CLASS(PathProcessorBrush))) { BrushHandle Handle = ((PathProcessorBrush *)pProcessor)->GetBrushDefinitionHandle(); return Handle; } } return BrushHandle_NoBrush; }

BrushHandle BrushAttrItem::GetCurrentDefaultBrushHandle (   )  [protected]

as above Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 10/10/99 Returns: the handle of the current defalt brush attribute Definition at line 706 of file sgbrush.cpp. { Document* pDoc = Document::GetCurrent(); if (pDoc == NULL) { ERROR3("No document"); return BrushHandle_NoBrush; } AttributeManager* pAttrMgr = &(pDoc->GetAttributeMgr()); if (pAttrMgr == NULL) { ERROR3("No attribute manager"); return BrushHandle_NoBrush; } AttrBrushType* pAttr = (AttrBrushType*)(pAttrMgr->GetCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), CC_RUNTIME_CLASS(AttrBrushType))); if (pAttr == NULL) { ERROR3("No current brush attribute"); return BrushHandle_NoBrush; } return pAttr->GetBrushHandle(); }

BOOL BrushAttrItem::IsEqualValueToAny (  NodeAttribute **  ppOtherAttribs  )  const [virtual]

Used when searching for display items representing the selection's current attributes. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 7/1/2000 Parameters: pOtherAttrib  - the attribute value to compare this item to [INPUTS] -  [OUTPUTS] Returns: TRUE if this item represents the same attribute value as the given attribute. Implements LineAttrItem. Definition at line 273 of file sgbrush.cpp. { if (*ppOtherAttribs == NULL) // When multiple attribs are selected, this will be NULL return(FALSE); AttrBrushType* pAttr = (AttrBrushType *) *ppOtherAttribs; ERROR3IF(!pAttr->IsKindOf(CC_RUNTIME_CLASS(AttrBrushType)), "BrushAttrItem::IsEqualValueToAny - unexpected object type"); if (pAttr != NULL) { BrushAttrValue *pOther = (BrushAttrValue *) pAttr->GetAttributeValue(); //return((*m_pBrushAttrVal) == (*pOther)); // to simplify - just check to see if they have the same brush handle BrushHandle Other = pOther->GetBrushHandle(); BrushHandle This = m_pBrushAttrVal->GetBrushHandle(); return (Other == This); } return(FALSE); }

BOOL BrushAttrItem::ItemSelected (  NodeAttribute *  pAttrBrush  )  [virtual]

Sets the default line width to be that of the brush, or the previous line width if the brush doesn't have one. Also broadcasts a message saying that it has been selected, for the benefit of the freehand tool. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 9/1/2000 Inputs; pNewAttr - the attribute node created from this BrushAttrItem Parameters: -  [OUTPUTS] Returns: FALSE, if all went well and we applied the attributes here ok Reimplemented from LineAttrItem. Definition at line 563 of file sgbrush.cpp. { if (m_pBrushAttrVal == NULL) { ERROR3("BrushAttrValue is NULL"); return TRUE; } // if we are setting a 'no brush' brush we must restore its line width to the last // line width set that had 'no brush' BOOL bSettingNoBrush = (m_pBrushAttrVal->GetBrushHandle() == BrushHandle_NoBrush); // if there is something in the selection then we do not want to change // the line width, as they may be different. the only exception to this is // if we are setting the default 'no brush' SelRange* pSel = GetApplication()->FindSelection(); if (pSel == NULL) return TRUE; if (pSel->FindFirst() != NULL) { if (!bSettingNoBrush) return TRUE; } MILLIPOINT OldLineWidth = 500; // initialise to default // first make sure the line gallery has its previous line width member set LineGallery* pLineGal = LineGallery::GetInstance(); if (pLineGal == NULL) return TRUE; else { // get the last line width in case we need it OldLineWidth = pLineGal->GetPreviousLineWidth(); // if we are going from a 'no brush' to a brush then we need to store the line // width of the 'no brush' if ((GetCurrentDefaultBrushHandle() == BrushHandle_NoBrush) && (!bSettingNoBrush)) pLineGal->SetPreviousLineWidth(); } // get the line width from the attribute MILLIPOINT LineWidth = m_pBrushAttrVal->GetDefaultLineWidth(TRUE); // if we receive < 0 from GetDefaultLineWidth it means that we have no // ink objects associated with this brush. In this instance it means we // are probably selecting the 'simple line' brush and should set the old line // width if (LineWidth <= 0) { if (OldLineWidth < 0) { ERROR3("negative line width"); return TRUE; } else LineWidth = OldLineWidth; } // quick hack until the problems in attrmgr.cpp with applying non-text attributes in the // text tool are sorted out if (Tool::GetCurrentID() == TOOLID_TEXT) return FALSE; // make a new line width node NodeAttribute* pNewAttr = new AttrLineWidth; if (pNewAttr == NULL) { ERROR3("Failed to allocate new line width"); return TRUE; } ((AttrLineWidth*)pNewAttr)->Value.LineWidth = LineWidth; // in order to apply the attributes together we need to make a list List AttribsList; NodeAttributePtrItem* pBrushAttrPtr = new NodeAttributePtrItem; if (pBrushAttrPtr == NULL) { delete pNewAttr; return TRUE; } pBrushAttrPtr->NodeAttribPtr = pAttrBrush; AttribsList.AddHead(pBrushAttrPtr); NodeAttributePtrItem* pLineWidthPtr = new NodeAttributePtrItem; if (pLineWidthPtr == NULL) { pBrushAttrPtr->NodeAttribPtr = NULL; return TRUE; } pLineWidthPtr->NodeAttribPtr = pNewAttr; AttribsList.AddHead(pLineWidthPtr); AttributeManager::AttributesSelected(AttribsList, _R(IDS_APPLYBRUSH_UNDO)); // We don't need the list of attrs anymore NodeAttributePtrItem* pAttrItem = (NodeAttributePtrItem*)AttribsList.GetHead(); while (pAttrItem) { delete (pAttrItem->NodeAttribPtr); pAttrItem->NodeAttribPtr = NULL; pAttrItem = (NodeAttributePtrItem*)AttribsList.GetNext(pAttrItem); } AttribsList.DeleteAll(); // tidyup BrushHandle NewHandle = GetBrushHandle(); BROADCAST_TO_ALL(BrushMsg(NewHandle)); return FALSE; }

void BrushAttrItem::RenderItem (  RenderRegion *  pRender, DocRect *  pDocRect, INT32  Width = c_nDefaultLineWidth )  [virtual]

Renders a representation of the stroke into the given renderregion. This is used by the line properties dialog since all the stuff needed seems to be private... Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 9/1/2000 Parameters: pRender  - RenderRegion to render into [INPUTS] pDocRect - Rectangle to render Definition at line 370 of file sgbrush.cpp. { if(pRender == NULL || pDocRect == NULL) { ERROR3("BrushAttrItem::RenderItem given null params"); return; } pRender->SaveContext(); // Make sure we're anti-aliasing Quality AntiAliasQuality(Quality::QualityMax); QualityAttribute AntiAliasQualityAttr(AntiAliasQuality); pRender->SetQuality(&AntiAliasQualityAttr,FALSE); // Render the background rectangle DialogColourInfo RedrawColours; pRender->SetLineColour(RedrawColours.DialogBack()); pRender->SetFillColour(RedrawColours.DialogBack()); pRender->DrawRect(pDocRect); // Draw the Saturation vs. Value square Path SquarePath; LinearFillAttribute ValueGradFill; LinearTranspFillAttribute TransFill; ValueGradFill.Colour = DocColour(255L, 0L, 0L); ValueGradFill.EndColour = DocColour(255L, 255L, 255L); DocCoord ThePoint(pDocRect->lo.x, pDocRect->hi.y); ValueGradFill.SetStartPoint(&ThePoint); ThePoint = DocCoord(pDocRect->hi.x, pDocRect->hi.y); ValueGradFill.SetEndPoint(&ThePoint); ValueGradFill.SetEndPoint2(NULL); pRender->SetFillGeometry(&ValueGradFill, FALSE); // Set Grad-filled pRender->SetLineColour(RedrawColours.TextFore()); SetAttributes(pRender); pRender->SetLineWidth((INT32)((double)Width * 0.8)); DrawItem(pRender, *pDocRect); pRender->RestoreContext(); }

void BrushAttrItem::SetAttributes (  RenderRegion *  pRegion  )  const [protected, virtual]

Sets the brush attributes in the given render-region to render this item correctly. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 3/3/97 Parameters: pRegion  - the render-region to draw into [INPUTS] Implements LineAttrItem. Definition at line 182 of file sgbrush.cpp. { // code has been moved into DrawItem, as we need to know the bounding box // before we can make the scaling adjustment // Set a line width //pRegion->SetLineWidth(1000); // Set the line width (this overrides the "default" line width set by the caller). //m_pBrushAttrVal->Render(pRegion, FALSE); }

void BrushAttrItem::UpdateGalleryItem (   )  [virtual]

Updates the gallery item's cached data to represent any changes this Stoke might have had done to it. Also redraw the gallery if necessary. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 9/1/2000 Definition at line 431 of file sgbrush.cpp. { BrushDefinition *pBrush = GetBrushDefinition(); if(pBrush != NULL) { // first try and allocate a new PPB PathProcessorBrush* pNewPPB = new PathProcessorBrush; if (pNewPPB == NULL) return; // give it the latest data pBrush->CopyDataToProcessor(pNewPPB); // tell it what handle to use pNewPPB->SetBrushDefinition(m_pBrushAttrVal->GetBrushHandle()); //ask our attr to delete its path processor m_pBrushAttrVal->SetPathProcessor(pNewPPB); // set the new name SetDescription(pBrush->GetLineName()); } ForceRedrawOfMyself(); }

BOOL BrushAttrItem::UpdateProcessor (   )

---

Member Data Documentation

BrushAttrValue* BrushAttrItem::m_pBrushAttrVal [private]

Definition at line 155 of file sgbrush.h.

---

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

• Kernel/sgbrush.h (r1785/r751)
• Kernel/sgbrush.cpp (r1785/r1732)

---