void wxStfGrid::OnKeyDown(wxKeyEvent& event) {
// Handle CTRL + 'c'
//event.Skip();
switch (event.GetKeyCode()) {
case 67:
case 99: {
if (event.ControlDown()) {
wxCommandEvent dEvent;
Copy(dEvent);
}
break;
}
default:
// pipe everything else to the graph
if (wxGetApp().GetActiveView()!=NULL && wxGetApp().GetActiveView()->GetGraph()!=NULL)
wxGetApp().GetActiveView()->GetGraph()->OnKeyDown(event);
}
}
void wxButton::OnCharHook(wxKeyEvent& event)
{
// We want to ensure that the button always processes Enter key events
// itself, even if it's inside some control that normally takes over them
// (this happens when the button is part of an in-place editor control for
// example).
if ( event.GetKeyCode() == WXK_RETURN )
{
// We should ensure that subsequent key events are still generated even
// if we did handle EVT_CHAR_HOOK (normally this would suppress their
// generation).
event.DoAllowNextEvent();
}
else
{
event.Skip();
}
}
bool Interactor2DVolumeEdit::ProcessKeyDownEvent( wxKeyEvent& event, RenderView* renderview )
{
UpdateCursor( event, renderview );
RenderView2D* view = ( RenderView2D* )renderview;
if ( event.GetModifiers() == wxMOD_ALT && event.GetKeyCode() == 'H' )
{
Contour2D* c2d = view->GetContour2D();
c2d->SetVisible( !c2d->IsVisible() );
view->NeedRedraw();
return false;
}
if ( !m_bEditing )
return Interactor2D::ProcessKeyDownEvent( event, renderview );
else
return false;
}
void MyFrame::OnKey(wxKeyEvent& event)
{
int key;
key = event.GetKeyCode();
if((currentcanvas != NULL) && (currentcanvas != FindFocus()))
{
if((key == WXK_F1) || (key == WXK_F2))
{
currentcanvas->OnKey(event);
currentcanvas->SetFocus();
return;
}
}
event.Skip();
}
void TApp::OnKeyUp(wxKeyEvent& event)
{
switch (event.GetKeyCode()) {
case WXK_SPACE: frame->canvas->trackball.Stop(); break;
case 'T': frame->NextModel(); break;
case 'Z': frame->NextTexture(); break;
case 'Q': frame->Close(); break;
case 'X': frame->Toggle(Id::BackgroundScaledTexture); break;
case 'P': frame->Toggle(Id::ViewPodium); break;
case 'B': frame->canvas->NextBackgroundColor(); break;
case 'A': frame->Toggle(Id::ViewAnimate); break;
case 'W': frame->Toggle(Id::ViewWireframe); break;
case 'G': frame->Toggle(Id::BackgroundColorGradient); break;
case WXK_CONTROL: frame->canvas->SetCursor(wxCURSOR_ARROW); break;
}
frame->canvas->Update();
event.Skip();
}
void wxGridCellBoolEditor::StartingKey(wxKeyEvent& event)
{
int keycode = event.GetKeyCode();
switch ( keycode )
{
case WXK_SPACE:
CBox()->SetValue(!CBox()->GetValue());
break;
case '+':
CBox()->SetValue(true);
break;
case '-':
CBox()->SetValue(false);
break;
}
}
void Taulell::enTeclaAvall(wxKeyEvent& event)
{
if (!this->isIniciat || this->FitxaActual.TreuForma() == FormaBuida) {
event.Skip();
return;
}
int keycode = event.GetKeyCode();
if (keycode == 'p' || keycode == 'P') {
Pausa();
return;
}
if (isAturat)
return;
switch (keycode) {
case WXK_LEFT:
this->ProvaMoure(curPiece, curX - 1, curY);
break;
case WXK_RIGHT:
this->ProvaMoure(curPiece, curX + 1, curY);
break;
case WXK_DOWN:
this->ProvaMoure(curPiece.RotateRight(), curX, curY);
break;
case WXK_UP:
this->ProvaMoure(curPiece.RotateLeft(), curX, curY);
break;
case WXK_SPACE:
this->LlancaAvall();
break;
case 'd':
this->LiniaAbaix();
break;
case 'D':
this->LiniaAbaix();
break;
default:
event.Skip();
}
}
bool Interactor2D::ProcessKeyDownEvent( wxKeyEvent& event, RenderView* renderview )
{
RenderView2D* view = ( RenderView2D* )renderview;
LayerCollectionManager* lcm = MainWindow::GetMainWindowPointer()->GetLayerCollectionManager();
if ( !lcm->HasAnyLayer() )
{
return Interactor::ProcessKeyDownEvent( event, renderview );
}
int nKeyCode = event.GetKeyCode();
if ( nKeyCode == WXK_PAGEUP )
{
view->MoveSlice( 1 );
}
else if ( nKeyCode == WXK_PAGEDOWN)
{
view->MoveSlice( -1 );
}
else if ( nKeyCode == WXK_UP )
{
view->MoveUp();
}
else if ( nKeyCode == WXK_DOWN )
{
view->MoveDown();
}
else if ( nKeyCode == WXK_LEFT )
{
view->MoveLeft();
}
else if ( nKeyCode == WXK_RIGHT )
{
view->MoveRight();
}
else if ( nKeyCode == '3' /*|| nKeyCode == 'W' || nKeyCode == 'S'*/ || nKeyCode == 'R' || nKeyCode == 'F' )
{
// do nothing, just intercept these vtk default keycodes
}
else
return Interactor::ProcessKeyDownEvent( event, view );
return false;
}
void Board::OnKeyDown(wxKeyEvent& event)
{
if (!isStarted || curPiece.GetShape() == NoShape) {
event.Skip();
return;
}
int keycode = event.GetKeyCode();
if (keycode == 'p' || keycode == 'P') {
Pause();
return;
}
if (isPaused)
return;
switch (keycode) {
case WXK_LEFT:
TryMove(curPiece, curX - 1, curY);
break;
case WXK_RIGHT:
TryMove(curPiece, curX + 1, curY);
break;
case WXK_DOWN:
TryMove(curPiece.RotateRight(), curX, curY);
break;
case WXK_UP:
TryMove(curPiece.RotateLeft(), curX, curY);
break;
case WXK_SPACE:
DropDown();
break;
case 'd':
OneLineDown();
break;
case 'D':
OneLineDown();
break;
default:
event.Skip();
}
}
void wxComboBox::OnChar( wxKeyEvent &event )
{
if ( event.GetKeyCode() == WXK_RETURN )
{
// GTK automatically selects an item if its in the list
wxCommandEvent eventEnter(wxEVT_TEXT_ENTER, GetId());
eventEnter.SetString( GetValue() );
eventEnter.SetInt( GetSelection() );
eventEnter.SetEventObject( this );
if (!HandleWindowEvent( eventEnter ))
{
// This will invoke the dialog default action, such
// as the clicking the default button.
wxWindow *top_frame = m_parent;
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
while (top_frame->GetParent() && !(top_frame->IsTopLevel()))
top_frame = top_frame->GetParent();
if (top_frame && GTK_IS_WINDOW(top_frame->m_widget))
{
GtkWindow *window = GTK_WINDOW(top_frame->m_widget);
if (window->default_widget)
gtk_widget_activate (window->default_widget);
}
}
// Catch GTK event so that GTK doesn't open the drop
// down list upon RETURN.
return;
}
event.Skip();
}
void CTreeCanvas::OnCharEvent(wxKeyEvent& event)
{
const int ControlA = 1;
const int ControlC = 3;
const int ControlV = 22;
// printf("Key event is '%d'\n", event.GetKeyCode());
switch (event.GetKeyCode())
{
case ControlA:
{
// Select all
std::list<HeeksObj*> obj_list;
for(HeeksObj* object = wxGetApp().GetFirstChild(); object != NULL; object = wxGetApp().GetNextChild())
{
if(object->GetType() != GripperType)
{
obj_list.push_back(object);
} // End if - then
} // End for
wxGetApp().m_marked_list->Add(obj_list, true);
wxGetApp().Repaint();
event.Skip();
break;
} // End ControlA scope
case ControlC:
// Copy
wxGetApp().m_marked_list->CopySelectedItems();
wxGetApp().Repaint();
event.Skip();
break;
case ControlV:
// Paste
wxGetApp().Paste(NULL, NULL);
wxGetApp().Repaint();
event.Skip();
break;
default:
break;
} // End switch
} // End OnCharEvent() method
void SudokuSolverFrame::OnGameBoardPanelKeyUp(wxKeyEvent& event)
{
unsigned int keyUp;
wxString debugStr;
keyUp = event.GetKeyCode();
if(keyUp >= '0' && keyUp <= '9')
{
if(!mGuessGB->GetShown(row, col))
{
if(ctrlSelect==SET)
{
mGuessGB->SetVal(row, col, keyUp-'0');
Refresh();
}
else if (ctrlSelect==NOTE)
{
mGuessGB->SetPossibles(row, col, keyUp-'0');
Refresh();
}
}
}
else if(keyUp >= 324 && keyUp <=333) // Numpad values for 0 - 9
{
if(!mGuessGB->GetShown(row, col))
{
if(ctrlSelect==SET)
{
mGuessGB->SetVal(row, col, keyUp-324);
Refresh();
}
else if (ctrlSelect==NOTE)
{
mGuessGB->SetPossibles(row, col, keyUp-324);
Refresh();
}
}
}
}
void wxGridCellTextEditor::StartingKey(wxKeyEvent& event)
{
// Since this is now happening in the EVT_CHAR event EmulateKeyPress is no
// longer an appropriate way to get the character into the text control.
// Do it ourselves instead. We know that if we get this far that we have
// a valid character, so not a whole lot of testing needs to be done.
wxTextCtrl* tc = Text();
int ch;
bool isPrintable;
#if wxUSE_UNICODE
ch = event.GetUnicodeKey();
if ( ch != WXK_NONE )
isPrintable = true;
else
#endif // wxUSE_UNICODE
{
ch = event.GetKeyCode();
isPrintable = ch >= WXK_SPACE && ch < WXK_START;
}
switch (ch)
{
case WXK_DELETE:
// Delete the initial character when starting to edit with DELETE.
tc->Remove(0, 1);
break;
case WXK_BACK:
// Delete the last character when starting to edit with BACKSPACE.
{
const long pos = tc->GetLastPosition();
tc->Remove(pos - 1, pos);
}
break;
default:
if ( isPrintable )
tc->WriteText(static_cast<wxChar>(ch));
break;
}
}
void TimeEdit::OnKeyDown(wxKeyEvent &event) {
int kc = event.GetKeyCode();
// Needs to be done here to trump user-defined hotkeys
int key = event.GetUnicodeKey();
if (event.CmdDown()) {
if (key == 'C' || key == 'X')
CopyTime();
else if (key == 'V')
PasteTime();
else
event.Skip();
return;
}
// Shift-Insert would paste the stuff anyway
// but no one updates the private "time" variable.
if (event.ShiftDown() && kc == WXK_INSERT) {
PasteTime();
return;
}
if (byFrame || insert) {
event.Skip();
return;
}
// Overwrite mode stuff
// On OS X backspace is reported as delete
#ifdef __APPLE__
if (kc == WXK_DELETE)
kc = WXK_BACK;
#endif
// Back just moves cursor back one without deleting
if (kc == WXK_BACK) {
long start = GetInsertionPoint();
if (start > 0)
SetInsertionPoint(start - 1);
}
// Delete just does nothing
else if (kc != WXK_DELETE)
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();
}
}
void wxCodeCompletionBox::StcKeyDown(wxKeyEvent& event)
{
switch(event.GetKeyCode()) {
case WXK_UP:
DoScrollUp();
break;
case WXK_DOWN:
DoScrollDown();
break;
case WXK_PAGEDOWN: {
DoPgDown();
break;
}
case WXK_PAGEUP: {
DoPgUp();
break;
}
case WXK_ESCAPE:
case WXK_LEFT:
case WXK_RIGHT:
case WXK_HOME:
case WXK_END:
case WXK_DELETE:
case WXK_NUMPAD_DELETE:
case WXK_ALT:
case WXK_WINDOWS_LEFT:
case WXK_WINDOWS_RIGHT:
case WXK_CONTROL:
DoDestroy();
event.Skip();
break;
case WXK_TAB:
case WXK_RETURN:
case WXK_NUMPAD_ENTER:
// Insert the selection
InsertSelection();
DoDestroy();
break;
default:
event.Skip();
break;
}
}
void MainGLCanvas::OnKeyDown( wxKeyEvent& event )
{
switch ( event.GetKeyCode() )
{
case WXK_RIGHT:
wxGetApp().GetContext(this).DrawScene();
break;
case WXK_LEFT:
wxGetApp().GetContext(this).DynamicDraw();
break;
case WXK_SPACE:
wxGetApp().GetContext(this).StepDraw();
break;
default:
event.Skip();
return;
}
}
void RegTreeCtrl::OnChar(wxKeyEvent& event)
{
switch ( event.GetKeyCode() )
{
case WXK_DELETE:
DeleteSelected();
return;
case WXK_RETURN:
if ( event.AltDown() )
{
ShowProperties();
return;
}
}
event.Skip();
}
void wxHexDataPanel::OnChar(wxKeyEvent &evt)
{
switch (evt.GetKeyCode())
{
case WXK_LEFT:
break;
case WXK_RIGHT:
{
wxPoint caretPos = GetCaret()->GetPosition();
caretPos.x += 20;
GetCaret()->Move(caretPos);
}
break;
default:
break;
}
}
void klsGLCanvas::wxKeyDown(wxKeyEvent& event) {
reclaimViewport();
// Give the subclassed handler first dibs on the event:
OnKeyDown( event );
// If the subclassed handler took the event, then don't handle it:
if( event.GetSkipped() ) return;
switch (event.GetKeyCode()) {
case WXK_LEFT:
case WXK_NUMPAD_LEFT:
translatePan(-PAN_STEP * getZoom(), 0.0);
break;
case WXK_RIGHT:
case WXK_NUMPAD_RIGHT:
translatePan(+PAN_STEP * getZoom(), 0.0);
break;
case WXK_UP:
case WXK_NUMPAD_UP:
translatePan(0.0, PAN_STEP * getZoom());
break;
case WXK_DOWN:
case WXK_NUMPAD_DOWN:
translatePan(0.0, -PAN_STEP * getZoom());
break;
case 43: // + key on top row (Works for both '+' and '=')
//if (!shiftKeyOn) break;
case WXK_NUMPAD_ADD:
setZoom( getZoom() * ZOOM_STEP );
break;
case 45: // - key on top row (Works for both '-' and '_')
case WXK_NUMPAD_SUBTRACT:
setZoom( getZoom() / ZOOM_STEP );
break;
default:
event.Skip();
break;
}
updateMiniMap();
}
wxString NewKeyShortcutDlg::ToString(wxKeyEvent& e)
{
wxString text;
// int flags = e.GetModifiers();
// if ( flags & wxMOD_ALT )
// text += wxT("Alt-");
// if ( flags & wxMOD_CONTROL )
// text += wxT("Ctrl-");
// if ( flags & wxMOD_SHIFT )
// text += wxT("Shift-");
const int code = e.GetKeyCode();
if(code >= WXK_F1 && code <= WXK_F12)
text << _("F") << code - WXK_F1 + 1;
else if(code >= WXK_NUMPAD0 && code <= WXK_NUMPAD9)
text << code - WXK_NUMPAD0;
else if(code >= WXK_SPECIAL1 && code <= WXK_SPECIAL20)
text << _("SPECIAL") << code - WXK_SPECIAL1 + 1;
else { // check the named keys
size_t n;
for(n = 0; n < WXSIZEOF(wxKeyNames); n++) {
const wxKeyName& kn = wxKeyNames[n];
if(code == kn.code && kn.code != WXK_COMMAND) {
text << wxGetTranslation(kn.name);
break;
}
}
if(n == WXSIZEOF(wxKeyNames)) {
// must be a simple key
if(isascii(code)) {
text << (wxChar)code;
} else {
return wxEmptyString;
}
}
}
return text;
}
void BrushListBox::OnKey(wxKeyEvent& event) {
switch(event.GetKeyCode()) {
case WXK_UP:
case WXK_DOWN:
case WXK_LEFT:
case WXK_RIGHT:
if(settings.getInteger(Config::LISTBOX_EATS_ALL_EVENTS)) {
case WXK_PAGEUP:
case WXK_PAGEDOWN:
case WXK_HOME:
case WXK_END:
event.Skip(true);
} else {
default:
if(gui.GetCurrentTab() != nullptr) {
gui.GetCurrentMapTab()->GetEventHandler()->AddPendingEvent(event);
}
}
}
}
virtual void OnChar(wxKeyEvent& event)
{
switch(event.GetKeyCode()) {
case WXK_PAGEUP: {
//zoom -
DoZoom(3);
event.Skip(false);
}
break;
case WXK_PAGEDOWN: {
//zoom +
DoZoom(-3);
event.Skip(false);
}
break;
default:
event.ResumePropagation(10);
event.Skip(true);
}
}
void GotoFileDlg::OnSearchChar(wxKeyEvent& event) {
switch ( event.GetKeyCode() )
{
case WXK_UP:
m_cmdList->SelectPrev();
UpdateStatusbar();
return;
case WXK_DOWN:
m_cmdList->SelectNext();
UpdateStatusbar();
return;
case WXK_ESCAPE:
m_isDone = true;
EndModal(wxID_CANCEL);
return;
}
// no, we didn't process it
event.Skip();
}
//---------------------------------------------------------
void CWKSP_Data_Button::On_Key(wxKeyEvent &event)
{
wxCommandEvent Command;
switch( event.GetKeyCode() )
{
case WXK_RETURN:
Command.SetId(ID_CMD_WKSP_ITEM_RETURN);
g_pData_Ctrl->On_Command(Command);
break;
case WXK_DELETE:
Command.SetId(ID_CMD_WKSP_ITEM_CLOSE);
g_pData_Ctrl->On_Command(Command);
break;
default:
break;
}
}
void UIEAttributes::OnCharHook(wxKeyEvent& event)
{
wxWindow *win = FindFocus ();
if (win == NULL)
{
event.Skip ();
return;
}
if (event.GetKeyCode () == WXK_TAB)
{
switch (win->GetId ())
{
case wxID_CANCEL:
text_value->SetFocus();
return;
}
}
event.Skip ();
}
//---------------------------- PRIVATE -----------------------------//
void wxTexDropListCtrl::OnKeyDown(const wxKeyEvent &event)
{
//check for a deletion
if(WXK_DELETE == event.GetKeyCode())
{
wxTexEditorPane *frame = static_cast<wxTexEditorPane *>(GetParent());
wxASSERT(NULL != frame);
wxInt32 index = GetSelectedItem();
if(-1 != index)
{
frame->DeleteItem(index);
// We need to stop promulgating this event becase we just deleted
// the window it came from.
const_cast<wxKeyEvent&>(event).Skip(false);
}
}
}
//---------------------------------------------------------
void CView_Map_3DPanel::On_Key_Down(wxKeyEvent &event)
{
switch( event.GetKeyCode() )
{
default: CSG_3DView_Panel::On_Key_Down(event); return;
case WXK_F1: m_zScale -= 0.5; break;
case WXK_F2: m_zScale += 0.5; break;
case WXK_F5: Inc_DEM_Res(-25); break;
case WXK_F6: Inc_DEM_Res( 25); break;
case WXK_F7: Inc_DEM_Res(-25); break;
case WXK_F8: Inc_DEM_Res( 25); break;
}
//-----------------------------------------------------
Update_View();
Update_Parent();
}
void OnCharHook( wxKeyEvent& aEvent )
{
// On certain platforms, EVT_CHAR_HOOK is the only handler that receives
// certain "special" keys. However, it doesn't always receive "normal"
// keys correctly. For example, with a US keyboard, it sees ? as shift+/.
//
// Untangling these incorrect keys would be too much trouble, so we bind
// both events, and simply skip the EVT_CHAR_HOOK if it receives a
// "normal" key.
const enum wxKeyCode skipped_keys[] =
{
WXK_NONE, WXK_SHIFT, WXK_ALT, WXK_CONTROL, WXK_CAPITAL,
WXK_NUMLOCK, WXK_SCROLL, WXK_RAW_CONTROL
};
int key = aEvent.GetKeyCode();
for( size_t i = 0; i < sizeof( skipped_keys ) / sizeof( skipped_keys[0] ); ++i )
{
if( key == skipped_keys[i] )
return;
}
if( key <= 255 && isprint( key ) && !isspace( key ) )
{
// Let EVT_CHAR handle this one
aEvent.DoAllowNextEvent();
// On Windows, wxEvent::Skip must NOT be called.
// On Linux and OSX, wxEvent::Skip MUST be called.
// No, I don't know why.
#ifndef __WXMSW__
aEvent.Skip();
#endif
}
else
{
OnChar( aEvent );
}
}
void wxTextCtrl::OnChar(
wxKeyEvent& rEvent
)
{
switch (rEvent.GetKeyCode())
{
case WXK_RETURN:
if ( !(m_windowStyle & wxTE_MULTILINE) )
{
wxCommandEvent vEvent(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
vEvent.SetEventObject(this);
if ( GetEventHandler()->ProcessEvent(vEvent))
return;
}
//else: multiline controls need Enter for themselves
break;
case WXK_TAB:
// always produce navigation event - even if we process TAB
// ourselves the fact that we got here means that the user code
// decided to skip processing of this TAB - probably to let it
// do its default job.
//
// NB: Notice that Ctrl-Tab is handled elsewhere and Alt-Tab is
// handled by Windows
{
wxNavigationKeyEvent vEventNav;
vEventNav.SetDirection(!rEvent.ShiftDown());
vEventNav.SetWindowChange(false);
vEventNav.SetEventObject(this);
if ( GetEventHandler()->ProcessEvent(vEventNav) )
return;
}
break;
}
rEvent.Skip();
} // end of wxTextCtrl::OnChar
