LibreOffice Module vcl (master)  1
floatwin.cxx
Go to the documentation of this file.
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 #include <svdata.hxx>
21 #include <brdwin.hxx>
22 #include <window.h>
23 #include <salframe.hxx>
24 #include <helpwin.hxx>
25 
26 #include <comphelper/lok.hxx>
27 #include <sal/log.hxx>
28 #include <vcl/layout.hxx>
29 #include <vcl/svapp.hxx>
30 #include <vcl/wrkwin.hxx>
31 #include <vcl/event.hxx>
32 #include <vcl/toolbox.hxx>
33 #include <vcl/floatwin.hxx>
34 #include <vcl/settings.hxx>
36 
38 {
39 public:
40  ImplData();
41 
43  tools::Rectangle maItemEdgeClipRect; // used to clip the common edge between a toolbar item and the border of this window
44  Point maPos; // position of the floating window wrt. parent
46 };
47 
49 {
50  mpBox = nullptr;
51 }
52 
54 {
55  return mpImplData->maItemEdgeClipRect;
56 }
57 
59 {
60  mpImplData.reset(new ImplData);
61 
62  mpWindowImpl->mbFloatWin = true;
63  mbInCleanUp = false;
64  mbGrabFocus = false;
65 
66  SAL_WARN_IF(!pParent, "vcl", "FloatWindow::FloatingWindow(): - pParent == NULL!");
67 
68  if (!pParent)
69  pParent = ImplGetSVData()->maFrameData.mpAppWin;
70 
71  SAL_WARN_IF(!pParent, "vcl", "FloatWindow::FloatingWindow(): - pParent == NULL and no AppWindow exists");
72 
73  // no Border, then we don't need a border window
74  if (!nStyle)
75  {
76  mpWindowImpl->mbOverlapWin = true;
77  nStyle |= WB_DIALOGCONTROL;
78  ImplInit(pParent, nStyle, nullptr);
79  }
80  else
81  {
82  if (!(nStyle & WB_NODIALOGCONTROL))
83  nStyle |= WB_DIALOGCONTROL;
84 
86  && !(nStyle & WB_OWNERDRAWDECORATION))
87  {
88  WinBits nFloatWinStyle = nStyle;
89  // #99154# floaters are not closeable by default anymore, eg fullscreen floater
90  // nFloatWinStyle |= WB_CLOSEABLE;
91  mpWindowImpl->mbFrame = true;
92  mpWindowImpl->mbOverlapWin = true;
93  ImplInit(pParent, nFloatWinStyle & ~WB_BORDER, nullptr);
94  }
95  else
96  {
97  VclPtr<ImplBorderWindow> pBorderWin;
99 
100  if (nStyle & WB_OWNERDRAWDECORATION)
101  nBorderStyle |= BorderWindowStyle::Frame;
102  else
103  nBorderStyle |= BorderWindowStyle::Overlap;
104 
105  if ((nStyle & WB_SYSTEMWINDOW) && !(nStyle & (WB_MOVEABLE | WB_SIZEABLE)))
106  {
107  nBorderStyle |= BorderWindowStyle::Frame;
108  nStyle |= WB_CLOSEABLE; // make undecorated floaters closeable
109  }
110  pBorderWin = VclPtr<ImplBorderWindow>::Create(pParent, nStyle, nBorderStyle);
111  ImplInit(pBorderWin, nStyle & ~WB_BORDER, nullptr);
112  pBorderWin->mpWindowImpl->mpClientWindow = this;
113  pBorderWin->GetBorder(mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder,
114  mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder);
115  pBorderWin->SetDisplayActive(true);
116  mpWindowImpl->mpBorderWindow = pBorderWin;
117  mpWindowImpl->mpRealParent = pParent;
118  }
119  }
121 
122  mpNextFloat = nullptr;
123  mpFirstPopupModeWin = nullptr;
124  mnPostId = nullptr;
128  mbInPopupMode = false;
129  mbPopupMode = false;
130  mbPopupModeCanceled = false;
131  mbPopupModeTearOff = false;
132  mbMouseDown = false;
133 
135 }
136 
138 {
139  const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
140 
141  Color aColor;
142  if (IsControlBackground())
143  aColor = GetControlBackground();
144  else if (Window::GetStyle() & WB_3DLOOK)
145  aColor = rStyleSettings.GetFaceColor();
146  else
147  aColor = rStyleSettings.GetWindowColor();
148  SetBackground(aColor);
149 }
150 
153 {
154  ImplInitFloating(pParent, nStyle);
155 }
156 
157 FloatingWindow::FloatingWindow(vcl::Window* pParent, const OString& rID, const OUString& rUIXMLDescription, const css::uno::Reference<css::frame::XFrame> &rFrame)
159  , mpNextFloat(nullptr)
160  , mpFirstPopupModeWin(nullptr)
161  , mnPostId(nullptr)
162  , mnPopupModeFlags(FloatWinPopupFlags::NONE)
163  , mnTitle(FloatWinTitleType::Unknown)
164  , mnOldTitle(FloatWinTitleType::Unknown)
165  , mbInPopupMode(false)
166  , mbPopupMode(false)
167  , mbPopupModeCanceled(false)
168  , mbPopupModeTearOff(false)
169  , mbMouseDown(false)
170  , mbGrabFocus(false)
171  , mbInCleanUp(false)
172 {
173  loadUI(pParent, rID, rUIXMLDescription, rFrame);
174 }
175 
176 //Find the real parent stashed in mpDialogParent.
178 {
179  vcl::Window *pParent = mpDialogParent;
180  mpDialogParent = nullptr;
181  ImplInitFloating(pParent, nBits);
182  mbIsDeferredInit = false;
183 }
184 
186 {
187  const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
188 
189  Color aColor;
190  if (Window::GetStyle() & WB_3DLOOK)
191  aColor = rStyleSettings.GetFaceColor();
192  else
193  aColor = rStyleSettings.GetWindowColor();
194 
195  ApplyControlBackground(rRenderContext, aColor);
196 }
197 
199 {
200  disposeOnce();
201  assert (!mnPostId);
202 }
203 
205 {
207 
208  if (mpImplData)
209  {
210  if( mbPopupModeCanceled )
211  // indicates that ESC key was pressed
212  // will be handled in Window::ImplGrabFocus()
214 
215  if ( IsInPopupMode() )
217 
218  if ( mnPostId )
220  mnPostId = nullptr;
221  }
222 
223  mpImplData.reset();
224 
225  mpNextFloat.clear();
229 }
230 
231 Point FloatingWindow::CalcFloatingPosition( vcl::Window* pWindow, const tools::Rectangle& rRect, FloatWinPopupFlags nFlags, sal_uInt16& rArrangeIndex )
232 {
233  return ImplCalcPos( pWindow, rRect, nFlags, rArrangeIndex );
234 }
235 
237  const tools::Rectangle& rRect, FloatWinPopupFlags nFlags,
238  sal_uInt16& rArrangeIndex, Point* pLOKTwipsPos)
239 {
240  // get window position
241  Point aPos;
242  Size aSize = ::isLayoutEnabled(pWindow) ? pWindow->get_preferred_size() : pWindow->GetSizePixel();
243  tools::Rectangle aScreenRect = pWindow->ImplGetFrameWindow()->GetDesktopRectPixel();
244  FloatingWindow *pFloatingWindow = dynamic_cast<FloatingWindow*>( pWindow );
245 
246  // convert...
247  vcl::Window* pW = pWindow;
248  if ( pW->mpWindowImpl->mpRealParent )
249  pW = pW->mpWindowImpl->mpRealParent;
250 
251  tools::Rectangle normRect( rRect ); // rRect is already relative to top-level window
252  normRect.SetPos( pW->ScreenToOutputPixel( normRect.TopLeft() ) );
253 
254  bool bRTL = AllSettings::GetLayoutRTL();
255 
256  tools::Rectangle devRect( pW->OutputToAbsoluteScreenPixel( normRect.TopLeft() ),
257  pW->OutputToAbsoluteScreenPixel( normRect.BottomRight() ) );
258 
259  tools::Rectangle devRectRTL( devRect );
260  if( bRTL )
261  // create a rect that can be compared to desktop coordinates
262  devRectRTL = pW->ImplOutputToUnmirroredAbsoluteScreenPixel( normRect );
265  Application::GetBestScreen( bRTL ? devRectRTL : devRect ) );
266 
267  FloatWinPopupFlags nArrangeAry[5];
268  sal_uInt16 nArrangeAttempts = 5;
269  Point e1,e2; // the common edge between the item rect and the floating window
270 
271  if ( nFlags & FloatWinPopupFlags::Left )
272  {
273  nArrangeAry[0] = FloatWinPopupFlags::Left;
274  nArrangeAry[1] = FloatWinPopupFlags::Right;
275  nArrangeAry[2] = FloatWinPopupFlags::Up;
276  nArrangeAry[3] = FloatWinPopupFlags::Down;
277  nArrangeAry[4] = FloatWinPopupFlags::Left;
278  }
279  else if ( nFlags & FloatWinPopupFlags::Right )
280  {
281  nArrangeAry[0] = FloatWinPopupFlags::Right;
282  nArrangeAry[1] = FloatWinPopupFlags::Left;
283  nArrangeAry[2] = FloatWinPopupFlags::Up;
284  nArrangeAry[3] = FloatWinPopupFlags::Down;
285  nArrangeAry[4] = FloatWinPopupFlags::Right;
286  }
287  else if ( nFlags & FloatWinPopupFlags::Up )
288  {
289  nArrangeAry[0] = FloatWinPopupFlags::Up;
290  nArrangeAry[1] = FloatWinPopupFlags::Down;
292  {
293  nArrangeAry[2] = FloatWinPopupFlags::Up;
294  nArrangeAttempts = 3;
295  }
296  else
297  {
298  nArrangeAry[2] = FloatWinPopupFlags::Right;
299  nArrangeAry[3] = FloatWinPopupFlags::Left;
300  nArrangeAry[4] = FloatWinPopupFlags::Up;
301  }
302  }
303  else
304  {
305  nArrangeAry[0] = FloatWinPopupFlags::Down;
306  nArrangeAry[1] = FloatWinPopupFlags::Up;
308  {
309  nArrangeAry[2] = FloatWinPopupFlags::Down;
310  nArrangeAttempts = 3;
311  }
312  else
313  {
314  nArrangeAry[2] = FloatWinPopupFlags::Right;
315  nArrangeAry[3] = FloatWinPopupFlags::Left;
316  nArrangeAry[4] = FloatWinPopupFlags::Down;
317  }
318  }
319 
320  sal_uInt16 nArrangeIndex = 0;
321  const bool bLOKActive = comphelper::LibreOfficeKit::isActive();
322 
323  for ( ; nArrangeIndex < nArrangeAttempts; nArrangeIndex++ )
324  {
325  bool bBreak = true;
326  switch ( nArrangeAry[nArrangeIndex] )
327  {
328 
329  case FloatWinPopupFlags::Left:
330  aPos.setX( devRect.Left()-aSize.Width()+1 );
331  aPos.setY( devRect.Top() );
332  aPos.AdjustY( -(pWindow->mpWindowImpl->mnTopBorder) );
333  if( bRTL )
334  {
335  if( (devRectRTL.Right()+aSize.Width()) > aScreenRect.Right() )
336  bBreak = false;
337  }
338  else
339  {
340  if ( aPos.X() < aScreenRect.Left() )
341  bBreak = false;
342  }
343  if (bBreak || bLOKActive)
344  {
345  e1 = devRect.TopLeft();
346  e2 = devRect.BottomLeft();
347  // set non-zero width
348  e2.AdjustX( 1 );
349  // don't clip corners
350  e1.AdjustY( 1 );
351  e2.AdjustY( -1 );
352  }
353  break;
354  case FloatWinPopupFlags::Right:
355  aPos = devRect.TopRight();
356  aPos.AdjustY( -(pWindow->mpWindowImpl->mnTopBorder) );
357  if( bRTL )
358  {
359  if( (devRectRTL.Left() - aSize.Width()) < aScreenRect.Left() )
360  bBreak = false;
361  }
362  else
363  {
364  if ( aPos.X()+aSize.Width() > aScreenRect.Right() )
365  bBreak = false;
366  }
367  if (bBreak || bLOKActive)
368  {
369  e1 = devRect.TopRight();
370  e2 = devRect.BottomRight();
371  // set non-zero width
372  e2.AdjustX( 1 );
373  // don't clip corners
374  e1.AdjustY( 1 );
375  e2.AdjustY( -1 );
376  }
377  break;
378  case FloatWinPopupFlags::Up:
379  aPos.setX( devRect.Left() );
380  aPos.setY( devRect.Top()-aSize.Height()+1 );
381  if ( aPos.Y() < aScreenRect.Top() )
382  bBreak = false;
383  if (bBreak || bLOKActive)
384  {
385  e1 = devRect.TopLeft();
386  e2 = devRect.TopRight();
387  // set non-zero height
388  e2.AdjustY( 1 );
389  // don't clip corners
390  e1.AdjustX( 1 );
391  e2.AdjustX( -1 );
392  }
393  break;
395  aPos = devRect.BottomLeft();
396  if ( aPos.Y()+aSize.Height() > aScreenRect.Bottom() )
397  bBreak = false;
398  if (bBreak || bLOKActive)
399  {
400  e1 = devRect.BottomLeft();
401  e2 = devRect.BottomRight();
402  // set non-zero height
403  e2.AdjustY( 1 );
404  // don't clip corners
405  e1.AdjustX( 1 );
406  e2.AdjustX( -1 );
407  }
408  break;
409  default: break;
410  }
411 
412  // no further adjustment for LibreOfficeKit
413  if (bLOKActive)
414  break;
415 
416  // adjust if necessary
417  if (bBreak)
418  {
419  if ( (nArrangeAry[nArrangeIndex] == FloatWinPopupFlags::Left) ||
420  (nArrangeAry[nArrangeIndex] == FloatWinPopupFlags::Right) )
421  {
422  if ( aPos.Y()+aSize.Height() > aScreenRect.Bottom() )
423  {
424  aPos.setY( devRect.Bottom()-aSize.Height()+1 );
425  if ( aPos.Y() < aScreenRect.Top() )
426  aPos.setY( aScreenRect.Top() );
427  }
428  }
429  else
430  {
431  if( bRTL )
432  {
433  if( devRectRTL.Right()-aSize.Width()+1 < aScreenRect.Left() )
434  aPos.AdjustX( -(aScreenRect.Left() - devRectRTL.Right() + aSize.Width() - 1) );
435  }
436  else if ( aPos.X()+aSize.Width() > aScreenRect.Right() )
437  {
438  aPos.setX( devRect.Right()-aSize.Width()+1 );
439  if ( aPos.X() < aScreenRect.Left() )
440  aPos.setX( aScreenRect.Left() );
441  }
442  }
443  }
444 
445  if ( bBreak )
446  break;
447  }
448  if (nArrangeIndex >= nArrangeAttempts)
449  nArrangeIndex = nArrangeAttempts - 1;
450 
451  rArrangeIndex = nArrangeIndex;
452 
453  aPos = pW->AbsoluteScreenToOutputPixel( aPos );
454 
455  // store a cliprect that can be used to clip the common edge of the itemrect and the floating window
456  if( pFloatingWindow && pFloatingWindow->mpImplData->mpBox )
457  {
458  pFloatingWindow->mpImplData->maItemEdgeClipRect =
459  tools::Rectangle( e1, e2 );
460  }
461 
462  if (bLOKActive && pLOKTwipsPos)
463  {
464  if (pW->IsMapModeEnabled() || pW->GetMapMode().GetMapUnit() == MapUnit::MapPixel)
465  {
466  // if we use pW->LogicToLogic(aPos, pW->GetMapMode(), MapMode(MapUnit::MapTwip)),
467  // for pixel conversions when map mode is not enabled, we get
468  // a 20 twips per pixel conversion since LogicToLogic uses
469  // a fixed 72 dpi value, instead of a correctly computed output
470  // device dpi or at least the most commonly used 96 dpi value;
471  // and anyway the following is what we already do in
472  // ScGridWindow::LogicInvalidate when map mode is not enabled.
473 
474  *pLOKTwipsPos = pW->PixelToLogic(aPos, MapMode(MapUnit::MapTwip));
475  }
476  else
477  {
478  *pLOKTwipsPos = OutputDevice::LogicToLogic(aPos, pW->GetMapMode(), MapMode(MapUnit::MapTwip));
479  }
480  }
481 
482  // caller expects coordinates relative to top-level win
483  return pW->OutputToScreenPixel( aPos );
484 }
485 
487 {
488  Point aAbsolute( rPos );
489 
490  const OutputDevice *pWindowOutDev = pReference->GetOutDev();
491 
492  // compare coordinates in absolute screen coordinates
493  if( pReference->HasMirroredGraphics() )
494  {
495  if(!pReference->IsRTLEnabled() )
496  pWindowOutDev->ReMirror( aAbsolute );
497 
498  tools::Rectangle aRect( pReference->ScreenToOutputPixel(aAbsolute), Size(1,1) ) ;
499  aRect = pReference->ImplOutputToUnmirroredAbsoluteScreenPixel( aRect );
500  aAbsolute = aRect.TopLeft();
501  }
502  else
503  aAbsolute = pReference->OutputToAbsoluteScreenPixel(
504  pReference->ScreenToOutputPixel(rPos) );
505 
506  return aAbsolute;
507 }
508 
510 {
511  tools::Rectangle aFloatRect = rRect;
512 
513  const OutputDevice *pParentWinOutDev = pReference->GetOutDev();
514 
515  // compare coordinates in absolute screen coordinates
516  // Keep in sync with FloatingWindow::ImplFloatHitTest, e.g. fdo#33509
517  if( pReference->HasMirroredGraphics() )
518  {
519  if(!pReference->IsRTLEnabled() )
520  pParentWinOutDev->ReMirror(aFloatRect);
521 
522  aFloatRect.SetPos(pReference->ScreenToOutputPixel(aFloatRect.TopLeft()));
523  aFloatRect = pReference->ImplOutputToUnmirroredAbsoluteScreenPixel(aFloatRect);
524  }
525  else
526  aFloatRect.SetPos(pReference->OutputToAbsoluteScreenPixel(pReference->ScreenToOutputPixel(rRect.TopLeft())));
527 
528  return aFloatRect;
529 }
530 
532 {
533  tools::Rectangle aFloatRect = rRect;
534 
535  const OutputDevice *pParentWinOutDev = pReference->GetOutDev();
536 
537  // compare coordinates in absolute screen coordinates
538  // Keep in sync with FloatingWindow::ImplFloatHitTest, e.g. fdo#33509
539  if( pReference->HasMirroredGraphics() )
540  {
541  aFloatRect = pReference->ImplUnmirroredAbsoluteScreenToOutputPixel(aFloatRect);
542  aFloatRect.SetPos(pReference->OutputToScreenPixel(aFloatRect.TopLeft()));
543 
544  if(!pReference->IsRTLEnabled() )
545  pParentWinOutDev->ReMirror(aFloatRect);
546  }
547  else
548  aFloatRect.SetPos(pReference->OutputToScreenPixel(pReference->AbsoluteScreenToOutputPixel(rRect.TopLeft())));
549 
550  return aFloatRect;
551 }
552 
553 FloatingWindow* FloatingWindow::ImplFloatHitTest( vcl::Window* pReference, const Point& rPos, bool& rbHitTestInsideRect )
554 {
555  FloatingWindow* pWin = this;
556  rbHitTestInsideRect = false;
557 
558  Point aAbsolute(FloatingWindow::ImplConvertToAbsPos(pReference, rPos));
559 
560  do
561  {
562  // compute the floating window's size in absolute screen coordinates
563 
564  // use the border window to have the exact position
565  vcl::Window *pBorderWin = pWin->GetWindow( GetWindowType::Border );
566  if (!pBorderWin)
567  break;
568 
569  // the top-left corner in output coordinates ie (0,0)
571  if ( devRect.IsInside( aAbsolute ) )
572  {
573  // inside the window
574  return pWin;
575  }
576 
577  // test, if mouse is in rectangle, (this is typically the rect of the active
578  // toolbox item or similar)
579  // note: maFloatRect is set in FloatingWindow::StartPopupMode() and
580  // is already in absolute device coordinates
581  if ( pWin->maFloatRect.IsInside( aAbsolute ) )
582  {
583  rbHitTestInsideRect = true;
584  return pWin;
585  }
586 
587  pWin = pWin->mpNextFloat;
588  }
589  while ( pWin );
590 
591  return nullptr;
592 }
593 
595 {
596  FloatingWindow* pWin = this;
597  FloatingWindow* pLastFoundWin = pWin;
598 
599  do
600  {
602  pLastFoundWin = pWin;
603 
604  pWin = pWin->mpNextFloat;
605  }
606  while ( pWin );
607 
608  return pLastFoundWin;
609 }
610 
612 {
613  FloatingWindow* pWin = this;
614 
615  do
616  {
617  if ( pWin->mpFirstPopupModeWin == pWindow )
618  return true;
619 
620  pWin = pWin->mpNextFloat;
621  }
622  while ( pWin );
623 
624  return false;
625 }
626 
627 IMPL_LINK_NOARG(FloatingWindow, ImplEndPopupModeHdl, void*, void)
628 {
629  VclPtr<FloatingWindow> pThis(this);
630  mnPostId = nullptr;
631  mnPopupModeFlags = FloatWinPopupFlags::NONE;
632  mbPopupMode = false;
633  PopupModeEnd();
634 }
635 
637 {
638  // call Base Class first for tab control
639  bool bRet = SystemWindow::EventNotify( rNEvt );
640  if ( !bRet )
641  {
642  if ( rNEvt.GetType() == MouseNotifyEvent::KEYINPUT )
643  {
644  const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
645  vcl::KeyCode aKeyCode = pKEvt->GetKeyCode();
646  sal_uInt16 nKeyCode = aKeyCode.GetCode();
647 
648  if ( (nKeyCode == KEY_ESCAPE) && (GetStyle() & WB_CLOSEABLE) )
649  {
650  Close();
651  return true;
652  }
653  }
654  }
655 
656  return bRet;
657 }
658 
660 {
662  {
663  std::vector<vcl::LOKPayloadItem> aPayload;
664  const tools::Rectangle aRect(Point(0,0), Size(GetSizePixel().Width()+1, GetSizePixel().Height()+1));
665  aPayload.push_back(std::make_pair(OString("rectangle"), aRect.toString()));
666  const vcl::ILibreOfficeKitNotifier* pNotifier = pParent->GetLOKNotifier();
667  pNotifier->notifyWindow(GetLOKWindowId(), "invalidate", aPayload);
668  }
669 }
670 
672 {
673  if (nType == StateChangedType::InitShow)
674  {
675  DoInitialLayout();
676  }
677 
679 
681  if (pParent)
682  {
683  if (nType == StateChangedType::InitShow)
684  {
685  std::vector<vcl::LOKPayloadItem> aItems;
686  if (pParent == this)
687  {
688  // we are a toplevel window, let's so far pretend to be a
689  // dialog - but maybe we'll need a separate type for this
690  // later
691  aItems.emplace_back("type", "dialog");
692  aItems.emplace_back("position", mpImplData->maLOKTwipsPos.toString()); // twips
693  }
694  else
695  {
696  SetLOKNotifier(pParent->GetLOKNotifier());
697  if (dynamic_cast<HelpTextWindow*>(this))
698  aItems.emplace_back("type", "tooltip");
699  else
700  aItems.emplace_back("type", "child");
701 
702  aItems.emplace_back("parentId", OString::number(pParent->GetLOKWindowId()));
703  if (mbInPopupMode)
704  aItems.emplace_back("position", mpImplData->maPos.toString()); // pixels
705  else // mpImplData->maPos is not set
706  aItems.emplace_back("position", GetPosPixel().toString());
707 
708  }
709  aItems.emplace_back("size", GetSizePixel().toString());
710  GetLOKNotifier()->notifyWindow(GetLOKWindowId(), "created", aItems);
711  }
712  else if (!IsVisible() && nType == StateChangedType::Visible)
713  {
714  if (const vcl::ILibreOfficeKitNotifier* pNotifier = GetLOKNotifier())
715  {
716  pNotifier->notifyWindow(GetLOKWindowId(), "close");
718  }
719  }
720  }
721 
723  {
725  Invalidate();
726  }
727 }
728 
730 {
731  SystemWindow::DataChanged( rDCEvt );
732 
733  if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
734  (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
735  {
737  Invalidate();
738  }
739 }
740 
742 {
743  // PopupMode is finished
744  mbInPopupMode = false;
745 
746  // call Handler asynchronously.
747  if ( mpImplData && !mnPostId )
748  mnPostId = Application::PostUserEvent(LINK(this, FloatingWindow, ImplEndPopupModeHdl));
749 }
750 
752 {
753  maPopupModeEndHdl.Call( this );
754 }
755 
757 {
758  if ( (mnTitle == nTitle) || !mpWindowImpl->mpBorderWindow )
759  return;
760 
761  mnTitle = nTitle;
762  Size aOutSize = GetOutputSizePixel();
763  BorderWindowTitleType nTitleStyle;
764  if ( nTitle == FloatWinTitleType::Normal )
765  nTitleStyle = BorderWindowTitleType::Small;
766  else if ( nTitle == FloatWinTitleType::TearOff )
767  nTitleStyle = BorderWindowTitleType::Tearoff;
768  else if ( nTitle == FloatWinTitleType::Popup )
769  nTitleStyle = BorderWindowTitleType::Popup;
770  else // nTitle == FloatWinTitleType::NONE
771  nTitleStyle = BorderWindowTitleType::NONE;
772  static_cast<ImplBorderWindow*>(mpWindowImpl->mpBorderWindow.get())->SetTitleType( nTitleStyle, aOutSize );
773  static_cast<ImplBorderWindow*>(mpWindowImpl->mpBorderWindow.get())->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder );
774 }
775 
777 {
778  // remove title
780  if ( ( mpWindowImpl->mnStyle & WB_POPUP ) && !GetText().isEmpty() )
782  else if ( nFlags & FloatWinPopupFlags::AllowTearOff )
784  else
786 
787  // avoid close on focus change for decorated floating windows only
788  if( mpWindowImpl->mbFrame && (GetStyle() & WB_MOVEABLE) )
790 
791  // compute window position according to flags and arrangement
792  sal_uInt16 nArrangeIndex;
793  DoInitialLayout();
794  mpImplData->maPos = ImplCalcPos(this, rRect, nFlags, nArrangeIndex, &mpImplData->maLOKTwipsPos);
795  SetPosPixel( mpImplData->maPos );
796  ImplGetFrame()->PositionByToolkit(rRect, nFlags);
797 
798  // set data and display window
799  // convert maFloatRect to absolute device coordinates
800  // so they can be compared across different frames
801  // !!! rRect is expected to be in screen coordinates of the parent frame window !!!
803 
804  maFloatRect.AdjustLeft( -2 );
805  maFloatRect.AdjustTop( -2 );
808  mnPopupModeFlags = nFlags;
809  mbInPopupMode = true;
810  mbPopupMode = true;
811  mbPopupModeCanceled = false;
812  mbPopupModeTearOff = false;
813  mbMouseDown = false;
814 
815  // add FloatingWindow to list of windows that are in popup mode
816  ImplSVData* pSVData = ImplGetSVData();
817  mpNextFloat = pSVData->mpWinData->mpFirstFloat;
818  pSVData->mpWinData->mpFirstFloat = this;
819  bool bGrabFocus(nFlags & FloatWinPopupFlags::GrabFocus);
820  if (bGrabFocus)
821  {
822  // force key input even without focus (useful for menus)
823  mbGrabFocus = true;
824  mxPrevFocusWin = Window::SaveFocus();
825  mpWindowImpl->mpFrameData->mbHasFocus = true;
826  }
827  Show( true, ShowFlags::NoActivate );
828  if (bGrabFocus)
829  GrabFocus();
830 }
831 
833 {
834  mpImplData->mpBox = pBox;
835 
836  // get selected button
837  sal_uInt16 nItemId = pBox->GetDownItemId();
838 
839  if ( nItemId )
840  pBox->ImplFloatControl( true, this );
841 
842  // retrieve some data from the ToolBox
843  tools::Rectangle aRect = nItemId ? pBox->GetItemRect( nItemId ) : pBox->GetOverflowRect();
844 
845  // convert to parent's screen coordinates
847  aRect.SetPos( mpImplData->maPos );
848 
849  nFlags |=
852 
853  // set Flags for positioning
856  {
857  if ( pBox->IsHorizontal() )
858  nFlags |= FloatWinPopupFlags::Down;
859  else
860  nFlags |= FloatWinPopupFlags::Right;
861  }
862 
863  // start FloatingMode
864  StartPopupMode( aRect, nFlags );
865 }
866 
868 {
869  if ( !mbInPopupMode )
870  return;
871 
872  ImplSVData* pSVData = ImplGetSVData();
873 
874  mbInCleanUp = true; // prevent killing this window due to focus change while working with it
875 
877  {
878  // stop the PopupMode also for all PopupMode windows created after us
879  std::vector<VclPtr<FloatingWindow>> aCancelFloats;
880  // stop the PopupMode also for all following PopupMode windows
881  for (auto pFloat = pSVData->mpWinData->mpFirstFloat;
882  pFloat != nullptr && pFloat != this;
883  pFloat = pFloat->mpNextFloat)
884  aCancelFloats.push_back(pFloat);
885  for (auto & it : aCancelFloats)
886  it->EndPopupMode(FloatWinPopupEndFlags::Cancel | FloatWinPopupEndFlags::NoCloseChildren);
887  }
888 
889  // delete window from the list
890  pSVData->mpWinData->mpFirstFloat = mpNextFloat;
891  mpNextFloat = nullptr;
892 
893  FloatWinPopupFlags nPopupModeFlags = mnPopupModeFlags;
895  nPopupModeFlags & FloatWinPopupFlags::AllowTearOff;
896 
897  // hide window again if it was not deleted
898  if (!mbPopupModeTearOff)
899  Show( false, ShowFlags::NoFocusChange );
900 
901  if (HasChildPathFocus() && xFocusId != nullptr)
902  {
903  // restore focus to previous focus window if we still have the focus
904  Window::EndSaveFocus(xFocusId);
905  }
906  else if ( pSVData->mpWinData->mpFocusWin && pSVData->mpWinData->mpFirstFloat &&
908  {
909  // maybe pass focus on to a suitable FloatingWindow
910  pSVData->mpWinData->mpFirstFloat->GrabFocus();
911  }
912 
914 
915  // redo title
917 
918  // set ToolBox again to normal
919  if (mpImplData && mpImplData->mpBox)
920  {
921  mpImplData->mpBox->ImplFloatControl( false, this );
922  // if the parent ToolBox is in popup mode, it should be closed too.
923  if ( GetDockingManager()->IsInPopupMode( mpImplData->mpBox ) )
925 
926  mpImplData->mpBox = nullptr;
927  }
928 
929  // call PopupModeEnd-Handler depending on parameter
930  if ( !(nFlags & FloatWinPopupEndFlags::DontCallHdl) )
932 
933  // close all other windows depending on parameter
934  if ( nFlags & FloatWinPopupEndFlags::CloseAll )
935  {
936  if ( !(nPopupModeFlags & FloatWinPopupFlags::NewLevel) )
937  {
938  if (pSVData->mpWinData->mpFirstFloat)
939  {
940  FloatingWindow* pLastLevelFloat = pSVData->mpWinData->mpFirstFloat->ImplFindLastLevelFloat();
941  pLastLevelFloat->EndPopupMode( FloatWinPopupEndFlags::Cancel | FloatWinPopupEndFlags::CloseAll );
942  }
943  }
944  }
945 
946  mbInCleanUp = false;
947 }
948 
950 {
952 }
953 
955 {
956  // !!! up-to-now only 1 window and not yet a list
957  mpFirstPopupModeWin = pWindow;
958 }
960 {
961  auto pWin = ImplGetParent();
962  if (pWin)
963  {
964  // Simulate Move, so the relative position of the floating window will be recalculated
965  pWin->ImplCallMove();
966  return true;
967  }
968 
969  return false;
970 }
971 
972 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
virtual Point GetPosPixel() const
Definition: window.cxx:2782
Point TopLeft() const
void SetPos(const Point &rPoint)
FloatWinTitleType mnOldTitle
Definition: floatwin.hxx:65
bool IsControlBackground() const
Definition: window2.cxx:1085
bool IsInPopupMode() const
Definition: floatwin.hxx:127
vcl::LOKWindowId GetLOKWindowId() const
Definition: window.cxx:3235
void StartPopupMode(const tools::Rectangle &rRect, FloatWinPopupFlags nFlags)
Definition: floatwin.cxx:776
bool mbPopupMode
Definition: floatwin.hxx:67
WinBits const WB_SYSTEMWINDOW
VclPtr< vcl::Window > mpFocusWin
Definition: svdata.hxx:248
void loadUI(vcl::Window *pParent, const OString &rID, const OUString &rUIXMLDescription, const css::uno::Reference< css::frame::XFrame > &rFrame=css::uno::Reference< css::frame::XFrame >())
Definition: syswin.cxx:88
tools::Long AdjustRight(tools::Long nHorzMoveDelta)
virtual bool EventNotify(NotifyEvent &rNEvt) override
Definition: syswin.cxx:171
Point LogicToLogic(const Point &rPtSource, const MapMode *pMapModeSource, const MapMode *pMapModeDest) const
Definition: map.cxx:1466
virtual void StateChanged(StateChangedType nType) override
Definition: floatwin.cxx:671
WinBits const WB_NODIALOGCONTROL
void PixelInvalidate(const tools::Rectangle *pRectangle) override
Notification about some rectangle of the output device got invalidated.
Definition: floatwin.cxx:659
SAL_DLLPRIVATE void ImplFloatControl(bool bStart, FloatingWindow *pWindow)
Definition: toolbox.cxx:2818
FloatingWindow(const FloatingWindow &)=delete
Point AbsoluteScreenToOutputPixel(const Point &rPos) const
Definition: window.cxx:2853
SAL_DLLPRIVATE void ImplInitFloating(vcl::Window *pParent, WinBits nStyle)
Definition: floatwin.cxx:58
void SetDisplayActive(bool bActive)
Definition: brdwin.cxx:1855
const StyleSettings & GetStyleSettings() const
bool UpdatePositionData()
Definition: floatwin.cxx:959
const Color & GetFaceColor() const
Link< FloatingWindow *, void > maPopupModeEndHdl
Definition: floatwin.hxx:73
bool IsMapModeEnabled() const
Definition: outdev.hxx:1682
virtual Size GetSizePixel() const
Definition: window.cxx:2393
SAL_DLLPRIVATE vcl::Window * ImplGetFrameWindow() const
Definition: window2.cxx:899
virtual ~FloatingWindow() override
Definition: floatwin.cxx:198
void SetLOKNotifier(const vcl::ILibreOfficeKitNotifier *pNotifier, bool bParent=false)
Interface to register for dialog / window tunneling.
Definition: window.cxx:3160
static ImplSVEvent * PostUserEvent(const Link< void *, void > &rLink, void *pCaller=nullptr, bool bReferenceLink=false)
Post a user event to the default window.
Definition: svapp.cxx:1020
const MapMode & GetMapMode() const
Definition: outdev.hxx:1688
sal_uInt16 GetCode() const
Definition: keycod.hxx:51
static bool IsUnifiedDisplay()
Determines if the screens that make up a display are separate or form one large display area...
Definition: svapp.cxx:1228
bool mbGrabFocus
Definition: floatwin.hxx:71
SAL_DLLPRIVATE tools::Rectangle ImplOutputToUnmirroredAbsoluteScreenPixel(const tools::Rectangle &rRect) const
Definition: window.cxx:2863
DataChangedEventType GetType() const
Definition: event.hxx:356
const KeyEvent * GetKeyEvent() const
Definition: event.hxx:310
tools::Rectangle GetDesktopRectPixel() const
Definition: window.cxx:2787
SAL_DLLPRIVATE void ImplInitSettings()
Definition: floatwin.cxx:137
const Color & GetControlBackground() const
Definition: window2.cxx:1080
bool mbInCleanUp
Definition: floatwin.hxx:72
FloatWinPopupFlags
Definition: vclenum.hxx:369
static Point ImplCalcPos(vcl::Window *pWindow, const tools::Rectangle &rRect, FloatWinPopupFlags nFlags, sal_uInt16 &rArrangeIndex, Point *pLOKTwipsPos=nullptr)
Definition: floatwin.cxx:236
bool HasChildPathFocus(bool bSystemWindow=false) const
Definition: window.cxx:2995
Unknown
BorderWindowTitleType
Definition: brdwin.hxx:65
DialogControlFlags GetDialogControlFlags() const
Definition: window2.cxx:1055
NONE
tools::Rectangle const & GetOverflowRect() const
Definition: toolbox2.cxx:851
tools::Rectangle maFloatRect
Definition: floatwin.hxx:61
StateChangedType
Definition: window.hxx:317
FloatWinPopupEndFlags
Definition: floatwin.hxx:30
WinBits const WB_OWNERDRAWDECORATION
sal_Int64 WinBits
void SetBackground()
bool mbPopupModeTearOff
Definition: floatwin.hxx:69
static tools::Rectangle ImplConvertToRelPos(vcl::Window *pReference, const tools::Rectangle &rRect)
Definition: floatwin.cxx:531
SAL_DLLPRIVATE void ReMirror(Point &rPoint) const
Definition: outdev.cxx:595
tools::Long Left() const
VclPtr< vcl::Window > GetParentWithLOKNotifier()
Find the nearest parent with LOK Notifier; can be itself if this Window has LOK notifier set...
Definition: window.cxx:3240
const BorderLinePrimitive2D *pCandidateB assert(pCandidateA)
AllSettingsFlags GetFlags() const
Definition: event.hxx:357
tools::Long Bottom() const
bool IsHorizontal() const
Definition: toolbox.hxx:333
VclPtr< ToolBox > mpBox
Definition: floatwin.cxx:42
FloatWinPopupFlags GetPopupModeFlags() const
Definition: floatwin.hxx:125
SAL_DLLPRIVATE tools::Rectangle & ImplGetItemEdgeClipRect()
Definition: floatwin.cxx:53
tools::Long AdjustBottom(tools::Long nVertMoveDelta)
tools::Rectangle maItemEdgeClipRect
Definition: floatwin.cxx:43
IMPL_LINK_NOARG(FloatingWindow, ImplEndPopupModeHdl, void *, void)
Definition: floatwin.cxx:627
std::unique_ptr< ImplData > mpImplData
Definition: floatwin.hxx:60
tools::Rectangle GetItemRect(sal_uInt16 nItemId)
Definition: toolbox2.cxx:831
virtual bool Close()
Definition: syswin.cxx:266
static void RemoveUserEvent(ImplSVEvent *nUserEvent)
Remove user event based on event ID.
Definition: svapp.cxx:1048
Point BottomRight() const
WinBits const WB_DIALOGCONTROL
ImplSVData * ImplGetSVData()
Definition: svdata.cxx:74
void clear()
Definition: vclptr.hxx:190
static tools::Rectangle GetScreenPosSizePixel(unsigned int nScreen)
Get a screen's rectangular area.
Definition: svapp.cxx:1263
VclPtr< vcl::Window > mxPrevFocusWin
Definition: floatwin.hxx:59
bool IsRTLEnabled() const
Definition: outdev.hxx:1364
void SetActivateMode(ActivateModeFlags nMode)
Definition: window.cxx:2626
sal_uInt16 GetDownItemId() const
Definition: toolbox.hxx:354
Point maLOKTwipsPos
absolute position of the floating window in the document - in twips (for toplevel floating windows)...
Definition: floatwin.cxx:45
virtual void doDeferredInit(WinBits nBits) override
Definition: floatwin.cxx:177
VclPtr< WorkWindow > mpAppWin
Definition: svdata.hxx:240
virtual void Invalidate(InvalidateFlags nFlags=InvalidateFlags::NONE)
Definition: paint.cxx:1158
static Point ImplConvertToAbsPos(vcl::Window *pReference, const Point &rPos)
Definition: floatwin.cxx:486
virtual bool HasMirroredGraphics() const
Definition: outdev.cxx:627
tools::Long Width() const
Some things multiple-inherit from VclAbstractDialog and OutputDevice, so we need to use virtual inher...
Definition: outdev.hxx:303
void AddPopupModeWindow(vcl::Window *pWindow)
Definition: floatwin.cxx:954
static bool GetLayoutRTL()
std::unique_ptr< WindowImpl > mpWindowImpl
Definition: window.hxx:521
SAL_DLLPRIVATE vcl::Window * ImplGetParent() const
Definition: window2.cxx:863
Size get_preferred_size() const
Definition: window2.cxx:1659
bool mbIsDeferredInit
Definition: syswin.hxx:115
MouseNotifyEvent GetType() const
Definition: event.hxx:302
VclPtr< FloatingWindow > mpNextFloat
Definition: floatwin.hxx:57
bool IsInside(const Point &rPOINT) const
static Point CalcFloatingPosition(vcl::Window *pWindow, const tools::Rectangle &rRect, FloatWinPopupFlags nFlags, sal_uInt16 &rArrangeIndex)
Definition: floatwin.cxx:231
SAL_DLLPRIVATE FloatingWindow * ImplFindLastLevelFloat()
Definition: floatwin.cxx:594
const AllSettings & GetSettings() const
Definition: outdev.hxx:418
FloatWinPopupFlags mnPopupModeFlags
Definition: floatwin.hxx:63
Size GetOutputSizePixel() const
Definition: outdev.hxx:441
MapUnit GetMapUnit() const
Definition: mapmod.cxx:168
static unsigned int GetScreenCount()
Get the number of screens available for the display.
Definition: svapp.cxx:1222
static SAL_DLLPRIVATE unsigned int GetBestScreen(const tools::Rectangle &)
Get the "best" screen.
Definition: svapp.cxx:1289
SAL_DLLPRIVATE bool ImplIsFloatPopupModeWindow(const vcl::Window *pWindow)
Definition: floatwin.cxx:611
virtual void PopupModeEnd()
Definition: floatwin.cxx:751
tools::Long Top() const
Point ScreenToOutputPixel(const Point &rPos) const
Definition: window.cxx:2800
void GrabFocus()
Definition: window.cxx:2967
virtual void DataChanged(const DataChangedEvent &rDCEvt) override
Definition: floatwin.cxx:729
FloatWinTitleType
Definition: floatwin.hxx:44
vcl::Window * GetParent() const
Definition: window2.cxx:1095
Point OutputToAbsoluteScreenPixel(const Point &rPos) const
Definition: window.cxx:2843
tools::Long AdjustTop(tools::Long nVertMoveDelta)
vcl::Window * GetWindow(GetWindowType nType) const
Definition: stacking.cxx:1035
SAL_DLLPRIVATE void ImplEndPopupMode(FloatWinPopupEndFlags nFlags, const VclPtr< vcl::Window > &xFocusId)
Definition: floatwin.cxx:867
Point PixelToLogic(const Point &rDevicePt) const
Definition: map.cxx:1021
SAL_DLLPRIVATE void ImplInit(vcl::Window *pParent, WinBits nStyle, SystemParentData *pSystemParentData)
Definition: window.cxx:936
SAL_DLLPRIVATE void ImplCallPopupModeEnd()
Definition: floatwin.cxx:741
WinBits const WB_3DLOOK
WinBits const WB_SIZEABLE
WinBits const WB_STANDALONE
void GetBorder(sal_Int32 &rLeftBorder, sal_Int32 &rTopBorder, sal_Int32 &rRightBorder, sal_Int32 &rBottomBorder) const
Definition: window.cxx:2415
SalFrame * ImplGetFrame() const
Definition: window2.cxx:846
const vcl::KeyCode & GetKeyCode() const
Definition: event.hxx:54
virtual void dispose() override
This is intended to be used to clear any locally held references to other Window-subclass objects...
Definition: syswin.cxx:101
ImplSVEvent * mnPostId
Definition: floatwin.hxx:62
virtual bool EventNotify(NotifyEvent &rNEvt) override
Definition: floatwin.cxx:636
WindowType
#define SAL_WARN_IF(condition, area, stream)
bool mbPopupModeCanceled
Definition: floatwin.hxx:68
WinBits const WB_BORDER
constexpr sal_uInt16 KEY_ESCAPE
Definition: keycodes.hxx:120
void GetBorder(sal_Int32 &rLeftBorder, sal_Int32 &rTopBorder, sal_Int32 &rRightBorder, sal_Int32 &rBottomBorder) const
Definition: brdwin.cxx:1950
ImplSVFrameData maFrameData
Definition: svdata.hxx:393
bool IsVisible() const
Definition: window2.cxx:1100
virtual OUString GetText() const override
Definition: syswin.cxx:1062
::OutputDevice const * GetOutDev() const
Definition: window.cxx:577
SAL_DLLPRIVATE tools::Rectangle ImplUnmirroredAbsoluteScreenToOutputPixel(const tools::Rectangle &rRect) const
Definition: window.cxx:2882
static VclPtr< reference_type > Create(Arg &&...arg)
A construction helper for VclPtr.
Definition: vclptr.hxx:127
virtual void PositionByToolkit(const tools::Rectangle &, FloatWinPopupFlags)
Definition: salframe.hxx:173
FloatWinTitleType mnTitle
Definition: floatwin.hxx:64
tools::Long Height() const
const Color & GetWindowColor() const
BorderWindowStyle
Definition: brdwin.hxx:33
SAL_DLLPRIVATE bool ImplIsWindowOrChild(const vcl::Window *pWindow, bool bSystemWindow=false) const
Definition: stacking.cxx:699
VclPtr< FloatingWindow > mpFirstFloat
Definition: svdata.hxx:251
void ApplyControlBackground(vcl::RenderContext &rRenderContext, const Color &rDefaultColor)
Definition: window2.cxx:527
virtual void ApplySettings(vcl::RenderContext &rRenderContext) override
Definition: floatwin.cxx:185
VclPtr< vcl::Window > mpFirstPopupModeWin
Definition: floatwin.hxx:58
VclPtr< vcl::Window > mpDialogParent
Definition: syswin.hxx:116
SAL_DLLPRIVATE FloatingWindow * ImplFloatHitTest(vcl::Window *pReference, const Point &rPos, bool &rbHitTestInsideRect)
Definition: floatwin.cxx:553
virtual void StateChanged(StateChangedType nStateChange)
Definition: window.cxx:1932
const vcl::ILibreOfficeKitNotifier * GetLOKNotifier() const
Definition: window.cxx:3230
tools::Long AdjustLeft(tools::Long nHorzMoveDelta)
void SetDialogControlFlags(DialogControlFlags nFlags)
Definition: window2.cxx:1050
WinBits GetStyle() const
Definition: window2.cxx:951
Point OutputToScreenPixel(const Point &rPos) const
Definition: window.cxx:2794
void ReleaseLOKNotifier()
Indicate that LOK is not going to use this dialog any more.
Definition: window.cxx:3198
WinBits const WB_CLOSEABLE
WinBits const WB_MOVEABLE
rtl::OString toString() const
virtual void dispose() override
This is intended to be used to clear any locally held references to other Window-subclass objects...
Definition: floatwin.cxx:204
WinBits const WB_POPUP
void SetTitleType(FloatWinTitleType nTitle)
Definition: floatwin.cxx:756
void EndPopupMode(FloatWinPopupEndFlags nFlags=FloatWinPopupEndFlags::NONE)
Definition: floatwin.cxx:949
bool mbInPopupMode
Definition: floatwin.hxx:66
virtual void SetPosPixel(const Point &rNewPos)
Definition: window2.cxx:1255
bool isLayoutEnabled() const
Definition: syswin.cxx:1011
tools::Long Right() const
SAL_DLLPRIVATE void DoInitialLayout()
Definition: syswin.cxx:1093
static DockingManager * GetDockingManager()
Definition: window2.cxx:801
virtual void DataChanged(const DataChangedEvent &rDCEvt)
Definition: event.cxx:34
OUString toString(OptionInfo const *info)
ImplSVWinData * mpWinData
Definition: svdata.hxx:394
bool mbMouseDown
Definition: floatwin.hxx:70
void Show(bool bVisible=true, ShowFlags nFlags=ShowFlags::NONE)
Definition: window.cxx:2179