KeyPress Class Reference

Encapsulates key presses in camelot. More...

#include <keypress.h>

List of all members.

Public Member Functions
	KeyPress (KeyPressSysMsg *pKeySysMsg, WCHAR UnicodeChar)
	Constructs a KeyPress object from the given parameters.
	KeyPress (UINT32 VirtKey, BOOL PlusAdjust=FALSE, BOOL PlusConstrain=FALSE, BOOL PlusAlternative=FALSE, BOOL ExtendedKey=FALSE, BOOL WorksInDragsKey=FALSE)
	Constructs a KeyPress object from the given parameters This constructor is for use by systems that deal with "hot keys", i.e. ones that are only interested in the physical key that is being pressed.
	KeyPress (const KeyPress &c)
BOOL	IsValid ()
	Allows you to see if the KeyPress is legal. The default KeyPress constuctor will always create invalid instances. It is up to other constructors, or member functions, to generate valid ones.
UINT32	GetVirtKey ()
WCHAR	GetUnicode ()
BOOL	IsAdjust ()
BOOL	IsConstrain ()
BOOL	IsAlternative ()
BOOL	IsOption ()
BOOL	IsModified ()
BOOL	IsExtended ()
BOOL	IsRepeat ()
BOOL	IsRightHand ()
BOOL	IsRelease ()
BOOL	IsChar ()
BOOL	IsPress ()
BOOL	IsOkInDrags ()
INT32	operator== (const KeyPress &)
	KeyPress == operator Two KeyPress objects are equal if 1) They have the same virtual key code 2) Have the same modifier settings 3) Have the same extended flag settings 4) Have the same validity (i.e. both valid OR both invalid).
Static Public Member Functions
static BOOL	Init ()
	Initialises the KeyPress class.
static FilePath	GetHotKeysFilename ()
static BOOL	DispatchKeyEvent (UINT32 nMsgID, UINT32 nChar, UINT32 nRepCnt, UINT32 nFlags)
	Packages an MFC key-stroke message into a form suitable for the kernel and calls the keyboard system with the event.
static BOOL	TranslateMessage (wxKeyEvent *pMsg)
	Called from a low-level PreTranslateMessage() routine to allow key presses to be processed If it is a key press message, it generates a KeyPress object and sends it off to Application::OnKeyPress().
static void	ResetModifierKeys ()
	Maintain integrity of our key modifier status. Win32S doesn't always tell us what key events have occured - notably when the user uses Alt-TAB to switch tasks. Hence this gets called whenever our main window is deactivated or activated. The temporary tool is updated if required.
static BOOL	GenerateCharMessage (wxKeyEvent *pMsg)
	This tries to see if the keypress message can generate a WM_CHAR message.
static BOOL	IsAdjustPressed ()
	Tests status of the "Adjust" key.
static BOOL	IsConstrainPressed ()
	Tests status of the "Constrain" key.
static BOOL	IsAlternativePressed ()
	Tests status of the "Alternative" key.
static BOOL	IsEscapePressed ()
	Lets you see if an escape key combination is currently being pressed, or has been pressed since the last call to this routine.
static BOOL	IsKeyPressed (UINT32 VirtKey)
	General async keypress func call.
static BOOL	ModifierChanged ()
static BOOL	IsGalleryShiftPressed (void)
	Tests status of the "Gallery Shift" key This is a special method for use by galleries, which must emulate the action of windows list boxes. "Gallery Shift" is the key used to select multiple items at once.
static BOOL	IsGalleryCtrlPressed (void)
	Tests status of the "Gallery Ctrl" key This is a special method for use by galleries, which must emulate the action of windows list boxes. "Gallery Ctrl" is the key used to add/remove single items to/from a selection.
static KeyPress *	ConstructVK (TCHAR ch)
	Constructs a keypress that represents the keypress required to generate the specified character. The Virtual Code will be CAMKEY(CC_NONE) if the key cannot be generated.
static BOOL	AddVirtualKeyCode (UINT32 VCode, WCHAR Unicode)
	Adds the given virtual key code to the list that Camelot knows about and send around internally (rather than ignoring).
static void	RemoveVirtualKeyCode (UINT32 VCode, WCHAR Unicode)
	Removes the given virtual key code that generates the givne unicode value from the list of additional virtual key codes. Only the first occurace is removed.
Private Member Functions
	CC_DECLARE_MEMDUMP (KeyPress)
	KeyPress ()
	Default constructor. Creates an invalid keypress object. The KeyPress class will have one or more public constructors or static member functions for creating valid KeyPress objects.
void	Initialise ()
	Initialises all member variables of the KeyPress object to sensible values.
Static Private Member Functions
static BOOL	GenerateKeyPress (wxKeyEvent *pMsg, KeyPress **ppKeyPress)
	Generates a legal, platform-independent key press object from the raw platform-dependent data provided.
static INT32	GenerateUnicode (UINT32 VirtKey, UINT32 ScanCode, BYTE *pKeyState, WCHAR *pWideCharBuf, UINT32 WideCharBufSize)
	Converts a virtual key code into a Unicode char. This is a layer on top of the Windows ToUnicode() function that will generate Unicodes in the corporate user zone for keys that do not have a standard Unicode evivalent (e.g. function keys).
static BOOL	IgnoreKeyMessage (KeyPressSysMsg *pKeySysMsg)
	This filters out any invalid key messages that we may get from Windows, such as auto-repeated modifier (shift, ctrl, alt) keys.
static BOOL	IsModifier (UINT32 VirtKey)
	Central modifier key identifying routine. The modifiers are as follows : Both Alt keys Both Shift keys Both Ctrl keys.
static void	UpdateModifierStatus (KeyPressSysMsg *pKeySysMsg)
	If the message is a modifier key press, the static status vars for the modifier keys in the KeyPress class are updated.
static KeyPress *	MakeKeyPress (KeyPressSysMsg *pKeySysMsg)
	Makes a KeyPress from a KeyPressSysMsg.
static BOOL	EscapePressed (KeyPress *pKeyPress)
	Deals with an Escape key press.
Private Attributes
UINT32	VirtKey
WCHAR	Unicode
BOOL	Adjust: 1
BOOL	Constrain: 1
BOOL	Alternative: 1
BOOL	Option: 1
BOOL	Extended: 1
BOOL	Repeat: 1
BOOL	RightHand: 1
BOOL	Release: 1
BOOL	m_fIsChar: 1
BOOL	Valid: 1
BOOL	WorksInDrag: 1
Static Private Attributes
static BOOL	AdjustStateLeft = FALSE
static BOOL	AdjustStateRight = FALSE
static BOOL	ConstrainStateLeft = FALSE
static BOOL	ConstrainStateRight = FALSE
static BOOL	AlternativeStateLeft = FALSE
static BOOL	AlternativeStateRight = FALSE
static BOOL	OptionStateLeft = FALSE
static BOOL	OptionStateRight = FALSE
static BOOL	fModifierChanged = FALSE
static INT32	AsciiVal = -1
static BOOL	ValidAsciiVal = FALSE
static BYTE	LastLeadByte = 0
static List	AdditionalVirtKeys

---

Detailed Description

Encapsulates key presses in camelot.

Author:

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

Date:

24/8/94

Definition at line 187 of file keypress.h.

---

Constructor & Destructor Documentation

KeyPress::KeyPress (  KeyPressSysMsg *  pKeySysMsg, WCHAR  UnicodeChar )

Constructs a KeyPress object from the given parameters. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 26/8/94 Parameters: pKeySysMsg  = Ptr to a platform indepenent version of a Windows key press message [INPUTS] UnicodeChar = The Unicode char this key press should have -  [OUTPUTS] Returns: - Errors: - See also: KeyPress::IsValid, KeyPress::GenerateKeyPress Definition at line 516 of file keypress.cpp. { VirtKey = pKeySysMsg->VirtKey; Unicode = UnicodeChar; Adjust = KeyPress::AdjustStateLeft | KeyPress::AdjustStateRight; Constrain = KeyPress::ConstrainStateLeft | KeyPress::ConstrainStateRight; Alternative = KeyPress::AlternativeStateLeft | KeyPress::AlternativeStateRight; Option = KeyPress::OptionStateLeft | KeyPress::OptionStateRight; Extended = pKeySysMsg->Extended; // Interpret Alt+Ctrl as Extended Alt, because AltGr (UK right hand Alt) produces an additional // Ctrl key press that is indistinguishable from a left hand Ctrl. // This means that left hand Alt+Ctrl will appear the same as right hand AltGr to Camelot. // E.g. Alt+Ctrl+Spacebar == AltGr+Spacebar if (Alternative && Constrain) { Extended = TRUE; Constrain = FALSE; } Repeat = pKeySysMsg->PrevDown; RightHand = pKeySysMsg->Extended; Release = (pKeySysMsg->Message == KM_KEYUP); m_fIsChar = (pKeySysMsg->Message == KM_CHAR); Valid = TRUE; // This is now a valid KeyPress object. }

KeyPress::KeyPress (  UINT32  ThisVirtKey, BOOL  PlusAdjust = FALSE, BOOL  PlusConstrain = FALSE, BOOL  PlusAlternative = FALSE, BOOL  ExtendedKey = FALSE, BOOL  WorksInDragsKey = FALSE )

Constructs a KeyPress object from the given parameters This constructor is for use by systems that deal with "hot keys", i.e. ones that are only interested in the physical key that is being pressed. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 30/8/94 Parameters: ThisVirtKey  = The virtual key code of the key you want to use [INPUTS] PlusAdjust = TRUE if the key should be modified by the Adjust key PlusConstrain = TRUE if the key should be modified by the Constrain key PlusAlternative = TRUE if the key should be modified by the Alternative key ExtendedKey = TRUE if you are specifying an extended key (e.g. "Enter" key instead of "Return") WorksInDragsKey = TRUE if you want this keypress to work in the middle of drags. -  [OUTPUTS] Returns: - Errors: - See also: KeyPress::IsValid, KeyPress::GenerateKeyPress Definition at line 572 of file keypress.cpp. { Initialise(); VirtKey = ThisVirtKey; Adjust = PlusAdjust; Constrain = PlusConstrain; Alternative = PlusAlternative; Extended = ExtendedKey; WorksInDrag = WorksInDragsKey; Valid = TRUE; }

KeyPress::KeyPress (  const KeyPress &  c  )  [inline]

Definition at line 218 of file keypress.h. : // Copy constructor as CCObject's is private which prevents synthesis working VirtKey(c.VirtKey), Unicode(c.Unicode), Adjust(c.Adjust), Constrain(c.Constrain), Alternative(c.Alternative), Option(c.Option), Extended(c.Extended), Repeat(c.Repeat), RightHand(c.RightHand), Valid(c.Valid) {}

KeyPress::KeyPress (   )  [private]

Default constructor. Creates an invalid keypress object. The KeyPress class will have one or more public constructors or static member functions for creating valid KeyPress objects. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 24/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: KeyPress::IsValid, KeyPress::GenerateKeyPress Definition at line 495 of file keypress.cpp. { Initialise(); }

---

Member Function Documentation

BOOL KeyPress::AddVirtualKeyCode (  UINT32  VCode, WCHAR  Unicode )  [static]

Adds the given virtual key code to the list that Camelot knows about and send around internally (rather than ignoring). Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/95 Parameters: VCode  - the virtual key code to add [INPUTS] Unicode - the unicode value generated when this key is pressed -  [OUTPUTS] Returns: TRUE/FALSE for success/failure Errors: - See also: - Definition at line 1789 of file keypress.cpp. { // Construct a list item AdditionalVirtKey* pNew = new AdditionalVirtKey; if (pNew != NULL) { pNew->VirtualKeyCode = VCode; pNew->UnicodeValue = Unicode; AdditionalVirtKeys.AddHead(pNew); } return (pNew != NULL); }

KeyPress::CC_DECLARE_MEMDUMP (  KeyPress   )  [private]

KeyPress * KeyPress::ConstructVK (  TCHAR  ch  )  [static]

Constructs a keypress that represents the keypress required to generate the specified character. The Virtual Code will be CAMKEY(CC_NONE) if the key cannot be generated. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/95 Parameters: ch  - ASCII/Unicode value of required keypress [INPUTS] -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 604 of file keypress.cpp. { // PORTNOTETRACE( "other", "KeyPress::ConstructVK - do nothing" ); KeyPress* pNew = new KeyPress(); #if !defined(EXCLUDE_FROM_XARALX) if (pNew != NULL) { INT8 Result = ::VkKeyScan(ch); BYTE LowByte = Result & 0xFF; BYTE HighByte = (Result >> 8) & 0xFF; if ((HighByte == 0xFF) && (LowByte == 0xFF)) { pNew->VirtKey = CAMKEY(CC_NONE); } else { pNew->VirtKey = LowByte; pNew->Adjust = HighByte & 1; pNew->Constrain = HighByte & 2; pNew->Alternative = HighByte & 4; } } #endif return pNew; }

BOOL KeyPress::DispatchKeyEvent (  UINT32  nMsgID, UINT32  nChar, UINT32  nRepCnt, UINT32  nFlags )  [static]

Packages an MFC key-stroke message into a form suitable for the kernel and calls the keyboard system with the event. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 7/10/94 Parameters: nMsgID  the Windows ID of the key message, eg. WM_KEYDOWN [INPUTS] nChar the virtual key code / char value (depending on you believe) nRepCnt repeat count nFlags keyboard state flags, eg. key down or up -  [OUTPUTS] Returns: TRUE if the app processed the event. Errors: - See also: KeyPress::TranslateMessage Definition at line 454 of file keypress.cpp. { // Make sure the kernel knows which view/doc the event applies to, if any. if (Document::GetSelected() != NULL) Document::GetSelected()->SetCurrent(); if (DocView::GetSelected() != NULL) DocView::GetSelected()->SetCurrent(); PORTNOTETRACE("other,", "BaseTextClass::PreOpProcessing - do nothing" ); #ifndef EXCLUDE_FROM_XARALX // For compatibility with existing code we must repackage the unpacked message. // NB. the RHS of the lParam expression will work for Win16 as well. MSG msg; msg.message = nMsgID; msg.wParam = nChar; msg.lParam = (nRepCnt & 0xFFFF) | ((((LPARAM) nFlags) & 0xFFFF) << 16); // Call the key-press system. return TranslateMessage(&msg); #else return true; #endif }

BOOL KeyPress::EscapePressed (  KeyPress *  pKeyPress  )  [static, private]

Deals with an Escape key press. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 15/9/94 Parameters: pKeyPress  = ptr to a key press [INPUTS] -  [OUTPUTS] Returns: TRUE - the key was an escape event (e.g. Escape, Break, etc) FALSE - the key was not an escape key, nothing happened If the key press was NOT an escape key, (i.e. not Escape or Ctrl+Pause (Break)), nothing happens, and FALSE is returned if it was an escape key press, it is processed in a relevent way At the moment, this just means that the current drag is terminated, if there is one. If it's an escape key press, and it was acted upon (e.g. a drag was terminated), TRUE is returned. Otherwise FALSE is returned See also: Definition at line 1447 of file keypress.cpp. { ENSURE(pKeyPress->IsValid(),"Invalid KeyPress given"); BOOL Processed = FALSE; UINT32 VirtKey = pKeyPress->GetVirtKey(); // Only check non-auto-repeat "key down" key presses if (pKeyPress->IsPress() && !pKeyPress->IsRepeat()) { if (VirtKey == CAMKEY(ESCAPE) || VirtKey == WXK_CANCEL) { #if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX) // MarkN I've moved this code in an attempt to stop the selection being // cleared after a bar drag cancel - Chris. if (!Processed) Processed = BaseBar::EscPressed(TRUE); // cancel any drag manager drags (and say that we have done so!!!) // stops the selection being cleared when you cancel a // colour or sprite (or any) DragManagerOp drag if(!Processed && DragManagerOp::GetCurrentManager() != NULL) { DragManagerOp::AbortDrag(); Processed = TRUE; } #endif if (!Processed && Operation::GetCurrentDragOp() != NULL) { OilCoord PointerPos(0,0); ClickModifiers ClickMods; // Spread* pSpread = NULL; DocView* pDocView = DocView::GetSelected(); if (pDocView) pDocView->DragFinished(Operation::GetCurrentDragOp(), PointerPos, ClickMods, FALSE); // We've done something with this escape key press so set Processed to TRUE // to prevent it from being passed on Processed = (Operation::GetCurrentDragOp() == NULL); } if (!Processed && Operation::GetCurrentDragOp() != NULL) { DocCoord PointerPos(0,0); ClickModifiers ClickMods; Spread* pSpread = NULL; Operation::GetCurrentDragOp()->DragFinished(PointerPos, ClickMods, pSpread, FALSE, FALSE); // We've done something with this escape key press so set Processed to TRUE // to prevent it from being passed on Processed = TRUE; } // This gives Chris a chance to terminate his bar dragging. This was necessary as his former // way of detecting Escape (via KeyMsg broadcasts) no longer works because Escape is now a hot key, and // as such gets in there before a KeyMsg is broadcast. // (MarkN 27/4/95) /*if (!Processed) Processed = BaseBar::EscPressed(TRUE); */ // Throw away all pending key messages PORTNOTE( "other", "Remove PeekMessage" ) #if !defined(EXCLUDE_FROM_XARALX) MSG msg; while(PeekMessage( &msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE )) ; #endif } } return Processed; }

BOOL KeyPress::GenerateCharMessage (  wxKeyEvent *  pMsg  )  [static]

This tries to see if the keypress message can generate a WM_CHAR message. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 10/3/95 Parameters: pMsg  = A Windows keypress message [INPUTS] -  [OUTPUTS] Returns: TRUE if the message was processed FALSE if the message wasn't processed It does this by trapping numerical key pad entry of the ASCII value of the char while the Alt ky is held down. (e.g. hold down ALT, type '6' then '5' on the num key pad, then release Alt - you should get 'A' appearing at the input focus). If, on a Alt key up event we have a valid ASCII value that's been entered, we post ourselves a WM_CHAR message containing the ASCII char. We have to do this ourselves because we get less messages generated in Win 3.1 than we do in NT, so the NT solution (act upon the auto generated WM_CHAR message) won't work an all target platforms (pain in the butt or what?). The ideal solution is to find out exactly why we don't get this extra WM_CHAR message in Win3.1, but I've traced paths of key press messages under NT and have found no obvious reason why the Win3.1 should behave differently. As we don't have single stepping technology under Win3.1, it's almost impossible to determine what's going on. So, the time honoured CC tradition, if the OS doesn't do it, we'll do it ourselves. Returns: Errors: - See also: KeyPress::TranslateMessage Definition at line 1556 of file keypress.cpp. { BOOL Processed = FALSE; // Get the virtual key code for the key pressed UINT32 VirtKey = pMsg->GetKeyCode(); //DumpKeyMessage(pMsg); if( wxEVT_KEY_DOWN == pMsg->GetEventType() ) { if (VirtKey == CAMKEY(MENU)) { // Trap ALL Alt key down messages if (!KeyPress::ValidAsciiVal) { // Initialise a ASCII value entry //TRACE( _T("-*-*-*-- Starting valid ascii val\n")); KeyPress::ValidAsciiVal = TRUE; KeyPress::AsciiVal = -1; } } else if (KeyPress::ValidAsciiVal && ((VirtKey < CAMKEY(NUMPAD0)) || (VirtKey > WXK_NUMPAD9))) { // If the key down message is not a num pad key between '0' and '9' // invalidate the ASCII value //TRACE( _T("-*-*-*-- (keydown) Invalidating ascii val\n")); KeyPress::ValidAsciiVal = FALSE; } } else if( wxEVT_KEY_UP == pMsg->GetEventType() ) { if (KeyPress::ValidAsciiVal) { // Only try to produce an ASCII value if the last set of key presses has generated // a valid value if (VirtKey == CAMKEY(MENU)) { // We've received a Alt key up message, so post ourselves a WM_CHAR message that // contains the generated ASCII value if (KeyPress::AsciiVal >= 0) { // Only post the ASCII value if one's been specified via the Num key pad // (i.e. the value >= 0) //TRACE( _T("-*-*-*-- Posting WM_CHAR. Val = %ld\n"),KeyPress::AsciiVal); PORTNOTE("other", "Removed PostMessage usage - WM_CHAR from ascii code" ) #ifndef EXCLUDE_FROM_XARALX Processed = ::PostMessage(pMsg->hwnd,WM_CHAR,KeyPress::AsciiVal % 256,1); #endif } //TRACE( _T("-*-*-*-- (keyup) Invalidating ascii val. Val = %ld\n"),KeyPress::AsciiVal); KeyPress::ValidAsciiVal = FALSE; } else if ((VirtKey >= CAMKEY(NUMPAD0)) && (VirtKey <= WXK_NUMPAD9)) { // We've got a num key pad key up event // We have to do this bit on key up events, because for some reason under NT (and possibly // other OSs) we don't get a key down event for the first key that's pressed while the // Alt key is auto-repeating (wierd - any ideas welcome) // If this is the first one (i.e. ASCII val is currently < 0), reset the value to 0 if (KeyPress::AsciiVal < 0) KeyPress::AsciiVal = 0; // Shift the current value up, and add in the digit of the num key pad key. KeyPress::AsciiVal = ((KeyPress::AsciiVal*10)+(VirtKey-CAMKEY(NUMPAD0))); // We've processed this key press Processed = TRUE; //TRACE( _T("-*-*-*-- ascii val digit received. Val = %ld\n"),KeyPress::AsciiVal); } } } return Processed; }

BOOL KeyPress::GenerateKeyPress (  wxKeyEvent *  pMsg, KeyPress **  ppKeyPress )  [static, private]

Generates a legal, platform-independent key press object from the raw platform-dependent data provided. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 24/8/94 Parameters: pMsg  = A Windows message [INPUTS] *ppKeyPress  = ptr to the generated KeyPress object, or NULL if not enough memory [OUTPUTS] Returns: TRUE if the message was to do with a key press. FALSE if the message wasn't to do with the keyboard at all & *ppKeyPress is unspecified Errors: If the virtual key code doesn't have an equivalent Unicode value (either standard, or one that we have allocated to it), then KeyPress::IsValid() will return FALSE. See also: KeyPress::IsValid Definition at line 1109 of file keypress.cpp. { // Ensure *ppKeyPress is valid, just in case we have to exit the function early *ppKeyPress = NULL; // Create a platform-indy key press message object KeyPressSysMsg KeySysMsg(pMsg); if (KeySysMsg.IsValid()) { // If it's a key press message that we can ignore, then ignore it, pretending we have processed it if (!IgnoreKeyMessage(&KeySysMsg)) { // We like the look of this key press event // Ensure the modifier key states are up to date UpdateModifierStatus(&KeySysMsg); // Make a KeyPress object *ppKeyPress = MakeKeyPress(&KeySysMsg); // If the mods have changed, and we were able to make a keypress object, send // a "modifiers have changed message" if (KeyPress::fModifierChanged && *ppKeyPress != NULL) { BROADCAST_TO_ALL(KeyMsg(KeyMsg::MODIFIERCHANGED,*ppKeyPress)); } } #ifdef _DEBUG /* if (*ppKeyPress != NULL) { char s[1000]; _stprintf(s,"Mess = %d, Virtkey = 0x%lx, Ext = %d, PrevD = %d, Shift = %d, Ctrl = %d, Alt = %d, AShift = 0x%x, ACtrl = 0x%x, AAlt = 0x%x, IsAd = %d, IsCon = %d, IsAlt = %d", KeySysMsg.Message, KeySysMsg.VirtKey, KeySysMsg.Extended, KeySysMsg.PrevDown, KeyPress::AdjustStateLeft | KeyPress::AdjustStateRight, KeyPress::ConstrainStateLeft | KeyPress::ConstrainStateRight, KeyPress::AlternativeStateLeft | KeyPress::AlternativeStateRight, AsyncShift, AsyncCtrl, AsyncAlt, (*ppKeyPress)->IsAdjust(), (*ppKeyPress)->IsConstrain(), (*ppKeyPress)->IsAlternative() ); ENSURE(FALSE,s); } */ //DumpKeyMessage(pMsg); #endif // _DEBUG // Return TRUE to say that it really was a keyboard message return TRUE; } else return FALSE; // Not a keybaord type event that we're interested in }

INT32 KeyPress::GenerateUnicode (  UINT32  VirtKey, UINT32  ScanCode, BYTE *  pKeyState, WCHAR *  pWideCharBuf, UINT32  WideCharBufSize )  [static, private]

Converts a virtual key code into a Unicode char. This is a layer on top of the Windows ToUnicode() function that will generate Unicodes in the corporate user zone for keys that do not have a standard Unicode evivalent (e.g. function keys). > static INT32 KeyPress::GenerateUnicode(UINT32 VirtKey,UINT32 ScanCode,BYTE* pKeyState,WCHAR* pWideCharBuf,INT32 WideCharBufSize) Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 25/8/94 Parameters: VirtKey  = a Windows virtual key code [INPUTS] ScanCode = the scan code generated by the keyboard pKeyState = 256 byte array filled with the current keyboard state via GetKeyboardState pWideCharBuf = buffer to stick the Unicode char(s) into WideCharBufSize = the size of the wide char buffer (min value of 2) pWideCharBuf  will contain 1 WCHAR at index [0] [OUTPUTS] Returns: The number of Unicode chars generated (see the Windows ToUnicode() function) If the internal call to ToUnicode() fails, but the VirtKey is an alphabetic key, a Unicode code is generated that is equivalent to pressing Ctrl+<alphabetic key>="">, e.g. Ctrl+A = 1, Ctrl+B = 2. This happens when you press Ctrl+Alt+<alphabetic key>="">, which is only really used by the hot key system, so therefore the actual unicode code is not significant (correct at time of writing - Markn 11/1/95) Returns: Errors: - See also: KeyPress::IsValid Definition at line 749 of file keypress.cpp. { #if defined(__WXMSW__) // Make sure we have a buffer to use ENSURE(WideCharBufSize >= 2,"The wide char buffer size should be at least 2"); if (WideCharBufSize < 2) return 0; INT32 NumChars = ToUnicode(VirtKey,ScanCode,pKeyState,pWideCharBuf,WideCharBufSize,0); // NumChars == 0 if ToUnicode() failed to generate a code for the keypress // If no direct eqivalent Unicode char, see if we can generate one with the ASCII value for the VirtKey // or look one up in our extra Unicode table if (NumChars == 0) { WORD pWordBuf[10]; // See if ToAscii() can make a Latin I ASCII char out of it INT32 NumASCIIChars = ToAscii(VirtKey,ScanCode,pKeyState,pWordBuf,0); if (NumASCIIChars == 1) { // Map the lower byte ASCII value onto the equivalent Unicode char pWideCharBuf[0] = pWordBuf[0] & 0xff; NumChars = 1; } } if (NumChars == 0) { // ToAscii() failed, so lets have a look in our table INT32 i=0; BOOL finished = FALSE; do { // We've finished if we've reached the ungeneratable VK code finished = (ExtraUnicodes[i].VirtKey == CAMKEY(CC_NONE)); if (!finished && ExtraUnicodes[i].VirtKey == VirtKey) { // We have found an entry in our table for the given virtual key // Stuff the Unicode value into the buffer and set the num chars generated to 1 pWideCharBuf[0] = ExtraUnicodes[i].Unicode; NumChars = 1; finished = TRUE; } i++; } while (!finished); // Check the runtime list too if (NumChars != 1) { finished = FALSE; AdditionalVirtKey* pKey = (AdditionalVirtKey*)AdditionalVirtKeys.GetHead(); while (!finished && (pKey != NULL)) { if (pKey->VirtualKeyCode == VirtKey) { pWideCharBuf[0] = pKey->UnicodeValue; NumChars = 1; finished = TRUE; } pKey = (AdditionalVirtKey*)AdditionalVirtKeys.GetNext(pKey); } } } if (NumChars == 0) { // If the virt key is obviously one that should be handled (i.e. an alphabetical key), // we automatically generate a code. // This Unicode code will be the same as the one generated by Ctrl+<alphabetical key> // // "Why do we need this?" I hear you scream. This is because ToUnicode() fails when you do a // Ctrl+Alt+<key>. As this is an important modifier combo used by the hot key system, we need to make it work. // // Markn - 11/1/95 if (VirtKey >= 'A' && VirtKey <= 'Z') { pWideCharBuf[0] = VirtKey - 'A'; NumChars = 1; } } #ifdef _DEBUG /* if (IsUserName("MarkN") && (NumChars == 0)) { Beep(); TRACE( _T("\n***\nVirtKey %lx has no Unicode equivalent!\n***\n"),VirtKey); } */ #endif // Return the number of Unicode chars that have been dumped into the buffer return NumChars; #else return 0; #endif }

FilePath KeyPress::GetHotKeysFilename (   )  [static]

Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 8/Jun/2006 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: PathName reference to location of hotkeys config file Definition at line 421 of file keypress.cpp. { FilePath result; wxStandardPaths Paths; wxString strPath( Paths.GetUserConfigDir() ); strPath += _T("/.xaralx/hotkeys"); if (wxFile::Exists(strPath)) result.SetPathName(strPath, FALSE); return result; }

WCHAR KeyPress::GetUnicode (   )  [inline]

Definition at line 230 of file keypress.h. { return Unicode; } // Returns the unicode char generated by the virtual key

UINT32 KeyPress::GetVirtKey (   )  [inline]

Definition at line 229 of file keypress.h. { return VirtKey; } // Returns the virtual key code

BOOL KeyPress::IgnoreKeyMessage (  KeyPressSysMsg *  pKeySysMsg  )  [static, private]

This filters out any invalid key messages that we may get from Windows, such as auto-repeated modifier (shift, ctrl, alt) keys. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 25/8/94 Parameters: pKeySysMsg  = Ptr to a platform indepenent version of a Windows key press message [INPUTS] -  [OUTPUTS] Returns: TRUE if the key press message should be ignored FALSE if the key press message should be processed Errors: - See also: KeyPress::GenerateKeyPress Definition at line 873 of file keypress.cpp. { // PORTNOTETRACE( "other", "KeyPress::IgnoreKeyMessage - do nothing" ); ENSURE(pKeySysMsg->IsValid(),"Invalid KeyPressSysMsg given"); // Ignore if it's a key down msg, and the key is a modifier, and it's an auto-repeat message BOOL Ignore = (pKeySysMsg->Message == KM_KEYDOWN && KeyPress::IsModifier(pKeySysMsg->VirtKey) && pKeySysMsg->PrevDown); #if !defined(EXCLUDE_FROM_XARALX) KeyPress* pNew = new KeyPress(); if (UnicodeManager::IsDBCSOS()) { // handling for DBCS characters; they roll up as two sepearte WM_CHAR messages if (!Ignore && pKeySysMsg->Message==KM_CHAR) { if (LastLeadByte==0 && IsDBCSLeadByte(pKeySysMsg->VirtKey)) { // It's a lead byte so store it away for the next message and ignore this one TRACE( _T("Lead byte %d\n"), pKeySysMsg->VirtKey); LastLeadByte = pKeySysMsg->VirtKey; Ignore = TRUE; } } } #endif return Ignore; }

BOOL KeyPress::Init (  void   )  [static]

Initialises the KeyPress class. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 26/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if initialised correctly Errors: - See also: KeyPress::IsValid, KeyPress::GenerateKeyPress Definition at line 401 of file keypress.cpp. { return TRUE; }

void KeyPress::Initialise (   )  [private]

Initialises all member variables of the KeyPress object to sensible values. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/96 Parameters: -  [INPUTS] See  below [OUTPUTS] Returns: - Errors: - See also: KeyPress constructors Definition at line 649 of file keypress.cpp. { // Some highly unlikely Unicode char Unicode = 0xffff; // A highly unlikely virtual key VirtKey = CAMKEY(CC_NONE); // Set all the flags to FALSE Adjust = FALSE; Constrain = FALSE; Alternative = FALSE; Option = FALSE; Extended = FALSE; Repeat = FALSE; RightHand = FALSE; Release = FALSE; m_fIsChar = FALSE; // This is an invalid KeyPress object at the moment Valid = FALSE; }

BOOL KeyPress::IsAdjust (   )  [inline]

Definition at line 233 of file keypress.h. { return Adjust; }

BOOL KeyPress::IsAdjustPressed (   )  [static]

Tests status of the "Adjust" key. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 1/12/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the "Adjust" key is currently depressed. Errors: - See also: - Definition at line 1225 of file keypress.cpp. { return ::wxGetKeyState(CAMKEY(CC_MOD_ADJUST)); }

BOOL KeyPress::IsAlternative (   )  [inline]

Definition at line 235 of file keypress.h. { return Alternative; }

BOOL KeyPress::IsAlternativePressed (   )  [static]

Tests status of the "Alternative" key. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 1/12/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the "Alternative" key is down. Errors: - See also: - Definition at line 1265 of file keypress.cpp. { return ::wxGetKeyState(CAMKEY(CC_MOD_ALTERNATIVE)); }

BOOL KeyPress::IsChar (   )  [inline]

Definition at line 243 of file keypress.h. { return m_fIsChar; }

BOOL KeyPress::IsConstrain (   )  [inline]

Definition at line 234 of file keypress.h. { return Constrain; }

BOOL KeyPress::IsConstrainPressed (   )  [static]

Tests status of the "Constrain" key. Author: Justin_Flude (Xara Group Ltd) <camelotdev@xara.com> Date: 1/12/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the "Constrain" key is down. Errors: - See also: - Definition at line 1245 of file keypress.cpp. { return ::wxGetKeyState(CAMKEY(CC_MOD_CONSTRAIN)); }

BOOL KeyPress::IsEscapePressed (   )  [static]

Lets you see if an escape key combination is currently being pressed, or has been pressed since the last call to this routine. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 16/9/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE - if an escape key is being pressed, or was pressed since the last call to this routine FALSE - no escape key has been pressed It does a GetAsyncKeyState() on certain key combinations, currently - CAMKEY(ESCAPE) CAMKEY(CANCEL) (Ctrl-Pause, or Break) GetAsyncKeyState() returns the current key state AND whether the key was pressed since the last call to GetAsyncKeyState(). Note: If TRUE is returned, all pending key messages will have been removed before hand. using PeekMessage(...WM_KEYFIRST,WM_KEYLAST,PM_REMOVE) See also: Definition at line 1368 of file keypress.cpp. { PORTNOTE("other", "KeyPress::IsEscapePressed - do nothing" ) #ifndef EXCLUDE_FROM_XARALX // TRACE( _T("Warning - KeyPress::IsEscapePressed called") ); /* BOOL EscapePressed = (GetAsyncKeyState(CAMKEY(ESCAPE)) != 0); BOOL Pressed = EscapePressed || (GetAsyncKeyState(CAMKEY(CANCEL)) != 0); if (Pressed) { BOOL EscapeKeyDown = FALSE; // Throw away all pending key messages MSG msg; while(PeekMessage( &msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE )) { //