ColourEditDlg Class Reference

#include <coldlog.h>

Inheritance diagram for ColourEditDlg:

List of all members.

Public Member Functions
	ColourEditDlg ()
	Default constructor for the colour editor dialogue class Notes: You shouldn't really use this constructor if you can avoid it.
	~ColourEditDlg ()
	Destructor for the colour editor dialogue class.
MsgResult	Message (Msg *Message)
	Standard DialogOp message handler, for the Colour Editor dialogue.
void	Do (OpDescriptor *MyOpDesc)
	Toggles the colour editor, and if opening it, finds a useful colour to edit.
void	DoWithParam (OpDescriptor *MyOpDesc, OpParam *Param)
	'Does' a colour editor dialogue op. Shows the dialogue. Scope: private
BOOL	Create ()
	Creates a colour editor dialogue box. Fails if DialogOp::Create fails to create the box.
virtual BOOL	TimedProcessing (void)
BOOL	UpdateColourEditor ()
	This function was originally was a override of the virtual OnIdle() function and was called whist the process had idle time to spare, which slowed down every other process on the computer. This function was modified and renamed so that it is now called by timer messages at fixed periods.
BOOL	StartingPickerDrag ()
BOOL	EndingPickerDrag ()
void	CloseColourEditor ()
	A public method to close the colour editor dialog Scope: public.
void	SetDoTimerProcessing (BOOL Value)
	sets a flag which indicates whether or not the colour picker will do idle processing. If this is set to false the colour picker is effectively disabled. Scope: public
BOOL	GetDoTimerProcessing ()
	Access fn. Scope: public.
Static Public Member Functions
static void	InvokeDialog (ColourList *ParentList, IndexedColour *ColourToEdit)
	Causes a modeless colour editor to appear for the given colour. Some time down the track, if the user commits a change to that colour, the system will be notified of that change via a ColourChangingMsg broadcast.
static BOOL	CanYouEditThis (ColourList *ParentList, IndexedColour *ColourToEdit, BOOL ForceNewMode=FALSE)
	Determines if the colour editor will be happy with you calling InvokeDialog with the given parameters. Allows you to enable/disable any UI mechanism that links onto this method. (e.g. colour line edit colour button uses this to determine if drags can be dropped onto it).
static void	ForceLineOrFillMode (BOOL PreferLineColour=FALSE)
	Sets the editing mode for local colours in the future. Whenever a new colour is chosen for editing, this will specify whether a line or fill colour should be chosen by preference.
static BOOL	Init ()
	Initialises the colour editor dialogue op.
static OpState	GetState (String_256 *, OpDescriptor *)
	Get the state of the Colour editor dialogue op.
static BOOL	OnKeyPress (KeyPress *pKeyPress)
	To handle keypresses. This is called by Application::OnKeyPress before all other keypress handling. Normally the colour editor will just return FALSE as fast as possible, but during drags in the editor, it will return TRUE to stop keypresses getting through to the rest of camelot.
static ColourEditDlg *	GetColourEditDlg ()
static void	SetEditingColour (IndexedColour *newEditingColour, Node *pSourceNode=NULL)
	Camelots new custom colour picker control (also written by me) needs to be able to change the value EditingColour on the fly (based upon the IndexedColour that is has just read/generated) so that we do not generate infinite amounts of undo information (which would be so if we always applied the supplied colour). This function allows us to achieve this functionality. Since this function is static, to access non-static member functions from within, we need to use TheEditor->function () otherwise VC6 complains. Scope: public.
static void	SetAbortColourState (AbortColourState state)
static void	ApplyEditingColourNow (BOOL UseAbortColour=FALSE)
	Camelots new custom colour picker control (also written by me) needs to be able to change the value EditingColour on the fly (based upon the IndexedColour that is has just read/generated) so that we do not generate infinite amounts of undo information (which would be so if we always applied the supplied colour). But we also need to be able to apply the edited colour to the selection when the user has finished dragging my colour picker control. This function allows us to achieve this functionality.
static BOOL	DoAbortColourNow (CWindowID colourPicker)
	Allows camelots new custom colour picker control to abort the changing of a colour (by way of the user pressing the escape key). This function simply applies the abort colour (which was already 'saved' within SetEditingColour (). Scope: public.
static void	DoHandleNamedcolour ()
static void	SetDefaultDisplayModel (INT32 newDisplayModel)
	Camelots new custom colour picker control has changed the way in which the old default colour space stuff worked. If a user selects a colour space on the combobox - then we SHOULD remember this - and NOT jump straight back into the default (i.e. we should now set the selection as the default). We need to do this in two places: 1) internally from within ColourEditDlg::Message (); and 2) when the user sets the defaut model for (local colours) from within the camelot options dialog. This function allows us to achieve the second of these. Scope: public.
static void	AbortColourPickerDrag ()
	Terminate the colour picker drag with extreme prejudice (I.e. pass non-zero WPARAM to prevent it calling us back).
Static Public Attributes
static const ResourceID	IDD = _R(IDD_COLOUREDITDLG)
static const CDlgMode	Mode = MODELESS
Protected Member Functions
OpState	GetCommandState (StringBase *Command, StringBase *ShadeReason)
	Upcall from the menu system to determine te state of a menu command.
void	DoCommand (StringBase *Command)
	Applies a given editor menu command.
void	CloseMyself (void)
	Cleans up, discards data on the colour being edited, and closes the editor window. Used to close the editor in response to different messages, e.g. when the selected document changes, or when the colour is deleted.
void	ShadeMyself (BOOL UnShade=FALSE, BOOL OtherGadgetsOnly=FALSE)
	Shades/Unshades the colour editor dialogue. Used to shade the dialogue while there is nothing available to edit, and return it to a useful state when something becomes available for editing.
void	SetControls (void)
void	SetColourNameList (void)
	Initialises the colour editor dialogue name combo-box list Scope: private.
void	RedrawColourNameList (void)
	Ensures that the colour splodge in the colour name dropdown list is redrawn using the correct new appearance of the colour. Far more efficient than rebuilding the colour list from scratch.
void	SetExtent (void)
	If necessary, changes the size of the editor window and shuffles controls around to show folded/unfolded tint/linked information appropriately. If the State has not been reset or changed, this may do nothing, to minimise unnecessary redraws.
void	InvalidateAndSetControls (void)
	Invalidates all of the GDraw colour-display areas (picker, patch, parent patch) and also calls SetControls to set up all the controls. Called whenever the colour has changed so significantly that the entire window needs to be updated.
void	InvalidatePatchGadget (ReDrawInfoType *Info=NULL)
	Invalidates the current colour patch to ensure it is redrawn.
void	SetColour (BOOL SetComponents=TRUE)
	Reads the colour definition from the window into the colour which is currently being edited, and broadcasts a colour changing message so everybody knows about the change.
void	SetComponentInfo (UINT32 ComponentID, UINT32 NameGadget, UINT32 WritableGadget, UINT32 InheritGadget)
	Finds and sets the component name for one gadget. If the component is not used in the EditingColours colour model, then the name is blanked and the related writable gadget is shaded.
void	SetAllHexComponentsInfo (UINT32 ComponentID, UINT32 NameGadget, UINT32 WritableGadget)
	Finds and sets all component names for the hex gadget. This actually gets the individual rgb values, and concatenates into a single string of the form rrggbb for display.
void	FindUsefulColourToEdit (BOOL WantLineColour=FALSE, BOOL TheWindowIsOpen=TRUE)
	Calls the ColourManager method (cf SeeAlso) to determine which colour should be displayed in the editor, and swaps to editing this colour (or if no colour is available, shades the editor).
void	ApplyNoColour (BOOL LineColour)
	Sets either the fill or the line colour to "No colour".
void	LimitTo216Only ()
	Finds the nearest 20% value for this component, e.g. if n=0.23, the result will be 0.2 as this is the closest 20% value.Snaps the current colour to the closest colour in the web browseer palette.
FIXED24	Nearest20Percent (FIXED24 n)
void	EditThisColour (ColourList *ParentList, IndexedColour *ColourToEdit, BOOL TheWindowIsOpen=TRUE)
	Switches the colour editor, when it is open, to edit a different colour If the ColourToEdit is the colour currently being edited, nothing happens Scope: protected.
void	EditingColourHasChanged (BOOL RedrawControls=TRUE, BOOL RedrawPicker=TRUE, BOOL FastTrackPicker=FALSE, Node *pSourceNode=NULL)
	Generic code to handle changes to EditingColour.
void	ApplyColourNow (IndexedColour *ColourToApply)
	Applies the EditingColour to the document selection. Whether named or unnamed, it is applied as a new colour attribute, thus changing the colour used by the selected objects (rather than just redrawing static references to a colour which has been modified).
IndexedColour *	FindSafeParent (IndexedColour *SuggestedParent, BOOL ChildIsATint)
	Determines a safe parent colour to use for a tint/link colour. If the suggested parent will do, it is returned, otherwise the first safe parent in the ParentList ColourList will be returned.
void	CompileParentColourList (CGadgetID TargetGadget)
	Sets up the given combo box gadget to provide a list of all the colours which can be used as a parent of an IndexedColour. This creates the list in the dialogue gadget specified, and selects the appropriate parent (of EditingColour) by default.
IndexedColour *	DecodeParentColourListSelection (INT32 Index)
	Shared code used by ColourTint and CoourLink Dlgs to decode selctions in the list of colours created by CompileParentColourList.
BOOL	OnMakeLocalToFrame ()
	Invokes the OpMakeColourLocalToFrame operation to make local copy of the current edited colour.
BOOL	ShouldUngrey (IndexedColour *pCol)
void	ResetState (void)
BOOL	IsSetGadgetValueCalled () const
BOOL	EnteredSetGadgetValue ()
BOOL	ExitedSetGadgetValue ()
void	RenderCross (RenderRegion *pRender, DocRect *CrossRect, INT32 PixelSize, BOOL Shaded=FALSE)
	Renders a colour picker marker cross (a 'plus' shape).
void	RenderParentCross (RenderRegion *pRender, DocRect *CrossRect, INT32 PixelSize)
	Renders a colour picker marker cross (an 'x' shape) to indicate the position of the PARENT colour on the colour's picker. Used for shades and maybe for linked colours if they ever become relative.
void	RenderConstraint (RenderRegion *pRender, DocCoord End1, DocCoord End2)
	Renders a colour picker constraint bubble. This is a "sausage" in a straight line around two endpoints, used to mark drag constraints on screen.
void	RenderControl (UINT32 GadgetToRender, ReDrawInfoType *RedrawInfo)
	Renders the controls that are kernel-redrawn (The colour 'picker' section, and the two (original and new colour definitions) colour patches).
void	RenderPickerHSV (RenderRegion *pRender, DocRect *VirtualSize, INT32 PixelSize, DialogColourInfo *RedrawColours, DocRect *pClipRect)
	Redraws a colour picker control for the colour editor dialogue. This is used in the given display mode to display the colour information in a useful format. e.g. in HSV mode, a wheel and slider arrangement.
void	RenderPickerRGB (RenderRegion *pRender, DocRect *VirtualSize, INT32 PixelSize, DialogColourInfo *RedrawColours)
	Redraws a colour picker control for the colour editor dialogue. This is used in the given display mode to display the colour information in a useful format. e.g. in HSV mode, a wheel and slider arrangement.
void	RenderPickerCMYK (RenderRegion *pRender, DocRect *VirtualSize, INT32 PixelSize, DialogColourInfo *RedrawColours)
	Redraws a colour picker control for the colour editor dialogue. This is used in the given display mode to display the colour information in a useful format. e.g. in HSV mode, a wheel and slider arrangement.
void	RenderPickerDefault (RenderRegion *pRender, DocRect *VirtualSize, INT32 PixelSize, DialogColourInfo *RedrawColours)
	Redraws a colour picker control for the colour editor dialogue. This is used in the given display mode to display the colour information in a useful format. e.g. in HSV mode, a wheel and slider arrangement.
void	RenderPickerTint (RenderRegion *pRender, DocRect *VirtualSize, INT32 PixelSize, DialogColourInfo *RedrawColours)
	Redraws a colour picker control for the colour editor dialogue. This is used in the given display mode to display the colour information in a useful format. e.g. in HSV mode, a wheel and slider arrangement.
void	RenderPickerShade (RenderRegion *pRender, DocRect *VirtualSize, INT32 PixelSize, DialogColourInfo *RedrawColours, DocRect *pClipRect)
	Redraws a colour picker control for the colour editor dialogue. This is used in the given display mode to display the colour information in a useful format. e.g. in HSV mode, a wheel and slider arrangement.
void	RenderPickerSliderH (RenderRegion *pRender, DocRect *SliderRect, INT32 PixelSize, FIXED24 DisplayValue, DocColour *LeftCol, DocColour *RightCol, DocColour *TopLeftCol, DocColour *TopRightCol, BOOL Shaded=FALSE)
	Redraws a horizontal slider in a colour picker control. This generic method is used to draw a slider for a colour component. Generally, the slider will be a linear grad filled rectangle which shades from a colour with that component = 0.0 to 1.0.
void	StartDrag (ReDrawInfoType *Info)
	Starts a drag from the colour picker control in the colour editor window.
void	UpdateDrag (ReDrawInfoType *Info)
	Updates during a drag from the colour picker control in the colour editor window.
void	EndDrag (ReDrawInfoType *Info)
	Ends a drag from the colour picker control in the colour editor window.
void	SetNewValueFromMousePos (ReDrawInfoType *Info, BOOL StartingNewDrag)
	Handles drag updates - determines the new colour values from the current mouse position, and sets the colour as appropriate.
void	SetNewValueHSV (ReDrawInfoType *Info, INT32 PixelSize, BOOL StartingNewDrag)
	Handles drag updates - determines the new colour values from the current mouse position, and sets the colour as appropriate. Just how it interprets the mouse position is dependant upon which region the drag was started within, and which DisplayMode is in operation. A different routine like this one will be called for each DisplayMode.
void	SetNewValueRGB (ReDrawInfoType *Info, INT32 PixelSize, BOOL StartingNewDrag)
	Handles drag updates - determines the new colour values from the current mouse position, and sets the colour as appropriate. Just how it interprets the mouse position is dependant upon which region the drag was started within, and which DisplayMode is in operation. A different routine like this one will be called for each DisplayMode.
void	SetNewValueCMYK (ReDrawInfoType *Info, INT32 PixelSize, BOOL StartingNewDrag)
	Handles drag updates - determines the new colour values from the current mouse position, and sets the colour as appropriate. Just how it interprets the mouse position is dependant upon which region the drag was started within, and which DisplayMode is in operation. A different routine like this one will be called for each DisplayMode.
void	SetNewValueDefault (ReDrawInfoType *Info, INT32 PixelSize, BOOL StartingNewDrag)
	Handles drag updates - determines the new colour values from the current mouse position, and sets the colour as appropriate. Just how it interprets the mouse position is dependant upon which region the drag was started within, and which DisplayMode is in operation. A different routine like this one will be called for each DisplayMode.
void	SetNewValueTint (ReDrawInfoType *Info, INT32 PixelSize, BOOL StartingNewDrag)
	Handles drag updates - determines the new colour values from the current mouse position, and sets the colour as appropriate.
void	SetNewValueShade (ReDrawInfoType *Info, INT32 PixelSize, BOOL StartingNewDrag)
	Handles drag updates - determines the new colour values from the current mouse position, and sets the colour as appropriate. Just how it interprets the mouse position is dependant upon which region the drag was started within, and which DisplayMode is in operation. A different routine like this one will be called for each DisplayMode.
BOOL	HandleIdlePointer (ReDrawInfoType *Info, String_128 *BubbleHelp, String_256 *StatusHelp, UINT32 *ControlID)
	Called when the mouse is idling over the colour picker control. Sets appropriate pointer shapes, and also returns bubble help for appropriate regions (probably only the original/current colour patches).
BOOL	HandleIdlePointerHSV (ReDrawInfoType *Info, String_128 *BubbleHelp, String_256 *StatusHelp)
	Called when the mouse is idling over the colour picker control. Sets appropriate pointer shapes, and also returns bubble help for appropriate regions (probably only the original/current colour patches).
BOOL	HandleIdlePointerRGB (ReDrawInfoType *Info, String_128 *BubbleHelp, String_256 *StatusHelp)
	Called when the mouse is idling over the colour picker control. Sets appropriate pointer shapes, and also returns bubble help for appropriate regions (probably only the original/current colour patches).
BOOL	HandleIdlePointerCMYK (ReDrawInfoType *Info, String_128 *BubbleHelp, String_256 *StatusHelp)
	Called when the mouse is idling over the colour picker control. Sets appropriate pointer shapes, and also returns bubble help for appropriate regions (probably only the original/current colour patches).
BOOL	HandleIdlePointerDefault (ReDrawInfoType *Info, String_128 *BubbleHelp, String_256 *StatusHelp)
	Called when the mouse is idling over the colour picker control. Sets appropriate pointer shapes, and also returns bubble help for appropriate regions (probably only the original/current colour patches).
BOOL	HandleIdlePointerTint (ReDrawInfoType *Info, String_128 *BubbleHelp, String_256 *StatusHelp)
	Called when the mouse is idling over the colour picker control. Sets appropriate pointer shapes, and also returns bubble help for appropriate regions (probably only the original/current colour patches).
BOOL	HandleIdlePointerShade (ReDrawInfoType *Info, String_128 *BubbleHelp, String_256 *StatusHelp)
	Called when the mouse is idling over the colour picker control. Sets appropriate pointer shapes, and also returns bubble help for appropriate regions (probably only the original/current colour patches).
CrossConstraint	CalcCrossRectRGB (ColourRGBT *SourceColour, DocRect *SquareRect, INT32 PixelSize, DocRect *Result)
	Determines the 3-D RGB picker cross position for the 2-component picker slice-through-the-cube display.
CrossConstraint	CalcCrossRectCMYK (ColourCMYK *SourceColour, DocRect *SquareRect, INT32 PixelSize, DocRect *Result)
	Determines the 3-D CMYK picker cross position for the 2-component picker slice-through-the-cube display.
void	SetCursor (UINT32 CursorResID)
	Called by HandleIdlePointerXXX functions to set the cursor shape they desire.
void	EndTimedProcessing ()
	Kills the message based timer which is used to call ColourEditDlg::TimedProcessing.
void	BeginTimedProcessing ()
	Sets a message based timer which indirectly calls ColourEditDlg::TimedProcessing.
void	HideGadgetList (CGadgetID *Gadgets, BOOL Hide=TRUE)
	Hides / shows the gadgets on the list.
void	HideOrShowColourPicker ()
	Synchronize state of colour picker gadget.
void	CheckDialogSize ()
	Ensure the dialog is a sensible size Scope: Protected.
void	NeedsResize ()
virtual BOOL	OnIdleEvent ()
	Idle event handler for the colour dialog.
Static Protected Member Functions
static BOOL	SetUnitGroupDefaults (ColourModel ColModel)
	Sets the default ScaleUnits for the Colour Editor (actually sets StandardUnit groups.
static BOOL	GetColourContext (ColourModel ColModel, ColourContext **ppContext)
	Gets an appropriate colour context for displaying the colour picker This is so that CMYK can use the printer profile.
Protected Attributes
BOOL	AmShaded
IndexedColour	OriginalColour
IndexedColour *	ResultColour
IndexedColour *	EditingColour
IndexedColour *	OriginalEditingColour
ColourList *	ParentList
BOOL	NoFillButtonDown
BOOL	FirstEdit
BOOL	ISentTheMessage
ColourDropDown *	NameDropDown
ColourDropDown *	ParentDropDown
ColEditDragArea	DragStartArea
DocCoord	LastDragPos
DocCoord	DragAnchor
BOOL	DragUpdatedOnIdle
ColourGeneric	ColourBeforeDrag
IndexedColour *	AbortColour
ColEditState	State
BOOL	m_bDoingSetGadget
UINT32	CurrentCursorID
Cursor *	CurrentCursor
BOOL	m_bDoTimerProcessing
BOOL	m_NeedsResize
Static Protected Attributes
static INT32	DefaultDisplayModel = (INT32) COLOURMODEL_HSVT
	If TRUE, the colour editor will automatically switch the display colour model whenever it switches to a new LOCAL colour (to that colour's model) If FALSE, the only time the display colour model will change is when the user explicitly sets a different colour model from the dialogue. Notes: Normal preference, available from the options dialogue. If TRUE, the colour editor will automatically switch the display colour model whenever it switches to a new NAMED colour (Colour STYLE) (to that colour's model) If FALSE, the only time the display colour model will change is when the user explicitly sets a different colour model from the dialogue. Notes: Normal preference, available from the options dialogue. Retains a 'memory' of the last used Colour Editor display model between sessions in Camelot. Used for LOCAL COLOURS Notes: Internal 'memory' preference, not directly settable by the user Retains a 'memory' of the last used Colour Editor display model between sessions in Camelot. used for COLOUR STYLES Notes: Internal 'memory' preference, not directly settable by the user Retains a 'memory' of the colour editor 'folded' state between sessions in Camelot. Notes: Internal 'memory' preference, not directly settable by the user Determines if the sliders in the colour editor show a 'split line' display. If FALSE, a simple display is given where each slider just shows the component being set (e.g. in RGB, the Red slider shades between black and red) If TRUE, the split mode is enabled, where the slider shows the normal grad-fill in the top half (black to red), but fills the bottom half with the range of colours which will result from changing that component of the edited colour (i.e. at any point on the slider it shows what colour you will get if you click on that spot) Notes: Secret squirrel preference! THis may become available in the options dialogue if it is decided that it is useful. If FALSE, the RGB/CMYK colour pickers in the colour editor will be simple sliders. If TRUE, the '3d colour cube' display will be used instead If TRUE, the HSV colour picker shows the SV Pane with full hue at the top (as all version did prior to Xara X1) If FALSE, the HSV colour picker shows the SV Pane with full hue at the bottom If TRUE, use print profile to do RGB-CMYK colour conversion.
static INT32	DefaultDisplayModelN = (INT32) COLOURMODEL_HSVT
static INT32	AutoModelChange = FALSE
static INT32	AutoModelChangeN = TRUE
static INT32	Folded = TRUE
static INT32	SplitLineDisplay = FALSE
static INT32	Use3DDisplay = FALSE
static BOOL	bHSVHueAtTop = TRUE
static BOOL	bUsePrintCMYK = TRUE
static AbortColourState	abortColourState
static BOOL	EscapeKeyWasPressed = FALSE
static ColourEditDlg *	TheEditor = NULL
static BOOL	EditingLineColour = FALSE
static BOOL	UpdateOnNextIdle = FALSE
static ColourModel	DisplayModel = COLOURMODEL_HSVT
static INT32	ColourPickerMode = 0
static BOOL	resetColPickPos
static RECT	colPickOrigRect
static BOOL	needColPickHidden
static BOOL	colPickHidden
Private Member Functions
BOOL	MakeNewNColour (void)
	Moves a lump of code out of the switch statement in the message handler, so it can be executed by the button in Camelot and the menu item in Webster.
BOOL	MakeColourASpot (void)
	Moves a lump of code out of the switch statement in the message handler.
void	LoseKeyboardFocus (void)
Friends
class	ColEditorDragTarget
class	ColourPicker
class	OpColEditCommand

---

Detailed Description

Definition at line 214 of file coldlog.h.

---

Constructor & Destructor Documentation

ColourEditDlg::ColourEditDlg (   )

Default constructor for the colour editor dialogue class Notes: You shouldn't really use this constructor if you can avoid it. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 653 of file coldlog.cpp. : DialogOp(ColourEditDlg::IDD, ColourEditDlg::Mode) { // If there is no existing editor, make us "the" editor instantiation // Otherwise, we'll realise our mistake (in Do/DoWithParam) and kill ourself if (TheEditor == NULL) TheEditor = this; ParentList = NULL; ResultColour = NULL; EditingColour = NULL; ISentTheMessage = FALSE; AmShaded = FALSE; DragStartArea = CEDRAG_NONE; DragUpdatedOnIdle = FALSE; FirstEdit = TRUE; ResetState(); // WEBSTER - markn 31/1/97 // Bodge - uses the Named default value to keep that model preserved #ifndef WEBSTER DisplayModel = (ColourModel) DefaultDisplayModel; #else DisplayModel = (ColourModel) DefaultDisplayModelN; #endif // WEBSTER AbortColour = NULL; NameDropDown = NULL; ParentDropDown = NULL; CurrentCursorID = 0; CurrentCursor = NULL; m_bDoingSetGadget = FALSE; m_NeedsResize = FALSE; GetApplication()->RegisterIdleProcessor(IDLEPRIORITY_LOW, this); }

ColourEditDlg::~ColourEditDlg (   )

Destructor for the colour editor dialogue class. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 710 of file coldlog.cpp. { GetApplication()->RemoveIdleProcessor(IDLEPRIORITY_LOW, this); EndTimedProcessing(); if (EditingColour != NULL) { // Ensure we remember the current model as the preferred default if (EditingColour->IsNamed()) DefaultDisplayModelN = (INT32) DisplayModel; // But do not overwrite the preference for local colours - this must be set in the options dlg // else // DefaultDisplayModel = (INT32) DisplayModel; delete EditingColour; } if (AbortColour != NULL) { delete AbortColour; AbortColour = NULL; } // If we were the current active editor instantiation then we indicate there // is no longer an editor open. if (TheEditor == this) TheEditor = NULL; // Delete our drop-down colour list support objects if (NameDropDown != NULL) delete NameDropDown; if (ParentDropDown != NULL) delete ParentDropDown; if (CurrentCursor != NULL) delete CurrentCursor; }

---

Member Function Documentation

void ColourEditDlg::AbortColourPickerDrag (   )  [static]

Terminate the colour picker drag with extreme prejudice (I.e. pass non-zero WPARAM to prevent it calling us back). Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 10/03/2004 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 2229 of file coldlog.cpp. { if (TheEditor) TheEditor->ColourPickerAbort(_R(IDC_COLOURPICKER), 1); }

void ColourEditDlg::ApplyColourNow (  IndexedColour *  IxColourToApply  )  [protected]

Applies the EditingColour to the document selection. Whether named or unnamed, it is applied as a new colour attribute, thus changing the colour used by the selected objects (rather than just redrawing static references to a colour which has been modified). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 2/4/95 Parameters: IxColourToApply-  the colour to be applied [INPUTS] Make sure that EditingColour is in either the named or unnamed colour list when it is applied, so that the reference is not left pointing a something which can be easily deleted out from under it. Definition at line 10454 of file coldlog.cpp. { // Apply it to the selection as a colour attrib mutator - this will thus affect // selected objects through selected grad-fill blobs etc NodeAttribute *Attrib = NULL; DocColour ColourToApply; ColourToApply.MakeRefToIndexedColour(IxColourToApply); if (EditingLineColour) { // Apply it as a Line colour mutator Attrib = new AttrStrokeColourChange; if (Attrib == NULL) return; ((AttrStrokeColourChange *)Attrib)->SetStartColour(&ColourToApply); } else { // Apply it as a fill mutator Attrib = new AttrColourChange; if (Attrib == NULL) return; ((AttrColourChange *)Attrib)->SetStartColour(&ColourToApply); } // Apply the attribute. While applying, we lock ourselves so we don't respond to the // attribute-changing messages, and also ensure that the attribute manager doesn't // ask the user if they want to set the current attribute (if you're editing the current // colour, you kindof expect the current colour to change!) BOOL OldSentState = ISentTheMessage; ISentTheMessage = TRUE; BOOL OldAskState = AttributeManager::AskBeforeSettingCurrentAttr; AttributeManager::AskBeforeSettingCurrentAttr = FALSE; // AttributeSelected knows what to do with a selected attribute AttributeManager::AttributeSelected(NULL, Attrib); AttributeManager::AskBeforeSettingCurrentAttr = OldAskState; ISentTheMessage = OldSentState; }

void ColourEditDlg::ApplyEditingColourNow (  BOOL  UseAbortColour = FALSE  )  [static]

Camelots new custom colour picker control (also written by me) needs to be able to change the value EditingColour on the fly (based upon the IndexedColour that is has just read/generated) so that we do not generate infinite amounts of undo information (which would be so if we always applied the supplied colour). But we also need to be able to apply the edited colour to the selection when the user has finished dragging my colour picker control. This function allows us to achieve this functionality. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 3/11/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - The function also (directly) applies named colours because of some nastiness that I have found it necessary to treat named colours as unnamed colours; and then revert at the end. Scope: public Returns: Errors: - See also: ColourEditDlg::SetEditingColour () Definition at line 2203 of file coldlog.cpp. { if (TheEditor->EditingColour != NULL) { TheEditor->SetColour (FALSE); } }

void ColourEditDlg::ApplyNoColour (  BOOL  LineColour  )  [protected]

Sets either the fill or the line colour to "No colour". Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/12/96 Parameters: LineColour  - TRUE if you want to set the line colour, FALSE if you want to set the fill colour [INPUTS] Needed for WEBSTER See also: - Definition at line 2606 of file coldlog.cpp. { DocColour ColourToApply(COLOUR_TRANS); if (LineColour) { // Line colour selected so create a line colour attribute AttrStrokeColourChange* pAttrib = new AttrStrokeColourChange; if (pAttrib == NULL) return; pAttrib->SetStartColour(&ColourToApply); // AttributeSelected knows what to do with a selected attribute AttributeManager::AttributeSelected(NULL, pAttrib); } else { // Rather than setting the flat fill colour, we do an AttrColourChange, which // (I assume) will handle things like selected grad fill points, etc. AttrColourChange* pAttrib = new AttrColourChange; if (pAttrib == NULL) return; pAttrib->SetStartColour(&ColourToApply); // AttributeSelected knows what to do with a selected attribute AttributeManager::AttributeSelected(NULL, pAttrib); } }

void ColourEditDlg::BeginTimedProcessing (   )  [protected]

Sets a message based timer which indirectly calls ColourEditDlg::TimedProcessing. Author: Noel_Someone (Xara Group Ltd) <camelotdev@xara.com> Date: 14/6/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 11717 of file coldlog.cpp. { KillTimer(COLED_TIMER_ID); SetTimer(COLED_TIMER_ID, COLED_TIMER_FREQUENCY, NULL); }

CrossConstraint ColourEditDlg::CalcCrossRectCMYK (  ColourCMYK *  SourceColour, DocRect *  SquareRect, INT32  PixelSize, DocRect *  Result )  [protected]

Determines the 3-D CMYK picker cross position for the 2-component picker slice-through-the-cube display. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 23/12/94 Parameters: SourceColour  - the colour definition for which the cross rect must be calc'd [INPUTS] SquareRect - The rect containing th 3-d cube 'slice' to plot the cross in PixelSize - the usual (size of a pixel in millipoints) Result  will be returned containing the CrossRect (in which to draw the cross) [OUTPUTS] Returns: A value indicating how the cross is constrained, so you can draw constraint bubbles as appropriate. See also: ColourEditDlg::SetNewValueCMYK; ColourEditDlg::RenderPickerCMYK Definition at line 5781 of file coldlog.cpp. { DocRect CrossRect(-CROSSRADIUS, -CROSSRADIUS, CROSSRADIUS, CROSSRADIUS); FIXED24 XComponent; FIXED24 YComponent; CrossConstraint ReturnVal = CROSSCONSTRAINED_NONE; switch(ColourPickerMode) { case 1: // XYZ = Y,M,C XComponent = SourceColour->Yellow; YComponent = SourceColour->Magenta; if (EditingColour->InheritsComponent(2)) ReturnVal = CROSSCONSTRAINED_HORZ; if (EditingColour->InheritsComponent(3)) { if (ReturnVal == CROSSCONSTRAINED_NONE) ReturnVal = CROSSCONSTRAINED_VERT; else ReturnVal = CROSSCONSTRAINED_BOTH; } break; case 2: // XYZ = M,C,Y XComponent = SourceColour->Magenta; YComponent = SourceColour->Cyan; if (EditingColour->InheritsComponent(1)) ReturnVal = CROSSCONSTRAINED_HORZ; if (EditingColour->InheritsComponent(2)) { if (ReturnVal == CROSSCONSTRAINED_NONE) ReturnVal = CROSSCONSTRAINED_VERT; else ReturnVal = CROSSCONSTRAINED_BOTH; } break; default: // XYZ = C,Y,M XComponent = SourceColour->Cyan; YComponent = SourceColour->Yellow; if (EditingColour->InheritsComponent(3)) ReturnVal = CROSSCONSTRAINED_HORZ; if (EditingColour->InheritsComponent(1)) { if (ReturnVal == CROSSCONSTRAINED_NONE) ReturnVal = CROSSCONSTRAINED_VERT; else ReturnVal = CROSSCONSTRAINED_BOTH; } break; } INT32 SizeXY = SquareRect->Height(); INT32 XTrans = (INT32) ((double)SizeXY * XComponent.MakeDouble()); INT32 YTrans = (INT32) ((double)SizeXY * YComponent.MakeDouble()); // Translate the cross to the appropriate position CrossRect.Translate(HalfGridLock(SquareRect->lo.x + XTrans, PixelSize), HalfGridLock(SquareRect->lo.y + YTrans, PixelSize)); *Result = CrossRect; if (EditingColour->GetType() == COLOURTYPE_TINT) return(CROSSCONSTRAINED_BOTH); return(ReturnVal); }

CrossConstraint ColourEditDlg::CalcCrossRectRGB (  ColourRGBT *  SourceColour, DocRect *  SquareRect, INT32  PixelSize, DocRect *  Result )  [protected]

Determines the 3-D RGB picker cross position for the 2-component picker slice-through-the-cube display. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 23/12/94 Parameters: SourceColour  - the colour definition for which the cross rect must be calc'd [INPUTS] SquareRect - The rect containing th 3-d cube 'slice' to plot the cross in PixelSize - the usual (size of a pixel in millipoints) Result  will be returned containing the CrossRect (in which to draw the cross) [OUTPUTS] Returns: A value indicating how the cross is constrained, so you can draw constraint bubbles as appropriate. See also: ColourEditDlg::SetNewValueRGB; ColourEditDlg::RenderPickerRGB Definition at line 5370 of file coldlog.cpp. { DocRect CrossRect(-CROSSRADIUS, -CROSSRADIUS, CROSSRADIUS, CROSSRADIUS); FIXED24 XComponent; FIXED24 YComponent; CrossConstraint ReturnVal = CROSSCONSTRAINED_NONE; switch(ColourPickerMode) { case 1: // XYZ = R,B,G XComponent = SourceColour->Red; YComponent = SourceColour->Blue; if (EditingColour->InheritsComponent(3)) ReturnVal = CROSSCONSTRAINED_HORZ; if (EditingColour->InheritsComponent(1)) { if (ReturnVal == CROSSCONSTRAINED_NONE) ReturnVal = CROSSCONSTRAINED_VERT; else ReturnVal = CROSSCONSTRAINED_BOTH; } break; case 2: // XYZ = B,G,R XComponent = SourceColour->Blue; YComponent = SourceColour->Green; if (EditingColour->InheritsComponent(2)) ReturnVal = CROSSCONSTRAINED_HORZ; if (EditingColour->InheritsComponent(3)) { if (ReturnVal == CROSSCONSTRAINED_NONE) ReturnVal = CROSSCONSTRAINED_VERT; else ReturnVal = CROSSCONSTRAINED_BOTH; } break; default: // XYZ = G,R,B XComponent = SourceColour->Green; YComponent = SourceColour->Red; if (EditingColour->InheritsComponent(1)) ReturnVal = CROSSCONSTRAINED_HORZ; if (EditingColour->InheritsComponent(2)) { if (ReturnVal == CROSSCONSTRAINED_NONE) ReturnVal = CROSSCONSTRAINED_VERT; else ReturnVal = CROSSCONSTRAINED_BOTH; } break; } INT32 SizeXY = SquareRect->Height(); INT32 XTrans = (INT32) ((double)SizeXY * XComponent.MakeDouble()); INT32 YTrans = (INT32) ((double)SizeXY * YComponent.MakeDouble()); // Translate the cross to the appropriate position CrossRect.Translate(HalfGridLock(SquareRect->lo.x + XTrans, PixelSize), HalfGridLock(SquareRect->lo.y + YTrans, PixelSize)); *Result = CrossRect; if (EditingColour->GetType() == COLOURTYPE_TINT) return(CROSSCONSTRAINED_BOTH); return(ReturnVal); }

BOOL ColourEditDlg::CanYouEditThis (  ColourList *  ParentList, IndexedColour *  ColourToEdit, BOOL  ForceNewMode = FALSE )  [static]

Determines if the colour editor will be happy with you calling InvokeDialog with the given parameters. Allows you to enable/disable any UI mechanism that links onto this method. (e.g. colour line edit colour button uses this to determine if drags can be dropped onto it). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 26/3/96 Parameters: ParentList  - the ColourList in which the colour to be edited resides [INPUTS] May be NULL to use the Selected Document's colour list ColourToEdit - the IndexedColour which you wish to edit. May be NULL if you just want it to find a useful local colour to edit, in which case it will return TRUE unless there are no documents open. ForceNewMode - DO NOT USE - this is an internal flag causing side effects (if TRUE, and the colour is local, the return value will be FALSE, and the EditingLineColour member flag will be changed to indicate which colour should be edited - see the InvokeDialog code) Returns: TRUE if the colour can be edited. If this returns FALSE, then a call to InvokeDialog with these parameters will fail (specifically, it will revert to editing a "useful" local colour) Notes: The colour must be in the ParentList Named colours in the ParentList can always be edited Unnamed colours can only be edited if they happen to coincide with the current line or fill colour - otherwise it makes no sense to edit a local colour (because you can only edit a local colour _on_ an object) See also: ColourEditDlg::InvokeDialog Definition at line 10336 of file coldlog.cpp. { // If no list specified, assume the one in the selected doc if (ParentList == NULL) ParentList = ColourManager::GetColourList(); // If they specified no colour, then we need to find a "useful" colour to edit. // This is always possible, except when there are no documents (SelDoc == NULL) if (ColourToEdit == NULL) return(Document::GetSelected() != NULL); if (ParentList != NULL) { if (ColourToEdit->IsNamed()) { // Named colour // Check that the colour resides in the given colour list if (ParentList->FindPosition(ColourToEdit) >= 0) return(TRUE); ERROR3("CanYouEditThis - Named IndexedColour not in provided ParentList!"); } else { // Local colour // It is deeply scary to allow local colours to be dragged to the editor. // Local colours do not exist on their own - they can only be edited ON // an object. The only objects we know of like this are the current selection, // so we can only edit local line and fill colours. StatusLine* pStatusLine = StatusLine::Get(); if (!pStatusLine || (pStatusLine->IsRestrictedAccessToColourPicker () == FALSE)) { // Get the current line/fill colours, and see if they match the colour we were asked for DocColour DocColourToCheck; // Try for current fill colour ColourManager::FindColourOfInterestToUser(&DocColourToCheck, NULL, FALSE); if (DocColourToCheck.FindParentIndexedColour() == ColourToEdit) { if (ForceNewMode) ForceLineOrFillMode(FALSE); // If appropriate, set line/fill mode and return FALSE else return(TRUE); } // Try for current line colour ColourManager::FindColourOfInterestToUser(&DocColourToCheck, NULL, TRUE); if (DocColourToCheck.FindParentIndexedColour() == ColourToEdit) { if (ForceNewMode) ForceLineOrFillMode(TRUE); // If appropriate, set line/fill mode and return FALSE else return(TRUE); } } else { // the above code may have been valid BEFORE camelots custom colour picker // control, but NOW we need to allow the colour editor to display/edit // local index colours .... return (TRUE); } } } // For whatever reason, we can't allow this to be edited return(FALSE); }

void ColourEditDlg::CheckDialogSize (   )  [protected]

Ensure the dialog is a sensible size Scope: Protected. Author: Alex Bligh Date: 30/5/2005 Parameters: -  [INPUTS] Definition at line 1179 of file coldlog.cpp. { if (!m_NeedsResize) return; m_NeedsResize=FALSE; // Set up bubble help ColourPicker::SetBubbleHelp(TintGadgetIDs); ColourPicker::SetBubbleHelp(LinkGadgetIDs); ColourPicker::SetBubbleHelp(OtherGadgetIDs); ColourPicker::RelayoutDialog(WindowID); }

void ColourEditDlg::CloseColourEditor (   )

A public method to close the colour editor dialog Scope: public. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 5/5/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: Definition at line 2122 of file coldlog.cpp. { CloseMyself(); }

void ColourEditDlg::CloseMyself (  void   )  [protected]

Cleans up, discards data on the colour being edited, and closes the editor window. Used to close the editor in response to different messages, e.g. when the selected document changes, or when the colour is deleted. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 15/11/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 2488 of file coldlog.cpp. { if (EditingColour != NULL) { // Ensure we remember the current model as the preferred default if (EditingColour->IsNamed()) DefaultDisplayModelN = (INT32) DisplayModel; // But do not overwrite the preference for local colours - this must be set in the options dlg // else // DefaultDisplayModel = (INT32) DisplayModel; delete EditingColour; EditingColour = NULL; } ParentList = NULL; State.ParentListOK = FALSE; // Swapping colours - ensure we update parent list Close(); End(); }

void ColourEditDlg::CompileParentColourList (  CGadgetID  TargetGadget  )  [protected]

Sets up the given combo box gadget to provide a list of all the colours which can be used as a parent of an IndexedColour. This creates the list in the dialogue gadget specified, and selects the appropriate parent (of EditingColour) by default. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/94 Parameters: TargetGadget  - The list gadget to write the list into [INPUTS] Notes: Quietly ignores calls when EditingColour == NULL See also: ColourEditDlg::DecodeParentColourListSelection Definition at line 10700 of file coldlog.cpp. { if (ParentList == NULL || EditingColour == NULL) return; if (ParentDropDown != NULL) delete ParentDropDown; ParentDropDown = new ColourDropDown; if (ParentDropDown != NULL) { if (ParentDropDown->Init(WindowID, TargetGadget)) { if (ParentDropDown->FillInColourList(EditingColour->FindLastLinkedParent(), -1, ResultColour)) return; // NOTE: We could do a SetComboListLength here, except that this causes awful // redraws of everything "behind" the combo-list extent. I can't stop it doing this, // other than by not setting the list length. } } // We must have failed in order to reach here, so shade the gadget and hang our head in shame EnableGadget(TargetGadget, FALSE); }

BOOL ColourEditDlg::Create (  void   )  [virtual]

Creates a colour editor dialogue box. Fails if DialogOp::Create fails to create the box. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: FALSE if it fails Errors: - See also: - Reimplemented from DialogOp. Definition at line 9990 of file coldlog.cpp. { ISentTheMessage = FALSE; // Ensure our message lock is disabled AmShaded = FALSE; // We are not currently in a shaded state m_bDoTimerProcessing = TRUE; if (TheEditor != this) // Allow only one instance of this dialogue open at once return(FALSE); if (EditingColour != NULL && ParentList == NULL) { ERROR3("ColourEditDlg not correctly initialised before call to Create()"); return(FALSE); } if (DialogOp::Create()) { // SetControls(); -- now done by DIM_CREATE handler return(TRUE); } return(FALSE); }

IndexedColour * ColourEditDlg::DecodeParentColourListSelection (  INT32  Index  )  [protected]

Shared code used by ColourTint and CoourLink Dlgs to decode selctions in the list of colours created by CompileParentColourList. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/94 Parameters: Index  - the index of the item in the list gadget which was selected [INPUTS] Returns: A pointer to the IndexedColour to be used as the new parent of the EditingColour, or NULL if the item wasn't found(!?) Notes: Quietly ignores calls when EditingColour == NULL See also: ColourEditDlg::CompileParentColourList Definition at line 10748 of file coldlog.cpp. { if (ParentList == NULL || EditingColour == NULL) return(NULL); if (ParentDropDown != NULL) return(ParentDropDown->DecodeSelection(Index)); /* IndexedColour *Ptr = (IndexedColour *) ParentList->GetHead(); while (Ptr != NULL) { // If this colour is a possible parent: // * Not deleted // * Named // * Not a Spot colour if EditingColour is LINKED // * Is not a child/descendant of the ResultColour (circular reference! no!) // (Note that this includes it being the ResultColour) // then we will add it to the list if (!Ptr->IsDeleted() && Ptr->IsNamed() && !Ptr->IsADescendantOf(ResultColour)) { if (EditingColour->GetType() != COLOURTYPE_LINKED || Ptr->GetType() != COLOURTYPE_SPOT) { Index--; if (Index < 0) return(Ptr); } } Ptr = (IndexedColour *) ParentList->GetNext(Ptr); } */ return(NULL); // Not found?! }

void ColourEditDlg::Do (  OpDescriptor *  MyOpDesc  )  [virtual]

Toggles the colour editor, and if opening it, finds a useful colour to edit. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 See also: ColourEditDlg::DoWithParam Reimplemented from Operation. Definition at line 10029 of file coldlog.cpp. { if (TheEditor != NULL && TheEditor != this) { // If there is an editor open, just ask it to die then kill ourself off, as // we don't want another editor to then pop up! TheEditor->Close(); TheEditor->End(); // Kill existing editor End(); // Kill ourself return; } if (EditingColour != NULL) { delete EditingColour; EditingColour = NULL; } // WEBSTER - markn 31/1/97 // Bodge - uses the Named default value to keep that model preserved #ifndef WEBSTER DisplayModel = (ColourModel) DefaultDisplayModel; #else DisplayModel = (ColourModel) DefaultDisplayModelN; #endif // WEBSTER FindUsefulColourToEdit(EditingLineColour, FALSE); Progress Hourglass; // Start an hourglass running if (Create()) { Open(); // Open the dialogue (& set the controls etc) PaintGadgetNow(_R(IDC_EDIT_PICKER)); // Redraw picker while hourglass is still up } else End(); }

BOOL ColourEditDlg::DoAbortColourNow (  CWindowID  colourPicker  )  [static]

Allows camelots new custom colour picker control to abort the changing of a colour (by way of the user pressing the escape key). This function simply applies the abort colour (which was already 'saved' within SetEditingColour (). Scope: public. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 1/2/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: ColourEditDlg::SetEditingColour () Definition at line 2255 of file coldlog.cpp. { // firstly, lets check for obvious insanity String_256 ClassNameStr; // The control type // Check passed a sensible window ID if (TheEditor && (TheEditor->WindowID == colourPicker)) { // only reset colour if we have a prior one to select (AbortColour). fixes #10649 - // crash when escape is pressed before the dropper has selected a colour... if (TheEditor->AbortColour != NULL) { if (TheEditor->EditingColour != NULL) { delete (TheEditor->EditingColour); } TheEditor->EditingColour = new IndexedColour (*(TheEditor->AbortColour)); ApplyEditingColourNow (TRUE); // this generates two bits of undo - which is undesirable! } return (TRUE); } ENSURE(FALSE, "DoColourPickerColour called for invalid colour picker control"); return (FALSE); }

void ColourEditDlg::DoCommand (  StringBase *  Command  )  [protected]

Applies a given editor menu command. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 3/10/95 Parameters: Command  - String indicating the command to apply (see colmenu.h) [INPUTS] Definition at line 7248 of file coldlog.cpp. { ColourModel NewColourModel = COLOURMODEL_INDEXED; if (*Command == ColCmd_Help) HelpUser(*this); else if (*Command == ColCmd_Name) { if (ResultColour != NULL && ParentList != NULL && ResultColour->IsNamed()) { // Lock ourselves so we don't update on any message broadcasts BOOL ISentState = ISentTheMessage; ISentTheMessage = TRUE; // Nasty, but ColourNameDlg is in sgcolour #ifndef EXCLUDE_GALS // Rename the result colour if (ColourNameDlg::InvokeDialog(ParentList, ResultColour)) { // Commit any colour model change to this colour now // ColourContext *cc = ColourContext::GetGlobalDefault(DisplayModel); ColourContext *cc = NULL; BOOL bDeleteCC = GetColourContext(DisplayModel, &cc); if (cc != NULL) { ColourPicker::ForceColourModel(ResultColour, cc); // Delete the colour context if necessary if (bDeleteCC) ColourContextList::GetList()->RemoveContext(&cc); // Have finished with it } // Make sure the editor swaps (it'll ignore us if ResultColour == ColToEdit) IndexedColour *ColToEdit = ResultColour; ResultColour = NULL; // And start the editor up again on the original colour EditThisColour(ParentList, ColToEdit); } #endif ISentTheMessage = ISentState; } } else if (*Command == ColCmd_EditParent) // Edit parent only available if have parent { if (ResultColour != NULL && ParentList != NULL && ResultColour->FindLinkedParent() != NULL) EditThisColour(ParentList, ResultColour->FindLinkedParent()); } else if (*Command == ColCmd_HSV) NewColourModel = COLOURMODEL_HSVT; else if (*Command == ColCmd_RGB) NewColourModel = COLOURMODEL_RGBT; else if (*Command == ColCmd_CMYK) NewColourModel = COLOURMODEL_CMYK; else if (*Command == ColCmd_Grey) NewColourModel = COLOURMODEL_GREYT; #ifdef WEBSTER // Martin 16/07/97 else if (*Command == ColCmd_NewNColour) MakeNewNColour(); //do the same thing as pressing the button! #endif //WEBSTER if (NewColourModel != COLOURMODEL_INDEXED && NewColourModel != DisplayModel) { DisplayModel = (ColourModel) NewColourModel; // Switch display to the new model // WEBSTER - markn 31/1/97 // Always set the default colour models to the display mode #ifndef WEBSTER if (EditingColour->IsNamed()) DefaultDisplayModelN = NewColourModel; // And remember preference #else DefaultDisplayModelN = NewColourModel; DefaultDisplayModel = NewColourModel; #endif // WEBSTER ColourEditDlg::SetUnitGroupDefaults(DisplayModel); InvalidateAndSetControls(); // And update the displays } }

static void ColourEditDlg::DoHandleNamedcolour (   )  [static]

void ColourEditDlg::DoWithParam (  OpDescriptor *  MyOpDedsc, OpParam *  Param )  [virtual]

'Does' a colour editor dialogue op. Shows the dialogue. Scope: private Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 Parameters: MyOpDesc  - as usual, the opdescriptor of this thingo [INPUTS] Param - points to a ColourEditDlgParam object -  [OUTPUTS] Returns: - Errors: - See also: ColourEditDlgParam::ColourEditDlgParam Reimplemented from Operation. Definition at line 10089 of file coldlog.cpp. { ERROR3IF(Param == NULL, "ColourEditDlg::DoWithParam - NULL Param passed in"); ERROR3IF(!Param->IsKindOf(CC_RUNTIME_CLASS(ColourEditDlgParam)), "ColourEditDlg::DoWithParam - Param is illegal"); // Initialise ourselves from the supplied parameters ColourEditDlgParam *Info = (ColourEditDlgParam *) Param; if (Info->ParentList == NULL) Info->ParentList = ColourManager::GetColourList(); // Determine if we can safely edit this colour // NOTE that the TRUE is used to cause side effects on the EditingLineColour flag, // and we will always edit a colour, even if this function returns FALSE. (But if // it is FALSE, we will edit a "useful" colour) if (!CanYouEditThis(Info->ParentList, Info->ColourToEdit, TRUE)) Info->ColourToEdit = NULL; // You can't do that! Choose a "useful" colour to edit instead if (TheEditor != NULL && TheEditor != this) { // If there is an editor open, bring it to the top of the window stack, and ask it // to swap to the ColourToEdit, or a useful local colour if ColourToEdit is NULL TheEditor->BringToTop(); if (Info->ColourToEdit == NULL) TheEditor->FindUsefulColourToEdit(TheEditor->EditingLineColour, TRUE); else TheEditor->EditThisColour(Info->ParentList, Info->ColourToEdit); // And kill ourself off, as we don't want multiple instantiations of the editor open End(); return; } if (Document::GetSelected() == NULL || (Info->ParentList != NULL && Document::GetSelected()->GetIndexedColours() != Info->ParentList)) { ERROR3("Colour editor: No selected doc or Colour not in selected doc"); End(); return; } // Check that the colour given really truly is in the parent list, but only if we've got a colour/list if (Info->ColourToEdit != NULL && Info->ParentList != NULL && // Have a valid pointer Info->ParentList->FindPosition(Info->ColourToEdit) < 0 && // Isn't in named colours Info->ParentList->GetUnnamedColours()->FindPosition(Info->ColourToEdit) < 0 ) // Isn't in unnamed colours { ERROR3("Colour editor: attempt to edit colour with bogus parent list pointer"); End(); return; } ParentList = Info->ParentList; // The list in which the edited colour resides ResultColour = Info->ColourToEdit; // The colour to recieve the result if (EditingColour != NULL) { delete EditingColour; EditingColour = NULL; } if (ResultColour != NULL) { FirstEdit = TRUE; EditingColour = new IndexedColour(*ResultColour); // The colour we're working on for now if (EditingColour == NULL) { InformError(); End(); return; } // Copy the original colour into the OriginalColour. // We only need the colour definition, but we do need the full accuracy of an // IndexedColour to ensure rounding errors (and thus slight dither differences in // redraw) do not occur. OriginalColour = *ResultColour; // Ensure the OriginalColour does not reference any other colour OriginalColour.SetLinkedParent(NULL, COLOURTYPE_NORMAL); } else { FindUsefulColourToEdit(EditingLineColour, FALSE); } if (EditingColour != NULL) { StatusLine* pStatusLine = StatusLine::Get(); if (EditingColour->IsNamed()) { if (!pStatusLine || (pStatusLine->IsRestrictedAccessToColourPicker () == FALSE)) { if (AutoModelChangeN) { DisplayModel = OriginalColour.GetColourModel(); // WEBSTER - markn 14/1/97 // Make sure the display model is either HSV or RGB // If it's neither RGB or HSV, force it to HSV #ifdef WEBSTER if (DisplayModel != COLOURMODEL_RGBT && DisplayModel != COLOURMODEL_HSVT) DisplayModel = COLOURMODEL_HSVT; #endif // WEBSTER #ifdef DISABLE_WEBHEXRGBT if (DisplayModel == COLOURMODEL_WEBHEXRGBT) DisplayModel == COLOURMODEL_RGBT; #endif } } } else { if (pStatusLine->IsRestrictedAccessToColourPicker () == FALSE) { if (AutoModelChange) DisplayModel = OriginalColour.GetColourModel(); #ifdef DISABLE_WEBHEXRGBT if (DisplayModel == COLOURMODEL_WEBHEXRGBT) DisplayModel == COLOURMODEL_RGBT; #endif } } } Progress Hourglass; // Start an hourglass running if (Create()) { Open(); // Open the dialogue (& set the controls etc) PaintGadgetNow(_R(IDC_EDIT_PICKER)); // Redraw picker while hourglass is still up } else End(); }

void ColourEditDlg::EditingColourHasChanged (  BOOL  RedrawControls = TRUE, BOOL  RedrawPicker = TRUE, BOOL  FastTrackPicker = FALSE, Node *  pSourceNode = NULL )  [protected]

Generic code to handle changes to EditingColour. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/94 Parameters: RedrawControls  - TRUE to update the editor controls (name, components etc) [INPUTS] to show the new values for this colour RedrawPicker - TRUE if the colour picker area should be redrawn to display the change. (NOTE that this determines whether the message broadcast is a COLOURUPDATED (TRUE) or a COLOURUPDATEDINVISIBLE (FALSE)) FastTrackPicker - TRUE if you want the picker section to redraw immediately to get instant-effect on the update. Returns: - Notes: Quietly ignores calls when EditingColour == NULL Definition at line 10527 of file coldlog.cpp. { if (EditingColour == NULL) return; if (RedrawControls) { SetControls(); RedrawColourNameList(); // And ensure the colour list redraws its colour patch } if (RedrawPicker) { InvalidateGadget(_R(IDC_EDIT_PICKER)); if (FastTrackPicker) PaintGadgetNow(_R(IDC_EDIT_PICKER)); } if (EditingColour->IsNamed()) { // Apply the change, generating UNDO. This uses 'EditingColour' for an UNDO // record, so we must not touch/delete EditingColour after this call. // // Thus, during processing of the ChangeColour call, it is highly advisable that // EditingColour does not point at the UndoRecord that we passed in, as any // re-entrant call to our code could potentially delete EditingColour or apply // another ChangeColour with the same UNDO buffer! Bad! // // NOTE that we copy UndoRecord into the new EditingColour buffer, because // ResultColour is out of date (it will shortly be changed to be the same as // the UndoRecord). Obviously, we don't want to suddenly swap the // definition back to the previous (undo) state of ResultColour; we want it // to effectively stay exactly as it is now. IndexedColour *UndoRecord = EditingColour; EditingColour = new IndexedColour(*UndoRecord); if (EditingColour == NULL) InformError(); // Set the new colour definition, locking out ColourChangingMsgs while it happens BOOL OldSentState = ISentTheMessage; ISentTheMessage = TRUE; ColourManager::ChangeColour(ParentList, UndoRecord, ResultColour, !RedrawPicker); ISentTheMessage = OldSentState; } else { if (FirstEdit) { // We have not yet changed this colour, so we must add the unnamed colour to // the colour list, and apply it to the selection. // Remember the colour to apply, and make a new copy to continue editing IndexedColour *IxColourToApply = EditingColour; EditingColour = new IndexedColour(*IxColourToApply); if (EditingColour == NULL) InformError(); // Add the new colour to the list of unnamed colours ParentList->GetUnnamedColours()->AddTail(IxColourToApply); // And apply the colour to the selection as a new attribute ApplyColourNow(IxColourToApply); // And now remember that we've applied it once, and remember the new resultcol FirstEdit = FALSE; ResultColour = IxColourToApply; // Make the colour list redraw the first time we change a local colour. // This is necessary because on the first edit, the colour in the list // (the physical colour pointer, not just the appearance) is changed. RedrawColourNameList(); } else { // We are changing the same unnamed colour as last time. Rather than // applying it to the selection and causing another undo record, we // want to poke at the first new unnamed colour we added, which conveniently // happens to be pointed at by 'ResultColour'. // Copy the new definition into ResultColour *ResultColour = *EditingColour; // And redraw the affected parts of the document tree ColourManager::ColourHasChanged((Document *)ParentList->GetParentDocument(), ParentList, ResultColour); } } }

void ColourEditDlg::EditThisColour (  ColourList *  NewParentList, IndexedColour *  ColourToEdit, BOOL  TheWindowIsOpen = TRUE )  [protected]

Switches the colour editor, when it is open, to edit a different colour If the ColourToEdit is the colour currently being edited, nothing happens Scope: protected. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 14/11/94 Parameters: NewParentList  - The list in which the ColourToEdit resides [INPUTS] ColourToEdit - The colour to be edited TheWindowIsOpen - TRUE if the window is believed to be open now, FALSE if it is not. Used by the create handler to stop us from poking at the window when it isn't actually open yet! Parameters: -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1911 of file coldlog.cpp. { if (ColourToEdit == ResultColour) // We're already editing it! return; if (Document::GetSelected() == NULL || Document::GetSelected()->GetIndexedColours() != NewParentList) { ERROR3("Colour editor: No selected doc or Colour not in selected doc"); return; } if (ColourToEdit == NULL) { ERROR3("Colour editor EditThisColour: What colour?! It's NULL!"); return; } // Check that the colour given really truly is in the parent list if (NewParentList != NULL && // Have valid pointers NewParentList->FindPosition(ColourToEdit) < 0 && // Isn't in named colours NewParentList->GetUnnamedColours()->FindPosition(ColourToEdit) < 0 ) // Isn't in unnamed colours { ERROR3("Colour editor: attempt to edit colour with bogus parent list pointer"); return; } State.ParentListOK = FALSE; // Swapping colours - ensure we update parent list if (TheWindowIsOpen) // Only poke at the window if it's actually open! { if (NewParentList == NULL || ColourToEdit == NULL || ColourToEdit->IsDeleted()) { // It's DELETED! Shade the window and exit ShadeMyself(); return; } ShadeMyself(TRUE, TRUE); // Unshade the window contents } ParentList = NewParentList; if (EditingColour != NULL) delete EditingColour; FirstEdit = TRUE; // Remember that we haven't applied this colour yet EditingColour = new IndexedColour(*ColourToEdit); // The colour we're working on for now if (EditingColour == NULL) { InformError(); ShadeMyself(); return; } ResultColour = ColourToEdit; // Where the result goes when 'OK'd // Copy the original colour into the OriginalColour. // We only need the colour definition, but we do need the full accuracy of an // IndexedColour to ensure rounding errors (and thus slight dither differences in // redraw) do not occur. OriginalColour = *ResultColour; StatusLine* pStatusLine = StatusLine::Get(); if (EditingColour->IsNamed()) { if (!pStatusLine || !pStatusLine->IsRestrictedAccessToColourPicker ()) { if (AutoModelChangeN) DisplayModel = OriginalColour.GetColourModel(); else DisplayModel = (ColourModel) DefaultDisplayModelN; } } else { if (!pStatusLine || !pStatusLine->IsRestrictedAccessToColourPicker ()) { if (AutoModelChange) DisplayModel = OriginalColour.GetColourModel(); else DisplayModel = (ColourModel) DefaultDisplayModel; } } // WEBSTER - markn 14/1/97 // Make sure the display model is either HSV or RGB // If it's neither RGB or HSV, force it to HSV #ifdef WEBSTER if (DisplayModel != COLOURMODEL_RGBT && DisplayModel != COLOURMODEL_HSVT) DisplayModel = COLOURMODEL_HSVT; #endif // WEBSTER // Ensure the OriginalColour does not reference any other colour OriginalColour.SetLinkedParent(NULL, COLOURTYPE_NORMAL); if (TheWindowIsOpen) InvalidateAndSetControls(); }

void ColourEditDlg::EndDrag (  ReDrawInfoType *  Info  )  [protected]

Ends a drag from the colour picker control in the colour editor window. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: Info  - The mouse-position information from the control [INPUTS] Notes: May be called when EditingColour is NULL (the window is shaded) Definition at line 7391 of file coldlog.cpp. { // Only update if we think we're dragging (as for the other Drag methods) // However, if the last update was on an idle event, then the mouse has not moved // and so the colour has not changed since we last broadcast, so there is no // need to broadcast again, with all the flickery redraw etc. that will cause if (DragStartArea != CEDRAG_NONE && EditingColour != NULL && !DragUpdatedOnIdle) { // EndTimedProcessing (); SetNewValueFromMousePos(Info, FALSE); // Update colour one last time if (CanSetColour(EditingColour) || EditingColour->GetType() == COLOURTYPE_TINT) EditingColourHasChanged(TRUE, TRUE, TRUE); // Ensure window etc fully updated } DragUpdatedOnIdle = FALSE; // GetApplication()->RemoveIdleProcessor(IDLEPRIORITY_HIGH, this); // Leave idles on for bubblehelp DragStartArea = CEDRAG_NONE; // We aren't dragging any more if (AbortColour != NULL) { delete AbortColour; AbortColour= NULL; } }

BOOL ColourEditDlg::EndingPickerDrag (   )

void ColourEditDlg::EndTimedProcessing (   )  [protected]

Kills the message based timer which is used to call ColourEditDlg::TimedProcessing. Author: Noel_Someone (Xara Group Ltd) <camelotdev@xara.com> Date: 14/6/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 11737 of file coldlog.cpp. { KillTimer(COLED_TIMER_ID); }

BOOL ColourEditDlg::EnteredSetGadgetValue (   )  [protected]

Definition at line 10793 of file coldlog.cpp. { m_bDoingSetGadget = TRUE; return FALSE; }

BOOL ColourEditDlg::ExitedSetGadgetValue (   )  [protected]

Definition at line 10799 of file coldlog.cpp. { m_bDoingSetGadget = FALSE; return TRUE; }

IndexedColour * ColourEditDlg::FindSafeParent (  IndexedColour *  SuggestedParent, BOOL  ChildIsATint )  [protected]

Determines a safe parent colour to use for a tint/link colour. If the suggested parent will do, it is returned, otherwise the first safe parent in the ParentList ColourList will be returned. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/94 Parameters: SuggestedParent  - NULL, or a pointer to a suggested parent colour [INPUTS] ChildIsATint - TRUE if the prospective child colour is (or will be) a tint colour. (FALSE if it's normal/spot/shade/linked) Returns: NULL if there is no safe parent, else a pointer to the colour to use. Notes: A colour is declared safe if it is alive, named, and will not result in a circular parent reference chain. Quietly ignores calls when EditingColour == NULL Definition at line 10644 of file coldlog.cpp. { if (ParentList == NULL || EditingColour == NULL || ResultColour == NULL) return(NULL); if (SuggestedParent != NULL) { // The caller has suggested a colour - is it safe to use it? // Conditions are: // Not deleted // Must be a named colour // Must not be a descendant of the ResultColour (avoid circular references) // Spot colours may only have tints as children if (SuggestedParent->IsDeleted() || !SuggestedParent->IsNamed() || SuggestedParent->IsADescendantOf(ResultColour)) { SuggestedParent = NULL; } } if (SuggestedParent != NULL) // SuggestedParent passed the test: let 'em use it return(SuggestedParent); IndexedColour *Ptr = (IndexedColour *) ParentList->GetHead(); while (Ptr != NULL) { if (!Ptr->IsDeleted() && Ptr->IsNamed() && !Ptr->IsADescendantOf(ResultColour)) return(Ptr); Ptr = (IndexedColour *) ParentList->GetNext(Ptr); } return(NULL); }

void ColourEditDlg::FindUsefulColourToEdit (  BOOL  WantLineColour = FALSE, BOOL  TheWindowIsOpen = TRUE )  [protected]

Calls the ColourManager method (cf SeeAlso) to determine which colour should be displayed in the editor, and swaps to editing this colour (or if no colour is available, shades the editor). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 3/1/95 Parameters: WantLineColour  - TRUE if you want line colour, FALSE if you want a fill colour [INPUTS] TheWindowIsOpen - FALSE if the window is closed, TRUE if it's open (used by the create code to stop us poking at the window when it's closed! See also: ColourManager::FindColourOfInterestToUser; ColourEditDlg::EditThisColour; ColourEditDlg::ShadeMyself Definition at line 2758 of file coldlog.cpp. { State.ParentListOK = FALSE; // Swapping colours - ensure we update parent list ColourList *NewParentList = NULL; IndexedColour *IxColourToEdit = NULL; DocColour DocColourToEdit; EditingLineColour = WantLineColour; // Remember whether editing line or fill ColourManager::FindColourOfInterestToUser(&DocColourToEdit, &NewParentList, WantLineColour); if (NewParentList == NULL) { if (TheWindowIsOpen) ShadeMyself(); } else { NoFillButtonDown = DocColourToEdit.IsTransparent(); if (NoFillButtonDown) { AttributeManager &AttrMgr = Document::GetSelected()->GetAttributeMgr(); DocColour LineCol; DocColour FillCol; AttrMgr.GetCurrentLineAndFillColour(CC_RUNTIME_CLASS(NodeRenderableInk), &LineCol, &FillCol); if (WantLineColour) DocColourToEdit = LineCol; else DocColourToEdit = FillCol; // if the default is no fill DON'T set that because this is the colour we get // when we are explicitly removing no fill if ( DocColourToEdit.IsTransparent() ) DocColourToEdit = DocColour(COLOUR_WHITE);//prob should set to page colour } IxColourToEdit = ColourManager::GenerateNewUnnamedColour(NewParentList, &DocColourToEdit); if (EditingColour == NULL || IxColourToEdit != NULL) EditThisColour(NewParentList, IxColourToEdit, TheWindowIsOpen); else { if (TheWindowIsOpen) ShadeMyself(); } } }

void ColourEditDlg::ForceLineOrFillMode (  BOOL  PreferLineColour = FALSE  )  [static]

Sets the editing mode for local colours in the future. Whenever a new colour is chosen for editing, this will specify whether a line or fill colour should be chosen by preference. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 4/4/95 Parameters: PreferLineColour  - TRUE to set the colour to defaulting to editing [INPUTS] local line colours, FALSE to make it default to editing fill colours Definition at line 10427 of file coldlog.cpp. { EditingLineColour = PreferLineColour; }

BOOL ColourEditDlg::GetColourContext (  ColourModel  ColModel, ColourContext **  ppContext )  [static, protected]

Gets an appropriate colour context for displaying the colour picker This is so that CMYK can use the printer profile. Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 27/02/04 Parameters: ColModel  - the colour model to get a context for [INPUTS] ppContext  - location to write the context pointer [OUTPUTS] Returns: TRUE if context should be delete'd after use Definition at line 11759 of file coldlog.cpp. { // If we want a CMYK context then try to set one up with the printer profile if (ColourEditDlg::bUsePrintCMYK && ColModel == COLOURMODEL_CMYK) { PORTNOTE("other", "Disabled CMS usage") #ifndef EXCLUDE_FROM_XARALX ColourContext *pContext; XaraCMS* ptheCMS = GetApplication()->GetCMSManager(); if (ptheCMS != NULL) { // First try to set the printer context specified in the ini file read // when we started up String_256 PrintProfile; ptheCMS->GetPrinterProfile(&PrintProfile); pContext = new ColourContextCMYK(NULL, &PrintProfile); if (pContext == NULL || !(pContext->IsDeviceContext())) { // Eeek, we failed to build the physical device context // which means something rather nasty went on. delete pContext; pContext=NULL; // Now try with the default printer profile ptheCMS->GetDefaultPrinterProfile(&PrintProfile); pContext = new ColourContextCMYK(NULL, &PrintProfile); if (pContext == NULL || !(pContext->IsDeviceContext())) { // We failed to get the default printer profile so delete the context and fall through delete pContext; pContext=NULL; } } if (pContext) { ColourContextList::GetList()->AddContext(&pContext); // Add it to the list so it works properly *ppContext = pContext; return(TRUE); } } #endif } // Otherwise just fall back to getting a default context for the required model *ppContext = ColourContext::GetGlobalDefault(ColModel); return(FALSE); }

static ColourEditDlg* ColourEditDlg::GetColourEditDlg (   )  [inline, static]

\ Custom colour picker interface functions Definition at line 309 of file coldlog.h. { return (TheEditor); }

OpState ColourEditDlg::GetCommandState (  StringBase *  Command, StringBase *  ShadeReason )  [protected]

Upcall from the menu system to determine te state of a menu command. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 3/10/95 Parameters: Command  - String indicating the command to apply (see colmenu.h) [INPUTS] ShadeReason  - if OpState.Greyed is returned TRUE, this describes why [OUTPUTS] the op is greyed. Returns: An OpState indicating the state of this command (shaded etc) Definition at line 7201 of file coldlog.cpp. { OpState State; if (*Command == ColCmd_Name) // Name only available for named colour { if (ResultColour == NULL || ParentList == NULL || !ResultColour->IsNamed()) { State.Greyed = TRUE; ShadeReason->MakeMsg(_R(IDS_K_COLDLOG_NONAMELOCCOLS)); } } else if (*Command == ColCmd_EditParent) // Edit parent only available if have parent { if (ResultColour == NULL || ParentList == NULL || ResultColour->FindLinkedParent() == NULL) { State.Greyed = TRUE; ShadeReason->MakeMsg(_R(IDS_COLMENU_NOPARENT)); } } else if (*Command == ColCmd_HSV) // Tick appropriate colour model State.Ticked = (DisplayModel == COLOURMODEL_HSVT); else if (*Command == ColCmd_RGB) State.Ticked = (DisplayModel == COLOURMODEL_RGBT); else if (*Command == ColCmd_CMYK) State.Ticked = (DisplayModel == COLOURMODEL_CMYK); else if (*Command == ColCmd_Grey) State.Ticked = (DisplayModel == COLOURMODEL_GREYT); return(State); }

BOOL ColourEditDlg::GetDoTimerProcessing (   )

Access fn. Scope: public. Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 5/5/2000 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Whether or not timer processing is currently enabled Errors: - See also: Definition at line 2172 of file coldlog.cpp. { return m_bDoTimerProcessing; }

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

Get the state of the Colour editor dialogue op. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 9881 of file coldlog.cpp. { OpState OpSt; // Tick the menu while the editor is open if (TheEditor != NULL) OpSt.Ticked = TRUE; return(OpSt); }

BOOL ColourEditDlg::HandleIdlePointer (  ReDrawInfoType *  Info, String_128 *  BubbleHelp, String_256 *  StatusHelp, UINT32 *  ControlID )  [protected]

Called when the mouse is idling over the colour picker control. Sets appropriate pointer shapes, and also returns bubble help for appropriate regions (probably only the original/current colour patches). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: Info  - Kernel-rendered gadget info indicating where the mouse pointer is [INPUTS] over the colour picker (_R(IDC_EDIT_PICKER)) control BubbleHelp  - Returned containing the new bubble help string to use for this [OUTPUTS] mouse position. StatusHelp - Returned containing appropriate status-line help. ControlID - Returned with a unique "control" ID number for the "control" which the pointer is over. Currently this means _R(IDC_EDIT_PATCH1) or _R(IDC_EDIT_PATCH2), which are not real controls, but fake ones just to get a unique ID number for the current/original colour patches. Returns: TRUE if the bubble help is valid, FALSE if there is no new bubble help (Bubble help will always be set to a valid string, possibly blank) Definition at line 9163 of file coldlog.cpp. { BOOL Result = FALSE; ERROR3IF(Info == NULL || BubbleHelp == NULL || ControlID == NULL, "Illegal NULL params"); // Return a valid string no matter what happens *BubbleHelp = String_128(_T("")); *StatusHelp = String_256(_T("")); *ControlID = 0; // No bubble help "control" if (EditingColour == NULL || AmShaded) // We are shaded - abort return(FALSE); // Reset the cursor ID to none. If nobody changes this before the end of this function, // then the cursor will reset to the default (arrow or whatever). See SetCursor // UINT32 OldCurrentCursor = CurrentCursorID; CurrentCursorID = 0; // First, calculate all the regions and stuff... INT32 PixelSize = 72000 / Info->Dpi; // Size of output pixel in millipoints // If the pointer is over the colour patches then handle it and return immediately, without // passing the call onto the specific picker. // if (pointer in the current/original colour patches) // Set up bubble help // Change pointer? // return(TRUE); DocRect VirtualSize(0, 0, Info->dx, Info->dy); VirtualSize.Inflate(-PixelSize * 4); // Now draw the original/current colour patch in the top right corner DocRect PatchRect(VirtualSize); PatchRect.lo.x = PatchRect.hi.x - PATCHSIZE; PatchRect.lo.y = PatchRect.hi.y - PATCHSIZE; GridLockRect(&PatchRect, PixelSize); // Patches are horizontal if the colour model is not HSV BOOL HorzPatch = (DisplayModel != COLOURMODEL_HSVT); // But this setting is overridden for the special tint and shade modes if (EditingColour != NULL && EditingColour->GetType() == COLOURTYPE_TINT) { if (EditingColour->TintIsShade()) HorzPatch = FALSE; else HorzPatch = TRUE; } { INT32 OverWhat = 0; if (PatchRect.ContainsCoord(*(Info->pMousePos))) { if (HorzPatch) OverWhat = 1; else OverWhat = 2; } else { if (HorzPatch) PatchRect.Translate(-PATCHSIZE, 0); else PatchRect.Translate(0, -PATCHSIZE); if (PatchRect.ContainsCoord(*(Info->pMousePos))) { if (HorzPatch) OverWhat = 2; else OverWhat = 1; } } if (OverWhat != 0) { if (OverWhat == 1) { BubbleHelp->MakeMsg(_R(IDS_K_COLDLOG_CURRCOLBBL)); StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_CURRCOLSTAT)); *ControlID = _R(IDC_EDIT_PATCH1); } else { BubbleHelp->MakeMsg(_R(IDS_K_COLDLOG_ORIGCOLBBL)); StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_ORIGCOLSTAT)); *ControlID = _R(IDC_EDIT_PATCH2); } Result = TRUE; } } // Finally, if we haven't sorted ourselves out, call the relevant colour picker handler // for the current display mode etc if (BubbleHelp->IsEmpty()) { if (EditingColour->GetType() == COLOURTYPE_TINT) { if (EditingColour->TintIsShade()) Result = HandleIdlePointerShade(Info, BubbleHelp, StatusHelp); else Result = HandleIdlePointerTint(Info, BubbleHelp, StatusHelp); } else { switch (DisplayModel) { case COLOURMODEL_HSVT: Result = HandleIdlePointerHSV(Info, BubbleHelp, StatusHelp); break; case COLOURMODEL_RGBT: case COLOURMODEL_WEBRGBT: // RGB has the ability to change display modes, even when the colour is uneditable // so we call the handler even when CanSetColour() == FALSE if (Use3DDisplay) Result = HandleIdlePointerRGB(Info, BubbleHelp, StatusHelp); else Result = HandleIdlePointerDefault(Info, BubbleHelp, StatusHelp); break; case COLOURMODEL_CMYK: // CMYK has the ability to change display modes, even when the colour is uneditable // so we call the handler even when CanSetColour() == FALSE if (Use3DDisplay) Result = HandleIdlePointerCMYK(Info, BubbleHelp, StatusHelp); else Result = HandleIdlePointerDefault(Info, BubbleHelp, StatusHelp); break; default: Result = HandleIdlePointerDefault(Info, BubbleHelp, StatusHelp); break; } } } // Last, set the appropriate cursor shape /* if (OldCurrentCursor != CurrentCursorID) { TRACEUSER( "Jason", _T("Cursor Change=%ld to %ld\n"), OldCurrentCursor, CurrentCursorID); if (CurrentCursor != NULL) { delete CurrentCursor; CurrentCursor = NULL; } if (CurrentCursorID != NULL) { CurrentCursor = new Cursor(CurrentCursorID); if (CurrentCursor != NULL) CurrentCursor->SetActive(); } else { if (Cursor::Arrow != NULL) Cursor::Arrow->SetActive(); } } */ return(Result); }

BOOL ColourEditDlg::HandleIdlePointerCMYK (  ReDrawInfoType *  Info, String_128 *  BubbleHelp, String_256 *  StatusHelp )  [protected]

Called when the mouse is idling over the colour picker control. Sets appropriate pointer shapes, and also returns bubble help for appropriate regions (probably only the original/current colour patches). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: Info  - Kernel-rendered gadget info indicating where the mouse pointer is [INPUTS] over the colour picker (_R(IDC_EDIT_PICKER)) control BubbleHelp  - Returned containing the new bubble help string to use for this [OUTPUTS] mouse position. StatusHelp - Returned containing appropriate status-line help. Returns: TRUE if the bubble help is valid, FALSE if there is no new bubble help Definition at line 9573 of file coldlog.cpp. { INT32 PixelSize = 72000 / Info->Dpi; // Size of output pixel in millipoints DocRect VirtualSize(0, 0, Info->dx, Info->dy); VirtualSize.Inflate(-PixelSize * 4); // And exclude the border // Determine how much space is left over after the key slider has been placed INT32 KeySliderLeft = VirtualSize.hi.x - (CROSSRADIUS+PixelSize)*2; ERROR3IF(KeySliderLeft < VirtualSize.lo.x, "Not enough room to render the colour picker!"); // Fill the control background, and draw the cube 'shadow' DocRect CubeAvailableSpace(VirtualSize); CubeAvailableSpace.hi.x = KeySliderLeft - 2000; DocRect SquareRect; INT32 SizeZ; DrawCubeShadowAndCalcValues(NULL, &CubeAvailableSpace, PixelSize, NULL, &SquareRect, &SizeZ); DocRect CubeFaceRect(SquareRect); // Remember the rect of the front face for below // Now, shift the square down from the front of the cube by an amount appropriate to // the Z-axis component of the colour // ColourContextCMYK *cc = (ColourContextCMYK *)ColourContext::GetGlobalDefault(COLOURMODEL_CMYK); ColourContext *cc = NULL; BOOL bDeleteCC = GetColourContext(DisplayModel, &cc); ColourCMYK SourceColour; if (EditingColour != NULL) cc->ConvertColour(EditingColour, (ColourGeneric *) &SourceColour); // Delete the colour context if necessary if (bDeleteCC) ColourContextList::GetList()->RemoveContext(&cc); // Have finished with it if (CanSetColour(EditingColour)) { FIXED24 ZComponent = SourceColour.Magenta; if (ColourPickerMode == 1) ZComponent = SourceColour.Cyan; else if (ColourPickerMode == 2) ZComponent = SourceColour.Yellow; INT32 ZTrans = (INT32) ((double)SizeZ * ZComponent.MakeDouble()) - SizeZ; SquareRect.Translate(-ZTrans, ZTrans); GridLockRect(&SquareRect, PixelSize); } DocCoord BitmapPos; BitmapPos.x = HalfGridLock(CubeFaceRect.hi.x + SizeZ/2, PixelSize); BitmapPos.y = HalfGridLock(CubeFaceRect.hi.y - SizeZ/2, PixelSize); const INT32 BitmapSize = 14 * PixelSize; DocRect SwapAxesRect(BitmapPos.x, BitmapPos.y, BitmapPos.x + BitmapSize + PixelSize * 3, BitmapPos.y + BitmapSize); GridLockRect(&SwapAxesRect, PixelSize); if (SwapAxesRect.ContainsCoord(*(Info->pMousePos))) { StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_CLICKTOCYCLE2)); return(TRUE); } if (EditingColour->GetType() != COLOURTYPE_LINKED) return(FALSE); if (SquareRect.ContainsCoord(*(Info->pMousePos))) { INT32 C1 = 1; INT32 C2 = 3; if (ColourPickerMode == 1) C1 = 2; else if (ColourPickerMode == 2) C2 = 2; INT32 Count = 0; if (EditingColour->InheritsComponent(C1)) Count++; if (EditingColour->InheritsComponent(C2)) Count++; if (Count == 1) StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_DRAGINONEDIR)); else if (Count == 2) StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_CANTDRAG)); } else { // Check if the pointer is in the Z 'drag button' DocRect ZButton(SquareRect); ZButton.lo.x = ZButton.hi.x; ZButton.hi.x += ZSLIDERSIZE - (PixelSize * 2); ZButton.hi.y = ZButton.lo.y; ZButton.lo.y -= ZSLIDERSIZE - (PixelSize * 2); GridLockRect(&ZButton, PixelSize); if (ZButton.ContainsCoord(*(Info->pMousePos))) { // How on earth did all of this get so out of hand?! INT32 ComponentID = 2; if (ColourPickerMode == 1) ComponentID = 1; else if (ColourPickerMode == 2) ComponentID = 3; if (EditingColour->InheritsComponent(ComponentID)) StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_CANTDRAG2)); } else { // Check if the pointer is in the Key slider DocRect KeyRect(KeySliderLeft, 0, Info->dx, Info->dy - (PATCHSIZE + PixelSize*2)); if (KeyRect.ContainsCoord(*(Info->pMousePos))) { if (EditingColour->InheritsComponent(4)) StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_CANTDRAGKEY)); } } } return(StatusHelp->IsEmpty()); }

BOOL ColourEditDlg::HandleIdlePointerDefault (  ReDrawInfoType *  Info, String_128 *  BubbleHelp, String_256 *  StatusHelp )  [protected]

Called when the mouse is idling over the colour picker control. Sets appropriate pointer shapes, and also returns bubble help for appropriate regions (probably only the original/current colour patches). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: Info  - Kernel-rendered gadget info indicating where the mouse pointer is [INPUTS] over the colour picker (_R(IDC_EDIT_PICKER)) control BubbleHelp  - Returned containing the new bubble help string to use for this [OUTPUTS] mouse position. StatusHelp - Returned containing appropriate status-line help. Returns: TRUE if the bubble help is valid, FALSE if there is no new bubble help Definition at line 9726 of file coldlog.cpp. { if (EditingColour->GetType() != COLOURTYPE_LINKED) return(FALSE); // ColourContext *cc = ColourContext::GetGlobalDefault(DisplayModel); ColourContext *cc = NULL; BOOL bDeleteCC = GetColourContext(DisplayModel, &cc); if (cc == NULL) return(FALSE); // Get the slider rectangle widths. The height is fixed/moved during the loop below INT32 PixelSize = 72000 / Info->Dpi; // Size of output pixel in millipoints DocRect SliderRect(0, 0, Info->dx, Info->dy); SliderRect.hi.y -= PATCHSIZE + (PixelSize * 2); // Allow space for the current colour patch // Count how many components we have to display INT32 NumComponents = 0; INT32 ComponentIndex; for (ComponentIndex = 1; ComponentIndex <= 4; ComponentIndex++) { if (cc->GetComponentName(ComponentIndex, NULL)) NumComponents++; } // Calculate slider sizes and spacing INT32 SliderHeight = GetSliderHeight(SliderRect.Height(), NumComponents); INT32 SliderGap = GetSliderGap(SliderRect.Height(), NumComponents); // And move the top down by half a SliderGap, so the sliders are centered vertically SliderRect.hi.y -= SliderGap / 2; // Check the slider for each component supplied in the current DisplayModel for (ComponentIndex = 0; ComponentIndex <= 3; ComponentIndex++) { // Ensure slider rect is the correct height SliderRect.lo.y = SliderRect.hi.y - SliderHeight; // If this component is available/used in this colour model, see if we are dragging it if (cc->GetComponentName(ComponentIndex+1, NULL)) { if (SliderRect.ContainsCoord(*(Info->pMousePos))) { if (EditingColour->InheritsComponent(ComponentIndex+1)) StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_CANTDRAG2)); return(StatusHelp->IsEmpty()); } } // Move down to the next slider rectangle position SliderRect.hi.y = SliderRect.lo.y - SliderGap; } // Delete the colour context if necessary if (bDeleteCC) ColourContextList::GetList()->RemoveContext(&cc); // Have finished with it return(FALSE); }

BOOL ColourEditDlg::HandleIdlePointerHSV (  ReDrawInfoType *  Info, String_128 *  BubbleHelp, String_256 *  StatusHelp )  [protected]

Called when the mouse is idling over the colour picker control. Sets appropriate pointer shapes, and also returns bubble help for appropriate regions (probably only the original/current colour patches). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: Info  - Kernel-rendered gadget info indicating where the mouse pointer is [INPUTS] over the colour picker (_R(IDC_EDIT_PICKER)) control BubbleHelp  - Returned containing the new bubble help string to use for this [OUTPUTS] mouse position. StatusHelp - Returned containing appropriate status-line help. Returns: TRUE if the bubble help is valid, FALSE if there is no new bubble help Definition at line 9386 of file coldlog.cpp. { if (EditingColour->GetType() != COLOURTYPE_LINKED) return(FALSE); INT32 PixelSize = 72000 / Info->Dpi; // Size of output pixel in millipoints DocRect VirtualSize(0, 0, Info->dx, Info->dy); VirtualSize.Inflate(-PixelSize * 4); // And exclude the border // Calculate the two important rectangles - the hue slider, and Val/Sat square DocRect HueRect; DocRect ValSatSquare; CalculateHSVPickerRects(&VirtualSize, PixelSize, &HueRect, &ValSatSquare); if (HueRect.ContainsCoord(*(Info->pMousePos)) && EditingColour->InheritsComponent(1)) { // SetCursor(No_can_drag_me_mate); StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_NOHUECHANGE)); } else if (ValSatSquare.ContainsCoord(*(Info->pMousePos))) { if (EditingColour->InheritsComponent(2)) { if (EditingColour->InheritsComponent(3)) StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_NOSATVALCHANGE)); else StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_NOSATCHANGE)); } else if (EditingColour->InheritsComponent(3)) { StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_NOVALCHANGE)); } } return(StatusHelp->IsEmpty()); }

BOOL ColourEditDlg::HandleIdlePointerRGB (  ReDrawInfoType *  Info, String_128 *  BubbleHelp, String_256 *  StatusHelp )  [protected]

Called when the mouse is idling over the colour picker control. Sets appropriate pointer shapes, and also returns bubble help for appropriate regions (probably only the original/current colour patches). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: Info  - Kernel-rendered gadget info indicating where the mouse pointer is [INPUTS] over the colour picker (_R(IDC_EDIT_PICKER)) control BubbleHelp  - Returned containing the new bubble help string to use for this [OUTPUTS] mouse position. StatusHelp - Returned containing appropriate status-line help. Returns: TRUE if the bubble help is valid, FALSE if there is no new bubble help Definition at line 9448 of file coldlog.cpp. { INT32 PixelSize = 72000 / Info->Dpi; // Size of output pixel in millipoints // Fill the control background, and calculate the cube params (without redraw) DocRect VirtualSize(0, 0, Info->dx, Info->dy); VirtualSize.Inflate(-PixelSize * 4); // And exclude the border DocRect SquareRect; INT32 SizeZ; DrawCubeShadowAndCalcValues(NULL, &VirtualSize, PixelSize, NULL, /* TO */ &SquareRect, &SizeZ); DocRect CubeFaceRect(SquareRect); // Remember the rect of the front face for below // Now, shift the square down from the front of the cube by an amount appropriate to // the Z-axis component of the colour ColourContextRGBT *cc = (ColourContextRGBT *) ColourContext::GetGlobalDefault(COLOURMODEL_RGBT); ColourRGBT SourceColour; if (EditingColour != NULL) cc->ConvertColour(EditingColour, (ColourGeneric *) &SourceColour); if (CanSetColour(EditingColour)) { FIXED24 ZComponent = SourceColour.Blue; if (ColourPickerMode == 1) ZComponent = SourceColour.Green; else if (ColourPickerMode == 2) ZComponent = SourceColour.Red; INT32 ZTrans = (INT32) ((double)SizeZ * ZComponent.MakeDouble()) - SizeZ; SquareRect.Translate(-ZTrans, ZTrans); GridLockRect(&SquareRect, PixelSize); } DocCoord BitmapPos; BitmapPos.x = HalfGridLock(CubeFaceRect.hi.x + SizeZ/2, PixelSize); BitmapPos.y = HalfGridLock(CubeFaceRect.hi.y - SizeZ/2, PixelSize); const INT32 BitmapSize = 14 * PixelSize; DocRect SwapAxesRect(BitmapPos.x, BitmapPos.y, BitmapPos.x + BitmapSize + PixelSize * 3, BitmapPos.y + BitmapSize); GridLockRect(&SwapAxesRect, PixelSize); if (SwapAxesRect.ContainsCoord(*(Info->pMousePos))) { StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_CLICKTOCYCLE)); return(TRUE); } if (EditingColour->GetType() != COLOURTYPE_LINKED) return(FALSE); if (SquareRect.ContainsCoord(*(Info->pMousePos))) { INT32 C1 = 1; INT32 C2 = 2; if (ColourPickerMode == 1) C1 = 3; else if (ColourPickerMode == 2) C2 = 3; INT32 Count = 0; if (EditingColour->InheritsComponent(C1)) Count++; if (EditingColour->InheritsComponent(C2)) Count++; if (Count == 1) StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_DRAGINONEDIR)); else if (Count == 2) StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_CANTDRAG)); } else { // Check if the pointer is in the Z 'drag button' DocRect ZButton(SquareRect); ZButton.lo.x = ZButton.hi.x; ZButton.hi.x += ZSLIDERSIZE - (PixelSize * 2); ZButton.hi.y = ZButton.lo.y; ZButton.lo.y -= ZSLIDERSIZE - (PixelSize * 2); GridLockRect(&ZButton, PixelSize); if (ZButton.ContainsCoord(*(Info->pMousePos))) { INT32 ComponentID = ColourPickerMode; if (ComponentID == 0) ComponentID = 3; if (EditingColour->InheritsComponent(ComponentID)) StatusHelp->MakeMsg(_R(IDS_K_COLDLOG_CANTDRAG2)); } } return(StatusHelp->IsEmpty()); }

BOOL ColourEditDlg::HandleIdlePointerShade (  ReDrawInfoType *  Info, String_128 *  BubbleHelp, String_256 *  StatusHelp )  [protected]

Called when the mouse is idling over the colour picker control. Sets appropriate pointer shapes, and also returns bubble help for appropriate regions (probably only the original/current colour patches). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: Info  - Kernel-rendered gadget info indicating where the mouse pointer is [INPUTS] over the colour picker (_R(IDC_EDIT_PICKER)) control BubbleHelp  - Returned containing the new bubble help string to use for this [OUTPUTS] mouse position. Returns: TRUE if the bubble help is valid, FALSE if there is no new bubble help StatusHelp - Returned containing appropriate status-line help. Definition at line 9843 of file coldlog.cpp. { /* DocRect VirtualSize(0, 0, Info->dx, Info->dy); VirtualSize.Inflate(-PixelSize * 4); // And exclude the border // Calculate the two important rectangles - the hue slider, and Val/Sat square DocRect HueRect; DocRect ValSatSquare; CalculateHSVPickerRects(&VirtualSize, PixelSize, &HueRect, &ValSatSquare); if (!ValSatSquare.ContainsCoord(*(Info->pMousePos))) return; */ return(FALSE); }

BOOL ColourEditDlg::HandleIdlePointerTint (  ReDrawInfoType *  Info, String_128 *  BubbleHelp, String_256 *  StatusHelp )  [protected]

Called when the mouse is idling over the colour picker control. Sets appropriate pointer shapes, and also returns bubble help for appropriate regions (probably only the original/current colour patches). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 16/10/95 Parameters: Info  - Kernel-rendered gadget info indicating where the mouse pointer is [INPUTS] over the colour picker (_R(IDC_EDIT_PICKER)) control BubbleHelp  - Returned containing the new bubble help string to use for this [OUTPUTS] mouse position. StatusHelp - Returned containing appropriate status-line help. Returns: TRUE if the bubble help is valid, FALSE if there is no new bubble help Definition at line 9812 of file coldlog.cpp. { return(FALSE); }

void ColourEditDlg::HideGadgetList (  CGadgetID *  Gadgets, BOOL  Hide = TRUE )  [protected]

Hides / shows the gadgets on the list. Author: Alex Bligh Date: 30/5/2005 Parameters: Gadgets  - NULL terminated list of gadgets [INPUTS] Hide - TRUE to hide else FALSE to show Scope: Protected Definition at line 1112 of file coldlog.cpp. { CGadgetID Gadget; while ((Gadget=*(Gadgets++))) // assignment { HideGadget(Gadget, Hide); } }

void ColourEditDlg::HideOrShowColourPicker (   )  [protected]

Synchronize state of colour picker gadget. Author: Alex Bligh Date: 30/5/2005 Parameters: -  [INPUTS] Scope: Protected Definition at line 1155 of file coldlog.cpp. { if (needColPickHidden != colPickHidden) { // this used to use Hide() but that was boring EnableGadget(_R(IDC_COLOURPICKER), !needColPickHidden); colPickHidden=needColPickHidden; //CheckDialogSize(); } }

BOOL ColourEditDlg::Init (  void   )  [static]

Initialises the colour editor dialogue op. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Reimplemented from SimpleCCObject. Definition at line 9909 of file coldlog.cpp. { Camelot.DeclareSection(TEXT("Displays"), 9); Camelot.DeclarePref(TEXT("Displays"), TEXT("ColourEditorDisplayModel"), &DefaultDisplayModel); Camelot.DeclarePref(TEXT("Displays"), TEXT("ColourEditorDisplayModelS"), &DefaultDisplayModelN); Camelot.DeclarePref(TEXT("Displays"), TEXT("ColourEditorAutoModel"), &AutoModelChange); Camelot.DeclarePref(TEXT("Displays"), TEXT("ColourEditorAutoModelS"), &AutoModelChangeN); Camelot.DeclarePref(TEXT("Displays"), TEXT("ColourEditorFolded"), &Folded); Camelot.DeclarePref(TEXT("Displays"), TEXT("ColourEditorSplitLine"), &SplitLineDisplay); Camelot.DeclarePref(TEXT("Displays"), TEXT("ColourEditorUse3D"), &Use3DDisplay); Camelot.DeclarePref(TEXT("Displays"), TEXT("ColourEditorHSVHueTop"), &bHSVHueAtTop); Camelot.DeclarePref(TEXT("Displays"), TEXT("UsePrintCMYK"), &bUsePrintCMYK); DisplayModel = (ColourModel) DefaultDisplayModel; ColourContext *DefCC = NULL; BOOL bDeleteCC = GetColourContext(DisplayModel, &DefCC); if (DefCC == NULL) { DisplayModel = COLOURMODEL_HSVT; DefaultDisplayModel = (INT32) COLOURMODEL_HSVT; } // Delete the colour context if necessary if (bDeleteCC) ColourContextList::GetList()->RemoveContext(&DefCC); // Have finished with it bDeleteCC = GetColourContext((ColourModel)DefaultDisplayModelN, &DefCC); if (DefCC == NULL) DefaultDisplayModelN = (INT32) COLOURMODEL_HSVT; // Delete the colour context if necessary if (bDeleteCC) ColourContextList::GetList()->RemoveContext(&DefCC); // Have finished with it #ifdef DISABLE_WEBHEXRGBT if (DisplayModel==COLOURMODEL_WEBHEXRGBT) DisplayModel = COLOURMODEL_RGBT; #endif // Initialise all of our menu command Ops if (!OpColEditCommand::Init()) return(FALSE); // And initialise our own op return(RegisterOpDescriptor(0, // Tool ID _R(IDS_COLOUREDITDLG), // String resource ID CC_RUNTIME_CLASS(ColourEditDlg), // Runtime class OPTOKEN_COLOUREDITDLG, // Token string ColourEditDlg::GetState, // GetState function 0, // help ID _R(IDBBL_COLOUREDITOR), // bubble help _R(IDD_BARCONTROLSTORE), // resource ID _R(IDC_COLOUREDITOR), // control ID SYSTEMBAR_UTILITIES, // Bar ID TRUE, // Recieve system messages FALSE, // Smart duplicate operation TRUE, // Clean operation 0, // No vertical counterpart 0, // String for one copy only error DONT_GREY_WHEN_SELECT_INSIDE, // Auto state flags TRUE // Tickable )); }

void ColourEditDlg::InvalidateAndSetControls (  void   )  [protected]

Invalidates all of the GDraw colour-display areas (picker, patch, parent patch) and also calls SetControls to set up all the controls. Called whenever the colour has changed so significantly that the entire window needs to be updated. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 24/11/94 Definition at line 2328 of file coldlog.cpp. { InvalidateGadget(_R(IDC_EDIT_PICKER)); // Redraw picker and colour patches RedrawColourNameList(); // Redraw colour name dropdown SetControls(); // Re-init the window controls }

void ColourEditDlg::InvalidatePatchGadget (  ReDrawInfoType *  Info = NULL  )  [protected]

Invalidates the current colour patch to ensure it is redrawn. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/9/95 Parameters: Info  - if non-NULL, points to the redraw info for the picker gadget [INPUTS] (If NULL, this method will find out the info for itself) Definition at line 2431 of file coldlog.cpp. { ReDrawInfoType LocalInfo; if (Info == NULL) GetKernelRenderedGadgetInfo(_R(IDC_EDIT_PICKER), &LocalInfo); else memcpy(&LocalInfo, Info, sizeof(ReDrawInfoType)); INT32 PixelSize = 72000 / LocalInfo.Dpi; // Size of output pixel in millipoints DocRect PatchRect(0, 0, LocalInfo.dx, LocalInfo.dy); PatchRect.Inflate(-PixelSize * 4); // Allow for the indented border // Now draw the original/current colour patch in the top right corner PatchRect.lo.x = PatchRect.hi.x - PATCHSIZE; PatchRect.lo.y = PatchRect.hi.y - PATCHSIZE; GridLockRect(&PatchRect, PixelSize); // Patches are horizontal if the colour model is not HSV BOOL HorzPatch = (DisplayModel != COLOURMODEL_HSVT); // But this setting is overridden for the special tint and shade modes if (EditingColour != NULL && EditingColour->GetType() == COLOURTYPE_TINT) { if (EditingColour->TintIsShade()) HorzPatch = FALSE; else HorzPatch = TRUE; } // Translate the rect across or down as appropriate to 'HorzPatch' if (!HorzPatch) PatchRect.Translate(0, -PATCHSIZE); InvalidateGadget(_R(IDC_EDIT_PICKER), &LocalInfo, &PatchRect); }

void ColourEditDlg::InvokeDialog (  ColourList *  ParentList, IndexedColour *  ColourToEdit )  [static]

Causes a modeless colour editor to appear for the given colour. Some time down the track, if the user commits a change to that colour, the system will be notified of that change via a ColourChangingMsg broadcast. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 14/6/94 Parameters: ParentList  - the ColourList in which the colour to be edited resides [INPUTS] May be NULL to use the Selected Document's colour list ColourToEdit - the IndexedColour which you wish to edit. May be NULL in which case the editor will try to find a useful local colour to edit, or shade itself. See also: ColourEditDlg::CanYouEditThis; ColourPicker::EditColour Definition at line 10251 of file coldlog.cpp. { if (ParentList == NULL) ParentList = ColourManager::GetColourList(); // Determine if we can safely edit this colour // NOTE that the TRUE is used to cause side effects on the EditingLineColour flag, // and we will always edit a colour, even if this function returns FALSE. (But if // it is FALSE, we will edit a "useful" colour) if (!CanYouEditThis(ParentList, ColourToEdit, TRUE)) ColourToEdit = NULL; // You can't do that! Choose a "useful" colour to edit instead if (TheEditor != NULL) { // If there is an editor open, bring it to the top of the window stack, and ask it // to swap to the ColourToEdit, or a useful local colour if ColourToEdit is NULL TheEditor->BringToTop(); if (ColourToEdit == NULL) TheEditor->FindUsefulColourToEdit(TheEditor->EditingLineColour, TRUE); else TheEditor->EditThisColour(ParentList, ColourToEdit); return; } // need to set/reset static variables that control where my (as in Chris Snook) custom // colour picker control appears ..... resetColPickPos = FALSE; needColPickHidden = FALSE; colPickHidden = FALSE; // Otherwise, invoke the dialogue to bring it up ColourEditDlgParam EditInfo(ParentList, ColourToEdit); OpDescriptor *EditDlg = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(ColourEditDlg)); ERROR3IF(EditDlg == NULL, "ColourEditDlg::InvokeDialog is unable to find the ColourEditDlg OpDescriptor"); if (EditDlg != NULL) EditDlg->Invoke(&EditInfo); }

BOOL ColourEditDlg::IsSetGadgetValueCalled (   )  const [protected]

Definition at line 10788 of file coldlog.cpp. { return m_bDoingSetGadget; }

void ColourEditDlg::LimitTo216Only (   )  [protected]

Finds the nearest 20% value for this component, e.g. if n=0.23, the result will be 0.2 as this is the closest 20% value.Snaps the current colour to the closest colour in the web browseer palette. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 14/12/96 Parameters: -  [INPUTS] Needed for WEBSTER See also: - Definition at line 2691 of file coldlog.cpp. { if (EditingColour == NULL) return; ColourContext *CCrgbt = ColourManager::GetColourContext(COLOURMODEL_RGBT); ColourRGBT RGBColour,result; CCrgbt->ConvertColour(EditingColour, (ColourGeneric *)&RGBColour); PaletteManager::FindNearestBrowserColour(RGBColour,&result); // IndexedColour NewRGBIndexedColour(COLOURMODEL_RGBT, (ColourGeneric *)&result); // // *EditingColour = NewRGBIndexedColour; if (EditingColour->GetColourModel() == COLOURMODEL_RGBT) { ColourPicker::SetComponentFromDouble(EditingColour, CCrgbt, 1, result.Red.MakeDouble()); ColourPicker::SetComponentFromDouble(EditingColour, CCrgbt, 2, result.Green.MakeDouble()); ColourPicker::SetComponentFromDouble(EditingColour, CCrgbt, 3, result.Blue.MakeDouble()); } else { IndexedColour NewRGBIndexedColour(COLOURMODEL_RGBT, (ColourGeneric *)&result); ColourContext *CChsvt = ColourManager::GetColourContext(COLOURMODEL_HSVT); ColourHSVT hsv; CChsvt->ConvertColour(&NewRGBIndexedColour, (ColourGeneric *)&hsv); ColourPicker::SetComponentFromDouble(EditingColour, CChsvt, 1, hsv.Hue.MakeDouble()); ColourPicker::SetComponentFromDouble(EditingColour, CChsvt, 2, hsv.Saturation.MakeDouble()); ColourPicker::SetComponentFromDouble(EditingColour, CChsvt, 3, hsv.Value.MakeDouble()); } EditingColourHasChanged(TRUE,TRUE,TRUE); // InvalidateAndSetControls(); // And redraw the picker, and put the new values in the writables //search for "DisplayModel =" to find where it sets the display colour model //search for "Command" to find all the menu handling code }

void ColourEditDlg::LoseKeyboardFocus (  void   )  [private]

Definition at line 533 of file coldlog.cpp. { // ControlHelper::BubbleHelpDisable(); // Ensure any open bubble help is killed if (!LockLoseFocus) { // If we don't want to throw away the focus from edit controls, we'll check for that case if (!LoseFocusFromEditControls) { // AWOOGA! NASTY WINOIL CODE HACK NASTINESS YUCK YUCK YUCK !!!! **** CWindowID Focus = wxWindow::FindFocus(); if (Focus != NULL) { static UINT32 WritableGadgets[] = { _R(IDC_EDIT_COMPONENT1), _R(IDC_EDIT_COMPONENT2), _R(IDC_EDIT_COMPONENT3), _R(IDC_EDIT_COMPONENT4), _R(IDC_EDIT_WEBHEX), _R(IDC_EDIT_TINT), _R(IDC_EDIT_SHADE), _R(IDC_COLOURPICKER), //_R(IDC_EDIT_216ONLY), 0 }; // Look to see if the input focus belonhgs to an edit control in our window. // If it does, then we won't throw the focus away - we'll return immediately. INT32 i = 0; while (WritableGadgets[i]) { if (Focus == DialogManager::GetGadget(WindowID, WritableGadgets[i])) return; i++; } } } DialogManager::DefaultKeyboardFocus(); // And ensure that all component gadgets are updated - if the user was editing // in one, then we need to chop it back to displaying the value to 1 d.p. with a %, etc if (EditingColour != NULL && TextMayBeWrong) { SetComponentInfo(1, _R(IDC_NAME_COMPONENT1), _R(IDC_EDIT_COMPONENT1), _R(IDC_EDIT_INHERIT1)); SetComponentInfo(2, _R(IDC_NAME_COMPONENT2), _R(IDC_EDIT_COMPONENT2), _R(IDC_EDIT_INHERIT2)); SetComponentInfo(3, _R(IDC_NAME_COMPONENT3), _R(IDC_EDIT_COMPONENT3), _R(IDC_EDIT_INHERIT3)); SetComponentInfo(4, _R(IDC_NAME_COMPONENT4), _R(IDC_EDIT_COMPONENT4), _R(IDC_EDIT_INHERIT4)); SetAllHexComponentsInfo ((UINT32)-1, _R(IDC_NAME_WEBHEX), _R(IDC_EDIT_WEBHEX)); } TextMayBeWrong = FALSE; LoseKbdFocusPending = FALSE; // And clear the pending flag } }

BOOL ColourEditDlg::MakeColourASpot (  void   )  [private]

Moves a lump of code out of the switch statement in the message handler. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 4/9/96 Returns: TRUE if EditingColour has changed Simply changes this colour's colour type to be COLOURTYPE_SPOT. However, there is a complication in that local colours can't be spots, so we prompt the user to see if they really want a spot, in which case we have to convert their colour into a named colour before setting the type to spot. They have the chance to cancel and act as if nothing happened. Definition at line 3993 of file coldlog.cpp. { // We might be about to show an InformError dialogue. This causes the dropdown list to // close, and that in turn causes a re-entrant call to this message handler, // the net result being that we create the new colour twice, once before // the user has even decided which button to press!!! AAAAARARRRRGGH! // Nasty sounding buglet there. But let's fix the symptom... static BOOL GoneReentrant = FALSE; if (GoneReentrant) // Eek! Reentrancy! Oh, no you don't, matey! return(FALSE); if (IndexedColour::AreSpotsForcedToProcess()) { // Hey, you can't create spots now - they're all process colours! GoneReentrant = TRUE; InformError(_R(IDE_SPOTSAREPROCESS), _R(IDS_OK)); GoneReentrant = FALSE; return(FALSE); } if (EditingColour == NULL || ParentList == NULL || ResultColour == NULL) return(FALSE); BOOL Changed = FALSE; if (!ResultColour->IsNamed()) // Unnamed colour - must convert to a named colour { GoneReentrant = TRUE; LoseKeyboardFocus(); // This is an unnamed (local) colour, so it can't be a spot colour. // Ask the user if they want to cancel or convert the colour to be a named spot if (InformError(_R(IDE_LOCALCANTBESPOT), _R(IDS_MAKENAMEDSPOT), _R(IDS_CANCEL)) == 1) { // Rightoh, we should be safe from the reentrancy demon now GoneReentrant = FALSE; // Create a colour (style or local) from the current EditingColour // Make sure the new colour has a suitable parent hint colour // Make sure we don't try to make an unnamed/deleted colour our parent! IndexedColour *NewParent = ResultColour; if (NewParent != NULL && !NewParent->IsNamed()) NewParent = NewParent->FindLastLinkedParent(); // Ensure the parent is legal if (NewParent != NULL && (!NewParent->IsNamed() || NewParent->IsDeleted())) NewParent = NULL; // EditingColour will now be put into use as an undo record, so we must get // a new one for our own use... We do this first in case re-entrant calls // occur which might make us delete EditingColour or something. IndexedColour *OldResultColour = ResultColour; IndexedColour *NewColour = new IndexedColour(*EditingColour); if (NewColour == NULL) { InformError(); return(FALSE); } // And set a legal parent, or NULL if we didn't find one NewColour->SetLinkedParent(NewParent, COLOURTYPE_SPOT); // Ask the user for new-colour settings, and allow them to cancel the // make-style if they like if (!NewColourDlg::InvokeDialog(ParentList, NewColour)) { // They've cancelled the operation. Go back to editing what they were // editing before. EditThisColour(ParentList, OldResultColour); return(FALSE); } if (NewColour->IsNamed()) { // Add it to the colour list, with undo ParentList->AddItem(NewColour); IndexedColour *NewCols[2]; NewCols[0] = NewColour; NewCols[1] = NULL; ColourManager::UnHideColours(ParentList, NewCols); } else { // This should now never happen. However, if it does, we might // as well add it to the unnamed colours so we don't memory leak it. ERROR3("'New named colour' dialogue returned an UNNAMED colour"); // Just add it to the colour list ParentList->GetUnnamedColours()->AddTail(NewColour); FirstEdit = FALSE; } // Apply it to the selection ApplyColourNow(NewColour); EditThisColour(ParentList, NewColour); // And make sure we know the colour changed in some way Changed = TRUE; } // else // user cancelled, so just drop through to return FALSE } else { // It's a named colour, so we can just make it a spot with no fuss IndexedColour *LastParent = EditingColour->FindLastLinkedParent(); // Check if any safe parent colours are available LastParent = FindSafeParent(LastParent, FALSE); if (EditingColour->GetType() != COLOURTYPE_SPOT) { EditingColour->SetLinkedParent(LastParent, COLOURTYPE_SPOT); Changed = TRUE; } } GoneReentrant = FALSE; return(Changed); }

BOOL ColourEditDlg::MakeNewNColour (  void   )  [private]

Moves a lump of code out of the switch statement in the message handler, so it can be executed by the button in Camelot and the menu item in Webster. Author: Martin_Bell (Xara Group Ltd) <camelotdev@xara.com> Date: 11/7/97 Returns: TRUE if EditingColour has changed Makes a new named colour or shade. See also: ColourEditDlg::MakeColourASpot for stuff about reentrancy Definition at line 3869 of file coldlog.cpp. { // We might be about to show an InformError dialogue. This causes the dropdown list to // close, and that in turn causes a re-entrant call to this message handler, // the net result being that we create the new colour twice, once before // the user has even decided which button to press!!! AAAAARARRRRGGH! // Nasty sounding buglet there. But let's fix the symptom... static BOOL GoneReentrant = FALSE; if (GoneReentrant) // Eek! Reentrancy! Oh, no you don't, matey! return(FALSE); // Create a colour (style or local) from the current EditingColour if (EditingColour != NULL && ParentList != NULL)// && !EditingColour->IsNamed()) { // Make sure the new colour has a suitable parent colour if (EditingColour->FindLastLinkedParent() == NULL || (EditingColour->GetType() != COLOURTYPE_TINT && EditingColour->GetType() != COLOURTYPE_LINKED)) { // Make sure we don't try to make an unnamed/deleted colour our parent! IndexedColour *NewParent = ResultColour; if (NewParent != NULL && !NewParent->IsNamed()) NewParent = NewParent->FindLastLinkedParent(); // Ensure the parent is legal if (NewParent != NULL && (!NewParent->IsNamed() || NewParent->IsDeleted())) NewParent = NULL; // And set a legal parent, or NULL if we didn't find one EditingColour->SetLinkedParent(NewParent, EditingColour->GetType()); } // EditingColour will now be put into use as an undo record, so we must get // a new one for our own use... We do this first in case re-entrant calls (to // Message !) occur which might make us delete EditingColour or something. We // must handle the other reentrancy problem of closing the menu if an error // dialog pops up as well by setting GoneReentrant. IndexedColour *OldResultColour = ResultColour; IndexedColour *NewColour = new IndexedColour(*EditingColour); if (NewColour == NULL) { GoneReentrant = TRUE; InformError(); GoneReentrant = FALSE; return(FALSE); } // Ask the user for new-colour settings, and allow them to cancel the // make-style if they like if (!NewColourDlg::InvokeDialog(ParentList, NewColour)) { // They've cancelled the operation. Go back to editing what they were // editing before. EditThisColour(ParentList, OldResultColour); return(FALSE); } if (NewColour->IsNamed()) { // Add it to the colour list, with undo ParentList->AddItem(NewColour); IndexedColour *NewCols[2]; NewCols[0] = NewColour; NewCols[1] = NULL; ColourManager::UnHideColours(ParentList, NewCols); } else { // This should now never happen. However, if it does, we might // as well add it to the unnamed colours so we don't memory leak it. ERROR3("'New named colour' dialogue returned an UNNAMED colour"); // Just add it to the colour list ParentList->GetUnnamedColours()->AddTail(NewColour); FirstEdit = FALSE; } // Force the new colour into the currently displayed colour model (wysiwyg) // ColourContext *cc = ColourContext::GetGlobalDefault(DisplayModel); ColourContext *cc = NULL; BOOL bDeleteCC = GetColourContext(DisplayModel, &cc); ERROR3IF(cc == NULL, "Necessary document default colour context not defined?!"); ColourPicker::ForceColourModel(NewColour, cc); // Delete the colour context if necessary if (bDeleteCC) ColourContextList::GetList()->RemoveContext(&cc); // Have finished with it // Apply it to the selection ApplyColourNow(NewColour); DisplayModel = NewColour->GetColourModel(); EditThisColour(ParentList, NewColour); } GoneReentrant = FALSE; return TRUE; }

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

Standard DialogOp message handler, for the Colour Editor dialogue. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 Parameters: Msg  - The dialogue manager message to handle [INPUTS] -  [OUTPUTS] Returns: A MsgResult Notes: All code in this method must be able to handle being called when EditingColour == NULL (the window is shaded) Returns: Errors: - See also: - Reimplemented from DialogOp. Definition at line 2831 of file coldlog.cpp. { // DY 5/5/2000 this is really ugly but I'm in a hurry. Basically I need to disable background processing // whilst a brush stroke is in progress, at the end of the drag normal servive will be resumed if (!m_bDoTimerProcessing) return(DialogOp::Message(Message)); if (MESSAGE_IS_A(Message, ColourChangingMsg)) { ColourChangingMsg *TheMsg = (ColourChangingMsg *) Message; switch ( TheMsg->State ) { case ColourChangingMsg::COLOURUPDATED: case ColourChangingMsg::COLOURUPDATEDINVISIBLE: // If I didn't send the message and the colour is the one I'm editing, // reset the controls to reflect whatever the change was. // (This mainly happens as a result of undo) if (!ISentTheMessage && TheMsg->ChangedColour == ResultColour) { // Delete our current copy of the EditingColour, and get a fresh one // as a copy of the newly-changed ResultColour if (EditingColour != NULL) delete EditingColour; EditingColour = new IndexedColour(*ResultColour); if (EditingColour == NULL) InformError(); // Report the memory error and continue InvalidateAndSetControls(); } else if (ResultColour != NULL && ResultColour->IsADescendantOf(TheMsg->ChangedColour)) { // If an ancestor of the colour being edited has changed, redraw the editor // to take on board the change in appearance InvalidateAndSetControls(); } break; case ColourChangingMsg::LISTPAGED: // May have swapped to another list if (TheMsg->NewColourList != ParentList) { ResultColour = NULL; // Lose this colour if (EditingColour != NULL) delete EditingColour; EditingColour = NULL; UpdateOnNextIdle = TRUE; UpdateColourEditor (); } /* if (TheMsg->NewColourList != ParentList) { ResultColour = NULL; // Lose this colour if (EditingColour != NULL) delete EditingColour; EditingColour = NULL; FindUsefulColourToEdit(EditingLineColour); // Try to find a replacement if (EditingColour == NULL) // We failed - shade the dialogue ShadeMyself(); } */ break; case ColourChangingMsg::LISTDELETED: // May have deleted this colour // The ColourList we're editing in has been deleted from under us! if (TheMsg->NewColourList == ParentList) ShadeMyself(); break; case ColourChangingMsg::LISTDESELECTED:// No document available ShadeMyself(); break; case ColourChangingMsg::LISTUPDATED: // Colour may have been deleted { //BOOL SetControls = FALSE; // If the colour is deleted out from under us, try to find another one to edit if (ResultColour != NULL && ResultColour->IsDeleted()) { ResultColour = NULL; // Lose this colour if (EditingColour != NULL) delete EditingColour; EditingColour = NULL; FindUsefulColourToEdit(EditingLineColour); // Try to find a replacement if (EditingColour == NULL) // We failed - shade the dialogue ShadeMyself(); } if (EditingColour != NULL) { if (EditingColour->FindLastLinkedParent() != NULL && EditingColour->FindLastLinkedParent()->IsDeleted()) { // If the parent of EditingColour has been deleted, then make standalone IndexedColourType Type = EditingColour->GetType(); if (Type != COLOURTYPE_SPOT) Type = COLOURTYPE_NORMAL; EditingColour->SetLinkedParent(NULL, Type); //SetControls = TRUE; } else if (EditingColour->GetType() == COLOURTYPE_NORMAL && ResultColour != NULL && ResultColour->FindLinkedParent() != NULL) { // ResultColour's parent may have just become un-deleted (by an UNDO). // If this could be the case, and EditingColour has no parent, then // we must have set EditingColour to have no parent just above (i.e. the // user deleted the parent and then hit UNDO) // In this case, set EditingColour back to the values in ResultColour EditingColour->SetLinkedParent(ResultColour->FindLinkedParent(), ResultColour->GetType()); //SetControls = TRUE; } } // Ensure the colour name and type dropdowns are updated to offer sensible options State.ParentListOK = FALSE; State.Initialised = FALSE; InvalidateAndSetControls(); } break; case ColourChangingMsg::SELVIEWCONTEXTCHANGE: // The selected view's colour context has chnaged, which probably affects the // colour correction/separation options. We redraw using these options, so we // need to redraw to reflect the new settings. InvalidateAndSetControls(); break; default: break; } return(DialogOp::Message(Message)); } if (MESSAGE_IS_A(Message, SelChangingMsg)) // Selection changed - edit new colour { SelChangingMsg *Msg = (SelChangingMsg *) Message; switch ( Msg->State ) { case SelChangingMsg::COLOURATTCHANGED: case SelChangingMsg::SELECTIONCHANGED: case SelChangingMsg::NODECHANGED: if (!ISentTheMessage) { UpdateOnNextIdle = TRUE; UpdateColourEditor (); } // FindUsefulColourToEdit(EditingLineColour); break; default: break; } } else if (MESSAGE_IS_A(Message, CurrentAttrChangedMsg)) // Current attrs changed - edit new colour { if (!ISentTheMessage) { UpdateOnNextIdle = TRUE; UpdateColourEditor (); } // FindUsefulColourToEdit(EditingLineColour); } else if (MESSAGE_IS_A(Message, DragMessage)) { // If a drag starting message comes around, pass it on to the tree DragMessage *Msg = (DragMessage *) Message; if (Msg->State == DragMessage::DRAGSTARTED) { // If it's a colour drag which did NOT originate from the editor, then attach // a drag target so it can be dropped into the editor. if (Msg->pInfo->IsKindOf(CC_RUNTIME_CLASS(ColourDragInformation)) && !IS_A(Msg->pInfo, ColEditorDragInfo)) { ColourDragInformation *CDI = (ColourDragInformation *)Msg->pInfo; // Check if it's a library colour, or else it must be a colour in the selected doc if (CDI->GetParentDoc() == NULL || CDI->GetParentDoc() == Document::GetSelected()) { // Create targets for all the interesting bits of the window // **** !!!! ToDo (maybe) Targets for colour picker and colour patches // Last, add one for the whole window - this is lower priority than the // others, so will only be active for any areas which are not claimed by // the above targets /*ColEditorDragTarget * NewTarget = */ new ColEditorDragTarget(this, 0); } // We don't really care if this failed... } } } // WEBSTER - markn 9/1/97 // This message shouldn't need servicing in Webster. //#ifndef WEBSTER else if (MESSAGE_IS_A(Message, OptionsChangingMsg)) { OptionsChangingMsg *Msg = (OptionsChangingMsg *) Message; if (Msg->State == OptionsChangingMsg::NEWUNITS) { // A unit has changed. This can include the decimal point character, so we need // to set the values in all writable fields again & get the default. SetUnitGroupDefaults(DisplayModel); SetControls(); } } //#endif // WEBSTER else if (MESSAGE_IS_A(Message, DocViewMsg)) { DocViewMsg *Msg = (DocViewMsg *) Message; if (Msg->State == DocViewMsg::SELCHANGED) { // Selected DocView is changing - redraw to use the new DocView's colour context BOOL DoRedraw = TRUE; if (Msg->pOldDocView != NULL && Msg->pNewDocView != NULL) { // If we know the old & new views, then see if they have the same colour // context attached - if they do, there's no need to redraw. This eliminates // flicker when swapping normal views (the most common view-swap action) // We only check the RGB context because we assume the screen is always RGB ColourContext *OldCC = Msg->pOldDocView->GetColourContext(COLOURMODEL_RGBT, TRUE); ColourContext *NewCC = Msg->pNewDocView->GetColourContext(COLOURMODEL_RGBT, TRUE); if (OldCC == NewCC) DoRedraw = FALSE; } if (DoRedraw) { UpdateOnNextIdle = TRUE; UpdateColourEditor (); } // InvalidateAndSetControls(); } } if (!(IS_OUR_DIALOG_MSG(Message))) return(DialogOp::Message(Message)); DialogMsg* Msg = (DialogMsg*)Message; #if _DEBUG /* if ((INT32)Msg->DlgMsg == (INT32)DIM_TITLEFOCUSWARN + 1) { if (CurrentCursor != NULL) { delete CurrentCursor; CurrentCursor = NULL; } if (CurrentCursorID != NULL) { CurrentCursor = new Cursor(CurrentCursorID); if (CurrentCursor != NULL) CurrentCursor->SetActive(); } else { if (Cursor::Arrow != NULL) Cursor::Arrow->SetActive(); } return(DialogOp::Message(Message)); } */ #endif switch(Msg->DlgMsg) { case DIM_TITLEFOCUSWARN: // --- Input focus bodge --- // The window has been moved or the titlebar clicked. This means we've been given // the input focus, and we don't want that. So we throw the focus away again. // Unfortunately this does not work as we immediately get the focus again! Thus, // we set up an idle processor to be called back once all the moving has been // finished, so that we lose the focus shortly after the drag completes, and // the effect is more permanent! DragStartArea = CEDRAG_NONE; // Tell idle system we're not in the middle of a picker drag //LoseKbdFocusPending = TRUE; // And flag the fact that we want to lose the focus //BeginTimedProcessing(); //LoseKeyboardFocus (); DialogManager::DefaultKeyboardFocus(); break; case DIM_CREATE: ColourPicker::OnCreate(WindowID); SetGadgetBitmaps(_R(IDC_EDIT_DROPMENU), 0, 0); #ifndef WEBSTER SetGadgetBitmaps(_R(IDC_EDIT_MAKESTYLE), 0, 0); SetGadgetBitmaps(_R(IDC_EDIT_ADVANCED), 0, 0); #endif // WEBSTER - markn 11/12/96 // Changes to the bitmap buttons at the top of the colour editor // Set up our bitmap button gadgets with appropriate bitmaps //SetGadgetBitmaps(_R(IDC_EDIT_LINEFILL), 0, 0); SetGadgetBitmaps(_R(IDC_EDIT_NOCOLOUR), 0, 0); SetGadgetBitmaps(_R(IDC_EDIT_216ONLY), 0, 0); SetGadgetBitmaps(_R(IDC_MAKE_LOCAL), 0, 0); SetGadgetBitmaps(_R(IDC_EDIT_RENAME), 0, 0); // WEBSTER - markn 31/1/97 // Make sure the line/fill switch is set correctly //#ifdef WEBSTER //SetBoolGadgetSelected(_R(IDC_EDIT_LINEFILL), EditingLineColour); //#endif // WEBSTER ResetState(); // Ensure all controls and window extent are updated SetUnitGroupDefaults(DisplayModel); // and defaults are set SetControls(); // ...and update them ColourPicker::RelayoutDialog(WindowID); // And then lob away the input focus again - put it back into the mainframe LockLoseFocus = FALSE; // Ensure the focus lock is reset to off whenever we open LoseFocusFromEditControls = FALSE; LoseKeyboardFocus(); { INT32 i = 0; while (GadgetHelp[i].Gadget) { SetGadgetHelp(GadgetHelp[i].Gadget, GadgetHelp[i].BubbleID, GadgetHelp[i].BubbleID); i++; } } BeginTimedProcessing(); break; case DIM_COMMIT: // // NOTE - this dialogue does NOT have an 'OK' (commit) button // // The only way that we can therefore recieve this message is if return // // is pressed. If this is done in the name text field, we must update // // the name list to show this colour's name correctly if (!ISentTheMessage) { SetColour(FALSE); // Update the colour LoseFocusFromEditControls = TRUE; LoseKeyboardFocus(); // And we've committed, so lose the keyboard focus LoseFocusFromEditControls = FALSE; // // State.ParentListOK = FALSE; // SetColourNameList(); // Update the parent list } break; case DIM_CANCEL: // Cancel clicked { StatusLine* pStatusLine = StatusLine::Get(); if (!pStatusLine || !pStatusLine->IsRestrictedAccessToColourPicker()) { CloseMyself(); // And close the window } else { ColourPickerAbort (_R(IDC_COLOURPICKER)); } } return(OK); // ... making sure the base class handler is NOT called (it blows up) case DIM_CTRL_RESIZED: { if (Msg->GadgetID == _R(IDC_EDIT_PICKER)) ColourPicker::OnSize(WindowID); } break; case DIM_REDRAW: // Kernel-redraw of colour patch or picker controls { RenderControl(Msg->GadgetID, (ReDrawInfoType*) Msg->DlgMsgParam); } break; case DIM_LFT_BN_CLICKED: // Remove bubble help whenever the user clicks PORTNOTE("other", "Disabled BubbleHelp stuff") #ifndef EXCLUDE_FROM_XARALX ControlHelper::BubbleHelpDisable(); #endif if (FALSE) {} #if 0 else if (Msg->GadgetID == _R(IDC_NATIVEPICKER)) { if (EditingColour != NULL) { Close(); // Close ourself, and replace with the native colour picker ColourPicker NewPicker; NewPicker.EditColour(ParentList, ResultColour, TRUE); if (EditingColour != NULL) { delete EditingColour; EditingColour = NULL; } End(); } } #endif // WEBSTER - markn 11/12/96 #ifndef WEBSTER else if (Msg->GadgetID == _R(IDC_EDIT_ADVANCED)) { // Toggling size is allowed even when we're shaded Folded = !Folded; // Toggle the folded state of the window SetControls(); // And re-set the window size } #endif // WEBSTER #if 0 // WEBSTER - markn 11/12/96 else if (Msg->GadgetID == _R(IDC_EDIT_LINEFILL)) { FindUsefulColourToEdit(GetBoolGadgetSelected(_R(IDC_EDIT_LINEFILL))); } #endif // WEBSTER - markn 14/12/96 else if (Msg->GadgetID == _R(IDC_EDIT_NOCOLOUR)) { if ( NoFillButtonDown ) { NoFillButtonDown = FALSE; // remember it's up EditingColourHasChanged( TRUE, FALSE ); } else ApplyNoColour(EditingLineColour);//push it down } else if (Msg->GadgetID == _R(IDC_EDIT_RENAME)) { DoCommand(&ColCmd_Name); } // WEBSTER - markn 14/12/96 else if (Msg->GadgetID == _R(IDC_EDIT_216ONLY)) { LimitTo216Only(); DialogManager::DefaultKeyboardFocus(); // remove the input focus from the button (yuk!) } else if (Msg->GadgetID == _R(IDC_EDIT_DROPMENU)) { // Show drop-down menu // Chuck up a context sensitive menu ColEditContextMenu *Bob = new ColEditContextMenu; if (Bob != NULL) Bob->Show(); } else if ((Msg->GadgetID == _R(IDC_EDIT_INHERIT1)) || (Msg->GadgetID == _R(IDC_EDIT_INHERIT2)) || (Msg->GadgetID == _R(IDC_EDIT_INHERIT3)) || (Msg->GadgetID == _R(IDC_EDIT_INHERIT4))) { SetColour(FALSE); // Read the new settings from the window SetControls(); // Ensure controls shade/unshade as appropriate } // WEBSTER - markn 14/1/97 // Removed click handling on unused buttons else if (Msg->GadgetID == _R(IDC_EDIT_3D)) { // 3D display mode turned on/off. Redraw the picker control to show it // in the new mode. Use3DDisplay = GetBoolGadgetSelected(_R(IDC_EDIT_3D)); InvalidateGadget(_R(IDC_EDIT_PICKER)); } else if (Msg->GadgetID == _R(IDC_EDIT_MAKESTYLE)) { MakeNewNColour(); } // can make named colours in webster #endif // WEBSTER else if (Msg->GadgetID == _R(IDC_MAKE_LOCAL)) { // handles the webster only "Make Local to Frame" button OnMakeLocalToFrame(); } // And then lob away the input focus again - put it back into the mainframe LoseKeyboardFocus(); break; case DIM_LFT_BN_DOWN: // case DIM_RGT_BN_DOWN: // Remove bubble help whenever the user clicks PORTNOTE("other", "Disabled BubbleHelp stuff") #ifndef EXCLUDE_FROM_XARALX ControlHelper::BubbleHelpDisable(); #endif if (Msg->GadgetID == _R(IDC_COLOURPICKER)) { // This little wheeze is enough to remove hover EnableGadget(_R(IDC_COLOURPICKER), FALSE); EnableGadget(_R(IDC_COLOURPICKER), TRUE); SetBoolGadgetSelected(_R(IDC_COLOURPICKER), FALSE); InvalidateGadget(_R(IDC_COLOURPICKER)); ColourPickerDragInformation * DragCol = new ColourPickerDragInformation(); DragManagerOp::StartDrag(DragCol, GetReadWriteWindowID()); break; } // Drag methods all cope with shaded condition (EditingColour == NULL) if (Msg->DlgMsgParam) { if (Msg->GadgetID == _R(IDC_EDIT_PICKER)) { StartDrag((ReDrawInfoType*) Msg->DlgMsgParam); NoFillButtonDown = FALSE; } #if FALSE /* else if (Msg->GadgetID == _R(IDC_EDIT_PATCH) && EditingColour != NULL && ParentList != NULL) { ReDrawInfoType* Info = (ReDrawInfoType *) Msg->DlgMsgParam; INT32 PatchHeight = Info->dy / 3; IndexedColour *TheColour = ResultColour; // Middle patch/default if (Info->pMousePos->y < PatchHeight) { // Bottom patch - parent colour if (EditingColour->FindLinkedParent() != NULL) TheColour = EditingColour->FindLinkedParent(); } else if (Info->pMousePos->y > PatchHeight * 2) { // Top patch - OriginalColour TheColour = new IndexedColour(OriginalColour); if (TheColour != NULL) { TheColour->SetUnnamed(); // Ensure we don't get a memory leak ParentList->AddItem(TheColour); } } if (TheColour != NULL) { ColourDragInformation *DragCol; DragCol = new ColourDragInformation(TheColour, FALSE, (Document *)ParentList->GetParentDocument()); DragManagerOp::StartDrag(DragCol, GetReadWriteWindowID()); } } */ #endif } break; case DIM_MOUSE_DRAG: // Drag methods all cope with shaded condition (EditingColour == NULL) if (Msg->GadgetID == _R(IDC_EDIT_PICKER) && DragStartArea != CEDRAG_NONE) UpdateDrag((ReDrawInfoType*) Msg->DlgMsgParam); break; /* case DIM_MOUSE_MOVE: ColourPicker::UpdateBubbleHelpAndPointer(); break; */ case DIM_LFT_BN_UP: // Drag methods all cope with shaded condition (EditingColour == NULL) if (Msg->GadgetID == _R(IDC_EDIT_PICKER) && DragStartArea != CEDRAG_NONE) EndDrag((ReDrawInfoType*) Msg->DlgMsgParam); else if (Msg->GadgetID != _R(IDC_EDIT_DROPMENU)) // Don't lose focus if dropping a menu! LoseKeyboardFocus(); break; case DIM_RGT_BN_UP: if (EditingColour != NULL && !AmShaded) { // Chuck up a context sensitive menu ColEditContextMenu *Bob = new ColEditContextMenu; if (Bob != NULL) Bob->Show(); } break; case DIM_TEXT_CHANGED: // Text in a writable icon has changed if (!ISentTheMessage && EditingColour != NULL) { // If we are editing a colour, and we are not responsible for the // change, we update the EditingColour, and possibly force-redraw the // current-colour indicator patch, as appropriate to the change if (( Msg->GadgetID == _R(IDC_EDIT_COMPONENT1)) || ( Msg->GadgetID == _R(IDC_EDIT_COMPONENT2)) || ( Msg->GadgetID == _R(IDC_EDIT_COMPONENT3)) || ( Msg->GadgetID == _R(IDC_EDIT_COMPONENT4)) || ( Msg->GadgetID == _R(IDC_EDIT_WEBHEX))) { // While setting the colour, make sure we don't try to update the // field that the user is currently typing into! CurrentTypingGadget = Msg->GadgetID; SetColour(); CurrentTypingGadget = 0; // We have to set the transparency button manually here 'cos SetColour // does not write the gadgets when we're typing (it would over write // whatever we are typing!) if (NoFillButtonDown) // if it's up already don't bother redrawing { NoFillButtonDown = FALSE; SetBoolGadgetSelected( _R(IDC_EDIT_NOCOLOUR), NoFillButtonDown); } // Set flag to tell the 'lose focus' function to also update the // text components once while it's at it - this just tidies up the // appearance of the controls as soon as we lose focus. TextMayBeWrong = TRUE; } else if (Msg->GadgetID == _R(IDC_EDIT_TINT)) { INT32 MinValue = (EditingColour->TintIsShade()) ? -100 : 0; INT32 NewValue = GetLongGadgetValue(_R(IDC_EDIT_TINT), MinValue, 100); if (NewValue < MinValue) NewValue = MinValue; if (NewValue > 100) NewValue = 100; CurrentTypingGadget = _R(IDC_EDIT_TINT); SetColour(FALSE); CurrentTypingGadget = 0; } else if (Msg->GadgetID == _R(IDC_EDIT_SHADE)) { INT32 NewValue = GetLongGadgetValue(_R(IDC_EDIT_SHADE), -100, 100); if (NewValue < -100) NewValue = -100; if (NewValue > 100) NewValue = 100; CurrentTypingGadget = _R(IDC_EDIT_SHADE); SetColour(FALSE); CurrentTypingGadget = 0; } } break; // case DIM_FOCUS_LOST: // // This message is sent from the Name Combo box when it loses the input focus. // // This occurs when we move to a different field, close the dialogue, press // // return, etc. It means any change to the name is only set when the user // // finishes editing the text, at which point it is reasonable to ensure the // // name is unique // // if (Msg->GadgetID == _R(IDC_EDIT_NAMEMENU)) // SetColour(FALSE); // Update the colour // break; /* case DIM_SLIDER_POS_CHANGING: case DIM_SLIDER_POS_SET: if (EditingColour != NULL && !ISentTheMessage) { INT32 NewValue = GetLongGadgetValue(_R(IDC_EDIT_TINTSLIDER), 0, 100); if (NewValue < 0) NewValue = 0; if (NewValue > 100) NewValue = 100; NewValue = 100-NewValue; INT32 WritableValue = GetLongGadgetValue(_R(IDC_EDIT_TINT), 0, 100); if (WritableValue != NewValue) { BOOL LastSentState = ISentTheMessage; // Lock: Ignore DIM_TEXT_CHANGED ISentTheMessage = TRUE; SetLongGadgetValue(_R(IDC_EDIT_TINT), NewValue); ISentTheMessage = LastSentState; SetColour(); } } // And then lob away the input focus again - put it back into the mainframe LoseKeyboardFocus(); break; */ case DIM_LISTDROPPED: // A dropdown list is about to drop down- turn on our focus-losing lock LockLoseFocus = TRUE; break; case DIM_TIMER: if(Msg->DlgMsgParam == COLED_TIMER_ID) // //UpdateOnNextIdle = TRUE; TimedProcessing(); //UpdateColourEditor (); break; case DIM_SELECTION_CHANGED: // Combo-box selection case DIM_SELECTION_CHANGED_COMMIT: // Combo-box selection if (ISentTheMessage) break; if ((Msg->GadgetID == _R(IDC_EDIT_NAMEMENU)) || (Msg->GadgetID == _R(IDC_EDIT_COLMODEL)) || (Msg->GadgetID == _R(IDC_EDIT_COLTYPE)) || (Msg->GadgetID == _R(IDC_EDIT_PARENTCOL))) { // A dropdown list has been closed up again - turn off our focus-losing lock LockLoseFocus = FALSE; } // WEBSTER - markn 14/1/97 // Commented out the combo box handling //#ifndef WEBSTER // Handle selections in the colour name combobox. This will switch to // editing the chosen colour if (Msg->GadgetID == _R(IDC_EDIT_NAMEMENU) && ParentList != NULL) { WORD SelIndex; GetValueIndex(_R(IDC_EDIT_NAMEMENU), &SelIndex); if (NameDropDown != NULL) { IndexedColour *Selected = NameDropDown->DecodeSelection((INT32)SelIndex); if (Selected == NULL) { if (SelIndex < 2) // Have chosen a valid special item { // Edit fill colour or line colour FindUsefulColourToEdit((SelIndex == 1)); } else { // Must have selected the separator line. Re-jig the list to make // sure the selection is shown correctly State.ParentListOK = FALSE; SetColourNameList(); } } else { // Have selected an IndexedColour if (!Selected->IsDeleted() && Selected->IsNamed()) // Safety check EditThisColour(ParentList, Selected); } } // And then lob away the input focus again - put it back into the mainframe LoseKeyboardFocus(); break; } //#endif if (EditingColour == NULL) break; if (Msg->GadgetID == _R(IDC_EDIT_COLMODEL)) { // A colour model has been selected. If it is different from the // current model, we convert the colour into the new model, and set // up the window to edit the colour in this new model WORD Index; GetValueIndex(_R(IDC_EDIT_COLMODEL), &Index); if (Index < MAX_COLOURMODELS) { ColourContextArray ColContexts; ColourContext::GetGlobalDefaults(&ColContexts); INT32 NewModelNum; for (NewModelNum = 0; NewModelNum < MAX_COLOURMODELS; NewModelNum++) { if (ColContexts.Context[NewModelNum] != NULL) { if ((Index--) <= 0) break; } } INT32 OldModelNum = (INT32) DisplayModel; if (NewModelNum < MAX_COLOURMODELS && NewModelNum != OldModelNum) { DefaultDisplayModel = DisplayModel = (ColourModel) NewModelNum; // Switch display to the new model if (EditingColour->IsNamed()) DefaultDisplayModelN = NewModelNum; // And remember preference // But do not overwrite the preference for local colours - this must be set in the options dlg // else // DefaultDisplayModel = NewModelNum; // And remember preference // And set up the controls as appropriate. If we did not make the // change, we still need to ensure the colour model setting is // returned to displaying the current model name. // We also invalidate the colour picker to redraw it in the new display model InvalidateAndSetControls(); } } } else if (Msg->GadgetID == _R(IDC_EDIT_COLTYPE)) { // A colour model as been selected. If it is different from the // current model, we convert the colour into the new model, and set // up the window to edit the colour in this new model WORD Index; GetValueIndex(_R(IDC_EDIT_COLTYPE), &Index); #ifdef WEBSTER // "spot colour" option is not present in Webster - adjust the index appropriately // Index now 0-normal, 1-tint, 2-shade, 3-linked if (Index > 0) Index++; // Index now 0-normal, 2-tint, 3-shade, 4-linked #endif // WEBSTER IndexedColour *LastParent = EditingColour->FindLastLinkedParent(); // Check if any safe parent colours are available LastParent = FindSafeParent(LastParent, (Index == 2)); // Correct index to allow for Shade colour entry (we handle tint/shade in the same 'case') BOOL IsShadeColour = (Index == 3) ? TRUE : FALSE; if (Index >= 3) Index--; // Index now 0-normal, 1-spot, 2-tint, 2-shade, 3-linked // If it's tint/shade(2) or linked(3) and there's no parent, scream blue murder if (LastParent == NULL && (Index == 2 || Index == 3)) { // No suitable parents are available! Disallow change to tint/linked InformMessage(_R(IDS_EDIT_NOPARENT), _R(IDS_OK)); SetControls(); // Revert the gadget to the previous type break; } // Get the colour definition so that we can make a sensible attempt // at converting it into the desired colour type without losing its appearance ColourContext *cc = ColourContext::GetGlobalDefault(COLOURMODEL_HSVT); ColourHSVT ParentDef; ColourHSVT ColourDef; cc->ConvertColour((LastParent == NULL) ? EditingColour : LastParent, (ColourGeneric *)&ParentDef); cc->ConvertColour(EditingColour, (ColourGeneric *)&ColourDef); // we need to hide/show camelots custom colour picker control depending upon what we get here .... if (Index != 0) // != Normal colour { needColPickHidden = TRUE; } else { needColPickHidden = FALSE; } HideOrShowColourPicker(); BOOL Changed = FALSE; switch (Index) { case 1: // Spot Changed = MakeColourASpot(); if (!Changed) { // The colour hasn't changed - make sure that the list does not show // "Spot colour" when it's not allowed State.ColType = (IndexedColourType) 99; // Invalid! Make sure it updates SetControls(); } break; case 2: // Tint (or Shade) // Determine if this will change the colour - attempts to change // a tint to a tint or a shade to a shade must be ignored. if (EditingColour->GetType() != COLOURTYPE_TINT) Changed = TRUE; // It was not a tint or a shade, so we must change it else { if (IsShadeColour && !EditingColour->TintIsShade()) Changed = TRUE; // We're changing a Tint into a Shade if (!IsShadeColour && EditingColour->TintIsShade()) Changed = TRUE; // We're chnaging a Shade into a Tint } if (Changed) // If the type needs to be changed, do it { // Not already a tint/shade, so make it so EditingColour->SetLinkedParent(LastParent, COLOURTYPE_TINT); if (IsShadeColour) { // Not already the right kind (tint/shade) of tint, so make it so EditingColour->SetTintOrShade(IsShadeColour); Changed = TRUE; FIXED24 NewX(0.0); FIXED24 NewY(0.0); double ParentVal = ParentDef.Saturation.MakeDouble(); double ColourVal = ColourDef.Saturation.MakeDouble(); if (ParentVal > ColourVal) { if (ParentVal > 0.0) NewX = -((ParentVal - ColourVal) / ParentVal); } else { if (ParentVal < 1.0) NewX = (ColourVal - ParentVal) / (1.0 - ParentVal); } // Work out Value scaling factor ParentVal = ParentDef.Value.MakeDouble(); ColourVal = ColourDef.Value.MakeDouble(); if (ParentVal > ColourVal) { if (ParentVal > 0.0) NewY = -((ParentVal - ColourVal) / ParentVal); } else { if (ParentVal < 1.0) NewY = (ColourVal - ParentVal) / (1.0 - ParentVal); } // And make the colour a shade (a special type of tint) EditingColour->SetShadeValues(NewX, NewY); } else { double TintValue = 1.0; if (ParentDef.Saturation.MakeDouble() != 0.0) TintValue = ColourDef.Saturation.MakeDouble() / ParentDef.Saturation.MakeDouble(); EditingColour->SetTintValue(FIXED24(TintValue)); } } break; case 3: // Linked if (EditingColour->GetType() != COLOURTYPE_LINKED) { EditingColour->SetLinkedParent(LastParent, COLOURTYPE_LINKED); EditingColour->SetInheritsComponent(1, TRUE); EditingColour->SetInheritsComponent(2, TRUE); EditingColour->SetInheritsComponent(3, TRUE); EditingColour->SetInheritsComponent(4, TRUE); Changed = TRUE; } break; default: // Normal if (EditingColour->GetType() != COLOURTYPE_NORMAL) { EditingColour->SetLinkedParent(LastParent, COLOURTYPE_NORMAL); Changed = TRUE; } break; } if (Changed) EditingColourHasChanged(); // Inform world and reset/redraw our window } else if (Msg->GadgetID == _R(IDC_EDIT_PARENTCOL)) { WORD Index; GetValueIndex(_R(IDC_EDIT_PARENTCOL), &Index); // If the old parent is now 'not in use' then we'd better broadcast a message // to ensure that the colour gallery redraws if necessary. Remember the old // parent for later on... IndexedColour *OldParent = EditingColour->FindLinkedParent(); // Find the new parent colour IndexedColour *NewParent = DecodeParentColourListSelection((INT32)Index); // And broadcast for the new parent, if it is now about to become in-use! if (NewParent != NULL && !NewParent->HasLinkedChildren()) ColourManager::ColourHasChangedInvisible((Document *)ParentList->GetParentDocument(), ParentList, NewParent); // Finally, set the new parent of this colour, and inform the world and fix up our window EditingColour->SetLinkedParent(NewParent, EditingColour->GetType()); EditingColourHasChanged(); // Now do the broadcast for the old parent (we waited until after SetLinkedParent so we // only bother with the broadcast if this has removed the *last* child of that parent) if (OldParent != NULL && !OldParent->HasLinkedChildren()) ColourManager::ColourHasChangedInvisible((Document *)ParentList->GetParentDocument(), ParentList, OldParent); } // And then lob away the input focus again - put it back into the mainframe LoseKeyboardFocus(); break; default: break; } return(DialogOp::Message(Message)); }

FIXED24 ColourEditDlg::Nearest20Percent (  FIXED24  n  )  [protected]

void ColourEditDlg::NeedsResize (   )  [inline, protected]

Definition at line 560 of file coldlog.h. {m_NeedsResize = TRUE;}

BOOL ColourEditDlg::OnIdleEvent (  void   )  [protected, virtual]

Idle event handler for the colour dialog. Author: Alex Bligh Date: 30/5/2005 Returns: FALSE (to indicate we want no more idle events) The wakeup from the timer will create one for us Errors: - Reimplemented from Operation. Definition at line 1135 of file coldlog.cpp. { return ColourPicker::OnIdleEvent(WindowID); }

BOOL ColourEditDlg::OnKeyPress (  KeyPress *  pKeyPress  )  [static]

To handle keypresses. This is called by Application::OnKeyPress before all other keypress handling. Normally the colour editor will just return FALSE as fast as possible, but during drags in the editor, it will return TRUE to stop keypresses getting through to the rest of camelot. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 5/2/95 Parameters: pKeyPress  - points to a keypress object describing the key press [INPUTS] Returns: TRUE if it has processed the keypress (claimed it) FALSE if it has not used the keypress, in which case it may be passed on Notes: Not intended to be called by anyone other than Application::OnKeypress May be called at any time See also: Application::OnKeyPress; ColourEditDlg::StartDrag Definition at line 7355 of file coldlog.cpp. { ERROR3IF(pKeyPress == NULL, "Illegal NULL param!"); if (TheEditor == NULL || TheEditor->DragStartArea == CEDRAG_NONE) return(FALSE); // No current drag, so leave the key alone // We are dragging... // Check for escape being pressed if ((TheEditor->AbortColour != NULL) && ((pKeyPress->GetVirtKey () == CAMKEY(ESCAPE)) || (pKeyPress->GetVirtKey () == CAMKEY(CANCEL)))) { EscapeKeyWasPressed = TRUE; TheEditor->SetNewValueFromMousePos(NULL, FALSE); } // Sit on all keypresses to make sure nobody else gets them return(TRUE); }

BOOL ColourEditDlg::OnMakeLocalToFrame (   )  [protected]

Invokes the OpMakeColourLocalToFrame operation to make local copy of the current edited colour. Author: Stefan_Stoykov (Xara Group Ltd) <camelotdev@xara.com> Date: 31/7/97 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 11612 of file coldlog.cpp. { #if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX) // find our operation OpDescriptor* OpDesc = OpDescriptor::FindOpDescriptor(CC_RUNTIME_CLASS(OpMakeColourLocalToFrame)); if (OpDesc != NULL) { // set up the info to pass to the operation ColourChangeInfo Param; Param.ParentList = ParentList; Param.Target = ResultColour; // invoke the operation OpDesc->Invoke((OpParam *) &Param); // set the colour in the colour editor EditThisColour(ParentList, Param.NewDefn, TRUE); return TRUE; } #endif return FALSE; }

void ColourEditDlg::RedrawColourNameList (  void   )  [protected]

Ensures that the colour splodge in the colour name dropdown list is redrawn using the correct new appearance of the colour. Far more efficient than rebuilding the colour list from scratch. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 20/10/95 Definition at line 919 of file coldlog.cpp. { if (NameDropDown == NULL) return; String_256 FillColDesc(_R(IDS_COLEDIT_FILL)); String_256 LineColDesc(_R(IDS_COLEDIT_LINE)); SelRange *Selection = GetApplication()->FindSelection(); if (Selection->Count() == 0) // No selection, so will use current colours { FillColDesc = String_256(_R(IDS_COLEDIT_CURFILL)); LineColDesc = String_256(_R(IDS_COLEDIT_CURLINE)); } ColourList *NewParentList = NULL; DocColour DocColourToEdit; ColourManager::FindColourOfInterestToUser(&DocColourToEdit, &NewParentList, FALSE); NameDropDown->UpdateSpecialEntry(&FillColDesc, &DocColourToEdit); ColourManager::FindColourOfInterestToUser(&DocColourToEdit, &NewParentList, TRUE); NameDropDown->UpdateSpecialEntry(&LineColDesc, &DocColourToEdit); // And ensure that the dropdown is redrawn InvalidateGadget(_R(IDC_EDIT_NAMEMENU)); }

void ColourEditDlg::RenderConstraint (  RenderRegion *  pRender, DocCoord  End1, DocCoord  End2 )  [protected]

Renders a colour picker constraint bubble. This is a "sausage" in a straight line around two endpoints, used to mark drag constraints on screen. Parameters: pRender  - The RenderRegion to render the constraint into [INPUTS] End1 - The point at one end of the constraint bubble End2 - The point at the other end of the constraint bubble Notes: if (End1 == End2) a circle will be drawn at that point This may draw the semicircular caps the wrong way around. It works for the cases I've needed so far, so I couldn't be bothered tidying it up. Definition at line 4253 of file coldlog.cpp. { if (End1 == End2) { const INT32 CircleSize = CROSSRADIUS + 1000; const INT32 CPDist = (const INT32) ( ((double)CircleSize) * 0.552 ); // The constraint bubble is a circle. Special-case the redraw pRender->SetLineColour(COLOUR_WHITE); Path Bubble; Bubble.Initialise(12, 12); Bubble.FindStartOfPath(); Bubble.InsertMoveTo(DocCoord(End1.x+CircleSize, End1.y)); Bubble.InsertCurveTo(DocCoord(End1.x+CircleSize, End1.y+CPDist), DocCoord(End1.x+CPDist, End1.y+CircleSize), DocCoord(End1.x, End1.y+CircleSize)); Bubble.InsertCurveTo(DocCoord(End1.x-CPDist, End1.y+CircleSize), DocCoord(End1.x-CircleSize, End1.y+CPDist), DocCoord(End1.x-CircleSize, End1.y)); Bubble.InsertCurveTo(DocCoord(End1.x-CircleSize, End1.y-CPDist), DocCoord(End1.x-CPDist, End1.y-CircleSize), DocCoord(End1.x, End1.y-CircleSize)); Bubble.InsertCurveTo(DocCoord(End1.x+CPDist, End1.y-CircleSize), DocCoord(End1.x+CircleSize, End1.y-CPDist), DocCoord(End1.x+CircleSize, End1.y)); Bubble.IsFilled = FALSE; pRender->DrawPath(&Bubble); // Render the value square } else { const INT32 CircleSize = (CROSSRADIUS + 1000) / 2; // const INT32 CPDist = (const INT32) ( ((double)CircleSize) * 0.552 ); DocCoord Dist = End1 - End2; double Angle = 0.0; if (Dist.x == 0) { if (Dist.y < 0) Angle = PI; } else Angle = atan2((double)Dist.y, (double)Dist.x) - (PI/2); Dist.x = (INT32) ((double)CircleSize * cos(Angle)); Dist.y = (INT32) ((double)CircleSize * sin(Angle)); DocCoord ArcStart1(End2 + Dist); DocCoord ArcEnd1(End2 - Dist); DocCoord ArcStart2(End1 - Dist); DocCoord ArcEnd2(End1 + Dist); pRender->SetLineColour(COLOUR_WHITE); Path Bubble; Bubble.Initialise(12, 12); Bubble.FindStartOfPath(); DocCoord RevDist(Dist.y, Dist.x); // BODGE to fix vertical case - only horizontal/vertical cases are guaranteed to work if (End1.y != End2.y) RevDist = DocCoord(-Dist.y, -Dist.x); Bubble.InsertMoveTo(ArcStart1); Bubble.InsertCurveTo(ArcStart1 + RevDist, ArcEnd1 + RevDist, ArcEnd1); Bubble.InsertLineTo(ArcStart2); Bubble.InsertCurveTo(ArcStart2 - RevDist, ArcEnd2 - RevDist, ArcEnd2); Bubble.InsertLineTo(ArcStart1); // Close the path Bubble.IsFilled = FALSE; pRender->DrawPath(&Bubble); // Render the value square } }

void ColourEditDlg::RenderControl (  UINT32  GadgetToRender, ReDrawInfoType *  RedrawInfo )  [protected]

Renders the controls that are kernel-redrawn (The colour 'picker' section, and the two (original and new colour definitions) colour patches). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 1/11/94 Parameters: GadgetToRender  - The gadget that needs to be redrawn [INPUTS] ExtraInfo - The structure that has the extra data we need to start rendering Notes: If EditingColour is NULL (as is the case when the window is shaded) the redraw is changed appropriately (pickers show values appropriate to display of 'white', position marker crosses are not drawn, an colour patches show mid grey). Definition at line 6676 of file coldlog.cpp. { // Use a virtual coord space of (0,0) to (dx, dy) DocRect VirtualSize(0, 0, RedrawInfo->dx, RedrawInfo->dy); // Get a render region to use. The TRUE parameter specifies that we want to use // the same colour correction/separation contexts as the currently selected DocView, // so that we display "document colour" in an appropriate manner. RenderRegion *pRender; if (GadgetToRender == _R(IDC_EDIT_PICKER)) pRender = CreateGRenderRegion(&VirtualSize, RedrawInfo, TRUE); else pRender = CreateOSRenderRegion(&VirtualSize, RedrawInfo, TRUE); // I would ENSURE pRender != NULL, but it's perfectly legal if we get a 0-width // redraw cliprect, etc, so we basically have to ignore NULL returns. INT32 PixelSize = 72000 / RedrawInfo->Dpi; // Size of output pixel in millipoints if (pRender != NULL) { // Interlock redraw with the drag manager to ensure we don't redraw over any drag blobs DragManagerOp::RedrawStarting(WindowID, GadgetToRender); DialogColourInfo RedrawColours; // Object supplying Host OS redraw colours if (GadgetToRender == _R(IDC_EDIT_PICKER)) { // Draw a narrow plinth around the edge of the control pRender->SaveContext(); pRender->SetLineWidth(0); pRender->SetFillColour(RedrawColours.DialogBack()); pRender->SetLineColour(RedrawColours.ButtonShadow()); pRender->DrawRect(&VirtualSize); pRender->SetLineColour(RedrawColours.ButtonHighlight()); pRender->DrawLine(VirtualSize.hi, DocCoord(VirtualSize.hi.x, VirtualSize.lo.y)); pRender->DrawLine(DocCoord(VirtualSize.hi.x, VirtualSize.lo.y), VirtualSize.lo); // And deflate the rect by 2 pixels VirtualSize.Inflate(-PixelSize * 4); // Now draw the original/current colour patch in the top right corner DocRect PatchRect(VirtualSize); PatchRect.lo.x = PatchRect.hi.x - PATCHSIZE; PatchRect.lo.y = PatchRect.hi.y - PATCHSIZE; GridLockRect(&PatchRect, PixelSize); DocColour Orig; if (EditingColour == NULL) Orig = DocColour(128, 128, 128); else Orig.MakeRefToIndexedColour(&OriginalColour); DocColour PatchCol; if (EditingColour == NULL) PatchCol = DocColour(128, 128, 128); else PatchCol.MakeRefToIndexedColour(EditingColour); // Patches are horizontal if the colour model is not HSV BOOL HorzPatch = (DisplayModel != COLOURMODEL_HSVT); // But this setting is overridden for the special tint and shade modes if (EditingColour != NULL && EditingColour->GetType() == COLOURTYPE_TINT) { if (EditingColour->TintIsShade()) HorzPatch = FALSE; else HorzPatch = TRUE; } pRender->SetLineWidth(0); pRender->SetLineColour(COLOUR_BLACK); if (HorzPatch) pRender->SetFillColour(PatchCol); else pRender->SetFillColour(Orig); pRender->DrawRect(&PatchRect); if (HorzPatch) { // Move the patch to the left for the second square PatchRect.Translate(-PATCHSIZE, 0); pRender->SetFillColour(Orig); } else { // Move the patch down for the second square PatchRect.Translate(0, -PATCHSIZE); pRender->SetFillColour(PatchCol); } pRender->DrawRect(&PatchRect); /* // DocColour Trans(COLOUR_TRANS); // pRender->SetLineColour(Trans); pRender->SetFillColour(Orig); Path TriPath; TriPath.Initialise(12, 12); TriPath.FindStartOfPath(); TriPath.InsertMoveTo(PatchRect.lo); TriPath.InsertLineTo(DocCoord(PatchRect.lo.x, PatchRect.hi.y)); TriPath.InsertLineTo(PatchRect.hi); TriPath.IsFilled = TRUE; pRender->DrawPath(&TriPath); // Render the value square */ pRender->RestoreContext(); if (EditingColour != NULL && EditingColour->GetType() == COLOURTYPE_TINT) // Tint or shade { if (EditingColour->TintIsShade()) { RenderPickerShade(pRender, &VirtualSize, PixelSize, &RedrawColours, RedrawInfo->pClipRect); } else RenderPickerTint(pRender, &VirtualSize, PixelSize, &RedrawColours); } else { switch (DisplayModel) { case COLOURMODEL_RGBT: case COLOURMODEL_WEBRGBT: if (Use3DDisplay) RenderPickerRGB(pRender, &VirtualSize, PixelSize, &RedrawColours); else RenderPickerDefault(pRender, &VirtualSize, PixelSize, &RedrawColours); break; case COLOURMODEL_CMYK: if (Use3DDisplay) RenderPickerCMYK(pRender, &VirtualSize, PixelSize, &RedrawColours); else RenderPickerDefault(pRender, &VirtualSize, PixelSize, &RedrawColours); break; case COLOURMODEL_HSVT: RenderPickerHSV(pRender, &VirtualSize, PixelSize, &RedrawColours, RedrawInfo->pClipRect); break; default: RenderPickerDefault(pRender, &VirtualSize, PixelSize, &RedrawColours); break; } } } #if 0 else if (GadgetToRender == _R(IDC_EDIT_PATCH)) // Old/New/Parent-colour patch { pRender->SaveContext(); DocColour Trans(COLOUR_TRANS); DocColour Orig; if (EditingColour == NULL) Orig = DocColour(128, 128, 128); else Orig.MakeRefToIndexedColour(&OriginalColour); pRender->SetLineWidth(0); pRender->SetLineColour(Trans); DocColour PatchCol; if (EditingColour == NULL) PatchCol = DocColour(128, 128, 128); else PatchCol.MakeRefToIndexedColour(EditingColour); pRender->SetFillColour(PatchCol); pRender->DrawRect(&VirtualSize); pRender->SetFillColour(Orig); Path TriPath; TriPath.Initialise(12, 12); TriPath.FindStartOfPath(); TriPath.InsertMoveTo(VirtualSize.lo); TriPath.InsertLineTo(DocCoord(VirtualSize.lo.x, VirtualSize.hi.y)); TriPath.InsertLineTo(DocCoord(VirtualSize.hi.x, VirtualSize.lo.y)); TriPath.IsFilled = TRUE; pRender->DrawPath(&TriPath); // Render the value square #if 0 INT32 PatchHeight = VirtualSize.Height() / 3; DocRect TheRect(VirtualSize); TheRect.lo.y = TheRect.hi.y - PatchHeight; pRender->DrawRect(&TheRect); DocColour PatchCol; if (EditingColour == NULL) PatchCol = DocColour(128, 128, 128); else PatchCol.MakeRefToIndexedColour(EditingColour); pRender->SetFillColour(PatchCol); TheRect.Translate(0, -PatchHeight); // Move the patch rect down and plot pRender->DrawRect(&TheRect); if (EditingColour != NULL && EditingColour->FindLinkedParent() != NULL) PatchCol.MakeRefToIndexedColour(EditingColour->FindLinkedParent()); pRender->SetFillColour(PatchCol); TheRect.Translate(0, -PatchHeight); // Move the patch rect down and plot pRender->DrawRect(&TheRect); #endif pRender->RestoreContext(); } #endif else { ERROR3("Render request for unsupported kernel-rendered control!"); } // Get rid of the render region if (GadgetToRender == _R(IDC_EDIT_PICKER)) DestroyGRenderRegion(pRender); else DestroyOSRenderRegion(pRender); // And turn off the drag redraw interlock DragManagerOp::RedrawFinished(); } }

void ColourEditDlg::RenderCross (  RenderRegion *  pRender, DocRect *  CrossRect, INT32  PixelSize, BOOL  Shaded = FALSE )  [protected]

Renders a colour picker marker cross (a 'plus' shape). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 15/11/94 Parameters: pRender  - The RenderRegion to render the marker cross into [INPUTS] CrossRect - The rectangle (in millipoints, within the RenderRegion) in which to draw the cross. This should be a square, CROSSRADIUS*2 millipoints wide/high. PixelSize - The size of a device pixel, in millipoints Shaded - TRUE if the cross should be drawn 'shaded' (not draggable) Definition at line 4138 of file coldlog.cpp. { pRender->SaveContext(); // Save the current rendering context DocColour Trans(COLOUR_TRANS); DocColour Black(COLOUR_BLACK); DocColour White(COLOUR_WHITE); if (Shaded) // Cross becomes more faint if it can't be dragged { // Black = DocColour(80L, 80L, 80L); // White = DocColour(176L, 176L, 176L); // Now it just gets a constraint circle around it DocCoord Center((CrossRect->lo.x + CrossRect->hi.x) / 2, (CrossRect->lo.y + CrossRect->hi.y) / 2); RenderConstraint(pRender, Center, Center); } pRender->SetLineWidth(0); pRender->SetLineColour(White); // Render a crosshair shape pRender->SetFillColour(Black); DocRect CrossLine; INT32 LineWidth = CrossRect->Width() / 2; INT32 LineHeight = CrossRect->Height() / 2; CrossLine.lo.y = CrossRect->lo.y + LineHeight - PixelSize; CrossLine.hi.y = CrossRect->lo.y + LineHeight + PixelSize; CrossLine.lo.x = CrossRect->lo.x; CrossLine.hi.x = CrossRect->lo.x + LineWidth/2; pRender->DrawRect(&CrossLine); CrossLine.lo.x = CrossRect->hi.x - LineWidth/2; CrossLine.hi.x = CrossRect->hi.x; pRender->DrawRect(&CrossLine); CrossLine.lo.x = CrossRect->lo.x + LineWidth - PixelSize; CrossLine.hi.x = CrossRect->lo.x + LineWidth + PixelSize; CrossLine.lo.y = CrossRect->lo.y; CrossLine.hi.y = CrossRect->lo.y + LineHeight/2; pRender->DrawRect(&CrossLine); CrossLine.lo.y = CrossRect->hi.y - LineHeight/2; CrossLine.hi.y = CrossRect->hi.y; pRender->DrawRect(&CrossLine); pRender->RestoreContext(); // Restore the previous rendering context }

void ColourEditDlg::RenderParentCross (  RenderRegion *  pRender, DocRect *  CrossRect, INT32  PixelSize )  [protected]

Renders a colour picker marker cross (an 'x' shape) to indicate the position of the PARENT colour on the colour's picker. Used for shades and maybe for linked colours if they ever become relative. Parameters: pRender  - The RenderRegion to render the marker cross into [INPUTS] CrossRect - The rectangle (in millipoints, within the RenderRegion) in which to draw the cross. This should be a square, CROSSRADIUS*2 millipoints wide/high. PixelSize - The size of a device pixel, in millipoints Definition at line 4213 of file coldlog.cpp. { pRender->SaveContext(); // Save the current rendering context pRender->SetLineWidth(0); pRender->SetLineColour(COLOUR_WHITE); pRender->SetFillColour(COLOUR_TRANS); pRender->DrawLine(CrossRect->lo, CrossRect->hi); pRender->DrawLine(DocCoord(CrossRect->lo.x, CrossRect->hi.y), DocCoord(CrossRect->hi.x, CrossRect->lo.y)); pRender->RestoreContext(); // Restore the previous rendering context }

void ColourEditDlg::RenderPickerCMYK (  RenderRegion *  pRender, DocRect *  VirtualSize, INT32  PixelSize, DialogColourInfo *  RedrawColours )  [protected]

Redraws a colour picker control for the colour editor dialogue. This is used in the given display mode to display the colour information in a useful format. e.g. in HSV mode, a wheel and slider arrangement. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 23/12/94 Parameters: pRender  - The render region to render the picker in [INPUTS] VirtualSize - The rectangle defining the coordinate space to draw into PixelSize - The size of a pixel as mapped into the MILLIPOINT VirtualSize coordinate space; ensures things line up on display pixel boundaries. RedrawColours - A pointer to a DialogColourInfo object describing OS-friendly drawing colours to be used in redrawing the control. See also: ColourEditDlg::RenderControl; ColourEditDlg::RenderPickerDefault Definition at line 5882 of file coldlog.cpp. { pRender->SaveContext(); // Save the current rendering context DocColour Trans(COLOUR_TRANS); // Determine how much space is left over after the key slider has been placed INT32 KeySliderLeft = VirtualSize->hi.x - (CROSSRADIUS+PixelSize)*2; ERROR3IF(KeySliderLeft < VirtualSize->lo.x, "Not enough room to render the colour picker!"); // First, set up the render region, and fill the background with Dialogue BG colour pRender->SetLineWidth(0); pRender->SetLineColour(Trans); // pRender->SetFillColour(RedrawColours->DialogBack()); // pRender->DrawRect(VirtualSize); // Draw the cube 'shadow', and calculate where the cube sits DocRect CubeAvailableSpace(*VirtualSize); CubeAvailableSpace.hi.x = KeySliderLeft - 2000; DocRect SquareRect; INT32 SizeZ; DrawCubeShadowAndCalcValues(pRender, &CubeAvailableSpace, PixelSize, RedrawColours, /* TO */ &SquareRect, &SizeZ); // Find the source colour definition in RGB space ColourCMYK SourceColour; if (EditingColour != NULL) { // ColourContextCMYK *ccCMYK = (ColourContextCMYK*)ColourContext::GetGlobalDefault(COLOURMODEL_CMYK); ColourContext *ccCMYK = NULL; BOOL bDeleteCC = GetColourContext(COLOURMODEL_CMYK, &ccCMYK); ERROR3IF(ccCMYK == NULL, "Can't get a CMYK colour context"); ccCMYK->ConvertColour(EditingColour, (ColourGeneric *) &SourceColour); // Delete the colour context if necessary if (bDeleteCC) ColourContextList::GetList()->RemoveContext(&ccCMYK); // Have finished with it } else { SourceColour.Cyan =SourceColour.Magenta = SourceColour.Yellow = SourceColour.Key = 0; } DocRect FrontFaceRect(SquareRect); // Remember the old squarerect for later // Now, Move the 'SquareRect' down and left so its bottom corner touches the Z axis // at the appropriate point for the current Z value. (i.e. slice the cube through at // the place where the slice really is) if (EditingColour != NULL) { FIXED24 ZComponent = SourceColour.Magenta; if (ColourPickerMode == 1) ZComponent = SourceColour.Cyan; else if (ColourPickerMode == 2) ZComponent = SourceColour.Yellow; INT32 ZTrans = (INT32) ((double)SizeZ * ZComponent.MakeDouble()) - SizeZ; SquareRect.Translate(-ZTrans, ZTrans); GridLockRect(&SquareRect, PixelSize); } // Now, composite up the picker square, which is made of 3 squares on top of each // other, all flat-filled in primary colours, the top 2 having horz/vert trans fills ColourCMYK BaseColour; ColourCMYK MidColour; ColourCMYK TopColour; BaseColour.Cyan = BaseColour.Magenta = BaseColour.Yellow = 0; BaseColour.Key = SourceColour.Key; memcpy(&MidColour, &BaseColour, sizeof(ColourCMYK)); memcpy(&TopColour, &BaseColour, sizeof(ColourCMYK)); switch(ColourPickerMode) { case 1: // XYZ = Y,M,C MidColour.Yellow = FIXED24(1.0); TopColour.Magenta = FIXED24(1.0); BaseColour.Cyan = SourceColour.Cyan; break; case 2: // XYZ = M,C,Y MidColour.Magenta = FIXED24(1.0); TopColour.Cyan = FIXED24(1.0); BaseColour.Yellow = SourceColour.Yellow; break; default: // XYZ = C,Y,M MidColour.Cyan = FIXED24(1.0); TopColour.Yellow = FIXED24(1.0); BaseColour.Magenta = SourceColour.Magenta; ColourPickerMode = 0; // Ensure any out of value setting is made valid break; } RenderPickerSquare(pRender, &SquareRect, (ColourGeneric *) &BaseColour, (ColourGeneric *) &MidColour, (ColourGeneric *) &TopColour, COLOURMODEL_CMYK, 2); // Use CMYK + 'Stain' (Filtering) transparency // Place the outline of the front of the cube on top DocColour CubeFaceGrey(180L, 180L, 180L); pRender->SetLineColour(CubeFaceGrey); pRender->SetFillColour(Trans); DocCoord BotRightFront(FrontFaceRect.hi.x, FrontFaceRect.lo.y); pRender->DrawLine(BotRightFront, FrontFaceRect.lo); pRender->DrawLine(BotRightFront, FrontFaceRect.hi); pRender->DrawLine(BotRightFront, DocCoord(FrontFaceRect.hi.x + SizeZ, FrontFaceRect.lo.y - SizeZ)); // Render the Key slider - a white->black grad filled rectangle LinearFillAttribute KeyGradFill; KeyGradFill.Colour = DocColour(0L, 0L, 0L); KeyGradFill.EndColour = DocColour(255L, 255L, 255L); DocCoord ThePoint(VirtualSize->hi.x, VirtualSize->hi.y - (PATCHSIZE + PixelSize*2)); KeyGradFill.SetStartPoint(&ThePoint); ThePoint = DocCoord(VirtualSize->hi.x, VirtualSize->lo.y); KeyGradFill.SetEndPoint(&ThePoint); KeyGradFill.SetEndPoint2(NULL); pRender->SetFillGeometry(&KeyGradFill, FALSE); pRender->SetLineColour(Trans); Path KeyPath; KeyPath.Initialise(12, 12); KeyPath.FindStartOfPath(); KeyPath.InsertMoveTo(DocCoord(KeySliderLeft, VirtualSize->lo.y)); KeyPath.InsertLineTo(DocCoord(VirtualSize->hi.x, VirtualSize->lo.y)); KeyPath.InsertLineTo(DocCoord(VirtualSize->hi.x, VirtualSize->hi.y - (PATCHSIZE + PixelSize*2))); KeyPath.InsertLineTo(DocCoord(KeySliderLeft, VirtualSize->hi.y - (PATCHSIZE + PixelSize*2))); KeyPath.IsFilled = TRUE; pRender->DrawPath(&KeyPath); // Render the value/brightness strip // Draw the swap-axes button DocCoord BitmapPos; BitmapPos.x = HalfGridLock(FrontFaceRect.hi.x + SizeZ/2, PixelSize); BitmapPos.y = HalfGridLock(FrontFaceRect.hi.y - SizeZ/2, PixelSize); const INT32 BitmapSize = 14 * PixelSize; DocRect SwapAxesStrip(BitmapPos.x + BitmapSize, BitmapPos.y, BitmapPos.x + BitmapSize + PixelSize * 3, BitmapPos.y + BitmapSize); GridLockRect(&SwapAxesStrip, PixelSize); DocColour SwapAxesFore(0L, 0L, 0L); DocColour SwapAxesFill(255L, 0L, 255L); if (ColourPickerMode == 1) SwapAxesFill = DocColour(0L, 255L, 255L); else if (ColourPickerMode == 2) SwapAxesFill = DocColour(255L, 255L, 0L); pRender->SetFillColour(SwapAxesFill); pRender->SetLineColour(SwapAxesFore); pRender->DrawRect(&SwapAxesStrip); // Render the bitmap last, to ensure we don't overwrite it pRender->DrawBitmap(BitmapPos, _R(IDB_PICKER_SWAPAXIS)); DocColour MidGrey(128L, 128L, 128L); if (EditingColour != NULL) { // And draw a drag icon on the current Z position **** !!!! ToDo: Should be a bitmap icon DocRect ZButton(SquareRect); ZButton.lo.x = ZButton.hi.x; ZButton.hi.x += ZSLIDERSIZE - (PixelSize * 2); ZButton.hi.y = ZButton.lo.y; ZButton.lo.y -= ZSLIDERSIZE - (PixelSize * 2); GridLockRect(&ZButton, PixelSize); pRender->DrawBitmap(ZButton.lo, _R(IDB_PICKER_ZSLIDER)); // Render marker cross in the appropriate X-Y place for the definition // of the current editing colour DocRect CrossRect; CrossConstraint Constraint = CalcCrossRectCMYK(&SourceColour, &SquareRect, PixelSize, &CrossRect); RenderCross(pRender, &CrossRect, PixelSize, (Constraint == CROSSCONSTRAINED_BOTH)); // And render constraint bubbles if necessary if (Constraint == CROSSCONSTRAINED_HORZ) { INT32 MidY = (CrossRect.lo.y + CrossRect.hi.y) / 2; RenderConstraint(pRender, DocCoord(SquareRect.lo.x, MidY), DocCoord(SquareRect.hi.x, MidY)); } else if (Constraint == CROSSCONSTRAINED_VERT) { INT32 MidX = (CrossRect.lo.x + CrossRect.hi.x) / 2; RenderConstraint(pRender, DocCoord(MidX, SquareRect.lo.y), DocCoord(MidX, SquareRect.hi.y)); } // And a cross on the Key slider too INT32 YTrans = (INT32) ((double)(VirtualSize->Height() - (PATCHSIZE + PixelSize*2)) * SourceColour.Key.MakeDouble()); CrossRect = DocRect(-CROSSRADIUS, -CROSSRADIUS, CROSSRADIUS, CROSSRADIUS); CrossRect.Translate(HalfGridLock(VirtualSize->hi.x - (CROSSRADIUS+PixelSize), PixelSize), HalfGridLock(VirtualSize->lo.y + YTrans, PixelSize)); BOOL Shaded = (EditingColour->GetType() == COLOURTYPE_TINT) || (EditingColour->InheritsComponent(4)); RenderCross(pRender, &CrossRect, PixelSize, Shaded); } pRender->RestoreContext(); }

void ColourEditDlg::RenderPickerDefault (  RenderRegion *  pRender, DocRect *  VirtualSize, INT32  PixelSize, DialogColourInfo *  RedrawColours )  [protected]

Redraws a colour picker control for the colour editor dialogue. This is used in the given display mode to display the colour information in a useful format. e.g. in HSV mode, a wheel and slider arrangement. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/94 Parameters: pRender  - The render region to render the picker in [INPUTS] VirtualSize - The rectangle defining the coordinate space to draw into PixelSize - The size of a pixel as mapped into the MILLIPOINT VirtualSize coordinate space; ensures things line up on display pixel boundaries. RedrawColours - A pointer to a DialogColourInfo object describing OS-friendly drawing colours to be used in redrawing the control. Notes: This is called as a default method for all colour models which are not specifically provided for by the editor. It shows generic horizontal sliders for each of the available colour components. Some colour models (e.g. Greyscale) will always use this default, as it is fine for them. See also: ColourEditDlg::RenderControl; ColourEditDlg::RenderPickerDefault Definition at line 6265 of file coldlog.cpp. { pRender->SaveContext(); // Save the current rendering context // Set rendering defaults: Fill paths only, and fill background with window grey DocColour Trans(COLOUR_TRANS); pRender->SetLineWidth(0); pRender->SetLineColour(Trans); // pRender->SetFillColour(RedrawColours->DialogBack()); // pRender->DrawRect(VirtualSize); ColourGeneric GradFillDef; // Colour for slider gradfill endpoint GradFillDef.Component1 = // Initialise to all components = 0 GradFillDef.Component2 = GradFillDef.Component3 = GradFillDef.Component4 = 0; ColourGeneric EditingColDef; // Colour holding the current component values EditingColDef.Component1 = // Default to all comps=0 in case of error EditingColDef.Component2 = // (and in case EditingCOlour == NULL) EditingColDef.Component3 = EditingColDef.Component4 = 0; // ColourContext *cc = ColourContext::GetGlobalDefault(DisplayModel); ColourContext *cc = NULL; BOOL bDeleteCC = GetColourContext(DisplayModel, &cc); if (cc == NULL) { pRender->RestoreContext(); ERROR2RAW("Can't get a colour context for the DisplayModel!"); return; } // Convert the editing colour (if any) into the current display model if (EditingColour != NULL) cc->ConvertColour(EditingColour, &EditingColDef); // Get a sneaky 'array of 4 components' to allow array-access into the colour definition ColourValue *ECComponent = (ColourValue *) &EditingColDef; // EC = EditingColour ColourValue *GFComponent = (ColourValue *) &GradFillDef; // GF = GradFill Colour // Create a colour in the current DisplayModel with all components zero (probably // black (RGB/Grey) or white (CMYK)) DocColour LeftColour(DisplayModel, &GradFillDef); DocColour TopLeftColour(DisplayModel, &GradFillDef); DocColour RightColour; DocColour TopRightColour; // Get the slider rectangle widths. The height is fixed/moved during the loop below DocRect SliderRect(*VirtualSize); SliderRect.hi.y -= PATCHSIZE + (PixelSize * 2); // Allow space for the current colour patch // Count how many components we have to display INT32 NumComponents = 0; INT32 ComponentIndex; for (ComponentIndex = 1; ComponentIndex <= 4; ComponentIndex++) { if (cc->GetComponentName(ComponentIndex, NULL)) NumComponents++; } // Calculate slider sizes and spacing INT32 SliderHeight = GetSliderHeight(SliderRect.Height(), NumComponents); INT32 SliderGap = GetSliderGap(SliderRect.Height(), NumComponents); // And move the top down by half a SliderGap, so the sliders are centered vertically SliderRect.hi.y -= SliderGap / 2; // Draw a slider for each component supplied in the current DisplayModel for (ComponentIndex = 0; ComponentIndex <= 3; ComponentIndex++) { // Ensure slider rect is the correct height SliderRect.lo.y = SliderRect.hi.y - SliderHeight; // If this component is available/used in this colour model, render it if (cc->GetComponentName(ComponentIndex+1, NULL)) { // TopLeft colour is static (always all zeros) // We calculate the other 3 colours here: // TopRight is all zeros except this component is 1.0 // Left/Right go from EditingColour with this component = 0.0 to this = 1.0 GradFillDef.Component1 = // Initialise to all components = 0 GradFillDef.Component2 = GradFillDef.Component3 = GradFillDef.Component4 = 0; GFComponent[ComponentIndex] = FIXED24(1.0); TopRightColour = DocColour(DisplayModel, &GradFillDef); // Make the slider use the colour definition with this component from 0 to 1 // (e.g. a red will give a green slider which shades from red to yellow) memcpy(&GradFillDef, &EditingColDef, sizeof(ColourGeneric)); GFComponent[ComponentIndex] = FIXED24(0.0); LeftColour = DocColour(DisplayModel, &GradFillDef); GFComponent[ComponentIndex] = FIXED24(1.0); RightColour = DocColour(DisplayModel, &GradFillDef); BOOL Shaded = EditingColour == NULL || ((EditingColour->GetType() == COLOURTYPE_TINT) || EditingColour->InheritsComponent(ComponentIndex+1)); // Render the slider if (SplitLineDisplay && NumComponents > 1) { // We want a split display for each line, with a gradfill showing // only this component (on top), and a gradfill showing the range of // colours you can get by changing only this component (below). RenderPickerSliderH(pRender, &SliderRect, PixelSize, ECComponent[ComponentIndex], &LeftColour, &RightColour, &TopLeftColour, &TopRightColour, Shaded); } else { // We want a non-split display. This redraws faster, as it only shows // the grad fill for this component. If there is only one colour component // (e.g. Greyscale) then the split display will look identical, so we // use the faster redraw method. RenderPickerSliderH(pRender, &SliderRect, PixelSize, ECComponent[ComponentIndex], NULL, NULL, &TopLeftColour, &TopRightColour, Shaded); } } // Move down to the next slider rectangle position SliderRect.hi.y = SliderRect.lo.y - SliderGap; } // Finally, return the render region context to its original state pRender->RestoreContext(); // Delete the colour context if necessary if (bDeleteCC) { ColourContextList::GetList()->RemoveContext(&cc); // Have finished with it } }

void ColourEditDlg::RenderPickerHSV (  RenderRegion *  pRender, DocRect *  VirtualSize, INT32  PixelSize, DialogColourInfo *  RedrawColours, DocRect *  pClipRect )  [protected]

Redraws a colour picker control for the colour editor dialogue. This is used in the given display mode to display the colour information in a useful format. e.g. in HSV mode, a wheel and slider arrangement. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/94 Parameters: pRender  - The render region to render the picker in [INPUTS] VirtualSize - The rectangle defining the coordinate space to draw into PixelSize - The size of a pixel as mapped into the MILLIPOINT VirtualSize coordinate space; ensures things line up on display pixel boundaries. RedrawColours - A pointer to a DialogColourInfo object describing OS-friendly drawing colours to be used in redrawing the control. pClipRect - The area to be redrawn, in (0,0)->(dx,dy) dialog millipoint coords See also: ColourEditDlg::RenderControl; ColourEditDlg::RenderPickerDefault Definition at line 4421 of file coldlog.cpp. { pRender->SaveContext(); // Save the current rendering context // Set defaults: Fill paths only, and fill background with window grey DocColour Trans(COLOUR_TRANS); pRender->SetLineWidth(0); pRender->SetLineColour(Trans); // pRender->SetFillColour(RedrawColours->DialogBack()); // pRender->DrawRect(VirtualSize); // First, do a Hue slider (a rainbow grad filled rectangle along the bottom) DocRect HueRect; DocRect ValSatSquare; CalculateHSVPickerRects(VirtualSize, PixelSize, &HueRect, &ValSatSquare); // Draw the Saturation vs. Value square Path SquarePath; LinearFillAttribute ValueGradFill; LinearTranspFillAttribute TransFill; ColourHSVT ColourDef; if (EditingColour != NULL) { BaseDocument *ScopeDocument = ParentList->GetParentDocument(); ColourContextArray *Contexts = ScopeDocument->GetDefaultColourContexts(); ERROR3IF(Contexts == NULL, "Document default contexts not defined?!"); ColourContextHSVT *ccHSV = (ColourContextHSVT *) Contexts->Context[COLOURMODEL_HSVT]; ERROR3IF(ccHSV == NULL, "Document default context for HSV not defined?!"); ccHSV->ConvertColour(EditingColour, (ColourGeneric *) &ColourDef); } else { // No colour - default to white ColourDef.Hue = 0; ColourDef.Saturation = ColourDef.Value = FIXED24(1.0); } if (pClipRect->IsIntersectedWith(ValSatSquare)) // If we need to redraw this bit... { // Copy the colour def, and force it's Value & Sat components to 1.0 ColourHSVT TempColourDef; TempColourDef.Hue = ColourDef.Hue; TempColourDef.Value = TempColourDef.Saturation = FIXED24(1.0); pRender->SaveContext(); ValueGradFill.Colour = DOCCOLOUR_HSVT(&TempColourDef); ValueGradFill.EndColour = DocColour(255L, 255L, 255L); DocCoord ThePoint; ThePoint = DocCoord(ValSatSquare.lo.x, ValSatSquare.hi.y); ValueGradFill.SetStartPoint(&ThePoint); ThePoint = DocCoord(ValSatSquare.hi.x, ValSatSquare.hi.y); ValueGradFill.SetEndPoint(&ThePoint); ValueGradFill.SetEndPoint2(NULL); pRender->SetFillGeometry(&ValueGradFill, FALSE); // Set Grad-filled SquarePath.Initialise(12, 12); SquarePath.FindStartOfPath(); SquarePath.InsertMoveTo(ValSatSquare.lo); SquarePath.InsertLineTo(DocCoord(ValSatSquare.hi.x, ValSatSquare.lo.y)); SquarePath.InsertLineTo(ValSatSquare.hi); SquarePath.InsertLineTo(DocCoord(ValSatSquare.lo.x, ValSatSquare.hi.y)); SquarePath.IsFilled = TRUE; pRender->DrawPath(&SquarePath); // Render the value square // Render a white linear-grad-transparency square over the top to get the // effect of the Saturation gradient DocColour black(0,0,0); pRender->SetFillColour(black); // Set transparency to circular 0% at center, 100% at radius, && plot it if (bHSVHueAtTop) { TransFill.SetStartPoint(&ValSatSquare.hi); ThePoint = DocCoord(ValSatSquare.hi.x, ValSatSquare.lo.y); TransFill.SetEndPoint(&ThePoint); TransFill.SetEndPoint2(NULL); } else { TransFill.SetStartPoint(&ValSatSquare.lo); ThePoint = DocCoord(ValSatSquare.lo.x, ValSatSquare.hi.y); TransFill.SetEndPoint(&ThePoint); TransFill.SetEndPoint2(NULL); } TransFill.Transp = 255; TransFill.EndTransp = 0; TransFill.TranspType = TT_StainGlass; // 'Stained glass' transparency pRender->SetTranspFillGeometry(&TransFill, FALSE); pRender->DrawPath(&SquarePath); // Render the saturation square pRender->RestoreContext(); } // (Declare variables now to stop render region going tits up) Path HuePath; FillEffectAltRainbowAttribute AltRainbow; LinearFillAttribute HueGradFill; if (pClipRect->IsIntersectedWith(HueRect)) // If we need to redraw this bit... { pRender->SaveContext(); HueGradFill.Colour = DocColour(255L, 0L, 0L); // Red to Red, alt-rainbow HueGradFill.EndColour = DocColour(255L, 0L, 0L); HueGradFill.SetStartPoint(&HueRect.hi); DocCoord ThePoint(HueRect.lo.x, HueRect.hi.y); HueGradFill.SetEndPoint(&ThePoint); HueGradFill.SetEndPoint2(NULL); pRender->SetFillGeometry(&HueGradFill, FALSE); // Set Grad-filled pRender->SetFillEffect(&AltRainbow, FALSE); // Set alt-rainbow fill // Draw the rectangle - done as a path so we can draw with grad-fill HuePath.Initialise(12, 12); HuePath.FindStartOfPath(); HuePath.InsertMoveTo(HueRect.lo); HuePath.InsertLineTo(DocCoord(HueRect.hi.x, HueRect.lo.y)); HuePath.InsertLineTo(HueRect.hi); HuePath.InsertLineTo(DocCoord(HueRect.lo.x, HueRect.hi.y)); HuePath.IsFilled = TRUE; pRender->DrawPath(&HuePath); // Render the hue strip pRender->RestoreContext(); } if (EditingColour != NULL) { // Render marker crosses in the appropriate places for the definition // of the current editing colour - First, the Hue cross DocRect CrossRect(-CROSSRADIUS, -CROSSRADIUS, CROSSRADIUS, CROSSRADIUS); INT32 TransX = (INT32) ((double) HueRect.Width() * ColourDef.Hue.MakeDouble()); CrossRect.Translate(HalfGridLock(HueRect.lo.x + TransX, PixelSize), HalfGridLock((HueRect.lo.y + HueRect.hi.y) / 2, PixelSize)); BOOL CrossShaded = (EditingColour->GetType() == COLOURTYPE_TINT) || (EditingColour->GetType() == COLOURTYPE_LINKED && EditingColour->InheritsComponent(1)); RenderCross(pRender, &CrossRect, PixelSize, CrossShaded); // And the Sat/Val cross CrossRect = DocRect(-CROSSRADIUS, -CROSSRADIUS, CROSSRADIUS, CROSSRADIUS); TransX = ValSatSquare.hi.x - (INT32) ((double)ValSatSquare.Width() * ColourDef.Saturation.MakeDouble()); INT32 TransY; if (bHSVHueAtTop) { TransY = ValSatSquare.lo.y + (INT32) ((double)ValSatSquare.Height() * ColourDef.Value.MakeDouble()); } else { TransY = ValSatSquare.hi.y - (INT32) ((double)ValSatSquare.Height() * ColourDef.Value.MakeDouble()); } CrossRect.Translate(HalfGridLock(TransX, PixelSize), HalfGridLock(TransY, PixelSize)); CrossShaded = (EditingColour->GetType() == COLOURTYPE_TINT) || (EditingColour->GetType() == COLOURTYPE_LINKED && EditingColour->InheritsComponent(2) && EditingColour->InheritsComponent(3)); RenderCross(pRender, &CrossRect, PixelSize, CrossShaded); if (!CrossShaded && EditingColour->GetType() == COLOURTYPE_LINKED) { if (EditingColour->InheritsComponent(2)) { // Saturation is locked, so constrain to Value axis RenderConstraint(pRender, DocCoord(TransX, ValSatSquare.hi.y), DocCoord(TransX, ValSatSquare.lo.y)); } else if (EditingColour->InheritsComponent(3)) { // Value is locked, so constrain to Saturation axis RenderConstraint(pRender, DocCoord(ValSatSquare.lo.x, TransY), DocCoord(ValSatSquare.hi.x, TransY)); } } } return; #if FALSE // Replacement code (developmental) to do a 3-d HSV colour cone display // Diameter is the width of the gadget - the value rectangle - a gap const INT32 MaxDiameter = (VirtualSize->Height() * 100) / 128; const INT32 MaxRadius = HalfGridLock(MaxDiameter/2, PixelSize); const INT32 TopMidY = HalfGridLock(VirtualSize->hi.y - MaxRadius, PixelSize); const INT32 TopMidX = HalfGridLock(VirtualSize->hi.x - MaxRadius, PixelSize); // The tip of the cone is 45 degrees down & to the left of the center. // It occurs just far enough away from the edge of the gadget to accomodate a Z Slider box const INT32 TipY = VirtualSize->lo.y + ZSLIDERSIZE; const INT32 TipX = TopMidX - (TopMidY - TipY); // Get the colour we want to display as an HSV colour definition ColourHSVT ColourDef; ColourHSVT TempColourDef; if (EditingColour != NULL) { BaseDocument *ScopeDocument = ParentList->GetParentDocument(); ColourContextArray *Contexts = ScopeDocument->GetDefaultColourContexts(); ERROR3IF(Contexts == NULL, "Document default contexts not defined?!"); ColourContextHSVT *ccHSV = (ColourContextHSVT *) Contexts->Context[COLOURMODEL_HSVT]; ERROR3IF(ccHSV == NULL, "Document default context for HSV not defined?!"); ccHSV->ConvertColour(EditingColour, (ColourGeneric *) &ColourDef); // --- Draw the value slider rectangle // Create a colour from this, but with Value = 1.0 memcpy(&TempColourDef, &ColourDef, sizeof(ColourHSVT)); } else TempColourDef.Value = FIXED24(1.0); const INT32 Diameter = (const INT32) ((double) MaxDiameter * TempColourDef.Value.MakeDouble()); const INT32 Radius = HalfGridLock(Diameter/2, PixelSize); INT32 Offset = (const INT32) ( ((double) (TopMidY - TipY)) * (1.0 - TempColourDef.Value.MakeDouble()) ); const INT32 MidY = HalfGridLock(TopMidY - Offset, PixelSize); const INT32 MidX = HalfGridLock(TopMidX - Offset, PixelSize); // --- Draw the HSV colour wheel - two semicircles with conical rainbow // fills (this will be overlaid with a transparent-filled white // circle to get the final colour wheel image) // The entire HSV picker is now drawn on top of a '3d cone shadow' display // Draw the cone 'shadow' (A triangle with a circle over one end) Path ShadowT; ShadowT.Initialise(12, 12); ShadowT.InsertMoveTo(DocCoord(TipX, TipY)); Offset = (INT32) (0.866025403 * (double)MaxRadius); // MaxRadius * sin(60) INT32 Offset2 = (INT32) (0.50 * (double)MaxRadius); // MaxRadius * cos(60) ShadowT.InsertLineTo(DocCoord(TopMidX-Offset, TopMidY+Offset2)); ShadowT.InsertLineTo(DocCoord(TopMidX+Offset2, TopMidY-Offset)); ShadowT.InsertLineTo(DocCoord(TipX, TipY)); ShadowT.IsFilled = TRUE; DocColour ShadowTFill(176L, 176L, 176L); pRender->SetFillColour(ShadowTFill); pRender->DrawPath(&ShadowT); // CPDist = the distance of the bezier control points from the line // endpoints to give us a circle const INT32 TopCPDist = (const INT32) ( ((double)MaxRadius) * 0.552 ); Path ShadowC; ShadowC.Initialise(12, 12); ShadowC.FindStartOfPath(); ShadowC.InsertMoveTo(DocCoord(TopMidX+MaxRadius, TopMidY)); ShadowC.InsertCurveTo(DocCoord(TopMidX+MaxRadius, TopMidY+TopCPDist), DocCoord(TopMidX+TopCPDist, TopMidY+MaxRadius), DocCoord(TopMidX, TopMidY+MaxRadius)); ShadowC.InsertCurveTo(DocCoord(TopMidX-TopCPDist, TopMidY+MaxRadius), DocCoord(TopMidX-MaxRadius, TopMidY+TopCPDist), DocCoord(TopMidX-MaxRadius, TopMidY)); ShadowC.InsertCurveTo(DocCoord(TopMidX-MaxRadius, TopMidY-TopCPDist), DocCoord(TopMidX-TopCPDist, TopMidY-MaxRadius), DocCoord(TopMidX, TopMidY-MaxRadius)); ShadowC.InsertCurveTo(DocCoord(TopMidX+TopCPDist, TopMidY-MaxRadius), DocCoord(TopMidX+MaxRadius, TopMidY-TopCPDist), DocCoord(TopMidX+MaxRadius, TopMidY)); ShadowC.IsFilled = TRUE; DocColour ShadowCFill(168L, 168L, 168L); pRender->SetFillColour(ShadowCFill); pRender->DrawPath(&ShadowC); // CPDist = the distance of the bezier control points from the line // endpoints to give us a circle const INT32 CPDist = (const INT32) ( ((double)Radius) * 0.552 ); // Generate the fill attribute for the HSV rainbow fill ConicalFillAttribute Conical; Conical.SetStartPoint(DocCoord(MidX, MidY)); Conical.SetEndPoint(DocCoord(MidX-Radius, MidY)); Conical.SetEndPoint2(NULL); // Fill: conical, (alt)rainbow, Hue 0.25 to 0.75, Value == SourceColour Value TempColourDef.Hue = FIXED24(0.25); TempColourDef.Saturation = FIXED24(1.0); Conical.Colour = DOCCOLOUR_HSVT(&TempColourDef); TempColourDef.Hue = FIXED24(0.75); Conical.EndColour = DOCCOLOUR_HSVT(&TempColourDef); pRender->SetFillGeometry(&Conical, FALSE); // Build and draw the Top (CircleT) and Bottom (CircleB) Semicircles Path CircleT; CircleT.Initialise(12, 12); CircleT.FindStartOfPath(); CircleT.InsertMoveTo(DocCoord(MidX+Radius, MidY)); CircleT.InsertCurveTo(DocCoord(MidX+Radius, MidY+CPDist), DocCoord(MidX+CPDist, MidY+Radius), DocCoord(MidX, MidY+Radius)); CircleT.InsertCurveTo(DocCoord(MidX-CPDist, MidY+Radius), DocCoord(MidX-Radius, MidY+CPDist), DocCoord(MidX-Radius, MidY)); CircleT.InsertLineTo(DocCoord(MidX+Radius, MidY)); CircleT.IsFilled = TRUE; FillEffectAltRainbowAttribute AltRainbow; pRender->SetFillEffect(&AltRainbow, FALSE); // Set alt-rainbow fill pRender->DrawPath(&CircleT); // And draw topmost semicircle Path CircleB; CircleB.Initialise(12, 12); CircleB.FindStartOfPath(); CircleB.InsertMoveTo(DocCoord(MidX+Radius, MidY)); CircleB.InsertCurveTo(DocCoord(MidX+Radius, MidY-CPDist), DocCoord(MidX+CPDist, MidY-Radius), DocCoord(MidX, MidY-Radius)); CircleB.InsertCurveTo(DocCoord(MidX-CPDist, MidY-Radius), DocCoord(MidX-Radius, MidY-CPDist), DocCoord(MidX-Radius, MidY)); CircleB.InsertLineTo(DocCoord(MidX+Radius, MidY)); CircleB.IsFilled = TRUE; FillEffectRainbowAttribute Rainbow; pRender->SetFillEffect(&Rainbow, FALSE); // Set rainbow fill pRender->DrawPath(&CircleB); // And draw bottom semicircle pRender->RestoreContext(); // Get attrs back to normality! pRender->SaveContext(); // --- Finally, draw a (rectangle) over the colour wheel, filled with // a grey of the same intensity/Value as the source colour (e.g // if source Value == 1.0, then fill with white). This is overlaid // using a circular transparent fill which is 0% transparent in the // center (white) and 100% at the edge of the wheel (wheel-colour) Path TransPath; TransPath.Initialise(12, 12); TransPath.FindStartOfPath(); TransPath.InsertMoveTo(DocCoord(MidX-Radius, MidY-Radius)); TransPath.InsertLineTo(DocCoord(MidX-Radius, MidY+Radius)); TransPath.InsertLineTo(DocCoord(MidX+Radius, MidY+Radius)); TransPath.InsertLineTo(DocCoord(MidX+Radius, MidY-Radius)); TransPath.InsertLineTo(DocCoord(MidX-Radius, MidY-Radius)); TransPath.IsFilled = TRUE; // Render the transpath TempColourDef.Hue = 0; TempColourDef.Saturation = 0; TempColourDef.Value = (EditingColour == NULL) ? FIXED24(1.0) : ColourDef.Value; DocColour MaxWhiteness = DOCCOLOUR_HSVT(&TempColourDef); pRender->SetLineWidth(0); // Ensure fill-only pRender->SetLineColour(Trans); pRender->SetFillColour(MaxWhiteness); // Set transparency to circular 0% at center, 100% at radius, && plot it RadialTranspFillAttribute TransFill; TransFill.SetStartPoint(DocCoord(MidX, MidY)); TransFill.SetEndPoint(DocCoord(MidX, MidY+Radius)); TransFill.SetEndPoint2(DocCoord(MidX+Radius, MidY)); TransFill.Transp = 0; TransFill.EndTransp = 255; TransFill.TranspType = TT_Mix; // 'Mix' transparency pRender->SetTranspFillGeometry(&TransFill, FALSE); pRender->DrawPath(&TransPath); // Finally, render an outlined circle over the top, to give the 'jelly cone' appearance pRender->SetFillColour(Trans); pRender->SetLineColour(ShadowCFill); pRender->DrawPath(&ShadowC); pRender->RestoreContext(); // Restore original attribute context if (EditingColour != NULL) { // And draw a drag icon on the current Z position **** !!!! ToDo: Should be a bitmap icon DocRect ZButton(TipX-ZSLIDERSIZE+PixelSize, TipY-ZSLIDERSIZE+PixelSize, TipX-PixelSize, TipY-PixelSize); // The drag icon should touch the edge of the HSV circle (at 45 degrees) Offset = (INT32) (((double) (TopMidY - TipY) - (0.707106781 * (double) MaxRadius)) * TempColourDef.Value.MakeDouble()); ZButton.Translate(Offset, Offset); GridLockRect(&ZButton, PixelSize); DocColour MidGrey(128L, 128L, 128L); pRender->SetFillColour(MidGrey); pRender->DrawRect(&ZButton); // Render marker crosses in the appropriate places for the definition // of the current editing colour DocRect CrossRect(-CROSSRADIUS, -CROSSRADIUS, CROSSRADIUS, CROSSRADIUS); // Convert Hue (0.0 -> 1.0) into an angle in radians (0 -> 2Pi) const double theta = 2.0 * PI * ColourDef.Hue.MakeDouble(); // Convert Saturation into a distance from the center of the colour wheel const double length = (double)Radius * ColourDef.Saturation.MakeDouble(); // Translate the cross to the polar coordinate (theta, length) CrossRect.Translate(HalfGridLock(MidX + (INT32)(length * sin(theta)), PixelSize), HalfGridLock(MidY + (INT32)(length * cos(theta)), PixelSize)); RenderCross(pRender, &CrossRect, PixelSize); } //#else // Calculate where the colour wheel circle & brightness slider rect will go // Note that we always try for an even number of pixels wide, to ensure that // the marker cross appears exactly centered (rather than 1 pixel more space // on one side of it) DocRect ValueRect; ValueRect.hi.x = HalfGridLock(VirtualSize->hi.x, PixelSize); ValueRect.lo.x = HalfGridLock(ValueRect.hi.x - (VirtualSize->Width() / 8), PixelSize * 2); // Diameter is the width of the gadget - the value rectangle - a gap INT32 Diameter = VirtualSize->Width() - ValueRect.Width() - (ValueRect.Width() / 3); if (Diameter > VirtualSize->Height()) Diameter = VirtualSize->Height(); const INT32 Radius = HalfGridLock(Diameter/2, PixelSize); const INT32 MidY = HalfGridLock(VirtualSize->Height() / 2, PixelSize); const INT32 MidX = HalfGridLock(VirtualSize->lo.x + Radius, PixelSize); ValueRect.lo.y = MidY - Radius; // Rect only as high as the circle ValueRect.hi.y = MidY + Radius; // Get the colour we want to display as an HSV colour definition ColourHSVT ColourDef; ColourHSVT TempColourDef; if (EditingColour != NULL) { BaseDocument *ScopeDocument = ParentList->GetParentDocument(); ColourContextArray *Contexts = ScopeDocument->GetDefaultColourContexts(); ERROR3IF(Contexts == NULL, "Document default contexts not defined?!"); ColourContextHSVT *ccHSV = (ColourContextHSVT *) Contexts->Context[COLOURMODEL_HSVT]; ERROR3IF(ccHSV == NULL, "Document default context for HSV not defined?!"); ccHSV->ConvertColour(EditingColour, (ColourGeneric *) &ColourDef); // --- Draw the value slider rectangle // Create a colour from this, but with Value = 1.0 memcpy(&TempColourDef, &ColourDef, sizeof(ColourHSVT)); TempColourDef.Value = FIXED24(1.0); } // Create a grad fill from this colour (V=1.0) to black (V=0.0) // (Declare variables now to stop render region going tits up) LinearFillAttribute ValueGradFill; Path ValuePath; if (pClipRect->IsIntersectedWith(ValueRect)) { if (EditingColour != NULL) ValueGradFill.Colour = DOCCOLOUR_HSVT(&TempColourDef); else ValueGradFill.Colour = DocColour(255L, 255L, 255L); ValueGradFill.EndColour = DocColour(0L, 0L, 0L); ValueGradFill.SetStartPoint(DocCoord((ValueRect.lo.x + ValueRect.hi.x) / 2, ValueRect.hi.y)); ValueGradFill.SetEndPoint(DocCoord((ValueRect.lo.x + ValueRect.hi.x) / 2, ValueRect.lo.y)); ValueGradFill.SetEndPoint2(NULL); pRender->SetFillGeometry(&ValueGradFill, FALSE); // Draw the rectangle - done as a path so we can draw with grad-fill ValuePath.Initialise(12, 12); ValuePath.FindStartOfPath(); ValuePath.InsertMoveTo(ValueRect.lo); ValuePath.InsertLineTo(DocCoord(ValueRect.hi.x, ValueRect.lo.y)); ValuePath.InsertLineTo(ValueRect.hi); ValuePath.InsertLineTo(DocCoord(ValueRect.lo.x, ValueRect.hi.y)); ValuePath.IsFilled = TRUE; pRender->DrawPath(&ValuePath); // Render the value/brightness strip } // --- Draw the HSV colour wheel - two semicircles with conical rainbow // fills (this will be overlaid with a transparent-filled white // circle to get the final colour wheel image) // CPDist = the distance of the bezier control points from the line // endpoints to give us a circle const INT32 CPDist = (const INT32) ( ((double)Radius) * 0.552 ); // Generate the fill attribute for the HSV rainbow fill // Again, create all the objects at this scope level to keep render region alive ConicalFillAttribute Conical; FillEffectAltRainbowAttribute AltRainbow; Path CircleT; Path CircleB; Path TransPath; RadialTranspFillAttribute TransFill; DocRect WheelRect(MidX - Radius, MidY - Radius, MidX + Radius, MidY + Radius); if (pClipRect->IsIntersectedWith(WheelRect)) { Conical.SetStartPoint(DocCoord(MidX, MidY)); Conical.SetEndPoint(DocCoord(MidX-Radius, MidY)); Conical.SetEndPoint2(NULL); // Fill: conical, (alt)rainbow, Hue 0.25 to 0.75, Value == SourceColour Value TempColourDef.Hue = FIXED24(0.25); TempColourDef.Saturation = FIXED24(1.0); if (EditingColour != NULL) TempColourDef.Value = ColourDef.Value; else TempColourDef.Value = FIXED24(1.0); Conical.Colour = DOCCOLOUR_HSVT(&TempColourDef); TempColourDef.Hue = FIXED24(0.75); Conical.EndColour = DOCCOLOUR_HSVT(&TempColourDef); pRender->SetFillGeometry(&Conical, FALSE); // Build and draw the Top (CircleT) and Bottom (CircleB) Semicircles CircleT.Initialise(12, 12); CircleT.FindStartOfPath(); CircleT.InsertMoveTo(DocCoord(MidX+Radius, MidY)); CircleT.InsertCurveTo(DocCoord(MidX+Radius, MidY+CPDist), DocCoord(MidX+CPDist, MidY+Radius), DocCoord(MidX, MidY+Radius)); CircleT.InsertCurveTo(DocCoord(MidX-CPDist, MidY+Radius), DocCoord(MidX-Radius, MidY+CPDist), DocCoord(MidX-Radius, MidY)); CircleT.InsertLineTo(DocCoord(MidX+Radius, MidY)); CircleT.IsFilled = TRUE; pRender->SetFillEffect(&AltRainbow, FALSE); // Set alt-rainbow fill pRender->DrawPath(&CircleT); // And draw topmost semicircle CircleB.Initialise(12, 12); CircleB.FindStartOfPath(); CircleB.InsertMoveTo(DocCoord(MidX+Radius, MidY)); CircleB.InsertCurveTo(DocCoord(MidX+Radius, MidY-CPDist), DocCoord(MidX+CPDist, MidY-Radius), DocCoord(MidX, MidY-Radius)); CircleB.InsertCurveTo(DocCoord(MidX-CPDist, MidY-Radius), DocCoord(MidX-Radius, MidY-CPDist), DocCoord(MidX-Radius, MidY)); CircleB.InsertLineTo(DocCoord(MidX+Radius, MidY)); CircleB.IsFilled = TRUE; FillEffectRainbowAttribute Rainbow; pRender->SetFillEffect(&Rainbow, FALSE); // Set rainbow fill pRender->DrawPath(&CircleB); // And draw bottom semicircle pRender->RestoreContext(); // Get attrs back to normality! pRender->SaveContext(); // --- Finally, draw a (rectangle) over the colour wheel, filled with // a grey of the same intensity/Value as the source colour (e.g // if source Value == 1.0, then fill with white). This is overlaid // using a circular transparent fill which is 0% transparent in the // center (white) and 100% at the edge of the wheel (wheel-colour) TransPath.Initialise(12, 12); TransPath.FindStartOfPath(); TransPath.InsertMoveTo(DocCoord(MidX-Radius, MidY-Radius)); TransPath.InsertLineTo(DocCoord(MidX-Radius, MidY+Radius)); TransPath.InsertLineTo(DocCoord(MidX+Radius, MidY+Radius)); TransPath.InsertLineTo(DocCoord(MidX+Radius, MidY-Radius)); TransPath.InsertLineTo(DocCoord(MidX-Radius, MidY-Radius)); TransPath.IsFilled = TRUE; // Render the transpath TempColourDef.Hue = 0; TempColourDef.Saturation = 0; TempColourDef.Value = (EditingColour == NULL) ? FIXED24(1.0) : ColourDef.Value; DocColour MaxWhiteness = DOCCOLOUR_HSVT(&TempColourDef); pRender->SetLineWidth(0); // Ensure fill-only pRender->SetLineColour(Trans); pRender->SetFillColour(MaxWhiteness); // Set transparency to circular 0% at center, 100% at radius, && plot it TransFill.SetStartPoint(DocCoord(MidX, MidY)); TransFill.SetEndPoint(DocCoord(MidX, MidY+Radius)); TransFill.SetEndPoint2(DocCoord(MidX+Radius, MidY)); TransFill.Transp = 0; TransFill.EndTransp = 255; TransFill.TranspType = TT_Mix; // 'Mix' transparency pRender->SetTranspFillGeometry(&TransFill, FALSE); pRender->DrawPath(&TransPath); } pRender->RestoreContext(); // Restore original attribute context if (EditingColour != NULL) { // Render marker crosses in the appropriate places for the definition // of the current editing colour DocRect CrossRect(-CROSSRADIUS, -CROSSRADIUS, CROSSRADIUS, CROSSRADIUS); // Convert Hue (0.0 -> 1.0) into an angle in radians (0 -> 2Pi) const double theta = 2.0 * PI * ColourDef.Hue.MakeDouble(); // Convert Saturation into a distance from the center of the colour wheel const double length = (double)Radius * ColourDef.Saturation.MakeDouble(); // Translate the cross to the polar coordinate (theta, length) CrossRect.Translate(HalfGridLock(MidX + (INT32)(length * sin(theta)), PixelSize), HalfGridLock(MidY + (INT32)(length * cos(theta)), PixelSize)); RenderCross(pRender, &CrossRect, PixelSize); CrossRect = DocRect(-CROSSRADIUS, -CROSSRADIUS, CROSSRADIUS, CROSSRADIUS); INT32 TransX = (ValueRect.lo.x + ValueRect.hi.x) / 2; INT32 TransY = ValueRect.lo.y + (INT32) ((double)ValueRect.Height() * ColourDef.Value.MakeDouble()); CrossRect.Translate(HalfGridLock(TransX, PixelSize), HalfGridLock(TransY, PixelSize)); RenderCross(pRender, &CrossRect, PixelSize); } #endif }

void ColourEditDlg::RenderPickerRGB (  RenderRegion *  pRender, DocRect *  VirtualSize, INT32  PixelSize, DialogColourInfo *  RedrawColours )  [protected]

Redraws a colour picker control for the colour editor dialogue. This is used in the given display mode to display the colour information in a useful format. e.g. in HSV mode, a wheel and slider arrangement. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 23/12/94 Parameters: pRender  - The render region to render the picker in [INPUTS] VirtualSize - The rectangle defining the coordinate space to draw into PixelSize - The size of a pixel as mapped into the MILLIPOINT VirtualSize coordinate space; ensures things line up on display pixel boundaries. RedrawColours - A pointer to a DialogColourInfo object describing OS-friendly drawing colours to be used in redrawing the control. See also: ColourEditDlg::RenderControl; ColourEditDlg::RenderPickerDefault Definition at line 5472 of file coldlog.cpp. { pRender->SaveContext(); // Save the current rendering context DocColour Trans(COLOUR_TRANS); // First, set up the render region, and fill the background with Dialogue BG colour pRender->SetLineWidth(0); pRender->SetLineColour(Trans); // pRender->SetFillColour(RedrawColours->DialogBack()); // pRender->DrawRect(VirtualSize); // Draw the cube 'shadow', and calculate where the cube sits DocRect SquareRect; INT32 SizeZ; DrawCubeShadowAndCalcValues(pRender, VirtualSize, PixelSize, RedrawColours, /* TO */ &SquareRect, &SizeZ); DocRect FrontFaceRect(SquareRect); // Remember the old squarerect for later #if FALSE /* Old code. Works fine normally, but due to using bleach trnsparency, fails to work properly in "show printer colours" preview mode. Also, the new 4-colour fill method below is faster, as it only does one path fill rather than 3 (plus transparency) // Find the source colour definition in RGB space ColourRGBT SourceColour; if (EditingColour != NULL) { ColourContextRGBT *ccRGB = (ColourContextRGBT *) ColourContext::GetGlobalDefault(COLOURMODEL_RGBT); ERROR3IF(ccRGB == NULL, "Can't get an RGB colour context"); ccRGB->ConvertColour(EditingColour, (ColourGeneric *) &SourceColour); } else { SourceColour.Red =SourceColour.Green = SourceColour.Blue = FIXED24(1.0); SourceColour.Transparent = 0; } // Now, Move the 'SquareRect' down and right so its bottom corner touches the Z axis // at the appropriate point for the current Z value. (i.e. slice the cube through at // the place where the slice really is) if (EditingColour != NULL) { FIXED24 ZComponent = SourceColour.Blue; if (ColourPickerMode == 1) ZComponent = SourceColour.Green; else if (ColourPickerMode == 2) ZComponent = SourceColour.Red; INT32 ZTrans = (INT32) ((double)SizeZ * ZComponent.MakeDouble()) - SizeZ; SquareRect.Translate(-ZTrans, ZTrans); GridLockRect(&SquareRect, PixelSize); } // Now, composite up the picker square, which is made of 3 squares on top of each // other, all flat-filled in primary colours, the top 2 having horz/vert trans fills ColourRGBT BaseColour; ColourRGBT MidColour; ColourRGBT TopColour; BaseColour.Red = BaseColour.Green = BaseColour.Blue = BaseColour.Transparent = 0; memcpy(&MidColour, &BaseColour, sizeof(ColourRGBT)); memcpy(&TopColour, &BaseColour, sizeof(ColourRGBT)); switch(ColourPickerMode) { case 1: // XYZ = R,B,G MidColour.Red = FIXED24(1.0); TopColour.Blue = FIXED24(1.0); BaseColour.Green = SourceColour.Green; break; case 2: // XYZ = B,G,R MidColour.Blue = FIXED24(1.0); TopColour.Green = FIXED24(1.0); BaseColour.Red = SourceColour.Red; break; default: // XYZ = G,R,B MidColour.Green = FIXED24(1.0); TopColour.Red = FIXED24(1.0); BaseColour.Blue = SourceColour.Blue; ColourPickerMode = 0; // Ensure any out of value setting is made valid break; } RenderPickerSquare(pRender, &SquareRect, (ColourGeneric *) &BaseColour, (ColourGeneric *) &MidColour, (ColourGeneric *) &TopColour, COLOURMODEL_RGBT, 3); // Use RGB + 'bleach' (additive) transparency */ #else // Find the source colour definition in RGB space PColourRGBT SourceColour; if (EditingColour != NULL) { ColourContextRGBT *ccRGB = (ColourContextRGBT *) ColourContext::GetGlobalDefault(COLOURMODEL_RGBT); ERROR3IF(ccRGB == NULL, "Can't get an RGB colour context"); DocColour TempRef; TempRef.MakeRefToIndexedColour(EditingColour); ccRGB->ConvertColour(&TempRef, (ColourPacked *) &SourceColour); } else { SourceColour.Red =SourceColour.Green = SourceColour.Blue = 255; SourceColour.Transparent = 0; } // Now, Move the 'SquareRect' down and right so its bottom corner touches the Z axis // at the appropriate point for the current Z value. (i.e. slice the cube through at // the place where the slice really is) if (EditingColour != NULL) { INT32 ZComponent = SourceColour.Blue; if (ColourPickerMode == 1) ZComponent = SourceColour.Green; else if (ColourPickerMode == 2) ZComponent = SourceColour.Red; INT32 ZTrans = (INT32) (((double)SizeZ * ZComponent) / 255.0) - SizeZ; SquareRect.Translate(-ZTrans, ZTrans); GridLockRect(&SquareRect, PixelSize); } // Draw a 4-colour fill for the cube face FourColFillAttribute Fill; // Set the points to be in the corners of the square rect Fill.SetStartPoint(&SquareRect.lo); // Bottom left DocCoord Corner = DocCoord(SquareRect.hi.x, SquareRect.lo.y); Fill.SetEndPoint(&Corner); // Bottom right Corner = DocCoord(SquareRect.lo.x, SquareRect.hi.y); Fill.SetEndPoint2(&Corner); // Top left Fill.SetEndPoint3(&SquareRect.hi); // Top right // And set the corner colours DocColour CornerCol; switch(ColourPickerMode) { case 1: // XYZ = R,B,G CornerCol = DocColour(0L, SourceColour.Green, 0L); // Bottom left Fill.SetStartColour(&CornerCol); CornerCol = DocColour(255L, SourceColour.Green, 0L); // Bottom right Fill.SetEndColour(&CornerCol); CornerCol = DocColour(0L, SourceColour.Green, 255L); // Top left Fill.SetEndColour2(&CornerCol); CornerCol = DocColour(255L, SourceColour.Green, 255L); // Top right Fill.SetEndColour3(&CornerCol); break; case 2: // XYZ = B,G,R CornerCol = DocColour(SourceColour.Red, 0L, 0L); // Bottom left Fill.SetStartColour(&CornerCol); CornerCol = DocColour(SourceColour.Red, 0L, 255L); // Bottom right Fill.SetEndColour(&CornerCol); CornerCol = DocColour(SourceColour.Red, 255L, 0L); // Top left Fill.SetEndColour2(&CornerCol); CornerCol = DocColour(SourceColour.Red, 255L, 255L); // Top right Fill.SetEndColour3(&CornerCol); break; default: // XYZ = G,R,B CornerCol = DocColour(0L, 0L, SourceColour.Blue); // Bottom left Fill.SetStartColour(&CornerCol); CornerCol = DocColour(0L, 255L, SourceColour.Blue); // Bottom right Fill.SetEndColour(&CornerCol); CornerCol = DocColour(255L, 0L, SourceColour.Blue); // Top left Fill.SetEndColour2(&CornerCol); CornerCol = DocColour(255L, 255L, SourceColour.Blue); // Top right Fill.SetEndColour3(&CornerCol); break; } // Build a path for the rectangle (DrawRect doesn't do grad fills) Path SquarePath; SquarePath.Initialise(12, 12); SquarePath.FindStartOfPath(); SquarePath.InsertMoveTo(SquareRect.lo); SquarePath.InsertLineTo(DocCoord(SquareRect.lo.x, SquareRect.hi.y)); SquarePath.InsertLineTo(SquareRect.hi); SquarePath.InsertLineTo(DocCoord(SquareRect.hi.x, SquareRect.lo.y)); SquarePath.IsFilled = TRUE; pRender->SetLineColour(Trans); pRender->SetFillGeometry(&Fill, FALSE); // And render it pRender->DrawPath(&SquarePath); #endif // Place the outline of the front of the cube on top DocColour CubeFaceGrey(180L, 180L, 180L); pRender->SetLineColour(CubeFaceGrey); pRender->SetFillColour(Trans); DocCoord BotRightFront(FrontFaceRect.hi.x, FrontFaceRect.lo.y); pRender->DrawLine(BotRightFront, FrontFaceRect.lo); pRender->DrawLine(BotRightFront, FrontFaceRect.hi); pRender->DrawLine(BotRightFront, DocCoord(FrontFaceRect.hi.x + SizeZ, FrontFaceRect.lo.y - SizeZ)); // Draw the swap-axes button DocCoord BitmapPos; BitmapPos.x = HalfGridLock(FrontFaceRect.hi.x + SizeZ/2, PixelSize); BitmapPos.y = HalfGridLock(FrontFaceRect.hi.y - SizeZ/2, PixelSize); const INT32 BitmapSize = 14 * PixelSize; DocRect SwapAxesStrip(BitmapPos.x + BitmapSize, BitmapPos.y, BitmapPos.x + BitmapSize + PixelSize * 3, BitmapPos.y + BitmapSize); GridLockRect(&SwapAxesStrip, PixelSize); DocColour SwapAxesFore(0L, 0L, 0L); DocColour SwapAxesFill(0L, 0L, 255L); if (ColourPickerMode == 1) SwapAxesFill = DocColour(0L, 255L, 0L); else if (ColourPickerMode == 2) SwapAxesFill = DocColour(255L, 0L, 0L); pRender->SetFillColour(SwapAxesFill); pRender->SetLineColour(SwapAxesFore); pRender->DrawRect(&SwapAxesStrip); // Render the bitmap last, to ensure we don't overwrite it pRender->DrawBitmap(BitmapPos, _R(IDB_PICKER_SWAPAXIS)); DocColour MidGrey(128L, 128L, 128L); if (EditingColour != NULL) { // And draw a drag icon on the current Z position DocRect ZButton(SquareRect); ZButton.lo.x = ZButton.hi.x; ZButton.hi.x += ZSLIDERSIZE - (PixelSize * 2); ZButton.hi.y = ZButton.lo.y; ZButton.lo.y -= ZSLIDERSIZE - (PixelSize * 2); GridLockRect(&ZButton, PixelSize); pRender->DrawBitmap(ZButton.lo, _R(IDB_PICKER_ZSLIDER)); DocRect CrossRect; ColourRGBT SourceDef; if (EditingColour != NULL) { ColourContextRGBT *ccRGB = (ColourContextRGBT *) ColourContext::GetGlobalDefault(COLOURMODEL_RGBT); ERROR3IF(ccRGB == NULL, "Can't get an RGB colour context"); ccRGB->ConvertColour(EditingColour, (ColourGeneric *) &SourceDef); } else { SourceDef.Red =SourceDef.Green = SourceDef.Blue = FIXED24(1.0); SourceDef.Transparent = 0; } CrossConstraint Constraint = CalcCrossRectRGB(&SourceDef, &SquareRect, PixelSize, &CrossRect); RenderCross(pRender, &CrossRect, PixelSize, (Constraint == CROSSCONSTRAINED_BOTH)); if (Constraint == CROSSCONSTRAINED_HORZ) { INT32 MidY = (CrossRect.lo.y + CrossRect.hi.y) / 2; RenderConstraint(pRender, DocCoord(SquareRect.lo.x, MidY), DocCoord(SquareRect.hi.x, MidY)); } else if (Constraint == CROSSCONSTRAINED_VERT) { INT32 MidX = (CrossRect.lo.x + CrossRect.hi.x) / 2; RenderConstraint(pRender, DocCoord(MidX, SquareRect.lo.y), DocCoord(MidX, SquareRect.hi.y)); } } pRender->RestoreContext(); }

void ColourEditDlg::RenderPickerShade (  RenderRegion *  pRender, DocRect *  VirtualSize, INT32  PixelSize, DialogColourInfo *  RedrawColours, DocRect *  pClipRect )  [protected]

Redraws a colour picker control for the colour editor dialogue. This is used in the given display mode to display the colour information in a useful format. e.g. in HSV mode, a wheel and slider arrangement. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/95 Parameters: pRender  - The render region to render the picker in [INPUTS] VirtualSize - The rectangle defining the coordinate space to draw into PixelSize - The size of a pixel as mapped into the MILLIPOINT VirtualSize coordinate space; ensures things line up on display pixel boundaries. RedrawColours - A pointer to a DialogColourInfo object describing OS-friendly drawing colours to be used in redrawing the control. pClipRect - The area to be redrawn, in (0,0)->(dx,dy) dialog millipoint coords See also: ColourEditDlg::RenderControl; ColourEditDlg::RenderPickerDefault Definition at line 6521 of file coldlog.cpp. { pRender->SaveContext(); // Save the current rendering context // Set defaults: Fill paths only, and fill background with window grey DocColour Trans(COLOUR_TRANS); pRender->SetLineWidth(0); pRender->SetLineColour(Trans); // First, do a Hue slider (a rainbow grad filled rectangle along the bottom) DocRect HueRect; DocRect ValSatSquare; CalculateHSVPickerRects(VirtualSize, PixelSize, &HueRect, &ValSatSquare); // Draw the Saturation vs. Value square Path SquarePath; LinearFillAttribute ValueGradFill; LinearTranspFillAttribute TransFill; ColourHSVT ColourDef; BaseDocument *ScopeDocument = ParentList->GetParentDocument(); ColourContextArray *Contexts = ScopeDocument->GetDefaultColourContexts(); ERROR3IF(Contexts == NULL, "Document default contexts not defined?!"); ColourContextHSVT *ccHSV = (ColourContextHSVT *) Contexts->Context[COLOURMODEL_HSVT]; ERROR3IF(ccHSV == NULL, "Document default context for HSV not defined?!"); // We need to use the PARENT's Hue as a basis for our shade display, because otherwise // as we change the child colour to a greyscale/black, it loses its Hue and the picker // flashes different colours. We also use this definition below to show the parent "cross" ColourHSVT ParentDef; ParentDef.Hue = 0; ParentDef.Saturation = ParentDef.Value = FIXED24(1.0); if (EditingColour != NULL) { ccHSV->ConvertColour(EditingColour, (ColourGeneric *) &ColourDef); if (EditingColour->FindLastLinkedParent() != NULL) ccHSV->ConvertColour(EditingColour->FindLastLinkedParent(), (ColourGeneric *) &ParentDef); } else { // No colour - default to white ColourDef.Hue = 0; ColourDef.Saturation = ColourDef.Value = FIXED24(1.0); } if (pClipRect->IsIntersectedWith(ValSatSquare)) // If we need to redraw this bit... { // Copy the colour def, and force it's Value & Sat components to 1.0 ColourHSVT TempColourDef; TempColourDef.Hue = ParentDef.Hue; TempColourDef.Value = TempColourDef.Saturation = FIXED24(1.0); pRender->SaveContext(); ValueGradFill.Colour = DOCCOLOUR_HSVT(&TempColourDef); ValueGradFill.EndColour = DocColour(255L, 255L, 255L); DocCoord ThePoint(ValSatSquare.lo.x, ValSatSquare.hi.y); ValueGradFill.SetStartPoint(&ThePoint); ThePoint = DocCoord(ValSatSquare.hi.x, ValSatSquare.hi.y); ValueGradFill.SetEndPoint(&ThePoint); ValueGradFill.SetEndPoint2(NULL); pRender->SetFillGeometry(&ValueGradFill, FALSE); // Set Grad-filled SquarePath.Initialise(12, 12); SquarePath.FindStartOfPath(); SquarePath.InsertMoveTo(ValSatSquare.lo); SquarePath.InsertLineTo(DocCoord(ValSatSquare.hi.x, ValSatSquare.lo.y)); SquarePath.InsertLineTo(ValSatSquare.hi); SquarePath.InsertLineTo(DocCoord(ValSatSquare.lo.x, ValSatSquare.hi.y)); SquarePath.IsFilled = TRUE; pRender->DrawPath(&SquarePath); // Render the value square // Render a white linear-grad-transparency square over the top to get the // effect of the Saturation gradient DocColour black(0,0,0); pRender->SetFillColour(black); // Set transparency to circular 0% at center, 100% at radius, && plot it TransFill.SetStartPoint(&ValSatSquare.hi); ThePoint = DocCoord(ValSatSquare.hi.x, ValSatSquare.lo.y); TransFill.SetEndPoint(&ThePoint); TransFill.SetEndPoint2(NULL); TransFill.Transp = 255; TransFill.EndTransp = 0; TransFill.TranspType = TT_StainGlass; // 'Stained glass' transparency pRender->SetTranspFillGeometry(&TransFill, FALSE); pRender->DrawPath(&SquarePath); // Render the saturation square pRender->RestoreContext(); } if (EditingColour != NULL) { // Render a parent colour marker to remind the user where the parent definition is DocRect CrossRect = DocRect(-PCROSSRADIUS, -PCROSSRADIUS, PCROSSRADIUS, PCROSSRADIUS); INT32 TransX = ValSatSquare.hi.x - (INT32) ((double)ValSatSquare.Width() * ParentDef.Saturation.MakeDouble()); INT32 TransY = ValSatSquare.lo.y + (INT32) ((double)ValSatSquare.Height() * ParentDef.Value.MakeDouble()); CrossRect.Translate(HalfGridLock(TransX, PixelSize), HalfGridLock(TransY, PixelSize)); RenderParentCross(pRender, &CrossRect, PixelSize); // Render marker crosses in the appropriate places for the definition // of the current editing colour - the shade Sat/Val crosses CrossRect = DocRect(-CROSSRADIUS, -CROSSRADIUS, CROSSRADIUS, CROSSRADIUS); TransX = ValSatSquare.hi.x - (INT32) ((double)ValSatSquare.Width() * ColourDef.Saturation.MakeDouble()); TransY = ValSatSquare.lo.y + (INT32) ((double)ValSatSquare.Height() * ColourDef.Value.MakeDouble()); CrossRect.Translate(HalfGridLock(TransX, PixelSize), HalfGridLock(TransY, PixelSize)); RenderCross(pRender, &CrossRect, PixelSize, FALSE); } return; }

void ColourEditDlg::RenderPickerSliderH (  RenderRegion *  pRender, DocRect *  SliderRect, INT32  PixelSize, FIXED24  DisplayValue, DocColour *  LeftCol, DocColour *  RightCol, DocColour *  TopLeftCol, DocColour *  TopRightCol, BOOL  Shaded = FALSE )  [protected]

Redraws a horizontal slider in a colour picker control. This generic method is used to draw a slider for a colour component. Generally, the slider will be a linear grad filled rectangle which shades from a colour with that component = 0.0 to 1.0. void ColourEditDlg::RenderPickerSliderH(RenderRegion *pRender, DocRect *SliderRect, INT32 PixelSize, FIXED24 DisplayValue, DocColour *LeftCol, DocColour *RightCol DocColour *TopLeftCol, DocColour *TopRightCol, BOOL Shaded = FALSE) Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/94 Parameters: pRender  - The render region to render the picker in [INPUTS] SliderRect - The rectangle in which the slider is to be rendered DisplayValue - The value (0.0 - 1.0) to display on the slider LeftCol - NULL or The colour to pot at the (bottom) left end of the slider RightCol - NULL or The colour to plot at the (bottom) right end of the slider TopLeftCol - The colour to pot at the (top) left end of the slider TopRightCol - The colour to plot at the (top) right end of the slider Shaded - TRUE if the marker cross should be shown shaded Notes: The slider is a split-display. It shows two horizontal grad-fills: The top half shows a fill from TopLeftCol to TopRight Col, while the bottom half shows a fill from LeftCol to RightCol. If LeftCol and/or RightCol are NULL, the strip will be filled with a single fill, from TopLeft to TopRight colours. This will use the line width/colour as set on entry, so you should set line width = 0 and line colour = COLOUR_TRANS before calling this fn The marker cross will only be rendered if EditingColour != NULL See also: ColourEditDlg::RenderControl; ColourEditDlg::RenderPickerDefault Definition at line 6137 of file coldlog.cpp. { ERROR3IF(pRender == NULL || SliderRect == NULL || TopLeftCol == NULL || TopRightCol == NULL, "ColourEditDlg::RenderPickerSliderH - NULL parameters are illegal"); pRender->SaveContext(); // Save the current rendering context INT32 MidY = (SliderRect->lo.y + SliderRect->hi.y) / 2; LinearFillAttribute BottomGradFill; Path RectPath; if (LeftCol != NULL && RightCol != NULL) { // Are in strip mode, so... create a grad fill for the bottom strip BottomGradFill.Colour = *LeftCol; BottomGradFill.EndColour = *RightCol; DocCoord ThePoint(SliderRect->lo.x, (SliderRect->lo.y + SliderRect->hi.y) / 2); BottomGradFill.SetStartPoint(&ThePoint); ThePoint = DocCoord(SliderRect->hi.x, (SliderRect->lo.y + SliderRect->hi.y) / 2); BottomGradFill.SetEndPoint(&ThePoint); BottomGradFill.SetEndPoint2(NULL); pRender->SetFillGeometry(&BottomGradFill, FALSE); // Draw the rectangle - done as a path so we can draw with grad-fill RectPath.Initialise(12, 12); RectPath.FindStartOfPath(); RectPath.InsertMoveTo(SliderRect->lo); RectPath.InsertLineTo(DocCoord(SliderRect->hi.x, SliderRect->lo.y)); RectPath.InsertLineTo(DocCoord(SliderRect->hi.x, MidY)); RectPath.InsertLineTo(DocCoord(SliderRect->lo.x, MidY)); RectPath.IsFilled = TRUE; pRender->DrawPath(&RectPath); // Render the bottom strip } // Create a grad fill for the top strip LinearFillAttribute TopGradFill; TopGradFill.Colour = *TopLeftCol; TopGradFill.EndColour = *TopRightCol; DocCoord ThePoint(SliderRect->lo.x, (SliderRect->lo.y + SliderRect->hi.y) / 2); TopGradFill.SetStartPoint(&ThePoint); ThePoint = DocCoord(SliderRect->hi.x, (SliderRect->lo.y + SliderRect->hi.y) / 2); TopGradFill.SetEndPoint(&ThePoint); TopGradFill.SetEndPoint2(NULL); pRender->SetFillGeometry(&TopGradFill, FALSE); Path TopRectPath; TopRectPath.Initialise(12, 12); TopRectPath.FindStartOfPath(); if (LeftCol != NULL && RightCol != NULL) { // Doing split-line display, so rect is bottom half of slider TopRectPath.InsertMoveTo(DocCoord(SliderRect->lo.x, MidY)); TopRectPath.InsertLineTo(DocCoord(SliderRect->hi.x, MidY)); TopRectPath.InsertLineTo(SliderRect->hi); TopRectPath.InsertLineTo(DocCoord(SliderRect->lo.x, SliderRect->hi.y)); } else { // Not doing split-line display, so rect is entire slider TopRectPath.InsertMoveTo(SliderRect->lo); TopRectPath.InsertLineTo(DocCoord(SliderRect->hi.x, SliderRect->lo.y)); TopRectPath.InsertLineTo(SliderRect->hi); TopRectPath.InsertLineTo(DocCoord(SliderRect->lo.x, SliderRect->hi.y)); } TopRectPath.IsFilled = TRUE; pRender->DrawPath(&TopRectPath); // Render the top strip pRender->RestoreContext(); // Restore original attribute context if (EditingColour != NULL) { if (DisplayValue < FIXED24(0.0)) // Clip the value to 0-1 range DisplayValue = 0; if (DisplayValue > FIXED24(1.0)) DisplayValue = FIXED24(1.0); DocRect CrossRect(-CROSSRADIUS, -CROSSRADIUS, CROSSRADIUS, CROSSRADIUS); INT32 TransX = SliderRect->lo.x + (INT32) ((double)SliderRect->Width() * DisplayValue.MakeDouble()); INT32 TransY = (SliderRect->lo.y + SliderRect->hi.y) / 2; CrossRect.Translate(HalfGridLock(TransX, PixelSize), HalfGridLock(TransY, PixelSize)); RenderCross(pRender, &CrossRect, PixelSize, Shaded); } }

void ColourEditDlg::RenderPickerTint (  RenderRegion *  pRender, DocRect *  VirtualSize, INT32  PixelSize, DialogColourInfo *  RedrawColours )  [protected]

Redraws a colour picker control for the colour editor dialogue. This is used in the given display mode to display the colour information in a useful format. e.g. in HSV mode, a wheel and slider arrangement. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 2/10/95 Parameters: pRender  - The render region to render the picker in [INPUTS] VirtualSize - The rectangle defining the coordinate space to draw into PixelSize - The size of a pixel as mapped into the MILLIPOINT VirtualSize coordinate space; ensures things line up on display pixel boundaries. RedrawColours - A pointer to a DialogColourInfo object describing OS-friendly drawing colours to be used in redrawing the control. Notes: This is called to render the picker for link and shade colours It simply gives a single slider which goes between the parent colour and white/black. See also: ColourEditDlg::RenderControl; ColourEditDlg::RenderPickerDefault Definition at line 6436 of file coldlog.cpp. { ERROR3IF(EditingColour->GetType() != COLOURTYPE_TINT, "ColourEditDlg::RenderPickerTint called on non-tint/shade colour!"); pRender->SaveContext(); // Save the current rendering context // Set rendering defaults: Fill paths only, and fill background with window grey pRender->SetLineWidth(0); pRender->SetLineColour(COLOUR_TRANS); // Calculate the slider rectangle const INT32 SliderHeight = 18000; DocRect SliderRect(*VirtualSize); SliderRect.Inflate(0, -(VirtualSize->Height() - SliderHeight) / 2); // And the grad fill colours, and the text to be drawn String_64 SliderText; DocColour LeftColour; // if (EditingColour->TintIsShade()) // { // LeftColour = DocColour(COLOUR_BLACK); // SliderText.MakeMsg(_R(IDS_SHADEOFCOLOUR), (TCHAR *) *(EditingColour->FindLinkedParent()->GetName())); // } // else { LeftColour = DocColour(255L, 255L, 255L); SliderText.MakeMsg(_R(IDS_TINTOFCOLOUR), (TCHAR *) *(EditingColour->FindLinkedParent()->GetName())); } DocColour RightColour; RightColour.MakeRefToIndexedColour(EditingColour->FindLinkedParent()); DocRect TextRect(SliderRect); TextRect.Translate(0, SliderHeight); pRender->SetFixedSystemTextColours(&RedrawColours->TextFore(), &RedrawColours->DialogBack()); pRender->DrawFixedSystemText((StringBase *) &SliderText, TextRect); FIXED24 DisplayValue = (EditingColour->TintIsShade()) ? EditingColour->GetShadeValueY() : EditingColour->GetTintValue(); // And render the slider RenderPickerSliderH(pRender, &SliderRect, PixelSize, DisplayValue, NULL, NULL, &LeftColour, &RightColour, FALSE); // Finally, return the render region context to its original state pRender->RestoreContext(); }

void ColourEditDlg::ResetState (  void   )  [protected]

Definition at line 965 of file coldlog.cpp. { State.Folded = 2; State.ColType = (IndexedColourType) 99; // An invalid value! State.DisplayModel = MAX_COLOURMODELS; State.ResultColour = NULL; State.Initialised = FALSE; State.ParentListOK = FALSE; }

static void ColourEditDlg::SetAbortColourState (  AbortColourState  state  )  [inline, static]

Definition at line 312 of file coldlog.h. { abortColourState = state; }

void ColourEditDlg::SetAllHexComponentsInfo (  UINT32  ComponentID, UINT32  NameGadget, UINT32  WritableGadget )  [protected]

Finds and sets all component names for the hex gadget. This actually gets the individual rgb values, and concatenates into a single string of the form rrggbb for display. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 15/11/99 Parameters: ComponentID  - Which component name is being set (must be set at -1). [INPUTS] NameGadget - Gadget ID for gadget displaying the name text (must be _R(IDC_NAME_WEBHEX)). WritableGadget - Writable gadget to also be shaded/unshaded (must be _R(IDC_EDIT_WEBHEX)) Scope: private Note: Should only be called in a: if (DisplayModel == COLOURMODEL_WEBRGBT) .... SetComponentInfo should also be called for all colour components before this function, since SetComponentInfo sets up all of the colour component inheritace stuff. Definition at line 1653 of file coldlog.cpp. { if (EditingColour == NULL) // This should never happen { ERROR3("Unexpectedly NULL EditingColour in ColourEditDlg::SetComponentInfo"); return; } if (!(ComponentID == (UINT32)-1) && (NameGadget == _R(IDC_NAME_WEBHEX)) && (WritableGadget == _R(IDC_EDIT_WEBHEX))) { ERROR3("Calling ColourEditDlg::SetAllHexComponentsInfo for incorrect control"); return; } if (CurrentTypingGadget != WritableGadget) { // We know that GetComponentsAsHexString only works if the colour context is RGBT // So why get anything else??? ColourContext *cc = ColourContext::GetGlobalDefault(COLOURMODEL_RGBT); String_32 CompName (_R(IDS_COLCOMPL_WEBHEX)); if (cc != NULL) { if (DisplayModel == COLOURMODEL_RGBT || DisplayModel == COLOURMODEL_HSVT) { SetStringGadgetValue(NameGadget, CompName); EnableGadget(NameGadget, TRUE); HideGadget(NameGadget, FALSE); String_16 NewText; ColourPicker::GetComponentsAsHexString(EditingColour, cc, ComponentID, &NewText); EnteredSetGadgetValue(); SetStringGadgetValue(WritableGadget, NewText); ExitedSetGadgetValue(); EnableGadget(WritableGadget, /*(!InheritsComponent) &&*/ (EditingColour->GetType() != COLOURTYPE_TINT)); HideGadget(WritableGadget, FALSE); } } } //CheckDialogSize(); }

void ColourEditDlg::SetColour (  BOOL  SetComponents = TRUE  )  [protected]

Reads the colour definition from the window into the colour which is currently being edited, and broadcasts a colour changing message so everybody knows about the change. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/6/94 Parameters: SetComponents  - TRUE if you wish to read all information, including the [INPUTS] component values - this may change the appearance of the colour, and thus causes much of the dialogue to be redrawn (and may also coerce the colour model). If the only thing which has changed is the name (for example) we don't want to change the model and/or redraw stuff, so we set this value to FALSE to stop it faffing around. This parameter is ignored for Tints, for which the components are read-only Scope: private Definition at line 1724 of file coldlog.cpp. { if (EditingColour == NULL) return; // Did we just get the gadget's value? if (IsSetGadgetValueCalled()) return; BOOL Clipped = FALSE; // ColourContext *cc = ColourContext::GetGlobalDefault(DisplayModel); ColourContext *cc = NULL; BOOL bDeleteCC = GetColourContext(DisplayModel, &cc); if (cc == NULL) return; // Make sure any chnage to the display colour model is committed ColourPicker::ForceColourModel(EditingColour, cc); // Read back the new component values. This is not done for tints, as their components // rely entirely upon the parent colour - reading out components is just going to // corrupt tinting values and stuff, and generally be a bad thing (tm). // Just does the set for the CurrentTypingGadget if (SetComponents && EditingColour->GetType() != COLOURTYPE_TINT) { String_32 CompName; if (cc == NULL) return; String_256 NewValue; if (CurrentTypingGadget!=_R(IDC_EDIT_WEBHEX)) { // Work out the index number INT32 nIndex=0; if (CurrentTypingGadget == _R(IDC_EDIT_COMPONENT1)) nIndex=1; else if (CurrentTypingGadget == _R(IDC_EDIT_COMPONENT2)) nIndex=2; else if (CurrentTypingGadget == _R(IDC_EDIT_COMPONENT3)) nIndex=3; else if (CurrentTypingGadget == _R(IDC_EDIT_COMPONENT4)) nIndex=4; ERROR3IF(nIndex < 1 || nIndex > 4, "ColourEditDlg::SetColour - nIndex invalid"); if (!nIndex) nIndex=1; if (cc->GetComponentName(nIndex, &NewValue)) { NewValue = GetStringGadgetValue(CurrentTypingGadget); Clipped |= ColourPicker::SetComponentFromString(EditingColour, cc, nIndex, (String_8 *) &NewValue); } } else { NewValue = GetStringGadgetValue(CurrentTypingGadget); // we need to set all of the components .... cc = ColourContext::GetGlobalDefault(COLOURMODEL_RGBT); Clipped |= ColourPicker::SetComponentsFromHexString(EditingColour, cc, (String_16 *) &NewValue); } /* if (cc->GetComponentName(2, &NewValue) != NULL) { NewValue = GetStringGadgetValue(_R(IDC_EDIT_COMPONENT2)); Clipped |= ColourPicker::SetComponentFromString(EditingColour, cc, 2, (String_8 *) &NewValue); } if (cc->GetComponentName(3, &NewValue) != NULL) { NewValue = GetStringGadgetValue(_R(IDC_EDIT_COMPONENT3)); Clipped |= ColourPicker::SetComponentFromString(EditingColour, cc, 3, (String_8 *) &NewValue); } if (cc->GetComponentName(4, &NewValue) != NULL) { NewValue = GetStringGadgetValue(_R(IDC_EDIT_COMPONENT4)); Clipped |= ColourPicker::SetComponentFromString(EditingColour, cc, 4, (String_8 *) &NewValue); } */ } // Delete the colour context if necessary if (bDeleteCC) ColourContextList::GetList()->RemoveContext(&cc); // Have finished with it /* // Set the new name of the colour - this is not done if the colour is unnamed, // because we don't want to accidentally convert an unnamed colour into a named one! BOOL NameMadeUnique = FALSE; // Have we had to change the name that was entered? BOOL NameHasChanged = FALSE; // Has the name been changed at all? if (EditingColour->IsNamed()) { String_256 NewName = GetStringGadgetValue(_R(IDC_EDIT_NAMEMENU), NULL); // If the name is not any different, then we must not try to update it NameHasChanged = (NewName.CompareTo(*((StringBase *)ResultColour->GetName())) != 0); if (NameHasChanged) { String_64 UniqueName; NameMadeUnique = ColourManager::GetCurrentColourList()-> GenerateUniqueColourName(&NewName, &UniqueName); EditingColour->SetName(UniqueName); } } */ switch(EditingColour->GetType()) { case COLOURTYPE_TINT: { if (EditingColour->TintIsShade()) { String_256 XValue = GetStringGadgetValue(_R(IDC_EDIT_TINT)); String_256 YValue = GetStringGadgetValue(_R(IDC_EDIT_SHADE)); ColourPicker::SetShadeFromStrings(EditingColour, &XValue, &YValue); } else { String_256 NewValue = GetStringGadgetValue(_R(IDC_EDIT_TINT)); ColourPicker::SetTintFromString(EditingColour, &NewValue); } Clipped = TRUE; // Ensure controls are updated too } break; case COLOURTYPE_LINKED: EditingColour->SetInheritsComponent(1, GetBoolGadgetSelected(_R(IDC_EDIT_INHERIT1))); EditingColour->SetInheritsComponent(2, GetBoolGadgetSelected(_R(IDC_EDIT_INHERIT2))); EditingColour->SetInheritsComponent(3, GetBoolGadgetSelected(_R(IDC_EDIT_INHERIT3))); EditingColour->SetInheritsComponent(4, GetBoolGadgetSelected(_R(IDC_EDIT_INHERIT4))); break; default: break; } if (EditingColour->IsDifferent(*ResultColour)) EditingColourHasChanged((SetComponents && Clipped), SetComponents); /* else if (NameHasChanged) { EditingColourHasChanged(FALSE, FALSE); SetColourNameList(); // The name has changed, so update the name list // if (NameMadeUnique) // We read the name and then changed it to ensure it was // SetControls(); // a unique name, so we must ensure the control is updated } */ }

void ColourEditDlg::SetColourNameList (  void   )  [protected]

Initialises the colour editor dialogue name combo-box list Scope: private. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/94 Definition at line 762 of file coldlog.cpp. { if (State.ParentListOK) return; // Get a description of the current local colour SelRange *Selection = GetApplication()->FindSelection(); // // String_256 SelDesc = Selection->Describe(MENU); // String_256 ColourDesc(TEXT("(No selection colour)"));; // if (Selection->Count() != 0) // ColourDesc._MakeMsg("Colour of #1%s", (TCHAR *)SelDesc); Progress Hourglass; // Start an hourglass running. On destruction it'll turn it off again BOOL OldSentState = ISentTheMessage; ISentTheMessage = TRUE; if (NameDropDown != NULL) delete NameDropDown; NameDropDown = new ColourDropDown; BOOL ok = TRUE; if (NameDropDown == NULL || !NameDropDown->Init(WindowID, _R(IDC_EDIT_NAMEMENU))) ok = FALSE; if (ok) { String_256 FillColDesc(_R(IDS_COLEDIT_FILL)); String_256 LineColDesc(_R(IDS_COLEDIT_LINE)); if (Selection->Count() == 0) // No selection, so will use current colours { FillColDesc = String_256(_R(IDS_COLEDIT_CURFILL)); LineColDesc = String_256(_R(IDS_COLEDIT_CURLINE)); } // Ensure there are no special entries in the list, then add the 2 we want this time NameDropDown->ClearAllSpecialEntries(); ColourList *NewParentList = NULL; DocColour DocColourToEdit; ColourManager::FindColourOfInterestToUser(&DocColourToEdit, &NewParentList, FALSE); ok = NameDropDown->AddSpecialEntry(&FillColDesc, &DocColourToEdit); if (ok) { ColourManager::FindColourOfInterestToUser(&DocColourToEdit, &NewParentList, TRUE); ok = NameDropDown->AddSpecialEntry(&LineColDesc, &DocColourToEdit); } if (ok) { // Determine if we're editing a named colour, or a current colour IndexedColour *Ptr = NULL; if (ParentList != NULL) { Ptr = (IndexedColour *) ParentList->GetHead(); while (Ptr != NULL) { if (!Ptr->IsDeleted() && Ptr->IsNamed()) { if (Ptr == ResultColour) break; } Ptr = (IndexedColour *) ParentList->GetNext(Ptr); } } // If we aren't editing a named colour (Ptr == NULL) then we're editing fill (0) or line (1) colour INT32 SelIndex = -1; if (Ptr == NULL) SelIndex = (EditingLineColour) ? 1 : 0; // Fill in the list ok = NameDropDown->FillInColourList(Ptr, SelIndex); // NOTE: We could do a SetComboListLength here, except that this causes awful // redraws of everything "behind" the combo-list extent. I can't stop it doing this, // other than by not setting the list length... so I don't } } // If we failed, then we shade this control so that some semblance of stability remains if (!ok) EnableGadget(_R(IDC_EDIT_NAMEMENU), FALSE); /* INT32 Index = 0; INT32 SelectedIndex = 0; // Compile a list of all editable colours into the colour name combo-list GadgetRedraw(_R(IDC_EDIT_NAMEMENU), FALSE); DeleteAllValues(_R(IDC_EDIT_NAMEMENU)); String_256 FillColDesc(TEXT("Fill colour")); String_256 LineColDesc(TEXT("Line colour")); String_256 DottedLine(TEXT("---------------------------------------")); if (Selection->Count() == 0) // No selection, so will use current colours { FillColDesc = TEXT("Current fill colour"); LineColDesc = TEXT("Current line colour"); } SetStringGadgetValue(_R(IDC_EDIT_NAMEMENU), &FillColDesc, TRUE); SetStringGadgetValue(_R(IDC_EDIT_NAMEMENU), &LineColDesc, TRUE); SetStringGadgetValue(_R(IDC_EDIT_NAMEMENU), &DottedLine, TRUE); Index += 3; if (EditingLineColour) SelectedIndex++; if (ParentList != NULL) { IndexedColour *Ptr = (IndexedColour *) ParentList->GetHead(); while (Ptr != NULL) { if (!Ptr->IsDeleted() && Ptr->IsNamed()) { SetStringGadgetValue(_R(IDC_EDIT_NAMEMENU), Ptr->GetName(), TRUE); if (Ptr == ResultColour) SelectedIndex = Index; Index++; } Ptr = (IndexedColour *) ParentList->GetNext(Ptr); } } GadgetRedraw(_R(IDC_EDIT_NAMEMENU), TRUE); // Set the writable colour name (combo box editable) field SetSelectedValueIndex(_R(IDC_EDIT_NAMEMENU), SelectedIndex); */ ISentTheMessage = OldSentState; State.ParentListOK = TRUE; }

void ColourEditDlg::SetComponentInfo (  UINT32  ComponentID, UINT32  Gadget, UINT32  WritableGadget, UINT32  InheritGadget )  [protected]

Finds and sets the component name for one gadget. If the component is not used in the EditingColours colour model, then the name is blanked and the related writable gadget is shaded. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 26/7/94 Parameters: ComponentID  - Which component name is being set (1..4) [INPUTS] NameGadget - Gadget ID for gadget displaying the name text WritableGadget - Writable gadget to also be shaded/unshaded InheritGadget - The checkbox gadget for linked-colour inheritance Scope: private Definition at line 1553 of file coldlog.cpp. { if (EditingColour == NULL) // This should never happen { ERROR3("Unexpectedly NULL EditingColour in ColourEditDlg::SetComponentInfo"); return; } if (CurrentTypingGadget != WritableGadget) { // ColourContext *cc = ColourContext::GetGlobalDefault(DisplayModel); ColourContext *cc = NULL; BOOL bDeleteCC = GetColourContext(DisplayModel, &cc); String_32 CompName; if (cc != NULL && cc->GetComponentName(ComponentID, &CompName)) { if (DisplayModel != COLOURMODEL_WEBRGBT) { SetStringGadgetValue(Gadget, CompName); SetStringGadgetValue(InheritGadget, CompName); EnableGadget(Gadget, TRUE); HideGadget(Gadget, FALSE); String_8 NewText; ColourPicker::GetComponentAsString(EditingColour, cc, ComponentID, &NewText); EnteredSetGadgetValue(); SetStringGadgetValue(WritableGadget, NewText); ExitedSetGadgetValue(); BOOL InheritsComponent = EditingColour->InheritsComponent(ComponentID); EnableGadget(WritableGadget, (!InheritsComponent) && (EditingColour->GetType() != COLOURTYPE_TINT)); HideGadget(WritableGadget, FALSE); // Set up the inheritance gadget EnableGadget(InheritGadget, EditingColour->GetType() == COLOURTYPE_LINKED); HideGadget(InheritGadget, EditingColour->GetType() != COLOURTYPE_LINKED); SetBoolGadgetSelected(InheritGadget, InheritsComponent); } else { //SetStringGadgetValue(Gadget, &CompName); SetStringGadgetValue(InheritGadget, CompName); //EnableGadget(Gadget, TRUE); //HideGadget(Gadget, FALSE); BOOL InheritsComponent = EditingColour->InheritsComponent(ComponentID); // Set up the inheritance gadget EnableGadget(InheritGadget, EditingColour->GetType() == COLOURTYPE_LINKED); HideGadget(InheritGadget, EditingColour->GetType() != COLOURTYPE_LINKED); SetBoolGadgetSelected(InheritGadget, InheritsComponent); } } else { HideGadget(Gadget, TRUE); HideGadget(WritableGadget, TRUE); HideGadget(InheritGadget, TRUE); } // Delete the colour context if necessary if (bDeleteCC) ColourContextList::GetList()->RemoveContext(&cc); // Have finished with it } //CheckDialogSize(); }

void ColourEditDlg::SetControls (  void   )  [protected]

Definition at line 1213 of file coldlog.cpp. { // If there is no colour to edit, desperately seek a new colour to edit - avoid // shading the dialogue at all costs. (We should then only shade if there are no documents) if (EditingColour == NULL) { FindUsefulColourToEdit(EditingLineColour); if (EditingColour != NULL) return; // Avoid infinite recursion! } SetExtent(); if (EditingColour == NULL) { ShadeMyself(); // No colour to edit - ensure we're shaded return; } BOOL OldSentState = ISentTheMessage; ISentTheMessage = TRUE; // Try to lock out DIM_TEXT_CHANGED messages during update ShadeMyself(TRUE, TRUE); // We have a colour - ensure we are not shaded SetColourNameList(); // Set the name writable and dropdown list of colours //Set the transparency button if( EditingColour->IsNamed() ) { EnableGadget( _R(IDC_EDIT_NOCOLOUR), FALSE); } else { EnableGadget( _R(IDC_EDIT_NOCOLOUR), TRUE); SetBoolGadgetSelected( _R(IDC_EDIT_NOCOLOUR), NoFillButtonDown); } //Graham 16/10/97: The rename button String_256 empty; OpState opstate=GetCommandState(&ColCmd_Name, &empty); BOOL fRenameCommandIsAvailable=opstate.Greyed; EnableGadget( _R(IDC_EDIT_RENAME), !fRenameCommandIsAvailable); // Set tint information BOOL Enable = (EditingColour->GetType() == COLOURTYPE_TINT); IndexedColourType CurrentColType = EditingColour->GetType(); if (CurrentColType == COLOURTYPE_TINT && EditingColour->TintIsShade()) CurrentColType = COLOURTYPE_SHADE; // Shade is a special "Bodge" colour type if (State.ColType != CurrentColType) { NeedsResize(); EnableGadget(_R(IDC_EDIT_TINT), Enable); EnableGadget(_R(IDC_EDIT_TINTNAME), Enable); EnableGadget(_R(IDC_EDIT_TINTPERCENT), Enable); // EnableGadget(_R(IDC_EDIT_TINTSLIDER), Enable); // SetGadgetRange(_R(IDC_EDIT_TINTSLIDER), 0, 100, 1); // SetGadgetBitmaps(_R(IDC_EDIT_TINTSLIDER), _R(IDB_SLIDERBASE), _R(IDB_SLIDERSLIDER)); if (CurrentColType == COLOURTYPE_SHADE) { EnableGadget(_R(IDC_EDIT_SHADE), Enable); EnableGadget(_R(IDC_EDIT_SHADEPERCENT), Enable); } // The Colour model dropdown and 3d button are not available while editing a tint/shade // (The 3d button is set below, but we need to enable it here too just in case the code below // is not called (when we only change the colour model) EnableGadget(_R(IDC_EDIT_COLMODEL), !Enable); EnableGadget(_R(IDC_EDIT_3D), !Enable); } if (Enable) { // It's a tint/shade. Set the "Tint:" or "Shade:" text as appropriate if (EditingColour->TintIsShade()) SetStringGadgetValue(_R(IDC_EDIT_TINTNAME), _R(IDS_EDIT_TEXTSHADE)); else SetStringGadgetValue(_R(IDC_EDIT_TINTNAME), _R(IDS_EDIT_TEXTTINT)); // If we're not currently typing into this field and it is displaying the wrong thing, // we'd better update it to be correct. if (CurrentTypingGadget != _R(IDC_EDIT_TINT)) { String_256 CurrentValue = GetStringGadgetValue(_R(IDC_EDIT_TINT)); String_8 NewValue; if (CurrentColType == COLOURTYPE_SHADE) ColourPicker::GetShadeValueAsString(EditingColour, 1, &NewValue); else ColourPicker::GetTintAsString(EditingColour, &NewValue); if (NewValue != CurrentValue) SetStringGadgetValue(_R(IDC_EDIT_TINT), NewValue); } if (CurrentColType == COLOURTYPE_SHADE && CurrentTypingGadget != _R(IDC_EDIT_SHADE)) { String_256 CurrentValue = GetStringGadgetValue(_R(IDC_EDIT_SHADE)); String_8 NewValue; ColourPicker::GetShadeValueAsString(EditingColour, 2, &NewValue); if (NewValue != CurrentValue) SetStringGadgetValue(_R(IDC_EDIT_SHADE), NewValue); } // And set the slider to the nearest position to this value INT32 SliderValue = (INT32) ((100.0 * (EditingColour->GetTintValue().MakeDouble())) + 0.5); if (SliderValue > 100) // Just ensure rounding doesn't give a 101%! SliderValue = 100; // SetLongGadgetValue(_R(IDC_EDIT_TINTSLIDER), 100-SliderValue); } // else // SetLongGadgetValue(_R(IDC_EDIT_TINTSLIDER), 100-0); // Set up the combo box of available colour models if (State.DisplayModel != DisplayModel) { NeedsResize(); // Shift around the component name and writable gadgets until Windows doesn't // know if it's coming or going. static CGadgetID CompGadgetIDs[10] = { _R(IDC_NAME_COMPONENT1), _R(IDC_EDIT_COMPONENT1), _R(IDC_NAME_COMPONENT2), _R(IDC_EDIT_COMPONENT2), _R(IDC_NAME_COMPONENT3), _R(IDC_EDIT_COMPONENT3), _R(IDC_NAME_COMPONENT4), _R(IDC_EDIT_COMPONENT4), _R(IDC_NAME_WEBHEX), _R(IDC_EDIT_WEBHEX) };// CGS CGS CGS // Special case for certain colour models but fall back to general formatter for everything else switch (DisplayModel) { case COLOURMODEL_RGBT: { INT32 TextWidth[5] = {7, 7, 7, 0, 7}; INT32 EditWidth[5] = {35, 35, 35, 0, 48}; ColourPicker::SetFixedComponentGadgets(WindowID, CompGadgetIDs, _R(IDC_EDIT_PICKER), DisplayModel, TextWidth, EditWidth); } break; case COLOURMODEL_HSVT: { INT32 TextWidth[5] = {7, 7, 7, 0, 7}; INT32 EditWidth[5] = {35, 35, 35, 0, 48}; ColourPicker::SetFixedComponentGadgets(WindowID, CompGadgetIDs, _R(IDC_EDIT_PICKER), DisplayModel, TextWidth, EditWidth); } break; default: ColourPicker::SetComponentGadgets(WindowID, CompGadgetIDs, _R(IDC_EDIT_PICKER), DisplayModel); break; } // Enable the '3d display' button if it is relevant (CMYK, RGB or WebRGB mode, and not showing a tint/shade EnableGadget(_R(IDC_EDIT_3D), (DisplayModel == COLOURMODEL_CMYK || DisplayModel == COLOURMODEL_RGBT || DisplayModel == COLOURMODEL_WEBRGBT) && (CurrentColType != COLOURTYPE_TINT && CurrentColType != COLOURTYPE_SHADE)); SetBoolGadgetSelected(_R(IDC_EDIT_3D), Use3DDisplay); GadgetRedraw(_R(IDC_EDIT_COLMODEL), FALSE); DeleteAllValues(_R(IDC_EDIT_COLMODEL)); ColourContextArray ColContexts; ColourContext::GetGlobalDefaults(&ColContexts); String_64 NameString; INT32 Index = 0; INT32 SelectedIndex = 0; for (INT32 i = 0; i < MAX_COLOURMODELS; i++) { if (ColContexts.Context[i] != NULL) { String_32 ModelName; ColContexts.Context[i]->GetModelName(&ModelName); NameString.MakeMsg(_R(IDS_COLCONTEXTNAME), (TCHAR *) ModelName); SetStringGadgetValue(_R(IDC_EDIT_COLMODEL), NameString, FALSE, Index); if (i == (INT32)DisplayModel) SelectedIndex = Index; Index++; } } GadgetRedraw(_R(IDC_EDIT_COLMODEL), TRUE); SetSelectedValueIndex(_R(IDC_EDIT_COLMODEL), SelectedIndex); SetComboListLength(_R(IDC_EDIT_COLMODEL)); } if (DisplayModel == COLOURMODEL_RGBT || DisplayModel == COLOURMODEL_HSVT) { //HideGadget (_R(IDC_NAME_COMPONENT4), TRUE); //HideGadget (_R(IDC_EDIT_COMPONENT4), TRUE); HideGadget (_R(IDC_NAME_WEBHEX), FALSE); HideGadget (_R(IDC_EDIT_WEBHEX), FALSE); } else { //HideGadget (_R(IDC_NAME_COMPONENT4), FALSE); //HideGadget (_R(IDC_EDIT_COMPONENT4), FALSE); HideGadget (_R(IDC_NAME_WEBHEX), TRUE); HideGadget (_R(IDC_EDIT_WEBHEX), TRUE); } // Set component name strings & writables, and inheritance gadgets // Note: This MUST occur AFTER the call to ColourPicker::SetComponentGadgets (up 1 page) SetComponentInfo(1, _R(IDC_NAME_COMPONENT1), _R(IDC_EDIT_COMPONENT1), _R(IDC_EDIT_INHERIT1)); SetComponentInfo(2, _R(IDC_NAME_COMPONENT2), _R(IDC_EDIT_COMPONENT2), _R(IDC_EDIT_INHERIT2)); SetComponentInfo(3, _R(IDC_NAME_COMPONENT3), _R(IDC_EDIT_COMPONENT3), _R(IDC_EDIT_INHERIT3)); SetComponentInfo(4, _R(IDC_NAME_COMPONENT4), _R(IDC_EDIT_COMPONENT4), _R(IDC_EDIT_INHERIT4)); if (DisplayModel == COLOURMODEL_WEBRGBT || DisplayModel==COLOURMODEL_RGBT || DisplayModel==COLOURMODEL_HSVT) { SetAllHexComponentsInfo ((UINT32)-1, _R(IDC_NAME_WEBHEX), _R(IDC_EDIT_WEBHEX)); } // Find a safe parent for the colour to link to. If we can't find one, then // we remove the linking options from the drop down list. IndexedColour *SafeParent; SafeParent = FindSafeParent(EditingColour->FindLastLinkedParent(), (CurrentColType == COLOURTYPE_TINT)); // Ensure the editing colour has a parent which is safe to link to if (SafeParent != EditingColour->FindLastLinkedParent()) EditingColour->SetLinkedParent(SafeParent, EditingColour->GetType()); // And make sure CurrentColType is still correct! CurrentColType = EditingColour->GetType(); if (CurrentColType == COLOURTYPE_TINT && EditingColour->TintIsShade()) CurrentColType = COLOURTYPE_SHADE; // Shade is a special "Bodge" colour type // Set up the colour type combo-box gadget whenever the type or the colour itself is changed, // or if we've not initialised it before if (State.ColType != CurrentColType || State.ResultColour != ResultColour || !State.Initialised) { GadgetRedraw(_R(IDC_EDIT_COLTYPE), FALSE); DeleteAllValues(_R(IDC_EDIT_COLTYPE)); INT32 Index = 0; // Compute an index for each item as we build the list INT32 SelIndex = 0; // Default SelIndex, for COLOURTYPE_NORMAL SetStringGadgetValue(_R(IDC_EDIT_COLTYPE), _R(IDS_COLTYPE_NORMAL), FALSE, Index++); // if (ResultColour->IsNamed()) // "Spot colour" only available for named colours // This option is now still shown in the list, but when the user tries to select it, // we force them to cancel or make a new named spot colour. #ifndef WEBSTER { if (CurrentColType == COLOURTYPE_SPOT) SelIndex = Index; SetStringGadgetValue(_R(IDC_EDIT_COLTYPE), _R(IDS_COLTYPE_SPOT), FALSE, Index++); } #endif //WEBSTER if (SafeParent != NULL) // We can make the colour linked { if (CurrentColType == COLOURTYPE_TINT) SelIndex = Index; SetStringGadgetValue(_R(IDC_EDIT_COLTYPE), _R(IDS_COLTYPE_TINT), FALSE, Index++); if (CurrentColType == COLOURTYPE_SHADE) SelIndex = Index; SetStringGadgetValue(_R(IDC_EDIT_COLTYPE), _R(IDS_COLTYPE_SHADE), FALSE, Index++); if (CurrentColType == COLOURTYPE_LINKED) SelIndex = Index; SetStringGadgetValue(_R(IDC_EDIT_COLTYPE), _R(IDS_COLTYPE_LINKED), FALSE, Index++); } GadgetRedraw(_R(IDC_EDIT_COLTYPE), TRUE); SetComboListLength(_R(IDC_EDIT_COLTYPE)); SetSelectedValueIndex(_R(IDC_EDIT_COLTYPE), SelIndex); } // Enable/Disable extra options gadgets as appropriate to EditingColour settings // and set up the list of potential parent colours if (State.ColType != CurrentColType) { Enable = (EditingColour->GetType() == COLOURTYPE_TINT || EditingColour->GetType() == COLOURTYPE_LINKED); EnableGadget(_R(IDC_EDIT_PARENTNAME), Enable); EnableGadget(_R(IDC_EDIT_PARENTCOL), Enable); } CompileParentColourList(_R(IDC_EDIT_PARENTCOL)); // Set the combo box list if ((EditingColour != NULL) && (EditingColour->IsNamed())) EnableGadget(_R(IDC_MAKE_LOCAL), TRUE); else EnableGadget(_R(IDC_MAKE_LOCAL), FALSE); // And finish ISentTheMessage = OldSentState; // Unlock the message handler again // And remember the new state of the controls/extent etc so we don't have to redraw // next time where these things have not changed State.Folded = (Folded) ? 1 : 0; State.ColType = CurrentColType; State.DisplayModel = DisplayModel; State.ResultColour = ResultColour; State.Initialised = TRUE; CheckDialogSize(); }

void ColourEditDlg::SetCursor (  UINT32  CursorResID  )  [protected]

Called by HandleIdlePointerXXX functions to set the cursor shape they desire. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 19/10/95 Parameters: CursorResID  - NULL (arrow pointer), or a resource ID that specifies a cursor [INPUTS] Notes: The base HandleIdlePointer function always resets the desired cursor ID to a standard Arrow cursor before calling the picker-specific code. If the called function does not set a cursor, then it will immediately revert. This function does *not* set the cursor, just remembers what cursor is wanted (Cursor setting is done in HandleIdlepointer) Definition at line 9354 of file coldlog.cpp. { // CurrentCursorID = CursorResID; //TRACEUSER( "Jason", _T("Cursor=%ld\n"), CursorResID); }

void ColourEditDlg::SetDefaultDisplayModel (  INT32  newDisplayModel  )  [static]

Camelots new custom colour picker control has changed the way in which the old default colour space stuff worked. If a user selects a colour space on the combobox - then we SHOULD remember this - and NOT jump straight back into the default (i.e. we should now set the selection as the default). We need to do this in two places: 1) internally from within ColourEditDlg::Message (); and 2) when the user sets the defaut model for (local colours) from within the camelot options dialog. This function allows us to achieve the second of these. Scope: public. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 3/11/99 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: ColourEditDlg::Message () (if (Msg->GadgetID == _R(IDC_EDIT_COLMODEL)) stuff) Definition at line 2307 of file coldlog.cpp. { TheEditor->DefaultDisplayModel = TheEditor->DisplayModel = (ColourModel) newDisplayModel; TheEditor->InvalidateAndSetControls (); }

void ColourEditDlg::SetDoTimerProcessing (  BOOL  Value  )

sets a flag which indicates whether or not the colour picker will do idle processing. If this is set to false the colour picker is effectively disabled. Scope: public Author: Diccon_Yamanaka (Xara Group Ltd) <camelotdev@xara.com> Date: 5/5/2000 Parameters: boolean  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: Definition at line 2145 of file coldlog.cpp. { m_bDoTimerProcessing = Value; if (!Value) EndTimedProcessing(); else BeginTimedProcessing(); }

void ColourEditDlg::SetEditingColour (  IndexedColour *  newEditingColour, Node *  pSourceNode = NULL )  [static]

Camelots new custom colour picker control (also written by me) needs to be able to change the value EditingColour on the fly (based upon the IndexedColour that is has just read/generated) so that we do not generate infinite amounts of undo information (which would be so if we always applied the supplied colour). This function allows us to achieve this functionality. Since this function is static, to access non-static member functions from within, we need to use TheEditor->function () otherwise VC6 complains. Scope: public. Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 3/11/99 Parameters: newEditingColour  - the IndexedColour that is to be set as EditingColour [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: ColourEditDlg::ApplyEditingColourNow () Definition at line 2036 of file coldlog.cpp. { // if we havn't saved an abort colour yet - then we save one here // otherwise we use the colour that weve already saved as our abort colour .... if (TheEditor->abortColourState == SAVE_ABORTCOLOUR) { if (TheEditor->EditingColour != NULL) { if (TheEditor->AbortColour != NULL) { if (!(TheEditor->AbortColour->IsNamed ())) { delete (TheEditor->AbortColour); } } TheEditor->AbortColour = new IndexedColour (*(TheEditor->EditingColour)); TheEditor->abortColourState = SAVED_ABORTCOLOUR; } } if (!(TheEditor->OriginalColour.IsNamed ())) { if (!(newEditingColour->IsNamed())) { if (TheEditor->EditingColour != NULL) { delete (TheEditor->EditingColour); } TheEditor->EditingColour = new IndexedColour (*newEditingColour); } else { if (TheEditor->EditingColour != NULL) { delete (TheEditor->EditingColour); } // we do some nasty stuff here - we use an unnamed colour to represent named colours // internally; and then convert (well actually we don't ever convert back again // cause this makes things more difficult - and I have more important things to be // doing with my time than working out why applying a named colour from this stuff // is such a pain in the but!) TheEditor->EditingColour = new IndexedColour (*newEditingColour); TheEditor->EditingColour->SetUnnamed (); } } else { if (TheEditor->EditingColour != NULL) { delete (TheEditor->EditingColour); } TheEditor->EditingColour = new IndexedColour (*newEditingColour); TheEditor->EditingColour->SetName (*(TheEditor->OriginalColour.GetName ())); } if (TheEditor->EditingColour == NULL) { InformError(); TheEditor->ShadeMyself(); return; } TheEditor->EditingColourHasChanged (TRUE, TRUE, TRUE, pSourceNode); // force everything to redraw }

void ColourEditDlg::SetExtent (  void   )  [protected]

If necessary, changes the size of the editor window and shuffles controls around to show folded/unfolded tint/linked information appropriately. If the State has not been reset or changed, this may do nothing, to minimise unnecessary redraws. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 23/1/95 Scope: private Definition at line 993 of file coldlog.cpp. { // Set size to small (cut off below 'more' button) or large (full-size) as appropriate // NOTE that this relies on the gadgets passed to SetWindowExtent being at the // bottom of the folded/unfolded layouts of the dialogue respectively. if (EditingColour == NULL) { // WEBSTER - markn 1/2/97 #ifdef WEBSTER ColourPicker::SetWindowExtent(WindowID, _R(IDC_EDIT_PICKER), _R(IDC_EDIT_PICKER)); #endif // WEBSTER HideGadget(_R(IDC_EDIT_ADVANCEDPANEL), TRUE); NeedsResize(); return; } // If there has been no change in the colour type, we should return. // This is compllicated by shades, which internally are a variant of TINTs, but // externally are different "types". IndexedColourType CurrentColType = EditingColour->GetType(); if (CurrentColType == COLOURTYPE_TINT && EditingColour->TintIsShade()) CurrentColType = COLOURTYPE_SHADE; // Shade is a special "Bodge" colour type #ifndef WEBSTER if (State.Folded == Folded && State.ColType == CurrentColType) return; #else // WEBSTER - markn 24/4/97 // Always unfolded. Folded = FALSE; // always unfolded #endif // WEBSTER NeedsResize(); if (Folded) { // WEBSTER - markn 11/12/96 // Always unfolded. // Changed folded to show ed fields #ifndef WEBSTER ColourPicker::SetWindowExtent(WindowID, _R(IDC_EDIT_PICKER), _R(IDC_EDIT_PICKER)); // SetStringGadgetValue(_R(IDC_EDIT_ADVANCED), _R(IDS_EDIT_MORE)); SetBoolGadgetSelected(_R(IDC_EDIT_ADVANCED), FALSE); #else ColourPicker::SetWindowExtent(WindowID, _R(IDC_EDIT_PICKER), _R(IDC_EDIT_COLTYPE)); #endif // WEBSTER HideGadget(_R(IDC_EDIT_ADVANCEDPANEL), TRUE); } else { HideGadget(_R(IDC_EDIT_ADVANCEDPANEL), FALSE); CGadgetID Gadget = _R(IDC_EDIT_COLTYPE); if (EditingColour != NULL) // If we have an editing colour, set tint/link controls { switch (EditingColour->GetType()) { case COLOURTYPE_TINT: { Gadget = _R(IDC_EDIT_TINT); HideGadgetList(LinkGadgetIDs, TRUE); HideGadgetList(TintGadgetIDs, FALSE); HideGadget (_R(IDC_EDIT_PARENTNAME), FALSE); HideGadget (_R(IDC_EDIT_PARENTCOL), FALSE); // ColourPicker::SetGadgetPositions(WindowID, LinkGadgetIDs, 0); // ColourPicker::SetGadgetPositions(WindowID, TintGadgetIDs, _R(IDC_EDIT_PARENTCOL)); // And if it's not a shade, hide the extra writable field HideGadget(_R(IDC_EDIT_SHADE), !EditingColour->TintIsShade()); HideGadget(_R(IDC_EDIT_SHADEPERCENT), !EditingColour->TintIsShade()); } break; case COLOURTYPE_LINKED: Gadget = _R(IDC_EDIT_INHERIT4); HideGadgetList(LinkGadgetIDs, FALSE); HideGadgetList(TintGadgetIDs, TRUE); HideGadget (_R(IDC_EDIT_PARENTNAME), FALSE); HideGadget (_R(IDC_EDIT_PARENTCOL), FALSE); // ColourPicker::SetGadgetPositions(WindowID, TintGadgetIDs, 0); // ColourPicker::SetGadgetPositions(WindowID, LinkGadgetIDs, _R(IDC_EDIT_PARENTCOL)); break; default: HideGadget (_R(IDC_EDIT_PARENTNAME), TRUE); HideGadget (_R(IDC_EDIT_PARENTCOL), TRUE); HideGadgetList(LinkGadgetIDs, TRUE); HideGadgetList(TintGadgetIDs, TRUE); break; } } ColourPicker::SetWindowExtent(WindowID, _R(IDC_EDIT_PICKER), Gadget); #ifndef WEBSTER // not included in Webster SetBoolGadgetSelected(_R(IDC_EDIT_ADVANCED), TRUE); // SetStringGadgetValue(_R(IDC_EDIT_ADVANCED), _R(IDS_EDIT_LESS)); #endif } }

void ColourEditDlg::SetNewValueCMYK (  ReDrawInfoType *  Info, INT32  PixelSize, BOOL  StartingNewDrag )  [protected]

Handles drag updates - determines the new colour values from the current mouse position, and sets the colour as appropriate. Just how it interprets the mouse position is dependant upon which region the drag was started within, and which DisplayMode is in operation. A different routine like this one will be called for each DisplayMode. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 23/12/94 Parameters: Info  - The redraw info for the kernel-drawn control's mouse event [INPUTS] PixelSize - The size of display pixels as they appear when mapped into the MILLIPOINT VirtualRect coordinate space (as used in the RenderControl methods) StartingNewDrag - TRUE if this is the first call to this function for a new drag operation (in which case, the DragStartArea is set appropriately) Notes: The RGB and CMYK pickers are almost identical in operation. It should be possible to tidy up the code considerably and make a generic routine for handling most of the common stuff. See also: ColourEditDlg::SetNewValueFromMousePos; ColourEditDlg::SetNewValueDefault Definition at line 8388 of file coldlog.cpp. { DocRect VirtualSize(0, 0, Info->dx, Info->dy); VirtualSize.Inflate(-PixelSize * 4); // And exclude the border // Determine how much space is left over after the key slider has been placed INT32 KeySliderLeft = VirtualSize.hi.x - (CROSSRADIUS+PixelSize)*2; ERROR3IF(KeySliderLeft < VirtualSize.lo.x, "Not enough room to render the colour picker!"); // Fill the control background, and draw the cube 'shadow' DocRect CubeAvailableSpace(VirtualSize); CubeAvailableSpace.hi.x = KeySliderLeft - 2000; DocRect SquareRect; INT32 SizeZ; DrawCubeShadowAndCalcValues(NULL, &CubeAvailableSpace, PixelSize, NULL, /* TO */ &SquareRect, &SizeZ); DocRect CubeFaceRect(SquareRect); // Remember the rect of the front face for below // Now, shift the square down from the front of the cube by an amount appropriate to // the Z-axis component of the colour // ColourContextCMYK *cc = (ColourContextCMYK*)ColourContext::GetGlobalDefault(COLOURMODEL_CMYK); ColourContext *cc = NULL; BOOL bDeleteCC = GetColourContext(DisplayModel, &cc); ColourCMYK SourceColour; if (CanSetColour(EditingColour)) { cc->ConvertColour(EditingColour, (ColourGeneric *) &SourceColour); FIXED24 ZComponent = SourceColour.Magenta; if (ColourPickerMode == 1) ZComponent = SourceColour.Cyan; else if (ColourPickerMode == 2) ZComponent = SourceColour.Yellow; INT32 ZTrans = (INT32) ((double)SizeZ * ZComponent.MakeDouble()) - SizeZ; SquareRect.Translate(-ZTrans, ZTrans); GridLockRect(&SquareRect, PixelSize); } if (StartingNewDrag) { // Remember what the colour was as we started the drag cc->ConvertColour(ResultColour, &ColourBeforeDrag); DocCoord BitmapPos; BitmapPos.x = HalfGridLock(CubeFaceRect.hi.x + SizeZ/2, PixelSize); BitmapPos.y = HalfGridLock(CubeFaceRect.hi.y - SizeZ/2, PixelSize); const INT32 BitmapSize = 14 * PixelSize; DocRect SwapAxesRect(BitmapPos.x, BitmapPos.y, BitmapPos.x + BitmapSize + PixelSize * 3, BitmapPos.y + BitmapSize); GridLockRect(&SwapAxesRect, PixelSize); if (SwapAxesRect.ContainsCoord(*(Info->pMousePos))) { // Swap the axes around - this is treated as a click (the rest of the drag ignored) DragStartArea = CEDRAG_NONE; ColourPickerMode = (ColourPickerMode + 1) % 3; InvalidateGadget(_R(IDC_EDIT_PICKER)); return; } if (SquareRect.ContainsCoord(*(Info->pMousePos))) DragStartArea = CEDRAG_CMYKPICKER_XY; else { // Check if the pointer is in the Z 'drag button' DocRect ZButton(SquareRect); ZButton.lo.x = ZButton.hi.x; ZButton.hi.x += ZSLIDERSIZE - (PixelSize * 2); ZButton.hi.y = ZButton.lo.y; ZButton.lo.y -= ZSLIDERSIZE - (PixelSize * 2); GridLockRect(&ZButton, PixelSize); if (ZButton.ContainsCoord(*(Info->pMousePos))) { DragStartArea = CEDRAG_CMYKPICKER_Z; // And remember the offset from the bottom right of the handle to the dragged point DragAnchor.x = Info->pMousePos->x - ZButton.lo.x; DragAnchor.y = Info->pMousePos->y - ZButton.hi.y; } else { // Check if the pointer is in the Key slider DocRect KeyRect(KeySliderLeft, 0, Info->dx, Info->dy - (PATCHSIZE + PixelSize*2)); if (KeyRect.ContainsCoord(*(Info->pMousePos))) DragStartArea = CEDRAG_CMYKPICKER_KEY; else { // OK, then. Is the click in a protuding bit of the marker cross? DocRect CrossRect; CalcCrossRectCMYK(&SourceColour, &SquareRect, PixelSize, &CrossRect); if (CrossRect.ContainsCoord(*(Info->pMousePos))) DragStartArea = CEDRAG_CMYKPICKER_XY; } } } } if (!CanSetColour(EditingColour)) // We can't change the colour - abort { DragStartArea = CEDRAG_NONE; return; } BOOL ColourHasChanged = TRUE; INT32 XPos = Info->pMousePos->x; INT32 YPos = Info->pMousePos->y; switch(DragStartArea) { case CEDRAG_CMYKPICKER_XY: { if (XPos < SquareRect.lo.x) XPos = SquareRect.lo.x; if (XPos > SquareRect.hi.x) XPos = SquareRect.hi.x; if (YPos < SquareRect.lo.y) YPos = SquareRect.lo.y; if (YPos > SquareRect.hi.y) YPos = SquareRect.hi.y; INT32 XComponent = 1; // XYZ = C,Y,M INT32 YComponent = 3; switch(ColourPickerMode) { case 1: // XYZ = Y,M,C XComponent = 3; YComponent = 2; break; case 2: // XYZ = M,C,Y XComponent = 2; YComponent = 1; break; } double NewX = ((double) (XPos - SquareRect.lo.x)) / ((double) SquareRect.Width()); if (NewX < 0.0) NewX = 0.0; if (NewX > 1.0) NewX = 1.0; double NewY = ((double) (YPos - SquareRect.lo.y)) / ((double) SquareRect.Height()); if (NewY < 0.0) NewY = 0.0; if (NewY > 1.0) NewY = 1.0; if (KeyPress::IsConstrainPressed()) { // ColourCMYK *ConstrainDef = (ColourCMYK *) &ColourBeforeDrag; double XDiff = GetComponent(&ColourBeforeDrag, XComponent).MakeDouble() - NewX; double YDiff = GetComponent(&ColourBeforeDrag, YComponent).MakeDouble() - NewY; if (XDiff < 0) XDiff = -XDiff; if (YDiff < 0) YDiff = -YDiff; if (XDiff < YDiff) NewX = GetComponent(&ColourBeforeDrag, XComponent).MakeDouble(); else NewY = GetComponent(&ColourBeforeDrag, YComponent).MakeDouble(); } ColourPicker::SetComponentFromDouble(EditingColour, cc, XComponent, NewX); ColourPicker::SetComponentFromDouble(EditingColour, cc, YComponent, NewY); DisplayModel = COLOURMODEL_CMYK; // Force display back to CMYK model if (!StartingNewDrag) { // Redraw the area where the cross used to be shown DocRect CrossRect; CalcCrossRectCMYK(&SourceColour, &SquareRect, PixelSize, &CrossRect); CrossRect.Inflate(4*PixelSize); // Inflate to ensure we redraw all of the cross InvalidateGadget(_R(IDC_EDIT_PICKER), Info, &CrossRect); // And force redraw the new cross position cc->ConvertColour(EditingColour, (ColourGeneric *) &SourceColour); CalcCrossRectCMYK(&SourceColour, &SquareRect, PixelSize, &CrossRect); CrossRect.Inflate(4*PixelSize); // Inflate to ensure we redraw all of the cross InvalidateGadget(_R(IDC_EDIT_PICKER), Info, &CrossRect); // Redraw the controls... InvalidatePatchGadget(Info); PaintGadgetNow(_R(IDC_EDIT_PICKER)); // And clear this flag so that the redraw below (of entire gadget) is not done. ColourHasChanged = FALSE; } } break; case CEDRAG_CMYKPICKER_Z: { XPos -= DragAnchor.x; // Correct the mouse position for anchoring YPos -= DragAnchor.y; INT32 ZComponent = 2; // XYZ = C,Y,M switch(ColourPickerMode) { case 1: // XYZ = Y,M,C ZComponent = 1; break; case 2: // XYZ = M,C,Y ZComponent = 3; break; } INT32 Offset = CubeFaceRect.hi.x + SizeZ - XPos; if (Offset > YPos - (CubeFaceRect.lo.y - SizeZ)) Offset = YPos - (CubeFaceRect.lo.y - SizeZ); double NewZ = ((double) Offset) / ((double) SizeZ); if (NewZ < 0.0) NewZ = 0.0; if (NewZ > 1.0) NewZ = 1.0; DisplayModel = COLOURMODEL_CMYK; // Force display back to CMYK model ColourPicker::SetComponentFromDouble(EditingColour, cc, ZComponent, NewZ); } break; case CEDRAG_CMYKPICKER_KEY: { XPos = LastDragPos.x = 0; // Make sure X move does not cause redraw if (YPos < 0) YPos = 0; if (YPos > Info->dy - (PATCHSIZE + PixelSize*2)) YPos = Info->dy - (PATCHSIZE + PixelSize*2); double NewValue = ((double)YPos) / ((double)(Info->dy - (PATCHSIZE + PixelSize*2))); DisplayModel = COLOURMODEL_CMYK; // Force display back to CMYK model ColourPicker::SetComponentFromDouble(EditingColour, cc, 4, NewValue); } break; default: return; // Not a legal drag, so we ignore it } // Delete the colour context if necessary if (bDeleteCC) ColourContextList::GetList()->RemoveContext(&cc); // Have finished with it // If necessary, redraw the colour picker control and the colour patch if (ColourHasChanged) { if (StartingNewDrag || YPos != LastDragPos.y || XPos != LastDragPos.x) { InvalidateGadget(_R(IDC_EDIT_PICKER)); PaintGadgetNow(_R(IDC_EDIT_PICKER)); } } // Remember the last position at which we updated LastDragPos.y = YPos; LastDragPos.x = XPos; }

void ColourEditDlg::SetNewValueDefault (  ReDrawInfoType *  Info, INT32  PixelSize, BOOL  StartingNewDrag )  [protected]

Handles drag updates - determines the new colour values from the current mouse position, and sets the colour as appropriate. Just how it interprets the mouse position is dependant upon which region the drag was started within, and which DisplayMode is in operation. A different routine like this one will be called for each DisplayMode. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/94 Parameters: Info  - The redraw info for the kernel-drawn control's mouse event [INPUTS] PixelSize - The size of display pixels as they appear when mapped into the MILLIPOINT VirtualRect coordinate space (as used in the RenderControl methods) StartingNewDrag - TRUE if this is the first call to this function for a new drag operation (in which case, the DragStartArea is set appropriately) Notes: The default method is called for all DisplayModes which are not specifically handled: It interprets mouse positions within the display drawn by its sister redraw method, which provides up to 4 horizontal component sliders. See also: ColourEditDlg::SetNewValueFromMousePos; ColourEditDlg::SetNewValueDefault; ColourEditDlg::RenderPickerDefault Definition at line 8695 of file coldlog.cpp. { // ColourContext *cc = ColourContext::GetGlobalDefault(DisplayModel); ColourContext *cc = NULL; BOOL bDeleteCC = GetColourContext(DisplayModel, &cc); if (cc == NULL) { ERROR2RAW("Can't get a colour context for the DisplayModel!"); return; } INT32 CurrentComponentIndex = 0; // Work out the index of the slider being dragged if (!StartingNewDrag) { switch (DragStartArea) { case CEDRAG_DEFAULT_COMPONENT2: CurrentComponentIndex = 1; break; case CEDRAG_DEFAULT_COMPONENT3: CurrentComponentIndex = 2; break; case CEDRAG_DEFAULT_COMPONENT4: CurrentComponentIndex = 3; break; default: break; } } // Get the slider rectangle widths. The height is fixed/moved during the loop below DocRect SliderRect(0, 0, Info->dx, Info->dy); SliderRect.hi.y -= PATCHSIZE + (PixelSize * 2); // Allow space for the current colour patch // Count how many components we have to display INT32 NumComponents = 0; INT32 ComponentIndex; for (ComponentIndex = 1; ComponentIndex <= 4; ComponentIndex++) { if (cc->GetComponentName(ComponentIndex, NULL)) NumComponents++; } // Calculate slider sizes and spacing INT32 SliderHeight = GetSliderHeight(SliderRect.Height(), NumComponents); INT32 SliderGap = GetSliderGap(SliderRect.Height(), NumComponents); // And move the top down by half a SliderGap, so the sliders are centered vertically SliderRect.hi.y -= SliderGap / 2; // Check the slider for each component supplied in the current DisplayModel for (ComponentIndex = 0; ComponentIndex <= 3; ComponentIndex++) { // Ensure slider rect is the correct height SliderRect.lo.y = SliderRect.hi.y - SliderHeight; // If we are just starting a new drag, we must determine which slider the mouse is // dragging. Otherwise, we need just go round the loop until we find the position // of the correct slider to use (so we can redraw only the changed slider) if (StartingNewDrag) { // If this component is available/used in this colour model, see if we are dragging it if (cc->GetComponentName(ComponentIndex+1, NULL)) { if (SliderRect.ContainsCoord(*(Info->pMousePos))) break; } } else { // We've calculated where the slider rect is now, so we can continue on if (ComponentIndex == CurrentComponentIndex) break; } // Move down to the next slider rectangle position SliderRect.hi.y = SliderRect.lo.y - SliderGap; } // ComponentIndex now contains the index of the component currently being // dragged (or it has the value 4 if no match was found) CurrentComponentIndex = ComponentIndex; if (StartingNewDrag) // Work out which slider we are dragging { switch (CurrentComponentIndex) { case 0: DragStartArea = CEDRAG_DEFAULT_COMPONENT1; break; case 1: DragStartArea = CEDRAG_DEFAULT_COMPONENT2; break; case 2: DragStartArea = CEDRAG_DEFAULT_COMPONENT3; break; case 3: DragStartArea = CEDRAG_DEFAULT_COMPONENT4; break; default: return; // Not dragging anything draggable, so ignore them } } // Now, if the mouse position has changed, calculate the new component value, and // set it, as appropriate for the CurrentComponentIndex component if (StartingNewDrag || Info->pMousePos->x != LastDragPos.x) { INT32 Offset = Info->pMousePos->x; if (Offset < 0) Offset = 0; if (Offset > Info->dx) Offset = Info->dx; ERROR3IF(Info->dx == 0, "Control width is zero! Divide by zero about to occur!"); double NewValue = (double)Offset / (double)Info->dx; ColourPicker::SetComponentFromDouble(EditingColour, cc, CurrentComponentIndex+1, NewValue); // If we are starting a new drag, or if we are in split-slider mode, we redraw everything if (StartingNewDrag || SplitLineDisplay) InvalidateGadget(_R(IDC_EDIT_PICKER)); // Invalidate all sliders else { InvalidateGadget(_R(IDC_EDIT_PICKER), Info, &SliderRect); // Only invalidate changed slider InvalidatePatchGadget(Info); } PaintGadgetNow(_R(IDC_EDIT_PICKER)); } LastDragPos.x = Info->pMousePos->x; LastDragPos.y = 0; // Delete the colour context if necessary if (bDeleteCC) ColourContextList::GetList()->RemoveContext(&cc); // Have finished with it }

void ColourEditDlg::SetNewValueFromMousePos (  ReDrawInfoType *  Info, BOOL  StartingNewDrag )  [protected]

Handles drag updates - determines the new colour values from the current mouse position, and sets the colour as appropriate. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: Info  - The redraw info for the kernel-drawn control's mouse event [INPUTS] This may be NULL if you merely want to check for escape being pressed to abort the drag, but note that if this is the case, all that will be done is the escape check. NOTE that StartingNewDrag MUST also be FALSE in this case. StartingNewDrag - TRUE if this is the first call to this function for a new drag operation (in which case, the DragStartArea is set appropriately) Will also check for escape being pressed, in which case the drag will be aborted, and the colour will return to its pre-drag state. Notes: This will generate an ERROR3 if called with EditingColour==NULL For those who haven't followed the progress of the colour editor, you will soon realise that it is one huge non-OO bodge, which grew from a tiny little thing in fits and starts and design retrofits. One day, I'll be allowed to write it properly, from scratch, instead of just bolting on more and more bits of ticky tacky. Definition at line 7452 of file coldlog.cpp. { if (EditingColour == NULL) // We are shaded - spurious call - shouldn't happen { ERROR3("ColourEditDlg::SetNewValueFromMousePos called when EditingColour == NULL"); return; } if (StartingNewDrag) { DragStartArea = CEDRAG_NONE; // For now, we are not dragging // And copy the original colour in case of an abort // NOTE: If new fails, then this pointer will be NULL, which merely disables abort checks. if (AbortColour != NULL) { delete AbortColour; AbortColour = NULL; } AbortColour = new IndexedColour(*EditingColour); } else { // Continuing a drag we've already started - check for escape being pressed if ((AbortColour != NULL && KeyPress::IsEscapePressed()) || (AbortColour != NULL && EscapeKeyWasPressed)) { // Beep to make user aware they've succeeded in aborting the drag Beep(); // Reset the definition of the EditingColour *EditingColour = *AbortColour; // And reset the drag state variables delete AbortColour; AbortColour = NULL; DragUpdatedOnIdle = FALSE; DragStartArea = CEDRAG_NONE; // Inform the editor of the change, and redraw everything (document and editor) EditingColourHasChanged(TRUE, TRUE, TRUE); InvalidatePatchGadget(); // EndTimedProcessing (); EscapeKeyWasPressed = FALSE; return; } } // If Info was NULL, the caller only wanted to check for the abort (escape) key being pressed if (Info == NULL) return; // Finally, call the appropriate colour model update routine to get the job done... // Yeah, yeah, I know. Where's the objects? Where's the virtual functions? INT32 PixelSize = 72000 / Info->Dpi; // Size of output pixel in millipoints if (EditingColour->GetType() == COLOURTYPE_TINT) { if (EditingColour->TintIsShade()) SetNewValueShade(Info, PixelSize, StartingNewDrag); else SetNewValueTint(Info, PixelSize, StartingNewDrag); } else { switch (DisplayModel) { case COLOURMODEL_HSVT: if (CanSetColour(EditingColour)) SetNewValueHSV(Info, PixelSize, StartingNewDrag); break; case COLOURMODEL_RGBT: case COLOURMODEL_WEBRGBT: // RGB has the ability to change display modes, even when the colour is uneditable // so we call the handler even when CanSetColour() == FALSE if (Use3DDisplay) SetNewValueRGB(Info, PixelSize, StartingNewDrag); else { if (CanSetColour(EditingColour)) SetNewValueDefault(Info, PixelSize, StartingNewDrag); } break; case COLOURMODEL_CMYK: // CMYK has the ability to change display modes, even when the colour is uneditable // so we call the handler even when CanSetColour() == FALSE if (Use3DDisplay) SetNewValueCMYK(Info, PixelSize, StartingNewDrag); else { if (CanSetColour(EditingColour)) SetNewValueDefault(Info, PixelSize, StartingNewDrag); } break; default: if (CanSetColour(EditingColour)) SetNewValueDefault(Info, PixelSize, StartingNewDrag); break; } } }

void ColourEditDlg::SetNewValueHSV (  ReDrawInfoType *  Info, INT32  PixelSize, BOOL  StartingNewDrag )  [protected]

Handles drag updates - determines the new colour values from the current mouse position, and sets the colour as appropriate. Just how it interprets the mouse position is dependant upon which region the drag was started within, and which DisplayMode is in operation. A different routine like this one will be called for each DisplayMode. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/12/94 Parameters: Info  - The redraw info for the kernel-drawn control's mouse event [INPUTS] PixelSize - The size of display pixels as they appear when mapped into the MILLIPOINT VirtualRect coordinate space (as used in the RenderControl methods) StartingNewDrag - TRUE if this is the first call to this function for a new drag operation (in which case, the DragStartArea is set appropriately) See also: ColourEditDlg::SetNewValueFromMousePos; ColourEditDlg::SetNewValueDefault Definition at line 7661 of file coldlog.cpp. { #if TRUE DocRect VirtualSize(0, 0, Info->dx, Info->dy); VirtualSize.Inflate(-PixelSize * 4); // And exclude the border // Calculate the two important rectangles - the hue slider, and Val/Sat square DocRect HueRect; DocRect ValSatSquare; CalculateHSVPickerRects(&VirtualSize, PixelSize, &HueRect, &ValSatSquare); // Get a colour context for our conversions and stuff ColourContext *cc = ColourContext::GetGlobalDefault(COLOURMODEL_HSVT); // Remember the old cross-position values from EditingColour ColourHSVT ColourDef; cc->ConvertColour(EditingColour, (ColourGeneric *) &ColourDef); // If starting a new drag, determine which area the drag is in... if (StartingNewDrag) { if (HueRect.ContainsCoord(*(Info->pMousePos))) DragStartArea = CEDRAG_HSVPICKER_HSLIDER; else if (ValSatSquare.ContainsCoord(*(Info->pMousePos))) { DragStartArea = CEDRAG_HSVPICKER_VSSQUARE; } else { // The user didn't hit inside a picker area, but have they tried to drag // a region outside that lies under a protuding marker cross? FIXED24 ReverseSat = FIXED24(1.0) - ColourDef.Saturation; if (MousePosInCross(Info->pMousePos, &ValSatSquare, &ReverseSat, &ColourDef.Value)) DragStartArea = CEDRAG_HSVPICKER_VSSQUARE; else if (MousePosInCross(Info->pMousePos, &HueRect, &ColourDef.Hue, NULL)) DragStartArea = CEDRAG_HSVPICKER_HSLIDER; else return; // Nope - just ignore the click } // Remember what the colour was as we started the drag cc->ConvertColour(ResultColour, &ColourBeforeDrag); } BOOL ColourHasChanged = FALSE; INT32 XPos=0; INT32 YPos=0; // Handle the new mouse position, using the area the drag started in (rather than // the area it may now be over) to determine which components to alter switch(DragStartArea) { case CEDRAG_HSVPICKER_HSLIDER: { XPos = Info->pMousePos->x - HueRect.lo.x; if (XPos < 0) XPos = 0; if (XPos > HueRect.Width()) XPos = HueRect.Width(); double NewValue = ((double) XPos) / ((double) HueRect.Width()); ColourPicker::SetComponentFromDouble(EditingColour, cc, 1, NewValue); DisplayModel = COLOURMODEL_HSVT; // Force display back to HSV model if (XPos != LastDragPos.x) ColourHasChanged = TRUE; break; } case CEDRAG_HSVPICKER_VSSQUARE: { INT32 Size = ValSatSquare.Width(); XPos = ValSatSquare.hi.x - Info->pMousePos->x; if (XPos < 0) XPos = 0; if (XPos > Size) XPos = Size; if (bHSVHueAtTop) { YPos = Info->pMousePos->y - ValSatSquare.lo.y; if (YPos < 0) YPos = 0; if (YPos > Size) YPos = Size; } else { YPos = ValSatSquare.hi.y - Info->pMousePos->y; if (YPos < 0) YPos = 0; if (YPos > Size) YPos = Size; } double NewSat = ((double)XPos) / ((double) Size); double NewVal = ((double)YPos) / ((double) Size); if (KeyPress::IsConstrainPressed()) { // If we should constrain this value, then we check the original // values for Sat/Val, and we only change the one which is furthest // away from the original value (i.e. if you drag near the old // Saturation value, only the Value will change & vice versa) ColourHSVT *ConstrainDef = (ColourHSVT *) &ColourBeforeDrag; double TempSat = ConstrainDef->Saturation.MakeDouble() - NewSat; if (TempSat < 0.0) TempSat = -TempSat; double TempVal = ConstrainDef->Value.MakeDouble() - NewVal; if (TempVal < 0.0) TempVal = -TempVal; if (TempSat < TempVal) NewSat = ConstrainDef->Saturation.MakeDouble(); else NewVal = ConstrainDef->Value.MakeDouble(); } DisplayModel = COLOURMODEL_HSVT; // Force display back to HSV model ColourPicker::SetComponentFromDouble(EditingColour, cc, 2, NewSat); ColourPicker::SetComponentFromDouble(EditingColour, cc, 3, NewVal); if (StartingNewDrag) ColourHasChanged = TRUE; // Always do full redraw when drag starts else { // --- Invalidate the old cross position DocRect CrossRect(-CROSSRADIUS, -CROSSRADIUS, CROSSRADIUS, CROSSRADIUS); INT32 TransX = ValSatSquare.hi.x - (INT32) ((double)ValSatSquare.Width() * ColourDef.Saturation.MakeDouble()); INT32 TransY = ValSatSquare.lo.y + (INT32) ((double)ValSatSquare.Height() * ColourDef.Value.MakeDouble()); CrossRect.Translate(HalfGridLock(TransX, PixelSize), HalfGridLock(TransY, PixelSize)); // Inflate by 2 pixels (the cross can actually draw marginally outside the crossrect ;-( CrossRect.Inflate(4*PixelSize); InvalidateGadget(_R(IDC_EDIT_PICKER), Info, &CrossRect); // --- And invalidate the new cross position CrossRect = DocRect(-CROSSRADIUS, -CROSSRADIUS, CROSSRADIUS, CROSSRADIUS); cc->ConvertColour(EditingColour, (ColourGeneric *) &ColourDef); TransX = ValSatSquare.hi.x - (INT32) ((double)ValSatSquare.Width() * ColourDef.Saturation.MakeDouble()); TransY = ValSatSquare.lo.y + (INT32) ((double)ValSatSquare.Height() * ColourDef.Value.MakeDouble()); CrossRect.Translate(HalfGridLock(TransX, PixelSize), HalfGridLock(TransY, PixelSize)); // Inflate by 2 pixels (the cross can actually draw marginally outside the crossrect ;-( CrossRect.Inflate(4*PixelSize); InvalidateGadget(_R(IDC_EDIT_PICKER), Info, &CrossRect); PaintGadgetNow(_R(IDC_EDIT_PICKER)); InvalidatePatchGadget(Info); // And leave ColourHasChanged as FALSE so that the code below does not do a ful redraw! } break; } default: return; // Illegal drag -= just ignore it } // If necessary, redraw the picker and the colour patch if (ColourHasChanged || StartingNewDrag) { InvalidateGadget(_R(IDC_EDIT_PICKER)); PaintGadgetNow(_R(IDC_EDIT_PICKER)); } // Remember the last position at which we updated LastDragPos.y = YPos; LastDragPos.x = XPos; #else /* DocRect ValueRect(0, 0, Info->dx, Info->dy); ValueRect.hi.x = HalfGridLock(ValueRect.hi.x, PixelSize); ValueRect.lo.x = HalfGridLock(ValueRect.hi.x - (ValueRect.Width() / 8), PixelSize * 2); // Diameter is the width of the gadget - the value rectangle - a gap INT32 Diameter = Info->dx - ValueRect.Width() - (ValueRect.Width() / 3); if (Diameter > abs(Info->dy)) Diameter = abs(Info->dy); const INT32 Radius = HalfGridLock(Diameter/2, PixelSize); const INT32 MidY = HalfGridLock(abs(Info->dy) / 2, PixelSize); const INT32 MidX = HalfGridLock(0 + Radius, PixelSize); ValueRect.lo.y = MidY - Radius; // Rect only as high as the circle ValueRect.hi.y = MidY + Radius; // Get a colour context for our conversions and stuff ColourContext *cc = ColourContext::GetGlobalDefault(COLOURMODEL_HSVT); // If starting a new drag, determine which area the drag is in... if (StartingNewDrag) { if (ValueRect.ContainsCoord(*(Info->pMousePos))) DragStartArea = CEDRAG_HSVPICKER_VSLIDER; else { DocRect HSRect (ValueRect); HSRect.lo.x = MidX - Radius; HSRect.hi.x = MidX + Radius; // Not in the square containing the HS circle either, so ignore it if (!HSRect.ContainsCoord(*(Info->pMousePos))) return; DragStartArea = CEDRAG_HSVPICKER_HSWHEEL; } // Remember what the colour was as we started the drag cc->ConvertColour(ResultColour, &ColourBeforeDrag); } BOOL ColourHasChanged = FALSE; INT32 XPos; INT32 YPos; // Handle the new mouse position, using the area the drag started in (rather than // the area it may now be over) to determine which components to alter switch(DragStartArea) { case CEDRAG_HSVPICKER_VSLIDER: { YPos = Info->pMousePos->y - ValueRect.lo.y; if (YPos < 0) YPos = 0; if (YPos > Diameter) YPos = Diameter; double NewValue = ((double) YPos) / ((double) Diameter); ColourPicker::SetComponentFromDouble(EditingColour, cc, 3, NewValue); DisplayModel = COLOURMODEL_HSVT; // Force display back to HSV model if (YPos != LastDragPos.y) ColourHasChanged = TRUE; break; } case CEDRAG_HSVPICKER_HSWHEEL: { YPos = Info->pMousePos->y - MidY; if (YPos < -Radius) YPos = -Radius; if (YPos > Radius) YPos = Radius; XPos = Info->pMousePos->x - MidX; if (XPos < -Radius) XPos = -Radius; if (XPos > Radius) XPos = Radius; double Temp = (double) XPos; // NewSat = sqrt(X^2 + Y^2) double NewSat = Temp * Temp; Temp = (double) YPos; NewSat += Temp * Temp; NewSat = sqrt(NewSat) / Radius; if (NewSat > 1.0) // Clip to within gamut NewSat = 1.0; double NewHue = 0.25; // (90 degrees of hue) in 0.0-1.0 space if (YPos == 0) { if (XPos < 0) NewHue = 0.75; // (270 degrees of hue) in 0.0-1.0 space // (else it is 0.25, the default from above) } else { // Get angle (in radians) within the 0 to (PI/2) quadrant NewHue = atan( fabs( ((double)XPos) / ((double)YPos) ) ); // And fix the angle into the appropriate quadrant... if (YPos < 0) NewHue = PI - NewHue; if (XPos < 0) NewHue = (2.0 * PI) - NewHue; // And convert 0 to 2PI radians value into a 0.0 to 1.0 Hue value NewHue /= 2.0 * PI; } if (KeyPress::IsConstrainPressed()) { // If we should constrain this value, then we check the original // values for Hue/Sat, and we only change the one which is furthest // away from the original value (i.e. if you drag near the old // Saturation value, only the Hue will change & vice versa) ColourHSVT *ConstrainDef = (ColourHSVT *) &ColourBeforeDrag; // NOTE: // The desired behaviour has several strange consequences // The "distance" from the old value should be the same on-screen // distance (e.g. 5 pixels around the circular Hue arc should be // the same as 5 pixels along the linear saturation radial. // Also, Hue wraps back around (1.0 is adjacent to 0.0) so we need to // take the "closest" direction around the circle! // Thus, we find the difference in hue, taking the shortest route, and // turn it into the (0 to PI) range. // This is compared to a value of (0 to 1.0) for saturation // Get Hue distance in terms of 0..PI Temp = NewHue - ConstrainDef->Hue.MakeDouble(); if (Temp < 0.0) Temp = -Temp; // Ensure difference is positive if (Temp > 1.0) // "Out of Gamut", so make distance = 0 Temp = 0.0; else { if (Temp >= 0.5) // Ensure difference is shortest distance Temp = 1.0 - Temp; // around the circle Temp *= PI; // And get as a 0..PI value } // Get Saturation in the range 0.0 to 1.0 double TempSat = NewSat - ConstrainDef->Saturation.MakeDouble(); if (TempSat < 0.0) TempSat = -TempSat; // Ensure difference is positive if (TempSat > 1.0) // Ensure it is clipped at 1.0 TempSat = 1.0; // Finally, if the saturation difference is larger than the Hue // difference, then lock the hue, else lock the saturation if (TempSat > Temp) NewHue = ConstrainDef->Hue.MakeDouble(); else NewSat = ConstrainDef->Saturation.MakeDouble(); } DisplayModel = COLOURMODEL_HSVT; // Force display back to HSV model if (!StartingNewDrag) // When starting a new drag we always do a complete redraw { // Get the old cross-position values from EditingColour ColourHSVT ColourDef; cc->ConvertColour(EditingColour, (ColourGeneric *) &ColourDef); // Set the new values ColourPicker::SetComponentFromDouble(EditingColour, cc, 1, NewHue); ColourPicker::SetComponentFromDouble(EditingColour, cc, 2, NewSat); // --- Invalidate the old cross position // RedrawSize gives the 'radius' of the cross rectangle to redraw. NOTE however, // that the cross lines can move up to 1 pixel outside the CrossRect, so we have to // invalidate one pixel more, just to make sure we always get the bugger! INT32 RedrawSize = CROSSRADIUS + (PixelSize * 2); DocRect CrossRect(-RedrawSize, -RedrawSize, RedrawSize, RedrawSize); // Convert Hue (0.0 -> 1.0) into an angle in radians (0 -> 2Pi) double theta = 2.0 * PI * ColourDef.Hue.MakeDouble(); // Convert Saturation into a distance from the center of the colour wheel double length = (double)Radius * ColourDef.Saturation.MakeDouble(); // Translate the cross to the polar coordinate (theta, length) CrossRect.Translate(HalfGridLock(MidX + (INT32)(length * sin(theta)), PixelSize), HalfGridLock(MidY + (INT32)(length * cos(theta)), PixelSize)); InvalidateGadget(_R(IDC_EDIT_PICKER), Info, &CrossRect); // --- Now invalidate the new cross position CrossRect = DocRect(-RedrawSize, -RedrawSize, RedrawSize, RedrawSize); // Convert Hue (0.0 -> 1.0) into an angle in radians (0 -> 2Pi) theta = 2.0 * PI * NewHue; // Convert Saturation into a distance from the center of the colour wheel length = (double)Radius * NewSat; // Translate the cross to the polar coordinate (theta, length) CrossRect.Translate(HalfGridLock(MidX + (INT32)(length * sin(theta)), PixelSize), HalfGridLock(MidY + (INT32)(length * cos(theta)), PixelSize)); InvalidateGadget(_R(IDC_EDIT_PICKER), Info, &CrossRect); // And finally, invalidate the value slider rectangle InvalidateGadget(_R(IDC_EDIT_PICKER), Info, &ValueRect); PaintGadgetNow(_R(IDC_EDIT_PICKER)); InvalidatePatchGadget(Info); // We leave "ColourHasChanged" FALSE here so that it doesn't force redraw // everything again, below! } else { ColourPicker::SetComponentFromDouble(EditingColour, cc, 1, NewHue); ColourPicker::SetComponentFromDouble(EditingColour, cc, 2, NewSat); ColourHasChanged = TRUE; } break; } default: return; // Illegal drag -= just ignore it } // If necessary, redraw the picker and the colour patch if (ColourHasChanged || StartingNewDrag) { InvalidateGadget(_R(IDC_EDIT_PICKER)); PaintGadgetNow(_R(IDC_EDIT_PICKER)); } // Remember the last position at which we updated LastDragPos.y = YPos; LastDragPos.x = XPos; */ #endif }

void ColourEditDlg::SetNewValueRGB (  ReDrawInfoType *  Info, INT32  PixelSize, BOOL  StartingNewDrag )  [protected]

Handles drag updates - determines the new colour values from the current mouse position, and sets the colour as appropriate. Just how it interprets the mouse position is dependant upon which region the drag was started within, and which DisplayMode is in operation. A different routine like this one will be called for each DisplayMode. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 23/12/94 Parameters: Info  - The redraw info for the kernel-drawn control's mouse event [INPUTS] PixelSize - The size of display pixels as they appear when mapped into the MILLIPOINT VirtualRect coordinate space (as used in the RenderControl methods) StartingNewDrag - TRUE if this is the first call to this function for a new drag operation (in which case, the DragStartArea is set appropriately) Notes: The RGB and CMYK pickers are almost identical in operation. It should be possible to tidy up the code considerably and make a generic routine for handling most of the common stuff. See also: ColourEditDlg::SetNewValueFromMousePos; ColourEditDlg::SetNewValueDefault Definition at line 8117 of file coldlog.cpp. { // Fill the control background, and calculate the cube params (without redraw) DocRect VirtualSize(0, 0, Info->dx, Info->dy); VirtualSize.Inflate(-PixelSize * 4); // And exclude the border DocRect SquareRect; INT32 SizeZ; DrawCubeShadowAndCalcValues(NULL, &VirtualSize, PixelSize, NULL, /* TO */ &SquareRect, &SizeZ); DocRect CubeFaceRect(SquareRect); // Remember the rect of the front face for below // Now, shift the square down from the front of the cube by an amount appropriate to // the Z-axis component of the colour ColourContextRGBT *cc = (ColourContextRGBT *) ColourContext::GetGlobalDefault(COLOURMODEL_RGBT); ColourRGBT SourceColour; if (EditingColour != NULL) cc->ConvertColour(EditingColour, (ColourGeneric *) &SourceColour); if (CanSetColour(EditingColour)) { FIXED24 ZComponent = SourceColour.Blue; if (ColourPickerMode == 1) ZComponent = SourceColour.Green; else if (ColourPickerMode == 2) ZComponent = SourceColour.Red; INT32 ZTrans = (INT32) ((double)SizeZ * ZComponent.MakeDouble()) - SizeZ; SquareRect.Translate(-ZTrans, ZTrans); GridLockRect(&SquareRect, PixelSize); } if (StartingNewDrag) { // Remember what the colour was as we started the drag cc->ConvertColour(ResultColour, &ColourBeforeDrag); DocCoord BitmapPos; BitmapPos.x = HalfGridLock(CubeFaceRect.hi.x + SizeZ/2, PixelSize); BitmapPos.y = HalfGridLock(CubeFaceRect.hi.y - SizeZ/2, PixelSize); const INT32 BitmapSize = 14 * PixelSize; DocRect SwapAxesRect(BitmapPos.x, BitmapPos.y, BitmapPos.x + BitmapSize + PixelSize * 3, BitmapPos.y + BitmapSize); GridLockRect(&SwapAxesRect, PixelSize); if (SwapAxesRect.ContainsCoord(*(Info->pMousePos))) { // Swap the axes around - this is treated as a click (the rest of the drag ignored) DragStartArea = CEDRAG_NONE; ColourPickerMode = (ColourPickerMode + 1) % 3; InvalidateGadget(_R(IDC_EDIT_PICKER)); return; } if (SquareRect.ContainsCoord(*(Info->pMousePos))) DragStartArea = CEDRAG_RGBPICKER_XY; else { // Check if the pointer is in the Z 'drag button' DocRect ZButton(SquareRect); ZButton.lo.x = ZButton.hi.x; ZButton.hi.x += ZSLIDERSIZE - (PixelSize * 2); ZButton.hi.y = ZButton.lo.y; ZButton.lo.y -= ZSLIDERSIZE - (PixelSize * 2); GridLockRect(&ZButton, PixelSize); if (ZButton.ContainsCoord(*(Info->pMousePos))) { DragStartArea = CEDRAG_RGBPICKER_Z; // And remember the offset from the bottom right of the handle to the dragged point DragAnchor.x = Info->pMousePos->x - ZButton.lo.x; DragAnchor.y = Info->pMousePos->y - ZButton.hi.y; } else { // OK, then. Is the click in a protuding bit of the marker cross? DocRect CrossRect; CalcCrossRectRGB(&SourceColour, &SquareRect, PixelSize, &CrossRect); if (CrossRect.ContainsCoord(*(Info->pMousePos))) DragStartArea = CEDRAG_RGBPICKER_XY; } } } if (!CanSetColour(EditingColour)) // We can't change the colour - abort { DragStartArea = CEDRAG_NONE; return; } BOOL ColourHasChanged = TRUE; INT32 XPos = Info->pMousePos->x; INT32 YPos = Info->pMousePos->y; switch(DragStartArea) { case CEDRAG_RGBPICKER_XY: { if (XPos < SquareRect.lo.x) XPos = SquareRect.lo.x; if (XPos > SquareRect.hi.x) XPos = SquareRect.hi.x; if (YPos < SquareRect.lo.y) YPos = SquareRect.lo.y; if (YPos > SquareRect.hi.y) YPos = SquareRect.hi.y; INT32 XComponent = 2; // XYZ = G,R,B INT32 YComponent = 1; switch(ColourPickerMode) { case 1: // XYZ = R,B,G XComponent = 1; YComponent = 3; break; case 2: // XYZ = B,G,R XComponent = 3; YComponent = 2; break; } double NewX = ((double) (XPos - SquareRect.lo.x)) / ((double) SquareRect.Width()); if (NewX < 0.0) NewX = 0.0; if (NewX > 1.0) NewX = 1.0; double NewY = ((double) (YPos - SquareRect.lo.y)) / ((double) SquareRect.Height()); if (NewY < 0.0) NewY = 0.0; if (NewY > 1.0) NewY = 1.0; if (KeyPress::IsConstrainPressed()) { // ColourRGBT *ConstrainDef = (ColourRGBT *) &ColourBeforeDrag; double XDiff = GetComponent(&ColourBeforeDrag, XComponent).MakeDouble() - NewX; double YDiff = GetComponent(&ColourBeforeDrag, YComponent).MakeDouble() - NewY; if (XDiff < 0) XDiff = -XDiff; if (YDiff < 0) YDiff = -YDiff; if (XDiff < YDiff) NewX = GetComponent(&ColourBeforeDrag, XComponent).MakeDouble(); else NewY = GetComponent(&ColourBeforeDrag, YComponent).MakeDouble(); } // Set the new values ColourPicker::SetComponentFromDouble(EditingColour, cc, XComponent, NewX); ColourPicker::SetComponentFromDouble(EditingColour, cc, YComponent, NewY); DisplayModel = COLOURMODEL_RGBT; // Force display back to RGB model if (!StartingNewDrag) { // Redraw the area where the cross used to be shown DocRect CrossRect; CalcCrossRectRGB(&SourceColour, &SquareRect, PixelSize, &CrossRect); CrossRect.Inflate(4*PixelSize); // Inflate to ensure we redraw all of the cross InvalidateGadget(_R(IDC_EDIT_PICKER), Info, &CrossRect); // And force redraw the new cross position cc->ConvertColour(EditingColour, (ColourGeneric *) &SourceColour); CalcCrossRectRGB(&SourceColour, &SquareRect, PixelSize, &CrossRect); CrossRect.Inflate(4*PixelSize); // Inflate to ensure we redraw all of the cross InvalidateGadget(_R(IDC_EDIT_PICKER), Info, &CrossRect); // Redraw the controls... InvalidatePatchGadget(Info); PaintGadgetNow(_R(IDC_EDIT_PICKER)); // And clear this flag so that the redraw below (of entire gadget) is not done. ColourHasChanged = FALSE; } } break; case CEDRAG_RGBPICKER_Z: { XPos -= DragAnchor.x; // Correct the mouse position for anchoring YPos -= DragAnchor.y; INT32 ZComponent = 3; // XYZ = G,R,B switch(ColourPickerMode) { case 1: // XYZ = R,B,G ZComponent = 2; break; case 2: // XYZ = B,G,R ZComponent = 1; break; } INT32 Offset = CubeFaceRect.hi.x + SizeZ - XPos; if (Offset > YPos - (CubeFaceRect.lo.y - SizeZ)) Offset = YPos - (CubeFaceRect.lo.y - SizeZ); double NewZ = ((double) Offset) / ((double) SizeZ); if (NewZ < 0.0) NewZ = 0.0; if (NewZ > 1.0) NewZ = 1.0; DisplayModel = COLOURMODEL_RGBT; // Force display back to RGB model ColourPicker::SetComponentFromDouble(EditingColour, cc, ZComponent, NewZ); } break; default: return; // Not a legal drag, so we ignore it } // If necessary, redraw the entire colour picker control and the colour patch if (ColourHasChanged) { if (StartingNewDrag || YPos != LastDragPos.y || XPos != LastDragPos.x) { InvalidateGadget(_R(IDC_EDIT_PICKER)); PaintGadgetNow(_R(IDC_EDIT_PICKER)); } } // Remember the last position at which we updated LastDragPos.y = YPos; LastDragPos.x = XPos; }

void ColourEditDlg::SetNewValueShade (  ReDrawInfoType *  Info, INT32  PixelSize, BOOL  StartingNewDrag )  [protected]

Handles drag updates - determines the new colour values from the current mouse position, and sets the colour as appropriate. Just how it interprets the mouse position is dependant upon which region the drag was started within, and which DisplayMode is in operation. A different routine like this one will be called for each DisplayMode. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 13/10/95 Parameters: Info  - The redraw info for the kernel-drawn control's mouse event [INPUTS] PixelSize - The size of display pixels as they appear when mapped into the MILLIPOINT VirtualRect coordinate space (as used in the RenderControl methods) StartingNewDrag - TRUE if this is the first call to this function for a new drag operation (in which case, the DragStartArea is set appropriately) See also: ColourEditDlg::SetNewValueFromMousePos; ColourEditDlg::SetNewValueDefault Definition at line 8953 of file coldlog.cpp. { DocRect VirtualSize(0, 0, Info->dx, Info->dy); VirtualSize.Inflate(-PixelSize * 4); // And exclude the border // Calculate the two important rectangles - the hue slider, and Val/Sat square DocRect HueRect; DocRect ValSatSquare; CalculateHSVPickerRects(&VirtualSize, PixelSize, &HueRect, &ValSatSquare); // Get a colour context for our conversions and stuff ColourContext *cc = ColourContext::GetGlobalDefault(COLOURMODEL_HSVT); // Remember the old cross-position values from EditingColour ColourHSVT ColourDef; cc->ConvertColour(EditingColour, (ColourGeneric *) &ColourDef); // If starting a new drag, determine which area the drag is in... if (StartingNewDrag) { if (!ValSatSquare.ContainsCoord(*(Info->pMousePos))) { // The user didn't hit inside a picker area, but have they tried to drag // a region outside that lies under a protuding marker cross? FIXED24 ReverseSat = FIXED24(1.0) - ColourDef.Saturation; if (!MousePosInCross(Info->pMousePos, &ValSatSquare, &ReverseSat, &ColourDef.Value)) return; // Nope - just ignore the click } DragStartArea = CEDRAG_HSVPICKER_VSSQUARE; // Remember what the colour was as we started the drag cc->ConvertColour(ResultColour, &ColourBeforeDrag); } BOOL ColourHasChanged = FALSE; INT32 XPos; INT32 YPos; // Handle the new mouse position, using the area the drag started in (rather than // the area it may now be over) to determine which components to alter switch(DragStartArea) { case CEDRAG_HSVPICKER_VSSQUARE: { INT32 Size = ValSatSquare.Width(); XPos = ValSatSquare.hi.x - Info->pMousePos->x; if (XPos < 0) XPos = 0; if (XPos > Size) XPos = Size; YPos = Info->pMousePos->y - ValSatSquare.lo.y; if (YPos < 0) YPos = 0; if (YPos > Size) YPos = Size; double NewSat = ((double)XPos) / ((double) Size); double NewVal = ((double)YPos) / ((double) Size); ColourHSVT ParentDef; cc->ConvertColour(EditingColour->FindLastLinkedParent(), (ColourGeneric *) &ParentDef); if (KeyPress::IsConstrainPressed()) { // If we should constrain this value, then we check the original // values for Sat/Val, and we only change the one which is furthest // away from the original value (i.e. if you drag near the old // Saturation value, only the Value will change & vice versa) // Shades constrain to their *parent* colour rather than their last definition ColourHSVT *ConstrainDef = &ParentDef; //(ColourHSVT *) &ColourBeforeDrag; double TempSat = ConstrainDef->Saturation.MakeDouble() - NewSat; if (TempSat < 0.0) TempSat = -TempSat; double TempVal = ConstrainDef->Value.MakeDouble() - NewVal; if (TempVal < 0.0) TempVal = -TempVal; if (TempSat < TempVal) NewSat = ConstrainDef->Saturation.MakeDouble(); else NewVal = ConstrainDef->Value.MakeDouble(); } FIXED24 NewX(0.0); FIXED24 NewY(0.0); // Work out saturation scaling factor double ParentVal = ParentDef.Saturation.MakeDouble(); if (ParentVal > NewSat) { if (ParentVal > 0.0) NewX = -((ParentVal - NewSat) / ParentVal); } else { if (ParentVal < 1.0) NewX = (NewSat - ParentVal) / (1.0 - ParentVal); } // Work out Value scaling factor ParentVal = ParentDef.Value.MakeDouble(); if (ParentVal > NewVal) { if (ParentVal > 0.0) NewY = -((ParentVal - NewVal) / ParentVal); } else { if (ParentVal < 1.0) NewY = (NewVal - ParentVal) / (1.0 - ParentVal); } EditingColour->SetShadeValues(NewX, NewY); if (StartingNewDrag) ColourHasChanged = TRUE; // Always do full redraw when drag starts else { // --- Invalidate the old cross position DocRect CrossRect(-CROSSRADIUS, -CROSSRADIUS, CROSSRADIUS, CROSSRADIUS); INT32 TransX = ValSatSquare.hi.x - (INT32) ((double)ValSatSquare.Width() * ColourDef.Saturation.MakeDouble()); INT32 TransY = ValSatSquare.lo.y + (INT32) ((double)ValSatSquare.Height() * ColourDef.Value.MakeDouble()); CrossRect.Translate(HalfGridLock(TransX, PixelSize), HalfGridLock(TransY, PixelSize)); // Inflate by 2 pixels (the cross can actually draw marginally outside the crossrect ;-( CrossRect.Inflate(4*PixelSize); InvalidateGadget(_R(IDC_EDIT_PICKER), Info, &CrossRect); // --- And invalidate the new cross position CrossRect = DocRect(-CROSSRADIUS, -CROSSRADIUS, CROSSRADIUS, CROSSRADIUS); cc->ConvertColour(EditingColour, (ColourGeneric *) &ColourDef); TransX = ValSatSquare.hi.x - (INT32) ((double)ValSatSquare.Width() * ColourDef.Saturation.MakeDouble()); TransY = ValSatSquare.lo.y + (INT32) ((double)ValSatSquare.Height() * ColourDef.Value.MakeDouble()); CrossRect.Translate(HalfGridLock(TransX, PixelSize), HalfGridLock(TransY, PixelSize)); // Inflate by 2 pixels (the cross can actually draw marginally outside the crossrect ;-( CrossRect.Inflate(4*PixelSize); InvalidateGadget(_R(IDC_EDIT_PICKER), Info, &CrossRect); PaintGadgetNow(_R(IDC_EDIT_PICKER)); InvalidatePatchGadget(Info); // And leave ColourHasChanged as FALSE so that the code below does not do a ful redraw! } break; } default: return; // Illegal drag -= just ignore it } // If necessary, redraw the picker and the colour patch if (ColourHasChanged || StartingNewDrag) { InvalidateGadget(_R(IDC_EDIT_PICKER)); PaintGadgetNow(_R(IDC_EDIT_PICKER)); } // Remember the last position at which we updated LastDragPos.y = YPos; LastDragPos.x = XPos; }

void ColourEditDlg::SetNewValueTint (  ReDrawInfoType *  Info, INT32  PixelSize, BOOL  StartingNewDrag )  [protected]

Handles drag updates - determines the new colour values from the current mouse position, and sets the colour as appropriate. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 2/10/95 Parameters: Info  - The redraw info for the kernel-drawn control's mouse event [INPUTS] PixelSize - The size of display pixels as they appear when mapped into the MILLIPOINT VirtualRect coordinate space (as used in the RenderControl methods) StartingNewDrag - TRUE if this is the first call to this function for a new drag operation (in which case, the DragStartArea is set appropriately) Handles drags when editing Tints and Shades. See also: ColourEditDlg::SetNewValueFromMousePos; ColourEditDlg::SetNewValueDefault; ColourEditDlg::RenderPickerDefault Definition at line 8869 of file coldlog.cpp. { ERROR3IF(EditingColour->GetType() != COLOURTYPE_TINT, "ColourEditDlg::SetNewValuTint called on non-tint/shade colour!"); // Calculate the slider rectangle const INT32 SliderHeight = 18000; DocRect SliderRect(0, 0, Info->dx, Info->dy); SliderRect.Inflate(0, -(Info->dy - SliderHeight) / 2); if (StartingNewDrag) // Work out which slider we are dragging { if (!SliderRect.ContainsCoord(*(Info->pMousePos))) return; DragStartArea = CEDRAG_TINTORSHADE; } // Now, if the mouse position has changed, calculate the new component value, and // set it, as appropriate for the CurrentComponentIndex component if (StartingNewDrag || Info->pMousePos->x != LastDragPos.x) { INT32 Offset = Info->pMousePos->x; if (Offset < 0) Offset = 0; if (Offset > Info->dx) Offset = Info->dx; ERROR3IF(Info->dx == 0, "Control width is zero! Divide by zero about to occur!"); double NewValue = (double)Offset / (double)Info->dx; NewValue += 1.0 / ((double) (1<<25)); // Clip to lie within gamut if (NewValue < 0.0) NewValue = 0.0; if (NewValue > 1.0) NewValue = 1.0; FIXED24 NewValue24(NewValue); EditingColour->SetTintValue(NewValue24); // If we are starting a new drag, or if we are in split-slider mode, we redraw everything if (StartingNewDrag) InvalidateGadget(_R(IDC_EDIT_PICKER)); // Invalidate all sliders else { InvalidateGadget(_R(IDC_EDIT_PICKER), Info, &SliderRect); // Only invalidate changed slider area InvalidatePatchGadget(Info); } PaintGadgetNow(_R(IDC_EDIT_PICKER)); } LastDragPos.x = Info->pMousePos->x; LastDragPos.y = 0; }

BOOL ColourEditDlg::SetUnitGroupDefaults (  ColourModel  ColModel  )  [static, protected]

Sets the default ScaleUnits for the Colour Editor (actually sets StandardUnit groups. Author: Colin_Barfoot (Xara Group Ltd) <camelotdev@xara.com> Date: 02/05/96 Imputs: ColModel = colour model we're editing (for WEBSTER - markn 9/1/97) Returns: Errors: ERROR3 if unable to initialize defaults Scope: static See also: class StandardUnit Definition at line 608 of file coldlog.cpp. { // WEBSTER - markn 9/1/97 // Rather than get the unit preference from the units tab (which doesn't exist in Webster) // it chooses between percent ('%') and 0-255 ('d') unit types dependant on the colour model. // HSV shows its values in '%' format // RGB shows its values in 0-255 format // #ifdef WEBSTER // WEBSTER - markn 23/1/97 // We've decided to make both models use percentages as the default unit type ScaleUnit* pUnit = StandardUnit::PercentGroup.FindUnitFromIndex(0); // percentage '%' #else ScaleUnit* pUnit = UnitsTab::GetColourUnitPreference(); #endif // WEBSTER if (pUnit == NULL || !pUnit->IS_KIND_OF(ScaleUnit)) { ERROR3("Failed to get a default unit"); return FALSE; } StandardUnit::PercentGroup.SetDefaultUnit(pUnit); StandardUnit::AngleGroup.SetDefaultUnit(&StandardUnit::UnitDegree); return TRUE; }

void ColourEditDlg::ShadeMyself (  BOOL  UnShade = FALSE, BOOL  OtherGadgetsOnly = FALSE )  [protected]

Shades/Unshades the colour editor dialogue. Used to shade the dialogue while there is nothing available to edit, and return it to a useful state when something becomes available for editing. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 6/12/94 Parameters: UnShade  - FALSE to shade, TRUE to un-shade the dialogue [INPUTS] OtherGadgetsOnly - FALSE to shade all gadgets. TRUE to only shade the 'ordinary' gadgets (those which are nothing to do with tint/link stuff) -  [OUTPUTS] Returns: - Definition at line 2530 of file coldlog.cpp. { if (AmShaded != UnShade) // Already in the required state. Leave it alone return; State.ParentListOK = FALSE; // Ensure we update parent list AmShaded = (UnShade) ? FALSE : TRUE; if (AmShaded) { if (EditingColour != NULL) delete EditingColour; EditingColour = NULL; ResultColour = NULL; ParentList = NULL; if (NameDropDown != NULL) { NameDropDown->ClearList(); NameDropDown->ClearAllSpecialEntries(); } if (ParentDropDown != NULL) ParentDropDown->ClearList(); } INT32 i = 0; while (OtherGadgetIDs[i]) { EnableGadget(OtherGadgetIDs[i], UnShade); i++; } // Force-redraw the colour patches and picker InvalidateGadget(_R(IDC_EDIT_PICKER)); // if (AmShaded) // If we are shading the dialogue, set the colour name to 'No colour' // SetStringGadgetValue(_R(IDC_EDIT_NAMEMENU), _R(IDS_NOCOLOUR), FALSE, -1); if (OtherGadgetsOnly) // Don't do tint/link gadgets - return now return; i = 0; while (TintGadgetIDs[i]) { EnableGadget(TintGadgetIDs[i], UnShade); i++; } i = 0; while (LinkGadgetIDs[i]) { EnableGadget(LinkGadgetIDs[i], UnShade); i++; } }

BOOL ColourEditDlg::ShouldUngrey (  IndexedColour *  pCol  )  [protected]

void ColourEditDlg::StartDrag (  ReDrawInfoType *  Info  )  [protected]

Starts a drag from the colour picker control in the colour editor window. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: Info  - The mouse-position information from the control [INPUTS] Notes: May be called when EditingColour is NULL (the window is shaded) Definition at line 6949 of file coldlog.cpp. { if (DragStartArea != CEDRAG_NONE) // We are already dragging! Ignore it return; // Lob away the input focus again - put it back into the mainframe LoseFocusFromEditControls = TRUE; LoseKeyboardFocus(); LoseFocusFromEditControls = FALSE; // Check if the drag is starting from a colour patch if (ParentList != NULL && EditingColour != NULL && ResultColour != NULL && !AmShaded) { //OldMousePos = *(Info->pMousePos); //HideGadget (_R(IDC_COLOURPICKER), TRUE); //CWindowID hwndColPick = DialogManager::GetGadget (GetReadWriteWindowID (), _R(IDC_COLOURPICKER)); //ASSERT (hwndColPick); //ShowWindow (hwndColPick, SW_HIDE); INT32 PixelSize = 72000 / Info->Dpi; // Size of output pixel in millipoints DocRect VirtualSize(0, 0, Info->dx, Info->dy); VirtualSize.Inflate(-PixelSize * 4); // Now draw the original/current colour patch in the top right corner DocRect PatchRect(VirtualSize); PatchRect.lo.x = PatchRect.hi.x - PATCHSIZE; PatchRect.lo.y = PatchRect.hi.y - PATCHSIZE; GridLockRect(&PatchRect, PixelSize); BOOL HorzPatch = (DisplayModel != COLOURMODEL_HSVT); // But this setting is overridden for the special tint and shade modes if (EditingColour != NULL && EditingColour->GetType() == COLOURTYPE_TINT) { if (EditingColour->TintIsShade()) HorzPatch = FALSE; else HorzPatch = TRUE; } INT32 InPatch = 0; if (PatchRect.ContainsCoord(*(Info->pMousePos))) InPatch = 1; else { if (HorzPatch) PatchRect.Translate(-PATCHSIZE, 0); else PatchRect.Translate(0, -PATCHSIZE); if (PatchRect.ContainsCoord(*(Info->pMousePos))) InPatch = 2; } if (InPatch != 0) { // Invert the logic of Horz in 1 case, so it is FALSE (original colour) or TRUE (current colour) if (InPatch == 1) HorzPatch = !HorzPatch; // It was in one of the 2 patches IndexedColour *TheColour = ResultColour; // Default to current colour if (HorzPatch) { TheColour = new IndexedColour(OriginalColour); // They are dragging original colour if (TheColour != NULL) { TheColour->SetUnnamed(); // Ensure we don't get a memory leak ParentList->AddItem(TheColour); } } if (TheColour != NULL) // If have colour to drag, drag it { ColEditorDragInfo *DragCol; DragCol = new ColEditorDragInfo(TheColour, FALSE, (Document *)ParentList->GetParentDocument()); DragManagerOp::StartDrag(DragCol, GetReadWriteWindowID()); } return; // Don't pass the call on to the picker } } // Pass the click/drag onto the appropriate colour picker, and start a picker drag DragUpdatedOnIdle = FALSE; if (EditingColour != NULL && !AmShaded) { // SetColour(FALSE); // Ensure name updated (the name control doesn't lose // kbd focus in this case, so we must force it) SetNewValueFromMousePos(Info, TRUE); // If we started dragging, then register for idle-event updates // (first, ensuring that we are not already on the list) EndTimedProcessing(); if (DragStartArea != CEDRAG_NONE) BeginTimedProcessing(); } }

BOOL ColourEditDlg::StartingPickerDrag (   )

BOOL ColourEditDlg::TimedProcessing (  void   )  [virtual]

Definition at line 7079 of file coldlog.cpp. { return (UpdateColourEditor ()); }

BOOL ColourEditDlg::UpdateColourEditor (   )

This function was originally was a override of the virtual OnIdle() function and was called whist the process had idle time to spare, which slowed down every other process on the computer. This function was modified and renamed so that it is now called by timer messages at fixed periods. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 1/12/94 Parameters: -  [INPUTS] Returns: Used during drags to detect when the mouse has stopped moving (we won't get idle events unless we have finished updating displays, etc) When we find idle time, we start a complete update of the colour window and the document, rather than the normal during-drag minimal updates. Notes: May be called when EditingColour is NULL (the window is shaded). See also: ColourEditDlg::BeginTimedProcessing, ColourEditDlg::EndTimedProcessing Definition at line 7109 of file coldlog.cpp. { // Ensure the focus is shunted back to the document (during a drag, and also after // the window has been moved) // if (LoseKbdFocusPending) // LoseKeyboardFocus(); // If something has changed while the program was busy, we will have flagged the fact // that we should update as soon as the busy job is finished and we start getting idles // once again. We find a safe colour to edit. (This usually happens when we load or swap // docs. This mechanism allows many changes to occur during loading while only triggering // one final colour editor redraw) if (UpdateOnNextIdle) { UpdateOnNextIdle = FALSE; FindUsefulColourToEdit(EditingLineColour); // Try to find a new colour to edit if (EditingColour == NULL) // We failed - shade the dialogue ShadeMyself(); return(FALSE); } // If we're not dragging, then update bubble help and stuff, and return if (DragStartArea == CEDRAG_NONE) { ColourPicker::UpdateBubbleHelpAndPointer(); return(FALSE); // Let low-priority idle handlers get a look in } // Otherwise we are dragging... // Check for escape being pressed if (AbortColour != NULL) { // Call SetNewValueFromMousePos to handle escape being pressed SetNewValueFromMousePos(NULL, FALSE); if (DragStartArea == CEDRAG_NONE) // Has the drag now been aborted? return(FALSE); // Yup, so exit } // If we've already updated on an idle and the mouse has not yet moved again, then // we won't bother with unnecessary redraws and suchlike. if (DragUpdatedOnIdle) return(FALSE); // Let low-priority idle handlers get a look in if (DragStartArea != CEDRAG_NONE && EditingColour != NULL) { // Flag that we have updated on an idle event - we won't respond to idles // again until another drag update occurs (as until a drag update occurs, there // can be no change in the colour) DragUpdatedOnIdle = TRUE; // Force complete update of the window and document, etc EditingColourHasChanged(TRUE, TRUE, TRUE); // The above call explicitly does not redraw the picker - it should be up to // date anyway, so why bother? However, the parent patch does need redrawing. InvalidatePatchGadget(); return(TRUE); // Don't waste any time on low-priority idle handlers this time around } // Deregister for idles, because we should not be getting them now // GetApplication()->RemoveIdleProcessor(IDLEPRIORITY_HIGH, this); // Leave idles on for bubble help return(FALSE); // And let the low-priority idle handlers do their stuff }

void ColourEditDlg::UpdateDrag (  ReDrawInfoType *  Info  )  [protected]

Updates during a drag from the colour picker control in the colour editor window. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 30/11/94 Parameters: Info  - The mouse-position information from the control [INPUTS] Notes: May be called when EditingColour is NULL (the window is shaded) Definition at line 7069 of file coldlog.cpp. { DragUpdatedOnIdle = FALSE; if (DragStartArea != CEDRAG_NONE && EditingColour != NULL && !AmShaded) { SetNewValueFromMousePos(Info, FALSE); } }

---

Friends And Related Function Documentation

friend class ColEditorDragTarget [friend]

Definition at line 216 of file coldlog.h.

friend class ColourPicker [friend]

Definition at line 217 of file coldlog.h.

friend class OpColEditCommand [friend]

Definition at line 218 of file coldlog.h.

---

Member Data Documentation

IndexedColour* ColourEditDlg::AbortColour [protected]

Definition at line 382 of file coldlog.h.

AbortColourState ColourEditDlg::abortColourState [static, protected]

Definition at line 293 of file coldlog.h.

BOOL ColourEditDlg::AmShaded [protected]

Definition at line 339 of file coldlog.h.

INT32 ColourEditDlg::AutoModelChange = FALSE [static, protected]

Definition at line 283 of file coldlog.h.

INT32 ColourEditDlg::AutoModelChangeN = TRUE [static, protected]

Definition at line 284 of file coldlog.h.

BOOL ColourEditDlg::bHSVHueAtTop = TRUE [static, protected]

Definition at line 288 of file coldlog.h.

BOOL ColourEditDlg::bUsePrintCMYK = TRUE [static, protected]

Definition at line 289 of file coldlog.h.

ColourGeneric ColourEditDlg::ColourBeforeDrag [protected]

Definition at line 379 of file coldlog.h.

INT32 ColourEditDlg::ColourPickerMode = 0 [static, protected]

Definition at line 356 of file coldlog.h.

BOOL ColourEditDlg::colPickHidden [static, protected]

Definition at line 368 of file coldlog.h.

RECT ColourEditDlg::colPickOrigRect [static, protected]

Definition at line 365 of file coldlog.h.

Cursor* ColourEditDlg::CurrentCursor [protected]

Definition at line 551 of file coldlog.h.

UINT32 ColourEditDlg::CurrentCursorID [protected]

Definition at line 550 of file coldlog.h.

KernelDragTarget UndoableOperation INT32 ColourEditDlg::DefaultDisplayModel = (INT32) COLOURMODEL_HSVT [static, protected]

If TRUE, the colour editor will automatically switch the display colour model whenever it switches to a new LOCAL colour (to that colour's model) If FALSE, the only time the display colour model will change is when the user explicitly sets a different colour model from the dialogue. Notes: Normal preference, available from the options dialogue. If TRUE, the colour editor will automatically switch the display colour model whenever it switches to a new NAMED colour (Colour STYLE) (to that colour's model) If FALSE, the only time the display colour model will change is when the user explicitly sets a different colour model from the dialogue. Notes: Normal preference, available from the options dialogue. Retains a 'memory' of the last used Colour Editor display model between sessions in Camelot. Used for LOCAL COLOURS Notes: Internal 'memory' preference, not directly settable by the user Retains a 'memory' of the last used Colour Editor display model between sessions in Camelot. used for COLOUR STYLES Notes: Internal 'memory' preference, not directly settable by the user Retains a 'memory' of the colour editor 'folded' state between sessions in Camelot. Notes: Internal 'memory' preference, not directly settable by the user Determines if the sliders in the colour editor show a 'split line' display. If FALSE, a simple display is given where each slider just shows the component being set (e.g. in RGB, the Red slider shades between black and red) If TRUE, the split mode is enabled, where the slider shows the normal grad-fill in the top half (black to red), but fills the bottom half with the range of colours which will result from changing that component of the edited colour (i.e. at any point on the slider it shows what colour you will get if you click on that spot) Notes: Secret squirrel preference! THis may become available in the options dialogue if it is decided that it is useful. If FALSE, the RGB/CMYK colour pickers in the colour editor will be simple sliders. If TRUE, the '3d colour cube' display will be used instead If TRUE, the HSV colour picker shows the SV Pane with full hue at the top (as all version did prior to Xara X1) If FALSE, the HSV colour picker shows the SV Pane with full hue at the bottom If TRUE, use print profile to do RGB-CMYK colour conversion. Preference: UsePrintCMYK Section: Displays Range: TRUE or FALSE See also: ColourEditDlg Definition at line 281 of file coldlog.h.

INT32 ColourEditDlg::DefaultDisplayModelN = (INT32) COLOURMODEL_HSVT [static, protected]

Definition at line 282 of file coldlog.h.

ColourModel ColourEditDlg::DisplayModel = COLOURMODEL_HSVT [static, protected]

Definition at line 355 of file coldlog.h.

DocCoord ColourEditDlg::DragAnchor [protected]

Definition at line 375 of file coldlog.h.

ColEditDragArea ColourEditDlg::DragStartArea [protected]

Definition at line 371 of file coldlog.h.

BOOL ColourEditDlg::DragUpdatedOnIdle [protected]

Definition at line 378 of file coldlog.h.

IndexedColour* ColourEditDlg::EditingColour [protected]

Definition at line 343 of file coldlog.h.

BOOL ColourEditDlg::EditingLineColour = FALSE [static, protected]

Definition at line 348 of file coldlog.h.

BOOL ColourEditDlg::EscapeKeyWasPressed = FALSE [static, protected]

Definition at line 296 of file coldlog.h.

BOOL ColourEditDlg::FirstEdit [protected]

Definition at line 349 of file coldlog.h.

INT32 ColourEditDlg::Folded = TRUE [static, protected]

Definition at line 285 of file coldlog.h.

const ResourceID ColourEditDlg::IDD = _R(IDD_COLOUREDITDLG) [static]

Definition at line 252 of file coldlog.h.

BOOL ColourEditDlg::ISentTheMessage [protected]

Definition at line 358 of file coldlog.h.

DocCoord ColourEditDlg::LastDragPos [protected]

Definition at line 373 of file coldlog.h.

BOOL ColourEditDlg::m_bDoingSetGadget [protected]

Definition at line 460 of file coldlog.h.

BOOL ColourEditDlg::m_bDoTimerProcessing [protected]

Definition at line 553 of file coldlog.h.

BOOL ColourEditDlg::m_NeedsResize [protected]

Definition at line 559 of file coldlog.h.

const CDlgMode ColourEditDlg::Mode = MODELESS [static]

Definition at line 254 of file coldlog.h.

ColourDropDown* ColourEditDlg::NameDropDown [protected]

Definition at line 360 of file coldlog.h.

BOOL ColourEditDlg::needColPickHidden [static, protected]

Definition at line 367 of file coldlog.h.

BOOL ColourEditDlg::NoFillButtonDown [protected]

Definition at line 347 of file coldlog.h.

IndexedColour ColourEditDlg::OriginalColour [protected]

Definition at line 341 of file coldlog.h.

IndexedColour* ColourEditDlg::OriginalEditingColour [protected]

Definition at line 344 of file coldlog.h.

ColourDropDown* ColourEditDlg::ParentDropDown [protected]

Definition at line 361 of file coldlog.h.

ColourList* ColourEditDlg::ParentList [protected]

Definition at line 345 of file coldlog.h.

BOOL ColourEditDlg::resetColPickPos [static, protected]

Definition at line 363 of file coldlog.h.

IndexedColour* ColourEditDlg::ResultColour [protected]

Definition at line 342 of file coldlog.h.

INT32 ColourEditDlg::SplitLineDisplay = FALSE [static, protected]

Definition at line 286 of file coldlog.h.

ColEditState ColourEditDlg::State [protected]

Definition at line 454 of file coldlog.h.

ColourEditDlg * ColourEditDlg::TheEditor = NULL [static, protected]

\ End of custom colour picker interface functions Definition at line 337 of file coldlog.h.

BOOL ColourEditDlg::UpdateOnNextIdle = FALSE [static, protected]

Definition at line 352 of file coldlog.h.

INT32 ColourEditDlg::Use3DDisplay = FALSE [static, protected]

Definition at line 287 of file coldlog.h.

---

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

• Kernel/coldlog.h (r1785/r1282)
• Kernel/coldlog.cpp (r1785/r1685)

---