FreeHandInfoBarOp Class Reference

Class for handling the FreeHand tool's information bar. More...

#include <freeinfo.h>

Inheritance diagram for FreeHandInfoBarOp:

List of all members.

Public Member Functions
	FreeHandInfoBarOp ()
	Sets the info bars vars to NULL defaults.
	~FreeHandInfoBarOp ()
	destructor
MsgResult	Message (Msg *Msg)
	Takes a look at the message and if it is for me it responds to it. Here the scroll bar for the freehand tool is Created and closed. It also responds to changes in the sliders position and tells the freehand tool to set its smoothing factor to something appropriate.
void	SetToolActiveState (BOOL IsToolActive)
	Allows the info bar to know if it is valid or not.
void	SetRetroState (BOOL CanRetroFit)
	Sets the Flag CanRetroFit and gets the infobar to redraw the static text item that says this.
void	SetRetroString ()
	Sets the static text item in the freehand info bar to say either 'Retro' or nothing, depending on the state of the flag CanRetroFit.
void	AddBrush ()
	Tells the infobar that a new brush has been added to the brush component. This function finds the last created brush and selects it as the head of the list of brushes to be displayed in the brush combo.
void	AddBrush (BrushHandle Handle)
	Overridden version of above function. In this version we specify the handle of the brush to add, plus we do not select the new brush.
virtual void	UpdateState ()
	Sets the state of button on the bar to keep them up to date.
BrushData	GetBrushDataFromSelection (BOOL *pSelEmpty=NULL)
	if there is one and only one brush in the selection the this function returns a brush data object representing its current state. If there is any other number then a data item is still returned but it will not be valid
void	SetDefaultStrokeInCombo ()
	Sets the bitmap showing in the brush combo to be that of the default stroke !!! Note - not actually working at the moment.
void	RemoveBrush (BrushHandle Handle)
	to remove the specified brush from the brush list
Static Public Member Functions
static CBrushGadget *	GetBrushGadget ()
Public Attributes
FreeHandTool *	pTool
BOOL	CanRetroFit
Protected Member Functions
BOOL	InitBrushList ()
	creates the brush list if it does not exist, if it already exists then we just empty it. Then we fill it with brush handles in the order that they exist in the brush component.
BOOL	ReInitBrushList ()
	This takes care of a situation where we might add a number of brushes at once and want to update the brush list without forgetting the order of the list. This kind of thing arises when we load in a new document. Anyway what we do is compare the number of brushes with the number of items in the list, and if there is a mismatch we add the new ones to the end of the list.
BOOL	SetBrushListToControl ()
	Goes through the brush list in order, creating attribute nodes from the brush handles and setting them into the combo.
BOOL	SetStrokesToControl ()
	Creates stroke shape items and adds them to the stroke combo.
void	HandleBrushSelectChange ()
	Called when a DIM_SELECTION message is received from _R(IDC_BRUSHTYPE).
void	HandleCreate ()
	Called when a DIM_CREATE message is received.
void	HandleSliderPosChanging ()
	Called when a SLIDER_POS_CHANGING message is received.
void	HandleStrokeSelectChange ()
	Called when a DIM_SELECTION message is received from _R(IDC_STROKETYPE).
void	LaunchBrushEditDialog ()
void	SetHeadOfListSelected ()
void	SetDisplayBrush ()
void	SetBrushComboFromSelection ()
BrushHandle	GetBrushHandleFromSelection (BOOL *pSelEmpty=NULL)
	To find out if there are any brushed objects in the selection.
void	SetStrokeComboFromSelection ()
INT32	GetStrokeIndexFromValueFunctionID (ValueFunctionID ID)
	Bit of a last minute bodge this, as we are trying to implement a small subset of the value functions into the stroke combo at fixed indexes. We will map the ValueFunctionID used by the ValueFunctions to the index into the combo.
BrushHandle	GetBrushHandleFromControlIndex (BrushHandle Index)
	Retrieves the brushhandle of the Indexth item in the list.
INT32	GetControlIndexFromBrushHandle (BrushHandle Handle)
	Retrieves the list position of the handle.
void	SetHeadOfList (BrushHandle Handle)
	Sets the given handle to the head of the 'most popular brush' list, also goes through the rest of the list and removes other instances of it, so as not to duplicate.
Protected Attributes
BOOL	ControlsExist
BOOL	DropDownInited
INT32	m_LastSmoothness
BrushList *	m_pBrushList
BrushHandle	m_DisplayBrush
CBitmapGridDropDown	m_bgddBrushType
CBitmapGridDropDown	m_bgddStrokes
INT32	m_SelectedStroke
Static Protected Attributes
static CBrushGadget	BrushGadget

---

Detailed Description

Class for handling the FreeHand tool's information bar.

Author:

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

Date:

28/4/94

Definition at line 127 of file freeinfo.h.

---

Constructor & Destructor Documentation

FreeHandInfoBarOp::FreeHandInfoBarOp (   )

Sets the info bars vars to NULL defaults. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 30/8/94 Definition at line 200 of file freeinfo.cpp. { DlgResID = _R(IDD_FREEHANDTOOL); // Don't know about the tool and can not retro fit to start with pTool = NULL; CanRetroFit = FALSE; // The Controls hasve not been created yet ControlsExist = FALSE; m_pBrushList = NULL; m_DisplayBrush = BrushHandle_NoBrush; /* m_pStrokeList = NULL; m_DisplayStroke = StrokeHandle_NoStroke; */ m_SelectedStroke = CONSTANT; // we want to start by displaying the constant stroke }

FreeHandInfoBarOp::~FreeHandInfoBarOp (   )

destructor Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 18/5/2000 Definition at line 234 of file freeinfo.cpp. { if (m_pBrushList != NULL) { m_pBrushList->clear(); delete m_pBrushList; m_pBrushList = NULL; } /* if (m_pStrokeList != NULL) { m_pStrokeList->RemoveAll(); delete m_pStrokeList; m_pStrokeList = NULL; } */ }

---

Member Function Documentation

void FreeHandInfoBarOp::AddBrush (  BrushHandle  Handle  )

Overridden version of above function. In this version we specify the handle of the brush to add, plus we do not select the new brush. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: Handle  of the brush to add [INPUTS] Returns: - Definition at line 612 of file freeinfo.cpp. { // Simply add this to the head of the list if (m_pBrushList == NULL) { // we might get here on start-up before the list is generated so just leave return; } m_pBrushList->push_back(Handle); if (ControlsExist) { SetBrushListToControl(); SetDisplayBrush(); } }

void FreeHandInfoBarOp::AddBrush (   )

Tells the infobar that a new brush has been added to the brush component. This function finds the last created brush and selects it as the head of the list of brushes to be displayed in the brush combo. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: -  [INPUTS] Returns: - Definition at line 578 of file freeinfo.cpp. { UINT32 BrushNum = BrushComponent::GetNumberOfBrushes() - 1; // Simply add this to the head of the list if (m_pBrushList == NULL) { ERROR3("Brush list is null in FreeHandInfoBarOp::AddBrush"); } SetHeadOfList((BrushHandle)BrushNum); m_DisplayBrush = 2; // display the new list if (ControlsExist) { SetBrushListToControl(); SetHeadOfListSelected(); } }

BrushData FreeHandInfoBarOp::GetBrushDataFromSelection (  BOOL *  pSelEmpty = NULL  )

if there is one and only one brush in the selection the this function returns a brush data object representing its current state. If there is any other number then a data item is still returned but it will not be valid Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: -  [INPUTS] pSelectionEmpty  - flag is set if the selection is empty [OUTPUTS] Returns: brush data object representing a selected brush, you can tell if there are no real brushes selected by looking at the m_BrushHandle member of the returned data Definition at line 1644 of file freeinfo.cpp. { // find all the brushes in the current selection List NodeList; BevelTools::BuildListOfSelectedNodes(&NodeList, CC_RUNTIME_CLASS(AttrBrushType)); BrushData Data; // initialises to default values INT32 NumItems = NodeList.GetCount(); // we can only retrieve a valid data item if there is a single item selected, // if there is any other number then we must return switch (NumItems) { case 0: if (pSelEmpty != NULL) *pSelEmpty = TRUE; NodeList.DeleteAll(); return Data; case 1: if (pSelEmpty != NULL) *pSelEmpty = FALSE; break; default: if (pSelEmpty != NULL) *pSelEmpty = FALSE; NodeList.DeleteAll(); return Data; } // we've got an item, so find its applied brush attribute NodeListItem * pItem = (NodeListItem *)NodeList.GetHead(); if (pItem) { Node* pBrush = pItem->pNode; if (pBrush) { AttrBrushType* pAttrBrush = (AttrBrushType*)pBrush; if (pAttrBrush->GetBrushHandle() != BrushHandle_NoBrush) { Data = pAttrBrush->GetBrushData(); } } } NodeList.DeleteAll(); return Data; }

static CBrushGadget* FreeHandInfoBarOp::GetBrushGadget (   )  [inline, static]

Definition at line 155 of file freeinfo.h. { return &BrushGadget;}

BrushHandle FreeHandInfoBarOp::GetBrushHandleFromControlIndex (  BrushHandle  Index  )  [protected]

Retrieves the brushhandle of the Indexth item in the list. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: Index  - the index selected from _R(IDC_BRUSHTYPE) [INPUTS] Returns: the brush handle in our 'most popular brushes' list Definition at line 2521 of file freeinfo.cpp. { BrushHandle RetVal = BrushHandle_NoBrush; if (m_pBrushList != NULL) { size_t i = (size_t)Index; // No, I don't know why it's declared to take a BrushHandle - bizarre - amb if (i<m_pBrushList->size()) { BrushList::const_iterator iter = m_pBrushList->begin(); for (size_t n=0; n<i; n++) iter++; return *iter; } } return RetVal; }

BrushHandle FreeHandInfoBarOp::GetBrushHandleFromSelection (  BOOL *  pSelEmpty = NULL  )  [protected]

To find out if there are any brushed objects in the selection. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: -  [INPUTS] pSelectionEmpty  - flag is set if the selection is empty [OUTPUTS] Returns: handle of the brush in the selection. Note that if there are many different brushes selected then BrushHandle_NoBrush will be returned Definition at line 1707 of file freeinfo.cpp. { // find all the brushes in the current selection List NodeList; BevelTools::BuildListOfSelectedNodes(&NodeList, CC_RUNTIME_CLASS(AttrBrushType), TRUE); BrushData Data; // initialises to default values INT32 NumItems = NodeList.GetCount(); BrushHandle SelHandle = BrushHandle_NoBrush; if (NumItems != 0) { if (pSelEmpty !=NULL) *pSelEmpty = FALSE; // we've got an item, so find its applied brush attribute NodeListItem * pItem = (NodeListItem *)NodeList.GetHead(); // BrushHandle LastHandle = BrushHandle_NoBrush; BOOL bFirst = TRUE; AttrBrushType* pAttrBrush = NULL; Node* pBrush = NULL; while (pItem) { pBrush = pItem->pNode; if (pBrush) { pAttrBrush = (AttrBrushType*)pBrush; if (bFirst) { SelHandle = pAttrBrush->GetBrushHandle(); bFirst = FALSE; } else { // if we have different brushes then show the 'many' string if (pAttrBrush->GetBrushHandle() != SelHandle) { SelHandle = BrushHandle_Many; break; } } } pItem = (NodeListItem *)NodeList.GetNext(pItem); } } else { // see if we actually have anything in the selection SelRange* pSel = GetApplication()->FindSelection(); if (pSel && pSel->IsEmpty()) { if (pSelEmpty != NULL) *pSelEmpty = TRUE; } } NodeList.DeleteAll(); return SelHandle; }

INT32 FreeHandInfoBarOp::GetControlIndexFromBrushHandle (  BrushHandle  Handle  )  [protected]

Retrieves the list position of the handle. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: Handle  - the brush handle that we want to locate [INPUTS] Returns: the position of Handle within our brush list, or - 1 if its not there Definition at line 2549 of file freeinfo.cpp. { INT32 Retval = -1; if (m_pBrushList != NULL) { INT32 Counter = 0; BrushList::const_iterator iter; for (iter = m_pBrushList->begin(); iter != m_pBrushList->end(); iter++) { if (*iter == Handle) { Retval = Counter; break; } Counter++; } } return Retval; }

INT32 FreeHandInfoBarOp::GetStrokeIndexFromValueFunctionID (  ValueFunctionID  ID  )  [protected]

Bit of a last minute bodge this, as we are trying to implement a small subset of the value functions into the stroke combo at fixed indexes. We will map the ValueFunctionID used by the ValueFunctions to the index into the combo. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: ID  of the value function [INPUTS] Returns: the corresponding index of this stroke into the stroke combo, if we get an unrecognised ID to be on the safe side we will return CONSTANT Definition at line 2395 of file freeinfo.cpp. { INT32 ReturnVal = CONSTANT; // if we get an invalid ID we will just stick to this switch (ID) { case ValueFunctionID_None: break; case ValueFunctionID_Constant: break; case ValueFunctionID_RampS: ReturnVal = RAMPS; break; case ValueFunctionID_RampS2: ReturnVal = RAMPS2; break; case ValueFunctionID_Teardrop: ReturnVal = TEARDROP; break; case ValueFunctionID_Ellipse: ReturnVal = ELLIPSE; break; case ValueFunctionID_Blip: ReturnVal = BLIP; break; case ValueFunctionID_RampL: ReturnVal = RAMPL; break; case ValueFunctionID_RampL2: ReturnVal = RAMPL2; break; case ValueFunctionID_DoubleRampS: ReturnVal = DOUBLERAMPS; break; case ValueFunctionID_TeardropCurvedEnd: ReturnVal = TEARDROPCURVEDEND; break; case ValueFunctionID_SawTooth: ReturnVal = SAWTOOTH; break; case ValueFunctionID_Propeller: ReturnVal = PROPELLER; break; case ValueFunctionID_Intestine: ReturnVal = INTESTINE; break; case ValueFunctionID_Decay: ReturnVal = DECAY; break; case ValueFunctionID_BevelEnds: ReturnVal = BEVELENDS; break; case ValueFunctionID_SS_Yacht: ReturnVal = SS_Yacht; break; case ValueFunctionID_SS_Iron: ReturnVal = SS_Iron; break; case ValueFunctionID_SS_Reed: ReturnVal = SS_Reed; break; case ValueFunctionID_SS_Meteor: ReturnVal = SS_Meteor; break; case ValueFunctionID_SS_Petal: ReturnVal = SS_Petal; break; case ValueFunctionID_SS_Comet: ReturnVal = SS_Comet; break; case ValueFunctionID_SS_Fallout: ReturnVal = SS_Fallout; break; case ValueFunctionID_SS_Torpedo: ReturnVal = SS_Torpedo; break; case ValueFunctionID_SS_Missile: ReturnVal = SS_Missile; break; case ValueFunctionID_SS_Convex: ReturnVal = SS_Convex; break; case ValueFunctionID_SS_Concave: ReturnVal = SS_Concave; break; case ValueFunctionID_SS_SlimBlip: ReturnVal = SS_SlimBlip; break; case ValueFunctionID_SS_Cigar: ReturnVal = SS_Cigar; break; case ValueFunctionID_SS_Cigar2: ReturnVal = SS_Cigar2; break; case ValueFunctionID_SS_Cigar3: ReturnVal = SS_Cigar3; break; case ValueFunctionID_SS_OceanLiner: ReturnVal = SS_OceanLiner; break; case ValueFunctionID_SS_Goldfish: ReturnVal = SS_Goldfish; break; case ValueFunctionID_SS_Barb: ReturnVal = SS_Barb; break; default: ERROR3("Illegal ValueFunction ID"); break; } return ReturnVal; }

void FreeHandInfoBarOp::HandleBrushSelectChange (   )  [protected]

Called when a DIM_SELECTION message is received from _R(IDC_BRUSHTYPE). Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: -  [INPUTS] Returns: - Notes: 10/10/2000 We have been through a few variants of this, but the current version is that when we select a brush from the drop down it is selected to draw with as well as being used to apply to the selection. Definition at line 755 of file freeinfo.cpp. { //#ifdef BUILDNEWBRUSHES // if we don't have a document then forget it, though its not erroneous Document* pDoc = Document::GetCurrent(); if (!pDoc) return; // Someone selected a new brush INT32 iIndex = m_bgddBrushType.GetSelected(); BrushHandle SelHandle; // the zeroth index is always reserved for the 'no-brush' // if (iIndex == 0) // SelHandle = BrushHandle_NoBrush; // else SelHandle = GetBrushHandleFromControlIndex(iIndex); //TRACEUSER( "Diccon", _T("Brush Combo: Handle = %d, Index = %d\n"), SelHandle, Index); // tell the tool our selection has changed if (pTool != NULL) { pTool->SetBrushUpdateState(UPDATE_ONIDLE); pTool->BrushSelected(SelHandle); } if (SelHandle != BrushHandle_NoBrush) { SetHeadOfList(SelHandle); SetBrushListToControl(); m_DisplayBrush = SelHandle; // TRACEUSER( "Diccon", _T("Brush Combo: Handle = %d, Index = %d\n"), SelHandle, Index);SetBrushListToControl(); SetHeadOfListSelected(); } else { m_DisplayBrush = SelHandle; // SetDisplayBrush(); } //#endif }

void FreeHandInfoBarOp::HandleCreate (   )  [protected]

Called when a DIM_CREATE message is received. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: -  [INPUTS] Returns: - Definition at line 677 of file freeinfo.cpp. { if (WindowID!=NULL) { // Set the state of the pressure button according to the Op's state. // Why buttons on infobars can't dynamically auto-connect to their ops is beyond me UpdateState(); // Set the range of the control SetGadgetRange(_R(IDC_FREEHANDSLIDER), 0, 100, 5); SetGadgetBitmaps(_R(IDC_FREEHANDSLIDER), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); // and its position INT32 Smoothness = 50; if (pTool!=NULL) Smoothness = pTool->GetSmoothness(); SetLongGadgetValue(_R(IDC_FREEHANDSLIDER), Smoothness); // Set the percentage string TCHAR Str[32]; String_32 jcf(_R(IDS_PERCENT_FORMAT)); camSnprintf(Str, 32, jcf, (INT32) Smoothness); String_32 PercentStr(Str); SetStringGadgetValue(_R(IDC_FREEHANDPERCENT), PercentStr); // Set the Retro field (Will be empty initially) if (pTool!=NULL) CanRetroFit = pTool->IsRetroPathStillValid(); SetRetroString(); // only initialise the brush list once otherwise we upset the order if (m_pBrushList == NULL || m_pBrushList->size() == 0) InitBrushList(); // Create the brush type combobox. m_bgddBrushType.Init(WindowID, _R(IDC_BRUSHTYPE)); m_bgddBrushType.SetColumns(3); m_bgddBrushType.SetItemSize(wxSize(75, 40)); // Create the stroke type combobox. m_bgddStrokes.Init(WindowID, _R(IDC_STROKETYPE)); m_bgddStrokes.SetColumns(3); m_bgddStrokes.SetItemSize(wxSize(50, 50)); // create our brush list objects and put them in the control SetBrushListToControl(); // make sure the combo shows the right thing SetBrushComboFromSelection(); //#ifdef BUILDNEWBRUSHES // set up the brush gadget PORTNOTE("other", "Disabled BrushGadget") #ifndef EXCLUDE_FROM_XARALX BrushGadget.LinkControlButton (this, _R(IDC_EDITBRUSH), _R(IDBBL_BRUSHEDIT), _R(IDS_BRUSHEDITDLG)); BrushGadget.DisableTimeStamping (); #endif //#endif } // Mark the controls as existing ControlsExist = TRUE; }

void FreeHandInfoBarOp::HandleSliderPosChanging (   )  [protected]

Called when a SLIDER_POS_CHANGING message is received. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: -  [INPUTS] Returns: - Definition at line 1581 of file freeinfo.cpp. { // Find the current scrollers position TCHAR Str[32]; BOOL Valid; INT32 Result = GetLongGadgetValue(_R(IDC_FREEHANDSLIDER), 0, 100, 0, &Valid); // Build the Percentage string and set it String_32 jcf(_R(IDS_PERCENT_FORMAT)); camSnprintf(Str, 32, jcf, (INT32) Result); String_8 PercentStr(Str); SetStringGadgetValue(_R(IDC_FREEHANDPERCENT), PercentStr); // Tell the freehand tool about the new smoothness if (Valid) { // Set the smoothness and re-fit the path if possible pTool->SetSmoothness(Result); pTool->RetroFitChanging(); } }

void FreeHandInfoBarOp::HandleStrokeSelectChange (   )  [protected]

Called when a DIM_SELECTION message is received from _R(IDC_STROKETYPE). Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: -  [INPUTS] Returns: - Definition at line 814 of file freeinfo.cpp. { // if we don't have a document then forget it, though its not erroneous Document* pDoc = Document::GetCurrent(); if (!pDoc) return; // Someone selected a new brush INT32 Index = m_bgddStrokes.GetSelected(); // what we are going to do is apply a stroke attribute and a variable width attribute at the // same time via the attribute manager. This will require making a list List AttribsList; // create new list items NodeAttributePtrItem* pStrokeItem = new NodeAttributePtrItem; if (pStrokeItem == NULL) { ERROR3("Unable to create new stroke item in FreeHandInfoBarOp::HandleStrokeSelectChange"); return; } NodeAttributePtrItem* pVarWidthItem = new NodeAttributePtrItem; if (pVarWidthItem == NULL) { ERROR3("Unable to create new variable width item in FreeHandInfoBarOp::HandleStrokeSelectChange"); delete pStrokeItem; return; } NodeAttribute* pVarWidth = NULL; NodeAttribute* pStrokeType = NULL; // now make a pathprocessor and a stroke attribute, note that if we apply a CONSTANT stroke we don't need to PathProcessorStroke* PPS = NULL; if (Index != CONSTANT) { PPS = new PathProcessorStroke; if (PPS == NULL) { ERROR3("Unable to create new path processor in FreeHandInfoBarOp::HandleStrokeSelectChange"); delete pStrokeItem; delete pVarWidthItem; return; } } StrokeTypeAttrValue NewStroke(PPS); pStrokeType = NewStroke.MakeNode(); if (pStrokeType == NULL) { ERROR3("Unable to create new stroke attribute in FreeHandInfoBarOp::HandleStrokeSelectChange"); delete pStrokeItem; delete pVarWidthItem; delete PPS; return; } pStrokeItem->NodeAttribPtr = pStrokeType; switch (Index) { case CONSTANT: { // Create a default variable width value (should get optimised out when applied to the doc) VariableWidthAttrValue VarWidth; // creates a CONSTANT variable width pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pVarWidthItem; return; } } break; case RAMPL: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionRampL); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case RAMPL2: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionRampL2); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case RAMPS: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionRampS); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case RAMPS2: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionRampS2); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case BLIP: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionBlip); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case ELLIPSE: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionEllipse); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case TEARDROP: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionTeardrop); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case TEARDROPCURVEDEND: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionTeardropCurvedEnd); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case DOUBLERAMPS: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionDoubleRampS); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SAWTOOTH: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSawTooth); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case PROPELLER: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionPropeller); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case INTESTINE: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionIntestine); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case DECAY: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionDecay); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case BEVELENDS: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionBevelEnds); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Yacht: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Yacht); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Iron: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Iron); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Reed: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Reed); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Meteor: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Meteor); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Petal: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Petal); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Comet: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Comet); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Fallout: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Fallout); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Torpedo: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Torpedo); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Missile: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Missile); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Convex: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Convex); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Concave: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Concave); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_SlimBlip: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_SlimBlip); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Cigar: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Cigar); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Cigar2: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Cigar2); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Cigar3: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Cigar3); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_OceanLiner: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_OceanLiner); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Goldfish: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Goldfish); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; case SS_Barb: { // create our attrval with a valuefunction VariableWidthAttrValue VarWidth(new ValueFunctionSS_Barb); pVarWidth = VarWidth.MakeNode(); if (pVarWidth) { pVarWidthItem->NodeAttribPtr = pVarWidth; } else { delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; return; } } break; default: { ERROR3("Unrecognised stroke type in HandleStrokeSelectChange"); delete pStrokeItem; delete pVarWidthItem; delete pStrokeType; m_SelectedStroke = CONSTANT; return; } } // now if the selection is empty then we want to update our selected stroke member SelRange* pSel = GetApplication()->FindSelection(); if (pSel) { // recall that the indexes in the control are 1 greater than our enum constants if (pSel->IsEmpty()) m_SelectedStroke = Index; // update the selection bounds pSel->UpdateParentBoundsOfSelection(); } // OK so now we should have two ListItems to add to the list, or only one if // its a CONSTANT stroke if (pStrokeItem != NULL) AttribsList.AddTail(pStrokeItem); if (pVarWidthItem != NULL) AttribsList.AddTail(pVarWidthItem); // apply those attributes! AttributeManager::AttributesSelected(AttribsList, _R(IDS_STROKEAPPLY_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 }

BOOL FreeHandInfoBarOp::InitBrushList (   )  [protected]

creates the brush list if it does not exist, if it already exists then we just empty it. Then we fill it with brush handles in the order that they exist in the brush component. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: -  [INPUTS] Returns: true, unless we failed to get a new Definition at line 1778 of file freeinfo.cpp. { if (m_pBrushList == NULL) m_pBrushList = new BrushList; if (m_pBrushList == NULL) return FALSE; m_pBrushList->clear(); UINT32 NumBrushes = BrushComponent::GetNumberOfBrushes(); for (UINT32 Index = 0; Index < NumBrushes; Index++) { BrushHandle Handle = Index; m_pBrushList->push_back(Handle); } return TRUE; }

void FreeHandInfoBarOp::LaunchBrushEditDialog (   )  [protected]

Definition at line 1616 of file freeinfo.cpp. { // launch the dialog OpDescriptor* pDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_BRUSHEDIT_DLG); if (pDesc != NULL) { pDesc->Invoke(); } }

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

Takes a look at the message and if it is for me it responds to it. Here the scroll bar for the freehand tool is Created and closed. It also responds to changes in the sliders position and tells the freehand tool to set its smoothing factor to something appropriate. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 12/5/94 Parameters: Message  - A dialog message [INPUTS] Returns: The result of the message Reimplemented from InformationBarOp. Definition at line 269 of file freeinfo.cpp. { if (IS_OUR_DIALOG_MSG(Message)) { DialogMsg* Msg = (DialogMsg*)Message; // Check if the message is a CANCEL if (Msg->DlgMsg == DIM_CANCEL) { // Mark the controls as no longer existing ControlsExist = FALSE; // Close the dialog Close(); } else if (Msg->DlgMsg == DIM_CREATE) { #if 0 // NB - not #ifndef #ifdef EXCLUDE_FROM_XARALX EnableGadget(_R(IDC_CREATEBRUSH), FALSE); EnableGadget(_R(IDC_EDITBRUSH), FALSE); #endif #endif HandleCreate(); } else { if (FALSE) {} // WEBSTER - markn 25/4/97 // No pen presure stuff required in Webster // Taken out by vector stroking code Neville 2/10/97 #ifdef VECTOR_STROKING else if (Msg->GadgetID == _R(IDC_FREEHANDPRESSURE)) { if (Msg->DlgMsg == DIM_LFT_BN_CLICKED) { OpDescriptor *pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_TOGGLEPRESSURE); if (pOpDesc != NULL) { pOpDesc->Invoke(); UpdateState(); } } } #endif // VECTOR_STROKING else if (Msg->GadgetID == _R(IDC_FREEHANDSLIDER)) { switch (Msg->DlgMsg) { case DIM_SLIDER_POS_CHANGING: { HandleSliderPosChanging(); break; } case DIM_SLIDER_POS_SET: { // Tell the tool that things are all finished with pTool->RetroFitFinished(); break; } default: break; } } else if (Msg->GadgetID == _R(IDC_CREATEBRUSH)) { pTool->CreateBrush(); UpdateState(); } else if (Msg->GadgetID == _R(IDC_EDITBRUSH)) { switch (Msg->DlgMsg) { case DIM_LFT_BN_CLICKED: { LaunchBrushEditDialog(); break; } default: break; } } else if (Msg->GadgetID == _R(IDC_BRUSHTYPE)) { switch (Msg->DlgMsg) { case DIM_SELECTION_CHANGED: { HandleBrushSelectChange(); UpdateState(); break; } default: break; } } else if (Msg->GadgetID == _R(IDC_STROKETYPE)) { switch (Msg->DlgMsg) { case DIM_SELECTION_CHANGED: { HandleStrokeSelectChange(); //UpdateState(); break; } default: break; } } } } else { // Handle non dialog messages in here if (ControlsExist && Message->IsKindOf(CC_RUNTIME_CLASS(SelChangingMsg))) { // Yep, we had better go an see if the retro path field is still valid if (pTool!=NULL) { // Find out if we can still do the retro fitting stuff CanRetroFit = pTool->IsRetroPathStillValid(); // set the string in the info bar SetRetroString(); } } // the following is required because the brushes do NOT exist until the document has // been created! We need to init brushes in three cases: // 1) THIS infobar is made active by the user - brushes inited via DIM_CREATE // 2) THIS infobar was the last used infobar when camelot quit - which means it will // be the first one created; occuring BEFORE the document has been created! // 3) Someone has edited the brush definition fron the line gallery, thereby changing the // appearance of the brushes. // we overcome this problem by detecting the documents BORNANDSTABLE and message if (ControlsExist) { if (IsVisible ()) // BUT only if the infobar is visible! { if (Message->IsKindOf(CC_RUNTIME_CLASS(DocChangingMsg))) { Document* pDoc = Document::GetCurrent(); BOOL EnableCombos = pDoc != NULL; if (!EnableCombos) { EnableGadget(_R(IDC_BRUSHTYPE), EnableCombos); EnableGadget(_R(IDC_STROKETYPE), EnableCombos); EnableGadget(_R(IDC_FREEHANDSLIDER), EnableCombos); } DocChangingMsg* pDocMsg = (DocChangingMsg*)Message; if (pDocMsg->State == DocChangingMsg::BORNANDSTABLE) { EnableGadget(_R(IDC_BRUSHTYPE), TRUE); EnableGadget(_R(IDC_STROKETYPE), TRUE); EnableGadget(_R(IDC_FREEHANDSLIDER), TRUE); if (m_pBrushList == NULL || m_pBrushList->size() == 0) InitBrushList(); else ReInitBrushList(); SetBrushListToControl (); } } else if (Message->IsKindOf(CC_RUNTIME_CLASS(BrushDefMsg))) { SetBrushListToControl(); // we've updated a brush definition so refresh SetHeadOfListSelected(); // the display } } } // if it is a brush selection message then pass the new handle on to the tool if (Message->IsKindOf(CC_RUNTIME_CLASS(BrushMsg))) // only pass it on if a) our tool is the current tool and b)we have a current document { BrushHandle SelHandle = ((BrushMsg*)Message)->m_BrushSelected; if (pTool != NULL) { pTool->SetBrushUpdateState(UPDATE_ONIDLE); pTool->BrushSelected(SelHandle, FALSE); } // tell the list it has a new head if (SelHandle != BrushHandle_NoBrush) SetHeadOfList(SelHandle); m_DisplayBrush = SelHandle; // display the new list if (ControlsExist) { SetBrushListToControl(); SetHeadOfListSelected(); } } // if it is a stroke message then update our combo if (Message->IsKindOf(CC_RUNTIME_CLASS(StrokeMsg)) && ControlsExist && IsVisible()) SetStrokeComboFromSelection(); // likewise if it is a screen change message if (Message->IsKindOf(CC_RUNTIME_CLASS(ScreenChangeMsg)) || Message->IsKindOf(CC_RUNTIME_CLASS(CurrentAttrChangedMsg)) || Message->IsKindOf(CC_RUNTIME_CLASS(BrushDefMsg))) { if (pTool != NULL && HasWindow() && (Document::GetCurrent() != NULL)) { pTool->ScreenChanged(TRUE); //((ScreenChangeMsg*)Message)->m_bClear); UpdateState(); } } if (Message->IsKindOf(CC_RUNTIME_CLASS(DocViewMsg))) { DocViewMsg* pDVM = (DocViewMsg*)Message; if (pDVM->State == DocViewMsg::SELCHANGED) pTool->ScreenChanged(TRUE); } // if it is a new brush then we need to update our list if (Message->IsKindOf(CC_RUNTIME_CLASS(NewBrushMsg))) { AddBrush(); if (pTool) { UINT32 BrushNum = BrushComponent::GetNumberOfBrushes() - 1; pTool->BrushSelected(BrushNum, FALSE); } } } // do we have a selection change message? if (MESSAGE_IS_A(Message, SelChangingMsg)) { Document* pDoc = Document::GetCurrent(); if (pDoc != NULL) { if (ControlsExist && IsVisible()) { // we may have just undone a brush edit, if the brush edit dialog is open then we // want to make sure it has the uptodate data. BrushData Data = GetBrushDataFromSelection(); if (Data.m_BrushHandle != BrushHandle_NoBrush) { PORTNOTE("other", "Disabled Brush editing") #ifndef EXCLUDE_FROM_XARALX if (BrushGadget.IsDialogOpen()) BrushGadget.ReInitialiseDialog(&Data); #endif } // also make sure our combo reflects the selection SetBrushComboFromSelection(); SetStrokeComboFromSelection(); } } // ask the tool to refresh its cache, as blobs will have changed if (pTool != NULL && HasWindow()) pTool->ScreenChanged(TRUE); } if (MESSAGE_IS_A(Message, ColourChangingMsg)) { ColourChangingMsg *TheMsg = (ColourChangingMsg *) Message; // handle the selected View's Colour Context is changing // e.g. if the show printer colours (plate) has changed if(TheMsg->State == ColourChangingMsg::SELVIEWCONTEXTCHANGE) { // ask the tool to refresh its cache // (so that the cache does not have the old colour in it // and the drawing will be agains the correct (current) // background!) if (pTool != NULL && HasWindow()) pTool->ScreenChanged(TRUE); } } // Pass message on return (InformationBarOp::Message(Message)); }

BOOL FreeHandInfoBarOp::ReInitBrushList (   )  [protected]

This takes care of a situation where we might add a number of brushes at once and want to update the brush list without forgetting the order of the list. This kind of thing arises when we load in a new document. Anyway what we do is compare the number of brushes with the number of items in the list, and if there is a mismatch we add the new ones to the end of the list. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: -  [INPUTS] Returns: true, unless something goes wrong Definition at line 1816 of file freeinfo.cpp. { if (m_pBrushList == NULL) return InitBrushList(); UINT32 NumBrushes = BrushComponent::GetNumberOfBrushes(); UINT32 NumListBrushes = m_pBrushList->size(); while (NumListBrushes < NumBrushes) { m_pBrushList->push_back(NumListBrushes); NumListBrushes++; } return TRUE; }

void FreeHandInfoBarOp::RemoveBrush (  BrushHandle  Handle  )

to remove the specified brush from the brush list Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: Handle  - identifier of the brush to remove [INPUTS] Returns: - Definition at line 641 of file freeinfo.cpp. { // first remove it from the list if (m_pBrushList != NULL) { m_pBrushList->remove(Handle); } // now we want to display the no-brush m_DisplayBrush = BrushHandle_NoBrush; if (ControlsExist) { SetBrushListToControl(); SetDisplayBrush(); } // tell the tool if (pTool != NULL) { pTool->SetBrushUpdateState(UPDATE_NOW); pTool->BrushSelected(BrushHandle_NoBrush, FALSE); } }

void FreeHandInfoBarOp::SetBrushComboFromSelection (   )  [protected]

Definition at line 2176 of file freeinfo.cpp. { /* there are a few different scenarios here: 1) we have a single brush in the selection, in which case show it in the combo 2) we have many different brushes in the selection, in which case show our most recently selected drawing brush 3) we have no brushes in the selection, but the selection is not empty, in this case show a default line 4) the selection is empty, in which case we show the selected drawing brush. */ BOOL bSelectionEmpty = FALSE; BrushHandle SelHandle = GetBrushHandleFromSelection(&bSelectionEmpty); switch (SelHandle) { case BrushHandle_NoBrush: // display our currently selected brush for drawing { // if the selection is empty then show our drawing brush, if however we just don't // have any brushes in the selection then display the no-brush if (bSelectionEmpty) { SetDisplayBrush(); } else { // temporarily change the display brush and reflect it in the control BrushHandle Temp = m_DisplayBrush; m_DisplayBrush = SelHandle; SetDisplayBrush(); // restore the original display brush m_DisplayBrush = Temp; } } break; case BrushHandle_Many: // display the 'many' string { // the only way to do this seems to be by sending a string to the control String_256 Many; Many.Load(_R(IDS_FILLTOOL_MANY)); // call custom controls interface .... // SelectCustomComboGadgetValueOnString (_R(IDC_BRUSHTYPE), &Many); m_bgddBrushType.SetSelected(-1); } break; default: // display the brush from the selection { // temporarily change the display brush and reflect it in the control BrushHandle Temp = m_DisplayBrush; m_DisplayBrush = SelHandle; SetDisplayBrush(); // restore the original display brush m_DisplayBrush = Temp; } break; } }

BOOL FreeHandInfoBarOp::SetBrushListToControl (   )  [protected]

Goes through the brush list in order, creating attribute nodes from the brush handles and setting them into the combo. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: -  [INPUTS] Returns: true, unless we failed to get a new Definition at line 1845 of file freeinfo.cpp. { //#ifdef BUILDNEWBRUSHES if (m_pBrushList == NULL) return TRUE; // not an error, we just can't do it // if we have no document then don't bother Document* pDoc = Document::GetCurrent(); if (pDoc == NULL) return TRUE; // wipe our existing control // DeleteAllValues(_R(IDC_BRUSHTYPE)); m_bgddBrushType.Clear(); // need a pointer of type CustomComboBoxControlDataItem to insert items into // a custom combobox .... // CustomComboBoxControlDataItem* theItem = NULL; // UINT32 Counter = 1; // the combo's indexes start at 1 BrushHandle Handle = BrushHandle_NoBrush; BrushList::const_iterator iter; for (iter = m_pBrushList->begin(); iter !=m_pBrushList->end(); iter++) { // get the next handle Handle = *iter; // ask the component to make a node for us if (Handle != BrushHandle_NoBrush) { AttrBrushType* pNewAttr = BrushComponent::CreateNode (Handle); if (pNewAttr != NULL) m_bgddBrushType.AddItem(pNewAttr); } else { ERROR3("Default brush handle found in list in FreeHandInfoBarOp::SetBrushListToControl"); } } return SetStrokesToControl() ; }

void FreeHandInfoBarOp::SetDefaultStrokeInCombo (   )

Sets the bitmap showing in the brush combo to be that of the default stroke !!! Note - not actually working at the moment. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: -  [INPUTS] Returns: - Definition at line 2617 of file freeinfo.cpp. { //#ifdef BUILDNEWBRUSHES // SetCustomComboGadgetValue(_R(IDC_BRUSHTYPE), NULL, 0, 1); m_bgddBrushType.SetSelected(0); //#endif }

void FreeHandInfoBarOp::SetDisplayBrush (   )  [protected]

Definition at line 2137 of file freeinfo.cpp. { //#ifdef BUILDNEWBRUSHES // we need to find the index for our brush INT32 iIndex = GetControlIndexFromBrushHandle(m_DisplayBrush); m_bgddBrushType.SetSelected(iIndex); /* switch (Index) { case -1: // SetCustomComboGadgetValue ( _R(IDC_BRUSHTYPE), NULL, TRUE, -2); // TRACEUSER( "Diccon", _T("Display default brush\n")); break; case 0: // the zeroth index is the same as the head of our selected brushes list SetHeadOfListSelected(); // TRACEUSER( "Diccon", _T("Displayed head of list\n")); break; default: SetCustomComboGadgetValue(_R(IDC_BRUSHTYPE), NULL, 0, Index + 2); // control indexes are +2 from the index into our list // TRACEUSER( "Diccon", _T("Displayed display brush\n")); break; } */ //#endif }

void FreeHandInfoBarOp::SetHeadOfList (  BrushHandle  Handle  )  [protected]

Sets the given handle to the head of the 'most popular brush' list, also goes through the rest of the list and removes other instances of it, so as not to duplicate. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: handle  - the handle to set at the head of the list [INPUTS] Returns: - Definition at line 2582 of file freeinfo.cpp. { if (Handle == BrushHandle_NoBrush) { ERROR3("Attempting to set BrushHandle_NoBrush to head of list in FreeHandInfoBarOp::SetHeadOfList"); return; } if (m_pBrushList == NULL) { ERROR3("Brush list is NULL in FreeHandInfoBarOp::SetHeadOfList"); return; } // go through the list replacing existing instances of Handle m_pBrushList->remove(Handle); // set Handle to the head of the list m_pBrushList->push_front(Handle); }

void FreeHandInfoBarOp::SetHeadOfListSelected (   )  [protected]

Definition at line 2097 of file freeinfo.cpp. { //#ifdef BUILDNEWBRUSHES // if we have no document then don't bother Document* pDoc = Document::GetCurrent(); if (pDoc == NULL) return; if (m_pBrushList == NULL) { ERROR3("Brush list is NULL in FreeHandInfoBarOp::SetHeadOfListSelected"); return; } // on start up we have not yet put anything in the list so make sure we're not empty, // however this may not be cause for an error if (!m_pBrushList->empty()) { BrushHandle Handle = m_pBrushList->front(); // SetCustomComboGadgetValue(_R(IDC_BRUSHTYPE), NULL, 0, 2 ); m_bgddBrushType.SetSelected(0); m_DisplayBrush = Handle; } //#endif }

void FreeHandInfoBarOp::SetRetroState (  BOOL  CanFit  )

Sets the Flag CanRetroFit and gets the infobar to redraw the static text item that says this. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 30/8/94 Parameters: CanRetroFit  - TRUE if we can currently retro fit the path, FALSE if not [INPUTS] Definition at line 2656 of file freeinfo.cpp. { // Set the Retro field to be empty by default CanRetroFit = CanFit; // Set the string in the info bar now SetRetroString(); }

void FreeHandInfoBarOp::SetRetroString (   )

Sets the static text item in the freehand info bar to say either 'Retro' or nothing, depending on the state of the flag CanRetroFit. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 30/8/94 See also: FreeHandInfoBarOp::SetRetroState Definition at line 2678 of file freeinfo.cpp. { // go see if there is an info bar to use if (WindowID!=NULL) { if (CanRetroFit) { // Make the word Retro appear String_64 RetroWord; if (RetroWord.Load(_R(IDS_FHANDRETROTEXT))) { // Set the contents of the field to indicate retro is possible SetStringGadgetValue(_R(IDC_FREEHANDRETRO), RetroWord); } } else { // make the word retro not appear String_8 RetroWord(_T("")); SetStringGadgetValue(_R(IDC_FREEHANDRETRO), RetroWord); } } }

void FreeHandInfoBarOp::SetStrokeComboFromSelection (   )  [protected]

Definition at line 2252 of file freeinfo.cpp. { Document* pDoc = Document::GetCurrent(); // if we have no document then don't bother if (pDoc == NULL) return; // find out how many items there are in the selection SelRange* pSel = GetApplication()->FindSelection(); // INT32 NumSelItems = 0; INT32 SelectedStroke = m_SelectedStroke; // this is the index that we will end up setting to the control if (pSel) { Node* pNode = pSel->FindFirst(); // declare some vars that we need in the loop AttrVariableWidth* pVarWidth = NULL; VariableWidthAttrValue* pVal = NULL; ValueFunction* pFunk = NULL; ValueFunctionID ID = ValueFunctionID_None; BOOL bFirst = TRUE; BOOL bDifferent = FALSE; INT32 NumItems = 0; // for each node check to get its applied variable width attribute, and then the value function // of the attribute. If its the first node then record it, otherwise just check to see if its different // and if so then break out while (pNode) { NumItems++; // if its a noderenderable ink then check its applied attrvarwidth if (pNode->IsAnObject()) { // find the attribute ((NodeRenderableInk*)pNode)->FindAppliedAttribute(CC_RUNTIME_CLASS(AttrVariableWidth), (NodeAttribute**)&pVarWidth); if (pVarWidth) { // get the variable width function from the attribute (can be null) pVal = (VariableWidthAttrValue*)pVarWidth->GetAttributeValue(); pFunk = pVal->GetWidthFunction(); // its the first one if (bFirst) { if (pFunk) ID = pFunk->GetUniqueID(); // get the index into our combo corresponding to this ID SelectedStroke = GetStrokeIndexFromValueFunctionID(ID); bFirst = FALSE; } else { // check to see if it is different, if so set the flag and quit if (pFunk && (pFunk->GetUniqueID() != ID)) { bDifferent = TRUE; break; } } } } pNode = pSel->FindNext(pNode); } // if there were no items then display the current attribute if (NumItems == 0) { // get the current attribute from the attribute manager AttributeManager* pAttrMgr = &(pDoc->GetAttributeMgr()); if (pAttrMgr == NULL) { ERROR3("Unable to get attribute manager!"); return; } // may as well reuse this var pVarWidth = NULL; pVarWidth = (AttrVariableWidth*)pAttrMgr->GetCurrentAttribute(CC_RUNTIME_CLASS(NodeRenderableInk), CC_RUNTIME_CLASS(AttrVariableWidth)); if (pVarWidth) { VariableWidthAttrValue* pVal = (VariableWidthAttrValue*)pVarWidth->GetAttributeValue(); ValueFunction* pFunk = pVal->GetWidthFunction(); if (pFunk) { SelectedStroke = GetStrokeIndexFromValueFunctionID(pFunk->GetUniqueID()); } else { SelectedStroke = CONSTANT; } } } // if we have different strokes we need to say 'many', (what choo talkin' bout Willis!?) if (bDifferent) { /* // the only way to do this seems to be by sending a string to the control String_256 Many; Many.Load(_R(IDS_FILLTOOL_MANY)); // call custom controls interface .... SelectCustomComboGadgetValueOnString (_R(IDC_STROKETYPE), &Many); */ // Select none in the stroke dropdown since we don't support placing "many" word // into the combobox. m_bgddStrokes.SetSelected(-1); return; } } // now set the index to the control m_bgddStrokes.SetSelected(SelectedStroke); }

BOOL FreeHandInfoBarOp::SetStrokesToControl (   )  [protected]

Creates stroke shape items and adds them to the stroke combo. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 23/3/2000 Parameters: -  [INPUTS] Returns: true, unless we failed to get a new Definition at line 1902 of file freeinfo.cpp. { // DeleteAllValues(_R(IDC_STROKETYPE)); m_bgddStrokes.Clear(); // UINT32 index = 1; // CustomComboBoxControlDataItem* theItem = NULL; // --- Simple constant-width line ------------------------------------------ VariableWidthAttrValue *pAttr; pAttr = new VariableWidthAttrValue(NULL); VarWidthItem* pItem = new VarWidthItem(pAttr, String_64(TEXT("Constant"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Fallout ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Fallout); pItem = new VarWidthItem(pAttr, String_64(TEXT("Fallout"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Iron ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Iron); pItem = new VarWidthItem(pAttr, String_64(TEXT("Iron"))); m_bgddStrokes.AddItem(pItem); // --- Ellipse ------------------------------------------------------------- pAttr = new VariableWidthAttrValue(new ValueFunctionEllipse); pItem = new VarWidthItem(pAttr, String_64(TEXT("Ellipse"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_SlimBlip ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_SlimBlip); pItem = new VarWidthItem(pAttr, String_64(TEXT("Slim Blip"))); m_bgddStrokes.AddItem(pItem); // --- Blip ---------------------------------------------------------------- pAttr = new VariableWidthAttrValue(new ValueFunctionBlip); pItem = new VarWidthItem(pAttr, String_64(TEXT("Blip"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Cigar ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Cigar); pItem = new VarWidthItem(pAttr, String_64(TEXT("Cigar"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Cigar2 ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Cigar2); pItem = new VarWidthItem(pAttr, String_64(TEXT("Cigar 2"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Cigar3 ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Cigar3); pItem = new VarWidthItem(pAttr, String_64(TEXT("Cigar 3"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Convex ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Convex); pItem = new VarWidthItem(pAttr, String_64(TEXT("Convex"))); m_bgddStrokes.AddItem(pItem); // --- Simple S-shaped ramp with non-zero end width ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionRampS2); pItem = new VarWidthItem(pAttr, String_64(TEXT("Convex 2"))); m_bgddStrokes.AddItem(pItem); // --- Simple S-shaped ramp ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionRampS); pItem = new VarWidthItem(pAttr, String_64(TEXT("Convex 3"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Concave ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Concave); pItem = new VarWidthItem(pAttr, String_64(TEXT("Concave"))); m_bgddStrokes.AddItem(pItem); // --- Simple linear ramp with non-zero end width -------------------------------------------------- pAttr = new VariableWidthAttrValue(new ValueFunctionRampL2); pItem = new VarWidthItem(pAttr, String_64(TEXT("Concave 2"))); m_bgddStrokes.AddItem(pItem); // --- Simple linear ramp -------------------------------------------------- pAttr = new VariableWidthAttrValue(new ValueFunctionRampL); pItem = new VarWidthItem(pAttr, String_64(TEXT("Concave 3"))); m_bgddStrokes.AddItem(pItem); // --- Teardrop CurvedEnd------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionTeardropCurvedEnd); pItem = new VarWidthItem(pAttr, String_64(TEXT("Dab"))); m_bgddStrokes.AddItem(pItem); // --- Teardrop ------------------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionTeardrop); pItem = new VarWidthItem(pAttr, String_64(TEXT("Raindrop"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Comet ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Comet); pItem = new VarWidthItem(pAttr, String_64(TEXT("Comet"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Petal ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Petal); pItem = new VarWidthItem(pAttr, String_64(TEXT("Petal"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Reed ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Reed); pItem = new VarWidthItem(pAttr, String_64(TEXT("Reed"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Meteor ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Meteor); pItem = new VarWidthItem(pAttr, String_64(TEXT("Meteor"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Torpedo ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Torpedo); pItem = new VarWidthItem(pAttr, String_64(TEXT("Torpedo"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Missile ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Missile); pItem = new VarWidthItem(pAttr, String_64(TEXT("Missile"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Goldfish ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Goldfish); pItem = new VarWidthItem(pAttr, String_64(TEXT("Goldfish"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Yacht ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Yacht); pItem = new VarWidthItem(pAttr, String_64(TEXT("Yacht"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_Barb ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_Barb); pItem = new VarWidthItem(pAttr, String_64(TEXT("Barb"))); m_bgddStrokes.AddItem(pItem); // --- Smooth Stroke SS_OceanLiner ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSS_OceanLiner); pItem = new VarWidthItem(pAttr, String_64(TEXT("Ocean Liner"))); m_bgddStrokes.AddItem(pItem); // --- Propeller ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionPropeller); pItem = new VarWidthItem(pAttr, String_64(TEXT("Propeller"))); m_bgddStrokes.AddItem(pItem); // --- Double S-shaped ramp ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionDoubleRampS); pItem = new VarWidthItem(pAttr, String_64(TEXT("Bow Tie"))); //pAttr2 = (NodeAttribute*) pItem->CreateNode (); m_bgddStrokes.AddItem(pItem); // --- BevelEnds ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionBevelEnds); pItem = new VarWidthItem(pAttr, String_64(TEXT("Bevel Ends"))); m_bgddStrokes.AddItem(pItem); // --- SawTooth ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionSawTooth); pItem = new VarWidthItem(pAttr, String_64(TEXT("Saw Tooth"))); //pAttr2 = (NodeAttribute*) pItem->CreateNode (); m_bgddStrokes.AddItem(pItem); // --- Intestine ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionIntestine); pItem = new VarWidthItem(pAttr, String_64(TEXT("Intestine"))); m_bgddStrokes.AddItem(pItem); // --- Decay ------------------------------------------------ pAttr = new VariableWidthAttrValue(new ValueFunctionDecay); pItem = new VarWidthItem(pAttr, String_64(TEXT("Decay"))); m_bgddStrokes.AddItem(pItem); SetStrokeComboFromSelection(); return TRUE; }

void FreeHandInfoBarOp::SetToolActiveState (  BOOL  IsToolActive  )

Allows the info bar to know if it is valid or not. Author: Rik_Heywood (Xara Group Ltd) <camelotdev@xara.com> Date: 31/8/94 Parameters: IsToolActive  - TRUE if the tool is becoming active, FALSE if it not [INPUTS] Definition at line 2636 of file freeinfo.cpp. { // Set the control state ControlsExist = IsToolActive; }

void FreeHandInfoBarOp::UpdateState (   )  [virtual]

Sets the state of button on the bar to keep them up to date. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/1/97 Reimplemented from DialogBarOp. Definition at line 2715 of file freeinfo.cpp. { // Don't try to set our controls when they're not there! if (!ControlsExist) return; // see if we're allowed to launch the brush dialog OpState State = CBrushEditDlg::GetState(NULL, NULL); //#ifdef BUILDNEWBRUSHES if (State.Greyed == FALSE) // && !BrushGadget.IsDialogOpen()) EnableGadget(_R(IDC_EDITBRUSH), TRUE); else EnableGadget(_R(IDC_EDITBRUSH), FALSE); //#endif SelRange* pSel = GetApplication()->FindSelection(); if (pSel != NULL) { //#ifdef BUILDNEWBRUSHES if (pSel->FindFirst() == NULL) EnableGadget(_R(IDC_CREATEBRUSH), FALSE); else EnableGadget(_R(IDC_CREATEBRUSH), TRUE); //#endif } // WEBSTER - markn 25/4/97 // No pen stuff required in Webster // Taken out by vector stroking code Neville 2/10/97 #ifdef VECTOR_STROKING // Set the state of the pressure button according to the Op's state. // Why buttons on infobars can't dynamically auto-connect to their ops is beyond me OpDescriptor *pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_TOGGLEPRESSURE); if (pOpDesc != NULL) { String_256 Why; OpState State = pOpDesc->GetOpsState(&Why); // stop this damn thing from falling over when there is no infobar .... CWindowID hGadget = DialogManager::GetGadget(GetReadWriteWindowID (), _R(IDC_FREEHANDPRESSURE)); if (hGadget) { SetBoolGadgetSelected(_R(IDC_FREEHANDPRESSURE), (State.Ticked) ? 1 : 0); EnableGadget(_R(IDC_FREEHANDPRESSURE), (State.Greyed) ? 0 : 1); } } #endif // VECTOR_STROKING }

---

Member Data Documentation

CBrushGadget FreeHandInfoBarOp::BrushGadget [static, protected]

Definition at line 213 of file freeinfo.h.

BOOL FreeHandInfoBarOp::CanRetroFit

Definition at line 188 of file freeinfo.h.

BOOL FreeHandInfoBarOp::ControlsExist [protected]

Definition at line 194 of file freeinfo.h.

BOOL FreeHandInfoBarOp::DropDownInited [protected]

Definition at line 195 of file freeinfo.h.

CBitmapGridDropDown FreeHandInfoBarOp::m_bgddBrushType [protected]

Definition at line 208 of file freeinfo.h.

CBitmapGridDropDown FreeHandInfoBarOp::m_bgddStrokes [protected]

Definition at line 209 of file freeinfo.h.

BrushHandle FreeHandInfoBarOp::m_DisplayBrush [protected]

Definition at line 206 of file freeinfo.h.

INT32 FreeHandInfoBarOp::m_LastSmoothness [protected]

Definition at line 202 of file freeinfo.h.

BrushList* FreeHandInfoBarOp::m_pBrushList [protected]

Definition at line 204 of file freeinfo.h.

INT32 FreeHandInfoBarOp::m_SelectedStroke [protected]

Definition at line 217 of file freeinfo.h.

FreeHandTool* FreeHandInfoBarOp::pTool

Definition at line 187 of file freeinfo.h.

---

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

• tools/freeinfo.h (r1785/r1702)
• tools/freeinfo.cpp (r1785/r1771)

---