]> git.saurik.com Git - wxWidgets.git/blobdiff - src/gtk/toplevel.cpp
many fixes to toolbar positioning code
[wxWidgets.git] / src / gtk / toplevel.cpp
index a28e6741a1e0d6232560127b980a51a8121c8e16..85f4b536dd1f9949cff890da5a1b9552d189bb57 100644 (file)
 #include "wx/toplevel.h"
 
 #ifndef WX_PRECOMP
 #include "wx/toplevel.h"
 
 #ifndef WX_PRECOMP
+    #include "wx/frame.h"
+    #include "wx/icon.h"
     #include "wx/log.h"
     #include "wx/app.h"
 #endif
 
     #include "wx/log.h"
     #include "wx/app.h"
 #endif
 
-#include "wx/dialog.h"
-#include "wx/control.h"
-#include "wx/dcclient.h"
 #include "wx/gtk/private.h"
 #include "wx/gtk/private.h"
-#include "wx/timer.h"
-#include "wx/settings.h"
 #include "wx/evtloop.h"
 
 #include "wx/evtloop.h"
 
-#include <glib.h>
-#include <gdk/gdk.h>
 #include <gtk/gtk.h>
 #include <gtk/gtk.h>
-#include <gdk/gdkkeysyms.h>
 #include <gdk/gdkx.h>
 
 #include "wx/gtk/win_gtk.h"
 #include <gdk/gdkx.h>
 
 #include "wx/gtk/win_gtk.h"
@@ -54,8 +48,6 @@
 // data
 // ----------------------------------------------------------------------------
 
 // data
 // ----------------------------------------------------------------------------
 
-extern wxList           wxPendingDelete;
-
 extern int              g_openDialogs;
 extern wxWindowGTK     *g_delayedFocus;
 
 extern int              g_openDialogs;
 extern wxWindowGTK     *g_delayedFocus;
 
@@ -119,8 +111,7 @@ static gboolean gtk_frame_focus_in_callback( GtkWidget *widget,
                                          GdkEvent *WXUNUSED(event),
                                          wxTopLevelWindowGTK *win )
 {
                                          GdkEvent *WXUNUSED(event),
                                          wxTopLevelWindowGTK *win )
 {
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    // don't need to install idle handler, its done from "event" signal
 
     switch ( g_sendActivateEvent )
     {
 
     switch ( g_sendActivateEvent )
     {
@@ -181,8 +172,7 @@ static gboolean gtk_frame_focus_out_callback( GtkWidget *widget,
                                           GdkEventFocus *WXUNUSED(gdk_event),
                                           wxTopLevelWindowGTK *win )
 {
                                           GdkEventFocus *WXUNUSED(gdk_event),
                                           wxTopLevelWindowGTK *win )
 {
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    // don't need to install idle handler, its done from "event" signal
 
     // if the focus goes out of our app alltogether, OnIdle() will send
     // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
 
     // if the focus goes out of our app alltogether, OnIdle() will send
     // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
@@ -212,13 +202,14 @@ static gboolean gtk_frame_focus_out_callback( GtkWidget *widget,
 //-----------------------------------------------------------------------------
 
 extern "C" {
 //-----------------------------------------------------------------------------
 
 extern "C" {
-static gboolean gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
+static gboolean gtk_frame_focus_callback( GtkWidget *WXUNUSED(widget),
+                                          GtkDirectionType WXUNUSED(d),
+                                          wxWindow *WXUNUSED(win) )
 {
     if (g_isIdle)
         wxapp_install_idle_handler();
 
     // This disables GTK's tab traversal
 {
     if (g_isIdle)
         wxapp_install_idle_handler();
 
     // This disables GTK's tab traversal
-    g_signal_stop_emission_by_name (widget, "focus");
     return TRUE;
 }
 }
     return TRUE;
 }
 }
@@ -239,17 +230,19 @@ static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation*
     if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
     {
 /*
     if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
     {
 /*
-        wxPrintf( "OnSize from " );
+        wxPrintf( wxT("gtk_frame_size_callback from ") );
         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
            wxPrintf( win->GetClassInfo()->GetClassName() );
         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
            wxPrintf( win->GetClassInfo()->GetClassName() );
-        wxPrintf( " %d %d %d %d\n", (int)alloc->x,
+        wxPrintf( wxT(" %d %d %d %d\n"), (int)alloc->x,
                                 (int)alloc->y,
                                 (int)alloc->width,
                                 (int)alloc->height );
 */
 
                                 (int)alloc->y,
                                 (int)alloc->width,
                                 (int)alloc->height );
 */
 
+        // Tell the wxWindow class about the new size
         win->m_width = alloc->width;
         win->m_height = alloc->height;
         win->m_width = alloc->width;
         win->m_height = alloc->height;
+        
         win->GtkUpdateSize();
     }
 }
         win->GtkUpdateSize();
     }
 }
@@ -265,8 +258,7 @@ gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget),
                            GdkEvent *WXUNUSED(event),
                            wxTopLevelWindowGTK *win )
 {
                            GdkEvent *WXUNUSED(event),
                            wxTopLevelWindowGTK *win )
 {
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    // don't need to install idle handler, its done from "event" signal
 
     if (win->IsEnabled() &&
         (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
 
     if (win->IsEnabled() &&
         (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
@@ -288,8 +280,7 @@ gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget),
                               GdkEventConfigure *WXUNUSED(event),
                               wxTopLevelWindowGTK *win )
 {
                               GdkEventConfigure *WXUNUSED(event),
                               wxTopLevelWindowGTK *win )
 {
-    if (g_isIdle)
-        wxapp_install_idle_handler();
+    // don't need to install idle handler, its done from "event" signal
 
     if (!win->m_hasVMT || !win->IsShown())
         return FALSE;
 
     if (!win->m_hasVMT || !win->IsShown())
         return FALSE;
@@ -437,9 +428,6 @@ static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow
                          child->m_width,
                          child->m_height );
     }
                          child->m_width,
                          child->m_height );
     }
-
-    // resize on OnInternalIdle
-    parent->GtkUpdateSize();
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -455,6 +443,7 @@ void wxTopLevelWindowGTK::Init()
     m_insertInClientArea = true;
     m_isIconized = false;
     m_fsIsShowing = false;
     m_insertInClientArea = true;
     m_isIconized = false;
     m_fsIsShowing = false;
+    m_fsSaveFlag = 0;
     m_themeEnabled = true;
     m_gdkDecor = m_gdkFunc = 0;
     m_grabbed = false;
     m_themeEnabled = true;
     m_gdkDecor = m_gdkFunc = 0;
     m_grabbed = false;
@@ -558,8 +547,10 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
     }
 #endif
 
     }
 #endif
 
+#if 0
     if (!name.empty())
     if (!name.empty())
-        gtk_window_set_wmclass( GTK_WINDOW(m_widget), wxGTK_CONV( name ), wxGTK_CONV( name ) );
+        gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) );
+#endif
 
     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 
     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
@@ -628,10 +619,19 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
                       G_CALLBACK (gtk_frame_focus_out_callback), this);
 
     // decorations
                       G_CALLBACK (gtk_frame_focus_out_callback), this);
 
     // decorations
-    if ((m_miniEdge > 0) || (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))
+    if ((style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))
+    {
+        m_gdkDecor = 0;
+        m_gdkFunc = 0;
+    }
+    else
+    if (m_miniEdge > 0)
     {
         m_gdkDecor = 0;
         m_gdkFunc = 0;
     {
         m_gdkDecor = 0;
         m_gdkFunc = 0;
+        
+        if ((style & wxRESIZE_BORDER) != 0)
+           m_gdkFunc |= GDK_FUNC_RESIZE;
     }
     else
     {
     }
     else
     {
@@ -694,7 +694,18 @@ wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
         g_lastActiveFrame = NULL;
 }
 
         g_lastActiveFrame = NULL;
 }
 
-
+bool wxTopLevelWindowGTK::EnableCloseButton( bool enable )
+{
+    if (enable)
+        m_gdkFunc |= GDK_FUNC_CLOSE;
+    else
+        m_gdkFunc &= ~GDK_FUNC_CLOSE;
+    
+    if (GTK_WIDGET_REALIZED(m_widget) && (m_widget->window))
+        gdk_window_set_functions( m_widget->window, (GdkWMFunction)m_gdkFunc );
+        
+    return true;
+}
 
 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
 {
 
 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
 {
@@ -715,9 +726,15 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
     if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) )
     {
         if (show)
     if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) )
     {
         if (show)
+        {
+            m_fsSaveFlag = style;
             gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
             gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
+        }
         else
         else
+        {
+            m_fsSaveFlag = 0;
             gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
             gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
+        }
     }
     else
 #endif // GTK+ >= 2.2.0
     }
     else
 #endif // GTK+ >= 2.2.0
@@ -760,6 +777,7 @@ bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
         }
         else // hide
         {
         }
         else // hide
         {
+            m_fsSaveFlag = 0;
             if (method != wxX11_FS_WMSPEC)
             {
                 // don't do it always, Metacity hates it
             if (method != wxX11_FS_WMSPEC)
             {
                 // don't do it always, Metacity hates it
@@ -795,6 +813,9 @@ bool wxTopLevelWindowGTK::Show( bool show )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
+    if (show == IsShown())
+        return true;
+
     if (show && !m_sizeSet)
     {
         /* by calling GtkOnSize here, we don't have to call
     if (show && !m_sizeSet)
     {
         /* by calling GtkOnSize here, we don't have to call
@@ -802,11 +823,14 @@ bool wxTopLevelWindowGTK::Show( bool show )
            much ugly flicker or from within the size_allocate
            handler, because GTK 1.1.X forbids that. */
 
            much ugly flicker or from within the size_allocate
            handler, because GTK 1.1.X forbids that. */
 
-        GtkOnSize( m_x, m_y, m_width, m_height );
+        GtkOnSize();
     }
 
     }
 
-    if (show)
-        gtk_widget_set_uposition( m_widget, m_x, m_y );
+    // This seems no longer to be needed and the call
+    // itself is deprecated.
+    //
+    //if (show)
+    //    gtk_widget_set_uposition( m_widget, m_x, m_y );
 
     return wxWindow::Show( show );
 }
 
     return wxWindow::Show( show );
 }
@@ -851,7 +875,7 @@ void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int si
     }
     if (width != -1) m_width = width;
     if (height != -1) m_height = height;
     }
     if (width != -1) m_width = width;
     if (height != -1) m_height = height;
-
+    
 /*
     if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
     {
 /*
     if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
     {
@@ -912,15 +936,17 @@ void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
-    wxWindow::DoGetClientSize( width, height );
     if (height)
     {
     if (height)
     {
-        // mini edge
-        *height -= m_miniEdge*2 + m_miniTitle;
+        *height = m_height - 2 * m_miniEdge - m_miniTitle;
+        if (*height < 0)
+            *height = 0;
     }
     if (width)
     {
     }
     if (width)
     {
-        *width -= m_miniEdge*2;
+        *width = m_width - 2 * m_miniEdge;
+        if (*width < 0)
+            *width = 0;
     }
 }
 
     }
 }
 
@@ -932,51 +958,19 @@ void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
               width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0);
 }
 
               width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0);
 }
 
-void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
-                                     int width, int height )
+void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
+                                          int maxW, int maxH,
+                                          int incW, int incH )
 {
 {
-    // due to a bug in gtk, x,y are always 0
-    // m_x = x;
-    // m_y = y;
-
-    // avoid recursions
-    if (m_resizing) return;
-    m_resizing = true;
-
-    if ( m_wxwindow == NULL ) return;
-
-    m_width = width;
-    m_height = height;
-
-    /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
-       wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
-       set in wxFrame::Create so it is used to check what kind of frame we
-       have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
-       skip the part which handles m_frameMenuBar, m_frameToolBar and (most
-       importantly) m_mainWidget */
-
-    int minWidth = GetMinWidth(),
-        minHeight = GetMinHeight(),
-        maxWidth = GetMaxWidth(),
-        maxHeight = GetMaxHeight();
-
-#ifdef __WXGPE__
-    // GPE's window manager doesn't like size hints
-    // at all, esp. when the user has to use the
-    // virtual keyboard.
-    minWidth = -1;
-    minHeight = -1;
-    maxWidth = -1;
-    maxHeight = -1;
-#endif
-
-    if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
-    if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
-    if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
-    if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
-
-    if (m_mainWidget)
+    wxTopLevelWindowBase::DoSetSizeHints( minW, minH, maxW, maxH, incW, incH );
+    
+    if (m_widget)
     {
     {
+        int minWidth = GetMinWidth(),
+            minHeight = GetMinHeight(),
+            maxWidth = GetMaxWidth(),
+            maxHeight = GetMaxHeight();
+            
         // set size hints
         gint            flag = 0; // GDK_HINT_POS;
         GdkGeometry     geom;
         // set size hints
         gint            flag = 0; // GDK_HINT_POS;
         GdkGeometry     geom;
@@ -1013,18 +1007,59 @@ void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
                                        (GtkWidget*) NULL,
                                        &geom,
                                        (GdkWindowHints) flag );
                                        (GtkWidget*) NULL,
                                        &geom,
                                        (GdkWindowHints) flag );
+    }
+}
+
+
+void wxTopLevelWindowGTK::GtkOnSize()
+{
+    // avoid recursions
+    if (m_resizing) return;
+    m_resizing = true;
+
+    if ( m_wxwindow == NULL ) return;
+
+    /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
+       wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
+       set in wxFrame::Create so it is used to check what kind of frame we
+       have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
+       skip the part which handles m_frameMenuBar, m_frameToolBar and (most
+       importantly) m_mainWidget */
 
 
-        /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
-         * menubar, the toolbar and the client area, which is represented by
-         * m_wxwindow.
-         * this hurts in the eye, but I don't want to call SetSize()
-         * because I don't want to call any non-native functions here. */
+    int minWidth = GetMinWidth(),
+        minHeight = GetMinHeight(),
+        maxWidth = GetMaxWidth(),
+        maxHeight = GetMaxHeight();
 
 
+#ifdef __WXGPE__
+    // GPE's window manager doesn't like size hints
+    // at all, esp. when the user has to use the
+    // virtual keyboard.
+    minWidth = -1;
+    minHeight = -1;
+    maxWidth = -1;
+    maxHeight = -1;
+#endif
+
+    if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
+    if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
+    if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
+    if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
+
+    if (m_mainWidget)
+    {
+        // m_mainWidget holds the menubar, the toolbar and the client area,
+        // which is represented by m_wxwindow.
         int client_x = m_miniEdge;
         int client_y = m_miniEdge + m_miniTitle;
         int client_w = m_width - 2*m_miniEdge;
         int client_h = m_height - 2*m_miniEdge - m_miniTitle;
         int client_x = m_miniEdge;
         int client_y = m_miniEdge + m_miniTitle;
         int client_w = m_width - 2*m_miniEdge;
         int client_h = m_height - 2*m_miniEdge - m_miniTitle;
+        if (client_w < 0)
+            client_w = 0;
+        if (client_h < 0)
+            client_h = 0;
 
 
+        // Let the parent perform the resize
         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                               m_wxwindow,
                               client_x, client_y, client_w, client_h );
         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
                               m_wxwindow,
                               client_x, client_y, client_w, client_h );
@@ -1049,7 +1084,7 @@ void wxTopLevelWindowGTK::OnInternalIdle()
 {
     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
     {
 {
     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
     {
-        GtkOnSize( m_x, m_y, m_width, m_height );
+        GtkOnSize();
 
         // we'll come back later
         if (g_isIdle)
 
         // we'll come back later
         if (g_isIdle)
@@ -1300,3 +1335,71 @@ void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
     }
 #endif // GTK+ 2.2
 }
     }
 #endif // GTK+ 2.2
 }
+
+#include <X11/Xlib.h>
+
+/* Get the X Window between child and the root window.
+   This should usually be the WM managed XID */
+static Window wxGetTopmostWindowX11(Display *dpy, Window child)
+{
+    Window root, parent;
+    Window* children;
+    unsigned int nchildren;
+
+    XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
+    XFree(children);
+
+    while (parent != root) {
+        child = parent;
+        XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
+        XFree(children);
+    }
+
+    return child;
+}
+
+bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
+{
+    if (!m_widget || !m_widget->window)
+        return false;
+
+    Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window);
+    // We need to get the X Window that has the root window as the immediate parent
+    // and m_widget->window as a child. This should be the X Window that the WM manages and
+    // from which the opacity property is checked from.
+    Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window));
+
+    unsigned int opacity = alpha * 0x1010101;
+
+    // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
+    if (alpha == 0xff)
+        XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
+    else
+        XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
+                        XA_CARDINAL, 32, PropModeReplace,
+                        (unsigned char *) &opacity, 1L);
+    XSync(dpy, False);
+    return true;
+}
+
+bool wxTopLevelWindowGTK::CanSetTransparent()
+{
+#if GTK_CHECK_VERSION(2,10,0)
+    if (!gtk_check_version(2,10,0))
+    {
+        if (gtk_widget_is_composited (m_widget))
+            return true;
+    }
+    else
+#endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
+    {
+        return false;
+    }
+
+#if 0 // Don't be optimistic here for the sake of wxAUI
+    int opcode, event, error;
+    // Check for the existence of a RGBA visual instead?
+    return XQueryExtension(gdk_x11_get_default_xdisplay (),
+                           "Composite", &opcode, &event, &error);
+#endif
+}