virtual void OnKeyup(wxKeyEvent& event)
{
int key = event.GetKeyCode();
// printf("ku:%c\n", key);
dword flags = 0;
if(event.AltDown()) flags |= KF_ALT;
if(event.ShiftDown()) flags |= KF_SHIFT;
TranslateKey(key, flags);
Handler()->OnKey(key, OpJoyKeyFlags());
}
KeyAcceleratorCode::KeyAcceleratorCode( const wxKeyEvent& evt )
{
val32 = 0;
keycode = evt.GetKeyCode();
if( evt.AltDown() ) Alt();
if( evt.CmdDown() ) Cmd();
if( evt.ShiftDown() ) Shift();
}
void ecConfigTreeCtrl::OnKeyDown(wxKeyEvent& event)
{
wxTreeItemId id = GetSelection();
if (event.GetKeyCode() == WXK_F10 && event.ShiftDown())
{
if (id.IsOk())
{
wxRect rect;
if (GetBoundingRect(id, rect))
{
GetPropertiesMenu()->SetClientData((void*) TRUE);
PopupMenu(GetPropertiesMenu(), 100, rect.GetTop() + 4);
}
}
}
else if (event.GetKeyCode() == '<')
{
if (id.IsOk())
{
ecConfigItem* item = ((ecTreeItemData*) GetItemData(id))->GetConfigItem();
item->BumpItem(-1);
}
}
else if (event.GetKeyCode() == '>')
{
if (id.IsOk())
{
ecConfigItem* item = ((ecTreeItemData*) GetItemData(id))->GetConfigItem();
item->BumpItem(+1);
}
}
else if (event.GetKeyCode() == WXK_SPACE)
{
if (id.IsOk())
{
ecConfigItem* item = ((ecTreeItemData*) GetItemData(id))->GetConfigItem();
item->BumpItem(0);
}
}
else if (event.GetKeyCode() == WXK_RETURN && event.AltDown())
{
if (id.IsOk())
{
ecConfigItem* item = ((ecTreeItemData*) GetItemData(id))->GetConfigItem();
ecConfigPropertiesDialog dialog(wxGetApp().GetTopWindow(), item);
dialog.SetTitle(item->GetName());
dialog.ShowModal();
}
}
else
{
event.Skip();
}
}
bool wxGenericComboCtrl::IsKeyPopupToggle(const wxKeyEvent& event) const
{
int keycode = event.GetKeyCode();
bool isPopupShown = IsPopupShown();
// This code is AFAIK appropriate for wxGTK.
if ( isPopupShown )
{
if ( keycode == WXK_ESCAPE ||
( keycode == WXK_UP && event.AltDown() ) )
return true;
}
else
{
if ( keycode == WXK_DOWN && event.AltDown() )
return true;
}
return false;
}
void MyFrame::OnChar( wxKeyEvent& event )
{
wxCommandEvent evt;
if ( event.m_keyCode == WXK_F1 )
{
OnFirst( evt );
}
else
{
if ( event.m_keyCode == WXK_F2 )
{
OnSecond( evt );
}
else
{
if ( event.m_keyCode == WXK_F3 )
{
OnThird( evt );
}
if ( event.m_keyCode == WXK_F4 && !event.AltDown() )
{
// "AI" :-)
wxMessageBox(_("There are only 3 layouts in this demo :-("));
}
else
{
if ( event.m_keyCode == WXK_TAB )
{
// USEFUL TRICK:: avoids flickering of application's frame
// when closing NN windows on exit:
Show(false);
if ( (mAutoSave && mSavedAlready) || !mAutoSave )
{
}
else
{
wxCommandEvent evt;
OnStore(evt);
}
Destroy();
}
else
{
event.Skip();
}
}
}
}
}
/// Key press
void InstanceCtrl::OnChar(wxKeyEvent& event)
{
int flags = 0;
if (event.ControlDown())
flags |= wxINST_CTRL_DOWN;
if (event.ShiftDown())
flags |= wxINST_SHIFT_DOWN;
if (event.AltDown())
flags |= wxINST_ALT_DOWN;
if (event.GetKeyCode() == WXK_LEFT ||
event.GetKeyCode() == WXK_RIGHT ||
event.GetKeyCode() == WXK_UP ||
event.GetKeyCode() == WXK_DOWN ||
event.GetKeyCode() == WXK_HOME ||
event.GetKeyCode() == WXK_PAGEUP ||
event.GetKeyCode() == WXK_PAGEDOWN ||
event.GetKeyCode() == WXK_END)
{
Navigate(event.GetKeyCode(), flags);
}
if (event.GetKeyCode() == WXK_RETURN)
{
InstanceCtrlEvent cmdEvent(
wxEVT_COMMAND_INST_ACTIVATE,
GetId());
cmdEvent.SetEventObject(this);
cmdEvent.SetFlags(flags);
GetEventHandler()->ProcessEvent(cmdEvent);
}
else if (event.GetKeyCode() == WXK_DELETE)
{
InstanceCtrlEvent cmdEvent(
wxEVT_COMMAND_INST_DELETE,
GetId());
cmdEvent.SetEventObject(this);
cmdEvent.SetFlags(flags);
GetEventHandler()->ProcessEvent(cmdEvent);
}
else if (event.GetKeyCode() == WXK_F2)
{
InstanceCtrlEvent cmdEvent(
wxEVT_COMMAND_INST_RENAME,
GetId());
cmdEvent.SetEventObject(this);
cmdEvent.SetFlags(flags);
GetEventHandler()->ProcessEvent(cmdEvent);
}
else
event.Skip();
}
void WinEDA_DrawPanel::OnKeyEvent(wxKeyEvent& event)
/****************************************************/
{
long key, localkey;
bool escape = FALSE;
key = localkey = event.m_keyCode;
switch( localkey )
{
case WXK_CONTROL:
case WXK_CAPITAL:
case WXK_SHIFT:
case WXK_NUMLOCK:
case WXK_LBUTTON:
case WXK_RBUTTON:
case 0x0135: /* Alt key */
return;
case WXK_ESCAPE:
escape = m_AbortRequest = TRUE;
break;
}
if( event.ControlDown() ) localkey |= GR_KB_CTRL;
if( event.AltDown() ) localkey |= GR_KB_ALT;
if( event.ShiftDown() && (key > 256) ) localkey |= GR_KB_SHIFT;
wxClientDC DC(this);
BASE_SCREEN * Screen = GetScreen();
PrepareGraphicContext(&DC);
g_KeyPressed = localkey;
if ( escape )
{
if( Screen->ManageCurseur && Screen->ForceCloseManageCurseur )
{
SetCursor(m_PanelCursor = m_PanelDefaultCursor);
Screen->ForceCloseManageCurseur(m_Parent, &DC);
SetCursor(m_PanelCursor = m_PanelDefaultCursor);
}
else m_Parent->SetToolID(0, m_PanelCursor = m_PanelDefaultCursor = wxCURSOR_ARROW, wxEmptyString);
}
m_Parent->GeneralControle(&DC, Screen->m_MousePosition);
}
PlatformKeyboardEvent::PlatformKeyboardEvent(wxKeyEvent& event)
{
m_text = wxString(event.GetUnicodeKey());
m_unmodifiedText = m_text;
m_keyIdentifier = keyIdentifierForWxKeyCode(event.GetKeyCode());
m_isKeyUp = event.GetEventType() == wxEVT_KEY_UP;
m_autoRepeat = false; // FIXME: not correct.
m_WindowsKeyCode = windowsKeyCodeForKeyEvent(event.GetKeyCode());
m_isKeypad = (event.GetKeyCode() >= WXK_NUMPAD_SPACE) && (event.GetKeyCode() <= WXK_NUMPAD_DIVIDE);
m_shiftKey = event.ShiftDown();
m_ctrlKey = event.CmdDown();
m_altKey = event.AltDown();
m_metaKey = event.MetaDown();
}
void AudacityApp::OnKey(wxKeyEvent& event)
{
AudacityProject *audacityPrj = GetActiveProject();
wxString newStr = "";
long key = event.GetKeyCode();
if(event.ControlDown())
newStr += "Ctrl+";
if(event.AltDown())
newStr += "Alt+";
if(event.ShiftDown())
newStr += "Shift+";
if (event.ControlDown() && key >= 1 && key <= 26)
newStr += (char)(64 + key);
else if (key >= 33 && key <= 126)
newStr += (char)key;
else if (key == WXK_BACK)
newStr = "Backspace";
else if (key == WXK_DELETE)
newStr = "Delete";
else if (key == WXK_SPACE)
newStr = "Spacebar";
else
{
event.Skip();
return; // Don't change it if we don't recognize the key
}
if(audacityPrj->IsActive())
{
int commandIndex = audacityPrj->FindCommandByCombos(newStr);
if(audacityPrj->GetCommandState(commandIndex) == enabledMenu)
{
audEventFunction audFunc = audacityPrj->GetCommandFunc(commandIndex);
if(audFunc)
(audacityPrj->*((wxEventFunction) audFunc))(event);
return;
}
}
event.Skip();
}
void CComposeBarEditBox::OnChar(wxKeyEvent& event)
{
// intercept the Enter key and make it call the OnAdvanceButton() handler
if (event.GetKeyCode() == WXK_RETURN)
{
wxCommandEvent bevent;
gpApp->GetFreeTrans()->OnAdvanceButton(bevent);
return; // don't call skip - we don't want the end-of-line character entered
// into the edit box
}
// only call skip when ALT key is NOT down (to avoid base class making a beep)
if (!event.AltDown())
event.Skip();
// The actual text characters typed in the compose bar's edit box go through here
}
virtual void OnKeydown(wxKeyEvent& event)
{
int key = event.GetKeyCode();
if(HasCapture() && key == WXK_ESCAPE)
{
KillMouseFocus();
return;
}
// printf("kd:%c\n", key);
dword flags = KF_DOWN|OpJoyKeyFlags();
if(event.AltDown()) flags |= KF_ALT;
if(event.ShiftDown()) flags |= KF_SHIFT;
TranslateKey(key, flags);
Handler()->OnKey(key, flags);
}
bool wxComboCtrl::IsKeyPopupToggle(const wxKeyEvent& event) const
{
const bool isPopupShown = IsPopupShown();
switch ( event.GetKeyCode() )
{
case WXK_F4:
// F4 toggles the popup in the native comboboxes, so emulate them
if ( !event.AltDown() )
return true;
break;
case WXK_ESCAPE:
if ( isPopupShown )
return true;
break;
case WXK_DOWN:
case WXK_UP:
// On XP or with writable combo in Classic, arrows don't open the
// popup but Alt-arrow does
if ( event.AltDown() ||
( !isPopupShown &&
HasFlag(wxCB_READONLY)
#if wxUSE_UXTHEME
&& !wxUxThemeEngine::GetIfActive()
#endif
) )
{
return true;
}
break;
}
return false;
}
PlatformKeyboardEvent::PlatformKeyboardEvent(wxKeyEvent& event)
{
if (event.GetEventType() == wxEVT_KEY_UP)
m_type = PlatformEvent::KeyUp;
else if (event.GetEventType() == wxEVT_KEY_DOWN)
m_type = PlatformEvent::KeyDown;
else if (event.GetEventType() == wxEVT_CHAR)
m_type = PlatformEvent::Char;
else
ASSERT_NOT_REACHED();
if (m_type != PlatformEvent::Char)
m_keyIdentifier = keyIdentifierForWxKeyCode(event.GetKeyCode());
else {
//ENTER is an editing command processed as a char (only Enter and Tab are)
//unfortunately the unicode key for numpad_enter (370) is NOT what we want here (13)
//The unicode values for normal enter and tab are the same as the ASCII values, thus ok
//Note that I think this a wx bug, as the Character Code is actually 13 when
//numpad_enter is a CHAR event.
if (event.GetKeyCode() == 13 && event.GetUnicodeKey() == wxChar(370))
m_text = "\r";
else
m_text = wxString(event.GetUnicodeKey());
m_unmodifiedText = m_text;
}
m_autoRepeat = false; // FIXME: not correct.
m_windowsVirtualKeyCode = windowsKeyCodeForKeyEvent(event.GetKeyCode());
m_nativeVirtualKeyCode = event.GetKeyCode();
m_isKeypad = (event.GetKeyCode() >= WXK_NUMPAD_SPACE) && (event.GetKeyCode() <= WXK_NUMPAD_DIVIDE);
m_modifiers = 0;
if (event.ShiftDown())
m_modifiers |= ShiftKey;
if (event.CmdDown())
m_modifiers |= CtrlKey;
if (event.AltDown())
m_modifiers |= AltKey;
if (event.MetaDown())
m_modifiers |= MetaKey;
m_timestamp = WTF::currentTime();
}
void CMyGLCanvas_DisplayWindow3D::display3D_processKeyEvent(
CDisplayWindow3D* m_win3D, wxKeyEvent& ev)
{
if (m_win3D)
{
if (ev.AltDown() && ev.GetKeyCode() == MRPTK_RETURN)
{
if (mrpt::system::timeDifference(
m_win3D->m_lastFullScreen, mrpt::system::now()) > 0.2)
{
m_win3D->m_lastFullScreen = mrpt::system::now();
cout << "[CDisplayWindow3D] Switching fullscreen...\n";
C3DWindowDialog* win = (C3DWindowDialog*)m_win3D->m_hwnd.get();
if (win)
{
win->ShowFullScreen(!win->IsFullScreen());
}
}
// Alt+Enter: Don't notify on this key stroke, since if we're
// switching to fullscreen
// and the user is waiting for a key to close the window, a runtime
// crash will occur,
// so return now:
return;
}
const int code = ev.GetKeyCode();
const mrptKeyModifier mod = mrpt::gui::keyEventToMrptKeyModifier(ev);
m_win3D->m_keyPushedCode = code;
m_win3D->m_keyPushedModifier = mod;
m_win3D->m_keyPushed = true;
// Send the event:
try
{
m_win3D->publishEvent(mrptEventWindowChar(m_win3D, code, mod));
}
catch (...)
{
}
}
// ev.Skip(); // Pass the event to whoever else.
}
void RegTreeCtrl::OnChar(wxKeyEvent& event)
{
switch ( event.GetKeyCode() )
{
case WXK_DELETE:
DeleteSelected();
return;
case WXK_RETURN:
if ( event.AltDown() )
{
ShowProperties();
return;
}
}
event.Skip();
}
void udCodeEditorPanel::OnKeyDown(wxKeyEvent& event)
{
switch( event.GetKeyCode() )
{
case 's':
case 'S':
if( event.AltDown() && CanSave() )
{
wxCommandEvent evt;
OnSave( evt );
}
else
event.Skip();
break;
default:
event.Skip();
}
}
// Process a key press
// left/right moves through history; 'p' passes the turn
void SimpleGoPanel::KeyDown(wxKeyEvent& event)
{ if(event.GetKeyCode()==WXK_LEFT&&curmove>0)
{ gnugopause = true;
gnugoscore = false;
curmove--;
UpdateBoard();
}
else if(event.GetKeyCode()==WXK_RIGHT&&curmove<totmove)
{ gnugoscore = false;
curmove++;
UpdateBoard();
}
else if(event.GetKeyCode()=='P'&&!event.AltDown())
MakePass();
else if(event.GetKeyCode()==WXK_ESCAPE)
{ gnugopause = true;
frame->playmenu->Check(ID_RANDOM, false);
}
event.Skip();
}
void wxWindow::OnChar(wxKeyEvent& event)
{
if ( event.AltDown() && !event.ControlDown() )
{
int key = event.GetKeyCode();
wxMenuBar *menubar = GetParentFrameMenuBar();
if ( menubar )
{
int item = menubar->FindNextItemForAccel(-1, key);
if ( item != -1 )
{
menubar->PopupMenu((size_t)item);
// skip "event.Skip()" below
return;
}
}
}
// if Return was pressed, see if there's a default button to activate
if ( !event.HasModifiers() && event.GetKeyCode() == WXK_RETURN )
{
wxTopLevelWindow *
tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
if ( tlw )
{
wxButton *btn = wxDynamicCast(tlw->GetDefaultItem(), wxButton);
if ( btn )
{
wxCommandEvent evt(wxEVT_COMMAND_BUTTON_CLICKED, btn->GetId());
evt.SetEventObject(btn);
btn->Command(evt);
return;
}
}
}
event.Skip();
}
void ControlToolBar::OnKeyEvent(wxKeyEvent & event)
{
if (event.ControlDown() || event.AltDown()) {
event.Skip();
return;
}
if (event.GetKeyCode() == WXK_SPACE) {
if (gAudioIO->IsStreamActive(GetActiveProject()->GetAudioIOToken())) {
SetPlay(false);
SetStop(true);
StopPlaying();
}
else if (!gAudioIO->IsBusy()) {
//SetPlay(true);// Not needed as done in PlayPlayRegion
SetStop(false);
PlayCurrentRegion();
}
return;
}
event.Skip();
}
void wxWindow::OnChar(wxKeyEvent& event)
{
if ( event.AltDown() && !event.ControlDown() )
{
int key = event.GetKeyCode();
wxMenuBar *menubar = GetParentFrameMenuBar();
if ( menubar )
{
int item = menubar->FindNextItemForAccel(-1, key);
if ( item != -1 )
{
menubar->PopupMenu((size_t)item);
// skip "event.Skip()" below
return;
}
}
}
event.Skip();
}
long WIDGET_HOTKEY_LIST::MapKeypressToKeycode( const wxKeyEvent& aEvent )
{
long key = aEvent.GetKeyCode();
if( key == WXK_ESCAPE )
{
return 0;
}
else
{
if( key >= 'a' && key <= 'z' ) // convert to uppercase
key = key + ('A' - 'a');
// Remap Ctrl A (=1+GR_KB_CTRL) to Ctrl Z(=26+GR_KB_CTRL)
// to GR_KB_CTRL+'A' .. GR_KB_CTRL+'Z'
if( aEvent.ControlDown() && key >= WXK_CONTROL_A && key <= WXK_CONTROL_Z )
key += 'A' - 1;
/* Disallow shift for keys that have two keycodes on them (e.g. number and
* punctuation keys) leaving only the "letter keys" of A-Z.
* Then, you can have, e.g. Ctrl-5 and Ctrl-% (GB layout)
* and Ctrl-( and Ctrl-5 (FR layout).
* Otherwise, you'd have to have to say Ctrl-Shift-5 on a FR layout
*/
bool keyIsLetter = key >= 'A' && key <= 'Z';
if( aEvent.ShiftDown() && ( keyIsLetter || key > 256 ) )
key |= GR_KB_SHIFT;
if( aEvent.ControlDown() )
key |= GR_KB_CTRL;
if( aEvent.AltDown() )
key |= GR_KB_ALT;
return key;
}
}
void ControlToolBar::OnKeyEvent(wxKeyEvent & event)
{
if (event.ControlDown() || event.AltDown()) {
event.Skip();
return;
}
// Does not appear to be needed on Linux. Perhaps on some other platform?
// If so, "!CanStopAudioStream()" should probably apply.
if (event.GetKeyCode() == WXK_SPACE) {
if (gAudioIO->IsStreamActive(GetActiveProject()->GetAudioIOToken())) {
SetPlay(false);
SetStop(true);
StopPlaying();
}
else if (!gAudioIO->IsBusy()) {
//SetPlay(true);// Not needed as done in PlayPlayRegion
SetStop(false);
PlayCurrentRegion();
}
return;
}
event.Skip();
}
void LogKeyEvent(const wxChar *name, const wxKeyEvent& event)
{
wxString key;
long keycode = event.GetKeyCode();
{
switch ( keycode )
{
case WXK_BACK: key = wxT("BACK"); break;
case WXK_TAB: key = wxT("TAB"); break;
case WXK_RETURN: key = wxT("RETURN"); break;
case WXK_ESCAPE: key = wxT("ESCAPE"); break;
case WXK_SPACE: key = wxT("SPACE"); break;
case WXK_DELETE: key = wxT("DELETE"); break;
case WXK_START: key = wxT("START"); break;
case WXK_LBUTTON: key = wxT("LBUTTON"); break;
case WXK_RBUTTON: key = wxT("RBUTTON"); break;
case WXK_CANCEL: key = wxT("CANCEL"); break;
case WXK_MBUTTON: key = wxT("MBUTTON"); break;
case WXK_CLEAR: key = wxT("CLEAR"); break;
case WXK_SHIFT: key = wxT("SHIFT"); break;
case WXK_ALT: key = wxT("ALT"); break;
case WXK_CONTROL: key = wxT("CONTROL"); break;
case WXK_MENU: key = wxT("MENU"); break;
case WXK_PAUSE: key = wxT("PAUSE"); break;
case WXK_CAPITAL: key = wxT("CAPITAL"); break;
case WXK_END: key = wxT("END"); break;
case WXK_HOME: key = wxT("HOME"); break;
case WXK_LEFT: key = wxT("LEFT"); break;
case WXK_UP: key = wxT("UP"); break;
case WXK_RIGHT: key = wxT("RIGHT"); break;
case WXK_DOWN: key = wxT("DOWN"); break;
case WXK_SELECT: key = wxT("SELECT"); break;
case WXK_PRINT: key = wxT("PRINT"); break;
case WXK_EXECUTE: key = wxT("EXECUTE"); break;
case WXK_SNAPSHOT: key = wxT("SNAPSHOT"); break;
case WXK_INSERT: key = wxT("INSERT"); break;
case WXK_HELP: key = wxT("HELP"); break;
case WXK_NUMPAD0: key = wxT("NUMPAD0"); break;
case WXK_NUMPAD1: key = wxT("NUMPAD1"); break;
case WXK_NUMPAD2: key = wxT("NUMPAD2"); break;
case WXK_NUMPAD3: key = wxT("NUMPAD3"); break;
case WXK_NUMPAD4: key = wxT("NUMPAD4"); break;
case WXK_NUMPAD5: key = wxT("NUMPAD5"); break;
case WXK_NUMPAD6: key = wxT("NUMPAD6"); break;
case WXK_NUMPAD7: key = wxT("NUMPAD7"); break;
case WXK_NUMPAD8: key = wxT("NUMPAD8"); break;
case WXK_NUMPAD9: key = wxT("NUMPAD9"); break;
case WXK_MULTIPLY: key = wxT("MULTIPLY"); break;
case WXK_ADD: key = wxT("ADD"); break;
case WXK_SEPARATOR: key = wxT("SEPARATOR"); break;
case WXK_SUBTRACT: key = wxT("SUBTRACT"); break;
case WXK_DECIMAL: key = wxT("DECIMAL"); break;
case WXK_DIVIDE: key = wxT("DIVIDE"); break;
case WXK_F1: key = wxT("F1"); break;
case WXK_F2: key = wxT("F2"); break;
case WXK_F3: key = wxT("F3"); break;
case WXK_F4: key = wxT("F4"); break;
case WXK_F5: key = wxT("F5"); break;
case WXK_F6: key = wxT("F6"); break;
case WXK_F7: key = wxT("F7"); break;
case WXK_F8: key = wxT("F8"); break;
case WXK_F9: key = wxT("F9"); break;
case WXK_F10: key = wxT("F10"); break;
case WXK_F11: key = wxT("F11"); break;
case WXK_F12: key = wxT("F12"); break;
case WXK_F13: key = wxT("F13"); break;
case WXK_F14: key = wxT("F14"); break;
case WXK_F15: key = wxT("F15"); break;
case WXK_F16: key = wxT("F16"); break;
case WXK_F17: key = wxT("F17"); break;
case WXK_F18: key = wxT("F18"); break;
case WXK_F19: key = wxT("F19"); break;
case WXK_F20: key = wxT("F20"); break;
case WXK_F21: key = wxT("F21"); break;
case WXK_F22: key = wxT("F22"); break;
case WXK_F23: key = wxT("F23"); break;
case WXK_F24: key = wxT("F24"); break;
case WXK_NUMLOCK: key = wxT("NUMLOCK"); break;
case WXK_SCROLL: key = wxT("SCROLL"); break;
case WXK_PAGEUP: key = wxT("PAGEUP"); break;
case WXK_PAGEDOWN: key = wxT("PAGEDOWN"); break;
case WXK_NUMPAD_SPACE: key = wxT("NUMPAD_SPACE"); break;
case WXK_NUMPAD_TAB: key = wxT("NUMPAD_TAB"); break;
case WXK_NUMPAD_ENTER: key = wxT("NUMPAD_ENTER"); break;
case WXK_NUMPAD_F1: key = wxT("NUMPAD_F1"); break;
case WXK_NUMPAD_F2: key = wxT("NUMPAD_F2"); break;
case WXK_NUMPAD_F3: key = wxT("NUMPAD_F3"); break;
case WXK_NUMPAD_F4: key = wxT("NUMPAD_F4"); break;
case WXK_NUMPAD_HOME: key = wxT("NUMPAD_HOME"); break;
case WXK_NUMPAD_LEFT: key = wxT("NUMPAD_LEFT"); break;
case WXK_NUMPAD_UP: key = wxT("NUMPAD_UP"); break;
case WXK_NUMPAD_RIGHT: key = wxT("NUMPAD_RIGHT"); break;
case WXK_NUMPAD_DOWN: key = wxT("NUMPAD_DOWN"); break;
case WXK_NUMPAD_PAGEUP: key = wxT("NUMPAD_PAGEUP"); break;
case WXK_NUMPAD_PAGEDOWN: key = wxT("NUMPAD_PAGEDOWN"); break;
case WXK_NUMPAD_END: key = wxT("NUMPAD_END"); break;
case WXK_NUMPAD_BEGIN: key = wxT("NUMPAD_BEGIN"); break;
case WXK_NUMPAD_INSERT: key = wxT("NUMPAD_INSERT"); break;
case WXK_NUMPAD_DELETE: key = wxT("NUMPAD_DELETE"); break;
case WXK_NUMPAD_EQUAL: key = wxT("NUMPAD_EQUAL"); break;
case WXK_NUMPAD_MULTIPLY: key = wxT("NUMPAD_MULTIPLY"); break;
case WXK_NUMPAD_ADD: key = wxT("NUMPAD_ADD"); break;
case WXK_NUMPAD_SEPARATOR: key = wxT("NUMPAD_SEPARATOR"); break;
case WXK_NUMPAD_SUBTRACT: key = wxT("NUMPAD_SUBTRACT"); break;
case WXK_NUMPAD_DECIMAL: key = wxT("NUMPAD_DECIMAL"); break;
default:
{
if ( keycode < 128 && wxIsprint((int)keycode) )
key.Printf(wxT("'%c'"), (char)keycode);
else if ( keycode > 0 && keycode < 27 )
key.Printf(_("Ctrl-%c"), wxT('A') + keycode - 1);
else
key.Printf(wxT("unknown (%ld)"), keycode);
}
}
}
wxLogMessage( wxT("%s event: %s (flags = %c%c%c%c)"),
name,
key.c_str(),
event.ControlDown() ? wxT('C') : wxT('-'),
event.AltDown() ? wxT('A') : wxT('-'),
event.ShiftDown() ? wxT('S') : wxT('-'),
event.MetaDown() ? wxT('M') : wxT('-'));
}
wxString KeyEventToKeyString(const wxKeyEvent & event)
{
wxString newStr = wxT("");
long key = event.GetKeyCode();
if (event.ControlDown())
newStr += wxT("Ctrl+");
if (event.AltDown())
newStr += wxT("Alt+");
if (event.ShiftDown())
newStr += wxT("Shift+");
#if defined(__WXMAC__)
if (event.RawControlDown())
newStr += wxT("XCtrl+");
#endif
if (event.RawControlDown() && key >= 1 && key <= 26)
newStr += (wxChar)(64 + key);
else if (key >= 33 && key <= 126)
newStr += (wxChar)key;
else
{
switch(key)
{
case WXK_BACK:
newStr += wxT("Backspace");
break;
case WXK_DELETE:
newStr += wxT("Delete");
break;
case WXK_SPACE:
newStr += wxT("Space");
break;
case WXK_TAB:
newStr += wxT("Tab");
break;
case WXK_RETURN:
newStr += wxT("Return");
break;
case WXK_PAGEUP:
newStr += wxT("PageUp");
break;
case WXK_PAGEDOWN:
newStr += wxT("PageDown");
break;
case WXK_END:
newStr += wxT("End");
break;
case WXK_HOME:
newStr += wxT("Home");
break;
case WXK_LEFT:
newStr += wxT("Left");
break;
case WXK_UP:
newStr += wxT("Up");
break;
case WXK_RIGHT:
newStr += wxT("Right");
break;
case WXK_DOWN:
newStr += wxT("Down");
break;
case WXK_ESCAPE:
newStr += wxT("Escape");
break;
case WXK_INSERT:
newStr += wxT("Insert");
break;
case WXK_NUMPAD0:
newStr += wxT("NUMPAD0");
break;
case WXK_NUMPAD1:
newStr += wxT("NUMPAD1");
break;
case WXK_NUMPAD2:
newStr += wxT("NUMPAD2");
break;
case WXK_NUMPAD3:
newStr += wxT("NUMPAD3");
break;
case WXK_NUMPAD4:
newStr += wxT("NUMPAD4");
break;
case WXK_NUMPAD5:
newStr += wxT("NUMPAD5");
break;
case WXK_NUMPAD6:
newStr += wxT("NUMPAD6");
break;
case WXK_NUMPAD7:
newStr += wxT("NUMPAD7");
break;
case WXK_NUMPAD8:
newStr += wxT("NUMPAD8");
break;
case WXK_NUMPAD9:
newStr += wxT("NUMPAD9");
break;
case WXK_MULTIPLY:
newStr += wxT("*");
break;
case WXK_ADD:
newStr += wxT("+");
break;
case WXK_SUBTRACT:
newStr += wxT("-");
break;
case WXK_DECIMAL:
newStr += wxT(".");
break;
case WXK_DIVIDE:
newStr += wxT("/");
break;
case WXK_F1:
newStr += wxT("F1");
break;
case WXK_F2:
newStr += wxT("F2");
break;
case WXK_F3:
newStr += wxT("F3");
break;
case WXK_F4:
newStr += wxT("F4");
break;
case WXK_F5:
newStr += wxT("F5");
break;
case WXK_F6:
newStr += wxT("F6");
break;
case WXK_F7:
newStr += wxT("F7");
break;
case WXK_F8:
newStr += wxT("F8");
break;
case WXK_F9:
newStr += wxT("F9");
break;
case WXK_F10:
newStr += wxT("F10");
break;
case WXK_F11:
newStr += wxT("F11");
break;
case WXK_F12:
newStr += wxT("F12");
break;
case WXK_F13:
newStr += wxT("F13");
break;
case WXK_F14:
newStr += wxT("F14");
break;
case WXK_F15:
newStr += wxT("F15");
break;
case WXK_F16:
newStr += wxT("F16");
break;
case WXK_F17:
newStr += wxT("F17");
break;
case WXK_F18:
newStr += wxT("F18");
break;
case WXK_F19:
newStr += wxT("F19");
break;
case WXK_F20:
newStr += wxT("F20");
break;
case WXK_F21:
newStr += wxT("F21");
break;
case WXK_F22:
newStr += wxT("F22");
break;
case WXK_F23:
newStr += wxT("F23");
break;
case WXK_F24:
newStr += wxT("F24");
break;
case WXK_NUMPAD_ENTER:
newStr += wxT("NUMPAD_ENTER");
break;
case WXK_NUMPAD_F1:
newStr += wxT("NUMPAD_F1");
break;
case WXK_NUMPAD_F2:
newStr += wxT("NUMPAD_F2");
break;
case WXK_NUMPAD_F3:
newStr += wxT("NUMPAD_F3");
break;
case WXK_NUMPAD_F4:
newStr += wxT("NUMPAD_F4");
break;
case WXK_NUMPAD_HOME:
newStr += wxT("NUMPAD_HOME");
break;
case WXK_NUMPAD_LEFT:
newStr += wxT("NUMPAD_LEFT");
break;
case WXK_NUMPAD_UP:
newStr += wxT("NUMPAD_UP");
break;
case WXK_NUMPAD_RIGHT:
newStr += wxT("NUMPAD_RIGHT");
break;
case WXK_NUMPAD_DOWN:
newStr += wxT("NUMPAD_DOWN");
break;
case WXK_NUMPAD_PAGEUP:
newStr += wxT("NUMPAD_PAGEUP");
break;
case WXK_NUMPAD_PAGEDOWN:
newStr += wxT("NUMPAD_PAGEDOWN");
break;
case WXK_NUMPAD_END:
newStr += wxT("NUMPAD_END");
break;
case WXK_NUMPAD_BEGIN:
newStr += wxT("NUMPAD_HOME");
break;
case WXK_NUMPAD_INSERT:
newStr += wxT("NUMPAD_INSERT");
break;
case WXK_NUMPAD_DELETE:
newStr += wxT("NUMPAD_DELETE");
break;
case WXK_NUMPAD_EQUAL:
newStr += wxT("NUMPAD_EQUAL");
break;
case WXK_NUMPAD_MULTIPLY:
newStr += wxT("NUMPAD_MULTIPLY");
break;
case WXK_NUMPAD_ADD:
newStr += wxT("NUMPAD_ADD");
break;
case WXK_NUMPAD_SUBTRACT:
newStr += wxT("NUMPAD_SUBTRACT");
break;
case WXK_NUMPAD_DECIMAL:
newStr += wxT("NUMPAD_DECIMAL");
break;
case WXK_NUMPAD_DIVIDE:
newStr += wxT("NUMPAD_DIVIDE");
break;
default:
return wxT(""); // Don't do anything if we don't recognize the key
}
}
return KeyStringNormalize(newStr);
}
bool wxStdListboxInputHandler::HandleKey(wxInputConsumer *consumer,
const wxKeyEvent& event,
bool pressed)
{
// we're only interested in the key press events
if ( pressed && !event.AltDown() )
{
bool isMoveCmd = true;
int style = consumer->GetInputWindow()->GetWindowStyle();
wxControlAction action;
wxString strArg;
int keycode = event.GetKeyCode();
switch ( keycode )
{
// movement
case WXK_UP:
action = wxACTION_LISTBOX_MOVEUP;
break;
case WXK_DOWN:
action = wxACTION_LISTBOX_MOVEDOWN;
break;
case WXK_PAGEUP:
case WXK_PRIOR:
action = wxACTION_LISTBOX_PAGEUP;
break;
case WXK_PAGEDOWN:
case WXK_NEXT:
action = wxACTION_LISTBOX_PAGEDOWN;
break;
case WXK_HOME:
action = wxACTION_LISTBOX_START;
break;
case WXK_END:
action = wxACTION_LISTBOX_END;
break;
// selection
case WXK_SPACE:
if ( style & wxLB_MULTIPLE )
{
action = wxACTION_LISTBOX_TOGGLE;
isMoveCmd = false;
}
break;
case WXK_RETURN:
action = wxACTION_LISTBOX_ACTIVATE;
isMoveCmd = false;
break;
default:
if ( (keycode < 255) && wxIsalnum((wxChar)keycode) )
{
action = wxACTION_LISTBOX_FIND;
strArg = (wxChar)keycode;
}
}
if ( !action.IsEmpty() )
{
consumer->PerformAction(action, -1, strArg);
if ( isMoveCmd )
{
if ( style & wxLB_SINGLE )
{
// the current item is always the one selected
consumer->PerformAction(wxACTION_LISTBOX_SELECT);
}
else if ( style & wxLB_EXTENDED )
{
if ( event.ShiftDown() )
consumer->PerformAction(wxACTION_LISTBOX_EXTENDSEL);
else
{
// select the item and make it the new selection anchor
consumer->PerformAction(wxACTION_LISTBOX_SELECT);
consumer->PerformAction(wxACTION_LISTBOX_ANCHOR);
}
}
//else: nothing to do for multiple selection listboxes
}
return true;
}
}
return wxStdInputHandler::HandleKey(consumer, event, pressed);
}
void EditorTweaks::OnKeyPress(wxKeyEvent& event)
{
const int keyCode = event.GetKeyCode();
// This set of laptop friendly helpers are a bit of a hack to make up for the lack of
// page up, page down, home, end, and delete keys on some laptops (especially Chromebooks)
if (m_laptop_friendly && keyCode == WXK_LEFT && event.AltDown())
{
cbStyledTextCtrl* control = GetSafeControl();
if (event.ShiftDown())
control->VCHomeDisplayExtend();
else
control->VCHomeDisplay();
event.Skip(false);
}
else if (m_laptop_friendly && keyCode == WXK_RIGHT && event.AltDown())
{
cbStyledTextCtrl* control = GetSafeControl();
if (event.ShiftDown())
control->LineEndDisplayExtend();
else
control->LineEndDisplay();
event.Skip(false);
}
else if (m_laptop_friendly && keyCode == WXK_UP && event.AltDown())
{
cbStyledTextCtrl* control = GetSafeControl();
if (event.ControlDown())
{
if (event.ShiftDown())
control->DocumentStartExtend();
else
control->DocumentStart();
} else
{
if (event.ShiftDown())
control->PageUpExtend();
else
control->PageUp();
}
event.Skip(false);
}
else if (m_laptop_friendly && keyCode == WXK_DOWN && event.AltDown())
{
cbStyledTextCtrl* control = GetSafeControl();
if (event.ControlDown())
{
if (event.ShiftDown())
control->DocumentEndExtend();
else
control->DocumentEnd();
} else
{
if (event.ShiftDown())
control->PageDownExtend();
else
control->PageDown();
}
event.Skip(false);
}
else if (m_laptop_friendly && keyCode == WXK_BACK && event.GetModifiers() == wxMOD_SHIFT)
{
cbStyledTextCtrl* control = GetSafeControl();
int anchor = control->GetAnchor();
int pos = control->GetCurrentPos();
if (anchor >= 0 && anchor != pos)
control->DeleteRange(control->GetSelectionStart(), control->GetSelectionEnd() - control->GetSelectionStart());
else
control->DeleteRange(control->GetCurrentPos(), 1);
event.Skip(false);
}
else if (m_suppress_insert && keyCode == WXK_INSERT && event.GetModifiers() == wxMOD_NONE)
event.Skip(false);
else if (m_convert_braces && keyCode == WXK_DELETE && (event.GetModifiers() == wxMOD_NONE || event.GetModifiers() == wxMOD_SHIFT))
{
event.Skip(true);
cbStyledTextCtrl* control = GetSafeControl();
if (!control)
return;
int p = control->GetCurrentPos();
int a = control->GetAnchor();
if (abs(p-a) != 1)
return;
int l = a<p? a: p;
int m = control->BraceMatch(l);
if (m == wxSCI_INVALID_POSITION)
return;
control->BeginUndoAction();
if(l<m)
{
control->DeleteRange(m, 1);
control->DeleteRange(l, 1);
}
else
{
control->DeleteRange(l, 1);
control->DeleteRange(m, 1);
l--;
}
control->SetCurrentPos(l);
control->SetAnchor(l);
control->EndUndoAction();
event.Skip(false);
}
else
event.Skip(true);
}
/* TextureEditorPanel::onTexCanvasKeyDown
* Called when a key is pressed within the texture canvas
*******************************************************************/
void TextureEditorPanel::onTexCanvasKeyDown(wxKeyEvent& e)
{
// Check if keypress matches any keybinds
wxArrayString binds = KeyBind::getBinds(KeyBind::asKeyPress(e.GetKeyCode(), e.GetModifiers()));
// Check for alt key
if (e.GetKeyCode() == WXK_ALT)
alt_press = true;
// Go through matching binds
int x_movement = 0;
int y_movement = 0;
bool handled = false;
for (unsigned a = 0; a < binds.size(); a++)
{
string name = binds[a];
// Move patch left
if (name == "txed_patch_left")
x_movement = -1;
else if (name == "txed_patch_left8")
x_movement = -8;
// Move patch up
else if (name == "txed_patch_up")
y_movement = -1;
else if (name == "txed_patch_up8")
y_movement = -8;
// Move patch right
else if (name == "txed_patch_right")
x_movement = 1;
else if (name == "txed_patch_right8")
x_movement = 8;
// Move patch down
else if (name == "txed_patch_down")
y_movement = 1;
else if (name == "txed_patch_down8")
y_movement = 8;
// Add patch
else if (name == "txed_patch_add")
{
hack_nodrag = true;
addPatch();
handled = true;
}
// Delete patch
else if (name == "txed_patch_delete")
{
removePatch();
handled = true;
}
// Replace patch
else if (name == "txed_patch_replace")
{
hack_nodrag = true;
replacePatch();
handled = true;
}
// Duplicate patch
else if (name == "txed_patch_duplicate")
{
duplicatePatch();
handled = true;
}
// Bring patch forward
else if (name == "txed_patch_forward")
{
patchForward();
handled = true;
}
// Send patch back
else if (name == "txed_patch_back")
{
patchBack();
handled = true;
}
}
// Move patches if needed
if (x_movement != 0 || y_movement != 0)
{
// Do patch duplicate if alt is pressed
if (e.GetModifiers() == wxMOD_ALT && alt_press)
{
duplicatePatch(0, 0);
alt_press = false;
}
wxArrayInt selected_patches = list_patches->selectedItems();
for (size_t a = 0; a < selected_patches.size(); a++)
{
CTPatch* patch = tex_current->getPatch(selected_patches[a]);
if (!patch) continue;
int16_t cx = patch->xOffset();
int16_t cy = patch->yOffset();
patch->setOffsetX(cx + x_movement);
patch->setOffsetY(cy + y_movement);
tex_modified = true;
}
tex_canvas->redraw(true);
handled = true;
}
if (!e.AltDown())
alt_press = false;
if (!handled)
e.Skip();
}
void
wxLayoutWindow::OnChar(wxKeyEvent& event)
{
int keyCode = event.GetKeyCode();
bool ctrlDown = event.ControlDown();
#ifdef WXLAYOUT_DEBUG
if(keyCode == WXK_F1)
{
m_llist->Debug();
return;
}
#endif
// Force m_Selecting to be false if shift is no longer
// pressed. OnKeyUp() cannot catch all Shift-Up events.
if(m_Selecting && !event.ShiftDown())
{
m_Selecting = false;
m_llist->EndSelection();
m_llist->DiscardSelection(); //FIXME: correct?
}
// If we deleted the selection here, we must not execute the
// deletion in Delete/Backspace handling.
bool deletedSelection = false;
// pressing any non-arrow key optionally replaces the selection:
if(m_AutoDeleteSelection
&& IsEditable()
&& !m_Selecting
&& m_llist->HasSelection()
&& ! IsDirectionKey(keyCode)
&& ! (event.AltDown() || ctrlDown) )
{
m_llist->DeleteSelection();
deletedSelection = true;
SetDirty();
}
// <Shift>+<arrow> starts selection
if ( IsDirectionKey(keyCode) )
{
// just continue the old selection
if ( m_Selecting && event.ShiftDown() )
{
m_llist->ContinueSelection();
}
else
{
m_llist->DiscardSelection();
m_Selecting = false;
if( event.ShiftDown() )
{
m_Selecting = true;
m_llist->StartSelection();
}
}
}
// If needed, make cursor visible:
if(m_CursorVisibility == -1)
m_CursorVisibility = 1;
/* These two nested switches work like this:
The first one processes all non-editing keycodes, to move the
cursor, etc. It's default will process all keycodes causing
modifications to the buffer, but only if editing is allowed.
*/
switch(keyCode)
{
case WXK_RIGHT:
if ( ctrlDown )
m_llist->MoveCursorWord(1);
else
m_llist->MoveCursorHorizontally(1);
break;
case WXK_LEFT:
if ( ctrlDown )
m_llist->MoveCursorWord(-1);
else
m_llist->MoveCursorHorizontally(-1);
break;
case WXK_UP:
m_llist->MoveCursorVertically(-1);
break;
case WXK_DOWN:
m_llist->MoveCursorVertically(1);
break;
case WXK_PRIOR:
m_llist->MoveCursorVertically(-Y_SCROLL_PAGE);
break;
case WXK_NEXT:
m_llist->MoveCursorVertically(Y_SCROLL_PAGE);
break;
case WXK_HOME:
if ( ctrlDown )
m_llist->MoveCursorTo(wxPoint(0, 0));
else
m_llist->MoveCursorToBeginOfLine();
break;
case WXK_END:
if ( ctrlDown )
m_llist->MoveCursorToEnd();
else
m_llist->MoveCursorToEndOfLine();
break;
default:
if(ctrlDown && ! IsEditable())
{
switch(keyCode)
{
case 'c':
// this should work even in read-only mode
Copy(true, true);
break;
case 's': // search
Find(wxEmptyString);
break;
case 't': // search again
FindAgain();
break;
default:
// we don't handle it, maybe an accelerator?
event.Skip();
;
}
}
else if( IsEditable() )
{
/* First, handle control keys */
if(ctrlDown && ! event.AltDown())
{
if(keyCode >= 'A' && keyCode <= 'Z')
keyCode = tolower(keyCode);
switch(keyCode)
{
case WXK_INSERT:
Copy();
break;
case WXK_DELETE :
if(! deletedSelection)
{
m_llist->DeleteWord();
SetDirty();
}
break;
case 'd':
if(! deletedSelection) // already done
{
m_llist->Delete(1);
SetDirty();
}
break;
case 'y':
m_llist->DeleteLines(1);
SetDirty();
break;
case 'h': // like backspace
if(m_llist->MoveCursorHorizontally(-1))
{
m_llist->Delete(1);
SetDirty();
}
break;
case 's': // search
Find(wxEmptyString);
break;
case 't': // search again
FindAgain();
break;
case 'u':
m_llist->DeleteToBeginOfLine();
SetDirty();
break;
case 'k':
m_llist->DeleteToEndOfLine();
SetDirty();
break;
case 'c':
Copy(true, true);
break;
case 'v':
Paste(true);
break;
case 'x':
Cut();
break;
case 'w':
if(m_WrapMargin > 0)
m_llist->WrapLine(m_WrapMargin);
break;
case 'q':
if(m_WrapMargin > 0)
m_llist->WrapAll(m_WrapMargin);
break;
#ifdef WXLAYOUT_DEBUG
case WXK_F1:
m_llist->SetFont(-1,-1,-1,-1,true); // underlined
break;
case 'l':
Refresh(true);
break;
#endif
default:
// we don't handle it, maybe an accelerator?
event.Skip();
}
}
// ALT only:
else if( event.AltDown() && ! event.ControlDown() )
{
switch(keyCode)
{
case WXK_DELETE:
case 'd':
m_llist->DeleteWord();
SetDirty();
break;
default:
// we don't handle it, maybe an accelerator?
event.Skip();
}
}
// no control keys:
else if ( ! event.AltDown() && ! event.ControlDown())
{
switch(keyCode)
{
case WXK_INSERT:
if(event.ShiftDown())
Paste();
break;
case WXK_DELETE :
if(event.ShiftDown())
{
Cut();
}
else if(! deletedSelection)
{
m_llist->Delete(1);
SetDirty();
}
break;
case WXK_BACK: // backspace
if(! deletedSelection)
{
if(m_llist->MoveCursorHorizontally(-1))
{
m_llist->Delete(1);
SetDirty();
}
}
break;
case WXK_RETURN:
if (m_DoWordWrap &&
m_WrapMargin > 0
&& m_llist->GetCursorPos().x > m_WrapMargin )
{
m_llist->WrapLine(m_WrapMargin);
}
m_llist->LineBreak();
SetDirty();
break;
case WXK_TAB:
if ( !event.ShiftDown() )
{
// TODO should be configurable
static const int tabSize = 8;
CoordType x = m_llist->GetCursorPos().x;
size_t numSpaces = tabSize - x % tabSize;
m_llist->Insert(wxString(' ', numSpaces));
SetDirty();
}
break;
default:
if ( ( !(event.ControlDown() || event.AltDown()) )
&& (keyCode < 256 && keyCode >= 32) )
{
if ( m_DoWordWrap
&& m_WrapMargin > 0
&& m_llist->GetCursorPos().x > m_WrapMargin
&& isspace(keyCode) )
{
m_llist->WrapLine(m_WrapMargin);
}
m_llist->Insert((wxChar)keyCode);
SetDirty();
}
else
{
// we don't handle it, maybe an accelerator?
event.Skip();
}
break;
}
}
}// if(IsEditable())
else
{
// we don't handle it, maybe an accelerator?
event.Skip();
}
}// first switch()
if ( m_Selecting )
{
// continue selection to the current (new) cursor position
m_llist->ContinueSelection();
}
ScrollToCursor();
// refresh the screen
RequestUpdate(m_llist->GetUpdateRect());
}
void ChoixClavier::OnPanel1KeyDown1(wxKeyEvent& event)
{
int code = event.GetKeyCode();
std::cout << code << std::endl;
if ( code == 48 ) selectedKey = "Num0";
else if ( code == 49 ) selectedKey = "Num1";
else if ( code == 50 ) selectedKey = "Num2";
else if ( code == 51 ) selectedKey = "Num3";
else if ( code == 52 ) selectedKey = "Num4";
else if ( code == 53 ) selectedKey = "Num5";
else if ( code == 54 ) selectedKey = "Num6";
else if ( code == 55 ) selectedKey = "Num7";
else if ( code == 56 ) selectedKey = "Num8";
else if ( code == 57 ) selectedKey = "Num9";
else if ( code == 65 ) selectedKey = "a";
else if ( code == 66 ) selectedKey = "b";
else if ( code == 67 ) selectedKey = "c";
else if ( code == 68 ) selectedKey = "d";
else if ( code == 69 ) selectedKey = "e";
else if ( code == 70 ) selectedKey = "f";
else if ( code == 71 ) selectedKey = "g";
else if ( code == 72 ) selectedKey = "h";
else if ( code == 73 ) selectedKey = "i";
else if ( code == 74 ) selectedKey = "j";
else if ( code == 75 ) selectedKey = "k";
else if ( code == 76 ) selectedKey = "l";
else if ( code == 77 ) selectedKey = "m";
else if ( code == 78 ) selectedKey = "n";
else if ( code == 79 ) selectedKey = "o";
else if ( code == 80 ) selectedKey = "p";
else if ( code == 81 ) selectedKey = "q";
else if ( code == 82 ) selectedKey = "r";
else if ( code == 83 ) selectedKey = "s";
else if ( code == 84 ) selectedKey = "t";
else if ( code == 85 ) selectedKey = "u";
else if ( code == 86 ) selectedKey = "v";
else if ( code == 87 ) selectedKey = "w";
else if ( code == 88 ) selectedKey = "x";
else if ( code == 89 ) selectedKey = "y";
else if ( code == 90 ) selectedKey = "z";
//TODO: Not working?
else if ( code == '[' ) selectedKey = "LBracket";
else if ( code == ']' ) selectedKey = "RBracket";
else if ( code == ';' ) selectedKey = "SemiColon";
else if ( code == WXK_NUMPAD0 ) selectedKey = "Numpad0";
else if ( code == WXK_NUMPAD1 ) selectedKey = "Numpad1";
else if ( code == WXK_NUMPAD2 ) selectedKey = "Numpad2";
else if ( code == WXK_NUMPAD3 ) selectedKey = "Numpad3";
else if ( code == WXK_NUMPAD4 ) selectedKey = "Numpad4";
else if ( code == WXK_NUMPAD5 ) selectedKey = "Numpad5";
else if ( code == WXK_NUMPAD6 ) selectedKey = "Numpad6";
else if ( code == WXK_NUMPAD7 ) selectedKey = "Numpad7";
else if ( code == WXK_NUMPAD8 ) selectedKey = "Numpad8";
else if ( code == WXK_NUMPAD9 ) selectedKey = "Numpad9";
else if ( code == WXK_ESCAPE ) selectedKey = "Escape";
else if ( code == WXK_SPACE ) selectedKey = "Space";
else if ( code == WXK_RETURN ) selectedKey = "Return";
else if ( code == WXK_BACK ) selectedKey = "Back";
else if ( code == WXK_TAB ) selectedKey = "Tab";
else if ( code == WXK_PAGEUP ) selectedKey = "PageUp";
else if ( code == WXK_PAGEDOWN ) selectedKey = "PageDown";
else if ( code == WXK_END ) selectedKey = "End";
else if ( code == WXK_HOME ) selectedKey = "Home";
else if ( code == WXK_INSERT ) selectedKey = "Insert";
else if ( code == WXK_DELETE ) selectedKey = "Delete";
else if ( code == WXK_ADD ) selectedKey = "Add";
else if ( code == WXK_SUBTRACT) selectedKey = "Subtract";
else if ( code == WXK_MULTIPLY ) selectedKey = "Multiply";
else if ( code == WXK_DIVIDE ) selectedKey = "Divide";
else if ( code == WXK_LEFT ) selectedKey = "Left";
else if ( code == WXK_RIGHT) selectedKey = "Right";
else if ( code == WXK_UP ) selectedKey = "Up";
else if ( code == WXK_DOWN ) selectedKey = "Down";
else if ( code == WXK_F1 ) selectedKey = "F1";
else if ( code == WXK_F2 ) selectedKey = "F2";
else if ( code == WXK_F3 ) selectedKey = "F3";
else if ( code == WXK_F4 ) selectedKey = "F4";
else if ( code == WXK_F5 ) selectedKey = "F5";
else if ( code == WXK_F6 ) selectedKey = "F6";
else if ( code == WXK_F7 ) selectedKey = "F7";
else if ( code == WXK_F8 ) selectedKey = "F8";
else if ( code == WXK_F9 ) selectedKey = "F9";
else if ( code == WXK_F10 ) selectedKey = "F10";
else if ( code == WXK_F11 ) selectedKey = "F11";
else if ( code == WXK_F12 ) selectedKey = "F12";
else if ( code == WXK_PAUSE ) selectedKey = "Pause";
else if ( event.ControlDown() )
{
if ( wxMessageBox(_("Right Control : No\nLeft Control : Yes"), _("Choose the key"), wxYES_NO) == wxNO)
selectedKey = "RControl";
else
selectedKey = "LControl";
}
else if ( event.AltDown() )
{
if ( wxMessageBox(_("Right Alt : No\nLeft alt : Yes"), _("Choose the key"), wxYES_NO) == wxNO)
selectedKey = "RAlt";
else
selectedKey = "LAlt";
}
else if ( event.ShiftDown() )
{
if ( wxMessageBox(_("Right Shift : No\nLeft Shift : Yes"), _("Choose the key"), wxYES_NO) == wxNO)
selectedKey = "RShift";
else
selectedKey = "LShift";
}
EndModal(1);
}
void EDA_DRAW_PANEL::OnKeyEvent( wxKeyEvent& event )
{
int localkey;
wxPoint pos;
wxLogTrace( kicadTraceKeyEvent, "EDA_DRAW_PANEL::OnKeyEvent %s", dump( event ) );
localkey = event.GetKeyCode();
bool keyWasHandled = false;
switch( localkey )
{
default:
break;
case WXK_ESCAPE:
m_abortRequest = true;
if( IsMouseCaptured() )
EndMouseCapture();
else
EndMouseCapture( ID_NO_TOOL_SELECTED, m_defaultCursor, wxEmptyString );
keyWasHandled = true; // The key is captured: the key event must not be skipped
break;
}
/* Normalize keys code to easily handle keys from Ctrl+A to Ctrl+Z
* They have an ascii code from 1 to 27 remapped
* to GR_KB_CTRL + 'A' to GR_KB_CTRL + 'Z'
*/
if( event.ControlDown() && localkey >= WXK_CONTROL_A && localkey <= WXK_CONTROL_Z )
localkey += 'A' - 1;
/* Disallow shift for keys that have two keycodes on them (e.g. number and
* punctuation keys) leaving only the "letter keys" of A-Z.
* Then, you can have, e.g. Ctrl-5 and Ctrl-% (GB layout)
* and Ctrl-( and Ctrl-5 (FR layout).
* Otherwise, you'd have to have to say Ctrl-Shift-5 on a FR layout
*/
bool keyIsLetter = ( localkey >= 'A' && localkey <= 'Z' ) ||
( localkey >= 'a' && localkey <= 'z' );
if( event.ShiftDown() && ( keyIsLetter || localkey > 256 ) )
localkey |= GR_KB_SHIFT;
if( event.ControlDown() )
localkey |= GR_KB_CTRL;
if( event.AltDown() )
localkey |= GR_KB_ALT;
INSTALL_UNBUFFERED_DC( DC, this );
// Some key commands use the current mouse position: refresh it.
pos = wxGetMousePosition() - GetScreenPosition();
// Compute the cursor position in drawing units. Also known as logical units to wxDC.
pos = wxPoint( DC.DeviceToLogicalX( pos.x ), DC.DeviceToLogicalY( pos.y ) );
GetParent()->SetMousePosition( pos );
if( !GetParent()->GeneralControl( &DC, pos, localkey ) && !keyWasHandled )
event.Skip(); // Skip this event only when the key was not handled
}
