+ g_object_unref (context);
+ }
+};
+
+extern "C" {
+static gboolean
+gtk_window_key_press_callback( GtkWidget *widget,
+ GdkEventKey *gdk_event,
+ wxWindow *win )
+{
+ DEBUG_MAIN_THREAD
+
+ if (!win->m_hasVMT)
+ return FALSE;
+ if (g_blockEventsOnDrag)
+ return FALSE;
+
+
+ wxKeyEvent event( wxEVT_KEY_DOWN );
+ bool ret = false;
+ bool return_after_IM = false;
+
+ if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
+ {
+ // Emit KEY_DOWN event
+ ret = win->GetEventHandler()->ProcessEvent( event );
+ }
+ else
+ {
+ // Return after IM processing as we cannot do
+ // anything with it anyhow.
+ return_after_IM = true;
+ }
+
+ // 2005.01.26 modified by Hong Jen Yee (hzysoft@sina.com.tw):
+ // When we get a key_press event here, it could be originate
+ // from the current widget or its child widgets. However, only the widget
+ // with the INPUT FOCUS can generate the INITIAL key_press event. That is,
+ // if the CURRENT widget doesn't have the FOCUS at all, this event definitely
+ // originated from its child widgets and shouldn't be passed to IM context.
+ // In fact, what a GTK+ IM should do is filtering keyEvents and convert them
+ // into text input ONLY WHEN THE WIDGET HAS INPUT FOCUS. Besides, when current
+ // widgets has both IM context and input focus, the event should be filtered
+ // by gtk_im_context_filter_keypress().
+ // Then, we should, according to GTK+ 2.0 API doc, return whatever it returns.
+ if ((!ret) && (win->m_imData != NULL) && ( wxWindow::FindFocus() == win ))
+ {
+ // 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);
+ win->m_imData->lastKeyEvent = NULL;
+ if (intercepted_by_IM)
+ {
+ wxLogTrace(TRACE_KEYS, _T("Key event intercepted by IM"));
+ return TRUE;
+ }
+ }
+
+ if (return_after_IM)
+ return FALSE;
+
+#if wxUSE_ACCEL
+ if (!ret)
+ {
+ wxWindowGTK *ancestor = win;
+ while (ancestor)
+ {
+ int command = ancestor->GetAcceleratorTable()->GetCommand( event );
+ if (command != -1)
+ {
+ wxCommandEvent command_event( wxEVT_COMMAND_MENU_SELECTED, command );
+ ret = ancestor->GetEventHandler()->ProcessEvent( command_event );
+ break;
+ }
+ if (ancestor->IsTopLevel())
+ break;
+ ancestor = ancestor->GetParent();
+ }
+ }
+#endif // wxUSE_ACCEL
+
+ // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x
+ // will only be sent if it is not in an accelerator table.
+ if (!ret)
+ {
+ long key_code;
+ KeySym keysym = gdk_event->keyval;
+ // Find key code for EVT_CHAR and EVT_CHAR_HOOK events
+ key_code = wxTranslateKeySymToWXKey(keysym, true /* isChar */);
+ if ( !key_code )
+ {
+ if ( wxIsAsciiKeysym(keysym) )
+ {
+ // ASCII key
+ key_code = (unsigned char)keysym;
+ }
+ // gdk_event->string is actually deprecated
+ else if ( gdk_event->length == 1 )
+ {
+ key_code = (unsigned char)gdk_event->string[0];
+ }
+ }
+
+ if ( key_code )
+ {
+ wxLogTrace(TRACE_KEYS, _T("Char event: %ld"), key_code);
+
+ event.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
+ }
+
+ // Implement OnCharHook by checking ancestor top level windows
+ wxWindow *parent = win;
+ while (parent && !parent->IsTopLevel())
+ parent = parent->GetParent();
+ if (parent)
+ {
+ event.SetEventType( wxEVT_CHAR_HOOK );
+ ret = parent->GetEventHandler()->ProcessEvent( event );
+ }
+
+ if (!ret)
+ {
+ event.SetEventType(wxEVT_CHAR);
+ ret = win->GetEventHandler()->ProcessEvent( event );
+ }
+ }
+ }
+
+ return ret;
+}
+}
+
+extern "C" {
+static void
+gtk_wxwindow_commit_cb (GtkIMContext *context,
+ const gchar *str,
+ wxWindow *window)
+{
+ wxKeyEvent event( wxEVT_KEY_DOWN );
+
+ // take modifiers, cursor position, timestamp etc. from the last
+ // key_press_event that was fed into Input Method:
+ if (window->m_imData->lastKeyEvent)
+ {
+ wxFillOtherKeyEventFields(event,
+ window, window->m_imData->lastKeyEvent);
+ }
+
+ const wxWxCharBuffer data(wxGTK_CONV_BACK_SYS(str));
+ if( !data )
+ return;
+
+ bool ret = false;
+
+ // Implement OnCharHook by checking ancestor top level windows
+ wxWindow *parent = window;
+ while (parent && !parent->IsTopLevel())
+ parent = parent->GetParent();
+
+ for( const wxChar* pstr = data; *pstr; pstr++ )
+ {
+#if wxUSE_UNICODE
+ event.m_uniChar = *pstr;
+ // Backward compatible for ISO-8859-1
+ event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0;
+ wxLogTrace(TRACE_KEYS, _T("IM sent character '%c'"), event.m_uniChar);
+#else
+ event.m_keyCode = *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;
+
+ event.m_keyCode = *pstr - 'a' + 1;
+#if wxUSE_UNICODE
+ event.m_uniChar = event.m_keyCode;
+#endif
+ }
+
+ if (parent)
+ {
+ event.SetEventType( wxEVT_CHAR_HOOK );
+ ret = parent->GetEventHandler()->ProcessEvent( event );
+ }
+
+ if (!ret)
+ {
+ event.SetEventType(wxEVT_CHAR);
+ ret = window->GetEventHandler()->ProcessEvent( event );
+ }
+ }
+}
+}
+
+
+//-----------------------------------------------------------------------------
+// "key_release_event" from any window
+//-----------------------------------------------------------------------------
+
+extern "C" {
+static gboolean
+gtk_window_key_release_callback( GtkWidget *widget,
+ GdkEventKey *gdk_event,
+ wxWindowGTK *win )
+{
+ DEBUG_MAIN_THREAD
+
+ if (!win->m_hasVMT)
+ return FALSE;
+
+ if (g_blockEventsOnDrag)
+ return FALSE;
+
+ wxKeyEvent event( wxEVT_KEY_UP );
+ if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) )
+ {
+ // unknown key pressed, ignore (the event would be useless anyhow)
+ return FALSE;
+ }
+
+ return win->GTKProcessEvent(event);
+}
+}
+
+// ============================================================================
+// the mouse events
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// mouse event processing helpers
+// ----------------------------------------------------------------------------
+
+// init wxMouseEvent with the info from GdkEventXXX struct
+template<typename T> void InitMouseEvent(wxWindowGTK *win,
+ wxMouseEvent& event,
+ T *gdk_event)
+{
+ event.SetTimestamp( gdk_event->time );
+ event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
+ event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
+ event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
+ event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
+ event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
+ event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
+ event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
+ if (event.GetEventType() == wxEVT_MOUSEWHEEL)
+ {
+ event.m_linesPerAction = 3;
+ event.m_wheelDelta = 120;
+ if (((GdkEventButton*)gdk_event)->button == 4)
+ event.m_wheelRotation = 120;
+ else if (((GdkEventButton*)gdk_event)->button == 5)
+ event.m_wheelRotation = -120;
+ }
+
+ wxPoint pt = win->GetClientAreaOrigin();
+ event.m_x = (wxCoord)gdk_event->x - pt.x;
+ event.m_y = (wxCoord)gdk_event->y - pt.y;
+
+ if ((win->m_wxwindow) && (win->GetLayoutDirection() == wxLayout_RightToLeft))
+ {
+ // origin in the upper right corner
+ int window_width = gtk_pizza_get_rtl_offset( GTK_PIZZA(win->m_wxwindow) );
+ event.m_x = window_width - event.m_x;
+ }
+
+ event.SetEventObject( win );
+ event.SetId( win->GetId() );
+ event.SetTimestamp( gdk_event->time );
+}
+
+static void AdjustEventButtonState(wxMouseEvent& event)
+{
+ // GDK reports the old state of the button for a button press event, but
+ // for compatibility with MSW and common sense we want m_leftDown be TRUE
+ // for a LEFT_DOWN event, not FALSE, so we will invert
+ // left/right/middleDown for the corresponding click events
+
+ if ((event.GetEventType() == wxEVT_LEFT_DOWN) ||
+ (event.GetEventType() == wxEVT_LEFT_DCLICK) ||
+ (event.GetEventType() == wxEVT_LEFT_UP))
+ {
+ event.m_leftDown = !event.m_leftDown;
+ return;
+ }
+
+ if ((event.GetEventType() == wxEVT_MIDDLE_DOWN) ||
+ (event.GetEventType() == wxEVT_MIDDLE_DCLICK) ||
+ (event.GetEventType() == wxEVT_MIDDLE_UP))
+ {
+ event.m_middleDown = !event.m_middleDown;
+ return;
+ }
+
+ if ((event.GetEventType() == wxEVT_RIGHT_DOWN) ||
+ (event.GetEventType() == wxEVT_RIGHT_DCLICK) ||
+ (event.GetEventType() == wxEVT_RIGHT_UP))
+ {
+ event.m_rightDown = !event.m_rightDown;
+ return;
+ }
+}
+
+// find the window to send the mouse event too
+static
+wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y)
+{
+ wxCoord xx = x;
+ wxCoord yy = y;
+
+ if (win->m_wxwindow)
+ {
+ GtkPizza *pizza = GTK_PIZZA(win->m_wxwindow);
+ xx += gtk_pizza_get_xoffset( pizza );
+ yy += gtk_pizza_get_yoffset( pizza );
+ }
+
+ wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst();
+ while (node)
+ {
+ wxWindowGTK *child = node->GetData();
+
+ node = node->GetNext();
+ if (!child->IsShown())
+ continue;
+
+ if (child->IsTransparentForMouse())
+ {
+ // wxStaticBox is transparent in the box itself
+ int xx1 = child->m_x;
+ int yy1 = child->m_y;
+ int xx2 = child->m_x + child->m_width;
+ int yy2 = child->m_y + child->m_height;
+
+ // left
+ if (((xx >= xx1) && (xx <= xx1+10) && (yy >= yy1) && (yy <= yy2)) ||
+ // right
+ ((xx >= xx2-10) && (xx <= xx2) && (yy >= yy1) && (yy <= yy2)) ||
+ // top
+ ((xx >= xx1) && (xx <= xx2) && (yy >= yy1) && (yy <= yy1+10)) ||
+ // bottom
+ ((xx >= xx1) && (xx <= xx2) && (yy >= yy2-1) && (yy <= yy2)))
+ {
+ win = child;
+ x -= child->m_x;
+ y -= child->m_y;
+ break;
+ }
+
+ }
+ else
+ {
+ if ((child->m_wxwindow == (GtkWidget*) NULL) &&
+ (child->m_x <= xx) &&
+ (child->m_y <= yy) &&
+ (child->m_x+child->m_width >= xx) &&
+ (child->m_y+child->m_height >= yy))
+ {
+ win = child;
+ x -= child->m_x;
+ y -= child->m_y;
+ break;
+ }
+ }
+ }
+
+ return win;
+}
+
+// ----------------------------------------------------------------------------
+// common event handlers helpers
+// ----------------------------------------------------------------------------
+
+bool wxWindowGTK::GTKProcessEvent(wxEvent& event) const
+{
+ // nothing special at this level
+ return GetEventHandler()->ProcessEvent(event);
+}
+
+int wxWindowGTK::GTKCallbackCommonPrologue(GdkEventAny *event) const
+{
+ DEBUG_MAIN_THREAD
+
+ if (!m_hasVMT)
+ return FALSE;
+ if (g_blockEventsOnDrag)
+ return TRUE;
+ if (g_blockEventsOnScroll)
+ return TRUE;
+
+ if (!GTKIsOwnWindow(event->window))
+ return FALSE;
+
+ return -1;
+}
+
+// overloads for all GDK event types we use here: we need to have this as
+// GdkEventXXX can't be implicitly cast to GdkEventAny even if it, in fact,
+// derives from it in the sense that the structs have the same layout
+#define wxDEFINE_COMMON_PROLOGUE_OVERLOAD(T) \
+ static int wxGtkCallbackCommonPrologue(T *event, wxWindowGTK *win) \
+ { \
+ return win->GTKCallbackCommonPrologue((GdkEventAny *)event); \
+ }
+
+wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventButton)
+wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventMotion)
+wxDEFINE_COMMON_PROLOGUE_OVERLOAD(GdkEventCrossing)
+
+#undef wxDEFINE_COMMON_PROLOGUE_OVERLOAD
+
+#define wxCOMMON_CALLBACK_PROLOGUE(event, win) \
+ const int rc = wxGtkCallbackCommonPrologue(event, win); \
+ if ( rc != -1 ) \
+ return rc
+
+// send the wxChildFocusEvent and wxFocusEvent, common code of
+// gtk_window_focus_in_callback() and SetFocus()
+static bool DoSendFocusEvents(wxWindow *win)
+{
+ // Notify the parent keeping track of focus for the kbd navigation
+ // purposes that we got it.
+ wxChildFocusEvent eventChildFocus(win);
+ (void)win->GetEventHandler()->ProcessEvent(eventChildFocus);
+
+ wxFocusEvent eventFocus(wxEVT_SET_FOCUS, win->GetId());
+ eventFocus.SetEventObject(win);
+
+ return win->GetEventHandler()->ProcessEvent(eventFocus);
+}
+
+// all event handlers must have C linkage as they're called from GTK+ C code
+extern "C"
+{
+
+//-----------------------------------------------------------------------------
+// "button_press_event"
+//-----------------------------------------------------------------------------
+
+static gboolean
+gtk_window_button_press_callback( GtkWidget *widget,
+ GdkEventButton *gdk_event,
+ wxWindowGTK *win )
+{
+ wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
+
+ g_lastButtonNumber = gdk_event->button;
+
+ if (win->m_wxwindow && (g_focusWindow != win) && win->CanAcceptFocus())
+ {
+ gtk_widget_grab_focus( win->m_wxwindow );
+ }
+
+ // GDK sends surplus button down events
+ // before a double click event. We
+ // need to filter these out.
+ if ((gdk_event->type == GDK_BUTTON_PRESS) && (win->m_wxwindow))
+ {
+ GdkEvent *peek_event = gdk_event_peek();
+ if (peek_event)
+ {
+ if ((peek_event->type == GDK_2BUTTON_PRESS) ||
+ (peek_event->type == GDK_3BUTTON_PRESS))
+ {
+ gdk_event_free( peek_event );
+ return TRUE;
+ }
+ else
+ {
+ gdk_event_free( peek_event );
+ }
+ }
+ }
+
+ wxEventType event_type = wxEVT_NULL;
+
+ // GdkDisplay is a GTK+ 2.2.0 thing
+#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2, 2, 0)
+ if ( gdk_event->type == GDK_2BUTTON_PRESS &&
+ !gtk_check_version(2,2,0) &&
+ gdk_event->button >= 1 && gdk_event->button <= 3 )
+ {
+ // Reset GDK internal timestamp variables in order to disable GDK
+ // triple click events. GDK will then next time believe no button has
+ // been clicked just before, and send a normal button click event.
+ GdkDisplay* display = gtk_widget_get_display (widget);
+ display->button_click_time[1] = 0;
+ display->button_click_time[0] = 0;
+ }
+#endif // GTK 2+
+
+ if (gdk_event->button == 1)
+ {
+ // note that GDK generates triple click events which are not supported
+ // by wxWidgets but still have to be passed to the app as otherwise
+ // clicks would simply go missing
+ switch (gdk_event->type)
+ {
+ // we shouldn't get triple clicks at all for GTK2 because we
+ // suppress them artificially using the code above but we still
+ // should map them to something for GTK1 and not just ignore them
+ // as this would lose clicks
+ case GDK_3BUTTON_PRESS: // we could also map this to DCLICK...
+ case GDK_BUTTON_PRESS:
+ event_type = wxEVT_LEFT_DOWN;
+ break;
+
+ case GDK_2BUTTON_PRESS:
+ event_type = wxEVT_LEFT_DCLICK;
+ break;
+
+ default:
+ // just to silence gcc warnings
+ ;
+ }
+ }
+ else if (gdk_event->button == 2)
+ {
+ switch (gdk_event->type)
+ {
+ case GDK_3BUTTON_PRESS:
+ case GDK_BUTTON_PRESS:
+ event_type = wxEVT_MIDDLE_DOWN;
+ break;
+
+ case GDK_2BUTTON_PRESS:
+ event_type = wxEVT_MIDDLE_DCLICK;
+ break;
+
+ default:
+ ;
+ }
+ }
+ else if (gdk_event->button == 3)
+ {
+ switch (gdk_event->type)
+ {
+ case GDK_3BUTTON_PRESS:
+ case GDK_BUTTON_PRESS:
+ event_type = wxEVT_RIGHT_DOWN;
+ break;
+
+ case GDK_2BUTTON_PRESS:
+ event_type = wxEVT_RIGHT_DCLICK;
+ break;
+
+ default:
+ ;
+ }
+ }
+ else if (gdk_event->button == 4 || gdk_event->button == 5)
+ {
+ if (gdk_event->type == GDK_BUTTON_PRESS )
+ {
+ event_type = wxEVT_MOUSEWHEEL;
+ }
+ }
+
+ if ( event_type == wxEVT_NULL )
+ {
+ // unknown mouse button or click type
+ return FALSE;
+ }
+
+ g_lastMouseEvent = (GdkEvent*) gdk_event;
+
+ wxMouseEvent event( event_type );
+ InitMouseEvent( win, event, gdk_event );
+
+ AdjustEventButtonState(event);
+
+ // wxListBox actually gets mouse events from the item, so we need to give it
+ // a chance to correct this
+ win->FixUpMouseEvent(widget, event.m_x, event.m_y);
+
+ // find the correct window to send the event to: it may be a different one
+ // from the one which got it at GTK+ level because some controls don't have
+ // their own X window and thus cannot get any events.
+ if ( !g_captureWindow )
+ win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
+
+ // reset the event object and id in case win changed.
+ event.SetEventObject( win );
+ event.SetId( win->GetId() );
+
+ bool ret = win->GTKProcessEvent( event );
+ g_lastMouseEvent = NULL;
+ if ( ret )
+ return TRUE;
+
+ if ((event_type == wxEVT_LEFT_DOWN) && !win->IsOfStandardClass() &&
+ (g_focusWindow != win) && win->CanAcceptFocus())
+ {
+ gtk_widget_grab_focus( win->m_wxwindow );
+ }
+
+ if (event_type == wxEVT_RIGHT_DOWN)
+ {
+ // generate a "context menu" event: this is similar to right mouse
+ // click under many GUIs except that it is generated differently
+ // (right up under MSW, ctrl-click under Mac, right down here) and
+ //
+ // (a) it's a command event and so is propagated to the parent
+ // (b) under some ports it can be generated from kbd too
+ // (c) it uses screen coords (because of (a))
+ wxContextMenuEvent evtCtx(
+ wxEVT_CONTEXT_MENU,
+ win->GetId(),
+ win->ClientToScreen(event.GetPosition()));
+ evtCtx.SetEventObject(win);
+ return win->GTKProcessEvent(evtCtx);
+ }
+
+ return FALSE;
+}
+
+//-----------------------------------------------------------------------------
+// "button_release_event"
+//-----------------------------------------------------------------------------
+
+static gboolean
+gtk_window_button_release_callback( GtkWidget *widget,
+ GdkEventButton *gdk_event,
+ wxWindowGTK *win )
+{
+ wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
+
+ g_lastButtonNumber = 0;
+
+ wxEventType event_type = wxEVT_NULL;
+
+ switch (gdk_event->button)
+ {
+ case 1:
+ event_type = wxEVT_LEFT_UP;
+ break;
+
+ case 2:
+ event_type = wxEVT_MIDDLE_UP;
+ break;
+
+ case 3:
+ event_type = wxEVT_RIGHT_UP;
+ break;
+
+ default:
+ // unknown button, don't process
+ return FALSE;
+ }
+
+ g_lastMouseEvent = (GdkEvent*) gdk_event;
+
+ wxMouseEvent event( event_type );
+ InitMouseEvent( win, event, gdk_event );
+
+ AdjustEventButtonState(event);
+
+ // same wxListBox hack as above
+ win->FixUpMouseEvent(widget, event.m_x, event.m_y);
+
+ if ( !g_captureWindow )
+ win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
+
+ // reset the event object and id in case win changed.
+ event.SetEventObject( win );
+ event.SetId( win->GetId() );
+
+ bool ret = win->GTKProcessEvent(event);
+
+ g_lastMouseEvent = NULL;
+
+ return ret;
+}
+
+//-----------------------------------------------------------------------------
+// "motion_notify_event"
+//-----------------------------------------------------------------------------
+
+static gboolean
+gtk_window_motion_notify_callback( GtkWidget *widget,
+ GdkEventMotion *gdk_event,
+ wxWindowGTK *win )
+{
+ wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
+
+ if (gdk_event->is_hint)
+ {
+ int x = 0;
+ int y = 0;
+ GdkModifierType state;
+ gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
+ gdk_event->x = x;
+ gdk_event->y = y;
+ }
+
+ g_lastMouseEvent = (GdkEvent*) gdk_event;
+
+ wxMouseEvent event( wxEVT_MOTION );
+ InitMouseEvent(win, event, gdk_event);
+
+ if ( g_captureWindow )
+ {
+ // synthesise a mouse enter or leave event if needed
+ GdkWindow *winUnderMouse = gdk_window_at_pointer(NULL, NULL);
+ // This seems to be necessary and actually been added to
+ // GDK itself in version 2.0.X
+ gdk_flush();
+
+ bool hasMouse = winUnderMouse == gdk_event->window;
+ if ( hasMouse != g_captureWindowHasMouse )
+ {
+ // the mouse changed window
+ g_captureWindowHasMouse = hasMouse;
+
+ wxMouseEvent eventM(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW
+ : wxEVT_LEAVE_WINDOW);
+ InitMouseEvent(win, eventM, gdk_event);
+ eventM.SetEventObject(win);
+ win->GTKProcessEvent(eventM);
+ }
+ }
+ else // no capture
+ {
+ win = FindWindowForMouseEvent(win, event.m_x, event.m_y);
+
+ // reset the event object and id in case win changed.
+ event.SetEventObject( win );
+ event.SetId( win->GetId() );
+ }
+
+ if ( !g_captureWindow )
+ {
+ wxSetCursorEvent cevent( event.m_x, event.m_y );
+ if (win->GTKProcessEvent( cevent ))
+ {
+ win->SetCursor( cevent.GetCursor() );
+ }
+ }
+
+ bool ret = win->GTKProcessEvent(event);
+
+ g_lastMouseEvent = NULL;
+
+ return ret;
+}
+
+//-----------------------------------------------------------------------------
+// "scroll_event", (mouse wheel event)
+//-----------------------------------------------------------------------------
+
+static gboolean
+window_scroll_event(GtkWidget*, GdkEventScroll* gdk_event, wxWindow* win)
+{
+ DEBUG_MAIN_THREAD
+
+ if (gdk_event->direction != GDK_SCROLL_UP &&
+ gdk_event->direction != GDK_SCROLL_DOWN)
+ {
+ return false;
+ }
+
+ wxMouseEvent event(wxEVT_MOUSEWHEEL);
+ // Can't use InitMouse macro because scroll events don't have button
+ event.SetTimestamp( gdk_event->time );
+ event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK);
+ event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK);
+ event.m_altDown = (gdk_event->state & GDK_MOD1_MASK);
+ event.m_metaDown = (gdk_event->state & GDK_MOD2_MASK);
+ event.m_leftDown = (gdk_event->state & GDK_BUTTON1_MASK);
+ event.m_middleDown = (gdk_event->state & GDK_BUTTON2_MASK);
+ event.m_rightDown = (gdk_event->state & GDK_BUTTON3_MASK);
+ event.m_linesPerAction = 3;
+ event.m_wheelDelta = 120;
+ if (gdk_event->direction == GDK_SCROLL_UP)
+ event.m_wheelRotation = 120;
+ else
+ event.m_wheelRotation = -120;
+
+ wxPoint pt = win->GetClientAreaOrigin();
+ event.m_x = (wxCoord)gdk_event->x - pt.x;
+ event.m_y = (wxCoord)gdk_event->y - pt.y;
+
+ event.SetEventObject( win );
+ event.SetId( win->GetId() );
+ event.SetTimestamp( gdk_event->time );
+
+ return win->GTKProcessEvent(event);
+}
+
+//-----------------------------------------------------------------------------
+// "popup-menu"
+//-----------------------------------------------------------------------------
+
+static gboolean wxgtk_window_popup_menu_callback(GtkWidget*, wxWindowGTK* win)
+{
+ wxContextMenuEvent event(wxEVT_CONTEXT_MENU, win->GetId(), wxPoint(-1, -1));
+ event.SetEventObject(win);
+ return win->GTKProcessEvent(event);
+}
+
+//-----------------------------------------------------------------------------
+// "focus_in_event"
+//-----------------------------------------------------------------------------
+
+static gboolean
+gtk_window_focus_in_callback( GtkWidget *widget,
+ GdkEventFocus *WXUNUSED(event),
+ wxWindow *win )
+{
+ DEBUG_MAIN_THREAD
+
+ if (win->m_imData)
+ gtk_im_context_focus_in(win->m_imData->context);
+
+ g_focusWindowLast =
+ g_focusWindow = win;
+
+ wxLogTrace(TRACE_FOCUS,
+ _T("%s: focus in"), win->GetName().c_str());
+
+#if wxUSE_CARET
+ // caret needs to be informed about focus change
+ wxCaret *caret = win->GetCaret();
+ if ( caret )
+ {
+ caret->OnSetFocus();
+ }
+#endif // wxUSE_CARET
+
+ gboolean ret = FALSE;
+
+ // does the window itself think that it has the focus?
+ if ( !win->m_hasFocus )
+ {
+ // not yet, notify it
+ win->m_hasFocus = true;
+
+ (void)DoSendFocusEvents(win);
+
+ ret = TRUE;
+ }
+
+ // Disable default focus handling for custom windows
+ // since the default GTK+ handler issues a repaint
+ if (win->m_wxwindow)
+ return ret;
+
+ return FALSE;
+}
+
+//-----------------------------------------------------------------------------
+// "focus_out_event"
+//-----------------------------------------------------------------------------
+
+static gboolean
+gtk_window_focus_out_callback( GtkWidget *widget,
+ GdkEventFocus *gdk_event,
+ wxWindowGTK *win )
+{
+ DEBUG_MAIN_THREAD
+
+ if (win->m_imData)
+ gtk_im_context_focus_out(win->m_imData->context);
+
+ wxLogTrace( TRACE_FOCUS,
+ _T("%s: focus out"), win->GetName().c_str() );
+
+
+ wxWindowGTK *winFocus = wxFindFocusedChild(win);
+ if ( winFocus )
+ win = winFocus;
+
+ g_focusWindow = (wxWindowGTK *)NULL;
+
+#if wxUSE_CARET
+ // caret needs to be informed about focus change
+ wxCaret *caret = win->GetCaret();
+ if ( caret )
+ {
+ caret->OnKillFocus();
+ }
+#endif // wxUSE_CARET
+
+ // don't send the window a kill focus event if it thinks that it doesn't
+ // have focus already
+ if ( win->m_hasFocus )
+ {
+ // the event handler might delete the window when it loses focus, so
+ // check whether this is a custom window before calling it
+ const bool has_wxwindow = win->m_wxwindow != NULL;
+
+ win->m_hasFocus = false;
+
+ wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() );
+ event.SetEventObject( win );
+
+ (void)win->GTKProcessEvent( event );
+
+ // Disable default focus handling for custom windows
+ // since the default GTK+ handler issues a repaint
+ if ( has_wxwindow )
+ return TRUE;
+ }
+
+ // continue with normal processing
+ return FALSE;
+}
+
+static gboolean
+wx_window_focus_callback(GtkWidget *widget,
+ GtkDirectionType direction,
+ wxWindowGTK *win)
+{
+ // the default handler for focus signal in GtkPizza (or, rather, in
+ // GtkScrolledWindow from which GtkPizza inherits this behaviour) sets
+ // focus to the window itself even if it doesn't accept focus, i.e. has no
+ // GTK_CAN_FOCUS in its style -- work around this by forcibly preventing
+ // the signal from reaching gtk_scrolled_window_focus() if we don't have
+ // any children which might accept focus (we know we don't accept the focus
+ // ourselves as this signal is only connected in this case)
+ if ( win->GetChildren().empty() )
+ g_signal_stop_emission_by_name(widget, "focus");
+
+ // we didn't change the focus
+ return FALSE;
+}
+
+//-----------------------------------------------------------------------------
+// "enter_notify_event"
+//-----------------------------------------------------------------------------
+
+static gboolean
+gtk_window_enter_callback( GtkWidget *widget,
+ GdkEventCrossing *gdk_event,
+ wxWindowGTK *win )
+{
+ wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
+
+ // Event was emitted after a grab
+ if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
+
+ int x = 0;
+ int y = 0;
+ GdkModifierType state = (GdkModifierType)0;
+
+ gdk_window_get_pointer( widget->window, &x, &y, &state );
+
+ wxMouseEvent event( wxEVT_ENTER_WINDOW );
+ InitMouseEvent(win, event, gdk_event);
+ wxPoint pt = win->GetClientAreaOrigin();
+ event.m_x = x + pt.x;
+ event.m_y = y + pt.y;
+
+ if ( !g_captureWindow )
+ {
+ wxSetCursorEvent cevent( event.m_x, event.m_y );
+ if (win->GTKProcessEvent( cevent ))
+ {
+ win->SetCursor( cevent.GetCursor() );
+ }
+ }
+
+ return win->GTKProcessEvent(event);
+}
+
+//-----------------------------------------------------------------------------
+// "leave_notify_event"
+//-----------------------------------------------------------------------------
+
+static gboolean
+gtk_window_leave_callback( GtkWidget *widget,
+ GdkEventCrossing *gdk_event,
+ wxWindowGTK *win )
+{
+ wxCOMMON_CALLBACK_PROLOGUE(gdk_event, win);
+
+ // Event was emitted after an ungrab
+ if (gdk_event->mode != GDK_CROSSING_NORMAL) return FALSE;
+
+ wxMouseEvent event( wxEVT_LEAVE_WINDOW );
+ event.SetTimestamp( gdk_event->time );
+ event.SetEventObject( win );
+
+ int x = 0;
+ int y = 0;
+ GdkModifierType state = (GdkModifierType)0;
+
+ gdk_window_get_pointer( widget->window, &x, &y, &state );
+
+ event.m_shiftDown = (state & GDK_SHIFT_MASK) != 0;
+ event.m_controlDown = (state & GDK_CONTROL_MASK) != 0;
+ event.m_altDown = (state & GDK_MOD1_MASK) != 0;
+ event.m_metaDown = (state & GDK_MOD2_MASK) != 0;
+ event.m_leftDown = (state & GDK_BUTTON1_MASK) != 0;
+ event.m_middleDown = (state & GDK_BUTTON2_MASK) != 0;
+ event.m_rightDown = (state & GDK_BUTTON3_MASK) != 0;
+
+ wxPoint pt = win->GetClientAreaOrigin();
+ event.m_x = x + pt.x;
+ event.m_y = y + pt.y;
+
+ return win->GTKProcessEvent(event);
+}
+
+//-----------------------------------------------------------------------------
+// "value_changed" from scrollbar
+//-----------------------------------------------------------------------------
+
+static void
+gtk_scrollbar_value_changed(GtkRange* range, wxWindow* win)
+{
+ wxEventType eventType = win->GetScrollEventType(range);
+ if (eventType != wxEVT_NULL)
+ {
+ // Convert scroll event type to scrollwin event type
+ eventType += wxEVT_SCROLLWIN_TOP - wxEVT_SCROLL_TOP;
+
+ // find the scrollbar which generated the event
+ wxWindowGTK::ScrollDir dir = win->ScrollDirFromRange(range);
+
+ // generate the corresponding wx event
+ const int orient = wxWindow::OrientFromScrollDir(dir);
+ wxScrollWinEvent event(eventType, win->GetScrollPos(orient), orient);
+ event.SetEventObject(win);
+
+ win->m_blockValueChanged[dir] = true;
+ win->GTKProcessEvent(event);
+ win->m_blockValueChanged[dir] = false;
+ }
+}
+
+//-----------------------------------------------------------------------------
+// "button_press_event" from scrollbar
+//-----------------------------------------------------------------------------
+
+static gboolean
+gtk_scrollbar_button_press_event(GtkRange*, GdkEventButton*, wxWindow* win)
+{
+ DEBUG_MAIN_THREAD
+
+ g_blockEventsOnScroll = true;
+ win->m_mouseButtonDown = true;
+
+ return false;
+}
+
+//-----------------------------------------------------------------------------
+// "event_after" from scrollbar
+//-----------------------------------------------------------------------------
+
+static void
+gtk_scrollbar_event_after(GtkRange* range, GdkEvent* event, wxWindow* win)
+{
+ if (event->type == GDK_BUTTON_RELEASE)
+ {
+ g_signal_handlers_block_by_func(range, (void*)gtk_scrollbar_event_after, win);
+
+ const int orient = wxWindow::OrientFromScrollDir(
+ win->ScrollDirFromRange(range));
+ wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBRELEASE, win->GetScrollPos(orient), orient);
+ event.SetEventObject(win);
+ win->GTKProcessEvent(event);
+ }
+}
+
+//-----------------------------------------------------------------------------
+// "button_release_event" from scrollbar
+//-----------------------------------------------------------------------------
+
+static gboolean
+gtk_scrollbar_button_release_event(GtkRange* range, GdkEventButton*, wxWindow* win)
+{
+ DEBUG_MAIN_THREAD
+
+ g_blockEventsOnScroll = false;
+ win->m_mouseButtonDown = false;
+ // If thumb tracking
+ if (win->m_isScrolling)
+ {
+ win->m_isScrolling = false;
+ // Hook up handler to send thumb release event after this emission is finished.
+ // To allow setting scroll position from event handler, sending event must
+ // be deferred until after the GtkRange handler for this signal has run
+ g_signal_handlers_unblock_by_func(range, (void*)gtk_scrollbar_event_after, win);
+ }
+
+ return false;
+}
+
+//-----------------------------------------------------------------------------
+// "realize" from m_widget
+//-----------------------------------------------------------------------------
+
+static void
+gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win )
+{
+ DEBUG_MAIN_THREAD
+
+ if (win->m_imData)
+ {
+ GtkPizza *pizza = GTK_PIZZA( m_widget );
+ gtk_im_context_set_client_window( win->m_imData->context,
+ pizza->bin_window );
+ }
+
+ // We cannot set colours and fonts before the widget
+ // been realized, so we do this directly after realization
+ // or otherwise in idle time
+
+ if (win->m_needsStyleChange)
+ {
+ win->SetBackgroundStyle(win->GetBackgroundStyle());
+ win->m_needsStyleChange = false;
+ }
+
+ wxWindowCreateEvent event( win );
+ event.SetEventObject( win );
+ win->GTKProcessEvent( event );
+}
+
+//-----------------------------------------------------------------------------
+// "size_allocate"
+//-----------------------------------------------------------------------------
+
+static
+void gtk_window_size_callback( GtkWidget *WXUNUSED(widget),
+ GtkAllocation *alloc,
+ wxWindow *win )
+{
+ int client_width = 0;
+ int client_height = 0;
+ win->GetClientSize( &client_width, &client_height );
+ if ((client_width == win->m_oldClientWidth) && (client_height == win->m_oldClientHeight))
+ return;
+
+ if ( !client_width && !client_height )
+ {
+ // the window is currently unmapped, don't generate size events
+ return;
+ }
+
+ win->m_oldClientWidth = client_width;
+ win->m_oldClientHeight = client_height;
+
+ if (!win->m_nativeSizeEvent)
+ {
+ wxSizeEvent event( win->GetSize(), win->GetId() );
+ event.SetEventObject( win );
+ win->GTKProcessEvent( event );
+ }
+}
+
+} // extern "C"
+
+// ----------------------------------------------------------------------------
+// this wxWindowBase function is implemented here (in platform-specific file)
+// because it is static and so couldn't be made virtual
+// ----------------------------------------------------------------------------
+
+wxWindow *wxWindowBase::DoFindFocus()
+{
+ // the cast is necessary when we compile in wxUniversal mode
+ return (wxWindow *)g_focusWindow;
+}
+
+//-----------------------------------------------------------------------------
+// InsertChild for wxWindowGTK.
+//-----------------------------------------------------------------------------
+
+/* Callback for wxWindowGTK. This very strange beast has to be used because
+ * C++ has no virtual methods in a constructor. We have to emulate a
+ * virtual function here as wxNotebook requires a different way to insert
+ * a child in it. I had opted for creating a wxNotebookPage window class
+ * which would have made this superfluous (such in the MDI window system),
+ * but no-one was listening to me... */
+
+static void wxInsertChildInWindow( wxWindowGTK* parent, wxWindowGTK* child )
+{
+ /* the window might have been scrolled already, do we
+ have to adapt the position */
+ GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
+ child->m_x += gtk_pizza_get_xoffset( pizza );
+ child->m_y += gtk_pizza_get_yoffset( pizza );
+
+ gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
+ child->m_widget,
+ child->m_x,
+ child->m_y,
+ child->m_width,
+ child->m_height );
+}
+
+//-----------------------------------------------------------------------------
+// global functions
+//-----------------------------------------------------------------------------
+
+wxWindow *wxGetActiveWindow()
+{
+ return wxWindow::FindFocus();
+}
+
+
+wxMouseState wxGetMouseState()
+{
+ wxMouseState ms;
+
+ gint x;
+ gint y;
+ GdkModifierType mask;
+
+ gdk_window_get_pointer(NULL, &x, &y, &mask);
+
+ ms.SetX(x);
+ ms.SetY(y);
+ ms.SetLeftDown(mask & GDK_BUTTON1_MASK);
+ ms.SetMiddleDown(mask & GDK_BUTTON2_MASK);
+ ms.SetRightDown(mask & GDK_BUTTON3_MASK);
+
+ ms.SetControlDown(mask & GDK_CONTROL_MASK);
+ ms.SetShiftDown(mask & GDK_SHIFT_MASK);
+ ms.SetAltDown(mask & GDK_MOD1_MASK);
+ ms.SetMetaDown(mask & GDK_MOD2_MASK);
+
+ return ms;
+}
+
+//-----------------------------------------------------------------------------
+// wxWindowGTK
+//-----------------------------------------------------------------------------
+
+// in wxUniv/MSW this class is abstract because it doesn't have DoPopupMenu()
+// method
+#ifdef __WXUNIVERSAL__
+ IMPLEMENT_ABSTRACT_CLASS(wxWindowGTK, wxWindowBase)
+#else // __WXGTK__
+ IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
+#endif // __WXUNIVERSAL__/__WXGTK__
+
+void wxWindowGTK::Init()
+{
+ // GTK specific
+ m_widget = (GtkWidget *) NULL;
+ m_wxwindow = (GtkWidget *) NULL;
+ m_focusWidget = (GtkWidget *) NULL;
+
+ // position/size
+ m_x = 0;
+ m_y = 0;
+ m_width = 0;
+ m_height = 0;
+
+ m_sizeSet = false;
+ m_hasVMT = false;
+ m_isBeingDeleted = false;
+
+ m_showOnIdle= false;
+
+ m_noExpose = false;
+ m_nativeSizeEvent = false;
+
+ m_hasScrolling = false;
+ m_isScrolling = false;
+ m_mouseButtonDown = false;
+ m_blockScrollEvent = false;
+
+ // initialize scrolling stuff
+ for ( int dir = 0; dir < ScrollDir_Max; dir++ )
+ {
+ m_scrollBar[dir] = NULL;
+ m_scrollPos[dir] = 0;
+ m_blockValueChanged[dir] = false;
+ }
+
+ m_oldClientWidth =
+ m_oldClientHeight = 0;
+
+ m_resizing = false;
+
+ m_insertCallback = (wxInsertChildFunction) NULL;
+
+ m_hasFocus = false;
+
+ m_clipPaintRegion = false;
+
+ m_needsStyleChange = false;
+
+ m_cursor = *wxSTANDARD_CURSOR;
+
+ m_imData = NULL;
+ m_dirtyTabOrder = false;
+}
+
+wxWindowGTK::wxWindowGTK()
+{
+ Init();
+}
+
+wxWindowGTK::wxWindowGTK( wxWindow *parent,
+ wxWindowID id,
+ const wxPoint &pos,
+ const wxSize &size,
+ long style,
+ const wxString &name )
+{
+ Init();
+
+ Create( parent, id, pos, size, style, name );
+}
+
+bool wxWindowGTK::Create( wxWindow *parent,
+ wxWindowID id,
+ const wxPoint &pos,
+ const wxSize &size,
+ long style,
+ const wxString &name )
+{
+ if (!PreCreation( parent, pos, size ) ||
+ !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
+ {
+ wxFAIL_MSG( wxT("wxWindowGTK creation failed") );
+ return false;
+ }
+
+ m_insertCallback = wxInsertChildInWindow;
+
+
+ if (!HasFlag(wxHSCROLL) && !HasFlag(wxVSCROLL))
+ {
+ m_wxwindow = gtk_pizza_new_no_scroll();
+
+#ifndef __WXUNIVERSAL__
+ if (HasFlag(wxSIMPLE_BORDER))
+ gtk_container_set_border_width((GtkContainer*)m_wxwindow, 1);
+ else if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
+ gtk_container_set_border_width((GtkContainer*)m_wxwindow, 2);
+#endif // __WXUNIVERSAL__
+
+ m_widget = m_wxwindow;
+ }
+ else
+ {
+ m_wxwindow = gtk_pizza_new();
+
+#ifndef __WXUNIVERSAL__
+ if (HasFlag(wxSIMPLE_BORDER))
+ gtk_container_set_border_width((GtkContainer*)m_wxwindow, 1);
+ else if (HasFlag(wxRAISED_BORDER) || HasFlag(wxSUNKEN_BORDER))
+ gtk_container_set_border_width((GtkContainer*)m_wxwindow, 2);
+#endif // __WXUNIVERSAL__
+
+ m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
+
+ GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
+
+ GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
+ scroll_class->scrollbar_spacing = 0;
+
+ // There is a conflict with default bindings at GTK+
+ // level between scrolled windows and notebooks both of which want to use
+ // Ctrl-PageUp/Down: scrolled windows for scrolling in the horizontal
+ // direction and notebooks for changing pages -- we decide that if we don't
+ // have wxHSCROLL style we can safely sacrifice horizontal scrolling if it
+ // means we can get working keyboard navigation in notebooks
+ if ( !HasFlag(wxHSCROLL) )
+ {
+ GtkBindingSet *
+ bindings = gtk_binding_set_by_class(G_OBJECT_GET_CLASS(m_widget));
+ if ( bindings )
+ {
+ gtk_binding_entry_remove(bindings, GDK_Page_Up, GDK_CONTROL_MASK);
+ gtk_binding_entry_remove(bindings, GDK_Page_Down, GDK_CONTROL_MASK);
+ }
+ }
+
+ if (HasFlag(wxALWAYS_SHOW_SB))
+ {
+ gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS );
+
+ scrolledWindow->hscrollbar_visible = TRUE;
+ scrolledWindow->vscrollbar_visible = TRUE;
+ }
+ else
+ {
+ gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
+ }
+
+ m_scrollBar[ScrollDir_Horz] = GTK_RANGE(scrolledWindow->hscrollbar);
+ m_scrollBar[ScrollDir_Vert] = GTK_RANGE(scrolledWindow->vscrollbar);
+ if (GetLayoutDirection() == wxLayout_RightToLeft)
+ gtk_range_set_inverted( m_scrollBar[ScrollDir_Horz], TRUE );
+
+ gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
+
+ // connect various scroll-related events
+ for ( int dir = 0; dir < ScrollDir_Max; dir++ )
+ {
+ // these handlers block mouse events to any window during scrolling
+ // such as motion events and prevent GTK and wxWidgets from fighting
+ // over where the slider should be
+ g_signal_connect(m_scrollBar[dir], "button_press_event",
+ G_CALLBACK(gtk_scrollbar_button_press_event), this);
+ g_signal_connect(m_scrollBar[dir], "button_release_event",
+ G_CALLBACK(gtk_scrollbar_button_release_event), this);
+
+ gulong handler_id = g_signal_connect(m_scrollBar[dir], "event_after",
+ G_CALLBACK(gtk_scrollbar_event_after), this);
+ g_signal_handler_block(m_scrollBar[dir], handler_id);
+
+ // these handlers get notified when scrollbar slider moves
+ g_signal_connect(m_scrollBar[dir], "value_changed",
+ G_CALLBACK(gtk_scrollbar_value_changed), this);
+ }
+
+ gtk_widget_show( m_wxwindow );
+ }
+
+ if (m_parent)
+ m_parent->DoAddChild( this );
+
+ m_focusWidget = m_wxwindow;
+
+ PostCreation();
+
+ return true;
+}
+
+wxWindowGTK::~wxWindowGTK()
+{
+ SendDestroyEvent();
+
+ if (g_focusWindow == this)
+ g_focusWindow = NULL;
+
+ if ( g_delayedFocus == this )
+ g_delayedFocus = NULL;
+
+ m_isBeingDeleted = true;
+ m_hasVMT = false;
+
+ // destroy children before destroying this window itself
+ DestroyChildren();
+
+ // unhook focus handlers to prevent stray events being
+ // propagated to this (soon to be) dead object
+ if (m_focusWidget != NULL)
+ {
+ g_signal_handlers_disconnect_by_func (m_focusWidget,
+ (gpointer) gtk_window_focus_in_callback,
+ this);
+ g_signal_handlers_disconnect_by_func (m_focusWidget,
+ (gpointer) gtk_window_focus_out_callback,
+ this);
+ }
+
+ if (m_widget)
+ Show( false );
+
+ // delete before the widgets to avoid a crash on solaris
+ delete m_imData;
+
+ if (m_wxwindow && (m_wxwindow != m_widget))
+ {
+ gtk_widget_destroy( m_wxwindow );
+ m_wxwindow = (GtkWidget*) NULL;
+ }
+
+ if (m_widget)
+ {
+ gtk_widget_destroy( m_widget );
+ m_widget = (GtkWidget*) NULL;
+ }
+}
+
+bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size )
+{
+ if ( GTKNeedsParent() )
+ {
+ wxCHECK_MSG( parent, false, wxT("Must have non-NULL parent") );
+ }
+
+ // Use either the given size, or the default if -1 is given.
+ // See wxWindowBase for these functions.
+ m_width = WidthDefault(size.x) ;
+ m_height = HeightDefault(size.y);
+
+ m_x = (int)pos.x;
+ m_y = (int)pos.y;
+
+ return true;
+}
+
+void wxWindowGTK::PostCreation()
+{
+ wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
+
+ if (m_wxwindow)
+ {
+ if (!m_noExpose)
+ {
+ // these get reported to wxWidgets -> wxPaintEvent
+
+ g_signal_connect (m_wxwindow, "expose_event",
+ G_CALLBACK (gtk_window_expose_callback), this);
+
+ if (GetLayoutDirection() == wxLayout_LeftToRight)
+ gtk_widget_set_redraw_on_allocate( GTK_WIDGET(m_wxwindow), HasFlag( wxFULL_REPAINT_ON_RESIZE ) );
+ }
+
+ // Create input method handler
+ m_imData = new wxGtkIMData;
+
+ // Cannot handle drawing preedited text yet
+ gtk_im_context_set_use_preedit( m_imData->context, FALSE );
+
+ g_signal_connect (m_imData->context, "commit",
+ G_CALLBACK (gtk_wxwindow_commit_cb), this);
+
+ // these are called when the "sunken" or "raised" borders are drawn
+ g_signal_connect (m_widget, "expose_event",
+ G_CALLBACK (gtk_window_own_expose_callback), this);
+ }
+
+ // focus handling
+
+ if (!GTK_IS_WINDOW(m_widget))
+ {
+ if (m_focusWidget == NULL)
+ m_focusWidget = m_widget;
+
+ if (m_wxwindow)
+ {
+ g_signal_connect (m_focusWidget, "focus_in_event",
+ G_CALLBACK (gtk_window_focus_in_callback), this);
+ g_signal_connect (m_focusWidget, "focus_out_event",
+ G_CALLBACK (gtk_window_focus_out_callback), this);
+ }
+ else
+ {
+ g_signal_connect_after (m_focusWidget, "focus_in_event",
+ G_CALLBACK (gtk_window_focus_in_callback), this);
+ g_signal_connect_after (m_focusWidget, "focus_out_event",
+ G_CALLBACK (gtk_window_focus_out_callback), this);
+ }
+ }
+
+ if ( !AcceptsFocusFromKeyboard() )
+ {
+ SetCanFocus(false);
+
+ g_signal_connect(m_widget, "focus",
+ G_CALLBACK(wx_window_focus_callback), this);
+ }
+
+ // connect to the various key and mouse handlers
+
+ GtkWidget *connect_widget = GetConnectWidget();
+
+ ConnectWidget( connect_widget );
+
+ /* We cannot set colours, fonts and cursors before the widget has
+ been realized, so we do this directly after realization */
+ g_signal_connect (connect_widget, "realize",
+ G_CALLBACK (gtk_window_realized_callback), this);
+
+ if (m_wxwindow)
+ {
+ // Catch native resize events
+ g_signal_connect (m_wxwindow, "size_allocate",
+ G_CALLBACK (gtk_window_size_callback), this);
+ }
+
+ if (GTK_IS_COMBO(m_widget))
+ {
+ GtkCombo *gcombo = GTK_COMBO(m_widget);
+
+ g_signal_connect (gcombo->entry, "size_request",
+ G_CALLBACK (wxgtk_combo_size_request_callback),
+ this);
+ }
+#ifdef GTK_IS_FILE_CHOOSER_BUTTON
+ else if (!gtk_check_version(2,6,0) && GTK_IS_FILE_CHOOSER_BUTTON(m_widget))
+ {
+ // If we connect to the "size_request" signal of a GtkFileChooserButton
+ // then that control won't be sized properly when placed inside sizers
+ // (this can be tested removing this elseif and running XRC or WIDGETS samples)
+ // FIXME: what should be done here ?
+ }
+#endif
+ else if ( !IsTopLevel() ) // top level windows use their own callback
+ {
+ // This is needed if we want to add our windows into native
+ // GTK controls, such as the toolbar. With this callback, the
+ // toolbar gets to know the correct size (the one set by the
+ // programmer). Sadly, it misbehaves for wxComboBox.
+ g_signal_connect (m_widget, "size_request",
+ G_CALLBACK (wxgtk_window_size_request_callback),
+ this);
+ }
+
+ InheritAttributes();
+
+ m_hasVMT = true;
+
+ SetLayoutDirection(wxLayout_Default);
+
+ // unless the window was created initially hidden (i.e. Hide() had been
+ // called before Create()), we should show it at GTK+ level as well
+ if ( IsShown() )
+ gtk_widget_show( m_widget );
+}
+
+void wxWindowGTK::ConnectWidget( GtkWidget *widget )
+{
+ g_signal_connect (widget, "key_press_event",
+ G_CALLBACK (gtk_window_key_press_callback), this);
+ g_signal_connect (widget, "key_release_event",
+ G_CALLBACK (gtk_window_key_release_callback), this);
+ g_signal_connect (widget, "button_press_event",
+ G_CALLBACK (gtk_window_button_press_callback), this);
+ g_signal_connect (widget, "button_release_event",
+ G_CALLBACK (gtk_window_button_release_callback), this);
+ g_signal_connect (widget, "motion_notify_event",
+ G_CALLBACK (gtk_window_motion_notify_callback), this);
+ g_signal_connect (widget, "scroll_event",
+ G_CALLBACK (window_scroll_event), this);
+ g_signal_connect (widget, "popup_menu",
+ G_CALLBACK (wxgtk_window_popup_menu_callback), this);
+ g_signal_connect (widget, "enter_notify_event",
+ G_CALLBACK (gtk_window_enter_callback), this);
+ g_signal_connect (widget, "leave_notify_event",
+ G_CALLBACK (gtk_window_leave_callback), this);
+}
+
+bool wxWindowGTK::Destroy()
+{
+ wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
+
+ m_hasVMT = false;
+
+ return wxWindowBase::Destroy();
+}
+
+void wxWindowGTK::DoMoveWindow(int x, int y, int width, int height)
+{
+ // inform the parent to perform the move
+ gtk_pizza_set_size( GTK_PIZZA(m_parent->m_wxwindow), m_widget, x, y, width, height );
+
+}
+
+void wxWindowGTK::ConstrainSize()
+{
+#ifdef __WXGPE__
+ // GPE's window manager doesn't like size hints at all, esp. when the user
+ // has to use the virtual keyboard, so don't constrain size there
+ if (!IsTopLevel())
+#endif
+ {
+ const wxSize minSize = GetMinSize();
+ const wxSize maxSize = GetMaxSize();
+ if (minSize.x > 0 && m_width < minSize.x) m_width = minSize.x;
+ if (minSize.y > 0 && m_height < minSize.y) m_height = minSize.y;
+ if (maxSize.x > 0 && m_width > maxSize.x) m_width = maxSize.x;
+ if (maxSize.y > 0 && m_height > maxSize.y) m_height = maxSize.y;
+ }
+}
+
+void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
+{
+ wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") );
+ wxASSERT_MSG( (m_parent != NULL), wxT("wxWindowGTK::SetSize requires parent.\n") );
+
+ if (m_resizing) return; /* I don't like recursions */
+ m_resizing = true;
+
+ int currentX, currentY;
+ GetPosition(¤tX, ¤tY);
+ if (x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+ x = currentX;
+ if (y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
+ y = currentY;
+ AdjustForParentClientOrigin(x, y, sizeFlags);
+
+ // calculate the best size if we should auto size the window
+ if ( ((sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1) ||
+ ((sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1) )
+ {
+ const wxSize sizeBest = GetBestSize();
+ if ( (sizeFlags & wxSIZE_AUTO_WIDTH) && width == -1 )
+ width = sizeBest.x;
+ if ( (sizeFlags & wxSIZE_AUTO_HEIGHT) && height == -1 )
+ height = sizeBest.y;
+ }
+
+ if (width != -1)
+ m_width = width;
+ if (height != -1)
+ m_height = height;
+
+ ConstrainSize();
+
+#if wxUSE_TOOLBAR_NATIVE
+ if (wxDynamicCast(GetParent(), wxToolBar))
+ {
+ // don't take the x,y values, they're wrong because toolbar sets them
+ GtkWidget *widget = m_widget;
+ gtk_widget_set_size_request (widget, m_width, m_height);
+ }
+ else
+#endif
+ if (m_parent->m_wxwindow == NULL) // i.e. wxNotebook
+ {
+ // don't set the size for children of wxNotebook, just take the values.
+ m_x = x;
+ m_y = y;
+ m_width = width;
+ m_height = height;
+ }
+ else
+ {
+ GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
+ if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
+ {
+ if (x != -1) m_x = x + gtk_pizza_get_xoffset( pizza );
+ if (y != -1) m_y = y + gtk_pizza_get_yoffset( pizza );
+ }
+ else
+ {
+ m_x = x + gtk_pizza_get_xoffset( pizza );
+ m_y = y + gtk_pizza_get_yoffset( pizza );
+ }
+
+ int left_border = 0;
+ int right_border = 0;
+ int top_border = 0;
+ int bottom_border = 0;
+
+ /* the default button has a border around it */
+ if (GTK_WIDGET_CAN_DEFAULT(m_widget))
+ {
+ GtkBorder *default_border = NULL;
+ gtk_widget_style_get( m_widget, "default_border", &default_border, NULL );
+ if (default_border)
+ {
+ left_border += default_border->left;
+ right_border += default_border->right;
+ top_border += default_border->top;
+ bottom_border += default_border->bottom;
+ g_free( default_border );
+ }
+ }
+
+ DoMoveWindow( m_x-top_border,
+ m_y-left_border,
+ m_width+left_border+right_border,
+ m_height+top_border+bottom_border );
+ }
+
+ if (m_hasScrolling)
+ {
+ /* Sometimes the client area changes size without the
+ whole windows's size changing, but if the whole
+ windows's size doesn't change, no wxSizeEvent will
+ normally be sent. Here we add an extra test if
+ the client test has been changed and this will
+ be used then. */
+ GetClientSize( &m_oldClientWidth, &m_oldClientHeight );
+ }
+
+/*
+ wxPrintf( "OnSize sent from " );
+ if (GetClassInfo() && GetClassInfo()->GetClassName())
+ wxPrintf( GetClassInfo()->GetClassName() );
+ wxPrintf( " %d %d %d %d\n", (int)m_x, (int)m_y, (int)m_width, (int)m_height );
+*/
+
+ if (!m_nativeSizeEvent)
+ {
+ wxSizeEvent event( wxSize(m_width,m_height), GetId() );
+ event.SetEventObject( this );
+ GetEventHandler()->ProcessEvent( event );
+ }
+
+ m_resizing = false;
+}
+
+bool wxWindowGTK::GtkShowFromOnIdle()
+{
+ if (IsShown() && m_showOnIdle && !GTK_WIDGET_VISIBLE (m_widget))
+ {
+ GtkAllocation alloc;
+ alloc.x = m_x;
+ alloc.y = m_y;
+ alloc.width = m_width;
+ alloc.height = m_height;
+ gtk_widget_size_allocate( m_widget, &alloc );
+ gtk_widget_show( m_widget );
+ wxShowEvent eventShow(GetId(), true);
+ eventShow.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(eventShow);
+ m_showOnIdle = false;
+ return true;
+ }
+
+ return false;
+}
+
+void wxWindowGTK::OnInternalIdle()
+{
+ // Check if we have to show window now
+ if (GtkShowFromOnIdle()) return;
+
+ if ( m_dirtyTabOrder )
+ {
+ m_dirtyTabOrder = false;
+ RealizeTabOrder();
+ }
+
+ // Update style if the window was not yet realized
+ // and SetBackgroundStyle(wxBG_STYLE_CUSTOM) was called
+ if (m_needsStyleChange)
+ {
+ SetBackgroundStyle(GetBackgroundStyle());
+ m_needsStyleChange = false;
+ }
+
+ wxCursor cursor = m_cursor;
+ if (g_globalCursor.Ok()) cursor = g_globalCursor;
+
+ if (cursor.Ok())
+ {
+ /* I now set the cursor anew in every OnInternalIdle call
+ as setting the cursor in a parent window also effects the
+ windows above so that checking for the current cursor is
+ not possible. */
+
+ if (m_wxwindow && (m_wxwindow != m_widget))
+ {
+ GdkWindow *window = GTK_PIZZA(m_wxwindow)->bin_window;
+ if (window)
+ gdk_window_set_cursor( window, cursor.GetCursor() );
+
+ if (!g_globalCursor.Ok())
+ cursor = *wxSTANDARD_CURSOR;
+
+ window = m_widget->window;
+ if ((window) && !(GTK_WIDGET_NO_WINDOW(m_widget)))
+ gdk_window_set_cursor( window, cursor.GetCursor() );
+
+ }
+ else if ( m_widget )
+ {
+ GdkWindow *window = m_widget->window;
+ if ( window && !GTK_WIDGET_NO_WINDOW(m_widget) )
+ gdk_window_set_cursor( window, cursor.GetCursor() );
+ }
+ }
+
+ if (wxUpdateUIEvent::CanUpdate(this))
+ UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
+}
+
+void wxWindowGTK::DoGetSize( int *width, int *height ) const
+{
+ wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+
+ if (width) (*width) = m_width;
+ if (height) (*height) = m_height;
+}
+
+void wxWindowGTK::DoSetClientSize( int width, int height )
+{
+ wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+
+ if (m_wxwindow)
+ {
+ int dw = 0;
+ int dh = 0;
+
+ if (m_hasScrolling)
+ {
+ GetScrollbarWidth(m_widget, dw, dh);
+ }
+
+ const int border = GTK_CONTAINER(m_wxwindow)->border_width;
+ dw += 2 * border;
+ dh += 2 * border;
+
+ width += dw;
+ height += dh;
+ }
+
+ SetSize(width, height);
+}
+
+void wxWindowGTK::DoGetClientSize( int *width, int *height ) const
+{
+ wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+
+ int w = m_width;
+ int h = m_height;
+
+ if (m_wxwindow)
+ {
+ int dw = 0;
+ int dh = 0;
+
+ if (m_hasScrolling)
+ GetScrollbarWidth(m_widget, dw, dh);
+
+ const int border = GTK_CONTAINER(m_wxwindow)->border_width;
+ dw += 2 * border;
+ dh += 2 * border;
+
+ w -= dw;
+ h -= dh;
+ if (w < 0)
+ w = 0;
+ if (h < 0)
+ h = 0;
+ }
+
+ if (width) *width = w;
+ if (height) *height = h;
+}
+
+void wxWindowGTK::DoGetPosition( int *x, int *y ) const
+{
+ wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+
+ int dx = 0;
+ int dy = 0;
+ if (m_parent && m_parent->m_wxwindow)
+ {
+ GtkPizza *pizza = GTK_PIZZA(m_parent->m_wxwindow);
+ dx = gtk_pizza_get_xoffset( pizza );
+ dy = gtk_pizza_get_yoffset( pizza );
+ }
+
+ if (m_x == -1 && m_y == -1)
+ {
+ GdkWindow *source = (GdkWindow *) NULL;
+ if (m_wxwindow)
+ source = GTK_PIZZA(m_wxwindow)->bin_window;
+ else
+ source = m_widget->window;
+
+ if (source)
+ {
+ int org_x = 0;
+ int org_y = 0;
+ gdk_window_get_origin( source, &org_x, &org_y );
+
+ if (m_parent)
+ m_parent->ScreenToClient(&org_x, &org_y);
+
+ wx_const_cast(wxWindowGTK*, this)->m_x = org_x;
+ wx_const_cast(wxWindowGTK*, this)->m_y = org_y;
+ }
+ }
+
+ if (x) (*x) = m_x - dx;
+ if (y) (*y) = m_y - dy;
+}
+
+void wxWindowGTK::DoClientToScreen( int *x, int *y ) const
+{
+ wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+
+ if (!m_widget->window) return;
+
+ GdkWindow *source = (GdkWindow *) NULL;
+ if (m_wxwindow)
+ source = GTK_PIZZA(m_wxwindow)->bin_window;
+ else
+ source = m_widget->window;
+
+ int org_x = 0;
+ int org_y = 0;
+ gdk_window_get_origin( source, &org_x, &org_y );
+
+ if (!m_wxwindow)
+ {
+ if (GTK_WIDGET_NO_WINDOW (m_widget))
+ {
+ org_x += m_widget->allocation.x;
+ org_y += m_widget->allocation.y;
+ }
+ }
+
+
+ if (x)
+ {
+ if (GetLayoutDirection() == wxLayout_RightToLeft)
+ *x = (GetClientSize().x - *x) + org_x;
+ else
+ *x += org_x;
+ }
+
+ if (y) *y += org_y;
+}
+
+void wxWindowGTK::DoScreenToClient( int *x, int *y ) const
+{
+ wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+
+ if (!m_widget->window) return;
+
+ GdkWindow *source = (GdkWindow *) NULL;
+ if (m_wxwindow)
+ source = GTK_PIZZA(m_wxwindow)->bin_window;
+ else
+ source = m_widget->window;
+
+ int org_x = 0;
+ int org_y = 0;
+ gdk_window_get_origin( source, &org_x, &org_y );
+
+ if (!m_wxwindow)
+ {
+ if (GTK_WIDGET_NO_WINDOW (m_widget))
+ {
+ org_x += m_widget->allocation.x;
+ org_y += m_widget->allocation.y;
+ }
+ }
+
+ if (x)
+ {
+ if (GetLayoutDirection() == wxLayout_RightToLeft)
+ *x = (GetClientSize().x - *x) - org_x;
+ else
+ *x -= org_x;
+ }
+ if (y) *y -= org_y;
+}
+
+bool wxWindowGTK::Show( bool show )
+{
+ wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") );
+
+ if (!wxWindowBase::Show(show))
+ {
+ // nothing to do
+ return false;
+ }
+
+ if (show)
+ {
+ if (!m_showOnIdle)
+ {
+ gtk_widget_show( m_widget );
+ wxShowEvent eventShow(GetId(), show);
+ eventShow.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(eventShow);
+ }
+ }
+ else
+ {
+ gtk_widget_hide( m_widget );
+ wxShowEvent eventShow(GetId(), show);
+ eventShow.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(eventShow);
+ }
+
+ return true;
+}
+
+void wxWindowGTK::DoEnable( bool enable )
+{
+ wxCHECK_RET( (m_widget != NULL), wxT("invalid window") );
+
+ gtk_widget_set_sensitive( m_widget, enable );
+ if (m_wxwindow && (m_wxwindow != m_widget))
+ gtk_widget_set_sensitive( m_wxwindow, enable );
+}
+
+int wxWindowGTK::GetCharHeight() const
+{
+ wxCHECK_MSG( (m_widget != NULL), 12, wxT("invalid window") );
+
+ wxFont font = GetFont();
+ wxCHECK_MSG( font.Ok(), 12, wxT("invalid font") );
+
+ PangoContext *context = NULL;
+ if (m_widget)
+ context = gtk_widget_get_pango_context( m_widget );
+
+ if (!context)
+ return 0;
+
+ PangoFontDescription *desc = font.GetNativeFontInfo()->description;
+ PangoLayout *layout = pango_layout_new(context);
+ pango_layout_set_font_description(layout, desc);
+ pango_layout_set_text(layout, "H", 1);
+ PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
+
+ PangoRectangle rect;
+ pango_layout_line_get_extents(line, NULL, &rect);
+
+ g_object_unref (layout);
+
+ return (int) PANGO_PIXELS(rect.height);
projects / wxWidgets.git / blobdiff