forked from amazingfate/loongoffice
99ac0876bd
...rather than on the deprecated OComponentHelper. Various classes like BaseContainerControl, FrameControl, and ProgressBar, all deriving from BaseControl, had been found to implement their respective queryInterface in a way that is incompatible with the XAggregation protocol inherited via OComponentHelper. It looks like no code actually made use of the XAggregation offered by this class hierarchy, so the easiest fix for those queryInterface implementations appears to switch from OComponentHelper to WeakComponentImplHelper. Ideally, BaseControl would derive from WeakComponentImplHelper<XServiceInfo, XPaintListener, XWindowListener, ...> covering all the UNO interface classes from which it currently derives manually. But changing that manual implementation across the BaseControl class Hierarchy looks tricky, so merely introduce an "empty" WeakComponentImplHelper<> for now and keep all the manual stuff, and leave proper clean up for later. Change-Id: I1aa8b06f78700008f844415818f4a5801daa89b8 Reviewed-on: https://gerrit.libreoffice.org/c/core/+/145902 Tested-by: Jenkins Reviewed-by: Stephan Bergmann <sbergman@redhat.com>
721 lines
18 KiB
C++
721 lines
18 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include <basecontrol.hxx>
|
|
#include <multiplexer.hxx>
|
|
|
|
#include <com/sun/star/awt/XDevice.hpp>
|
|
#include <com/sun/star/awt/WindowAttribute.hpp>
|
|
#include <com/sun/star/awt/PosSize.hpp>
|
|
#include <com/sun/star/awt/Toolkit.hpp>
|
|
#include <cppuhelper/supportsservice.hxx>
|
|
#include <cppuhelper/queryinterface.hxx>
|
|
#include <cppuhelper/typeprovider.hxx>
|
|
|
|
// namespaces
|
|
|
|
using namespace ::cppu;
|
|
using namespace ::osl;
|
|
using namespace ::com::sun::star::uno;
|
|
using namespace ::com::sun::star::lang;
|
|
using namespace ::com::sun::star::awt;
|
|
|
|
namespace unocontrols {
|
|
|
|
constexpr sal_Int32 DEFAULT_X = 0;
|
|
constexpr sal_Int32 DEFAULT_Y = 0;
|
|
constexpr sal_Int32 DEFAULT_WIDTH = 100;
|
|
constexpr sal_Int32 DEFAULT_HEIGHT = 100;
|
|
constexpr bool DEFAULT_VISIBLE = false;
|
|
constexpr bool DEFAULT_INDESIGNMODE = false;
|
|
constexpr bool DEFAULT_ENABLE = true;
|
|
|
|
// construct/destruct
|
|
|
|
BaseControl::BaseControl( const Reference< XComponentContext >& rxContext )
|
|
: WeakComponentImplHelper ( m_aMutex )
|
|
, m_xComponentContext ( rxContext )
|
|
, m_nX ( DEFAULT_X )
|
|
, m_nY ( DEFAULT_Y )
|
|
, m_nWidth ( DEFAULT_WIDTH )
|
|
, m_nHeight ( DEFAULT_HEIGHT )
|
|
, m_bVisible ( DEFAULT_VISIBLE )
|
|
, m_bInDesignMode ( DEFAULT_INDESIGNMODE )
|
|
, m_bEnable ( DEFAULT_ENABLE )
|
|
{
|
|
}
|
|
|
|
BaseControl::~BaseControl()
|
|
{
|
|
}
|
|
|
|
// XInterface
|
|
|
|
Any SAL_CALL BaseControl::queryInterface( const Type& rType )
|
|
{
|
|
// Ask for my own supported interfaces ...
|
|
// Attention: XTypeProvider and XInterface are supported by WeakComponentImplHelper!
|
|
Any aReturn ( ::cppu::queryInterface( rType ,
|
|
static_cast< XPaintListener*> ( this ) ,
|
|
static_cast< XWindowListener*> ( this ) ,
|
|
static_cast< XView* > ( this ) ,
|
|
static_cast< XWindow* > ( this ) ,
|
|
static_cast< XServiceInfo* > ( this ) ,
|
|
static_cast< XControl* > ( this )
|
|
)
|
|
);
|
|
|
|
// If searched interface supported by this class ...
|
|
if ( aReturn.hasValue() )
|
|
{
|
|
// ... return this information.
|
|
return aReturn;
|
|
}
|
|
else
|
|
{
|
|
// Else; ... ask baseclass for interfaces!
|
|
return WeakComponentImplHelper::queryInterface( rType );
|
|
}
|
|
}
|
|
|
|
// XInterface
|
|
|
|
void SAL_CALL BaseControl::acquire() noexcept
|
|
{
|
|
// Attention:
|
|
// Don't use mutex or guard in this method!!! Is a method of XInterface.
|
|
|
|
// Forward to baseclass
|
|
WeakComponentImplHelper::acquire();
|
|
}
|
|
|
|
// XInterface
|
|
|
|
void SAL_CALL BaseControl::release() noexcept
|
|
{
|
|
// Attention:
|
|
// Don't use mutex or guard in this method!!! Is a method of XInterface.
|
|
|
|
// Forward to baseclass
|
|
WeakComponentImplHelper::release();
|
|
}
|
|
|
|
// XTypeProvider
|
|
|
|
Sequence< Type > SAL_CALL BaseControl::getTypes()
|
|
{
|
|
static OTypeCollection ourTypeCollection(
|
|
cppu::UnoType<XPaintListener>::get(),
|
|
cppu::UnoType<XWindowListener>::get(),
|
|
cppu::UnoType<XView>::get(),
|
|
cppu::UnoType<XWindow>::get(),
|
|
cppu::UnoType<XServiceInfo>::get(),
|
|
cppu::UnoType<XControl>::get(),
|
|
WeakComponentImplHelper::getTypes() );
|
|
|
|
return ourTypeCollection.getTypes();
|
|
}
|
|
|
|
// XTypeProvider
|
|
|
|
Sequence< sal_Int8 > SAL_CALL BaseControl::getImplementationId()
|
|
{
|
|
return css::uno::Sequence<sal_Int8>();
|
|
}
|
|
|
|
// XServiceInfo
|
|
|
|
OUString SAL_CALL BaseControl::getImplementationName()
|
|
{
|
|
return OUString();
|
|
}
|
|
|
|
// XServiceInfo
|
|
|
|
sal_Bool SAL_CALL BaseControl::supportsService( const OUString& sServiceName )
|
|
{
|
|
return cppu::supportsService(this, sServiceName);
|
|
}
|
|
|
|
// XServiceInfo
|
|
|
|
Sequence< OUString > SAL_CALL BaseControl::getSupportedServiceNames()
|
|
{
|
|
return Sequence< OUString >();
|
|
}
|
|
|
|
// XComponent
|
|
|
|
void SAL_CALL BaseControl::dispose()
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
|
|
if ( m_xMultiplexer.is() )
|
|
{
|
|
// to all other paint, focus, etc.
|
|
m_xMultiplexer->disposeAndClear();
|
|
}
|
|
|
|
// set the service manager to disposed
|
|
WeakComponentImplHelper::dispose();
|
|
|
|
// release context and peer
|
|
m_xContext.clear();
|
|
if ( m_xPeer.is() )
|
|
{
|
|
if ( m_xGraphicsPeer.is() )
|
|
{
|
|
removePaintListener( this );
|
|
removeWindowListener( this );
|
|
m_xGraphicsPeer.clear();
|
|
}
|
|
|
|
m_xPeer->dispose();
|
|
m_xPeerWindow.clear();
|
|
m_xPeer.clear();
|
|
|
|
if ( m_xMultiplexer.is() )
|
|
{
|
|
// take changes on multiplexer
|
|
m_xMultiplexer->setPeer( Reference< XWindow >() );
|
|
}
|
|
}
|
|
|
|
// release view
|
|
if ( m_xGraphicsView.is() )
|
|
{
|
|
m_xGraphicsView.clear();
|
|
}
|
|
}
|
|
|
|
// XComponent
|
|
|
|
void SAL_CALL BaseControl::addEventListener( const Reference< XEventListener >& xListener )
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
WeakComponentImplHelper::addEventListener( xListener );
|
|
}
|
|
|
|
// XComponent
|
|
|
|
void SAL_CALL BaseControl::removeEventListener( const Reference< XEventListener >& xListener )
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
WeakComponentImplHelper::removeEventListener( xListener );
|
|
}
|
|
|
|
// XControl
|
|
|
|
void SAL_CALL BaseControl::createPeer( const Reference< XToolkit >& xToolkit ,
|
|
const Reference< XWindowPeer >& xParentPeer )
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
|
|
if ( m_xPeer.is() )
|
|
return;
|
|
|
|
// use method "BaseControl::getWindowDescriptor()" to change window attributes!
|
|
WindowDescriptor aDescriptor = impl_getWindowDescriptor( xParentPeer );
|
|
|
|
if ( m_bVisible )
|
|
{
|
|
aDescriptor.WindowAttributes |= WindowAttribute::SHOW;
|
|
}
|
|
|
|
// very slow under remote conditions!
|
|
// create the window on the server
|
|
Reference< XToolkit > xLocalToolkit = xToolkit;
|
|
if ( !xLocalToolkit.is() )
|
|
{
|
|
// but first create well known toolkit, if it not exist
|
|
xLocalToolkit.set( Toolkit::create(m_xComponentContext), UNO_QUERY_THROW );
|
|
}
|
|
m_xPeer = xLocalToolkit->createWindow( aDescriptor );
|
|
m_xPeerWindow.set( m_xPeer, UNO_QUERY );
|
|
|
|
if ( !m_xPeerWindow.is() )
|
|
return;
|
|
|
|
if ( m_xMultiplexer.is() )
|
|
{
|
|
m_xMultiplexer->setPeer( m_xPeerWindow );
|
|
}
|
|
|
|
// create new reference to xgraphics for painting on a peer
|
|
// and add a paint listener
|
|
Reference< XDevice > xDevice( m_xPeerWindow, UNO_QUERY );
|
|
|
|
if ( xDevice.is() )
|
|
{
|
|
m_xGraphicsPeer = xDevice->createGraphics();
|
|
}
|
|
|
|
if ( m_xGraphicsPeer.is() )
|
|
{
|
|
addPaintListener( this );
|
|
addWindowListener( this );
|
|
}
|
|
|
|
m_xPeerWindow->setPosSize( m_nX, m_nY, m_nWidth, m_nHeight, PosSize::POSSIZE );
|
|
m_xPeerWindow->setEnable( m_bEnable );
|
|
m_xPeerWindow->setVisible( m_bVisible && !m_bInDesignMode );
|
|
}
|
|
|
|
// XControl
|
|
|
|
void SAL_CALL BaseControl::setContext( const Reference< XInterface >& xContext )
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
m_xContext = xContext;
|
|
}
|
|
|
|
// XControl
|
|
|
|
void SAL_CALL BaseControl::setDesignMode( sal_Bool bOn )
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
m_bInDesignMode = bOn;
|
|
}
|
|
|
|
// XControl
|
|
|
|
Reference< XInterface > SAL_CALL BaseControl::getContext()
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
return m_xContext;
|
|
}
|
|
|
|
// XControl
|
|
|
|
Reference< XWindowPeer > SAL_CALL BaseControl::getPeer()
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
return m_xPeer;
|
|
}
|
|
|
|
// XControl
|
|
|
|
Reference< XView > SAL_CALL BaseControl::getView()
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
return this;
|
|
}
|
|
|
|
// XControl
|
|
|
|
sal_Bool SAL_CALL BaseControl::isDesignMode()
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
return m_bInDesignMode;
|
|
}
|
|
|
|
// XControl
|
|
|
|
sal_Bool SAL_CALL BaseControl::isTransparent()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::setPosSize( sal_Int32 nX ,
|
|
sal_Int32 nY ,
|
|
sal_Int32 nWidth ,
|
|
sal_Int32 nHeight ,
|
|
sal_Int16 nFlags )
|
|
{
|
|
// - change size and position of window and save the values
|
|
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
|
|
bool bChanged = false;
|
|
|
|
if ( nFlags & PosSize::X )
|
|
{
|
|
bChanged |= m_nX != nX;
|
|
m_nX = nX;
|
|
}
|
|
|
|
if ( nFlags & PosSize::Y )
|
|
{
|
|
bChanged |= m_nY != nY;
|
|
m_nY = nY;
|
|
}
|
|
|
|
if ( nFlags & PosSize::WIDTH )
|
|
{
|
|
bChanged |= m_nWidth != nWidth;
|
|
m_nWidth = nWidth;
|
|
}
|
|
|
|
if ( nFlags & PosSize::HEIGHT )
|
|
{
|
|
bChanged |= m_nHeight != nHeight;
|
|
m_nHeight = nHeight;
|
|
}
|
|
|
|
if ( bChanged && m_xPeerWindow.is() )
|
|
{
|
|
m_xPeerWindow->setPosSize( m_nX, m_nY, m_nWidth, m_nHeight, nFlags );
|
|
}
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::setVisible( sal_Bool bVisible )
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
|
|
// Set new state of flag
|
|
m_bVisible = bVisible;
|
|
|
|
if ( m_xPeerWindow.is() )
|
|
{
|
|
// Set it also on peerwindow
|
|
m_xPeerWindow->setVisible( m_bVisible );
|
|
}
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::setEnable( sal_Bool bEnable )
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
|
|
// Set new state of flag
|
|
m_bEnable = bEnable;
|
|
|
|
if ( m_xPeerWindow.is() )
|
|
{
|
|
// Set it also on peerwindow
|
|
m_xPeerWindow->setEnable( m_bEnable );
|
|
}
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::setFocus()
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
|
|
if ( m_xPeerWindow.is() )
|
|
{
|
|
m_xPeerWindow->setFocus();
|
|
}
|
|
}
|
|
|
|
// XWindow
|
|
|
|
Rectangle SAL_CALL BaseControl::getPosSize()
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
return Rectangle( m_nX, m_nY , m_nWidth, m_nHeight );
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::addWindowListener( const Reference< XWindowListener >& xListener )
|
|
{
|
|
impl_getMultiplexer()->advise( cppu::UnoType<XWindowListener>::get(), xListener );
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::addFocusListener( const Reference< XFocusListener >& xListener )
|
|
{
|
|
impl_getMultiplexer()->advise( cppu::UnoType<XFocusListener>::get(), xListener );
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::addKeyListener( const Reference< XKeyListener >& xListener )
|
|
{
|
|
impl_getMultiplexer()->advise( cppu::UnoType<XKeyListener>::get(), xListener );
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::addMouseListener( const Reference< XMouseListener >& xListener )
|
|
{
|
|
impl_getMultiplexer()->advise( cppu::UnoType<XMouseListener>::get(), xListener );
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::addMouseMotionListener( const Reference< XMouseMotionListener >& xListener )
|
|
{
|
|
impl_getMultiplexer()->advise( cppu::UnoType<XMouseMotionListener>::get(), xListener );
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::addPaintListener( const Reference< XPaintListener >& xListener )
|
|
{
|
|
impl_getMultiplexer()->advise( cppu::UnoType<XPaintListener>::get(), xListener );
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::removeWindowListener( const Reference< XWindowListener >& xListener )
|
|
{
|
|
impl_getMultiplexer()->unadvise( cppu::UnoType<XWindowListener>::get(), xListener );
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::removeFocusListener( const Reference< XFocusListener >& xListener )
|
|
{
|
|
impl_getMultiplexer()->unadvise( cppu::UnoType<XFocusListener>::get(), xListener );
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::removeKeyListener( const Reference< XKeyListener >& xListener )
|
|
{
|
|
impl_getMultiplexer()->unadvise( cppu::UnoType<XKeyListener>::get(), xListener );
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::removeMouseListener( const Reference< XMouseListener >& xListener )
|
|
{
|
|
impl_getMultiplexer()->unadvise( cppu::UnoType<XMouseListener>::get(), xListener );
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::removeMouseMotionListener( const Reference< XMouseMotionListener >& xListener )
|
|
{
|
|
impl_getMultiplexer()->unadvise( cppu::UnoType<XMouseMotionListener>::get(), xListener );
|
|
}
|
|
|
|
// XWindow
|
|
|
|
void SAL_CALL BaseControl::removePaintListener( const Reference< XPaintListener >& xListener )
|
|
{
|
|
impl_getMultiplexer()->unadvise( cppu::UnoType<XPaintListener>::get(), xListener );
|
|
}
|
|
|
|
// XView
|
|
|
|
void SAL_CALL BaseControl::draw( sal_Int32 nX ,
|
|
sal_Int32 nY )
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
|
|
// - paint to a view
|
|
// - use the method "paint()"
|
|
// - see also "windowPaint()"
|
|
impl_paint( nX, nY, m_xGraphicsView );
|
|
}
|
|
|
|
// XView
|
|
|
|
sal_Bool SAL_CALL BaseControl::setGraphics( const Reference< XGraphics >& xDevice )
|
|
{
|
|
// - set the graphics for a view
|
|
// - in this class exist 2 graphics-member ... one for peer[_xGraphicsPeer] and one for view[_xGraphicsView]
|
|
// - they are used by "windowPaint() and draw()", forwarded to "paint ()"
|
|
bool bReturn = false;
|
|
if ( xDevice.is() )
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
|
|
m_xGraphicsView = xDevice;
|
|
bReturn = true;
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
// XView
|
|
|
|
void SAL_CALL BaseControl::setZoom( float /*fZoomX*/ ,
|
|
float /*fZoomY*/ )
|
|
{
|
|
// Not implemented yet
|
|
}
|
|
|
|
// XView
|
|
|
|
Reference< XGraphics > SAL_CALL BaseControl::getGraphics()
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
return m_xGraphicsView;
|
|
}
|
|
|
|
// XView
|
|
|
|
Size SAL_CALL BaseControl::getSize()
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
return Size( m_nWidth, m_nHeight );
|
|
}
|
|
|
|
// XEventListener
|
|
|
|
void SAL_CALL BaseControl::disposing( const EventObject& /*aSource*/ )
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
|
|
// - release ALL references
|
|
// - it must be !!!
|
|
if ( m_xGraphicsPeer.is() )
|
|
{
|
|
removePaintListener( this );
|
|
removeWindowListener( this );
|
|
m_xGraphicsPeer.clear();
|
|
}
|
|
|
|
if ( m_xGraphicsView.is() )
|
|
{
|
|
m_xGraphicsView.clear();
|
|
}
|
|
}
|
|
|
|
// XPaintListener
|
|
|
|
void SAL_CALL BaseControl::windowPaint( const PaintEvent& /*aEvent*/ )
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
|
|
// - repaint the peer
|
|
// - use the method "paint ()" for painting on a peer and a print device !!!
|
|
// - see also "draw ()"
|
|
impl_paint( 0, 0, m_xGraphicsPeer );
|
|
}
|
|
|
|
// XWindowListener
|
|
|
|
void SAL_CALL BaseControl::windowResized( const WindowEvent& aEvent )
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
|
|
m_nWidth = aEvent.Width;
|
|
m_nHeight = aEvent.Height;
|
|
WindowEvent aMappedEvent = aEvent;
|
|
aMappedEvent.X = 0;
|
|
aMappedEvent.Y = 0;
|
|
impl_recalcLayout( aMappedEvent );
|
|
}
|
|
|
|
// XWindowListener
|
|
|
|
void SAL_CALL BaseControl::windowMoved( const WindowEvent& aEvent )
|
|
{
|
|
// Ready for multithreading
|
|
MutexGuard aGuard( m_aMutex );
|
|
|
|
m_nWidth = aEvent.Width;
|
|
m_nHeight = aEvent.Height;
|
|
WindowEvent aMappedEvent = aEvent;
|
|
aMappedEvent.X = 0;
|
|
aMappedEvent.Y = 0;
|
|
impl_recalcLayout( aMappedEvent );
|
|
}
|
|
|
|
// XWindowListener
|
|
|
|
void SAL_CALL BaseControl::windowShown( const EventObject& /*aEvent*/ )
|
|
{
|
|
}
|
|
|
|
// XWindowListener
|
|
|
|
void SAL_CALL BaseControl::windowHidden( const EventObject& /*aEvent*/ )
|
|
{
|
|
}
|
|
|
|
// protected method
|
|
|
|
WindowDescriptor BaseControl::impl_getWindowDescriptor( const Reference< XWindowPeer >& xParentPeer )
|
|
{
|
|
// - used from "createPeer()" to set the values of a css::awt::WindowDescriptor !!!
|
|
// - if you will change the descriptor-values, you must override this virtual function
|
|
// - the caller must release the memory for this dynamical descriptor !!!
|
|
|
|
WindowDescriptor aDescriptor;
|
|
|
|
aDescriptor.Type = WindowClass_SIMPLE;
|
|
aDescriptor.WindowServiceName = "window";
|
|
aDescriptor.ParentIndex = -1;
|
|
aDescriptor.Parent = xParentPeer;
|
|
aDescriptor.Bounds = getPosSize ();
|
|
aDescriptor.WindowAttributes = 0;
|
|
|
|
return aDescriptor;
|
|
}
|
|
|
|
// protected method
|
|
|
|
void BaseControl::impl_paint( sal_Int32 /*nX*/ ,
|
|
sal_Int32 /*nY*/ ,
|
|
const Reference< XGraphics >& /*xGraphics*/ )
|
|
{
|
|
// - one paint method for peer AND view !!!
|
|
// (see also => "windowPaint()" and "draw()")
|
|
// - not used in this implementation, but it's not necessary to make it pure virtual !!!
|
|
}
|
|
|
|
// protected method
|
|
|
|
void BaseControl::impl_recalcLayout( const WindowEvent& /*aEvent*/ )
|
|
{
|
|
// We need as virtual function to support automatically resizing of derived controls!
|
|
// But we make it not pure virtual because it's not necessary for all derived classes!
|
|
}
|
|
|
|
// private method
|
|
|
|
OMRCListenerMultiplexerHelper* BaseControl::impl_getMultiplexer()
|
|
{
|
|
if ( !m_xMultiplexer.is() )
|
|
{
|
|
m_xMultiplexer = new OMRCListenerMultiplexerHelper( static_cast<XWindow*>(this), m_xPeerWindow );
|
|
}
|
|
|
|
return m_xMultiplexer.get();
|
|
}
|
|
|
|
} // namespace unocontrols
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|