extensions/source/propctrlr/propertyhandler.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 <memory>
  21 #include "propertyhandler.hxx"
  22 #include "formmetadata.hxx"
  23 #include "formbrowsertools.hxx"
  24 #include "handlerhelper.hxx"
  25 #include "formstrings.hxx"
  26
  27 #include <com/sun/star/lang/NullPointerException.hpp>
  28 #include <com/sun/star/util/XModifiable.hpp>
  29 #include <com/sun/star/script/Converter.hpp>
  30
  31 #include <cppuhelper/supportsservice.hxx>
  32 #include <tools/debug.hxx>
  33 #include <unotools/confignode.hxx>
  34 #include <unotools/localedatawrapper.hxx>
  35 #include <unotools/syslocale.hxx>
  36 #include <toolkit/helper/vclunohelper.hxx>
  37 #include <rtl/ref.hxx>
  38
  39 #include <algorithm>
  40
  41 namespace pcr
  42 {
  43
  44     using namespace ::com::sun::star::uno;
  45     using namespace ::com::sun::star::awt;
  46     using namespace ::com::sun::star::beans;
  47     using namespace ::com::sun::star::script;
  48     using namespace ::com::sun::star::lang;
  49     using namespace ::com::sun::star::util;
  50     using namespace ::com::sun::star::frame;
  51     using namespace ::com::sun::star::inspection;
  52     using namespace ::comphelper;
  53
  54
  55     PropertyHandler::PropertyHandler( const Reference< XComponentContext >& _rxContext )
  56         :PropertyHandler_Base( m_aMutex )
  57         ,m_bSupportedPropertiesAreKnown( false )
  58         ,m_aPropertyListeners( m_aMutex )
  59         ,m_xContext( _rxContext )
  60         ,m_pInfoService  ( new OPropertyInfoService )
  61     {
  62
  63         m_xTypeConverter = Converter::create(_rxContext);
  64     }
  65
  66     PropertyHandler::~PropertyHandler()
  67     {
  68     }
  69
  70     void SAL_CALL PropertyHandler::inspect( const Reference< XInterface >& _rxIntrospectee )
  71     {
  72         if ( !_rxIntrospectee.is() )
  73             throw NullPointerException();
  74
  75         ::osl::MutexGuard aGuard( m_aMutex );
  76
  77         Reference< XPropertySet > xNewComponent( _rxIntrospectee, UNO_QUERY );
  78         if ( xNewComponent == m_xComponent )
  79             return;
  80
  81         // remove all old property change listeners
  82         ::comphelper::OInterfaceIteratorHelper3 removeListener(m_aPropertyListeners);
  83         ::comphelper::OInterfaceIteratorHelper3 readdListener(m_aPropertyListeners);  // will copy the container as needed
  84         while ( removeListener.hasMoreElements() )
  85             removePropertyChangeListener( removeListener.next() );
  86         OSL_ENSURE( m_aPropertyListeners.getLength() == 0, "PropertyHandler::inspect: derived classes are expected to forward the removePropertyChangeListener call to their base class (me)!" );
  87
  88         // remember the new component, and give derived classes the chance to react on it
  89         m_xComponent = xNewComponent;
  90         onNewComponent();
  91
  92         // add the listeners, again
  93         while ( readdListener.hasMoreElements() )
  94             addPropertyChangeListener( readdListener.next() );
  95     }
  96
  97     void PropertyHandler::onNewComponent()
  98     {
  99         if ( m_xComponent.is() )
 100             m_xComponentPropertyInfo = m_xComponent->getPropertySetInfo();
 101         else
 102             m_xComponentPropertyInfo.clear();
 103
 104         m_bSupportedPropertiesAreKnown = false;
 105         m_aSupportedProperties.realloc( 0 );
 106     }
 107
 108     Sequence< Property > SAL_CALL PropertyHandler::getSupportedProperties()
 109     {
 110         ::osl::MutexGuard aGuard( m_aMutex );
 111         if ( !m_bSupportedPropertiesAreKnown )
 112         {
 113             m_aSupportedProperties = StlSyntaxSequence<css::beans::Property>(doDescribeSupportedProperties());
 114             m_bSupportedPropertiesAreKnown = true;
 115         }
 116         return m_aSupportedProperties;
 117     }
 118
 119     Sequence< OUString > SAL_CALL PropertyHandler::getSupersededProperties( )
 120     {
 121         return Sequence< OUString >();
 122     }
 123
 124     Sequence< OUString > SAL_CALL PropertyHandler::getActuatingProperties( )
 125     {
 126         return Sequence< OUString >();
 127     }
 128
 129     Any SAL_CALL PropertyHandler::convertToPropertyValue( const OUString& _rPropertyName, const Any& _rControlValue )
 130     {
 131         ::osl::MutexGuard aGuard( m_aMutex );
 132         PropertyId nPropId = m_pInfoService->getPropertyId( _rPropertyName );
 133         Property aProperty( impl_getPropertyFromName_throw( _rPropertyName ) );
 134
 135         Any aPropertyValue;
 136         if ( !_rControlValue.hasValue() )
 137             // NULL is converted to NULL
 138             return aPropertyValue;
 139
 140         if ( ( m_pInfoService->getPropertyUIFlags( nPropId ) & PROP_FLAG_ENUM ) != 0 )
 141         {
 142             OUString sControlValue;
 143             OSL_VERIFY( _rControlValue >>= sControlValue );
 144             ::rtl::Reference< IPropertyEnumRepresentation > aEnumConversion(
 145                 new DefaultEnumRepresentation( *m_pInfoService, aProperty.Type, nPropId ) );
 146             // TODO/UNOize: cache those converters?
 147             aEnumConversion->getValueFromDescription( sControlValue, aPropertyValue );
 148         }
 149         else
 150             aPropertyValue = PropertyHandlerHelper::convertToPropertyValue(
 151                 m_xContext, m_xTypeConverter, aProperty, _rControlValue );
 152         return aPropertyValue;
 153     }
 154
 155     Any SAL_CALL PropertyHandler::convertToControlValue( const OUString& _rPropertyName, const Any& _rPropertyValue, const Type& _rControlValueType )
 156     {
 157         ::osl::MutexGuard aGuard( m_aMutex );
 158         PropertyId nPropId = m_pInfoService->getPropertyId( _rPropertyName );
 159
 160         if ( ( m_pInfoService->getPropertyUIFlags( nPropId ) & PROP_FLAG_ENUM ) != 0 )
 161         {
 162             DBG_ASSERT( _rControlValueType.getTypeClass() == TypeClass_STRING, "PropertyHandler::convertToControlValue: ENUM, but not STRING?" );
 163
 164             ::rtl::Reference< IPropertyEnumRepresentation > aEnumConversion(
 165                 new DefaultEnumRepresentation( *m_pInfoService, _rPropertyValue.getValueType(), nPropId ) );
 166             // TODO/UNOize: cache those converters?
 167             return Any( aEnumConversion->getDescriptionForValue( _rPropertyValue ) );
 168         }
 169
 170         return PropertyHandlerHelper::convertToControlValue(
 171             m_xContext, m_xTypeConverter, _rPropertyValue, _rControlValueType );
 172     }
 173
 174     PropertyState SAL_CALL PropertyHandler::getPropertyState( const OUString& /*_rPropertyName*/ )
 175     {
 176         return PropertyState_DIRECT_VALUE;
 177     }
 178
 179     LineDescriptor SAL_CALL PropertyHandler::describePropertyLine( const OUString& _rPropertyName,
 180         const Reference< XPropertyControlFactory >& _rxControlFactory )
 181     {
 182         if ( !_rxControlFactory.is() )
 183             throw NullPointerException();
 184
 185         ::osl::MutexGuard aGuard( m_aMutex );
 186         PropertyId nPropId( impl_getPropertyId_throwUnknownProperty( _rPropertyName ) );
 187         const Property& rProperty( impl_getPropertyFromId_throw( nPropId ) );
 188
 189         LineDescriptor aDescriptor;
 190         if ( ( m_pInfoService->getPropertyUIFlags( nPropId ) & PROP_FLAG_ENUM ) != 0 )
 191         {
 192             aDescriptor.Control = PropertyHandlerHelper::createListBoxControl(
 193                 _rxControlFactory, m_pInfoService->getPropertyEnumRepresentations( nPropId ),
 194                 PropertyHandlerHelper::requiresReadOnlyControl( rProperty.Attributes ), false );
 195         }
 196         else
 197             PropertyHandlerHelper::describePropertyLine( rProperty, aDescriptor, _rxControlFactory );
 198
 199         aDescriptor.HelpURL = HelpIdUrl::getHelpURL( m_pInfoService->getPropertyHelpId( nPropId ) );
 200         aDescriptor.DisplayName = m_pInfoService->getPropertyTranslation( nPropId );
 201
 202         if ( ( m_pInfoService->getPropertyUIFlags( nPropId ) & PROP_FLAG_DATA_PROPERTY ) != 0 )
 203             aDescriptor.Category = "Data";
 204         else
 205             aDescriptor.Category = "General";
 206         return aDescriptor;
 207     }
 208
 209     sal_Bool SAL_CALL PropertyHandler::isComposable( const OUString& _rPropertyName )
 210     {
 211         ::osl::MutexGuard aGuard( m_aMutex );
 212         return m_pInfoService->isComposeable( _rPropertyName );
 213     }
 214
 215     InteractiveSelectionResult SAL_CALL PropertyHandler::onInteractivePropertySelection( const OUString& /*_rPropertyName*/, sal_Bool /*_bPrimary*/, Any& /*_rData*/, const Reference< XObjectInspectorUI >& /*_rxInspectorUI*/ )
 216     {
 217         OSL_FAIL( "PropertyHandler::onInteractivePropertySelection: not implemented!" );
 218         return InteractiveSelectionResult_Cancelled;
 219     }
 220
 221     void SAL_CALL PropertyHandler::actuatingPropertyChanged( const OUString& /*_rActuatingPropertyName*/, const Any& /*_rNewValue*/, const Any& /*_rOldValue*/, const Reference< XObjectInspectorUI >& /*_rxInspectorUI*/, sal_Bool /*_bFirstTimeInit*/ )
 222     {
 223         OSL_FAIL( "PropertyHandler::actuatingPropertyChanged: not implemented!" );
 224     }
 225
 226     void SAL_CALL PropertyHandler::addPropertyChangeListener( const Reference< XPropertyChangeListener >& _rxListener )
 227     {
 228         ::osl::MutexGuard aGuard( m_aMutex );
 229         if ( !_rxListener.is() )
 230             throw NullPointerException();
 231         m_aPropertyListeners.addInterface( _rxListener );
 232     }
 233
 234     void SAL_CALL PropertyHandler::removePropertyChangeListener( const Reference< XPropertyChangeListener >& _rxListener )
 235     {
 236         ::osl::MutexGuard aGuard( m_aMutex );
 237         m_aPropertyListeners.removeInterface( _rxListener );
 238     }
 239
 240     sal_Bool SAL_CALL PropertyHandler::suspend( sal_Bool /*_bSuspend*/ )
 241     {
 242         return true;
 243     }
 244
 245     void SAL_CALL PropertyHandler::dispose(  )
 246     {
 247         PropertyHandler_Base::WeakComponentImplHelperBase::dispose();
 248         m_xComponent.clear();
 249         m_xComponentPropertyInfo.clear();
 250         m_xTypeConverter.clear();
 251     }
 252     void SAL_CALL PropertyHandler::addEventListener( const css::uno::Reference< css::lang::XEventListener >& Listener )
 253     {
 254         PropertyHandler_Base::WeakComponentImplHelperBase::addEventListener( Listener );
 255     }
 256     void SAL_CALL PropertyHandler::removeEventListener( const css::uno::Reference< css::lang::XEventListener >& Listener )
 257     {
 258         PropertyHandler_Base::WeakComponentImplHelperBase::removeEventListener( Listener );
 259     }
 260
 261
 262     void SAL_CALL PropertyHandler::disposing()
 263     {
 264         m_xComponent.clear();
 265         m_aPropertyListeners.clear();
 266         m_xTypeConverter.clear();
 267         m_aSupportedProperties.realloc( 0 );
 268     }
 269
 270     void PropertyHandler::firePropertyChange( const OUString& _rPropName, PropertyId _nPropId, const Any& _rOldValue, const Any& _rNewValue )
 271     {
 272         PropertyChangeEvent aEvent;
 273         aEvent.Source = m_xComponent;
 274         aEvent.PropertyHandle = _nPropId;
 275         aEvent.PropertyName = _rPropName;
 276         aEvent.OldValue = _rOldValue;
 277         aEvent.NewValue = _rNewValue;
 278         m_aPropertyListeners.notifyEach( &XPropertyChangeListener::propertyChange, aEvent );
 279     }
 280
 281     const Property* PropertyHandler::impl_getPropertyFromId_nothrow( PropertyId _nPropId ) const
 282     {
 283         const_cast< PropertyHandler* >( this )->getSupportedProperties();
 284         const Property* pFound = std::find_if( m_aSupportedProperties.begin(), m_aSupportedProperties.end(),
 285             FindPropertyByHandle( _nPropId )
 286         );
 287         if ( pFound != m_aSupportedProperties.end() )
 288             return pFound;
 289         return nullptr;
 290     }
 291
 292     const Property& PropertyHandler::impl_getPropertyFromId_throw( PropertyId _nPropId ) const
 293     {
 294         const Property* pProperty = impl_getPropertyFromId_nothrow( _nPropId );
 295         if ( !pProperty )
 296             throw UnknownPropertyException();
 297
 298         return *pProperty;
 299     }
 300
 301     const Property& PropertyHandler::impl_getPropertyFromName_throw( const OUString& _rPropertyName ) const
 302     {
 303         const_cast< PropertyHandler* >( this )->getSupportedProperties();
 304         StlSyntaxSequence< Property >::const_iterator pFound = std::find_if( m_aSupportedProperties.begin(), m_aSupportedProperties.end(),
 305             FindPropertyByName( _rPropertyName )
 306         );
 307         if ( pFound == m_aSupportedProperties.end() )
 308             throw UnknownPropertyException(_rPropertyName);
 309
 310         return *pFound;
 311     }
 312
 313     void PropertyHandler::implAddPropertyDescription( std::vector< Property >& _rProperties, const OUString& _rPropertyName, const Type& _rType, sal_Int16 _nAttribs ) const
 314     {
 315         _rProperties.push_back( Property(
 316             _rPropertyName,
 317             m_pInfoService->getPropertyId( _rPropertyName ),
 318             _rType,
 319             _nAttribs
 320         ) );
 321     }
 322
 323     weld::Window* PropertyHandler::impl_getDefaultDialogFrame_nothrow() const
 324     {
 325         return PropertyHandlerHelper::getDialogParentFrame(m_xContext);
 326     }
 327
 328     PropertyId PropertyHandler::impl_getPropertyId_throwUnknownProperty( const OUString& _rPropertyName ) const
 329     {
 330         PropertyId nPropId = m_pInfoService->getPropertyId( _rPropertyName );
 331         if ( nPropId == -1 )
 332             throw UnknownPropertyException(_rPropertyName);
 333         return nPropId;
 334     }
 335
 336     PropertyId PropertyHandler::impl_getPropertyId_throwRuntime( const OUString& _rPropertyName ) const
 337     {
 338         PropertyId nPropId = m_pInfoService->getPropertyId( _rPropertyName );
 339         if ( nPropId == -1 )
 340             throw RuntimeException();
 341         return nPropId;
 342     }
 343
 344     PropertyId PropertyHandler::impl_getPropertyId_nothrow( const OUString& _rPropertyName ) const
 345     {
 346         return m_pInfoService->getPropertyId( _rPropertyName );
 347     }
 348
 349     void PropertyHandler::impl_setContextDocumentModified_nothrow() const
 350     {
 351         Reference< XModifiable > xModifiable( impl_getContextDocument_nothrow(), UNO_QUERY );
 352         if ( xModifiable.is() )
 353             xModifiable->setModified( true );
 354     }
 355
 356     bool PropertyHandler::impl_componentHasProperty_throw( const OUString& _rPropName ) const
 357     {
 358         return m_xComponentPropertyInfo.is() && m_xComponentPropertyInfo->hasPropertyByName( _rPropName );
 359     }
 360
 361     sal_Int16 PropertyHandler::impl_getDocumentMeasurementUnit_throw() const
 362     {
 363         FieldUnit eUnit = FieldUnit::NONE;
 364
 365         Reference< XServiceInfo > xDocumentSI( impl_getContextDocument_nothrow(), UNO_QUERY );
 366         OSL_ENSURE( xDocumentSI.is(), "PropertyHandlerHelper::impl_getDocumentMeasurementUnit_throw: No context document - where do I live?" );
 367         if ( xDocumentSI.is() )
 368         {
 369             // determine the application type we live in
 370             OUString sConfigurationLocation;
 371             OUString sConfigurationProperty;
 372             if ( xDocumentSI->supportsService( SERVICE_WEB_DOCUMENT ) )
 373             {   // writer
 374                 sConfigurationLocation = "/org.openoffice.Office.WriterWeb/Layout/Other";
 375                 sConfigurationProperty = "MeasureUnit";
 376             }
 377             else if ( xDocumentSI->supportsService( SERVICE_TEXT_DOCUMENT ) )
 378             {   // writer
 379                 sConfigurationLocation = "/org.openoffice.Office.Writer/Layout/Other";
 380                 sConfigurationProperty = "MeasureUnit";
 381             }
 382             else if ( xDocumentSI->supportsService( SERVICE_SPREADSHEET_DOCUMENT ) )
 383             {   // calc
 384                 sConfigurationLocation = "/org.openoffice.Office.Calc/Layout/Other/MeasureUnit";
 385                 sConfigurationProperty = "Metric";
 386             }
 387             else if ( xDocumentSI->supportsService( SERVICE_DRAWING_DOCUMENT ) )
 388             {
 389                 sConfigurationLocation = "/org.openoffice.Office.Draw/Layout/Other/MeasureUnit";
 390                 sConfigurationProperty = "Metric";
 391             }
 392             else if ( xDocumentSI->supportsService( SERVICE_PRESENTATION_DOCUMENT ) )
 393             {
 394                 sConfigurationLocation = "/org.openoffice.Office.Impress/Layout/Other/MeasureUnit";
 395                 sConfigurationProperty = "Metric";
 396             }
 397
 398             // read the measurement unit from the configuration
 399             if ( !(sConfigurationLocation.isEmpty() || sConfigurationProperty.isEmpty()) )
 400             {
 401                 ::utl::OConfigurationTreeRoot aConfigTree( ::utl::OConfigurationTreeRoot::createWithComponentContext(
 402                     m_xContext, sConfigurationLocation, -1, ::utl::OConfigurationTreeRoot::CM_READONLY ) );
 403                 sal_Int32 nUnitAsInt = sal_Int32(FieldUnit::NONE);
 404                 aConfigTree.getNodeValue( sConfigurationProperty ) >>= nUnitAsInt;
 405
 406                 // if this denotes a valid (and accepted) unit, then use it
 407                 if  ( ( nUnitAsInt > sal_Int32(FieldUnit::NONE) ) && ( nUnitAsInt <= sal_Int32(FieldUnit::MM_100TH) ) )
 408                     eUnit = static_cast< FieldUnit >( nUnitAsInt );
 409             }
 410         }
 411
 412         if ( FieldUnit::NONE == eUnit )
 413         {
 414             MeasurementSystem eSystem = SvtSysLocale().GetLocaleData().getMeasurementSystemEnum();
 415             eUnit = MeasurementSystem::Metric == eSystem ? FieldUnit::CM : FieldUnit::INCH;
 416         }
 417
 418         return VCLUnoHelper::ConvertToMeasurementUnit( eUnit, 1 );
 419     }
 420
 421     PropertyHandlerComponent::PropertyHandlerComponent( const Reference< XComponentContext >& _rxContext )
 422         :PropertyHandler( _rxContext )
 423     {
 424     }
 425
 426     IMPLEMENT_FORWARD_XINTERFACE2( PropertyHandlerComponent, PropertyHandler, PropertyHandlerComponent_Base )
 427     IMPLEMENT_FORWARD_XTYPEPROVIDER2( PropertyHandlerComponent, PropertyHandler, PropertyHandlerComponent_Base )
 428
 429     sal_Bool SAL_CALL PropertyHandlerComponent::supportsService( const OUString& ServiceName )
 430     {
 431         return cppu::supportsService(this, ServiceName);
 432     }
 433
 434 }   // namespace pcr
 435
 436 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */