Back out dd103ec4c44b through fba3a342a530 because of B2G test failures on a CLOSED TREE
authorMatt Brubeck <mbrubeck@mozilla.com>
Tue, 19 Feb 2013 17:06:18 -0800
changeset 122392 e8c8d9373eba3573dfaaf5ce90419eb574ac4722
parent 122391 6d504df6f023173832683178f62e25d6e894be4d
child 122393 1c3fed1032513ca9d2955fad8881e99640aa7af0
push id24336
push userryanvm@gmail.com
push dateWed, 20 Feb 2013 12:07:46 +0000
treeherdermozilla-central@1bcc3c56b011 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
milestone22.0a1
backs outdd103ec4c44ba305cc5a08350e1352a7afcdb8ce
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Back out dd103ec4c44b through fba3a342a530 because of B2G test failures on a CLOSED TREE
gfx/gl/GLContext.h
layout/generic/nsGfxScrollFrame.cpp
toolkit/system/gnome/Makefile.in
toolkit/system/gnome/nsAlertsService.cpp
toolkit/system/gnome/nsAlertsService.h
toolkit/system/gnome/nsGnomeModule.cpp
toolkit/system/gnome/nsSystemAlertsService.cpp
toolkit/system/gnome/nsSystemAlertsService.h
widget/gtk2/nsDragService.cpp
widget/gtk2/nsDragService.h
widget/gtk2/nsNativeThemeGTK.cpp
widget/gtkxtbin/gtk2xtbin.c
--- a/gfx/gl/GLContext.h
+++ b/gfx/gl/GLContext.h
@@ -237,16 +237,18 @@ public:
     }
 
     virtual bool IsCurrent() = 0;
 
     bool IsContextLost() { return mContextLost; }
 
     virtual bool SetupLookupFunction() = 0;
 
+    virtual void WindowDestroyed() {}
+
     virtual void ReleaseSurface() {}
 
     void *GetUserData(void *aKey) {
         void *result = nullptr;
         mUserData.Get(aKey, &result);
         return result;
     }
 
--- a/layout/generic/nsGfxScrollFrame.cpp
+++ b/layout/generic/nsGfxScrollFrame.cpp
@@ -3561,26 +3561,26 @@ nsGfxScrollFrameInner::LayoutScrollbars(
     if (mScrollCornerBox) {
       nsBoxFrame::LayoutChildAt(aState, mScrollCornerBox, r);
     }
 
     if (hasResizer) {
       // if a resizer is present, get its size. Assume a default size of 15 pixels.
       nsSize resizerSize;
       nscoord defaultSize = nsPresContext::CSSPixelsToAppUnits(15);
-      resizerSize.width = mVScrollbarBox ?
-        mVScrollbarBox->GetPrefSize(aState).width : defaultSize;
+      resizerSize.width =
+        mVScrollbarBox ? mVScrollbarBox->GetMinSize(aState).width : defaultSize;
       if (resizerSize.width > r.width) {
         r.width = resizerSize.width;
         if (aContentArea.x == mScrollPort.x && !scrollbarOnLeft)
           r.x = aContentArea.XMost() - r.width;
       }
 
-      resizerSize.height = mHScrollbarBox ?
-        mHScrollbarBox->GetPrefSize(aState).height : defaultSize;
+      resizerSize.height =
+        mHScrollbarBox ? mHScrollbarBox->GetMinSize(aState).height : defaultSize;
       if (resizerSize.height > r.height) {
         r.height = resizerSize.height;
         if (aContentArea.y == mScrollPort.y)
           r.y = aContentArea.YMost() - r.height;
       }
 
       nsBoxFrame::LayoutChildAt(aState, mResizerBox, r);
     }
--- a/toolkit/system/gnome/Makefile.in
+++ b/toolkit/system/gnome/Makefile.in
@@ -13,17 +13,17 @@ MODULE		= mozgnome
 LIBRARY_NAME	= mozgnome
 FORCE_SHARED_LIB = 1
 IS_COMPONENT	= 1
 FAIL_ON_WARNINGS = 1
 
 
 CPPSRCS = \
   nsGnomeModule.cpp \
-  nsSystemAlertsService.cpp \
+  nsAlertsService.cpp \
   nsAlertsIconListener.cpp \
   $(NULL)
 
 ifdef MOZ_ENABLE_GCONF
 CPPSRCS += \
   nsGConfService.cpp \
   $(NULL)
 endif
rename from toolkit/system/gnome/nsSystemAlertsService.cpp
rename to toolkit/system/gnome/nsAlertsService.cpp
--- a/toolkit/system/gnome/nsSystemAlertsService.cpp
+++ b/toolkit/system/gnome/nsAlertsService.cpp
@@ -1,45 +1,42 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode:nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include "nsSystemAlertsService.h"
+#include "nsAlertsService.h"
 #include "nsAlertsIconListener.h"
 #include "nsAutoPtr.h"
 
-NS_IMPL_THREADSAFE_ADDREF(nsSystemAlertsService)
-NS_IMPL_THREADSAFE_RELEASE(nsSystemAlertsService)
+NS_IMPL_THREADSAFE_ADDREF(nsAlertsService)
+NS_IMPL_THREADSAFE_RELEASE(nsAlertsService)
 
-NS_INTERFACE_MAP_BEGIN(nsSystemAlertsService)
+NS_INTERFACE_MAP_BEGIN(nsAlertsService)
    NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIAlertsService)
    NS_INTERFACE_MAP_ENTRY(nsIAlertsService)
 NS_INTERFACE_MAP_END_THREADSAFE
 
-nsSystemAlertsService::nsSystemAlertsService()
+nsAlertsService::nsAlertsService()
 {}
 
-nsSystemAlertsService::~nsSystemAlertsService()
+nsAlertsService::~nsAlertsService()
 {}
 
 nsresult
-nsSystemAlertsService::Init()
+nsAlertsService::Init()
 {
   return NS_OK;
 }
 
-NS_IMETHODIMP
-nsSystemAlertsService::ShowAlertNotification(const nsAString & aImageUrl,
-                                             const nsAString & aAlertTitle, 
-                                             const nsAString & aAlertText,
-                                             bool aAlertTextClickable,
-                                             const nsAString & aAlertCookie,
-                                             nsIObserver * aAlertListener,
-                                             const nsAString & aAlertName)
+NS_IMETHODIMP nsAlertsService::ShowAlertNotification(const nsAString & aImageUrl, const nsAString & aAlertTitle, 
+                                                     const nsAString & aAlertText, bool aAlertTextClickable,
+                                                     const nsAString & aAlertCookie,
+                                                     nsIObserver * aAlertListener,
+                                                     const nsAString & aAlertName)
 {
   nsRefPtr<nsAlertsIconListener> alertListener = new nsAlertsIconListener();
   if (!alertListener)
     return NS_ERROR_OUT_OF_MEMORY;
 
   return alertListener->InitAlertAsync(aImageUrl, aAlertTitle, aAlertText, aAlertTextClickable,
                                        aAlertCookie, aAlertListener);
 }
rename from toolkit/system/gnome/nsSystemAlertsService.h
rename to toolkit/system/gnome/nsAlertsService.h
--- a/toolkit/system/gnome/nsSystemAlertsService.h
+++ b/toolkit/system/gnome/nsAlertsService.h
@@ -1,27 +1,27 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef nsSystemAlertsService_h__
-#define nsSystemAlertsService_h__
+#ifndef nsAlertsService_h__
+#define nsAlertsService_h__
 
 #include "nsIAlertsService.h"
 #include "nsCOMPtr.h"
 
-class nsSystemAlertsService : public nsIAlertsService
+class nsAlertsService : public nsIAlertsService
 {
 public:
   NS_DECL_NSIALERTSSERVICE
   NS_DECL_ISUPPORTS
 
-  nsSystemAlertsService();
-  virtual ~nsSystemAlertsService();
+  nsAlertsService();
+  virtual ~nsAlertsService();
 
   nsresult Init();
 
 protected:
 
 };
 
-#endif /* nsSystemAlertsService_h__ */
+#endif /* nsAlertsService_h__ */
--- a/toolkit/system/gnome/nsGnomeModule.cpp
+++ b/toolkit/system/gnome/nsGnomeModule.cpp
@@ -17,18 +17,18 @@ NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsGC
 NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsGnomeVFSService, Init)
 #endif
 #ifdef MOZ_ENABLE_GIO
 #include "nsGIOService.h"
 #include "nsGSettingsService.h"
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsGIOService)
 NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsGSettingsService, Init)
 #endif
-#include "nsSystemAlertsService.h"
-NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsSystemAlertsService, Init)
+#include "nsAlertsService.h"
+NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsAlertsService, Init)
 
 #ifdef MOZ_ENABLE_GCONF
 NS_DEFINE_NAMED_CID(NS_GCONFSERVICE_CID);
 #endif
 #ifdef MOZ_ENABLE_GNOMEVFS
 NS_DEFINE_NAMED_CID(NS_GNOMEVFSSERVICE_CID);
 #endif
 #ifdef MOZ_ENABLE_GIO
@@ -44,17 +44,17 @@ static const mozilla::Module::CIDEntry k
 #endif
 #ifdef MOZ_ENABLE_GNOMEVFS
   { &kNS_GNOMEVFSSERVICE_CID, false, NULL, nsGnomeVFSServiceConstructor },
 #endif
 #ifdef MOZ_ENABLE_GIO
   { &kNS_GIOSERVICE_CID, false, NULL, nsGIOServiceConstructor },
   { &kNS_GSETTINGSSERVICE_CID, false, NULL, nsGSettingsServiceConstructor },
 #endif
-  { &kNS_SYSTEMALERTSSERVICE_CID, false, NULL, nsSystemAlertsServiceConstructor },
+  { &kNS_SYSTEMALERTSSERVICE_CID, false, NULL, nsAlertsServiceConstructor },
   { NULL }
 };
 
 static const mozilla::Module::ContractIDEntry kGnomeContracts[] = {
 #ifdef MOZ_ENABLE_GCONF
   { NS_GCONFSERVICE_CONTRACTID, &kNS_GCONFSERVICE_CID },
 #endif
 #ifdef MOZ_ENABLE_GNOMEVFS
--- a/widget/gtk2/nsDragService.cpp
+++ b/widget/gtk2/nsDragService.cpp
@@ -1163,22 +1163,26 @@ nsDragService::GetSourceList(void)
     // Check to see if we're dragging > 1 item.
     if (numDragItems > 1) {
         // as the Xdnd protocol only supports a single item (or is it just
         // gtk's implementation?), we don't advertise all flavours listed
         // in the nsITransferable.
 
         // the application/x-moz-internal-item-list format, which preserves
         // all information for drags within the same mozilla instance.
+        GdkAtom listAtom = gdk_atom_intern(gMimeListType, FALSE);
         GtkTargetEntry *listTarget =
             (GtkTargetEntry *)g_malloc(sizeof(GtkTargetEntry));
         listTarget->target = g_strdup(gMimeListType);
         listTarget->flags = 0;
+        /* Bug 331198 */
+        listTarget->info = NS_PTR_TO_UINT32(listAtom);
         PR_LOG(sDragLm, PR_LOG_DEBUG,
-               ("automatically adding target %s\n", listTarget->target));
+               ("automatically adding target %s with id %ld\n",
+               listTarget->target, listAtom));
         targetArray.AppendElement(listTarget);
 
         // check what flavours are supported so we can decide what other
         // targets to advertise.
         nsCOMPtr<nsISupports> genericItem;
         mSourceDataItems->GetElementAt(0, getter_AddRefs(genericItem));
         nsCOMPtr<nsITransferable> currItem(do_QueryInterface(genericItem));
 
@@ -1199,23 +1203,26 @@ nsDragService::GetSourceList(void)
                     if (currentFlavor) {
                         nsXPIDLCString flavorStr;
                         currentFlavor->ToString(getter_Copies(flavorStr));
 
                         // check if text/x-moz-url is supported.
                         // If so, advertise
                         // text/uri-list.
                         if (strcmp(flavorStr, kURLMime) == 0) {
+                            listAtom = gdk_atom_intern(gTextUriListType, FALSE);
                             listTarget =
                              (GtkTargetEntry *)g_malloc(sizeof(GtkTargetEntry));
                             listTarget->target = g_strdup(gTextUriListType);
                             listTarget->flags = 0;
+                            /* Bug 331198 */
+                            listTarget->info = NS_PTR_TO_UINT32(listAtom);
                             PR_LOG(sDragLm, PR_LOG_DEBUG,
-                                   ("automatically adding target %s\n",
-                                    listTarget->target));
+                                   ("automatically adding target %s with \
+                                   id %ld\n", listTarget->target, listAtom));
                             targetArray.AppendElement(listTarget);
                         }
                     }
                 } // foreach flavor in item
             } // if valid flavor list
         } // if item is a transferable
     } else if (numDragItems == 1) {
         nsCOMPtr<nsISupports> genericItem;
@@ -1233,57 +1240,77 @@ nsDragService::GetSourceList(void)
                     nsCOMPtr<nsISupports> genericWrapper;
                     flavorList->GetElementAt(flavorIndex,
                                              getter_AddRefs(genericWrapper));
                     nsCOMPtr<nsISupportsCString> currentFlavor;
                     currentFlavor = do_QueryInterface(genericWrapper);
                     if (currentFlavor) {
                         nsXPIDLCString flavorStr;
                         currentFlavor->ToString(getter_Copies(flavorStr));
+                        // get the atom
+                        GdkAtom atom = gdk_atom_intern(flavorStr, FALSE);
                         GtkTargetEntry *target =
                           (GtkTargetEntry *)g_malloc(sizeof(GtkTargetEntry));
                         target->target = g_strdup(flavorStr);
                         target->flags = 0;
+                        /* Bug 331198 */
+                        target->info = NS_PTR_TO_UINT32(atom);
                         PR_LOG(sDragLm, PR_LOG_DEBUG,
-                               ("adding target %s\n", target->target));
+                               ("adding target %s with id %ld\n",
+                               target->target, atom));
                         targetArray.AppendElement(target);
                         // Check to see if this is text/unicode.
                         // If it is, add text/plain
                         // since we automatically support text/plain
                         // if we support text/unicode.
                         if (strcmp(flavorStr, kUnicodeMime) == 0) {
+                            // get the atom for the unicode string
+                            GdkAtom plainUTF8Atom =
+                              gdk_atom_intern(gTextPlainUTF8Type, FALSE);
                             GtkTargetEntry *plainUTF8Target =
                              (GtkTargetEntry *)g_malloc(sizeof(GtkTargetEntry));
                             plainUTF8Target->target = g_strdup(gTextPlainUTF8Type);
                             plainUTF8Target->flags = 0;
+                            /* Bug 331198 */
+                            plainUTF8Target->info = NS_PTR_TO_UINT32(plainUTF8Atom);
                             PR_LOG(sDragLm, PR_LOG_DEBUG,
-                                   ("automatically adding target %s\n",
-                                    plainUTF8Target->target));
+                                   ("automatically adding target %s with \
+                                   id %ld\n", plainUTF8Target->target, plainUTF8Atom));
                             targetArray.AppendElement(plainUTF8Target);
 
+                            // get the atom for the ASCII string
+                            GdkAtom plainAtom =
+                              gdk_atom_intern(kTextMime, FALSE);
                             GtkTargetEntry *plainTarget =
                              (GtkTargetEntry *)g_malloc(sizeof(GtkTargetEntry));
                             plainTarget->target = g_strdup(kTextMime);
                             plainTarget->flags = 0;
+                            /* Bug 331198 */
+                            plainTarget->info = NS_PTR_TO_UINT32(plainAtom);
                             PR_LOG(sDragLm, PR_LOG_DEBUG,
-                                   ("automatically adding target %s\n",
-                                    plainTarget->target));
+                                   ("automatically adding target %s with \
+                                   id %ld\n", plainTarget->target, plainAtom));
                             targetArray.AppendElement(plainTarget);
                         }
                         // Check to see if this is the x-moz-url type.
                         // If it is, add _NETSCAPE_URL
                         // this is a type used by everybody.
                         if (strcmp(flavorStr, kURLMime) == 0) {
+                            // get the atom name for it
+                            GdkAtom urlAtom =
+                             gdk_atom_intern(gMozUrlType, FALSE);
                             GtkTargetEntry *urlTarget =
                              (GtkTargetEntry *)g_malloc(sizeof(GtkTargetEntry));
                             urlTarget->target = g_strdup(gMozUrlType);
                             urlTarget->flags = 0;
+                            /* Bug 331198 */
+                            urlTarget->info = NS_PTR_TO_UINT32(urlAtom);
                             PR_LOG(sDragLm, PR_LOG_DEBUG,
-                                   ("automatically adding target %s\n",
-                                    urlTarget->target));
+                                   ("automatically adding target %s with \
+                                   id %ld\n", urlTarget->target, urlAtom));
                             targetArray.AppendElement(urlTarget);
                         }
                     }
                 } // foreach flavor in item
             } // if valid flavor list
         } // if item is a transferable
     } // if it is a single item drag
 
@@ -1294,17 +1321,17 @@ nsDragService::GetSourceList(void)
         targets =
           (GtkTargetEntry *)g_malloc(sizeof(GtkTargetEntry) * targetCount);
         uint32_t targetIndex;
         for ( targetIndex = 0; targetIndex < targetCount; ++targetIndex) {
             GtkTargetEntry *disEntry = targetArray.ElementAt(targetIndex);
             // this is a string reference but it will be freed later.
             targets[targetIndex].target = disEntry->target;
             targets[targetIndex].flags = disEntry->flags;
-            targets[targetIndex].info = 0;
+            targets[targetIndex].info = disEntry->info;
         }
         targetList = gtk_target_list_new(targets, targetCount);
         // clean up the target list
         for (uint32_t cleanIndex = 0; cleanIndex < targetCount; ++cleanIndex) {
             GtkTargetEntry *thisTarget = targetArray.ElementAt(cleanIndex);
             g_free(thisTarget->target);
             g_free(thisTarget);
         }
@@ -1445,23 +1472,24 @@ CreateUriList(nsISupportsArray *items, g
     g_string_free(uriList, FALSE); // don't free the data
 }
 
 
 void
 nsDragService::SourceDataGet(GtkWidget        *aWidget,
                              GdkDragContext   *aContext,
                              GtkSelectionData *aSelectionData,
+                             guint             aInfo,
                              guint32           aTime)
 {
     PR_LOG(sDragLm, PR_LOG_DEBUG, ("nsDragService::SourceDataGet"));
-    GdkAtom target = gtk_selection_data_get_target(aSelectionData);
+    GdkAtom atom = (GdkAtom)aInfo;
     nsXPIDLCString mimeFlavor;
     gchar *typeName = 0;
-    typeName = gdk_atom_name(target);
+    typeName = gdk_atom_name(atom);
     if (!typeName) {
         PR_LOG(sDragLm, PR_LOG_DEBUG, ("failed to get atom name.\n"));
         return;
     }
 
     PR_LOG(sDragLm, PR_LOG_DEBUG, ("Type is %s\n", typeName));
     // make a copy since |nsXPIDLCString| won't use |g_free|...
     mimeFlavor.Adopt(nsCRT::strdup(typeName));
@@ -1534,29 +1562,31 @@ nsDragService::SourceDataGet(GtkWidget  
                     // this was not allocated using glib
                     free(tmpData);
                     tmpData = plainTextData;
                     tmpDataLen = plainTextLen;
                 }
             }
             if (tmpData) {
                 // this copies the data
-                gtk_selection_data_set(aSelectionData, target,
+                gtk_selection_data_set(aSelectionData,
+                                       gtk_selection_data_get_target(aSelectionData),
                                        8,
                                        (guchar *)tmpData, tmpDataLen);
                 // this wasn't allocated with glib
                 free(tmpData);
             }
         } else {
             if (strcmp(mimeFlavor, gTextUriListType) == 0) {
                 // fall back for text/uri-list
                 gchar *uriList;
                 gint length;
                 CreateUriList(mSourceDataItems, &uriList, &length);
-                gtk_selection_data_set(aSelectionData, target,
+                gtk_selection_data_set(aSelectionData,
+                                       gtk_selection_data_get_target(aSelectionData),
                                        8, (guchar *)uriList, length);
                 g_free(uriList);
                 return;
             }
         }
     }
 }
 
@@ -1625,17 +1655,17 @@ invisibleSourceDragDataGet(GtkWidget    
                            GtkSelectionData *aSelectionData,
                            guint             aInfo,
                            guint32           aTime,
                            gpointer          aData)
 {
     PR_LOG(sDragLm, PR_LOG_DEBUG, ("invisibleSourceDragDataGet"));
     nsDragService *dragService = (nsDragService *)aData;
     dragService->SourceDataGet(aWidget, aContext,
-                               aSelectionData, aTime);
+                               aSelectionData, aInfo, aTime);
 }
 
 static gboolean
 invisibleSourceDragFailed(GtkWidget        *aWidget,
                           GdkDragContext   *aContext,
                           gint              aResult,
                           gpointer          aData)
 {
--- a/widget/gtk2/nsDragService.h
+++ b/widget/gtk2/nsDragService.h
@@ -101,16 +101,17 @@ public:
     // These methods are public only so that they can be called from functions
     // with C calling conventions.  They are called for drags started with the
     // invisible widget.
     void           SourceEndDragSession(GdkDragContext *aContext,
                                         gint            aResult);
     void           SourceDataGet(GtkWidget        *widget,
                                  GdkDragContext   *context,
                                  GtkSelectionData *selection_data,
+                                 guint             info,
                                  guint32           aTime);
 
     // set the drag icon during drag-begin
     void SetDragIcon(GdkDragContext* aContext);
 
 private:
 
     // mScheduledTask indicates what signal has been received from GTK and
--- a/widget/gtk2/nsNativeThemeGTK.cpp
+++ b/widget/gtk2/nsNativeThemeGTK.cpp
@@ -1047,19 +1047,19 @@ nsNativeThemeGTK::GetMinimumWidgetSize(n
        * for the some scrollbars if buttons are hidden (bug 513006) because
        * the thumb isn't a direct child of the scrollbar, unlike the buttons
        * or track. So add a minimum size to the track as well to prevent a
        * 0-width scrollbar. */
       MozGtkScrollbarMetrics metrics;
       moz_gtk_get_scrollbar_metrics(&metrics);
 
       if (aWidgetType == NS_THEME_SCROLLBAR_TRACK_VERTICAL)
-        aResult->width = metrics.slider_width + 2 * metrics.trough_border;
+        aResult->width = metrics.slider_width;
       else
-        aResult->height = metrics.slider_width + 2 * metrics.trough_border;
+        aResult->height = metrics.slider_width;
 
       *aIsOverridable = false;
     }
     break;
     case NS_THEME_SCROLLBAR_THUMB_VERTICAL:
     case NS_THEME_SCROLLBAR_THUMB_HORIZONTAL:
       {
         MozGtkScrollbarMetrics metrics;
--- a/widget/gtkxtbin/gtk2xtbin.c
+++ b/widget/gtkxtbin/gtk2xtbin.c
@@ -560,21 +560,16 @@ xt_client_create ( XtClient* xtclient ,
                     (XtEventHandler)xt_client_focus_listener, 
                     xtclient);
   XSync(xtclient->xtdisplay, FALSE);
 }
 
 void
 xt_client_unrealize ( XtClient* xtclient )
 {
-  /* Explicitly destroy the child_widget window because this is actually a
-     child of the socket window.  It is not a child of top_widget's window
-     when that is destroyed. */
-  XtUnrealizeWidget(xtclient->child_widget);
-
 #if XlibSpecificationRelease >= 6
   XtUnregisterDrawable(xtclient->xtdisplay,
                        xtclient->top_widget->core.window);
 #else
   _XtUnregisterWindow(xtclient->top_widget->core.window,
                       xtclient->top_widget);
 #endif