include/vcl/dockwin.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_DOCKWIN_HXX
  21 #define INCLUDED_VCL_DOCKWIN_HXX
  22
  23 #include <vcl/dllapi.h>
  24 #include <o3tl/deleter.hxx>
  25 #include <vcl/builder.hxx>
  26 #include <vcl/floatwin.hxx>
  27 #include <memory>
  28 #include <vector>
  29
  30 // data to be sent with docking events
  31 struct DockingData
  32 {
  33     Point const       maMousePos;     // in
  34     tools::Rectangle   maTrackRect;    // in/out
  35     bool        mbFloating;     // out
  36
  37     DockingData( const Point& rPt, const tools::Rectangle& rRect, bool b) :
  38         maMousePos( rPt ), maTrackRect( rRect ), mbFloating( b )
  39         {};
  40 };
  41
  42 struct EndDockingData
  43 {
  44     tools::Rectangle const   maWindowRect;    // in
  45     bool const        mbFloating;      // in
  46     bool const        mbCancelled;     // in
  47
  48     EndDockingData( const tools::Rectangle& rRect, bool b, bool bCancelled ) :
  49         maWindowRect( rRect ), mbFloating( b ), mbCancelled( bCancelled )
  50         {};
  51 };
  52
  53 struct EndPopupModeData
  54 {
  55     Point const       maFloatingPos;    // in
  56     bool const        mbTearoff;        // in
  57
  58     EndPopupModeData( const Point& rPos, bool bTearoff ) :
  59         maFloatingPos( rPos ), mbTearoff( bTearoff )
  60         {};
  61 };
  62
  63 /** ImplDockingWindowWrapper
  64  *
  65  *  ImplDockingWindowWrapper obsoletes the DockingWindow class.
  66  *  It is better because it can make a "normal window" dockable.
  67  *  All DockingWindows should be converted the new class.
  68  */
  69
  70 class ImplDockingWindowWrapper final
  71 {
  72     friend class ::vcl::Window;
  73     friend class DockingManager;
  74     friend class DockingWindow;
  75
  76 private:
  77
  78     // the original 'Docking'window
  79     VclPtr<vcl::Window>    mpDockingWindow;
  80
  81     // the original DockingWindow members
  82     VclPtr<FloatingWindow> mpFloatWin;
  83     VclPtr<vcl::Window>    mpOldBorderWin;
  84     VclPtr<vcl::Window>    mpParent;
  85     Point           maFloatPos;
  86     Point           maDockPos;
  87     Point           maMouseOff;
  88     Size            maRollUpOutSize;
  89     Size            maMinOutSize;
  90     Size            maMaxOutSize;
  91     tools::Rectangle       maDragArea;
  92     long            mnTrackX;
  93     long            mnTrackY;
  94     long            mnTrackWidth;
  95     long            mnTrackHeight;
  96     sal_Int32       mnDockLeft;
  97     sal_Int32       mnDockTop;
  98     sal_Int32       mnDockRight;
  99     sal_Int32       mnDockBottom;
 100     WinBits         mnFloatBits;
 101     bool            mbDockCanceled:1,
 102                     mbDocking:1,
 103                     mbLastFloatMode:1,
 104                     mbRollUp:1,
 105                     mbDockBtn:1,
 106                     mbHideBtn:1,
 107                     mbStartDockingEnabled:1,
 108                     mbLocked:1;
 109
 110                     DECL_LINK( PopupModeEnd, FloatingWindow*, void );
 111     void            ImplEnableStartDocking()  { mbStartDockingEnabled = true; }
 112     bool            ImplStartDockingEnabled() const { return mbStartDockingEnabled; }
 113     void            ImplPreparePopupMode();
 114
 115 public:
 116     ImplDockingWindowWrapper( const vcl::Window *pWindow );
 117     ~ImplDockingWindowWrapper();
 118
 119     vcl::Window*    GetWindow()     { return mpDockingWindow; }
 120     void            ImplStartDocking( const Point& rPos );
 121
 122     // those methods actually call the corresponding handlers
 123     void            StartDocking( const Point& rPos, tools::Rectangle const & rRect );
 124     bool            Docking( const Point& rPos, tools::Rectangle& rRect );
 125     void            EndDocking( const tools::Rectangle& rRect, bool bFloatMode );
 126     bool            PrepareToggleFloatingMode();
 127     void            ToggleFloatingMode();
 128
 129     void            SetDragArea( const tools::Rectangle& rRect );
 130     const tools::Rectangle& GetDragArea() const { return maDragArea;}
 131
 132     void            Lock();
 133     void            Unlock();
 134     bool            IsLocked() const { return mbLocked;}
 135
 136     void            StartPopupMode( const tools::Rectangle& rRect, FloatWinPopupFlags nPopupModeFlags );
 137     void            StartPopupMode( ToolBox* pParentToolBox, FloatWinPopupFlags nPopupModeFlags );
 138     bool            IsInPopupMode() const;
 139
 140     void            TitleButtonClick( TitleButton nButton );
 141     void            Resizing( Size& rSize );
 142     void            Tracking( const TrackingEvent& rTEvt );
 143
 144     void            ShowTitleButton( TitleButton nButton, bool bVisible );
 145
 146     void            SetMinOutputSizePixel( const Size& rSize );
 147
 148     void            SetMaxOutputSizePixel( const Size& rSize );
 149
 150     bool            IsDocking() const { return mbDocking; }
 151     bool            IsDockingCanceled() const { return mbDockCanceled; }
 152
 153     void            SetFloatingMode( bool bFloatMode );
 154     bool            IsFloatingMode() const;
 155     FloatingWindow* GetFloatingWindow() const { return mpFloatWin; }
 156
 157     void            SetFloatStyle( WinBits nWinStyle );
 158     WinBits         GetFloatStyle() const { return mnFloatBits;}
 159
 160     void            setPosSizePixel( long nX, long nY,
 161                                      long nWidth, long nHeight,
 162                                      PosSizeFlags nFlags );
 163     Point           GetPosPixel() const;
 164     Size            GetSizePixel() const;
 165 };
 166
 167 class VCL_DLLPUBLIC DockingManager
 168 {
 169     std::vector<std::unique_ptr<ImplDockingWindowWrapper, o3tl::default_delete<ImplDockingWindowWrapper>>> mvDockingWindows;
 170
 171 public:
 172     DockingManager();
 173     ~DockingManager();
 174
 175     DockingManager& operator=( DockingManager const & ) = delete; // MSVC2015 workaround
 176     DockingManager( DockingManager const & ) = delete; // MSVC2015 workaround
 177
 178     void AddWindow( const vcl::Window *pWin );
 179     void RemoveWindow( const vcl::Window *pWin );
 180
 181     ImplDockingWindowWrapper*  GetDockingWindowWrapper( const vcl::Window *pWin );
 182     bool IsDockable( const vcl::Window *pWin );
 183
 184     bool IsFloating( const vcl::Window *pWin );
 185     void SetFloatingMode( const vcl::Window *pWin, bool bFloating );
 186
 187     void Lock( const vcl::Window *pWin );
 188     void Unlock( const vcl::Window *pWin );
 189     bool IsLocked( const vcl::Window *pWin );
 190
 191     void    StartPopupMode( const vcl::Window *pWin, const tools::Rectangle& rRect, FloatWinPopupFlags nPopupModeFlags );
 192     void    StartPopupMode( ToolBox *pParentToolBox, const vcl::Window *pWin );
 193     void    StartPopupMode( ToolBox *pParentToolBox, const vcl::Window *pWin, FloatWinPopupFlags nPopupModeFlags );
 194
 195     bool    IsInPopupMode( const vcl::Window *pWin );
 196     void    EndPopupMode( const vcl::Window *pWin );
 197
 198     // required because those methods are not virtual in Window (!!!) and must
 199     // be available from the toolkit
 200     void        SetPosSizePixel( vcl::Window const *pWin, long nX, long nY,
 201                                 long nWidth, long nHeight,
 202                                 PosSizeFlags nFlags );
 203     tools::Rectangle   GetPosSizePixel( const vcl::Window *pWin );
 204 };
 205
 206
 207 class VCL_DLLPUBLIC DockingWindow
 208     : public vcl::Window
 209     , public VclBuilderContainer
 210 {
 211     class   ImplData;
 212 private:
 213     VclPtr<FloatingWindow> mpFloatWin;
 214     VclPtr<vcl::Window>    mpOldBorderWin;
 215     std::unique_ptr<ImplData> mpImplData;
 216     Point           maFloatPos;
 217     Point           maDockPos;
 218     Point           maMouseOff;
 219     Size            maRollUpOutSize;
 220     Size            maMinOutSize;
 221     long            mnTrackX;
 222     long            mnTrackY;
 223     long            mnTrackWidth;
 224     long            mnTrackHeight;
 225     sal_Int32       mnDockLeft;
 226     sal_Int32       mnDockTop;
 227     sal_Int32       mnDockRight;
 228     sal_Int32       mnDockBottom;
 229     WinBits         mnFloatBits;
 230     Idle            maLayoutIdle;
 231     bool            mbDockCanceled:1,
 232                     mbDockable:1,
 233                     mbDocking:1,
 234                     mbDragFull:1,
 235                     mbLastFloatMode:1,
 236                     mbStartFloat:1,
 237                     mbRollUp:1,
 238                     mbDockBtn:1,
 239                     mbHideBtn:1,
 240                     mbIsCalculatingInitialLayoutSize:1;
 241
 242 protected:
 243     bool mbIsDeferredInit;
 244     VclPtr<vcl::Window>  mpDialogParent;
 245 private:
 246
 247     SAL_DLLPRIVATE void    ImplInitDockingWindowData();
 248     SAL_DLLPRIVATE void    setPosSizeOnContainee();
 249     DECL_DLLPRIVATE_LINK( ImplHandleLayoutTimerHdl, Timer*, void );
 250
 251                            DockingWindow (const DockingWindow &) = delete;
 252                            DockingWindow & operator= (const DockingWindow &) = delete;
 253
 254 protected:
 255     SAL_DLLPRIVATE void    SetIdleDebugName( const sal_Char *pDebugName );
 256
 257     using Window::ImplInit;
 258     SAL_DLLPRIVATE void    ImplInit( vcl::Window* pParent, WinBits nStyle );
 259     SAL_DLLPRIVATE void    ImplInitSettings();
 260
 261     SAL_DLLPRIVATE void DoInitialLayout();
 262
 263     void loadUI(vcl::Window* pParent, const OString& rID, const OUString& rUIXMLDescription,
 264                 const css::uno::Reference<css::frame::XFrame> &rFrame);
 265
 266 public:
 267     bool            isLayoutEnabled() const;
 268     void            setOptimalLayoutSize();
 269
 270     //FIXME: is it okay to make this public?
 271     void    ImplStartDocking( const Point& rPos );
 272     SAL_DLLPRIVATE bool    isDeferredInit() const { return mbIsDeferredInit; }
 273     virtual        void    doDeferredInit(WinBits nBits);
 274 protected:
 275                     DockingWindow( WindowType nType );
 276
 277 public:
 278     DockingWindow(vcl::Window* pParent, WinBits nStyle);
 279     DockingWindow(vcl::Window* pParent, const OString& rID, const OUString& rUIXMLDescription,
 280         const css::uno::Reference<css::frame::XFrame> &rFrame = css::uno::Reference<css::frame::XFrame>());
 281     virtual ~DockingWindow() override;
 282     virtual void dispose() override;
 283
 284     virtual void    StartDocking();
 285     virtual bool    Docking( const Point& rPos, tools::Rectangle& rRect );
 286     virtual void    EndDocking( const tools::Rectangle& rRect, bool bFloatMode );
 287     virtual bool    PrepareToggleFloatingMode();
 288     virtual void    ToggleFloatingMode();
 289
 290     virtual void    Resizing( Size& rSize );
 291     virtual bool    Close();
 292     virtual void    Tracking( const TrackingEvent& rTEvt ) override;
 293     virtual bool    EventNotify( NotifyEvent& rNEvt ) override;
 294     virtual void    StateChanged( StateChangedType nType ) override;
 295     virtual void    DataChanged( const DataChangedEvent& rDCEvt ) override;
 296
 297     void            RollDown();
 298     bool            IsRollUp() const;
 299
 300     void            SetMinOutputSizePixel( const Size& rSize );
 301     const Size&     GetMinOutputSizePixel() const;
 302
 303     void            SetMaxOutputSizePixel( const Size& rSize );
 304
 305     bool            IsDocking() const { return mbDocking; }
 306     bool            IsDockable() const { return mbDockable; }
 307     bool            IsDockingCanceled() const { return mbDockCanceled; }
 308
 309     void            SetFloatingMode( bool bFloatMode );
 310     bool            IsFloatingMode() const;
 311     FloatingWindow* GetFloatingWindow() const { return mpFloatWin; }
 312
 313     void            SetFloatingPos( const Point& rNewPos );
 314     Point           GetFloatingPos() const;
 315
 316     void            SetFloatStyle( WinBits nWinStyle );
 317     WinBits         GetFloatStyle() const;
 318
 319     virtual void    setPosSizePixel( long nX, long nY,
 320                                      long nWidth, long nHeight,
 321                                      PosSizeFlags nFlags = PosSizeFlags::All ) override;
 322     using Window::SetPosSizePixel;
 323     Point           GetPosPixel() const override;
 324     Size            GetSizePixel() const override;
 325     void            SetOutputSizePixel( const Size& rNewSize ) override;
 326     Size            GetOutputSizePixel() const;
 327
 328     virtual void SetText( const OUString& rStr ) override;
 329     virtual OUString GetText() const override;
 330     virtual Size GetOptimalSize() const override;
 331     virtual void queue_resize(StateChangedType eReason = StateChangedType::Layout) override;
 332 };
 333
 334
 335 inline void DockingWindow::RollDown()
 336 {
 337     if ( mpFloatWin )
 338         mpFloatWin->RollDown();
 339     mbRollUp = false;
 340 }
 341
 342 inline bool DockingWindow::IsRollUp() const
 343 {
 344     if ( mpFloatWin )
 345         return mpFloatWin->IsRollUp();
 346     return mbRollUp;
 347 }
 348
 349
 350 inline void DockingWindow::SetMinOutputSizePixel( const Size& rSize )
 351 {
 352     if ( mpFloatWin )
 353         mpFloatWin->SetMinOutputSizePixel( rSize );
 354     maMinOutSize = rSize;
 355 }
 356
 357 inline const Size& DockingWindow::GetMinOutputSizePixel() const
 358 {
 359     if ( mpFloatWin )
 360         return mpFloatWin->GetMinOutputSizePixel();
 361     return maMinOutSize;
 362 }
 363
 364 inline void DockingWindow::SetFloatingPos( const Point& rNewPos )
 365 {
 366     if ( mpFloatWin )
 367         mpFloatWin->SetPosPixel( rNewPos );
 368     else
 369         maFloatPos = rNewPos;
 370 }
 371
 372 inline void DockingWindow::SetIdleDebugName( const sal_Char *pDebugName )
 373 {
 374     maLayoutIdle.SetDebugName( pDebugName );
 375 }
 376
 377
 378 #endif // INCLUDED_VCL_DOCKWIN_HXX
 379
 380 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */