office-gobmx/toolkit/source/awt/vclxwindow.cxx
Noel Grandin 60e8446323 tsan: fix data race in VCLXWindowImpl
Change-Id: I68894dabdaa22ac3733d08ae85df5c82e3b9654c
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/169333
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
2024-06-21 16:45:21 +02:00

2611 lines
88 KiB
C++

/* -*- 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 <stdarg.h>
#include <memory>
#include <com/sun/star/awt/WindowEvent.hpp>
#include <com/sun/star/awt/KeyEvent.hpp>
#include <com/sun/star/awt/MouseEvent.hpp>
#include <com/sun/star/awt/MouseWheelBehavior.hpp>
#include <com/sun/star/awt/Style.hpp>
#include <com/sun/star/awt/DockingEvent.hpp>
#include <com/sun/star/awt/EndDockingEvent.hpp>
#include <com/sun/star/awt/EndPopupModeEvent.hpp>
#include <com/sun/star/awt/XWindowListener2.hpp>
#include <com/sun/star/style/VerticalAlignment.hpp>
#include <com/sun/star/lang/DisposedException.hpp>
#include <com/sun/star/text/WritingMode2.hpp>
#include <toolkit/awt/vclxwindow.hxx>
#include <awt/vclxpointer.hxx>
#include <toolkit/awt/vclxwindows.hxx>
#include <toolkit/helper/vclunohelper.hxx>
#include <toolkit/helper/convert.hxx>
#include <helper/property.hxx>
#include <rtl/math.hxx>
#include <sal/log.hxx>
#include <utility>
#include <vcl/toolkit/floatwin.hxx>
#include <vcl/svapp.hxx>
#include <vcl/window.hxx>
#include <tools/color.hxx>
#include <tools/fract.hxx>
#include <tools/debug.hxx>
#include <vcl/event.hxx>
#include <vcl/dockwin.hxx>
#include <vcl/pdfextoutdevdata.hxx>
#include <vcl/tabpage.hxx>
#include <vcl/ctrl.hxx>
#include <vcl/settings.hxx>
#include <vcl/commandevent.hxx>
#include <comphelper/flagguard.hxx>
#include <comphelper/interfacecontainer3.hxx>
#include <comphelper/profilezone.hxx>
#include "stylesettings.hxx"
#include <tools/urlobj.hxx>
#include <helper/accessibilityclient.hxx>
#include <helper/unopropertyarrayhelper.hxx>
#include <atomic>
using namespace ::com::sun::star;
using ::com::sun::star::uno::Reference;
using ::com::sun::star::uno::UNO_QUERY;
using ::com::sun::star::lang::EventObject;
using ::com::sun::star::awt::XWindowListener2;
using ::com::sun::star::awt::XDockableWindowListener;
using ::com::sun::star::awt::XDevice;
using ::com::sun::star::awt::XStyleSettings;
using ::com::sun::star::lang::DisposedException;
using ::com::sun::star::style::VerticalAlignment;
using ::com::sun::star::style::VerticalAlignment_TOP;
using ::com::sun::star::style::VerticalAlignment_MIDDLE;
using ::com::sun::star::style::VerticalAlignment_BOTTOM;
namespace WritingMode2 = ::com::sun::star::text::WritingMode2;
//= VCLXWindowImpl
class VCLXWindowImpl
{
private:
typedef ::std::vector< VCLXWindow::Callback > CallbackArray;
private:
VCLXWindow& mrAntiImpl;
::toolkit::AccessibilityClient maAccFactory;
bool mbDisposed;
bool mbDrawingOntoParent; // no bit mask, is passed around by reference
bool mbEnableVisible;
bool mbDirectVisible;
::osl::Mutex maListenerContainerMutex;
::comphelper::OInterfaceContainerHelper3<css::awt::XWindowListener2> maWindow2Listeners;
::comphelper::OInterfaceContainerHelper3<XDockableWindowListener> maDockableWindowListeners;
EventListenerMultiplexer maEventListeners;
FocusListenerMultiplexer maFocusListeners;
WindowListenerMultiplexer maWindowListeners;
KeyListenerMultiplexer maKeyListeners;
MouseListenerMultiplexer maMouseListeners;
MouseMotionListenerMultiplexer maMouseMotionListeners;
PaintListenerMultiplexer maPaintListeners;
VclContainerListenerMultiplexer maContainerListeners;
TopWindowListenerMultiplexer maTopWindowListeners;
CallbackArray maCallbackEvents;
ImplSVEvent * mnCallbackEventId;
public:
bool mbDisposing : 1;
bool mbDesignMode : 1;
bool mbSynthesizingVCLEvent : 1;
bool mbWithDefaultProps : 1;
std::atomic<int> mnListenerLockLevel;
sal_Int16 mnWritingMode;
sal_Int16 mnContextWritingMode;
std::unique_ptr<UnoPropertyArrayHelper>
mpPropHelper;
css::uno::Reference< css::accessibility::XAccessibleContext >
mxAccessibleContext;
css::uno::Reference< css::awt::XGraphics >
mxViewGraphics;
rtl::Reference< toolkit::WindowStyleSettings >
mxWindowStyleSettings;
public:
bool& getDrawingOntoParent_ref() { return mbDrawingOntoParent; }
public:
/** ctor
@param _pAntiImpl
the <type>VCLXWindow</type> instance which the object belongs to. Must
live longer then the object just being constructed.
*/
VCLXWindowImpl( VCLXWindow& _rAntiImpl, bool _bWithDefaultProps );
VCLXWindowImpl( const VCLXWindowImpl& ) = delete;
const VCLXWindowImpl& operator=(const VCLXWindowImpl&) = delete;
/** synchronously mbEnableVisible
*/
void setEnableVisible( bool bEnableVisible ) { mbEnableVisible = bEnableVisible; }
bool isEnableVisible() const { return mbEnableVisible; }
/** synchronously mbDirectVisible;
*/
void setDirectVisible( bool bDirectVisible ) { mbDirectVisible = bDirectVisible; }
bool isDirectVisible() const { return mbDirectVisible; }
/** impl-version of VCLXWindow::ImplExecuteAsyncWithoutSolarLock
*/
void callBackAsync( const VCLXWindow::Callback& i_callback );
/** notifies the object that its VCLXWindow is being disposed
*/
void disposing();
::toolkit::AccessibilityClient& getAccessibleFactory()
{
return maAccFactory;
}
Reference< XStyleSettings > getStyleSettings();
/** returns the container of registered XWindowListener2 listeners
*/
::comphelper::OInterfaceContainerHelper3<css::awt::XWindowListener2>& getWindow2Listeners() { return maWindow2Listeners; }
::comphelper::OInterfaceContainerHelper3<XDockableWindowListener>& getDockableWindowListeners() { return maDockableWindowListeners; }
EventListenerMultiplexer& getEventListeners() { return maEventListeners; }
FocusListenerMultiplexer& getFocusListeners() { return maFocusListeners; }
WindowListenerMultiplexer& getWindowListeners() { return maWindowListeners; }
KeyListenerMultiplexer& getKeyListeners() { return maKeyListeners; }
MouseListenerMultiplexer& getMouseListeners() { return maMouseListeners; }
MouseMotionListenerMultiplexer& getMouseMotionListeners() { return maMouseMotionListeners; }
PaintListenerMultiplexer& getPaintListeners() { return maPaintListeners; }
VclContainerListenerMultiplexer& getContainerListeners() { return maContainerListeners; }
TopWindowListenerMultiplexer& getTopWindowListeners() { return maTopWindowListeners; }
private:
DECL_LINK( OnProcessCallbacks, void*, void );
};
VCLXWindowImpl::VCLXWindowImpl( VCLXWindow& _rAntiImpl, bool _bWithDefaultProps )
:mrAntiImpl( _rAntiImpl )
,mbDisposed( false )
,mbDrawingOntoParent( false )
,mbEnableVisible(true)
,mbDirectVisible(true)
,maWindow2Listeners( maListenerContainerMutex )
,maDockableWindowListeners( maListenerContainerMutex )
,maEventListeners( _rAntiImpl )
,maFocusListeners( _rAntiImpl )
,maWindowListeners( _rAntiImpl )
,maKeyListeners( _rAntiImpl )
,maMouseListeners( _rAntiImpl )
,maMouseMotionListeners( _rAntiImpl )
,maPaintListeners( _rAntiImpl )
,maContainerListeners( _rAntiImpl )
,maTopWindowListeners( _rAntiImpl )
,mnCallbackEventId( nullptr )
,mbDisposing( false )
,mbDesignMode( false )
,mbSynthesizingVCLEvent( false )
,mbWithDefaultProps( _bWithDefaultProps )
,mnListenerLockLevel( 0 )
,mnWritingMode( WritingMode2::CONTEXT )
,mnContextWritingMode( WritingMode2::CONTEXT )
{
}
void VCLXWindowImpl::disposing()
{
SolarMutexGuard aGuard;
assert(!mbDisposed);
mbDisposed = true;
if ( mnCallbackEventId )
{
Application::RemoveUserEvent( mnCallbackEventId );
mnCallbackEventId = nullptr;
// we acquired our VCLXWindow once before posting the event, release this one ref now
mrAntiImpl.release();
}
maCallbackEvents.clear();
css::lang::EventObject aEvent;
aEvent.Source = mrAntiImpl;
maDockableWindowListeners.disposeAndClear( aEvent );
maEventListeners.disposeAndClear( aEvent );
maFocusListeners.disposeAndClear( aEvent );
maWindowListeners.disposeAndClear( aEvent );
maKeyListeners.disposeAndClear( aEvent );
maMouseListeners.disposeAndClear( aEvent );
maMouseMotionListeners.disposeAndClear( aEvent );
maPaintListeners.disposeAndClear( aEvent );
maContainerListeners.disposeAndClear( aEvent );
maTopWindowListeners.disposeAndClear( aEvent );
maWindow2Listeners.disposeAndClear( aEvent );
if ( mxWindowStyleSettings )
mxWindowStyleSettings->dispose();
mxWindowStyleSettings.clear();
}
void VCLXWindowImpl::callBackAsync( const VCLXWindow::Callback& i_callback )
{
DBG_TESTSOLARMUTEX();
maCallbackEvents.push_back( i_callback );
if ( !mnCallbackEventId )
{
// ensure our VCLXWindow is not destroyed while the event is underway
mrAntiImpl.acquire();
mnCallbackEventId = Application::PostUserEvent( LINK( this, VCLXWindowImpl, OnProcessCallbacks ) );
}
}
IMPL_LINK_NOARG(VCLXWindowImpl, OnProcessCallbacks, void*, void)
{
const Reference< uno::XInterface > xKeepAlive( mrAntiImpl );
SAL_INFO("toolkit.controls", "OnProcessCallbacks grabbing solarmutex");
// work on a copy of the callback array
CallbackArray aCallbacksCopy;
{
SolarMutexGuard aGuard;
aCallbacksCopy.swap(maCallbackEvents);
// we acquired our VCLXWindow once before posting the event, release this one ref now
mrAntiImpl.release();
assert( mnCallbackEventId && "should not be possible to call us if the event was removed");
mnCallbackEventId = nullptr;
}
{
SAL_INFO("toolkit.controls", "OnProcessCallbacks relinquished solarmutex");
SolarMutexReleaser aReleaseSolar;
for (const auto& rCallback : aCallbacksCopy)
{
rCallback();
}
}
}
Reference< XStyleSettings > VCLXWindowImpl::getStyleSettings()
{
SolarMutexGuard aGuard;
if ( mbDisposed )
throw DisposedException( OUString(), mrAntiImpl );
if ( !mxWindowStyleSettings.is() )
mxWindowStyleSettings = new ::toolkit::WindowStyleSettings( maListenerContainerMutex, mrAntiImpl );
return mxWindowStyleSettings;
}
// Uses an out-parameter instead of return value, due to the object reference
static void ImplInitWindowEvent( css::awt::WindowEvent& rEvent, vcl::Window const * pWindow )
{
Point aPos = pWindow->GetPosPixel();
Size aSz = pWindow->GetSizePixel();
rEvent.X = aPos.X();
rEvent.Y = aPos.Y();
rEvent.Width = aSz.Width();
rEvent.Height = aSz.Height();
pWindow->GetBorder( rEvent.LeftInset, rEvent.TopInset, rEvent.RightInset, rEvent.BottomInset );
}
VCLXWindow::VCLXWindow( bool _bWithDefaultProps )
{
mpImpl.reset( new VCLXWindowImpl( *this, _bWithDefaultProps ) );
}
VCLXWindow::~VCLXWindow()
{
assert(mpImpl->mbDisposing && "forgot to call dispose()");
}
void VCLXWindow::ImplExecuteAsyncWithoutSolarLock( const Callback& i_callback )
{
if (mpImpl->mbDisposing)
return;
mpImpl->callBackAsync( i_callback );
}
::toolkit::IAccessibleFactory& VCLXWindow::getAccessibleFactory()
{
return mpImpl->getAccessibleFactory().getFactory();
}
void VCLXWindow::SetWindow( const VclPtr<vcl::Window> &pWindow )
{
assert(!mpImpl->mbDisposing || !pWindow);
if ( GetWindow() )
{
GetWindow()->RemoveEventListener( LINK( this, VCLXWindow, WindowEventListener ) );
// GetWindow()->DbgAssertNoEventListeners();
}
SetOutputDevice( pWindow ? pWindow->GetOutDev() : nullptr );
if ( GetWindow() )
{
GetWindow()->AddEventListener( LINK( this, VCLXWindow, WindowEventListener ) );
bool bDirectVisible = pWindow && pWindow->IsVisible();
mpImpl->setDirectVisible( bDirectVisible );
}
}
void VCLXWindow::suspendVclEventListening( )
{
++mpImpl->mnListenerLockLevel;
}
void VCLXWindow::resumeVclEventListening( )
{
DBG_ASSERT( mpImpl->mnListenerLockLevel, "VCLXWindow::resumeVclEventListening: not suspended!" );
--mpImpl->mnListenerLockLevel;
}
void VCLXWindow::notifyWindowRemoved( vcl::Window const & _rWindow )
{
if ( mpImpl->getContainerListeners().getLength() )
{
awt::VclContainerEvent aEvent;
aEvent.Source = *this;
aEvent.Child = static_cast< XWindow* >( _rWindow.GetWindowPeer() );
mpImpl->getContainerListeners().windowRemoved( aEvent );
}
}
IMPL_LINK( VCLXWindow, WindowEventListener, VclWindowEvent&, rEvent, void )
{
if ( mpImpl->mbDisposing || mpImpl->mnListenerLockLevel )
return;
DBG_ASSERT( rEvent.GetWindow() && GetWindow(), "Window???" );
ProcessWindowEvent( rEvent );
}
namespace
{
struct CallWindow2Listener
{
CallWindow2Listener( ::comphelper::OInterfaceContainerHelper3<css::awt::XWindowListener2>& i_rWindow2Listeners, const bool i_bEnabled, EventObject i_Event )
:m_rWindow2Listeners( i_rWindow2Listeners )
,m_bEnabled( i_bEnabled )
,m_aEvent(std::move( i_Event ))
{
}
void operator()()
{
m_rWindow2Listeners.notifyEach( m_bEnabled ? &XWindowListener2::windowEnabled : &XWindowListener2::windowDisabled, m_aEvent );
}
::comphelper::OInterfaceContainerHelper3<css::awt::XWindowListener2>& m_rWindow2Listeners;
const bool m_bEnabled;
const EventObject m_aEvent;
};
}
void VCLXWindow::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
{
if (mpImpl->mbDisposing)
return;
css::uno::Reference< css::uno::XInterface > xThis( getXWeak() );
switch ( rVclWindowEvent.GetId() )
{
case VclEventId::WindowEnabled:
case VclEventId::WindowDisabled:
{
Callback aCallback = CallWindow2Listener(
mpImpl->getWindow2Listeners(),
( VclEventId::WindowEnabled == rVclWindowEvent.GetId() ),
EventObject( *this )
);
ImplExecuteAsyncWithoutSolarLock( aCallback );
}
break;
case VclEventId::WindowPaint:
{
if ( mpImpl->getPaintListeners().getLength() )
{
css::awt::PaintEvent aEvent;
aEvent.Source = getXWeak();
aEvent.UpdateRect = AWTRectangle( *static_cast<tools::Rectangle*>(rVclWindowEvent.GetData()) );
aEvent.Count = 0;
mpImpl->getPaintListeners().windowPaint( aEvent );
}
}
break;
case VclEventId::WindowMove:
{
if ( mpImpl->getWindowListeners().getLength() )
{
css::awt::WindowEvent aEvent;
aEvent.Source = getXWeak();
ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() );
mpImpl->getWindowListeners().windowMoved( aEvent );
}
}
break;
case VclEventId::WindowResize:
{
if ( mpImpl->getWindowListeners().getLength() )
{
css::awt::WindowEvent aEvent;
aEvent.Source = getXWeak();
ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() );
mpImpl->getWindowListeners().windowResized( aEvent );
}
}
break;
case VclEventId::WindowShow:
{
if ( mpImpl->getWindowListeners().getLength() )
{
css::awt::WindowEvent aEvent;
aEvent.Source = getXWeak();
ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() );
mpImpl->getWindowListeners().windowShown( aEvent );
}
// For TopWindows this means opened...
if ( mpImpl->getTopWindowListeners().getLength() )
{
css::lang::EventObject aEvent;
aEvent.Source = getXWeak();
mpImpl->getTopWindowListeners().windowOpened( aEvent );
}
}
break;
case VclEventId::WindowHide:
{
if ( mpImpl->getWindowListeners().getLength() )
{
css::awt::WindowEvent aEvent;
aEvent.Source = getXWeak();
ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() );
mpImpl->getWindowListeners().windowHidden( aEvent );
}
// For TopWindows this means closed...
if ( mpImpl->getTopWindowListeners().getLength() )
{
css::lang::EventObject aEvent;
aEvent.Source = getXWeak();
mpImpl->getTopWindowListeners().windowClosed( aEvent );
}
}
break;
case VclEventId::WindowActivate:
case VclEventId::WindowDeactivate:
{
if (!mpImpl->getTopWindowListeners().getLength())
return;
// Suppress events which are unlikely to be interesting to our listeners.
vcl::Window* pWin = static_cast<vcl::Window*>(rVclWindowEvent.GetData());
bool bSuppress = false;
while (pWin)
{
// Either the event came from the same window, from its
// child, or from a child of its border window (e.g.
// menubar or notebookbar).
if (pWin->GetWindow(GetWindowType::Client) == GetWindow())
return;
if (pWin->IsMenuFloatingWindow())
bSuppress = true;
if (pWin->GetType() == WindowType::FLOATINGWINDOW &&
static_cast<FloatingWindow*>(pWin)->IsInPopupMode())
bSuppress = true;
// Otherwise, don't suppress if the event came from a different frame.
if (!bSuppress && pWin->GetWindow(GetWindowType::Frame) == pWin)
break;
pWin = pWin->GetWindow(GetWindowType::RealParent);
}
css::lang::EventObject aEvent;
aEvent.Source = getXWeak();
if (rVclWindowEvent.GetId() == VclEventId::WindowActivate)
mpImpl->getTopWindowListeners().windowActivated( aEvent );
else
mpImpl->getTopWindowListeners().windowDeactivated( aEvent );
}
break;
case VclEventId::WindowClose:
{
if ( mpImpl->getDockableWindowListeners().getLength() )
{
css::lang::EventObject aEvent;
aEvent.Source = getXWeak();
mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::closed, aEvent );
}
if ( mpImpl->getTopWindowListeners().getLength() )
{
css::lang::EventObject aEvent;
aEvent.Source = getXWeak();
mpImpl->getTopWindowListeners().windowClosing( aEvent );
}
}
break;
case VclEventId::ControlGetFocus:
case VclEventId::WindowGetFocus:
{
if ( ( rVclWindowEvent.GetWindow()->IsCompoundControl()
&& rVclWindowEvent.GetId() == VclEventId::ControlGetFocus
)
|| ( !rVclWindowEvent.GetWindow()->IsCompoundControl()
&& rVclWindowEvent.GetId() == VclEventId::WindowGetFocus
)
)
{
if ( mpImpl->getFocusListeners().getLength() )
{
css::awt::FocusEvent aEvent;
aEvent.Source = getXWeak();
aEvent.FocusFlags = static_cast<sal_Int16>(rVclWindowEvent.GetWindow()->GetGetFocusFlags());
aEvent.Temporary = false;
mpImpl->getFocusListeners().focusGained( aEvent );
}
}
}
break;
case VclEventId::ControlLoseFocus:
case VclEventId::WindowLoseFocus:
{
if ( ( rVclWindowEvent.GetWindow()->IsCompoundControl()
&& rVclWindowEvent.GetId() == VclEventId::ControlLoseFocus
)
|| ( !rVclWindowEvent.GetWindow()->IsCompoundControl()
&& rVclWindowEvent.GetId() == VclEventId::WindowLoseFocus
)
)
{
if ( mpImpl->getFocusListeners().getLength() )
{
css::awt::FocusEvent aEvent;
aEvent.Source = getXWeak();
aEvent.FocusFlags = static_cast<sal_Int16>(rVclWindowEvent.GetWindow()->GetGetFocusFlags());
aEvent.Temporary = false;
vcl::Window* pNext = Application::GetFocusWindow();
if ( pNext )
{
// Don't care about internals if this control is compound
vcl::Window* pNextC = pNext;
while ( pNextC && !pNextC->IsCompoundControl() )
pNextC = pNextC->GetParent();
if ( pNextC )
pNext = pNextC;
pNext->GetComponentInterface();
aEvent.NextFocus = cppu::getXWeak(pNext->GetWindowPeer());
}
mpImpl->getFocusListeners().focusLost( aEvent );
}
}
}
break;
case VclEventId::WindowMinimize:
{
if ( mpImpl->getTopWindowListeners().getLength() )
{
css::lang::EventObject aEvent;
aEvent.Source = getXWeak();
mpImpl->getTopWindowListeners().windowMinimized( aEvent );
}
}
break;
case VclEventId::WindowNormalize:
{
if ( mpImpl->getTopWindowListeners().getLength() )
{
css::lang::EventObject aEvent;
aEvent.Source = getXWeak();
mpImpl->getTopWindowListeners().windowNormalized( aEvent );
}
}
break;
case VclEventId::WindowKeyInput:
{
if ( mpImpl->getKeyListeners().getLength() )
{
css::awt::KeyEvent aEvent( VCLUnoHelper::createKeyEvent(
*static_cast<KeyEvent*>(rVclWindowEvent.GetData()), *this
) );
mpImpl->getKeyListeners().keyPressed( aEvent );
}
}
break;
case VclEventId::WindowKeyUp:
{
if ( mpImpl->getKeyListeners().getLength() )
{
css::awt::KeyEvent aEvent( VCLUnoHelper::createKeyEvent(
*static_cast<KeyEvent*>(rVclWindowEvent.GetData()), *this
) );
mpImpl->getKeyListeners().keyReleased( aEvent );
}
}
break;
case VclEventId::WindowCommand:
{
CommandEvent* pCmdEvt = static_cast<CommandEvent*>(rVclWindowEvent.GetData());
if ( mpImpl->getMouseListeners().getLength() && ( pCmdEvt->GetCommand() == CommandEventId::ContextMenu ) )
{
// CommandEventId::ContextMenu: send as mousePressed with PopupTrigger = true ...
Point aWhere = static_cast< CommandEvent* >( rVclWindowEvent.GetData() )->GetMousePosPixel();
if ( !pCmdEvt->IsMouseEvent() )
{ // for keyboard events, we set the coordinates to -1,-1. This is a slight HACK, but the current API
// handles a context menu command as special case of a mouse event, which is simply wrong.
// Without extending the API, we would not have another chance to notify listeners of a
// keyboard-triggered context menu request
aWhere = Point( -1, -1 );
}
MouseEvent aMEvt( aWhere, 1, MouseEventModifiers::SIMPLECLICK, MOUSE_LEFT, 0 );
awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( aMEvt, *this ) );
aEvent.PopupTrigger = true;
Callback aCallback = [ this, aEvent=std::move(aEvent) ]()
{ this->mpImpl->getMouseListeners().mousePressed( aEvent ); };
ImplExecuteAsyncWithoutSolarLock( aCallback );
}
}
break;
case VclEventId::WindowMouseMove:
{
MouseEvent* pMouseEvt = static_cast<MouseEvent*>(rVclWindowEvent.GetData());
if ( mpImpl->getMouseListeners().getLength() && ( pMouseEvt->IsEnterWindow() || pMouseEvt->IsLeaveWindow() ) )
{
awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( *pMouseEvt, *this ) );
bool const isEnter(pMouseEvt->IsEnterWindow());
Callback aCallback = [ this, isEnter, aEvent=std::move(aEvent) ]()
{ MouseListenerMultiplexer& rMouseListeners = this->mpImpl->getMouseListeners();
isEnter
? rMouseListeners.mouseEntered(aEvent)
: rMouseListeners.mouseExited(aEvent); };
ImplExecuteAsyncWithoutSolarLock( aCallback );
}
if ( mpImpl->getMouseMotionListeners().getLength() && !pMouseEvt->IsEnterWindow() && !pMouseEvt->IsLeaveWindow() )
{
awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( *pMouseEvt, *this ) );
aEvent.ClickCount = 0;
if ( pMouseEvt->GetMode() & MouseEventModifiers::SIMPLEMOVE )
mpImpl->getMouseMotionListeners().mouseMoved( aEvent );
else
mpImpl->getMouseMotionListeners().mouseDragged( aEvent );
}
}
break;
case VclEventId::WindowMouseButtonDown:
{
if ( mpImpl->getMouseListeners().getLength() )
{
awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( *static_cast<MouseEvent*>(rVclWindowEvent.GetData()), *this ) );
Callback aCallback = [ this, aEvent=std::move(aEvent) ]()
{ this->mpImpl->getMouseListeners().mousePressed( aEvent ); };
ImplExecuteAsyncWithoutSolarLock( aCallback );
}
}
break;
case VclEventId::WindowMouseButtonUp:
{
if ( mpImpl->getMouseListeners().getLength() )
{
awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( *static_cast<MouseEvent*>(rVclWindowEvent.GetData()), *this ) );
Callback aCallback = [ this, aEvent=std::move(aEvent) ]()
{ this->mpImpl->getMouseListeners().mouseReleased( aEvent ); };
ImplExecuteAsyncWithoutSolarLock( aCallback );
}
}
break;
case VclEventId::WindowStartDocking:
{
if ( mpImpl->getDockableWindowListeners().getLength() )
{
DockingData *pData = static_cast<DockingData*>(rVclWindowEvent.GetData());
if( pData )
{
css::awt::DockingEvent aEvent;
aEvent.Source = getXWeak();
aEvent.TrackingRectangle = AWTRectangle( pData->maTrackRect );
aEvent.MousePos.X = pData->maMousePos.X();
aEvent.MousePos.Y = pData->maMousePos.Y();
aEvent.bLiveMode = false;
aEvent.bInteractive = true;
mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::startDocking, aEvent );
}
}
}
break;
case VclEventId::WindowDocking:
{
if ( mpImpl->getDockableWindowListeners().getLength() )
{
DockingData *pData = static_cast<DockingData*>(rVclWindowEvent.GetData());
if( pData )
{
css::awt::DockingEvent aEvent;
aEvent.Source = getXWeak();
aEvent.TrackingRectangle = AWTRectangle( pData->maTrackRect );
aEvent.MousePos.X = pData->maMousePos.X();
aEvent.MousePos.Y = pData->maMousePos.Y();
aEvent.bLiveMode = false;
aEvent.bInteractive = true;
Reference< XDockableWindowListener > xFirstListener;
::comphelper::OInterfaceIteratorHelper3 aIter( mpImpl->getDockableWindowListeners() );
while ( aIter.hasMoreElements() && !xFirstListener.is() )
{
xFirstListener = aIter.next();
}
css::awt::DockingData aDockingData =
xFirstListener->docking( aEvent );
pData->maTrackRect = VCLRectangle( aDockingData.TrackingRectangle );
pData->mbFloating = aDockingData.bFloating;
}
}
}
break;
case VclEventId::WindowEndDocking:
{
if ( mpImpl->getDockableWindowListeners().getLength() )
{
EndDockingData *pData = static_cast<EndDockingData*>(rVclWindowEvent.GetData());
if( pData )
{
css::awt::EndDockingEvent aEvent;
aEvent.Source = getXWeak();
aEvent.WindowRectangle = AWTRectangle( pData->maWindowRect );
aEvent.bFloating = pData->mbFloating;
aEvent.bCancelled = pData->mbCancelled;
mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::endDocking, aEvent );
}
}
}
break;
case VclEventId::WindowPrepareToggleFloating:
{
if ( mpImpl->getDockableWindowListeners().getLength() )
{
sal_Bool *p_bFloating = static_cast<sal_Bool*>(rVclWindowEvent.GetData());
css::lang::EventObject aEvent;
aEvent.Source = getXWeak();
Reference< XDockableWindowListener > xFirstListener;
::comphelper::OInterfaceIteratorHelper3 aIter( mpImpl->getDockableWindowListeners() );
while ( aIter.hasMoreElements() && !xFirstListener.is() )
{
xFirstListener = aIter.next();
}
*p_bFloating = xFirstListener->prepareToggleFloatingMode( aEvent );
}
}
break;
case VclEventId::WindowToggleFloating:
{
if ( mpImpl->getDockableWindowListeners().getLength() )
{
css::lang::EventObject aEvent;
aEvent.Source = getXWeak();
mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::toggleFloatingMode, aEvent );
}
}
break;
case VclEventId::WindowEndPopupMode:
{
if ( mpImpl->getDockableWindowListeners().getLength() )
{
EndPopupModeData *pData = static_cast<EndPopupModeData*>(rVclWindowEvent.GetData());
if( pData )
{
css::awt::EndPopupModeEvent aEvent;
aEvent.Source = getXWeak();
aEvent.FloatingPosition.X = pData->maFloatingPos.X();
aEvent.FloatingPosition.Y = pData->maFloatingPos.Y();
aEvent.bTearoff = pData->mbTearoff;
mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::endPopupMode, aEvent );
}
}
}
break;
default: break;
}
}
uno::Reference< accessibility::XAccessibleContext > VCLXWindow::CreateAccessibleContext()
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return nullptr;
return getAccessibleFactory().createAccessibleContext( this );
}
void VCLXWindow::SetSynthesizingVCLEvent( bool _b )
{
mpImpl->mbSynthesizingVCLEvent = _b;
}
bool VCLXWindow::IsSynthesizingVCLEvent() const
{
return mpImpl->mbSynthesizingVCLEvent;
}
Size VCLXWindow::ImplCalcWindowSize( const Size& rOutSz ) const
{
Size aSz = rOutSz;
VclPtr<vcl::Window> pWindow = GetWindow();
if ( pWindow )
{
sal_Int32 nLeft, nTop, nRight, nBottom;
pWindow->GetBorder( nLeft, nTop, nRight, nBottom );
aSz.AdjustWidth(nLeft+nRight );
aSz.AdjustHeight(nTop+nBottom );
}
return aSz;
}
// css::lang::Component
void VCLXWindow::dispose( )
{
SolarMutexGuard aGuard;
if ( mpImpl->mbDisposing )
return;
mpImpl->mbDisposing = true;
mpImpl->mxViewGraphics = nullptr;
mpImpl->disposing();
if ( VclPtr<vcl::Window> pWindow = GetWindow() )
{
pWindow->RemoveEventListener( LINK( this, VCLXWindow, WindowEventListener ) );
pWindow->SetWindowPeer( nullptr, nullptr );
SetOutputDevice( nullptr );
pWindow.disposeAndClear();
}
// #i14103# dispose the accessible context after the window has been destroyed,
// otherwise the old value in the child event fired in VCLXAccessibleComponent::ProcessWindowEvent()
// for VclEventId::WindowChildDestroyed contains a reference to an already disposed accessible object
try
{
css::uno::Reference< css::lang::XComponent > xComponent( mpImpl->mxAccessibleContext, css::uno::UNO_QUERY );
if ( xComponent.is() )
xComponent->dispose();
}
catch ( const css::uno::Exception& )
{
OSL_FAIL( "VCLXWindow::dispose: could not dispose the accessible context!" );
}
mpImpl->mxAccessibleContext.clear();
}
void VCLXWindow::addEventListener( const css::uno::Reference< css::lang::XEventListener >& rxListener )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing) // called during dispose by accessibility stuff
return;
mpImpl->getEventListeners().addInterface( rxListener );
}
void VCLXWindow::removeEventListener( const css::uno::Reference< css::lang::XEventListener >& rxListener )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return;
mpImpl->getEventListeners().removeInterface( rxListener );
}
// css::awt::XWindow
void VCLXWindow::setPosSize( sal_Int32 X, sal_Int32 Y, sal_Int32 Width, sal_Int32 Height, sal_Int16 Flags )
{
SolarMutexGuard aGuard;
comphelper::ProfileZone aZone("setPosSize");
if ( GetWindow() )
{
if( vcl::Window::GetDockingManager()->IsDockable( GetWindow() ) )
vcl::Window::GetDockingManager()->SetPosSizePixel( GetWindow() , X, Y, Width, Height, static_cast<PosSizeFlags>(Flags) );
else
GetWindow()->setPosSizePixel( X, Y, Width, Height, static_cast<PosSizeFlags>(Flags) );
}
}
css::awt::Rectangle VCLXWindow::getPosSize( )
{
SolarMutexGuard aGuard;
css::awt::Rectangle aBounds;
if ( GetWindow() )
{
if( vcl::Window::GetDockingManager()->IsDockable( GetWindow() ) )
aBounds = AWTRectangle( vcl::Window::GetDockingManager()->GetPosSizePixel( GetWindow() ) );
else
aBounds = AWTRectangle( tools::Rectangle( GetWindow()->GetPosPixel(), GetWindow()->GetSizePixel() ) );
}
return aBounds;
}
void VCLXWindow::setVisible( sal_Bool bVisible )
{
SolarMutexGuard aGuard;
VclPtr<vcl::Window> pWindow = GetWindow();
if ( pWindow )
{
mpImpl->setDirectVisible( bVisible );
pWindow->Show( bVisible && mpImpl->isEnableVisible() );
}
}
void VCLXWindow::setEnable( sal_Bool bEnable )
{
SolarMutexGuard aGuard;
VclPtr<vcl::Window> pWindow = GetWindow();
if ( pWindow )
{
pWindow->Enable( bEnable, false ); // #95824# without children!
pWindow->EnableInput( bEnable );
}
}
void VCLXWindow::setFocus( )
{
SolarMutexGuard aGuard;
if ( GetWindow() )
GetWindow()->GrabFocus();
}
void VCLXWindow::addWindowListener( const css::uno::Reference< css::awt::XWindowListener >& rxListener )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return;
mpImpl->getWindowListeners().addInterface( rxListener );
Reference< XWindowListener2 > xListener2( rxListener, UNO_QUERY );
if ( xListener2.is() )
mpImpl->getWindow2Listeners().addInterface( xListener2 );
// #100119# Get all resize events, even if height or width 0, or invisible
if ( GetWindow() )
GetWindow()->EnableAllResize();
}
void VCLXWindow::removeWindowListener( const css::uno::Reference< css::awt::XWindowListener >& rxListener )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return;
Reference< XWindowListener2 > xListener2( rxListener, UNO_QUERY );
if ( xListener2.is() )
mpImpl->getWindow2Listeners().removeInterface( xListener2 );
mpImpl->getWindowListeners().removeInterface( rxListener );
}
void VCLXWindow::addFocusListener( const css::uno::Reference< css::awt::XFocusListener >& rxListener )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return;
mpImpl->getFocusListeners().addInterface( rxListener );
}
void VCLXWindow::removeFocusListener( const css::uno::Reference< css::awt::XFocusListener >& rxListener )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return;
mpImpl->getFocusListeners().removeInterface( rxListener );
}
void VCLXWindow::addKeyListener( const css::uno::Reference< css::awt::XKeyListener >& rxListener )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return;
mpImpl->getKeyListeners().addInterface( rxListener );
}
void VCLXWindow::removeKeyListener( const css::uno::Reference< css::awt::XKeyListener >& rxListener )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return;
mpImpl->getKeyListeners().removeInterface( rxListener );
}
void VCLXWindow::addMouseListener( const css::uno::Reference< css::awt::XMouseListener >& rxListener )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return;
mpImpl->getMouseListeners().addInterface( rxListener );
}
void VCLXWindow::removeMouseListener( const css::uno::Reference< css::awt::XMouseListener >& rxListener )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return;
mpImpl->getMouseListeners().removeInterface( rxListener );
}
void VCLXWindow::addMouseMotionListener( const css::uno::Reference< css::awt::XMouseMotionListener >& rxListener )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return;
mpImpl->getMouseMotionListeners().addInterface( rxListener );
}
void VCLXWindow::removeMouseMotionListener( const css::uno::Reference< css::awt::XMouseMotionListener >& rxListener )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return;
mpImpl->getMouseMotionListeners().removeInterface( rxListener );
}
void VCLXWindow::addPaintListener( const css::uno::Reference< css::awt::XPaintListener >& rxListener )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return;
mpImpl->getPaintListeners().addInterface( rxListener );
}
void VCLXWindow::removePaintListener( const css::uno::Reference< css::awt::XPaintListener >& rxListener )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return;
mpImpl->getPaintListeners().removeInterface( rxListener );
}
// css::awt::XWindowPeer
css::uno::Reference< css::awt::XToolkit > VCLXWindow::getToolkit( )
{
// no guard. nothing to guard here.
// 82463 - 12/21/00 - fs
return Application::GetVCLToolkit();
}
void VCLXWindow::setPointer( const css::uno::Reference< css::awt::XPointer >& rxPointer )
{
SolarMutexGuard aGuard;
VCLXPointer* pPointer = dynamic_cast<VCLXPointer*>( rxPointer.get() );
if ( pPointer && GetWindow() )
GetWindow()->SetPointer( pPointer->GetPointer() );
}
void VCLXWindow::setBackground( sal_Int32 nColor )
{
SolarMutexGuard aGuard;
if ( !GetWindow() )
return;
Color aColor(ColorTransparency, nColor);
GetWindow()->SetBackground( aColor );
GetWindow()->SetControlBackground( aColor );
WindowType eWinType = GetWindow()->GetType();
if ( ( eWinType == WindowType::WINDOW ) ||
( eWinType == WindowType::WORKWINDOW ) ||
( eWinType == WindowType::FLOATINGWINDOW ) )
{
GetWindow()->Invalidate();
}
}
void VCLXWindow::invalidate( sal_Int16 nInvalidateFlags )
{
SolarMutexGuard aGuard;
if ( GetWindow() )
GetWindow()->Invalidate( static_cast<InvalidateFlags>(nInvalidateFlags) );
}
void VCLXWindow::invalidateRect( const css::awt::Rectangle& rRect, sal_Int16 nInvalidateFlags )
{
SolarMutexGuard aGuard;
if ( GetWindow() )
GetWindow()->Invalidate( VCLRectangle(rRect), static_cast<InvalidateFlags>(nInvalidateFlags) );
}
// css::awt::XVclWindowPeer
sal_Bool VCLXWindow::isChild( const css::uno::Reference< css::awt::XWindowPeer >& rxPeer )
{
SolarMutexGuard aGuard;
bool bIsChild = false;
VclPtr<vcl::Window> pWindow = GetWindow();
if ( pWindow )
{
VclPtr<vcl::Window> pPeerWindow = VCLUnoHelper::GetWindow( rxPeer );
bIsChild = pPeerWindow && pWindow->IsChild( pPeerWindow );
}
return bIsChild;
}
void VCLXWindow::setDesignMode( sal_Bool bOn )
{
SolarMutexGuard aGuard;
mpImpl->mbDesignMode = bOn;
}
sal_Bool VCLXWindow::isDesignMode( )
{
SolarMutexGuard aGuard;
return mpImpl->mbDesignMode;
}
void VCLXWindow::enableClipSiblings( sal_Bool bClip )
{
SolarMutexGuard aGuard;
if ( GetWindow() )
GetWindow()->EnableClipSiblings( bClip );
}
void VCLXWindow::setForeground( sal_Int32 nColor )
{
SolarMutexGuard aGuard;
if ( GetWindow() )
{
GetWindow()->SetControlForeground( Color(ColorTransparency, nColor) );
}
}
void VCLXWindow::setControlFont( const css::awt::FontDescriptor& rFont )
{
SolarMutexGuard aGuard;
if ( GetWindow() )
GetWindow()->SetControlFont( VCLUnoHelper::CreateFont( rFont, GetWindow()->GetControlFont() ) );
}
void VCLXWindow::getStyles( sal_Int16 nType, css::awt::FontDescriptor& Font, sal_Int32& ForegroundColor, sal_Int32& BackgroundColor )
{
SolarMutexGuard aGuard;
if ( !GetWindow() )
return;
const StyleSettings& rStyleSettings = GetWindow()->GetSettings().GetStyleSettings();
switch ( nType )
{
case css::awt::Style::FRAME:
{
Font = VCLUnoHelper::CreateFontDescriptor( rStyleSettings.GetAppFont() );
ForegroundColor = sal_Int32(rStyleSettings.GetWindowTextColor());
BackgroundColor = sal_Int32(rStyleSettings.GetWindowColor());
}
break;
case css::awt::Style::DIALOG:
{
Font = VCLUnoHelper::CreateFontDescriptor( rStyleSettings.GetAppFont() );
ForegroundColor = sal_Int32(rStyleSettings.GetDialogTextColor());
BackgroundColor = sal_Int32(rStyleSettings.GetDialogColor());
}
break;
default: OSL_FAIL( "VCLWindow::getStyles() - unknown Type" );
}
}
namespace toolkit
{
static void setColorSettings( vcl::Window* _pWindow, const css::uno::Any& _rValue,
void (StyleSettings::*pSetter)( const Color& ), const Color& (StyleSettings::*pGetter)( ) const )
{
sal_Int32 nColor = 0;
if ( !( _rValue >>= nColor ) )
nColor = sal_Int32((Application::GetSettings().GetStyleSettings().*pGetter)());
AllSettings aSettings = _pWindow->GetSettings();
StyleSettings aStyleSettings = aSettings.GetStyleSettings();
(aStyleSettings.*pSetter)( Color( ColorTransparency, nColor ) );
aSettings.SetStyleSettings( aStyleSettings );
_pWindow->SetSettings( aSettings, true );
}
}
// Terminated by BASEPROPERTY_NOTFOUND (or 0)
void VCLXWindow::PushPropertyIds( std::vector< sal_uInt16 > &rIds,
int nFirstId, ...)
{
va_list pVarArgs;
va_start( pVarArgs, nFirstId );
for ( int nId = nFirstId; nId != BASEPROPERTY_NOTFOUND;
nId = va_arg( pVarArgs, int ) )
rIds.push_back( static_cast<sal_uInt16>(nId) );
va_end( pVarArgs );
}
void VCLXWindow::ImplGetPropertyIds( std::vector< sal_uInt16 > &rIds, bool bWithDefaults )
{
// These are common across ~all VCLXWindow derived classes
if( bWithDefaults )
PushPropertyIds( rIds,
BASEPROPERTY_ALIGN,
BASEPROPERTY_BACKGROUNDCOLOR,
BASEPROPERTY_BORDER,
BASEPROPERTY_BORDERCOLOR,
BASEPROPERTY_DEFAULTCONTROL,
BASEPROPERTY_ENABLED,
BASEPROPERTY_FONTDESCRIPTOR,
BASEPROPERTY_HELPTEXT,
BASEPROPERTY_HELPURL,
BASEPROPERTY_TEXT,
BASEPROPERTY_PRINTABLE,
BASEPROPERTY_ENABLEVISIBLE, // for visibility
BASEPROPERTY_TABSTOP,
0);
// lovely hack from:
// void UnoControlModel::ImplRegisterProperty( sal_uInt16 nPropId )
if( std::find(rIds.begin(), rIds.end(), BASEPROPERTY_FONTDESCRIPTOR) != rIds.end() )
{
// some properties are not included in the FontDescriptor, but every time
// when we have a FontDescriptor we want to have these properties too.
// => Easier to register the here, instead everywhere where I register the FontDescriptor...
rIds.push_back( BASEPROPERTY_TEXTCOLOR );
rIds.push_back( BASEPROPERTY_TEXTLINECOLOR );
rIds.push_back( BASEPROPERTY_FONTRELIEF );
rIds.push_back( BASEPROPERTY_FONTEMPHASISMARK );
}
}
void VCLXWindow::GetPropertyIds( std::vector< sal_uInt16 >& _out_rIds )
{
return ImplGetPropertyIds( _out_rIds, mpImpl->mbWithDefaultProps );
}
ListenerMultiplexerBase<css::awt::XVclContainerListener>& VCLXWindow::GetContainerListeners()
{
return mpImpl->getContainerListeners();
}
ListenerMultiplexerBase<css::awt::XTopWindowListener>& VCLXWindow::GetTopWindowListeners()
{
return mpImpl->getTopWindowListeners();
}
namespace
{
void lcl_updateWritingMode( vcl::Window& _rWindow, const sal_Int16 _nWritingMode, const sal_Int16 _nContextWritingMode )
{
bool bEnableRTL = false;
switch ( _nWritingMode )
{
case WritingMode2::LR_TB: bEnableRTL = false; break;
case WritingMode2::RL_TB: bEnableRTL = true; break;
case WritingMode2::CONTEXT:
{
// consult our ContextWritingMode. If it has an explicit RTL/LTR value, then use
// it. If it doesn't (but is CONTEXT itself), then just ask the parent window of our
// own window for its RTL mode
switch ( _nContextWritingMode )
{
case WritingMode2::LR_TB: bEnableRTL = false; break;
case WritingMode2::RL_TB: bEnableRTL = true; break;
case WritingMode2::CONTEXT:
{
const vcl::Window* pParent = _rWindow.GetParent();
OSL_ENSURE( pParent, "lcl_updateWritingMode: cannot determine context's writing mode!" );
if ( pParent )
bEnableRTL = pParent->IsRTLEnabled();
}
break;
}
}
break;
default:
OSL_FAIL( "lcl_updateWritingMode: unsupported WritingMode!" );
} // switch ( nWritingMode )
_rWindow.EnableRTL( bEnableRTL );
}
}
void VCLXWindow::setProperty( const OUString& PropertyName, const css::uno::Any& Value )
{
SolarMutexGuard aGuard;
VclPtr<vcl::Window> pWindow = GetWindow();
if ( !pWindow )
return;
bool bVoid = Value.getValueType().getTypeClass() == css::uno::TypeClass_VOID;
WindowType eWinType = pWindow->GetType();
sal_uInt16 nPropType = GetPropertyId( PropertyName );
switch ( nPropType )
{
case BASEPROPERTY_REFERENCE_DEVICE:
{
Control* pControl = dynamic_cast< Control* >( pWindow.get() );
OSL_ENSURE( pControl, "VCLXWindow::setProperty( RefDevice ): need a Control for this!" );
if ( !pControl )
break;
Reference< XDevice > xDevice( Value, UNO_QUERY );
OutputDevice* pDevice = VCLUnoHelper::GetOutputDevice( xDevice );
pControl->SetReferenceDevice( pDevice );
}
break;
case BASEPROPERTY_CONTEXT_WRITING_MODE:
{
OSL_VERIFY( Value >>= mpImpl->mnContextWritingMode );
if ( mpImpl->mnWritingMode == WritingMode2::CONTEXT )
lcl_updateWritingMode( *pWindow, mpImpl->mnWritingMode, mpImpl->mnContextWritingMode );
}
break;
case BASEPROPERTY_WRITING_MODE:
{
bool bProperType = ( Value >>= mpImpl->mnWritingMode );
OSL_ENSURE( bProperType, "VCLXWindow::setProperty( 'WritingMode' ): illegal value type!" );
if ( bProperType )
lcl_updateWritingMode( *pWindow, mpImpl->mnWritingMode, mpImpl->mnContextWritingMode );
}
break;
case BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR:
{
sal_uInt16 nWheelBehavior( css::awt::MouseWheelBehavior::SCROLL_FOCUS_ONLY );
OSL_VERIFY( Value >>= nWheelBehavior );
AllSettings aSettings = pWindow->GetSettings();
MouseSettings aMouseSettings = aSettings.GetMouseSettings();
MouseWheelBehaviour nVclBehavior( MouseWheelBehaviour::FocusOnly );
switch ( nWheelBehavior )
{
case css::awt::MouseWheelBehavior::SCROLL_DISABLED: nVclBehavior = MouseWheelBehaviour::Disable; break;
case css::awt::MouseWheelBehavior::SCROLL_FOCUS_ONLY: nVclBehavior = MouseWheelBehaviour::FocusOnly; break;
case css::awt::MouseWheelBehavior::SCROLL_ALWAYS: nVclBehavior = MouseWheelBehaviour::ALWAYS; break;
default:
OSL_FAIL( "VCLXWindow::setProperty( 'MouseWheelBehavior' ): illegal property value!" );
}
aMouseSettings.SetWheelBehavior( nVclBehavior );
aSettings.SetMouseSettings( aMouseSettings );
pWindow->SetSettings( aSettings, true );
}
break;
case BASEPROPERTY_NATIVE_WIDGET_LOOK:
{
bool bEnable( true );
OSL_VERIFY( Value >>= bEnable );
pWindow->EnableNativeWidget( bEnable );
}
break;
case BASEPROPERTY_PLUGINPARENT:
{
// set parent handle
SetSystemParent_Impl( Value );
}
break;
case BASEPROPERTY_ENABLED:
{
bool b = bool();
if ( Value >>= b )
setEnable( b );
}
break;
case BASEPROPERTY_ENABLEVISIBLE:
{
bool b = false;
if ( Value >>= b )
{
if( b != mpImpl->isEnableVisible() )
{
mpImpl->setEnableVisible( b );
pWindow->Show( b && mpImpl->isDirectVisible() );
}
}
}
break;
case BASEPROPERTY_TEXT:
case BASEPROPERTY_LABEL:
case BASEPROPERTY_TITLE:
{
OUString aText;
if ( Value >>= aText )
{
switch (eWinType)
{
case WindowType::OKBUTTON:
case WindowType::CANCELBUTTON:
case WindowType::HELPBUTTON:
// Standard Button: overwrite only if not empty.
if (!aText.isEmpty())
pWindow->SetText( aText );
break;
default:
pWindow->SetText( aText );
break;
}
}
}
break;
case BASEPROPERTY_ACCESSIBLENAME:
{
OUString aText;
if ( Value >>= aText )
pWindow->SetAccessibleName( aText );
}
break;
case BASEPROPERTY_HELPURL:
{
OUString aURL;
if ( Value >>= aURL )
{
INetURLObject aHelpURL( aURL );
if ( aHelpURL.GetProtocol() == INetProtocol::Hid )
pWindow->SetHelpId( aHelpURL.GetURLPath() );
else
pWindow->SetHelpId( aURL );
}
}
break;
case BASEPROPERTY_HELPTEXT:
{
OUString aHelpText;
if ( Value >>= aHelpText )
{
pWindow->SetQuickHelpText( aHelpText );
}
}
break;
case BASEPROPERTY_FONTDESCRIPTOR:
{
if ( bVoid )
pWindow->SetControlFont( vcl::Font() );
else
{
css::awt::FontDescriptor aFont;
if ( Value >>= aFont )
pWindow->SetControlFont( VCLUnoHelper::CreateFont( aFont, pWindow->GetControlFont() ) );
}
}
break;
case BASEPROPERTY_FONTRELIEF:
{
sal_Int16 n = sal_Int16();
if ( Value >>= n )
{
vcl::Font aFont = pWindow->GetControlFont();
aFont.SetRelief( static_cast<FontRelief>(n) );
pWindow->SetControlFont( aFont );
}
}
break;
case BASEPROPERTY_FONTEMPHASISMARK:
{
sal_Int16 n = sal_Int16();
if ( Value >>= n )
{
vcl::Font aFont = pWindow->GetControlFont();
aFont.SetEmphasisMark( static_cast<FontEmphasisMark>(n) );
pWindow->SetControlFont( aFont );
}
}
break;
case BASEPROPERTY_BACKGROUNDCOLOR:
if ( bVoid )
{
switch ( eWinType )
{
// set dialog color for default
case WindowType::DIALOG:
case WindowType::MESSBOX:
case WindowType::INFOBOX:
case WindowType::WARNINGBOX:
case WindowType::ERRORBOX:
case WindowType::QUERYBOX:
case WindowType::TABPAGE:
{
Color aColor = pWindow->GetSettings().GetStyleSettings().GetDialogColor();
pWindow->SetBackground( aColor );
pWindow->SetControlBackground( aColor );
break;
}
case WindowType::FIXEDTEXT:
case WindowType::CHECKBOX:
case WindowType::RADIOBUTTON:
case WindowType::GROUPBOX:
case WindowType::FIXEDLINE:
{
// support transparency only for special controls
pWindow->SetBackground();
pWindow->SetControlBackground();
pWindow->SetPaintTransparent( true );
break;
}
default:
{
// default code which enables transparency for
// compound controls. It's not real transparency
// as most of these controls repaint their client
// area completely new.
if ( pWindow->IsCompoundControl() )
pWindow->SetBackground();
pWindow->SetControlBackground();
break;
}
}
}
else
{
Color aColor;
if ( Value >>= aColor )
{
pWindow->SetControlBackground( aColor );
pWindow->SetBackground( aColor );
switch ( eWinType )
{
// reset paint transparent mode
case WindowType::FIXEDTEXT:
case WindowType::CHECKBOX:
case WindowType::RADIOBUTTON:
case WindowType::GROUPBOX:
case WindowType::FIXEDLINE:
pWindow->SetPaintTransparent( false );
break;
default:
break;
}
pWindow->Invalidate(); // Invalidate if control does not respond to it
}
}
break;
case BASEPROPERTY_TEXTCOLOR:
if ( bVoid )
{
pWindow->SetControlForeground();
}
else
{
Color nColor ;
if ( Value >>= nColor )
{
pWindow->SetTextColor( nColor );
pWindow->SetControlForeground( nColor );
}
}
break;
case BASEPROPERTY_TEXTLINECOLOR:
if ( bVoid )
{
pWindow->SetTextLineColor();
}
else
{
Color nColor;
if ( Value >>= nColor )
pWindow->SetTextLineColor( nColor );
}
break;
case BASEPROPERTY_FILLCOLOR:
if ( bVoid )
pWindow->GetOutDev()->SetFillColor();
else
{
Color nColor;
if ( Value >>= nColor )
pWindow->GetOutDev()->SetFillColor( nColor );
}
break;
case BASEPROPERTY_LINECOLOR:
if ( bVoid )
pWindow->GetOutDev()->SetLineColor();
else
{
Color nColor;
if ( Value >>= nColor )
pWindow->GetOutDev()->SetLineColor( nColor );
}
break;
case BASEPROPERTY_HIGHLIGHT_COLOR:
{
Color nColor = 0;
if ( bVoid )
{
nColor = Application::GetSettings().GetStyleSettings().GetHighlightColor();
}
else
{
if (!(Value >>= nColor))
break;
}
AllSettings aSettings(pWindow->GetSettings());
StyleSettings aStyle(aSettings.GetStyleSettings());
aStyle.SetHighlightColor(nColor);
aSettings.SetStyleSettings(aStyle);
pWindow->SetSettings(aSettings);
}
break;
case BASEPROPERTY_HIGHLIGHT_TEXT_COLOR:
{
Color nColor = 0;
if (bVoid)
{
nColor = Application::GetSettings().GetStyleSettings().GetHighlightTextColor();
}
else
{
if (!(Value >>= nColor))
break;
}
AllSettings aSettings(pWindow->GetSettings());
StyleSettings aStyle(aSettings.GetStyleSettings());
aStyle.SetHighlightTextColor(nColor);
aSettings.SetStyleSettings(aStyle);
pWindow->SetSettings(aSettings);
}
break;
case BASEPROPERTY_BORDER:
{
WinBits nStyle = pWindow->GetStyle();
sal_uInt16 nTmp = 0;
Value >>= nTmp;
// clear any dodgy bits passed in, can come from dodgy extensions
nTmp &= o3tl::typed_flags<WindowBorderStyle>::mask;
WindowBorderStyle nBorder = static_cast<WindowBorderStyle>(nTmp);
if ( !bool(nBorder) )
{
pWindow->SetStyle( nStyle & ~WB_BORDER );
}
else
{
pWindow->SetStyle( nStyle | WB_BORDER );
pWindow->SetBorderStyle( nBorder );
}
}
break;
case BASEPROPERTY_TABSTOP:
{
WinBits nStyle = pWindow->GetStyle() & ~WB_TABSTOP;
if ( !bVoid )
{
bool bTab = false;
Value >>= bTab;
if ( bTab )
nStyle |= WB_TABSTOP;
else
nStyle |= WB_NOTABSTOP;
}
pWindow->SetStyle( nStyle );
}
break;
case BASEPROPERTY_VERTICALALIGN:
{
VerticalAlignment eAlign = css::style::VerticalAlignment::VerticalAlignment_MAKE_FIXED_SIZE;
WinBits nStyle = pWindow->GetStyle();
nStyle &= ~(WB_TOP|WB_VCENTER|WB_BOTTOM);
if ( !bVoid )
Value >>= eAlign;
switch ( eAlign )
{
case VerticalAlignment_TOP:
nStyle |= WB_TOP;
break;
case VerticalAlignment_MIDDLE:
nStyle |= WB_VCENTER;
break;
case VerticalAlignment_BOTTOM:
nStyle |= WB_BOTTOM;
break;
default: ; // for warning free code, MAKE_FIXED_SIZE
}
pWindow->SetStyle( nStyle );
}
break;
case BASEPROPERTY_ALIGN:
{
sal_Int16 nAlign = PROPERTY_ALIGN_LEFT;
switch ( eWinType )
{
case WindowType::COMBOBOX:
case WindowType::PUSHBUTTON:
case WindowType::OKBUTTON:
case WindowType::CANCELBUTTON:
case WindowType::HELPBUTTON:
nAlign = PROPERTY_ALIGN_CENTER;
[[fallthrough]];
case WindowType::FIXEDTEXT:
case WindowType::EDIT:
case WindowType::MULTILINEEDIT:
case WindowType::CHECKBOX:
case WindowType::RADIOBUTTON:
case WindowType::LISTBOX:
{
WinBits nStyle = pWindow->GetStyle();
nStyle &= ~(WB_LEFT|WB_CENTER|WB_RIGHT);
if ( !bVoid )
Value >>= nAlign;
if ( nAlign == PROPERTY_ALIGN_LEFT )
nStyle |= WB_LEFT;
else if ( nAlign == PROPERTY_ALIGN_CENTER )
nStyle |= WB_CENTER;
else
nStyle |= WB_RIGHT;
pWindow->SetStyle( nStyle );
}
break;
default: break;
}
}
break;
case BASEPROPERTY_MULTILINE:
{
if ( ( eWinType == WindowType::FIXEDTEXT )
|| ( eWinType == WindowType::CHECKBOX )
|| ( eWinType == WindowType::RADIOBUTTON )
|| ( eWinType == WindowType::PUSHBUTTON )
|| ( eWinType == WindowType::OKBUTTON )
|| ( eWinType == WindowType::CANCELBUTTON )
|| ( eWinType == WindowType::HELPBUTTON )
)
{
WinBits nStyle = pWindow->GetStyle();
bool bMulti = false;
Value >>= bMulti;
if ( bMulti )
nStyle |= WB_WORDBREAK;
else
nStyle &= ~WB_WORDBREAK;
pWindow->SetStyle( nStyle );
}
}
break;
case BASEPROPERTY_ORIENTATION:
{
if ( eWinType == WindowType::FIXEDLINE)
{
sal_Int32 nOrientation = 0;
if ( Value >>= nOrientation )
{
WinBits nStyle = pWindow->GetStyle();
nStyle &= ~(WB_HORZ|WB_VERT);
if ( nOrientation == 0 )
nStyle |= WB_HORZ;
else
nStyle |= WB_VERT;
pWindow->SetStyle( nStyle );
}
}
}
break;
case BASEPROPERTY_AUTOMNEMONICS:
{
bool bAutoMnemonics = false;
Value >>= bAutoMnemonics;
AllSettings aSettings = pWindow->GetSettings();
StyleSettings aStyleSettings = aSettings.GetStyleSettings();
if ( aStyleSettings.GetAutoMnemonic() != bAutoMnemonics )
{
aStyleSettings.SetAutoMnemonic( bAutoMnemonics );
aSettings.SetStyleSettings( aStyleSettings );
pWindow->SetSettings( aSettings );
}
}
break;
case BASEPROPERTY_MOUSETRANSPARENT:
{
bool bMouseTransparent = false;
Value >>= bMouseTransparent;
pWindow->SetMouseTransparent( bMouseTransparent );
}
break;
case BASEPROPERTY_PAINTTRANSPARENT:
{
bool bPaintTransparent = false;
Value >>= bPaintTransparent;
pWindow->SetPaintTransparent( bPaintTransparent );
// pWindow->SetBackground();
}
break;
case BASEPROPERTY_REPEAT:
{
bool bRepeat( false );
Value >>= bRepeat;
WinBits nStyle = pWindow->GetStyle();
if ( bRepeat )
nStyle |= WB_REPEAT;
else
nStyle &= ~WB_REPEAT;
pWindow->SetStyle( nStyle );
}
break;
case BASEPROPERTY_REPEAT_DELAY:
{
sal_Int32 nRepeatDelay = 0;
if ( Value >>= nRepeatDelay )
{
AllSettings aSettings = pWindow->GetSettings();
MouseSettings aMouseSettings = aSettings.GetMouseSettings();
aMouseSettings.SetButtonRepeat( nRepeatDelay );
aSettings.SetMouseSettings( aMouseSettings );
pWindow->SetSettings( aSettings, true );
}
}
break;
case BASEPROPERTY_SYMBOL_COLOR:
::toolkit::setColorSettings( pWindow, Value, &StyleSettings::SetButtonTextColor, &StyleSettings::GetButtonTextColor );
break;
case BASEPROPERTY_BORDERCOLOR:
::toolkit::setColorSettings( pWindow, Value, &StyleSettings::SetMonoColor, &StyleSettings::GetMonoColor);
break;
}
}
css::uno::Any VCLXWindow::getProperty( const OUString& PropertyName )
{
SolarMutexGuard aGuard;
css::uno::Any aProp;
if ( GetWindow() )
{
if (PropertyName == "ParentIs100thmm")
{
bool bParentIs100thmm = false;
VclPtr<vcl::Window> pWindow = GetWindow();
if (pWindow)
{
pWindow = pWindow->GetParent();
if(pWindow && MapUnit::Map100thMM == pWindow->GetMapMode().GetMapUnit())
{
bParentIs100thmm = true;
}
}
aProp <<= bParentIs100thmm;
return aProp;
}
WindowType eWinType = GetWindow()->GetType();
sal_uInt16 nPropType = GetPropertyId( PropertyName );
switch ( nPropType )
{
case BASEPROPERTY_REFERENCE_DEVICE:
{
VclPtr<Control> pControl = GetAsDynamic<Control >();
OSL_ENSURE( pControl, "VCLXWindow::setProperty( RefDevice ): need a Control for this!" );
if ( !pControl )
break;
rtl::Reference<VCLXDevice> pDevice = new VCLXDevice;
pDevice->SetOutputDevice( pControl->GetReferenceDevice() );
aProp <<= Reference< XDevice >( pDevice );
}
break;
case BASEPROPERTY_CONTEXT_WRITING_MODE:
aProp <<= mpImpl->mnContextWritingMode;
break;
case BASEPROPERTY_WRITING_MODE:
aProp <<= mpImpl->mnWritingMode;
break;
case BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR:
{
MouseWheelBehaviour nVclBehavior = GetWindow()->GetSettings().GetMouseSettings().GetWheelBehavior();
sal_uInt16 nBehavior = css::awt::MouseWheelBehavior::SCROLL_FOCUS_ONLY;
switch ( nVclBehavior )
{
case MouseWheelBehaviour::Disable: nBehavior = css::awt::MouseWheelBehavior::SCROLL_DISABLED; break;
case MouseWheelBehaviour::FocusOnly: nBehavior = css::awt::MouseWheelBehavior::SCROLL_FOCUS_ONLY; break;
case MouseWheelBehaviour::ALWAYS: nBehavior = css::awt::MouseWheelBehavior::SCROLL_ALWAYS; break;
default:
OSL_FAIL( "VCLXWindow::getProperty( 'MouseWheelBehavior' ): illegal VCL value!" );
}
aProp <<= nBehavior;
}
break;
case BASEPROPERTY_NATIVE_WIDGET_LOOK:
aProp <<= GetWindow()->IsNativeWidgetEnabled();
break;
case BASEPROPERTY_ENABLED:
aProp <<= GetWindow()->IsEnabled();
break;
case BASEPROPERTY_ENABLEVISIBLE:
aProp <<= mpImpl->isEnableVisible();
break;
case BASEPROPERTY_HIGHCONTRASTMODE:
aProp <<= GetWindow()->GetSettings().GetStyleSettings().GetHighContrastMode();
break;
case BASEPROPERTY_TEXT:
case BASEPROPERTY_LABEL:
case BASEPROPERTY_TITLE:
{
OUString aText = GetWindow()->GetText();
aProp <<= aText;
}
break;
case BASEPROPERTY_ACCESSIBLENAME:
{
OUString aText = GetWindow()->GetAccessibleName();
aProp <<= aText;
}
break;
case BASEPROPERTY_HELPTEXT:
{
OUString aText = GetWindow()->GetQuickHelpText();
aProp <<= aText;
}
break;
case BASEPROPERTY_HELPURL:
aProp <<= GetWindow()->GetHelpId();
break;
case BASEPROPERTY_FONTDESCRIPTOR:
{
vcl::Font aFont = GetWindow()->GetControlFont();
css::awt::FontDescriptor aFD = VCLUnoHelper::CreateFontDescriptor( aFont );
aProp <<= aFD;
}
break;
case BASEPROPERTY_BACKGROUNDCOLOR:
aProp <<= GetWindow()->GetControlBackground();
break;
case BASEPROPERTY_DISPLAYBACKGROUNDCOLOR:
aProp <<= GetWindow()->GetBackgroundColor();
break;
case BASEPROPERTY_FONTRELIEF:
aProp <<= static_cast<sal_Int16>(GetWindow()->GetControlFont().GetRelief());
break;
case BASEPROPERTY_FONTEMPHASISMARK:
aProp <<= static_cast<sal_Int16>(GetWindow()->GetControlFont().GetEmphasisMark());
break;
case BASEPROPERTY_TEXTCOLOR:
aProp <<= GetWindow()->GetControlForeground();
break;
case BASEPROPERTY_TEXTLINECOLOR:
aProp <<= GetWindow()->GetTextLineColor();
break;
case BASEPROPERTY_FILLCOLOR:
aProp <<= GetWindow()->GetOutDev()->GetFillColor();
break;
case BASEPROPERTY_LINECOLOR:
aProp <<= GetWindow()->GetOutDev()->GetLineColor();
break;
case BASEPROPERTY_HIGHLIGHT_COLOR:
aProp <<= GetWindow()->GetSettings().GetStyleSettings().GetHighlightColor();
break;
case BASEPROPERTY_HIGHLIGHT_TEXT_COLOR:
aProp <<= GetWindow()->GetSettings().GetStyleSettings().GetHighlightTextColor();
break;
case BASEPROPERTY_BORDER:
{
WindowBorderStyle nBorder = WindowBorderStyle::NONE;
if ( GetWindow()->GetStyle() & WB_BORDER )
nBorder = GetWindow()->GetBorderStyle();
aProp <<= static_cast<sal_uInt16>(nBorder);
}
break;
case BASEPROPERTY_TABSTOP:
aProp <<= ( GetWindow()->GetStyle() & WB_TABSTOP ) != 0;
break;
case BASEPROPERTY_VERTICALALIGN:
{
WinBits nStyle = GetWindow()->GetStyle();
if ( nStyle & WB_TOP )
aProp <<= VerticalAlignment_TOP;
else if ( nStyle & WB_VCENTER )
aProp <<= VerticalAlignment_MIDDLE;
else if ( nStyle & WB_BOTTOM )
aProp <<= VerticalAlignment_BOTTOM;
}
break;
case BASEPROPERTY_ALIGN:
{
switch ( eWinType )
{
case WindowType::FIXEDTEXT:
case WindowType::EDIT:
case WindowType::MULTILINEEDIT:
case WindowType::CHECKBOX:
case WindowType::RADIOBUTTON:
case WindowType::LISTBOX:
case WindowType::COMBOBOX:
case WindowType::PUSHBUTTON:
case WindowType::OKBUTTON:
case WindowType::CANCELBUTTON:
case WindowType::HELPBUTTON:
{
WinBits nStyle = GetWindow()->GetStyle();
if ( nStyle & WB_LEFT )
aProp <<= sal_Int16(PROPERTY_ALIGN_LEFT);
else if ( nStyle & WB_CENTER )
aProp <<= sal_Int16(PROPERTY_ALIGN_CENTER);
else if ( nStyle & WB_RIGHT )
aProp <<= sal_Int16(PROPERTY_ALIGN_RIGHT);
}
break;
default: break;
}
}
break;
case BASEPROPERTY_MULTILINE:
{
if ( ( eWinType == WindowType::FIXEDTEXT )
|| ( eWinType == WindowType::CHECKBOX )
|| ( eWinType == WindowType::RADIOBUTTON )
|| ( eWinType == WindowType::PUSHBUTTON )
|| ( eWinType == WindowType::OKBUTTON )
|| ( eWinType == WindowType::CANCELBUTTON )
|| ( eWinType == WindowType::HELPBUTTON )
)
aProp <<= ( GetWindow()->GetStyle() & WB_WORDBREAK ) != 0;
}
break;
case BASEPROPERTY_AUTOMNEMONICS:
{
bool bAutoMnemonics = GetWindow()->GetSettings().GetStyleSettings().GetAutoMnemonic();
aProp <<= bAutoMnemonics;
}
break;
case BASEPROPERTY_MOUSETRANSPARENT:
{
bool bMouseTransparent = GetWindow()->IsMouseTransparent();
aProp <<= bMouseTransparent;
}
break;
case BASEPROPERTY_PAINTTRANSPARENT:
{
bool bPaintTransparent = GetWindow()->IsPaintTransparent();
aProp <<= bPaintTransparent;
}
break;
case BASEPROPERTY_REPEAT:
aProp <<= ( 0 != ( GetWindow()->GetStyle() & WB_REPEAT ) );
break;
case BASEPROPERTY_REPEAT_DELAY:
{
sal_Int32 nButtonRepeat = GetWindow()->GetSettings().GetMouseSettings().GetButtonRepeat();
aProp <<= nButtonRepeat;
}
break;
case BASEPROPERTY_SYMBOL_COLOR:
aProp <<= GetWindow()->GetSettings().GetStyleSettings().GetButtonTextColor();
break;
case BASEPROPERTY_BORDERCOLOR:
aProp <<= GetWindow()->GetSettings().GetStyleSettings().GetMonoColor();
break;
}
}
return aProp;
}
// css::awt::XLayoutConstrains
css::awt::Size VCLXWindow::getMinimumSize( )
{
SolarMutexGuard aGuard;
// Use this method only for those components which can be created through
// css::awt::Toolkit , but do not have an interface
Size aSz;
if ( GetWindow() )
{
WindowType nWinType = GetWindow()->GetType();
switch ( nWinType )
{
case WindowType::CONTROL:
aSz.setWidth( GetWindow()->GetTextWidth( GetWindow()->GetText() )+2*12 );
aSz.setHeight( GetWindow()->GetTextHeight()+2*6 );
break;
case WindowType::PATTERNBOX:
case WindowType::NUMERICBOX:
case WindowType::METRICBOX:
case WindowType::CURRENCYBOX:
case WindowType::DATEBOX:
case WindowType::TIMEBOX:
case WindowType::LONGCURRENCYBOX:
aSz.setWidth( GetWindow()->GetTextWidth( GetWindow()->GetText() )+2*2 );
aSz.setHeight( GetWindow()->GetTextHeight()+2*2 );
break;
case WindowType::SCROLLBARBOX:
return VCLXScrollBar::implGetMinimumSize( GetWindow() );
default:
aSz = GetWindow()->get_preferred_size();
}
}
return css::awt::Size( aSz.Width(), aSz.Height() );
}
css::awt::Size VCLXWindow::getPreferredSize( )
{
return getMinimumSize();
}
css::awt::Size VCLXWindow::calcAdjustedSize( const css::awt::Size& rNewSize )
{
SolarMutexGuard aGuard;
css::awt::Size aNewSize( rNewSize );
css::awt::Size aMinSize = getMinimumSize();
if ( aNewSize.Width < aMinSize.Width )
aNewSize.Width = aMinSize.Width;
if ( aNewSize.Height < aMinSize.Height )
aNewSize.Height = aMinSize.Height;
return aNewSize;
}
// css::awt::XView
sal_Bool VCLXWindow::setGraphics( const css::uno::Reference< css::awt::XGraphics >& rxDevice )
{
SolarMutexGuard aGuard;
if ( VCLUnoHelper::GetOutputDevice( rxDevice ) )
mpImpl->mxViewGraphics = rxDevice;
else
mpImpl->mxViewGraphics = nullptr;
return mpImpl->mxViewGraphics.is();
}
css::uno::Reference< css::awt::XGraphics > VCLXWindow::getGraphics( )
{
SolarMutexGuard aGuard;
return mpImpl->mxViewGraphics;
}
css::awt::Size VCLXWindow::getSize( )
{
SolarMutexGuard aGuard;
Size aSz;
if ( GetWindow() )
aSz = GetWindow()->GetSizePixel();
return css::awt::Size( aSz.Width(), aSz.Height() );
}
void VCLXWindow::draw( sal_Int32 nX, sal_Int32 nY )
{
SolarMutexGuard aGuard;
VclPtr<vcl::Window> pWindow = GetWindow();
if ( !pWindow )
return;
if ( !(isDesignMode() || mpImpl->isEnableVisible()) )
return;
OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( mpImpl->mxViewGraphics );
if (!pDev)
pDev = pWindow->GetParent()->GetOutDev();
TabPage* pTabPage = dynamic_cast< TabPage* >( pWindow.get() );
if ( pTabPage )
{
Point aPos( nX, nY );
aPos = pDev->PixelToLogic( aPos );
pTabPage->Draw( pDev, aPos, SystemTextColorFlags::NONE );
return;
}
Point aPos( nX, nY );
if ( pWindow->GetParent() && !pWindow->IsSystemWindow() && ( pWindow->GetParent()->GetOutDev() == pDev ) )
{
// #i40647# don't draw here if this is a recursive call
// sometimes this is called recursively, because the Update call on the parent
// (strangely) triggers another paint. Prevent a stack overflow here
// Yes, this is only fixing symptoms for the moment...
// #i40647# / 2005-01-18 / frank.schoenheit@sun.com
if ( !mpImpl->getDrawingOntoParent_ref() )
{
::comphelper::FlagGuard aDrawingflagGuard( mpImpl->getDrawingOntoParent_ref() );
bool bWasVisible = pWindow->IsVisible();
Point aOldPos( pWindow->GetPosPixel() );
if ( bWasVisible && aOldPos == aPos )
{
pWindow->PaintImmediately();
return;
}
pWindow->SetPosPixel( aPos );
// Update parent first to avoid painting the parent upon the update
// of this window, as it may otherwise cause the parent
// to hide this window again
if( pWindow->GetParent() )
pWindow->GetParent()->PaintImmediately();
pWindow->Show();
pWindow->PaintImmediately();
pWindow->SetParentUpdateMode( false );
pWindow->Hide();
pWindow->SetParentUpdateMode( true );
pWindow->SetPosPixel( aOldPos );
if ( bWasVisible )
pWindow->Show();
}
}
else if ( pDev )
{
Point aP = pDev->PixelToLogic( aPos );
vcl::PDFExtOutDevData* pPDFExport = dynamic_cast<vcl::PDFExtOutDevData*>(pDev->GetExtOutDevData());
bool bDrawSimple = ( pDev->GetOutDevType() == OUTDEV_PRINTER )
|| ( pDev->GetOutDevViewType() == OutDevViewType::PrintPreview )
|| ( pPDFExport != nullptr );
if ( bDrawSimple )
{
pWindow->Draw( pDev, aP, SystemTextColorFlags::NoControls );
}
else
{
bool bOldNW =pWindow->IsNativeWidgetEnabled();
if( bOldNW )
pWindow->EnableNativeWidget(false);
pWindow->PaintToDevice( pDev, aP );
if( bOldNW )
pWindow->EnableNativeWidget();
}
}
}
void VCLXWindow::setZoom( float fZoomX, float /*fZoomY*/ )
{
SolarMutexGuard aGuard;
if ( GetWindow() )
{
// Fraction::Fraction takes a double, but we have a float only.
// The implicit conversion from float to double can result in a precision loss, i.e. 1.2 is converted to
// 1.200000000047something. To prevent this, we convert explicitly to double, and round it.
double nZoom( fZoomX );
Fraction aZoom(::rtl::math::round(nZoom, 4));
aZoom.ReduceInaccurate(10); // to avoid runovers and BigInt mapping
GetWindow()->SetZoom(aZoom);
}
}
// css::lang::XEventListener
void SAL_CALL VCLXWindow::disposing( const css::lang::EventObject& _rSource )
{
SolarMutexGuard aGuard;
if (mpImpl->mbDisposing)
return;
// check if it comes from our AccessibleContext
uno::Reference< uno::XInterface > aAC( mpImpl->mxAccessibleContext, uno::UNO_QUERY );
uno::Reference< uno::XInterface > xSource( _rSource.Source, uno::UNO_QUERY );
if ( aAC.get() == xSource.get() )
{ // yep, it does
mpImpl->mxAccessibleContext.clear();
}
}
// css::accessibility::XAccessible
css::uno::Reference< css::accessibility::XAccessibleContext > VCLXWindow::getAccessibleContext( )
{
SolarMutexGuard aGuard;
// already disposed
if (mpImpl->mbDisposing)
return uno::Reference< accessibility::XAccessibleContext >();
if ( !mpImpl->mxAccessibleContext.is() && GetWindow() )
{
mpImpl->mxAccessibleContext = CreateAccessibleContext();
// add as event listener to this component
// in case somebody disposes it, we do not want to have a (though weak) reference to a dead
// object
uno::Reference< lang::XComponent > xComp( mpImpl->mxAccessibleContext, uno::UNO_QUERY );
if ( xComp.is() )
xComp->addEventListener( this );
}
return mpImpl->mxAccessibleContext;
}
// css::awt::XDockable
void SAL_CALL VCLXWindow::addDockableWindowListener( const css::uno::Reference< css::awt::XDockableWindowListener >& xListener )
{
SolarMutexGuard aGuard;
if (!mpImpl->mbDisposing && xListener.is() )
mpImpl->getDockableWindowListeners().addInterface( xListener );
}
void SAL_CALL VCLXWindow::removeDockableWindowListener( const css::uno::Reference< css::awt::XDockableWindowListener >& xListener )
{
SolarMutexGuard aGuard;
if (!mpImpl->mbDisposing)
mpImpl->getDockableWindowListeners().removeInterface( xListener );
}
void SAL_CALL VCLXWindow::enableDocking( sal_Bool bEnable )
{
SolarMutexGuard aGuard;
VclPtr<vcl::Window> pWindow = GetWindow();
if ( pWindow )
pWindow->EnableDocking( bEnable );
}
sal_Bool SAL_CALL VCLXWindow::isFloating( )
{
SolarMutexGuard aGuard;
VclPtr<vcl::Window> pWindow = GetWindow();
if( pWindow )
return vcl::Window::GetDockingManager()->IsFloating( pWindow );
else
return false;
}
void SAL_CALL VCLXWindow::setFloatingMode( sal_Bool bFloating )
{
SolarMutexGuard aGuard;
VclPtr<vcl::Window> pWindow = GetWindow();
if( pWindow )
vcl::Window::GetDockingManager()->SetFloatingMode( pWindow, bFloating );
}
sal_Bool SAL_CALL VCLXWindow::isLocked( )
{
SolarMutexGuard aGuard;
VclPtr<vcl::Window> pWindow = GetWindow();
if( pWindow )
return vcl::Window::GetDockingManager()->IsLocked( pWindow );
else
return false;
}
void SAL_CALL VCLXWindow::lock( )
{
SolarMutexGuard aGuard;
VclPtr<vcl::Window> pWindow = GetWindow();
if( pWindow && !vcl::Window::GetDockingManager()->IsFloating( pWindow ) )
vcl::Window::GetDockingManager()->Lock( pWindow );
}
void SAL_CALL VCLXWindow::unlock( )
{
SolarMutexGuard aGuard;
VclPtr<vcl::Window> pWindow = GetWindow();
if( pWindow && !vcl::Window::GetDockingManager()->IsFloating( pWindow ) )
vcl::Window::GetDockingManager()->Unlock( pWindow );
}
void SAL_CALL VCLXWindow::startPopupMode( const css::awt::Rectangle& )
{
// deprecated
}
sal_Bool SAL_CALL VCLXWindow::isInPopupMode( )
{
// deprecated
return false;
}
// css::awt::XWindow2
void SAL_CALL VCLXWindow::setOutputSize( const css::awt::Size& aSize )
{
SolarMutexGuard aGuard;
if( VclPtr<vcl::Window> pWindow = GetWindow() )
pWindow->SetOutputSizePixel( VCLSize( aSize ) );
}
css::awt::Size SAL_CALL VCLXWindow::getOutputSize( )
{
SolarMutexGuard aGuard;
if( VclPtr<vcl::Window> pWindow = GetWindow() )
return AWTSize( pWindow->GetOutputSizePixel() );
else
return css::awt::Size();
}
sal_Bool SAL_CALL VCLXWindow::isVisible( )
{
SolarMutexGuard aGuard;
if( GetWindow() )
return GetWindow()->IsVisible();
else
return false;
}
sal_Bool SAL_CALL VCLXWindow::isActive( )
{
SolarMutexGuard aGuard;
if( GetWindow() )
return GetWindow()->IsActive();
else
return false;
}
sal_Bool SAL_CALL VCLXWindow::isEnabled( )
{
SolarMutexGuard aGuard;
if( GetWindow() )
return GetWindow()->IsEnabled();
else
return false;
}
sal_Bool SAL_CALL VCLXWindow::hasFocus( )
{
SolarMutexGuard aGuard;
if( GetWindow() )
return GetWindow()->HasFocus();
else
return false;
}
// css::beans::XPropertySetInfo
UnoPropertyArrayHelper *
VCLXWindow::GetPropHelper()
{
SolarMutexGuard aGuard;
if ( mpImpl->mpPropHelper == nullptr )
{
std::vector< sal_uInt16 > aIDs;
GetPropertyIds( aIDs );
mpImpl->mpPropHelper.reset( new UnoPropertyArrayHelper( aIDs ) );
}
return mpImpl->mpPropHelper.get();
}
css::uno::Sequence< css::beans::Property > SAL_CALL
VCLXWindow::getProperties()
{
return GetPropHelper()->getProperties();
}
css::beans::Property SAL_CALL
VCLXWindow::getPropertyByName( const OUString& rName )
{
return GetPropHelper()->getPropertyByName( rName );
}
sal_Bool SAL_CALL
VCLXWindow::hasPropertyByName( const OUString& rName )
{
return GetPropHelper()->hasPropertyByName( rName );
}
Reference< XStyleSettings > SAL_CALL VCLXWindow::getStyleSettings()
{
return mpImpl->getStyleSettings();
}
bool VCLXWindow::IsDisposed() const
{
return mpImpl->mbDisposing;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */