Line data Source code
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 <limits.h>
21 : #include <tools/debug.hxx>
22 : #include <tools/poly.hxx>
23 :
24 : #include <vcl/bitmap.hxx>
25 : #include <vcl/dialog.hxx>
26 : #include <vcl/event.hxx>
27 : #include <vcl/fixed.hxx>
28 : #include <vcl/layout.hxx>
29 : #include <vcl/timer.hxx>
30 : #include <vcl/metric.hxx>
31 : #include <vcl/virdev.hxx>
32 : #include <vcl/window.hxx>
33 : #include <vcl/scrbar.hxx>
34 : #include <vcl/dockwin.hxx>
35 : #include <vcl/tabctrl.hxx>
36 : #include <vcl/settings.hxx>
37 :
38 : #include <window.h>
39 : #include <outfont.hxx>
40 : #include <outdev.h>
41 : #include <svdata.hxx>
42 : #include <impbmp.hxx>
43 : #include <salbmp.hxx>
44 : #include <salgdi.hxx>
45 : #include <salframe.hxx>
46 : #include <scrwnd.hxx>
47 :
48 : using namespace com::sun::star;
49 :
50 : namespace vcl {
51 :
52 25 : void Window::ShowFocus( const Rectangle& rRect )
53 : {
54 25 : if( mpWindowImpl->mbInShowFocus )
55 0 : return;
56 25 : mpWindowImpl->mbInShowFocus = true;
57 :
58 25 : ImplWinData* pWinData = ImplGetWinData();
59 :
60 : // native themeing suggest not to use focus rects
61 25 : if( ! ( mpWindowImpl->mbUseNativeFocus &&
62 25 : IsNativeWidgetEnabled() ) )
63 : {
64 25 : if ( !mpWindowImpl->mbInPaint )
65 : {
66 7 : if ( mpWindowImpl->mbFocusVisible )
67 : {
68 0 : if ( *(pWinData->mpFocusRect) == rRect )
69 : {
70 0 : mpWindowImpl->mbInShowFocus = false;
71 0 : return;
72 : }
73 :
74 0 : ImplInvertFocus( *(pWinData->mpFocusRect) );
75 : }
76 :
77 7 : ImplInvertFocus( rRect );
78 : }
79 25 : if ( !pWinData->mpFocusRect )
80 11 : pWinData->mpFocusRect = new Rectangle( rRect );
81 : else
82 14 : *(pWinData->mpFocusRect) = rRect;
83 25 : mpWindowImpl->mbFocusVisible = true;
84 : }
85 : else
86 : {
87 0 : if( ! mpWindowImpl->mbNativeFocusVisible )
88 : {
89 0 : mpWindowImpl->mbNativeFocusVisible = true;
90 0 : if ( !mpWindowImpl->mbInPaint )
91 0 : Invalidate();
92 : }
93 : }
94 25 : mpWindowImpl->mbInShowFocus = false;
95 : }
96 :
97 8317 : void Window::HideFocus()
98 : {
99 :
100 8317 : if( mpWindowImpl->mbInHideFocus )
101 0 : return;
102 8317 : mpWindowImpl->mbInHideFocus = true;
103 :
104 : // native themeing can suggest not to use focus rects
105 8317 : if( ! ( mpWindowImpl->mbUseNativeFocus &&
106 8317 : IsNativeWidgetEnabled() ) )
107 : {
108 8317 : if ( !mpWindowImpl->mbFocusVisible )
109 : {
110 8300 : mpWindowImpl->mbInHideFocus = false;
111 8300 : return;
112 : }
113 :
114 17 : if ( !mpWindowImpl->mbInPaint )
115 14 : ImplInvertFocus( *(ImplGetWinData()->mpFocusRect) );
116 17 : mpWindowImpl->mbFocusVisible = false;
117 : }
118 : else
119 : {
120 0 : if( mpWindowImpl->mbNativeFocusVisible )
121 : {
122 0 : mpWindowImpl->mbNativeFocusVisible = false;
123 0 : if ( !mpWindowImpl->mbInPaint )
124 0 : Invalidate();
125 : }
126 : }
127 17 : mpWindowImpl->mbInHideFocus = false;
128 : }
129 :
130 62346 : void Window::Invert( const Rectangle& rRect, InvertFlags nFlags )
131 : {
132 62346 : if ( !IsDeviceOutputNecessary() )
133 215 : return;
134 :
135 62308 : OutputDevice *pOutDev = GetOutDev();
136 62308 : Rectangle aRect( pOutDev->ImplLogicToDevicePixel( rRect ) );
137 :
138 62308 : if ( aRect.IsEmpty() )
139 106 : return;
140 62202 : aRect.Justify();
141 :
142 : // we need a graphics
143 62202 : if ( !mpGraphics )
144 : {
145 0 : if ( !pOutDev->AcquireGraphics() )
146 0 : return;
147 : }
148 :
149 62202 : if ( mbInitClipRegion )
150 8799 : InitClipRegion();
151 :
152 62202 : if ( mbOutputClipped )
153 33 : return;
154 :
155 62169 : SalInvert nSalFlags = 0;
156 62169 : if ( nFlags & InvertFlags::Highlight )
157 0 : nSalFlags |= SAL_INVERT_HIGHLIGHT;
158 62169 : if ( nFlags & InvertFlags::N50 )
159 0 : nSalFlags |= SAL_INVERT_50;
160 62169 : mpGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight(), nSalFlags, this );
161 : }
162 :
163 18 : void Window::Invert( const Polygon& rPoly, InvertFlags nFlags )
164 : {
165 18 : if ( !IsDeviceOutputNecessary() )
166 0 : return;
167 :
168 18 : sal_uInt16 nPoints = rPoly.GetSize();
169 :
170 18 : if ( nPoints < 2 )
171 0 : return;
172 :
173 18 : OutputDevice *pOutDev = GetOutDev();
174 18 : Polygon aPoly( pOutDev->ImplLogicToDevicePixel( rPoly ) );
175 :
176 : // we need a graphics
177 18 : if ( !mpGraphics )
178 : {
179 0 : if ( !pOutDev->AcquireGraphics() )
180 0 : return;
181 : }
182 :
183 18 : if ( mbInitClipRegion )
184 2 : InitClipRegion();
185 :
186 18 : if ( mbOutputClipped )
187 0 : return;
188 :
189 18 : SalInvert nSalFlags = 0;
190 18 : if ( nFlags & InvertFlags::Highlight )
191 0 : nSalFlags |= SAL_INVERT_HIGHLIGHT;
192 18 : if ( nFlags & InvertFlags::N50 )
193 0 : nSalFlags |= SAL_INVERT_50;
194 18 : const SalPoint* pPtAry = reinterpret_cast<const SalPoint*>(aPoly.GetConstPointAry());
195 18 : mpGraphics->Invert( nPoints, pPtAry, nSalFlags, this );
196 : }
197 :
198 0 : void Window::ShowTracking( const Rectangle& rRect, sal_uInt16 nFlags )
199 : {
200 0 : ImplWinData* pWinData = ImplGetWinData();
201 :
202 0 : if ( !mpWindowImpl->mbInPaint || !(nFlags & SHOWTRACK_WINDOW) )
203 : {
204 0 : if ( mpWindowImpl->mbTrackVisible )
205 : {
206 0 : if ( (*(pWinData->mpTrackRect) == rRect) &&
207 0 : (pWinData->mnTrackFlags == nFlags) )
208 0 : return;
209 :
210 0 : InvertTracking( *(pWinData->mpTrackRect), pWinData->mnTrackFlags );
211 : }
212 :
213 0 : InvertTracking( rRect, nFlags );
214 : }
215 :
216 0 : if ( !pWinData->mpTrackRect )
217 0 : pWinData->mpTrackRect = new Rectangle( rRect );
218 : else
219 0 : *(pWinData->mpTrackRect) = rRect;
220 0 : pWinData->mnTrackFlags = nFlags;
221 0 : mpWindowImpl->mbTrackVisible = true;
222 : }
223 :
224 0 : void Window::HideTracking()
225 : {
226 0 : if ( mpWindowImpl->mbTrackVisible )
227 : {
228 0 : ImplWinData* pWinData = ImplGetWinData();
229 0 : if ( !mpWindowImpl->mbInPaint || !(pWinData->mnTrackFlags & SHOWTRACK_WINDOW) )
230 0 : InvertTracking( *(pWinData->mpTrackRect), pWinData->mnTrackFlags );
231 0 : mpWindowImpl->mbTrackVisible = false;
232 : }
233 0 : }
234 :
235 47 : void Window::InvertTracking( const Rectangle& rRect, sal_uInt16 nFlags )
236 : {
237 47 : OutputDevice *pOutDev = GetOutDev();
238 47 : Rectangle aRect( pOutDev->ImplLogicToDevicePixel( rRect ) );
239 :
240 47 : if ( aRect.IsEmpty() )
241 6 : return;
242 44 : aRect.Justify();
243 :
244 : SalGraphics* pGraphics;
245 :
246 44 : if ( nFlags & SHOWTRACK_WINDOW )
247 : {
248 44 : if ( !IsDeviceOutputNecessary() )
249 0 : return;
250 :
251 : // we need a graphics
252 44 : if ( !mpGraphics )
253 : {
254 0 : if ( !pOutDev->AcquireGraphics() )
255 0 : return;
256 : }
257 :
258 44 : if ( mbInitClipRegion )
259 25 : InitClipRegion();
260 :
261 44 : if ( mbOutputClipped )
262 0 : return;
263 :
264 44 : pGraphics = mpGraphics;
265 : }
266 : else
267 : {
268 0 : pGraphics = ImplGetFrameGraphics();
269 :
270 0 : if ( nFlags & SHOWTRACK_CLIP )
271 : {
272 0 : Point aPoint( mnOutOffX, mnOutOffY );
273 : vcl::Region aRegion( Rectangle( aPoint,
274 0 : Size( mnOutWidth, mnOutHeight ) ) );
275 0 : ImplClipBoundaries( aRegion, false, false );
276 0 : pOutDev->SelectClipRegion( aRegion, pGraphics );
277 : }
278 : }
279 :
280 44 : sal_uInt16 nStyle = nFlags & SHOWTRACK_STYLE;
281 44 : if ( nStyle == SHOWTRACK_OBJECT )
282 0 : pGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight(), SAL_INVERT_TRACKFRAME, this );
283 44 : else if ( nStyle == SHOWTRACK_SPLIT )
284 0 : pGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight(), SAL_INVERT_50, this );
285 : else
286 : {
287 44 : long nBorder = 1;
288 44 : if ( nStyle == SHOWTRACK_BIG )
289 0 : nBorder = 5;
290 44 : pGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), nBorder, SAL_INVERT_50, this );
291 44 : pGraphics->Invert( aRect.Left(), aRect.Bottom()-nBorder+1, aRect.GetWidth(), nBorder, SAL_INVERT_50, this );
292 44 : pGraphics->Invert( aRect.Left(), aRect.Top()+nBorder, nBorder, aRect.GetHeight()-(nBorder*2), SAL_INVERT_50, this );
293 44 : pGraphics->Invert( aRect.Right()-nBorder+1, aRect.Top()+nBorder, nBorder, aRect.GetHeight()-(nBorder*2), SAL_INVERT_50, this );
294 : }
295 : }
296 :
297 0 : void Window::InvertTracking( const Polygon& rPoly, sal_uInt16 nFlags )
298 : {
299 0 : sal_uInt16 nPoints = rPoly.GetSize();
300 :
301 0 : if ( nPoints < 2 )
302 0 : return;
303 :
304 0 : OutputDevice *pOutDev = GetOutDev();
305 :
306 0 : Polygon aPoly( pOutDev->ImplLogicToDevicePixel( rPoly ) );
307 :
308 : SalGraphics* pGraphics;
309 :
310 0 : if ( nFlags & SHOWTRACK_WINDOW )
311 : {
312 0 : if ( !IsDeviceOutputNecessary() )
313 0 : return;
314 :
315 : // we need a graphics
316 0 : if ( !mpGraphics )
317 : {
318 0 : if ( !pOutDev->AcquireGraphics() )
319 0 : return;
320 : }
321 :
322 0 : if ( mbInitClipRegion )
323 0 : InitClipRegion();
324 :
325 0 : if ( mbOutputClipped )
326 0 : return;
327 :
328 0 : pGraphics = mpGraphics;
329 : }
330 : else
331 : {
332 0 : pGraphics = ImplGetFrameGraphics();
333 :
334 0 : if ( nFlags & SHOWTRACK_CLIP )
335 : {
336 0 : Point aPoint( mnOutOffX, mnOutOffY );
337 : vcl::Region aRegion( Rectangle( aPoint,
338 0 : Size( mnOutWidth, mnOutHeight ) ) );
339 0 : ImplClipBoundaries( aRegion, false, false );
340 0 : pOutDev->SelectClipRegion( aRegion, pGraphics );
341 : }
342 : }
343 :
344 0 : const SalPoint* pPtAry = reinterpret_cast<const SalPoint*>(aPoly.GetConstPointAry());
345 0 : pGraphics->Invert( nPoints, pPtAry, SAL_INVERT_TRACKFRAME, this );
346 : }
347 :
348 0 : IMPL_LINK_TYPED( Window, ImplTrackTimerHdl, Timer*, pTimer, void )
349 : {
350 0 : ImplSVData* pSVData = ImplGetSVData();
351 :
352 : // Bei Button-Repeat muessen wir den Timeout umsetzen
353 0 : if ( pSVData->maWinData.mnTrackFlags & StartTrackingFlags::ButtonRepeat )
354 0 : pTimer->SetTimeout( GetSettings().GetMouseSettings().GetButtonRepeat() );
355 :
356 : // Tracking-Event erzeugen
357 0 : Point aMousePos( mpWindowImpl->mpFrameData->mnLastMouseX, mpWindowImpl->mpFrameData->mnLastMouseY );
358 0 : if( ImplIsAntiparallel() )
359 : {
360 : // - RTL - re-mirror frame pos at pChild
361 0 : const OutputDevice *pOutDev = GetOutDev();
362 0 : pOutDev->ReMirror( aMousePos );
363 : }
364 : MouseEvent aMEvt( ImplFrameToOutput( aMousePos ),
365 : mpWindowImpl->mpFrameData->mnClickCount, MouseEventModifiers::NONE,
366 : mpWindowImpl->mpFrameData->mnMouseCode,
367 0 : mpWindowImpl->mpFrameData->mnMouseCode );
368 0 : TrackingEvent aTEvt( aMEvt, TrackingEventFlags::Repeat );
369 0 : Tracking( aTEvt );
370 0 : }
371 :
372 0 : void Window::StartTracking( StartTrackingFlags nFlags )
373 : {
374 0 : ImplSVData* pSVData = ImplGetSVData();
375 :
376 0 : if ( pSVData->maWinData.mpTrackWin.get() != this )
377 : {
378 0 : if ( pSVData->maWinData.mpTrackWin )
379 0 : pSVData->maWinData.mpTrackWin->EndTracking( TrackingEventFlags::Cancel );
380 : }
381 :
382 0 : if ( nFlags & (StartTrackingFlags::ScrollRepeat | StartTrackingFlags::ButtonRepeat) )
383 : {
384 0 : pSVData->maWinData.mpTrackTimer = new AutoTimer;
385 :
386 0 : if ( nFlags & StartTrackingFlags::ScrollRepeat )
387 0 : pSVData->maWinData.mpTrackTimer->SetTimeout( GetSettings().GetMouseSettings().GetScrollRepeat() );
388 : else
389 0 : pSVData->maWinData.mpTrackTimer->SetTimeout( GetSettings().GetMouseSettings().GetButtonStartRepeat() );
390 0 : pSVData->maWinData.mpTrackTimer->SetTimeoutHdl( LINK( this, Window, ImplTrackTimerHdl ) );
391 0 : pSVData->maWinData.mpTrackTimer->Start();
392 : }
393 :
394 0 : pSVData->maWinData.mpTrackWin = this;
395 0 : pSVData->maWinData.mnTrackFlags = nFlags;
396 0 : CaptureMouse();
397 0 : }
398 :
399 2 : void Window::EndTracking( TrackingEventFlags nFlags )
400 : {
401 2 : ImplSVData* pSVData = ImplGetSVData();
402 :
403 2 : if ( pSVData->maWinData.mpTrackWin.get() == this )
404 : {
405 : // due to DbgChkThis in brackets, as the window could be destroyed
406 : // in the handler
407 : {
408 :
409 0 : if ( pSVData->maWinData.mpTrackTimer )
410 : {
411 0 : delete pSVData->maWinData.mpTrackTimer;
412 0 : pSVData->maWinData.mpTrackTimer = NULL;
413 : }
414 :
415 0 : pSVData->maWinData.mpTrackWin = NULL;
416 0 : pSVData->maWinData.mnTrackFlags = StartTrackingFlags::NONE;
417 0 : ReleaseMouse();
418 : }
419 :
420 : // call EndTracking if required
421 0 : if ( !(nFlags & TrackingEventFlags::DontCallHdl) )
422 : {
423 0 : Point aMousePos( mpWindowImpl->mpFrameData->mnLastMouseX, mpWindowImpl->mpFrameData->mnLastMouseY );
424 0 : if( ImplIsAntiparallel() )
425 : {
426 : // - RTL - re-mirror frame pos at pChild
427 0 : const OutputDevice *pOutDev = GetOutDev();
428 0 : pOutDev->ReMirror( aMousePos );
429 : }
430 :
431 : MouseEvent aMEvt( ImplFrameToOutput( aMousePos ),
432 : mpWindowImpl->mpFrameData->mnClickCount, MouseEventModifiers::NONE,
433 : mpWindowImpl->mpFrameData->mnMouseCode,
434 0 : mpWindowImpl->mpFrameData->mnMouseCode );
435 0 : TrackingEvent aTEvt( aMEvt, nFlags | TrackingEventFlags::End );
436 0 : Tracking( aTEvt );
437 : }
438 : }
439 2 : }
440 :
441 90204 : bool Window::IsTracking() const
442 : {
443 90204 : return (ImplGetSVData()->maWinData.mpTrackWin == this);
444 : }
445 :
446 0 : void Window::StartAutoScroll( StartAutoScrollFlags nFlags )
447 : {
448 0 : ImplSVData* pSVData = ImplGetSVData();
449 :
450 0 : if ( pSVData->maWinData.mpAutoScrollWin.get() != this )
451 : {
452 0 : if ( pSVData->maWinData.mpAutoScrollWin )
453 0 : pSVData->maWinData.mpAutoScrollWin->EndAutoScroll();
454 : }
455 :
456 0 : pSVData->maWinData.mpAutoScrollWin = this;
457 0 : pSVData->maWinData.mnAutoScrollFlags = nFlags;
458 0 : pSVData->maAppData.mpWheelWindow = VclPtr<ImplWheelWindow>::Create( this );
459 0 : }
460 :
461 0 : void Window::EndAutoScroll()
462 : {
463 0 : ImplSVData* pSVData = ImplGetSVData();
464 :
465 0 : if ( pSVData->maWinData.mpAutoScrollWin.get() == this )
466 : {
467 0 : pSVData->maWinData.mpAutoScrollWin = NULL;
468 0 : pSVData->maWinData.mnAutoScrollFlags = StartAutoScrollFlags::NONE;
469 0 : pSVData->maAppData.mpWheelWindow->ImplStop();
470 0 : pSVData->maAppData.mpWheelWindow->doLazyDelete();
471 0 : pSVData->maAppData.mpWheelWindow = NULL;
472 : }
473 0 : }
474 :
475 8 : sal_uIntPtr Window::SaveFocus()
476 : {
477 8 : ImplSVData* pSVData = ImplGetSVData();
478 8 : if ( pSVData->maWinData.mpFocusWin )
479 : {
480 8 : ImplFocusDelData* pDelData = new ImplFocusDelData;
481 8 : pSVData->maWinData.mpFocusWin->ImplAddDel( pDelData );
482 8 : pDelData->mpFocusWin = pSVData->maWinData.mpFocusWin;
483 8 : return reinterpret_cast<sal_uIntPtr>(pDelData);
484 : }
485 : else
486 0 : return 0;
487 : }
488 :
489 16 : bool Window::EndSaveFocus( sal_uIntPtr nSaveId, bool bRestore )
490 : {
491 16 : if ( !nSaveId )
492 10 : return false;
493 : else
494 : {
495 6 : bool bOK = true;
496 6 : ImplFocusDelData* pDelData = reinterpret_cast<ImplFocusDelData*>(nSaveId);
497 6 : if ( !pDelData->IsDead() )
498 : {
499 6 : pDelData->mpFocusWin->ImplRemoveDel( pDelData );
500 6 : if ( bRestore )
501 6 : pDelData->mpFocusWin->GrabFocus();
502 : }
503 : else
504 0 : bOK = !bRestore;
505 6 : delete pDelData;
506 6 : return bOK;
507 : }
508 : }
509 :
510 26743 : void Window::SetZoom( const Fraction& rZoom )
511 : {
512 26743 : if ( mpWindowImpl && mpWindowImpl->maZoom != rZoom )
513 : {
514 54 : mpWindowImpl->maZoom = rZoom;
515 54 : CompatStateChanged( StateChangedType::Zoom );
516 : }
517 26743 : }
518 :
519 17258 : inline long WinFloatRound( double fVal )
520 : {
521 17258 : return( fVal > 0.0 ? (long) ( fVal + 0.5 ) : -(long) ( -fVal + 0.5 ) );
522 : }
523 :
524 160638 : void Window::SetZoomedPointFont(vcl::RenderContext& rRenderContext, const vcl::Font& rFont)
525 : {
526 160638 : const Fraction& rZoom = GetZoom();
527 160638 : if (rZoom.GetNumerator() != rZoom.GetDenominator())
528 : {
529 6471 : vcl::Font aFont(rFont);
530 6471 : Size aSize = aFont.GetSize();
531 6471 : double n = double(aSize.Width());
532 6471 : n *= double(rZoom.GetNumerator());
533 6471 : n /= double(rZoom.GetDenominator());
534 6471 : aSize.Width() = WinFloatRound(n);
535 6471 : n = double(aSize.Height());
536 6471 : n *= double(rZoom.GetNumerator());
537 6471 : n /= double(rZoom.GetDenominator());
538 6471 : aSize.Height() = WinFloatRound(n);
539 6471 : aFont.SetSize(aSize);
540 6471 : SetPointFont(rRenderContext, aFont);
541 :
542 : // Use another font if the representation is to be scaled,
543 : // and the actual font is not scalable
544 12942 : FontMetric aMetric = rRenderContext.GetFontMetric();
545 6471 : long nFontDiff = std::abs(rRenderContext.GetFont().GetSize().Height() - aMetric.GetSize().Height());
546 6471 : if ((aMetric.GetType() == TYPE_RASTER) && (nFontDiff >= 2))
547 : {
548 : DefaultFontType nType;
549 0 : if (aMetric.GetPitch() == PITCH_FIXED)
550 0 : nType = DefaultFontType::FIXED;
551 : else
552 0 : nType = DefaultFontType::UI_SANS;
553 0 : vcl::Font aTempFont = OutputDevice::GetDefaultFont(nType, rRenderContext.GetSettings().GetLanguageTag().getLanguageType(), GetDefaultFontFlags::NONE);
554 0 : aFont.SetName(aTempFont.GetName());
555 0 : SetPointFont(rRenderContext, aFont);
556 6471 : }
557 : }
558 : else
559 : {
560 154167 : SetPointFont(rRenderContext, rFont);
561 : }
562 160638 : }
563 :
564 49411 : long Window::CalcZoom( long nCalc ) const
565 : {
566 :
567 49411 : const Fraction& rZoom = GetZoom();
568 49411 : if ( rZoom.GetNumerator() != rZoom.GetDenominator() )
569 : {
570 4316 : double n = (double)nCalc;
571 4316 : n *= (double)rZoom.GetNumerator();
572 4316 : n /= (double)rZoom.GetDenominator();
573 4316 : nCalc = WinFloatRound( n );
574 : }
575 49411 : return nCalc;
576 : }
577 :
578 820 : void Window::SetControlFont()
579 : {
580 820 : if (mpWindowImpl && mpWindowImpl->mpControlFont)
581 : {
582 0 : delete mpWindowImpl->mpControlFont;
583 0 : mpWindowImpl->mpControlFont = NULL;
584 0 : CompatStateChanged(StateChangedType::ControlFont);
585 : }
586 820 : }
587 :
588 4528 : void Window::SetControlFont(const vcl::Font& rFont)
589 : {
590 4528 : if (rFont == vcl::Font())
591 : {
592 722 : SetControlFont();
593 722 : return;
594 : }
595 :
596 3806 : if (mpWindowImpl->mpControlFont)
597 : {
598 3288 : if (*mpWindowImpl->mpControlFont == rFont)
599 786 : return;
600 2502 : *mpWindowImpl->mpControlFont = rFont;
601 : }
602 : else
603 518 : mpWindowImpl->mpControlFont = new vcl::Font(rFont);
604 :
605 3020 : CompatStateChanged(StateChangedType::ControlFont);
606 : }
607 :
608 13803 : vcl::Font Window::GetControlFont() const
609 : {
610 13803 : if (mpWindowImpl->mpControlFont)
611 11875 : return *mpWindowImpl->mpControlFont;
612 : else
613 : {
614 1928 : vcl::Font aFont;
615 1928 : return aFont;
616 : }
617 : }
618 :
619 82837 : void Window::ApplyControlFont(vcl::RenderContext& rRenderContext, const vcl::Font& rFont)
620 : {
621 82837 : vcl::Font aFont(rFont);
622 82837 : if (IsControlFont())
623 7870 : aFont.Merge(GetControlFont());
624 82837 : SetZoomedPointFont(rRenderContext, aFont);
625 82837 : }
626 :
627 453 : void Window::SetControlForeground()
628 : {
629 453 : if (mpWindowImpl->mbControlForeground)
630 : {
631 0 : mpWindowImpl->maControlForeground = Color(COL_TRANSPARENT);
632 0 : mpWindowImpl->mbControlForeground = false;
633 0 : CompatStateChanged(StateChangedType::ControlForeground);
634 : }
635 453 : }
636 :
637 171 : void Window::SetControlForeground(const Color& rColor)
638 : {
639 171 : if (rColor.GetTransparency())
640 : {
641 0 : if (mpWindowImpl->mbControlForeground)
642 : {
643 0 : mpWindowImpl->maControlForeground = Color(COL_TRANSPARENT);
644 0 : mpWindowImpl->mbControlForeground = false;
645 0 : CompatStateChanged(StateChangedType::ControlForeground);
646 : }
647 : }
648 : else
649 : {
650 171 : if (mpWindowImpl->maControlForeground != rColor)
651 : {
652 126 : mpWindowImpl->maControlForeground = rColor;
653 126 : mpWindowImpl->mbControlForeground = true;
654 126 : CompatStateChanged(StateChangedType::ControlForeground);
655 : }
656 : }
657 171 : }
658 :
659 79805 : void Window::ApplyControlForeground(vcl::RenderContext& rRenderContext, const Color& rDefaultColor)
660 : {
661 79805 : Color aTextColor(rDefaultColor);
662 79805 : if (IsControlForeground())
663 6670 : aTextColor = GetControlForeground();
664 79805 : rRenderContext.SetTextColor(aTextColor);
665 79805 : }
666 :
667 1059 : void Window::SetControlBackground()
668 : {
669 1059 : if (mpWindowImpl->mbControlBackground)
670 : {
671 48 : mpWindowImpl->maControlBackground = Color(COL_TRANSPARENT);
672 48 : mpWindowImpl->mbControlBackground = false;
673 48 : CompatStateChanged(StateChangedType::ControlBackground);
674 : }
675 1059 : }
676 :
677 3608 : void Window::SetControlBackground(const Color& rColor)
678 : {
679 3608 : if (rColor.GetTransparency())
680 : {
681 0 : if (mpWindowImpl->mbControlBackground)
682 : {
683 0 : mpWindowImpl->maControlBackground = Color(COL_TRANSPARENT);
684 0 : mpWindowImpl->mbControlBackground = false;
685 0 : CompatStateChanged(StateChangedType::ControlBackground);
686 : }
687 : }
688 : else
689 : {
690 3608 : if (mpWindowImpl->maControlBackground != rColor)
691 : {
692 3608 : mpWindowImpl->maControlBackground = rColor;
693 3608 : mpWindowImpl->mbControlBackground = true;
694 3608 : CompatStateChanged(StateChangedType::ControlBackground);
695 : }
696 : }
697 3608 : }
698 :
699 23900 : void Window::ApplyControlBackground(vcl::RenderContext& rRenderContext, const Color& rDefaultColor)
700 : {
701 23900 : Color aColor(rDefaultColor);
702 23900 : if (IsControlBackground())
703 0 : aColor = GetControlBackground();
704 23900 : rRenderContext.SetBackground(aColor);
705 23900 : }
706 :
707 36857 : Size Window::CalcWindowSize( const Size& rOutSz ) const
708 : {
709 36857 : Size aSz = rOutSz;
710 36857 : aSz.Width() += mpWindowImpl->mnLeftBorder+mpWindowImpl->mnRightBorder;
711 36857 : aSz.Height() += mpWindowImpl->mnTopBorder+mpWindowImpl->mnBottomBorder;
712 36857 : return aSz;
713 : }
714 :
715 16453 : Size Window::CalcOutputSize( const Size& rWinSz ) const
716 : {
717 16453 : Size aSz = rWinSz;
718 16453 : aSz.Width() -= mpWindowImpl->mnLeftBorder+mpWindowImpl->mnRightBorder;
719 16453 : aSz.Height() -= mpWindowImpl->mnTopBorder+mpWindowImpl->mnBottomBorder;
720 16453 : return aSz;
721 : }
722 :
723 0 : vcl::Font Window::GetDrawPixelFont(OutputDevice* pDev) const
724 : {
725 0 : vcl::Font aFont = GetPointFont(*const_cast<Window*>(this));
726 0 : Size aFontSize = aFont.GetSize();
727 0 : MapMode aPtMapMode(MAP_POINT);
728 0 : aFontSize = pDev->LogicToPixel( aFontSize, aPtMapMode );
729 0 : aFont.SetSize( aFontSize );
730 0 : return aFont;
731 : }
732 :
733 6548 : long Window::GetDrawPixel( OutputDevice* pDev, long nPixels ) const
734 : {
735 6548 : long nP = nPixels;
736 6548 : if ( pDev->GetOutDevType() != OUTDEV_WINDOW )
737 : {
738 0 : MapMode aMap( MAP_100TH_MM );
739 0 : Size aSz( nP, 0 );
740 0 : aSz = PixelToLogic( aSz, aMap );
741 0 : aSz = pDev->LogicToPixel( aSz, aMap );
742 0 : nP = aSz.Width();
743 : }
744 6548 : return nP;
745 : }
746 :
747 0 : static void lcl_HandleScrollHelper( ScrollBar* pScrl, long nN, bool isMultiplyByLineSize )
748 : {
749 0 : if ( pScrl && nN && pScrl->IsEnabled() && pScrl->IsInputEnabled() && ! pScrl->IsInModalMode() )
750 : {
751 0 : long nNewPos = pScrl->GetThumbPos();
752 :
753 0 : if ( nN == -LONG_MAX )
754 0 : nNewPos += pScrl->GetPageSize();
755 0 : else if ( nN == LONG_MAX )
756 0 : nNewPos -= pScrl->GetPageSize();
757 : else
758 : {
759 : // allowing both chunked and continuous scrolling
760 0 : if(isMultiplyByLineSize){
761 0 : nN*=pScrl->GetLineSize();
762 : }
763 :
764 0 : const double fVal = (double)(nNewPos - nN);
765 :
766 0 : if ( fVal < LONG_MIN )
767 0 : nNewPos = LONG_MIN;
768 0 : else if ( fVal > LONG_MAX )
769 0 : nNewPos = LONG_MAX;
770 : else
771 0 : nNewPos = (long)fVal;
772 : }
773 :
774 0 : pScrl->DoScroll( nNewPos );
775 : }
776 :
777 0 : }
778 :
779 0 : bool Window::HandleScrollCommand( const CommandEvent& rCmd,
780 : ScrollBar* pHScrl, ScrollBar* pVScrl )
781 : {
782 0 : bool bRet = false;
783 :
784 0 : if ( pHScrl || pVScrl )
785 : {
786 0 : switch( rCmd.GetCommand() )
787 : {
788 : case CommandEventId::StartAutoScroll:
789 : {
790 0 : StartAutoScrollFlags nFlags = StartAutoScrollFlags::NONE;
791 0 : if ( pHScrl )
792 : {
793 0 : if ( (pHScrl->GetVisibleSize() < pHScrl->GetRangeMax()) &&
794 0 : pHScrl->IsEnabled() && pHScrl->IsInputEnabled() && ! pHScrl->IsInModalMode() )
795 0 : nFlags |= StartAutoScrollFlags::Horz;
796 : }
797 0 : if ( pVScrl )
798 : {
799 0 : if ( (pVScrl->GetVisibleSize() < pVScrl->GetRangeMax()) &&
800 0 : pVScrl->IsEnabled() && pVScrl->IsInputEnabled() && ! pVScrl->IsInModalMode() )
801 0 : nFlags |= StartAutoScrollFlags::Vert;
802 : }
803 :
804 0 : if ( nFlags != StartAutoScrollFlags::NONE )
805 : {
806 0 : StartAutoScroll( nFlags );
807 0 : bRet = true;
808 : }
809 : }
810 0 : break;
811 :
812 : case CommandEventId::Wheel:
813 : {
814 0 : const CommandWheelData* pData = rCmd.GetWheelData();
815 :
816 0 : if ( pData && (CommandWheelMode::SCROLL == pData->GetMode()) )
817 : {
818 0 : if (!pData->IsDeltaPixel())
819 : {
820 0 : sal_uLong nScrollLines = pData->GetScrollLines();
821 : long nLines;
822 0 : if ( nScrollLines == COMMAND_WHEEL_PAGESCROLL )
823 : {
824 0 : if ( pData->GetDelta() < 0 )
825 0 : nLines = -LONG_MAX;
826 : else
827 0 : nLines = LONG_MAX;
828 : }
829 : else
830 0 : nLines = pData->GetNotchDelta() * (long)nScrollLines;
831 0 : if ( nLines )
832 : {
833 : ImplHandleScroll( NULL,
834 : 0L,
835 0 : pData->IsHorz() ? pHScrl : pVScrl,
836 0 : nLines );
837 0 : bRet = true;
838 : }
839 : }
840 : else
841 : {
842 : // Mobile / touch scrolling section
843 0 : const Point & deltaPoint = rCmd.GetMousePosPixel();
844 :
845 0 : double deltaXInPixels = double(deltaPoint.X());
846 0 : double deltaYInPixels = double(deltaPoint.Y());
847 0 : Size winSize = this->GetOutputSizePixel();
848 :
849 0 : if(pHScrl)
850 : {
851 0 : double visSizeX = double(pHScrl->GetVisibleSize());
852 0 : double ratioX = deltaXInPixels / double(winSize.getWidth());
853 0 : long deltaXInLogic = long(visSizeX * ratioX);
854 : // Touch need to work by pixels. Did not apply this to
855 : // Android, as android code may require adaptations
856 : // to work with this scrolling code
857 : #ifndef IOS
858 0 : long lineSizeX = pHScrl->GetLineSize();
859 :
860 0 : if(lineSizeX)
861 : {
862 0 : deltaXInLogic /= lineSizeX;
863 : }
864 : else
865 : {
866 0 : deltaXInLogic = 0;
867 : }
868 : #endif
869 0 : if ( deltaXInLogic)
870 : {
871 : #ifndef IOS
872 0 : bool isMultiplyByLineSize = true;
873 : #else
874 : bool isMultiplyByLineSize = false;
875 : #endif
876 0 : lcl_HandleScrollHelper( pHScrl, deltaXInLogic, isMultiplyByLineSize );
877 0 : bRet = true;
878 : }
879 : }
880 0 : if(pVScrl)
881 : {
882 0 : double visSizeY = double(pVScrl->GetVisibleSize());
883 0 : double ratioY = deltaYInPixels / double(winSize.getHeight());
884 0 : long deltaYInLogic = long(visSizeY * ratioY);
885 :
886 : // Touch need to work by pixels. Did not apply this to
887 : // Android, as android code may require adaptations
888 : // to work with this scrolling code
889 : #ifndef IOS
890 0 : long lineSizeY = pVScrl->GetLineSize();
891 0 : if(lineSizeY)
892 : {
893 0 : deltaYInLogic /= lineSizeY;
894 : }
895 : else
896 : {
897 0 : deltaYInLogic = 0;
898 : }
899 : #endif
900 0 : if ( deltaYInLogic )
901 : {
902 : #ifndef IOS
903 0 : bool isMultiplyByLineSize = true;
904 : #else
905 : bool isMultiplyByLineSize = false;
906 : #endif
907 0 : lcl_HandleScrollHelper( pVScrl, deltaYInLogic, isMultiplyByLineSize );
908 :
909 0 : bRet = true;
910 : }
911 : }
912 : }
913 : }
914 : }
915 0 : break;
916 :
917 : case CommandEventId::AutoScroll:
918 : {
919 0 : const CommandScrollData* pData = rCmd.GetAutoScrollData();
920 0 : if ( pData && (pData->GetDeltaX() || pData->GetDeltaY()) )
921 : {
922 : ImplHandleScroll( pHScrl, pData->GetDeltaX(),
923 0 : pVScrl, pData->GetDeltaY() );
924 0 : bRet = true;
925 : }
926 : }
927 0 : break;
928 :
929 : default:
930 0 : break;
931 : }
932 : }
933 :
934 0 : return bRet;
935 : }
936 :
937 : // Note that when called for CommandEventId::Wheel above, despite its name,
938 : // pVScrl isn't necessarily the vertical scroll bar. Depending on
939 : // whether the scroll is horizontal or vertical, it is either the
940 : // horizontal or vertical scroll bar. nY is correspondingly either
941 : // the horizontal or vertical scroll amount.
942 :
943 0 : void Window::ImplHandleScroll( ScrollBar* pHScrl, long nX,
944 : ScrollBar* pVScrl, long nY )
945 : {
946 0 : lcl_HandleScrollHelper( pHScrl, nX, true );
947 0 : lcl_HandleScrollHelper( pVScrl, nY, true );
948 0 : }
949 :
950 548718 : DockingManager* Window::GetDockingManager()
951 : {
952 548718 : return ImplGetDockingManager();
953 : }
954 :
955 9522 : void Window::EnableDocking( bool bEnable )
956 : {
957 : // update list of dockable windows
958 9522 : if( bEnable )
959 9522 : ImplGetDockingManager()->AddWindow( this );
960 : else
961 0 : ImplGetDockingManager()->RemoveWindow( this );
962 9522 : }
963 :
964 : // retrieves the list of owner draw decorated windows for this window hiearchy
965 0 : ::std::vector<VclPtr<vcl::Window> >& Window::ImplGetOwnerDrawList()
966 : {
967 0 : return ImplGetTopmostFrameWindow()->mpWindowImpl->mpFrameData->maOwnerDrawList;
968 : }
969 :
970 50498 : void Window::SetHelpId( const OString& rHelpId )
971 : {
972 50498 : mpWindowImpl->maHelpId = rHelpId;
973 50498 : }
974 :
975 182779 : const OString& Window::GetHelpId() const
976 : {
977 182779 : return mpWindowImpl->maHelpId;
978 : }
979 :
980 7457 : void Window::SetUniqueId( const OString& rUniqueId )
981 : {
982 7457 : mpWindowImpl->maUniqId = rUniqueId;
983 7457 : }
984 :
985 82 : const OString& Window::GetUniqueId() const
986 : {
987 82 : return mpWindowImpl->maUniqId;
988 : }
989 :
990 : // --------- old inline methods ---------------
991 :
992 1080641 : vcl::Window* Window::ImplGetWindow()
993 : {
994 1080641 : if ( mpWindowImpl->mpClientWindow )
995 840248 : return mpWindowImpl->mpClientWindow;
996 : else
997 240393 : return this;
998 : }
999 :
1000 0 : ImplFrameData* Window::ImplGetFrameData()
1001 : {
1002 0 : return mpWindowImpl ? mpWindowImpl->mpFrameData : NULL;
1003 : }
1004 :
1005 153534 : SalFrame* Window::ImplGetFrame() const
1006 : {
1007 153534 : return mpWindowImpl ? mpWindowImpl->mpFrame : NULL;
1008 : }
1009 :
1010 5250508 : vcl::Window* Window::ImplGetParent() const
1011 : {
1012 5250508 : return mpWindowImpl ? mpWindowImpl->mpParent.get() : NULL;
1013 : }
1014 :
1015 66759 : vcl::Window* Window::ImplGetClientWindow() const
1016 : {
1017 66759 : return mpWindowImpl ? mpWindowImpl->mpClientWindow.get() : NULL;
1018 : }
1019 :
1020 207845 : vcl::Window* Window::ImplGetBorderWindow() const
1021 : {
1022 207845 : return mpWindowImpl ? mpWindowImpl->mpBorderWindow.get() : NULL;
1023 : }
1024 :
1025 374103 : vcl::Window* Window::ImplGetFirstOverlapWindow()
1026 : {
1027 374103 : if ( mpWindowImpl->mbOverlapWin )
1028 6938 : return this;
1029 : else
1030 367165 : return mpWindowImpl->mpOverlapWindow;
1031 : }
1032 :
1033 0 : const vcl::Window* Window::ImplGetFirstOverlapWindow() const
1034 : {
1035 0 : if ( mpWindowImpl->mbOverlapWin )
1036 0 : return this;
1037 : else
1038 0 : return mpWindowImpl->mpOverlapWindow;
1039 : }
1040 :
1041 20809 : vcl::Window* Window::ImplGetFrameWindow() const
1042 : {
1043 20809 : return mpWindowImpl ? mpWindowImpl->mpFrameWindow.get() : NULL;
1044 : }
1045 :
1046 3396 : bool Window::IsDockingWindow() const
1047 : {
1048 3396 : return mpWindowImpl && mpWindowImpl->mbDockWin;
1049 : }
1050 :
1051 121 : bool Window::ImplIsFloatingWindow() const
1052 : {
1053 121 : return mpWindowImpl && mpWindowImpl->mbFloatWin;
1054 : }
1055 :
1056 0 : bool Window::ImplIsSplitter() const
1057 : {
1058 0 : return mpWindowImpl && mpWindowImpl->mbSplitter;
1059 : }
1060 :
1061 4482 : bool Window::ImplIsPushButton() const
1062 : {
1063 4482 : return mpWindowImpl && mpWindowImpl->mbPushButton;
1064 : }
1065 :
1066 8190546 : bool Window::ImplIsOverlapWindow() const
1067 : {
1068 8190546 : return mpWindowImpl && mpWindowImpl->mbOverlapWin;
1069 : }
1070 :
1071 0 : void Window::ImplSetMouseTransparent( bool bTransparent )
1072 : {
1073 0 : if (mpWindowImpl)
1074 0 : mpWindowImpl->mbMouseTransparent = bTransparent;
1075 0 : }
1076 :
1077 8 : Point Window::ImplOutputToFrame( const Point& rPos )
1078 : {
1079 8 : return Point( rPos.X()+mnOutOffX, rPos.Y()+mnOutOffY );
1080 : }
1081 :
1082 42899 : Point Window::ImplFrameToOutput( const Point& rPos )
1083 : {
1084 42899 : return Point( rPos.X()-mnOutOffX, rPos.Y()-mnOutOffY );
1085 : }
1086 :
1087 5598 : void Window::SetCompoundControl( bool bCompound )
1088 : {
1089 5598 : if (mpWindowImpl)
1090 5598 : mpWindowImpl->mbCompoundControl = bCompound;
1091 5598 : }
1092 :
1093 299 : void Window::IncrementLockCount()
1094 : {
1095 299 : mpWindowImpl->mnLockCount++;
1096 299 : }
1097 :
1098 299 : void Window::DecrementLockCount()
1099 : {
1100 299 : mpWindowImpl->mnLockCount--;
1101 299 : }
1102 :
1103 4028191 : WinBits Window::GetStyle() const
1104 : {
1105 4028191 : return mpWindowImpl ? mpWindowImpl->mnStyle : 0;
1106 : }
1107 :
1108 14037 : WinBits Window::GetPrevStyle() const
1109 : {
1110 14037 : return mpWindowImpl ? mpWindowImpl->mnPrevStyle : 0;
1111 : }
1112 :
1113 8 : WinBits Window::GetExtendedStyle() const
1114 : {
1115 8 : return mpWindowImpl ? mpWindowImpl->mnExtendedStyle : 0;
1116 : }
1117 :
1118 26139 : void Window::SetType( WindowType nType )
1119 : {
1120 26139 : if (mpWindowImpl)
1121 26139 : mpWindowImpl->mnType = nType;
1122 26139 : }
1123 :
1124 9690445 : WindowType Window::GetType() const
1125 : {
1126 9690445 : if (mpWindowImpl)
1127 9690445 : return mpWindowImpl->mnType;
1128 : else
1129 0 : return 0;
1130 : }
1131 :
1132 0 : Dialog* Window::GetParentDialog() const
1133 : {
1134 0 : const vcl::Window *pWindow = this;
1135 :
1136 0 : while( pWindow )
1137 : {
1138 0 : if( pWindow->IsDialog() )
1139 0 : break;
1140 :
1141 0 : pWindow = pWindow->GetParent();
1142 : }
1143 :
1144 0 : return const_cast<Dialog *>(dynamic_cast<const Dialog*>(pWindow));
1145 : }
1146 :
1147 375460 : bool Window::IsSystemWindow() const
1148 : {
1149 375460 : return mpWindowImpl && mpWindowImpl->mbSysWin;
1150 : }
1151 :
1152 470 : bool Window::IsDialog() const
1153 : {
1154 470 : return mpWindowImpl && mpWindowImpl->mbDialog;
1155 : }
1156 :
1157 738 : bool Window::IsMenuFloatingWindow() const
1158 : {
1159 738 : return mpWindowImpl && mpWindowImpl->mbMenuFloatingWindow;
1160 : }
1161 :
1162 182 : bool Window::IsToolbarFloatingWindow() const
1163 : {
1164 182 : return mpWindowImpl && mpWindowImpl->mbToolbarFloatingWindow;
1165 : }
1166 :
1167 23693 : void Window::EnableAllResize( bool bEnable )
1168 : {
1169 23693 : mpWindowImpl->mbAllResize = bEnable;
1170 23693 : }
1171 :
1172 54448 : void Window::EnableChildTransparentMode( bool bEnable )
1173 : {
1174 54448 : mpWindowImpl->mbChildTransparent = bEnable;
1175 54448 : }
1176 :
1177 25160 : bool Window::IsChildTransparentModeEnabled() const
1178 : {
1179 25160 : return mpWindowImpl && mpWindowImpl->mbChildTransparent;
1180 : }
1181 :
1182 0 : bool Window::IsMouseTransparent() const
1183 : {
1184 0 : return mpWindowImpl && mpWindowImpl->mbMouseTransparent;
1185 : }
1186 :
1187 1157378 : bool Window::IsPaintTransparent() const
1188 : {
1189 1157378 : return mpWindowImpl && mpWindowImpl->mbPaintTransparent;
1190 : }
1191 :
1192 8 : void Window::SetDialogControlStart( bool bStart )
1193 : {
1194 8 : mpWindowImpl->mbDlgCtrlStart = bStart;
1195 8 : }
1196 :
1197 9440 : bool Window::IsDialogControlStart() const
1198 : {
1199 9440 : return mpWindowImpl && mpWindowImpl->mbDlgCtrlStart;
1200 : }
1201 :
1202 3309 : void Window::SetDialogControlFlags( DialogControlFlags nFlags )
1203 : {
1204 3309 : mpWindowImpl->mnDlgCtrlFlags = nFlags;
1205 3309 : }
1206 :
1207 14892 : DialogControlFlags Window::GetDialogControlFlags() const
1208 : {
1209 14892 : return mpWindowImpl->mnDlgCtrlFlags;
1210 : }
1211 :
1212 21592 : const InputContext& Window::GetInputContext() const
1213 : {
1214 21592 : return mpWindowImpl->maInputContext;
1215 : }
1216 :
1217 161384 : bool Window::IsControlFont() const
1218 : {
1219 161384 : return (mpWindowImpl->mpControlFont != 0);
1220 : }
1221 :
1222 8988 : Color Window::GetControlForeground() const
1223 : {
1224 8988 : return mpWindowImpl->maControlForeground;
1225 : }
1226 :
1227 166004 : bool Window::IsControlForeground() const
1228 : {
1229 166004 : return mpWindowImpl->mbControlForeground;
1230 : }
1231 :
1232 4444 : Color Window::GetControlBackground() const
1233 : {
1234 4444 : return mpWindowImpl->maControlBackground;
1235 : }
1236 :
1237 267119 : bool Window::IsControlBackground() const
1238 : {
1239 267119 : return mpWindowImpl->mbControlBackground;
1240 : }
1241 :
1242 127549 : bool Window::IsInPaint() const
1243 : {
1244 127549 : return mpWindowImpl && mpWindowImpl->mbInPaint;
1245 : }
1246 :
1247 22446958 : vcl::Window* Window::GetParent() const
1248 : {
1249 22446958 : return mpWindowImpl ? mpWindowImpl->mpRealParent.get() : NULL;
1250 : }
1251 :
1252 1506650 : bool Window::IsVisible() const
1253 : {
1254 1506650 : return mpWindowImpl && mpWindowImpl->mbVisible;
1255 : }
1256 :
1257 3075467 : bool Window::IsReallyVisible() const
1258 : {
1259 3075467 : return mpWindowImpl && mpWindowImpl->mbReallyVisible;
1260 : }
1261 :
1262 131413 : bool Window::IsReallyShown() const
1263 : {
1264 131413 : return mpWindowImpl && mpWindowImpl->mbReallyShown;
1265 : }
1266 :
1267 0 : bool Window::IsInInitShow() const
1268 : {
1269 0 : return mpWindowImpl->mbInInitShow;
1270 : }
1271 :
1272 152845 : bool Window::IsEnabled() const
1273 : {
1274 152845 : return mpWindowImpl && !mpWindowImpl->mbDisabled;
1275 : }
1276 :
1277 36951 : bool Window::IsInputEnabled() const
1278 : {
1279 36951 : return mpWindowImpl && !mpWindowImpl->mbInputDisabled;
1280 : }
1281 :
1282 0 : bool Window::IsAlwaysEnableInput() const
1283 : {
1284 0 : return mpWindowImpl->meAlwaysInputMode == AlwaysInputEnabled;
1285 : }
1286 :
1287 3656 : ActivateModeFlags Window::GetActivateMode() const
1288 : {
1289 3656 : return mpWindowImpl->mnActivateMode;
1290 :
1291 : }
1292 :
1293 0 : bool Window::IsAlwaysOnTopEnabled() const
1294 : {
1295 0 : return mpWindowImpl->mbAlwaysOnTop;
1296 : }
1297 :
1298 0 : bool Window::IsDefaultPos() const
1299 : {
1300 0 : return mpWindowImpl->mbDefPos;
1301 : }
1302 :
1303 205 : bool Window::IsDefaultSize() const
1304 : {
1305 205 : return mpWindowImpl->mbDefSize;
1306 : }
1307 :
1308 30115 : void Window::EnablePaint( bool bEnable )
1309 : {
1310 30115 : mpWindowImpl->mbPaintDisabled = !bEnable;
1311 30115 : }
1312 :
1313 90900 : bool Window::IsPaintEnabled() const
1314 : {
1315 90900 : return !mpWindowImpl->mbPaintDisabled;
1316 : }
1317 :
1318 592485 : bool Window::IsUpdateMode() const
1319 : {
1320 592485 : return !mpWindowImpl->mbNoUpdate;
1321 : }
1322 :
1323 96 : void Window::SetParentUpdateMode( bool bUpdate )
1324 : {
1325 96 : mpWindowImpl->mbNoParentUpdate = !bUpdate;
1326 96 : }
1327 :
1328 35457 : bool Window::IsActive() const
1329 : {
1330 35457 : return mpWindowImpl->mbActive;
1331 : }
1332 :
1333 3669 : GetFocusFlags Window::GetGetFocusFlags() const
1334 : {
1335 3669 : return mpWindowImpl->mnGetFocusFlags;
1336 : }
1337 :
1338 40822 : bool Window::IsCompoundControl() const
1339 : {
1340 40822 : return mpWindowImpl->mbCompoundControl;
1341 : }
1342 :
1343 328 : bool Window::IsWait() const
1344 : {
1345 328 : return (mpWindowImpl->mnWaitCount != 0);
1346 : }
1347 :
1348 32265 : vcl::Cursor* Window::GetCursor() const
1349 : {
1350 32265 : if (!mpWindowImpl)
1351 0 : return NULL;
1352 32265 : return mpWindowImpl->mpCursor;
1353 : }
1354 :
1355 210748 : const Fraction& Window::GetZoom() const
1356 : {
1357 210748 : return mpWindowImpl->maZoom;
1358 : }
1359 :
1360 1408 : bool Window::IsZoom() const
1361 : {
1362 1408 : return mpWindowImpl->maZoom.GetNumerator() != mpWindowImpl->maZoom.GetDenominator();
1363 : }
1364 :
1365 3020 : void Window::SetHelpText( const OUString& rHelpText )
1366 : {
1367 3020 : mpWindowImpl->maHelpText = rHelpText;
1368 3020 : mpWindowImpl->mbHelpTextDynamic = true;
1369 3020 : }
1370 :
1371 22588 : void Window::SetQuickHelpText( const OUString& rHelpText )
1372 : {
1373 22588 : if (mpWindowImpl)
1374 22588 : mpWindowImpl->maQuickHelpText = rHelpText;
1375 22588 : }
1376 :
1377 7968 : const OUString& Window::GetQuickHelpText() const
1378 : {
1379 7968 : return mpWindowImpl->maQuickHelpText;
1380 : }
1381 :
1382 50 : void Window::SetData( void* pNewData )
1383 : {
1384 50 : mpWindowImpl->mpUserData = pNewData;
1385 50 : }
1386 :
1387 0 : void* Window::GetData() const
1388 : {
1389 0 : return mpWindowImpl->mpUserData;
1390 : }
1391 :
1392 0 : bool Window::IsCreatedWithToolkit() const
1393 : {
1394 0 : return mpWindowImpl->mbCreatedWithToolkit;
1395 : }
1396 :
1397 29910 : void Window::SetCreatedWithToolkit( bool b )
1398 : {
1399 29910 : mpWindowImpl->mbCreatedWithToolkit = b;
1400 29910 : }
1401 :
1402 3 : const Pointer& Window::GetPointer() const
1403 : {
1404 3 : return mpWindowImpl->maPointer;
1405 : }
1406 :
1407 853800 : VCLXWindow* Window::GetWindowPeer() const
1408 : {
1409 853800 : return mpWindowImpl ? mpWindowImpl->mpVCLXWindow : NULL;
1410 : }
1411 :
1412 41506 : void Window::SetPosPixel( const Point& rNewPos )
1413 : {
1414 41506 : setPosSizePixel( rNewPos.X(), rNewPos.Y(), 0, 0, PosSizeFlags::Pos );
1415 41506 : }
1416 :
1417 142205 : void Window::SetSizePixel( const Size& rNewSize )
1418 : {
1419 : setPosSizePixel( 0, 0, rNewSize.Width(), rNewSize.Height(),
1420 142205 : PosSizeFlags::Size );
1421 142205 : }
1422 :
1423 295021 : void Window::SetPosSizePixel( const Point& rNewPos, const Size& rNewSize )
1424 : {
1425 : setPosSizePixel( rNewPos.X(), rNewPos.Y(),
1426 : rNewSize.Width(), rNewSize.Height(),
1427 295021 : PosSizeFlags::PosSize );
1428 295021 : }
1429 :
1430 34936 : void Window::SetOutputSizePixel( const Size& rNewSize )
1431 : {
1432 34936 : SetSizePixel( Size( rNewSize.Width()+mpWindowImpl->mnLeftBorder+mpWindowImpl->mnRightBorder,
1433 69872 : rNewSize.Height()+mpWindowImpl->mnTopBorder+mpWindowImpl->mnBottomBorder ) );
1434 34936 : }
1435 :
1436 : //When a widget wants to renegotiate layout, get toplevel parent dialog and call
1437 : //resize on it. Mark all intermediate containers (or container-alike) widgets
1438 : //as dirty for the size remains unchanged, but layout changed circumstances
1439 : namespace
1440 : {
1441 1635868 : bool queue_ungrouped_resize(vcl::Window *pOrigWindow)
1442 : {
1443 1635868 : bool bSomeoneCares = false;
1444 :
1445 1635868 : vcl::Window *pWindow = pOrigWindow->GetParent();
1446 1635868 : if (pWindow)
1447 : {
1448 1589656 : if (isContainerWindow(*pWindow))
1449 : {
1450 258830 : bSomeoneCares = true;
1451 : }
1452 1330826 : else if (pWindow->GetType() == WINDOW_TABCONTROL)
1453 : {
1454 82 : bSomeoneCares = true;
1455 : }
1456 1589656 : pWindow->queue_resize();
1457 : }
1458 :
1459 1635868 : return bSomeoneCares;
1460 : }
1461 : }
1462 :
1463 1251058 : void Window::InvalidateSizeCache()
1464 : {
1465 1251058 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1466 1251058 : pWindowImpl->mnOptimalWidthCache = -1;
1467 1251058 : pWindowImpl->mnOptimalHeightCache = -1;
1468 1251058 : }
1469 :
1470 1599698 : void Window::queue_resize(StateChangedType eReason)
1471 : {
1472 1599698 : if (IsDisposed())
1473 1599698 : return;
1474 :
1475 1599698 : bool bSomeoneCares = queue_ungrouped_resize(this);
1476 :
1477 1599698 : if (eReason != StateChangedType::Visible)
1478 : {
1479 1249017 : InvalidateSizeCache();
1480 : }
1481 :
1482 1599698 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1483 1599698 : if (pWindowImpl->m_xSizeGroup && pWindowImpl->m_xSizeGroup->get_mode() != VCL_SIZE_GROUP_NONE)
1484 : {
1485 12512 : std::set<VclPtr<vcl::Window> > &rWindows = pWindowImpl->m_xSizeGroup->get_widgets();
1486 61194 : for (auto aI = rWindows.begin(), aEnd = rWindows.end(); aI != aEnd; ++aI)
1487 : {
1488 48682 : vcl::Window *pOther = *aI;
1489 48682 : if (pOther == this)
1490 12512 : continue;
1491 36170 : queue_ungrouped_resize(pOther);
1492 : }
1493 : }
1494 :
1495 1599698 : if (bSomeoneCares && !mpWindowImpl->mbInDispose)
1496 : {
1497 : //fdo#57090 force a resync of the borders of the borderwindow onto this
1498 : //window in case they have changed
1499 199592 : vcl::Window* pBorderWindow = ImplGetBorderWindow();
1500 199592 : if (pBorderWindow)
1501 12411 : pBorderWindow->Resize();
1502 : }
1503 : }
1504 :
1505 : namespace
1506 : {
1507 6161 : VclAlign toAlign(const OString &rValue)
1508 : {
1509 6161 : VclAlign eRet = VCL_ALIGN_FILL;
1510 :
1511 6161 : if (rValue == "fill")
1512 0 : eRet = VCL_ALIGN_FILL;
1513 6161 : else if (rValue == "start")
1514 791 : eRet = VCL_ALIGN_START;
1515 5370 : else if (rValue == "end")
1516 1165 : eRet = VCL_ALIGN_END;
1517 4205 : else if (rValue == "center")
1518 4205 : eRet = VCL_ALIGN_CENTER;
1519 6161 : return eRet;
1520 : }
1521 : }
1522 :
1523 0 : bool Window::set_font_attribute(const OString &rKey, const OString &rValue)
1524 : {
1525 0 : if (rKey == "weight")
1526 : {
1527 0 : vcl::Font aFont(GetControlFont());
1528 0 : if (rValue == "thin")
1529 0 : aFont.SetWeight(WEIGHT_THIN);
1530 0 : else if (rValue == "ultralight")
1531 0 : aFont.SetWeight(WEIGHT_ULTRALIGHT);
1532 0 : else if (rValue == "light")
1533 0 : aFont.SetWeight(WEIGHT_LIGHT);
1534 0 : else if (rValue == "book")
1535 0 : aFont.SetWeight(WEIGHT_SEMILIGHT);
1536 0 : else if (rValue == "normal")
1537 0 : aFont.SetWeight(WEIGHT_NORMAL);
1538 0 : else if (rValue == "medium")
1539 0 : aFont.SetWeight(WEIGHT_MEDIUM);
1540 0 : else if (rValue == "semibold")
1541 0 : aFont.SetWeight(WEIGHT_SEMIBOLD);
1542 0 : else if (rValue == "bold")
1543 0 : aFont.SetWeight(WEIGHT_BOLD);
1544 0 : else if (rValue == "ultrabold")
1545 0 : aFont.SetWeight(WEIGHT_ULTRABOLD);
1546 : else
1547 0 : aFont.SetWeight(WEIGHT_BLACK);
1548 0 : SetControlFont(aFont);
1549 : }
1550 0 : else if (rKey == "style")
1551 : {
1552 0 : vcl::Font aFont(GetControlFont());
1553 0 : if (rValue == "normal")
1554 0 : aFont.SetItalic(ITALIC_NONE);
1555 0 : else if (rValue == "oblique")
1556 0 : aFont.SetItalic(ITALIC_OBLIQUE);
1557 0 : else if (rValue == "italic")
1558 0 : aFont.SetItalic(ITALIC_NORMAL);
1559 0 : SetControlFont(aFont);
1560 : }
1561 0 : else if (rKey == "underline")
1562 : {
1563 0 : vcl::Font aFont(GetControlFont());
1564 0 : aFont.SetUnderline(toBool(rValue) ? UNDERLINE_SINGLE : UNDERLINE_NONE);
1565 0 : SetControlFont(aFont);
1566 : }
1567 0 : else if (rKey == "size")
1568 : {
1569 0 : vcl::Font aFont(GetControlFont());
1570 0 : sal_Int32 nHeight = rValue.toInt32() / 1000;
1571 0 : aFont.SetHeight(nHeight);
1572 0 : SetControlFont(aFont);
1573 : }
1574 : else
1575 : {
1576 : SAL_INFO("vcl.layout", "unhandled font attribute: " << rKey.getStr());
1577 0 : return false;
1578 : }
1579 0 : return true;
1580 : }
1581 :
1582 96933 : bool Window::set_property(const OString &rKey, const OString &rValue)
1583 : {
1584 96933 : if ((rKey == "label") || (rKey == "title") || (rKey == "text") )
1585 : {
1586 3770 : SetText(OStringToOUString(VclBuilder::convertMnemonicMarkup(rValue), RTL_TEXTENCODING_UTF8));
1587 : }
1588 93163 : else if (rKey == "visible")
1589 26179 : Show(toBool(rValue));
1590 66984 : else if (rKey == "sensitive")
1591 0 : Enable(toBool(rValue));
1592 66984 : else if (rKey == "resizable")
1593 : {
1594 0 : WinBits nBits = GetStyle();
1595 0 : nBits &= ~(WB_SIZEABLE);
1596 0 : if (toBool(rValue))
1597 0 : nBits |= WB_SIZEABLE;
1598 0 : SetStyle(nBits);
1599 : }
1600 66984 : else if (rKey == "xalign")
1601 : {
1602 1910 : WinBits nBits = GetStyle();
1603 1910 : nBits &= ~(WB_LEFT | WB_CENTER | WB_RIGHT);
1604 :
1605 1910 : float f = rValue.toFloat();
1606 1910 : if (f == 0.0)
1607 1910 : nBits |= WB_LEFT;
1608 0 : else if (f == 1.0)
1609 0 : nBits |= WB_RIGHT;
1610 0 : else if (f == 0.5)
1611 0 : nBits |= WB_CENTER;
1612 :
1613 1910 : SetStyle(nBits);
1614 : }
1615 65074 : else if (rKey == "justification")
1616 : {
1617 0 : WinBits nBits = GetStyle();
1618 0 : nBits &= ~(WB_LEFT | WB_CENTER | WB_RIGHT);
1619 :
1620 0 : if (rValue == "left")
1621 0 : nBits |= WB_LEFT;
1622 0 : else if (rValue == "right")
1623 0 : nBits |= WB_RIGHT;
1624 0 : else if (rValue == "center")
1625 0 : nBits |= WB_CENTER;
1626 :
1627 0 : SetStyle(nBits);
1628 : }
1629 65074 : else if (rKey == "yalign")
1630 : {
1631 0 : WinBits nBits = GetStyle();
1632 0 : nBits &= ~(WB_TOP | WB_VCENTER | WB_BOTTOM);
1633 :
1634 0 : float f = rValue.toFloat();
1635 0 : if (f == 0.0)
1636 0 : nBits |= WB_TOP;
1637 0 : else if (f == 1.0)
1638 0 : nBits |= WB_BOTTOM;
1639 0 : else if (f == 0.5)
1640 0 : nBits |= WB_CENTER;
1641 :
1642 0 : SetStyle(nBits);
1643 : }
1644 65074 : else if (rKey == "wrap")
1645 : {
1646 0 : WinBits nBits = GetStyle();
1647 0 : nBits &= ~(WB_WORDBREAK);
1648 0 : if (toBool(rValue))
1649 0 : nBits |= WB_WORDBREAK;
1650 0 : SetStyle(nBits);
1651 : }
1652 65074 : else if (rKey == "height-request")
1653 0 : set_height_request(rValue.toInt32());
1654 65074 : else if (rKey == "width-request")
1655 3 : set_width_request(rValue.toInt32());
1656 65071 : else if (rKey == "hexpand")
1657 3604 : set_hexpand(toBool(rValue));
1658 61467 : else if (rKey == "vexpand")
1659 57 : set_vexpand(toBool(rValue));
1660 61410 : else if (rKey == "halign")
1661 4320 : set_halign(toAlign(rValue));
1662 57090 : else if (rKey == "valign")
1663 1841 : set_valign(toAlign(rValue));
1664 55249 : else if (rKey == "tooltip-markup")
1665 1681 : SetQuickHelpText(OStringToOUString(rValue, RTL_TEXTENCODING_UTF8));
1666 53568 : else if (rKey == "tooltip-text")
1667 5701 : SetQuickHelpText(OStringToOUString(rValue, RTL_TEXTENCODING_UTF8));
1668 47867 : else if (rKey == "border-width")
1669 1638 : set_border_width(rValue.toInt32());
1670 46229 : else if (rKey == "margin-left")
1671 14 : set_margin_left(rValue.toInt32());
1672 46215 : else if (rKey == "margin-right")
1673 13 : set_margin_right(rValue.toInt32());
1674 46202 : else if (rKey == "margin-top")
1675 4 : set_margin_top(rValue.toInt32());
1676 46198 : else if (rKey == "margin-bottom")
1677 4 : set_margin_bottom(rValue.toInt32());
1678 46194 : else if (rKey == "hscrollbar-policy")
1679 : {
1680 0 : WinBits nBits = GetStyle();
1681 0 : nBits &= ~(WB_AUTOHSCROLL|WB_HSCROLL);
1682 0 : if (rValue == "always")
1683 0 : nBits |= WB_HSCROLL;
1684 0 : else if (rValue == "automatic")
1685 0 : nBits |= WB_AUTOHSCROLL;
1686 0 : SetStyle(nBits);
1687 : }
1688 46194 : else if (rKey == "vscrollbar-policy")
1689 : {
1690 0 : WinBits nBits = GetStyle();
1691 0 : nBits &= ~(WB_AUTOVSCROLL|WB_VSCROLL);
1692 0 : if (rValue == "always")
1693 0 : nBits |= WB_VSCROLL;
1694 0 : else if (rValue == "automatic")
1695 0 : nBits |= WB_AUTOVSCROLL;
1696 0 : SetStyle(nBits);
1697 : }
1698 46194 : else if (rKey == "accessible-name")
1699 : {
1700 5 : SetAccessibleName(OStringToOUString(rValue, RTL_TEXTENCODING_UTF8));
1701 : }
1702 46189 : else if (rKey == "accessible-description")
1703 : {
1704 0 : SetAccessibleDescription(OStringToOUString(rValue, RTL_TEXTENCODING_UTF8));
1705 : }
1706 46189 : else if (rKey == "use-markup")
1707 : {
1708 : //https://live.gnome.org/GnomeGoals/RemoveMarkupInMessages
1709 : SAL_WARN_IF(toBool(rValue), "vcl.layout", "Use pango attributes instead of mark-up");
1710 : }
1711 46189 : else if (rKey == "has-focus")
1712 : {
1713 0 : if (toBool(rValue))
1714 0 : GrabFocus();
1715 : }
1716 : else
1717 : {
1718 : SAL_INFO("vcl.layout", "unhandled property: " << rKey.getStr());
1719 46189 : return false;
1720 : }
1721 50744 : return true;
1722 : }
1723 :
1724 987 : void Window::set_height_request(sal_Int32 nHeightRequest)
1725 : {
1726 987 : if (!mpWindowImpl)
1727 987 : return;
1728 :
1729 987 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1730 :
1731 987 : if ( pWindowImpl->mnHeightRequest != nHeightRequest )
1732 : {
1733 987 : pWindowImpl->mnHeightRequest = nHeightRequest;
1734 987 : queue_resize();
1735 : }
1736 : }
1737 :
1738 2683 : void Window::set_width_request(sal_Int32 nWidthRequest)
1739 : {
1740 2683 : if (!mpWindowImpl)
1741 2683 : return;
1742 :
1743 2683 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1744 :
1745 2683 : if ( pWindowImpl->mnWidthRequest != nWidthRequest )
1746 : {
1747 2681 : pWindowImpl->mnWidthRequest = nWidthRequest;
1748 2681 : queue_resize();
1749 : }
1750 : }
1751 :
1752 117183 : Size Window::get_ungrouped_preferred_size() const
1753 : {
1754 117183 : Size aRet(get_width_request(), get_height_request());
1755 117183 : if (aRet.Width() == -1 || aRet.Height() == -1)
1756 : {
1757 : //cache gets blown away by queue_resize
1758 114704 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1759 114704 : if (pWindowImpl->mnOptimalWidthCache == -1 || pWindowImpl->mnOptimalHeightCache == -1)
1760 : {
1761 27343 : Size aOptimal(GetOptimalSize());
1762 27343 : pWindowImpl->mnOptimalWidthCache = aOptimal.Width();
1763 27343 : pWindowImpl->mnOptimalHeightCache = aOptimal.Height();
1764 : }
1765 :
1766 114704 : if (aRet.Width() == -1)
1767 108142 : aRet.Width() = pWindowImpl->mnOptimalWidthCache;
1768 114704 : if (aRet.Height() == -1)
1769 114704 : aRet.Height() = pWindowImpl->mnOptimalHeightCache;
1770 : }
1771 117183 : return aRet;
1772 : }
1773 :
1774 92457 : Size Window::get_preferred_size() const
1775 : {
1776 92457 : Size aRet(get_ungrouped_preferred_size());
1777 :
1778 92457 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1779 92457 : if (pWindowImpl->m_xSizeGroup)
1780 : {
1781 4947 : const VclSizeGroupMode eMode = pWindowImpl->m_xSizeGroup->get_mode();
1782 4947 : if (eMode != VCL_SIZE_GROUP_NONE)
1783 : {
1784 4947 : const bool bIgnoreInHidden = pWindowImpl->m_xSizeGroup->get_ignore_hidden();
1785 4947 : const std::set<VclPtr<vcl::Window> > &rWindows = pWindowImpl->m_xSizeGroup->get_widgets();
1786 34617 : for (auto aI = rWindows.begin(), aEnd = rWindows.end(); aI != aEnd; ++aI)
1787 : {
1788 29670 : const vcl::Window *pOther = *aI;
1789 29670 : if (pOther == this)
1790 9888 : continue;
1791 24726 : if (bIgnoreInHidden && !pOther->IsVisible())
1792 0 : continue;
1793 24726 : Size aOtherSize = pOther->get_ungrouped_preferred_size();
1794 24726 : if (eMode == VCL_SIZE_GROUP_BOTH || eMode == VCL_SIZE_GROUP_HORIZONTAL)
1795 6 : aRet.Width() = std::max(aRet.Width(), aOtherSize.Width());
1796 24726 : if (eMode == VCL_SIZE_GROUP_BOTH || eMode == VCL_SIZE_GROUP_VERTICAL)
1797 24726 : aRet.Height() = std::max(aRet.Height(), aOtherSize.Height());
1798 : }
1799 : }
1800 : }
1801 :
1802 92457 : return aRet;
1803 : }
1804 :
1805 36084 : VclAlign Window::get_halign() const
1806 : {
1807 36084 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1808 36084 : return pWindowImpl->meHalign;
1809 : }
1810 :
1811 4320 : void Window::set_halign(VclAlign eAlign)
1812 : {
1813 4320 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1814 4320 : pWindowImpl->meHalign = eAlign;
1815 4320 : }
1816 :
1817 36084 : VclAlign Window::get_valign() const
1818 : {
1819 36084 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1820 36084 : return pWindowImpl->meValign;
1821 : }
1822 :
1823 1841 : void Window::set_valign(VclAlign eAlign)
1824 : {
1825 1841 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1826 1841 : pWindowImpl->meValign = eAlign;
1827 1841 : }
1828 :
1829 49203 : bool Window::get_hexpand() const
1830 : {
1831 49203 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1832 49203 : return pWindowImpl->mbHexpand;
1833 : }
1834 :
1835 3621 : void Window::set_hexpand(bool bExpand)
1836 : {
1837 3621 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1838 3621 : pWindowImpl->mbHexpand = bExpand;
1839 3621 : }
1840 :
1841 41786 : bool Window::get_vexpand() const
1842 : {
1843 41786 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1844 41786 : return pWindowImpl->mbVexpand;
1845 : }
1846 :
1847 74 : void Window::set_vexpand(bool bExpand)
1848 : {
1849 74 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1850 74 : pWindowImpl->mbVexpand = bExpand;
1851 74 : }
1852 :
1853 54638 : bool Window::get_expand() const
1854 : {
1855 54638 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1856 54638 : return pWindowImpl->mbExpand;
1857 : }
1858 :
1859 19199 : void Window::set_expand(bool bExpand)
1860 : {
1861 19199 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1862 19199 : pWindowImpl->mbExpand = bExpand;
1863 19199 : }
1864 :
1865 63674 : VclPackType Window::get_pack_type() const
1866 : {
1867 63674 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1868 63674 : return pWindowImpl->mePackType;
1869 : }
1870 :
1871 3538 : void Window::set_pack_type(VclPackType ePackType)
1872 : {
1873 3538 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1874 3538 : pWindowImpl->mePackType = ePackType;
1875 3538 : }
1876 :
1877 52562 : sal_Int32 Window::get_padding() const
1878 : {
1879 52562 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1880 52562 : return pWindowImpl->mnPadding;
1881 : }
1882 :
1883 0 : void Window::set_padding(sal_Int32 nPadding)
1884 : {
1885 0 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1886 0 : pWindowImpl->mnPadding = nPadding;
1887 0 : }
1888 :
1889 27322 : bool Window::get_fill() const
1890 : {
1891 27322 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1892 27322 : return pWindowImpl->mbFill;
1893 : }
1894 :
1895 19199 : void Window::set_fill(bool bFill)
1896 : {
1897 19199 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1898 19199 : pWindowImpl->mbFill = bFill;
1899 19199 : }
1900 :
1901 18318 : sal_Int32 Window::get_grid_width() const
1902 : {
1903 18318 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1904 18318 : return pWindowImpl->mnGridWidth;
1905 : }
1906 :
1907 2567 : void Window::set_grid_width(sal_Int32 nCols)
1908 : {
1909 2567 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1910 2567 : pWindowImpl->mnGridWidth = nCols;
1911 2567 : }
1912 :
1913 59350 : sal_Int32 Window::get_grid_left_attach() const
1914 : {
1915 59350 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1916 59350 : return pWindowImpl->mnGridLeftAttach;
1917 : }
1918 :
1919 5321 : void Window::set_grid_left_attach(sal_Int32 nAttach)
1920 : {
1921 5321 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1922 5321 : pWindowImpl->mnGridLeftAttach = nAttach;
1923 5321 : }
1924 :
1925 18318 : sal_Int32 Window::get_grid_height() const
1926 : {
1927 18318 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1928 18318 : return pWindowImpl->mnGridHeight;
1929 : }
1930 :
1931 2229 : void Window::set_grid_height(sal_Int32 nRows)
1932 : {
1933 2229 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1934 2229 : pWindowImpl->mnGridHeight = nRows;
1935 2229 : }
1936 :
1937 62830 : sal_Int32 Window::get_grid_top_attach() const
1938 : {
1939 62830 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1940 62830 : return pWindowImpl->mnGridTopAttach;
1941 : }
1942 :
1943 5321 : void Window::set_grid_top_attach(sal_Int32 nAttach)
1944 : {
1945 5321 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1946 5321 : pWindowImpl->mnGridTopAttach = nAttach;
1947 5321 : }
1948 :
1949 1640 : void Window::set_border_width(sal_Int32 nBorderWidth)
1950 : {
1951 1640 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1952 1640 : pWindowImpl->mnBorderWidth = nBorderWidth;
1953 1640 : }
1954 :
1955 116656 : sal_Int32 Window::get_border_width() const
1956 : {
1957 116656 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1958 116656 : return pWindowImpl->mnBorderWidth;
1959 : }
1960 :
1961 14 : void Window::set_margin_left(sal_Int32 nWidth)
1962 : {
1963 14 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1964 14 : pWindowImpl->mnMarginLeft = nWidth;
1965 14 : }
1966 :
1967 116239 : sal_Int32 Window::get_margin_left() const
1968 : {
1969 116239 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1970 116239 : return pWindowImpl->mnMarginLeft;
1971 : }
1972 :
1973 13 : void Window::set_margin_right(sal_Int32 nWidth)
1974 : {
1975 13 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1976 13 : pWindowImpl->mnMarginRight = nWidth;
1977 13 : }
1978 :
1979 116239 : sal_Int32 Window::get_margin_right() const
1980 : {
1981 116239 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1982 116239 : return pWindowImpl->mnMarginRight;
1983 : }
1984 :
1985 4 : void Window::set_margin_top(sal_Int32 nWidth)
1986 : {
1987 4 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1988 4 : pWindowImpl->mnMarginTop = nWidth;
1989 4 : }
1990 :
1991 116239 : sal_Int32 Window::get_margin_top() const
1992 : {
1993 116239 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1994 116239 : return pWindowImpl->mnMarginTop;
1995 : }
1996 :
1997 4 : void Window::set_margin_bottom(sal_Int32 nWidth)
1998 : {
1999 4 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
2000 4 : pWindowImpl->mnMarginBottom = nWidth;
2001 4 : }
2002 :
2003 116239 : sal_Int32 Window::get_margin_bottom() const
2004 : {
2005 116239 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
2006 116239 : return pWindowImpl->mnMarginBottom;
2007 : }
2008 :
2009 117184 : sal_Int32 Window::get_height_request() const
2010 : {
2011 117184 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
2012 117184 : return pWindowImpl->mnHeightRequest;
2013 : }
2014 :
2015 117286 : sal_Int32 Window::get_width_request() const
2016 : {
2017 117286 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
2018 117286 : return pWindowImpl->mnWidthRequest;
2019 : }
2020 :
2021 29276 : bool Window::get_secondary() const
2022 : {
2023 29276 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
2024 29276 : return pWindowImpl->mbSecondary;
2025 : }
2026 :
2027 0 : void Window::set_secondary(bool bSecondary)
2028 : {
2029 0 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
2030 0 : pWindowImpl->mbSecondary = bSecondary;
2031 0 : }
2032 :
2033 0 : bool Window::get_non_homogeneous() const
2034 : {
2035 0 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
2036 0 : return pWindowImpl->mbNonHomogeneous;
2037 : }
2038 :
2039 0 : void Window::set_non_homogeneous(bool bNonHomogeneous)
2040 : {
2041 0 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
2042 0 : pWindowImpl->mbNonHomogeneous = bNonHomogeneous;
2043 0 : }
2044 :
2045 2030 : void Window::add_to_size_group(std::shared_ptr<VclSizeGroup> xGroup)
2046 : {
2047 2030 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
2048 : //To-Do, multiple groups
2049 2030 : pWindowImpl->m_xSizeGroup = xGroup;
2050 2030 : pWindowImpl->m_xSizeGroup->insert(this);
2051 2030 : if (VCL_SIZE_GROUP_NONE != pWindowImpl->m_xSizeGroup->get_mode())
2052 2030 : queue_resize();
2053 2030 : }
2054 :
2055 267413 : void Window::remove_from_all_size_groups()
2056 : {
2057 267413 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
2058 : //To-Do, multiple groups
2059 267413 : if (pWindowImpl->m_xSizeGroup)
2060 : {
2061 2030 : if (VCL_SIZE_GROUP_NONE != pWindowImpl->m_xSizeGroup->get_mode())
2062 2030 : queue_resize();
2063 2030 : pWindowImpl->m_xSizeGroup->erase(this);
2064 2030 : pWindowImpl->m_xSizeGroup.reset();
2065 : }
2066 267413 : }
2067 :
2068 1136 : void Window::add_mnemonic_label(FixedText *pLabel)
2069 : {
2070 1136 : std::vector<VclPtr<FixedText> >& v = mpWindowImpl->m_aMnemonicLabels;
2071 1136 : if (std::find(v.begin(), v.end(), VclPtr<FixedText>(pLabel)) != v.end())
2072 1136 : return;
2073 1136 : v.push_back(pLabel);
2074 1136 : pLabel->set_mnemonic_widget(this);
2075 : }
2076 :
2077 2271 : void Window::remove_mnemonic_label(FixedText *pLabel)
2078 : {
2079 2271 : std::vector<VclPtr<FixedText> >& v = mpWindowImpl->m_aMnemonicLabels;
2080 2271 : auto aFind = std::find(v.begin(), v.end(), VclPtr<FixedText>(pLabel));
2081 2271 : if (aFind == v.end())
2082 3406 : return;
2083 1136 : v.erase(aFind);
2084 1136 : pLabel->set_mnemonic_widget(NULL);
2085 : }
2086 :
2087 272569 : std::vector<VclPtr<FixedText> > Window::list_mnemonic_labels() const
2088 : {
2089 272569 : return mpWindowImpl->m_aMnemonicLabels;
2090 : }
2091 :
2092 801 : } /* namespace vcl */
2093 :
2094 :
2095 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
