diff options
Diffstat (limited to 'vcl/source/window/window2.cxx')
| -rw-r--r-- | vcl/source/window/window2.cxx | 1984 |
1 files changed, 1984 insertions, 0 deletions
diff --git a/vcl/source/window/window2.cxx b/vcl/source/window/window2.cxx new file mode 100644 index 000000000..6e5bbc372 --- /dev/null +++ b/vcl/source/window/window2.cxx @@ -0,0 +1,1984 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <limits.h> + +#include <o3tl/float_int_conversion.hxx> +#include <sal/log.hxx> + +#include <vcl/toolkit/dialog.hxx> +#include <vcl/event.hxx> +#include <vcl/fixed.hxx> +#include <vcl/layout.hxx> +#include <vcl/timer.hxx> +#include <vcl/window.hxx> +#include <vcl/scrbar.hxx> +#include <vcl/dockwin.hxx> +#include <vcl/settings.hxx> +#include <vcl/builder.hxx> + +#include <window.h> +#include <svdata.hxx> +#include <salgdi.hxx> +#include <salframe.hxx> +#include <scrwnd.hxx> + +#include <com/sun/star/accessibility/AccessibleRelation.hpp> +#include <com/sun/star/accessibility/AccessibleRole.hpp> + +using namespace com::sun::star; + +namespace vcl { + +void Window::ShowFocus( const tools::Rectangle& rRect ) +{ + if( mpWindowImpl->mbInShowFocus ) + return; + mpWindowImpl->mbInShowFocus = true; + + ImplWinData* pWinData = ImplGetWinData(); + + // native themeing suggest not to use focus rects + if( ! ( mpWindowImpl->mbUseNativeFocus && + IsNativeWidgetEnabled() ) ) + { + if ( !mpWindowImpl->mbInPaint ) + { + if ( mpWindowImpl->mbFocusVisible ) + { + if ( *pWinData->mpFocusRect == rRect ) + { + mpWindowImpl->mbInShowFocus = false; + return; + } + + ImplInvertFocus( *pWinData->mpFocusRect ); + } + + ImplInvertFocus( rRect ); + } + pWinData->mpFocusRect = rRect; + mpWindowImpl->mbFocusVisible = true; + } + else + { + if( ! mpWindowImpl->mbNativeFocusVisible ) + { + mpWindowImpl->mbNativeFocusVisible = true; + if ( !mpWindowImpl->mbInPaint ) + Invalidate(); + } + } + mpWindowImpl->mbInShowFocus = false; +} + +void Window::HideFocus() +{ + + if( mpWindowImpl->mbInHideFocus ) + return; + mpWindowImpl->mbInHideFocus = true; + + // native themeing can suggest not to use focus rects + if( ! ( mpWindowImpl->mbUseNativeFocus && + IsNativeWidgetEnabled() ) ) + { + if ( !mpWindowImpl->mbFocusVisible ) + { + mpWindowImpl->mbInHideFocus = false; + return; + } + + if ( !mpWindowImpl->mbInPaint ) + ImplInvertFocus( *ImplGetWinData()->mpFocusRect ); + mpWindowImpl->mbFocusVisible = false; + } + else + { + if( mpWindowImpl->mbNativeFocusVisible ) + { + mpWindowImpl->mbNativeFocusVisible = false; + if ( !mpWindowImpl->mbInPaint ) + Invalidate(); + } + } + mpWindowImpl->mbInHideFocus = false; +} + +void Window::ShowTracking( const tools::Rectangle& rRect, ShowTrackFlags nFlags ) +{ + ImplWinData* pWinData = ImplGetWinData(); + + if ( !mpWindowImpl->mbInPaint || !(nFlags & ShowTrackFlags::TrackWindow) ) + { + if ( mpWindowImpl->mbTrackVisible ) + { + if ( (*pWinData->mpTrackRect == rRect) && + (pWinData->mnTrackFlags == nFlags) ) + return; + + InvertTracking( *pWinData->mpTrackRect, pWinData->mnTrackFlags ); + } + + InvertTracking( rRect, nFlags ); + } + + pWinData->mpTrackRect = rRect; + pWinData->mnTrackFlags = nFlags; + mpWindowImpl->mbTrackVisible = true; +} + +void Window::HideTracking() +{ + if ( mpWindowImpl->mbTrackVisible ) + { + ImplWinData* pWinData = ImplGetWinData(); + if ( !mpWindowImpl->mbInPaint || !(pWinData->mnTrackFlags & ShowTrackFlags::TrackWindow) ) + InvertTracking( *pWinData->mpTrackRect, pWinData->mnTrackFlags ); + mpWindowImpl->mbTrackVisible = false; + } +} + +void Window::InvertTracking( const tools::Rectangle& rRect, ShowTrackFlags nFlags ) +{ + OutputDevice *pOutDev = GetOutDev(); + tools::Rectangle aRect( pOutDev->ImplLogicToDevicePixel( rRect ) ); + + if ( aRect.IsEmpty() ) + return; + aRect.Justify(); + + SalGraphics* pGraphics; + + if ( nFlags & ShowTrackFlags::TrackWindow ) + { + if ( !IsDeviceOutputNecessary() ) + return; + + // we need a graphics + if ( !mpGraphics ) + { + if ( !pOutDev->AcquireGraphics() ) + return; + } + + if ( mbInitClipRegion ) + InitClipRegion(); + + if ( mbOutputClipped ) + return; + + pGraphics = mpGraphics; + } + else + { + pGraphics = ImplGetFrameGraphics(); + + if ( nFlags & ShowTrackFlags::Clip ) + { + Point aPoint( mnOutOffX, mnOutOffY ); + vcl::Region aRegion( tools::Rectangle( aPoint, + Size( mnOutWidth, mnOutHeight ) ) ); + ImplClipBoundaries( aRegion, false, false ); + pOutDev->SelectClipRegion( aRegion, pGraphics ); + } + } + + ShowTrackFlags nStyle = nFlags & ShowTrackFlags::StyleMask; + if ( nStyle == ShowTrackFlags::Object ) + pGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight(), SalInvert::TrackFrame, this ); + else if ( nStyle == ShowTrackFlags::Split ) + pGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight(), SalInvert::N50, this ); + else + { + long nBorder = 1; + if ( nStyle == ShowTrackFlags::Big ) + nBorder = 5; + pGraphics->Invert( aRect.Left(), aRect.Top(), aRect.GetWidth(), nBorder, SalInvert::N50, this ); + pGraphics->Invert( aRect.Left(), aRect.Bottom()-nBorder+1, aRect.GetWidth(), nBorder, SalInvert::N50, this ); + pGraphics->Invert( aRect.Left(), aRect.Top()+nBorder, nBorder, aRect.GetHeight()-(nBorder*2), SalInvert::N50, this ); + pGraphics->Invert( aRect.Right()-nBorder+1, aRect.Top()+nBorder, nBorder, aRect.GetHeight()-(nBorder*2), SalInvert::N50, this ); + } +} + +IMPL_LINK( Window, ImplTrackTimerHdl, Timer*, pTimer, void ) +{ + ImplSVData* pSVData = ImplGetSVData(); + + // if Button-Repeat we have to change the timeout + if ( pSVData->mpWinData->mnTrackFlags & StartTrackingFlags::ButtonRepeat ) + pTimer->SetTimeout( GetSettings().GetMouseSettings().GetButtonRepeat() ); + + // create Tracking-Event + Point aMousePos( mpWindowImpl->mpFrameData->mnLastMouseX, mpWindowImpl->mpFrameData->mnLastMouseY ); + if( ImplIsAntiparallel() ) + { + // re-mirror frame pos at pChild + const OutputDevice *pOutDev = GetOutDev(); + pOutDev->ReMirror( aMousePos ); + } + MouseEvent aMEvt( ImplFrameToOutput( aMousePos ), + mpWindowImpl->mpFrameData->mnClickCount, MouseEventModifiers::NONE, + mpWindowImpl->mpFrameData->mnMouseCode, + mpWindowImpl->mpFrameData->mnMouseCode ); + TrackingEvent aTEvt( aMEvt, TrackingEventFlags::Repeat ); + Tracking( aTEvt ); +} + +void Window::StartTracking( StartTrackingFlags nFlags ) +{ + ImplSVData* pSVData = ImplGetSVData(); + + if ( pSVData->mpWinData->mpTrackWin.get() != this ) + { + if ( pSVData->mpWinData->mpTrackWin ) + pSVData->mpWinData->mpTrackWin->EndTracking( TrackingEventFlags::Cancel ); + } + + if ( nFlags & (StartTrackingFlags::ScrollRepeat | StartTrackingFlags::ButtonRepeat) ) + { + pSVData->mpWinData->mpTrackTimer = new AutoTimer; + + if ( nFlags & StartTrackingFlags::ScrollRepeat ) + pSVData->mpWinData->mpTrackTimer->SetTimeout( MouseSettings::GetScrollRepeat() ); + else + pSVData->mpWinData->mpTrackTimer->SetTimeout( MouseSettings::GetButtonStartRepeat() ); + pSVData->mpWinData->mpTrackTimer->SetInvokeHandler( LINK( this, Window, ImplTrackTimerHdl ) ); + pSVData->mpWinData->mpTrackTimer->SetDebugName( "vcl::Window pSVData->mpWinData->mpTrackTimer" ); + pSVData->mpWinData->mpTrackTimer->Start(); + } + + pSVData->mpWinData->mpTrackWin = this; + pSVData->mpWinData->mnTrackFlags = nFlags; + CaptureMouse(); +} + +void Window::EndTracking( TrackingEventFlags nFlags ) +{ + ImplSVData* pSVData = ImplGetSVData(); + + if ( pSVData->mpWinData->mpTrackWin.get() == this ) + { + if ( pSVData->mpWinData->mpTrackTimer ) + { + delete pSVData->mpWinData->mpTrackTimer; + pSVData->mpWinData->mpTrackTimer = nullptr; + } + + pSVData->mpWinData->mpTrackWin = nullptr; + pSVData->mpWinData->mnTrackFlags = StartTrackingFlags::NONE; + ReleaseMouse(); + + // call EndTracking if required + { + Point aMousePos( mpWindowImpl->mpFrameData->mnLastMouseX, mpWindowImpl->mpFrameData->mnLastMouseY ); + if( ImplIsAntiparallel() ) + { + // re-mirror frame pos at pChild + const OutputDevice *pOutDev = GetOutDev(); + pOutDev->ReMirror( aMousePos ); + } + + MouseEvent aMEvt( ImplFrameToOutput( aMousePos ), + mpWindowImpl->mpFrameData->mnClickCount, MouseEventModifiers::NONE, + mpWindowImpl->mpFrameData->mnMouseCode, + mpWindowImpl->mpFrameData->mnMouseCode ); + TrackingEvent aTEvt( aMEvt, nFlags | TrackingEventFlags::End ); + // CompatTracking effectively + if (!mpWindowImpl || mpWindowImpl->mbInDispose) + return Window::Tracking( aTEvt ); + else + return Tracking( aTEvt ); + } + } +} + +bool Window::IsTracking() const +{ + return (ImplGetSVData()->mpWinData->mpTrackWin == this); +} + +void Window::StartAutoScroll( StartAutoScrollFlags nFlags ) +{ + ImplSVData* pSVData = ImplGetSVData(); + + if ( pSVData->mpWinData->mpAutoScrollWin.get() != this ) + { + if ( pSVData->mpWinData->mpAutoScrollWin ) + pSVData->mpWinData->mpAutoScrollWin->EndAutoScroll(); + } + + pSVData->mpWinData->mpAutoScrollWin = this; + pSVData->mpWinData->mnAutoScrollFlags = nFlags; + pSVData->maAppData.mpWheelWindow = VclPtr<ImplWheelWindow>::Create( this ); +} + +void Window::EndAutoScroll() +{ + ImplSVData* pSVData = ImplGetSVData(); + + if ( pSVData->mpWinData->mpAutoScrollWin.get() == this ) + { + pSVData->mpWinData->mpAutoScrollWin = nullptr; + pSVData->mpWinData->mnAutoScrollFlags = StartAutoScrollFlags::NONE; + pSVData->maAppData.mpWheelWindow->ImplStop(); + pSVData->maAppData.mpWheelWindow->SetParentToDefaultWindow(); + pSVData->maAppData.mpWheelWindow.disposeAndClear(); + } +} + +VclPtr<vcl::Window> Window::SaveFocus() +{ + ImplSVData* pSVData = ImplGetSVData(); + if ( pSVData->mpWinData->mpFocusWin ) + { + return pSVData->mpWinData->mpFocusWin; + } + else + return nullptr; +} + +void Window::EndSaveFocus(const VclPtr<vcl::Window>& xFocusWin) +{ + if (xFocusWin && !xFocusWin->IsDisposed()) + { + xFocusWin->GrabFocus(); + } +} + +void Window::SetZoom( const Fraction& rZoom ) +{ + if ( mpWindowImpl && mpWindowImpl->maZoom != rZoom ) + { + mpWindowImpl->maZoom = rZoom; + CompatStateChanged( StateChangedType::Zoom ); + } +} + +static long WinFloatRound( double fVal ) +{ + return( fVal > 0.0 ? static_cast<long>( fVal + 0.5 ) : -static_cast<long>( -fVal + 0.5 ) ); +} + +void Window::SetZoomedPointFont(vcl::RenderContext& rRenderContext, const vcl::Font& rFont) +{ + const Fraction& rZoom = GetZoom(); + if (rZoom.GetNumerator() != rZoom.GetDenominator()) + { + vcl::Font aFont(rFont); + Size aSize = aFont.GetFontSize(); + aSize.setWidth( WinFloatRound(double(aSize.Width() * rZoom)) ); + aSize.setHeight( WinFloatRound(double(aSize.Height() * rZoom)) ); + aFont.SetFontSize(aSize); + SetPointFont(rRenderContext, aFont); + } + else + { + SetPointFont(rRenderContext, rFont); + } +} + +long Window::CalcZoom( long nCalc ) const +{ + + const Fraction& rZoom = GetZoom(); + if ( rZoom.GetNumerator() != rZoom.GetDenominator() ) + { + double n = double(nCalc * rZoom); + nCalc = WinFloatRound( n ); + } + return nCalc; +} + +void Window::SetControlFont() +{ + if (mpWindowImpl && mpWindowImpl->mpControlFont) + { + mpWindowImpl->mpControlFont.reset(); + CompatStateChanged(StateChangedType::ControlFont); + } +} + +void Window::SetControlFont(const vcl::Font& rFont) +{ + if (rFont == vcl::Font()) + { + SetControlFont(); + return; + } + + if (mpWindowImpl->mpControlFont) + { + if (*mpWindowImpl->mpControlFont == rFont) + return; + *mpWindowImpl->mpControlFont = rFont; + } + else + mpWindowImpl->mpControlFont.reset( new vcl::Font(rFont) ); + + CompatStateChanged(StateChangedType::ControlFont); +} + +vcl::Font Window::GetControlFont() const +{ + if (mpWindowImpl->mpControlFont) + return *mpWindowImpl->mpControlFont; + else + { + vcl::Font aFont; + return aFont; + } +} + +void Window::ApplyControlFont(vcl::RenderContext& rRenderContext, const vcl::Font& rFont) +{ + vcl::Font aFont(rFont); + if (IsControlFont()) + aFont.Merge(GetControlFont()); + SetZoomedPointFont(rRenderContext, aFont); +} + +void Window::SetControlForeground() +{ + if (mpWindowImpl->mbControlForeground) + { + mpWindowImpl->maControlForeground = COL_TRANSPARENT; + mpWindowImpl->mbControlForeground = false; + CompatStateChanged(StateChangedType::ControlForeground); + } +} + +void Window::SetControlForeground(const Color& rColor) +{ + if (rColor.GetTransparency()) + { + if (mpWindowImpl->mbControlForeground) + { + mpWindowImpl->maControlForeground = COL_TRANSPARENT; + mpWindowImpl->mbControlForeground = false; + CompatStateChanged(StateChangedType::ControlForeground); + } + } + else + { + if (mpWindowImpl->maControlForeground != rColor) + { + mpWindowImpl->maControlForeground = rColor; + mpWindowImpl->mbControlForeground = true; + CompatStateChanged(StateChangedType::ControlForeground); + } + } +} + +void Window::ApplyControlForeground(vcl::RenderContext& rRenderContext, const Color& rDefaultColor) +{ + Color aTextColor(rDefaultColor); + if (IsControlForeground()) + aTextColor = GetControlForeground(); + rRenderContext.SetTextColor(aTextColor); +} + +void Window::SetControlBackground() +{ + if (mpWindowImpl->mbControlBackground) + { + mpWindowImpl->maControlBackground = COL_TRANSPARENT; + mpWindowImpl->mbControlBackground = false; + CompatStateChanged(StateChangedType::ControlBackground); + } +} + +void Window::SetControlBackground(const Color& rColor) +{ + if (rColor.GetTransparency()) + { + if (mpWindowImpl->mbControlBackground) + { + mpWindowImpl->maControlBackground = COL_TRANSPARENT; + mpWindowImpl->mbControlBackground = false; + CompatStateChanged(StateChangedType::ControlBackground); + } + } + else + { + if (mpWindowImpl->maControlBackground != rColor) + { + mpWindowImpl->maControlBackground = rColor; + mpWindowImpl->mbControlBackground = true; + CompatStateChanged(StateChangedType::ControlBackground); + } + } +} + +void Window::ApplyControlBackground(vcl::RenderContext& rRenderContext, const Color& rDefaultColor) +{ + Color aColor(rDefaultColor); + if (IsControlBackground()) + aColor = GetControlBackground(); + rRenderContext.SetBackground(aColor); +} + +Size Window::CalcWindowSize( const Size& rOutSz ) const +{ + Size aSz = rOutSz; + aSz.AdjustWidth(mpWindowImpl->mnLeftBorder+mpWindowImpl->mnRightBorder ); + aSz.AdjustHeight(mpWindowImpl->mnTopBorder+mpWindowImpl->mnBottomBorder ); + return aSz; +} + +Size Window::CalcOutputSize( const Size& rWinSz ) const +{ + Size aSz = rWinSz; + aSz.AdjustWidth( -(mpWindowImpl->mnLeftBorder+mpWindowImpl->mnRightBorder) ); + aSz.AdjustHeight( -(mpWindowImpl->mnTopBorder+mpWindowImpl->mnBottomBorder) ); + return aSz; +} + +vcl::Font Window::GetDrawPixelFont(OutputDevice const * pDev) const +{ + vcl::Font aFont = GetPointFont(*const_cast<Window*>(this)); + Size aFontSize = aFont.GetFontSize(); + MapMode aPtMapMode(MapUnit::MapPoint); + aFontSize = pDev->LogicToPixel( aFontSize, aPtMapMode ); + aFont.SetFontSize( aFontSize ); + return aFont; +} + +long Window::GetDrawPixel( OutputDevice const * pDev, long nPixels ) const +{ + long nP = nPixels; + if ( pDev->GetOutDevType() != OUTDEV_WINDOW ) + { + MapMode aMap( MapUnit::Map100thMM ); + Size aSz( nP, 0 ); + aSz = PixelToLogic( aSz, aMap ); + aSz = pDev->LogicToPixel( aSz, aMap ); + nP = aSz.Width(); + } + return nP; +} + +static void lcl_HandleScrollHelper( ScrollBar* pScrl, double nN, bool isMultiplyByLineSize ) +{ + if ( pScrl && nN && pScrl->IsEnabled() && pScrl->IsInputEnabled() && ! pScrl->IsInModalMode() ) + { + long nNewPos = pScrl->GetThumbPos(); + + if ( nN == double(-LONG_MAX) ) + nNewPos += pScrl->GetPageSize(); + else if ( nN == double(LONG_MAX) ) + nNewPos -= pScrl->GetPageSize(); + else + { + // allowing both chunked and continuous scrolling + if(isMultiplyByLineSize){ + nN*=pScrl->GetLineSize(); + } + + const double fVal = nNewPos - nN; + + if ( !o3tl::convertsToAtLeast(fVal, LONG_MIN) ) + nNewPos = LONG_MIN; + else if ( !o3tl::convertsToAtMost(fVal, LONG_MAX) ) + nNewPos = LONG_MAX; + else + nNewPos = static_cast<long>(fVal); + } + + pScrl->DoScroll( nNewPos ); + } + +} + +bool Window::HandleScrollCommand( const CommandEvent& rCmd, + ScrollBar* pHScrl, ScrollBar* pVScrl ) +{ + bool bRet = false; + + if ( pHScrl || pVScrl ) + { + switch( rCmd.GetCommand() ) + { + case CommandEventId::StartAutoScroll: + { + StartAutoScrollFlags nFlags = StartAutoScrollFlags::NONE; + if ( pHScrl ) + { + if ( (pHScrl->GetVisibleSize() < pHScrl->GetRangeMax()) && + pHScrl->IsEnabled() && pHScrl->IsInputEnabled() && ! pHScrl->IsInModalMode() ) + nFlags |= StartAutoScrollFlags::Horz; + } + if ( pVScrl ) + { + if ( (pVScrl->GetVisibleSize() < pVScrl->GetRangeMax()) && + pVScrl->IsEnabled() && pVScrl->IsInputEnabled() && ! pVScrl->IsInModalMode() ) + nFlags |= StartAutoScrollFlags::Vert; + } + + if ( nFlags != StartAutoScrollFlags::NONE ) + { + StartAutoScroll( nFlags ); + bRet = true; + } + } + break; + + case CommandEventId::Wheel: + { + const CommandWheelData* pData = rCmd.GetWheelData(); + + if ( pData && (CommandWheelMode::SCROLL == pData->GetMode()) ) + { + if (!pData->IsDeltaPixel()) + { + double nScrollLines = pData->GetScrollLines(); + double nLines; + if ( nScrollLines == COMMAND_WHEEL_PAGESCROLL ) + { + if ( pData->GetDelta() < 0 ) + nLines = double(-LONG_MAX); + else + nLines = double(LONG_MAX); + } + else + nLines = pData->GetNotchDelta() * nScrollLines; + if ( nLines ) + { + ImplHandleScroll( nullptr, + 0L, + pData->IsHorz() ? pHScrl : pVScrl, + nLines ); + bRet = true; + } + } + else + { + // Mobile / touch scrolling section + const Point & deltaPoint = rCmd.GetMousePosPixel(); + + double deltaXInPixels = double(deltaPoint.X()); + double deltaYInPixels = double(deltaPoint.Y()); + Size winSize = GetOutputSizePixel(); + + if(pHScrl) + { + double visSizeX = double(pHScrl->GetVisibleSize()); + double ratioX = deltaXInPixels / double(winSize.getWidth()); + long deltaXInLogic = long(visSizeX * ratioX); + // Touch need to work by pixels. Did not apply this to + // Android, as android code may require adaptations + // to work with this scrolling code +#ifndef IOS + long lineSizeX = pHScrl->GetLineSize(); + + if(lineSizeX) + { + deltaXInLogic /= lineSizeX; + } + else + { + deltaXInLogic = 0; + } +#endif + if ( deltaXInLogic) + { +#ifndef IOS + bool const isMultiplyByLineSize = true; +#else + bool const isMultiplyByLineSize = false; +#endif + lcl_HandleScrollHelper( pHScrl, deltaXInLogic, isMultiplyByLineSize ); + bRet = true; + } + } + if(pVScrl) + { + double visSizeY = double(pVScrl->GetVisibleSize()); + double ratioY = deltaYInPixels / double(winSize.getHeight()); + long deltaYInLogic = long(visSizeY * ratioY); + + // Touch need to work by pixels. Did not apply this to + // Android, as android code may require adaptations + // to work with this scrolling code +#ifndef IOS + long lineSizeY = pVScrl->GetLineSize(); + if(lineSizeY) + { + deltaYInLogic /= lineSizeY; + } + else + { + deltaYInLogic = 0; + } +#endif + if ( deltaYInLogic ) + { +#ifndef IOS + bool const isMultiplyByLineSize = true; +#else + bool const isMultiplyByLineSize = false; +#endif + lcl_HandleScrollHelper( pVScrl, deltaYInLogic, isMultiplyByLineSize ); + + bRet = true; + } + } + } + } + } + break; + + case CommandEventId::Gesture: + { + if (pVScrl) + { + const CommandGestureData* pData = rCmd.GetGestureData(); + if (pData->meEventType == GestureEventType::PanningBegin) + { + mpWindowImpl->mpFrameData->mnTouchPanPosition = pVScrl->GetThumbPos(); + } + else if(pData->meEventType == GestureEventType::PanningUpdate) + { + long nOriginalPosition = mpWindowImpl->mpFrameData->mnTouchPanPosition; + pVScrl->DoScroll(nOriginalPosition + (pData->mfOffset / pVScrl->GetVisibleSize())); + } + if (pData->meEventType == GestureEventType::PanningEnd) + { + mpWindowImpl->mpFrameData->mnTouchPanPosition = -1; + } + bRet = true; + } + break; + } + + case CommandEventId::AutoScroll: + { + const CommandScrollData* pData = rCmd.GetAutoScrollData(); + if ( pData && (pData->GetDeltaX() || pData->GetDeltaY()) ) + { + ImplHandleScroll( pHScrl, pData->GetDeltaX(), + pVScrl, pData->GetDeltaY() ); + bRet = true; + } + } + break; + + default: + break; + } + } + + return bRet; +} + +// Note that when called for CommandEventId::Wheel above, despite its name, +// pVScrl isn't necessarily the vertical scroll bar. Depending on +// whether the scroll is horizontal or vertical, it is either the +// horizontal or vertical scroll bar. nY is correspondingly either +// the horizontal or vertical scroll amount. + +void Window::ImplHandleScroll( ScrollBar* pHScrl, double nX, + ScrollBar* pVScrl, double nY ) +{ + lcl_HandleScrollHelper( pHScrl, nX, true ); + lcl_HandleScrollHelper( pVScrl, nY, true ); +} + +DockingManager* Window::GetDockingManager() +{ + return ImplGetDockingManager(); +} + +void Window::EnableDocking( bool bEnable ) +{ + // update list of dockable windows + if( bEnable ) + ImplGetDockingManager()->AddWindow( this ); + else + ImplGetDockingManager()->RemoveWindow( this ); +} + +// retrieves the list of owner draw decorated windows for this window hierarchy +::std::vector<VclPtr<vcl::Window> >& Window::ImplGetOwnerDrawList() +{ + return ImplGetTopmostFrameWindow()->mpWindowImpl->mpFrameData->maOwnerDrawList; +} + +void Window::SetHelpId( const OString& rHelpId ) +{ + mpWindowImpl->maHelpId = rHelpId; +} + +const OString& Window::GetHelpId() const +{ + return mpWindowImpl->maHelpId; +} + +// --------- old inline methods --------------- + +vcl::Window* Window::ImplGetWindow() const +{ + if ( mpWindowImpl->mpClientWindow ) + return mpWindowImpl->mpClientWindow; + else + return const_cast<vcl::Window*>(this); +} + +ImplFrameData* Window::ImplGetFrameData() +{ + return mpWindowImpl ? mpWindowImpl->mpFrameData : nullptr; +} + +SalFrame* Window::ImplGetFrame() const +{ + return mpWindowImpl ? mpWindowImpl->mpFrame : nullptr; +} + +weld::Window* Window::GetFrameWeld() const +{ + SalFrame* pFrame = ImplGetFrame(); + return pFrame ? pFrame->GetFrameWeld() : nullptr; +} + +vcl::Window* Window::GetFrameWindow() const +{ + SalFrame* pFrame = ImplGetFrame(); + return pFrame ? pFrame->GetWindow() : nullptr; +} + +vcl::Window* Window::ImplGetParent() const +{ + return mpWindowImpl ? mpWindowImpl->mpParent.get() : nullptr; +} + +vcl::Window* Window::ImplGetClientWindow() const +{ + return mpWindowImpl ? mpWindowImpl->mpClientWindow.get() : nullptr; +} + +vcl::Window* Window::ImplGetBorderWindow() const +{ + return mpWindowImpl ? mpWindowImpl->mpBorderWindow.get() : nullptr; +} + +vcl::Window* Window::ImplGetFirstOverlapWindow() +{ + if (!mpWindowImpl) + { + return nullptr; + } + + if ( mpWindowImpl->mbOverlapWin ) + return this; + else + return mpWindowImpl->mpOverlapWindow; +} + +const vcl::Window* Window::ImplGetFirstOverlapWindow() const +{ + if ( mpWindowImpl->mbOverlapWin ) + return this; + else + return mpWindowImpl->mpOverlapWindow; +} + +vcl::Window* Window::ImplGetFrameWindow() const +{ + return mpWindowImpl ? mpWindowImpl->mpFrameWindow.get() : nullptr; +} + +bool Window::IsDockingWindow() const +{ + return mpWindowImpl && mpWindowImpl->mbDockWin; +} + +bool Window::ImplIsFloatingWindow() const +{ + return mpWindowImpl && mpWindowImpl->mbFloatWin; +} + +bool Window::ImplIsSplitter() const +{ + return mpWindowImpl && mpWindowImpl->mbSplitter; +} + +bool Window::ImplIsPushButton() const +{ + return mpWindowImpl && mpWindowImpl->mbPushButton; +} + +bool Window::ImplIsOverlapWindow() const +{ + return mpWindowImpl && mpWindowImpl->mbOverlapWin; +} + +void Window::ImplSetMouseTransparent( bool bTransparent ) +{ + if (mpWindowImpl) + mpWindowImpl->mbMouseTransparent = bTransparent; +} + +Point Window::ImplOutputToFrame( const Point& rPos ) +{ + return Point( rPos.X()+mnOutOffX, rPos.Y()+mnOutOffY ); +} + +Point Window::ImplFrameToOutput( const Point& rPos ) +{ + return Point( rPos.X()-mnOutOffX, rPos.Y()-mnOutOffY ); +} + +void Window::SetCompoundControl( bool bCompound ) +{ + if (mpWindowImpl) + mpWindowImpl->mbCompoundControl = bCompound; +} + +WinBits Window::GetStyle() const +{ + return mpWindowImpl ? mpWindowImpl->mnStyle : 0; +} + +WinBits Window::GetPrevStyle() const +{ + return mpWindowImpl ? mpWindowImpl->mnPrevStyle : 0; +} + +WindowExtendedStyle Window::GetExtendedStyle() const +{ + return mpWindowImpl ? mpWindowImpl->mnExtendedStyle : WindowExtendedStyle::NONE; +} + +void Window::SetType( WindowType nType ) +{ + if (mpWindowImpl) + mpWindowImpl->mnType = nType; +} + +WindowType Window::GetType() const +{ + if (mpWindowImpl) + return mpWindowImpl->mnType; + else + return WindowType::NONE; +} + +Dialog* Window::GetParentDialog() const +{ + const vcl::Window *pWindow = this; + + while( pWindow ) + { + if( pWindow->IsDialog() ) + break; + + pWindow = pWindow->GetParent(); + } + + return const_cast<Dialog *>(dynamic_cast<const Dialog*>(pWindow)); +} + +bool Window::IsSystemWindow() const +{ + return mpWindowImpl && mpWindowImpl->mbSysWin; +} + +bool Window::IsDialog() const +{ + return mpWindowImpl && mpWindowImpl->mbDialog; +} + +bool Window::IsMenuFloatingWindow() const +{ + return mpWindowImpl && mpWindowImpl->mbMenuFloatingWindow; +} + +bool Window::IsToolbarFloatingWindow() const +{ + return mpWindowImpl && mpWindowImpl->mbToolbarFloatingWindow; +} + +void Window::EnableAllResize() +{ + mpWindowImpl->mbAllResize = true; +} + +void Window::EnableChildTransparentMode( bool bEnable ) +{ + mpWindowImpl->mbChildTransparent = bEnable; +} + +bool Window::IsChildTransparentModeEnabled() const +{ + return mpWindowImpl && mpWindowImpl->mbChildTransparent; +} + +bool Window::IsMouseTransparent() const +{ + return mpWindowImpl && mpWindowImpl->mbMouseTransparent; +} + +bool Window::IsPaintTransparent() const +{ + return mpWindowImpl && mpWindowImpl->mbPaintTransparent; +} + +void Window::SetDialogControlStart( bool bStart ) +{ + mpWindowImpl->mbDlgCtrlStart = bStart; +} + +bool Window::IsDialogControlStart() const +{ + return mpWindowImpl && mpWindowImpl->mbDlgCtrlStart; +} + +void Window::SetDialogControlFlags( DialogControlFlags nFlags ) +{ + mpWindowImpl->mnDlgCtrlFlags = nFlags; +} + +DialogControlFlags Window::GetDialogControlFlags() const +{ + return mpWindowImpl->mnDlgCtrlFlags; +} + +const InputContext& Window::GetInputContext() const +{ + return mpWindowImpl->maInputContext; +} + +bool Window::IsControlFont() const +{ + return bool(mpWindowImpl->mpControlFont); +} + +const Color& Window::GetControlForeground() const +{ + return mpWindowImpl->maControlForeground; +} + +bool Window::IsControlForeground() const +{ + return mpWindowImpl->mbControlForeground; +} + +const Color& Window::GetControlBackground() const +{ + return mpWindowImpl->maControlBackground; +} + +bool Window::IsControlBackground() const +{ + return mpWindowImpl->mbControlBackground; +} + +bool Window::IsInPaint() const +{ + return mpWindowImpl && mpWindowImpl->mbInPaint; +} + +vcl::Window* Window::GetParent() const +{ + return mpWindowImpl ? mpWindowImpl->mpRealParent.get() : nullptr; +} + +bool Window::IsVisible() const +{ + return mpWindowImpl && mpWindowImpl->mbVisible; +} + +bool Window::IsReallyVisible() const +{ + return mpWindowImpl && mpWindowImpl->mbReallyVisible; +} + +bool Window::IsReallyShown() const +{ + return mpWindowImpl && mpWindowImpl->mbReallyShown; +} + +bool Window::IsInInitShow() const +{ + return mpWindowImpl->mbInInitShow; +} + +bool Window::IsEnabled() const +{ + return mpWindowImpl && !mpWindowImpl->mbDisabled; +} + +bool Window::IsInputEnabled() const +{ + return mpWindowImpl && !mpWindowImpl->mbInputDisabled; +} + +bool Window::IsAlwaysEnableInput() const +{ + return mpWindowImpl->meAlwaysInputMode == AlwaysInputEnabled; +} + +ActivateModeFlags Window::GetActivateMode() const +{ + return mpWindowImpl->mnActivateMode; + +} + +bool Window::IsAlwaysOnTopEnabled() const +{ + return mpWindowImpl->mbAlwaysOnTop; +} + +bool Window::IsDefaultPos() const +{ + return mpWindowImpl->mbDefPos; +} + +bool Window::IsDefaultSize() const +{ + return mpWindowImpl->mbDefSize; +} + +Point Window::GetOffsetPixelFrom(const vcl::Window& rWindow) const +{ + return Point(GetOutOffXPixel() - rWindow.GetOutOffXPixel(), GetOutOffYPixel() - rWindow.GetOutOffYPixel()); +} + +void Window::EnablePaint( bool bEnable ) +{ + mpWindowImpl->mbPaintDisabled = !bEnable; +} + +bool Window::IsPaintEnabled() const +{ + return !mpWindowImpl->mbPaintDisabled; +} + +bool Window::IsUpdateMode() const +{ + return !mpWindowImpl->mbNoUpdate; +} + +void Window::SetParentUpdateMode( bool bUpdate ) +{ + mpWindowImpl->mbNoParentUpdate = !bUpdate; +} + +bool Window::IsActive() const +{ + return mpWindowImpl->mbActive; +} + +GetFocusFlags Window::GetGetFocusFlags() const +{ + return mpWindowImpl->mnGetFocusFlags; +} + +bool Window::IsCompoundControl() const +{ + return mpWindowImpl->mbCompoundControl; +} + +bool Window::IsWait() const +{ + return (mpWindowImpl->mnWaitCount != 0); +} + +vcl::Cursor* Window::GetCursor() const +{ + if (!mpWindowImpl) + return nullptr; + return mpWindowImpl->mpCursor; +} + +const Fraction& Window::GetZoom() const +{ + return mpWindowImpl->maZoom; +} + +bool Window::IsZoom() const +{ + return mpWindowImpl->maZoom.GetNumerator() != mpWindowImpl->maZoom.GetDenominator(); +} + +void Window::SetHelpText( const OUString& rHelpText ) +{ + mpWindowImpl->maHelpText = rHelpText; + mpWindowImpl->mbHelpTextDynamic = true; +} + +void Window::SetQuickHelpText( const OUString& rHelpText ) +{ + if (mpWindowImpl) + mpWindowImpl->maQuickHelpText = rHelpText; +} + +const OUString& Window::GetQuickHelpText() const +{ + return mpWindowImpl->maQuickHelpText; +} + +bool Window::IsCreatedWithToolkit() const +{ + return mpWindowImpl->mbCreatedWithToolkit; +} + +void Window::SetCreatedWithToolkit( bool b ) +{ + mpWindowImpl->mbCreatedWithToolkit = b; +} + +PointerStyle Window::GetPointer() const +{ + return mpWindowImpl->maPointer; +} + +VCLXWindow* Window::GetWindowPeer() const +{ + return mpWindowImpl ? mpWindowImpl->mpVCLXWindow : nullptr; +} + +void Window::SetPosPixel( const Point& rNewPos ) +{ + setPosSizePixel( rNewPos.X(), rNewPos.Y(), 0, 0, PosSizeFlags::Pos ); +} + +void Window::SetSizePixel( const Size& rNewSize ) +{ + setPosSizePixel( 0, 0, rNewSize.Width(), rNewSize.Height(), + PosSizeFlags::Size ); +} + +void Window::SetPosSizePixel( const Point& rNewPos, const Size& rNewSize ) +{ + setPosSizePixel( rNewPos.X(), rNewPos.Y(), + rNewSize.Width(), rNewSize.Height()); +} + +void Window::SetOutputSizePixel( const Size& rNewSize ) +{ + SetSizePixel( Size( rNewSize.Width()+mpWindowImpl->mnLeftBorder+mpWindowImpl->mnRightBorder, + rNewSize.Height()+mpWindowImpl->mnTopBorder+mpWindowImpl->mnBottomBorder ) ); +} + +//When a widget wants to renegotiate layout, get toplevel parent dialog and call +//resize on it. Mark all intermediate containers (or container-alike) widgets +//as dirty for the size remains unchanged, but layout changed circumstances +namespace +{ + bool queue_ungrouped_resize(vcl::Window const *pOrigWindow) + { + bool bSomeoneCares = false; + + vcl::Window *pWindow = pOrigWindow->GetParent(); + if (pWindow) + { + if (isContainerWindow(*pWindow)) + { + bSomeoneCares = true; + } + else if (pWindow->GetType() == WindowType::TABCONTROL) + { + bSomeoneCares = true; + } + pWindow->queue_resize(); + } + + return bSomeoneCares; + } +} + +void Window::InvalidateSizeCache() +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->mnOptimalWidthCache = -1; + pWindowImpl->mnOptimalHeightCache = -1; +} + +void Window::queue_resize(StateChangedType eReason) +{ + if (IsDisposed()) + return; + + bool bSomeoneCares = queue_ungrouped_resize(this); + + if (eReason != StateChangedType::Visible) + { + InvalidateSizeCache(); + } + + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + if (pWindowImpl->m_xSizeGroup && pWindowImpl->m_xSizeGroup->get_mode() != VclSizeGroupMode::NONE) + { + std::set<VclPtr<vcl::Window> > &rWindows = pWindowImpl->m_xSizeGroup->get_widgets(); + for (VclPtr<vcl::Window> const & pOther : rWindows) + { + if (pOther == this) + continue; + queue_ungrouped_resize(pOther); + } + } + + if (bSomeoneCares && !mpWindowImpl->mbInDispose) + { + //fdo#57090 force a resync of the borders of the borderwindow onto this + //window in case they have changed + vcl::Window* pBorderWindow = ImplGetBorderWindow(); + if (pBorderWindow) + pBorderWindow->Resize(); + } + if (VclPtr<vcl::Window> pParent = GetParentWithLOKNotifier()) + { + Size aSize = GetSizePixel(); + if (!aSize.IsEmpty() && GetParentDialog() && !pParent->IsInInitShow()) + LogicInvalidate(nullptr); + } +} + +namespace +{ + VclAlign toAlign(const OUString &rValue) + { + VclAlign eRet = VclAlign::Fill; + + if (rValue == "fill") + eRet = VclAlign::Fill; + else if (rValue == "start") + eRet = VclAlign::Start; + else if (rValue == "end") + eRet = VclAlign::End; + else if (rValue == "center") + eRet = VclAlign::Center; + return eRet; + } +} + +bool Window::set_font_attribute(const OString &rKey, const OUString &rValue) +{ + if (rKey == "weight") + { + vcl::Font aFont(GetControlFont()); + if (rValue == "thin") + aFont.SetWeight(WEIGHT_THIN); + else if (rValue == "ultralight") + aFont.SetWeight(WEIGHT_ULTRALIGHT); + else if (rValue == "light") + aFont.SetWeight(WEIGHT_LIGHT); + else if (rValue == "book") + aFont.SetWeight(WEIGHT_SEMILIGHT); + else if (rValue == "normal") + aFont.SetWeight(WEIGHT_NORMAL); + else if (rValue == "medium") + aFont.SetWeight(WEIGHT_MEDIUM); + else if (rValue == "semibold") + aFont.SetWeight(WEIGHT_SEMIBOLD); + else if (rValue == "bold") + aFont.SetWeight(WEIGHT_BOLD); + else if (rValue == "ultrabold") + aFont.SetWeight(WEIGHT_ULTRABOLD); + else + aFont.SetWeight(WEIGHT_BLACK); + SetControlFont(aFont); + } + else if (rKey == "style") + { + vcl::Font aFont(GetControlFont()); + if (rValue == "normal") + aFont.SetItalic(ITALIC_NONE); + else if (rValue == "oblique") + aFont.SetItalic(ITALIC_OBLIQUE); + else if (rValue == "italic") + aFont.SetItalic(ITALIC_NORMAL); + SetControlFont(aFont); + } + else if (rKey == "underline") + { + vcl::Font aFont(GetControlFont()); + aFont.SetUnderline(toBool(rValue) ? LINESTYLE_SINGLE : LINESTYLE_NONE); + SetControlFont(aFont); + } + else if (rKey == "size") + { + vcl::Font aFont(GetControlFont()); + sal_Int32 nHeight = rValue.toInt32() / 1000; + aFont.SetFontHeight(nHeight); + SetControlFont(aFont); + } + else + { + SAL_INFO("vcl.layout", "unhandled font attribute: " << rKey); + return false; + } + return true; +} + +bool Window::set_property(const OString &rKey, const OUString &rValue) +{ + if ((rKey == "label") || (rKey == "title") || (rKey == "text") ) + { + SetText(BuilderUtils::convertMnemonicMarkup(rValue)); + } + else if (rKey == "visible") + Show(toBool(rValue)); + else if (rKey == "sensitive") + Enable(toBool(rValue)); + else if (rKey == "resizable") + { + WinBits nBits = GetStyle(); + nBits &= ~WB_SIZEABLE; + if (toBool(rValue)) + nBits |= WB_SIZEABLE; + SetStyle(nBits); + } + else if (rKey == "xalign") + { + WinBits nBits = GetStyle(); + nBits &= ~(WB_LEFT | WB_CENTER | WB_RIGHT); + + float f = rValue.toFloat(); + if (f == 0.0) + nBits |= WB_LEFT; + else if (f == 1.0) + nBits |= WB_RIGHT; + else if (f == 0.5) + nBits |= WB_CENTER; + + SetStyle(nBits); + } + else if (rKey == "justification") + { + WinBits nBits = GetStyle(); + nBits &= ~(WB_LEFT | WB_CENTER | WB_RIGHT); + + if (rValue == "left") + nBits |= WB_LEFT; + else if (rValue == "right") + nBits |= WB_RIGHT; + else if (rValue == "center") + nBits |= WB_CENTER; + + SetStyle(nBits); + } + else if (rKey == "yalign") + { + WinBits nBits = GetStyle(); + nBits &= ~(WB_TOP | WB_VCENTER | WB_BOTTOM); + + float f = rValue.toFloat(); + if (f == 0.0) + nBits |= WB_TOP; + else if (f == 1.0) + nBits |= WB_BOTTOM; + else if (f == 0.5) + nBits |= WB_CENTER; + + SetStyle(nBits); + } + else if (rKey == "wrap") + { + WinBits nBits = GetStyle(); + nBits &= ~WB_WORDBREAK; + if (toBool(rValue)) + nBits |= WB_WORDBREAK; + SetStyle(nBits); + } + else if (rKey == "height-request") + set_height_request(rValue.toInt32()); + else if (rKey == "width-request") + set_width_request(rValue.toInt32()); + else if (rKey == "hexpand") + set_hexpand(toBool(rValue)); + else if (rKey == "vexpand") + set_vexpand(toBool(rValue)); + else if (rKey == "halign") + set_halign(toAlign(rValue)); + else if (rKey == "valign") + set_valign(toAlign(rValue)); + else if (rKey == "tooltip-markup") + SetQuickHelpText(rValue); + else if (rKey == "tooltip-text") + SetQuickHelpText(rValue); + else if (rKey == "border-width") + set_border_width(rValue.toInt32()); + else if (rKey == "margin-left") + set_margin_left(rValue.toInt32()); + else if (rKey == "margin-right") + set_margin_right(rValue.toInt32()); + else if (rKey == "margin-top") + set_margin_top(rValue.toInt32()); + else if (rKey == "margin-bottom") + set_margin_bottom(rValue.toInt32()); + else if (rKey == "hscrollbar-policy") + { + WinBits nBits = GetStyle(); + nBits &= ~(WB_AUTOHSCROLL|WB_HSCROLL); + if (rValue == "always") + nBits |= WB_HSCROLL; + else if (rValue == "automatic") + nBits |= WB_AUTOHSCROLL; + SetStyle(nBits); + } + else if (rKey == "vscrollbar-policy") + { + WinBits nBits = GetStyle(); + nBits &= ~(WB_AUTOVSCROLL|WB_VSCROLL); + if (rValue == "always") + nBits |= WB_VSCROLL; + else if (rValue == "automatic") + nBits |= WB_AUTOVSCROLL; + SetStyle(nBits); + } + else if (rKey == "accessible-name") + { + SetAccessibleName(rValue); + } + else if (rKey == "accessible-description") + { + SetAccessibleDescription(rValue); + } + else if (rKey == "accessible-role") + { + sal_Int16 role = BuilderUtils::getRoleFromName(rValue.toUtf8()); + if (role != com::sun::star::accessibility::AccessibleRole::UNKNOWN) + SetAccessibleRole(role); + } + else if (rKey == "use-markup") + { + //https://live.gnome.org/GnomeGoals/RemoveMarkupInMessages + SAL_WARN_IF(toBool(rValue), "vcl.layout", "Use pango attributes instead of mark-up"); + } + else if (rKey == "has-focus") + { + if (toBool(rValue)) + GrabFocus(); + } + else if (rKey == "can-focus") + { + WinBits nBits = GetStyle(); + nBits &= ~(WB_TABSTOP|WB_NOTABSTOP); + if (toBool(rValue)) + nBits |= WB_TABSTOP; + else + nBits |= WB_NOTABSTOP; + SetStyle(nBits); + } + else + { + SAL_INFO("vcl.layout", "unhandled property: " << rKey); + return false; + } + return true; +} + +void Window::set_height_request(sal_Int32 nHeightRequest) +{ + if (!mpWindowImpl) + return; + + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + + if ( pWindowImpl->mnHeightRequest != nHeightRequest ) + { + pWindowImpl->mnHeightRequest = nHeightRequest; + queue_resize(); + } +} + +void Window::set_width_request(sal_Int32 nWidthRequest) +{ + if (!mpWindowImpl) + return; + + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + + if ( pWindowImpl->mnWidthRequest != nWidthRequest ) + { + pWindowImpl->mnWidthRequest = nWidthRequest; + queue_resize(); + } +} + +Size Window::get_ungrouped_preferred_size() const +{ + Size aRet(get_width_request(), get_height_request()); + if (aRet.Width() == -1 || aRet.Height() == -1) + { + //cache gets blown away by queue_resize + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + if (pWindowImpl->mnOptimalWidthCache == -1 || pWindowImpl->mnOptimalHeightCache == -1) + { + Size aOptimal(GetOptimalSize()); + pWindowImpl->mnOptimalWidthCache = aOptimal.Width(); + pWindowImpl->mnOptimalHeightCache = aOptimal.Height(); + } + + if (aRet.Width() == -1) + aRet.setWidth( pWindowImpl->mnOptimalWidthCache ); + if (aRet.Height() == -1) + aRet.setHeight( pWindowImpl->mnOptimalHeightCache ); + } + return aRet; +} + +Size Window::get_preferred_size() const +{ + Size aRet(get_ungrouped_preferred_size()); + + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + if (pWindowImpl->m_xSizeGroup) + { + const VclSizeGroupMode eMode = pWindowImpl->m_xSizeGroup->get_mode(); + if (eMode != VclSizeGroupMode::NONE) + { + const bool bIgnoreInHidden = pWindowImpl->m_xSizeGroup->get_ignore_hidden(); + const std::set<VclPtr<vcl::Window> > &rWindows = pWindowImpl->m_xSizeGroup->get_widgets(); + for (auto const& window : rWindows) + { + const vcl::Window *pOther = window; + if (pOther == this) + continue; + if (bIgnoreInHidden && !pOther->IsVisible()) + continue; + Size aOtherSize = pOther->get_ungrouped_preferred_size(); + if (eMode == VclSizeGroupMode::Both || eMode == VclSizeGroupMode::Horizontal) + aRet.setWidth( std::max(aRet.Width(), aOtherSize.Width()) ); + if (eMode == VclSizeGroupMode::Both || eMode == VclSizeGroupMode::Vertical) + aRet.setHeight( std::max(aRet.Height(), aOtherSize.Height()) ); + } + } + } + + return aRet; +} + +VclAlign Window::get_halign() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->meHalign; +} + +void Window::set_halign(VclAlign eAlign) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->meHalign = eAlign; +} + +VclAlign Window::get_valign() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->meValign; +} + +void Window::set_valign(VclAlign eAlign) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->meValign = eAlign; +} + +bool Window::get_hexpand() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mbHexpand; +} + +void Window::set_hexpand(bool bExpand) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->mbHexpand = bExpand; +} + +bool Window::get_vexpand() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mbVexpand; +} + +void Window::set_vexpand(bool bExpand) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->mbVexpand = bExpand; +} + +bool Window::get_expand() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mbExpand; +} + +void Window::set_expand(bool bExpand) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->mbExpand = bExpand; +} + +VclPackType Window::get_pack_type() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mePackType; +} + +void Window::set_pack_type(VclPackType ePackType) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->mePackType = ePackType; +} + +sal_Int32 Window::get_padding() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mnPadding; +} + +void Window::set_padding(sal_Int32 nPadding) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->mnPadding = nPadding; +} + +bool Window::get_fill() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mbFill; +} + +void Window::set_fill(bool bFill) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->mbFill = bFill; +} + +sal_Int32 Window::get_grid_width() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mnGridWidth; +} + +void Window::set_grid_width(sal_Int32 nCols) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->mnGridWidth = nCols; +} + +sal_Int32 Window::get_grid_left_attach() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mnGridLeftAttach; +} + +void Window::set_grid_left_attach(sal_Int32 nAttach) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->mnGridLeftAttach = nAttach; +} + +sal_Int32 Window::get_grid_height() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mnGridHeight; +} + +void Window::set_grid_height(sal_Int32 nRows) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->mnGridHeight = nRows; +} + +sal_Int32 Window::get_grid_top_attach() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mnGridTopAttach; +} + +void Window::set_grid_top_attach(sal_Int32 nAttach) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->mnGridTopAttach = nAttach; +} + +void Window::set_border_width(sal_Int32 nBorderWidth) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->mnBorderWidth = nBorderWidth; +} + +sal_Int32 Window::get_border_width() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mnBorderWidth; +} + +void Window::set_margin_left(sal_Int32 nWidth) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + if (pWindowImpl->mnMarginLeft != nWidth) + { + pWindowImpl->mnMarginLeft = nWidth; + queue_resize(); + } +} + +sal_Int32 Window::get_margin_left() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mnMarginLeft; +} + +void Window::set_margin_right(sal_Int32 nWidth) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + if (pWindowImpl->mnMarginRight != nWidth) + { + pWindowImpl->mnMarginRight = nWidth; + queue_resize(); + } +} + +sal_Int32 Window::get_margin_right() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mnMarginRight; +} + +void Window::set_margin_top(sal_Int32 nWidth) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + if (pWindowImpl->mnMarginTop != nWidth) + { + pWindowImpl->mnMarginTop = nWidth; + queue_resize(); + } +} + +sal_Int32 Window::get_margin_top() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mnMarginTop; +} + +void Window::set_margin_bottom(sal_Int32 nWidth) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + if (pWindowImpl->mnMarginBottom != nWidth) + { + pWindowImpl->mnMarginBottom = nWidth; + queue_resize(); + } +} + +sal_Int32 Window::get_margin_bottom() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mnMarginBottom; +} + +sal_Int32 Window::get_height_request() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mnHeightRequest; +} + +sal_Int32 Window::get_width_request() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mnWidthRequest; +} + +bool Window::get_secondary() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mbSecondary; +} + +void Window::set_secondary(bool bSecondary) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->mbSecondary = bSecondary; +} + +bool Window::get_non_homogeneous() const +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + return pWindowImpl->mbNonHomogeneous; +} + +void Window::set_non_homogeneous(bool bNonHomogeneous) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + pWindowImpl->mbNonHomogeneous = bNonHomogeneous; +} + +void Window::add_to_size_group(const std::shared_ptr<VclSizeGroup>& xGroup) +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + //To-Do, multiple groups + pWindowImpl->m_xSizeGroup = xGroup; + pWindowImpl->m_xSizeGroup->insert(this); + if (VclSizeGroupMode::NONE != pWindowImpl->m_xSizeGroup->get_mode()) + queue_resize(); +} + +void Window::remove_from_all_size_groups() +{ + WindowImpl *pWindowImpl = mpWindowImpl->mpBorderWindow ? mpWindowImpl->mpBorderWindow->mpWindowImpl.get() : mpWindowImpl.get(); + //To-Do, multiple groups + if (pWindowImpl->m_xSizeGroup) + { + if (VclSizeGroupMode::NONE != pWindowImpl->m_xSizeGroup->get_mode()) + queue_resize(); + pWindowImpl->m_xSizeGroup->erase(this); + pWindowImpl->m_xSizeGroup.reset(); + } +} + +void Window::add_mnemonic_label(FixedText *pLabel) +{ + std::vector<VclPtr<FixedText> >& v = mpWindowImpl->m_aMnemonicLabels; + if (std::find(v.begin(), v.end(), VclPtr<FixedText>(pLabel)) != v.end()) + return; + v.emplace_back(pLabel); + pLabel->set_mnemonic_widget(this); +} + +void Window::remove_mnemonic_label(FixedText *pLabel) +{ + std::vector<VclPtr<FixedText> >& v = mpWindowImpl->m_aMnemonicLabels; + auto aFind = std::find(v.begin(), v.end(), VclPtr<FixedText>(pLabel)); + if (aFind == v.end()) + return; + v.erase(aFind); + pLabel->set_mnemonic_widget(nullptr); +} + +const std::vector<VclPtr<FixedText> >& Window::list_mnemonic_labels() const +{ + return mpWindowImpl->m_aMnemonicLabels; +} + +} /* namespace vcl */ + +void DrawFocusRect(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) +{ + const int nBorder = 1; + rRenderContext.Invert(tools::Rectangle(Point(rRect.Left(), rRect.Top()), Size(rRect.GetWidth(), nBorder)), InvertFlags::N50); + rRenderContext.Invert(tools::Rectangle(Point(rRect.Left(), rRect.Bottom()-nBorder+1), Size(rRect.GetWidth(), nBorder)), InvertFlags::N50); + rRenderContext.Invert(tools::Rectangle(Point(rRect.Left(), rRect.Top()+nBorder), Size(nBorder, rRect.GetHeight()-(nBorder*2))), InvertFlags::N50); + rRenderContext.Invert(tools::Rectangle(Point(rRect.Right()-nBorder+1, rRect.Top()+nBorder), Size(nBorder, rRect.GetHeight()-(nBorder*2))), InvertFlags::N50); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |