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 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 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('-'));
}
void Grid::OnKeyDown(wxKeyEvent &event)
{
switch (event.GetKeyCode())
{
case WXK_LEFT:
case WXK_RIGHT:
{
int rows = GetNumberRows();
int cols = GetNumberCols();
int crow = GetGridCursorRow();
int ccol = GetGridCursorCol();
if (event.GetKeyCode() == WXK_LEFT) {
if (crow == 0 && ccol == 0) {
// do nothing
}
else if (ccol == 0) {
SetGridCursor(crow - 1, cols - 1);
}
else {
SetGridCursor(crow, ccol - 1);
}
}
else {
if (crow == rows - 1 && ccol == cols - 1) {
// do nothing
}
else if (ccol == cols - 1) {
SetGridCursor(crow + 1, 0);
}
else {
SetGridCursor(crow, ccol + 1);
}
}
#if wxUSE_ACCESSIBILITY
// Make sure the NEW cell is made available to the screen reader
mAx->SetCurrentCell(GetGridCursorRow(), GetGridCursorCol());
#endif
}
break;
case WXK_TAB:
{
int rows = GetNumberRows();
int cols = GetNumberCols();
int crow = GetGridCursorRow();
int ccol = GetGridCursorCol();
if (event.ControlDown()) {
int flags = wxNavigationKeyEvent::FromTab |
( event.ShiftDown() ?
wxNavigationKeyEvent::IsBackward :
wxNavigationKeyEvent::IsForward );
Navigate(flags);
return;
}
else if (event.ShiftDown()) {
if (crow == 0 && ccol == 0) {
Navigate(wxNavigationKeyEvent::FromTab | wxNavigationKeyEvent::IsBackward);
return;
}
else if (ccol == 0) {
SetGridCursor(crow - 1, cols - 1);
}
else {
SetGridCursor(crow, ccol - 1);
}
}
else {
if (crow == rows - 1 && ccol == cols - 1) {
Navigate(wxNavigationKeyEvent::FromTab | wxNavigationKeyEvent::IsForward);
return;
}
else if (ccol == cols - 1) {
SetGridCursor(crow + 1, 0);
}
else {
SetGridCursor(crow, ccol + 1);
}
}
MakeCellVisible(GetGridCursorRow(), GetGridCursorCol());
#if wxUSE_ACCESSIBILITY
// Make sure the NEW cell is made available to the screen reader
mAx->SetCurrentCell(GetGridCursorRow(), GetGridCursorCol());
#endif
}
break;
case WXK_RETURN:
case WXK_NUMPAD_ENTER:
{
if (!IsCellEditControlShown()) {
wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
wxWindow *def = tlw->GetDefaultItem();
if (def && def->IsEnabled()) {
wxCommandEvent cevent(wxEVT_COMMAND_BUTTON_CLICKED,
def->GetId());
GetParent()->GetEventHandler()->ProcessEvent(cevent);
}
}
else {
wxGrid::OnKeyDown(event);
// This looks strange, but what it does is selects the cell when
// enter is pressed after editing. Without it, Jaws and Window-Eyes
// do not speak the NEW cell contents (the one below the edited one).
SetGridCursor(GetGridCursorRow(), GetGridCursorCol());
}
break;
}
default:
wxGrid::OnKeyDown(event);
break;
}
}
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
}
// kbd handling: notice that we use OnChar() and not OnKeyDown() for
// compatibility here - if we used OnKeyDown(), the programs which process
// arrows themselves in their OnChar() would never get the message and like
// this they always have the priority
void wxScrolledWindow::OnChar(wxKeyEvent& event)
{
int stx, sty, // view origin
szx, szy, // view size (total)
clix, cliy; // view size (on screen)
GetViewStart(&stx, &sty);
GetClientSize(&clix, &cliy);
GetVirtualSize(&szx, &szy);
if( m_xScrollPixelsPerLine )
{
clix /= m_xScrollPixelsPerLine;
szx /= m_xScrollPixelsPerLine;
}
else
{
clix = 0;
szx = -1;
}
if( m_yScrollPixelsPerLine )
{
cliy /= m_yScrollPixelsPerLine;
szy /= m_yScrollPixelsPerLine;
}
else
{
cliy = 0;
szy = -1;
}
int xScrollOld = GetScrollPos(wxHORIZONTAL),
yScrollOld = GetScrollPos(wxVERTICAL);
int dsty;
switch ( event.GetKeyCode() )
{
case WXK_PAGEUP:
case WXK_PRIOR:
dsty = sty - (5 * cliy / 6);
Scroll(-1, (dsty == -1) ? 0 : dsty);
break;
case WXK_PAGEDOWN:
case WXK_NEXT:
Scroll(-1, sty + (5 * cliy / 6));
break;
case WXK_HOME:
Scroll(0, event.ControlDown() ? 0 : -1);
break;
case WXK_END:
Scroll(szx - clix, event.ControlDown() ? szy - cliy : -1);
break;
case WXK_UP:
Scroll(-1, sty - 1);
break;
case WXK_DOWN:
Scroll(-1, sty + 1);
break;
case WXK_LEFT:
Scroll(stx - 1, -1);
break;
case WXK_RIGHT:
Scroll(stx + 1, -1);
break;
default:
// not for us
event.Skip();
return;
}
int xScroll = GetScrollPos(wxHORIZONTAL);
if ( xScroll != xScrollOld )
{
wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, xScroll,
wxHORIZONTAL);
event.SetEventObject(this);
GetEventHandler()->ProcessEvent(event);
}
int yScroll = GetScrollPos(wxVERTICAL);
if ( yScroll != yScrollOld )
{
wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, yScroll,
wxVERTICAL);
event.SetEventObject(this);
GetEventHandler()->ProcessEvent(event);
}
}
void
GlCanvas::OnKeyDown(wxKeyEvent & event)
{
static bool physics = true;
_setCamera();
if (0 == m_pCamera) {
return;
}
vec4 camPosition = m_pCamera->getPropfv(Camera::POSITION);
vec4 camUp = m_pCamera->getPropfv(Camera::NORMALIZED_UP_VEC);
vec4 camView = m_pCamera->getPropfv(Camera::NORMALIZED_VIEW_VEC);
// vec3& camLookAt = m_pCamera->getLookAtPoint();
if ('K' == event.GetKeyCode()) {
m_pEngine->sendKeyToEngine (event.GetKeyCode());
}
if ('M' == event.GetKeyCode()) {
EVENTMANAGER->notifyEvent("NEXT_POSE", "MainCanvas", "", NULL);
}
if ('9' >= event.GetKeyCode() && '0' <= event.GetKeyCode()) {
//m_pEngine->sendKeyToEngine (event.GetKeyCode());
Camera *aCam = RENDERMANAGER->getCamera ("MainCamera");
vec3 v;
switch (event.GetKeyCode()) {
case '1':
v.set (-14.486f * cos (DegToRad (-137.0)) - 59.256 * -sin (DegToRad (-137.0)),
13.266f,
-59.256 * cos (DegToRad(-137.0)) + -14.486f * sin (DegToRad (-137.0)));
aCam->setCamera (vec3 (-14.486f, 13.266f, -59.256f), v, vec3 (0.0f, 1.0f, 0.0f));
break;
case '2':
v.set (0.0f, 0.0f, -1.0f * cos (DegToRad (-141.4f)));
aCam->setCamera (vec3 (7.930f, 16.135f, -38.392f), v, vec3 (0.0f, 1.0f, 0.0f));
break;
case '3':
v.set (0.0f, 0.0f, -1.0f * cos (DegToRad (-81.8f)));
aCam->setCamera (vec3 (7.374f, 14.465f, -58.637f), v, vec3 (0.0f, 1.0f, 0.0f));
break;
case '4':
v.set (0.0f, 0.0f, -1.0f * cos (DegToRad (-17.0f)));
aCam->setCamera (vec3 (13.363f, 13.977f, -47.436f), v, vec3 (0.0f, 1.0f, 0.0f));
break;
case '5':
v.set (0.0f, 0.0f, -1.0f * cos (DegToRad (135.58f)));
aCam->setCamera (vec3 (-131.176f, 9.555f, 188.927f), v, vec3 (0.0f, 1.0f, 0.0f));
break;
}
}
if ('B' == event.GetKeyCode()) {
m_pEngine->sendKeyToEngine (event.GetKeyCode());
}
if ('P' == event.GetKeyCode()) {
m_pEngine->sendKeyToEngine (event.GetKeyCode());
}
float direction;
if (true == m_pCamera->isDynamic()) {
direction = VELOCITY;
}
else {
direction = NON_DYNAMIC_VELOCITY;
}
if (true == event.ShiftDown()) { // SHIFT = fast motion
direction *= 10.0f;
}
else if (true == event.ControlDown()) { // CTRL = very fast motion. note: shift has precedence over control!
direction *= 100.0f;
}
if ('S' == event.GetKeyCode()) {
if (true == m_pCamera->isDynamic()) {
vec4 vel (camView);
//vel *= 2.0f;
//vel -= m_OldCamView;
//m_OldCamView.set (vel.x, vel.y, vel.z);
vel.y = 0.0f;
vel.normalize();
vel *= -direction;
vec3 v3;
v3.set(vel.x,vel.y,vel.z);
m_pEngine->getWorld().setVelocity ("testCamera", v3);
}
else {
curitiba::event_::CameraMotion c("BACKWARD", direction);
curitiba::event_::IEventData *e= curitiba::event_::EventFactory::create("Camera Motion");
e->setData(&c);
EVENTMANAGER->notifyEvent("CAMERA_MOTION", "MainCanvas", "", e);
delete e;
}
DlgCameras::Instance()->updateInfo(m_pCamera->getName());
}
if ('W' == event.GetKeyCode()) {
if (true == m_pCamera->isDynamic()) {
vec4 vel (camView);
//vel *= 2.0f;
//vel -= m_OldCamView;
//m_OldCamView.set (camView.x, camView.y, camView.z);
vel.y = 0.0f;
vel.normalize();
vel *= direction;
vec3 v3;
v3.set(vel.x,vel.y,vel.z);
m_pEngine->getWorld().setVelocity ("testCamera", v3);
}
else {
curitiba::event_::CameraMotion c("FORWARD", direction);
curitiba::event_::IEventData *e= curitiba::event_::EventFactory::create("Camera Motion");
e->setData(&c);
EVENTMANAGER->notifyEvent("CAMERA_MOTION", "MainCanvas", "", e);
delete e;
}
DlgCameras::Instance()->updateInfo(m_pCamera->getName());
}
if ('A' == event.GetKeyCode()){
if (true == m_pCamera->isDynamic()) {
vec4 vel (camView.cross (camUp));
vel *= -direction;
vel.y = 0.0f;
vec3 v3;
v3.set(vel.x,vel.y,vel.z);
m_pEngine->getWorld().setVelocity ("testCamera", v3);
}
else {
curitiba::event_::CameraMotion c("LEFT", direction);
curitiba::event_::IEventData *e= curitiba::event_::EventFactory::create("Camera Motion");
e->setData(&c);
EVENTMANAGER->notifyEvent("CAMERA_MOTION", "MainCanvas", "", e);
delete e;
}
DlgCameras::Instance()->updateInfo(m_pCamera->getName());
}
if ('D' == event.GetKeyCode()){
if (true == m_pCamera->isDynamic()) {
vec4 vel (camView.cross (camUp));
vel *= direction;
vel.y = 0.0f;
vec3 v3;
v3.set(vel.x,vel.y,vel.z);
m_pEngine->getWorld().setVelocity ("testCamera", v3);
}
else {
curitiba::event_::CameraMotion c("RIGHT", direction);
curitiba::event_::IEventData *e= curitiba::event_::EventFactory::create("Camera Motion");
e->setData(&c);
EVENTMANAGER->notifyEvent("CAMERA_MOTION", "MainCanvas", "", e);
delete e;
}
DlgCameras::Instance()->updateInfo(m_pCamera->getName());
}
if ('Q' == event.GetKeyCode()){
if (false == m_pCamera->isDynamic()) {
curitiba::event_::CameraMotion c("UP", direction);
curitiba::event_::IEventData *e= curitiba::event_::EventFactory::create("Camera Motion");
e->setData(&c);
EVENTMANAGER->notifyEvent("CAMERA_MOTION", "MainCanvas", "", e);
delete e;
}
DlgCameras::Instance()->updateInfo(m_pCamera->getName());
}
if ('Z' == event.GetKeyCode()){
if (false == m_pCamera->isDynamic()) {
curitiba::event_::CameraMotion c("DOWN", direction);
curitiba::event_::IEventData *e= curitiba::event_::EventFactory::create("Camera Motion");
e->setData(&c);
EVENTMANAGER->notifyEvent("CAMERA_MOTION", "MainCanvas", "", e);
delete e;
}
DlgCameras::Instance()->updateInfo(m_pCamera->getName());
}
if (m_pCamera->isDynamic()){
EVENTMANAGER->notifyEvent("DYNAMIC_CAMERA", "MainCanvas", "", NULL);
}
/* if (WXK_SPACE == event.GetKeyCode()) {
if (true == m_pCamera->m_IsDynamic) {
vec3 vel (camUp);
vel *= direction * 3;
vel.x = 0.0f;
vel.z = 0.0f;
m_pEngine->getWorld().setVelocity ("MainCamera", vel);
m_WaterState = changeWaterState (m_WaterState);
}
}
*/
/* if ('N' == event.GetKeyCode()){
m_pCamera->setNearPlane (m_pCamera->getNearPlane() + 0.5f);
}
if ('M' == event.GetKeyCode()){
m_pCamera->setNearPlane (m_pCamera->getNearPlane() - 0.5f);
}
if ('F' == event.GetKeyCode()){
m_pCamera->setFarPlane (m_pCamera->getFarPlane() + 1.0f);
}
if ('G' == event.GetKeyCode()){
m_pCamera->setFarPlane (m_pCamera->getFarPlane() - 1.0f);
}
*/
if ('+' == event.GetKeyCode() || WXK_NUMPAD_ADD == event.GetKeyCode()) {
SceneObject *aObject = RENDERMANAGER->getScene ("MainScene")->getSceneObject ("pPlane1");
aObject->_getTransformPtr()->translate (0.0f, 0.5f, 0.0f);
}
if ('-' == event.GetKeyCode() || WXK_NUMPAD_SUBTRACT == event.GetKeyCode()) {
SceneObject *aObject = RENDERMANAGER->getScene ("MainScene")->getSceneObject ("pPlane1");
aObject->_getTransformPtr()->translate (0.0f, -0.5f, 0.0f);
}
curitiba::scene::Camera *cam = RENDERMANAGER->getCamera ("testCamera");
if ('L' == event.GetKeyCode()){
if (false == physics) {
m_pEngine->enablePhysics();
cam->setDynamic(true);
} else {
m_pEngine->disablePhysics();
cam->setDynamic(false);
}
physics = !physics;
}
//if ('Y' == event.GetKeyCode()){
//
// m_Stereo = !m_Stereo;
// if (true == m_Stereo) {
// m_pEngine->enableStereo();
// } else {
// m_pEngine->disableStereo();
// }
//}
#if (CURITIBA_OPENGL_VERSIONOPENGL_VERSION >= 400)
if ('C' == event.GetKeyCode()) {
for (unsigned int i = 0; i < IRenderer::MAX_COUNTERS; i++)
SLOG("%d", RENDERER->getCounter(i));
}
#endif
event.Skip();
}
/* TextEditor::onKeyDown
* Called when a key is pressed
*******************************************************************/
void TextEditor::onKeyDown(wxKeyEvent& e)
{
// Check if keypress matches any keybinds
wxArrayString binds = KeyBind::getBinds(KeyBind::asKeyPress(e.GetKeyCode(), e.GetModifiers()));
// Go through matching binds
bool handled = false;
for (unsigned a = 0; a < binds.size(); a++)
{
string name = binds[a];
// Open/update calltip
if (name == "ted_calltip")
{
updateCalltip();
handled = true;
}
// Autocomplete
else if (name == "ted_autocomplete")
{
// Get word before cursor
string word = GetTextRange(WordStartPosition(GetCurrentPos(), true), GetCurrentPos());
// If a language is loaded, bring up autocompletion list
if (language)
{
autocomp_list = language->getAutocompletionList(word);
AutoCompShow(word.size(), autocomp_list);
}
handled = true;
}
// Find/replace
else if (name == "ted_findreplace")
{
showFindReplacePanel();
handled = true;
}
// Find next
else if (name == "ted_findnext")
{
if (panel_fr && panel_fr->IsShown())
findNext(panel_fr->getFindText(), panel_fr->getFindFlags());
handled = true;
}
// Find previous
else if (name == "ted_findprev")
{
if (panel_fr && panel_fr->IsShown())
findPrev(panel_fr->getFindText(), panel_fr->getFindFlags());
handled = true;
}
// Replace next
else if (name == "ted_replacenext")
{
if (panel_fr && panel_fr->IsShown())
replaceCurrent(panel_fr->getFindText(), panel_fr->getReplaceText(), panel_fr->getFindFlags());
handled = true;
}
// Replace all
else if (name == "ted_replaceall")
{
if (panel_fr && panel_fr->IsShown())
replaceAll(panel_fr->getFindText(), panel_fr->getReplaceText(), panel_fr->getFindFlags());
handled = true;
}
// Fold all
else if (name == "ted_fold_foldall")
{
foldAll(true);
handled = true;
}
// Unfold all
else if (name == "ted_fold_unfoldall")
{
foldAll(false);
handled = true;
}
// Jump to line
else if (name == "ted_jumptoline")
{
jumpToLine();
handled = true;
}
}
// Check for esc key
if (!handled && e.GetKeyCode() == WXK_ESCAPE)
{
// Hide call tip if showing
if (call_tip->IsShown())
call_tip->Show(false);
// Hide F+R panel if showing
else if (panel_fr && panel_fr->IsShown())
showFindReplacePanel(false);
}
// Check for up/down keys while calltip with multiple arg sets is open
if (call_tip->IsShown() && ct_function && ct_function->nArgSets() > 1 && !ct_dwell)
{
if (e.GetKeyCode() == WXK_UP)
{
call_tip->prevArgSet();
handled = true;
}
else if (e.GetKeyCode() == WXK_DOWN)
{
call_tip->nextArgSet();
handled = true;
}
}
#ifdef __WXMSW__
Colourise(GetCurrentPos(), GetLineEndPosition(GetCurrentLine()));
#endif
#ifdef __APPLE__
if (!handled) {
const int keyCode = e.GetKeyCode();
const bool shiftDown = e.ShiftDown();
if (e.ControlDown()) {
if (WXK_LEFT == keyCode) {
if (shiftDown) {
HomeExtend();
}
else {
Home();
}
handled = true;
}
else if (WXK_RIGHT == keyCode) {
if (shiftDown) {
LineEndExtend();
}
else {
LineEnd();
}
handled = true;
}
else if (WXK_UP == keyCode) {
if (shiftDown) {
DocumentStartExtend();
}
else {
DocumentStart();
}
handled = true;
}
else if (WXK_DOWN == keyCode) {
if (shiftDown) {
DocumentEndExtend();
}
else {
DocumentEnd();
}
handled = true;
}
}
else if (e.RawControlDown()) {
if (WXK_LEFT == keyCode) {
if (shiftDown) {
WordLeftExtend();
}
else {
WordLeft();
}
handled = true;
}
else if (WXK_RIGHT == keyCode) {
if (shiftDown) {
WordRightExtend();
}
else {
WordRight();
}
handled = true;
}
}
}
#endif // __APPLE__
if (!handled)
e.Skip();
}
void BetProcedureFrame::OnKeyEvent(wxKeyEvent& event) {
int code = event.GetKeyCode();
bool special = false;
//set focus
if (code == 'v' || code == 'V') {
m_txtVoltage->SetFocus();
special = true;
}
if (code == 'd' || code == 'D') {
m_txtDuration->SetFocus();
special = true;
}
if (code == 'c' || code == 'C') {
m_txtCurrent->SetFocus();
special = true;
}
//switches
if (code >= 0x154 && code <= 0x159 && state_ == STATE_INITIAL) {
DoSwitchChange(code - 0x154); //0...5
special = true;
}
//currents limit
if (code >= 0x31 && code <= 0x36 && event.ControlDown()) {
int cur = code - 0x31;
switch (cur) {
case 0:
m_txtLimitCur1->SetFocus();
break;
case 1:
m_txtLimitCur2->SetFocus();
break;
case 2:
m_txtLimitCur3->SetFocus();
break;
case 3:
m_txtLimitCur4->SetFocus();
break;
case 4:
m_txtLimitCur5->SetFocus();
break;
case 5:
m_txtLimitCur6->SetFocus();
break;
}
special = true;
}
//start procedure
if (code == 's' || code == 'S') {
if (state_ == STATE_INITIAL && validate())
DoStart();
if (state_ == STATE_RUNNING)
DoGoInFinishing();
special = true;
}
//increase values
if ((code == 0x184 || code == 0x3d) && state_ == STATE_RUNNING) { //'+'
wxWindow* focusWnd = wxWindow::FindFocus();
if (focusWnd == m_txtVoltage) {
float value = std::atof(m_txtVoltage->GetValue()) + VOLTAGE_LOW_INCREMENT;
if (value > VOLTAGE_LIMIT)
value = VOLTAGE_LIMIT;
DoUpdateVoltage(value);
}
if (focusWnd == m_txtCurrent) {
int value = std::atoi(m_txtCurrent->GetValue()) + CURRENT_INCREMENT;
if (value > CURRENT_LIMIT)
value = CURRENT_LIMIT;
DoUpdateCurrent(value);
}
if (focusWnd == m_txtDuration) {
int value = std::atoi(m_txtDuration->GetValue()) * 60 + DURATION_INCREMENT;
if (value > DURATION_LIMIT)
value = DURATION_LIMIT;
DoUpdateDuration(value);
}
special = true;
}
//decrease values
if ((code == 0x2d) && state_ == STATE_RUNNING) { //'-'
wxWindow* focusWnd = wxWindow::FindFocus();
if (focusWnd == m_txtVoltage) {
float value = std::atof(m_txtVoltage->GetValue()) - VOLTAGE_LOW_DECREMENT;
if (value < 0)
value = 0;
DoUpdateVoltage(value);
}
if (focusWnd == m_txtCurrent) {
int value = std::atoi(m_txtCurrent->GetValue()) - CURRENT_DECREMENT;
if (value < 0)
value = 0;
DoUpdateCurrent(value);
}
if (focusWnd == m_txtDuration) {
int value = std::atoi(m_txtDuration->GetValue()) * 60 - DURATION_DECREMENT;
if (value < 0)
value = 0;
DoUpdateDuration(value);
}
special = true;
}
if ((code == 'P' || code == 'p') && state_ == STATE_INITIAL) {
DoPolarityChange();
special = true;
}
if ((code == 'E' || code == 'e') && state_ != STATE_INITIAL) {
DoTerminate();
special = true;
}
if (state_ != STATE_INITIAL)
special = true;
event.Skip(special);
}
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 ProsodyDisplay::OnKey(wxKeyEvent& event)
{//========================================
PHONEME_LIST *p;
int display=1;
if(selected_ph < 0)
selected_ph = 0;
p = &phlist[selected_ph];
switch(event.GetKeyCode())
{
case WXK_F2:
// make and play from this clause
MakeWave2(phlist,numph);
break;
case WXK_LEFT:
if(selected_ph > 1)
selected_ph--;
break;
case WXK_RIGHT:
if(selected_ph < (numph-2))
selected_ph++;
break;
case WXK_UP:
if(event.ControlDown())
ChangePh(-1,2);
else
ChangePh(1,0);
display = 1;
break;
case WXK_DOWN:
if(event.ControlDown())
ChangePh(1,-2);
else
ChangePh(-1,0);
break;
case ',':
case '<':
if(p->length > 0)
p->length--;
break;
case '.':
case '>':
p->length++;
break;
case WXK_TAB:
display = 0;
event.Skip();
transldlg->SetFocus();
break;
default:
display = 0;
event.Skip();
break;
}
if(display)
{
Refresh();
SelectPh(selected_ph);
}
} // end of ProsodyDisplay::OnKey
void wxListBox::OnChar(wxKeyEvent& event)
{
if ( event.GetKeyCode() == WXK_RETURN || event.GetKeyCode() == WXK_NUMPAD_ENTER)
{
wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
if ( tlw && tlw->GetDefaultItem() )
{
wxButton *def = wxDynamicCast(tlw->GetDefaultItem(), wxButton);
if ( def && def->IsEnabled() )
{
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
event.SetEventObject(def);
def->Command(event);
return ;
}
}
event.Skip() ;
}
/* generate wxID_CANCEL if command-. or <esc> has been pressed (typically in dialogs) */
else if (event.GetKeyCode() == WXK_ESCAPE || (event.GetKeyCode() == '.' && event.MetaDown() ) )
{
// FIXME: look in ancestors, not just parent.
wxWindow* win = GetParent()->FindWindow( wxID_CANCEL ) ;
if (win)
{
wxCommandEvent new_event(wxEVT_COMMAND_BUTTON_CLICKED,wxID_CANCEL);
new_event.SetEventObject( win );
win->GetEventHandler()->ProcessEvent( new_event );
}
}
else if ( event.GetKeyCode() == WXK_TAB )
{
wxNavigationKeyEvent new_event;
new_event.SetEventObject( this );
new_event.SetDirection( !event.ShiftDown() );
/* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
new_event.SetWindowChange( event.ControlDown() );
new_event.SetCurrentFocus( this );
if ( !GetEventHandler()->ProcessEvent( new_event ) )
event.Skip() ;
}
else if ( event.GetKeyCode() == WXK_DOWN || event.GetKeyCode() == WXK_UP )
{
// perform the default key handling first
wxControl::OnKeyDown( event ) ;
wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, m_windowId);
event.SetEventObject( this );
wxArrayInt aSelections;
int n, count = GetSelections(aSelections);
if ( count > 0 )
{
n = aSelections[0];
if ( HasClientObjectData() )
event.SetClientObject( GetClientObject(n) );
else if ( HasClientUntypedData() )
event.SetClientData( GetClientData(n) );
event.SetString(GetString(n));
}
else
{
n = -1;
}
event.SetInt(n);
GetEventHandler()->ProcessEvent(event);
}
else
{
if ( event.GetTimestamp() > m_lastTypeIn + 60 )
{
m_typeIn = wxEmptyString ;
}
m_lastTypeIn = event.GetTimestamp() ;
m_typeIn += (char) event.GetKeyCode() ;
int line = FindString(wxT("*")+m_typeIn+wxT("*")) ;
if ( line >= 0 )
{
if ( GetSelection() != line )
{
SetSelection(line) ;
wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, m_windowId);
event.SetEventObject( this );
if ( HasClientObjectData() )
event.SetClientObject( GetClientObject( line ) );
else if ( HasClientUntypedData() )
event.SetClientData( GetClientData(line) );
event.SetString(GetString(line));
event.SetInt(line);
GetEventHandler()->ProcessEvent(event);
}
}
}
}
void FrequencyDialog::OnChar(wxKeyEvent& event) {
int c = event.GetKeyCode();
long long freq;
std::string lastDemodType = activeDemod?activeDemod->getDemodulatorType():wxGetApp().getDemodMgr().getLastDemodulatorType();
switch (c) {
case WXK_RETURN:
case WXK_NUMPAD_ENTER:
// Do Stuff
freq = strToFrequency(dialogText->GetValue().ToStdString());
if (targetMode == FDIALOG_TARGET_DEFAULT) {
if (activeDemod) {
activeDemod->setTracking(true);
activeDemod->setFollow(true);
activeDemod->setFrequency(freq);
activeDemod->updateLabel(freq);
} else {
wxGetApp().setFrequency(freq);
}
}
if (targetMode == FDIALOG_TARGET_BANDWIDTH) {
if (lastDemodType == "USB" || lastDemodType == "LSB") {
freq *= 2;
}
if (activeDemod) {
activeDemod->setBandwidth(freq);
} else {
wxGetApp().getDemodMgr().setLastBandwidth(freq);
}
}
Close();
break;
case WXK_ESCAPE:
Close();
break;
}
std::string allowed("0123456789.MKGHZmkghz");
if (allowed.find_first_of(c) != std::string::npos || c == WXK_DELETE || c == WXK_BACK || c == WXK_NUMPAD_DECIMAL
|| (c >= WXK_NUMPAD0 && c <= WXK_NUMPAD9)) {
#ifdef __linux__
dialogText->OnChar(event);
event.Skip();
#else
event.DoAllowNextEvent();
#endif
} else if (event.ControlDown() && c == 'V') {
// Alter clipboard contents to remove unwanted chars
wxTheClipboard->Open();
wxTextDataObject data;
wxTheClipboard->GetData(data);
std::string clipText = data.GetText().ToStdString();
std::string pasteText = filterChars(clipText, std::string(allowed));
wxTheClipboard->SetData(new wxTextDataObject(pasteText));
wxTheClipboard->Close();
event.Skip();
} else if (c == WXK_RIGHT || c == WXK_LEFT || event.ControlDown()) {
event.Skip();
}
}
void OnCompletionBox::OnKeyEvent(wxKeyEvent& event)
{
const int keyCode = event.GetKeyCode();
switch (keyCode)
{
case WXK_DELETE:
case WXK_NUMPAD_DELETE:
{
//try to delete the currently selected config history item
int pos = this->GetCurrentSelection();
if (0 <= pos && pos < static_cast<int>(this->GetCount()) &&
//what a mess...:
(GetValue() != GetString(pos) || //avoid problems when a character shall be deleted instead of list item
GetValue().empty())) //exception: always allow removing empty entry
{
const auto selValue = utfCvrtTo<Zstring>(GetString(pos));
if (std::find(history_.begin(), history_.end(), selValue) != history_.end()) //only history elements may be deleted
{
//save old (selected) value: deletion seems to have influence on this
const wxString currentVal = this->GetValue();
//this->SetSelection(wxNOT_FOUND);
//delete selected row
erase_if(history_, [&](const Zstring& item) { return item == selValue; });
SetString(pos, wxString()); //in contrast to Delete(), this one does not kill the drop-down list and gives a nice visual feedback!
//Delete(pos);
//(re-)set value
SetValue(currentVal);
}
return; //eat up key event
}
}
break;
case WXK_UP:
case WXK_NUMPAD_UP:
case WXK_DOWN:
case WXK_NUMPAD_DOWN:
case WXK_PAGEUP:
case WXK_NUMPAD_PAGEUP:
case WXK_PAGEDOWN:
case WXK_NUMPAD_PAGEDOWN:
return; //swallow -> using these keys gives a weird effect due to this weird control
}
#ifdef ZEN_MAC
//copy/paste is broken on wxCocoa: http://trac.wxwidgets.org/ticket/14953 => implement manually:
assert(CanCopy() && CanPaste() && CanCut());
if (event.ControlDown())
switch (keyCode)
{
case 'C': //Command + C
Copy();
return;
case 'V': //Command + V
Paste();
return;
case 'X': //Command + X
Cut();
return;
}
#endif
event.Skip();
}
/* TextEditor::onKeyDown
* Called when a key is pressed
*******************************************************************/
void TextEditor::onKeyDown(wxKeyEvent& e)
{
// Check if keypress matches any keybinds
wxArrayString binds = KeyBind::getBinds(KeyBind::asKeyPress(e.GetKeyCode(), e.GetModifiers()));
// Go through matching binds
bool handled = false;
for (unsigned a = 0; a < binds.size(); a++)
{
string name = binds[a];
// Open/update calltip
if (name == "ted_calltip")
{
updateCalltip();
handled = true;
}
// Autocomplete
else if (name == "ted_autocomplete")
{
// Get word before cursor
string word = GetTextRange(WordStartPosition(GetCurrentPos(), true), GetCurrentPos());
// If a language is loaded, bring up autocompletion list
if (language)
{
autocomp_list = language->getAutocompletionList(word);
AutoCompShow(word.size(), autocomp_list);
}
handled = true;
}
// Find/replace
else if (name == "ted_findreplace")
{
showFindReplaceDialog();
handled = true;
}
// Find next
else if (name == "ted_findnext")
{
wxCommandEvent e;
onFRDBtnFindNext(e);
handled = true;
}
// Jump to
else if (name == "ted_jumpto")
{
openJumpToDialog();
handled = true;
}
}
#ifdef __WXMSW__
Colourise(GetCurrentPos(), GetLineEndPosition(GetCurrentLine()));
#endif
#ifdef __APPLE__
if (!handled) {
const int keyCode = e.GetKeyCode();
const bool shiftDown = e.ShiftDown();
if (e.ControlDown()) {
if (WXK_LEFT == keyCode) {
if (shiftDown) {
HomeExtend();
}
else {
Home();
}
handled = true;
}
else if (WXK_RIGHT == keyCode) {
if (shiftDown) {
LineEndExtend();
}
else {
LineEnd();
}
handled = true;
}
else if (WXK_UP == keyCode) {
if (shiftDown) {
DocumentStartExtend();
}
else {
DocumentStart();
}
handled = true;
}
else if (WXK_DOWN == keyCode) {
if (shiftDown) {
DocumentEndExtend();
}
else {
DocumentEnd();
}
handled = true;
}
}
else if (e.RawControlDown()) {
if (WXK_LEFT == keyCode) {
if (shiftDown) {
WordLeftExtend();
}
else {
WordLeft();
}
handled = true;
}
else if (WXK_RIGHT == keyCode) {
if (shiftDown) {
WordRightExtend();
}
else {
WordRight();
}
handled = true;
}
}
}
#endif // __APPLE__
if (!handled)
e.Skip();
}
void CMuleListCtrl::OnChar(wxKeyEvent& evt)
{
int key = evt.GetKeyCode();
if (key == 0) {
// We prefer GetKeyCode() to GetUnicodeKey(), in order to work
// around a bug in the GetUnicodeKey(), that causes values to
// be returned untranslated. This means for instance, that if
// shift and '1' is pressed, the result is '1' rather than '!'
// (as it should be on my keyboard). This has been reported:
// http://sourceforge.net/tracker/index.php?func=detail&aid=1864810&group_id=9863&atid=109863
key = evt.GetUnicodeKey();
} else if (key >= WXK_START) {
// wxKeycodes are ignored, as they signify events such as the 'home'
// button. Unicoded chars are not checked as there is an overlap valid
// chars and the wx keycodes.
evt.Skip();
return;
}
// We wish to avoid handling shortcuts, with the exception of 'select-all'.
if (evt.AltDown() || evt.ControlDown() || evt.MetaDown()) {
if (evt.CmdDown() && (evt.GetKeyCode() == 0x01)) {
// Ctrl+a (Command+a on Mac) was pressed, select all items
for (int i = 0; i < GetItemCount(); ++i) {
SetItemState(i, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
}
}
evt.Skip();
return;
} else if (m_tts_time + 1500u < GetTickCount()) {
m_tts_text.Clear();
}
m_tts_time = GetTickCount();
m_tts_text.Append(wxTolower(key));
// May happen if the subclass does not forward deletion events.
// Or rather when single-char-repeated (see below) wraps around, so don't assert.
if (m_tts_item >= GetItemCount()) {
m_tts_item = -1;
}
unsigned next = (m_tts_item == -1) ? 0 : m_tts_item;
for (unsigned i = 0, count = GetItemCount(); i < count; ++i) {
wxString text = GetTTSText((next + i) % count).MakeLower();
if (text.StartsWith(m_tts_text)) {
ClearSelection();
m_tts_item = (next + i) % count;
SetItemState(m_tts_item, wxLIST_STATE_FOCUSED | wxLIST_STATE_SELECTED,
wxLIST_STATE_FOCUSED | wxLIST_STATE_SELECTED);
EnsureVisible(m_tts_item);
return;
}
}
if (m_tts_item != -1) {
// Crop the string so that it matches the old item (avoid typos).
wxString text = GetTTSText(m_tts_item).MakeLower();
// If the last key didn't result in a hit, then we skip the event.
if (!text.StartsWith(m_tts_text)) {
if ((m_tts_text.Length() == 2) && (m_tts_text[0] == m_tts_text[1])) {
// Special case, single-char, repeated. This allows toggeling
// between items starting with a specific letter.
m_tts_text.Clear();
// Increment, so the next will be selected (or wrap around).
m_tts_item++;
OnChar(evt);
} else {
m_tts_text.RemoveLast();
evt.Skip(true);
}
}
} else {
evt.Skip(true);
}
}
void wxWindow::OnKeyDown(wxKeyEvent& event)
{
#if wxUSE_MENUS
int key = event.GetKeyCode();
if ( !event.ControlDown() && (key == WXK_ALT || key == WXK_F10) )
{
ms_winLastAltPress = this;
// it can't be an accel anyhow
return;
}
ms_winLastAltPress = NULL;
#endif // wxUSE_MENUS
#if wxUSE_ACCEL
for ( wxWindow *win = this; win; win = win->GetParent() )
{
int command = win->GetAcceleratorTable()->GetCommand(event);
if ( command != -1 )
{
wxCommandEvent eventCmd(wxEVT_COMMAND_MENU_SELECTED, command);
if ( win->GetEventHandler()->ProcessEvent(eventCmd) )
{
// skip "event.Skip()" below
return;
}
}
if ( win->IsTopLevel() )
{
// try the frame menu bar
#if wxUSE_MENUS
wxFrame *frame = wxDynamicCast(win, wxFrame);
if ( frame )
{
wxMenuBar *menubar = frame->GetMenuBar();
if ( menubar && menubar->ProcessAccelEvent(event) )
{
// skip "event.Skip()" below
return;
}
}
#endif // wxUSE_MENUS
#if wxUSE_BUTTON
// if it wasn't in a menu, try to find a button
if ( command != -1 )
{
wxWindow* child = win->FindWindow(command);
if ( child && wxDynamicCast(child, wxButton) )
{
wxCommandEvent eventCmd(wxEVT_COMMAND_BUTTON_CLICKED, command);
eventCmd.SetEventObject(child);
if ( child->GetEventHandler()->ProcessEvent(eventCmd) )
{
// skip "event.Skip()" below
return;
}
}
}
#endif // wxUSE_BUTTON
// don't propagate accels from the child frame to the parent one
break;
}
}
#endif // wxUSE_ACCEL
event.Skip();
}
void HOTKEY_LIST_CTRL::OnChar( wxKeyEvent& aEvent )
{
if( m_curEditingRow != -1 )
{
long key = aEvent.GetKeyCode();
switch( key )
{
case WXK_ESCAPE:
// Remove selection
DeselectRow( m_curEditingRow );
m_curEditingRow = -1;
break;
default:
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;
// See if this key code is handled in hotkeys names list
bool exists;
KeyNameFromKeyCode( key, &exists );
if( exists && m_hotkeys[m_curEditingRow]->m_KeyCode != key )
{
bool canUpdate = ((HOTKEY_SECTION_PAGE *)m_parent)->GetDialog()->CanSetKey( key, m_sectionTag );
if( canUpdate )
{
m_hotkeys[m_curEditingRow]->m_KeyCode = key;
recalculateColumns();
}
// Remove selection
DeselectRow( m_curEditingRow );
m_curEditingRow = -1;
}
}
}
RefreshItems(0,m_hotkeys.size()-1);
}
void SpectDisplay::OnKey(wxKeyEvent& event)
{//====================================
int key;
int display=0; // 1=change one peak 2=one frame, 3=all
int direction=0;
int x_inc;
int y_inc;
int i;
int field=0xff;
int keyfr;
int control;
int number;
double value;
SpectFrame *sf;
peak_t *pk;
// static short pk_inc1[N_PEAKS] = {2,2,2,5,5,5,5,5,5};
static short pk_inc1[N_PEAKS] = {4,4,4,8,8,8,8,8,8};
static short pk_inc2[N_PEAKS] = {8,8,20,20,20,20,25,25,25};
sf = spectseq->frames[sframe];
pk = &sf->peaks[pk_num];
key = event.GetKeyCode();
control = event.ControlDown();
if(control && isalnum(key)) key |= 0x1000;
if(event.ShiftDown())
{
x_inc = pk_inc1[pk_num];
y_inc = 0x40;
}
else
{
x_inc = pk_inc2[pk_num];
y_inc = 0x100;
}
switch(key)
{
case WXK_NEXT:
if(sframe < spectseq->numframes-1)
{
formantdlg->GetValues(spectseq, sframe);
spectseq->SelectAll(0);
sframe++;
spectseq->frames[sframe]->selected = 1;
display = 3;
}
break;
case WXK_PRIOR:
if(sframe > 0)
{
formantdlg->GetValues(spectseq, sframe);
spectseq->SelectAll(0);
sframe--;
spectseq->frames[sframe]->selected = 1;
display = 3;
}
break;
case 'Z':
if(pk_num > 0)
{
pk_num--;
display = 2;
}
break;
case 'X':
if(pk_num < N_PEAKS-1)
{
pk_num++;
display = 2;
}
break;
case WXK_RIGHT:
pk->pkfreq = pk->pkfreq - (pk->pkfreq % x_inc) + x_inc;
if(pk->pkfreq >= MAX_DISPLAY_FREQ)
pk->pkfreq = MAX_DISPLAY_FREQ;
display = 1;
direction = 1;
field = 1;
break;
case WXK_LEFT:
pk->pkfreq = pk->pkfreq - (pk->pkfreq % x_inc) - x_inc;
if(pk->pkfreq < 50)
pk->pkfreq = 50;
display = 1;
direction = -1;
field = 1;
break;
case WXK_UP:
pk->pkheight = pk->pkheight - (pk->pkheight % y_inc) + y_inc;
if(pk->pkheight >= 0x7fff)
pk->pkheight = 0x7fff;
display = 1;
field = 2;
SetKeyframe(sf,1);
break;
case WXK_DOWN:
pk->pkheight = pk->pkheight - (pk->pkheight % y_inc) - y_inc;
if(pk->pkheight <= 0)
{
pk->pkheight = 0;
keyfr = 0; // but only if all the other peaks are zero
for(i=0; i<N_PEAKS; i++)
{
if(sf->peaks[i].pkheight > 0)
keyfr = 1;
}
SetKeyframe(sf,keyfr);
}
display = 1;
field = 2;
break;
case ',': // width--
if(event.ControlDown())
{
// CTRL, rotate, make right slope steeper
if(pk_num < 3)
{
pk->pkright-= 5;
pk->pkwidth += 5;
}
}
else
{
pk->pkright -= 10;
pk->pkwidth -= 10;
if(pk->pkright < 0)
pk->pkright = 0;
if(pk->pkwidth < 0)
pk->pkwidth = 0;
}
field = 4;
display = 1;
break;
case '.': // width++
if(event.ControlDown())
{
// CTRL: rotate, make left slope steeper
if(pk_num < 3)
{
pk->pkright += 5;
pk->pkwidth -= 5;
}
}
else
{
pk->pkright += 10;
pk->pkwidth += 10;
}
field = 4;
display = 1;
break;
case '<': // width--
pk->pkright -= 2;
pk->pkwidth -= 2;
if(pk->pkwidth < 0)
pk->pkwidth = 0;
display = 1;
field = 4;
break;
case '>': // width++
pk->pkright += 2;
pk->pkwidth += 2;
display = 1;
field = 4;
break;
case '[': // width--
pk->pkright -= 1;
if(pk->pkright < 0)
pk->pkright = 0;
display = 1;
field = 4;
break;
case ']': // width++
pk->pkright += 1;
display = 1;
field = 4;
break;
case '/': // make left=right
i = pk->pkwidth + pk->pkright;
pk->pkwidth = pk->pkright = i/2;
display = 1;
field = 4;
break;
case 0x1041: // CTRL-A
spectseq->SelectAll(1);
Refresh();
break;
case 0x1042: // CTRL-B
// toggle bass reduction
spectseq->bass_reduction ^= 1;
Refresh();
break;
case 0x1043: // CTRL-C
spectseq->ClipboardCopy();
break;
case 0x1044: // CTRL-D
// copy peaks down from previous/next keyframe
if(event.ShiftDown())
spectseq->CopyDown(sframe,1);
else
spectseq->CopyDown(sframe,-1);
SetKeyframe(sf,1);
display = 2;
break;
case 0x1047: // CTRL-G toggle grid
spectseq->grid ^= 1;
Refresh();
break;
case 0x1049: // CTRL-I interpolate between two frames
spectseq->InterpolateAdjacent();
display = 2;
break;
case 0x104b: // CTRL-K
// spectseq->SetKlattDefaults();
// display = 3;
break;
case 0x104d: // CTRL-M
sf->ToggleMarker(1);
display = 2;
break;
case 0x104e: // CTRL-N
number = wxGetNumberFromUser(_T("Toggle Marker"),_T("Marker"),_T(""),1,0,7);
sf->ToggleMarker(number);
display = 2;
break;
case 0x104f: // CTRL-O
spectseq->ConstructVowel();
break;
case 0x1051: // CTRL-Q
if(event.ShiftDown())
spectseq->InterpolatePeaks(0); // remove interpolation
else
spectseq->InterpolatePeaks(1); // show interpolation
display = 3;
break;
case 0x1052: // CTRL-R
value = sf->GetRms(spectseq->amplitude);
break;
case 0x1053: // CTRL-S
Save(savepath);
break;
case 0x1056: // CTRL-V
if(event.ShiftDown())
{
// insert frames from the clipboard
sframe = spectseq->ClipboardInsert(sframe);
SetExtent();
display = 3;
pitchgraph->Refresh();
break;
}
// overwrite just the peaks
if(clipboard_spect == NULL)
break;
i = 0;
while((i < clipboard_spect->numframes) && ((sframe+i) < spectseq->numframes))
{
spectseq->frames[sframe+i]->CopyPeaks(clipboard_spect->frames[i]);
i++;
}
display = 3;
break;
case 0x1058: // CTRL-X
spectseq->ClipboardCopy();
spectseq->DeleteSelected();
SetExtent();
sframe = 0;
display = 3;
pitchgraph->Refresh();
break;
case 0x105a: // CTRK-Z
sf->ZeroPeaks();
SetKeyframe(sf,0);
display = 2;
break;
case WXK_F10:
sf->ApplyVoiceMods();
display = 2;
break;
case WXK_F2:
// make and play sequence
ReadDialogValues();
spectseq->MakeWave(0,spectseq->numframes-1,voicedlg->pitchenv);
break;
case WXK_F1:
// make and play selected
ReadDialogValues();
sf->MakeWaveF(0,voicedlg->pitchenv,spectseq->amplitude,spectseq->duration);
break;
case WXK_F3:
// make and play selected
ReadDialogValues();
sf->MakeWaveF(1,voicedlg->pitchenv,spectseq->amplitude,spectseq->duration);
break;
default:
if(key>='0' && key<='9')
{
i = key-'0';
if(event.ControlDown())
{
if(i==0) i=10;
PlayChild(i-1,voicedlg->pitchenv);
}
else
{
// select peak number
if((pk_num = i) >= N_PEAKS) pk_num = N_PEAKS-1;
}
display=2;
}
event.Skip();
break;
}
if(display)
{
pk_select = pk_num;
sf = spectseq->frames[sframe];
pk = &sf->peaks[pk_num];
if(pk->pkwidth < 50) pk->pkwidth = 50; // min. width
if(pk->pkright < 50) pk->pkright = 50;
// ensure minimum separation between peaks & prevent crossover
if(direction > 0)
{
for(i=pk_num+1; i<N_PEAKS; i++)
{
if(sf->peaks[i].pkfreq < sf->peaks[i-1].pkfreq + 100)
sf->peaks[i].pkfreq = sf->peaks[i-1].pkfreq + 100;
}
}
else
if(direction < 0)
{
for(i=pk_num-1; i>=0; i--)
{
if(sf->peaks[i].pkfreq > sf->peaks[i+1].pkfreq - 100)
sf->peaks[i].pkfreq = sf->peaks[i+1].pkfreq - 100;
}
}
if(display==3)
{
formantdlg->ShowFrame(spectseq,sframe,pk_num,0xff);
Refresh();
}
else
{
// only one frame needs to be redrawn
formantdlg->ShowFrame(spectseq,sframe,pk_num,field);
RefreshFrame(sframe);
}
if(sframe >= 0)
{
if(ScrollToFrame(sframe,0))
Refresh(); // shouldn't need this, but we have redraw problems
}
}
} // end of SpectDisplay::OnKey
void cbStyledTextCtrl::OnKeyDown(wxKeyEvent& event)
{
m_lastSelectedText = GetSelectedText();
bool emulateDwellStart = false;
switch ( event.GetKeyCode() )
{
case _T('I'):
{
if (event.GetModifiers() == wxMOD_ALT)
m_braceShortcutState = true;
break;
}
case WXK_TAB:
{
if (m_tabSmartJump && event.GetModifiers() == wxMOD_NONE)
{
if (!AutoCompActive() && m_bracePosition != wxSCI_INVALID_POSITION)
{
m_lastPosition = GetCurrentPos();
GotoPos(m_bracePosition);
// Need judge if it's the final brace
HighlightRightBrace();
if (!m_tabSmartJump && CallTipActive())
CallTipCancel();
return;
}
}
}
break;
case WXK_BACK:
{
if (m_tabSmartJump)
{
if (!(event.ControlDown() || event.ShiftDown() || event.AltDown()))
{
const int pos = GetCurrentPos();
const int index = s_leftBrace.Find((wxChar)GetCharAt(pos - 1));
if (index != wxNOT_FOUND && (wxChar)GetCharAt(pos) == s_rightBrace.GetChar(index))
{
CharRight();
DeleteBack();
}
}
else if (m_lastPosition != wxSCI_INVALID_POSITION && event.ControlDown())
{
GotoPos(m_lastPosition);
m_lastPosition = wxSCI_INVALID_POSITION;
return;
}
}
}
break;
case WXK_RETURN:
case WXK_NUMPAD_ENTER:
case WXK_ESCAPE:
{
if (m_tabSmartJump)
m_tabSmartJump = false;
}
break;
case WXK_CONTROL:
{
EmulateDwellStart();
emulateDwellStart = true;
}
break;
default: break;
}
if (event.ControlDown() && !emulateDwellStart)
EmulateDwellStart();
event.Skip();
}
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
}
void ContentBoxCtrol::OnKeyDown(wxKeyEvent& event)
{
// flags for DoHandleItemClick()
int flags = ItemClick_Kbd;
int current;
switch ( event.GetKeyCode() )
{
case WXK_HOME:
current = 0;
break;
case WXK_END:
current = GetRowCount() - 1;
break;
case WXK_DOWN:
if ( m_current == (int)GetRowCount() - 1 )
return;
current = m_current + 1;
break;
case WXK_UP:
if ( m_current == wxNOT_FOUND )
current = GetRowCount() - 1;
else if ( m_current != 0 )
current = m_current - 1;
else // m_current == 0
return;
break;
case WXK_PAGEDOWN:
PageDown();
current = GetVisibleRowsBegin();
break;
case WXK_PAGEUP:
if ( m_current == (int)GetVisibleRowsBegin() )
{
PageUp();
}
current = GetVisibleRowsBegin();
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;
current = m_current;
break;
#if (LENMUS_PLATFORM_WIN32 == 1)
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(); //continue processing the event
current = 0; // just to silent the stupid compiler warnings
wxUnusedVar(current);
return;
}
if ( event.ShiftDown() )
flags |= ItemClick_Shift;
if ( event.ControlDown() )
flags |= ItemClick_Ctrl;
DoHandleItemClick(current, flags);
}
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 wxVListBox::OnKeyDown(wxKeyEvent& event)
{
// flags for DoHandleItemClick()
int flags = ItemClick_Kbd;
int current;
switch ( event.GetKeyCode() )
{
case WXK_HOME:
case WXK_NUMPAD_HOME:
current = 0;
break;
case WXK_END:
case WXK_NUMPAD_END:
current = GetRowCount() - 1;
break;
case WXK_DOWN:
case WXK_NUMPAD_DOWN:
if ( m_current == (int)GetRowCount() - 1 )
return;
current = m_current + 1;
break;
case WXK_UP:
case WXK_NUMPAD_UP:
if ( m_current == wxNOT_FOUND )
current = GetRowCount() - 1;
else if ( m_current != 0 )
current = m_current - 1;
else // m_current == 0
return;
break;
case WXK_PAGEDOWN:
case WXK_NUMPAD_PAGEDOWN:
PageDown();
current = GetVisibleBegin();
break;
case WXK_PAGEUP:
case WXK_NUMPAD_PAGEUP:
if ( m_current == (int)GetVisibleBegin() )
{
PageUp();
}
current = GetVisibleBegin();
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;
current = m_current;
break;
#ifdef __WXMSW__
case WXK_TAB:
// Since we are using wxWANTS_CHARS we need to send navigation
// events for the tabs on MSW
HandleAsNavigationKey(event);
// fall through to default
#endif
default:
event.Skip();
current = 0; // just to silent the stupid compiler warnings
wxUnusedVar(current);
return;
}
if ( event.ShiftDown() )
flags |= ItemClick_Shift;
if ( event.ControlDown() )
flags |= ItemClick_Ctrl;
DoHandleItemClick(current, flags);
}
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);
}
void wxTextCtrl::OnChar(wxKeyEvent& event)
{
int key = event.GetKeyCode() ;
bool eat_key = false ;
long from, to;
if ( !IsEditable() && !event.IsKeyInCategory(WXK_CATEGORY_ARROW | WXK_CATEGORY_TAB) &&
!( key == WXK_RETURN && ( (m_windowStyle & wxTE_PROCESS_ENTER) || (m_windowStyle & wxTE_MULTILINE) ) )
// && key != WXK_PAGEUP && key != WXK_PAGEDOWN && key != WXK_HOME && key != WXK_END
)
{
// eat it
return ;
}
// Check if we have reached the max # of chars (if it is set), but still
// allow navigation and deletion
GetSelection( &from, &to );
if ( !IsMultiLine() && m_maxLength && GetValue().length() >= m_maxLength &&
!event.IsKeyInCategory(WXK_CATEGORY_ARROW | WXK_CATEGORY_TAB | WXK_CATEGORY_CUT) &&
!( key == WXK_RETURN && (m_windowStyle & wxTE_PROCESS_ENTER) ) &&
from == to )
{
// eat it, we don't want to add more than allowed # of characters
// TODO: generate EVT_TEXT_MAXLEN()
return;
}
// assume that any key not processed yet is going to modify the control
m_dirty = true;
switch ( key )
{
case WXK_RETURN:
if (m_windowStyle & wxTE_PROCESS_ENTER)
{
wxCommandEvent event(wxEVT_COMMAND_TEXT_ENTER, m_windowId);
event.SetEventObject( this );
event.SetString( GetValue() );
if ( HandleWindowEvent(event) )
return;
}
if ( !(m_windowStyle & wxTE_MULTILINE) )
{
wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
if ( tlw && tlw->GetDefaultItem() )
{
wxButton *def = wxDynamicCast(tlw->GetDefaultItem(), wxButton);
if ( def && def->IsEnabled() )
{
wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, def->GetId() );
event.SetEventObject(def);
def->Command(event);
return ;
}
}
// this will make wxWidgets eat the ENTER key so that
// we actually prevent line wrapping in a single line text control
eat_key = true;
}
break;
case WXK_TAB:
if ( !(m_windowStyle & wxTE_PROCESS_TAB))
{
int flags = 0;
if (!event.ShiftDown())
flags |= wxNavigationKeyEvent::IsForward ;
if (event.ControlDown())
flags |= wxNavigationKeyEvent::WinChange ;
Navigate(flags);
return;
}
else
{
// This is necessary (don't know why);
// otherwise the tab will not be inserted.
WriteText(wxT("\t"));
eat_key = true;
}
break;
default:
break;
}
if (!eat_key)
{
// perform keystroke handling
event.Skip(true) ;
}
// osx_cocoa sends its event upon insertText
#if wxOSX_USE_CARBON
if ( ( key >= 0x20 && key < WXK_START ) ||
( key >= WXK_NUMPAD0 && key <= WXK_DIVIDE ) ||
key == WXK_RETURN ||
key == WXK_DELETE ||
key == WXK_BACK)
{
wxCommandEvent event1(wxEVT_COMMAND_TEXT_UPDATED, m_windowId);
event1.SetEventObject( this );
wxPostEvent( GetEventHandler(), event1 );
}
#endif
}
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);
}
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 LWSlider::OnKeyEvent(wxKeyEvent & event)
{
if (mEnabled)
{
switch( event.GetKeyCode() )
{
case WXK_RIGHT:
case WXK_UP:
Increase( mScrollLine );
SendUpdate( mCurrentValue );
break;
case WXK_LEFT:
case WXK_DOWN:
Decrease( mScrollLine );
SendUpdate( mCurrentValue );
break;
case WXK_PAGEUP:
#if !wxCHECK_VERSION(2,7,0)
case WXK_PRIOR:
#endif
Increase( mScrollPage );
SendUpdate( mCurrentValue );
break;
case WXK_PAGEDOWN:
#if !wxCHECK_VERSION(2,7,0)
case WXK_NEXT:
#endif
Decrease( mScrollPage );
SendUpdate( mCurrentValue );
break;
case WXK_HOME:
SendUpdate( mMinValue );
break;
case WXK_END:
SendUpdate( mMaxValue );
break;
case WXK_TAB:
{
wxNavigationKeyEvent nevent;
nevent.SetWindowChange( event.ControlDown() );
nevent.SetDirection( !event.ShiftDown() );
nevent.SetEventObject( mParent );
nevent.SetCurrentFocus( mParent );
mParent->GetParent()->GetEventHandler()->ProcessEvent(nevent);
}
break;
case WXK_RETURN:
case WXK_NUMPAD_ENTER:
{
wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(mParent), wxTopLevelWindow);
wxWindow *def = tlw->GetDefaultItem();
if (def && def->IsEnabled()) {
wxCommandEvent cevent(wxEVT_COMMAND_BUTTON_CLICKED,
def->GetId());
mParent->GetEventHandler()->ProcessEvent(cevent);
}
}
default:
// Allow it to propagate
event.Skip();
break;
}
}
event.Skip();
}
void wxBlokus::KeyDown(wxKeyEvent &event)
{
bool updateTiles = false;
switch(event.GetKeyCode())
{
case WXK_LEFT:
if(event.ShiftDown())
{
TileRotateLeft(game->getCurrentPlayer()->getCurrentTile()->getTileData());
updateTiles = true;
break;
}
if(event.ControlDown())
{
TileFlipHorizontal(game->getCurrentPlayer()->getCurrentTile()->getTileData());
updateTiles = true;
break;
}
if(BlokusFieldPanel->getTileX() == 0)
break;
BlokusFieldPanel->setTileX(BlokusFieldPanel->getTileX()-1);
break;
case WXK_RIGHT:
if(event.ShiftDown())
{
TileRotateRight(game->getCurrentPlayer()->getCurrentTile()->getTileData());
updateTiles = true;
break;
}
if(event.ControlDown())
{
TileFlipHorizontal(game->getCurrentPlayer()->getCurrentTile()->getTileData());
updateTiles = true;
break;
}
if(BlokusFieldPanel->getTileX() == game->getField()->Width-game->getCurrentPlayer()->getCurrentTile()->getTileData()->Width)
break;
BlokusFieldPanel->setTileX(BlokusFieldPanel->getTileX()+1);
break;
case WXK_UP:
if(event.ShiftDown())
{
game->getCurrentPlayer()->setPreviousTile();
updateTiles = true;
break;
}
if(event.ControlDown())
{
TileFlipVertical(game->getCurrentPlayer()->getCurrentTile()->getTileData());
updateTiles = true;
break;
}
if(BlokusFieldPanel->getTileY() == 0)
break;
BlokusFieldPanel->setTileY(BlokusFieldPanel->getTileY()-1);
break;
case WXK_DOWN:
if(event.ShiftDown())
{
game->getCurrentPlayer()->setNextTile();
updateTiles = true;
break;
}
if(event.ControlDown())
{
TileFlipVertical(game->getCurrentPlayer()->getCurrentTile()->getTileData());
updateTiles = true;
break;
}
if(BlokusFieldPanel->getTileY() == game->getField()->Width-game->getCurrentPlayer()->getCurrentTile()->getTileData()->Height)
break;
BlokusFieldPanel->setTileY(BlokusFieldPanel->getTileY()+1);
break;
case WXK_RETURN:
game->PlaceTile(game->getCurrentPlayer()->getCurrentTile(), BlokusFieldPanel->getTileX(), BlokusFieldPanel->getTileY());
updateTiles = true;
break;
default:
break;
}
BlokusFieldPanel->Refresh();
if(updateTiles)
{
if(BlokusFieldPanel->getTileX() > game->getField()->Width-game->getCurrentPlayer()->getCurrentTile()->getTileData()->Width)
BlokusFieldPanel->setTileX(game->getField()->Width-game->getCurrentPlayer()->getCurrentTile()->getTileData()->Width);
if(BlokusFieldPanel->getTileY() > game->getField()->Width-game->getCurrentPlayer()->getCurrentTile()->getTileData()->Height)
BlokusFieldPanel->setTileY(game->getField()->Width-game->getCurrentPlayer()->getCurrentTile()->getTileData()->Height);
RefreshTilePanels();
}
}
