include/vcl/window.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_VCL_WINDOW_HXX
  21 #define INCLUDED_VCL_WINDOW_HXX
  22
  23 #include <tools/solar.h>
  24 #include <vcl/dllapi.h>
  25 #include <vcl/outdev.hxx>
  26 #include <vcl/pointr.hxx>
  27 #include <tools/wintypes.hxx>
  28 #include <rsc/rsc-vcl-shared-types.hxx>
  29 #include <vcl/inputtypes.hxx>
  30 #include <vcl/cursor.hxx>
  31 #include <vcl/inputctx.hxx>
  32 #include <vcl/keycodes.hxx>
  33 #include <vcl/region.hxx>
  34 #include <vcl/salnativewidgets.hxx>
  35 #include <vcl/uitest/factory.hxx>
  36 #include <vcl/vclevent.hxx>
  37 #include <rtl/ustring.hxx>
  38 #include <rtl/ref.hxx>
  39 #include <cppuhelper/weakref.hxx>
  40 #include <com/sun/star/uno/Reference.hxx>
  41 #include <memory>
  42
  43 class VirtualDevice;
  44 struct ImplSVEvent;
  45 struct ImplWinData;
  46 struct ImplFrameData;
  47 struct ImplCalcToTopData;
  48 struct SystemEnvData;
  49 struct SystemParentData;
  50 class ImplBorderWindow;
  51 class Idle;
  52 class Timer;
  53 class DockingManager;
  54 class ScrollBar;
  55 class Bitmap;
  56 class FixedText;
  57 class Image;
  58 class MouseEvent;
  59 class KeyEvent;
  60 class CommandEvent;
  61 class TrackingEvent;
  62 class HelpEvent;
  63 class DataChangedEvent;
  64 class VclSimpleEvent;
  65 class NotifyEvent;
  66 class SystemWindow;
  67 class SalFrame;
  68 class MenuFloatingWindow;
  69 class VCLXWindow;
  70 class VclWindowEvent;
  71 enum class ImplPaintFlags;
  72 enum class VclEventId;
  73
  74 namespace com { namespace sun { namespace star {
  75 namespace accessibility {
  76     class XAccessible;
  77 }
  78 namespace beans {
  79     struct PropertyValue;
  80 }
  81 namespace rendering {
  82     class XCanvas;
  83     class XSpriteCanvas;
  84 }
  85 namespace awt {
  86     class XWindowPeer;
  87     class XWindow;
  88 }
  89 namespace uno {
  90     class Any;
  91     class XInterface;
  92 }
  93 namespace datatransfer { namespace clipboard {
  94     class XClipboard;
  95 }
  96 namespace dnd {
  97     class XDragGestureRecognizer;
  98     class XDragSource;
  99     class XDropTarget;
 100 }}}}}
 101
 102 namespace vcl {
 103     struct ControlLayoutData;
 104 }
 105
 106 namespace svt { class PopupWindowControllerImpl; }
 107
 108 template<class T> class VclPtr;
 109
 110 enum class TrackingEventFlags
 111 {
 112     NONE           = 0x0000,
 113     Cancel         = 0x0001,
 114     Key            = 0x0002,
 115     Focus          = 0x0004,
 116     Repeat         = 0x0100,
 117     End            = 0x1000,
 118     DontCallHdl    = 0x8000,
 119 };
 120 namespace o3tl
 121 {
 122     template<> struct typed_flags<TrackingEventFlags> : is_typed_flags<TrackingEventFlags, 0x9107> {};
 123 }
 124
 125
 126 // Type fuer GetWindow()
 127 enum class GetWindowType
 128 {
 129     Parent                   =  0,
 130     FirstChild               =  1,
 131     LastChild                =  2,
 132     Prev                     =  3,
 133     Next                     =  4,
 134     FirstOverlap             =  5,
 135     Overlap                  =  7,
 136     ParentOverlap            =  8,
 137     Client                   =  9,
 138     RealParent               = 10,
 139     Frame                    = 11,
 140     Border                   = 12,
 141     FirstTopWindowChild      = 13,
 142     NextTopWindowSibling     = 16,
 143 };
 144
 145 // Flags for setPosSizePixel()
 146 // These must match the definitions in css::awt::PosSize
 147 enum class PosSizeFlags
 148 {
 149     NONE             = 0x0000,
 150     X                = 0x0001,
 151     Y                = 0x0002,
 152     Width            = 0x0004,
 153     Height           = 0x0008,
 154     Pos              = X | Y,
 155     Size             = Width | Height,
 156     PosSize          = Pos | Size,
 157     All              = PosSize,
 158 };
 159
 160 namespace o3tl
 161 {
 162     template<> struct typed_flags<PosSizeFlags> : is_typed_flags<PosSizeFlags, 0x000f> {};
 163 }
 164
 165 // Flags for Show()
 166 enum class ShowFlags
 167 {
 168     NONE                       = 0x0000,
 169     NoParentUpdate             = 0x0001,
 170     NoFocusChange              = 0x0002,
 171     NoActivate                 = 0x0004,
 172     ForegroundTask             = 0x0008,
 173 };
 174 namespace o3tl
 175 {
 176     template<> struct typed_flags<ShowFlags> : is_typed_flags<ShowFlags, 0x000f> {};
 177 }
 178
 179 // Flags for SetZOrder()
 180 enum class ZOrderFlags
 181 {
 182     NONE              = 0x0000,
 183     Before            = 0x0001,
 184     Behind            = 0x0002,
 185     First             = 0x0004,
 186     Last              = 0x0008,
 187 };
 188 namespace o3tl
 189 {
 190     template<> struct typed_flags<ZOrderFlags> : is_typed_flags<ZOrderFlags, 0x000f> {};
 191 }
 192
 193 // Activate-Flags
 194 enum class ActivateModeFlags
 195 {
 196     NONE        = 0,
 197     GrabFocus   = 0x0001,
 198 };
 199 namespace o3tl
 200 {
 201     template<> struct typed_flags<ActivateModeFlags> : is_typed_flags<ActivateModeFlags, 0x0001> {};
 202 }
 203
 204 // ToTop-Flags
 205 enum class ToTopFlags
 206 {
 207     NONE            = 0x0000,
 208     RestoreWhenMin  = 0x0001,
 209     ForegroundTask  = 0x0002,
 210     NoGrabFocus     = 0x0004,
 211     GrabFocusOnly   = 0x0008,
 212 };
 213 namespace o3tl
 214 {
 215     template<> struct typed_flags<ToTopFlags> : is_typed_flags<ToTopFlags, 0x000f> {};
 216 }
 217
 218 // Flags for Invalidate
 219 // must match css::awt::InvalidateStyle
 220 enum class InvalidateFlags
 221 {
 222     NONE                 = 0x0000,
 223     Children             = 0x0001,
 224     NoChildren           = 0x0002,
 225     NoErase              = 0x0004,
 226     Update               = 0x0008,
 227     Transparent          = 0x0010,
 228     NoTransparent        = 0x0020,
 229     NoClipChildren       = 0x4000,
 230 };
 231 namespace o3tl
 232 {
 233     template<> struct typed_flags<InvalidateFlags> : is_typed_flags<InvalidateFlags, 0x403f> {};
 234 }
 235
 236 // Flags for Validate
 237 enum class ValidateFlags
 238 {
 239     NONE                = 0x0000,
 240     Children            = 0x0001,
 241     NoChildren          = 0x0002
 242 };
 243 namespace o3tl
 244 {
 245     template<> struct typed_flags<ValidateFlags> : is_typed_flags<ValidateFlags, 0x0003> {};
 246 }
 247
 248 // Flags for Scroll
 249 enum class ScrollFlags
 250 {
 251     NONE                     = 0x0000,
 252     Clip                     = 0x0001,
 253     Children                 = 0x0002,
 254     NoChildren               = 0x0004,
 255     UseClipRegion            = 0x0008,
 256     Update                   = 0x0010,
 257 };
 258 namespace o3tl
 259 {
 260     template<> struct typed_flags<ScrollFlags> : is_typed_flags<ScrollFlags, 0x001f> {};
 261 }
 262
 263 // Flags for ParentClipMode
 264 enum class ParentClipMode
 265 {
 266     NONE             = 0x0000,
 267     Clip             = 0x0001,
 268     NoClip           = 0x0002,
 269 };
 270 namespace o3tl
 271 {
 272     template<> struct typed_flags<ParentClipMode> : is_typed_flags<ParentClipMode, 0x0003> {};
 273 }
 274
 275 // Flags for ShowTracking()
 276 enum class ShowTrackFlags {
 277     NONE                  = 0x0000,
 278     Small                 = 0x0001,
 279     Big                   = 0x0002,
 280     Split                 = 0x0003,
 281     Object                = 0x0004,
 282     StyleMask             = 0x000F,
 283     TrackWindow           = 0x1000,
 284     Clip                  = 0x2000,
 285 };
 286 namespace o3tl
 287 {
 288     template<> struct typed_flags<ShowTrackFlags> : is_typed_flags<ShowTrackFlags, 0x300f> {};
 289 }
 290
 291 // Flags for StartTracking()
 292 enum class StartTrackingFlags
 293 {
 294     NONE                 = 0x0000,
 295     KeyInput             = 0x0001,
 296     KeyMod               = 0x0002,
 297     NoKeyCancel          = 0x0004,
 298     ScrollRepeat         = 0x0008,
 299     ButtonRepeat         = 0x0010,
 300     MouseButtonDown      = 0x0020,
 301     FocusCancel          = 0x0040,
 302 };
 303
 304 namespace o3tl
 305 {
 306     template<> struct typed_flags<StartTrackingFlags> : is_typed_flags<StartTrackingFlags, 0x007f> {};
 307 }
 308
 309 // Flags for StartAutoScroll()
 310 enum class StartAutoScrollFlags
 311 {
 312     NONE                 = 0x0000,
 313     Vert                 = 0x0001,
 314     Horz                 = 0x0002,
 315 };
 316 namespace o3tl
 317 {
 318     template<> struct typed_flags<StartAutoScrollFlags> : is_typed_flags<StartAutoScrollFlags, 0x0003> {};
 319 }
 320
 321 // Flags for StateChanged()
 322 enum class StateChangedType : sal_uInt16
 323 {
 324     InitShow           = 1,
 325     Visible            = 2,
 326     UpdateMode         = 3,
 327     Enable             = 4,
 328     Text               = 5,
 329     Data               = 7,
 330     State              = 8,
 331     Style              = 9,
 332     Zoom               = 10,
 333     ControlFont        = 13,
 334     ControlForeground  = 14,
 335     ControlBackground  = 15,
 336     ReadOnly           = 16,
 337     ExtendedStyle      = 17,
 338     Mirroring          = 18,
 339     Layout             = 19,
 340     ControlFocus       = 20
 341 };
 342
 343 // GetFocusFlags
 344 // must match constants in css:awt::FocusChangeReason
 345 enum class GetFocusFlags
 346 {
 347     NONE                   = 0x0000,
 348     Tab                    = 0x0001,
 349     CURSOR                 = 0x0002, // avoid name-clash with X11 #define
 350     Mnemonic               = 0x0004,
 351     F6                     = 0x0008,
 352     Forward                = 0x0010,
 353     Backward               = 0x0020,
 354     Around                 = 0x0040,
 355     UniqueMnemonic         = 0x0100,
 356     Init                   = 0x0200,
 357     FloatWinPopupModeEndCancel = 0x0400,
 358 };
 359 namespace o3tl
 360 {
 361     template<> struct typed_flags<GetFocusFlags> : is_typed_flags<GetFocusFlags, 0x077f> {};
 362 }
 363
 364
 365 // Flags for Draw()
 366 enum class DrawFlags
 367 {
 368     NONE                = 0x0000,
 369     Mono                = 0x0001,
 370     NoBorder            = 0x0002,
 371     NoControls          = 0x0004,
 372     NoDisable           = 0x0008,
 373     NoMnemonic          = 0x0010,
 374     NoSelection         = 0x0020,
 375     NoBackground        = 0x0040,
 376     NoRollover          = 0x0080,
 377 };
 378 namespace o3tl
 379 {
 380     template<> struct typed_flags<DrawFlags> : is_typed_flags<DrawFlags, 0x00ff> {};
 381 }
 382
 383 // DialogControl-Flags
 384 enum class DialogControlFlags
 385 {
 386     NONE                       = 0x0000,
 387     Return                     = 0x0001,
 388     WantFocus                  = 0x0002,
 389     FloatWinPopupModeEndCancel = 0x0004,
 390 };
 391 namespace o3tl
 392 {
 393     template<> struct typed_flags<DialogControlFlags> : is_typed_flags<DialogControlFlags, 0x0007> {};
 394 }
 395
 396 // EndExtTextInput() Flags
 397 enum class EndExtTextInputFlags
 398 {
 399     NONE           = 0x0000,
 400     Complete       = 0x0001
 401 };
 402 namespace o3tl
 403 {
 404     template<> struct typed_flags<EndExtTextInputFlags> : is_typed_flags<EndExtTextInputFlags, 0x0001> {};
 405 }
 406
 407 #define IMPL_MINSIZE_BUTTON_WIDTH       70
 408 #define IMPL_MINSIZE_BUTTON_HEIGHT      22
 409 #define IMPL_EXTRA_BUTTON_WIDTH         18
 410 #define IMPL_EXTRA_BUTTON_HEIGHT        10
 411 #define IMPL_SEP_BUTTON_X               5
 412 #define IMPL_SEP_BUTTON_Y               5
 413 #define IMPL_MINSIZE_MSGBOX_WIDTH       150
 414 #define IMPL_DIALOG_OFFSET              5
 415 #define IMPL_DIALOG_BAR_OFFSET          3
 416 #define IMPL_MSGBOX_OFFSET_EXTRA_X      0
 417 #define IMPL_MSGBOX_OFFSET_EXTRA_Y      2
 418 #define IMPL_SEP_MSGBOX_IMAGE           8
 419
 420 // ImplGetDlgWindow()
 421 enum class GetDlgWindowType
 422 {
 423     Prev, Next, First
 424 };
 425
 426
 427 #ifdef DBG_UTIL
 428 const char* ImplDbgCheckWindow( const void* pObj );
 429 #endif
 430
 431 namespace vcl { class Window; }
 432 namespace vcl { class Cursor; }
 433 class Dialog;
 434 class WindowImpl;
 435 class PaintHelper;
 436 class VclBuilder;
 437 class VclSizeGroup;
 438 class OutputDevice;
 439 class Application;
 440 class SystemWindow;
 441 class WorkWindow;
 442 class Dialog;
 443 class MessBox;
 444 class DockingWindow;
 445 class FloatingWindow;
 446 class GroupBox;
 447 class PushButton;
 448 class RadioButton;
 449 class SystemChildWindow;
 450 class ImplBorderWindow;
 451 class VclBuilder;
 452 class ImplDockingWindowWrapper;
 453 class ImplPopupFloatWin;
 454 class MenuFloatingWindow;
 455 class LifecycleTest;
 456
 457 namespace svt { class PopupWindowControllerImpl; }
 458 enum class WindowHitTest {
 459     NONE        = 0x0000,
 460     Inside      = 0x0001,
 461     Transparent = 0x0002
 462 };
 463 namespace o3tl {
 464     template<> struct typed_flags<WindowHitTest> : is_typed_flags<WindowHitTest, 0x0003> {};
 465 };
 466
 467 namespace vcl {
 468
 469 class VCL_DLLPUBLIC RenderTools
 470 {
 471 public:
 472     // transparent background for selected or checked items in toolboxes etc.
 473     // + selection Color with a text color complementing the selection background
 474     // + rounded edge
 475     static void DrawSelectionBackground(vcl::RenderContext& rRenderContext, vcl::Window& rWindow,
 476                                         const tools::Rectangle& rRect, sal_uInt16 nHighlight,
 477                                         bool bChecked, bool bDrawBorder, bool bDrawExtBorderOnly,
 478                                         Color* pSelectionTextColor = nullptr, long nCornerRadius = 0,
 479                                         Color* pPaintColor = nullptr);
 480 };
 481
 482 class VCL_DLLPUBLIC Window : public ::OutputDevice
 483 {
 484     friend class ::vcl::Cursor;
 485     friend class ::OutputDevice;
 486     friend class ::Application;
 487     friend class ::SystemWindow;
 488     friend class ::WorkWindow;
 489     friend class ::Dialog;
 490     friend class ::MessBox;
 491     friend class ::DockingWindow;
 492     friend class ::FloatingWindow;
 493     friend class ::GroupBox;
 494     friend class ::PushButton;
 495     friend class ::RadioButton;
 496     friend class ::SystemChildWindow;
 497     friend class ::ImplBorderWindow;
 498     friend class ::VclBuilder;
 499     friend class ::PaintHelper;
 500     friend class ::LifecycleTest;
 501
 502     // TODO: improve missing functionality
 503     // only required because of SetFloatingMode()
 504     friend class ::ImplDockingWindowWrapper;
 505     friend class ::ImplPopupFloatWin;
 506     friend class ::MenuFloatingWindow;
 507
 508     friend class ::svt::PopupWindowControllerImpl;
 509
 510 private:
 511     // NOTE: to remove many dependencies of other modules
 512     //       to this central file, all members are now hidden
 513     //       in the WindowImpl class and all inline functions
 514     //       were removed.
 515     //       (WindowImpl is a pImpl pattern)
 516
 517     //       Please do *not* add new members or inline functions to class Window,
 518     //       but use class WindowImpl instead
 519
 520     std::unique_ptr<WindowImpl> mpWindowImpl;
 521
 522 #ifdef DBG_UTIL
 523     friend const char* ::ImplDbgCheckWindow( const void* pObj );
 524 #endif
 525
 526 public:
 527
 528     DECL_DLLPRIVATE_LINK( ImplHandlePaintHdl, Timer*, void );
 529     DECL_DLLPRIVATE_LINK( ImplGenerateMouseMoveHdl, void*, void );
 530     DECL_DLLPRIVATE_LINK( ImplTrackTimerHdl, Timer*, void );
 531     DECL_DLLPRIVATE_LINK( ImplAsyncFocusHdl, void*, void );
 532     DECL_DLLPRIVATE_LINK( ImplHandleResizeTimerHdl, Timer*, void );
 533
 534
 535     SAL_DLLPRIVATE static void          ImplInitAppFontData( vcl::Window* pWindow );
 536
 537     SAL_DLLPRIVATE vcl::Window*         ImplGetFrameWindow() const;
 538     SalFrame*                           ImplGetFrame() const;
 539     SAL_DLLPRIVATE ImplFrameData*       ImplGetFrameData();
 540
 541     SAL_DLLPRIVATE vcl::Window*         ImplGetWindow();
 542     SAL_DLLPRIVATE ImplWinData*         ImplGetWinData() const;
 543     SAL_DLLPRIVATE vcl::Window*         ImplGetClientWindow() const;
 544     SAL_DLLPRIVATE vcl::Window*         ImplGetDlgWindow( sal_uInt16 n, GetDlgWindowType nType, sal_uInt16 nStart = 0, sal_uInt16 nEnd = 0xFFFF, sal_uInt16* pIndex = nullptr );
 545     SAL_DLLPRIVATE vcl::Window*         ImplGetParent() const;
 546     SAL_DLLPRIVATE vcl::Window*         ImplFindWindow( const Point& rFramePos );
 547
 548     SAL_DLLPRIVATE void                 ImplInvalidateFrameRegion( const vcl::Region* pRegion, InvalidateFlags nFlags );
 549     SAL_DLLPRIVATE void                 ImplInvalidateOverlapFrameRegion( const vcl::Region& rRegion );
 550
 551     SAL_DLLPRIVATE bool                 ImplSetClipFlag( bool bSysObjOnlySmaller = false );
 552
 553     SAL_DLLPRIVATE bool                 ImplIsWindowOrChild( const vcl::Window* pWindow, bool bSystemWindow = false ) const;
 554     SAL_DLLPRIVATE bool                 ImplIsChild( const vcl::Window* pWindow, bool bSystemWindow = false ) const;
 555     SAL_DLLPRIVATE bool                 ImplIsFloatingWindow() const;
 556     SAL_DLLPRIVATE bool                 ImplIsPushButton() const;
 557     SAL_DLLPRIVATE bool                 ImplIsSplitter() const;
 558     SAL_DLLPRIVATE bool                 ImplIsOverlapWindow() const;
 559
 560     SAL_DLLPRIVATE void                 ImplIsInTaskPaneList( bool mbIsInTaskList );
 561
 562     SAL_DLLPRIVATE WindowImpl*          ImplGetWindowImpl() const { return mpWindowImpl.get(); }
 563
 564     SAL_DLLPRIVATE Point                ImplFrameToOutput( const Point& rPos );
 565
 566     SAL_DLLPRIVATE void                 ImplGrabFocus( GetFocusFlags nFlags );
 567     SAL_DLLPRIVATE void                 ImplGrabFocusToDocument( GetFocusFlags nFlags );
 568     SAL_DLLPRIVATE void                 ImplInvertFocus( const tools::Rectangle& rRect );
 569
 570     SAL_DLLPRIVATE PointerStyle         ImplGetMousePointer() const;
 571     SAL_DLLPRIVATE void                 ImplCallMouseMove( sal_uInt16 nMouseCode, bool bModChanged = false );
 572     SAL_DLLPRIVATE void                 ImplGenerateMouseMove();
 573
 574     SAL_DLLPRIVATE void                 ImplNotifyKeyMouseCommandEventListeners( NotifyEvent& rNEvt );
 575     SAL_DLLPRIVATE void                 ImplNotifyIconifiedState( bool bIconified );
 576
 577     SAL_DLLPRIVATE void                 ImplUpdateAll();
 578
 579     SAL_DLLPRIVATE void                 ImplControlFocus( GetFocusFlags nFlags = GetFocusFlags::NONE );
 580
 581     SAL_DLLPRIVATE void                 ImplMirrorFramePos( Point &pt ) const;
 582
 583     SAL_DLLPRIVATE void                 ImplPosSizeWindow( long nX, long nY, long nWidth, long nHeight, PosSizeFlags nFlags );
 584
 585     SAL_DLLPRIVATE void                 ImplCallResize();
 586     SAL_DLLPRIVATE void                 ImplCallMove();
 587
 588     SAL_DLLPRIVATE void                 ImplIncModalCount();
 589     SAL_DLLPRIVATE void                 ImplDecModalCount();
 590
 591     SAL_DLLPRIVATE static void          ImplCalcSymbolRect( tools::Rectangle& rRect );
 592
 593 protected:
 594
 595     /** This is intended to be used to clear any locally held references to other Window-subclass objects */
 596     virtual void                        dispose() override;
 597
 598     SAL_DLLPRIVATE void                 ImplInit( vcl::Window* pParent, WinBits nStyle, SystemParentData* pSystemParentData );
 599
 600     SAL_DLLPRIVATE Point                ImplOutputToFrame( const Point& rPos );
 601
 602     SAL_DLLPRIVATE void                 ImplInvalidateParentFrameRegion( vcl::Region& rRegion );
 603     SAL_DLLPRIVATE void                 ImplValidateFrameRegion( const vcl::Region* rRegion, ValidateFlags nFlags );
 604     SAL_DLLPRIVATE void                 ImplValidate();
 605     SAL_DLLPRIVATE void                 ImplMoveInvalidateRegion( const tools::Rectangle& rRect, long nHorzScroll, long nVertScroll, bool bChildren );
 606     SAL_DLLPRIVATE void                 ImplMoveAllInvalidateRegions( const tools::Rectangle& rRect, long nHorzScroll, long nVertScroll, bool bChildren );
 607
 608     SAL_DLLPRIVATE vcl::Window*         ImplGetBorderWindow() const;
 609
 610     SAL_DLLPRIVATE void                 ImplInvalidate( const vcl::Region* rRegion, InvalidateFlags nFlags );
 611
 612     SAL_DLLPRIVATE WindowHitTest        ImplHitTest( const Point& rFramePos );
 613
 614     SAL_DLLPRIVATE void                 ImplSetMouseTransparent( bool bTransparent );
 615
 616     SAL_DLLPRIVATE void                 ImplScroll( const tools::Rectangle& rRect, long nHorzScroll, long nVertScroll, ScrollFlags nFlags );
 617
 618     SAL_DLLPRIVATE bool                 ImplSetClipFlagChildren( bool bSysObjOnlySmaller );
 619     SAL_DLLPRIVATE bool                 ImplSetClipFlagOverlapWindows( bool bSysObjOnlySmaller = false );
 620
 621     SAL_DLLPRIVATE void                 PushPaintHelper(PaintHelper* pHelper, vcl::RenderContext& rRenderContext);
 622     SAL_DLLPRIVATE void                 PopPaintHelper(PaintHelper* pHelper);
 623
 624 private:
 625
 626     SAL_DLLPRIVATE void                 ImplSetFrameParent( const vcl::Window* pParent );
 627
 628     SAL_DLLPRIVATE void                 ImplInsertWindow( vcl::Window* pParent );
 629     SAL_DLLPRIVATE void                 ImplRemoveWindow( bool bRemoveFrameData );
 630
 631     SAL_DLLPRIVATE SalGraphics*         ImplGetFrameGraphics() const;
 632
 633     SAL_DLLPRIVATE static void          ImplCallFocusChangeActivate( vcl::Window* pNewOverlapWindow, vcl::Window* pOldOverlapWindow );
 634     SAL_DLLPRIVATE vcl::Window*         ImplGetFirstOverlapWindow();
 635     SAL_DLLPRIVATE const vcl::Window*   ImplGetFirstOverlapWindow() const;
 636
 637     SAL_DLLPRIVATE bool                 ImplIsRealParentPath( const vcl::Window* pWindow ) const;
 638
 639     SAL_DLLPRIVATE bool                 ImplTestMousePointerSet();
 640
 641     SAL_DLLPRIVATE void                 ImplResetReallyVisible();
 642     SAL_DLLPRIVATE void                 ImplSetReallyVisible();
 643
 644     SAL_DLLPRIVATE void                 ImplCallInitShow();
 645
 646     SAL_DLLPRIVATE void                 ImplInitResolutionSettings();
 647
 648     SAL_DLLPRIVATE void                 ImplPointToLogic(vcl::RenderContext& rRenderContext, vcl::Font& rFont) const;
 649     SAL_DLLPRIVATE void                 ImplLogicToPoint(vcl::RenderContext& rRenderContext, vcl::Font& rFont) const;
 650
 651     SAL_DLLPRIVATE bool                 ImplSysObjClip( const vcl::Region* pOldRegion );
 652     SAL_DLLPRIVATE void                 ImplUpdateSysObjChildrenClip();
 653     SAL_DLLPRIVATE void                 ImplUpdateSysObjOverlapsClip();
 654     SAL_DLLPRIVATE void                 ImplUpdateSysObjClip();
 655
 656     SAL_DLLPRIVATE void                 ImplIntersectWindowClipRegion( vcl::Region& rRegion );
 657     SAL_DLLPRIVATE void                 ImplIntersectWindowRegion( vcl::Region& rRegion );
 658     SAL_DLLPRIVATE void                 ImplExcludeWindowRegion( vcl::Region& rRegion );
 659     SAL_DLLPRIVATE void                 ImplExcludeOverlapWindows( vcl::Region& rRegion );
 660     SAL_DLLPRIVATE void                 ImplExcludeOverlapWindows2( vcl::Region& rRegion );
 661
 662     SAL_DLLPRIVATE void                 ImplClipBoundaries( vcl::Region& rRegion, bool bThis, bool bOverlaps );
 663     SAL_DLLPRIVATE bool                 ImplClipChildren( vcl::Region& rRegion );
 664     SAL_DLLPRIVATE void                 ImplClipAllChildren( vcl::Region& rRegion );
 665     SAL_DLLPRIVATE void                 ImplClipSiblings( vcl::Region& rRegion );
 666
 667     SAL_DLLPRIVATE void                 ImplInitWinClipRegion();
 668     SAL_DLLPRIVATE void                 ImplInitWinChildClipRegion();
 669     SAL_DLLPRIVATE vcl::Region*         ImplGetWinChildClipRegion();
 670
 671     SAL_DLLPRIVATE void                 ImplIntersectAndUnionOverlapWindows( const vcl::Region& rInterRegion, vcl::Region& rRegion );
 672     SAL_DLLPRIVATE void                 ImplIntersectAndUnionOverlapWindows2( const vcl::Region& rInterRegion, vcl::Region& rRegion );
 673     SAL_DLLPRIVATE void                 ImplCalcOverlapRegionOverlaps( const vcl::Region& rInterRegion, vcl::Region& rRegion );
 674     SAL_DLLPRIVATE void                 ImplCalcOverlapRegion( const tools::Rectangle& rSourceRect, vcl::Region& rRegion,
 675                                                                bool bChildren, bool bSiblings );
 676
 677     /** Invoke the actual painting.
 678
 679         This function is kind of recursive - it may be called from the
 680         PaintHelper destructor; and on the other hand it creates PaintHelper
 681         that (when destructed) calls other ImplCallPaint()'s.
 682     */
 683     SAL_DLLPRIVATE void                 ImplCallPaint(const vcl::Region* pRegion, ImplPaintFlags nPaintFlags);
 684
 685     SAL_DLLPRIVATE void                 ImplCallOverlapPaint();
 686
 687     SAL_DLLPRIVATE void                 ImplUpdateWindowPtr( vcl::Window* pWindow );
 688     SAL_DLLPRIVATE void                 ImplUpdateWindowPtr();
 689     SAL_DLLPRIVATE void                 ImplUpdateOverlapWindowPtr( bool bNewFrame );
 690
 691     SAL_DLLPRIVATE bool                 ImplUpdatePos();
 692     SAL_DLLPRIVATE void                 ImplUpdateSysObjPos();
 693
 694     SAL_DLLPRIVATE void                 ImplUpdateGlobalSettings( AllSettings& rSettings, bool bCallHdl = true );
 695
 696     SAL_DLLPRIVATE void                 ImplToBottomChild();
 697
 698     SAL_DLLPRIVATE void                 ImplCalcToTop( ImplCalcToTopData* pPrevData );
 699     SAL_DLLPRIVATE void                 ImplToTop( ToTopFlags nFlags );
 700     SAL_DLLPRIVATE void                 ImplStartToTop( ToTopFlags nFlags );
 701     SAL_DLLPRIVATE void                 ImplFocusToTop( ToTopFlags nFlags, bool bReallyVisible );
 702
 703     SAL_DLLPRIVATE void                 ImplShowAllOverlaps();
 704     SAL_DLLPRIVATE void                 ImplHideAllOverlaps();
 705
 706     SAL_DLLPRIVATE bool                 ImplDlgCtrl( const KeyEvent& rKEvt, bool bKeyInput );
 707     SAL_DLLPRIVATE bool                 ImplHasDlgCtrl();
 708     SAL_DLLPRIVATE void                 ImplDlgCtrlNextWindow();
 709     SAL_DLLPRIVATE void                 ImplDlgCtrlFocusChanged( vcl::Window* pWindow, bool bGetFocus );
 710     SAL_DLLPRIVATE vcl::Window*         ImplFindDlgCtrlWindow( vcl::Window* pWindow );
 711
 712     SAL_DLLPRIVATE static void          ImplNewInputContext();
 713
 714     SAL_DLLPRIVATE void                 ImplCallActivateListeners(vcl::Window*);
 715     SAL_DLLPRIVATE void                 ImplCallDeactivateListeners(vcl::Window*);
 716
 717     SAL_DLLPRIVATE static void          ImplHandleScroll(ScrollBar* pHScrl, double nX, ScrollBar* pVScrl, double nY);
 718
 719     SAL_DLLPRIVATE tools::Rectangle     ImplOutputToUnmirroredAbsoluteScreenPixel( const tools::Rectangle& rRect ) const;
 720     SAL_DLLPRIVATE long                 ImplGetUnmirroredOutOffX();
 721
 722     // retrieves the list of owner draw decorated windows for this window hiearchy
 723     SAL_DLLPRIVATE ::std::vector<VclPtr<vcl::Window> >& ImplGetOwnerDrawList();
 724
 725     SAL_DLLPRIVATE vcl::Window*         ImplGetTopmostFrameWindow();
 726
 727     SAL_DLLPRIVATE tools::Rectangle     ImplGetWindowExtentsRelative( vcl::Window *pRelativeWindow, bool bClientOnly ) const;
 728
 729     SAL_DLLPRIVATE bool                 ImplStopDnd();
 730     SAL_DLLPRIVATE void                 ImplStartDnd();
 731
 732     SAL_DLLPRIVATE void                 ImplPaintToDevice( ::OutputDevice* pTargetOutDev, const Point& rPos );
 733
 734     SAL_DLLPRIVATE css::uno::Reference< css::rendering::XCanvas >
 735                                         ImplGetCanvas( bool bSpriteCanvas ) const;
 736
 737 public:
 738     virtual vcl::Region                 GetActiveClipRegion() const override;
 739
 740 protected:
 741     // Single argument ctors shall be explicit.
 742     explicit                            Window( WindowType nType );
 743
 744             void                        SetCompoundControl( bool bCompound );
 745
 746             void                        CallEventListeners( VclEventId nEvent, void* pData = nullptr );
 747     static  void                        FireVclEvent( VclSimpleEvent& rEvent );
 748
 749     virtual bool                        AcquireGraphics() const override;
 750     virtual void                        ReleaseGraphics( bool bRelease = true ) override;
 751
 752     virtual void                        InitClipRegion() override;
 753
 754     // FIXME: this is a hack to workaround missing layout functionality
 755     SAL_DLLPRIVATE void                 ImplAdjustNWFSizes();
 756
 757     virtual void                        CopyDeviceArea( SalTwoRect& aPosAry, bool bWindowInvalidate) override;
 758     virtual void                        ClipToPaintRegion( tools::Rectangle& rDstRect ) override;
 759     virtual bool                        UsePolyPolygonForComplexGradient() override;
 760
 761     virtual void ApplySettings(vcl::RenderContext& rRenderContext);
 762 public:
 763     bool                                HasMirroredGraphics() const override;
 764
 765 public:
 766     // Single argument ctors shall be explicit.
 767     explicit                            Window( vcl::Window* pParent, WinBits nStyle = 0 );
 768
 769     virtual                             ~Window() override;
 770
 771     ::OutputDevice const*               GetOutDev() const;
 772     ::OutputDevice*                     GetOutDev();
 773
 774     virtual void                        EnableRTL ( bool bEnable = true ) override;
 775     virtual void                        MouseMove( const MouseEvent& rMEvt );
 776     virtual void                        MouseButtonDown( const MouseEvent& rMEvt );
 777     virtual void                        MouseButtonUp( const MouseEvent& rMEvt );
 778     virtual void                        KeyInput( const KeyEvent& rKEvt );
 779     virtual void                        KeyUp( const KeyEvent& rKEvt );
 780     virtual void                        PrePaint(vcl::RenderContext& rRenderContext);
 781     virtual void                        Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect);
 782     virtual void                        PostPaint(vcl::RenderContext& rRenderContext);
 783
 784     using OutputDevice::Erase;
 785     void                                Erase(vcl::RenderContext& rRenderContext);
 786
 787     virtual void                        Draw( ::OutputDevice* pDev, const Point& rPos, const Size& rSize, DrawFlags nFlags );
 788     virtual void                        Move();
 789     virtual void                        Resize();
 790     virtual void                        Activate();
 791     virtual void                        Deactivate();
 792     virtual void                        GetFocus();
 793     virtual void                        LoseFocus();
 794     virtual void                        RequestHelp( const HelpEvent& rHEvt );
 795     virtual void                        Command( const CommandEvent& rCEvt );
 796     virtual void                        Tracking( const TrackingEvent& rTEvt );
 797     virtual void                        StateChanged( StateChangedType nStateChange );
 798     virtual void                        DataChanged( const DataChangedEvent& rDCEvt );
 799     virtual bool                        PreNotify( NotifyEvent& rNEvt );
 800     virtual bool                        EventNotify( NotifyEvent& rNEvt );
 801
 802     // These methods call the relevant virtual method when not in/post dispose
 803     void                                CompatGetFocus();
 804     void                                CompatLoseFocus();
 805     void                                CompatStateChanged( StateChangedType nStateChange );
 806     void                                CompatDataChanged( const DataChangedEvent& rDCEvt );
 807     bool                                CompatPreNotify( NotifyEvent& rNEvt );
 808     bool                                CompatNotify( NotifyEvent& rNEvt );
 809
 810     void                                AddEventListener( const Link<VclWindowEvent&,void>& rEventListener );
 811     void                                RemoveEventListener( const Link<VclWindowEvent&,void>& rEventListener );
 812     void                                AddChildEventListener( const Link<VclWindowEvent&,void>& rEventListener );
 813     void                                RemoveChildEventListener( const Link<VclWindowEvent&,void>& rEventListener );
 814
 815     ImplSVEvent *                       PostUserEvent( const Link<void*,void>& rLink, void* pCaller = nullptr, bool bReferenceLink = false );
 816     void                                RemoveUserEvent( ImplSVEvent * nUserEvent );
 817
 818     void                                IncrementLockCount();
 819     void                                DecrementLockCount();
 820     bool                                IsLocked() const;
 821
 822                                         // returns the input language used for the last key stroke
 823                                         // may be LANGUAGE_DONTKNOW if not supported by the OS
 824     LanguageType                        GetInputLanguage() const;
 825
 826     void                                SetStyle( WinBits nStyle );
 827     WinBits                             GetStyle() const;
 828     WinBits                             GetPrevStyle() const;
 829     void                                SetExtendedStyle( WinBits nExtendedStyle );
 830     WinBits                             GetExtendedStyle() const;
 831     void                                SetType( WindowType nType );
 832     WindowType                          GetType() const;
 833     bool                                IsSystemWindow() const;
 834     bool                                IsDockingWindow() const;
 835     bool                                IsDialog() const;
 836     bool                                IsMenuFloatingWindow() const;
 837     bool                                IsToolbarFloatingWindow() const;
 838     bool                                IsTopWindow() const;
 839     bool                                IsDisposed() const;
 840     SystemWindow*                       GetSystemWindow() const;
 841
 842     /// Can the widget derived from this Window do the double-buffering via RenderContext properly?
 843     bool                                SupportsDoubleBuffering() const;
 844     /// Enable/disable double-buffering of the frame window and all its children.
 845     void                                RequestDoubleBuffering(bool bRequest);
 846
 847     void                                EnableAllResize();
 848
 849     void                                SetBorderStyle( WindowBorderStyle nBorderStyle );
 850     WindowBorderStyle                   GetBorderStyle() const;
 851     void                                GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder,
 852                                                    sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const;
 853     Size                                CalcWindowSize( const Size& rOutSz ) const;
 854     Size                                CalcOutputSize( const Size& rWinSz ) const;
 855     long                                CalcTitleWidth() const;
 856
 857     void                                EnableClipSiblings( bool bClipSiblings = true );
 858
 859     void                                EnableChildTransparentMode( bool bEnable = true );
 860     bool                                IsChildTransparentModeEnabled() const;
 861
 862     void                                SetMouseTransparent( bool bTransparent );
 863     bool                                IsMouseTransparent() const;
 864     void                                SetPaintTransparent( bool bTransparent );
 865     bool                                IsPaintTransparent() const;
 866     void                                SetDialogControlStart( bool bStart );
 867     bool                                IsDialogControlStart() const;
 868     void                                SetDialogControlFlags( DialogControlFlags nFlags );
 869     DialogControlFlags                  GetDialogControlFlags() const;
 870
 871     struct PointerState
 872     {
 873         sal_uLong   mnState;    // the button state
 874         Point   maPos;      // mouse position in output coordinates
 875     };
 876     PointerState                        GetPointerState();
 877     bool                                IsMouseOver();
 878
 879     void                                SetInputContext( const InputContext& rInputContext );
 880     const InputContext&                 GetInputContext() const;
 881     void                                EndExtTextInput();
 882     void                                SetCursorRect( const tools::Rectangle* pRect = nullptr, long nExtTextInputWidth = 0 );
 883     const tools::Rectangle*                    GetCursorRect() const;
 884     long                                GetCursorExtTextInputWidth() const;
 885
 886     void                                SetCompositionCharRect( const tools::Rectangle* pRect, long nCompositionLength, bool bVertical = false );
 887
 888     using                               ::OutputDevice::SetSettings;
 889     virtual void                        SetSettings( const AllSettings& rSettings ) override;
 890     void                                SetSettings( const AllSettings& rSettings, bool bChild );
 891     void                                UpdateSettings( const AllSettings& rSettings, bool bChild = false );
 892     void                                NotifyAllChildren( DataChangedEvent& rDCEvt );
 893
 894     void                                SetPointFont(vcl::RenderContext& rRenderContext, const vcl::Font& rFont);
 895     vcl::Font                           GetPointFont(vcl::RenderContext& rRenderContext) const;
 896     void                                SetZoomedPointFont(vcl::RenderContext& rRenderContext, const vcl::Font& rFont);
 897     long                                GetDrawPixel( ::OutputDevice* pDev, long nPixels ) const;
 898     vcl::Font                           GetDrawPixelFont( ::OutputDevice* pDev ) const;
 899
 900     void SetControlFont();
 901     void SetControlFont( const vcl::Font& rFont );
 902     vcl::Font GetControlFont() const;
 903     bool IsControlFont() const;
 904     void ApplyControlFont(vcl::RenderContext& rRenderContext, const vcl::Font& rDefaultFont);
 905
 906     void SetControlForeground();
 907     void SetControlForeground(const Color& rColor);
 908     const Color& GetControlForeground() const;
 909     bool IsControlForeground() const;
 910     void ApplyControlForeground(vcl::RenderContext& rRenderContext, const Color& rDefaultColor);
 911
 912     void SetControlBackground();
 913     void SetControlBackground( const Color& rColor );
 914     const Color& GetControlBackground() const;
 915     bool IsControlBackground() const;
 916     void ApplyControlBackground(vcl::RenderContext& rRenderContext, const Color& rDefaultColor);
 917
 918     void                                SetParentClipMode( ParentClipMode nMode = ParentClipMode::NONE );
 919     ParentClipMode                      GetParentClipMode() const;
 920
 921     void                                SetWindowRegionPixel();
 922     void                                SetWindowRegionPixel( const vcl::Region& rRegion );
 923     const vcl::Region&                  GetWindowRegionPixel() const;
 924     bool                                IsWindowRegionPixel() const;
 925     vcl::Region                         GetWindowClipRegionPixel() const;
 926     vcl::Region                         GetPaintRegion() const;
 927     bool                                IsInPaint() const;
 928     // while IsInPaint returns true ExpandPaintClipRegion adds the
 929     // submitted region to the paint clip region so you can
 930     // paint additional parts of your window if necessary
 931     void                                ExpandPaintClipRegion( const vcl::Region& rRegion );
 932
 933     void                                SetParent( vcl::Window* pNewParent );
 934     vcl::Window*                        GetParent() const;
 935     // return the dialog we are contained in or NULL if un-contained
 936     Dialog*                             GetParentDialog() const;
 937
 938     void                                Show( bool bVisible = true, ShowFlags nFlags = ShowFlags::NONE );
 939     void                                Hide() { Show( false ); }
 940     bool                                IsVisible() const;
 941     bool                                IsReallyVisible() const;
 942     bool                                IsReallyShown() const;
 943     bool                                IsInInitShow() const;
 944
 945     void                                Enable( bool bEnable = true, bool bChild = true );
 946     void                                Disable( bool bChild = true ) { Enable( false, bChild ); }
 947     bool                                IsEnabled() const;
 948
 949     void                                EnableInput( bool bEnable = true, bool bChild = true );
 950     void                                EnableInput( bool bEnable, const vcl::Window* pExcludeWindow );
 951     bool                                IsInputEnabled() const;
 952
 953     /** Override <code>EnableInput</code>. This can be necessary due to other people
 954         using EnableInput for whole window hierarchies.
 955
 956
 957         <code>AlwaysEnableInput</code> and <code>AlwaysDisableInput</code> are
 958         mutually exclusive; the last setter wins.
 959         @param bAlways
 960         sets always enabled flag
 961
 962         @param bChild
 963         if true children are recursively set to AlwaysEnableInput
 964     */
 965     void                                AlwaysEnableInput( bool bAlways, bool bChild = true );
 966     /** returns the current AlwaysEnableInput state
 967     @return
 968     true if window is in AlwaysEnableInput state
 969     */
 970     bool                                IsAlwaysEnableInput() const;
 971     /** Override <code>EnableInput</code>, counterpart to AlwaysEnableInput.
 972         Windows with AlwaysDisableInput will not get key events even if enabled
 973         and input enabled.This can be necessary due to other people using EnableInput
 974         for whole window hierarchies.
 975
 976         <code>AlwaysEnableInput</code> and <code>AlwaysDisableInput</code> are
 977         mutually exclusive; the last setter wins.
 978
 979         @param bAlways
 980         sets always disable flag
 981
 982         @param bChild
 983         if true children are recursively set to AlwaysDisableInput
 984     */
 985     void                                AlwaysDisableInput( bool bAlways, bool bChild = true );
 986
 987     /** usually event handlers (see AddEventListener and AddChildEventListener)
 988     are not called on disabled, modal or input disabled windows. There are however rare cases
 989     in which one wants a Window or rather one of its Control subclasses to
 990     not evaluate events but still react to those events externally. In these
 991     rare cases call SetCallHandlersOnInputDisabled( true ) to have your handler
 992     called anyway.
 993
 994     Currently only mouse events get this special treatment.
 995
 996     Use this sparingly, chances are if you want to use it you're working around
 997     the real problem.
 998
 999     @param bCall
1000     Enable/Disable calling event handlers for this disabled, modal or input disabled window.
1001     This call is implicity done recursively for possible child windows.
1002     */
1003     void                                SetCallHandlersOnInputDisabled( bool bCall );
1004     /** get state of SetCallHandlersOnInputDisabled
1005
1006     @returns whether handlers are called regardless of input enabled state
1007     */
1008     bool                                IsCallHandlersOnInputDisabled() const;
1009     /** A window is in modal mode if one of its children or subchildren
1010         is a running modal window (a modal dialog)
1011
1012         @returns sal_True if a child or subchild is a running modal window
1013     */
1014     bool                                IsInModalMode() const;
1015
1016     void                                SetActivateMode( ActivateModeFlags nMode );
1017     ActivateModeFlags                   GetActivateMode() const;
1018
1019     void                                ToTop( ToTopFlags nFlags = ToTopFlags::NONE );
1020     void                                SetZOrder( vcl::Window* pRefWindow, ZOrderFlags nFlags );
1021     void                                EnableAlwaysOnTop( bool bEnable = true );
1022     bool                                IsAlwaysOnTopEnabled() const;
1023
1024     virtual void                        setPosSizePixel( long nX, long nY,
1025                                                          long nWidth, long nHeight,
1026                                                          PosSizeFlags nFlags = PosSizeFlags::All );
1027     virtual void                        SetPosPixel( const Point& rNewPos );
1028     virtual Point                       GetPosPixel() const;
1029     virtual void                        SetSizePixel( const Size& rNewSize );
1030     virtual Size                        GetSizePixel() const;
1031     virtual void                        SetPosSizePixel( const Point& rNewPos,
1032                                                          const Size& rNewSize );
1033     virtual void                        SetOutputSizePixel( const Size& rNewSize );
1034     bool                                IsDefaultPos() const;
1035     bool                                IsDefaultSize() const;
1036
1037     // those conversion routines might deliver different results during UI mirroring
1038     Point                               OutputToScreenPixel( const Point& rPos ) const;
1039     Point                               ScreenToOutputPixel( const Point& rPos ) const;
1040     //  the normalized screen methods work independent from UI mirroring
1041     Point                               OutputToNormalizedScreenPixel( const Point& rPos ) const;
1042     Point                               NormalizedScreenToOutputPixel( const Point& rPos ) const;
1043     Point                               OutputToAbsoluteScreenPixel( const Point& rPos ) const;
1044     Point                               AbsoluteScreenToOutputPixel( const Point& rPos ) const;
1045     tools::Rectangle                           GetDesktopRectPixel() const;
1046     //  window extents including border and decoration
1047     tools::Rectangle                           GetWindowExtentsRelative( vcl::Window *pRelativeWindow ) const;
1048     // window extents of the client window, coordinates to be used in SetPosPixel
1049     tools::Rectangle                           GetClientWindowExtentsRelative() const;
1050
1051     bool                                IsScrollable() const;
1052     virtual void                        Scroll( long nHorzScroll, long nVertScroll,
1053                                                 ScrollFlags nFlags = ScrollFlags::NONE );
1054     void                                Scroll( long nHorzScroll, long nVertScroll,
1055                                                 const tools::Rectangle& rRect, ScrollFlags nFlags = ScrollFlags::NONE );
1056     virtual void                        Invalidate( InvalidateFlags nFlags = InvalidateFlags::NONE );
1057     virtual void                        Invalidate( const tools::Rectangle& rRect, InvalidateFlags nFlags = InvalidateFlags::NONE );
1058     virtual void                        Invalidate( const vcl::Region& rRegion, InvalidateFlags nFlags = InvalidateFlags::NONE );
1059     void                                Validate();
1060     bool                                HasPaintEvent() const;
1061     void                                Update();
1062     void                                Flush();
1063
1064     // toggles new docking support, enabled via toolkit
1065     void                                EnableDocking( bool bEnable = true );
1066     // retrieves the single dockingmanager instance
1067     static DockingManager*              GetDockingManager();
1068
1069     void                                EnablePaint( bool bEnable );
1070     bool                                IsPaintEnabled() const;
1071     void                                SetUpdateMode( bool bUpdate );
1072     bool                                IsUpdateMode() const;
1073     void                                SetParentUpdateMode( bool bUpdate );
1074
1075     void                                GrabFocus();
1076     bool                                HasFocus() const;
1077     bool                                HasChildPathFocus( bool bSystemWindow = false ) const;
1078     bool                                IsActive() const;
1079     bool                                HasActiveChildFrame();
1080     GetFocusFlags                       GetGetFocusFlags() const;
1081     void                                GrabFocusToDocument();
1082
1083     /**
1084      * Set this when you need to act as if the window has focus even if it
1085      * doesn't.  This is necessary for implementing tab stops inside floating
1086      * windows, but floating windows don't get focus from the system.
1087      */
1088     void                                SetFakeFocus( bool bFocus );
1089
1090     bool                                IsCompoundControl() const;
1091
1092     static VclPtr<vcl::Window>          SaveFocus();
1093     static void                         EndSaveFocus(const VclPtr<vcl::Window>& xFocusWin);
1094
1095     void                                CaptureMouse();
1096     void                                ReleaseMouse();
1097     bool                                IsMouseCaptured() const;
1098
1099     void                                SetPointer( const Pointer& rPointer );
1100     const Pointer&                      GetPointer() const;
1101     void                                EnableChildPointerOverwrite( bool bOverwrite );
1102     void                                SetPointerPosPixel( const Point& rPos );
1103     Point                               GetPointerPosPixel();
1104     Point                               GetLastPointerPosPixel();
1105     /// Similar to SetPointerPosPixel(), but sets the frame data's last mouse position instead.
1106     void                                SetLastMousePos(const Point& rPos);
1107     void                                ShowPointer( bool bVisible );
1108     void                                EnterWait();
1109     void                                LeaveWait();
1110     bool                                IsWait() const;
1111
1112     void                                SetCursor( vcl::Cursor* pCursor );
1113     vcl::Cursor*                        GetCursor() const;
1114
1115     void                                SetZoom( const Fraction& rZoom );
1116     const Fraction&                     GetZoom() const;
1117     bool                                IsZoom() const;
1118     long                                CalcZoom( long n ) const;
1119
1120     virtual void                        SetText( const OUString& rStr );
1121     virtual OUString                    GetText() const;
1122     // return the actual text displayed
1123     // this may have e.g. accelerators removed or portions
1124     // replaced by ellipses
1125     virtual OUString                    GetDisplayText() const;
1126     // gets the visible background color. for transparent windows
1127     // this may be the parent's background color; for controls
1128     // this may be a child's background color (e.g. ListBox)
1129     virtual const Wallpaper&            GetDisplayBackground() const;
1130
1131     void                                SetHelpText( const OUString& rHelpText );
1132     const OUString&                     GetHelpText() const;
1133
1134     void                                SetQuickHelpText( const OUString& rHelpText );
1135     const OUString&                     GetQuickHelpText() const;
1136
1137     void                                SetHelpId( const OString& );
1138     const OString&                      GetHelpId() const;
1139
1140     /** String ID of this window for the purpose of creating a screenshot
1141
1142         In default implementation this ID is the same as HelpId. Override this method
1143         in windows (dialogs,tabpages) that need different IDs for different configurations
1144         they can be in
1145
1146         @return screenshot ID of this window
1147     */
1148     virtual OString                     GetScreenshotId() const;
1149
1150     vcl::Window*                        FindWindow( const Point& rPos ) const;
1151
1152     sal_uInt16                          GetChildCount() const;
1153     vcl::Window*                        GetChild( sal_uInt16 nChild ) const;
1154     vcl::Window*                        GetWindow( GetWindowType nType ) const;
1155     bool                                IsChild( const vcl::Window* pWindow, bool bSystemWindow = false ) const;
1156     bool                                IsWindowOrChild( const vcl::Window* pWindow, bool bSystemWindow = false  ) const;
1157
1158     /// Add all children to rAllChildren recursively.
1159     SAL_DLLPRIVATE void                 CollectChildren(::std::vector<vcl::Window *>& rAllChildren );
1160
1161     virtual void                        ShowFocus(const tools::Rectangle& rRect);
1162     void                                HideFocus();
1163
1164     // transparent background for selected or checked items in toolboxes etc.
1165     void                                DrawSelectionBackground( const tools::Rectangle& rRect, sal_uInt16 highlight, bool bChecked, bool bDrawBorder );
1166
1167     void                                ShowTracking( const tools::Rectangle& rRect,
1168                                                       ShowTrackFlags nFlags = ShowTrackFlags::Small );
1169     void                                HideTracking();
1170     void                                InvertTracking( const tools::Rectangle& rRect, ShowTrackFlags nFlags );
1171     void                                InvertTracking( const tools::Polygon& rPoly, ShowTrackFlags nFlags );
1172
1173     void                                StartTracking( StartTrackingFlags nFlags = StartTrackingFlags::NONE );
1174     void                                EndTracking( TrackingEventFlags nFlags = TrackingEventFlags::NONE );
1175     bool                                IsTracking() const;
1176
1177     void                                StartAutoScroll( StartAutoScrollFlags nFlags );
1178     void                                EndAutoScroll();
1179
1180     bool                                HandleScrollCommand( const CommandEvent& rCmd,
1181                                                              ScrollBar* pHScrl,
1182                                                              ScrollBar* pVScrl );
1183
1184     void                                SaveBackground( const Point& rPos, const Size& rSize,
1185                                                         VirtualDevice& rSaveDevice );
1186
1187     virtual const SystemEnvData*        GetSystemData() const;
1188     css::uno::Any                       GetSystemDataAny() const;
1189
1190     // API to set/query the component interfaces
1191     virtual css::uno::Reference< css::awt::XWindowPeer >
1192                                         GetComponentInterface( bool bCreate = true );
1193
1194     void                        SetComponentInterface( css::uno::Reference< css::awt::XWindowPeer > const & xIFace );
1195
1196     /** @name Accessibility
1197      */
1198     ///@{
1199 public:
1200
1201     css::uno::Reference< css::accessibility::XAccessible >
1202                                         GetAccessible( bool bCreate = true );
1203
1204     virtual css::uno::Reference< css::accessibility::XAccessible >
1205                                         CreateAccessible();
1206
1207     void                                SetAccessible( const css::uno::Reference< css::accessibility::XAccessible >& );
1208
1209     vcl::Window*                        GetAccessibleParentWindow() const;
1210     sal_uInt16                          GetAccessibleChildWindowCount();
1211     vcl::Window*                        GetAccessibleChildWindow( sal_uInt16 n );
1212
1213     void                                SetAccessibleRole( sal_uInt16 nRole );
1214     sal_uInt16                          GetAccessibleRole() const;
1215
1216     void                                SetAccessibleName( const OUString& rName );
1217     OUString                            GetAccessibleName() const;
1218
1219     void                                SetAccessibleDescription( const OUString& rDescr );
1220     OUString                            GetAccessibleDescription() const;
1221
1222     void                                SetAccessibleRelationLabeledBy( vcl::Window* pLabeledBy );
1223     vcl::Window*                        GetAccessibleRelationLabeledBy() const;
1224
1225     void                                SetAccessibleRelationLabelFor( vcl::Window* pLabelFor );
1226     vcl::Window*                        GetAccessibleRelationLabelFor() const;
1227
1228     void                                SetAccessibleRelationMemberOf( vcl::Window* pMemberOf );
1229     vcl::Window*                        GetAccessibleRelationMemberOf() const;
1230
1231
1232     // to avoid sending accessibility events in cases like closing dialogs
1233     // by default checks complete parent path
1234     bool                                IsAccessibilityEventsSuppressed( bool bTraverseParentPath = true );
1235     void                                SetAccessibilityEventsSuppressed(bool bSuppressed);
1236
1237     // Deprecated - can use SetAccessibleRelationLabelFor/By nowadays
1238     virtual vcl::Window*                GetParentLabelFor( const vcl::Window* pLabel ) const;
1239     virtual vcl::Window*                GetParentLabeledBy( const vcl::Window* pLabeled ) const;
1240     KeyEvent                            GetActivationKey() const;
1241
1242 protected:
1243
1244     // These eventually are supposed to go when everything is converted to .ui
1245     SAL_DLLPRIVATE vcl::Window*         getLegacyNonLayoutAccessibleRelationMemberOf() const;
1246     SAL_DLLPRIVATE vcl::Window*         getLegacyNonLayoutAccessibleRelationLabeledBy() const;
1247     SAL_DLLPRIVATE vcl::Window*         getLegacyNonLayoutAccessibleRelationLabelFor() const;
1248
1249     // Let Label override the code part of GetAccessibleRelationLabelFor
1250     virtual vcl::Window*                getAccessibleRelationLabelFor() const;
1251     virtual sal_uInt16                  getDefaultAccessibleRole() const;
1252     virtual OUString                    getDefaultAccessibleName() const;
1253
1254     /*
1255      * Advisory Sizing - what is a good size for this widget
1256      *
1257      * Retrieves the preferred size of a widget ignoring
1258      * "width-request" and "height-request" properties.
1259      *
1260      * Implement this in sub-classes to tell layout
1261      * the preferred widget size.
1262      *
1263      * Use get_preferred_size to retrieve this value
1264      * cached and mediated via height and width requests
1265      */
1266     virtual Size GetOptimalSize() const;
1267     /// clear OptimalSize cache
1268     void InvalidateSizeCache();
1269 private:
1270
1271     SAL_DLLPRIVATE bool                 ImplIsAccessibleCandidate() const;
1272     SAL_DLLPRIVATE bool                 ImplIsAccessibleNativeFrame() const;
1273     ///@}
1274
1275     /*
1276      * Retrieves the preferred size of a widget taking
1277      * into account the "width-request" and "height-request" properties.
1278      *
1279      * Overrides the result of GetOptimalSize to honor the
1280      * width-request and height-request properties.
1281      *
1282      * So the same as get_ungrouped_preferred_size except
1283      * it ignores groups. A building block of get_preferred_size
1284      * that access the size cache
1285      *
1286      * @see get_preferred_size
1287      */
1288     Size get_ungrouped_preferred_size() const;
1289 public:
1290     /// request XCanvas render interface for this window
1291     css::uno::Reference< css::rendering::XCanvas >
1292                                         GetCanvas() const;
1293     /// request XSpriteCanvas render interface for this window
1294     css::uno::Reference< css::rendering::XSpriteCanvas >
1295                                         GetSpriteCanvas() const;
1296
1297     /*  records all DrawText operations within the passed rectangle;
1298      *  a synchronous paint is sent to achieve this
1299      */
1300     void                                RecordLayoutData( vcl::ControlLayoutData* pLayout, const tools::Rectangle& rRect );
1301
1302     // set and retrieve for Toolkit
1303     VCLXWindow*                         GetWindowPeer() const;
1304     void                                SetWindowPeer( css::uno::Reference< css::awt::XWindowPeer > const & xPeer, VCLXWindow* pVCLXWindow );
1305
1306     // remember if it was generated by Toolkit
1307     bool                                IsCreatedWithToolkit() const;
1308     void                                SetCreatedWithToolkit( bool b );
1309
1310     // Drag and Drop interfaces
1311     css::uno::Reference< css::datatransfer::dnd::XDropTarget > GetDropTarget();
1312     css::uno::Reference< css::datatransfer::dnd::XDragSource > GetDragSource();
1313     css::uno::Reference< css::datatransfer::dnd::XDragGestureRecognizer > GetDragGestureRecognizer();
1314
1315     // Clipboard/Selection interfaces
1316     css::uno::Reference< css::datatransfer::clipboard::XClipboard > GetClipboard();
1317     /// Sets a custom clipboard for the window's frame, instead of creating it on-demand using css::datatransfer::clipboard::SystemClipboard.
1318     void SetClipboard(css::uno::Reference<css::datatransfer::clipboard::XClipboard> const & xClipboard);
1319     css::uno::Reference< css::datatransfer::clipboard::XClipboard > GetPrimarySelection();
1320
1321     /*
1322      * Widgets call this to inform their owner container that the widget wants
1323      * to renegotiate its size. Should be called when a widget has a new size
1324      * request. e.g. a FixedText Control gets a new label.
1325      *
1326      * akin to gtk_widget_queue_resize
1327      */
1328     virtual void queue_resize(StateChangedType eReason = StateChangedType::Layout);
1329
1330     /*
1331      * Sets the "height-request" property
1332      *
1333      * Override for height request of the widget, or -1 if natural request
1334      * should be used.
1335      *
1336      * @see get_preferred_size, set_width_request
1337      */
1338     void set_height_request(sal_Int32 nHeightRequest);
1339     sal_Int32 get_height_request() const;
1340
1341     /*
1342      * Sets the "width-request" property
1343      *
1344      * Override for width request of the widget, or -1 if natural request
1345      * should be used.
1346      *
1347      * @see get_preferred_size, set_height_request
1348      */
1349     void set_width_request(sal_Int32 nWidthRequest);
1350     sal_Int32 get_width_request() const;
1351
1352     /*
1353      * Retrieves the preferred size of a widget taking
1354      * into account the "width-request" and "height-request" properties.
1355      *
1356      * Overrides the result of GetOptimalSize to honor the
1357      * width-request and height-request properties.
1358      *
1359      * @see GetOptimalSize
1360      *
1361      * akin to gtk_widget_get_preferred_size
1362      */
1363     Size get_preferred_size() const;
1364
1365     /*
1366      * How to horizontally align this widget
1367      */
1368     VclAlign get_halign() const;
1369     void set_halign(VclAlign eAlign);
1370
1371     /*
1372      * How to vertically align this widget
1373      */
1374     VclAlign get_valign() const;
1375     void set_valign(VclAlign eAlign);
1376
1377     /*
1378      * Whether the widget would like to use any available extra horizontal
1379      * space.
1380      */
1381     bool get_hexpand() const;
1382     void set_hexpand(bool bExpand);
1383
1384     /*
1385      * Whether the widget would like to use any available extra vertical
1386      * space.
1387      */
1388     bool get_vexpand() const;
1389     void set_vexpand(bool bExpand);
1390
1391     /*
1392      * Whether the widget would like to use any available extra space.
1393      */
1394     bool get_expand() const;
1395     void set_expand(bool bExpand);
1396
1397     /*
1398      * Whether the widget should receive extra space when the parent grows
1399      */
1400     bool get_fill() const;
1401     void set_fill(bool bFill);
1402
1403     void set_border_width(sal_Int32 nBorderWidth);
1404     sal_Int32 get_border_width() const;
1405
1406     void set_margin_left(sal_Int32 nWidth);
1407     sal_Int32 get_margin_left() const;
1408
1409     void set_margin_right(sal_Int32 nWidth);
1410     sal_Int32 get_margin_right() const;
1411
1412     void set_margin_top(sal_Int32 nWidth);
1413     sal_Int32 get_margin_top() const;
1414
1415     void set_margin_bottom(sal_Int32 nWidth);
1416     sal_Int32 get_margin_bottom() const;
1417
1418     /*
1419      * How the widget is packed with reference to the start or end of the parent
1420      */
1421     VclPackType get_pack_type() const;
1422     void set_pack_type(VclPackType ePackType);
1423
1424     /*
1425      * The extra space to put between the widget and its neighbors
1426      */
1427     sal_Int32 get_padding() const;
1428     void set_padding(sal_Int32 nPadding);
1429
1430     /*
1431      * The number of columns that the widget spans
1432      */
1433     sal_Int32 get_grid_width() const;
1434     void set_grid_width(sal_Int32 nCols);
1435
1436     /*
1437      * The column number to attach the left side of the widget to
1438      */
1439     sal_Int32 get_grid_left_attach() const;
1440     void set_grid_left_attach(sal_Int32 nAttach);
1441
1442     /*
1443      * The number of row that the widget spans
1444      */
1445     sal_Int32 get_grid_height() const;
1446     void set_grid_height(sal_Int32 nRows);
1447
1448     /*
1449      * The row number to attach the top side of the widget to
1450      */
1451     sal_Int32 get_grid_top_attach() const;
1452     void set_grid_top_attach(sal_Int32 nAttach);
1453
1454     /*
1455      * If true this child appears in a secondary layout group of children
1456      * e.g. help buttons in a buttonbox
1457      */
1458     bool get_secondary() const;
1459     void set_secondary(bool bSecondary);
1460
1461     /*
1462      * If true this child is exempted from homogenous sizing
1463      * e.g. special button in a buttonbox
1464      */
1465     bool get_non_homogeneous() const;
1466     void set_non_homogeneous(bool bNonHomogeneous);
1467
1468     /*
1469      * Sets a widget property
1470      *
1471      * @return false if property is unknown
1472      */
1473     virtual bool set_property(const OString &rKey, const OUString &rValue);
1474
1475     /*
1476      * Sets a font attribute
1477      *
1478      * @return false if attribute is unknown
1479      */
1480     bool set_font_attribute(const OString &rKey, const OUString &rValue);
1481
1482     /*
1483      * Adds this widget to the xGroup VclSizeGroup
1484      *
1485      */
1486     void add_to_size_group(const std::shared_ptr<VclSizeGroup>& xGroup);
1487     void remove_from_all_size_groups();
1488
1489     /*
1490      * add/remove mnemonic label
1491      */
1492     void add_mnemonic_label(FixedText *pLabel);
1493     void remove_mnemonic_label(FixedText *pLabel);
1494     const std::vector<VclPtr<FixedText> >& list_mnemonic_labels() const;
1495
1496     /*
1497      * Move this widget to be the nNewPosition'd child of its parent
1498      */
1499     void reorderWithinParent(sal_uInt16 nNewPosition);
1500
1501     /**
1502      * Sets an ID.
1503      */
1504     void set_id(const OUString& rID);
1505
1506     /**
1507      * Get the ID of the window.
1508      */
1509     const OUString& get_id() const;
1510
1511
1512     //  Native Widget Rendering functions
1513
1514
1515     // form controls must never use native widgets, this can be toggled here
1516     void    EnableNativeWidget( bool bEnable = true );
1517     bool    IsNativeWidgetEnabled() const;
1518
1519     // a helper method for a Control's Draw method
1520     void PaintToDevice( ::OutputDevice* pDevice, const Point& rPos, const Size& rSize );
1521
1522     /* mark Window for deletion in top of event queue
1523     */
1524     void doLazyDelete();
1525
1526
1527     //  Keyboard access functions
1528
1529
1530     /** Query the states of keyboard indicators - Caps Lock, Num Lock and
1531         Scroll Lock.  Use the following mask to retrieve the state of each
1532         indicator:
1533
1534             KeyIndicatorState::CAPS_LOCK
1535             KeyIndicatorState::NUM_LOCK
1536             KeyIndicatorState::SCROLL_LOCK
1537       */
1538     KeyIndicatorState GetIndicatorState() const;
1539
1540     void SimulateKeyPress( sal_uInt16 nKeyCode ) const;
1541
1542     virtual OUString GetSurroundingText() const;
1543     virtual Selection GetSurroundingTextSelection() const;
1544
1545     virtual FactoryFunction GetUITestFactory() const;
1546 };
1547
1548 }
1549
1550 // Only for compatibility - because many people outside haven't included event.hxx
1551 // These require Window to be defined for VclPtr<Window>
1552 #include <vcl/event.hxx>
1553
1554 #endif // INCLUDED_VCL_WINDOW_HXX
1555
1556 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */