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