sfx2/source/sidebar/CommandInfoProvider.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 <sfx2/sidebar/CommandInfoProvider.hxx>
  21
  22 #include <comphelper/processfactory.hxx>
  23 #include <svtools/acceleratorexecute.hxx>
  24 #include <cppuhelper/compbase1.hxx>
  25 #include <cppuhelper/basemutex.hxx>
  26
  27 #include <com/sun/star/frame/ModuleManager.hpp>
  28 #include <com/sun/star/frame/theUICommandDescription.hpp>
  29 #include <com/sun/star/ui/GlobalAcceleratorConfiguration.hpp>
  30 #include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp>
  31 #include <com/sun/star/ui/theModuleUIConfigurationManagerSupplier.hpp>
  32
  33 using namespace css;
  34 using namespace css::uno;
  35 using ::rtl::OUString;
  36
  37
  38 namespace
  39 {
  40     typedef ::cppu::WeakComponentImplHelper1 <
  41         css::lang::XEventListener
  42         > FrameListenerInterfaceBase;
  43     class FrameListener
  44         : public ::cppu::BaseMutex,
  45           public FrameListenerInterfaceBase
  46     {
  47     public:
  48         FrameListener (sfx2::sidebar::CommandInfoProvider& rInfoProvider, const Reference<frame::XFrame>& rxFrame)
  49             : FrameListenerInterfaceBase(m_aMutex),
  50               mrInfoProvider(rInfoProvider),
  51               mxFrame(rxFrame)
  52         {
  53             if (mxFrame.is())
  54                 mxFrame->addEventListener(this);
  55         }
  56         virtual ~FrameListener()
  57         {
  58         }
  59         virtual void SAL_CALL disposing() SAL_OVERRIDE
  60         {
  61             if (mxFrame.is())
  62                 mxFrame->removeEventListener(this);
  63         }
  64         virtual void SAL_CALL disposing (const css::lang::EventObject& rEvent)
  65             throw (css::uno::RuntimeException, std::exception) SAL_OVERRIDE
  66         {
  67             (void)rEvent;
  68             mrInfoProvider.SetFrame(NULL);
  69             mxFrame = NULL;
  70         }
  71
  72     private:
  73         sfx2::sidebar::CommandInfoProvider& mrInfoProvider;
  74         Reference<frame::XFrame> mxFrame;
  75     };
  76 }
  77
  78 namespace sfx2 { namespace sidebar {
  79
  80 CommandInfoProvider& CommandInfoProvider::Instance()
  81 {
  82     static CommandInfoProvider aProvider;
  83     return aProvider;
  84 }
  85
  86 CommandInfoProvider::CommandInfoProvider()
  87     : mxContext(comphelper::getProcessComponentContext()),
  88       mxCachedDataFrame(),
  89       mxCachedDocumentAcceleratorConfiguration(),
  90       mxCachedModuleAcceleratorConfiguration(),
  91       mxCachedGlobalAcceleratorConfiguration(),
  92       msCachedModuleIdentifier(),
  93       mxFrameListener()
  94 {
  95 }
  96
  97 CommandInfoProvider::~CommandInfoProvider()
  98 {
  99     if (mxFrameListener.is())
 100     {
 101         mxFrameListener->dispose();
 102         mxFrameListener = NULL;
 103     }
 104 }
 105
 106
 107 OUString CommandInfoProvider::GetLabelForCommand (
 108     const OUString& rsCommandName,
 109     const Reference<frame::XFrame>& rxFrame)
 110 {
 111     SetFrame(rxFrame);
 112
 113     const OUString sLabel (GetCommandLabel(rsCommandName));
 114     const OUString sShortCut (GetCommandShortcut(rsCommandName));
 115     if (sShortCut.getLength() > 0)
 116         return sLabel + " (" + sShortCut + ")";
 117     else
 118         return sLabel;
 119 }
 120
 121 void CommandInfoProvider::SetFrame (const Reference<frame::XFrame>& rxFrame)
 122 {
 123     if (rxFrame != mxCachedDataFrame)
 124     {
 125         // Detach from the old frame.
 126         if (mxFrameListener.is())
 127         {
 128             mxFrameListener->dispose();
 129             mxFrameListener = NULL;
 130         }
 131
 132         // Release objects that are tied to the old frame.
 133         mxCachedDocumentAcceleratorConfiguration = NULL;
 134         mxCachedModuleAcceleratorConfiguration = NULL;
 135         msCachedModuleIdentifier.clear();
 136         mxCachedDataFrame = rxFrame;
 137
 138         // Connect to the new frame.
 139         if (rxFrame.is())
 140             mxFrameListener = new FrameListener(*this, rxFrame);
 141     }
 142 }
 143
 144 Reference<ui::XAcceleratorConfiguration> CommandInfoProvider::GetDocumentAcceleratorConfiguration()
 145 {
 146     if ( ! mxCachedDocumentAcceleratorConfiguration.is())
 147     {
 148         // Get the accelerator configuration for the document.
 149         if (mxCachedDataFrame.is())
 150         {
 151             Reference<frame::XController> xController = mxCachedDataFrame->getController();
 152             if (xController.is())
 153             {
 154                 Reference<frame::XModel> xModel (xController->getModel());
 155                 if (xModel.is())
 156                 {
 157                     Reference<ui::XUIConfigurationManagerSupplier> xSupplier (xModel, UNO_QUERY);
 158                     if (xSupplier.is())
 159                     {
 160                         Reference<ui::XUIConfigurationManager> xConfigurationManager(
 161                             xSupplier->getUIConfigurationManager(),
 162                             UNO_QUERY);
 163                         if (xConfigurationManager.is())
 164                         {
 165                             mxCachedDocumentAcceleratorConfiguration = xConfigurationManager->getShortCutManager();
 166                         }
 167                     }
 168                 }
 169             }
 170         }
 171     }
 172     return mxCachedDocumentAcceleratorConfiguration;
 173 }
 174
 175 Reference<ui::XAcceleratorConfiguration> CommandInfoProvider::GetModuleAcceleratorConfiguration()
 176 {
 177     if ( ! mxCachedModuleAcceleratorConfiguration.is())
 178     {
 179         try
 180         {
 181             Reference<ui::XModuleUIConfigurationManagerSupplier> xSupplier  = ui::theModuleUIConfigurationManagerSupplier::get(mxContext);
 182             Reference<ui::XUIConfigurationManager> xManager (
 183                 xSupplier->getUIConfigurationManager(GetModuleIdentifier()));
 184             if (xManager.is())
 185             {
 186                 mxCachedModuleAcceleratorConfiguration = xManager->getShortCutManager();
 187             }
 188         }
 189         catch (Exception&)
 190         {
 191         }
 192     }
 193     return mxCachedModuleAcceleratorConfiguration;
 194 }
 195
 196 Reference<ui::XAcceleratorConfiguration> CommandInfoProvider::GetGlobalAcceleratorConfiguration()
 197 {
 198     // Get the global accelerator configuration.
 199     if ( ! mxCachedGlobalAcceleratorConfiguration.is())
 200     {
 201         mxCachedGlobalAcceleratorConfiguration = ui::GlobalAcceleratorConfiguration::create(mxContext);
 202     }
 203
 204     return mxCachedGlobalAcceleratorConfiguration;
 205 }
 206
 207 OUString CommandInfoProvider::GetModuleIdentifier()
 208 {
 209     if (msCachedModuleIdentifier.getLength() == 0)
 210     {
 211         Reference<frame::XModuleManager2> xModuleManager = frame::ModuleManager::create(mxContext);
 212         msCachedModuleIdentifier = xModuleManager->identify(mxCachedDataFrame);
 213     }
 214     return msCachedModuleIdentifier;
 215 }
 216
 217 OUString CommandInfoProvider::GetCommandShortcut (const OUString& rsCommandName)
 218 {
 219     OUString sShortcut;
 220
 221     sShortcut = RetrieveShortcutsFromConfiguration(GetDocumentAcceleratorConfiguration(), rsCommandName);
 222     if (sShortcut.getLength() > 0)
 223         return sShortcut;
 224
 225     sShortcut = RetrieveShortcutsFromConfiguration(GetModuleAcceleratorConfiguration(), rsCommandName);
 226     if (sShortcut.getLength() > 0)
 227         return sShortcut;
 228
 229     sShortcut = RetrieveShortcutsFromConfiguration(GetGlobalAcceleratorConfiguration(), rsCommandName);
 230     if (sShortcut.getLength() > 0)
 231         return sShortcut;
 232
 233     return OUString();
 234 }
 235
 236 OUString CommandInfoProvider::RetrieveShortcutsFromConfiguration(
 237     const Reference<ui::XAcceleratorConfiguration>& rxConfiguration,
 238     const OUString& rsCommandName)
 239 {
 240     if (rxConfiguration.is())
 241     {
 242         try
 243         {
 244             Sequence<OUString> aCommands(1);
 245             aCommands[0] = rsCommandName;
 246
 247             Sequence<Any> aKeyCodes (rxConfiguration->getPreferredKeyEventsForCommandList(aCommands));
 248             if (aCommands.getLength() == 1)
 249             {
 250                 css::awt::KeyEvent aKeyEvent;
 251                 if (aKeyCodes[0] >>= aKeyEvent)
 252                 {
 253                     return svt::AcceleratorExecute::st_AWTKey2VCLKey(aKeyEvent).GetName();
 254                 }
 255             }
 256         }
 257         catch (lang::IllegalArgumentException&)
 258         {
 259         }
 260     }
 261     return OUString();
 262 }
 263
 264 Sequence<beans::PropertyValue> CommandInfoProvider::GetCommandProperties (const OUString& rsCommandName)
 265 {
 266     Sequence<beans::PropertyValue> aProperties;
 267
 268     try
 269     {
 270         const OUString sModuleIdentifier (GetModuleIdentifier());
 271         if (sModuleIdentifier.getLength() > 0)
 272         {
 273             Reference<container::XNameAccess> xNameAccess  = frame::theUICommandDescription::get(mxContext);
 274             Reference<container::XNameAccess> xUICommandLabels;
 275             if (xNameAccess->getByName(sModuleIdentifier) >>= xUICommandLabels)
 276                 xUICommandLabels->getByName(rsCommandName) >>= aProperties;
 277         }
 278     }
 279     catch (Exception&)
 280     {
 281     }
 282
 283     return aProperties;
 284 }
 285
 286 OUString CommandInfoProvider::GetCommandLabel (const OUString& rsCommandName)
 287 {
 288     const Sequence<beans::PropertyValue> aProperties (GetCommandProperties(rsCommandName));
 289     for (sal_Int32 nIndex=0; nIndex<aProperties.getLength(); ++nIndex)
 290     {
 291         if (aProperties[nIndex].Name == "Name")
 292         {
 293             OUString sLabel;
 294             aProperties[nIndex].Value >>= sLabel;
 295             return sLabel;
 296         }
 297     }
 298     return OUString();
 299 }
 300
 301 } } // end of namespace sfx2/framework
 302
 303 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */