1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_extensions.hxx" 26 27 #include "controltype.hxx" 28 #include "propctrlr.hrc" 29 #include "extensio.hrc" 30 #include "fontdialog.hxx" 31 #include "formcomponenthandler.hxx" 32 #include "formlinkdialog.hxx" 33 #include "formmetadata.hxx" 34 #include "formresid.hrc" 35 #include "formstrings.hxx" 36 #include "handlerhelper.hxx" 37 #include "listselectiondlg.hxx" 38 #include "pcrcommon.hxx" 39 #include "selectlabeldialog.hxx" 40 #include "taborder.hxx" 41 #include "usercontrol.hxx" 42 43 /** === begin UNO includes === **/ 44 #include <com/sun/star/lang/NullPointerException.hpp> 45 #include <com/sun/star/awt/XControlModel.hpp> 46 #include <com/sun/star/lang/XServiceInfo.hpp> 47 #include <com/sun/star/form/FormComponentType.hpp> 48 #include <com/sun/star/beans/PropertyAttribute.hpp> 49 #include <com/sun/star/util/XNumberFormatsSupplier.hpp> 50 #include <com/sun/star/container/XNameAccess.hpp> 51 #include <com/sun/star/form/XForm.hpp> 52 #include <com/sun/star/container/XChild.hpp> 53 #include <com/sun/star/sdbc/XConnection.hpp> 54 #include <com/sun/star/sdb/CommandType.hpp> 55 #include <com/sun/star/form/XGridColumnFactory.hpp> 56 #include <com/sun/star/sdb/SQLContext.hpp> 57 #include <com/sun/star/sdbcx/XTablesSupplier.hpp> 58 #include <com/sun/star/sdb/XQueriesSupplier.hpp> 59 #include <com/sun/star/form/ListSourceType.hpp> 60 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp> 61 #include <com/sun/star/sdb/XSingleSelectQueryComposer.hpp> 62 #include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp> 63 #include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp> 64 #include <com/sun/star/awt/XTabControllerModel.hpp> 65 #include <com/sun/star/form/FormSubmitEncoding.hpp> 66 #include <com/sun/star/awt/VisualEffect.hpp> 67 #include <com/sun/star/form/FormButtonType.hpp> 68 #include <com/sun/star/inspection/PropertyControlType.hpp> 69 #include <com/sun/star/util/MeasureUnit.hpp> 70 #include <com/sun/star/inspection/XObjectInspectorUI.hpp> 71 #include <com/sun/star/inspection/PropertyLineElement.hpp> 72 #include <com/sun/star/resource/XStringResourceManager.hpp> 73 #include <com/sun/star/resource/MissingResourceException.hpp> 74 #include <com/sun/star/graphic/GraphicObject.hpp> 75 #include <com/sun/star/text/WritingMode2.hpp> 76 /** === end UNO includes === **/ 77 78 #include <comphelper/extract.hxx> 79 #include <connectivity/dbconversion.hxx> 80 #include <connectivity/dbexception.hxx> 81 #include <cppuhelper/exc_hlp.hxx> 82 #include <sfx2/app.hxx> 83 #include <sfx2/basedlgs.hxx> 84 #include <sfx2/docfilt.hxx> 85 #include <sfx2/filedlghelper.hxx> 86 #include <svl/ctloptions.hxx> 87 #include <svtools/colrdlg.hxx> 88 #include <svl/filenotation.hxx> 89 #include <svl/intitem.hxx> 90 #include <svl/itemset.hxx> 91 #include <unotools/moduleoptions.hxx> 92 #include <svl/numuno.hxx> 93 #include <svl/urihelper.hxx> 94 #include <svx/dialogs.hrc> 95 #include <svx/numinf.hxx> 96 #include <svx/svxdlg.hxx> 97 #include <svx/svxids.hrc> 98 #include <toolkit/helper/vclunohelper.hxx> 99 #include <tools/diagnose_ex.h> 100 #include <vcl/msgbox.hxx> 101 #include <vcl/stdtext.hxx> 102 #include <vcl/wrkwin.hxx> 103 #include <tools/StringListResource.hxx> 104 105 #include <limits> 106 107 #define GRAPHOBJ_URLPREFIX "vnd.sun.star.GraphicObject:" 108 //------------------------------------------------------------------------ 109 extern "C" void SAL_CALL createRegistryInfo_FormComponentPropertyHandler() 110 { 111 ::pcr::FormComponentPropertyHandler::registerImplementation(); 112 } 113 114 //........................................................................ 115 namespace pcr 116 { 117 //........................................................................ 118 119 using namespace ::com::sun::star; 120 using namespace uno; 121 using namespace lang; 122 using namespace beans; 123 using namespace frame; 124 using namespace script; 125 using namespace form; 126 using namespace util; 127 using namespace awt; 128 using namespace sdb; 129 using namespace sdbc; 130 using namespace sdbcx; 131 using namespace form; 132 using namespace container; 133 using namespace ui::dialogs; 134 using namespace inspection; 135 using namespace ::dbtools; 136 137 namespace WritingMode2 = ::com::sun::star::text::WritingMode2; 138 139 //==================================================================== 140 //= FormComponentPropertyHandler 141 //==================================================================== 142 DBG_NAME( FormComponentPropertyHandler ) 143 #define PROPERTY_ID_ROWSET 1 144 //-------------------------------------------------------------------- 145 FormComponentPropertyHandler::FormComponentPropertyHandler( const Reference< XComponentContext >& _rxContext ) 146 :FormComponentPropertyHandler_Base( _rxContext ) 147 ,::comphelper::OPropertyContainer(FormComponentPropertyHandler_Base::rBHelper) 148 ,m_sDefaultValueString( String( PcrRes( RID_STR_STANDARD ) ) ) 149 ,m_eComponentClass( eUnknown ) 150 ,m_bComponentIsSubForm( false ) 151 ,m_bHaveListSource( false ) 152 ,m_bHaveCommand( false ) 153 ,m_nClassId( 0 ) 154 { 155 DBG_CTOR( FormComponentPropertyHandler, NULL ); 156 registerProperty(PROPERTY_ROWSET,PROPERTY_ID_ROWSET,0,&m_xRowSet,::getCppuType(&m_xRowSet)); 157 } 158 159 //-------------------------------------------------------------------- 160 FormComponentPropertyHandler::~FormComponentPropertyHandler() 161 { 162 DBG_DTOR( FormComponentPropertyHandler, NULL ); 163 } 164 //-------------------------------------------------------------------- 165 IMPLEMENT_FORWARD_XINTERFACE2(FormComponentPropertyHandler,FormComponentPropertyHandler_Base,::comphelper::OPropertyContainer) 166 //-------------------------------------------------------------------- 167 ::rtl::OUString SAL_CALL FormComponentPropertyHandler::getImplementationName_static( ) throw (RuntimeException) 168 { 169 return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.extensions.FormComponentPropertyHandler" ) ); 170 } 171 172 //-------------------------------------------------------------------- 173 Sequence< ::rtl::OUString > SAL_CALL FormComponentPropertyHandler::getSupportedServiceNames_static( ) throw (RuntimeException) 174 { 175 Sequence< ::rtl::OUString > aSupported( 1 ); 176 aSupported[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.form.inspection.FormComponentPropertyHandler" ) ); 177 return aSupported; 178 } 179 180 //============================================ 181 // TODO: -> export from toolkit 182 struct LanguageDependentProp 183 { 184 const char* pPropName; 185 sal_Int32 nPropNameLength; 186 }; 187 188 static LanguageDependentProp aLanguageDependentProp[] = 189 { 190 { "Text", 4 }, 191 { "Label", 5 }, 192 { "Title", 5 }, 193 { "HelpText", 8 }, 194 { "CurrencySymbol", 14 }, 195 { "StringItemList", 14 }, 196 { 0, 0 } 197 }; 198 199 namespace 200 { 201 bool lcl_isLanguageDependentProperty( ::rtl::OUString aName ) 202 { 203 bool bRet = false; 204 205 LanguageDependentProp* pLangDepProp = aLanguageDependentProp; 206 while( pLangDepProp->pPropName != 0 ) 207 { 208 if( aName.equalsAsciiL( pLangDepProp->pPropName, pLangDepProp->nPropNameLength )) 209 { 210 bRet = true; 211 break; 212 } 213 pLangDepProp++; 214 } 215 return bRet; 216 } 217 218 Reference< resource::XStringResourceResolver > lcl_getStringResourceResolverForProperty 219 ( Reference< XPropertySet > _xComponent, const ::rtl::OUString& _rPropertyName, 220 const Any& _rPropertyValue ) 221 { 222 Reference< resource::XStringResourceResolver > xRet; 223 const TypeClass eType = _rPropertyValue.getValueType().getTypeClass(); 224 if ( (eType == TypeClass_STRING || eType == TypeClass_SEQUENCE) && 225 lcl_isLanguageDependentProperty( _rPropertyName ) ) 226 { 227 static const ::rtl::OUString s_sResourceResolverPropName(RTL_CONSTASCII_USTRINGPARAM("ResourceResolver")); 228 229 Reference< resource::XStringResourceResolver > xStringResourceResolver; 230 try 231 { 232 xStringResourceResolver.set( _xComponent->getPropertyValue( s_sResourceResolverPropName ),UNO_QUERY); 233 if( xStringResourceResolver.is() && 234 xStringResourceResolver->getLocales().getLength() > 0 ) 235 { 236 xRet = xStringResourceResolver; 237 } 238 } 239 catch(UnknownPropertyException&) 240 { 241 // nii 242 } 243 } 244 245 return xRet; 246 } 247 } 248 249 //-------------------------------------------------------------------- 250 Any FormComponentPropertyHandler::impl_getPropertyValue_throw( const ::rtl::OUString& _rPropertyName ) const 251 { 252 const PropertyId nPropId( impl_getPropertyId_throw( _rPropertyName ) ); 253 254 Any aPropertyValue( m_xComponent->getPropertyValue( _rPropertyName ) ); 255 256 Reference< resource::XStringResourceResolver > xStringResourceResolver 257 = lcl_getStringResourceResolverForProperty( m_xComponent, _rPropertyName, aPropertyValue ); 258 if( xStringResourceResolver.is() ) 259 { 260 TypeClass eType = aPropertyValue.getValueType().getTypeClass(); 261 if( eType == TypeClass_STRING ) 262 { 263 ::rtl::OUString aPropStr; 264 aPropertyValue >>= aPropStr; 265 if( aPropStr.getLength() > 1 ) 266 { 267 ::rtl::OUString aPureIdStr = aPropStr.copy( 1 ); 268 if( xStringResourceResolver->hasEntryForId( aPureIdStr ) ) 269 { 270 ::rtl::OUString aResourceStr = xStringResourceResolver->resolveString( aPureIdStr ); 271 aPropertyValue <<= aResourceStr; 272 } 273 } 274 } 275 // StringItemList? 276 else if( eType == TypeClass_SEQUENCE ) 277 { 278 Sequence< ::rtl::OUString > aStrings; 279 aPropertyValue >>= aStrings; 280 281 const ::rtl::OUString* pStrings = aStrings.getConstArray(); 282 sal_Int32 nCount = aStrings.getLength(); 283 284 Sequence< ::rtl::OUString > aResolvedStrings; 285 aResolvedStrings.realloc( nCount ); 286 ::rtl::OUString* pResolvedStrings = aResolvedStrings.getArray(); 287 try 288 { 289 for ( sal_Int32 i = 0; i < nCount; ++i ) 290 { 291 ::rtl::OUString aIdStr = pStrings[i]; 292 ::rtl::OUString aPureIdStr = aIdStr.copy( 1 ); 293 if( xStringResourceResolver->hasEntryForId( aPureIdStr ) ) 294 pResolvedStrings[i] = xStringResourceResolver->resolveString( aPureIdStr ); 295 else 296 pResolvedStrings[i] = aIdStr; 297 } 298 } 299 catch( resource::MissingResourceException & ) 300 {} 301 aPropertyValue <<= aResolvedStrings; 302 } 303 } 304 else 305 impl_normalizePropertyValue_nothrow( aPropertyValue, nPropId ); 306 307 return aPropertyValue; 308 } 309 310 //-------------------------------------------------------------------- 311 Any SAL_CALL FormComponentPropertyHandler::getPropertyValue( const ::rtl::OUString& _rPropertyName ) throw (UnknownPropertyException, RuntimeException) 312 { 313 if( _rPropertyName == PROPERTY_ROWSET ) 314 return ::comphelper::OPropertyContainer::getPropertyValue( _rPropertyName ); 315 316 ::osl::MutexGuard aGuard( m_aMutex ); 317 return impl_getPropertyValue_throw( _rPropertyName ); 318 } 319 320 //-------------------------------------------------------------------- 321 void SAL_CALL FormComponentPropertyHandler::setPropertyValue( const ::rtl::OUString& _rPropertyName, const Any& _rValue ) throw (UnknownPropertyException, RuntimeException) 322 { 323 if( _rPropertyName == PROPERTY_ROWSET ) 324 { 325 ::comphelper::OPropertyContainer::setPropertyValue( _rPropertyName, _rValue ); 326 return; 327 } 328 329 ::osl::MutexGuard aGuard( m_aMutex ); 330 PropertyId nPropId( impl_getPropertyId_throw( _rPropertyName ) ); // check if property is known by the handler 331 332 Reference< graphic::XGraphicObject > xGrfObj; 333 if ( PROPERTY_ID_IMAGE_URL == nPropId && ( _rValue >>= xGrfObj ) ) 334 { 335 DBG_ASSERT( xGrfObj.is(), "FormComponentPropertyHandler::setPropertyValue() xGrfObj is invalid"); 336 rtl::OUString sObjectID( RTL_CONSTASCII_USTRINGPARAM( GRAPHOBJ_URLPREFIX ) ); 337 sObjectID = sObjectID + xGrfObj->getUniqueID(); 338 m_xComponent->setPropertyValue( _rPropertyName, uno::makeAny( sObjectID ) ); 339 } 340 else if ( PROPERTY_ID_FONT == nPropId ) 341 { 342 // special handling, the value is a faked value we generated ourself in impl_executeFontDialog_nothrow 343 Sequence< NamedValue > aFontPropertyValues; 344 OSL_VERIFY( _rValue >>= aFontPropertyValues ); 345 const NamedValue* fontPropertyValue = aFontPropertyValues.getConstArray(); 346 const NamedValue* fontPropertyValueEnd = fontPropertyValue + aFontPropertyValues.getLength(); 347 for ( ; fontPropertyValue != fontPropertyValueEnd; ++fontPropertyValue ) 348 m_xComponent->setPropertyValue( fontPropertyValue->Name, fontPropertyValue->Value ); 349 } 350 else 351 { 352 Any aValue = _rValue; 353 354 Reference< resource::XStringResourceResolver > xStringResourceResolver 355 = lcl_getStringResourceResolverForProperty( m_xComponent, _rPropertyName, _rValue ); 356 if( xStringResourceResolver.is() ) 357 { 358 Reference< resource::XStringResourceManager > 359 xStringResourceManager( xStringResourceResolver, UNO_QUERY ); 360 if( xStringResourceManager.is() ) 361 { 362 Any aPropertyValue( m_xComponent->getPropertyValue( _rPropertyName ) ); 363 TypeClass eType = aPropertyValue.getValueType().getTypeClass(); 364 if( eType == TypeClass_STRING ) 365 { 366 ::rtl::OUString aPropStr; 367 aPropertyValue >>= aPropStr; 368 if( aPropStr.getLength() > 1 ) 369 { 370 ::rtl::OUString aPureIdStr = aPropStr.copy( 1 ); 371 ::rtl::OUString aValueStr; 372 _rValue >>= aValueStr; 373 xStringResourceManager->setString( aPureIdStr, aValueStr ); 374 aValue = aPropertyValue; // set value to force modified 375 } 376 } 377 // StringItemList? 378 else if( eType == TypeClass_SEQUENCE ) 379 { 380 static ::rtl::OUString aDot = ::rtl::OUString::createFromAscii( "." ); 381 static ::rtl::OUString aEsc = ::rtl::OUString::createFromAscii( "&" ); 382 383 // Put strings into resource using new ids 384 Sequence< ::rtl::OUString > aNewStrings; 385 _rValue >>= aNewStrings; 386 387 const ::rtl::OUString* pNewStrings = aNewStrings.getConstArray(); 388 sal_Int32 nNewCount = aNewStrings.getLength(); 389 390 // Create new Ids 391 ::rtl::OUString* pNewPureIds = new ::rtl::OUString[nNewCount]; 392 ::rtl::OUString aIdStrBase = aDot; 393 Any aNameAny = m_xComponent->getPropertyValue(PROPERTY_NAME); 394 ::rtl::OUString sControlName; 395 aNameAny >>= sControlName; 396 aIdStrBase += sControlName; 397 aIdStrBase += aDot; 398 aIdStrBase += _rPropertyName; 399 sal_Int32 i; 400 ::rtl::OUString aDummyStr; 401 for ( i = 0; i < nNewCount; ++i ) 402 { 403 sal_Int32 nUniqueId = xStringResourceManager->getUniqueNumericId(); 404 ::rtl::OUString aPureIdStr = ::rtl::OUString::valueOf( nUniqueId ); 405 aPureIdStr += aIdStrBase; 406 pNewPureIds[i] = aPureIdStr; 407 // Force usage of next Unique Id 408 xStringResourceManager->setString( aPureIdStr, aDummyStr ); 409 } 410 411 // Move strings to new Ids for all locales 412 Sequence< Locale > aLocaleSeq = xStringResourceManager->getLocales(); 413 const Locale* pLocale = aLocaleSeq.getConstArray(); 414 sal_Int32 nLocaleCount = aLocaleSeq.getLength(); 415 Sequence< ::rtl::OUString > aOldIdStrings; 416 aPropertyValue >>= aOldIdStrings; 417 try 418 { 419 const ::rtl::OUString* pOldIdStrings = aOldIdStrings.getConstArray(); 420 sal_Int32 nOldIdCount = aOldIdStrings.getLength(); 421 for ( i = 0; i < nNewCount; ++i ) 422 { 423 ::rtl::OUString aOldIdStr; 424 ::rtl::OUString aOldPureIdStr; 425 if( i < nOldIdCount ) 426 { 427 aOldIdStr = pOldIdStrings[i]; 428 aOldPureIdStr = aOldIdStr.copy( 1 ); 429 } 430 ::rtl::OUString aNewPureIdStr = pNewPureIds[i]; 431 432 for ( sal_Int32 iLocale = 0; iLocale < nLocaleCount; ++iLocale ) 433 { 434 Locale aLocale = pLocale[iLocale]; 435 436 ::rtl::OUString aResourceStr; 437 if( aOldPureIdStr.getLength() != 0 ) 438 { 439 if( xStringResourceManager->hasEntryForIdAndLocale( aOldPureIdStr, aLocale ) ) 440 { 441 aResourceStr = xStringResourceManager-> 442 resolveStringForLocale( aOldPureIdStr, aLocale ); 443 } 444 } 445 xStringResourceManager->setStringForLocale( aNewPureIdStr, aResourceStr, aLocale ); 446 } 447 } 448 } 449 catch( resource::MissingResourceException & ) 450 {} 451 452 453 // Set new strings for current locale and create 454 // new Id sequence as new property value 455 Sequence< ::rtl::OUString > aNewIdStrings; 456 aNewIdStrings.realloc( nNewCount ); 457 ::rtl::OUString* pNewIdStrings = aNewIdStrings.getArray(); 458 for ( i = 0; i < nNewCount; ++i ) 459 { 460 ::rtl::OUString aPureIdStr = pNewPureIds[i]; 461 ::rtl::OUString aStr = pNewStrings[i]; 462 xStringResourceManager->setString( aPureIdStr, aStr ); 463 464 ::rtl::OUString aIdStr = aEsc; 465 aIdStr += aPureIdStr; 466 pNewIdStrings[i] = aIdStr; 467 } 468 aValue <<= aNewIdStrings; 469 470 // Remove old ids from resource for all locales 471 const ::rtl::OUString* pOldIdStrings = aOldIdStrings.getConstArray(); 472 sal_Int32 nOldIdCount = aOldIdStrings.getLength(); 473 for( i = 0 ; i < nOldIdCount ; ++i ) 474 { 475 ::rtl::OUString aIdStr = pOldIdStrings[i]; 476 ::rtl::OUString aPureIdStr = aIdStr.copy( 1 ); 477 for ( sal_Int32 iLocale = 0; iLocale < nLocaleCount; ++iLocale ) 478 { 479 Locale aLocale = pLocale[iLocale]; 480 try 481 { 482 xStringResourceManager->removeIdForLocale( aPureIdStr, aLocale ); 483 } 484 catch( resource::MissingResourceException & ) 485 {} 486 } 487 } 488 delete[] pNewPureIds; 489 } 490 } 491 } 492 493 m_xComponent->setPropertyValue( _rPropertyName, aValue ); 494 } 495 } 496 497 //-------------------------------------------------------------------- 498 Any SAL_CALL FormComponentPropertyHandler::convertToPropertyValue( const ::rtl::OUString& _rPropertyName, const Any& _rControlValue ) throw (UnknownPropertyException, RuntimeException) 499 { 500 ::osl::MutexGuard aGuard( m_aMutex ); 501 PropertyId nPropId( impl_getPropertyId_throw( _rPropertyName ) ); 502 Property aProperty( impl_getPropertyFromId_throw( nPropId ) ); 503 504 Any aPropertyValue( _rControlValue ); 505 if ( !aPropertyValue.hasValue() ) 506 { 507 if ( ( aProperty.Attributes & PropertyAttribute::MAYBEVOID ) == 0 ) 508 // default construct an instance of the proper type 509 aPropertyValue = Any( NULL, aProperty.Type ); 510 // nothing to do 511 return aPropertyValue; 512 } 513 514 /// care for the special "default" string, translate it to VOID 515 if ( m_aPropertiesWithDefListEntry.find( _rPropertyName ) != m_aPropertiesWithDefListEntry.end() ) 516 { 517 // it's a control with a string list 518 ::rtl::OUString sStringValue; 519 if ( _rControlValue >>= sStringValue ) 520 { // note that ColorListBoxes might transfer values either as string or as css.util.Color, 521 // so this check here is important 522 if ( sStringValue == m_sDefaultValueString ) 523 return Any(); 524 } 525 } 526 527 switch ( nPropId ) 528 { 529 case PROPERTY_ID_DATASOURCE: 530 { 531 ::rtl::OUString sControlValue; 532 OSL_VERIFY( _rControlValue >>= sControlValue ); 533 534 if ( sControlValue.getLength() ) 535 { 536 Reference< XNameAccess > xDatabaseContext; 537 m_aContext.createComponent( (::rtl::OUString)SERVICE_DATABASE_CONTEXT, xDatabaseContext ); 538 if ( !xDatabaseContext.is() || !xDatabaseContext->hasByName( sControlValue ) ) 539 { 540 ::svt::OFileNotation aTransformer(sControlValue); 541 aPropertyValue <<= ::rtl::OUString( aTransformer.get( ::svt::OFileNotation::N_URL ) ); 542 } 543 } 544 } 545 break; // case PROPERTY_ID_DATASOURCE 546 547 case PROPERTY_ID_SHOW_POSITION: 548 case PROPERTY_ID_SHOW_NAVIGATION: 549 case PROPERTY_ID_SHOW_RECORDACTIONS: 550 case PROPERTY_ID_SHOW_FILTERSORT: 551 { 552 ::rtl::OUString sControlValue; 553 OSL_VERIFY( _rControlValue >>= sControlValue ); 554 555 ::std::vector< ::rtl::OUString > aListEntries; 556 tools::StringListResource aRes( PcrRes( RID_RSC_ENUM_SHOWHIDE ), aListEntries ); 557 OSL_ENSURE( aListEntries.size() == 2, "FormComponentPropertyHandler::convertToPropertyValue: broken resource for Show/Hide!" ); 558 sal_Bool bShow = ( aListEntries.size() < 2 ) || ( sControlValue == aListEntries[1] ); 559 560 aPropertyValue <<= bShow; 561 } 562 break; 563 564 case PROPERTY_ID_TARGET_URL: 565 case PROPERTY_ID_IMAGE_URL: 566 { 567 ::rtl::OUString sControlValue; 568 OSL_VERIFY( _rControlValue >>= sControlValue ); 569 // Don't convert a placeholder 570 if ( nPropId == PROPERTY_ID_IMAGE_URL && sControlValue.equals( String( PcrRes( RID_EMBED_IMAGE_PLACEHOLDER ) ) ) ) 571 aPropertyValue <<= sControlValue; 572 else 573 { 574 INetURLObject aDocURL( impl_getDocumentURL_nothrow() ); 575 aPropertyValue <<= (::rtl::OUString)URIHelper::SmartRel2Abs( aDocURL, sControlValue, Link(), false, true, INetURLObject::WAS_ENCODED, INetURLObject::DECODE_TO_IURI ); 576 } 577 } 578 break; 579 580 case PROPERTY_ID_DATEMIN: 581 case PROPERTY_ID_DATEMAX: 582 case PROPERTY_ID_DEFAULT_DATE: 583 case PROPERTY_ID_DATE: 584 { 585 util::Date aDate; 586 OSL_VERIFY( _rControlValue >>= aDate ); 587 aPropertyValue <<= (sal_Int32)DBTypeConversion::toINT32( aDate ); 588 } 589 break; 590 591 case PROPERTY_ID_TIMEMIN: 592 case PROPERTY_ID_TIMEMAX: 593 case PROPERTY_ID_DEFAULT_TIME: 594 case PROPERTY_ID_TIME: 595 { 596 util::Time aTime; 597 OSL_VERIFY( _rControlValue >>= aTime ); 598 aPropertyValue <<= (sal_Int32)DBTypeConversion::toINT32( aTime ); 599 } 600 break; 601 602 case PROPERTY_ID_WRITING_MODE: 603 { 604 aPropertyValue = FormComponentPropertyHandler_Base::convertToPropertyValue( _rPropertyName, _rControlValue ); 605 606 sal_Int16 nNormalizedValue( 2 ); 607 OSL_VERIFY( aPropertyValue >>= nNormalizedValue ); 608 sal_Int16 nWritingMode = WritingMode2::CONTEXT; 609 switch ( nNormalizedValue ) 610 { 611 case 0: nWritingMode = WritingMode2::LR_TB; break; 612 case 1: nWritingMode = WritingMode2::RL_TB; break; 613 case 2: nWritingMode = WritingMode2::CONTEXT; break; 614 default: 615 OSL_ENSURE( false, "FormComponentPropertyHandler::convertToPropertyValue: unexpected 'normalized value' for WritingMode!" ); 616 nWritingMode = WritingMode2::CONTEXT; 617 break; 618 } 619 620 aPropertyValue <<= nWritingMode; 621 } 622 break; 623 624 default: 625 aPropertyValue = FormComponentPropertyHandler_Base::convertToPropertyValue( _rPropertyName, _rControlValue ); 626 break; // default 627 628 } // switch ( nPropId ) 629 630 return aPropertyValue; 631 } 632 633 //-------------------------------------------------------------------- 634 Any SAL_CALL FormComponentPropertyHandler::convertToControlValue( const ::rtl::OUString& _rPropertyName, const Any& _rPropertyValue, const Type& _rControlValueType ) throw (UnknownPropertyException, RuntimeException) 635 { 636 ::osl::MutexGuard aGuard( m_aMutex ); 637 sal_Int32 nPropId = m_pInfoService->getPropertyId( _rPropertyName ); 638 DBG_ASSERT( nPropId != -1, "FormComponentPropertyHandler::convertToPropertyValue: not one of my properties!!" ); 639 640 Property aProperty( impl_getPropertyFromId_throw( nPropId ) ); 641 642 Any aControlValue( _rPropertyValue ); 643 if ( !aControlValue.hasValue() ) 644 { 645 // if the property is represented with a list box or color list box, we need to 646 // translate this into the string "Default" 647 if ( m_aPropertiesWithDefListEntry.find( _rPropertyName ) != m_aPropertiesWithDefListEntry.end() ) 648 aControlValue <<= m_sDefaultValueString; 649 650 return aControlValue; 651 } 652 653 switch ( nPropId ) 654 { 655 ////////////////////////////////////////////////////////////// 656 case PROPERTY_ID_SHOW_POSITION: 657 case PROPERTY_ID_SHOW_NAVIGATION: 658 case PROPERTY_ID_SHOW_RECORDACTIONS: 659 case PROPERTY_ID_SHOW_FILTERSORT: 660 { 661 ::std::vector< ::rtl::OUString > aListEntries; 662 tools::StringListResource aRes( PcrRes( RID_RSC_ENUM_SHOWHIDE ), aListEntries ); 663 OSL_ENSURE( aListEntries.size() == 2, "FormComponentPropertyHandler::convertToControlValue: broken resource for Show/Hide!" ); 664 665 if ( aListEntries.size() == 2 ) 666 { 667 ::rtl::OUString sControlValue = ::comphelper::getBOOL( _rPropertyValue ) 668 ? aListEntries[1] 669 : aListEntries[0]; 670 aControlValue <<= sControlValue; 671 } 672 } 673 break; 674 675 ////////////////////////////////////////////////////////////// 676 case PROPERTY_ID_DATASOURCE: 677 { 678 OSL_ENSURE( _rControlValueType.getTypeClass() == TypeClass_STRING, 679 "FormComponentPropertyHandler::convertToControlValue: wrong ControlValueType!" ); 680 681 ::rtl::OUString sDataSource; 682 _rPropertyValue >>= sDataSource; 683 if ( sDataSource.getLength() ) 684 { 685 ::svt::OFileNotation aTransformer( sDataSource ); 686 sDataSource = aTransformer.get( ::svt::OFileNotation::N_SYSTEM ); 687 } 688 aControlValue <<= sDataSource; 689 } 690 break; 691 692 ////////////////////////////////////////////////////////////// 693 case PROPERTY_ID_CONTROLLABEL: 694 { 695 ::rtl::OUString sControlValue; 696 697 Reference< XPropertySet > xSet; 698 _rPropertyValue >>= xSet; 699 Reference< XPropertySetInfo > xPSI; 700 if ( xSet.is() ) 701 xPSI = xSet->getPropertySetInfo(); 702 if ( xPSI.is() && xPSI->hasPropertyByName( PROPERTY_LABEL ) ) 703 { 704 ::rtl::OUStringBuffer aValue; 705 aValue.append( (sal_Unicode)'<' ); 706 ::rtl::OUString sLabel; 707 OSL_VERIFY( xSet->getPropertyValue( PROPERTY_LABEL ) >>= sLabel ); 708 aValue.append( sLabel ); 709 aValue.append( (sal_Unicode)'>' ); 710 sControlValue = aValue.makeStringAndClear(); 711 } 712 713 aControlValue <<= sControlValue; 714 } 715 break; 716 717 ////////////////////////////////////////////////////////////// 718 case PROPERTY_ID_DATEMIN: 719 case PROPERTY_ID_DATEMAX: 720 case PROPERTY_ID_DEFAULT_DATE: 721 case PROPERTY_ID_DATE: 722 { 723 sal_Int32 nDate = 0; 724 OSL_VERIFY( _rPropertyValue >>= nDate ); 725 aControlValue <<= DBTypeConversion::toDate( nDate ); 726 } 727 break; 728 729 case PROPERTY_ID_TIMEMIN: 730 case PROPERTY_ID_TIMEMAX: 731 case PROPERTY_ID_DEFAULT_TIME: 732 case PROPERTY_ID_TIME: 733 { 734 sal_Int32 nTime = 0; 735 OSL_VERIFY( _rPropertyValue >>= nTime ); 736 aControlValue <<= DBTypeConversion::toTime( nTime ); 737 } 738 break; 739 740 case PROPERTY_ID_WRITING_MODE: 741 { 742 sal_Int16 nWritingMode( WritingMode2::CONTEXT ); 743 OSL_VERIFY( _rPropertyValue >>= nWritingMode ); 744 sal_Int16 nNormalized = 2; 745 switch ( nWritingMode ) 746 { 747 case WritingMode2::LR_TB: nNormalized = 0; break; 748 case WritingMode2::RL_TB: nNormalized = 1; break; 749 case WritingMode2::CONTEXT: nNormalized = 2; break; 750 default: 751 OSL_ENSURE( false, "FormComponentPropertyHandler::convertToControlValue: unsupported API value for WritingMode!" ); 752 nNormalized = 2; 753 break; 754 } 755 756 aControlValue = FormComponentPropertyHandler_Base::convertToControlValue( _rPropertyName, makeAny( nNormalized ), _rControlValueType ); 757 } 758 break; 759 760 case PROPERTY_ID_FONT: 761 { 762 FontDescriptor aFont; 763 OSL_VERIFY( _rPropertyValue >>= aFont ); 764 765 ::rtl::OUStringBuffer displayName; 766 if ( !aFont.Name.getLength() ) 767 { 768 displayName.append( String( PcrRes( RID_STR_FONT_DEFAULT ) ) ); 769 } 770 else 771 { 772 // font name 773 displayName.append( aFont.Name ); 774 displayName.appendAscii( ", " ); 775 776 // font style 777 ::FontWeight eWeight = VCLUnoHelper::ConvertFontWeight( aFont.Weight ); 778 sal_uInt16 nStyleResID = RID_STR_FONTSTYLE_REGULAR; 779 if ( aFont.Slant == FontSlant_ITALIC ) 780 { 781 if ( eWeight > WEIGHT_NORMAL ) 782 nStyleResID = RID_STR_FONTSTYLE_BOLD_ITALIC; 783 else 784 nStyleResID = RID_STR_FONTSTYLE_ITALIC; 785 } 786 else 787 { 788 if ( eWeight > WEIGHT_NORMAL ) 789 nStyleResID = RID_STR_FONTSTYLE_BOLD; 790 } 791 displayName.append( String( PcrRes( nStyleResID ) ) ); 792 793 // font size 794 if ( aFont.Height ) 795 { 796 displayName.appendAscii( ", " ); 797 displayName.append( sal_Int32( aFont.Height ) ); 798 } 799 } 800 801 aControlValue <<= displayName.makeStringAndClear(); 802 } 803 break; 804 805 default: 806 aControlValue = FormComponentPropertyHandler_Base::convertToControlValue( _rPropertyName, _rPropertyValue, _rControlValueType ); 807 break; 808 809 } // switch ( nPropId ) 810 811 return aControlValue; 812 } 813 814 //-------------------------------------------------------------------- 815 PropertyState SAL_CALL FormComponentPropertyHandler::getPropertyState( const ::rtl::OUString& _rPropertyName ) throw (UnknownPropertyException, RuntimeException) 816 { 817 ::osl::MutexGuard aGuard( m_aMutex ); 818 if ( m_xPropertyState.is() ) 819 return m_xPropertyState->getPropertyState( _rPropertyName ); 820 return PropertyState_DIRECT_VALUE; 821 } 822 823 //-------------------------------------------------------------------- 824 void SAL_CALL FormComponentPropertyHandler::addPropertyChangeListener( const Reference< XPropertyChangeListener >& _rxListener ) throw (RuntimeException) 825 { 826 ::osl::MutexGuard aGuard( m_aMutex ); 827 FormComponentPropertyHandler_Base::addPropertyChangeListener( _rxListener ); 828 if ( m_xComponent.is() ) 829 m_xComponent->addPropertyChangeListener( ::rtl::OUString(), _rxListener ); 830 } 831 832 //-------------------------------------------------------------------- 833 void SAL_CALL FormComponentPropertyHandler::removePropertyChangeListener( const Reference< XPropertyChangeListener >& _rxListener ) throw (RuntimeException) 834 { 835 ::osl::MutexGuard aGuard( m_aMutex ); 836 if ( m_xComponent.is() ) 837 m_xComponent->removePropertyChangeListener( ::rtl::OUString(), _rxListener ); 838 FormComponentPropertyHandler_Base::removePropertyChangeListener( _rxListener ); 839 } 840 841 //-------------------------------------------------------------------- 842 void FormComponentPropertyHandler::onNewComponent() 843 { 844 FormComponentPropertyHandler_Base::onNewComponent(); 845 if ( !m_xComponentPropertyInfo.is() && m_xComponent.is() ) 846 throw NullPointerException(); 847 848 m_xPropertyState.set( m_xComponent, UNO_QUERY ); 849 m_eComponentClass = eUnknown; 850 m_bComponentIsSubForm = m_bHaveListSource = m_bHaveCommand = false; 851 m_nClassId = 0; 852 853 impl_initComponentMetaData_throw(); 854 } 855 856 //-------------------------------------------------------------------- 857 Sequence< Property > SAL_CALL FormComponentPropertyHandler::doDescribeSupportedProperties() const 858 { 859 if ( !m_xComponentPropertyInfo.is() ) 860 return Sequence< Property >(); 861 862 ::std::vector< Property > aProperties; 863 864 Sequence< Property > aAllProperties( m_xComponentPropertyInfo->getProperties() ); 865 aProperties.reserve( aAllProperties.getLength() ); 866 867 // filter the properties 868 PropertyId nPropId( 0 ); 869 ::rtl::OUString sDisplayName; 870 871 Property* pProperty = aAllProperties.getArray(); 872 Property* pPropertiesEnd = pProperty + aAllProperties.getLength(); 873 for ( ; pProperty != pPropertiesEnd; ++pProperty ) 874 { 875 nPropId = m_pInfoService->getPropertyId( pProperty->Name ); 876 if ( nPropId == -1 ) 877 continue; 878 pProperty->Handle = nPropId; 879 880 sDisplayName = m_pInfoService->getPropertyTranslation( nPropId ); 881 if ( !sDisplayName.getLength() ) 882 continue; 883 884 sal_uInt32 nPropertyUIFlags = m_pInfoService->getPropertyUIFlags( nPropId ); 885 bool bIsVisibleForForms = ( nPropertyUIFlags & PROP_FLAG_FORM_VISIBLE ) != 0; 886 bool bIsVisibleForDialogs = ( nPropertyUIFlags & PROP_FLAG_DIALOG_VISIBLE ) != 0; 887 888 // depending on whether we're working for a form or a UNO dialog, some 889 // properties are not displayed 890 if ( ( m_eComponentClass == eFormControl && !bIsVisibleForForms ) 891 || ( m_eComponentClass == eDialogControl && !bIsVisibleForDialogs ) 892 ) 893 continue; 894 895 // some generic sanity checks 896 if ( impl_shouldExcludeProperty_nothrow( *pProperty ) ) 897 continue; 898 899 switch ( nPropId ) 900 { 901 case PROPERTY_ID_BORDER: 902 case PROPERTY_ID_TABSTOP: 903 // BORDER and TABSTOP are normalized (see impl_normalizePropertyValue_nothrow) 904 // to not allow VOID values 905 pProperty->Attributes &= ~( PropertyAttribute::MAYBEVOID ); 906 break; 907 908 case PROPERTY_ID_LISTSOURCE: 909 // no cursor source if no Base is installed. #124939# 910 // This fix is not intendend to appear on the main trunk. If you find it there, 911 // please tell me! frank.schoenheit@sun.com 912 if ( SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::E_SDATABASE ) ) 913 const_cast< FormComponentPropertyHandler* >( this )->m_bHaveListSource = true; 914 break; 915 916 case PROPERTY_ID_COMMAND: 917 // no cursor source if no Base is installed. #124939# 918 // This fix is not intendend to appear on the main trunk. If you find it there, 919 // please tell me! frank.schoenheit@sun.com 920 if ( SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::E_SDATABASE ) ) 921 const_cast< FormComponentPropertyHandler* >( this )->m_bHaveCommand = true; 922 break; 923 } // switch ( nPropId ) 924 925 aProperties.push_back( *pProperty ); 926 } 927 928 if ( aProperties.empty() ) 929 return Sequence< Property >(); 930 return Sequence< Property >( &(*aProperties.begin()), aProperties.size() ); 931 } 932 933 //-------------------------------------------------------------------- 934 Sequence< ::rtl::OUString > SAL_CALL FormComponentPropertyHandler::getSupersededProperties( ) throw (RuntimeException) 935 { 936 return Sequence< ::rtl::OUString >( ); 937 } 938 939 //-------------------------------------------------------------------- 940 Sequence< ::rtl::OUString > SAL_CALL FormComponentPropertyHandler::getActuatingProperties( ) throw (RuntimeException) 941 { 942 ::osl::MutexGuard aGuard( m_aMutex ); 943 ::std::vector< ::rtl::OUString > aInterestingProperties; 944 aInterestingProperties.push_back( PROPERTY_DATASOURCE ); 945 aInterestingProperties.push_back( PROPERTY_COMMAND ); 946 aInterestingProperties.push_back( PROPERTY_COMMANDTYPE ); 947 aInterestingProperties.push_back( PROPERTY_LISTSOURCE ); 948 aInterestingProperties.push_back( PROPERTY_LISTSOURCETYPE ); 949 aInterestingProperties.push_back( PROPERTY_SUBMIT_ENCODING ); 950 aInterestingProperties.push_back( PROPERTY_REPEAT ); 951 aInterestingProperties.push_back( PROPERTY_TABSTOP ); 952 aInterestingProperties.push_back( PROPERTY_BORDER ); 953 aInterestingProperties.push_back( PROPERTY_CONTROLSOURCE ); 954 aInterestingProperties.push_back( PROPERTY_DROPDOWN ); 955 aInterestingProperties.push_back( PROPERTY_IMAGE_URL ); 956 aInterestingProperties.push_back( PROPERTY_TARGET_URL ); 957 aInterestingProperties.push_back( PROPERTY_STRINGITEMLIST ); 958 aInterestingProperties.push_back( PROPERTY_BUTTONTYPE ); 959 aInterestingProperties.push_back( PROPERTY_ESCAPE_PROCESSING ); 960 aInterestingProperties.push_back( PROPERTY_TRISTATE ); 961 aInterestingProperties.push_back( PROPERTY_DECIMAL_ACCURACY ); 962 aInterestingProperties.push_back( PROPERTY_SHOWTHOUSANDSEP ); 963 aInterestingProperties.push_back( PROPERTY_FORMATKEY ); 964 aInterestingProperties.push_back( PROPERTY_EMPTY_IS_NULL ); 965 aInterestingProperties.push_back( PROPERTY_TOGGLE ); 966 return Sequence< ::rtl::OUString >( &(*aInterestingProperties.begin()), aInterestingProperties.size() ); 967 } 968 969 //-------------------------------------------------------------------- 970 LineDescriptor SAL_CALL FormComponentPropertyHandler::describePropertyLine( const ::rtl::OUString& _rPropertyName, 971 const Reference< XPropertyControlFactory >& _rxControlFactory ) 972 throw (UnknownPropertyException, NullPointerException, RuntimeException) 973 { 974 if ( !_rxControlFactory.is() ) 975 throw NullPointerException(); 976 977 ::osl::MutexGuard aGuard( m_aMutex ); 978 PropertyId nPropId( impl_getPropertyId_throw( _rPropertyName ) ); 979 Property aProperty( impl_getPropertyFromId_throw( nPropId ) ); 980 981 ////////////////////////////////////////////////////////////////////// 982 // for the MultiLine property, we have different UI translations depending on the control 983 // type 984 if ( nPropId == PROPERTY_ID_MULTILINE ) 985 { 986 if ( ( m_nClassId == FormComponentType::FIXEDTEXT ) 987 || ( m_nClassId == FormComponentType::COMMANDBUTTON ) 988 || ( m_nClassId == FormComponentType::RADIOBUTTON ) 989 || ( m_nClassId == FormComponentType::CHECKBOX ) 990 ) 991 nPropId = PROPERTY_ID_WORDBREAK; 992 } 993 994 String sDisplayName = m_pInfoService->getPropertyTranslation( nPropId ); 995 if ( !sDisplayName.Len() ) 996 { 997 DBG_ERROR( "FormComponentPropertyHandler::describePropertyLine: did getSupportedProperties not work properly?" ); 998 throw UnknownPropertyException(); 999 } 1000 1001 ////////////////////////////////////////////////////////////////////// 1002 1003 LineDescriptor aDescriptor; 1004 aDescriptor.HelpURL = HelpIdUrl::getHelpURL( m_pInfoService->getPropertyHelpId( nPropId ) ); 1005 aDescriptor.DisplayName = sDisplayName; 1006 1007 // for the moment, assume a text field 1008 sal_Int16 nControlType = PropertyControlType::TextField; 1009 sal_Bool bReadOnly = sal_False; 1010 aDescriptor.Control.clear(); 1011 1012 ////////////////////////////////////////////////////////////////////// 1013 1014 bool bNeedDefaultStringIfVoidAllowed = false; 1015 1016 TypeClass eType = aProperty.Type.getTypeClass(); 1017 1018 switch ( nPropId ) 1019 { 1020 case PROPERTY_ID_DEFAULT_SELECT_SEQ: 1021 case PROPERTY_ID_SELECTEDITEMS: 1022 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_SELECTION); 1023 break; 1024 1025 case PROPERTY_ID_FILTER: 1026 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_FILTER); 1027 break; 1028 1029 case PROPERTY_ID_SORT: 1030 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_ORDER); 1031 break; 1032 1033 case PROPERTY_ID_MASTERFIELDS: 1034 case PROPERTY_ID_DETAILFIELDS: 1035 nControlType = PropertyControlType::StringListField; 1036 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_FORMLINKFIELDS); 1037 break; 1038 1039 case PROPERTY_ID_COMMAND: 1040 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_SQLCOMMAND); 1041 break; 1042 1043 case PROPERTY_ID_TABINDEX: 1044 { 1045 Reference< XControlContainer > xControlContext( impl_getContextControlContainer_nothrow() ); 1046 if ( xControlContext.is() ) 1047 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_TABINDEX); 1048 nControlType = PropertyControlType::NumericField; 1049 }; 1050 break; 1051 1052 case PROPERTY_ID_FONT: 1053 bReadOnly = sal_True; 1054 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_FONT_TYPE); 1055 break; 1056 1057 case PROPERTY_ID_TARGET_URL: 1058 case PROPERTY_ID_IMAGE_URL: 1059 { 1060 aDescriptor.Control = new OFileUrlControl( impl_getDefaultDialogParent_nothrow(), WB_TABSTOP | WB_BORDER ); 1061 1062 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(( PROPERTY_ID_TARGET_URL == nPropId ) 1063 ? UID_PROP_DLG_ATTR_TARGET_URL : UID_PROP_DLG_IMAGE_URL); 1064 } 1065 break; 1066 1067 case PROPERTY_ID_ECHO_CHAR: 1068 nControlType = PropertyControlType::CharacterField; 1069 break; 1070 1071 case PROPERTY_ID_BACKGROUNDCOLOR: 1072 case PROPERTY_ID_FILLCOLOR: 1073 case PROPERTY_ID_SYMBOLCOLOR: 1074 case PROPERTY_ID_BORDERCOLOR: 1075 nControlType = PropertyControlType::ColorListBox; 1076 1077 switch( nPropId ) 1078 { 1079 case PROPERTY_ID_BACKGROUNDCOLOR: 1080 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_BACKGROUNDCOLOR); break; 1081 case PROPERTY_ID_FILLCOLOR: 1082 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_FILLCOLOR); break; 1083 case PROPERTY_ID_SYMBOLCOLOR: 1084 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_SYMBOLCOLOR); break; 1085 case PROPERTY_ID_BORDERCOLOR: 1086 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_BORDERCOLOR); break; 1087 } 1088 break; 1089 1090 case PROPERTY_ID_LABEL: 1091 nControlType = PropertyControlType::MultiLineTextField; 1092 break; 1093 1094 case PROPERTY_ID_DEFAULT_TEXT: 1095 { 1096 if (FormComponentType::FILECONTROL == m_nClassId) 1097 nControlType = PropertyControlType::TextField; 1098 else 1099 nControlType = PropertyControlType::MultiLineTextField; 1100 } 1101 break; 1102 1103 case PROPERTY_ID_TEXT: 1104 if ( impl_componentHasProperty_throw( PROPERTY_MULTILINE ) ) 1105 nControlType = PropertyControlType::MultiLineTextField; 1106 break; 1107 1108 case PROPERTY_ID_CONTROLLABEL: 1109 bReadOnly = sal_True; 1110 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_CONTROLLABEL); 1111 break; 1112 1113 case PROPERTY_ID_FORMATKEY: 1114 case PROPERTY_ID_EFFECTIVE_MIN: 1115 case PROPERTY_ID_EFFECTIVE_MAX: 1116 case PROPERTY_ID_EFFECTIVE_DEFAULT: 1117 case PROPERTY_ID_EFFECTIVE_VALUE: 1118 { 1119 // and the supplier is really available 1120 Reference< XNumberFormatsSupplier > xSupplier; 1121 m_xComponent->getPropertyValue( PROPERTY_FORMATSSUPPLIER ) >>= xSupplier; 1122 if (xSupplier.is()) 1123 { 1124 Reference< XUnoTunnel > xTunnel(xSupplier,UNO_QUERY); 1125 DBG_ASSERT(xTunnel.is(), "FormComponentPropertyHandler::describePropertyLine : xTunnel is invalid!"); 1126 SvNumberFormatsSupplierObj* pSupplier = reinterpret_cast<SvNumberFormatsSupplierObj*>(xTunnel->getSomething(SvNumberFormatsSupplierObj::getUnoTunnelId())); 1127 1128 if (pSupplier != NULL) 1129 { 1130 sal_Bool bIsFormatKey = (PROPERTY_ID_FORMATKEY == nPropId); 1131 1132 bReadOnly = bIsFormatKey; 1133 1134 if ( bIsFormatKey ) 1135 { 1136 OFormatSampleControl* pControl = new OFormatSampleControl( impl_getDefaultDialogParent_nothrow(), WB_READONLY | WB_TABSTOP | WB_BORDER ); 1137 aDescriptor.Control = pControl; 1138 pControl->SetFormatSupplier( pSupplier ); 1139 1140 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_NUMBER_FORMAT); 1141 } 1142 else 1143 { 1144 OFormattedNumericControl* pControl = new OFormattedNumericControl( impl_getDefaultDialogParent_nothrow(), WB_TABSTOP | WB_BORDER ); 1145 aDescriptor.Control = pControl; 1146 1147 FormatDescription aDesc; 1148 aDesc.pSupplier = pSupplier; 1149 Any aFormatKeyValue = m_xComponent->getPropertyValue(PROPERTY_FORMATKEY); 1150 if ( !( aFormatKeyValue >>= aDesc.nKey ) ) 1151 aDesc.nKey = 0; 1152 1153 pControl->SetFormatDescription( aDesc ); 1154 } 1155 } 1156 } 1157 } 1158 break; 1159 1160 case PROPERTY_ID_DATEMIN: 1161 case PROPERTY_ID_DATEMAX: 1162 case PROPERTY_ID_DEFAULT_DATE: 1163 case PROPERTY_ID_DATE: 1164 nControlType = PropertyControlType::DateField; 1165 break; 1166 1167 case PROPERTY_ID_TIMEMIN: 1168 case PROPERTY_ID_TIMEMAX: 1169 case PROPERTY_ID_DEFAULT_TIME: 1170 case PROPERTY_ID_TIME: 1171 nControlType = PropertyControlType::TimeField; 1172 break; 1173 1174 case PROPERTY_ID_VALUEMIN: 1175 case PROPERTY_ID_VALUEMAX: 1176 case PROPERTY_ID_DEFAULT_VALUE: 1177 case PROPERTY_ID_VALUE: 1178 { 1179 OFormattedNumericControl* pControl = new OFormattedNumericControl( impl_getDefaultDialogParent_nothrow(), WB_TABSTOP | WB_BORDER | WB_SPIN | WB_REPEAT ); 1180 aDescriptor.Control = pControl; 1181 1182 // we don't set a formatter so the control uses a default (which uses the application 1183 // language and a default numeric format) 1184 // but we set the decimal digits 1185 pControl->SetDecimalDigits( 1186 ::comphelper::getINT16( m_xComponent->getPropertyValue( PROPERTY_DECIMAL_ACCURACY ) ) 1187 ); 1188 1189 // and the thousands separator 1190 pControl->SetThousandsSep( 1191 ::comphelper::getBOOL( m_xComponent->getPropertyValue(PROPERTY_SHOWTHOUSANDSEP) ) 1192 ); 1193 1194 // and the default value for the property 1195 try 1196 { 1197 if (m_xPropertyState.is() && ((PROPERTY_ID_VALUEMIN == nPropId) || (PROPERTY_ID_VALUEMAX == nPropId))) 1198 { 1199 double nDefault = 0; 1200 if ( m_xPropertyState->getPropertyDefault( aProperty.Name ) >>= nDefault ) 1201 pControl->SetDefaultValue( nDefault ); 1202 } 1203 } 1204 catch (Exception&) 1205 { 1206 // just ignore it 1207 } 1208 1209 // and allow empty values only for the default value and the value 1210 pControl->EnableEmptyField( ( PROPERTY_ID_DEFAULT_VALUE == nPropId ) 1211 || ( PROPERTY_ID_VALUE == nPropId ) ); 1212 } 1213 break; 1214 1215 default: 1216 if ( TypeClass_BYTE <= eType && eType <= TypeClass_DOUBLE ) 1217 { 1218 sal_Int16 nDigits = 0; 1219 sal_Int16 nValueUnit = -1; 1220 sal_Int16 nDisplayUnit = -1; 1221 if ( m_eComponentClass == eFormControl ) 1222 { 1223 if ( ( nPropId == PROPERTY_ID_WIDTH ) 1224 || ( nPropId == PROPERTY_ID_ROWHEIGHT ) 1225 || ( nPropId == PROPERTY_ID_HEIGHT ) 1226 ) 1227 { 1228 nValueUnit = MeasureUnit::MM_10TH; 1229 nDisplayUnit = impl_getDocumentMeasurementUnit_throw(); 1230 nDigits = 2; 1231 } 1232 } 1233 1234 Optional< double > aValueNotPresent( sal_False, 0 ); 1235 aDescriptor.Control = PropertyHandlerHelper::createNumericControl( 1236 _rxControlFactory, nDigits, aValueNotPresent, aValueNotPresent, sal_False ); 1237 1238 Reference< XNumericControl > xNumericControl( aDescriptor.Control, UNO_QUERY_THROW ); 1239 if ( nValueUnit != -1 ) 1240 xNumericControl->setValueUnit( nValueUnit ); 1241 if ( nDisplayUnit != -1 ) 1242 xNumericControl->setDisplayUnit( nDisplayUnit ); 1243 } 1244 break; 1245 } 1246 1247 ////////////////////////////////////////////////////////////////////// 1248 if ( eType == TypeClass_SEQUENCE ) 1249 nControlType = PropertyControlType::StringListField; 1250 1251 ////////////////////////////////////////////////////////////////////// 1252 // boolean values 1253 if ( eType == TypeClass_BOOLEAN ) 1254 { 1255 sal_uInt16 nResId = RID_RSC_ENUM_YESNO; 1256 if ( ( nPropId == PROPERTY_ID_SHOW_POSITION ) 1257 || ( nPropId == PROPERTY_ID_SHOW_NAVIGATION ) 1258 || ( nPropId == PROPERTY_ID_SHOW_RECORDACTIONS ) 1259 || ( nPropId == PROPERTY_ID_SHOW_FILTERSORT ) 1260 ) 1261 nResId = RID_RSC_ENUM_SHOWHIDE; 1262 1263 ::std::vector< ::rtl::OUString > aListEntries; 1264 tools::StringListResource aRes(PcrRes(nResId),aListEntries); 1265 aDescriptor.Control = PropertyHandlerHelper::createListBoxControl( _rxControlFactory, aListEntries, sal_False, sal_False ); 1266 bNeedDefaultStringIfVoidAllowed = true; 1267 } 1268 1269 ////////////////////////////////////////////////////////////////////// 1270 // enum properties 1271 sal_uInt32 nPropertyUIFlags = m_pInfoService->getPropertyUIFlags( nPropId ); 1272 bool bIsEnumProperty = ( nPropertyUIFlags & PROP_FLAG_ENUM ) != 0; 1273 if ( bIsEnumProperty || ( PROPERTY_ID_TARGET_FRAME == nPropId ) ) 1274 { 1275 ::std::vector< ::rtl::OUString > aEnumValues = m_pInfoService->getPropertyEnumRepresentations( nPropId ); 1276 ::std::vector< ::rtl::OUString >::const_iterator pStart = aEnumValues.begin(); 1277 ::std::vector< ::rtl::OUString >::const_iterator pEnd = aEnumValues.end(); 1278 1279 // for a checkbox: if "ambiguous" is not allowed, remove this from the sequence 1280 if ( ( PROPERTY_ID_DEFAULT_STATE == nPropId ) 1281 || ( PROPERTY_ID_STATE == nPropId ) 1282 ) 1283 { 1284 if ( impl_componentHasProperty_throw( PROPERTY_TRISTATE ) ) 1285 { 1286 if ( !::comphelper::getBOOL( m_xComponent->getPropertyValue( PROPERTY_TRISTATE ) ) ) 1287 { // remove the last sequence element 1288 if ( pEnd > pStart ) 1289 --pEnd; 1290 } 1291 } 1292 else 1293 --pEnd; 1294 } 1295 1296 if ( PROPERTY_ID_LISTSOURCETYPE == nPropId ) 1297 if ( FormComponentType::COMBOBOX == m_nClassId ) 1298 // remove the first sequence element -> value list not possible for combo boxes 1299 ++pStart; 1300 1301 // copy the sequence 1302 ::std::vector< ::rtl::OUString > aListEntries( pEnd - pStart ); 1303 ::std::copy( pStart, pEnd, aListEntries.begin() ); 1304 1305 // create the control 1306 if ( PROPERTY_ID_TARGET_FRAME == nPropId ) 1307 aDescriptor.Control = PropertyHandlerHelper::createComboBoxControl( _rxControlFactory, aListEntries, sal_False, sal_False ); 1308 else 1309 { 1310 aDescriptor.Control = PropertyHandlerHelper::createListBoxControl( _rxControlFactory, aListEntries, sal_False, sal_False ); 1311 bNeedDefaultStringIfVoidAllowed = true; 1312 } 1313 } 1314 1315 ////////////////////////////////////////////////////////////////////// 1316 switch( nPropId ) 1317 { 1318 case PROPERTY_ID_REPEAT_DELAY: 1319 { 1320 OTimeDurationControl* pControl = new OTimeDurationControl( impl_getDefaultDialogParent_nothrow(), WB_BORDER | WB_TABSTOP ); 1321 aDescriptor.Control = pControl; 1322 1323 pControl->setMinValue( Optional< double >( sal_True, 0 ) ); 1324 pControl->setMaxValue( Optional< double >( sal_True, ::std::numeric_limits< double >::max() ) ); 1325 } 1326 break; 1327 1328 case PROPERTY_ID_TABINDEX: 1329 case PROPERTY_ID_BOUNDCOLUMN: 1330 case PROPERTY_ID_VISIBLESIZE: 1331 case PROPERTY_ID_MAXTEXTLEN: 1332 case PROPERTY_ID_LINEINCREMENT: 1333 case PROPERTY_ID_BLOCKINCREMENT: 1334 case PROPERTY_ID_SPININCREMENT: 1335 { 1336 Optional< double > aMinValue( sal_True, 0 ); 1337 Optional< double > aMaxValue( sal_True, 0x7FFFFFFF ); 1338 1339 if ( nPropId == PROPERTY_ID_MAXTEXTLEN ) 1340 aMinValue.Value = -1; 1341 else if ( nPropId == PROPERTY_ID_VISIBLESIZE ) 1342 aMinValue.Value = 1; 1343 else 1344 aMinValue.Value = 0; 1345 1346 aDescriptor.Control = PropertyHandlerHelper::createNumericControl( 1347 _rxControlFactory, 0, aMinValue, aMaxValue, sal_False ); 1348 } 1349 break; 1350 1351 case PROPERTY_ID_DECIMAL_ACCURACY: 1352 { 1353 Optional< double > aMinValue( sal_True, 0 ); 1354 Optional< double > aMaxValue( sal_True, 20 ); 1355 1356 aDescriptor.Control = PropertyHandlerHelper::createNumericControl( 1357 _rxControlFactory, 0, aMinValue, aMaxValue, sal_False ); 1358 } 1359 break; 1360 1361 ////////////////////////////////////////////////////////////////////// 1362 // DataSource 1363 case PROPERTY_ID_DATASOURCE: 1364 { 1365 aDescriptor.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_ATTR_DATASOURCE); 1366 1367 ::std::vector< ::rtl::OUString > aListEntries; 1368 1369 Reference< XNameAccess > xDatabaseContext; 1370 m_aContext.createComponent( (rtl::OUString)SERVICE_DATABASE_CONTEXT, xDatabaseContext ); 1371 if (xDatabaseContext.is()) 1372 { 1373 Sequence< ::rtl::OUString > aDatasources = xDatabaseContext->getElementNames(); 1374 aListEntries.resize( aDatasources.getLength() ); 1375 ::std::copy( aDatasources.getConstArray(), aDatasources.getConstArray() + aDatasources.getLength(), 1376 aListEntries.begin() ); 1377 } 1378 aDescriptor.Control = PropertyHandlerHelper::createComboBoxControl( 1379 _rxControlFactory, aListEntries, sal_False, sal_True ); 1380 } 1381 break; 1382 1383 case PROPERTY_ID_CONTROLSOURCE: 1384 { 1385 ::std::vector< ::rtl::OUString > aFieldNames; 1386 impl_initFieldList_nothrow( aFieldNames ); 1387 aDescriptor.Control = PropertyHandlerHelper::createComboBoxControl( 1388 _rxControlFactory, aFieldNames, sal_False, sal_False ); 1389 } 1390 break; 1391 1392 case PROPERTY_ID_COMMAND: 1393 impl_describeCursorSource_nothrow( aDescriptor, _rxControlFactory ); 1394 break; 1395 1396 case PROPERTY_ID_LISTSOURCE: 1397 impl_describeListSourceUI_throw( aDescriptor, _rxControlFactory ); 1398 break; 1399 } 1400 1401 if ( !aDescriptor.Control.is() ) 1402 aDescriptor.Control = _rxControlFactory->createPropertyControl( nControlType, bReadOnly ); 1403 1404 if ( ( aProperty.Attributes & PropertyAttribute::MAYBEVOID ) != 0 ) 1405 { 1406 // insert the string "Default" string, if necessary 1407 if ( bNeedDefaultStringIfVoidAllowed || ( nControlType == PropertyControlType::ColorListBox ) ) 1408 { 1409 Reference< XStringListControl > xStringList( aDescriptor.Control, UNO_QUERY_THROW ); 1410 xStringList->prependListEntry( m_sDefaultValueString ); 1411 m_aPropertiesWithDefListEntry.insert( _rPropertyName ); 1412 } 1413 } 1414 1415 if ( aDescriptor.PrimaryButtonId.getLength() ) 1416 aDescriptor.HasPrimaryButton = sal_True; 1417 if ( aDescriptor.SecondaryButtonId.getLength() ) 1418 aDescriptor.HasSecondaryButton = sal_True; 1419 1420 bool bIsDataProperty = ( nPropertyUIFlags & PROP_FLAG_DATA_PROPERTY ) != 0; 1421 aDescriptor.Category = ::rtl::OUString::createFromAscii( bIsDataProperty ? "Data" : "General" ); 1422 return aDescriptor; 1423 } 1424 1425 //-------------------------------------------------------------------- 1426 InteractiveSelectionResult SAL_CALL FormComponentPropertyHandler::onInteractivePropertySelection( const ::rtl::OUString& _rPropertyName, sal_Bool /*_bPrimary*/, Any& _rData, const Reference< XObjectInspectorUI >& _rxInspectorUI ) throw (UnknownPropertyException, NullPointerException, RuntimeException) 1427 { 1428 if ( !_rxInspectorUI.is() ) 1429 throw NullPointerException(); 1430 1431 ::osl::ClearableMutexGuard aGuard( m_aMutex ); 1432 PropertyId nPropId( impl_getPropertyId_throw( _rPropertyName ) ); 1433 1434 InteractiveSelectionResult eResult = InteractiveSelectionResult_Cancelled; 1435 switch ( nPropId ) 1436 { 1437 case PROPERTY_ID_DEFAULT_SELECT_SEQ: 1438 case PROPERTY_ID_SELECTEDITEMS: 1439 if ( impl_dialogListSelection_nothrow( _rPropertyName, aGuard ) ) 1440 eResult = InteractiveSelectionResult_Success; 1441 break; 1442 1443 case PROPERTY_ID_FILTER: 1444 case PROPERTY_ID_SORT: 1445 { 1446 ::rtl::OUString sClause; 1447 if ( impl_dialogFilterOrSort_nothrow( PROPERTY_ID_FILTER == nPropId, sClause, aGuard ) ) 1448 { 1449 _rData <<= sClause; 1450 eResult = InteractiveSelectionResult_ObtainedValue; 1451 } 1452 } 1453 break; 1454 1455 case PROPERTY_ID_MASTERFIELDS: 1456 case PROPERTY_ID_DETAILFIELDS: 1457 if ( impl_dialogLinkedFormFields_nothrow( aGuard ) ) 1458 eResult = InteractiveSelectionResult_Success; 1459 break; 1460 1461 case PROPERTY_ID_FORMATKEY: 1462 if ( impl_dialogFormatting_nothrow( _rData, aGuard ) ) 1463 eResult = InteractiveSelectionResult_ObtainedValue; 1464 break; 1465 1466 case PROPERTY_ID_IMAGE_URL: 1467 if ( impl_browseForImage_nothrow( _rData, aGuard ) ) 1468 eResult = InteractiveSelectionResult_ObtainedValue; 1469 break; 1470 1471 case PROPERTY_ID_TARGET_URL: 1472 if ( impl_browseForTargetURL_nothrow( _rData, aGuard ) ) 1473 eResult = InteractiveSelectionResult_ObtainedValue; 1474 break; 1475 1476 case PROPERTY_ID_FONT: 1477 if ( impl_executeFontDialog_nothrow( _rData, aGuard ) ) 1478 eResult = InteractiveSelectionResult_ObtainedValue; 1479 break; 1480 1481 case PROPERTY_ID_DATASOURCE: 1482 if ( impl_browseForDatabaseDocument_throw( _rData, aGuard ) ) 1483 eResult = InteractiveSelectionResult_ObtainedValue; 1484 break; 1485 1486 case PROPERTY_ID_BACKGROUNDCOLOR: 1487 case PROPERTY_ID_FILLCOLOR: 1488 case PROPERTY_ID_SYMBOLCOLOR: 1489 case PROPERTY_ID_BORDERCOLOR: 1490 if ( impl_dialogColorChooser_throw( nPropId, _rData, aGuard ) ) 1491 eResult = InteractiveSelectionResult_ObtainedValue; 1492 break; 1493 1494 case PROPERTY_ID_CONTROLLABEL: 1495 if ( impl_dialogChooseLabelControl_nothrow( _rData, aGuard ) ) 1496 eResult = InteractiveSelectionResult_ObtainedValue; 1497 break; 1498 1499 case PROPERTY_ID_TABINDEX: 1500 if ( impl_dialogChangeTabOrder_nothrow( aGuard ) ) 1501 eResult = InteractiveSelectionResult_Success; 1502 break; 1503 1504 case PROPERTY_ID_COMMAND: 1505 case PROPERTY_ID_LISTSOURCE: 1506 if ( impl_doDesignSQLCommand_nothrow( _rxInspectorUI, nPropId ) ) 1507 eResult = InteractiveSelectionResult_Pending; 1508 break; 1509 default: 1510 DBG_ERROR( "FormComponentPropertyHandler::onInteractivePropertySelection: request for a property which does not have dedicated UI!" ); 1511 break; 1512 } 1513 return eResult; 1514 } 1515 1516 //-------------------------------------------------------------------- 1517 namespace 1518 { 1519 void lcl_rebuildAndResetCommand( const Reference< XObjectInspectorUI >& _rxInspectorUI, const Reference< XPropertyHandler >& _rxHandler ) 1520 { 1521 OSL_PRECOND( _rxInspectorUI.is(), "lcl_rebuildAndResetCommand: invalid BrowserUI!" ); 1522 OSL_PRECOND( _rxHandler.is(), "lcl_rebuildAndResetCommand: invalid handler!" ); 1523 _rxInspectorUI->rebuildPropertyUI( PROPERTY_COMMAND ); 1524 _rxHandler->setPropertyValue( PROPERTY_COMMAND, makeAny( ::rtl::OUString() ) ); 1525 } 1526 } 1527 1528 //-------------------------------------------------------------------- 1529 void SAL_CALL FormComponentPropertyHandler::actuatingPropertyChanged( const ::rtl::OUString& _rActuatingPropertyName, const Any& _rNewValue, const Any& /*_rOldValue*/, const Reference< XObjectInspectorUI >& _rxInspectorUI, sal_Bool _bFirstTimeInit ) throw (NullPointerException, RuntimeException) 1530 { 1531 if ( !_rxInspectorUI.is() ) 1532 throw NullPointerException(); 1533 1534 ::osl::MutexGuard aGuard( m_aMutex ); 1535 PropertyId nActuatingPropId( impl_getPropertyId_throw( _rActuatingPropertyName ) ); 1536 1537 ::std::vector< PropertyId > aDependentProperties; 1538 1539 switch ( nActuatingPropId ) 1540 { 1541 // ----- EscapeProcessing ----- 1542 case PROPERTY_ID_ESCAPE_PROCESSING: 1543 aDependentProperties.push_back( PROPERTY_ID_FILTER ); 1544 aDependentProperties.push_back( PROPERTY_ID_SORT ); 1545 break; // case PROPERTY_ID_ESCAPE_PROCESSING 1546 1547 // ----- CommandType ----- 1548 case PROPERTY_ID_COMMANDTYPE: 1549 // available commands (tables or queries) might have changed 1550 if ( !_bFirstTimeInit && m_bHaveCommand ) 1551 lcl_rebuildAndResetCommand( _rxInspectorUI, this ); 1552 aDependentProperties.push_back( PROPERTY_ID_COMMAND ); 1553 break; // case PROPERTY_ID_COMMANDTYPE 1554 1555 // ----- DataSourceName ----- 1556 case PROPERTY_ID_DATASOURCE: 1557 // reset the connection, now that we have a new data source 1558 impl_clearRowsetConnection_nothrow(); 1559 1560 // available list source values (tables or queries) might have changed 1561 if ( !_bFirstTimeInit && m_bHaveListSource ) 1562 _rxInspectorUI->rebuildPropertyUI( PROPERTY_LISTSOURCE ); 1563 1564 // available commands (tables or queries) might have changed 1565 if ( !_bFirstTimeInit && m_bHaveCommand ) 1566 lcl_rebuildAndResetCommand( _rxInspectorUI, this ); 1567 1568 // Command also depends on DataSource 1569 aDependentProperties.push_back( PROPERTY_ID_COMMAND ); 1570 // NO break! 1571 1572 // ----- Command ----- 1573 case PROPERTY_ID_COMMAND: 1574 aDependentProperties.push_back( PROPERTY_ID_FILTER ); 1575 aDependentProperties.push_back( PROPERTY_ID_SORT ); 1576 if ( m_bComponentIsSubForm ) 1577 aDependentProperties.push_back( PROPERTY_ID_DETAILFIELDS ); 1578 break; 1579 1580 // ----- ListSourceType ----- 1581 case PROPERTY_ID_LISTSOURCETYPE: 1582 if ( !_bFirstTimeInit && m_bHaveListSource ) 1583 // available list source values (tables or queries) might have changed 1584 _rxInspectorUI->rebuildPropertyUI( PROPERTY_LISTSOURCE ); 1585 aDependentProperties.push_back( PROPERTY_ID_BOUNDCOLUMN ); 1586 aDependentProperties.push_back( PROPERTY_ID_STRINGITEMLIST ); 1587 // NO break! 1588 1589 // ----- StringItemList ----- 1590 case PROPERTY_ID_STRINGITEMLIST: 1591 aDependentProperties.push_back( PROPERTY_ID_SELECTEDITEMS ); 1592 aDependentProperties.push_back( PROPERTY_ID_DEFAULT_SELECT_SEQ ); 1593 break; 1594 1595 // ----- ListSource ----- 1596 case PROPERTY_ID_LISTSOURCE: 1597 aDependentProperties.push_back( PROPERTY_ID_STRINGITEMLIST ); 1598 break; 1599 1600 // ----- DataField ----- 1601 case PROPERTY_ID_CONTROLSOURCE: 1602 { 1603 ::rtl::OUString sControlSource; 1604 _rNewValue >>= sControlSource; 1605 if ( impl_componentHasProperty_throw( PROPERTY_FILTERPROPOSAL ) ) 1606 _rxInspectorUI->enablePropertyUI( PROPERTY_FILTERPROPOSAL, sControlSource.getLength() > 0 ); 1607 if ( impl_componentHasProperty_throw( PROPERTY_EMPTY_IS_NULL ) ) 1608 _rxInspectorUI->enablePropertyUI( PROPERTY_EMPTY_IS_NULL, sControlSource.getLength() > 0 ); 1609 1610 aDependentProperties.push_back( PROPERTY_ID_BOUNDCOLUMN ); 1611 aDependentProperties.push_back( PROPERTY_ID_SCALEIMAGE ); 1612 aDependentProperties.push_back( PROPERTY_ID_SCALE_MODE ); 1613 aDependentProperties.push_back( PROPERTY_ID_INPUT_REQUIRED ); 1614 } 1615 break; 1616 1617 case PROPERTY_ID_EMPTY_IS_NULL: 1618 aDependentProperties.push_back( PROPERTY_ID_INPUT_REQUIRED ); 1619 break; 1620 1621 // ----- SubmitEncoding ----- 1622 case PROPERTY_ID_SUBMIT_ENCODING: 1623 { 1624 FormSubmitEncoding eEncoding = FormSubmitEncoding_URL; 1625 OSL_VERIFY( _rNewValue >>= eEncoding ); 1626 _rxInspectorUI->enablePropertyUI( PROPERTY_SUBMIT_METHOD, eEncoding == FormSubmitEncoding_URL ); 1627 } 1628 break; 1629 1630 // ----- Repeat ----- 1631 case PROPERTY_ID_REPEAT: 1632 { 1633 sal_Bool bIsRepeating = sal_False; 1634 OSL_VERIFY( _rNewValue >>= bIsRepeating ); 1635 _rxInspectorUI->enablePropertyUI( PROPERTY_REPEAT_DELAY, bIsRepeating ); 1636 } 1637 break; 1638 1639 // ----- TabStop ----- 1640 case PROPERTY_ID_TABSTOP: 1641 { 1642 if ( !impl_componentHasProperty_throw( PROPERTY_TABINDEX ) ) 1643 break; 1644 sal_Bool bHasTabStop = sal_False; 1645 _rNewValue >>= bHasTabStop; 1646 _rxInspectorUI->enablePropertyUI( PROPERTY_TABINDEX, bHasTabStop ); 1647 } 1648 break; 1649 1650 // ----- Border ----- 1651 case PROPERTY_ID_BORDER: 1652 { 1653 sal_Int16 nBordeType = VisualEffect::NONE; 1654 OSL_VERIFY( _rNewValue >>= nBordeType ); 1655 _rxInspectorUI->enablePropertyUI( PROPERTY_BORDERCOLOR, nBordeType == VisualEffect::FLAT ); 1656 } 1657 break; 1658 1659 // ----- DropDown ----- 1660 case PROPERTY_ID_DROPDOWN: 1661 { 1662 if ( impl_isSupportedProperty_nothrow( PROPERTY_ID_LINECOUNT ) ) 1663 { 1664 sal_Bool bDropDown = sal_True; 1665 _rNewValue >>= bDropDown; 1666 _rxInspectorUI->enablePropertyUI( PROPERTY_LINECOUNT, bDropDown ); 1667 } 1668 } 1669 break; 1670 1671 // ----- ImageURL ----- 1672 case PROPERTY_ID_IMAGE_URL: 1673 { 1674 if ( impl_isSupportedProperty_nothrow( PROPERTY_ID_IMAGEPOSITION ) ) 1675 { 1676 ::rtl::OUString sImageURL; 1677 OSL_VERIFY( _rNewValue >>= sImageURL ); 1678 _rxInspectorUI->enablePropertyUI( PROPERTY_IMAGEPOSITION, sImageURL.getLength() != 0 ); 1679 } 1680 1681 aDependentProperties.push_back( PROPERTY_ID_SCALEIMAGE ); 1682 aDependentProperties.push_back( PROPERTY_ID_SCALE_MODE ); 1683 } 1684 break; 1685 1686 // ----- ButtonType ----- 1687 case PROPERTY_ID_BUTTONTYPE: 1688 { 1689 FormButtonType eButtonType( FormButtonType_PUSH ); 1690 OSL_VERIFY( _rNewValue >>= eButtonType ); 1691 _rxInspectorUI->enablePropertyUI( PROPERTY_TARGET_URL, FormButtonType_URL == eButtonType ); 1692 } 1693 // NO break! 1694 1695 // ----- TargetURL ----- 1696 case PROPERTY_ID_TARGET_URL: 1697 aDependentProperties.push_back( PROPERTY_ID_TARGET_FRAME ); 1698 break; // case PROPERTY_ID_TARGET_URL 1699 1700 // ----- TriState ----- 1701 case PROPERTY_ID_TRISTATE: 1702 if ( !_bFirstTimeInit ) 1703 _rxInspectorUI->rebuildPropertyUI( m_eComponentClass == eFormControl ? PROPERTY_DEFAULT_STATE : PROPERTY_STATE ); 1704 break; // case PROPERTY_ID_TRISTATE 1705 1706 // ----- DecimalAccuracy ----- 1707 case PROPERTY_ID_DECIMAL_ACCURACY: 1708 // ----- ShowThousandsSeparator ----- 1709 case PROPERTY_ID_SHOWTHOUSANDSEP: 1710 { 1711 sal_Bool bAccuracy = (PROPERTY_ID_DECIMAL_ACCURACY == nActuatingPropId); 1712 sal_uInt16 nNewDigits = 0; 1713 sal_Bool bUseSep = sal_False; 1714 if ( bAccuracy ) 1715 OSL_VERIFY( _rNewValue >>= nNewDigits ); 1716 else 1717 OSL_VERIFY( _rNewValue >>= bUseSep ); 1718 1719 // propagate the changes to the min/max/default fields 1720 Any aCurrentProp; 1721 ::rtl::OUString aAffectedProps[] = { PROPERTY_VALUE, PROPERTY_DEFAULT_VALUE, PROPERTY_VALUEMIN, PROPERTY_VALUEMAX }; 1722 for (sal_uInt16 i=0; i<sizeof(aAffectedProps)/sizeof(aAffectedProps[0]); ++i) 1723 { 1724 Reference< XPropertyControl > xControl; 1725 try 1726 { 1727 xControl = _rxInspectorUI->getPropertyControl( aAffectedProps[i] ); 1728 } 1729 catch( const UnknownPropertyException& e ) { (void)e; } 1730 if ( xControl.is() ) 1731 { 1732 OFormattedNumericControl* pControl = dynamic_cast< OFormattedNumericControl* >( xControl.get() ); 1733 DBG_ASSERT( pControl, "FormComponentPropertyHandler::actuatingPropertyChanged: invalid control!" ); 1734 if ( pControl ) 1735 { 1736 if ( bAccuracy ) 1737 pControl->SetDecimalDigits( nNewDigits ); 1738 else 1739 pControl->SetThousandsSep( bUseSep ); 1740 } 1741 } 1742 } 1743 } 1744 break; 1745 1746 // ----- FormatKey ----- 1747 case PROPERTY_ID_FORMATKEY: 1748 { 1749 FormatDescription aNewDesc; 1750 1751 Reference< XNumberFormatsSupplier > xSupplier; 1752 OSL_VERIFY( m_xComponent->getPropertyValue( PROPERTY_FORMATSSUPPLIER ) >>= xSupplier ); 1753 1754 Reference< XUnoTunnel > xTunnel( xSupplier, UNO_QUERY ); 1755 DBG_ASSERT(xTunnel.is(), "FormComponentPropertyHandler::actuatingPropertyChanged: xTunnel is invalid!"); 1756 if ( xTunnel.is() ) 1757 { 1758 SvNumberFormatsSupplierObj* pSupplier = reinterpret_cast<SvNumberFormatsSupplierObj*>(xTunnel->getSomething(SvNumberFormatsSupplierObj::getUnoTunnelId())); 1759 // the same again 1760 1761 aNewDesc.pSupplier = pSupplier; 1762 if ( !( _rNewValue >>= aNewDesc.nKey ) ) 1763 aNewDesc.nKey = 0; 1764 1765 // give each control which has to know this an own copy of the description 1766 ::rtl::OUString aFormattedPropertyControls[] = { 1767 PROPERTY_EFFECTIVE_MIN, PROPERTY_EFFECTIVE_MAX, PROPERTY_EFFECTIVE_DEFAULT, PROPERTY_EFFECTIVE_VALUE 1768 }; 1769 for ( sal_uInt16 i=0; i<sizeof(aFormattedPropertyControls)/sizeof(aFormattedPropertyControls[0]); ++i ) 1770 { 1771 Reference< XPropertyControl > xControl; 1772 try 1773 { 1774 xControl = _rxInspectorUI->getPropertyControl( aFormattedPropertyControls[i] ); 1775 } 1776 catch( const UnknownPropertyException& e ) { (void)e; } 1777 if ( xControl.is() ) 1778 { 1779 OFormattedNumericControl* pControl = dynamic_cast< OFormattedNumericControl* >( xControl.get() ); 1780 DBG_ASSERT( pControl, "FormComponentPropertyHandler::actuatingPropertyChanged: invalid control!" ); 1781 if ( pControl ) 1782 pControl->SetFormatDescription( aNewDesc ); 1783 } 1784 } 1785 } 1786 } 1787 break; 1788 1789 case PROPERTY_ID_TOGGLE: 1790 { 1791 sal_Bool bIsToggleButton = sal_False; 1792 OSL_VERIFY( _rNewValue >>= bIsToggleButton ); 1793 _rxInspectorUI->enablePropertyUI( PROPERTY_DEFAULT_STATE, bIsToggleButton ); 1794 } 1795 break; 1796 1797 default: 1798 DBG_ERROR( "FormComponentPropertyHandler::actuatingPropertyChanged: did not register for this property!" ); 1799 break; 1800 1801 } // switch ( nActuatingPropId ) 1802 1803 for ( ::std::vector< PropertyId >::const_iterator loopAffected = aDependentProperties.begin(); 1804 loopAffected != aDependentProperties.end(); 1805 ++loopAffected 1806 ) 1807 { 1808 if ( impl_isSupportedProperty_nothrow( *loopAffected ) ) 1809 impl_updateDependentProperty_nothrow( *loopAffected, _rxInspectorUI ); 1810 } 1811 } 1812 1813 //------------------------------------------------------------------------ 1814 void FormComponentPropertyHandler::impl_updateDependentProperty_nothrow( PropertyId _nPropId, const Reference< XObjectInspectorUI >& _rxInspectorUI ) const 1815 { 1816 try 1817 { 1818 switch ( _nPropId ) 1819 { 1820 // ----- StringItemList ----- 1821 case PROPERTY_ID_STRINGITEMLIST: 1822 { 1823 ListSourceType eLSType = ListSourceType_VALUELIST; 1824 OSL_VERIFY( impl_getPropertyValue_throw( PROPERTY_LISTSOURCETYPE ) >>= eLSType ); 1825 1826 ::rtl::OUString sListSource; 1827 { 1828 Sequence< ::rtl::OUString > aListSource; 1829 Any aListSourceValue( impl_getPropertyValue_throw( PROPERTY_LISTSOURCE ) ); 1830 if ( aListSourceValue >>= aListSource ) 1831 { 1832 if ( aListSource.getLength() ) 1833 sListSource = aListSource[0]; 1834 } 1835 else 1836 OSL_VERIFY( aListSourceValue >>= sListSource ); 1837 } 1838 1839 sal_Bool bIsEnabled = ( ( eLSType == ListSourceType_VALUELIST ) 1840 || ( sListSource.getLength() == 0 ) 1841 ); 1842 _rxInspectorUI->enablePropertyUI( PROPERTY_STRINGITEMLIST, bIsEnabled ); 1843 } 1844 break; // case PROPERTY_ID_STRINGITEMLIST 1845 1846 // ----- BoundColumn ----- 1847 case PROPERTY_ID_BOUNDCOLUMN: 1848 { 1849 ::rtl::OUString sControlSource; 1850 OSL_VERIFY( impl_getPropertyValue_throw( PROPERTY_CONTROLSOURCE ) >>= sControlSource ); 1851 1852 ListSourceType eLSType = ListSourceType_VALUELIST; 1853 OSL_VERIFY( impl_getPropertyValue_throw( PROPERTY_LISTSOURCETYPE ) >>= eLSType ); 1854 1855 _rxInspectorUI->enablePropertyUI( PROPERTY_BOUNDCOLUMN, 1856 ( sControlSource.getLength() > 0 ) 1857 && ( eLSType != ListSourceType_TABLEFIELDS ) 1858 && ( eLSType != ListSourceType_VALUELIST ) 1859 ); 1860 } 1861 break; // case PROPERTY_ID_BOUNDCOLUMN 1862 1863 // ----- ScaleImage, ScaleMode ----- 1864 case PROPERTY_ID_SCALEIMAGE: 1865 case PROPERTY_ID_SCALE_MODE: 1866 { 1867 ::rtl::OUString sControlSource; 1868 if ( impl_isSupportedProperty_nothrow( PROPERTY_ID_CONTROLSOURCE ) ) 1869 impl_getPropertyValue_throw( PROPERTY_CONTROLSOURCE ) >>= sControlSource; 1870 1871 ::rtl::OUString sImageURL; 1872 impl_getPropertyValue_throw( PROPERTY_IMAGE_URL ) >>= sImageURL; 1873 1874 _rxInspectorUI->enablePropertyUI( impl_getPropertyNameFromId_nothrow( _nPropId ), 1875 ( sControlSource.getLength() != 0 ) || ( sImageURL.getLength() != 0 ) 1876 ); 1877 } 1878 break; // case PROPERTY_ID_SCALEIMAGE, PROPERTY_ID_SCALE_MODE 1879 1880 // ----- InputRequired ----- 1881 case PROPERTY_ID_INPUT_REQUIRED: 1882 { 1883 ::rtl::OUString sControlSource; 1884 OSL_VERIFY( impl_getPropertyValue_throw( PROPERTY_CONTROLSOURCE ) >>= sControlSource ); 1885 1886 sal_Bool bEmptyIsNULL = sal_False; 1887 sal_Bool bHasEmptyIsNULL = impl_componentHasProperty_throw( PROPERTY_EMPTY_IS_NULL ); 1888 if ( bHasEmptyIsNULL ) 1889 OSL_VERIFY( impl_getPropertyValue_throw( PROPERTY_EMPTY_IS_NULL ) >>= bEmptyIsNULL ); 1890 1891 // if the control is not bound to a DB field, there is no sense in having the "Input required" 1892 // property 1893 // Also, if an empty input of this control are *not* written as NULL, but as empty strings, 1894 // then "Input required" does not make sense, too (since there's always an input, even if the control 1895 // is empty). 1896 _rxInspectorUI->enablePropertyUI( PROPERTY_INPUT_REQUIRED, 1897 ( sControlSource.getLength() != 0 ) && ( !bHasEmptyIsNULL || bEmptyIsNULL ) 1898 ); 1899 } 1900 break; 1901 1902 // ----- SelectedItems, DefaultSelection ----- 1903 case PROPERTY_ID_SELECTEDITEMS: 1904 case PROPERTY_ID_DEFAULT_SELECT_SEQ: 1905 { 1906 Sequence< ::rtl::OUString > aEntries; 1907 impl_getPropertyValue_throw( PROPERTY_STRINGITEMLIST ) >>= aEntries; 1908 bool isEnabled = aEntries.getLength() != 0; 1909 1910 if ( ( m_nClassId == FormComponentType::LISTBOX ) && ( m_eComponentClass == eFormControl ) ) 1911 { 1912 ListSourceType eLSType = ListSourceType_VALUELIST; 1913 impl_getPropertyValue_throw( PROPERTY_LISTSOURCETYPE ) >>= eLSType; 1914 isEnabled &= ( eLSType == ListSourceType_VALUELIST ); 1915 } 1916 _rxInspectorUI->enablePropertyUIElements( impl_getPropertyNameFromId_nothrow( _nPropId ), 1917 PropertyLineElement::PrimaryButton, isEnabled ); 1918 } 1919 break; // case PROPERTY_ID_DEFAULT_SELECT_SEQ 1920 1921 // ----- TargetFrame ------ 1922 case PROPERTY_ID_TARGET_FRAME: 1923 { 1924 ::rtl::OUString sTargetURL; 1925 impl_getPropertyValue_throw( PROPERTY_TARGET_URL ) >>= sTargetURL; 1926 FormButtonType eButtonType( FormButtonType_URL ); 1927 if ( 0 != m_nClassId ) 1928 { 1929 OSL_VERIFY( impl_getPropertyValue_throw( PROPERTY_BUTTONTYPE ) >>= eButtonType ); 1930 } 1931 // if m_nClassId is 0, then we're inspecting a form. In this case, eButtonType is always 1932 // FormButtonType_URL here 1933 _rxInspectorUI->enablePropertyUI( PROPERTY_TARGET_FRAME, 1934 ( eButtonType == FormButtonType_URL ) && ( sTargetURL.getLength() > 0 ) 1935 ); 1936 } 1937 break; 1938 1939 // ----- Order ------ 1940 case PROPERTY_ID_SORT: 1941 // ----- Filter ------ 1942 case PROPERTY_ID_FILTER: 1943 { 1944 Reference< XConnection > xConnection; 1945 bool bAllowEmptyDS = ::dbtools::isEmbeddedInDatabase( m_xComponent, xConnection ); 1946 1947 // if there's no escape processing, we cannot enter any values for this property 1948 sal_Bool bDoEscapeProcessing( sal_False ); 1949 impl_getPropertyValue_throw( PROPERTY_ESCAPE_PROCESSING ) >>= bDoEscapeProcessing; 1950 _rxInspectorUI->enablePropertyUI( 1951 impl_getPropertyNameFromId_nothrow( _nPropId ), 1952 bDoEscapeProcessing 1953 ); 1954 1955 // also care for the browse button - enabled if we have escape processing, and a valid 1956 // data source signature 1957 _rxInspectorUI->enablePropertyUIElements( 1958 impl_getPropertyNameFromId_nothrow( _nPropId ), 1959 PropertyLineElement::PrimaryButton, 1960 impl_hasValidDataSourceSignature_nothrow( m_xComponent, bAllowEmptyDS ) 1961 && bDoEscapeProcessing 1962 ); 1963 } 1964 break; // case PROPERTY_ID_FILTER: 1965 1966 // ----- Command ----- 1967 case PROPERTY_ID_COMMAND: 1968 { 1969 sal_Int32 nCommandType( CommandType::COMMAND ); 1970 OSL_VERIFY( impl_getPropertyValue_throw( PROPERTY_COMMANDTYPE ) >>= nCommandType ); 1971 1972 impl_ensureRowsetConnection_nothrow(); 1973 Reference< XConnection > xConnection = m_xRowSetConnection.getTyped(); 1974 bool bAllowEmptyDS = false; 1975 if ( !xConnection.is() ) 1976 bAllowEmptyDS = ::dbtools::isEmbeddedInDatabase( m_xComponent, xConnection ); 1977 1978 bool doEnable = ( nCommandType == CommandType::COMMAND ) 1979 && ( m_xRowSetConnection.is() 1980 || xConnection.is() 1981 || impl_hasValidDataSourceSignature_nothrow( m_xComponent, bAllowEmptyDS) 1982 ); 1983 1984 _rxInspectorUI->enablePropertyUIElements( 1985 PROPERTY_COMMAND, 1986 PropertyLineElement::PrimaryButton, 1987 doEnable 1988 ); 1989 } 1990 break; // case PROPERTY_ID_COMMAND 1991 1992 // ----- DetailFields ----- 1993 case PROPERTY_ID_DETAILFIELDS: 1994 { 1995 Reference< XConnection > xConnection; 1996 bool bAllowEmptyDS = ::dbtools::isEmbeddedInDatabase( m_xComponent, xConnection ); 1997 1998 // both our current form, and it's parent form, need to have a valid 1999 // data source signature 2000 bool bDoEnableMasterDetailFields = 2001 impl_hasValidDataSourceSignature_nothrow( m_xComponent, bAllowEmptyDS ) 2002 && impl_hasValidDataSourceSignature_nothrow( Reference< XPropertySet >( m_xObjectParent, UNO_QUERY ), bAllowEmptyDS ); 2003 2004 // in opposite to the other properties, here in real *two* properties are 2005 // affected 2006 _rxInspectorUI->enablePropertyUIElements( PROPERTY_DETAILFIELDS, PropertyLineElement::PrimaryButton, bDoEnableMasterDetailFields ); 2007 _rxInspectorUI->enablePropertyUIElements( PROPERTY_MASTERFIELDS, PropertyLineElement::PrimaryButton, bDoEnableMasterDetailFields ); 2008 } 2009 break; 2010 2011 default: 2012 OSL_ENSURE( false, "FormComponentPropertyHandler::impl_updateDependentProperty_nothrow: unexpected property to update!" ); 2013 break; 2014 2015 } // switch 2016 } 2017 catch( const Exception& ) 2018 { 2019 OSL_ENSURE( sal_False, "FormComponentPropertyHandler::impl_updateDependentProperty_nothrow: caught an exception!" ); 2020 } 2021 } 2022 2023 //------------------------------------------------------------------------ 2024 void SAL_CALL FormComponentPropertyHandler::disposing() 2025 { 2026 FormComponentPropertyHandler_Base::disposing(); 2027 if ( m_xCommandDesigner.is() && m_xCommandDesigner->isActive() ) 2028 m_xCommandDesigner->dispose(); 2029 } 2030 2031 //------------------------------------------------------------------------ 2032 sal_Bool SAL_CALL FormComponentPropertyHandler::suspend( sal_Bool _bSuspend ) throw (RuntimeException) 2033 { 2034 ::osl::MutexGuard aGuard( m_aMutex ); 2035 if ( _bSuspend ) 2036 if ( m_xCommandDesigner.is() && m_xCommandDesigner->isActive() ) 2037 return m_xCommandDesigner->suspend(); 2038 return sal_True; 2039 } 2040 2041 //------------------------------------------------------------------------ 2042 void FormComponentPropertyHandler::impl_initComponentMetaData_throw() 2043 { 2044 try 2045 { 2046 ////////////////////////////////////////////////////////////////// 2047 // component class 2048 m_eComponentClass = eUnknown; 2049 2050 if ( impl_componentHasProperty_throw( PROPERTY_WIDTH ) 2051 && impl_componentHasProperty_throw( PROPERTY_HEIGHT ) 2052 && impl_componentHasProperty_throw( PROPERTY_POSITIONX ) 2053 && impl_componentHasProperty_throw( PROPERTY_POSITIONY ) 2054 && impl_componentHasProperty_throw( PROPERTY_STEP ) 2055 && impl_componentHasProperty_throw( PROPERTY_TABINDEX ) 2056 ) 2057 { 2058 m_eComponentClass = eDialogControl; 2059 } 2060 else 2061 { 2062 m_eComponentClass = eFormControl; 2063 } 2064 2065 ////////////////////////////////////////////////////////////////// 2066 // (database) sub form? 2067 Reference< XForm > xAsForm( m_xComponent, UNO_QUERY ); 2068 if ( xAsForm.is() ) 2069 { 2070 Reference< XChild > xFormAsChild( xAsForm, UNO_QUERY ); 2071 Reference< XForm > xFormsParent; 2072 if ( xFormAsChild.is() ) 2073 xFormsParent = xFormsParent.query( xFormAsChild->getParent() ); 2074 m_bComponentIsSubForm = xFormsParent.is(); 2075 } 2076 2077 ////////////////////////////////////////////////////////////////// 2078 // ClassId 2079 Reference< XChild > xCompAsChild( m_xComponent, UNO_QUERY ); 2080 if ( xCompAsChild.is() ) 2081 m_xObjectParent = xCompAsChild->getParent(); 2082 2083 ////////////////////////////////////////////////////////////////// 2084 // ClassId 2085 impl_classifyControlModel_throw(); 2086 } 2087 catch( const RuntimeException& ) 2088 { 2089 throw; 2090 } 2091 catch( const Exception& ) 2092 { 2093 OSL_ENSURE( sal_False, "FormComponentPropertyHandler::impl_initComponentMetaData_throw: caught an exception!" ); 2094 } 2095 } 2096 2097 //------------------------------------------------------------------------ 2098 void FormComponentPropertyHandler::impl_classifyControlModel_throw( ) 2099 { 2100 if ( impl_componentHasProperty_throw( PROPERTY_CLASSID ) ) 2101 { 2102 OSL_VERIFY( m_xComponent->getPropertyValue( PROPERTY_CLASSID ) >>= m_nClassId ); 2103 } 2104 else if ( eDialogControl == m_eComponentClass ) 2105 { 2106 Reference< XControlModel > xControlModel( m_xComponent, UNO_QUERY ); 2107 Reference< XServiceInfo > xServiceInfo( m_xComponent, UNO_QUERY ); 2108 if ( xServiceInfo.is() ) 2109 { 2110 // it's a control model, and can tell about it's supported services 2111 m_nClassId = FormComponentType::CONTROL; 2112 2113 const sal_Char* aControlModelServiceNames[] = 2114 { 2115 "UnoControlButtonModel", 2116 "UnoControlCheckBoxModel", 2117 "UnoControlComboBoxModel", 2118 "UnoControlCurrencyFieldModel", 2119 "UnoControlDateFieldModel", 2120 "UnoControlEditModel", 2121 "UnoControlFileControlModel", 2122 "UnoControlFixedTextModel", 2123 "UnoControlGroupBoxModel", 2124 "UnoControlImageControlModel", 2125 "UnoControlListBoxModel", 2126 "UnoControlNumericFieldModel", 2127 "UnoControlPatternFieldModel", 2128 "UnoControlRadioButtonModel", 2129 "UnoControlScrollBarModel", 2130 "UnoControlSpinButtonModel", 2131 "UnoControlTimeFieldModel", 2132 2133 "UnoControlFixedLineModel", 2134 "UnoControlFormattedFieldModel", 2135 "UnoControlProgressBarModel" 2136 }; 2137 const sal_Int16 nClassIDs[] = 2138 { 2139 FormComponentType::COMMANDBUTTON, 2140 FormComponentType::CHECKBOX, 2141 FormComponentType::COMBOBOX, 2142 FormComponentType::CURRENCYFIELD, 2143 FormComponentType::DATEFIELD, 2144 FormComponentType::TEXTFIELD, 2145 FormComponentType::FILECONTROL, 2146 FormComponentType::FIXEDTEXT, 2147 FormComponentType::GROUPBOX, 2148 FormComponentType::IMAGECONTROL, 2149 FormComponentType::LISTBOX, 2150 FormComponentType::NUMERICFIELD, 2151 FormComponentType::PATTERNFIELD, 2152 FormComponentType::RADIOBUTTON, 2153 FormComponentType::SCROLLBAR, 2154 FormComponentType::SPINBUTTON, 2155 FormComponentType::TIMEFIELD, 2156 2157 ControlType::FIXEDLINE, 2158 ControlType::FORMATTEDFIELD, 2159 ControlType::PROGRESSBAR 2160 }; 2161 2162 sal_Int32 nKnownControlTypes = sizeof( aControlModelServiceNames ) / sizeof( aControlModelServiceNames[ 0 ] ); 2163 OSL_ENSURE( nKnownControlTypes == sizeof( nClassIDs ) / sizeof( nClassIDs[ 0 ] ), 2164 "FormComponentPropertyHandler::impl_classifyControlModel_throw: inconsistence" ); 2165 2166 for ( sal_Int32 i = 0; i < nKnownControlTypes; ++i ) 2167 { 2168 ::rtl::OUString sServiceName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.awt." ) ); 2169 sServiceName += ::rtl::OUString::createFromAscii( aControlModelServiceNames[ i ] ); 2170 2171 if ( xServiceInfo->supportsService( sServiceName ) ) 2172 { 2173 m_nClassId = nClassIDs[ i ]; 2174 break; 2175 } 2176 } 2177 } 2178 } 2179 } 2180 2181 //------------------------------------------------------------------------ 2182 void FormComponentPropertyHandler::impl_normalizePropertyValue_nothrow( Any& _rValue, PropertyId _nPropId ) const 2183 { 2184 switch ( _nPropId ) 2185 { 2186 case PROPERTY_ID_TABSTOP: 2187 if ( !_rValue.hasValue() ) 2188 { 2189 switch ( m_nClassId ) 2190 { 2191 case FormComponentType::COMMANDBUTTON: 2192 case FormComponentType::RADIOBUTTON: 2193 case FormComponentType::CHECKBOX: 2194 case FormComponentType::TEXTFIELD: 2195 case FormComponentType::LISTBOX: 2196 case FormComponentType::COMBOBOX: 2197 case FormComponentType::FILECONTROL: 2198 case FormComponentType::DATEFIELD: 2199 case FormComponentType::TIMEFIELD: 2200 case FormComponentType::NUMERICFIELD: 2201 case ControlType::FORMATTEDFIELD: 2202 case FormComponentType::CURRENCYFIELD: 2203 case FormComponentType::PATTERNFIELD: 2204 _rValue = makeAny( (sal_Bool)sal_True ); 2205 break; 2206 default: 2207 _rValue = makeAny( (sal_Bool)sal_False ); 2208 break; 2209 } 2210 } 2211 break; 2212 } 2213 } 2214 2215 //------------------------------------------------------------------------ 2216 bool FormComponentPropertyHandler::impl_shouldExcludeProperty_nothrow( const Property& _rProperty ) const 2217 { 2218 OSL_ENSURE( _rProperty.Handle == m_pInfoService->getPropertyId( _rProperty.Name ), 2219 "FormComponentPropertyHandler::impl_shouldExcludeProperty_nothrow: insonsistency in the property!" ); 2220 2221 if ( _rProperty.Handle == PROPERTY_ID_CONTROLLABEL ) 2222 // prevent that this is caught below 2223 return false; 2224 2225 if ( ( _rProperty.Type.getTypeClass() == TypeClass_INTERFACE ) 2226 || ( _rProperty.Type.getTypeClass() == TypeClass_ARRAY ) 2227 || ( _rProperty.Type.getTypeClass() == TypeClass_UNKNOWN ) 2228 ) 2229 return true; 2230 2231 if ( ( _rProperty.Attributes & PropertyAttribute::TRANSIENT ) && ( m_eComponentClass != eDialogControl ) ) 2232 // strange enough, dialog controls declare a lot of their properties as transient 2233 return true; 2234 2235 if ( _rProperty.Attributes & PropertyAttribute::READONLY ) 2236 return true; 2237 2238 switch ( _rProperty.Handle ) 2239 { 2240 case PROPERTY_ID_MASTERFIELDS: 2241 case PROPERTY_ID_DETAILFIELDS: 2242 if ( !m_bComponentIsSubForm ) 2243 // no master and detail fields for forms which are no sub forms 2244 return true; 2245 break; 2246 2247 case PROPERTY_ID_DATASOURCE: 2248 { 2249 // don't show DataSource if the component is part of an embedded form document 2250 Reference< XConnection > xConn; 2251 if ( isEmbeddedInDatabase( m_xComponent, xConn ) ) 2252 return true; 2253 } 2254 break; 2255 2256 case PROPERTY_ID_TEXT: 2257 // don't show the "Text" property of formatted fields 2258 if ( ControlType::FORMATTEDFIELD == m_nClassId ) 2259 return true; 2260 break; 2261 2262 case PROPERTY_ID_FORMATKEY: 2263 case PROPERTY_ID_EFFECTIVE_MIN: 2264 case PROPERTY_ID_EFFECTIVE_MAX: 2265 case PROPERTY_ID_EFFECTIVE_DEFAULT: 2266 case PROPERTY_ID_EFFECTIVE_VALUE: 2267 // only if the set has a formats supplier, too 2268 if ( !impl_componentHasProperty_throw( PROPERTY_FORMATSSUPPLIER ) ) 2269 return true; 2270 // (form) date and time fields also have a formats supplier, but the format itself 2271 // is reflected in another property 2272 if ( ( FormComponentType::DATEFIELD == m_nClassId ) 2273 || ( FormComponentType::TIMEFIELD == m_nClassId ) 2274 ) 2275 return true; 2276 break; 2277 2278 case PROPERTY_ID_SCALEIMAGE: 2279 if ( impl_componentHasProperty_throw( PROPERTY_SCALE_MODE ) ) 2280 // ScaleImage is superseded by ScaleMode 2281 return true; 2282 break; 2283 2284 case PROPERTY_ID_WRITING_MODE: 2285 if ( !SvtCTLOptions().IsCTLFontEnabled() ) 2286 return true; 2287 break; 2288 } 2289 2290 sal_uInt32 nPropertyUIFlags = m_pInfoService->getPropertyUIFlags( _rProperty.Handle ); 2291 2292 // don't show experimental properties unless allowed to do so 2293 if ( ( nPropertyUIFlags & PROP_FLAG_EXPERIMENTAL ) != 0 ) 2294 { 2295 if ( true ) // TODO 2296 return true; 2297 } 2298 2299 // no data properties if no Base is installed. #124939# 2300 // This fix is not intendend to appear on the main trunk. If you find it there, 2301 // please tell me! frank.schoenheit@sun.com 2302 if ( ( nPropertyUIFlags & PROP_FLAG_DATA_PROPERTY ) != 0 ) 2303 if ( !SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::E_SDATABASE ) ) 2304 return true; 2305 2306 return false; 2307 } 2308 2309 //------------------------------------------------------------------------ 2310 Reference< XRowSet > FormComponentPropertyHandler::impl_getRowSet_throw( ) const 2311 { 2312 Reference< XRowSet > xRowSet = m_xRowSet; 2313 if ( !xRowSet.is() ) 2314 { 2315 xRowSet.set( m_xComponent, UNO_QUERY ); 2316 if ( !xRowSet.is() ) 2317 { 2318 xRowSet = Reference< XRowSet >( m_xObjectParent, UNO_QUERY ); 2319 if ( !xRowSet.is() ) 2320 { 2321 // are we inspecting a grid column? 2322 if (Reference< XGridColumnFactory >( m_xObjectParent, UNO_QUERY) .is()) 2323 { // yes 2324 Reference< XChild > xParentAsChild( m_xObjectParent, UNO_QUERY ); 2325 if ( xParentAsChild.is() ) 2326 xRowSet = Reference< XRowSet >( xParentAsChild->getParent(), UNO_QUERY ); 2327 } 2328 } 2329 if ( !xRowSet.is() ) 2330 xRowSet = m_xRowSet; 2331 } 2332 DBG_ASSERT( xRowSet.is(), "FormComponentPropertyHandler::impl_getRowSet_throw: could not obtain the rowset for the introspectee!" ); 2333 } 2334 return xRowSet; 2335 } 2336 2337 //------------------------------------------------------------------------ 2338 Reference< XRowSet > FormComponentPropertyHandler::impl_getRowSet_nothrow( ) const 2339 { 2340 Reference< XRowSet > xReturn; 2341 try 2342 { 2343 xReturn = impl_getRowSet_throw(); 2344 } 2345 catch( const Exception& ) 2346 { 2347 OSL_ENSURE( sal_False, "FormComponentPropertyHandler::impl_getRowSet_nothrow: caught an exception!" ); 2348 } 2349 return xReturn; 2350 } 2351 2352 //------------------------------------------------------------------------ 2353 void FormComponentPropertyHandler::impl_initFieldList_nothrow( ::std::vector< ::rtl::OUString >& _rFieldNames ) const 2354 { 2355 clearContainer( _rFieldNames ); 2356 try 2357 { 2358 WaitCursor aWaitCursor( impl_getDefaultDialogParent_nothrow() ); 2359 2360 Reference< XPreparedStatement > xStatement; 2361 2362 // get the form of the control we're inspecting 2363 Reference< XPropertySet > xFormSet( impl_getRowSet_throw(), UNO_QUERY ); 2364 if ( !xFormSet.is() ) 2365 return; 2366 2367 ::rtl::OUString sObjectName; 2368 OSL_VERIFY( xFormSet->getPropertyValue( PROPERTY_COMMAND ) >>= sObjectName ); 2369 // when there is no command we don't need to ask for columns 2370 if ( sObjectName.getLength() && impl_ensureRowsetConnection_nothrow() ) 2371 { 2372 ::rtl::OUString aDatabaseName; 2373 OSL_VERIFY( xFormSet->getPropertyValue( PROPERTY_DATASOURCE ) >>= aDatabaseName ); 2374 sal_Int32 nObjectType = CommandType::COMMAND; 2375 OSL_VERIFY( xFormSet->getPropertyValue( PROPERTY_COMMANDTYPE ) >>= nObjectType ); 2376 2377 Sequence< ::rtl::OUString > aFields( ::dbtools::getFieldNamesByCommandDescriptor( m_xRowSetConnection, nObjectType, sObjectName ) ); 2378 2379 const ::rtl::OUString* pFields = aFields.getConstArray(); 2380 for ( sal_Int32 i = 0; i < aFields.getLength(); ++i, ++pFields ) 2381 _rFieldNames.push_back( *pFields ); 2382 } 2383 } 2384 catch (Exception&) 2385 { 2386 DBG_ERROR( "FormComponentPropertyHandler::impl_initFieldList_nothrow: caught an exception!" ); 2387 } 2388 } 2389 2390 //------------------------------------------------------------------------ 2391 void FormComponentPropertyHandler::impl_clearRowsetConnection_nothrow() 2392 { 2393 m_xRowSetConnection.clear(); 2394 } 2395 2396 //------------------------------------------------------------------------ 2397 void FormComponentPropertyHandler::impl_displaySQLError_nothrow( const ::dbtools::SQLExceptionInfo& _rErrorDescriptor ) const 2398 { 2399 ::dbtools::showError( _rErrorDescriptor, VCLUnoHelper::GetInterface( impl_getDefaultDialogParent_nothrow() ), m_aContext.getLegacyServiceFactory() ); 2400 } 2401 2402 //------------------------------------------------------------------------ 2403 bool FormComponentPropertyHandler::impl_ensureRowsetConnection_nothrow() const 2404 { 2405 if ( !m_xRowSetConnection.is() ) 2406 { 2407 uno::Reference<sdbc::XConnection> xConnection(m_aContext.getContextValueByAsciiName( "ActiveConnection" ),uno::UNO_QUERY); 2408 m_xRowSetConnection.reset(xConnection,::dbtools::SharedConnection::NoTakeOwnership); 2409 } 2410 if ( m_xRowSetConnection.is() ) 2411 return true; 2412 2413 Reference< XRowSet > xRowSet( impl_getRowSet_throw() ); 2414 Reference< XPropertySet > xRowSetProps( xRowSet, UNO_QUERY ); 2415 2416 // connect the row set - this is delegated to elsewhere - while observing errors 2417 SQLExceptionInfo aError; 2418 try 2419 { 2420 if ( xRowSetProps.is() ) 2421 { 2422 WaitCursor aWaitCursor( impl_getDefaultDialogParent_nothrow() ); 2423 m_xRowSetConnection = ::dbtools::ensureRowSetConnection( xRowSet, m_aContext.getLegacyServiceFactory(), false ); 2424 } 2425 } 2426 catch ( const SQLException& ) { aError = SQLExceptionInfo( ::cppu::getCaughtException() ); } 2427 catch ( const WrappedTargetException& e ) { aError = SQLExceptionInfo( e.TargetException ); } 2428 catch ( const Exception& ) { DBG_UNHANDLED_EXCEPTION(); } 2429 2430 // report errors, if necessary 2431 if ( aError.isValid() ) 2432 { 2433 ::rtl::OUString sDataSourceName; 2434 try 2435 { 2436 xRowSetProps->getPropertyValue( PROPERTY_DATASOURCE ) >>= sDataSourceName; 2437 } 2438 catch( const Exception& ) 2439 { 2440 DBG_ERROR( "FormComponentPropertyHandler::impl_ensureRowsetConnection_nothrow: caught an exception during error handling!" ); 2441 } 2442 // additional info about what happended 2443 String sInfo( PcrRes( RID_STR_UNABLETOCONNECT ) ); 2444 INetURLObject aParser( sDataSourceName ); 2445 if ( aParser.GetProtocol() != INET_PROT_NOT_VALID ) 2446 sDataSourceName = aParser.getBase( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_WITH_CHARSET ); 2447 sInfo.SearchAndReplaceAllAscii( "$name$", sDataSourceName ); 2448 2449 SQLContext aContext; 2450 aContext.Message = sInfo; 2451 aContext.NextException = aError.get(); 2452 impl_displaySQLError_nothrow( aContext ); 2453 } 2454 2455 return m_xRowSetConnection.is(); 2456 } 2457 2458 //------------------------------------------------------------------------ 2459 void FormComponentPropertyHandler::impl_describeCursorSource_nothrow( LineDescriptor& _out_rProperty, const Reference< XPropertyControlFactory >& _rxControlFactory ) const 2460 { 2461 try 2462 { 2463 WaitCursor aWaitCursor( impl_getDefaultDialogParent_nothrow() ); 2464 2465 //////////////////////////////////////////////////////////// 2466 // Setzen der UI-Daten 2467 _out_rProperty.DisplayName = m_pInfoService->getPropertyTranslation( PROPERTY_ID_COMMAND ); 2468 2469 _out_rProperty.HelpURL = HelpIdUrl::getHelpURL( m_pInfoService->getPropertyHelpId( PROPERTY_ID_COMMAND ) ); 2470 _out_rProperty.PrimaryButtonId = rtl::OUString::createFromAscii(UID_PROP_DLG_SQLCOMMAND); 2471 2472 //////////////////////////////////////////////////////////// 2473 sal_Int32 nCommandType = CommandType::COMMAND; 2474 impl_getPropertyValue_throw( PROPERTY_COMMANDTYPE ) >>= nCommandType; 2475 2476 switch ( nCommandType ) 2477 { 2478 case CommandType::TABLE: 2479 case CommandType::QUERY: 2480 { 2481 ::std::vector< ::rtl::OUString > aNames; 2482 if ( impl_ensureRowsetConnection_nothrow() ) 2483 { 2484 if ( nCommandType == CommandType::TABLE ) 2485 impl_fillTableNames_throw( aNames ); 2486 else 2487 impl_fillQueryNames_throw( aNames ); 2488 } 2489 _out_rProperty.Control = PropertyHandlerHelper::createComboBoxControl( _rxControlFactory, aNames, sal_False, sal_True ); 2490 } 2491 break; 2492 2493 default: 2494 _out_rProperty.Control = _rxControlFactory->createPropertyControl( PropertyControlType::MultiLineTextField, sal_False ); 2495 break; 2496 } 2497 } 2498 catch (Exception&) 2499 { 2500 DBG_ERROR("FormComponentPropertyHandler::impl_describeCursorSource_nothrow: caught an exception !"); 2501 } 2502 } 2503 2504 //------------------------------------------------------------------------ 2505 void FormComponentPropertyHandler::impl_fillTableNames_throw( ::std::vector< ::rtl::OUString >& _out_rNames ) const 2506 { 2507 OSL_PRECOND( m_xRowSetConnection.is(), "FormComponentPropertyHandler::impl_fillTableNames_throw: need a connection!" ); 2508 _out_rNames.resize( 0 ); 2509 2510 Reference< XTablesSupplier > xSupplyTables( m_xRowSetConnection, UNO_QUERY ); 2511 Reference< XNameAccess > xTableNames; 2512 if ( xSupplyTables.is() ) 2513 xTableNames = xSupplyTables->getTables(); 2514 DBG_ASSERT( xTableNames.is(), "FormComponentPropertyHandler::impl_fillTableNames_throw: no way to obtain the tables of the connection!" ); 2515 if ( !xTableNames.is() ) 2516 return; 2517 2518 Sequence< ::rtl::OUString> aTableNames = xTableNames->getElementNames(); 2519 sal_uInt32 nCount = aTableNames.getLength(); 2520 const ::rtl::OUString* pTableNames = aTableNames.getConstArray(); 2521 2522 for ( sal_uInt32 i=0; i<nCount; ++i ,++pTableNames ) 2523 _out_rNames.push_back( *pTableNames ); 2524 } 2525 2526 //------------------------------------------------------------------------ 2527 void FormComponentPropertyHandler::impl_fillQueryNames_throw( ::std::vector< ::rtl::OUString >& _out_rNames ) const 2528 { 2529 OSL_PRECOND( m_xRowSetConnection.is(), "FormComponentPropertyHandler::impl_fillQueryNames_throw: need a connection!" ); 2530 _out_rNames.resize( 0 ); 2531 2532 Reference< XQueriesSupplier > xSupplyQueries( m_xRowSetConnection, UNO_QUERY ); 2533 Reference< XNameAccess > xQueryNames; 2534 if ( xSupplyQueries.is() ) 2535 { 2536 xQueryNames = xSupplyQueries->getQueries(); 2537 impl_fillQueryNames_throw(xQueryNames,_out_rNames); 2538 } 2539 } 2540 //------------------------------------------------------------------------ 2541 void FormComponentPropertyHandler::impl_fillQueryNames_throw( const Reference< XNameAccess >& _xQueryNames,::std::vector< ::rtl::OUString >& _out_rNames,const ::rtl::OUString& _sName ) const 2542 { 2543 DBG_ASSERT( _xQueryNames.is(), "FormComponentPropertyHandler::impl_fillQueryNames_throw: no way to obtain the queries of the connection!" ); 2544 if ( !_xQueryNames.is() ) 2545 return; 2546 2547 Sequence< ::rtl::OUString> aQueryNames = _xQueryNames->getElementNames(); 2548 sal_uInt32 nCount = aQueryNames.getLength(); 2549 const ::rtl::OUString* pQueryNames = aQueryNames.getConstArray(); 2550 sal_Bool bAdd = _sName.getLength(); 2551 2552 for ( sal_uInt32 i=0; i<nCount; i++, ++pQueryNames ) 2553 { 2554 ::rtl::OUStringBuffer sTemp; 2555 if ( bAdd ) 2556 { 2557 sTemp.append(_sName); 2558 sTemp.appendAscii("/"); 2559 } 2560 sTemp.append(*pQueryNames); 2561 Reference< XNameAccess > xSubQueries(_xQueryNames->getByName(*pQueryNames),UNO_QUERY); 2562 if ( xSubQueries.is() ) 2563 impl_fillQueryNames_throw(xSubQueries,_out_rNames,sTemp.makeStringAndClear()); 2564 else 2565 _out_rNames.push_back( sTemp.makeStringAndClear() ); 2566 } 2567 } 2568 2569 //------------------------------------------------------------------------ 2570 void FormComponentPropertyHandler::impl_describeListSourceUI_throw( LineDescriptor& _out_rDescriptor, const Reference< XPropertyControlFactory >& _rxControlFactory ) const 2571 { 2572 OSL_PRECOND( m_xComponent.is(), "FormComponentPropertyHandler::impl_describeListSourceUI_throw: no component!" ); 2573 2574 //////////////////////////////////////////////////////////// 2575 // Auslesen des ListSourceTypes 2576 Any aListSourceType( m_xComponent->getPropertyValue( PROPERTY_LISTSOURCETYPE ) ); 2577 2578 sal_Int32 nListSourceType = ListSourceType_VALUELIST; 2579 ::cppu::enum2int( nListSourceType, aListSourceType ); 2580 2581 _out_rDescriptor.DisplayName = m_pInfoService->getPropertyTranslation( PROPERTY_ID_LISTSOURCE ); 2582 _out_rDescriptor.HelpURL = HelpIdUrl::getHelpURL( m_pInfoService->getPropertyHelpId( PROPERTY_ID_LISTSOURCE ) ); 2583 2584 //////////////////////////////////////////////////////////// 2585 // Enums setzen 2586 switch( nListSourceType ) 2587 { 2588 case ListSourceType_VALUELIST: 2589 _out_rDescriptor.Control = _rxControlFactory->createPropertyControl( PropertyControlType::StringListField, sal_False ); 2590 break; 2591 2592 case ListSourceType_TABLEFIELDS: 2593 case ListSourceType_TABLE: 2594 case ListSourceType_QUERY: 2595 { 2596 ::std::vector< ::rtl::OUString > aListEntries; 2597 if ( impl_ensureRowsetConnection_nothrow() ) 2598 { 2599 if ( nListSourceType == ListSourceType_QUERY ) 2600 impl_fillQueryNames_throw( aListEntries ); 2601 else 2602 impl_fillTableNames_throw( aListEntries ); 2603 } 2604 _out_rDescriptor.Control = PropertyHandlerHelper::createComboBoxControl( _rxControlFactory, aListEntries, sal_False, sal_False ); 2605 } 2606 break; 2607 case ListSourceType_SQL: 2608 case ListSourceType_SQLPASSTHROUGH: 2609 impl_ensureRowsetConnection_nothrow(); 2610 _out_rDescriptor.HasPrimaryButton = m_xRowSetConnection.is(); 2611 break; 2612 } 2613 } 2614 2615 //------------------------------------------------------------------------ 2616 bool FormComponentPropertyHandler::impl_dialogListSelection_nothrow( const ::rtl::OUString& _rProperty, ::osl::ClearableMutexGuard& _rClearBeforeDialog ) const 2617 { 2618 OSL_PRECOND( m_pInfoService.get(), "FormComponentPropertyHandler::impl_dialogListSelection_nothrow: no property meta data!" ); 2619 2620 String sPropertyUIName( m_pInfoService->getPropertyTranslation( m_pInfoService->getPropertyId( _rProperty ) ) ); 2621 ListSelectionDialog aDialog( impl_getDefaultDialogParent_nothrow(), m_xComponent, _rProperty, sPropertyUIName ); 2622 _rClearBeforeDialog.clear(); 2623 return ( RET_OK == aDialog.Execute() ); 2624 } 2625 2626 //------------------------------------------------------------------------ 2627 bool FormComponentPropertyHandler::impl_dialogFilterOrSort_nothrow( bool _bFilter, ::rtl::OUString& _out_rSelectedClause, ::osl::ClearableMutexGuard& _rClearBeforeDialog ) const 2628 { 2629 OSL_PRECOND( Reference< XRowSet >( m_xComponent, UNO_QUERY ).is(), 2630 "FormComponentPropertyHandler::impl_dialogFilterOrSort_nothrow: to be called for forms only!" ); 2631 2632 _out_rSelectedClause = ::rtl::OUString(); 2633 bool bSuccess = false; 2634 SQLExceptionInfo aErrorInfo; 2635 try 2636 { 2637 if ( !impl_ensureRowsetConnection_nothrow() ) 2638 return false; 2639 2640 // get a composer for the statement which the form is currently based on 2641 Reference< XSingleSelectQueryComposer > xComposer( ::dbtools::getCurrentSettingsComposer( m_xComponent, m_aContext.getLegacyServiceFactory() ) ); 2642 OSL_ENSURE( xComposer.is(), "FormComponentPropertyHandler::impl_dialogFilterOrSort_nothrow: could not obtain a composer!" ); 2643 if ( !xComposer.is() ) 2644 return false; 2645 2646 ::rtl::OUString sPropertyUIName( m_pInfoService->getPropertyTranslation( _bFilter ? PROPERTY_ID_FILTER : PROPERTY_ID_SORT ) ); 2647 2648 const sal_Char* pAsciiServiceName = _bFilter ? "com.sun.star.sdb.FilterDialog" : "com.sun.star.sdb.OrderDialog"; 2649 2650 // create the dialog 2651 Reference< XExecutableDialog > xDialog; 2652 if ( !m_aContext.createComponent( pAsciiServiceName, xDialog ) ) 2653 { 2654 ShowServiceNotAvailableError( impl_getDefaultDialogParent_nothrow(), ::rtl::OUString::createFromAscii( pAsciiServiceName ), sal_True ); 2655 return false; 2656 } 2657 2658 // initialize the dialog 2659 Reference< XPropertySet > xDialogProps( xDialog, UNO_QUERY_THROW ); 2660 xDialogProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "QueryComposer" ) ), makeAny( xComposer ) ); 2661 xDialogProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "RowSet" ) ), makeAny( m_xComponent ) ); 2662 xDialogProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ParentWindow" ) ), makeAny( VCLUnoHelper::GetInterface( impl_getDefaultDialogParent_nothrow() ) ) ); 2663 xDialogProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Title" ) ), makeAny( sPropertyUIName ) ); 2664 2665 _rClearBeforeDialog.clear(); 2666 bSuccess = ( xDialog->execute() != 0 ); 2667 if ( bSuccess ) 2668 _out_rSelectedClause = _bFilter ? xComposer->getFilter() : xComposer->getOrder(); 2669 } 2670 catch (SQLContext& e) { aErrorInfo = e; } 2671 catch (SQLWarning& e) { aErrorInfo = e; } 2672 catch (SQLException& e) { aErrorInfo = e; } 2673 catch( const Exception& ) 2674 { 2675 OSL_ENSURE( sal_False, "FormComponentPropertyHandler::impl_dialogFilterOrSort_nothrow: caught an exception!" ); 2676 } 2677 2678 if ( aErrorInfo.isValid() ) 2679 impl_displaySQLError_nothrow( aErrorInfo ); 2680 2681 return bSuccess; 2682 } 2683 2684 //------------------------------------------------------------------------ 2685 bool FormComponentPropertyHandler::impl_dialogLinkedFormFields_nothrow( ::osl::ClearableMutexGuard& _rClearBeforeDialog ) const 2686 { 2687 Reference< XForm > xDetailForm( m_xComponent, UNO_QUERY ); 2688 Reference< XForm > xMasterForm( m_xObjectParent, UNO_QUERY ); 2689 uno::Reference<beans::XPropertySet> xMasterProp(m_xObjectParent,uno::UNO_QUERY); 2690 OSL_PRECOND( xDetailForm.is() && xMasterForm.is(), "FormComponentPropertyHandler::impl_dialogLinkedFormFields_nothrow: no forms!" ); 2691 if ( !xDetailForm.is() || !xMasterForm.is() ) 2692 return false; 2693 2694 2695 FormLinkDialog aDialog( impl_getDefaultDialogParent_nothrow(), m_xComponent, xMasterProp, m_aContext.getLegacyServiceFactory() ); 2696 _rClearBeforeDialog.clear(); 2697 return ( RET_OK == aDialog.Execute() ); 2698 } 2699 2700 //------------------------------------------------------------------------ 2701 bool FormComponentPropertyHandler::impl_dialogFormatting_nothrow( Any& _out_rNewValue, ::osl::ClearableMutexGuard& _rClearBeforeDialog ) const 2702 { 2703 bool bChanged = false; 2704 try 2705 { 2706 // create the itemset for the dialog 2707 SfxItemSet aCoreSet(SFX_APP()->GetPool(), 2708 SID_ATTR_NUMBERFORMAT_VALUE, SID_ATTR_NUMBERFORMAT_VALUE, 2709 SID_ATTR_NUMBERFORMAT_INFO, SID_ATTR_NUMBERFORMAT_INFO, 2710 0); // ripped this somewhere ... don't understand it :( 2711 2712 // get the number formats supplier 2713 Reference< XNumberFormatsSupplier > xSupplier; 2714 m_xComponent->getPropertyValue( PROPERTY_FORMATSSUPPLIER ) >>= xSupplier; 2715 2716 DBG_ASSERT(xSupplier.is(), "FormComponentPropertyHandler::impl_dialogFormatting_nothrow: invalid call !" ); 2717 Reference< XUnoTunnel > xTunnel( xSupplier, UNO_QUERY_THROW ); 2718 SvNumberFormatsSupplierObj* pSupplier = 2719 reinterpret_cast< SvNumberFormatsSupplierObj* >( xTunnel->getSomething( SvNumberFormatsSupplierObj::getUnoTunnelId() ) ); 2720 DBG_ASSERT( pSupplier != NULL, "FormComponentPropertyHandler::impl_dialogFormatting_nothrow: invalid call !" ); 2721 2722 sal_Int32 nFormatKey = 0; 2723 impl_getPropertyValue_throw( PROPERTY_FORMATKEY ) >>= nFormatKey; 2724 aCoreSet.Put( SfxUInt32Item( SID_ATTR_NUMBERFORMAT_VALUE, nFormatKey ) ); 2725 2726 SvNumberFormatter* pFormatter = pSupplier->GetNumberFormatter(); 2727 double dPreviewVal = OFormatSampleControl::getPreviewValue(pFormatter,nFormatKey); 2728 SvxNumberInfoItem aFormatter( pFormatter, dPreviewVal, String( PcrRes( RID_STR_TEXT_FORMAT ) ), SID_ATTR_NUMBERFORMAT_INFO ); 2729 aCoreSet.Put( aFormatter ); 2730 2731 // a tab dialog with a single page 2732 ::std::auto_ptr< SfxSingleTabDialog > pDialog( new SfxSingleTabDialog( impl_getDefaultDialogParent_nothrow(), aCoreSet, 0 ) ); 2733 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); 2734 DBG_ASSERT( pFact, "CreateFactory fail!" ); 2735 ::CreateTabPage fnCreatePage = pFact->GetTabPageCreatorFunc( RID_SVXPAGE_NUMBERFORMAT ); 2736 if ( !fnCreatePage ) 2737 throw RuntimeException(); // caught below 2738 2739 SfxTabPage* pPage = (*fnCreatePage)( pDialog.get(), aCoreSet ); 2740 pDialog->SetTabPage( pPage ); 2741 2742 _rClearBeforeDialog.clear(); 2743 if ( RET_OK == pDialog->Execute() ) 2744 { 2745 const SfxItemSet* pResult = pDialog->GetOutputItemSet(); 2746 2747 const SfxPoolItem* pItem = pResult->GetItem( SID_ATTR_NUMBERFORMAT_INFO ); 2748 const SvxNumberInfoItem* pInfoItem = dynamic_cast< const SvxNumberInfoItem* >( pItem ); 2749 if (pInfoItem && pInfoItem->GetDelCount()) 2750 { 2751 const sal_uInt32* pDeletedKeys = pInfoItem->GetDelArray(); 2752 2753 for (sal_uInt16 i=0; i< pInfoItem->GetDelCount(); ++i, ++pDeletedKeys) 2754 pFormatter->DeleteEntry(*pDeletedKeys); 2755 } 2756 2757 pItem = NULL; 2758 if ( SFX_ITEM_SET == pResult->GetItemState( SID_ATTR_NUMBERFORMAT_VALUE, sal_False, &pItem ) ) 2759 { 2760 _out_rNewValue <<= (sal_Int32)( static_cast< const SfxUInt32Item* >( pItem )->GetValue() ); 2761 bChanged = true; 2762 } 2763 } 2764 } 2765 catch( const Exception& ) 2766 { 2767 OSL_ENSURE( sal_False, "FormComponentPropertyHandler::impl_dialogFormatting_nothrow: : caught an exception!" ); 2768 } 2769 return bChanged; 2770 } 2771 2772 //------------------------------------------------------------------------ 2773 bool FormComponentPropertyHandler::impl_browseForImage_nothrow( Any& _out_rNewValue, ::osl::ClearableMutexGuard& _rClearBeforeDialog ) const 2774 { 2775 bool bIsLink = true;// reflect the legacy behavior 2776 ::rtl::OUString aStrTrans = m_pInfoService->getPropertyTranslation( PROPERTY_ID_IMAGE_URL ); 2777 2778 ::sfx2::FileDialogHelper aFileDlg(SFXWB_GRAPHIC); 2779 2780 aFileDlg.SetTitle(aStrTrans); 2781 // non-linked images ( e.g. those located in the document 2782 // stream ) cannot *currently* be handled by openoffice basic dialogs. 2783 bool bHandleNonLink = ( m_eComponentClass == eFormControl ); 2784 2785 Reference< XFilePickerControlAccess > xController(aFileDlg.GetFilePicker(), UNO_QUERY); 2786 DBG_ASSERT(xController.is(), "FormComponentPropertyHandler::impl_browseForImage_nothrow: missing the controller interface on the file picker!"); 2787 if (xController.is()) 2788 { 2789 // do a preview by default 2790 xController->setValue(ExtendedFilePickerElementIds::CHECKBOX_PREVIEW, 0, ::cppu::bool2any(sal_True)); 2791 2792 xController->setValue(ExtendedFilePickerElementIds::CHECKBOX_LINK, 0, ::cppu::bool2any(bIsLink)); 2793 xController->enableControl(ExtendedFilePickerElementIds::CHECKBOX_LINK, bHandleNonLink ); 2794 2795 } 2796 2797 ::rtl::OUString sCurValue; 2798 OSL_VERIFY( impl_getPropertyValue_throw( PROPERTY_IMAGE_URL ) >>= sCurValue ); 2799 if ( sCurValue.getLength() != 0 && sCurValue.compareToAscii(GRAPHOBJ_URLPREFIX, RTL_CONSTASCII_LENGTH(GRAPHOBJ_URLPREFIX) ) != 0 ) 2800 { 2801 aFileDlg.SetDisplayDirectory( sCurValue ); 2802 // TODO: need to set the display directory _and_ the default name 2803 } 2804 2805 _rClearBeforeDialog.clear(); 2806 bool bSuccess = ( 0 == aFileDlg.Execute() ); 2807 if ( bSuccess ) 2808 { 2809 if ( bHandleNonLink && xController.is() ) 2810 { 2811 xController->getValue(ExtendedFilePickerElementIds::CHECKBOX_LINK, 0) >>= bIsLink; 2812 } 2813 if ( !bIsLink ) 2814 { 2815 Graphic aGraphic; 2816 aFileDlg.GetGraphic( aGraphic ); 2817 2818 Reference< graphic::XGraphicObject > xGrfObj = graphic::GraphicObject::create( m_aContext.getUNOContext() ); 2819 xGrfObj->setGraphic( aGraphic.GetXGraphic() ); 2820 2821 2822 _out_rNewValue <<= xGrfObj; 2823 2824 } 2825 else 2826 _out_rNewValue <<= (::rtl::OUString)aFileDlg.GetPath(); 2827 } 2828 return bSuccess; 2829 } 2830 2831 //------------------------------------------------------------------------ 2832 bool FormComponentPropertyHandler::impl_browseForTargetURL_nothrow( Any& _out_rNewValue, ::osl::ClearableMutexGuard& _rClearBeforeDialog ) const 2833 { 2834 ::sfx2::FileDialogHelper aFileDlg( WB_3DLOOK ); 2835 2836 ::rtl::OUString sURL; 2837 OSL_VERIFY( impl_getPropertyValue_throw( PROPERTY_TARGET_URL ) >>= sURL ); 2838 INetURLObject aParser( sURL ); 2839 if ( INET_PROT_FILE == aParser.GetProtocol() ) 2840 // set the initial directory only for file-URLs. Everything else 2841 // is considered to be potentially expensive 2842 // 106126 - 2002/12/10 - fs@openoffice.org 2843 aFileDlg.SetDisplayDirectory( sURL ); 2844 2845 _rClearBeforeDialog.clear(); 2846 bool bSuccess = ( 0 == aFileDlg.Execute() ); 2847 if ( bSuccess ) 2848 _out_rNewValue <<= (::rtl::OUString)aFileDlg.GetPath(); 2849 return bSuccess; 2850 } 2851 2852 //------------------------------------------------------------------------ 2853 bool FormComponentPropertyHandler::impl_executeFontDialog_nothrow( Any& _out_rNewValue, ::osl::ClearableMutexGuard& _rClearBeforeDialog ) const 2854 { 2855 bool bSuccess = false; 2856 2857 // create an item set for use with the dialog 2858 SfxItemSet* pSet = NULL; 2859 SfxItemPool* pPool = NULL; 2860 SfxPoolItem** pDefaults = NULL; 2861 ControlCharacterDialog::createItemSet(pSet, pPool, pDefaults); 2862 ControlCharacterDialog::translatePropertiesToItems(m_xComponent, pSet); 2863 2864 { // do this in an own block. The dialog needs to be destroyed before we call 2865 // destroyItemSet 2866 ControlCharacterDialog aDlg( impl_getDefaultDialogParent_nothrow(), *pSet ); 2867 _rClearBeforeDialog.clear(); 2868 if ( RET_OK == aDlg.Execute() ) 2869 { 2870 const SfxItemSet* pOut = aDlg.GetOutputItemSet(); 2871 if ( pOut ) 2872 { 2873 Sequence< NamedValue > aFontPropertyValues; 2874 ControlCharacterDialog::translateItemsToProperties( *pOut, aFontPropertyValues ); 2875 _out_rNewValue <<= aFontPropertyValues; 2876 bSuccess = true; 2877 } 2878 } 2879 } 2880 2881 ControlCharacterDialog::destroyItemSet(pSet, pPool, pDefaults); 2882 return bSuccess; 2883 } 2884 2885 //------------------------------------------------------------------------ 2886 bool FormComponentPropertyHandler::impl_browseForDatabaseDocument_throw( Any& _out_rNewValue, ::osl::ClearableMutexGuard& _rClearBeforeDialog ) const 2887 { 2888 ::sfx2::FileDialogHelper aFileDlg(WB_3DLOOK|WB_OPEN,::String::CreateFromAscii("sdatabase")); 2889 2890 ::rtl::OUString sDataSource; 2891 OSL_VERIFY( impl_getPropertyValue_throw( PROPERTY_DATASOURCE ) >>= sDataSource ); 2892 INetURLObject aParser( sDataSource ); 2893 if ( INET_PROT_FILE == aParser.GetProtocol() ) 2894 // set the initial directory only for file-URLs. Everything else 2895 // is considered to be potentially expensive 2896 // 106126 - 2002/12/10 - fs@openoffice.org 2897 aFileDlg.SetDisplayDirectory( sDataSource ); 2898 2899 const String s_sDatabaseType = String::CreateFromAscii("StarOffice XML (Base)"); 2900 const SfxFilter* pFilter = SfxFilter::GetFilterByName( s_sDatabaseType); 2901 OSL_ENSURE(pFilter,"Filter: StarOffice XML (Base) could not be found!"); 2902 if ( pFilter ) 2903 { 2904 aFileDlg.SetCurrentFilter(pFilter->GetUIName()); 2905 //aFileDlg.AddFilter(pFilter->GetFilterName(),pFilter->GetDefaultExtension()); 2906 } 2907 2908 _rClearBeforeDialog.clear(); 2909 bool bSuccess = ( 0 == aFileDlg.Execute() ); 2910 if ( bSuccess ) 2911 _out_rNewValue <<= (::rtl::OUString)aFileDlg.GetPath(); 2912 return bSuccess; 2913 } 2914 2915 //------------------------------------------------------------------------ 2916 bool FormComponentPropertyHandler::impl_dialogColorChooser_throw( sal_Int32 _nColorPropertyId, Any& _out_rNewValue, ::osl::ClearableMutexGuard& _rClearBeforeDialog ) const 2917 { 2918 sal_Int32 nColor = 0; 2919 OSL_VERIFY( impl_getPropertyValue_throw( impl_getPropertyNameFromId_nothrow( _nColorPropertyId ) ) >>= nColor ); 2920 ::Color aColor( nColor ); 2921 SvColorDialog aColorDlg( impl_getDefaultDialogParent_nothrow() ); 2922 aColorDlg.SetColor( aColor ); 2923 2924 _rClearBeforeDialog.clear(); 2925 if ( !aColorDlg.Execute() ) 2926 return false; 2927 2928 aColor = aColorDlg.GetColor(); 2929 nColor = aColor.GetColor(); 2930 _out_rNewValue <<= (sal_Int32)nColor; 2931 return true; 2932 } 2933 2934 //------------------------------------------------------------------------ 2935 bool FormComponentPropertyHandler::impl_dialogChooseLabelControl_nothrow( Any& _out_rNewValue, ::osl::ClearableMutexGuard& _rClearBeforeDialog ) const 2936 { 2937 OSelectLabelDialog dlgSelectLabel( impl_getDefaultDialogParent_nothrow(), m_xComponent ); 2938 _rClearBeforeDialog.clear(); 2939 bool bSuccess = ( RET_OK == dlgSelectLabel.Execute() ); 2940 if ( bSuccess ) 2941 _out_rNewValue <<= dlgSelectLabel.GetSelected(); 2942 return bSuccess; 2943 } 2944 2945 //------------------------------------------------------------------------ 2946 Reference< XControlContainer > FormComponentPropertyHandler::impl_getContextControlContainer_nothrow() const 2947 { 2948 Reference< XControlContainer > xControlContext( 2949 m_aContext.getContextValueByAsciiName( "ControlContext" ), 2950 UNO_QUERY ); 2951 return xControlContext; 2952 } 2953 2954 //------------------------------------------------------------------------ 2955 bool FormComponentPropertyHandler::impl_dialogChangeTabOrder_nothrow( ::osl::ClearableMutexGuard& _rClearBeforeDialog ) const 2956 { 2957 OSL_PRECOND( impl_getContextControlContainer_nothrow().is(), "FormComponentPropertyHandler::impl_dialogChangeTabOrder_nothrow: invalid control context!" ); 2958 2959 Reference< XTabControllerModel > xTabControllerModel( impl_getRowSet_nothrow(), UNO_QUERY ); 2960 TabOrderDialog aDialog( 2961 impl_getDefaultDialogParent_nothrow(), 2962 xTabControllerModel, 2963 impl_getContextControlContainer_nothrow(), 2964 m_aContext.getLegacyServiceFactory() 2965 ); 2966 _rClearBeforeDialog.clear(); 2967 return ( RET_OK == aDialog.Execute() ); 2968 } 2969 2970 //------------------------------------------------------------------------ 2971 namespace 2972 { 2973 //-------------------------------------------------------------------- 2974 //- ISQLCommandPropertyUI 2975 //-------------------------------------------------------------------- 2976 class ISQLCommandPropertyUI : public ISQLCommandAdapter 2977 { 2978 public: 2979 /** returns the empty-string-terminated list of names of properties 2980 whose UI is to be disabled while the SQL command property is 2981 being edited. 2982 */ 2983 virtual ::rtl::OUString* getPropertiesToDisable() = 0; 2984 }; 2985 2986 //-------------------------------------------------------------------- 2987 //- SQLCommandPropertyUI 2988 //-------------------------------------------------------------------- 2989 class SQLCommandPropertyUI : public ISQLCommandPropertyUI 2990 { 2991 protected: 2992 SQLCommandPropertyUI( const Reference< XPropertySet >& _rxObject ) 2993 :m_xObject( _rxObject ) 2994 { 2995 if ( !m_xObject.is() ) 2996 throw NullPointerException(); 2997 } 2998 2999 virtual oslInterlockedCount SAL_CALL acquire() 3000 { 3001 return osl_incrementInterlockedCount( &m_refCount ); 3002 } 3003 3004 virtual oslInterlockedCount SAL_CALL release() 3005 { 3006 if ( 0 == osl_decrementInterlockedCount( &m_refCount ) ) 3007 { 3008 delete this; 3009 return 0; 3010 } 3011 return m_refCount; 3012 } 3013 3014 protected: 3015 Reference< XPropertySet > m_xObject; 3016 3017 private: 3018 oslInterlockedCount m_refCount; 3019 }; 3020 3021 //-------------------------------------------------------------------- 3022 //- FormSQLCommandUI - declaration 3023 //-------------------------------------------------------------------- 3024 class FormSQLCommandUI : public SQLCommandPropertyUI 3025 { 3026 public: 3027 FormSQLCommandUI( const Reference< XPropertySet >& _rxForm ); 3028 3029 // ISQLCommandAdapter 3030 virtual ::rtl::OUString getSQLCommand() const; 3031 virtual sal_Bool getEscapeProcessing() const; 3032 virtual void setSQLCommand( const ::rtl::OUString& _rCommand ) const; 3033 virtual void setEscapeProcessing( const sal_Bool _bEscapeProcessing ) const; 3034 3035 // ISQLCommandPropertyUI 3036 virtual ::rtl::OUString* getPropertiesToDisable(); 3037 }; 3038 3039 //-------------------------------------------------------------------- 3040 //- FormSQLCommandUI - implementation 3041 //-------------------------------------------------------------------- 3042 //.................................................................... 3043 FormSQLCommandUI::FormSQLCommandUI( const Reference< XPropertySet >& _rxForm ) 3044 :SQLCommandPropertyUI( _rxForm ) 3045 { 3046 } 3047 3048 //.................................................................... 3049 ::rtl::OUString FormSQLCommandUI::getSQLCommand() const 3050 { 3051 ::rtl::OUString sCommand; 3052 OSL_VERIFY( m_xObject->getPropertyValue( PROPERTY_COMMAND ) >>= sCommand ); 3053 return sCommand; 3054 } 3055 3056 //.................................................................... 3057 sal_Bool FormSQLCommandUI::getEscapeProcessing() const 3058 { 3059 sal_Bool bEscapeProcessing( sal_False ); 3060 OSL_VERIFY( m_xObject->getPropertyValue( PROPERTY_ESCAPE_PROCESSING ) >>= bEscapeProcessing ); 3061 return bEscapeProcessing; 3062 } 3063 3064 //.................................................................... 3065 void FormSQLCommandUI::setSQLCommand( const ::rtl::OUString& _rCommand ) const 3066 { 3067 m_xObject->setPropertyValue( PROPERTY_COMMAND, makeAny( _rCommand ) ); 3068 } 3069 3070 //.................................................................... 3071 void FormSQLCommandUI::setEscapeProcessing( const sal_Bool _bEscapeProcessing ) const 3072 { 3073 m_xObject->setPropertyValue( PROPERTY_ESCAPE_PROCESSING, makeAny( _bEscapeProcessing ) ); 3074 } 3075 3076 //.................................................................... 3077 ::rtl::OUString* FormSQLCommandUI::getPropertiesToDisable() 3078 { 3079 static ::rtl::OUString s_aCommandProps[] = { 3080 PROPERTY_DATASOURCE, 3081 PROPERTY_COMMAND, 3082 PROPERTY_COMMANDTYPE, 3083 PROPERTY_ESCAPE_PROCESSING, 3084 ::rtl::OUString() 3085 }; 3086 return s_aCommandProps; 3087 } 3088 //-------------------------------------------------------------------- 3089 //- ValueListCommandUI - declaration 3090 //-------------------------------------------------------------------- 3091 class ValueListCommandUI : public SQLCommandPropertyUI 3092 { 3093 public: 3094 ValueListCommandUI( const Reference< XPropertySet >& _rxListOrCombo ); 3095 3096 // ISQLCommandAdapter 3097 virtual ::rtl::OUString getSQLCommand() const; 3098 virtual sal_Bool getEscapeProcessing() const; 3099 virtual void setSQLCommand( const ::rtl::OUString& _rCommand ) const; 3100 virtual void setEscapeProcessing( const sal_Bool _bEscapeProcessing ) const; 3101 3102 // ISQLCommandPropertyUI 3103 virtual ::rtl::OUString* getPropertiesToDisable(); 3104 private: 3105 mutable bool m_bPropertyValueIsList; 3106 }; 3107 3108 //-------------------------------------------------------------------- 3109 //- ValueListCommandUI - implementation 3110 //-------------------------------------------------------------------- 3111 //.................................................................... 3112 ValueListCommandUI::ValueListCommandUI( const Reference< XPropertySet >& _rxListOrCombo ) 3113 :SQLCommandPropertyUI( _rxListOrCombo ) 3114 ,m_bPropertyValueIsList( false ) 3115 { 3116 } 3117 3118 //.................................................................... 3119 ::rtl::OUString ValueListCommandUI::getSQLCommand() const 3120 { 3121 ::rtl::OUString sValue; 3122 m_bPropertyValueIsList = false; 3123 3124 // for combo boxes, the property is a mere string 3125 Any aValue( m_xObject->getPropertyValue( PROPERTY_LISTSOURCE ) ); 3126 if ( aValue >>= sValue ) 3127 return sValue; 3128 3129 Sequence< ::rtl::OUString > aValueList; 3130 if ( aValue >>= aValueList ) 3131 { 3132 m_bPropertyValueIsList = true; 3133 if ( aValueList.getLength() ) 3134 sValue = aValueList[0]; 3135 return sValue; 3136 } 3137 3138 OSL_ENSURE( false, "ValueListCommandUI::getSQLCommand: unexpected property type!" ); 3139 return sValue; 3140 } 3141 3142 //.................................................................... 3143 sal_Bool ValueListCommandUI::getEscapeProcessing() const 3144 { 3145 enum ListSourceType eType( ListSourceType_SQL ); 3146 OSL_VERIFY( m_xObject->getPropertyValue( PROPERTY_LISTSOURCETYPE ) >>= eType ); 3147 OSL_ENSURE( ( eType == ListSourceType_SQL ) || ( eType == ListSourceType_SQLPASSTHROUGH ), 3148 "ValueListCommandUI::getEscapeProcessing: unexpected list source type!" ); 3149 return ( eType == ListSourceType_SQL ); 3150 } 3151 3152 //.................................................................... 3153 void ValueListCommandUI::setSQLCommand( const ::rtl::OUString& _rCommand ) const 3154 { 3155 Any aValue; 3156 if ( m_bPropertyValueIsList ) 3157 aValue <<= Sequence< ::rtl::OUString >( &_rCommand, 1 ); 3158 else 3159 aValue <<= _rCommand; 3160 m_xObject->setPropertyValue( PROPERTY_LISTSOURCE, aValue ); 3161 } 3162 3163 //.................................................................... 3164 void ValueListCommandUI::setEscapeProcessing( const sal_Bool _bEscapeProcessing ) const 3165 { 3166 m_xObject->setPropertyValue( PROPERTY_LISTSOURCETYPE, makeAny( 3167 _bEscapeProcessing ? ListSourceType_SQL : ListSourceType_SQLPASSTHROUGH ) ); 3168 } 3169 3170 //.................................................................... 3171 ::rtl::OUString* ValueListCommandUI::getPropertiesToDisable() 3172 { 3173 static ::rtl::OUString s_aListSourceProps[] = { 3174 PROPERTY_LISTSOURCETYPE, 3175 PROPERTY_LISTSOURCE, 3176 ::rtl::OUString() 3177 }; 3178 return s_aListSourceProps; 3179 } 3180 } 3181 3182 //------------------------------------------------------------------------ 3183 bool FormComponentPropertyHandler::impl_doDesignSQLCommand_nothrow( const Reference< XObjectInspectorUI >& _rxInspectorUI, PropertyId _nDesignForProperty ) 3184 { 3185 try 3186 { 3187 if ( m_xCommandDesigner.is() ) 3188 { 3189 if ( m_xCommandDesigner->isActive() ) 3190 { 3191 m_xCommandDesigner->raise(); 3192 return true; 3193 } 3194 m_xCommandDesigner->dispose(); 3195 m_xCommandDesigner.set( NULL ); 3196 } 3197 3198 if ( !impl_ensureRowsetConnection_nothrow() ) 3199 return false; 3200 3201 Reference< XPropertySet > xComponentProperties( m_xComponent, UNO_QUERY_THROW ); 3202 3203 ::rtl::Reference< ISQLCommandPropertyUI > xCommandUI; 3204 switch ( _nDesignForProperty ) 3205 { 3206 case PROPERTY_ID_COMMAND: 3207 xCommandUI = new FormSQLCommandUI( xComponentProperties ); 3208 break; 3209 case PROPERTY_ID_LISTSOURCE: 3210 xCommandUI = new ValueListCommandUI( xComponentProperties ); 3211 break; 3212 default: 3213 OSL_ENSURE( false, "FormComponentPropertyHandler::OnDesignerClosed: invalid property id!" ); 3214 return false; 3215 } 3216 3217 m_xCommandDesigner.set( new SQLCommandDesigner( m_aContext.getUNOContext(), xCommandUI.get(), m_xRowSetConnection, LINK( this, FormComponentPropertyHandler, OnDesignerClosed ) ) ); 3218 3219 DBG_ASSERT( _rxInspectorUI.is(), "FormComponentPropertyHandler::OnDesignerClosed: no access to the property browser ui!" ); 3220 if ( m_xCommandDesigner->isActive() && _rxInspectorUI.is() ) 3221 { 3222 m_xBrowserUI = _rxInspectorUI; 3223 // disable everything which would affect this property 3224 const ::rtl::OUString* pToDisable = xCommandUI->getPropertiesToDisable(); 3225 while ( pToDisable->getLength() ) 3226 { 3227 m_xBrowserUI->enablePropertyUIElements( *pToDisable++, PropertyLineElement::All, sal_False ); 3228 } 3229 3230 // but enable the browse button for the property itself - so it can be used to raise the query designer 3231 ::rtl::OUString sPropertyName( impl_getPropertyNameFromId_nothrow( _nDesignForProperty ) ); 3232 m_xBrowserUI->enablePropertyUIElements( sPropertyName, PropertyLineElement::PrimaryButton, sal_True ); 3233 } 3234 } 3235 catch( const Exception& ) 3236 { 3237 DBG_UNHANDLED_EXCEPTION(); 3238 } 3239 return m_xCommandDesigner.is(); 3240 } 3241 3242 //------------------------------------------------------------------------ 3243 IMPL_LINK( FormComponentPropertyHandler, OnDesignerClosed, void*, /*NOTINTERESTEDIN*/ ) 3244 { 3245 OSL_ENSURE( m_xBrowserUI.is() && m_xCommandDesigner.is(), "FormComponentPropertyHandler::OnDesignerClosed: too many NULLs!" ); 3246 if ( m_xBrowserUI.is() && m_xCommandDesigner.is() ) 3247 { 3248 try 3249 { 3250 ::rtl::Reference< ISQLCommandPropertyUI > xCommandUI( 3251 dynamic_cast< ISQLCommandPropertyUI* >( m_xCommandDesigner->getPropertyAdapter().get() ) ); 3252 if ( !xCommandUI.is() ) 3253 throw NullPointerException(); 3254 3255 const ::rtl::OUString* pToEnable = xCommandUI->getPropertiesToDisable(); 3256 while ( pToEnable->getLength() ) 3257 { 3258 m_xBrowserUI->enablePropertyUIElements( *pToEnable++, PropertyLineElement::All, sal_True ); 3259 } 3260 } 3261 catch( const Exception& ) 3262 { 3263 DBG_UNHANDLED_EXCEPTION(); 3264 } 3265 } 3266 3267 return 0L; 3268 } 3269 3270 //------------------------------------------------------------------------ 3271 bool FormComponentPropertyHandler::impl_hasValidDataSourceSignature_nothrow( const Reference< XPropertySet >& _xFormProperties, bool _bAllowEmptyDataSourceName ) SAL_THROW(()) 3272 { 3273 bool bHas = false; 3274 if ( _xFormProperties.is() ) 3275 { 3276 try 3277 { 3278 ::rtl::OUString sPropertyValue; 3279 // first, we need the name of an existent data source 3280 if ( _xFormProperties->getPropertySetInfo()->hasPropertyByName(PROPERTY_DATASOURCE) ) 3281 _xFormProperties->getPropertyValue( PROPERTY_DATASOURCE ) >>= sPropertyValue; 3282 bHas = ( sPropertyValue.getLength() != 0 ) || _bAllowEmptyDataSourceName; 3283 3284 // then, the command should not be empty 3285 if ( bHas ) 3286 { 3287 if ( _xFormProperties->getPropertySetInfo()->hasPropertyByName(PROPERTY_COMMAND) ) 3288 _xFormProperties->getPropertyValue( PROPERTY_COMMAND ) >>= sPropertyValue; 3289 bHas = ( sPropertyValue.getLength() != 0 ); 3290 } 3291 } 3292 catch( const Exception& ) 3293 { 3294 OSL_ENSURE( false, "FormComponentPropertyHandler::impl_hasValidDataSourceSignature_nothrow: caught an exception!" ); 3295 } 3296 } 3297 return bHas; 3298 } 3299 //------------------------------------------------------------------------ 3300 ::rtl::OUString FormComponentPropertyHandler::impl_getDocumentURL_nothrow() const 3301 { 3302 ::rtl::OUString sURL; 3303 try 3304 { 3305 Reference< XModel > xDocument( impl_getContextDocument_nothrow() ); 3306 if ( xDocument.is() ) 3307 sURL = xDocument->getURL(); 3308 } 3309 catch( const Exception& ) 3310 { 3311 DBG_UNHANDLED_EXCEPTION(); 3312 } 3313 return sURL; 3314 } 3315 // ------------------------------------------------------------------------- 3316 ::cppu::IPropertyArrayHelper* FormComponentPropertyHandler::createArrayHelper( ) const 3317 { 3318 uno::Sequence< beans::Property > aProps; 3319 describeProperties(aProps); 3320 return new ::cppu::OPropertyArrayHelper(aProps); 3321 3322 } 3323 // ------------------------------------------------------------------------- 3324 ::cppu::IPropertyArrayHelper & FormComponentPropertyHandler::getInfoHelper() 3325 { 3326 return *const_cast<FormComponentPropertyHandler*>(this)->getArrayHelper(); 3327 } 3328 // ----------------------------------------------------------------------------- 3329 uno::Reference< beans::XPropertySetInfo > SAL_CALL FormComponentPropertyHandler::getPropertySetInfo( ) throw(uno::RuntimeException) 3330 { 3331 return ::cppu::OPropertySetHelper::createPropertySetInfo(getInfoHelper()); 3332 } 3333 3334 //........................................................................ 3335 } // namespace pcr 3336 //........................................................................ 3337 3338