?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / dbaccess / source / core / api / definitioncolumn.cxx
blob6cb16e8c7119b02b4187d71e40685cae230927c3
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: definitioncolumn.cxx,v $
10 * $Revision: 1.26 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_dbaccess.hxx"
33
34 #ifndef _DBA_COREAPI_DEFINITIONSETTINGS_HXX_
35 #include "definitioncolumn.hxx"
36 #endif
37 #ifndef _CPPUHELPER_TYPEPROVIDER_HXX_
38 #include <cppuhelper/typeprovider.hxx>
39 #endif
40 #ifndef _COMPHELPER_PROPERTY_HXX_
41 #include <comphelper/property.hxx>
42 #endif
43 #ifndef _COMPHELPER_TYPES_HXX_
44 #include <comphelper/types.hxx>
45 #endif
46 #ifndef DBACCESS_SHARED_DBASTRINGS_HRC
47 #include "dbastrings.hrc"
48 #endif
49 #ifndef _DBASHARED_APITOOLS_HXX_
50 #include "apitools.hxx"
51 #endif
52 #ifndef _TOOLS_DEBUG_HXX
53 #include <tools/debug.hxx>
54 #endif
55 #ifndef _COM_SUN_STAR_BEANS_PROPERTYATTRIBUTE_HPP_
56 #include <com/sun/star/beans/PropertyAttribute.hpp>
57 #endif
58 #ifndef DBACORE_SDBCORETOOLS_HXX
59 #include "sdbcoretools.hxx"
60 #endif
61
62
63 using namespace ::com::sun::star::sdbc;
64 using namespace ::com::sun::star::beans;
65 using namespace ::com::sun::star::uno;
66 using namespace ::com::sun::star::lang;
67 using namespace ::cppu;
68 using namespace ::comphelper;
69 using namespace ::osl;
70 using namespace dbaccess;
71
72 #define HAS_DESCRIPTION 0x00000001
73 #define HAS_DEFAULTVALUE 0x00000002
74 #define HAS_ROWVERSION 0x00000004
75 #define HAS_AUTOINCREMENT_CREATION 0x00000008
76
77 //============================================================
78 //= OTableColumnDescriptor
79 //============================================================
80 IMPLEMENT_FORWARD_XINTERFACE2(OTableColumnDescriptor,OColumn,TXChild)
81
82 // com::sun::star::lang::XTypeProvider
83 //--------------------------------------------------------------------------
84 Sequence< sal_Int8 > OTableColumnDescriptor::getImplementationId() throw (RuntimeException)
85 {
86 static OImplementationId * pId = 0;
87 if (! pId)
88 {
89 MutexGuard aGuard( Mutex::getGlobalMutex() );
90 if (! pId)
91 {
92 static OImplementationId aId;
93 pId = &aId;
94 }
95 }
96 return pId->getImplementationId();
97 }
98
99 // ::com::sun::star::lang::XServiceInfo
100 //------------------------------------------------------------------------------
101 rtl::OUString OTableColumnDescriptor::getImplementationName( ) throw (RuntimeException)
102 {
103 return rtl::OUString::createFromAscii("com.sun.star.sdb.OTableColumnDescriptor");
104 }
105
106 //------------------------------------------------------------------------------
107 Sequence< ::rtl::OUString > OTableColumnDescriptor::getSupportedServiceNames( ) throw (RuntimeException)
108 {
109 Sequence< ::rtl::OUString > aSNS( 2 );
110 aSNS[0] = SERVICE_SDBCX_COLUMNDESCRIPTOR;
111 aSNS[1] = SERVICE_SDB_COLUMNSETTINGS;
112 return aSNS;
113 }
114
115 // comphelper::OPropertyArrayUsageHelper
116 //------------------------------------------------------------------------------
117 ::cppu::IPropertyArrayHelper* OTableColumnDescriptor::createArrayHelper( ) const
118 {
119 BEGIN_PROPERTY_HELPER(20)
120 DECL_PROP2(ALIGN, sal_Int32, BOUND,MAYBEVOID);
121 DECL_PROP1(AUTOINCREMENTCREATION,::rtl::OUString, MAYBEVOID);
122 DECL_PROP2(CONTROLDEFAULT, ::rtl::OUString, BOUND,MAYBEVOID);
123 DECL_PROP1_IFACE(CONTROLMODEL, XPropertySet, BOUND );
124 DECL_PROP0(DEFAULTVALUE, ::rtl::OUString );
125 DECL_PROP0(DESCRIPTION, ::rtl::OUString );
126 DECL_PROP2(NUMBERFORMAT, sal_Int32, BOUND,MAYBEVOID);
127 DECL_PROP2(HELPTEXT, ::rtl::OUString, BOUND,MAYBEVOID);
128 DECL_PROP1_BOOL(HIDDEN, BOUND);
129 DECL_PROP0_BOOL(ISAUTOINCREMENT );
130 DECL_PROP0_BOOL(ISCURRENCY );
131 DECL_PROP0(ISNULLABLE, sal_Int32 );
132 DECL_PROP0_BOOL(ISROWVERSION );
133 DECL_PROP0(NAME, ::rtl::OUString );
134 DECL_PROP0(PRECISION, sal_Int32 );
135 DECL_PROP2(RELATIVEPOSITION, sal_Int32, BOUND, MAYBEVOID);
136 DECL_PROP0(SCALE, sal_Int32 );
137 DECL_PROP0(TYPE, sal_Int32 );
138 DECL_PROP0(TYPENAME, ::rtl::OUString );
139 DECL_PROP2(WIDTH, sal_Int32, BOUND, MAYBEVOID);
140 END_PROPERTY_HELPER();
141 }
142
143 // cppu::OPropertySetHelper
144 //------------------------------------------------------------------------------
145 ::cppu::IPropertyArrayHelper& OTableColumnDescriptor::getInfoHelper()
146 {
147 return *static_cast< ::comphelper::OPropertyArrayUsageHelper< OTableColumnDescriptor >* >(this)->getArrayHelper();
148 }
149
150 //------------------------------------------------------------------------------
151 void OTableColumnDescriptor::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
152 {
153 switch (nHandle)
154 {
155 case PROPERTY_ID_TYPE:
156 rValue <<= m_nType;
157 break;
158 case PROPERTY_ID_PRECISION:
159 rValue <<= m_nPrecision;
160 break;
161 case PROPERTY_ID_SCALE:
162 rValue <<= m_nScale;
163 break;
164 case PROPERTY_ID_ISNULLABLE:
165 rValue <<= m_nIsNullable;
166 break;
167 case PROPERTY_ID_TYPENAME:
168 rValue <<= m_aTypeName;
169 break;
170 case PROPERTY_ID_DESCRIPTION:
171 rValue <<= m_aDescription;
172 break;
173 case PROPERTY_ID_DEFAULTVALUE:
174 rValue <<= m_aDefaultValue;
175 break;
176 case PROPERTY_ID_AUTOINCREMENTCREATION:
177 rValue <<= m_aAutoIncrementValue;
178 break;
179 case PROPERTY_ID_ISAUTOINCREMENT:
180 {
181 sal_Bool bVal = m_bAutoIncrement;
182 rValue.setValue(&bVal, getBooleanCppuType());
183 } break;
184 case PROPERTY_ID_ISCURRENCY:
185 {
186 sal_Bool bVal = m_bCurrency;
187 rValue.setValue(&bVal, getBooleanCppuType());
188 } break;
189 case PROPERTY_ID_ISROWVERSION:
190 {
191 sal_Bool bVal = m_bRowVersion;
192 rValue.setValue(&bVal, getBooleanCppuType());
193 } break;
194 case PROPERTY_ID_NAME:
195 OColumn::getFastPropertyValue( rValue, nHandle );
196 break;
197 default:
198 OColumnSettings::getFastPropertyValue( rValue, nHandle );
199 }
200 }
201
202 //------------------------------------------------------------------------------
203 sal_Bool OTableColumnDescriptor::convertFastPropertyValue(
204 Any & rConvertedValue,
205 Any & rOldValue,
206 sal_Int32 nHandle,
207 const Any& rValue )
208 throw (IllegalArgumentException)
209 {
210 sal_Bool bModified = sal_False;
211 switch (nHandle)
212 {
213 case PROPERTY_ID_TYPE:
214 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_nType);
215 break;
216 case PROPERTY_ID_PRECISION:
217 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_nPrecision);
218 break;
219 case PROPERTY_ID_SCALE:
220 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_nScale);
221 break;
222 case PROPERTY_ID_ISNULLABLE:
223 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_nIsNullable);
224 break;
225 case PROPERTY_ID_TYPENAME:
226 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_aTypeName);
227 break;
228 case PROPERTY_ID_DESCRIPTION:
229 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_aDescription);
230 break;
231 case PROPERTY_ID_DEFAULTVALUE:
232 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_aDefaultValue);
233 break;
234 case PROPERTY_ID_AUTOINCREMENTCREATION:
235 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_aAutoIncrementValue);
236 break;
237 case PROPERTY_ID_ISAUTOINCREMENT:
238 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_bAutoIncrement);
239 break;
240 case PROPERTY_ID_ISCURRENCY:
241 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_bCurrency);
242 break;
243 case PROPERTY_ID_ISROWVERSION:
244 bModified = ::comphelper::tryPropertyValue(rConvertedValue, rOldValue, rValue, m_bRowVersion);
245 break;
246 case PROPERTY_ID_NAME:
247 bModified = OColumn::convertFastPropertyValue( rConvertedValue, rOldValue, nHandle, rValue );
248 break;
249 default:
250 bModified = OColumnSettings::convertFastPropertyValue( rConvertedValue, rOldValue, nHandle, rValue );
251 }
252 return bModified;
253 }
254
255 //------------------------------------------------------------------------------
256 void OTableColumnDescriptor::setFastPropertyValue_NoBroadcast(
257 sal_Int32 nHandle,
258 const Any& rValue
259 )
260 throw (Exception)
261 {
262 switch (nHandle)
263 {
264 case PROPERTY_ID_TYPE:
265 OSL_ENSURE(rValue.getValueType().equals(::getCppuType(static_cast< sal_Int32* >(NULL))),
266 "OTableColumnDescriptor::setFastPropertyValue_NoBroadcast(TYPE) : invalid value !");
267 rValue >>= m_nType;
268 break;
269 case PROPERTY_ID_PRECISION:
270 OSL_ENSURE(rValue.getValueType().equals(::getCppuType(static_cast< sal_Int32* >(NULL))),
271 "OTableColumnDescriptor::setFastPropertyValue_NoBroadcast(PRECISION) : invalid value !");
272 rValue >>= m_nPrecision;
273 break;
274 case PROPERTY_ID_SCALE:
275 OSL_ENSURE(rValue.getValueType().equals(::getCppuType(static_cast< sal_Int32* >(NULL))),
276 "OTableColumnDescriptor::setFastPropertyValue_NoBroadcast(SCALE) : invalid value !");
277 rValue >>= m_nScale;
278 break;
279 case PROPERTY_ID_ISNULLABLE:
280 OSL_ENSURE(rValue.getValueType().equals(::getCppuType(static_cast< sal_Int32* >(NULL))),
281 "OTableColumnDescriptor::setFastPropertyValue_NoBroadcast(ISNULLABLE) : invalid value !");
282 rValue >>= m_nIsNullable;
283 break;
284 case PROPERTY_ID_TYPENAME:
285 OSL_ENSURE(rValue.getValueType().equals(::getCppuType(static_cast< rtl::OUString* >(NULL))),
286 "OTableColumnDescriptor::setFastPropertyValue_NoBroadcast(TYPENAME) : invalid value !");
287 rValue >>= m_aTypeName;
288 break;
289 case PROPERTY_ID_DESCRIPTION:
290 OSL_ENSURE(rValue.getValueType().equals(::getCppuType(static_cast< rtl::OUString* >(NULL))),
291 "OTableColumnDescriptor::setFastPropertyValue_NoBroadcast(DESCRIPTION) : invalid value !");
292 rValue >>= m_aDescription;
293 break;
294 case PROPERTY_ID_DEFAULTVALUE:
295 OSL_ENSURE(rValue.getValueType().equals(::getCppuType(static_cast< rtl::OUString* >(NULL))),
296 "OTableColumnDescriptor::setFastPropertyValue_NoBroadcast(DEFAULTVALUE) : invalid value !");
297 rValue >>= m_aDefaultValue;
298 break;
299 case PROPERTY_ID_AUTOINCREMENTCREATION:
300 OSL_ENSURE(rValue.getValueType().equals(::getCppuType(static_cast< rtl::OUString* >(NULL))),
301 "OTableColumnDescriptor::setFastPropertyValue_NoBroadcast(AUTOINCREMENTVALUE) : invalid value !");
302 rValue >>= m_aAutoIncrementValue;
303 break;
304 case PROPERTY_ID_ISAUTOINCREMENT:
305 OSL_ENSURE(rValue.getValueType().equals(::getCppuType(static_cast< sal_Bool* >(NULL))),
306 "OTableColumnDescriptor::setFastPropertyValue_NoBroadcast(ISAUTOINCREMENT) : invalid value !");
307 m_bAutoIncrement = ::comphelper::getBOOL(rValue);
308 break;
309 case PROPERTY_ID_ISCURRENCY:
310 OSL_ENSURE(rValue.getValueType().equals(::getCppuType(static_cast< sal_Bool* >(NULL))),
311 "OTableColumnDescriptor::setFastPropertyValue_NoBroadcast(ISCURRENCY) : invalid value !");
312 m_bCurrency = ::comphelper::getBOOL(rValue);
313 break;
314 case PROPERTY_ID_ISROWVERSION:
315 OSL_ENSURE(rValue.getValueType().equals(::getCppuType(static_cast< sal_Bool* >(NULL))),
316 "OTableColumnDescriptor::setFastPropertyValue_NoBroadcast(ISROWVERSION) : invalid value !");
317 m_bRowVersion = ::comphelper::getBOOL(rValue);
318 break;
319 case PROPERTY_ID_NAME:
320 OColumn::setFastPropertyValue_NoBroadcast( nHandle, rValue );
321 break;
322 default:
323 OColumnSettings::setFastPropertyValue_NoBroadcast( nHandle, rValue );
324 }
325 ::dbaccess::notifyDataSourceModified(m_xParent,sal_True);
326 }
327
328 // -----------------------------------------------------------------------------
329 sal_Int64 SAL_CALL OTableColumnDescriptor::getSomething( const Sequence< sal_Int8 >& aIdentifier ) throw(RuntimeException)
330 {
331 sal_Int64 nReturn = OColumn::getSomething( aIdentifier );
332 if ( !nReturn )
333 nReturn = OColumnSettings::getSomething( aIdentifier );
334 return nReturn;
335 }
336
337 // -----------------------------------------------------------------------------
338 Reference< XInterface > SAL_CALL OTableColumnDescriptor::getParent( ) throw (RuntimeException)
339 {
340 ::osl::MutexGuard aGuard(m_aMutex);
341 return m_xParent;
342 }
343 // -----------------------------------------------------------------------------
344 void SAL_CALL OTableColumnDescriptor::setParent( const Reference< XInterface >& _xParent ) throw (NoSupportException, RuntimeException)
345 {
346 ::osl::MutexGuard aGuard(m_aMutex);
347 m_xParent = _xParent;
348 }
349 //============================================================
350 //= OTableColumn
351 //============================================================
352 DBG_NAME(OTableColumn);
353 OTableColumn::OTableColumn(const ::rtl::OUString& _rName)
354 {
355 DBG_CTOR(OTableColumn,NULL);
356 m_sName = _rName;
357 }
358 // -------------------------------------------------------------------------
359 OTableColumn::OTableColumn(const Reference<XPropertySet>& _xColumn)
360 {
361 DBG_CTOR(OTableColumn,NULL);
362
363 m_aTypeName = (::comphelper::getString(_xColumn->getPropertyValue(PROPERTY_TYPENAME)));
364 if(_xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_DEFAULTVALUE))
365 m_aDefaultValue = (::comphelper::getString(_xColumn->getPropertyValue(PROPERTY_DEFAULTVALUE)));
366 m_nIsNullable = (::comphelper::getINT32(_xColumn->getPropertyValue(PROPERTY_ISNULLABLE)));
367 m_nPrecision = (::comphelper::getINT32(_xColumn->getPropertyValue(PROPERTY_PRECISION)));
368 m_nScale = (::comphelper::getINT32(_xColumn->getPropertyValue(PROPERTY_SCALE)));
369 m_nType = (::comphelper::getINT32(_xColumn->getPropertyValue(PROPERTY_TYPE)));
370 m_bAutoIncrement = (::comphelper::getBOOL(_xColumn->getPropertyValue(PROPERTY_ISAUTOINCREMENT)));
371 m_bRowVersion = (sal_False);
372 m_bCurrency = (::comphelper::getBOOL(_xColumn->getPropertyValue(PROPERTY_ISCURRENCY)));
373 _xColumn->getPropertyValue(PROPERTY_NAME) >>= m_sName;
374 }
375 // -----------------------------------------------------------------------------
376 OTableColumn::~OTableColumn()
377 {
378 DBG_DTOR(OTableColumn,NULL);
379 }
380 // com::sun::star::lang::XTypeProvider
381 //--------------------------------------------------------------------------
382 Sequence< sal_Int8 > OTableColumn::getImplementationId() throw (RuntimeException)
383 {
384 static OImplementationId * pId = 0;
385 if (! pId)
386 {
387 MutexGuard aGuard( Mutex::getGlobalMutex() );
388 if (! pId)
389 {
390 static OImplementationId aId;
391 pId = &aId;
392 }
393 }
394 return pId->getImplementationId();
395 }
396
397 // ::com::sun::star::lang::XServiceInfo
398 //------------------------------------------------------------------------------
399 rtl::OUString OTableColumn::getImplementationName( ) throw (RuntimeException)
400 {
401 return rtl::OUString::createFromAscii("com.sun.star.sdb.OTableColumn");
402 }
403
404 //------------------------------------------------------------------------------
405 Sequence< ::rtl::OUString > OTableColumn::getSupportedServiceNames( ) throw (RuntimeException)
406 {
407 Sequence< ::rtl::OUString > aSNS( 2 );
408 aSNS[0] = SERVICE_SDBCX_COLUMN;
409 aSNS[1] = SERVICE_SDB_COLUMNSETTINGS;
410 return aSNS;
411 }
412
413 //------------------------------------------------------------------------------
414 ::cppu::IPropertyArrayHelper& OTableColumn::getInfoHelper()
415 {
416 return *static_cast< ::comphelper::OPropertyArrayUsageHelper< OTableColumn >* >(this)->getArrayHelper();
417 }
418
419 // comphelper::OPropertyArrayUsageHelper
420 //------------------------------------------------------------------------------
421 ::cppu::IPropertyArrayHelper* OTableColumn::createArrayHelper( ) const
422 {
423 BEGIN_PROPERTY_HELPER(19)
424 DECL_PROP2(ALIGN, sal_Int32, BOUND, MAYBEVOID);
425 DECL_PROP2(CONTROLDEFAULT, ::rtl::OUString, BOUND,MAYBEVOID);
426 DECL_PROP1_IFACE(CONTROLMODEL, XPropertySet , BOUND);
427 DECL_PROP1(DEFAULTVALUE, ::rtl::OUString, READONLY);
428 DECL_PROP1(DESCRIPTION, ::rtl::OUString, READONLY);
429 DECL_PROP2(NUMBERFORMAT, sal_Int32, BOUND, MAYBEVOID);
430 DECL_PROP2(HELPTEXT, ::rtl::OUString, BOUND,MAYBEVOID);
431 DECL_PROP1_BOOL(HIDDEN, BOUND);
432 DECL_PROP1_BOOL(ISAUTOINCREMENT, READONLY);
433 DECL_PROP1_BOOL(ISCURRENCY, READONLY);
434 DECL_PROP1(ISNULLABLE, sal_Int32, READONLY);
435 DECL_PROP1_BOOL(ISROWVERSION, READONLY);
436 DECL_PROP1(NAME, ::rtl::OUString, READONLY);
437 DECL_PROP1(PRECISION, sal_Int32, READONLY);
438 DECL_PROP2(RELATIVEPOSITION, sal_Int32, BOUND, MAYBEVOID);
439 DECL_PROP1(SCALE, sal_Int32, READONLY);
440 DECL_PROP1(TYPE, sal_Int32, READONLY);
441 DECL_PROP1(TYPENAME, ::rtl::OUString, READONLY);
442 DECL_PROP2(WIDTH, sal_Int32, BOUND, MAYBEVOID);
443 END_PROPERTY_HELPER();
444 }
445
446 //============================================================
447 //= OColumnWrapper
448 //============================================================
449 DBG_NAME(OColumnWrapper);
450 //--------------------------------------------------------------------------
451 OColumnWrapper::OColumnWrapper(const Reference< XPropertySet > & rCol)
452 :m_xAggregate(rCol)
453 ,m_nColTypeID(-1)
454 {
455 DBG_CTOR(OColumnWrapper,NULL);
456 // which type of aggregate property do we have
457 if (m_nColTypeID == -1)
458 {
459 // we distingish the properties by the containment of optional properties, these are:
460 // Description 0x0001
461 // Hidden 0x0002
462 // IsRowVersion 0x0004
463 m_nColTypeID = 0;
464 if ( m_xAggregate.is() )
465 {
466 Reference <XPropertySetInfo > xInfo(m_xAggregate->getPropertySetInfo());
467 m_nColTypeID |= xInfo->hasPropertyByName(PROPERTY_DESCRIPTION) ? HAS_DESCRIPTION : 0;
468 m_nColTypeID |= xInfo->hasPropertyByName(PROPERTY_DEFAULTVALUE) ? HAS_DEFAULTVALUE : 0;
469 m_nColTypeID |= xInfo->hasPropertyByName(PROPERTY_ISROWVERSION) ? HAS_ROWVERSION : 0;
470 m_nColTypeID |= xInfo->hasPropertyByName(PROPERTY_AUTOINCREMENTCREATION) ? HAS_AUTOINCREMENT_CREATION : 0;
471
472 m_xAggregate->getPropertyValue(PROPERTY_NAME) >>= m_sName;
473 }
474 }
475 }
476 // -----------------------------------------------------------------------------
477 OColumnWrapper::~OColumnWrapper()
478 {
479 DBG_DTOR(OColumnWrapper,NULL);
480 }
481
482 //------------------------------------------------------------------------------
483 void OColumnWrapper::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
484 {
485 switch (nHandle)
486 {
487 case PROPERTY_ID_NAME:
488 rValue <<= m_sName;
489 break;
490 default:
491 {
492 // get the property name
493 ::rtl::OUString aPropName;
494 sal_Int16 nAttributes;
495 const_cast<OColumnWrapper*>(this)->getInfoHelper().
496 fillPropertyMembersByHandle(&aPropName, &nAttributes, nHandle);
497 OSL_ENSURE(aPropName.getLength(), "property not found?");
498
499 // now read the value
500 rValue = m_xAggregate->getPropertyValue(aPropName);
501 }
502 }
503 }
504
505 //------------------------------------------------------------------------------
506 sal_Bool OColumnWrapper::convertFastPropertyValue(
507 Any & rConvertedValue,
508 Any & rOldValue,
509 sal_Int32 nHandle,
510 const Any& rValue )
511 throw (IllegalArgumentException)
512 {
513 // used for the name
514 sal_Bool bModified = OColumn::convertFastPropertyValue( rConvertedValue, rOldValue, nHandle, rValue );
515
516 // get the property name
517 ::rtl::OUString aPropName;
518 sal_Int16 nAttributes;
519 getInfoHelper().fillPropertyMembersByHandle(&aPropName, &nAttributes, nHandle);
520 OSL_ENSURE(aPropName.getLength(), "property not found?");
521
522 // now read the value
523 m_xAggregate->setPropertyValue(aPropName, rValue);
524 return bModified;
525 }
526
527 //------------------------------------------------------------------------------
528 void OColumnWrapper::setFastPropertyValue_NoBroadcast(
529 sal_Int32 nHandle,
530 const Any& rValue
531 )
532 throw (Exception)
533 {
534 OColumn::setFastPropertyValue_NoBroadcast( nHandle, rValue );
535 }
536 // -----------------------------------------------------------------------------
537 sal_Int64 SAL_CALL OColumnWrapper::getSomething( const Sequence< sal_Int8 >& aIdentifier ) throw(RuntimeException)
538 {
539 sal_Int64 nRet = OColumn::getSomething(aIdentifier);
540 if(!nRet)
541 {
542 Reference<XUnoTunnel> xTunnel(m_xAggregate,UNO_QUERY);
543 if(xTunnel.is())
544 nRet = xTunnel->getSomething(aIdentifier);
545 }
546 return nRet;
547 }
548 //============================================================
549 //= OTableColumnDescriptorWrapper
550 //============================================================
551 // com::sun::star::lang::XTypeProvider
552 //--------------------------------------------------------------------------
553 Sequence< sal_Int8 > OTableColumnDescriptorWrapper::getImplementationId() throw (RuntimeException)
554 {
555 static OImplementationId * pId = 0;
556 if (! pId)
557 {
558 MutexGuard aGuard( Mutex::getGlobalMutex() );
559 if (! pId)
560 {
561 static OImplementationId aId;
562 pId = &aId;
563 }
564 }
565 return pId->getImplementationId();
566 }
567
568 // ::com::sun::star::lang::XServiceInfo
569 //------------------------------------------------------------------------------
570 rtl::OUString OTableColumnDescriptorWrapper::getImplementationName( ) throw (RuntimeException)
571 {
572 return rtl::OUString::createFromAscii("com.sun.star.sdb.OTableColumnDescriptorWrapper");
573 }
574
575 //------------------------------------------------------------------------------
576 Sequence< ::rtl::OUString > OTableColumnDescriptorWrapper::getSupportedServiceNames( ) throw (RuntimeException)
577 {
578 Sequence< ::rtl::OUString > aSNS( 2 );
579 aSNS[0] = SERVICE_SDBCX_COLUMNDESCRIPTOR;
580 aSNS[1] = SERVICE_SDB_COLUMNSETTINGS;
581 return aSNS;
582 }
583
584 // -----------------------------------------------------------------------------
585 sal_Int64 SAL_CALL OTableColumnDescriptorWrapper::getSomething( const Sequence< sal_Int8 >& aIdentifier ) throw(RuntimeException)
586 {
587 sal_Int64 nReturn = OColumnWrapper::getSomething( aIdentifier );
588 if ( !nReturn )
589 nReturn = OColumnSettings::getSomething( aIdentifier );
590 return nReturn;
591 }
592
593 // comphelper::OPropertyArrayUsageHelper
594 //------------------------------------------------------------------------------
595 ::cppu::IPropertyArrayHelper* OTableColumnDescriptorWrapper::createArrayHelper( sal_Int32 nId ) const
596 {
597 // BEGIN_PROPERTY_HELPER(17)
598 sal_Int32 nPropertyCount = 16;
599 // How many properties do we have?
600 // Which optional properties are contained?
601 if (nId & HAS_DESCRIPTION)
602 ++nPropertyCount;
603 if (nId & HAS_DEFAULTVALUE)
604 ++nPropertyCount;
605 if (nId & HAS_ROWVERSION)
606 ++nPropertyCount;
607 if ( nId & HAS_AUTOINCREMENT_CREATION )
608 ++nPropertyCount;
609
610 Sequence< Property> aDescriptor(nPropertyCount);
611 Property* pDesc = aDescriptor.getArray();
612 sal_Int32 nPos = 0;
613
614 // Description, Defaultvalue, IsRowVersion
615 DECL_PROP2(ALIGN, sal_Int32, BOUND,MAYBEVOID);
616 if ( nId & HAS_AUTOINCREMENT_CREATION )
617 {
618 DECL_PROP1(AUTOINCREMENTCREATION,::rtl::OUString, MAYBEVOID);
619 }
620 DECL_PROP2(CONTROLDEFAULT, ::rtl::OUString, BOUND,MAYBEVOID);
621 DECL_PROP1_IFACE(CONTROLMODEL, XPropertySet, BOUND );
622 if (nId & HAS_DEFAULTVALUE)
623 {
624 DECL_PROP0(DEFAULTVALUE, ::rtl::OUString );
625 }
626
627 if (nId & HAS_DESCRIPTION)
628 {
629 DECL_PROP0(DESCRIPTION, ::rtl::OUString );
630 }
631
632 DECL_PROP2(NUMBERFORMAT, sal_Int32, BOUND,MAYBEVOID);
633 DECL_PROP2(HELPTEXT, ::rtl::OUString, BOUND,MAYBEVOID);
634 DECL_PROP1_BOOL(HIDDEN, BOUND);
635 DECL_PROP0_BOOL(ISAUTOINCREMENT );
636 DECL_PROP0_BOOL(ISCURRENCY );
637 DECL_PROP0(ISNULLABLE, sal_Int32 );
638
639 if (nId & HAS_ROWVERSION)
640 {
641 DECL_PROP0_BOOL(ISROWVERSION );
642 }
643
644 DECL_PROP0(NAME, ::rtl::OUString );
645 DECL_PROP0(PRECISION, sal_Int32 );
646 DECL_PROP2(RELATIVEPOSITION, sal_Int32, BOUND, MAYBEVOID);
647 DECL_PROP0(SCALE, sal_Int32 );
648 DECL_PROP0(TYPE, sal_Int32 );
649 DECL_PROP0(TYPENAME, ::rtl::OUString );
650 DECL_PROP1(WIDTH, sal_Int32, MAYBEVOID);
651 END_PROPERTY_HELPER();
652 }
653
654 // cppu::OPropertySetHelper
655 //------------------------------------------------------------------------------
656 ::cppu::IPropertyArrayHelper& OTableColumnDescriptorWrapper::getInfoHelper()
657 {
658 return *static_cast< OIdPropertyArrayUsageHelper< OTableColumnDescriptorWrapper >* >(this)->getArrayHelper(m_nColTypeID);
659 }
660
661 //------------------------------------------------------------------------------
662 void OTableColumnDescriptorWrapper::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
663 {
664 if ( m_bPureWrap )
665 {
666 // get the property name
667 ::rtl::OUString aPropName;
668 sal_Int16 nAttributes;
669 const_cast<OTableColumnDescriptorWrapper*>(this)->getInfoHelper().
670 fillPropertyMembersByHandle(&aPropName, &nAttributes, nHandle);
671 OSL_ENSURE(aPropName.getLength(), "property not found?");
672
673 // now read the value
674 rValue = m_xAggregate->getPropertyValue(aPropName);
675 }
676 else
677 {
678 switch (nHandle)
679 {
680 case PROPERTY_ID_ALIGN:
681 case PROPERTY_ID_NUMBERFORMAT:
682 case PROPERTY_ID_RELATIVEPOSITION:
683 case PROPERTY_ID_WIDTH:
684 case PROPERTY_ID_HIDDEN:
685 case PROPERTY_ID_CONTROLMODEL:
686 case PROPERTY_ID_HELPTEXT:
687 case PROPERTY_ID_CONTROLDEFAULT:
688 OColumnSettings::getFastPropertyValue( rValue, nHandle );
689 break;
690 default:
691 {
692 // get the property name
693 ::rtl::OUString aPropName;
694 sal_Int16 nAttributes;
695 const_cast<OTableColumnDescriptorWrapper*>(this)->getInfoHelper().
696 fillPropertyMembersByHandle(&aPropName, &nAttributes, nHandle);
697 OSL_ENSURE(aPropName.getLength(), "property not found?");
698
699 // now read the value
700 rValue = m_xAggregate->getPropertyValue(aPropName);
701 }
702 }
703 }
704 }
705
706 //------------------------------------------------------------------------------
707 sal_Bool OTableColumnDescriptorWrapper::convertFastPropertyValue(
708 Any & rConvertedValue,
709 Any & rOldValue,
710 sal_Int32 nHandle,
711 const Any& rValue )
712 throw (IllegalArgumentException)
713 {
714 sal_Bool bModified(sal_False);
715 if ( m_bPureWrap )
716 bModified = OColumnWrapper::convertFastPropertyValue( rConvertedValue, rOldValue, nHandle, rValue );
717 else
718 {
719 switch (nHandle)
720 {
721 case PROPERTY_ID_ALIGN:
722 case PROPERTY_ID_NUMBERFORMAT:
723 case PROPERTY_ID_RELATIVEPOSITION:
724 case PROPERTY_ID_WIDTH:
725 case PROPERTY_ID_HIDDEN:
726 case PROPERTY_ID_CONTROLMODEL:
727 case PROPERTY_ID_HELPTEXT:
728 case PROPERTY_ID_CONTROLDEFAULT:
729 bModified = OColumnSettings::convertFastPropertyValue( rConvertedValue, rOldValue, nHandle, rValue );
730 break;
731 default:
732 bModified = OColumnWrapper::convertFastPropertyValue( rConvertedValue, rOldValue, nHandle, rValue );
733 }
734 }
735 return bModified;
736 }
737
738 //------------------------------------------------------------------------------
739 void OTableColumnDescriptorWrapper::setFastPropertyValue_NoBroadcast(
740 sal_Int32 nHandle,
741 const Any& rValue
742 )
743 throw (Exception)
744 {
745 if ( m_bPureWrap )
746 OColumnWrapper::setFastPropertyValue_NoBroadcast( nHandle, rValue );
747 else
748 {
749 switch (nHandle)
750 {
751 case PROPERTY_ID_ALIGN:
752 case PROPERTY_ID_NUMBERFORMAT:
753 case PROPERTY_ID_RELATIVEPOSITION:
754 case PROPERTY_ID_WIDTH:
755 case PROPERTY_ID_HIDDEN:
756 case PROPERTY_ID_CONTROLMODEL:
757 case PROPERTY_ID_HELPTEXT:
758 case PROPERTY_ID_CONTROLDEFAULT:
759 OColumnSettings::setFastPropertyValue_NoBroadcast( nHandle, rValue );
760 break;
761 default:
762 OColumnWrapper::setFastPropertyValue_NoBroadcast( nHandle, rValue );
763 }
764 }
765 }
766
767 //============================================================
768 //= OTableColumnWrapper
769 //============================================================
770 //--------------------------------------------------------------------------
771 OTableColumnWrapper::OTableColumnWrapper(const Reference< XPropertySet >& rCol
772 ,const Reference< XPropertySet >& _xColDefintion
773 ,sal_Bool _bPureWrap)
774 :OTableColumnDescriptorWrapper(rCol,_bPureWrap)
775 {
776 osl_incrementInterlockedCount(&m_refCount);
777 if ( _xColDefintion.is() )
778 {
779 try
780 {
781 ::comphelper::copyProperties(_xColDefintion,this);
782 }
783 catch(Exception&)
784 {
785 OSL_ENSURE(sal_False, "OTableColumnWrapper::OTableColumnWrapper: caught an exception!");
786 }
787 }
788 osl_decrementInterlockedCount(&m_refCount);
789 }
790
791 //--------------------------------------------------------------------------
792 OTableColumnWrapper::~OTableColumnWrapper()
793 {
794 }
795
796 // com::sun::star::lang::XTypeProvider
797 //--------------------------------------------------------------------------
798 Sequence< sal_Int8 > OTableColumnWrapper::getImplementationId() throw (RuntimeException)
799 {
800 static OImplementationId * pId = 0;
801 if (! pId)
802 {
803 MutexGuard aGuard( Mutex::getGlobalMutex() );
804 if (! pId)
805 {
806 static OImplementationId aId;
807 pId = &aId;
808 }
809 }
810 return pId->getImplementationId();
811 }
812 // ::com::sun::star::lang::XServiceInfo
813 //------------------------------------------------------------------------------
814 rtl::OUString OTableColumnWrapper::getImplementationName( ) throw (RuntimeException)
815 {
816 return rtl::OUString::createFromAscii("com.sun.star.sdb.OTableColumnWrapper");
817 }
818
819 //------------------------------------------------------------------------------
820 Sequence< ::rtl::OUString > OTableColumnWrapper::getSupportedServiceNames( ) throw (RuntimeException)
821 {
822 Sequence< ::rtl::OUString > aSNS( 2 );
823 aSNS[0] = SERVICE_SDBCX_COLUMN;
824 aSNS[1] = SERVICE_SDB_COLUMNSETTINGS;
825 return aSNS;
826 }
827
828 //------------------------------------------------------------------------------
829 ::cppu::IPropertyArrayHelper& OTableColumnWrapper::getInfoHelper()
830 {
831 return *static_cast< OIdPropertyArrayUsageHelper< OTableColumnWrapper >* >(this)->getArrayHelper(m_nColTypeID);
832 }
833
834 // comphelper::OPropertyArrayUsageHelper
835 //------------------------------------------------------------------------------
836 ::cppu::IPropertyArrayHelper* OTableColumnWrapper::createArrayHelper( sal_Int32 nId ) const
837 {
838 // BEGIN_PROPERTY_HELPER(17)
839 sal_Int32 nPropertyCount = 16;
840 // How many properties do we have?
841 // Which optional properties are contained?
842 if (nId & HAS_DESCRIPTION)
843 nPropertyCount++;
844 if (nId & HAS_DEFAULTVALUE)
845 nPropertyCount++;
846 if (nId & HAS_ROWVERSION)
847 nPropertyCount++;
848 if ( nId & HAS_AUTOINCREMENT_CREATION )
849 ++nPropertyCount;
850
851 Sequence< Property> aDescriptor(nPropertyCount);
852 Property* pDesc = aDescriptor.getArray();
853 sal_Int32 nPos = 0;
854
855 // Description, Defaultvalue, IsRowVersion
856 DECL_PROP2(ALIGN, sal_Int32, BOUND, MAYBEVOID);
857 if ( nId & HAS_AUTOINCREMENT_CREATION )
858 {
859 DECL_PROP1(AUTOINCREMENTCREATION,::rtl::OUString, MAYBEVOID);
860 }
861 DECL_PROP2(CONTROLDEFAULT, ::rtl::OUString, BOUND,MAYBEVOID);
862 DECL_PROP1_IFACE(CONTROLMODEL, XPropertySet , BOUND);
863 if (nId & HAS_DEFAULTVALUE)
864 {
865 DECL_PROP1(DEFAULTVALUE, ::rtl::OUString, READONLY);
866 }
867
868 if (nId & HAS_DESCRIPTION)
869 {
870 DECL_PROP1(DESCRIPTION, ::rtl::OUString, READONLY);
871 }
872
873 DECL_PROP2(NUMBERFORMAT, sal_Int32, BOUND, MAYBEVOID);
874 DECL_PROP2(HELPTEXT, ::rtl::OUString, BOUND,MAYBEVOID);
875 DECL_PROP1_BOOL(HIDDEN, BOUND);
876 DECL_PROP1_BOOL(ISAUTOINCREMENT, READONLY);
877 DECL_PROP1_BOOL(ISCURRENCY, READONLY);
878
879 DECL_PROP1(ISNULLABLE, sal_Int32, READONLY);
880
881 if (nId & HAS_ROWVERSION)
882 {
883 DECL_PROP1_BOOL(ISROWVERSION, READONLY);
884 }
885
886 DECL_PROP1(NAME, ::rtl::OUString, READONLY);
887 DECL_PROP1(PRECISION, sal_Int32, READONLY);
888 DECL_PROP2(RELATIVEPOSITION, sal_Int32, BOUND, MAYBEVOID);
889 DECL_PROP1(SCALE, sal_Int32, READONLY);
890 DECL_PROP1(TYPE, sal_Int32, READONLY);
891 DECL_PROP1(TYPENAME, ::rtl::OUString, READONLY);
892 DECL_PROP2(WIDTH, sal_Int32, BOUND, MAYBEVOID);
893 END_PROPERTY_HELPER();
894 }
895
896 //============================================================
897 //= OIndexColumnWrapper
898 //============================================================
899 // com::sun::star::lang::XTypeProvider
900 //--------------------------------------------------------------------------
901 Sequence< sal_Int8 > OIndexColumnWrapper::getImplementationId() throw (RuntimeException)
902 {
903 static OImplementationId * pId = 0;
904 if (! pId)
905 {
906 MutexGuard aGuard( Mutex::getGlobalMutex() );
907 if (! pId)
908 {
909 static OImplementationId aId;
910 pId = &aId;
911 }
912 }
913 return pId->getImplementationId();
914 }
915 // ::com::sun::star::lang::XServiceInfo
916 //------------------------------------------------------------------------------
917 rtl::OUString OIndexColumnWrapper::getImplementationName( ) throw (RuntimeException)
918 {
919 return rtl::OUString::createFromAscii("com.sun.star.sdb.OIndexColumnWrapper");
920 }
921
922 //------------------------------------------------------------------------------
923 Sequence< ::rtl::OUString > OIndexColumnWrapper::getSupportedServiceNames( ) throw (RuntimeException)
924 {
925 Sequence< ::rtl::OUString > aSNS( 2 );
926 aSNS[0] = SERVICE_SDBCX_COLUMN;
927 aSNS[1] = SERVICE_SDBCX_INDEXCOLUMN;
928 return aSNS;
929 }
930
931 //------------------------------------------------------------------------------
932 ::cppu::IPropertyArrayHelper& OIndexColumnWrapper::getInfoHelper()
933 {
934 return *static_cast< OPropertyArrayUsageHelper< OIndexColumnWrapper >* >(this)->getArrayHelper();
935 }
936
937 // comphelper::OPropertyArrayUsageHelper
938 //------------------------------------------------------------------------------
939 ::cppu::IPropertyArrayHelper* OIndexColumnWrapper::createArrayHelper() const
940 {
941 BEGIN_PROPERTY_HELPER(9)
942 DECL_PROP1_BOOL(ISASCENDING, READONLY);
943 DECL_PROP1_BOOL(ISAUTOINCREMENT, READONLY);
944 DECL_PROP1_BOOL(ISCURRENCY, READONLY);
945 DECL_PROP1(ISNULLABLE, sal_Int32, READONLY);
946 DECL_PROP1(NAME, ::rtl::OUString, READONLY);
947 DECL_PROP1(PRECISION, sal_Int32, READONLY);
948 DECL_PROP1(SCALE, sal_Int32, READONLY);
949 DECL_PROP1(TYPE, sal_Int32, READONLY);
950 DECL_PROP1(TYPENAME, ::rtl::OUString, READONLY);
951 END_PROPERTY_HELPER();
952 }
953
954 //------------------------------------------------------------------------------
955 void OIndexColumnWrapper::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
956 {
957 switch (nHandle)
958 {
959 case PROPERTY_ID_ISASCENDING:
960 {
961 sal_Bool bVal = m_bAscending;
962 rValue.setValue(&bVal, getBooleanCppuType());
963 } break;
964 default:
965 OColumnWrapper::getFastPropertyValue( rValue, nHandle );
966 }
967 }
968
969 //============================================================
970 //= OKeyColumnWrapper
971 //============================================================
972 // com::sun::star::lang::XTypeProvider
973 //--------------------------------------------------------------------------
974 Sequence< sal_Int8 > OKeyColumnWrapper::getImplementationId() throw (RuntimeException)
975 {
976 static OImplementationId * pId = 0;
977 if (! pId)
978 {
979 MutexGuard aGuard( Mutex::getGlobalMutex() );
980 if (! pId)
981 {
982 static OImplementationId aId;
983 pId = &aId;
984 }
985 }
986 return pId->getImplementationId();
987 }
988 // ::com::sun::star::lang::XServiceInfo
989 //------------------------------------------------------------------------------
990 rtl::OUString OKeyColumnWrapper::getImplementationName( ) throw (RuntimeException)
991 {
992 return rtl::OUString::createFromAscii("com.sun.star.sdb.OIndexColumnWrapper");
993 }
994
995 //------------------------------------------------------------------------------
996 Sequence< ::rtl::OUString > OKeyColumnWrapper::getSupportedServiceNames( ) throw (RuntimeException)
997 {
998 Sequence< ::rtl::OUString > aSNS( 2 );
999 aSNS[0] = SERVICE_SDBCX_COLUMN;
1000 aSNS[1] = SERVICE_SDBCX_KEYCOLUMN;
1001 return aSNS;
1002 }
1003
1004 //------------------------------------------------------------------------------
1005 ::cppu::IPropertyArrayHelper& OKeyColumnWrapper::getInfoHelper()
1006 {
1007 return *static_cast< OPropertyArrayUsageHelper< OKeyColumnWrapper >* >(this)->getArrayHelper();
1008 }
1009
1010 // comphelper::OPropertyArrayUsageHelper
1011 //------------------------------------------------------------------------------
1012 ::cppu::IPropertyArrayHelper* OKeyColumnWrapper::createArrayHelper() const
1013 {
1014 BEGIN_PROPERTY_HELPER(9)
1015 DECL_PROP1_BOOL(ISAUTOINCREMENT, READONLY);
1016 DECL_PROP1_BOOL(ISCURRENCY, READONLY);
1017 DECL_PROP1(ISNULLABLE, sal_Int32, READONLY);
1018 DECL_PROP1(NAME, ::rtl::OUString, READONLY);
1019 DECL_PROP1(PRECISION, sal_Int32, READONLY);
1020 DECL_PROP1(RELATEDCOLUMN, ::rtl::OUString, READONLY);
1021 DECL_PROP1(SCALE, sal_Int32, READONLY);
1022 DECL_PROP1(TYPE, sal_Int32, READONLY);
1023 DECL_PROP1(TYPENAME, ::rtl::OUString, READONLY);
1024 END_PROPERTY_HELPER();
1025 }
1026
1027 //------------------------------------------------------------------------------
1028 void OKeyColumnWrapper::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const
1029 {
1030 switch (nHandle)
1031 {
1032 case PROPERTY_ID_RELATEDCOLUMN:
1033 rValue <<= m_aRelatedColumn;
1034 break;
1035 default:
1036 OColumnWrapper::getFastPropertyValue( rValue, nHandle );
1037 }
1038 }
1039
1040
vba interoperability for OOo