framework/source/uielement/addonstoolbarmanager.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 <uielement/addonstoolbarmanager.hxx>
  21 #include <uielement/toolbarmerger.hxx>
  22
  23 #include <uielement/generictoolbarcontroller.hxx>
  24 #include "services.h"
  25 #include <framework/imageproducer.hxx>
  26 #include <framework/sfxhelperfunctions.hxx>
  27 #include <classes/fwkresid.hxx>
  28 #include <classes/resource.hrc>
  29 #include <framework/addonsoptions.hxx>
  30 #include <uielement/comboboxtoolbarcontroller.hxx>
  31 #include <uielement/imagebuttontoolbarcontroller.hxx>
  32 #include <uielement/togglebuttontoolbarcontroller.hxx>
  33 #include <uielement/buttontoolbarcontroller.hxx>
  34 #include <uielement/spinfieldtoolbarcontroller.hxx>
  35 #include <uielement/edittoolbarcontroller.hxx>
  36 #include <uielement/dropdownboxtoolbarcontroller.hxx>
  37
  38 #include <com/sun/star/ui/ItemType.hpp>
  39 #include <com/sun/star/frame/ModuleManager.hpp>
  40 #include <com/sun/star/frame/XToolbarController.hpp>
  41 #include <com/sun/star/frame/XDispatchProvider.hpp>
  42 #include <com/sun/star/lang/XServiceInfo.hpp>
  43 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  44 #include <com/sun/star/frame/XLayoutManager.hpp>
  45 #include <com/sun/star/ui/DockingArea.hpp>
  46 #include <com/sun/star/lang/XMultiComponentFactory.hpp>
  47 #include <comphelper/processfactory.hxx>
  48 #include <svtools/imgdef.hxx>
  49 #include <svtools/toolboxcontroller.hxx>
  50 #include <toolkit/helper/vclunohelper.hxx>
  51
  52 #include <svtools/miscopt.hxx>
  53 #include <vcl/svapp.hxx>
  54 #include <vcl/menu.hxx>
  55 #include <vcl/syswin.hxx>
  56 #include <vcl/taskpanelist.hxx>
  57 #include <vcl/toolbox.hxx>
  58 #include <vcl/settings.hxx>
  59
  60 //  namespaces
  61
  62 using namespace ::com::sun::star;
  63 using namespace ::com::sun::star::awt;
  64 using namespace ::com::sun::star::beans;
  65 using namespace ::com::sun::star::uno;
  66 using namespace ::com::sun::star::lang;
  67 using namespace ::com::sun::star::frame;
  68 using namespace ::com::sun::star::util;
  69 using namespace ::com::sun::star::container;
  70 using namespace ::com::sun::star::ui;
  71
  72 namespace framework
  73 {
  74
  75 static const char   TOOLBOXITEM_SEPARATOR_STR[] = "private:separator";
  76
  77 AddonsToolBarManager::AddonsToolBarManager( const Reference< XComponentContext >& rxContext,
  78                                 const Reference< XFrame >& rFrame,
  79                                 const OUString& rResourceName,
  80                                 ToolBox* pToolBar ) :
  81     ToolBarManager( rxContext, rFrame, rResourceName, pToolBar )
  82 {
  83     m_pToolBar->SetMenuType( TOOLBOX_MENUTYPE_CLIPPEDITEMS );
  84     m_pToolBar->SetSelectHdl( LINK( this, AddonsToolBarManager, Select) );
  85     m_pToolBar->SetActivateHdl( LINK( this, AddonsToolBarManager, Activate) );
  86     m_pToolBar->SetDeactivateHdl( LINK( this, AddonsToolBarManager, Deactivate) );
  87     m_pToolBar->SetClickHdl( LINK( this, AddonsToolBarManager, Click ) );
  88     m_pToolBar->SetDoubleClickHdl( LINK( this, AddonsToolBarManager, DoubleClick ) );
  89     m_pToolBar->SetCommandHdl( LINK( this, AddonsToolBarManager, Command ) );
  90     m_pToolBar->SetStateChangedHdl( LINK( this, AddonsToolBarManager, StateChanged ) );
  91     m_pToolBar->SetDataChangedHdl( LINK( this, AddonsToolBarManager, DataChanged ) );
  92 }
  93
  94 AddonsToolBarManager::~AddonsToolBarManager()
  95 {
  96 }
  97
  98 static bool IsCorrectContext( const OUString& rModuleIdentifier, const OUString& aContextList )
  99 {
 100     if ( aContextList.isEmpty() )
 101         return true;
 102
 103     if ( !rModuleIdentifier.isEmpty() )
 104     {
 105         sal_Int32 nIndex = aContextList.indexOf( rModuleIdentifier );
 106         return ( nIndex >= 0 );
 107     }
 108
 109     return false;
 110 }
 111
 112 static Image RetrieveImage( Reference< com::sun::star::frame::XFrame >& rFrame,
 113                             const OUString& aImageId,
 114                             const OUString& aURL,
 115                             bool bBigImage
 116 )
 117 {
 118     Image aImage;
 119
 120     if ( !aImageId.isEmpty() )
 121     {
 122         aImage = framework::AddonsOptions().GetImageFromURL( aImageId, bBigImage );
 123         if ( !!aImage )
 124             return aImage;
 125         else
 126             aImage = GetImageFromURL( rFrame, aImageId, bBigImage );
 127         if ( !!aImage )
 128             return aImage;
 129     }
 130
 131     aImage = framework::AddonsOptions().GetImageFromURL( aURL, bBigImage );
 132     if ( !aImage )
 133         aImage = GetImageFromURL( rFrame, aImageId, bBigImage );
 134
 135     return aImage;
 136 }
 137
 138 // XComponent
 139 void SAL_CALL AddonsToolBarManager::dispose() throw( RuntimeException, std::exception )
 140 {
 141     Reference< XComponent > xThis( static_cast< OWeakObject* >(this), UNO_QUERY );
 142
 143     {
 144         // Remove addon specific data from toolbar items.
 145         SolarMutexGuard g;
 146         for ( sal_uInt16 n = 0; n < m_pToolBar->GetItemCount(); n++ )
 147         {
 148             sal_uInt16 nId( m_pToolBar->GetItemId( n ) );
 149
 150             if ( nId > 0 )
 151             {
 152                 AddonsParams* pRuntimeItemData = static_cast<AddonsParams*>(m_pToolBar->GetItemData( nId ));
 153                 if ( pRuntimeItemData )
 154                     delete pRuntimeItemData;
 155                 m_pToolBar->SetItemData( nId, NULL );
 156             }
 157         }
 158     }
 159
 160     // Base class will destroy our m_pToolBar member
 161     ToolBarManager::dispose();
 162 }
 163
 164 bool AddonsToolBarManager::MenuItemAllowed( sal_uInt16 nId ) const
 165 {
 166     if (( nId == MENUITEM_TOOLBAR_VISIBLEBUTTON ) ||
 167         ( nId == MENUITEM_TOOLBAR_CUSTOMIZETOOLBAR ))
 168         return false;
 169     else
 170         return true;
 171 }
 172
 173 void AddonsToolBarManager::RefreshImages()
 174 {
 175     bool  bBigImages( SvtMiscOptions().AreCurrentSymbolsLarge() );
 176     for ( sal_uInt16 nPos = 0; nPos < m_pToolBar->GetItemCount(); nPos++ )
 177     {
 178         sal_uInt16 nId( m_pToolBar->GetItemId( nPos ) );
 179
 180         if ( nId > 0 )
 181         {
 182             OUString aCommandURL = m_pToolBar->GetItemCommand( nId );
 183             OUString aImageId;
 184             AddonsParams* pRuntimeItemData = static_cast<AddonsParams*>(m_pToolBar->GetItemData( nId ));
 185             if ( pRuntimeItemData )
 186                 aImageId  = pRuntimeItemData->aImageId;
 187
 188             m_pToolBar->SetItemImage(
 189                 nId,
 190                 RetrieveImage( m_xFrame, aImageId, aCommandURL, bBigImages )
 191             );
 192         }
 193     }
 194     m_pToolBar->SetToolboxButtonSize( bBigImages ? TOOLBOX_BUTTONSIZE_LARGE : TOOLBOX_BUTTONSIZE_SMALL );
 195     ::Size aSize = m_pToolBar->CalcWindowSizePixel();
 196     m_pToolBar->SetOutputSizePixel( aSize );
 197 }
 198
 199 void AddonsToolBarManager::FillToolbar( const Sequence< Sequence< PropertyValue > >& rAddonToolbar )
 200 {
 201     SolarMutexGuard g;
 202
 203     if ( m_bDisposed )
 204         return;
 205
 206     sal_uInt16 nId( 1 );
 207
 208     RemoveControllers();
 209
 210     m_pToolBar->Clear();
 211     m_aControllerMap.clear();
 212
 213     OUString aModuleIdentifier;
 214     try
 215     {
 216         Reference< XModuleManager2 > xModuleManager = ModuleManager::create( m_xContext );
 217         aModuleIdentifier = xModuleManager->identify( m_xFrame );
 218     }
 219     catch ( const Exception& )
 220     {
 221     }
 222
 223     sal_uInt32  nElements( 0 );
 224     bool    bAppendSeparator( false );
 225     Reference< XWindow > xToolbarWindow = VCLUnoHelper::GetInterface( m_pToolBar );
 226     for ( sal_uInt32 n = 0; n < (sal_uInt32)rAddonToolbar.getLength(); n++ )
 227     {
 228         OUString   aURL;
 229         OUString   aTitle;
 230         OUString   aImageId;
 231         OUString   aContext;
 232         OUString   aTarget;
 233         OUString   aControlType;
 234         sal_uInt16      nWidth( 0 );
 235
 236         const Sequence< PropertyValue >& rSeq = rAddonToolbar[n];
 237
 238         ToolBarMerger::ConvertSequenceToValues( rSeq, aURL, aTitle, aImageId, aTarget, aContext, aControlType, nWidth );
 239
 240         if ( IsCorrectContext( aModuleIdentifier, aContext ))
 241         {
 242             if ( aURL == TOOLBOXITEM_SEPARATOR_STR )
 243             {
 244                 sal_uInt16 nCount = m_pToolBar->GetItemCount();
 245                 if ( nCount > 0 && ( m_pToolBar->GetItemType( nCount-1 ) != ToolBoxItemType::SEPARATOR ) && nElements > 0 )
 246                 {
 247                     nElements = 0;
 248                     m_pToolBar->InsertSeparator();
 249                 }
 250             }
 251             else
 252             {
 253                 sal_uInt16 nCount = m_pToolBar->GetItemCount();
 254                 if ( bAppendSeparator && nCount > 0 && ( m_pToolBar->GetItemType( nCount-1 ) != ToolBoxItemType::SEPARATOR ))
 255                 {
 256                     // We have to append a separator first if the last item is not a separator
 257                     m_pToolBar->InsertSeparator();
 258                 }
 259                 bAppendSeparator = false;
 260
 261                 m_pToolBar->InsertItem( nId, aTitle );
 262
 263                 // don't setup images yet, AddonsToolbarWrapper::populateImages does that.
 264
 265                 // Create TbRuntimeItemData to hold additional information we will need in the future
 266                 AddonsParams* pRuntimeItemData = new AddonsParams;
 267                 pRuntimeItemData->aImageId  = aImageId;
 268                 pRuntimeItemData->aTarget   = aTarget;
 269                 m_pToolBar->SetItemData( nId, pRuntimeItemData );
 270                 m_pToolBar->SetItemCommand( nId, aURL );
 271
 272                 Reference< XStatusListener > xController;
 273
 274                 bool bMustBeInit( true );
 275
 276                 // Support external toolbar controller for add-ons!
 277                 if ( m_xToolbarControllerFactory.is() &&
 278                      m_xToolbarControllerFactory->hasController( aURL, m_aModuleIdentifier ))
 279                 {
 280                     Sequence< Any > aArgs(5);
 281                     PropertyValue   aPropValue;
 282
 283                     aPropValue.Name     = "ModuleIdentifier";
 284                     aPropValue.Value    <<= m_aModuleIdentifier;
 285                     aArgs[0] <<= aPropValue;
 286                     aPropValue.Name     = "Frame";
 287                     aPropValue.Value    <<= m_xFrame;
 288                     aArgs[1] <<= aPropValue;
 289                     aPropValue.Name     = "ServiceManager";
 290                     aPropValue.Value    <<= Reference<XMultiServiceFactory>(m_xContext->getServiceManager(), UNO_QUERY_THROW);
 291                     aArgs[2] <<= aPropValue;
 292                     aPropValue.Name     = "ParentWindow";
 293                     aPropValue.Value    <<= xToolbarWindow;
 294                     aArgs[3] <<= aPropValue;
 295                     aPropValue.Name     = "ItemId";
 296                     aPropValue.Value    = makeAny( sal_Int32( nId ));
 297                     aArgs[4] <<= aPropValue;
 298
 299                     try
 300                     {
 301                         xController = Reference< XStatusListener >( m_xToolbarControllerFactory->createInstanceWithArgumentsAndContext(
 302                                                                         aURL, aArgs, m_xContext ),
 303                                                                     UNO_QUERY );
 304                     }
 305                     catch ( uno::Exception& )
 306                     {
 307                     }
 308                     bMustBeInit = false; // factory called init already!
 309                 }
 310                 else
 311                 {
 312                     ::cppu::OWeakObject* pController = 0;
 313
 314                     pController = ToolBarMerger::CreateController( m_xContext, m_xFrame, m_pToolBar, aURL, nId, nWidth, aControlType );
 315                     xController = Reference< XStatusListener >( pController, UNO_QUERY );
 316                 }
 317
 318                 // insert controller to the map
 319                 m_aControllerMap[nId] = xController;
 320
 321                 Reference< XInitialization > xInit( xController, UNO_QUERY );
 322                 if ( xInit.is() && bMustBeInit )
 323                 {
 324                     PropertyValue aPropValue;
 325                     Sequence< Any > aArgs( 3 );
 326                     aPropValue.Name = "Frame";
 327                     aPropValue.Value <<= m_xFrame;
 328                     aArgs[0] <<= aPropValue;
 329                     aPropValue.Name = "CommandURL";
 330                     aPropValue.Value <<= aURL;
 331                     aArgs[1] <<= aPropValue;
 332                     aPropValue.Name = "ServiceManager";
 333                     aPropValue.Value <<= Reference<XMultiServiceFactory>(m_xContext->getServiceManager(), UNO_QUERY_THROW);
 334                     aArgs[2] <<= aPropValue;
 335                     try
 336                     {
 337                         xInit->initialize( aArgs );
 338                     }
 339                     catch ( const uno::Exception& )
 340                     {
 341                     }
 342                 }
 343
 344                 // Request a item window from the toolbar controller and set it at the VCL toolbar
 345                 Reference< XToolbarController > xTbxController( xController, UNO_QUERY );
 346                 if ( xTbxController.is() && xToolbarWindow.is() )
 347                 {
 348                     Reference< XWindow > xWindow = xTbxController->createItemWindow( xToolbarWindow );
 349                     if ( xWindow.is() )
 350                     {
 351                         vcl::Window* pItemWin = VCLUnoHelper::GetWindow( xWindow );
 352                         if ( pItemWin )
 353                         {
 354                             WindowType nType = pItemWin->GetType();
 355                             if ( nType == WINDOW_LISTBOX || nType == WINDOW_MULTILISTBOX || nType == WINDOW_COMBOBOX )
 356                                 pItemWin->SetAccessibleName( m_pToolBar->GetItemText( nId ) );
 357                             m_pToolBar->SetItemWindow( nId, pItemWin );
 358                         }
 359                     }
 360                 }
 361
 362                 // Notify controller implementation to its listeners. Controller is now useable from outside.
 363                 Reference< XUpdatable > xUpdatable( xController, UNO_QUERY );
 364                 if ( xUpdatable.is() )
 365                 {
 366                     try
 367                     {
 368                         xUpdatable->update();
 369                     }
 370                     catch ( const uno::Exception& )
 371                     {
 372                     }
 373                 }
 374
 375                 ++nId;
 376                 ++nElements;
 377             }
 378         }
 379     }
 380
 381     AddFrameActionListener();
 382 }
 383
 384 IMPL_LINK_NOARG_TYPED(AddonsToolBarManager, Click, ToolBox *, void)
 385 {
 386     if ( m_bDisposed )
 387         return;
 388
 389     sal_uInt16 nId( m_pToolBar->GetCurItemId() );
 390     ToolBarControllerMap::const_iterator pIter = m_aControllerMap.find( nId );
 391     if ( pIter != m_aControllerMap.end() )
 392     {
 393         Reference< XToolbarController > xController( pIter->second, UNO_QUERY );
 394
 395         if ( xController.is() )
 396             xController->click();
 397     }
 398 }
 399
 400 IMPL_LINK_NOARG_TYPED(AddonsToolBarManager, DoubleClick, ToolBox *, void)
 401 {
 402     if ( m_bDisposed )
 403         return;
 404
 405     sal_uInt16 nId( m_pToolBar->GetCurItemId() );
 406     ToolBarControllerMap::const_iterator pIter = m_aControllerMap.find( nId );
 407     if ( pIter != m_aControllerMap.end() )
 408     {
 409         Reference< XToolbarController > xController( pIter->second, UNO_QUERY );
 410
 411         if ( xController.is() )
 412             xController->doubleClick();
 413     }
 414 }
 415
 416 IMPL_LINK_NOARG_TYPED(AddonsToolBarManager, Command, CommandEvent const *, void)
 417 {}
 418
 419 IMPL_LINK_NOARG_TYPED(AddonsToolBarManager, Select, ToolBox *, void)
 420 {
 421     if ( m_bDisposed )
 422         return;
 423
 424     sal_Int16   nKeyModifier( (sal_Int16)m_pToolBar->GetModifier() );
 425     sal_uInt16      nId( m_pToolBar->GetCurItemId() );
 426     ToolBarControllerMap::const_iterator pIter = m_aControllerMap.find( nId );
 427     if ( pIter != m_aControllerMap.end() )
 428     {
 429         Reference< XToolbarController > xController( pIter->second, UNO_QUERY );
 430
 431         if ( xController.is() )
 432             xController->execute( nKeyModifier );
 433     }
 434 }
 435
 436 IMPL_LINK_NOARG_TYPED(AddonsToolBarManager, Activate, ToolBox *, void)
 437 {}
 438
 439 IMPL_LINK_NOARG_TYPED(AddonsToolBarManager, Deactivate, ToolBox *, void)
 440 {}
 441
 442 IMPL_LINK_TYPED( AddonsToolBarManager, StateChanged, StateChangedType const *, pStateChangedType, void )
 443 {
 444     if ( *pStateChangedType == StateChangedType::ControlBackground )
 445     {
 446         CheckAndUpdateImages();
 447     }
 448 }
 449
 450 IMPL_LINK_TYPED( AddonsToolBarManager, DataChanged, DataChangedEvent const *, pDataChangedEvent, void )
 451 {
 452     if ((( pDataChangedEvent->GetType() == DataChangedEventType::SETTINGS )   ||
 453         (  pDataChangedEvent->GetType() == DataChangedEventType::DISPLAY  ))  &&
 454         ( pDataChangedEvent->GetFlags() & AllSettingsFlags::STYLE        ))
 455     {
 456         CheckAndUpdateImages();
 457     }
 458
 459     for ( sal_uInt16 nPos = 0; nPos < m_pToolBar->GetItemCount(); ++nPos )
 460     {
 461         const sal_uInt16 nId = m_pToolBar->GetItemId(nPos);
 462         vcl::Window* pWindow = m_pToolBar->GetItemWindow( nId );
 463         if ( pWindow )
 464         {
 465             const DataChangedEvent& rDCEvt( *pDataChangedEvent );
 466             pWindow->DataChanged( rDCEvt );
 467         }
 468     }
 469 }
 470
 471 }
 472
 473 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */