forms/source/component/Columns.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "Columns.hxx"
  21 #include <property.hxx>
  22 #include <componenttools.hxx>
  23 #include "findpos.hxx"
  24 #include <com/sun/star/beans/PropertyAttribute.hpp>
  25 #include <com/sun/star/io/XPersistObject.hpp>
  26 #include <com/sun/star/io/XMarkableStream.hpp>
  27 #include <com/sun/star/form/XFormComponent.hpp>
  28 #include <com/sun/star/lang/XServiceInfo.hpp>
  29 #include <com/sun/star/form/binding/XBindableValue.hpp>
  30 #include <com/sun/star/beans/XPropertyContainer.hpp>
  31 #include <com/sun/star/text/XText.hpp>
  32 #include <comphelper/property.hxx>
  33 #include <comphelper/basicio.hxx>
  34 #include <comphelper/servicehelper.hxx>
  35 #include <comphelper/types.hxx>
  36 #include <services.hxx>
  37 #include <tools/debug.hxx>
  38 #include <o3tl/sorted_vector.hxx>
  39 #include <utility>
  40
  41
  42 namespace frm
  43 {
  44
  45 using namespace ::com::sun::star::uno;
  46 using namespace ::com::sun::star::beans;
  47 using namespace ::com::sun::star::container;
  48 using namespace ::com::sun::star::form;
  49 using namespace ::com::sun::star::io;
  50 using namespace ::com::sun::star::lang;
  51 using namespace ::com::sun::star::util;
  52 using namespace ::com::sun::star::text;
  53 using namespace ::com::sun::star::form::binding;
  54
  55 const sal_uInt16 WIDTH              = 0x0001;
  56 const sal_uInt16 ALIGN              = 0x0002;
  57 const sal_uInt16 OLD_HIDDEN         = 0x0004;
  58 const sal_uInt16 COMPATIBLE_HIDDEN  = 0x0008;
  59
  60
  61 const css::uno::Sequence<OUString>& getColumnTypes()
  62 {
  63     static css::uno::Sequence<OUString> aColumnTypes = []()
  64     {
  65         css::uno::Sequence<OUString> tmp(10);
  66         OUString* pNames = tmp.getArray();
  67         pNames[TYPE_CHECKBOX]       = "CheckBox";
  68         pNames[TYPE_COMBOBOX]       = "ComboBox";
  69         pNames[TYPE_CURRENCYFIELD]  = "CurrencyField";
  70         pNames[TYPE_DATEFIELD]      = "DateField";
  71         pNames[TYPE_FORMATTEDFIELD] = "FormattedField";
  72         pNames[TYPE_LISTBOX]        = "ListBox";
  73         pNames[TYPE_NUMERICFIELD]   = "NumericField";
  74         pNames[TYPE_PATTERNFIELD]   = "PatternField";
  75         pNames[TYPE_TEXTFIELD]      = "TextField";
  76         pNames[TYPE_TIMEFIELD]      = "TimeField";
  77         return tmp;
  78     }();
  79     return aColumnTypes;
  80 }
  81
  82
  83 sal_Int32 getColumnTypeByModelName(const OUString& aModelName)
  84 {
  85     static constexpr OUString aModelPrefix (u"com.sun.star.form.component."_ustr);
  86     static constexpr OUString aCompatibleModelPrefix (u"stardiv.one.form.component."_ustr);
  87
  88     sal_Int32 nTypeId = -1;
  89     if (aModelName == FRM_COMPONENT_EDIT)
  90         nTypeId = TYPE_TEXTFIELD;
  91     else
  92     {
  93         sal_Int32 nPrefixPos = aModelName.indexOf(aModelPrefix);
  94 #ifdef DBG_UTIL
  95         sal_Int32 nCompatiblePrefixPos = aModelName.indexOf(aCompatibleModelPrefix);
  96         DBG_ASSERT( (nPrefixPos != -1) ||   (nCompatiblePrefixPos != -1),
  97                 "::getColumnTypeByModelName() : wrong service!");
  98 #endif
  99
 100         OUString aColumnType = (nPrefixPos != -1)
 101             ? aModelName.copy(aModelPrefix.getLength())
 102             : aModelName.copy(aCompatibleModelPrefix.getLength());
 103
 104         const css::uno::Sequence<OUString>& rColumnTypes = getColumnTypes();
 105         nTypeId = ::detail::findPos(aColumnType, rColumnTypes);
 106     }
 107     return nTypeId;
 108 }
 109
 110 const Sequence<sal_Int8>& OGridColumn::getUnoTunnelId()
 111 {
 112     static const comphelper::UnoIdInit theOGridColumnImplementationId;
 113     return theOGridColumnImplementationId.getSeq();
 114 }
 115
 116
 117 sal_Int64 SAL_CALL OGridColumn::getSomething( const Sequence<sal_Int8>& _rIdentifier)
 118 {
 119     sal_Int64 nReturn(0);
 120
 121     if ( comphelper::isUnoTunnelId<OGridColumn>(_rIdentifier) )
 122     {
 123         nReturn = comphelper::getSomething_cast(this);
 124     }
 125     else
 126     {
 127         if (auto xAggTunnel = query_aggregation<XUnoTunnel>(m_xAggregate))
 128             return xAggTunnel->getSomething( _rIdentifier );
 129     }
 130     return nReturn;
 131 }
 132
 133
 134 Sequence<sal_Int8> SAL_CALL OGridColumn::getImplementationId()
 135 {
 136     return css::uno::Sequence<sal_Int8>();
 137 }
 138
 139
 140 Sequence<Type> SAL_CALL OGridColumn::getTypes()
 141 {
 142     TypeBag aTypes( OGridColumn_BASE::getTypes() );
 143     // erase the types which we do not support
 144     aTypes.removeType( cppu::UnoType<XFormComponent>::get() );
 145     aTypes.removeType( cppu::UnoType<XServiceInfo>::get() );
 146     aTypes.removeType( cppu::UnoType<XBindableValue>::get() );
 147     aTypes.removeType( cppu::UnoType<XPropertyContainer>::get() );
 148
 149     // but re-add their base class(es)
 150     aTypes.addType( cppu::UnoType<XChild>::get() );
 151
 152     if (auto xProv = query_aggregation<XTypeProvider>(m_xAggregate))
 153         aTypes.addTypes( xProv->getTypes() );
 154
 155     aTypes.removeType( cppu::UnoType<XTextRange>::get() );
 156     aTypes.removeType( cppu::UnoType<XSimpleText>::get() );
 157     aTypes.removeType( cppu::UnoType<XText>::get() );
 158
 159     return aTypes.getTypes();
 160 }
 161
 162
 163 Any SAL_CALL OGridColumn::queryAggregation( const Type& _rType )
 164 {
 165     Any aReturn;
 166     // some functionality at our aggregate cannot be reasonably fulfilled here.
 167     if  (   _rType.equals(cppu::UnoType<XFormComponent>::get())
 168         ||  _rType.equals(cppu::UnoType<XServiceInfo>::get())
 169         ||  _rType.equals(cppu::UnoType<XBindableValue>::get())
 170         ||  _rType.equals(cppu::UnoType<XPropertyContainer>::get())
 171         ||  comphelper::isAssignableFrom(cppu::UnoType<XTextRange>::get(),_rType)
 172         )
 173         return aReturn;
 174
 175     aReturn = OGridColumn_BASE::queryAggregation(_rType);
 176     if (!aReturn.hasValue())
 177     {
 178         aReturn = OPropertySetAggregationHelper::queryInterface(_rType);
 179         if (!aReturn.hasValue() && m_xAggregate.is())
 180             aReturn = m_xAggregate->queryAggregation(_rType);
 181     }
 182
 183     return aReturn;
 184 }
 185
 186
 187 OGridColumn::OGridColumn( const Reference<XComponentContext>& _rContext, OUString _sModelName )
 188     :OGridColumn_BASE(m_aMutex)
 189     ,OPropertySetAggregationHelper(OGridColumn_BASE::rBHelper)
 190     ,m_aHidden( Any( false ) )
 191     ,m_aModelName(std::move(_sModelName))
 192 {
 193
 194     // Create the UnoControlModel
 195     if ( m_aModelName.isEmpty() ) // is there a to-be-aggregated model?
 196         return;
 197
 198     osl_atomic_increment( &m_refCount );
 199
 200     {
 201         m_xAggregate.set( _rContext->getServiceManager()->createInstanceWithContext( m_aModelName, _rContext ), UNO_QUERY );
 202         setAggregation( m_xAggregate );
 203     }
 204
 205     if ( m_xAggregate.is() )
 206     {   // don't omit those brackets - they ensure that the following temporary is properly deleted
 207         m_xAggregate->setDelegator( static_cast< ::cppu::OWeakObject* >( this ) );
 208     }
 209
 210     // Set refcount back to zero
 211     osl_atomic_decrement( &m_refCount );
 212 }
 213
 214
 215 OGridColumn::OGridColumn( const OGridColumn* _pOriginal )
 216     :OGridColumn_BASE( m_aMutex )
 217     ,OPropertySetAggregationHelper( OGridColumn_BASE::rBHelper )
 218 {
 219
 220     m_aWidth = _pOriginal->m_aWidth;
 221     m_aAlign = _pOriginal->m_aAlign;
 222     m_aHidden = _pOriginal->m_aHidden;
 223     m_aModelName = _pOriginal->m_aModelName;
 224     m_aLabel = _pOriginal->m_aLabel;
 225
 226     osl_atomic_increment( &m_refCount );
 227     {
 228         {
 229             m_xAggregate = createAggregateClone( _pOriginal );
 230             setAggregation( m_xAggregate );
 231         }
 232
 233         if ( m_xAggregate.is() )
 234         {   // don't omit this brackets - they ensure that the following temporary is properly deleted
 235             m_xAggregate->setDelegator( static_cast< ::cppu::OWeakObject* >( this ) );
 236         }
 237     }
 238     osl_atomic_decrement( &m_refCount );
 239 }
 240
 241
 242 OGridColumn::~OGridColumn()
 243 {
 244     if (!OGridColumn_BASE::rBHelper.bDisposed)
 245     {
 246         acquire();
 247         dispose();
 248     }
 249
 250     // Free the aggregate
 251     if (m_xAggregate.is())
 252     {
 253         css::uno::Reference<css::uno::XInterface>  xIface;
 254         m_xAggregate->setDelegator(xIface);
 255     }
 256
 257 }
 258
 259 // XEventListener
 260
 261 void SAL_CALL OGridColumn::disposing(const EventObject& _rSource)
 262 {
 263     OPropertySetAggregationHelper::disposing(_rSource);
 264
 265     if (auto xEvtLstner = query_aggregation<XEventListener>(m_xAggregate))
 266         xEvtLstner->disposing(_rSource);
 267 }
 268
 269 // OGridColumn_BASE
 270
 271 void OGridColumn::disposing()
 272 {
 273     OGridColumn_BASE::disposing();
 274     OPropertySetAggregationHelper::disposing();
 275
 276     if (auto xComp = query_aggregation<XComponent>(m_xAggregate))
 277         xComp->dispose();
 278 }
 279
 280
 281 void OGridColumn::clearAggregateProperties( Sequence< Property >& _rProps, bool bAllowDropDown )
 282 {
 283     // some properties are not to be exposed to the outer world
 284     static const o3tl::sorted_vector< OUString > aForbiddenProperties {
 285       PROPERTY_ALIGN,
 286       PROPERTY_AUTOCOMPLETE,
 287       PROPERTY_BACKGROUNDCOLOR,
 288       PROPERTY_BORDER,
 289       PROPERTY_BORDERCOLOR,
 290       PROPERTY_ECHO_CHAR,
 291       PROPERTY_FILLCOLOR,
 292       PROPERTY_FONT,
 293       PROPERTY_FONT_NAME,
 294       PROPERTY_FONT_STYLENAME,
 295       PROPERTY_FONT_FAMILY,
 296       PROPERTY_FONT_CHARSET,
 297       PROPERTY_FONT_HEIGHT,
 298       PROPERTY_FONT_WEIGHT,
 299       PROPERTY_FONT_SLANT,
 300       PROPERTY_FONT_UNDERLINE,
 301       PROPERTY_FONT_STRIKEOUT,
 302       PROPERTY_FONT_WORDLINEMODE,
 303       PROPERTY_TEXTLINECOLOR,
 304       PROPERTY_FONTEMPHASISMARK,
 305       PROPERTY_FONTRELIEF,
 306       PROPERTY_HARDLINEBREAKS,
 307       PROPERTY_HSCROLL,
 308       PROPERTY_LABEL,
 309       PROPERTY_LINECOLOR,
 310       PROPERTY_MULTISELECTION,
 311       PROPERTY_PRINTABLE,
 312       PROPERTY_TABINDEX,
 313       PROPERTY_TABSTOP,
 314       PROPERTY_TEXTCOLOR,
 315       PROPERTY_VSCROLL,
 316       PROPERTY_CONTROLLABEL,
 317       PROPERTY_RICH_TEXT,
 318       PROPERTY_VERTICAL_ALIGN,
 319       PROPERTY_IMAGE_URL,
 320       PROPERTY_IMAGE_POSITION,
 321       PROPERTY_ENABLEVISIBLE
 322     };
 323
 324     Sequence< Property > aNewProps( _rProps.getLength() );
 325     Property* pNewProps = aNewProps.getArray();
 326
 327     const Property* pProps = _rProps.getConstArray();
 328     const Property* pPropsEnd = pProps + _rProps.getLength();
 329     for ( ; pProps != pPropsEnd; ++pProps )
 330     {
 331         if ( aForbiddenProperties.find( pProps->Name ) == aForbiddenProperties.end()
 332             && (bAllowDropDown || pProps->Name != PROPERTY_DROPDOWN))
 333             *pNewProps++ = *pProps;
 334     }
 335
 336     aNewProps.realloc( pNewProps - aNewProps.getArray() );
 337     _rProps = std::move(aNewProps);
 338 }
 339
 340
 341 void OGridColumn::setOwnProperties(Sequence<Property>& aDescriptor)
 342 {
 343     aDescriptor.realloc(5);
 344     Property* pProperties = aDescriptor.getArray();
 345     *pProperties++ = css::beans::Property(PROPERTY_LABEL, PROPERTY_ID_LABEL, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::BOUND);
 346     *pProperties++ = css::beans::Property(PROPERTY_WIDTH, PROPERTY_ID_WIDTH, cppu::UnoType<sal_Int32>::get(), css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::MAYBEVOID | css::beans::PropertyAttribute::MAYBEDEFAULT);
 347     *pProperties++ = css::beans::Property(PROPERTY_ALIGN, PROPERTY_ID_ALIGN, cppu::UnoType<sal_Int16>::get(), css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::MAYBEVOID | css::beans::PropertyAttribute::MAYBEDEFAULT);
 348     *pProperties++ = css::beans::Property(PROPERTY_HIDDEN, PROPERTY_ID_HIDDEN, cppu::UnoType<bool>::get(),
 349                                           css::beans::PropertyAttribute::BOUND | css::beans::PropertyAttribute::MAYBEDEFAULT);
 350     *pProperties++ = css::beans::Property(PROPERTY_COLUMNSERVICENAME, PROPERTY_ID_COLUMNSERVICENAME, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::READONLY);
 351 }
 352
 353 // Reference<XPropertySet>
 354
 355 void OGridColumn::getFastPropertyValue(Any& rValue, sal_Int32 nHandle ) const
 356 {
 357     switch (nHandle)
 358     {
 359         case PROPERTY_ID_COLUMNSERVICENAME:
 360             rValue <<= m_aModelName;
 361             break;
 362         case PROPERTY_ID_LABEL:
 363             rValue <<= m_aLabel;
 364             break;
 365         case PROPERTY_ID_WIDTH:
 366             rValue = m_aWidth;
 367             break;
 368         case PROPERTY_ID_ALIGN:
 369             rValue = m_aAlign;
 370             break;
 371         case PROPERTY_ID_HIDDEN:
 372             rValue = m_aHidden;
 373             break;
 374         default:
 375             OPropertySetAggregationHelper::getFastPropertyValue(rValue, nHandle);
 376     }
 377 }
 378
 379
 380 sal_Bool OGridColumn::convertFastPropertyValue( Any& rConvertedValue, Any& rOldValue,
 381                                             sal_Int32 nHandle, const Any& rValue )
 382 {
 383     bool bModified(false);
 384     switch (nHandle)
 385     {
 386         case PROPERTY_ID_LABEL:
 387             bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, m_aLabel);
 388             break;
 389         case PROPERTY_ID_WIDTH:
 390             bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, m_aWidth, cppu::UnoType<sal_Int32>::get());
 391             break;
 392         case PROPERTY_ID_ALIGN:
 393             bModified = tryPropertyValue( rConvertedValue, rOldValue, rValue, m_aAlign, cppu::UnoType<sal_Int32>::get());
 394             // strange enough, css.awt.TextAlign is a 32-bit integer, while the Align property (both here for grid controls
 395             // and for ordinary toolkit controls) is a 16-bit integer. So, allow for 32 bit, but normalize it to 16 bit
 396             if ( bModified )
 397             {
 398                 sal_Int32 nAlign( 0 );
 399                 if ( rConvertedValue >>= nAlign )
 400                     rConvertedValue <<= static_cast<sal_Int16>(nAlign);
 401             }
 402             break;
 403         case PROPERTY_ID_HIDDEN:
 404             bModified = tryPropertyValue(rConvertedValue, rOldValue, rValue, getBOOL(m_aHidden));
 405             break;
 406     }
 407     return bModified;
 408 }
 409
 410
 411 void OGridColumn::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const Any& rValue )
 412 {
 413     switch (nHandle)
 414     {
 415         case PROPERTY_ID_LABEL:
 416             DBG_ASSERT(rValue.getValueTypeClass() == TypeClass_STRING, "invalid type" );
 417             rValue >>= m_aLabel;
 418             break;
 419         case PROPERTY_ID_WIDTH:
 420             m_aWidth = rValue;
 421             break;
 422         case PROPERTY_ID_ALIGN:
 423             m_aAlign = rValue;
 424             break;
 425         case PROPERTY_ID_HIDDEN:
 426             m_aHidden = rValue;
 427             break;
 428     }
 429 }
 430
 431
 432 // XPropertyState
 433
 434 Any OGridColumn::getPropertyDefaultByHandle( sal_Int32 nHandle ) const
 435 {
 436     switch (nHandle)
 437     {
 438         case PROPERTY_ID_WIDTH:
 439         case PROPERTY_ID_ALIGN:
 440             return Any();
 441         case PROPERTY_ID_HIDDEN:
 442             return Any(false);
 443         default:
 444             return OPropertySetAggregationHelper::getPropertyDefaultByHandle(nHandle);
 445     }
 446 }
 447
 448 // XCloneable
 449
 450 Reference< XCloneable > SAL_CALL OGridColumn::createClone(  )
 451 {
 452     return createCloneColumn();
 453 }
 454
 455 // XPersistObject
 456
 457 void OGridColumn::write(const Reference<XObjectOutputStream>& _rxOutStream)
 458 {
 459     // 1. Write the UnoControl
 460     Reference<XMarkableStream>  xMark(_rxOutStream, UNO_QUERY);
 461     sal_Int32 nMark = xMark->createMark();
 462
 463     sal_Int32 nLen = 0;
 464     _rxOutStream->writeLong(nLen);
 465
 466     if (auto xPersist = query_aggregation<XPersistObject>(m_xAggregate))
 467         xPersist->write(_rxOutStream);
 468
 469     // Calculate the length
 470     nLen = xMark->offsetToMark(nMark) - 4;
 471     xMark->jumpToMark(nMark);
 472     _rxOutStream->writeLong(nLen);
 473     xMark->jumpToFurthest();
 474     xMark->deleteMark(nMark);
 475
 476     // 2. Write a version number
 477     _rxOutStream->writeShort(0x0002);
 478
 479     sal_uInt16 nAnyMask = 0;
 480     if (m_aWidth.getValueTypeClass() == TypeClass_LONG)
 481         nAnyMask |= WIDTH;
 482
 483     if (m_aAlign.getValueTypeClass() == TypeClass_SHORT)
 484         nAnyMask |= ALIGN;
 485
 486     nAnyMask |= COMPATIBLE_HIDDEN;
 487
 488     _rxOutStream->writeShort(nAnyMask);
 489
 490     if (nAnyMask & WIDTH)
 491         _rxOutStream->writeLong(getINT32(m_aWidth));
 492     if (nAnyMask & ALIGN)
 493         _rxOutStream->writeShort(getINT16(m_aAlign));
 494
 495     // Name
 496     _rxOutStream << m_aLabel;
 497
 498     // the new place for the hidden flag : after m_aLabel, so older office version read the correct label, too
 499     if (nAnyMask & COMPATIBLE_HIDDEN)
 500         _rxOutStream->writeBoolean(getBOOL(m_aHidden));
 501 }
 502
 503
 504 void OGridColumn::read(const Reference<XObjectInputStream>& _rxInStream)
 505 {
 506     // 1. Read the UnoControl
 507     sal_Int32 nLen = _rxInStream->readLong();
 508     if (nLen)
 509     {
 510         Reference<XMarkableStream>  xMark(_rxInStream, UNO_QUERY);
 511         sal_Int32 nMark = xMark->createMark();
 512         if (auto xPersist = query_aggregation<XPersistObject>(m_xAggregate))
 513             xPersist->read(_rxInStream);
 514
 515         xMark->jumpToMark(nMark);
 516         _rxInStream->skipBytes(nLen);
 517         xMark->deleteMark(nMark);
 518     }
 519
 520     // 2. Write a version number
 521     _rxInStream->readShort(); // version;
 522     sal_uInt16 nAnyMask = _rxInStream->readShort();
 523
 524     if (nAnyMask & WIDTH)
 525     {
 526         sal_Int32 nValue = _rxInStream->readLong();
 527         m_aWidth <<= nValue;
 528     }
 529
 530     if (nAnyMask & ALIGN)
 531     {
 532         sal_Int16 nValue = _rxInStream->readShort();
 533         m_aAlign <<= nValue;
 534     }
 535     if (nAnyMask & OLD_HIDDEN)
 536     {
 537         bool bValue = _rxInStream->readBoolean();
 538         m_aHidden <<= bValue;
 539     }
 540
 541     // Name
 542     _rxInStream >> m_aLabel;
 543
 544     if (nAnyMask & COMPATIBLE_HIDDEN)
 545     {
 546         bool bValue = _rxInStream->readBoolean();
 547         m_aHidden <<= bValue;
 548     }
 549 }
 550
 551 TextFieldColumn::TextFieldColumn(const css::uno::Reference<css::uno::XComponentContext>& _rContext)
 552                                 :OGridColumn(_rContext, FRM_SUN_COMPONENT_TEXTFIELD)
 553 {
 554 }
 555 TextFieldColumn::TextFieldColumn(const TextFieldColumn* _pCloneFrom)
 556                                 :OGridColumn( _pCloneFrom )
 557 {
 558 }
 559 css::uno::Reference< css::beans::XPropertySetInfo> TextFieldColumn::getPropertySetInfo()
 560 {
 561     css::uno::Reference< css::beans::XPropertySetInfo>  xInfo( createPropertySetInfo( getInfoHelper() ) );
 562     return xInfo;
 563 }
 564 ::cppu::IPropertyArrayHelper& TextFieldColumn::getInfoHelper()
 565 {
 566     return *getArrayHelper();
 567 }
 568 void TextFieldColumn::fillProperties(
 569     css::uno::Sequence< css::beans::Property >& /* [out] */ _rProps,
 570     css::uno::Sequence< css::beans::Property >& /* [out] */ _rAggregateProps
 571     ) const
 572 {
 573     if (m_xAggregateSet.is())
 574     {
 575         _rAggregateProps = m_xAggregateSet->getPropertySetInfo()->getProperties();
 576         clearAggregateProperties(_rAggregateProps, false);
 577         setOwnProperties(_rProps);
 578     }
 579 }
 580 rtl::Reference<OGridColumn> TextFieldColumn::createCloneColumn() const
 581 {
 582     return new TextFieldColumn(this);
 583 }
 584
 585 PatternFieldColumn::PatternFieldColumn(const css::uno::Reference<css::uno::XComponentContext>& _rContext)
 586                                 :OGridColumn(_rContext, FRM_SUN_COMPONENT_PATTERNFIELD)
 587 {
 588 }
 589 PatternFieldColumn::PatternFieldColumn(const PatternFieldColumn* _pCloneFrom)
 590                                 :OGridColumn( _pCloneFrom )
 591 {
 592 }
 593 css::uno::Reference< css::beans::XPropertySetInfo> PatternFieldColumn::getPropertySetInfo()
 594 {
 595     css::uno::Reference< css::beans::XPropertySetInfo>  xInfo( createPropertySetInfo( getInfoHelper() ) );
 596     return xInfo;
 597 }
 598 ::cppu::IPropertyArrayHelper& PatternFieldColumn::getInfoHelper()
 599 {
 600     return *getArrayHelper();
 601 }
 602 void PatternFieldColumn::fillProperties(
 603     css::uno::Sequence< css::beans::Property >& /* [out] */ _rProps,
 604     css::uno::Sequence< css::beans::Property >& /* [out] */ _rAggregateProps
 605     ) const
 606 {
 607     if (m_xAggregateSet.is())
 608     {
 609         _rAggregateProps = m_xAggregateSet->getPropertySetInfo()->getProperties();
 610         clearAggregateProperties(_rAggregateProps, false);
 611         setOwnProperties(_rProps);
 612     }
 613 }
 614 rtl::Reference<OGridColumn> PatternFieldColumn::createCloneColumn() const
 615 {
 616     return new PatternFieldColumn(this);
 617 }
 618
 619 DateFieldColumn::DateFieldColumn(const css::uno::Reference<css::uno::XComponentContext>& _rContext)
 620                                 :OGridColumn(_rContext, FRM_SUN_COMPONENT_DATEFIELD)
 621 {
 622 }
 623 DateFieldColumn::DateFieldColumn(const DateFieldColumn* _pCloneFrom)
 624                                 :OGridColumn( _pCloneFrom )
 625 {
 626 }
 627 css::uno::Reference< css::beans::XPropertySetInfo> DateFieldColumn::getPropertySetInfo()
 628 {
 629     css::uno::Reference< css::beans::XPropertySetInfo>  xInfo( createPropertySetInfo( getInfoHelper() ) );
 630     return xInfo;
 631 }
 632 ::cppu::IPropertyArrayHelper& DateFieldColumn::getInfoHelper()
 633 {
 634     return *getArrayHelper();
 635 }
 636 void DateFieldColumn::fillProperties(
 637     css::uno::Sequence< css::beans::Property >& /* [out] */ _rProps,
 638     css::uno::Sequence< css::beans::Property >& /* [out] */ _rAggregateProps
 639     ) const
 640 {
 641     if (m_xAggregateSet.is())
 642     {
 643         _rAggregateProps = m_xAggregateSet->getPropertySetInfo()->getProperties();
 644         clearAggregateProperties(_rAggregateProps, true);
 645         setOwnProperties(_rProps);
 646     }
 647 }
 648 rtl::Reference<OGridColumn> DateFieldColumn::createCloneColumn() const
 649 {
 650     return new DateFieldColumn(this);
 651 }
 652
 653 TimeFieldColumn::TimeFieldColumn(const css::uno::Reference<css::uno::XComponentContext>& _rContext)
 654                                 :OGridColumn(_rContext, FRM_SUN_COMPONENT_TIMEFIELD)
 655 {
 656 }
 657 TimeFieldColumn::TimeFieldColumn(const TimeFieldColumn* _pCloneFrom)
 658                                 :OGridColumn( _pCloneFrom )
 659 {
 660 }
 661 css::uno::Reference< css::beans::XPropertySetInfo> TimeFieldColumn::getPropertySetInfo()
 662 {
 663     css::uno::Reference< css::beans::XPropertySetInfo>  xInfo( createPropertySetInfo( getInfoHelper() ) );
 664     return xInfo;
 665 }
 666 ::cppu::IPropertyArrayHelper& TimeFieldColumn::getInfoHelper()
 667 {
 668     return *getArrayHelper();
 669 }
 670 void TimeFieldColumn::fillProperties(
 671     css::uno::Sequence< css::beans::Property >& /* [out] */ _rProps,
 672     css::uno::Sequence< css::beans::Property >& /* [out] */ _rAggregateProps
 673     ) const
 674 {
 675     if (m_xAggregateSet.is())
 676     {
 677         _rAggregateProps = m_xAggregateSet->getPropertySetInfo()->getProperties();
 678         clearAggregateProperties(_rAggregateProps, false);
 679         setOwnProperties(_rProps);
 680     }
 681 }
 682 rtl::Reference<OGridColumn> TimeFieldColumn::createCloneColumn() const
 683 {
 684     return new TimeFieldColumn(this);
 685 }
 686
 687 NumericFieldColumn::NumericFieldColumn(const css::uno::Reference<css::uno::XComponentContext>& _rContext)
 688                                 :OGridColumn(_rContext, FRM_SUN_COMPONENT_NUMERICFIELD)
 689 {
 690 }
 691 NumericFieldColumn::NumericFieldColumn(const NumericFieldColumn* _pCloneFrom)
 692                                 :OGridColumn( _pCloneFrom )
 693 {
 694 }
 695 css::uno::Reference< css::beans::XPropertySetInfo> NumericFieldColumn::getPropertySetInfo()
 696 {
 697     css::uno::Reference< css::beans::XPropertySetInfo>  xInfo( createPropertySetInfo( getInfoHelper() ) );
 698     return xInfo;
 699 }
 700 ::cppu::IPropertyArrayHelper& NumericFieldColumn::getInfoHelper()
 701 {
 702     return *getArrayHelper();
 703 }
 704 void NumericFieldColumn::fillProperties(
 705     css::uno::Sequence< css::beans::Property >& /* [out] */ _rProps,
 706     css::uno::Sequence< css::beans::Property >& /* [out] */ _rAggregateProps
 707     ) const
 708 {
 709     if (m_xAggregateSet.is())
 710     {
 711         _rAggregateProps = m_xAggregateSet->getPropertySetInfo()->getProperties();
 712         clearAggregateProperties(_rAggregateProps, false);
 713         setOwnProperties(_rProps);
 714     }
 715 }
 716 rtl::Reference<OGridColumn> NumericFieldColumn::createCloneColumn() const
 717 {
 718     return new NumericFieldColumn(this);
 719 }
 720
 721 CurrencyFieldColumn::CurrencyFieldColumn(const css::uno::Reference<css::uno::XComponentContext>& _rContext)
 722                                 :OGridColumn(_rContext, FRM_SUN_COMPONENT_CURRENCYFIELD)
 723 {
 724 }
 725 CurrencyFieldColumn::CurrencyFieldColumn(const CurrencyFieldColumn* _pCloneFrom)
 726                                 :OGridColumn( _pCloneFrom )
 727 {
 728 }
 729 css::uno::Reference< css::beans::XPropertySetInfo> CurrencyFieldColumn::getPropertySetInfo()
 730 {
 731     css::uno::Reference< css::beans::XPropertySetInfo>  xInfo( createPropertySetInfo( getInfoHelper() ) );
 732     return xInfo;
 733 }
 734 ::cppu::IPropertyArrayHelper& CurrencyFieldColumn::getInfoHelper()
 735 {
 736     return *getArrayHelper();
 737 }
 738 void CurrencyFieldColumn::fillProperties(
 739     css::uno::Sequence< css::beans::Property >& /* [out] */ _rProps,
 740     css::uno::Sequence< css::beans::Property >& /* [out] */ _rAggregateProps
 741     ) const
 742 {
 743     if (m_xAggregateSet.is())
 744     {
 745         _rAggregateProps = m_xAggregateSet->getPropertySetInfo()->getProperties();
 746         clearAggregateProperties(_rAggregateProps, false);
 747         setOwnProperties(_rProps);
 748     }
 749 }
 750 rtl::Reference<OGridColumn> CurrencyFieldColumn::createCloneColumn() const
 751 {
 752     return new CurrencyFieldColumn(this);
 753 }
 754
 755 CheckBoxColumn::CheckBoxColumn(const css::uno::Reference<css::uno::XComponentContext>& _rContext)
 756                                 :OGridColumn(_rContext, FRM_SUN_COMPONENT_CHECKBOX)
 757 {
 758 }
 759 CheckBoxColumn::CheckBoxColumn(const CheckBoxColumn* _pCloneFrom)
 760                                 :OGridColumn( _pCloneFrom )
 761 {
 762 }
 763 css::uno::Reference< css::beans::XPropertySetInfo> CheckBoxColumn::getPropertySetInfo()
 764 {
 765     css::uno::Reference< css::beans::XPropertySetInfo>  xInfo( createPropertySetInfo( getInfoHelper() ) );
 766     return xInfo;
 767 }
 768 ::cppu::IPropertyArrayHelper& CheckBoxColumn::getInfoHelper()
 769 {
 770     return *getArrayHelper();
 771 }
 772 void CheckBoxColumn::fillProperties(
 773     css::uno::Sequence< css::beans::Property >& /* [out] */ _rProps,
 774     css::uno::Sequence< css::beans::Property >& /* [out] */ _rAggregateProps
 775     ) const
 776 {
 777     if (m_xAggregateSet.is())
 778     {
 779         _rAggregateProps = m_xAggregateSet->getPropertySetInfo()->getProperties();
 780         clearAggregateProperties(_rAggregateProps, false);
 781         setOwnProperties(_rProps);
 782     }
 783 }
 784 rtl::Reference<OGridColumn> CheckBoxColumn::createCloneColumn() const
 785 {
 786     return new CheckBoxColumn(this);
 787 }
 788
 789 ComboBoxColumn::ComboBoxColumn(const css::uno::Reference<css::uno::XComponentContext>& _rContext)
 790                                 :OGridColumn(_rContext, FRM_SUN_COMPONENT_COMBOBOX)
 791 {
 792 }
 793 ComboBoxColumn::ComboBoxColumn(const ComboBoxColumn* _pCloneFrom)
 794                                 :OGridColumn( _pCloneFrom )
 795 {
 796 }
 797 css::uno::Reference< css::beans::XPropertySetInfo> ComboBoxColumn::getPropertySetInfo()
 798 {
 799     css::uno::Reference< css::beans::XPropertySetInfo>  xInfo( createPropertySetInfo( getInfoHelper() ) );
 800     return xInfo;
 801 }
 802 ::cppu::IPropertyArrayHelper& ComboBoxColumn::getInfoHelper()
 803 {
 804     return *getArrayHelper();
 805 }
 806 void ComboBoxColumn::fillProperties(
 807     css::uno::Sequence< css::beans::Property >& /* [out] */ _rProps,
 808     css::uno::Sequence< css::beans::Property >& /* [out] */ _rAggregateProps
 809     ) const
 810 {
 811     if (m_xAggregateSet.is())
 812     {
 813         _rAggregateProps = m_xAggregateSet->getPropertySetInfo()->getProperties();
 814         clearAggregateProperties(_rAggregateProps, false);
 815         setOwnProperties(_rProps);
 816     }
 817 }
 818 rtl::Reference<OGridColumn> ComboBoxColumn::createCloneColumn() const
 819 {
 820     return new ComboBoxColumn(this);
 821 }
 822
 823 ListBoxColumn::ListBoxColumn(const css::uno::Reference<css::uno::XComponentContext>& _rContext)
 824                                 :OGridColumn(_rContext, FRM_SUN_COMPONENT_LISTBOX)
 825 {
 826 }
 827 ListBoxColumn::ListBoxColumn(const ListBoxColumn* _pCloneFrom)
 828                                 :OGridColumn( _pCloneFrom )
 829 {
 830 }
 831 css::uno::Reference< css::beans::XPropertySetInfo> ListBoxColumn::getPropertySetInfo()
 832 {
 833     css::uno::Reference< css::beans::XPropertySetInfo>  xInfo( createPropertySetInfo( getInfoHelper() ) );
 834     return xInfo;
 835 }
 836 ::cppu::IPropertyArrayHelper& ListBoxColumn::getInfoHelper()
 837 {
 838     return *getArrayHelper();
 839 }
 840 void ListBoxColumn::fillProperties(
 841     css::uno::Sequence< css::beans::Property >& /* [out] */ _rProps,
 842     css::uno::Sequence< css::beans::Property >& /* [out] */ _rAggregateProps
 843     ) const
 844 {
 845     if (m_xAggregateSet.is())
 846     {
 847         _rAggregateProps = m_xAggregateSet->getPropertySetInfo()->getProperties();
 848         clearAggregateProperties(_rAggregateProps, false);
 849         setOwnProperties(_rProps);
 850     }
 851 }
 852 rtl::Reference<OGridColumn> ListBoxColumn::createCloneColumn() const
 853 {
 854     return new ListBoxColumn(this);
 855 }
 856
 857 FormattedFieldColumn::FormattedFieldColumn(const css::uno::Reference<css::uno::XComponentContext>& _rContext)
 858                                 :OGridColumn(_rContext, FRM_SUN_COMPONENT_FORMATTEDFIELD)
 859 {
 860 }
 861 FormattedFieldColumn::FormattedFieldColumn(const FormattedFieldColumn* _pCloneFrom)
 862                                 :OGridColumn( _pCloneFrom )
 863 {
 864 }
 865 css::uno::Reference< css::beans::XPropertySetInfo> FormattedFieldColumn::getPropertySetInfo()
 866 {
 867     css::uno::Reference< css::beans::XPropertySetInfo>  xInfo( createPropertySetInfo( getInfoHelper() ) );
 868     return xInfo;
 869 }
 870 ::cppu::IPropertyArrayHelper& FormattedFieldColumn::getInfoHelper()
 871 {
 872     return *getArrayHelper();
 873 }
 874 void FormattedFieldColumn::fillProperties(
 875     css::uno::Sequence< css::beans::Property >& /* [out] */ _rProps,
 876     css::uno::Sequence< css::beans::Property >& /* [out] */ _rAggregateProps
 877     ) const
 878 {
 879     if (m_xAggregateSet.is())
 880     {
 881         _rAggregateProps = m_xAggregateSet->getPropertySetInfo()->getProperties();
 882         clearAggregateProperties(_rAggregateProps, false);
 883         setOwnProperties(_rProps);
 884     }
 885 }
 886 rtl::Reference<OGridColumn> FormattedFieldColumn::createCloneColumn() const
 887 {
 888     return new FormattedFieldColumn(this);
 889 }
 890
 891 }   // namespace frm
 892
 893
 894 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */