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