framework/source/uifactory/addonstoolbarfactory.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 <sal/config.h>
  21
  22 #include <string_view>
  23
  24 #include <uielement/addonstoolbarwrapper.hxx>
  25
  26 #include <com/sun/star/frame/ModuleManager.hpp>
  27 #include <com/sun/star/frame/XModuleManager2.hpp>
  28 #include <com/sun/star/frame/XFrame.hpp>
  29 #include <com/sun/star/lang/XServiceInfo.hpp>
  30 #include <com/sun/star/ui/XUIElementFactory.hpp>
  31
  32 #include <comphelper/propertyvalue.hxx>
  33 #include <cppuhelper/implbase.hxx>
  34 #include <cppuhelper/supportsservice.hxx>
  35 #include <vcl/svapp.hxx>
  36
  37 using namespace com::sun::star::uno;
  38 using namespace com::sun::star::lang;
  39 using namespace com::sun::star::frame;
  40 using namespace com::sun::star::beans;
  41 using namespace ::com::sun::star::ui;
  42 using namespace framework;
  43
  44 namespace {
  45
  46 class AddonsToolBarFactory :  public ::cppu::WeakImplHelper< css::lang::XServiceInfo ,
  47                                                               css::ui::XUIElementFactory >
  48 {
  49 public:
  50     explicit AddonsToolBarFactory( const css::uno::Reference< css::uno::XComponentContext >& xContext );
  51
  52     virtual OUString SAL_CALL getImplementationName() override
  53     {
  54         return u"com.sun.star.comp.framework.AddonsToolBarFactory"_ustr;
  55     }
  56
  57     virtual sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override
  58     {
  59         return cppu::supportsService(this, ServiceName);
  60     }
  61
  62     virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override
  63     {
  64         return {u"com.sun.star.ui.ToolBarFactory"_ustr};
  65     }
  66
  67     // XUIElementFactory
  68     virtual css::uno::Reference< css::ui::XUIElement > SAL_CALL createUIElement( const OUString& ResourceURL, const css::uno::Sequence< css::beans::PropertyValue >& Args ) override;
  69
  70     bool hasButtonsInContext( const css::uno::Sequence< css::uno::Sequence< css::beans::PropertyValue > >& rPropSeq,
  71                                   const css::uno::Reference< css::frame::XFrame >& rFrame );
  72
  73 private:
  74     css::uno::Reference< css::uno::XComponentContext >     m_xContext;
  75     css::uno::Reference< css::frame::XModuleManager2 >     m_xModuleManager;
  76 };
  77
  78 AddonsToolBarFactory::AddonsToolBarFactory(
  79     const css::uno::Reference< css::uno::XComponentContext >& xContext ) :
  80     m_xContext( xContext )
  81     , m_xModuleManager( ModuleManager::create( xContext ) )
  82 {
  83 }
  84
  85 bool IsCorrectContext( std::u16string_view rModuleIdentifier, std::u16string_view aContextList )
  86 {
  87     if ( aContextList.empty() )
  88         return true;
  89
  90     if ( !rModuleIdentifier.empty() )
  91     {
  92         return aContextList.find( rModuleIdentifier ) != std::u16string_view::npos;
  93     }
  94
  95     return false;
  96 }
  97
  98 bool AddonsToolBarFactory::hasButtonsInContext(
  99     const Sequence< Sequence< PropertyValue > >& rPropSeqSeq,
 100     const Reference< XFrame >& rFrame )
 101 {
 102     OUString aModuleIdentifier;
 103     try
 104     {
 105         aModuleIdentifier = m_xModuleManager->identify( rFrame );
 106     }
 107     catch ( const RuntimeException& )
 108     {
 109         throw;
 110     }
 111     catch ( const Exception& )
 112     {
 113     }
 114
 115     // Check before we create a toolbar that we have at least one button in
 116     // the current frame context.
 117     for ( Sequence<PropertyValue> const & props : rPropSeqSeq )
 118     {
 119         bool    bIsButton( true );
 120         bool    bIsCorrectContext( false );
 121         sal_uInt32  nPropChecked( 0 );
 122
 123         for ( PropertyValue const & prop : props )
 124         {
 125             if ( prop.Name == "Context" )
 126             {
 127                 OUString aContextList;
 128                 if ( prop.Value >>= aContextList )
 129                     bIsCorrectContext = IsCorrectContext( aModuleIdentifier, aContextList );
 130                 nPropChecked++;
 131             }
 132             else if ( prop.Name == "URL" )
 133             {
 134                 OUString aURL;
 135                 prop.Value >>= aURL;
 136                 bIsButton = aURL != "private:separator";
 137                 nPropChecked++;
 138             }
 139
 140             if ( nPropChecked == 2 )
 141                 break;
 142         }
 143
 144         if ( bIsButton && bIsCorrectContext )
 145             return true;
 146     }
 147
 148     return false;
 149 }
 150
 151 // XUIElementFactory
 152 Reference< XUIElement > SAL_CALL AddonsToolBarFactory::createUIElement(
 153     const OUString& ResourceURL,
 154     const Sequence< PropertyValue >& Args )
 155 {
 156     SolarMutexGuard g;
 157
 158     Sequence< Sequence< PropertyValue > >   aConfigData;
 159     Reference< XFrame >                     xFrame;
 160     OUString                           aResourceURL( ResourceURL );
 161
 162     for ( PropertyValue const & arg : Args )
 163     {
 164         if ( arg.Name == "ConfigurationData" )
 165             arg.Value >>= aConfigData;
 166         else if ( arg.Name == "Frame" )
 167             arg.Value >>= xFrame;
 168         else if ( arg.Name == "ResourceURL" )
 169             arg.Value >>= aResourceURL;
 170     }
 171
 172     if ( !aResourceURL.startsWith("private:resource/toolbar/addon_") )
 173         throw IllegalArgumentException();
 174
 175     // Identify frame and determine module identifier to look for context based buttons
 176     Reference< css::ui::XUIElement > xToolBar;
 177     if ( xFrame.is() &&
 178          aConfigData.hasElements() &&
 179          hasButtonsInContext( aConfigData, xFrame ))
 180     {
 181         Sequence< Any > aPropSeq{ Any(comphelper::makePropertyValue(u"Frame"_ustr, xFrame)),
 182                                   Any(comphelper::makePropertyValue(u"ConfigurationData"_ustr,
 183                                                                     aConfigData)),
 184                                   Any(comphelper::makePropertyValue(u"ResourceURL"_ustr, aResourceURL)) };
 185
 186         SolarMutexGuard aGuard;
 187         rtl::Reference<AddonsToolBarWrapper> pToolBarWrapper = new AddonsToolBarWrapper( m_xContext );
 188         xToolBar = pToolBarWrapper;
 189         pToolBarWrapper->initialize( aPropSeq );
 190     }
 191
 192     return xToolBar;
 193 }
 194
 195 }
 196
 197 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 198 com_sun_star_comp_framework_AddonsToolBarFactory_get_implementation(
 199     css::uno::XComponentContext *context,
 200     css::uno::Sequence<css::uno::Any> const &)
 201 {
 202     return cppu::acquire(new AddonsToolBarFactory(context));
 203 }
 204
 205 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */