fe2fc695df
2009-06-29 20:53:25 +0200 fs r273484 : #i103138# Rectangle conversion 2009-06-29 20:51:50 +0200 fs r273483 : #i103138# yet more refactoring, now also setting the proper zoom level at the proper point in time 2009-06-29 13:40:26 +0200 fs r273470 : added svn:ignore to ignore output paths 2009-06-29 10:08:54 +0200 fs r273455 : #i103138# refactored the code for positioning/zooming the control Basically, we now allow adjustControlGeometry_throw (formerly known as positionControl_throw and setControlZoom) to take an additional ViewTransformation parameter, describing the transformation to obtain the actual control position/size. Consequently, positionControl itself also allows for a ViewTransformation parameter. This has become necessary since during painting, the device which we created our control for might not necessarily have a proper MapMode set. In this case, if we would use this map mode for calculating the control's position/size, this would lead to wrong results. Note that this problem was introduced by the fix for #i101398#: During the fix, we postponed the control creation to a later time (when it is really needed). At this later time, the MapMode at the device is broken, at the earlier time where we formerly crearted the control (createPrimitive2DSequence), it is not yet broken. Whether or not the MapMode is defined as "broken" might depend on one's point of view, however ... I consider it broken, since: - we need the map mode to obtain the proper zoom level, which is to be forwarded to the control - there are scenarios where the MapMode is *not* set to MAP_PIXEL (in those scenarios, everything works fine), and there are scenarios where it *is* set to MAP_PIXEL (in those the bug 103138 appears). It somehow feels wrong that one cannot rely on the device's map mode this way, but on the other hand one has no possibility to obtain the current zoom by other means. Note that one issue (still to be submitted) is left: In the page pane of a Draw/Impress document, controls have a wrong text size. This is because in this pane, the above-mentioned "broken" map mode is used, which means the controls have a zoom of "1:1" set, which is wrong here. 2009-06-25 13:41:35 +0200 msc r273380 : #100000# the tabs changed die to new properties 2009-06-24 12:42:40 +0200 msc r273330 : #102082# remove issue warning 2009-06-22 10:43:14 +0200 fs r273201 : createPrimitive2DSequence: care for being disposed 2009-06-18 12:35:13 +0200 oj r273109 : #i102305# make nooptfiles for gcc 2009-06-17 12:14:37 +0200 oj r273056 : #i102305# fix for linux 2009-06-17 07:20:22 +0200 oj r273046 : #i102305# move ValueTransfer into the for loop to avoid a crash under Linux 2009-06-17 07:17:28 +0200 oj r273045 : #i102305# use varchar 2009-06-15 14:11:27 +0200 fs r272983 : added since tag 2009-06-15 12:11:39 +0200 oj r272973 : #i102305# SAL_DLLPUBLIC_EXPORT inserted 2009-06-15 11:08:53 +0200 fs r272969 : #i10000# 2009-06-15 09:25:13 +0200 fs r272963 : merging fix for P1 issue #i102701# 2009-06-11 11:31:24 +0200 fs r272858 : #i10000# copied the fix which before the rebase was done in ../dialog/macropg.src 2009-06-11 09:38:14 +0200 fs r272846 : CWS-TOOLING: rebase CWS dba32c to trunk@272827 (milestone: DEV300:m50) 2009-06-02 09:53:10 +0200 fs r272483 : #i10000# 2009-05-29 15:55:03 +0200 fs r272465 : #i100818# 2009-05-29 12:58:43 +0200 fs r272452 : don't apply comphelper::getString on possibly VOID any 2009-05-29 10:38:35 +0200 oj r272437 : #i101519# handle where condition 2009-05-29 09:53:39 +0200 fs r272434 : #i100818# call into releaseStubs /without/ locked GlobalMutex 2009-05-28 07:53:44 +0200 oj r272375 : #i101369# parse tree changed 2009-05-27 14:53:36 +0200 fs r272347 : #i10000# 2009-05-27 09:29:15 +0200 oj r272327 : #i101626# check for double before hard cast 2009-05-27 09:13:58 +0200 oj r272326 : #i101626# handle void correctly 2009-05-27 08:04:39 +0200 oj r272321 : #i102256# wrong method signature used 2009-05-27 07:55:52 +0200 oj r272320 : #i101519# look up parameter typ if used in function 2009-05-27 06:49:07 +0200 oj r272319 : #i101519# set parameter from rowset as well 2009-05-26 13:30:56 +0200 oj r272297 : #i101987# impl XBatchExecution 2009-05-26 12:44:34 +0200 oj r272293 : #i101700# check if group is not set 2009-05-26 12:16:53 +0200 oj r272290 : #i101369# resolved some reduce7reduce problems with boolean_term and search_condition 2009-05-26 12:12:42 +0200 oj r272289 : #i101369# fix for or on one line criteria 2009-05-25 16:02:25 +0200 fs r272257 : #i999704# +PROPERTY_MOUSE_WHEEL_BEHAVIOR 2009-05-25 16:01:55 +0200 fs r272256 : merging the changes from CWS dba32b herein 2009-05-25 15:49:57 +0200 fs r272254 : #i999704# 2009-05-25 15:32:57 +0200 fs r272252 : #i99704# grid columns also to respect the MouseWheelBehavior property 2009-05-25 15:23:43 +0200 fs r272251 : don't pass empty Anys to ::comphelper::getString 2009-05-25 14:48:43 +0200 fs r272248 : merged changes from CWS dba32b herein 2009-05-25 14:44:40 +0200 fs r272247 : #i99704# support new MouseWheelBehavior property 2009-05-25 14:43:18 +0200 fs r272246 : #i99704# WheelWithoutFocus (peer property) superseded by MouseWheelBehavior (model property) 2009-05-25 14:41:03 +0200 fs r272245 : #i99704# no need to set the mouse wheel behavior at the peer, this is now a model property, having the right default 2009-05-25 14:39:31 +0200 fs r272243 : removed dead import 2009-05-25 14:35:36 +0200 fs r272242 : the new EnableVisible doesn't make sense for grid columns 2009-05-25 14:34:33 +0200 fs r272241 : #i99704# +MouseWheelBehavior - allow to enable/disable the mouse wheel for the control, or make it focus-dependent 2009-05-25 14:26:11 +0200 fs r272240 : #i99704# change MouseSettings wheel flag (NoWheelActionWithoutFocus) to a three-state option, allowing to completely ignore the mouse wheel 2009-05-23 21:35:59 +0200 fs r272213 : localize 'sub component opened/closed' event 2009-05-22 21:42:47 +0200 fs r272211 : #i102003# 2009-05-22 21:42:20 +0200 fs r272210 : grammar 2009-05-22 21:36:10 +0200 fs r272209 : #i102140# load only once, not twice, and show error messages during loading (and during any form action, that is) asynchronously 2009-05-22 21:35:11 +0200 fs r272208 : #i102140# +clear 2009-05-22 14:50:30 +0200 fs r272194 : #i102139# for newly created DB docs, set the MacroExecutionMode to USE_CONFIG 2009-05-22 12:03:42 +0200 fs r272180 : #i88878# provided by noel.power@novell.com implement a visibility property (EnableVisible) for toolkit controls, and usage in forms and UNO dialogs 2009-05-15 15:37:31 +0200 fs r271942 : #i100671# corrected some @since tags, so autodoc has better chances of correctly reading them 2009-05-15 15:33:11 +0200 fs r271940 : don't call comphelper::getFOO for VOID values 2009-05-15 15:08:31 +0200 fs r271937 : includes 2009-05-15 13:39:22 +0200 fs r271934 : #i101398# createPrimitive2DSequence: when we already have a control, use the old code. In particular, call positionControlForPaint 2009-05-15 12:33:48 +0200 fs r271933 : make the geometry a part of the ControlPrimitive2D's identity 2009-05-15 10:15:44 +0200 fs r271928 : #i10000# 2009-05-14 20:55:38 +0200 fs r271921 : #i101398# don't reuse the name PRIMITIVE_ID_CONTROLPRIMITIVE2D, make the name of our own ControlPrimitive2D unique 2009-05-14 20:55:31 +0200 fs r271920 : #i101398# don't reuse the name PRIMITIVE_ID_CONTROLPRIMITIVE2D, make the name of our own ControlPrimitive2D unique 2009-05-14 20:23:23 +0200 fs r271919 : #i101622# 2009-05-14 16:04:38 +0200 fs r271898 : don't use comphelper::getInt32 on voids 2009-05-14 16:04:12 +0200 fs r271897 : merge fix for issue whose number just slipped my memory ... (originally fixed in CWS dba32b) 2009-05-14 15:36:55 +0200 fs r271895 : merging changes from DEV300:m48 2009-05-07 14:43:19 +0200 fs r271670 : #i101477# 2009-05-07 14:37:30 +0200 fs r271668 : #i101477# 2009-05-07 09:27:30 +0200 oj r271628 : #i101343# remove pch 2009-05-06 09:36:02 +0200 fs r271568 : getFoo: diagnostics 2009-05-04 09:23:06 +0200 oj r271438 : CWS-TOOLING: rebase CWS dba32c to trunk@271427 (milestone: DEV300:m47) 2009-04-29 23:18:13 +0200 fs r271394 : #i101398# use a dedicated 2DPrimitive for UNO Controls, which is able to provide the B2DRange *without* actually creating the control 2009-04-29 13:52:25 +0200 fs r271366 : #i101308#
2796 lines
98 KiB
C++
2796 lines
98 KiB
C++
/*************************************************************************
|
|
*
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* Copyright 2008 by Sun Microsystems, Inc.
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* $RCSfile: vclxwindow.cxx,v $
|
|
* $Revision: 1.90 $
|
|
*
|
|
* This file is part of OpenOffice.org.
|
|
*
|
|
* OpenOffice.org is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License version 3
|
|
* only, as published by the Free Software Foundation.
|
|
*
|
|
* OpenOffice.org is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License version 3 for more details
|
|
* (a copy is included in the LICENSE file that accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* version 3 along with OpenOffice.org. If not, see
|
|
* <http://www.openoffice.org/license.html>
|
|
* for a copy of the LGPLv3 License.
|
|
*
|
|
************************************************************************/
|
|
|
|
// MARKER(update_precomp.py): autogen include statement, do not remove
|
|
#include "precompiled_toolkit.hxx"
|
|
#include <com/sun/star/awt/WindowEvent.hpp>
|
|
#include <com/sun/star/awt/KeyEvent.hpp>
|
|
#include <com/sun/star/awt/KeyModifier.hpp>
|
|
#include <com/sun/star/awt/MouseEvent.hpp>
|
|
#include <com/sun/star/awt/MouseButton.hpp>
|
|
#include <com/sun/star/awt/MouseWheelBehavior.hpp>
|
|
#include <com/sun/star/awt/XTopWindow.hpp>
|
|
#include <com/sun/star/awt/Style.hpp>
|
|
#include <com/sun/star/accessibility/AccessibleRole.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/text/WritingMode2.hpp>
|
|
#include <toolkit/awt/vclxwindow.hxx>
|
|
#include <toolkit/awt/vclxpointer.hxx>
|
|
#include <toolkit/awt/vclxwindows.hxx>
|
|
#include <toolkit/helper/macros.hxx>
|
|
#include <toolkit/helper/vclunohelper.hxx>
|
|
#include <toolkit/helper/convert.hxx>
|
|
#include <toolkit/helper/macros.hxx>
|
|
#include <toolkit/helper/property.hxx>
|
|
#include <toolkit/helper/accessibilityclient.hxx>
|
|
#include <cppuhelper/typeprovider.hxx>
|
|
#include <rtl/memory.h>
|
|
#include <rtl/uuid.h>
|
|
#include <rtl/ustrbuf.hxx>
|
|
#include <vcl/svapp.hxx>
|
|
#include <vcl/window.hxx>
|
|
#include <tools/color.hxx>
|
|
#include <vcl/dockwin.hxx>
|
|
#include <vcl/pdfextoutdevdata.hxx>
|
|
#include <vcl/tabpage.hxx>
|
|
#include <comphelper/asyncnotification.hxx>
|
|
#include <toolkit/helper/solarrelease.hxx>
|
|
|
|
#include <toolkit/helper/unopropertyarrayhelper.hxx>
|
|
|
|
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::style::VerticalAlignment;
|
|
using ::com::sun::star::style::VerticalAlignment_TOP;
|
|
using ::com::sun::star::style::VerticalAlignment_MIDDLE;
|
|
using ::com::sun::star::style::VerticalAlignment_BOTTOM;
|
|
using ::com::sun::star::style::VerticalAlignment_MAKE_FIXED_SIZE;
|
|
|
|
namespace WritingMode2 = ::com::sun::star::text::WritingMode2;
|
|
namespace MouseWheelBehavior = ::com::sun::star::awt::MouseWheelBehavior;
|
|
|
|
|
|
//====================================================================
|
|
//= misc helpers
|
|
//====================================================================
|
|
namespace
|
|
{
|
|
//................................................................
|
|
//. FlagGuard
|
|
//................................................................
|
|
class FlagGuard
|
|
{
|
|
private:
|
|
bool& m_rFlag;
|
|
|
|
public:
|
|
FlagGuard( bool& _rFlag )
|
|
:m_rFlag( _rFlag )
|
|
{
|
|
m_rFlag = true;
|
|
}
|
|
~FlagGuard()
|
|
{
|
|
m_rFlag = false;
|
|
}
|
|
};
|
|
|
|
//................................................................
|
|
//. MouseEventType
|
|
//................................................................
|
|
enum MouseEventType
|
|
{
|
|
META_FIRST_MOUSE_EVENT = 0,
|
|
|
|
EVENT_MOUSE_PRESSED = 0,
|
|
EVENT_MOUSE_RELEASED = 1,
|
|
EVENT_MOUSE_ENTERED = 2,
|
|
EVENT_MOUSE_EXITED = 3,
|
|
|
|
META_LAST_MOUSE_EVENT = 3
|
|
};
|
|
|
|
//................................................................
|
|
//. PlainEventType
|
|
//................................................................
|
|
enum PlainEventType
|
|
{
|
|
META_FIRST_PLAIN_EVENT = 4,
|
|
|
|
EVENT_WINDOW_ENABLED = 4,
|
|
EVENT_WINDOW_DISABLED = 5,
|
|
|
|
META_LAST_PLAIN_EVENT = 5
|
|
};
|
|
|
|
#if OSL_DEBUG_LEVEL > 0
|
|
static void checkEventDefinitions()
|
|
{
|
|
OSL_ENSURE( (int)META_LAST_MOUSE_EVENT < (int)META_FIRST_PLAIN_EVENT, "checkEventDefinitions: invalid event definitions!" );
|
|
}
|
|
#define DBG_CHECK_EVENTS() checkEventDefinitions()
|
|
#else
|
|
#define DBG_CHECK_EVENTS()
|
|
#endif
|
|
|
|
//................................................................
|
|
//. AnyWindowEvent
|
|
//................................................................
|
|
struct AnyWindowEvent : public ::comphelper::AnyEvent
|
|
{
|
|
private:
|
|
awt::MouseEvent m_aMouseEvent;
|
|
lang::EventObject m_aPlainEvent;
|
|
|
|
sal_Int32 m_nEventType;
|
|
|
|
public:
|
|
AnyWindowEvent( const awt::MouseEvent& _rEvent, MouseEventType _nType )
|
|
:comphelper::AnyEvent()
|
|
,m_aMouseEvent( _rEvent )
|
|
,m_nEventType( static_cast< sal_Int32 >( _nType ) )
|
|
{
|
|
DBG_CHECK_EVENTS();
|
|
}
|
|
|
|
AnyWindowEvent( const lang::EventObject& _rEvent, PlainEventType _nType )
|
|
:comphelper::AnyEvent()
|
|
,m_aPlainEvent( _rEvent )
|
|
,m_nEventType( static_cast< sal_Int32 >( _nType ) )
|
|
{
|
|
DBG_CHECK_EVENTS();
|
|
}
|
|
|
|
bool isMouseEvent() const
|
|
{
|
|
return ( META_FIRST_MOUSE_EVENT <= m_nEventType ) && ( m_nEventType <= META_LAST_MOUSE_EVENT );
|
|
}
|
|
|
|
bool isPlainEvent() const
|
|
{
|
|
return ( META_FIRST_PLAIN_EVENT <= m_nEventType ) && ( m_nEventType <= META_LAST_PLAIN_EVENT );
|
|
}
|
|
|
|
const awt::MouseEvent& getMouseEvent() const
|
|
{
|
|
OSL_ENSURE( isMouseEvent(), "AnyWindowEvent::getMouseEvent: no mouse event!" );
|
|
return m_aMouseEvent;
|
|
}
|
|
|
|
MouseEventType getMouseEventType() const
|
|
{
|
|
OSL_ENSURE( isMouseEvent(), "AnyWindowEvent::getMouseEventType: no mouse event!" );
|
|
return static_cast< MouseEventType >( m_nEventType );
|
|
}
|
|
|
|
const lang::EventObject& getPlainEvent() const
|
|
{
|
|
OSL_ENSURE( isPlainEvent(), "AnyWindowEvent::getPlainEvent: no plain event!" );
|
|
return m_aPlainEvent;
|
|
}
|
|
|
|
PlainEventType getPlainEventType() const
|
|
{
|
|
OSL_ENSURE( isPlainEvent(), "AnyWindowEvent::getPlainEventType: no mouse event!" );
|
|
return static_cast< PlainEventType >( m_nEventType );
|
|
}
|
|
};
|
|
}
|
|
|
|
//====================================================================
|
|
//= VCLXWindowImpl
|
|
//====================================================================
|
|
class SAL_DLLPRIVATE VCLXWindowImpl : public ::comphelper::IEventProcessor
|
|
{
|
|
private:
|
|
typedef ::std::vector< ::rtl::Reference< ::comphelper::AnyEvent > >
|
|
EventArray;
|
|
|
|
private:
|
|
VCLXWindow& mrAntiImpl;
|
|
::vos::IMutex& mrMutex;
|
|
::toolkit::AccessibilityClient maAccFactory;
|
|
bool mbDisposed;
|
|
bool mbDrawingOntoParent; // no bit mask, is passed around by reference
|
|
sal_Bool mbEnableVisible;
|
|
sal_Bool mbDirectVisible;
|
|
|
|
::osl::Mutex maListenerContainerMutex;
|
|
::cppu::OInterfaceContainerHelper maWindow2Listeners;
|
|
::cppu::OInterfaceContainerHelper maDockableWindowListeners;
|
|
EventListenerMultiplexer maEventListeners;
|
|
FocusListenerMultiplexer maFocusListeners;
|
|
WindowListenerMultiplexer maWindowListeners;
|
|
KeyListenerMultiplexer maKeyListeners;
|
|
MouseListenerMultiplexer maMouseListeners;
|
|
MouseMotionListenerMultiplexer maMouseMotionListeners;
|
|
PaintListenerMultiplexer maPaintListeners;
|
|
VclContainerListenerMultiplexer maContainerListeners;
|
|
TopWindowListenerMultiplexer maTopWindowListeners;
|
|
|
|
EventArray maEvents;
|
|
ULONG mnEventId;
|
|
|
|
public:
|
|
bool mbDisposing : 1;
|
|
bool mbDesignMode : 1;
|
|
bool mbSynthesizingVCLEvent : 1;
|
|
bool mbWithDefaultProps : 1;
|
|
|
|
ULONG mnListenerLockLevel;
|
|
sal_Int16 mnWritingMode;
|
|
sal_Int16 mnContextWritingMode;
|
|
|
|
UnoPropertyArrayHelper* mpPropHelper;
|
|
|
|
::com::sun::star::uno::Reference< ::com::sun::star::awt::XPointer >
|
|
mxPointer;
|
|
::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext >
|
|
mxAccessibleContext;
|
|
::com::sun::star::uno::Reference< ::com::sun::star::awt::XGraphics >
|
|
mxViewGraphics;
|
|
|
|
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, ::vos::IMutex& _rMutex, bool _bWithDefaultProps );
|
|
|
|
/** synchronously mbEnableVisible
|
|
*/
|
|
void setEnableVisible( sal_Bool bEnableVisible ) { mbEnableVisible = bEnableVisible; }
|
|
sal_Bool isEnableVisible() { return mbEnableVisible; }
|
|
/** synchronously mbDirectVisible;
|
|
*/
|
|
void setDirectVisible( sal_Bool bDirectVisible ) { mbDirectVisible = bDirectVisible; }
|
|
sal_Bool isDirectVisible() { return mbDirectVisible; }
|
|
|
|
/** asynchronously notifies a mouse event to the VCLXWindow's XMouseListeners
|
|
*/
|
|
void notifyMouseEvent( const awt::MouseEvent& _rMouseEvent, MouseEventType _nType );
|
|
|
|
/** asynchronously notifies an event described by an EventObject to the respective listeners
|
|
*/
|
|
void notifyPlainEvent( const lang::EventObject& _rPlainEvent, PlainEventType _nType );
|
|
|
|
/** notifies the object that its VCLXWindow is being disposed
|
|
*/
|
|
void disposing();
|
|
|
|
inline ::toolkit::AccessibilityClient& getAccessibleFactory()
|
|
{
|
|
return maAccFactory;
|
|
}
|
|
|
|
/** returns the container of registered XWindowListener2 listeners
|
|
*/
|
|
inline ::cppu::OInterfaceContainerHelper& getWindow2Listeners() { return maWindow2Listeners; }
|
|
inline ::cppu::OInterfaceContainerHelper& getDockableWindowListeners(){ return maDockableWindowListeners; }
|
|
inline EventListenerMultiplexer& getEventListeners() { return maEventListeners; }
|
|
inline FocusListenerMultiplexer& getFocusListeners() { return maFocusListeners; }
|
|
inline WindowListenerMultiplexer& getWindowListeners() { return maWindowListeners; }
|
|
inline KeyListenerMultiplexer& getKeyListeners() { return maKeyListeners; }
|
|
inline MouseListenerMultiplexer& getMouseListeners() { return maMouseListeners; }
|
|
inline MouseMotionListenerMultiplexer& getMouseMotionListeners() { return maMouseMotionListeners; }
|
|
inline PaintListenerMultiplexer& getPaintListeners() { return maPaintListeners; }
|
|
inline VclContainerListenerMultiplexer& getContainerListeners() { return maContainerListeners; }
|
|
inline TopWindowListenerMultiplexer& getTopWindowListeners() { return maTopWindowListeners; }
|
|
|
|
virtual ~VCLXWindowImpl();
|
|
|
|
protected:
|
|
virtual void SAL_CALL acquire();
|
|
virtual void SAL_CALL release();
|
|
|
|
// IEventProcessor
|
|
virtual void processEvent( const ::comphelper::AnyEvent& _rEvent );
|
|
|
|
private:
|
|
DECL_LINK( OnProcessEvent, void* );
|
|
|
|
private:
|
|
/** notifies an arbitrary event
|
|
@param _rEvent
|
|
the event to notify
|
|
*/
|
|
void impl_notifyAnyEvent(
|
|
const ::rtl::Reference< ::comphelper::AnyEvent >& _rEvent
|
|
);
|
|
|
|
private:
|
|
/** determines whether the instance is already disposed
|
|
@precond
|
|
m_aMutex must be acquired
|
|
*/
|
|
inline bool impl_isDisposed()
|
|
{
|
|
return mbDisposed;
|
|
}
|
|
|
|
private:
|
|
VCLXWindowImpl(); // never implemented
|
|
VCLXWindowImpl( const VCLXWindowImpl& ); // never implemented
|
|
VCLXWindowImpl& operator=( const VCLXWindowImpl& ); // never implemented
|
|
};
|
|
|
|
//--------------------------------------------------------------------
|
|
VCLXWindowImpl::VCLXWindowImpl( VCLXWindow& _rAntiImpl, ::vos::IMutex& _rMutex, bool _bWithDefaultProps )
|
|
:mrAntiImpl( _rAntiImpl )
|
|
,mrMutex( _rMutex )
|
|
,mbDisposed( false )
|
|
,mbDrawingOntoParent( false )
|
|
,mbEnableVisible(sal_True)
|
|
,mbDirectVisible(sal_True)
|
|
,maListenerContainerMutex( )
|
|
,maWindow2Listeners( maListenerContainerMutex )
|
|
,maDockableWindowListeners( maListenerContainerMutex )
|
|
,maEventListeners( _rAntiImpl )
|
|
,maFocusListeners( _rAntiImpl )
|
|
,maWindowListeners( _rAntiImpl )
|
|
,maKeyListeners( _rAntiImpl )
|
|
,maMouseListeners( _rAntiImpl )
|
|
,maMouseMotionListeners( _rAntiImpl )
|
|
,maPaintListeners( _rAntiImpl )
|
|
,maContainerListeners( _rAntiImpl )
|
|
,maTopWindowListeners( _rAntiImpl )
|
|
,mnEventId( 0 )
|
|
,mbDisposing( false )
|
|
,mbDesignMode( false )
|
|
,mbSynthesizingVCLEvent( false )
|
|
,mbWithDefaultProps( _bWithDefaultProps )
|
|
,mnListenerLockLevel( 0 )
|
|
,mnWritingMode( WritingMode2::CONTEXT )
|
|
,mnContextWritingMode( WritingMode2::CONTEXT )
|
|
,mpPropHelper( NULL )
|
|
{
|
|
}
|
|
|
|
VCLXWindowImpl::~VCLXWindowImpl()
|
|
{
|
|
delete mpPropHelper;
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
void VCLXWindowImpl::disposing()
|
|
{
|
|
::vos::OGuard aGuard( mrMutex );
|
|
if ( mnEventId )
|
|
Application::RemoveUserEvent( mnEventId );
|
|
mnEventId = 0;
|
|
mbDisposed= true;
|
|
|
|
::com::sun::star::lang::EventObject aEvent;
|
|
aEvent.Source = mrAntiImpl;
|
|
|
|
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 );
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
void VCLXWindowImpl::impl_notifyAnyEvent( const ::rtl::Reference< ::comphelper::AnyEvent >& _rEvent )
|
|
{
|
|
maEvents.push_back( _rEvent );
|
|
if ( !mnEventId )
|
|
mnEventId = Application::PostUserEvent( LINK( this, VCLXWindowImpl, OnProcessEvent ) );
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
void VCLXWindowImpl::notifyMouseEvent( const awt::MouseEvent& _rMouseEvent, MouseEventType _nType )
|
|
{
|
|
::vos::OClearableGuard aGuard( mrMutex );
|
|
if ( maMouseListeners.getLength() )
|
|
impl_notifyAnyEvent( new AnyWindowEvent( _rMouseEvent, _nType ) );
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
void VCLXWindowImpl::notifyPlainEvent( const lang::EventObject& _rPlainEvent, PlainEventType _nType )
|
|
{
|
|
::vos::OClearableGuard aGuard( mrMutex );
|
|
if ( maWindow2Listeners.getLength() )
|
|
impl_notifyAnyEvent( new AnyWindowEvent( _rPlainEvent, _nType ) );
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
IMPL_LINK( VCLXWindowImpl, OnProcessEvent, void*, EMPTYARG )
|
|
{
|
|
// work on a copy of the events array
|
|
EventArray aEventsCopy;
|
|
{
|
|
::vos::OGuard aGuard( mrMutex );
|
|
aEventsCopy = maEvents;
|
|
maEvents.clear();
|
|
|
|
if ( !mnEventId )
|
|
// we were disposed while waiting for the mutex to lock
|
|
return 1L;
|
|
|
|
mnEventId = 0;
|
|
}
|
|
|
|
{
|
|
::toolkit::ReleaseSolarMutex aReleaseSolar;
|
|
for ( EventArray::const_iterator loop = aEventsCopy.begin();
|
|
loop != aEventsCopy.end();
|
|
++loop
|
|
)
|
|
{
|
|
processEvent( *(*loop) );
|
|
}
|
|
}
|
|
|
|
return 0L;
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
void VCLXWindowImpl::processEvent( const ::comphelper::AnyEvent& _rEvent )
|
|
{
|
|
::vos::OGuard aGuard( mrMutex );
|
|
if ( impl_isDisposed() )
|
|
// while we were waiting for our mutex, another thread disposed us
|
|
return;
|
|
|
|
const AnyWindowEvent& rEventDescriptor( static_cast< const AnyWindowEvent& >( _rEvent ) );
|
|
if ( rEventDescriptor.isMouseEvent() )
|
|
{
|
|
const awt::MouseEvent& rEvent( rEventDescriptor.getMouseEvent() );
|
|
switch ( rEventDescriptor.getMouseEventType() )
|
|
{
|
|
case EVENT_MOUSE_PRESSED:
|
|
maMouseListeners.mousePressed( rEvent );
|
|
break;
|
|
case EVENT_MOUSE_RELEASED:
|
|
maMouseListeners.mouseReleased( rEvent );
|
|
break;
|
|
case EVENT_MOUSE_ENTERED:
|
|
maMouseListeners.mouseEntered( rEvent );
|
|
break;
|
|
case EVENT_MOUSE_EXITED:
|
|
maMouseListeners.mouseExited( rEvent );
|
|
break;
|
|
default:
|
|
DBG_ERROR( "VCLXWindowImpl::processEvent: what kind of event *is* this (1)?" );
|
|
break;
|
|
}
|
|
}
|
|
else if ( rEventDescriptor.isPlainEvent() )
|
|
{
|
|
const lang::EventObject& rEvent( rEventDescriptor.getPlainEvent() );
|
|
switch ( rEventDescriptor.getPlainEventType() )
|
|
{
|
|
case EVENT_WINDOW_ENABLED:
|
|
maWindow2Listeners.notifyEach( &XWindowListener2::windowEnabled, rEvent );
|
|
break;
|
|
case EVENT_WINDOW_DISABLED:
|
|
maWindow2Listeners.notifyEach( &XWindowListener2::windowDisabled, rEvent );
|
|
break;
|
|
default:
|
|
DBG_ERROR( "VCLXWindowImpl::processEvent: what kind of event *is* this (2)?" );
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DBG_ERROR( "VCLXWindowImpl::processEvent: what kind of event *is* this (3)?" );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
void SAL_CALL VCLXWindowImpl::acquire()
|
|
{
|
|
mrAntiImpl.acquire();
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
void SAL_CALL VCLXWindowImpl::release()
|
|
{
|
|
mrAntiImpl.release();
|
|
}
|
|
|
|
//====================================================================
|
|
//====================================================================
|
|
|
|
// Mit Out-Parameter besser als Rueckgabewert, wegen Ref-Objekt...
|
|
|
|
void ImplInitWindowEvent( ::com::sun::star::awt::WindowEvent& rEvent, Window* 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 );
|
|
}
|
|
|
|
void ImplInitKeyEvent( ::com::sun::star::awt::KeyEvent& rEvent, const KeyEvent& rEvt )
|
|
{
|
|
rEvent.Modifiers = 0;
|
|
if ( rEvt.GetKeyCode().IsShift() )
|
|
rEvent.Modifiers |= ::com::sun::star::awt::KeyModifier::SHIFT;
|
|
if ( rEvt.GetKeyCode().IsMod1() )
|
|
rEvent.Modifiers |= ::com::sun::star::awt::KeyModifier::MOD1;
|
|
if ( rEvt.GetKeyCode().IsMod2() )
|
|
rEvent.Modifiers |= ::com::sun::star::awt::KeyModifier::MOD2;
|
|
if ( rEvt.GetKeyCode().IsMod3() )
|
|
rEvent.Modifiers |= ::com::sun::star::awt::KeyModifier::MOD3;
|
|
|
|
rEvent.KeyCode = rEvt.GetKeyCode().GetCode();
|
|
rEvent.KeyChar = rEvt.GetCharCode();
|
|
rEvent.KeyFunc = sal::static_int_cast< sal_Int16 >(
|
|
rEvt.GetKeyCode().GetFunction());
|
|
}
|
|
|
|
void ImplInitMouseEvent( awt::MouseEvent& rEvent, const MouseEvent& rEvt )
|
|
{
|
|
rEvent.Modifiers = 0;
|
|
if ( rEvt.IsShift() )
|
|
rEvent.Modifiers |= ::com::sun::star::awt::KeyModifier::SHIFT;
|
|
if ( rEvt.IsMod1() )
|
|
rEvent.Modifiers |= ::com::sun::star::awt::KeyModifier::MOD1;
|
|
if ( rEvt.IsMod2() )
|
|
rEvent.Modifiers |= ::com::sun::star::awt::KeyModifier::MOD2;
|
|
|
|
rEvent.Buttons = 0;
|
|
if ( rEvt.IsLeft() )
|
|
rEvent.Buttons |= ::com::sun::star::awt::MouseButton::LEFT;
|
|
if ( rEvt.IsRight() )
|
|
rEvent.Buttons |= ::com::sun::star::awt::MouseButton::RIGHT;
|
|
if ( rEvt.IsMiddle() )
|
|
rEvent.Buttons |= ::com::sun::star::awt::MouseButton::MIDDLE;
|
|
|
|
rEvent.X = rEvt.GetPosPixel().X();
|
|
rEvent.Y = rEvt.GetPosPixel().Y();
|
|
rEvent.ClickCount = rEvt.GetClicks();
|
|
rEvent.PopupTrigger = sal_False;
|
|
}
|
|
|
|
// ----------------------------------------------------
|
|
// class VCLXWindow
|
|
// ----------------------------------------------------
|
|
|
|
DBG_NAME(VCLXWindow);
|
|
|
|
VCLXWindow::VCLXWindow( bool _bWithDefaultProps )
|
|
:mpImpl( NULL )
|
|
{
|
|
DBG_CTOR( VCLXWindow, 0 );
|
|
|
|
mpImpl = new VCLXWindowImpl( *this, GetMutex(), _bWithDefaultProps );
|
|
}
|
|
|
|
VCLXWindow::~VCLXWindow()
|
|
{
|
|
DBG_DTOR( VCLXWindow, 0 );
|
|
|
|
delete mpImpl;
|
|
|
|
if ( GetWindow() )
|
|
{
|
|
GetWindow()->RemoveEventListener( LINK( this, VCLXWindow, WindowEventListener ) );
|
|
GetWindow()->SetWindowPeer( NULL, NULL );
|
|
GetWindow()->SetAccessible( NULL );
|
|
}
|
|
}
|
|
|
|
::toolkit::IAccessibleFactory& VCLXWindow::getAccessibleFactory()
|
|
{
|
|
return mpImpl->getAccessibleFactory().getFactory();
|
|
}
|
|
|
|
void VCLXWindow::SetWindow( Window* pWindow )
|
|
{
|
|
if ( GetWindow() )
|
|
{
|
|
GetWindow()->RemoveEventListener( LINK( this, VCLXWindow, WindowEventListener ) );
|
|
// GetWindow()->DbgAssertNoEventListeners();
|
|
}
|
|
|
|
SetOutputDevice( pWindow );
|
|
|
|
if ( GetWindow() )
|
|
{
|
|
GetWindow()->AddEventListener( LINK( this, VCLXWindow, WindowEventListener ) );
|
|
sal_Bool bDirectVisible = pWindow ? pWindow->IsVisible() : false;
|
|
mpImpl->setDirectVisible( bDirectVisible );
|
|
}
|
|
|
|
}
|
|
|
|
void VCLXWindow::suspendVclEventListening( )
|
|
{
|
|
++mpImpl->mnListenerLockLevel;
|
|
}
|
|
|
|
void VCLXWindow::resumeVclEventListening( )
|
|
{
|
|
DBG_ASSERT( mpImpl->mnListenerLockLevel, "VCLXWindow::resumeVclEventListening: not suspended!" );
|
|
--mpImpl->mnListenerLockLevel;
|
|
}
|
|
|
|
void VCLXWindow::notifyWindowRemoved( Window& _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, VclSimpleEvent*, pEvent )
|
|
{
|
|
if ( mpImpl->mnListenerLockLevel )
|
|
return 0L;
|
|
|
|
DBG_ASSERT( pEvent && pEvent->ISA( VclWindowEvent ), "Unknown WindowEvent!" );
|
|
if ( pEvent && pEvent->ISA( VclWindowEvent ) )
|
|
{
|
|
DBG_ASSERT( ((VclWindowEvent*)pEvent)->GetWindow() && GetWindow(), "Window???" );
|
|
ProcessWindowEvent( *(VclWindowEvent*)pEvent );
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void VCLXWindow::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
|
|
{
|
|
::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xThis( (::cppu::OWeakObject*)this );
|
|
|
|
switch ( rVclWindowEvent.GetId() )
|
|
{
|
|
case VCLEVENT_WINDOW_ENABLED:
|
|
case VCLEVENT_WINDOW_DISABLED:
|
|
{
|
|
bool bEnabled = ( VCLEVENT_WINDOW_ENABLED == rVclWindowEvent.GetId() );
|
|
EventObject aEvent( *this );
|
|
mpImpl->notifyPlainEvent( aEvent,
|
|
bEnabled ? EVENT_WINDOW_ENABLED : EVENT_WINDOW_DISABLED );
|
|
}
|
|
break;
|
|
|
|
case VCLEVENT_WINDOW_PAINT:
|
|
{
|
|
if ( mpImpl->getPaintListeners().getLength() )
|
|
{
|
|
::com::sun::star::awt::PaintEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
aEvent.UpdateRect = AWTRectangle( *(Rectangle*)rVclWindowEvent.GetData() );
|
|
aEvent.Count = 0;
|
|
mpImpl->getPaintListeners().windowPaint( aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_MOVE:
|
|
{
|
|
if ( mpImpl->getWindowListeners().getLength() )
|
|
{
|
|
::com::sun::star::awt::WindowEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() );
|
|
mpImpl->getWindowListeners().windowMoved( aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_RESIZE:
|
|
{
|
|
if ( mpImpl->getWindowListeners().getLength() )
|
|
{
|
|
::com::sun::star::awt::WindowEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() );
|
|
mpImpl->getWindowListeners().windowResized( aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_SHOW:
|
|
{
|
|
if ( mpImpl->getWindowListeners().getLength() )
|
|
{
|
|
::com::sun::star::awt::WindowEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() );
|
|
mpImpl->getWindowListeners().windowShown( aEvent );
|
|
}
|
|
|
|
// For TopWindows this means opened...
|
|
if ( mpImpl->getTopWindowListeners().getLength() )
|
|
{
|
|
::com::sun::star::lang::EventObject aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
mpImpl->getTopWindowListeners().windowOpened( aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_HIDE:
|
|
{
|
|
if ( mpImpl->getWindowListeners().getLength() )
|
|
{
|
|
::com::sun::star::awt::WindowEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() );
|
|
mpImpl->getWindowListeners().windowHidden( aEvent );
|
|
}
|
|
|
|
// For TopWindows this means closed...
|
|
if ( mpImpl->getTopWindowListeners().getLength() )
|
|
{
|
|
::com::sun::star::lang::EventObject aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
mpImpl->getTopWindowListeners().windowClosed( aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_ACTIVATE:
|
|
{
|
|
if ( mpImpl->getTopWindowListeners().getLength() )
|
|
{
|
|
::com::sun::star::lang::EventObject aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
mpImpl->getTopWindowListeners().windowActivated( aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_DEACTIVATE:
|
|
{
|
|
if ( mpImpl->getTopWindowListeners().getLength() )
|
|
{
|
|
::com::sun::star::lang::EventObject aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
mpImpl->getTopWindowListeners().windowDeactivated( aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_CLOSE:
|
|
{
|
|
if ( mpImpl->getDockableWindowListeners().getLength() )
|
|
{
|
|
::com::sun::star::lang::EventObject aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::closed, aEvent );
|
|
}
|
|
if ( mpImpl->getTopWindowListeners().getLength() )
|
|
{
|
|
::com::sun::star::lang::EventObject aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
mpImpl->getTopWindowListeners().windowClosing( aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_CONTROL_GETFOCUS:
|
|
case VCLEVENT_WINDOW_GETFOCUS:
|
|
{
|
|
if ( ( rVclWindowEvent.GetWindow()->IsCompoundControl()
|
|
&& rVclWindowEvent.GetId() == VCLEVENT_CONTROL_GETFOCUS
|
|
)
|
|
|| ( !rVclWindowEvent.GetWindow()->IsCompoundControl()
|
|
&& rVclWindowEvent.GetId() == VCLEVENT_WINDOW_GETFOCUS
|
|
)
|
|
)
|
|
{
|
|
if ( mpImpl->getFocusListeners().getLength() )
|
|
{
|
|
::com::sun::star::awt::FocusEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
aEvent.FocusFlags = rVclWindowEvent.GetWindow()->GetGetFocusFlags();
|
|
aEvent.Temporary = sal_False;
|
|
mpImpl->getFocusListeners().focusGained( aEvent );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_CONTROL_LOSEFOCUS:
|
|
case VCLEVENT_WINDOW_LOSEFOCUS:
|
|
{
|
|
if ( ( rVclWindowEvent.GetWindow()->IsCompoundControl()
|
|
&& rVclWindowEvent.GetId() == VCLEVENT_CONTROL_LOSEFOCUS
|
|
)
|
|
|| ( !rVclWindowEvent.GetWindow()->IsCompoundControl()
|
|
&& rVclWindowEvent.GetId() == VCLEVENT_WINDOW_LOSEFOCUS
|
|
)
|
|
)
|
|
{
|
|
if ( mpImpl->getFocusListeners().getLength() )
|
|
{
|
|
::com::sun::star::awt::FocusEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
aEvent.FocusFlags = rVclWindowEvent.GetWindow()->GetGetFocusFlags();
|
|
aEvent.Temporary = sal_False;
|
|
|
|
Window* pNext = Application::GetFocusWindow();
|
|
if ( pNext )
|
|
{
|
|
// Bei zusammengesetzten Controls interessiert sich keiner fuer das Innenleben:
|
|
Window* pNextC = pNext;
|
|
while ( pNextC && !pNextC->IsCompoundControl() )
|
|
pNextC = pNextC->GetParent();
|
|
if ( pNextC )
|
|
pNext = pNextC;
|
|
|
|
pNext->GetComponentInterface( sal_True );
|
|
aEvent.NextFocus = (::cppu::OWeakObject*)pNext->GetWindowPeer();
|
|
}
|
|
mpImpl->getFocusListeners().focusLost( aEvent );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_MINIMIZE:
|
|
{
|
|
if ( mpImpl->getTopWindowListeners().getLength() )
|
|
{
|
|
::com::sun::star::lang::EventObject aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
mpImpl->getTopWindowListeners().windowMinimized( aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_NORMALIZE:
|
|
{
|
|
if ( mpImpl->getTopWindowListeners().getLength() )
|
|
{
|
|
::com::sun::star::lang::EventObject aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
mpImpl->getTopWindowListeners().windowNormalized( aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_KEYINPUT:
|
|
{
|
|
if ( mpImpl->getKeyListeners().getLength() )
|
|
{
|
|
::com::sun::star::awt::KeyEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
ImplInitKeyEvent( aEvent, *(KeyEvent*)rVclWindowEvent.GetData() );
|
|
mpImpl->getKeyListeners().keyPressed( aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_KEYUP:
|
|
{
|
|
if ( mpImpl->getKeyListeners().getLength() )
|
|
{
|
|
::com::sun::star::awt::KeyEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
ImplInitKeyEvent( aEvent, *(KeyEvent*)rVclWindowEvent.GetData() );
|
|
mpImpl->getKeyListeners().keyReleased( aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_COMMAND:
|
|
{
|
|
CommandEvent* pCmdEvt = (CommandEvent*)rVclWindowEvent.GetData();
|
|
if ( mpImpl->getMouseListeners().getLength() && ( pCmdEvt->GetCommand() == COMMAND_CONTEXTMENU ) )
|
|
{
|
|
// COMMAND_CONTEXTMENU als mousePressed mit PopupTrigger = sal_True versenden...
|
|
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
|
|
// 102205 - 16.08.2002 - fs@openoffice.org
|
|
aWhere = Point( -1, -1 );
|
|
}
|
|
|
|
MouseEvent aMEvt( aWhere, 1, MOUSE_SIMPLECLICK, MOUSE_LEFT, 0 );
|
|
awt::MouseEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
ImplInitMouseEvent( aEvent, aMEvt );
|
|
aEvent.PopupTrigger = sal_True;
|
|
mpImpl->notifyMouseEvent( aEvent, EVENT_MOUSE_PRESSED );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_MOUSEMOVE:
|
|
{
|
|
MouseEvent* pMouseEvt = (MouseEvent*)rVclWindowEvent.GetData();
|
|
if ( mpImpl->getMouseListeners().getLength() && ( pMouseEvt->IsEnterWindow() || pMouseEvt->IsLeaveWindow() ) )
|
|
{
|
|
awt::MouseEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
ImplInitMouseEvent( aEvent, *pMouseEvt );
|
|
|
|
mpImpl->notifyMouseEvent(
|
|
aEvent,
|
|
pMouseEvt->IsEnterWindow() ? EVENT_MOUSE_ENTERED : EVENT_MOUSE_EXITED
|
|
);
|
|
}
|
|
|
|
if ( mpImpl->getMouseMotionListeners().getLength() && !pMouseEvt->IsEnterWindow() && !pMouseEvt->IsLeaveWindow() )
|
|
{
|
|
awt::MouseEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
ImplInitMouseEvent( aEvent, *pMouseEvt );
|
|
aEvent.ClickCount = 0; // #92138#
|
|
|
|
if ( pMouseEvt->GetMode() & MOUSE_SIMPLEMOVE )
|
|
mpImpl->getMouseMotionListeners().mouseMoved( aEvent );
|
|
else
|
|
mpImpl->getMouseMotionListeners().mouseDragged( aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_MOUSEBUTTONDOWN:
|
|
{
|
|
if ( mpImpl->getMouseListeners().getLength() )
|
|
{
|
|
awt::MouseEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
ImplInitMouseEvent( aEvent, *(MouseEvent*)rVclWindowEvent.GetData() );
|
|
mpImpl->notifyMouseEvent( aEvent, EVENT_MOUSE_PRESSED );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_MOUSEBUTTONUP:
|
|
{
|
|
if ( mpImpl->getMouseListeners().getLength() )
|
|
{
|
|
awt::MouseEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
ImplInitMouseEvent( aEvent, *(MouseEvent*)rVclWindowEvent.GetData() );
|
|
mpImpl->notifyMouseEvent( aEvent, EVENT_MOUSE_RELEASED );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_STARTDOCKING:
|
|
{
|
|
if ( mpImpl->getDockableWindowListeners().getLength() )
|
|
{
|
|
DockingData *pData = (DockingData*)rVclWindowEvent.GetData();
|
|
|
|
if( pData )
|
|
{
|
|
::com::sun::star::awt::DockingEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
aEvent.TrackingRectangle = AWTRectangle( pData->maTrackRect );
|
|
aEvent.MousePos.X = pData->maMousePos.X();
|
|
aEvent.MousePos.Y = pData->maMousePos.Y();
|
|
aEvent.bLiveMode = pData->mbLivemode;
|
|
aEvent.bInteractive = pData->mbInteractive;
|
|
|
|
mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::startDocking, aEvent );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_DOCKING:
|
|
{
|
|
if ( mpImpl->getDockableWindowListeners().getLength() )
|
|
{
|
|
DockingData *pData = (DockingData*)rVclWindowEvent.GetData();
|
|
|
|
if( pData )
|
|
{
|
|
::com::sun::star::awt::DockingEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
aEvent.TrackingRectangle = AWTRectangle( pData->maTrackRect );
|
|
aEvent.MousePos.X = pData->maMousePos.X();
|
|
aEvent.MousePos.Y = pData->maMousePos.Y();
|
|
aEvent.bLiveMode = pData->mbLivemode;
|
|
aEvent.bInteractive = pData->mbInteractive;
|
|
|
|
Reference< XDockableWindowListener > xFirstListener;
|
|
::cppu::OInterfaceIteratorHelper aIter( mpImpl->getDockableWindowListeners() );
|
|
while ( aIter.hasMoreElements() && !xFirstListener.is() )
|
|
{
|
|
xFirstListener.set( aIter.next(), UNO_QUERY );
|
|
}
|
|
|
|
::com::sun::star::awt::DockingData aDockingData =
|
|
xFirstListener->docking( aEvent );
|
|
pData->maTrackRect = VCLRectangle( aDockingData.TrackingRectangle );
|
|
pData->mbFloating = aDockingData.bFloating;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_ENDDOCKING:
|
|
{
|
|
if ( mpImpl->getDockableWindowListeners().getLength() )
|
|
{
|
|
EndDockingData *pData = (EndDockingData*)rVclWindowEvent.GetData();
|
|
|
|
if( pData )
|
|
{
|
|
::com::sun::star::awt::EndDockingEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
aEvent.WindowRectangle = AWTRectangle( pData->maWindowRect );
|
|
aEvent.bFloating = pData->mbFloating;
|
|
aEvent.bCancelled = pData->mbCancelled;
|
|
mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::endDocking, aEvent );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_PREPARETOGGLEFLOATING:
|
|
{
|
|
if ( mpImpl->getDockableWindowListeners().getLength() )
|
|
{
|
|
BOOL *p_bFloating = (BOOL*)rVclWindowEvent.GetData();
|
|
|
|
::com::sun::star::lang::EventObject aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
|
|
Reference< XDockableWindowListener > xFirstListener;
|
|
::cppu::OInterfaceIteratorHelper aIter( mpImpl->getDockableWindowListeners() );
|
|
while ( aIter.hasMoreElements() && !xFirstListener.is() )
|
|
{
|
|
xFirstListener.set( aIter.next(), UNO_QUERY );
|
|
}
|
|
|
|
*p_bFloating = xFirstListener->prepareToggleFloatingMode( aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_TOGGLEFLOATING:
|
|
{
|
|
if ( mpImpl->getDockableWindowListeners().getLength() )
|
|
{
|
|
::com::sun::star::lang::EventObject aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::toggleFloatingMode, aEvent );
|
|
}
|
|
}
|
|
break;
|
|
case VCLEVENT_WINDOW_ENDPOPUPMODE:
|
|
{
|
|
if ( mpImpl->getDockableWindowListeners().getLength() )
|
|
{
|
|
EndPopupModeData *pData = (EndPopupModeData*)rVclWindowEvent.GetData();
|
|
|
|
if( pData )
|
|
{
|
|
::com::sun::star::awt::EndPopupModeEvent aEvent;
|
|
aEvent.Source = (::cppu::OWeakObject*)this;
|
|
aEvent.FloatingPosition.X = pData->maFloatingPos.X();
|
|
aEvent.FloatingPosition.Y = pData->maFloatingPos.Y();
|
|
aEvent.bTearoff = pData->mbTearoff;
|
|
mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::endPopupMode, aEvent );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
uno::Reference< accessibility::XAccessibleContext > VCLXWindow::CreateAccessibleContext()
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
return getAccessibleFactory().createAccessibleContext( this );
|
|
}
|
|
|
|
void VCLXWindow::SetSynthesizingVCLEvent( sal_Bool _b )
|
|
{
|
|
mpImpl->mbSynthesizingVCLEvent = _b;
|
|
}
|
|
|
|
BOOL VCLXWindow::IsSynthesizingVCLEvent() const
|
|
{
|
|
return mpImpl->mbSynthesizingVCLEvent;
|
|
}
|
|
|
|
Size VCLXWindow::ImplCalcWindowSize( const Size& rOutSz ) const
|
|
{
|
|
Size aSz = rOutSz;
|
|
|
|
Window* pWindow = GetWindow();
|
|
if ( pWindow )
|
|
{
|
|
sal_Int32 nLeft, nTop, nRight, nBottom;
|
|
pWindow->GetBorder( nLeft, nTop, nRight, nBottom );
|
|
aSz.Width() += nLeft+nRight;
|
|
aSz.Height() += nTop+nBottom;
|
|
}
|
|
return aSz;
|
|
}
|
|
|
|
|
|
// ::com::sun::star::lang::XUnoTunnel
|
|
IMPL_XUNOTUNNEL2( VCLXWindow, VCLXDevice )
|
|
|
|
// ::com::sun::star::lang::Component
|
|
void VCLXWindow::dispose( ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
mpImpl->mxViewGraphics = NULL;
|
|
|
|
if ( !mpImpl->mbDisposing )
|
|
{
|
|
mpImpl->mbDisposing = true;
|
|
|
|
mpImpl->disposing();
|
|
|
|
if ( GetWindow() )
|
|
{
|
|
OutputDevice* pOutDev = GetOutputDevice();
|
|
SetWindow( NULL ); // Damit ggf. Handler abgemeldet werden (virtuell).
|
|
SetOutputDevice( pOutDev );
|
|
DestroyOutputDevice();
|
|
}
|
|
|
|
// #i14103# dispose the accessible context after the window has been destroyed,
|
|
// otherwise the old value in the child event fired in VCLXAccessibleComponent::ProcessWindowEvent()
|
|
// for VCLEVENT_WINDOW_CHILDDESTROYED contains a reference to an already disposed accessible object
|
|
try
|
|
{
|
|
::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent > xComponent( mpImpl->mxAccessibleContext, ::com::sun::star::uno::UNO_QUERY );
|
|
if ( xComponent.is() )
|
|
xComponent->dispose();
|
|
}
|
|
catch ( const ::com::sun::star::uno::Exception& )
|
|
{
|
|
DBG_ERROR( "VCLXWindow::dispose: could not dispose the accessible context!" );
|
|
}
|
|
mpImpl->mxAccessibleContext.clear();
|
|
|
|
mpImpl->mbDisposing = false;
|
|
}
|
|
}
|
|
|
|
void VCLXWindow::addEventListener( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
mpImpl->getEventListeners().addInterface( rxListener );
|
|
}
|
|
|
|
void VCLXWindow::removeEventListener( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
mpImpl->getEventListeners().removeInterface( rxListener );
|
|
}
|
|
|
|
|
|
// ::com::sun::star::awt::XWindow
|
|
void VCLXWindow::setPosSize( sal_Int32 X, sal_Int32 Y, sal_Int32 Width, sal_Int32 Height, sal_Int16 Flags ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
if ( GetWindow() )
|
|
{
|
|
if( Window::GetDockingManager()->IsDockable( GetWindow() ) )
|
|
Window::GetDockingManager()->SetPosSizePixel( GetWindow() , X, Y, Width, Height, Flags );
|
|
else
|
|
GetWindow()->SetPosSizePixel( X, Y, Width, Height, Flags );
|
|
}
|
|
}
|
|
|
|
::com::sun::star::awt::Rectangle VCLXWindow::getPosSize( ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
::com::sun::star::awt::Rectangle aBounds;
|
|
if ( GetWindow() )
|
|
{
|
|
if( Window::GetDockingManager()->IsDockable( GetWindow() ) )
|
|
aBounds = AWTRectangle( Window::GetDockingManager()->GetPosSizePixel( GetWindow() ) );
|
|
else
|
|
aBounds = AWTRectangle( Rectangle( GetWindow()->GetPosPixel(), GetWindow()->GetSizePixel() ) );
|
|
}
|
|
|
|
return aBounds;
|
|
}
|
|
|
|
void VCLXWindow::setVisible( sal_Bool bVisible ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
Window* pWindow = GetWindow();
|
|
if ( pWindow )
|
|
{
|
|
/*
|
|
if ( bVisible )
|
|
{
|
|
// #57167# TopWindows mit unsichtbaren Parent anzeigen...
|
|
::com::sun::star::uno::Any aTest = queryInterface( ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTopWindow >*) 0 ) );
|
|
if ( aTest.hasValue() )
|
|
{
|
|
Window* pParent = pWindow->GetWindow( WINDOW_PARENTOVERLAP );
|
|
if ( pParent && !pParent->IsReallyVisible() )
|
|
pWindow->SetParent( pWindow->GetWindow( WINDOW_FRAME ) );
|
|
}
|
|
}
|
|
*/
|
|
mpImpl->setDirectVisible( bVisible );
|
|
pWindow->Show( bVisible && mpImpl->isEnableVisible() );
|
|
}
|
|
}
|
|
|
|
void VCLXWindow::setEnable( sal_Bool bEnable ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
Window* pWindow = GetWindow();
|
|
if ( pWindow )
|
|
{
|
|
pWindow->Enable( bEnable, FALSE ); // #95824# without children!
|
|
pWindow->EnableInput( bEnable );
|
|
}
|
|
}
|
|
|
|
void VCLXWindow::setFocus( ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
if ( GetWindow() )
|
|
GetWindow()->GrabFocus();
|
|
}
|
|
|
|
void VCLXWindow::addWindowListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
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( TRUE );
|
|
}
|
|
|
|
void VCLXWindow::removeWindowListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
Reference< XWindowListener2 > xListener2( rxListener, UNO_QUERY );
|
|
if ( xListener2.is() )
|
|
mpImpl->getWindow2Listeners().removeInterface( xListener2 );
|
|
|
|
mpImpl->getWindowListeners().removeInterface( rxListener );
|
|
}
|
|
|
|
void VCLXWindow::addFocusListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XFocusListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
mpImpl->getFocusListeners().addInterface( rxListener );
|
|
}
|
|
|
|
void VCLXWindow::removeFocusListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XFocusListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
mpImpl->getFocusListeners().removeInterface( rxListener );
|
|
}
|
|
|
|
void VCLXWindow::addKeyListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XKeyListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
mpImpl->getKeyListeners().addInterface( rxListener );
|
|
}
|
|
|
|
void VCLXWindow::removeKeyListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XKeyListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
mpImpl->getKeyListeners().removeInterface( rxListener );
|
|
}
|
|
|
|
void VCLXWindow::addMouseListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XMouseListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
mpImpl->getMouseListeners().addInterface( rxListener );
|
|
}
|
|
|
|
void VCLXWindow::removeMouseListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XMouseListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
mpImpl->getMouseListeners().removeInterface( rxListener );
|
|
}
|
|
|
|
void VCLXWindow::addMouseMotionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XMouseMotionListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
mpImpl->getMouseMotionListeners().addInterface( rxListener );
|
|
}
|
|
|
|
void VCLXWindow::removeMouseMotionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XMouseMotionListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
mpImpl->getMouseMotionListeners().removeInterface( rxListener );
|
|
}
|
|
|
|
void VCLXWindow::addPaintListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XPaintListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
mpImpl->getPaintListeners().addInterface( rxListener );
|
|
}
|
|
|
|
void VCLXWindow::removePaintListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XPaintListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
mpImpl->getPaintListeners().removeInterface( rxListener );
|
|
}
|
|
|
|
// ::com::sun::star::awt::XWindowPeer
|
|
::com::sun::star::uno::Reference< ::com::sun::star::awt::XToolkit > VCLXWindow::getToolkit( ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
// no guard. nothing to guard here.
|
|
// 82463 - 12/21/00 - fs
|
|
return Application::GetVCLToolkit();
|
|
}
|
|
|
|
void VCLXWindow::setPointer( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XPointer >& rxPointer ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
VCLXPointer* pPointer = VCLXPointer::GetImplementation( rxPointer );
|
|
if ( pPointer )
|
|
{
|
|
mpImpl->mxPointer = rxPointer;
|
|
if ( GetWindow() )
|
|
GetWindow()->SetPointer( pPointer->GetPointer() );
|
|
}
|
|
}
|
|
|
|
void VCLXWindow::setBackground( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
if ( GetWindow() )
|
|
{
|
|
Color aColor( (sal_uInt32)nColor );
|
|
GetWindow()->SetBackground( aColor );
|
|
GetWindow()->SetControlBackground( aColor );
|
|
|
|
WindowType eWinType = GetWindow()->GetType();
|
|
if ( ( eWinType == WINDOW_WINDOW ) ||
|
|
( eWinType == WINDOW_WORKWINDOW ) ||
|
|
( eWinType == WINDOW_FLOATINGWINDOW ) )
|
|
{
|
|
GetWindow()->Invalidate();
|
|
}
|
|
}
|
|
}
|
|
|
|
void VCLXWindow::invalidate( sal_Int16 nInvalidateFlags ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
if ( GetWindow() )
|
|
GetWindow()->Invalidate( (sal_uInt16) nInvalidateFlags );
|
|
}
|
|
|
|
void VCLXWindow::invalidateRect( const ::com::sun::star::awt::Rectangle& rRect, sal_Int16 nInvalidateFlags ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
if ( GetWindow() )
|
|
GetWindow()->Invalidate( VCLRectangle(rRect), (sal_uInt16) nInvalidateFlags );
|
|
}
|
|
|
|
|
|
// ::com::sun::star::awt::XVclWindowPeer
|
|
sal_Bool VCLXWindow::isChild( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer >& rxPeer ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
sal_Bool bIsChild = sal_False;
|
|
Window* pWindow = GetWindow();
|
|
if ( pWindow )
|
|
{
|
|
Window* pPeerWindow = VCLUnoHelper::GetWindow( rxPeer );
|
|
bIsChild = pPeerWindow && pWindow->IsChild( pPeerWindow );
|
|
}
|
|
|
|
return bIsChild;
|
|
}
|
|
|
|
void VCLXWindow::setDesignMode( sal_Bool bOn ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
mpImpl->mbDesignMode = bOn;
|
|
}
|
|
|
|
sal_Bool VCLXWindow::isDesignMode( ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
return mpImpl->mbDesignMode;
|
|
}
|
|
|
|
void VCLXWindow::enableClipSiblings( sal_Bool bClip ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
if ( GetWindow() )
|
|
GetWindow()->EnableClipSiblings( bClip );
|
|
}
|
|
|
|
void VCLXWindow::setForeground( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
if ( GetWindow() )
|
|
{
|
|
Color aColor( (sal_uInt32)nColor );
|
|
GetWindow()->SetControlForeground( aColor );
|
|
}
|
|
}
|
|
|
|
void VCLXWindow::setControlFont( const ::com::sun::star::awt::FontDescriptor& rFont ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
if ( GetWindow() )
|
|
GetWindow()->SetControlFont( VCLUnoHelper::CreateFont( rFont, GetWindow()->GetControlFont() ) );
|
|
}
|
|
|
|
void VCLXWindow::getStyles( sal_Int16 nType, ::com::sun::star::awt::FontDescriptor& Font, sal_Int32& ForegroundColor, sal_Int32& BackgroundColor ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
if ( GetWindow() )
|
|
{
|
|
const StyleSettings& rStyleSettings = GetWindow()->GetSettings().GetStyleSettings();
|
|
|
|
switch ( nType )
|
|
{
|
|
case ::com::sun::star::awt::Style::FRAME:
|
|
{
|
|
Font = VCLUnoHelper::CreateFontDescriptor( rStyleSettings.GetAppFont() );
|
|
ForegroundColor = rStyleSettings.GetWindowTextColor().GetColor();
|
|
BackgroundColor = rStyleSettings.GetWindowColor().GetColor();
|
|
}
|
|
break;
|
|
case ::com::sun::star::awt::Style::DIALOG:
|
|
{
|
|
Font = VCLUnoHelper::CreateFontDescriptor( rStyleSettings.GetAppFont() );
|
|
ForegroundColor = rStyleSettings.GetDialogTextColor().GetColor();
|
|
BackgroundColor = rStyleSettings.GetDialogColor().GetColor();
|
|
}
|
|
break;
|
|
default: DBG_ERROR( "VCLWindow::getStyles() - unknown Type" );
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
namespace toolkit
|
|
{
|
|
static void setColorSettings( Window* _pWindow, const ::com::sun::star::uno::Any& _rValue,
|
|
void (StyleSettings::*pSetter)( const Color& ), const Color& (StyleSettings::*pGetter)( ) const )
|
|
{
|
|
sal_Int32 nColor = 0;
|
|
if ( !( _rValue >>= nColor ) )
|
|
nColor = (Application::GetSettings().GetStyleSettings().*pGetter)().GetColor();
|
|
|
|
AllSettings aSettings = _pWindow->GetSettings();
|
|
StyleSettings aStyleSettings = aSettings.GetStyleSettings();
|
|
|
|
(aStyleSettings.*pSetter)( Color( nColor ) );
|
|
|
|
aSettings.SetStyleSettings( aStyleSettings );
|
|
_pWindow->SetSettings( aSettings, TRUE );
|
|
}
|
|
}
|
|
|
|
// Terminated by BASEPROPERTY_NOTFOUND (or 0)
|
|
void VCLXWindow::PushPropertyIds( std::list< 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( (sal_uInt16) nId );
|
|
|
|
va_end( pVarArgs );
|
|
}
|
|
|
|
void VCLXWindow::ImplGetPropertyIds( std::list< 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 )
|
|
std::list< sal_uInt16 >::const_iterator iter;
|
|
for( iter = rIds.begin(); iter != rIds.end(); iter++) {
|
|
if( *iter == BASEPROPERTY_FONTDESCRIPTOR )
|
|
{
|
|
// some properties are not included in the FontDescriptor, but everytime
|
|
// when we have a FontDescriptor we want to have these properties too.
|
|
// => Easier to register the here, istead 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 );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void VCLXWindow::GetPropertyIds( std::list< sal_uInt16 >& _out_rIds )
|
|
{
|
|
return ImplGetPropertyIds( _out_rIds, mpImpl->mbWithDefaultProps );
|
|
}
|
|
|
|
::cppu::OInterfaceContainerHelper& VCLXWindow::GetContainerListeners()
|
|
{
|
|
return mpImpl->getContainerListeners();
|
|
}
|
|
|
|
::cppu::OInterfaceContainerHelper& VCLXWindow::GetTopWindowListeners()
|
|
{
|
|
return mpImpl->getTopWindowListeners();
|
|
}
|
|
|
|
namespace
|
|
{
|
|
void lcl_updateWritingMode( 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 Window* pParent = _rWindow.GetParent();
|
|
OSL_ENSURE( pParent, "lcl_updateWritingMode: cannot determine context's writing mode!" );
|
|
if ( pParent )
|
|
bEnableRTL = pParent->IsRTLEnabled();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
OSL_ENSURE( false, "lcl_updateWritingMode: unsupported WritingMode!" );
|
|
} // switch ( nWritingMode )
|
|
|
|
_rWindow.EnableRTL( bEnableRTL );
|
|
}
|
|
}
|
|
|
|
void VCLXWindow::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
Window* pWindow = GetWindow();
|
|
if ( !pWindow )
|
|
return;
|
|
|
|
sal_Bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
|
|
|
|
WindowType eWinType = pWindow->GetType();
|
|
sal_uInt16 nPropType = GetPropertyId( PropertyName );
|
|
switch ( nPropType )
|
|
{
|
|
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:
|
|
{
|
|
sal_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( MouseWheelBehavior::SCROLL_FOCUS_ONLY );
|
|
OSL_VERIFY( Value >>= nWheelBehavior );
|
|
|
|
AllSettings aSettings = pWindow->GetSettings();
|
|
MouseSettings aMouseSettings = aSettings.GetMouseSettings();
|
|
|
|
USHORT nVclBehavior( MOUSE_WHEEL_FOCUS_ONLY );
|
|
switch ( nWheelBehavior )
|
|
{
|
|
case MouseWheelBehavior::SCROLL_DISABLED: nVclBehavior = MOUSE_WHEEL_DISABLE; break;
|
|
case MouseWheelBehavior::SCROLL_FOCUS_ONLY: nVclBehavior = MOUSE_WHEEL_FOCUS_ONLY; break;
|
|
case MouseWheelBehavior::SCROLL_ALWAYS: nVclBehavior = MOUSE_WHEEL_ALWAYS; break;
|
|
default:
|
|
OSL_ENSURE( false, "VCLXWindow::setProperty( 'MouseWheelBehavior' ): illegal property value!" );
|
|
}
|
|
|
|
aMouseSettings.SetWheelBehavior( nWheelBehavior );
|
|
aSettings.SetMouseSettings( aMouseSettings );
|
|
pWindow->SetSettings( aSettings, TRUE );
|
|
}
|
|
break;
|
|
|
|
case BASEPROPERTY_NATIVE_WIDGET_LOOK:
|
|
{
|
|
sal_Bool bEnable( sal_True );
|
|
OSL_VERIFY( Value >>= bEnable );
|
|
pWindow->EnableNativeWidget( bEnable );
|
|
}
|
|
break;
|
|
|
|
case BASEPROPERTY_PLUGINPARENT:
|
|
{
|
|
// set parent handle
|
|
SetSystemParent_Impl( Value );
|
|
}
|
|
break;
|
|
|
|
case BASEPROPERTY_ENABLED:
|
|
{
|
|
sal_Bool b = sal_Bool();
|
|
if ( Value >>= b )
|
|
setEnable( b );
|
|
}
|
|
break;
|
|
case BASEPROPERTY_ENABLEVISIBLE:
|
|
{
|
|
sal_Bool b = sal_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:
|
|
{
|
|
::rtl::OUString aText;
|
|
if ( Value >>= aText )
|
|
{
|
|
switch (eWinType)
|
|
{
|
|
case WINDOW_OKBUTTON:
|
|
case WINDOW_CANCELBUTTON:
|
|
case WINDOW_HELPBUTTON:
|
|
// Standard Button: overwrite only if not empty.
|
|
if (aText.getLength())
|
|
pWindow->SetText( aText );
|
|
break;
|
|
|
|
default:
|
|
pWindow->SetText( aText );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case BASEPROPERTY_ACCESSIBLENAME:
|
|
{
|
|
::rtl::OUString aText;
|
|
if ( Value >>= aText )
|
|
pWindow->SetAccessibleName( aText );
|
|
}
|
|
break;
|
|
case BASEPROPERTY_HELPURL:
|
|
{
|
|
::rtl::OUString aURL;
|
|
if ( Value >>= aURL )
|
|
{
|
|
String aHelpURL( aURL );
|
|
String aPattern( RTL_CONSTASCII_USTRINGPARAM( "HID:" ) );
|
|
if ( aHelpURL.CompareIgnoreCaseToAscii( aPattern, aPattern.Len() ) == COMPARE_EQUAL )
|
|
{
|
|
String aID = aHelpURL.Copy( aPattern.Len() );
|
|
pWindow->SetHelpId( aID.ToInt32() );
|
|
}
|
|
else
|
|
{
|
|
pWindow->SetSmartHelpId( SmartId( aHelpURL ) );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case BASEPROPERTY_HELPTEXT:
|
|
{
|
|
::rtl::OUString aHelpText;
|
|
if ( Value >>= aHelpText )
|
|
{
|
|
pWindow->SetQuickHelpText( aHelpText );
|
|
}
|
|
}
|
|
break;
|
|
case BASEPROPERTY_FONTDESCRIPTOR:
|
|
{
|
|
if ( bVoid )
|
|
pWindow->SetControlFont( Font() );
|
|
else
|
|
{
|
|
::com::sun::star::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 )
|
|
{
|
|
Font aFont = pWindow->GetControlFont();
|
|
aFont.SetRelief( (FontRelief)n );
|
|
pWindow->SetControlFont( aFont );
|
|
}
|
|
}
|
|
break;
|
|
case BASEPROPERTY_FONTEMPHASISMARK:
|
|
{
|
|
sal_Int16 n = sal_Int16();
|
|
if ( Value >>= n )
|
|
{
|
|
Font aFont = pWindow->GetControlFont();
|
|
aFont.SetEmphasisMark( n );
|
|
pWindow->SetControlFont( aFont );
|
|
}
|
|
}
|
|
break;
|
|
case BASEPROPERTY_BACKGROUNDCOLOR:
|
|
if ( bVoid )
|
|
{
|
|
switch ( eWinType )
|
|
{
|
|
// set dialog color for default
|
|
case WINDOW_DIALOG:
|
|
case WINDOW_MESSBOX:
|
|
case WINDOW_INFOBOX:
|
|
case WINDOW_WARNINGBOX:
|
|
case WINDOW_ERRORBOX:
|
|
case WINDOW_QUERYBOX:
|
|
case WINDOW_TABPAGE:
|
|
{
|
|
Color aColor = pWindow->GetSettings().GetStyleSettings().GetDialogColor();
|
|
pWindow->SetBackground( aColor );
|
|
pWindow->SetControlBackground( aColor );
|
|
break;
|
|
}
|
|
|
|
case WINDOW_FIXEDTEXT:
|
|
case WINDOW_CHECKBOX:
|
|
case WINDOW_RADIOBUTTON:
|
|
case WINDOW_GROUPBOX:
|
|
case WINDOW_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
|
|
{
|
|
sal_Int32 nColor = 0;
|
|
if ( Value >>= nColor )
|
|
{
|
|
Color aColor( nColor );
|
|
pWindow->SetControlBackground( aColor );
|
|
pWindow->SetBackground( aColor );
|
|
switch ( eWinType )
|
|
{
|
|
// reset paint transparent mode
|
|
case WINDOW_FIXEDTEXT:
|
|
case WINDOW_CHECKBOX:
|
|
case WINDOW_RADIOBUTTON:
|
|
case WINDOW_GROUPBOX:
|
|
case WINDOW_FIXEDLINE:
|
|
pWindow->SetPaintTransparent( FALSE );
|
|
default: ;
|
|
}
|
|
pWindow->Invalidate(); // Falls das Control nicht drauf reagiert
|
|
}
|
|
}
|
|
break;
|
|
case BASEPROPERTY_TEXTCOLOR:
|
|
if ( bVoid )
|
|
{
|
|
pWindow->SetControlForeground();
|
|
}
|
|
else
|
|
{
|
|
sal_Int32 nColor = 0;
|
|
if ( Value >>= nColor )
|
|
{
|
|
Color aColor( nColor );
|
|
pWindow->SetTextColor( aColor );
|
|
pWindow->SetControlForeground( aColor );
|
|
}
|
|
}
|
|
break;
|
|
case BASEPROPERTY_TEXTLINECOLOR:
|
|
if ( bVoid )
|
|
{
|
|
pWindow->SetTextLineColor();
|
|
}
|
|
else
|
|
{
|
|
sal_Int32 nColor = 0;
|
|
if ( Value >>= nColor )
|
|
{
|
|
Color aColor( nColor );
|
|
pWindow->SetTextLineColor( aColor );
|
|
}
|
|
}
|
|
break;
|
|
case BASEPROPERTY_FILLCOLOR:
|
|
if ( bVoid )
|
|
pWindow->SetFillColor();
|
|
else
|
|
{
|
|
sal_Int32 nColor = 0;
|
|
if ( Value >>= nColor )
|
|
{
|
|
Color aColor( nColor );
|
|
pWindow->SetFillColor( aColor );
|
|
}
|
|
}
|
|
break;
|
|
case BASEPROPERTY_LINECOLOR:
|
|
if ( bVoid )
|
|
pWindow->SetLineColor();
|
|
else
|
|
{
|
|
sal_Int32 nColor = 0;
|
|
if ( Value >>= nColor )
|
|
{
|
|
Color aColor( nColor );
|
|
pWindow->SetLineColor( aColor );
|
|
}
|
|
}
|
|
break;
|
|
case BASEPROPERTY_BORDER:
|
|
{
|
|
WinBits nStyle = pWindow->GetStyle();
|
|
sal_uInt16 nBorder = 0;
|
|
Value >>= nBorder;
|
|
if ( !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 )
|
|
{
|
|
sal_Bool bTab = false;
|
|
Value >>= bTab;
|
|
if ( bTab )
|
|
nStyle |= WB_TABSTOP;
|
|
else
|
|
nStyle |= WB_NOTABSTOP;
|
|
}
|
|
pWindow->SetStyle( nStyle );
|
|
}
|
|
break;
|
|
case BASEPROPERTY_VERTICALALIGN:
|
|
{
|
|
VerticalAlignment eAlign = 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 WINDOW_COMBOBOX:
|
|
case WINDOW_BUTTON:
|
|
case WINDOW_PUSHBUTTON:
|
|
case WINDOW_OKBUTTON:
|
|
case WINDOW_CANCELBUTTON:
|
|
case WINDOW_HELPBUTTON:
|
|
nAlign = PROPERTY_ALIGN_CENTER;
|
|
// no break here!
|
|
case WINDOW_FIXEDTEXT:
|
|
case WINDOW_EDIT:
|
|
case WINDOW_MULTILINEEDIT:
|
|
case WINDOW_CHECKBOX:
|
|
case WINDOW_RADIOBUTTON:
|
|
case WINDOW_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;
|
|
}
|
|
}
|
|
break;
|
|
case BASEPROPERTY_MULTILINE:
|
|
{
|
|
if ( ( eWinType == WINDOW_FIXEDTEXT )
|
|
|| ( eWinType == WINDOW_CHECKBOX )
|
|
|| ( eWinType == WINDOW_RADIOBUTTON )
|
|
|| ( eWinType == WINDOW_BUTTON )
|
|
|| ( eWinType == WINDOW_PUSHBUTTON )
|
|
|| ( eWinType == WINDOW_OKBUTTON )
|
|
|| ( eWinType == WINDOW_CANCELBUTTON )
|
|
|| ( eWinType == WINDOW_HELPBUTTON )
|
|
)
|
|
{
|
|
WinBits nStyle = pWindow->GetStyle();
|
|
sal_Bool bMulti = false;
|
|
Value >>= bMulti;
|
|
if ( bMulti )
|
|
nStyle |= WB_WORDBREAK;
|
|
else
|
|
nStyle &= ~WB_WORDBREAK;
|
|
pWindow->SetStyle( nStyle );
|
|
}
|
|
}
|
|
break;
|
|
case BASEPROPERTY_ORIENTATION:
|
|
{
|
|
switch ( eWinType )
|
|
{
|
|
case WINDOW_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;
|
|
}
|
|
}
|
|
break;
|
|
case BASEPROPERTY_AUTOMNEMONICS:
|
|
{
|
|
sal_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:
|
|
{
|
|
sal_Bool bMouseTransparent = false;
|
|
Value >>= bMouseTransparent;
|
|
pWindow->SetMouseTransparent( bMouseTransparent );
|
|
}
|
|
break;
|
|
case BASEPROPERTY_PAINTTRANSPARENT:
|
|
{
|
|
sal_Bool bPaintTransparent = false;
|
|
Value >>= bPaintTransparent;
|
|
pWindow->SetPaintTransparent( bPaintTransparent );
|
|
// pWindow->SetBackground();
|
|
}
|
|
break;
|
|
|
|
case BASEPROPERTY_REPEAT:
|
|
{
|
|
sal_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;
|
|
case BASEPROPERTY_DEFAULTCONTROL:
|
|
{
|
|
rtl::OUString aName;
|
|
Value >>= aName;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
::com::sun::star::uno::Any VCLXWindow::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
::com::sun::star::uno::Any aProp;
|
|
if ( GetWindow() )
|
|
{
|
|
WindowType eWinType = GetWindow()->GetType();
|
|
sal_uInt16 nPropType = GetPropertyId( PropertyName );
|
|
switch ( nPropType )
|
|
{
|
|
case BASEPROPERTY_CONTEXT_WRITING_MODE:
|
|
aProp <<= mpImpl->mnContextWritingMode;
|
|
break;
|
|
|
|
case BASEPROPERTY_WRITING_MODE:
|
|
aProp <<= mpImpl->mnWritingMode;
|
|
break;
|
|
|
|
case BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR:
|
|
{
|
|
USHORT nVclBehavior = GetWindow()->GetSettings().GetMouseSettings().GetWheelBehavior();
|
|
sal_Int16 nBehavior = MouseWheelBehavior::SCROLL_FOCUS_ONLY;
|
|
switch ( nVclBehavior )
|
|
{
|
|
case MOUSE_WHEEL_DISABLE: nBehavior = MouseWheelBehavior::SCROLL_DISABLED; break;
|
|
case MOUSE_WHEEL_FOCUS_ONLY: nBehavior = MouseWheelBehavior::SCROLL_FOCUS_ONLY; break;
|
|
case MOUSE_WHEEL_ALWAYS: nBehavior = MouseWheelBehavior::SCROLL_ALWAYS; break;
|
|
default:
|
|
OSL_ENSURE( false, "VCLXWindow::getProperty( 'MouseWheelBehavior' ): illegal VCL value!" );
|
|
}
|
|
aProp <<= nBehavior;
|
|
}
|
|
break;
|
|
|
|
case BASEPROPERTY_NATIVE_WIDGET_LOOK:
|
|
aProp <<= (sal_Bool) GetWindow()->IsNativeWidgetEnabled();
|
|
break;
|
|
|
|
case BASEPROPERTY_ENABLED:
|
|
aProp <<= (sal_Bool) GetWindow()->IsEnabled();
|
|
break;
|
|
|
|
case BASEPROPERTY_ENABLEVISIBLE:
|
|
aProp <<= (sal_Bool) mpImpl->isEnableVisible();
|
|
break;
|
|
|
|
case BASEPROPERTY_TEXT:
|
|
case BASEPROPERTY_LABEL:
|
|
case BASEPROPERTY_TITLE:
|
|
{
|
|
::rtl::OUString aText = GetWindow()->GetText();
|
|
aProp <<= aText;
|
|
}
|
|
break;
|
|
case BASEPROPERTY_ACCESSIBLENAME:
|
|
{
|
|
::rtl::OUString aText = GetWindow()->GetAccessibleName();
|
|
aProp <<= aText;
|
|
}
|
|
break;
|
|
case BASEPROPERTY_HELPTEXT:
|
|
{
|
|
::rtl::OUString aText = GetWindow()->GetQuickHelpText();
|
|
aProp <<= aText;
|
|
}
|
|
break;
|
|
case BASEPROPERTY_HELPURL:
|
|
{
|
|
SmartId aSmartId = GetWindow()->GetSmartHelpId();
|
|
if( aSmartId.HasString() )
|
|
{
|
|
String aStrHelpId = aSmartId.GetStr();
|
|
aProp <<= ::rtl::OUString( aStrHelpId );
|
|
}
|
|
else
|
|
{
|
|
::rtl::OUStringBuffer aURL;
|
|
aURL.appendAscii( "HID:" );
|
|
aURL.append( (sal_Int32) GetWindow()->GetHelpId() );
|
|
aProp <<= aURL.makeStringAndClear();
|
|
}
|
|
}
|
|
break;
|
|
case BASEPROPERTY_FONTDESCRIPTOR:
|
|
{
|
|
Font aFont = GetWindow()->GetControlFont();
|
|
::com::sun::star::awt::FontDescriptor aFD = VCLUnoHelper::CreateFontDescriptor( aFont );
|
|
aProp <<= aFD;
|
|
}
|
|
break;
|
|
case BASEPROPERTY_BACKGROUNDCOLOR:
|
|
aProp <<= (sal_Int32) GetWindow()->GetControlBackground().GetColor();
|
|
break;
|
|
case BASEPROPERTY_DISPLAYBACKGROUNDCOLOR:
|
|
aProp <<= (sal_Int32) GetWindow()->GetDisplayBackground().GetColor().GetColor();
|
|
break;
|
|
case BASEPROPERTY_FONTRELIEF:
|
|
aProp <<= (sal_Int16) GetWindow()->GetControlFont().GetRelief();
|
|
break;
|
|
case BASEPROPERTY_FONTEMPHASISMARK:
|
|
aProp <<= (sal_Int16) GetWindow()->GetControlFont().GetEmphasisMark();
|
|
break;
|
|
case BASEPROPERTY_TEXTCOLOR:
|
|
aProp <<= (sal_Int32) GetWindow()->GetControlForeground().GetColor();
|
|
break;
|
|
case BASEPROPERTY_TEXTLINECOLOR:
|
|
aProp <<= (sal_Int32) GetWindow()->GetTextLineColor().GetColor();
|
|
break;
|
|
case BASEPROPERTY_FILLCOLOR:
|
|
aProp <<= (sal_Int32) GetWindow()->GetFillColor().GetColor();
|
|
break;
|
|
case BASEPROPERTY_LINECOLOR:
|
|
aProp <<= (sal_Int32) GetWindow()->GetLineColor().GetColor();
|
|
break;
|
|
case BASEPROPERTY_BORDER:
|
|
{
|
|
sal_Int16 nBorder = 0;
|
|
if ( GetWindow()->GetStyle() & WB_BORDER )
|
|
nBorder = GetWindow()->GetBorderStyle();
|
|
aProp <<= nBorder;
|
|
}
|
|
break;
|
|
case BASEPROPERTY_TABSTOP:
|
|
aProp <<= (sal_Bool) ( GetWindow()->GetStyle() & WB_TABSTOP ) ? sal_True : sal_False;
|
|
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 WINDOW_FIXEDTEXT:
|
|
case WINDOW_EDIT:
|
|
case WINDOW_MULTILINEEDIT:
|
|
case WINDOW_CHECKBOX:
|
|
case WINDOW_RADIOBUTTON:
|
|
case WINDOW_LISTBOX:
|
|
case WINDOW_COMBOBOX:
|
|
case WINDOW_BUTTON:
|
|
case WINDOW_PUSHBUTTON:
|
|
case WINDOW_OKBUTTON:
|
|
case WINDOW_CANCELBUTTON:
|
|
case WINDOW_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;
|
|
}
|
|
}
|
|
case BASEPROPERTY_MULTILINE:
|
|
{
|
|
if ( ( eWinType == WINDOW_FIXEDTEXT )
|
|
|| ( eWinType == WINDOW_CHECKBOX )
|
|
|| ( eWinType == WINDOW_RADIOBUTTON )
|
|
|| ( eWinType == WINDOW_BUTTON )
|
|
|| ( eWinType == WINDOW_PUSHBUTTON )
|
|
|| ( eWinType == WINDOW_OKBUTTON )
|
|
|| ( eWinType == WINDOW_CANCELBUTTON )
|
|
|| ( eWinType == WINDOW_HELPBUTTON )
|
|
)
|
|
aProp <<= (sal_Bool) ( GetWindow()->GetStyle() & WB_WORDBREAK ) ? sal_True : sal_False;
|
|
}
|
|
break;
|
|
case BASEPROPERTY_AUTOMNEMONICS:
|
|
{
|
|
sal_Bool bAutoMnemonics = GetWindow()->GetSettings().GetStyleSettings().GetAutoMnemonic();
|
|
aProp <<= bAutoMnemonics;
|
|
}
|
|
break;
|
|
case BASEPROPERTY_MOUSETRANSPARENT:
|
|
{
|
|
sal_Bool bMouseTransparent = GetWindow()->IsMouseTransparent();
|
|
aProp <<= bMouseTransparent;
|
|
}
|
|
break;
|
|
case BASEPROPERTY_PAINTTRANSPARENT:
|
|
{
|
|
sal_Bool bPaintTransparent = GetWindow()->IsPaintTransparent();
|
|
aProp <<= bPaintTransparent;
|
|
}
|
|
break;
|
|
|
|
case BASEPROPERTY_REPEAT:
|
|
aProp <<= (sal_Bool)( 0 != ( GetWindow()->GetStyle() & WB_REPEAT ) );
|
|
break;
|
|
|
|
case BASEPROPERTY_REPEAT_DELAY:
|
|
{
|
|
sal_Int32 nButtonRepeat = GetWindow()->GetSettings().GetMouseSettings().GetButtonRepeat();
|
|
aProp <<= (sal_Int32)nButtonRepeat;
|
|
}
|
|
break;
|
|
|
|
case BASEPROPERTY_SYMBOL_COLOR:
|
|
aProp <<= (sal_Int32)GetWindow()->GetSettings().GetStyleSettings().GetButtonTextColor().GetColor();
|
|
break;
|
|
|
|
case BASEPROPERTY_BORDERCOLOR:
|
|
aProp <<= (sal_Int32)GetWindow()->GetSettings().GetStyleSettings().GetMonoColor().GetColor();
|
|
break;
|
|
}
|
|
}
|
|
return aProp;
|
|
}
|
|
|
|
|
|
// ::com::sun::star::awt::XLayoutConstrains
|
|
::com::sun::star::awt::Size VCLXWindow::getMinimumSize( ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
// Diese Methode sollte nur fuer Componenten gerufen werden, die zwar
|
|
// ueber das ::com::sun::star::awt::Toolkit erzeugt werden koennen, aber fuer die es
|
|
// kein Interface gibt.
|
|
|
|
Size aSz;
|
|
if ( GetWindow() )
|
|
{
|
|
WindowType nWinType = GetWindow()->GetType();
|
|
switch ( nWinType )
|
|
{
|
|
case WINDOW_CONTROL:
|
|
aSz.Width() = GetWindow()->GetTextWidth( GetWindow()->GetText() )+2*12;
|
|
aSz.Height() = GetWindow()->GetTextHeight()+2*6;
|
|
break;
|
|
|
|
case WINDOW_PATTERNBOX:
|
|
case WINDOW_NUMERICBOX:
|
|
case WINDOW_METRICBOX:
|
|
case WINDOW_CURRENCYBOX:
|
|
case WINDOW_DATEBOX:
|
|
case WINDOW_TIMEBOX:
|
|
case WINDOW_LONGCURRENCYBOX:
|
|
aSz.Width() = GetWindow()->GetTextWidth( GetWindow()->GetText() )+2*2;
|
|
aSz.Height() = GetWindow()->GetTextHeight()+2*2;
|
|
break;
|
|
case WINDOW_SCROLLBARBOX:
|
|
return VCLXScrollBar::implGetMinimumSize( GetWindow() );
|
|
default:
|
|
aSz = GetWindow()->GetOptimalSize( WINDOWSIZE_MINIMUM );
|
|
}
|
|
}
|
|
|
|
return ::com::sun::star::awt::Size( aSz.Width(), aSz.Height() );
|
|
}
|
|
|
|
::com::sun::star::awt::Size VCLXWindow::getPreferredSize( ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
return getMinimumSize();
|
|
}
|
|
|
|
::com::sun::star::awt::Size VCLXWindow::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
::com::sun::star::awt::Size aNewSize( rNewSize );
|
|
::com::sun::star::awt::Size aMinSize = getMinimumSize();
|
|
|
|
if ( aNewSize.Width < aMinSize.Width )
|
|
aNewSize.Width = aMinSize.Width;
|
|
if ( aNewSize.Height < aMinSize.Height )
|
|
aNewSize.Height = aMinSize.Height;
|
|
|
|
return aNewSize;
|
|
}
|
|
|
|
|
|
// ::com::sun::star::awt::XView
|
|
sal_Bool VCLXWindow::setGraphics( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XGraphics >& rxDevice ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
if ( VCLUnoHelper::GetOutputDevice( rxDevice ) )
|
|
mpImpl->mxViewGraphics = rxDevice;
|
|
else
|
|
mpImpl->mxViewGraphics = NULL;
|
|
|
|
return mpImpl->mxViewGraphics.is();
|
|
}
|
|
|
|
::com::sun::star::uno::Reference< ::com::sun::star::awt::XGraphics > VCLXWindow::getGraphics( ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
return mpImpl->mxViewGraphics;
|
|
}
|
|
|
|
::com::sun::star::awt::Size VCLXWindow::getSize( ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
Size aSz;
|
|
if ( GetWindow() )
|
|
aSz = GetWindow()->GetSizePixel();
|
|
return ::com::sun::star::awt::Size( aSz.Width(), aSz.Height() );
|
|
}
|
|
|
|
void VCLXWindow::draw( sal_Int32 nX, sal_Int32 nY ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
Window* pWindow = GetWindow();
|
|
if ( !pWindow )
|
|
return;
|
|
|
|
if ( isDesignMode() || mpImpl->isEnableVisible() )
|
|
{
|
|
TabPage* pTabPage = dynamic_cast< TabPage* >( pWindow );
|
|
if ( pTabPage )
|
|
{
|
|
Point aPos( nX, nY );
|
|
Size aSize = pWindow->GetSizePixel();
|
|
|
|
OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( mpImpl->mxViewGraphics );
|
|
aPos = pDev->PixelToLogic( aPos );
|
|
aSize = pDev->PixelToLogic( aSize );
|
|
|
|
pTabPage->Draw( pDev, aPos, aSize, 0 );
|
|
return;
|
|
}
|
|
|
|
OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( mpImpl->mxViewGraphics );
|
|
Point aPos( nX, nY );
|
|
|
|
if ( !pDev )
|
|
pDev = pWindow->GetParent();
|
|
|
|
if ( pWindow->GetParent() && !pWindow->IsSystemWindow() && ( pWindow->GetParent() == 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() )
|
|
{
|
|
FlagGuard aDrawingflagGuard( mpImpl->getDrawingOntoParent_ref() );
|
|
|
|
BOOL bWasVisible = pWindow->IsVisible();
|
|
Point aOldPos( pWindow->GetPosPixel() );
|
|
|
|
if ( bWasVisible && aOldPos == aPos )
|
|
{
|
|
pWindow->Update();
|
|
return;
|
|
}
|
|
|
|
pWindow->SetPosPixel( aPos );
|
|
|
|
// Erstmal ein Update auf den Parent, damit nicht beim Update
|
|
// auf dieses Fenster noch ein Paint vom Parent abgearbeitet wird,
|
|
// wo dann ggf. dieses Fenster sofort wieder gehidet wird.
|
|
if( pWindow->GetParent() )
|
|
pWindow->GetParent()->Update();
|
|
|
|
pWindow->Show();
|
|
pWindow->Update();
|
|
pWindow->SetParentUpdateMode( sal_False );
|
|
pWindow->Hide();
|
|
pWindow->SetParentUpdateMode( sal_True );
|
|
|
|
pWindow->SetPosPixel( aOldPos );
|
|
if ( bWasVisible )
|
|
pWindow->Show( TRUE );
|
|
}
|
|
}
|
|
else if ( pDev )
|
|
{
|
|
Size aSz = pWindow->GetSizePixel();
|
|
aSz = pDev->PixelToLogic( aSz );
|
|
Point aP = pDev->PixelToLogic( aPos );
|
|
|
|
vcl::PDFExtOutDevData* pPDFExport = dynamic_cast<vcl::PDFExtOutDevData*>(pDev->GetExtOutDevData());
|
|
bool bDrawSimple = ( pDev->GetOutDevType() == OUTDEV_PRINTER )
|
|
|| ( pDev->GetOutDevViewType() == OUTDEV_VIEWTYPE_PRINTPREVIEW )
|
|
|| ( pPDFExport && ! pPDFExport->GetIsExportFormFields() );
|
|
if ( bDrawSimple )
|
|
{
|
|
pWindow->Draw( pDev, aP, aSz, WINDOW_DRAW_NOCONTROLS );
|
|
}
|
|
else
|
|
{
|
|
BOOL bOldNW =pWindow->IsNativeWidgetEnabled();
|
|
if( bOldNW )
|
|
pWindow->EnableNativeWidget(FALSE);
|
|
pWindow->PaintToDevice( pDev, aP, aSz );
|
|
if( bOldNW )
|
|
pWindow->EnableNativeWidget(TRUE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void VCLXWindow::setZoom( float fZoomX, float /*fZoomY*/ ) throw(::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
if ( GetWindow() )
|
|
GetWindow()->SetZoom( Fraction( fZoomX ) );
|
|
}
|
|
|
|
// ::com::sun::star::lang::XEventListener
|
|
void SAL_CALL VCLXWindow::disposing( const ::com::sun::star::lang::EventObject& _rSource ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
// 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 = uno::Reference< accessibility::XAccessibleContext >();
|
|
}
|
|
}
|
|
|
|
// ::com::sun::star::accessibility::XAccessible
|
|
::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXWindow::getAccessibleContext( ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
using namespace ::com::sun::star;
|
|
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
// already disposed
|
|
if( ! mpImpl )
|
|
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;
|
|
}
|
|
|
|
// ::com::sun::star::awt::XDockable
|
|
void SAL_CALL VCLXWindow::addDockableWindowListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XDockableWindowListener >& xListener ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
if ( xListener.is() )
|
|
mpImpl->getDockableWindowListeners().addInterface( xListener );
|
|
|
|
}
|
|
|
|
void SAL_CALL VCLXWindow::removeDockableWindowListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XDockableWindowListener >& xListener ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
mpImpl->getDockableWindowListeners().removeInterface( xListener );
|
|
}
|
|
|
|
void SAL_CALL VCLXWindow::enableDocking( sal_Bool bEnable ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
Window* pWindow = GetWindow();
|
|
if ( pWindow )
|
|
pWindow->EnableDocking( bEnable );
|
|
}
|
|
|
|
sal_Bool SAL_CALL VCLXWindow::isFloating( ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
Window* pWindow = GetWindow();
|
|
if( pWindow )
|
|
return Window::GetDockingManager()->IsFloating( pWindow );
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
void SAL_CALL VCLXWindow::setFloatingMode( sal_Bool bFloating ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
Window* pWindow = GetWindow();
|
|
if( pWindow )
|
|
Window::GetDockingManager()->SetFloatingMode( pWindow, bFloating );
|
|
}
|
|
|
|
sal_Bool SAL_CALL VCLXWindow::isLocked( ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
Window* pWindow = GetWindow();
|
|
if( pWindow )
|
|
return Window::GetDockingManager()->IsLocked( pWindow );
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
void SAL_CALL VCLXWindow::lock( ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
Window* pWindow = GetWindow();
|
|
if( pWindow && !Window::GetDockingManager()->IsFloating( pWindow ) )
|
|
Window::GetDockingManager()->Lock( pWindow );
|
|
}
|
|
|
|
void SAL_CALL VCLXWindow::unlock( ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
Window* pWindow = GetWindow();
|
|
if( pWindow && !Window::GetDockingManager()->IsFloating( pWindow ) )
|
|
Window::GetDockingManager()->Unlock( pWindow );
|
|
}
|
|
void SAL_CALL VCLXWindow::startPopupMode( const ::com::sun::star::awt::Rectangle& ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
// TODO: remove interface in the next incompatible build
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
|
|
}
|
|
|
|
sal_Bool SAL_CALL VCLXWindow::isInPopupMode( ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
// TODO: remove interface in the next incompatible build
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// ::com::sun::star::awt::XWindow2
|
|
|
|
void SAL_CALL VCLXWindow::setOutputSize( const ::com::sun::star::awt::Size& aSize ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
Window *pWindow;
|
|
if( (pWindow = GetWindow()) != NULL )
|
|
{
|
|
DockingWindow *pDockingWindow = dynamic_cast< DockingWindow* >(pWindow);
|
|
if( pDockingWindow )
|
|
pDockingWindow->SetOutputSizePixel( VCLSize( aSize ) );
|
|
else
|
|
pWindow->SetOutputSizePixel( VCLSize( aSize ) );
|
|
}
|
|
}
|
|
|
|
::com::sun::star::awt::Size SAL_CALL VCLXWindow::getOutputSize( ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
Window *pWindow;
|
|
if( (pWindow = GetWindow()) != NULL )
|
|
{
|
|
DockingWindow *pDockingWindow = dynamic_cast< DockingWindow* >(pWindow);
|
|
if( pDockingWindow )
|
|
return AWTSize( pDockingWindow->GetOutputSizePixel() );
|
|
else
|
|
return AWTSize( pWindow->GetOutputSizePixel() );
|
|
}
|
|
else
|
|
return ::com::sun::star::awt::Size();
|
|
}
|
|
|
|
sal_Bool SAL_CALL VCLXWindow::isVisible( ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
if( GetWindow() )
|
|
return GetWindow()->IsVisible();
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
sal_Bool SAL_CALL VCLXWindow::isActive( ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
if( GetWindow() )
|
|
return GetWindow()->IsActive();
|
|
else
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
sal_Bool SAL_CALL VCLXWindow::isEnabled( ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
if( GetWindow() )
|
|
return GetWindow()->IsEnabled();
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
sal_Bool SAL_CALL VCLXWindow::hasFocus( ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
if( GetWindow() )
|
|
return GetWindow()->HasFocus();
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
// ::com::sun::star::beans::XPropertySetInfo
|
|
|
|
UnoPropertyArrayHelper *
|
|
VCLXWindow::GetPropHelper()
|
|
{
|
|
::vos::OGuard aGuard( GetMutex() );
|
|
if ( mpImpl->mpPropHelper == NULL )
|
|
{
|
|
std::list< sal_uInt16 > aIDs;
|
|
GetPropertyIds( aIDs );
|
|
mpImpl->mpPropHelper = new UnoPropertyArrayHelper( aIDs );
|
|
}
|
|
return mpImpl->mpPropHelper;
|
|
}
|
|
|
|
::com::sun::star::uno::Sequence< ::com::sun::star::beans::Property > SAL_CALL
|
|
VCLXWindow::getProperties() throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
return GetPropHelper()->getProperties();
|
|
}
|
|
::com::sun::star::beans::Property SAL_CALL
|
|
VCLXWindow::getPropertyByName( const ::rtl::OUString& rName ) throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::uno::RuntimeException)
|
|
{
|
|
return GetPropHelper()->getPropertyByName( rName );
|
|
}
|
|
|
|
::sal_Bool SAL_CALL
|
|
VCLXWindow::hasPropertyByName( const ::rtl::OUString& rName ) throw (::com::sun::star::uno::RuntimeException)
|
|
{
|
|
return GetPropHelper()->hasPropertyByName( rName );
|
|
}
|