1*2a97ec55SAndrew Rist /**************************************************************
2cdf0e10cSrcweir  *
3*2a97ec55SAndrew Rist  * Licensed to the Apache Software Foundation (ASF) under one
4*2a97ec55SAndrew Rist  * or more contributor license agreements.  See the NOTICE file
5*2a97ec55SAndrew Rist  * distributed with this work for additional information
6*2a97ec55SAndrew Rist  * regarding copyright ownership.  The ASF licenses this file
7*2a97ec55SAndrew Rist  * to you under the Apache License, Version 2.0 (the
8*2a97ec55SAndrew Rist  * "License"); you may not use this file except in compliance
9*2a97ec55SAndrew Rist  * with the License.  You may obtain a copy of the License at
10*2a97ec55SAndrew Rist  *
11*2a97ec55SAndrew Rist  *   http://www.apache.org/licenses/LICENSE-2.0
12*2a97ec55SAndrew Rist  *
13*2a97ec55SAndrew Rist  * Unless required by applicable law or agreed to in writing,
14*2a97ec55SAndrew Rist  * software distributed under the License is distributed on an
15*2a97ec55SAndrew Rist  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*2a97ec55SAndrew Rist  * KIND, either express or implied.  See the License for the
17*2a97ec55SAndrew Rist  * specific language governing permissions and limitations
18*2a97ec55SAndrew Rist  * under the License.
19*2a97ec55SAndrew Rist  *
20*2a97ec55SAndrew Rist  *************************************************************/
21*2a97ec55SAndrew Rist 
22*2a97ec55SAndrew Rist 
23cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
24cdf0e10cSrcweir #include "precompiled_extensions.hxx"
25cdf0e10cSrcweir 
26cdf0e10cSrcweir #include "sal/config.h"
27cdf0e10cSrcweir #include "cppuhelper/factory.hxx"
28cdf0e10cSrcweir #include "cppuhelper/implementationentry.hxx"
29cdf0e10cSrcweir #include "cppuhelper/implbase3.hxx"
30cdf0e10cSrcweir #include "com/sun/star/lang/XServiceInfo.hpp"
31cdf0e10cSrcweir #include "com/sun/star/inspection/XStringRepresentation.hpp"
32cdf0e10cSrcweir #include "com/sun/star/lang/XInitialization.hpp"
33cdf0e10cSrcweir #include "com/sun/star/script/XTypeConverter.hpp"
34cdf0e10cSrcweir #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
35cdf0e10cSrcweir #include <com/sun/star/reflection/XConstantsTypeDescription.hpp>
36cdf0e10cSrcweir #include <com/sun/star/beans/XIntrospection.hpp>
37cdf0e10cSrcweir #include <com/sun/star/util/DateTime.hpp>
38cdf0e10cSrcweir #include <com/sun/star/util/Date.hpp>
39cdf0e10cSrcweir #include <com/sun/star/util/Time.hpp>
40cdf0e10cSrcweir #include <comphelper/sequence.hxx>
41cdf0e10cSrcweir #include <connectivity/dbconversion.hxx>
42cdf0e10cSrcweir #ifndef _EXTENSIONS_PROPCTRLR_MODULEPRC_HXX_
43cdf0e10cSrcweir #include "modulepcr.hxx"
44cdf0e10cSrcweir #endif
45cdf0e10cSrcweir #ifndef _EXTENSIONS_FORMCTRLR_PROPRESID_HRC_
46cdf0e10cSrcweir #include "formresid.hrc"
47cdf0e10cSrcweir #endif
48cdf0e10cSrcweir #include <tools/debug.hxx>
49cdf0e10cSrcweir #include <tools/string.hxx>
50cdf0e10cSrcweir #include <tools/StringListResource.hxx>
51cdf0e10cSrcweir #include <comphelper/types.hxx>
52cdf0e10cSrcweir #ifndef _EXTENSIONS_PROPCTRLR_MODULEPCR_HXX_
53cdf0e10cSrcweir #include "modulepcr.hxx"
54cdf0e10cSrcweir #endif
55cdf0e10cSrcweir 
56cdf0e10cSrcweir #include <functional>
57cdf0e10cSrcweir #include <algorithm>
58cdf0e10cSrcweir 
59cdf0e10cSrcweir // component helper namespace
60cdf0e10cSrcweir namespace comp_StringRepresentation {
61cdf0e10cSrcweir 
62cdf0e10cSrcweir using namespace ::com::sun::star;
63cdf0e10cSrcweir 
64cdf0e10cSrcweir // component and service helper functions:
65cdf0e10cSrcweir ::rtl::OUString SAL_CALL _getImplementationName();
66cdf0e10cSrcweir uno::Sequence< ::rtl::OUString > SAL_CALL _getSupportedServiceNames();
67cdf0e10cSrcweir uno::Reference< uno::XInterface > SAL_CALL _create( uno::Reference< uno::XComponentContext > const & context );
68cdf0e10cSrcweir 
69cdf0e10cSrcweir } // closing component helper namespace
70cdf0e10cSrcweir 
71cdf0e10cSrcweir 
72cdf0e10cSrcweir namespace pcr{
73cdf0e10cSrcweir 
74cdf0e10cSrcweir using namespace ::com::sun::star;
75cdf0e10cSrcweir using namespace ::com::sun::star::uno;
76cdf0e10cSrcweir 
77cdf0e10cSrcweir class StringRepresentation:
78cdf0e10cSrcweir     public ::cppu::WeakImplHelper3<
79cdf0e10cSrcweir         lang::XServiceInfo,
80cdf0e10cSrcweir         inspection::XStringRepresentation,
81cdf0e10cSrcweir         lang::XInitialization>
82cdf0e10cSrcweir {
83cdf0e10cSrcweir public:
84cdf0e10cSrcweir     explicit StringRepresentation(uno::Reference< uno::XComponentContext > const & context);
85cdf0e10cSrcweir 
86cdf0e10cSrcweir     // lang::XServiceInfo:
87cdf0e10cSrcweir     virtual ::rtl::OUString SAL_CALL getImplementationName() throw (uno::RuntimeException);
88cdf0e10cSrcweir     virtual ::sal_Bool SAL_CALL supportsService(const ::rtl::OUString & ServiceName) throw (uno::RuntimeException);
89cdf0e10cSrcweir     virtual uno::Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames() throw (uno::RuntimeException);
90cdf0e10cSrcweir 
91cdf0e10cSrcweir     // inspection::XStringRepresentation:
92cdf0e10cSrcweir     virtual ::rtl::OUString SAL_CALL convertToControlValue(const uno::Any & PropertyValue) throw (uno::RuntimeException, uno::Exception);
93cdf0e10cSrcweir     virtual uno::Any SAL_CALL convertToPropertyValue(const ::rtl::OUString & ControlValue, const uno::Type & ControlValueType) throw (uno::RuntimeException, uno::Exception);
94cdf0e10cSrcweir 
95cdf0e10cSrcweir     // lang::XInitialization:
96cdf0e10cSrcweir     virtual void SAL_CALL initialize(const uno::Sequence< uno::Any > & aArguments) throw (uno::RuntimeException, uno::Exception);
97cdf0e10cSrcweir 
98cdf0e10cSrcweir private:
99cdf0e10cSrcweir     StringRepresentation(StringRepresentation &); // not defined
100cdf0e10cSrcweir     void operator =(StringRepresentation &); // not defined
101cdf0e10cSrcweir 
~StringRepresentation()102cdf0e10cSrcweir     virtual ~StringRepresentation() {}
103cdf0e10cSrcweir 
104cdf0e10cSrcweir     /** converts a generic value into a string representation
105cdf0e10cSrcweir 
106cdf0e10cSrcweir         If you want to convert values whose string representation does not depend
107cdf0e10cSrcweir         on a concrete property, use this version
108cdf0e10cSrcweir 
109cdf0e10cSrcweir         @return <TRUE/>
110cdf0e10cSrcweir             if and only if the value could be converted
111cdf0e10cSrcweir     */
112cdf0e10cSrcweir     bool            convertGenericValueToString(
113cdf0e10cSrcweir                         const uno::Any&   _rValue,
114cdf0e10cSrcweir                                 ::rtl::OUString&              _rStringRep
115cdf0e10cSrcweir                     );
116cdf0e10cSrcweir 
117cdf0e10cSrcweir     /** converts string representation into generic value
118cdf0e10cSrcweir 
119cdf0e10cSrcweir         If you want to convert values whose string representation does not depend
120cdf0e10cSrcweir         on a concrete property, use this version
121cdf0e10cSrcweir 
122cdf0e10cSrcweir         @return <TRUE/>
123cdf0e10cSrcweir             if and only if the value could be converted
124cdf0e10cSrcweir     */
125cdf0e10cSrcweir     bool            convertStringToGenericValue(
126cdf0e10cSrcweir                         const ::rtl::OUString&              _rStringRep,
127cdf0e10cSrcweir                                 uno::Any&   _rValue,
128cdf0e10cSrcweir                         const uno::Type& _rTargetType
129cdf0e10cSrcweir                     );
130cdf0e10cSrcweir 
131cdf0e10cSrcweir     /** uses the simple convert method from the type converter
132cdf0e10cSrcweir     *
133cdf0e10cSrcweir     * \param _rValue the value to be converted
134cdf0e10cSrcweir     * \return the converted string.
135cdf0e10cSrcweir     */
136cdf0e10cSrcweir     ::rtl::OUString convertSimpleToString( const uno::Any& _rValue );
137cdf0e10cSrcweir 
138cdf0e10cSrcweir     /** converts a string into his constant value if it exists, otherwise the type converter is used.
139cdf0e10cSrcweir     * \param _rValue the value to be converted
140cdf0e10cSrcweir     * \param _ePropertyType teh type of the propery to be converted into
141cdf0e10cSrcweir     * \return the converted value
142cdf0e10cSrcweir     */
143cdf0e10cSrcweir     uno::Any convertStringToSimple( const ::rtl::OUString& _rValue,const uno::TypeClass& _ePropertyType );
144cdf0e10cSrcweir 
145cdf0e10cSrcweir     uno::Reference< uno::XComponentContext >                                m_xContext;
146cdf0e10cSrcweir     uno::Reference< script::XTypeConverter >                                m_xTypeConverter;
147cdf0e10cSrcweir     uno::Reference< reflection::XConstantsTypeDescription >                 m_xTypeDescription;
148cdf0e10cSrcweir     uno::Sequence< ::rtl::OUString >                                        m_aValues;
149cdf0e10cSrcweir     uno::Sequence< uno::Reference< reflection::XConstantTypeDescription> >  m_aConstants;
150cdf0e10cSrcweir 
151cdf0e10cSrcweir };
152cdf0e10cSrcweir 
StringRepresentation(uno::Reference<uno::XComponentContext> const & context)153cdf0e10cSrcweir StringRepresentation::StringRepresentation(uno::Reference< uno::XComponentContext > const & context) :
154cdf0e10cSrcweir     m_xContext(context)
155cdf0e10cSrcweir {}
156cdf0e10cSrcweir 
157cdf0e10cSrcweir // com.sun.star.uno.XServiceInfo:
getImplementationName()158cdf0e10cSrcweir ::rtl::OUString  SAL_CALL StringRepresentation::getImplementationName() throw (uno::RuntimeException)
159cdf0e10cSrcweir {
160cdf0e10cSrcweir     return comp_StringRepresentation::_getImplementationName();
161cdf0e10cSrcweir }
162cdf0e10cSrcweir 
supportsService(::rtl::OUString const & serviceName)163cdf0e10cSrcweir ::sal_Bool SAL_CALL StringRepresentation::supportsService(::rtl::OUString const & serviceName) throw (uno::RuntimeException)
164cdf0e10cSrcweir {
165cdf0e10cSrcweir     return ::comphelper::existsValue(serviceName,comp_StringRepresentation::_getSupportedServiceNames());
166cdf0e10cSrcweir }
167cdf0e10cSrcweir 
getSupportedServiceNames()168cdf0e10cSrcweir uno::Sequence< ::rtl::OUString >  SAL_CALL StringRepresentation::getSupportedServiceNames() throw (uno::RuntimeException)
169cdf0e10cSrcweir {
170cdf0e10cSrcweir     return comp_StringRepresentation::_getSupportedServiceNames();
171cdf0e10cSrcweir }
172cdf0e10cSrcweir 
173cdf0e10cSrcweir // inspection::XStringRepresentation:
convertToControlValue(const uno::Any & PropertyValue)174cdf0e10cSrcweir ::rtl::OUString SAL_CALL StringRepresentation::convertToControlValue(const uno::Any & PropertyValue) throw (uno::RuntimeException, uno::Exception)
175cdf0e10cSrcweir {
176cdf0e10cSrcweir     ::rtl::OUString sReturn;
177cdf0e10cSrcweir     if ( !convertGenericValueToString( PropertyValue, sReturn ) )
178cdf0e10cSrcweir     {
179cdf0e10cSrcweir         sReturn = convertSimpleToString( PropertyValue );
180cdf0e10cSrcweir #ifdef DBG_UTIL
181cdf0e10cSrcweir         if ( !sReturn.getLength() && PropertyValue.hasValue() )
182cdf0e10cSrcweir         {
183cdf0e10cSrcweir             ::rtl::OString sMessage( "StringRepresentation::convertPropertyValueToStringRepresentation: cannot convert values of type '" );
184cdf0e10cSrcweir             sMessage += ::rtl::OString( PropertyValue.getValueType().getTypeName().getStr(), PropertyValue.getValueType().getTypeName().getLength(), RTL_TEXTENCODING_ASCII_US );
185cdf0e10cSrcweir             sMessage += ::rtl::OString( "'!" );
186cdf0e10cSrcweir             DBG_ERROR( sMessage.getStr() );
187cdf0e10cSrcweir         }
188cdf0e10cSrcweir #endif
189cdf0e10cSrcweir     }
190cdf0e10cSrcweir 
191cdf0e10cSrcweir     return sReturn;
192cdf0e10cSrcweir }
193cdf0e10cSrcweir 
convertToPropertyValue(const::rtl::OUString & ControlValue,const uno::Type & ControlValueType)194cdf0e10cSrcweir uno::Any SAL_CALL StringRepresentation::convertToPropertyValue(const ::rtl::OUString & ControlValue, const uno::Type & ControlValueType) throw (uno::RuntimeException, uno::Exception)
195cdf0e10cSrcweir {
196cdf0e10cSrcweir     uno::Any aReturn;
197cdf0e10cSrcweir 
198cdf0e10cSrcweir     uno::TypeClass ePropertyType = ControlValueType.getTypeClass();
199cdf0e10cSrcweir 	switch ( ePropertyType )
200cdf0e10cSrcweir 	{
201cdf0e10cSrcweir 	case uno::TypeClass_FLOAT:
202cdf0e10cSrcweir 	case uno::TypeClass_DOUBLE:
203cdf0e10cSrcweir 	case uno::TypeClass_BYTE:
204cdf0e10cSrcweir 	case uno::TypeClass_SHORT:
205cdf0e10cSrcweir 	case uno::TypeClass_LONG:
206cdf0e10cSrcweir 	case uno::TypeClass_HYPER:
207cdf0e10cSrcweir 	case uno::TypeClass_UNSIGNED_SHORT:
208cdf0e10cSrcweir 	case uno::TypeClass_UNSIGNED_LONG:
209cdf0e10cSrcweir 	case uno::TypeClass_UNSIGNED_HYPER:
210cdf0e10cSrcweir 		try
211cdf0e10cSrcweir 		{
212cdf0e10cSrcweir             aReturn = convertStringToSimple(ControlValue, ePropertyType);
213cdf0e10cSrcweir 		}
214cdf0e10cSrcweir 		catch( const script::CannotConvertException& ) { }
215cdf0e10cSrcweir         catch( const lang::IllegalArgumentException& ) { }
216cdf0e10cSrcweir 		break;
217cdf0e10cSrcweir 
218cdf0e10cSrcweir     default:
219cdf0e10cSrcweir     #if OSL_DEBUG_LEVEL > 0
220cdf0e10cSrcweir         bool bCanConvert =
221cdf0e10cSrcweir     #endif
222cdf0e10cSrcweir         convertStringToGenericValue( ControlValue, aReturn, ControlValueType );
223cdf0e10cSrcweir 
224cdf0e10cSrcweir     #if OSL_DEBUG_LEVEL > 0
225cdf0e10cSrcweir         // could not convert ...
226cdf0e10cSrcweir         if ( !bCanConvert && ControlValue.getLength() )
227cdf0e10cSrcweir         {
228cdf0e10cSrcweir             ::rtl::OString sMessage( "StringRepresentation::convertStringRepresentationToPropertyValue: cannot convert into values of type '" );
229cdf0e10cSrcweir             sMessage += ::rtl::OString( ControlValueType.getTypeName().getStr(), ControlValueType.getTypeName().getLength(), RTL_TEXTENCODING_ASCII_US );
230cdf0e10cSrcweir             sMessage += ::rtl::OString( "'!" );
231cdf0e10cSrcweir             DBG_ERROR( sMessage.getStr() );
232cdf0e10cSrcweir         }
233cdf0e10cSrcweir     #endif
234cdf0e10cSrcweir     }
235cdf0e10cSrcweir 
236cdf0e10cSrcweir     return aReturn;
237cdf0e10cSrcweir }
238cdf0e10cSrcweir 
239cdf0e10cSrcweir // lang::XInitialization:
initialize(const uno::Sequence<uno::Any> & aArguments)240cdf0e10cSrcweir void SAL_CALL StringRepresentation::initialize(const uno::Sequence< uno::Any > & aArguments) throw (uno::RuntimeException, uno::Exception)
241cdf0e10cSrcweir {
242cdf0e10cSrcweir     sal_Int32 nLength = aArguments.getLength();
243cdf0e10cSrcweir     if ( nLength )
244cdf0e10cSrcweir     {
245cdf0e10cSrcweir         const uno::Any* pIter = aArguments.getConstArray();
246cdf0e10cSrcweir         m_xTypeConverter.set(*pIter++,uno::UNO_QUERY);
247cdf0e10cSrcweir         if ( nLength == 3 )
248cdf0e10cSrcweir         {
249cdf0e10cSrcweir             ::rtl::OUString sConstantName;
250cdf0e10cSrcweir             *pIter++ >>= sConstantName;
251cdf0e10cSrcweir             *pIter >>= m_aValues;
252cdf0e10cSrcweir 
253cdf0e10cSrcweir             if ( m_xContext.is() )
254cdf0e10cSrcweir             {
255cdf0e10cSrcweir                 uno::Reference< container::XHierarchicalNameAccess > xTypeDescProv(
256cdf0e10cSrcweir                     m_xContext->getValueByName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/singletons/com.sun.star.reflection.theTypeDescriptionManager" ) ) ),
257cdf0e10cSrcweir                     uno::UNO_QUERY_THROW );
258cdf0e10cSrcweir 
259cdf0e10cSrcweir                 m_xTypeDescription.set( xTypeDescProv->getByHierarchicalName( sConstantName ), uno::UNO_QUERY_THROW );
260cdf0e10cSrcweir                 m_aConstants = m_xTypeDescription->getConstants();
261cdf0e10cSrcweir             }
262cdf0e10cSrcweir         }
263cdf0e10cSrcweir     }
264cdf0e10cSrcweir }
265cdf0e10cSrcweir //------------------------------------------------------------------------
convertSimpleToString(const uno::Any & _rValue)266cdf0e10cSrcweir ::rtl::OUString StringRepresentation::convertSimpleToString( const uno::Any& _rValue )
267cdf0e10cSrcweir {
268cdf0e10cSrcweir 	::rtl::OUString sReturn;
269cdf0e10cSrcweir 	if ( m_xTypeConverter.is() && _rValue.hasValue() )
270cdf0e10cSrcweir 	{
271cdf0e10cSrcweir 		try
272cdf0e10cSrcweir 		{
273cdf0e10cSrcweir             if ( m_aConstants.getLength() )
274cdf0e10cSrcweir             {
275cdf0e10cSrcweir                 sal_Int16 nConstantValue = 0;
276cdf0e10cSrcweir                 if ( _rValue >>= nConstantValue )
277cdf0e10cSrcweir                 {
278cdf0e10cSrcweir                     const uno::Reference< reflection::XConstantTypeDescription>* pIter = m_aConstants.getConstArray();
279cdf0e10cSrcweir                     const uno::Reference< reflection::XConstantTypeDescription>* pEnd  = pIter + m_aConstants.getLength();
280cdf0e10cSrcweir                     for(sal_Int32 i = 0;pIter != pEnd;++pIter,++i)
281cdf0e10cSrcweir                     {
282cdf0e10cSrcweir                         if ( (*pIter)->getConstantValue() == _rValue )
283cdf0e10cSrcweir                         {
284cdf0e10cSrcweir                             OSL_ENSURE(i < m_aValues.getLength() ,"StringRepresentation::convertSimpleToString: Index is not in range of m_aValues");
285cdf0e10cSrcweir                             sReturn = m_aValues[i];
286cdf0e10cSrcweir                             break;
287cdf0e10cSrcweir                         }
288cdf0e10cSrcweir                     }
289cdf0e10cSrcweir                 }
290cdf0e10cSrcweir             }
291cdf0e10cSrcweir 
292cdf0e10cSrcweir             if ( !sReturn.getLength() )
293cdf0e10cSrcweir 			    m_xTypeConverter->convertToSimpleType( _rValue, uno::TypeClass_STRING ) >>= sReturn;
294cdf0e10cSrcweir 		}
295cdf0e10cSrcweir 		catch( script::CannotConvertException& ) { }
296cdf0e10cSrcweir 		catch( lang::IllegalArgumentException& ) { }
297cdf0e10cSrcweir 	}
298cdf0e10cSrcweir 	return sReturn;
299cdf0e10cSrcweir }
300cdf0e10cSrcweir 
301cdf0e10cSrcweir //--------------------------------------------------------------------
302cdf0e10cSrcweir namespace
303cdf0e10cSrcweir {
304cdf0e10cSrcweir     struct ConvertIntegerFromAndToString
305cdf0e10cSrcweir     {
operator ()pcr::__anon6ce98ff70111::ConvertIntegerFromAndToString306cdf0e10cSrcweir         ::rtl::OUString operator()( sal_Int32 _rIntValue ) const
307cdf0e10cSrcweir         {
308cdf0e10cSrcweir             return ::rtl::OUString::valueOf( (sal_Int32)_rIntValue );
309cdf0e10cSrcweir         }
operator ()pcr::__anon6ce98ff70111::ConvertIntegerFromAndToString310cdf0e10cSrcweir         sal_Int32 operator()( const ::rtl::OUString& _rStringValue ) const
311cdf0e10cSrcweir         {
312cdf0e10cSrcweir             return _rStringValue.toInt32();
313cdf0e10cSrcweir         }
314cdf0e10cSrcweir     };
315cdf0e10cSrcweir 
316cdf0e10cSrcweir     struct StringIdentity
317cdf0e10cSrcweir     {
operator ()pcr::__anon6ce98ff70111::StringIdentity318cdf0e10cSrcweir         ::rtl::OUString operator()( const ::rtl::OUString& _rValue ) const
319cdf0e10cSrcweir         {
320cdf0e10cSrcweir             return _rValue;
321cdf0e10cSrcweir         }
322cdf0e10cSrcweir     };
323cdf0e10cSrcweir 
324cdf0e10cSrcweir     template < class ElementType, class Transformer >
composeSequenceElements(const Sequence<ElementType> & _rElements,const Transformer & _rTransformer)325cdf0e10cSrcweir     ::rtl::OUString composeSequenceElements( const Sequence< ElementType >& _rElements, const Transformer& _rTransformer )
326cdf0e10cSrcweir     {
327cdf0e10cSrcweir 		String sCompose;
328cdf0e10cSrcweir 
329cdf0e10cSrcweir 		// loop through the elements and concatenate the string representations of the integers
330cdf0e10cSrcweir 		// (separated by a line break)
331cdf0e10cSrcweir         const ElementType* pElements = _rElements.getConstArray();
332cdf0e10cSrcweir         const ElementType* pElementsEnd = pElements + _rElements.getLength();
333cdf0e10cSrcweir         for ( ; pElements != pElementsEnd; ++pElements )
334cdf0e10cSrcweir         {
335cdf0e10cSrcweir 			sCompose += String( _rTransformer( *pElements ) );
336cdf0e10cSrcweir 			if ( pElements != pElementsEnd )
337cdf0e10cSrcweir 				sCompose += '\n';
338cdf0e10cSrcweir         }
339cdf0e10cSrcweir 
340cdf0e10cSrcweir         return sCompose;
341cdf0e10cSrcweir     }
342cdf0e10cSrcweir 
343cdf0e10cSrcweir     template < class ElementType, class Transformer >
splitComposedStringToSequence(const::rtl::OUString & _rComposed,Sequence<ElementType> & _out_SplitUp,const Transformer & _rTransformer)344cdf0e10cSrcweir     void splitComposedStringToSequence( const ::rtl::OUString& _rComposed, Sequence< ElementType >& _out_SplitUp, const Transformer& _rTransformer )
345cdf0e10cSrcweir     {
346cdf0e10cSrcweir         _out_SplitUp.realloc( 0 );
347cdf0e10cSrcweir         if ( !_rComposed.getLength() )
348cdf0e10cSrcweir             return;
349cdf0e10cSrcweir         sal_Int32 tokenPos = 0;
350cdf0e10cSrcweir         do
351cdf0e10cSrcweir         {
352cdf0e10cSrcweir             _out_SplitUp.realloc( _out_SplitUp.getLength() + 1 );
353cdf0e10cSrcweir             _out_SplitUp[ _out_SplitUp.getLength() - 1 ] = (ElementType)_rTransformer( _rComposed.getToken( 0, '\n', tokenPos ) );
354cdf0e10cSrcweir         }
355cdf0e10cSrcweir         while ( tokenPos != -1 );
356cdf0e10cSrcweir     }
357cdf0e10cSrcweir }
358cdf0e10cSrcweir 
359cdf0e10cSrcweir //--------------------------------------------------------------------
convertGenericValueToString(const uno::Any & _rValue,::rtl::OUString & _rStringRep)360cdf0e10cSrcweir bool StringRepresentation::convertGenericValueToString( const uno::Any& _rValue, ::rtl::OUString& _rStringRep )
361cdf0e10cSrcweir {
362cdf0e10cSrcweir     bool bCanConvert = true;
363cdf0e10cSrcweir 
364cdf0e10cSrcweir 	switch ( _rValue.getValueTypeClass() )
365cdf0e10cSrcweir 	{
366cdf0e10cSrcweir     case uno::TypeClass_STRING:
367cdf0e10cSrcweir         _rValue >>= _rStringRep;
368cdf0e10cSrcweir         break;
369cdf0e10cSrcweir 
370cdf0e10cSrcweir 	case uno::TypeClass_BOOLEAN:
371cdf0e10cSrcweir 	{
372cdf0e10cSrcweir         ::std::vector< ::rtl::OUString > aListEntries;
373cdf0e10cSrcweir         tools::StringListResource aRes(PcrRes(RID_RSC_ENUM_YESNO),aListEntries);
374cdf0e10cSrcweir         sal_Bool bValue = sal_False;
375cdf0e10cSrcweir         _rValue >>= bValue;
376cdf0e10cSrcweir         _rStringRep = bValue ? aListEntries[1] : aListEntries[0];
377cdf0e10cSrcweir 	}
378cdf0e10cSrcweir 	break;
379cdf0e10cSrcweir 
380cdf0e10cSrcweir 	// some sequence types
381cdf0e10cSrcweir 	case uno::TypeClass_SEQUENCE:
382cdf0e10cSrcweir 	{
383cdf0e10cSrcweir 		Sequence< ::rtl::OUString > aStringValues;
384cdf0e10cSrcweir         Sequence< sal_Int8 > aInt8Values;
385cdf0e10cSrcweir 		Sequence< sal_uInt16 > aUInt16Values;
386cdf0e10cSrcweir         Sequence< sal_Int16 > aInt16Values;
387cdf0e10cSrcweir 		Sequence< sal_uInt32 > aUInt32Values;
388cdf0e10cSrcweir         Sequence< sal_Int32 > aInt32Values;
389cdf0e10cSrcweir 
390cdf0e10cSrcweir         // string sequences
391cdf0e10cSrcweir         if ( _rValue >>= aStringValues )
392cdf0e10cSrcweir 		{
393cdf0e10cSrcweir             _rStringRep = composeSequenceElements( aStringValues, StringIdentity() );
394cdf0e10cSrcweir 		}
395cdf0e10cSrcweir 		// byte sequences
396cdf0e10cSrcweir 		else if ( _rValue >>= aInt8Values )
397cdf0e10cSrcweir 		{
398cdf0e10cSrcweir             _rStringRep = composeSequenceElements( aInt8Values, ConvertIntegerFromAndToString() );
399cdf0e10cSrcweir 		}
400cdf0e10cSrcweir 		// uInt16 sequences
401cdf0e10cSrcweir 		else if ( _rValue >>= aUInt16Values )
402cdf0e10cSrcweir 		{
403cdf0e10cSrcweir             _rStringRep = composeSequenceElements( aUInt16Values, ConvertIntegerFromAndToString() );
404cdf0e10cSrcweir 		}
405cdf0e10cSrcweir 		// Int16 sequences
406cdf0e10cSrcweir 		else if ( _rValue >>= aInt16Values )
407cdf0e10cSrcweir 		{
408cdf0e10cSrcweir             _rStringRep = composeSequenceElements( aInt16Values, ConvertIntegerFromAndToString() );
409cdf0e10cSrcweir 		}
410cdf0e10cSrcweir 		// uInt32 sequences
411cdf0e10cSrcweir 		else if ( _rValue >>= aUInt32Values )
412cdf0e10cSrcweir 		{
413cdf0e10cSrcweir             _rStringRep = composeSequenceElements( aUInt32Values, ConvertIntegerFromAndToString() );
414cdf0e10cSrcweir 		}
415cdf0e10cSrcweir 		// Int32 sequences
416cdf0e10cSrcweir 		else if ( _rValue >>= aInt32Values )
417cdf0e10cSrcweir 		{
418cdf0e10cSrcweir             _rStringRep = composeSequenceElements( aInt32Values, ConvertIntegerFromAndToString() );
419cdf0e10cSrcweir 		}
420cdf0e10cSrcweir         else
421cdf0e10cSrcweir             bCanConvert = false;
422cdf0e10cSrcweir 	}
423cdf0e10cSrcweir 	break;
424cdf0e10cSrcweir     case uno::TypeClass_CONSTANT:
425cdf0e10cSrcweir         {
426cdf0e10cSrcweir             int i = 0;
427cdf0e10cSrcweir             ++i;
428cdf0e10cSrcweir         }
429cdf0e10cSrcweir         break;
430cdf0e10cSrcweir 
431cdf0e10cSrcweir 	// some structs
432cdf0e10cSrcweir     case uno::TypeClass_STRUCT:
433cdf0e10cSrcweir         OSL_ENSURE( false, "StringRepresentation::convertGenericValueToString(STRUCT): this is dead code - isn't it?" );
434cdf0e10cSrcweir         if ( _rValue.getValueType().equals( ::getCppuType( static_cast< util::Date* >( NULL ) ) ) )
435cdf0e10cSrcweir         {
436cdf0e10cSrcweir             // weird enough, the string representation of dates, as used
437cdf0e10cSrcweir             // by the control displaying dates, and thus as passed through the layers,
438cdf0e10cSrcweir             // is YYYYMMDD.
439cdf0e10cSrcweir             util::Date aUnoDate;
440cdf0e10cSrcweir             _rValue >>= aUnoDate;
441cdf0e10cSrcweir             _rStringRep = ::dbtools::DBTypeConversion::toDateString(aUnoDate);
442cdf0e10cSrcweir         }
443cdf0e10cSrcweir         else if ( _rValue.getValueType().equals( ::getCppuType( static_cast< util::Time* >( NULL ) ) ) )
444cdf0e10cSrcweir         {
445cdf0e10cSrcweir             // similar for time (HHMMSSHH)
446cdf0e10cSrcweir             util::Time aUnoTime;
447cdf0e10cSrcweir             _rValue >>= aUnoTime;
448cdf0e10cSrcweir             _rStringRep = ::dbtools::DBTypeConversion::toTimeString(aUnoTime);
449cdf0e10cSrcweir         }
450cdf0e10cSrcweir         else if ( _rValue.getValueType().equals( ::getCppuType( static_cast< util::DateTime* >( NULL ) ) ) )
451cdf0e10cSrcweir         {
452cdf0e10cSrcweir             util::DateTime aUnoDateTime;
453cdf0e10cSrcweir             _rValue >>= aUnoDateTime;
454cdf0e10cSrcweir             _rStringRep = ::dbtools::DBTypeConversion::toDateTimeString(aUnoDateTime);
455cdf0e10cSrcweir         }
456cdf0e10cSrcweir         else
457cdf0e10cSrcweir             bCanConvert = false;
458cdf0e10cSrcweir         break;
459cdf0e10cSrcweir 
460cdf0e10cSrcweir     default:
461cdf0e10cSrcweir         bCanConvert = false;
462cdf0e10cSrcweir         break;
463cdf0e10cSrcweir 	}
464cdf0e10cSrcweir 
465cdf0e10cSrcweir     return bCanConvert;
466cdf0e10cSrcweir }
467cdf0e10cSrcweir //------------------------------------------------------------------------
convertStringToSimple(const::rtl::OUString & _rValue,const uno::TypeClass & _ePropertyType)468cdf0e10cSrcweir uno::Any StringRepresentation::convertStringToSimple( const ::rtl::OUString& _rValue,const uno::TypeClass& _ePropertyType )
469cdf0e10cSrcweir {
470cdf0e10cSrcweir 	uno::Any aReturn;
471cdf0e10cSrcweir 	if ( m_xTypeConverter.is() && _rValue.getLength() )
472cdf0e10cSrcweir 	{
473cdf0e10cSrcweir 		try
474cdf0e10cSrcweir 		{
475cdf0e10cSrcweir             if ( m_aConstants.getLength() && m_aValues.getLength() )
476cdf0e10cSrcweir             {
477cdf0e10cSrcweir                 const ::rtl::OUString* pIter = m_aValues.getConstArray();
478cdf0e10cSrcweir                 const ::rtl::OUString* pEnd	  = pIter + m_aValues.getLength();
479cdf0e10cSrcweir                 for(sal_Int32 i = 0;pIter != pEnd;++pIter,++i)
480cdf0e10cSrcweir                 {
481cdf0e10cSrcweir                     if ( *pIter == _rValue )
482cdf0e10cSrcweir                     {
483cdf0e10cSrcweir                         OSL_ENSURE(i < m_aConstants.getLength() ,"StringRepresentation::convertSimpleToString: Index is not in range of m_aValues");
484cdf0e10cSrcweir                         aReturn <<= m_aConstants[i]->getConstantValue();
485cdf0e10cSrcweir                         break;
486cdf0e10cSrcweir                     }
487cdf0e10cSrcweir                 }
488cdf0e10cSrcweir             }
489cdf0e10cSrcweir 
490cdf0e10cSrcweir             if ( !aReturn.hasValue() )
491cdf0e10cSrcweir                 aReturn = m_xTypeConverter->convertToSimpleType( makeAny( _rValue ), _ePropertyType );
492cdf0e10cSrcweir 		}
493cdf0e10cSrcweir 		catch( script::CannotConvertException& ) { }
494cdf0e10cSrcweir 		catch( lang::IllegalArgumentException& ) { }
495cdf0e10cSrcweir 	}
496cdf0e10cSrcweir 	return aReturn;
497cdf0e10cSrcweir }
498cdf0e10cSrcweir //--------------------------------------------------------------------
convertStringToGenericValue(const::rtl::OUString & _rStringRep,uno::Any & _rValue,const uno::Type & _rTargetType)499cdf0e10cSrcweir bool StringRepresentation::convertStringToGenericValue( const ::rtl::OUString& _rStringRep, uno::Any& _rValue, const uno::Type& _rTargetType )
500cdf0e10cSrcweir {
501cdf0e10cSrcweir     bool bCanConvert = true;
502cdf0e10cSrcweir 
503cdf0e10cSrcweir     switch ( _rTargetType.getTypeClass() )
504cdf0e10cSrcweir     {
505cdf0e10cSrcweir 	case uno::TypeClass_STRING:
506cdf0e10cSrcweir         _rValue <<= _rStringRep;
507cdf0e10cSrcweir         break;
508cdf0e10cSrcweir 
509cdf0e10cSrcweir     case uno::TypeClass_BOOLEAN:
510cdf0e10cSrcweir 	{
511cdf0e10cSrcweir         ::std::vector< ::rtl::OUString > aListEntries;
512cdf0e10cSrcweir         tools::StringListResource aRes(PcrRes(RID_RSC_ENUM_YESNO),aListEntries);
513cdf0e10cSrcweir         if ( aListEntries[0] == _rStringRep )
514cdf0e10cSrcweir 			_rValue <<= (sal_Bool)sal_False;
515cdf0e10cSrcweir 		else
516cdf0e10cSrcweir 			_rValue <<= (sal_Bool)sal_True;
517cdf0e10cSrcweir 	}
518cdf0e10cSrcweir 	break;
519cdf0e10cSrcweir 
520cdf0e10cSrcweir 	case uno::TypeClass_SEQUENCE:
521cdf0e10cSrcweir 	{
522cdf0e10cSrcweir 		uno::Type aElementType = ::comphelper::getSequenceElementType( _rTargetType );
523cdf0e10cSrcweir 
524cdf0e10cSrcweir 		String aStr( _rStringRep );
525cdf0e10cSrcweir 		switch ( aElementType.getTypeClass() )
526cdf0e10cSrcweir 		{
527cdf0e10cSrcweir 			case uno::TypeClass_STRING:
528cdf0e10cSrcweir 			{
529cdf0e10cSrcweir                 Sequence< ::rtl::OUString > aElements;
530cdf0e10cSrcweir                 splitComposedStringToSequence( aStr, aElements, StringIdentity() );
531cdf0e10cSrcweir 				_rValue <<= aElements;
532cdf0e10cSrcweir 			}
533cdf0e10cSrcweir 			break;
534cdf0e10cSrcweir 			case uno::TypeClass_SHORT:
535cdf0e10cSrcweir 			{
536cdf0e10cSrcweir                 Sequence< sal_Int16 > aElements;
537cdf0e10cSrcweir                 splitComposedStringToSequence( aStr, aElements, ConvertIntegerFromAndToString() );
538cdf0e10cSrcweir 				_rValue <<= aElements;
539cdf0e10cSrcweir 			}
540cdf0e10cSrcweir 			break;
541cdf0e10cSrcweir 			case uno::TypeClass_UNSIGNED_SHORT:
542cdf0e10cSrcweir 			{
543cdf0e10cSrcweir                 Sequence< sal_uInt16 > aElements;
544cdf0e10cSrcweir                 splitComposedStringToSequence( aStr, aElements, ConvertIntegerFromAndToString() );
545cdf0e10cSrcweir 				_rValue <<= aElements;
546cdf0e10cSrcweir 			}
547cdf0e10cSrcweir 			break;
548cdf0e10cSrcweir 			case uno::TypeClass_LONG:
549cdf0e10cSrcweir 			{
550cdf0e10cSrcweir                 Sequence< sal_Int32 > aElements;
551cdf0e10cSrcweir                 splitComposedStringToSequence( aStr, aElements, ConvertIntegerFromAndToString() );
552cdf0e10cSrcweir 				_rValue <<= aElements;
553cdf0e10cSrcweir 			}
554cdf0e10cSrcweir 			break;
555cdf0e10cSrcweir 			case uno::TypeClass_UNSIGNED_LONG:
556cdf0e10cSrcweir 			{
557cdf0e10cSrcweir                 Sequence< sal_uInt32 > aElements;
558cdf0e10cSrcweir                 splitComposedStringToSequence( aStr, aElements, ConvertIntegerFromAndToString() );
559cdf0e10cSrcweir 				_rValue <<= aElements;
560cdf0e10cSrcweir 			}
561cdf0e10cSrcweir 			break;
562cdf0e10cSrcweir 			case uno::TypeClass_BYTE:
563cdf0e10cSrcweir 			{
564cdf0e10cSrcweir                 Sequence< sal_Int8 > aElements;
565cdf0e10cSrcweir                 splitComposedStringToSequence( aStr, aElements, ConvertIntegerFromAndToString() );
566cdf0e10cSrcweir 				_rValue <<= aElements;
567cdf0e10cSrcweir 			}
568cdf0e10cSrcweir 			break;
569cdf0e10cSrcweir             default:
570cdf0e10cSrcweir                 bCanConvert = false;
571cdf0e10cSrcweir                 break;
572cdf0e10cSrcweir 		}
573cdf0e10cSrcweir 	}
574cdf0e10cSrcweir 	break;
575cdf0e10cSrcweir 
576cdf0e10cSrcweir     case uno::TypeClass_STRUCT:
577cdf0e10cSrcweir         OSL_ENSURE( false, "StringRepresentation::convertStringToGenericValue(STRUCT): this is dead code - isn't it?" );
578cdf0e10cSrcweir         if ( _rTargetType.equals( ::getCppuType( static_cast< util::Date* >( NULL ) ) ) )
579cdf0e10cSrcweir         {
580cdf0e10cSrcweir             // weird enough, the string representation of dates, as used
581cdf0e10cSrcweir             // by the control displaying dates, and thus as passed through the layers,
582cdf0e10cSrcweir             // is YYYYMMDD.
583cdf0e10cSrcweir 
584cdf0e10cSrcweir             _rValue <<= ::dbtools::DBTypeConversion::toDate(_rStringRep);
585cdf0e10cSrcweir         }
586cdf0e10cSrcweir         else if ( _rTargetType.equals( ::getCppuType( static_cast< util::Time* >( NULL ) ) ) )
587cdf0e10cSrcweir         {
588cdf0e10cSrcweir             // similar for time (HHMMSSHH)
589cdf0e10cSrcweir             _rValue <<= ::dbtools::DBTypeConversion::toTime(_rStringRep);
590cdf0e10cSrcweir         }
591cdf0e10cSrcweir         else if ( _rTargetType.equals( ::getCppuType( static_cast< util::DateTime* >( NULL ) ) ) )
592cdf0e10cSrcweir         {
593cdf0e10cSrcweir             _rValue <<= ::dbtools::DBTypeConversion::toDateTime(_rStringRep);
594cdf0e10cSrcweir         }
595cdf0e10cSrcweir         else
596cdf0e10cSrcweir             bCanConvert = false;
597cdf0e10cSrcweir         break;
598cdf0e10cSrcweir 
599cdf0e10cSrcweir     default:
600cdf0e10cSrcweir         bCanConvert = false;
601cdf0e10cSrcweir         break;
602cdf0e10cSrcweir     }
603cdf0e10cSrcweir 
604cdf0e10cSrcweir     return bCanConvert;
605cdf0e10cSrcweir }
606cdf0e10cSrcweir //------------------------------------------------------------------------
607cdf0e10cSrcweir //------------------------------------------------------------------------
608cdf0e10cSrcweir } // pcr
609cdf0e10cSrcweir //------------------------------------------------------------------------
610cdf0e10cSrcweir 
611cdf0e10cSrcweir 
612cdf0e10cSrcweir // component helper namespace
613cdf0e10cSrcweir namespace comp_StringRepresentation {
614cdf0e10cSrcweir 
_getImplementationName()615cdf0e10cSrcweir ::rtl::OUString SAL_CALL _getImplementationName() {
616cdf0e10cSrcweir     return ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
617cdf0e10cSrcweir         "StringRepresentation"));
618cdf0e10cSrcweir }
619cdf0e10cSrcweir 
_getSupportedServiceNames()620cdf0e10cSrcweir uno::Sequence< ::rtl::OUString > SAL_CALL _getSupportedServiceNames()
621cdf0e10cSrcweir {
622cdf0e10cSrcweir     uno::Sequence< ::rtl::OUString > s(1);
623cdf0e10cSrcweir     s[0] = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
624cdf0e10cSrcweir         "com.sun.star.inspection.StringRepresentation"));
625cdf0e10cSrcweir     return s;
626cdf0e10cSrcweir }
627cdf0e10cSrcweir 
_create(const uno::Reference<uno::XComponentContext> & context)628cdf0e10cSrcweir uno::Reference< uno::XInterface > SAL_CALL _create(
629cdf0e10cSrcweir     const uno::Reference< uno::XComponentContext > & context)
630cdf0e10cSrcweir         SAL_THROW((uno::Exception))
631cdf0e10cSrcweir {
632cdf0e10cSrcweir     return static_cast< ::cppu::OWeakObject * >(new pcr::StringRepresentation(context));
633cdf0e10cSrcweir }
634cdf0e10cSrcweir 
635cdf0e10cSrcweir } // closing component helper namespace
636cdf0e10cSrcweir 
637cdf0e10cSrcweir //------------------------------------------------------------------------
createRegistryInfo_StringRepresentation()638cdf0e10cSrcweir extern "C" void SAL_CALL createRegistryInfo_StringRepresentation()
639cdf0e10cSrcweir {
640cdf0e10cSrcweir     ::pcr::PcrModule::getInstance().registerImplementation(
641cdf0e10cSrcweir             comp_StringRepresentation::_getImplementationName(),
642cdf0e10cSrcweir             comp_StringRepresentation::_getSupportedServiceNames(),
643cdf0e10cSrcweir             comp_StringRepresentation::_create
644cdf0e10cSrcweir         );
645cdf0e10cSrcweir }
646cdf0e10cSrcweir 
647