C++ wxKeyEvent::GetKeyCode方法代码示例

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();
	}
}