execute move of global headers

see https://gerrit.libreoffice.org/#/c/3367/
and Change-Id: I00c96fa77d04b33a6f8c8cd3490dfcd9bdc9e84a for details

Change-Id: I199a75bc4042af20817265d5ef85b1134a96ff5a

1 files changed, 1279 insertions, 0 deletions

diff --git a/include/vcl/window.hxx b/include/vcl/window.hxx
new file mode 100644
index 000000000000..43e232dab55c
--- /dev/null
+++ b/include/vcl/window.hxx
@@ -0,0 +1,1279 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef _SV_WINDOW_HXX
+#define _SV_WINDOW_HXX
+
+#include <tools/solar.h>
+#include <vcl/dllapi.h>
+#include <vcl/outdev.hxx>
+#include <tools/resid.hxx>
+#include <vcl/pointr.hxx>
+#include <tools/wintypes.hxx>
+#include <rsc/rsc-vcl-shared-types.hxx>
+#include <vcl/apptypes.hxx>
+#include <vcl/inputctx.hxx>
+#include <vcl/vclevent.hxx>
+// Only for compatibility - because many people outside haven't included event.hxx
+#include <vcl/event.hxx>
+#include <vcl/region.hxx>
+#include <vcl/salnativewidgets.hxx>
+#include <rtl/ustring.hxx>
+#include <cppuhelper/weakref.hxx>
+#include <com/sun/star/uno/Reference.hxx>
+#include <boost/shared_ptr.hpp>
+
+class VirtualDevice;
+struct ImplDelData;
+struct ImplWinData;
+struct ImplOverlapData;
+struct ImplFrameData;
+struct ImplCalcToTopData;
+struct SystemEnvData;
+struct SystemParentData;
+class ImplBorderWindow;
+class VirtualDevice;
+class Timer;
+class Cursor;
+class DockingManager;
+class ScrollBar;
+class Bitmap;
+class FixedText;
+class Image;
+class MouseEvent;
+class KeyEvent;
+class CommandEvent;
+class TrackingEvent;
+class HelpEvent;
+class DataChangedEvent;
+class NotifyEvent;
+class SystemWindow;
+class SalFrame;
+class SalObject;
+class MenuFloatingWindow;
+class UNOWindowData;
+// Nur fuer ExecuteDrag:
+struct IDataObject;
+class VCLXWindow;
+struct ImplAccessibleInfos;
+
+namespace com {
+namespace sun {
+namespace star {
+namespace accessibility {
+    class XAccessible;
+}}}}
+
+namespace com {
+namespace sun {
+namespace star {
+namespace beans {
+    struct PropertyValue;
+}}}}
+
+namespace com {
+namespace sun {
+namespace star {
+namespace rendering {
+    class XCanvas;
+    class XSpriteCanvas;
+}}}}
+
+namespace com {
+namespace sun {
+namespace star {
+namespace awt {
+    class XWindowPeer;
+    class XWindow;
+}
+namespace uno {
+    class Any;
+    class XInterface;
+}
+namespace datatransfer {
+namespace clipboard {
+    class XClipboard;
+}
+
+namespace dnd {
+    class XDragGestureRecognizer;
+    class XDragSource;
+    class XDropTarget;
+} } } } }
+
+namespace vcl {
+    struct ControlLayoutData;
+}
+
+namespace svt { class PopupWindowControllerImpl; }
+
+// ---------------
+// - WindowTypes -
+// ---------------
+
+// Type fuer GetWindow()
+#define WINDOW_PARENT                   ((sal_uInt16)0)
+#define WINDOW_FIRSTCHILD               ((sal_uInt16)1)
+#define WINDOW_LASTCHILD                ((sal_uInt16)2)
+#define WINDOW_PREV                     ((sal_uInt16)3)
+#define WINDOW_NEXT                     ((sal_uInt16)4)
+#define WINDOW_FIRSTOVERLAP             ((sal_uInt16)5)
+#define WINDOW_LASTOVERLAP              ((sal_uInt16)6)
+#define WINDOW_OVERLAP                  ((sal_uInt16)7)
+#define WINDOW_PARENTOVERLAP            ((sal_uInt16)8)
+#define WINDOW_CLIENT                   ((sal_uInt16)9)
+#define WINDOW_REALPARENT               ((sal_uInt16)10)
+#define WINDOW_FRAME                    ((sal_uInt16)11)
+#define WINDOW_BORDER                   ((sal_uInt16)12)
+#define WINDOW_FIRSTTOPWINDOWCHILD      ((sal_uInt16)13)
+#define WINDOW_LASTTOPWINDOWCHILD       ((sal_uInt16)14)
+#define WINDOW_PREVTOPWINDOWSIBLING     ((sal_uInt16)15)
+#define WINDOW_NEXTTOPWINDOWSIBLING     ((sal_uInt16)16)
+
+// Flags for setPosSizePixel()
+#define WINDOW_POSSIZE_X                ((sal_uInt16)0x0001)
+#define WINDOW_POSSIZE_Y                ((sal_uInt16)0x0002)
+#define WINDOW_POSSIZE_WIDTH            ((sal_uInt16)0x0004)
+#define WINDOW_POSSIZE_HEIGHT           ((sal_uInt16)0x0008)
+#define WINDOW_POSSIZE_POS              (WINDOW_POSSIZE_X | WINDOW_POSSIZE_Y)
+#define WINDOW_POSSIZE_SIZE             (WINDOW_POSSIZE_WIDTH | WINDOW_POSSIZE_HEIGHT)
+#define WINDOW_POSSIZE_POSSIZE          (WINDOW_POSSIZE_POS | WINDOW_POSSIZE_SIZE)
+#define WINDOW_POSSIZE_ALL              (WINDOW_POSSIZE_POSSIZE)
+#define WINDOW_POSSIZE_DROPDOWN         ((sal_uInt16)0x0010)
+
+// Flags for Show()
+#define SHOW_NOPARENTUPDATE             ((sal_uInt16)0x0001)
+#define SHOW_NOFOCUSCHANGE              ((sal_uInt16)0x0002)
+#define SHOW_NOACTIVATE                 ((sal_uInt16)0x0004)
+#define SHOW_FOREGROUNDTASK             ((sal_uInt16)0x0008)
+
+// Flags for SetZOrder()
+#define WINDOW_ZORDER_BEFOR             ((sal_uInt16)0x0001)
+#define WINDOW_ZORDER_BEHIND            ((sal_uInt16)0x0002)
+#define WINDOW_ZORDER_FIRST             ((sal_uInt16)0x0004)
+#define WINDOW_ZORDER_LAST              ((sal_uInt16)0x0008)
+
+// Activate-Flags
+#define ACTIVATE_MODE_GRABFOCUS         ((sal_uInt16)0x0001)
+
+// ToTop-Flags
+#define TOTOP_RESTOREWHENMIN            ((sal_uInt16)0x0001)
+#define TOTOP_FOREGROUNDTASK            ((sal_uInt16)0x0002)
+#define TOTOP_NOGRABFOCUS               ((sal_uInt16)0x0004)
+#define TOTOP_GRABFOCUSONLY             ((sal_uInt16)0x0008)
+
+// Flags for Invalidate
+#define INVALIDATE_CHILDREN             ((sal_uInt16)0x0001)
+#define INVALIDATE_NOCHILDREN           ((sal_uInt16)0x0002)
+#define INVALIDATE_NOERASE              ((sal_uInt16)0x0004)
+#define INVALIDATE_UPDATE               ((sal_uInt16)0x0008)
+#define INVALIDATE_TRANSPARENT          ((sal_uInt16)0x0010)
+#define INVALIDATE_NOTRANSPARENT        ((sal_uInt16)0x0020)
+#define INVALIDATE_NOCLIPCHILDREN       ((sal_uInt16)0x4000)
+// Temporaer fuer Kompatibilitaet
+#define INVALIDATE_BACKGROUND           INVALIDATE_TRANSPARENT
+
+// Flags for Validate
+#define VALIDATE_CHILDREN               ((sal_uInt16)0x0001)
+#define VALIDATE_NOCHILDREN             ((sal_uInt16)0x0002)
+
+// Flags for Scroll
+#define SCROLL_CLIP                     ((sal_uInt16)0x0001)
+#define SCROLL_CHILDREN                 ((sal_uInt16)0x0002)
+#define SCROLL_NOCHILDREN               ((sal_uInt16)0x0004)
+#define SCROLL_NOERASE                  ((sal_uInt16)0x0008)
+#define SCROLL_NOINVALIDATE             ((sal_uInt16)0x0010)
+#define SCROLL_NOWINDOWINVALIDATE       ((sal_uInt16)0x0020)
+#define SCROLL_USECLIPREGION            ((sal_uInt16)0x0040)
+#define SCROLL_UPDATE                   ((sal_uInt16)0x0080)
+
+// Flags for ParentClipMode
+#define PARENTCLIPMODE_CLIP             ((sal_uInt16)0x0001)
+#define PARENTCLIPMODE_NOCLIP           ((sal_uInt16)0x0002)
+
+// Flags for Invert()
+#define INVERT_HIGHLIGHT                ((sal_uInt16)0x0001)
+#define INVERT_50                       ((sal_uInt16)0x0002)
+
+// Flags for ShowTracking()
+#define SHOWTRACK_SMALL                 ((sal_uInt16)0x0001)
+#define SHOWTRACK_BIG                   ((sal_uInt16)0x0002)
+#define SHOWTRACK_SPLIT                 ((sal_uInt16)0x0003)
+#define SHOWTRACK_OBJECT                ((sal_uInt16)0x0004)
+#define SHOWTRACK_WINDOW                ((sal_uInt16)0x1000)
+#define SHOWTRACK_CLIP                  ((sal_uInt16)0x2000)
+#define SHOWTRACK_STYLE                 ((sal_uInt16)0x000F)
+
+// Flags for StartTracking()
+#define STARTTRACK_KEYINPUT             ((sal_uInt16)0x0001)
+#define STARTTRACK_KEYMOD               ((sal_uInt16)0x0002)
+#define STARTTRACK_NOKEYCANCEL          ((sal_uInt16)0x0004)
+#define STARTTRACK_SCROLLREPEAT         ((sal_uInt16)0x0008)
+#define STARTTRACK_BUTTONREPEAT         ((sal_uInt16)0x0010)
+#define STARTTRACK_MOUSEBUTTONDOWN      ((sal_uInt16)0x0020)
+#define STARTTRACK_FOCUSCANCEL          ((sal_uInt16)0x0040)
+
+// Flags for StartAutoScroll()
+#define AUTOSCROLL_VERT                 ((sal_uInt16)0x0001)
+#define AUTOSCROLL_HORZ                 ((sal_uInt16)0x0002)
+
+// Flags for StateChanged()
+typedef sal_uInt16 StateChangedType;
+#define STATE_CHANGE_INITSHOW           ((StateChangedType)1)
+#define STATE_CHANGE_VISIBLE            ((StateChangedType)2)
+#define STATE_CHANGE_UPDATEMODE         ((StateChangedType)3)
+#define STATE_CHANGE_ENABLE             ((StateChangedType)4)
+#define STATE_CHANGE_TEXT               ((StateChangedType)5)
+#define STATE_CHANGE_IMAGE              ((StateChangedType)6)
+#define STATE_CHANGE_DATA               ((StateChangedType)7)
+#define STATE_CHANGE_STATE              ((StateChangedType)8)
+#define STATE_CHANGE_STYLE              ((StateChangedType)9)
+#define STATE_CHANGE_ZOOM               ((StateChangedType)10)
+#define STATE_CHANGE_BORDER             ((StateChangedType)11)
+#define STATE_CHANGE_TRANSPARENT        ((StateChangedType)12)
+#define STATE_CHANGE_CONTROLFONT        ((StateChangedType)13)
+#define STATE_CHANGE_CONTROLFOREGROUND  ((StateChangedType)14)
+#define STATE_CHANGE_CONTROLBACKGROUND  ((StateChangedType)15)
+#define STATE_CHANGE_READONLY           ((StateChangedType)16)
+#define STATE_CHANGE_EXTENDEDSTYLE      ((StateChangedType)17)
+#define STATE_CHANGE_MIRRORING          ((StateChangedType)18)
+#define STATE_CHANGE_CONTROL_FOCUS      ((StateChangedType)20)
+#define STATE_CHANGE_USER               ((StateChangedType)10000)
+
+// GetFocusFlags
+#define GETFOCUS_TAB                    ((sal_uInt16)0x0001)
+#define GETFOCUS_CURSOR                 ((sal_uInt16)0x0002)
+#define GETFOCUS_MNEMONIC               ((sal_uInt16)0x0004)
+#define GETFOCUS_FORWARD                ((sal_uInt16)0x0010)
+#define GETFOCUS_BACKWARD               ((sal_uInt16)0x0020)
+#define GETFOCUS_AROUND                 ((sal_uInt16)0x0040)
+#define GETFOCUS_UNIQUEMNEMONIC         ((sal_uInt16)0x0100)
+#define GETFOCUS_INIT                   ((sal_uInt16)0x0200)
+#define GETFOCUS_FLOATWIN_POPUPMODEEND_CANCEL ((sal_uInt16)0x0400)
+
+// Draw-Flags fuer Draw()
+#define WINDOW_DRAW_MONO                ((sal_uLong)0x00000001)
+#define WINDOW_DRAW_NOBORDER            ((sal_uLong)0x00000002)
+#define WINDOW_DRAW_NOCONTROLS          ((sal_uLong)0x00000004)
+#define WINDOW_DRAW_NODISABLE           ((sal_uLong)0x00000008)
+#define WINDOW_DRAW_NOMNEMONIC          ((sal_uLong)0x00000010)
+#define WINDOW_DRAW_NOSELECTION         ((sal_uLong)0x00000020)
+#define WINDOW_DRAW_NOFOCUS             ((sal_uLong)0x00000040)
+#define WINDOW_DRAW_NOBACKGROUND        ((sal_uLong)0x00000080)
+#define WINDOW_DRAW_ROLLOVER            ((sal_uLong)0x00000100)
+
+// DialogControl-Flags
+#define WINDOW_DLGCTRL_RETURN           ((sal_uInt16)0x0001)
+#define WINDOW_DLGCTRL_WANTFOCUS        ((sal_uInt16)0x0002)
+#define WINDOW_DLGCTRL_MOD1TAB          ((sal_uInt16)0x0004)
+#define WINDOW_DLGCTRL_FLOATWIN_POPUPMODEEND_CANCEL ((sal_uInt16)0x0008)
+
+// GetWindowClipRegionPixel-Flags
+#define WINDOW_GETCLIPREGION_NULL       ((sal_uInt16)0x0001)
+#define WINDOW_GETCLIPREGION_NOCHILDREN ((sal_uInt16)0x0002)
+
+// EndExtTextInput-Flags
+#define EXTTEXTINPUT_END_COMPLETE       ((sal_uInt16)0x0001)
+#define EXTTEXTINPUT_END_CANCEL         ((sal_uInt16)0x0002)
+
+#define IMPL_MINSIZE_BUTTON_WIDTH       70
+#define IMPL_MINSIZE_BUTTON_HEIGHT      22
+#define IMPL_EXTRA_BUTTON_WIDTH         18
+#define IMPL_EXTRA_BUTTON_HEIGHT        10
+#define IMPL_SEP_BUTTON_X               5
+#define IMPL_SEP_BUTTON_Y               5
+#define IMPL_MINSIZE_MSGBOX_WIDTH       150
+#define IMPL_MINSIZE_MSGBOX_HEIGHT      80
+#define IMPL_DIALOG_OFFSET              5
+#define IMPL_DIALOG_BAR_OFFSET          3
+#define IMPL_MSGBOX_OFFSET_EXTRA_X      0
+#define IMPL_MSGBOX_OFFSET_EXTRA_Y      2
+#define IMPL_SEP_MSGBOX_IMAGE           8
+
+#define DLGWINDOW_PREV                  0
+#define DLGWINDOW_NEXT                  1
+#define DLGWINDOW_FIRST                 2
+
+// ----------
+// - Window -
+// ----------
+
+#ifdef DBG_UTIL
+const char* ImplDbgCheckWindow( const void* pObj );
+#endif
+
+class Dialog;
+class WindowImpl;
+class VclBuilder;
+class VclSizeGroup;
+
+struct WindowResHeader
+{
+    sal_uLong nObjMask;
+    OString aHelpId;
+    sal_uLong nRSStyle;
+};
+
+class VCL_DLLPUBLIC Window : public OutputDevice
+{
+    friend class Cursor;
+    friend class OutputDevice;
+    friend class Application;
+    friend class SystemWindow;
+    friend class WorkWindow;
+    friend class Dialog;
+    friend class MessBox;
+    friend class DockingWindow;
+    friend class FloatingWindow;
+    friend class GroupBox;
+    friend class PushButton;
+    friend class RadioButton;
+    friend class SystemChildWindow;
+    friend class ImplBorderWindow;
+    friend class VclBuilder;
+
+    // TODO: improve missing functionality
+    // only required because of SetFloatingMode()
+    friend class ImplDockingWindowWrapper;
+    friend class ImplPopupFloatWin;
+    friend class MenuFloatingWindow;
+
+    friend class svt::PopupWindowControllerImpl;
+
+private:
+    // NOTE: to remove many dependencies of other modules
+    //       to this central file, all members are now hidden
+    //       in the WindowImpl class and all inline functions
+    //       were removed
+    //
+    //       Please do *not* add new members or inline functions to class Window,
+    //       but use class WindowImpl instead
+    //
+    WindowImpl* mpWindowImpl;
+
+    SAL_DLLPRIVATE void ImplInitWindowData( WindowType nType );
+
+#ifdef DBG_UTIL
+    friend const char* ImplDbgCheckWindow( const void* pObj );
+#endif
+    friend Window* ImplFindWindow( const SalFrame* pFrame, Point& rSalFramePos );
+public:
+    SAL_DLLPRIVATE void                ImplInit( Window* pParent, WinBits nStyle, SystemParentData* pSystemParentData );
+    SAL_DLLPRIVATE WinBits             ImplInitRes( const ResId& rResId );
+    SAL_DLLPRIVATE WindowResHeader     ImplLoadResHeader( const ResId& rResId );
+    SAL_DLLPRIVATE void                ImplLoadRes( const ResId& rResId );
+    SAL_DLLPRIVATE void                ImplSetFrameParent( const Window* pParent );
+    SAL_DLLPRIVATE void                ImplInsertWindow( Window* pParent );
+    SAL_DLLPRIVATE void                ImplRemoveWindow( sal_Bool bRemoveFrameData );
+    SAL_DLLPRIVATE Window*             ImplGetWindow();
+    SAL_DLLPRIVATE ImplFrameData*      ImplGetFrameData();
+                   SalFrame*           ImplGetFrame() const;
+    SAL_DLLPRIVATE ImplWinData*        ImplGetWinData() const;
+    SAL_DLLPRIVATE SalGraphics*        ImplGetFrameGraphics() const;
+    SAL_DLLPRIVATE void                ImplCallFocusChangeActivate( Window* pNewOverlapWindow, Window* pOldOverlapWindow );
+    SAL_DLLPRIVATE Window*             ImplFindWindow( const Point& rFramePos );
+    SAL_DLLPRIVATE sal_uInt16              ImplHitTest( const Point& rFramePos );
+    SAL_DLLPRIVATE Window*             ImplGetParent() const;
+    SAL_DLLPRIVATE Window*             ImplGetClientWindow() const;
+    SAL_DLLPRIVATE Window*             ImplGetBorderWindow() const;
+    SAL_DLLPRIVATE Window*             ImplGetFirstOverlapWindow();
+    SAL_DLLPRIVATE const Window*       ImplGetFirstOverlapWindow() const;
+    SAL_DLLPRIVATE Window*             ImplGetFrameWindow() const;
+    SAL_DLLPRIVATE sal_Bool                ImplIsRealParentPath( const Window* pWindow ) const;
+    SAL_DLLPRIVATE sal_Bool                ImplIsChild( const Window* pWindow, sal_Bool bSystemWindow = sal_False ) const;
+    SAL_DLLPRIVATE sal_Bool                ImplIsWindowOrChild( const Window* pWindow, sal_Bool bSystemWindow = sal_False ) const;
+    SAL_DLLPRIVATE sal_Bool                ImplIsDockingWindow() const;
+    SAL_DLLPRIVATE sal_Bool                ImplIsFloatingWindow() const;
+    SAL_DLLPRIVATE sal_Bool                ImplIsSplitter() const;
+    SAL_DLLPRIVATE sal_Bool                ImplIsPushButton() const;
+    SAL_DLLPRIVATE sal_Bool                ImplIsOverlapWindow() const;
+    SAL_DLLPRIVATE void                ImplSetMouseTransparent( sal_Bool bTransparent );
+    SAL_DLLPRIVATE int                 ImplTestMousePointerSet();
+    SAL_DLLPRIVATE PointerStyle        ImplGetMousePointer() const;
+    SAL_DLLPRIVATE void                ImplResetReallyVisible();
+    SAL_DLLPRIVATE void                ImplSetReallyVisible();
+    SAL_DLLPRIVATE void                ImplCallInitShow();
+    SAL_DLLPRIVATE void                ImplAddDel( ImplDelData* pDel );
+    SAL_DLLPRIVATE void                ImplRemoveDel( ImplDelData* pDel );
+    SAL_DLLPRIVATE void                ImplInitResolutionSettings();
+    SAL_DLLPRIVATE void                ImplPointToLogic( Font& rFont ) const;
+    SAL_DLLPRIVATE void                ImplLogicToPoint( Font& rFont ) const;
+    SAL_DLLPRIVATE Point               ImplOutputToFrame( const Point& rPos );
+    SAL_DLLPRIVATE Point               ImplFrameToOutput( const Point& rPos );
+    SAL_DLLPRIVATE sal_Bool                ImplSysObjClip( const Region* pOldRegion );
+    SAL_DLLPRIVATE void                ImplUpdateSysObjChildrenClip();
+    SAL_DLLPRIVATE void                ImplUpdateSysObjOverlapsClip();
+    SAL_DLLPRIVATE void                ImplUpdateSysObjClip();
+    SAL_DLLPRIVATE sal_Bool                ImplSetClipFlagChildren( sal_Bool bSysObjOnlySmaller = sal_False );
+    SAL_DLLPRIVATE sal_Bool                ImplSetClipFlagOverlapWindows( sal_Bool bSysObjOnlySmaller = sal_False );
+    SAL_DLLPRIVATE sal_Bool                ImplSetClipFlag( sal_Bool bSysObjOnlySmaller = sal_False );
+    SAL_DLLPRIVATE void                ImplIntersectWindowClipRegion( Region& rRegion );
+    SAL_DLLPRIVATE void                ImplIntersectWindowRegion( Region& rRegion );
+    SAL_DLLPRIVATE void                ImplExcludeWindowRegion( Region& rRegion );
+    SAL_DLLPRIVATE void                ImplExcludeOverlapWindows( Region& rRegion );
+    SAL_DLLPRIVATE void                ImplExcludeOverlapWindows2( Region& rRegion );
+    SAL_DLLPRIVATE void                ImplClipBoundaries( Region& rRegion, sal_Bool bThis, sal_Bool bOverlaps );
+    SAL_DLLPRIVATE sal_Bool                ImplClipChildren( Region& rRegion );
+    SAL_DLLPRIVATE void                ImplClipAllChildren( Region& rRegion );
+    SAL_DLLPRIVATE void                ImplClipSiblings( Region& rRegion );
+    SAL_DLLPRIVATE void                ImplInitWinClipRegion();
+    SAL_DLLPRIVATE void                ImplInitWinChildClipRegion();
+    SAL_DLLPRIVATE Region*             ImplGetWinChildClipRegion();
+    SAL_DLLPRIVATE void                ImplIntersectAndUnionOverlapWindows( const Region& rInterRegion, Region& rRegion );
+    SAL_DLLPRIVATE void                ImplIntersectAndUnionOverlapWindows2( const Region& rInterRegion, Region& rRegion );
+    SAL_DLLPRIVATE void                ImplCalcOverlapRegionOverlaps( const Region& rInterRegion, Region& rRegion );
+    SAL_DLLPRIVATE void                ImplCalcOverlapRegion( const Rectangle& rSourceRect, Region& rRegion,
+                                               sal_Bool bChildren, sal_Bool bParent, sal_Bool bSiblings );
+    SAL_DLLPRIVATE void                ImplCallPaint( const Region* pRegion, sal_uInt16 nPaintFlags );
+    SAL_DLLPRIVATE void                ImplCallOverlapPaint();
+    SAL_DLLPRIVATE void                ImplPostPaint();
+    SAL_DLLPRIVATE void                ImplInvalidateFrameRegion( const Region* pRegion, sal_uInt16 nFlags );
+    SAL_DLLPRIVATE void                ImplInvalidateOverlapFrameRegion( const Region& rRegion );
+    SAL_DLLPRIVATE void                ImplInvalidateParentFrameRegion( Region& rRegion );
+    SAL_DLLPRIVATE void                ImplInvalidate( const Region* rRegion, sal_uInt16 nFlags );
+    SAL_DLLPRIVATE void                ImplValidateFrameRegion( const Region* rRegion, sal_uInt16 nFlags );
+    SAL_DLLPRIVATE void                ImplValidate( const Region* rRegion, sal_uInt16 nFlags );
+    SAL_DLLPRIVATE void                ImplMoveInvalidateRegion( const Rectangle& rRect, long nHorzScroll, long nVertScroll, sal_Bool bChildren );
+    SAL_DLLPRIVATE void                ImplMoveAllInvalidateRegions( const Rectangle& rRect, long nHorzScroll, long nVertScroll, sal_Bool bChildren );
+    SAL_DLLPRIVATE void                ImplScroll( const Rectangle& rRect, long nHorzScroll, long nVertScroll, sal_uInt16 nFlags );
+    SAL_DLLPRIVATE void                ImplUpdateAll( sal_Bool bOverlapWindows = sal_True );
+    SAL_DLLPRIVATE void                ImplUpdateWindowPtr( Window* pWindow );
+    SAL_DLLPRIVATE void                ImplUpdateWindowPtr();
+    SAL_DLLPRIVATE void                ImplUpdateOverlapWindowPtr( sal_Bool bNewFrame );
+    SAL_DLLPRIVATE sal_Bool                ImplUpdatePos();
+    SAL_DLLPRIVATE void                ImplUpdateSysObjPos();
+    SAL_DLLPRIVATE WindowImpl*         ImplGetWindowImpl() const { return mpWindowImpl; }
+
+    /** check whether a font is suitable for UI
+
+    The font to be tested will be checked whether it could display a
+    localized test string. If this is not the case, then the font
+    is deemed unsuitable as UI font.
+
+    @param rFont
+    the font to be tested
+
+    @returns
+    <TRUE/> if the font can be used as UI font
+    <FALSE/> if the font is unsuitable as UI font
+     */
+    SAL_DLLPRIVATE bool        ImplCheckUIFont( const Font& rFont );
+    SAL_DLLPRIVATE void        ImplUpdateGlobalSettings( AllSettings& rSettings, sal_Bool bCallHdl = sal_True );
+    SAL_DLLPRIVATE void        ImplAlignChildren();
+    SAL_DLLPRIVATE void        ImplPosSizeWindow( long nX, long nY, long nWidth, long nHeight, sal_uInt16 nFlags );
+    SAL_DLLPRIVATE void        ImplToBottomChild();
+    SAL_DLLPRIVATE void        ImplCalcToTop( ImplCalcToTopData* pPrevData );
+    SAL_DLLPRIVATE void        ImplToTop( sal_uInt16 nFlags );
+    SAL_DLLPRIVATE void        ImplStartToTop( sal_uInt16 nFlags );
+    SAL_DLLPRIVATE void        ImplFocusToTop( sal_uInt16 nFlags, sal_Bool bReallyVisible );
+    SAL_DLLPRIVATE void        ImplShowAllOverlaps();
+    SAL_DLLPRIVATE void        ImplHideAllOverlaps();
+    SAL_DLLPRIVATE void        ImplNotifyKeyMouseCommandEventListeners( NotifyEvent& rNEvt );
+    SAL_DLLPRIVATE void        ImplCallMouseMove( sal_uInt16 nMouseCode, sal_Bool bModChanged = sal_False );
+    SAL_DLLPRIVATE void        ImplGenerateMouseMove();
+    SAL_DLLPRIVATE void        ImplGrabFocus( sal_uInt16 nFlags );
+    SAL_DLLPRIVATE void        ImplInvertFocus( const Rectangle& rRect );
+    SAL_DLLPRIVATE void        ImplControlFocus( sal_uInt16 nFlags = 0 );
+    SAL_DLLPRIVATE Window*     ImplGetDlgWindow( sal_uInt16 n, sal_uInt16 nType, sal_uInt16 nStart = 0, sal_uInt16 nEnd = 0xFFFF, sal_uInt16* pIndex = NULL );
+    SAL_DLLPRIVATE sal_Bool        ImplDlgCtrl( const KeyEvent& rKEvt, sal_Bool bKeyInput );
+    SAL_DLLPRIVATE sal_Bool        ImplHasDlgCtrl();
+    SAL_DLLPRIVATE void        ImplDlgCtrlNextWindow();
+    SAL_DLLPRIVATE void        ImplDlgCtrlFocusChanged( Window* pWindow, sal_Bool bGetFocus );
+    SAL_DLLPRIVATE Window*     ImplFindDlgCtrlWindow( Window* pWindow );
+    SAL_DLLPRIVATE long        ImplLogicUnitToPixelX( long nX, MapUnit eUnit );
+    SAL_DLLPRIVATE long        ImplLogicUnitToPixelY( long nY, MapUnit eUnit );
+    SAL_DLLPRIVATE sal_Bool        ImplIsWindowInFront( const Window* pTestWindow ) const;
+    SAL_DLLPRIVATE void        ImplSaveOverlapBackground();
+    SAL_DLLPRIVATE sal_Bool        ImplRestoreOverlapBackground( Region& rInvRegion );
+    SAL_DLLPRIVATE void        ImplDeleteOverlapBackground();
+    SAL_DLLPRIVATE void        ImplInvalidateAllOverlapBackgrounds();
+    SAL_DLLPRIVATE static void ImplNewInputContext();
+    SAL_DLLPRIVATE void        ImplCallActivateListeners(Window*);
+    SAL_DLLPRIVATE void        ImplCallDeactivateListeners(Window*);
+    DECL_DLLPRIVATE_LINK(      ImplHandlePaintHdl, void* );
+    DECL_DLLPRIVATE_LINK(      ImplGenerateMouseMoveHdl, void* );
+    DECL_DLLPRIVATE_LINK(      ImplTrackTimerHdl, Timer* );
+    DECL_DLLPRIVATE_LINK(      ImplAsyncFocusHdl, void* );
+    DECL_DLLPRIVATE_LINK(      ImplHideOwnerDrawWindowsHdl, void* );
+    DECL_DLLPRIVATE_LINK(      ImplHandleResizeTimerHdl, void* );
+
+    SAL_DLLPRIVATE static void ImplCalcSymbolRect( Rectangle& rRect );
+    SAL_DLLPRIVATE void        ImplHandleScroll( ScrollBar* pHScrl, long nX, ScrollBar* pVScrl, long nY );
+    SAL_DLLPRIVATE sal_Bool        ImplIsAccessibleCandidate() const;
+    SAL_DLLPRIVATE sal_Bool        ImplIsAccessibleNativeFrame() const;
+    SAL_DLLPRIVATE sal_uInt16      ImplGetAccessibleCandidateChildWindowCount( sal_uInt16 nFirstWindowType ) const;
+    SAL_DLLPRIVATE Window*     ImplGetAccessibleCandidateChild( sal_uInt16 nChild, sal_uInt16& rChildCount, sal_uInt16 nFirstWindowType, sal_Bool bTopLevel = sal_True ) const;
+    SAL_DLLPRIVATE sal_Bool        ImplRegisterAccessibleNativeFrame();
+    SAL_DLLPRIVATE void        ImplRevokeAccessibleNativeFrame();
+    SAL_DLLPRIVATE void        ImplCallResize();
+    SAL_DLLPRIVATE void        ImplCallMove();
+    SAL_DLLPRIVATE Rectangle   ImplOutputToUnmirroredAbsoluteScreenPixel( const Rectangle& rRect ) const;
+    SAL_DLLPRIVATE void        ImplMirrorFramePos( Point &pt ) const;
+    SAL_DLLPRIVATE long        ImplGetUnmirroredOutOffX();
+    SAL_DLLPRIVATE void        ImplIncModalCount();
+    SAL_DLLPRIVATE void        ImplDecModalCount();
+
+    // retrieves the list of owner draw decorated windows for this window hiearchy
+    SAL_DLLPRIVATE ::std::vector<Window *>& ImplGetOwnerDrawList();
+    SAL_DLLPRIVATE Window*     ImplGetTopmostFrameWindow();
+
+    SAL_DLLPRIVATE Rectangle   ImplGetWindowExtentsRelative( Window *pRelativeWindow, sal_Bool bClientOnly ) const;
+    SAL_DLLPRIVATE void        ImplNotifyIconifiedState( sal_Bool bIconified );
+    SAL_DLLPRIVATE bool        ImplStopDnd();
+    SAL_DLLPRIVATE void        ImplStartDnd();
+
+    SAL_DLLPRIVATE static void ImplInitAppFontData( Window* pWindow );
+    SAL_DLLPRIVATE void        ImplPaintToDevice( OutputDevice* pTargetOutDev, const Point& rPos );
+
+    SAL_DLLPRIVATE void        ImplIsInTaskPaneList( sal_Bool mbIsInTaskList );
+    SAL_DLLPRIVATE ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCanvas >
+                               ImplGetCanvas( const Size& rFullscreenSize, bool bFullscreen, bool bSpriteCanvas ) const;
+
+private:
+    // Default construction is forbidden and not implemented.
+    SAL_DLLPRIVATE             Window();
+
+    // Copy assignment is forbidden and not implemented.
+    SAL_DLLPRIVATE             Window (const Window &);
+    SAL_DLLPRIVATE             Window & operator= (const Window &);
+
+protected:
+    // Single argument ctors shall be explicit.
+    explicit            Window( WindowType nType );
+
+            void        SetCompoundControl( sal_Bool bCompound );
+
+            void        ImplCallEventListeners( sal_uLong nEvent, void* pData = NULL );
+            void        CallEventListeners( sal_uLong nEvent, void* pData = NULL );
+            void        FireVclEvent( VclSimpleEvent* pEvent );
+
+    // FIXME: this is a hack to workaround missing layout functionality
+    SAL_DLLPRIVATE void ImplAdjustNWFSizes();
+
+    // These eventually are supposed to go when everything is converted to .ui
+    SAL_DLLPRIVATE Window* getLegacyNonLayoutAccessibleRelationMemberOf() const;
+    SAL_DLLPRIVATE Window* getLegacyNonLayoutAccessibleRelationLabeledBy() const;
+    SAL_DLLPRIVATE Window* getLegacyNonLayoutAccessibleRelationLabelFor() const;
+
+    // Let Label override the code part of GetAccessibleRelationLabelFor
+    virtual Window* getAccessibleRelationLabelFor() const;
+    virtual sal_uInt16 getDefaultAccessibleRole() const;
+    virtual OUString getDefaultAccessibleName() const;
+public:
+    // Single argument ctors shall be explicit.
+    explicit            Window( Window* pParent, WinBits nStyle = 0 );
+
+                        Window( Window* pParent, const ResId& rResId );
+    virtual             ~Window();
+
+    virtual void        MouseMove( const MouseEvent& rMEvt );
+    virtual void        MouseButtonDown( const MouseEvent& rMEvt );
+    virtual void        MouseButtonUp( const MouseEvent& rMEvt );
+    virtual void        KeyInput( const KeyEvent& rKEvt );
+    virtual void        KeyUp( const KeyEvent& rKEvt );
+    virtual void        PrePaint();
+    virtual void        Paint( const Rectangle& rRect );
+
+    virtual void        PostPaint();
+    virtual void        Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, sal_uLong nFlags );
+    virtual void        Move();
+    virtual void        Resize();
+    virtual void        Activate();
+    virtual void        Deactivate();
+    virtual void        GetFocus();
+    virtual void        LoseFocus();
+    virtual void        RequestHelp( const HelpEvent& rHEvt );
+    virtual void        Command( const CommandEvent& rCEvt );
+    virtual void        Tracking( const TrackingEvent& rTEvt );
+    virtual void        UserEvent( sal_uLong nEvent, void* pEventData );
+    virtual void        StateChanged( StateChangedType nStateChange );
+    virtual void        DataChanged( const DataChangedEvent& rDCEvt );
+    virtual long        PreNotify( NotifyEvent& rNEvt );
+    virtual long        Notify( NotifyEvent& rNEvt );
+    virtual Window*     GetPreferredKeyInputWindow();
+
+    /*virtual*/ void    AddEventListener( const Link& rEventListener );
+    /*virtual*/ void    RemoveEventListener( const Link& rEventListener );
+    /*virtual*/ void    AddChildEventListener( const Link& rEventListener );
+    /*virtual*/ void    RemoveChildEventListener( const Link& rEventListener );
+
+    sal_uLong               PostUserEvent( const Link& rLink, void* pCaller = NULL );
+    sal_Bool                PostUserEvent( sal_uLong& rEventId, const Link& rLink, void* pCaller = NULL );
+    void                RemoveUserEvent( sal_uLong nUserEvent );
+
+    void                IncrementLockCount();
+    void                DecrementLockCount();
+    sal_Bool                IsLocked( sal_Bool bChildren = sal_False ) const;
+
+                        // returns the input language used for the last key stroke
+                        // may be LANGUAGE_DONTKNOW if not supported by the OS
+    LanguageType        GetInputLanguage() const;
+
+    void                SetStyle( WinBits nStyle );
+    WinBits             GetStyle() const;
+    WinBits             GetPrevStyle() const;
+    void                SetExtendedStyle( WinBits nExtendedStyle );
+    WinBits             GetExtendedStyle() const;
+    void                SetType( WindowType nType );
+    WindowType          GetType() const;
+    sal_Bool                IsSystemWindow() const;
+    sal_Bool                IsDialog() const;
+    sal_Bool                IsMenuFloatingWindow() const;
+    sal_Bool                IsToolbarFloatingWindow() const;
+    sal_Bool                IsTopWindow() const;
+    SystemWindow*       GetSystemWindow() const;
+
+    void                EnableAllResize( sal_Bool bEnable = sal_True );
+
+    void                SetBorderStyle( sal_uInt16 nBorderStyle );
+    sal_uInt16              GetBorderStyle() const;
+    void                GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder,
+                                   sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const;
+    Size                CalcWindowSize( const Size& rOutSz ) const;
+    Size                CalcOutputSize( const Size& rWinSz ) const;
+    long                CalcTitleWidth() const;
+
+    void                EnableClipSiblings( sal_Bool bClipSiblings = sal_True );
+
+    void                EnableChildTransparentMode( sal_Bool bEnable = sal_True );
+    sal_Bool                IsChildTransparentModeEnabled() const;
+
+    void                SetMouseTransparent( sal_Bool bTransparent );
+    sal_Bool                IsMouseTransparent() const;
+    void                SetPaintTransparent( sal_Bool bTransparent );
+    sal_Bool                IsPaintTransparent() const;
+    void                SetDialogControlStart( sal_Bool bStart );
+    sal_Bool                IsDialogControlStart() const;
+    void                SetDialogControlFlags( sal_uInt16 nFlags );
+    sal_uInt16              GetDialogControlFlags() const;
+
+    struct PointerState
+    {
+        sal_uLong   mnState;    // the button state
+        Point   maPos;      // mouse position in output coordinates
+    };
+    PointerState        GetPointerState();
+    sal_Bool                IsMouseOver();
+
+    sal_uLong               GetCurrentModButtons();
+
+    void                SetInputContext( const InputContext& rInputContext );
+    const InputContext& GetInputContext() const;
+    void                EndExtTextInput( sal_uInt16 nFlags );
+    void                SetCursorRect( const Rectangle* pRect = NULL, long nExtTextInputWidth = 0 );
+    const Rectangle*    GetCursorRect() const;
+    long                GetCursorExtTextInputWidth() const;
+
+    using               OutputDevice::SetSettings;
+    virtual void        SetSettings( const AllSettings& rSettings );
+    virtual void        SetSettings( const AllSettings& rSettings, sal_Bool bChild );
+    void                UpdateSettings( const AllSettings& rSettings, sal_Bool bChild = sal_False );
+    void                NotifyAllChildren( DataChangedEvent& rDCEvt );
+
+    void                SetPointFont( const Font& rFont );
+    Font                GetPointFont() const;
+    void                SetZoomedPointFont( const Font& rFont );
+    long                GetDrawPixel( OutputDevice* pDev, long nPixels ) const;
+    Font                GetDrawPixelFont( OutputDevice* pDev ) const;
+
+    void                SetControlFont();
+    void                SetControlFont( const Font& rFont );
+    Font                GetControlFont() const;
+    sal_Bool                IsControlFont() const;
+    void                SetControlForeground();
+    void                SetControlForeground( const Color& rColor );
+    Color               GetControlForeground() const;
+    sal_Bool                IsControlForeground() const;
+    void                SetControlBackground();
+    void                SetControlBackground( const Color& rColor );
+    Color               GetControlBackground() const;
+    sal_Bool                IsControlBackground() const;
+
+    void                SetParentClipMode( sal_uInt16 nMode = 0 );
+    sal_uInt16              GetParentClipMode() const;
+
+    void                SetWindowRegionPixel();
+    void                SetWindowRegionPixel( const Region& rRegion );
+    const Region&       GetWindowRegionPixel() const;
+    sal_Bool                IsWindowRegionPixel() const;
+    Region              GetWindowClipRegionPixel( sal_uInt16 nFlags = 0 ) const;
+    Region              GetPaintRegion() const;
+    sal_Bool                IsInPaint() const;
+    // while IsInPaint returns true ExpandPaintClipRegion adds the
+    // submitted region to the paint clip region so you can
+    // paint additional parts of your window if necessary
+    void                ExpandPaintClipRegion( const Region& rRegion );
+
+    void                SetParent( Window* pNewParent );
+    Window*             GetParent() const;
+    // return the dialog we are contained in or NULL if un-contained
+    Dialog*             GetParentDialog() const;
+
+    void                Show( sal_Bool bVisible = sal_True, sal_uInt16 nFlags = 0 );
+    void                Hide( sal_uInt16 nFlags = 0 ) { Show( sal_False, nFlags ); }
+    sal_Bool                IsVisible() const;
+    sal_Bool                IsReallyVisible() const;
+    sal_Bool                IsReallyShown() const;
+    sal_Bool                IsInInitShow() const;
+
+    void                Enable( bool bEnable = true, bool bChild = true );
+    void                Disable( bool bChild = true ) { Enable( false, bChild ); }
+    sal_Bool                IsEnabled() const;
+
+    void                EnableInput( sal_Bool bEnable = sal_True, sal_Bool bChild = sal_True );
+    void                EnableInput( sal_Bool bEnable, sal_Bool bChild, sal_Bool bSysWin,
+                                     const Window* pExcludeWindow = NULL );
+    sal_Bool                IsInputEnabled() const;
+
+    /** Override <code>EnableInput</code>. This can be necessary due to other people
+        using EnableInput for whole window hierarchies.
+
+
+        <code>AlwaysEnableInput</code> and <code>AlwaysDisableInput</code> are
+        mutually exclusive; the last setter wins.
+        @param bAlways
+        sets always enabled flag
+
+        @param bChild
+        if true children are recursively set to AlwaysEnableInput
+    */
+    void                AlwaysEnableInput( sal_Bool bAlways, sal_Bool bChild = sal_True );
+    /** returns the current AlwaysEnableInput state
+    @return
+    true if window is in AlwaysEnableInput state
+    */
+    sal_Bool                IsAlwaysEnableInput() const;
+    /** Override <code>EnableInput</code>, counterpart to AlwaysEnableInput.
+        Windows with AlwaysDisableInput will not get key events even if enabled
+        and input enabled.This can be necessary due to other people using EnableInput
+        for whole window hierarchies.
+
+        <code>AlwaysEnableInput</code> and <code>AlwaysDisableInput</code> are
+        mutually exclusive; the last setter wins.
+
+        @param bAlways
+        sets always disable flag
+
+        @param bChild
+        if true children are recursively set to AlwaysDisableInput
+    */
+    void                AlwaysDisableInput( sal_Bool bAlways, sal_Bool bChild = sal_True );
+
+    /** usually event handlers (see AddEventListener and AddChildEventListener)
+    are not called on disabled, modal or input disabled windows. There are however rare cases
+    in which one wants a Window or rather one of its Control subclasses to
+    not evaluate events but still react to those events externally. In these
+    rare cases call SetCallHandlersOnInputDisabled( true ) to have your handler
+    called anyway.
+
+    Currently only mouse events get this special treatment.
+
+    Use this sparingly, chances are if you want to use it you're working around
+    the real problem.
+
+    @param bCall
+    Enable/Disable calling event handlers for this disabled, modal or input disabled window.
+    This call is implicity done recursively for possible child windows.
+    */
+    void                SetCallHandlersOnInputDisabled( bool bCall );
+    /** get state of SetCallHandlersOnInputDisabled
+
+    @returns whether handlers are called regardless of input enabled state
+    */
+    bool                IsCallHandlersOnInputDisabled() const;
+    /** A window is in modal mode if one of its children or subchildren
+        is a running modal window (a modal dialog)
+
+        @returns sal_True if a child or subchild is a running modal window
+    */
+    sal_Bool                IsInModalMode() const;
+
+    /**
+     *  Necessary for calc ref input handling from modal dialogs
+     */
+    bool                IsInModalNonRefMode() const;
+
+    void                SetActivateMode( sal_uInt16 nMode );
+    sal_uInt16              GetActivateMode() const;
+
+    void                ToTop( sal_uInt16 nFlags = 0 );
+    void                SetZOrder( Window* pRefWindow, sal_uInt16 nFlags );
+    void                EnableAlwaysOnTop( sal_Bool bEnable = sal_True );
+    sal_Bool                IsAlwaysOnTopEnabled() const;
+
+    virtual void        setPosSizePixel( long nX, long nY,
+                                         long nWidth, long nHeight,
+                                         sal_uInt16 nFlags = WINDOW_POSSIZE_ALL );
+    virtual void        SetPosPixel( const Point& rNewPos );
+    virtual Point       GetPosPixel() const;
+    virtual void        SetSizePixel( const Size& rNewSize );
+    virtual Size        GetSizePixel() const;
+    virtual void        SetPosSizePixel( const Point& rNewPos,
+                                         const Size& rNewSize );
+    virtual void        SetOutputSizePixel( const Size& rNewSize );
+    sal_Bool                IsDefaultPos() const;
+    sal_Bool                IsDefaultSize() const;
+
+    // those conversion routines might deliver different results during UI mirroring
+    Point               OutputToScreenPixel( const Point& rPos ) const;
+    Point               ScreenToOutputPixel( const Point& rPos ) const;
+    //  the normalized screen methods work independent from UI mirroring
+    Point               OutputToNormalizedScreenPixel( const Point& rPos ) const;
+    Point               NormalizedScreenToOutputPixel( const Point& rPos ) const;
+    Point               OutputToAbsoluteScreenPixel( const Point& rPos ) const;
+    Point               AbsoluteScreenToOutputPixel( const Point& rPos ) const;
+    Rectangle           GetDesktopRectPixel() const;
+    //  window extents including border and decoratrion
+    Rectangle           GetWindowExtentsRelative( Window *pRelativeWindow ) const;
+    // window extents of the client window, coordinates to be used in SetPosPixel
+    Rectangle           GetClientWindowExtentsRelative( Window *pRelativeWindow ) const;
+
+    virtual sal_Bool        IsScrollable() const;
+    virtual void        Scroll( long nHorzScroll, long nVertScroll,
+                                sal_uInt16 nFlags = 0 );
+    virtual void        Scroll( long nHorzScroll, long nVertScroll,
+                                const Rectangle& rRect, sal_uInt16 nFlags = 0 );
+    virtual void        Invalidate( sal_uInt16 nFlags = 0 );
+    virtual void        Invalidate( const Rectangle& rRect, sal_uInt16 nFlags = 0 );
+    virtual void        Invalidate( const Region& rRegion, sal_uInt16 nFlags = 0 );
+    void                Validate( sal_uInt16 nFlags = 0 );
+    sal_Bool                HasPaintEvent() const;
+    void                Update();
+    void                Flush();
+    void                Sync();
+
+    // toggles new docking support, enabled via toolkit
+    void                EnableDocking( sal_Bool bEnable = sal_True );
+    // retrieves the single dockingmanager instance
+    static DockingManager* GetDockingManager();
+
+    void                EnablePaint( sal_Bool bEnable );
+    sal_Bool                IsPaintEnabled() const;
+    void                SetUpdateMode( sal_Bool bUpdate );
+    sal_Bool                IsUpdateMode() const;
+    void                SetParentUpdateMode( sal_Bool bUpdate );
+
+    void                GrabFocus();
+    sal_Bool                HasFocus() const;
+    sal_Bool                HasChildPathFocus( sal_Bool bSystemWindow = sal_False ) const;
+    sal_Bool                IsActive() const;
+    sal_Bool                HasActiveChildFrame();
+    sal_uInt16              GetGetFocusFlags() const;
+    void                GrabFocusToDocument();
+
+    /**
+     * Set this when you need to act as if the window has focus even if it
+     * doesn't.  This is necessary for implementing tab stops inside floating
+     * windows, but floating windows don't get focus from the system.
+     */
+    void                SetFakeFocus( bool bFocus );
+
+    sal_Bool                IsCompoundControl() const;
+
+    static sal_uIntPtr  SaveFocus();
+    static sal_Bool         EndSaveFocus( sal_uIntPtr nSaveId, sal_Bool bRestore = sal_True );
+
+    void                CaptureMouse();
+    void                ReleaseMouse();
+    sal_Bool                IsMouseCaptured() const;
+
+    void                SetPointer( const Pointer& rPointer );
+    const Pointer&      GetPointer() const;
+    void                EnableChildPointerOverwrite( sal_Bool bOverwrite = sal_True );
+    void                SetPointerPosPixel( const Point& rPos );
+    Point               GetPointerPosPixel();
+    Point               GetLastPointerPosPixel();
+    void                ShowPointer( sal_Bool bVisible );
+    void                EnterWait();
+    void                LeaveWait();
+    sal_Bool                IsWait() const;
+
+    void                SetCursor( Cursor* pCursor );
+    Cursor*             GetCursor() const;
+
+    void                SetZoom( const Fraction& rZoom );
+    const Fraction&     GetZoom() const;
+    sal_Bool                IsZoom() const;
+    long                CalcZoom( long n ) const;
+
+    virtual void      SetText( const OUString& rStr );
+    virtual OUString      GetText() const;
+    // return the actual text displayed
+    // this may have e.g. accellerators removed or portions
+    // replaced by ellipsis
+    virtual OUString      GetDisplayText() const;
+    // gets the visible background color. for transparent windows
+    // this may be the parent's background color; for controls
+    // this may be a child's background color (e.g. ListBox)
+    virtual const Wallpaper& GetDisplayBackground() const;
+
+    void                SetHelpText( const XubString& rHelpText );
+    const XubString&    GetHelpText() const;
+
+    void                SetQuickHelpText( const XubString& rHelpText );
+    const XubString&    GetQuickHelpText() const;
+
+    void                SetHelpId( const OString& );
+    const OString& GetHelpId() const;
+
+    void                SetUniqueId( const OString& );
+    const OString& GetUniqueId() const;
+
+    Window*             FindWindow( const Point& rPos ) const;
+
+    sal_uInt16              GetChildCount() const;
+    Window*             GetChild( sal_uInt16 nChild ) const;
+    Window*             GetWindow( sal_uInt16 nType ) const;
+    sal_Bool                IsChild( const Window* pWindow, sal_Bool bSystemWindow = sal_False ) const;
+    sal_Bool                IsWindowOrChild( const Window* pWindow, sal_Bool bSystemWindow = sal_False  ) const;
+
+    void                SetData( void* pNewData );
+    void*               GetData() const;
+
+    void                ShowFocus( const Rectangle& rRect );
+    void                HideFocus();
+
+    void                Invert( const Rectangle& rRect, sal_uInt16 nFlags = 0 );
+    void                Invert( const Polygon& rPoly, sal_uInt16 nFlags = 0 );
+
+    // transparent background for selected or checked items in toolboxes etc.
+    void                DrawSelectionBackground( const Rectangle& rRect, sal_uInt16 highlight, sal_Bool bChecked, sal_Bool bDrawBorder, sal_Bool bDrawExtBorderOnly );
+    // the same, but fills a passed Color with a text color complementing the selection background
+    void                DrawSelectionBackground( const Rectangle& rRect, sal_uInt16 highlight, sal_Bool bChecked, sal_Bool bDrawBorder, sal_Bool bDrawExtBorderOnly, Color* pSelectionTextColor );
+    // support rounded edges in the selection rect
+    void                DrawSelectionBackground( const Rectangle& rRect, sal_uInt16 highlight, sal_Bool bChecked, sal_Bool bDrawBorder, sal_Bool bDrawExtBorderOnly, long nCornerRadius, Color* pSelectionTextColor, Color* pPaintColor );
+
+    void                ShowTracking( const Rectangle& rRect,
+                                      sal_uInt16 nFlags = SHOWTRACK_SMALL );
+    void                HideTracking();
+    void                InvertTracking( const Rectangle& rRect,
+                                        sal_uInt16 nFlags = SHOWTRACK_SMALL );
+    void                InvertTracking( const Polygon& rPoly, sal_uInt16 nFlags = 0 );
+
+    void                StartTracking( sal_uInt16 nFlags = 0 );
+    void                EndTracking( sal_uInt16 nFlags = 0 );
+    sal_Bool                IsTracking() const;
+
+    void                StartAutoScroll( sal_uInt16 nFlags );
+    void                EndAutoScroll();
+
+    sal_Bool                HandleScrollCommand( const CommandEvent& rCmd,
+                                             ScrollBar* pHScrl = NULL,
+                                             ScrollBar* pVScrl = NULL );
+
+    void                SaveBackground( const Point& rPos, const Size& rSize,
+                                        const Point& rDestOff, VirtualDevice& rSaveDevice );
+
+    const SystemEnvData*                      GetSystemData() const;
+    ::com::sun::star::uno::Any                GetSystemDataAny() const;
+
+    // API to set/query the component interfaces
+    virtual ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > GetComponentInterface( sal_Bool bCreate = sal_True );
+    virtual void                    SetComponentInterface( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > xIFace );
+
+    // Accessibility
+    ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > GetAccessible( sal_Bool bCreate = sal_True );
+    virtual ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > CreateAccessible();
+    void SetAccessible( ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > );
+
+    Window* GetAccessibleParentWindow() const;
+    sal_uInt16  GetAccessibleChildWindowCount();
+    Window* GetAccessibleChildWindow( sal_uInt16 n );
+
+    void    SetAccessibleRole( sal_uInt16 nRole );
+    sal_uInt16  GetAccessibleRole() const;
+
+    void    SetAccessibleName( const String& rName );
+    String  GetAccessibleName() const;
+
+    void    SetAccessibleDescription( const String& rDescr );
+    String  GetAccessibleDescription() const;
+
+    void    SetAccessibleRelationLabeledBy( Window* pLabeledBy );
+    Window* GetAccessibleRelationLabeledBy() const;
+
+    void    SetAccessibleRelationLabelFor( Window* pLabelFor );
+    Window* GetAccessibleRelationLabelFor() const;
+
+    void    SetAccessibleRelationMemberOf( Window* pMemberOf );
+    Window* GetAccessibleRelationMemberOf() const;
+
+
+    // to avoid sending accessibility events in cases like closing dialogs
+    // by default checks complete parent path
+    sal_Bool    IsAccessibilityEventsSuppressed( sal_Bool bTraverseParentPath = sal_True );
+    void    SetAccessibilityEventsSuppressed(sal_Bool bSuppressed);
+
+    /// request XCanvas render interface for this window
+    ::com::sun::star::uno::Reference<
+        ::com::sun::star::rendering::XCanvas > GetCanvas() const;
+    /// request XSpriteCanvas render interface for this window
+    ::com::sun::star::uno::Reference<
+        ::com::sun::star::rendering::XSpriteCanvas > GetSpriteCanvas() const;
+
+    /*  records all DrawText operations within the passed rectangle;
+     *  a synchronous paint is sent to achieve this
+     */
+    void                RecordLayoutData( vcl::ControlLayoutData* pLayout, const Rectangle& rRect );
+
+    // set and retrieve for Toolkit
+    VCLXWindow*             GetWindowPeer() const;
+    void                    SetWindowPeer( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > xPeer, VCLXWindow* pVCLXWindow );
+
+    // remember if it was generated by Toolkit
+    sal_Bool                IsCreatedWithToolkit() const;
+    void                    SetCreatedWithToolkit( sal_Bool b );
+
+            // Deprecated - can use SetAccessibleRelationLabelFor/By nowadys
+    virtual Window* GetParentLabelFor( const Window* pLabel ) const;
+    virtual Window* GetParentLabeledBy( const Window* pLabeled ) const;
+    KeyEvent            GetActivationKey() const;
+
+    // Drag and Drop interfaces
+    virtual ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDropTarget > GetDropTarget();
+    virtual ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragSource > GetDragSource();
+    virtual ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragGestureRecognizer > GetDragGestureRecognizer();
+
+    // Clipboard/Selection interfaces
+    virtual ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::clipboard::XClipboard > GetClipboard();
+    virtual ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::clipboard::XClipboard > GetPrimarySelection();
+
+    /*
+     * Advisory Sizing - what is a good size for this widget
+     *
+     * Retrieves the preferred size of a widget ignoring
+     * "width-request" and "height-request" properties.
+     *
+     * Implement this in sub-classes to tell layout
+     * the preferred widget size.
+     */
+    virtual Size GetOptimalSize() const;
+
+    /*
+     * Widgets call this to inform their owner container that the widget wants
+     * to renegotiate its size. Should be called when a widget has a new size
+     * request. e.g. a FixedText Control gets a new label.
+     *
+     * akin to gtk_widget_queue_resize
+     */
+    void queue_resize();
+
+    /*
+     * Sets the "width-request" property
+     *
+     * Override for width request of the widget, or -1 if natural request
+     * should be used.
+     *
+     * @see get_preferred_size, set_width_request
+     */
+    void set_height_request(sal_Int32 nHeightRequest);
+    sal_Int32 get_height_request() const;
+
+    /*
+     * Sets the "height-request" property
+     *
+     * Override for height request of the widget, or -1 if natural request
+     * should be used.
+     *
+     * @see get_preferred_size, set_height_request
+     */
+    void set_width_request(sal_Int32 nWidthRequest);
+    sal_Int32 get_width_request() const;
+
+    /*
+     * Retrieves the preferred size of a widget taking
+     * into account the "width-request" and "height-request" properties.
+     *
+     * Overrides the result of GetOptimalSize to honor the
+     * width-request and height-request properties.
+     *
+     * @see GetOptimalSize
+     *
+     * akin to gtk_widget_get_preferred_size
+     */
+    Size get_preferred_size() const;
+
+    /*
+     * How to horizontally align this widget
+     */
+    VclAlign get_halign() const;
+    void set_halign(VclAlign eAlign);
+
+    /*
+     * How to vertically align this widget
+     */
+    VclAlign get_valign() const;
+    void set_valign(VclAlign eAlign);
+
+    /*
+     * Whether the widget would like to use any available extra horizontal
+     * space.
+     */
+    bool get_hexpand() const;
+    void set_hexpand(bool bExpand);
+
+    /*
+     * Whether the widget would like to use any available extra vertical
+     * space.
+     */
+    bool get_vexpand() const;
+    void set_vexpand(bool bExpand);
+
+    /*
+     * Whether the widget would like to use any available extra space.
+     */
+    bool get_expand() const;
+    void set_expand(bool bExpand);
+
+    /*
+     * Whether the widget should receive extra space when the parent grows
+     */
+    bool get_fill() const;
+    void set_fill(bool bFill);
+
+    void set_border_width(sal_Int32 nBorderWidth);
+    sal_Int32 get_border_width() const;
+
+    void set_margin_left(sal_Int32 nWidth);
+    sal_Int32 get_margin_left() const;
+
+    void set_margin_right(sal_Int32 nWidth);
+    sal_Int32 get_margin_right() const;
+
+    void set_margin_top(sal_Int32 nWidth);
+    sal_Int32 get_margin_top() const;
+
+    void set_margin_bottom(sal_Int32 nWidth);
+    sal_Int32 get_margin_bottom() const;
+
+    /*
+     * How the widget is packed with reference to the start or end of the parent
+     */
+    VclPackType get_pack_type() const;
+    void set_pack_type(VclPackType ePackType);
+
+    /*
+     * The extra space to put between the widget and its neighbors
+     */
+    sal_Int32 get_padding() const;
+    void set_padding(sal_Int32 nPadding);
+
+    /*
+     * The number of columns that the widget spans
+     */
+    sal_Int32 get_grid_width() const;
+    void set_grid_width(sal_Int32 nCols);
+
+    /*
+     * The column number to attach the left side of the widget to
+     */
+    sal_Int32 get_grid_left_attach() const;
+    void set_grid_left_attach(sal_Int32 nAttach);
+
+    /*
+     * The number of row that the widget spans
+     */
+    sal_Int32 get_grid_height() const;
+    void set_grid_height(sal_Int32 nRows);
+
+    /*
+     * The row number to attach the top side of the widget to
+     */
+    sal_Int32 get_grid_top_attach() const;
+    void set_grid_top_attach(sal_Int32 nAttach);
+
+    /*
+     * If true this child appears in a secondary layout group of children
+     * e.g. help buttons in a buttonbox
+     */
+    bool get_secondary() const;
+    void set_secondary(bool bSecondary);
+
+    /*
+     * Sets a widget property
+     *
+     * @return false if property is unknown
+     */
+    virtual bool set_property(const OString &rKey, const OString &rValue);
+
+    /*
+     * Sets a font attribute
+     *
+     * @return false if attribute is unknown
+     */
+    bool set_font_attribute(const OString &rKey, const OString &rValue);
+
+    /*
+     * Adds this widget to the xGroup VclSizeGroup
+     *
+     */
+    void add_to_size_group(boost::shared_ptr< VclSizeGroup > xGroup);
+    void remove_from_all_size_groups();
+
+    /*
+     * add/remove mnemonic label
+     */
+    void add_mnemonic_label(FixedText *pLabel);
+    void remove_mnemonic_label(FixedText *pLabel);
+    std::vector<FixedText*> list_mnemonic_labels() const;
+
+    /*
+     * Move this widget to be the nNewPosition'd child of its parent
+     */
+    void reorderWithinParent(sal_uInt16 nNewPosition);
+
+    //-------------------------------------
+    //  Native Widget Rendering functions
+    //-------------------------------------
+
+    // form controls must never use native widgets, this can be toggled here
+    void    EnableNativeWidget( sal_Bool bEnable = sal_True );
+    sal_Bool    IsNativeWidgetEnabled() const;
+
+    // a helper method for a Control's Draw method
+    void PaintToDevice( OutputDevice* pDevice, const Point& rPos, const Size& rSize );
+
+    /* mark Window for deletion in top of event queue
+    */
+    void doLazyDelete();
+
+    //-------------------------------------
+    //  Keyboard access functions
+    //-------------------------------------
+
+    /** Query the states of keyboard indicators - Caps Lock, Num Lock and
+        Scroll Lock.  Use the following mask to retrieve the state of each
+        indicator:
+
+            INDICATOR_CAPS_LOCK
+            INDICATOR_NUM_LOCK
+            INDICATOR_SCROLL_LOCK
+      */
+    sal_uInt16 GetIndicatorState() const;
+
+    void SimulateKeyPress( sal_uInt16 nKeyCode ) const;
+
+    virtual OUString GetSurroundingText() const;
+    virtual Selection GetSurroundingTextSelection() const;
+};
+
+
+#endif // _SV_WINDOW_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */