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

void ContrastDialog::OnChar(wxKeyEvent &event)
{
   event.Skip(false);
   return;
}

void MyListCtrl::OnChar(wxKeyEvent& event)
{
    wxLogMessage(wxT("Got char event."));

    event.Skip();
}

void TimeTextCtrl::OnKeyDown(wxKeyEvent &event)
{
   event.Skip(false);
   int keyCode = event.GetKeyCode();
   int digit = mFocusedDigit;

   if (mFocusedDigit < 0)
      mFocusedDigit = 0;
   if (mFocusedDigit >= (int)mDigits.GetCount())
      mFocusedDigit = mDigits.GetCount()-1;

   // Convert numeric keypad entries.
   if ((keyCode >= WXK_NUMPAD0) && (keyCode <= WXK_NUMPAD9)) keyCode -= WXK_NUMPAD0 - '0';

   if (keyCode >= '0' && keyCode <= '9') {
      mValueString[mDigits[mFocusedDigit].pos] = wxChar(keyCode);
      ControlsToValue();
      ValueToControls();
      mFocusedDigit = (mFocusedDigit+1)%(mDigits.GetCount());
      Updated();
   }

   else if (keyCode == WXK_BACK) {
      // Moves left, replaces that char with '0', stays there...
      mFocusedDigit--;
      mFocusedDigit += mDigits.GetCount();
      mFocusedDigit %= mDigits.GetCount();
      mValueString[mDigits[mFocusedDigit].pos] = '0';
      ControlsToValue();
      ValueToControls();
      Updated();
   }

   else if (keyCode == WXK_LEFT) {
      mFocusedDigit--;
      mFocusedDigit += mDigits.GetCount();
      mFocusedDigit %= mDigits.GetCount();
      Refresh();
   }

   else if (keyCode == WXK_RIGHT) {
      mFocusedDigit++;
      mFocusedDigit %= mDigits.GetCount();
      Refresh();
   }
   
   else if (keyCode == WXK_HOME) {
      mFocusedDigit = 0;
      Refresh();
   }
   
   else if (keyCode == WXK_END) {
      mFocusedDigit = mDigits.GetCount() - 1;
      Refresh();
   }

   else if (keyCode == WXK_UP) {
      Increase(1);
      Updated();
   }

   else if (keyCode == WXK_DOWN) {
      Decrease(1);
      Updated();
   }

   else if (keyCode == WXK_TAB) {   
      wxWindow *parent = GetParent();
      wxNavigationKeyEvent nevent;
      nevent.SetWindowChange(event.ControlDown());
      nevent.SetDirection(!event.ShiftDown());
      nevent.SetEventObject(parent);
      nevent.SetCurrentFocus(parent);
      GetParent()->ProcessEvent(nevent);
   } 

   else if (keyCode == WXK_RETURN || keyCode == WXK_NUMPAD_ENTER) {
      wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
      wxWindow *def = tlw->GetDefaultItem();
      if (def && def->IsEnabled()) {
         wxCommandEvent cevent(wxEVT_COMMAND_BUTTON_CLICKED,
                               def->GetId());
         GetParent()->ProcessEvent(cevent);
      }
   }

   else {
      event.Skip();
      return;
   }

   if (digit != mFocusedDigit) {
      SetFieldFocus(mFocusedDigit);
   }

   event.Skip(false);
}

void CorrelationDialog::OnChar(wxKeyEvent& event){
	if (event.GetKeyCode() == WXK_ESCAPE){
		this->EndModal(wxCANCEL);
	}
	event.Skip();
};

void wxCheckListBox::OnKeyDown(wxKeyEvent& event)
{
    // what do we do?
    enum
    {
        NONE,
        TOGGLE,
        SET,
        CLEAR
    } oper;

    switch ( event.GetKeyCode() )
    {
        case WXK_SPACE:
            oper = TOGGLE;
            break;

        case WXK_NUMPAD_ADD:
        case '+':
            oper = SET;
            break;

        case WXK_NUMPAD_SUBTRACT:
        case '-':
            oper = CLEAR;
            break;

        default:
            oper = NONE;
    }

    if ( oper != NONE )
    {
        wxArrayInt selections;
        int count = 0;
        if ( HasMultipleSelection() )
        {
            count = GetSelections(selections);
        }
        else
        {
            int sel = GetSelection();
            if (sel != -1)
            {
                count = 1;
                selections.Add(sel);
            }
        }

        for ( int i = 0; i < count; i++ )
        {
            int nItem = selections[i];

            switch ( oper )
            {
                case TOGGLE:
                    Toggle(nItem);
                    break;

                case SET:
                case CLEAR:
                    Check(nItem, oper == SET);
                    break;

                default:
                    wxFAIL_MSG( wxT("what should this key do?") );
            }

            // we should send an event as this has been done by the user and
            // not by the program
            SendEvent(nItem);
        }
    }
    else // nothing to do
    {
        event.Skip();
    }
}

void MemCheckOutputView::OnListCtrlErrorsKeyUp(wxKeyEvent& event)
{
    event.Skip();
    UpdateStatusSupp();
}

// -----------------------------------------------------------------------------
// Called when a key is pressed in the texture list
// -----------------------------------------------------------------------------
void TextureXPanel::onTextureListKeyDown(wxKeyEvent& e)
{
	// Check if keypress matches any keybinds
	wxArrayString binds = KeyBind::getBinds(KeyBind::asKeyPress(e.GetKeyCode(), e.GetModifiers()));

	// Go through matching binds
	for (unsigned a = 0; a < binds.size(); a++)
	{
		string name = binds[a];

		// Copy
		if (name == "copy")
		{
			copy();
			return;
		}

		// Cut
		else if (name == "cut")
		{
			copy();
			removeTexture();
			return;
		}

		// Paste
		else if (name == "paste")
		{
			paste();
			return;
		}

		// Move texture up
		else if (name == "txed_tex_up")
		{
			moveUp();
			return;
		}

		// Move texture down
		else if (name == "txed_tex_down")
		{
			moveDown();
			return;
		}

		// New texture
		else if (name == "txed_tex_new")
		{
			newTexture();
			return;
		}

		// New texture from patch
		else if (name == "txed_tex_new_patch")
		{
			newTextureFromPatch();
			return;
		}

		// New texture from file
		else if (name == "txed_tex_new_file")
		{
			newTextureFromFile();
			return;
		}

		// Delete texture
		else if (name == "txed_tex_delete")
		{
			removeTexture();
			return;
		}
	}

	// Not handled here, send off to be handled by a parent window
	e.Skip();
}

void wxSymbolListCtrl::OnKeyDown(wxKeyEvent& event)
{
    // No keyboard interface for now
    event.Skip();
#if 0
    // flags for DoHandleItemClick()
    int flags = ItemClick_Kbd;

    int currentLineNow = SymbolValueToLineNumber(m_current);

    int currentLine;
    switch ( event.GetKeyCode() )
    {
        case WXK_HOME:
            currentLine = 0;
            break;

        case WXK_END:
            currentLine = GetLineCount() - 1;
            break;

        case WXK_DOWN:
            if ( currentLineNow == (int)GetLineCount() - 1 )
                return;

            currentLine = currentLineNow + 1;
            break;

        case WXK_UP:
            if ( m_current == wxNOT_FOUND )
                currentLine = GetLineCount() - 1;
            else if ( currentLineNow != 0 )
                currentLine = currentLineNow - 1;
            else // currentLineNow == 0
                return;
            break;

        case WXK_PAGEDOWN:
            PageDown();
            currentLine = GetFirstVisibleLine();
            break;

        case WXK_PAGEUP:
            if ( currentLineNow == (int)GetFirstVisibleLine() )
            {
                PageUp();
            }

            currentLine = GetFirstVisibleLine();
            break;

        case WXK_SPACE:
            // hack: pressing space should work like a mouse click rather than
            // like a keyboard arrow press, so trick DoHandleItemClick() in
            // thinking we were clicked
            flags &= ~ItemClick_Kbd;
            currentLine = currentLineNow;
            break;

#ifdef __WXMSW__
        case WXK_TAB:
            // Since we are using wxWANTS_CHARS we need to send navigation
            // events for the tabs on MSW
            {
                wxNavigationKeyEvent ne;
                ne.SetDirection(!event.ShiftDown());
                ne.SetCurrentFocus(this);
                ne.SetEventObject(this);
                GetParent()->GetEventHandler()->ProcessEvent(ne);
            }
            // fall through to default
#endif
        default:
            event.Skip();
            currentLine = 0; // just to silent the stupid compiler warnings
            wxUnusedVar(currentNow);
            return;
    }

#if 0
    if ( event.ShiftDown() )
       flags |= ItemClick_Shift;
    if ( event.ControlDown() )
        flags |= ItemClick_Ctrl;

    DoHandleItemClick(current, flags);
#endif
#endif
}

void wxPropertyList::OnKeyPressed( wxKeyEvent &event )
{
    event.Skip();
}

void AutocompletePopup::ProcessEvent(wxKeyEvent& event)
{
  event.Skip();
}

void ClientBoard::OnKeyDown( wxKeyEvent& event )
{
    AILOCKT(CltTetrisEngine::getMe().m_SyncMsgList);

    stTetrisOperator cmd;

    int keycode = event.GetKeyCode();

    if (m_LogicBoard.isPaused)
        return;

    switch (keycode) {
    case WXK_LEFT:
    {
        cmd.btOperator = emTR_OPERATOR_LEFT;
    }
    break;
    case WXK_RIGHT:
    {
        cmd.btOperator = emTR_OPERATOR_RIGHT;
    }
    break;
    case WXK_DOWN:
    {
        cmd.btOperator = emTR_OPERATOR_DOWN;

    }
    break;
    case WXK_UP:
    {
        cmd.btOperator = emTR_OPERATOR_ROTATELEFT;
    }
    break;
    case WXK_SPACE:
    {
        cmd.btOperator = emTR_OPERATOR_START;
    }
    break;
    case 'd':
    {
        cmd.btOperator = emTR_OPERATOR_PAUSE;
    }
    break;
    case 'D':
    {
        cmd.btOperator = emTR_OPERATOR_PAUSE;
    }
    break;
    case 'O':
    case 'o':
    {
    } break;
    case 'p':
    case 'P':
    {
        cmd.btOperator = emTR_OPERATOR_PAUSE;
    }
    break;
    default:
        cmd.btOperator = emTR_OPERATOR_NULL;
        event.Skip();
    }

    if (cmd.btOperator !=emTR_OPERATOR_NULL)
    {
        if (CltTetrisEngine::getMe().m_boAlone) {
            stBaseMessage* bmsg = __copy_msg((stBaseCmd*)&cmd,sizeof(stTetrisOperator));
            if (bmsg)
                CltTetrisEngine::getMe().m_SyncMsgList.push_back(bmsg);
        } else {
            if (CltTetrisEngine::getMe().m_ClientSession)
                CltTetrisEngine::getMe().m_ClientSession->write((stBaseCmd*)&cmd,sizeof(stTetrisOperator));
        }
    }
}

void wxInputConsumer::OnKeyUp(wxKeyEvent& event)
{
    if ( !m_inputHandler || !m_inputHandler->HandleKey(this, event, false) )
        event.Skip();
}

void ctlSQLBox::OnKeyDown(wxKeyEvent& event)
{
#ifdef __WXGTK__
    event.m_metaDown=false;
#endif

    // Get the line ending type
    wxString lineEnd;
    switch (GetEOLMode())
    {
        case wxSTC_EOL_LF:
            lineEnd = wxT("\n");
            break;
        case wxSTC_EOL_CRLF:
            lineEnd = wxT("\r\n");
            break;
        case wxSTC_EOL_CR:
            lineEnd = wxT("\r");
            break;
    }

    // Block comment/uncomment
    if (event.GetKeyCode() == 'K')
    {
        // Comment (Ctrl+k)
        if (event.GetModifiers() == wxMOD_CONTROL)
        {
            if (BlockComment(false))
                return;
        }
        // Uncomment (Ctrl+Shift+K)
        else if (event.GetModifiers() == (wxMOD_CONTROL | wxMOD_SHIFT))
        {
            if (BlockComment(true))
                return;
        }
    }

    // Autoindent
    if (m_autoIndent && event.GetKeyCode() == WXK_RETURN)
    {
        wxString indent, line;
        line = GetLine(GetCurrentLine());

        // Get the offset for the current line - basically, whether
        // or not it ends with a \r\n, \n or \r, and if so, the length
        int offset =  0;
        if (line.EndsWith(wxT("\r\n")))
            offset = 2;
        else if (line.EndsWith(wxT("\n")))
            offset = 1;
        else if (line.EndsWith(wxT("\r")))
            offset = 1;

        // Get the indent. This is every leading space or tab on the
        // line, up until the current cursor position.
        int x = 0;
        int max = line.Length() - (GetLineEndPosition(GetCurrentLine()) - GetCurrentPos()) - offset;
        while ((line[x] == '\t' || line[x] == ' ') && x < max)
            indent += line[x++];

        // Select any indent in front of the cursor to be removed. If
        // the cursor is positioned after any non-indent characters, 
        // we don't remove anything. If there is already some selected,
        // don't select anything new at all.
        if (indent.Length() != 0 && 
            (unsigned int)GetCurrentPos() <= ((GetLineEndPosition(GetCurrentLine()) - line.Length()) + indent.Length() + offset) && 
            GetSelectedText() == wxEmptyString)
            SetSelection(GetLineEndPosition(GetCurrentLine()) - line.Length() + offset, GetLineEndPosition(GetCurrentLine()) - line.Length() + indent.Length() + offset);

        // Lose any selected text.
        ReplaceSelection(wxEmptyString);

        // Insert a replacement \n (or whatever), and the indent at the insertion point.
        InsertText(GetCurrentPos(), lineEnd + indent);

        // Now, reset the position, and clear the selection
        SetCurrentPos(GetCurrentPos() + indent.Length() + lineEnd.Length());
        SetSelection(GetCurrentPos(), GetCurrentPos());
    }
    else if (m_dlgFindReplace && event.GetKeyCode() == WXK_F3)
    {
        m_dlgFindReplace->FindNext();
    }
    else
        event.Skip();
}

//.........这里部分代码省略.........
        {
            if(current_pos < static_cast<int>(Historical.GetCount())-1)
            {
                ++current_pos;
                SetValue(Historical[current_pos]);
            }
            else
            {
                current_pos = Historical.GetCount();
                SetValue( m_original );
                SetInsertionPointEnd();
            }
        }
        else
		if(keyCode == WXK_TAB )
        {
			if ( ( modifier & wxMOD_CONTROL ) != 0 ){
				ui().mw().GetChatTab().AdvanceSelection( ( modifier & wxMOD_SHIFT ) == 0 );
			}
			else {
				wxString text = this->GetValue();
				long pos_Cursor = this->GetInsertionPoint();
				wxString selection_Begin_InsertPos = this->GetRange( 0, pos_Cursor );
				wxString selection_InsertPos_End = this->GetRange( pos_Cursor, this->GetLastPosition() );

				// Search for the shortest Match, starting from the Insertionpoint to the left, until we find a "\ "
				// Special Characters according to regular Expression Syntax needs to be escaped: [,]
				wxRegEx regex_currentWord;
				#ifdef wxHAS_REGEX_ADVANCED
				regex_currentWord.Compile( wxT("(_|\\[|\\]|\\w)+$"), wxRE_ADVANCED );
				#else
				regex_currentWord.Compile( wxT("(_|\\[|\\]|\\w)+$"), wxRE_EXTENDED );
				#endif

				if ( regex_currentWord.Matches( selection_Begin_InsertPos ) ) {
					wxString currentWord = regex_currentWord.GetMatch( selection_Begin_InsertPos );
					// std::cout << "#########: Current Word: (" << currentWord.char_str() << ")" << std::endl;

					wxString selection_Begin_BeforeCurrentWord = this->GetRange( 0, pos_Cursor - currentWord.length() );
					// std::cout << "#########: selection_Begin_BeforeCurrentWord: (" << selection_Begin_BeforeCurrentWord.char_str() << ")" << std::endl;

					HashMap_String_String hm = textcompletiondatabase.GetMapping( currentWord );

					// std::cout << "#########: Mapping-Size: (" << hm.size() << ")" << std::endl;

					wxString completed_Text;
					int new_Cursor_Pos = 0;
					if( hm.size() == 1 ) {
						completed_Text.append( selection_Begin_BeforeCurrentWord );
						completed_Text.append( hm.begin()->second );
						completed_Text.append( selection_InsertPos_End );
						new_Cursor_Pos = selection_Begin_BeforeCurrentWord.length() + hm.begin()->second.length();
					} else {
						//match nearest only makes sense when there's actually more than one match
						if ( hm.size() > 1 && sett().GetCompletionMethod() == Settings::MatchNearest ) {
							wxArrayString matches;
							GetArrayStringFromHashMap( hm , matches );
							wxString newWord = GetBestMatch( matches, currentWord );

							bool realCompletion = newWord.Len() >= currentWord.Len(); // otherwise we have actually less word than before :P
							if ( realCompletion )
								currentWord =  newWord;

							completed_Text.append( selection_Begin_BeforeCurrentWord );
							completed_Text.append( currentWord );
							completed_Text.append( selection_InsertPos_End );
							new_Cursor_Pos = selection_Begin_BeforeCurrentWord.length() + currentWord.length();

							// We ring the System Bell, to signalise the User, that no Completion was applied.
							if (!realCompletion)
								wxBell();
						}
						else {
							completed_Text.append( selection_Begin_BeforeCurrentWord );
							completed_Text.append( currentWord );
							completed_Text.append( selection_InsertPos_End );
							new_Cursor_Pos = selection_Begin_BeforeCurrentWord.length() + currentWord.length();
							// We ring the System Bell, to signalise the User, that no Completion was applied.
							wxBell();
						}
					}
					// Replace the old Text with our completed Text
					// or
					// if nothing was found remove the typed TAB, so that the User stays comfortable not to remove the TAB by himself.
					this->ChangeValue( completed_Text );
					this->SetInsertionPoint( new_Cursor_Pos );
				} else {
					wxString old_Text;
					old_Text.append( selection_Begin_InsertPos );
					old_Text.append( selection_InsertPos_End );
					this->ChangeValue( old_Text );
					this->SetInsertionPoint( selection_Begin_InsertPos.length() );
					wxBell();
				}
			}
        }
        else
            event.Skip();

}

void wxFlatButton::OnKeyDown(wxKeyEvent& event) { event.Skip(); }