extensions/source/propctrlr/xsdvalidationhelper.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 "xsdvalidationhelper.hxx"
  21 #include "xsddatatypes.hxx"
  22 #include "formstrings.hxx"
  23
  24 #include <com/sun/star/lang/XServiceInfo.hpp>
  25 #include <com/sun/star/xsd/DataTypeClass.hpp>
  26 #include <com/sun/star/util/NumberFormat.hpp>
  27 #include <com/sun/star/util/XNumberFormatTypes.hpp>
  28 #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
  29 #include <com/sun/star/xforms/XDataTypeRepository.hpp>
  30 #include <unotools/syslocale.hxx>
  31 #include <i18nlangtag/languagetag.hxx>
  32 #include <tools/diagnose_ex.h>
  33
  34
  35 namespace pcr
  36 {
  37
  38
  39     using namespace ::com::sun::star;
  40     using namespace ::com::sun::star::uno;
  41     using namespace ::com::sun::star::beans;
  42     using namespace ::com::sun::star::xsd;
  43     using namespace ::com::sun::star::util;
  44     using namespace ::com::sun::star::lang;
  45     using namespace ::com::sun::star::xforms;
  46
  47     namespace NumberFormat = ::com::sun::star::util::NumberFormat;
  48
  49
  50     //= XSDValidationHelper
  51
  52
  53     XSDValidationHelper::XSDValidationHelper( ::osl::Mutex& _rMutex, const Reference< XPropertySet >& _rxIntrospectee, const Reference< frame::XModel >& _rxContextDocument )
  54         :EFormsHelper( _rMutex, _rxIntrospectee, _rxContextDocument )
  55         ,m_bInspectingFormattedField( false )
  56     {
  57         try
  58         {
  59             Reference< XPropertySetInfo > xPSI;
  60             Reference< XServiceInfo >     xSI( _rxIntrospectee, UNO_QUERY );
  61             if ( m_xControlModel.is() )
  62                 xPSI = m_xControlModel->getPropertySetInfo();
  63             if  (   xPSI.is()
  64                 &&  xPSI->hasPropertyByName( PROPERTY_FORMATKEY )
  65                 &&  xPSI->hasPropertyByName( PROPERTY_FORMATSSUPPLIER )
  66                 &&  xSI.is()
  67                 &&  xSI->supportsService( SERVICE_COMPONENT_FORMATTEDFIELD )
  68                 )
  69                 m_bInspectingFormattedField = true;
  70         }
  71         catch( const Exception& )
  72         {
  73             OSL_FAIL( "XSDValidationHelper::XSDValidationHelper: caught an exception while examining the introspectee!" );
  74         }
  75     }
  76
  77
  78     void XSDValidationHelper::getAvailableDataTypeNames( std::vector< OUString >& /* [out] */ _rNames ) const
  79     {
  80         _rNames.resize( 0 );
  81
  82         try
  83         {
  84             Reference< XDataTypeRepository > xRepository = getDataTypeRepository();
  85             Sequence< OUString > aElements;
  86             if ( xRepository.is() )
  87                 aElements = xRepository->getElementNames();
  88
  89             _rNames.resize( aElements.getLength() );
  90             std::copy( aElements.begin(), aElements.end(), _rNames.begin() );
  91         }
  92         catch( const Exception& )
  93         {
  94             OSL_FAIL( "XSDValidationHelper::getAvailableDataTypeNames: caught an exception!" );
  95         }
  96     }
  97
  98
  99     Reference< XDataTypeRepository > XSDValidationHelper::getDataTypeRepository() const
 100     {
 101         Reference< XDataTypeRepository > xRepository;
 102
 103         Reference< xforms::XModel > xModel( getCurrentFormModel( ) );
 104         if ( xModel.is() )
 105             xRepository = xModel->getDataTypeRepository();
 106
 107         return xRepository;
 108     }
 109
 110
 111     Reference< XDataTypeRepository > XSDValidationHelper::getDataTypeRepository( const OUString& _rModelName ) const
 112     {
 113         Reference< XDataTypeRepository > xRepository;
 114
 115         Reference< xforms::XModel > xModel( getFormModelByName( _rModelName ) );
 116         if ( xModel.is() )
 117             xRepository = xModel->getDataTypeRepository();
 118
 119         return xRepository;
 120     }
 121
 122
 123     Reference< XDataType > XSDValidationHelper::getDataType( const OUString& _rName ) const
 124     {
 125         Reference< XDataType > xDataType;
 126
 127         if ( !_rName.isEmpty() )
 128         {
 129             Reference< XDataTypeRepository > xRepository = getDataTypeRepository();
 130             if ( xRepository.is() )
 131                 xDataType = xRepository->getDataType( _rName );
 132         }
 133         return xDataType;
 134     }
 135
 136
 137     OUString XSDValidationHelper::getValidatingDataTypeName( ) const
 138     {
 139         OUString sDataTypeName;
 140         try
 141         {
 142             Reference< XPropertySet > xBinding( getCurrentBinding() );
 143             // it's allowed here to not (yet) have a binding
 144             if ( xBinding.is() )
 145             {
 146                 OSL_VERIFY( xBinding->getPropertyValue( PROPERTY_XSD_DATA_TYPE ) >>= sDataTypeName );
 147             }
 148         }
 149         catch( const Exception& )
 150         {
 151             OSL_FAIL( "XSDValidationHelper::getValidatingDataTypeName: caught an exception!" );
 152         }
 153         return sDataTypeName;
 154     }
 155
 156
 157     ::rtl::Reference< XSDDataType > XSDValidationHelper::getDataTypeByName( const OUString& _rName ) const
 158     {
 159         ::rtl::Reference< XSDDataType > pReturn;
 160
 161         try
 162         {
 163             Reference< XDataType > xValidatedAgainst;
 164
 165             if ( !_rName.isEmpty() )
 166                 xValidatedAgainst = getDataType( _rName );
 167
 168             if ( xValidatedAgainst.is() )
 169                 pReturn = new XSDDataType( xValidatedAgainst );
 170         }
 171         catch( const Exception& )
 172         {
 173             OSL_FAIL( "XSDValidationHelper::getDataTypeByName: caught an exception!" );
 174         }
 175
 176         return pReturn;
 177     }
 178
 179
 180     ::rtl::Reference< XSDDataType > XSDValidationHelper::getValidatingDataType( ) const
 181     {
 182         return getDataTypeByName( getValidatingDataTypeName() );
 183     }
 184
 185
 186     bool XSDValidationHelper::cloneDataType( const ::rtl::Reference< XSDDataType >& _pDataType, const OUString& _rNewName ) const
 187     {
 188         OSL_ENSURE( _pDataType.is(), "XSDValidationHelper::removeDataTypeFromRepository: invalid data type!" );
 189         if ( !_pDataType.is() )
 190             return false;
 191
 192         try
 193         {
 194             Reference< XDataTypeRepository > xRepository( getDataTypeRepository() );
 195             OSL_ENSURE( xRepository.is(), "XSDValidationHelper::removeDataTypeFromRepository: invalid data type repository!" );
 196             if ( !xRepository.is() )
 197                 return false;
 198
 199             Reference< XDataType > xDataType( _pDataType->getUnoDataType() );
 200             OSL_ENSURE( xDataType.is(), "XSDValidationHelper::removeDataTypeFromRepository: invalid data type (II)!" );
 201             if ( !xDataType.is() )
 202                 return false;
 203
 204             xRepository->cloneDataType( xDataType->getName(), _rNewName );
 205         }
 206         catch( const Exception& )
 207         {
 208             OSL_FAIL( "XSDValidationHelper::cloneDataType: caught an exception!" );
 209         }
 210         return true;
 211     }
 212
 213
 214     bool XSDValidationHelper::removeDataTypeFromRepository( const OUString& _rName ) const
 215     {
 216         try
 217         {
 218             Reference< XDataTypeRepository > xRepository( getDataTypeRepository() );
 219             OSL_ENSURE( xRepository.is(), "XSDValidationHelper::removeDataTypeFromRepository: invalid data type repository!" );
 220             if ( !xRepository.is() )
 221                 return false;
 222
 223             if ( !xRepository->hasByName( _rName ) )
 224             {
 225                 OSL_FAIL( "XSDValidationHelper::removeDataTypeFromRepository: invalid repository and/or data type!" );
 226                 return false;
 227             }
 228
 229             xRepository->revokeDataType( _rName );
 230         }
 231         catch( const Exception& )
 232         {
 233             OSL_FAIL( "XSDValidationHelper::removeDataTypeFromRepository: caught an exception!" );
 234             return false;
 235         }
 236         return true;
 237     }
 238
 239
 240     void XSDValidationHelper::setValidatingDataTypeByName( const OUString& _rName ) const
 241     {
 242         try
 243         {
 244             Reference< XPropertySet > xBinding( getCurrentBinding() );
 245             OSL_ENSURE( xBinding.is(), "XSDValidationHelper::setValidatingDataTypeByName: no active binding - how this?" );
 246
 247             if ( xBinding.is() )
 248             {
 249                 // get the old data type - this is necessary for notifying property changes
 250                 OUString sOldDataTypeName;
 251                 OSL_VERIFY( xBinding->getPropertyValue( PROPERTY_XSD_DATA_TYPE ) >>= sOldDataTypeName );
 252                 Reference< XPropertySet > xOldType;
 253                 try { xOldType.set(getDataType( sOldDataTypeName ), css::uno::UNO_QUERY); } catch( const Exception& ) { }
 254
 255                 // set the new data type name
 256                 xBinding->setPropertyValue( PROPERTY_XSD_DATA_TYPE, makeAny( _rName ) );
 257
 258                 // retrieve the new data type object
 259                 Reference< XPropertySet > xNewType( getDataType( _rName ), UNO_QUERY );
 260
 261                 // fire any changes in the properties which result from this new type
 262                 std::set< OUString > aFilter; aFilter.insert( PROPERTY_NAME );
 263                 firePropertyChanges( xOldType, xNewType, aFilter );
 264
 265                 // fire the change in the Data Type property
 266                 OUString sNewDataTypeName;
 267                 OSL_VERIFY( xBinding->getPropertyValue( PROPERTY_XSD_DATA_TYPE ) >>= sNewDataTypeName );
 268                 firePropertyChange( PROPERTY_XSD_DATA_TYPE, makeAny( sOldDataTypeName ), makeAny( sNewDataTypeName ) );
 269             }
 270         }
 271         catch( const Exception& )
 272         {
 273             DBG_UNHANDLED_EXCEPTION("extensions.propctrlr");
 274         }
 275     }
 276
 277
 278     void XSDValidationHelper::copyDataType( const OUString& _rFromModel, const OUString& _rToModel,
 279                 const OUString& _rDataTypeName ) const
 280     {
 281         if ( _rFromModel == _rToModel )
 282             // nothing to do (me thinks)
 283             return;
 284
 285         try
 286         {
 287             Reference< XDataTypeRepository > xFromRepository, xToRepository;
 288             if ( !_rFromModel.isEmpty() )
 289                 xFromRepository = getDataTypeRepository( _rFromModel );
 290             if ( !_rToModel.isEmpty() )
 291                 xToRepository = getDataTypeRepository( _rToModel );
 292
 293             if ( !xFromRepository.is() || !xToRepository.is() )
 294                 return;
 295
 296             if ( !xFromRepository->hasByName( _rDataTypeName ) || xToRepository->hasByName( _rDataTypeName ) )
 297                 // not existent in the source, or already existent (by name) in the destination
 298                 return;
 299
 300             // determine the built-in type belonging to the source type
 301             ::rtl::Reference< XSDDataType > pSourceType = new XSDDataType( xFromRepository->getDataType( _rDataTypeName ) );
 302             OUString sTargetBaseType = getBasicTypeNameForClass( pSourceType->classify(), xToRepository );
 303
 304             // create the target type
 305             Reference< XDataType > xTargetType = xToRepository->cloneDataType( sTargetBaseType, _rDataTypeName );
 306             ::rtl::Reference< XSDDataType > pTargetType = new XSDDataType( xTargetType );
 307
 308             // copy the facets
 309             pTargetType->copyFacetsFrom( pSourceType );
 310         }
 311         catch( const Exception& )
 312         {
 313             OSL_FAIL( "XSDValidationHelper::copyDataType: caught an exception!" );
 314         }
 315     }
 316
 317
 318     void XSDValidationHelper::findDefaultFormatForIntrospectee()
 319     {
 320         try
 321         {
 322             ::rtl::Reference< XSDDataType > xDataType = getValidatingDataType();
 323             if ( xDataType.is() )
 324             {
 325                 // find a NumberFormat type corresponding to the DataTypeClass
 326                 sal_Int16 nNumberFormatType = NumberFormat::NUMBER;
 327                 switch ( xDataType->classify() )
 328                 {
 329                 case DataTypeClass::DATETIME:
 330                     nNumberFormatType = NumberFormat::DATETIME;
 331                     break;
 332                 case DataTypeClass::DATE:
 333                     nNumberFormatType = NumberFormat::DATE;
 334                     break;
 335                 case DataTypeClass::TIME:
 336                     nNumberFormatType = NumberFormat::TIME;
 337                     break;
 338                 case DataTypeClass::STRING:
 339                 case DataTypeClass::anyURI:
 340                 case DataTypeClass::QName:
 341                 case DataTypeClass::NOTATION:
 342                     nNumberFormatType = NumberFormat::TEXT;
 343                     break;
 344                 }
 345
 346                 // get the number formatter from the introspectee
 347                 Reference< XNumberFormatsSupplier > xSupplier;
 348                 Reference< XNumberFormatTypes > xFormatTypes;
 349                 OSL_VERIFY( m_xControlModel->getPropertyValue( PROPERTY_FORMATSSUPPLIER ) >>= xSupplier );
 350                 if ( xSupplier.is() )
 351                     xFormatTypes.set(xSupplier->getNumberFormats(), css::uno::UNO_QUERY);
 352                 OSL_ENSURE( xFormatTypes.is(), "XSDValidationHelper::findDefaultFormatForIntrospectee: no number formats for the introspectee!" );
 353                 if ( !xFormatTypes.is() )
 354                     return;
 355
 356                 // and the standard format for the given NumberFormat type
 357                 sal_Int32 nDesiredFormat = xFormatTypes->getStandardFormat( nNumberFormatType, SvtSysLocale().GetLanguageTag().getLocale() );
 358
 359                 // set this at the introspectee
 360                 m_xControlModel->setPropertyValue( PROPERTY_FORMATKEY, makeAny( nDesiredFormat ) );
 361             }
 362         }
 363         catch( const Exception& )
 364         {
 365             OSL_FAIL( "XSDValidationHelper::findDefaultFormatForIntrospectee: caught an exception!" );
 366         }
 367     }
 368
 369
 370     OUString XSDValidationHelper::getBasicTypeNameForClass( sal_Int16 _nClass ) const
 371     {
 372         return getBasicTypeNameForClass( _nClass, getDataTypeRepository() );
 373     }
 374
 375
 376     OUString XSDValidationHelper::getBasicTypeNameForClass( sal_Int16 _nClass, const Reference< XDataTypeRepository >& _rxRepository )
 377     {
 378         OUString sReturn;
 379         OSL_ENSURE( _rxRepository.is(), "XSDValidationHelper::getBasicTypeNameForClass: invalid repository!" );
 380         if ( !_rxRepository.is() )
 381             return sReturn;
 382
 383         try
 384         {
 385             Reference< XDataType > xDataType = _rxRepository->getBasicDataType( _nClass );
 386             OSL_ENSURE( xDataType.is(), "XSDValidationHelper::getBasicTypeNameForClass: invalid data type returned!" );
 387             if ( xDataType.is() )
 388                 sReturn = xDataType->getName();
 389         }
 390         catch( const Exception& )
 391         {
 392             OSL_FAIL( "XSDValidationHelper::getBasicTypeNameForClass: caught an exception!" );
 393         }
 394
 395         return sReturn;
 396     }
 397
 398
 399 } // namespace pcr
 400
 401
 402 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */