forms/source/component/Button.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "Button.hxx"
  22
  23 #include <com/sun/star/awt/XVclWindowPeer.hpp>
  24
  25 #include <comphelper/streamsection.hxx>
  26 #include <comphelper/basicio.hxx>
  27 #include <comphelper/processfactory.hxx>
  28 #include <tools/diagnose_ex.h>
  29 #include <tools/debug.hxx>
  30 #include <tools/urlobj.hxx>
  31 #include <vcl/svapp.hxx>
  32 #include <osl/mutex.hxx>
  33
  34 namespace frm
  35 {
  36
  37
  38 using namespace ::com::sun::star::uno;
  39 using namespace ::com::sun::star::sdb;
  40 using namespace ::com::sun::star::sdbc;
  41 using namespace ::com::sun::star::sdbcx;
  42 using namespace ::com::sun::star::beans;
  43 using namespace ::com::sun::star::container;
  44 using namespace ::com::sun::star::form;
  45 using namespace ::com::sun::star::awt;
  46 using namespace ::com::sun::star::io;
  47 using namespace ::com::sun::star::lang;
  48 using namespace ::com::sun::star::util;
  49 using ::com::sun::star::frame::XDispatchProviderInterceptor;
  50
  51
  52 //= OButtonModel
  53
  54
  55 OButtonModel::OButtonModel(const Reference<XComponentContext>& _rxFactory)
  56     :OClickableImageBaseModel( _rxFactory, VCL_CONTROLMODEL_COMMANDBUTTON, FRM_SUN_CONTROL_COMMANDBUTTON )
  57                                     // use the old control name for compatibility reasons
  58     ,m_aResetHelper( *this, m_aMutex )
  59     ,m_eDefaultState( TRISTATE_FALSE )
  60 {
  61     m_nClassId = FormComponentType::COMMANDBUTTON;
  62 }
  63
  64
  65 Any SAL_CALL OButtonModel::queryAggregation( const Type& _type ) throw(RuntimeException, std::exception)
  66 {
  67     Any aReturn = OClickableImageBaseModel::queryAggregation( _type );
  68     if ( !aReturn.hasValue() )
  69         aReturn = OButtonModel_Base::queryInterface( _type );
  70     return aReturn;
  71 }
  72
  73
  74 Sequence< Type > OButtonModel::_getTypes()
  75 {
  76     return ::comphelper::concatSequences(
  77         OClickableImageBaseModel::_getTypes(),
  78         OButtonModel_Base::getTypes()
  79     );
  80 }
  81
  82
  83 OButtonModel::OButtonModel( const OButtonModel* _pOriginal, const Reference<XComponentContext>& _rxFactory )
  84     :OClickableImageBaseModel( _pOriginal, _rxFactory )
  85     ,m_aResetHelper( *this, m_aMutex )
  86     ,m_eDefaultState( _pOriginal->m_eDefaultState )
  87 {
  88     m_nClassId = FormComponentType::COMMANDBUTTON;
  89
  90     implInitializeImageURL();
  91 }
  92
  93
  94 OButtonModel::~OButtonModel()
  95 {
  96 }
  97
  98
  99 void OButtonModel::describeFixedProperties( Sequence< Property >& _rProps ) const
 100 {
 101     BEGIN_DESCRIBE_PROPERTIES( 6, OClickableImageBaseModel )
 102         DECL_PROP1( BUTTONTYPE,             FormButtonType,             BOUND );
 103         DECL_PROP1( DEFAULT_STATE,          sal_Int16,                  BOUND );
 104         DECL_PROP1( DISPATCHURLINTERNAL,    sal_Bool,                   BOUND );
 105         DECL_PROP1( TARGET_URL,             OUString,            BOUND );
 106         DECL_PROP1( TARGET_FRAME,           OUString,            BOUND );
 107         DECL_PROP1( TABINDEX,               sal_Int16,                  BOUND );
 108     END_DESCRIBE_PROPERTIES();
 109 }
 110
 111
 112 IMPLEMENT_DEFAULT_CLONING( OButtonModel )
 113
 114 // XServiceInfo
 115
 116 StringSequence  OButtonModel::getSupportedServiceNames() throw(std::exception)
 117 {
 118     StringSequence aSupported = OClickableImageBaseModel::getSupportedServiceNames();
 119     aSupported.realloc( aSupported.getLength() + 2 );
 120
 121     OUString* pArray = aSupported.getArray();
 122     pArray[ aSupported.getLength() - 2 ] = FRM_SUN_COMPONENT_COMMANDBUTTON;
 123     pArray[ aSupported.getLength() - 1 ] = FRM_COMPONENT_COMMANDBUTTON;
 124
 125     return aSupported;
 126 }
 127
 128
 129 OUString OButtonModel::getServiceName() throw ( ::com::sun::star::uno::RuntimeException, std::exception)
 130 {
 131     return OUString(FRM_COMPONENT_COMMANDBUTTON); // old (non-sun) name for compatibility !
 132 }
 133
 134
 135 void OButtonModel::write(const Reference<XObjectOutputStream>& _rxOutStream) throw (::com::sun::star::io::IOException, ::com::sun::star::uno::RuntimeException, std::exception)
 136 {
 137     OClickableImageBaseModel::write(_rxOutStream);
 138
 139     _rxOutStream->writeShort(0x0003);   // Version
 140
 141     {
 142         OStreamSection aSection( _rxOutStream.get() );
 143             // this will allow readers to skip unknown bytes in their dtor
 144
 145         _rxOutStream->writeShort( (sal_uInt16)m_eButtonType );
 146
 147         OUString sTmp = INetURLObject::decode( m_sTargetURL, INetURLObject::DECODE_UNAMBIGUOUS);
 148         _rxOutStream << sTmp;
 149         _rxOutStream << m_sTargetFrame;
 150         writeHelpTextCompatibly(_rxOutStream);
 151         _rxOutStream << isDispatchUrlInternal();
 152     }
 153 }
 154
 155
 156 void OButtonModel::read(const Reference<XObjectInputStream>& _rxInStream) throw (::com::sun::star::io::IOException, ::com::sun::star::uno::RuntimeException, std::exception)
 157 {
 158     OClickableImageBaseModel::read(_rxInStream);
 159
 160     sal_uInt16 nVersion = _rxInStream->readShort();     // Version
 161     switch (nVersion)
 162     {
 163         case 0x0001:
 164         {
 165             m_eButtonType = (FormButtonType)_rxInStream->readShort();
 166
 167             _rxInStream >> m_sTargetURL;
 168             _rxInStream >> m_sTargetFrame;
 169         }
 170         break;
 171
 172         case 0x0002:
 173         {
 174             m_eButtonType = (FormButtonType)_rxInStream->readShort();
 175
 176             _rxInStream >> m_sTargetURL;
 177             _rxInStream >> m_sTargetFrame;
 178             readHelpTextCompatibly(_rxInStream);
 179         }
 180         break;
 181
 182         case 0x0003:
 183         {
 184             OStreamSection aSection( _rxInStream.get() );
 185             // this will skip any unknown bytes in it's dtor
 186
 187             // button type
 188             m_eButtonType = (FormButtonType)_rxInStream->readShort();
 189
 190             // URL
 191             _rxInStream >> m_sTargetURL;
 192
 193             // target frame
 194             _rxInStream >> m_sTargetFrame;
 195
 196             // help text
 197             readHelpTextCompatibly(_rxInStream);
 198
 199             // DispatchInternal
 200             bool bDispath;
 201             _rxInStream >> bDispath;
 202             setDispatchUrlInternal(bDispath);
 203         }
 204         break;
 205
 206         default:
 207             OSL_FAIL("OButtonModel::read : unknown version !");
 208             m_eButtonType = FormButtonType_PUSH;
 209             m_sTargetURL.clear();
 210             m_sTargetFrame.clear();
 211             break;
 212     }
 213 }
 214
 215
 216 void SAL_CALL OButtonModel::disposing()
 217 {
 218     m_aResetHelper.disposing();
 219     OClickableImageBaseModel::disposing();
 220 }
 221
 222
 223 void SAL_CALL OButtonModel::reset() throw (RuntimeException, std::exception)
 224 {
 225     if ( !m_aResetHelper.approveReset() )
 226         return;
 227
 228     impl_resetNoBroadcast_nothrow();
 229
 230     m_aResetHelper.notifyResetted();
 231 }
 232
 233
 234 void SAL_CALL OButtonModel::addResetListener( const Reference< XResetListener >& _listener ) throw (RuntimeException, std::exception)
 235 {
 236     m_aResetHelper.addResetListener( _listener );
 237 }
 238
 239
 240 void SAL_CALL OButtonModel::removeResetListener( const Reference< XResetListener >& _listener ) throw (RuntimeException, std::exception)
 241 {
 242     m_aResetHelper.removeResetListener( _listener );
 243 }
 244
 245
 246 void SAL_CALL OButtonModel::getFastPropertyValue( Any& _rValue, sal_Int32 _nHandle ) const
 247 {
 248     switch ( _nHandle )
 249     {
 250     case PROPERTY_ID_DEFAULT_STATE:
 251         _rValue <<= (sal_Int16)m_eDefaultState;
 252         break;
 253
 254     default:
 255         OClickableImageBaseModel::getFastPropertyValue( _rValue, _nHandle );
 256         break;
 257     }
 258 }
 259
 260
 261 void SAL_CALL OButtonModel::setFastPropertyValue_NoBroadcast( sal_Int32 _nHandle, const Any& _rValue ) throw (Exception, std::exception)
 262 {
 263     switch ( _nHandle )
 264     {
 265     case PROPERTY_ID_DEFAULT_STATE:
 266     {
 267         sal_Int16 nDefaultState( (sal_Int16)TRISTATE_FALSE );
 268         OSL_VERIFY( _rValue >>= nDefaultState );
 269         m_eDefaultState = (ToggleState)nDefaultState;
 270         impl_resetNoBroadcast_nothrow();
 271     }
 272     break;
 273
 274     default:
 275         OClickableImageBaseModel::setFastPropertyValue_NoBroadcast( _nHandle, _rValue );
 276         break;
 277     }
 278 }
 279
 280
 281 sal_Bool SAL_CALL OButtonModel::convertFastPropertyValue( Any& _rConvertedValue, Any& _rOldValue, sal_Int32 _nHandle, const Any& _rValue ) throw (IllegalArgumentException)
 282 {
 283     bool bModified = false;
 284     switch ( _nHandle )
 285     {
 286     case PROPERTY_ID_DEFAULT_STATE:
 287         bModified = tryPropertyValue( _rConvertedValue, _rOldValue, _rValue, (sal_Int16)m_eDefaultState );
 288         break;
 289
 290     default:
 291         bModified = OClickableImageBaseModel::convertFastPropertyValue( _rConvertedValue, _rOldValue, _nHandle, _rValue );
 292         break;
 293     }
 294     return bModified;
 295 }
 296
 297
 298 Any OButtonModel::getPropertyDefaultByHandle( sal_Int32 _nHandle ) const
 299 {
 300     Any aDefault;
 301     switch ( _nHandle )
 302     {
 303     case PROPERTY_ID_DEFAULT_STATE:
 304         aDefault <<= (sal_Int16)TRISTATE_FALSE;
 305         break;
 306
 307     default:
 308         aDefault = OClickableImageBaseModel::getPropertyDefaultByHandle( _nHandle );
 309         break;
 310     }
 311     return aDefault;
 312 }
 313
 314
 315 void OButtonModel::impl_resetNoBroadcast_nothrow()
 316 {
 317     try
 318     {
 319         setPropertyValue( PROPERTY_STATE, getPropertyValue( PROPERTY_DEFAULT_STATE ) );
 320     }
 321     catch( const Exception& )
 322     {
 323         DBG_UNHANDLED_EXCEPTION();
 324     }
 325 }
 326
 327
 328 // OButtonControl
 329
 330
 331 Sequence<Type> OButtonControl::_getTypes()
 332 {
 333     return ::comphelper::concatSequences(
 334         OButtonControl_BASE::getTypes(),
 335         OClickableImageBaseControl::_getTypes(),
 336         OFormNavigationHelper::getTypes()
 337     );
 338 }
 339
 340
 341 StringSequence  OButtonControl::getSupportedServiceNames() throw(std::exception)
 342 {
 343     StringSequence aSupported = OClickableImageBaseControl::getSupportedServiceNames();
 344     aSupported.realloc(aSupported.getLength() + 2);
 345
 346     OUString*pArray = aSupported.getArray();
 347     pArray[aSupported.getLength()-2] = FRM_SUN_CONTROL_COMMANDBUTTON;
 348     pArray[aSupported.getLength()-1] = STARDIV_ONE_FORM_CONTROL_COMMANDBUTTON;
 349     return aSupported;
 350 }
 351
 352
 353 OButtonControl::OButtonControl(const Reference<XComponentContext>& _rxFactory)
 354                  :OClickableImageBaseControl(_rxFactory, VCL_CONTROL_COMMANDBUTTON)
 355                  ,OFormNavigationHelper( _rxFactory )
 356                  ,m_nClickEvent( 0 )
 357                  ,m_nTargetUrlFeatureId( -1 )
 358                  ,m_bEnabledByPropertyValue( false )
 359 {
 360     osl_atomic_increment(&m_refCount);
 361     {
 362         // Register as ActionListener
 363         Reference<XButton>  xButton;
 364         query_aggregation( m_xAggregate, xButton);
 365         if (xButton.is())
 366             xButton->addActionListener(this);
 367     }
 368     // For Listener: refcount at one
 369     osl_atomic_decrement(&m_refCount);
 370 }
 371
 372
 373 OButtonControl::~OButtonControl()
 374 {
 375     if (m_nClickEvent)
 376         Application::RemoveUserEvent(m_nClickEvent);
 377 }
 378
 379 // UNO binding
 380
 381 Any SAL_CALL OButtonControl::queryAggregation(const Type& _rType) throw (RuntimeException, std::exception)
 382 {
 383     // if asked for the XTypeProvider, don't let OButtonControl_BASE do this
 384     Any aReturn;
 385     if ( !_rType.equals( cppu::UnoType<XTypeProvider>::get() ) )
 386         aReturn = OButtonControl_BASE::queryInterface( _rType );
 387
 388     if ( !aReturn.hasValue() )
 389         aReturn = OClickableImageBaseControl::queryAggregation( _rType );
 390
 391     if ( !aReturn.hasValue() )
 392         aReturn = OFormNavigationHelper::queryInterface( _rType );
 393
 394     return aReturn;
 395 }
 396
 397
 398 void SAL_CALL OButtonControl::disposing()
 399 {
 400     startOrStopModelPropertyListening( false );
 401
 402     OClickableImageBaseControl::disposing();
 403     OFormNavigationHelper::dispose();
 404 }
 405
 406
 407 void SAL_CALL OButtonControl::disposing( const EventObject& _rSource ) throw( RuntimeException, std::exception )
 408 {
 409     OControl::disposing( _rSource );
 410     OFormNavigationHelper::disposing( _rSource );
 411 }
 412
 413 // ActionListener
 414
 415 void OButtonControl::actionPerformed(const ActionEvent& /*rEvent*/) throw ( ::com::sun::star::uno::RuntimeException, std::exception)
 416 {
 417     // Asynchronous for css::util::URL-Button
 418     ImplSVEvent * n = Application::PostUserEvent( LINK(this, OButtonControl,OnClick) );
 419     {
 420         ::osl::MutexGuard aGuard( m_aMutex );
 421         m_nClickEvent = n;
 422     }
 423 }
 424
 425
 426 IMPL_LINK_NOARG(OButtonControl, OnClick)
 427 {
 428     ::osl::ClearableMutexGuard aGuard( m_aMutex );
 429     m_nClickEvent = 0;
 430
 431     if (m_aApproveActionListeners.getLength())
 432     {
 433         // if there are listeners, start the action in an own thread, to not allow
 434         // them to block us here (we're in the application's main thread)
 435         getImageProducerThread()->addEvent();
 436     }
 437     else
 438     {
 439         // Else, don't. We then must not notify the Listeners in any case,
 440         // not even if added later on.
 441         aGuard.clear();
 442
 443         // recognize the button type
 444         Reference<XPropertySet>  xSet(getModel(), UNO_QUERY);
 445         if (!xSet.is())
 446             return 0L;
 447
 448         if (FormButtonType_PUSH == *static_cast<FormButtonType const *>(xSet->getPropertyValue(PROPERTY_BUTTONTYPE).getValue()))
 449         {
 450             // notify the action listeners for a push button
 451             ::cppu::OInterfaceIteratorHelper aIter(m_aActionListeners);
 452             ActionEvent aEvt(static_cast<XWeak*>(this), m_aActionCommand);
 453             while(aIter.hasMoreElements() )
 454             {
 455                 // catch exceptions
 456                 // and catch them on a per-listener basis - if one listener fails, the others still need
 457                 // to get notified
 458                 try
 459                 {
 460                     static_cast< XActionListener* >( aIter.next() )->actionPerformed(aEvt);
 461                 }
 462 #ifdef DBG_UTIL
 463                 catch( const RuntimeException& )
 464                 {
 465                     // silence this
 466                 }
 467 #endif
 468                 catch( const Exception& )
 469                 {
 470                     OSL_FAIL( "OButtonControl::OnClick: caught a exception other than RuntimeException!" );
 471                 }
 472             }
 473         }
 474         else
 475             actionPerformed_Impl( false, ::com::sun::star::awt::MouseEvent() );
 476     }
 477     return 0L;
 478 }
 479
 480
 481 void OButtonControl::actionPerformed_Impl( bool _bNotifyListener, const ::com::sun::star::awt::MouseEvent& _rEvt )
 482 {
 483     {
 484         sal_Int16 nFeatureId = -1;
 485         {
 486             ::osl::MutexGuard aGuard( m_aMutex );
 487             nFeatureId = m_nTargetUrlFeatureId;
 488         }
 489
 490         if ( nFeatureId != -1 )
 491         {
 492             if ( !approveAction() )
 493                 return;
 494
 495             SolarMutexGuard aGuard;
 496             dispatch( nFeatureId );
 497             return;
 498         }
 499     }
 500
 501     OClickableImageBaseControl::actionPerformed_Impl( _bNotifyListener, _rEvt );
 502 }
 503
 504 // XButton
 505
 506 void OButtonControl::setLabel(const OUString& Label) throw( RuntimeException, std::exception )
 507 {
 508     Reference<XButton>  xButton;
 509     query_aggregation( m_xAggregate, xButton );
 510     if (xButton.is())
 511         xButton->setLabel(Label);
 512 }
 513
 514
 515 void SAL_CALL OButtonControl::setActionCommand(const OUString& _rCommand) throw( RuntimeException, std::exception )
 516 {
 517     {
 518         ::osl::MutexGuard aGuard( m_aMutex );
 519         m_aActionCommand = _rCommand;
 520     }
 521
 522     Reference<XButton>  xButton;
 523     query_aggregation( m_xAggregate, xButton);
 524     if (xButton.is())
 525         xButton->setActionCommand(_rCommand);
 526 }
 527
 528
 529 void SAL_CALL OButtonControl::addActionListener(const Reference<XActionListener>& _rxListener) throw( RuntimeException, std::exception )
 530 {
 531     m_aActionListeners.addInterface(_rxListener);
 532 }
 533
 534
 535 void SAL_CALL OButtonControl::removeActionListener(const Reference<XActionListener>& _rxListener) throw( RuntimeException, std::exception )
 536 {
 537     m_aActionListeners.removeInterface(_rxListener);
 538 }
 539
 540
 541 class DoPropertyListening
 542 {
 543 private:
 544     Reference< XPropertySet >               m_xProps;
 545     Reference< XPropertyChangeListener >    m_xListener;
 546     bool                                    m_bStartListening;
 547
 548 public:
 549     DoPropertyListening(
 550         const Reference< XInterface >& _rxComponent,
 551         const Reference< XPropertyChangeListener >& _rxListener,
 552         bool _bStart
 553     );
 554
 555     void    handleListening( const OUString& _rPropertyName );
 556 };
 557
 558
 559 DoPropertyListening::DoPropertyListening(
 560         const Reference< XInterface >& _rxComponent, const Reference< XPropertyChangeListener >& _rxListener,
 561         bool _bStart )
 562     :m_xProps( _rxComponent, UNO_QUERY )
 563     ,m_xListener( _rxListener )
 564     ,m_bStartListening( _bStart )
 565 {
 566     DBG_ASSERT( m_xProps.is() || !_rxComponent.is(), "DoPropertyListening::DoPropertyListening: valid component, but no property set!" );
 567     DBG_ASSERT( m_xListener.is(), "DoPropertyListening::DoPropertyListening: invalid listener!" );
 568 }
 569
 570
 571 void DoPropertyListening::handleListening( const OUString& _rPropertyName )
 572 {
 573     if ( m_xProps.is() )
 574     {
 575         if ( m_bStartListening )
 576             m_xProps->addPropertyChangeListener( _rPropertyName, m_xListener );
 577         else
 578             m_xProps->removePropertyChangeListener( _rPropertyName, m_xListener );
 579     }
 580 }
 581
 582
 583 void OButtonControl::startOrStopModelPropertyListening( bool _bStart )
 584 {
 585     DoPropertyListening aListeningHandler( getModel(), this, _bStart );
 586     aListeningHandler.handleListening( PROPERTY_TARGET_URL );
 587     aListeningHandler.handleListening( PROPERTY_BUTTONTYPE );
 588     aListeningHandler.handleListening( PROPERTY_ENABLED );
 589 }
 590
 591
 592 sal_Bool SAL_CALL OButtonControl::setModel( const Reference< XControlModel >& _rxModel ) throw ( RuntimeException, std::exception )
 593 {
 594     startOrStopModelPropertyListening( false );
 595     bool bResult = OClickableImageBaseControl::setModel( _rxModel );
 596     startOrStopModelPropertyListening( true );
 597
 598     m_bEnabledByPropertyValue = true;
 599     Reference< XPropertySet > xModelProps( _rxModel, UNO_QUERY );
 600     if ( xModelProps.is() )
 601         xModelProps->getPropertyValue( PROPERTY_ENABLED ) >>= m_bEnabledByPropertyValue;
 602
 603     modelFeatureUrlPotentiallyChanged( );
 604
 605     return bResult;
 606 }
 607
 608
 609 void OButtonControl::modelFeatureUrlPotentiallyChanged( )
 610 {
 611     sal_Int16 nOldUrlFeatureId = m_nTargetUrlFeatureId;
 612
 613     // Do we have another TargetURL now? If so, we need to update our dispatches
 614     m_nTargetUrlFeatureId = getModelUrlFeatureId( );
 615     if ( nOldUrlFeatureId != m_nTargetUrlFeatureId )
 616     {
 617         invalidateSupportedFeaturesSet();
 618         if ( !isDesignMode() )
 619             updateDispatches( );
 620     }
 621 }
 622
 623
 624 void SAL_CALL OButtonControl::propertyChange( const PropertyChangeEvent& _rEvent ) throw ( RuntimeException, std::exception )
 625 {
 626     if  (   _rEvent.PropertyName == PROPERTY_TARGET_URL
 627         ||  _rEvent.PropertyName == PROPERTY_BUTTONTYPE
 628         )
 629     {
 630         modelFeatureUrlPotentiallyChanged( );
 631     }
 632     else if ( _rEvent.PropertyName == PROPERTY_ENABLED )
 633     {
 634         _rEvent.NewValue >>= m_bEnabledByPropertyValue;
 635     }
 636 }
 637
 638
 639 namespace
 640 {
 641     bool isFormControllerURL( const OUString& _rURL )
 642     {
 643         return  ( _rURL.getLength() > RTL_CONSTASCII_LENGTH( ".uno:FormController/" ) )
 644             &&  ( _rURL.startsWith( ".uno:FormController/" ) );
 645     }
 646 }
 647
 648
 649 sal_Int16 OButtonControl::getModelUrlFeatureId( ) const
 650 {
 651     sal_Int16 nFeatureId = -1;
 652
 653     // some URL related properties of the model
 654     OUString sUrl;
 655     FormButtonType eButtonType = FormButtonType_PUSH;
 656
 657     Reference< XPropertySet > xModelProps( const_cast< OButtonControl* >( this )->getModel(), UNO_QUERY );
 658     if ( xModelProps.is() )
 659     {
 660         xModelProps->getPropertyValue( PROPERTY_TARGET_URL ) >>= sUrl;
 661         xModelProps->getPropertyValue( PROPERTY_BUTTONTYPE ) >>= eButtonType;
 662     }
 663
 664     // are we a URL button?
 665     if ( eButtonType == FormButtonType_URL )
 666     {
 667         // is it a feature URL?
 668         if ( isFormControllerURL( sUrl ) )
 669         {
 670             nFeatureId = OFormNavigationMapper::getFeatureId( sUrl );
 671         }
 672     }
 673
 674     return nFeatureId;
 675 }
 676
 677
 678 void SAL_CALL OButtonControl::setDesignMode( sal_Bool _bOn ) throw( RuntimeException, std::exception )
 679 {
 680     OClickableImageBaseControl::setDesignMode( _bOn  );
 681
 682     if ( _bOn )
 683         disconnectDispatchers();
 684     else
 685         connectDispatchers();
 686         // this will connect if not already connected and just update else
 687 }
 688
 689
 690 void OButtonControl::getSupportedFeatures( ::std::vector< sal_Int16 >& /* [out] */ _rFeatureIds )
 691 {
 692     if ( -1 != m_nTargetUrlFeatureId )
 693         _rFeatureIds.push_back( m_nTargetUrlFeatureId );
 694 }
 695
 696
 697 void OButtonControl::featureStateChanged( sal_Int16 _nFeatureId, bool _bEnabled )
 698 {
 699     if ( _nFeatureId == m_nTargetUrlFeatureId )
 700     {
 701         // enable or disable our peer, according to the new state
 702         Reference< XVclWindowPeer > xPeer( getPeer(), UNO_QUERY );
 703         if ( xPeer.is() )
 704             xPeer->setProperty( PROPERTY_ENABLED, makeAny( m_bEnabledByPropertyValue && _bEnabled ) );
 705             // if we're disabled according to our model's property, then
 706             // we don't care for the feature state, but *are* disabled.
 707             // If the model's property states that we're enabled, then we *do*
 708             // care for the feature state
 709     }
 710
 711     // base class
 712     OFormNavigationHelper::featureStateChanged( _nFeatureId, _bEnabled );
 713 }
 714
 715
 716 void OButtonControl::allFeatureStatesChanged( )
 717 {
 718     if ( -1 != m_nTargetUrlFeatureId )
 719         // we have only one supported feature, so simulate it has changed ...
 720         featureStateChanged( m_nTargetUrlFeatureId, isEnabled( m_nTargetUrlFeatureId ) );
 721
 722     // base class
 723     OFormNavigationHelper::allFeatureStatesChanged( );
 724 }
 725
 726
 727 bool OButtonControl::isEnabled( sal_Int16 _nFeatureId ) const
 728 {
 729     if ( const_cast< OButtonControl* >( this )->isDesignMode() )
 730         // TODO: the model property?
 731        return true;
 732
 733     return OFormNavigationHelper::isEnabled( _nFeatureId );
 734 }
 735
 736
 737 void SAL_CALL OButtonControl::registerDispatchProviderInterceptor( const Reference< XDispatchProviderInterceptor >& _rxInterceptor ) throw (RuntimeException, std::exception)
 738 {
 739     OClickableImageBaseControl::registerDispatchProviderInterceptor( _rxInterceptor );
 740     OFormNavigationHelper::registerDispatchProviderInterceptor( _rxInterceptor );
 741 }
 742
 743
 744 void SAL_CALL OButtonControl::releaseDispatchProviderInterceptor( const Reference< XDispatchProviderInterceptor >& _rxInterceptor ) throw (RuntimeException, std::exception)
 745 {
 746     OClickableImageBaseControl::releaseDispatchProviderInterceptor( _rxInterceptor );
 747     OFormNavigationHelper::releaseDispatchProviderInterceptor( _rxInterceptor );
 748 }
 749
 750 }   // namespace frm
 751
 752 extern "C" SAL_DLLPUBLIC_EXPORT ::com::sun::star::uno::XInterface* SAL_CALL
 753 com_sun_star_form_OButtonModel_get_implementation(::com::sun::star::uno::XComponentContext* component,
 754         ::com::sun::star::uno::Sequence<css::uno::Any> const &)
 755 {
 756     return cppu::acquire(new frm::OButtonModel(component));
 757 }
 758
 759 extern "C" SAL_DLLPUBLIC_EXPORT ::com::sun::star::uno::XInterface* SAL_CALL
 760 com_sun_star_form_OButtonControl_get_implementation(::com::sun::star::uno::XComponentContext* component,
 761         ::com::sun::star::uno::Sequence<css::uno::Any> const &)
 762 {
 763     return cppu::acquire(new frm::OButtonControl(component));
 764 }
 765
 766 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */