1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_extensions.hxx"
26 #include "eformshelper.hxx"
27 #include "formstrings.hxx"
28 #ifndef _EXTENSIONS_FORMCTRLR_PROPRESID_HRC_
29 #include "formresid.hrc"
30 #endif
31 #ifndef _EXTENSIONS_PROPCTRLR_MODULEPRC_HXX_
32 #include "modulepcr.hxx"
33 #endif
34 #include "propeventtranslation.hxx"
35 #include "formbrowsertools.hxx"
36 
37 /** === begin UNO includes === **/
38 #include <com/sun/star/lang/XServiceInfo.hpp>
39 #include <com/sun/star/form/FormComponentType.hpp>
40 #include <com/sun/star/xforms/XFormsUIHelper1.hpp>
41 #include <com/sun/star/xsd/DataTypeClass.hpp>
42 #include <com/sun/star/form/binding/XListEntrySink.hpp>
43 /** === end UNO includes === **/
44 #include <tools/diagnose_ex.h>
45 #include <rtl/ustrbuf.hxx>
46 
47 #include <functional>
48 #include <algorithm>
49 
50 //........................................................................
51 namespace pcr
52 {
53 //........................................................................
54 
55     using namespace ::com::sun::star;
56     using namespace ::com::sun::star::uno;
57     using namespace ::com::sun::star::beans;
58     using namespace ::com::sun::star::container;
59     using namespace ::com::sun::star::form::binding;
60     using namespace ::com::sun::star::xsd;
61     using namespace ::com::sun::star::lang;
62     using namespace ::com::sun::star::form;
63 
64 	//====================================================================
65 	//= file-local helpers
66 	//====================================================================
67     namespace
68     {
69 	    //--------------------------------------------------------------------
composeModelElementUIName(const::rtl::OUString & _rModelName,const::rtl::OUString & _rElementName)70         ::rtl::OUString composeModelElementUIName( const ::rtl::OUString& _rModelName, const ::rtl::OUString& _rElementName )
71         {
72             ::rtl::OUStringBuffer aBuffer;
73             aBuffer.appendAscii( "[" );
74             aBuffer.append( _rModelName );
75             aBuffer.appendAscii( "] " );
76             aBuffer.append( _rElementName );
77             return aBuffer.makeStringAndClear();
78         }
79     }
80 
81 	//====================================================================
82 	//= EFormsHelper
83 	//====================================================================
84 	//--------------------------------------------------------------------
EFormsHelper(::osl::Mutex & _rMutex,const Reference<XPropertySet> & _rxControlModel,const Reference<frame::XModel> & _rxContextDocument)85     EFormsHelper::EFormsHelper( ::osl::Mutex& _rMutex, const Reference< XPropertySet >& _rxControlModel, const Reference< frame::XModel >& _rxContextDocument )
86         :m_xControlModel( _rxControlModel )
87         ,m_aPropertyListeners( _rMutex )
88     {
89         OSL_ENSURE( _rxControlModel.is(), "EFormsHelper::EFormsHelper: invalid control model!" );
90         m_xBindableControl = m_xBindableControl.query( _rxControlModel );
91 
92         m_xDocument = m_xDocument.query( _rxContextDocument );
93         OSL_ENSURE( m_xDocument.is(), "EFormsHelper::EFormsHelper: invalid document!" );
94 
95     }
96 
97 	//--------------------------------------------------------------------
isEForm(const Reference<frame::XModel> & _rxContextDocument)98     bool EFormsHelper::isEForm( const Reference< frame::XModel >& _rxContextDocument )
99     {
100         try
101         {
102             Reference< xforms::XFormsSupplier > xDocument( _rxContextDocument, UNO_QUERY );
103             if ( !xDocument.is() )
104                 return false;
105 
106             return xDocument->getXForms().is();
107         }
108         catch( const Exception& )
109         {
110         	OSL_ENSURE( sal_False, "EFormsHelper::isEForm: caught an exception!" );
111         }
112         return false;
113     }
114 
115 	//--------------------------------------------------------------------
canBindToDataType(sal_Int32 _nDataType) const116     bool EFormsHelper::canBindToDataType( sal_Int32 _nDataType ) const SAL_THROW(())
117     {
118         if ( !m_xBindableControl.is() )
119             // cannot bind at all
120             return false;
121 
122         // some types cannot be bound, independent from the control type
123         if (  ( DataTypeClass::hexBinary == _nDataType )
124            || ( DataTypeClass::base64Binary == _nDataType )
125            || ( DataTypeClass::QName == _nDataType )
126            || ( DataTypeClass::NOTATION == _nDataType )
127            )
128            return false;
129 
130         bool bCan = false;
131         try
132         {
133             // classify the control model
134             sal_Int16 nControlType = FormComponentType::CONTROL;
135             OSL_VERIFY( m_xControlModel->getPropertyValue( PROPERTY_CLASSID ) >>= nControlType );
136 
137             // some lists
138             sal_Int16 nNumericCompatibleTypes[] = { DataTypeClass::DECIMAL, DataTypeClass::FLOAT, DataTypeClass::DOUBLE, 0 };
139             sal_Int16 nDateCompatibleTypes[] = { DataTypeClass::DATE, 0 };
140             sal_Int16 nTimeCompatibleTypes[] = { DataTypeClass::TIME, 0 };
141             sal_Int16 nCheckboxCompatibleTypes[] = { DataTypeClass::BOOLEAN, DataTypeClass::STRING, DataTypeClass::anyURI, 0 };
142             sal_Int16 nRadiobuttonCompatibleTypes[] = { DataTypeClass::STRING, DataTypeClass::anyURI, 0 };
143             sal_Int16 nFormattedCompatibleTypes[] = { DataTypeClass::DECIMAL, DataTypeClass::FLOAT, DataTypeClass::DOUBLE, DataTypeClass::DATETIME, DataTypeClass::DATE, DataTypeClass::TIME, 0 };
144 
145             sal_Int16* pCompatibleTypes = NULL;
146             switch ( nControlType )
147             {
148             case FormComponentType::SPINBUTTON:
149             case FormComponentType::NUMERICFIELD:
150                 pCompatibleTypes = nNumericCompatibleTypes;
151                 break;
152             case FormComponentType::DATEFIELD:
153                 pCompatibleTypes = nDateCompatibleTypes;
154                 break;
155             case FormComponentType::TIMEFIELD:
156                 pCompatibleTypes = nTimeCompatibleTypes;
157                 break;
158             case FormComponentType::CHECKBOX:
159                 pCompatibleTypes = nCheckboxCompatibleTypes;
160                 break;
161             case FormComponentType::RADIOBUTTON:
162                 pCompatibleTypes = nRadiobuttonCompatibleTypes;
163                 break;
164 
165             case FormComponentType::TEXTFIELD:
166             {
167                 // both the normal text field, and the formatted field, claim to be a TEXTFIELD
168                 // need to distinguish by service name
169                 Reference< XServiceInfo > xSI( m_xControlModel, UNO_QUERY );
170                 OSL_ENSURE( xSI.is(), "EFormsHelper::canBindToDataType: a control model which has no service info?" );
171                 if ( xSI.is() )
172                 {
173                     if ( xSI->supportsService( SERVICE_COMPONENT_FORMATTEDFIELD ) )
174                     {
175                         pCompatibleTypes = nFormattedCompatibleTypes;
176                         break;
177                     }
178                 }
179                 // NO break here!
180             }
181             case FormComponentType::LISTBOX:
182             case FormComponentType::COMBOBOX:
183                 // edit fields and list/combo boxes can be bound to anything
184                 bCan = true;
185             }
186 
187             if ( !bCan && pCompatibleTypes )
188             {
189                 if ( _nDataType == -1 )
190                 {
191                     // the control can be bound to at least one type, and exactly this is being asked for
192                     bCan = true;
193                 }
194                 else
195                 {
196                     while ( *pCompatibleTypes && !bCan )
197                         bCan = ( *pCompatibleTypes++ == _nDataType );
198                 }
199             }
200         }
201         catch( const Exception& )
202         {
203         	OSL_ENSURE( sal_False, "EFormsHelper::canBindToDataType: caught an exception!" );
204         }
205 
206         return bCan;
207     }
208 
209 	//--------------------------------------------------------------------
isListEntrySink() const210     bool EFormsHelper::isListEntrySink() const SAL_THROW(())
211     {
212         bool bIs = false;
213         try
214         {
215             Reference< XListEntrySink > xAsSink( m_xControlModel, UNO_QUERY );
216             bIs = xAsSink.is();
217         }
218         catch( const Exception& )
219         {
220         	OSL_ENSURE( sal_False, "EFormsHelper::isListEntrySink: caught an exception!" );
221         }
222         return bIs;
223     }
224 
225 	//--------------------------------------------------------------------
impl_switchBindingListening_throw(bool _bDoListening,const Reference<XPropertyChangeListener> & _rxListener)226     void EFormsHelper::impl_switchBindingListening_throw( bool _bDoListening, const Reference< XPropertyChangeListener >& _rxListener )
227     {
228         Reference< XPropertySet > xBindingProps;
229         if ( m_xBindableControl.is() )
230             xBindingProps = xBindingProps.query( m_xBindableControl->getValueBinding() );
231         if ( !xBindingProps.is() )
232             return;
233 
234         if ( _bDoListening )
235         {
236             xBindingProps->addPropertyChangeListener( ::rtl::OUString(), _rxListener );
237         }
238         else
239         {
240             xBindingProps->removePropertyChangeListener( ::rtl::OUString(), _rxListener );
241         }
242     }
243 
244 	//--------------------------------------------------------------------
registerBindingListener(const Reference<XPropertyChangeListener> & _rxBindingListener)245     void EFormsHelper::registerBindingListener( const Reference< XPropertyChangeListener >& _rxBindingListener )
246     {
247         if ( !_rxBindingListener.is() )
248             return;
249         impl_toggleBindingPropertyListening_throw( true, _rxBindingListener );
250     }
251 
252 	//--------------------------------------------------------------------
impl_toggleBindingPropertyListening_throw(bool _bDoListen,const Reference<XPropertyChangeListener> & _rxConcreteListenerOrNull)253     void EFormsHelper::impl_toggleBindingPropertyListening_throw( bool _bDoListen, const Reference< XPropertyChangeListener >& _rxConcreteListenerOrNull )
254     {
255         if ( !_bDoListen )
256         {
257             ::std::auto_ptr< ::cppu::OInterfaceIteratorHelper > pListenerIterator = m_aPropertyListeners.createIterator();
258             while ( pListenerIterator->hasMoreElements() )
259             {
260                 PropertyEventTranslation* pTranslator = dynamic_cast< PropertyEventTranslation* >( pListenerIterator->next() );
261                 OSL_ENSURE( pTranslator, "EFormsHelper::impl_toggleBindingPropertyListening_throw: invalid listener element in my container!" );
262                 if ( !pTranslator )
263                     continue;
264 
265                 Reference< XPropertyChangeListener > xEventSourceTranslator( pTranslator );
266                 if ( _rxConcreteListenerOrNull.is() )
267                 {
268                     if ( pTranslator->getDelegator() == _rxConcreteListenerOrNull )
269                     {
270                         impl_switchBindingListening_throw( false, xEventSourceTranslator );
271                         m_aPropertyListeners.removeListener( xEventSourceTranslator );
272                         break;
273                     }
274                 }
275                 else
276                 {
277                     impl_switchBindingListening_throw( false, xEventSourceTranslator );
278                 }
279             }
280         }
281         else
282         {
283             if ( _rxConcreteListenerOrNull.is() )
284             {
285                 Reference< XPropertyChangeListener > xEventSourceTranslator( new PropertyEventTranslation( _rxConcreteListenerOrNull, m_xBindableControl ) );
286                 m_aPropertyListeners.addListener( xEventSourceTranslator );
287                 impl_switchBindingListening_throw( true, xEventSourceTranslator );
288             }
289             else
290             {
291                 ::std::auto_ptr< ::cppu::OInterfaceIteratorHelper > pListenerIterator = m_aPropertyListeners.createIterator();
292                 while ( pListenerIterator->hasMoreElements() )
293                 {
294                     Reference< XPropertyChangeListener > xListener( pListenerIterator->next(), UNO_QUERY );
295                     impl_switchBindingListening_throw( true, xListener );
296                 }
297             }
298         }
299     }
300 
301 	//--------------------------------------------------------------------
revokeBindingListener(const Reference<XPropertyChangeListener> & _rxBindingListener)302     void EFormsHelper::revokeBindingListener( const Reference< XPropertyChangeListener >& _rxBindingListener )
303     {
304         impl_toggleBindingPropertyListening_throw( false, _rxBindingListener );
305     }
306 
307 	//--------------------------------------------------------------------
getFormModelNames(::std::vector<::rtl::OUString> & _rModelNames) const308     void EFormsHelper::getFormModelNames( ::std::vector< ::rtl::OUString >& /* [out] */ _rModelNames ) const SAL_THROW(())
309     {
310         if ( m_xDocument.is() )
311         {
312             try
313             {
314                 _rModelNames.resize( 0 );
315 
316                 Reference< XNameContainer > xForms( m_xDocument->getXForms() );
317                 OSL_ENSURE( xForms.is(), "EFormsHelper::getFormModelNames: invalid forms container!" );
318                 if ( xForms.is() )
319                 {
320                     Sequence< ::rtl::OUString > aModelNames = xForms->getElementNames();
321                     _rModelNames.resize( aModelNames.getLength() );
322                     ::std::copy( aModelNames.getConstArray(), aModelNames.getConstArray() + aModelNames.getLength(),
323                         _rModelNames.begin()
324                     );
325                 }
326             }
327             catch( const Exception& )
328             {
329                 OSL_ENSURE( sal_False, "EFormsHelper::getFormModelNames: caught an exception!" );
330             }
331         }
332     }
333 
334     //--------------------------------------------------------------------
getBindingNames(const::rtl::OUString & _rModelName,::std::vector<::rtl::OUString> & _rBindingNames) const335     void EFormsHelper::getBindingNames( const ::rtl::OUString& _rModelName, ::std::vector< ::rtl::OUString >& /* [out] */ _rBindingNames ) const SAL_THROW(())
336     {
337         _rBindingNames.resize( 0 );
338         try
339         {
340             Reference< xforms::XModel > xModel( getFormModelByName( _rModelName ) );
341             if ( xModel.is() )
342             {
343                 Reference< XNameAccess > xBindings( xModel->getBindings(), UNO_QUERY );
344                 OSL_ENSURE( xBindings.is(), "EFormsHelper::getBindingNames: invalid bindings container obtained from the model!" );
345                 if ( xBindings.is() )
346                 {
347                     Sequence< ::rtl::OUString > aNames = xBindings->getElementNames();
348                     _rBindingNames.resize( aNames.getLength() );
349                     ::std::copy( aNames.getConstArray(), aNames.getConstArray() + aNames.getLength(), _rBindingNames.begin() );
350                 }
351             }
352         }
353         catch( const Exception& )
354         {
355         	OSL_ENSURE( sal_False, "EFormsHelper::getBindingNames: caught an exception!" );
356         }
357     }
358 
359 	//--------------------------------------------------------------------
getFormModelByName(const::rtl::OUString & _rModelName) const360     Reference< xforms::XModel > EFormsHelper::getFormModelByName( const ::rtl::OUString& _rModelName ) const SAL_THROW(())
361     {
362         Reference< xforms::XModel > xReturn;
363         try
364         {
365             Reference< XNameContainer > xForms( m_xDocument->getXForms() );
366             OSL_ENSURE( xForms.is(), "EFormsHelper::getFormModelByName: invalid forms container!" );
367             if ( xForms.is() )
368                 OSL_VERIFY( xForms->getByName( _rModelName ) >>= xReturn );
369         }
370         catch( const Exception& )
371         {
372         	OSL_ENSURE( sal_False, "EFormsHelper::getFormModelByName: caught an exception!" );
373         }
374         return xReturn;
375     }
376 
377 	//--------------------------------------------------------------------
getCurrentFormModel() const378     Reference< xforms::XModel > EFormsHelper::getCurrentFormModel() const SAL_THROW(())
379     {
380         Reference< xforms::XModel > xModel;
381         try
382         {
383             Reference< XPropertySet > xBinding( getCurrentBinding() );
384             if ( xBinding.is() )
385             {
386                 OSL_VERIFY( xBinding->getPropertyValue( PROPERTY_MODEL ) >>= xModel );
387             }
388         }
389         catch( const Exception& )
390         {
391         	OSL_ENSURE( sal_False, "EFormsHelper::getCurrentFormModel: caught an exception!" );
392         }
393         return xModel;
394     }
395 
396 	//--------------------------------------------------------------------
getCurrentFormModelName() const397     ::rtl::OUString EFormsHelper::getCurrentFormModelName() const SAL_THROW(())
398     {
399         ::rtl::OUString sModelName;
400         try
401         {
402             Reference< xforms::XModel > xFormsModel( getCurrentFormModel() );
403             if ( xFormsModel.is() )
404                 sModelName = xFormsModel->getID();
405         }
406         catch( const Exception& )
407         {
408         	OSL_ENSURE( sal_False, "EFormsHelper::getCurrentFormModel: caught an exception!" );
409         }
410         return sModelName;
411     }
412 
413     //--------------------------------------------------------------------
getCurrentBinding() const414     Reference< XPropertySet > EFormsHelper::getCurrentBinding() const SAL_THROW(())
415     {
416         Reference< XPropertySet > xBinding;
417 
418         try
419         {
420             if ( m_xBindableControl.is() )
421                 xBinding = xBinding.query( m_xBindableControl->getValueBinding() );
422         }
423         catch( const Exception& )
424         {
425         	OSL_ENSURE( sal_False, "EFormsHelper::getCurrentBinding: caught an exception!" );
426         }
427 
428         return xBinding;
429     }
430 
431     //--------------------------------------------------------------------
getCurrentBindingName() const432     ::rtl::OUString EFormsHelper::getCurrentBindingName() const SAL_THROW(())
433     {
434         ::rtl::OUString sBindingName;
435         try
436         {
437             Reference< XPropertySet > xBinding( getCurrentBinding() );
438             if ( xBinding.is() )
439                 xBinding->getPropertyValue( PROPERTY_BINDING_ID ) >>= sBindingName;
440         }
441         catch( const Exception& )
442         {
443             OSL_ENSURE( sal_False, "EFormsHelper::getCurrentBindingName: caught an exception!" );
444         }
445         return sBindingName;
446     }
447 
448     //--------------------------------------------------------------------
getCurrentListSourceBinding() const449     Reference< XListEntrySource > EFormsHelper::getCurrentListSourceBinding() const SAL_THROW(())
450     {
451         Reference< XListEntrySource > xReturn;
452         try
453         {
454             Reference< XListEntrySink > xAsSink( m_xControlModel, UNO_QUERY );
455             OSL_ENSURE( xAsSink.is(), "EFormsHelper::getCurrentListSourceBinding: you should have used isListEntrySink before!" );
456             if ( xAsSink.is() )
457                 xReturn = xAsSink->getListEntrySource();
458         }
459         catch( const Exception& )
460         {
461         	OSL_ENSURE( sal_False, "EFormsHelper::getCurrentListSourceBinding: caught an exception!" );
462         }
463         return xReturn;
464     }
465 
466     //--------------------------------------------------------------------
setListSourceBinding(const Reference<XListEntrySource> & _rxListSource)467     void EFormsHelper::setListSourceBinding( const Reference< XListEntrySource >& _rxListSource ) SAL_THROW(())
468     {
469         try
470         {
471             Reference< XListEntrySink > xAsSink( m_xControlModel, UNO_QUERY );
472             OSL_ENSURE( xAsSink.is(), "EFormsHelper::setListSourceBinding: you should have used isListEntrySink before!" );
473             if ( xAsSink.is() )
474                 xAsSink->setListEntrySource( _rxListSource );
475         }
476         catch( const Exception& )
477         {
478         	OSL_ENSURE( sal_False, "EFormsHelper::setListSourceBinding: caught an exception!" );
479         }
480     }
481 
482     //--------------------------------------------------------------------
setBinding(const Reference<::com::sun::star::beans::XPropertySet> & _rxBinding)483     void EFormsHelper::setBinding( const Reference< ::com::sun::star::beans::XPropertySet >& _rxBinding ) SAL_THROW(())
484     {
485         if ( !m_xBindableControl.is() )
486             return;
487 
488         try
489         {
490             Reference< XPropertySet > xOldBinding( m_xBindableControl->getValueBinding(), UNO_QUERY );
491 
492             Reference< XValueBinding > xBinding( _rxBinding, UNO_QUERY );
493             OSL_ENSURE( xBinding.is() || !_rxBinding.is(), "EFormsHelper::setBinding: invalid binding!" );
494 
495             impl_toggleBindingPropertyListening_throw( false, NULL );
496             m_xBindableControl->setValueBinding( xBinding );
497             impl_toggleBindingPropertyListening_throw( true, NULL );
498 
499             ::std::set< ::rtl::OUString > aSet;
500             firePropertyChanges( xOldBinding, _rxBinding, aSet );
501         }
502         catch( const Exception& )
503         {
504         	OSL_ENSURE( sal_False, "EFormsHelper::setBinding: caught an exception!" );
505         }
506     }
507 
508     //--------------------------------------------------------------------
getOrCreateBindingForModel(const::rtl::OUString & _rTargetModel,const::rtl::OUString & _rBindingName) const509     Reference< XPropertySet > EFormsHelper::getOrCreateBindingForModel( const ::rtl::OUString& _rTargetModel, const ::rtl::OUString& _rBindingName ) const SAL_THROW(())
510     {
511         OSL_ENSURE( _rBindingName.getLength(), "EFormsHelper::getOrCreateBindingForModel: invalid binding name!" );
512         return implGetOrCreateBinding( _rTargetModel, _rBindingName );
513     }
514 
515     //--------------------------------------------------------------------
implGetOrCreateBinding(const::rtl::OUString & _rTargetModel,const::rtl::OUString & _rBindingName) const516     Reference< XPropertySet > EFormsHelper::implGetOrCreateBinding( const ::rtl::OUString& _rTargetModel, const ::rtl::OUString& _rBindingName ) const SAL_THROW(())
517     {
518         OSL_ENSURE( !( !_rTargetModel.getLength() && _rBindingName .getLength() ), "EFormsHelper::implGetOrCreateBinding: no model, but a binding name?" );
519 
520         Reference< XPropertySet > xBinding;
521         try
522         {
523             ::rtl::OUString sTargetModel( _rTargetModel );
524             // determine the model which the binding should belong to
525             if ( !sTargetModel.getLength() )
526             {
527                 ::std::vector< ::rtl::OUString > aModelNames;
528                 getFormModelNames( aModelNames );
529                 if ( !aModelNames.empty() )
530                     sTargetModel = *aModelNames.begin();
531                 OSL_ENSURE( sTargetModel.getLength(), "EFormsHelper::implGetOrCreateBinding: unable to obtain a default model!" );
532             }
533             Reference< xforms::XModel > xModel( getFormModelByName( sTargetModel ) );
534             Reference< XNameAccess > xBindingNames( xModel.is() ? xModel->getBindings() : Reference< XSet >(), UNO_QUERY );
535             if ( xBindingNames.is() )
536             {
537                 // get or create the binding instance
538                 if ( _rBindingName.getLength() )
539                 {
540                     if ( xBindingNames->hasByName( _rBindingName ) )
541                         OSL_VERIFY( xBindingNames->getByName( _rBindingName ) >>= xBinding );
542                     else
543                     {
544                         xBinding = xModel->createBinding( );
545                         if ( xBinding.is() )
546                         {
547                             xBinding->setPropertyValue( PROPERTY_BINDING_ID, makeAny( _rBindingName ) );
548                             xModel->getBindings()->insert( makeAny( xBinding ) );
549                         }
550                     }
551                 }
552                 else
553                 {
554                     xBinding = xModel->createBinding( );
555                     if ( xBinding.is() )
556                     {
557                         // find a nice name for it
558                         String sBaseName( PcrRes( RID_STR_BINDING_UI_NAME ) );
559                         sBaseName += String::CreateFromAscii( " " );
560 			            String sNewName;
561                         sal_Int32 nNumber = 1;
562                         do
563                         {
564                             sNewName = sBaseName + ::rtl::OUString::valueOf( nNumber++ );
565                         }
566                         while ( xBindingNames->hasByName( sNewName ) );
567                         Reference< XNamed > xName( xBinding, UNO_QUERY_THROW );
568                         xName->setName( sNewName );
569                         // and insert into the model
570                         xModel->getBindings()->insert( makeAny( xBinding ) );
571                     }
572                 }
573             }
574         }
575         catch( const Exception& )
576         {
577             DBG_UNHANDLED_EXCEPTION();
578         }
579 
580         return xBinding;
581     }
582 
583     //--------------------------------------------------------------------
584     namespace
585     {
586         //................................................................
587         struct PropertyBagInserter : public ::std::unary_function< Property, void >
588         {
589         private:
590             PropertyBag& m_rProperties;
591 
592         public:
PropertyBagInserterpcr::__anon0f4e8eb90211::PropertyBagInserter593             PropertyBagInserter( PropertyBag& rProperties ) : m_rProperties( rProperties ) { }
594 
operator ()pcr::__anon0f4e8eb90211::PropertyBagInserter595             void operator()( const Property& _rProp )
596             {
597                 m_rProperties.insert( _rProp );
598             }
599         };
600 
601         //................................................................
collectPropertiesGetInfo(const Reference<XPropertySet> & _rxProps,PropertyBag & _rBag)602         Reference< XPropertySetInfo > collectPropertiesGetInfo( const Reference< XPropertySet >& _rxProps, PropertyBag& _rBag )
603         {
604             Reference< XPropertySetInfo > xInfo;
605             if ( _rxProps.is() )
606                 xInfo = _rxProps->getPropertySetInfo();
607             if ( xInfo.is() )
608             {
609                 Sequence< Property > aProperties = xInfo->getProperties();
610                 ::std::for_each( aProperties.getConstArray(), aProperties.getConstArray() + aProperties.getLength(),
611                     PropertyBagInserter( _rBag )
612                 );
613             }
614             return xInfo;
615         }
616     }
617 
618 	//--------------------------------------------------------------------
getModelElementUIName(const EFormsHelper::ModelElementType _eType,const Reference<XPropertySet> & _rxElement) const619     ::rtl::OUString EFormsHelper::getModelElementUIName( const EFormsHelper::ModelElementType _eType, const Reference< XPropertySet >& _rxElement ) const SAL_THROW(())
620     {
621         ::rtl::OUString sUIName;
622         try
623         {
624             // determine the model which the element belongs to
625             Reference< xforms::XFormsUIHelper1 > xHelper;
626             if ( _rxElement.is() )
627                 _rxElement->getPropertyValue( PROPERTY_MODEL ) >>= xHelper;
628             OSL_ENSURE( xHelper.is(), "EFormsHelper::getModelElementUIName: invalid element or model!" );
629             if ( xHelper.is() )
630             {
631                 ::rtl::OUString sElementName = ( _eType == Submission ) ? xHelper->getSubmissionName( _rxElement, sal_True ) : xHelper->getBindingName( _rxElement, sal_True );
632                 Reference< xforms::XModel > xModel( xHelper, UNO_QUERY_THROW );
633                 sUIName = composeModelElementUIName( xModel->getID(), sElementName );
634             }
635         }
636         catch( const Exception& )
637         {
638         	OSL_ENSURE( sal_False, "EFormsHelper::getModelElementUIName: caught an exception!" );
639         }
640 
641         return sUIName;
642     }
643 
644 	//--------------------------------------------------------------------
getModelElementFromUIName(const EFormsHelper::ModelElementType _eType,const::rtl::OUString & _rUIName) const645     Reference< XPropertySet > EFormsHelper::getModelElementFromUIName( const EFormsHelper::ModelElementType _eType, const ::rtl::OUString& _rUIName ) const SAL_THROW(())
646     {
647         const MapStringToPropertySet& rMapUINameToElement( ( _eType == Submission ) ? m_aSubmissionUINames : m_aBindingUINames );
648         MapStringToPropertySet::const_iterator pos = rMapUINameToElement.find( _rUIName );
649         OSL_ENSURE( pos != rMapUINameToElement.end(), "EFormsHelper::getModelElementFromUIName: didn't find it!" );
650 
651         return ( pos != rMapUINameToElement.end() ) ? pos->second : Reference< XPropertySet >();
652     }
653 
654 	//--------------------------------------------------------------------
getAllElementUINames(const ModelElementType _eType,::std::vector<::rtl::OUString> & _rElementNames,bool _bPrepentEmptyEntry)655     void EFormsHelper::getAllElementUINames( const ModelElementType _eType, ::std::vector< ::rtl::OUString >& /* [out] */ _rElementNames, bool _bPrepentEmptyEntry )
656     {
657         MapStringToPropertySet& rMapUINameToElement( ( _eType == Submission ) ? m_aSubmissionUINames : m_aBindingUINames );
658         rMapUINameToElement.clear();
659         _rElementNames.resize( 0 );
660 
661         if ( _bPrepentEmptyEntry )
662             rMapUINameToElement[ ::rtl::OUString() ] = Reference< XPropertySet >();
663 
664         try
665         {
666             // obtain the model names
667             ::std::vector< ::rtl::OUString > aModels;
668             getFormModelNames( aModels );
669             _rElementNames.reserve( aModels.size() * 2 );    // heuristics
670 
671             // for every model, obtain the element
672             for ( ::std::vector< ::rtl::OUString >::const_iterator pModelName = aModels.begin();
673                   pModelName != aModels.end();
674                   ++pModelName
675                 )
676             {
677                 Reference< xforms::XModel > xModel = getFormModelByName( *pModelName );
678                 OSL_ENSURE( xModel.is(), "EFormsHelper::getAllElementUINames: inconsistency in the models!" );
679                 Reference< xforms::XFormsUIHelper1 > xHelper( xModel, UNO_QUERY );
680 
681                 Reference< XIndexAccess > xElements;
682                 if ( xModel.is() )
683                     xElements = xElements.query( ( _eType == Submission ) ? xModel->getSubmissions() : xModel->getBindings() );
684                 if ( !xElements.is() )
685                     break;
686 
687                 sal_Int32 nElementCount = xElements->getCount();
688                 for ( sal_Int32 i = 0; i < nElementCount; ++i )
689                 {
690                     Reference< XPropertySet > xElement( xElements->getByIndex( i ), UNO_QUERY );
691                     OSL_ENSURE( xElement.is(), "EFormsHelper::getAllElementUINames: empty element!" );
692                     if ( !xElement.is() )
693                         continue;
694 #if OSL_DEBUG_LEVEL > 0
695                     {
696                         Reference< xforms::XModel > xElementsModel;
697                         xElement->getPropertyValue( PROPERTY_MODEL ) >>= xElementsModel;
698                         OSL_ENSURE( xElementsModel == xModel, "EFormsHelper::getAllElementUINames: inconsistency in the model-element relationship!" );
699                         if ( !( xElementsModel == xModel ) )
700                             xElement->setPropertyValue( PROPERTY_MODEL, makeAny( xModel ) );
701                     }
702 #endif
703                     ::rtl::OUString sElementName = ( _eType == Submission ) ? xHelper->getSubmissionName( xElement, sal_True ) : xHelper->getBindingName( xElement, sal_True );
704                     ::rtl::OUString sUIName = composeModelElementUIName( *pModelName, sElementName );
705 
706                     OSL_ENSURE( rMapUINameToElement.find( sUIName ) == rMapUINameToElement.end(), "EFormsHelper::getAllElementUINames: duplicate name!" );
707                     rMapUINameToElement.insert( MapStringToPropertySet::value_type( sUIName, xElement ) );
708                 }
709             }
710         }
711         catch( const Exception& )
712         {
713         	OSL_ENSURE( sal_False, "EFormsHelper::getAllElementUINames: caught an exception!" );
714         }
715 
716         _rElementNames.resize( rMapUINameToElement.size() );
717         ::std::transform( rMapUINameToElement.begin(), rMapUINameToElement.end(), _rElementNames.begin(), ::std::select1st< MapStringToPropertySet::value_type >() );
718     }
719 
720     //--------------------------------------------------------------------
firePropertyChange(const::rtl::OUString & _rName,const Any & _rOldValue,const Any & _rNewValue) const721     void EFormsHelper::firePropertyChange( const ::rtl::OUString& _rName, const Any& _rOldValue, const Any& _rNewValue ) const
722     {
723         if ( m_aPropertyListeners.empty() )
724             return;
725 
726         if ( _rOldValue == _rNewValue )
727             return;
728 
729         try
730         {
731             PropertyChangeEvent aEvent;
732 
733             aEvent.Source = m_xBindableControl.get();
734             aEvent.PropertyName = _rName;
735             aEvent.OldValue = _rOldValue;
736             aEvent.NewValue = _rNewValue;
737 
738             const_cast< EFormsHelper* >( this )->m_aPropertyListeners.notify( aEvent, &XPropertyChangeListener::propertyChange );
739         }
740         catch( const Exception& )
741         {
742             OSL_ENSURE( sal_False, "EFormsHelper::firePropertyChange: caught an exception!" );
743         }
744     }
745 
746     //--------------------------------------------------------------------
firePropertyChanges(const Reference<XPropertySet> & _rxOldProps,const Reference<XPropertySet> & _rxNewProps,::std::set<::rtl::OUString> & _rFilter) const747     void EFormsHelper::firePropertyChanges( const Reference< XPropertySet >& _rxOldProps, const Reference< XPropertySet >& _rxNewProps, ::std::set< ::rtl::OUString >& _rFilter ) const
748     {
749         if ( m_aPropertyListeners.empty() )
750             return;
751 
752         try
753         {
754             PropertyBag aProperties;
755             Reference< XPropertySetInfo > xOldInfo = collectPropertiesGetInfo( _rxOldProps, aProperties );
756             Reference< XPropertySetInfo > xNewInfo = collectPropertiesGetInfo( _rxNewProps, aProperties );
757 
758             for ( PropertyBag::const_iterator aProp = aProperties.begin();
759                   aProp != aProperties.end();
760                   ++aProp
761                 )
762             {
763                 if ( _rFilter.find( aProp->Name ) != _rFilter.end() )
764                     continue;
765 
766                 Any aOldValue( NULL, aProp->Type );
767                 if ( xOldInfo.is() && xOldInfo->hasPropertyByName( aProp->Name ) )
768                     aOldValue = _rxOldProps->getPropertyValue( aProp->Name );
769 
770                 Any aNewValue( NULL, aProp->Type );
771                 if ( xNewInfo.is() && xNewInfo->hasPropertyByName( aProp->Name ) )
772                     aNewValue = _rxNewProps->getPropertyValue( aProp->Name );
773 
774                 firePropertyChange( aProp->Name, aOldValue, aNewValue );
775             }
776         }
777         catch( const Exception& )
778         {
779         	OSL_ENSURE( sal_False, "EFormsHelper::firePropertyChanges: caught an exception!" );
780         }
781     }
782 
783 //........................................................................
784 } // namespace pcr
785 //........................................................................
786 
787