HotKey Class Reference

Encapsulates hot keys in camelot. More...

#include <hotkeys.h>

Inheritance diagram for HotKey:

List of all members.

Public Member Functions
void	GetTextDesc (String_256 *pStr)
	Stuffs the hot key text desc (if it has one) into *pStr.
Static Public Member Functions
static BOOL	Init ()
	Initialises the HotKey class. At the moment it just involves the reading of the hot key definitions.
static void	Deinit ()
	Cleans up the HotKey class on program exit.
static BOOL	AddHotKey (KeyPress *pKeyPress, TCHAR *pOpToken, String_32 *pTextDesc, BOOL CheckUnicode)
	The place where hot keys are added to Camelot.
static BOOL	OnKeyPress (KeyPress *pKeyPress)
	This will invoke an operation if the given key press matches a registered hot key.
static HotKey *	FindHotKey (OpDescriptor *pThisOpDesc)
	Finds the first hot key that is associated with the given op desc NULL is returned if there isn't one or the hot key has been disabled.
Private Member Functions
	HotKey ()
	The default constructor. Does nothing at the moment.
	~HotKey ()
	The default destructor. Main job is to delete any attached objects (such as the key press object).
BOOL	IsEnabled ()
	Tests to see if it is possible to invoke a hot key's operation. This will also update the status bar with a relevent message. If the op is enabled, a general description of the op is displayed If the op is disabled, a description of why is displayed.
Static Private Member Functions
static BOOL	DoesHotKeyMatchKeyPress (HotKey *pHotKey, KeyPress *pKeyPress)
	Central routine for checking HotKeys against key press objects.
static BOOL	ReadHotKeys ()
	Reads the hot key definitions from somewhere (either file or bound-in resource file).
static BOOL	ReadHotKeysFromDisk ()
	Reads the hot key definitions from disk (i.e. writable media).
static BOOL	ReadHotKeysFromRes ()
	Reads the hot key definitions from the bound in resource.
static BOOL	ReadHotKeysFromFile (CCLexFile &file)
	Reads the hot key definitions from the given file.
static BOOL	ReadHotKey (CCLexFile &file)
	Read one hot key definition from the given file.
static BOOL	ReadToolSwitch (CCLexFile &file)
	Read one tool switch definition from the given file.
static BOOL	ReadKeyDef (CCLexFile &file, KeyPress **ppKeyPress, String_256 *pOpToken, String_32 **ppTextDesc, BOOL *pCheckUnicode)
	Generates a key press object and op token from the given file.
Private Attributes
KeyPress *	pKeyPress
OpDescriptor *	pOpDesc
String_32 *	pTextDesc
BOOL	CheckUnicode

---

Detailed Description

Encapsulates hot keys in camelot.

Author:

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

Date:

31/8/94

Definition at line 121 of file hotkeys.h.

---

Constructor & Destructor Documentation

HotKey::HotKey (   )  [private]

The default constructor. Does nothing at the moment. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 31/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 228 of file hotkeys.cpp. { pKeyPress = NULL; pOpDesc = NULL; pTextDesc = NULL; CheckUnicode= FALSE; }

HotKey::~HotKey (   )  [private]

The default destructor. Main job is to delete any attached objects (such as the key press object). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 251 of file hotkeys.cpp. { if (pKeyPress != NULL) { delete pKeyPress; pKeyPress = NULL; } if (pTextDesc != NULL) { delete pTextDesc; pTextDesc = NULL; } }

---

Member Function Documentation

BOOL HotKey::AddHotKey (  KeyPress *  pKeyPress, TCHAR *  pOpToken, String_32 *  pTextDesc, BOOL  CheckUnicode )  [static]

The place where hot keys are added to Camelot. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 31/8/94 Parameters: pKeyPress  = ptr to the key press that will invoke the operation [INPUTS] pOpToken = ptr to the char array of the operation's op token pTextDesc = ptr to a string that describes the hot key (e.g. "Ctrl+X") CheckUnicode= Flag to determine how the hot key is compared with key press objects -  [OUTPUTS] Returns: TRUE if it could find the operation and the ky press was valid FALSE if something hideous happend See also: - Definition at line 284 of file hotkeys.cpp. { PORTNOTE( "other", "AddHotKey - Carry on even if OpDesc not found" ); BOOL ok = TRUE; // Is this key press ok? if (pKeyPress->IsValid()) { // We have a valid key press object, but do we have a valid op token? OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(pOpToken); if (pOpDesc != NULL) { // Yes, we now have a valid op token too. Now make a HotKey object HotKey* pHotKey = new HotKey; if (pHotKey != NULL) { // We have everything we need, so set up the HotKey and add it to the list pHotKey->pKeyPress = pKeyPress; pHotKey->pOpDesc = pOpDesc; pHotKey->pTextDesc = pTextDesc; pHotKey->CheckUnicode= CheckUnicode; HotKeyList.AddTail(pHotKey); ok = TRUE; } } else { TRACE( _T("HotKey: Unable to find op desc \"%s\"\n"),pOpToken); // These will only get deleted if we return false so delete them here delete pKeyPress; delete pTextDesc; } } return ok; }

void HotKey::Deinit (  void   )  [static]

Cleans up the HotKey class on program exit. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - See also: - Definition at line 208 of file hotkeys.cpp. { HotKeyList.DeleteAll(); }

BOOL HotKey::DoesHotKeyMatchKeyPress (  HotKey *  pHotKey, KeyPress *  pKeyPress )  [static, private]

Central routine for checking HotKeys against key press objects. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 25/7/95 Parameters: pHotKey  = ptr to HotKey [INPUTS] pKeyPress = ptr to KeyPress -  [OUTPUTS] Returns: TRUE if HotKey matches the key press, FALSE otherwise See also: - Definition at line 403 of file hotkeys.cpp. { ERROR3IF(pHotKey == NULL,"pHotKey == NULL"); ERROR3IF(pKeyPress == NULL,"pHotKey == NULL"); if (pHotKey == NULL || pKeyPress == NULL) return FALSE; if (pHotKey->CheckUnicode) { ERROR3IF(pHotKey->pTextDesc == NULL,"pHotKey->pTextDesc == NULL"); if (pHotKey->pTextDesc == NULL) return FALSE; TCHAR str[3]; str[0] = (pKeyPress->GetUnicode() & 0xff); str[1] = ((pKeyPress->GetUnicode() & 0xff00)>>8); str[2] = 0; String_32 KeyPressStr = String_32(str); return (KeyPressStr == *pHotKey->pTextDesc); } else return (*pHotKey->pKeyPress == *pKeyPress); }

HotKey * HotKey::FindHotKey (  OpDescriptor *  pThisOpDesc  )  [static]

Finds the first hot key that is associated with the given op desc NULL is returned if there isn't one or the hot key has been disabled. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/9/94 Parameters: pThisOpDesc  = ptr to an op desc [INPUTS] Returns: ptr to a HotKey, or NULL See also: OpDescriptor::IsHotKeyEnabled() Definition at line 446 of file hotkeys.cpp. { if (!pThisOpDesc->IsHotKeyEnabled()) { return NULL; } HotKey* pHotKey = (HotKey*)HotKeyList.GetHead(); while (pHotKey != NULL && (pHotKey->pOpDesc != pThisOpDesc)) pHotKey = (HotKey*)HotKeyList.GetNext(pHotKey); return pHotKey; }

void HotKey::GetTextDesc (  String_256 *  pStr  )

Stuffs the hot key text desc (if it has one) into *pStr. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/9/94 Parameters: pStr  = ptr to a string to put the text desc of the hot key [INPUTS] *pStr  contains the description [OUTPUTS] Returns: - See also: - Definition at line 1008 of file hotkeys.cpp. { ENSURE(pStr != NULL,"pStr is NULL"); if (pStr == NULL) return; if (pTextDesc != NULL) *pStr = *pTextDesc; }

BOOL HotKey::Init (  void   )  [static]

Initialises the HotKey class. At the moment it just involves the reading of the hot key definitions. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE otherwise See also: - Reimplemented from SimpleCCObject. Definition at line 189 of file hotkeys.cpp. { return (HotKey::ReadHotKeys()); }

BOOL HotKey::IsEnabled (   )  [private]

Tests to see if it is possible to invoke a hot key's operation. This will also update the status bar with a relevent message. If the op is enabled, a general description of the op is displayed If the op is disabled, a description of why is displayed. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the hot key operation is enabled FALSE otherwise Errors: None Definition at line 479 of file hotkeys.cpp. { ENSURE(pOpDesc != NULL, "Hot key's op desc ptr is NULL"); // Check if the hot key is available to the user, i.e., it is shown if (!pOpDesc->IsHotKeyEnabled()) { return FALSE; } // String that will contain the string to display in the status bar String_256 StatusMsg; // get hotkey's op state OpState HotKeyState = pOpDesc->GetOpsState(&StatusMsg); // If the op state is greyed, then the description of why it's grey should have been // set up by the GetOpsState() call // If it's not greyed, get a general description of the op to place in the status bar if (!HotKeyState.Greyed) pOpDesc->GetText(&StatusMsg,OP_DESC_TEXT); // Display msg in the status bar GetApplication()->UpdateStatusBarText(&StatusMsg); // Return TRUE if not greyed return (!HotKeyState.Greyed); }

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

This will invoke an operation if the given key press matches a registered hot key. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 31/8/94 Parameters: pKeyPress  = ptr to the key press that's just been generated [INPUTS] -  [OUTPUTS] Returns: TRUE if processed (i.e. a hot key was pressed), so do not pass on FALSE if not processed, so pass on to others See also: - Definition at line 344 of file hotkeys.cpp. { TRACEUSER( "jlh92", _T("Key VK=%04x (%08x) in Hotkey\n"), pKeyPress->GetVirtKey(), pKeyPress->GetUnicode() ); BOOL Processed = FALSE; BOOL DuringADrag = (Operation::GetCurrentDragOp() != NULL || DragManagerOp::IsDragActive() || BaseBar::IsDragging()); HotKey* pHotKey = (HotKey*)HotKeyList.GetHead(); while (pHotKey != NULL && !Processed) { if (DoesHotKeyMatchKeyPress(pHotKey,pKeyPress)) { TRACEUSER( "jlh92", _T("Key VK=%04x (%08x) handled as HotKey\n"), pKeyPress->GetVirtKey(), pKeyPress->GetUnicode() ); // The key press is a hot key combination if ((pHotKey->pKeyPress->IsOkInDrags() || !DuringADrag) && pKeyPress->IsPress()) { // There is no drag happening (or the keypress works in drags), and it is a "key down" key press // If the hot key's op is enabled, invoke it if (pHotKey->IsEnabled()) pHotKey->pOpDesc->Invoke(); } // Do not pass on if it is a hot key combination, whether the op was invoked or not Processed = TRUE; } // Get the next hot key pHotKey = (HotKey*)HotKeyList.GetNext(pHotKey); } if( !Processed ) { TRACEUSER( "luke", _T("Key VK=%04x (%08x) not handled as HotKey\n"), pKeyPress->GetVirtKey(), pKeyPress->GetUnicode() ); } return Processed; }

BOOL HotKey::ReadHotKey (  CCLexFile &  file  )  [static, private]

Read one hot key definition from the given file. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/9/94 Parameters: file  = file that contains the hot key definitions [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE otherwise See also: - Definition at line 698 of file hotkeys.cpp. { KeyPress* pKeyPress = NULL; String_256 OpToken; String_32* pTextDesc = NULL; BOOL CheckUnicode; BOOL ok = HotKey::ReadKeyDef(file,&pKeyPress,&OpToken,&pTextDesc,&CheckUnicode); if (ok) { ok = HotKey::AddHotKey(pKeyPress,OpToken,pTextDesc,CheckUnicode); if (!ok) TRACE( _T("HotKey: Unable to add hot key to the system\n")); } else { delete pKeyPress; delete pTextDesc; } return (ok); }

BOOL HotKey::ReadHotKeys (   )  [static, private]

Reads the hot key definitions from somewhere (either file or bound-in resource file). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE otherwise See also: - Definition at line 525 of file hotkeys.cpp. { BOOL ok = HotKey::ReadHotKeysFromDisk(); if (!ok) ok = HotKey::ReadHotKeysFromRes(); return (ok); }

BOOL HotKey::ReadHotKeysFromDisk (   )  [static, private]

Reads the hot key definitions from disk (i.e. writable media). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE otherwise See also: - Definition at line 548 of file hotkeys.cpp. { CCDiskFile file; // File FilePath filepath = KeyPress::GetHotKeysFilename(); if (!filepath.IsValid()) return FALSE; BOOL ok = TRUE; // Prevent file errors from being reported directly to the user BOOL OldThrowingState = file.SetThrowExceptions( TRUE ); BOOL OldReportingState = file.SetReportErrors( FALSE ); try { ok = file.open(filepath, ios::in); // Open file if (ok) { ok = HotKey::ReadHotKeysFromFile(file); file.close(); } } catch (...) { Error::ClearError(); ok = FALSE; } // Must set the exception throwing and reporting flags back to their entry states file.SetThrowExceptions( OldThrowingState ); file.SetReportErrors( OldReportingState ); return ok; }

BOOL HotKey::ReadHotKeysFromFile (  CCLexFile &  file  )  [static, private]

Reads the hot key definitions from the given file. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/9/94 Parameters: file  = file that contains the hot key definitions [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE otherwise See also: - Definition at line 629 of file hotkeys.cpp. { BOOL finished = FALSE; BOOL ok;; // Initialise lexing routines, and aspects of the lexer ok = file.InitLexer(); file.SetDelimiters("\r\n"); // Set token delimiting characters file.SetCommentMarker(';'); // Set comment marker char file.SetWhitespace(" \t"); // Set whitespace chars file.SetStringDelimiters("\"\""); // Set string delimiters HK_TokenIndex Token; const TCHAR* TokenBuf = file.GetTokenBuf(); // Token buffer remains constant until lexer deinitialisation while (ok && !finished) { // Grab a token ok = file.GetSimpleToken(); // Look the token up in our table Token = FindToken(TokenBuf); switch (Token) { case HK_TOKEN_HOTKEY: ok = HotKey::ReadHotKey(file); break; case HK_TOKEN_TOOLSWITCH: ok = HotKey::ReadToolSwitch(file); break; case HK_TOKEN_HOTKEYEND: finished = TRUE; break; default: TRACE( _T("HotKey: Unexpected token - %s\n"),TokenBuf); break; } } if (!ok) { TRACE( _T("\nHotKey: Offending line - %s\n"),file.GetLineBuf()); ENSURE(FALSE,"Error reading hot keys. See TRACE output for details"); } // We are now finished with the lexer file.DeinitLexer(); return (ok); }

BOOL HotKey::ReadHotKeysFromRes (   )  [static, private]

Reads the hot key definitions from the bound in resource. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 5/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE otherwise See also: - Definition at line 600 of file hotkeys.cpp. { CCResTextFile file; // Resource File BOOL ok = file.open(_R(IDH_STANDARD_HOTKEYS), _R(IDT_CAM_HOTKEY_RES)); // Open resource if (ok) { ok = HotKey::ReadHotKeysFromFile(file); file.close(); } return (ok); }

BOOL HotKey::ReadKeyDef (  CCLexFile &  file, KeyPress **  ppKeyPress, String_256 *  pOpToken, String_32 **  ppTextDesc, BOOL *  pCheckUnicode )  [static, private]

Generates a key press object and op token from the given file. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/94 Parameters: file  = file that contains the key definitions [INPUTS] ppKeyPress = Place to put the ptr to a key press object pOpToken = ptr to string to place the op token string ppTextDesc = ptr to a ptr to a String_32 object that describes the key def (e.g. "Ctrl+X") pCheckUnicode = Flag to determine how the hot key is compared with key press objects *ppKeyPress  = a ptr to a key press object OR NULL [OUTPUTS] pOpToken = op token of op associated with the key press object OR empty string ppTextDesc = ptr to a String_32 describing the key combination. If this is NULL, then the key combo has no text description pCheckUnicode = TRUE if Unicode checking should be done, FALSE otherwise Returns: TRUE if OK FALSE otherwise (syntax error, not enough memory, etc) See also: - Definition at line 817 of file hotkeys.cpp. { // Check the params ENSURE(ppKeyPress != NULL,"ppKeyPress is NULL"); ENSURE(pOpToken != NULL,"pOpToken is NULL"); ENSURE(ppTextDesc != NULL,"ppTextDesc is NULL"); ENSURE(pCheckUnicode!= NULL,"pCheckUnicode is NULL"); if (ppKeyPress == NULL || pOpToken == NULL || ppTextDesc == NULL || pCheckUnicode == NULL) return FALSE; *ppKeyPress = NULL; // We haven't made a key press object yet *ppTextDesc = NULL; // No text description yet *pCheckUnicode = FALSE; // Assume we don't want Unicode checking HK_TokenIndex Token; const TCHAR* TokenBuf = file.GetTokenBuf(); // This set of parameters will combine to form a key press object that represents // the hot key combination UINT32 VirtKey = CAMKEY(CC_NONE); BOOL Adjust = FALSE; BOOL Constrain = FALSE; BOOL Alternative = FALSE; BOOL Extended = FALSE; BOOL WorksInDrag = FALSE; String_32* pTextDesc = NULL; // This is FALSE until we have read the text that describes the key combination BOOL TextDescRead = FALSE; BOOL EnumStringRead = FALSE; // We haven't finsihed, but we're OK at the mo BOOL finished = FALSE; BOOL ok = TRUE; while (ok && !finished) { // Get the next token ok = file.GetSimpleToken(); if (ok) { // Find out the type of the token LexTokenType TokenType = file.GetTokenType(); switch (TokenType) { case TOKEN_STRING: if (!EnumStringRead) { // The first string encountered is the "WXK_" string representation of // the enumeration. // Make sure the enum string is not too long. UINT32 TokenLen = camStrlen(TokenBuf); if (TokenLen <= ENUM_STR_DESC_SIZE) { // Is the string not empty (i.e. "") ? if (TokenLen > 0) { VirtKey=wxKeyMap::GetKeyVal(TokenBuf); } } else TRACE( _T("HotKey: Enum string ('%s') is too long - should be <= %d"),TokenBuf,ENUM_STR_DESC_SIZE); EnumStringRead = TRUE; } else if (!TextDescRead) { // We haven't yet read the textual desc of the key definition, so assume // that this is it // Make sure the desc is not too long UINT32 TokenLen = camStrlen(TokenBuf); if (TokenLen <= TEXT_DESC_SIZE) { // Is the string not empty (i.e. "") ? if (TokenLen > 0) { // if there is a valid text desc, get a String_32 ready for it // and put the desc in it pTextDesc = new String_32; if (pTextDesc != NULL) *pTextDesc = TokenBuf; else TRACE( _T("HotKey: Not enough memory for a String_32 - pathetic eh?")); } } else TRACE( _T("HotKey: Menu text ('%s') is too long - should be <= %d"),TokenBuf,TEXT_DESC_SIZE); // We have read the text desc string TextDescRead = TRUE; } else { // When we get a string after the menu text string, assume this is // the op token of the operation the hot key is intended to invoke // Also, regard the op token string as the last aspect of a key def *pOpToken = TokenBuf; finished = TRUE; } break; case TOKEN_NORMAL: { Token = FindToken(TokenBuf); switch (Token) { case HK_TOKEN_ADJUST : Adjust = TRUE; break; case HK_TOKEN_CONSTRAIN : Constrain = TRUE; break; case HK_TOKEN_ALTERNATIVE : Alternative = TRUE; break; case HK_TOKEN_EXTENDED : Extended = TRUE; break; case HK_TOKEN_WORKSINDRAG : WorksInDrag = TRUE; break; case HK_TOKEN_CHECKUNICODE : *pCheckUnicode = TRUE; break; case HK_TOKEN_NONE: //Should no longer get this token. /*ok = (camSscanf(TokenBuf,_T("%li"),&VirtKey) == 1); if (!ok) TRACE( _T("HotKey: Expected a virtual key code but got : '%s'\n"),TokenBuf); break;*/ default: ok = FALSE; TRACE( _T("HotKey: Didn't expect to get this token ('%s') in the middle of a hot key def\n"),TokenBuf); break; } } break; default: TRACE( _T("HotKey: Unexpected token - %s\n"),TokenBuf); ok = FALSE; break; } } } if (ok) { ok = (VirtKey != CAMKEY(CC_NONE)); if (ok) { *ppKeyPress = new KeyPress(VirtKey,Adjust,Constrain,Alternative,Extended,WorksInDrag); ok = (*ppKeyPress != NULL); if (ok) *ppTextDesc = pTextDesc; else TRACE( _T("HotKey: Not enough memory for the key press object")); } else TRACE( _T("HotKey: Virtual key code was not found\n")); } if (!ok) { if (*ppKeyPress != NULL) { delete *ppKeyPress; *ppKeyPress = NULL; } if (pTextDesc != NULL) { delete pTextDesc; pTextDesc = NULL; } } return (ok); }

BOOL HotKey::ReadToolSwitch (  CCLexFile &  file  )  [static, private]

Read one tool switch definition from the given file. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 6/9/94 Parameters: file  = file that contains the tool switch definitions [INPUTS] -  [OUTPUTS] Returns: TRUE if OK, FALSE otherwise See also: - Definition at line 735 of file hotkeys.cpp. { KeyPress* pKeyPress = NULL; String_256 OpToken; String_32* pTextDesc = NULL; // This is not used with tool switches BOOL CheckUnicode; // This is not used with tool switches BOOL ok = HotKey::ReadKeyDef(file,&pKeyPress,&OpToken,&pTextDesc,&CheckUnicode); // This text desc is ignored at the mo by the tool switch mechanism // so if ReadKeyDef() happens to return one, destory it if (pTextDesc != NULL) { delete pTextDesc; pTextDesc = NULL; } if (ok) { OpDescriptor* pOpDesc = OpDescriptor::FindOpDescriptor(OpToken); ok = (pOpDesc != NULL); if (ok) { UINT32 ToolID = pOpDesc->GetToolID(); ToolListItem* pToolListItem = Tool::Find(ToolID); ok = ((pToolListItem != NULL) && (pToolListItem->m_pTool != NULL)); if (ok) { ok = pToolListItem->m_pTool->RegisterToolSwitch(pKeyPress,TRUE); if (!ok) { TRACE( _T("HotKey: Unable to register the tool switch\n")); delete pKeyPress; } } else TRACE( _T("HotKey: Dodgy ToolListItem for the tool ID %ld\n"),ToolID); } else TRACE( _T("HotKey: Unable to find op '%s'\n"),(TCHAR*)OpToken); } else { delete pKeyPress; } return (ok); }

---

Member Data Documentation

BOOL HotKey::CheckUnicode [private]

Definition at line 155 of file hotkeys.h.

KeyPress* HotKey::pKeyPress [private]

Definition at line 152 of file hotkeys.h.

OpDescriptor* HotKey::pOpDesc [private]

Definition at line 153 of file hotkeys.h.

String_32* HotKey::pTextDesc [private]

Definition at line 154 of file hotkeys.h.

---

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

• Kernel/hotkeys.h (r1785/r1282)
• Kernel/hotkeys.cpp (r1785/r1769)

---