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();
}
void wxTextCtrlHist::OnChar(wxKeyEvent & event)
{
const int keyCode = event.GetKeyCode();
const int modifier = event.GetModifiers();
if ( current_pos == int(Historical.GetCount()) ) {
m_original = GetValue();
}
if(keyCode == WXK_UP)
{
if(current_pos > 0)
{
--current_pos;
SetValue(Historical[current_pos]);
SetInsertionPointEnd();
}
}
else
if(keyCode == WXK_DOWN)
{
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(); }
void wxMultiColumnListCtrl::OnKey(wxKeyEvent& event)
{
if (event.GetEventType() == wxEVT_KEY_UP)
{
if (event.GetKeyCode() == GetModifierKey())
{
// The window will close, don't select the item under mouse pointer
m_ptMouse.x = m_ptMouse.y = -2;
SendCloseEvent();
}
event.Skip();
return;
}
if (event.GetKeyCode() == WXK_ESCAPE || event.GetKeyCode() == WXK_RETURN || event.GetKeyCode() == WXK_NUMPAD_ENTER)
{
// The window will close, don't select the item under mouse pointer
m_ptMouse.x = m_ptMouse.y = -2;
if (event.GetKeyCode() == WXK_ESCAPE)
m_items.SetSelection(-1);
SendCloseEvent();
}
else if (event.GetKeyCode() == WXK_TAB || event.GetKeyCode() == GetExtraNavigationKey())
{
if (event.ShiftDown())
{
m_items.SetSelection(m_items.GetSelection() - 1);
if (m_items.GetSelection() < 0)
m_items.SetSelection(m_items.GetItemCount() - 1);
AdvanceToNextSelectableItem(-1);
}
else
{
m_items.SetSelection(m_items.GetSelection() + 1);
if (m_items.GetSelection() >= m_items.GetItemCount())
m_items.SetSelection(0);
AdvanceToNextSelectableItem(1);
}
GenerateSelectionEvent();
Refresh();
}
else if (event.GetKeyCode() == WXK_DOWN || event.GetKeyCode() == WXK_NUMPAD_DOWN)
{
m_items.SetSelection(m_items.GetSelection() + 1);
if (m_items.GetSelection() >= m_items.GetItemCount())
m_items.SetSelection(0);
AdvanceToNextSelectableItem(1);
GenerateSelectionEvent();
Refresh();
}
else if (event.GetKeyCode() == WXK_UP || event.GetKeyCode() == WXK_NUMPAD_UP)
{
m_items.SetSelection(m_items.GetSelection() - 1);
if (m_items.GetSelection() < 0)
m_items.SetSelection(m_items.GetItemCount() - 1);
AdvanceToNextSelectableItem(-1);
GenerateSelectionEvent();
Refresh();
}
else if (event.GetKeyCode() == WXK_HOME || event.GetKeyCode() == WXK_NUMPAD_HOME)
{
m_items.SetSelection(0);
AdvanceToNextSelectableItem(1);
GenerateSelectionEvent();
Refresh();
}
else if (event.GetKeyCode() == WXK_END || event.GetKeyCode() == WXK_NUMPAD_END)
{
m_items.SetSelection(m_items.GetItemCount() - 1);
AdvanceToNextSelectableItem(-1);
GenerateSelectionEvent();
Refresh();
}
else if (event.GetKeyCode() == WXK_LEFT || event.GetKeyCode() == WXK_NUMPAD_LEFT)
{
wxSwitcherItem& item = m_items.GetItem(m_items.GetSelection());
int row = item.GetRowPos();
int newCol = item.GetColPos() - 1;
if (newCol < 0)
newCol = (m_items.GetColumnCount() - 1);
// Find the first item from the end whose row matches and whose column is equal or lower
int i;
for (i = m_items.GetItemCount()-1; i >= 0; i--)
{
wxSwitcherItem& item2 = m_items.GetItem(i);
if (item2.GetColPos() == newCol && item2.GetRowPos() <= row)
{
m_items.SetSelection(i);
break;
}
}
AdvanceToNextSelectableItem(-1);
GenerateSelectionEvent();
Refresh();
}
else if (event.GetKeyCode() == WXK_RIGHT || event.GetKeyCode() == WXK_NUMPAD_RIGHT)
{
wxSwitcherItem& item = m_items.GetItem(m_items.GetSelection());
int row = item.GetRowPos();
int newCol = item.GetColPos() + 1;
if (newCol >= m_items.GetColumnCount())
newCol = 0;
// Find the first item from the end whose row matches and whose column is equal or lower
int i;
for (i = m_items.GetItemCount()-1; i >= 0; i--)
{
wxSwitcherItem& item2 = m_items.GetItem(i);
if (item2.GetColPos() == newCol && item2.GetRowPos() <= row)
{
m_items.SetSelection(i);
break;
}
}
AdvanceToNextSelectableItem(1);
GenerateSelectionEvent();
Refresh();
}
else
event.Skip();
}
void MemCheckOutputView::OnListCtrlErrorsChar(wxKeyEvent& event) { event.Skip(); }
void IWnd_stc::OnKeyEvent(wxKeyEvent& evt)
{
int kc = evt.GetRawKeyCode();
if(kc==wxSTC_KEY_TAB)
{
if(evt.ShiftDown())
{
CmdKeyExecute (wxSTC_CMD_BACKTAB);
}
else
{
CmdKeyExecute (wxSTC_CMD_TAB);
}
return;
}
if(evt.ControlDown())
{
switch(kc)
{
case 'C':
{
Copy();
}
return;
case 'X':
{
Cut();
}
return;
case 'V':
{
Paste();
}
return;
case 'A':
{
SelectAll();
}
return;
case 'Z':
{
Undo();
}
return;
case 'R':
{
Redo();
}
return;
case 'D':
{
this->Clear();
}
return;
//case 'F':
// if(style.get(STYLE_CAN_FIND))
// {
// WndManager::current().evtmgr["Find"].CmdExecuteEx(-1);
// evt.Skip();
// return;
// }
// break;
//case 'H':
// if(style.get(STYLE_CAN_REPLACE))
// {
// WndManager::current().evtmgr["Replace"].CmdExecuteEx(-1);
// evt.Skip();
// return;
// }
// break;
};
}
evt.Skip();
}
void MiniStyledTextCtrl::OnKey(wxKeyEvent& event)
{ // ignore key press events
event.Skip(false);
}
void ContentAssistantPopup::OnKeyPress(wxKeyEvent& event)
{
#if wxUSE_UNICODE
wxChar key = event.GetUnicodeKey();
#else
wxChar key = wxString::Format(wxT("%c"), ChangeNumpadToChar(event.GetKeyCode()));
#endif
switch (event.GetKeyCode()) {
case WXK_TAB:
if(m_completions.GetCount()>0)
{
wxChar ch;
bool addChar = true;
wxString word=m_editor->GetSelectionString();
int index=word.Length();
do
{
if(m_completions[0].Length()<=index)
addChar = false;
else
{
ch = m_completions[0][index];
for(size_t i=0;i<m_completions.GetCount();i++)
if((m_completions[i].Length()<index + 1)||(m_completions[i][index]!=ch))
addChar = false;
}
if(addChar)
{
index++;
word += ch;
}
}
while(addChar);
m_editor->ReplaceSelection(m_editor->GetSelectionString(),word,true);
}
break;
case WXK_RETURN:
case WXK_RIGHT:
case WXK_NUMPAD_ENTER:
{
int selection = m_autocompletions->GetSelection();
if(selection<0)
selection = 0;
if(m_completions.GetCount()>0)
m_editor->ReplaceSelection(
m_editor->GetSelectionString(),
m_completions[selection]
);
this->GetParent()->GetParent()->Refresh();
if(!m_editor->IsActive())
m_editor->ActivateCell();
Dismiss();
}
break;
case WXK_LEFT:
case WXK_ESCAPE:
this->GetParent()->GetParent()->Refresh();
if(!m_editor->IsActive())
m_editor->ActivateCell();
Dismiss();
break;
case WXK_UP:
{
int selection = m_autocompletions->GetSelection();
if(selection > 0)
m_autocompletions->SetSelection(selection-1);
else
{
if(m_completions.GetCount()>0)
m_autocompletions->SetSelection(0);
}
break;
}
case WXK_DOWN:
{
int selection = m_autocompletions->GetSelection();
if(selection<0) selection = 0;
selection++;
if(selection >= m_completions.GetCount())
selection--;
if(m_completions.GetCount()>0)
m_autocompletions->SetSelection(selection);
break;
}
case WXK_BACK:
{
wxString oldString=m_editor->GetSelectionString();
if(oldString!=wxEmptyString)
{
m_editor->ReplaceSelection(
oldString,
oldString.Left(oldString.Length()-1),
true
);
UpdateResults();
}
else
this->GetParent()->GetParent()->Refresh();
if(!m_editor->IsActive())
m_editor->ActivateCell();
Dismiss();
break;
}
default:
{
if((wxIsalpha(key))||(key==wxT('_')))
{
wxString oldString=m_editor->GetSelectionString();
m_editor->ReplaceSelection(
oldString,
oldString+wxString(key),
true
);
UpdateResults();
}
else if(wxIsprint(key))
{
int selection = m_autocompletions->GetSelection();
if(selection<0)
selection = 0;
m_editor->ReplaceSelection(
m_editor->GetSelectionString(),
m_completions[selection]+key
);
this->GetParent()->GetParent()->Refresh();
if(!m_editor->IsActive())
m_editor->ActivateCell();
Dismiss();
} else
event.Skip();
}
}
this->GetParent()->GetParent()->Refresh();
}
void PythonCodeCtrl::OnUserInput(wxKeyEvent& ke)
{
Manager::Get()->GetLogManager()->Log(_T("Key event"));
if(ke.GetModifiers()==wxMOD_CONTROL)
{
// wxMessageBox(_T("control pressed"));
// wxMessageBox(wxString::Format(_("Key: %i"),ke.GetKeyCode()));
if(ke.GetKeyCode()=='D')
{
m_pyctrl->DispatchCode(GetValue());
// if(m_pyctrl->DispatchCode(GetValue()))
// ChangeValue(_T(""));
return;
}
if(ke.GetKeyCode()=='K')
{
m_pyctrl->BreakCode();
return;
}
if(ke.GetKeyCode()==WXK_RETURN)
{
m_pyctrl->DispatchCode(GetValue());
return;
}
if(ke.GetKeyCode()==WXK_UP) //TODO: If the text is ever changed, set m_history_position to -1
{
if (m_history_position < 0)
m_history_working = GetValue();
m_history_position--;
if (m_history_position < -1)
m_history_position = m_history_commands.GetCount()-1;
if (m_history_position >= 0)
SetValue(m_history_commands[m_history_position]);
else
SetValue(m_history_working);
int pos = GetLastPosition();
SetSelection(pos,pos);
return;
}
if(ke.GetKeyCode()==WXK_DOWN)
{
if (m_history_position < 0)
m_history_working = GetValue();
m_history_position++;
if (m_history_position >= int(m_history_commands.GetCount()))
m_history_position = -1;
if (m_history_position >= 0)
SetValue(m_history_commands[m_history_position]);
else
SetValue(m_history_working);
int pos = GetLastPosition();
SetSelection(pos,pos);
return;
}
}
if(ke.GetModifiers()==wxMOD_NONE && ke.GetKeyCode()==WXK_RETURN)
{
wxString code = GetValue();
wxString lastline = code.AfterLast(_T('\n'));
if (!lastline.StartsWith(_T("\t")) && !lastline.StartsWith(_T("\t")) &&
!lastline.EndsWith(_T(":")))
{
long rs,re;
GetSelection(&rs,&re);
if(rs==re && this->GetLastPosition()==rs)
{
m_pyctrl->DispatchCode(code);
return;
}
}
}
ke.Skip();
}
void CFilterDialog::OnKeyEvent(wxKeyEvent& event)
{
m_shiftClick = event.ShiftDown();
event.Skip();
}
void MainFrame::OnKeyDown(wxKeyEvent& event)
{
if ( !scenesLockingShortcuts.empty() )
{
event.Skip();
return;
}
if(event.GetModifiers() == wxMOD_CMD)
{
switch(event.GetKeyCode()) {
case 'S':
{
wxCommandEvent uselessEvent;
OnMenuSaveSelected(uselessEvent);
break;
}
case 'O':
{
wxCommandEvent uselessEvent;
OnMenuOpenSelected(uselessEvent);
break;
}
case 'N':
{
wxCommandEvent uselessEvent;
OnMenuNewSelected(uselessEvent);
break;
}
case 'W':
{
wxRibbonButtonBarEvent uselessEvent;
if ( projectManager ) projectManager->OnRibbonCloseSelected(uselessEvent);
break;
}
case 'Q':
{
wxCloseEvent uselessEvent;
OnClose(uselessEvent);
break;
}
/*case 'G':
{
if ( editorsNotebook->GetSelection() == editorsNotebook->GetPageCount()-1 )
editorsNotebook->SetSelection(0);
else
editorsNotebook->SetSelection(editorsNotebook->GetSelection()+1);
break;
}*/
default:
break;
}
}
if(event.GetModifiers() == (wxMOD_CMD|wxMOD_SHIFT) )
{
switch(event.GetKeyCode()) {
case 'S':
{
wxRibbonButtonBarEvent uselessEvent;
OnRibbonSaveAllClicked(uselessEvent);
break;
}
default:
break;
}
}
else
{
switch(event.GetKeyCode())
{
case WXK_F1:
{
wxCommandEvent uselessEvent;
OnMenuAideSelected(uselessEvent);
break;
}
default:
break;
}
}
//Not a shortcut, let the event propagates.
event.Skip();
}
/* MapCanvas::onKeyDown
* Called when a key is pressed within the canvas
*******************************************************************/
void MapCanvas::onKeyDown(wxKeyEvent& e)
{
// Send to editor
context_->input().updateKeyModifiersWx(e.GetModifiers());
context_->input().keyDown(KeyBind::keyName(e.GetKeyCode()));
// Testing
if (Global::debug)
{
if (e.GetKeyCode() == WXK_F6)
{
Polygon2D poly;
sf::Clock clock;
LOG_MESSAGE(1, "Generating polygons...");
for (unsigned a = 0; a < context_->map().nSectors(); a++)
{
if (!poly.openSector(context_->map().getSector(a)))
LOG_MESSAGE(1, "Splitting failed for sector %d", a);
}
//int ms = clock.GetElapsedTime() * 1000;
//LOG_MESSAGE(1, "Polygon generation took %dms", ms);
}
if (e.GetKeyCode() == WXK_F7)
{
// Get nearest line
int nearest = context_->map().nearestLine(context_->input().mousePosMap(), 999999);
MapLine* line = context_->map().getLine(nearest);
if (line)
{
SectorBuilder sbuilder;
// Determine line side
double side = MathStuff::lineSide(context_->input().mousePosMap(), line->seg());
if (side >= 0)
sbuilder.traceSector(&(context_->map()), line, true);
else
sbuilder.traceSector(&(context_->map()), line, false);
}
}
if (e.GetKeyCode() == WXK_F5)
{
// Get nearest line
int nearest = context_->map().nearestLine(context_->input().mousePosMap(), 999999);
MapLine* line = context_->map().getLine(nearest);
// Get sectors
MapSector* sec1 = context_->map().getLineSideSector(line, true);
MapSector* sec2 = context_->map().getLineSideSector(line, false);
int i1 = -1;
int i2 = -1;
if (sec1) i1 = sec1->getIndex();
if (sec2) i2 = sec2->getIndex();
context_->addEditorMessage(S_FMT("Front %d Back %d", i1, i2));
}
if (e.GetKeyCode() == WXK_F5 && context_->editMode() == Mode::Sectors)
{
PolygonSplitter splitter;
splitter.setVerbose(true);
splitter.openSector(context_->selection().hilightedSector());
Polygon2D temp;
splitter.doSplitting(&temp);
}
}
// Update cursor in object edit mode
//if (mouse_state == Input::MouseState::ObjectEdit)
// determineObjectEditState();
#ifndef __WXMAC__
// Skipping events on OS X doesn't do anything but causes
// sound alert (a.k.a. error beep) on every key press
if (e.GetKeyCode() != WXK_UP &&
e.GetKeyCode() != WXK_DOWN &&
e.GetKeyCode() != WXK_LEFT &&
e.GetKeyCode() != WXK_RIGHT &&
e.GetKeyCode() != WXK_NUMPAD_UP &&
e.GetKeyCode() != WXK_NUMPAD_DOWN &&
e.GetKeyCode() != WXK_NUMPAD_LEFT &&
e.GetKeyCode() != WXK_NUMPAD_RIGHT)
e.Skip();
#endif // !__WXMAC__
}
void wxListCtrlEx::OnKeyDown(wxKeyEvent& event)
{
if (!m_prefixSearch_enabled)
{
event.Skip();
return;
}
int code = event.GetKeyCode();
if (code == WXK_LEFT ||
code == WXK_RIGHT ||
code == WXK_UP ||
code == WXK_DOWN ||
code == WXK_HOME ||
code == WXK_END)
{
ResetSearchPrefix();
event.Skip();
return;
}
if (event.AltDown() && !event.ControlDown()) // Alt but not AltGr
{
event.Skip();
return;
}
wxChar key;
switch (code)
{
case WXK_NUMPAD0:
case WXK_NUMPAD1:
case WXK_NUMPAD2:
case WXK_NUMPAD3:
case WXK_NUMPAD4:
case WXK_NUMPAD5:
case WXK_NUMPAD6:
case WXK_NUMPAD7:
case WXK_NUMPAD8:
case WXK_NUMPAD9:
key = '0' + code - WXK_NUMPAD0;
break;
case WXK_NUMPAD_ADD:
key = '+';
break;
case WXK_NUMPAD_SUBTRACT:
key = '-';
break;
case WXK_NUMPAD_MULTIPLY:
key = '*';
break;
case WXK_NUMPAD_DIVIDE:
key = '/';
break;
default:
key = 0;
break;
}
if (key)
{
if (event.GetModifiers())
{
// Numpad keys can not have modifiers
event.Skip();
}
HandlePrefixSearch(key);
return;
}
#if defined(__WXMSW__)
if (code >= 300 && code != WXK_NUMPAD_DECIMAL)
{
event.Skip();
return;
}
// Get the actual key
BYTE state[256];
if (!GetKeyboardState(state)) {
event.Skip();
return;
}
wxChar buffer[1];
int res = ToUnicode(event.GetRawKeyCode(), 0, state, buffer, 1, 0);
if (res != 1)
{
event.Skip();
return;
}
key = buffer[0];
if (key < 32)
{
event.Skip();
return;
}
if (key == 32 && event.HasModifiers())
{
event.Skip();
return;
}
HandlePrefixSearch(key);
return;
#else
if (code > 32 && code < 300 && !event.HasModifiers())
{
int unicodeKey = event.GetUnicodeKey();
if (unicodeKey)
code = unicodeKey;
HandlePrefixSearch(code);
}
else
event.Skip();
#endif //defined(__WXMSW__)
}
void tcNumberWidget<T>::OnChar(wxKeyEvent& event)
{
int nChar = event.GetKeyCode();
unsigned t = tcTime::Get()->Get30HzCount();
unsigned dt = t - lastKeypressTime;
bool addDigit = (keyboardWait && (dt < keyboardTimeout));
keyboardWait = true;
lastKeypressTime = t;
const int val0 = '0';
const int val9 = '9';
if (nChar == WXK_RETURN)
{
keyboardWait = false;
afterDecimalPoint = 0;
isNegative = false;
tcSound::Get()->PlayEffect("MutedBeep");
}
else if ((nChar >= val0) && (nChar <= val9))
{
if (addDigit)
{
if (afterDecimalPoint == 0)
{
val = isNegative ? (10.0f * val - (nChar - val0)) : (10.0f * val + (nChar - val0));
}
else if (pow(10.0, -double(afterDecimalPoint)) >= double(smallestIncrement))
{
T dv = T((nChar - val0)) * pow(10.0, -double(afterDecimalPoint));
val += isNegative ? -dv : dv;
afterDecimalPoint++;
}
}
else
{
val = (nChar - val0);
}
tcSound::Get()->PlayEffect("MutedBeep");
}
else if ((nChar == '-') && (minVal < 0))
{
if (!addDigit)
{
isNegative = true;
val = 0;
}
else
{
// ignore negative in middle of entry
}
}
else if ((nChar == '.') && (double(smallestIncrement) < 1.0))
{
afterDecimalPoint = 1;
}
else
{
event.Skip();
}
ApplyBounds();
}
void App::OnChar( wxKeyEvent& event )
{
// It seems like this is swallowing all events to all text fields.. disabling for now
event.Skip();
return;
#if KEYBOARD_REFACTOR
if ( !m_Frame )
{
return;
}
Helium::KeyboardInput input;
Helium::ConvertEvent( event, input );
std::string error;
if ( input.IsCtrlDown() )
{
switch( input.GetKeyCode() )
{
case KeyCodes::a: // ctrl-a
{
wxCommandEvent evt ( wxEVT_COMMAND_MENU_SELECTED, wxID_SELECTALL );
m_Frame->GetEventHandler()->ProcessEvent( evt );
event.Skip( false );
return;
}
case KeyCodes::i: // ctrl-i
{
m_Frame->InvertSelection();
event.Skip( false );
return;
}
case KeyCodes::o: // ctrl-o
{
m_Frame->OpenProjectDialog();
event.Skip( false );
return;
}
case KeyCodes::s: // ctrl-s
{
if ( !m_Frame->SaveAll( error ) )
{
wxMessageBox( error.c_str(), wxT( "Error" ), wxCENTER | wxICON_ERROR | wxOK, m_Frame );
}
event.Skip( false );
return;
}
case KeyCodes::v: // ctrl-v
{
wxCommandEvent evt ( wxEVT_COMMAND_MENU_SELECTED, wxID_PASTE );
m_Frame->GetEventHandler()->ProcessEvent( evt );
event.Skip( false );
return;
}
case KeyCodes::w: // ctrl-w
{
m_Frame->CloseProject();
event.Skip( false );
return;
}
case KeyCodes::x: // ctrl-x
{
wxCommandEvent evt ( wxEVT_COMMAND_MENU_SELECTED, wxID_CUT );
m_Frame->GetEventHandler()->ProcessEvent( evt );
event.Skip( false );
return;
}
default:
break;
}
}
#endif
}
void wxVListBoxComboPopup::OnComboKeyEvent( wxKeyEvent& event )
{
// Saturated key movement on
if ( !HandleKey(event.GetKeyCode(), true) )
event.Skip();
}
void HistoryWindow::OnChar(wxKeyEvent &event)
{
event.Skip(false);
return;
}
void wxKeyCodeCtrl::OnChar(wxKeyEvent& event)
{
wxString str;
m_Key = -1;
if(event.GetModifiers() & wxMOD_ALT)
str += wxT("Alt+");
if(event.GetModifiers() & wxMOD_CONTROL)
str += wxT("Ctrl+");
if(event.GetModifiers() & wxMOD_SHIFT)
str += wxT("Shift+");
int kode = event.GetKeyCode();
m_Flags = event.GetModifiers();
if(kode >= WXK_F1 && kode <= WXK_F12)
{
str += wxString::Format(wxT("F%d"), kode - WXK_DIVIDE );
m_Key = kode;
}
else if((kode >= (int)'A' && kode <= (int)'Z') || (kode >= (int)'0' && kode <= (int)'9') || (kode >= WXK_NUMPAD0 && kode <= WXK_NUMPAD9))
{
str += wxString(event.GetUnicodeKey());
m_Key = kode;
}
else if(kode == WXK_DELETE || kode == WXK_NUMPAD_DELETE)//del
{
str += wxString(wxT("Del"));
m_Key = kode;
}
else if(kode == WXK_ESCAPE)//esc
{
str += wxString(wxT("Esc"));
m_Key = kode;
}
else if(kode == WXK_SPACE || kode == WXK_NUMPAD_SPACE)//Space
{
str += wxString(wxT("Space"));
m_Key = kode;
}
else if(kode == WXK_RETURN || kode == WXK_EXECUTE)//enter
{
str += wxString(wxT("Enter"));
m_Key = kode;
}
else if(kode == WXK_PAUSE)//pause
{
str += wxString(wxT("Pause"));
m_Key = kode;
}
else if(kode == WXK_END || kode == WXK_NUMPAD_END)//end
{
str += wxString(wxT("End"));
m_Key = kode;
}
else if(kode == WXK_HOME || kode == WXK_NUMPAD_HOME)//home
{
str += wxString(wxT("Home"));
m_Key = kode;
}
else if(kode == WXK_INSERT || kode == WXK_NUMPAD_INSERT)//ins
{
str += wxString(wxT("Ins"));
m_Key = kode;
}
SetValue(str);
event.Skip(false);
}
