LibreOffice Module vcl (master)  1
brdwin.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 <strings.hrc>
21 #include <svdata.hxx>
22 #include <brdwin.hxx>
23 #include <window.h>
24 
25 #include <vcl/textrectinfo.hxx>
26 #include <vcl/event.hxx>
27 #include <vcl/decoview.hxx>
28 #include <vcl/syswin.hxx>
29 #include <vcl/dockwin.hxx>
30 #include <vcl/floatwin.hxx>
31 #include <vcl/help.hxx>
32 #include <vcl/toolkit/edit.hxx>
33 #include <vcl/settings.hxx>
34 #include <vcl/toolbox.hxx>
35 #include <vcl/ptrstyle.hxx>
36 
37 using namespace ::com::sun::star::uno;
38 
39 // useful caption height for title bar buttons
40 #define MIN_CAPTION_HEIGHT 18
41 
42 namespace vcl {
43 
44 void Window::ImplCalcSymbolRect( tools::Rectangle& rRect )
45 {
46  // Add border, not shown in the non-default representation,
47  // as we want to use it for small buttons
48  rRect.AdjustLeft( -1 );
49  rRect.AdjustTop( -1 );
50  rRect.AdjustRight( 1 );
51  rRect.AdjustBottom( 1 );
52 
53  // we leave 5% room between the symbol and the button border
54  tools::Long nExtraWidth = ((rRect.GetWidth()*50)+500)/1000;
55  tools::Long nExtraHeight = ((rRect.GetHeight()*50)+500)/1000;
56  rRect.AdjustLeft(nExtraWidth );
57  rRect.AdjustRight( -nExtraWidth );
58  rRect.AdjustTop(nExtraHeight );
59  rRect.AdjustBottom( -nExtraHeight );
60 }
61 
62 } /* namespace vcl */
63 
64 static void ImplDrawBrdWinSymbol( vcl::RenderContext* pDev,
65  const tools::Rectangle& rRect, SymbolType eSymbol )
66 {
67  // we leave 5% room between the symbol and the button border
68  DecorationView aDecoView( pDev );
69  tools::Rectangle aTempRect = rRect;
70  vcl::Window::ImplCalcSymbolRect( aTempRect );
71  aDecoView.DrawSymbol( aTempRect, eSymbol,
72  pDev->GetSettings().GetStyleSettings().GetButtonTextColor() );
73 }
74 
75 static void ImplDrawBrdWinSymbolButton( vcl::RenderContext* pDev,
76  const tools::Rectangle& rRect,
77  SymbolType eSymbol, DrawButtonFlags nState )
78 {
79  bool bMouseOver(nState & DrawButtonFlags::Highlight);
80  nState &= ~DrawButtonFlags::Highlight;
81 
82  tools::Rectangle aTempRect;
83  vcl::Window *pWin = dynamic_cast< vcl::Window* >(pDev);
84  if( pWin )
85  {
86  if( bMouseOver )
87  {
88  // provide a bright background for selection effect
89  pDev->SetFillColor( pDev->GetSettings().GetStyleSettings().GetWindowColor() );
90  pDev->SetLineColor();
91  pDev->DrawRect( rRect );
92  pWin->DrawSelectionBackground( rRect, 2, bool(nState & DrawButtonFlags::Pressed),
93  true );
94  }
95  aTempRect = rRect;
96  aTempRect.AdjustLeft(3 );
97  aTempRect.AdjustRight( -4 );
98  aTempRect.AdjustTop(3 );
99  aTempRect.AdjustBottom( -4 );
100  }
101  else
102  {
103  DecorationView aDecoView( pDev );
104  aTempRect = aDecoView.DrawButton( rRect, nState|DrawButtonFlags::Flat );
105  }
106  ImplDrawBrdWinSymbol( pDev, aTempRect, eSymbol );
107 }
108 
109 
110 ImplBorderWindowView::~ImplBorderWindowView()
111 {
112 }
113 
114 bool ImplBorderWindowView::MouseMove( const MouseEvent& )
115 {
116  return false;
117 }
118 
119 bool ImplBorderWindowView::MouseButtonDown( const MouseEvent& )
120 {
121  return false;
122 }
123 
124 bool ImplBorderWindowView::Tracking( const TrackingEvent& )
125 {
126  return false;
127 }
128 
129 OUString ImplBorderWindowView::RequestHelp( const Point&, tools::Rectangle& )
130 {
131  return OUString();
132 }
133 
134 tools::Rectangle ImplBorderWindowView::GetMenuRect() const
135 {
136  return tools::Rectangle();
137 }
138 
139 void ImplBorderWindowView::ImplInitTitle(ImplBorderFrameData* pData)
140 {
141  ImplBorderWindow* pBorderWindow = pData->mpBorderWindow;
142 
143  if ( !(pBorderWindow->GetStyle() & (WB_MOVEABLE | WB_POPUP)) ||
144  (pData->mnTitleType == BorderWindowTitleType::NONE) )
145  {
146  pData->mnTitleType = BorderWindowTitleType::NONE;
147  pData->mnTitleHeight = 0;
148  }
149  else
150  {
151  const StyleSettings& rStyleSettings = pData->mpOutDev->GetSettings().GetStyleSettings();
152  if (pData->mnTitleType == BorderWindowTitleType::Tearoff)
153  pData->mnTitleHeight = ToolBox::ImplGetDragWidth(*pData->mpBorderWindow, false) + 2;
154  else
155  {
156  if (pData->mnTitleType == BorderWindowTitleType::Small)
157  {
158  pBorderWindow->SetPointFont(*pBorderWindow, rStyleSettings.GetFloatTitleFont() );
159  pData->mnTitleHeight = rStyleSettings.GetFloatTitleHeight();
160  }
161  else // pData->mnTitleType == BorderWindowTitleType::Normal
162  {
163  // FIXME RenderContext
164  pBorderWindow->SetPointFont(*pBorderWindow, rStyleSettings.GetTitleFont());
165  pData->mnTitleHeight = rStyleSettings.GetTitleHeight();
166  }
167  tools::Long nTextHeight = pBorderWindow->GetTextHeight();
168  if (nTextHeight > pData->mnTitleHeight)
169  pData->mnTitleHeight = nTextHeight;
170  }
171  }
172 }
173 
174 BorderWindowHitTest ImplBorderWindowView::ImplHitTest( ImplBorderFrameData const * pData, const Point& rPos )
175 {
176  ImplBorderWindow* pBorderWindow = pData->mpBorderWindow;
177 
178  if ( pData->maTitleRect.IsInside( rPos ) )
179  {
180  if ( pData->maCloseRect.IsInside( rPos ) )
181  return BorderWindowHitTest::Close;
182  else if ( pData->maRollRect.IsInside( rPos ) )
183  return BorderWindowHitTest::Roll;
184  else if ( pData->maMenuRect.IsInside( rPos ) )
185  return BorderWindowHitTest::Menu;
186  else if ( pData->maDockRect.IsInside( rPos ) )
187  return BorderWindowHitTest::Dock;
188  else if ( pData->maHideRect.IsInside( rPos ) )
189  return BorderWindowHitTest::Hide;
190  else if ( pData->maHelpRect.IsInside( rPos ) )
191  return BorderWindowHitTest::Help;
192  else
193  return BorderWindowHitTest::Title;
194  }
195 
196  if ( (pBorderWindow->GetStyle() & WB_SIZEABLE) &&
197  !pBorderWindow->mbRollUp )
198  {
199  tools::Long nSizeWidth = pData->mnNoTitleTop+pData->mnTitleHeight;
200  if ( nSizeWidth < 16 )
201  nSizeWidth = 16;
202 
203  // no corner resize for floating toolbars, which would lead to jumps while formatting
204  // setting nSizeWidth = 0 will only return pure left,top,right,bottom
205  if( pBorderWindow->GetStyle() & (WB_OWNERDRAWDECORATION | WB_POPUP) )
206  nSizeWidth = 0;
207 
208  if ( rPos.X() < pData->mnLeftBorder )
209  {
210  if ( rPos.Y() < nSizeWidth )
211  return BorderWindowHitTest::TopLeft;
212  else if ( rPos.Y() >= pData->mnHeight-nSizeWidth )
213  return BorderWindowHitTest::BottomLeft;
214  else
215  return BorderWindowHitTest::Left;
216  }
217  else if ( rPos.X() >= pData->mnWidth-pData->mnRightBorder )
218  {
219  if ( rPos.Y() < nSizeWidth )
220  return BorderWindowHitTest::TopRight;
221  else if ( rPos.Y() >= pData->mnHeight-nSizeWidth )
222  return BorderWindowHitTest::BottomRight;
223  else
224  return BorderWindowHitTest::Right;
225  }
226  else if ( rPos.Y() < pData->mnNoTitleTop )
227  {
228  if ( rPos.X() < nSizeWidth )
229  return BorderWindowHitTest::TopLeft;
230  else if ( rPos.X() >= pData->mnWidth-nSizeWidth )
231  return BorderWindowHitTest::TopRight;
232  else
233  return BorderWindowHitTest::Top;
234  }
235  else if ( rPos.Y() >= pData->mnHeight-pData->mnBottomBorder )
236  {
237  if ( rPos.X() < nSizeWidth )
238  return BorderWindowHitTest::BottomLeft;
239  else if ( rPos.X() >= pData->mnWidth-nSizeWidth )
240  return BorderWindowHitTest::BottomRight;
241  else
242  return BorderWindowHitTest::Bottom;
243  }
244  }
245 
246  return BorderWindowHitTest::NONE;
247 }
248 
249 void ImplBorderWindowView::ImplMouseMove( ImplBorderFrameData* pData, const MouseEvent& rMEvt )
250 {
251  DrawButtonFlags oldCloseState = pData->mnCloseState;
252  DrawButtonFlags oldMenuState = pData->mnMenuState;
253  pData->mnCloseState &= ~DrawButtonFlags::Highlight;
254  pData->mnMenuState &= ~DrawButtonFlags::Highlight;
255 
256  Point aMousePos = rMEvt.GetPosPixel();
257  BorderWindowHitTest nHitTest = ImplHitTest( pData, aMousePos );
258  PointerStyle ePtrStyle = PointerStyle::Arrow;
259  if ( nHitTest & BorderWindowHitTest::Left )
260  ePtrStyle = PointerStyle::WindowWSize;
261  else if ( nHitTest & BorderWindowHitTest::Right )
262  ePtrStyle = PointerStyle::WindowESize;
263  else if ( nHitTest & BorderWindowHitTest::Top )
264  ePtrStyle = PointerStyle::WindowNSize;
265  else if ( nHitTest & BorderWindowHitTest::Bottom )
266  ePtrStyle = PointerStyle::WindowSSize;
267  else if ( nHitTest & BorderWindowHitTest::TopLeft )
268  ePtrStyle = PointerStyle::WindowNWSize;
269  else if ( nHitTest & BorderWindowHitTest::BottomRight )
270  ePtrStyle = PointerStyle::WindowSESize;
271  else if ( nHitTest & BorderWindowHitTest::TopRight )
272  ePtrStyle = PointerStyle::WindowNESize;
273  else if ( nHitTest & BorderWindowHitTest::BottomLeft )
274  ePtrStyle = PointerStyle::WindowSWSize;
275  else if ( nHitTest & BorderWindowHitTest::Close )
276  pData->mnCloseState |= DrawButtonFlags::Highlight;
277  else if ( nHitTest & BorderWindowHitTest::Menu )
278  pData->mnMenuState |= DrawButtonFlags::Highlight;
279  else if ( nHitTest & BorderWindowHitTest::Title &&
280  pData->mnTitleType == BorderWindowTitleType::Tearoff && !rMEvt.IsLeaveWindow() )
281  ePtrStyle = PointerStyle::Move;
282  pData->mpBorderWindow->SetPointer( ePtrStyle );
283 
284  if( pData->mnCloseState != oldCloseState )
285  pData->mpBorderWindow->Invalidate( pData->maCloseRect );
286  if( pData->mnMenuState != oldMenuState )
287  pData->mpBorderWindow->Invalidate( pData->maMenuRect );
288 }
289 
290 OUString ImplBorderWindowView::ImplRequestHelp( ImplBorderFrameData const * pData,
291  const Point& rPos,
292  tools::Rectangle& rHelpRect )
293 {
294  const char* pHelpId = nullptr;
295  OUString aHelpStr;
296  BorderWindowHitTest nHitTest = ImplHitTest( pData, rPos );
297  if ( nHitTest != BorderWindowHitTest::NONE )
298  {
299  if ( nHitTest & BorderWindowHitTest::Close )
300  {
301  pHelpId = SV_HELPTEXT_CLOSE;
302  rHelpRect = pData->maCloseRect;
303  }
304  else if ( nHitTest & BorderWindowHitTest::Roll )
305  {
306  if ( pData->mpBorderWindow->mbRollUp )
307  pHelpId = SV_HELPTEXT_ROLLDOWN;
308  else
309  pHelpId = SV_HELPTEXT_ROLLUP;
310  rHelpRect = pData->maRollRect;
311  }
312  else if ( nHitTest & BorderWindowHitTest::Dock )
313  {
314  pHelpId = SV_HELPTEXT_MAXIMIZE;
315  rHelpRect = pData->maDockRect;
316  }
317  else if ( nHitTest & BorderWindowHitTest::Hide )
318  {
319  pHelpId = SV_HELPTEXT_MINIMIZE;
320  rHelpRect = pData->maHideRect;
321  }
322  else if ( nHitTest & BorderWindowHitTest::Help )
323  {
324  pHelpId = SV_HELPTEXT_HELP;
325  rHelpRect = pData->maHelpRect;
326  }
327  else if ( nHitTest & BorderWindowHitTest::Title )
328  {
329  if( !pData->maTitleRect.IsEmpty() )
330  {
331  // tooltip only if title truncated
332  if( pData->mbTitleClipped )
333  {
334  rHelpRect = pData->maTitleRect;
335  // no help id, use window title as help string
336  aHelpStr = pData->mpBorderWindow->GetText();
337  }
338  }
339  }
340  }
341 
342  if (pHelpId)
343  aHelpStr = VclResId(pHelpId);
344 
345  return aHelpStr;
346 }
347 
348 tools::Long ImplBorderWindowView::ImplCalcTitleWidth( const ImplBorderFrameData* pData )
349 {
350  // title is not visible therefore no width
351  if ( !pData->mnTitleHeight )
352  return 0;
353 
354  ImplBorderWindow* pBorderWindow = pData->mpBorderWindow;
355  tools::Long nTitleWidth = pBorderWindow->GetTextWidth( pBorderWindow->GetText() )+6;
356  nTitleWidth += pData->maCloseRect.GetWidth();
357  nTitleWidth += pData->maRollRect.GetWidth();
358  nTitleWidth += pData->maDockRect.GetWidth();
359  nTitleWidth += pData->maMenuRect.GetWidth();
360  nTitleWidth += pData->maHideRect.GetWidth();
361  nTitleWidth += pData->maHelpRect.GetWidth();
362  nTitleWidth += pData->mnLeftBorder+pData->mnRightBorder;
363  return nTitleWidth;
364 }
365 
366 
367 ImplNoBorderWindowView::ImplNoBorderWindowView()
368 {
369 }
370 
371 void ImplNoBorderWindowView::Init( OutputDevice*, tools::Long, tools::Long )
372 {
373 }
374 
375 void ImplNoBorderWindowView::GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder,
376  sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const
377 {
378  rLeftBorder = 0;
379  rTopBorder = 0;
380  rRightBorder = 0;
381  rBottomBorder = 0;
382 }
383 
384 tools::Long ImplNoBorderWindowView::CalcTitleWidth() const
385 {
386  return 0;
387 }
388 
389 void ImplNoBorderWindowView::DrawWindow(vcl::RenderContext&, const Point*)
390 {
391 }
392 
393 ImplSmallBorderWindowView::ImplSmallBorderWindowView( ImplBorderWindow* pBorderWindow )
394  : mpBorderWindow(pBorderWindow)
395  , mpOutDev(nullptr)
396  , mnWidth(0)
397  , mnHeight(0)
398  , mnLeftBorder(0)
399  , mnTopBorder(0)
400  , mnRightBorder(0)
401  , mnBottomBorder(0)
402  , mbNWFBorder(false)
403 {
404 }
405 
406 void ImplSmallBorderWindowView::Init( OutputDevice* pDev, tools::Long nWidth, tools::Long nHeight )
407 {
408  mpOutDev = pDev;
409  mnWidth = nWidth;
410  mnHeight = nHeight;
411  mbNWFBorder = false;
412 
413  vcl::Window *pWin = nullptr, *pCtrl = nullptr;
414  if (mpOutDev->GetOutDevType() == OUTDEV_WINDOW)
415  pWin = static_cast<vcl::Window*>(mpOutDev.get());
416 
417  if (pWin)
418  pCtrl = mpBorderWindow->GetWindow(GetWindowType::Client);
419 
420  tools::Long nOrigLeftBorder = mnLeftBorder;
421  tools::Long nOrigTopBorder = mnTopBorder;
422  tools::Long nOrigRightBorder = mnRightBorder;
423  tools::Long nOrigBottomBorder = mnBottomBorder;
424 
425  WindowBorderStyle nBorderStyle = mpBorderWindow->GetBorderStyle();
426  if ( nBorderStyle & WindowBorderStyle::NOBORDER )
427  {
428  mnLeftBorder = 0;
429  mnTopBorder = 0;
430  mnRightBorder = 0;
431  mnBottomBorder = 0;
432  }
433  else
434  {
435  // FIXME: this is currently only on macOS, check with other
436  // platforms
437  if( ImplGetSVData()->maNWFData.mbNoFocusRects && !( nBorderStyle & WindowBorderStyle::NWF ) )
438  {
439  // for native widget drawing we must find out what
440  // control this border belongs to
441  ControlType aCtrlType = ControlType::Generic;
442  if (pCtrl)
443  {
444  switch( pCtrl->GetType() )
445  {
446  case WindowType::LISTBOX:
447  if( pCtrl->GetStyle() & WB_DROPDOWN )
448  {
449  aCtrlType = ControlType::Listbox;
450  mbNWFBorder = true;
451  }
452  break;
453  case WindowType::COMBOBOX:
454  if( pCtrl->GetStyle() & WB_DROPDOWN )
455  {
456  aCtrlType = ControlType::Combobox;
457  mbNWFBorder = true;
458  }
459  break;
460  case WindowType::MULTILINEEDIT:
461  aCtrlType = ControlType::MultilineEditbox;
462  mbNWFBorder = true;
463  break;
464  case WindowType::EDIT:
465  case WindowType::PATTERNFIELD:
466  case WindowType::METRICFIELD:
467  case WindowType::CURRENCYFIELD:
468  case WindowType::DATEFIELD:
469  case WindowType::TIMEFIELD:
470  case WindowType::SPINFIELD:
471  case WindowType::FORMATTEDFIELD:
472  mbNWFBorder = true;
473  if (pCtrl->GetStyle() & WB_SPIN)
474  aCtrlType = ControlType::Spinbox;
475  else
476  aCtrlType = ControlType::Editbox;
477  break;
478  default:
479  break;
480  }
481  }
482  if( mbNWFBorder )
483  {
484  ImplControlValue aControlValue;
485  Size aMinSize( mnWidth - mnLeftBorder - mnRightBorder, mnHeight - mnTopBorder - mnBottomBorder );
486  if( aMinSize.Width() < 10 ) aMinSize.setWidth( 10 );
487  if( aMinSize.Height() < 10 ) aMinSize.setHeight( 10 );
488  tools::Rectangle aCtrlRegion( Point(mnLeftBorder, mnTopBorder), aMinSize );
489  tools::Rectangle aBounds, aContent;
490  if( pWin->GetNativeControlRegion( aCtrlType, ControlPart::Entire, aCtrlRegion,
491  ControlState::ENABLED, aControlValue,
492  aBounds, aContent ) )
493  {
494  mnLeftBorder = aContent.Left() - aBounds.Left();
495  mnRightBorder = aBounds.Right() - aContent.Right();
496  mnTopBorder = aContent.Top() - aBounds.Top();
497  mnBottomBorder = aBounds.Bottom() - aContent.Bottom();
498  if( mnWidth && mnHeight )
499  {
500 
501  mpBorderWindow->SetPaintTransparent( true );
502  mpBorderWindow->SetBackground();
503  if (!pCtrl->IsControlBackground())
504  pCtrl->SetPaintTransparent(true);
505 
506  vcl::Window* pCompoundParent = nullptr;
507  if( pWin->GetParent() && pWin->GetParent()->IsCompoundControl() )
508  pCompoundParent = pWin->GetParent();
509 
510  if( pCompoundParent )
511  pCompoundParent->SetPaintTransparent( true );
512 
513  if( mnWidth < aBounds.GetWidth() || mnHeight < aBounds.GetHeight() )
514  {
515  if( ! pCompoundParent ) // compound controls have to fix themselves
516  {
517  Point aPos( mpBorderWindow->GetPosPixel() );
518  if( mnWidth < aBounds.GetWidth() )
519  aPos.AdjustX( -((aBounds.GetWidth() - mnWidth) / 2) );
520  if( mnHeight < aBounds.GetHeight() )
521  aPos.AdjustY( -((aBounds.GetHeight() - mnHeight) / 2) );
522  mpBorderWindow->SetPosSizePixel( aPos, aBounds.GetSize() );
523  }
524  }
525  }
526  }
527  else
528  mbNWFBorder = false;
529  }
530  }
531 
532  if( ! mbNWFBorder )
533  {
534  DrawFrameStyle nStyle = DrawFrameStyle::NONE;
535  DrawFrameFlags nFlags = DrawFrameFlags::NoDraw;
536  // move border outside if border was converted or if the BorderWindow is a frame window,
537  if ( mpBorderWindow->mbSmallOutBorder )
538  nStyle = DrawFrameStyle::DoubleOut;
539  else if ( nBorderStyle & WindowBorderStyle::NWF )
540  nStyle = DrawFrameStyle::NWF;
541  else
542  nStyle = DrawFrameStyle::DoubleIn;
543  if ( nBorderStyle & WindowBorderStyle::MONO )
544  nFlags |= DrawFrameFlags::Mono;
545 
546  DecorationView aDecoView( mpOutDev );
547  tools::Rectangle aRect( 0, 0, 10, 10 );
548  tools::Rectangle aCalcRect = aDecoView.DrawFrame( aRect, nStyle, nFlags );
549  mnLeftBorder = aCalcRect.Left();
550  mnTopBorder = aCalcRect.Top();
551  mnRightBorder = aRect.Right()-aCalcRect.Right();
552  mnBottomBorder = aRect.Bottom()-aCalcRect.Bottom();
553  }
554  }
555 
556  if (pCtrl)
557  {
558  //fdo#57090 If the borders have changed, then trigger a queue_resize on
559  //the bordered window, which will resync its borders at that point
560  if (nOrigLeftBorder != mnLeftBorder ||
561  nOrigTopBorder != mnTopBorder ||
562  nOrigRightBorder != mnRightBorder ||
563  nOrigBottomBorder != mnBottomBorder)
564  {
565  pCtrl->queue_resize();
566  }
567  }
568 }
569 
570 void ImplSmallBorderWindowView::GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder,
571  sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const
572 {
573  rLeftBorder = mnLeftBorder;
574  rTopBorder = mnTopBorder;
575  rRightBorder = mnRightBorder;
576  rBottomBorder = mnBottomBorder;
577 }
578 
579 tools::Long ImplSmallBorderWindowView::CalcTitleWidth() const
580 {
581  return 0;
582 }
583 
584 void ImplSmallBorderWindowView::DrawWindow(vcl::RenderContext& rRenderContext, const Point*)
585 {
586  WindowBorderStyle nBorderStyle = mpBorderWindow->GetBorderStyle();
587  if (nBorderStyle & WindowBorderStyle::NOBORDER)
588  return;
589 
590  bool bNativeOK = false;
591  // for native widget drawing we must find out what
592  // control this border belongs to
593  vcl::Window* pCtrl = mpBorderWindow->GetWindow(GetWindowType::Client);
594 
595  ControlType aCtrlType = ControlType::Generic;
596  ControlPart aCtrlPart = ControlPart::Entire;
597  if (pCtrl)
598  {
599  switch (pCtrl->GetType())
600  {
601  case WindowType::MULTILINEEDIT:
602  aCtrlType = ControlType::MultilineEditbox;
603  break;
604  case WindowType::EDIT:
605  case WindowType::PATTERNFIELD:
606  case WindowType::METRICFIELD:
607  case WindowType::CURRENCYFIELD:
608  case WindowType::DATEFIELD:
609  case WindowType::TIMEFIELD:
610  case WindowType::SPINFIELD:
611  case WindowType::FORMATTEDFIELD:
612  if (pCtrl->GetStyle() & WB_SPIN)
613  aCtrlType = ControlType::Spinbox;
614  else
615  aCtrlType = ControlType::Editbox;
616  break;
617 
618  case WindowType::LISTBOX:
619  case WindowType::MULTILISTBOX:
620  case WindowType::TREELISTBOX:
621  aCtrlType = ControlType::Listbox;
622  if (pCtrl->GetStyle() & WB_DROPDOWN)
623  aCtrlPart = ControlPart::Entire;
624  else
625  aCtrlPart = ControlPart::ListboxWindow;
626  break;
627 
628  case WindowType::LISTBOXWINDOW:
629  aCtrlType = ControlType::Listbox;
630  aCtrlPart = ControlPart::ListboxWindow;
631  break;
632 
633  case WindowType::COMBOBOX:
634  case WindowType::PATTERNBOX:
635  case WindowType::NUMERICBOX:
636  case WindowType::METRICBOX:
637  case WindowType::CURRENCYBOX:
638  case WindowType::DATEBOX:
639  case WindowType::TIMEBOX:
640  case WindowType::LONGCURRENCYBOX:
641  if (pCtrl->GetStyle() & WB_DROPDOWN)
642  {
643  aCtrlType = ControlType::Combobox;
644  aCtrlPart = ControlPart::Entire;
645  }
646  else
647  {
648  aCtrlType = ControlType::Listbox;
649  aCtrlPart = ControlPart::ListboxWindow;
650  }
651  break;
652 
653  default:
654  break;
655  }
656  }
657 
658  if (aCtrlType != ControlType::Generic && pCtrl->IsNativeControlSupported(aCtrlType, aCtrlPart))
659  {
660  ImplControlValue aControlValue;
661  ControlState nState = ControlState::ENABLED;
662 
663  if (!mpBorderWindow->IsEnabled())
664  nState &= ~ControlState::ENABLED;
665  if (mpBorderWindow->HasFocus())
666  nState |= ControlState::FOCUSED;
667  else if(mbNWFBorder)
668  {
669  // FIXME: this is currently only on macOS, see if other platforms can profit
670 
671  // FIXME: for macOS focus rings all controls need to support GetNativeControlRegion
672  // for the dropdown style
673  if (pCtrl->HasFocus() || pCtrl->HasChildPathFocus())
674  nState |= ControlState::FOCUSED;
675  }
676 
677  bool bMouseOver = false;
678  vcl::Window *pCtrlChild = pCtrl->GetWindow(GetWindowType::FirstChild);
679  while(pCtrlChild)
680  {
681  bMouseOver = pCtrlChild->IsMouseOver();
682  if (bMouseOver)
683  break;
684  pCtrlChild = pCtrlChild->GetWindow(GetWindowType::Next);
685  }
686 
687  if (bMouseOver)
688  nState |= ControlState::ROLLOVER;
689 
690  Point aPoint;
691  tools::Rectangle aCtrlRegion(aPoint, Size(mnWidth, mnHeight));
692 
693  tools::Rectangle aBoundingRgn(aPoint, Size(mnWidth, mnHeight));
694  tools::Rectangle aContentRgn(aCtrlRegion);
695  if (!ImplGetSVData()->maNWFData.mbCanDrawWidgetAnySize &&
696  rRenderContext.GetNativeControlRegion(aCtrlType, aCtrlPart, aCtrlRegion,
697  nState, aControlValue,
698  aBoundingRgn, aContentRgn))
699  {
700  aCtrlRegion=aContentRgn;
701  }
702 
703  Color aBackgroundColor = COL_AUTO;
704  if (pCtrl->IsControlBackground())
705  aBackgroundColor = pCtrl->GetBackgroundColor();
706  bNativeOK = rRenderContext.DrawNativeControl(aCtrlType, aCtrlPart, aCtrlRegion, nState, aControlValue, OUString(), aBackgroundColor);
707 
708  // if the native theme draws the spinbuttons in one call, make sure the proper settings
709  // are passed, this might force a redraw though... (TODO: improve)
710  if ((aCtrlType == ControlType::Spinbox) && !pCtrl->IsNativeControlSupported(ControlType::Spinbox, ControlPart::ButtonUp))
711  {
712  Edit* pEdit = static_cast<Edit*>(pCtrl)->GetSubEdit();
713  if (pEdit && !pEdit->SupportsDoubleBuffering())
714  pCtrl->Paint(*pCtrl, tools::Rectangle()); // make sure the buttons are also drawn as they might overwrite the border
715  }
716  }
717 
718  if (bNativeOK)
719  return;
720 
721  DrawFrameStyle nStyle = DrawFrameStyle::NONE;
722  DrawFrameFlags nFlags = DrawFrameFlags::NONE;
723  // move border outside if border was converted or if the border window is a frame window,
724  if (mpBorderWindow->mbSmallOutBorder)
725  nStyle = DrawFrameStyle::DoubleOut;
726  else if (nBorderStyle & WindowBorderStyle::NWF)
727  nStyle = DrawFrameStyle::NWF;
728  else
729  nStyle = DrawFrameStyle::DoubleIn;
730  if (nBorderStyle & WindowBorderStyle::MONO)
731  nFlags |= DrawFrameFlags::Mono;
732  if (nBorderStyle & WindowBorderStyle::MENU)
733  nFlags |= DrawFrameFlags::Menu;
734  // tell DrawFrame that we're drawing a window border of a frame window to avoid round corners
735  if (mpBorderWindow == mpBorderWindow->ImplGetFrameWindow())
736  nFlags |= DrawFrameFlags::WindowBorder;
737 
738  DecorationView aDecoView(&rRenderContext);
739  tools::Rectangle aInRect(Point(), Size(mnWidth, mnHeight));
740  aDecoView.DrawFrame(aInRect, nStyle, nFlags);
741 }
742 
743 
744 ImplStdBorderWindowView::ImplStdBorderWindowView( ImplBorderWindow* pBorderWindow )
745 {
746  maFrameData.mpBorderWindow = pBorderWindow;
747  maFrameData.mbDragFull = false;
748  maFrameData.mnHitTest = BorderWindowHitTest::NONE;
749  maFrameData.mnCloseState = DrawButtonFlags::NONE;
750  maFrameData.mnRollState = DrawButtonFlags::NONE;
751  maFrameData.mnDockState = DrawButtonFlags::NONE;
752  maFrameData.mnMenuState = DrawButtonFlags::NONE;
753  maFrameData.mnHideState = DrawButtonFlags::NONE;
754  maFrameData.mnHelpState = DrawButtonFlags::NONE;
755  maFrameData.mbTitleClipped = false;
756 }
757 
758 ImplStdBorderWindowView::~ImplStdBorderWindowView()
759 {
760 }
761 
762 bool ImplStdBorderWindowView::MouseMove( const MouseEvent& rMEvt )
763 {
764  ImplMouseMove( &maFrameData, rMEvt );
765  return true;
766 }
767 
768 bool ImplStdBorderWindowView::MouseButtonDown( const MouseEvent& rMEvt )
769 {
770  ImplBorderWindow* pBorderWindow = maFrameData.mpBorderWindow;
771 
772  if ( rMEvt.IsLeft() || rMEvt.IsRight() )
773  {
774  maFrameData.maMouseOff = rMEvt.GetPosPixel();
775  maFrameData.mnHitTest = ImplHitTest( &maFrameData, maFrameData.maMouseOff );
776  if ( maFrameData.mnHitTest != BorderWindowHitTest::NONE )
777  {
778  DragFullOptions nDragFullTest = DragFullOptions::NONE;
779  bool bTracking = true;
780  bool bHitTest = true;
781 
782  if ( maFrameData.mnHitTest & BorderWindowHitTest::Close )
783  {
784  maFrameData.mnCloseState |= DrawButtonFlags::Pressed;
785  pBorderWindow->InvalidateBorder();
786  }
787  else if ( maFrameData.mnHitTest & BorderWindowHitTest::Roll )
788  {
789  maFrameData.mnRollState |= DrawButtonFlags::Pressed;
790  pBorderWindow->InvalidateBorder();
791  }
792  else if ( maFrameData.mnHitTest & BorderWindowHitTest::Dock )
793  {
794  maFrameData.mnDockState |= DrawButtonFlags::Pressed;
795  pBorderWindow->InvalidateBorder();
796  }
797  else if ( maFrameData.mnHitTest & BorderWindowHitTest::Menu )
798  {
799  maFrameData.mnMenuState |= DrawButtonFlags::Pressed;
800  pBorderWindow->InvalidateBorder();
801 
802  // call handler already on mouse down
803  if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() )
804  {
805  SystemWindow* pClientWindow = static_cast<SystemWindow*>(pBorderWindow->ImplGetClientWindow());
806  pClientWindow->TitleButtonClick( TitleButton::Menu );
807  }
808  }
809  else if ( maFrameData.mnHitTest & BorderWindowHitTest::Hide )
810  {
811  maFrameData.mnHideState |= DrawButtonFlags::Pressed;
812  pBorderWindow->InvalidateBorder();
813  }
814  else if ( maFrameData.mnHitTest & BorderWindowHitTest::Help )
815  {
816  maFrameData.mnHelpState |= DrawButtonFlags::Pressed;
817  pBorderWindow->InvalidateBorder();
818  }
819  else
820  {
821  if ( rMEvt.GetClicks() == 1 )
822  {
823  Point aPos = pBorderWindow->GetPosPixel();
824  Size aSize = pBorderWindow->GetOutputSizePixel();
825  maFrameData.mnTrackX = aPos.X();
826  maFrameData.mnTrackY = aPos.Y();
827  maFrameData.mnTrackWidth = aSize.Width();
828  maFrameData.mnTrackHeight = aSize.Height();
829 
830  if (maFrameData.mnHitTest & BorderWindowHitTest::Title)
831  nDragFullTest = DragFullOptions::WindowMove;
832  else
833  nDragFullTest = DragFullOptions::WindowSize;
834  }
835  else
836  {
837  bTracking = false;
838 
839  if ( (maFrameData.mnHitTest & BorderWindowHitTest::Title) &&
840  ((rMEvt.GetClicks() % 2) == 0) )
841  {
842  maFrameData.mnHitTest = BorderWindowHitTest::NONE;
843  bHitTest = false;
844 
845  if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() )
846  {
847  SystemWindow* pClientWindow = static_cast<SystemWindow*>(pBorderWindow->ImplGetClientWindow());
848  // always perform docking on double click, no button required
849  pClientWindow->TitleButtonClick( TitleButton::Docking );
850  }
851  }
852  }
853  }
854 
855  if ( bTracking )
856  {
857  maFrameData.mbDragFull = false;
858  if ( nDragFullTest != DragFullOptions::NONE )
859  maFrameData.mbDragFull = true; // always fulldrag for proper docking, ignore system settings
860  pBorderWindow->StartTracking();
861  }
862  else if ( bHitTest )
863  maFrameData.mnHitTest = BorderWindowHitTest::NONE;
864  }
865  }
866 
867  return true;
868 }
869 
870 bool ImplStdBorderWindowView::Tracking( const TrackingEvent& rTEvt )
871 {
872  ImplBorderWindow* pBorderWindow = maFrameData.mpBorderWindow;
873 
874  if ( rTEvt.IsTrackingEnded() )
875  {
876  BorderWindowHitTest nHitTest = maFrameData.mnHitTest;
877  maFrameData.mnHitTest = BorderWindowHitTest::NONE;
878 
879  if ( nHitTest & BorderWindowHitTest::Close )
880  {
881  if ( maFrameData.mnCloseState & DrawButtonFlags::Pressed )
882  {
883  maFrameData.mnCloseState &= ~DrawButtonFlags::Pressed;
884  pBorderWindow->InvalidateBorder();
885 
886  // do not call a Click-Handler when aborting
887  if ( !rTEvt.IsTrackingCanceled() )
888  {
889  // dispatch to correct window type (why is Close() not virtual ??? )
890  // TODO: make Close() virtual
891  VclPtr<vcl::Window> pWin = pBorderWindow->ImplGetClientWindow()->ImplGetWindow();
892  SystemWindow *pSysWin = dynamic_cast<SystemWindow* >(pWin.get());
893  DockingWindow *pDockWin = dynamic_cast<DockingWindow*>(pWin.get());
894  if ( pSysWin )
895  pSysWin->Close();
896  else if ( pDockWin )
897  pDockWin->Close();
898  }
899  }
900  }
901  else if ( nHitTest & BorderWindowHitTest::Roll )
902  {
903  if ( maFrameData.mnRollState & DrawButtonFlags::Pressed )
904  {
905  maFrameData.mnRollState &= ~DrawButtonFlags::Pressed;
906  pBorderWindow->InvalidateBorder();
907 
908  // do not call a Click-Handler when aborting
909  if ( !rTEvt.IsTrackingCanceled() )
910  {
911  if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() )
912  {
913  SystemWindow* pClientWindow = static_cast<SystemWindow*>(pBorderWindow->ImplGetClientWindow());
914  if ( pClientWindow->IsRollUp() )
915  pClientWindow->RollDown();
916  else
917  pClientWindow->RollUp();
918  }
919  }
920  }
921  }
922  else if ( nHitTest & BorderWindowHitTest::Dock )
923  {
924  if ( maFrameData.mnDockState & DrawButtonFlags::Pressed )
925  {
926  maFrameData.mnDockState &= ~DrawButtonFlags::Pressed;
927  pBorderWindow->InvalidateBorder();
928 
929  // do not call a Click-Handler when aborting
930  if ( !rTEvt.IsTrackingCanceled() )
931  {
932  if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() )
933  {
934  SystemWindow* pClientWindow = static_cast<SystemWindow*>(pBorderWindow->ImplGetClientWindow());
935  pClientWindow->TitleButtonClick( TitleButton::Docking );
936  }
937  }
938  }
939  }
940  else if ( nHitTest & BorderWindowHitTest::Menu )
941  {
942  if ( maFrameData.mnMenuState & DrawButtonFlags::Pressed )
943  {
944  maFrameData.mnMenuState &= ~DrawButtonFlags::Pressed;
945  pBorderWindow->InvalidateBorder();
946 
947  // handler already called on mouse down
948  }
949  }
950  else if ( nHitTest & BorderWindowHitTest::Hide )
951  {
952  if ( maFrameData.mnHideState & DrawButtonFlags::Pressed )
953  {
954  maFrameData.mnHideState &= ~DrawButtonFlags::Pressed;
955  pBorderWindow->InvalidateBorder();
956 
957  // do not call a Click-Handler when aborting
958  if ( !rTEvt.IsTrackingCanceled() )
959  {
960  if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() )
961  {
962  SystemWindow* pClientWindow = static_cast<SystemWindow*>(pBorderWindow->ImplGetClientWindow());
963  pClientWindow->TitleButtonClick( TitleButton::Hide );
964  }
965  }
966  }
967  }
968  else if ( nHitTest & BorderWindowHitTest::Help )
969  {
970  if ( maFrameData.mnHelpState & DrawButtonFlags::Pressed )
971  {
972  maFrameData.mnHelpState &= ~DrawButtonFlags::Pressed;
973  pBorderWindow->InvalidateBorder();
974  }
975  }
976  else
977  {
978  if ( maFrameData.mbDragFull )
979  {
980  // restore old state when aborting
981  if ( rTEvt.IsTrackingCanceled() )
982  pBorderWindow->SetPosSizePixel( Point( maFrameData.mnTrackX, maFrameData.mnTrackY ), Size( maFrameData.mnTrackWidth, maFrameData.mnTrackHeight ) );
983  }
984  else
985  {
986  pBorderWindow->HideTracking();
987  if ( !rTEvt.IsTrackingCanceled() )
988  pBorderWindow->SetPosSizePixel( Point( maFrameData.mnTrackX, maFrameData.mnTrackY ), Size( maFrameData.mnTrackWidth, maFrameData.mnTrackHeight ) );
989  }
990 
991  if ( !rTEvt.IsTrackingCanceled() )
992  {
993  if ( pBorderWindow->ImplGetClientWindow()->ImplIsFloatingWindow() )
994  {
995  if ( static_cast<FloatingWindow*>(pBorderWindow->ImplGetClientWindow())->IsInPopupMode() )
996  static_cast<FloatingWindow*>(pBorderWindow->ImplGetClientWindow())->EndPopupMode( FloatWinPopupEndFlags::TearOff );
997  }
998  }
999  }
1000  }
1001  else if ( !rTEvt.GetMouseEvent().IsSynthetic() )
1002  {
1003  Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel();
1004 
1005  if ( maFrameData.mnHitTest & BorderWindowHitTest::Close )
1006  {
1007  if ( maFrameData.maCloseRect.IsInside( aMousePos ) )
1008  {
1009  if ( !(maFrameData.mnCloseState & DrawButtonFlags::Pressed) )
1010  {
1011  maFrameData.mnCloseState |= DrawButtonFlags::Pressed;
1012  pBorderWindow->InvalidateBorder();
1013  }
1014  }
1015  else
1016  {
1017  if ( maFrameData.mnCloseState & DrawButtonFlags::Pressed )
1018  {
1019  maFrameData.mnCloseState &= ~DrawButtonFlags::Pressed;
1020  pBorderWindow->InvalidateBorder();
1021  }
1022  }
1023  }
1024  else if ( maFrameData.mnHitTest & BorderWindowHitTest::Roll )
1025  {
1026  if ( maFrameData.maRollRect.IsInside( aMousePos ) )
1027  {
1028  if ( !(maFrameData.mnRollState & DrawButtonFlags::Pressed) )
1029  {
1030  maFrameData.mnRollState |= DrawButtonFlags::Pressed;
1031  pBorderWindow->InvalidateBorder();
1032  }
1033  }
1034  else
1035  {
1036  if ( maFrameData.mnRollState & DrawButtonFlags::Pressed )
1037  {
1038  maFrameData.mnRollState &= ~DrawButtonFlags::Pressed;
1039  pBorderWindow->InvalidateBorder();
1040  }
1041  }
1042  }
1043  else if ( maFrameData.mnHitTest & BorderWindowHitTest::Dock )
1044  {
1045  if ( maFrameData.maDockRect.IsInside( aMousePos ) )
1046  {
1047  if ( !(maFrameData.mnDockState & DrawButtonFlags::Pressed) )
1048  {
1049  maFrameData.mnDockState |= DrawButtonFlags::Pressed;
1050  pBorderWindow->InvalidateBorder();
1051  }
1052  }
1053  else
1054  {
1055  if ( maFrameData.mnDockState & DrawButtonFlags::Pressed )
1056  {
1057  maFrameData.mnDockState &= ~DrawButtonFlags::Pressed;
1058  pBorderWindow->InvalidateBorder();
1059  }
1060  }
1061  }
1062  else if ( maFrameData.mnHitTest & BorderWindowHitTest::Menu )
1063  {
1064  if ( maFrameData.maMenuRect.IsInside( aMousePos ) )
1065  {
1066  if ( !(maFrameData.mnMenuState & DrawButtonFlags::Pressed) )
1067  {
1068  maFrameData.mnMenuState |= DrawButtonFlags::Pressed;
1069  pBorderWindow->InvalidateBorder();
1070  }
1071  }
1072  else
1073  {
1074  if ( maFrameData.mnMenuState & DrawButtonFlags::Pressed )
1075  {
1076  maFrameData.mnMenuState &= ~DrawButtonFlags::Pressed;
1077  pBorderWindow->InvalidateBorder();
1078  }
1079  }
1080  }
1081  else if ( maFrameData.mnHitTest & BorderWindowHitTest::Hide )
1082  {
1083  if ( maFrameData.maHideRect.IsInside( aMousePos ) )
1084  {
1085  if ( !(maFrameData.mnHideState & DrawButtonFlags::Pressed) )
1086  {
1087  maFrameData.mnHideState |= DrawButtonFlags::Pressed;
1088  pBorderWindow->InvalidateBorder();
1089  }
1090  }
1091  else
1092  {
1093  if ( maFrameData.mnHideState & DrawButtonFlags::Pressed )
1094  {
1095  maFrameData.mnHideState &= ~DrawButtonFlags::Pressed;
1096  pBorderWindow->InvalidateBorder();
1097  }
1098  }
1099  }
1100  else if ( maFrameData.mnHitTest & BorderWindowHitTest::Help )
1101  {
1102  if ( maFrameData.maHelpRect.IsInside( aMousePos ) )
1103  {
1104  if ( !(maFrameData.mnHelpState & DrawButtonFlags::Pressed) )
1105  {
1106  maFrameData.mnHelpState |= DrawButtonFlags::Pressed;
1107  pBorderWindow->InvalidateBorder();
1108  }
1109  }
1110  else
1111  {
1112  if ( maFrameData.mnHelpState & DrawButtonFlags::Pressed )
1113  {
1114  maFrameData.mnHelpState &= ~DrawButtonFlags::Pressed;
1115  pBorderWindow->InvalidateBorder();
1116  }
1117  }
1118  }
1119  else
1120  {
1121  aMousePos.AdjustX( -(maFrameData.maMouseOff.X()) );
1122  aMousePos.AdjustY( -(maFrameData.maMouseOff.Y()) );
1123 
1124  if ( maFrameData.mnHitTest & BorderWindowHitTest::Title )
1125  {
1126  maFrameData.mpBorderWindow->SetPointer( PointerStyle::Move );
1127 
1128  Point aPos = pBorderWindow->GetPosPixel();
1129  aPos.AdjustX(aMousePos.X() );
1130  aPos.AdjustY(aMousePos.Y() );
1131  if ( maFrameData.mbDragFull )
1132  {
1133  pBorderWindow->SetPosPixel( aPos );
1134  pBorderWindow->ImplUpdateAll();
1135  pBorderWindow->ImplGetFrameWindow()->ImplUpdateAll();
1136  }
1137  else
1138  {
1139  maFrameData.mnTrackX = aPos.X();
1140  maFrameData.mnTrackY = aPos.Y();
1141  pBorderWindow->ShowTracking( tools::Rectangle( pBorderWindow->ScreenToOutputPixel( aPos ), pBorderWindow->GetOutputSizePixel() ), ShowTrackFlags::Big );
1142  }
1143  }
1144  else
1145  {
1146  Point aOldPos = pBorderWindow->GetPosPixel();
1147  Size aSize = pBorderWindow->GetSizePixel();
1148  tools::Rectangle aNewRect( aOldPos, aSize );
1149  tools::Long nOldWidth = aSize.Width();
1150  tools::Long nOldHeight = aSize.Height();
1151  tools::Long nBorderWidth = maFrameData.mnLeftBorder+maFrameData.mnRightBorder;
1152  tools::Long nBorderHeight = maFrameData.mnTopBorder+maFrameData.mnBottomBorder;
1153  tools::Long nMinWidth = pBorderWindow->mnMinWidth+nBorderWidth;
1154  tools::Long nMinHeight = pBorderWindow->mnMinHeight+nBorderHeight;
1155  tools::Long nMinWidth2 = nBorderWidth;
1156  tools::Long nMaxWidth = pBorderWindow->mnMaxWidth+nBorderWidth;
1157  tools::Long nMaxHeight = pBorderWindow->mnMaxHeight+nBorderHeight;
1158 
1159  if ( maFrameData.mnTitleHeight )
1160  {
1161  nMinWidth2 += 4;
1162 
1163  if ( pBorderWindow->GetStyle() & WB_CLOSEABLE )
1164  nMinWidth2 += maFrameData.maCloseRect.GetWidth();
1165  }
1166  if ( nMinWidth2 > nMinWidth )
1167  nMinWidth = nMinWidth2;
1168  if ( maFrameData.mnHitTest & (BorderWindowHitTest::Left | BorderWindowHitTest::TopLeft | BorderWindowHitTest::BottomLeft) )
1169  {
1170  aNewRect.AdjustLeft(aMousePos.X() );
1171  if ( aNewRect.GetWidth() < nMinWidth )
1172  aNewRect.SetLeft( aNewRect.Right()-nMinWidth+1 );
1173  else if ( aNewRect.GetWidth() > nMaxWidth )
1174  aNewRect.SetLeft( aNewRect.Right()-nMaxWidth+1 );
1175  }
1176  else if ( maFrameData.mnHitTest & (BorderWindowHitTest::Right | BorderWindowHitTest::TopRight | BorderWindowHitTest::BottomRight) )
1177  {
1178  aNewRect.AdjustRight(aMousePos.X() );
1179  if ( aNewRect.GetWidth() < nMinWidth )
1180  aNewRect.SetRight( aNewRect.Left()+nMinWidth+1 );
1181  else if ( aNewRect.GetWidth() > nMaxWidth )
1182  aNewRect.SetRight( aNewRect.Left()+nMaxWidth+1 );
1183  }
1184  if ( maFrameData.mnHitTest & (BorderWindowHitTest::Top | BorderWindowHitTest::TopLeft | BorderWindowHitTest::TopRight) )
1185  {
1186  aNewRect.AdjustTop(aMousePos.Y() );
1187  if ( aNewRect.GetHeight() < nMinHeight )
1188  aNewRect.SetTop( aNewRect.Bottom()-nMinHeight+1 );
1189  else if ( aNewRect.GetHeight() > nMaxHeight )
1190  aNewRect.SetTop( aNewRect.Bottom()-nMaxHeight+1 );
1191  }
1192  else if ( maFrameData.mnHitTest & (BorderWindowHitTest::Bottom | BorderWindowHitTest::BottomLeft | BorderWindowHitTest::BottomRight) )
1193  {
1194  aNewRect.AdjustBottom(aMousePos.Y() );
1195  if ( aNewRect.GetHeight() < nMinHeight )
1196  aNewRect.SetBottom( aNewRect.Top()+nMinHeight+1 );
1197  else if ( aNewRect.GetHeight() > nMaxHeight )
1198  aNewRect.SetBottom( aNewRect.Top()+nMaxHeight+1 );
1199  }
1200 
1201  // call Resizing-Handler for SystemWindows
1202  if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() )
1203  {
1204  // adjust size for Resizing-call
1205  aSize = aNewRect.GetSize();
1206  aSize.AdjustWidth( -nBorderWidth );
1207  aSize.AdjustHeight( -nBorderHeight );
1208  static_cast<SystemWindow*>(pBorderWindow->ImplGetClientWindow())->Resizing( aSize );
1209  aSize.AdjustWidth(nBorderWidth );
1210  aSize.AdjustHeight(nBorderHeight );
1211  if ( aSize.Width() < nMinWidth )
1212  aSize.setWidth( nMinWidth );
1213  if ( aSize.Height() < nMinHeight )
1214  aSize.setHeight( nMinHeight );
1215  if ( aSize.Width() > nMaxWidth )
1216  aSize.setWidth( nMaxWidth );
1217  if ( aSize.Height() > nMaxHeight )
1218  aSize.setHeight( nMaxHeight );
1219  if ( maFrameData.mnHitTest & (BorderWindowHitTest::Left | BorderWindowHitTest::TopLeft | BorderWindowHitTest::BottomLeft) )
1220  aNewRect.SetLeft( aNewRect.Right()-aSize.Width()+1 );
1221  else
1222  aNewRect.SetRight( aNewRect.Left()+aSize.Width()-1 );
1223  if ( maFrameData.mnHitTest & (BorderWindowHitTest::Top | BorderWindowHitTest::TopLeft | BorderWindowHitTest::TopRight) )
1224  aNewRect.SetTop( aNewRect.Bottom()-aSize.Height()+1 );
1225  else
1226  aNewRect.SetBottom( aNewRect.Top()+aSize.Height()-1 );
1227  }
1228 
1229  if ( maFrameData.mbDragFull )
1230  {
1231  // no move (only resize) if position did not change
1232  if( aOldPos != aNewRect.TopLeft() )
1233  pBorderWindow->setPosSizePixel( aNewRect.Left(), aNewRect.Top(),
1234  aNewRect.GetWidth(), aNewRect.GetHeight() );
1235  else
1236  pBorderWindow->setPosSizePixel( aNewRect.Left(), aNewRect.Top(),
1237  aNewRect.GetWidth(), aNewRect.GetHeight(), PosSizeFlags::Size );
1238 
1239  pBorderWindow->ImplUpdateAll();
1240  pBorderWindow->ImplGetFrameWindow()->ImplUpdateAll();
1241  if ( maFrameData.mnHitTest & (BorderWindowHitTest::Right | BorderWindowHitTest::TopRight | BorderWindowHitTest::BottomRight) )
1242  maFrameData.maMouseOff.AdjustX(aNewRect.GetWidth()-nOldWidth );
1243  if ( maFrameData.mnHitTest & (BorderWindowHitTest::Bottom | BorderWindowHitTest::BottomLeft | BorderWindowHitTest::BottomRight) )
1244  maFrameData.maMouseOff.AdjustY(aNewRect.GetHeight()-nOldHeight );
1245  }
1246  else
1247  {
1248  maFrameData.mnTrackX = aNewRect.Left();
1249  maFrameData.mnTrackY = aNewRect.Top();
1250  maFrameData.mnTrackWidth = aNewRect.GetWidth();
1251  maFrameData.mnTrackHeight = aNewRect.GetHeight();
1252  pBorderWindow->ShowTracking( tools::Rectangle( pBorderWindow->ScreenToOutputPixel( aNewRect.TopLeft() ), aNewRect.GetSize() ), ShowTrackFlags::Big );
1253  }
1254  }
1255  }
1256  }
1257 
1258  return true;
1259 }
1260 
1261 OUString ImplStdBorderWindowView::RequestHelp( const Point& rPos, tools::Rectangle& rHelpRect )
1262 {
1263  return ImplRequestHelp( &maFrameData, rPos, rHelpRect );
1264 }
1265 
1266 tools::Rectangle ImplStdBorderWindowView::GetMenuRect() const
1267 {
1268  return maFrameData.maMenuRect;
1269 }
1270 
1271 void ImplStdBorderWindowView::Init( OutputDevice* pDev, tools::Long nWidth, tools::Long nHeight )
1272 {
1273  ImplBorderFrameData* pData = &maFrameData;
1274  ImplBorderWindow* pBorderWindow = maFrameData.mpBorderWindow;
1275  const StyleSettings& rStyleSettings = pDev->GetSettings().GetStyleSettings();
1276  DecorationView aDecoView( pDev );
1277  tools::Rectangle aRect( 0, 0, 10, 10 );
1278  tools::Rectangle aCalcRect = aDecoView.DrawFrame( aRect, DrawFrameStyle::DoubleOut, DrawFrameFlags::NoDraw );
1279 
1280  pData->mpOutDev = pDev;
1281  pData->mnWidth = nWidth;
1282  pData->mnHeight = nHeight;
1283 
1284  pData->mnTitleType = pBorderWindow->mnTitleType;
1285 
1286  if ( !(pBorderWindow->GetStyle() & (WB_MOVEABLE | WB_POPUP)) || (pData->mnTitleType == BorderWindowTitleType::NONE) )
1287  pData->mnBorderSize = 0;
1288  else if ( pData->mnTitleType == BorderWindowTitleType::Tearoff )
1289  pData->mnBorderSize = 0;
1290  else
1291  pData->mnBorderSize = StyleSettings::GetBorderSize();
1292  pData->mnLeftBorder = aCalcRect.Left();
1293  pData->mnTopBorder = aCalcRect.Top();
1294  pData->mnRightBorder = aRect.Right()-aCalcRect.Right();
1295  pData->mnBottomBorder = aRect.Bottom()-aCalcRect.Bottom();
1296  pData->mnLeftBorder += pData->mnBorderSize;
1297  pData->mnTopBorder += pData->mnBorderSize;
1298  pData->mnRightBorder += pData->mnBorderSize;
1299  pData->mnBottomBorder += pData->mnBorderSize;
1300  pData->mnNoTitleTop = pData->mnTopBorder;
1301 
1302  ImplInitTitle(&maFrameData);
1303  if (pData->mnTitleHeight)
1304  {
1305  // to improve symbol display force a minimum title height
1306  if (pData->mnTitleType != BorderWindowTitleType::Tearoff &&
1307  pData->mnTitleHeight < MIN_CAPTION_HEIGHT)
1308  pData->mnTitleHeight = MIN_CAPTION_HEIGHT;
1309 
1310  // set a proper background for drawing
1311  // highlighted buttons in the title
1312  pBorderWindow->SetBackground( rStyleSettings.GetFaceColor() );
1313 
1314  pData->maTitleRect.SetLeft( pData->mnLeftBorder );
1315  pData->maTitleRect.SetRight( nWidth-pData->mnRightBorder-1 );
1316  pData->maTitleRect.SetTop( pData->mnTopBorder );
1317  pData->maTitleRect.SetBottom( pData->maTitleRect.Top()+pData->mnTitleHeight-1 );
1318 
1319  if ( pData->mnTitleType & (BorderWindowTitleType::Normal | BorderWindowTitleType::Small) )
1320  {
1321  tools::Long nRight = pData->maTitleRect.Right() - 3;
1322  tools::Long const nItemTop = pData->maTitleRect.Top() + 2;
1323  tools::Long const nItemBottom = pData->maTitleRect.Bottom() - 2;
1324 
1325  auto addSquareOnRight = [&nRight, nItemTop, nItemBottom](
1326  tools::Rectangle & rect, tools::Long gap)
1327  {
1328  rect.SetTop( nItemTop );
1329  rect.SetBottom( nItemBottom );
1330  rect.SetRight( nRight );
1331  rect.SetLeft( rect.Right() - rect.GetHeight() + 1 );
1332  nRight -= rect.GetWidth() + gap;
1333  };
1334 
1335  if ( pBorderWindow->GetStyle() & WB_CLOSEABLE )
1336  {
1337  addSquareOnRight(pData->maCloseRect, 3);
1338  }
1339 
1340  if ( pBorderWindow->mbMenuBtn )
1341  {
1342  addSquareOnRight(pData->maMenuRect, 0);
1343  }
1344 
1345  if ( pBorderWindow->mbDockBtn )
1346  {
1347  addSquareOnRight(pData->maDockRect, 0);
1348  }
1349 
1350  if ( pBorderWindow->mbHideBtn )
1351  {
1352  addSquareOnRight(pData->maHideRect, 0);
1353  }
1354 
1355  if ( pBorderWindow->GetStyle() & WB_ROLLABLE )
1356  {
1357  addSquareOnRight(pData->maRollRect, 0);
1358  }
1359  }
1360  else
1361  {
1362  pData->maCloseRect.SetEmpty();
1363  pData->maDockRect.SetEmpty();
1364  pData->maMenuRect.SetEmpty();
1365  pData->maHideRect.SetEmpty();
1366  pData->maRollRect.SetEmpty();
1367  pData->maHelpRect.SetEmpty();
1368  }
1369 
1370  pData->mnTopBorder += pData->mnTitleHeight;
1371  }
1372  else
1373  {
1374  pData->maTitleRect.SetEmpty();
1375  pData->maCloseRect.SetEmpty();
1376  pData->maDockRect.SetEmpty();
1377  pData->maMenuRect.SetEmpty();
1378  pData->maHideRect.SetEmpty();
1379  pData->maRollRect.SetEmpty();
1380  pData->maHelpRect.SetEmpty();
1381  }
1382 }
1383 
1384 void ImplStdBorderWindowView::GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder,
1385  sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const
1386 {
1387  rLeftBorder = maFrameData.mnLeftBorder;
1388  rTopBorder = maFrameData.mnTopBorder;
1389  rRightBorder = maFrameData.mnRightBorder;
1390  rBottomBorder = maFrameData.mnBottomBorder;
1391 }
1392 
1393 tools::Long ImplStdBorderWindowView::CalcTitleWidth() const
1394 {
1395  return ImplCalcTitleWidth( &maFrameData );
1396 }
1397 
1398 void ImplStdBorderWindowView::DrawWindow(vcl::RenderContext& rRenderContext, const Point* pOffset)
1399 {
1400  ImplBorderFrameData* pData = &maFrameData;
1401  ImplBorderWindow* pBorderWindow = pData->mpBorderWindow;
1402  Point aTmpPoint = pOffset ? *pOffset : Point();
1403  tools::Rectangle aInRect( aTmpPoint, Size( pData->mnWidth, pData->mnHeight ) );
1404  const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
1405  Color aFaceColor(rStyleSettings.GetFaceColor());
1406  Color aFrameColor(aFaceColor);
1407 
1408  aFrameColor.DecreaseContrast(sal_uInt8(0.5 * 255));
1409 
1410  // Draw Frame
1411  vcl::Region oldClipRgn(rRenderContext.GetClipRegion());
1412 
1413  // for popups, don't draw part of the frame
1414  if (!(pData->mnTitleType & (BorderWindowTitleType::Normal | BorderWindowTitleType::Small)))
1415  {
1416  FloatingWindow* pWin = dynamic_cast<FloatingWindow*>(pData->mpBorderWindow->GetWindow(GetWindowType::Client));
1417  if (pWin)
1418  {
1419  vcl::Region aClipRgn(aInRect);
1420  tools::Rectangle aItemClipRect(pWin->ImplGetItemEdgeClipRect());
1421  if (!aItemClipRect.IsEmpty())
1422  {
1423  aItemClipRect.SetPos(pData->mpBorderWindow->AbsoluteScreenToOutputPixel(aItemClipRect.TopLeft()));
1424  aClipRgn.Exclude(aItemClipRect);
1425  rRenderContext.SetClipRegion(aClipRgn);
1426  }
1427  }
1428  }
1429 
1430  // single line frame
1431  rRenderContext.SetLineColor(aFrameColor);
1432  rRenderContext.SetFillColor();
1433  rRenderContext.DrawRect(aInRect);
1434  aInRect.AdjustLeft( 1 );
1435  aInRect.AdjustRight( -1 );
1436  aInRect.AdjustTop( 1 );
1437  aInRect.AdjustBottom( -1 );
1438 
1439  // restore
1440  if (!(pData->mnTitleType & (BorderWindowTitleType::Normal | BorderWindowTitleType::Small)))
1441  rRenderContext.SetClipRegion(oldClipRgn);
1442 
1443  // Draw Border
1444  rRenderContext.SetLineColor();
1445  tools::Long nBorderSize = pData->mnBorderSize;
1446  if (nBorderSize)
1447  {
1448  rRenderContext.SetFillColor(rStyleSettings.GetFaceColor());
1449  rRenderContext.DrawRect(tools::Rectangle(Point(aInRect.Left(), aInRect.Top()),
1450  Size(aInRect.GetWidth(), nBorderSize)));
1451  rRenderContext.DrawRect(tools::Rectangle(Point(aInRect.Left(), aInRect.Top() + nBorderSize),
1452  Size(nBorderSize, aInRect.GetHeight() - nBorderSize)));
1453  rRenderContext.DrawRect(tools::Rectangle(Point(aInRect.Left(), aInRect.Bottom() - nBorderSize + 1),
1454  Size(aInRect.GetWidth(), nBorderSize)));
1455  rRenderContext.DrawRect(tools::Rectangle(Point(aInRect.Right()-nBorderSize + 1, aInRect.Top() + nBorderSize),
1456  Size(nBorderSize, aInRect.GetHeight() - nBorderSize)));
1457  }
1458 
1459  // Draw Title
1460  if (!pData->maTitleRect.IsEmpty())
1461  {
1462  aInRect = pData->maTitleRect;
1463 
1464  // use no gradient anymore, just a static titlecolor
1465  if (pData->mnTitleType == BorderWindowTitleType::Tearoff)
1466  rRenderContext.SetFillColor(rStyleSettings.GetFaceGradientColor());
1467  else if (pData->mnTitleType == BorderWindowTitleType::Popup)
1468  rRenderContext.SetFillColor(aFaceColor);
1469  else
1470  rRenderContext.SetFillColor(aFrameColor);
1471 
1472  rRenderContext.SetTextColor(rStyleSettings.GetButtonTextColor());
1473  tools::Rectangle aTitleRect(pData->maTitleRect);
1474  if(pOffset)
1475  aTitleRect.Move(pOffset->X(), pOffset->Y());
1476  rRenderContext.DrawRect(aTitleRect);
1477 
1478  if (pData->mnTitleType != BorderWindowTitleType::Tearoff)
1479  {
1480  aInRect.AdjustLeft(2 );
1481  aInRect.AdjustRight( -2 );
1482 
1483  if (!pData->maHelpRect.IsEmpty())
1484  aInRect.SetRight( pData->maHelpRect.Left() - 2 );
1485  else if (!pData->maRollRect.IsEmpty())
1486  aInRect.SetRight( pData->maRollRect.Left() - 2 );
1487  else if (!pData->maHideRect.IsEmpty())
1488  aInRect.SetRight( pData->maHideRect.Left() - 2 );
1489  else if (!pData->maDockRect.IsEmpty())
1490  aInRect.SetRight( pData->maDockRect.Left() - 2 );
1491  else if (!pData->maMenuRect.IsEmpty())
1492  aInRect.SetRight( pData->maMenuRect.Left() - 2 );
1493  else if (!pData->maCloseRect.IsEmpty())
1494  aInRect.SetRight( pData->maCloseRect.Left() - 2 );
1495 
1496  if (pOffset)
1497  aInRect.Move(pOffset->X(), pOffset->Y());
1498 
1499  DrawTextFlags nTextStyle = DrawTextFlags::Left | DrawTextFlags::VCenter | DrawTextFlags::EndEllipsis | DrawTextFlags::Clip;
1500 
1501  // must show tooltip ?
1502  TextRectInfo aInfo;
1503  rRenderContext.GetTextRect(aInRect, pBorderWindow->GetText(), nTextStyle, &aInfo);
1504  pData->mbTitleClipped = aInfo.IsEllipses();
1505 
1506  rRenderContext.DrawText(aInRect, pBorderWindow->GetText(), nTextStyle);
1507  }
1508  else
1509  {
1510  ToolBox::ImplDrawGrip(rRenderContext, aTitleRect, ToolBox::ImplGetDragWidth(rRenderContext, false),
1511  WindowAlign::Left, false);
1512  }
1513  }
1514 
1515  if (!pData->maCloseRect.IsEmpty())
1516  {
1517  tools::Rectangle aSymbolRect(pData->maCloseRect);
1518  if (pOffset)
1519  aSymbolRect.Move(pOffset->X(), pOffset->Y());
1520  ImplDrawBrdWinSymbolButton(&rRenderContext, aSymbolRect, SymbolType::CLOSE, pData->mnCloseState);
1521  }
1522  if (!pData->maDockRect.IsEmpty())
1523  {
1524  tools::Rectangle aSymbolRect(pData->maDockRect);
1525  if (pOffset)
1526  aSymbolRect.Move(pOffset->X(), pOffset->Y());
1527  ImplDrawBrdWinSymbolButton(&rRenderContext, aSymbolRect, SymbolType::DOCK, pData->mnDockState);
1528  }
1529  if (!pData->maMenuRect.IsEmpty())
1530  {
1531  tools::Rectangle aSymbolRect(pData->maMenuRect);
1532  if (pOffset)
1533  aSymbolRect.Move(pOffset->X(), pOffset->Y());
1534  ImplDrawBrdWinSymbolButton(&rRenderContext, aSymbolRect, SymbolType::MENU, pData->mnMenuState);
1535  }
1536  if (!pData->maHideRect.IsEmpty())
1537  {
1538  tools::Rectangle aSymbolRect(pData->maHideRect);
1539  if (pOffset)
1540  aSymbolRect.Move(pOffset->X(), pOffset->Y());
1541  ImplDrawBrdWinSymbolButton(&rRenderContext, aSymbolRect, SymbolType::HIDE, pData->mnHideState);
1542  }
1543  if (!pData->maRollRect.IsEmpty())
1544  {
1545  SymbolType eType;
1546  if (pBorderWindow->mbRollUp)
1547  eType = SymbolType::ROLLDOWN;
1548  else
1549  eType = SymbolType::ROLLUP;
1550  tools::Rectangle aSymbolRect(pData->maRollRect);
1551  if (pOffset)
1552  aSymbolRect.Move(pOffset->X(), pOffset->Y());
1553  ImplDrawBrdWinSymbolButton(&rRenderContext, aSymbolRect, eType, pData->mnRollState);
1554  }
1555 
1556  if (!pData->maHelpRect.IsEmpty())
1557  {
1558  tools::Rectangle aSymbolRect(pData->maHelpRect);
1559  if (pOffset)
1560  aSymbolRect.Move(pOffset->X(), pOffset->Y());
1561  ImplDrawBrdWinSymbolButton(&rRenderContext, aSymbolRect, SymbolType::HELP, pData->mnHelpState);
1562  }
1563 }
1564 
1565 void ImplBorderWindow::ImplInit( vcl::Window* pParent,
1566  WinBits nStyle, BorderWindowStyle nTypeStyle,
1567  SystemParentData* pSystemParentData
1568  )
1569 {
1570  // remove all unwanted WindowBits
1571  WinBits nOrgStyle = nStyle;
1572  WinBits nTestStyle = (WB_MOVEABLE | WB_SIZEABLE | WB_ROLLABLE | WB_CLOSEABLE | WB_STANDALONE | WB_DIALOGCONTROL | WB_NODIALOGCONTROL | WB_SYSTEMFLOATWIN | WB_INTROWIN | WB_DEFAULTWIN | WB_TOOLTIPWIN | WB_NOSHADOW | WB_OWNERDRAWDECORATION | WB_SYSTEMCHILDWINDOW | WB_POPUP);
1573  if ( nTypeStyle & BorderWindowStyle::App )
1574  nTestStyle |= WB_APP;
1575  nStyle &= nTestStyle;
1576 
1577  mpWindowImpl->mbBorderWin = true;
1578  mbSmallOutBorder = false;
1579  if ( nTypeStyle & BorderWindowStyle::Frame )
1580  {
1581  if( nStyle & WB_SYSTEMCHILDWINDOW )
1582  {
1583  mpWindowImpl->mbOverlapWin = true;
1584  mpWindowImpl->mbFrame = true;
1585  mbFrameBorder = false;
1586  }
1587  else if( nStyle & (WB_OWNERDRAWDECORATION | WB_POPUP) )
1588  {
1589  mpWindowImpl->mbOverlapWin = true;
1590  mpWindowImpl->mbFrame = true;
1591  mbFrameBorder = (nOrgStyle & WB_NOBORDER) == 0;
1592  }
1593  else
1594  {
1595  mpWindowImpl->mbOverlapWin = true;
1596  mpWindowImpl->mbFrame = true;
1597  mbFrameBorder = false;
1598  // closeable windows may have a border as well, eg. system floating windows without caption
1599  if ( (nOrgStyle & (WB_BORDER | WB_NOBORDER | WB_MOVEABLE | WB_SIZEABLE/* | WB_CLOSEABLE*/)) == WB_BORDER )
1600  mbSmallOutBorder = true;
1601  }
1602  }
1603  else if ( nTypeStyle & BorderWindowStyle::Overlap )
1604  {
1605  mpWindowImpl->mbOverlapWin = true;
1606  mbFrameBorder = true;
1607  }
1608  else
1609  mbFrameBorder = false;
1610 
1611  if ( nTypeStyle & BorderWindowStyle::Float )
1612  mbFloatWindow = true;
1613  else
1614  mbFloatWindow = false;
1615 
1616  Window::ImplInit( pParent, nStyle, pSystemParentData );
1617  SetBackground();
1618  SetTextFillColor();
1619 
1620  mpMenuBarWindow = nullptr;
1621  mnMinWidth = 0;
1622  mnMinHeight = 0;
1623  mnMaxWidth = SHRT_MAX;
1624  mnMaxHeight = SHRT_MAX;
1625  mnOrgMenuHeight = 0;
1626  mbRollUp = false;
1627  mbMenuHide = false;
1628  mbDockBtn = false;
1629  mbMenuBtn = false;
1630  mbHideBtn = false;
1631  mbDisplayActive = IsActive();
1632 
1633  if ( nTypeStyle & BorderWindowStyle::Float )
1634  mnTitleType = BorderWindowTitleType::Small;
1635  else
1636  mnTitleType = BorderWindowTitleType::Normal;
1637  mnBorderStyle = WindowBorderStyle::NORMAL;
1638  InitView();
1639 }
1640 
1641 ImplBorderWindow::ImplBorderWindow( vcl::Window* pParent,
1642  SystemParentData* pSystemParentData,
1643  WinBits nStyle, BorderWindowStyle nTypeStyle
1644  ) : Window( WindowType::BORDERWINDOW )
1645 {
1646  ImplInit( pParent, nStyle, nTypeStyle, pSystemParentData );
1647 }
1648 
1649 ImplBorderWindow::ImplBorderWindow( vcl::Window* pParent, WinBits nStyle ,
1650  BorderWindowStyle nTypeStyle ) :
1651  Window( WindowType::BORDERWINDOW )
1652 {
1653  ImplInit( pParent, nStyle, nTypeStyle, nullptr );
1654 }
1655 
1656 ImplBorderWindow::~ImplBorderWindow()
1657 {
1658  disposeOnce();
1659 }
1660 
1661 void ImplBorderWindow::dispose()
1662 {
1663  mpBorderView.reset();
1664  mpMenuBarWindow.clear();
1665  mpNotebookBar.disposeAndClear();
1666  vcl::Window::dispose();
1667 }
1668 
1669 void ImplBorderWindow::MouseMove( const MouseEvent& rMEvt )
1670 {
1671  if (mpBorderView)
1672  mpBorderView->MouseMove( rMEvt );
1673 }
1674 
1675 void ImplBorderWindow::MouseButtonDown( const MouseEvent& rMEvt )
1676 {
1677  if (mpBorderView)
1678  mpBorderView->MouseButtonDown( rMEvt );
1679 }
1680 
1681 void ImplBorderWindow::Tracking( const TrackingEvent& rTEvt )
1682 {
1683  if (mpBorderView)
1684  mpBorderView->Tracking( rTEvt );
1685 }
1686 
1687 void ImplBorderWindow::Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& )
1688 {
1689  if (mpBorderView)
1690  mpBorderView->DrawWindow(rRenderContext);
1691 }
1692 
1693 void ImplBorderWindow::Draw( OutputDevice* pOutDev, const Point& rPos )
1694 {
1695  if (mpBorderView)
1696  mpBorderView->DrawWindow(*pOutDev, &rPos);
1697 }
1698 
1699 void ImplBorderWindow::Activate()
1700 {
1701  SetDisplayActive( true );
1702  Window::Activate();
1703 }
1704 
1705 void ImplBorderWindow::Deactivate()
1706 {
1707  // remove active windows from the ruler, also ignore the Deactivate
1708  // if a menu becomes active
1709  if (GetActivateMode() != ActivateModeFlags::NONE && !ImplGetSVData()->mpWinData->mbNoDeactivate)
1710  SetDisplayActive( false );
1711  Window::Deactivate();
1712 }
1713 
1714 void ImplBorderWindow::RequestHelp( const HelpEvent& rHEvt )
1715 {
1716  // no keyboard help for border window
1717  if ( rHEvt.GetMode() & (HelpEventMode::BALLOON | HelpEventMode::QUICK) && !rHEvt.KeyboardActivated() )
1718  {
1719  Point aMousePosPixel = ScreenToOutputPixel( rHEvt.GetMousePosPixel() );
1720  tools::Rectangle aHelpRect;
1721  OUString aHelpStr( mpBorderView->RequestHelp( aMousePosPixel, aHelpRect ) );
1722 
1723  // retrieve rectangle
1724  if ( !aHelpStr.isEmpty() )
1725  {
1726  aHelpRect.SetPos( OutputToScreenPixel( aHelpRect.TopLeft() ) );
1727  if ( rHEvt.GetMode() & HelpEventMode::BALLOON )
1728  Help::ShowBalloon( this, aHelpRect.Center(), aHelpRect, aHelpStr );
1729  else
1730  Help::ShowQuickHelp( this, aHelpRect, aHelpStr );
1731  return;
1732  }
1733  }
1734 
1735  Window::RequestHelp( rHEvt );
1736 }
1737 
1738 void ImplBorderWindow::Resize()
1739 {
1740  Size aSize = GetOutputSizePixel();
1741 
1742  if ( !mbRollUp )
1743  {
1744  vcl::Window* pClientWindow = ImplGetClientWindow();
1745 
1746  sal_Int32 nLeftBorder;
1747  sal_Int32 nTopBorder;
1748  sal_Int32 nRightBorder;
1749  sal_Int32 nBottomBorder;
1750  mpBorderView->GetBorder( nLeftBorder, nTopBorder, nRightBorder, nBottomBorder );
1751 
1752  if (mpMenuBarWindow)
1753  {
1754  tools::Long nMenuHeight = mpMenuBarWindow->GetSizePixel().Height();
1755  if ( mbMenuHide )
1756  {
1757  if ( nMenuHeight )
1758  mnOrgMenuHeight = nMenuHeight;
1759  nMenuHeight = 0;
1760  }
1761  else
1762  {
1763  if ( !nMenuHeight )
1764  nMenuHeight = mnOrgMenuHeight;
1765  }
1766  mpMenuBarWindow->setPosSizePixel(
1767  nLeftBorder, nTopBorder,
1768  aSize.Width()-nLeftBorder-nRightBorder,
1769  nMenuHeight);
1770 
1771  // shift the notebookbar down accordingly
1772  nTopBorder += nMenuHeight;
1773  }
1774 
1775  if (mpNotebookBar)
1776  {
1777  tools::Long nNotebookBarHeight = mpNotebookBar->GetSizePixel().Height();
1778 
1779  const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1780  const BitmapEx& aPersona = rStyleSettings.GetPersonaHeader();
1781  // since size of notebookbar changes, to make common persona for menubar
1782  // and notebookbar persona should be set again with changed coordinates
1783  if (!aPersona.IsEmpty())
1784  {
1785  Wallpaper aWallpaper(aPersona);
1786  aWallpaper.SetStyle(WallpaperStyle::TopRight);
1787  aWallpaper.SetRect(tools::Rectangle(Point(0, -nTopBorder),
1788  Size(aSize.Width() - nLeftBorder - nRightBorder,
1789  nNotebookBarHeight + nTopBorder)));
1790  mpNotebookBar->SetBackground(aWallpaper);
1791  }
1792 
1793  mpNotebookBar->setPosSizePixel(
1794  nLeftBorder, nTopBorder,
1795  aSize.Width() - nLeftBorder - nRightBorder,
1796  nNotebookBarHeight);
1797  }
1798 
1799  GetBorder( pClientWindow->mpWindowImpl->mnLeftBorder, pClientWindow->mpWindowImpl->mnTopBorder,
1800  pClientWindow->mpWindowImpl->mnRightBorder, pClientWindow->mpWindowImpl->mnBottomBorder );
1801  pClientWindow->ImplPosSizeWindow( pClientWindow->mpWindowImpl->mnLeftBorder,
1802  pClientWindow->mpWindowImpl->mnTopBorder,
1803  aSize.Width()-pClientWindow->mpWindowImpl->mnLeftBorder-pClientWindow->mpWindowImpl->mnRightBorder,
1804  aSize.Height()-pClientWindow->mpWindowImpl->mnTopBorder-pClientWindow->mpWindowImpl->mnBottomBorder,
1805  PosSizeFlags::X | PosSizeFlags::Y |
1806  PosSizeFlags::Width | PosSizeFlags::Height );
1807  }
1808 
1809  // UpdateView
1810  mpBorderView->Init( this, aSize.Width(), aSize.Height() );
1811  InvalidateBorder();
1812 
1813  Window::Resize();
1814 }
1815 
1816 void ImplBorderWindow::StateChanged( StateChangedType nType )
1817 {
1818  if ( (nType == StateChangedType::Text) ||
1819  (nType == StateChangedType::Data) )
1820  {
1821  if (IsReallyVisible() && mbFrameBorder)
1822  InvalidateBorder();
1823  }
1824 
1825  Window::StateChanged( nType );
1826 }
1827 
1828 void ImplBorderWindow::DataChanged( const DataChangedEvent& rDCEvt )
1829 {
1830  if ( (rDCEvt.GetType() == DataChangedEventType::FONTS) ||
1831  (rDCEvt.GetType() == DataChangedEventType::FONTSUBSTITUTION) ||
1832  ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
1833  (rDCEvt.GetFlags() & AllSettingsFlags::STYLE)) )
1834  {
1835  if ( !mpWindowImpl->mbFrame || (GetStyle() & (WB_OWNERDRAWDECORATION | WB_POPUP)) )
1836  UpdateView( true, ImplGetWindow()->GetOutputSizePixel() );
1837  }
1838 
1839  Window::DataChanged( rDCEvt );
1840 }
1841 
1842 void ImplBorderWindow::InitView()
1843 {
1844  if ( mbSmallOutBorder )
1845  mpBorderView.reset(new ImplSmallBorderWindowView( this ));
1846  else if ( mpWindowImpl->mbFrame )
1847  {
1848  if( mbFrameBorder )
1849  mpBorderView.reset(new ImplStdBorderWindowView( this ));
1850  else
1851  mpBorderView.reset(new ImplNoBorderWindowView);
1852  }
1853  else if ( !mbFrameBorder )
1854  mpBorderView.reset(new ImplSmallBorderWindowView( this ));
1855  else
1856  mpBorderView.reset(new ImplStdBorderWindowView( this ));
1857  Size aSize = GetOutputSizePixel();
1858  mpBorderView->Init( this, aSize.Width(), aSize.Height() );
1859 }
1860 
1861 void ImplBorderWindow::UpdateView( bool bNewView, const Size& rNewOutSize )
1862 {
1863  sal_Int32 nLeftBorder;
1864  sal_Int32 nTopBorder;
1865  sal_Int32 nRightBorder;
1866  sal_Int32 nBottomBorder;
1867  Size aOldSize = GetSizePixel();
1868  Size aOutputSize = rNewOutSize;
1869 
1870  if ( bNewView )
1871  {
1872  mpBorderView.reset();
1873  InitView();
1874  }
1875  else
1876  {
1877  Size aSize = aOutputSize;
1878  mpBorderView->GetBorder( nLeftBorder, nTopBorder, nRightBorder, nBottomBorder );
1879  aSize.AdjustWidth(nLeftBorder+nRightBorder );
1880  aSize.AdjustHeight(nTopBorder+nBottomBorder );
1881  mpBorderView->Init( this, aSize.Width(), aSize.Height() );
1882  }
1883 
1884  vcl::Window* pClientWindow = ImplGetClientWindow();
1885  if ( pClientWindow )
1886  {
1887  GetBorder( pClientWindow->mpWindowImpl->mnLeftBorder, pClientWindow->mpWindowImpl->mnTopBorder,
1888  pClientWindow->mpWindowImpl->mnRightBorder, pClientWindow->mpWindowImpl->mnBottomBorder );
1889  }
1890  GetBorder( nLeftBorder, nTopBorder, nRightBorder, nBottomBorder );
1891  if ( aOldSize.Width() || aOldSize.Height() )
1892  {
1893  aOutputSize.AdjustWidth(nLeftBorder+nRightBorder );
1894  aOutputSize.AdjustHeight(nTopBorder+nBottomBorder );
1895  if ( aOutputSize == GetSizePixel() )
1896  InvalidateBorder();
1897  else
1898  SetSizePixel( aOutputSize );
1899  }
1900 }
1901 
1902 void ImplBorderWindow::InvalidateBorder()
1903 {
1904  if ( !IsReallyVisible() )
1905  return;
1906 
1907  // invalidate only if we have a border
1908  sal_Int32 nLeftBorder;
1909  sal_Int32 nTopBorder;
1910  sal_Int32 nRightBorder;
1911  sal_Int32 nBottomBorder;
1912  mpBorderView->GetBorder( nLeftBorder, nTopBorder, nRightBorder, nBottomBorder );
1913  if ( !(nLeftBorder || nTopBorder || nRightBorder || nBottomBorder) )
1914  return;
1915 
1916  tools::Rectangle aWinRect( Point( 0, 0 ), GetOutputSizePixel() );
1917  vcl::Region aRegion( aWinRect );
1918  aWinRect.AdjustLeft(nLeftBorder );
1919  aWinRect.AdjustTop(nTopBorder );
1920  aWinRect.AdjustRight( -nRightBorder );
1921  aWinRect.AdjustBottom( -nBottomBorder );
1922  // no output area anymore, now invalidate all
1923  if ( (aWinRect.Right() < aWinRect.Left()) ||
1924  (aWinRect.Bottom() < aWinRect.Top()) )
1925  Invalidate( InvalidateFlags::NoChildren );
1926  else
1927  {
1928  aRegion.Exclude( aWinRect );
1929  Invalidate( aRegion, InvalidateFlags::NoChildren );
1930  }
1931 }
1932 
1933 void ImplBorderWindow::SetDisplayActive( bool bActive )
1934 {
1935  if ( mbDisplayActive != bActive )
1936  {
1937  mbDisplayActive = bActive;
1938  if ( mbFrameBorder )
1939  InvalidateBorder();
1940  }
1941 }
1942 
1943 void ImplBorderWindow::SetTitleType( BorderWindowTitleType nTitleType, const Size& rSize )
1944 {
1945  mnTitleType = nTitleType;
1946  UpdateView( false, rSize );
1947 }
1948 
1949 void ImplBorderWindow::SetBorderStyle( WindowBorderStyle nStyle )
1950 {
1951  if ( !mbFrameBorder && (mnBorderStyle != nStyle) )
1952  {
1953  mnBorderStyle = nStyle;
1954  UpdateView( false, ImplGetWindow()->GetOutputSizePixel() );
1955  }
1956 }
1957 
1958 void ImplBorderWindow::SetRollUp( bool bRollUp, const Size& rSize )
1959 {
1960  mbRollUp = bRollUp;
1961  UpdateView( false, rSize );
1962 }
1963 
1964 void ImplBorderWindow::SetCloseButton()
1965 {
1966  SetStyle( GetStyle() | WB_CLOSEABLE );
1967  Size aSize = GetOutputSizePixel();
1968  mpBorderView->Init( this, aSize.Width(), aSize.Height() );
1969  InvalidateBorder();
1970 }
1971 
1972 void ImplBorderWindow::SetDockButton( bool bDockButton )
1973 {
1974  mbDockBtn = bDockButton;
1975  Size aSize = GetOutputSizePixel();
1976  mpBorderView->Init( this, aSize.Width(), aSize.Height() );
1977  InvalidateBorder();
1978 }
1979 
1980 void ImplBorderWindow::SetHideButton( bool bHideButton )
1981 {
1982  mbHideBtn = bHideButton;
1983  Size aSize = GetOutputSizePixel();
1984  mpBorderView->Init( this, aSize.Width(), aSize.Height() );
1985  InvalidateBorder();
1986 }
1987 
1988 void ImplBorderWindow::SetMenuButton( bool bMenuButton )
1989 {
1990  mbMenuBtn = bMenuButton;
1991  Size aSize = GetOutputSizePixel();
1992  mpBorderView->Init( this, aSize.Width(), aSize.Height() );
1993  InvalidateBorder();
1994 }
1995 
1996 void ImplBorderWindow::UpdateMenuHeight()
1997 {
1998  Resize();
1999 }
2000 
2001 void ImplBorderWindow::SetMenuBarWindow( vcl::Window* pWindow )
2002 {
2003  mpMenuBarWindow = pWindow;
2004  UpdateMenuHeight();
2005  if ( pWindow )
2006  pWindow->Show();
2007 }
2008 
2009 void ImplBorderWindow::SetMenuBarMode( bool bHide )
2010 {
2011  mbMenuHide = bHide;
2012  UpdateMenuHeight();
2013 }
2014 
2015 void ImplBorderWindow::SetNotebookBar(const OUString& rUIXMLDescription,
2016  const css::uno::Reference<css::frame::XFrame>& rFrame,
2017  const NotebookBarAddonsItem& aNotebookBarAddonsItem)
2018 {
2019  if (mpNotebookBar)
2020  mpNotebookBar.disposeAndClear();
2021  mpNotebookBar = VclPtr<NotebookBar>::Create(this, "NotebookBar", rUIXMLDescription, rFrame,
2022  aNotebookBarAddonsItem);
2023  Resize();
2024 }
2025 
2026 void ImplBorderWindow::CloseNotebookBar()
2027 {
2028  if (mpNotebookBar)
2029  mpNotebookBar.disposeAndClear();
2030  mpNotebookBar = nullptr;
2031  Resize();
2032 }
2033 
2034 void ImplBorderWindow::GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder,
2035  sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const
2036 {
2037  mpBorderView->GetBorder(rLeftBorder, rTopBorder, rRightBorder, rBottomBorder);
2038 
2039  if (mpMenuBarWindow && !mbMenuHide)
2040  rTopBorder += mpMenuBarWindow->GetSizePixel().Height();
2041 
2042  if (mpNotebookBar && mpNotebookBar->IsVisible())
2043  rTopBorder += mpNotebookBar->GetSizePixel().Height();
2044 }
2045 
2046 tools::Long ImplBorderWindow::CalcTitleWidth() const
2047 {
2048  return mpBorderView->CalcTitleWidth();
2049 }
2050 
2051 tools::Rectangle ImplBorderWindow::GetMenuRect() const
2052 {
2053  return mpBorderView->GetMenuRect();
2054 }
2055 
2056 Size ImplBorderWindow::GetOptimalSize() const
2057 {
2058  const vcl::Window* pClientWindow = ImplGetClientWindow();
2059  if (pClientWindow)
2060  return pClientWindow->GetOptimalSize();
2061  return Size(mnMinWidth, mnMinHeight);
2062 }
2063 
2064 void ImplBorderWindow::queue_resize(StateChangedType eReason)
2065 {
2066  //if we are floating, then we don't want to inform our parent that it needs
2067  //to calculate a new layout allocation. Because while we are a child
2068  //of our parent we are not embedded into the parent so it doesn't care
2069  //about us.
2070  if (mbFloatWindow)
2071  return;
2072  vcl::Window::queue_resize(eReason);
2073 }
2074 
2075 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
ImplBorderFrameData::mnWidth
tools::Long mnWidth
Definition: brdwin.hxx:188
vcl::Window::GetPosPixel
virtual Point GetPosPixel() const
Definition: window.cxx:2786
WB_ROLLABLE
WinBits const WB_ROLLABLE
tools::Rectangle::TopLeft
Point TopLeft() const
OutputDevice::GetClipRegion
vcl::Region GetClipRegion() const
Definition: outdev/clipping.cxx:37
OutputDevice::DrawText
void DrawText(const Point &rStartPt, const OUString &rStr, sal_Int32 nIndex=0, sal_Int32 nLen=-1, MetricVector *pVector=nullptr, OUString *pDisplayText=nullptr, const SalLayoutGlyphs *pLayoutCache=nullptr)
Definition: text.cxx:795
mnHeight
double mnHeight
tools::Rectangle::SetPos
void SetPos(const Point &rPoint)
OutputDevice::GetOutDevType
OutDevType GetOutDevType() const
Definition: outdev.hxx:523
vcl::Window::IsControlBackground
bool IsControlBackground() const
Definition: window2.cxx:1087
ImplBorderWindow::CloseNotebookBar
void CloseNotebookBar()
Definition: brdwin.cxx:2026
WB_APP
WinBits const WB_APP
ImplNoBorderWindowView::GetBorder
virtual void GetBorder(sal_Int32 &rLeftBorder, sal_Int32 &rTopBorder, sal_Int32 &rRightBorder, sal_Int32 &rBottomBorder) const override
Definition: brdwin.cxx:375
WB_NOSHADOW
WinBits const WB_NOSHADOW
ImplStdBorderWindowView::maFrameData
ImplBorderFrameData maFrameData
Definition: brdwin.hxx:273
vcl::Window::ImplGetWindow
vcl::Window * ImplGetWindow() const
if this is a proxy return the client, otherwise itself
Definition: window2.cxx:835
vcl::Window::GetActivateMode
ActivateModeFlags GetActivateMode() const
Definition: window2.cxx:1137
ImplStdBorderWindowView::CalcTitleWidth
virtual tools::Long CalcTitleWidth() const override
Definition: brdwin.cxx:1393
ImplBorderWindowView::ImplHitTest
static BorderWindowHitTest ImplHitTest(ImplBorderFrameData const *pData, const Point &rPos)
Definition: brdwin.cxx:174
vcl::Window::ImplIsFloatingWindow
SAL_DLLPRIVATE bool ImplIsFloatingWindow() const
Definition: window2.cxx:911
SystemWindow::RollDown
void RollDown()
Definition: syswin.cxx:385
ImplStdBorderWindowView::DrawWindow
virtual void DrawWindow(vcl::RenderContext &rRenderContext, const Point *pOffset=nullptr) override
Definition: brdwin.cxx:1398
ImplBorderWindow::SetCloseButton
void SetCloseButton()
Definition: brdwin.cxx:1964
ImplBorderWindow::ImplStdBorderWindowView
friend class ImplStdBorderWindowView
Definition: brdwin.hxx:82
ImplBorderWindow::mnMinHeight
tools::Long mnMinHeight
Definition: brdwin.hxx:89
tools::Rectangle::AdjustRight
tools::Long AdjustRight(tools::Long nHorzMoveDelta)
ImplBorderFrameData::mnCloseState
DrawButtonFlags mnCloseState
Definition: brdwin.hxx:202
Size::setWidth
void setWidth(tools::Long nWidth)
OutputDevice::GetNativeControlRegion
bool GetNativeControlRegion(ControlType nType, ControlPart nPart, const tools::Rectangle &rControlRegion, ControlState nState, const ImplControlValue &aValue, tools::Rectangle &rNativeBoundingRegion, tools::Rectangle &rNativeContentRegion) const
Query the native control's actual drawing region (including adornment)
Definition: nativecontrols.cxx:324
ImplStdBorderWindowView::ImplStdBorderWindowView
ImplStdBorderWindowView(ImplBorderWindow *pBorderWindow)
Definition: brdwin.cxx:744
pData
std::unique_ptr< ContentProperties > pData
ImplBorderWindow::Deactivate
virtual void Deactivate() override
Definition: brdwin.cxx:1705
ImplStdBorderWindowView::MouseButtonDown
virtual bool MouseButtonDown(const MouseEvent &rMEvt) override
Definition: brdwin.cxx:768
SystemWindow::IsRollUp
bool IsRollUp() const
Definition: syswin.hxx:146
ImplBorderWindowView::ImplCalcTitleWidth
static tools::Long ImplCalcTitleWidth(const ImplBorderFrameData *pData)
Definition: brdwin.cxx:348
WB_NODIALOGCONTROL
WinBits const WB_NODIALOGCONTROL
ImplBorderWindow::dispose
virtual void dispose() override
This is intended to be used to clear any locally held references to other Window-subclass objects...
Definition: brdwin.cxx:1661
ImplBorderWindow::Tracking
virtual void Tracking(const TrackingEvent &rTEvt) override
Definition: brdwin.cxx:1681
ImplBorderFrameData::mnTitleType
BorderWindowTitleType mnTitleType
Definition: brdwin.hxx:208
ImplBorderFrameData::mpBorderWindow
VclPtr< ImplBorderWindow > mpBorderWindow
Definition: brdwin.hxx:178
vcl::Window::AbsoluteScreenToOutputPixel
Point AbsoluteScreenToOutputPixel(const Point &rPos) const
Definition: window.cxx:2857
tools::Long
long Long
VclPtr::disposeAndClear
void disposeAndClear()
Definition: vclptr.hxx:200
ImplBorderWindow::SetDisplayActive
void SetDisplayActive(bool bActive)
Definition: brdwin.cxx:1933
AllSettings::GetStyleSettings
const StyleSettings & GetStyleSettings() const
Definition: app/settings.cxx:3051
StyleSettings::GetFaceColor
const Color & GetFaceColor() const
Definition: app/settings.cxx:746
StyleSettings::GetPersonaHeader
BitmapEx const & GetPersonaHeader() const
Definition: app/settings.cxx:2345
DecorationView::DrawFrame
void DrawFrame(const tools::Rectangle &rRect, const Color &rLeftTopColor, const Color &rRightBottomColor)
Definition: decoview.cxx:837
ImplSmallBorderWindowView::GetBorder
virtual void GetBorder(sal_Int32 &rLeftBorder, sal_Int32 &rTopBorder, sal_Int32 &rRightBorder, sal_Int32 &rBottomBorder) const override
Definition: brdwin.cxx:570
ImplBorderWindow::Resize
virtual void Resize() override
Definition: brdwin.cxx:1738
vcl::Window::HideTracking
void HideTracking()
Definition: window2.cxx:147
vcl::Window::GetSizePixel
virtual Size GetSizePixel() const
Definition: window.cxx:2397
vcl::Window::ImplGetFrameWindow
SAL_DLLPRIVATE vcl::Window * ImplGetFrameWindow() const
Definition: window2.cxx:901
vcl::Window::SetSizePixel
virtual void SetSizePixel(const Size &rNewSize)
Definition: window2.cxx:1262
vcl::Window::GetOptimalSize
virtual Size GetOptimalSize() const
Definition: window3.cxx:33
ImplBorderFrameData::mnBottomBorder
sal_Int32 mnBottomBorder
Definition: brdwin.hxx:197
OutputDevice::SetTextFillColor
void SetTextFillColor()
Definition: text.cxx:701
tools::Rectangle::GetWidth
tools::Long GetWidth() const
DataChangedEvent::GetType
DataChangedEventType GetType() const
Definition: event.hxx:356
DrawButtonFlags
DrawButtonFlags
Definition: decoview.hxx:53
ImplBorderWindow::InvalidateBorder
void InvalidateBorder()
Definition: brdwin.cxx:1902
ImplBorderFrameData::mpOutDev
VclPtr< OutputDevice > mpOutDev
Definition: brdwin.hxx:179
ImplBorderWindow::StateChanged
virtual void StateChanged(StateChangedType nType) override
Definition: brdwin.cxx:1816
DecorationView::DrawButton
tools::Rectangle DrawButton(const tools::Rectangle &rRect, DrawButtonFlags nStyle)
Definition: decoview.cxx:931
vcl::Window::ImplUpdateAll
SAL_DLLPRIVATE void ImplUpdateAll()
Definition: paint.cxx:989
ImplBorderWindow::ImplInit
void ImplInit(vcl::Window *pParent, WinBits nStyle, BorderWindowStyle nTypeStyle, SystemParentData *pParentData)
Definition: brdwin.cxx:1565
vcl::Window::dispose
virtual void dispose() override
This is intended to be used to clear any locally held references to other Window-subclass objects...
Definition: window.cxx:147
vcl::Window::StartTracking
void StartTracking(StartTrackingFlags nFlags=StartTrackingFlags::NONE)
Definition: window2.cxx:244
vcl::Window::HasChildPathFocus
bool HasChildPathFocus(bool bSystemWindow=false) const
Definition: window.cxx:2982
OutputDevice::IsNativeControlSupported
bool IsNativeControlSupported(ControlType nType, ControlPart nPart) const
Query the platform layer for control support.
Definition: nativecontrols.cxx:168
ImplBorderFrameData::mnRollState
DrawButtonFlags mnRollState
Definition: brdwin.hxx:203
HelpEvent::GetMode
HelpEventMode GetMode() const
Definition: event.hxx:205
tools::Rectangle::SetRight
void SetRight(tools::Long v)
ImplBorderWindow::mpNotebookBar
VclPtr< NotebookBar > mpNotebookBar
Definition: brdwin.hxx:87
vcl::Window::GetBackgroundColor
Color GetBackgroundColor() const override
Definition: window.cxx:588
ImplSmallBorderWindowView::mpOutDev
VclPtr< OutputDevice > mpOutDev
Definition: brdwin.hxx:252
BorderWindowTitleType
BorderWindowTitleType
Definition: brdwin.hxx:66
ImplBorderFrameData::maRollRect
tools::Rectangle maRollRect
Definition: brdwin.hxx:182
SystemWindow::RollUp
void RollUp()
Definition: syswin.cxx:369
tools::Rectangle::IsEmpty
bool IsEmpty() const
ImplDrawBrdWinSymbolButton
static void ImplDrawBrdWinSymbolButton(vcl::RenderContext *pDev, const tools::Rectangle &rRect, SymbolType eSymbol, DrawButtonFlags nState)
Definition: brdwin.cxx:75
StateChangedType
StateChangedType
Definition: window.hxx:317
OutputDevice::GetTextRect
tools::Rectangle GetTextRect(const tools::Rectangle &rRect, const OUString &rStr, DrawTextFlags nStyle=DrawTextFlags::WordBreak, TextRectInfo *pInfo=nullptr, const vcl::ITextLayout *_pTextLayout=nullptr) const
Definition: text.cxx:1808
COL_AUTO
constexpr::Color COL_AUTO(0xFF, 0xFF, 0xFF, 0xFF)
MIN_CAPTION_HEIGHT
#define MIN_CAPTION_HEIGHT
Definition: brdwin.cxx:40
WB_OWNERDRAWDECORATION
WinBits const WB_OWNERDRAWDECORATION
MouseEvent::GetClicks
sal_uInt16 GetClicks() const
Definition: event.hxx:123
ImplBorderWindow::mnTitleType
BorderWindowTitleType mnTitleType
Definition: brdwin.hxx:93
WinBits
sal_Int64 WinBits
OutputDevice::SetBackground
void SetBackground()
Definition: outdevstate.cxx:437
ImplBorderFrameData::mnLeftBorder
sal_Int32 mnLeftBorder
Definition: brdwin.hxx:194
tools::Rectangle::Left
tools::Long Left() const
tools::Rectangle::SetLeft
void SetLeft(tools::Long v)
SymbolType
SymbolType
Definition: vclenum.hxx:73
vcl::Window::ShowTracking
void ShowTracking(const tools::Rectangle &rRect, ShowTrackFlags nFlags=ShowTrackFlags::Small)
Definition: window2.cxx:124
ImplDrawBrdWinSymbol
static void ImplDrawBrdWinSymbol(vcl::RenderContext *pDev, const tools::Rectangle &rRect, SymbolType eSymbol)
Definition: brdwin.cxx:64
ImplBorderFrameData::mnTrackX
tools::Long mnTrackX
Definition: brdwin.hxx:190
ImplBorderWindow::mbFrameBorder
bool mbFrameBorder
Definition: brdwin.hxx:97
DataChangedEvent::GetFlags
AllSettingsFlags GetFlags() const
Definition: event.hxx:357
tools::Rectangle::Bottom
tools::Long Bottom() const
ImplBorderWindow::mnMaxWidth
tools::Long mnMaxWidth
Definition: brdwin.hxx:90
ImplSmallBorderWindowView::CalcTitleWidth
virtual tools::Long CalcTitleWidth() const override
Definition: brdwin.cxx:579
vcl::Window::queue_resize
virtual void queue_resize(StateChangedType eReason=StateChangedType::Layout)
Definition: window2.cxx:1327
ImplBorderFrameData::mnTopBorder
sal_Int32 mnTopBorder
Definition: brdwin.hxx:195
ImplBorderFrameData::maHideRect
tools::Rectangle maHideRect
Definition: brdwin.hxx:185
vcl::Window::GetText
virtual OUString GetText() const
Definition: window.cxx:3033
WB_SYSTEMFLOATWIN
WinBits const WB_SYSTEMFLOATWIN
FloatingWindow::ImplGetItemEdgeClipRect
SAL_DLLPRIVATE tools::Rectangle & ImplGetItemEdgeClipRect()
Definition: floatwin.cxx:53
ImplBorderFrameData::maCloseRect
tools::Rectangle maCloseRect
Definition: brdwin.hxx:181
vcl::Window::ImplCalcSymbolRect
static SAL_DLLPRIVATE void ImplCalcSymbolRect(tools::Rectangle &rRect)
Definition: brdwin.cxx:44
Edit
Definition: edit.hxx:55
ImplBorderFrameData::mnRightBorder
sal_Int32 mnRightBorder
Definition: brdwin.hxx:196
ImplBorderFrameData::mnHeight
tools::Long mnHeight
Definition: brdwin.hxx:189
tools::Rectangle::AdjustBottom
tools::Long AdjustBottom(tools::Long nVertMoveDelta)
ImplBorderWindow::mpBorderView
std::unique_ptr< ImplBorderWindowView > mpBorderView
Definition: brdwin.hxx:85
NotebookBar::setPosSizePixel
virtual void setPosSizePixel(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, PosSizeFlags nFlags=PosSizeFlags::All) override
Definition: notebookbar.cxx:160
ImplSmallBorderWindowView::mpBorderWindow
VclPtr< ImplBorderWindow > mpBorderWindow
Definition: brdwin.hxx:251
ImplBorderFrameData::maHelpRect
tools::Rectangle maHelpRect
Definition: brdwin.hxx:186
OutputDevice::DrawRect
void DrawRect(const tools::Rectangle &rRect)
Definition: rect.cxx:51
HelpEvent::GetMousePosPixel
const Point & GetMousePosPixel() const
Definition: event.hxx:204
eType
DocumentType eType
ImplBorderWindowView::MouseMove
virtual bool MouseMove(const MouseEvent &rMEvt)
Definition: brdwin.cxx:114
WB_INTROWIN
WinBits const WB_INTROWIN
ImplBorderFrameData::mnTrackY
tools::Long mnTrackY
Definition: brdwin.hxx:191
SystemWindow::Close
virtual bool Close()
Definition: syswin.cxx:266
ImplBorderFrameData::mnTitleHeight
tools::Long mnTitleHeight
Definition: brdwin.hxx:200
WB_DIALOGCONTROL
WinBits const WB_DIALOGCONTROL
BitmapEx::IsEmpty
bool IsEmpty() const
Definition: bitmapex.cxx:199
ImplGetSVData
ImplSVData * ImplGetSVData()
Definition: svdata.cxx:76
ImplBorderWindow::SetRollUp
void SetRollUp(bool bRollUp, const Size &rSize)
Definition: brdwin.cxx:1958
ImplBorderWindow::UpdateView
void UpdateView(bool bNewView, const Size &rNewOutSize)
Definition: brdwin.cxx:1861
OutputDevice::SetLineColor
void SetLineColor()
Definition: outdevstate.cxx:389
VclPtr::clear
void clear()
Definition: vclptr.hxx:190
ImplBorderWindowView::ImplRequestHelp
static OUString ImplRequestHelp(ImplBorderFrameData const *pData, const Point &rPos, tools::Rectangle &rHelpRect)
Definition: brdwin.cxx:290
ImplStdBorderWindowView::RequestHelp
virtual OUString RequestHelp(const Point &rPos, tools::Rectangle &rHelpRect) override
Definition: brdwin.cxx:1261
MouseEvent::IsLeaveWindow
bool IsLeaveWindow() const
Definition: event.hxx:137
Wallpaper::SetRect
void SetRect(const tools::Rectangle &rRect)
Definition: wall.cxx:296
vcl::Window::IsSystemWindow
bool IsSystemWindow() const
Definition: window2.cxx:997
vcl::Window::DrawSelectionBackground
void DrawSelectionBackground(const tools::Rectangle &rRect, sal_uInt16 highlight, bool bChecked, bool bDrawBorder)
Definition: window.cxx:3427
ImplBorderWindow::RequestHelp
virtual void RequestHelp(const HelpEvent &rHEvt) override
Definition: brdwin.cxx:1714
ImplBorderWindow::GetBorderStyle
WindowBorderStyle GetBorderStyle() const
Definition: brdwin.hxx:145
ImplBorderWindowView::~ImplBorderWindowView
virtual ~ImplBorderWindowView()
Definition: brdwin.cxx:110
ImplBorderWindow::mbFloatWindow
bool mbFloatWindow
Definition: brdwin.hxx:95
ImplBorderWindow::SetMenuBarWindow
void SetMenuBarWindow(vcl::Window *pWindow)
Definition: brdwin.cxx:2001
Wallpaper::SetStyle
void SetStyle(WallpaperStyle eStyle)
Definition: wall.cxx:203
ImplBorderWindow::mpMenuBarWindow
VclPtr< vcl::Window > mpMenuBarWindow
Definition: brdwin.hxx:86
vcl::Window::Invalidate
virtual void Invalidate(InvalidateFlags nFlags=InvalidateFlags::NONE)
Definition: paint.cxx:1164
ImplBorderFrameData::mnBorderSize
tools::Long mnBorderSize
Definition: brdwin.hxx:199
ImplBorderWindow::ImplSmallBorderWindowView
friend class ImplSmallBorderWindowView
Definition: brdwin.hxx:81
ImplBorderWindowView::Tracking
virtual bool Tracking(const TrackingEvent &rTEvt)
Definition: brdwin.cxx:124
OutputDevice::SetFillColor
void SetFillColor()
Definition: outdevstate.cxx:311
Size::Width
tools::Long Width() const
OutputDevice
Some things multiple-inherit from VclAbstractDialog and OutputDevice, so we need to use virtual inher...
Definition: outdev.hxx:302
ImplStdBorderWindowView::~ImplStdBorderWindowView
virtual ~ImplStdBorderWindowView() override
Definition: brdwin.cxx:758
ImplBorderWindow::mnBorderStyle
WindowBorderStyle mnBorderStyle
Definition: brdwin.hxx:94
OutputDevice::SetTextColor
void SetTextColor(const Color &rColor)
Definition: text.cxx:666
vcl::Window::mpWindowImpl
std::unique_ptr< WindowImpl > mpWindowImpl
Definition: window.hxx:519
ImplBorderWindow::CalcTitleWidth
tools::Long CalcTitleWidth() const
Definition: brdwin.cxx:2046
WB_TOOLTIPWIN
WinBits const WB_TOOLTIPWIN
ImplBorderWindow::Paint
virtual void Paint(vcl::RenderContext &rRenderContext, const tools::Rectangle &rRect) override
Definition: brdwin.cxx:1687
tools::Rectangle::IsInside
bool IsInside(const Point &rPOINT) const
ImplBorderWindow::UpdateMenuHeight
void UpdateMenuHeight()
Definition: brdwin.cxx:1996
OutputDevice::DrawNativeControl
bool DrawNativeControl(ControlType nType, ControlPart nPart, const tools::Rectangle &rControlRegion, ControlState nState, const ImplControlValue &aValue, const OUString &aCaption, const Color &rBackgroundColor=COL_AUTO)
Request rendering of a particular control and/or part.
Definition: nativecontrols.cxx:287
tools::Rectangle::SetTop
void SetTop(tools::Long v)
tools::Rectangle::SetBottom
void SetBottom(tools::Long v)
WB_DROPDOWN
WinBits const WB_DROPDOWN
OutputDevice::GetSettings
const AllSettings & GetSettings() const
Definition: outdev.hxx:417
vcl::Window::SetPaintTransparent
void SetPaintTransparent(bool bTransparent)
Definition: paint.cxx:1026
OutputDevice::GetOutputSizePixel
Size GetOutputSizePixel() const
Definition: outdev.hxx:440
ImplBorderWindow::GetMenuRect
tools::Rectangle GetMenuRect() const
Definition: brdwin.cxx:2051
DrawTextFlags
DrawTextFlags
Definition: outdev.hxx:142
ImplBorderFrameData::mnHitTest
BorderWindowHitTest mnHitTest
Definition: brdwin.hxx:201
ImplBorderWindow::MouseButtonDown
virtual void MouseButtonDown(const MouseEvent &rMEvt) override
Definition: brdwin.cxx:1675
tools::Rectangle::Top
tools::Long Top() const
vcl::Window::ScreenToOutputPixel
Point ScreenToOutputPixel(const Point &rPos) const
Definition: window.cxx:2804
HelpEvent::KeyboardActivated
bool KeyboardActivated() const
Definition: event.hxx:206
ImplBorderWindow::SetBorderStyle
void SetBorderStyle(WindowBorderStyle nStyle)
Definition: brdwin.cxx:1949
Help::ShowQuickHelp
static void ShowQuickHelp(vcl::Window *pParent, const tools::Rectangle &rScreenRect, const OUString &rHelpText, QuickHelpFlags nStyle=QuickHelpFlags::NONE)
Definition: help.cxx:180
vcl::Window::GetParent
vcl::Window * GetParent() const
Definition: window2.cxx:1097
vcl::Window::ImplGetClientWindow
SAL_DLLPRIVATE vcl::Window * ImplGetClientWindow() const
Definition: window2.cxx:870
ImplBorderWindowView::GetMenuRect
virtual tools::Rectangle GetMenuRect() const
Definition: brdwin.cxx:134
ImplBorderWindow::Activate
virtual void Activate() override
Definition: brdwin.cxx:1699
TrackingEvent::IsTrackingEnded
bool IsTrackingEnded() const
Definition: event.hxx:263
vcl::Window::SetStyle
void SetStyle(WinBits nStyle)
Definition: window.cxx:1958
tools::Rectangle::GetSize
Size GetSize() const
vcl::Window::IsCompoundControl
bool IsCompoundControl() const
Definition: window2.cxx:1193
ImplSmallBorderWindowView::Init
virtual void Init(OutputDevice *pOutDev, tools::Long nWidth, tools::Long nHeight) override
Definition: brdwin.cxx:406
WB_NOBORDER
WinBits const WB_NOBORDER
vcl::Window::SetPosSizePixel
virtual void SetPosSizePixel(const Point &rNewPos, const Size &rNewSize)
Definition: window2.cxx:1268
ImplBorderWindow::DataChanged
virtual void DataChanged(const DataChangedEvent &rDCEvt) override
Definition: brdwin.cxx:1828
tools::Rectangle::AdjustTop
tools::Long AdjustTop(tools::Long nVertMoveDelta)
vcl::Window::GetWindow
vcl::Window * GetWindow(GetWindowType nType) const
Definition: stacking.cxx:1039
WB_SYSTEMCHILDWINDOW
WinBits const WB_SYSTEMCHILDWINDOW
DrawFrameStyle
DrawFrameStyle
Definition: vclenum.hxx:336
vcl::Window::SetPointFont
void SetPointFont(vcl::RenderContext &rRenderContext, const vcl::Font &rFont)
Definition: window.cxx:2169
ImplBorderWindow::SetNotebookBar
void SetNotebookBar(const OUString &rUIXMLDescription, const css::uno::Reference< css::frame::XFrame > &rFrame, const NotebookBarAddonsItem &aNotebookBarAddonsItem)
Definition: brdwin.cxx:2015
ImplBorderWindow::mnMaxHeight
tools::Long mnMaxHeight
Definition: brdwin.hxx:91
ControlType
ControlType
These types are all based on the supported variants vcl/salnativewidgets.hxx and must be kept in-sync...
Definition: WidgetThemeLibraryTypes.hxx:28
ImplBorderFrameData::mnTrackHeight
tools::Long mnTrackHeight
Definition: brdwin.hxx:193
vcl::Window::setPosSizePixel
virtual void setPosSizePixel(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, PosSizeFlags nFlags=PosSizeFlags::All)
Definition: window.cxx:2661
ImplBorderWindowView::ImplMouseMove
static void ImplMouseMove(ImplBorderFrameData *pData, const MouseEvent &rMEvt)
Definition: brdwin.cxx:249
WB_SIZEABLE
WinBits const WB_SIZEABLE
WB_STANDALONE
WinBits const WB_STANDALONE
ImplStdBorderWindowView::Tracking
virtual bool Tracking(const TrackingEvent &rTEvt) override
Definition: brdwin.cxx:870
ImplBorderWindow::SetMenuBarMode
void SetMenuBarMode(bool bHide)
Definition: brdwin.cxx:2009
BorderWindowHitTest
BorderWindowHitTest
Definition: brdwin.hxx:44
vcl::Window::SetPointer
void SetPointer(PointerStyle)
Definition: mouse.cxx:474
ImplBorderWindow::mbSmallOutBorder
bool mbSmallOutBorder
Definition: brdwin.hxx:96
ImplBorderWindow::mbDisplayActive
bool mbDisplayActive
Definition: brdwin.hxx:103
vcl::Region::Exclude
void Exclude(const tools::Rectangle &rRegion)
Definition: region.cxx:675
ImplStdBorderWindowView::GetBorder
virtual void GetBorder(sal_Int32 &rLeftBorder, sal_Int32 &rTopBorder, sal_Int32 &rRightBorder, sal_Int32 &rBottomBorder) const override
Definition: brdwin.cxx:1384
ImplBorderWindow::Draw
void Draw(OutputDevice *pDev, const Point &rPos)
Definition: brdwin.cxx:1693
vcl::Window::IsMouseOver
bool IsMouseOver() const
Definition: mouse.cxx:606
WindowType
WindowType
StyleSettings::GetFaceGradientColor
Color GetFaceGradientColor() const
Definition: app/settings.cxx:2369
MouseEvent::IsSynthetic
bool IsSynthetic() const
Definition: event.hxx:139
StyleSettings::GetTitleFont
const vcl::Font & GetTitleFont() const
Definition: app/settings.cxx:1739
StyleSettings::GetButtonTextColor
const Color & GetButtonTextColor() const
Definition: app/settings.cxx:837
WB_BORDER
WinBits const WB_BORDER
sal_uInt8
unsigned char sal_uInt8
ImplStdBorderWindowView::GetMenuRect
virtual tools::Rectangle GetMenuRect() const override
Definition: brdwin.cxx:1266
ImplBorderWindow::GetOptimalSize
virtual Size GetOptimalSize() const override
Definition: brdwin.cxx:2056
ImplBorderFrameData::maMenuRect
tools::Rectangle maMenuRect
Definition: brdwin.hxx:184
ImplBorderWindow::GetBorder
void GetBorder(sal_Int32 &rLeftBorder, sal_Int32 &rTopBorder, sal_Int32 &rRightBorder, sal_Int32 &rBottomBorder) const
Definition: brdwin.cxx:2034
ImplBorderWindow::mnOrgMenuHeight
tools::Long mnOrgMenuHeight
Definition: brdwin.hxx:92
ImplBorderWindowView::RequestHelp
virtual OUString RequestHelp(const Point &rPos, tools::Rectangle &rHelpRect)
Definition: brdwin.cxx:129
ImplBorderWindow::SetHideButton
void SetHideButton(bool bHideButton)
Definition: brdwin.cxx:1980
vcl::Window::IsVisible
bool IsVisible() const
Definition: window2.cxx:1102
ImplBorderWindow::SetTitleType
void SetTitleType(BorderWindowTitleType nTitleType, const Size &rSize)
Definition: brdwin.cxx:1943
OutputDevice::GetTextHeight
tools::Long GetTextHeight() const
Height where any character of the current font fits; in logic coordinates.
Definition: text.cxx:903
ImplBorderWindow::SetDockButton
void SetDockButton(bool bDockButton)
Definition: brdwin.cxx:1972
MouseEvent::IsLeft
bool IsLeft() const
Definition: event.hxx:146
ImplBorderFrameData::mnHelpState
DrawButtonFlags mnHelpState
Definition: brdwin.hxx:207
ImplNoBorderWindowView::DrawWindow
virtual void DrawWindow(vcl::RenderContext &rRenderContext, const Point *pOffset=nullptr) override
Definition: brdwin.cxx:389
mnWidth
double mnWidth
Size::AdjustWidth
tools::Long AdjustWidth(tools::Long n)
VclPtr::Create
static VclPtr< reference_type > Create(Arg &&...arg)
A construction helper for VclPtr.
Definition: vclptr.hxx:127
OutputDevice::GetTextWidth
tools::Long GetTextWidth(const OUString &rStr, sal_Int32 nIndex=0, sal_Int32 nLen=-1, vcl::TextLayoutCache const *=nullptr, SalLayoutGlyphs const *const pLayoutCache=nullptr) const
Width of the text.
Definition: text.cxx:892
Size::Height
tools::Long Height() const
vcl::Window::Paint
virtual void Paint(vcl::RenderContext &rRenderContext, const tools::Rectangle &rRect)
Definition: paint.cxx:1021
StyleSettings::GetFloatTitleHeight
tools::Long GetFloatTitleHeight() const
Definition: app/settings.cxx:1901
StyleSettings::GetFloatTitleFont
const vcl::Font & GetFloatTitleFont() const
Definition: app/settings.cxx:1752
vcl::Window::IsActive
bool IsActive() const
Definition: window2.cxx:1183
StyleSettings::GetWindowColor
const Color & GetWindowColor() const
Definition: app/settings.cxx:1058
BorderWindowStyle
BorderWindowStyle
Definition: brdwin.hxx:33
MouseEvent::GetPosPixel
const Point & GetPosPixel() const
Definition: event.hxx:120
StyleSettings::GetTitleHeight
tools::Long GetTitleHeight() const
Definition: app/settings.cxx:1888
ImplBorderFrameData::mnMenuState
DrawButtonFlags mnMenuState
Definition: brdwin.hxx:205
ImplBorderFrameData::mnHideState
DrawButtonFlags mnHideState
Definition: brdwin.hxx:206
ImplBorderWindowView::MouseButtonDown
virtual bool MouseButtonDown(const MouseEvent &rMEvt)
Definition: brdwin.cxx:119
Size::AdjustHeight
tools::Long AdjustHeight(tools::Long n)
PointerStyle
PointerStyle
Definition: ptrstyle.hxx:25
WB_DEFAULTWIN
WinBits const WB_DEFAULTWIN
ImplStdBorderWindowView::Init
virtual void Init(OutputDevice *pDev, tools::Long nWidth, tools::Long nHeight) override
Definition: brdwin.cxx:1271
ImplBorderWindowView::ImplInitTitle
static void ImplInitTitle(ImplBorderFrameData *pData)
Definition: brdwin.cxx:139
ImplBorderWindow::queue_resize
virtual void queue_resize(StateChangedType eReason=StateChangedType::Layout) override
Definition: brdwin.cxx:2064
Size::setHeight
void setHeight(tools::Long nHeight)
tools::Rectangle::GetHeight
tools::Long GetHeight() const
ImplNoBorderWindowView::Init
virtual void Init(OutputDevice *pDev, tools::Long nWidth, tools::Long nHeight) override
Definition: brdwin.cxx:371
vcl::Window::GetType
WindowType GetType() const
Definition: window2.cxx:974
ImplBorderFrameData::maTitleRect
tools::Rectangle maTitleRect
Definition: brdwin.hxx:180
ImplSmallBorderWindowView::ImplSmallBorderWindowView
ImplSmallBorderWindowView(ImplBorderWindow *pBorderWindow)
Definition: brdwin.cxx:393
tools::Rectangle::Move
void Move(tools::Long nHorzMoveDelta, tools::Long nVertMoveDelta)
ImplSmallBorderWindowView::DrawWindow
virtual void DrawWindow(vcl::RenderContext &rRenderContext, const Point *pOffset=nullptr) override
Definition: brdwin.cxx:584
VclPtr::get
reference_type * get() const
Get the body.
Definition: vclptr.hxx:143
vcl::Window::IsEnabled
bool IsEnabled() const
Definition: window2.cxx:1122
ImplBorderWindow::ImplBorderWindow
ImplBorderWindow(const ImplBorderWindow &)=delete
tools::Rectangle::AdjustLeft
tools::Long AdjustLeft(tools::Long nHorzMoveDelta)
DockingWindow::Close
virtual bool Close()
Definition: dockwin.cxx:620
ImplBorderWindow::~ImplBorderWindow
virtual ~ImplBorderWindow() override
Definition: brdwin.cxx:1656
DecorationView::DrawSymbol
void DrawSymbol(const tools::Rectangle &rRect, SymbolType eType, const Color &rColor, DrawSymbolFlags nStyle=DrawSymbolFlags::NONE)
Definition: decoview.cxx:794
TrackingEvent::IsTrackingCanceled
bool IsTrackingCanceled() const
Definition: event.hxx:265
VclResId
OUString VclResId(const char *pId)
Definition: svdata.cxx:267
SystemWindow::TitleButtonClick
virtual void TitleButtonClick(TitleButton nButton)
Definition: syswin.cxx:291
vcl::Window::GetStyle
WinBits GetStyle() const
Definition: window2.cxx:953
MouseEvent::IsRight
bool IsRight() const
Definition: event.hxx:150
vcl::Window::OutputToScreenPixel
Point OutputToScreenPixel(const Point &rPos) const
Definition: window.cxx:2798
ToolBox::ImplGetDragWidth
SAL_DLLPRIVATE int ImplGetDragWidth() const
Definition: toolbox.cxx:142
WindowBorderStyle
WindowBorderStyle
Definition: vclenum.hxx:108
WB_CLOSEABLE
WinBits const WB_CLOSEABLE
DragFullOptions
DragFullOptions
Definition: settings.hxx:166
WB_MOVEABLE
WinBits const WB_MOVEABLE
ImplBorderWindow::mnMinWidth
tools::Long mnMinWidth
Definition: brdwin.hxx:88
DrawFrameFlags
DrawFrameFlags
Definition: vclenum.hxx:348
TrackingEvent::GetMouseEvent
const MouseEvent & GetMouseEvent() const
Definition: event.hxx:259
vcl::Window::IsReallyVisible
bool IsReallyVisible() const
Definition: window2.cxx:1107
ImplBorderFrameData::mnNoTitleTop
tools::Long mnNoTitleTop
Definition: brdwin.hxx:198
ImplBorderFrameData::maDockRect
tools::Rectangle maDockRect
Definition: brdwin.hxx:183
vcl::Window::HasFocus
bool HasFocus() const
Definition: window.cxx:2959
WB_SPIN
WinBits const WB_SPIN
vcl::Window::SupportsDoubleBuffering
bool SupportsDoubleBuffering() const
Can the widget derived from this Window do the double-buffering via RenderContext properly...
Definition: window.cxx:3841
WB_POPUP
WinBits const WB_POPUP
TextRectInfo::IsEllipses
bool IsEllipses() const
Definition: textrectinfo.hxx:42
StyleSettings::GetBorderSize
static tools::Long GetBorderSize()
Definition: app/settings.cxx:1875
InvalidateFlags::NoChildren
The child windows are not invalidated.
ImplBorderWindow::SetMenuButton
void SetMenuButton(bool bMenuButton)
Definition: brdwin.cxx:1988
nState
sal_Int32 nState
vcl::Window::SetPosPixel
virtual void SetPosPixel(const Point &rNewPos)
Definition: window2.cxx:1257
ImplBorderFrameData::mnTrackWidth
tools::Long mnTrackWidth
Definition: brdwin.hxx:192
ImplStdBorderWindowView::MouseMove
virtual bool MouseMove(const MouseEvent &rMEvt) override
Definition: brdwin.cxx:762
tools::Rectangle::Right
tools::Long Right() const
ImplBorderFrameData::mnDockState
DrawButtonFlags mnDockState
Definition: brdwin.hxx:204
ToolBox::ImplDrawGrip
static SAL_DLLPRIVATE void ImplDrawGrip(vcl::RenderContext &rRenderContext, const tools::Rectangle &aDragArea, int nDragWidth, WindowAlign eAlign, bool bHorz)
Definition: toolbox.cxx:239
vcl::Window::ImplPosSizeWindow
SAL_DLLPRIVATE void ImplPosSizeWindow(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, PosSizeFlags nFlags)
Definition: window.cxx:1443
ImplNoBorderWindowView::CalcTitleWidth
virtual tools::Long CalcTitleWidth() const override
Definition: brdwin.cxx:384
ImplBorderWindow::MouseMove
virtual void MouseMove(const MouseEvent &rMEvt) override
Definition: brdwin.cxx:1669
Help::ShowBalloon
static void ShowBalloon(vcl::Window *pParent, const Point &rScreenPos, const tools::Rectangle &, const OUString &rHelpText)
Definition: help.cxx:157
vcl::Window::Show
void Show(bool bVisible=true, ShowFlags nFlags=ShowFlags::NONE)
Definition: window.cxx:2183
Generated on Tue Nov 24 2020 03:20:36 for LibreOffice Module vcl (master) by   doxygen 1.8.10