extensions/source/propctrlr/eventhandler.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_extensions.hxx"
  30
  31 #include "eventhandler.hxx"
  32 #include "propctrlr.hrc"
  33 #include "formbrowsertools.hxx"
  34 #include "formresid.hrc"
  35 #include "formstrings.hxx"
  36 #include "handlerhelper.hxx"
  37 #include "modulepcr.hxx"
  38 #include "pcrcommon.hxx"
  39 #include "pcrstrings.hxx"
  40 #include "propertycontrolextender.hxx"
  41
  42 /** === begin UNO includes === **/
  43 #include <com/sun/star/awt/XTabControllerModel.hpp>
  44 #include <com/sun/star/beans/PropertyAttribute.hpp>
  45 #include <com/sun/star/beans/UnknownPropertyException.hpp>
  46 #include <com/sun/star/beans/XIntrospection.hpp>
  47 #include <com/sun/star/beans/XIntrospectionAccess.hpp>
  48 #include <com/sun/star/container/NoSuchElementException.hpp>
  49 #include <com/sun/star/container/XChild.hpp>
  50 #include <com/sun/star/container/XIndexAccess.hpp>
  51 #include <com/sun/star/container/XNameContainer.hpp>
  52 #include <com/sun/star/container/XNameReplace.hpp>
  53 #include <com/sun/star/form/FormComponentType.hpp>
  54 #include <com/sun/star/form/XForm.hpp>
  55 #include <com/sun/star/form/runtime/XFormController.hpp>
  56 #include <com/sun/star/inspection/PropertyControlType.hpp>
  57 #include <com/sun/star/lang/NullPointerException.hpp>
  58 #include <com/sun/star/script/XEventAttacherManager.hpp>
  59 #include <com/sun/star/script/XScriptEventsSupplier.hpp>
  60 #include <com/sun/star/util/XModifiable.hpp>
  61 #include <com/sun/star/uri/UriReferenceFactory.hpp>
  62 #include <com/sun/star/uri/XVndSunStarScriptUrlReference.hpp>
  63 /** === end UNO includes === **/
  64
  65 #include <comphelper/namedvaluecollection.hxx>
  66 #include <comphelper/evtmethodhelper.hxx>
  67 #include <comphelper/types.hxx>
  68 #include <cppuhelper/implbase1.hxx>
  69 #include <rtl/ref.hxx>
  70 #include <rtl/ustrbuf.hxx>
  71 #include <sfx2/app.hxx>
  72 #include <svl/eitem.hxx>
  73 #include <svl/itemset.hxx>
  74 #include <svx/svxdlg.hxx>
  75 #include <svx/svxids.hrc>
  76 #include <tools/diagnose_ex.h>
  77 #include <vcl/msgbox.hxx>
  78
  79 #include <map>
  80 #include <algorithm>
  81
  82 //------------------------------------------------------------------------
  83 extern "C" void SAL_CALL createRegistryInfo_EventHandler()
  84 {
  85     ::pcr::OAutoRegistration< ::pcr::EventHandler > aAutoRegistration;
  86 }
  87
  88 //........................................................................
  89 namespace pcr
  90 {
  91 //........................................................................
  92
  93     /** === begin UNO using === **/
  94     using ::com::sun::star::uno::Reference;
  95     using ::com::sun::star::uno::XComponentContext;
  96     using ::com::sun::star::beans::XPropertySet;
  97     using ::com::sun::star::uno::Any;
  98     using ::com::sun::star::uno::TypeClass_STRING;
  99     using ::com::sun::star::uno::Type;
 100     using ::com::sun::star::beans::XPropertyChangeListener;
 101     using ::com::sun::star::beans::Property;
 102     using ::com::sun::star::beans::PropertyState;
 103     using ::com::sun::star::beans::PropertyState_DIRECT_VALUE;
 104     using ::com::sun::star::uno::Sequence;
 105     using ::com::sun::star::script::ScriptEventDescriptor;
 106     using ::com::sun::star::script::XScriptEventsSupplier;
 107     using ::com::sun::star::lang::NullPointerException;
 108     using ::com::sun::star::uno::Exception;
 109     using ::com::sun::star::container::XChild;
 110     using ::com::sun::star::container::XIndexAccess;
 111     using ::com::sun::star::script::XEventAttacherManager;
 112     using ::com::sun::star::uno::UNO_QUERY;
 113     using ::com::sun::star::uno::UNO_QUERY_THROW;
 114     using ::com::sun::star::uno::XInterface;
 115     using ::com::sun::star::beans::XIntrospection;
 116     using ::com::sun::star::beans::XIntrospectionAccess;
 117     using ::com::sun::star::container::XNameContainer;
 118     using ::com::sun::star::awt::XTabControllerModel;
 119     using ::com::sun::star::form::XForm;
 120     using ::com::sun::star::form::runtime::XFormController;
 121     using ::com::sun::star::beans::UnknownPropertyException;
 122     using ::com::sun::star::uno::makeAny;
 123     using ::com::sun::star::container::NoSuchElementException;
 124     using ::com::sun::star::beans::XPropertySetInfo;
 125     using ::com::sun::star::container::XNameReplace;
 126     using ::com::sun::star::lang::IllegalArgumentException;
 127     using ::com::sun::star::lang::WrappedTargetException;
 128     using ::com::sun::star::uno::RuntimeException;
 129     using ::com::sun::star::beans::PropertyValue;
 130     using ::com::sun::star::inspection::LineDescriptor;
 131     using ::com::sun::star::inspection::XPropertyControlFactory;
 132     using ::com::sun::star::inspection::InteractiveSelectionResult;
 133     using ::com::sun::star::inspection::InteractiveSelectionResult_Cancelled;
 134     using ::com::sun::star::inspection::InteractiveSelectionResult_Success;
 135     using ::com::sun::star::inspection::XObjectInspectorUI;
 136     using ::com::sun::star::util::XModifiable;
 137     using ::com::sun::star::beans::PropertyChangeEvent;
 138     using ::com::sun::star::frame::XFrame;
 139     using ::com::sun::star::frame::XModel;
 140     using ::com::sun::star::frame::XController;
 141     using ::com::sun::star::uno::UNO_SET_THROW;
 142     using com::sun::star::uri::UriReferenceFactory;
 143     using com::sun::star::uri::XUriReferenceFactory;
 144     using com::sun::star::uri::XVndSunStarScriptUrlReference;
 145     using ::com::sun::star::lang::XEventListener;
 146     /** === end UNO using === **/
 147     namespace PropertyControlType = ::com::sun::star::inspection::PropertyControlType;
 148     namespace PropertyAttribute = ::com::sun::star::beans::PropertyAttribute;
 149     namespace FormComponentType = ::com::sun::star::form::FormComponentType;
 150
 151     //====================================================================
 152     //= EventDescription
 153     //====================================================================
 154     EventDescription::EventDescription( EventId _nId, const sal_Char* _pListenerNamespaceAscii, const sal_Char* _pListenerClassAsciiName,
 155             const sal_Char* _pListenerMethodAsciiName, sal_uInt16 _nDisplayNameResId, const rtl::OString& _sHelpId, const rtl::OString& _sUniqueBrowseId )
 156         :sDisplayName( String( PcrRes( _nDisplayNameResId ) ) )
 157         ,sListenerMethodName( ::rtl::OUString::createFromAscii( _pListenerMethodAsciiName ) )
 158         ,sHelpId( _sHelpId )
 159         ,sUniqueBrowseId( _sUniqueBrowseId )
 160         ,nId( _nId )
 161     {
 162         ::rtl::OUStringBuffer aQualifiedListenerClass;
 163         aQualifiedListenerClass.appendAscii( "com.sun.star." );
 164         aQualifiedListenerClass.appendAscii( _pListenerNamespaceAscii );
 165         aQualifiedListenerClass.appendAscii( "." );
 166         aQualifiedListenerClass.appendAscii( _pListenerClassAsciiName );
 167         sListenerClassName = aQualifiedListenerClass.makeStringAndClear();
 168     }
 169
 170     //========================================================================
 171     //= helper
 172     //========================================================================
 173     namespace
 174     {
 175         //....................................................................
 176         #define DESCRIBE_EVENT( asciinamespace, asciilistener, asciimethod, id_postfix ) \
 177             s_aKnownEvents.insert( EventMap::value_type( \
 178                 ::rtl::OUString::createFromAscii( asciimethod ), \
 179                 EventDescription( ++nEventId, asciinamespace, asciilistener, asciimethod, RID_STR_EVT_##id_postfix, HID_EVT_##id_postfix, UID_BRWEVT_##id_postfix ) ) )
 180
 181         //....................................................................
 182         bool lcl_getEventDescriptionForMethod( const ::rtl::OUString& _rMethodName, EventDescription& _out_rDescription )
 183         {
 184             static EventMap s_aKnownEvents;
 185             if ( s_aKnownEvents.empty() )
 186             {
 187                 ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 188                 if ( s_aKnownEvents.empty() )
 189                 {
 190                     static sal_Int32 nEventId = 0;
 191
 192                     DESCRIBE_EVENT( "form", "XApproveActionListener",       "approveAction",            APPROVEACTIONPERFORMED );
 193                     DESCRIBE_EVENT( "awt",  "XActionListener",              "actionPerformed",          ACTIONPERFORMED );
 194                     DESCRIBE_EVENT( "form", "XChangeListener",              "changed",                  CHANGED );
 195                     DESCRIBE_EVENT( "awt",  "XTextListener",                "textChanged",              TEXTCHANGED );
 196                     DESCRIBE_EVENT( "awt",  "XItemListener",                "itemStateChanged",         ITEMSTATECHANGED );
 197                     DESCRIBE_EVENT( "awt",  "XFocusListener",               "focusGained",              FOCUSGAINED );
 198                     DESCRIBE_EVENT( "awt",  "XFocusListener",               "focusLost",                FOCUSLOST );
 199                     DESCRIBE_EVENT( "awt",  "XKeyListener",                 "keyPressed",               KEYTYPED );
 200                     DESCRIBE_EVENT( "awt",  "XKeyListener",                 "keyReleased",              KEYUP );
 201                     DESCRIBE_EVENT( "awt",  "XMouseListener",               "mouseEntered",             MOUSEENTERED );
 202                     DESCRIBE_EVENT( "awt",  "XMouseMotionListener",         "mouseDragged",             MOUSEDRAGGED );
 203                     DESCRIBE_EVENT( "awt",  "XMouseMotionListener",         "mouseMoved",               MOUSEMOVED );
 204                     DESCRIBE_EVENT( "awt",  "XMouseListener",               "mousePressed",             MOUSEPRESSED );
 205                     DESCRIBE_EVENT( "awt",  "XMouseListener",               "mouseReleased",            MOUSERELEASED );
 206                     DESCRIBE_EVENT( "awt",  "XMouseListener",               "mouseExited",              MOUSEEXITED );
 207                     DESCRIBE_EVENT( "form", "XResetListener",               "approveReset",             APPROVERESETTED );
 208                     DESCRIBE_EVENT( "form", "XResetListener",               "resetted",                 RESETTED );
 209                     DESCRIBE_EVENT( "form", "XSubmitListener",              "approveSubmit",            SUBMITTED );
 210                     DESCRIBE_EVENT( "form", "XUpdateListener",              "approveUpdate",            BEFOREUPDATE );
 211                     DESCRIBE_EVENT( "form", "XUpdateListener",              "updated",                  AFTERUPDATE );
 212                     DESCRIBE_EVENT( "form", "XLoadListener",                "loaded",                   LOADED );
 213                     DESCRIBE_EVENT( "form", "XLoadListener",                "reloading",                RELOADING );
 214                     DESCRIBE_EVENT( "form", "XLoadListener",                "reloaded",                 RELOADED );
 215                     DESCRIBE_EVENT( "form", "XLoadListener",                "unloading",                UNLOADING );
 216                     DESCRIBE_EVENT( "form", "XLoadListener",                "unloaded",                 UNLOADED );
 217                     DESCRIBE_EVENT( "form", "XConfirmDeleteListener",       "confirmDelete",            CONFIRMDELETE );
 218                     DESCRIBE_EVENT( "sdb",  "XRowSetApproveListener",       "approveRowChange",         APPROVEROWCHANGE );
 219                     DESCRIBE_EVENT( "sdbc", "XRowSetListener",              "rowChanged",               ROWCHANGE );
 220                     DESCRIBE_EVENT( "sdb",  "XRowSetApproveListener",       "approveCursorMove",        POSITIONING );
 221                     DESCRIBE_EVENT( "sdbc", "XRowSetListener",              "cursorMoved",              POSITIONED );
 222                     DESCRIBE_EVENT( "form", "XDatabaseParameterListener",   "approveParameter",         APPROVEPARAMETER );
 223                     DESCRIBE_EVENT( "sdb",  "XSQLErrorListener",            "errorOccured",             ERROROCCURED );
 224                     DESCRIBE_EVENT( "awt",  "XAdjustmentListener",          "adjustmentValueChanged",   ADJUSTMENTVALUECHANGED );
 225                 }
 226             }
 227
 228             EventMap::const_iterator pos = s_aKnownEvents.find( _rMethodName );
 229             if ( pos == s_aKnownEvents.end() )
 230                 return false;
 231
 232             _out_rDescription = pos->second;
 233             return true;
 234         }
 235
 236         //....................................................................
 237         ::rtl::OUString lcl_getEventPropertyName( const ::rtl::OUString& _rListenerClassName, const ::rtl::OUString& _rMethodName )
 238         {
 239             ::rtl::OUStringBuffer aPropertyName;
 240             aPropertyName.append( _rListenerClassName );
 241             aPropertyName.append( (sal_Unicode)';' );
 242             aPropertyName.append( _rMethodName.getStr() );
 243             return aPropertyName.makeStringAndClear();
 244         }
 245
 246         //................................................................
 247         ScriptEventDescriptor lcl_getAssignedScriptEvent( const EventDescription& _rEvent, const Sequence< ScriptEventDescriptor >& _rAllAssignedMacros )
 248         {
 249             ScriptEventDescriptor aScriptEvent;
 250             // for the case there is actually no event assigned, initialize at least ListenerType and MethodName,
 251             //  so this ScriptEventDescriptor properly describes the given event
 252             aScriptEvent.ListenerType = _rEvent.sListenerClassName;
 253             aScriptEvent.EventMethod = _rEvent.sListenerMethodName;
 254
 255             const ScriptEventDescriptor* pAssignedEvent = _rAllAssignedMacros.getConstArray();
 256             sal_Int32 assignedEventCount( _rAllAssignedMacros.getLength() );
 257             for ( sal_Int32 assignedEvent = 0; assignedEvent < assignedEventCount; ++assignedEvent, ++pAssignedEvent )
 258             {
 259                 if  (   ( pAssignedEvent->ListenerType != _rEvent.sListenerClassName )
 260                     ||  ( pAssignedEvent->EventMethod != _rEvent.sListenerMethodName )
 261                     )
 262                     continue;
 263
 264                 if  (   ( pAssignedEvent->ScriptCode.getLength() == 0 )
 265                     ||  ( pAssignedEvent->ScriptType.getLength() == 0 )
 266                     )
 267                 {
 268                     DBG_ERROR( "lcl_getAssignedScriptEvent: me thinks this should not happen!" );
 269                     continue;
 270                 }
 271
 272                 aScriptEvent = *pAssignedEvent;
 273
 274                 if ( !aScriptEvent.ScriptType.equalsAscii( "StarBasic" ) )
 275                     continue;
 276
 277                 // this is an old-style macro specification:
 278                 // [document|application]:Library.Module.Function
 279                 // we need to translate this to the new-style macro specification
 280                 // vnd.sun.star.script:Library.Module.Function?language=Basic&location=[document|application]
 281
 282                 sal_Int32 nPrefixLen = aScriptEvent.ScriptCode.indexOf( ':' );
 283                 OSL_ENSURE( nPrefixLen > 0, "lcl_getAssignedScriptEvent: illegal location!" );
 284                 ::rtl::OUString sLocation = aScriptEvent.ScriptCode.copy( 0, nPrefixLen );
 285                 ::rtl::OUString sMacroPath = aScriptEvent.ScriptCode.copy( nPrefixLen + 1 );
 286
 287                 ::rtl::OUStringBuffer aNewStyleSpec;
 288                 aNewStyleSpec.appendAscii( "vnd.sun.star.script:" );
 289                 aNewStyleSpec.append     ( sMacroPath );
 290                 aNewStyleSpec.appendAscii( "?language=Basic&location=" );
 291                 aNewStyleSpec.append     ( sLocation );
 292
 293                 aScriptEvent.ScriptCode = aNewStyleSpec.makeStringAndClear();
 294
 295                 // also, this new-style spec requires the script code to be "Script" instead of "StarBasic"
 296                 aScriptEvent.ScriptType = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Script" ) );
 297             }
 298             return aScriptEvent;
 299         }
 300
 301         //................................................................
 302         ::rtl::OUString lcl_getQualifiedKnownListenerName( const ScriptEventDescriptor& _rFormComponentEventDescriptor )
 303         {
 304             EventDescription aKnownEvent;
 305             if ( lcl_getEventDescriptionForMethod( _rFormComponentEventDescriptor.EventMethod, aKnownEvent ) )
 306                 return aKnownEvent.sListenerClassName;
 307             DBG_ERROR( "lcl_getQualifiedKnownListenerName: unknown method name!" );
 308                 // somebody assigned an script to a form component event which we don't know
 309                 // Speaking strictly, this is not really an error - it is possible to do
 310                 // this programmatically -, but it should rarely happen, since it's not possible
 311                 // via UI
 312             return _rFormComponentEventDescriptor.ListenerType;
 313         }
 314
 315         //................................................................
 316         typedef ::std::set< Type, TypeLessByName > TypeBag;
 317
 318         //................................................................
 319         void lcl_addListenerTypesFor_throw( const Reference< XInterface >& _rxComponent,
 320             const Reference< XIntrospection >& _rxIntrospection, TypeBag& _out_rTypes )
 321         {
 322             if ( !_rxComponent.is() )
 323                 return;
 324             OSL_PRECOND( _rxIntrospection.is(), "lcl_addListenerTypesFor_throw: this will crash!" );
 325
 326             Reference< XIntrospectionAccess > xIntrospectionAccess(
 327                 _rxIntrospection->inspect( makeAny( _rxComponent ) ), UNO_QUERY_THROW );
 328
 329             Sequence< Type > aListeners( xIntrospectionAccess->getSupportedListeners() );
 330
 331             ::std::copy( aListeners.getConstArray(), aListeners.getConstArray() + aListeners.getLength(),
 332                 ::std::insert_iterator< TypeBag >( _out_rTypes, _out_rTypes.begin() ) );
 333         }
 334
 335         //................................................................
 336         bool operator ==( const ScriptEventDescriptor _lhs, const ScriptEventDescriptor _rhs )
 337         {
 338             return  (   ( _lhs.ListenerType         == _rhs.ListenerType        )
 339                     &&  ( _lhs.EventMethod          == _rhs.EventMethod         )
 340                     &&  ( _lhs.AddListenerParam     == _rhs.AddListenerParam    )
 341                     &&  ( _lhs.ScriptType           == _rhs.ScriptType          )
 342                     &&  ( _lhs.ScriptCode           == _rhs.ScriptCode          )
 343                     );
 344         }
 345     }
 346
 347     //====================================================================
 348     //= EventHandler
 349     //====================================================================
 350     typedef ::cppu::WeakImplHelper1 <   ::com::sun::star::container::XNameReplace
 351                                     >   EventHolder_Base;
 352     /** a UNO component holding assigned event descriptions, for use with a SvxMacroAssignDlg
 353     */
 354     class EventHolder : public EventHolder_Base
 355     {
 356     private:
 357         typedef ::std::hash_map< ::rtl::OUString, ScriptEventDescriptor, ::rtl::OUStringHash >  EventMap;
 358         typedef ::std::map< EventId, EventMap::iterator >                                       EventMapIndexAccess;
 359
 360         EventMap            m_aEventNameAccess;
 361         EventMapIndexAccess m_aEventIndexAccess;
 362
 363     public:
 364         EventHolder( );
 365
 366         void addEvent( EventId _nId, const ::rtl::OUString& _rEventName, const ScriptEventDescriptor& _rScriptEvent );
 367
 368         /** effectively the same as getByName, but instead of converting the ScriptEventDescriptor to the weird
 369             format used by the macro assignment dialog, it is returned directly
 370         */
 371         ScriptEventDescriptor getNormalizedDescriptorByName( const ::rtl::OUString& _rEventName ) const;
 372
 373         // XNameReplace
 374         virtual void SAL_CALL replaceByName( const ::rtl::OUString& _rName, const Any& aElement ) throw (IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException);
 375         virtual Any SAL_CALL getByName( const ::rtl::OUString& _rName ) throw (NoSuchElementException, WrappedTargetException, RuntimeException);
 376         virtual Sequence< ::rtl::OUString > SAL_CALL getElementNames(  ) throw (RuntimeException);
 377         virtual ::sal_Bool SAL_CALL hasByName( const ::rtl::OUString& _rName ) throw (RuntimeException);
 378         virtual Type SAL_CALL getElementType(  ) throw (RuntimeException);
 379         virtual ::sal_Bool SAL_CALL hasElements(  ) throw (RuntimeException);
 380
 381     protected:
 382         ~EventHolder( );
 383
 384     private:
 385         ScriptEventDescriptor impl_getDescriptor_throw( const ::rtl::OUString& _rEventName ) const;
 386     };
 387
 388     DBG_NAME( EventHolder )
 389     //------------------------------------------------------------------------
 390     EventHolder::EventHolder()
 391     {
 392         DBG_CTOR( EventHolder, NULL );
 393     }
 394
 395     //------------------------------------------------------------------------
 396     EventHolder::~EventHolder()
 397     {
 398         m_aEventNameAccess.clear();
 399         m_aEventIndexAccess.clear();
 400         DBG_DTOR( EventHolder, NULL );
 401     }
 402
 403     //------------------------------------------------------------------------
 404     void EventHolder::addEvent( EventId _nId, const ::rtl::OUString& _rEventName, const ScriptEventDescriptor& _rScriptEvent )
 405     {
 406         ::std::pair< EventMap::iterator, bool > insertionResult =
 407             m_aEventNameAccess.insert( EventMap::value_type( _rEventName, _rScriptEvent ) );
 408         OSL_ENSURE( insertionResult.second, "EventHolder::addEvent: there already was a MacroURL for this event!" );
 409         m_aEventIndexAccess[ _nId ] = insertionResult.first;
 410     }
 411
 412     //------------------------------------------------------------------------
 413     ScriptEventDescriptor EventHolder::getNormalizedDescriptorByName( const ::rtl::OUString& _rEventName ) const
 414     {
 415         return impl_getDescriptor_throw( _rEventName );
 416     }
 417
 418     //------------------------------------------------------------------------
 419     ScriptEventDescriptor EventHolder::impl_getDescriptor_throw( const ::rtl::OUString& _rEventName ) const
 420     {
 421         EventMap::const_iterator pos = m_aEventNameAccess.find( _rEventName );
 422         if ( pos == m_aEventNameAccess.end() )
 423             throw NoSuchElementException( ::rtl::OUString(), *const_cast< EventHolder* >( this ) );
 424         return pos->second;
 425     }
 426
 427     //------------------------------------------------------------------------
 428     void SAL_CALL EventHolder::replaceByName( const ::rtl::OUString& _rName, const Any& _rElement ) throw (IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException)
 429     {
 430         EventMap::iterator pos = m_aEventNameAccess.find( _rName );
 431         if ( pos == m_aEventNameAccess.end() )
 432             throw NoSuchElementException( ::rtl::OUString(), *this );
 433
 434         Sequence< PropertyValue > aScriptDescriptor;
 435         OSL_VERIFY( _rElement >>= aScriptDescriptor );
 436
 437         ::comphelper::NamedValueCollection aExtractor( aScriptDescriptor );
 438
 439         pos->second.ScriptType = aExtractor.getOrDefault( "EventType", ::rtl::OUString() );
 440         pos->second.ScriptCode = aExtractor.getOrDefault( "Script", ::rtl::OUString() );
 441     }
 442
 443     //------------------------------------------------------------------------
 444     Any SAL_CALL EventHolder::getByName( const ::rtl::OUString& _rName ) throw (NoSuchElementException, WrappedTargetException, RuntimeException)
 445     {
 446         ScriptEventDescriptor aDescriptor( impl_getDescriptor_throw( _rName ) );
 447
 448         Any aRet;
 449         Sequence< PropertyValue > aScriptDescriptor( 2 );
 450         aScriptDescriptor[0].Name = ::rtl::OUString::createFromAscii( "EventType" );
 451         aScriptDescriptor[0].Value <<= aDescriptor.ScriptType;
 452         aScriptDescriptor[1].Name = ::rtl::OUString::createFromAscii( "Script" );
 453         aScriptDescriptor[1].Value <<= aDescriptor.ScriptCode;
 454
 455         return makeAny( aScriptDescriptor );
 456     }
 457
 458     //------------------------------------------------------------------------
 459     Sequence< ::rtl::OUString > SAL_CALL EventHolder::getElementNames(  ) throw (RuntimeException)
 460     {
 461         Sequence< ::rtl::OUString > aReturn( m_aEventIndexAccess.size() );
 462         ::rtl::OUString* pReturn = aReturn.getArray();
 463
 464         // SvxMacroAssignDlg has a weird API: It expects a XNameReplace, means a container whose
 465         // main access method is by name. In it's UI, it shows the possible events in exactly the
 466         // order in which XNameAccess::getElementNames returns them.
 467         // However, SvxMacroAssignDlg *also* takes an index for the initial selection, which is
 468         // relative to the sequence returned by XNameAccess::getElementNames.
 469         // This is IMO weird, since it mixes index access with name access, which decreases efficiency
 470         // of the implementation.
 471         // Well, it means we're forced to return the events in getElementNames in exactly the same as they
 472         // appear in the property browser UI.
 473         for (   EventMapIndexAccess::const_iterator loop = m_aEventIndexAccess.begin();
 474                 loop != m_aEventIndexAccess.end();
 475                 ++loop, ++pReturn
 476             )
 477             *pReturn = loop->second->first;
 478         return aReturn;
 479     }
 480
 481      //------------------------------------------------------------------------
 482     sal_Bool SAL_CALL EventHolder::hasByName( const ::rtl::OUString& _rName ) throw (RuntimeException)
 483     {
 484         EventMap::const_iterator pos = m_aEventNameAccess.find( _rName );
 485         return pos != m_aEventNameAccess.end();
 486     }
 487
 488     //------------------------------------------------------------------------
 489     Type SAL_CALL EventHolder::getElementType(  ) throw (RuntimeException)
 490     {
 491         return ::getCppuType( static_cast< Sequence< PropertyValue >* >( NULL ) );
 492     }
 493
 494     //------------------------------------------------------------------------
 495     sal_Bool SAL_CALL EventHolder::hasElements(  ) throw (RuntimeException)
 496     {
 497         return !m_aEventNameAccess.empty();
 498     }
 499
 500
 501     //====================================================================
 502     //= EventHandler
 503     //====================================================================
 504     DBG_NAME( EventHandler )
 505     //--------------------------------------------------------------------
 506     EventHandler::EventHandler( const Reference< XComponentContext >& _rxContext )
 507         :EventHandler_Base( m_aMutex )
 508         ,m_aContext( _rxContext )
 509         ,m_aPropertyListeners( m_aMutex )
 510         ,m_bEventsMapInitialized( false )
 511         ,m_bIsDialogElement( false )
 512         ,m_nGridColumnType( -1 )
 513     {
 514         DBG_CTOR( EventHandler, NULL );
 515     }
 516
 517     //--------------------------------------------------------------------
 518     EventHandler::~EventHandler()
 519     {
 520         DBG_DTOR( EventHandler, NULL );
 521     }
 522
 523     //--------------------------------------------------------------------
 524     ::rtl::OUString SAL_CALL EventHandler::getImplementationName(  ) throw (RuntimeException)
 525     {
 526         return getImplementationName_static();
 527     }
 528
 529     //--------------------------------------------------------------------
 530     ::sal_Bool SAL_CALL EventHandler::supportsService( const ::rtl::OUString& ServiceName ) throw (RuntimeException)
 531     {
 532         StlSyntaxSequence< ::rtl::OUString > aAllServices( getSupportedServiceNames() );
 533         return ::std::find( aAllServices.begin(), aAllServices.end(), ServiceName ) != aAllServices.end();
 534     }
 535
 536     //--------------------------------------------------------------------
 537     Sequence< ::rtl::OUString > SAL_CALL EventHandler::getSupportedServiceNames(  ) throw (RuntimeException)
 538     {
 539         return getSupportedServiceNames_static();
 540     }
 541
 542     //--------------------------------------------------------------------
 543     ::rtl::OUString SAL_CALL EventHandler::getImplementationName_static(  ) throw (RuntimeException)
 544     {
 545         return ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.extensions.EventHandler" ) );
 546     }
 547
 548     //--------------------------------------------------------------------
 549     Sequence< ::rtl::OUString > SAL_CALL EventHandler::getSupportedServiceNames_static(  ) throw (RuntimeException)
 550     {
 551         Sequence< ::rtl::OUString > aSupported( 1 );
 552         aSupported[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.form.inspection.EventHandler" ) );
 553         return aSupported;
 554     }
 555
 556     //--------------------------------------------------------------------
 557     Reference< XInterface > SAL_CALL EventHandler::Create( const Reference< XComponentContext >& _rxContext )
 558     {
 559         return *( new EventHandler( _rxContext ) );
 560     }
 561
 562     //--------------------------------------------------------------------
 563     void SAL_CALL EventHandler::inspect( const Reference< XInterface >& _rxIntrospectee ) throw (RuntimeException, NullPointerException)
 564     {
 565         ::osl::MutexGuard aGuard( m_aMutex );
 566
 567         if ( !_rxIntrospectee.is() )
 568             throw NullPointerException();
 569
 570         m_xComponent = Reference< XPropertySet >( _rxIntrospectee, UNO_QUERY_THROW );
 571
 572         m_bEventsMapInitialized = false;
 573         EventMap aEmpty;
 574         m_aEvents.swap( aEmpty );
 575
 576         m_bIsDialogElement = false;
 577         m_nGridColumnType = -1;
 578         try
 579         {
 580             Reference< XPropertySetInfo > xPSI( m_xComponent->getPropertySetInfo() );
 581             m_bIsDialogElement = xPSI.is()
 582                               && xPSI->hasPropertyByName( PROPERTY_WIDTH )
 583                               && xPSI->hasPropertyByName( PROPERTY_HEIGHT )
 584                               && xPSI->hasPropertyByName( PROPERTY_POSITIONX )
 585                               && xPSI->hasPropertyByName( PROPERTY_POSITIONY );
 586
 587             Reference< XChild > xAsChild( _rxIntrospectee, UNO_QUERY );
 588             if ( xAsChild.is() && !Reference< XForm >( _rxIntrospectee, UNO_QUERY ).is() )
 589             {
 590                 if ( FormComponentType::GRIDCONTROL == classifyComponent( xAsChild->getParent() ) )
 591                 {
 592                     m_nGridColumnType = classifyComponent( _rxIntrospectee );
 593                 }
 594             }
 595         }
 596         catch( const Exception& )
 597         {
 598             DBG_UNHANDLED_EXCEPTION();
 599         }
 600     }
 601
 602     //--------------------------------------------------------------------
 603     Any SAL_CALL EventHandler::getPropertyValue( const ::rtl::OUString& _rPropertyName ) throw (UnknownPropertyException, RuntimeException)
 604     {
 605         ::osl::MutexGuard aGuard( m_aMutex );
 606
 607         const EventDescription& rEvent = impl_getEventForName_throw( _rPropertyName );
 608
 609         Sequence< ScriptEventDescriptor > aEvents;
 610         impl_getComponentScriptEvents_nothrow( aEvents );
 611
 612         sal_Int32 nEventCount = aEvents.getLength();
 613         const ScriptEventDescriptor* pEvents = aEvents.getConstArray();
 614
 615         ScriptEventDescriptor aPropertyValue;
 616         for ( sal_Int32 event = 0; event < nEventCount; ++event, ++pEvents )
 617         {
 618             if  (   rEvent.sListenerClassName == pEvents->ListenerType
 619                 &&  rEvent.sListenerMethodName == pEvents->EventMethod
 620                 )
 621             {
 622                 aPropertyValue = *pEvents;
 623                 break;
 624             }
 625         }
 626
 627         return makeAny( aPropertyValue );
 628     }
 629
 630     //--------------------------------------------------------------------
 631     void SAL_CALL EventHandler::setPropertyValue( const ::rtl::OUString& _rPropertyName, const Any& _rValue ) throw (UnknownPropertyException, RuntimeException)
 632     {
 633         ::osl::MutexGuard aGuard( m_aMutex );
 634
 635         const EventDescription& rEvent = impl_getEventForName_throw( _rPropertyName );
 636
 637         ScriptEventDescriptor aNewScriptEvent;
 638         OSL_VERIFY( _rValue >>= aNewScriptEvent );
 639
 640         ScriptEventDescriptor aOldScriptEvent;
 641         OSL_VERIFY( getPropertyValue( _rPropertyName ) >>= aOldScriptEvent );
 642         if ( aOldScriptEvent == aNewScriptEvent )
 643             return;
 644
 645         if ( m_bIsDialogElement )
 646             impl_setDialogElementScriptEvent_nothrow( aNewScriptEvent );
 647         else
 648             impl_setFormComponentScriptEvent_nothrow( aNewScriptEvent );
 649
 650         Reference< XModifiable > xDoc( m_aContext.getContextValueByAsciiName( "ContextDocument" ), UNO_QUERY );
 651         if ( xDoc.is() )
 652             xDoc->setModified( sal_True );
 653
 654         PropertyChangeEvent aEvent;
 655         aEvent.Source = m_xComponent;
 656         aEvent.PropertyHandle = rEvent.nId;
 657         aEvent.PropertyName = _rPropertyName;
 658         aEvent.OldValue <<= aOldScriptEvent;
 659         aEvent.NewValue <<= aNewScriptEvent;
 660         m_aPropertyListeners.notify( aEvent, &XPropertyChangeListener::propertyChange );
 661     }
 662
 663     //--------------------------------------------------------------------
 664     Any SAL_CALL EventHandler::convertToPropertyValue( const ::rtl::OUString& _rPropertyName, const Any& _rControlValue ) throw (UnknownPropertyException, RuntimeException)
 665     {
 666         ::osl::MutexGuard aGuard( m_aMutex );
 667
 668         ::rtl::OUString sNewScriptCode;
 669         OSL_VERIFY( _rControlValue >>= sNewScriptCode );
 670
 671         Sequence< ScriptEventDescriptor > aAllAssignedEvents;
 672         impl_getComponentScriptEvents_nothrow( aAllAssignedEvents );
 673
 674         const EventDescription& rEvent = impl_getEventForName_throw( _rPropertyName );
 675         ScriptEventDescriptor aAssignedScript = lcl_getAssignedScriptEvent( rEvent, aAllAssignedEvents );
 676
 677         OSL_ENSURE( !sNewScriptCode.getLength(), "EventHandler::convertToPropertyValue: cannot convert a non-empty display name!" );
 678         // Usually, there is no possibility for the user to change the content of an event binding directly in the
 679         // input field, this instead is done with the macro assignment dialog.
 680         // The only exception is the user pressing "DEL" while the control has the focus, in this case, we reset the
 681         // control content to an empty string. So this is the only scenario where this method is allowed to be called.
 682
 683         // Striclty, we would be able to convert the display value to a property value,
 684         // using the "name (location, language)" format we used in convertToControlValue. However,
 685         // there is no need for this code ...
 686
 687         aAssignedScript.ScriptCode = sNewScriptCode;
 688         return makeAny( aAssignedScript );
 689     }
 690
 691     //--------------------------------------------------------------------
 692     Any SAL_CALL EventHandler::convertToControlValue( const ::rtl::OUString& /*_rPropertyName*/, const Any& _rPropertyValue, const Type& _rControlValueType ) throw (UnknownPropertyException, RuntimeException)
 693     {
 694         ::osl::MutexGuard aGuard( m_aMutex );
 695
 696         ScriptEventDescriptor aScriptEvent;
 697         OSL_VERIFY( _rPropertyValue >>= aScriptEvent );
 698
 699         OSL_ENSURE( _rControlValueType.getTypeClass() == TypeClass_STRING,
 700             "EventHandler::convertToControlValue: unexpected ControlValue type class!" );
 701         (void)_rControlValueType;
 702
 703         ::rtl::OUString sScript( aScriptEvent.ScriptCode );
 704         if ( sScript.getLength() )
 705         {
 706             // format is: "name (location, language)"
 707             try
 708             {
 709                 // parse
 710                 Reference< XUriReferenceFactory > xUriRefFac = UriReferenceFactory::create( m_aContext.getUNOContext() );
 711                 Reference< XVndSunStarScriptUrlReference > xScriptUri( xUriRefFac->parse( sScript ), UNO_QUERY_THROW );
 712
 713                 ::rtl::OUStringBuffer aComposeBuffer;
 714
 715                 // name
 716                 aComposeBuffer.append( xScriptUri->getName() );
 717
 718                 // location
 719                 const ::rtl::OUString sLocationParamName( RTL_CONSTASCII_USTRINGPARAM( "location" ) );
 720                 const ::rtl::OUString sLocation = xScriptUri->getParameter( sLocationParamName );
 721                 const ::rtl::OUString sLangParamName( RTL_CONSTASCII_USTRINGPARAM( "language" ) );
 722                 const ::rtl::OUString sLanguage = xScriptUri->getParameter( sLangParamName );
 723
 724                 if ( sLocation.getLength() || sLanguage.getLength() )
 725                 {
 726                     aComposeBuffer.appendAscii( " (" );
 727
 728                     // location
 729                     OSL_ENSURE( sLocation.getLength(), "EventHandler::convertToControlValue: unexpected: no location!" );
 730                     if ( sLocation.getLength() )
 731                     {
 732                         aComposeBuffer.append( sLocation );
 733                         aComposeBuffer.appendAscii( ", " );
 734                     }
 735
 736                     // language
 737                     if ( sLanguage.getLength() )
 738                     {
 739                         aComposeBuffer.append( sLanguage );
 740                     }
 741
 742                     aComposeBuffer.append( sal_Unicode( ')' ) );
 743                 }
 744
 745                 sScript = aComposeBuffer.makeStringAndClear();
 746             }
 747             catch( const Exception& )
 748             {
 749                 DBG_UNHANDLED_EXCEPTION();
 750             }
 751         }
 752
 753         return makeAny( sScript );
 754     }
 755
 756     //--------------------------------------------------------------------
 757     PropertyState SAL_CALL EventHandler::getPropertyState( const ::rtl::OUString& /*_rPropertyName*/ ) throw (UnknownPropertyException, RuntimeException)
 758     {
 759         return PropertyState_DIRECT_VALUE;
 760     }
 761
 762     //--------------------------------------------------------------------
 763     void SAL_CALL EventHandler::addPropertyChangeListener( const Reference< XPropertyChangeListener >& _rxListener ) throw (RuntimeException)
 764     {
 765         ::osl::MutexGuard aGuard( m_aMutex );
 766         if ( !_rxListener.is() )
 767             throw NullPointerException();
 768         m_aPropertyListeners.addListener( _rxListener );
 769     }
 770
 771     //--------------------------------------------------------------------
 772     void SAL_CALL EventHandler::removePropertyChangeListener( const Reference< XPropertyChangeListener >& _rxListener ) throw (RuntimeException)
 773     {
 774         ::osl::MutexGuard aGuard( m_aMutex );
 775         m_aPropertyListeners.removeListener( _rxListener );
 776     }
 777
 778     //--------------------------------------------------------------------
 779     Sequence< Property > SAL_CALL EventHandler::getSupportedProperties() throw (RuntimeException)
 780     {
 781         ::osl::MutexGuard aGuard( m_aMutex );
 782         if ( !m_bEventsMapInitialized )
 783         {
 784             const_cast< EventHandler* >( this )->m_bEventsMapInitialized = true;
 785             try
 786             {
 787                 Sequence< Type > aListeners;
 788                 impl_getCopmonentListenerTypes_nothrow( aListeners );
 789                 sal_Int32 listenerCount = aListeners.getLength();
 790
 791                 Property aCurrentProperty;
 792                 ::rtl::OUString sListenerClassName;
 793
 794                 // loop through all listeners and all methods, and see which we can present at the UI
 795                 const Type* pListeners = aListeners.getConstArray();
 796                 for ( sal_Int32 listener = 0; listener < listenerCount; ++listener, ++pListeners )
 797                 {
 798                     aCurrentProperty = Property();
 799
 800                     // the programmatic name of the listener, to be used as "property" name
 801                     sListenerClassName = pListeners->getTypeName();
 802                     OSL_ENSURE( sListenerClassName.getLength(), "EventHandler::getSupportedProperties: strange - no listener name ..." );
 803                     if ( !sListenerClassName.getLength() )
 804                         continue;
 805
 806                     // loop through all methods
 807                     Sequence< ::rtl::OUString > aMethods( comphelper::getEventMethodsForType( *pListeners ) );
 808
 809                     const ::rtl::OUString* pMethods = aMethods.getConstArray();
 810                     sal_uInt32 methodCount = aMethods.getLength();
 811
 812                     for (sal_uInt32 method = 0 ; method < methodCount ; ++method, ++pMethods )
 813                     {
 814                         EventDescription aEvent;
 815                         if ( !lcl_getEventDescriptionForMethod( *pMethods, aEvent ) )
 816                             continue;
 817
 818                         if ( !impl_filterMethod_nothrow( aEvent ) )
 819                             continue;
 820
 821                         const_cast< EventHandler* >( this )->m_aEvents.insert( EventMap::value_type(
 822                             lcl_getEventPropertyName( sListenerClassName, *pMethods ), aEvent ) );
 823                     }
 824                 }
 825
 826             }
 827             catch( const Exception& )
 828             {
 829                 DBG_UNHANDLED_EXCEPTION();
 830             }
 831         }
 832
 833         // sort them by ID - this is the relative ordering in the UI
 834         ::std::map< EventId, Property > aOrderedProperties;
 835         for (   EventMap::const_iterator loop = m_aEvents.begin();
 836                 loop != m_aEvents.end();
 837                 ++loop
 838             )
 839         {
 840             aOrderedProperties[ loop->second.nId ] = Property(
 841                 loop->first, loop->second.nId,
 842                 ::getCppuType( static_cast< const ::rtl::OUString* >( NULL ) ),
 843                 PropertyAttribute::BOUND );
 844         }
 845
 846         StlSyntaxSequence< Property > aReturn( aOrderedProperties.size() );
 847         ::std::transform( aOrderedProperties.begin(), aOrderedProperties.end(), aReturn.begin(),
 848             ::std::select2nd< ::std::map< EventId, Property >::value_type >() );
 849         return aReturn;
 850     }
 851
 852     //--------------------------------------------------------------------
 853     Sequence< ::rtl::OUString > SAL_CALL EventHandler::getSupersededProperties( ) throw (RuntimeException)
 854     {
 855         // none
 856         return Sequence< ::rtl::OUString >( );
 857     }
 858
 859     //--------------------------------------------------------------------
 860     Sequence< ::rtl::OUString > SAL_CALL EventHandler::getActuatingProperties( ) throw (RuntimeException)
 861     {
 862         // none
 863         return Sequence< ::rtl::OUString >( );
 864     }
 865
 866     //--------------------------------------------------------------------
 867     LineDescriptor SAL_CALL EventHandler::describePropertyLine( const ::rtl::OUString& _rPropertyName,
 868         const Reference< XPropertyControlFactory >& _rxControlFactory )
 869         throw (UnknownPropertyException, NullPointerException, RuntimeException)
 870     {
 871         if ( !_rxControlFactory.is() )
 872             throw NullPointerException();
 873
 874         ::osl::MutexGuard aGuard( m_aMutex );
 875
 876         LineDescriptor aDescriptor;
 877
 878         aDescriptor.Control = _rxControlFactory->createPropertyControl( PropertyControlType::TextField, sal_True );
 879         Reference< XEventListener > xControlExtender = new PropertyControlExtender( aDescriptor.Control );
 880
 881         const EventDescription& rEvent = impl_getEventForName_throw( _rPropertyName );
 882         aDescriptor.DisplayName = rEvent.sDisplayName;
 883         aDescriptor.HelpURL = HelpIdUrl::getHelpURL( rEvent.sHelpId );
 884         aDescriptor.PrimaryButtonId = rtl::OStringToOUString(rEvent.sUniqueBrowseId, RTL_TEXTENCODING_UTF8);
 885         aDescriptor.HasPrimaryButton = sal_True;
 886         aDescriptor.Category = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Events" ) );
 887         return aDescriptor;
 888     }
 889
 890     //--------------------------------------------------------------------
 891     ::sal_Bool SAL_CALL EventHandler::isComposable( const ::rtl::OUString& /*_rPropertyName*/ ) throw (UnknownPropertyException, RuntimeException)
 892     {
 893         return sal_False;
 894     }
 895
 896     //--------------------------------------------------------------------
 897     InteractiveSelectionResult SAL_CALL EventHandler::onInteractivePropertySelection( const ::rtl::OUString& _rPropertyName, sal_Bool /*_bPrimary*/, Any& /*_rData*/, const Reference< XObjectInspectorUI >& _rxInspectorUI ) throw (UnknownPropertyException, NullPointerException, RuntimeException)
 898     {
 899         if ( !_rxInspectorUI.is() )
 900             throw NullPointerException();
 901
 902         ::osl::MutexGuard aGuard( m_aMutex );
 903         const EventDescription& rForEvent = impl_getEventForName_throw( _rPropertyName );
 904
 905         Sequence< ScriptEventDescriptor > aAllAssignedEvents;
 906         impl_getComponentScriptEvents_nothrow( aAllAssignedEvents );
 907
 908         // SvxMacroAssignDlg-compatible structure holding all event/assignments
 909         ::rtl::Reference< EventHolder >  pEventHolder( new EventHolder );
 910
 911         for (   EventMap::const_iterator event = m_aEvents.begin();
 912                 event != m_aEvents.end();
 913                 ++event
 914             )
 915         {
 916             // the script which is assigned to the current event (if any)
 917             ScriptEventDescriptor aAssignedScript = lcl_getAssignedScriptEvent( event->second, aAllAssignedEvents );
 918             pEventHolder->addEvent( event->second.nId, event->second.sListenerMethodName, aAssignedScript );
 919         }
 920
 921         // the inital selection in the dialog
 922         Sequence< ::rtl::OUString > aNames( pEventHolder->getElementNames() );
 923         const ::rtl::OUString* pChosenEvent = ::std::find( aNames.getConstArray(), aNames.getConstArray() + aNames.getLength(), rForEvent.sListenerMethodName );
 924         sal_uInt16 nInitialSelection = (sal_uInt16)( pChosenEvent - aNames.getConstArray() );
 925
 926         // the dialog
 927         SvxAbstractDialogFactory* pFactory = SvxAbstractDialogFactory::Create();
 928         if ( !pFactory )
 929             return InteractiveSelectionResult_Cancelled;
 930
 931         ::std::auto_ptr< VclAbstractDialog > pDialog( pFactory->CreateSvxMacroAssignDlg(
 932             PropertyHandlerHelper::getDialogParentWindow( m_aContext ),
 933             impl_getContextFrame_nothrow(),
 934             m_bIsDialogElement,
 935             pEventHolder.get(),
 936             nInitialSelection
 937         ) );
 938
 939         if ( !pDialog.get() )
 940             return InteractiveSelectionResult_Cancelled;
 941
 942         // DF definite problem here
 943         // OK & Cancel seem to be both returning 0
 944         if ( pDialog->Execute() == RET_CANCEL )
 945             return InteractiveSelectionResult_Cancelled;
 946
 947         try
 948         {
 949             for (   EventMap::const_iterator event = m_aEvents.begin();
 950                     event != m_aEvents.end();
 951                     ++event
 952                 )
 953             {
 954                 ScriptEventDescriptor aScriptDescriptor( pEventHolder->getNormalizedDescriptorByName( event->second.sListenerMethodName ) );
 955
 956                 // set the new "property value"
 957                 setPropertyValue(
 958                     lcl_getEventPropertyName( event->second.sListenerClassName, event->second.sListenerMethodName ),
 959                     makeAny( aScriptDescriptor )
 960                 );
 961             }
 962         }
 963         catch( const Exception& )
 964         {
 965             DBG_UNHANDLED_EXCEPTION();
 966         }
 967
 968         return InteractiveSelectionResult_Success;
 969     }
 970
 971     //--------------------------------------------------------------------
 972     void SAL_CALL EventHandler::actuatingPropertyChanged( const ::rtl::OUString& /*_rActuatingPropertyName*/, const Any& /*_rNewValue*/, const Any& /*_rOldValue*/, const Reference< XObjectInspectorUI >& /*_rxInspectorUI*/, sal_Bool /*_bFirstTimeInit*/ ) throw (NullPointerException, RuntimeException)
 973     {
 974         DBG_ERROR( "EventHandler::actuatingPropertyChanged: no actuating properties -> no callback (well, this is how it *should* be!)" );
 975     }
 976
 977     //--------------------------------------------------------------------
 978     IMPLEMENT_FORWARD_XCOMPONENT( EventHandler, EventHandler_Base )
 979
 980     //--------------------------------------------------------------------
 981     void SAL_CALL EventHandler::disposing()
 982     {
 983         EventMap aEmpty;
 984         m_aEvents.swap( aEmpty );
 985         m_xComponent.clear();
 986     }
 987
 988     //--------------------------------------------------------------------
 989     sal_Bool SAL_CALL EventHandler::suspend( sal_Bool /*_bSuspend*/ ) throw (RuntimeException)
 990     {
 991         return sal_True;
 992     }
 993
 994     //------------------------------------------------------------------------
 995     Reference< XFrame > EventHandler::impl_getContextFrame_nothrow() const
 996     {
 997         Reference< XFrame > xContextFrame;
 998
 999         try
1000         {
1001             Reference< XModel > xContextDocument( m_aContext.getContextValueByAsciiName( "ContextDocument" ), UNO_QUERY_THROW );
1002             Reference< XController > xController( xContextDocument->getCurrentController(), UNO_SET_THROW );
1003             xContextFrame.set( xController->getFrame(), UNO_SET_THROW );
1004         }
1005         catch( const Exception& )
1006         {
1007             DBG_UNHANDLED_EXCEPTION();
1008         }
1009
1010         return xContextFrame;
1011     }
1012
1013     //--------------------------------------------------------------------
1014     sal_Int32 EventHandler::impl_getComponentIndexInParent_throw() const
1015     {
1016         Reference< XChild > xChild( m_xComponent, UNO_QUERY_THROW );
1017         Reference< XIndexAccess > xParentAsIndexAccess( xChild->getParent(), UNO_QUERY_THROW );
1018
1019         // get the index of the inspected object within it's parent container
1020         sal_Int32 nElements = xParentAsIndexAccess->getCount();
1021         for ( sal_Int32 i=0; i<nElements; ++i )
1022         {
1023             Reference< XInterface > xElement( xParentAsIndexAccess->getByIndex( i ), UNO_QUERY_THROW );
1024             if ( xElement == m_xComponent )
1025                 return i;
1026         }
1027         throw NoSuchElementException();
1028     }
1029
1030     //--------------------------------------------------------------------
1031     void EventHandler::impl_getFormComponentScriptEvents_nothrow( Sequence < ScriptEventDescriptor >& _out_rEvents ) const
1032     {
1033         _out_rEvents = Sequence < ScriptEventDescriptor >();
1034         try
1035         {
1036             Reference< XChild > xChild( m_xComponent, UNO_QUERY_THROW );
1037             Reference< XEventAttacherManager > xEventManager( xChild->getParent(), UNO_QUERY_THROW );
1038             _out_rEvents = xEventManager->getScriptEvents( impl_getComponentIndexInParent_throw() );
1039
1040             // the form component script API has unqualified listener names, but for normalization
1041             // purpose, we want fully qualified ones
1042             ScriptEventDescriptor* pEvents = _out_rEvents.getArray();
1043             ScriptEventDescriptor* pEventsEnd = _out_rEvents.getArray() + _out_rEvents.getLength();
1044             while ( pEvents != pEventsEnd )
1045             {
1046                 pEvents->ListenerType = lcl_getQualifiedKnownListenerName( *pEvents );
1047                 ++pEvents;
1048             }
1049         }
1050         catch( const Exception& )
1051         {
1052             DBG_UNHANDLED_EXCEPTION();
1053         }
1054     }
1055
1056     //--------------------------------------------------------------------
1057     void EventHandler::impl_getCopmonentListenerTypes_nothrow( Sequence< Type >& _out_rTypes ) const
1058     {
1059         _out_rTypes.realloc( 0 );
1060         try
1061         {
1062             // we use a set to avoid duplicates
1063             TypeBag aListeners;
1064
1065             Reference< XIntrospection > xIntrospection( m_aContext.createComponent( "com.sun.star.beans.Introspection" ), UNO_QUERY_THROW );
1066
1067             // --- model listeners
1068             lcl_addListenerTypesFor_throw(
1069                 m_xComponent, xIntrospection, aListeners );
1070
1071             // --- "secondary component" (usually: "control" listeners)
1072             {
1073                 Reference< XInterface > xSecondaryComponent( impl_getSecondaryComponentForEventInspection_throw() );
1074                 lcl_addListenerTypesFor_throw( xSecondaryComponent, xIntrospection, aListeners );
1075                 ::comphelper::disposeComponent( xSecondaryComponent );
1076             }
1077
1078             // now that they're disambiguated, copy these types into our member
1079             _out_rTypes.realloc( aListeners.size() );
1080             ::std::copy( aListeners.begin(), aListeners.end(), _out_rTypes.getArray() );
1081         }
1082         catch( const Exception& )
1083         {
1084             DBG_UNHANDLED_EXCEPTION();
1085         }
1086     }
1087
1088     //--------------------------------------------------------------------
1089     void EventHandler::impl_getDialogElementScriptEvents_nothrow( Sequence < ScriptEventDescriptor >& _out_rEvents ) const
1090     {
1091         _out_rEvents = Sequence < ScriptEventDescriptor >();
1092         try
1093         {
1094             Reference< XScriptEventsSupplier > xEventsSupplier( m_xComponent, UNO_QUERY_THROW );
1095             Reference< XNameContainer > xEvents( xEventsSupplier->getEvents(), UNO_QUERY_THROW );
1096             Sequence< ::rtl::OUString > aEventNames( xEvents->getElementNames() );
1097
1098             sal_Int32 nEventCount = aEventNames.getLength();
1099             _out_rEvents.realloc( nEventCount );
1100
1101             const ::rtl::OUString* pNames = aEventNames.getConstArray();
1102             ScriptEventDescriptor* pDescs = _out_rEvents.getArray();
1103
1104             for( sal_Int32 i = 0 ; i < nEventCount ; ++i, ++pNames, ++pDescs )
1105                 OSL_VERIFY( xEvents->getByName( *pNames ) >>= *pDescs );
1106         }
1107         catch( const Exception& )
1108         {
1109             DBG_UNHANDLED_EXCEPTION();
1110         }
1111     }
1112
1113     //--------------------------------------------------------------------
1114     Reference< XInterface > EventHandler::impl_getSecondaryComponentForEventInspection_throw( ) const
1115     {
1116         Reference< XInterface > xReturn;
1117
1118         // if it's a form, create a form controller for the additional events
1119         Reference< XForm > xComponentAsForm( m_xComponent, UNO_QUERY );
1120         if ( xComponentAsForm.is() )
1121         {
1122             Reference< XTabControllerModel > xComponentAsTCModel( m_xComponent, UNO_QUERY_THROW );
1123             Reference< XFormController > xController(
1124                 m_aContext.createComponent( "com.sun.star.form.runtime.FormController" ), UNO_QUERY_THROW );
1125             xController->setModel( xComponentAsTCModel );
1126
1127             xReturn = xController;
1128         }
1129         else
1130         {
1131             ::rtl::OUString sControlService;
1132             OSL_VERIFY( m_xComponent->getPropertyValue( PROPERTY_DEFAULTCONTROL ) >>= sControlService );
1133
1134             xReturn = m_aContext.createComponent( sControlService );
1135         }
1136         return xReturn;
1137     }
1138
1139     //--------------------------------------------------------------------
1140     const EventDescription& EventHandler::impl_getEventForName_throw( const ::rtl::OUString& _rPropertyName ) const
1141     {
1142         EventMap::const_iterator pos = m_aEvents.find( _rPropertyName );
1143         if ( pos == m_aEvents.end() )
1144             throw UnknownPropertyException();
1145         return pos->second;
1146     }
1147
1148     //--------------------------------------------------------------------
1149     namespace
1150     {
1151         static bool lcl_endsWith( const ::rtl::OUString& _rText, const ::rtl::OUString& _rCheck )
1152         {
1153             sal_Int32 nTextLen = _rText.getLength();
1154             sal_Int32 nCheckLen = _rCheck.getLength();
1155             if ( nCheckLen > nTextLen )
1156                 return false;
1157
1158             return _rText.indexOf( _rCheck ) == ( nTextLen - nCheckLen );
1159         }
1160     }
1161     //--------------------------------------------------------------------
1162     void EventHandler::impl_setFormComponentScriptEvent_nothrow( const ScriptEventDescriptor& _rScriptEvent )
1163     {
1164         try
1165         {
1166             ::rtl::OUString sScriptCode( _rScriptEvent.ScriptCode );
1167             ::rtl::OUString sScriptType( _rScriptEvent.ScriptType );
1168             bool bResetScript = ( sScriptCode.getLength() == 0 );
1169
1170             sal_Int32 nObjectIndex = impl_getComponentIndexInParent_throw();
1171             Reference< XChild > xChild( m_xComponent, UNO_QUERY_THROW );
1172             Reference< XEventAttacherManager > xEventManager( xChild->getParent(), UNO_QUERY_THROW );
1173             Sequence< ScriptEventDescriptor > aEvents( xEventManager->getScriptEvents( nObjectIndex ) );
1174
1175             // is there already a registered script for this event?
1176             ScriptEventDescriptor* pEvent = aEvents.getArray();
1177             sal_Int32 eventCount = aEvents.getLength(), event = 0;
1178             for ( event = 0; event < eventCount; ++event, ++pEvent )
1179             {
1180                 if  (   ( pEvent->EventMethod == _rScriptEvent.EventMethod )
1181                     &&  ( lcl_endsWith( _rScriptEvent.ListenerType, pEvent->ListenerType ) )
1182                           // (strange enough, the events we get from getScriptEvents are not fully qualified)
1183                     )
1184                 {
1185                     // yes
1186                     if ( !bResetScript )
1187                     {
1188                         // set to something non-empty -> overwrite
1189                         pEvent->ScriptCode = sScriptCode;
1190                         pEvent->ScriptType = sScriptType;
1191                     }
1192                     else
1193                     {
1194                         // set to empty -> remove from sequence
1195                         ::std::copy( pEvent + 1, aEvents.getArray() + eventCount, pEvent );
1196                         aEvents.realloc( eventCount - 1 );
1197                         --eventCount;
1198                     }
1199                     break;
1200                 }
1201             }
1202             if ( ( event >= eventCount ) && !bResetScript )
1203             {
1204                 // no, did not find it -> append
1205                 aEvents.realloc( eventCount + 1 );
1206                 aEvents[ eventCount ] = _rScriptEvent;
1207             }
1208
1209             xEventManager->revokeScriptEvents( nObjectIndex );
1210             xEventManager->registerScriptEvents( nObjectIndex, aEvents );
1211
1212             PropertyHandlerHelper::setContextDocumentModified( m_aContext );
1213         }
1214         catch( const Exception& )
1215         {
1216             DBG_UNHANDLED_EXCEPTION();
1217         }
1218     }
1219
1220     //--------------------------------------------------------------------
1221     void EventHandler::impl_setDialogElementScriptEvent_nothrow( const ScriptEventDescriptor& _rScriptEvent )
1222     {
1223         try
1224         {
1225             ::rtl::OUString sScriptCode( _rScriptEvent.ScriptCode );
1226             bool bResetScript = ( sScriptCode.getLength() == 0 );
1227
1228             Reference< XScriptEventsSupplier > xEventsSupplier( m_xComponent, UNO_QUERY_THROW );
1229             Reference< XNameContainer > xEvents( xEventsSupplier->getEvents(), UNO_QUERY_THROW );
1230
1231             ::rtl::OUStringBuffer aCompleteName;
1232             aCompleteName.append( _rScriptEvent.ListenerType );
1233             aCompleteName.appendAscii( "::" );
1234             aCompleteName.append( _rScriptEvent.EventMethod );
1235             ::rtl::OUString sCompleteName( aCompleteName.makeStringAndClear() );
1236
1237             bool bExists = xEvents->hasByName( sCompleteName );
1238
1239             if ( bResetScript )
1240             {
1241                 if ( bExists )
1242                     xEvents->removeByName( sCompleteName );
1243             }
1244             else
1245             {
1246                 Any aNewValue; aNewValue <<= _rScriptEvent;
1247
1248                 if ( bExists )
1249                     xEvents->replaceByName( sCompleteName, aNewValue );
1250                 else
1251                     xEvents->insertByName( sCompleteName, aNewValue );
1252             }
1253         }
1254         catch( const Exception& )
1255         {
1256             DBG_UNHANDLED_EXCEPTION();
1257         }
1258     }
1259
1260     //--------------------------------------------------------------------
1261     bool EventHandler::impl_filterMethod_nothrow( const EventDescription& _rEvent ) const
1262     {
1263         // some (control-triggered) events do not make sense for certain grid control columns. However,
1264         // our mechnism to retrieve control-triggered events does not know about this, so we do some
1265         // late filtering here.
1266         switch ( m_nGridColumnType )
1267         {
1268         case FormComponentType::COMBOBOX:
1269             if ( UID_BRWEVT_ACTIONPERFORMED == _rEvent.sUniqueBrowseId )
1270                 return false;
1271             break;
1272         case FormComponentType::LISTBOX:
1273             if  (   ( UID_BRWEVT_CHANGED == _rEvent.sUniqueBrowseId )
1274                 ||  ( UID_BRWEVT_ACTIONPERFORMED == _rEvent.sUniqueBrowseId )
1275                 )
1276                 return false;
1277             break;
1278         }
1279
1280         return true;
1281     }
1282
1283 //........................................................................
1284 } // namespace pcr
1285 //........................................................................
1286