svtools/source/uno/toolboxcontroller.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 #include <svtools/toolboxcontroller.hxx>
  21 #include <com/sun/star/beans/PropertyAttribute.hpp>
  22 #include <com/sun/star/beans/PropertyValue.hpp>
  23 #include <com/sun/star/beans/XPropertySet.hpp>
  24 #include <com/sun/star/frame/XDispatchProvider.hpp>
  25 #include <com/sun/star/lang/DisposedException.hpp>
  26 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  27 #include <com/sun/star/frame/XLayoutManager.hpp>
  28 #include <com/sun/star/util/URLTransformer.hpp>
  29 #include <osl/mutex.hxx>
  30 #include <vcl/svapp.hxx>
  31 #include <svtools/imgdef.hxx>
  32 #include <svtools/miscopt.hxx>
  33 #include <toolkit/helper/vclunohelper.hxx>
  34 #include <vcl/toolbox.hxx>
  35 #include <comphelper/processfactory.hxx>
  36
  37 const int TOOLBARCONTROLLER_PROPHANDLE_SUPPORTSVISIBLE  = 1;
  38 const char TOOLBARCONTROLLER_PROPNAME_SUPPORTSVISIBLE[] = "SupportsVisible";
  39
  40
  41 using namespace ::cppu;
  42 using namespace ::com::sun::star::awt;
  43 using namespace ::com::sun::star::uno;
  44 using namespace ::com::sun::star::util;
  45 using namespace ::com::sun::star::beans;
  46 using namespace ::com::sun::star::lang;
  47 using namespace ::com::sun::star::frame;
  48
  49 namespace svt
  50 {
  51
  52 ToolboxController::ToolboxController(
  53     const Reference< XComponentContext >& rxContext,
  54     const Reference< XFrame >& xFrame,
  55     const OUString& aCommandURL ) :
  56     OPropertyContainer(GetBroadcastHelper())
  57     ,   OWeakObject()
  58     ,   m_bSupportVisible(sal_False)
  59     ,   m_bInitialized( sal_False )
  60     ,   m_bDisposed( sal_False )
  61     ,   m_nToolBoxId( SAL_MAX_UINT16 )
  62     ,   m_xFrame(xFrame)
  63     ,   m_xContext( rxContext )
  64     ,   m_aCommandURL( aCommandURL )
  65     ,   m_aListenerContainer( m_aMutex )
  66 {
  67     OSL_ASSERT( m_xContext.is() );
  68     registerProperty( OUString(TOOLBARCONTROLLER_PROPNAME_SUPPORTSVISIBLE),
  69         TOOLBARCONTROLLER_PROPHANDLE_SUPPORTSVISIBLE,
  70         css::beans::PropertyAttribute::TRANSIENT | css::beans::PropertyAttribute::READONLY,
  71         &m_bSupportVisible, getCppuType(&m_bSupportVisible));
  72
  73     try
  74     {
  75         m_xUrlTransformer = URLTransformer::create( rxContext );
  76     }
  77     catch(const Exception&)
  78     {
  79     }
  80 }
  81
  82 ToolboxController::ToolboxController() :
  83     OPropertyContainer(GetBroadcastHelper())
  84     ,   OWeakObject()
  85     ,   m_bSupportVisible(sal_False)
  86     ,   m_bInitialized( sal_False )
  87     ,   m_bDisposed( sal_False )
  88     ,   m_nToolBoxId( SAL_MAX_UINT16 )
  89     ,   m_aListenerContainer( m_aMutex )
  90 {
  91     registerProperty( OUString(TOOLBARCONTROLLER_PROPNAME_SUPPORTSVISIBLE),
  92         TOOLBARCONTROLLER_PROPHANDLE_SUPPORTSVISIBLE,
  93         css::beans::PropertyAttribute::TRANSIENT | css::beans::PropertyAttribute::READONLY,
  94         &m_bSupportVisible, getCppuType(&m_bSupportVisible));
  95 }
  96
  97 ToolboxController::~ToolboxController()
  98 {
  99 }
 100
 101 Reference< XFrame > ToolboxController::getFrameInterface() const
 102 {
 103     SolarMutexGuard aSolarMutexGuard;
 104     return m_xFrame;
 105 }
 106
 107 const Reference< XComponentContext > & ToolboxController::getContext() const
 108 {
 109     SolarMutexGuard aSolarMutexGuard;
 110     return m_xContext;
 111 }
 112
 113 Reference< XLayoutManager > ToolboxController::getLayoutManager() const
 114 {
 115     Reference< XLayoutManager > xLayoutManager;
 116     Reference< XPropertySet > xPropSet;
 117     {
 118         SolarMutexGuard aSolarMutexGuard;
 119         xPropSet = Reference< XPropertySet >( m_xFrame, UNO_QUERY );
 120     }
 121
 122     if ( xPropSet.is() )
 123     {
 124         try
 125         {
 126             xLayoutManager.set(xPropSet->getPropertyValue("LayoutManager"),UNO_QUERY);
 127         }
 128         catch ( Exception& )
 129         {
 130         }
 131     }
 132
 133     return xLayoutManager;
 134 }
 135
 136 // XInterface
 137 Any SAL_CALL ToolboxController::queryInterface( const Type& rType )
 138 throw ( RuntimeException )
 139 {
 140     Any a = ::cppu::queryInterface(
 141                 rType ,
 142                 static_cast< XToolbarController* >( this ),
 143                 static_cast< XStatusListener* >( this ),
 144                 static_cast< XEventListener* >( this ),
 145                 static_cast< XInitialization* >( this ),
 146                 static_cast< XComponent* >( this ),
 147                 static_cast< XUpdatable* >( this ));
 148     if ( !a.hasValue())
 149     {
 150         a = ::cppu::queryInterface(rType
 151             ,static_cast<XPropertySet*>(this)
 152             ,static_cast<XMultiPropertySet*>(this)
 153             ,static_cast<XFastPropertySet*>(this));
 154         if (!a.hasValue())
 155             return OWeakObject::queryInterface( rType );
 156     }
 157     return a;
 158 }
 159
 160 void SAL_CALL ToolboxController::acquire() throw ()
 161 {
 162     OWeakObject::acquire();
 163 }
 164
 165 void SAL_CALL ToolboxController::release() throw ()
 166 {
 167     OWeakObject::release();
 168 }
 169
 170 void SAL_CALL ToolboxController::initialize( const Sequence< Any >& aArguments )
 171 throw ( Exception, RuntimeException )
 172 {
 173     bool bInitialized( true );
 174
 175     {
 176         SolarMutexGuard aSolarMutexGuard;
 177
 178         if ( m_bDisposed )
 179             throw DisposedException();
 180
 181         bInitialized = m_bInitialized;
 182     }
 183
 184     if ( !bInitialized )
 185     {
 186         SolarMutexGuard aSolarMutexGuard;
 187         m_bInitialized = sal_True;
 188         //shizhoubo add
 189         m_bSupportVisible = sal_False;
 190         PropertyValue aPropValue;
 191         for ( int i = 0; i < aArguments.getLength(); i++ )
 192         {
 193             if ( aArguments[i] >>= aPropValue )
 194             {
 195                 if ( aPropValue.Name == "Frame" )
 196                     m_xFrame.set(aPropValue.Value,UNO_QUERY);
 197                 else if ( aPropValue.Name == "CommandURL" )
 198                     aPropValue.Value >>= m_aCommandURL;
 199                 else if ( aPropValue.Name == "ServiceManager" )
 200                 {
 201                     Reference<XMultiServiceFactory> xMSF(aPropValue.Value, UNO_QUERY);
 202                     if (xMSF.is())
 203                         m_xContext = comphelper::getComponentContext(xMSF);
 204                 }
 205                 else if ( aPropValue.Name == "ParentWindow" )
 206                     m_xParentWindow.set(aPropValue.Value,UNO_QUERY);
 207                 else if ( aPropValue.Name == "ModuleIdentifier" )
 208                     aPropValue.Value >>= m_sModuleName;
 209                 else if ( aPropValue.Name == "Identifier" )
 210                     aPropValue.Value >>= m_nToolBoxId;
 211             }
 212         }
 213
 214         try
 215         {
 216             if ( !m_xUrlTransformer.is() && m_xContext.is() )
 217                 m_xUrlTransformer = URLTransformer::create( m_xContext );
 218         }
 219         catch(const Exception&)
 220         {
 221         }
 222
 223         if ( !m_aCommandURL.isEmpty() )
 224             m_aListenerMap.insert( URLToDispatchMap::value_type( m_aCommandURL, Reference< XDispatch >() ));
 225     }
 226 }
 227
 228 void SAL_CALL ToolboxController::update()
 229 throw ( RuntimeException )
 230 {
 231     {
 232         SolarMutexGuard aSolarMutexGuard;
 233         if ( m_bDisposed )
 234             throw DisposedException();
 235     }
 236
 237     // Bind all registered listeners to their dispatch objects
 238     bindListener();
 239 }
 240
 241 // XComponent
 242 void SAL_CALL ToolboxController::dispose()
 243 throw (::com::sun::star::uno::RuntimeException)
 244 {
 245     Reference< XComponent > xThis( static_cast< OWeakObject* >(this), UNO_QUERY );
 246
 247     {
 248         SolarMutexGuard aSolarMutexGuard;
 249         if ( m_bDisposed )
 250             throw DisposedException();
 251     }
 252
 253     com::sun::star::lang::EventObject aEvent( xThis );
 254     m_aListenerContainer.disposeAndClear( aEvent );
 255
 256     SolarMutexGuard aSolarMutexGuard;
 257     Reference< XStatusListener > xStatusListener( static_cast< OWeakObject* >( this ), UNO_QUERY );
 258     URLToDispatchMap::iterator pIter = m_aListenerMap.begin();
 259     while ( pIter != m_aListenerMap.end() )
 260     {
 261         try
 262         {
 263             Reference< XDispatch > xDispatch( pIter->second );
 264
 265             com::sun::star::util::URL aTargetURL;
 266             aTargetURL.Complete = pIter->first;
 267             if ( m_xUrlTransformer.is() )
 268                 m_xUrlTransformer->parseStrict( aTargetURL );
 269
 270             if ( xDispatch.is() && xStatusListener.is() )
 271                 xDispatch->removeStatusListener( xStatusListener, aTargetURL );
 272         }
 273         catch ( Exception& )
 274         {
 275         }
 276
 277         ++pIter;
 278     }
 279
 280     m_bDisposed = sal_True;
 281 }
 282
 283 void SAL_CALL ToolboxController::addEventListener( const Reference< XEventListener >& xListener )
 284 throw ( RuntimeException )
 285 {
 286     m_aListenerContainer.addInterface( ::getCppuType( ( const Reference< XEventListener >* ) NULL ), xListener );
 287 }
 288
 289 void SAL_CALL ToolboxController::removeEventListener( const Reference< XEventListener >& aListener )
 290 throw ( RuntimeException )
 291 {
 292     m_aListenerContainer.removeInterface( ::getCppuType( ( const Reference< XEventListener >* ) NULL ), aListener );
 293 }
 294
 295 // XEventListener
 296 void SAL_CALL ToolboxController::disposing( const EventObject& Source )
 297 throw ( RuntimeException )
 298 {
 299     Reference< XInterface > xSource( Source.Source );
 300
 301     SolarMutexGuard aSolarMutexGuard;
 302
 303     if ( m_bDisposed )
 304         return;
 305
 306     URLToDispatchMap::iterator pIter = m_aListenerMap.begin();
 307     while ( pIter != m_aListenerMap.end() )
 308     {
 309         // Compare references and release dispatch references if they are equal.
 310         Reference< XInterface > xIfac( pIter->second, UNO_QUERY );
 311         if ( xSource == xIfac )
 312             pIter->second.clear();
 313         ++pIter;
 314     }
 315
 316     Reference< XInterface > xIfac( m_xFrame, UNO_QUERY );
 317     if ( xIfac == xSource )
 318         m_xFrame.clear();
 319 }
 320
 321 // XStatusListener
 322 void SAL_CALL ToolboxController::statusChanged( const FeatureStateEvent& )
 323 throw ( RuntimeException )
 324 {
 325     // must be implemented by sub class
 326 }
 327
 328 // XToolbarController
 329 void SAL_CALL ToolboxController::execute( sal_Int16 KeyModifier )
 330 throw (::com::sun::star::uno::RuntimeException)
 331 {
 332     Reference< XDispatch >       xDispatch;
 333     OUString                     aCommandURL;
 334
 335     {
 336         SolarMutexGuard aSolarMutexGuard;
 337
 338         if ( m_bDisposed )
 339             throw DisposedException();
 340
 341         if ( m_bInitialized &&
 342              m_xFrame.is() &&
 343              m_xContext.is() &&
 344              !m_aCommandURL.isEmpty() )
 345         {
 346
 347             aCommandURL = m_aCommandURL;
 348             URLToDispatchMap::iterator pIter = m_aListenerMap.find( m_aCommandURL );
 349             if ( pIter != m_aListenerMap.end() )
 350                 xDispatch = pIter->second;
 351         }
 352     }
 353
 354     if ( xDispatch.is() )
 355     {
 356         try
 357         {
 358             com::sun::star::util::URL aTargetURL;
 359             Sequence<PropertyValue>   aArgs( 1 );
 360
 361             // Provide key modifier information to dispatch function
 362             aArgs[0].Name   = "KeyModifier";
 363             aArgs[0].Value  = makeAny( KeyModifier );
 364
 365             aTargetURL.Complete = aCommandURL;
 366             if ( m_xUrlTransformer.is() )
 367                 m_xUrlTransformer->parseStrict( aTargetURL );
 368             xDispatch->dispatch( aTargetURL, aArgs );
 369         }
 370         catch ( DisposedException& )
 371         {
 372         }
 373     }
 374 }
 375
 376 void SAL_CALL ToolboxController::click()
 377 throw (::com::sun::star::uno::RuntimeException)
 378 {
 379 }
 380
 381 void SAL_CALL ToolboxController::doubleClick()
 382 throw (::com::sun::star::uno::RuntimeException)
 383 {
 384 }
 385
 386 Reference< XWindow > SAL_CALL ToolboxController::createPopupWindow()
 387 throw (::com::sun::star::uno::RuntimeException)
 388 {
 389     return Reference< XWindow >();
 390 }
 391
 392 Reference< XWindow > SAL_CALL ToolboxController::createItemWindow( const Reference< XWindow >& )
 393 throw (::com::sun::star::uno::RuntimeException)
 394 {
 395     return Reference< XWindow >();
 396 }
 397
 398 void ToolboxController::addStatusListener( const OUString& aCommandURL )
 399 {
 400     Reference< XDispatch >       xDispatch;
 401     Reference< XStatusListener > xStatusListener;
 402     com::sun::star::util::URL    aTargetURL;
 403
 404     {
 405         SolarMutexGuard aSolarMutexGuard;
 406         URLToDispatchMap::iterator pIter = m_aListenerMap.find( aCommandURL );
 407
 408         // Already in the list of status listener. Do nothing.
 409         if ( pIter != m_aListenerMap.end() )
 410             return;
 411
 412         // Check if we are already initialized. Implementation starts adding itself as status listener when
 413         // intialize is called.
 414         if ( !m_bInitialized )
 415         {
 416             // Put into the boost::unordered_map of status listener. Will be activated when initialized is called
 417             m_aListenerMap.insert( URLToDispatchMap::value_type( aCommandURL, Reference< XDispatch >() ));
 418             return;
 419         }
 420         else
 421         {
 422             // Add status listener directly as intialize has already been called.
 423             Reference< XDispatchProvider > xDispatchProvider( m_xFrame, UNO_QUERY );
 424             if ( m_xContext.is() && xDispatchProvider.is() )
 425             {
 426                 aTargetURL.Complete = aCommandURL;
 427                 if ( m_xUrlTransformer.is() )
 428                     m_xUrlTransformer->parseStrict( aTargetURL );
 429                 xDispatch = xDispatchProvider->queryDispatch( aTargetURL, OUString(), 0 );
 430
 431                 xStatusListener = Reference< XStatusListener >( static_cast< OWeakObject* >( this ), UNO_QUERY );
 432                 URLToDispatchMap::iterator aIter = m_aListenerMap.find( aCommandURL );
 433                 if ( aIter != m_aListenerMap.end() )
 434                 {
 435                     Reference< XDispatch > xOldDispatch( aIter->second );
 436                     aIter->second = xDispatch;
 437
 438                     try
 439                     {
 440                         if ( xOldDispatch.is() )
 441                             xOldDispatch->removeStatusListener( xStatusListener, aTargetURL );
 442                     }
 443                     catch ( Exception& )
 444                     {
 445                     }
 446                 }
 447                 else
 448                     m_aListenerMap.insert( URLToDispatchMap::value_type( aCommandURL, xDispatch ));
 449             }
 450         }
 451     }
 452
 453     // Call without locked mutex as we are called back from dispatch implementation
 454     try
 455     {
 456         if ( xDispatch.is() )
 457             xDispatch->addStatusListener( xStatusListener, aTargetURL );
 458     }
 459     catch ( Exception& )
 460     {
 461     }
 462 }
 463
 464 void ToolboxController::removeStatusListener( const OUString& aCommandURL )
 465 {
 466     SolarMutexGuard aSolarMutexGuard;
 467
 468     URLToDispatchMap::iterator pIter = m_aListenerMap.find( aCommandURL );
 469     if ( pIter != m_aListenerMap.end() )
 470     {
 471         Reference< XDispatch > xDispatch( pIter->second );
 472         Reference< XStatusListener > xStatusListener( static_cast< OWeakObject* >( this ), UNO_QUERY );
 473         m_aListenerMap.erase( pIter );
 474
 475         try
 476         {
 477             com::sun::star::util::URL aTargetURL;
 478             aTargetURL.Complete = aCommandURL;
 479             if ( m_xUrlTransformer.is() )
 480                 m_xUrlTransformer->parseStrict( aTargetURL );
 481
 482             if ( xDispatch.is() && xStatusListener.is() )
 483                 xDispatch->removeStatusListener( xStatusListener, aTargetURL );
 484         }
 485         catch ( Exception& )
 486         {
 487         }
 488     }
 489 }
 490
 491 void ToolboxController::bindListener()
 492 {
 493     std::vector< Listener > aDispatchVector;
 494     Reference< XStatusListener > xStatusListener;
 495
 496     {
 497         SolarMutexGuard aSolarMutexGuard;
 498
 499         if ( !m_bInitialized )
 500             return;
 501
 502         // Collect all registered command URL's and store them temporary
 503         Reference< XDispatchProvider > xDispatchProvider( m_xFrame, UNO_QUERY );
 504         if ( m_xContext.is() && xDispatchProvider.is() )
 505         {
 506             xStatusListener = Reference< XStatusListener >( static_cast< OWeakObject* >( this ), UNO_QUERY );
 507             URLToDispatchMap::iterator pIter = m_aListenerMap.begin();
 508             while ( pIter != m_aListenerMap.end() )
 509             {
 510                 com::sun::star::util::URL aTargetURL;
 511                 aTargetURL.Complete = pIter->first;
 512                 if ( m_xUrlTransformer.is() )
 513                     m_xUrlTransformer->parseStrict( aTargetURL );
 514
 515                 Reference< XDispatch > xDispatch( pIter->second );
 516                 if ( xDispatch.is() )
 517                 {
 518                     // We already have a dispatch object => we have to requery.
 519                     // Release old dispatch object and remove it as listener
 520                     try
 521                     {
 522                         xDispatch->removeStatusListener( xStatusListener, aTargetURL );
 523                     }
 524                     catch ( Exception& )
 525                     {
 526                     }
 527                 }
 528
 529                 pIter->second.clear();
 530                 xDispatch.clear();
 531
 532                 // Query for dispatch object. Old dispatch will be released with this, too.
 533                 try
 534                 {
 535                     xDispatch = xDispatchProvider->queryDispatch( aTargetURL, OUString(), 0 );
 536                 }
 537                 catch ( Exception& )
 538                 {
 539                 }
 540                 pIter->second = xDispatch;
 541
 542                 Listener aListener( aTargetURL, xDispatch );
 543                 aDispatchVector.push_back( aListener );
 544                 ++pIter;
 545             }
 546         }
 547     }
 548
 549     // Call without locked mutex as we are called back from dispatch implementation
 550     if ( xStatusListener.is() )
 551     {
 552         try
 553         {
 554             for ( sal_uInt32 i = 0; i < aDispatchVector.size(); i++ )
 555             {
 556                 Listener& rListener = aDispatchVector[i];
 557                 if ( rListener.xDispatch.is() )
 558                     rListener.xDispatch->addStatusListener( xStatusListener, rListener.aURL );
 559                 else if ( rListener.aURL.Complete == m_aCommandURL )
 560                 {
 561                     try
 562                     {
 563                         // Send status changed for the main URL, if we cannot get a valid dispatch object.
 564                         // UI disables the button. Catch exception as we release our mutex, it is possible
 565                         // that someone else already disposed this instance!
 566                         FeatureStateEvent aFeatureStateEvent;
 567                         aFeatureStateEvent.IsEnabled = sal_False;
 568                         aFeatureStateEvent.FeatureURL = rListener.aURL;
 569                         aFeatureStateEvent.State = Any();
 570                         xStatusListener->statusChanged( aFeatureStateEvent );
 571                     }
 572                     catch ( Exception& )
 573                     {
 574                     }
 575                 }
 576             }
 577         }
 578         catch ( Exception& )
 579         {
 580         }
 581     }
 582 }
 583
 584 void ToolboxController::unbindListener()
 585 {
 586     SolarMutexGuard aSolarMutexGuard;
 587
 588     if ( !m_bInitialized )
 589         return;
 590
 591     // Collect all registered command URL's and store them temporary
 592     Reference< XDispatchProvider > xDispatchProvider( m_xFrame, UNO_QUERY );
 593     if ( m_xContext.is() && xDispatchProvider.is() )
 594     {
 595         Reference< XStatusListener > xStatusListener( static_cast< OWeakObject* >( this ), UNO_QUERY );
 596         URLToDispatchMap::iterator pIter = m_aListenerMap.begin();
 597         while ( pIter != m_aListenerMap.end() )
 598         {
 599             com::sun::star::util::URL aTargetURL;
 600             aTargetURL.Complete = pIter->first;
 601             if ( m_xUrlTransformer.is() )
 602                 m_xUrlTransformer->parseStrict( aTargetURL );
 603
 604             Reference< XDispatch > xDispatch( pIter->second );
 605             if ( xDispatch.is() )
 606             {
 607                 // We already have a dispatch object => we have to requery.
 608                 // Release old dispatch object and remove it as listener
 609                 try
 610                 {
 611                     xDispatch->removeStatusListener( xStatusListener, aTargetURL );
 612                 }
 613                 catch ( Exception& )
 614                 {
 615                 }
 616             }
 617             pIter->second.clear();
 618             ++pIter;
 619         }
 620     }
 621 }
 622
 623 sal_Bool ToolboxController::isBound() const
 624 {
 625     SolarMutexGuard aSolarMutexGuard;
 626
 627     if ( !m_bInitialized )
 628         return sal_False;
 629
 630     URLToDispatchMap::const_iterator pIter = m_aListenerMap.find( m_aCommandURL );
 631     if ( pIter != m_aListenerMap.end() )
 632         return ( pIter->second.is() );
 633
 634     return sal_False;
 635 }
 636
 637 void ToolboxController::updateStatus()
 638 {
 639     bindListener();
 640 }
 641
 642 void ToolboxController::updateStatus( const OUString aCommandURL )
 643 {
 644     Reference< XDispatch > xDispatch;
 645     Reference< XStatusListener > xStatusListener;
 646     com::sun::star::util::URL aTargetURL;
 647
 648     {
 649         SolarMutexGuard aSolarMutexGuard;
 650
 651         if ( !m_bInitialized )
 652             return;
 653
 654         // Try to find a dispatch object for the requested command URL
 655         Reference< XDispatchProvider > xDispatchProvider( m_xFrame, UNO_QUERY );
 656         xStatusListener = Reference< XStatusListener >( static_cast< OWeakObject* >( this ), UNO_QUERY );
 657         if ( m_xContext.is() && xDispatchProvider.is() )
 658         {
 659             aTargetURL.Complete = aCommandURL;
 660             if ( m_xUrlTransformer.is() )
 661                 m_xUrlTransformer->parseStrict( aTargetURL );
 662             xDispatch = xDispatchProvider->queryDispatch( aTargetURL, OUString(), 0 );
 663         }
 664     }
 665
 666     if ( xDispatch.is() && xStatusListener.is() )
 667     {
 668         // Catch exception as we release our mutex, it is possible that someone else
 669         // has already disposed this instance!
 670         // Add/remove status listener to get a update status information from the
 671         // requested command.
 672         try
 673         {
 674             xDispatch->addStatusListener( xStatusListener, aTargetURL );
 675             xDispatch->removeStatusListener( xStatusListener, aTargetURL );
 676         }
 677         catch ( Exception& )
 678         {
 679         }
 680     }
 681 }
 682
 683 Reference< XURLTransformer > ToolboxController::getURLTransformer() const
 684 {
 685     return m_xUrlTransformer;
 686 }
 687
 688 Reference< ::com::sun::star::awt::XWindow > ToolboxController::getParent() const
 689 {
 690     return m_xParentWindow;
 691 }
 692
 693 void ToolboxController::dispatchCommand( const OUString& sCommandURL, const Sequence< PropertyValue >& rArgs, const OUString &sTarget )
 694 {
 695     try
 696     {
 697         Reference< XDispatchProvider > xDispatchProvider( m_xFrame, UNO_QUERY_THROW );
 698         URL aURL;
 699         aURL.Complete = sCommandURL;
 700         getURLTransformer()->parseStrict( aURL );
 701
 702         Reference< XDispatch > xDispatch( xDispatchProvider->queryDispatch( aURL, sTarget, 0 ), UNO_QUERY_THROW );
 703
 704         DispatchInfo *pDispatchInfo = new DispatchInfo( xDispatch, aURL, rArgs );
 705         if ( !Application::PostUserEvent( STATIC_LINK(0, ToolboxController, ExecuteHdl_Impl),
 706                                           pDispatchInfo ) )
 707             delete pDispatchInfo;
 708
 709     }
 710     catch( Exception& )
 711     {
 712     }
 713 }
 714
 715 //
 716 //-------------------------------------------------------------------------
 717 // XPropertySet by shizhoubo
 718 com::sun::star::uno::Reference< com::sun::star::beans::XPropertySetInfo >  SAL_CALL ToolboxController::getPropertySetInfo() throw(::com::sun::star::uno::RuntimeException)
 719 {
 720     Reference<XPropertySetInfo>  xInfo( createPropertySetInfo( getInfoHelper() ) );
 721     return xInfo;
 722 }
 723 //-------------------------------------------------------------------------
 724 ::cppu::IPropertyArrayHelper& ToolboxController::getInfoHelper()
 725 {
 726         return *const_cast<ToolboxController*>(this)->getArrayHelper();
 727 }
 728 //OPropertyArrayUsageHelper by shizhoubo
 729 //------------------------------------------------------------------------------
 730 ::cppu::IPropertyArrayHelper* ToolboxController::createArrayHelper( ) const
 731 {
 732         com::sun::star::uno::Sequence< Property > aProps;
 733         describeProperties(aProps);
 734         return new ::cppu::OPropertyArrayHelper(aProps);
 735 }
 736 //shizhoubo for supportsvisiable
 737 void ToolboxController::setSupportVisibleProperty(sal_Bool bValue)
 738 {
 739     m_bSupportVisible = bValue;
 740 }
 741 //OPropertySetHelper by shizhoubo
 742 sal_Bool SAL_CALL ToolboxController::convertFastPropertyValue( com::sun::star::uno::Any&    aConvertedValue ,
 743                                              com::sun::star::uno::Any&        aOldValue       ,
 744                                              sal_Int32                        nHandle         ,
 745                                              const com::sun::star::uno::Any&  aValue          ) throw( com::sun::star::lang::IllegalArgumentException )
 746 {
 747     switch (nHandle)
 748     {
 749         case TOOLBARCONTROLLER_PROPHANDLE_SUPPORTSVISIBLE:
 750         {
 751             sal_Bool aNewValue(sal_False);
 752             aValue >>= aNewValue;
 753             if (aNewValue != m_bSupportVisible)
 754             {
 755                 aConvertedValue <<= aNewValue;
 756                 aOldValue <<= m_bSupportVisible;
 757                 return sal_True;
 758             }
 759             return sal_False;
 760         }
 761     }
 762     return OPropertyContainer::convertFastPropertyValue(aConvertedValue, aOldValue, nHandle, aValue);
 763 }
 764
 765 void SAL_CALL ToolboxController::setFastPropertyValue_NoBroadcast(
 766     sal_Int32                       nHandle,
 767     const com::sun::star::uno::Any& aValue )
 768 throw( com::sun::star::uno::Exception)
 769 {
 770     OPropertyContainer::setFastPropertyValue_NoBroadcast(nHandle, aValue);
 771     if (TOOLBARCONTROLLER_PROPHANDLE_SUPPORTSVISIBLE == nHandle)
 772     {
 773         sal_Bool rValue(sal_False);
 774         if (( aValue >>= rValue ) && m_bInitialized)
 775             this->setSupportVisibleProperty( rValue );
 776     }
 777 }
 778
 779 //--------------------------------------------------------------------
 780
 781 IMPL_STATIC_LINK_NOINSTANCE( ToolboxController, ExecuteHdl_Impl, DispatchInfo*, pDispatchInfo )
 782 {
 783     pDispatchInfo->mxDispatch->dispatch( pDispatchInfo->maURL, pDispatchInfo->maArgs );
 784     delete pDispatchInfo;
 785     return 0;
 786 }
 787
 788 void ToolboxController::enable( bool bEnable )
 789 {
 790     ToolBox* pToolBox = 0;
 791     sal_uInt16 nItemId = 0;
 792     if( getToolboxId( nItemId, &pToolBox ) )
 793     {
 794         pToolBox->EnableItem( nItemId, bEnable ? sal_True : sal_False );
 795     }
 796 }
 797
 798 bool ToolboxController::getToolboxId( sal_uInt16& rItemId, ToolBox** ppToolBox )
 799 {
 800     if( (m_nToolBoxId != SAL_MAX_UINT16) && (ppToolBox == 0) )
 801         return m_nToolBoxId;
 802
 803     ToolBox* pToolBox = static_cast< ToolBox* >( VCLUnoHelper::GetWindow( getParent() ) );
 804
 805     if( (m_nToolBoxId == SAL_MAX_UINT16) && pToolBox )
 806     {
 807         const sal_uInt16 nCount = pToolBox->GetItemCount();
 808         for ( sal_uInt16 nPos = 0; nPos < nCount; ++nPos )
 809         {
 810             const sal_uInt16 nItemId = pToolBox->GetItemId( nPos );
 811             if ( pToolBox->GetItemCommand( nItemId ) == m_aCommandURL )
 812             {
 813                 m_nToolBoxId = nItemId;
 814                 break;
 815             }
 816         }
 817     }
 818
 819     if( ppToolBox )
 820         *ppToolBox = pToolBox;
 821
 822     rItemId = m_nToolBoxId;
 823
 824     return (rItemId != SAL_MAX_UINT16) && (( ppToolBox == 0) || (*ppToolBox != 0) );
 825 }
 826 //end
 827
 828 } // svt
 829
 830 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */