Tool Class Reference

The Tool type reflects the latest Tool specification. Do NOT subclass from Tool, but use the latest Tool revision (e.g. Tool_v42). The Tool type should only be used by the Kernel and OIL layers, never by tools themselves. More...

#include <tool.h>

Inheritance diagram for Tool:

List of all members.

Public Member Functions
void	SetCurrent ()
	Sets the 'this' tool to be the current tool.
void	SetButtons (BOOL State)
	Selects/Deselects the buttons associated with this buttons.
Static Public Member Functions
static BOOL	InitToolList ()
	Initialise the static ToolList object which holds all tools that the kernel knows about.
static BOOL	InitTools ()
	Called at the end of initialisation (as it may well need all other initialisations to have been done) to add Tools and Modules to the Kernel's knowledgebase.
static void	SelectFirstTool ()
	Selects the tool that is retrieved from the prefs file. If no pref is found will default to Selector Tool - If the appropriate tool can't be found the first will be used instead.
static void	DeinitTools ()
	Deletes all allocated tools. Safe to call more than once.
static OILTool *	GetOILTool (UINT32 ToolID)
	Given a Tool ID, returns a pointer to the OILTool object associated with this tool.
static Tool *	GetCurrent ()
	Determine the current tool. Scope: Public static.
static UINT32	GetCurrentID ()
	Determine the current tool. Scope: Public static.
static void	SetNoCurrent ()
	Sets no tool as the current tool. Scope: Public static.
static UINT32	GetNumTools ()
	Find out how many tools have registered and initialised successfully.
static ToolListItem *	Find (UINT32 ToolID)
	Anyone can ask about a tool's presence by its ID.
static ToolListItem *	Declare (Tool *, UINT32 ParentID)
	Called by OIL code to declare new tool types.
static ToolListItem *	GetFirstTool ()
	Called for the currently-selected tool when the current DocView changes. Called when the selected DocView changes, ie. the user has moved the focus to another document view window. Allows the Tool to update the info bar according to its internal settings and values. Usually called when the info bar is first created and when a new tool becomes selected.Allows the tool to handle UI events from the info bar. It is similar to the DialogOp::HandleMessage function. returns the first Tool in the list.
static ToolListItem *	GetNextTool (ToolListItem *CurrTool)
	return the next Tool in the list
static UINT32	GetModuleID (UINT32 ToolID)
	Particulary useful for error handling, it allows the owner module ID to be determined given just a tool ID.
static BOOL	SelectATool ()
static Tool *	FindTool (UINT32 ToolID)
	Anyone can ask about a tool's presence by its ID. But Geez! The caller doesn't want to know about ToolListItems!!!
static void	ActivateTemporaryTool (Tool *)
	Temporarily invoke the specified tool. This is called when the user holds down modifier keys to switch tools - this function remembers the currently active tool and will switch back to it when you call Tool::DeactivateTemporaryTool(). It is ok to keep calling this without first deactivating the temporary tool - the system will correctly remember which tool was originally active and restore it when all DeactivateTemporaryTool() is called.
static void	DeactivateTemporaryTool ()
	Deactivate the temporary tool and restore the original one.
static BOOL	SwitchTool (KeyPress *pKeyPress)
	The place where tool switching takes place.
static void	RemoveDirectRegToolSwitches (Tool *pThisTool)
	This goes through the list of registered tool switches and removes all switches that belong to the given tool and were defined directly, i.e. ones that were NOT defined via a file.
static void	DeleteTempToolList ()
	This deletes all temp tool items in the list temp tools. After this call, the temp tool stacking info is lost. This should be called whenever a user selects a new tool directly (i.e. via clicking on the tool icon, a hot key, or menu item).
static void	SetToolChangingState (BOOL state)
	Check to see if the currently active tool is permanently or temporarily active. If, e.g. the user is holding down ALT to get the selector tool, then this returns TRUE. Lets you set the ToolChanging flag.
static BOOL	IsToolChanging ()
	Lets you see the state of the ToolChanging flag.
static void	OnActivateApp (BOOL bActive)
	This is called when the app's active state changes.
static void	EndDrag ()
	This is called when a drag ends.
static void	ServicePendingToolChange ()
	This is called when a drag ends, or the app's active state changes This will deactivate the temporary tool if a deactivate key event was encounted during a drag.
Static Public Attributes
static UINT32	InitTool
Private Member Functions
	CC_DECLARE_MEMDUMP (Tool)
Static Private Attributes
static ToolList *	Tools = NULL
static Tool *	Current = NULL
static BOOL	ToolChanging = FALSE
static BOOL	PendingDeactivateTempTool = FALSE
static List	TempToolList

---

Detailed Description

The Tool type reflects the latest Tool specification. Do NOT subclass from Tool, but use the latest Tool revision (e.g. Tool_v42). The Tool type should only be used by the Kernel and OIL layers, never by tools themselves.

Author:

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

Date:

21/6/93

See also:

ToolInfo

Definition at line 416 of file tool.h.

---

Member Function Documentation

void Tool::ActivateTemporaryTool (  Tool *  pTempTool  )  [static]

Temporarily invoke the specified tool. This is called when the user holds down modifier keys to switch tools - this function remembers the currently active tool and will switch back to it when you call Tool::DeactivateTemporaryTool(). It is ok to keep calling this without first deactivating the temporary tool - the system will correctly remember which tool was originally active and restore it when all DeactivateTemporaryTool() is called. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 04/05/94 Parameters: pTempTool  - the tool to be made active. [INPUTS] See also: Tool::DeactivateTemporaryTool Definition at line 785 of file tool.cpp. { // If the current tool is not temporary, then remember it so we can revert // to it when the user lets go of the hot-keys. // NB. We have to make this test so if the user invokes one tool, then another in such // a way that the original tool si not switched back to inbetween, then things will // go wrong and we won't return to the original tool. TempToolItem* pTempToolItem = new TempToolItem; if (pTempToolItem != NULL) { pTempToolItem->SetPrevTool(Current); pTempToolItem->SetTempTool(pTempTool); TempToolList.AddHead(pTempToolItem); // if (PrevTool == NULL) // PrevTool = Current; //Current->SelectChange(FALSE); // Find the instance of the ToolOpDescriptor String_64 OpToken; camSnprintf( OpToken, 64, _T("TOOL%u"), pTempTool->GetID() ); ToolOpDescriptor* ToolOp = (ToolOpDescriptor *) OpDescriptor::FindOpDescriptor(OpToken); // Use the OpDescriptor to invoke the tool (i.e. make it become the selected tool) ToolOp->Invoke(); } }

Tool::CC_DECLARE_MEMDUMP (  Tool   )  [private]

void Tool::DeactivateTemporaryTool (   )  [static]

Deactivate the temporary tool and restore the original one. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 04/05/94 See also: void Tool::DeactivateTemporaryTool() Definition at line 825 of file tool.cpp. { /* // Do nothing if we don't have a previous tool if (PrevTool == NULL) return; // If the previous tool is the current one, don't have to do nowt if (PrevTool == Current) return; */ TempToolItem* pTempToolItem = (TempToolItem*)TempToolList.RemoveHead(); // Only do something if we have a temp tool item if (pTempToolItem != NULL) { UINT32 PrevToolID = pTempToolItem->GetPrevTool()->GetID(); // We don't need this temp tool item any more. delete pTempToolItem; pTempToolItem = NULL; // Find the instance of the ToolOpDescriptor String_64 OpToken; camSnprintf( OpToken, 64, _T("TOOL%u"), PrevToolID ); ToolOpDescriptor* ToolOp = (ToolOpDescriptor *) OpDescriptor::FindOpDescriptor(OpToken); // Use the OpDescriptor to invoke the tool (i.e. make it become the selected tool) ToolOp->Invoke(); } // Not temporary any more // PrevTool = NULL; }

ToolListItem * Tool::Declare (  Tool *  NewTool, UINT32  ParentID )  [static]

Called by OIL code to declare new tool types. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/93 Parameters: NewTool  - Pointer to a new Tool and its ID [INPUTS] ParentID - Module ID of the module that provides this tool. None  [OUTPUTS] Returns: Pointer to new tool list item. Errors: Will return NULL if invalid ID or same tool ID used twice. Definition at line 454 of file tool.cpp. { // Try to add the tool to the kernel's list. ToolListItem *NewItem = Tools->Add(NewTool, ParentID); if (NewItem == NULL) { // Tool has invalid ID - print error message and destroy tool. ToolInfo Info; NewTool->Describe(&Info); TRACE( _T("Tool %u is invalid\n"), Info.ID); delete NewTool; } return NewItem; }

void Tool::DeinitTools (   )  [static]

Deletes all allocated tools. Safe to call more than once. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: None Do NOT try to use any tools after calling this. Returns: Errors: None Definition at line 720 of file tool.cpp. { if (Tools != NULL) { // Deselect the current tool, if there is one. if (Current) { Current->SelectChange(FALSE); Current = 0; } // Delete the tool list. delete Tools; Tools = NULL; } ToolSwitchList.DeleteAll(); DeleteTempToolList(); }

void Tool::DeleteTempToolList (   )  [static]

This deletes all temp tool items in the list temp tools. After this call, the temp tool stacking info is lost. This should be called whenever a user selects a new tool directly (i.e. via clicking on the tool icon, a hot key, or menu item). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 8/12/94 Returns: - See also: Tool::ActivateTemporaryTool; Tool::DeactivateTemporaryTool Definition at line 874 of file tool.cpp. { TempToolList.DeleteAll(); }

void Tool::EndDrag (  void   )  [static]

This is called when a drag ends. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: ServicePendingToolChange Definition at line 1077 of file tool.cpp. { ServicePendingToolChange(); }

ToolListItem * Tool::Find (  UINT32  ToolID  )  [static]

Anyone can ask about a tool's presence by its ID. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/93 Parameters: Tool  ID [INPUTS] None  [OUTPUTS] Returns: Pointer to required tool, or NULL if not found. Errors: None Definition at line 508 of file tool.cpp. { // Simple search of list for ID ToolListItem *Item = (ToolListItem *) Tools->GetHead(); while (Item != NULL) { if (Item->m_ToolInfo.ID == ToolID) // Found ID - return pointer to its tool. return Item; Item = (ToolListItem *) Tools->GetNext(Item); } // Not found return NULL; }

Tool * Tool::FindTool (  UINT32  ToolID  )  [static]

Anyone can ask about a tool's presence by its ID. But Geez! The caller doesn't want to know about ToolListItems!!! Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 19/11/2004 Parameters: Tool  ID [INPUTS] None  [OUTPUTS] Returns: Pointer to required tool, or NULL if not found. Errors: None Definition at line 544 of file tool.cpp. { ToolListItem* pItem = Find(ToolID); if (pItem) return pItem->m_pTool; return NULL; }

Tool * Tool::GetCurrent (   )  [static]

Determine the current tool. Scope: Public static. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 19/10/94 Returns: A pointer to the current tool, or NULL if there isn't one. Definition at line 1772 of file tool.cpp. { return Current; }

UINT32 Tool::GetCurrentID (   )  [static]

Determine the current tool. Scope: Public static. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 19/10/94 Returns: The ID of the current tool, or 0 if none is selected. Definition at line 1809 of file tool.cpp. { if (Current) return Current->GetID(); else return 0; }

ToolListItem * Tool::GetFirstTool (   )  [static]

Called for the currently-selected tool when the current DocView changes. Called when the selected DocView changes, ie. the user has moved the focus to another document view window. Allows the Tool to update the info bar according to its internal settings and values. Usually called when the info bar is first created and when a new tool becomes selected.Allows the tool to handle UI events from the info bar. It is similar to the DialogOp::HandleMessage function. returns the first Tool in the list. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 19/8/93 Returns: A pointer to the first tool if list is not empty and NULL otherwise Definition at line 1728 of file tool.cpp. { if (Tool::Tools) return (ToolListItem*) Tool::Tools->GetHead(); else return NULL; }

UINT32 Tool::GetModuleID (  UINT32  ToolID  )  [static]

Particulary useful for error handling, it allows the owner module ID to be determined given just a tool ID. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 20/8/93 Parameters: Tool  ID [INPUTS] None  [OUTPUTS] Returns: Module ID of parent module, or 0 if not found. Errors: 0 if cannot be found. Definition at line 570 of file tool.cpp. { if ( ToolID == TOOLID_INVALID ) return 0; // If unknown tool do nothing! const ToolListItem *Tool = Tool::Find(ToolID); if (Tool) return Tool->m_ToolInfo.ParentModuleID; // return ID if found else return 0; // 0=not found }

ToolListItem * Tool::GetNextTool (  ToolListItem *  CurrTool  )  [static]

return the next Tool in the list Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 19/8/93 Parameters: pointer  to last Tool return by GetFirst ot GetNextDescriptor [INPUTS] Returns: A pointer to the first tool if list is not empty and NULL otherwise Definition at line 1749 of file tool.cpp. { if (Tool::Tools) return (ToolListItem*) Tool::Tools->GetNext( CurrTool ); else return NULL; }

UINT32 Tool::GetNumTools (   )  [static]

Find out how many tools have registered and initialised successfully. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 13/9/93 Returns: The number of tools registered with the kernel. Definition at line 484 of file tool.cpp. { if (Tools == NULL) return 0; else return (UINT32) Tools->GetCount(); }

OILTool * Tool::GetOILTool (  UINT32  ID  )  [static]

Given a Tool ID, returns a pointer to the OILTool object associated with this tool. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 6/7/93 Parameters: ID  - The ID of the Tool [INPUTS] -  [OUTPUTS] Returns: Pointer to the OILTool object for this tool. Errors: Returns NULL if the associated OILTool object does not exist (maybe the tool ID is invalid?) See also: ToolListItem Definition at line 759 of file tool.cpp. { /*ToolListItem *Item =*/ Find(ID); // return Item ? Item->m_pOILTool : NULL; return NULL; }

BOOL Tool::InitToolList (   )  [static]

Initialise the static ToolList object which holds all tools that the kernel knows about. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 1/7/93 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if list initialised ok, FALSE otherwise. Errors: Assert if list is already initialised. Definition at line 314 of file tool.cpp. { ENSURE(Tools == NULL, "Attempt to initialise the ToolList more than once"); Tools = new ToolList; return (Tools != NULL); }

BOOL Tool::InitTools (   )  [static]

Called at the end of initialisation (as it may well need all other initialisations to have been done) to add Tools and Modules to the Kernel's knowledgebase. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 21/6/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: TRUE if OK, FALSE for catastrophic failure Errors: None Scope: Public Definition at line 340 of file tool.cpp. { BOOL Finished; do { // All the tools have been 'new'ed now. We can now ask them to initialise themselves. // If they don't want to, they get 'delete'ed. ToolListItem *Item = (ToolListItem *) Tools->GetHead(); Finished = TRUE; while (Item != NULL) { Tool *Tool = Item->m_pTool; // If this tool exists and has not been initialised yet, then try to // initialise it. If it initialises ok, set the item's flag, and force // another scan of the remaining tools in case one of them depends on // this tool being present. if( NULL != Tool && !Item->m_fInitialised && Tool->Init() ) { Item->m_fInitialised = TRUE; // Tool initialised ok. Finished = FALSE; // At least one more loop to try } // Try the next tool Item = (ToolListItem *) Tools->GetNext(Item); } } while (!Finished); // Delete any un-initialised tools ToolListItem *Item = (ToolListItem *) Tools->GetHead(); while (Item != NULL) { ToolListItem *NextItem = (ToolListItem*) Tools->GetNext(Item); if ((Item->m_pTool != NULL) && (!Item->m_fInitialised)) { // the Tool didn't want to play, so remove it // we've already got the next item, so its OK to kill the old one delete Tools->RemoveItem( Item ); // remove from list & free up } // Try the next tool Item = NextItem; } // default to Selector tool in case we cant find a pref InitTool = TOOLID_SELECTOR; // declare a pref if( Camelot.DeclareSection( _T("InitialTool"), 1 ) ) Camelot.DeclarePref( _T("InitialTool"), _T("InitTool"), &InitTool ); return TRUE; // no error return possible at present }

BOOL Tool::IsToolChanging (   )  [static]

Lets you see the state of the ToolChanging flag. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE - tool is in the middle of changing FALSE - oh no it's not! See also: - Definition at line 937 of file tool.cpp. { return (ToolChanging); }

void Tool::OnActivateApp (  BOOL  bActive  )  [static]

This is called when the app's active state changes. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/2/96 Parameters: bActive  - this is ignored [INPUTS] -  [OUTPUTS] Returns: - See also: ServicePendingToolChange Definition at line 1096 of file tool.cpp. { ServicePendingToolChange(); }

void Tool::RemoveDirectRegToolSwitches (  Tool *  pThisTool  )  [static]

This goes through the list of registered tool switches and removes all switches that belong to the given tool and were defined directly, i.e. ones that were NOT defined via a file. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/94 Parameters: pThisTool  = the tool in question [INPUTS] -  [OUTPUTS] Returns: - Errors: - Definition at line 1141 of file tool.cpp. { ToolSwitch* pToolSwitch; ToolSwitch* pNextToolSwitch = (ToolSwitch*)ToolSwitchList.GetHead(); while (pNextToolSwitch != NULL) { pToolSwitch = pNextToolSwitch; pNextToolSwitch = (ToolSwitch*)ToolSwitchList.GetNext(pNextToolSwitch); if (pToolSwitch->pTool == pThisTool && !pToolSwitch->DefFromFile) { // if this tool switch belongs to the given tool // and it was a directly defined one, remove it from // the list and delete it ToolSwitchList.RemoveItem(pToolSwitch); delete pToolSwitch; } } }

static BOOL Tool::SelectATool (   )  [static]

void Tool::SelectFirstTool (   )  [static]

Selects the tool that is retrieved from the prefs file. If no pref is found will default to Selector Tool - If the appropriate tool can't be found the first will be used instead. Author: Chris_Parks (Xara Group Ltd) <camelotdev@xara.com> Date: 9/1/95 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: Tool::InitTools Definition at line 423 of file tool.cpp. { // look for the initial tool ToolListItem* pItem = (ToolListItem*) Find(InitTool); // if we can't find it go for the first if(pItem == NULL) pItem = (ToolListItem*) Tools->GetHead(); if (pItem != NULL && pItem->m_pTool != NULL) pItem->m_pTool->SetCurrent(); }

void Tool::ServicePendingToolChange (   )  [static]

This is called when a drag ends, or the app's active state changes This will deactivate the temporary tool if a deactivate key event was encounted during a drag. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/2/96 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: EndDrag(), OnActivateApp() Definition at line 1117 of file tool.cpp. { if (PendingDeactivateTempTool) { DeactivateTemporaryTool(); PendingDeactivateTempTool = FALSE; } }

void Tool::SetButtons (  BOOL  State  )

Selects/Deselects the buttons associated with this buttons. Author: Chris_Parks (Xara Group Ltd) <camelotdev@xara.com> Date: 6/6/94 Parameters: State  to set buttons to [INPUTS] None  [OUTPUTS] Returns: None Errors: None Definition at line 596 of file tool.cpp. { #if !defined(EXCLUDE_FROM_RALPH) String OpToken; camSnprintf(OpToken, 16, _T("TOOL%u"), GetID()); ToolOpDescriptor* ToolOp = (ToolOpDescriptor *) OpDescriptor::FindOpDescriptor(OpToken); // Keep Select state in the OpDescriptor ToolOp->SetCurrentTool(State); List * pGadgetList = new List; if (pGadgetList == 0) { InformError(); return; } //Build list of all controls linked to this Op if (!ToolOp->BuildGadgetList(pGadgetList)) { TRACEUSER( "Chris", _T("Couldn't build gadget list in Tool::SetCurrent\n")); delete pGadgetList; return; } ListItem* pListItem = pGadgetList->GetHead(); while (pListItem != NULL) { // Set the Select State of each gadget GadgetListItem* pGadgetItem = (GadgetListItem*) pListItem; pGadgetItem->pDialogOp->SetLongGadgetValue(pGadgetItem->gidGadgetID, State, FALSE, FALSE); // Do the next control in the list, if any. pListItem = pGadgetList->GetNext(pListItem); } // Don't forget to delete the list afterwards! pGadgetList->DeleteAll(); delete pGadgetList; #endif }

void Tool::SetCurrent (   )

Sets the 'this' tool to be the current tool. Author: Mario_Shamtani (Xara Group Ltd) <camelotdev@xara.com> Date: 19/8/93 Parameters: None  [INPUTS] None  [OUTPUTS] Returns: None Errors: None Definition at line 652 of file tool.cpp. { if(Current == this) { // Ensure the buttons are set right Current->SetButtons(SELECTED); return ; } SetToolChangingState(TRUE); // Deselect current tool if (Current) { Current->SetButtons(DESELECTED); Current->SelectChange(FALSE); OpDescriptor::RemoveAllAliases(); } // Find the CurrentAttributeGroup associated with the Tool we are switching away from CCRuntimeClass* OldCurrentAttrGroup = NULL; if (Current) OldCurrentAttrGroup = Current->Parent->m_ToolInfo.CurrentAttributeGroup; // Select new tool. Current = this; SetButtons(SELECTED); // Inform tool that it has been selected. SelectChange(TRUE); // save ID in preference InitTool = GetID(); SetToolChangingState(FALSE); TempToolItem* pTempToolItem = (TempToolItem*)TempToolList.GetHead(); if (pTempToolItem != NULL && pTempToolItem->GetTempTool() != Current) DeleteTempToolList(); // Finally if the CurrentAttributeGroup has changed then tell people if (Parent->m_ToolInfo.CurrentAttributeGroup != OldCurrentAttrGroup) { BROADCAST_TO_ALL(ToolsCurrentAttrGroupChangedMsg); } }

void Tool::SetNoCurrent (   )  [static]

Sets no tool as the current tool. Scope: Public static. Author: Andy_Pennell (Xara Group Ltd) <camelotdev@xara.com> Date: 19/10/94 Definition at line 1788 of file tool.cpp. { if (Current) { Current->SelectChange(FALSE); } Current = NULL; }

void Tool::SetToolChangingState (  BOOL  state  )  [static]

Check to see if the currently active tool is permanently or temporarily active. If, e.g. the user is holding down ALT to get the selector tool, then this returns TRUE. Lets you set the ToolChanging flag. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 25/05/94 Parameters: state  - boolean used to set ToolChanging flag [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 917 of file tool.cpp. { ToolChanging = state; }

BOOL Tool::SwitchTool (  KeyPress *  pKeyPress  )  [static]

The place where tool switching takes place. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 30/8/94 Parameters: pKeyPress  = ptr to the key press that's just occurred [INPUTS] -  [OUTPUTS] Returns: TRUE - the key press caused a tool switch, do not pass on FALSE - no tool switching, see if anyone else wants it See also: - Definition at line 957 of file tool.cpp. { BOOL Processed = FALSE; BOOL DuringADrag = (Operation::GetCurrentDragOp() != NULL); #if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX) DuringADrag = (DuringADrag || BaseBar::IsDragging()); #endif ToolSwitch* pToolSwitch = (ToolSwitch*)ToolSwitchList.GetHead(); while (pToolSwitch != NULL && !Processed) { // Is it a tool switch key press? if (*pToolSwitch->pKeyPress == *pKeyPress) { // This key press is a tool switch combination for a tool // Are we waiting to deactivate the temp tool at the end of a drag? if (!PendingDeactivateTempTool) { // We are NOT wait to deactivate the temp tool at the end of a drag, so proceed // pTool is the ptr to the tool in question Tool* pTool = pToolSwitch->pTool; // Is it a "key down" key press? if (pKeyPress->IsPress()) { // It's a "key down" event // Is it the first "key down", or has it auto-repeated? if (!pKeyPress->IsRepeat()) { // It's the first press // is it already the current tool? if (pTool != Current) { // We now have the first "key down" of a tool switch for a tool that // is NOT the current tool // is a drag happening? if (!DuringADrag) { // If we are not doing this during a drag, make it the current tool. // Also, set the Temp flag to FALSE as it may be a permanent change ActivateTemporaryTool(pTool); pToolSwitch->Temp = FALSE; } } else { // We now have the first "key down" of a tool switch for a tool that // IS the current tool // If we are not dragging, deactivate the tool if (!DuringADrag) DeactivateTemporaryTool(); else // Remember to deactivate the tool after the drag has ended PendingDeactivateTempTool = TRUE; } } else { // It's an auto-repeated key press // if the switch belongs to the current tool, and is auto-repeated // make the switch temporary if (pTool == Current) pToolSwitch->Temp = TRUE; } } else { // It's a "key up" event // Does it belong to the current tool? if (pTool == Current) { // "Key up" on a tool switch for the current tool. // If the current tool was selected temporarily, select the previous current tool if (pToolSwitch->Temp) { // If we are not dragging, deactivate the tool if (!DuringADrag) DeactivateTemporaryTool(); else // Remember to deactivate the tool after the drag has ended PendingDeactivateTempTool = TRUE; } } } } // The key press object was a tool switching one, so we have processed the key press Processed = TRUE; } // Get the next tool switch in the list pToolSwitch = (ToolSwitch*)ToolSwitchList.GetNext(pToolSwitch); } return Processed; }

---

Member Data Documentation

Tool * Tool::Current = NULL [static, private]

Definition at line 466 of file tool.h.

UINT32 Tool::InitTool [static]

Definition at line 436 of file tool.h.

BOOL Tool::PendingDeactivateTempTool = FALSE [static, private]

Definition at line 470 of file tool.h.

List Tool::TempToolList [static, private]

Definition at line 471 of file tool.h.

BOOL Tool::ToolChanging = FALSE [static, private]

Definition at line 469 of file tool.h.

ToolList * Tool::Tools = NULL [static, private]

Definition at line 465 of file tool.h.

---

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

• Kernel/tool.h (r1785/r1535)
• Kernel/tool.cpp (r1785/r1535)

---