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 )) { // If we the actual Escape key has been pressed, see if we got an Escape Key Down event. if (EscapePressed) { KeyPressSysMsg KeyMsg(&msg); if (KeyMsg.IsValid() && (KeyMsg.Message == KM_KEYDOWN) && (KeyMsg.VirtKey == CAMKEY(ESCAPE))) EscapeKeyDown = TRUE; } } // Alt+Tab Esc fix - i.e. Aborting a task switch via Alt+Tab using the Escape key. // // If the actual Escape key has been pressed, only allow it if we have been posted a KeyDown event // for the Escape key. // // When you do Alt+Tab while in Studio, then hit Escape, unfortunately we get posted an Escape Key Up event // which also means that the line above that reads "GetAsyncKeyState(CAMKEY(ESCAPE)) != 0" will return TRUE. // Obviously we want to ignore the Escape key being pressed in this circumstance, but it seems the only way // to identify the Escape key press as one we don't want is to see if we *don't* have a corresponding // key down event. // // if (GetAsyncKeyState(CAMKEY(ESCAPE)) != 0) // i.e. the Escape key has been pressed // { // if (App received a Escape KeyDown message) // Legitimate Escape key press, so Pressed = TRUE // else // Escape hit outside our app, so ignore it // } // If the ActualEscape key has been pressed, then Pressed should only be TRUE if we have received a // Escape Key Down event. if (EscapePressed) Pressed = EscapeKeyDown; } return (Pressed); */ #endif return false; }

BOOL KeyPress::IsExtended (   )  [inline]

Definition at line 239 of file keypress.h. { return Extended; }

BOOL KeyPress::IsGalleryCtrlPressed (  void   )  [static]

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. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 9/2/95 Returns: TRUE if the "Gallery Ctrl" key is down. Notes: SHOULD NOT be used outside the gallery system Definition at line 1332 of file keypress.cpp. { return ::wxGetKeyState(CAMKEY(CONTROL)); }

BOOL KeyPress::IsGalleryShiftPressed (  void   )  [static]

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. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 9/2/95 Returns: TRUE if the "Gallery Shift" key is down. Notes: SHOULD NOT be used outside the gallery system Definition at line 1307 of file keypress.cpp. { return ::wxGetKeyState(CAMKEY(SHIFT)); }

BOOL KeyPress::IsKeyPressed (  UINT32  VirtKey  )  [static]

General async keypress func call. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 26/7/94 Parameters: VirtKey  = key to check [INPUTS] -  [OUTPUTS] Returns: TRUE if the VirtKey key is down. Errors: - See also: - Definition at line 1283 of file keypress.cpp. { return ::wxGetKeyState( wxKeyCode(VirtKey) ); }

BOOL KeyPress::IsModified (   )  [inline]

Definition at line 237 of file keypress.h. { return (IsAdjust() || IsConstrain() || IsAlternative() || IsOption()); }

BOOL KeyPress::IsModifier (  UINT32  VirtKey  )  [static, private]

Central modifier key identifying routine. The modifiers are as follows : Both Alt keys Both Shift keys Both Ctrl keys. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 26/8/94 Parameters: VirtKey  = A Windows virtual key code [INPUTS] -  [OUTPUTS] Returns: TRUE if the key is one of the modifier keys FALSE otherwise Errors: - See also: - Definition at line 718 of file keypress.cpp. { return (VirtKey == CAMKEY(CC_MOD_ADJUST) || VirtKey == WXK_CC_MOD_CONSTRAIN || VirtKey == WXK_CC_MOD_ALTERNATIVE); }

BOOL KeyPress::IsOkInDrags (   )  [inline]

Definition at line 245 of file keypress.h. { return WorksInDrag; }

BOOL KeyPress::IsOption (   )  [inline]

Definition at line 236 of file keypress.h. { return Option; }

BOOL KeyPress::IsPress (   )  [inline]

Definition at line 244 of file keypress.h. { return !m_fIsChar && !Release; }

BOOL KeyPress::IsRelease (   )  [inline]

Definition at line 242 of file keypress.h. { return Release; }

BOOL KeyPress::IsRepeat (   )  [inline]

Definition at line 240 of file keypress.h. { return Repeat; }

BOOL KeyPress::IsRightHand (   )  [inline]

Definition at line 241 of file keypress.h. { return RightHand; }

BOOL KeyPress::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. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 26/8/94 Parameters: -  [INPUTS] -  [OUTPUTS] Returns: TRUE if the KeyPress object is a valid one. FALSE otherwise Errors: - See also: KeyPress::KeyPress, KeyPress::GenerateKeyPress Definition at line 693 of file keypress.cpp. { return Valid; }

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

Makes a KeyPress from a KeyPressSysMsg. 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] -  [OUTPUTS] Returns: Ptr to a valid KeyPress object OR NULL if not enough memory Errors: - See also: KeyPress::GenerateKeyPress,KeyPress::GenerateUnicode Definition at line 965 of file keypress.cpp. { // PORTNOTETRACE( "other", "KeyPress::MakeKeyPress - do nothing" ); KeyPress* pKeyPress = NULL; // This will point to the key press object // Try and get a Unicode char to represent the key press WCHAR pWideChar[10]; INT32 NumChars = 0; if (pKeySysMsg->Message == KM_CHAR) { #if FALSE != wxUSE_UNICODE NumChars = 1; pWideChar[0] = pKeySysMsg->m_Char; TRACEUSER( "jlh92", _T("Unicode = %c\n"), pKeySysMsg->m_Char ); #else // If the message is a CHAR message, then we need to generate a Unicode value ourselves // using the char code (which is stored in the VirtKey field of the KeyPressSysMsg class) // // These codes are generated by holding down Alt and typing the ASCII value of a character // on the numerical key pad. The Virt key codes generated when doing this fail to produce // Uncode chars, so the key presses never get passed on. However, if after this sequence an // ASCII char is specified (e.g. 'A' via Alt+ '6' '5') a WM_CHAR message is posted, so we need // to trap this and pass the Unicode equivalent of the ASCII char onto Camelot. // // The fake VirtKey code (CAMKEY(CC_NONE)) is specified so that the receiver of this key message // will not process it on the VirtKey code. However, anyone interested in just the Unicode // value (e.g. the text tool) will process it successfully. TRACE( _T("Trail byte %d\n"), pKeySysMsg->VirtKey); char pants[3]; if (UnicodeManager::IsDBCSOS()) { // See if we have a lead byte if (LastLeadByte != 0) { pants[0] = LastLeadByte; pants[1] = pKeySysMsg->VirtKey; pants[2] = 0; pWideChar[0] = UnicodeManager::MultiByteToUnicode(UnicodeManager::ComposeMultiBytes(LastLeadByte, pKeySysMsg->VirtKey)); } else { pants[0] = pKeySysMsg->VirtKey; pants[1] = 0; pWideChar[0] = pKeySysMsg->VirtKey; } LastLeadByte = 0; } else { pants[0] = pKeySysMsg->VirtKey; pants[1] = 0; pWideChar[0] = pKeySysMsg->VirtKey; } TRACE( _T("Entered character %s\n"),pants); TRACE( _T("Unicode value = %X\n"),pWideChar[0]); pKeySysMsg->VirtKey = CAMKEY(CC_NONE); NumChars = 1; #endif } else { #if FALSE != wxUSE_UNICODE NumChars = 1; pWideChar[0] = pKeySysMsg->m_Char; // We still have to try our custom translations (for VirtKey >= WXK_START) if( pKeySysMsg->VirtKey >= WXK_START ) { INT32 i; for( i = 0; ExtraUnicodes[i].VirtKey != CAMKEY(CC_NONE); ++i ) { // We have found an entry in our table for the given virtual key if( ExtraUnicodes[i].VirtKey == pKeySysMsg->VirtKey ) { // Stuff the Unicode value into the buffer and set the num chars generated to 1 pWideChar[0] = ExtraUnicodes[i].Unicode; break; } } // Don't pass on unknown function keys if( ExtraUnicodes[i].VirtKey == CAMKEY(CC_NONE) ) NumChars = 0; } // Windows translates Ctrl+char to control codes, I don't think we need too. Hopefully // just using CR will be enought. if( IsConstrainPressed() ) pWideChar[0] = _T('\n'); #elif defined(__WXMSW__) BYTE pKeyState[256]; // Array to hold the current state of the keyboard if (GetKeyboardState(pKeyState)) // Scan the current keyboard state { NumChars = GenerateUnicode( pKeySysMsg->VirtKey, pKeySysMsg->ScanCode, pKeyState, pWideChar, 10 ); } #else // This should never happen, but just in case we'll use a dumb implementation NumChars = 1; mbtowc( pWideChar, pKeySysMsg->VirtKey ); #endif } if (NumChars == 1) // Make a KeyPress object if we have a valid associated Unicode character { // Construct a KeyPress object pKeyPress = new KeyPress(pKeySysMsg,pWideChar[0]); // If we make an invalid one, delete it and make sure we return NULL if (pKeyPress != NULL && !pKeyPress->IsValid()) { delete pKeyPress; pKeyPress = NULL; } } return pKeyPress; }

static BOOL KeyPress::ModifierChanged (   )  [inline, static]

Definition at line 207 of file keypress.h. { return fModifierChanged; }

INT32 KeyPress::operator== (  const KeyPress &  other  )

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). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 26/8/94 Parameters: other  = the key press you wish to check for equivalence with this key press [INPUTS] -  [OUTPUTS] Returns: TRUE if equal, FALSE otherwise THIS DOES NOT COMPARE THE UNICODE COMPONENTS OF THE TWO KeyPress OBJECTS. To compare Unicode values, use the KeyPress::GetUnicode() func. Returns: Errors: - See also: KeyPress::GetUnicode() Definition at line 1758 of file keypress.cpp. { return ( VirtKey == other.VirtKey && Adjust == other.Adjust && Constrain == other.Constrain && Alternative == other.Alternative && Option == other.Option && Extended == other.Extended && Valid == other.Valid ); }

void KeyPress::RemoveVirtualKeyCode (  UINT32  VCode, WCHAR  Unicode )  [static]

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. Author: Peter_Arnold (Xara Group Ltd) <camelotdev@xara.com> Date: 11/10/95 Parameters: VCode  - the virtual key code to remove [INPUTS] Unicode - the unicode value generated when this key is pressed -  [OUTPUTS] Returns: - Errors: - See also: - Definition at line 1824 of file keypress.cpp. { // Loop through the list until we find the list item BOOL finished = FALSE; AdditionalVirtKey* pKey = (AdditionalVirtKey*)AdditionalVirtKeys.GetHead(); while (!finished && (pKey != NULL)) { AdditionalVirtKey* pNext = (AdditionalVirtKey*)AdditionalVirtKeys.GetNext(pKey); if ((pKey->VirtualKeyCode == VCode) && (pKey->UnicodeValue == Unicode)) { AdditionalVirtKeys.RemoveItem(pKey); delete pKey; finished = TRUE; } pKey = pNext; } }

void KeyPress::ResetModifierKeys (   )  [static]

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. Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> (Equivalent to Tim's ResetModifierKeys() routine) Date: 26/08/94 See also: UpdateTemporaryTool Definition at line 1188 of file keypress.cpp. { //ENSURE(FALSE,"KeyPress::ResetModifierKeys() called"); // We can't trust Win32S to tell us about all keypreses we need to know about, // so set all modifiers to ff to avoid weird effects. if (INCOMPLETE_KEYS) { KeyPress::AdjustStateLeft = FALSE; KeyPress::AdjustStateRight = FALSE; KeyPress::ConstrainStateLeft = FALSE; KeyPress::ConstrainStateRight = FALSE; KeyPress::AlternativeStateLeft = FALSE; KeyPress::AlternativeStateRight = FALSE; KeyPress::OptionStateLeft = FALSE; KeyPress::OptionStateRight = FALSE; } // Temporary tool may have changed - update it. //UpdateTemporaryTool(); }

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

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(). Author: Mark_Neves (Xara Group Ltd) <camelotdev@xara.com> Date: 26/08/94 Parameters: pMsg  = A Windows message [INPUTS] -  [OUTPUTS] Returns: TRUE if the message was to do with a key press AND was processed FALSE if the message wasn't to do with the keyboard at all OR key press was not processed Errors: - See also: Application::OnKeyPress Definition at line 1656 of file keypress.cpp. { #if !defined(EXCLUDE_FROM_RALPH) && !defined(EXCLUDE_FROM_XARALX) // What kind of message is it? BOOL KeyDown = wxEVT_KEY_DOWN == pMsg->GetEventType(); BOOL KeyUp = wxEVT_KEY_UP == pMsg->GetEventType(); // If it's a key event, lose the bubble help. if (KeyDown || KeyUp) ControlHelper::BubbleHelpDisable(); #endif TRACEUSER( "jlh92", _T("TM - %s\n"), wxEVT_KEY_DOWN == pMsg->GetEventType() ? _T("KDN") : wxEVT_KEY_UP == pMsg->GetEventType() ? _T("KUP") : wxEVT_CHAR == pMsg->GetEventType() ? _T("KCH") : _T("K??") ); // Normal key processing. KeyPress* pKeyPress; BOOL Processed = FALSE; // See if we can generate an WM_CHAR message from the key press if (!Processed) Processed = GenerateCharMessage(pMsg); // Can we make a key press event from this message? if (!Processed && KeyPress::GenerateKeyPress(pMsg,&pKeyPress)) { if (pKeyPress != NULL) { // The message was a key press and we have a key press object at pKeyPress // check for an escape key press if (!Processed) Processed = EscapePressed(pKeyPress); // Now see if Camelot wants to use it if (!Processed) Processed = GetApplication()->OnKeyPress(pKeyPress); // Don't process Alt key presses. By always returning FALSE on Alt key presses, we get // normal functionality from single press/releases of Alt, even in the Selector tool if (Processed && pKeyPress->VirtKey == CAMKEY(MENU)) Processed = FALSE; //TRACE( _T("Processed = %d\n"),Processed); // Must delete the key press after use delete pKeyPress; } } if (!Processed) { // MFC ISSUES... // If we have had a key press we wish to ignore totally (i.e. repeated modifier key presses) // then return TRUE so that it doesn't get passed onto the rest of MFC. // // This is mainly for performance improvements during a drag AND modifier key press op, e.g. Alt held down // in the freehand tool for drawing straight lines. // // This fix makes modified drags usable in retail builds. In debug builds, you get an extra hit with // AfxValidateObject (or what ever it's called), which takes about 50% of the time. // // During Drags: // We want to prevent key presses getting to MFC during drags. In particular things like // Ctrl-Tab (i.e. switch to new doc) KeyPressSysMsg KeySysMsg(pMsg); if (KeySysMsg.IsValid()) { // We have a keypress message // Prevent it getting to MFC if we are dragging or it's one we wish to ignore Processed = ((Operation::GetCurrentDragOp()!=NULL) || IgnoreKeyMessage(&KeySysMsg)); } } return Processed; }

void KeyPress::UpdateModifierStatus (  KeyPressSysMsg *  pKeySysMsg  )  [static, private]

If the message is a modifier key press, the static status vars for the modifier keys in the KeyPress class are updated. 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] -  [OUTPUTS] Returns: - Errors: - See also: KeyPress::GenerateKeyPress Definition at line 919 of file keypress.cpp. { ENSURE(pKeySysMsg->IsValid(),"Invalid KeyPressSysMsg given"); // pKeySysMsg is not used at the moment // The modifier key state is read via GetKeyState() BOOL AdjL = KeyPress::AdjustStateLeft; BOOL AdjR = KeyPress::AdjustStateRight; BOOL ConL = KeyPress::ConstrainStateLeft; BOOL ConR = KeyPress::ConstrainStateRight; BOOL AltL = KeyPress::AlternativeStateLeft; BOOL AltR = KeyPress::AlternativeStateRight; BOOL OptL = KeyPress::OptionStateLeft; BOOL OptR = KeyPress::OptionStateRight; KeyPress::AdjustStateLeft = wxGetKeyState(CAMKEY(CC_MOD_ADJUST)); KeyPress::AdjustStateRight = KeyPress::AdjustStateLeft; KeyPress::ConstrainStateLeft = wxGetKeyState(CAMKEY(CC_MOD_CONSTRAIN)); KeyPress::ConstrainStateRight = KeyPress::ConstrainStateLeft; KeyPress::AlternativeStateLeft = wxGetKeyState(CAMKEY(CC_MOD_ALTERNATIVE)); KeyPress::AlternativeStateRight = KeyPress::AlternativeStateLeft; KeyPress::OptionStateLeft = FALSE; KeyPress::OptionStateRight = FALSE; KeyPress::fModifierChanged =(AdjL != KeyPress::AdjustStateLeft) || (AdjR != KeyPress::AdjustStateRight) || (ConL != KeyPress::ConstrainStateLeft) || (ConR != KeyPress::ConstrainStateRight) || (AltL != KeyPress::AlternativeStateLeft)|| (AltR != KeyPress::AlternativeStateRight)|| (OptL != KeyPress::OptionStateLeft) || (OptR != KeyPress::OptionStateRight); }

---

Member Data Documentation

List KeyPress::AdditionalVirtKeys [static, private]

Definition at line 317 of file keypress.h.

BOOL KeyPress::Adjust [private]

Definition at line 280 of file keypress.h.

BOOL KeyPress::AdjustStateLeft = FALSE [static, private]

Definition at line 297 of file keypress.h.

BOOL KeyPress::AdjustStateRight = FALSE [static, private]

Definition at line 298 of file keypress.h.

BOOL KeyPress::Alternative [private]

Definition at line 282 of file keypress.h.

BOOL KeyPress::AlternativeStateLeft = FALSE [static, private]

Definition at line 301 of file keypress.h.

BOOL KeyPress::AlternativeStateRight = FALSE [static, private]

Definition at line 302 of file keypress.h.

INT32 KeyPress::AsciiVal = -1 [static, private]

Definition at line 310 of file keypress.h.

BOOL KeyPress::Constrain [private]

Definition at line 281 of file keypress.h.

BOOL KeyPress::ConstrainStateLeft = FALSE [static, private]

Definition at line 299 of file keypress.h.

BOOL KeyPress::ConstrainStateRight = FALSE [static, private]

Definition at line 300 of file keypress.h.

BOOL KeyPress::Extended [private]

Definition at line 285 of file keypress.h.

BOOL KeyPress::fModifierChanged = FALSE [static, private]

Definition at line 307 of file keypress.h.

BYTE KeyPress::LastLeadByte = 0 [static, private]

Definition at line 314 of file keypress.h.

BOOL KeyPress::m_fIsChar [private]

Definition at line 290 of file keypress.h.

BOOL KeyPress::Option [private]

Definition at line 283 of file keypress.h.

BOOL KeyPress::OptionStateLeft = FALSE [static, private]

Definition at line 303 of file keypress.h.

BOOL KeyPress::OptionStateRight = FALSE [static, private]

Definition at line 304 of file keypress.h.

BOOL KeyPress::Release [private]

Definition at line 289 of file keypress.h.

BOOL KeyPress::Repeat [private]

Definition at line 287 of file keypress.h.

BOOL KeyPress::RightHand [private]

Definition at line 288 of file keypress.h.

WCHAR KeyPress::Unicode [private]

Definition at line 278 of file keypress.h.

BOOL KeyPress::Valid [private]

Definition at line 292 of file keypress.h.

BOOL KeyPress::ValidAsciiVal = FALSE [static, private]

Definition at line 311 of file keypress.h.

UINT32 KeyPress::VirtKey [private]

Definition at line 277 of file keypress.h.

BOOL KeyPress::WorksInDrag [private]

Definition at line 293 of file keypress.h.

---

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

• wxOil/keypress.h (r1785/r1282)
• wxOil/keypress.cpp (r1785/r1361)

---