CColourBar Class Reference

The CColourBar window - a window like the status bar, which contains a strip of colours that can be used in the selected Document. More...

#include <ccolbar.h>

List of all members.

Public Member Functions
	CColourBar ()
	CColourBar constructor Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care.
virtual	~CColourBar ()
	Destroys the object, as one might expect. Notes: IMPORTANT - After calling the destructor (delete ColourBar) it is VITAL that you then call RecalcLayout() for the main frame window in which the Colour Bar is appearing (the one you passed in to PB::Create(). If you don't do this, the bar won't disappear until the next time the main window is resized or a tool is chosen.
BOOL	Create (wxWindow *parent, UINT32 id)
	Creates a window and associates it with this CColourBar object. The window appears at the bottom of the main frame window, just like the status bar.
virtual wxSize	DoGetBestSize () const
void	SetSizes (INT32 NewCellSize, INT32 NewScrollbarSize)
	Sets the base sizes of the colour strip and colour scroll bar in the colour bar window. Other features of the bar are automatically resized to fit the new sizing. The bar will be redrawn. If the combined height of the bar elements has now changed, the bar will be resized (by calling the parent's RecalcLayout method).
INT32	GetNumberOfColours ()
	Determines the number of colours that we wish to display on the ColourBar.
BOOL	IsColourPickerOverStripRect (wxWindow *colourPicker, wxPoint mousePt)
	This function helps to determin how colour picker controls should behave when they are over the colour bar.
BOOL	DoColourPickerColour (wxWindow *colourPicker, wxPoint mousePt, IndexedColour **pTheCol=NULL)
	Instruct the colour edit dialog to use that colour on the colour bar (of which the colour picker is over).
Static Public Member Functions
static void	RedrawGBrushAreas (void)
	Force-redraws all areas of the colourbar that depend upon GBrush for their rendering. Used by winoil.cpp when GBrush rendering is enabled or disabled in order to redraw the colourbar.
static void	Show (BOOL HideOrShow=FALSE)
	Tells the colour bar to show or hide itself. The bar will remain visible/hidden until the next call to this method. If no colour bar currently exists, the desired state will be remembered and used on creation of any new bar.
static void	SetDisplayMode (INT32 NewDisplayMode=-1)
	Sets the Colour Bar display mode to the new value. Current legal mode values are 0..3 (small, med, med+scroll, large) Illegal values will cause it to resort to the default mode, medium+scroll (2) The default value of -1 is used to mean 'use the preference setting'. This allows the prefs dialogue to cause the ColourBar to sit up and take notice of changed preference settings. The preference setting ColourBarMode will be set to the new value.
static BOOL	GetStatusLineText (String_256 *Result)
	To retrieve help text for use by the status line system.
static CColourBar *	GetColourBar ()
static BOOL	EnsureLibraryColoursPresent ()
	Ensures that any colour library sections we require are present.
Protected Member Functions
void	DoPaint (wxDC *pDC)
	Redraws the ColourBar window contents.
void	OnPaint (wxPaintEvent &event)
	Redraws the colour bar.
void	OnSize (wxSizeEvent &event)
	Handle resizing of our window. This ensures that the scroll offset is within the new bounds of the colour strip, and forces a redraw.
void	OnLButtonDown (wxMouseEvent &event)
	Handle left-button clicks in the colour bar Note that a shift-click is converted into the equivalent of a right-click by this function.
void	OnRButtonDown (wxMouseEvent &event)
	Handle right-button clicks in the Colour Bar.
void	OnLButtonDblClk (wxMouseEvent &event)
	Handle left-button double clicks in the colour bar.
void	OnRButtonDblClk (wxMouseEvent &event)
	Handle right-button double clicks in the Colour Bar.
void	OnLButtonUp (wxMouseEvent &event)
	Processes a left-button-released message.
void	OnRButtonUp (wxMouseEvent &event)
	Processes a right-button-released message.
void	OnMouseMove (wxMouseEvent &event)
	Processes all mouse moves over the colour bar. This currently involves providing bubble help and updating during drags of the scroll sausage. Other 'drag' updates (button autorepeats) are handled by OnTimer().
void	OnTimer (wxTimerEvent &event)
	Responds to the triggering of the timer which we set when a click or drag first occurred, in order to check for auto-repeat of buttons. This currently processes the scroll left/right and page left/right areas Dragging the scroll sausage is handled in OnMouseMove.
BOOL	HasNoScrollBar (INT32 DisplayedColours, INT32 MaxColours, wxRect *pStripRect=NULL)
	Determines if the ColourBar actually need bother with a scrollbar (It does not need one if it can display all the available colours).
void	CalculateRects (void)
	Calculates various useful rectangular regions to be found within the Colour Bar window. Returns the screen rectangles ready for redraw.
void	CalculateRectsInternal (wxRect *pWindowRect, wxRect *pStripRect, wxRect *pIndicatorRect, wxRect *pScrollBarRect, wxRect *pEditButtonRect, wxRect *pNewButtonRect)
	Calculates various useful rectangular regions to be found within the Colour Bar window. Returns the screen rectangles ready for redraw.
BOOL	CalculateSausageRect (wxRect *Result)
	Calculates the scroll sausage area within the scroll bar rectangle Notes: You must call CalculateRects and cache the value of TotalNumColours prior to calling this function - see DoPaint for everything that needs to be done. The ColourBar works exclusively on the SELECTED Doc. Change with care.
void	CalculateNoColourCellRect (wxRect *Rect)
	Calculates the 'NoColour' colour cell position, just to the left of the ColourStrip Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care.
INT32	CalculateNewBarHeight (wxRect *AvailableRect)
	Determine how high the colour bar should be - this is difficult, because the height depends upon whether we want a scrollbar, and this in turn depends upon how wide the colourstrip is.
INT32	CalculateColourCellIndex (IndexedColour *TheColour)
	Searches the colour list to find the given colour, returning its index in the list if it is found, or a negative value if it is not.
INT32	CalculateColourCellIndex (DocColour *TheColour)
	Given a DocColour, will determine which *visible* colour cell, if any, is displaying that colour, anmd return its Cell Index.
void	OnAnyButtonUp (const wxPoint &point)
	Processes any button-released event. This stops auto-repeat and drags, and releases any claims (timers, drags) we might have.
void	OnAnyButtonDown (const wxPoint &point, INT32 Modifier)
	Handle button clicks in the colour bar. Called by the LButton and RButton handlers to share the code somewhat.
void	OnAnyButtonDblClk (wxPoint point, INT32 Modifier)
	Handle double clicks in the colour bar. This brings up the colour picker on the given colour. This works on any colour cell, including the current colour indicators. Double clicks on scroll arrows are passed on to the normal single-click handler (otherwise every second click, when repeating fast, is lost).
void	EditAColour (ColourList *DisplayList, IndexedColour *TheColour, BOOL LineColour=FALSE)
	Edits the given colour.
INT32	WhereIsMouse (wxPoint MousePos, wxRect *TheRectItIsIn=NULL, BOOL *ToLeft=NULL)
	Checks which part of the ColourBar the given point lies over (if any) and returns a value indicating where it is.
void	ApplyColour (IndexedColour *TheColour, BOOL SetLineColour)
	Applies the given IndexedColour as a stroke/fill colour attribute to the selected objects. This also makes the colour the 'current' attribute, etc, if desired by the user.
void	CellClicked (INT32 CellIndex, BOOL SetLineColour)
	Processes a click on a given colour cell by setting the line/fill colour of the selected objects, or if nothing is selected, setting the default line/fill colour.
IndexedColour *	FindColourByIndex (UINT32 Index)
	Given the current Display List, finds the 'Index'th item, and dereferences it to find the actual IndexedColour that lies at that list position in the current colour bar display order.
DocColour *	FindLibColourByIndex (UINT32 Index, SGDisplayLibColour **ppLibColour=NULL)
	Given the current Display List, finds the 'Index'th item, and dereferences it to find the actual DocColour that lies at that list position in the current colour bar display order. This will only look through the Library colours and hence returns DocColours rather than indexed colours.
IndexedColour *	FindLibIndexedColourByIndex (UINT32 Index)
	Given the current Display List, finds the 'Index'th item, and dereferences it to find the actual DocColour that lies at that list position in the current colour bar display order. This will only look through the Library colours and hence finds DocColours rather than indexed colours. This versions is the same as above but then goes and creates an IndexedColour in the current document and returns this.
void	PaintColourCell (wxDC *pDC, wxRect *Rect, DocColour *RectCol)
	Draws the given rectangle as a 'Colour cell' for the given DocColour. The top half of the rect is solid-filled with the colour, while the bottom 2 quarters are filled with the colour as it would appear on top of a white background and black bgnd respectively (if the col isn't fractionally transparent, rect is just solid filled).
void	PaintNoColourCell (wxDC *pDC)
	Draws the 'NoColour' colour cell just to the left of the ColourStrip Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care.
void	PaintIndicatorDiamond (wxDC *pDC, const wxRect &CellRect, CBColourType ColourType, INT32 CellIndex, BOOL DiamondType)
	Draws a small diamond in the top left/right corner of a colour cell to indicate that the given cell is the current line/fill colour.
void	PaintColourStrip (wxDC *pDC, const wxRect &ClipRect)
	Redraws the ColourBar colour strip Notes: You must call CalculateRects and cache the value of TotalNumColours prior to calling this function - see DoPaint for everything that needs to be done. If GBrush has been initialised before calling this function, it will be used to plot the colour cells.
void	PaintIndicators (wxDC *pDC)
	Redraws the ColourBar colour indicators (current fg/bg colours) Notes: You must call CalculateRects and cache the value of TotalNumColours prior to calling this function - see DoPaint for everything that needs to be done. If GBrush has been initialised before calling this function, it will be used to plot the colour cells. The ColourBar works exclusively on the SELECTED Doc. Change with care.
void	PaintEditOrNewButton (wxDC *pDC, BOOL Normal, BOOL IsEditButton)
	Draws the colour bar "edit colour" or "new colour" button Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care.
void	PaintScrollButton (wxDC *pDC, INT32 ButtonID, BOOL Normal)
	Draws a scroll button at the appropriate end of the scroll bar The button is scaled to fit into (ButtonWidth x ScrollHeight) Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care.
void	PaintScrollBar (wxDC *pDC)
	Redraws the ColourBar window's mini proportional scroll bar Notes: You must call CalculateRects and cache the value of TotalNumColours prior to calling this function - see DoPaint for everything that needs to be done.
void	PaintLibColourCell (wxDC *pDC, wxRect *Rect, DocColour *RectCol, BOOL SpotColour=FALSE)
	Draws the given rectangle as a 'Colour cell' for the given DocColour.
void	ForceRedrawOfCell (INT32 CellIndex)
	Forces a redraw of the given Cell in the colour strip. The index is from the first colour in the list - if this is outside the displayed portion of the colour strip, no action will be taken Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care.
void	ForceRedrawOfCell (DocColour *TheColour)
void	ForceRedrawOfRect (const wxRect &RectToDraw)
	Causes the given portion of the colour bar to be redrawn Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care.
void	ScrollTheStrip (INT32 ScrollBy, BOOL RedrawAlways=FALSE)
	Scrolls the colour strip to the left or right. Does not allow scrolling past the ends of the available list. Causes the window to be redrawn.
void	CaptureTheMouse (void)
	Captures the mouse for drags/autorepeat. Nothing will be done if we already have mouse capture.
void	SetATimer (BOOL Delay)
	Sets a timer to cause a timer message to be sent to us after the keyboard auto-repeat delay. If we are already waiting for a timer event, the current timer will be replaced by the new one.
void	ReleaseAllClaims (void)
	Ensures that all our temporary claims (timers, mouse capture) are released.
BOOL	InitPrefs (void)
	Initialisation of ColourBar preference option(s) Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care.
wxBrush *	GetColourBrush (COLORREF rgb)
	Calculates a logical brush for use in painting. If GDraw is available via CColourBar::GDrawBrush, GDraw will be used. If not, GDI will be used. Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care.
void	SelectionHasChangedInternal (void)
	This will cause the colourbar to redraw any necessary portions of the colour strip and indicators to indicate the colour of the selection (or the default line/fill colours if there is no selection).
Static Protected Member Functions
static INT32	GetCurrentBarHeight (void)
	Determine how high the colour bar currently is.
static TCHAR *	HelpCallbackHandler (wxWindow *Window, INT32 Item, void *This)
	Callback handler for providing Bubble help over the Colour Bar window.
static void	PaletteHasChanged (ColourList *ChangedList=NULL)
	This will cause the colourbar to redraw itself with the new list if necessary, and cache new values for the new current list.
static void	SelectionHasChanged (void)
	This will cause the colourbar to redraw any necessary portions of the colour strip and indicators to indicate the colour of the selection (or the default line/fill colours if there is no selection).
Protected Attributes
INT32	m_cxLeftBorder
INT32	m_cyTopBorder
INT32	m_cxRightBorder
INT32	m_cyBottomBorder
UINT32	LeftmostColour
UINT32	TotalNumColours
INT32	LastLineCell
INT32	LastFillCell
INT32	LastEndCell
BOOL	LastDiamondShape
INT32	IndentedButton
ColourList *	m_pCurrentColourList
ColourBarMsgHandler *	MsgHandler
wxRect	WindowRect
wxRect	StripRect
wxRect	IndicatorRect
wxRect	ScrollBarRect
wxRect	EditButtonRect
wxRect	NewButtonRect
INT32	OldBarHeight
wxTimer	m_DragTimer
ColourSGallery *	m_pColourGallery
CBDragInfo	DragInfo
Cursor *	PushCursor
GBrush	GDrawBrush
Static Protected Attributes
static CColourBar *	TheColourBar = NULL
static BOOL	BarIsVisible = TRUE
Friends
class	ColourBarMsgHandler
class	ColourDragInformation
class	EditButtonDragTarget
class	ColourLineDragTarget

---

Detailed Description

The CColourBar window - a window like the status bar, which contains a strip of colours that can be used in the selected Document.

Author:

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

Date:

17/6/94

Definition at line 282 of file ccolbar.h.

---

Constructor & Destructor Documentation

CColourBar::CColourBar (   )

CColourBar constructor Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 17/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Definition at line 827 of file ccolbar.cpp. { m_pCurrentColourList = NULL; LeftmostColour = 0; // Initially, are at left end of the colourstrip LastLineCell = CELLINDEX_NOCELL; // We have not drawn any indicator diamonds anywhere LastFillCell = CELLINDEX_NOCELL; LastEndCell = CELLINDEX_NOCELL; LastDiamondShape = TRUE; IndentedButton = CLICKED_NOTHING; m_cxLeftBorder = 1; // Automatic 1 pixel gap at left end of bar m_cyTopBorder = 0; m_cxRightBorder = 0; m_cyBottomBorder = 0; TheColourBar = this; MsgHandler = NULL; m_DragTimer.SetOwner(this, 2); DragInfo.TimerOn = 0; DragInfo.MouseCaptured = FALSE; PushCursor = NULL; OldBarHeight = 0; // We have no current colour gallery to access the fixed gallery section colours m_pColourGallery = NULL; }

CColourBar::~CColourBar (   )  [virtual]

Destroys the object, as one might expect. Notes: IMPORTANT - After calling the destructor (delete ColourBar) it is VITAL that you then call RecalcLayout() for the main frame window in which the Colour Bar is appearing (the one you passed in to PB::Create(). If you don't do this, the bar won't disappear until the next time the main window is resized or a tool is chosen. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 17/6/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - The ColourBar works exclusively on the SELECTED Doc. Change with care Definition at line 884 of file ccolbar.cpp. { TheColourBar = NULL; // There is no longer a colour bar around if (MsgHandler != NULL) delete MsgHandler; // Kill our message handler ReleaseAllClaims(); // Ensure all temp. window claims (mouse/timer) released if (PushCursor) delete PushCursor; }

---

Member Function Documentation

void CColourBar::ApplyColour (  IndexedColour *  TheColour, BOOL  SetLineColour )  [protected]

Applies the given IndexedColour as a stroke/fill colour attribute to the selected objects. This also makes the colour the 'current' attribute, etc, if desired by the user. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 5/10/94 (separated from CellClicked() - originally written 23/6/94) Parameters: TheColour  - The IndexedColour to apply, or NULL to apply 'no colour' (complete [INPUTS] transparency) SetLineColour - TRUE to set this as a line colour, FALSE to set as a fill colour Scope: private Notes: Works on CurrentDoc, so ensure Current == Selected before calling this function Definition at line 3103 of file ccolbar.cpp. { NodeAttribute *Attrib = NULL; DocColour ColourToApply(COLOUR_TRANS); if (TheColour != NULL) ColourToApply.MakeRefToIndexedColour(TheColour); if (SetLineColour) { // Line colour selected so create a line colour attribute Attrib = new AttrStrokeColourChange; if (Attrib == NULL) return; ((AttrStrokeColourChange *)Attrib)->SetStartColour(&ColourToApply); // AttributeSelected knows what to do with a selected attribute AttributeManager::AttributeSelected(NULL, Attrib); /* // Bodge Alert !! // To make blends work properly, we need to set the line transparecy. // We set it to Max if the colour is 'Tranaparent' or zero otherwise Attrib = new AttrStrokeTranspChange; if (Attrib == NULL) return; UINT32 Transp; if (ColourToApply.IsTransparent()) Transp = 255; else Transp = 0; ((AttrStrokeTranspChange *)Attrib)->SetStartTransp(&Transp); // AttributeSelected knows what to do with a selected attribute AttributeManager::AttributeSelected(NULL, Attrib); */ } else { // Rather than setting the flat fill colour, we do an AttrColourChange, which // (I assume) will handle things like selected grad fill points, etc. Attrib = new AttrColourChange; if (Attrib == NULL) return; ((AttrColourChange *)Attrib)->SetStartColour(&ColourToApply); // AttributeSelected knows what to do with a selected attribute AttributeManager::AttributeSelected(NULL, Attrib); } // Note: Redraw of affected parts of the colour bar (indicator diamonds, etc) will // automatically occur as a result of the message which the AttributeManager will // broadcast in the above call. Thus we need do no more. }

INT32 CColourBar::CalculateColourCellIndex (  DocColour *  TheColour  )  [protected]

Given a DocColour, will determine which *visible* colour cell, if any, is displaying that colour, anmd return its Cell Index. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 14/7/94 Parameters: TheColour  - the colour whose Cell index you wish to calculate [INPUTS] Returns: CELLINDEX_NOCOLOURCELL, CELLINDEX_NOCELL, or the index of the given colour Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care Definition at line 3446 of file ccolbar.cpp. { if (TheColour == NULL) return(CELLINDEX_NOCELL); if (TheColour->IsTransparent()) return(CELLINDEX_NOCOLOURCELL); return (CalculateColourCellIndex(TheColour->FindParentIndexedColour())); }

INT32 CColourBar::CalculateColourCellIndex (  IndexedColour *  TheColour  )  [protected]

Searches the colour list to find the given colour, returning its index in the list if it is found, or a negative value if it is not. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 6/7/94 Parameters: TheColour  - The colour to find the index of [INPUTS] Returns: The index (0..NumColours-1) of the colour cell containing the colour, or CELLINDEX_NOCELL (-2) if the colour wasn't found Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care Definition at line 3399 of file ccolbar.cpp. { m_pCurrentColourList = ColourManager::GetColourList(); if (TheColour == NULL || m_pCurrentColourList == NULL) return(CELLINDEX_NOCELL); INT32 Index = 0; // If the user has asked for document colours in the colour line then check these first // Indexed Colours are document colours and so can never exist in the library groups. if (ColourSGallery::ShowDocumentColours) { IndexedColour *TestColour = m_pCurrentColourList->GetUndeletedHead(); while (TestColour != NULL) { if (TheColour == TestColour) return((INT32) Index); TestColour = m_pCurrentColourList->GetUndeletedNext(TestColour); Index++; } } // Didn't find a match for this colour in the list return(CELLINDEX_NOCELL); }

INT32 CColourBar::CalculateNewBarHeight (  wxRect *  AvailableRect  )  [protected]

Determine how high the colour bar should be - this is difficult, because the height depends upon whether we want a scrollbar, and this in turn depends upon how wide the colourstrip is. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/94 Parameters: AvailableRect  - The space available for the colourbar to fit into. [INPUTS] Only the available x space is significant. -  [OUTPUTS] Returns: The height, in pixels, the bar will need to be at this width in order to contain all its 'controls'. Notes: AvailableRect is now preserved by this call See also: CColourBar::GetCurrentBarHeight; CColourBar::OnSize Definition at line 4306 of file ccolbar.cpp. { TRACEUSER("Gerry", _T("CColourBar::CalculateNewBarHeight")); if (ScrollHeight == 0) // Has no scroll bar, so always the same height { TRACEUSER("Gerry", _T(" returning %d"), BarHeight); return(BarHeight); } // Work out how many colours we want to display in the window. // Removed this line so that FullScreen mode (which destroys and recreates the colour // gallery) does not leave us with a cached pointer to garbage memory. // if (m_pCurrentColourList == NULL) m_pCurrentColourList = ColourManager::GetColourList(); if (m_pCurrentColourList == NULL) // No colours; we won't display anything anyway { // TRACEUSER("Gerry", _T(" returning %d"), BarHeight - ScrollHeight); // return(BarHeight - ScrollHeight); return(CellSize + 4); } // Calculate where all the rectangles are going to be placed if the window is resized // to the 'AvailableRect'. From this, we get the projected StripRect size, which allows // us to project the number of colours we will be able to display. wxRect tStripRect; // Temporary lookalikes to the global cached rects wxRect tIndicatorRect; wxRect tScrollBarRect; wxRect tEditButtonRect; wxRect tNewButtonRect; // Warning - this button is now defunct CalculateRectsInternal(AvailableRect, &tStripRect, &tIndicatorRect, &tScrollBarRect, &tEditButtonRect, &tNewButtonRect); INT32 DisplayedColours = tStripRect.width / CellSize; // We can display all the colours, we don't need a scrollbar, so only need CellSize+4 pixels //if ((INT32) m_pCurrentColourList->GetUndeletedCount() <= DisplayedColours) // FIXEDCOLOURS if ((INT32)GetNumberOfColours() <= DisplayedColours) { // TRACEUSER("Gerry", _T(" returning %d"), BarHeight - ScrollHeight); // return(BarHeight - ScrollHeight); return(CellSize + 4); } // We can't display all colours, so we need the desired BarHeight, which includes the // size of the colourstrip and the scrollbar (if enabled) TRACEUSER("Gerry", _T(" returning %d"), BarHeight); return(BarHeight); }

void CColourBar::CalculateNoColourCellRect (  wxRect *  Rect  )  [protected]

Calculates the 'NoColour' colour cell position, just to the left of the ColourStrip Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 15/7/94 Parameters: -  [INPUTS] Rect  - will be filled in with the caclculated rect [OUTPUTS] Returns: - Definition at line 1693 of file ccolbar.cpp. { *Rect = StripRect; if (ScrollHeight == 0) // If in 'small' mode, correct for scroll arrow Rect->x -= ButtonWidth; // else if (!HasNoScrollBar(-1, -1)) // otherwise if there IS a scroll bar // Rect->Offset(0,1); // then move the rectangle down a pixel Rect->x -= NoColourSize + InterControlGap; Rect->width = NoColourSize; Rect->height = NoColourSize; }

void CColourBar::CalculateRects (  void   )  [protected]

Calculates various useful rectangular regions to be found within the Colour Bar window. Returns the screen rectangles ready for redraw. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 17/6/94 Parameters: -  [INPUTS] The  following data members are calculated on exit: [OUTPUTS] WindowRect - The usable client-are of the ColourBar window StripRect - The area in which the colour cells are drawn IndicatorRect - The area the current colour indicator is drawn in ScrollBarRect - The area in which the scrollbar is drawn EditButtonRect - The area in which the Edit Button is drawn NewButtonRect - The area in which the New Button is drawn [DEFUNCT] Returns: - Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care IMPORTANT: If you change the rect calculations, be sure to change the 2 occurences of a related calculation in CColBar::CalculateNewBarHeight, below See also: CColourBar::CalculateScrollButtonRects; CColourBar::CalculateRectsInternal Definition at line 1449 of file ccolbar.cpp. { // Calculate inside of window area WindowRect = GetClientRect(); CalculateRectsInternal(&WindowRect, &StripRect, &IndicatorRect, &ScrollBarRect, &EditButtonRect, &NewButtonRect); // Now, calculate the inside rect (the area of the window which lies inside the borders // which have been drawn by the base class DoPaint() function). The only things that // should be using this rectangle (rather than the rects calculated above) should be // the 2 bits in the DoPaint method which fill undrawn areas of the bar with grey. // CalcInsideRect(&WindowRect); }

void CColourBar::CalculateRectsInternal (  wxRect *  pWindowRect, wxRect *  pStripRect, wxRect *  pIndicatorRect, wxRect *  pScrollBarRect, wxRect *  pEditButtonRect, wxRect *  pNewButtonRect )  [protected]

Calculates various useful rectangular regions to be found within the Colour Bar window. Returns the screen rectangles ready for redraw. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 17/6/94 Parameters: pWindowRect  - The usable client-area of the ColourBar window [INPUTS] pStripRect  - The area in which the colour cells are drawn [OUTPUTS] pIndicatorRect - The area the current colour indicator is drawn in pScrollBarRect - The area in which the scrollbar is drawn pEditButtonRect - The area in which the Edit Button is drawn pNewButtonRect - The area in which the New Button is drawn [DEFUNCT] NONE of these inputs/outputs may be NULL! Returns: - Identical to the CalculateRects function, but you pass in the rects for it to plonk the results into. WindowRect is untouched. All other rects are updated from WindowRect. The contents on entry of all but WindowRect are unimportant. Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care USE CalculateRects UNLESS ABSOLUTELY NECESSARY See also: CColourBar::CalculateRects Definition at line 1502 of file ccolbar.cpp. { ERROR3IF(pWindowRect == NULL || pStripRect == NULL || pIndicatorRect == NULL || pScrollBarRect == NULL || pEditButtonRect == NULL || pNewButtonRect == NULL, _T("NULL parameter passed to CColourBar::CalculateRectsInternal")); wxRect TempRect(*pWindowRect); // CalcInsideRect(&TempRect); TempRect.Inflate(-CX_BORDER, -CY_BORDER); // Calculate the current-colour indicator rectangle, and ensure it's a square *pIndicatorRect = TempRect; pIndicatorRect->width = pIndicatorRect->height; // Subtract the indicator width from the available space. We now always make the indicator // 'BarHeight' pixels wide: This means that there is a gap to its right when there is // no scrollbar (because the square indicator shrinks), but this means the colourstrip // width is not dependant on whether or not it has a scrollbar (which in turn is dependant // upon the colourstrip width - a nasty circular reference!) TempRect.x += BarHeight + InterControlGap; TempRect.width -= BarHeight + InterControlGap; // Calculate the new and edit button positions *pNewButtonRect = TempRect; pNewButtonRect->width = EditButtonSizeX; pNewButtonRect->height = EditButtonSizeY; *pEditButtonRect = *pNewButtonRect; // The new button isn't current present so make the edit button the same // pEditButtonRect->x += EditButtonSizeX + InterControlGap; // Subtract new, edit, and no-colour buttons from the TempRect TempRect.x += NoColourSize + EditButtonSizeX + (InterControlGap * 2); TempRect.width -= NoColourSize + EditButtonSizeX + (InterControlGap * 2); // Calculate scrollbar and colour strip rectangles in the remaining space *pStripRect = TempRect; // This may be called fairly early on so if no colour list then get out immediately if (m_pCurrentColourList == NULL) // No colours, so give safe default and exit { *pScrollBarRect = TempRect; return; } // INT32 MaxColours = (INT32) m_pCurrentColourList->GetUndeletedCount(); FIXED COLOURS INT32 MaxColours = GetNumberOfColours(); // Removed 4/8/97 Neville as causes a redraw problem when switching from document with two colours // in to one with none in. /* if (MaxColours <= 0) { pScrollBarRect->CopyRect(&TempRect); return; } */ INT32 Width = pStripRect->width; // Normally, the buttons are flush with the ends of the colourstrip, but in // this mode, they sit outside the ends of the colourstrip instead if (ScrollHeight == 0) Width -= 2 * (ButtonWidth + 1); if (MaxColours * CellSize < Width) pStripRect->width = MaxColours * CellSize; else pStripRect->width = Width - (Width % CellSize); if (ScrollHeight == 0) { // We want no scroll bar, just arrows on either end of the colourstrip // As the arrows are drawn on either end (outside) of the scroll rect, // we must now move both rects one scroll button width to the right pStripRect->Offset(ButtonWidth + 1, 0); *pScrollBarRect = *pStripRect; // And then make the scroll bar rect slightly bigger so there is a small // gap between the buttons and the strip pScrollBarRect->Inflate(2, 0); } else { // If there is no need for a scrollbar, StripRect expands to fill the space if (HasNoScrollBar(-1, MaxColours)) { // For now we will force the strip rect to only be CellSize high // because the window resizing code isn't working properly pStripRect->height = CellSize; return; } *pScrollBarRect = *pStripRect; // ScrollBarRect is only ScrollHeight pixels high. // We also subtract off the space for the scroll arrows pScrollBarRect->y = pScrollBarRect->y + pScrollBarRect->height - ScrollHeight; pScrollBarRect->height = ScrollHeight; pScrollBarRect->Inflate(-(ButtonWidth-1), 0); // Colour strip is immediately above scroll rect: same width, CellSize height pStripRect->height = CellSize; pStripRect->y = pScrollBarRect->y - CellSize; } }

BOOL CColourBar::CalculateSausageRect (  wxRect *  Result  )  [protected]

Calculates the scroll sausage area within the scroll bar rectangle Notes: You must call CalculateRects and cache the value of TotalNumColours prior to calling this function - see DoPaint for everything that needs to be done. The ColourBar works exclusively on the SELECTED Doc. Change with care. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/94 Parameters: -  [INPUTS] If  successful, Result contains the sausage rect [OUTPUTS] Returns: TRUE if it succeeds, FALSE if the scrollbar/sausage is non existent Definition at line 1628 of file ccolbar.cpp. { // If the scroll bar hasn't got enough room to exist, it does not appear if (ScrollBarRect.width < 5) return(FALSE); // If we are in Med/Large mode and have no scrollbar, it doesn't appear if (HasNoScrollBar(-1, -1)) return(FALSE); *Result = ScrollBarRect; UINT32 NumDisplayedColours = StripRect.width / CellSize; Result->Inflate(-1, -1); if (NumDisplayedColours < TotalNumColours) { UINT32 BarWidth = Result->width; // Calculate the midpoint and width of the scroll 'sausage' // MidPointColour = LeftmostColour + NumDisplayedColours/2; // Mid = (MidPointColour / TotalColours) * BarWidth; // We calculate everything at *2 magnification to avoid rounding errors UINT32 Mid = (((LeftmostColour * 2) + NumDisplayedColours) * BarWidth) / (TotalNumColours * 2); BarWidth = (BarWidth * NumDisplayedColours) / TotalNumColours; if (BarWidth < (UINT32)4) BarWidth = 4; // Try to keep some sausage visible! Result->x += Mid - (BarWidth / 2); Result->width = BarWidth; // Clip the values in case of rounding errors causing a pixel or 2 error if (Result->x <= ScrollBarRect.x) Result->x = ScrollBarRect.x + 1; // Clip rounding error, also make sure that errors don't make bar 1 pixel // short when at the very rightmost scroll position (this douubles up the // black lines around scroll sausage/arrow and looks bad) if (Result->GetRight() >= ScrollBarRect.GetRight() || TotalNumColours-NumDisplayedColours <= LeftmostColour) Result->SetRight(ScrollBarRect.GetRight() - 1); } return(TRUE); }

void CColourBar::CaptureTheMouse (  void   )  [protected]

Captures the mouse for drags/autorepeat. Nothing will be done if we already have mouse capture. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/6/94 Parameters: -  [INPUTS] Notes: When capturing the mouse, you should also set the value of DragInfo.CaptureRect to the area within which the mouse was captured. This allows the other handlers to determine if the mouse strays out of the relevant area (in which case scrolling/autorepeat will cease). If not set, this will cause odd effects. The ColourBar works exclusively on the SELECTED Doc. Change with care Definition at line 3883 of file ccolbar.cpp. { TRACEUSER("Gerry", _T("CColourBar::CaptureTheMouse")); if (DragInfo.MouseCaptured) { TRACEUSER("Gerry", _T("Already got capture")); return; } CaptureMouse(); DragInfo.MouseCaptured = TRUE; }

void CColourBar::CellClicked (  INT32  CellIndex, BOOL  SetLineColour )  [protected]

Processes a click on a given colour cell by setting the line/fill colour of the selected objects, or if nothing is selected, setting the default line/fill colour. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 23/6/94 Parameters: CellIndex  - The index of the clicked colour cell (0..MaxColours) [INPUTS] SetLineColour - TRUE to set the line colour to the given colour FALSE to set the fill color to the given colour -  [OUTPUTS] Returns: - Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care If you add code to this routine, note the way in which we return - the selected order must always be deselected before exit Definition at line 3186 of file ccolbar.cpp. { if ((CellIndex >= CLICKED_NOTHING && CellIndex != CLICKED_NOCOLOURCELL) || m_pCurrentColourList == NULL) return; // Ensure that CurrentDoc == SelectedDoc Document *OldCurrentDoc = SetCurrentDoc(); // Create an attribute of the correct type IndexedColour *TheColour = NULL; if (CellIndex != CLICKED_NOCOLOURCELL) { // If the user has asked for document colours in the colour line then check these first if (ColourSGallery::ShowDocumentColours) TheColour = FindColourByIndex(CellIndex); // If we didn't find it there check the library colours if (TheColour == NULL) { // FIXED COLOURS // It is not one of the standard document colours so check the fixed library colours // If it finds the correct one then this will create an indexed colour and add it to // the currently selected document TheColour = FindLibIndexedColourByIndex(CellIndex); if (TheColour == NULL) { // It is an unknown colour so just exit // Before exiting the function, we must always restore CurrentDoc RestoreCurrentDoc(OldCurrentDoc); return; } } } ApplyColour(TheColour, SetLineColour); // Apply this colour to the selection RestoreCurrentDoc(OldCurrentDoc); // Restore previous CurrentDoc value }

BOOL CColourBar::Create (  wxWindow *  pParent, UINT32  id )

Creates a window and associates it with this CColourBar object. The window appears at the bottom of the main frame window, just like the status bar. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 17/6/94 Parameters: ParentWnd  - The parent frame window (in Camelot, there can be only one) [INPUTS] dwstyle, nID - you shouldn't have to mess with these (cf CStatusBar) -  [OUTPUTS] Returns: TRUE if the initialisation of the Colour bar was successful. Notes: The ColourBar works exclusively on the SELECTED Doc. Change with care Definition at line 949 of file ccolbar.cpp. { if (!wxWindow::Create(pParent, id, wxDefaultPosition, wxSize(BarHeight, BarHeight), wxNO_BORDER)) return(FALSE); #if FALSE ASSERT_VALID(pParentWnd); // must have a parent // Create a new WndClass- this should be identical to CControlBar's WndClass but // we also would kindof like double clicks if it isn't too much trouble, Mr MFC CString WndClassName = AfxRegisterWndClass(CS_DBLCLKS, NULL, //Cursor::Arrow->Handle(), (HBRUSH)(COLOR_BTNFACE + 1)); // Do we want to show this bar after it's created? BOOL Show = dwStyle & WS_VISIBLE; // Make sure the style flags only has legal flags set (VC6 change) dwStyle &= CBRS_ALL; #if WIN32 // this element of CControlBar does not exist in MFC 2.5 16-bit m_dwStyle = dwStyle; #endif // create the wxWindow* wxRect rect; rect.SetRectEmpty(); if (!CWnd::Create(WndClassName, NULL, dwStyle, rect, pParentWnd, nID)) return(FALSE); // NOTE: Parent must resize itself for control bar to be resized if (Show) ShowWindow(SW_SHOW); #endif InitPrefs(); SetDisplayMode(); InvalidateBestSize(); IndentedButton = CLICKED_NOTHING; return(TRUE); }

BOOL CColourBar::DoColourPickerColour (  wxWindow *  colourPicker, wxPoint  mousePt, IndexedColour **  pTheCol = NULL )

Instruct the colour edit dialog to use that colour on the colour bar (of which the colour picker is over). Author: Chris_Snook (Xara Group Ltd) <camelotdev@xara.com> Date: 22/10/99 Parameters: colourPicker  - The wxWindow* of the claimed colour picker control [INPUTS] Returns: True if success False otherwise Throws ENSURE error if colourPicker is NOT a colour picker control Definition at line 1293 of file ccolbar.cpp. { if (colourPicker == this) { UINT32 ColourCell = WhereIsMouse (mousePt); static UINT32 lastColourCell = (UINT32)-1; if ((((INT32)ColourCell) >= 0)/* && (lastColourCell != ColourCell)*/) // we are over a valid colour { BOOL validColour = FALSE; if (m_pCurrentColourList == NULL) // Ensure the current ColourList pointer is valid { m_pCurrentColourList = ColourManager::GetColourList(); } IndexedColour *TheColour = NULL; // If the user has the preference set then include and hence show the document // colours if (ColourSGallery::ShowDocumentColours) { TheColour = FindColourByIndex(ColourCell); } if (TheColour != NULL) { validColour = TRUE; } else { // We didn't find the colour in the document colours section // so check any library sections that may be present SGDisplayLibColour *pLibColour = NULL; DocColour * pTheDocColour = FindLibColourByIndex(ColourCell, &pLibColour); TheColour = ColourManager::GenerateNewUnnamedColour (m_pCurrentColourList, pTheDocColour); if (pTheDocColour && pLibColour) { validColour = TRUE; } } if (validColour && pTheCol) *pTheCol = TheColour; if ((lastColourCell != ColourCell) && validColour) { ColourEditDlg* pColourEditDlg = ColourEditDlg::GetColourEditDlg (); ASSERT (pColourEditDlg); pColourEditDlg->SetEditingColour (TheColour); lastColourCell = ColourCell; } return (TRUE); } else { return (TRUE); } } ENSURE(FALSE, "DoColourPickerColour called for invalid colour picker control"); return (FALSE); }

wxSize CColourBar::DoGetBestSize (   )  const [virtual]

Author: Gerry_Iles (Xara Group Ltd) <camelotdev@xara.com> Date: 10/03/06 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: Best size of this window Definition at line 1008 of file ccolbar.cpp. { TRACEUSER("Gerry", _T("CColourBar::DoGetBestSize")); wxRect AvailableRect = GetParent()->GetClientRect(); AvailableRect.height = BarHeight; INT32 Height = ((CColourBar*)this)->CalculateNewBarHeight(&AvailableRect); INT32 Width = GetParent()->GetClientSize().x; return(wxSize(Width, Height)); }

void CColourBar::DoPaint (  wxDC *  pDC