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_toolkit.hxx" 26 #include <com/sun/star/awt/XTextArea.hpp> 27 #include <com/sun/star/awt/XVclWindowPeer.hpp> 28 #include <com/sun/star/lang/XMultiServiceFactory.hpp> 29 #include <com/sun/star/awt/PosSize.hpp> 30 #include <com/sun/star/awt/VisualEffect.hpp> 31 #include <com/sun/star/awt/LineEndFormat.hpp> 32 #include <com/sun/star/graphic/XGraphicProvider.hpp> 33 #include <com/sun/star/graphic/GraphicObject.hpp> 34 #include <com/sun/star/util/Date.hpp> 35 #include <com/sun/star/awt/ImageScaleMode.hpp> 36 37 38 #include <toolkit/controls/formattedcontrol.hxx> 39 #include <toolkit/controls/roadmapcontrol.hxx> 40 #include <toolkit/controls/unocontrols.hxx> 41 #include <toolkit/controls/stdtabcontroller.hxx> 42 #include <toolkit/helper/property.hxx> 43 #include <toolkit/helper/unopropertyarrayhelper.hxx> 44 #include <toolkit/helper/unomemorystream.hxx> 45 #include <toolkit/helper/servicenames.hxx> 46 #include <toolkit/helper/macros.hxx> 47 #include <toolkit/helper/imagealign.hxx> 48 49 // for introspection 50 #include <toolkit/awt/vclxwindows.hxx> 51 #include <cppuhelper/typeprovider.hxx> 52 #include <comphelper/componentcontext.hxx> 53 #include <comphelper/processfactory.hxx> 54 #include <comphelper/extract.hxx> 55 #include <vcl/wrkwin.hxx> 56 #include <vcl/svapp.hxx> 57 #include <vcl/edit.hxx> 58 #ifndef _SV_BUTTON_HXX 59 #include <vcl/button.hxx> 60 #endif 61 #include <vcl/group.hxx> 62 #include <vcl/fixed.hxx> 63 #include <vcl/lstbox.hxx> 64 #include <vcl/combobox.hxx> 65 #include <tools/debug.hxx> 66 #include <tools/diagnose_ex.h> 67 #include <tools/date.hxx> 68 #include <tools/time.hxx> 69 70 #include <algorithm> 71 #include <functional> 72 73 using namespace ::com::sun::star; 74 using ::com::sun::star::graphic::XGraphic; 75 using ::com::sun::star::uno::Reference; 76 using namespace ::toolkit; 77 78 #define IMPL_SERVICEINFO_DERIVED( ImplName, BaseClass, ServiceName ) \ 79 ::rtl::OUString SAL_CALL ImplName::getImplementationName( ) throw(::com::sun::star::uno::RuntimeException) { return ::rtl::OUString::createFromAscii( "stardiv.Toolkit." #ImplName ); } \ 80 ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL ImplName::getSupportedServiceNames() throw(::com::sun::star::uno::RuntimeException) \ 81 { \ 82 ::com::sun::star::uno::Sequence< ::rtl::OUString > aNames = BaseClass::getSupportedServiceNames( ); \ 83 aNames.realloc( aNames.getLength() + 1 ); \ 84 aNames[ aNames.getLength() - 1 ] = ::rtl::OUString::createFromAscii( ServiceName ); \ 85 return aNames; \ 86 } \ 87 88 89 90 // ---------------------------------------------------- 91 // class UnoControlEditModel 92 // ---------------------------------------------------- 93 UnoControlEditModel::UnoControlEditModel( const Reference< XMultiServiceFactory >& i_factory ) 94 :UnoControlModel( i_factory ) 95 { 96 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXEdit ); 97 } 98 99 ::rtl::OUString UnoControlEditModel::getServiceName( ) throw(::com::sun::star::uno::RuntimeException) 100 { 101 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlEditModel ); 102 } 103 104 uno::Any UnoControlEditModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 105 { 106 uno::Any aReturn; 107 108 switch ( nPropId ) 109 { 110 case BASEPROPERTY_LINE_END_FORMAT: 111 aReturn <<= (sal_Int16)awt::LineEndFormat::LINE_FEED; // LF 112 break; 113 case BASEPROPERTY_DEFAULTCONTROL: 114 aReturn <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlEdit ); 115 break; 116 default: 117 aReturn = UnoControlModel::ImplGetDefaultValue( nPropId ); 118 break; 119 } 120 return aReturn; 121 } 122 123 ::cppu::IPropertyArrayHelper& UnoControlEditModel::getInfoHelper() 124 { 125 static UnoPropertyArrayHelper* pHelper = NULL; 126 if ( !pHelper ) 127 { 128 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 129 pHelper = new UnoPropertyArrayHelper( aIDs ); 130 } 131 return *pHelper; 132 } 133 134 // beans::XMultiPropertySet 135 uno::Reference< beans::XPropertySetInfo > UnoControlEditModel::getPropertySetInfo( ) throw(uno::RuntimeException) 136 { 137 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 138 return xInfo; 139 } 140 141 142 // ---------------------------------------------------- 143 // class UnoEditControl 144 // ---------------------------------------------------- 145 UnoEditControl::UnoEditControl( const Reference< XMultiServiceFactory >& i_factory ) 146 :UnoControlBase( i_factory ) 147 ,maTextListeners( *this ) 148 ,mnMaxTextLen( 0 ) 149 ,mbSetTextInPeer( sal_False ) 150 ,mbSetMaxTextLenInPeer( sal_False ) 151 ,mbHasTextProperty( sal_False ) 152 { 153 maComponentInfos.nWidth = 100; 154 maComponentInfos.nHeight = 12; 155 mnMaxTextLen = 0; 156 mbSetMaxTextLenInPeer = sal_False; 157 } 158 159 uno::Any SAL_CALL UnoEditControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException) 160 { 161 uno::Any aReturn = UnoControlBase::queryAggregation( rType ); 162 if ( !aReturn.hasValue() ) 163 aReturn = UnoEditControl_Base::queryInterface( rType ); 164 return aReturn; 165 } 166 167 uno::Any SAL_CALL UnoEditControl::queryInterface( const uno::Type & rType ) throw(uno::RuntimeException) 168 { 169 return UnoControlBase::queryInterface( rType ); 170 } 171 172 void SAL_CALL UnoEditControl::acquire( ) throw () 173 { 174 UnoControlBase::acquire(); 175 } 176 177 void SAL_CALL UnoEditControl::release( ) throw () 178 { 179 UnoControlBase::release(); 180 } 181 182 IMPLEMENT_FORWARD_XTYPEPROVIDER2( UnoEditControl, UnoControlBase, UnoEditControl_Base ) 183 184 ::rtl::OUString UnoEditControl::GetComponentServiceName() 185 { 186 // by default, we want a simple edit field 187 ::rtl::OUString sName( ::rtl::OUString::createFromAscii( "Edit" ) ); 188 189 // but maybe we are to display multi-line text? 190 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_MULTILINE ) ); 191 sal_Bool b = sal_Bool(); 192 if ( ( aVal >>= b ) && b ) 193 sName= ::rtl::OUString::createFromAscii( "MultiLineEdit" ); 194 195 return sName; 196 } 197 198 sal_Bool SAL_CALL UnoEditControl::setModel(const uno::Reference< awt::XControlModel >& _rModel) throw ( uno::RuntimeException ) 199 { 200 sal_Bool bReturn = UnoControlBase::setModel( _rModel ); 201 mbHasTextProperty = ImplHasProperty( BASEPROPERTY_TEXT ); 202 return bReturn; 203 } 204 205 void UnoEditControl::ImplSetPeerProperty( const ::rtl::OUString& rPropName, const uno::Any& rVal ) 206 { 207 sal_Bool bDone = sal_False; 208 if ( GetPropertyId( rPropName ) == BASEPROPERTY_TEXT ) 209 { 210 // #96986# use setText(), or text listener will not be called. 211 uno::Reference < awt::XTextComponent > xTextComponent( getPeer(), uno::UNO_QUERY ); 212 if ( xTextComponent.is() ) 213 { 214 ::rtl::OUString sText; 215 rVal >>= sText; 216 ImplCheckLocalize( sText ); 217 xTextComponent->setText( sText ); 218 bDone = sal_True; 219 } 220 } 221 222 if ( !bDone ) 223 UnoControlBase::ImplSetPeerProperty( rPropName, rVal ); 224 } 225 226 void UnoEditControl::dispose() throw(uno::RuntimeException) 227 { 228 lang::EventObject aEvt( *this ); 229 maTextListeners.disposeAndClear( aEvt ); 230 UnoControl::dispose(); 231 } 232 233 void UnoEditControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException) 234 { 235 UnoControl::createPeer( rxToolkit, rParentPeer ); 236 237 uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY ); 238 if ( xText.is() ) 239 { 240 xText->addTextListener( this ); 241 242 if ( mbSetMaxTextLenInPeer ) 243 xText->setMaxTextLen( mnMaxTextLen ); 244 if ( mbSetTextInPeer ) 245 xText->setText( maText ); 246 } 247 } 248 249 void UnoEditControl::textChanged(const awt::TextEvent& e) throw(uno::RuntimeException) 250 { 251 uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY ); 252 253 if ( mbHasTextProperty ) 254 { 255 uno::Any aAny; 256 aAny <<= xText->getText(); 257 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TEXT ), aAny, sal_False ); 258 } 259 else 260 { 261 maText = xText->getText(); 262 } 263 264 if ( maTextListeners.getLength() ) 265 maTextListeners.textChanged( e ); 266 } 267 268 void UnoEditControl::addTextListener(const uno::Reference< awt::XTextListener > & l) throw(uno::RuntimeException) 269 { 270 maTextListeners.addInterface( l ); 271 } 272 273 void UnoEditControl::removeTextListener(const uno::Reference< awt::XTextListener > & l) throw(uno::RuntimeException) 274 { 275 maTextListeners.removeInterface( l ); 276 } 277 278 void UnoEditControl::setText( const ::rtl::OUString& aText ) throw(uno::RuntimeException) 279 { 280 if ( mbHasTextProperty ) 281 { 282 uno::Any aAny; 283 aAny <<= aText; 284 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TEXT ), aAny, sal_True ); 285 } 286 else 287 { 288 maText = aText; 289 mbSetTextInPeer = sal_True; 290 uno::Reference < awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY ); 291 if ( xText.is() ) 292 xText->setText( maText ); 293 } 294 295 // Setting the property to the VCLXWindow doesn't call textChanged 296 if ( maTextListeners.getLength() ) 297 { 298 awt::TextEvent aEvent; 299 aEvent.Source = *this; 300 maTextListeners.textChanged( aEvent ); 301 } 302 } 303 304 namespace 305 { 306 static void lcl_normalize( awt::Selection& _rSel ) 307 { 308 if ( _rSel.Min > _rSel.Max ) 309 ::std::swap( _rSel.Min, _rSel.Max ); 310 } 311 312 /* 313 static bool lcl_intersect( const awt::Selection& _rLHS, const awt::Selection& _rRHS ) 314 { 315 OSL_PRECOND( _rLHS.Min <= _rLHS.Max, "lcl_intersect: LHS to be normalized!" ); 316 OSL_PRECOND( _rRHS.Min <= _rRHS.Max, "lcl_intersect: RHS to be normalized!" ); 317 return !( ( _rLHS.Max < _rRHS.Min ) || ( _rLHS.Min > _rRHS.Max ) ); 318 } 319 */ 320 } 321 322 void UnoEditControl::insertText( const awt::Selection& rSel, const ::rtl::OUString& rNewText ) throw(uno::RuntimeException) 323 { 324 // normalize the selection - OUString::replaceAt has a strange behaviour if the min is greater than the max 325 awt::Selection aSelection( rSel ); 326 lcl_normalize( aSelection ); 327 328 // preserve the selection resp. cursor position 329 awt::Selection aNewSelection( getSelection() ); 330 #ifdef ALSO_PRESERVE_COMPLETE_SELECTION 331 // (not sure - looks uglier ...) 332 sal_Int32 nDeletedCharacters = ( aSelection.Max - aSelection.Min ) - rNewText.getLength(); 333 if ( aNewSelection.Min > aSelection.Min ) 334 aNewSelection.Min -= nDeletedCharacters; 335 if ( aNewSelection.Max > aSelection.Max ) 336 aNewSelection.Max -= nDeletedCharacters; 337 #else 338 aNewSelection.Max = ::std::min( aNewSelection.Min, aNewSelection.Max ) + rNewText.getLength(); 339 aNewSelection.Min = aNewSelection.Max; 340 #endif 341 342 ::rtl::OUString aOldText = getText(); 343 ::rtl::OUString aNewText = aOldText.replaceAt( aSelection.Min, aSelection.Max - aSelection.Min, rNewText ); 344 setText( aNewText ); 345 346 setSelection( aNewSelection ); 347 } 348 349 ::rtl::OUString UnoEditControl::getText() throw(uno::RuntimeException) 350 { 351 ::rtl::OUString aText = maText; 352 353 if ( mbHasTextProperty ) 354 aText = ImplGetPropertyValue_UString( BASEPROPERTY_TEXT ); 355 else 356 { 357 uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY ); 358 if ( xText.is() ) 359 aText = xText->getText(); 360 } 361 362 return aText; 363 } 364 365 ::rtl::OUString UnoEditControl::getSelectedText( void ) throw(uno::RuntimeException) 366 { 367 ::rtl::OUString sSelected; 368 uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY ); 369 if ( xText.is() ) 370 sSelected = xText->getSelectedText(); 371 372 return sSelected; 373 } 374 375 void UnoEditControl::setSelection( const awt::Selection& aSelection ) throw(uno::RuntimeException) 376 { 377 uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY ); 378 if ( xText.is() ) 379 xText->setSelection( aSelection ); 380 } 381 382 awt::Selection UnoEditControl::getSelection( void ) throw(uno::RuntimeException) 383 { 384 awt::Selection aSel; 385 uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY ); 386 if ( xText.is() ) 387 aSel = xText->getSelection(); 388 return aSel; 389 } 390 391 sal_Bool UnoEditControl::isEditable( void ) throw(uno::RuntimeException) 392 { 393 return !ImplGetPropertyValue_BOOL( BASEPROPERTY_READONLY ); 394 } 395 396 void UnoEditControl::setEditable( sal_Bool bEditable ) throw(uno::RuntimeException) 397 { 398 uno::Any aAny; 399 aAny <<= (sal_Bool)!bEditable; 400 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_READONLY ), aAny, sal_True ); 401 } 402 403 sal_Int16 UnoEditControl::getMaxTextLen() throw(uno::RuntimeException) 404 { 405 sal_Int16 nMaxLen = mnMaxTextLen; 406 407 if ( ImplHasProperty( BASEPROPERTY_MAXTEXTLEN ) ) 408 nMaxLen = ImplGetPropertyValue_INT16( BASEPROPERTY_MAXTEXTLEN ); 409 410 return nMaxLen; 411 } 412 413 void UnoEditControl::setMaxTextLen( sal_Int16 nLen ) throw(uno::RuntimeException) 414 { 415 if ( ImplHasProperty( BASEPROPERTY_MAXTEXTLEN) ) 416 { 417 uno::Any aAny; 418 aAny <<= (sal_Int16)nLen; 419 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_MAXTEXTLEN ), aAny, sal_True ); 420 } 421 else 422 { 423 mnMaxTextLen = nLen; 424 mbSetMaxTextLenInPeer = sal_True; 425 uno::Reference < awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY ); 426 if ( xText.is() ) 427 xText->setMaxTextLen( mnMaxTextLen ); 428 } 429 } 430 431 awt::Size UnoEditControl::getMinimumSize( ) throw(uno::RuntimeException) 432 { 433 return Impl_getMinimumSize(); 434 } 435 436 awt::Size UnoEditControl::getPreferredSize( ) throw(uno::RuntimeException) 437 { 438 return Impl_getPreferredSize(); 439 } 440 441 awt::Size UnoEditControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException) 442 { 443 return Impl_calcAdjustedSize( rNewSize ); 444 } 445 446 awt::Size UnoEditControl::getMinimumSize( sal_Int16 nCols, sal_Int16 nLines ) throw(uno::RuntimeException) 447 { 448 return Impl_getMinimumSize( nCols, nLines ); 449 } 450 451 void UnoEditControl::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(uno::RuntimeException) 452 { 453 Impl_getColumnsAndLines( nCols, nLines ); 454 } 455 456 457 // ---------------------------------------------------- 458 // class UnoControlFileControlModel 459 // ---------------------------------------------------- 460 UnoControlFileControlModel::UnoControlFileControlModel( const Reference< XMultiServiceFactory >& i_factory ) 461 :UnoControlModel( i_factory ) 462 { 463 ImplRegisterProperty( BASEPROPERTY_ALIGN ); 464 ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR ); 465 ImplRegisterProperty( BASEPROPERTY_BORDER ); 466 ImplRegisterProperty( BASEPROPERTY_BORDERCOLOR ); 467 ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL ); 468 ImplRegisterProperty( BASEPROPERTY_ENABLED ); 469 ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE ); 470 ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR ); 471 ImplRegisterProperty( BASEPROPERTY_HELPTEXT ); 472 ImplRegisterProperty( BASEPROPERTY_HELPURL ); 473 ImplRegisterProperty( BASEPROPERTY_PRINTABLE ); 474 ImplRegisterProperty( BASEPROPERTY_READONLY ); 475 ImplRegisterProperty( BASEPROPERTY_TABSTOP ); 476 ImplRegisterProperty( BASEPROPERTY_TEXT ); 477 ImplRegisterProperty( BASEPROPERTY_VERTICALALIGN ); 478 ImplRegisterProperty( BASEPROPERTY_WRITING_MODE ); 479 ImplRegisterProperty( BASEPROPERTY_CONTEXT_WRITING_MODE ); 480 ImplRegisterProperty( BASEPROPERTY_HIDEINACTIVESELECTION ); 481 } 482 483 ::rtl::OUString UnoControlFileControlModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 484 { 485 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlFileControlModel ); 486 } 487 488 uno::Any UnoControlFileControlModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 489 { 490 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL ) 491 { 492 uno::Any aAny; 493 aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlFileControl ); 494 return aAny; 495 } 496 return UnoControlModel::ImplGetDefaultValue( nPropId ); 497 } 498 499 ::cppu::IPropertyArrayHelper& UnoControlFileControlModel::getInfoHelper() 500 { 501 static UnoPropertyArrayHelper* pHelper = NULL; 502 if ( !pHelper ) 503 { 504 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 505 pHelper = new UnoPropertyArrayHelper( aIDs ); 506 } 507 return *pHelper; 508 } 509 510 // beans::XMultiPropertySet 511 uno::Reference< beans::XPropertySetInfo > UnoControlFileControlModel::getPropertySetInfo( ) throw(uno::RuntimeException) 512 { 513 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 514 return xInfo; 515 } 516 517 // ---------------------------------------------------- 518 // class UnoFileControl 519 // ---------------------------------------------------- 520 UnoFileControl::UnoFileControl( const Reference< XMultiServiceFactory >& i_factory ) 521 :UnoEditControl( i_factory ) 522 { 523 } 524 525 ::rtl::OUString UnoFileControl::GetComponentServiceName() 526 { 527 return ::rtl::OUString::createFromAscii( "filecontrol" ); 528 } 529 530 // ---------------------------------------------------- 531 // class GraphicControlModel 532 // ---------------------------------------------------- 533 uno::Any GraphicControlModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 534 { 535 if ( nPropId == BASEPROPERTY_GRAPHIC ) 536 return uno::makeAny( uno::Reference< graphic::XGraphic >() ); 537 538 return UnoControlModel::ImplGetDefaultValue( nPropId ); 539 } 540 uno::Reference< graphic::XGraphic > GraphicControlModel::getGraphicFromURL_nothrow( const ::rtl::OUString& _rURL ) 541 { 542 uno::Reference< graphic::XGraphic > xGraphic; 543 544 if( ( _rURL.compareToAscii( UNO_NAME_GRAPHOBJ_URLPREFIX, RTL_CONSTASCII_LENGTH( UNO_NAME_GRAPHOBJ_URLPREFIX ) ) == 0 ) ) 545 { 546 // graphic manager uniqueid 547 rtl::OUString sID = _rURL.copy( sizeof( UNO_NAME_GRAPHOBJ_URLPREFIX ) - 1 ); 548 // get the DefaultContext 549 mxGrfObj = graphic::GraphicObject::createWithId( maContext.getUNOContext(), sID ); 550 } 551 else // linked 552 mxGrfObj = NULL; // release the GraphicObject 553 554 if ( !_rURL.getLength() ) 555 return xGraphic; 556 557 try 558 { 559 uno::Reference< graphic::XGraphicProvider > xProvider; 560 if ( maContext.createComponent( "com.sun.star.graphic.GraphicProvider", xProvider ) ) 561 { 562 uno::Sequence< beans::PropertyValue > aMediaProperties(1); 563 aMediaProperties[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "URL" ) ); 564 aMediaProperties[0].Value <<= _rURL; 565 xGraphic = xProvider->queryGraphic( aMediaProperties ); 566 } 567 } 568 catch( const Exception& ) 569 { 570 DBG_UNHANDLED_EXCEPTION(); 571 } 572 573 return xGraphic; 574 } 575 576 void SAL_CALL GraphicControlModel::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const ::com::sun::star::uno::Any& rValue ) throw (::com::sun::star::uno::Exception) 577 { 578 UnoControlModel::setFastPropertyValue_NoBroadcast( nHandle, rValue ); 579 580 // - ImageAlign and ImagePosition need to correspond to each other 581 // - Graphic and ImageURL need to correspond to each other 582 try 583 { 584 switch ( nHandle ) 585 { 586 case BASEPROPERTY_IMAGEURL: 587 if ( !mbAdjustingGraphic && ImplHasProperty( BASEPROPERTY_GRAPHIC ) ) 588 { 589 mbAdjustingGraphic = true; 590 ::rtl::OUString sImageURL; 591 OSL_VERIFY( rValue >>= sImageURL ); 592 setDependentFastPropertyValue( BASEPROPERTY_GRAPHIC, uno::makeAny( getGraphicFromURL_nothrow( sImageURL ) ) ); 593 mbAdjustingGraphic = false; 594 } 595 break; 596 597 case BASEPROPERTY_GRAPHIC: 598 if ( !mbAdjustingGraphic && ImplHasProperty( BASEPROPERTY_IMAGEURL ) ) 599 { 600 mbAdjustingGraphic = true; 601 setDependentFastPropertyValue( BASEPROPERTY_IMAGEURL, uno::makeAny( ::rtl::OUString() ) ); 602 mbAdjustingGraphic = false; 603 } 604 break; 605 606 case BASEPROPERTY_IMAGEALIGN: 607 if ( !mbAdjustingImagePosition && ImplHasProperty( BASEPROPERTY_IMAGEPOSITION ) ) 608 { 609 mbAdjustingImagePosition = true; 610 sal_Int16 nUNOValue = 0; 611 OSL_VERIFY( rValue >>= nUNOValue ); 612 setDependentFastPropertyValue( BASEPROPERTY_IMAGEPOSITION, uno::makeAny( getExtendedImagePosition( nUNOValue ) ) ); 613 mbAdjustingImagePosition = false; 614 } 615 break; 616 case BASEPROPERTY_IMAGEPOSITION: 617 if ( !mbAdjustingImagePosition && ImplHasProperty( BASEPROPERTY_IMAGEALIGN ) ) 618 { 619 mbAdjustingImagePosition = true; 620 sal_Int16 nUNOValue = 0; 621 OSL_VERIFY( rValue >>= nUNOValue ); 622 setDependentFastPropertyValue( BASEPROPERTY_IMAGEALIGN, uno::makeAny( getCompatibleImageAlign( translateImagePosition( nUNOValue ) ) ) ); 623 mbAdjustingImagePosition = false; 624 } 625 break; 626 } 627 } 628 catch( const ::com::sun::star::uno::Exception& ) 629 { 630 OSL_ENSURE( sal_False, "GraphicControlModel::setFastPropertyValue_NoBroadcast: caught an exception while aligning the ImagePosition/ImageAlign properties!" ); 631 mbAdjustingImagePosition = sal_False; 632 } 633 } 634 635 // ---------------------------------------------------- 636 // class UnoControlButtonModel 637 // ---------------------------------------------------- 638 UnoControlButtonModel::UnoControlButtonModel( const Reference< XMultiServiceFactory >& i_factory ) 639 :GraphicControlModel( i_factory ) 640 { 641 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXButton ); 642 643 osl_incrementInterlockedCount( &m_refCount ); 644 { 645 setFastPropertyValue_NoBroadcast( BASEPROPERTY_IMAGEPOSITION, ImplGetDefaultValue( BASEPROPERTY_IMAGEPOSITION ) ); 646 // this ensures that our ImagePosition is consistent with our ImageAlign property (since both 647 // defaults are not per se consistent), since both are coupled in setFastPropertyValue_NoBroadcast 648 } 649 osl_decrementInterlockedCount( &m_refCount ); 650 } 651 652 ::rtl::OUString UnoControlButtonModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 653 { 654 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlButtonModel ); 655 } 656 657 uno::Any UnoControlButtonModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 658 { 659 switch ( nPropId ) 660 { 661 case BASEPROPERTY_DEFAULTCONTROL: 662 return uno::makeAny( ::rtl::OUString::createFromAscii( szServiceName_UnoControlButton ) ); 663 case BASEPROPERTY_TOGGLE: 664 return uno::makeAny( (sal_Bool)sal_False ); 665 case BASEPROPERTY_ALIGN: 666 return uno::makeAny( (sal_Int16)PROPERTY_ALIGN_CENTER ); 667 case BASEPROPERTY_FOCUSONCLICK: 668 return uno::makeAny( (sal_Bool)sal_True ); 669 } 670 671 return GraphicControlModel::ImplGetDefaultValue( nPropId ); 672 } 673 674 ::cppu::IPropertyArrayHelper& UnoControlButtonModel::getInfoHelper() 675 { 676 static UnoPropertyArrayHelper* pHelper = NULL; 677 if ( !pHelper ) 678 { 679 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 680 pHelper = new UnoPropertyArrayHelper( aIDs ); 681 } 682 return *pHelper; 683 } 684 685 // beans::XMultiPropertySet 686 uno::Reference< beans::XPropertySetInfo > UnoControlButtonModel::getPropertySetInfo( ) throw(uno::RuntimeException) 687 { 688 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 689 return xInfo; 690 } 691 692 // ---------------------------------------------------- 693 // class UnoButtonControl 694 // ---------------------------------------------------- 695 UnoButtonControl::UnoButtonControl( const uno::Reference< lang::XMultiServiceFactory >& i_factory ) 696 :UnoButtonControl_Base( i_factory ) 697 ,maActionListeners( *this ) 698 ,maItemListeners( *this ) 699 { 700 maComponentInfos.nWidth = 50; 701 maComponentInfos.nHeight = 14; 702 } 703 704 ::rtl::OUString UnoButtonControl::GetComponentServiceName() 705 { 706 ::rtl::OUString aName( ::rtl::OUString::createFromAscii( "pushbutton" ) ); 707 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_PUSHBUTTONTYPE ) ); 708 sal_Int16 n = sal_Int16(); 709 if ( ( aVal >>= n ) && n ) 710 { 711 // Use PushButtonType later when available... 712 switch ( n ) 713 { 714 case 1 /*PushButtonType::OK*/: aName= ::rtl::OUString::createFromAscii( "okbutton" ); 715 break; 716 case 2 /*PushButtonType::CANCEL*/: aName= ::rtl::OUString::createFromAscii( "cancelbutton" ); 717 break; 718 case 3 /*PushButtonType::HELP*/: aName= ::rtl::OUString::createFromAscii( "helpbutton" ); 719 break; 720 default: 721 { 722 DBG_ERROR( "Unknown Button Type!" ); 723 } 724 } 725 } 726 return aName; 727 } 728 729 void UnoButtonControl::dispose() throw(uno::RuntimeException) 730 { 731 lang::EventObject aEvt; 732 aEvt.Source = (::cppu::OWeakObject*)this; 733 maActionListeners.disposeAndClear( aEvt ); 734 maItemListeners.disposeAndClear( aEvt ); 735 UnoControlBase::dispose(); 736 } 737 738 void UnoButtonControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException) 739 { 740 UnoControlBase::createPeer( rxToolkit, rParentPeer ); 741 742 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY ); 743 xButton->setActionCommand( maActionCommand ); 744 if ( maActionListeners.getLength() ) 745 xButton->addActionListener( &maActionListeners ); 746 747 uno::Reference< XToggleButton > xPushButton( getPeer(), uno::UNO_QUERY ); 748 if ( xPushButton.is() ) 749 xPushButton->addItemListener( this ); 750 } 751 752 void UnoButtonControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException) 753 { 754 maActionListeners.addInterface( l ); 755 if( getPeer().is() && maActionListeners.getLength() == 1 ) 756 { 757 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY ); 758 xButton->addActionListener( &maActionListeners ); 759 } 760 } 761 762 void UnoButtonControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException) 763 { 764 if( getPeer().is() && maActionListeners.getLength() == 1 ) 765 { 766 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY ); 767 xButton->removeActionListener( &maActionListeners ); 768 } 769 maActionListeners.removeInterface( l ); 770 } 771 772 void UnoButtonControl::addItemListener(const uno::Reference< awt::XItemListener > & l) throw(uno::RuntimeException) 773 { 774 maItemListeners.addInterface( l ); 775 } 776 777 void UnoButtonControl::removeItemListener(const uno::Reference< awt::XItemListener > & l) throw(uno::RuntimeException) 778 { 779 maItemListeners.removeInterface( l ); 780 } 781 782 void SAL_CALL UnoButtonControl::disposing( const lang::EventObject& Source ) throw (uno::RuntimeException) 783 { 784 UnoControlBase::disposing( Source ); 785 } 786 787 void SAL_CALL UnoButtonControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw (uno::RuntimeException) 788 { 789 // forward to model 790 uno::Any aAny; 791 aAny <<= (sal_Int16)rEvent.Selected; 792 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_False ); 793 794 // multiplex 795 ItemEvent aEvent( rEvent ); 796 aEvent.Source = *this; 797 maItemListeners.itemStateChanged( aEvent ); 798 } 799 800 void UnoButtonControl::setLabel( const ::rtl::OUString& rLabel ) throw(uno::RuntimeException) 801 { 802 uno::Any aAny; 803 aAny <<= rLabel; 804 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True ); 805 } 806 807 void UnoButtonControl::setActionCommand( const ::rtl::OUString& rCommand ) throw(uno::RuntimeException) 808 { 809 maActionCommand = rCommand; 810 if ( getPeer().is() ) 811 { 812 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY ); 813 xButton->setActionCommand( rCommand ); 814 } 815 } 816 817 awt::Size UnoButtonControl::getMinimumSize( ) throw(uno::RuntimeException) 818 { 819 return Impl_getMinimumSize(); 820 } 821 822 awt::Size UnoButtonControl::getPreferredSize( ) throw(uno::RuntimeException) 823 { 824 return Impl_getPreferredSize(); 825 } 826 827 awt::Size UnoButtonControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException) 828 { 829 return Impl_calcAdjustedSize( rNewSize ); 830 } 831 832 // ---------------------------------------------------- 833 // class UnoControlImageControlModel 834 // ---------------------------------------------------- 835 UnoControlImageControlModel::UnoControlImageControlModel( const Reference< XMultiServiceFactory >& i_factory ) 836 :GraphicControlModel( i_factory ) 837 ,mbAdjustingImageScaleMode( false ) 838 { 839 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXImageControl ); 840 } 841 842 ::rtl::OUString UnoControlImageControlModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 843 { 844 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlImageControlModel ); 845 } 846 847 uno::Any UnoControlImageControlModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 848 { 849 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL ) 850 return uno::makeAny( ::rtl::OUString::createFromAscii( szServiceName_UnoControlImageControl ) ); 851 852 if ( nPropId == BASEPROPERTY_IMAGE_SCALE_MODE ) 853 return makeAny( awt::ImageScaleMode::Anisotropic ); 854 855 return GraphicControlModel::ImplGetDefaultValue( nPropId ); 856 } 857 858 ::cppu::IPropertyArrayHelper& UnoControlImageControlModel::getInfoHelper() 859 { 860 static UnoPropertyArrayHelper* pHelper = NULL; 861 if ( !pHelper ) 862 { 863 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 864 pHelper = new UnoPropertyArrayHelper( aIDs ); 865 } 866 return *pHelper; 867 } 868 869 // beans::XMultiPropertySet 870 uno::Reference< beans::XPropertySetInfo > UnoControlImageControlModel::getPropertySetInfo( ) throw(uno::RuntimeException) 871 { 872 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 873 return xInfo; 874 } 875 876 void SAL_CALL UnoControlImageControlModel::setFastPropertyValue_NoBroadcast( sal_Int32 _nHandle, const ::com::sun::star::uno::Any& _rValue ) throw (::com::sun::star::uno::Exception) 877 { 878 GraphicControlModel::setFastPropertyValue_NoBroadcast( _nHandle, _rValue ); 879 880 // ScaleImage is an older (and less powerful) version of ScaleMode, but keep both in sync as far as possible 881 try 882 { 883 switch ( _nHandle ) 884 { 885 case BASEPROPERTY_IMAGE_SCALE_MODE: 886 if ( !mbAdjustingImageScaleMode && ImplHasProperty( BASEPROPERTY_SCALEIMAGE ) ) 887 { 888 mbAdjustingImageScaleMode = true; 889 sal_Int16 nScaleMode( awt::ImageScaleMode::Anisotropic ); 890 OSL_VERIFY( _rValue >>= nScaleMode ); 891 setDependentFastPropertyValue( BASEPROPERTY_SCALEIMAGE, uno::makeAny( sal_Bool( nScaleMode != awt::ImageScaleMode::None ) ) ); 892 mbAdjustingImageScaleMode = false; 893 } 894 break; 895 case BASEPROPERTY_SCALEIMAGE: 896 if ( !mbAdjustingImageScaleMode && ImplHasProperty( BASEPROPERTY_IMAGE_SCALE_MODE ) ) 897 { 898 mbAdjustingImageScaleMode = true; 899 sal_Bool bScale = sal_True; 900 OSL_VERIFY( _rValue >>= bScale ); 901 setDependentFastPropertyValue( BASEPROPERTY_IMAGE_SCALE_MODE, uno::makeAny( bScale ? awt::ImageScaleMode::Anisotropic : awt::ImageScaleMode::None ) ); 902 mbAdjustingImageScaleMode = false; 903 } 904 break; 905 } 906 } 907 catch( const Exception& ) 908 { 909 mbAdjustingImageScaleMode = false; 910 throw; 911 } 912 } 913 914 // ---------------------------------------------------- 915 // class UnoImageControlControl 916 // ---------------------------------------------------- 917 UnoImageControlControl::UnoImageControlControl( const Reference< XMultiServiceFactory >& i_factory ) 918 :UnoImageControlControl_Base( i_factory ) 919 ,maActionListeners( *this ) 920 { 921 // Woher die Defaults nehmen? 922 maComponentInfos.nWidth = 100; 923 maComponentInfos.nHeight = 100; 924 } 925 926 ::rtl::OUString UnoImageControlControl::GetComponentServiceName() 927 { 928 return ::rtl::OUString::createFromAscii( "fixedimage" ); 929 } 930 931 void UnoImageControlControl::dispose() throw(uno::RuntimeException) 932 { 933 lang::EventObject aEvt; 934 aEvt.Source = (::cppu::OWeakObject*)this; 935 maActionListeners.disposeAndClear( aEvt ); 936 UnoControl::dispose(); 937 } 938 939 sal_Bool UnoImageControlControl::isTransparent() throw(uno::RuntimeException) 940 { 941 return sal_True; 942 } 943 944 awt::Size UnoImageControlControl::getMinimumSize( ) throw(uno::RuntimeException) 945 { 946 return Impl_getMinimumSize(); 947 } 948 949 awt::Size UnoImageControlControl::getPreferredSize( ) throw(uno::RuntimeException) 950 { 951 return Impl_getPreferredSize(); 952 } 953 954 awt::Size UnoImageControlControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException) 955 { 956 return Impl_calcAdjustedSize( rNewSize ); 957 } 958 959 // ---------------------------------------------------- 960 // class UnoControlRadioButtonModel 961 // ---------------------------------------------------- 962 UnoControlRadioButtonModel::UnoControlRadioButtonModel( const Reference< XMultiServiceFactory >& i_factory ) 963 :GraphicControlModel( i_factory ) 964 { 965 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXRadioButton ); 966 } 967 968 ::rtl::OUString UnoControlRadioButtonModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 969 { 970 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlRadioButtonModel ); 971 } 972 973 uno::Any UnoControlRadioButtonModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 974 { 975 switch ( nPropId ) 976 { 977 case BASEPROPERTY_DEFAULTCONTROL: 978 return uno::makeAny( ::rtl::OUString::createFromAscii( szServiceName_UnoControlRadioButton ) ); 979 980 case BASEPROPERTY_VISUALEFFECT: 981 return uno::makeAny( (sal_Int16)awt::VisualEffect::LOOK3D ); 982 } 983 984 return GraphicControlModel::ImplGetDefaultValue( nPropId ); 985 } 986 987 ::cppu::IPropertyArrayHelper& UnoControlRadioButtonModel::getInfoHelper() 988 { 989 static UnoPropertyArrayHelper* pHelper = NULL; 990 if ( !pHelper ) 991 { 992 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 993 pHelper = new UnoPropertyArrayHelper( aIDs ); 994 } 995 return *pHelper; 996 } 997 998 // beans::XMultiPropertySet 999 uno::Reference< beans::XPropertySetInfo > UnoControlRadioButtonModel::getPropertySetInfo( ) throw(uno::RuntimeException) 1000 { 1001 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 1002 return xInfo; 1003 } 1004 1005 1006 1007 // ---------------------------------------------------- 1008 // class UnoRadioButtonControl 1009 // ---------------------------------------------------- 1010 UnoRadioButtonControl::UnoRadioButtonControl( const Reference< XMultiServiceFactory >& i_factory ) 1011 :UnoRadioButtonControl_Base( i_factory ) 1012 ,maItemListeners( *this ) 1013 ,maActionListeners( *this ) 1014 { 1015 maComponentInfos.nWidth = 100; 1016 maComponentInfos.nHeight = 12; 1017 } 1018 1019 ::rtl::OUString UnoRadioButtonControl::GetComponentServiceName() 1020 { 1021 return ::rtl::OUString::createFromAscii( "radiobutton" ); 1022 } 1023 1024 void UnoRadioButtonControl::dispose() throw(uno::RuntimeException) 1025 { 1026 lang::EventObject aEvt; 1027 aEvt.Source = (::cppu::OWeakObject*)this; 1028 maItemListeners.disposeAndClear( aEvt ); 1029 UnoControlBase::dispose(); 1030 } 1031 1032 1033 sal_Bool UnoRadioButtonControl::isTransparent() throw(uno::RuntimeException) 1034 { 1035 return sal_True; 1036 } 1037 1038 void UnoRadioButtonControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException) 1039 { 1040 UnoControlBase::createPeer( rxToolkit, rParentPeer ); 1041 1042 uno::Reference < awt::XRadioButton > xRadioButton( getPeer(), uno::UNO_QUERY ); 1043 xRadioButton->addItemListener( this ); 1044 1045 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY ); 1046 xButton->setActionCommand( maActionCommand ); 1047 if ( maActionListeners.getLength() ) 1048 xButton->addActionListener( &maActionListeners ); 1049 1050 // as default, set the "AutoToggle" to true 1051 // (it is set to false in VCLXToolkit::ImplCreateWindow because of #87254#, but we want to 1052 // have it enabled by default because of 85071) 1053 uno::Reference< awt::XVclWindowPeer > xVclWindowPeer( getPeer(), uno::UNO_QUERY ); 1054 if ( xVclWindowPeer.is() ) 1055 xVclWindowPeer->setProperty( GetPropertyName( BASEPROPERTY_AUTOTOGGLE ), ::cppu::bool2any( sal_True ) ); 1056 } 1057 1058 void UnoRadioButtonControl::addItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException) 1059 { 1060 maItemListeners.addInterface( l ); 1061 } 1062 1063 void UnoRadioButtonControl::removeItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException) 1064 { 1065 maItemListeners.removeInterface( l ); 1066 } 1067 1068 void UnoRadioButtonControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException) 1069 { 1070 maActionListeners.addInterface( l ); 1071 if( getPeer().is() && maActionListeners.getLength() == 1 ) 1072 { 1073 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY ); 1074 xButton->addActionListener( &maActionListeners ); 1075 } 1076 } 1077 1078 void UnoRadioButtonControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException) 1079 { 1080 if( getPeer().is() && maActionListeners.getLength() == 1 ) 1081 { 1082 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY ); 1083 xButton->removeActionListener( &maActionListeners ); 1084 } 1085 maActionListeners.removeInterface( l ); 1086 } 1087 1088 void UnoRadioButtonControl::setLabel( const ::rtl::OUString& rLabel ) throw(uno::RuntimeException) 1089 { 1090 uno::Any aAny; 1091 aAny <<= rLabel; 1092 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True ); 1093 } 1094 1095 void UnoRadioButtonControl::setActionCommand( const ::rtl::OUString& rCommand ) throw(uno::RuntimeException) 1096 { 1097 maActionCommand = rCommand; 1098 if ( getPeer().is() ) 1099 { 1100 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY ); 1101 xButton->setActionCommand( rCommand ); 1102 } 1103 } 1104 1105 void UnoRadioButtonControl::setState( sal_Bool bOn ) throw(uno::RuntimeException) 1106 { 1107 sal_Int16 nState = bOn ? 1 : 0; 1108 uno::Any aAny; 1109 aAny <<= nState; 1110 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_True ); 1111 } 1112 1113 sal_Bool UnoRadioButtonControl::getState() throw(uno::RuntimeException) 1114 { 1115 sal_Int16 nState = 0; 1116 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ) ); 1117 aVal >>= nState; 1118 return nState ? sal_True : sal_False; 1119 } 1120 1121 void UnoRadioButtonControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw(uno::RuntimeException) 1122 { 1123 uno::Any aAny; 1124 aAny <<= (sal_Int16)rEvent.Selected; 1125 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_False ); 1126 1127 // compatibility: 1128 // in OOo 1.0.x, when the user clicked a radio button in a group of buttons, this resulted 1129 // in _one_ itemStateChanged call for exactly the radio button which's state changed from 1130 // "0" to "1". 1131 // Nowadays, since the listener handling changed a lot towards 1.1 (the VCLXWindow reacts on more 1132 // basic events from the VCL-windows, not anymore on the Link-based events like in 1.0.x), this 1133 // isn't the case anymore: For instance, this method here gets called for the radio button 1134 // which is being implicitily _de_selected, too. This is pretty bad for compatibility. 1135 // Thus, we suppress all events with a new state other than "1". This is unlogical, and weird, when looking 1136 // from a pure API perspective, but it's _compatible_ with older product versions, and this is 1137 // all which matters here. 1138 // #i14703# - 2003-05-23 - fs@openoffice.org 1139 if ( 1 == rEvent.Selected ) 1140 { 1141 if ( maItemListeners.getLength() ) 1142 maItemListeners.itemStateChanged( rEvent ); 1143 } 1144 // note that speaking stricly, this is wrong: When in 1.0.x, the user would have de-selected 1145 // a radio button _without_ selecing another one, this would have caused a notification. 1146 // With the change done here, this today won't cause a notification anymore. 1147 // 1148 // Fortunately, it's not possible for the user to de-select a radio button without selecting another on, 1149 // at least not via the regular UI. It _would_ be possible via the Accessibility API, which 1150 // counts as "user input", too. But in 1.0.x, there was no Accessibility API, so there is nothing 1151 // to be inconsistent with. 1152 } 1153 1154 awt::Size UnoRadioButtonControl::getMinimumSize( ) throw(uno::RuntimeException) 1155 { 1156 return Impl_getMinimumSize(); 1157 } 1158 1159 awt::Size UnoRadioButtonControl::getPreferredSize( ) throw(uno::RuntimeException) 1160 { 1161 return Impl_getPreferredSize(); 1162 } 1163 1164 awt::Size UnoRadioButtonControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException) 1165 { 1166 return Impl_calcAdjustedSize( rNewSize ); 1167 } 1168 1169 // ---------------------------------------------------- 1170 // class UnoControlCheckBoxModel 1171 // ---------------------------------------------------- 1172 UnoControlCheckBoxModel::UnoControlCheckBoxModel( const Reference< XMultiServiceFactory >& i_factory ) 1173 :GraphicControlModel( i_factory ) 1174 { 1175 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXCheckBox ); 1176 } 1177 1178 ::rtl::OUString UnoControlCheckBoxModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 1179 { 1180 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlCheckBoxModel ); 1181 } 1182 1183 uno::Any UnoControlCheckBoxModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 1184 { 1185 switch ( nPropId ) 1186 { 1187 case BASEPROPERTY_DEFAULTCONTROL: 1188 return uno::makeAny( ::rtl::OUString::createFromAscii( szServiceName_UnoControlCheckBox ) ); 1189 1190 case BASEPROPERTY_VISUALEFFECT: 1191 return uno::makeAny( (sal_Int16)awt::VisualEffect::LOOK3D ); 1192 } 1193 1194 return GraphicControlModel::ImplGetDefaultValue( nPropId ); 1195 } 1196 1197 ::cppu::IPropertyArrayHelper& UnoControlCheckBoxModel::getInfoHelper() 1198 { 1199 static UnoPropertyArrayHelper* pHelper = NULL; 1200 if ( !pHelper ) 1201 { 1202 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 1203 pHelper = new UnoPropertyArrayHelper( aIDs ); 1204 } 1205 return *pHelper; 1206 } 1207 1208 // beans::XMultiPropertySet 1209 uno::Reference< beans::XPropertySetInfo > UnoControlCheckBoxModel::getPropertySetInfo( ) throw(uno::RuntimeException) 1210 { 1211 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 1212 return xInfo; 1213 } 1214 1215 1216 1217 // ---------------------------------------------------- 1218 // class UnoCheckBoxControl 1219 // ---------------------------------------------------- 1220 UnoCheckBoxControl::UnoCheckBoxControl( const uno::Reference< lang::XMultiServiceFactory >& i_factory ) 1221 :UnoCheckBoxControl_Base( i_factory ) 1222 ,maItemListeners( *this ), maActionListeners( *this ) 1223 { 1224 maComponentInfos.nWidth = 100; 1225 maComponentInfos.nHeight = 12; 1226 } 1227 1228 ::rtl::OUString UnoCheckBoxControl::GetComponentServiceName() 1229 { 1230 return ::rtl::OUString::createFromAscii( "checkbox" ); 1231 } 1232 1233 void UnoCheckBoxControl::dispose() throw(uno::RuntimeException) 1234 { 1235 lang::EventObject aEvt; 1236 aEvt.Source = (::cppu::OWeakObject*)this; 1237 maItemListeners.disposeAndClear( aEvt ); 1238 UnoControlBase::dispose(); 1239 } 1240 1241 sal_Bool UnoCheckBoxControl::isTransparent() throw(uno::RuntimeException) 1242 { 1243 return sal_True; 1244 } 1245 1246 void UnoCheckBoxControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException) 1247 { 1248 UnoControlBase::createPeer( rxToolkit, rParentPeer ); 1249 1250 uno::Reference < awt::XCheckBox > xCheckBox( getPeer(), uno::UNO_QUERY ); 1251 xCheckBox->addItemListener( this ); 1252 1253 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY ); 1254 xButton->setActionCommand( maActionCommand ); 1255 if ( maActionListeners.getLength() ) 1256 xButton->addActionListener( &maActionListeners ); 1257 } 1258 1259 void UnoCheckBoxControl::addItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException) 1260 { 1261 maItemListeners.addInterface( l ); 1262 } 1263 1264 void UnoCheckBoxControl::removeItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException) 1265 { 1266 maItemListeners.removeInterface( l ); 1267 } 1268 1269 void UnoCheckBoxControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException) 1270 { 1271 maActionListeners.addInterface( l ); 1272 if( getPeer().is() && maActionListeners.getLength() == 1 ) 1273 { 1274 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY ); 1275 xButton->addActionListener( &maActionListeners ); 1276 } 1277 } 1278 1279 void UnoCheckBoxControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException) 1280 { 1281 if( getPeer().is() && maActionListeners.getLength() == 1 ) 1282 { 1283 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY ); 1284 xButton->removeActionListener( &maActionListeners ); 1285 } 1286 maActionListeners.removeInterface( l ); 1287 } 1288 1289 void UnoCheckBoxControl::setActionCommand( const ::rtl::OUString& rCommand ) throw(uno::RuntimeException) 1290 { 1291 maActionCommand = rCommand; 1292 if ( getPeer().is() ) 1293 { 1294 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY ); 1295 xButton->setActionCommand( rCommand ); 1296 } 1297 } 1298 1299 1300 void UnoCheckBoxControl::setLabel( const ::rtl::OUString& rLabel ) throw(uno::RuntimeException) 1301 { 1302 uno::Any aAny; 1303 aAny <<= rLabel; 1304 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True ); 1305 } 1306 1307 void UnoCheckBoxControl::setState( short n ) throw(uno::RuntimeException) 1308 { 1309 uno::Any aAny; 1310 aAny <<= (sal_Int16)n; 1311 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_True ); 1312 } 1313 1314 short UnoCheckBoxControl::getState() throw(uno::RuntimeException) 1315 { 1316 short nState = 0; 1317 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ) ); 1318 aVal >>= nState; 1319 return nState; 1320 } 1321 1322 void UnoCheckBoxControl::enableTriState( sal_Bool b ) throw(uno::RuntimeException) 1323 { 1324 uno::Any aAny; 1325 aAny <<= b; 1326 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TRISTATE ), aAny, sal_True ); 1327 } 1328 1329 void UnoCheckBoxControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw(uno::RuntimeException) 1330 { 1331 uno::Any aAny; 1332 aAny <<= (sal_Int16)rEvent.Selected; 1333 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_False ); 1334 1335 if ( maItemListeners.getLength() ) 1336 maItemListeners.itemStateChanged( rEvent ); 1337 } 1338 1339 awt::Size UnoCheckBoxControl::getMinimumSize( ) throw(uno::RuntimeException) 1340 { 1341 return Impl_getMinimumSize(); 1342 } 1343 1344 awt::Size UnoCheckBoxControl::getPreferredSize( ) throw(uno::RuntimeException) 1345 { 1346 return Impl_getPreferredSize(); 1347 } 1348 1349 awt::Size UnoCheckBoxControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException) 1350 { 1351 return Impl_calcAdjustedSize( rNewSize ); 1352 } 1353 1354 // ---------------------------------------------------- 1355 // class UnoControlFixedHyperlinkModel 1356 // ---------------------------------------------------- 1357 UnoControlFixedHyperlinkModel::UnoControlFixedHyperlinkModel( const Reference< XMultiServiceFactory >& i_factory ) 1358 :UnoControlModel( i_factory ) 1359 { 1360 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXFixedHyperlink ); 1361 } 1362 1363 ::rtl::OUString UnoControlFixedHyperlinkModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 1364 { 1365 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlFixedHyperlinkModel ); 1366 } 1367 1368 uno::Any UnoControlFixedHyperlinkModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 1369 { 1370 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL ) 1371 { 1372 uno::Any aAny; 1373 aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlFixedHyperlink ); 1374 return aAny; 1375 } 1376 else if ( nPropId == BASEPROPERTY_BORDER ) 1377 { 1378 uno::Any aAny; 1379 aAny <<= (sal_Int16)0; 1380 return aAny; 1381 } 1382 else if ( nPropId == BASEPROPERTY_URL ) 1383 { 1384 uno::Any aAny; 1385 aAny <<= ::rtl::OUString(); 1386 return aAny; 1387 } 1388 1389 return UnoControlModel::ImplGetDefaultValue( nPropId ); 1390 } 1391 1392 ::cppu::IPropertyArrayHelper& UnoControlFixedHyperlinkModel::getInfoHelper() 1393 { 1394 static UnoPropertyArrayHelper* pHelper = NULL; 1395 if ( !pHelper ) 1396 { 1397 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 1398 pHelper = new UnoPropertyArrayHelper( aIDs ); 1399 } 1400 return *pHelper; 1401 } 1402 1403 // beans::XMultiPropertySet 1404 uno::Reference< beans::XPropertySetInfo > UnoControlFixedHyperlinkModel::getPropertySetInfo( ) throw(uno::RuntimeException) 1405 { 1406 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 1407 return xInfo; 1408 } 1409 1410 // ---------------------------------------------------- 1411 // class UnoFixedHyperlinkControl 1412 // ---------------------------------------------------- 1413 UnoFixedHyperlinkControl::UnoFixedHyperlinkControl( const Reference< XMultiServiceFactory >& i_factory ) 1414 :UnoControlBase( i_factory ) 1415 ,maActionListeners( *this ) 1416 { 1417 maComponentInfos.nWidth = 100; 1418 maComponentInfos.nHeight = 12; 1419 } 1420 1421 ::rtl::OUString UnoFixedHyperlinkControl::GetComponentServiceName() 1422 { 1423 return ::rtl::OUString::createFromAscii( "fixedhyperlink" ); 1424 } 1425 1426 // uno::XInterface 1427 uno::Any UnoFixedHyperlinkControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException) 1428 { 1429 uno::Any aRet = ::cppu::queryInterface( rType, 1430 SAL_STATIC_CAST( awt::XFixedHyperlink*, this ), 1431 SAL_STATIC_CAST( awt::XLayoutConstrains*, this ) ); 1432 return (aRet.hasValue() ? aRet : UnoControlBase::queryAggregation( rType )); 1433 } 1434 1435 // lang::XTypeProvider 1436 IMPL_XTYPEPROVIDER_START( UnoFixedHyperlinkControl ) 1437 getCppuType( ( uno::Reference< awt::XFixedHyperlink>* ) NULL ), 1438 getCppuType( ( uno::Reference< awt::XLayoutConstrains>* ) NULL ), 1439 UnoControlBase::getTypes() 1440 IMPL_XTYPEPROVIDER_END 1441 1442 sal_Bool UnoFixedHyperlinkControl::isTransparent() throw(uno::RuntimeException) 1443 { 1444 return sal_True; 1445 } 1446 1447 void UnoFixedHyperlinkControl::setText( const ::rtl::OUString& Text ) throw(uno::RuntimeException) 1448 { 1449 uno::Any aAny; 1450 aAny <<= Text; 1451 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True ); 1452 } 1453 1454 ::rtl::OUString UnoFixedHyperlinkControl::getText() throw(uno::RuntimeException) 1455 { 1456 return ImplGetPropertyValue_UString( BASEPROPERTY_LABEL ); 1457 } 1458 1459 void UnoFixedHyperlinkControl::setURL( const ::rtl::OUString& URL ) throw(::com::sun::star::uno::RuntimeException) 1460 { 1461 uno::Any aAny; 1462 aAny <<= URL; 1463 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_URL ), aAny, sal_True ); 1464 } 1465 1466 ::rtl::OUString UnoFixedHyperlinkControl::getURL( ) throw(::com::sun::star::uno::RuntimeException) 1467 { 1468 return ImplGetPropertyValue_UString( BASEPROPERTY_URL ); 1469 } 1470 1471 void UnoFixedHyperlinkControl::setAlignment( short nAlign ) throw(uno::RuntimeException) 1472 { 1473 uno::Any aAny; 1474 aAny <<= (sal_Int16)nAlign; 1475 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_ALIGN ), aAny, sal_True ); 1476 } 1477 1478 short UnoFixedHyperlinkControl::getAlignment() throw(uno::RuntimeException) 1479 { 1480 short nAlign = 0; 1481 if ( mxModel.is() ) 1482 { 1483 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_ALIGN ) ); 1484 aVal >>= nAlign; 1485 } 1486 return nAlign; 1487 } 1488 1489 awt::Size UnoFixedHyperlinkControl::getMinimumSize( ) throw(uno::RuntimeException) 1490 { 1491 return Impl_getMinimumSize(); 1492 } 1493 1494 awt::Size UnoFixedHyperlinkControl::getPreferredSize( ) throw(uno::RuntimeException) 1495 { 1496 return Impl_getPreferredSize(); 1497 } 1498 1499 awt::Size UnoFixedHyperlinkControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException) 1500 { 1501 return Impl_calcAdjustedSize( rNewSize ); 1502 } 1503 1504 void UnoFixedHyperlinkControl::dispose() throw(uno::RuntimeException) 1505 { 1506 lang::EventObject aEvt; 1507 aEvt.Source = (::cppu::OWeakObject*)this; 1508 maActionListeners.disposeAndClear( aEvt ); 1509 UnoControlBase::dispose(); 1510 } 1511 1512 void UnoFixedHyperlinkControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException) 1513 { 1514 UnoControlBase::createPeer( rxToolkit, rParentPeer ); 1515 1516 uno::Reference < awt::XFixedHyperlink > xFixedHyperlink( getPeer(), uno::UNO_QUERY ); 1517 if ( maActionListeners.getLength() ) 1518 xFixedHyperlink->addActionListener( &maActionListeners ); 1519 } 1520 1521 void UnoFixedHyperlinkControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException) 1522 { 1523 maActionListeners.addInterface( l ); 1524 if( getPeer().is() && maActionListeners.getLength() == 1 ) 1525 { 1526 uno::Reference < awt::XFixedHyperlink > xFixedHyperlink( getPeer(), uno::UNO_QUERY ); 1527 xFixedHyperlink->addActionListener( &maActionListeners ); 1528 } 1529 } 1530 1531 void UnoFixedHyperlinkControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException) 1532 { 1533 if( getPeer().is() && maActionListeners.getLength() == 1 ) 1534 { 1535 uno::Reference < awt::XFixedHyperlink > xFixedHyperlink( getPeer(), uno::UNO_QUERY ); 1536 xFixedHyperlink->removeActionListener( &maActionListeners ); 1537 } 1538 maActionListeners.removeInterface( l ); 1539 } 1540 1541 // ---------------------------------------------------- 1542 // class UnoControlFixedTextModel 1543 // ---------------------------------------------------- 1544 UnoControlFixedTextModel::UnoControlFixedTextModel( const Reference< XMultiServiceFactory >& i_factory ) 1545 :UnoControlModel( i_factory ) 1546 { 1547 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXFixedText ); 1548 } 1549 1550 ::rtl::OUString UnoControlFixedTextModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 1551 { 1552 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlFixedTextModel ); 1553 } 1554 1555 uno::Any UnoControlFixedTextModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 1556 { 1557 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL ) 1558 { 1559 uno::Any aAny; 1560 aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlFixedText ); 1561 return aAny; 1562 } 1563 else if ( nPropId == BASEPROPERTY_BORDER ) 1564 { 1565 uno::Any aAny; 1566 aAny <<= (sal_Int16)0; 1567 return aAny; 1568 } 1569 1570 return UnoControlModel::ImplGetDefaultValue( nPropId ); 1571 } 1572 1573 ::cppu::IPropertyArrayHelper& UnoControlFixedTextModel::getInfoHelper() 1574 { 1575 static UnoPropertyArrayHelper* pHelper = NULL; 1576 if ( !pHelper ) 1577 { 1578 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 1579 pHelper = new UnoPropertyArrayHelper( aIDs ); 1580 } 1581 return *pHelper; 1582 } 1583 1584 // beans::XMultiPropertySet 1585 uno::Reference< beans::XPropertySetInfo > UnoControlFixedTextModel::getPropertySetInfo( ) throw(uno::RuntimeException) 1586 { 1587 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 1588 return xInfo; 1589 } 1590 1591 1592 // ---------------------------------------------------- 1593 // class UnoFixedTextControl 1594 // ---------------------------------------------------- 1595 UnoFixedTextControl::UnoFixedTextControl( const Reference< XMultiServiceFactory >& i_factory ) 1596 :UnoControlBase( i_factory ) 1597 { 1598 maComponentInfos.nWidth = 100; 1599 maComponentInfos.nHeight = 12; 1600 } 1601 1602 ::rtl::OUString UnoFixedTextControl::GetComponentServiceName() 1603 { 1604 return ::rtl::OUString::createFromAscii( "fixedtext" ); 1605 } 1606 1607 // uno::XInterface 1608 uno::Any UnoFixedTextControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException) 1609 { 1610 uno::Any aRet = ::cppu::queryInterface( rType, 1611 SAL_STATIC_CAST( awt::XFixedText*, this ), 1612 SAL_STATIC_CAST( awt::XLayoutConstrains*, this ) ); 1613 return (aRet.hasValue() ? aRet : UnoControlBase::queryAggregation( rType )); 1614 } 1615 1616 // lang::XTypeProvider 1617 IMPL_XTYPEPROVIDER_START( UnoFixedTextControl ) 1618 getCppuType( ( uno::Reference< awt::XFixedText>* ) NULL ), 1619 getCppuType( ( uno::Reference< awt::XLayoutConstrains>* ) NULL ), 1620 UnoControlBase::getTypes() 1621 IMPL_XTYPEPROVIDER_END 1622 1623 sal_Bool UnoFixedTextControl::isTransparent() throw(uno::RuntimeException) 1624 { 1625 return sal_True; 1626 } 1627 1628 void UnoFixedTextControl::setText( const ::rtl::OUString& Text ) throw(uno::RuntimeException) 1629 { 1630 uno::Any aAny; 1631 aAny <<= Text; 1632 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True ); 1633 } 1634 1635 ::rtl::OUString UnoFixedTextControl::getText() throw(uno::RuntimeException) 1636 { 1637 return ImplGetPropertyValue_UString( BASEPROPERTY_LABEL ); 1638 } 1639 1640 void UnoFixedTextControl::setAlignment( short nAlign ) throw(uno::RuntimeException) 1641 { 1642 uno::Any aAny; 1643 aAny <<= (sal_Int16)nAlign; 1644 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_ALIGN ), aAny, sal_True ); 1645 } 1646 1647 short UnoFixedTextControl::getAlignment() throw(uno::RuntimeException) 1648 { 1649 short nAlign = 0; 1650 if ( mxModel.is() ) 1651 { 1652 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_ALIGN ) ); 1653 aVal >>= nAlign; 1654 } 1655 return nAlign; 1656 } 1657 1658 awt::Size UnoFixedTextControl::getMinimumSize( ) throw(uno::RuntimeException) 1659 { 1660 return Impl_getMinimumSize(); 1661 } 1662 1663 awt::Size UnoFixedTextControl::getPreferredSize( ) throw(uno::RuntimeException) 1664 { 1665 return Impl_getPreferredSize(); 1666 } 1667 1668 awt::Size UnoFixedTextControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException) 1669 { 1670 return Impl_calcAdjustedSize( rNewSize ); 1671 } 1672 1673 // ---------------------------------------------------- 1674 // class UnoControlGroupBoxModel 1675 // ---------------------------------------------------- 1676 UnoControlGroupBoxModel::UnoControlGroupBoxModel( const Reference< XMultiServiceFactory >& i_factory ) 1677 :UnoControlModel( i_factory ) 1678 { 1679 ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL ); 1680 ImplRegisterProperty( BASEPROPERTY_ENABLED ); 1681 ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE ); 1682 ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR ); 1683 ImplRegisterProperty( BASEPROPERTY_HELPTEXT ); 1684 ImplRegisterProperty( BASEPROPERTY_HELPURL ); 1685 ImplRegisterProperty( BASEPROPERTY_LABEL ); 1686 ImplRegisterProperty( BASEPROPERTY_PRINTABLE ); 1687 ImplRegisterProperty( BASEPROPERTY_WRITING_MODE ); 1688 ImplRegisterProperty( BASEPROPERTY_CONTEXT_WRITING_MODE ); 1689 } 1690 1691 ::rtl::OUString UnoControlGroupBoxModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 1692 { 1693 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlGroupBoxModel ); 1694 } 1695 1696 uno::Any UnoControlGroupBoxModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 1697 { 1698 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL ) 1699 { 1700 uno::Any aAny; 1701 aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlGroupBox ); 1702 return aAny; 1703 } 1704 return UnoControlModel::ImplGetDefaultValue( nPropId ); 1705 } 1706 1707 ::cppu::IPropertyArrayHelper& UnoControlGroupBoxModel::getInfoHelper() 1708 { 1709 static UnoPropertyArrayHelper* pHelper = NULL; 1710 if ( !pHelper ) 1711 { 1712 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 1713 pHelper = new UnoPropertyArrayHelper( aIDs ); 1714 } 1715 return *pHelper; 1716 } 1717 1718 // beans::XMultiPropertySet 1719 uno::Reference< beans::XPropertySetInfo > UnoControlGroupBoxModel::getPropertySetInfo( ) throw(uno::RuntimeException) 1720 { 1721 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 1722 return xInfo; 1723 } 1724 1725 // ---------------------------------------------------- 1726 // class UnoGroupBoxControl 1727 // ---------------------------------------------------- 1728 UnoGroupBoxControl::UnoGroupBoxControl( const Reference< XMultiServiceFactory >& i_factory ) 1729 :UnoControlBase( i_factory ) 1730 { 1731 maComponentInfos.nWidth = 100; 1732 maComponentInfos.nHeight = 100; 1733 } 1734 1735 ::rtl::OUString UnoGroupBoxControl::GetComponentServiceName() 1736 { 1737 return ::rtl::OUString::createFromAscii( "groupbox" ); 1738 } 1739 1740 sal_Bool UnoGroupBoxControl::isTransparent() throw(uno::RuntimeException) 1741 { 1742 return sal_True; 1743 } 1744 1745 // ===================================================================================================================== 1746 // = UnoControlListBoxModel_Data 1747 // ===================================================================================================================== 1748 struct ListItem 1749 { 1750 ::rtl::OUString ItemText; 1751 ::rtl::OUString ItemImageURL; 1752 Any ItemData; 1753 1754 ListItem() 1755 :ItemText() 1756 ,ItemImageURL() 1757 ,ItemData() 1758 { 1759 } 1760 1761 ListItem( const ::rtl::OUString& i_rItemText ) 1762 :ItemText( i_rItemText ) 1763 ,ItemImageURL() 1764 ,ItemData() 1765 { 1766 } 1767 }; 1768 1769 typedef beans::Pair< ::rtl::OUString, ::rtl::OUString > UnoListItem; 1770 1771 struct StripItemData : public ::std::unary_function< ListItem, UnoListItem > 1772 { 1773 UnoListItem operator()( const ListItem& i_rItem ) 1774 { 1775 return UnoListItem( i_rItem.ItemText, i_rItem.ItemImageURL ); 1776 } 1777 }; 1778 1779 struct UnoControlListBoxModel_Data 1780 { 1781 UnoControlListBoxModel_Data( UnoControlListBoxModel& i_rAntiImpl ) 1782 :m_bSettingLegacyProperty( false ) 1783 ,m_rAntiImpl( i_rAntiImpl ) 1784 ,m_aListItems() 1785 { 1786 } 1787 1788 sal_Int32 getItemCount() const { return sal_Int32( m_aListItems.size() ); } 1789 1790 const ListItem& getItem( const sal_Int32 i_nIndex ) const 1791 { 1792 if ( ( i_nIndex < 0 ) || ( i_nIndex >= sal_Int32( m_aListItems.size() ) ) ) 1793 throw IndexOutOfBoundsException( ::rtl::OUString(), m_rAntiImpl ); 1794 return m_aListItems[ i_nIndex ]; 1795 } 1796 1797 ListItem& getItem( const sal_Int32 i_nIndex ) 1798 { 1799 return const_cast< ListItem& >( static_cast< const UnoControlListBoxModel_Data* >( this )->getItem( i_nIndex ) ); 1800 } 1801 1802 ListItem& insertItem( const sal_Int32 i_nIndex ) 1803 { 1804 if ( ( i_nIndex < 0 ) || ( i_nIndex > sal_Int32( m_aListItems.size() ) ) ) 1805 throw IndexOutOfBoundsException( ::rtl::OUString(), m_rAntiImpl ); 1806 return *m_aListItems.insert( m_aListItems.begin() + i_nIndex, ListItem() ); 1807 } 1808 1809 Sequence< UnoListItem > getAllItems() const 1810 { 1811 Sequence< UnoListItem > aItems( sal_Int32( m_aListItems.size() ) ); 1812 ::std::transform( m_aListItems.begin(), m_aListItems.end(), aItems.getArray(), StripItemData() ); 1813 return aItems; 1814 } 1815 1816 void copyItems( const UnoControlListBoxModel_Data& i_copySource ) 1817 { 1818 m_aListItems = i_copySource.m_aListItems; 1819 } 1820 1821 void setAllItems( const ::std::vector< ListItem >& i_rItems ) 1822 { 1823 m_aListItems = i_rItems; 1824 } 1825 1826 void removeItem( const sal_Int32 i_nIndex ) 1827 { 1828 if ( ( i_nIndex < 0 ) || ( i_nIndex >= sal_Int32( m_aListItems.size() ) ) ) 1829 throw IndexOutOfBoundsException( ::rtl::OUString(), m_rAntiImpl ); 1830 m_aListItems.erase( m_aListItems.begin() + i_nIndex ); 1831 } 1832 1833 void removeAllItems() 1834 { 1835 ::std::vector< ListItem > aEmpty; 1836 m_aListItems.swap( aEmpty ); 1837 } 1838 1839 public: 1840 bool m_bSettingLegacyProperty; 1841 1842 private: 1843 UnoControlListBoxModel& m_rAntiImpl; 1844 ::std::vector< ListItem > m_aListItems; 1845 }; 1846 1847 // ===================================================================================================================== 1848 // = UnoControlListBoxModel 1849 // ===================================================================================================================== 1850 // --------------------------------------------------------------------------------------------------------------------- 1851 UnoControlListBoxModel::UnoControlListBoxModel( const Reference< XMultiServiceFactory >& i_factory, ConstructorMode const i_mode ) 1852 :UnoControlListBoxModel_Base( i_factory ) 1853 ,m_pData( new UnoControlListBoxModel_Data( *this ) ) 1854 ,m_aItemListListeners( GetMutex() ) 1855 { 1856 if ( i_mode == ConstructDefault ) 1857 { 1858 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXListBox ); 1859 } 1860 } 1861 // --------------------------------------------------------------------------------------------------------------------- 1862 UnoControlListBoxModel::UnoControlListBoxModel( const UnoControlListBoxModel& i_rSource ) 1863 :UnoControlListBoxModel_Base( i_rSource ) 1864 ,m_pData( new UnoControlListBoxModel_Data( *this ) ) 1865 ,m_aItemListListeners( GetMutex() ) 1866 { 1867 m_pData->copyItems( *i_rSource.m_pData ); 1868 } 1869 UnoControlListBoxModel::~UnoControlListBoxModel() 1870 { 1871 } 1872 IMPL_SERVICEINFO_DERIVED( UnoControlListBoxModel, UnoControlModel, szServiceName2_UnoControlListBoxModel ) 1873 // --------------------------------------------------------------------------------------------------------------------- 1874 ::rtl::OUString UnoControlListBoxModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 1875 { 1876 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlListBoxModel ); 1877 } 1878 1879 // --------------------------------------------------------------------------------------------------------------------- 1880 uno::Any UnoControlListBoxModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 1881 { 1882 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL ) 1883 { 1884 uno::Any aAny; 1885 aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlListBox ); 1886 return aAny; 1887 } 1888 return UnoControlModel::ImplGetDefaultValue( nPropId ); 1889 } 1890 1891 // --------------------------------------------------------------------------------------------------------------------- 1892 ::cppu::IPropertyArrayHelper& UnoControlListBoxModel::getInfoHelper() 1893 { 1894 static UnoPropertyArrayHelper* pHelper = NULL; 1895 if ( !pHelper ) 1896 { 1897 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 1898 pHelper = new UnoPropertyArrayHelper( aIDs ); 1899 } 1900 return *pHelper; 1901 } 1902 1903 // --------------------------------------------------------------------------------------------------------------------- 1904 // beans::XMultiPropertySet 1905 uno::Reference< beans::XPropertySetInfo > UnoControlListBoxModel::getPropertySetInfo( ) throw(uno::RuntimeException) 1906 { 1907 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 1908 return xInfo; 1909 } 1910 1911 // --------------------------------------------------------------------------------------------------------------------- 1912 namespace 1913 { 1914 struct CreateListItem : public ::std::unary_function< ::rtl::OUString, ListItem > 1915 { 1916 ListItem operator()( const ::rtl::OUString& i_rItemText ) 1917 { 1918 return ListItem( i_rItemText ); 1919 } 1920 }; 1921 } 1922 1923 // --------------------------------------------------------------------------------------------------------------------- 1924 void SAL_CALL UnoControlListBoxModel::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const uno::Any& rValue ) throw (uno::Exception) 1925 { 1926 UnoControlModel::setFastPropertyValue_NoBroadcast( nHandle, rValue ); 1927 1928 if ( nHandle == BASEPROPERTY_STRINGITEMLIST ) 1929 { 1930 // reset selection 1931 uno::Sequence<sal_Int16> aSeq; 1932 uno::Any aAny; 1933 aAny <<= aSeq; 1934 setDependentFastPropertyValue( BASEPROPERTY_SELECTEDITEMS, aAny ); 1935 1936 if ( !m_pData->m_bSettingLegacyProperty ) 1937 { 1938 // synchronize the legacy StringItemList property with our list items 1939 Sequence< ::rtl::OUString > aStringItemList; 1940 Any aPropValue; 1941 getFastPropertyValue( aPropValue, BASEPROPERTY_STRINGITEMLIST ); 1942 OSL_VERIFY( aPropValue >>= aStringItemList ); 1943 1944 ::std::vector< ListItem > aItems( aStringItemList.getLength() ); 1945 ::std::transform( 1946 aStringItemList.getConstArray(), 1947 aStringItemList.getConstArray() + aStringItemList.getLength(), 1948 aItems.begin(), 1949 CreateListItem() 1950 ); 1951 m_pData->setAllItems( aItems ); 1952 1953 // since an XItemListListener does not have a "all items modified" or some such method, 1954 // we simulate this by notifying removal of all items, followed by insertion of all new 1955 // items 1956 lang::EventObject aEvent; 1957 aEvent.Source = *this; 1958 m_aItemListListeners.notifyEach( &XItemListListener::itemListChanged, aEvent ); 1959 // TODO: OPropertySetHelper calls into this method with the mutex locked ... 1960 // which is wrong for the above notifications ... 1961 } 1962 } 1963 } 1964 1965 // --------------------------------------------------------------------------------------------------------------------- 1966 void UnoControlListBoxModel::ImplNormalizePropertySequence( const sal_Int32 _nCount, sal_Int32* _pHandles, 1967 uno::Any* _pValues, sal_Int32* _pValidHandles ) const SAL_THROW(()) 1968 { 1969 // dependencies we know: 1970 // BASEPROPERTY_STRINGITEMLIST->BASEPROPERTY_SELECTEDITEMS 1971 ImplEnsureHandleOrder( _nCount, _pHandles, _pValues, BASEPROPERTY_STRINGITEMLIST, BASEPROPERTY_SELECTEDITEMS ); 1972 1973 UnoControlModel::ImplNormalizePropertySequence( _nCount, _pHandles, _pValues, _pValidHandles ); 1974 } 1975 1976 // --------------------------------------------------------------------------------------------------------------------- 1977 ::sal_Int32 SAL_CALL UnoControlListBoxModel::getItemCount() throw (RuntimeException) 1978 { 1979 ::osl::MutexGuard aGuard( GetMutex() ); 1980 return m_pData->getItemCount(); 1981 } 1982 1983 // --------------------------------------------------------------------------------------------------------------------- 1984 void SAL_CALL UnoControlListBoxModel::insertItem( ::sal_Int32 i_nPosition, const ::rtl::OUString& i_rItemText, const ::rtl::OUString& i_rItemImageURL ) throw (IndexOutOfBoundsException, RuntimeException) 1985 { 1986 ::osl::ClearableMutexGuard aGuard( GetMutex() ); 1987 // SYNCHRONIZED -----> 1988 ListItem& rItem( m_pData->insertItem( i_nPosition ) ); 1989 rItem.ItemText = i_rItemText; 1990 rItem.ItemImageURL = i_rItemImageURL; 1991 1992 impl_handleInsert( i_nPosition, i_rItemText, i_rItemImageURL, aGuard ); 1993 // <----- SYNCHRONIZED 1994 } 1995 1996 // --------------------------------------------------------------------------------------------------------------------- 1997 void SAL_CALL UnoControlListBoxModel::insertItemText( ::sal_Int32 i_nPosition, const ::rtl::OUString& i_rItemText ) throw (IndexOutOfBoundsException, RuntimeException) 1998 { 1999 ::osl::ClearableMutexGuard aGuard( GetMutex() ); 2000 // SYNCHRONIZED -----> 2001 ListItem& rItem( m_pData->insertItem( i_nPosition ) ); 2002 rItem.ItemText = i_rItemText; 2003 2004 impl_handleInsert( i_nPosition, i_rItemText, ::boost::optional< ::rtl::OUString >(), aGuard ); 2005 // <----- SYNCHRONIZED 2006 } 2007 2008 // --------------------------------------------------------------------------------------------------------------------- 2009 void SAL_CALL UnoControlListBoxModel::insertItemImage( ::sal_Int32 i_nPosition, const ::rtl::OUString& i_rItemImageURL ) throw (IndexOutOfBoundsException, RuntimeException) 2010 { 2011 ::osl::ClearableMutexGuard aGuard( GetMutex() ); 2012 // SYNCHRONIZED -----> 2013 ListItem& rItem( m_pData->insertItem( i_nPosition ) ); 2014 rItem.ItemImageURL = i_rItemImageURL; 2015 2016 impl_handleInsert( i_nPosition, ::boost::optional< ::rtl::OUString >(), i_rItemImageURL, aGuard ); 2017 // <----- SYNCHRONIZED 2018 } 2019 2020 // --------------------------------------------------------------------------------------------------------------------- 2021 void SAL_CALL UnoControlListBoxModel::removeItem( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException) 2022 { 2023 ::osl::ClearableMutexGuard aGuard( GetMutex() ); 2024 // SYNCHRONIZED -----> 2025 m_pData->removeItem( i_nPosition ); 2026 2027 impl_handleRemove( i_nPosition, aGuard ); 2028 // <----- SYNCHRONIZED 2029 } 2030 2031 // --------------------------------------------------------------------------------------------------------------------- 2032 void SAL_CALL UnoControlListBoxModel::removeAllItems( ) throw (::com::sun::star::uno::RuntimeException) 2033 { 2034 ::osl::ClearableMutexGuard aGuard( GetMutex() ); 2035 // SYNCHRONIZED -----> 2036 m_pData->removeAllItems(); 2037 2038 impl_handleRemove( -1, aGuard ); 2039 // <----- SYNCHRONIZED 2040 } 2041 2042 // --------------------------------------------------------------------------------------------------------------------- 2043 void SAL_CALL UnoControlListBoxModel::setItemText( ::sal_Int32 i_nPosition, const ::rtl::OUString& i_rItemText ) throw (IndexOutOfBoundsException, RuntimeException) 2044 { 2045 ::osl::ClearableMutexGuard aGuard( GetMutex() ); 2046 // SYNCHRONIZED -----> 2047 ListItem& rItem( m_pData->getItem( i_nPosition ) ); 2048 rItem.ItemText = i_rItemText; 2049 2050 impl_handleModify( i_nPosition, i_rItemText, ::boost::optional< ::rtl::OUString >(), aGuard ); 2051 // <----- SYNCHRONIZED 2052 } 2053 2054 // --------------------------------------------------------------------------------------------------------------------- 2055 void SAL_CALL UnoControlListBoxModel::setItemImage( ::sal_Int32 i_nPosition, const ::rtl::OUString& i_rItemImageURL ) throw (IndexOutOfBoundsException, RuntimeException) 2056 { 2057 ::osl::ClearableMutexGuard aGuard( GetMutex() ); 2058 // SYNCHRONIZED -----> 2059 ListItem& rItem( m_pData->getItem( i_nPosition ) ); 2060 rItem.ItemImageURL = i_rItemImageURL; 2061 2062 impl_handleModify( i_nPosition, ::boost::optional< ::rtl::OUString >(), i_rItemImageURL, aGuard ); 2063 // <----- SYNCHRONIZED 2064 } 2065 2066 // --------------------------------------------------------------------------------------------------------------------- 2067 void SAL_CALL UnoControlListBoxModel::setItemTextAndImage( ::sal_Int32 i_nPosition, const ::rtl::OUString& i_rItemText, const ::rtl::OUString& i_rItemImageURL ) throw (IndexOutOfBoundsException, RuntimeException) 2068 { 2069 ::osl::ClearableMutexGuard aGuard( GetMutex() ); 2070 // SYNCHRONIZED -----> 2071 ListItem& rItem( m_pData->getItem( i_nPosition ) ); 2072 rItem.ItemText = i_rItemText; 2073 rItem.ItemImageURL = i_rItemImageURL; 2074 2075 impl_handleModify( i_nPosition, i_rItemText, i_rItemImageURL, aGuard ); 2076 // <----- SYNCHRONIZED 2077 } 2078 2079 // --------------------------------------------------------------------------------------------------------------------- 2080 void SAL_CALL UnoControlListBoxModel::setItemData( ::sal_Int32 i_nPosition, const Any& i_rDataValue ) throw (IndexOutOfBoundsException, RuntimeException) 2081 { 2082 ::osl::ClearableMutexGuard aGuard( GetMutex() ); 2083 ListItem& rItem( m_pData->getItem( i_nPosition ) ); 2084 rItem.ItemData = i_rDataValue; 2085 } 2086 2087 // --------------------------------------------------------------------------------------------------------------------- 2088 ::rtl::OUString SAL_CALL UnoControlListBoxModel::getItemText( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException) 2089 { 2090 ::osl::MutexGuard aGuard( GetMutex() ); 2091 const ListItem& rItem( m_pData->getItem( i_nPosition ) ); 2092 return rItem.ItemText; 2093 } 2094 2095 // --------------------------------------------------------------------------------------------------------------------- 2096 ::rtl::OUString SAL_CALL UnoControlListBoxModel::getItemImage( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException) 2097 { 2098 ::osl::MutexGuard aGuard( GetMutex() ); 2099 const ListItem& rItem( m_pData->getItem( i_nPosition ) ); 2100 return rItem.ItemImageURL; 2101 } 2102 2103 // --------------------------------------------------------------------------------------------------------------------- 2104 beans::Pair< ::rtl::OUString, ::rtl::OUString > SAL_CALL UnoControlListBoxModel::getItemTextAndImage( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException) 2105 { 2106 ::osl::MutexGuard aGuard( GetMutex() ); 2107 const ListItem& rItem( m_pData->getItem( i_nPosition ) ); 2108 return beans::Pair< ::rtl::OUString, ::rtl::OUString >( rItem.ItemText, rItem.ItemImageURL ); 2109 } 2110 2111 // --------------------------------------------------------------------------------------------------------------------- 2112 Any SAL_CALL UnoControlListBoxModel::getItemData( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException) 2113 { 2114 ::osl::ClearableMutexGuard aGuard( GetMutex() ); 2115 const ListItem& rItem( m_pData->getItem( i_nPosition ) ); 2116 return rItem.ItemData; 2117 } 2118 2119 // --------------------------------------------------------------------------------------------------------------------- 2120 Sequence< beans::Pair< ::rtl::OUString, ::rtl::OUString > > SAL_CALL UnoControlListBoxModel::getAllItems( ) throw (RuntimeException) 2121 { 2122 ::osl::MutexGuard aGuard( GetMutex() ); 2123 return m_pData->getAllItems(); 2124 } 2125 2126 // --------------------------------------------------------------------------------------------------------------------- 2127 void SAL_CALL UnoControlListBoxModel::addItemListListener( const uno::Reference< awt::XItemListListener >& i_Listener ) throw (uno::RuntimeException) 2128 { 2129 if ( i_Listener.is() ) 2130 m_aItemListListeners.addInterface( i_Listener ); 2131 } 2132 2133 // --------------------------------------------------------------------------------------------------------------------- 2134 void SAL_CALL UnoControlListBoxModel::removeItemListListener( const uno::Reference< awt::XItemListListener >& i_Listener ) throw (uno::RuntimeException) 2135 { 2136 if ( i_Listener.is() ) 2137 m_aItemListListeners.removeInterface( i_Listener ); 2138 } 2139 2140 // --------------------------------------------------------------------------------------------------------------------- 2141 void UnoControlListBoxModel::impl_getStringItemList( ::std::vector< ::rtl::OUString >& o_rStringItems ) const 2142 { 2143 Sequence< ::rtl::OUString > aStringItemList; 2144 Any aPropValue; 2145 getFastPropertyValue( aPropValue, BASEPROPERTY_STRINGITEMLIST ); 2146 OSL_VERIFY( aPropValue >>= aStringItemList ); 2147 2148 o_rStringItems.resize( size_t( aStringItemList.getLength() ) ); 2149 ::std::copy( 2150 aStringItemList.getConstArray(), 2151 aStringItemList.getConstArray() + aStringItemList.getLength(), 2152 o_rStringItems.begin() 2153 ); 2154 } 2155 2156 // --------------------------------------------------------------------------------------------------------------------- 2157 void UnoControlListBoxModel::impl_setStringItemList_nolck( const ::std::vector< ::rtl::OUString >& i_rStringItems ) 2158 { 2159 Sequence< ::rtl::OUString > aStringItems( i_rStringItems.size() ); 2160 ::std::copy( 2161 i_rStringItems.begin(), 2162 i_rStringItems.end(), 2163 aStringItems.getArray() 2164 ); 2165 m_pData->m_bSettingLegacyProperty = true; 2166 try 2167 { 2168 setFastPropertyValue( BASEPROPERTY_STRINGITEMLIST, uno::makeAny( aStringItems ) ); 2169 } 2170 catch( const Exception& ) 2171 { 2172 m_pData->m_bSettingLegacyProperty = false; 2173 throw; 2174 } 2175 m_pData->m_bSettingLegacyProperty = false; 2176 } 2177 2178 // --------------------------------------------------------------------------------------------------------------------- 2179 void UnoControlListBoxModel::impl_handleInsert( const sal_Int32 i_nItemPosition, const ::boost::optional< ::rtl::OUString >& i_rItemText, 2180 const ::boost::optional< ::rtl::OUString >& i_rItemImageURL, ::osl::ClearableMutexGuard& i_rClearBeforeNotify ) 2181 { 2182 // SYNCHRONIZED -----> 2183 // sync with legacy StringItemList property 2184 ::std::vector< ::rtl::OUString > aStringItems; 2185 impl_getStringItemList( aStringItems ); 2186 OSL_ENSURE( size_t( i_nItemPosition ) <= aStringItems.size(), "UnoControlListBoxModel::impl_handleInsert" ); 2187 if ( size_t( i_nItemPosition ) <= aStringItems.size() ) 2188 { 2189 const ::rtl::OUString sItemText( !!i_rItemText ? *i_rItemText : ::rtl::OUString() ); 2190 aStringItems.insert( aStringItems.begin() + i_nItemPosition, sItemText ); 2191 } 2192 2193 i_rClearBeforeNotify.clear(); 2194 // <----- SYNCHRONIZED 2195 impl_setStringItemList_nolck( aStringItems ); 2196 2197 // notify ItemListListeners 2198 impl_notifyItemListEvent_nolck( i_nItemPosition, i_rItemText, i_rItemImageURL, &XItemListListener::listItemInserted ); 2199 } 2200 2201 // --------------------------------------------------------------------------------------------------------------------- 2202 void UnoControlListBoxModel::impl_handleRemove( const sal_Int32 i_nItemPosition, ::osl::ClearableMutexGuard& i_rClearBeforeNotify ) 2203 { 2204 // SYNCHRONIZED -----> 2205 const bool bAllItems = ( i_nItemPosition < 0 ); 2206 // sync with legacy StringItemList property 2207 ::std::vector< ::rtl::OUString > aStringItems; 2208 impl_getStringItemList( aStringItems ); 2209 if ( !bAllItems ) 2210 { 2211 OSL_ENSURE( size_t( i_nItemPosition ) < aStringItems.size(), "UnoControlListBoxModel::impl_handleRemove" ); 2212 if ( size_t( i_nItemPosition ) < aStringItems.size() ) 2213 { 2214 aStringItems.erase( aStringItems.begin() + i_nItemPosition ); 2215 } 2216 } 2217 else 2218 { 2219 aStringItems.resize(0); 2220 } 2221 2222 i_rClearBeforeNotify.clear(); 2223 // <----- SYNCHRONIZED 2224 impl_setStringItemList_nolck( aStringItems ); 2225 2226 // notify ItemListListeners 2227 if ( bAllItems ) 2228 { 2229 EventObject aEvent( *this ); 2230 m_aItemListListeners.notifyEach( &XItemListListener::allItemsRemoved, aEvent ); 2231 } 2232 else 2233 { 2234 impl_notifyItemListEvent_nolck( i_nItemPosition, ::boost::optional< ::rtl::OUString >(), ::boost::optional< ::rtl::OUString >(), 2235 &XItemListListener::listItemRemoved ); 2236 } 2237 } 2238 2239 // --------------------------------------------------------------------------------------------------------------------- 2240 void UnoControlListBoxModel::impl_handleModify( const sal_Int32 i_nItemPosition, const ::boost::optional< ::rtl::OUString >& i_rItemText, 2241 const ::boost::optional< ::rtl::OUString >& i_rItemImageURL, ::osl::ClearableMutexGuard& i_rClearBeforeNotify ) 2242 { 2243 // SYNCHRONIZED -----> 2244 if ( !!i_rItemText ) 2245 { 2246 // sync with legacy StringItemList property 2247 ::std::vector< ::rtl::OUString > aStringItems; 2248 impl_getStringItemList( aStringItems ); 2249 OSL_ENSURE( size_t( i_nItemPosition ) < aStringItems.size(), "UnoControlListBoxModel::impl_handleModify" ); 2250 if ( size_t( i_nItemPosition ) < aStringItems.size() ) 2251 { 2252 aStringItems[ i_nItemPosition] = *i_rItemText; 2253 } 2254 2255 i_rClearBeforeNotify.clear(); 2256 // <----- SYNCHRONIZED 2257 impl_setStringItemList_nolck( aStringItems ); 2258 } 2259 else 2260 { 2261 i_rClearBeforeNotify.clear(); 2262 // <----- SYNCHRONIZED 2263 } 2264 2265 // notify ItemListListeners 2266 impl_notifyItemListEvent_nolck( i_nItemPosition, i_rItemText, i_rItemImageURL, &XItemListListener::listItemModified ); 2267 } 2268 2269 // --------------------------------------------------------------------------------------------------------------------- 2270 void UnoControlListBoxModel::impl_notifyItemListEvent_nolck( const sal_Int32 i_nItemPosition, const ::boost::optional< ::rtl::OUString >& i_rItemText, 2271 const ::boost::optional< ::rtl::OUString >& i_rItemImageURL, 2272 void ( SAL_CALL XItemListListener::*NotificationMethod )( const ItemListEvent& ) ) 2273 { 2274 ItemListEvent aEvent; 2275 aEvent.Source = *this; 2276 aEvent.ItemPosition = i_nItemPosition; 2277 if ( !!i_rItemText ) 2278 { 2279 aEvent.ItemText.IsPresent = sal_True; 2280 aEvent.ItemText.Value = *i_rItemText; 2281 } 2282 if ( !!i_rItemImageURL ) 2283 { 2284 aEvent.ItemImageURL.IsPresent = sal_True; 2285 aEvent.ItemImageURL.Value = *i_rItemImageURL; 2286 } 2287 2288 m_aItemListListeners.notifyEach( NotificationMethod, aEvent ); 2289 } 2290 2291 // ---------------------------------------------------- 2292 // class UnoListBoxControl 2293 // ---------------------------------------------------- 2294 UnoListBoxControl::UnoListBoxControl( const Reference< XMultiServiceFactory >& i_factory ) 2295 :UnoListBoxControl_Base( i_factory ) 2296 ,maActionListeners( *this ) 2297 ,maItemListeners( *this ) 2298 { 2299 maComponentInfos.nWidth = 100; 2300 maComponentInfos.nHeight = 12; 2301 } 2302 2303 ::rtl::OUString UnoListBoxControl::GetComponentServiceName() 2304 { 2305 return ::rtl::OUString::createFromAscii( "listbox" ); 2306 } 2307 IMPL_SERVICEINFO_DERIVED( UnoListBoxControl, UnoControlBase, szServiceName2_UnoControlListBox ) 2308 2309 void UnoListBoxControl::dispose() throw(uno::RuntimeException) 2310 { 2311 lang::EventObject aEvt; 2312 aEvt.Source = (::cppu::OWeakObject*)this; 2313 maActionListeners.disposeAndClear( aEvt ); 2314 maItemListeners.disposeAndClear( aEvt ); 2315 UnoControl::dispose(); 2316 } 2317 2318 void UnoListBoxControl::ImplUpdateSelectedItemsProperty() 2319 { 2320 if ( getPeer().is() ) 2321 { 2322 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY ); 2323 DBG_ASSERT( xListBox.is(), "XListBox?" ); 2324 2325 uno::Sequence<sal_Int16> aSeq = xListBox->getSelectedItemsPos(); 2326 uno::Any aAny; 2327 aAny <<= aSeq; 2328 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_SELECTEDITEMS ), aAny, sal_False ); 2329 } 2330 } 2331 2332 void UnoListBoxControl::updateFromModel() 2333 { 2334 UnoControlBase::updateFromModel(); 2335 2336 Reference< XItemListListener > xItemListListener( getPeer(), UNO_QUERY ); 2337 ENSURE_OR_RETURN_VOID( xItemListListener.is(), "UnoListBoxControl::updateFromModel: a peer which is no ItemListListener?!" ); 2338 2339 EventObject aEvent( getModel() ); 2340 xItemListListener->itemListChanged( aEvent ); 2341 2342 // notify the change of the SelectedItems property, again. While our base class, in updateFromModel, 2343 // already did this, our peer(s) can only legitimately set the selection after they have the string 2344 // item list, which we just notified with the itemListChanged call. 2345 const ::rtl::OUString sSelectedItemsPropName( GetPropertyName( BASEPROPERTY_SELECTEDITEMS ) ); 2346 ImplSetPeerProperty( sSelectedItemsPropName, ImplGetPropertyValue( sSelectedItemsPropName ) ); 2347 } 2348 2349 void UnoListBoxControl::ImplSetPeerProperty( const ::rtl::OUString& rPropName, const uno::Any& rVal ) 2350 { 2351 if ( rPropName == GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) ) 2352 // do not forward this to our peer. We are a XItemListListener at our model, and changes in the string item 2353 // list (which is a legacy property) will, later, arrive as changes in the ItemList. Those latter changes 2354 // will be forwarded to the peer, which will update itself accordingly. 2355 return; 2356 2357 UnoControl::ImplSetPeerProperty( rPropName, rVal ); 2358 } 2359 2360 void UnoListBoxControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException) 2361 { 2362 UnoControl::createPeer( rxToolkit, rParentPeer ); 2363 2364 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY ); 2365 xListBox->addItemListener( this ); 2366 2367 if ( maActionListeners.getLength() ) 2368 xListBox->addActionListener( &maActionListeners ); 2369 } 2370 2371 void UnoListBoxControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException) 2372 { 2373 maActionListeners.addInterface( l ); 2374 if( getPeer().is() && maActionListeners.getLength() == 1 ) 2375 { 2376 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY ); 2377 xListBox->addActionListener( &maActionListeners ); 2378 } 2379 } 2380 2381 void UnoListBoxControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException) 2382 { 2383 if( getPeer().is() && maActionListeners.getLength() == 1 ) 2384 { 2385 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY ); 2386 xListBox->removeActionListener( &maActionListeners ); 2387 } 2388 maActionListeners.removeInterface( l ); 2389 } 2390 2391 void UnoListBoxControl::addItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException) 2392 { 2393 maItemListeners.addInterface( l ); 2394 } 2395 2396 void UnoListBoxControl::removeItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException) 2397 { 2398 maItemListeners.removeInterface( l ); 2399 } 2400 2401 void UnoListBoxControl::addItem( const ::rtl::OUString& aItem, sal_Int16 nPos ) throw(uno::RuntimeException) 2402 { 2403 uno::Sequence< ::rtl::OUString> aSeq( 1 ); 2404 aSeq.getArray()[0] = aItem; 2405 addItems( aSeq, nPos ); 2406 } 2407 2408 void UnoListBoxControl::addItems( const uno::Sequence< ::rtl::OUString>& aItems, sal_Int16 nPos ) throw(uno::RuntimeException) 2409 { 2410 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) ); 2411 uno::Sequence< ::rtl::OUString> aSeq; 2412 aVal >>= aSeq; 2413 sal_uInt16 nNewItems = (sal_uInt16)aItems.getLength(); 2414 sal_uInt16 nOldLen = (sal_uInt16)aSeq.getLength(); 2415 sal_uInt16 nNewLen = nOldLen + nNewItems; 2416 2417 uno::Sequence< ::rtl::OUString> aNewSeq( nNewLen ); 2418 ::rtl::OUString* pNewData = aNewSeq.getArray(); 2419 ::rtl::OUString* pOldData = aSeq.getArray(); 2420 2421 if ( ( nPos < 0 ) || ( nPos > nOldLen ) ) 2422 nPos = (sal_uInt16) nOldLen; 2423 2424 sal_uInt16 n; 2425 // Items vor der Einfuege-Position 2426 for ( n = 0; n < nPos; n++ ) 2427 pNewData[n] = pOldData[n]; 2428 2429 // Neue Items 2430 for ( n = 0; n < nNewItems; n++ ) 2431 pNewData[nPos+n] = aItems.getConstArray()[n]; 2432 2433 // Rest der alten Items 2434 for ( n = nPos; n < nOldLen; n++ ) 2435 pNewData[nNewItems+n] = pOldData[n]; 2436 2437 uno::Any aAny; 2438 aAny <<= aNewSeq; 2439 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ), aAny, sal_True ); 2440 } 2441 2442 void UnoListBoxControl::removeItems( sal_Int16 nPos, sal_Int16 nCount ) throw(uno::RuntimeException) 2443 { 2444 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) ); 2445 uno::Sequence< ::rtl::OUString> aSeq; 2446 aVal >>= aSeq; 2447 sal_uInt16 nOldLen = (sal_uInt16)aSeq.getLength(); 2448 if ( nOldLen && ( nPos < nOldLen ) ) 2449 { 2450 if ( nCount > ( nOldLen-nPos ) ) 2451 nCount = nOldLen-nPos; 2452 2453 sal_uInt16 nNewLen = nOldLen - nCount; 2454 2455 uno::Sequence< ::rtl::OUString> aNewSeq( nNewLen ); 2456 ::rtl::OUString* pNewData = aNewSeq.getArray(); 2457 ::rtl::OUString* pOldData = aSeq.getArray(); 2458 2459 sal_uInt16 n; 2460 // Items vor der Entfern-Position 2461 for ( n = 0; n < nPos; n++ ) 2462 pNewData[n] = pOldData[n]; 2463 2464 // Rest der Items 2465 for ( n = nPos; n < (nOldLen-nCount); n++ ) 2466 pNewData[n] = pOldData[n+nCount]; 2467 2468 uno::Any aAny; 2469 aAny <<= aNewSeq; 2470 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ), aAny, sal_True ); 2471 } 2472 } 2473 2474 sal_Int16 UnoListBoxControl::getItemCount() throw(uno::RuntimeException) 2475 { 2476 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) ); 2477 uno::Sequence< ::rtl::OUString> aSeq; 2478 aVal >>= aSeq; 2479 return (sal_Int16)aSeq.getLength(); 2480 } 2481 2482 ::rtl::OUString UnoListBoxControl::getItem( sal_Int16 nPos ) throw(uno::RuntimeException) 2483 { 2484 ::rtl::OUString aItem; 2485 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) ); 2486 uno::Sequence< ::rtl::OUString> aSeq; 2487 aVal >>= aSeq; 2488 if ( nPos < aSeq.getLength() ) 2489 aItem = aSeq.getConstArray()[nPos]; 2490 return aItem; 2491 } 2492 2493 uno::Sequence< ::rtl::OUString> UnoListBoxControl::getItems() throw(uno::RuntimeException) 2494 { 2495 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) ); 2496 uno::Sequence< ::rtl::OUString> aSeq; 2497 aVal >>= aSeq; 2498 return aSeq; 2499 } 2500 2501 sal_Int16 UnoListBoxControl::getSelectedItemPos() throw(uno::RuntimeException) 2502 { 2503 sal_Int16 n = -1; 2504 if ( getPeer().is() ) 2505 { 2506 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY ); 2507 n = xListBox->getSelectedItemPos(); 2508 } 2509 return n; 2510 } 2511 2512 uno::Sequence<sal_Int16> UnoListBoxControl::getSelectedItemsPos() throw(uno::RuntimeException) 2513 { 2514 uno::Sequence<sal_Int16> aSeq; 2515 if ( getPeer().is() ) 2516 { 2517 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY ); 2518 aSeq = xListBox->getSelectedItemsPos(); 2519 } 2520 return aSeq; 2521 } 2522 2523 ::rtl::OUString UnoListBoxControl::getSelectedItem() throw(uno::RuntimeException) 2524 { 2525 ::rtl::OUString aItem; 2526 if ( getPeer().is() ) 2527 { 2528 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY ); 2529 aItem = xListBox->getSelectedItem(); 2530 } 2531 return aItem; 2532 } 2533 2534 uno::Sequence< ::rtl::OUString> UnoListBoxControl::getSelectedItems() throw(uno::RuntimeException) 2535 { 2536 uno::Sequence< ::rtl::OUString> aSeq; 2537 if ( getPeer().is() ) 2538 { 2539 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY ); 2540 aSeq = xListBox->getSelectedItems(); 2541 } 2542 return aSeq; 2543 } 2544 2545 void UnoListBoxControl::selectItemPos( sal_Int16 nPos, sal_Bool bSelect ) throw(uno::RuntimeException) 2546 { 2547 if ( getPeer().is() ) 2548 { 2549 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY ); 2550 xListBox->selectItemPos( nPos, bSelect ); 2551 } 2552 ImplUpdateSelectedItemsProperty(); 2553 } 2554 2555 void UnoListBoxControl::selectItemsPos( const uno::Sequence<sal_Int16>& aPositions, sal_Bool bSelect ) throw(uno::RuntimeException) 2556 { 2557 if ( getPeer().is() ) 2558 { 2559 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY ); 2560 xListBox->selectItemsPos( aPositions, bSelect ); 2561 } 2562 ImplUpdateSelectedItemsProperty(); 2563 } 2564 2565 void UnoListBoxControl::selectItem( const ::rtl::OUString& aItem, sal_Bool bSelect ) throw(uno::RuntimeException) 2566 { 2567 if ( getPeer().is() ) 2568 { 2569 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY ); 2570 xListBox->selectItem( aItem, bSelect ); 2571 } 2572 ImplUpdateSelectedItemsProperty(); 2573 } 2574 2575 void UnoListBoxControl::makeVisible( sal_Int16 nEntry ) throw(uno::RuntimeException) 2576 { 2577 if ( getPeer().is() ) 2578 { 2579 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY ); 2580 xListBox->makeVisible( nEntry ); 2581 } 2582 } 2583 2584 void UnoListBoxControl::setDropDownLineCount( sal_Int16 nLines ) throw(uno::RuntimeException) 2585 { 2586 uno::Any aAny; 2587 aAny <<= (sal_Int16)nLines; 2588 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LINECOUNT ), aAny, sal_True ); 2589 } 2590 2591 sal_Int16 UnoListBoxControl::getDropDownLineCount() throw(uno::RuntimeException) 2592 { 2593 return ImplGetPropertyValue_INT16( BASEPROPERTY_LINECOUNT ); 2594 } 2595 2596 sal_Bool UnoListBoxControl::isMutipleMode() throw(uno::RuntimeException) 2597 { 2598 return ImplGetPropertyValue_BOOL( BASEPROPERTY_MULTISELECTION ); 2599 } 2600 2601 void UnoListBoxControl::setMultipleMode( sal_Bool bMulti ) throw(uno::RuntimeException) 2602 { 2603 uno::Any aAny; 2604 aAny <<= bMulti; 2605 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_MULTISELECTION ), aAny, sal_True ); 2606 } 2607 2608 void UnoListBoxControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw(uno::RuntimeException) 2609 { 2610 ImplUpdateSelectedItemsProperty(); 2611 if ( maItemListeners.getLength() ) 2612 { 2613 try 2614 { 2615 maItemListeners.itemStateChanged( rEvent ); 2616 } 2617 catch( const Exception& e ) 2618 { 2619 #if OSL_DEBUG_LEVEL == 0 2620 (void) e; // suppress warning 2621 #else 2622 ::rtl::OString sMessage( "UnoListBoxControl::itemStateChanged: caught an exception:\n" ); 2623 sMessage += ::rtl::OString( e.Message.getStr(), e.Message.getLength(), RTL_TEXTENCODING_ASCII_US ); 2624 OSL_ENSURE( sal_False, sMessage.getStr() ); 2625 #endif 2626 } 2627 } 2628 } 2629 2630 awt::Size UnoListBoxControl::getMinimumSize( ) throw(uno::RuntimeException) 2631 { 2632 return Impl_getMinimumSize(); 2633 } 2634 2635 awt::Size UnoListBoxControl::getPreferredSize( ) throw(uno::RuntimeException) 2636 { 2637 return Impl_getPreferredSize(); 2638 } 2639 2640 awt::Size UnoListBoxControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException) 2641 { 2642 return Impl_calcAdjustedSize( rNewSize ); 2643 } 2644 2645 awt::Size UnoListBoxControl::getMinimumSize( sal_Int16 nCols, sal_Int16 nLines ) throw(uno::RuntimeException) 2646 { 2647 return Impl_getMinimumSize( nCols, nLines ); 2648 } 2649 2650 void UnoListBoxControl::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(uno::RuntimeException) 2651 { 2652 Impl_getColumnsAndLines( nCols, nLines ); 2653 } 2654 2655 sal_Bool SAL_CALL UnoListBoxControl::setModel( const uno::Reference< awt::XControlModel >& i_rModel ) throw ( uno::RuntimeException ) 2656 { 2657 ::osl::MutexGuard aGuard( GetMutex() ); 2658 2659 const Reference< XItemList > xOldItems( getModel(), UNO_QUERY ); 2660 OSL_ENSURE( xOldItems.is() || !getModel().is(), "UnoListBoxControl::setModel: illegal old model!" ); 2661 const Reference< XItemList > xNewItems( i_rModel, UNO_QUERY ); 2662 OSL_ENSURE( xNewItems.is() || !i_rModel.is(), "UnoListBoxControl::setModel: illegal new model!" ); 2663 2664 if ( !UnoListBoxControl_Base::setModel( i_rModel ) ) 2665 return sal_False; 2666 2667 if ( xOldItems.is() ) 2668 xOldItems->removeItemListListener( this ); 2669 if ( xNewItems.is() ) 2670 xNewItems->addItemListListener( this ); 2671 2672 return sal_True; 2673 } 2674 2675 void SAL_CALL UnoListBoxControl::listItemInserted( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException) 2676 { 2677 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY ); 2678 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::listItemInserted: invalid peer!" ); 2679 if ( xPeerListener.is() ) 2680 xPeerListener->listItemInserted( i_rEvent ); 2681 } 2682 2683 void SAL_CALL UnoListBoxControl::listItemRemoved( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException) 2684 { 2685 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY ); 2686 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::listItemRemoved: invalid peer!" ); 2687 if ( xPeerListener.is() ) 2688 xPeerListener->listItemRemoved( i_rEvent ); 2689 } 2690 2691 void SAL_CALL UnoListBoxControl::listItemModified( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException) 2692 { 2693 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY ); 2694 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::listItemModified: invalid peer!" ); 2695 if ( xPeerListener.is() ) 2696 xPeerListener->listItemModified( i_rEvent ); 2697 } 2698 2699 void SAL_CALL UnoListBoxControl::allItemsRemoved( const lang::EventObject& i_rEvent ) throw (uno::RuntimeException) 2700 { 2701 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY ); 2702 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::allItemsRemoved: invalid peer!" ); 2703 if ( xPeerListener.is() ) 2704 xPeerListener->allItemsRemoved( i_rEvent ); 2705 } 2706 2707 void SAL_CALL UnoListBoxControl::itemListChanged( const lang::EventObject& i_rEvent ) throw (uno::RuntimeException) 2708 { 2709 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY ); 2710 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::itemListChanged: invalid peer!" ); 2711 if ( xPeerListener.is() ) 2712 xPeerListener->itemListChanged( i_rEvent ); 2713 } 2714 ActionListenerMultiplexer& UnoListBoxControl::getActionListeners() 2715 { 2716 return maActionListeners; 2717 } 2718 ItemListenerMultiplexer& UnoListBoxControl::getItemListeners() 2719 { 2720 return maItemListeners; 2721 } 2722 // ---------------------------------------------------- 2723 // class UnoControlComboBoxModel 2724 // ---------------------------------------------------- 2725 UnoControlComboBoxModel::UnoControlComboBoxModel( const Reference< XMultiServiceFactory >& i_factory ) 2726 :UnoControlListBoxModel( i_factory, ConstructWithoutProperties ) 2727 { 2728 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXComboBox ); 2729 } 2730 2731 IMPL_SERVICEINFO_DERIVED( UnoControlComboBoxModel, UnoControlModel, szServiceName2_UnoControlComboBoxModel ) 2732 2733 uno::Reference< beans::XPropertySetInfo > UnoControlComboBoxModel::getPropertySetInfo( ) throw(uno::RuntimeException) 2734 { 2735 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 2736 return xInfo; 2737 } 2738 // --------------------------------------------------------------------------------------------------------------------- 2739 ::cppu::IPropertyArrayHelper& UnoControlComboBoxModel::getInfoHelper() 2740 { 2741 static UnoPropertyArrayHelper* pHelper = NULL; 2742 if ( !pHelper ) 2743 { 2744 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 2745 pHelper = new UnoPropertyArrayHelper( aIDs ); 2746 } 2747 return *pHelper; 2748 } 2749 2750 2751 ::rtl::OUString UnoControlComboBoxModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 2752 { 2753 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlComboBoxModel ); 2754 } 2755 void SAL_CALL UnoControlComboBoxModel::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const uno::Any& rValue ) throw (uno::Exception) 2756 { 2757 UnoControlModel::setFastPropertyValue_NoBroadcast( nHandle, rValue ); 2758 2759 if ( nHandle == BASEPROPERTY_STRINGITEMLIST && !m_pData->m_bSettingLegacyProperty) 2760 { 2761 // synchronize the legacy StringItemList property with our list items 2762 Sequence< ::rtl::OUString > aStringItemList; 2763 Any aPropValue; 2764 getFastPropertyValue( aPropValue, BASEPROPERTY_STRINGITEMLIST ); 2765 OSL_VERIFY( aPropValue >>= aStringItemList ); 2766 2767 ::std::vector< ListItem > aItems( aStringItemList.getLength() ); 2768 ::std::transform( 2769 aStringItemList.getConstArray(), 2770 aStringItemList.getConstArray() + aStringItemList.getLength(), 2771 aItems.begin(), 2772 CreateListItem() 2773 ); 2774 m_pData->setAllItems( aItems ); 2775 2776 // since an XItemListListener does not have a "all items modified" or some such method, 2777 // we simulate this by notifying removal of all items, followed by insertion of all new 2778 // items 2779 lang::EventObject aEvent; 2780 aEvent.Source = *this; 2781 m_aItemListListeners.notifyEach( &XItemListListener::itemListChanged, aEvent ); 2782 // TODO: OPropertySetHelper calls into this method with the mutex locked ... 2783 // which is wrong for the above notifications ... 2784 } 2785 } 2786 2787 uno::Any UnoControlComboBoxModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 2788 { 2789 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL ) 2790 { 2791 uno::Any aAny; 2792 aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlComboBox ); 2793 return aAny; 2794 } 2795 return UnoControlModel::ImplGetDefaultValue( nPropId ); 2796 } 2797 2798 // ---------------------------------------------------- 2799 // class UnoComboBoxControl 2800 // ---------------------------------------------------- 2801 UnoComboBoxControl::UnoComboBoxControl( const Reference< XMultiServiceFactory >& i_factory ) 2802 :UnoEditControl( i_factory ) 2803 ,maActionListeners( *this ) 2804 ,maItemListeners( *this ) 2805 { 2806 maComponentInfos.nWidth = 100; 2807 maComponentInfos.nHeight = 12; 2808 } 2809 IMPL_SERVICEINFO_DERIVED( UnoComboBoxControl, UnoEditControl, szServiceName2_UnoControlComboBox ) 2810 2811 ::rtl::OUString UnoComboBoxControl::GetComponentServiceName() 2812 { 2813 return ::rtl::OUString::createFromAscii( "combobox" ); 2814 } 2815 2816 void UnoComboBoxControl::dispose() throw(uno::RuntimeException) 2817 { 2818 lang::EventObject aEvt; 2819 aEvt.Source = (::cppu::OWeakObject*)this; 2820 maActionListeners.disposeAndClear( aEvt ); 2821 maItemListeners.disposeAndClear( aEvt ); 2822 UnoControl::dispose(); 2823 } 2824 uno::Any UnoComboBoxControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException) 2825 { 2826 uno::Any aRet = ::cppu::queryInterface( rType, 2827 SAL_STATIC_CAST( awt::XComboBox*, this ) ); 2828 if ( !aRet.hasValue() ) 2829 { 2830 aRet = ::cppu::queryInterface( rType, 2831 SAL_STATIC_CAST( awt::XItemListener*, this ) ); 2832 if ( !aRet.hasValue() ) 2833 { 2834 aRet = ::cppu::queryInterface( rType, 2835 SAL_STATIC_CAST( awt::XItemListListener*, this ) ); 2836 } 2837 } 2838 return (aRet.hasValue() ? aRet : UnoEditControl::queryAggregation( rType )); 2839 } 2840 // lang::XTypeProvider 2841 IMPL_XTYPEPROVIDER_START( UnoComboBoxControl ) 2842 getCppuType( ( uno::Reference< awt::XComboBox>* ) NULL ), 2843 getCppuType( ( uno::Reference< awt::XItemListener>* ) NULL ), 2844 getCppuType( ( uno::Reference< awt::XItemListListener>* ) NULL ), 2845 UnoEditControl::getTypes() 2846 IMPL_XTYPEPROVIDER_END 2847 2848 void UnoComboBoxControl::updateFromModel() 2849 { 2850 UnoEditControl::updateFromModel(); 2851 2852 Reference< XItemListListener > xItemListListener( getPeer(), UNO_QUERY ); 2853 ENSURE_OR_RETURN_VOID( xItemListListener.is(), "UnoComboBoxControl::updateFromModel: a peer which is no ItemListListener?!" ); 2854 2855 EventObject aEvent( getModel() ); 2856 xItemListListener->itemListChanged( aEvent ); 2857 } 2858 void UnoComboBoxControl::ImplSetPeerProperty( const ::rtl::OUString& rPropName, const uno::Any& rVal ) 2859 { 2860 if ( rPropName == GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) ) 2861 // do not forward this to our peer. We are a XItemListListener at our model, and changes in the string item 2862 // list (which is a legacy property) will, later, arrive as changes in the ItemList. Those latter changes 2863 // will be forwarded to the peer, which will update itself accordingly. 2864 return; 2865 2866 UnoEditControl::ImplSetPeerProperty( rPropName, rVal ); 2867 } 2868 void UnoComboBoxControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException) 2869 { 2870 UnoEditControl::createPeer( rxToolkit, rParentPeer ); 2871 2872 uno::Reference < awt::XComboBox > xComboBox( getPeer(), uno::UNO_QUERY ); 2873 if ( maActionListeners.getLength() ) 2874 xComboBox->addActionListener( &maActionListeners ); 2875 if ( maItemListeners.getLength() ) 2876 xComboBox->addItemListener( &maItemListeners ); 2877 } 2878 2879 void UnoComboBoxControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException) 2880 { 2881 maActionListeners.addInterface( l ); 2882 if( getPeer().is() && maActionListeners.getLength() == 1 ) 2883 { 2884 uno::Reference < awt::XComboBox > xComboBox( getPeer(), uno::UNO_QUERY ); 2885 xComboBox->addActionListener( &maActionListeners ); 2886 } 2887 } 2888 2889 void UnoComboBoxControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException) 2890 { 2891 if( getPeer().is() && maActionListeners.getLength() == 1 ) 2892 { 2893 uno::Reference < awt::XComboBox > xComboBox( getPeer(), uno::UNO_QUERY ); 2894 xComboBox->removeActionListener( &maActionListeners ); 2895 } 2896 maActionListeners.removeInterface( l ); 2897 } 2898 2899 void UnoComboBoxControl::addItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException) 2900 { 2901 maItemListeners.addInterface( l ); 2902 if( getPeer().is() && maItemListeners.getLength() == 1 ) 2903 { 2904 uno::Reference < awt::XComboBox > xComboBox( getPeer(), uno::UNO_QUERY ); 2905 xComboBox->addItemListener( &maItemListeners ); 2906 } 2907 } 2908 2909 void UnoComboBoxControl::removeItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException) 2910 { 2911 if( getPeer().is() && maItemListeners.getLength() == 1 ) 2912 { 2913 uno::Reference < awt::XComboBox > xComboBox( getPeer(), uno::UNO_QUERY ); // MT: Mal alles so umstellen, schoener als Ref anlegen und query rufen 2914 xComboBox->removeItemListener( &maItemListeners ); 2915 } 2916 maItemListeners.removeInterface( l ); 2917 } 2918 void UnoComboBoxControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw(uno::RuntimeException) 2919 { 2920 if ( maItemListeners.getLength() ) 2921 { 2922 try 2923 { 2924 maItemListeners.itemStateChanged( rEvent ); 2925 } 2926 catch( const Exception& e ) 2927 { 2928 #if OSL_DEBUG_LEVEL == 0 2929 (void) e; // suppress warning 2930 #else 2931 ::rtl::OString sMessage( "UnoComboBoxControl::itemStateChanged: caught an exception:\n" ); 2932 sMessage += ::rtl::OString( e.Message.getStr(), e.Message.getLength(), RTL_TEXTENCODING_ASCII_US ); 2933 OSL_ENSURE( sal_False, sMessage.getStr() ); 2934 #endif 2935 } 2936 } 2937 } 2938 sal_Bool SAL_CALL UnoComboBoxControl::setModel( const uno::Reference< awt::XControlModel >& i_rModel ) throw ( uno::RuntimeException ) 2939 { 2940 ::osl::MutexGuard aGuard( GetMutex() ); 2941 2942 const Reference< XItemList > xOldItems( getModel(), UNO_QUERY ); 2943 OSL_ENSURE( xOldItems.is() || !getModel().is(), "UnoComboBoxControl::setModel: illegal old model!" ); 2944 const Reference< XItemList > xNewItems( i_rModel, UNO_QUERY ); 2945 OSL_ENSURE( xNewItems.is() || !i_rModel.is(), "UnoComboBoxControl::setModel: illegal new model!" ); 2946 2947 if ( !UnoEditControl::setModel( i_rModel ) ) 2948 return sal_False; 2949 2950 if ( xOldItems.is() ) 2951 xOldItems->removeItemListListener( this ); 2952 if ( xNewItems.is() ) 2953 xNewItems->addItemListListener( this ); 2954 2955 return sal_True; 2956 } 2957 2958 void SAL_CALL UnoComboBoxControl::listItemInserted( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException) 2959 { 2960 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY ); 2961 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::listItemInserted: invalid peer!" ); 2962 if ( xPeerListener.is() ) 2963 xPeerListener->listItemInserted( i_rEvent ); 2964 } 2965 2966 void SAL_CALL UnoComboBoxControl::listItemRemoved( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException) 2967 { 2968 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY ); 2969 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::listItemRemoved: invalid peer!" ); 2970 if ( xPeerListener.is() ) 2971 xPeerListener->listItemRemoved( i_rEvent ); 2972 } 2973 2974 void SAL_CALL UnoComboBoxControl::listItemModified( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException) 2975 { 2976 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY ); 2977 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::listItemModified: invalid peer!" ); 2978 if ( xPeerListener.is() ) 2979 xPeerListener->listItemModified( i_rEvent ); 2980 } 2981 2982 void SAL_CALL UnoComboBoxControl::allItemsRemoved( const lang::EventObject& i_rEvent ) throw (uno::RuntimeException) 2983 { 2984 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY ); 2985 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::allItemsRemoved: invalid peer!" ); 2986 if ( xPeerListener.is() ) 2987 xPeerListener->allItemsRemoved( i_rEvent ); 2988 } 2989 2990 void SAL_CALL UnoComboBoxControl::itemListChanged( const lang::EventObject& i_rEvent ) throw (uno::RuntimeException) 2991 { 2992 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY ); 2993 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::itemListChanged: invalid peer!" ); 2994 if ( xPeerListener.is() ) 2995 xPeerListener->itemListChanged( i_rEvent ); 2996 } 2997 ActionListenerMultiplexer& UnoComboBoxControl::getActionListeners() 2998 { 2999 return maActionListeners; 3000 } 3001 ItemListenerMultiplexer& UnoComboBoxControl::getItemListeners() 3002 { 3003 return maItemListeners; 3004 } 3005 3006 void UnoComboBoxControl::addItem( const ::rtl::OUString& aItem, sal_Int16 nPos ) throw(uno::RuntimeException) 3007 { 3008 uno::Sequence< ::rtl::OUString> aSeq( 1 ); 3009 aSeq.getArray()[0] = aItem; 3010 addItems( aSeq, nPos ); 3011 } 3012 3013 void UnoComboBoxControl::addItems( const uno::Sequence< ::rtl::OUString>& aItems, sal_Int16 nPos ) throw(uno::RuntimeException) 3014 { 3015 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) ); 3016 uno::Sequence< ::rtl::OUString> aSeq; 3017 aVal >>= aSeq; 3018 sal_uInt16 nNewItems = (sal_uInt16)aItems.getLength(); 3019 sal_uInt16 nOldLen = (sal_uInt16)aSeq.getLength(); 3020 sal_uInt16 nNewLen = nOldLen + nNewItems; 3021 3022 uno::Sequence< ::rtl::OUString> aNewSeq( nNewLen ); 3023 ::rtl::OUString* pNewData = aNewSeq.getArray(); 3024 const ::rtl::OUString* pOldData = aSeq.getConstArray(); 3025 3026 if ( ( nPos < 0 ) || ( nPos > nOldLen ) ) 3027 nPos = (sal_uInt16) nOldLen; 3028 3029 sal_uInt16 n; 3030 // Items vor der Einfuege-Position 3031 for ( n = 0; n < nPos; n++ ) 3032 pNewData[n] = pOldData[n]; 3033 3034 // Neue Items 3035 for ( n = 0; n < nNewItems; n++ ) 3036 pNewData[nPos+n] = aItems.getConstArray()[n]; 3037 3038 // Rest der alten Items 3039 for ( n = nPos; n < nOldLen; n++ ) 3040 pNewData[nNewItems+n] = pOldData[n]; 3041 3042 uno::Any aAny; 3043 aAny <<= aNewSeq; 3044 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ), aAny, sal_True ); 3045 } 3046 3047 void UnoComboBoxControl::removeItems( sal_Int16 nPos, sal_Int16 nCount ) throw(uno::RuntimeException) 3048 { 3049 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) ); 3050 uno::Sequence< ::rtl::OUString> aSeq; 3051 aVal >>= aSeq; 3052 sal_uInt16 nOldLen = (sal_uInt16)aSeq.getLength(); 3053 if ( nOldLen && ( nPos < nOldLen ) ) 3054 { 3055 if ( nCount > ( nOldLen-nPos ) ) 3056 nCount = nOldLen-nPos; 3057 3058 sal_uInt16 nNewLen = nOldLen - nCount; 3059 3060 uno::Sequence< ::rtl::OUString> aNewSeq( nNewLen ); 3061 ::rtl::OUString* pNewData = aNewSeq.getArray(); 3062 ::rtl::OUString* pOldData = aSeq.getArray(); 3063 3064 sal_uInt16 n; 3065 // Items vor der Entfern-Position 3066 for ( n = 0; n < nPos; n++ ) 3067 pNewData[n] = pOldData[n]; 3068 3069 // Rest der Items 3070 for ( n = nPos; n < (nOldLen-nCount); n++ ) 3071 pNewData[n] = pOldData[n+nCount]; 3072 3073 uno::Any aAny; 3074 aAny <<= aNewSeq; 3075 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ), aAny, sal_True ); 3076 } 3077 } 3078 3079 sal_Int16 UnoComboBoxControl::getItemCount() throw(uno::RuntimeException) 3080 { 3081 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) ); 3082 uno::Sequence< ::rtl::OUString> aSeq; 3083 aVal >>= aSeq; 3084 return (sal_Int16)aSeq.getLength(); 3085 } 3086 3087 ::rtl::OUString UnoComboBoxControl::getItem( sal_Int16 nPos ) throw(uno::RuntimeException) 3088 { 3089 ::rtl::OUString aItem; 3090 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) ); 3091 uno::Sequence< ::rtl::OUString> aSeq; 3092 aVal >>= aSeq; 3093 if ( nPos < aSeq.getLength() ) 3094 aItem = aSeq.getConstArray()[nPos]; 3095 return aItem; 3096 } 3097 3098 uno::Sequence< ::rtl::OUString> UnoComboBoxControl::getItems() throw(uno::RuntimeException) 3099 { 3100 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) ); 3101 uno::Sequence< ::rtl::OUString> aSeq; 3102 aVal >>= aSeq; 3103 return aSeq; 3104 } 3105 3106 void UnoComboBoxControl::setDropDownLineCount( sal_Int16 nLines ) throw(uno::RuntimeException) 3107 { 3108 uno::Any aAny; 3109 aAny <<= nLines; 3110 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LINECOUNT ), aAny, sal_True ); 3111 } 3112 3113 sal_Int16 UnoComboBoxControl::getDropDownLineCount() throw(uno::RuntimeException) 3114 { 3115 return ImplGetPropertyValue_INT16( BASEPROPERTY_LINECOUNT ); 3116 } 3117 3118 3119 // ---------------------------------------------------- 3120 // UnoSpinFieldControl 3121 // ---------------------------------------------------- 3122 UnoSpinFieldControl::UnoSpinFieldControl( const Reference< XMultiServiceFactory >& i_factory ) 3123 :UnoEditControl( i_factory ) 3124 ,maSpinListeners( *this ) 3125 { 3126 mbRepeat = sal_False; 3127 } 3128 3129 // uno::XInterface 3130 uno::Any UnoSpinFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException) 3131 { 3132 uno::Any aRet = ::cppu::queryInterface( rType, 3133 SAL_STATIC_CAST( awt::XSpinField*, this ) ); 3134 return (aRet.hasValue() ? aRet : UnoEditControl::queryAggregation( rType )); 3135 } 3136 3137 // lang::XTypeProvider 3138 IMPL_XTYPEPROVIDER_START( UnoSpinFieldControl ) 3139 getCppuType( ( uno::Reference< awt::XSpinField>* ) NULL ), 3140 UnoEditControl::getTypes() 3141 IMPL_XTYPEPROVIDER_END 3142 3143 void UnoSpinFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException) 3144 { 3145 UnoEditControl::createPeer( rxToolkit, rParentPeer ); 3146 3147 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY ); 3148 xField->enableRepeat( mbRepeat ); 3149 if ( maSpinListeners.getLength() ) 3150 xField->addSpinListener( &maSpinListeners ); 3151 } 3152 3153 // ::com::sun::star::awt::XSpinField 3154 void UnoSpinFieldControl::addSpinListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XSpinListener >& l ) throw(::com::sun::star::uno::RuntimeException) 3155 { 3156 maSpinListeners.addInterface( l ); 3157 if( getPeer().is() && maSpinListeners.getLength() == 1 ) 3158 { 3159 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY ); 3160 xField->addSpinListener( &maSpinListeners ); 3161 } 3162 } 3163 3164 void UnoSpinFieldControl::removeSpinListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XSpinListener >& l ) throw(::com::sun::star::uno::RuntimeException) 3165 { 3166 if( getPeer().is() && maSpinListeners.getLength() == 1 ) 3167 { 3168 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY ); 3169 xField->removeSpinListener( &maSpinListeners ); 3170 } 3171 maSpinListeners.removeInterface( l ); 3172 } 3173 3174 void UnoSpinFieldControl::up() throw(::com::sun::star::uno::RuntimeException) 3175 { 3176 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY ); 3177 if ( xField.is() ) 3178 xField->up(); 3179 } 3180 3181 void UnoSpinFieldControl::down() throw(::com::sun::star::uno::RuntimeException) 3182 { 3183 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY ); 3184 if ( xField.is() ) 3185 xField->down(); 3186 } 3187 3188 void UnoSpinFieldControl::first() throw(::com::sun::star::uno::RuntimeException) 3189 { 3190 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY ); 3191 if ( xField.is() ) 3192 xField->first(); 3193 } 3194 3195 void UnoSpinFieldControl::last() throw(::com::sun::star::uno::RuntimeException) 3196 { 3197 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY ); 3198 if ( xField.is() ) 3199 xField->last(); 3200 } 3201 3202 void UnoSpinFieldControl::enableRepeat( sal_Bool bRepeat ) throw(::com::sun::star::uno::RuntimeException) 3203 { 3204 mbRepeat = bRepeat; 3205 3206 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY ); 3207 if ( xField.is() ) 3208 xField->enableRepeat( bRepeat ); 3209 } 3210 3211 // ---------------------------------------------------- 3212 // class UnoControlDateFieldModel 3213 // ---------------------------------------------------- 3214 UnoControlDateFieldModel::UnoControlDateFieldModel( const Reference< XMultiServiceFactory >& i_factory ) 3215 :UnoControlModel( i_factory ) 3216 { 3217 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXDateField ); 3218 } 3219 3220 ::rtl::OUString UnoControlDateFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 3221 { 3222 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlDateFieldModel ); 3223 } 3224 3225 uno::Any UnoControlDateFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 3226 { 3227 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL ) 3228 { 3229 uno::Any aAny; 3230 aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlDateField ); 3231 return aAny; 3232 } 3233 return UnoControlModel::ImplGetDefaultValue( nPropId ); 3234 } 3235 3236 3237 ::cppu::IPropertyArrayHelper& UnoControlDateFieldModel::getInfoHelper() 3238 { 3239 static UnoPropertyArrayHelper* pHelper = NULL; 3240 if ( !pHelper ) 3241 { 3242 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 3243 pHelper = new UnoPropertyArrayHelper( aIDs ); 3244 } 3245 return *pHelper; 3246 } 3247 3248 // beans::XMultiPropertySet 3249 uno::Reference< beans::XPropertySetInfo > UnoControlDateFieldModel::getPropertySetInfo( ) throw(uno::RuntimeException) 3250 { 3251 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 3252 return xInfo; 3253 } 3254 3255 3256 3257 // ---------------------------------------------------- 3258 // class UnoDateFieldControl 3259 // ---------------------------------------------------- 3260 UnoDateFieldControl::UnoDateFieldControl( const Reference< XMultiServiceFactory >& i_factory ) 3261 :UnoSpinFieldControl( i_factory ) 3262 { 3263 mnFirst = Date( 1, 1, 1900 ).GetDate(); 3264 mnLast = Date( 31, 12, 2200 ).GetDate(); 3265 mbLongFormat = 2; 3266 } 3267 3268 ::rtl::OUString UnoDateFieldControl::GetComponentServiceName() 3269 { 3270 return ::rtl::OUString::createFromAscii( "datefield" ); 3271 } 3272 3273 // uno::XInterface 3274 uno::Any UnoDateFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException) 3275 { 3276 uno::Any aRet = ::cppu::queryInterface( rType, 3277 SAL_STATIC_CAST( awt::XDateField*, this ) ); 3278 return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType )); 3279 } 3280 3281 // lang::XTypeProvider 3282 IMPL_XTYPEPROVIDER_START( UnoDateFieldControl ) 3283 getCppuType( ( uno::Reference< awt::XDateField>* ) NULL ), 3284 UnoSpinFieldControl::getTypes() 3285 IMPL_XTYPEPROVIDER_END 3286 3287 void UnoDateFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException) 3288 { 3289 UnoSpinFieldControl::createPeer( rxToolkit, rParentPeer ); 3290 3291 uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY ); 3292 xField->setFirst( mnFirst ); 3293 xField->setLast( mnLast ); 3294 if ( mbLongFormat != 2 ) // not set 3295 xField->setLongFormat( mbLongFormat ); 3296 } 3297 3298 3299 void UnoDateFieldControl::textChanged( const awt::TextEvent& e ) throw(uno::RuntimeException) 3300 { 3301 uno::Reference< awt::XVclWindowPeer > xPeer( getPeer(), uno::UNO_QUERY ); 3302 3303 // also change the text property (#i25106#) 3304 if ( xPeer.is() ) 3305 { 3306 ::rtl::OUString sTextPropertyName = GetPropertyName( BASEPROPERTY_TEXT ); 3307 ImplSetPropertyValue( sTextPropertyName, xPeer->getProperty( sTextPropertyName ), sal_False ); 3308 } 3309 3310 // re-calc the Date property 3311 uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY ); 3312 uno::Any aValue; 3313 if ( xField->isEmpty() ) 3314 { 3315 // the field says it's empty 3316 sal_Bool bEnforceFormat = sal_True; 3317 if ( xPeer.is() ) 3318 xPeer->getProperty( GetPropertyName( BASEPROPERTY_ENFORCE_FORMAT ) ) >>= bEnforceFormat; 3319 if ( !bEnforceFormat ) 3320 { 3321 // and it also says that it is currently accepting invalid inputs, without 3322 // forcing it to a valid date 3323 uno::Reference< awt::XTextComponent > xText( xPeer, uno::UNO_QUERY ); 3324 if ( xText.is() && xText->getText().getLength() ) 3325 // and in real, the text of the peer is *not* empty 3326 // -> simulate an invalid date, which is different from "no date" 3327 aValue <<= util::Date( 0, 0, 0 ); 3328 } 3329 } 3330 else 3331 aValue <<= xField->getDate(); 3332 3333 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DATE ), aValue, sal_False ); 3334 3335 // multiplex the event 3336 if ( GetTextListeners().getLength() ) 3337 GetTextListeners().textChanged( e ); 3338 } 3339 3340 void UnoDateFieldControl::setDate( sal_Int32 Date ) throw(uno::RuntimeException) 3341 { 3342 uno::Any aAny; 3343 aAny <<= Date; 3344 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DATE ), aAny, sal_True ); 3345 } 3346 3347 sal_Int32 UnoDateFieldControl::getDate() throw(uno::RuntimeException) 3348 { 3349 return ImplGetPropertyValue_INT32( BASEPROPERTY_DATE ); 3350 } 3351 3352 void UnoDateFieldControl::setMin( sal_Int32 Date ) throw(uno::RuntimeException) 3353 { 3354 uno::Any aAny; 3355 aAny <<= Date; 3356 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DATEMIN ), aAny, sal_True ); 3357 } 3358 3359 sal_Int32 UnoDateFieldControl::getMin() throw(uno::RuntimeException) 3360 { 3361 return ImplGetPropertyValue_INT32( BASEPROPERTY_DATEMIN ); 3362 } 3363 3364 void UnoDateFieldControl::setMax( sal_Int32 Date ) throw(uno::RuntimeException) 3365 { 3366 uno::Any aAny; 3367 aAny <<= Date; 3368 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DATEMAX ), aAny, sal_True ); 3369 } 3370 3371 sal_Int32 UnoDateFieldControl::getMax() throw(uno::RuntimeException) 3372 { 3373 return ImplGetPropertyValue_INT32( BASEPROPERTY_DATEMAX ); 3374 } 3375 3376 void UnoDateFieldControl::setFirst( sal_Int32 Date ) throw(uno::RuntimeException) 3377 { 3378 mnFirst = Date; 3379 if ( getPeer().is() ) 3380 { 3381 uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY ); 3382 xField->setFirst( Date ); 3383 } 3384 } 3385 3386 sal_Int32 UnoDateFieldControl::getFirst() throw(uno::RuntimeException) 3387 { 3388 return mnFirst; 3389 } 3390 3391 void UnoDateFieldControl::setLast( sal_Int32 Date ) throw(uno::RuntimeException) 3392 { 3393 mnLast = Date; 3394 if ( getPeer().is() ) 3395 { 3396 uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY ); 3397 xField->setLast( Date ); 3398 } 3399 } 3400 3401 sal_Int32 UnoDateFieldControl::getLast() throw(uno::RuntimeException) 3402 { 3403 return mnLast; 3404 } 3405 3406 void UnoDateFieldControl::setLongFormat( sal_Bool bLong ) throw(uno::RuntimeException) 3407 { 3408 mbLongFormat = bLong; 3409 if ( getPeer().is() ) 3410 { 3411 uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY ); 3412 xField->setLongFormat( bLong ); 3413 } 3414 } 3415 3416 sal_Bool UnoDateFieldControl::isLongFormat() throw(uno::RuntimeException) 3417 { 3418 return ( mbLongFormat != 2 ) ? mbLongFormat : sal_False; 3419 } 3420 3421 void UnoDateFieldControl::setEmpty() throw(uno::RuntimeException) 3422 { 3423 if ( getPeer().is() ) 3424 { 3425 uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY ); 3426 xField->setEmpty(); 3427 } 3428 } 3429 3430 sal_Bool UnoDateFieldControl::isEmpty() throw(uno::RuntimeException) 3431 { 3432 sal_Bool bEmpty = sal_False; 3433 if ( getPeer().is() ) 3434 { 3435 uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY ); 3436 bEmpty = xField->isEmpty(); 3437 } 3438 return bEmpty; 3439 } 3440 3441 void UnoDateFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException) 3442 { 3443 uno::Any aAny; 3444 aAny <<= bStrict; 3445 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True ); 3446 } 3447 3448 sal_Bool UnoDateFieldControl::isStrictFormat() throw(uno::RuntimeException) 3449 { 3450 return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT ); 3451 } 3452 3453 // ---------------------------------------------------- 3454 // class UnoControlTimeFieldModel 3455 // ---------------------------------------------------- 3456 UnoControlTimeFieldModel::UnoControlTimeFieldModel( const Reference< XMultiServiceFactory >& i_factory ) 3457 :UnoControlModel( i_factory ) 3458 { 3459 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXTimeField ); 3460 } 3461 3462 ::rtl::OUString UnoControlTimeFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 3463 { 3464 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlTimeFieldModel ); 3465 } 3466 3467 uno::Any UnoControlTimeFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 3468 { 3469 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL ) 3470 { 3471 uno::Any aAny; 3472 aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlTimeField ); 3473 return aAny; 3474 } 3475 return UnoControlModel::ImplGetDefaultValue( nPropId ); 3476 } 3477 3478 3479 ::cppu::IPropertyArrayHelper& UnoControlTimeFieldModel::getInfoHelper() 3480 { 3481 static UnoPropertyArrayHelper* pHelper = NULL; 3482 if ( !pHelper ) 3483 { 3484 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 3485 pHelper = new UnoPropertyArrayHelper( aIDs ); 3486 } 3487 return *pHelper; 3488 } 3489 3490 // beans::XMultiPropertySet 3491 uno::Reference< beans::XPropertySetInfo > UnoControlTimeFieldModel::getPropertySetInfo( ) throw(uno::RuntimeException) 3492 { 3493 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 3494 return xInfo; 3495 } 3496 3497 3498 3499 // ---------------------------------------------------- 3500 // class UnoTimeFieldControl 3501 // ---------------------------------------------------- 3502 UnoTimeFieldControl::UnoTimeFieldControl( const Reference< XMultiServiceFactory >& i_factory ) 3503 :UnoSpinFieldControl( i_factory ) 3504 { 3505 mnFirst = Time( 0, 0 ).GetTime(); 3506 mnLast = Time( 23, 59, 59, 99 ).GetTime(); 3507 } 3508 3509 ::rtl::OUString UnoTimeFieldControl::GetComponentServiceName() 3510 { 3511 return ::rtl::OUString::createFromAscii( "timefield" ); 3512 } 3513 3514 // uno::XInterface 3515 uno::Any UnoTimeFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException) 3516 { 3517 uno::Any aRet = ::cppu::queryInterface( rType, 3518 SAL_STATIC_CAST( awt::XTimeField*, this ) ); 3519 return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType )); 3520 } 3521 3522 // lang::XTypeProvider 3523 IMPL_XTYPEPROVIDER_START( UnoTimeFieldControl ) 3524 getCppuType( ( uno::Reference< awt::XTimeField>* ) NULL ), 3525 UnoSpinFieldControl::getTypes() 3526 IMPL_XTYPEPROVIDER_END 3527 3528 void UnoTimeFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException) 3529 { 3530 UnoSpinFieldControl::createPeer( rxToolkit, rParentPeer ); 3531 3532 uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY ); 3533 xField->setFirst( mnFirst ); 3534 xField->setLast( mnLast ); 3535 } 3536 3537 void UnoTimeFieldControl::textChanged( const awt::TextEvent& e ) throw(uno::RuntimeException) 3538 { 3539 // also change the text property (#i25106#) 3540 uno::Reference< awt::XVclWindowPeer > xPeer( getPeer(), uno::UNO_QUERY ); 3541 ::rtl::OUString sTextPropertyName = GetPropertyName( BASEPROPERTY_TEXT ); 3542 ImplSetPropertyValue( sTextPropertyName, xPeer->getProperty( sTextPropertyName ), sal_False ); 3543 3544 // re-calc the Time property 3545 uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY ); 3546 uno::Any aValue; 3547 if ( !xField->isEmpty() ) 3548 aValue <<= xField->getTime(); 3549 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TIME ), aValue, sal_False ); 3550 3551 // multiplex the event 3552 if ( GetTextListeners().getLength() ) 3553 GetTextListeners().textChanged( e ); 3554 } 3555 3556 void UnoTimeFieldControl::setTime( sal_Int32 Time ) throw(uno::RuntimeException) 3557 { 3558 uno::Any aAny; 3559 aAny <<= Time; 3560 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TIME ), aAny, sal_True ); 3561 } 3562 3563 sal_Int32 UnoTimeFieldControl::getTime() throw(uno::RuntimeException) 3564 { 3565 return ImplGetPropertyValue_INT32( BASEPROPERTY_TIME ); 3566 } 3567 3568 void UnoTimeFieldControl::setMin( sal_Int32 Time ) throw(uno::RuntimeException) 3569 { 3570 uno::Any aAny; 3571 aAny <<= Time; 3572 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TIMEMIN ), aAny, sal_True ); 3573 } 3574 3575 sal_Int32 UnoTimeFieldControl::getMin() throw(uno::RuntimeException) 3576 { 3577 return ImplGetPropertyValue_INT32( BASEPROPERTY_TIMEMIN ); 3578 } 3579 3580 void UnoTimeFieldControl::setMax( sal_Int32 Time ) throw(uno::RuntimeException) 3581 { 3582 uno::Any aAny; 3583 aAny <<= Time; 3584 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TIMEMAX ), aAny, sal_True ); 3585 } 3586 3587 sal_Int32 UnoTimeFieldControl::getMax() throw(uno::RuntimeException) 3588 { 3589 return ImplGetPropertyValue_INT32( BASEPROPERTY_TIMEMAX ); 3590 } 3591 3592 void UnoTimeFieldControl::setFirst( sal_Int32 Time ) throw(uno::RuntimeException) 3593 { 3594 mnFirst = Time; 3595 if ( getPeer().is() ) 3596 { 3597 uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY ); 3598 xField->setFirst( mnFirst ); 3599 } 3600 } 3601 3602 sal_Int32 UnoTimeFieldControl::getFirst() throw(uno::RuntimeException) 3603 { 3604 return mnFirst; 3605 } 3606 3607 void UnoTimeFieldControl::setLast( sal_Int32 Time ) throw(uno::RuntimeException) 3608 { 3609 mnLast = Time; 3610 if ( getPeer().is() ) 3611 { 3612 uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY ); 3613 xField->setFirst( mnLast ); 3614 } 3615 } 3616 3617 sal_Int32 UnoTimeFieldControl::getLast() throw(uno::RuntimeException) 3618 { 3619 return mnLast; 3620 } 3621 3622 void UnoTimeFieldControl::setEmpty() throw(uno::RuntimeException) 3623 { 3624 if ( getPeer().is() ) 3625 { 3626 uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY ); 3627 xField->setEmpty(); 3628 } 3629 } 3630 3631 sal_Bool UnoTimeFieldControl::isEmpty() throw(uno::RuntimeException) 3632 { 3633 sal_Bool bEmpty = sal_False; 3634 if ( getPeer().is() ) 3635 { 3636 uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY ); 3637 bEmpty = xField->isEmpty(); 3638 } 3639 return bEmpty; 3640 } 3641 3642 void UnoTimeFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException) 3643 { 3644 uno::Any aAny; 3645 aAny <<= bStrict; 3646 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True ); 3647 } 3648 3649 sal_Bool UnoTimeFieldControl::isStrictFormat() throw(uno::RuntimeException) 3650 { 3651 return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT ); 3652 } 3653 3654 // ---------------------------------------------------- 3655 // class UnoControlNumericFieldModel 3656 // ---------------------------------------------------- 3657 UnoControlNumericFieldModel::UnoControlNumericFieldModel( const Reference< XMultiServiceFactory >& i_factory ) 3658 :UnoControlModel( i_factory ) 3659 { 3660 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXNumericField ); 3661 } 3662 3663 ::rtl::OUString UnoControlNumericFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 3664 { 3665 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlNumericFieldModel ); 3666 } 3667 3668 uno::Any UnoControlNumericFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 3669 { 3670 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL ) 3671 { 3672 uno::Any aAny; 3673 aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlNumericField ); 3674 return aAny; 3675 } 3676 return UnoControlModel::ImplGetDefaultValue( nPropId ); 3677 } 3678 3679 3680 ::cppu::IPropertyArrayHelper& UnoControlNumericFieldModel::getInfoHelper() 3681 { 3682 static UnoPropertyArrayHelper* pHelper = NULL; 3683 if ( !pHelper ) 3684 { 3685 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 3686 pHelper = new UnoPropertyArrayHelper( aIDs ); 3687 } 3688 return *pHelper; 3689 } 3690 3691 // beans::XMultiPropertySet 3692 uno::Reference< beans::XPropertySetInfo > UnoControlNumericFieldModel::getPropertySetInfo( ) throw(uno::RuntimeException) 3693 { 3694 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 3695 return xInfo; 3696 } 3697 3698 3699 3700 // ---------------------------------------------------- 3701 // class UnoNumericFieldControl 3702 // ---------------------------------------------------- 3703 UnoNumericFieldControl::UnoNumericFieldControl( const Reference< XMultiServiceFactory >& i_factory ) 3704 :UnoSpinFieldControl( i_factory ) 3705 { 3706 mnFirst = 0; 3707 mnLast = 0x7FFFFFFF; 3708 } 3709 3710 ::rtl::OUString UnoNumericFieldControl::GetComponentServiceName() 3711 { 3712 return ::rtl::OUString::createFromAscii( "numericfield" ); 3713 } 3714 3715 // uno::XInterface 3716 uno::Any UnoNumericFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException) 3717 { 3718 uno::Any aRet = ::cppu::queryInterface( rType, 3719 SAL_STATIC_CAST( awt::XNumericField*, this ) ); 3720 return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType )); 3721 } 3722 3723 // lang::XTypeProvider 3724 IMPL_XTYPEPROVIDER_START( UnoNumericFieldControl ) 3725 getCppuType( ( uno::Reference< awt::XNumericField>* ) NULL ), 3726 UnoSpinFieldControl::getTypes() 3727 IMPL_XTYPEPROVIDER_END 3728 3729 void UnoNumericFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException) 3730 { 3731 UnoSpinFieldControl::createPeer( rxToolkit, rParentPeer ); 3732 3733 uno::Reference < awt::XNumericField > xField( getPeer(), uno::UNO_QUERY ); 3734 xField->setFirst( mnFirst ); 3735 xField->setLast( mnLast ); 3736 } 3737 3738 3739 void UnoNumericFieldControl::textChanged( const awt::TextEvent& e ) throw(uno::RuntimeException) 3740 { 3741 uno::Reference < awt::XNumericField > xField( getPeer(), uno::UNO_QUERY ); 3742 uno::Any aAny; 3743 aAny <<= xField->getValue(); 3744 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUE_DOUBLE ), aAny, sal_False ); 3745 3746 if ( GetTextListeners().getLength() ) 3747 GetTextListeners().textChanged( e ); 3748 } 3749 3750 void UnoNumericFieldControl::setValue( double Value ) throw(uno::RuntimeException) 3751 { 3752 uno::Any aAny; 3753 aAny <<= Value; 3754 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUE_DOUBLE ), aAny, sal_True ); 3755 } 3756 3757 double UnoNumericFieldControl::getValue() throw(uno::RuntimeException) 3758 { 3759 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUE_DOUBLE ); 3760 } 3761 3762 void UnoNumericFieldControl::setMin( double Value ) throw(uno::RuntimeException) 3763 { 3764 uno::Any aAny; 3765 aAny <<= Value; 3766 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUEMIN_DOUBLE ), aAny, sal_True ); 3767 } 3768 3769 double UnoNumericFieldControl::getMin() throw(uno::RuntimeException) 3770 { 3771 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUEMIN_DOUBLE ); 3772 } 3773 3774 void UnoNumericFieldControl::setMax( double Value ) throw(uno::RuntimeException) 3775 { 3776 uno::Any aAny; 3777 aAny <<= Value; 3778 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUEMAX_DOUBLE ), aAny, sal_True ); 3779 } 3780 3781 double UnoNumericFieldControl::getMax() throw(uno::RuntimeException) 3782 { 3783 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUEMAX_DOUBLE ); 3784 } 3785 3786 void UnoNumericFieldControl::setFirst( double Value ) throw(uno::RuntimeException) 3787 { 3788 mnFirst = Value; 3789 if ( getPeer().is() ) 3790 { 3791 uno::Reference < awt::XNumericField > xField( getPeer(), uno::UNO_QUERY ); 3792 xField->setFirst( mnFirst ); 3793 } 3794 } 3795 3796 double UnoNumericFieldControl::getFirst() throw(uno::RuntimeException) 3797 { 3798 return mnFirst; 3799 } 3800 3801 void UnoNumericFieldControl::setLast( double Value ) throw(uno::RuntimeException) 3802 { 3803 mnLast = Value; 3804 if ( getPeer().is() ) 3805 { 3806 uno::Reference < awt::XNumericField > xField( getPeer(), uno::UNO_QUERY ); 3807 xField->setLast( mnLast ); 3808 } 3809 } 3810 3811 double UnoNumericFieldControl::getLast() throw(uno::RuntimeException) 3812 { 3813 return mnLast; 3814 } 3815 3816 void UnoNumericFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException) 3817 { 3818 uno::Any aAny; 3819 aAny <<= bStrict; 3820 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True ); 3821 } 3822 3823 sal_Bool UnoNumericFieldControl::isStrictFormat() throw(uno::RuntimeException) 3824 { 3825 return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT ); 3826 } 3827 3828 void UnoNumericFieldControl::setSpinSize( double Digits ) throw(uno::RuntimeException) 3829 { 3830 uno::Any aAny; 3831 aAny <<= Digits; 3832 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUESTEP_DOUBLE ), aAny, sal_True ); 3833 } 3834 3835 double UnoNumericFieldControl::getSpinSize() throw(uno::RuntimeException) 3836 { 3837 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUESTEP_DOUBLE ); 3838 } 3839 3840 void UnoNumericFieldControl::setDecimalDigits( sal_Int16 Digits ) throw(uno::RuntimeException) 3841 { 3842 uno::Any aAny; 3843 aAny <<= Digits; 3844 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DECIMALACCURACY ), aAny, sal_True ); 3845 } 3846 3847 sal_Int16 UnoNumericFieldControl::getDecimalDigits() throw(uno::RuntimeException) 3848 { 3849 return ImplGetPropertyValue_INT16( BASEPROPERTY_DECIMALACCURACY ); 3850 } 3851 3852 // ---------------------------------------------------- 3853 // class UnoControlCurrencyFieldModel 3854 // ---------------------------------------------------- 3855 UnoControlCurrencyFieldModel::UnoControlCurrencyFieldModel( const Reference< XMultiServiceFactory >& i_factory ) 3856 :UnoControlModel( i_factory ) 3857 { 3858 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXCurrencyField ); 3859 } 3860 3861 ::rtl::OUString UnoControlCurrencyFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 3862 { 3863 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlCurrencyFieldModel ); 3864 } 3865 3866 uno::Any UnoControlCurrencyFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 3867 { 3868 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL ) 3869 { 3870 uno::Any aAny; 3871 aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlCurrencyField ); 3872 return aAny; 3873 } 3874 if ( nPropId == BASEPROPERTY_CURSYM_POSITION ) 3875 { 3876 uno::Any aAny; 3877 aAny <<= (sal_Bool)sal_False; 3878 return aAny; 3879 } 3880 3881 return UnoControlModel::ImplGetDefaultValue( nPropId ); 3882 } 3883 3884 ::cppu::IPropertyArrayHelper& UnoControlCurrencyFieldModel::getInfoHelper() 3885 { 3886 static UnoPropertyArrayHelper* pHelper = NULL; 3887 if ( !pHelper ) 3888 { 3889 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 3890 pHelper = new UnoPropertyArrayHelper( aIDs ); 3891 } 3892 return *pHelper; 3893 } 3894 3895 // beans::XMultiPropertySet 3896 uno::Reference< beans::XPropertySetInfo > UnoControlCurrencyFieldModel::getPropertySetInfo( ) throw(uno::RuntimeException) 3897 { 3898 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 3899 return xInfo; 3900 } 3901 3902 // ---------------------------------------------------- 3903 // class UnoCurrencyFieldControl 3904 // ---------------------------------------------------- 3905 UnoCurrencyFieldControl::UnoCurrencyFieldControl( const Reference< XMultiServiceFactory >& i_factory ) 3906 :UnoSpinFieldControl( i_factory ) 3907 { 3908 mnFirst = 0; 3909 mnLast = 0x7FFFFFFF; 3910 } 3911 3912 ::rtl::OUString UnoCurrencyFieldControl::GetComponentServiceName() 3913 { 3914 return ::rtl::OUString::createFromAscii( "longcurrencyfield" ); 3915 } 3916 3917 // uno::XInterface 3918 uno::Any UnoCurrencyFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException) 3919 { 3920 uno::Any aRet = ::cppu::queryInterface( rType, 3921 SAL_STATIC_CAST( awt::XCurrencyField*, this ) ); 3922 return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType )); 3923 } 3924 3925 // lang::XTypeProvider 3926 IMPL_XTYPEPROVIDER_START( UnoCurrencyFieldControl ) 3927 getCppuType( ( uno::Reference< awt::XCurrencyField>* ) NULL ), 3928 UnoSpinFieldControl::getTypes() 3929 IMPL_XTYPEPROVIDER_END 3930 3931 void UnoCurrencyFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException) 3932 { 3933 UnoSpinFieldControl::createPeer( rxToolkit, rParentPeer ); 3934 3935 uno::Reference < awt::XCurrencyField > xField( getPeer(), uno::UNO_QUERY ); 3936 xField->setFirst( mnFirst ); 3937 xField->setLast( mnLast ); 3938 } 3939 3940 void UnoCurrencyFieldControl::textChanged( const awt::TextEvent& e ) throw(uno::RuntimeException) 3941 { 3942 uno::Reference < awt::XCurrencyField > xField( getPeer(), uno::UNO_QUERY ); 3943 uno::Any aAny; 3944 aAny <<= xField->getValue(); 3945 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUE_DOUBLE ), aAny, sal_False ); 3946 3947 if ( GetTextListeners().getLength() ) 3948 GetTextListeners().textChanged( e ); 3949 } 3950 3951 void UnoCurrencyFieldControl::setValue( double Value ) throw(uno::RuntimeException) 3952 { 3953 uno::Any aAny; 3954 aAny <<= Value; 3955 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUE_DOUBLE ), aAny, sal_True ); 3956 } 3957 3958 double UnoCurrencyFieldControl::getValue() throw(uno::RuntimeException) 3959 { 3960 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUE_DOUBLE ); 3961 } 3962 3963 void UnoCurrencyFieldControl::setMin( double Value ) throw(uno::RuntimeException) 3964 { 3965 uno::Any aAny; 3966 aAny <<= Value; 3967 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUEMIN_DOUBLE ), aAny, sal_True ); 3968 } 3969 3970 double UnoCurrencyFieldControl::getMin() throw(uno::RuntimeException) 3971 { 3972 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUEMIN_DOUBLE ); 3973 } 3974 3975 void UnoCurrencyFieldControl::setMax( double Value ) throw(uno::RuntimeException) 3976 { 3977 uno::Any aAny; 3978 aAny <<= Value; 3979 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUEMAX_DOUBLE ), aAny, sal_True ); 3980 } 3981 3982 double UnoCurrencyFieldControl::getMax() throw(uno::RuntimeException) 3983 { 3984 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUEMAX_DOUBLE ); 3985 } 3986 3987 void UnoCurrencyFieldControl::setFirst( double Value ) throw(uno::RuntimeException) 3988 { 3989 mnFirst = Value; 3990 if ( getPeer().is() ) 3991 { 3992 uno::Reference < awt::XCurrencyField > xField( getPeer(), uno::UNO_QUERY ); 3993 xField->setFirst( mnFirst ); 3994 } 3995 } 3996 3997 double UnoCurrencyFieldControl::getFirst() throw(uno::RuntimeException) 3998 { 3999 return mnFirst; 4000 } 4001 4002 void UnoCurrencyFieldControl::setLast( double Value ) throw(uno::RuntimeException) 4003 { 4004 mnLast = Value; 4005 if ( getPeer().is() ) 4006 { 4007 uno::Reference < awt::XCurrencyField > xField( getPeer(), uno::UNO_QUERY ); 4008 xField->setLast( mnLast ); 4009 } 4010 } 4011 4012 double UnoCurrencyFieldControl::getLast() throw(uno::RuntimeException) 4013 { 4014 return mnLast; 4015 } 4016 4017 void UnoCurrencyFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException) 4018 { 4019 uno::Any aAny; 4020 aAny <<= bStrict; 4021 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True ); 4022 } 4023 4024 sal_Bool UnoCurrencyFieldControl::isStrictFormat() throw(uno::RuntimeException) 4025 { 4026 return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT ); 4027 } 4028 4029 void UnoCurrencyFieldControl::setSpinSize( double Digits ) throw(uno::RuntimeException) 4030 { 4031 uno::Any aAny; 4032 aAny <<= Digits; 4033 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUESTEP_DOUBLE ), aAny, sal_True ); 4034 } 4035 4036 double UnoCurrencyFieldControl::getSpinSize() throw(uno::RuntimeException) 4037 { 4038 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUESTEP_DOUBLE ); 4039 } 4040 4041 void UnoCurrencyFieldControl::setDecimalDigits( sal_Int16 Digits ) throw(uno::RuntimeException) 4042 { 4043 uno::Any aAny; 4044 aAny <<= Digits; 4045 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DECIMALACCURACY ), aAny, sal_True ); 4046 } 4047 4048 sal_Int16 UnoCurrencyFieldControl::getDecimalDigits() throw(uno::RuntimeException) 4049 { 4050 return ImplGetPropertyValue_INT16( BASEPROPERTY_DECIMALACCURACY ); 4051 } 4052 4053 // ---------------------------------------------------- 4054 // class UnoControlPatternFieldModel 4055 // ---------------------------------------------------- 4056 UnoControlPatternFieldModel::UnoControlPatternFieldModel( const Reference< XMultiServiceFactory >& i_factory ) 4057 :UnoControlModel( i_factory ) 4058 { 4059 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXPatternField ); 4060 } 4061 4062 ::rtl::OUString UnoControlPatternFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException) 4063 { 4064 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlPatternFieldModel ); 4065 } 4066 4067 uno::Any UnoControlPatternFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 4068 { 4069 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL ) 4070 { 4071 uno::Any aAny; 4072 aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlPatternField ); 4073 return aAny; 4074 } 4075 return UnoControlModel::ImplGetDefaultValue( nPropId ); 4076 } 4077 4078 ::cppu::IPropertyArrayHelper& UnoControlPatternFieldModel::getInfoHelper() 4079 { 4080 static UnoPropertyArrayHelper* pHelper = NULL; 4081 if ( !pHelper ) 4082 { 4083 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 4084 pHelper = new UnoPropertyArrayHelper( aIDs ); 4085 } 4086 return *pHelper; 4087 } 4088 4089 // beans::XMultiPropertySet 4090 uno::Reference< beans::XPropertySetInfo > UnoControlPatternFieldModel::getPropertySetInfo( ) throw(uno::RuntimeException) 4091 { 4092 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 4093 return xInfo; 4094 } 4095 4096 4097 // ---------------------------------------------------- 4098 // class UnoPatternFieldControl 4099 // ---------------------------------------------------- 4100 UnoPatternFieldControl::UnoPatternFieldControl( const Reference< XMultiServiceFactory >& i_factory ) 4101 :UnoSpinFieldControl( i_factory ) 4102 { 4103 } 4104 4105 ::rtl::OUString UnoPatternFieldControl::GetComponentServiceName() 4106 { 4107 return ::rtl::OUString::createFromAscii( "patternfield" ); 4108 } 4109 4110 void UnoPatternFieldControl::ImplSetPeerProperty( const ::rtl::OUString& rPropName, const uno::Any& rVal ) 4111 { 4112 sal_uInt16 nType = GetPropertyId( rPropName ); 4113 if ( ( nType == BASEPROPERTY_TEXT ) || ( nType == BASEPROPERTY_EDITMASK ) || ( nType == BASEPROPERTY_LITERALMASK ) ) 4114 { 4115 // Die Masken koennen nicht nacheinander gesetzt werden. 4116 ::rtl::OUString Text = ImplGetPropertyValue_UString( BASEPROPERTY_TEXT ); 4117 ::rtl::OUString EditMask = ImplGetPropertyValue_UString( BASEPROPERTY_EDITMASK ); 4118 ::rtl::OUString LiteralMask = ImplGetPropertyValue_UString( BASEPROPERTY_LITERALMASK ); 4119 4120 uno::Reference < awt::XPatternField > xPF( getPeer(), uno::UNO_QUERY ); 4121 if (xPF.is()) 4122 { 4123 // same comment as in UnoControl::ImplSetPeerProperty - see there 4124 ::rtl::OUString sText( Text ); 4125 ImplCheckLocalize( sText ); 4126 xPF->setString( sText ); 4127 xPF->setMasks( EditMask, LiteralMask ); 4128 } 4129 } 4130 else 4131 UnoSpinFieldControl::ImplSetPeerProperty( rPropName, rVal ); 4132 } 4133 4134 4135 // uno::XInterface 4136 uno::Any UnoPatternFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException) 4137 { 4138 uno::Any aRet = ::cppu::queryInterface( rType, 4139 SAL_STATIC_CAST( awt::XPatternField*, this ) ); 4140 return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType )); 4141 } 4142 4143 // lang::XTypeProvider 4144 IMPL_XTYPEPROVIDER_START( UnoPatternFieldControl ) 4145 getCppuType( ( uno::Reference< awt::XPatternField>* ) NULL ), 4146 UnoSpinFieldControl::getTypes() 4147 IMPL_XTYPEPROVIDER_END 4148 4149 void UnoPatternFieldControl::setString( const ::rtl::OUString& rString ) throw(uno::RuntimeException) 4150 { 4151 setText( rString ); 4152 } 4153 4154 ::rtl::OUString UnoPatternFieldControl::getString() throw(uno::RuntimeException) 4155 { 4156 return getText(); 4157 } 4158 4159 void UnoPatternFieldControl::setMasks( const ::rtl::OUString& EditMask, const ::rtl::OUString& LiteralMask ) throw(uno::RuntimeException) 4160 { 4161 uno::Any aAny; 4162 aAny <<= EditMask; 4163 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_EDITMASK ), aAny, sal_True ); 4164 aAny <<= LiteralMask; 4165 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LITERALMASK ), aAny, sal_True ); 4166 } 4167 4168 void UnoPatternFieldControl::getMasks( ::rtl::OUString& EditMask, ::rtl::OUString& LiteralMask ) throw(uno::RuntimeException) 4169 { 4170 EditMask = ImplGetPropertyValue_UString( BASEPROPERTY_EDITMASK ); 4171 LiteralMask = ImplGetPropertyValue_UString( BASEPROPERTY_LITERALMASK ); 4172 } 4173 4174 void UnoPatternFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException) 4175 { 4176 uno::Any aAny; 4177 aAny <<= bStrict; 4178 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True ); 4179 } 4180 4181 sal_Bool UnoPatternFieldControl::isStrictFormat() throw(uno::RuntimeException) 4182 { 4183 return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT ); 4184 } 4185 4186 4187 // ---------------------------------------------------- 4188 // class UnoControlProgressBarModel 4189 // ---------------------------------------------------- 4190 UnoControlProgressBarModel::UnoControlProgressBarModel( const Reference< XMultiServiceFactory >& i_factory ) 4191 :UnoControlModel( i_factory ) 4192 { 4193 ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR ); 4194 ImplRegisterProperty( BASEPROPERTY_BORDER ); 4195 ImplRegisterProperty( BASEPROPERTY_BORDERCOLOR ); 4196 ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL ); 4197 ImplRegisterProperty( BASEPROPERTY_ENABLED ); 4198 ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE ); 4199 ImplRegisterProperty( BASEPROPERTY_FILLCOLOR ); 4200 ImplRegisterProperty( BASEPROPERTY_HELPTEXT ); 4201 ImplRegisterProperty( BASEPROPERTY_HELPURL ); 4202 ImplRegisterProperty( BASEPROPERTY_PRINTABLE ); 4203 ImplRegisterProperty( BASEPROPERTY_PROGRESSVALUE ); 4204 ImplRegisterProperty( BASEPROPERTY_PROGRESSVALUE_MAX ); 4205 ImplRegisterProperty( BASEPROPERTY_PROGRESSVALUE_MIN ); 4206 } 4207 4208 ::rtl::OUString UnoControlProgressBarModel::getServiceName( ) throw(::com::sun::star::uno::RuntimeException) 4209 { 4210 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlProgressBarModel ); 4211 } 4212 4213 uno::Any UnoControlProgressBarModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 4214 { 4215 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL ) 4216 { 4217 uno::Any aAny; 4218 aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlProgressBar ); 4219 return aAny; 4220 } 4221 4222 return UnoControlModel::ImplGetDefaultValue( nPropId ); 4223 } 4224 4225 ::cppu::IPropertyArrayHelper& UnoControlProgressBarModel::getInfoHelper() 4226 { 4227 static UnoPropertyArrayHelper* pHelper = NULL; 4228 if ( !pHelper ) 4229 { 4230 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 4231 pHelper = new UnoPropertyArrayHelper( aIDs ); 4232 } 4233 return *pHelper; 4234 } 4235 4236 // beans::XMultiPropertySet 4237 uno::Reference< beans::XPropertySetInfo > UnoControlProgressBarModel::getPropertySetInfo( ) throw(uno::RuntimeException) 4238 { 4239 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 4240 return xInfo; 4241 } 4242 4243 4244 // ---------------------------------------------------- 4245 // class UnoProgressBarControl 4246 // ---------------------------------------------------- 4247 UnoProgressBarControl::UnoProgressBarControl( const Reference< XMultiServiceFactory >& i_factory ) 4248 :UnoControlBase( i_factory ) 4249 { 4250 } 4251 4252 ::rtl::OUString UnoProgressBarControl::GetComponentServiceName() 4253 { 4254 return ::rtl::OUString::createFromAscii( "ProgressBar" ); 4255 } 4256 4257 // uno::XInterface 4258 uno::Any UnoProgressBarControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException) 4259 { 4260 uno::Any aRet = ::cppu::queryInterface( rType, 4261 SAL_STATIC_CAST( awt::XProgressBar*, this ) ); 4262 return (aRet.hasValue() ? aRet : UnoControlBase::queryAggregation( rType )); 4263 } 4264 4265 // lang::XTypeProvider 4266 IMPL_XTYPEPROVIDER_START( UnoProgressBarControl ) 4267 getCppuType( ( uno::Reference< awt::XProgressBar>* ) NULL ), 4268 UnoControlBase::getTypes() 4269 IMPL_XTYPEPROVIDER_END 4270 4271 // ::com::sun::star::awt::XProgressBar 4272 void UnoProgressBarControl::setForegroundColor( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException) 4273 { 4274 uno::Any aAny; 4275 aAny <<= nColor; 4276 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_FILLCOLOR ), aAny, sal_True ); 4277 } 4278 4279 void UnoProgressBarControl::setBackgroundColor( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException) 4280 { 4281 uno::Any aAny; 4282 aAny <<= nColor; 4283 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_BACKGROUNDCOLOR ), aAny, sal_True ); 4284 } 4285 4286 void UnoProgressBarControl::setValue( sal_Int32 nValue ) throw(::com::sun::star::uno::RuntimeException) 4287 { 4288 uno::Any aAny; 4289 aAny <<= nValue; 4290 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_PROGRESSVALUE ), aAny, sal_True ); 4291 } 4292 4293 void UnoProgressBarControl::setRange( sal_Int32 nMin, sal_Int32 nMax ) throw(::com::sun::star::uno::RuntimeException ) 4294 { 4295 uno::Any aMin; 4296 uno::Any aMax; 4297 4298 if ( nMin < nMax ) 4299 { 4300 // take correct min and max 4301 aMin <<= nMin; 4302 aMax <<= nMax; 4303 } 4304 else 4305 { 4306 // change min and max 4307 aMin <<= nMax; 4308 aMax <<= nMin; 4309 } 4310 4311 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_PROGRESSVALUE_MIN ), aMin, sal_True ); 4312 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_PROGRESSVALUE_MAX ), aMax, sal_True ); 4313 } 4314 4315 sal_Int32 UnoProgressBarControl::getValue() throw(::com::sun::star::uno::RuntimeException) 4316 { 4317 return ImplGetPropertyValue_INT32( BASEPROPERTY_PROGRESSVALUE ); 4318 } 4319 4320 4321 // ---------------------------------------------------- 4322 // class UnoControlFixedLineModel 4323 // ---------------------------------------------------- 4324 UnoControlFixedLineModel::UnoControlFixedLineModel( const Reference< XMultiServiceFactory >& i_factory ) 4325 :UnoControlModel( i_factory ) 4326 { 4327 ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR ); 4328 ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL ); 4329 ImplRegisterProperty( BASEPROPERTY_ENABLED ); 4330 ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE ); 4331 ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR ); 4332 ImplRegisterProperty( BASEPROPERTY_HELPTEXT ); 4333 ImplRegisterProperty( BASEPROPERTY_HELPURL ); 4334 ImplRegisterProperty( BASEPROPERTY_LABEL ); 4335 ImplRegisterProperty( BASEPROPERTY_ORIENTATION ); 4336 ImplRegisterProperty( BASEPROPERTY_PRINTABLE ); 4337 } 4338 4339 ::rtl::OUString UnoControlFixedLineModel::getServiceName( ) throw(::com::sun::star::uno::RuntimeException) 4340 { 4341 return ::rtl::OUString::createFromAscii( szServiceName_UnoControlFixedLineModel ); 4342 } 4343 4344 uno::Any UnoControlFixedLineModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const 4345 { 4346 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL ) 4347 { 4348 uno::Any aAny; 4349 aAny <<= ::rtl::OUString::createFromAscii( szServiceName_UnoControlFixedLine ); 4350 return aAny; 4351 } 4352 return UnoControlModel::ImplGetDefaultValue( nPropId ); 4353 } 4354 4355 ::cppu::IPropertyArrayHelper& UnoControlFixedLineModel::getInfoHelper() 4356 { 4357 static UnoPropertyArrayHelper* pHelper = NULL; 4358 if ( !pHelper ) 4359 { 4360 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds(); 4361 pHelper = new UnoPropertyArrayHelper( aIDs ); 4362 } 4363 return *pHelper; 4364 } 4365 4366 // beans::XMultiPropertySet 4367 uno::Reference< beans::XPropertySetInfo > UnoControlFixedLineModel::getPropertySetInfo( ) throw(uno::RuntimeException) 4368 { 4369 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); 4370 return xInfo; 4371 } 4372 4373 // ---------------------------------------------------- 4374 // class UnoFixedLineControl 4375 // ---------------------------------------------------- 4376 UnoFixedLineControl::UnoFixedLineControl( const Reference< XMultiServiceFactory >& i_factory ) 4377 :UnoControlBase( i_factory ) 4378 { 4379 maComponentInfos.nWidth = 100; // ?? 4380 maComponentInfos.nHeight = 100; // ?? 4381 } 4382 4383 ::rtl::OUString UnoFixedLineControl::GetComponentServiceName() 4384 { 4385 return ::rtl::OUString::createFromAscii( "FixedLine" ); 4386 } 4387 4388 sal_Bool UnoFixedLineControl::isTransparent() throw(uno::RuntimeException) 4389 { 4390 return sal_True; 4391 } 4392 4393