#include "wx/tooltip.h"
#include "wx/caret.h"
#include "wx/fontutil.h"
+#include "wx/scopeguard.h"
#include "wx/sysopt.h"
#include <ctype.h>
// "key_press_event" from any window
//-----------------------------------------------------------------------------
-// These are used when transforming Ctrl-alpha to ascii values 1-26
-inline bool wxIsLowerChar(int code)
-{
- return (code >= 'a' && code <= 'z' );
-}
-
-inline bool wxIsUpperChar(int code)
-{
- return (code >= 'A' && code <= 'Z' );
-}
-
-
// set WXTRACE to this to see the key event codes on the console
#define TRACE_KEYS wxT("keyevent")
namespace
{
-// Send wxEVT_CHAR_HOOK event to the parent of the window and if it wasn't
-// processed, send wxEVT_CHAR to the window itself. Return true if either of
-// them was handled.
-bool
-SendCharHookAndCharEvents(const wxKeyEvent& event, wxWindow *win)
+// Send wxEVT_CHAR_HOOK event to the parent of the window and return true only
+// if it was processed (and not skipped).
+bool SendCharHookEvent(const wxKeyEvent& event, wxWindow *win)
{
- // wxEVT_CHAR_HOOK must be sent to the top level parent window to allow it
+ // wxEVT_CHAR_HOOK must be sent to allow the parent windows (e.g. a dialog
+ // which typically closes when Esc key is pressed in any of its controls)
// to handle key events in all of its children unless the mouse is captured
// in which case we consider that the keyboard should be "captured" too.
if ( !g_captureWindow )
{
- wxWindow * const parent = wxGetTopLevelParent(win);
- if ( parent )
- {
- // We need to make a copy of the event object because it is
- // modified while it's handled, notably its WasProcessed() flag
- // is set after it had been processed once.
- wxKeyEvent eventCharHook(event);
- eventCharHook.SetEventType(wxEVT_CHAR_HOOK);
- if ( parent->HandleWindowEvent(eventCharHook) )
- return true;
- }
+ wxKeyEvent eventCharHook(wxEVT_CHAR_HOOK, event);
+ if ( win->HandleWindowEvent(eventCharHook)
+ && !event.IsNextEventAllowed() )
+ return true;
}
- // As above, make a copy of the event first.
- wxKeyEvent eventChar(event);
- eventChar.SetEventType(wxEVT_CHAR);
- return win->HandleWindowEvent(eventChar);
+ return false;
+}
+
+// Adjust wxEVT_CHAR event key code fields. This function takes care of two
+// conventions:
+// (a) Ctrl-letter key presses generate key codes in range 1..26
+// (b) Unicode key codes are same as key codes for the codes in 1..255 range
+void AdjustCharEventKeyCodes(wxKeyEvent& event)
+{
+ const int code = event.m_keyCode;
+
+ // Check for (a) above.
+ if ( event.ControlDown() )
+ {
+ // We intentionally don't use isupper/lower() here, we really need
+ // ASCII letters only as it doesn't make sense to translate any other
+ // ones into this range which has only 26 slots.
+ if ( code >= 'a' && code <= 'z' )
+ event.m_keyCode = code - 'a' + 1;
+ else if ( code >= 'A' && code <= 'Z' )
+ event.m_keyCode = code - 'A' + 1;
+
+#if wxUSE_UNICODE
+ // Adjust the Unicode equivalent in the same way too.
+ if ( event.m_keyCode != code )
+ event.m_uniChar = event.m_keyCode;
+#endif // wxUSE_UNICODE
+ }
+
+#if wxUSE_UNICODE
+ // Check for (b) from above.
+ //
+ // FIXME: Should we do it for key codes up to 255?
+ if ( !event.m_uniChar && code < WXK_DELETE )
+ event.m_uniChar = code;
+#endif // wxUSE_UNICODE
}
} // anonymous namespace
if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
{
+ // Send the CHAR_HOOK event first
+ if ( SendCharHookEvent(event, win) )
+ {
+ // Don't do anything at all with this event any more.
+ return TRUE;
+ }
+
// Emit KEY_DOWN event
ret = win->HandleWindowEvent( event );
}
if ( key_code )
{
+ wxKeyEvent eventChar(wxEVT_CHAR, event);
+
wxLogTrace(TRACE_KEYS, wxT("Char event: %ld"), key_code);
- event.m_keyCode = key_code;
+ eventChar.m_keyCode = key_code;
- // To conform to the docs we need to translate Ctrl-alpha
- // characters to values in the range 1-26.
- if ( event.ControlDown() &&
- ( wxIsLowerChar(key_code) || wxIsUpperChar(key_code) ))
- {
- if ( wxIsLowerChar(key_code) )
- event.m_keyCode = key_code - 'a' + 1;
- if ( wxIsUpperChar(key_code) )
- event.m_keyCode = key_code - 'A' + 1;
-#if wxUSE_UNICODE
- event.m_uniChar = event.m_keyCode;
-#endif
- }
+ AdjustCharEventKeyCodes(eventChar);
- ret = SendCharHookAndCharEvents(event, win);
+ ret = win->HandleWindowEvent(eventChar);
}
}
const gchar *str,
wxWindow *window)
{
- wxKeyEvent event( wxEVT_KEY_DOWN );
+ wxKeyEvent event( wxEVT_CHAR );
// take modifiers, cursor position, timestamp etc. from the last
// key_press_event that was fed into Input Method:
event.m_keyCode = (char)*pstr;
#endif // wxUSE_UNICODE
- // To conform to the docs we need to translate Ctrl-alpha
- // characters to values in the range 1-26.
- if ( event.ControlDown() &&
- ( wxIsLowerChar(*pstr) || wxIsUpperChar(*pstr) ))
- {
- if ( wxIsLowerChar(*pstr) )
- event.m_keyCode = *pstr - 'a' + 1;
- if ( wxIsUpperChar(*pstr) )
- event.m_keyCode = *pstr - 'A' + 1;
+ AdjustCharEventKeyCodes(event);
- event.m_keyCode = *pstr - 'a' + 1;
-#if wxUSE_UNICODE
- event.m_uniChar = event.m_keyCode;
-#endif
- }
-
- SendCharHookAndCharEvents(event, window);
+ window->HandleWindowEvent(event);
}
}
}
RealizeTabOrder();
}
- // Update style if the window was not yet realized when
- // SetBackgroundStyle() was called
- if (m_needsStyleChange)
- {
- SetBackgroundStyle(GetBackgroundStyle());
- m_needsStyleChange = false;
- }
-
wxWindowBase::OnInternalIdle();
}
void wxWindowGTK::Refresh(bool WXUNUSED(eraseBackground),
const wxRect *rect)
{
- if (m_widget == NULL || !gtk_widget_get_mapped(m_widget))
- return;
-
if (m_wxwindow)
{
- GdkWindow* window = gtk_widget_get_window(m_wxwindow);
- if (rect)
+ if (gtk_widget_get_mapped(m_wxwindow))
{
- GdkRectangle r = { rect->x, rect->y, rect->width, rect->height };
- if (GetLayoutDirection() == wxLayout_RightToLeft)
- r.x = gdk_window_get_width(window) - r.x - rect->width;
- gdk_window_invalidate_rect(window, &r, true);
+ GdkWindow* window = gtk_widget_get_window(m_wxwindow);
+ if (rect)
+ {
+ GdkRectangle r = { rect->x, rect->y, rect->width, rect->height };
+ if (GetLayoutDirection() == wxLayout_RightToLeft)
+ r.x = gdk_window_get_width(window) - r.x - rect->width;
+ gdk_window_invalidate_rect(window, &r, true);
+ }
+ else
+ gdk_window_invalidate_rect(window, NULL, true);
}
- else
- gdk_window_invalidate_rect(window, NULL, true);
}
- else
+ else if (m_widget)
{
- if (rect)
- gtk_widget_queue_draw_area(m_widget, rect->x, rect->y, rect->width, rect->height);
- else
- gtk_widget_queue_draw(m_widget);
+ if (gtk_widget_get_mapped(m_widget))
+ {
+ if (rect)
+ gtk_widget_queue_draw_area(m_widget, rect->x, rect->y, rect->width, rect->height);
+ else
+ gtk_widget_queue_draw(m_widget);
+ }
}
}
}
else // window not realized yet
{
- // Do in OnIdle, because the window is not yet available
+ // Do when window is realized
m_needsStyleChange = true;
}
{
wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") );
+ // For compatibility with other ports, pretend that the window showing the
+ // menu has focus while the menu is shown. This is needed because the popup
+ // menu actually steals the focus from the window it's associated it in
+ // wxGTK unlike, say, wxMSW.
+ wxWindowGTK* const oldPendingFocus = gs_pendingFocus;
+ gs_pendingFocus = this;
+ wxON_BLOCK_EXIT_SET( gs_pendingFocus, oldPendingFocus );
+
menu->UpdateUI();
wxPoint pos;
projects / wxWidgets.git / blobdiff