framework/source/tabwin/tabwindow.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: tabwindow.cxx,v $
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_framework.hxx"
  33 #include <tabwin/tabwindow.hxx>
  34 #include <properties.h>
  35
  36 //_________________________________________________________________________________________________________________
  37 //      my own includes
  38 //_________________________________________________________________________________________________________________
  39 #include <threadhelp/resetableguard.hxx>
  40
  41 //_________________________________________________________________________________________________________________
  42 //      interface includes
  43 //_________________________________________________________________________________________________________________
  44 #include <com/sun/star/util/XURLTransformer.hpp>
  45 #include <com/sun/star/awt/PosSize.hpp>
  46 #include <com/sun/star/awt/WindowDescriptor.hpp>
  47 #include <com/sun/star/beans/PropertyAttribute.hpp>
  48 #include <com/sun/star/lang/DisposedException.hpp>
  49 //_________________________________________________________________________________________________________________
  50 //      includes of other projects
  51 //_________________________________________________________________________________________________________________
  52 #include <rtl/ustrbuf.hxx>
  53 #include <tools/urlobj.hxx>
  54 #include <vcl/svapp.hxx>
  55 #include <vcl/window.hxx>
  56 #include <vcl/wrkwin.hxx>
  57 #ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_
  58 #include <toolkit/unohlp.hxx>
  59 #endif
  60 #include <comphelper/sequenceashashmap.hxx>
  61
  62 //_________________________________________________________________________________________________________________
  63 //      Defines
  64 //_________________________________________________________________________________________________________________
  65 //
  66
  67 using namespace rtl;
  68 using namespace com::sun::star;
  69
  70 namespace framework
  71 {
  72
  73 //*****************************************************************************************************************
  74 //      XInterface, XTypeProvider, XServiceInfo
  75 //*****************************************************************************************************************
  76 DEFINE_XINTERFACE_11                    (   TabWindow                                                                                                              ,
  77                                             ::cppu::OWeakObject                                                                ,
  78                                             DIRECT_INTERFACE( css::lang::XTypeProvider                                                                    ),
  79                                             DIRECT_INTERFACE( css::lang::XServiceInfo                                                                     ),
  80                                             DIRECT_INTERFACE( css::lang::XInitialization                                                                  ),
  81                                             DIRECT_INTERFACE( css::lang::XComponent                                           ),
  82                                             DIRECT_INTERFACE( css::awt::XWindowListener                                                                   ),
  83                                             DIRECT_INTERFACE( css::awt::XTopWindowListener                                    ),
  84                                             DIRECT_INTERFACE( css::awt::XSimpleTabController                                  ),
  85                                             DERIVED_INTERFACE( css::lang::XEventListener, css::awt::XWindowListener           ),
  86                                             DIRECT_INTERFACE( css::beans::XMultiPropertySet                                                               ),
  87                                             DIRECT_INTERFACE( css::beans::XFastPropertySet                                                                ),
  88                                             DIRECT_INTERFACE( css::beans::XPropertySet                                                                    )
  89                                         )
  90
  91 DEFINE_XTYPEPROVIDER_11                 (   TabWindow                                                           ,
  92                                             css::lang::XTypeProvider                        ,
  93                                             css::lang::XServiceInfo                                 ,
  94                                             css::lang::XInitialization                          ,
  95                                             css::lang::XComponent                   ,
  96                                             css::awt::XWindowListener                           ,
  97                                             css::awt::XTopWindowListener            ,
  98                                             css::awt::XSimpleTabController          ,
  99                                             css::lang::XEventListener                           ,
 100                                             css::beans::XMultiPropertySet           ,
 101                                             css::beans::XFastPropertySet            ,
 102                                             css::beans::XPropertySet
 103                                         )
 104
 105 DEFINE_XSERVICEINFO_MULTISERVICE        (   TabWindow                                                   ,
 106                                             ::cppu::OWeakObject                 ,
 107                                             SERVICENAME_TABWINDOW                               ,
 108                                             IMPLEMENTATIONNAME_TABWINDOW
 109                                         )
 110
 111 DEFINE_INIT_SERVICE                     (   TabWindow, {} )
 112
 113 TabWindow::TabWindow( const css::uno::Reference< css::lang::XMultiServiceFactory >& xServiceManager ) :
 114     ThreadHelpBase( &Application::GetSolarMutex() )
 115     , ::cppu::OBroadcastHelperVar< ::cppu::OMultiTypeInterfaceContainerHelper, ::cppu::OMultiTypeInterfaceContainerHelper::keyType >( m_aLock.getShareableOslMutex() )
 116     , ::cppu::OPropertySetHelper  ( *(static_cast< ::cppu::OBroadcastHelper* >(this)) )
 117     , m_bInitialized( sal_False )
 118     , m_bDisposed( sal_False )
 119     , m_nNextTabID( 1 )
 120     , m_aTitlePropName( RTL_CONSTASCII_USTRINGPARAM( "Title" ))
 121     , m_aPosPropName( RTL_CONSTASCII_USTRINGPARAM( "Position" ))
 122     , m_xServiceManager( xServiceManager )
 123     , m_aListenerContainer( m_aLock.getShareableOslMutex() )
 124 {
 125 }
 126
 127 TabWindow::~TabWindow()
 128 {
 129 }
 130
 131 //---------------------------------------------------------------------------------------------------------
 132 // Helper
 133 //---------------------------------------------------------------------------------------------------------
 134
 135 void TabWindow::implts_LayoutWindows() const
 136 {
 137     const sal_Int32 nTabControlHeight = 30;
 138
 139     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 140     ResetableGuard aLock( m_aLock );
 141     css::uno::Reference< css::awt::XDevice > xDevice( m_xTopWindow, css::uno::UNO_QUERY );
 142     css::uno::Reference< css::awt::XWindow > xWindow( m_xTopWindow, css::uno::UNO_QUERY );
 143     css::uno::Reference< css::awt::XWindow > xTabControlWindow( m_xTabControlWindow );
 144     css::uno::Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow );
 145     aLock.unlock();
 146     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 147
 148     // Convert relativ size to output size.
 149     if ( xWindow.is() && xDevice.is() )
 150     {
 151         css::awt::Rectangle  aRectangle  = xWindow->getPosSize();
 152         css::awt::DeviceInfo aInfo       = xDevice->getInfo();
 153         css::awt::Size       aSize       (  aRectangle.Width  - aInfo.LeftInset - aInfo.RightInset  ,
 154                                             aRectangle.Height - aInfo.TopInset  - aInfo.BottomInset );
 155
 156         css::awt::Size  aContainerWindowSize;
 157         css::awt::Size  aTabControlSize;
 158
 159         aContainerWindowSize.Width = aSize.Width;
 160         aTabControlSize.Width = aSize.Width;
 161
 162         aContainerWindowSize.Height = std::max( sal_Int32( 0 ), aSize.Height - nTabControlHeight );
 163         aTabControlSize.Height = nTabControlHeight;
 164
 165         xContainerWindow->setPosSize( 0, 0,
 166                                       aContainerWindowSize.Width, aContainerWindowSize.Height,
 167                                       css::awt::PosSize::POSSIZE );
 168         xTabControlWindow->setPosSize( 0, std::max( nTabControlHeight, sal_Int32( aSize.Height - nTabControlHeight)),
 169                                        aTabControlSize.Width, aTabControlSize.Height,
 170                                        css::awt::PosSize::POSSIZE );
 171     }
 172 }
 173
 174 TabControl* TabWindow::impl_GetTabControl( const css::uno::Reference< css::awt::XWindow >& rTabControlWindow ) const
 175 {
 176     Window* pWindow = VCLUnoHelper::GetWindow( rTabControlWindow );
 177     if ( pWindow )
 178         return (TabControl *)pWindow;
 179     else
 180         return NULL;
 181 }
 182
 183 void TabWindow::impl_SetTitle( const ::rtl::OUString& rTitle )
 184 {
 185     if ( m_xTopWindow.is() )
 186     {
 187         Window* pWindow = VCLUnoHelper::GetWindow(
 188                             css::uno::Reference< css::awt::XWindow >(
 189                                 m_xTopWindow, css::uno::UNO_QUERY ));
 190         if ( pWindow )
 191             pWindow->SetText( rTitle );
 192     }
 193 }
 194
 195 void TabWindow::implts_SendNotification( Notification eNotify, sal_Int32 ID ) const
 196 {
 197     ::cppu::OInterfaceContainerHelper* pContainer = m_aListenerContainer.getContainer(
 198                                                         ::getCppuType( ( const css::uno::Reference< css::awt::XTabListener >*) NULL ) );
 199     if (pContainer!=NULL)
 200     {
 201         ::cppu::OInterfaceIteratorHelper pIterator(*pContainer);
 202         while (pIterator.hasMoreElements())
 203         {
 204             try
 205             {
 206                 switch ( eNotify )
 207                 {
 208                     case NOTIFY_INSERTED:
 209                         ((css::awt::XTabListener*)pIterator.next())->inserted( ID );
 210                         break;
 211                     case NOTIFY_REMOVED:
 212                         ((css::awt::XTabListener*)pIterator.next())->removed( ID );
 213                         break;
 214                     case NOTIFY_ACTIVATED:
 215                         ((css::awt::XTabListener*)pIterator.next())->activated( ID );
 216                         break;
 217                     case NOTIFY_DEACTIVATED:
 218                         ((css::awt::XTabListener*)pIterator.next())->deactivated( ID );
 219                         break;
 220                     default:
 221                         break;
 222                 }
 223             }
 224             catch( css::uno::RuntimeException& )
 225             {
 226                 pIterator.remove();
 227             }
 228         }
 229     }
 230 }
 231
 232 void TabWindow::implts_SendNotification( Notification eNotify, sal_Int32 ID, const css::uno::Sequence< css::beans::NamedValue >& rSeq ) const
 233 {
 234     ::cppu::OInterfaceContainerHelper* pContainer = m_aListenerContainer.getContainer(
 235                                                         ::getCppuType( ( const css::uno::Reference< css::awt::XTabListener >*) NULL ) );
 236     if (pContainer!=NULL)
 237     {
 238         ::cppu::OInterfaceIteratorHelper pIterator(*pContainer);
 239         while (pIterator.hasMoreElements())
 240         {
 241             try
 242             {
 243                 switch ( eNotify )
 244                 {
 245                     case NOTIFY_CHANGED:
 246                         ((css::awt::XTabListener*)pIterator.next())->changed( ID, rSeq );
 247                         break;
 248                     default:
 249                         break;
 250                 }
 251             }
 252             catch( css::uno::RuntimeException& )
 253             {
 254                 pIterator.remove();
 255             }
 256         }
 257     }
 258 }
 259
 260 //---------------------------------------------------------------------------------------------------------
 261 // Links
 262 //---------------------------------------------------------------------------------------------------------
 263
 264 IMPL_LINK( TabWindow, Activate, TabControl*, pTabControl )
 265 {
 266     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 267     ResetableGuard aLock( m_aLock );
 268
 269     sal_Int32 nPageId = pTabControl->GetCurPageId();
 270
 271     rtl::OUString aTitle = pTabControl->GetPageText( sal_uInt16( nPageId ));
 272     impl_SetTitle( aTitle );
 273     aLock.unlock();
 274     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 275
 276     implts_SendNotification( NOTIFY_ACTIVATED, nPageId );
 277
 278     return 1;
 279 }
 280
 281 IMPL_LINK( TabWindow, Deactivate, TabControl*, pTabControl )
 282 {
 283     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 284     ResetableGuard aLock( m_aLock );
 285     sal_Int32 nPageId = pTabControl->GetCurPageId();
 286     aLock.unlock();
 287     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 288
 289     implts_SendNotification( NOTIFY_DEACTIVATED, nPageId );
 290
 291     return 1;
 292 }
 293
 294 //---------------------------------------------------------------------------------------------------------
 295 // XInitilization
 296 //---------------------------------------------------------------------------------------------------------
 297
 298 void SAL_CALL TabWindow::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
 299 throw (css::uno::Exception, css::uno::RuntimeException)
 300 {
 301     const rtl::OUString aTopWindowArgName( RTL_CONSTASCII_USTRINGPARAM( "TopWindow" ));
 302     const rtl::OUString aSizeArgName( RTL_CONSTASCII_USTRINGPARAM( "Size" ));
 303
 304     css::awt::Size aDefaultSize( 500, 500 );
 305     css::awt::Size aSize( aDefaultSize );
 306
 307     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 308     ResetableGuard aLock( m_aLock );
 309     sal_Bool                                               bInitalized( m_bInitialized );
 310     css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR( m_xServiceManager );
 311     aLock.unlock();
 312     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 313
 314     if ( !bInitalized )
 315     {
 316         css::beans::PropertyValue                                   aPropValue;
 317         css::uno::Reference< css::awt::XTopWindow > xTopWindow;
 318         css::uno::Reference< css::awt::XToolkit >   xToolkit;
 319         css::awt::WindowDescriptor                  aDescriptor;
 320
 321         if ( xSMGR.is() )
 322         {
 323             try
 324             {
 325                 xToolkit = css::uno::Reference< css::awt::XToolkit >(
 326                     xSMGR->createInstance( SERVICENAME_VCLTOOLKIT ), css::uno::UNO_QUERY );
 327             }
 328             catch ( css::uno::RuntimeException& )
 329             {
 330                 throw;
 331             }
 332             catch ( css::uno::Exception& )
 333             {
 334             }
 335         }
 336
 337         for ( int i = 0; i < aArguments.getLength(); i++ )
 338         {
 339             if ( aArguments[i] >>= aPropValue )
 340             {
 341                 if ( aPropValue.Name == aTopWindowArgName )
 342                     aPropValue.Value >>= xTopWindow;
 343                 else if ( aPropValue.Name == aSizeArgName )
 344                 {
 345                     aPropValue.Value >>= aSize;
 346                     if ( aSize.Width <= 0 )
 347                         aSize.Width = aDefaultSize.Width;
 348                     if ( aSize.Height <= 0 )
 349                         aSize.Height = aDefaultSize.Height;
 350                 }
 351             }
 352         }
 353
 354         if ( xToolkit.is() )
 355         {
 356             if ( !xTopWindow.is() )
 357             {
 358                 // describe top window properties.
 359                 aDescriptor.Type                =   css::awt::WindowClass_TOP;
 360                 aDescriptor.ParentIndex         =   -1;
 361                 aDescriptor.Parent              =   css::uno::Reference< css::awt::XWindowPeer >();
 362                 aDescriptor.Bounds              =   css::awt::Rectangle( 0, 0, aSize.Width, aSize.Height );
 363                 aDescriptor.WindowAttributes    =   0;
 364
 365                 try
 366                 {
 367                     xTopWindow = css::uno::Reference< css::awt::XTopWindow >( xToolkit->createWindow( aDescriptor ), css::uno::UNO_QUERY );
 368                 }
 369                 catch ( css::uno::RuntimeException& )
 370                 {
 371                     throw;
 372                 }
 373                 catch ( css::uno::Exception& )
 374                 {
 375                 }
 376             }
 377
 378             if ( xTopWindow.is() )
 379             {
 380                 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 381                 aLock.lock();
 382                 m_bInitialized = sal_True;
 383                 aLock.unlock();
 384                 /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 385
 386                 css::uno::Reference< css::awt::XWindow > xWindow( xTopWindow, css::uno::UNO_QUERY );
 387                 xWindow->addWindowListener( css::uno::Reference< css::awt::XWindowListener >(
 388                     static_cast< ::cppu::OWeakObject* >( this ), css::uno::UNO_QUERY_THROW ));
 389
 390                 xTopWindow->addTopWindowListener( css::uno::Reference< css::awt::XTopWindowListener >(
 391                     static_cast< ::cppu::OWeakObject* >( this ), css::uno::UNO_QUERY_THROW ));
 392
 393                 css::uno::Reference< css::awt::XWindow > xContainerWindow;
 394                 css::uno::Reference< css::awt::XWindow > xTabControl;
 395
 396                 // describe container window properties.
 397                 aDescriptor.Type                =   css::awt::WindowClass_SIMPLE;
 398                 aDescriptor.ParentIndex         =   -1;
 399                 aDescriptor.Parent              =   css::uno::Reference< css::awt::XWindowPeer >( xTopWindow, css::uno::UNO_QUERY );
 400                 aDescriptor.Bounds              =   css::awt::Rectangle(0,0,0,0);
 401                 aDescriptor.WindowAttributes    =   0;
 402
 403                 xContainerWindow = css::uno::Reference< css::awt::XWindow >( xToolkit->createWindow( aDescriptor ), css::uno::UNO_QUERY );
 404
 405                 // create a tab control window properties
 406                 aDescriptor.Type                                = css::awt::WindowClass_SIMPLE;
 407                 aDescriptor.WindowServiceName   = DECLARE_ASCII("tabcontrol");
 408                 aDescriptor.ParentIndex                 = -1;
 409                 aDescriptor.Parent                              = css::uno::Reference< css::awt::XWindowPeer >( xTopWindow, css::uno::UNO_QUERY );
 410                 aDescriptor.Bounds                              = css::awt::Rectangle( 0,0,0,0 );
 411                 aDescriptor.WindowAttributes    = 0;
 412
 413                 xTabControl = css::uno::Reference< css::awt::XWindow >( xToolkit->createWindow( aDescriptor ), css::uno::UNO_QUERY );
 414
 415                 if ( xContainerWindow.is() && xTabControl.is() )
 416                 {
 417                     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 418                     aLock.lock();
 419                     m_xTopWindow = xTopWindow;
 420                     m_xContainerWindow = xContainerWindow;
 421                     m_xTabControlWindow = xTabControl;
 422                     aLock.unlock();
 423                     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 424
 425                     xWindow->setPosSize( 0, 0, aSize.Width, aSize.Height, css::awt::PosSize::POSSIZE );
 426
 427                     vos::OGuard aGuard( Application::GetSolarMutex() );
 428                     Window* pWindow = VCLUnoHelper::GetWindow( xWindow );
 429                     if( pWindow )
 430                         pWindow->Show( TRUE );
 431
 432                     pWindow = VCLUnoHelper::GetWindow( xContainerWindow );
 433                     if ( pWindow )
 434                         pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE  );
 435
 436                     pWindow = VCLUnoHelper::GetWindow( xTabControl );
 437                     if ( pWindow )
 438                     {
 439                         pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE  );
 440                         TabControl* pTabControl = (TabControl *)pWindow;
 441                         pTabControl->SetActivatePageHdl( LINK( this, TabWindow, Activate ));
 442                         pTabControl->SetDeactivatePageHdl( LINK( this, TabWindow, Deactivate ));
 443                     }
 444
 445                     implts_LayoutWindows();
 446                 }
 447             }
 448         }
 449     }
 450 }
 451
 452 //---------------------------------------------------------------------------------------------------------
 453 //      XComponent
 454 //---------------------------------------------------------------------------------------------------------
 455 void SAL_CALL TabWindow::dispose() throw (css::uno::RuntimeException)
 456 {
 457     // Send message to all listener and forget her references.
 458     css::uno::Reference< css::lang::XComponent > xThis(
 459         static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY );
 460     css::lang::EventObject aEvent( xThis );
 461
 462     m_aListenerContainer.disposeAndClear( aEvent );
 463
 464     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 465     ResetableGuard aLock( m_aLock );
 466     css::uno::Reference< css::awt::XWindow > xTabControlWindow( m_xTabControlWindow );
 467     css::uno::Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow );
 468     css::uno::Reference< css::awt::XTopWindow > xTopWindow( m_xTopWindow );
 469     m_xTabControlWindow.clear();
 470     m_xContainerWindow.clear();
 471     m_xTopWindow.clear();
 472     aLock.unlock();
 473     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 474
 475     css::uno::Reference< css::lang::XComponent > xComponent( xTabControlWindow, css::uno::UNO_QUERY );
 476     if ( xComponent.is() )
 477         xComponent->dispose();
 478
 479     xComponent = css::uno::Reference< css::lang::XComponent >( xContainerWindow, css::uno::UNO_QUERY );
 480     if ( xComponent.is() )
 481         xComponent->dispose();
 482
 483     xComponent = css::uno::Reference< css::lang::XComponent >( xTopWindow, css::uno::UNO_QUERY );
 484     if ( xComponent.is() )
 485         xComponent->dispose();
 486
 487     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 488     aLock.lock();
 489     m_bDisposed = sal_True;
 490     aLock.unlock();
 491     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 492 }
 493
 494 void SAL_CALL TabWindow::addEventListener( const css::uno::Reference< css::lang::XEventListener >& xListener )
 495 throw (css::uno::RuntimeException)
 496 {
 497     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 498     ResetableGuard aLock( m_aLock );
 499     if ( m_bDisposed )
 500         return;
 501     aLock.unlock();
 502     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 503
 504     m_aListenerContainer.addInterface( ::getCppuType( ( const css::uno::Reference< css::lang::XEventListener >* ) NULL ), xListener );
 505 }
 506
 507 void SAL_CALL TabWindow::removeEventListener( const css::uno::Reference< css::lang::XEventListener >& xListener )
 508 throw (css::uno::RuntimeException)
 509 {
 510     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 511     ResetableGuard aLock( m_aLock );
 512     if ( m_bDisposed )
 513         return;
 514     aLock.unlock();
 515     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 516
 517     m_aListenerContainer.removeInterface( ::getCppuType( ( const css::uno::Reference< css::lang::XEventListener >* ) NULL ), xListener );
 518 }
 519
 520 //---------------------------------------------------------------------------------------------------------
 521 // XEventListener
 522 //---------------------------------------------------------------------------------------------------------
 523 void SAL_CALL TabWindow::disposing( const css::lang::EventObject& )
 524 throw( css::uno::RuntimeException )
 525 {
 526 }
 527
 528 //---------------------------------------------------------------------------------------------------------
 529 // XWindowListener
 530 //---------------------------------------------------------------------------------------------------------
 531 void SAL_CALL TabWindow::windowResized( const css::awt::WindowEvent& )
 532 throw( css::uno::RuntimeException )
 533 {
 534     implts_LayoutWindows();
 535 }
 536
 537 void SAL_CALL TabWindow::windowMoved( const css::awt::WindowEvent& )
 538 throw( css::uno::RuntimeException )
 539 {
 540 }
 541
 542 void SAL_CALL TabWindow::windowShown( const css::lang::EventObject& )
 543 throw( css::uno::RuntimeException )
 544 {
 545     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 546     ResetableGuard aLock( m_aLock );
 547
 548     TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
 549     if ( pTabControl )
 550         pTabControl->Show();
 551
 552     if ( m_xContainerWindow.is() )
 553     {
 554         Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
 555         if ( pWindow )
 556             pWindow->Show();
 557     }
 558 }
 559
 560 void SAL_CALL TabWindow::windowHidden( const css::lang::EventObject& )
 561 throw( css::uno::RuntimeException )
 562 {
 563     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 564     ResetableGuard aLock( m_aLock );
 565     if ( m_xContainerWindow.is() )
 566     {
 567         Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow );
 568         if ( pWindow )
 569             pWindow->Hide();
 570     }
 571
 572     TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
 573     if ( pTabControl )
 574         pTabControl->Hide();
 575 }
 576
 577 //---------------------------------------------------------------------------------------------------------
 578 // XTopWindowListener
 579 //---------------------------------------------------------------------------------------------------------
 580 void SAL_CALL TabWindow::windowOpened( const css::lang::EventObject& )
 581 throw (css::uno::RuntimeException)
 582 {
 583 }
 584
 585 void SAL_CALL TabWindow::windowClosing( const css::lang::EventObject& )
 586 throw (css::uno::RuntimeException)
 587 {
 588     css::uno::Reference< css::lang::XComponent > xComponent( (OWeakObject *)this, css::uno::UNO_QUERY );
 589     if ( xComponent.is() )
 590         xComponent->dispose();
 591 }
 592
 593 void SAL_CALL TabWindow::windowClosed( const css::lang::EventObject& )
 594 throw (css::uno::RuntimeException)
 595 {
 596 }
 597
 598 void SAL_CALL TabWindow::windowMinimized( const css::lang::EventObject& )
 599 throw (css::uno::RuntimeException)
 600 {
 601 }
 602
 603 void SAL_CALL TabWindow::windowNormalized( const css::lang::EventObject& )
 604 throw (css::uno::RuntimeException)
 605 {
 606 }
 607
 608 void SAL_CALL TabWindow::windowActivated( const css::lang::EventObject& )
 609 throw (css::uno::RuntimeException)
 610 {
 611 }
 612
 613 void SAL_CALL TabWindow::windowDeactivated( const css::lang::EventObject& )
 614 throw (css::uno::RuntimeException)
 615 {
 616 }
 617
 618 //---------------------------------------------------------------------------------------------------------
 619 //      XSimpleTabController
 620 //---------------------------------------------------------------------------------------------------------
 621
 622 ::sal_Int32 SAL_CALL TabWindow::insertTab()
 623 throw (css::uno::RuntimeException)
 624 {
 625     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 626     ResetableGuard aLock( m_aLock );
 627
 628     if ( m_bDisposed )
 629         throw css::lang::DisposedException();
 630
 631     sal_Int32 nNextTabID( m_nNextTabID++ );
 632
 633     rtl::OUString aTitle;
 634     TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
 635     if ( pTabControl )
 636         pTabControl->InsertPage( sal_uInt16( nNextTabID ), aTitle );
 637     aLock.unlock();
 638     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 639
 640     implts_SendNotification( NOTIFY_INSERTED, nNextTabID );
 641
 642     return nNextTabID;
 643 }
 644
 645 void SAL_CALL TabWindow::removeTab( ::sal_Int32 ID )
 646 throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException)
 647 {
 648     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 649     ResetableGuard aLock( m_aLock );
 650
 651     if ( m_bDisposed )
 652         throw css::lang::DisposedException();
 653
 654     TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
 655     if ( pTabControl )
 656     {
 657         sal_uInt16 nCurTabId = pTabControl->GetCurPageId();
 658         sal_uInt16 nPos      = pTabControl->GetPagePos( sal_uInt16( ID ));
 659         if ( nPos == TAB_PAGE_NOTFOUND )
 660             throw css::lang::IndexOutOfBoundsException();
 661         else
 662         {
 663             pTabControl->RemovePage( sal_uInt16( ID ));
 664             nCurTabId = pTabControl->GetCurPageId();
 665         }
 666         aLock.unlock();
 667         /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 668
 669         implts_SendNotification( NOTIFY_REMOVED, ID );
 670
 671         // activate new tab if old tab was active!
 672         nPos = pTabControl->GetPagePos( sal_uInt16( nCurTabId ));
 673         if ( nPos != TAB_PAGE_NOTFOUND && nCurTabId != ID )
 674             activateTab( nCurTabId );
 675     }
 676 }
 677
 678 void SAL_CALL TabWindow::setTabProps( ::sal_Int32 ID, const css::uno::Sequence< css::beans::NamedValue >& Properties )
 679 throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException)
 680 {
 681     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 682     ResetableGuard aLock( m_aLock );
 683
 684     if ( m_bDisposed )
 685         throw css::lang::DisposedException();
 686
 687     TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
 688     if ( pTabControl )
 689     {
 690         sal_uInt16 nPos = pTabControl->GetPagePos( sal_uInt16( ID ));
 691         if ( nPos == TAB_PAGE_NOTFOUND )
 692             throw css::lang::IndexOutOfBoundsException();
 693         else
 694         {
 695             comphelper::SequenceAsHashMap aSeqHashMap( Properties );
 696
 697             ::rtl::OUString aTitle  = pTabControl->GetPageText( sal_uInt16( ID ));
 698             sal_Int32       nNewPos = nPos;
 699
 700             aTitle = aSeqHashMap.getUnpackedValueOrDefault< ::rtl::OUString >(
 701                                     m_aTitlePropName, aTitle );
 702             pTabControl->SetPageText( sal_uInt16( ID ), aTitle );
 703             nNewPos = aSeqHashMap.getUnpackedValueOrDefault< sal_Int32 >(
 704                                     m_aPosPropName, nNewPos );
 705             if ( nNewPos != sal_Int32( nPos ))
 706             {
 707                 nPos = sal_uInt16( nNewPos );
 708                 if ( nPos >= pTabControl->GetPageCount() )
 709                     nPos = TAB_APPEND;
 710
 711                 pTabControl->RemovePage( sal_uInt16( ID ));
 712                 pTabControl->InsertPage( sal_uInt16( ID ), aTitle, nPos );
 713             }
 714
 715             /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 716             aLock.unlock();
 717
 718             css::uno::Sequence< css::beans::NamedValue > aNamedValueSeq = getTabProps( ID );
 719             implts_SendNotification( NOTIFY_CHANGED, ID, aNamedValueSeq );
 720         }
 721     }
 722 }
 723
 724 css::uno::Sequence< css::beans::NamedValue > SAL_CALL TabWindow::getTabProps( ::sal_Int32 ID )
 725 throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException)
 726 {
 727     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 728     ResetableGuard aLock( m_aLock );
 729
 730     if ( m_bDisposed )
 731         throw css::lang::DisposedException();
 732
 733     css::uno::Sequence< css::beans::NamedValue > aNamedValueSeq;
 734
 735     TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
 736     if ( pTabControl )
 737     {
 738         sal_uInt16 nPos = pTabControl->GetPagePos( sal_uInt16( ID ));
 739         if ( nPos == TAB_PAGE_NOTFOUND )
 740             throw css::lang::IndexOutOfBoundsException();
 741         else
 742         {
 743             rtl::OUString aTitle = pTabControl->GetPageText( sal_uInt16( ID ));
 744                           nPos   = pTabControl->GetPagePos( sal_uInt16( ID ));
 745
 746             css::uno::Sequence< css::beans::NamedValue > aSeq( 2 );
 747             aSeq[0].Name  = m_aTitlePropName;
 748             aSeq[0].Value = css::uno::makeAny( aTitle );
 749             aSeq[1].Name  = m_aPosPropName;
 750             aSeq[1].Value = css::uno::makeAny( sal_Int32( nPos ));
 751             return aSeq;
 752         }
 753     }
 754     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 755
 756     return aNamedValueSeq;
 757 }
 758
 759 void SAL_CALL TabWindow::activateTab( ::sal_Int32 ID )
 760 throw (css::lang::IndexOutOfBoundsException, css::uno::RuntimeException)
 761 {
 762     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 763     ResetableGuard aLock( m_aLock );
 764
 765     if ( m_bDisposed )
 766         throw css::lang::DisposedException();
 767
 768     TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
 769     if ( pTabControl )
 770     {
 771         sal_uInt16 nPos = pTabControl->GetPagePos( sal_uInt16( ID ));
 772         if ( nPos == TAB_PAGE_NOTFOUND )
 773             throw css::lang::IndexOutOfBoundsException();
 774         else
 775         {
 776             sal_Int32 nOldID     = pTabControl->GetCurPageId();
 777             rtl::OUString aTitle = pTabControl->GetPageText( sal_uInt16( ID ));
 778             pTabControl->SetCurPageId( sal_uInt16( ID ));
 779             pTabControl->SelectTabPage( sal_uInt16( ID ));
 780             impl_SetTitle( aTitle );
 781
 782             aLock.unlock();
 783             /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 784
 785             if ( nOldID != TAB_PAGE_NOTFOUND )
 786                 implts_SendNotification( NOTIFY_DEACTIVATED, nOldID );
 787             implts_SendNotification( NOTIFY_ACTIVATED, ID );
 788         }
 789     }
 790 }
 791
 792 ::sal_Int32 SAL_CALL TabWindow::getActiveTabID()
 793 throw (css::uno::RuntimeException)
 794 {
 795     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 796     ResetableGuard aLock( m_aLock );
 797
 798     if ( m_bDisposed )
 799         throw css::lang::DisposedException();
 800
 801     TabControl* pTabControl = impl_GetTabControl( m_xTabControlWindow );
 802     if ( pTabControl )
 803     {
 804         sal_uInt16 nID = pTabControl->GetCurPageId();
 805         if ( nID == TAB_PAGE_NOTFOUND )
 806             return -1;
 807         else
 808             return sal_Int32( nID );
 809     }
 810
 811     return -1;
 812     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 813 }
 814
 815 void SAL_CALL TabWindow::addTabListener(
 816     const css::uno::Reference< css::awt::XTabListener >& xListener )
 817 throw (css::uno::RuntimeException)
 818 {
 819     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 820     ResetableGuard aLock( m_aLock );
 821     if ( m_bDisposed )
 822         return;
 823     aLock.unlock();
 824     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 825
 826     m_aListenerContainer.addInterface(
 827         ::getCppuType( ( const css::uno::Reference< css::awt::XTabListener >* ) NULL ), xListener );
 828 }
 829
 830 void SAL_CALL TabWindow::removeTabListener( const css::uno::Reference< css::awt::XTabListener >& xListener )
 831 throw (css::uno::RuntimeException)
 832 {
 833     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 834     ResetableGuard aLock( m_aLock );
 835     if ( m_bDisposed )
 836         return;
 837     aLock.unlock();
 838     /* SAFE AREA ----------------------------------------------------------------------------------------------- */
 839
 840     m_aListenerContainer.removeInterface(
 841         ::getCppuType( ( const css::uno::Reference< css::awt::XTabListener >* ) NULL ), xListener );
 842 }
 843
 844 //---------------------------------------------------------------------------------------------------------
 845 //      OPropertySetHelper
 846 //---------------------------------------------------------------------------------------------------------
 847
 848 // XPropertySet helper
 849 sal_Bool SAL_CALL TabWindow::convertFastPropertyValue( css::uno::Any&       aConvertedValue ,
 850                                                        css::uno::Any&       aOldValue       ,
 851                                                        sal_Int32                        nHandle         ,
 852                                                        const css::uno::Any& aValue             )
 853 throw( css::lang::IllegalArgumentException )
 854 {
 855     //  Initialize state with FALSE !!!
 856     //  (Handle can be invalid)
 857     sal_Bool bReturn = sal_False;
 858
 859     switch( nHandle )
 860     {
 861         case TABWINDOW_PROPHANDLE_PARENTWINDOW :
 862             bReturn = PropHelper::willPropertyBeChanged(
 863                         com::sun::star::uno::makeAny( m_xContainerWindow ),
 864                         aValue,
 865                         aOldValue,
 866                         aConvertedValue);
 867                 break;
 868
 869         case TABWINDOW_PROPHANDLE_TOPWINDOW :
 870             bReturn = PropHelper::willPropertyBeChanged(
 871                         com::sun::star::uno::makeAny( m_xTopWindow ),
 872                         aValue,
 873                         aOldValue,
 874                         aConvertedValue);
 875                 break;
 876     }
 877
 878     // Return state of operation.
 879     return bReturn ;
 880 }
 881
 882 void SAL_CALL TabWindow::setFastPropertyValue_NoBroadcast( sal_Int32,
 883                                                            const css::uno::Any&)
 884 throw( css::uno::Exception )
 885 {
 886 }
 887
 888 void SAL_CALL TabWindow::getFastPropertyValue( css::uno::Any& aValue  ,
 889                                                sal_Int32      nHandle    ) const
 890 {
 891     switch( nHandle )
 892     {
 893         case TABWINDOW_PROPHANDLE_PARENTWINDOW:
 894             aValue <<= m_xContainerWindow;
 895             break;
 896         case TABWINDOW_PROPHANDLE_TOPWINDOW:
 897             aValue <<= m_xTopWindow;
 898             break;
 899     }
 900 }
 901
 902 ::cppu::IPropertyArrayHelper& SAL_CALL TabWindow::getInfoHelper()
 903 {
 904     // Optimize this method !
 905     // We initialize a static variable only one time. And we don't must use a mutex at every call!
 906     // For the first call; pInfoHelper is NULL - for the second call pInfoHelper is different from NULL!
 907     static ::cppu::OPropertyArrayHelper* pInfoHelper = NULL;
 908
 909     if( pInfoHelper == NULL )
 910     {
 911         // Ready for multithreading
 912         osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
 913
 914         // Control this pointer again, another instance can be faster then these!
 915         if( pInfoHelper == NULL )
 916         {
 917             // Define static member to give structure of properties to baseclass "OPropertySetHelper".
 918             // "impl_getStaticPropertyDescriptor" is a non exported and static funtion, who will define a static propertytable.
 919             // "sal_True" say: Table is sorted by name.
 920             static ::cppu::OPropertyArrayHelper aInfoHelper( impl_getStaticPropertyDescriptor(), sal_True );
 921             pInfoHelper = &aInfoHelper;
 922         }
 923     }
 924
 925     return(*pInfoHelper);
 926 }
 927
 928 css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL TabWindow::getPropertySetInfo()
 929 throw ( css::uno::RuntimeException )
 930 {
 931     // Optimize this method !
 932     // We initialize a static variable only one time. And we don't must use a mutex at every call!
 933     // For the first call; pInfo is NULL - for the second call pInfo is different from NULL!
 934     static css::uno::Reference< css::beans::XPropertySetInfo >* pInfo = NULL;
 935
 936     if( pInfo == NULL )
 937     {
 938         // Ready for multithreading
 939         osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
 940         // Control this pointer again, another instance can be faster then these!
 941         if( pInfo == NULL )
 942         {
 943             // Create structure of propertysetinfo for baseclass "OPropertySetHelper".
 944             // (Use method "getInfoHelper()".)
 945             static css::uno::Reference< css::beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
 946             pInfo = &xInfo;
 947         }
 948     }
 949
 950     return (*pInfo);
 951 }
 952
 953 const css::uno::Sequence< css::beans::Property > TabWindow::impl_getStaticPropertyDescriptor()
 954 {
 955     // Create a new static property array to initialize sequence!
 956     // Table of all predefined properties of this class. Its used from OPropertySetHelper-class!
 957     // Don't forget to change the defines (see begin of this file), if you add, change or delete a property in this list!!!
 958     // It's necessary for methods of OPropertySetHelper.
 959     // ATTENTION:
 960     //      YOU MUST SORT FOLLOW TABLE BY NAME ALPHABETICAL !!!
 961
 962     static const com::sun::star::beans::Property pProperties[] =
 963     {
 964         com::sun::star::beans::Property( TABWINDOW_PROPNAME_PARENTWINDOW,
 965                                          TABWINDOW_PROPHANDLE_PARENTWINDOW,
 966                                          ::getCppuType((const css::uno::Reference< css::awt::XWindow >*)NULL),
 967                                          com::sun::star::beans::PropertyAttribute::READONLY  ),
 968         com::sun::star::beans::Property( TABWINDOW_PROPNAME_TOPWINDOW,
 969                                          TABWINDOW_PROPHANDLE_TOPWINDOW,
 970                                          ::getCppuType((const css::uno::Reference< css::awt::XWindow >*)NULL),
 971                                          com::sun::star::beans::PropertyAttribute::READONLY  )
 972     };  // Use it to initialize sequence!
 973     static const com::sun::star::uno::Sequence< com::sun::star::beans::Property > lPropertyDescriptor( pProperties, TABWINDOW_PROPCOUNT );
 974
 975     // Return static "PropertyDescriptor"
 976     return lPropertyDescriptor;
 977 }
 978
 979 }