X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/c7382f913cc2d3ddcc782b876574c58865e7d842..38c8fce8c4348a61a1e55da13142b84e44924845:/src/gtk1/window.cpp?ds=sidebyside diff --git a/src/gtk1/window.cpp b/src/gtk1/window.cpp index 380f121828..7bd13fae8e 100644 --- a/src/gtk1/window.cpp +++ b/src/gtk1/window.cpp @@ -7,11 +7,6 @@ // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// - -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #pragma implementation "window.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -28,6 +23,7 @@ #include "wx/dialog.h" #include "wx/msgdlg.h" #include "wx/module.h" +#include "wx/combobox.h" #if wxUSE_DRAG_AND_DROP #include "wx/dnd.h" @@ -56,7 +52,7 @@ #include "wx/thread.h" #endif -#include +#include "wx/math.h" #include #include "wx/gtk/private.h" @@ -73,11 +69,6 @@ #include #endif -#ifdef __WXGTK20__ - #define SET_CONTAINER_FOCUS(w, d) gtk_widget_child_focus((w), (d)) -#else - #define SET_CONTAINER_FOCUS(w, d) gtk_container_focus(GTK_CONTAINER(w), (d)) -#endif #ifdef __WXGTK20__ #ifdef HAVE_XIM @@ -233,33 +224,24 @@ static GdkGC *g_eraseGC = NULL; // mouse capture state: the window which has it and if the mouse is currently // inside it static wxWindowGTK *g_captureWindow = (wxWindowGTK*) NULL; -static bool g_captureWindowHasMouse = FALSE; +static bool g_captureWindowHasMouse = false; -/* extern */ wxWindowGTK *g_focusWindow = (wxWindowGTK*) NULL; +wxWindowGTK *g_focusWindow = (wxWindowGTK*) NULL; // the last window which had the focus - this is normally never NULL (except // if we never had focus at all) as even when g_focusWindow is NULL it still // keeps its previous value -static wxWindowGTK *g_focusWindowLast = (wxWindowGTK*) NULL; - -// the frame that is currently active (i.e. its child has focus). It is -// used to generate wxActivateEvents -static wxWindowGTK *g_activeFrame = (wxWindowGTK*) NULL; -static bool g_activeFrameLostFocus = FALSE; +wxWindowGTK *g_focusWindowLast = (wxWindowGTK*) NULL; // If a window get the focus set but has not been realized // yet, defer setting the focus to idle time. wxWindowGTK *g_delayedFocus = (wxWindowGTK*) NULL; -// if we detect that the app has got/lost the focus, we set this variable to -// either TRUE or FALSE and an activate event will be sent during the next -// OnIdle() call and it is reset to -1: this value means that we shouldn't -// send any activate events at all -static int g_sendActivateEvent = -1; - // hack: we need something to pass to gtk_menu_popup, so we store the time of // the last click here -static guint32 gs_timeLastClick = 0; +#ifndef __WXGTK20__ +static guint32 gs_timeLastClick = 0; +#endif extern bool g_mainThreadLocked; @@ -394,7 +376,7 @@ static void draw_frame( GtkWidget *widget, wxWindowGTK *win ) dh += hscroll_req.height; dh += scroll_class->scrollbar_spacing; } -} + } int dx = 0; int dy = 0; @@ -444,7 +426,8 @@ static void draw_frame( GtkWidget *widget, wxWindowGTK *win ) // "expose_event" of m_widget //----------------------------------------------------------------------------- -gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindowGTK *win ) +extern "C" { +static gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindowGTK *win ) { if (gdk_event->count > 0) return FALSE; @@ -457,6 +440,7 @@ gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_even #endif return TRUE; } +} //----------------------------------------------------------------------------- // "draw" of m_widget @@ -464,10 +448,12 @@ gint gtk_window_own_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_even #ifndef __WXGTK20__ +extern "C" { static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNUSED(rect), wxWindowGTK *win ) { draw_frame( widget, win ); } +} #endif // GTK+ < 2.0 @@ -475,8 +461,8 @@ static void gtk_window_own_draw_callback( GtkWidget *widget, GdkRectangle *WXUNU // "size_request" of m_widget //----------------------------------------------------------------------------- -// make it extern because wxStatitText needs to disconnect this one -extern "C" +// make it extern because wxStaticText needs to disconnect this one +extern "C" { void wxgtk_window_size_request_callback(GtkWidget *widget, GtkRequisition *requisition, wxWindow *win) @@ -491,11 +477,42 @@ void wxgtk_window_size_request_callback(GtkWidget *widget, requisition->height = h; requisition->width = w; } +} + +extern "C" { +static +void wxgtk_combo_size_request_callback(GtkWidget *widget, + GtkRequisition *requisition, + wxComboBox *win) +{ + // This callback is actually hooked into the text entry + // of the combo box, not the GtkHBox. + + int w, h; + win->GetSize( &w, &h ); + if (w < 2) + w = 2; + if (h < 2) + h = 2; + + GtkCombo *gcombo = GTK_COMBO(win->m_widget); + + GtkRequisition entry_req; + entry_req.width = 2; + entry_req.height = 2; + (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(gcombo->button) )->size_request ) + (gcombo->button, &entry_req ); + + requisition->width = w - entry_req.width; + requisition->height = entry_req.height; +} +} //----------------------------------------------------------------------------- // "expose_event" of m_wxwindow //----------------------------------------------------------------------------- +extern "C" { static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win ) @@ -524,7 +541,7 @@ static int gtk_window_expose_callback( GtkWidget *widget, (int)gdk_event->area.width, (int)gdk_event->area.height ); } - + gtk_paint_box ( win->m_wxwindow->style, @@ -565,17 +582,22 @@ static int gtk_window_expose_callback( GtkWidget *widget, return FALSE; } +} //----------------------------------------------------------------------------- // "event" of m_wxwindow //----------------------------------------------------------------------------- +#ifndef __WXGTK20__ + // GTK thinks it is clever and filters out a certain amount of "unneeded" // expose events. We need them, of course, so we override the main event // procedure in GtkWidget by giving our own handler for all system events. // There, we look for expose events ourselves whereas all other events are // handled normally. +extern "C" { +static gint gtk_window_event_event_callback( GtkWidget *widget, GdkEventExpose *event, wxWindow *win ) @@ -588,6 +610,9 @@ gint gtk_window_event_event_callback( GtkWidget *widget, return FALSE; } +} + +#endif // !GTK+ 2 //----------------------------------------------------------------------------- // "draw" of m_wxwindow @@ -598,6 +623,7 @@ gint gtk_window_event_event_callback( GtkWidget *widget, // This callback is a complete replacement of the gtk_pizza_draw() function, // which is disabled. +extern "C" { static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win ) @@ -632,7 +658,7 @@ static void gtk_window_draw_callback( GtkWidget *widget, #ifndef __WXUNIVERSAL__ GtkPizza *pizza = GTK_PIZZA (widget); - if (win->GetThemeEnabled() && win->GetBackgroundStyle() != wxBG_STYLE_CUSTOM) + if (win->GetThemeEnabled() && win->GetBackgroundStyle() == wxBG_STYLE_SYSTEM) { wxWindow *parent = win->GetParent(); while (parent && !parent->IsTopLevel()) @@ -673,6 +699,7 @@ static void gtk_window_draw_callback( GtkWidget *widget, } #endif } +} #endif @@ -976,6 +1003,7 @@ static void wxFillOtherKeyEventFields(wxKeyEvent& event, gdk_window_get_pointer(gdk_event->window, &x, &y, &state); event.SetTimestamp( gdk_event->time ); + event.SetId(win->GetId()); event.m_shiftDown = (gdk_event->state & GDK_SHIFT_MASK) != 0; event.m_controlDown = (gdk_event->state & GDK_CONTROL_MASK) != 0; event.m_altDown = (gdk_event->state & GDK_MOD1_MASK) != 0; @@ -983,6 +1011,11 @@ static void wxFillOtherKeyEventFields(wxKeyEvent& event, event.m_scanCode = gdk_event->keyval; event.m_rawCode = (wxUint32) gdk_event->keyval; event.m_rawFlags = 0; +#if wxUSE_UNICODE + event.m_uniChar = gdk_keyval_to_unicode(gdk_event->keyval); +#endif + wxGetMousePosition( &x, &y ); + win->ScreenToClient( &x, &y ); event.m_x = x; event.m_y = y; event.SetEventObject( win ); @@ -1012,7 +1045,7 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event, : _T("press"), keysym); - long key_code = wxTranslateKeySymToWXKey(keysym, FALSE /* !isChar */); + long key_code = wxTranslateKeySymToWXKey(keysym, false /* !isChar */); if ( !key_code ) { @@ -1081,14 +1114,14 @@ wxTranslateGTKKeyEventToWx(wxKeyEvent& event, // sending unknown key events doesn't really make sense if ( !key_code ) - return FALSE; + return false; // now fill all the other fields wxFillOtherKeyEventFields(event, win, gdk_event); - + event.m_keyCode = key_code; - return TRUE; + return true; } @@ -1110,6 +1143,7 @@ struct wxGtkIMData }; #endif +extern "C" { static gint gtk_window_key_press_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindow *win ) @@ -1123,48 +1157,113 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, return FALSE; if (g_blockEventsOnDrag) return FALSE; - -#ifdef __WXGTK20__ - // We have to pass key press events through GTK+'s Input Method context - // object in order to get correct characters. By doing so, we loose the - // ability to let other GTK+'s handlers (namely, widgets' default signal - // handlers) handle the signal by returning false from this callback. - // Because GTK+ sends the events to parent widgets as well, we can't - // afford loosing it, otherwise native widgets inserted into wxPanel - // would break in subtle ways (e.g. spacebar would no longer toggle - // wxCheckButton's state). Therefore, we only pass the event to IM if it - // originated in this window's widget, which we detect by checking if we've - // seen the same event before (no events from children are lost this way, - // because gtk_window_key_press_callback is installed for native controls - // as well and the wxKeyEvent it creates propagates upwards). - static GdkEventKey s_lastEvent; - - bool useIM = (win->m_imData != NULL) && - memcmp(gdk_event, &s_lastEvent, sizeof(GdkEventKey)) != 0; - - s_lastEvent = *gdk_event; -#endif - + + wxKeyEvent event( wxEVT_KEY_DOWN ); - if ( !wxTranslateGTKKeyEventToWx(event, win, gdk_event) ) + bool ret = false; + bool return_after_IM = false; + + if( wxTranslateGTKKeyEventToWx(event, win, gdk_event) ) { - // unknown key pressed, ignore (the event would be useless anyhow) + // 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; + } + #ifdef __WXGTK20__ - if ( useIM ) + // 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) { - // it may be useful for the input method, though: - win->m_imData->lastKeyEvent = gdk_event; - bool ret = gtk_im_context_filter_keypress(win->m_imData->context, - gdk_event); - win->m_imData->lastKeyEvent = NULL; - return ret; + wxLogTrace(TRACE_KEYS, _T("Key event intercepted by IM")); + return true; } + } #endif - return FALSE; + if (return_after_IM) + return false; + +#ifndef __WXGTK20__ + // This is for GTK+ 1.2 only. The char event generatation for GTK+ 2.0 is done + // in the "commit" handler. + + // 2005.02.02 modified by Hong Jen Yee (hzysoft@sina.com.tw). + // In GTK+ 1.2, strings sent by IMs are also regarded as key_press events whose + // keyCodes cannot be recognized by wxWidgets. These MBCS strings, however, are + // composed of more than one character, which means gdk_event->length will always + // greater than one. When gtk_event->length == 1, this may be an ASCII character + // and can be translated by wx. However, when MBCS characters are sent by IM, + // gdk_event->length will >= 2. So neither should we pass it to accelerator table, + // nor should we pass it to controls. The following explanation was excerpted + // from GDK documentation. + // gint length : the length of string. + // gchar *string : a null-terminated multi-byte string containing the composed + // characters resulting from the key press. When text is being input, in a GtkEntry + // for example, it is these characters which should be added to the input buffer. + // When using Input Methods to support internationalized text input, the composed + // characters appear here after the pre-editing has been completed. + + if ( (!ret) && (gdk_event->length > 1) ) // If this event contains a pre-edited string from IM. + { + // We should translate this key event into wxEVT_CHAR not wxEVT_KEY_DOWN. + #if wxUSE_UNICODE // GTK+ 1.2 is not UTF-8 based. + const wxWCharBuffer string = wxConvLocal.cMB2WC( gdk_event->string ); + if( !string ) + return false; + #else + const char* string = gdk_event->string; + #endif + + // Implement OnCharHook by checking ancesteror top level windows + wxWindow *parent = win; + while (parent && !parent->IsTopLevel()) + parent = parent->GetParent(); + + for( const wxChar* pstr = string; *pstr; pstr++ ) + { + #if wxUSE_UNICODE + event.m_uniChar = *pstr; + // Backward compatible for ISO-8859-1 + event.m_keyCode = *pstr < 256 ? event.m_uniChar : 0; + #else + event.m_keyCode = *pstr; + #endif + if (parent) + { + event.SetEventType( wxEVT_CHAR_HOOK ); + ret = parent->GetEventHandler()->ProcessEvent( event ); + } + if (!ret) + { + event.SetEventType(wxEVT_CHAR); + win->GetEventHandler()->ProcessEvent( event ); + } + } + return true; } - // Emit KEY_DOWN event - bool ret = win->GetEventHandler()->ProcessEvent( event ); +#endif // #ifndef __WXGTK20__ #if wxUSE_ACCEL if (!ret) @@ -1190,41 +1289,22 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, // will only be sent if it is not in an accelerator table. if (!ret) { -#ifdef __WXGTK20__ - if (useIM) - { - // In GTK 2.0, we need to hand over the key event to an input method - // and the IM will emit a "commit" event containing the actual utf8 - // character. In that case the EVT_CHAR events will be sent from - // there. - win->m_imData->lastKeyEvent = gdk_event; - if ( gtk_im_context_filter_keypress(win->m_imData->context, - gdk_event) ) - { - win->m_imData->lastKeyEvent = NULL; - wxLogTrace(TRACE_KEYS, _T("Key event intercepted by IM")); - return TRUE; - } - else - win->m_imData->lastKeyEvent = NULL; - } -#endif - 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 */); + key_code = wxTranslateKeySymToWXKey(keysym, true /* isChar */); if ( !key_code ) { - if ( gdk_event->length == 1 ) - { - key_code = (unsigned char)gdk_event->string[0]; - } - else if ( wxIsAsciiKeysym(keysym) ) + 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 ) @@ -1251,6 +1331,10 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, } } + + + + // win is a control: tab can be propagated up if ( !ret && ((gdk_event->keyval == GDK_Tab) || (gdk_event->keyval == GDK_ISO_Left_Tab)) && @@ -1306,9 +1390,9 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, if ( btnCancel ) { - wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL); - event.SetEventObject(btnCancel); - ret = btnCancel->GetEventHandler()->ProcessEvent(event); + wxCommandEvent eventClick(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL); + eventClick.SetEventObject(btnCancel); + ret = btnCancel->GetEventHandler()->ProcessEvent(eventClick); } } @@ -1320,8 +1404,10 @@ static gint gtk_window_key_press_callback( GtkWidget *widget, return FALSE; } +} #ifdef __WXGTK20__ +extern "C" { static void gtk_wxwindow_commit_cb (GtkIMContext *context, const gchar *str, wxWindow *window) @@ -1337,24 +1423,13 @@ static void gtk_wxwindow_commit_cb (GtkIMContext *context, } #if wxUSE_UNICODE - event.m_uniChar = g_utf8_get_char( str ); - - // Backward compatible for ISO-8859 - if (event.m_uniChar < 256) - event.m_keyCode = event.m_uniChar; - wxLogTrace(TRACE_KEYS, _T("IM sent character '%c'"), event.m_uniChar); + const wxWCharBuffer data = wxConvUTF8.cMB2WC( (char*)str ); #else - wchar_t unistr[2]; - unistr[0] = g_utf8_get_char(str); - unistr[1] = 0; - wxCharBuffer ansistr(wxConvLocal.cWC2MB(unistr)); - // We cannot handle characters that cannot be represented in - // current locale's charset in non-Unicode mode: - if (ansistr.data() == NULL) - return; - event.m_keyCode = ansistr[0u]; - wxLogTrace(TRACE_KEYS, _T("IM sent character '%c'"), (wxChar)event.m_keyCode); + const wxWCharBuffer wdata = wxConvUTF8.cMB2WC( (char*)str ); + const wxCharBuffer data = wxConvLocal.cWC2MB( wdata ); #endif // wxUSE_UNICODE + if( !(const wxChar*)data ) + return; bool ret = false; @@ -1362,18 +1437,31 @@ static void gtk_wxwindow_commit_cb (GtkIMContext *context, wxWindow *parent = window; while (parent && !parent->IsTopLevel()) parent = parent->GetParent(); - if (parent) - { - event.SetEventType( wxEVT_CHAR_HOOK ); - ret = parent->GetEventHandler()->ProcessEvent( event ); - } - if (!ret) + for( const wxChar* pstr = data; *pstr; pstr++ ) { - event.SetEventType(wxEVT_CHAR); - ret = window->GetEventHandler()->ProcessEvent( event ); +#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 + if (parent) + { + event.SetEventType( wxEVT_CHAR_HOOK ); + ret = parent->GetEventHandler()->ProcessEvent( event ); + } + + if (!ret) + { + event.SetEventType(wxEVT_CHAR); + ret = window->GetEventHandler()->ProcessEvent( event ); + } } } +} #endif @@ -1381,6 +1469,7 @@ static void gtk_wxwindow_commit_cb (GtkIMContext *context, // "key_release_event" from any window //----------------------------------------------------------------------------- +extern "C" { static gint gtk_window_key_release_callback( GtkWidget *widget, GdkEventKey *gdk_event, wxWindowGTK *win ) @@ -1409,6 +1498,7 @@ static gint gtk_window_key_release_callback( GtkWidget *widget, gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "key_release_event" ); return TRUE; } +} // ============================================================================ // the mouse events @@ -1552,6 +1642,7 @@ wxWindowGTK *FindWindowForMouseEvent(wxWindowGTK *win, wxCoord& x, wxCoord& y) // "button_press_event" //----------------------------------------------------------------------------- +extern "C" { static gint gtk_window_button_press_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindowGTK *win ) @@ -1610,6 +1701,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, // 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 @@ -1703,30 +1795,15 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, // a chance to correct this win->FixUpMouseEvent(widget, event.m_x, event.m_y); - 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 MSW 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())); - (void)win->GetEventHandler()->ProcessEvent(evtCtx); - } - // find the correct window to send the event too: it may be a different one // from the one which got it at GTK+ level because some control 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); +#ifndef __WXGTK20__ gs_timeLastClick = gdk_event->time; -#ifndef __WXGTK20__ if (event_type == wxEVT_LEFT_DCLICK) { // GTK 1.2 crashes when intercepting double @@ -1738,7 +1815,7 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, return FALSE; } } -#endif +#endif // !__WXGTK20__ if (win->GetEventHandler()->ProcessEvent( event )) { @@ -1746,13 +1823,32 @@ static gint gtk_window_button_press_callback( GtkWidget *widget, return TRUE; } + 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->GetEventHandler()->ProcessEvent(evtCtx); + } + return FALSE; } +} //----------------------------------------------------------------------------- // "button_release_event" //----------------------------------------------------------------------------- +extern "C" { static gint gtk_window_button_release_callback( GtkWidget *widget, GdkEventButton *gdk_event, wxWindowGTK *win ) @@ -1808,11 +1904,13 @@ static gint gtk_window_button_release_callback( GtkWidget *widget, return FALSE; } +} //----------------------------------------------------------------------------- // "motion_notify_event" //----------------------------------------------------------------------------- +extern "C" { static gint gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxWindowGTK *win ) @@ -1862,11 +1960,11 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, // the mouse changed window g_captureWindowHasMouse = hasMouse; - wxMouseEvent event(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW - : wxEVT_LEAVE_WINDOW); - InitMouseEvent(win, event, gdk_event); - event.SetEventObject(win); - win->GetEventHandler()->ProcessEvent(event); + wxMouseEvent eventM(g_captureWindowHasMouse ? wxEVT_ENTER_WINDOW + : wxEVT_LEAVE_WINDOW); + InitMouseEvent(win, eventM, gdk_event); + eventM.SetEventObject(win); + win->GetEventHandler()->ProcessEvent(eventM); } } else // no capture @@ -1882,15 +1980,17 @@ static gint gtk_window_motion_notify_callback( GtkWidget *widget, return FALSE; } +} #ifdef __WXGTK20__ //----------------------------------------------------------------------------- // "mouse_wheel_event" //----------------------------------------------------------------------------- +extern "C" { static gint gtk_window_wheel_callback (GtkWidget * widget, - GdkEventScroll * gdk_event, - wxWindowGTK * win) + GdkEventScroll * gdk_event, + wxWindowGTK * win) { DEBUG_MAIN_THREAD @@ -1904,7 +2004,7 @@ static gint gtk_window_wheel_callback (GtkWidget * widget, event_type = wxEVT_MOUSEWHEEL; else return FALSE; - + wxMouseEvent event( event_type ); // Can't use InitMouse macro because scroll events don't have button event.SetTimestamp( gdk_event->time ); @@ -1929,7 +2029,7 @@ static gint gtk_window_wheel_callback (GtkWidget * widget, event.SetEventObject( win ); event.SetId( win->GetId() ); event.SetTimestamp( gdk_event->time ); - + if (win->GetEventHandler()->ProcessEvent( event )) { gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "scroll_event" ); @@ -1938,7 +2038,23 @@ static gint gtk_window_wheel_callback (GtkWidget * widget, return FALSE; } -#endif +} + +//----------------------------------------------------------------------------- +// "popup-menu" +//----------------------------------------------------------------------------- +extern "C" { +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->GetEventHandler()->ProcessEvent(event); +} +} +#endif // __WXGTK20__ //----------------------------------------------------------------------------- // "focus_in_event" @@ -1959,6 +2075,7 @@ static bool DoSendFocusEvents(wxWindow *win) return win->GetEventHandler()->ProcessEvent(eventFocus); } +extern "C" { static gint gtk_window_focus_in_callback( GtkWidget *widget, GdkEvent *WXUNUSED(event), wxWindow *win ) @@ -1973,23 +2090,6 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, gtk_im_context_focus_in(win->m_imData->context); #endif - if (!win->m_hasVMT) return FALSE; - if (g_blockEventsOnDrag) return FALSE; - - switch ( g_sendActivateEvent ) - { - case -1: - // we've got focus from outside, synthetize wxActivateEvent - g_sendActivateEvent = 1; - break; - - case 0: - // another our window just lost focus, it was already ours before - // - don't send any wxActivateEvent - g_sendActivateEvent = -1; - break; - } - g_focusWindowLast = g_focusWindow = win; @@ -2010,35 +2110,11 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, } #endif // wxUSE_CARET - g_activeFrameLostFocus = FALSE; - - wxWindowGTK *active = wxGetTopLevelParent(win); - if ( active != g_activeFrame ) - { - if ( g_activeFrame ) - { - wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from focus_in)"), g_activeFrame); - wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId()); - event.SetEventObject(g_activeFrame); - g_activeFrame->GetEventHandler()->ProcessEvent(event); - } - - wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), active); - g_activeFrame = active; - wxActivateEvent event(wxEVT_ACTIVATE, TRUE, g_activeFrame->GetId()); - event.SetEventObject(g_activeFrame); - g_activeFrame->GetEventHandler()->ProcessEvent(event); - - // Don't send focus events in addition to activate - // if (win == g_activeFrame) - // return TRUE; - } - // does the window itself think that it has the focus? if ( !win->m_hasFocus ) { // not yet, notify it - win->m_hasFocus = TRUE; + win->m_hasFocus = true; if ( DoSendFocusEvents(win) ) { @@ -2049,11 +2125,13 @@ static gint gtk_window_focus_in_callback( GtkWidget *widget, return FALSE; } +} //----------------------------------------------------------------------------- // "focus_out_event" //----------------------------------------------------------------------------- +extern "C" { static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk_event, wxWindowGTK *win ) { DEBUG_MAIN_THREAD @@ -2066,29 +2144,9 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk gtk_im_context_focus_out(win->m_imData->context); #endif - if (!win->m_hasVMT) return FALSE; - if (g_blockEventsOnDrag) return FALSE; - wxLogTrace( TRACE_FOCUS, _T("%s: focus out"), win->GetName().c_str() ); - if ( !g_activeFrameLostFocus && g_activeFrame ) - { - // VZ: commenting this out because it does happen (although not easy - // to reproduce, I only see it when using wxMiniFrame and not - // always) and makes using Mahogany quite annoying -#if 0 - wxASSERT_MSG( wxGetTopLevelParent(win) == g_activeFrame, - wxT("unfocusing window that hasn't gained focus properly") ); -#endif // 0 - - g_activeFrameLostFocus = TRUE; - } - - // if the focus goes out of our app alltogether, OnIdle() will send - // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset - // g_sendActivateEvent to -1 - g_sendActivateEvent = 0; wxWindowGTK *winFocus = wxFindFocusedChild(win); if ( winFocus ) @@ -2114,25 +2172,27 @@ static gint gtk_window_focus_out_callback( GtkWidget *widget, GdkEventFocus *gdk // have focus already if ( win->m_hasFocus ) { - win->m_hasFocus = FALSE; + win->m_hasFocus = false; wxFocusEvent event( wxEVT_KILL_FOCUS, win->GetId() ); event.SetEventObject( win ); - if (win->GetEventHandler()->ProcessEvent( event )) - { - gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus_out_event" ); - return TRUE; - } + // even if we did process the event in wx code, still let GTK itself + // process it too as otherwise bad things happen, especially in GTK2 + // where the text control simply aborts the program if it doesn't get + // the matching focus out event + (void)win->GetEventHandler()->ProcessEvent( event ); } return FALSE; } +} //----------------------------------------------------------------------------- // "enter_notify_event" //----------------------------------------------------------------------------- +extern "C" { static gint gtk_window_enter_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, @@ -2171,11 +2231,13 @@ gint gtk_window_enter_callback( GtkWidget *widget, return FALSE; } +} //----------------------------------------------------------------------------- // "leave_notify_event" //----------------------------------------------------------------------------- +extern "C" { static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_event, wxWindowGTK *win ) { DEBUG_MAIN_THREAD @@ -2221,11 +2283,13 @@ static gint gtk_window_leave_callback( GtkWidget *widget, GdkEventCrossing *gdk_ return FALSE; } +} //----------------------------------------------------------------------------- // "value_changed" from m_vAdjust //----------------------------------------------------------------------------- +extern "C" { static void gtk_window_vscroll_callback( GtkAdjustment *adjust, SCROLLBAR_CBACK_ARG wxWindowGTK *win ) @@ -2255,11 +2319,13 @@ static void gtk_window_vscroll_callback( GtkAdjustment *adjust, event.SetEventObject( win ); win->GetEventHandler()->ProcessEvent( event ); } +} //----------------------------------------------------------------------------- // "value_changed" from m_hAdjust //----------------------------------------------------------------------------- +extern "C" { static void gtk_window_hscroll_callback( GtkAdjustment *adjust, SCROLLBAR_CBACK_ARG wxWindowGTK *win ) @@ -2288,11 +2354,13 @@ static void gtk_window_hscroll_callback( GtkAdjustment *adjust, event.SetEventObject( win ); win->GetEventHandler()->ProcessEvent( event ); } +} //----------------------------------------------------------------------------- // "button_press_event" from scrollbar //----------------------------------------------------------------------------- +extern "C" { static gint gtk_scrollbar_button_press_callback( GtkRange *widget, GdkEventButton *gdk_event, wxWindowGTK *win) @@ -2303,7 +2371,7 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *widget, wxapp_install_idle_handler(); - g_blockEventsOnScroll = TRUE; + g_blockEventsOnScroll = true; // FIXME: there is no 'slider' field in GTK+ 2.0 any more #ifndef __WXGTK20__ @@ -2312,11 +2380,13 @@ static gint gtk_scrollbar_button_press_callback( GtkRange *widget, return FALSE; } +} //----------------------------------------------------------------------------- // "button_release_event" from scrollbar //----------------------------------------------------------------------------- +extern "C" { static gint gtk_scrollbar_button_release_callback( GtkRange *widget, GdkEventButton *WXUNUSED(gdk_event), wxWindowGTK *win) @@ -2328,7 +2398,7 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *widget, // // if (gdk_event->window != widget->slider) return FALSE; - g_blockEventsOnScroll = FALSE; + g_blockEventsOnScroll = false; if (win->m_isScrolling) { @@ -2353,23 +2423,23 @@ static gint gtk_scrollbar_button_release_callback( GtkRange *widget, win->GetEventHandler()->ProcessEvent( event ); } - win->m_isScrolling = FALSE; + win->m_isScrolling = false; return FALSE; } +} // ---------------------------------------------------------------------------- // this wxWindowBase function is implemented here (in platform-specific file) // because it is static and so couldn't be made virtual // ---------------------------------------------------------------------------- -wxWindow *wxWindowBase::FindFocus() +wxWindow *wxWindowBase::DoFindFocus() { // the cast is necessary when we compile in wxUniversal mode return (wxWindow *)g_focusWindow; } - //----------------------------------------------------------------------------- // "realize" from m_widget //----------------------------------------------------------------------------- @@ -2377,6 +2447,7 @@ wxWindow *wxWindowBase::FindFocus() /* We cannot set colours and fonts before the widget has been realized, so we do this directly after realization. */ +extern "C" { static gint gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win ) { @@ -2384,7 +2455,7 @@ gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win ) if (g_isIdle) wxapp_install_idle_handler(); - + #ifdef __WXGTK20__ if (win->m_imData) { @@ -2400,11 +2471,13 @@ gtk_window_realized_callback( GtkWidget *m_widget, wxWindow *win ) return FALSE; } +} //----------------------------------------------------------------------------- // "size_allocate" //----------------------------------------------------------------------------- +extern "C" { static void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation *WXUNUSED(alloc), @@ -2431,6 +2504,7 @@ void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), win->GetEventHandler()->ProcessEvent( event ); } } +} #ifdef HAVE_XIM @@ -2441,6 +2515,7 @@ void gtk_window_size_callback( GtkWidget *WXUNUSED(widget), /* Resize XIM window */ +extern "C" { static void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget), GtkAllocation* WXUNUSED_UNLESS_XIM(alloc), @@ -2464,6 +2539,7 @@ void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget), } #endif // HAVE_XIM } +} //----------------------------------------------------------------------------- // "realize" from m_wxwindow @@ -2471,6 +2547,7 @@ void gtk_wxwindow_size_callback( GtkWidget* WXUNUSED_UNLESS_XIM(widget), /* Initialize XIM support */ +extern "C" { static gint gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget), wxWindowGTK * WXUNUSED_UNLESS_XIM(win) ) @@ -2557,6 +2634,7 @@ gtk_wxwindow_realized_callback( GtkWidget * WXUNUSED_UNLESS_XIM(widget), return FALSE; } +} //----------------------------------------------------------------------------- // InsertChild for wxWindowGTK. @@ -2619,16 +2697,16 @@ void wxWindowGTK::Init() m_width = 0; m_height = 0; - m_sizeSet = FALSE; - m_hasVMT = FALSE; - m_needParent = TRUE; - m_isBeingDeleted = FALSE; + m_sizeSet = false; + m_hasVMT = false; + m_needParent = true; + m_isBeingDeleted = false; - m_noExpose = FALSE; - m_nativeSizeEvent = FALSE; + m_noExpose = false; + m_nativeSizeEvent = false; - m_hasScrolling = FALSE; - m_isScrolling = FALSE; + m_hasScrolling = false; + m_isScrolling = false; m_hAdjust = (GtkAdjustment*) NULL; m_vAdjust = (GtkAdjustment*) NULL; @@ -2637,14 +2715,14 @@ void wxWindowGTK::Init() m_oldClientWidth = m_oldClientHeight = 0; - m_resizing = FALSE; + m_resizing = false; m_insertCallback = (wxInsertChildFunction) NULL; - m_acceptsFocus = FALSE; - m_hasFocus = FALSE; + m_acceptsFocus = false; + m_hasFocus = false; - m_clipPaintRegion = FALSE; + m_clipPaintRegion = false; m_needsStyleChange = false; @@ -2690,7 +2768,7 @@ bool wxWindowGTK::Create( wxWindow *parent, !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) { wxFAIL_MSG( wxT("wxWindowGTK creation failed") ); - return FALSE; + return false; } m_insertCallback = wxInsertChildInWindow; @@ -2734,7 +2812,7 @@ bool wxWindowGTK::Create( wxWindow *parent, gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow ); GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS ); - m_acceptsFocus = TRUE; + m_acceptsFocus = true; // I _really_ don't want scrollbars in the beginning m_vAdjust->lower = 0.0; @@ -2786,7 +2864,7 @@ bool wxWindowGTK::Create( wxWindow *parent, PostCreation(); - return TRUE; + return true; } wxWindowGTK::~wxWindowGTK() @@ -2796,20 +2874,28 @@ wxWindowGTK::~wxWindowGTK() if (g_focusWindow == this) g_focusWindow = NULL; - if (g_activeFrame == this) - g_activeFrame = NULL; - if ( g_delayedFocus == this ) g_delayedFocus = NULL; - m_isBeingDeleted = TRUE; - m_hasVMT = FALSE; - - if (m_widget) - Show( FALSE ); + 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) + { + gtk_signal_disconnect_by_func( GTK_OBJECT(m_focusWidget), + (GtkSignalFunc) gtk_window_focus_in_callback, (gpointer) this ); + gtk_signal_disconnect_by_func( GTK_OBJECT(m_focusWidget), + (GtkSignalFunc) gtk_window_focus_out_callback, (gpointer) this ); + } + + if (m_widget) + Show( false ); + #ifdef HAVE_XIM if (m_ic) gdk_ic_destroy (m_ic); @@ -2817,6 +2903,11 @@ wxWindowGTK::~wxWindowGTK() gdk_ic_attr_destroy (m_icattr); #endif +#ifdef __WXGTK20__ + // delete before the widgets to avoid a crash on solaris + delete m_imData; +#endif + if (m_wxwindow) { gtk_widget_destroy( m_wxwindow ); @@ -2828,15 +2919,11 @@ wxWindowGTK::~wxWindowGTK() gtk_widget_destroy( m_widget ); m_widget = (GtkWidget*) NULL; } - -#ifdef __WXGTK20__ - delete m_imData; -#endif } bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size ) { - wxCHECK_MSG( !m_needParent || parent, FALSE, wxT("Need complete parent.") ); + wxCHECK_MSG( !m_needParent || parent, false, wxT("Need complete parent.") ); // Use either the given size, or the default if -1 is given. // See wxWindowBase for these functions. @@ -2846,7 +2933,7 @@ bool wxWindowGTK::PreCreation( wxWindowGTK *parent, const wxPoint &pos, const w m_x = (int)pos.x; m_y = (int)pos.y; - return TRUE; + return true; } void wxWindowGTK::PostCreation() @@ -2901,14 +2988,17 @@ void wxWindowGTK::PostCreation() // focus handling - if (m_focusWidget == NULL) - m_focusWidget = m_widget; + if (!GTK_IS_WINDOW(m_widget)) + { + if (m_focusWidget == NULL) + m_focusWidget = m_widget; - gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event", - GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this ); + gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_in_event", + GTK_SIGNAL_FUNC(gtk_window_focus_in_callback), (gpointer)this ); - gtk_signal_connect( GTK_OBJECT(m_focusWidget), "focus_out_event", - GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this ); + gtk_signal_connect_after( GTK_OBJECT(m_focusWidget), "focus_out_event", + GTK_SIGNAL_FUNC(gtk_window_focus_out_callback), (gpointer)this ); + } // connect to the various key and mouse handlers @@ -2936,13 +3026,20 @@ void wxWindowGTK::PostCreation() GTK_SIGNAL_FUNC(gtk_wxwindow_size_callback), (gpointer)this ); } - if ( !GTK_IS_COMBO(m_widget)) + if (GTK_IS_COMBO(m_widget)) + { + GtkCombo *gcombo = GTK_COMBO(m_widget); + + gtk_signal_connect( GTK_OBJECT(gcombo->entry), "size_request", + GTK_SIGNAL_FUNC(wxgtk_combo_size_request_callback), + (gpointer) this ); + } + else { // This is needed if we want to add our windows into native - // GTK control, such as the toolbar. With this callback, the + // 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. FIXME - // when moving to GTK 2.0. + // programmer). Sadly, it misbehaves for wxComboBox. gtk_signal_connect( GTK_OBJECT(m_widget), "size_request", GTK_SIGNAL_FUNC(wxgtk_window_size_request_callback), (gpointer) this ); @@ -2950,7 +3047,7 @@ void wxWindowGTK::PostCreation() InheritAttributes(); - m_hasVMT = TRUE; + m_hasVMT = true; // unless the window was created initially hidden (i.e. Hide() had been // called before Create()), we should show it at GTK+ level as well @@ -2978,6 +3075,8 @@ void wxWindowGTK::ConnectWidget( GtkWidget *widget ) #ifdef __WXGTK20__ gtk_signal_connect( GTK_OBJECT(widget), "scroll_event", GTK_SIGNAL_FUNC(gtk_window_wheel_callback), (gpointer)this ); + g_signal_connect(widget, "popup_menu", + G_CALLBACK(wxgtk_window_popup_menu_callback), this); #endif gtk_signal_connect( GTK_OBJECT(widget), "enter_notify_event", @@ -2991,7 +3090,7 @@ bool wxWindowGTK::Destroy() { wxASSERT_MSG( (m_widget != NULL), wxT("invalid window") ); - m_hasVMT = FALSE; + m_hasVMT = false; return wxWindowBase::Destroy(); } @@ -3011,7 +3110,7 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags */ if (m_resizing) return; /* I don't like recursions */ - m_resizing = TRUE; + m_resizing = true; int currentX, currentY; GetPosition(¤tX, ¤tY); @@ -3069,22 +3168,37 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth; if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight; - int border = 0; + int left_border = 0; + int right_border = 0; + int top_border = 0; int bottom_border = 0; -#ifndef __WXGTK20__ + /* the default button has a border around it */ if (GTK_WIDGET_CAN_DEFAULT(m_widget)) { - /* the default button has a border around it */ - border = 6; +#ifdef __WXGTK20__ + 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 ); + } +#else + left_border = 6; + right_border = 6; + top_border = 6; bottom_border = 5; - } #endif + } - DoMoveWindow( m_x-border, - m_y-border, - m_width+2*border, - m_height+border+bottom_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) @@ -3112,7 +3226,7 @@ void wxWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags GetEventHandler()->ProcessEvent( event ); } - m_resizing = FALSE; + m_resizing = false; } void wxWindowGTK::OnInternalIdle() @@ -3132,30 +3246,6 @@ void wxWindowGTK::OnInternalIdle() // Update invalidated regions. GtkUpdate(); - // Synthetize activate events. - if ( g_sendActivateEvent != -1 ) - { - bool activate = g_sendActivateEvent != 0; - - // do it only once - g_sendActivateEvent = -1; - - wxTheApp->SetActive(activate, (wxWindow *)g_focusWindowLast); - } - - if ( g_activeFrameLostFocus ) - { - if ( g_activeFrame ) - { - wxLogTrace(wxT("activate"), wxT("Deactivating frame %p (from idle)"), g_activeFrame); - wxActivateEvent event(wxEVT_ACTIVATE, FALSE, g_activeFrame->GetId()); - event.SetEventObject(g_activeFrame); - g_activeFrame->GetEventHandler()->ProcessEvent(event); - g_activeFrame = NULL; - } - g_activeFrameLostFocus = FALSE; - } - wxCursor cursor = m_cursor; if (g_globalCursor.Ok()) cursor = g_globalCursor; @@ -3414,12 +3504,12 @@ void wxWindowGTK::DoScreenToClient( int *x, int *y ) const bool wxWindowGTK::Show( bool show ) { - wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); + wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") ); if (!wxWindowBase::Show(show)) { // nothing to do - return FALSE; + return false; } if (show) @@ -3428,11 +3518,11 @@ bool wxWindowGTK::Show( bool show ) gtk_widget_hide( m_widget ); wxShowEvent eventShow(GetId(), show); - eventShow.m_eventObject = this; + eventShow.SetEventObject(this); GetEventHandler()->ProcessEvent(eventShow); - return TRUE; + return true; } static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable) @@ -3454,12 +3544,12 @@ static void wxWindowNotifyEnable(wxWindowGTK* win, bool enable) bool wxWindowGTK::Enable( bool enable ) { - wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); + wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") ); if (!wxWindowBase::Enable(enable)) { // nothing to do - return FALSE; + return false; } gtk_widget_set_sensitive( m_widget, enable ); @@ -3468,7 +3558,7 @@ bool wxWindowGTK::Enable( bool enable ) wxWindowNotifyEnable(this, enable); - return TRUE; + return true; } int wxWindowGTK::GetCharHeight() const @@ -3540,17 +3630,17 @@ int wxWindowGTK::GetCharWidth() const } void wxWindowGTK::GetTextExtent( const wxString& string, - int *x, - int *y, - int *descent, - int *externalLeading, - const wxFont *theFont ) const + int *x, + int *y, + int *descent, + int *externalLeading, + const wxFont *theFont ) const { wxFont fontToUse = theFont ? *theFont : GetFont(); wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") ); - if (string.IsEmpty()) + if (string.empty()) { if (x) (*x) = 0; if (y) (*y) = 0; @@ -3625,8 +3715,16 @@ void wxWindowGTK::SetFocus() } else if (m_widget) { +#ifdef __WXGTK20__ + if (GTK_IS_CONTAINER(m_widget)) + { + gtk_widget_child_focus( m_widget, GTK_DIR_TAB_FORWARD ); + } + else +#endif if (GTK_WIDGET_CAN_FOCUS(m_widget) && !GTK_WIDGET_HAS_FOCUS (m_widget) ) { + if (!GTK_WIDGET_REALIZED(m_widget)) { // we can't set the focus to the widget now so we remember that @@ -3647,11 +3745,14 @@ void wxWindowGTK::SetFocus() gtk_widget_grab_focus (m_widget); } } - else if (GTK_IS_CONTAINER(m_widget)) + else +#ifndef __WXGTK20__ + if (GTK_IS_CONTAINER(m_widget)) { - SET_CONTAINER_FOCUS( m_widget, GTK_DIR_TAB_FORWARD ); + gtk_container_focus( GTK_CONTAINER(m_widget), GTK_DIR_TAB_FORWARD ); } else +#endif { wxLogTrace(TRACE_FOCUS, _T("Can't set focus to %s(%s)"), @@ -3667,7 +3768,7 @@ bool wxWindowGTK::AcceptsFocus() const bool wxWindowGTK::Reparent( wxWindowBase *newParentBase ) { - wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); + wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") ); wxWindowGTK *oldParent = m_parent, *newParent = (wxWindowGTK *)newParentBase; @@ -3675,7 +3776,7 @@ bool wxWindowGTK::Reparent( wxWindowBase *newParentBase ) wxASSERT( GTK_IS_WIDGET(m_widget) ); if ( !wxWindowBase::Reparent(newParent) ) - return FALSE; + return false; wxASSERT( GTK_IS_WIDGET(m_widget) ); @@ -3698,7 +3799,7 @@ bool wxWindowGTK::Reparent( wxWindowBase *newParentBase ) /* reverse: prevent GTK from deleting the widget arbitrarily */ gtk_widget_unref( m_widget ); - return TRUE; + return true; } void wxWindowGTK::DoAddChild(wxWindowGTK *child) @@ -3733,7 +3834,7 @@ void wxWindowGTK::RemoveChild(wxWindowBase *child) if (g_isIdle) wxapp_install_idle_handler(); } - + void wxWindowGTK::DoMoveInTabOrder(wxWindow *win, MoveKind move) { wxWindowBase::DoMoveInTabOrder(win, move); @@ -3749,15 +3850,15 @@ void wxWindowGTK::RealizeTabOrder() if (m_children.size() > 0) { GList *chain = NULL; - + for (wxWindowList::const_iterator i = m_children.begin(); i != m_children.end(); ++i) { chain = g_list_prepend(chain, (*i)->m_widget); } - + chain = g_list_reverse(chain); - + gtk_container_set_focus_chain(GTK_CONTAINER(m_wxwindow), chain); g_list_free(chain); } @@ -3766,7 +3867,7 @@ void wxWindowGTK::RealizeTabOrder() gtk_container_unset_focus_chain(GTK_CONTAINER(m_wxwindow)); } } - + m_dirtyTabOrder = false; } @@ -3776,26 +3877,36 @@ void wxWindowGTK::Raise() { wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - if (!m_widget->window) return; - - gdk_window_raise( m_widget->window ); + if (m_wxwindow && m_wxwindow->window) + { + gdk_window_raise( m_wxwindow->window ); + } + else if (m_widget->window) + { + gdk_window_raise( m_widget->window ); + } } void wxWindowGTK::Lower() { wxCHECK_RET( (m_widget != NULL), wxT("invalid window") ); - if (!m_widget->window) return; - - gdk_window_lower( m_widget->window ); + if (m_wxwindow && m_wxwindow->window) + { + gdk_window_lower( m_wxwindow->window ); + } + else if (m_widget->window) + { + gdk_window_lower( m_widget->window ); + } } bool wxWindowGTK::SetCursor( const wxCursor &cursor ) { - wxCHECK_MSG( (m_widget != NULL), FALSE, wxT("invalid window") ); + wxCHECK_MSG( (m_widget != NULL), false, wxT("invalid window") ); if (cursor == m_cursor) - return FALSE; + return false; if (g_isIdle) wxapp_install_idle_handler(); @@ -3826,35 +3937,38 @@ void wxWindowGTK::WarpPointer( int x, int y ) void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect ) { - if (!m_widget) return; - if (!m_widget->window) return; + if (!m_widget) + return; + if (!m_widget->window) + return; #ifndef __WXGTK20__ if (g_isIdle) wxapp_install_idle_handler(); - wxRect myRect(0,0,0,0); + wxRect myRect; if (m_wxwindow && rect) { myRect.SetSize(wxSize( m_wxwindow->allocation.width, m_wxwindow->allocation.height)); - myRect.Intersect(*rect); - if (!myRect.width || !myRect.height) + if ( myRect.Intersect(*rect).IsEmpty() ) + { // nothing to do, rectangle is empty return; + } + rect = &myRect; } + // schedule the area for later updating in GtkUpdate() if (eraseBackground && m_wxwindow && m_wxwindow->window) { if (rect) { - // Schedule for later Updating in ::Update() or ::OnInternalIdle(). m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height ); } else { - // Schedule for later Updating in ::Update() or ::OnInternalIdle(). m_clearRegion.Clear(); m_clearRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height ); } @@ -3864,7 +3978,6 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect ) { if (m_wxwindow) { - // Schedule for later Updating in ::Update() or ::OnInternalIdle(). m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height ); } else @@ -3881,7 +3994,6 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect ) { if (m_wxwindow) { - // Schedule for later Updating in ::Update() or ::OnInternalIdle(). m_updateRegion.Clear(); m_updateRegion.Union( 0, 0, m_wxwindow->allocation.width, m_wxwindow->allocation.height ); } @@ -3890,29 +4002,38 @@ void wxWindowGTK::Refresh( bool eraseBackground, const wxRect *rect ) gtk_widget_draw( m_widget, (GdkRectangle*) NULL ); } } -#else +#else // GTK+ 2 if (m_wxwindow) { + GdkRectangle gdk_rect, + *p; if (rect) { - GdkRectangle gdk_rect; gdk_rect.x = rect->x; gdk_rect.y = rect->y; gdk_rect.width = rect->width; gdk_rect.height = rect->height; - gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, &gdk_rect, TRUE ); + p = &gdk_rect; } - else + else // invalidate everything { - gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, NULL, TRUE ); + p = NULL; } + + gdk_window_invalidate_rect( GTK_PIZZA(m_wxwindow)->bin_window, p, TRUE ); } -#endif +#endif // GTK+ 1/2 } void wxWindowGTK::Update() { GtkUpdate(); + + // when we call Update() we really want to update the window immediately on + // screen, even if itmeans flushing the entire queue and hence slowing down + // everything -- but it should still be done, it's just that Update() should + // be called very rarely + gdk_flush(); } void wxWindowGTK::GtkUpdate() @@ -3924,6 +4045,16 @@ void wxWindowGTK::GtkUpdate() if (!m_updateRegion.IsEmpty()) GtkSendPaintEvents(); #endif + + // for consistency with other platforms (and also because it's convenient + // to be able to update an entire TLW by calling Update() only once), we + // should also update all our children here + for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); + node; + node = node->GetNext() ) + { + node->GetData()->GtkUpdate(); + } } void wxWindowGTK::GtkSendPaintEvents() @@ -3938,39 +4069,40 @@ void wxWindowGTK::GtkSendPaintEvents() } // Clip to paint region in wxClientDC - m_clipPaintRegion = TRUE; + m_clipPaintRegion = true; // widget to draw on GtkPizza *pizza = GTK_PIZZA (m_wxwindow); - if (GetThemeEnabled() && GetBackgroundStyle() != wxBG_STYLE_CUSTOM) + if (GetThemeEnabled() && (GetBackgroundStyle() == wxBG_STYLE_SYSTEM)) { // find ancestor from which to steal background - wxWindow *parent = GetParent(); - while (parent && !parent->IsTopLevel()) - parent = parent->GetParent(); + wxWindow *parent = wxGetTopLevelParent((wxWindow *)this); if (!parent) parent = (wxWindow*)this; - wxRegionIterator upd( m_updateRegion ); - while (upd) + if (GTK_WIDGET_MAPPED(parent->m_widget)) { - GdkRectangle rect; - rect.x = upd.GetX(); - rect.y = upd.GetY(); - rect.width = upd.GetWidth(); - rect.height = upd.GetHeight(); - - gtk_paint_flat_box( parent->m_widget->style, - pizza->bin_window, - (GtkStateType)GTK_WIDGET_STATE(m_wxwindow), - GTK_SHADOW_NONE, - &rect, - parent->m_widget, - (char *)"base", - 0, 0, -1, -1 ); - - upd ++; + wxRegionIterator upd( m_updateRegion ); + while (upd) + { + GdkRectangle rect; + rect.x = upd.GetX(); + rect.y = upd.GetY(); + rect.width = upd.GetWidth(); + rect.height = upd.GetHeight(); + + gtk_paint_flat_box( parent->m_widget->style, + pizza->bin_window, + (GtkStateType)GTK_WIDGET_STATE(m_wxwindow), + GTK_SHADOW_NONE, + &rect, + parent->m_widget, + (char *)"base", + 0, 0, -1, -1 ); + + ++upd; + } } } else @@ -4026,10 +4158,9 @@ void wxWindowGTK::GtkSendPaintEvents() paint_event.SetEventObject( this ); GetEventHandler()->ProcessEvent( paint_event ); - m_clipPaintRegion = FALSE; + m_clipPaintRegion = false; -#ifndef __WXUNIVERSAL__ -#ifndef __WXGTK20__ +#if !defined(__WXUNIVERSAL__) && !defined(__WXGTK20__) // The following code will result in all window-less widgets // being redrawn because the wxWidgets class is allowed to // paint over the window-less widgets. @@ -4050,6 +4181,7 @@ void wxWindowGTK::GtkSendPaintEvents() gdk_event.type = GDK_EXPOSE; gdk_event.window = pizza->bin_window; gdk_event.count = 0; + gdk_event.send_event = TRUE; wxRegionIterator upd( m_updateRegion ); while (upd) @@ -4069,8 +4201,7 @@ void wxWindowGTK::GtkSendPaintEvents() } } } -#endif -#endif +#endif // native GTK 1 m_updateRegion.Clear(); } @@ -4110,7 +4241,7 @@ void wxWindowGTK::ApplyToolTip( GtkTooltips *tips, const wxChar *tip ) bool wxWindowGTK::SetBackgroundColour( const wxColour &colour ) { - wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); + wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") ); if (!wxWindowBase::SetBackgroundColour(colour)) return false; @@ -4131,13 +4262,13 @@ bool wxWindowGTK::SetBackgroundColour( const wxColour &colour ) bool wxWindowGTK::SetForegroundColour( const wxColour &colour ) { - wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); + wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") ); if (!wxWindowBase::SetForegroundColour(colour)) { return false; } - + if (colour.Ok()) { // We need the pixel value e.g. for background clearing. @@ -4157,15 +4288,13 @@ PangoContext *wxWindowGTK::GtkGetPangoDefaultContext() return gtk_widget_get_pango_context( m_widget ); } +// MR: Returns the same as GtkGetPangoDefaultContext until the symbol can be removed in 2.7.x PangoContext *wxWindowGTK::GtkGetPangoX11Context() { - if (!m_x11Context) - m_x11Context = pango_x_get_context( gdk_display ); - - return m_x11Context; + return gtk_widget_get_pango_context( m_widget ); } #endif - + GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle) { // do we need to apply any changes at all? @@ -4181,7 +4310,7 @@ GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle) if ( m_font.Ok() ) { #ifdef __WXGTK20__ - style->font_desc = + style->font_desc = pango_font_description_copy( m_font.GetNativeFontInfo()->description ); #else wxString xfontname = m_font.GetNativeFontInfo()->GetXFontName(); @@ -4192,13 +4321,13 @@ GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle) if ( m_foregroundColour.Ok() ) { GdkColor *fg = m_foregroundColour.GetColor(); - + style->fg[GTK_STATE_NORMAL] = *fg; style->color_flags[GTK_STATE_NORMAL] = GTK_RC_FG; - + style->fg[GTK_STATE_PRELIGHT] = *fg; style->color_flags[GTK_STATE_PRELIGHT] = GTK_RC_FG; - + style->fg[GTK_STATE_ACTIVE] = *fg; style->color_flags[GTK_STATE_ACTIVE] = GTK_RC_FG; } @@ -4211,23 +4340,23 @@ GtkRcStyle *wxWindowGTK::CreateWidgetStyle(bool forceStyle) style->base[GTK_STATE_NORMAL] = *bg; style->color_flags[GTK_STATE_NORMAL] = (GtkRcFlags) (style->color_flags[GTK_STATE_NORMAL] | GTK_RC_BG | GTK_RC_BASE); - + style->bg[GTK_STATE_PRELIGHT] = *bg; style->base[GTK_STATE_PRELIGHT] = *bg; style->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags) (style->color_flags[GTK_STATE_PRELIGHT] | GTK_RC_BG | GTK_RC_BASE); - + style->bg[GTK_STATE_ACTIVE] = *bg; style->base[GTK_STATE_ACTIVE] = *bg; style->color_flags[GTK_STATE_ACTIVE] = (GtkRcFlags) (style->color_flags[GTK_STATE_ACTIVE] | GTK_RC_BG | GTK_RC_BASE); - + style->bg[GTK_STATE_INSENSITIVE] = *bg; style->base[GTK_STATE_INSENSITIVE] = *bg; style->color_flags[GTK_STATE_INSENSITIVE] = (GtkRcFlags) (style->color_flags[GTK_STATE_INSENSITIVE] | GTK_RC_BG | GTK_RC_BASE); } - + return style; } @@ -4248,13 +4377,14 @@ void wxWindowGTK::DoApplyWidgetStyle(GtkRcStyle *style) { if (m_wxwindow) gtk_widget_modify_style(m_wxwindow, style); - gtk_widget_modify_style(m_widget, style); + else + gtk_widget_modify_style(m_widget, style); } bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) { wxWindowBase::SetBackgroundStyle(style); - + if (style == wxBG_STYLE_CUSTOM) { GdkWindow *window = (GdkWindow*) NULL; @@ -4277,7 +4407,7 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) else // Do in OnIdle, because the window is not yet available m_needsStyleChange = true; - + // Don't apply widget style, or we get a grey background } else @@ -4295,15 +4425,16 @@ bool wxWindowGTK::SetBackgroundStyle(wxBackgroundStyle style) #if wxUSE_MENUS_NATIVE -extern "C" +extern "C" WXDLLIMPEXP_CORE void gtk_pop_hide_callback( GtkWidget *WXUNUSED(widget), bool* is_waiting ) { *is_waiting = FALSE; } -static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win ) +WXDLLIMPEXP_CORE void SetInvokingWindow( wxMenu *menu, wxWindow* win ) { menu->SetInvokingWindow( win ); + wxMenuItemList::compatibility_iterator node = menu->GetMenuItems().GetFirst(); while (node) { @@ -4317,12 +4448,13 @@ static void SetInvokingWindow( wxMenu *menu, wxWindowGTK *win ) } } -extern "C" void wxPopupMenuPositionCallback( GtkMenu *menu, - gint *x, gint *y, +extern "C" WXDLLIMPEXP_CORE +void wxPopupMenuPositionCallback( GtkMenu *menu, + gint *x, gint *y, #ifdef __WXGTK20__ - gboolean * WXUNUSED(whatever), + gboolean * WXUNUSED(whatever), #endif - gpointer user_data ) + gpointer user_data ) { // ensure that the menu appears entirely on screen GtkRequisition req; @@ -4344,6 +4476,10 @@ bool wxWindowGTK::DoPopupMenu( wxMenu *menu, int x, int y ) wxCHECK_MSG( menu != NULL, false, wxT("invalid popup-menu") ); + // NOTE: if you change this code, you need to update + // the same code in taskbar.cpp as well. This + // is ugly code duplication, I know, + SetInvokingWindow( menu, this ); menu->UpdateUI(); @@ -4433,14 +4569,14 @@ bool wxWindowGTK::IsOwnGtkWindow( GdkWindow *window ) bool wxWindowGTK::SetFont( const wxFont &font ) { - wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid window") ); + wxCHECK_MSG( m_widget != NULL, false, wxT("invalid window") ); if (!wxWindowBase::SetFont(font)) return false; // apply style change (forceStyle=true so that new style is applied // even if the font changed from valid to wxNullFont): - ApplyWidgetStyle(true); + ApplyWidgetStyle(true); return true; } @@ -4471,7 +4607,7 @@ void wxWindowGTK::DoCaptureMouse() cursor->GetCursor(), (guint32)GDK_CURRENT_TIME ); g_captureWindow = this; - g_captureWindowHasMouse = TRUE; + g_captureWindowHasMouse = true; } void wxWindowGTK::DoReleaseMouse() @@ -4502,7 +4638,7 @@ wxWindow *wxWindowBase::GetCapture() bool wxWindowGTK::IsRetained() const { - return FALSE; + return false; } void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible, @@ -4512,7 +4648,7 @@ void wxWindowGTK::SetScrollbar( int orient, int pos, int thumbVisible, wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") ); - m_hasScrolling = TRUE; + m_hasScrolling = true; if (orient == wxHORIZONTAL) { @@ -4688,11 +4824,11 @@ void wxWindowGTK::ScrollWindow( int dx, int dy, const wxRect* WXUNUSED(rect) ) } #endif - m_clipPaintRegion = TRUE; + m_clipPaintRegion = true; gtk_pizza_scroll( GTK_PIZZA(m_wxwindow), -dx, -dy ); - m_clipPaintRegion = FALSE; + m_clipPaintRegion = false; } @@ -4756,7 +4892,7 @@ bool wxWinModule::OnInit() // g_eraseGC = gdk_gc_new( GDK_ROOT_PARENT() ); // gdk_gc_set_fill( g_eraseGC, GDK_SOLID ); - return TRUE; + return true; } void wxWinModule::OnExit()