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