CBrushEditDlg Class Reference

#include <brushdlg.h>

Inheritance diagram for CBrushEditDlg:

List of all members.

Public Member Functions
	CBrushEditDlg ()
	Default constructor for CBrushEditDlg.
	~CBrushEditDlg ()
	Destructor.
void	Do (OpDescriptor *)
	launches the brush edit dialog, this method will determine which brush it is editing from the document selection.
void	DoWithParam (OpDescriptor *, OpParam *OwningGadgetParams)
	launches the brush edit dialog, however this the BrushData to initialise the dialog is provided through the opparam. Note: I don't think that we use this method anymore.
virtual MsgResult	Message (Msg *)
	Message proc for this dialog.
void	CreateNewBrush ()
void	HandleBrushEditSpacingMsg (DialogMsg *Msg)
	Subhandler for messages from the spacing tab, except for the edit box and sliders, which have their own handlers.
void	HandleBrushEditOffsetMsg (DialogMsg *Msg)
	Subhandler for messages from the offset tab, except for the edit box and sliders, which have their own handlers.
void	HandleBrushEditScalingMsg (DialogMsg *Msg)
	Subhandler for messages from the scaling tab, except for the edit box and sliders, which have their own handlers.
void	HandleBrushEditEffectMsg (DialogMsg *Msg)
	Subhandler for messages from the rotation tab, except for the edit box and sliders, which have their own handlers.
void	HandleBrushEditSequenceMsg (DialogMsg *Msg)
	Subhandler for messages from the transparency tab, except for the edit box and sliders, which have their own handlers.
void	HandleBrushFillMsg (DialogMsg *Msg)
	Subhandler for messages from the fill tab, except for the edit box and sliders, which have their own handlers.
void	InvokeVia (CBrushGadget &pInvokeWith, BrushData *pInvokeOn, AttrBrushType *pBrush, BOOL &bMany)
	I'm not entirely sure what this does, perhaps Chris will be able to elaborate, I think they were once used as part of launching the dialog, but I think they are no longer used.
void	InvokeVia (CBrushGadget &pInvokeWith, BrushData *pInvokeOn, AttrBrushType *pBrush, AttrBrushType *pOrigBrush, BOOL &bMany)
void	InvokeVia (CBrushGadget &pInvokeWith, BrushHandle Handle)
virtual BOOL	RegisterYourPagesInOrderPlease ()
	This virtual function will get called to give you a chance to add pages to your DialogTabOp. This function will usually make multiple calls to AddAPage to register the initial set of pages to be contained in the tab dialog. The pages should all be the same size and be registered in the left to right order in which you wish them to appear.
void	ReInitialiseDialog (BrushData *pData)
void	SetDialogTitle (String_256 Title)
Static Public Member Functions
static BOOL	Init ()
	the init function to register us as an Op
static OpState	GetState (String_256 *, OpDescriptor *)
	Determines whether or not we can launch this op. We are allowed to launch in the following circumstances: Any tool, one AttrBrushType in the selection FreeHandTool, as above OR brush selected in the brush combo and no document selection.
static AttrBrushType *	GetSingleSelectedBrushAttribute ()
Static Public Attributes
static const UINT32	IDD = _R(IDD_BRUSHEDIT)
static const CDlgMode	Mode = MODELESS
Private Member Functions
void	HideShuffleIrrelevantButtons ()
	Because CPropertySheets only let you have an OK, Apply,Cancel, and Help button, we must rename these for our own devious ends and swap their positions.
void	InitBrushSpacing (BOOL OnlyForUnitChange=FALSE)
void	InitBrushOffset (BOOL OnlyForUnitChange=FALSE)
void	InitBrushScaling (BOOL OnlyForUnitChange=FALSE)
void	InitBrushEffects (BOOL OnlyForUnitChange=FALSE)
void	InitBrushSequence (BOOL OnlyForUnitChange=FALSE)
void	InitBrushFill (BOOL OnlyForUnitChange=FALSE)
void	ReInitBrushSpacing ()
void	ReInitBrushOffset ()
void	ReInitBrushScaling ()
void	ReInitBrushEffects ()
void	ReInitBrushSequence ()
void	ReInitBrushFill ()
void	ReInitUnitDependantFields (CDlgResID ThePage)
void	InitComboPathOffsetType ()
void	InitSequenceType ()
void	HandleCommit (DialogMsg *Msg)
void	HandleSelectionChange (DialogMsg *Msg)
void	HandleButtonDown (DialogMsg *Msg)
void	HandleSliderPosChanging (DialogMsg *Msg)
void	HandleSliderPosSet (DialogMsg *Msg)
void	ReadButtons (DialogMsg *Msg)
void	ReadRadios (DialogMsg *Msg)
void	ReadEditBox (DialogMsg *Msg)
void	ReadComboBox (DialogMsg *Msg)
void	ReadCheckBox (DialogMsg *Msg)
void	ReadSlider (DialogMsg *Msg)
void	WriteSliders (DialogMsg *Msg)
void	UpdateEditBox (CGadgetID GadgetToUpdate)
void	LaunchOp ()
UINT32	GetNewRandomNumber (UINT32 OldNumber)
void	ReInitPage (CDlgResID PageID)
BOOL	GetAttributeNodeFromDefinition ()
void	HandleDocSelectionChange ()
void	RefreshActivePage ()
void	GetSpacingRange (double *, double *)
void	SetSpacingSlider ()
void	SetSpacingIncrSlider ()
void	SetOffsetValSlider ()
void	GetOffsetRange (double *, double *)
MILLIPOINT	GetSideOfBoundingBox (RectSideInfo RectInfo)
double	GetDistanceAsPercentageOfBBox (MILLIPOINT Distance, RectSideInfo RectInfo)
MILLIPOINT	GetPercentageAsDistance (double Percent, RectSideInfo RectInfo)
void	ChangeButtonText ()
	Because CPropertySheets only let you have an OK, Apply,Cancel, and Help button, we must rename these for our own devious ends.
void	SetRandomRangeText (CGadgetID SliderID)
String_32	GetRandomRangeText (INT32 SliderVal)
String_32	GetRotationRandomText (INT32 SliderVal)
String_32	GetRandomText (INT32 Value, INT32 MaxValue)
virtual BOOL	AddControlsToHelper ()
	We need to subclass our edit box controls so we're adding them to the helper here.
virtual void	RemoveControlsFromHelper ()
	removing the edit controls from the helper
Private Attributes
CBrushGadget *	m_pOwningGadget
CGadgetID	Id_m
BrushData *	OriginalData
BrushData *	EditData
BrushData	m_LastData
BrushHandle	m_Handle
AttrBrushType *	pAttrBrush_m
AttrBrushType *	pOrigAttrBrush_m
ChangeBrushType	ChangeType_m
ChangeBrushOpParam	ChangeParam_m
BOOL	FirstTime
BOOL	EditingBrushDef
BOOL	m_bDisableOps
RenderPreviewType	RenderType
DocUnitList *	pDocUnitList
UnitType	CurrentUserUnitType
BOOL	m_bDisableGadgets
BOOL	m_bPreventUpdateSet
BOOL	m_SliderStarted
BOOL	UsingRandomSpacing
BOOL	UsingRandomOffset
BOOL	UsingRandomScaling
CGadgetID	EditGadgetLostFocus
Static Private Attributes
static BOOL	m_bIsOpen = FALSE

---

Detailed Description

Definition at line 112 of file brushdlg.h.

---

Constructor & Destructor Documentation

CBrushEditDlg::CBrushEditDlg (   )

Default constructor for CBrushEditDlg. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 220 of file brushdlg.cpp. : DialogTabOp/*DialogOp*/( CBrushEditDlg::IDD, CBrushEditDlg::Mode ) { FirstTime = TRUE; EditingBrushDef = FALSE; m_Handle = BrushHandle_NoBrush; RenderType = RT_LINE; pDocUnitList = NULL; CurrentUserUnitType = NOTYPE; UsingRandomSpacing = FALSE; UsingRandomOffset = FALSE; UsingRandomScaling = FALSE; EditGadgetLostFocus = 0; pAttrBrush_m = NULL; }

CBrushEditDlg::~CBrushEditDlg (   )

Destructor. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 260 of file brushdlg.cpp. { if (OriginalData != NULL) delete (OriginalData); if (EditData != NULL) delete (EditData); }

---

Member Function Documentation

BOOL CBrushEditDlg::AddControlsToHelper (   )  [private, virtual]

We need to subclass our edit box controls so we're adding them to the helper here. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/7/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if all went well, FALSE if something went wrong Errors: - See also: DialogControlHelper class (DlgCtHlp.h/.cpp) Reimplemented from DialogOp. Definition at line 557 of file brushdlg.cpp. { // basically we just add 'em in one by one BOOL ok = AddDialogControlToHelper(_R(IDC_EDITBRUSHSPACING), _R(IDD_BRUSHEDITSPACING)); // if (ok) ok = AddDialogControlToHelper(_R(IDC_EDITBRUSHSPACINGINCRCONST), _R(IDD_BRUSHEDITSPACING)); if (ok) ok = AddDialogControlToHelper(_R(IDC_EDITPATHOFFSETVALUE), _R(IDD_BRUSHEDITOFFSET)); // if (ok) ok = AddDialogControlToHelper(_R(IDC_EDITPATHOFFSETINCRCONST), _R(IDD_BRUSHEDITOFFSET)); // if (ok) ok = AddDialogControlToHelper(_R(IDC_EDITSCALINGINCRCONST), _R(IDD_BRUSHEDITSCALING)); if (ok) ok = AddDialogControlToHelper(_R(IDC_EDITROTATEANGLE), _R(IDD_BRUSHEDITEFFECTS)); if (ok) ok = AddDialogControlToHelper(_R(IDC_EDITROTATEANGLEINCR), _R(IDD_BRUSHEDITEFFECTS)); if (ok) ok = AddDialogControlToHelper(_R(IDC_EDITBRUSHTRANSP), _R(IDD_BRUSHEDITSEQUENCE)); return ok; }

void CBrushEditDlg::ChangeButtonText (   )  [private]

Because CPropertySheets only let you have an OK, Apply,Cancel, and Help button, we must rename these for our own devious ends. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1276 of file brushdlg.cpp. { SetStringGadgetValue(_R(ID_CANCEL), _R(IDS_BRUSH_CLOSEDLG)); SetStringGadgetValue(_R(ID_APPLY_NOW), _R(IDS_BRUSH_SAVE)); SetStringGadgetValue(_R(IDOK), _R(IDS_BRUSH_SAVE_AS)); }

void CBrushEditDlg::CreateNewBrush (   )

Definition at line 3417 of file brushdlg.cpp. { // as we are basically making a copy of an existing definition we can use the nodetree // of the existing definition, so we need to obtain a pointer to it. BrushHandle ThisHandle = EditData->m_BrushHandle; // get the brush component from the document Document* pDoc = Document::GetCurrent(); if (pDoc == NULL) { ERROR3("Document is NULL in CBrushEditDlg::BrushEditDlgOnOK"); return; } BrushComponent* pBrushComp = (BrushComponent*)pDoc->GetDocComponent(CC_RUNTIME_CLASS(BrushComponent)); if (pBrushComp == NULL) { ERROR3("Brush component is null in CBrushEditDlg::BrushEditDlgOnOK"); return; } BrushDefinition* pBrushDef = pBrushComp->FindBrushDefinition(ThisHandle); if (pBrushDef == NULL) { ERROR3("Brush definition is NULL in CBrushEditDlg::BrushEditDlgOnOK"); return; } // ask the definition to copy itself BrushDefinition* pNewBrushDef = pBrushDef->Copy(); if (pNewBrushDef == NULL) return; // copy our brush data to the definition pNewBrushDef->SetMembersFromData(*EditData); pNewBrushDef->SetBrushScaling(1.0); // find out how many brushes there are UINT32 LastBrush = pBrushComp->GetNumberOfBrushes() - 1; BrushHandle NewHandle = pBrushComp->AddNewItem(pNewBrushDef, TRUE); // tell the world who we are if (NewHandle > LastBrush) BROADCAST_TO_ALL(NewBrushMsg()); else //ERROR3("Tried to make an identical brush"); TRACEUSER( "Diccon", _T("Tried to make an identical brush\n")); EditData->m_BrushHandle = NewHandle; }

void CBrushEditDlg::Do (  OpDescriptor *   )  [virtual]

launches the brush edit dialog, this method will determine which brush it is editing from the document selection. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: not  used [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from Operation. Definition at line 376 of file brushdlg.cpp. { Document * pDocument = Document::GetSelected(); ERROR3IF(pDocument == NULL,"UnitPropertiesDlg::DoWithParam No selected document"); if (pDocument) pDocUnitList = pDocument->GetDocUnitList(); ERROR3IF(pDocUnitList == NULL,"UnitPropertiesDlg::DoWithParam No doc unit list attached to this doc yet"); CurrentUserUnitType = pDocUnitList->GetPageUnits (); PORTNOTE("other", "Disabled CBrushGadget") #ifndef EXCLUDE_FROM_XARALX // this fn. is called from the ViewContextMenu without any params so here we must initialise it ourselves //m_pOwningGadget = FreeHandInfoBarOp::GetSpareGadget(); m_pOwningGadget = FreeHandInfoBarOp::GetBrushGadget(); if (m_pOwningGadget != NULL) m_pOwningGadget->SetBrushDialog(this); #endif EditData = new BrushData; if (EditData == NULL) return; OriginalData = new BrushData; m_bDisableGadgets = TRUE; // we want to see if there is a brush in the selection, in which case grab its data so we // can initialise everything ok. Otherwise keep everything disabled AttrBrushType* pAttrBrush = GetSingleSelectedBrushAttribute(); if (pAttrBrush != NULL) { *EditData = pAttrBrush->GetBrushData(); *OriginalData = *EditData; m_bDisableGadgets = FALSE; //initialise our opparam with the original data, just in case we want to do change all ChangeParam_m.SetValues(*EditData); String_256 Name = EditData->m_Name; SetName(&Name); } else { // If we are in the freehand tool then we can launch so long as the tool selected brush is not default if (Tool::GetCurrentID() == TOOLID_FREEHAND) { FreeHandTool* pTool = (FreeHandTool*)Tool::GetCurrent(); BrushHandle Handle = pTool->GetBrushHandle(); if (Handle != BrushHandle_NoBrush) { BrushDefinition* pDef = BrushComponent::FindBrushDefinition(Handle); if (pDef != NULL) { // the definition allocates a new data object for us delete EditData; EditData = pDef->GetBrushData(); EditData->m_BrushHandle = Handle; *OriginalData = *EditData; m_bDisableGadgets = FALSE; //initialise our opparam with the original data, just in case we want to do change all ChangeParam_m.SetValues(*EditData); EditingBrushDef = TRUE; String_256 Name = EditData->m_Name; SetName(&Name); } } } } Create (); Open (); m_bIsOpen = TRUE; m_bPreventUpdateSet = FALSE; m_SliderStarted = FALSE; }

void CBrushEditDlg::DoWithParam (  OpDescriptor *  , OpParam *  OwningGadgetParams )  [virtual]

launches the brush edit dialog, however this the BrushData to initialise the dialog is provided through the opparam. Note: I don't think that we use this method anymore. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: OwningGadgetParams  - recast to get a BrushData object [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from Operation. Definition at line 468 of file brushdlg.cpp. { PORTNOTE("other", "Disabled CBrushGadget") #ifndef EXCLUDE_FROM_XARALX m_pOwningGadget = reinterpret_cast<CBrushGadget*> (OwningGadgetParams->Param1); m_pOwningGadget->SetCBrushEditDlg (this); #endif // if theres already one open the don't if (WindowID != NULL && IsOpen() && IsWindowVisible()) return; EditData = new BrushData (*(reinterpret_cast<BrushData*> ((void*)(OwningGadgetParams->Param2)))); // if we're editing the definition then we had to create a brush data from scratch so delete // it here if (EditingBrushDef) { BrushData* DeleteData = ((reinterpret_cast<BrushData*> ((void *)(OwningGadgetParams->Param2)))); delete DeleteData; } //EditData = reinterpret_cast<BrushData*> (OwningGadgetParams->Param2); OriginalData = new BrushData (*EditData); //initialise our opparam with the original data, just in case we want to do change all ChangeParam_m.SetValues(*EditData); m_bDisableGadgets = FALSE; PORTNOTE("other", "Disabled CBrushGadget") #ifndef EXCLUDE_FROM_XARALX // get the ID if (m_pOwningGadget != 0) { Id_m = m_pOwningGadget->GetGadgetID (); } if (m_pOwningGadget->GetEditingBrushDefinition ()) { EditingBrushDef = TRUE; GetAttributeNodeFromDefinition(); } #endif Document * pDocument = Document::GetSelected(); ERROR3IF(pDocument == NULL,"UnitPropertiesDlg::DoWithParam No selected document"); if (pDocument) pDocUnitList = pDocument->GetDocUnitList(); ERROR3IF(pDocUnitList == NULL,"UnitPropertiesDlg::DoWithParam No doc unit list attached to this doc yet"); CurrentUserUnitType = pDocUnitList->GetPageUnits (); String_256 Title (_R(IDS_BRUSHEDITDLGTITLE)); SetName (&Title); Create (); Open (); PORTNOTE("other", "Disabled CBrushGadget") #ifndef EXCLUDE_FROM_XARALX // tell the owning gadget that this dialog has opened if (m_pOwningGadget != 0) { m_pOwningGadget->DialogHasOpened (); } #endif m_bIsOpen = TRUE; m_bPreventUpdateSet = FALSE; m_SliderStarted = FALSE; }

BOOL CBrushEditDlg::GetAttributeNodeFromDefinition (   )  [private]

Definition at line 1939 of file brushdlg.cpp. { // just a quick check to see if we're in the right place if (!EditingBrushDef) return FALSE; // we need to get hold of the brush component from the document Document* pDoc = Document::GetCurrent(); if (pDoc == NULL) return FALSE; BrushComponent* pBrushComp = (BrushComponent*)pDoc->GetDocComponent(CC_RUNTIME_CLASS(BrushComponent)); if (pBrushComp == NULL) { ERROR3("No brush component in our document"); return FALSE; } // wipe our existing attribute if (pAttrBrush_m != NULL) { delete pAttrBrush_m; pAttrBrush_m = NULL; } // ask the component for a new one pAttrBrush_m = pBrushComp->CreateAttributeNode(m_Handle); // did we get it? if (pAttrBrush_m == NULL) return FALSE; return TRUE; }

double CBrushEditDlg::GetDistanceAsPercentageOfBBox (  MILLIPOINT  Distance, RectSideInfo  RectInfo )  [private]

Definition at line 3120 of file brushdlg.cpp. { MILLIPOINT RectSide = GetSideOfBoundingBox(Side); if (RectSide == 0) { // ERROR3("Bounding rect is empty in CBrushEditDlg::GetSpacingRange"); return 0; } double Percent = (double)Distance / (double)RectSide; return Percent * 100; }

UINT32 CBrushEditDlg::GetNewRandomNumber (  UINT32  OldNumber  )  [private]

Definition at line 1975 of file brushdlg.cpp. { // seed the random number generator srand( (unsigned)time( NULL ) ); UINT32 Rand = (UINT32)rand(); // make sure its not the same (unlikely) while (Rand == OldNumber) Rand = (UINT32)rand(); return Rand; }

void CBrushEditDlg::GetOffsetRange (  double *  , double *  )  [private]

Definition at line 3092 of file brushdlg.cpp. { if (pMin == NULL || pMax == NULL) { ERROR3("Null pointers in CBrushEditDlg::GetOffsetRange"); return; } *pMin = MinOffset; MILLIPOINT Height = GetSideOfBoundingBox(HEIGHT); if (Height == 0) { // ERROR3("Bounding rect is empty in CBrushEditDlg::GetSpacingRange"); return; } Height = Height * MAXOFFSETMULTIPLIER; if (Height > MAX_BRUSH_OFFSET) Height = MAX_BRUSH_OFFSET; double ExpRootHeight = pow((double)Height, 1/ExpFactor); *pMax = ExpRootHeight; }

MILLIPOINT CBrushEditDlg::GetPercentageAsDistance (  double  Percent, RectSideInfo  RectInfo )  [private]

Definition at line 3170 of file brushdlg.cpp. { MILLIPOINT Side = GetSideOfBoundingBox(RectSide); MILLIPOINT ReturnVal = (MILLIPOINT)(((double)Side) * (Percent / 100)); return ReturnVal; }

String_32 CBrushEditDlg::GetRandomRangeText (  INT32  SliderVal  )  [private]

Definition at line 3181 of file brushdlg.cpp. { String_32 RangeText(_T(" ")); if (SliderVal < MIN_RANDOM_SLIDER || SliderVal > MAX_RANDOM_SLIDER) { ERROR3("Slider value is out of range in CBrushEditDlg::GetRandomRangeText"); return RangeText; } UINT32 BaseVal = 100; UINT32 MinVal = 100 ; UINT32 MaxVal = 100 ; // the actual limits are worked out in the PPB static function PathProcessorBrush::GetRandomLimits(BaseVal, SliderVal, &MinVal, &MaxVal); // annoyingly we now need to recast our values as long String_32 MinString; String_32 MaxString; String_32 MiddleString = _T(" - "); Convert::LongToString((INT32)MinVal, &MinString); Convert::LongToString((INT32)MaxVal, &MaxString); RangeText += MinString; RangeText += MiddleString; RangeText += MaxString; return RangeText; }

String_32 CBrushEditDlg::GetRandomText (  INT32  Value, INT32  MaxValue )  [private]

Definition at line 3382 of file brushdlg.cpp. { INT32 Base = 100; INT32 MinVal = Base; INT32 MaxVal = Base; double RandomFactor = (double)Rand / 100; RandomFactor++; // = (RandomFactor * MaxRand); if (RandomFactor != 0) { MinVal = (INT32)((double)Base / RandomFactor); MaxVal =(INT32)((double)Base * RandomFactor); } String_32 RangeText(_T("")); // annoyingly we now need to recast our values as long String_32 MinString; String_32 MaxString; String_32 MiddleString = _T(" - "); Convert::LongToString(MinVal, &MinString); Convert::LongToString(MaxVal, &MaxString); RangeText += MinString; RangeText += MiddleString; RangeText += MaxString; return RangeText; }

String_32 CBrushEditDlg::GetRotationRandomText (  INT32  SliderVal  )  [private]

Definition at line 3213 of file brushdlg.cpp. { String_32 RangeText(_T(" ")); if (SliderVal < MIN_RANDOM_SLIDER || SliderVal > MAX_RANDOM_SLIDER) { ERROR3("Slider value is out of range in CBrushEditDlg::GetRandomRangeText"); return RangeText; } UINT32 BaseVal = 100; UINT32 MinVal = 100 ; UINT32 MaxVal = 100 ; // the actual limits are worked out in the PPB static function PathProcessorBrush::GetRotationRandomLimits(BaseVal, SliderVal, &MinVal, &MaxVal); //double MinValDegrees = // annoyingly we now need to recast our values as long String_32 MinString; String_32 MaxString; String_32 MiddleString = _T(" - "); Convert::LongToString((INT32)MinVal, &MinString); Convert::LongToString((INT32)MaxVal, &MaxString); RangeText += MinString; RangeText += MiddleString; RangeText += MaxString; return RangeText; }

MILLIPOINT CBrushEditDlg::GetSideOfBoundingBox (  RectSideInfo  RectInfo  )  [private]

Definition at line 3133 of file brushdlg.cpp. { BrushDefinition* pBrushDef = BrushComponent::FindBrushDefinition(EditData->m_BrushHandle); if (pBrushDef == NULL) { // ERROR3("No brush definition in CBrushEditDlg::GetLongestSideOfBoundingBox"); return 0; } DocRect BRect = pBrushDef->GetLargestBoundingBox(); if (BRect.IsEmpty()) { //ERROR3("Bounding rect is empty in CBrushEditDlg::GetSpacingRange"); return 0; } MILLIPOINT Side = 0; switch (RectSide) { case WIDTH: Side = BRect.Width(); break; case HEIGHT: Side = BRect.Height(); break; case LONGEST: Side = BRect.Width() > BRect.Height() ? BRect.Width() : BRect.Height(); break; default: ERROR3("Invalid side info passed to CBrushEditDlg::GetSideOfBoundingBox"); Side = BRect.Width(); break; } return Side; }

AttrBrushType * CBrushEditDlg::GetSingleSelectedBrushAttribute (   )  [static]

Definition at line 2903 of file brushdlg.cpp. { AttrBrushType* pAttrBrush = NULL; List NodeList; BevelTools::BuildListOfSelectedNodes(&NodeList, CC_RUNTIME_CLASS(AttrBrushType)); BrushData Data; // initialises to default values INT32 NumItems = NodeList.GetCount(); if (NumItems == 1) { NodeListItem* pItem = (NodeListItem*)NodeList.GetHead(); if (pItem != NULL) pAttrBrush = (AttrBrushType*)pItem->pNode; } NodeList.DeleteAll(); return pAttrBrush; }

void CBrushEditDlg::GetSpacingRange (  double *  , double *  )  [private]

Definition at line 3064 of file brushdlg.cpp. { if (pMinimum == NULL || pMaximum == NULL) { ERROR3("Null pointers in CBrushEditDlg::GetSpacingRange"); return; } *pMinimum = MinSliderSpacing; MILLIPOINT Width = GetSideOfBoundingBox(WIDTH); if (Width == 0) { ERROR3("Bounding rect is empty in CBrushEditDlg::GetSpacingRange"); return; } Width = Width * MAXSPACINGMULTIPLIER; if (Width> MAX_BRUSH_SPACING) Width = MAX_BRUSH_SPACING; double ExpRootWidth = pow((double)Width, 1/ExpFactor); *pMaximum = ExpRootWidth; }

OpState CBrushEditDlg::GetState (  String_256 *  pHelpString, OpDescriptor *  )  [static]

Determines whether or not we can launch this op. We are allowed to launch in the following circumstances: Any tool, one AttrBrushType in the selection FreeHandTool, as above OR brush selected in the brush combo and no document selection. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: not  used [INPUTS] -  [OUTPUTS] Returns: the OpState indicating whether or not this op is greyed Note also that we can only ever have one instance of the dialog open at once Returns: Errors: - See also: - Definition at line 332 of file brushdlg.cpp. { static OpState DialogState; DialogState.Greyed = TRUE; // if we have a single brush in the selection then we're ok AttrBrushType* pAttrBrush = GetSingleSelectedBrushAttribute(); if (pAttrBrush != NULL && pAttrBrush->GetBrushHandle() != BrushHandle_NoBrush) DialogState.Greyed = FALSE; // if we're in the freehand tool and we our current brush is not default then we're also ok if (Tool::GetCurrentID() == TOOLID_FREEHAND) { FreeHandTool* pTool = (FreeHandTool*)Tool::GetCurrent(); if (pTool->GetBrushHandle() != BrushHandle_NoBrush) DialogState.Greyed = FALSE; } // we only ever want one instance of the dialog so check our static member if (m_bIsOpen) DialogState.Greyed = TRUE; return (DialogState); }

void CBrushEditDlg::HandleBrushEditEffectMsg (  DialogMsg *  Msg  )

Subhandler for messages from the rotation tab, except for the edit box and sliders, which have their own handlers. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: Msg  - the message to handle [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1003 of file brushdlg.cpp. { TalkToPage (_R(IDD_BRUSHEDITEFFECTS)); switch(Msg->DlgMsg) { case DIM_CREATE: InitBrushEffects (); break; case DIM_COMMIT : { HandleCommit (Msg); DialogManager::DefaultKeyboardFocus (); } break; default: break; } }

void CBrushEditDlg::HandleBrushEditOffsetMsg (  DialogMsg *  Msg  )

Subhandler for messages from the offset tab, except for the edit box and sliders, which have their own handlers. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: Msg  - the message to handle [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 924 of file brushdlg.cpp. { TalkToPage (_R(IDD_BRUSHEDITOFFSET)); switch(Msg->DlgMsg) { case DIM_CREATE: InitBrushOffset (); break; case DIM_COMMIT : { HandleCommit (Msg); DialogManager::DefaultKeyboardFocus (); } break; default: break; } }

void CBrushEditDlg::HandleBrushEditScalingMsg (  DialogMsg *  Msg  )

Subhandler for messages from the scaling tab, except for the edit box and sliders, which have their own handlers. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: Msg  - the message to handle [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 963 of file brushdlg.cpp. { TalkToPage (_R(IDD_BRUSHEDITSCALING)); switch(Msg->DlgMsg) { case DIM_CREATE: InitBrushScaling (); break; case DIM_COMMIT : { HandleCommit (Msg); DialogManager::DefaultKeyboardFocus (); } break; default: break; } }

void CBrushEditDlg::HandleBrushEditSequenceMsg (  DialogMsg *  Msg  )

Subhandler for messages from the transparency tab, except for the edit box and sliders, which have their own handlers. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: Msg  - the message to handle [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1043 of file brushdlg.cpp. { TalkToPage (_R(IDD_BRUSHEDITSEQUENCE)); switch(Msg->DlgMsg) { case DIM_CREATE: InitBrushSequence (); break; case DIM_COMMIT : { HandleCommit (Msg); DialogManager::DefaultKeyboardFocus (); } break; default: break; } }

void CBrushEditDlg::HandleBrushEditSpacingMsg (  DialogMsg *  Msg  )

Subhandler for messages from the spacing tab, except for the edit box and sliders, which have their own handlers. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: Msg  - the message to handle [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - edit box interaction messages Definition at line 884 of file brushdlg.cpp. { TalkToPage (_R(IDD_BRUSHEDITSPACING)); switch(Msg->DlgMsg) { case DIM_CREATE: InitBrushSpacing (); break; case DIM_COMMIT : { HandleCommit (Msg); DialogManager::DefaultKeyboardFocus (); } break; default: break; } }

void CBrushEditDlg::HandleBrushFillMsg (  DialogMsg *  Msg  )

Subhandler for messages from the fill tab, except for the edit box and sliders, which have their own handlers. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: Msg  - the message to handle [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1083 of file brushdlg.cpp. { TalkToPage (_R(IDD_BRUSHEDITFILL)); switch(Msg->DlgMsg) { case DIM_CREATE: InitBrushFill (); break; case DIM_COMMIT : { HandleCommit (Msg); DialogManager::DefaultKeyboardFocus (); } break; default: break; } }

void CBrushEditDlg::HandleButtonDown (  DialogMsg *  Msg  )  [private]

Definition at line 1850 of file brushdlg.cpp. { // try reading the checkboxes first ReadCheckBox (Msg); // if it wasn't a checkbox then try the buttons if (ChangeType_m == CHANGEBRUSH_NONE) ReadButtons(Msg); // still no joy, try the radio buttons if (ChangeType_m == CHANGEBRUSH_NONE) ReadRadios(Msg); BROADCAST_TO_CLASS (DialogMsg (0, DIM_COMMIT/*Msg->DlgMsg*/, Id_m, (UINT_PTR) (EditData)), DialogBarOp); LaunchOp(); }

void CBrushEditDlg::HandleCommit (  DialogMsg *  Msg  )  [private]

Definition at line 1824 of file brushdlg.cpp. { ReadEditBox (Msg); WriteSliders (Msg); BROADCAST_TO_CLASS (DialogMsg (0, Msg->DlgMsg, Id_m, (UINT_PTR) (EditData)), DialogBarOp); LaunchOp(); }

void CBrushEditDlg::HandleDocSelectionChange (   )  [private]

Definition at line 2922 of file brushdlg.cpp. { AttrBrushType* pAttrBrush = GetSingleSelectedBrushAttribute(); if (pAttrBrush == NULL) { m_bDisableGadgets = TRUE; String_32 Title = TEXT(""); SetDialogTitle(Title); RefreshActivePage(); return; } // lets get the data from the attribute and into our members if (EditData == NULL) EditData = new BrushData; if (EditData == NULL) ERROR3("Unable to allocate brush data in CBrushEditDlg::HandleDocSelectionChange"); *EditData = pAttrBrush->GetBrushData(); if (OriginalData == NULL) OriginalData = new BrushData; if (OriginalData == NULL) ERROR3("Unable to allocate brush data in CBrushEditDlg::HandleDocSelectionChange"); *OriginalData = *EditData; m_LastData = *EditData; m_bDisableGadgets = FALSE; // set the name of the new brush SetDialogTitle(EditData->m_Name); //initialise our opparam with the original data, just in case we want to do change all ChangeParam_m.SetValues(*EditData); EditingBrushDef = FALSE; // now refresh the page that is currently active RefreshActivePage(); }

void CBrushEditDlg::HandleSelectionChange (  DialogMsg *  Msg  )  [private]

Definition at line 1836 of file brushdlg.cpp. { ReadComboBox (Msg); // we are now routing edit box messages through Enter_Select so if we didn't get a result in // the combo boxes then try the edit boxes if (ChangeType_m == CHANGEBRUSH_NONE) ReadEditBox(Msg); BROADCAST_TO_CLASS (DialogMsg (0, Msg->DlgMsg, Id_m, (UINT_PTR) (EditData)), DialogBarOp); // launch the changebrush op LaunchOp(); }

void CBrushEditDlg::HandleSliderPosChanging (  DialogMsg *  Msg  )  [private]

Definition at line 1867 of file brushdlg.cpp. { ReadSlider (Msg); BROADCAST_TO_CLASS (DialogMsg (0, Msg->DlgMsg, Id_m, (UINT_PTR) (EditData)), DialogBarOp); // ok, so in order to avoid generating an undoable op for each slider movement we will only // do so on the first movement, so that undo will take it back to its original position if (!m_SliderStarted) // our flag that indicates if this is the first slider movement or not { TRACEUSER( "Diccon", _T("Launching Op\n")); LaunchOp(); m_SliderStarted = TRUE; } else if (ChangeType_m != CHANGEBRUSH_NONE && EditingBrushDef == FALSE) { ChangeParam_m.ChangeType = ChangeType_m; ChangeBrushAction Action; Action.ChangeSelectionNoUndo(&ChangeParam_m); } }

void CBrushEditDlg::HandleSliderPosSet (  DialogMsg *  Msg  )  [private]

Definition at line 1891 of file brushdlg.cpp. { ReadSlider (Msg); BROADCAST_TO_CLASS (DialogMsg (0, Msg->DlgMsg, Id_m, (UINT_PTR) (EditData)), DialogBarOp); // don't launch an op, see above for comments if (ChangeType_m != CHANGEBRUSH_NONE && EditingBrushDef == FALSE) { ChangeParam_m.ChangeType = ChangeType_m; ChangeBrushAction Action; Action.ChangeSelectionNoUndo(&ChangeParam_m); } m_SliderStarted = FALSE; }

void CBrushEditDlg::HideShuffleIrrelevantButtons (   )  [private]

Because CPropertySheets only let you have an OK, Apply,Cancel, and Help button, we must rename these for our own devious ends and swap their positions. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1233 of file brushdlg.cpp. { TalkToPage (0); // say bye-bye to the ok button! //HideGadget (IDOK, TRUE); // now swap the position of the apply and cancel buttons .... TalkToPage (0); RECT rectApply; GetGadgetPosition (_R(ID_APPLY_NOW), &rectApply); // Preview RECT rectCancel; GetGadgetPosition (_R(IDCANCEL), &rectCancel); // Cancel SetGadgetPosition (_R(IDCANCEL), rectApply); SetGadgetPosition (_R(ID_APPLY_NOW), rectCancel); ChangeButtonText(); }

BOOL CBrushEditDlg::Init (  void   )  [static]

the init function to register us as an Op Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from SimpleCCObject. Definition at line 285 of file brushdlg.cpp. { return ( RegisterOpDescriptor ( 0, // Tool ID _R(IDS_BRUSHEDITDLG), // String resource ID CC_RUNTIME_CLASS (CBrushEditDlg), // Runtime class OPTOKEN_BRUSHEDIT_DLG, // Token string CBrushEditDlg::GetState, // GetState function 0, // Help ID _R(IDBBL_BRUSHEDIT), // Bubble ID _R(IDD_BARCONTROLSTORE), // Resource ID _R(IDC_BRUSHEDIT), // Control ID SYSTEMBAR_EDIT, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation 0, // No vertical counterpart 0, // String for one copy only ( DONT_GREY_WHEN_SELECT_INSIDE | GREY_WHEN_NO_CURRENT_DOC ) // Auto state flags ) ); }

void CBrushEditDlg::InitBrushEffects (  BOOL  OnlyForUnitChange = FALSE  )  [private]

Definition at line 1501 of file brushdlg.cpp. { // set the random slider SetGadgetRange (_R(IDC_SLIDERROTATEANGLEMAXRAND), MIN_RANDOM_SLIDER, MAX_ROTATION_RANDOM_SLIDER); SetGadgetBitmaps (_R(IDC_SLIDERROTATEANGLEMAXRAND), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); SetLongGadgetValue (_R(IDC_SLIDERROTATEANGLEMAXRAND), MAX_ROTATION_RANDOM_SLIDER - (EditData->m_RotationMaxRand) + MIN_RANDOM_SLIDER); SetRandomRangeText(_R(IDC_SLIDERROTATEANGLEMAXRAND)); // set the rotate angle slider and edit field SetDoubleGadgetValue (_R(IDC_EDITROTATEANGLE), EditData->m_RotateAngle); SetGadgetBitmaps (_R(IDC_SLIDERROTATEANGLE), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); SetGadgetRange (_R(IDC_SLIDERROTATEANGLE), MIN_ROTATION_SLIDER, MAX_ROTATION_SLIDER); SetDoubleGadgetValue (_R(IDC_SLIDERROTATEANGLE), (MAX_ROTATION_SLIDER - EditData->m_RotateAngle) + MIN_ROTATION_SLIDER); // set the angle increment slider and edit field SetDoubleGadgetValue (_R(IDC_EDITROTATEANGLEINCR), EditData->m_RotAngleIncrConst); SetGadgetBitmaps (_R(IDC_SLIDERROTATEANGLEINCR), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); SetGadgetRange (_R(IDC_SLIDERROTATEANGLEINCR), MIN_ROTATION_INCR_SLIDER, MAX_ROTATION_INCR_SLIDER); SetDoubleGadgetValue (_R(IDC_SLIDERROTATEANGLEINCR), (MAX_ROTATION_INCR_SLIDER - EditData->m_RotAngleIncrConst) + MIN_ROTATION_INCR_SLIDER); if (m_bDisableGadgets) { ReInitBrushEffects(); return; } if (EditData->m_RotationMaxRand == 0) { EnableGadget (_R(IDC_BUTTONROTATEANGLERANDSEED), FALSE); } if (EditData->m_bRotate) { SetLongGadgetValue (_R(IDC_CHECKROTATE), 1); } }

void CBrushEditDlg::InitBrushFill (  BOOL  OnlyForUnitChange = FALSE  )  [private]

Definition at line 1603 of file brushdlg.cpp. { if (m_bDisableGadgets) { ReInitBrushFill(); return; } // do the hue and saturation sliders SetGadgetBitmaps(_R(IDC_SLIDERSATURATIONRANDOM), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); SetGadgetRange(_R(IDC_SLIDERSATURATIONRANDOM), MIN_RANDOM_SLIDER, MAX_RANDOM_SAT_SLIDER); SetLongGadgetValue(_R(IDC_SLIDERSATURATIONRANDOM), (MAX_RANDOM_SAT_SLIDER - EditData->m_BrushSatMaxRand) + MIN_RANDOM_SLIDER); SetRandomRangeText(_R(IDC_SLIDERSATURATIONRANDOM)); SetGadgetBitmaps(_R(IDC_SLIDERHUERANDOM), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); SetGadgetRange(_R(IDC_SLIDERHUERANDOM), MIN_RANDOM_SLIDER, MAX_RANDOM_HUE_SLIDER); SetLongGadgetValue(_R(IDC_SLIDERHUERANDOM), (MAX_RANDOM_HUE_SLIDER - EditData->m_BrushHueMaxRand) + MIN_RANDOM_SLIDER); SetRandomRangeText(_R(IDC_SLIDERHUERANDOM)); if (EditData->m_BrushHueMaxRand > 0 || EditData->m_BrushSatMaxRand > 0) EnableGadget(_R(IDC_BUTTONBRUSHFILLRANDOM), TRUE); else EnableGadget(_R(IDC_BUTTONBRUSHFILLRANDOM), FALSE); if (EditData->m_bTile) { SetLongGadgetValue (_R(IDC_CHECKTILEING), 1); } else { SetLongGadgetValue (_R(IDC_CHECKTILEING), 0); } // use local options not available for the brush definitions if (!EditingBrushDef) { SetRadioGroupSelected(LocalFillRadioGadgets, _R(IDC_RADIOLOCALFILLNONE)); if (EditData->m_bUseLocalFillColour) { SetRadioGroupSelected(LocalFillRadioGadgets, _R(IDC_RADIOLOCALFILLALL)); } if (EditData->m_bUseNamedColour == FALSE) { SetRadioGroupSelected(LocalFillRadioGadgets, _R(IDC_RADIOLOCALFILLNAMED)); } } else { for (INT32 i = 0; i < NumberOfLocalFillRadios - 1; i++) // -1 because the last value is NULL EnableGadget(LocalFillRadioGadgets[i], FALSE); } }

void CBrushEditDlg::InitBrushOffset (  BOOL  OnlyForUnitChange = FALSE  )  [private]

Definition at line 1363 of file brushdlg.cpp. { SetOffsetValSlider(); // do the addition slider // SetGadgetRange(_R(IDC_SLIDEROFFSETINCRCONST), MIN_SPACING_INCR, MAX_SPACING_INCR); // SetGadgetBitmaps(_R(IDC_SLIDEROFFSETINCRCONST), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); // double PercentVal = GetDistanceAsPercentageOfBBox(EditData->m_PathOffsetIncrConst); // SetDoubleGadgetValue (_R(IDC_SLIDEROFFSETINCRCONST), MAX_SPACING_INCR - PercentVal + MIN_SPACING_INCR); // set up the random slider SetGadgetRange (_R(IDC_SLIDEROFFSETVALUEMAXRAND), MinOffsetSlider, MaxOffsetSlider); SetGadgetBitmaps (_R(IDC_SLIDEROFFSETVALUEMAXRAND), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); SetRandomRangeText(_R(IDC_SLIDEROFFSETVALUEMAXRAND)); if (m_bDisableGadgets) { ReInitBrushOffset(); return; } EnableGadget (_R(IDC_BUTTONOFFSETVALUERANDSEED), FALSE); switch (EditData->m_PathOffsetType) { case OFFSET_NONE: UsingRandomOffset = FALSE; EnableGadget (_R(IDC_STATICPATHOFFSETVALUE), FALSE); EnableGadget (_R(IDC_SPINPATHOFFSETVALUE), FALSE); EnableGadget (_R(IDC_EDITPATHOFFSETVALUE), FALSE); EnableGadget (_R(IDC_STATICPATHOFFSETINCRCONST), FALSE); EnableGadget (_R(IDC_SPINPATHOFFSETINCRCONST), FALSE); EnableGadget (_R(IDC_EDITPATHOFFSETINCRCONST), FALSE); //EnableGadget (_R(IDC_SLIDEROFFSETVALUEMAXRAND), FALSE); EnableGadget (_R(IDC_SLIDERPATHOFFSETVAL), FALSE); EnableGadget (_R(IDC_SLIDEROFFSETINCRCONST), FALSE); //EnableGadget (_R(IDC_STATICOFFSETVALUEMAXRAND), FALSE); break; case OFFSET_RANDOM: EnableGadget (_R(IDC_EDITPATHOFFSETVALUE), FALSE); EnableGadget (_R(IDC_SLIDERPATHOFFSETVAL), FALSE); EnableGadget (_R(IDC_STATICPATHOFFSETVALUE), FALSE); break; default: break; } if (EditData->m_OffsetValueMaxRand > 0) EnableGadget (_R(IDC_BUTTONOFFSETVALUERANDSEED), TRUE); InitComboPathOffsetType (); SetLongGadgetValue (_R(IDC_SLIDEROFFSETVALUEMAXRAND), MaxOffsetSlider - (EditData->m_OffsetValueMaxRand)); }

void CBrushEditDlg::InitBrushScaling (  BOOL  OnlyForUnitChange = FALSE  )  [private]

Definition at line 1438 of file brushdlg.cpp. { // set up the random scaling slider SetGadgetRange (_R(IDC_SLIDERBRUSHSCALINGMAXRAND), MinScalingSlider, MaxScalingSlider); SetGadgetBitmaps (_R(IDC_SLIDERBRUSHSCALINGMAXRAND), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); SetLongGadgetValue (_R(IDC_SLIDERBRUSHSCALINGMAXRAND), MaxScalingSlider - (EditData->m_BrushScalingMaxRand)); SetRandomRangeText(_R(IDC_SLIDERBRUSHSCALINGMAXRAND)); // set up the increment slider // SetGadgetBitmaps (_R(IDC_SLIDERSCALINGINCRCONST), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); // SetLongGadgetValue (_R(IDC_SLIDERSCALINGINCRCONST), (MaxScalingIncrSlider - (EditData->m_BrushScalingIncrConst)) + MinScalingIncrSlider); // SetDoubleGadgetValue(_R(IDC_EDITSCALINGINCRCONST), EditData->m_BrushScalingIncrConst); // setup the pressure slider SetGadgetRange (_R(IDC_SLIDERSCALINGPRESSURE), MIN_PRESSURE_SLIDER, MAX_PRESSURE_SLIDER); SetGadgetBitmaps (_R(IDC_SLIDERSCALINGPRESSURE), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); SetLongGadgetValue (_R(IDC_SLIDERSCALINGPRESSURE), (MAX_PRESSURE_SLIDER - EditData->m_ScalingMaxPressure) + MIN_PRESSURE_SLIDER); SetRandomRangeText(_R(IDC_SLIDERSCALINGPRESSURE)); SetStringGadgetValue(_R(IDC_STATICBRUSHSCALEINFO), _R(IDS_BRUSHSCALE)); if (m_bDisableGadgets) { ReInitBrushScaling(); return; } if (EditData->m_BrushScalingMaxRand == 0) // no random scaling { UsingRandomScaling = FALSE; //EnableGadget (_R(IDC_SLIDERBRUSHSCALINGMAXRAND), FALSE); //EnableGadget (_R(IDC_STATICBRUSHSCALINGMAXRAND), FALSE); EnableGadget (_R(IDC_BUTTONBRUSHSCALINGRANDSEED), FALSE); } else // we have random scaling { UsingRandomScaling = TRUE; // EnableGadget (_R(IDC_STATICBRUSHSCALINGINCR), FALSE); // EnableGadget (_R(IDC_SPINBRUSHSCALINGINCR), FALSE); // EnableGadget (_R(IDC_EDITBRUSHSCALINGINCR), FALSE); } }

void CBrushEditDlg::InitBrushSequence (  BOOL  OnlyForUnitChange = FALSE  )  [private]

Definition at line 1560 of file brushdlg.cpp. { if (m_bDisableGadgets) { ReInitBrushSequence(); return; } // do the transparency sliders SetGadgetBitmaps(_R(IDC_SLIDERTRANSP), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); SetGadgetRange(_R(IDC_SLIDERTRANSP), MIN_TRANSP_SLIDER, MAX_TRANSP_SLIDER); SetLongGadgetValue(_R(IDC_SLIDERTRANSP), (MAX_TRANSP_SLIDER - EditData->m_BrushTransparency) + MIN_TRANSP_SLIDER); SetGadgetBitmaps(_R(IDC_SLIDERTRANSPPRESSURE), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); SetGadgetRange(_R(IDC_SLIDERTRANSPPRESSURE), MIN_PRESSURE_SLIDER, MAX_PRESSURE_SLIDER); SetLongGadgetValue(_R(IDC_SLIDERTRANSPPRESSURE), (MAX_PRESSURE_SLIDER - EditData->m_TranspMaxPressure) + MIN_PRESSURE_SLIDER); UpdateEditBox(_R(IDC_EDITBRUSHTRANSP)); SetRandomRangeText(_R(IDC_SLIDERTRANSPPRESSURE)); }

void CBrushEditDlg::InitBrushSpacing (  BOOL  OnlyForUnitChange = FALSE  )  [private]

Definition at line 1305 of file brushdlg.cpp. { SetSpacingSlider(); // SetSpacingIncrSlider(); // Edit boxes have their own function // UpdateEditBox(_R(IDC_EDITBRUSHSPACINGINCRCONST)); UpdateEditBox (_R(IDC_EDITBRUSHSPACING)); SetGadgetRange (_R(IDC_SLIDERBRUSHSPACINGMAXRAND), MIN_RANDOM_SLIDER, MAX_RANDOM_SLIDER); SetGadgetBitmaps (_R(IDC_SLIDERBRUSHSPACINGMAXRAND), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); SetLongGadgetValue (_R(IDC_SLIDERBRUSHSPACINGMAXRAND), MAX_RANDOM_SLIDER - (EditData->m_BrushSpacingMaxRand) + MIN_RANDOM_SLIDER); SetRandomRangeText(_R(IDC_SLIDERBRUSHSPACINGMAXRAND)); if (m_bDisableGadgets) { ReInitBrushSpacing(); return; } // now have to share the randomize button between spacing and sequence if (EditData->m_BrushSpacingMaxRand == 0 && EditData->m_SequenceType != SEQ_RANDOM ) // no random spacing { UsingRandomSpacing = FALSE; EnableGadget (_R(IDC_BUTTONBRUSHSPACINGRANDSEED), FALSE); } else // we have random spacing { UsingRandomSpacing = TRUE; EnableGadget (_R(IDC_BUTTONBRUSHSPACINGRANDSEED), TRUE); } InitSequenceType (); }

void CBrushEditDlg::InitComboPathOffsetType (   )  [private]

Definition at line 1677 of file brushdlg.cpp. { DeleteAllValues (_R(IDC_COMBOPATHOFFSETTYPE)); SetStringGadgetValue (_R(IDC_COMBOPATHOFFSETTYPE), _R(IDS_OFFSET_NONE), TRUE, 0); SetStringGadgetValue (_R(IDC_COMBOPATHOFFSETTYPE), _R(IDS_OFFSET_ALTERNATE), TRUE, 1); SetStringGadgetValue (_R(IDC_COMBOPATHOFFSETTYPE), _R(IDS_OFFSET_LEFT), TRUE, 2); SetStringGadgetValue (_R(IDC_COMBOPATHOFFSETTYPE), _R(IDS_OFFSET_RIGHT), TRUE, 3); //SetStringGadgetValue (_R(IDC_COMBOPATHOFFSETTYPE), _R(IDS_OFFSET_RANDOM), TRUE, 4); switch (EditData->m_PathOffsetType) { case OFFSET_NONE: SetStringGadgetValue (_R(IDC_COMBOPATHOFFSETTYPE), _R(IDS_OFFSET_NONE), FALSE, -1); break; case OFFSET_ALTERNATE: SetStringGadgetValue (_R(IDC_COMBOPATHOFFSETTYPE), _R(IDS_OFFSET_ALTERNATE), FALSE, -1); break; case OFFSET_LEFT: SetStringGadgetValue (_R(IDC_COMBOPATHOFFSETTYPE), _R(IDS_OFFSET_LEFT), FALSE, -1); break; case OFFSET_RIGHT: SetStringGadgetValue (_R(IDC_COMBOPATHOFFSETTYPE), _R(IDS_OFFSET_RIGHT), FALSE, -1); break; // We have gotten rid of the random option but some may remain from early files, so // display the default default: SetStringGadgetValue (_R(IDC_COMBOPATHOFFSETTYPE), _R(IDS_OFFSET_NONE), FALSE, -1); break; } }

void CBrushEditDlg::InitSequenceType (   )  [private]

Definition at line 1709 of file brushdlg.cpp. { DeleteAllValues (_R(IDC_COMBOSEQUENCETYPE)); SetStringGadgetValue (_R(IDC_COMBOSEQUENCETYPE), _R(IDS_SEQ_FORWARD), TRUE, 0); SetStringGadgetValue (_R(IDC_COMBOSEQUENCETYPE), _R(IDS_SEQ_BACKWARD), TRUE, 1); SetStringGadgetValue (_R(IDC_COMBOSEQUENCETYPE), _R(IDS_SEQ_MIRROR), TRUE, 2); SetStringGadgetValue (_R(IDC_COMBOSEQUENCETYPE), _R(IDS_SEQ_RANDOM), TRUE, 3); switch (EditData->m_SequenceType) { case SEQ_FORWARD: SetStringGadgetValue (_R(IDC_COMBOSEQUENCETYPE), _R(IDS_SEQ_FORWARD), FALSE, -1); break; case SEQ_BACKWARD: SetStringGadgetValue (_R(IDC_COMBOSEQUENCETYPE), _R(IDS_SEQ_BACKWARD), FALSE, -1); break; case SEQ_MIRROR: SetStringGadgetValue (_R(IDC_COMBOSEQUENCETYPE), _R(IDS_SEQ_MIRROR), FALSE, -1); break; case SEQ_RANDOM: SetStringGadgetValue (_R(IDC_COMBOSEQUENCETYPE), _R(IDS_SEQ_RANDOM), FALSE, -1); break; } BrushDefinition* pDef = BrushComponent::FindBrushDefinition(EditData->m_BrushHandle); if (pDef) { UINT32 Num = pDef->GetNumBrushObjects(); if (Num == 1) EnableGadget(_R(IDC_COMBOSEQUENCETYPE), FALSE); } }

void CBrushEditDlg::InvokeVia (  CBrushGadget &  pInvokeWith, BrushHandle  Handle )

Definition at line 1144 of file brushdlg.cpp. { // we need to make sure our handle is valid Document* pDoc = Document::GetCurrent(); if (pDoc == NULL) return; BrushComponent* pBrushComp = (BrushComponent*)pDoc->GetDocComponent(CC_RUNTIME_CLASS(BrushComponent)); if (pBrushComp == NULL) { ERROR3("No brush component in our document"); return; } BrushDefinition* pBrushDef = pBrushComp->FindBrushDefinition(Handle); if (pBrushDef == NULL) return; // set the flag so we know what we're doing EditingBrushDef = TRUE; //get some brush data from the definition BrushData* pInvokeOn = pBrushDef->GetBrushData(); if (pInvokeOn == NULL) return; // for various reasons we want to disable the first operation m_bDisableOps = TRUE; m_Handle = Handle; OpDescriptor* pOpDescriptor = OpDescriptor::FindOpDescriptor (OPTOKEN_BRUSHEDIT_DLG); if( pOpDescriptor != 0 ) { OpParam Param( reinterpret_cast<INT32>( &pInvokeWith ), reinterpret_cast<INT32>( pInvokeOn ) ); DoWithParam( pOpDescriptor, &Param ); } }

void CBrushEditDlg::InvokeVia (  CBrushGadget &  pInvokeWith, BrushData *  pInvokeOn, AttrBrushType *  pBrush, AttrBrushType *  pOrigBrush, BOOL &  bMany )

Definition at line 1181 of file brushdlg.cpp. { if (pInvokeOn == NULL || pBrush == NULL) { ERROR3("Invalid inputs"); return; } OpDescriptor* pOpDescriptor = OpDescriptor::FindOpDescriptor (OPTOKEN_BRUSHEDIT_DLG); if( pOpDescriptor != 0 ) { pAttrBrush_m = pBrush; pOrigAttrBrush_m = pOrigBrush; OpParam Param( reinterpret_cast<INT32>( &pInvokeWith ), reinterpret_cast<INT32>( pInvokeOn ) ); DoWithParam( pOpDescriptor, &Param ); } }

void CBrushEditDlg::InvokeVia (  CBrushGadget &  pInvokeWith, BrushData *  pInvokeOn, AttrBrushType *  pBrush, BOOL &  bMany )

I'm not entirely sure what this does, perhaps Chris will be able to elaborate, I think they were once used as part of launching the dialog, but I think they are no longer used. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1125 of file brushdlg.cpp. { if (pInvokeOn == NULL) { ERROR3("Invalid inputs"); return; } // for various reasons we want to disable the first operation m_bDisableOps = TRUE; OpDescriptor* pOpDescriptor = OpDescriptor::FindOpDescriptor (OPTOKEN_BRUSHEDIT_DLG); if( pOpDescriptor != 0 ) { OpParam Param( reinterpret_cast<INT32>( &pInvokeWith ), reinterpret_cast<INT32>( pInvokeOn ) ); DoWithParam( pOpDescriptor, &Param ); } }

void CBrushEditDlg::LaunchOp (   )  [private]

Definition at line 1908 of file brushdlg.cpp. { // the op we launch differs slightly depending on whether we are editing a brush from // the selection or the brush definition. If its from the selection then its easy if (ChangeType_m != CHANGEBRUSH_NONE) { if (EditingBrushDef == FALSE) { OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_CHANGEBRUSH); if (pOpDesc != NULL ) { ChangeParam_m.ChangeType = ChangeType_m; pOpDesc->Invoke(&ChangeParam_m); m_LastData = *EditData; } } } else TRACEUSER( "Diccon", _T("NOT LAUNCHING OP!!\n")); // reset our member ChangeType_m = CHANGEBRUSH_NONE; // enable the save button SetPropertyPageModified(TRUE); }

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

Message proc for this dialog. Author: This comment by Diccon (function originally by ChrisS) Date: Comment added 15/12/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from DialogTabOp. Definition at line 622 of file brushdlg.cpp. { BOOL bClose = FALSE; if (IS_OUR_DIALOG_MSG (Message)) { DialogMsg* Msg = static_cast<DialogMsg*>( Message ); CDlgResID ThePage = Msg->PageID; // the current page BOOL MessageAlreadyHandled = FALSE; // due to the 'multi-pass' nature of the function INT32 Test = -1; switch (Msg->DlgMsg) { // we don't want the focus .... case DIM_TITLEFOCUSWARN: { // DialogManager::DefaultKeyboardFocus(); // MessageAlreadyHandled = TRUE; // this message is sent because the dialog has moved BROADCAST_TO_ALL(ScreenChangeMsg()); } break; // we don't want the focus .... case DIM_CREATE: { // are we editing a brush definition? if (EditingBrushDef) { // is this the first time the dialog has been created? if (FirstTime) { HideShuffleIrrelevantButtons (); //ResizeDialogAndCreateBrushPreview (); FirstTime = FALSE; } } else { if (FirstTime) { HideShuffleIrrelevantButtons (); FirstTime = FALSE; } } DialogManager::DefaultKeyboardFocus(); } break; case DIM_SET_ACTIVE: { ReInitPage(ThePage); } break; case DIM_COMMIT: // we have renamed the OK button to be Save As New so creat // a new brush here CreateNewBrush(); break; case DIM_SOFT_COMMIT: { // soft commit is generated by the apply button, which we have renamed // we now wish to save this brush data as the brush definition. OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OPTOKEN_CHANGEBRUSHDEF); if (pOpDesc != NULL) { // make a derived class OpParam from the member, and tell it which definition to edit ChangeBrushDefOpParam DefParam; DefParam = ChangeParam_m; DefParam.ChangeType = CHANGEBRUSH_ALL; DefParam.m_Handle = EditData->m_BrushHandle; DefParam.m_NewScaling = 1.0; pOpDesc->Invoke(&DefParam); } EnableGadget(_R(ID_APPLY_NOW), TRUE); } break; // close the dialog .... case DIM_CANCEL: { TRACEUSER( "Diccon", _T("Closing dialog, EditingBD = %d\n"), EditingBrushDef); if (EditingBrushDef) { if (pAttrBrush_m != NULL) delete pAttrBrush_m; } m_bIsOpen = FALSE; Close (); bClose = TRUE; MessageAlreadyHandled = TRUE; } break; // handle sliders: case DIM_SLIDER_POS_CHANGING : { if (!m_bPreventUpdateSet) { if (Tool::GetCurrentID() == TOOLID_FREEHAND) { FreeHandTool* pTool = (FreeHandTool*)Tool::GetCurrent(); pTool->SetBrushUpdateState(UPDATE_NEVER); } m_bPreventUpdateSet = TRUE; } HandleSliderPosChanging (Msg); } break; // handle sliders: case DIM_SLIDER_POS_SET: { if (m_bPreventUpdateSet) { if (Tool::GetCurrentID() == TOOLID_FREEHAND) { FreeHandTool* pTool = (FreeHandTool*)Tool::GetCurrent(); pTool->SetBrushUpdateState(UPDATE_ONIDLE); } m_bPreventUpdateSet = FALSE; } HandleSliderPosSet (Msg); } break; // handle buttons case DIM_LFT_BN_CLICKED: { HandleButtonDown(Msg); } break; // now that we have subclassed our edit boxes this handles both combos and edit boxes case DIM_SELECTION_CHANGED: { switch (Msg->DlgMsgParam) { case ENTER_COMMIT: Test = 3; break; case TAB_COMMIT: Test = 4; break; default: break; } HandleSelectionChange (Msg); } break; default: break; } // dispatch message to relevant page handler .... if ( ThePage && !MessageAlreadyHandled) { if (FALSE) {} else if (ThePage == _R(IDD_BRUSHEDITSPACING)) HandleBrushEditSpacingMsg (Msg); else if (ThePage == _R(IDD_BRUSHEDITOFFSET)) HandleBrushEditOffsetMsg (Msg); else if (ThePage == _R(IDD_BRUSHEDITSCALING)) HandleBrushEditScalingMsg (Msg); else if (ThePage == _R(IDD_BRUSHEDITEFFECTS)) HandleBrushEditEffectMsg (Msg); else if (ThePage == _R(IDD_BRUSHEDITSEQUENCE)) HandleBrushEditSequenceMsg (Msg); else if (ThePage == _R(IDD_BRUSHEDITFILL)) HandleBrushFillMsg(Msg); else { ERROR3("Message from unknown tab dialog page"); } } } else // deal with non-dialog messages here { // this message tells us that the brushdefinition has changed so we need // to update our preview window if (Message->IsKindOf(CC_RUNTIME_CLASS(BrushDefMsg))) { // only if we are editing the definition if (EditingBrushDef) { // deelete our attribute node, and ask the definition for a new one GetAttributeNodeFromDefinition(); } } if (MESSAGE_IS_A(Message, SelChangingMsg)) { HandleDocSelectionChange(); } } // Pass all unhandled messages to base class for default processing! MsgResult Result = DialogOp::Message (Message); if (bClose) { PORTNOTE("other", "Disabled CBrushGadget") #ifndef EXCLUDE_FROM_XARALX // tell the owning gadget that this dialog has closed if (m_pOwningGadget != 0) { m_pOwningGadget->DialogHasClosed(); } #endif } return Result; }

void CBrushEditDlg::ReadButtons (  DialogMsg *  Msg  )  [private]

Definition at line 2734 of file brushdlg.cpp. { if (Msg->GadgetID == _R(IDC_BUTTONBRUSHSCALINGRANDSEED)) { ChangeType_m = CHANGEBRUSH_SCALING_RANDSEED; ChangeParam_m.m_NewScalingRandSeed = GetNewRandomNumber(0); EditData->m_BrushScalingRandSeed = ChangeParam_m.m_NewScalingRandSeed; } else if (Msg->GadgetID == _R(IDC_BUTTONBRUSHSPACINGRANDSEED)) { ChangeType_m = CHANGEBRUSH_SPACING_RANDSEED; ChangeParam_m.m_NewSpacingRandSeed = GetNewRandomNumber(0); EditData->m_BrushSpacingRandSeed = ChangeParam_m.m_NewSpacingRandSeed; // We're changing sequence seed too ChangeParam_m.m_NewSequenceRandSeed = EditData->m_BrushSpacingRandSeed; EditData->m_SequenceRandSeed = ChangeParam_m.m_NewSequenceRandSeed; } else if (Msg->GadgetID == _R(IDC_BUTTONOFFSETVALUERANDSEED)) { // bit of a change here, we only want to have one random button on the offset tab // so this button now changes seeds for both offset value and offset type ChangeType_m = CHANGEBRUSH_OFFSET_SEEDS; ChangeParam_m.m_NewOffsetValRandSeed = GetNewRandomNumber(0); ChangeParam_m.m_NewOffsetTypeRandSeed = GetNewRandomNumber(0); EditData->m_OffsetValueRandSeed = ChangeParam_m.m_NewOffsetValRandSeed; EditData->m_OffsetTypeRandSeed = ChangeParam_m.m_NewOffsetTypeRandSeed; } else if (Msg->GadgetID == _R(IDC_BUTTONBRUSHSEQUENCERANDSEED)) { ChangeType_m = CHANGEBRUSH_SEQUENCE_RANDSEED; ChangeParam_m.m_NewSequenceRandSeed = GetNewRandomNumber(0); EditData->m_SequenceRandSeed = ChangeParam_m.m_NewSequenceRandSeed; } else if (Msg->GadgetID == _R(IDC_BUTTONROTATEANGLERANDSEED)) { ChangeType_m = CHANGEBRUSH_ROTATE_RANDSEED; ChangeParam_m.m_NewRotateRandSeed = GetNewRandomNumber(0); EditData->m_RotationRandSeed = ChangeParam_m.m_NewRotateRandSeed; } else if (Msg->GadgetID == _R(IDC_BUTTONBRUSHFILLRANDOM)) { ChangeType_m = CHANGEBRUSH_FILL_SEEDS; ChangeParam_m.m_NewHueRandSeed = GetNewRandomNumber(0); ChangeParam_m.m_NewSatRandSeed = GetNewRandomNumber(0); EditData->m_BrushHueRandSeed = ChangeParam_m.m_NewHueRandSeed; EditData->m_BrushSatRandSeed = ChangeParam_m.m_NewSatRandSeed; } }

void CBrushEditDlg::ReadCheckBox (  DialogMsg *  Msg  )  [private]

Definition at line 2304 of file brushdlg.cpp. { // BOOL Checked; if (Msg->GadgetID == _R(IDC_CHECKTILEING)) { EditData->m_bTile = !(EditData->m_bTile); //GetBoolGadgetSelected (_R(IDC_CHECKTILEING),0, &Checked); //EditData->m_bTile = Checked; ChangeType_m = CHANGEBRUSH_TILED; ChangeParam_m.m_bNewTiled = EditData->m_bTile;//Checked; ReInitBrushFill(); } else if (Msg->GadgetID == _R(IDC_CHECKLOCALFILLCOLOUR)) { //GetBoolGadgetSelected (_R(IDC_CHECKLOCALFILLCOLOUR),0, &Checked); EditData->m_bUseLocalFillColour = !(EditData->m_bUseLocalFillColour);//Checked; ChangeType_m = CHANGEBRUSH_USELOCALFILLCOL; ChangeParam_m.m_bNewUseLocalFillColour = EditData->m_bUseLocalFillColour;//Checked; ReInitBrushFill(); } else if (Msg->GadgetID == _R(IDC_CHECKOVERRIDENAMED)) { EditData->m_bUseNamedColour = !(EditData->m_bUseNamedColour); ChangeType_m = CHANGEBRUSH_USENAMEDCOL; ChangeParam_m.m_bNewUseNamed = EditData->m_bUseNamedColour; ReInitBrushFill(); } else if (Msg->GadgetID == _R(IDC_CHECKROTATE)) { //GetBoolGadgetSelected (_R(IDC_CHECKROTATE),0, &Checked); EditData->m_bRotate = !(EditData->m_bRotate);//Checked; ChangeType_m = CHANGEBRUSH_TANGENTIAL; ChangeParam_m.m_bNewRotated = EditData->m_bRotate;//Checked; // ReInitBrushEffects (); /*if (!(EditData->m_bRotate)) { EditData->m_RotateAngle = DefaultRotationAngle; }*/ } else { //ERROR3 ("Unrecognised gadget"); // not necessarily an error, as it may have been a button ChangeType_m = CHANGEBRUSH_NONE; } }

void CBrushEditDlg::ReadComboBox (  DialogMsg *  Msg  )  [private]

Definition at line 2201 of file brushdlg.cpp. { // SequenceType NewSeqType; // PathOffset NewOffsetType; WORD Index = (WORD)(-1); if (Msg->GadgetID == _R(IDC_COMBOPATHOFFSETTYPE)) { GetValueIndex(_R(IDC_COMBOPATHOFFSETTYPE), &Index); UsingRandomOffset = FALSE; switch (Index) { case -1: ERROR3("Invalid index"); break; case OFFSET_NONE: EditData->m_PathOffsetType = OFFSET_NONE; if (EditData->m_OffsetValueMaxRand == 0) ChangeParam_m.m_NewPathOffsetType = OFFSET_NONE; else ChangeParam_m.m_NewPathOffsetType = OFFSET_RANDOM; ChangeType_m = CHANGEBRUSH_OFFSET_TYPE; ReInitBrushOffset (); break; case OFFSET_ALTERNATE: EditData->m_PathOffsetType = OFFSET_ALTERNATE; ChangeType_m = CHANGEBRUSH_OFFSET_TYPE; ChangeParam_m.m_NewPathOffsetType = OFFSET_ALTERNATE; ReInitBrushOffset (); break; case OFFSET_LEFT: EditData->m_PathOffsetType = OFFSET_LEFT; ChangeType_m = CHANGEBRUSH_OFFSET_TYPE; ChangeParam_m.m_NewPathOffsetType = OFFSET_LEFT; ReInitBrushOffset (); break; case OFFSET_RIGHT: EditData->m_PathOffsetType = OFFSET_RIGHT; ChangeType_m = CHANGEBRUSH_OFFSET_TYPE; ChangeParam_m.m_NewPathOffsetType = OFFSET_RIGHT; ReInitBrushOffset (); break; case OFFSET_RANDOM: UsingRandomOffset = TRUE; EditData->m_PathOffsetType = OFFSET_RANDOM; ChangeType_m = CHANGEBRUSH_OFFSET_TYPE; ChangeParam_m.m_NewPathOffsetType = OFFSET_RANDOM; ReInitBrushOffset (); break; default: ERROR3("Unrecognised offset type"); ChangeType_m = CHANGEBRUSH_NONE; break; } } else if (Msg->GadgetID == _R(IDC_COMBOSEQUENCETYPE)) { GetValueIndex(_R(IDC_COMBOSEQUENCETYPE), &Index); switch(Index) { case SEQ_FORWARD: EditData->m_SequenceType = SEQ_FORWARD; ChangeType_m = CHANGEBRUSH_SEQUENCE; ChangeParam_m.m_NewSequenceType = SEQ_FORWARD; break; case SEQ_BACKWARD: EditData->m_SequenceType = SEQ_BACKWARD; ChangeType_m = CHANGEBRUSH_SEQUENCE; ChangeParam_m.m_NewSequenceType = SEQ_BACKWARD; break; case SEQ_MIRROR: EditData->m_SequenceType = SEQ_MIRROR; ChangeType_m = CHANGEBRUSH_SEQUENCE; ChangeParam_m.m_NewSequenceType = SEQ_MIRROR; break; case SEQ_RANDOM: EditData->m_SequenceType = SEQ_RANDOM; ChangeType_m = CHANGEBRUSH_SEQUENCE; ChangeParam_m.m_NewSequenceType = SEQ_RANDOM; break; default: ERROR3("Unrecognised sequence type"); ChangeType_m = CHANGEBRUSH_NONE; break; } ReInitBrushSpacing(); } else ChangeType_m = CHANGEBRUSH_NONE; }

void CBrushEditDlg::ReadEditBox (  DialogMsg *  Msg  )  [private]

Definition at line 2005 of file brushdlg.cpp. { MILLIPOINT MilliPointNewVal; double DoubleNewVal; INT32 LongNewVal; BOOL Valid = FALSE; ChangeType_m = CHANGEBRUSH_NONE; // brush spacing stuff .... if (FALSE) {} else if (Msg->GadgetID == _R(IDC_EDITBRUSHSPACING)) { double MinSpacingSlider = 0; double MaxSpacingSlider = 0; GetSpacingRange(&MinSpacingSlider, &MaxSpacingSlider); DoubleNewVal = GetDoubleGadgetValue (_R(IDC_EDITBRUSHSPACING), MinSpacingSlider , MaxSpacingSlider); MILLIPOINT NewVal = GetPercentageAsDistance(DoubleNewVal, WIDTH); DoubleNewVal = pow((double)NewVal, InvFactor); if (DoubleNewVal >= MinSpacingSlider && DoubleNewVal <= MaxSpacingSlider) { if (EditData->m_BrushSpacing != NewVal) { EditData->m_BrushSpacing = NewVal; ChangeType_m = CHANGEBRUSH_SPACING; ChangeParam_m.m_NewSpacing = NewVal; ReInitBrushSpacing(); } } else { //InformWarning(_R(IDS_BRUSHSPACING_INVALID)); UpdateEditBox(_R(IDC_EDITBRUSHSPACING)); } } else if (Msg->GadgetID == _R(IDC_EDITBRUSHSPACINGINCRCONST)) { DoubleNewVal = GetDoubleGadgetValue(_R(IDC_EDITBRUSHSPACINGINCRCONST), MIN_SPACING_INCR, MAX_SPACING_INCR, _R(IDS_BRUSHINCRINVALID), &Valid); if (DoubleNewVal > MIN_SPACING_INCR && DoubleNewVal < MAX_SPACING_INCR && Valid) { // we need to convert the % value we got from the slider into millipoints MILLIPOINT Distance = GetPercentageAsDistance(DoubleNewVal, WIDTH); if (abs(Distance - EditData->m_BrushSpacingIncrConst) > 5) { EditData->m_BrushSpacingIncrConst = Distance; ChangeType_m = CHANGEBRUSH_SPACING_INCRCONST; ChangeParam_m.m_NewSpacingIncrConst = Distance; SetSpacingIncrSlider(); } } else { //InformWarning(_R(IDS_BRUSHINCRINVALID)); UpdateEditBox(_R(IDC_EDITBRUSHSPACINGINCRCONST)); } } else if (Msg->GadgetID == _R(IDC_EDITPATHOFFSETVALUE)) { DoubleNewVal = GetDoubleGadgetValue(_R(IDC_EDITPATHOFFSETVALUE), MinOffset, MaxOffset,0, &Valid ); if (DoubleNewVal <= MaxOffset && DoubleNewVal >= MinOffset && Valid) { // convert the % val into millipoints MILLIPOINT Offset = GetPercentageAsDistance(DoubleNewVal, HEIGHT); if (abs(Offset - EditData->m_PathOffsetValue) > 5) { EditData->m_PathOffsetValue = Offset; ChangeType_m = CHANGEBRUSH_OFFSET_VAL; ChangeParam_m.m_NewPathOffsetVal = Offset; ReInitBrushOffset(); } } else { UpdateEditBox(_R(IDC_EDITPATHOFFSETVALUE)); } } else if (Msg->GadgetID == _R(IDC_EDITPATHOFFSETINCRCONST)) { DoubleNewVal = GetDoubleGadgetValue(_R(IDC_EDITPATHOFFSETINCRCONST), MIN_SPACING_INCR, MAX_SPACING_INCR, _R(IDS_BRUSHINCRINVALID), &Valid); if (Valid && DoubleNewVal <= MAX_SPACING_INCR && DoubleNewVal >= MIN_SPACING_INCR) { MilliPointNewVal = GetPercentageAsDistance(DoubleNewVal, HEIGHT); if (EditData->m_PathOffsetIncrConst != MilliPointNewVal) { EditData->m_PathOffsetIncrConst = MilliPointNewVal; ChangeParam_m.m_NewOffsetIncrConst = MilliPointNewVal; ChangeType_m = CHANGEBRUSH_OFFSET_INCRCONST; ReInitBrushOffset(); } } else { //InformWarning(_R(IDS_BRUSHINCRINVALID)); UpdateEditBox(_R(IDC_EDITPATHOFFSETINCRCONST)); } } else if (Msg->GadgetID == _R(IDC_EDITSCALINGINCRCONST)) { DoubleNewVal = GetDoubleGadgetValue (_R(IDC_EDITSCALINGINCRCONST), MinScalingIncrSlider, MaxScalingIncrSlider, _R(IDS_BRUSHSCALINGINCRINVALID), &Valid); if (DoubleNewVal <= MaxScalingIncrSlider && DoubleNewVal >= MinScalingIncrSlider && Valid) { // we need to convert the % value we got from the slider into millipoints if (EditData->m_BrushScalingIncrConst != DoubleNewVal) { EditData->m_BrushScalingIncrConst = DoubleNewVal; ReInitBrushScaling(); ChangeType_m = CHANGEBRUSH_SCALING_INCRCONST; ChangeParam_m.m_NewScalingIncrConst = EditData->m_BrushScalingIncrConst; } } else { //InformWarning(_R(IDS_BRUSHSCALINGINCRINVALID)); UpdateEditBox(_R(IDC_EDITSCALINGINCRCONST)); } } else if (Msg->GadgetID == _R(IDC_EDITBRUSHSCALINGINCR)) { DoubleNewVal = GetDoubleGadgetValue (_R(IDC_EDITBRUSHSCALINGINCR), MinMultiSlider, MaxMultiSlider, _R(IDS_INCRPROP_INVALID), &Valid); if (! Valid || DoubleNewVal < MinMultiSlider || DoubleNewVal > MaxMultiSlider) { //InformWarning(_R(IDS_INCRPROP_INVALID)); UpdateEditBox(_R(IDC_EDITBRUSHSCALINGINCR)); } else { if (EditData->m_BrushScalingIncr != DoubleNewVal / 100) { EditData->m_BrushScalingIncr = DoubleNewVal / 100; ChangeType_m = CHANGEBRUSH_SCALING_INCR; ChangeParam_m.m_NewScalingIncr = DoubleNewVal / 100; ReInitBrushScaling(); } } } else if (Msg->GadgetID == _R(IDC_EDITROTATEANGLE)) { DoubleNewVal = GetDoubleGadgetValue(_R(IDC_EDITROTATEANGLE), 0, MAX_ANGLE_DEG, _R(IDS_BRUSHANGLE_INVALID), &Valid ); if (! Valid || DoubleNewVal < 0 || DoubleNewVal > MAX_ANGLE_DEG) { //InformWarning(_R(IDS_BRUSHANGLE_INVALID)); UpdateEditBox(_R(IDC_EDITROTATEANGLE)); } else { if (EditData->m_RotateAngle != DoubleNewVal) { EditData->m_RotateAngle = DoubleNewVal; ChangeType_m = CHANGEBRUSH_ROTATE_ANGLE; ChangeParam_m.m_NewRotateAngle = DoubleNewVal; ReInitBrushEffects(); } } } else if (Msg->GadgetID == _R(IDC_EDITROTATEANGLEINCR)) { DoubleNewVal = GetDoubleGadgetValue(_R(IDC_EDITROTATEANGLEINCR), MIN_ANGLE_DEG , MAX_ANGLE_DEG, _R(IDS_BRUSHANGLE_INVALID), &Valid); if (!Valid || DoubleNewVal < MIN_ANGLE_DEG || DoubleNewVal > MAX_ANGLE_DEG) { //InformWarning(_R(IDS_BRUSHANGLE_INVALID)); UpdateEditBox(_R(IDC_EDITROTATEANGLEINCR)); } else { if (EditData->m_RotAngleIncrConst != DoubleNewVal) { EditData->m_RotAngleIncrConst = DoubleNewVal ; ChangeType_m = CHANGEBRUSH_ROTATE_INCRCONST; ChangeParam_m.m_NewRotationIncrConst = DoubleNewVal ; ReInitBrushEffects(); } } } else if (Msg->GadgetID == _R(IDC_EDITBRUSHTRANSP)) { LongNewVal = GetLongGadgetValue(_R(IDC_EDITBRUSHTRANSP), MIN_TRANSP_SLIDER-100 , MAX_TRANSP_SLIDER-100, _R(IDS_BRUSHTRANSP_INVALID), &Valid); if (Valid) { if (EditData->m_BrushTransparency != LongNewVal + 100) { EditData->m_BrushTransparency = LongNewVal + 100; ChangeType_m = CHANGEBRUSH_TRANSP; ChangeParam_m.m_NewTransp = EditData->m_BrushTransparency; ReInitBrushSequence(); } } UpdateEditBox(_R(IDC_EDITBRUSHTRANSP)); } }

void CBrushEditDlg::ReadRadios (  DialogMsg *  Msg  )  [private]

Definition at line 2352 of file brushdlg.cpp. { if (Msg == NULL) return; if (Msg->GadgetID == _R(IDC_RADIOLOCALFILLALL)) { if (EditData->m_bUseLocalFillColour == FALSE) { EditData->m_bUseLocalFillColour = TRUE; // we need to set this to true to indicate that we are not overriding only named // colours, the semantics are a little off i'm afraid EditData->m_bUseNamedColour = TRUE; ChangeParam_m.m_bNewUseLocalFillColour = TRUE; ChangeType_m = CHANGEBRUSH_USELOCALFILLCOL; } } else if (Msg->GadgetID == _R(IDC_RADIOLOCALFILLNAMED)) { // potentially a bit confusing this: if UseNamed == TRUE then we do not use // any of the local colours, if UseNamed == FALSE then we do if (EditData->m_bUseNamedColour == TRUE) { EditData->m_bUseNamedColour = FALSE; EditData->m_bUseLocalFillColour = FALSE; ChangeParam_m.m_bNewUseNamed = FALSE; ChangeType_m = CHANGEBRUSH_USENAMEDCOL; } } else if (Msg->GadgetID == _R(IDC_RADIOLOCALFILLNONE)) { // find out which local option was selected and turn it off if (EditData->m_bUseLocalFillColour) { EditData->m_bUseLocalFillColour = FALSE; ChangeParam_m.m_bNewUseLocalFillColour = FALSE; ChangeType_m = CHANGEBRUSH_USELOCALFILLCOL; } if (EditData->m_bUseNamedColour == FALSE) { EditData->m_bUseNamedColour = TRUE; ChangeParam_m.m_bNewUseNamed = TRUE; ChangeType_m = CHANGEBRUSH_USENAMEDCOL; } } }

void CBrushEditDlg::ReadSlider (  DialogMsg *  Msg  )  [private]

Definition at line 2401 of file brushdlg.cpp. { BOOL Valid; INT32 Result; ChangeType_m = CHANGEBRUSH_NONE; // initialise our op type to none if (Msg->GadgetID == _R(IDC_SLIDERBRUSHSPACING1)) { double MinSpacingSlider = 0; double MaxSpacingSlider = 0; GetSpacingRange(&MinSpacingSlider, &MaxSpacingSlider); INT32 IntMin = (INT32)(MinSpacingSlider); INT32 IntMax = (INT32)(MaxSpacingSlider); Result = GetLongGadgetValue (_R(IDC_SLIDERBRUSHSPACING1), IntMin, IntMax, 0, &Valid); Result = (IntMax - Result) + IntMin; if (Valid) { double ExpVal = pow(Result, ExpFactor); MILLIPOINT NewSpacing = (MILLIPOINT)ExpVal; EditData->m_BrushSpacing = NewSpacing; ChangeParam_m.m_NewSpacing = NewSpacing; ChangeType_m = CHANGEBRUSH_SPACING; SetSpacingSlider(); } } else if (Msg->GadgetID == _R(IDC_SLIDERBRUSHSPACINGINCR)) { double dblResult = GetDoubleGadgetValue(_R(IDC_SLIDERBRUSHSPACINGINCR), MIN_SPACING_INCR, MAX_SPACING_INCR, 0, &Valid); dblResult = (MAX_SPACING_INCR - dblResult) + MIN_SPACING_INCR; if (Valid) { // we need to convert the % value we got from the slider into millipoints MILLIPOINT Distance = GetPercentageAsDistance(dblResult, WIDTH); EditData->m_BrushSpacingIncrConst = Distance; ChangeParam_m.m_NewSpacingIncrConst = Distance; ChangeType_m = CHANGEBRUSH_SPACING_INCRCONST; UpdateEditBox(_R(IDC_EDITBRUSHSPACINGINCRCONST)); } } else if (Msg->GadgetID == _R(IDC_SLIDERBRUSHSPACINGMAXRAND)) { Result = GetLongGadgetValue (_R(IDC_SLIDERBRUSHSPACINGMAXRAND), MIN_RANDOM_SLIDER, MAX_RANDOM_SLIDER, 0, &Valid); Result = MAX_RANDOM_SLIDER - Result; if (Valid) { EditData->m_BrushSpacingMaxRand = Result; if (!UsingRandomSpacing) { if (Result != MIN_RANDOM_SLIDER) { ReInitBrushSpacing (); } } else if (Result == MIN_RANDOM_SLIDER) { ReInitBrushSpacing (); } ChangeType_m = CHANGEBRUSH_SPACING_MAXRAND; ChangeParam_m.m_NewSpacingMaxRand = Result; SetRandomRangeText(_R(IDC_SLIDERBRUSHSPACINGMAXRAND)); } } else if (Msg->GadgetID == _R(IDC_SLIDERPATHOFFSETVAL)) { double MinOffset = 0; double MaxOffset = 0; GetOffsetRange(&MinOffset, &MaxOffset); INT32 lMinOffset = (INT32)MinOffset; INT32 lMaxOffset = (INT32)MaxOffset; Result = GetLongGadgetValue(_R(IDC_SLIDERPATHOFFSETVAL), lMinOffset, lMaxOffset, 0, &Valid); Result = (lMaxOffset - Result) + lMinOffset; if (Valid) { double ExpVal = pow(Result, ExpFactor); MILLIPOINT NewOffset = (MILLIPOINT)ExpVal; EditData->m_PathOffsetValue = NewOffset; ChangeParam_m.m_NewPathOffsetVal = NewOffset; ChangeType_m = CHANGEBRUSH_OFFSET_VAL; ReInitBrushOffset(); } } else if (Msg->GadgetID == _R(IDC_SLIDEROFFSETINCRCONST)) { double NewIncr = GetDoubleGadgetValue(_R(IDC_SLIDEROFFSETINCRCONST), MIN_SPACING_INCR, MAX_SPACING_INCR, 0, &Valid); if (Valid) { NewIncr = (MAX_SPACING_INCR - NewIncr) + MIN_SPACING_INCR; MILLIPOINT Incr = GetPercentageAsDistance(NewIncr, HEIGHT); if (abs(EditData->m_PathOffsetIncrConst - Incr) > 20) { EditData->m_PathOffsetIncrConst = Incr; ChangeParam_m.m_NewOffsetIncrConst = Incr; ChangeType_m = CHANGEBRUSH_OFFSET_INCRCONST; UpdateEditBox(_R(IDC_EDITPATHOFFSETINCRCONST)); } } } else if (Msg->GadgetID == _R(IDC_SLIDEROFFSETVALUEMAXRAND)) { Result = GetLongGadgetValue (_R(IDC_SLIDEROFFSETVALUEMAXRAND), MinOffsetSlider, MaxOffsetSlider, 0, &Valid); Result = MaxOffsetSlider - Result; if (Valid) { EditData->m_OffsetValueMaxRand = Result; // if this is the first movement of the slider and our offset type is offset_none then // surreptitiously change this to offset_random if (EditData->m_PathOffsetType == OFFSET_NONE) { EditData->m_PathOffsetType = OFFSET_RANDOM; ChangeParam_m.m_NewPathOffsetType = OFFSET_RANDOM; ChangeType_m = CHANGEBRUSH_ALL; } else ChangeType_m = CHANGEBRUSH_OFFSET_MAXRAND; ChangeParam_m.m_NewOffsetValMaxRand = Result; } ReInitBrushOffset(); } else if (Msg->GadgetID == _R(IDC_SLIDERBRUSHSCALINGMAXRAND)) { Result = GetLongGadgetValue (_R(IDC_SLIDERBRUSHSCALINGMAXRAND), MinScalingSlider, MaxScalingSlider, 0, &Valid); Result = MaxScalingSlider - Result; if (Valid) { EditData->m_BrushScalingMaxRand = Result; if (!UsingRandomScaling) { if (Result != MinScalingSlider) { ReInitBrushScaling (); } } else if (Result == MinScalingSlider) { ReInitBrushScaling (); } SetRandomRangeText(_R(IDC_SLIDERBRUSHSCALINGMAXRAND)); ChangeType_m = CHANGEBRUSH_SCALING_MAXRAND; ChangeParam_m.m_NewScalingMaxRand = Result; } } else if (Msg->GadgetID == _R(IDC_SLIDERROTATEANGLE)) { double NewAngle = GetDoubleGadgetValue(_R(IDC_SLIDERROTATEANGLE), MIN_ROTATION_SLIDER, MAX_ROTATION_SLIDER, 0, &Valid); if (Valid) { NewAngle = (MAX_ROTATION_SLIDER - NewAngle) + MIN_ROTATION_SLIDER; // make it a whole number INT32 AngleRounded = (INT32)NewAngle; ChangeParam_m.m_NewRotateAngle = (double)AngleRounded; ChangeType_m = CHANGEBRUSH_ROTATE_ANGLE; EditData->m_RotateAngle = ChangeParam_m.m_NewRotateAngle; ReInitBrushEffects(); } } else if (Msg->GadgetID == _R(IDC_SLIDERROTATEANGLEINCR)) { double NewIncr = GetDoubleGadgetValue(_R(IDC_SLIDERROTATEANGLEINCR), MIN_ROTATION_INCR_SLIDER, MAX_ROTATION_INCR_SLIDER, 0, &Valid); if (Valid) { NewIncr = (MAX_ROTATION_INCR_SLIDER - NewIncr) + MIN_ROTATION_INCR_SLIDER; INT32 IncrRounded = (INT32)NewIncr; EditData->m_RotAngleIncrConst =(double)IncrRounded; ChangeParam_m.m_NewRotationIncrConst = EditData->m_RotAngleIncrConst; ChangeType_m = CHANGEBRUSH_ROTATE_INCRCONST; ReInitBrushEffects(); } } else if (Msg->GadgetID == _R(IDC_SLIDERROTATEANGLEMAXRAND)) { Result = GetLongGadgetValue (_R(IDC_SLIDERROTATEANGLEMAXRAND), MIN_RANDOM_SLIDER, MAX_ROTATION_RANDOM_SLIDER, 0, &Valid); Result = (MAX_ROTATION_RANDOM_SLIDER - Result) + MIN_RANDOM_SLIDER; //TRACEUSER( "Diccon", _T("Rotation max rand = %d\n"), Result); if (Valid) { EditData->m_RotationMaxRand = Result; ReInitBrushEffects (); ChangeType_m = CHANGEBRUSH_ROTATE_MAXRAND; ChangeParam_m.m_NewRotateMaxRand = Result; SetRandomRangeText(_R(IDC_SLIDERROTATEANGLEMAXRAND)); } } else if (Msg->GadgetID == _R(IDC_SLIDERROTATEINCR)) { Result = GetLongGadgetValue(_R(IDC_SLIDERROTATEINCR), MinMultiSlider, MaxMultiSlider, 0, &Valid); Result = (MaxMultiSlider - Result) + MinMultiSlider; if (Valid) { EditData->m_RotAngleIncrProp = (double)((double)Result / 100); ReInitBrushEffects(); ChangeType_m = CHANGEBRUSH_ROTATE_INCRPROP; ChangeParam_m.m_NewRotationIncrProp = EditData->m_RotAngleIncrProp; } } else if (Msg->GadgetID == _R(IDC_SLIDERBRUSHSCALINGINCR)) { Result = GetLongGadgetValue (_R(IDC_SLIDERBRUSHSCALINGINCR), MinMultiSlider, MaxMultiSlider, 0, &Valid); Result = (MaxMultiSlider - Result) + MinMultiSlider; if (Valid) { EditData->m_BrushScalingIncr = (double)Result / 100; ReInitBrushScaling(); ChangeType_m = CHANGEBRUSH_SCALING_INCR; ChangeParam_m.m_NewScalingIncr = EditData->m_BrushScalingIncr; } } else if (Msg->GadgetID == _R(IDC_SLIDERSCALINGINCRCONST)) { Result = GetLongGadgetValue(_R(IDC_SLIDERSCALINGINCRCONST), MinScalingIncrSlider, MaxScalingIncrSlider, 0, &Valid); Result = (MaxScalingIncrSlider - Result) + MinScalingIncrSlider; if (Valid) { if (EditData->m_BrushScalingIncrConst != Result) { EditData->m_BrushScalingIncrConst = (double)Result; ReInitBrushScaling(); ChangeType_m = CHANGEBRUSH_SCALING_INCRCONST; ChangeParam_m.m_NewScalingIncrConst = (double)Result; } } } else if (Msg->GadgetID == _R(IDC_SLIDERSCALINGPRESSURE)) { Result = GetLongGadgetValue(_R(IDC_SLIDERSCALINGPRESSURE), MIN_PRESSURE_SLIDER, MAX_PRESSURE_SLIDER, 0, &Valid); if (Valid) { Result = (MAX_PRESSURE_SLIDER - Result) + MIN_PRESSURE_SLIDER; EditData->m_ScalingMaxPressure = Result; ReInitBrushScaling(); ChangeType_m = CHANGEBRUSH_SCALING_PRESSURE; ChangeParam_m.m_NewScalingMaxPressure = Result; SetRandomRangeText(_R(IDC_SLIDERSCALINGPRESSURE)); } } else if (Msg->GadgetID == _R(IDC_SLIDERSATURATIONRANDOM)) { Result = GetLongGadgetValue(_R(IDC_SLIDERSATURATIONRANDOM), MIN_RANDOM_SLIDER, MAX_RANDOM_SAT_SLIDER, 0, &Valid); if (Valid) { Result = (MAX_RANDOM_SAT_SLIDER - Result) + MIN_RANDOM_SLIDER; EditData->m_BrushSatMaxRand = Result; ChangeType_m = CHANGEBRUSH_SAT_MAXRAND; ChangeParam_m.m_NewSatMaxRand = Result; SetRandomRangeText(_R(IDC_SLIDERSATURATIONRANDOM)); ReInitBrushFill(); } } else if (Msg->GadgetID == _R(IDC_SLIDERHUERANDOM)) { Result = GetLongGadgetValue(_R(IDC_SLIDERHUERANDOM), MIN_RANDOM_SLIDER, MAX_RANDOM_HUE_SLIDER, 0, &Valid); if (Valid) { Result = (MAX_RANDOM_HUE_SLIDER - Result) + MIN_RANDOM_SLIDER; EditData->m_BrushHueMaxRand = Result; ChangeType_m = CHANGEBRUSH_HUE_MAXRAND; ChangeParam_m.m_NewHueMaxRand = Result; SetRandomRangeText(_R(IDC_SLIDERHUERANDOM)); ReInitBrushFill(); } } else if (Msg->GadgetID == _R(IDC_SLIDERTRANSP)) { Result = GetLongGadgetValue(_R(IDC_SLIDERTRANSP), MIN_TRANSP_SLIDER, MAX_TRANSP_SLIDER, 0, &Valid); if (Valid) { Result = (MAX_TRANSP_SLIDER - Result) + MIN_TRANSP_SLIDER; EditData->m_BrushTransparency = Result; ChangeType_m = CHANGEBRUSH_TRANSP; ChangeParam_m.m_NewTransp = Result; UpdateEditBox(_R(IDC_EDITBRUSHTRANSP)); } } else if (Msg->GadgetID == _R(IDC_SLIDERTRANSPPRESSURE)) { Result = GetLongGadgetValue(_R(IDC_SLIDERTRANSPPRESSURE), MIN_PRESSURE_SLIDER, MAX_PRESSURE_SLIDER, 0, &Valid); if (Valid) { Result = (MAX_PRESSURE_SLIDER - Result) + MIN_PRESSURE_SLIDER; EditData->m_TranspMaxPressure = Result; ChangeType_m = CHANGEBRUSH_TRANSP_PRESSURE; ChangeParam_m.m_NewTranspPressure = Result; ReInitBrushSequence(); } } }

void CBrushEditDlg::RefreshActivePage (   )  [private]

Definition at line 2967 of file brushdlg.cpp. { CDlgResID ActivePageID = GetCurrentPageID(); if (ActivePageID == _R(IDD_BRUSHEDITSPACING)) { ReInitBrushSpacing(); } else if (ActivePageID == _R(IDD_BRUSHEDITOFFSET)) { ReInitBrushOffset(); } else if (ActivePageID == _R(IDD_BRUSHEDITSCALING)) { ReInitBrushScaling(); } else if (ActivePageID == _R(IDD_BRUSHEDITEFFECTS)) { ReInitBrushEffects(); } else if (ActivePageID == _R(IDD_BRUSHEDITSEQUENCE)) { ReInitBrushSequence(); } else if (ActivePageID == _R(IDD_BRUSHEDITFILL)) { ReInitBrushFill(); } }

BOOL CBrushEditDlg::RegisterYourPagesInOrderPlease (   )  [virtual]

This virtual function will get called to give you a chance to add pages to your DialogTabOp. This function will usually make multiple calls to AddAPage to register the initial set of pages to be contained in the tab dialog. The pages should all be the same size and be registered in the left to right order in which you wish them to appear. Author: Simon_Maneggio (Xara Group Ltd) <camelotdev@xara.com> Date: 21/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: return TRUE if all calls to AddAPage returned TRUE This function get's called directly from the Create method, Don't call it explicitly yourself. If you return FALSE from this method then the Create method will fail. Returns: Errors: - See also: DialogTabOp::AddPage DialogOp::Create Reimplemented from DialogTabOp. Definition at line 1200 of file brushdlg.cpp. { BOOL ok = ( AddAPage (_R(IDD_BRUSHEDITSPACING)) && AddAPage (_R(IDD_BRUSHEDITOFFSET)) && AddAPage (_R(IDD_BRUSHEDITSCALING)) && AddAPage (_R(IDD_BRUSHEDITEFFECTS)) && AddAPage (_R(IDD_BRUSHEDITSEQUENCE)) && AddAPage (_R(IDD_BRUSHEDITFILL)) ); return (ok); }

void CBrushEditDlg::ReInitBrushEffects (   )  [private]

Definition at line 1779 of file brushdlg.cpp. { BOOL Enable = !m_bDisableGadgets; for (INT32 i = 0; i < NumberOfBrushEffectsGadgets; i++) { EnableGadget (BrushEffectsGadgetIDs [i], Enable); } if (Enable) InitBrushEffects (); }

void CBrushEditDlg::ReInitBrushFill (   )  [private]

Definition at line 1662 of file brushdlg.cpp. { BOOL Enable = !m_bDisableGadgets; for (INT32 i = 0; i < NumberOfBrushFillGadgets; i++) { EnableGadget (BrushSequenceGadgetIDs [i], Enable); } if (Enable) InitBrushFill (); }

void CBrushEditDlg::ReInitBrushOffset (   )  [private]

Definition at line 1755 of file brushdlg.cpp. { BOOL Enable = !m_bDisableGadgets; for (INT32 i = 0; i < NumberOfBrushOffsetGadgets; i++) { EnableGadget (BrushOffsetGadgetIDs [i], Enable); } if (Enable) InitBrushOffset (); }

void CBrushEditDlg::ReInitBrushScaling (   )  [private]

Definition at line 1767 of file brushdlg.cpp. { BOOL Enable = !m_bDisableGadgets; for (INT32 i = 0; i < NumberOfBrushScalingGadgets; i++) { EnableGadget (BrushScalingGadgetIDs [i], Enable); } if (Enable) InitBrushScaling (); }

void CBrushEditDlg::ReInitBrushSequence (   )  [private]

Definition at line 1791 of file brushdlg.cpp. { BOOL Enable = !m_bDisableGadgets; for (INT32 i = 0; i < NumberOfBrushSequenceGadgets; i++) { EnableGadget (BrushSequenceGadgetIDs [i], Enable); } if (Enable) InitBrushSequence (); }

void CBrushEditDlg::ReInitBrushSpacing (   )  [private]

Definition at line 1744 of file brushdlg.cpp. { BOOL Enable = !m_bDisableGadgets; for (INT32 i = 0; i < NumberOfBrushSpacingGadgets; i++) { EnableGadget (BrushSpacingGadgetIDs [i], Enable); } if (Enable) InitBrushSpacing (); }

void CBrushEditDlg::ReInitialiseDialog (  BrushData *  pData  )

Definition at line 2853 of file brushdlg.cpp. { if (pData != NULL) { if (EditData != NULL) delete EditData; EditData = new BrushData(*pData); if (EditData == NULL) { ERROR3("Argh we failed to allocate new brush data"); return; } // we have to reinit all the pages one by one ReInitPage(_R(IDD_BRUSHEDITSPACING)); ReInitPage(_R(IDD_BRUSHEDITOFFSET)); ReInitPage(_R(IDD_BRUSHEDITSCALING)); ReInitPage(_R(IDD_BRUSHEDITEFFECTS)); ReInitPage(_R(IDD_BRUSHEDITSEQUENCE)); } // end if data }

void CBrushEditDlg::ReInitPage (  CDlgResID  PageID  )  [private]

Definition at line 2876 of file brushdlg.cpp. { // tell the page we're talking to it TalkToPage(PageID); // reinit our active page if (PageID == _R(IDD_BRUSHEDITSPACING)) ReInitBrushSpacing(); else if (PageID == _R(IDD_BRUSHEDITOFFSET)) ReInitBrushOffset(); else if (PageID == _R(IDD_BRUSHEDITSCALING)) ReInitBrushScaling(); else if (PageID == _R(IDD_BRUSHEDITEFFECTS)) ReInitBrushEffects(); else if (PageID == _R(IDD_BRUSHEDITSEQUENCE)) ReInitBrushSequence(); else if (PageID == _R(IDD_BRUSHEDITFILL)) { } else { ERROR3("Message from unknown tab dialog page"); } }

void CBrushEditDlg::ReInitUnitDependantFields (  CDlgResID  ThePage  )  [private]

Definition at line 1804 of file brushdlg.cpp. { if (ThePage == _R(IDD_BRUSHEDITSPACING)) InitBrushSpacing (TRUE); else if (ThePage == _R(IDD_BRUSHEDITOFFSET)) InitBrushOffset (TRUE); else if (ThePage == _R(IDD_BRUSHEDITSCALING)) InitBrushScaling (TRUE); else if (ThePage == _R(IDD_BRUSHEDITEFFECTS)) InitBrushEffects (TRUE); else if (ThePage == _R(IDD_BRUSHEDITSEQUENCE)) InitBrushSequence (TRUE); else if (ThePage == _R(IDD_BRUSHEDITFILL)) InitBrushFill (TRUE); else { ERROR3("Unknown tab dialog page"); } }

void CBrushEditDlg::RemoveControlsFromHelper (   )  [private, virtual]

removing the edit controls from the helper Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 14/7/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: DialogControlHelper class (DlgCtHlp.h/.cpp) Reimplemented from DialogOp. Definition at line 589 of file brushdlg.cpp. { BOOL ok = RemoveDialogControlFromHelper(_R(IDC_EDITBRUSHSPACING), _R(IDD_BRUSHEDITSPACING)); // if (ok) ok = RemoveDialogControlFromHelper(_R(IDC_EDITBRUSHSPACINGINCRCONST), _R(IDD_BRUSHEDITSPACING)); if (ok) ok = RemoveDialogControlFromHelper(_R(IDC_EDITPATHOFFSETVALUE), _R(IDD_BRUSHEDITOFFSET)); // if (ok) ok = RemoveDialogControlFromHelper(_R(IDC_EDITPATHOFFSETINCRCONST), _R(IDD_BRUSHEDITOFFSET)); // if (ok) ok = RemoveDialogControlFromHelper(_R(IDC_EDITSCALINGINCRCONST), _R(IDD_BRUSHEDITSCALING)); if (ok) ok = RemoveDialogControlFromHelper(_R(IDC_EDITROTATEANGLE), _R(IDD_BRUSHEDITEFFECTS)); if (ok) ok = RemoveDialogControlFromHelper(_R(IDC_EDITROTATEANGLEINCR), _R(IDD_BRUSHEDITEFFECTS)); if (ok) ok = RemoveDialogControlFromHelper(_R(IDC_EDITBRUSHTRANSP), _R(IDD_BRUSHEDITSEQUENCE)); return; }

void CBrushEditDlg::SetDialogTitle (  String_256  Title  )

Definition at line 3000 of file brushdlg.cpp. { SetTitlebarName(&Title); }

void CBrushEditDlg::SetOffsetValSlider (   )  [private]

Definition at line 3039 of file brushdlg.cpp. { double MinSlider = 0; double MaxSlider = 0; GetOffsetRange(&MinSlider, &MaxSlider); INT32 IntMin = (INT32)MinSlider; INT32 IntMax = (INT32)MaxSlider; SetGadgetRange(_R(IDC_SLIDERPATHOFFSETVAL), IntMin, IntMax); SetGadgetBitmaps (_R(IDC_SLIDERPATHOFFSETVAL), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); double dOffsetVal = pow((double)EditData->m_PathOffsetValue, InvFactor); INT32 iOffsetVal = (INT32)dOffsetVal; SetLongGadgetValue(_R(IDC_SLIDERPATHOFFSETVAL), (IntMax - iOffsetVal) + IntMin); UpdateEditBox(_R(IDC_EDITPATHOFFSETVALUE)); }

void CBrushEditDlg::SetRandomRangeText (  CGadgetID  SliderID  )  [private]

Definition at line 3246 of file brushdlg.cpp. { BOOL Valid = FALSE; INT32 SliderVal = 0; if (SliderID == _R(IDC_SLIDERBRUSHSPACINGMAXRAND)) { SliderVal = GetLongGadgetValue (_R(IDC_SLIDERBRUSHSPACINGMAXRAND), MIN_RANDOM_SLIDER, MAX_RANDOM_SLIDER, 0, &Valid); if (Valid) { SliderVal = (MAX_RANDOM_SLIDER - SliderVal) + MIN_RANDOM_SLIDER; String_32 RangeText = GetRandomRangeText(SliderVal); SetStringGadgetValue(_R(IDC_STATICBRUSHSPACINGRAND1), RangeText); } } else if (SliderID == _R(IDC_SLIDEROFFSETVALUEMAXRAND)) { SliderVal = GetLongGadgetValue(_R(IDC_SLIDEROFFSETVALUEMAXRAND), MIN_RANDOM_SLIDER, MAX_RANDOM_SLIDER, 0, &Valid); if (Valid) { SliderVal = (MAX_RANDOM_SLIDER - SliderVal) + MIN_RANDOM_SLIDER; String_32 RangeText = TEXT(""); //GetRandomRangeText(SliderVal); String_32 MinString = TEXT("0 - "); String_32 MaxString = TEXT("");; Convert::LongToString((INT32)SliderVal, &MaxString); RangeText += MinString; RangeText += MaxString; SetStringGadgetValue(_R(IDC_STATICOFFSETRAND), RangeText); } } else if (SliderID == _R(IDC_SLIDERBRUSHSCALINGMAXRAND)) { SliderVal = GetLongGadgetValue(_R(IDC_SLIDERBRUSHSCALINGMAXRAND), MinScalingSlider, MaxScalingSlider, 0, &Valid); if (Valid) { SliderVal = (MaxScalingSlider - SliderVal) + MinScalingSlider; String_32 RangeText = GetRandomRangeText(SliderVal); SetStringGadgetValue(_R(IDC_STATICSCALINGRAND), RangeText); } } else if (SliderID == _R(IDC_SLIDERROTATEANGLEMAXRAND)) { // This is a little different as we go from 0 - Max degrees, where Max is determined by // SliderVal * 360 SliderVal = GetLongGadgetValue(_R(IDC_SLIDERROTATEANGLEMAXRAND), MIN_RANDOM_SLIDER, MAX_ROTATION_RANDOM_SLIDER, 0, &Valid); if (Valid) { SliderVal = (MAX_ROTATION_RANDOM_SLIDER - SliderVal) + MIN_RANDOM_SLIDER; //SliderVal = (SliderVal * 2) + 100; double MaxAngle = double(SliderVal); // * 360; //MaxAngle = (MaxAngle * 0.01) - 360; String_32 RangeText(_T("")); String_32 MinString; String_32 MaxString; String_32 MiddleString = _T(" - "); Convert::LongToString(0, &MinString); Convert::LongToString(INT32(MaxAngle), &MaxString); RangeText = MinString; RangeText += MiddleString; RangeText += MaxString; SetStringGadgetValue(_R(IDC_STATICROTATIONRAND), RangeText); } } else if (SliderID == _R(IDC_SLIDERSCALINGPRESSURE)) { SliderVal = GetLongGadgetValue(_R(IDC_SLIDERSCALINGPRESSURE), MIN_PRESSURE_SLIDER, MAX_PRESSURE_SLIDER, 0, &Valid); if (Valid) { // INT32 lSlider = MAX_PRESSURE_SLIDER - (INT32)SliderVal; String_32 MinString = TEXT(""); Convert::LongToString((INT32)SliderVal, &MinString); // our maximum is always 100% String_32 MaxString = TEXT(" - 100"); MinString += MaxString; SetStringGadgetValue(_R(IDC_STATICSCALINGPRESS), MinString); } } else if (SliderID == _R(IDC_SLIDERSATURATIONRANDOM)) { // this is a little different as it only goes from 0 - SliderVal; SliderVal = GetLongGadgetValue(_R(IDC_SLIDERSATURATIONRANDOM), MIN_RANDOM_SLIDER, MAX_RANDOM_SAT_SLIDER, 0, &Valid); if (Valid) { SliderVal = MAX_RANDOM_SAT_SLIDER - SliderVal; String_32 RangeText(_T("")); String_32 MinString; String_32 MaxString; String_32 MiddleString = _T(" - "); Convert::LongToString(0, &MinString); Convert::LongToString(SliderVal, &MaxString); RangeText = MinString; RangeText += MiddleString; RangeText += MaxString; SetStringGadgetValue(_R(IDC_STATICSATRAND), RangeText); } } else if (SliderID == _R(IDC_SLIDERHUERANDOM)) { SliderVal = GetLongGadgetValue(_R(IDC_SLIDERHUERANDOM), MIN_RANDOM_SLIDER, MAX_RANDOM_HUE_SLIDER, 0, &Valid); if (Valid) { SliderVal = MAX_RANDOM_HUE_SLIDER - SliderVal; // String_32 RangeText = GetRandomText(SliderVal, MAX_RANDOM_HUE_SLIDER); // SetStringGadgetValue(_R(IDC_STATICHUERAND), &RangeText); String_32 MinString = TEXT("0 - "); String_32 MaxString = TEXT(""); Convert::LongToString((INT32)SliderVal, &MaxString); MinString += MaxString; SetStringGadgetValue(_R(IDC_STATICSCALINGPRESS), MinString); } } else if (SliderID == _R(IDC_SLIDERTRANSPPRESSURE)) { SliderVal = GetLongGadgetValue(_R(IDC_SLIDERTRANSPPRESSURE), MIN_RANDOM_SLIDER, MAX_RANDOM_SLIDER, 0, &Valid); if (Valid) { SliderVal = MAX_RANDOM_SLIDER - SliderVal; String_32 RangeText = GetRandomText(SliderVal, MAX_RANDOM_SLIDER); SetStringGadgetValue(_R(IDC_STATICTRANSPPRESSURE), RangeText); } } }

void CBrushEditDlg::SetSpacingIncrSlider (   )  [private]

Definition at line 3029 of file brushdlg.cpp. { SetGadgetRange(_R(IDC_SLIDERBRUSHSPACINGINCR), MIN_SPACING_INCR, MAX_SPACING_INCR); SetGadgetBitmaps (_R(IDC_SLIDERBRUSHSPACINGINCR), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); double PercentVal = GetDistanceAsPercentageOfBBox(EditData->m_BrushSpacingIncrConst, WIDTH); SetDoubleGadgetValue(_R(IDC_SLIDERBRUSHSPACINGINCR), (MAX_SPACING_INCR - PercentVal) + MIN_SPACING_INCR); }

void CBrushEditDlg::SetSpacingSlider (   )  [private]

Definition at line 3006 of file brushdlg.cpp. { // first work out the maximum and minimum values for the spacing slider double MinSpacingSlider = 0; double MaxSpacingSlider = 0; GetSpacingRange(&MinSpacingSlider, &MaxSpacingSlider); INT32 IntMin = (INT32)(MinSpacingSlider); INT32 IntMax = (INT32)(MaxSpacingSlider); // set the range SetGadgetRange (_R(IDC_SLIDERBRUSHSPACING1), IntMin, IntMax); SetGadgetBitmaps( _R(IDC_SLIDERBRUSHSPACING1), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); // work out the current actual spacing value double dSpacingValue = (double)EditData->m_BrushSpacing; // * EditData->m_BrushScaling; dSpacingValue = pow(dSpacingValue, 1/ExpFactor); INT32 iSpacingValue = (INT32)dSpacingValue; SetLongGadgetValue (_R(IDC_SLIDERBRUSHSPACING1), (IntMax - iSpacingValue) + IntMin); UpdateEditBox(_R(IDC_EDITBRUSHSPACING)); }

void CBrushEditDlg::UpdateEditBox (  CGadgetID  GadgetToUpdate  )  [private]

Definition at line 2790 of file brushdlg.cpp. { if (GadgetToUpdate == _R(IDC_EDITBRUSHSPACING)) { // work out the current actual spacing value double dSpacingValue = (double)EditData->m_BrushSpacing; // * EditData->m_BrushScaling; MILLIPOINT lSpacingValue = (MILLIPOINT)dSpacingValue; dSpacingValue = pow(dSpacingValue, 1/ExpFactor); // INT32 iSpacingValue = (INT32)dSpacingValue; // get the spacing value as a % and set that in the edit field double SpacingAsPercent = GetDistanceAsPercentageOfBBox(lSpacingValue, WIDTH); SetDoubleGadgetValue (_R(IDC_EDITBRUSHSPACING), SpacingAsPercent); } /* else if (GadgetToUpdate == _R(IDC_EDITBRUSHSPACINGINCRCONST)) { // for the edit box we need to set it as a percentage double PercentVal = GetDistanceAsPercentageOfBBox(EditData->m_BrushSpacingIncrConst); SetDoubleGadgetValue(_R(IDC_EDITBRUSHSPACINGINCRCONST), PercentVal); } */ else if (GadgetToUpdate == _R(IDC_EDITPATHOFFSETVALUE)) { double PercentVal = GetDistanceAsPercentageOfBBox(EditData->m_PathOffsetValue, HEIGHT); SetDoubleGadgetValue(_R(IDC_EDITPATHOFFSETVALUE), PercentVal); } /* else if (GadgetToUpdate == _R(IDC_EDITPATHOFFSETINCRCONST)) { double PercentVal = GetDistanceAsPercentageOfBBox(EditData->m_PathOffsetIncrConst); SetDoubleGadgetValue(_R(IDC_EDITPATHOFFSETINCRCONST), PercentVal); } */ else if (GadgetToUpdate == _R(IDC_EDITBRUSHSCALING)) { SetDoubleGadgetValue (_R(IDC_EDITBRUSHSCALING), EditData->m_BrushScaling); } else if (GadgetToUpdate == _R(IDC_EDITBRUSHSCALINGINCR)) { SetDoubleGadgetValue (_R(IDC_EDITBRUSHSCALINGINCR), EditData->m_BrushScalingIncr*100); } /* else if (GadgetToUpdate == _R(IDC_EDITSCALINGINCRCONST)) { SetDoubleGadgetValue (_R(IDC_EDITSCALINGINCRCONST), EditData->m_BrushScalingIncrConst); } */ else if (GadgetToUpdate == _R(IDC_EDITROTATEANGLEINCR)) { SetDoubleGadgetValue (_R(IDC_EDITROTATEANGLEINCR), EditData->m_RotAngleIncrConst); } else if (GadgetToUpdate == _R(IDC_EDITROTATEANGLE)) { SetDoubleGadgetValue (_R(IDC_EDITROTATEANGLE), EditData->m_RotAngleIncrConst); } else if (GadgetToUpdate == _R(IDC_EDITBRUSHTRANSP)) { SetLongGadgetValue(_R(IDC_EDITBRUSHTRANSP), EditData->m_BrushTransparency - 100); } }

void CBrushEditDlg::WriteSliders (  DialogMsg *  Msg  )  [private]

Definition at line 2785 of file brushdlg.cpp. { }

---

Member Data Documentation

ChangeBrushOpParam CBrushEditDlg::ChangeParam_m [private]

Definition at line 138 of file brushdlg.h.

ChangeBrushType CBrushEditDlg::ChangeType_m [private]

Definition at line 137 of file brushdlg.h.

UnitType CBrushEditDlg::CurrentUserUnitType [private]

Definition at line 149 of file brushdlg.h.

BrushData* CBrushEditDlg::EditData [private]

Definition at line 129 of file brushdlg.h.

CGadgetID CBrushEditDlg::EditGadgetLostFocus [private]

Definition at line 196 of file brushdlg.h.

BOOL CBrushEditDlg::EditingBrushDef [private]

Definition at line 144 of file brushdlg.h.

BOOL CBrushEditDlg::FirstTime [private]

Definition at line 140 of file brushdlg.h.

CGadgetID CBrushEditDlg::Id_m [private]

Definition at line 125 of file brushdlg.h.

const UINT32 CBrushEditDlg::IDD = _R(IDD_BRUSHEDIT) [static]

Definition at line 238 of file brushdlg.h.

BOOL CBrushEditDlg::m_bDisableGadgets [private]

Definition at line 151 of file brushdlg.h.

BOOL CBrushEditDlg::m_bDisableOps [private]

Definition at line 145 of file brushdlg.h.

BOOL CBrushEditDlg::m_bIsOpen = FALSE [static, private]

Definition at line 156 of file brushdlg.h.

BOOL CBrushEditDlg::m_bPreventUpdateSet [private]

Definition at line 153 of file brushdlg.h.

BrushHandle CBrushEditDlg::m_Handle [private]

Definition at line 132 of file brushdlg.h.

BrushData CBrushEditDlg::m_LastData [private]

Definition at line 131 of file brushdlg.h.

CBrushGadget* CBrushEditDlg::m_pOwningGadget [private]

Definition at line 121 of file brushdlg.h.

BOOL CBrushEditDlg::m_SliderStarted [private]

Definition at line 154 of file brushdlg.h.

const CDlgMode CBrushEditDlg::Mode = MODELESS [static]

Definition at line 239 of file brushdlg.h.

BrushData* CBrushEditDlg::OriginalData [private]

Definition at line 128 of file brushdlg.h.

AttrBrushType* CBrushEditDlg::pAttrBrush_m [private]

Definition at line 134 of file brushdlg.h.

DocUnitList* CBrushEditDlg::pDocUnitList [private]

Definition at line 148 of file brushdlg.h.

AttrBrushType* CBrushEditDlg::pOrigAttrBrush_m [private]

Definition at line 135 of file brushdlg.h.

RenderPreviewType CBrushEditDlg::RenderType [private]

Definition at line 146 of file brushdlg.h.

BOOL CBrushEditDlg::UsingRandomOffset [private]

Definition at line 193 of file brushdlg.h.

BOOL CBrushEditDlg::UsingRandomScaling [private]

Definition at line 194 of file brushdlg.h.

BOOL CBrushEditDlg::UsingRandomSpacing [private]

Definition at line 192 of file brushdlg.h.

---

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

• Kernel/brushdlg.h (r1785/r1732)
• Kernel/brushdlg.cpp (r1785/r1732)

---