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 128823 e8c8d9373eba3573dfaaf5ce90419eb574ac4722
parent 128822 6d504df6f023173832683178f62e25d6e894be4d
child 128824 1c3fed1032513ca9d2955fad8881e99640aa7af0
push id3582
push userbbajaj@mozilla.com
push dateMon, 01 Apr 2013 20:50:56 +0000
treeherdermozilla-aurora@400370bbc9fa [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
milestone22.0a1
backs outdd103ec4c44ba305cc5a08350e1352a7afcdb8ce
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