framework/source/uiconfiguration/windowstateconfiguration.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 <uiconfiguration/windowstateproperties.hxx>
  21 #include <helper/mischelper.hxx>
  22
  23 #include <com/sun/star/beans/PropertyValue.hpp>
  24 #include <com/sun/star/beans/XPropertySet.hpp>
  25 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  26 #include <com/sun/star/container/XNameAccess.hpp>
  27 #include <com/sun/star/container/XNameContainer.hpp>
  28 #include <com/sun/star/container/XContainer.hpp>
  29 #include <com/sun/star/lang/XServiceInfo.hpp>
  30 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  31 #include <com/sun/star/frame/ModuleManager.hpp>
  32 #include <com/sun/star/frame/XModuleManager2.hpp>
  33 #include <com/sun/star/awt/Point.hpp>
  34 #include <com/sun/star/awt/Size.hpp>
  35 #include <com/sun/star/ui/DockingArea.hpp>
  36 #include <com/sun/star/util/XChangesBatch.hpp>
  37 #include <com/sun/star/uno/XComponentContext.hpp>
  38
  39 #include <comphelper/compbase.hxx>
  40 #include <comphelper/string.hxx>
  41 #include <cppuhelper/implbase.hxx>
  42 #include <cppuhelper/supportsservice.hxx>
  43 #include <comphelper/propertysequence.hxx>
  44 #include <comphelper/sequence.hxx>
  45 #include <rtl/ref.hxx>
  46 #include <sal/log.hxx>
  47 #include <o3tl/string_view.hxx>
  48
  49 #include <mutex>
  50 #include <string_view>
  51 #include <unordered_map>
  52 #include <vector>
  53
  54 using namespace com::sun::star::uno;
  55 using namespace com::sun::star::lang;
  56 using namespace com::sun::star::beans;
  57 using namespace com::sun::star::util;
  58 using namespace com::sun::star::configuration;
  59 using namespace com::sun::star::container;
  60 using namespace ::com::sun::star::frame;
  61 using namespace ::com::sun::star::ui;
  62 using namespace framework;
  63
  64 namespace {
  65
  66 // Zero based indexes, order must be the same as WindowStateMask && CONFIGURATION_PROPERTIES!
  67 const sal_Int16 PROPERTY_LOCKED                  = 0;
  68 const sal_Int16 PROPERTY_DOCKED                  = 1;
  69 const sal_Int16 PROPERTY_VISIBLE                 = 2;
  70 const sal_Int16 PROPERTY_CONTEXT                 = 3;
  71 const sal_Int16 PROPERTY_HIDEFROMMENU            = 4;
  72 const sal_Int16 PROPERTY_NOCLOSE                 = 5;
  73 const sal_Int16 PROPERTY_SOFTCLOSE               = 6;
  74 const sal_Int16 PROPERTY_CONTEXTACTIVE           = 7;
  75 const sal_Int16 PROPERTY_DOCKINGAREA             = 8;
  76 const sal_Int16 PROPERTY_POS                     = 9;
  77 const sal_Int16 PROPERTY_SIZE                    = 10;
  78 const sal_Int16 PROPERTY_UINAME                  = 11;
  79 const sal_Int16 PROPERTY_INTERNALSTATE           = 12;
  80 const sal_Int16 PROPERTY_STYLE                   = 13;
  81 const sal_Int16 PROPERTY_DOCKPOS                 = 14;
  82 const sal_Int16 PROPERTY_DOCKSIZE                = 15;
  83
  84 // Order must be the same as WindowStateMask!!
  85 constexpr OUString CONFIGURATION_PROPERTIES[]
  86 {
  87     WINDOWSTATE_PROPERTY_LOCKED,
  88     WINDOWSTATE_PROPERTY_DOCKED,
  89     WINDOWSTATE_PROPERTY_VISIBLE,
  90     WINDOWSTATE_PROPERTY_CONTEXT,
  91     WINDOWSTATE_PROPERTY_HIDEFROMENU,
  92     WINDOWSTATE_PROPERTY_NOCLOSE,
  93     WINDOWSTATE_PROPERTY_SOFTCLOSE,
  94     WINDOWSTATE_PROPERTY_CONTEXTACTIVE,
  95     WINDOWSTATE_PROPERTY_DOCKINGAREA,
  96     WINDOWSTATE_PROPERTY_POS,
  97     WINDOWSTATE_PROPERTY_SIZE,
  98     WINDOWSTATE_PROPERTY_UINAME,
  99     WINDOWSTATE_PROPERTY_INTERNALSTATE,
 100     WINDOWSTATE_PROPERTY_STYLE,
 101     WINDOWSTATE_PROPERTY_DOCKPOS,
 102     WINDOWSTATE_PROPERTY_DOCKSIZE
 103 };
 104
 105 //  Configuration access class for WindowState supplier implementation
 106
 107 class ConfigurationAccess_WindowState : public  ::cppu::WeakImplHelper< XNameContainer, XContainerListener >
 108 {
 109     public:
 110                                   ConfigurationAccess_WindowState( std::u16string_view aWindowStateConfigFile, const Reference< XComponentContext >& rxContext );
 111         virtual                   ~ConfigurationAccess_WindowState() override;
 112
 113         // XNameAccess
 114         virtual css::uno::Any SAL_CALL getByName( const OUString& aName ) override;
 115
 116         virtual css::uno::Sequence< OUString > SAL_CALL getElementNames() override;
 117
 118         virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override;
 119
 120         // XNameContainer
 121         virtual void SAL_CALL removeByName( const OUString& sName ) override;
 122
 123         virtual void SAL_CALL insertByName( const OUString& sName, const css::uno::Any&   aPropertySet ) override;
 124
 125         // XNameReplace
 126         virtual void SAL_CALL replaceByName( const OUString& sName, const css::uno::Any& aPropertySet ) override;
 127
 128         // XElementAccess
 129         virtual css::uno::Type SAL_CALL getElementType() override;
 130
 131         virtual sal_Bool SAL_CALL hasElements() override;
 132
 133         // container.XContainerListener
 134         virtual void SAL_CALL     elementInserted( const ContainerEvent& aEvent ) override;
 135         virtual void SAL_CALL     elementRemoved ( const ContainerEvent& aEvent ) override;
 136         virtual void SAL_CALL     elementReplaced( const ContainerEvent& aEvent ) override;
 137
 138         // lang.XEventListener
 139         virtual void SAL_CALL disposing( const EventObject& aEvent ) override;
 140
 141     protected:
 142         enum // WindowStateMask
 143         {
 144             WINDOWSTATE_MASK_DOCKINGAREA    = 256,
 145             WINDOWSTATE_MASK_POS            = 512,
 146             WINDOWSTATE_MASK_SIZE           = 1024,
 147             WINDOWSTATE_MASK_UINAME         = 2048,
 148             WINDOWSTATE_MASK_INTERNALSTATE  = 4096,
 149             WINDOWSTATE_MASK_STYLE          = 8192,
 150             WINDOWSTATE_MASK_DOCKPOS        = 16384,
 151             WINDOWSTATE_MASK_DOCKSIZE       = 32768
 152         };
 153
 154         // Cache structure. Valid values are described by the eMask member. All other values should not be
 155         // provided to outside code!
 156         struct WindowStateInfo
 157         {
 158             WindowStateInfo()
 159                 : bLocked(false)
 160                 , bDocked(false)
 161                 , bVisible(false)
 162                 , bContext(false)
 163                 , bHideFromMenu(false)
 164                 , bNoClose(false)
 165                 , bSoftClose(false)
 166                 , bContextActive(false)
 167                 , aDockingArea(css::ui::DockingArea_DOCKINGAREA_TOP)
 168                 , aDockPos(0, 0)
 169                 , aPos(0, 0)
 170                 , aSize(0, 0)
 171                 , nInternalState(0)
 172                 , nStyle(0)
 173                 , nMask(0)
 174             {
 175             }
 176
 177             bool                                    bLocked : 1,
 178                                                     bDocked : 1,
 179                                                     bVisible : 1,
 180                                                     bContext : 1,
 181                                                     bHideFromMenu : 1,
 182                                                     bNoClose : 1,
 183                                                     bSoftClose : 1,
 184                                                     bContextActive : 1;
 185             css::ui::DockingArea                    aDockingArea;
 186             css::awt::Point                         aDockPos;
 187             css::awt::Size                          aDockSize;
 188             css::awt::Point                         aPos;
 189             css::awt::Size                          aSize;
 190             OUString                                aUIName;
 191             sal_uInt32                              nInternalState;
 192             sal_uInt16                              nStyle;
 193             sal_uInt32                              nMask; // see WindowStateMask
 194         };
 195
 196         void                      impl_putPropertiesFromStruct( const WindowStateInfo& rWinStateInfo, Reference< XPropertySet > const & xPropSet );
 197         Any                       impl_insertCacheAndReturnSequence( const OUString& rResourceURL, Reference< XNameAccess > const & rNameAccess );
 198         WindowStateInfo&          impl_insertCacheAndReturnWinState( const OUString& rResourceURL, Reference< XNameAccess > const & rNameAccess );
 199         Any                       impl_getSequenceFromStruct( const WindowStateInfo& rWinStateInfo );
 200         void                      impl_fillStructFromSequence( WindowStateInfo& rWinStateInfo, const Sequence< PropertyValue >& rSeq );
 201         Any                       impl_getWindowStateFromResourceURL( const OUString& rResourceURL );
 202         void                      impl_initializeConfigAccess();
 203
 204     private:
 205         typedef std::unordered_map< OUString,
 206                                     WindowStateInfo > ResourceURLToInfoCache;
 207
 208         std::mutex                        m_aMutex;
 209         OUString                          m_aConfigWindowAccess;
 210         Reference< XMultiServiceFactory > m_xConfigProvider;
 211         Reference< XNameAccess >          m_xConfigAccess;
 212         rtl::Reference< WeakContainerListener >   m_xConfigListener;
 213         ResourceURLToInfoCache            m_aResourceURLToInfoCache;
 214         bool                              m_bConfigAccessInitialized : 1,
 215                                           m_bModified : 1;
 216         std::vector< OUString >           m_aPropArray;
 217 };
 218
 219 ConfigurationAccess_WindowState::ConfigurationAccess_WindowState( std::u16string_view aModuleName, const Reference< XComponentContext >& rxContext ) :
 220     // Create configuration hierarchical access name
 221     m_aConfigWindowAccess(
 222         OUString::Concat("/org.openoffice.Office.UI.") + aModuleName + "/UIElements/States"),
 223     m_xConfigProvider(theDefaultProvider::get( rxContext )),
 224     m_bConfigAccessInitialized( false ),
 225     m_bModified( false )
 226 {
 227     // Initialize access array with property names.
 228     for (const OUString & s : CONFIGURATION_PROPERTIES )
 229         m_aPropArray.push_back(s);
 230 }
 231
 232 ConfigurationAccess_WindowState::~ConfigurationAccess_WindowState()
 233 {
 234     // SAFE
 235     std::unique_lock g(m_aMutex);
 236     Reference< XContainer > xContainer( m_xConfigAccess, UNO_QUERY );
 237     if ( xContainer.is() )
 238         xContainer->removeContainerListener(m_xConfigListener);
 239 }
 240
 241 // XNameAccess
 242 Any SAL_CALL ConfigurationAccess_WindowState::getByName( const OUString& rResourceURL )
 243 {
 244     // SAFE
 245     std::unique_lock g(m_aMutex);
 246
 247     ResourceURLToInfoCache::const_iterator pIter = m_aResourceURLToInfoCache.find( rResourceURL );
 248     if ( pIter != m_aResourceURLToInfoCache.end() )
 249         return impl_getSequenceFromStruct( pIter->second );
 250     else
 251     {
 252         Any a( impl_getWindowStateFromResourceURL( rResourceURL ) );
 253         if ( a == Any() )
 254             throw NoSuchElementException();
 255         return a;
 256     }
 257 }
 258
 259 Sequence< OUString > SAL_CALL ConfigurationAccess_WindowState::getElementNames()
 260 {
 261     // SAFE
 262     std::unique_lock g(m_aMutex);
 263
 264     if ( !m_bConfigAccessInitialized )
 265     {
 266         impl_initializeConfigAccess();
 267         m_bConfigAccessInitialized = true;
 268     }
 269
 270     if ( m_xConfigAccess.is() )
 271         return m_xConfigAccess->getElementNames();
 272     else
 273         return Sequence< OUString > ();
 274 }
 275
 276 sal_Bool SAL_CALL ConfigurationAccess_WindowState::hasByName( const OUString& rResourceURL )
 277 {
 278     // SAFE
 279     std::unique_lock g(m_aMutex);
 280
 281     ResourceURLToInfoCache::const_iterator pIter = m_aResourceURLToInfoCache.find( rResourceURL );
 282     if ( pIter != m_aResourceURLToInfoCache.end() )
 283         return true;
 284     else
 285     {
 286         Any a( impl_getWindowStateFromResourceURL( rResourceURL ) );
 287         if ( a == Any() )
 288             return false;
 289         else
 290             return true;
 291     }
 292 }
 293
 294 // XElementAccess
 295 Type SAL_CALL ConfigurationAccess_WindowState::getElementType()
 296 {
 297     return cppu::UnoType<Sequence< PropertyValue >>::get();
 298 }
 299
 300 sal_Bool SAL_CALL ConfigurationAccess_WindowState::hasElements()
 301 {
 302     // SAFE
 303     std::unique_lock g(m_aMutex);
 304
 305     if ( !m_bConfigAccessInitialized )
 306     {
 307         impl_initializeConfigAccess();
 308         m_bConfigAccessInitialized = true;
 309     }
 310
 311     if ( m_xConfigAccess.is() )
 312         return m_xConfigAccess->hasElements();
 313     else
 314         return false;
 315 }
 316
 317 // XNameContainer
 318 void SAL_CALL ConfigurationAccess_WindowState::removeByName( const OUString& rResourceURL )
 319 {
 320     // SAFE
 321     std::unique_lock g(m_aMutex);
 322
 323     ResourceURLToInfoCache::iterator pIter = m_aResourceURLToInfoCache.find( rResourceURL );
 324     if ( pIter != m_aResourceURLToInfoCache.end() )
 325         m_aResourceURLToInfoCache.erase( pIter );
 326
 327     if ( !m_bConfigAccessInitialized )
 328     {
 329         impl_initializeConfigAccess();
 330         m_bConfigAccessInitialized = true;
 331     }
 332
 333     try
 334     {
 335         // Remove must be write-through => remove element from configuration
 336         Reference< XNameContainer > xNameContainer( m_xConfigAccess, UNO_QUERY );
 337         if ( xNameContainer.is() )
 338         {
 339             g.unlock();
 340
 341             xNameContainer->removeByName( rResourceURL );
 342             Reference< XChangesBatch > xFlush( m_xConfigAccess, UNO_QUERY );
 343             if ( xFlush.is() )
 344                 xFlush->commitChanges();
 345         }
 346     }
 347     catch ( const css::lang::WrappedTargetException& )
 348     {
 349     }
 350 }
 351
 352 void SAL_CALL ConfigurationAccess_WindowState::insertByName( const OUString& rResourceURL, const css::uno::Any& aPropertySet )
 353 {
 354     // SAFE
 355     std::unique_lock g(m_aMutex);
 356
 357     Sequence< PropertyValue > aPropSet;
 358     if ( !(aPropertySet >>= aPropSet) )
 359         throw IllegalArgumentException();
 360
 361     ResourceURLToInfoCache::const_iterator pIter = m_aResourceURLToInfoCache.find( rResourceURL );
 362     if ( pIter != m_aResourceURLToInfoCache.end() )
 363         throw ElementExistException();
 364
 365     if ( !m_bConfigAccessInitialized )
 366     {
 367         impl_initializeConfigAccess();
 368         m_bConfigAccessInitialized = true;
 369     }
 370
 371     // Try to ask our configuration access
 372     if ( !m_xConfigAccess.is() )
 373         return;
 374
 375     if ( m_xConfigAccess->hasByName( rResourceURL ) )
 376         throw ElementExistException();
 377
 378     WindowStateInfo aWinStateInfo;
 379     impl_fillStructFromSequence( aWinStateInfo, aPropSet );
 380     m_aResourceURLToInfoCache.emplace( rResourceURL, aWinStateInfo );
 381
 382     // insert must be write-through => insert element into configuration
 383     Reference< XNameContainer > xNameContainer( m_xConfigAccess, UNO_QUERY );
 384     if ( !xNameContainer.is() )
 385         return;
 386
 387     Reference< XSingleServiceFactory > xFactory( m_xConfigAccess, UNO_QUERY );
 388     g.unlock();
 389
 390     try
 391     {
 392         Reference< XPropertySet > xPropSet( xFactory->createInstance(), UNO_QUERY );
 393         if ( xPropSet.is() )
 394         {
 395             Any a;
 396             impl_putPropertiesFromStruct( aWinStateInfo, xPropSet );
 397             a <<= xPropSet;
 398             xNameContainer->insertByName( rResourceURL, a );
 399             Reference< XChangesBatch > xFlush( xFactory, UNO_QUERY );
 400             if ( xFlush.is() )
 401                 xFlush->commitChanges();
 402         }
 403     }
 404     catch ( const Exception& )
 405     {
 406     }
 407 }
 408
 409 // XNameReplace
 410 void SAL_CALL ConfigurationAccess_WindowState::replaceByName( const OUString& rResourceURL, const css::uno::Any& aPropertySet )
 411 {
 412     // SAFE
 413     std::unique_lock g(m_aMutex);
 414
 415     Sequence< PropertyValue > aPropSet;
 416     if ( !(aPropertySet >>= aPropSet) )
 417         throw IllegalArgumentException();
 418
 419     ResourceURLToInfoCache::iterator pIter = m_aResourceURLToInfoCache.find( rResourceURL );
 420     if ( pIter != m_aResourceURLToInfoCache.end() )
 421     {
 422         WindowStateInfo& rWinStateInfo = pIter->second;
 423         impl_fillStructFromSequence( rWinStateInfo, aPropSet );
 424         m_bModified = true;
 425     }
 426     else
 427     {
 428         if ( !m_bConfigAccessInitialized )
 429         {
 430             impl_initializeConfigAccess();
 431             m_bConfigAccessInitialized = true;
 432         }
 433
 434         // Try to ask our configuration access
 435         Reference< XNameAccess > xNameAccess;
 436         Any a( m_xConfigAccess->getByName( rResourceURL ));
 437
 438         if ( !(a >>= xNameAccess) )
 439             throw NoSuchElementException();
 440
 441         WindowStateInfo& rWinStateInfo( impl_insertCacheAndReturnWinState( rResourceURL, xNameAccess ));
 442         impl_fillStructFromSequence( rWinStateInfo, aPropSet );
 443         m_bModified = true;
 444         pIter = m_aResourceURLToInfoCache.find( rResourceURL );
 445
 446     }
 447
 448     if ( !(m_bModified && pIter != m_aResourceURLToInfoCache.end()) )
 449         return;
 450
 451     Reference< XNameContainer > xNameContainer( m_xConfigAccess, UNO_QUERY );
 452     if ( !xNameContainer.is() )
 453         return;
 454
 455     WindowStateInfo aWinStateInfo( pIter->second );
 456     OUString        aResourceURL( pIter->first );
 457     m_bModified = false;
 458     g.unlock();
 459
 460     try
 461     {
 462         Reference< XPropertySet > xPropSet;
 463         if ( xNameContainer->getByName( aResourceURL ) >>= xPropSet )
 464         {
 465             impl_putPropertiesFromStruct( aWinStateInfo, xPropSet );
 466
 467             Reference< XChangesBatch > xFlush( m_xConfigAccess, UNO_QUERY );
 468             if ( xFlush.is() )
 469                 xFlush->commitChanges();
 470         }
 471     }
 472     catch ( const Exception& )
 473     {
 474     }
 475
 476 }
 477
 478 // container.XContainerListener
 479 void SAL_CALL ConfigurationAccess_WindowState::elementInserted( const ContainerEvent& )
 480 {
 481     // do nothing - next time someone wants to retrieve this node we will find it in the configuration
 482 }
 483
 484 void SAL_CALL ConfigurationAccess_WindowState::elementRemoved ( const ContainerEvent& )
 485 {
 486 }
 487
 488 void SAL_CALL ConfigurationAccess_WindowState::elementReplaced( const ContainerEvent& )
 489 {
 490 }
 491
 492 // lang.XEventListener
 493 void SAL_CALL ConfigurationAccess_WindowState::disposing( const EventObject& aEvent )
 494 {
 495     // SAFE
 496     // remove our reference to the config access
 497     std::unique_lock g(m_aMutex);
 498
 499     Reference< XInterface > xIfac1( aEvent.Source, UNO_QUERY );
 500     Reference< XInterface > xIfac2( m_xConfigAccess, UNO_QUERY );
 501     if ( xIfac1 == xIfac2 )
 502         m_xConfigAccess.clear();
 503 }
 504
 505 // private helper methods
 506 Any ConfigurationAccess_WindowState::impl_getSequenceFromStruct( const WindowStateInfo& rWinStateInfo )
 507 {
 508     sal_Int32                 i( 0 );
 509     sal_Int32                 nCount( m_aPropArray.size() );
 510     std::vector< PropertyValue > aPropVec;
 511
 512     for ( i = 0; i < nCount; i++ )
 513     {
 514         if ( rWinStateInfo.nMask & ( 1 << i ))
 515         {
 516             // put value into the return sequence
 517             PropertyValue pv;
 518             pv.Name = m_aPropArray[i];
 519
 520             switch ( i )
 521             {
 522                 case PROPERTY_LOCKED:
 523                     pv.Value <<= rWinStateInfo.bLocked; break;
 524                 case PROPERTY_DOCKED:
 525                     pv.Value <<= rWinStateInfo.bDocked; break;
 526                 case PROPERTY_VISIBLE:
 527                     pv.Value <<= rWinStateInfo.bVisible; break;
 528                 case PROPERTY_CONTEXT:
 529                     pv.Value <<= rWinStateInfo.bContext; break;
 530                 case PROPERTY_HIDEFROMMENU:
 531                     pv.Value <<= rWinStateInfo.bHideFromMenu; break;
 532                 case PROPERTY_NOCLOSE:
 533                     pv.Value <<= rWinStateInfo.bNoClose; break;
 534                 case PROPERTY_SOFTCLOSE:
 535                     pv.Value <<= rWinStateInfo.bSoftClose; break;
 536                 case PROPERTY_CONTEXTACTIVE:
 537                     pv.Value <<= rWinStateInfo.bContextActive; break;
 538                 case PROPERTY_DOCKINGAREA:
 539                     pv.Value <<= rWinStateInfo.aDockingArea; break;
 540                 case PROPERTY_POS:
 541                     pv.Value <<= rWinStateInfo.aPos; break;
 542                 case PROPERTY_SIZE:
 543                     pv.Value <<= rWinStateInfo.aSize; break;
 544                 case PROPERTY_UINAME:
 545                     pv.Value <<= rWinStateInfo.aUIName; break;
 546                 case PROPERTY_INTERNALSTATE:
 547                     pv.Value <<= sal_Int32( rWinStateInfo.nInternalState ); break;
 548                 case PROPERTY_STYLE:
 549                     pv.Value <<= sal_Int16( rWinStateInfo.nStyle ); break;
 550                 case PROPERTY_DOCKPOS:
 551                     pv.Value <<= rWinStateInfo.aDockPos; break;
 552                 case PROPERTY_DOCKSIZE:
 553                     pv.Value <<= rWinStateInfo.aDockSize; break;
 554                 default:
 555                     assert( false && "Wrong value for ConfigurationAccess_WindowState. Who has forgotten to add this new property!" );
 556             }
 557             aPropVec.push_back(pv);
 558         }
 559     }
 560
 561     return Any( comphelper::containerToSequence(aPropVec) );
 562 }
 563
 564 Any ConfigurationAccess_WindowState::impl_insertCacheAndReturnSequence( const OUString& rResourceURL, Reference< XNameAccess > const & xNameAccess )
 565 {
 566     sal_Int32                 nMask( 0 );
 567     sal_Int32                 nCount( m_aPropArray.size() );
 568     sal_Int32                 i( 0 );
 569     std::vector< PropertyValue > aPropVec;
 570     WindowStateInfo           aWindowStateInfo;
 571
 572     for ( i = 0; i < nCount; i++ )
 573     {
 574         try
 575         {
 576             bool    bAddToSeq( false );
 577             Any     a( xNameAccess->getByName( m_aPropArray[i] ) );
 578             switch ( i )
 579             {
 580                 case PROPERTY_LOCKED:
 581                 case PROPERTY_DOCKED:
 582                 case PROPERTY_VISIBLE:
 583                 case PROPERTY_CONTEXT:
 584                 case PROPERTY_HIDEFROMMENU:
 585                 case PROPERTY_NOCLOSE:
 586                 case PROPERTY_SOFTCLOSE:
 587                 case PROPERTY_CONTEXTACTIVE:
 588                 {
 589                     bool bValue;
 590                     if ( a >>= bValue )
 591                     {
 592                         sal_Int32 nValue( 1 << i );
 593                         nMask |= nValue;
 594                         bAddToSeq = true;
 595                         switch ( i )
 596                         {
 597                             case PROPERTY_LOCKED:
 598                                 aWindowStateInfo.bLocked = bValue; break;
 599                             case PROPERTY_DOCKED:
 600                                 aWindowStateInfo.bDocked = bValue; break;
 601                             case PROPERTY_VISIBLE:
 602                                 aWindowStateInfo.bVisible = bValue; break;
 603                             case PROPERTY_CONTEXT:
 604                                 aWindowStateInfo.bContext = bValue; break;
 605                             case PROPERTY_HIDEFROMMENU:
 606                                 aWindowStateInfo.bHideFromMenu = bValue; break;
 607                             case PROPERTY_NOCLOSE:
 608                                 aWindowStateInfo.bNoClose = bValue; break;
 609                             case PROPERTY_SOFTCLOSE:
 610                                 aWindowStateInfo.bSoftClose = bValue; break;
 611                             case PROPERTY_CONTEXTACTIVE:
 612                                 aWindowStateInfo.bContextActive = bValue; break;
 613                         }
 614                     }
 615                 }
 616                 break;
 617
 618                 case PROPERTY_DOCKINGAREA:
 619                 {
 620                     sal_Int32 nDockingArea = 0;
 621                     if ( a >>= nDockingArea )
 622                     {
 623                         if (( nDockingArea >= 0 ) &&
 624                             ( nDockingArea <= sal_Int32( DockingArea_DOCKINGAREA_RIGHT )))
 625                         {
 626                             aWindowStateInfo.aDockingArea = static_cast<DockingArea>(nDockingArea);
 627                             nMask |= WINDOWSTATE_MASK_DOCKINGAREA;
 628                             a <<= aWindowStateInfo.aDockingArea;
 629                             bAddToSeq = true;
 630                         }
 631                     }
 632                 }
 633                 break;
 634
 635                 case PROPERTY_POS:
 636                 case PROPERTY_DOCKPOS:
 637                 {
 638                     OUString aString;
 639                     if ( a >>= aString )
 640                     {
 641                         sal_Int32 nToken( 0 );
 642                         std::u16string_view aXStr = o3tl::getToken(aString, 0, ',', nToken );
 643                         if ( nToken > 0 )
 644                         {
 645                             css::awt::Point aPos;
 646                             aPos.X = o3tl::toInt32(aXStr);
 647                             aPos.Y = o3tl::toInt32(o3tl::getToken(aString, 0, ',', nToken ));
 648
 649                             if ( i == PROPERTY_POS )
 650                             {
 651                                 aWindowStateInfo.aPos = aPos;
 652                                 nMask |= WINDOWSTATE_MASK_POS;
 653                             }
 654                             else
 655                             {
 656                                 aWindowStateInfo.aDockPos = aPos;
 657                                 nMask |= WINDOWSTATE_MASK_DOCKPOS;
 658                             }
 659
 660                             a <<= aPos;
 661                             bAddToSeq = true;
 662                         }
 663                     }
 664                 }
 665                 break;
 666
 667                 case PROPERTY_SIZE:
 668                 case PROPERTY_DOCKSIZE:
 669                 {
 670                     OUString aString;
 671                     if ( a >>= aString )
 672                     {
 673                         sal_Int32 nToken( 0 );
 674                         std::u16string_view aStr = o3tl::getToken(aString, 0, ',', nToken );
 675                         if ( nToken > 0 )
 676                         {
 677                             css::awt::Size aSize;
 678                             aSize.Width = o3tl::toInt32(aStr);
 679                             aSize.Height = o3tl::toInt32(o3tl::getToken(aString, 0, ',', nToken ));
 680                             if ( i == PROPERTY_SIZE )
 681                             {
 682                                 aWindowStateInfo.aSize = aSize;
 683                                 nMask |= WINDOWSTATE_MASK_SIZE;
 684                             }
 685                             else
 686                             {
 687                                 aWindowStateInfo.aDockSize = aSize;
 688                                 nMask |= WINDOWSTATE_MASK_DOCKSIZE;
 689                             }
 690
 691                             a <<= aSize;
 692                             bAddToSeq = true;
 693                         }
 694                     }
 695                 }
 696                 break;
 697
 698                 case PROPERTY_UINAME:
 699                 {
 700                     OUString aValue;
 701                     if ( a >>= aValue )
 702                     {
 703                         nMask |= WINDOWSTATE_MASK_UINAME;
 704                         aWindowStateInfo.aUIName = aValue;
 705                         bAddToSeq = true;
 706                     }
 707                 }
 708                 break;
 709
 710                 case PROPERTY_INTERNALSTATE:
 711                 {
 712                     sal_uInt32 nValue = 0;
 713                     if ( a >>= nValue )
 714                     {
 715                         nMask |= WINDOWSTATE_MASK_INTERNALSTATE;
 716                         aWindowStateInfo.nInternalState = nValue;
 717                         bAddToSeq = true;
 718                     }
 719                 }
 720                 break;
 721
 722                 case PROPERTY_STYLE:
 723                 {
 724                     sal_Int32 nValue = 0;
 725                     if ( a >>= nValue )
 726                     {
 727                         nMask |= WINDOWSTATE_MASK_STYLE;
 728                         aWindowStateInfo.nStyle = sal_uInt16( nValue );
 729                         bAddToSeq = true;
 730                     }
 731                 }
 732                 break;
 733
 734                 default:
 735                    assert( false && "Wrong value for ConfigurationAccess_WindowState. Who has forgotten to add this new property!" );
 736             }
 737
 738             if ( bAddToSeq )
 739             {
 740                 // put value into the return sequence
 741                 PropertyValue pv;
 742                 pv.Name  = m_aPropArray[i];
 743                 pv.Value = std::move(a);
 744                 aPropVec.push_back(pv);
 745             }
 746         }
 747         catch( const css::container::NoSuchElementException& )
 748         {
 749         }
 750         catch ( const css::lang::WrappedTargetException& )
 751         {
 752         }
 753     }
 754
 755     aWindowStateInfo.nMask = nMask;
 756     m_aResourceURLToInfoCache.emplace( rResourceURL, aWindowStateInfo );
 757     return Any( comphelper::containerToSequence(aPropVec) );
 758 }
 759
 760 ConfigurationAccess_WindowState::WindowStateInfo& ConfigurationAccess_WindowState::impl_insertCacheAndReturnWinState( const OUString& rResourceURL, Reference< XNameAccess > const & rNameAccess )
 761 {
 762     sal_Int32                 nMask( 0 );
 763     sal_Int32                 nCount( m_aPropArray.size() );
 764     sal_Int32                 i( 0 );
 765     WindowStateInfo           aWindowStateInfo;
 766
 767     for ( i = 0; i < nCount; i++ )
 768     {
 769         try
 770         {
 771             Any     a( rNameAccess->getByName( m_aPropArray[i] ) );
 772             switch ( i )
 773             {
 774                 case PROPERTY_LOCKED:
 775                 case PROPERTY_DOCKED:
 776                 case PROPERTY_VISIBLE:
 777                 case PROPERTY_CONTEXT:
 778                 case PROPERTY_HIDEFROMMENU:
 779                 case PROPERTY_NOCLOSE:
 780                 case PROPERTY_SOFTCLOSE:
 781                 case PROPERTY_CONTEXTACTIVE:
 782                 {
 783                     bool bValue;
 784                     if ( a >>= bValue )
 785                     {
 786                         sal_Int32 nValue( 1 << i );
 787                         nMask |= nValue;
 788                         switch ( i )
 789                         {
 790                             case PROPERTY_LOCKED:
 791                                 aWindowStateInfo.bLocked = bValue; break;
 792                             case PROPERTY_DOCKED:
 793                                 aWindowStateInfo.bDocked = bValue; break;
 794                             case PROPERTY_VISIBLE:
 795                                 aWindowStateInfo.bVisible = bValue; break;
 796                             case PROPERTY_CONTEXT:
 797                                 aWindowStateInfo.bContext = bValue; break;
 798                             case PROPERTY_HIDEFROMMENU:
 799                                 aWindowStateInfo.bHideFromMenu = bValue; break;
 800                             case PROPERTY_NOCLOSE:
 801                                 aWindowStateInfo.bNoClose = bValue; break;
 802                             case PROPERTY_SOFTCLOSE:
 803                                 aWindowStateInfo.bNoClose = bValue; break;
 804                             case PROPERTY_CONTEXTACTIVE:
 805                                 aWindowStateInfo.bContextActive = bValue; break;
 806                             default:
 807                                 SAL_WARN( "fwk.uiconfiguration", "Unknown boolean property in WindowState found!" );
 808                         }
 809                     }
 810                 }
 811                 break;
 812
 813                 case PROPERTY_DOCKINGAREA:
 814                 {
 815                     sal_Int32 nDockingArea = 0;
 816                     if ( a >>= nDockingArea )
 817                     {
 818                         if (( nDockingArea >= 0 ) &&
 819                             ( nDockingArea <= sal_Int32( DockingArea_DOCKINGAREA_RIGHT )))
 820                         {
 821                             aWindowStateInfo.aDockingArea = static_cast<DockingArea>(nDockingArea);
 822                             nMask |= WINDOWSTATE_MASK_DOCKINGAREA;
 823                         }
 824                     }
 825                 }
 826                 break;
 827
 828                 case PROPERTY_POS:
 829                 case PROPERTY_DOCKPOS:
 830                 {
 831                     OUString aString;
 832                     if ( a >>= aString )
 833                     {
 834                         sal_Int32 nToken( 0 );
 835                         std::u16string_view aXStr = o3tl::getToken(aString, 0, ',', nToken );
 836                         if ( nToken > 0 )
 837                         {
 838                             css::awt::Point aPos;
 839                             aPos.X = o3tl::toInt32(aXStr);
 840                             aPos.Y = o3tl::toInt32(o3tl::getToken(aString, 0, ',', nToken ));
 841
 842                             if ( i == PROPERTY_POS )
 843                             {
 844                                 aWindowStateInfo.aPos = aPos;
 845                                 nMask |= WINDOWSTATE_MASK_POS;
 846                             }
 847                             else
 848                             {
 849                                 aWindowStateInfo.aDockPos = aPos;
 850                                 nMask |= WINDOWSTATE_MASK_DOCKPOS;
 851                             }
 852                         }
 853                     }
 854                 }
 855                 break;
 856
 857                 case PROPERTY_SIZE:
 858                 case PROPERTY_DOCKSIZE:
 859                 {
 860                     OUString aString;
 861                     if ( a >>= aString )
 862                     {
 863                         sal_Int32 nToken( 0 );
 864                         std::u16string_view aStr = o3tl::getToken(aString, 0, ',', nToken );
 865                         if ( nToken > 0 )
 866                         {
 867                             css::awt::Size aSize;
 868                             aSize.Width  = o3tl::toInt32(aStr);
 869                             aSize.Height = o3tl::toInt32(o3tl::getToken(aString, 0, ',', nToken ));
 870                             if ( i == PROPERTY_SIZE )
 871                             {
 872                                 aWindowStateInfo.aSize = aSize;
 873                                 nMask |= WINDOWSTATE_MASK_SIZE;
 874                             }
 875                             else
 876                             {
 877                                 aWindowStateInfo.aDockSize = aSize;
 878                                 nMask |= WINDOWSTATE_MASK_DOCKSIZE;
 879                             }
 880                         }
 881                     }
 882                 }
 883                 break;
 884
 885                 case PROPERTY_UINAME:
 886                 {
 887                     OUString aValue;
 888                     if ( a >>= aValue )
 889                     {
 890                         nMask |= WINDOWSTATE_MASK_UINAME;
 891                         aWindowStateInfo.aUIName = aValue;
 892                     }
 893                 }
 894                 break;
 895
 896                 case PROPERTY_INTERNALSTATE:
 897                 {
 898                     sal_Int32 nValue = 0;
 899                     if ( a >>= nValue )
 900                     {
 901                         nMask |= WINDOWSTATE_MASK_INTERNALSTATE;
 902                         aWindowStateInfo.nInternalState = sal_uInt32( nValue );
 903                     }
 904                 }
 905                 break;
 906
 907                 case PROPERTY_STYLE:
 908                 {
 909                     sal_Int32 nValue = 0;
 910                     if ( a >>= nValue )
 911                     {
 912                         nMask |= WINDOWSTATE_MASK_STYLE;
 913                         aWindowStateInfo.nStyle = sal_uInt16( nValue );
 914                     }
 915                 }
 916                 break;
 917
 918                 default:
 919                    assert( false && "Wrong value for ConfigurationAccess_WindowState. Who has forgotten to add this new property!" );
 920             }
 921         }
 922         catch( const css::container::NoSuchElementException& )
 923         {
 924         }
 925         catch ( const css::lang::WrappedTargetException& )
 926         {
 927         }
 928     }
 929
 930     aWindowStateInfo.nMask = nMask;
 931     ResourceURLToInfoCache::iterator pIter = m_aResourceURLToInfoCache.emplace( rResourceURL, aWindowStateInfo ).first;
 932     return pIter->second;
 933 }
 934
 935 Any ConfigurationAccess_WindowState::impl_getWindowStateFromResourceURL( const OUString& rResourceURL )
 936 {
 937     if ( !m_bConfigAccessInitialized )
 938     {
 939         impl_initializeConfigAccess();
 940         m_bConfigAccessInitialized = true;
 941     }
 942
 943     try
 944     {
 945         // Try to ask our configuration access
 946         if ( m_xConfigAccess.is() && m_xConfigAccess->hasByName( rResourceURL ) )
 947         {
 948
 949             Reference< XNameAccess > xNameAccess( m_xConfigAccess->getByName( rResourceURL ), UNO_QUERY );
 950             if ( xNameAccess.is() )
 951                 return impl_insertCacheAndReturnSequence( rResourceURL, xNameAccess );
 952         }
 953     }
 954     catch( const css::container::NoSuchElementException& )
 955     {
 956     }
 957     catch ( const css::lang::WrappedTargetException& )
 958     {
 959     }
 960
 961     return Any();
 962 }
 963
 964 void ConfigurationAccess_WindowState::impl_fillStructFromSequence( WindowStateInfo& rWinStateInfo, const Sequence< PropertyValue >& rSeq )
 965 {
 966     sal_Int32 nCompareCount( m_aPropArray.size() );
 967     sal_Int32 nCount( rSeq.getLength() );
 968     sal_Int32 i( 0 );
 969
 970     for ( i = 0; i < nCount; i++ )
 971     {
 972         for ( sal_Int32 j = 0; j < nCompareCount; j++ )
 973         {
 974             if ( rSeq[i].Name == m_aPropArray[j] )
 975             {
 976                 switch ( j )
 977                 {
 978                     case PROPERTY_LOCKED:
 979                     case PROPERTY_DOCKED:
 980                     case PROPERTY_VISIBLE:
 981                     case PROPERTY_CONTEXT:
 982                     case PROPERTY_HIDEFROMMENU:
 983                     case PROPERTY_NOCLOSE:
 984                     case PROPERTY_SOFTCLOSE:
 985                     case PROPERTY_CONTEXTACTIVE:
 986                     {
 987                         bool bValue;
 988                         if ( rSeq[i].Value >>= bValue )
 989                         {
 990                             sal_Int32 nValue( 1 << j );
 991                             rWinStateInfo.nMask |= nValue;
 992                             switch ( j )
 993                             {
 994                                 case PROPERTY_LOCKED:
 995                                     rWinStateInfo.bLocked = bValue;
 996                                     break;
 997                                 case PROPERTY_DOCKED:
 998                                     rWinStateInfo.bDocked = bValue;
 999                                     break;
1000                                 case PROPERTY_VISIBLE:
1001                                     rWinStateInfo.bVisible = bValue;
1002                                     break;
1003                                 case PROPERTY_CONTEXT:
1004                                     rWinStateInfo.bContext = bValue;
1005                                     break;
1006                                 case PROPERTY_HIDEFROMMENU:
1007                                     rWinStateInfo.bHideFromMenu = bValue;
1008                                     break;
1009                                 case PROPERTY_NOCLOSE:
1010                                     rWinStateInfo.bNoClose = bValue;
1011                                     break;
1012                                 case PROPERTY_SOFTCLOSE:
1013                                     rWinStateInfo.bSoftClose = bValue;
1014                                     break;
1015                                 case PROPERTY_CONTEXTACTIVE:
1016                                     rWinStateInfo.bContextActive = bValue;
1017                                     break;
1018                             }
1019                         }
1020                     }
1021                     break;
1022
1023                     case PROPERTY_DOCKINGAREA:
1024                     {
1025                         css::ui::DockingArea eDockingArea;
1026                         if ( rSeq[i].Value >>= eDockingArea )
1027                         {
1028                             rWinStateInfo.aDockingArea = eDockingArea;
1029                             rWinStateInfo.nMask |= WINDOWSTATE_MASK_DOCKINGAREA;
1030                         }
1031                     }
1032                     break;
1033
1034                     case PROPERTY_POS:
1035                     case PROPERTY_DOCKPOS:
1036                     {
1037                         css::awt::Point aPoint;
1038                         if ( rSeq[i].Value >>= aPoint )
1039                         {
1040                             if ( j == PROPERTY_POS )
1041                             {
1042                                 rWinStateInfo.aPos = aPoint;
1043                                 rWinStateInfo.nMask |= WINDOWSTATE_MASK_POS;
1044                             }
1045                             else
1046                             {
1047                                 rWinStateInfo.aDockPos = aPoint;
1048                                 rWinStateInfo.nMask |= WINDOWSTATE_MASK_DOCKPOS;
1049                             }
1050                         }
1051                     }
1052                     break;
1053
1054                     case PROPERTY_SIZE:
1055                     case PROPERTY_DOCKSIZE:
1056                     {
1057                         css::awt::Size aSize;
1058                         if ( rSeq[i].Value >>= aSize )
1059                         {
1060                             if ( j == PROPERTY_SIZE )
1061                             {
1062                                 rWinStateInfo.aSize = aSize;
1063                                 rWinStateInfo.nMask |= WINDOWSTATE_MASK_SIZE;
1064                             }
1065                             else
1066                             {
1067                                 rWinStateInfo.aDockSize = aSize;
1068                                 rWinStateInfo.nMask |= WINDOWSTATE_MASK_DOCKSIZE;
1069                             }
1070                         }
1071                     }
1072                     break;
1073
1074                     case PROPERTY_UINAME:
1075                     {
1076                         OUString aValue;
1077                         if ( rSeq[i].Value >>= aValue )
1078                         {
1079                             rWinStateInfo.aUIName = aValue;
1080                             rWinStateInfo.nMask |= WINDOWSTATE_MASK_UINAME;
1081                         }
1082                     }
1083                     break;
1084
1085                     case PROPERTY_INTERNALSTATE:
1086                     {
1087                         sal_Int32 nValue = 0;
1088                         if ( rSeq[i].Value >>= nValue )
1089                         {
1090                             rWinStateInfo.nInternalState = sal_uInt32( nValue );
1091                             rWinStateInfo.nMask |= WINDOWSTATE_MASK_INTERNALSTATE;
1092                         }
1093                     }
1094                     break;
1095
1096                     case PROPERTY_STYLE:
1097                     {
1098                         sal_Int32 nValue = 0;
1099                         if ( rSeq[i].Value >>= nValue )
1100                         {
1101                             rWinStateInfo.nStyle = sal_uInt16( nValue );
1102                             rWinStateInfo.nMask |= WINDOWSTATE_MASK_STYLE;
1103                         }
1104                     }
1105                     break;
1106
1107                     default:
1108                        assert( false && "Wrong value for ConfigurationAccess_WindowState. Who has forgotten to add this new property!" );
1109                 }
1110
1111                 break;
1112             }
1113         }
1114     }
1115 }
1116
1117 void ConfigurationAccess_WindowState::impl_putPropertiesFromStruct( const WindowStateInfo& rWinStateInfo, Reference< XPropertySet > const & xPropSet )
1118 {
1119     sal_Int32                 i( 0 );
1120     sal_Int32                 nCount( m_aPropArray.size() );
1121     OUString                  aDelim( u","_ustr );
1122
1123     for ( i = 0; i < nCount; i++ )
1124     {
1125         if ( rWinStateInfo.nMask & ( 1 << i ))
1126         {
1127             try
1128             {
1129                 // put values into the property set
1130                 switch ( i )
1131                 {
1132                     case PROPERTY_LOCKED:
1133                         xPropSet->setPropertyValue( m_aPropArray[i], Any( rWinStateInfo.bLocked ) ); break;
1134                     case PROPERTY_DOCKED:
1135                         xPropSet->setPropertyValue( m_aPropArray[i], Any( rWinStateInfo.bDocked ) ); break;
1136                     case PROPERTY_VISIBLE:
1137                         xPropSet->setPropertyValue( m_aPropArray[i], Any( rWinStateInfo.bVisible ) ); break;
1138                     case PROPERTY_CONTEXT:
1139                         xPropSet->setPropertyValue( m_aPropArray[i], Any( rWinStateInfo.bContext ) ); break;
1140                     case PROPERTY_HIDEFROMMENU:
1141                         xPropSet->setPropertyValue( m_aPropArray[i], Any( rWinStateInfo.bHideFromMenu ) ); break;
1142                     case PROPERTY_NOCLOSE:
1143                         xPropSet->setPropertyValue( m_aPropArray[i], Any( rWinStateInfo.bNoClose ) ); break;
1144                     case PROPERTY_SOFTCLOSE:
1145                         xPropSet->setPropertyValue( m_aPropArray[i], Any( rWinStateInfo.bSoftClose ) ); break;
1146                     case PROPERTY_CONTEXTACTIVE:
1147                         xPropSet->setPropertyValue( m_aPropArray[i], Any( rWinStateInfo.bContextActive ) ); break;
1148                     case PROPERTY_DOCKINGAREA:
1149                         xPropSet->setPropertyValue( m_aPropArray[i], Any( sal_Int16( rWinStateInfo.aDockingArea ) ) ); break;
1150                     case PROPERTY_POS:
1151                     case PROPERTY_DOCKPOS:
1152                     {
1153                         OUString aPosStr;
1154                         if ( i == PROPERTY_POS )
1155                             aPosStr = OUString::number( rWinStateInfo.aPos.X );
1156                         else
1157                             aPosStr = OUString::number( rWinStateInfo.aDockPos.X );
1158                         aPosStr += aDelim;
1159                         if ( i == PROPERTY_POS )
1160                             aPosStr += OUString::number( rWinStateInfo.aPos.Y );
1161                         else
1162                             aPosStr += OUString::number( rWinStateInfo.aDockPos.Y );
1163                         xPropSet->setPropertyValue( m_aPropArray[i], Any( aPosStr ) );
1164                         break;
1165                     }
1166                     case PROPERTY_SIZE:
1167                     case PROPERTY_DOCKSIZE:
1168                     {
1169                         OUString aSizeStr;
1170                         if ( i == PROPERTY_SIZE )
1171                             aSizeStr = OUString::number( rWinStateInfo.aSize.Width );
1172                         else
1173                             aSizeStr = OUString::number( rWinStateInfo.aDockSize.Width );
1174                         aSizeStr += aDelim;
1175                         if ( i == PROPERTY_SIZE )
1176                             aSizeStr += OUString::number( rWinStateInfo.aSize.Height );
1177                         else
1178                             aSizeStr += OUString::number( rWinStateInfo.aDockSize.Height );
1179                         xPropSet->setPropertyValue( m_aPropArray[i], Any( aSizeStr ) );
1180                         break;
1181                     }
1182                     case PROPERTY_UINAME:
1183                         xPropSet->setPropertyValue( m_aPropArray[i], Any( rWinStateInfo.aUIName ) ); break;
1184                     case PROPERTY_INTERNALSTATE:
1185                         xPropSet->setPropertyValue( m_aPropArray[i], Any( sal_Int32( rWinStateInfo.nInternalState )) ); break;
1186                     case PROPERTY_STYLE:
1187                         xPropSet->setPropertyValue( m_aPropArray[i], Any( sal_Int32( rWinStateInfo.nStyle )) ); break;
1188                     default:
1189                        assert( false && "Wrong value for ConfigurationAccess_WindowState. Who has forgotten to add this new property!" );
1190                 }
1191             }
1192             catch( const Exception& )
1193             {
1194             }
1195         }
1196     }
1197 }
1198
1199 void ConfigurationAccess_WindowState::impl_initializeConfigAccess()
1200 {
1201     try
1202     {
1203         Sequence<Any> aArgs(comphelper::InitAnyPropertySequence(
1204         {
1205             {"nodepath", Any(m_aConfigWindowAccess)}
1206         }));
1207         m_xConfigAccess.set( m_xConfigProvider->createInstanceWithArguments(
1208                     u"com.sun.star.configuration.ConfigurationUpdateAccess"_ustr, aArgs ), UNO_QUERY );
1209         if ( m_xConfigAccess.is() )
1210         {
1211             // Add as container listener
1212             Reference< XContainer > xContainer( m_xConfigAccess, UNO_QUERY );
1213             if ( xContainer.is() )
1214             {
1215                 m_xConfigListener = new WeakContainerListener(this);
1216                 xContainer->addContainerListener(m_xConfigListener);
1217             }
1218         }
1219     }
1220     catch ( const WrappedTargetException& )
1221     {
1222     }
1223     catch ( const Exception& )
1224     {
1225     }
1226 }
1227
1228 typedef comphelper::WeakComponentImplHelper< css::container::XNameAccess,
1229         css::lang::XServiceInfo> WindowStateConfiguration_BASE;
1230
1231 class WindowStateConfiguration : public WindowStateConfiguration_BASE
1232 {
1233 public:
1234     explicit WindowStateConfiguration( const css::uno::Reference< css::uno::XComponentContext >& rxContext );
1235     virtual ~WindowStateConfiguration() override;
1236
1237     virtual OUString SAL_CALL getImplementationName() override
1238     {
1239         return u"com.sun.star.comp.framework.WindowStateConfiguration"_ustr;
1240     }
1241
1242     virtual sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override
1243     {
1244         return cppu::supportsService(this, ServiceName);
1245     }
1246
1247     virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override
1248     {
1249         return {u"com.sun.star.ui.WindowStateConfiguration"_ustr};
1250     }
1251
1252     // XNameAccess
1253     virtual css::uno::Any SAL_CALL getByName( const OUString& aName ) override;
1254
1255     virtual css::uno::Sequence< OUString > SAL_CALL getElementNames() override;
1256
1257     virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override;
1258
1259     // XElementAccess
1260     virtual css::uno::Type SAL_CALL getElementType() override;
1261     virtual sal_Bool SAL_CALL hasElements() override;
1262
1263     typedef std::unordered_map< OUString,
1264                                 OUString > ModuleToWindowStateFileMap;
1265
1266     typedef std::unordered_map< OUString,
1267                                 css::uno::Reference< css::container::XNameAccess > > ModuleToWindowStateConfigHashMap;
1268
1269 private:
1270     css::uno::Reference< css::uno::XComponentContext>         m_xContext;
1271     ModuleToWindowStateFileMap                                m_aModuleToFileHashMap;
1272     ModuleToWindowStateConfigHashMap                          m_aModuleToWindowStateHashMap;
1273 };
1274
1275 WindowStateConfiguration::WindowStateConfiguration( const Reference< XComponentContext >& rxContext ) :
1276     m_xContext( rxContext )
1277 {
1278     css::uno::Reference< css::frame::XModuleManager2 > xModuleManager =
1279         ModuleManager::create( m_xContext );
1280     Reference< XNameAccess > xEmptyNameAccess;
1281     Sequence< OUString > aElementNames;
1282     try
1283     {
1284         aElementNames = xModuleManager->getElementNames();
1285     }
1286     catch (const css::uno::RuntimeException &)
1287     {
1288     }
1289     Sequence< PropertyValue > aSeq;
1290
1291     for (OUString const& aModuleIdentifier : aElementNames)
1292     {
1293         if ( xModuleManager->getByName( aModuleIdentifier ) >>= aSeq )
1294         {
1295             OUString aWindowStateFileStr;
1296             for (PropertyValue const& rProp : aSeq)
1297             {
1298                 if ( rProp.Name == "ooSetupFactoryWindowStateConfigRef" )
1299                 {
1300                     rProp.Value >>= aWindowStateFileStr;
1301                     break;
1302                 }
1303             }
1304
1305             if ( !aWindowStateFileStr.isEmpty() )
1306             {
1307                 // Create first mapping ModuleIdentifier ==> Window state configuration file
1308                 m_aModuleToFileHashMap.emplace( aModuleIdentifier, aWindowStateFileStr );
1309
1310                 // Create second mapping Command File ==> Window state configuration instance
1311                 ModuleToWindowStateConfigHashMap::iterator pIter = m_aModuleToWindowStateHashMap.find( aWindowStateFileStr );
1312                 if ( pIter == m_aModuleToWindowStateHashMap.end() )
1313                     m_aModuleToWindowStateHashMap.emplace( aWindowStateFileStr, xEmptyNameAccess );
1314             }
1315         }
1316     }
1317 }
1318
1319 WindowStateConfiguration::~WindowStateConfiguration()
1320 {
1321     std::unique_lock g(m_aMutex);
1322     m_aModuleToFileHashMap.clear();
1323     m_aModuleToWindowStateHashMap.clear();
1324 }
1325
1326 Any SAL_CALL WindowStateConfiguration::getByName( const OUString& aModuleIdentifier )
1327 {
1328     std::unique_lock g(m_aMutex);
1329
1330     ModuleToWindowStateFileMap::const_iterator pIter = m_aModuleToFileHashMap.find( aModuleIdentifier );
1331     if ( pIter != m_aModuleToFileHashMap.end() )
1332     {
1333         Any a;
1334         OUString aWindowStateConfigFile( pIter->second );
1335
1336         ModuleToWindowStateConfigHashMap::iterator pModuleIter = m_aModuleToWindowStateHashMap.find( aWindowStateConfigFile );
1337         if ( pModuleIter != m_aModuleToWindowStateHashMap.end() )
1338         {
1339             if ( pModuleIter->second.is() )
1340                 a <<= pModuleIter->second;
1341             else
1342             {
1343                 Reference< XNameAccess > xResourceURLWindowState = new ConfigurationAccess_WindowState( aWindowStateConfigFile, m_xContext );
1344                 pModuleIter->second = xResourceURLWindowState;
1345                 a <<= xResourceURLWindowState;
1346             }
1347
1348             return a;
1349         }
1350     }
1351
1352     throw NoSuchElementException();
1353 }
1354
1355 Sequence< OUString > SAL_CALL WindowStateConfiguration::getElementNames()
1356 {
1357     std::unique_lock g(m_aMutex);
1358
1359     return comphelper::mapKeysToSequence( m_aModuleToFileHashMap );
1360 }
1361
1362 sal_Bool SAL_CALL WindowStateConfiguration::hasByName( const OUString& aName )
1363 {
1364     std::unique_lock g(m_aMutex);
1365
1366     ModuleToWindowStateFileMap::const_iterator pIter = m_aModuleToFileHashMap.find( aName );
1367     return ( pIter != m_aModuleToFileHashMap.end() );
1368 }
1369
1370 // XElementAccess
1371 Type SAL_CALL WindowStateConfiguration::getElementType()
1372 {
1373     return cppu::UnoType<XNameAccess>::get();
1374 }
1375
1376 sal_Bool SAL_CALL WindowStateConfiguration::hasElements()
1377 {
1378     // We always have at least one module. So it is valid to return true!
1379     return true;
1380 }
1381
1382 }
1383
1384 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1385 com_sun_star_comp_framework_WindowStateConfiguration_get_implementation(
1386     css::uno::XComponentContext *context,
1387     css::uno::Sequence<css::uno::Any> const &)
1388 {
1389     return cppu::acquire(new WindowStateConfiguration(context));
1390 }
1391
1392 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */