mac paths updated

[wxWidgets.git] / src / gtk / toplevel.cpp

diff --git a/src/gtk/toplevel.cpp b/src/gtk/toplevel.cpp
index 35197bcd419b5623dcce60129429d297a7461b29..d87eec8b6a45f3ab0f3a7bf75a5982a70bb0444d 100644 (file)
--- a/src/gtk/toplevel.cpp
+++ b/src/gtk/toplevel.cpp
@@ -57,8 +57,6 @@
 // this is incremented while a modal dialog is shown
 int wxOpenModalDialogsCount = 0;
 
 // this is incremented while a modal dialog is shown
 int wxOpenModalDialogsCount = 0;
 

-extern wxWindowGTK     *g_delayedFocus;
-

 // the frame that is currently active (i.e. its child has focus). It is
 // used to generate wxActivateEvents
 static wxTopLevelWindowGTK *g_activeFrame = (wxTopLevelWindowGTK*) NULL;
 // the frame that is currently active (i.e. its child has focus). It is
 // used to generate wxActivateEvents
 static wxTopLevelWindowGTK *g_activeFrame = (wxTopLevelWindowGTK*) NULL;


@@ -326,6 +324,9 @@ gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
         win->SetIcon( wxNullIcon );
         win->SetIcons( iconsOld );
     }
         win->SetIcon( wxNullIcon );
         win->SetIcons( iconsOld );
     }

+
+    if (win->HasFlag(wxFRAME_SHAPED))
+        win->SetShape(win->m_shape); // it will really set the window shape now

 }
 }
 
 }
 }
 


@@ -374,6 +375,37 @@ gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
 }
 }
 
 }
 }
 

+//-----------------------------------------------------------------------------
+
+bool wxGetFrameExtents(GdkWindow* window, int* left, int* right, int* top, int* bottom)
+{
+    static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false);
+    Atom xproperty = gdk_x11_atom_to_xatom_for_display(
+                        gdk_drawable_get_display(window), property);
+    Atom type;
+    int format;
+    gulong nitems, bytes_after;
+    guchar* data;
+    Status status = XGetWindowProperty(
+        gdk_x11_drawable_get_xdisplay(window),
+        gdk_x11_drawable_get_xid(window),
+        xproperty,
+        0, 4, false, XA_CARDINAL,
+        &type, &format, &nitems, &bytes_after, &data);
+    const bool success = status == Success && data && nitems == 4;
+    if (success)
+    {
+        long* p = (long*)data;
+        if (left)   *left   = int(p[0]);
+        if (right)  *right  = int(p[1]);
+        if (top)    *top    = int(p[2]);
+        if (bottom) *bottom = int(p[3]);
+    }
+    if (data)
+        XFree(data);
+    return success;
+}
+

 //-----------------------------------------------------------------------------
 // "property_notify_event" from m_widget
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // "property_notify_event" from m_widget
 //-----------------------------------------------------------------------------


@@ -386,27 +418,13 @@ static gboolean property_notify_event(
     static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false);
     if (event->state == GDK_PROPERTY_NEW_VALUE && event->atom == property)
     {
     static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false);
     if (event->state == GDK_PROPERTY_NEW_VALUE && event->atom == property)
     {

-        Atom xproperty = gdk_x11_atom_to_xatom_for_display(
-                            gdk_drawable_get_display(event->window), property);
-        Atom type;
-        int format;
-        gulong nitems, bytes_after;
-        guchar* data;
-        Status status = XGetWindowProperty(
-            gdk_x11_drawable_get_xdisplay(event->window),
-            gdk_x11_drawable_get_xid(event->window),
-            xproperty,
-            0, 4, false, XA_CARDINAL,
-            &type, &format, &nitems, &bytes_after, &data);
-        if (status == Success && data && nitems == 4)
+        int left, right, top, bottom;
+        if (wxGetFrameExtents(event->window, &left, &right, &top, &bottom))

         {
         {

-            long* p = (long*)data;

             const wxSize decorSize =
             const wxSize decorSize =

-                wxSize(int(p[0] + p[1]), int(p[2] + p[3]));
+                wxSize(left + right, top + bottom);

             win->GTKUpdateDecorSize(decorSize);
         }
             win->GTKUpdateDecorSize(decorSize);
         }

-        if (data)
-            XFree(data);

     }
     return false;
 }
     }
     return false;
 }


@@ -623,7 +641,10 @@ bool wxTopLevelWindowGTK::Create( wxWindow *parent,
         }
     }
 
         }
     }
 

-    gtk_window_set_default_size(GTK_WINDOW(m_widget), m_width, m_height);
+    m_decorSize = GetCachedDecorSize();
+    int w, h;
+    GTKDoGetSize(&w, &h);
+    gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h);

 
     return true;
 }
 
     return true;
 }


@@ -760,8 +781,19 @@ bool wxTopLevelWindowGTK::Show( bool show )
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 
 {
     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 

-    const bool wasRealized = GTK_WIDGET_REALIZED(m_widget);
-    bool deferShow = show && m_deferShow && !wasRealized;
+    bool deferShow = show && m_deferShow && !m_isShown;
+    if (deferShow)
+    {
+        m_deferShow =
+        deferShow = !GTK_WIDGET_REALIZED(m_widget) &&
+            gdk_x11_screen_supports_net_wm_hint(
+                gtk_widget_get_screen(m_widget),
+                gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false)) &&
+            g_signal_handler_find(m_widget,
+                GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA),
+                g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET),
+                0, NULL, NULL, this);
+    }

     if (deferShow)
     {
         // Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer
     if (deferShow)
     {
         // Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer


@@ -771,30 +803,17 @@ bool wxTopLevelWindowGTK::Show( bool show )
         // what wxWidgets expects it to be without an obvious change in the
         // window size immediately after it becomes visible.
 
         // what wxWidgets expects it to be without an obvious change in the
         // window size immediately after it becomes visible.
 

-        // Realize m_widget, so m_widget->window can be used. Realizing causes
-        // the widget tree to be size_allocated, which generates size events in
-        // the wrong order. So temporarily remove child from m_widget while
-        // realizing.
-        GtkWidget* child = GTK_BIN(m_widget)->child;
-        if (child)
-        {
-            g_object_ref(child);
-            gtk_container_remove(GTK_CONTAINER(m_widget), child);
-        }
+        // Realize m_widget, so m_widget->window can be used. Realizing normally
+        // causes the widget tree to be size_allocated, which generates size
+        // events in the wrong order. However, the size_allocates will not be
+        // done if the allocation is not the default (1,1).
+        const int alloc_width = m_widget->allocation.width;
+        if (alloc_width == 1)
+            m_widget->allocation.width = 2;

         gtk_widget_realize(m_widget);
         gtk_widget_realize(m_widget);

-        if (child)
-        {
-            gtk_container_add(GTK_CONTAINER(m_widget), child);
-            g_object_unref(child);
-        }
+        if (alloc_width == 1)
+            m_widget->allocation.width = 1;

 
 

-        m_deferShow =
-        deferShow = gdk_x11_screen_supports_net_wm_hint(
-            gdk_drawable_get_screen(m_widget->window),
-            gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false)) != 0;
-    }
-    if (deferShow)
-    {

         // send _NET_REQUEST_FRAME_EXTENTS
         XClientMessageEvent xevent;
         memset(&xevent, 0, sizeof(xevent));
         // send _NET_REQUEST_FRAME_EXTENTS
         XClientMessageEvent xevent;
         memset(&xevent, 0, sizeof(xevent));


@@ -814,7 +833,7 @@ bool wxTopLevelWindowGTK::Show( bool show )
         return true;
     }
 
         return true;
     }
 

-    if (show && !wasRealized)
+    if (show && !GTK_WIDGET_REALIZED(m_widget))

     {
         // size_allocate signals occur in reverse order (bottom to top).
         // Things work better if the initial wxSizeEvents are sent (from the
     {
         // size_allocate signals occur in reverse order (bottom to top).
         // Things work better if the initial wxSizeEvents are sent (from the


@@ -939,8 +958,6 @@ void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
                                           int incW, int incH )
 {
     wxTopLevelWindowBase::DoSetSizeHints( minW, minH, maxW, maxH, incW, incH );
                                           int incW, int incH )
 {
     wxTopLevelWindowBase::DoSetSizeHints( minW, minH, maxW, maxH, incW, incH );

-    m_sizeIncHint.x = incW;
-    m_sizeIncHint.y = incH;

 
     const wxSize minSize = GetMinSize();
     const wxSize maxSize = GetMaxSize();
 
     const wxSize minSize = GetMinSize();
     const wxSize maxSize = GetMaxSize();


@@ -978,19 +995,27 @@ void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
 
 void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize)
 {
 
 void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize)
 {

+    if (!IsMaximized() && !IsFullScreen())
+        GetCachedDecorSize() = decorSize;

     if (m_decorSize != decorSize)
     {
         const wxSize diff = decorSize - m_decorSize;
         m_decorSize = decorSize;
     if (m_decorSize != decorSize)
     {
         const wxSize diff = decorSize - m_decorSize;
         m_decorSize = decorSize;

-        SetSizeHints(GetMinSize(), GetMaxSize(), m_sizeIncHint);
+        bool resized = false;

         if (m_deferShow)
         {
             // keep overall size unchanged by shrinking m_widget
             int w, h;
             GTKDoGetSize(&w, &h);
         if (m_deferShow)
         {
             // keep overall size unchanged by shrinking m_widget
             int w, h;
             GTKDoGetSize(&w, &h);

-            gtk_window_resize(GTK_WINDOW(m_widget), w, h);
+            // but not if size would be less than minimum, it won't take effect
+            const wxSize minSize = GetMinSize();
+            if (w >= minSize.x && h >= minSize.y)
+            {
+                gtk_window_resize(GTK_WINDOW(m_widget), w, h);
+                resized = true;
+            }

         }
         }

-        else
+        if (!resized)

         {
             // adjust overall size to match change in frame extents
             m_width  += diff.x;
         {
             // adjust overall size to match change in frame extents
             m_width  += diff.x;


@@ -1018,24 +1043,25 @@ void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize)
     }
 }
 
     }
 }
 

-void wxTopLevelWindowGTK::OnInternalIdle()
+wxSize& wxTopLevelWindowGTK::GetCachedDecorSize()

 {
 {

-    // set the focus if not done yet and if we can already do it
-    if ( GTK_WIDGET_REALIZED(m_wxwindow) )
-    {
-        if ( g_delayedFocus &&
-             wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
-        {
-            wxLogTrace(_T("focus"),
-                       _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
-                       g_delayedFocus->GetClassInfo()->GetClassName(),
-                       g_delayedFocus->GetLabel().c_str());
-
-            g_delayedFocus->SetFocus();
-            g_delayedFocus = NULL;
-        }
-    }
+    static wxSize size[8];
+
+    int index = 0;
+    // title bar
+    if (m_gdkDecor & (GDK_DECOR_MENU | GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE | GDK_DECOR_TITLE))
+        index = 1;
+    // border
+    if (m_gdkDecor & GDK_DECOR_BORDER)
+        index |= 2;
+    // utility window decor can be different
+    if (m_windowStyle & wxFRAME_TOOL_WINDOW)
+        index |= 4;
+    return size[index];
+}

 
 

+void wxTopLevelWindowGTK::OnInternalIdle()
+{

     wxWindow::OnInternalIdle();
 
     // Synthetize activate events.
     wxWindow::OnInternalIdle();
 
     // Synthetize activate events.


@@ -1180,13 +1206,22 @@ bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
     wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
                  _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
 
     wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
                  _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
 

-    GdkWindow *window = NULL;
-    if (m_wxwindow)
+    if ( GTK_WIDGET_REALIZED(m_widget) )

     {
     {

-        do_shape_combine_region(m_wxwindow->window, region);
+        if ( m_wxwindow )
+            do_shape_combine_region(m_wxwindow->window, region);
+
+        return do_shape_combine_region(m_widget->window, region);
+    }
+    else // not realized yet
+    {
+        // store the shape to set, it will be really set once we're realized
+        m_shape = region;
+
+        // we don't know if we're going to succeed or fail, be optimistic by
+        // default
+        return true;

     }
     }

-    window = m_widget->window;
-    return do_shape_combine_region(window, region);

 }
 
 bool wxTopLevelWindowGTK::IsActive()
 }
 
 bool wxTopLevelWindowGTK::IsActive()