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 248 : void Window::ShowFocus( const Rectangle& rRect )
53 : {
54 248 : if( mpWindowImpl->mbInShowFocus )
55 0 : return;
56 248 : mpWindowImpl->mbInShowFocus = true;
57 :
58 248 : ImplWinData* pWinData = ImplGetWinData();
59 :
60 : // native themeing suggest not to use focus rects
61 248 : if( ! ( mpWindowImpl->mbUseNativeFocus &&
62 248 : IsNativeWidgetEnabled() ) )
63 : {
64 248 : if ( !mpWindowImpl->mbInPaint )
65 : {
66 15 : 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 15 : ImplInvertFocus( rRect );
78 : }
79 248 : if ( !pWinData->mpFocusRect )
80 129 : pWinData->mpFocusRect = new Rectangle( rRect );
81 : else
82 119 : *(pWinData->mpFocusRect) = rRect;
83 248 : 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 248 : mpWindowImpl->mbInShowFocus = false;
95 : }
96 :
97 28675 : void Window::HideFocus()
98 : {
99 :
100 28675 : if( mpWindowImpl->mbInHideFocus )
101 0 : return;
102 28675 : mpWindowImpl->mbInHideFocus = true;
103 :
104 : // native themeing can suggest not to use focus rects
105 28675 : if( ! ( mpWindowImpl->mbUseNativeFocus &&
106 28675 : IsNativeWidgetEnabled() ) )
107 : {
108 28675 : if ( !mpWindowImpl->mbFocusVisible )
109 : {
110 28436 : mpWindowImpl->mbInHideFocus = false;
111 28436 : return;
112 : }
113 :
114 239 : if ( !mpWindowImpl->mbInPaint )
115 235 : ImplInvertFocus( *(ImplGetWinData()->mpFocusRect) );
116 239 : 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 239 : mpWindowImpl->mbInHideFocus = false;
128 : }
129 :
130 103960 : void Window::Invert( const Rectangle& rRect, sal_uInt16 nFlags )
131 : {
132 103960 : if ( !IsDeviceOutputNecessary() )
133 412 : return;
134 :
135 103900 : OutputDevice *pOutDev = GetOutDev();
136 103900 : Rectangle aRect( pOutDev->ImplLogicToDevicePixel( rRect ) );
137 :
138 103900 : if ( aRect.IsEmpty() )
139 274 : return;
140 103626 : aRect.Justify();
141 :
142 : // we need a graphics
143 103626 : if ( !mpGraphics )
144 : {
145 0 : if ( !pOutDev->AcquireGraphics() )
146 0 : return;
147 : }
148 :
149 103626 : if ( mbInitClipRegion )
150 12715 : InitClipRegion();
151 :
152 103626 : if ( mbOutputClipped )
153 18 : return;
154 :
155 103608 : SalInvert nSalFlags = 0;
156 103608 : if ( nFlags & INVERT_HIGHLIGHT )
157 0 : nSalFlags |= SAL_INVERT_HIGHLIGHT;
158 103608 : if ( nFlags & INVERT_50 )
159 0 : nSalFlags |= SAL_INVERT_50;
160 103608 : mpGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight(), nSalFlags, this );
161 : }
162 :
163 24 : void Window::Invert( const Polygon& rPoly, sal_uInt16 nFlags )
164 : {
165 24 : if ( !IsDeviceOutputNecessary() )
166 0 : return;
167 :
168 24 : sal_uInt16 nPoints = rPoly.GetSize();
169 :
170 24 : if ( nPoints < 2 )
171 0 : return;
172 :
173 24 : OutputDevice *pOutDev = GetOutDev();
174 24 : Polygon aPoly( pOutDev->ImplLogicToDevicePixel( rPoly ) );
175 :
176 : // we need a graphics
177 24 : if ( !mpGraphics )
178 : {
179 0 : if ( !pOutDev->AcquireGraphics() )
180 0 : return;
181 : }
182 :
183 24 : if ( mbInitClipRegion )
184 2 : InitClipRegion();
185 :
186 24 : if ( mbOutputClipped )
187 0 : return;
188 :
189 24 : SalInvert nSalFlags = 0;
190 24 : if ( nFlags & INVERT_HIGHLIGHT )
191 0 : nSalFlags |= SAL_INVERT_HIGHLIGHT;
192 24 : if ( nFlags & INVERT_50 )
193 0 : nSalFlags |= SAL_INVERT_50;
194 24 : const SalPoint* pPtAry = (const SalPoint*)aPoly.GetConstPointAry();
195 24 : 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 507 : void Window::InvertTracking( const Rectangle& rRect, sal_uInt16 nFlags )
236 : {
237 507 : OutputDevice *pOutDev = GetOutDev();
238 507 : Rectangle aRect( pOutDev->ImplLogicToDevicePixel( rRect ) );
239 :
240 507 : if ( aRect.IsEmpty() )
241 113 : return;
242 501 : aRect.Justify();
243 :
244 : SalGraphics* pGraphics;
245 :
246 501 : if ( nFlags & SHOWTRACK_WINDOW )
247 : {
248 501 : if ( !IsDeviceOutputNecessary() )
249 101 : return;
250 :
251 : // we need a graphics
252 400 : if ( !mpGraphics )
253 : {
254 0 : if ( !pOutDev->AcquireGraphics() )
255 0 : return;
256 : }
257 :
258 400 : if ( mbInitClipRegion )
259 281 : InitClipRegion();
260 :
261 400 : if ( mbOutputClipped )
262 0 : return;
263 :
264 400 : 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 400 : sal_uInt16 nStyle = nFlags & SHOWTRACK_STYLE;
281 400 : if ( nStyle == SHOWTRACK_OBJECT )
282 0 : pGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight(), SAL_INVERT_TRACKFRAME, this );
283 400 : 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 400 : long nBorder = 1;
288 400 : if ( nStyle == SHOWTRACK_BIG )
289 0 : nBorder = 5;
290 400 : pGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), nBorder, SAL_INVERT_50, this );
291 400 : pGraphics->Invert( aRect.Left(), aRect.Bottom()-nBorder+1, aRect.GetWidth(), nBorder, SAL_INVERT_50, this );
292 400 : pGraphics->Invert( aRect.Left(), aRect.Top()+nBorder, nBorder, aRect.GetHeight()-(nBorder*2), SAL_INVERT_50, this );
293 400 : 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 = (const SalPoint*)aPoly.GetConstPointAry();
345 0 : pGraphics->Invert( nPoints, pPtAry, SAL_INVERT_TRACKFRAME, this );
346 : }
347 :
348 0 : IMPL_LINK( Window, ImplTrackTimerHdl, Timer*, pTimer )
349 : {
350 0 : ImplSVData* pSVData = ImplGetSVData();
351 :
352 : // Bei Button-Repeat muessen wir den Timeout umsetzen
353 0 : if ( pSVData->maWinData.mnTrackFlags & STARTTRACK_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, 0,
366 0 : mpWindowImpl->mpFrameData->mnMouseCode, mpWindowImpl->mpFrameData->mnMouseCode );
367 0 : TrackingEvent aTEvt( aMEvt, TRACKING_REPEAT );
368 0 : Tracking( aTEvt );
369 :
370 0 : return 0;
371 : }
372 :
373 0 : void Window::StartTracking( sal_uInt16 nFlags )
374 : {
375 0 : ImplSVData* pSVData = ImplGetSVData();
376 :
377 0 : if ( pSVData->maWinData.mpTrackWin != this )
378 : {
379 0 : if ( pSVData->maWinData.mpTrackWin )
380 0 : pSVData->maWinData.mpTrackWin->EndTracking( ENDTRACK_CANCEL );
381 : }
382 :
383 0 : if ( nFlags & (STARTTRACK_SCROLLREPEAT | STARTTRACK_BUTTONREPEAT) )
384 : {
385 0 : pSVData->maWinData.mpTrackTimer = new AutoTimer;
386 :
387 0 : if ( nFlags & STARTTRACK_SCROLLREPEAT )
388 0 : pSVData->maWinData.mpTrackTimer->SetTimeout( GetSettings().GetMouseSettings().GetScrollRepeat() );
389 : else
390 0 : pSVData->maWinData.mpTrackTimer->SetTimeout( GetSettings().GetMouseSettings().GetButtonStartRepeat() );
391 0 : pSVData->maWinData.mpTrackTimer->SetTimeoutHdl( LINK( this, Window, ImplTrackTimerHdl ) );
392 0 : pSVData->maWinData.mpTrackTimer->Start();
393 : }
394 :
395 0 : pSVData->maWinData.mpTrackWin = this;
396 0 : pSVData->maWinData.mnTrackFlags = nFlags;
397 0 : CaptureMouse();
398 0 : }
399 :
400 6 : void Window::EndTracking( sal_uInt16 nFlags )
401 : {
402 6 : ImplSVData* pSVData = ImplGetSVData();
403 :
404 6 : if ( pSVData->maWinData.mpTrackWin == this )
405 : {
406 : // due to DbgChkThis in brackets, as the window could be destroyed
407 : // in the handler
408 : {
409 :
410 0 : if ( pSVData->maWinData.mpTrackTimer )
411 : {
412 0 : delete pSVData->maWinData.mpTrackTimer;
413 0 : pSVData->maWinData.mpTrackTimer = NULL;
414 : }
415 :
416 0 : pSVData->maWinData.mpTrackWin = NULL;
417 0 : pSVData->maWinData.mnTrackFlags = 0;
418 0 : ReleaseMouse();
419 : }
420 :
421 : // call EndTracking if required
422 0 : if ( !(nFlags & ENDTRACK_DONTCALLHDL) )
423 : {
424 0 : Point aMousePos( mpWindowImpl->mpFrameData->mnLastMouseX, mpWindowImpl->mpFrameData->mnLastMouseY );
425 0 : if( ImplIsAntiparallel() )
426 : {
427 : // - RTL - re-mirror frame pos at pChild
428 0 : const OutputDevice *pOutDev = GetOutDev();
429 0 : pOutDev->ReMirror( aMousePos );
430 : }
431 :
432 : MouseEvent aMEvt( ImplFrameToOutput( aMousePos ),
433 : mpWindowImpl->mpFrameData->mnClickCount, 0,
434 0 : mpWindowImpl->mpFrameData->mnMouseCode, mpWindowImpl->mpFrameData->mnMouseCode );
435 0 : TrackingEvent aTEvt( aMEvt, nFlags | ENDTRACK_END );
436 0 : Tracking( aTEvt );
437 : }
438 : }
439 6 : }
440 :
441 144367 : bool Window::IsTracking() const
442 : {
443 144367 : return (ImplGetSVData()->maWinData.mpTrackWin == this);
444 : }
445 :
446 0 : void Window::StartAutoScroll( sal_uInt16 nFlags )
447 : {
448 0 : ImplSVData* pSVData = ImplGetSVData();
449 :
450 0 : if ( pSVData->maWinData.mpAutoScrollWin != 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 = new ImplWheelWindow( this );
459 0 : }
460 :
461 0 : void Window::EndAutoScroll()
462 : {
463 0 : ImplSVData* pSVData = ImplGetSVData();
464 :
465 0 : if ( pSVData->maWinData.mpAutoScrollWin == this )
466 : {
467 0 : pSVData->maWinData.mpAutoScrollWin = NULL;
468 0 : pSVData->maWinData.mnAutoScrollFlags = 0;
469 0 : pSVData->maAppData.mpWheelWindow->ImplStop();
470 0 : pSVData->maAppData.mpWheelWindow->doLazyDelete();
471 0 : pSVData->maAppData.mpWheelWindow = NULL;
472 : }
473 0 : }
474 :
475 16 : sal_uIntPtr Window::SaveFocus()
476 : {
477 16 : ImplSVData* pSVData = ImplGetSVData();
478 16 : if ( pSVData->maWinData.mpFocusWin )
479 : {
480 16 : ImplFocusDelData* pDelData = new ImplFocusDelData;
481 16 : pSVData->maWinData.mpFocusWin->ImplAddDel( pDelData );
482 16 : pDelData->mpFocusWin = pSVData->maWinData.mpFocusWin;
483 16 : return reinterpret_cast<sal_uIntPtr>(pDelData);
484 : }
485 : else
486 0 : return 0;
487 : }
488 :
489 32 : bool Window::EndSaveFocus( sal_uIntPtr nSaveId, bool bRestore )
490 : {
491 32 : if ( !nSaveId )
492 20 : return false;
493 : else
494 : {
495 12 : bool bOK = true;
496 12 : ImplFocusDelData* pDelData = reinterpret_cast<ImplFocusDelData*>(nSaveId);
497 12 : if ( !pDelData->IsDead() )
498 : {
499 12 : pDelData->mpFocusWin->ImplRemoveDel( pDelData );
500 12 : if ( bRestore )
501 12 : pDelData->mpFocusWin->GrabFocus();
502 : }
503 : else
504 0 : bOK = !bRestore;
505 12 : delete pDelData;
506 12 : return bOK;
507 : }
508 : }
509 :
510 15928 : void Window::SetZoom( const Fraction& rZoom )
511 : {
512 15928 : if ( mpWindowImpl->maZoom != rZoom )
513 : {
514 85 : mpWindowImpl->maZoom = rZoom;
515 85 : StateChanged( StateChangedType::ZOOM );
516 : }
517 15928 : }
518 :
519 464 : inline long WinFloatRound( double fVal )
520 : {
521 464 : return( fVal > 0.0 ? (long) ( fVal + 0.5 ) : -(long) ( -fVal + 0.5 ) );
522 : }
523 :
524 163726 : void Window::SetZoomedPointFont( const vcl::Font& rFont )
525 : {
526 163726 : const Fraction& rZoom = GetZoom();
527 163726 : if ( rZoom.GetNumerator() != rZoom.GetDenominator() )
528 : {
529 84 : vcl::Font aFont( rFont );
530 84 : Size aSize = aFont.GetSize();
531 84 : double n = (double)aSize.Width();
532 84 : n *= (double)rZoom.GetNumerator();
533 84 : n /= (double)rZoom.GetDenominator();
534 84 : aSize.Width() = WinFloatRound( n );
535 84 : n = (double)aSize.Height();
536 84 : n *= (double)rZoom.GetNumerator();
537 84 : n /= (double)rZoom.GetDenominator();
538 84 : aSize.Height() = WinFloatRound( n );
539 84 : aFont.SetSize( aSize );
540 84 : SetPointFont( aFont );
541 :
542 : // Use another font if the representation is to be scaled,
543 : // and the actual font is not scalable
544 168 : FontMetric aMetric = GetFontMetric();
545 84 : long nFontDiff = std::abs( GetFont().GetSize().Height()-aMetric.GetSize().Height() );
546 84 : if ( (aMetric.GetType() == TYPE_RASTER) && (nFontDiff >= 2) )
547 : {
548 : sal_uInt16 nType;
549 0 : if ( aMetric.GetPitch() == PITCH_FIXED )
550 0 : nType = DEFAULTFONT_FIXED;
551 : else
552 0 : nType = DEFAULTFONT_UI_SANS;
553 0 : vcl::Font aTempFont = GetDefaultFont( nType, GetSettings().GetLanguageTag().getLanguageType(), 0 );
554 0 : aFont.SetName( aTempFont.GetName() );
555 0 : SetPointFont( aFont );
556 84 : }
557 : }
558 : else
559 163642 : SetPointFont( rFont );
560 163726 : }
561 :
562 80429 : long Window::CalcZoom( long nCalc ) const
563 : {
564 :
565 80429 : const Fraction& rZoom = GetZoom();
566 80429 : if ( rZoom.GetNumerator() != rZoom.GetDenominator() )
567 : {
568 296 : double n = (double)nCalc;
569 296 : n *= (double)rZoom.GetNumerator();
570 296 : n /= (double)rZoom.GetDenominator();
571 296 : nCalc = WinFloatRound( n );
572 : }
573 80429 : return nCalc;
574 : }
575 :
576 1588 : void Window::SetControlFont()
577 : {
578 1588 : if ( mpWindowImpl->mpControlFont )
579 : {
580 0 : delete mpWindowImpl->mpControlFont;
581 0 : mpWindowImpl->mpControlFont = NULL;
582 0 : StateChanged( StateChangedType::CONTROLFONT );
583 : }
584 1588 : }
585 :
586 8803 : void Window::SetControlFont( const vcl::Font& rFont )
587 : {
588 8803 : if ( rFont == vcl::Font() )
589 : {
590 1380 : SetControlFont();
591 1380 : return;
592 : }
593 :
594 7423 : if ( mpWindowImpl->mpControlFont )
595 : {
596 6580 : if ( *mpWindowImpl->mpControlFont == rFont )
597 1326 : return;
598 5254 : *mpWindowImpl->mpControlFont = rFont;
599 : }
600 : else
601 843 : mpWindowImpl->mpControlFont = new vcl::Font( rFont );
602 :
603 6097 : StateChanged( StateChangedType::CONTROLFONT );
604 : }
605 :
606 16854 : vcl::Font Window::GetControlFont() const
607 : {
608 16854 : if ( mpWindowImpl->mpControlFont )
609 13465 : return *mpWindowImpl->mpControlFont;
610 : else
611 : {
612 3389 : vcl::Font aFont;
613 3389 : return aFont;
614 : }
615 : }
616 :
617 1046 : void Window::SetControlForeground()
618 : {
619 1046 : if ( mpWindowImpl->mbControlForeground )
620 : {
621 0 : mpWindowImpl->maControlForeground = Color( COL_TRANSPARENT );
622 0 : mpWindowImpl->mbControlForeground = false;
623 0 : StateChanged( StateChangedType::CONTROLFOREGROUND );
624 : }
625 1046 : }
626 :
627 150 : void Window::SetControlForeground( const Color& rColor )
628 : {
629 150 : if ( rColor.GetTransparency() )
630 : {
631 0 : if ( mpWindowImpl->mbControlForeground )
632 : {
633 0 : mpWindowImpl->maControlForeground = Color( COL_TRANSPARENT );
634 0 : mpWindowImpl->mbControlForeground = false;
635 0 : StateChanged( StateChangedType::CONTROLFOREGROUND );
636 : }
637 : }
638 : else
639 : {
640 150 : if ( mpWindowImpl->maControlForeground != rColor )
641 : {
642 122 : mpWindowImpl->maControlForeground = rColor;
643 122 : mpWindowImpl->mbControlForeground = true;
644 122 : StateChanged( StateChangedType::CONTROLFOREGROUND );
645 : }
646 : }
647 150 : }
648 :
649 1142 : void Window::SetControlBackground()
650 : {
651 1142 : if ( mpWindowImpl->mbControlBackground )
652 : {
653 32 : mpWindowImpl->maControlBackground = Color( COL_TRANSPARENT );
654 32 : mpWindowImpl->mbControlBackground = false;
655 32 : StateChanged( StateChangedType::CONTROLBACKGROUND );
656 : }
657 1142 : }
658 :
659 5956 : void Window::SetControlBackground( const Color& rColor )
660 : {
661 5956 : if ( rColor.GetTransparency() )
662 : {
663 0 : if ( mpWindowImpl->mbControlBackground )
664 : {
665 0 : mpWindowImpl->maControlBackground = Color( COL_TRANSPARENT );
666 0 : mpWindowImpl->mbControlBackground = false;
667 0 : StateChanged( StateChangedType::CONTROLBACKGROUND );
668 : }
669 : }
670 : else
671 : {
672 5956 : if ( mpWindowImpl->maControlBackground != rColor )
673 : {
674 5956 : mpWindowImpl->maControlBackground = rColor;
675 5956 : mpWindowImpl->mbControlBackground = true;
676 5956 : StateChanged( StateChangedType::CONTROLBACKGROUND );
677 : }
678 : }
679 5956 : }
680 :
681 65378 : Size Window::CalcWindowSize( const Size& rOutSz ) const
682 : {
683 65378 : Size aSz = rOutSz;
684 65378 : aSz.Width() += mpWindowImpl->mnLeftBorder+mpWindowImpl->mnRightBorder;
685 65378 : aSz.Height() += mpWindowImpl->mnTopBorder+mpWindowImpl->mnBottomBorder;
686 65378 : return aSz;
687 : }
688 :
689 30580 : Size Window::CalcOutputSize( const Size& rWinSz ) const
690 : {
691 30580 : Size aSz = rWinSz;
692 30580 : aSz.Width() -= mpWindowImpl->mnLeftBorder+mpWindowImpl->mnRightBorder;
693 30580 : aSz.Height() -= mpWindowImpl->mnTopBorder+mpWindowImpl->mnBottomBorder;
694 30580 : return aSz;
695 : }
696 :
697 0 : vcl::Font Window::GetDrawPixelFont( OutputDevice* pDev ) const
698 : {
699 0 : vcl::Font aFont = GetPointFont();
700 0 : Size aFontSize = aFont.GetSize();
701 0 : MapMode aPtMapMode( MAP_POINT );
702 0 : aFontSize = pDev->LogicToPixel( aFontSize, aPtMapMode );
703 0 : aFont.SetSize( aFontSize );
704 0 : return aFont;
705 : }
706 :
707 12523 : long Window::GetDrawPixel( OutputDevice* pDev, long nPixels ) const
708 : {
709 12523 : long nP = nPixels;
710 12523 : if ( pDev->GetOutDevType() != OUTDEV_WINDOW )
711 : {
712 0 : MapMode aMap( MAP_100TH_MM );
713 0 : Size aSz( nP, 0 );
714 0 : aSz = PixelToLogic( aSz, aMap );
715 0 : aSz = pDev->LogicToPixel( aSz, aMap );
716 0 : nP = aSz.Width();
717 : }
718 12523 : return nP;
719 : }
720 :
721 0 : static void lcl_HandleScrollHelper( ScrollBar* pScrl, long nN, bool isMultiplyByLineSize )
722 : {
723 0 : if ( pScrl && nN && pScrl->IsEnabled() && pScrl->IsInputEnabled() && ! pScrl->IsInModalMode() )
724 : {
725 0 : long nNewPos = pScrl->GetThumbPos();
726 :
727 0 : if ( nN == -LONG_MAX )
728 0 : nNewPos += pScrl->GetPageSize();
729 0 : else if ( nN == LONG_MAX )
730 0 : nNewPos -= pScrl->GetPageSize();
731 : else
732 : {
733 : // allowing both chunked and continuous scrolling
734 0 : if(isMultiplyByLineSize){
735 0 : nN*=pScrl->GetLineSize();
736 : }
737 :
738 0 : const double fVal = (double)(nNewPos - nN);
739 :
740 0 : if ( fVal < LONG_MIN )
741 0 : nNewPos = LONG_MIN;
742 0 : else if ( fVal > LONG_MAX )
743 0 : nNewPos = LONG_MAX;
744 : else
745 0 : nNewPos = (long)fVal;
746 : }
747 :
748 0 : pScrl->DoScroll( nNewPos );
749 : }
750 :
751 0 : }
752 :
753 0 : bool Window::HandleScrollCommand( const CommandEvent& rCmd,
754 : ScrollBar* pHScrl, ScrollBar* pVScrl )
755 : {
756 0 : bool bRet = false;
757 :
758 0 : if ( pHScrl || pVScrl )
759 : {
760 0 : switch( rCmd.GetCommand() )
761 : {
762 : case COMMAND_STARTAUTOSCROLL:
763 : {
764 0 : sal_uInt16 nFlags = 0;
765 0 : if ( pHScrl )
766 : {
767 0 : if ( (pHScrl->GetVisibleSize() < pHScrl->GetRangeMax()) &&
768 0 : pHScrl->IsEnabled() && pHScrl->IsInputEnabled() && ! pHScrl->IsInModalMode() )
769 0 : nFlags |= AUTOSCROLL_HORZ;
770 : }
771 0 : if ( pVScrl )
772 : {
773 0 : if ( (pVScrl->GetVisibleSize() < pVScrl->GetRangeMax()) &&
774 0 : pVScrl->IsEnabled() && pVScrl->IsInputEnabled() && ! pVScrl->IsInModalMode() )
775 0 : nFlags |= AUTOSCROLL_VERT;
776 : }
777 :
778 0 : if ( nFlags )
779 : {
780 0 : StartAutoScroll( nFlags );
781 0 : bRet = true;
782 : }
783 : }
784 0 : break;
785 :
786 : case COMMAND_WHEEL:
787 : {
788 0 : const CommandWheelData* pData = rCmd.GetWheelData();
789 :
790 0 : if ( pData && (CommandWheelMode::SCROLL == pData->GetMode()) )
791 : {
792 0 : if (!pData->IsDeltaPixel())
793 : {
794 0 : sal_uLong nScrollLines = pData->GetScrollLines();
795 : long nLines;
796 0 : if ( nScrollLines == COMMAND_WHEEL_PAGESCROLL )
797 : {
798 0 : if ( pData->GetDelta() < 0 )
799 0 : nLines = -LONG_MAX;
800 : else
801 0 : nLines = LONG_MAX;
802 : }
803 : else
804 0 : nLines = pData->GetNotchDelta() * (long)nScrollLines;
805 0 : if ( nLines )
806 : {
807 : ImplHandleScroll( NULL,
808 : 0L,
809 0 : pData->IsHorz() ? pHScrl : pVScrl,
810 0 : nLines );
811 0 : bRet = true;
812 : }
813 : }
814 : else
815 : {
816 : // Mobile / touch scrolling section
817 0 : const Point & deltaPoint = rCmd.GetMousePosPixel();
818 :
819 0 : double deltaXInPixels = double(deltaPoint.X());
820 0 : double deltaYInPixels = double(deltaPoint.Y());
821 0 : Size winSize = this->GetOutputSizePixel();
822 :
823 0 : if(pHScrl)
824 : {
825 0 : double visSizeX = double(pHScrl->GetVisibleSize());
826 0 : double ratioX = deltaXInPixels / double(winSize.getWidth());
827 0 : long deltaXInLogic = long(visSizeX * ratioX);
828 : // Touch need to work by pixels. Did not apply this to
829 : // Android, as android code may require adaptations
830 : // to work with this scrolling code
831 : #ifndef IOS
832 0 : long lineSizeX = pHScrl->GetLineSize();
833 :
834 0 : if(lineSizeX)
835 : {
836 0 : deltaXInLogic /= lineSizeX;
837 : }
838 : else
839 : {
840 0 : deltaXInLogic = 0;
841 : }
842 : #endif
843 0 : if ( deltaXInLogic)
844 : {
845 : #ifndef IOS
846 0 : bool isMultiplyByLineSize = true;
847 : #else
848 : bool isMultiplyByLineSize = false;
849 : #endif
850 0 : lcl_HandleScrollHelper( pHScrl, deltaXInLogic, isMultiplyByLineSize );
851 0 : bRet = true;
852 : }
853 : }
854 0 : if(pVScrl)
855 : {
856 0 : double visSizeY = double(pVScrl->GetVisibleSize());
857 0 : double ratioY = deltaYInPixels / double(winSize.getHeight());
858 0 : long deltaYInLogic = long(visSizeY * ratioY);
859 :
860 : // Touch need to work by pixels. Did not apply this to
861 : // Android, as android code may require adaptations
862 : // to work with this scrolling code
863 : #ifndef IOS
864 0 : long lineSizeY = pVScrl->GetLineSize();
865 0 : if(lineSizeY)
866 : {
867 0 : deltaYInLogic /= lineSizeY;
868 : }
869 : else
870 : {
871 0 : deltaYInLogic = 0;
872 : }
873 : #endif
874 0 : if ( deltaYInLogic )
875 : {
876 : #ifndef IOS
877 0 : bool isMultiplyByLineSize = true;
878 : #else
879 : bool isMultiplyByLineSize = false;
880 : #endif
881 0 : lcl_HandleScrollHelper( pVScrl, deltaYInLogic, isMultiplyByLineSize );
882 :
883 0 : bRet = true;
884 : }
885 : }
886 : }
887 : }
888 : }
889 0 : break;
890 :
891 : case COMMAND_AUTOSCROLL:
892 : {
893 0 : const CommandScrollData* pData = rCmd.GetAutoScrollData();
894 0 : if ( pData && (pData->GetDeltaX() || pData->GetDeltaY()) )
895 : {
896 : ImplHandleScroll( pHScrl, pData->GetDeltaX(),
897 0 : pVScrl, pData->GetDeltaY() );
898 0 : bRet = true;
899 : }
900 : }
901 0 : break;
902 :
903 : default:
904 0 : break;
905 : }
906 : }
907 :
908 0 : return bRet;
909 : }
910 :
911 : // Note that when called for COMMAND_WHEEL above, despite its name,
912 : // pVScrl isn't necessarily the vertical scroll bar. Depending on
913 : // whether the scroll is horizontal or vertical, it is either the
914 : // horizontal or vertical scroll bar. nY is correspondingly either
915 : // the horizontal or vertical scroll amount.
916 :
917 0 : void Window::ImplHandleScroll( ScrollBar* pHScrl, long nX,
918 : ScrollBar* pVScrl, long nY )
919 : {
920 0 : lcl_HandleScrollHelper( pHScrl, nX, true );
921 0 : lcl_HandleScrollHelper( pVScrl, nY, true );
922 0 : }
923 :
924 871204 : DockingManager* Window::GetDockingManager()
925 : {
926 871204 : return ImplGetDockingManager();
927 : }
928 :
929 16268 : void Window::EnableDocking( bool bEnable )
930 : {
931 : // update list of dockable windows
932 16268 : if( bEnable )
933 16268 : ImplGetDockingManager()->AddWindow( this );
934 : else
935 0 : ImplGetDockingManager()->RemoveWindow( this );
936 16268 : }
937 :
938 : // retrieves the list of owner draw decorated windows for this window hiearchy
939 0 : ::std::vector<vcl::Window *>& Window::ImplGetOwnerDrawList()
940 : {
941 0 : return ImplGetTopmostFrameWindow()->mpWindowImpl->mpFrameData->maOwnerDrawList;
942 : }
943 :
944 79682 : void Window::SetHelpId( const OString& rHelpId )
945 : {
946 79682 : mpWindowImpl->maHelpId = rHelpId;
947 79682 : }
948 :
949 319762 : const OString& Window::GetHelpId() const
950 : {
951 319762 : return mpWindowImpl->maHelpId;
952 : }
953 :
954 12208 : void Window::SetUniqueId( const OString& rUniqueId )
955 : {
956 12208 : mpWindowImpl->maUniqId = rUniqueId;
957 12208 : }
958 :
959 104 : const OString& Window::GetUniqueId() const
960 : {
961 104 : return mpWindowImpl->maUniqId;
962 : }
963 :
964 : // --------- old inline methods ---------------
965 :
966 1832057 : vcl::Window* Window::ImplGetWindow()
967 : {
968 1832057 : if ( mpWindowImpl->mpClientWindow )
969 1336099 : return mpWindowImpl->mpClientWindow;
970 : else
971 495958 : return this;
972 : }
973 :
974 0 : ImplFrameData* Window::ImplGetFrameData()
975 : {
976 0 : return mpWindowImpl->mpFrameData;
977 : }
978 :
979 192319 : SalFrame* Window::ImplGetFrame() const
980 : {
981 192319 : return mpWindowImpl->mpFrame;
982 : }
983 :
984 10628452 : vcl::Window* Window::ImplGetParent() const
985 : {
986 10628452 : return mpWindowImpl->mpParent;
987 : }
988 :
989 117608 : vcl::Window* Window::ImplGetClientWindow() const
990 : {
991 117608 : return mpWindowImpl->mpClientWindow;
992 : }
993 :
994 375512 : vcl::Window* Window::ImplGetBorderWindow() const
995 : {
996 375512 : return mpWindowImpl->mpBorderWindow;
997 : }
998 :
999 606575 : vcl::Window* Window::ImplGetFirstOverlapWindow()
1000 : {
1001 606575 : if ( mpWindowImpl->mbOverlapWin )
1002 12444 : return this;
1003 : else
1004 594131 : return mpWindowImpl->mpOverlapWindow;
1005 : }
1006 :
1007 0 : const vcl::Window* Window::ImplGetFirstOverlapWindow() const
1008 : {
1009 0 : if ( mpWindowImpl->mbOverlapWin )
1010 0 : return this;
1011 : else
1012 0 : return mpWindowImpl->mpOverlapWindow;
1013 : }
1014 :
1015 41828 : vcl::Window* Window::ImplGetFrameWindow() const
1016 : {
1017 41828 : return mpWindowImpl->mpFrameWindow;
1018 : }
1019 :
1020 0 : bool Window::ImplIsDockingWindow() const
1021 : {
1022 0 : return mpWindowImpl->mbDockWin;
1023 : }
1024 :
1025 346 : bool Window::ImplIsFloatingWindow() const
1026 : {
1027 346 : return mpWindowImpl->mbFloatWin;
1028 : }
1029 :
1030 0 : bool Window::ImplIsSplitter() const
1031 : {
1032 0 : return mpWindowImpl->mbSplitter;
1033 : }
1034 :
1035 10774 : bool Window::ImplIsPushButton() const
1036 : {
1037 10774 : return mpWindowImpl->mbPushButton;
1038 : }
1039 :
1040 15365297 : bool Window::ImplIsOverlapWindow() const
1041 : {
1042 15365297 : return mpWindowImpl->mbOverlapWin;
1043 : }
1044 :
1045 0 : void Window::ImplSetMouseTransparent( bool bTransparent )
1046 : {
1047 0 : mpWindowImpl->mbMouseTransparent = bTransparent;
1048 0 : }
1049 :
1050 0 : Point Window::ImplOutputToFrame( const Point& rPos )
1051 : {
1052 0 : return Point( rPos.X()+mnOutOffX, rPos.Y()+mnOutOffY );
1053 : }
1054 :
1055 80466 : Point Window::ImplFrameToOutput( const Point& rPos )
1056 : {
1057 80466 : return Point( rPos.X()-mnOutOffX, rPos.Y()-mnOutOffY );
1058 : }
1059 :
1060 10511 : void Window::SetCompoundControl( bool bCompound )
1061 : {
1062 10511 : mpWindowImpl->mbCompoundControl = bCompound;
1063 10511 : }
1064 :
1065 431 : void Window::IncrementLockCount()
1066 : {
1067 431 : mpWindowImpl->mnLockCount++;
1068 431 : }
1069 :
1070 431 : void Window::DecrementLockCount()
1071 : {
1072 431 : mpWindowImpl->mnLockCount--;
1073 431 : }
1074 :
1075 7505694 : WinBits Window::GetStyle() const
1076 : {
1077 7505694 : return mpWindowImpl->mnStyle;
1078 : }
1079 :
1080 16849 : WinBits Window::GetPrevStyle() const
1081 : {
1082 16849 : return mpWindowImpl->mnPrevStyle;
1083 : }
1084 :
1085 18 : WinBits Window::GetExtendedStyle() const
1086 : {
1087 18 : return mpWindowImpl->mnExtendedStyle;
1088 : }
1089 :
1090 21910 : void Window::SetType( WindowType nType )
1091 : {
1092 21910 : mpWindowImpl->mnType = nType;
1093 21910 : }
1094 :
1095 16486000 : WindowType Window::GetType() const
1096 : {
1097 16486000 : return mpWindowImpl->mnType;
1098 : }
1099 :
1100 0 : Dialog* Window::GetParentDialog() const
1101 : {
1102 0 : const vcl::Window *pWindow = this;
1103 :
1104 0 : while( pWindow )
1105 : {
1106 0 : if( pWindow->IsDialog() )
1107 0 : break;
1108 :
1109 0 : pWindow = pWindow->GetParent();
1110 : }
1111 :
1112 0 : return const_cast<Dialog *>(dynamic_cast<const Dialog*>(pWindow));
1113 : }
1114 :
1115 548163 : bool Window::IsSystemWindow() const
1116 : {
1117 548163 : return mpWindowImpl->mbSysWin;
1118 : }
1119 :
1120 1036 : bool Window::IsDialog() const
1121 : {
1122 1036 : return mpWindowImpl->mbDialog;
1123 : }
1124 :
1125 1698 : bool Window::IsMenuFloatingWindow() const
1126 : {
1127 1698 : return mpWindowImpl->mbMenuFloatingWindow;
1128 : }
1129 :
1130 422 : bool Window::IsToolbarFloatingWindow() const
1131 : {
1132 422 : return mpWindowImpl->mbToolbarFloatingWindow;
1133 : }
1134 :
1135 40523 : void Window::EnableAllResize( bool bEnable )
1136 : {
1137 40523 : mpWindowImpl->mbAllResize = bEnable;
1138 40523 : }
1139 :
1140 68006 : void Window::EnableChildTransparentMode( bool bEnable )
1141 : {
1142 68006 : mpWindowImpl->mbChildTransparent = bEnable;
1143 68006 : }
1144 :
1145 34366 : bool Window::IsChildTransparentModeEnabled() const
1146 : {
1147 34366 : return mpWindowImpl->mbChildTransparent;
1148 : }
1149 :
1150 0 : bool Window::IsMouseTransparent() const
1151 : {
1152 0 : return mpWindowImpl->mbMouseTransparent;
1153 : }
1154 :
1155 2127790 : bool Window::IsPaintTransparent() const
1156 : {
1157 2127790 : return mpWindowImpl->mbPaintTransparent;
1158 : }
1159 :
1160 16 : void Window::SetDialogControlStart( bool bStart )
1161 : {
1162 16 : mpWindowImpl->mbDlgCtrlStart = bStart;
1163 16 : }
1164 :
1165 23491 : bool Window::IsDialogControlStart() const
1166 : {
1167 23491 : return mpWindowImpl->mbDlgCtrlStart;
1168 : }
1169 :
1170 5598 : void Window::SetDialogControlFlags( sal_uInt16 nFlags )
1171 : {
1172 5598 : mpWindowImpl->mnDlgCtrlFlags = nFlags;
1173 5598 : }
1174 :
1175 25397 : sal_uInt16 Window::GetDialogControlFlags() const
1176 : {
1177 25397 : return mpWindowImpl->mnDlgCtrlFlags;
1178 : }
1179 :
1180 36233 : const InputContext& Window::GetInputContext() const
1181 : {
1182 36233 : return mpWindowImpl->maInputContext;
1183 : }
1184 :
1185 164541 : bool Window::IsControlFont() const
1186 : {
1187 164541 : return (mpWindowImpl->mpControlFont != 0);
1188 : }
1189 :
1190 421 : Color Window::GetControlForeground() const
1191 : {
1192 421 : return mpWindowImpl->maControlForeground;
1193 : }
1194 :
1195 189731 : bool Window::IsControlForeground() const
1196 : {
1197 189731 : return mpWindowImpl->mbControlForeground;
1198 : }
1199 :
1200 2310 : Color Window::GetControlBackground() const
1201 : {
1202 2310 : return mpWindowImpl->maControlBackground;
1203 : }
1204 :
1205 379360 : bool Window::IsControlBackground() const
1206 : {
1207 379360 : return mpWindowImpl->mbControlBackground;
1208 : }
1209 :
1210 382460 : bool Window::IsInPaint() const
1211 : {
1212 382460 : return mpWindowImpl->mbInPaint;
1213 : }
1214 :
1215 39176845 : vcl::Window* Window::GetParent() const
1216 : {
1217 39176845 : return mpWindowImpl->mpRealParent;
1218 : }
1219 :
1220 2753049 : bool Window::IsVisible() const
1221 : {
1222 2753049 : return mpWindowImpl->mbVisible;
1223 : }
1224 :
1225 5470309 : bool Window::IsReallyVisible() const
1226 : {
1227 5470309 : return mpWindowImpl->mbReallyVisible;
1228 : }
1229 :
1230 217987 : bool Window::IsReallyShown() const
1231 : {
1232 217987 : return mpWindowImpl->mbReallyShown;
1233 : }
1234 :
1235 0 : bool Window::IsInInitShow() const
1236 : {
1237 0 : return mpWindowImpl->mbInInitShow;
1238 : }
1239 :
1240 390802 : bool Window::IsEnabled() const
1241 : {
1242 390802 : return !mpWindowImpl->mbDisabled;
1243 : }
1244 :
1245 63823 : bool Window::IsInputEnabled() const
1246 : {
1247 63823 : return !mpWindowImpl->mbInputDisabled;
1248 : }
1249 :
1250 0 : bool Window::IsAlwaysEnableInput() const
1251 : {
1252 0 : return mpWindowImpl->meAlwaysInputMode == AlwaysInputEnabled;
1253 : }
1254 :
1255 6158 : sal_uInt16 Window::GetActivateMode() const
1256 : {
1257 6158 : return mpWindowImpl->mnActivateMode;
1258 :
1259 : }
1260 :
1261 0 : bool Window::IsAlwaysOnTopEnabled() const
1262 : {
1263 0 : return mpWindowImpl->mbAlwaysOnTop;
1264 : }
1265 :
1266 0 : bool Window::IsDefaultPos() const
1267 : {
1268 0 : return mpWindowImpl->mbDefPos;
1269 : }
1270 :
1271 260 : bool Window::IsDefaultSize() const
1272 : {
1273 260 : return mpWindowImpl->mbDefSize;
1274 : }
1275 :
1276 49587 : void Window::EnablePaint( bool bEnable )
1277 : {
1278 49587 : mpWindowImpl->mbPaintDisabled = !bEnable;
1279 49587 : }
1280 :
1281 168381 : bool Window::IsPaintEnabled() const
1282 : {
1283 168381 : return !mpWindowImpl->mbPaintDisabled;
1284 : }
1285 :
1286 956892 : bool Window::IsUpdateMode() const
1287 : {
1288 956892 : return !mpWindowImpl->mbNoUpdate;
1289 : }
1290 :
1291 64 : void Window::SetParentUpdateMode( bool bUpdate )
1292 : {
1293 64 : mpWindowImpl->mbNoParentUpdate = !bUpdate;
1294 64 : }
1295 :
1296 62298 : bool Window::IsActive() const
1297 : {
1298 62298 : return mpWindowImpl->mbActive;
1299 : }
1300 :
1301 6294 : sal_uInt16 Window::GetGetFocusFlags() const
1302 : {
1303 6294 : return mpWindowImpl->mnGetFocusFlags;
1304 : }
1305 :
1306 68541 : bool Window::IsCompoundControl() const
1307 : {
1308 68541 : return mpWindowImpl->mbCompoundControl;
1309 : }
1310 :
1311 798 : bool Window::IsWait() const
1312 : {
1313 798 : return (mpWindowImpl->mnWaitCount != 0);
1314 : }
1315 :
1316 71153 : vcl::Cursor* Window::GetCursor() const
1317 : {
1318 71153 : return mpWindowImpl->mpCursor;
1319 : }
1320 :
1321 244862 : const Fraction& Window::GetZoom() const
1322 : {
1323 244862 : return mpWindowImpl->maZoom;
1324 : }
1325 :
1326 1760 : bool Window::IsZoom() const
1327 : {
1328 1760 : return mpWindowImpl->maZoom.GetNumerator() != mpWindowImpl->maZoom.GetDenominator();
1329 : }
1330 :
1331 3216 : void Window::SetHelpText( const OUString& rHelpText )
1332 : {
1333 3216 : mpWindowImpl->maHelpText = rHelpText;
1334 3216 : mpWindowImpl->mbHelpTextDynamic = true;
1335 3216 : }
1336 :
1337 32904 : void Window::SetQuickHelpText( const OUString& rHelpText )
1338 : {
1339 32904 : mpWindowImpl->maQuickHelpText = rHelpText;
1340 32904 : }
1341 :
1342 17218 : const OUString& Window::GetQuickHelpText() const
1343 : {
1344 17218 : return mpWindowImpl->maQuickHelpText;
1345 : }
1346 :
1347 126 : void Window::SetData( void* pNewData )
1348 : {
1349 126 : mpWindowImpl->mpUserData = pNewData;
1350 126 : }
1351 :
1352 0 : void* Window::GetData() const
1353 : {
1354 0 : return mpWindowImpl->mpUserData;
1355 : }
1356 :
1357 0 : bool Window::IsCreatedWithToolkit() const
1358 : {
1359 0 : return mpWindowImpl->mbCreatedWithToolkit;
1360 : }
1361 :
1362 50867 : void Window::SetCreatedWithToolkit( bool b )
1363 : {
1364 50867 : mpWindowImpl->mbCreatedWithToolkit = b;
1365 :
1366 50867 : }
1367 0 : const Pointer& Window::GetPointer() const
1368 : {
1369 0 : return mpWindowImpl->maPointer;
1370 : }
1371 :
1372 1434405 : VCLXWindow* Window::GetWindowPeer() const
1373 : {
1374 1434405 : return mpWindowImpl->mpVCLXWindow;
1375 : }
1376 :
1377 57754 : void Window::SetPosPixel( const Point& rNewPos )
1378 : {
1379 57754 : setPosSizePixel( rNewPos.X(), rNewPos.Y(), 0, 0, WINDOW_POSSIZE_POS );
1380 57754 : }
1381 :
1382 254077 : void Window::SetSizePixel( const Size& rNewSize )
1383 : {
1384 : setPosSizePixel( 0, 0, rNewSize.Width(), rNewSize.Height(),
1385 254077 : WINDOW_POSSIZE_SIZE );
1386 254077 : }
1387 :
1388 494873 : void Window::SetPosSizePixel( const Point& rNewPos, const Size& rNewSize )
1389 : {
1390 : setPosSizePixel( rNewPos.X(), rNewPos.Y(),
1391 : rNewSize.Width(), rNewSize.Height(),
1392 494873 : WINDOW_POSSIZE_POSSIZE );
1393 494873 : }
1394 :
1395 59562 : void Window::SetOutputSizePixel( const Size& rNewSize )
1396 : {
1397 59562 : SetSizePixel( Size( rNewSize.Width()+mpWindowImpl->mnLeftBorder+mpWindowImpl->mnRightBorder,
1398 119124 : rNewSize.Height()+mpWindowImpl->mnTopBorder+mpWindowImpl->mnBottomBorder ) );
1399 59562 : }
1400 :
1401 : //When a widget wants to renegotiate layout, get toplevel parent dialog and call
1402 : //resize on it. Mark all intermediate containers (or container-alike) widgets
1403 : //as dirty for the size remains unchanged, but layout changed circumstances
1404 : namespace
1405 : {
1406 2959683 : bool queue_ungrouped_resize(vcl::Window *pOrigWindow)
1407 : {
1408 2959683 : bool bSomeoneCares = false;
1409 :
1410 2959683 : vcl::Window *pWindow = pOrigWindow->GetParent();
1411 2959683 : if (pWindow)
1412 : {
1413 2856690 : if (isContainerWindow(*pWindow))
1414 : {
1415 439672 : bSomeoneCares = true;
1416 : }
1417 2417018 : else if (pWindow->GetType() == WINDOW_TABCONTROL)
1418 : {
1419 104 : bSomeoneCares = true;
1420 : }
1421 2856690 : pWindow->queue_resize();
1422 : }
1423 :
1424 2959683 : return bSomeoneCares;
1425 : }
1426 : }
1427 :
1428 2880717 : void Window::queue_resize(StateChangedType eReason)
1429 : {
1430 2880717 : bool bSomeoneCares = queue_ungrouped_resize(this);
1431 :
1432 2880717 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1433 2880717 : if (eReason != StateChangedType::VISIBLE)
1434 : {
1435 2276509 : pWindowImpl->mnOptimalWidthCache = -1;
1436 2276509 : pWindowImpl->mnOptimalHeightCache = -1;
1437 : }
1438 2880717 : if (pWindowImpl->m_xSizeGroup && pWindowImpl->m_xSizeGroup->get_mode() != VCL_SIZE_GROUP_NONE)
1439 : {
1440 27306 : std::set<vcl::Window*> &rWindows = pWindowImpl->m_xSizeGroup->get_widgets();
1441 160884 : for (std::set<vcl::Window*>::iterator aI = rWindows.begin(),
1442 27306 : aEnd = rWindows.end(); aI != aEnd; ++aI)
1443 : {
1444 106272 : vcl::Window *pOther = *aI;
1445 106272 : if (pOther == this)
1446 27306 : continue;
1447 78966 : queue_ungrouped_resize(pOther);
1448 : }
1449 : }
1450 :
1451 2880717 : if (bSomeoneCares)
1452 : {
1453 : //fdo#57090 force a resync of the borders of the borderwindow onto this
1454 : //window in case they have changed
1455 360810 : vcl::Window* pBorderWindow = ImplGetBorderWindow();
1456 360810 : if (pBorderWindow)
1457 22140 : pBorderWindow->Resize();
1458 : }
1459 2880717 : }
1460 :
1461 : namespace
1462 : {
1463 11820 : VclAlign toAlign(const OString &rValue)
1464 : {
1465 11820 : VclAlign eRet = VCL_ALIGN_FILL;
1466 :
1467 11820 : if (rValue == "fill")
1468 0 : eRet = VCL_ALIGN_FILL;
1469 11820 : else if (rValue == "start")
1470 738 : eRet = VCL_ALIGN_START;
1471 11082 : else if (rValue == "end")
1472 2218 : eRet = VCL_ALIGN_END;
1473 8864 : else if (rValue == "center")
1474 8864 : eRet = VCL_ALIGN_CENTER;
1475 11820 : return eRet;
1476 : }
1477 : }
1478 :
1479 0 : bool Window::set_font_attribute(const OString &rKey, const OString &rValue)
1480 : {
1481 0 : if (rKey == "weight")
1482 : {
1483 0 : vcl::Font aFont(GetControlFont());
1484 0 : if (rValue == "thin")
1485 0 : aFont.SetWeight(WEIGHT_THIN);
1486 0 : else if (rValue == "ultralight")
1487 0 : aFont.SetWeight(WEIGHT_ULTRALIGHT);
1488 0 : else if (rValue == "light")
1489 0 : aFont.SetWeight(WEIGHT_LIGHT);
1490 0 : else if (rValue == "book")
1491 0 : aFont.SetWeight(WEIGHT_SEMILIGHT);
1492 0 : else if (rValue == "normal")
1493 0 : aFont.SetWeight(WEIGHT_NORMAL);
1494 0 : else if (rValue == "medium")
1495 0 : aFont.SetWeight(WEIGHT_MEDIUM);
1496 0 : else if (rValue == "semibold")
1497 0 : aFont.SetWeight(WEIGHT_SEMIBOLD);
1498 0 : else if (rValue == "bold")
1499 0 : aFont.SetWeight(WEIGHT_BOLD);
1500 0 : else if (rValue == "ultrabold")
1501 0 : aFont.SetWeight(WEIGHT_ULTRABOLD);
1502 : else
1503 0 : aFont.SetWeight(WEIGHT_BLACK);
1504 0 : SetControlFont(aFont);
1505 : }
1506 0 : else if (rKey == "style")
1507 : {
1508 0 : vcl::Font aFont(GetControlFont());
1509 0 : if (rValue == "normal")
1510 0 : aFont.SetItalic(ITALIC_NONE);
1511 0 : else if (rValue == "oblique")
1512 0 : aFont.SetItalic(ITALIC_OBLIQUE);
1513 0 : else if (rValue == "italic")
1514 0 : aFont.SetItalic(ITALIC_NORMAL);
1515 0 : SetControlFont(aFont);
1516 : }
1517 0 : else if (rKey == "underline" && toBool(rValue) == true)
1518 : {
1519 0 : vcl::Font aFont(GetControlFont());
1520 0 : aFont.SetUnderline(UNDERLINE_SINGLE);
1521 0 : SetControlFont(aFont);
1522 : }
1523 0 : else if (rKey == "size")
1524 : {
1525 0 : vcl::Font aFont(GetControlFont());
1526 0 : sal_Int32 nHeight = rValue.toInt32() / 1000;
1527 0 : aFont.SetHeight(nHeight);
1528 0 : SetControlFont(aFont);
1529 : }
1530 : else
1531 : {
1532 : SAL_INFO("vcl.layout", "unhandled font attribute: " << rKey.getStr());
1533 0 : return false;
1534 : }
1535 0 : return true;
1536 : }
1537 :
1538 142826 : bool Window::set_property(const OString &rKey, const OString &rValue)
1539 : {
1540 142826 : if ((rKey == "label") || (rKey == "title") || (rKey == "text") )
1541 : {
1542 5224 : SetText(OStringToOUString(VclBuilder::convertMnemonicMarkup(rValue), RTL_TEXTENCODING_UTF8));
1543 : }
1544 137602 : else if (rKey == "visible")
1545 37898 : Show(toBool(rValue));
1546 99704 : else if (rKey == "sensitive")
1547 0 : Enable(toBool(rValue));
1548 99704 : else if (rKey == "resizable")
1549 : {
1550 0 : WinBits nBits = GetStyle();
1551 0 : nBits &= ~(WB_SIZEABLE);
1552 0 : if (toBool(rValue))
1553 0 : nBits |= WB_SIZEABLE;
1554 0 : SetStyle(nBits);
1555 : }
1556 99704 : else if (rKey == "xalign")
1557 : {
1558 1496 : WinBits nBits = GetStyle();
1559 1496 : nBits &= ~(WB_LEFT | WB_CENTER | WB_RIGHT);
1560 :
1561 1496 : float f = rValue.toFloat();
1562 1496 : if (f == 0.0)
1563 1496 : nBits |= WB_LEFT;
1564 0 : else if (f == 1.0)
1565 0 : nBits |= WB_RIGHT;
1566 0 : else if (f == 0.5)
1567 0 : nBits |= WB_CENTER;
1568 :
1569 1496 : SetStyle(nBits);
1570 : }
1571 98208 : else if (rKey == "justification")
1572 : {
1573 0 : WinBits nBits = GetStyle();
1574 0 : nBits &= ~(WB_LEFT | WB_CENTER | WB_RIGHT);
1575 :
1576 0 : if (rValue == "left")
1577 0 : nBits |= WB_LEFT;
1578 0 : else if (rValue == "right")
1579 0 : nBits |= WB_RIGHT;
1580 0 : else if (rValue == "center")
1581 0 : nBits |= WB_CENTER;
1582 :
1583 0 : SetStyle(nBits);
1584 : }
1585 98208 : else if (rKey == "yalign")
1586 : {
1587 0 : WinBits nBits = GetStyle();
1588 0 : nBits &= ~(WB_TOP | WB_VCENTER | WB_BOTTOM);
1589 :
1590 0 : float f = rValue.toFloat();
1591 0 : if (f == 0.0)
1592 0 : nBits |= WB_TOP;
1593 0 : else if (f == 1.0)
1594 0 : nBits |= WB_BOTTOM;
1595 0 : else if (f == 0.5)
1596 0 : nBits |= WB_CENTER;
1597 :
1598 0 : SetStyle(nBits);
1599 : }
1600 98208 : else if (rKey == "wrap")
1601 : {
1602 0 : WinBits nBits = GetStyle();
1603 0 : nBits &= ~(WB_WORDBREAK);
1604 0 : if (toBool(rValue))
1605 0 : nBits |= WB_WORDBREAK;
1606 0 : SetStyle(nBits);
1607 : }
1608 98208 : else if (rKey == "height-request")
1609 0 : set_height_request(rValue.toInt32());
1610 98208 : else if (rKey == "width-request")
1611 0 : set_width_request(rValue.toInt32());
1612 98208 : else if (rKey == "hexpand")
1613 7494 : set_hexpand(toBool(rValue));
1614 90714 : else if (rKey == "vexpand")
1615 110 : set_vexpand(toBool(rValue));
1616 90604 : else if (rKey == "halign")
1617 8130 : set_halign(toAlign(rValue));
1618 82474 : else if (rKey == "valign")
1619 3690 : set_valign(toAlign(rValue));
1620 78784 : else if (rKey == "tooltip-markup")
1621 0 : SetQuickHelpText(OStringToOUString(rValue, RTL_TEXTENCODING_UTF8));
1622 78784 : else if (rKey == "tooltip-text")
1623 9594 : SetQuickHelpText(OStringToOUString(rValue, RTL_TEXTENCODING_UTF8));
1624 69190 : else if (rKey == "border-width")
1625 2254 : set_border_width(rValue.toInt32());
1626 66936 : else if (rKey == "margin-left")
1627 28 : set_margin_left(rValue.toInt32());
1628 66908 : else if (rKey == "margin-right")
1629 26 : set_margin_right(rValue.toInt32());
1630 66882 : else if (rKey == "margin-top")
1631 8 : set_margin_top(rValue.toInt32());
1632 66874 : else if (rKey == "margin-bottom")
1633 8 : set_margin_bottom(rValue.toInt32());
1634 66866 : else if (rKey == "hscrollbar-policy")
1635 : {
1636 0 : WinBits nBits = GetStyle();
1637 0 : nBits &= ~(WB_AUTOHSCROLL|WB_HSCROLL);
1638 0 : if (rValue == "always")
1639 0 : nBits |= WB_HSCROLL;
1640 0 : else if (rValue == "automatic")
1641 0 : nBits |= WB_AUTOHSCROLL;
1642 0 : SetStyle(nBits);
1643 : }
1644 66866 : else if (rKey == "vscrollbar-policy")
1645 : {
1646 0 : WinBits nBits = GetStyle();
1647 0 : nBits &= ~(WB_AUTOVSCROLL|WB_VSCROLL);
1648 0 : if (rValue == "always")
1649 0 : nBits |= WB_VSCROLL;
1650 0 : else if (rValue == "automatic")
1651 0 : nBits |= WB_AUTOVSCROLL;
1652 0 : SetStyle(nBits);
1653 : }
1654 66866 : else if (rKey == "accessible-name")
1655 : {
1656 0 : SetAccessibleName(OStringToOUString(rValue, RTL_TEXTENCODING_UTF8));
1657 : }
1658 66866 : else if (rKey == "accessible-description")
1659 : {
1660 0 : SetAccessibleDescription(OStringToOUString(rValue, RTL_TEXTENCODING_UTF8));
1661 : }
1662 66866 : else if (rKey == "use-markup")
1663 : {
1664 : //https://live.gnome.org/GnomeGoals/RemoveMarkupInMessages
1665 : SAL_WARN_IF(toBool(rValue), "vcl.layout", "Use pango attributes instead of mark-up");
1666 : }
1667 : else
1668 : {
1669 : SAL_INFO("vcl.layout", "unhandled property: " << rKey.getStr());
1670 66866 : return false;
1671 : }
1672 75960 : return true;
1673 : }
1674 :
1675 1956 : void Window::set_height_request(sal_Int32 nHeightRequest)
1676 : {
1677 :
1678 1956 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1679 :
1680 1956 : if ( pWindowImpl->mnHeightRequest != nHeightRequest )
1681 : {
1682 1956 : pWindowImpl->mnHeightRequest = nHeightRequest;
1683 1956 : queue_resize();
1684 : }
1685 1956 : }
1686 :
1687 5650 : void Window::set_width_request(sal_Int32 nWidthRequest)
1688 : {
1689 :
1690 5650 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1691 :
1692 5650 : if ( pWindowImpl->mnWidthRequest != nWidthRequest )
1693 : {
1694 5648 : pWindowImpl->mnWidthRequest = nWidthRequest;
1695 5648 : queue_resize();
1696 : }
1697 5650 : }
1698 :
1699 237153 : Size Window::get_ungrouped_preferred_size() const
1700 : {
1701 237153 : Size aRet(get_width_request(), get_height_request());
1702 237153 : if (aRet.Width() == -1 || aRet.Height() == -1)
1703 : {
1704 : //cache gets blown away by queue_resize
1705 232721 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1706 232721 : if (pWindowImpl->mnOptimalWidthCache == -1 || pWindowImpl->mnOptimalHeightCache == -1)
1707 : {
1708 42868 : Size aOptimal(GetOptimalSize());
1709 42868 : pWindowImpl->mnOptimalWidthCache = aOptimal.Width();
1710 42868 : pWindowImpl->mnOptimalHeightCache = aOptimal.Height();
1711 : }
1712 :
1713 232721 : if (aRet.Width() == -1)
1714 214265 : aRet.Width() = pWindowImpl->mnOptimalWidthCache;
1715 232721 : if (aRet.Height() == -1)
1716 232721 : aRet.Height() = pWindowImpl->mnOptimalHeightCache;
1717 : }
1718 237153 : return aRet;
1719 : }
1720 :
1721 170733 : Size Window::get_preferred_size() const
1722 : {
1723 170733 : Size aRet(get_ungrouped_preferred_size());
1724 :
1725 170733 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1726 170733 : if (pWindowImpl->m_xSizeGroup)
1727 : {
1728 13284 : const VclSizeGroupMode eMode = pWindowImpl->m_xSizeGroup->get_mode();
1729 13284 : if (eMode != VCL_SIZE_GROUP_NONE)
1730 : {
1731 13284 : const bool bIgnoreInHidden = pWindowImpl->m_xSizeGroup->get_ignore_hidden();
1732 13284 : const std::set<vcl::Window*> &rWindows = pWindowImpl->m_xSizeGroup->get_widgets();
1733 106272 : for (std::set<vcl::Window*>::const_iterator aI = rWindows.begin(),
1734 13284 : aEnd = rWindows.end(); aI != aEnd; ++aI)
1735 : {
1736 79704 : const vcl::Window *pOther = *aI;
1737 79704 : if (pOther == this)
1738 26568 : continue;
1739 66420 : if (bIgnoreInHidden && !pOther->IsVisible())
1740 0 : continue;
1741 66420 : Size aOtherSize = pOther->get_ungrouped_preferred_size();
1742 66420 : if (eMode == VCL_SIZE_GROUP_BOTH || eMode == VCL_SIZE_GROUP_HORIZONTAL)
1743 0 : aRet.Width() = std::max(aRet.Width(), aOtherSize.Width());
1744 66420 : if (eMode == VCL_SIZE_GROUP_BOTH || eMode == VCL_SIZE_GROUP_VERTICAL)
1745 66420 : aRet.Height() = std::max(aRet.Height(), aOtherSize.Height());
1746 : }
1747 : }
1748 : }
1749 :
1750 170733 : return aRet;
1751 : }
1752 :
1753 64747 : VclAlign Window::get_halign() const
1754 : {
1755 64747 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1756 64747 : return pWindowImpl->meHalign;
1757 : }
1758 :
1759 8130 : void Window::set_halign(VclAlign eAlign)
1760 : {
1761 8130 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1762 8130 : pWindowImpl->meHalign = eAlign;
1763 8130 : }
1764 :
1765 64747 : VclAlign Window::get_valign() const
1766 : {
1767 64747 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1768 64747 : return pWindowImpl->meValign;
1769 : }
1770 :
1771 3690 : void Window::set_valign(VclAlign eAlign)
1772 : {
1773 3690 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1774 3690 : pWindowImpl->meValign = eAlign;
1775 3690 : }
1776 :
1777 93304 : bool Window::get_hexpand() const
1778 : {
1779 93304 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1780 93304 : return pWindowImpl->mbHexpand;
1781 : }
1782 :
1783 7494 : void Window::set_hexpand(bool bExpand)
1784 : {
1785 7494 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1786 7494 : pWindowImpl->mbHexpand = bExpand;
1787 7494 : }
1788 :
1789 72282 : bool Window::get_vexpand() const
1790 : {
1791 72282 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1792 72282 : return pWindowImpl->mbVexpand;
1793 : }
1794 :
1795 110 : void Window::set_vexpand(bool bExpand)
1796 : {
1797 110 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1798 110 : pWindowImpl->mbVexpand = bExpand;
1799 110 : }
1800 :
1801 98104 : bool Window::get_expand() const
1802 : {
1803 98104 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1804 98104 : return pWindowImpl->mbExpand;
1805 : }
1806 :
1807 26618 : void Window::set_expand(bool bExpand)
1808 : {
1809 26618 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1810 26618 : pWindowImpl->mbExpand = bExpand;
1811 26618 : }
1812 :
1813 100840 : VclPackType Window::get_pack_type() const
1814 : {
1815 100840 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1816 100840 : return pWindowImpl->mePackType;
1817 : }
1818 :
1819 3690 : void Window::set_pack_type(VclPackType ePackType)
1820 : {
1821 3690 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1822 3690 : pWindowImpl->mePackType = ePackType;
1823 3690 : }
1824 :
1825 95080 : sal_Int32 Window::get_padding() const
1826 : {
1827 95080 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1828 95080 : return pWindowImpl->mnPadding;
1829 : }
1830 :
1831 0 : void Window::set_padding(sal_Int32 nPadding)
1832 : {
1833 0 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1834 0 : pWindowImpl->mnPadding = nPadding;
1835 0 : }
1836 :
1837 49056 : bool Window::get_fill() const
1838 : {
1839 49056 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1840 49056 : return pWindowImpl->mbFill;
1841 : }
1842 :
1843 26618 : void Window::set_fill(bool bFill)
1844 : {
1845 26618 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1846 26618 : pWindowImpl->mbFill = bFill;
1847 26618 : }
1848 :
1849 33382 : sal_Int32 Window::get_grid_width() const
1850 : {
1851 33382 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1852 33382 : return pWindowImpl->mnGridWidth;
1853 : }
1854 :
1855 8978 : void Window::set_grid_width(sal_Int32 nCols)
1856 : {
1857 8978 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1858 8978 : pWindowImpl->mnGridWidth = nCols;
1859 8978 : }
1860 :
1861 97006 : sal_Int32 Window::get_grid_left_attach() const
1862 : {
1863 97006 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1864 97006 : return pWindowImpl->mnGridLeftAttach;
1865 : }
1866 :
1867 8978 : void Window::set_grid_left_attach(sal_Int32 nAttach)
1868 : {
1869 8978 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1870 8978 : pWindowImpl->mnGridLeftAttach = nAttach;
1871 8978 : }
1872 :
1873 33382 : sal_Int32 Window::get_grid_height() const
1874 : {
1875 33382 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1876 33382 : return pWindowImpl->mnGridHeight;
1877 : }
1878 :
1879 8978 : void Window::set_grid_height(sal_Int32 nRows)
1880 : {
1881 8978 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1882 8978 : pWindowImpl->mnGridHeight = nRows;
1883 8978 : }
1884 :
1885 101570 : sal_Int32 Window::get_grid_top_attach() const
1886 : {
1887 101570 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1888 101570 : return pWindowImpl->mnGridTopAttach;
1889 : }
1890 :
1891 8978 : void Window::set_grid_top_attach(sal_Int32 nAttach)
1892 : {
1893 8978 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1894 8978 : pWindowImpl->mnGridTopAttach = nAttach;
1895 8978 : }
1896 :
1897 2254 : void Window::set_border_width(sal_Int32 nBorderWidth)
1898 : {
1899 2254 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1900 2254 : pWindowImpl->mnBorderWidth = nBorderWidth;
1901 2254 : }
1902 :
1903 214010 : sal_Int32 Window::get_border_width() const
1904 : {
1905 214010 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1906 214010 : return pWindowImpl->mnBorderWidth;
1907 : }
1908 :
1909 28 : void Window::set_margin_left(sal_Int32 nWidth)
1910 : {
1911 28 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1912 28 : pWindowImpl->mnMarginLeft = nWidth;
1913 28 : }
1914 :
1915 213874 : sal_Int32 Window::get_margin_left() const
1916 : {
1917 213874 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1918 213874 : return pWindowImpl->mnMarginLeft;
1919 : }
1920 :
1921 26 : void Window::set_margin_right(sal_Int32 nWidth)
1922 : {
1923 26 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1924 26 : pWindowImpl->mnMarginRight = nWidth;
1925 26 : }
1926 :
1927 213874 : sal_Int32 Window::get_margin_right() const
1928 : {
1929 213874 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1930 213874 : return pWindowImpl->mnMarginRight;
1931 : }
1932 :
1933 8 : void Window::set_margin_top(sal_Int32 nWidth)
1934 : {
1935 8 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1936 8 : pWindowImpl->mnMarginTop = nWidth;
1937 8 : }
1938 :
1939 213874 : sal_Int32 Window::get_margin_top() const
1940 : {
1941 213874 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1942 213874 : return pWindowImpl->mnMarginTop;
1943 : }
1944 :
1945 8 : void Window::set_margin_bottom(sal_Int32 nWidth)
1946 : {
1947 8 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1948 8 : pWindowImpl->mnMarginBottom = nWidth;
1949 8 : }
1950 :
1951 213874 : sal_Int32 Window::get_margin_bottom() const
1952 : {
1953 213874 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1954 213874 : return pWindowImpl->mnMarginBottom;
1955 : }
1956 :
1957 237155 : sal_Int32 Window::get_height_request() const
1958 : {
1959 237155 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1960 237155 : return pWindowImpl->mnHeightRequest;
1961 : }
1962 :
1963 238607 : sal_Int32 Window::get_width_request() const
1964 : {
1965 238607 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1966 238607 : return pWindowImpl->mnWidthRequest;
1967 : }
1968 :
1969 44404 : bool Window::get_secondary() const
1970 : {
1971 44404 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1972 44404 : return pWindowImpl->mbSecondary;
1973 : }
1974 :
1975 0 : void Window::set_secondary(bool bSecondary)
1976 : {
1977 0 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1978 0 : pWindowImpl->mbSecondary = bSecondary;
1979 0 : }
1980 :
1981 0 : bool Window::get_non_homogeneous() const
1982 : {
1983 0 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1984 0 : return pWindowImpl->mbNonHomogeneous;
1985 : }
1986 :
1987 0 : void Window::set_non_homogeneous(bool bNonHomogeneous)
1988 : {
1989 0 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1990 0 : pWindowImpl->mbNonHomogeneous = bNonHomogeneous;
1991 0 : }
1992 :
1993 4428 : void Window::add_to_size_group(boost::shared_ptr< VclSizeGroup > xGroup)
1994 : {
1995 4428 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
1996 : //To-Do, multiple groups
1997 4428 : pWindowImpl->m_xSizeGroup = xGroup;
1998 4428 : pWindowImpl->m_xSizeGroup->insert(this);
1999 4428 : if (VCL_SIZE_GROUP_NONE != pWindowImpl->m_xSizeGroup->get_mode())
2000 4428 : queue_resize();
2001 4428 : }
2002 :
2003 442826 : void Window::remove_from_all_size_groups()
2004 : {
2005 442826 : WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl : mpWindowImpl;
2006 : //To-Do, multiple groups
2007 442826 : if (pWindowImpl->m_xSizeGroup)
2008 : {
2009 4428 : if (VCL_SIZE_GROUP_NONE != pWindowImpl->m_xSizeGroup->get_mode())
2010 4428 : queue_resize();
2011 4428 : pWindowImpl->m_xSizeGroup->erase(this);
2012 4428 : pWindowImpl->m_xSizeGroup.reset();
2013 : }
2014 442826 : }
2015 :
2016 1476 : void Window::add_mnemonic_label(FixedText *pLabel)
2017 : {
2018 1476 : std::vector<FixedText*>& v = mpWindowImpl->m_aMnemonicLabels;
2019 1476 : if (std::find(v.begin(), v.end(), pLabel) != v.end())
2020 1476 : return;
2021 1476 : v.push_back(pLabel);
2022 1476 : pLabel->set_mnemonic_widget(this);
2023 : }
2024 :
2025 2952 : void Window::remove_mnemonic_label(FixedText *pLabel)
2026 : {
2027 2952 : std::vector<FixedText*>& v = mpWindowImpl->m_aMnemonicLabels;
2028 2952 : std::vector<FixedText*>::iterator aFind = std::find(v.begin(), v.end(), pLabel);
2029 2952 : if (aFind == v.end())
2030 4428 : return;
2031 1476 : v.erase(aFind);
2032 1476 : pLabel->set_mnemonic_widget(NULL);
2033 : }
2034 :
2035 452560 : std::vector<FixedText*> Window::list_mnemonic_labels() const
2036 : {
2037 452560 : return mpWindowImpl->m_aMnemonicLabels;
2038 : }
2039 :
2040 1233 : } /* namespace vcl */
2041 :
2042 :
2043 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
