framework/source/accelerators/acceleratorconfiguration.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 <accelerators/acceleratorconfiguration.hxx>
  21 #include <accelerators/keymapping.hxx>
  22 #include <accelerators/presethandler.hxx>
  23
  24 #include <xml/saxnamespacefilter.hxx>
  25 #include <xml/acceleratorconfigurationreader.hxx>
  26 #include <xml/acceleratorconfigurationwriter.hxx>
  27
  28 #include <acceleratorconst.h>
  29 #include <services.h>
  30
  31 #include <com/sun/star/xml/sax/Parser.hpp>
  32 #include <com/sun/star/xml/sax/InputSource.hpp>
  33 #include <com/sun/star/xml/sax/Writer.hpp>
  34 #include <com/sun/star/io/XActiveDataSource.hpp>
  35 #include <com/sun/star/embed/ElementModes.hpp>
  36 #include <com/sun/star/io/XSeekable.hpp>
  37 #include <com/sun/star/io/XTruncate.hpp>
  38 #include <com/sun/star/beans/XPropertySet.hpp>
  39
  40 #include <vcl/svapp.hxx>
  41 #include <com/sun/star/container/XNamed.hpp>
  42 #include <com/sun/star/container/XNameContainer.hpp>
  43 #include <com/sun/star/awt/KeyEvent.hpp>
  44 #include <com/sun/star/awt/KeyModifier.hpp>
  45 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  46 #include <comphelper/configurationhelper.hxx>
  47 #include <comphelper/sequence.hxx>
  48 #include <officecfg/Setup.hxx>
  49 #include <unotools/configpaths.hxx>
  50 #include <svtools/acceleratorexecute.hxx>
  51
  52 #define PRESET_DEFAULT "default"
  53 #define TARGET_CURRENT "current"
  54
  55 namespace framework
  56 {
  57     const char CFG_ENTRY_SECONDARY[] = "SecondaryKeys";
  58     const char CFG_PROP_COMMAND[] = "Command";
  59
  60     OUString lcl_getKeyString(const css::awt::KeyEvent& aKeyEvent)
  61     {
  62         const sal_Int32 nBeginIndex = 4; // "KEY_" is the prefix of a identifier...
  63         OUStringBuffer sKeyBuffer((KeyMapping::get().mapCodeToIdentifier(aKeyEvent.KeyCode)).copy(nBeginIndex));
  64
  65         if ( (aKeyEvent.Modifiers & css::awt::KeyModifier::SHIFT) == css::awt::KeyModifier::SHIFT )
  66             sKeyBuffer.append("_SHIFT");
  67         if ( (aKeyEvent.Modifiers & css::awt::KeyModifier::MOD1 ) == css::awt::KeyModifier::MOD1  )
  68             sKeyBuffer.append("_MOD1");
  69         if ( (aKeyEvent.Modifiers & css::awt::KeyModifier::MOD2 ) == css::awt::KeyModifier::MOD2  )
  70             sKeyBuffer.append("_MOD2");
  71         if ( (aKeyEvent.Modifiers & css::awt::KeyModifier::MOD3 ) == css::awt::KeyModifier::MOD3  )
  72             sKeyBuffer.append("_MOD3");
  73
  74         return sKeyBuffer.makeStringAndClear();
  75     }
  76
  77 XMLBasedAcceleratorConfiguration::XMLBasedAcceleratorConfiguration(const css::uno::Reference< css::uno::XComponentContext >& xContext)
  78     : m_xContext      (xContext                     )
  79     , m_aPresetHandler(xContext                     )
  80     , m_pWriteCache   (nullptr                            )
  81 {
  82 }
  83
  84 XMLBasedAcceleratorConfiguration::~XMLBasedAcceleratorConfiguration()
  85 {
  86     SAL_WARN_IF(m_pWriteCache, "fwk", "XMLBasedAcceleratorConfiguration::~XMLBasedAcceleratorConfiguration(): Changes not flushed. Ignore it ...");
  87 }
  88
  89 css::uno::Sequence< css::awt::KeyEvent > SAL_CALL XMLBasedAcceleratorConfiguration::getAllKeyEvents()
  90     throw(css::uno::RuntimeException, std::exception)
  91 {
  92     SolarMutexGuard g;
  93     AcceleratorCache&          rCache = impl_getCFG();
  94     AcceleratorCache::TKeyList lKeys  = rCache.getAllKeys();
  95     return comphelper::containerToSequence(lKeys);
  96 }
  97
  98 OUString SAL_CALL XMLBasedAcceleratorConfiguration::getCommandByKeyEvent(const css::awt::KeyEvent& aKeyEvent)
  99     throw(css::container::NoSuchElementException,
 100           css::uno::RuntimeException, std::exception            )
 101 {
 102     SolarMutexGuard g;
 103     AcceleratorCache& rCache = impl_getCFG();
 104     if (!rCache.hasKey(aKeyEvent))
 105         throw css::container::NoSuchElementException(
 106                 OUString(),
 107                 static_cast< ::cppu::OWeakObject* >(this));
 108     return rCache.getCommandByKey(aKeyEvent);
 109 }
 110
 111 void SAL_CALL XMLBasedAcceleratorConfiguration::setKeyEvent(const css::awt::KeyEvent& aKeyEvent,
 112                                                     const OUString&    sCommand )
 113                                                     throw(css::lang::IllegalArgumentException,
 114                                                     css::uno::RuntimeException, std::exception         )
 115 {
 116     if (
 117         (aKeyEvent.KeyCode   == 0) &&
 118         (aKeyEvent.KeyChar   == 0) &&
 119         (aKeyEvent.KeyFunc   == 0) &&
 120         (aKeyEvent.Modifiers == 0)
 121         )
 122         throw css::lang::IllegalArgumentException(
 123         OUString("Such key event seems not to be supported by any operating system."),
 124         static_cast< ::cppu::OWeakObject* >(this),
 125         0);
 126
 127     if (sCommand.isEmpty())
 128         throw css::lang::IllegalArgumentException(
 129         OUString("Empty command strings are not allowed here."),
 130         static_cast< ::cppu::OWeakObject* >(this),
 131         1);
 132
 133     SolarMutexGuard g;
 134     AcceleratorCache& rCache = impl_getCFG(true); // sal_True => force getting of a writeable cache!
 135     rCache.setKeyCommandPair(aKeyEvent, sCommand);
 136 }
 137
 138 void SAL_CALL XMLBasedAcceleratorConfiguration::removeKeyEvent(const css::awt::KeyEvent& aKeyEvent)
 139 throw(css::container::NoSuchElementException,
 140       css::uno::RuntimeException, std::exception            )
 141 {
 142     SolarMutexGuard g;
 143     AcceleratorCache& rCache = impl_getCFG(true); // true => force using of a writeable cache
 144     if (!rCache.hasKey(aKeyEvent))
 145         throw css::container::NoSuchElementException(
 146         OUString(),
 147         static_cast< ::cppu::OWeakObject* >(this));
 148     rCache.removeKey(aKeyEvent);
 149 }
 150
 151 css::uno::Sequence< css::awt::KeyEvent > SAL_CALL XMLBasedAcceleratorConfiguration::getKeyEventsByCommand(const OUString& sCommand)
 152     throw(css::lang::IllegalArgumentException   ,
 153           css::container::NoSuchElementException,
 154           css::uno::RuntimeException, std::exception            )
 155 {
 156     if (sCommand.isEmpty())
 157         throw css::lang::IllegalArgumentException(
 158                 OUString("Empty command strings are not allowed here."),
 159                 static_cast< ::cppu::OWeakObject* >(this),
 160                 1);
 161
 162     SolarMutexGuard g;
 163     AcceleratorCache& rCache = impl_getCFG();
 164     if (!rCache.hasCommand(sCommand))
 165         throw css::container::NoSuchElementException(
 166                 OUString(),
 167                 static_cast< ::cppu::OWeakObject* >(this));
 168
 169     AcceleratorCache::TKeyList lKeys  = rCache.getKeysByCommand(sCommand);
 170     return comphelper::containerToSequence(lKeys);
 171 }
 172
 173 css::uno::Sequence< css::uno::Any > SAL_CALL XMLBasedAcceleratorConfiguration::getPreferredKeyEventsForCommandList(const css::uno::Sequence< OUString >& lCommandList)
 174     throw (css::lang::IllegalArgumentException, css::container::NoSuchElementException,
 175            css::uno::RuntimeException, std::exception)
 176 {
 177     SolarMutexGuard g;
 178
 179     sal_Int32                           i              = 0;
 180     sal_Int32                           c              = lCommandList.getLength();
 181     css::uno::Sequence< css::uno::Any > lPreferredOnes (c); // don't pack list!
 182     AcceleratorCache&                   rCache         = impl_getCFG();
 183
 184     for (i=0; i<c; ++i)
 185     {
 186         const OUString& rCommand = lCommandList[i];
 187         if (rCommand.isEmpty())
 188             throw css::lang::IllegalArgumentException(
 189                     OUString("Empty command strings are not allowed here."),
 190                     static_cast< ::cppu::OWeakObject* >(this),
 191                     (sal_Int16)i);
 192
 193         if (!rCache.hasCommand(rCommand))
 194             continue;
 195
 196         AcceleratorCache::TKeyList lKeys = rCache.getKeysByCommand(rCommand);
 197         if ( lKeys.empty() )
 198             continue;
 199
 200         css::uno::Any& rAny = lPreferredOnes[i];
 201         rAny <<= *(lKeys.begin());
 202     }
 203
 204     return lPreferredOnes;
 205 }
 206
 207 void SAL_CALL XMLBasedAcceleratorConfiguration::removeCommandFromAllKeyEvents(const OUString& sCommand)
 208     throw(css::lang::IllegalArgumentException   ,
 209           css::container::NoSuchElementException,
 210           css::uno::RuntimeException, std::exception            )
 211 {
 212     if (sCommand.isEmpty())
 213         throw css::lang::IllegalArgumentException(
 214                 OUString("Empty command strings are not allowed here."),
 215                 static_cast< ::cppu::OWeakObject* >(this),
 216                 0);
 217
 218     SolarMutexGuard g;
 219     AcceleratorCache& rCache = impl_getCFG(true); // sal_True => force getting of a writeable cache!
 220     if (!rCache.hasCommand(sCommand))
 221         throw css::container::NoSuchElementException(
 222                 OUString("Command does not exists inside this container."),
 223                 static_cast< ::cppu::OWeakObject* >(this));
 224     rCache.removeCommand(sCommand);
 225 }
 226
 227 void SAL_CALL XMLBasedAcceleratorConfiguration::reload()
 228     throw(css::uno::Exception       ,
 229         css::uno::RuntimeException, std::exception)
 230 {
 231     css::uno::Reference< css::io::XStream > xStream;
 232     css::uno::Reference< css::io::XStream > xStreamNoLang;
 233     {
 234         SolarMutexGuard g;
 235         xStream = m_aPresetHandler.openTarget(TARGET_CURRENT,
 236                 css::embed::ElementModes::READ);
 237         try
 238         {
 239             xStreamNoLang = m_aPresetHandler.openPreset(PRESET_DEFAULT);
 240         }
 241         catch(const css::io::IOException&) {} // does not have to exist
 242     }
 243
 244     css::uno::Reference< css::io::XInputStream > xIn;
 245     if (xStream.is())
 246         xIn = xStream->getInputStream();
 247     if (!xIn.is())
 248         throw css::io::IOException(
 249         OUString("Could not open accelerator configuration for reading."),
 250         static_cast< ::cppu::OWeakObject* >(this));
 251
 252     // impl_ts_load() does not clear the cache
 253     {
 254         SolarMutexGuard g;
 255         m_aReadCache = AcceleratorCache();
 256     }
 257
 258     impl_ts_load(xIn);
 259
 260     // Load also the general language independent default accelerators
 261     // (ignoring the already defined accelerators)
 262     if (xStreamNoLang.is())
 263     {
 264         xIn = xStreamNoLang->getInputStream();
 265         if (xIn.is())
 266             impl_ts_load(xIn);
 267     }
 268 }
 269
 270 void SAL_CALL XMLBasedAcceleratorConfiguration::store()
 271     throw(css::uno::Exception       ,
 272         css::uno::RuntimeException, std::exception)
 273 {
 274     css::uno::Reference< css::io::XStream > xStream;
 275     {
 276         SolarMutexGuard g;
 277         xStream = m_aPresetHandler.openTarget(TARGET_CURRENT,
 278                css::embed::ElementModes::READWRITE); // open or create!
 279     }
 280
 281     css::uno::Reference< css::io::XOutputStream > xOut;
 282     if (xStream.is())
 283         xOut = xStream->getOutputStream();
 284
 285     if (!xOut.is())
 286         throw css::io::IOException(
 287         OUString("Could not open accelerator configuration for saving."),
 288         static_cast< ::cppu::OWeakObject* >(this));
 289
 290     impl_ts_save(xOut);
 291
 292     xOut.clear();
 293     xStream.clear();
 294
 295     m_aPresetHandler.commitUserChanges();
 296 }
 297
 298 void SAL_CALL XMLBasedAcceleratorConfiguration::storeToStorage(const css::uno::Reference< css::embed::XStorage >& xStorage)
 299     throw(css::uno::Exception       ,
 300           css::uno::RuntimeException, std::exception)
 301 {
 302     css::uno::Reference< css::io::XStream > xStream = StorageHolder::openSubStreamWithFallback(
 303                                                             xStorage,
 304                                                             TARGET_CURRENT,
 305                                                             css::embed::ElementModes::READWRITE,
 306                                                             false); // False => no fallback from read/write to readonly!
 307     css::uno::Reference< css::io::XOutputStream > xOut;
 308     if (xStream.is())
 309         xOut = xStream->getOutputStream();
 310
 311     if (!xOut.is())
 312         throw css::io::IOException(
 313                 OUString("Could not open accelerator configuration for saving."),
 314                 static_cast< ::cppu::OWeakObject* >(this));
 315
 316     impl_ts_save(xOut);
 317
 318     // TODO inform listener about success, so it can flush the root and sub storage of this stream!
 319 }
 320
 321 sal_Bool SAL_CALL XMLBasedAcceleratorConfiguration::isModified()
 322     throw(css::uno::RuntimeException, std::exception)
 323 {
 324     SolarMutexGuard g;
 325     return (m_pWriteCache != nullptr);
 326 }
 327
 328 sal_Bool SAL_CALL XMLBasedAcceleratorConfiguration::isReadOnly()
 329     throw(css::uno::RuntimeException, std::exception)
 330 {
 331     css::uno::Reference< css::io::XStream > xStream;
 332     {
 333         SolarMutexGuard g;
 334         xStream = m_aPresetHandler.openTarget(TARGET_CURRENT,
 335                 css::embed::ElementModes::READWRITE); // open or create!
 336     }
 337
 338     css::uno::Reference< css::io::XOutputStream > xOut;
 339     if (xStream.is())
 340         xOut = xStream->getOutputStream();
 341     return !(xOut.is());
 342 }
 343
 344 void SAL_CALL XMLBasedAcceleratorConfiguration::setStorage(const css::uno::Reference< css::embed::XStorage >& /*xStorage*/)
 345     throw(css::uno::RuntimeException, std::exception)
 346 {
 347     SAL_INFO("fwk", "XMLBasedAcceleratorConfiguration::setStorage(): implement this HACK .-)");
 348 }
 349
 350 sal_Bool SAL_CALL XMLBasedAcceleratorConfiguration::hasStorage()
 351     throw(css::uno::RuntimeException, std::exception)
 352 {
 353     SAL_INFO("fwk", "XMLBasedAcceleratorConfiguration::hasStorage(): implement this HACK .-)");
 354     return false;
 355 }
 356
 357 void SAL_CALL XMLBasedAcceleratorConfiguration::addConfigurationListener(const css::uno::Reference< css::ui::XUIConfigurationListener >& /*xListener*/)
 358     throw(css::uno::RuntimeException, std::exception)
 359 {
 360     SAL_INFO("fwk", "XMLBasedAcceleratorConfiguration::addConfigurationListener(): implement me");
 361 }
 362
 363 void SAL_CALL XMLBasedAcceleratorConfiguration::removeConfigurationListener(const css::uno::Reference< css::ui::XUIConfigurationListener >& /*xListener*/)
 364     throw(css::uno::RuntimeException, std::exception)
 365 {
 366     SAL_INFO("fwk", "XMLBasedAcceleratorConfiguration::removeConfigurationListener(): implement me");
 367 }
 368
 369 void SAL_CALL XMLBasedAcceleratorConfiguration::reset()
 370 throw(css::uno::RuntimeException, std::exception)
 371 {
 372     {
 373         SolarMutexGuard g;
 374         m_aPresetHandler.copyPresetToTarget(PRESET_DEFAULT, TARGET_CURRENT);
 375     }
 376
 377     reload();
 378 }
 379
 380 void SAL_CALL XMLBasedAcceleratorConfiguration::addResetListener(const css::uno::Reference< css::form::XResetListener >& /*xListener*/)
 381     throw(css::uno::RuntimeException, std::exception)
 382 {
 383     SAL_INFO("fwk", "XMLBasedAcceleratorConfiguration::addResetListener(): implement me");
 384 }
 385
 386 void SAL_CALL XMLBasedAcceleratorConfiguration::removeResetListener(const css::uno::Reference< css::form::XResetListener >& /*xListener*/)
 387     throw(css::uno::RuntimeException, std::exception)
 388 {
 389     SAL_INFO("fwk", "XMLBasedAcceleratorConfiguration::removeResetListener(): implement me");
 390 }
 391
 392 // IStorageListener
 393 void XMLBasedAcceleratorConfiguration::changesOccurred()
 394 {
 395     reload();
 396 }
 397
 398 void XMLBasedAcceleratorConfiguration::impl_ts_load(const css::uno::Reference< css::io::XInputStream >& xStream)
 399 {
 400     css::uno::Reference< css::uno::XComponentContext > xContext;
 401     {
 402         SolarMutexGuard g;
 403         xContext = m_xContext;
 404         if (m_pWriteCache)
 405         {
 406             // be aware of reentrance problems - use temp variable for calling delete ... :-)
 407             AcceleratorCache* pTemp = m_pWriteCache;
 408             m_pWriteCache = nullptr;
 409             delete pTemp;
 410         }
 411     }
 412
 413     css::uno::Reference< css::io::XSeekable > xSeek(xStream, css::uno::UNO_QUERY);
 414     if (xSeek.is())
 415         xSeek->seek(0);
 416
 417     SolarMutexGuard g;
 418
 419     // create the parser queue
 420     // Note: Use special filter object between parser and reader
 421     // to get filtered xml with right namespaces ...
 422     // Use further a temp cache for reading!
 423     AcceleratorConfigurationReader*                        pReader = new AcceleratorConfigurationReader(m_aReadCache);
 424     css::uno::Reference< css::xml::sax::XDocumentHandler > xReader (static_cast< ::cppu::OWeakObject* >(pReader), css::uno::UNO_QUERY_THROW);
 425     SaxNamespaceFilter*                                    pFilter = new SaxNamespaceFilter(xReader);
 426     css::uno::Reference< css::xml::sax::XDocumentHandler > xFilter (static_cast< ::cppu::OWeakObject* >(pFilter), css::uno::UNO_QUERY_THROW);
 427
 428     // connect parser, filter and stream
 429     css::uno::Reference< css::xml::sax::XParser > xParser = css::xml::sax::Parser::create(xContext);
 430     xParser->setDocumentHandler(xFilter);
 431
 432     css::xml::sax::InputSource aSource;
 433     aSource.aInputStream = xStream;
 434
 435     // TODO think about error handling
 436     xParser->parseStream(aSource);
 437 }
 438
 439 void XMLBasedAcceleratorConfiguration::impl_ts_save(const css::uno::Reference< css::io::XOutputStream >& xStream)
 440 {
 441     bool bChanged;
 442     AcceleratorCache aCache;
 443     css::uno::Reference< css::uno::XComponentContext > xContext;
 444     {
 445         SolarMutexGuard g;
 446         bChanged = (m_pWriteCache != nullptr);
 447         if (bChanged)
 448             aCache.takeOver(*m_pWriteCache);
 449         else
 450             aCache.takeOver(m_aReadCache);
 451         xContext = m_xContext;
 452     }
 453
 454     css::uno::Reference< css::io::XTruncate > xClearable(xStream, css::uno::UNO_QUERY_THROW);
 455     xClearable->truncate();
 456
 457     // TODO can be removed if seek(0) is done by truncate() automatically!
 458     css::uno::Reference< css::io::XSeekable > xSeek(xStream, css::uno::UNO_QUERY);
 459     if (xSeek.is())
 460         xSeek->seek(0);
 461
 462     // combine writer/cache/stream etcpp.
 463     css::uno::Reference< css::xml::sax::XWriter > xWriter = css::xml::sax::Writer::create(xContext);
 464     xWriter->setOutputStream(xStream);
 465
 466     // write into the stream
 467     css::uno::Reference< css::xml::sax::XDocumentHandler > xHandler(xWriter, css::uno::UNO_QUERY_THROW);
 468     AcceleratorConfigurationWriter aWriter(aCache, xHandler);
 469     aWriter.flush();
 470
 471     SolarMutexGuard g;
 472     // take over all changes into the readonly cache ...
 473     // and forget the copy-on-write copied cache
 474     if (bChanged)
 475     {
 476         m_aReadCache.takeOver(*m_pWriteCache);
 477         // live with reentrance .-)
 478         AcceleratorCache* pTemp = m_pWriteCache;
 479         m_pWriteCache = nullptr;
 480         delete pTemp;
 481     }
 482 }
 483
 484 AcceleratorCache& XMLBasedAcceleratorConfiguration::impl_getCFG(bool bWriteAccessRequested)
 485 {
 486     SolarMutexGuard g;
 487
 488     //create copy of our readonly-cache, if write access is forced ... but
 489     //not still possible!
 490     if (
 491         (bWriteAccessRequested) &&
 492         (!m_pWriteCache       )
 493        )
 494     {
 495         m_pWriteCache = new AcceleratorCache(m_aReadCache);
 496     }
 497
 498     // in case, we have a writeable cache, we use it for reading too!
 499     // Otherwise the API user can't find its own changes ...
 500     if (m_pWriteCache)
 501         return *m_pWriteCache;
 502     else
 503         return m_aReadCache;
 504 }
 505
 506 OUString XMLBasedAcceleratorConfiguration::impl_ts_getLocale() const
 507 {
 508     OUString sISOLocale = officecfg::Setup::L10N::ooLocale::get();
 509
 510     if (sISOLocale.isEmpty())
 511         return OUString("en-US");
 512     return sISOLocale;
 513 }
 514
 515 /*******************************************************************************
 516 *
 517 * XCU based accelerator configuration
 518 *
 519 *******************************************************************************/
 520
 521 XCUBasedAcceleratorConfiguration::XCUBasedAcceleratorConfiguration(const css::uno::Reference< css::uno::XComponentContext >& xContext)
 522                                 : m_xContext      (xContext                     )
 523                                 , m_pPrimaryWriteCache(nullptr                        )
 524                                 , m_pSecondaryWriteCache(nullptr                      )
 525 {
 526     const OUString CFG_ENTRY_ACCELERATORS("org.openoffice.Office.Accelerators");
 527     m_xCfg.set(
 528              ::comphelper::ConfigurationHelper::openConfig( m_xContext, CFG_ENTRY_ACCELERATORS, ::comphelper::EConfigurationModes::AllLocales ),
 529              css::uno::UNO_QUERY );
 530 }
 531
 532 XCUBasedAcceleratorConfiguration::~XCUBasedAcceleratorConfiguration()
 533 {
 534 }
 535
 536 css::uno::Sequence< css::awt::KeyEvent > SAL_CALL XCUBasedAcceleratorConfiguration::getAllKeyEvents()
 537     throw(css::uno::RuntimeException, std::exception)
 538 {
 539     SolarMutexGuard g;
 540
 541     AcceleratorCache::TKeyList lKeys  = impl_getCFG(true).getAllKeys(); //get keys from PrimaryKeys set
 542
 543     AcceleratorCache::TKeyList lSecondaryKeys = impl_getCFG(false).getAllKeys(); //get keys from SecondaryKeys set
 544     lKeys.reserve(lKeys.size()+lSecondaryKeys.size());
 545     AcceleratorCache::TKeyList::const_iterator pIt;
 546     AcceleratorCache::TKeyList::const_iterator pEnd = lSecondaryKeys.end();
 547     for ( pIt  = lSecondaryKeys.begin(); pIt != pEnd; ++pIt )
 548         lKeys.push_back(*pIt);
 549
 550     return comphelper::containerToSequence(lKeys);
 551 }
 552
 553 OUString SAL_CALL XCUBasedAcceleratorConfiguration::getCommandByKeyEvent(const css::awt::KeyEvent& aKeyEvent)
 554     throw(css::container::NoSuchElementException,
 555           css::uno::RuntimeException, std::exception            )
 556 {
 557     SolarMutexGuard g;
 558
 559     AcceleratorCache& rPrimaryCache   = impl_getCFG(true );
 560     AcceleratorCache& rSecondaryCache = impl_getCFG(false);
 561
 562     if (!rPrimaryCache.hasKey(aKeyEvent) && !rSecondaryCache.hasKey(aKeyEvent))
 563         throw css::container::NoSuchElementException(
 564         OUString(),
 565         static_cast< ::cppu::OWeakObject* >(this));
 566
 567     if (rPrimaryCache.hasKey(aKeyEvent))
 568         return rPrimaryCache.getCommandByKey(aKeyEvent);
 569     else
 570         return rSecondaryCache.getCommandByKey(aKeyEvent);
 571 }
 572
 573 void SAL_CALL XCUBasedAcceleratorConfiguration::setKeyEvent(const css::awt::KeyEvent& aKeyEvent,
 574                                                     const OUString&    sCommand )
 575                                                     throw (css::lang::IllegalArgumentException,
 576                                                            css::container::NoSuchElementException,
 577                                                            css::uno::RuntimeException, std::exception)
 578 {
 579     SAL_INFO( "fwk.accelerators", "XCUBasedAcceleratorConfiguration::setKeyEvent" );
 580
 581     if (
 582         (aKeyEvent.KeyCode   == 0) &&
 583         (aKeyEvent.KeyChar   == 0) &&
 584         (aKeyEvent.KeyFunc   == 0) &&
 585         (aKeyEvent.Modifiers == 0)
 586         )
 587         throw css::lang::IllegalArgumentException(
 588                 OUString("Such key event seems not to be supported by any operating system."),
 589                 static_cast< ::cppu::OWeakObject* >(this),
 590                 0);
 591
 592     if (sCommand.isEmpty())
 593                 throw css::lang::IllegalArgumentException(
 594                 OUString("Empty command strings are not allowed here."),
 595                 static_cast< ::cppu::OWeakObject* >(this),
 596                 1);
 597
 598     SolarMutexGuard g;
 599
 600     AcceleratorCache& rPrimaryCache   = impl_getCFG(true, true ); // sal_True => force getting of a writeable cache!
 601     AcceleratorCache& rSecondaryCache = impl_getCFG(false, true); // sal_True => force getting of a writeable cache!
 602
 603     if ( rPrimaryCache.hasKey(aKeyEvent) )
 604     {
 605         OUString sOriginalCommand = rPrimaryCache.getCommandByKey(aKeyEvent);
 606         if ( sCommand != sOriginalCommand )
 607         {
 608             if (rSecondaryCache.hasCommand(sOriginalCommand))
 609             {
 610                 AcceleratorCache::TKeyList lSecondaryKeys = rSecondaryCache.getKeysByCommand(sOriginalCommand);
 611                 rSecondaryCache.removeKey(lSecondaryKeys[0]);
 612                 rPrimaryCache.setKeyCommandPair(lSecondaryKeys[0], sOriginalCommand);
 613             }
 614
 615             if (rPrimaryCache.hasCommand(sCommand))
 616             {
 617                 AcceleratorCache::TKeyList lPrimaryKeys = rPrimaryCache.getKeysByCommand(sCommand);
 618                 rPrimaryCache.removeKey(lPrimaryKeys[0]);
 619                 rSecondaryCache.setKeyCommandPair(lPrimaryKeys[0], sCommand);
 620             }
 621
 622             rPrimaryCache.setKeyCommandPair(aKeyEvent, sCommand);
 623         }
 624     }
 625
 626     else if ( rSecondaryCache.hasKey(aKeyEvent) )
 627     {
 628         OUString sOriginalCommand = rSecondaryCache.getCommandByKey(aKeyEvent);
 629         if (sCommand != sOriginalCommand)
 630         {
 631             if (rPrimaryCache.hasCommand(sCommand))
 632             {
 633                 AcceleratorCache::TKeyList lPrimaryKeys = rPrimaryCache.getKeysByCommand(sCommand);
 634                 rPrimaryCache.removeKey(lPrimaryKeys[0]);
 635                 rSecondaryCache.setKeyCommandPair(lPrimaryKeys[0], sCommand);
 636             }
 637
 638             rSecondaryCache.removeKey(aKeyEvent);
 639             rPrimaryCache.setKeyCommandPair(aKeyEvent, sCommand);
 640         }
 641     }
 642
 643     else
 644     {
 645         if (rPrimaryCache.hasCommand(sCommand))
 646         {
 647             AcceleratorCache::TKeyList lPrimaryKeys = rPrimaryCache.getKeysByCommand(sCommand);
 648             rPrimaryCache.removeKey(lPrimaryKeys[0]);
 649             rSecondaryCache.setKeyCommandPair(lPrimaryKeys[0], sCommand);
 650         }
 651
 652         rPrimaryCache.setKeyCommandPair(aKeyEvent, sCommand);
 653     }
 654 }
 655
 656 void SAL_CALL XCUBasedAcceleratorConfiguration::removeKeyEvent(const css::awt::KeyEvent& aKeyEvent)
 657     throw(css::container::NoSuchElementException,
 658           css::uno::RuntimeException, std::exception            )
 659 {
 660     SolarMutexGuard g;
 661
 662     AcceleratorCache& rPrimaryCache   = impl_getCFG(true, true );
 663     AcceleratorCache& rSecondaryCache = impl_getCFG(false, true);
 664
 665     if (!rPrimaryCache.hasKey(aKeyEvent) && !rSecondaryCache.hasKey(aKeyEvent))
 666         throw css::container::NoSuchElementException(
 667         OUString(),
 668         static_cast< ::cppu::OWeakObject* >(this));
 669
 670     if (rPrimaryCache.hasKey(aKeyEvent))
 671     {
 672         OUString sDelCommand = rPrimaryCache.getCommandByKey(aKeyEvent);
 673         if (!sDelCommand.isEmpty())
 674         {
 675             OUString sOriginalCommand = rPrimaryCache.getCommandByKey(aKeyEvent);
 676             if (rSecondaryCache.hasCommand(sOriginalCommand))
 677             {
 678                 AcceleratorCache::TKeyList lSecondaryKeys = rSecondaryCache.getKeysByCommand(sOriginalCommand);
 679                 rSecondaryCache.removeKey(lSecondaryKeys[0]);
 680                 rPrimaryCache.setKeyCommandPair(lSecondaryKeys[0], sOriginalCommand);
 681             }
 682
 683             rPrimaryCache.removeKey(aKeyEvent);
 684         }
 685
 686     }
 687     else
 688     {
 689         OUString sDelCommand = rSecondaryCache.getCommandByKey(aKeyEvent);
 690         if (!sDelCommand.isEmpty())
 691             rSecondaryCache.removeKey(aKeyEvent);
 692     }
 693 }
 694
 695 css::uno::Sequence< css::awt::KeyEvent > SAL_CALL XCUBasedAcceleratorConfiguration::getKeyEventsByCommand(const OUString& sCommand)
 696     throw(css::lang::IllegalArgumentException   ,
 697         css::container::NoSuchElementException,
 698         css::uno::RuntimeException, std::exception            )
 699 {
 700     if (sCommand.isEmpty())
 701         throw css::lang::IllegalArgumentException(
 702                 OUString("Empty command strings are not allowed here."),
 703                 static_cast< ::cppu::OWeakObject* >(this),
 704                 1);
 705
 706     SolarMutexGuard g;
 707
 708     AcceleratorCache& rPrimaryCache   = impl_getCFG(true );
 709     AcceleratorCache& rSecondaryCache = impl_getCFG(false);
 710
 711     if (!rPrimaryCache.hasCommand(sCommand) && !rSecondaryCache.hasCommand(sCommand))
 712         throw css::container::NoSuchElementException(
 713                 OUString(),
 714                 static_cast< ::cppu::OWeakObject* >(this));
 715
 716     AcceleratorCache::TKeyList lKeys  = rPrimaryCache.getKeysByCommand(sCommand);
 717
 718     AcceleratorCache::TKeyList lSecondaryKeys = rSecondaryCache.getKeysByCommand(sCommand);
 719     AcceleratorCache::TKeyList::const_iterator pIt;
 720     for (pIt = lSecondaryKeys.begin(); pIt != lSecondaryKeys.end(); ++pIt)
 721         lKeys.push_back(*pIt);
 722
 723     return comphelper::containerToSequence(lKeys);
 724 }
 725
 726 AcceleratorCache::TKeyList::const_iterator lcl_getPreferredKey(const AcceleratorCache::TKeyList& lKeys)
 727 {
 728     AcceleratorCache::TKeyList::const_iterator pIt;
 729     for (  pIt  = lKeys.begin ();
 730            pIt != lKeys.end   ();
 731          ++pIt                  )
 732     {
 733         const css::awt::KeyEvent& rAWTKey = *pIt;
 734         const vcl::KeyCode        aVCLKey = ::svt::AcceleratorExecute::st_AWTKey2VCLKey(rAWTKey);
 735         const OUString            sName   = aVCLKey.GetName();
 736
 737         if (!sName.isEmpty())
 738             return pIt;
 739     }
 740
 741     return lKeys.end();
 742 }
 743
 744 css::uno::Sequence< css::uno::Any > SAL_CALL XCUBasedAcceleratorConfiguration::getPreferredKeyEventsForCommandList(const css::uno::Sequence< OUString >& lCommandList)
 745     throw(css::lang::IllegalArgumentException, css::container::NoSuchElementException,
 746           css::uno::RuntimeException, std::exception)
 747 {
 748     SolarMutexGuard g;
 749
 750     sal_Int32                           i              = 0;
 751     sal_Int32                           c              = lCommandList.getLength();
 752     css::uno::Sequence< css::uno::Any > lPreferredOnes (c); // don't pack list!
 753     AcceleratorCache&                   rCache         = impl_getCFG(true);
 754
 755     for (i=0; i<c; ++i)
 756     {
 757         const OUString& rCommand = lCommandList[i];
 758         if (rCommand.isEmpty())
 759             throw css::lang::IllegalArgumentException(
 760                     OUString("Empty command strings are not allowed here."),
 761                     static_cast< ::cppu::OWeakObject* >(this),
 762                     (sal_Int16)i);
 763
 764         if (!rCache.hasCommand(rCommand))
 765             continue;
 766
 767         AcceleratorCache::TKeyList lKeys = rCache.getKeysByCommand(rCommand);
 768         if ( lKeys.empty() )
 769             continue;
 770
 771         AcceleratorCache::TKeyList::const_iterator pPreferredKey = lcl_getPreferredKey(lKeys);
 772         if (pPreferredKey != lKeys.end ())
 773         {
 774             css::uno::Any& rAny = lPreferredOnes[i];
 775             rAny <<= *(pPreferredKey);
 776         }
 777     }
 778
 779     return lPreferredOnes;
 780 }
 781
 782 void SAL_CALL XCUBasedAcceleratorConfiguration::removeCommandFromAllKeyEvents(const OUString& sCommand)
 783     throw(css::lang::IllegalArgumentException   ,
 784         css::container::NoSuchElementException,
 785         css::uno::RuntimeException, std::exception            )
 786 {
 787     if (sCommand.isEmpty())
 788         throw css::lang::IllegalArgumentException(
 789                 OUString("Empty command strings are not allowed here."),
 790                 static_cast< ::cppu::OWeakObject* >(this),
 791                 0);
 792
 793     SolarMutexGuard g;
 794
 795     AcceleratorCache& rPrimaryCache   = impl_getCFG(true, true );
 796     AcceleratorCache& rSecondaryCache = impl_getCFG(false, true);
 797
 798     if (!rPrimaryCache.hasCommand(sCommand) && !rSecondaryCache.hasCommand(sCommand))
 799         throw css::container::NoSuchElementException(
 800                 OUString("Command does not exists inside this container."),
 801                 static_cast< ::cppu::OWeakObject* >(this));
 802
 803     if (rPrimaryCache.hasCommand(sCommand))
 804         rPrimaryCache.removeCommand(sCommand);
 805     if (rSecondaryCache.hasCommand(sCommand))
 806         rSecondaryCache.removeCommand(sCommand);
 807 }
 808
 809 void SAL_CALL XCUBasedAcceleratorConfiguration::reload()
 810     throw(css::uno::Exception       ,
 811         css::uno::RuntimeException, std::exception)
 812 {
 813     SAL_INFO( "fwk.accelerators", "XCUBasedAcceleratorConfiguration::reload()" );
 814
 815     SolarMutexGuard g;
 816
 817     bool bPreferred;
 818     css::uno::Reference< css::container::XNameAccess > xAccess;
 819
 820     bPreferred = true;
 821     m_aPrimaryReadCache = AcceleratorCache();
 822     if (m_pPrimaryWriteCache)
 823     {
 824         // be aware of reentrance problems - use temp variable for calling delete ... :-)
 825         AcceleratorCache* pTemp = m_pPrimaryWriteCache;
 826         m_pPrimaryWriteCache = nullptr;
 827         delete pTemp;
 828     }
 829     m_xCfg->getByName(CFG_ENTRY_PRIMARY) >>= xAccess;
 830     impl_ts_load(bPreferred, xAccess); // load the preferred keys
 831
 832     bPreferred = false;
 833     m_aSecondaryReadCache = AcceleratorCache();
 834     if (m_pSecondaryWriteCache)
 835     {
 836         // be aware of reentrance problems - use temp variable for calling delete ... :-)
 837         AcceleratorCache* pTemp = m_pSecondaryWriteCache;
 838         m_pSecondaryWriteCache = nullptr;
 839         delete pTemp;
 840     }
 841     m_xCfg->getByName(CFG_ENTRY_SECONDARY) >>= xAccess;
 842     impl_ts_load(bPreferred, xAccess); // load the secondary keys
 843 }
 844
 845 void SAL_CALL XCUBasedAcceleratorConfiguration::store()
 846     throw(css::uno::Exception       ,
 847           css::uno::RuntimeException, std::exception)
 848 {
 849     SAL_INFO( "fwk.accelerators", "XCUBasedAcceleratorConfiguration::store()" );
 850
 851     SolarMutexGuard g;
 852
 853     bool bPreferred;
 854     css::uno::Reference< css::container::XNameAccess > xAccess;
 855
 856     bPreferred = true;
 857     // on-demand creation of the primary write cache
 858     impl_getCFG(bPreferred, true);
 859     m_xCfg->getByName(CFG_ENTRY_PRIMARY) >>= xAccess;
 860     impl_ts_save(bPreferred, xAccess);
 861
 862     bPreferred = false;
 863     // on-demand creation of the secondary write cache
 864     impl_getCFG(bPreferred, true);
 865     m_xCfg->getByName(CFG_ENTRY_SECONDARY) >>= xAccess;
 866     impl_ts_save(bPreferred, xAccess);
 867 }
 868
 869 void SAL_CALL XCUBasedAcceleratorConfiguration::storeToStorage(const css::uno::Reference< css::embed::XStorage >& xStorage)
 870     throw(css::uno::Exception       ,
 871       css::uno::RuntimeException, std::exception)
 872 {
 873     // use m_aCache + old AcceleratorXMLWriter to store data directly on storage given as parameter ...
 874     if (!xStorage.is())
 875         return;
 876
 877     long nOpenModes = css::embed::ElementModes::READWRITE;
 878     css::uno::Reference< css::embed::XStorage > xAcceleratorTypeStorage = xStorage->openStorageElement("accelerator", nOpenModes);
 879     if (!xAcceleratorTypeStorage.is())
 880         return;
 881
 882     css::uno::Reference< css::io::XStream > xStream = xAcceleratorTypeStorage->openStreamElement("current", nOpenModes);
 883     css::uno::Reference< css::io::XOutputStream > xOut;
 884     if (xStream.is())
 885         xOut = xStream->getOutputStream();
 886     if (!xOut.is())
 887         throw css::io::IOException(
 888         OUString("Could not open accelerator configuration for saving."),
 889         static_cast< ::cppu::OWeakObject* >(this));
 890
 891     // the original m_aCache has been split into primary cache and secondary cache...
 892     // we should merge them before storing to storage
 893     AcceleratorCache aCache;
 894     {
 895         SolarMutexGuard g;
 896
 897         if (m_pPrimaryWriteCache != nullptr)
 898             aCache.takeOver(*m_pPrimaryWriteCache);
 899         else
 900             aCache.takeOver(m_aPrimaryReadCache);
 901
 902         AcceleratorCache::TKeyList lKeys;
 903         AcceleratorCache::TKeyList::const_iterator pIt;
 904         if (m_pSecondaryWriteCache!=nullptr)
 905         {
 906             lKeys = m_pSecondaryWriteCache->getAllKeys();
 907             for ( pIt=lKeys.begin(); pIt!=lKeys.end(); ++pIt )
 908                 aCache.setKeyCommandPair(*pIt, m_pSecondaryWriteCache->getCommandByKey(*pIt));
 909         }
 910         else
 911         {
 912             lKeys = m_aSecondaryReadCache.getAllKeys();
 913             for ( pIt=lKeys.begin(); pIt!=lKeys.end(); ++pIt )
 914                 aCache.setKeyCommandPair(*pIt, m_aSecondaryReadCache.getCommandByKey(*pIt));
 915         }
 916     }
 917
 918     css::uno::Reference< css::io::XTruncate > xClearable(xOut, css::uno::UNO_QUERY_THROW);
 919     xClearable->truncate();
 920     css::uno::Reference< css::io::XSeekable > xSeek(xOut, css::uno::UNO_QUERY);
 921     if (xSeek.is())
 922         xSeek->seek(0);
 923
 924     css::uno::Reference< css::xml::sax::XWriter > xWriter = css::xml::sax::Writer::create(m_xContext);
 925     xWriter->setOutputStream(xOut);
 926
 927     // write into the stream
 928     css::uno::Reference< css::xml::sax::XDocumentHandler > xHandler(xWriter, css::uno::UNO_QUERY_THROW);
 929     AcceleratorConfigurationWriter aWriter(aCache, xHandler);
 930     aWriter.flush();
 931 }
 932
 933 sal_Bool SAL_CALL XCUBasedAcceleratorConfiguration::isModified()
 934     throw(css::uno::RuntimeException, std::exception)
 935 {
 936     return false;
 937 }
 938
 939 sal_Bool SAL_CALL XCUBasedAcceleratorConfiguration::isReadOnly()
 940     throw(css::uno::RuntimeException, std::exception)
 941 {
 942     return false;
 943 }
 944
 945 void SAL_CALL XCUBasedAcceleratorConfiguration::setStorage(const css::uno::Reference< css::embed::XStorage >& /*xStorage*/)
 946     throw(css::uno::RuntimeException, std::exception)
 947 {
 948     SAL_INFO("fwk", "XCUBasedAcceleratorConfiguration::setStorage(): implement this HACK .-)");
 949 }
 950
 951 sal_Bool SAL_CALL XCUBasedAcceleratorConfiguration::hasStorage()
 952     throw(css::uno::RuntimeException, std::exception)
 953 {
 954     SAL_INFO("fwk", "XCUBasedAcceleratorConfiguration::hasStorage(): implement this HACK .-)");
 955         return false;
 956 }
 957
 958 void SAL_CALL XCUBasedAcceleratorConfiguration::addConfigurationListener(const css::uno::Reference< css::ui::XUIConfigurationListener >& /*xListener*/)
 959     throw(css::uno::RuntimeException, std::exception)
 960 {
 961     SAL_INFO("fwk", "XCUBasedAcceleratorConfiguration::addConfigurationListener(): implement me");
 962 }
 963
 964 void SAL_CALL XCUBasedAcceleratorConfiguration::removeConfigurationListener(const css::uno::Reference< css::ui::XUIConfigurationListener >& /*xListener*/)
 965     throw(css::uno::RuntimeException, std::exception)
 966 {
 967     SAL_INFO("fwk", "XCUBasedAcceleratorConfiguration::removeConfigurationListener(): implement me");
 968 }
 969
 970 void SAL_CALL XCUBasedAcceleratorConfiguration::reset()
 971     throw(css::uno::RuntimeException, std::exception)
 972 {
 973     css::uno::Reference< css::container::XNamed > xNamed(m_xCfg, css::uno::UNO_QUERY);
 974     OUString sConfig = xNamed->getName();
 975     if ( sConfig == "Global" )
 976     {
 977         m_xCfg.set(
 978             ::comphelper::ConfigurationHelper::openConfig( m_xContext, CFG_ENTRY_GLOBAL, ::comphelper::EConfigurationModes::AllLocales ),
 979             css::uno::UNO_QUERY );
 980         XCUBasedAcceleratorConfiguration::reload();
 981     }
 982     else if ( sConfig == "Modules" )
 983     {
 984         m_xCfg.set(
 985             ::comphelper::ConfigurationHelper::openConfig( m_xContext, CFG_ENTRY_MODULES, ::comphelper::EConfigurationModes::AllLocales ),
 986             css::uno::UNO_QUERY );
 987         XCUBasedAcceleratorConfiguration::reload();
 988     }
 989 }
 990
 991 void SAL_CALL XCUBasedAcceleratorConfiguration::addResetListener(const css::uno::Reference< css::form::XResetListener >& /*xListener*/)
 992     throw(css::uno::RuntimeException, std::exception)
 993 {
 994     SAL_INFO("fwk", "XCUBasedAcceleratorConfiguration::addResetListener(): implement me");
 995 }
 996
 997 void SAL_CALL XCUBasedAcceleratorConfiguration::removeResetListener(const css::uno::Reference< css::form::XResetListener >& /*xListener*/)
 998     throw(css::uno::RuntimeException, std::exception)
 999 {
1000     SAL_INFO("fwk", "XCUBasedAcceleratorConfiguration::removeResetListener(): implement me");
1001 }
1002
1003 void SAL_CALL XCUBasedAcceleratorConfiguration::changesOccurred(const css::util::ChangesEvent& aEvent)
1004     throw(css::uno::RuntimeException, std::exception)
1005 {
1006     SAL_INFO( "fwk.accelerators", "XCUBasedAcceleratorConfiguration::changesOccurred()" );
1007
1008     css::uno::Reference< css::container::XHierarchicalNameAccess > xHAccess;
1009     aEvent.Base >>= xHAccess;
1010     if (! xHAccess.is ())
1011         return;
1012
1013     css::util::ChangesEvent aReceivedEvents( aEvent );
1014     const sal_Int32 c = aReceivedEvents.Changes.getLength();
1015           sal_Int32 i = 0;
1016     for (i=0; i<c; ++i)
1017     {
1018         const css::util::ElementChange& aChange  =   aReceivedEvents.Changes[i];
1019
1020         // Only path of form "PrimaryKeys/Modules/Module['<module_name>']/Key['<command_url>']/Command[<locale>]" will
1021         // be interesting for use. Sometimes short path values are given also by the broadcaster ... but they must be ignored :-)
1022         // So we try to split the path into 3 parts (module isn't important here, because we already know it ... because
1023         // these instance is bound to a specific module configuration ... or it''s the global configuration where no module is given at all.
1024
1025         OUString sOrgPath;
1026         OUString sPath;
1027         OUString sKey;
1028
1029         aChange.Accessor >>= sOrgPath;
1030         sPath              = sOrgPath;
1031         OUString sPrimarySecondary = ::utl::extractFirstFromConfigurationPath(sPath, &sPath);
1032         OUString sGlobalModules = ::utl::extractFirstFromConfigurationPath(sPath, &sPath);
1033
1034         if ( sGlobalModules == CFG_ENTRY_GLOBAL )
1035         {
1036             OUString sModule;
1037             sKey = ::utl::extractFirstFromConfigurationPath(sPath, &sPath);
1038             if ( !sKey.isEmpty() && !sPath.isEmpty() )
1039                 reloadChanged(sPrimarySecondary, sGlobalModules, sModule, sKey);
1040         }
1041         else if ( sGlobalModules == CFG_ENTRY_MODULES )
1042         {
1043             OUString sModule = ::utl::extractFirstFromConfigurationPath(sPath, &sPath);
1044             sKey = ::utl::extractFirstFromConfigurationPath(sPath, &sPath);
1045
1046             if ( !sKey.isEmpty() && !sPath.isEmpty() )
1047             {
1048                 reloadChanged(sPrimarySecondary, sGlobalModules, sModule, sKey);
1049             }
1050         }
1051     }
1052 }
1053
1054 void SAL_CALL XCUBasedAcceleratorConfiguration::disposing(const css::lang::EventObject& /*aSource*/)
1055     throw(css::uno::RuntimeException, std::exception)
1056 {
1057 }
1058
1059 void SAL_CALL XCUBasedAcceleratorConfiguration::dispose()
1060     throw(css::uno::RuntimeException, std::exception)
1061 {
1062     // nop
1063 }
1064
1065 void SAL_CALL XCUBasedAcceleratorConfiguration::addEventListener( const css::uno::Reference< css::lang::XEventListener >& /*xListener*/ )
1066     throw(css::uno::RuntimeException, std::exception)
1067 {
1068     // nop
1069 }
1070
1071 void SAL_CALL XCUBasedAcceleratorConfiguration::removeEventListener( const css::uno::Reference< css::lang::XEventListener >& /*xListener*/ )
1072     throw(css::uno::RuntimeException, std::exception)
1073 {
1074     // nop
1075 }
1076
1077 void XCUBasedAcceleratorConfiguration::impl_ts_load( bool bPreferred, const css::uno::Reference< css::container::XNameAccess >& xCfg )
1078 {
1079     AcceleratorCache aReadCache = AcceleratorCache();
1080     css::uno::Reference< css::container::XNameAccess > xAccess;
1081     if ( m_sGlobalOrModules == "Global" )
1082         xCfg->getByName(CFG_ENTRY_GLOBAL) >>= xAccess;
1083     else if ( m_sGlobalOrModules == "Modules" )
1084     {
1085         css::uno::Reference< css::container::XNameAccess > xModules;
1086         xCfg->getByName(CFG_ENTRY_MODULES) >>= xModules;
1087         xModules->getByName(m_sModuleCFG) >>= xAccess;
1088     }
1089
1090     const OUString sIsoLang       = impl_ts_getLocale();
1091     const OUString sDefaultLocale("en-US");
1092
1093     css::uno::Reference< css::container::XNameAccess > xKey;
1094     css::uno::Reference< css::container::XNameAccess > xCommand;
1095     if (xAccess.is())
1096     {
1097         css::uno::Sequence< OUString > lKeys = xAccess->getElementNames();
1098         sal_Int32 nKeys = lKeys.getLength();
1099         for ( sal_Int32 i=0; i<nKeys; ++i )
1100         {
1101             OUString sKey = lKeys[i];
1102             xAccess->getByName(sKey) >>= xKey;
1103             xKey->getByName(CFG_PROP_COMMAND) >>= xCommand;
1104
1105             css::uno::Sequence< OUString > lLocales = xCommand->getElementNames();
1106             sal_Int32 nLocales = lLocales.getLength();
1107             ::std::vector< OUString > aLocales;
1108             for ( sal_Int32 j=0; j<nLocales; ++j )
1109                 aLocales.push_back(lLocales[j]);
1110
1111             ::std::vector< OUString >::const_iterator pFound;
1112             for ( pFound = aLocales.begin(); pFound != aLocales.end(); ++pFound )
1113             {
1114                 if ( *pFound == sIsoLang )
1115                     break;
1116             }
1117
1118             if ( pFound == aLocales.end() )
1119             {
1120                 for ( pFound = aLocales.begin(); pFound != aLocales.end(); ++pFound )
1121                 {
1122                     if ( *pFound == sDefaultLocale )
1123                         break;
1124                 }
1125
1126                 if ( pFound == aLocales.end() )
1127                     continue;
1128             }
1129
1130             OUString sLocale = *pFound;
1131             OUString sCommand;
1132             xCommand->getByName(sLocale) >>= sCommand;
1133             if (sCommand.isEmpty())
1134                 continue;
1135
1136             css::awt::KeyEvent aKeyEvent;
1137
1138             sal_Int32 nIndex = 0;
1139             OUString sKeyCommand = sKey.getToken(0, '_', nIndex);
1140             OUString sPrefix("KEY_");
1141             aKeyEvent.KeyCode = KeyMapping::get().mapIdentifierToCode(sPrefix + sKeyCommand);
1142
1143             css::uno::Sequence< OUString > sToken(4);
1144             const sal_Int32 nToken = 4;
1145             bool bValid = true;
1146             sal_Int32 k;
1147             for (k=0; k<nToken; ++k)
1148             {
1149                 if (nIndex < 0)
1150                     break;
1151
1152                 sToken[k] = sKey.getToken(0, '_', nIndex);
1153                 if (sToken[k].isEmpty())
1154                 {
1155                     bValid = false;
1156                     break;
1157                 }
1158
1159                 if ( sToken[k] == "SHIFT" )
1160                     aKeyEvent.Modifiers |= css::awt::KeyModifier::SHIFT;
1161                 else if ( sToken[k] == "MOD1" )
1162                     aKeyEvent.Modifiers |= css::awt::KeyModifier::MOD1;
1163                 else if ( sToken[k] == "MOD2" )
1164                     aKeyEvent.Modifiers |= css::awt::KeyModifier::MOD2;
1165                 else if ( sToken[k] == "MOD3" )
1166                     aKeyEvent.Modifiers |= css::awt::KeyModifier::MOD3;
1167                 else
1168                 {
1169                     bValid = false;
1170                     break;
1171                 }
1172             }
1173
1174             if ( !aReadCache.hasKey(aKeyEvent) && bValid && k<nToken)
1175                 aReadCache.setKeyCommandPair(aKeyEvent, sCommand);
1176         }
1177     }
1178
1179     if (bPreferred)
1180         m_aPrimaryReadCache.takeOver(aReadCache);
1181     else
1182         m_aSecondaryReadCache.takeOver(aReadCache);
1183 }
1184
1185 void XCUBasedAcceleratorConfiguration::impl_ts_save(bool bPreferred, const css::uno::Reference< css::container::XNameAccess >& /*xCfg*/)
1186 {
1187     if (bPreferred)
1188     {
1189         AcceleratorCache::TKeyList::const_iterator pIt;
1190         AcceleratorCache::TKeyList lPrimaryReadKeys  = m_aPrimaryReadCache.getAllKeys();
1191         AcceleratorCache::TKeyList lPrimaryWriteKeys = m_pPrimaryWriteCache->getAllKeys();
1192
1193         for ( pIt  = lPrimaryReadKeys.begin(); pIt != lPrimaryReadKeys.end(); ++pIt )
1194         {
1195             if (!m_pPrimaryWriteCache->hasKey(*pIt))
1196                 removeKeyFromConfiguration(*pIt, true);
1197         }
1198
1199         for ( pIt  = lPrimaryWriteKeys.begin(); pIt != lPrimaryWriteKeys.end(); ++pIt )
1200         {
1201             OUString sCommand = m_pPrimaryWriteCache->getCommandByKey(*pIt);
1202             if (!m_aPrimaryReadCache.hasKey(*pIt))
1203             {
1204                 insertKeyToConfiguration(*pIt, sCommand, true);
1205             }
1206             else
1207             {
1208                 OUString sReadCommand = m_aPrimaryReadCache.getCommandByKey(*pIt);
1209                 if (sReadCommand != sCommand)
1210                     insertKeyToConfiguration(*pIt, sCommand, true);
1211             }
1212         }
1213
1214         // take over all changes into the original container
1215         SolarMutexGuard g;
1216         // coverity[check_after_deref]
1217         if (m_pPrimaryWriteCache)
1218         {
1219             m_aPrimaryReadCache.takeOver(*m_pPrimaryWriteCache);
1220             AcceleratorCache* pTemp = m_pPrimaryWriteCache;
1221             m_pPrimaryWriteCache = nullptr;
1222             delete pTemp;
1223         }
1224     }
1225
1226     else
1227     {
1228         AcceleratorCache::TKeyList::const_iterator pIt;
1229         AcceleratorCache::TKeyList lSecondaryReadKeys  = m_aSecondaryReadCache.getAllKeys();
1230         AcceleratorCache::TKeyList lSecondaryWriteKeys = m_pSecondaryWriteCache->getAllKeys();
1231
1232         for ( pIt  = lSecondaryReadKeys.begin(); pIt != lSecondaryReadKeys.end(); ++pIt)
1233         {
1234             if (!m_pSecondaryWriteCache->hasKey(*pIt))
1235                 removeKeyFromConfiguration(*pIt, false);
1236         }
1237
1238         for ( pIt  = lSecondaryWriteKeys.begin(); pIt != lSecondaryWriteKeys.end(); ++pIt )
1239         {
1240             OUString sCommand = m_pSecondaryWriteCache->getCommandByKey(*pIt);
1241             if (!m_aSecondaryReadCache.hasKey(*pIt))
1242             {
1243                 insertKeyToConfiguration(*pIt, sCommand, false);
1244             }
1245             else
1246             {
1247                 OUString sReadCommand = m_aSecondaryReadCache.getCommandByKey(*pIt);
1248                 if (sReadCommand != sCommand)
1249                     insertKeyToConfiguration(*pIt, sCommand, false);
1250             }
1251         }
1252
1253         // take over all changes into the original container
1254         SolarMutexGuard g;
1255         // coverity[check_after_deref]
1256         if (m_pSecondaryWriteCache)
1257         {
1258             m_aSecondaryReadCache.takeOver(*m_pSecondaryWriteCache);
1259             AcceleratorCache* pTemp = m_pSecondaryWriteCache;
1260             m_pSecondaryWriteCache = nullptr;
1261             delete pTemp;
1262         }
1263     }
1264
1265     ::comphelper::ConfigurationHelper::flush(m_xCfg);
1266 }
1267
1268 void XCUBasedAcceleratorConfiguration::insertKeyToConfiguration( const css::awt::KeyEvent& aKeyEvent, const OUString& sCommand, const bool bPreferred )
1269 {
1270     css::uno::Reference< css::container::XNameAccess > xAccess;
1271     css::uno::Reference< css::container::XNameContainer > xContainer;
1272     css::uno::Reference< css::lang::XSingleServiceFactory > xFac;
1273     css::uno::Reference< css::uno::XInterface > xInst;
1274
1275     if ( bPreferred )
1276         m_xCfg->getByName(CFG_ENTRY_PRIMARY) >>= xAccess;
1277     else
1278         m_xCfg->getByName(CFG_ENTRY_SECONDARY) >>= xAccess;
1279
1280     if ( m_sGlobalOrModules == CFG_ENTRY_GLOBAL )
1281         xAccess->getByName(CFG_ENTRY_GLOBAL) >>= xContainer;
1282     else if ( m_sGlobalOrModules == CFG_ENTRY_MODULES )
1283     {
1284         css::uno::Reference< css::container::XNameContainer > xModules;
1285         xAccess->getByName(CFG_ENTRY_MODULES) >>= xModules;
1286         if ( !xModules->hasByName(m_sModuleCFG) )
1287         {
1288             xFac.set(xModules, css::uno::UNO_QUERY);
1289             xInst = xFac->createInstance();
1290             xModules->insertByName(m_sModuleCFG, css::uno::makeAny(xInst));
1291         }
1292         xModules->getByName(m_sModuleCFG) >>= xContainer;
1293     }
1294
1295     const OUString sKey = lcl_getKeyString(aKeyEvent);
1296     css::uno::Reference< css::container::XNameAccess > xKey;
1297     css::uno::Reference< css::container::XNameContainer > xCommand;
1298     if ( !xContainer->hasByName(sKey) )
1299     {
1300         xFac.set(xContainer, css::uno::UNO_QUERY);
1301         xInst = xFac->createInstance();
1302         xContainer->insertByName(sKey, css::uno::makeAny(xInst));
1303     }
1304     xContainer->getByName(sKey) >>= xKey;
1305
1306     xKey->getByName(CFG_PROP_COMMAND) >>= xCommand;
1307     OUString sLocale = impl_ts_getLocale();
1308     if ( !xCommand->hasByName(sLocale) )
1309         xCommand->insertByName(sLocale, css::uno::makeAny(sCommand));
1310     else
1311         xCommand->replaceByName(sLocale, css::uno::makeAny(sCommand));
1312 }
1313
1314 void XCUBasedAcceleratorConfiguration::removeKeyFromConfiguration( const css::awt::KeyEvent& aKeyEvent, const bool bPreferred )
1315 {
1316     css::uno::Reference< css::container::XNameAccess > xAccess;
1317     css::uno::Reference< css::container::XNameContainer > xContainer;
1318
1319     if ( bPreferred )
1320         m_xCfg->getByName(CFG_ENTRY_PRIMARY) >>= xAccess;
1321     else
1322         m_xCfg->getByName(CFG_ENTRY_SECONDARY) >>= xAccess;
1323
1324     if ( m_sGlobalOrModules == CFG_ENTRY_GLOBAL )
1325         xAccess->getByName(CFG_ENTRY_GLOBAL) >>= xContainer;
1326     else if ( m_sGlobalOrModules == CFG_ENTRY_MODULES )
1327     {
1328         css::uno::Reference< css::container::XNameAccess > xModules;
1329         xAccess->getByName(CFG_ENTRY_MODULES) >>= xModules;
1330         if ( !xModules->hasByName(m_sModuleCFG) )
1331             return;
1332         xModules->getByName(m_sModuleCFG) >>= xContainer;
1333     }
1334
1335     const OUString sKey = lcl_getKeyString(aKeyEvent);
1336     xContainer->removeByName(sKey);
1337 }
1338
1339 void XCUBasedAcceleratorConfiguration::reloadChanged( const OUString& sPrimarySecondary, const OUString& sGlobalModules, const OUString& sModule, const OUString& sKey )
1340 {
1341     css::uno::Reference< css::container::XNameAccess > xAccess;
1342     css::uno::Reference< css::container::XNameContainer > xContainer;
1343
1344     m_xCfg->getByName(sPrimarySecondary) >>= xAccess;
1345     if ( sGlobalModules == CFG_ENTRY_GLOBAL )
1346         xAccess->getByName(CFG_ENTRY_GLOBAL) >>= xContainer;
1347     else
1348     {
1349         css::uno::Reference< css::container::XNameAccess > xModules;
1350         xAccess->getByName(CFG_ENTRY_MODULES) >>= xModules;
1351         if ( !xModules->hasByName(sModule) )
1352             return;
1353         xModules->getByName(sModule) >>= xContainer;
1354     }
1355
1356     css::awt::KeyEvent aKeyEvent;
1357     OUString sKeyIdentifier;
1358
1359     sal_Int32 nIndex = 0;
1360     sKeyIdentifier = sKey.getToken(0, '_', nIndex);
1361     aKeyEvent.KeyCode = KeyMapping::get().mapIdentifierToCode("KEY_"+sKeyIdentifier);
1362
1363     css::uno::Sequence< OUString > sToken(3);
1364     const sal_Int32 nToken = 3;
1365     for (sal_Int32 i=0; i<nToken; ++i)
1366     {
1367         if ( nIndex < 0 )
1368             break;
1369
1370         sToken[i] = sKey.getToken(0, '_', nIndex);
1371         if ( sToken[i] == "SHIFT" )
1372             aKeyEvent.Modifiers |= css::awt::KeyModifier::SHIFT;
1373         else if ( sToken[i] == "MOD1" )
1374             aKeyEvent.Modifiers |= css::awt::KeyModifier::MOD1;
1375         else if ( sToken[i] == "MOD2" )
1376             aKeyEvent.Modifiers |= css::awt::KeyModifier::MOD2;
1377                 else if ( sToken[i] == "MOD3" )
1378                         aKeyEvent.Modifiers |= css::awt::KeyModifier::MOD3;
1379     }
1380
1381     css::uno::Reference< css::container::XNameAccess > xKey;
1382     css::uno::Reference< css::container::XNameAccess > xCommand;
1383     OUString sCommand;
1384
1385     if (xContainer->hasByName(sKey))
1386     {
1387         OUString sLocale = impl_ts_getLocale();
1388         xContainer->getByName(sKey)    >>= xKey;
1389         xKey->getByName(CFG_PROP_COMMAND)  >>= xCommand;
1390         xCommand->getByName(sLocale)       >>= sCommand;
1391     }
1392
1393     if ( sPrimarySecondary == CFG_ENTRY_PRIMARY )
1394     {
1395         if (sCommand.isEmpty())
1396             m_aPrimaryReadCache.removeKey(aKeyEvent);
1397         else
1398             m_aPrimaryReadCache.setKeyCommandPair(aKeyEvent, sCommand);
1399     }
1400     else if ( sPrimarySecondary == CFG_ENTRY_SECONDARY )
1401     {
1402         if (sCommand.isEmpty())
1403             m_aSecondaryReadCache.removeKey(aKeyEvent);
1404         else
1405             m_aSecondaryReadCache.setKeyCommandPair(aKeyEvent, sCommand);
1406     }
1407 }
1408
1409 AcceleratorCache& XCUBasedAcceleratorConfiguration::impl_getCFG(bool bPreferred, bool bWriteAccessRequested)
1410 {
1411     SolarMutexGuard g;
1412
1413     if (bPreferred)
1414     {
1415         //create copy of our readonly-cache, if write access is forced ... but
1416         //not still possible!
1417         if (
1418             (bWriteAccessRequested) &&
1419             (!m_pPrimaryWriteCache       )
1420             )
1421         {
1422             m_pPrimaryWriteCache = new AcceleratorCache(m_aPrimaryReadCache);
1423         }
1424
1425         // in case, we have a writeable cache, we use it for reading too!
1426         // Otherwise the API user can't find its own changes ...
1427         if (m_pPrimaryWriteCache)
1428             return *m_pPrimaryWriteCache;
1429         else
1430             return m_aPrimaryReadCache;
1431     }
1432
1433     else
1434     {
1435         //create copy of our readonly-cache, if write access is forced ... but
1436         //not still possible!
1437         if (
1438             (bWriteAccessRequested) &&
1439             (!m_pSecondaryWriteCache       )
1440             )
1441         {
1442             m_pSecondaryWriteCache = new AcceleratorCache(m_aSecondaryReadCache);
1443         }
1444
1445         // in case, we have a writeable cache, we use it for reading too!
1446         // Otherwise the API user can't find its own changes ...
1447         if (m_pSecondaryWriteCache)
1448             return *m_pSecondaryWriteCache;
1449         else
1450             return m_aSecondaryReadCache;
1451     }
1452 }
1453
1454 OUString XCUBasedAcceleratorConfiguration::impl_ts_getLocale() const
1455 {
1456     OUString sISOLocale = officecfg::Setup::L10N::ooLocale::get();
1457
1458     if (sISOLocale.isEmpty())
1459         return OUString("en-US");
1460     return sISOLocale;
1461 }
1462
1463 } // namespace framework
1464
1465 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */