ControlHelper Class Reference

Provide a system for subclassing controls on Camelot bars which offers various facilities such as bubble help/status bar text and commit handling. To use this system you use the Notifyxxx() functions to keep the class up to date with which bars/controls exist. This module will subclass these controls and do some preprocessing of Windows messages in order to do bubble help/commit handling etc. You can 'fake' bubble help on a window that doesn't really have controls in it, by using the 'ad-hoc' bubble help function, DoBubbleHelpOn(). More...

#include <ctrlhelp.h>

Inheritance diagram for ControlHelper:

List of all members.

Public Types
typedef TCHAR *(*	BubbleHelpCallback )(wxWindow *, UINT32, void *)
Static Public Member Functions
static BOOL	Init ()
	Called to initialise the control helper system.
static void	DeInit ()
	Deinitialise the control helper system.
static BOOL	NotifyBarCreated (wxWindow *)
	Inform the ControlHelper class that a bar has been created with the specified window handle.
static BOOL	NotifyBarDeleted (wxWindow *)
	Notify the ControlHelper class that a bar has been deleted.
static BOOL	NotifyBarChanged (wxWindow *Old, wxWindow *New)
	Notify the ControlHelper class that a bar's window handle has been changed.
static BOOL	NotifyControlCreated (wxWindow *, ControlHelpInfo *)
	Inform the Control helper system that a control has just been created.
static BOOL	NotifyControlCreated (wxWindow *, OpDescriptor *)
static BOOL	NotifyControlDeleted (wxWindow *)
	Notify the control helper system that a control has just been deleted.
static BOOL	NotifyControlChanged (wxWindow *, ControlHelpInfo *)
	Allows the Bubble and Status ID's of a control to be changed.
static void	DoBubbleHelpOn (wxWindow *, UINT32, BubbleHelpCallback, void *)
	Provide bubble-help on an ad-hoc basis, i.e. this allows bubble help to be provided for GUI elements which are not necessarily 'controls' as such on a Camelot bar. For example the colour bar uses this to pretend that each colour swatch is a control, and provides the bubble help to be shown on it. This function should be called on mouse move messages over such GUI elements. (It cannot be done automatically by the bubble help system because we do not subclass such elements - because they're not really individual windows!).
static void	ServiceBubbleHelp ()
	Updates the bubble help for our controls. Should be called on idle or timer events.
static void	BubbleHelpDisable ()
	Cause the bubble help to go into its 'disabled' state, so that even if it is over a control that supports bubble help, bubble help will not be displayed. If bubble help is currently displayed, it is removed. This function should be called on events that ought to kill off bubble help, e.g. key presses, focus switches etc.
static void	InformModalDialogOpened ()
	Informs the ControlHelper class that a modal dialog which is NOT managed by the kernel Dialog Manager (i.e. NOT a DialogOp) has been opened. This allows us to disable bubble help whiole modal dialogs are open. Examples of the use of this are the error box, or use of the Windows Common Dialog functions.
static void	InformModalDialogClosed ()
	Informs the ControlHelper class that a modal dialog which is NOT managed by the kernel Dialog Manager (i.e. NOT a DialogOp) has been closed. This allows us to disable bubble help whiole modal dialogs are open. Examples of the use of this are the error box, or use of the Windows Common Dialog functions.
static BOOL	GetStatusLineText (String_256 *ptext, wxWindow *window)
	Get status-line text for a control with given WHND.
static BOOL	IsUserInterfaceCaptured ()
	Determine if the user interface is 'captured' in any way, e.g. if a bar is being dragged or a menu is up, and so on. This is used to determine whether or not to do certain background/idle operations, e.g. background rendering and the like. This does NOT include drag operations such as any tool drags etc., as this would mean that the push tool would not work properly etc.
Private Types
enum	BubbleState {   STATE_DEAD, STATE_ACTIVE, STATE_INITIAL_PENDING, STATE_UPDATE_PENDING,   STATE_INITIAL_DISABLED, STATE_DISABLED }
Static Private Member Functions
static void	BubbleHelpKill ()
	Low level function to kill off the bubble help window and delete it, and set various variables for ad-hoc bubble help to sensible 'null' values.
static BOOL	AddControl (wxWindow *, ControlHelpInfo *)
	Add entries for a window and all its descendant windows to our list of subclassed controls. This is a 'helper' function for ControlHelper::NotifyControlCreated.
static LRESULT CALLBACK	MyWndProc (wxWindow *, UINT32, WPARAM, LPARAM)
	Callback function for special handling of controls on Camelot bars. At present it does nothing - just chains to the controls usual WndProc.
static void	SetState (BubbleState NewState, wxWindow *Window=NULL)
	Change the state of the bubble help state machine to the specified state. Calls the appropriate state change handler to process the event.
static void	DeadHandler ()
	Kill off the bubble help by setting the bubble help state machine to the STATE_DEAD state.
static void	ActiveHandler (wxWindow *Window)
	Activate the bubble help system by moving to the STATE_ACTIVE state. This causes a bubble help window to appear under the cursor, but not is there are any keys down, or if there is a drag going on, or if our app is not active. At some time in the future we should also refuse to put up bubble help if the user has the menu up.
static void	InitialPendingHandler ()
	Sets the state to STATE_INITIAL_PENDING, which means that the bubble help window is about to come up, when a timer has elapsed, providing the user doesn't move the cursor away or press a key etc.
static void	InitialDisabledHandler ()
	Sets the bubble help state to STATE_INITIAL_DISABLED, which means that the cursor is over a Camelot bar but not over a control, or that for some reason (key press, focus change etc) bubble help should not be displayed, even though the cursor is over a control that supports bubble help.
static void	UpdatePendingHandler ()
	Set the bubble help state to STATE_UPDATE_PENDING, which means that the bubble help will appear very quickly if moved over a control. This is used when the user moves from a control to another control, so it enables the user to move along the controls and browse the bubble text for them quite quickly.
static void	DisabledHandler ()
	Set the bubble help state to STATE_DISABLED, which means that the bubble help will appear very quickly if moved over a control. This is used when the user moves from a control to a Camelot bar, so it enables the user to move between bars (or even controls which are separated on a bar) and browse the bubble text for them quite quickly.
Static Private Attributes
static ControlTable *	Controls = NULL
static BarTable *	Bars = NULL
static BubbleHelpWnd *	BubbleWnd = NULL
static MonotonicTime	PendingTimer
static POINT	LastPos = {-1, -1}
static wxWindow *	LastControl = NULL
static BOOL	ControlHasFocus = FALSE
static wxWindow *	AdHocWindow = NULL
static UINT32	AdHocControl = 0
static BOOL	AdHocControlIsDifferent = TRUE
static void *	AdHocReference = NULL
static BubbleHelpCallback	AdHocCallback = NULL
static BubbleState	BubbleHelpState = STATE_DEAD
static INT32	ModalDialogs = 0

---

Detailed Description

Provide a system for subclassing controls on Camelot bars which offers various facilities such as bubble help/status bar text and commit handling. To use this system you use the Notifyxxx() functions to keep the class up to date with which bars/controls exist. This module will subclass these controls and do some preprocessing of Windows messages in order to do bubble help/commit handling etc. You can 'fake' bubble help on a window that doesn't really have controls in it, by using the 'ad-hoc' bubble help function, DoBubbleHelpOn().

Author:

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

Date:

01/07/94

See also:

ControlHelpInfo; ControlHelper::NotifyBarCreated; ControlHelper::NotifyBarDeleted; ControlHelper::NotifyBarChanged; ControlHelper::NotifyControlCreated; ControlHelper::NotifyControlDeleted ControlHelper::DoBubbleHelpOn

Definition at line 205 of file ctrlhelp.h.

---

Member Typedef Documentation

typedef TCHAR*(* ControlHelper::BubbleHelpCallback)(wxWindow *, UINT32, void *)

Definition at line 222 of file ctrlhelp.h.

---

Member Enumeration Documentation

enum ControlHelper::BubbleState [private]

Enumerator: STATE_DEAD  STATE_ACTIVE  STATE_INITIAL_PENDING  STATE_UPDATE_PENDING  STATE_INITIAL_DISABLED  STATE_DISABLED  Definition at line 255 of file ctrlhelp.h. { STATE_DEAD, // No bubble help is displayed - cursor is not over a // a bar or a control. STATE_ACTIVE, // Bubble help is displayed - cursor is over a control. STATE_INITIAL_PENDING, // Waiting to show bubble help for the first time - the // cursor is over a control. STATE_UPDATE_PENDING, // Waiting to display help for a different control - i.e. // the user has moved from one control to another, // possible via a bar (STATE_DISABLED). STATE_INITIAL_DISABLED, // Pointer is over bar, but no help has yet been displayed // during this session. STATE_DISABLED // Pointer over bar, and bubble help has been displayed // during this session. } BubbleState;

---

Member Function Documentation

void ControlHelper::ActiveHandler (  wxWindow *  Window  )  [static, private]

Activate the bubble help system by moving to the STATE_ACTIVE state. This causes a bubble help window to appear under the cursor, but not is there are any keys down, or if there is a drag going on, or if our app is not active. At some time in the future we should also refuse to put up bubble help if the user has the menu up. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/06/94 Parameters: Window  - handle of the control the cursor is currently over. [INPUTS] See also: ControlHelper::DeadHandler; ControlHelper::InitialPendingHandler; ControlHelper::InitialDisabledHandler; ControlHelper::DisabledHandler; ControlHelper::UpdatePendingHandler Definition at line 1791 of file ctrlhelp.cpp. { // Sanity checks ENSURE(Window != NULL, "Bad handle in control helper ActiveHandler()"); ENSURE(BubbleWnd == NULL, "Bubble window already exists in BubbleHelpStart()"); // No bubble help during drags, or if any mouse buttons are down. // Get mouse keys - top bit is set if the button is down. INT8 MouseStatus = (::GetKeyState(CAMKEY(LBUTTON)) | ::GetKeyState(CAMKEY(MBUTTON)) | ::GetKeyState(CAMKEY(RBUTTON))); if ((MouseStatus & 0x8000) || (Operation::GetCurrentDragOp() != NULL)) { // Revert to pending BubbleHelpState = STATE_ACTIVE; // Very important else state machine gets upset! SetState(STATE_INITIAL_PENDING); return; } // Don't do bubble help if we're iconised. CWnd *pMainWnd = AfxGetApp()->m_pMainWnd; if (pMainWnd->IsIconic()) { // Revert to pending BubbleHelpState = STATE_ACTIVE; // Very important else state machine gets upset! SetState(STATE_INITIAL_PENDING); return; } // Only do bubble help if our application is active. wxWindow* Active = ::GetActiveWindow(); wxWindow* MainWnd = pMainWnd->m_wxWindow*; if ((Active != MainWnd) && (::GetParent(Active) != MainWnd)) { // Revert to pending BubbleHelpState = STATE_ACTIVE; // Very important else state machine gets upset! SetState(STATE_INITIAL_PENDING); return; } // Don't do bubble help if modal dialog is open. if (DialogManager::ModalDialogOpen() || (ModalDialogs > 0)) { // Revert to pending BubbleHelpState = STATE_ACTIVE; // Very important else state machine gets upset! SetState(STATE_INITIAL_PENDING); return; } // Don't do bubble help if a menu is up - Windows captures the mouse during a menu // processing loop. if (::GetCapture() != NULL) { // Revert to pending BubbleHelpState = STATE_ACTIVE; // Very important else state machine gets upset! SetState(STATE_INITIAL_PENDING); return; } // also only do bubble help if the control were over is actually visible if (::IsWindowVisible (Window) == FALSE) { // Revert to pending BubbleHelpState = STATE_ACTIVE; // Very important else state machine gets upset! SetState(STATE_INITIAL_PENDING); return; } // Ok - we're allowed to display bubble help - work out what to do: #if STATE_TRACE if (IsUserName("Tim")) TRACE( _T("STATE_ACTIVE\n")); #endif switch (BubbleHelpState) { case STATE_INITIAL_PENDING: case STATE_UPDATE_PENDING: BubbleHelpState = STATE_ACTIVE; // Create and show a bubble help window ENSURE(BubbleWnd == NULL, "Bubble window already exists!"); // Make a new bubble help window TRY { BubbleWnd = new BubbleHelpWnd; } CATCH(CMemoryException, e) { TRACEALL( _T("Unable to create bubble help window!\n")); return; } END_CATCH // Create the actual window if (!BubbleWnd->Create()) { TRACEALL( _T("Could not Init bubble help window\n")); return; } // If ad-hoc bubble help, call provider to get required text, otherwise // get resource IDs out of the OpDescriptor in our table of controls. if ((AdHocCallback != NULL) && (Window == AdHocWindow)) { char *BubbleText = AdHocCallback(AdHocWindow, AdHocControl, AdHocReference); if (BubbleWnd->SetText(BubbleText)) BubbleWnd->Show(); } else { // Find the record for this control. ControlEntry *pEntry; pEntry = Controls->FindControl(Window); ENSURE(pEntry != NULL, "Bad Entry in ActiveHandler"); // If we have an OpDescriptor, then get the bubble help/module IDs from that, // otherwise get them directly out of the ControlEntry. UINT32 BubbleID; UINT32 ModuleID; if (pEntry->pOpDesc != NULL) { BubbleID = pEntry->pOpDesc->GetBubbleId(); ModuleID = Tool::GetModuleID(pEntry->pOpDesc->GetToolID()); } else { BubbleID = pEntry->BubbleID; ModuleID = pEntry->ModuleID; } // Load the bubble help text. // Ugly hack, but who cares? String_256 strCaption; GetWindowText(Window, strCaption, 255); if (strCaption == String_256("Download")) { if (BubbleWnd->SetText("Download this resource")) // If the string loaded ok, put the window in the correct place and show it. BubbleWnd->Show(); } else { if (BubbleWnd->SetText(BubbleID, ModuleID)) // If the string loaded ok, put the window in the correct place and show it. BubbleWnd->Show(); } } break; default: ENSURE(FALSE, "Wrong state in bubble help"); break; } }

BOOL ControlHelper::AddControl (  wxWindow *  Window, ControlHelpInfo *  pInfo )  [static, private]

Add entries for a window and all its descendant windows to our list of subclassed controls. This is a 'helper' function for ControlHelper::NotifyControlCreated. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 10/05/94 Parameters: Window  - The window to add an entries for. [INPUTS] pInfo - information about the control being added. Returns: TRUE if the window and its descendants were processed ok; FALSE if not. See also: ControlTable::AddControl; ControlHelper::NotifyControlCreated Definition at line 947 of file ctrlhelp.cpp. { // Firstly, try to add this control WNDPROC WndProc = (WNDPROC) ::GetWindowLong(Window, GWL_WNDPROC); ENSURE(WndProc != 0, "NULL WndProc in ControlHelper::AddControl"); if (!(Controls->AddControl(Window, pInfo, WndProc))) goto Failure; // Subclass the control. ::SetWindowLong(Window, GWL_WNDPROC, (INT32) MyWndProc); // Now try to add/subclass all the children... wxWindow* Child; Child = ::GetWindow(Window, GW_CHILD); while (Child != NULL) { // Recurse for this child window if (!(AddControl(Child, pInfo))) goto Failure; // Get the next child window, if any. Child = ::GetWindow(Child, GW_wxWindow*NEXT); } // Success! return TRUE; Failure: // Could not add all the controls for some reason - remove any we might have added // so far, but only if this call is for the parent control (cos we recurse in this // function, and we only want to do this once). if (Window == pInfo->Parent) { wxWindow* RealWindow; while ((WndProc = Controls->DeleteControl(Window, &RealWindow)) != NULL) { // De-subclass the control. WNDPROC TheWndProc = (WNDPROC) ::GetWindowLong(Window, GWL_WNDPROC); if (TheWndProc = MyWndProc) // It really is one we've subclassed, so 'de-subclass' it! ::SetWindowLong(Window, GWL_WNDPROC, (INT32) WndProc); } } // Failed return FALSE; }

void ControlHelper::BubbleHelpDisable (   )  [static]

Cause the bubble help to go into its 'disabled' state, so that even if it is over a control that supports bubble help, bubble help will not be displayed. If bubble help is currently displayed, it is removed. This function should be called on events that ought to kill off bubble help, e.g. key presses, focus switches etc. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/06/94 See also: ControlHelper::BubbleHelpKill Definition at line 2149 of file ctrlhelp.cpp. { // If bubble help is around, disable it. switch (BubbleHelpState) { case STATE_ACTIVE: case STATE_UPDATE_PENDING: // Bubble help is on screen or will be RSN so slide into the disabled // state in order to get rid of/avoid it. SetState(STATE_DISABLED); break; case STATE_INITIAL_PENDING: // Bubble help will be on screen RSN so slide into the initial disabled // state in order to get rid of/avoid it. SetState(STATE_INITIAL_DISABLED); break; } }

void ControlHelper::BubbleHelpKill (   )  [static, private]

Low level function to kill off the bubble help window and delete it, and set various variables for ad-hoc bubble help to sensible 'null' values. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/06/94 See also: ControlHelper::BubbleHelpDisable Scope: Private Definition at line 2182 of file ctrlhelp.cpp. { // Destroy the bubble help window. if (BubbleWnd != NULL) { BubbleWnd->Hide(); delete BubbleWnd; BubbleWnd = NULL; } // Disable ad-hoc bubble help. // NB we don't change the AdHocControl, because then we know that we're over the same // control and should remain disabled (e.g. if user clicks on button and bubble help // goes away, it shouldn't come back until they move to another control). AdHocWindow = NULL; AdHocCallback = NULL; AdHocReference = NULL; }

void ControlHelper::DeadHandler (   )  [static, private]

Kill off the bubble help by setting the bubble help state machine to the STATE_DEAD state. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/06/94 See also: ControlHelper::ActiveHandler; ControlHelper::InitialPendingHandler; ControlHelper::InitialDisabledHandler; ControlHelper::DisabledHandler; ControlHelper::UpdatePendingHandler Definition at line 1746 of file ctrlhelp.cpp. { #if STATE_TRACE if (IsUserName("Tim")) TRACE( _T("STATE_DEAD\n")); #endif switch (BubbleHelpState) { case STATE_ACTIVE: // Kill the bubble help window and fall through. ENSURE(BubbleWnd != NULL, "No bubble help window!"); BubbleHelpKill(); case STATE_INITIAL_PENDING: case STATE_INITIAL_DISABLED: case STATE_DISABLED: case STATE_UPDATE_PENDING: BubbleHelpState = STATE_DEAD; break; default: ENSURE(FALSE, "Wrong state in bubble help"); break; } }

void ControlHelper::DeInit (  void   )  [static]

Deinitialise the control helper system. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 26/04/94 Definition at line 842 of file ctrlhelp.cpp. { // Deallocate our control table and bar table objects. delete Bars; Bars = NULL; delete Controls; Controls = NULL; BubbleHelpWnd::DeInit(); }

void ControlHelper::DisabledHandler (   )  [static, private]

Set the bubble help state to STATE_DISABLED, which means that the bubble help will appear very quickly if moved over a control. This is used when the user moves from a control to a Camelot bar, so it enables the user to move between bars (or even controls which are separated on a bar) and browse the bubble text for them quite quickly. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/06/94 See also: ControlHelper::DeadHandler; ControlHelper::ActiveHandler; ControlHelper::InitialPendingHandler; ControlHelper::InitialDisabledHandler; ControlHelper::UpdatePendingHandler Definition at line 2103 of file ctrlhelp.cpp. { #if STATE_TRACE if (IsUserName("Tim")) TRACE( _T("STATE_DISABLED\n")); #endif // If a control has focus, then don't change state unless it's in order to die. if (ControlHasFocus) { if (BubbleHelpState != STATE_DEAD) return; } switch (BubbleHelpState) { case STATE_ACTIVE: // Kill the bubble help window and fall through. ENSURE(BubbleWnd != NULL, "No bubble help window!"); BubbleHelpKill(); case STATE_UPDATE_PENDING: BubbleHelpState = STATE_DISABLED; break; default: ENSURE(FALSE, "Wrong state in bubble help"); break; } }

void ControlHelper::DoBubbleHelpOn (  wxWindow *  Window, UINT32  NewControl, BubbleHelpCallback  Callback, void *  Reference )  [static]

Provide bubble-help on an ad-hoc basis, i.e. this allows bubble help to be provided for GUI elements which are not necessarily 'controls' as such on a Camelot bar. For example the colour bar uses this to pretend that each colour swatch is a control, and provides the bubble help to be shown on it. This function should be called on mouse move messages over such GUI elements. (It cannot be done automatically by the bubble help system because we do not subclass such elements - because they're not really individual windows!). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/06/94 Parameters: Window  - the window to provide bubble help on. [INPUTS] NewControl - pseudo-ID of the imaginary control - this is so the bubble knows when a different control has been moved onto, and hence that it should update the bubble help window. Callback - the callback routine for ad-hoc bubble help - this is called to get the bubble help text when the bubble window needs to be shown. Reference - arbritrary data that the Callback may make use of to provide it with context information for the callback event. Definition at line 2227 of file ctrlhelp.cpp. { // Caller is telling us that they have detected a mouse move over one of their // controls - therefore take a record of their window handle, and fake an event // to the state machine. AdHocWindow = Window; AdHocCallback = Callback; AdHocReference = Reference; // Work out if this is a different control we're being told about. AdHocControlIsDifferent = (AdHocControl != NewControl); // Remember control ID for next time (we do this before calling BubbleHelpStateMachine() // because it uses AdHocControl to display the bubble help when it flips into the // Active state). AdHocControl = NewControl; // We give our WndProc to the state machine so that it thinks that NewControl is one of // our 'proper' controls. POINT Pos; ::GetCursorPos(&Pos); BubbleHelpStateMachine(Pos, Window, ControlHelper::MyWndProc); }

BOOL ControlHelper::GetStatusLineText (  String_256 *  ptext, wxWindow *  window )  [static]

Get status-line text for a control with given WHND. Author: Ed_Cornes (Xara Group Ltd) <camelotdev@xara.com> Date: 20/11/94 Returns: TRUE if returning valid text Definition at line 1128 of file ctrlhelp.cpp. { if (window==NULL) return FALSE; ControlEntry* pEntry=Controls->FindControl(window); if (pEntry==NULL) return FALSE; String_256 strCaption; GetWindowText(window, strCaption, 255); if (strCaption == String_256("Download")) { *ptext = "Download selected resource to the local hard disk"; return TRUE; } else return pEntry->ControlStatusLineText(ptext); }

void ControlHelper::InformModalDialogClosed (   )  [static]

Informs the ControlHelper class that a modal dialog which is NOT managed by the kernel Dialog Manager (i.e. NOT a DialogOp) has been closed. This allows us to disable bubble help whiole modal dialogs are open. Examples of the use of this are the error box, or use of the Windows Common Dialog functions. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/09/94 See also: ControlHelper::IncModalDialogCount Definition at line 2293 of file ctrlhelp.cpp. { ModalDialogs--; // Restore the active window DialogManager::RestoreActiveDialogState(); // Sanity check ENSURE(ModalDialogs >= 0, "Unbalanced call to ControlHelper::InformModalDialogClosed()!"); }

void ControlHelper::InformModalDialogOpened (   )  [static]

Informs the ControlHelper class that a modal dialog which is NOT managed by the kernel Dialog Manager (i.e. NOT a DialogOp) has been opened. This allows us to disable bubble help whiole modal dialogs are open. Examples of the use of this are the error box, or use of the Windows Common Dialog functions. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/09/94 See also: ControlHelper::DecModalDialogCount Definition at line 2268 of file ctrlhelp.cpp. { ModalDialogs++; // Record the currently active window DialogManager::RecordActiveDialogState(); // This is the ideal place to disable all modeless dialogs DialogManager::EnableAllDialogs(FALSE); }

BOOL ControlHelper::Init (  void   )  [static]

Called to initialise the control helper system. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 26/04/94 Returns: TRUE if initialised ok; FALSE if not. Reimplemented from SimpleCCObject. Definition at line 816 of file ctrlhelp.cpp. { // Allocate and initialise a BarTable object. Bars = new BarTable; if ((Bars == NULL) || !Bars->Init()) return FALSE; // Allocate and intialise ourselves a ControlTable object Controls = new ControlTable; if ((Controls == NULL) || !Controls->Init()) return FALSE; // Initialise the bubble help window system return BubbleHelpWnd::Init(); }

void ControlHelper::InitialDisabledHandler (   )  [static, private]

Sets the bubble help state to STATE_INITIAL_DISABLED, which means that the cursor is over a Camelot bar but not over a control, or that for some reason (key press, focus change etc) bubble help should not be displayed, even though the cursor is over a control that supports bubble help. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/06/94 See also: ControlHelper::DeadHandler; ControlHelper::ActiveHandler; ControlHelper::InitialPendingHandler; ControlHelper::DisabledHandler; ControlHelper::UpdatePendingHandler Definition at line 2013 of file ctrlhelp.cpp. { #if STATE_TRACE if (IsUserName("Tim")) TRACE( _T("STATE_INITIAL_DISABLED\n")); #endif // If a control has focus, then don't change state unless it's in order to die. if (ControlHasFocus) { if (BubbleHelpState != STATE_DEAD) return; } switch (BubbleHelpState) { case STATE_DEAD: case STATE_INITIAL_PENDING: // Don't do anything. BubbleHelpState = STATE_INITIAL_DISABLED; break; default: ENSURE(FALSE, "Wrong state in bubble help"); break; } }

void ControlHelper::InitialPendingHandler (   )  [static, private]

Sets the state to STATE_INITIAL_PENDING, which means that the bubble help window is about to come up, when a timer has elapsed, providing the user doesn't move the cursor away or press a key etc. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 30/06/94 See also: ControlHelper::DeadHandler; ControlHelper::ActiveHandler; ControlHelper::InitialDisabledHandler; ControlHelper::DisabledHandler; ControlHelper::UpdatePendingHandler Definition at line 1971 of file ctrlhelp.cpp. { #if STATE_TRACE if (IsUserName("Tim")) TRACE( _T("STATE_INITIAL_PENDING\n")); #endif switch (BubbleHelpState) { case STATE_ACTIVE: // Kill off bubble help (if it exists) and fall through BubbleHelpKill(); case STATE_DEAD: case STATE_INITIAL_DISABLED: // Sample timer (i.e. reset delay) PendingTimer.Sample(); BubbleHelpState = STATE_INITIAL_PENDING; break; default: ENSURE(FALSE, "Wrong state in bubble help"); break; } }

BOOL ControlHelper::IsUserInterfaceCaptured (   )  [static]

Determine if the user interface is 'captured' in any way, e.g. if a bar is being dragged or a menu is up, and so on. This is used to determine whether or not to do certain background/idle operations, e.g. background rendering and the like. This does NOT include drag operations such as any tool drags etc., as this would mean that the push tool would not work properly etc. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 04/01/95 Returns: TRUE => User interface is captured in some way (e.g. a menu is up) FALSE => User interface is not captured. Definition at line 2324 of file ctrlhelp.cpp. { // Bodge for delta - don't ever disable background rendering. return FALSE; if (Operation::GetCurrentDragOp() != NULL) // Camelot drag in progress - this does not count as capture. return FALSE; // Find out the handle of our main window CWnd *pMainCWnd = AfxGetMainWnd(); wxWindow* MainwxWindow* = NULL; if (pMainCWnd != NULL) MainwxWindow* = pMainCWnd->GetSafewxWindow*(); // Find out which window, if any, is captured. wxWindow* CapturedwxWindow* = ::GetCapture(); // Return TRUE if mouse is captured, and it is not our window. return ((CapturedwxWindow* != NULL) && (CapturedwxWindow* != MainwxWindow*)); }

LRESULT ControlHelper::MyWndProc (  wxWindow *  Window, UINT32  Msg, WPARAM  wParam, LPARAM  lParam )  [static, private]

Callback function for special handling of controls on Camelot bars. At present it does nothing - just chains to the controls usual WndProc. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 26/04/94 Parameters: The  usual - see SDK documentation for "WindowProc". [INPUTS] Returns: As for SDK WindowProc. Errors: See also: ControlHelper Definition at line 1162 of file ctrlhelp.cpp. { ENSURE(Window != 0, "NULL Window handle in ControlHelper::MyWndProc"); // Find the WindowProc for this control. ControlEntry *pEntry = Controls->FindControl(Window); ENSURE(pEntry != NULL, "Could not find subclassed control in ControlHelper::MyWndProc"); if (pEntry != NULL) { switch (Msg) { case WM_MOUSEMOVE: { // start control drag if(KeyPress::IsAlternativePressed()) { return TRUE; } // Update the status bar on MouseMove messages String_256 Desc; if (pEntry->ControlStatusLineText(&Desc)) { StatusLine* pStatusLine=GetApplication()->GetpStatusLine(); if (pStatusLine->AllowControlHelp ()) { if (pStatusLine) pStatusLine->UpdateText(&Desc,STATUSLINE_SELDESC_BUTTONS); } } } break; case WM_SETFOCUS: // This control has focus - disable the bubble help. //ControlHasFocus = TRUE; if (pEntry->AddCommitHandling) { SendMessage(GetParent(GetParent(Window)),WM_CTL_SETFOCUS,TRUE,(LPARAM)Window); SendMessage(GetParent(Window),WM_CTL_SETFOCUS,TRUE,(LPARAM)Window); // Send the control an EM_SETSEL message so the text within it is highlighted. ::SendMessage(Window, EM_SETSEL, 0, (LPARAM) (INT32) -1); } // Fall through... case WM_LBUTTONDOWN: if(KeyPress::IsAlternativePressed()) { String_256 ClassNameStr; // The control type GetClassName(GetParent(Window), (TCHAR*)ClassNameStr, 255); if (ClassNameStr == String_8(TEXT("ComboBox"))) { SendMessage(GetParent(GetParent(Window)),WM_START_CTLDRAG, KeyPress::IsConstrainPressed(),(LPARAM)GetParent(Window)); } else { SendMessage(GetParent(Window),WM_START_CTLDRAG, KeyPress::IsConstrainPressed(),(LPARAM)Window); } return TRUE; } case WM_MBUTTONDOWN: case WM_RBUTTONDOWN: case WM_LBUTTONUP: case WM_MBUTTONUP: case WM_RBUTTONUP: case WM_LBUTTONDBLCLK: case WM_MBUTTONDBLCLK: case WM_RBUTTONDBLCLK: // start control drag // Mouse activity - disable bubble help. BubbleHelpDisable(); break; case WM_KILLFOCUS: // This control has lost focus - allow the bubble help to start working again. ControlHasFocus = FALSE; if (pEntry->AddCommitHandling) { SendMessage(GetParent(GetParent(Window)),WM_CTL_SETFOCUS,FALSE,(LPARAM)Window); SendMessage(GetParent(Window),WM_CTL_SETFOCUS,FALSE,(LPARAM)Window); } break; default: if (pEntry->AddCommitHandling) { // Is commit processing required, this should be the case if the control // is an edit or ComboBox // Determine the control type switch (Msg) { case WM_CHAR: // Process this message to avoid message beeps. if ((wParam == CAMKEY(RETURN)) || (wParam == CAMKEY(TAB))) { ControlHasFocus = FALSE; return FALSE; } break; case WM_GETDLGCODE: return DLGC_WANTALLKEYS; case WM_KEYDOWN: // escape should return the focus back to the main frame if (wParam == CAMKEY(ESCAPE)) { ControlHasFocus = FALSE; DialogManager::DefaultKeyboardFocus(); return FALSE; } else if (wParam == CAMKEY(RETURN) || wParam == CAMKEY(TAB)) { wxWindow* BarWnd; wxWindow* CtlWnd; String_256 ClassNameStr; // The control type BOOL camelotCustomComboBox = FALSE; // need to do things slightly differently if the control is a // cc_1dBitmapComboBoxEdit or cc_2dBitmapComboBoxEdit GetClassName (Window, (TCHAR*)ClassNameStr, 255); if ((ClassNameStr == String_64(TEXT("cc_1dBitmapComboBoxEdit"))) || (ClassNameStr == String_64(TEXT("cc_2dBitmapComboBoxEdit")))) { camelotCustomComboBox = TRUE; } if (camelotCustomComboBox == FALSE) { GetClassName(GetParent(Window), (TCHAR*)ClassNameStr, 255); if (ClassNameStr == String_8(TEXT("ComboBox")) || ClassNameStr == String_16(TEXT("cc_CustomEdit"))) { // edit controls of these classes are children of the controls. BarWnd = GetParent(GetParent(Window)); // Because combo edit control // is a child of the combo // control itself CtlWnd = GetParent(Window); } else { // It's an Edit control BarWnd = GetParent(Window); // Bar is the edit's parent CtlWnd = Window; } } else { BarWnd = GetParent (Window); CtlWnd = Window; // the following sendmessage is actually so that when CAMKEY(RETURN) is hit, // (which actually goes through the WM_KEYDOWN in ctrlhelp.cpp); that we can actually // set the selected item BEFORE dialog manager continues ! if (wParam == CAMKEY(RETURN)) { SendMessage (CtlWnd, CB_SETTOPINDEX, 1, 0); } else { SendMessage (CtlWnd, CB_SETTOPINDEX, 0, 0); } } if (wParam == CAMKEY(RETURN) ) { ControlHasFocus = FALSE; SendMessage(BarWnd, WM_CTL_SETFOCUS, COMMIT, (LPARAM) Window); } // Send commit message to parent, passing the key code (TAB or ENTER) which // it might be useful to know. SendMessage(BarWnd, WM_CTL_COMMIT, GetWindowID(CtlWnd), (LPARAM) wParam); // To fix various bugs this code is a little bodged. The problems // that this code tries to address are: // 1) Clicking in one of the size edit controls in the selector info bar, // entering some text, pressing enter and then clicking in the same edit // control a second time (this was refusing to take the focus a second // time) // 2) Typing a font name in the font drop down box box and then pressing // enter (this was returning to the font the user had selected before // they started typeing) if (::GetDlgCtrlID(Window) != _R(IDC_FONT_COMBO)) { if (wParam == CAMKEY(RETURN)) { GetMainFrame()->SetFocus(); } else { // Move focus to the next (previous) control, just like Windows. wxWindow* wxWindow*NewFocus = ::GetNextDlgTabItem(BarWnd, Window, ::GetKeyState(CAMKEY(SHIFT)) < 0); if (wxWindow*NewFocus != NULL) ::SetFocus(wxWindow*NewFocus); } return FALSE; } } // added by Karim 30/9/99, to allow a more intelligent font-combo else if (wParam >= 'A' && wParam <= 'Z' && ::GetDlgCtrlID(Window) == _R(IDC_FONT_COMBO)) { // pass the message on to the combo-box's parent, to be // processed in DialogManager::SendDialogMessage. ::SendMessage(GetParent(Window), WM_KEYDOWN, wParam, lParam); } break; } } } } // For any other messages, kill bubble help before passing them on. // if (BubbleHel