LCOV - app.info - widget/gtk2/nsWindow.h

LCOV - code coverage report
| Current view: | directory - widget/gtk2 - nsWindow.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 3 | 0 | 0.0 %
| Date: | 2012-04-21 | Functions: | 3 | 0 | 0.0 %

           1                 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
           2                 : /* vim:expandtab:shiftwidth=4:tabstop=4:
           3                 :  */
           4                 : /* ***** BEGIN LICENSE BLOCK *****
           5                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
           6                 :  *
           7                 :  * The contents of this file are subject to the Mozilla Public License Version
           8                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           9                 :  * the License. You may obtain a copy of the License at
          10                 :  * http://www.mozilla.org/MPL/
          11                 :  *
          12                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          13                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          14                 :  * for the specific language governing rights and limitations under the
          15                 :  * License.
          16                 :  *
          17                 :  * The Original Code is mozilla.org code.
          18                 :  *
          19                 :  * The Initial Developer of the Original Code is Christopher Blizzard
          20                 :  * <blizzard@mozilla.org>.  Portions created by the Initial Developer
          21                 :  * are Copyright (C) 2001 the Initial Developer. All Rights Reserved.
          22                 :  *
          23                 :  * Contributor(s):
          24                 :  *   Masayuki Nakano <masayuki@d-toybox.com>
          25                 :  *
          26                 :  * Alternatively, the contents of this file may be used under the terms of
          27                 :  * either the GNU General Public License Version 2 or later (the "GPL"), or
          28                 :  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          29                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          30                 :  * of those above. If you wish to allow use of your version of this file only
          31                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          32                 :  * use your version of this file under the terms of the MPL, indicate your
          33                 :  * decision by deleting the provisions above and replace them with the notice
          34                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          35                 :  * the provisions above, a recipient may use your version of this file under
          36                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          37                 :  *
          38                 :  * ***** END LICENSE BLOCK ***** */
          39                 :
          40                 : #ifndef __nsWindow_h__
          41                 : #define __nsWindow_h__
          42                 :
          43                 : #include "mozilla/ipc/SharedMemorySysV.h"
          44                 :
          45                 : #include "nsAutoPtr.h"
          46                 :
          47                 : #include "mozcontainer.h"
          48                 : #include "nsWeakReference.h"
          49                 :
          50                 : #include "nsIDragService.h"
          51                 : #include "nsITimer.h"
          52                 : #include "nsGkAtoms.h"
          53                 :
          54                 : #include "gfxASurface.h"
          55                 :
          56                 : #include "nsBaseWidget.h"
          57                 : #include "nsGUIEvent.h"
          58                 : #include <gdk/gdk.h>
          59                 : #include <gtk/gtk.h>
          60                 :
          61                 : #ifdef MOZ_X11
          62                 : #include <gdk/gdkx.h>
          63                 : #endif /* MOZ_X11 */
          64                 :
          65                 : #ifdef ACCESSIBILITY
          66                 : #include "nsAccessible.h"
          67                 : #endif
          68                 :
          69                 : #include "nsGtkIMModule.h"
          70                 :
          71                 : #ifdef MOZ_LOGGING
          72                 :
          73                 : // make sure that logging is enabled before including prlog.h
          74                 : #define FORCE_PR_LOG
          75                 :
          76                 : #include "prlog.h"
          77                 : #include "nsTArray.h"
          78                 :
          79                 : extern PRLogModuleInfo *gWidgetLog;
          80                 : extern PRLogModuleInfo *gWidgetFocusLog;
          81                 : extern PRLogModuleInfo *gWidgetDragLog;
          82                 : extern PRLogModuleInfo *gWidgetDrawLog;
          83                 :
          84                 : #define LOG(args) PR_LOG(gWidgetLog, 4, args)
          85                 : #define LOGFOCUS(args) PR_LOG(gWidgetFocusLog, 4, args)
          86                 : #define LOGDRAG(args) PR_LOG(gWidgetDragLog, 4, args)
          87                 : #define LOGDRAW(args) PR_LOG(gWidgetDrawLog, 4, args)
          88                 :
          89                 : #else
          90                 :
          91                 : #define LOG(args)
          92                 : #define LOGFOCUS(args)
          93                 : #define LOGDRAG(args)
          94                 : #define LOGDRAW(args)
          95                 :
          96                 : #endif /* MOZ_LOGGING */
          97                 :
          98                 : #if defined(MOZ_X11) && defined(MOZ_HAVE_SHAREDMEMORYSYSV)
          99                 : #  define MOZ_HAVE_SHMIMAGE
         100                 :
         101                 : class nsShmImage;
         102                 : #endif
         103                 :
         104                 : class nsWindow : public nsBaseWidget, public nsSupportsWeakReference
         105                 : {
         106                 : public:
         107                 :     nsWindow();
         108                 :     virtual ~nsWindow();
         109                 :
         110                 :     static void ReleaseGlobals();
         111                 :
         112                 :     NS_DECL_ISUPPORTS_INHERITED
         113                 :
         114                 :     void CommonCreate(nsIWidget *aParent, bool aListenForResizes);
         115                 :
         116                 :     // event handling code
         117                 :     void DispatchActivateEvent(void);
         118                 :     void DispatchDeactivateEvent(void);
         119                 :     void DispatchResizeEvent(nsIntRect &aRect, nsEventStatus &aStatus);
         120                 :
         121                 :     virtual nsresult DispatchEvent(nsGUIEvent *aEvent, nsEventStatus &aStatus);
         122                 :
         123                 :     // called when we are destroyed
         124                 :     void OnDestroy(void);
         125                 :
         126                 :     // called to check and see if a widget's dimensions are sane
         127                 :     bool AreBoundsSane(void);
         128                 :
         129                 :     // nsIWidget
         130                 :     NS_IMETHOD         Create(nsIWidget        *aParent,
         131                 :                               nsNativeWidget   aNativeParent,
         132                 :                               const nsIntRect  &aRect,
         133                 :                               EVENT_CALLBACK   aHandleEventFunction,
         134                 :                               nsDeviceContext *aContext,
         135                 :                               nsWidgetInitData *aInitData);
         136                 :     NS_IMETHOD         Destroy(void);
         137                 :     virtual nsIWidget *GetParent();
         138                 :     virtual float      GetDPI();
         139                 :     virtual nsresult   SetParent(nsIWidget* aNewParent);
         140                 :     NS_IMETHOD         SetModal(bool aModal);
         141                 :     NS_IMETHOD         IsVisible(bool & aState);
         142                 :     NS_IMETHOD         ConstrainPosition(bool aAllowSlop,
         143                 :                                          PRInt32 *aX,
         144                 :                                          PRInt32 *aY);
         145                 :     NS_IMETHOD         Move(PRInt32 aX,
         146                 :                             PRInt32 aY);
         147                 :     NS_IMETHOD         Show             (bool aState);
         148                 :     NS_IMETHOD         Resize           (PRInt32 aWidth,
         149                 :                                          PRInt32 aHeight,
         150                 :                                          bool    aRepaint);
         151                 :     NS_IMETHOD         Resize           (PRInt32 aX,
         152                 :                                          PRInt32 aY,
         153                 :                                          PRInt32 aWidth,
         154                 :                                          PRInt32 aHeight,
         155                 :                                          bool     aRepaint);
         156                 :     NS_IMETHOD         IsEnabled        (bool *aState);
         157                 :
         158                 :
         159                 :     NS_IMETHOD         PlaceBehind(nsTopLevelWidgetZPlacement  aPlacement,
         160                 :                                    nsIWidget                  *aWidget,
         161                 :                                    bool                        aActivate);
         162                 :     NS_IMETHOD         SetZIndex(PRInt32 aZIndex);
         163                 :     NS_IMETHOD         SetSizeMode(PRInt32 aMode);
         164                 :     NS_IMETHOD         Enable(bool aState);
         165                 :     NS_IMETHOD         SetFocus(bool aRaise = false);
         166                 :     NS_IMETHOD         GetScreenBounds(nsIntRect &aRect);
         167                 :     NS_IMETHOD         GetClientBounds(nsIntRect &aRect);
         168                 :     virtual nsIntPoint GetClientOffset();
         169                 :     NS_IMETHOD         SetForegroundColor(const nscolor &aColor);
         170                 :     NS_IMETHOD         SetBackgroundColor(const nscolor &aColor);
         171                 :     NS_IMETHOD         SetCursor(nsCursor aCursor);
         172                 :     NS_IMETHOD         SetCursor(imgIContainer* aCursor,
         173                 :                                  PRUint32 aHotspotX, PRUint32 aHotspotY);
         174                 :     NS_IMETHOD         Invalidate(const nsIntRect &aRect);
         175                 :     virtual void*      GetNativeData(PRUint32 aDataType);
         176                 :     NS_IMETHOD         SetTitle(const nsAString& aTitle);
         177                 :     NS_IMETHOD         SetIcon(const nsAString& aIconSpec);
         178                 :     NS_IMETHOD         SetWindowClass(const nsAString& xulWinType);
         179                 :     virtual nsIntPoint WidgetToScreenOffset();
         180                 :     NS_IMETHOD         EnableDragDrop(bool aEnable);
         181                 :     NS_IMETHOD         CaptureMouse(bool aCapture);
         182                 :     NS_IMETHOD         CaptureRollupEvents(nsIRollupListener *aListener,
         183                 :                                            bool aDoCapture,
         184                 :                                            bool aConsumeRollupEvent);
         185                 :     NS_IMETHOD         GetAttention(PRInt32 aCycleCount);
         186                 :
         187                 :     virtual bool       HasPendingInputEvent();
         188                 :
         189                 :     NS_IMETHOD         MakeFullScreen(bool aFullScreen);
         190                 :     NS_IMETHOD         HideWindowChrome(bool aShouldHide);
         191                 :
         192                 :     /**
         193                 :      * GetLastUserInputTime returns a timestamp for the most recent user input
         194                 :      * event.  This is intended for pointer grab requests (including drags).
         195                 :      */
         196                 :     static guint32     GetLastUserInputTime();
         197                 :
         198                 :     // utility method, -1 if no change should be made, otherwise returns a
         199                 :     // value that can be passed to gdk_window_set_decorations
         200                 :     gint               ConvertBorderStyles(nsBorderStyle aStyle);
         201                 :
         202                 :     // event callbacks
         203                 : #if defined(MOZ_WIDGET_GTK2)
         204                 :     gboolean           OnExposeEvent(GdkEventExpose *aEvent);
         205                 : #else
         206                 :     gboolean           OnExposeEvent(cairo_t *cr);
         207                 : #endif
         208                 :     gboolean           OnConfigureEvent(GtkWidget *aWidget,
         209                 :                                         GdkEventConfigure *aEvent);
         210                 :     void               OnContainerUnrealize(GtkWidget *aWidget);
         211                 :     void               OnSizeAllocate(GtkWidget *aWidget,
         212                 :                                       GtkAllocation *aAllocation);
         213                 :     void               OnDeleteEvent(GtkWidget *aWidget,
         214                 :                                      GdkEventAny *aEvent);
         215                 :     void               OnEnterNotifyEvent(GtkWidget *aWidget,
         216                 :                                           GdkEventCrossing *aEvent);
         217                 :     void               OnLeaveNotifyEvent(GtkWidget *aWidget,
         218                 :                                           GdkEventCrossing *aEvent);
         219                 :     void               OnMotionNotifyEvent(GtkWidget *aWidget,
         220                 :                                            GdkEventMotion *aEvent);
         221                 :     void               OnButtonPressEvent(GtkWidget *aWidget,
         222                 :                                           GdkEventButton *aEvent);
         223                 :     void               OnButtonReleaseEvent(GtkWidget *aWidget,
         224                 :                                             GdkEventButton *aEvent);
         225                 :     void               OnContainerFocusInEvent(GtkWidget *aWidget,
         226                 :                                                GdkEventFocus *aEvent);
         227                 :     void               OnContainerFocusOutEvent(GtkWidget *aWidget,
         228                 :                                                 GdkEventFocus *aEvent);
         229                 :     gboolean           OnKeyPressEvent(GtkWidget *aWidget,
         230                 :                                        GdkEventKey *aEvent);
         231                 :     gboolean           OnKeyReleaseEvent(GtkWidget *aWidget,
         232                 :                                          GdkEventKey *aEvent);
         233                 :     void               OnScrollEvent(GtkWidget *aWidget,
         234                 :                                      GdkEventScroll *aEvent);
         235                 :     void               OnVisibilityNotifyEvent(GtkWidget *aWidget,
         236                 :                                                GdkEventVisibility *aEvent);
         237                 :     void               OnWindowStateEvent(GtkWidget *aWidget,
         238                 :                                           GdkEventWindowState *aEvent);
         239                 :     gboolean           OnDragMotionEvent(GtkWidget       *aWidget,
         240                 :                                          GdkDragContext  *aDragContext,
         241                 :                                          gint             aX,
         242                 :                                          gint             aY,
         243                 :                                          guint            aTime,
         244                 :                                          gpointer         aData);
         245                 :     void               OnDragLeaveEvent(GtkWidget *      aWidget,
         246                 :                                         GdkDragContext   *aDragContext,
         247                 :                                         guint            aTime,
         248                 :                                         gpointer         aData);
         249                 :     gboolean           OnDragDropEvent(GtkWidget        *aWidget,
         250                 :                                        GdkDragContext   *aDragContext,
         251                 :                                        gint             aX,
         252                 :                                        gint             aY,
         253                 :                                        guint            aTime,
         254                 :                                        gpointer         aData);
         255                 :     void               OnDragDataReceivedEvent(GtkWidget       *aWidget,
         256                 :                                                GdkDragContext  *aDragContext,
         257                 :                                                gint             aX,
         258                 :                                                gint             aY,
         259                 :                                                GtkSelectionData*aSelectionData,
         260                 :                                                guint            aInfo,
         261                 :                                                guint            aTime,
         262                 :                                                gpointer         aData);
         263                 :     void               OnDragLeave(void);
         264                 :     void               OnDragEnter(nscoord aX, nscoord aY);
         265                 :
         266                 : private:
         267                 :     void               NativeResize(PRInt32 aWidth,
         268                 :                                     PRInt32 aHeight,
         269                 :                                     bool    aRepaint);
         270                 :
         271                 :     void               NativeResize(PRInt32 aX,
         272                 :                                     PRInt32 aY,
         273                 :                                     PRInt32 aWidth,
         274                 :                                     PRInt32 aHeight,
         275                 :                                     bool    aRepaint);
         276                 :
         277                 :     void               NativeShow  (bool    aAction);
         278                 :     void               SetHasMappedToplevel(bool aState);
         279                 :     nsIntSize          GetSafeWindowSize(nsIntSize aSize);
         280                 :
         281                 :     void               EnsureGrabs  (void);
         282                 :     void               GrabPointer  (guint32 aTime);
         283                 :     void               ReleaseGrabs (void);
         284                 :
         285                 : public:
         286                 :     enum PluginType {
         287                 :         PluginType_NONE = 0,   /* do not have any plugin */
         288                 :         PluginType_XEMBED,     /* the plugin support xembed */
         289                 :         PluginType_NONXEMBED   /* the plugin does not support xembed */
         290                 :     };
         291                 :
         292                 :     void               SetPluginType(PluginType aPluginType);
         293                 : #ifdef MOZ_X11
         294                 :     void               SetNonXEmbedPluginFocus(void);
         295                 :     void               LoseNonXEmbedPluginFocus(void);
         296                 : #endif /* MOZ_X11 */
         297                 :
         298                 :     void               ThemeChanged(void);
         299                 :
         300                 :     void CheckNeedDragLeaveEnter(nsWindow* aInnerMostWidget,
         301                 :                                  nsIDragService* aDragService,
         302                 :                                  GdkDragContext *aDragContext,
         303                 :                                  nscoord aX, nscoord aY);
         304                 :
         305                 : #ifdef MOZ_X11
         306                 :     Window             mOldFocusWindow;
         307                 : #endif /* MOZ_X11 */
         308                 :
         309                 :     static guint32     sLastButtonPressTime;
         310                 :     static guint32     sLastButtonReleaseTime;
         311                 :
         312                 :     NS_IMETHOD         BeginResizeDrag(nsGUIEvent* aEvent, PRInt32 aHorizontal, PRInt32 aVertical);
         313                 :     NS_IMETHOD         BeginMoveDrag(nsMouseEvent* aEvent);
         314                 :
         315               0 :     MozContainer*      GetMozContainer() { return mContainer; }
         316               0 :     GdkWindow*         GetGdkWindow() { return mGdkWindow; }
         317               0 :     bool               IsDestroyed() { return mIsDestroyed; }
         318                 :
         319                 :     // If this dispatched the keydown event actually, this returns TRUE,
         320                 :     // otherwise, FALSE.
         321                 :     bool               DispatchKeyDownEvent(GdkEventKey *aEvent,
         322                 :                                             bool *aIsCancelled);
         323                 :
         324                 :     NS_IMETHOD ResetInputState();
         325                 :     NS_IMETHOD_(void) SetInputContext(const InputContext& aContext,
         326                 :                                       const InputContextAction& aAction);
         327                 :     NS_IMETHOD_(InputContext) GetInputContext();
         328                 :     NS_IMETHOD CancelIMEComposition();
         329                 :     NS_IMETHOD OnIMEFocusChange(bool aFocus);
         330                 :     NS_IMETHOD GetToggledKeyState(PRUint32 aKeyCode, bool* aLEDState);
         331                 :
         332                 :    void                ResizeTransparencyBitmap(PRInt32 aNewWidth, PRInt32 aNewHeight);
         333                 :    void                ApplyTransparencyBitmap();
         334                 :    virtual void        SetTransparencyMode(nsTransparencyMode aMode);
         335                 :    virtual nsTransparencyMode GetTransparencyMode();
         336                 :    virtual nsresult    ConfigureChildren(const nsTArray<Configuration>& aConfigurations);
         337                 :    nsresult            UpdateTranslucentWindowAlphaInternal(const nsIntRect& aRect,
         338                 :                                                             PRUint8* aAlphas, PRInt32 aStride);
         339                 :
         340                 : #if defined(MOZ_WIDGET_GTK2)
         341                 :     gfxASurface       *GetThebesSurface();
         342                 :
         343                 :     static already_AddRefed<gfxASurface> GetSurfaceForGdkDrawable(GdkDrawable* aDrawable,
         344                 :                                                                   const nsIntSize& aSize);
         345                 : #else
         346                 :     gfxASurface       *GetThebesSurface(cairo_t *cr);
         347                 : #endif
         348                 :     NS_IMETHOD         ReparentNativeWidget(nsIWidget* aNewParent);
         349                 :
         350                 : protected:
         351                 :     // Helper for SetParent and ReparentNativeWidget.
         352                 :     void ReparentNativeWidgetInternal(nsIWidget* aNewParent,
         353                 :                                       GtkWidget* aNewContainer,
         354                 :                                       GdkWindow* aNewParentWindow,
         355                 :                                       GtkWidget* aOldContainer);
         356                 :     nsCOMPtr<nsIWidget> mParent;
         357                 :     // Is this a toplevel window?
         358                 :     bool                mIsTopLevel;
         359                 :     // Has this widget been destroyed yet?
         360                 :     bool                mIsDestroyed;
         361                 :
         362                 :     // This is a flag that tracks if we need to resize a widget or
         363                 :     // window when we show it.
         364                 :     bool                mNeedsResize;
         365                 :     // This is a flag that tracks if we need to move a widget or
         366                 :     // window when we show it.
         367                 :     bool                mNeedsMove;
         368                 :     // Should we send resize events on all resizes?
         369                 :     bool                mListenForResizes;
         370                 :     // This flag tracks if we're hidden or shown.
         371                 :     bool                mIsShown;
         372                 :     bool                mNeedsShow;
         373                 :     // is this widget enabled?
         374                 :     bool                mEnabled;
         375                 :     // has the native window for this been created yet?
         376                 :     bool                mCreated;
         377                 :
         378                 : private:
         379                 :     void               DestroyChildWindows();
         380                 :     void               GetToplevelWidget(GtkWidget **aWidget);
         381                 :     GtkWidget         *GetMozContainerWidget();
         382                 :     nsWindow          *GetContainerWindow();
         383                 :     void               SetUrgencyHint(GtkWidget *top_window, bool state);
         384                 :     void              *SetupPluginPort(void);
         385                 :     void               SetDefaultIcon(void);
         386                 :     void               InitButtonEvent(nsMouseEvent &aEvent, GdkEventButton *aGdkEvent);
         387                 :     bool               DispatchCommandEvent(nsIAtom* aCommand);
         388                 :     bool               DispatchContentCommandEvent(PRInt32 aMsg);
         389                 :     void               SetWindowClipRegion(const nsTArray<nsIntRect>& aRects,
         390                 :                                            bool aIntersectWithExisting);
         391                 :     bool               GetDragInfo(nsMouseEvent* aMouseEvent,
         392                 :                                    GdkWindow** aWindow, gint* aButton,
         393                 :                                    gint* aRootX, gint* aRootY);
         394                 :     void               ClearCachedResources();
         395                 :
         396                 :     GtkWidget          *mShell;
         397                 :     MozContainer       *mContainer;
         398                 :     GdkWindow          *mGdkWindow;
         399                 :
         400                 :     GtkWindowGroup     *mWindowGroup;
         401                 :
         402                 :     PRUint32            mHasMappedToplevel : 1,
         403                 :                         mIsFullyObscured : 1,
         404                 :                         mRetryPointerGrab : 1;
         405                 :     GtkWindow          *mTransientParent;
         406                 :     PRInt32             mSizeState;
         407                 :     PluginType          mPluginType;
         408                 :
         409                 :     PRInt32             mTransparencyBitmapWidth;
         410                 :     PRInt32             mTransparencyBitmapHeight;
         411                 :
         412                 : #ifdef MOZ_HAVE_SHMIMAGE
         413                 :     // If we're using xshm rendering, mThebesSurface wraps mShmImage
         414                 :     nsRefPtr<nsShmImage>  mShmImage;
         415                 : #endif
         416                 :     nsRefPtr<gfxASurface> mThebesSurface;
         417                 :
         418                 : #ifdef ACCESSIBILITY
         419                 :     nsRefPtr<nsAccessible> mRootAccessible;
         420                 :
         421                 :     /**
         422                 :      * Request to create the accessible for this window if it is top level.
         423                 :      */
         424                 :     void                CreateRootAccessible();
         425                 :
         426                 :     /**
         427                 :      * Generate the NS_GETACCESSIBLE event to get accessible for this window
         428                 :      * and return it.
         429                 :      */
         430                 :     nsAccessible       *DispatchAccessibleEvent();
         431                 :
         432                 :     /**
         433                 :      * Dispatch accessible event for the top level window accessible.
         434                 :      *
         435                 :      * @param  aEventType  [in] the accessible event type to dispatch
         436                 :      */
         437                 :     void                DispatchEventToRootAccessible(PRUint32 aEventType);
         438                 :
         439                 :     /**
         440                 :      * Dispatch accessible window activate event for the top level window
         441                 :      * accessible.
         442                 :      */
         443                 :     void                DispatchActivateEventAccessible();
         444                 :
         445                 :     /**
         446                 :      * Dispatch accessible window deactivate event for the top level window
         447                 :      * accessible.
         448                 :      */
         449                 :     void                DispatchDeactivateEventAccessible();
         450                 :
         451                 :     /**
         452                 :      * Dispatch accessible window maximize event for the top level window
         453                 :      * accessible.
         454                 :      */
         455                 :     void                DispatchMaximizeEventAccessible();
         456                 :
         457                 :     /**
         458                 :      * Dispatch accessible window minize event for the top level window
         459                 :      * accessible.
         460                 :      */
         461                 :     void                DispatchMinimizeEventAccessible();
         462                 :
         463                 :     /**
         464                 :      * Dispatch accessible window restore event for the top level window
         465                 :      * accessible.
         466                 :      */
         467                 :     void                DispatchRestoreEventAccessible();
         468                 : #endif
         469                 :
         470                 :     // The cursor cache
         471                 :     static GdkCursor   *gsGtkCursorCache[eCursorCount];
         472                 :
         473                 :     // Transparency
         474                 :     bool         mIsTransparent;
         475                 :     // This bitmap tracks which pixels are transparent. We don't support
         476                 :     // full translucency at this time; each pixel is either fully opaque
         477                 :     // or fully transparent.
         478                 :     gchar*       mTransparencyBitmap;
         479                 :
         480                 :     // all of our DND stuff
         481                 :     // this is the last window that had a drag event happen on it.
         482                 :     static nsWindow    *sLastDragMotionWindow;
         483                 :     void   InitDragEvent         (nsDragEvent &aEvent);
         484                 :     void   UpdateDragStatus      (GdkDragContext *aDragContext,
         485                 :                                   nsIDragService *aDragService);
         486                 :
         487                 :     nsCOMPtr<nsITimer> mDragLeaveTimer;
         488                 :     float              mLastMotionPressure;
         489                 :
         490                 :     // Remember the last sizemode so that we can restore it when
         491                 :     // leaving fullscreen
         492                 :     nsSizeMode         mLastSizeMode;
         493                 :
         494                 :     static bool        sIsDraggingOutOf;
         495                 :     // drag in progress
         496                 :     static bool DragInProgress(void);
         497                 :
         498                 :     void         FireDragLeaveTimer       (void);
         499                 :     static void  DragLeaveTimerCallback  (nsITimer *aTimer, void *aClosure);
         500                 :
         501                 :     void DispatchMissedButtonReleases(GdkEventCrossing *aGdkEvent);
         502                 :
         503                 :     /**
         504                 :      * |mIMModule| takes all IME related stuff.
         505                 :      *
         506                 :      * This is owned by the top-level nsWindow or the topmost child
         507                 :      * nsWindow embedded in a non-Gecko widget.
         508                 :      *
         509                 :      * The instance is created when the top level widget is created.  And when
         510                 :      * the widget is destroyed, it's released.  All child windows refer its
         511                 :      * ancestor widget's instance.  So, one set of IM contexts is created for
         512                 :      * all windows in a hierarchy.  If the children are released after the top
         513                 :      * level window is released, the children still have a valid pointer,
         514                 :      * however, IME doesn't work at that time.
         515                 :      */
         516                 :     nsRefPtr<nsGtkIMModule> mIMModule;
         517                 : };
         518                 :
         519                 : class nsChildWindow : public nsWindow {
         520                 : public:
         521                 :     nsChildWindow();
         522                 :     ~nsChildWindow();
         523                 : };
         524                 :
         525                 : #endif /* __nsWindow_h__ */

Generated by: LCOV version 1.7