extensions/source/propctrlr/xsdvalidationpropertyhandler.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 // MARKER(update_precomp.py): autogen include statement, do not remove
  30 #include "precompiled_extensions.hxx"
  31 #include "xsdvalidationpropertyhandler.hxx"
  32 #include "formstrings.hxx"
  33 #include "formmetadata.hxx"
  34 #include "xsddatatypes.hxx"
  35 #include "modulepcr.hxx"
  36 #include "formresid.hrc"
  37 #include "formlocalid.hrc"
  38 #include "propctrlr.hrc"
  39 #include "newdatatype.hxx"
  40 #include "xsdvalidationhelper.hxx"
  41 #include "pcrcommon.hxx"
  42 #include "handlerhelper.hxx"
  43
  44 /** === begin UNO includes === **/
  45 #include <com/sun/star/beans/PropertyAttribute.hpp>
  46 #include <com/sun/star/xsd/WhiteSpaceTreatment.hpp>
  47 #include <com/sun/star/xsd/DataTypeClass.hpp>
  48 #include <com/sun/star/inspection/PropertyControlType.hpp>
  49 #include <com/sun/star/beans/Optional.hpp>
  50 #include <com/sun/star/inspection/XObjectInspectorUI.hpp>
  51 #include <com/sun/star/inspection/PropertyLineElement.hpp>
  52 /** === end UNO includes === **/
  53 #include <vcl/msgbox.hxx>
  54 #include <tools/debug.hxx>
  55 #include <svtools/localresaccess.hxx>
  56 #include <sal/macros.h>
  57
  58 #include <algorithm>
  59 #include <functional>
  60 #include <limits>
  61
  62 //------------------------------------------------------------------------
  63 extern "C" void SAL_CALL createRegistryInfo_XSDValidationPropertyHandler()
  64 {
  65     ::pcr::XSDValidationPropertyHandler::registerImplementation();
  66 }
  67
  68 //........................................................................
  69 namespace pcr
  70 {
  71 //........................................................................
  72
  73     using namespace ::com::sun::star;
  74     using namespace ::com::sun::star::uno;
  75     using namespace ::com::sun::star::lang;
  76     using namespace ::com::sun::star::beans;
  77     using namespace ::com::sun::star::xforms;
  78     using namespace ::com::sun::star::xsd;
  79     using namespace ::com::sun::star::script;
  80     using namespace ::com::sun::star::inspection;
  81
  82     using ::com::sun::star::beans::PropertyAttribute::MAYBEVOID;
  83
  84     //====================================================================
  85     //= XSDValidationPropertyHandler
  86     //====================================================================
  87     DBG_NAME( XSDValidationPropertyHandler )
  88     //--------------------------------------------------------------------
  89     XSDValidationPropertyHandler::XSDValidationPropertyHandler( const Reference< XComponentContext >& _rxContext )
  90         :XSDValidationPropertyHandler_Base( _rxContext )
  91     {
  92         DBG_CTOR( XSDValidationPropertyHandler, NULL );
  93     }
  94
  95     //--------------------------------------------------------------------
  96     XSDValidationPropertyHandler::~XSDValidationPropertyHandler()
  97     {
  98         DBG_DTOR( XSDValidationPropertyHandler, NULL );
  99     }
 100
 101     //--------------------------------------------------------------------
 102     ::rtl::OUString SAL_CALL XSDValidationPropertyHandler::getImplementationName_static(  ) throw (RuntimeException)
 103     {
 104         return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.extensions.XSDValidationPropertyHandler" ) );
 105     }
 106
 107     //--------------------------------------------------------------------
 108     Sequence< ::rtl::OUString > SAL_CALL XSDValidationPropertyHandler::getSupportedServiceNames_static(  ) throw (RuntimeException)
 109     {
 110         Sequence< ::rtl::OUString > aSupported( 1 );
 111         aSupported[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.form.inspection.XSDValidationPropertyHandler" ) );
 112         return aSupported;
 113     }
 114
 115     //--------------------------------------------------------------------
 116     Any SAL_CALL XSDValidationPropertyHandler::getPropertyValue( const ::rtl::OUString& _rPropertyName ) throw (UnknownPropertyException, RuntimeException)
 117     {
 118         ::osl::MutexGuard aGuard( m_aMutex );
 119         PropertyId nPropId( impl_getPropertyId_throw( _rPropertyName ) );
 120
 121         OSL_ENSURE( m_pHelper.get(), "XSDValidationPropertyHandler::getPropertyValue: inconsistency!" );
 122             // if we survived impl_getPropertyId_throw, we should have a helper, since no helper implies no properties
 123
 124         Any aReturn;
 125         ::rtl::Reference< XSDDataType > pType = m_pHelper->getValidatingDataType();
 126         switch ( nPropId )
 127         {
 128         // common facets
 129         case PROPERTY_ID_XSD_DATA_TYPE:  aReturn = pType.is() ? pType->getFacet( PROPERTY_NAME ) : makeAny( ::rtl::OUString() ); break;
 130         case PROPERTY_ID_XSD_WHITESPACES:aReturn = pType.is() ? pType->getFacet( PROPERTY_XSD_WHITESPACES ) : makeAny( WhiteSpaceTreatment::Preserve ); break;
 131         case PROPERTY_ID_XSD_PATTERN:    aReturn = pType.is() ? pType->getFacet( PROPERTY_XSD_PATTERN ) : makeAny( ::rtl::OUString() ); break;
 132
 133         // all other properties are simply forwarded, if they exist at the given type
 134         default:
 135         {
 136             if ( pType.is() && pType->hasFacet( _rPropertyName ) )
 137                 aReturn = pType->getFacet( _rPropertyName );
 138         }
 139         break;
 140         }
 141
 142         return aReturn;
 143     }
 144
 145     //--------------------------------------------------------------------
 146     void SAL_CALL XSDValidationPropertyHandler::setPropertyValue( const ::rtl::OUString& _rPropertyName, const Any& _rValue ) throw (UnknownPropertyException, RuntimeException)
 147     {
 148         ::osl::MutexGuard aGuard( m_aMutex );
 149         PropertyId nPropId( impl_getPropertyId_throw( _rPropertyName ) );
 150
 151         OSL_ENSURE( m_pHelper.get(), "XSDValidationPropertyHandler::getPropertyValue: inconsistency!" );
 152             // if we survived impl_getPropertyId_throw, we should have a helper, since no helper implies no properties
 153
 154         if ( PROPERTY_ID_XSD_DATA_TYPE == nPropId )
 155         {
 156             ::rtl::OUString sTypeName;
 157             OSL_VERIFY( _rValue >>= sTypeName );
 158             m_pHelper->setValidatingDataTypeByName( sTypeName );
 159             impl_setContextDocumentModified_nothrow();
 160             return;
 161         }
 162
 163         ::rtl::Reference< XSDDataType > pType = m_pHelper->getValidatingDataType();
 164         if ( !pType.is() )
 165         {
 166             DBG_ERROR( "XSDValidationPropertyHandler::setPropertyValue: you're trying to set a type facet, without a current type!" );
 167             return;
 168         }
 169
 170         pType->setFacet( _rPropertyName, _rValue );
 171         impl_setContextDocumentModified_nothrow();
 172     }
 173
 174     //--------------------------------------------------------------------
 175     void XSDValidationPropertyHandler::onNewComponent()
 176     {
 177         XSDValidationPropertyHandler_Base::onNewComponent();
 178
 179         Reference< frame::XModel > xDocument( impl_getContextDocument_nothrow() );
 180         DBG_ASSERT( xDocument.is(), "XSDValidationPropertyHandler::onNewComponent: no document!" );
 181         if ( EFormsHelper::isEForm( xDocument ) )
 182             m_pHelper.reset( new XSDValidationHelper( m_aMutex, m_xComponent, xDocument ) );
 183         else
 184             m_pHelper.reset( NULL );
 185     }
 186
 187     //--------------------------------------------------------------------
 188     Sequence< Property > XSDValidationPropertyHandler::doDescribeSupportedProperties() const
 189     {
 190         ::std::vector< Property > aProperties;
 191
 192         if ( m_pHelper.get() )
 193         {
 194             bool bAllowBinding = m_pHelper->canBindToAnyDataType();
 195
 196             if ( bAllowBinding )
 197             {
 198                 aProperties.reserve( 12 );
 199
 200                 addStringPropertyDescription( aProperties, PROPERTY_XSD_DATA_TYPE   );
 201                 addInt16PropertyDescription ( aProperties, PROPERTY_XSD_WHITESPACES );
 202                 addStringPropertyDescription( aProperties, PROPERTY_XSD_PATTERN     );
 203
 204                 // string facets
 205                 addInt32PropertyDescription( aProperties, PROPERTY_XSD_LENGTH,          MAYBEVOID );
 206                 addInt32PropertyDescription( aProperties, PROPERTY_XSD_MIN_LENGTH,      MAYBEVOID );
 207                 addInt32PropertyDescription( aProperties, PROPERTY_XSD_MAX_LENGTH,      MAYBEVOID );
 208
 209                 // decimal facets
 210                 addInt32PropertyDescription( aProperties, PROPERTY_XSD_TOTAL_DIGITS,    MAYBEVOID );
 211                 addInt32PropertyDescription( aProperties, PROPERTY_XSD_FRACTION_DIGITS, MAYBEVOID );
 212
 213                 // facets for different types
 214                 addInt16PropertyDescription( aProperties, PROPERTY_XSD_MAX_INCLUSIVE_INT, MAYBEVOID );
 215                 addInt16PropertyDescription( aProperties, PROPERTY_XSD_MAX_EXCLUSIVE_INT, MAYBEVOID );
 216                 addInt16PropertyDescription( aProperties, PROPERTY_XSD_MIN_INCLUSIVE_INT, MAYBEVOID );
 217                 addInt16PropertyDescription( aProperties, PROPERTY_XSD_MIN_EXCLUSIVE_INT, MAYBEVOID );
 218                 addDoublePropertyDescription( aProperties, PROPERTY_XSD_MAX_INCLUSIVE_DOUBLE, MAYBEVOID );
 219                 addDoublePropertyDescription( aProperties, PROPERTY_XSD_MAX_EXCLUSIVE_DOUBLE, MAYBEVOID );
 220                 addDoublePropertyDescription( aProperties, PROPERTY_XSD_MIN_INCLUSIVE_DOUBLE, MAYBEVOID );
 221                 addDoublePropertyDescription( aProperties, PROPERTY_XSD_MIN_EXCLUSIVE_DOUBLE, MAYBEVOID );
 222                 addDatePropertyDescription( aProperties, PROPERTY_XSD_MAX_INCLUSIVE_DATE, MAYBEVOID );
 223                 addDatePropertyDescription( aProperties, PROPERTY_XSD_MAX_EXCLUSIVE_DATE, MAYBEVOID );
 224                 addDatePropertyDescription( aProperties, PROPERTY_XSD_MIN_INCLUSIVE_DATE, MAYBEVOID );
 225                 addDatePropertyDescription( aProperties, PROPERTY_XSD_MIN_EXCLUSIVE_DATE, MAYBEVOID );
 226                 addTimePropertyDescription( aProperties, PROPERTY_XSD_MAX_INCLUSIVE_TIME, MAYBEVOID );
 227                 addTimePropertyDescription( aProperties, PROPERTY_XSD_MAX_EXCLUSIVE_TIME, MAYBEVOID );
 228                 addTimePropertyDescription( aProperties, PROPERTY_XSD_MIN_INCLUSIVE_TIME, MAYBEVOID );
 229                 addTimePropertyDescription( aProperties, PROPERTY_XSD_MIN_EXCLUSIVE_TIME, MAYBEVOID );
 230                 addDateTimePropertyDescription( aProperties, PROPERTY_XSD_MAX_INCLUSIVE_DATE_TIME, MAYBEVOID );
 231                 addDateTimePropertyDescription( aProperties, PROPERTY_XSD_MAX_EXCLUSIVE_DATE_TIME, MAYBEVOID );
 232                 addDateTimePropertyDescription( aProperties, PROPERTY_XSD_MIN_INCLUSIVE_DATE_TIME, MAYBEVOID );
 233                 addDateTimePropertyDescription( aProperties, PROPERTY_XSD_MIN_EXCLUSIVE_DATE_TIME, MAYBEVOID );
 234             }
 235         }
 236
 237         if ( aProperties.empty() )
 238             return Sequence< Property >();
 239         return Sequence< Property >( &(*aProperties.begin()), aProperties.size() );
 240     }
 241
 242     //--------------------------------------------------------------------
 243     Sequence< ::rtl::OUString > SAL_CALL XSDValidationPropertyHandler::getSupersededProperties( ) throw (RuntimeException)
 244     {
 245         ::osl::MutexGuard aGuard( m_aMutex );
 246
 247         ::std::vector< ::rtl::OUString > aSuperfluous;
 248         if ( m_pHelper.get() )
 249         {
 250             aSuperfluous.push_back( PROPERTY_CONTROLSOURCE );
 251             aSuperfluous.push_back( PROPERTY_EMPTY_IS_NULL );
 252             aSuperfluous.push_back( PROPERTY_FILTERPROPOSAL );
 253             aSuperfluous.push_back( PROPERTY_LISTSOURCETYPE );
 254             aSuperfluous.push_back( PROPERTY_LISTSOURCE );
 255             aSuperfluous.push_back( PROPERTY_BOUNDCOLUMN );
 256
 257             bool bAllowBinding = m_pHelper->canBindToAnyDataType();
 258
 259             if ( bAllowBinding )
 260             {
 261                 aSuperfluous.push_back( PROPERTY_MAXTEXTLEN );
 262                 aSuperfluous.push_back( PROPERTY_VALUEMIN );
 263                 aSuperfluous.push_back( PROPERTY_VALUEMAX );
 264                 aSuperfluous.push_back( PROPERTY_DECIMAL_ACCURACY );
 265                 aSuperfluous.push_back( PROPERTY_TIMEMIN );
 266                 aSuperfluous.push_back( PROPERTY_TIMEMAX );
 267                 aSuperfluous.push_back( PROPERTY_DATEMIN );
 268                 aSuperfluous.push_back( PROPERTY_DATEMAX );
 269                 aSuperfluous.push_back( PROPERTY_EFFECTIVE_MIN );
 270                 aSuperfluous.push_back( PROPERTY_EFFECTIVE_MAX );
 271             }
 272         }
 273
 274         if ( aSuperfluous.empty() )
 275             return Sequence< ::rtl::OUString >();
 276         return Sequence< ::rtl::OUString >( &(*aSuperfluous.begin()), aSuperfluous.size() );
 277     }
 278
 279     //--------------------------------------------------------------------
 280     Sequence< ::rtl::OUString > SAL_CALL XSDValidationPropertyHandler::getActuatingProperties( ) throw (RuntimeException)
 281     {
 282         ::osl::MutexGuard aGuard( m_aMutex );
 283         ::std::vector< ::rtl::OUString > aInterestedInActuations( 2 );
 284         if ( m_pHelper.get() )
 285         {
 286             aInterestedInActuations.push_back( PROPERTY_XSD_DATA_TYPE );
 287             aInterestedInActuations.push_back( PROPERTY_XML_DATA_MODEL );
 288         }
 289         if ( aInterestedInActuations.empty() )
 290             return Sequence< ::rtl::OUString >();
 291         return Sequence< ::rtl::OUString >( &(*aInterestedInActuations.begin()), aInterestedInActuations.size() );
 292     }
 293
 294     //--------------------------------------------------------------------
 295     namespace
 296     {
 297         void showPropertyUI( const Reference< XObjectInspectorUI >& _rxInspectorUI, const ::rtl::OUString& _rPropertyName, bool _bShow )
 298         {
 299             if ( _bShow )
 300                 _rxInspectorUI->showPropertyUI( _rPropertyName );
 301             else
 302                 _rxInspectorUI->hidePropertyUI( _rPropertyName );
 303         }
 304     }
 305
 306     //--------------------------------------------------------------------
 307     LineDescriptor SAL_CALL XSDValidationPropertyHandler::describePropertyLine( const ::rtl::OUString& _rPropertyName,
 308         const Reference< XPropertyControlFactory >& _rxControlFactory )
 309         throw (UnknownPropertyException, NullPointerException, RuntimeException)
 310     {
 311         ::osl::MutexGuard aGuard( m_aMutex );
 312         if ( !_rxControlFactory.is() )
 313             throw NullPointerException();
 314         if ( !m_pHelper.get() )
 315             throw RuntimeException();
 316
 317         PropertyId nPropId( impl_getPropertyId_throw( _rPropertyName ) );
 318
 319         LineDescriptor aDescriptor;
 320         if ( nPropId != PROPERTY_ID_XSD_DATA_TYPE )
 321             aDescriptor.IndentLevel = 1;
 322
 323         // collect some information about the to-be-created control
 324         sal_Int16 nControlType = PropertyControlType::TextField;
 325         ::std::vector< ::rtl::OUString > aListEntries;
 326         Optional< double > aMinValue( sal_False, 0 );
 327         Optional< double > aMaxValue( sal_False, 0 );
 328
 329         switch ( nPropId )
 330         {
 331         case PROPERTY_ID_XSD_DATA_TYPE:
 332             nControlType = PropertyControlType::ListBox;
 333
 334             implGetAvailableDataTypeNames( aListEntries );
 335
 336             aDescriptor.PrimaryButtonId = UID_PROP_ADD_DATA_TYPE;
 337             aDescriptor.SecondaryButtonId = UID_PROP_REMOVE_DATA_TYPE;
 338             aDescriptor.HasPrimaryButton = aDescriptor.HasSecondaryButton = sal_True;
 339             aDescriptor.PrimaryButtonImageURL = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "private:graphicrepository/extensions/res/buttonplus.png" ) );
 340             aDescriptor.SecondaryButtonImageURL = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "private:graphicrepository/extensions/res/buttonminus.png" ) );
 341             break;
 342
 343         case PROPERTY_ID_XSD_WHITESPACES:
 344         {
 345             nControlType = PropertyControlType::ListBox;
 346             aListEntries = m_pInfoService->getPropertyEnumRepresentations( PROPERTY_ID_XSD_WHITESPACES );
 347         }
 348         break;
 349
 350         case PROPERTY_ID_XSD_PATTERN:
 351             nControlType = PropertyControlType::TextField;
 352             break;
 353
 354         case PROPERTY_ID_XSD_LENGTH:
 355         case PROPERTY_ID_XSD_MIN_LENGTH:
 356         case PROPERTY_ID_XSD_MAX_LENGTH:
 357             nControlType = PropertyControlType::NumericField;
 358             break;
 359
 360         case PROPERTY_ID_XSD_TOTAL_DIGITS:
 361         case PROPERTY_ID_XSD_FRACTION_DIGITS:
 362             nControlType = PropertyControlType::NumericField;
 363             break;
 364
 365         case PROPERTY_ID_XSD_MAX_INCLUSIVE_INT:
 366         case PROPERTY_ID_XSD_MAX_EXCLUSIVE_INT:
 367         case PROPERTY_ID_XSD_MIN_INCLUSIVE_INT:
 368         case PROPERTY_ID_XSD_MIN_EXCLUSIVE_INT:
 369         {
 370             nControlType = PropertyControlType::NumericField;
 371
 372             // handle limits for various 'INT' types according to
 373             // their actual semantics (year, month, day)
 374
 375             ::rtl::Reference< XSDDataType > xDataType( m_pHelper->getValidatingDataType() );
 376             sal_Int16 nTypeClass = xDataType.is() ? xDataType->classify() : DataTypeClass::STRING;
 377
 378             aMinValue.IsPresent = aMaxValue.IsPresent = sal_True;
 379             aMinValue.Value = DataTypeClass::gYear == nTypeClass ? 0 : 1;
 380             aMaxValue.Value = ::std::numeric_limits< sal_Int32 >::max();
 381             if ( DataTypeClass::gMonth == nTypeClass )
 382                 aMaxValue.Value = 12;
 383             else if ( DataTypeClass::gDay == nTypeClass )
 384                 aMaxValue.Value = 31;
 385         }
 386         break;
 387
 388         case PROPERTY_ID_XSD_MAX_INCLUSIVE_DOUBLE:
 389         case PROPERTY_ID_XSD_MAX_EXCLUSIVE_DOUBLE:
 390         case PROPERTY_ID_XSD_MIN_INCLUSIVE_DOUBLE:
 391         case PROPERTY_ID_XSD_MIN_EXCLUSIVE_DOUBLE:
 392             nControlType = PropertyControlType::NumericField;
 393             // TODO/eForms: do we have "auto-digits"?
 394             break;
 395
 396         case PROPERTY_ID_XSD_MAX_INCLUSIVE_DATE:
 397         case PROPERTY_ID_XSD_MAX_EXCLUSIVE_DATE:
 398         case PROPERTY_ID_XSD_MIN_INCLUSIVE_DATE:
 399         case PROPERTY_ID_XSD_MIN_EXCLUSIVE_DATE:
 400             nControlType = PropertyControlType::DateField;
 401             break;
 402
 403         case PROPERTY_ID_XSD_MAX_INCLUSIVE_TIME:
 404         case PROPERTY_ID_XSD_MAX_EXCLUSIVE_TIME:
 405         case PROPERTY_ID_XSD_MIN_INCLUSIVE_TIME:
 406         case PROPERTY_ID_XSD_MIN_EXCLUSIVE_TIME:
 407             nControlType = PropertyControlType::TimeField;
 408             break;
 409
 410         case PROPERTY_ID_XSD_MAX_INCLUSIVE_DATE_TIME:
 411         case PROPERTY_ID_XSD_MAX_EXCLUSIVE_DATE_TIME:
 412         case PROPERTY_ID_XSD_MIN_INCLUSIVE_DATE_TIME:
 413         case PROPERTY_ID_XSD_MIN_EXCLUSIVE_DATE_TIME:
 414             nControlType = PropertyControlType::DateTimeField;
 415             break;
 416
 417         default:
 418             DBG_ERROR( "XSDValidationPropertyHandler::describePropertyLine: cannot handle this property!" );
 419             break;
 420         }
 421
 422         switch ( nControlType )
 423         {
 424         case PropertyControlType::ListBox:
 425             aDescriptor.Control = PropertyHandlerHelper::createListBoxControl( _rxControlFactory, aListEntries, sal_False, sal_False );
 426             break;
 427         case PropertyControlType::NumericField:
 428             aDescriptor.Control = PropertyHandlerHelper::createNumericControl( _rxControlFactory, 0, aMinValue, aMaxValue, sal_False );
 429             break;
 430         default:
 431             aDescriptor.Control = _rxControlFactory->createPropertyControl( nControlType, sal_False );
 432             break;
 433         }
 434
 435         aDescriptor.Category = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Data" ) );
 436         aDescriptor.DisplayName = m_pInfoService->getPropertyTranslation( nPropId );
 437         aDescriptor.HelpURL = HelpIdUrl::getHelpURL( m_pInfoService->getPropertyHelpId( nPropId ) );
 438
 439         return aDescriptor;
 440     }
 441
 442     //--------------------------------------------------------------------
 443     InteractiveSelectionResult SAL_CALL XSDValidationPropertyHandler::onInteractivePropertySelection( const ::rtl::OUString& _rPropertyName, sal_Bool _bPrimary, Any& /*_rData*/, const Reference< XObjectInspectorUI >& _rxInspectorUI ) throw (UnknownPropertyException, NullPointerException, RuntimeException)
 444     {
 445         if ( !_rxInspectorUI.is() )
 446             throw NullPointerException();
 447
 448         ::osl::MutexGuard aGuard( m_aMutex );
 449         OSL_ENSURE( m_pHelper.get(), "XSDValidationPropertyHandler::onInteractivePropertySelection: we don't have any SupportedProperties!" );
 450         if ( !m_pHelper.get() )
 451             return InteractiveSelectionResult_Cancelled;
 452
 453         PropertyId nPropId( impl_getPropertyId_throw( _rPropertyName ) );
 454
 455         switch ( nPropId )
 456         {
 457         case PROPERTY_ID_XSD_DATA_TYPE:
 458         {
 459             if ( _bPrimary )
 460             {
 461                 ::rtl::OUString sNewDataTypeName;
 462                 if ( implPrepareCloneDataCurrentType( sNewDataTypeName ) )
 463                 {
 464                     implDoCloneCurrentDataType( sNewDataTypeName );
 465                     return InteractiveSelectionResult_Success;
 466                 }
 467             }
 468             else
 469                 return implPrepareRemoveCurrentDataType() && implDoRemoveCurrentDataType() ? InteractiveSelectionResult_Success : InteractiveSelectionResult_Cancelled;
 470         }
 471         break;
 472
 473         default:
 474             DBG_ERROR( "XSDValidationPropertyHandler::onInteractivePropertySelection: unexpected property to build a dedicated UI!" );
 475             break;
 476         }
 477         return InteractiveSelectionResult_Cancelled;
 478     }
 479
 480     //--------------------------------------------------------------------
 481     void SAL_CALL XSDValidationPropertyHandler::addPropertyChangeListener( const Reference< XPropertyChangeListener >& _rxListener ) throw (RuntimeException)
 482     {
 483         ::osl::MutexGuard aGuard( m_aMutex );
 484         XSDValidationPropertyHandler_Base::addPropertyChangeListener( _rxListener );
 485         if ( m_pHelper.get() )
 486             m_pHelper->registerBindingListener( _rxListener );
 487     }
 488
 489     //--------------------------------------------------------------------
 490     void SAL_CALL XSDValidationPropertyHandler::removePropertyChangeListener( const Reference< XPropertyChangeListener >& _rxListener ) throw (RuntimeException)
 491     {
 492         ::osl::MutexGuard aGuard( m_aMutex );
 493         if ( m_pHelper.get() )
 494             m_pHelper->revokeBindingListener( _rxListener );
 495         XSDValidationPropertyHandler_Base::removePropertyChangeListener( _rxListener );
 496     }
 497
 498     //--------------------------------------------------------------------
 499     bool XSDValidationPropertyHandler::implPrepareCloneDataCurrentType( ::rtl::OUString& _rNewName ) SAL_THROW(())
 500     {
 501         OSL_PRECOND( m_pHelper.get(), "XSDValidationPropertyHandler::implPrepareCloneDataCurrentType: this will crash!" );
 502
 503         ::rtl::Reference< XSDDataType > pType = m_pHelper->getValidatingDataType();
 504         if ( !pType.is() )
 505         {
 506             DBG_ERROR( "XSDValidationPropertyHandler::implPrepareCloneDataCurrentType: invalid current data type!" );
 507             return false;
 508         }
 509
 510         ::std::vector< ::rtl::OUString > aExistentNames;
 511         m_pHelper->getAvailableDataTypeNames( aExistentNames );
 512
 513         NewDataTypeDialog aDialog( NULL, pType->getName(), aExistentNames );  // TODO/eForms: proper parent
 514         if ( aDialog.Execute() != RET_OK )
 515             return false;
 516
 517         _rNewName = aDialog.GetName();
 518         return true;
 519     }
 520
 521     //--------------------------------------------------------------------
 522     bool XSDValidationPropertyHandler::implDoCloneCurrentDataType( const ::rtl::OUString& _rNewName ) SAL_THROW(())
 523     {
 524         OSL_PRECOND( m_pHelper.get(), "XSDValidationPropertyHandler::implDoCloneCurrentDataType: this will crash!" );
 525
 526         ::rtl::Reference< XSDDataType > pType = m_pHelper->getValidatingDataType();
 527         if ( !pType.is() )
 528             return false;
 529
 530         if ( !m_pHelper->cloneDataType( pType, _rNewName ) )
 531             return false;
 532
 533         m_pHelper->setValidatingDataTypeByName( _rNewName );
 534         return true;
 535     }
 536
 537     //--------------------------------------------------------------------
 538     bool XSDValidationPropertyHandler::implPrepareRemoveCurrentDataType() SAL_THROW(())
 539     {
 540         OSL_PRECOND( m_pHelper.get(), "XSDValidationPropertyHandler::implPrepareRemoveCurrentDataType: this will crash!" );
 541
 542         ::rtl::Reference< XSDDataType > pType = m_pHelper->getValidatingDataType();
 543         if ( !pType.is() )
 544         {
 545             DBG_ERROR( "XSDValidationPropertyHandler::implPrepareRemoveCurrentDataType: invalid current data type!" );
 546             return false;
 547         }
 548
 549         // confirmation message
 550         String sConfirmation( PcrRes( RID_STR_CONFIRM_DELETE_DATA_TYPE ) );
 551         sConfirmation.SearchAndReplaceAscii( "#type#", pType->getName() );
 552         QueryBox aQuery( NULL, WB_YES_NO, sConfirmation ); // TODO/eForms: proper parent
 553         if ( aQuery.Execute() != RET_YES )
 554             return false;
 555
 556         return true;
 557     }
 558
 559     //--------------------------------------------------------------------
 560     bool XSDValidationPropertyHandler::implDoRemoveCurrentDataType() SAL_THROW(())
 561     {
 562         OSL_PRECOND( m_pHelper.get(), "XSDValidationPropertyHandler::implDoRemoveCurrentDataType: this will crash!" );
 563
 564         ::rtl::Reference< XSDDataType > pType = m_pHelper->getValidatingDataType();
 565         if ( !pType.is() )
 566             return false;
 567
 568         // set a new data type at the binding, which is the "basic" type for the one
 569         // we are going to delete
 570         // (do this before the actual deletion, so the old type is still valid for property change
 571         // notifications)
 572         m_pHelper->setValidatingDataTypeByName( m_pHelper->getBasicTypeNameForClass( pType->classify() ) );
 573         // now remove the type
 574         m_pHelper->removeDataTypeFromRepository( pType->getName() );
 575
 576         return true;
 577     }
 578
 579     //--------------------------------------------------------------------
 580     void SAL_CALL XSDValidationPropertyHandler::actuatingPropertyChanged( const ::rtl::OUString& _rActuatingPropertyName, const Any& _rNewValue, const Any& _rOldValue, const Reference< XObjectInspectorUI >& _rxInspectorUI, sal_Bool _bFirstTimeInit ) throw (NullPointerException, RuntimeException)
 581     {
 582         if ( !_rxInspectorUI.is() )
 583             throw NullPointerException();
 584
 585         ::osl::MutexGuard aGuard( m_aMutex );
 586         PropertyId nActuatingPropId( impl_getPropertyId_throw( _rActuatingPropertyName ) );
 587         if ( !m_pHelper.get() )
 588             throw RuntimeException();
 589             // if we survived impl_getPropertyId_throw, we should have a helper, since no helper implies no properties
 590
 591         switch ( nActuatingPropId )
 592         {
 593         case PROPERTY_ID_XSD_DATA_TYPE:
 594         {
 595             ::rtl::Reference< XSDDataType > xDataType( m_pHelper->getValidatingDataType() );
 596
 597             // is removal of this type possible?
 598             sal_Bool bIsBasicType = xDataType.is() && xDataType->isBasicType();
 599             _rxInspectorUI->enablePropertyUIElements( PROPERTY_XSD_DATA_TYPE, PropertyLineElement::PrimaryButton, xDataType.is() );
 600             _rxInspectorUI->enablePropertyUIElements( PROPERTY_XSD_DATA_TYPE, PropertyLineElement::SecondaryButton, xDataType.is() && !bIsBasicType );
 601
 602             //------------------------------------------------------------
 603             // show the facets which are available at the data type
 604             ::rtl::OUString aFacets[] = {
 605                 PROPERTY_XSD_WHITESPACES, PROPERTY_XSD_PATTERN,
 606                 PROPERTY_XSD_LENGTH, PROPERTY_XSD_MIN_LENGTH, PROPERTY_XSD_MAX_LENGTH, PROPERTY_XSD_TOTAL_DIGITS,
 607                 PROPERTY_XSD_FRACTION_DIGITS,
 608                 PROPERTY_XSD_MAX_INCLUSIVE_INT,
 609                 PROPERTY_XSD_MAX_EXCLUSIVE_INT,
 610                 PROPERTY_XSD_MIN_INCLUSIVE_INT,
 611                 PROPERTY_XSD_MIN_EXCLUSIVE_INT,
 612                 PROPERTY_XSD_MAX_INCLUSIVE_DOUBLE,
 613                 PROPERTY_XSD_MAX_EXCLUSIVE_DOUBLE,
 614                 PROPERTY_XSD_MIN_INCLUSIVE_DOUBLE,
 615                 PROPERTY_XSD_MIN_EXCLUSIVE_DOUBLE,
 616                 PROPERTY_XSD_MAX_INCLUSIVE_DATE,
 617                 PROPERTY_XSD_MAX_EXCLUSIVE_DATE,
 618                 PROPERTY_XSD_MIN_INCLUSIVE_DATE,
 619                 PROPERTY_XSD_MIN_EXCLUSIVE_DATE,
 620                 PROPERTY_XSD_MAX_INCLUSIVE_TIME,
 621                 PROPERTY_XSD_MAX_EXCLUSIVE_TIME,
 622                 PROPERTY_XSD_MIN_INCLUSIVE_TIME,
 623                 PROPERTY_XSD_MIN_EXCLUSIVE_TIME,
 624                 PROPERTY_XSD_MAX_INCLUSIVE_DATE_TIME,
 625                 PROPERTY_XSD_MAX_EXCLUSIVE_DATE_TIME,
 626                 PROPERTY_XSD_MIN_INCLUSIVE_DATE_TIME,
 627                 PROPERTY_XSD_MIN_EXCLUSIVE_DATE_TIME
 628             };
 629
 630             size_t i=0;
 631             const ::rtl::OUString* pLoop = NULL;
 632             for ( i = 0, pLoop = aFacets;
 633                   i < SAL_N_ELEMENTS( aFacets );
 634                   ++i, ++pLoop
 635                 )
 636             {
 637                 showPropertyUI( _rxInspectorUI, *pLoop, xDataType.is() && xDataType->hasFacet( *pLoop ) );
 638                 _rxInspectorUI->enablePropertyUI( *pLoop, !bIsBasicType );
 639             }
 640         }
 641         break;
 642
 643         case PROPERTY_ID_XML_DATA_MODEL:
 644         {
 645             // The data type which the current binding works with may not be present in the
 646             // new model. Thus, transfer it.
 647             ::rtl::OUString sOldModelName; _rOldValue >>= sOldModelName;
 648             ::rtl::OUString sNewModelName; _rNewValue >>= sNewModelName;
 649             ::rtl::OUString sDataType = m_pHelper->getValidatingDataTypeName();
 650             m_pHelper->copyDataType( sOldModelName, sNewModelName, sDataType );
 651
 652             // the list of available data types depends on the chosen model, so update this
 653             if ( !_bFirstTimeInit )
 654                 _rxInspectorUI->rebuildPropertyUI( PROPERTY_XSD_DATA_TYPE );
 655         }
 656         break;
 657
 658         default:
 659             DBG_ERROR( "XSDValidationPropertyHandler::actuatingPropertyChanged: cannot handle this property!" );
 660             return;
 661         }
 662
 663         // in both cases, we need to care for the current value of the XSD_DATA_TYPE property,
 664         // and update the FormatKey of the formatted field we're inspecting (if any)
 665         if ( !_bFirstTimeInit && m_pHelper->isInspectingFormattedField() )
 666             m_pHelper->findDefaultFormatForIntrospectee();
 667     }
 668
 669     //--------------------------------------------------------------------
 670     void XSDValidationPropertyHandler::implGetAvailableDataTypeNames( ::std::vector< ::rtl::OUString >& /* [out] */ _rNames ) const SAL_THROW(())
 671     {
 672         OSL_PRECOND( m_pHelper.get(), "XSDValidationPropertyHandler::implGetAvailableDataTypeNames: this will crash!" );
 673         // start with *all* types which are available at the model
 674         ::std::vector< ::rtl::OUString > aAllTypes;
 675         m_pHelper->getAvailableDataTypeNames( aAllTypes );
 676         _rNames.clear();
 677         _rNames.reserve( aAllTypes.size() );
 678
 679         // then allow only those which are "compatible" with our control
 680         for ( ::std::vector< ::rtl::OUString >::const_iterator dataType = aAllTypes.begin();
 681               dataType != aAllTypes.end();
 682               ++dataType
 683             )
 684         {
 685             ::rtl::Reference< XSDDataType > pType = m_pHelper->getDataTypeByName( *dataType );
 686             if ( pType.is() && m_pHelper->canBindToDataType( pType->classify() ) )
 687                 _rNames.push_back( *dataType );
 688         }
 689     }
 690
 691 //........................................................................
 692 } // namespace pcr
 693 //........................................................................
 694
 695 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */