framework/source/fwe/classes/rootactiontriggercontainer.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <classes/rootactiontriggercontainer.hxx>
  22 #include <classes/actiontriggercontainer.hxx>
  23 #include <classes/actiontriggerpropertyset.hxx>
  24 #include <classes/actiontriggerseparatorpropertyset.hxx>
  25 #include <framework/actiontriggerhelper.hxx>
  26 #include <threadhelp/resetableguard.hxx>
  27 #include <osl/mutex.hxx>
  28 #include <vcl/svapp.hxx>
  29 #include <cppuhelper/typeprovider.hxx>
  30
  31
  32 using namespace cppu;
  33 using namespace com::sun::star::uno;
  34 using namespace com::sun::star::lang;
  35 using namespace com::sun::star::container;
  36 using namespace com::sun::star::beans;
  37
  38
  39 namespace framework
  40 {
  41
  42 static Sequence< sal_Int8 > impl_getStaticIdentifier()
  43 {
  44     static sal_uInt8 pGUID[16] = { 0x17, 0x0F, 0xA2, 0xC9, 0xCA, 0x50, 0x4A, 0xD3, 0xA6, 0x3B, 0x39, 0x99, 0xC5, 0x96, 0x43, 0x27 };
  45     static ::com::sun::star::uno::Sequence< sal_Int8 > seqID((sal_Int8*)pGUID,16) ;
  46     return seqID ;
  47 }
  48
  49
  50 RootActionTriggerContainer::RootActionTriggerContainer( const Menu* pMenu, const OUString* pMenuIdentifier ) :
  51     PropertySetContainer()
  52     ,   m_bContainerCreated( sal_False )
  53     ,   m_bContainerChanged( sal_False )
  54     ,   m_bInContainerCreation( sal_False )
  55     ,   m_pMenu( pMenu )
  56     ,   m_pMenuIdentifier( pMenuIdentifier )
  57 {
  58 }
  59
  60 RootActionTriggerContainer::~RootActionTriggerContainer()
  61 {
  62 }
  63
  64 // XInterface
  65 Any SAL_CALL RootActionTriggerContainer::queryInterface( const Type& aType )
  66 throw ( RuntimeException )
  67 {
  68     Any a = ::cppu::queryInterface(
  69                 aType ,
  70                 (static_cast< XMultiServiceFactory*   >(this)),
  71                 (static_cast< XServiceInfo*           >(this)),
  72                 (static_cast< XUnoTunnel*             >(this)),
  73                 (static_cast< XTypeProvider*          >(this)),
  74                 (static_cast< XNamed*                 >(this)));
  75
  76     if( a.hasValue() )
  77     {
  78         return a;
  79     }
  80
  81     return PropertySetContainer::queryInterface( aType );
  82 }
  83
  84 void SAL_CALL RootActionTriggerContainer::acquire() throw ()
  85 {
  86     PropertySetContainer::acquire();
  87 }
  88
  89 void SAL_CALL RootActionTriggerContainer::release() throw ()
  90 {
  91     PropertySetContainer::release();
  92 }
  93
  94 // XMultiServiceFactory
  95 Reference< XInterface > SAL_CALL RootActionTriggerContainer::createInstance( const OUString& aServiceSpecifier )
  96 throw ( Exception,  RuntimeException )
  97 {
  98     if ( aServiceSpecifier.equalsAscii( SERVICENAME_ACTIONTRIGGER ))
  99         return (OWeakObject *)( new ActionTriggerPropertySet());
 100     else if ( aServiceSpecifier.equalsAscii( SERVICENAME_ACTIONTRIGGERCONTAINER ))
 101         return (OWeakObject *)( new ActionTriggerContainer());
 102     else if ( aServiceSpecifier.equalsAscii( SERVICENAME_ACTIONTRIGGERSEPARATOR ))
 103         return (OWeakObject *)( new ActionTriggerSeparatorPropertySet());
 104     else
 105         throw com::sun::star::uno::RuntimeException( OUString( "Unknown service specifier!" ), (OWeakObject *)this );
 106 }
 107
 108 Reference< XInterface > SAL_CALL RootActionTriggerContainer::createInstanceWithArguments( const OUString& ServiceSpecifier, const Sequence< Any >& /*Arguments*/ )
 109 throw ( Exception, RuntimeException )
 110 {
 111     return createInstance( ServiceSpecifier );
 112 }
 113
 114 Sequence< OUString > SAL_CALL RootActionTriggerContainer::getAvailableServiceNames()
 115 throw ( RuntimeException )
 116 {
 117     Sequence< OUString > aSeq( 3 );
 118
 119     aSeq[0] = OUString( SERVICENAME_ACTIONTRIGGER );
 120     aSeq[1] = OUString( SERVICENAME_ACTIONTRIGGERCONTAINER );
 121     aSeq[2] = OUString( SERVICENAME_ACTIONTRIGGERSEPARATOR );
 122
 123     return aSeq;
 124 }
 125
 126
 127 // XIndexContainer
 128 void SAL_CALL RootActionTriggerContainer::insertByIndex( sal_Int32 Index, const Any& Element )
 129 throw ( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException )
 130 {
 131     ResetableGuard aGuard( m_aLock );
 132
 133     if ( !m_bContainerCreated )
 134         FillContainer();
 135
 136     if ( !m_bInContainerCreation )
 137         m_bContainerChanged = sal_True;
 138     PropertySetContainer::insertByIndex( Index, Element );
 139 }
 140
 141 void SAL_CALL RootActionTriggerContainer::removeByIndex( sal_Int32 Index )
 142 throw ( IndexOutOfBoundsException, WrappedTargetException, RuntimeException )
 143 {
 144     ResetableGuard aGuard( m_aLock );
 145
 146     if ( !m_bContainerCreated )
 147         FillContainer();
 148
 149     if ( !m_bInContainerCreation )
 150         m_bContainerChanged = sal_True;
 151     PropertySetContainer::removeByIndex( Index );
 152 }
 153
 154
 155 // XIndexReplace
 156 void SAL_CALL RootActionTriggerContainer::replaceByIndex( sal_Int32 Index, const Any& Element )
 157 throw ( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException )
 158 {
 159     ResetableGuard aGuard( m_aLock );
 160
 161     if ( !m_bContainerCreated )
 162         FillContainer();
 163
 164     if ( !m_bInContainerCreation )
 165         m_bContainerChanged = sal_True;
 166     PropertySetContainer::replaceByIndex( Index, Element );
 167 }
 168
 169
 170 // XIndexAccess
 171 sal_Int32 SAL_CALL RootActionTriggerContainer::getCount()
 172 throw ( RuntimeException )
 173 {
 174     ResetableGuard aGuard( m_aLock );
 175
 176     if ( !m_bContainerCreated )
 177     {
 178         if ( m_pMenu )
 179         {
 180             SolarMutexGuard aSolarMutexGuard;
 181             return m_pMenu->GetItemCount();
 182         }
 183         else
 184             return 0;
 185     }
 186     else
 187     {
 188         return PropertySetContainer::getCount();
 189     }
 190 }
 191
 192 Any SAL_CALL RootActionTriggerContainer::getByIndex( sal_Int32 Index )
 193 throw ( IndexOutOfBoundsException, WrappedTargetException, RuntimeException )
 194 {
 195     ResetableGuard aGuard( m_aLock );
 196
 197     if ( !m_bContainerCreated )
 198         FillContainer();
 199
 200     return PropertySetContainer::getByIndex( Index );
 201 }
 202
 203
 204 // XElementAccess
 205 Type SAL_CALL RootActionTriggerContainer::getElementType()
 206     throw (::com::sun::star::uno::RuntimeException)
 207 {
 208     return ::getCppuType(( Reference< XPropertySet >*)0);
 209 }
 210
 211 sal_Bool SAL_CALL RootActionTriggerContainer::hasElements()
 212 throw (::com::sun::star::uno::RuntimeException)
 213 {
 214     if ( m_pMenu )
 215     {
 216         SolarMutexGuard aSolarMutexGuard;
 217         return ( m_pMenu->GetItemCount() > 0 );
 218     }
 219
 220     return sal_False;
 221 }
 222
 223
 224 // XServiceInfo
 225 OUString SAL_CALL RootActionTriggerContainer::getImplementationName()
 226 throw ( RuntimeException )
 227 {
 228     return OUString( IMPLEMENTATIONNAME_ROOTACTIONTRIGGERCONTAINER );
 229 }
 230
 231 sal_Bool SAL_CALL RootActionTriggerContainer::supportsService( const OUString& ServiceName )
 232 throw ( RuntimeException )
 233 {
 234     if ( ServiceName.equalsAscii( SERVICENAME_ACTIONTRIGGERCONTAINER ))
 235         return sal_True;
 236
 237     return sal_False;
 238 }
 239
 240 Sequence< OUString > SAL_CALL RootActionTriggerContainer::getSupportedServiceNames()
 241 throw ( RuntimeException )
 242 {
 243     Sequence< OUString > seqServiceNames( 1 );
 244
 245     seqServiceNames[0] = OUString( SERVICENAME_ACTIONTRIGGERCONTAINER );
 246     return seqServiceNames;
 247 }
 248
 249 // XUnoTunnel
 250 sal_Int64 SAL_CALL RootActionTriggerContainer::getSomething( const Sequence< sal_Int8 >& aIdentifier ) throw ( RuntimeException )
 251 {
 252     if ( aIdentifier == impl_getStaticIdentifier() )
 253         return reinterpret_cast< sal_Int64 >( this );
 254     else
 255         return 0;
 256 }
 257
 258 // XTypeProvider
 259 Sequence< Type > SAL_CALL RootActionTriggerContainer::getTypes() throw ( RuntimeException )
 260 {
 261     // Optimize this method !
 262     // We initialize a static variable only one time. And we don't must use a mutex at every call!
 263     // For the first call; pTypeCollection is NULL - for the second call pTypeCollection is different from NULL!
 264     static ::cppu::OTypeCollection* pTypeCollection = NULL ;
 265
 266     if ( pTypeCollection == NULL )
 267     {
 268         // Ready for multithreading; get global mutex for first call of this method only! see before
 269         osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
 270
 271         // Control these pointer again ... it can be, that another instance will be faster then these!
 272         if ( pTypeCollection == NULL )
 273         {
 274             // Create a static typecollection ...
 275             static ::cppu::OTypeCollection aTypeCollection(
 276                         ::getCppuType(( const Reference< XMultiServiceFactory   >*)NULL ) ,
 277                         ::getCppuType(( const Reference< XIndexContainer        >*)NULL ) ,
 278                         ::getCppuType(( const Reference< XServiceInfo           >*)NULL ) ,
 279                         ::getCppuType(( const Reference< XTypeProvider          >*)NULL ) ,
 280                         ::getCppuType(( const Reference< XUnoTunnel             >*)NULL ) ,
 281                         ::getCppuType(( const Reference< XNamed                 >*)NULL )) ;
 282
 283             // ... and set his address to static pointer!
 284             pTypeCollection = &aTypeCollection ;
 285         }
 286     }
 287
 288     return pTypeCollection->getTypes() ;
 289 }
 290
 291 Sequence< sal_Int8 > SAL_CALL RootActionTriggerContainer::getImplementationId() throw ( RuntimeException )
 292 {
 293     // Create one Id for all instances of this class.
 294     // Use ethernet address to do this! (sal_True)
 295
 296     // Optimize this method
 297     // We initialize a static variable only one time. And we don't must use a mutex at every call!
 298     // For the first call; pID is NULL - for the second call pID is different from NULL!
 299     static ::cppu::OImplementationId* pID = NULL ;
 300
 301     if ( pID == NULL )
 302     {
 303         // Ready for multithreading; get global mutex for first call of this method only! see before
 304         osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ;
 305
 306         // Control these pointer again ... it can be, that another instance will be faster then these!
 307         if ( pID == NULL )
 308         {
 309             // Create a new static ID ...
 310             static ::cppu::OImplementationId aID( sal_False ) ;
 311             // ... and set his address to static pointer!
 312             pID = &aID ;
 313         }
 314     }
 315
 316     return pID->getImplementationId() ;
 317 }
 318
 319 // private implementation helper
 320 void RootActionTriggerContainer::FillContainer()
 321 {
 322     m_bContainerCreated = sal_True;
 323     m_bInContainerCreation = sal_True;
 324     Reference<XIndexContainer> xXIndexContainer( (OWeakObject *)this, UNO_QUERY );
 325     ActionTriggerHelper::FillActionTriggerContainerFromMenu(
 326         xXIndexContainer,
 327         m_pMenu );
 328     m_bInContainerCreation = sal_False;
 329 }
 330 OUString RootActionTriggerContainer::getName() throw ( RuntimeException )
 331 {
 332     OUString sRet;
 333     if( m_pMenuIdentifier )
 334         sRet = *m_pMenuIdentifier;
 335     return sRet;
 336 }
 337
 338 void RootActionTriggerContainer::setName( const OUString& ) throw ( RuntimeException)
 339 {
 340     throw RuntimeException();
 341 }
 342 }
 343
 344 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */