/* -*- 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 <com/sun/star/awt/XVclContainerPeer.hpp>
#include <com/sun/star/beans/XPropertyChangeListener.hpp>
#include <com/sun/star/container/NoSuchElementException.hpp>
#include <com/sun/star/uno/XComponentContext.hpp>
#include <cppuhelper/typeprovider.hxx>
#include <cppuhelper/implbase.hxx>
#include <rtl/uuid.h>
#include <toolkit/controls/unocontrolcontainer.hxx>
#include <toolkit/helper/property.hxx>
#include <toolkit/helper/servicenames.hxx>
#include <comphelper/sequence.hxx>
#include <tools/debug.hxx>
#include <vcl/svapp.hxx>
#include <vcl/window.hxx>
#include <limits>
#include <map>
#include <memory>
#include <com/sun/star/awt/VclWindowPeerAttribute.hpp>
using namespace ::com::sun::star;
// class UnoControlHolder
struct UnoControlHolder
{
uno::Reference< awt::XControl > mxControl;
OUString msName;
public:
UnoControlHolder( const OUString& rName, const uno::Reference< awt::XControl > & rControl )
: mxControl( rControl ),
msName( rName )
{
}
const OUString& getName() const { return msName; }
const uno::Reference< awt::XControl >& getControl() const { return mxControl; }
};
class UnoControlHolderList
{
public:
typedef sal_Int32 ControlIdentifier;
private:
typedef std::shared_ptr< UnoControlHolder > ControlInfo;
typedef ::std::map< ControlIdentifier, ControlInfo > ControlMap;
private:
ControlMap maControls;
public:
UnoControlHolderList();
/** adds a control with the given name to the list
@param _rxControl
the control to add. Must not be <NULL/>
@param _pBName
the name of the control, or <NULL/> if an automatic name should be generated
@return
the identifier of the newly added control
*/
ControlIdentifier addControl( const uno::Reference< awt::XControl >& _rxControl, const OUString* _pName );
/** determines whether or not the list is empty
*/
bool empty() const { return maControls.empty(); }
/** retrieves all controls currently in the list
*/
void getControls( uno::Sequence< uno::Reference< awt::XControl > >& _out_rControls ) const;
/** retrieves all identifiers of all controls currently in the list
*/
void getIdentifiers( uno::Sequence< sal_Int32 >& _out_rIdentifiers ) const;
/** returns the first control which is registered under the given name
*/
uno::Reference< awt::XControl >
getControlForName( const OUString& _rName ) const;
/** returns the identifier which a control is registered for, or -1 if the control
isn't registered
*/
ControlIdentifier
getControlIdentifier( const uno::Reference< awt::XControl >& _rxControl );
/** retrieves the control for a given id
@param _nIdentifier
the identifier for the control
@param _out_rxControl
takes the XControl upon successful return
@return
<TRUE/> if and only if a control with the given id is part of the list
*/
bool getControlForIdentifier( ControlIdentifier _nIdentifier, uno::Reference< awt::XControl >& _out_rxControl ) const;
/** removes a control from the list, given by id
@param _nId
The identifier of the control to remove.
*/
void removeControlById( ControlIdentifier _nId );
/** replaces a control from the list with another one
@param _nId
The identifier of the control to replace
@param _rxNewControl
the new control to put into the list
*/
void replaceControlById( ControlIdentifier _nId, const uno::Reference< awt::XControl >& _rxNewControl );
private:
/** adds a control
@param _rxControl
the control to add to the container
@param _pName
pointer to the name of the control. Might be <NULL/>, in this case, a name is generated.
@return
the identifier of the newly inserted control
*/
ControlIdentifier impl_addControl(
const uno::Reference< awt::XControl >& _rxControl,
const OUString* _pName
);
/** finds a free identifier
@throw uno::RuntimeException
if no free identifier can be found
*/
ControlIdentifier impl_getFreeIdentifier_throw();
/** finds a free name
@throw uno::RuntimeException
if no free name can be found
*/
OUString impl_getFreeName_throw();
};
UnoControlHolderList::UnoControlHolderList()
{
}
UnoControlHolderList::ControlIdentifier UnoControlHolderList::addControl( const uno::Reference< awt::XControl >& _rxControl, const OUString* _pName )
{
return impl_addControl( _rxControl, _pName );
}
void UnoControlHolderList::getControls( uno::Sequence< uno::Reference< awt::XControl > >& _out_rControls ) const
{
_out_rControls.realloc( maControls.size() );
uno::Reference< awt::XControl >* pControls = _out_rControls.getArray();
for ( ControlMap::const_iterator loop = maControls.begin();
loop != maControls.end();
++loop, ++pControls
)
*pControls = loop->second->getControl();
}
void UnoControlHolderList::getIdentifiers( uno::Sequence< sal_Int32 >& _out_rIdentifiers ) const
{
_out_rIdentifiers.realloc( maControls.size() );
sal_Int32* pIndentifiers = _out_rIdentifiers.getArray();
for ( ControlMap::const_iterator loop = maControls.begin();
loop != maControls.end();
++loop, ++pIndentifiers
)
*pIndentifiers = loop->first;
}
uno::Reference< awt::XControl > UnoControlHolderList::getControlForName( const OUString& _rName ) const
{
for ( ControlMap::const_iterator loop = maControls.begin();
loop != maControls.end();
++loop
)
if ( loop->second->getName() == _rName )
return loop->second->getControl();
return uno::Reference< awt::XControl >();
}
UnoControlHolderList::ControlIdentifier UnoControlHolderList::getControlIdentifier( const uno::Reference< awt::XControl >& _rxControl )
{
for ( ControlMap::iterator loop = maControls.begin();
loop != maControls.end();
++loop
)
{
if ( loop->second->getControl().get() == _rxControl.get() )
return loop->first;
}
return -1;
}
bool UnoControlHolderList::getControlForIdentifier( UnoControlHolderList::ControlIdentifier _nIdentifier, uno::Reference< awt::XControl >& _out_rxControl ) const
{
ControlMap::const_iterator pos = maControls.find( _nIdentifier );
if ( pos == maControls.end() )
return false;
_out_rxControl = pos->second->getControl();
return true;
}
void UnoControlHolderList::removeControlById( UnoControlHolderList::ControlIdentifier _nId )
{
ControlMap::iterator pos = maControls.find( _nId );
DBG_ASSERT( pos != maControls.end(), "UnoControlHolderList::removeControlById: invalid id!" );
if ( pos == maControls.end() )
return;
maControls.erase( pos );
}
void UnoControlHolderList::replaceControlById( ControlIdentifier _nId, const uno::Reference< awt::XControl >& _rxNewControl )
{
DBG_ASSERT( _rxNewControl.is(), "UnoControlHolderList::replaceControlById: invalid new control!" );
ControlMap::iterator pos = maControls.find( _nId );
DBG_ASSERT( pos != maControls.end(), "UnoControlHolderList::replaceControlById: invalid id!" );
if ( pos == maControls.end() )
return;
pos->second.reset( new UnoControlHolder( pos->second->getName(), _rxNewControl ) );
}
UnoControlHolderList::ControlIdentifier UnoControlHolderList::impl_addControl( const uno::Reference< awt::XControl >& _rxControl, const OUString* _pName )
{
DBG_ASSERT( _rxControl.is(), "UnoControlHolderList::impl_addControl: invalid control!" );
OUString sName = _pName ? *_pName : impl_getFreeName_throw();
sal_Int32 nId = impl_getFreeIdentifier_throw();
maControls[ nId ] = std::make_shared<UnoControlHolder>( sName, _rxControl );
return nId;
}
UnoControlHolderList::ControlIdentifier UnoControlHolderList::impl_getFreeIdentifier_throw()
{
for ( ControlIdentifier candidateId = 0; candidateId < ::std::numeric_limits< ControlIdentifier >::max(); ++candidateId )
{
ControlMap::const_iterator existent = maControls.find( candidateId );
if ( existent == maControls.end() )
return candidateId;
}
throw uno::RuntimeException("out of identifiers" );
}
OUString UnoControlHolderList::impl_getFreeName_throw()
{
for ( ControlIdentifier candidateId = 0; candidateId < ::std::numeric_limits< ControlIdentifier >::max(); ++candidateId )
{
OUString candidateName( "control_" + OUString::number( candidateId ) );
ControlMap::const_iterator loop = maControls.begin();
for ( ; loop != maControls.end(); ++loop )
{
if ( loop->second->getName() == candidateName )
break;
}
if ( loop == maControls.end() )
return candidateName;
}
throw uno::RuntimeException("out of identifiers" );
}
// Function to set the controls' visibility according
// to the dialog's "Step" property
void implUpdateVisibility
(
sal_Int32 nDialogStep,
const uno::Reference< awt::XControlContainer >& xControlContainer
)
{
uno::Sequence< uno::Reference< awt::XControl > >
aCtrls = xControlContainer->getControls();
const uno::Reference< awt::XControl >* pCtrls = aCtrls.getConstArray();
sal_uInt32 nCtrls = aCtrls.getLength();
bool bCompleteVisible = (nDialogStep == 0);
for( sal_uInt32 n = 0; n < nCtrls; n++ )
{
uno::Reference< awt::XControl > xControl = pCtrls[ n ];
bool bVisible = bCompleteVisible;
if( !bVisible )
{
uno::Reference< awt::XControlModel > xModel( xControl->getModel() );
uno::Reference< beans::XPropertySet > xPSet
( xModel, uno::UNO_QUERY );
uno::Reference< beans::XPropertySetInfo >
xInfo = xPSet->getPropertySetInfo();
OUString aPropName( "Step" );
sal_Int32 nControlStep = 0;
if ( xInfo->hasPropertyByName( aPropName ) )
{
uno::Any aVal = xPSet->getPropertyValue( aPropName );
aVal >>= nControlStep;
}
bVisible = (nControlStep == 0) || (nControlStep == nDialogStep);
}
uno::Reference< awt::XWindow> xWindow
( xControl, uno::UNO_QUERY );
if( xWindow.is() )
xWindow->setVisible( bVisible );
}
}
// class DialogStepChangedListener
typedef ::cppu::WeakImplHelper< beans::XPropertyChangeListener > PropertyChangeListenerHelper;
class DialogStepChangedListener: public PropertyChangeListenerHelper
{
private:
uno::Reference< awt::XControlContainer > mxControlContainer;
public:
explicit DialogStepChangedListener( uno::Reference< awt::XControlContainer > const & xControlContainer )
: mxControlContainer( xControlContainer ) {}
// XEventListener
virtual void SAL_CALL disposing( const lang::EventObject& Source ) override;
// XPropertyChangeListener
virtual void SAL_CALL propertyChange( const beans::PropertyChangeEvent& evt ) override;
};
void SAL_CALL DialogStepChangedListener::disposing( const lang::EventObject& /*_rSource*/)
{
mxControlContainer.clear();
}
void SAL_CALL DialogStepChangedListener::propertyChange( const beans::PropertyChangeEvent& evt )
{
// evt.PropertyName HAS to be "Step" because we only use the listener for that
sal_Int32 nDialogStep = 0;
evt.NewValue >>= nDialogStep;
implUpdateVisibility( nDialogStep, mxControlContainer );
}
// class UnoControlContainer
UnoControlContainer::UnoControlContainer()
:UnoControlContainer_Base()
,maCListeners( *this )
{
mpControls.reset(new UnoControlHolderList);
}
UnoControlContainer::UnoControlContainer(const uno::Reference< awt::XWindowPeer >& xP )
:UnoControlContainer_Base()
,maCListeners( *this )
{
setPeer( xP );
mbDisposePeer = false;
mpControls.reset(new UnoControlHolderList);
}
UnoControlContainer::~UnoControlContainer()
{
}
void UnoControlContainer::ImplActivateTabControllers()
{
sal_uInt32 nCount = maTabControllers.getLength();
for ( sal_uInt32 n = 0; n < nCount; n++ )
{
maTabControllers.getArray()[n]->setContainer( this );
maTabControllers.getArray()[n]->activateTabOrder();
}
}
// lang::XComponent
void UnoControlContainer::dispose( )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
lang::EventObject aDisposeEvent;
aDisposeEvent.Source = static_cast< uno::XAggregation* >( this );
// Notify listeners about disposal of this Container (This is much faster if they
// listen on the controls and the container).
maDisposeListeners.disposeAndClear( aDisposeEvent );
maCListeners.disposeAndClear( aDisposeEvent );
uno::Sequence< uno::Reference< awt::XControl > > aCtrls = getControls();
for( uno::Reference< awt::XControl > const & control : aCtrls )
{
removingControl( control );
// Delete control
control->dispose();
}
// Delete all structures
mpControls.reset(new UnoControlHolderList);
UnoControlBase::dispose();
}
// lang::XEventListener
void UnoControlContainer::disposing( const lang::EventObject& _rEvt )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
uno::Reference< awt::XControl > xControl( _rEvt.Source, uno::UNO_QUERY );
if ( xControl.is() )
removeControl( xControl );
UnoControlBase::disposing( _rEvt );
}
// container::XContainer
void UnoControlContainer::addContainerListener( const uno::Reference< container::XContainerListener >& rxListener )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
maCListeners.addInterface( rxListener );
}
void UnoControlContainer::removeContainerListener( const uno::Reference< container::XContainerListener >& rxListener )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
maCListeners.removeInterface( rxListener );
}
::sal_Int32 SAL_CALL UnoControlContainer::insert( const uno::Any& _rElement )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
uno::Reference< awt::XControl > xControl;
if ( !( _rElement >>= xControl ) || !xControl.is() )
throw lang::IllegalArgumentException(
"Elements must support the XControl interface.",
*this,
1
);
return impl_addControl( xControl );
}
void SAL_CALL UnoControlContainer::removeByIdentifier( ::sal_Int32 _nIdentifier )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
uno::Reference< awt::XControl > xControl;
if ( !mpControls->getControlForIdentifier( _nIdentifier, xControl ) )
throw container::NoSuchElementException(
"There is no element with the given identifier.",
*this
);
impl_removeControl( _nIdentifier, xControl );
}
void SAL_CALL UnoControlContainer::replaceByIdentifer( ::sal_Int32 _nIdentifier, const uno::Any& _rElement )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
uno::Reference< awt::XControl > xExistentControl;
if ( !mpControls->getControlForIdentifier( _nIdentifier, xExistentControl ) )
throw container::NoSuchElementException(
"There is no element with the given identifier.",
*this
);
uno::Reference< awt::XControl > xNewControl;
if ( !( _rElement >>= xNewControl ) )
throw lang::IllegalArgumentException(
"Elements must support the XControl interface.",
*this,
1
);
removingControl( xExistentControl );
mpControls->replaceControlById( _nIdentifier, xNewControl );
addingControl( xNewControl );
impl_createControlPeerIfNecessary( xNewControl );
if ( maCListeners.getLength() )
{
container::ContainerEvent aEvent;
aEvent.Source = *this;
aEvent.Accessor <<= _nIdentifier;
aEvent.Element <<= xNewControl;
aEvent.ReplacedElement <<= xExistentControl;
maCListeners.elementReplaced( aEvent );
}
}
uno::Any SAL_CALL UnoControlContainer::getByIdentifier( ::sal_Int32 _nIdentifier )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
uno::Reference< awt::XControl > xControl;
if ( !mpControls->getControlForIdentifier( _nIdentifier, xControl ) )
throw container::NoSuchElementException();
return uno::makeAny( xControl );
}
uno::Sequence< ::sal_Int32 > SAL_CALL UnoControlContainer::getIdentifiers( )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
uno::Sequence< ::sal_Int32 > aIdentifiers;
mpControls->getIdentifiers( aIdentifiers );
return aIdentifiers;
}
// container::XElementAccess
uno::Type SAL_CALL UnoControlContainer::getElementType( )
{
return cppu::UnoType<awt::XControlModel>::get();
}
sal_Bool SAL_CALL UnoControlContainer::hasElements( )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
return !mpControls->empty();
}
// awt::XControlContainer
void UnoControlContainer::setStatusText( const OUString& rStatusText )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
// Descend the parent hierarchy
uno::Reference< awt::XControlContainer > xContainer( mxContext, uno::UNO_QUERY );
if( xContainer.is() )
xContainer->setStatusText( rStatusText );
}
uno::Sequence< uno::Reference< awt::XControl > > UnoControlContainer::getControls( )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
uno::Sequence< uno::Reference< awt::XControl > > aControls;
mpControls->getControls( aControls );
return aControls;
}
uno::Reference< awt::XControl > UnoControlContainer::getControl( const OUString& rName )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
return mpControls->getControlForName( rName );
}
void UnoControlContainer::addingControl( const uno::Reference< awt::XControl >& _rxControl )
{
if ( _rxControl.is() )
{
uno::Reference< uno::XInterface > xThis;
OWeakAggObject::queryInterface( cppu::UnoType<uno::XInterface>::get() ) >>= xThis;
_rxControl->setContext( xThis );
_rxControl->addEventListener( this );
}
}
void UnoControlContainer::impl_createControlPeerIfNecessary( const uno::Reference< awt::XControl >& _rxControl )
{
OSL_PRECOND( _rxControl.is(), "UnoControlContainer::impl_createControlPeerIfNecessary: invalid control, this will crash!" );
// if the container already has a peer, then also create a peer for the control
uno::Reference< awt::XWindowPeer > xMyPeer( getPeer() );
if( xMyPeer.is() )
{
_rxControl->createPeer( nullptr, xMyPeer );
ImplActivateTabControllers();
}
}
sal_Int32 UnoControlContainer::impl_addControl( const uno::Reference< awt::XControl >& _rxControl, const OUString* _pName )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
UnoControlHolderList::ControlIdentifier id = mpControls->addControl( _rxControl, _pName );
addingControl( _rxControl );
impl_createControlPeerIfNecessary( _rxControl );
if ( maCListeners.getLength() )
{
container::ContainerEvent aEvent;
aEvent.Source = *this;
_pName ? ( aEvent.Accessor <<= *_pName ) : ( aEvent.Accessor <<= static_cast<sal_Int32>(id) );
aEvent.Element <<= _rxControl;
maCListeners.elementInserted( aEvent );
}
return id;
}
void UnoControlContainer::addControl( const OUString& rName, const uno::Reference< awt::XControl >& rControl )
{
if ( rControl.is() )
impl_addControl( rControl, &rName );
}
void UnoControlContainer::removingControl( const uno::Reference< awt::XControl >& _rxControl )
{
if ( _rxControl.is() )
{
_rxControl->removeEventListener( this );
_rxControl->setContext( nullptr );
}
}
void UnoControlContainer::impl_removeControl( sal_Int32 _nId, const uno::Reference< awt::XControl >& _rxControl )
{
#ifdef DBG_UTIL
{
uno::Reference< awt::XControl > xControl;
bool bHas = mpControls->getControlForIdentifier( _nId, xControl );
DBG_ASSERT( bHas && xControl == _rxControl, "UnoControlContainer::impl_removeControl: inconsistency in the parameters!" );
}
#endif
removingControl( _rxControl );
mpControls->removeControlById( _nId );
if ( maCListeners.getLength() )
{
container::ContainerEvent aEvent;
aEvent.Source = *this;
aEvent.Accessor <<= _nId;
aEvent.Element <<= _rxControl;
maCListeners.elementRemoved( aEvent );
}
}
void UnoControlContainer::removeControl( const uno::Reference< awt::XControl >& _rxControl )
{
if ( _rxControl.is() )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
UnoControlHolderList::ControlIdentifier id = mpControls->getControlIdentifier( _rxControl );
if ( id != -1 )
impl_removeControl( id, _rxControl );
}
}
// awt::XUnoControlContainer
void UnoControlContainer::setTabControllers( const uno::Sequence< uno::Reference< awt::XTabController > >& TabControllers )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
maTabControllers = TabControllers;
}
uno::Sequence< uno::Reference< awt::XTabController > > UnoControlContainer::getTabControllers( )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
return maTabControllers;
}
void UnoControlContainer::addTabController( const uno::Reference< awt::XTabController >& TabController )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
sal_uInt32 nCount = maTabControllers.getLength();
maTabControllers.realloc( nCount + 1 );
maTabControllers[ nCount ] = TabController;
}
void UnoControlContainer::removeTabController( const uno::Reference< awt::XTabController >& TabController )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
sal_uInt32 nCount = maTabControllers.getLength();
const uno::Reference< awt::XTabController >* pLoop = maTabControllers.getConstArray();
for ( sal_uInt32 n = 0; n < nCount; ++n, ++pLoop )
{
if( pLoop->get() == TabController.get() )
{
::comphelper::removeElementAt( maTabControllers, n );
break;
}
}
}
// awt::XControl
void UnoControlContainer::createPeer( const uno::Reference< awt::XToolkit >& rxToolkit, const uno::Reference< awt::XWindowPeer >& rParent )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
if( !getPeer().is() )
{
bool bVis = maComponentInfos.bVisible;
if( bVis )
UnoControl::setVisible( false );
// Create a new peer
UnoControl::createPeer( rxToolkit, rParent );
// Create all children's peers
if ( !mbCreatingCompatiblePeer )
{
// Evaluate "Step" property
uno::Reference< awt::XControlModel > xModel( getModel() );
uno::Reference< beans::XPropertySet > xPSet
( xModel, uno::UNO_QUERY );
uno::Reference< beans::XPropertySetInfo >
xInfo = xPSet->getPropertySetInfo();
OUString aPropName( "Step" );
if ( xInfo->hasPropertyByName( aPropName ) )
{
css::uno::Any aVal = xPSet->getPropertyValue( aPropName );
sal_Int32 nDialogStep = 0;
aVal >>= nDialogStep;
uno::Reference< awt::XControlContainer > xContainer =
static_cast< awt::XControlContainer* >(this);
implUpdateVisibility( nDialogStep, xContainer );
uno::Reference< beans::XPropertyChangeListener > xListener =
static_cast< beans::XPropertyChangeListener* >(
new DialogStepChangedListener( xContainer ) );
xPSet->addPropertyChangeListener( aPropName, xListener );
}
uno::Sequence< uno::Reference< awt::XControl > > aCtrls = getControls();
sal_uInt32 nCtrls = aCtrls.getLength();
for( sal_uInt32 n = 0; n < nCtrls; n++ )
aCtrls.getArray()[n]->createPeer( rxToolkit, getPeer() );
uno::Reference< awt::XVclContainerPeer > xC( getPeer(), uno::UNO_QUERY );
if ( xC.is() )
xC->enableDialogControl( true );
ImplActivateTabControllers();
}
if( bVis && !isDesignMode() )
UnoControl::setVisible( true );
}
}
// awt::XWindow
void UnoControlContainer::setVisible( sal_Bool bVisible )
{
::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
UnoControl::setVisible( bVisible );
if( !mxContext.is() && bVisible )
// This is a Topwindow, thus show it automatically
createPeer( uno::Reference< awt::XToolkit > (), uno::Reference< awt::XWindowPeer > () );
}
OUString UnoControlContainer::getImplementationName()
{
return OUString("stardiv.Toolkit.UnoControlContainer");
}
css::uno::Sequence<OUString> UnoControlContainer::getSupportedServiceNames()
{
auto s(UnoControlBase::getSupportedServiceNames());
s.realloc(s.getLength() + 2);
s[s.getLength() - 2] = "com.sun.star.awt.UnoControlContainer";
s[s.getLength() - 1] = "stardiv.vcl.control.ControlContainer";
return s;
}
void UnoControlContainer::PrepareWindowDescriptor( css::awt::WindowDescriptor& rDesc )
{
// HACK due to the fact that we can't really use VSCROLL & HSCROLL
// for Dialog ( css::awt::VclWindowPeerAttribute::VSCROLL
// has the same value as
// css::awt::WindowAttribute::NODECORATION )
// For convenience in the PropBrowse using HSCROLL and VSCROLL ensures
// the Correct text. We exchange them here and the control knows
// about this hack ( it sucks badly I know )
if ( rDesc.WindowAttributes & css::awt::VclWindowPeerAttribute::VSCROLL )
{
rDesc.WindowAttributes &= ~css::awt::VclWindowPeerAttribute::VSCROLL;
rDesc.WindowAttributes |= css::awt::VclWindowPeerAttribute::AUTOVSCROLL;
}
if ( rDesc.WindowAttributes & css::awt::VclWindowPeerAttribute::HSCROLL )
{
rDesc.WindowAttributes &= ~css::awt::VclWindowPeerAttribute::HSCROLL;
rDesc.WindowAttributes |= css::awt::VclWindowPeerAttribute::AUTOHSCROLL;
}
}
extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
stardiv_Toolkit_UnoControlContainer_get_implementation(
css::uno::XComponentContext *,
css::uno::Sequence<css::uno::Any> const &)
{
return cppu::acquire(new UnoControlContainer());
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V572 It is odd that the object which was created using 'new' operator is immediately cast to another type.