// Name: src/gtk/window.cpp
// Purpose: wxWindowGTK implementation
// Author: Robert Roebling
-// Id: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
KeySym keysym = gdk_event->keyval;
- wxLogTrace(TRACE_KEYS, wxT("Key %s event: keysym = %ld"),
+ wxLogTrace(TRACE_KEYS, wxT("Key %s event: keysym = %lu"),
event.GetEventType() == wxEVT_KEY_UP ? wxT("release")
: wxT("press"),
- keysym);
+ static_cast<unsigned long>(keysym));
long key_code = wxTranslateKeySymToWXKey(keysym, false /* !isChar */);
}
-struct wxGtkIMData
-{
- GtkIMContext *context;
- GdkEventKey *lastKeyEvent;
-
- wxGtkIMData()
- {
- context = gtk_im_multicontext_new();
- lastKeyEvent = NULL;
- }
- ~wxGtkIMData()
- {
- g_object_unref (context);
- }
-};
-
namespace
{
int command = ancestor->GetAcceleratorTable()->GetCommand( event );
if (command != -1)
{
- wxCommandEvent menu_event( wxEVT_COMMAND_MENU_SELECTED, command );
+ wxCommandEvent menu_event( wxEVT_MENU, command );
ret = ancestor->HandleWindowEvent( menu_event );
if ( !ret )
// if the accelerator wasn't handled as menu event, try
// it as button click (for compatibility with other
// platforms):
- wxCommandEvent button_event( wxEVT_COMMAND_BUTTON_CLICKED, command );
+ wxCommandEvent button_event( wxEVT_BUTTON, command );
ret = ancestor->HandleWindowEvent( button_event );
}
return_after_IM = true;
}
- if (!ret && win->m_imData)
+ if ( !ret )
{
- win->m_imData->lastKeyEvent = gdk_event;
+ // Indicate that IM handling is in process by setting this pointer
+ // (which will remain valid for all the code called during IM key
+ // handling).
+ win->m_imKeyEvent = gdk_event;
// We should let GTK+ IM filter key event first. According to GTK+ 2.0 API
// docs, if IM filter returns true, no further processing should be done.
// we should send the key_down event anyway.
- bool intercepted_by_IM =
- gtk_im_context_filter_keypress(win->m_imData->context, gdk_event) != 0;
- win->m_imData->lastKeyEvent = NULL;
- if (intercepted_by_IM)
+ const int intercepted_by_IM = win->GTKIMFilterKeypress(gdk_event);
+
+ win->m_imKeyEvent = NULL;
+
+ if ( intercepted_by_IM )
{
wxLogTrace(TRACE_KEYS, wxT("Key event intercepted by IM"));
return TRUE;
}
}
+int wxWindowGTK::GTKIMFilterKeypress(GdkEventKey* event) const
+{
+ return m_imContext ? gtk_im_context_filter_keypress(m_imContext, event)
+ : FALSE;
+}
+
extern "C" {
static void
gtk_wxwindow_commit_cb (GtkIMContext * WXUNUSED(context),
const gchar *str,
wxWindow *window)
+{
+ // Ignore the return value here, it doesn't matter for the "commit" signal.
+ window->GTKDoInsertTextFromIM(str);
+}
+}
+
+bool wxWindowGTK::GTKDoInsertTextFromIM(const char* str)
{
wxKeyEvent event( wxEVT_CHAR );
// take modifiers, cursor position, timestamp etc. from the last
// key_press_event that was fed into Input Method:
- if (window->m_imData->lastKeyEvent)
+ if ( m_imKeyEvent )
{
- wxFillOtherKeyEventFields(event,
- window, window->m_imData->lastKeyEvent);
+ wxFillOtherKeyEventFields(event, this, m_imKeyEvent);
}
else
{
- event.SetEventObject( window );
+ event.SetEventObject(this);
}
const wxString data(wxGTK_CONV_BACK_SYS(str));
if( data.empty() )
- return;
+ return false;
+ bool processed = false;
for( wxString::const_iterator pstr = data.begin(); pstr != data.end(); ++pstr )
{
#if wxUSE_UNICODE
AdjustCharEventKeyCodes(event);
- window->HandleWindowEvent(event);
+ if ( HandleWindowEvent(event) )
+ processed = true;
}
+
+ return processed;
}
+
+bool wxWindowGTK::GTKOnInsertText(const char* text)
+{
+ if ( !m_imKeyEvent )
+ {
+ // We're not inside IM key handling at all.
+ return false;
+ }
+
+ return GTKDoInsertTextFromIM(text);
}
// FIXME: Get these values from GTK or GDK
event.m_linesPerAction = 3;
+ event.m_columnsPerAction = 3;
event.m_wheelDelta = 120;
// Determine the scroll direction.
if (win->GTKProcessEvent(event))
return TRUE;
- GtkRange *range = win->m_scrollBar[wxWindow::ScrollDir_Vert];
+ GtkRange *range;
+ switch (gdk_event->direction)
+ {
+ case GDK_SCROLL_UP:
+ case GDK_SCROLL_DOWN:
+ range = win->m_scrollBar[wxWindow::ScrollDir_Vert];
+ break;
+
+ case GDK_SCROLL_LEFT:
+ case GDK_SCROLL_RIGHT:
+ range = win->m_scrollBar[wxWindow::ScrollDir_Horz];
+ break;
+
+ default:
+ return false;
+ }
if (range && gtk_widget_get_visible(GTK_WIDGET(range)))
{
GtkAdjustment* adj = gtk_range_get_adjustment(range);
double delta = gtk_adjustment_get_step_increment(adj) * 3;
- if (gdk_event->direction == GDK_SCROLL_UP)
+ if (gdk_event->direction == GDK_SCROLL_UP ||
+ gdk_event->direction == GDK_SCROLL_LEFT)
delta = -delta;
gtk_range_set_value(range, gtk_adjustment_get_value(adj) + delta);
if (w < 0) w = 0;
if (h < 0) h = 0;
}
+ GtkAllocation a;
+ gtk_widget_get_allocation(win->m_widget, &a);
+ // update position for widgets in native containers, such as wxToolBar
+ if (!WX_IS_PIZZA(gtk_widget_get_parent(win->m_widget)))
+ {
+ win->m_x = a.x;
+ win->m_y = a.y;
+ }
win->m_useCachedClientSize = true;
if (win->m_clientWidth != w || win->m_clientHeight != h)
{
win->m_clientHeight = h;
// this callback can be connected to m_wxwindow,
// so always get size from m_widget->allocation
- GtkAllocation a;
- gtk_widget_get_allocation(win->m_widget, &a);
win->m_width = a.width;
win->m_height = a.height;
if (!win->m_nativeSizeEvent)
GdkWindow* const window = GTKGetDrawingWindow();
- if (m_imData)
+ if (m_imContext)
{
gtk_im_context_set_client_window
(
- m_imData->context,
+ m_imContext,
window ? window
: gtk_widget_get_window(m_widget)
);
}
#endif
- GTKApplyWidgetStyle();
-
wxWindowCreateEvent event(static_cast<wxWindow*>(this));
event.SetEventObject( this );
GTKProcessEvent( event );
if (m_wxwindow)
{
- if (m_imData)
- gtk_im_context_set_client_window(m_imData->context, NULL);
+ if (m_imContext)
+ gtk_im_context_set_client_window(m_imContext, NULL);
if (IsTopLevel())
{
wxWindow *wxWindowBase::DoFindFocus()
{
+#if wxUSE_MENUS
// For compatibility with wxMSW, pretend that showing a popup menu doesn't
// change the focus and that it remains on the window showing it, even
// though the real focus does change in GTK.
extern wxMenu *wxCurrentPopupMenu;
if ( wxCurrentPopupMenu )
return wxCurrentPopupMenu->GetInvokingWindow();
+#endif // wxUSE_MENUS
wxWindowGTK *focus = gs_pendingFocus ? gs_pendingFocus : gs_currentFocus;
// the cast is necessary when we compile in wxUniversal mode
m_cursor = *wxSTANDARD_CURSOR;
- m_imData = NULL;
+ m_imContext = NULL;
+ m_imKeyEvent = NULL;
+
m_dirtyTabOrder = false;
}
// destroy children before destroying this window itself
DestroyChildren();
- if (m_widget)
- Show( false );
-
// delete before the widgets to avoid a crash on solaris
- delete m_imData;
- m_imData = NULL;
+ if ( m_imContext )
+ {
+ g_object_unref(m_imContext);
+ m_imContext = NULL;
+ }
// avoid problem with GTK+ 2.18 where a frozen window causes the whole
// TLW to be frozen, and if the window is then destroyed, nothing ever
}
// Create input method handler
- m_imData = new wxGtkIMData;
+ m_imContext = gtk_im_multicontext_new();
// Cannot handle drawing preedited text yet
- gtk_im_context_set_use_preedit( m_imData->context, FALSE );
+ gtk_im_context_set_use_preedit( m_imContext, FALSE );
- g_signal_connect (m_imData->context, "commit",
+ g_signal_connect (m_imContext, "commit",
G_CALLBACK (gtk_wxwindow_commit_cb), this);
}
if (!WX_IS_PIZZA(gtk_widget_get_parent(m_widget)) && !GTK_IS_WINDOW(m_widget))
gtk_widget_set_size_request(m_widget, m_width, m_height);
+ // apply any font or color changes made before creation
+ GTKApplyWidgetStyle();
+
InheritAttributes();
SetLayoutDirection(wxLayout_Default);
"handling focus_in event for %s(%p, %s)",
GetClassInfo()->GetClassName(), this, GetLabel());
- if (m_imData)
- gtk_im_context_focus_in(m_imData->context);
+ if (m_imContext)
+ gtk_im_context_focus_in(m_imContext);
gs_currentFocus = this;
gs_pendingFocus = NULL;
"handling focus_out event for %s(%p, %s)",
GetClassInfo()->GetClassName(), this, GetLabel());
- if (m_imData)
- gtk_im_context_focus_out(m_imData->context);
+ if (m_imContext)
+ gtk_im_context_focus_out(m_imContext);
if ( gs_currentFocus != this )
{
void wxWindowGTK::SetCanFocus(bool canFocus)
{
+ wxCHECK_RET(m_widget, "invalid window");
+
gtk_widget_set_can_focus(m_widget, canFocus);
if ( m_wxwindow && (m_widget != m_wxwindow) )
gtk_get_current_event_time()
);
+ // it is possible for gtk_menu_popup() to fail
+ if (!gtk_widget_get_visible(GTK_WIDGET(menu->m_menu)))
+ {
+ menu->m_popupShown = false;
+ return false;
+ }
+
while (menu->m_popupShown)
{
gtk_main_iteration();
// difference due to possible inexactness in floating point arithmetic
static inline bool IsScrollIncrement(double increment, double x)
{
- wxASSERT(increment > 0);
+ wxASSERT(increment >= 0);
+ if ( increment == 0. )
+ return false;
const double tolerance = 1.0 / 1024;
return fabs(increment - fabs(x)) < tolerance;
}
projects / wxWidgets.git / blobdiff