fcbefea017
Conflicts: framework/inc/dispatch/oxt_handler.hxx framework/inc/services/layoutmanager.hxx framework/inc/tabwin/tabwindow.hxx framework/source/dispatch/menudispatcher.cxx framework/source/helper/dockingareadefaultacceptor.cxx framework/source/helper/ocomponentaccess.cxx framework/source/helper/ocomponentenumeration.cxx framework/source/helper/oframes.cxx framework/source/layoutmanager/toolbarlayoutmanager.hxx framework/source/recording/dispatchrecorder.cxx framework/source/services/desktop.cxx framework/source/services/frame.cxx framework/source/services/urltransformer.cxx Change-Id: Ibb04e3f6f0796e7f2be16dcce38542f8b90708d4 Reviewed-on: https://gerrit.libreoffice.org/8265 Reviewed-by: Caolán McNamara <caolanm@redhat.com> Tested-by: Caolán McNamara <caolanm@redhat.com>
956 lines
38 KiB
C++
956 lines
38 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 <tabwin/tabwindow.hxx>
|
|
#include <properties.h>
|
|
|
|
#include <threadhelp/resetableguard.hxx>
|
|
|
|
#include <com/sun/star/util/XURLTransformer.hpp>
|
|
#include <com/sun/star/awt/Toolkit.hpp>
|
|
#include <com/sun/star/awt/PosSize.hpp>
|
|
#include <com/sun/star/awt/WindowDescriptor.hpp>
|
|
#include <com/sun/star/beans/PropertyAttribute.hpp>
|
|
#include <com/sun/star/lang/DisposedException.hpp>
|
|
|
|
#include <rtl/ustrbuf.hxx>
|
|
#include <vcl/svapp.hxx>
|
|
#include <vcl/window.hxx>
|
|
#include <vcl/wrkwin.hxx>
|
|
#include <toolkit/helper/vclunohelper.hxx>
|
|
#include <comphelper/sequenceashashmap.hxx>
|
|
|
|
|
|
// Defines
|
|
|
|
|
|
using namespace com::sun::star;
|
|
|
|
namespace framework
|
|
{
|
|
|
|
|
|
// XInterface, XTypeProvider, XServiceInfo
|
|
|
|
DEFINE_XINTERFACE_11 ( TabWindow ,
|
|
::cppu::OWeakObject ,
|
|
DIRECT_INTERFACE( css::lang::XTypeProvider ),
|
|
DIRECT_INTERFACE( css::lang::XServiceInfo ),
|
|
DIRECT_INTERFACE( css::lang::XInitialization ),
|
|
DIRECT_INTERFACE( css::lang::XComponent ),
|
|
DIRECT_INTERFACE( css::awt::XWindowListener ),
|
|
DIRECT_INTERFACE( css::awt::XTopWindowListener ),
|
|
DIRECT_INTERFACE( css::awt::XSimpleTabController ),
|
|
DERIVED_INTERFACE( css::lang::XEventListener, css::awt::XWindowListener ),
|
|
DIRECT_INTERFACE( css::beans::XMultiPropertySet ),
|
|
DIRECT_INTERFACE( css::beans::XFastPropertySet ),
|
|
DIRECT_INTERFACE( css::beans::XPropertySet )
|
|
)
|
|
|
|
DEFINE_XTYPEPROVIDER_11 ( TabWindow ,
|
|
css::lang::XTypeProvider ,
|
|
css::lang::XServiceInfo ,
|
|
css::lang::XInitialization ,
|
|
css::lang::XComponent ,
|
|
css::awt::XWindowListener ,
|
|
css::awt::XTopWindowListener ,
|
|
css::awt::XSimpleTabController ,
|
|
css::lang::XEventListener ,
|
|
css::beans::XMultiPropertySet ,
|
|
css::beans::XFastPropertySet ,
|
|
css::beans::XPropertySet
|
|
)
|
|
|
|
PRIVATE_DEFINE_XSERVICEINFO_BASE ( TabWindow ,
|
|
::cppu::OWeakObject ,
|
|
SERVICENAME_TABWINDOW ,
|
|
IMPLEMENTATIONNAME_TABWINDOW
|
|
)
|
|
|
|
DEFINE_INIT_SERVICE ( TabWindow, {} )
|
|
|
|
TabWindow::TabWindow( const css::uno::Reference< css::uno::XComponentContext >& xContext ) :
|
|
ThreadHelpBase( &Application::GetSolarMutex() )
|
|
, ::cppu::OBroadcastHelperVar< ::cppu::OMultiTypeInterfaceContainerHelper, ::cppu::OMultiTypeInterfaceContainerHelper::keyType >( m_aLock.getShareableOslMutex() )
|
|
, ::cppu::OPropertySetHelper ( *(static_cast< ::cppu::OBroadcastHelper* >(this)) )
|
|
, m_bInitialized( sal_False )
|
|
, m_bDisposed( sal_False )
|
|
, m_nNextTabID( 1 )
|
|
, m_aTitlePropName( "Title" )
|
|
, m_aPosPropName( "Position" )
|
|
, m_xContext( xContext )
|
|
, m_aListenerContainer( m_aLock.getShareableOslMutex() )
|
|
{
|
|
}
|
|
|
|
TabWindow::~TabWindow()
|
|
{
|
|
}
|
|
|
|
|
|
// Helper
|
|
|
|
|
|
void TabWindow::implts_LayoutWindows() const
|
|
{
|
|
const sal_Int32 nTabControlHeight = 30;
|
|
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
css::uno::Reference< css::awt::XDevice > xDevice( m_xTopWindow, css::uno::UNO_QUERY );
|
|
css::uno::Reference< css::awt::XWindow > xWindow( m_xTopWindow, css::uno::UNO_QUERY );
|
|
css::uno::Reference< css::awt::XWindow > xTabControlWindow( m_xTabControlWindow );
|
|
css::uno::Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow );
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
// Convert relativ size to output size.
|
|
if ( xWindow.is() && xDevice.is() )
|
|
{
|
|
css::awt::Rectangle aRectangle = xWindow->getPosSize();
|
|
css::awt::DeviceInfo aInfo = xDevice->getInfo();
|
|
css::awt::Size aSize ( aRectangle.Width - aInfo.LeftInset - aInfo.RightInset ,
|
|
aRectangle.Height - aInfo.TopInset - aInfo.BottomInset );
|
|
|
|
css::awt::Size aContainerWindowSize;
|
|
css::awt::Size aTabControlSize;
|
|
|
|
aContainerWindowSize.Width = aSize.Width;
|
|
aTabControlSize.Width = aSize.Width;
|
|
|
|
aContainerWindowSize.Height = std::max( sal_Int32( 0 ), aSize.Height - nTabControlHeight );
|
|
aTabControlSize.Height = nTabControlHeight;
|
|
|
|
xContainerWindow->setPosSize( 0, 0,
|
|
aContainerWindowSize.Width, aContainerWindowSize.Height,
|
|
css::awt::PosSize::POSSIZE );
|
|
xTabControlWindow->setPosSize( 0, std::max( nTabControlHeight, sal_Int32( aSize.Height - nTabControlHeight)),
|
|
aTabControlSize.Width, aTabControlSize.Height,
|
|
css::awt::PosSize::POSSIZE );
|
|
}
|
|
}
|
|
|
|
TabControl* TabWindow::impl_GetTabControl( const css::uno::Reference< css::awt::XWindow >& rTabControlWindow ) const
|
|
{
|
|
Window* pWindow = VCLUnoHelper::GetWindow( rTabControlWindow );
|
|
if ( pWindow )
|
|
return (TabControl *)pWindow;
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
void TabWindow::impl_SetTitle( const OUString& rTitle )
|
|
{
|
|
if ( m_xTopWindow.is() )
|
|
{
|
|
Window* pWindow = VCLUnoHelper::GetWindow(
|
|
css::uno::Reference< css::awt::XWindow >(
|
|
m_xTopWindow, css::uno::UNO_QUERY ));
|
|
if ( pWindow )
|
|
pWindow->SetText( rTitle );
|
|
}
|
|
}
|
|
|
|
void TabWindow::implts_SendNotification( Notification eNotify, sal_Int32 ID ) const
|
|
{
|
|
::cppu::OInterfaceContainerHelper* pContainer = m_aListenerContainer.getContainer(
|
|
::getCppuType( ( const css::uno::Reference< css::awt::XTabListener >*) NULL ) );
|
|
if (pContainer!=NULL)
|
|
{
|
|
::cppu::OInterfaceIteratorHelper pIterator(*pContainer);
|
|
while (pIterator.hasMoreElements())
|
|
{
|
|
try
|
|
{
|
|
switch ( eNotify )
|
|
{
|
|
case NOTIFY_INSERTED:
|
|
((css::awt::XTabListener*)pIterator.next())->inserted( ID );
|
|
break;
|
|
case NOTIFY_REMOVED:
|
|
((css::awt::XTabListener*)pIterator.next())->removed( ID );
|
|
break;
|
|
case NOTIFY_ACTIVATED:
|
|
((css::awt::XTabListener*)pIterator.next())->activated( ID );
|
|
break;
|
|
case NOTIFY_DEACTIVATED:
|
|
((css::awt::XTabListener*)pIterator.next())->deactivated( ID );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
catch( const css::uno::RuntimeException& )
|
|
{
|
|
pIterator.remove();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void TabWindow::implts_SendNotification( Notification eNotify, sal_Int32 ID, const css::uno::Sequence< css::beans::NamedValue >& rSeq ) const
|
|
{
|
|
::cppu::OInterfaceContainerHelper* pContainer = m_aListenerContainer.getContainer(
|
|
::getCppuType( ( const css::uno::Reference< css::awt::XTabListener >*) NULL ) );
|
|
if (pContainer!=NULL)
|
|
{
|
|
::cppu::OInterfaceIteratorHelper pIterator(*pContainer);
|
|
while (pIterator.hasMoreElements())
|
|
{
|
|
try
|
|
{
|
|
switch ( eNotify )
|
|
{
|
|
case NOTIFY_CHANGED:
|
|
((css::awt::XTabListener*)pIterator.next())->changed( ID, rSeq );
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
catch( const css::uno::RuntimeException& )
|
|
{
|
|
pIterator.remove();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Links
|
|
|
|
|
|
IMPL_LINK( TabWindow, Activate, TabControl*, pTabControl )
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
|
|
sal_Int32 nPageId = pTabControl->GetCurPageId();
|
|
|
|
OUString aTitle = pTabControl->GetPageText( sal_uInt16( nPageId ));
|
|
impl_SetTitle( aTitle );
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
implts_SendNotification( NOTIFY_ACTIVATED, nPageId );
|
|
|
|
return 1;
|
|
}
|
|
|
|
IMPL_LINK( TabWindow, Deactivate, TabControl*, pTabControl )
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
sal_Int32 nPageId = pTabControl->GetCurPageId();
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
implts_SendNotification( NOTIFY_DEACTIVATED, nPageId );
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
// XInitilization
|
|
|
|
|
|
void SAL_CALL TabWindow::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
|
|
throw (css::uno::Exception, css::uno::RuntimeException, std::exception)
|
|
{
|
|
const OUString aTopWindowArgName( "TopWindow" );
|
|
const OUString aSizeArgName( "Size" );
|
|
|
|
css::awt::Size aDefaultSize( 500, 500 );
|
|
css::awt::Size aSize( aDefaultSize );
|
|
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
sal_Bool bInitalized( m_bInitialized );
|
|
css::uno::Reference< css::uno::XComponentContext > xContext( m_xContext );
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
if ( !bInitalized )
|
|
{
|
|
css::beans::PropertyValue aPropValue;
|
|
css::uno::Reference< css::awt::XTopWindow > xTopWindow;
|
|
css::uno::Reference< css::awt::XToolkit2 > xToolkit;
|
|
css::awt::WindowDescriptor aDescriptor;
|
|
|
|
if ( xContext.is() )
|
|
{
|
|
try
|
|
{
|
|
xToolkit = css::awt::Toolkit::create( xContext );
|
|
}
|
|
catch ( const css::uno::RuntimeException& )
|
|
{
|
|
throw;
|
|
}
|
|
catch ( const css::uno::Exception& )
|
|
{
|
|
}
|
|
}
|
|
|
|
for ( int i = 0; i < aArguments.getLength(); i++ )
|
|
{
|
|
if ( aArguments[i] >>= aPropValue )
|
|
{
|
|
if ( aPropValue.Name == aTopWindowArgName )
|
|
aPropValue.Value >>= xTopWindow;
|
|
else if ( aPropValue.Name == aSizeArgName )
|
|
{
|
|
aPropValue.Value >>= aSize;
|
|
if ( aSize.Width <= 0 )
|
|
aSize.Width = aDefaultSize.Width;
|
|
if ( aSize.Height <= 0 )
|
|
aSize.Height = aDefaultSize.Height;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( xToolkit.is() )
|
|
{
|
|
if ( !xTopWindow.is() )
|
|
{
|
|
// describe top window properties.
|
|
aDescriptor.Type = css::awt::WindowClass_TOP;
|
|
aDescriptor.ParentIndex = -1;
|
|
aDescriptor.Parent = css::uno::Reference< css::awt::XWindowPeer >();
|
|
aDescriptor.Bounds = css::awt::Rectangle( 0, 0, aSize.Width, aSize.Height );
|
|
aDescriptor.WindowAttributes = 0;
|
|
|
|
try
|
|
{
|
|
xTopWindow = css::uno::Reference< css::awt::XTopWindow >( xToolkit->createWindow( aDescriptor ), css::uno::UNO_QUERY );
|
|
}
|
|
catch ( const css::uno::RuntimeException& )
|
|
{
|
|
throw;
|
|
}
|
|
catch ( const css::uno::Exception& )
|
|
{
|
|
}
|
|
}
|
|
|
|
if ( xTopWindow.is() )
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
aLock.lock();
|
|
m_bInitialized = sal_True;
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
css::uno::Reference< css::awt::XWindow > xWindow( xTopWindow, css::uno::UNO_QUERY );
|
|
xWindow->addWindowListener( css::uno::Reference< css::awt::XWindowListener >(
|
|
static_cast< ::cppu::OWeakObject* >( this ), css::uno::UNO_QUERY_THROW ));
|
|
|
|
xTopWindow->addTopWindowListener( css::uno::Reference< css::awt::XTopWindowListener >(
|
|
static_cast< ::cppu::OWeakObject* >( this ), css::uno::UNO_QUERY_THROW ));
|
|
|
|
css::uno::Reference< css::awt::XWindow > xContainerWindow;
|
|
css::uno::Reference< css::awt::XWindow > xTabControl;
|
|
|
|
// describe container window properties.
|
|
aDescriptor.Type = css::awt::WindowClass_SIMPLE;
|
|
aDescriptor.ParentIndex = -1;
|
|
aDescriptor.Parent = css::uno::Reference< css::awt::XWindowPeer >( xTopWindow, css::uno::UNO_QUERY );
|
|
aDescriptor.Bounds = css::awt::Rectangle(0,0,0,0);
|
|
aDescriptor.WindowAttributes = 0;
|
|
|
|
xContainerWindow = css::uno::Reference< css::awt::XWindow >( xToolkit->createWindow( aDescriptor ), css::uno::UNO_QUERY );
|
|
|
|
// create a tab control window properties
|
|
aDescriptor.Type = css::awt::WindowClass_SIMPLE;
|
|
aDescriptor.WindowServiceName = "tabcontrol";
|
|
aDescriptor.ParentIndex = -1;
|
|
aDescriptor.Parent = css::uno::Reference< css::awt::XWindowPeer >( xTopWindow, css::uno::UNO_QUERY );
|
|
aDescriptor.Bounds = css::awt::Rectangle( 0,0,0,0 );
|
|
aDescriptor.WindowAttributes = 0;
|
|
|
|
xTabControl = css::uno::Reference< css::awt::XWindow >( xToolkit->createWindow( aDescriptor ), css::uno::UNO_QUERY );
|
|
|
|
if ( xContainerWindow.is() && xTabControl.is() )
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
aLock.lock();
|
|
m_xTopWindow = xTopWindow;
|
|
m_xContainerWindow = xContainerWindow;
|
|
m_xTabControlWindow = xTabControl;
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
xWindow->setPosSize( 0, 0, aSize.Width, aSize.Height, css::awt::PosSize::POSSIZE );
|
|
|
|
SolarMutexGuard aGuard;
|
|
Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
|
|
if( pWindow )
|
|
pWindow->Show( true );
|
|
|
|
pWindow = VCLUnoHelper::GetWindow( xContainerWindow );
|
|
if ( pWindow )
|
|
pWindow->Show( true, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
|
|
|
|
pWindow = VCLUnoHelper::GetWindow( xTabControl );
|
|
if ( pWindow )
|
|
{
|
|
pWindow->Show( true, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
|
|
TabControl* pTabControl = (TabControl *)pWindow;
|
|
pTabControl->SetActivatePageHdl( LINK( this, TabWindow, Activate ));
|
|
pTabControl->SetDeactivatePageHdl( LINK( this, TabWindow, Deactivate ));
|
|
}
|
|
|
|
implts_LayoutWindows();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// XComponent
|
|
|
|
void SAL_CALL TabWindow::dispose() throw (css::uno::RuntimeException, std::exception)
|
|
{
|
|
// Send message to all listener and forget her references.
|
|
css::uno::Reference< css::lang::XComponent > xThis(
|
|
static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY );
|
|
css::lang::EventObject aEvent( xThis );
|
|
|
|
m_aListenerContainer.disposeAndClear( aEvent );
|
|
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
css::uno::Reference< css::awt::XWindow > xTabControlWindow( m_xTabControlWindow );
|
|
css::uno::Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow );
|
|
css::uno::Reference< css::awt::XTopWindow > xTopWindow( m_xTopWindow );
|
|
m_xTabControlWindow.clear();
|
|
m_xContainerWindow.clear();
|
|
m_xTopWindow.clear();
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
css::uno::Reference< css::lang::XComponent > xComponent( xTabControlWindow, css::uno::UNO_QUERY );
|
|
if ( xComponent.is() )
|
|
xComponent->dispose();
|
|
|
|
xComponent = css::uno::Reference< css::lang::XComponent >( xContainerWindow, css::uno::UNO_QUERY );
|
|
if ( xComponent.is() )
|
|
xComponent->dispose();
|
|
|
|
xComponent = css::uno::Reference< css::lang::XComponent >( xTopWindow, css::uno::UNO_QUERY );
|
|
if ( xComponent.is() )
|
|
xComponent->dispose();
|
|
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
aLock.lock();
|
|
m_bDisposed = sal_True;
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
}
|
|
|
|
void SAL_CALL TabWindow::addEventListener( const css::uno::Reference< css::lang::XEventListener >& xListener )
|
|
throw (css::uno::RuntimeException, std::exception)
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
if ( m_bDisposed )
|
|
return;
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
m_aListenerContainer.addInterface( ::getCppuType( ( const css::uno::Reference< css::lang::XEventListener >* ) NULL ), xListener );
|
|
}
|
|
|
|
void SAL_CALL TabWindow::removeEventListener( const css::uno::Reference< css::lang::XEventListener >& xListener )
|
|
throw (css::uno::RuntimeException, std::exception)
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
if ( m_bDisposed )
|
|
return;
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
m_aListenerContainer.removeInterface( ::getCppuType( ( const css::uno::Reference< css::lang::XEventListener >* ) NULL ), xListener );
|
|
}
|
|
|
|
|
|
// XEventListener
|
|
|
|
void SAL_CALL TabWindow::disposing( const css::lang::EventObject& )
|
|
throw( css::uno::RuntimeException, std::exception )
|
|
{
|
|
}
|
|
|
|
|
|
// XWindowListener
|
|
|
|
void SAL_CALL TabWindow::windowResized( const css::awt::WindowEvent& )
|
|
throw( css::uno::RuntimeException, std::exception )
|
|
{
|
|
implts_LayoutWindows();
|
|
}
|
|
|
|
void SAL_CALL TabWindow::windowMoved( const css::awt::WindowEvent& )
|
|
throw( css::uno::RuntimeException, std::exception )
|
|
{
|
|
}
|
|
|
|
void SAL_CALL TabWindow::windowShown( const css::lang::EventObject& )
|
|
throw( css::uno::RuntimeException, std::exception )
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
|
|
TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
|
|
if ( pTabControl )
|
|
pTabControl->Show();
|
|
|
|
if ( m_xContainerWindow.is() )
|
|
{
|
|
Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
|
|
if ( pWindow )
|
|
pWindow->Show();
|
|
}
|
|
}
|
|
|
|
void SAL_CALL TabWindow::windowHidden( const css::lang::EventObject& )
|
|
throw( css::uno::RuntimeException, std::exception )
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
if ( m_xContainerWindow.is() )
|
|
{
|
|
Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
|
|
if ( pWindow )
|
|
pWindow->Hide();
|
|
}
|
|
|
|
TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
|
|
if ( pTabControl )
|
|
pTabControl->Hide();
|
|
}
|
|
|
|
|
|
// XTopWindowListener
|
|
|
|
void SAL_CALL TabWindow::windowOpened( const css::lang::EventObject& )
|
|
throw (css::uno::RuntimeException, std::exception)
|
|
{
|
|
}
|
|
|
|
void SAL_CALL TabWindow::windowClosing( const css::lang::EventObject& )
|
|
throw (css::uno::RuntimeException, std::exception)
|
|
{
|
|
css::uno::Reference< css::lang::XComponent > xComponent( (OWeakObject *)this, css::uno::UNO_QUERY );
|
|
if ( xComponent.is() )
|
|
xComponent->dispose();
|
|
}
|
|
|
|
void SAL_CALL TabWindow::windowClosed( const css::lang::EventObject& )
|
|
throw (css::uno::RuntimeException, std::exception)
|
|
{
|
|
}
|
|
|
|
void SAL_CALL TabWindow::windowMinimized( const css::lang::EventObject& )
|
|
throw (css::uno::RuntimeException, std::exception)
|
|
{
|
|
}
|
|
|
|
void SAL_CALL TabWindow::windowNormalized( const css::lang::EventObject& )
|
|
throw (css::uno::RuntimeException, std::exception)
|
|
{
|
|
}
|
|
|
|
void SAL_CALL TabWindow::windowActivated( const css::lang::EventObject& )
|
|
throw (css::uno::RuntimeException, std::exception)
|
|
{
|
|
}
|
|
|
|
void SAL_CALL TabWindow::windowDeactivated( const css::lang::EventObject& )
|
|
throw (css::uno::RuntimeException, std::exception)
|
|
{
|
|
}
|
|
|
|
|
|
// XSimpleTabController
|
|
|
|
|
|
::sal_Int32 SAL_CALL TabWindow::insertTab()
|
|
throw (css::uno::RuntimeException, std::exception)
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
|
|
if ( m_bDisposed )
|
|
throw css::lang::DisposedException();
|
|
|
|
sal_Int32 nNextTabID( m_nNextTabID++ );
|
|
|
|
OUString aTitle;
|
|
TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
|
|
if ( pTabControl )
|
|
pTabControl->InsertPage( sal_uInt16( nNextTabID ), aTitle );
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
implts_SendNotification( NOTIFY_INSERTED, nNextTabID );
|
|
|
|
return nNextTabID;
|
|
}
|
|
|
|
void SAL_CALL TabWindow::removeTab( ::sal_Int32 ID )
|
|
throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception)
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
|
|
if ( m_bDisposed )
|
|
throw css::lang::DisposedException();
|
|
|
|
TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
|
|
if ( pTabControl )
|
|
{
|
|
sal_uInt16 nCurTabId = pTabControl->GetCurPageId();
|
|
sal_uInt16 nPos = pTabControl->GetPagePos( sal_uInt16( ID ));
|
|
if ( nPos == TAB_PAGE_NOTFOUND )
|
|
throw css::lang::IndexOutOfBoundsException();
|
|
else
|
|
{
|
|
pTabControl->RemovePage( sal_uInt16( ID ));
|
|
nCurTabId = pTabControl->GetCurPageId();
|
|
}
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
implts_SendNotification( NOTIFY_REMOVED, ID );
|
|
|
|
// activate new tab if old tab was active!
|
|
nPos = pTabControl->GetPagePos( sal_uInt16( nCurTabId ));
|
|
if ( nPos != TAB_PAGE_NOTFOUND && nCurTabId != ID )
|
|
activateTab( nCurTabId );
|
|
}
|
|
}
|
|
|
|
void SAL_CALL TabWindow::setTabProps( ::sal_Int32 ID, const css::uno::Sequence< css::beans::NamedValue >& Properties )
|
|
throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception)
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
|
|
if ( m_bDisposed )
|
|
throw css::lang::DisposedException();
|
|
|
|
TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
|
|
if ( pTabControl )
|
|
{
|
|
sal_uInt16 nPos = pTabControl->GetPagePos( sal_uInt16( ID ));
|
|
if ( nPos == TAB_PAGE_NOTFOUND )
|
|
throw css::lang::IndexOutOfBoundsException();
|
|
else
|
|
{
|
|
comphelper::SequenceAsHashMap aSeqHashMap( Properties );
|
|
|
|
OUString aTitle = pTabControl->GetPageText( sal_uInt16( ID ));
|
|
sal_Int32 nNewPos = nPos;
|
|
|
|
aTitle = aSeqHashMap.getUnpackedValueOrDefault< OUString >(
|
|
m_aTitlePropName, aTitle );
|
|
pTabControl->SetPageText( sal_uInt16( ID ), aTitle );
|
|
nNewPos = aSeqHashMap.getUnpackedValueOrDefault< sal_Int32 >(
|
|
m_aPosPropName, nNewPos );
|
|
if ( nNewPos != sal_Int32( nPos ))
|
|
{
|
|
nPos = sal_uInt16( nNewPos );
|
|
if ( nPos >= pTabControl->GetPageCount() )
|
|
nPos = TAB_APPEND;
|
|
|
|
pTabControl->RemovePage( sal_uInt16( ID ));
|
|
pTabControl->InsertPage( sal_uInt16( ID ), aTitle, nPos );
|
|
}
|
|
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
aLock.unlock();
|
|
|
|
css::uno::Sequence< css::beans::NamedValue > aNamedValueSeq = getTabProps( ID );
|
|
implts_SendNotification( NOTIFY_CHANGED, ID, aNamedValueSeq );
|
|
}
|
|
}
|
|
}
|
|
|
|
css::uno::Sequence< css::beans::NamedValue > SAL_CALL TabWindow::getTabProps( ::sal_Int32 ID )
|
|
throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception)
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
|
|
if ( m_bDisposed )
|
|
throw css::lang::DisposedException();
|
|
|
|
css::uno::Sequence< css::beans::NamedValue > aNamedValueSeq;
|
|
|
|
TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
|
|
if ( pTabControl )
|
|
{
|
|
sal_uInt16 nPos = pTabControl->GetPagePos( sal_uInt16( ID ));
|
|
if ( nPos == TAB_PAGE_NOTFOUND )
|
|
throw css::lang::IndexOutOfBoundsException();
|
|
else
|
|
{
|
|
OUString aTitle = pTabControl->GetPageText( sal_uInt16( ID ));
|
|
nPos = pTabControl->GetPagePos( sal_uInt16( ID ));
|
|
|
|
css::uno::Sequence< css::beans::NamedValue > aSeq( 2 );
|
|
aSeq[0].Name = m_aTitlePropName;
|
|
aSeq[0].Value = css::uno::makeAny( aTitle );
|
|
aSeq[1].Name = m_aPosPropName;
|
|
aSeq[1].Value = css::uno::makeAny( sal_Int32( nPos ));
|
|
return aSeq;
|
|
}
|
|
}
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
return aNamedValueSeq;
|
|
}
|
|
|
|
void SAL_CALL TabWindow::activateTab( ::sal_Int32 ID )
|
|
throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException, std::exception)
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
|
|
if ( m_bDisposed )
|
|
throw css::lang::DisposedException();
|
|
|
|
TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
|
|
if ( pTabControl )
|
|
{
|
|
sal_uInt16 nPos = pTabControl->GetPagePos( sal_uInt16( ID ));
|
|
if ( nPos == TAB_PAGE_NOTFOUND )
|
|
throw css::lang::IndexOutOfBoundsException();
|
|
else
|
|
{
|
|
sal_Int32 nOldID = pTabControl->GetCurPageId();
|
|
OUString aTitle = pTabControl->GetPageText( sal_uInt16( ID ));
|
|
pTabControl->SetCurPageId( sal_uInt16( ID ));
|
|
pTabControl->SelectTabPage( sal_uInt16( ID ));
|
|
impl_SetTitle( aTitle );
|
|
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
if ( nOldID != TAB_PAGE_NOTFOUND )
|
|
implts_SendNotification( NOTIFY_DEACTIVATED, nOldID );
|
|
implts_SendNotification( NOTIFY_ACTIVATED, ID );
|
|
}
|
|
}
|
|
}
|
|
|
|
::sal_Int32 SAL_CALL TabWindow::getActiveTabID()
|
|
throw (css::uno::RuntimeException, std::exception)
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
|
|
if ( m_bDisposed )
|
|
throw css::lang::DisposedException();
|
|
|
|
TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
|
|
if ( pTabControl )
|
|
{
|
|
sal_uInt16 nID = pTabControl->GetCurPageId();
|
|
if ( nID == TAB_PAGE_NOTFOUND )
|
|
return -1;
|
|
else
|
|
return sal_Int32( nID );
|
|
}
|
|
|
|
return -1;
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
}
|
|
|
|
void SAL_CALL TabWindow::addTabListener(
|
|
const css::uno::Reference< css::awt::XTabListener >& xListener )
|
|
throw (css::uno::RuntimeException, std::exception)
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
if ( m_bDisposed )
|
|
return;
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
m_aListenerContainer.addInterface(
|
|
::getCppuType( ( const css::uno::Reference< css::awt::XTabListener >* ) NULL ), xListener );
|
|
}
|
|
|
|
void SAL_CALL TabWindow::removeTabListener( const css::uno::Reference< css::awt::XTabListener >& xListener )
|
|
throw (css::uno::RuntimeException, std::exception)
|
|
{
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
ResetableGuard aLock( m_aLock );
|
|
if ( m_bDisposed )
|
|
return;
|
|
aLock.unlock();
|
|
/* SAFE AREA ----------------------------------------------------------------------------------------------- */
|
|
|
|
m_aListenerContainer.removeInterface(
|
|
::getCppuType( ( const css::uno::Reference< css::awt::XTabListener >* ) NULL ), xListener );
|
|
}
|
|
|
|
|
|
// OPropertySetHelper
|
|
|
|
|
|
// XPropertySet helper
|
|
sal_Bool SAL_CALL TabWindow::convertFastPropertyValue( css::uno::Any& aConvertedValue ,
|
|
css::uno::Any& aOldValue ,
|
|
sal_Int32 nHandle ,
|
|
const css::uno::Any& aValue )
|
|
throw( css::lang::IllegalArgumentException )
|
|
{
|
|
// Initialize state with sal_False !!!
|
|
// (Handle can be invalid)
|
|
sal_Bool bReturn = sal_False;
|
|
|
|
switch( nHandle )
|
|
{
|
|
case TABWINDOW_PROPHANDLE_PARENTWINDOW :
|
|
bReturn = PropHelper::willPropertyBeChanged(
|
|
com::sun::star::uno::makeAny( m_xContainerWindow ),
|
|
aValue,
|
|
aOldValue,
|
|
aConvertedValue);
|
|
break;
|
|
|
|
case TABWINDOW_PROPHANDLE_TOPWINDOW :
|
|
bReturn = PropHelper::willPropertyBeChanged(
|
|
com::sun::star::uno::makeAny( m_xTopWindow ),
|
|
aValue,
|
|
aOldValue,
|
|
aConvertedValue);
|
|
break;
|
|
}
|
|
|
|
// Return state of operation.
|
|
return bReturn ;
|
|
}
|
|
|
|
void SAL_CALL TabWindow::setFastPropertyValue_NoBroadcast( sal_Int32,
|
|
const css::uno::Any&)
|
|
throw( css::uno::Exception, std::exception )
|
|
{
|
|
}
|
|
|
|
void SAL_CALL TabWindow::getFastPropertyValue( css::uno::Any& aValue ,
|
|
sal_Int32 nHandle ) const
|
|
{
|
|
switch( nHandle )
|
|
{
|
|
case TABWINDOW_PROPHANDLE_PARENTWINDOW:
|
|
aValue <<= m_xContainerWindow;
|
|
break;
|
|
case TABWINDOW_PROPHANDLE_TOPWINDOW:
|
|
aValue <<= m_xTopWindow;
|
|
break;
|
|
}
|
|
}
|
|
|
|
::cppu::IPropertyArrayHelper& SAL_CALL TabWindow::getInfoHelper()
|
|
{
|
|
// Optimize this method !
|
|
// We initialize a static variable only one time. And we don't must use a mutex at every call!
|
|
// For the first call; pInfoHelper is NULL - for the second call pInfoHelper is different from NULL!
|
|
static ::cppu::OPropertyArrayHelper* pInfoHelper = NULL;
|
|
|
|
if( pInfoHelper == NULL )
|
|
{
|
|
// Ready for multithreading
|
|
osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
|
|
|
|
// Control this pointer again, another instance can be faster then these!
|
|
if( pInfoHelper == NULL )
|
|
{
|
|
// Define static member to give structure of properties to baseclass "OPropertySetHelper".
|
|
// "impl_getStaticPropertyDescriptor" is a non exported and static funtion, who will define a static propertytable.
|
|
// "sal_True" say: Table is sorted by name.
|
|
static ::cppu::OPropertyArrayHelper aInfoHelper( impl_getStaticPropertyDescriptor(), sal_True );
|
|
pInfoHelper = &aInfoHelper;
|
|
}
|
|
}
|
|
|
|
return(*pInfoHelper);
|
|
}
|
|
|
|
css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL TabWindow::getPropertySetInfo()
|
|
throw ( css::uno::RuntimeException, std::exception )
|
|
{
|
|
// Optimize this method !
|
|
// We initialize a static variable only one time. And we don't must use a mutex at every call!
|
|
// For the first call; pInfo is NULL - for the second call pInfo is different from NULL!
|
|
static css::uno::Reference< css::beans::XPropertySetInfo >* pInfo = NULL;
|
|
|
|
if( pInfo == NULL )
|
|
{
|
|
// Ready for multithreading
|
|
osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
|
|
// Control this pointer again, another instance can be faster then these!
|
|
if( pInfo == NULL )
|
|
{
|
|
// Create structure of propertysetinfo for baseclass "OPropertySetHelper".
|
|
// (Use method "getInfoHelper()".)
|
|
static css::uno::Reference< css::beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
|
|
pInfo = &xInfo;
|
|
}
|
|
}
|
|
|
|
return (*pInfo);
|
|
}
|
|
|
|
const css::uno::Sequence< css::beans::Property > TabWindow::impl_getStaticPropertyDescriptor()
|
|
{
|
|
// Create property array to initialize sequence!
|
|
// Table of all predefined properties of this class. Its used from OPropertySetHelper-class!
|
|
// Don't forget to change the defines (see begin of this file), if you add, change or delete a property in this list!!!
|
|
// It's necessary for methods of OPropertySetHelper.
|
|
// ATTENTION:
|
|
// YOU MUST SORT FOLLOW TABLE BY NAME ALPHABETICAL !!!
|
|
|
|
const com::sun::star::beans::Property pProperties[] =
|
|
{
|
|
com::sun::star::beans::Property( TABWINDOW_PROPNAME_PARENTWINDOW,
|
|
TABWINDOW_PROPHANDLE_PARENTWINDOW,
|
|
::getCppuType((const css::uno::Reference< css::awt::XWindow >*)NULL),
|
|
com::sun::star::beans::PropertyAttribute::READONLY ),
|
|
com::sun::star::beans::Property( TABWINDOW_PROPNAME_TOPWINDOW,
|
|
TABWINDOW_PROPHANDLE_TOPWINDOW,
|
|
::getCppuType((const css::uno::Reference< css::awt::XWindow >*)NULL),
|
|
com::sun::star::beans::PropertyAttribute::READONLY )
|
|
}; // Use it to initialize sequence!
|
|
const com::sun::star::uno::Sequence< com::sun::star::beans::Property > lPropertyDescriptor( pProperties, TABWINDOW_PROPCOUNT );
|
|
|
|
// Return "PropertyDescriptor"
|
|
return lPropertyDescriptor;
|
|
}
|
|
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|