extensions/source/propctrlr/propcontroller.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: propcontroller.cxx,v $
  10  * $Revision: 1.41.66.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_extensions.hxx"
  33 #include "propcontroller.hxx"
  34 #include "pcrstrings.hxx"
  35 #include "standardcontrol.hxx"
  36 #include "linedescriptor.hxx"
  37 #ifndef EXTENSIONS_PROPRESID_HRC
  38 #include "propresid.hrc"
  39 #endif
  40 #ifndef _EXTENSIONS_FORMCTRLR_PROPRESID_HRC_
  41 #include "formresid.hrc"
  42 #endif
  43 #include "propertyeditor.hxx"
  44 #ifndef _EXTENSIONS_PROPCTRLR_MODULEPRC_HXX_
  45 #include "modulepcr.hxx"
  46 #endif
  47 #include "formstrings.hxx"
  48 #include "formmetadata.hxx"
  49 #include "formbrowsertools.hxx"
  50 #include "propertycomposer.hxx"
  51
  52 /** === begin UNO includes === **/
  53 #include <com/sun/star/awt/XWindow.hpp>
  54 #include <com/sun/star/util/XCloseable.hpp>
  55 #include <com/sun/star/inspection/PropertyControlType.hpp>
  56 #include <com/sun/star/ucb/AlreadyInitializedException.hpp>
  57 /** === end UNO includes === **/
  58 #include <tools/debug.hxx>
  59 #include <tools/diagnose_ex.h>
  60 #include <comphelper/types.hxx>
  61 #include <comphelper/extract.hxx>
  62 #include <toolkit/awt/vclxwindow.hxx>
  63 #ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_
  64 #include <toolkit/unohlp.hxx>
  65 #endif
  66 #include <comphelper/property.hxx>
  67 #include <vcl/msgbox.hxx>
  68 #include <vcl/svapp.hxx>
  69 #include <vos/mutex.hxx>
  70 #include <cppuhelper/component_context.hxx>
  71 #include <cppuhelper/exc_hlp.hxx>
  72
  73 #include <algorithm>
  74 #include <functional>
  75
  76 //------------------------------------------------------------------------
  77 // !!! outside the namespace !!!
  78 extern "C" void SAL_CALL createRegistryInfo_OPropertyBrowserController()
  79 {
  80     ::pcr::OAutoRegistration< ::pcr::OPropertyBrowserController > aAutoRegistration;
  81 }
  82
  83 //............................................................................
  84 namespace pcr
  85 {
  86 //............................................................................
  87
  88     using namespace ::com::sun::star;
  89     using namespace ::com::sun::star::uno;
  90     using namespace ::com::sun::star::awt;
  91     using namespace ::com::sun::star::form;
  92     using namespace ::com::sun::star::beans;
  93     using namespace ::com::sun::star::script;
  94     using namespace ::com::sun::star::lang;
  95     using namespace ::com::sun::star::container;
  96     using namespace ::com::sun::star::frame;
  97     using namespace ::com::sun::star::util;
  98     using namespace ::com::sun::star::inspection;
  99     using namespace ::com::sun::star::ucb;
 100     using namespace ::comphelper;
 101
 102 #define THISREF()       static_cast< XController* >(this)
 103
 104     //========================================================================
 105     //= OPropertyBrowserController
 106     //========================================================================
 107     DBG_NAME(OPropertyBrowserController)
 108     //------------------------------------------------------------------------
 109     OPropertyBrowserController::OPropertyBrowserController( const Reference< XComponentContext >& _rxContext )
 110             :m_aContext(_rxContext)
 111             ,m_aDisposeListeners( m_aMutex )
 112             ,m_aControlObservers( m_aMutex )
 113             ,m_pView(NULL)
 114             ,m_bContainerFocusListening( false )
 115             ,m_bSuspendingPropertyHandlers( false )
 116             ,m_bConstructed( false )
 117             ,m_bBindingIntrospectee( false )
 118     {
 119         DBG_CTOR(OPropertyBrowserController,NULL);
 120     }
 121
 122     //------------------------------------------------------------------------
 123     OPropertyBrowserController::~OPropertyBrowserController()
 124     {
 125         // stop listening for property changes
 126         acquire();
 127         stopInspection( true );
 128         DBG_DTOR(OPropertyBrowserController,NULL);
 129     }
 130
 131     //------------------------------------------------------------------------
 132     IMPLEMENT_FORWARD_REFCOUNT( OPropertyBrowserController, OPropertyBrowserController_Base )
 133
 134     //------------------------------------------------------------------------
 135     Any SAL_CALL OPropertyBrowserController::queryInterface( const Type& _rType ) throw (RuntimeException)
 136     {
 137         Any aReturn = OPropertyBrowserController_Base::queryInterface( _rType );
 138         if ( !aReturn.hasValue() )
 139             aReturn = ::cppu::queryInterface(
 140                 _rType,
 141                 static_cast< XObjectInspectorUI* >( this )
 142             );
 143         return aReturn;
 144     }
 145
 146     //------------------------------------------------------------------------
 147     void OPropertyBrowserController::startContainerWindowListening()
 148     {
 149         if (m_bContainerFocusListening)
 150             return;
 151
 152         if (m_xFrame.is())
 153         {
 154             Reference< XWindow > xContainerWindow = m_xFrame->getContainerWindow();
 155             if (xContainerWindow.is())
 156             {
 157                 xContainerWindow->addFocusListener(this);
 158                 m_bContainerFocusListening = sal_True;
 159             }
 160         }
 161
 162         DBG_ASSERT(m_bContainerFocusListening, "OPropertyBrowserController::startContainerWindowListening: unable to start listening (inconsistence)!");
 163     }
 164
 165     //------------------------------------------------------------------------
 166     void OPropertyBrowserController::stopContainerWindowListening()
 167     {
 168         if (!m_bContainerFocusListening)
 169             return;
 170
 171         if (m_xFrame.is())
 172         {
 173             Reference< XWindow > xContainerWindow = m_xFrame->getContainerWindow();
 174             if (xContainerWindow.is())
 175             {
 176                 xContainerWindow->removeFocusListener(this);
 177                 m_bContainerFocusListening = sal_False;
 178             }
 179         }
 180
 181         DBG_ASSERT(!m_bContainerFocusListening, "OPropertyBrowserController::stopContainerWindowListening: unable to stop listening (inconsistence)!");
 182     }
 183
 184     //--------------------------------------------------------------------
 185     Reference< XObjectInspectorModel > SAL_CALL OPropertyBrowserController::getInspectorModel() throw (RuntimeException)
 186     {
 187         return m_xModel;
 188     }
 189
 190     //--------------------------------------------------------------------
 191     void OPropertyBrowserController::impl_initializeView_nothrow()
 192     {
 193         OSL_PRECOND( haveView(), "OPropertyBrowserController::impl_initializeView_nothrow: not to be called when we have no view!" );
 194         if ( !haveView() )
 195             return;
 196
 197         if ( !m_xModel.is() )
 198             // allowed
 199             return;
 200
 201         try
 202         {
 203             getPropertyBox().EnableHelpSection( m_xModel->getHasHelpSection() );
 204             getPropertyBox().SetHelpLineLimites( m_xModel->getMinHelpTextLines(), m_xModel->getMaxHelpTextLines() );
 205         }
 206         catch( const Exception& )
 207         {
 208             DBG_UNHANDLED_EXCEPTION();
 209         }
 210     }
 211
 212     //--------------------------------------------------------------------
 213     void OPropertyBrowserController::impl_updateReadOnlyView_nothrow()
 214     {
 215         // this is a huge cudgel, admitted.
 216         // The problem is that in case we were previously read-only, all our controls
 217         // were created read-only, too. We cannot simply switch them to not-read-only.
 218         // Even if they had an API for this, we do not know whether they were
 219         // originally created read-only, or if they are read-only just because
 220         // the model was.
 221         impl_rebindToInspectee_nothrow( m_aInspectedObjects );
 222     }
 223
 224     //--------------------------------------------------------------------
 225     bool OPropertyBrowserController::impl_isReadOnlyModel_throw() const
 226     {
 227         if ( !m_xModel.is() )
 228             return false;
 229
 230         return m_xModel->getIsReadOnly();
 231     }
 232
 233     //--------------------------------------------------------------------
 234     void OPropertyBrowserController::impl_startOrStopModelListening_nothrow( bool _bDoListen ) const
 235     {
 236         try
 237         {
 238             Reference< XPropertySet > xModelProperties( m_xModel, UNO_QUERY );
 239             if ( !xModelProperties.is() )
 240                 // okay, so the model doesn't want to change its properties
 241                 // dynamically - fine with us
 242                 return;
 243
 244             void (SAL_CALL XPropertySet::*pListenerOperation)( const ::rtl::OUString&, const Reference< XPropertyChangeListener >& )
 245                 = _bDoListen ? &XPropertySet::addPropertyChangeListener : &XPropertySet::removePropertyChangeListener;
 246
 247             (xModelProperties.get()->*pListenerOperation)(
 248                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsReadOnly" ) ),
 249                 const_cast< OPropertyBrowserController* >( this )
 250             );
 251         }
 252         catch( const Exception& )
 253         {
 254             DBG_UNHANDLED_EXCEPTION();
 255         }
 256     }
 257
 258     //--------------------------------------------------------------------
 259     void OPropertyBrowserController::impl_bindToNewModel_nothrow( const Reference< XObjectInspectorModel >& _rxInspectorModel )
 260     {
 261         impl_startOrStopModelListening_nothrow( false );
 262         m_xModel = _rxInspectorModel;
 263         impl_startOrStopModelListening_nothrow( true );
 264
 265         // initialize the view, if we already have one
 266         if ( haveView() )
 267             impl_initializeView_nothrow();
 268
 269         // inspect again, if we already have inspectees
 270         if ( !m_aInspectedObjects.empty() )
 271             impl_rebindToInspectee_nothrow( m_aInspectedObjects );
 272     }
 273
 274     //--------------------------------------------------------------------
 275     void SAL_CALL OPropertyBrowserController::setInspectorModel( const Reference< XObjectInspectorModel >& _inspectorModel ) throw (RuntimeException)
 276     {
 277         ::osl::MutexGuard aGuard( m_aMutex );
 278
 279         if ( m_xModel == _inspectorModel )
 280             return;
 281
 282         impl_bindToNewModel_nothrow( _inspectorModel );
 283     }
 284
 285     //--------------------------------------------------------------------
 286     Reference< XObjectInspectorUI > SAL_CALL OPropertyBrowserController::getInspectorUI() throw (RuntimeException)
 287     {
 288         // we're derived from this interface, though we do not expose it in queryInterface and getTypes.
 289         return this;
 290     }
 291
 292     //--------------------------------------------------------------------
 293     void SAL_CALL OPropertyBrowserController::inspect( const Sequence< Reference< XInterface > >& _rObjects ) throw (com::sun::star::util::VetoException, RuntimeException)
 294     {
 295         ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 296         ::osl::MutexGuard aGuard( m_aMutex );
 297
 298         if ( m_bSuspendingPropertyHandlers || !suspendAll_nothrow() )
 299         {   // we already are trying to suspend the component (this is somewhere up the stack)
 300             // OR one of our property handlers raised a veto against closing. Well, we *need* to close
 301             // it in order to inspect another object.
 302             throw VetoException();
 303         }
 304         if ( m_bBindingIntrospectee )
 305             throw VetoException();
 306
 307         m_bBindingIntrospectee = true;
 308         impl_rebindToInspectee_nothrow( InterfaceArray( _rObjects.getConstArray(), _rObjects.getConstArray() + _rObjects.getLength() ) );
 309         m_bBindingIntrospectee = false;
 310
 311     }
 312
 313     //--------------------------------------------------------------------
 314     Reference< XDispatch > SAL_CALL OPropertyBrowserController::queryDispatch( const URL& /*URL*/, const ::rtl::OUString& /*TargetFrameName*/, ::sal_Int32 /*SearchFlags*/ ) throw (RuntimeException)
 315     {
 316         // we don't have any dispatches at all, right now
 317         return Reference< XDispatch >();
 318     }
 319
 320     //--------------------------------------------------------------------
 321     Sequence< Reference< XDispatch > > SAL_CALL OPropertyBrowserController::queryDispatches( const Sequence< DispatchDescriptor >& Requests ) throw (RuntimeException)
 322     {
 323         Sequence< Reference< XDispatch > > aReturn;
 324         sal_Int32 nLen = Requests.getLength();
 325         aReturn.realloc( nLen );
 326
 327                 Reference< XDispatch >* pReturn         = aReturn.getArray();
 328         const   Reference< XDispatch >* pReturnEnd      = aReturn.getArray() + nLen;
 329         const   DispatchDescriptor*     pDescripts      = Requests.getConstArray();
 330
 331         for ( ; pReturn != pReturnEnd; ++ pReturn, ++pDescripts )
 332             *pReturn = queryDispatch( pDescripts->FeatureURL, pDescripts->FrameName, pDescripts->SearchFlags );
 333
 334         return aReturn;
 335     }
 336
 337     //------------------------------------------------------------------------
 338     void SAL_CALL OPropertyBrowserController::initialize( const Sequence< Any >& _arguments ) throw (Exception, RuntimeException)
 339     {
 340         if ( m_bConstructed )
 341             throw AlreadyInitializedException();
 342
 343         StlSyntaxSequence< Any > arguments( _arguments );
 344         if ( arguments.empty() )
 345         {   // constructor: "createDefault()"
 346             createDefault();
 347             return;
 348         }
 349
 350         Reference< XObjectInspectorModel > xModel;
 351         if ( arguments.size() == 1 )
 352         {   // constructor: "createWithModel( XObjectInspectorModel )"
 353             if ( !( arguments[0] >>= xModel ) )
 354                 throw IllegalArgumentException( ::rtl::OUString(), *this, 0 );
 355             createWithModel( xModel );
 356             return;
 357         }
 358
 359         throw IllegalArgumentException( ::rtl::OUString(), *this, 0 );
 360     }
 361
 362     //------------------------------------------------------------------------
 363     void OPropertyBrowserController::createDefault()
 364     {
 365         m_bConstructed = true;
 366     }
 367
 368     //------------------------------------------------------------------------
 369     void OPropertyBrowserController::createWithModel( const Reference< XObjectInspectorModel >& _rxModel )
 370     {
 371         osl_incrementInterlockedCount( &m_refCount );
 372         {
 373             setInspectorModel( _rxModel );
 374         }
 375         osl_decrementInterlockedCount( &m_refCount );
 376
 377         m_bConstructed = true;
 378     }
 379
 380     //------------------------------------------------------------------------
 381     void SAL_CALL OPropertyBrowserController::attachFrame( const Reference< XFrame >& _rxFrame ) throw(RuntimeException)
 382     {
 383         ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 384         ::osl::MutexGuard aGuard( m_aMutex );
 385
 386         if (_rxFrame.is() && haveView())
 387             throw RuntimeException(::rtl::OUString::createFromAscii("Unable to attach to a second frame."),*this);
 388
 389         // revoke as focus listener from the old container window
 390         stopContainerWindowListening();
 391
 392         m_xFrame = _rxFrame;
 393         if (!m_xFrame.is())
 394             return;
 395
 396         // TODO: this construction perhaps should be done outside. Don't know the exact meaning of attachFrame.
 397         // Maybe it is intended to only announce the frame to the controller, and the instance doing this
 398         // announcement is responsible for calling setComponent, too.
 399         Reference< XWindow > xContainerWindow = m_xFrame->getContainerWindow();
 400         VCLXWindow*     pContainerWindow = VCLXWindow::GetImplementation(xContainerWindow);
 401         Window* pParentWin = pContainerWindow ? pContainerWindow->GetWindow() : NULL;
 402         if (!pParentWin)
 403             throw RuntimeException(::rtl::OUString::createFromAscii("The frame is invalid. Unable to extract the container window."),*this);
 404
 405         if ( Construct( pParentWin ) )
 406         {
 407             try
 408             {
 409                 m_xFrame->setComponent( VCLUnoHelper::GetInterface( m_pView ), this );
 410             }
 411             catch( const Exception& )
 412             {
 413                 OSL_ENSURE( sal_False, "OPropertyBrowserController::attachFrame: caught an exception!" );
 414             }
 415         }
 416
 417         startContainerWindowListening();
 418
 419         UpdateUI();
 420     }
 421
 422     //------------------------------------------------------------------------
 423     sal_Bool SAL_CALL OPropertyBrowserController::attachModel( const Reference< XModel >& _rxModel ) throw(RuntimeException)
 424     {
 425         Reference< XObjectInspectorModel > xModel( _rxModel, UNO_QUERY );
 426         if ( !xModel.is() )
 427             return false;
 428
 429         setInspectorModel( xModel );
 430         return getInspectorModel() == _rxModel;
 431     }
 432
 433     //------------------------------------------------------------------------
 434     sal_Bool OPropertyBrowserController::suspendAll_nothrow()
 435     {
 436         // if there is a handle inside its "onInteractivePropertySelection" method,
 437         // then veto
 438         // Normally, we could expect every handler to do this itself, but being
 439         // realistic, it's safer to handle this here in general.
 440         if ( m_xInteractiveHandler.is() )
 441             return sal_False;
 442
 443         m_bSuspendingPropertyHandlers = true;
 444         sal_Bool bHandlerVeto = !suspendPropertyHandlers_nothrow( sal_True );
 445         m_bSuspendingPropertyHandlers = false;
 446         if ( bHandlerVeto )
 447             return sal_False;
 448
 449         return sal_True;
 450     }
 451
 452     //------------------------------------------------------------------------
 453     sal_Bool OPropertyBrowserController::suspendPropertyHandlers_nothrow( sal_Bool _bSuspend )
 454     {
 455         PropertyHandlerArray aAllHandlers;  // will contain every handler exactly once
 456         for (   PropertyHandlerRepository::const_iterator handler = m_aPropertyHandlers.begin();
 457                 handler != m_aPropertyHandlers.end();
 458                 ++handler
 459             )
 460         {
 461             if ( ::std::find( aAllHandlers.begin(), aAllHandlers.end(), handler->second ) != aAllHandlers.end() )
 462                 // already visited this particular handler (m_aPropertyHandlers usually contains
 463                 // the same handler more than once)
 464                 continue;
 465             aAllHandlers.push_back( handler->second );
 466         }
 467
 468         for ( PropertyHandlerArray::iterator loop = aAllHandlers.begin();
 469               loop != aAllHandlers.end();
 470               ++loop
 471             )
 472         {
 473             try
 474             {
 475                 if ( !(*loop)->suspend( _bSuspend ) )
 476                     if ( _bSuspend )
 477                         // if we're not suspending, but reactivating, ignore the error
 478                         return sal_False;
 479             }
 480             catch( const Exception& )
 481             {
 482                 OSL_ENSURE( sal_False, "OPropertyBrowserController::suspendPropertyHandlers_nothrow: caught an exception!" );
 483             }
 484         }
 485         return sal_True;
 486     }
 487
 488     //------------------------------------------------------------------------
 489     sal_Bool SAL_CALL OPropertyBrowserController::suspend( sal_Bool _bSuspend ) throw(RuntimeException)
 490     {
 491         ::osl::MutexGuard aGuard( m_aMutex );
 492         OSL_ENSURE( haveView(), "OPropertyBrowserController::suspend: don't have a view anymore!" );
 493
 494         if ( !_bSuspend )
 495         {   // this means a "suspend" is to be "revoked"
 496             suspendPropertyHandlers_nothrow( sal_False );
 497             // we ourself cannot revoke our suspend
 498             return sal_False;
 499         }
 500
 501         if ( !suspendAll_nothrow() )
 502             return sal_False;
 503
 504         // commit the editor's content
 505         if ( haveView() )
 506             getPropertyBox().CommitModified();
 507
 508         // stop listening
 509         stopContainerWindowListening();
 510
 511         // outtahere
 512         return sal_True;
 513     }
 514
 515     //------------------------------------------------------------------------
 516     Any SAL_CALL OPropertyBrowserController::getViewData(  ) throw(RuntimeException)
 517     {
 518         return makeAny( m_sPageSelection );
 519     }
 520
 521     //------------------------------------------------------------------------
 522     void SAL_CALL OPropertyBrowserController::restoreViewData( const Any& Data ) throw(RuntimeException)
 523     {
 524         ::rtl::OUString sPageSelection;
 525         if ( ( Data >>= sPageSelection ) && sPageSelection.getLength() )
 526         {
 527             m_sPageSelection = sPageSelection;
 528             selectPageFromViewData();
 529         }
 530     }
 531
 532     //------------------------------------------------------------------------
 533     Reference< XModel > SAL_CALL OPropertyBrowserController::getModel(  ) throw(RuntimeException)
 534     {
 535         // have no model
 536         return Reference< XModel >();
 537     }
 538
 539     //------------------------------------------------------------------------
 540     Reference< XFrame > SAL_CALL OPropertyBrowserController::getFrame(  ) throw(RuntimeException)
 541     {
 542         return m_xFrame;
 543     }
 544
 545     //------------------------------------------------------------------------
 546     void SAL_CALL OPropertyBrowserController::dispose(  ) throw(RuntimeException)
 547     {
 548         ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
 549
 550         // stop inspecting the current object
 551         stopInspection( false );
 552
 553         // say our dispose listeners goodbye
 554         ::com::sun::star::lang::EventObject aEvt;
 555         aEvt.Source = static_cast< ::cppu::OWeakObject* >(this);
 556         m_aDisposeListeners.disposeAndClear(aEvt);
 557         m_aControlObservers.disposeAndClear(aEvt);
 558
 559         // don't delete explicitly (this is done by the frame we reside in)
 560         m_pView = NULL;
 561
 562         Reference< XComponent > xViewAsComp( m_xView, UNO_QUERY );
 563         if ( xViewAsComp.is() )
 564             xViewAsComp->removeEventListener( static_cast< XPropertyChangeListener* >( this ) );
 565         m_xView.clear( );
 566
 567         m_aInspectedObjects.clear();
 568         impl_bindToNewModel_nothrow( NULL );
 569     }
 570
 571     //------------------------------------------------------------------------
 572     void SAL_CALL OPropertyBrowserController::addEventListener( const Reference< XEventListener >& _rxListener ) throw(RuntimeException)
 573     {
 574         m_aDisposeListeners.addInterface(_rxListener);
 575     }
 576
 577     //------------------------------------------------------------------------
 578     void SAL_CALL OPropertyBrowserController::removeEventListener( const Reference< XEventListener >& _rxListener ) throw(RuntimeException)
 579     {
 580         m_aDisposeListeners.removeInterface(_rxListener);
 581     }
 582
 583     //------------------------------------------------------------------------
 584     ::rtl::OUString SAL_CALL OPropertyBrowserController::getImplementationName(  ) throw(RuntimeException)
 585     {
 586         return getImplementationName_static();
 587     }
 588
 589     //------------------------------------------------------------------------
 590     sal_Bool SAL_CALL OPropertyBrowserController::supportsService( const ::rtl::OUString& ServiceName ) throw(RuntimeException)
 591     {
 592         Sequence< ::rtl::OUString > aSupported(getSupportedServiceNames());
 593         const ::rtl::OUString* pArray = aSupported.getConstArray();
 594         for (sal_Int32 i = 0; i < aSupported.getLength(); ++i, ++pArray)
 595             if (pArray->equals(ServiceName))
 596                 return sal_True;
 597         return sal_False;
 598     }
 599
 600     //------------------------------------------------------------------------
 601     Sequence< ::rtl::OUString > SAL_CALL OPropertyBrowserController::getSupportedServiceNames(  ) throw(RuntimeException)
 602     {
 603         return getSupportedServiceNames_static();
 604     }
 605
 606     //------------------------------------------------------------------------
 607     ::rtl::OUString OPropertyBrowserController::getImplementationName_static(  ) throw(RuntimeException)
 608     {
 609         return ::rtl::OUString::createFromAscii("org.openoffice.comp.extensions.ObjectInspector");
 610     }
 611
 612     //------------------------------------------------------------------------
 613     Sequence< ::rtl::OUString > OPropertyBrowserController::getSupportedServiceNames_static(  ) throw(RuntimeException)
 614     {
 615         Sequence< ::rtl::OUString > aSupported(1);
 616         aSupported[0] = ::rtl::OUString::createFromAscii( "com.sun.star.inspection.ObjectInspector" );
 617         return aSupported;
 618     }
 619
 620     //------------------------------------------------------------------------
 621     Reference< XInterface > SAL_CALL OPropertyBrowserController::Create(const Reference< XComponentContext >& _rxContext)
 622     {
 623         return *(new OPropertyBrowserController( _rxContext ) );
 624     }
 625
 626     //------------------------------------------------------------------------
 627     void SAL_CALL OPropertyBrowserController::focusGained( const FocusEvent& _rSource ) throw (RuntimeException)
 628     {
 629         Reference< XWindow > xSourceWindow(_rSource.Source, UNO_QUERY);
 630         Reference< XWindow > xContainerWindow;
 631         if (m_xFrame.is())
 632             xContainerWindow = m_xFrame->getContainerWindow();
 633
 634         if ( xContainerWindow.get() == xSourceWindow.get() )
 635         {       // our container window got the focus
 636             if ( haveView() )
 637                 getPropertyBox().GrabFocus();
 638         }
 639     }
 640
 641     //------------------------------------------------------------------------
 642     void SAL_CALL OPropertyBrowserController::focusLost( const FocusEvent& /*_rSource*/ ) throw (RuntimeException)
 643     {
 644         // not interested in
 645     }
 646
 647     //------------------------------------------------------------------------
 648     void SAL_CALL OPropertyBrowserController::disposing( const EventObject& _rSource ) throw(RuntimeException)
 649     {
 650         if ( m_xView.is() && ( m_xView == _rSource.Source ) )
 651         {
 652             m_xView = NULL;
 653             m_pView = NULL;
 654         }
 655
 656         for (   InterfaceArray::iterator loop = m_aInspectedObjects.begin();
 657                 loop != m_aInspectedObjects.end();
 658                 ++loop
 659             )
 660         {
 661             if ( *loop == _rSource.Source )
 662             {
 663                 m_aInspectedObjects.erase( loop );
 664                 break;
 665             }
 666         }
 667     }
 668
 669     //------------------------------------------------------------------------
 670     IMPL_LINK(OPropertyBrowserController, OnPageActivation, void*, EMPTYARG)
 671     {
 672         updateViewDataFromActivePage();
 673         return 0L;
 674     }
 675
 676     //------------------------------------------------------------------------
 677     void OPropertyBrowserController::updateViewDataFromActivePage()
 678     {
 679         if (!haveView())
 680             return;
 681
 682         ::rtl::OUString sOldSelection = m_sPageSelection;
 683         m_sPageSelection = ::rtl::OUString();
 684
 685         const sal_uInt16 nCurrentPage = m_pView->getActivaPage();
 686         if ( (sal_uInt16)-1 != nCurrentPage )
 687         {
 688             for (   HashString2Int16::const_iterator pageId = m_aPageIds.begin();
 689                     pageId != m_aPageIds.end();
 690                     ++pageId
 691                 )
 692             {
 693                 if ( nCurrentPage == pageId->second )
 694                 {
 695                     m_sPageSelection = pageId->first;
 696                     break;
 697                 }
 698             }
 699         }
 700
 701         if ( m_sPageSelection.getLength() )
 702             m_sLastValidPageSelection = m_sPageSelection;
 703         else if ( sOldSelection.getLength() )
 704             m_sLastValidPageSelection = sOldSelection;
 705     }
 706
 707     //------------------------------------------------------------------------
 708     sal_uInt16 OPropertyBrowserController::impl_getPageIdForCategory_nothrow( const ::rtl::OUString& _rCategoryName ) const
 709     {
 710         sal_uInt16 nPageId = (sal_uInt16)-1;
 711         HashString2Int16::const_iterator pagePos = m_aPageIds.find( _rCategoryName );
 712         if ( pagePos != m_aPageIds.end() )
 713             nPageId = pagePos->second;
 714         return nPageId;
 715     }
 716
 717     //------------------------------------------------------------------------
 718     void OPropertyBrowserController::selectPageFromViewData()
 719     {
 720         sal_uInt16 nNewPage = impl_getPageIdForCategory_nothrow( m_sPageSelection );
 721
 722         if ( haveView() && ( nNewPage != (sal_uInt16)-1 ) )
 723             m_pView->activatePage( nNewPage );
 724
 725         // just in case ...
 726         updateViewDataFromActivePage();
 727     }
 728
 729     //------------------------------------------------------------------------
 730     sal_Bool OPropertyBrowserController::Construct(Window* _pParentWin)
 731     {
 732         DBG_ASSERT(!haveView(), "OPropertyBrowserController::Construct: already have a view!");
 733         DBG_ASSERT(_pParentWin, "OPropertyBrowserController::Construct: invalid parent window!");
 734
 735         m_pView = new OPropertyBrowserView(m_aContext.getLegacyServiceFactory(), _pParentWin);
 736         m_pView->setPageActivationHandler(LINK(this, OPropertyBrowserController, OnPageActivation));
 737
 738         // add as dispose listener for our view. The view is disposed by the frame we're plugged into,
 739         // and this disposal _deletes_ the view, so it would be deadly if we use our m_pView member
 740         // after that
 741         m_xView = VCLUnoHelper::GetInterface(m_pView);
 742         Reference< XComponent > xViewAsComp(m_xView, UNO_QUERY);
 743         if (xViewAsComp.is())
 744             xViewAsComp->addEventListener( static_cast< XPropertyChangeListener* >( this ) );
 745
 746         getPropertyBox().SetLineListener(this);
 747         getPropertyBox().SetControlObserver(this);
 748         impl_initializeView_nothrow();
 749
 750         m_pView->Show();
 751
 752         return sal_True;
 753     }
 754
 755     //------------------------------------------------------------------------
 756     void SAL_CALL OPropertyBrowserController::propertyChange( const PropertyChangeEvent& _rEvent ) throw (RuntimeException)
 757     {
 758         if ( _rEvent.Source == m_xModel )
 759         {
 760             if ( _rEvent.PropertyName.equalsAscii( "IsReadOnly" ) )
 761                 impl_updateReadOnlyView_nothrow();
 762             return;
 763         }
 764
 765         if ( m_sCommittingProperty == _rEvent.PropertyName )
 766             return;
 767
 768         if ( !haveView() )
 769             return;
 770
 771         Any aNewValue( _rEvent.NewValue );
 772         if ( impl_hasPropertyHandlerFor_nothrow( _rEvent.PropertyName ) )
 773         {
 774             // forward the new value to the property box, to reflect the change in the UI
 775             aNewValue = impl_getPropertyValue_throw( _rEvent.PropertyName );
 776
 777             // check whether the state is ambiguous. This is interesting in case we display the properties
 778             // for multiple objects at once: In this case, we'll get a notification from one of the objects,
 779             // but need to care for the "composed" value, which can be "ambiguous".
 780             PropertyHandlerRef xHandler( impl_getHandlerForProperty_throw( _rEvent.PropertyName ), UNO_SET_THROW );
 781             PropertyState ePropertyState( xHandler->getPropertyState( _rEvent.PropertyName ) );
 782             bool bAmbiguousValue = ( PropertyState_AMBIGUOUS_VALUE == ePropertyState );
 783
 784             getPropertyBox().SetPropertyValue( _rEvent.PropertyName, aNewValue, bAmbiguousValue );
 785         }
 786
 787         // if it's a actuating property, then update the UI for any dependent
 788         // properties
 789         if ( impl_isActuatingProperty_nothrow( _rEvent.PropertyName ) )
 790             impl_broadcastPropertyChange_nothrow( _rEvent.PropertyName, aNewValue, _rEvent.OldValue, false );
 791     }
 792
 793     //------------------------------------------------------------------------
 794     Reference< XPropertyControl > SAL_CALL OPropertyBrowserController::createPropertyControl( ::sal_Int16 ControlType, ::sal_Bool _CreateReadOnly ) throw (IllegalArgumentException, RuntimeException)
 795     {
 796         ::osl::MutexGuard aGuard( m_aMutex );
 797
 798         Reference< XPropertyControl > xControl;
 799
 800         // default winbits: a border only
 801         WinBits nWinBits = WB_BORDER;
 802
 803         // read-only-ness
 804         _CreateReadOnly |= (sal_Bool)impl_isReadOnlyModel_throw();
 805         if ( _CreateReadOnly )
 806             nWinBits |= WB_READONLY;
 807
 808         switch ( ControlType )
 809         {
 810             case PropertyControlType::StringListField:
 811                 xControl = new OMultilineEditControl( &getPropertyBox(), eStringList, nWinBits | WB_DROPDOWN | WB_TABSTOP );
 812                 break;
 813
 814             case PropertyControlType::MultiLineTextField:
 815                 xControl = new OMultilineEditControl( &getPropertyBox(), eMultiLineText, nWinBits | WB_DROPDOWN | WB_TABSTOP );
 816                 break;
 817
 818             case PropertyControlType::ListBox:
 819                 xControl = new OListboxControl( &getPropertyBox(), nWinBits | WB_TABSTOP | WB_DROPDOWN);
 820                 break;
 821
 822             case PropertyControlType::ComboBox:
 823                 xControl = new OComboboxControl( &getPropertyBox(), nWinBits | WB_TABSTOP | WB_DROPDOWN);
 824                 break;
 825
 826             case PropertyControlType::TextField:
 827                 xControl = new OEditControl( &getPropertyBox(), sal_False, nWinBits | WB_TABSTOP );
 828                 break;
 829
 830             case PropertyControlType::CharacterField:
 831                 xControl = new OEditControl( &getPropertyBox(), sal_True, nWinBits | WB_TABSTOP );
 832                 break;
 833
 834             case PropertyControlType::NumericField:
 835                 xControl = new ONumericControl( &getPropertyBox(), nWinBits | WB_TABSTOP | WB_SPIN | WB_REPEAT );
 836                 break;
 837
 838             case PropertyControlType::DateTimeField:
 839                 xControl = new ODateTimeControl( &getPropertyBox(), nWinBits | WB_TABSTOP );
 840                 break;
 841
 842             case PropertyControlType::DateField:
 843                 xControl = new ODateControl( &getPropertyBox(), nWinBits | WB_TABSTOP | WB_SPIN | WB_REPEAT );
 844                 break;
 845
 846             case PropertyControlType::TimeField:
 847                 xControl = new OTimeControl( &getPropertyBox(), nWinBits | WB_TABSTOP | WB_SPIN | WB_REPEAT );
 848                 break;
 849
 850             case PropertyControlType::ColorListBox:
 851                 xControl = new OColorControl( &getPropertyBox(), nWinBits | WB_TABSTOP | WB_DROPDOWN );
 852                 break;
 853
 854             case PropertyControlType::HyperlinkField:
 855                 xControl = new OHyperlinkControl( &getPropertyBox(), nWinBits | WB_TABSTOP | WB_DROPDOWN );
 856                 break;
 857
 858             default:
 859                 throw IllegalArgumentException( ::rtl::OUString(), *this, 1 );
 860         }
 861
 862         return xControl;
 863     }
 864
 865     //------------------------------------------------------------------------
 866     void OPropertyBrowserController::impl_toggleInspecteeListening_nothrow( bool _bOn )
 867     {
 868         for (   InterfaceArray::const_iterator loop = m_aInspectedObjects.begin();
 869                 loop != m_aInspectedObjects.end();
 870                 ++loop
 871             )
 872         {
 873             try
 874             {
 875                 Reference< XComponent > xComp( *loop, UNO_QUERY );
 876                 if ( xComp.is() )
 877                 {
 878                     if ( _bOn )
 879                         xComp->addEventListener( static_cast< XPropertyChangeListener* >( this ) );
 880                     else
 881                         xComp->removeEventListener( static_cast< XPropertyChangeListener* >( this ) );
 882                 }
 883             }
 884             catch( const Exception& )
 885             {
 886                 DBG_UNHANDLED_EXCEPTION();
 887             }
 888         }
 889     }
 890
 891     //------------------------------------------------------------------------
 892     void OPropertyBrowserController::stopInspection( bool _bCommitModified )
 893     {
 894         if ( haveView() )
 895         {
 896             if ( _bCommitModified )
 897                 // commit the editor's content
 898                 getPropertyBox().CommitModified();
 899
 900             // hide the property box so that it does not flicker
 901             getPropertyBox().Hide();
 902
 903             // clear the property box
 904             getPropertyBox().ClearAll();
 905         }
 906
 907         // destroy the view first
 908         if ( haveView() )
 909         {
 910             // remove the pages
 911             for (   HashString2Int16::const_iterator erase = m_aPageIds.begin();
 912                     erase != m_aPageIds.end();
 913                     ++erase
 914                 )
 915                 getPropertyBox().RemovePage( erase->second );
 916             clearContainer( m_aPageIds );
 917         }
 918
 919         clearContainer( m_aProperties );
 920
 921         // de-register as dispose-listener from our inspected objects
 922         impl_toggleInspecteeListening_nothrow( false );
 923
 924         // handlers are obsolete, so is our "composer" for their UI requests
 925         if ( m_pUIRequestComposer.get() )
 926             m_pUIRequestComposer->dispose();
 927         m_pUIRequestComposer.reset( NULL );
 928
 929         // clean up the property handlers
 930         PropertyHandlerArray aAllHandlers;  // will contain every handler exactly once
 931         for ( PropertyHandlerRepository::const_iterator aHandler = m_aPropertyHandlers.begin();
 932               aHandler != m_aPropertyHandlers.end();
 933               ++aHandler
 934             )
 935             if ( ::std::find( aAllHandlers.begin(), aAllHandlers.end(), aHandler->second ) == aAllHandlers.end() )
 936                 aAllHandlers.push_back( aHandler->second );
 937
 938         for ( PropertyHandlerArray::iterator loop = aAllHandlers.begin();
 939               loop != aAllHandlers.end();
 940               ++loop
 941             )
 942         {
 943             try
 944             {
 945                 (*loop)->removePropertyChangeListener( this );
 946                 (*loop)->dispose();
 947             }
 948             catch( const DisposedException& )
 949             {
 950             }
 951             catch( const Exception& )
 952             {
 953                 DBG_UNHANDLED_EXCEPTION();
 954             }
 955         }
 956
 957         clearContainer( m_aPropertyHandlers );
 958         clearContainer( m_aDependencyHandlers );
 959     }
 960
 961     //------------------------------------------------------------------------
 962     bool OPropertyBrowserController::impl_hasPropertyHandlerFor_nothrow( const ::rtl::OUString& _rPropertyName ) const
 963     {
 964         PropertyHandlerRepository::const_iterator handlerPos = m_aPropertyHandlers.find( _rPropertyName );
 965         return ( handlerPos != m_aPropertyHandlers.end() );
 966     }
 967
 968     //------------------------------------------------------------------------
 969     OPropertyBrowserController::PropertyHandlerRef OPropertyBrowserController::impl_getHandlerForProperty_throw( const ::rtl::OUString& _rPropertyName ) const
 970     {
 971         PropertyHandlerRepository::const_iterator handlerPos = m_aPropertyHandlers.find( _rPropertyName );
 972         if ( handlerPos == m_aPropertyHandlers.end() )
 973             throw RuntimeException();
 974         return handlerPos->second;
 975     }
 976
 977     //------------------------------------------------------------------------
 978     Any OPropertyBrowserController::impl_getPropertyValue_throw( const ::rtl::OUString& _rPropertyName )
 979     {
 980         PropertyHandlerRef handler = impl_getHandlerForProperty_throw( _rPropertyName );
 981         return handler->getPropertyValue( _rPropertyName );
 982     }
 983
 984     //------------------------------------------------------------------------
 985     void OPropertyBrowserController::impl_rebindToInspectee_nothrow( const InterfaceArray& _rObjects )
 986     {
 987         try
 988         {
 989             // stop inspecting the old object(s)
 990             stopInspection( true );
 991
 992             // inspect the new object(s)
 993             m_aInspectedObjects = _rObjects;
 994             doInspection();
 995
 996             // update the user interface
 997             UpdateUI();
 998         }
 999
1000         catch(Exception&)
1001         {
1002             DBG_ERROR("OPropertyBrowserController::impl_rebindToInspectee_nothrow: caught an exception !");
1003         }
1004     }
1005
1006     //------------------------------------------------------------------------
1007     void OPropertyBrowserController::doInspection()
1008     {
1009         try
1010         {
1011             //////////////////////////////////////////////////////////////////////
1012             // obtain the properties of the object
1013             ::std::vector< Property > aProperties;
1014
1015             PropertyHandlerArray aPropertyHandlers;
1016             getPropertyHandlers( m_aInspectedObjects, aPropertyHandlers );
1017
1018             PropertyHandlerArray::iterator aHandler( aPropertyHandlers.begin() );
1019             while ( aHandler != aPropertyHandlers.end() )
1020             {
1021                 DBG_ASSERT( aHandler->get(), "OPropertyBrowserController::doInspection: invalid handler!" );
1022
1023                 StlSyntaxSequence< Property > aThisHandlersProperties = (*aHandler)->getSupportedProperties();
1024
1025                 if ( aThisHandlersProperties.empty() )
1026                 {
1027                     // this handler doesn't know anything about the current inspectee -> ignore it
1028                     (*aHandler)->dispose();
1029                     aHandler = aPropertyHandlers.erase( aHandler );
1030                     continue;
1031                 }
1032
1033                 // append these properties to our "all properties" array
1034                 aProperties.reserve( aProperties.size() + aThisHandlersProperties.size() );
1035                 for (   StlSyntaxSequence< Property >::const_iterator copyProperty = aThisHandlersProperties.begin();
1036                         copyProperty != aThisHandlersProperties.end();
1037                         ++copyProperty
1038                     )
1039                 {
1040                     ::std::vector< Property >::const_iterator previous = ::std::find_if(
1041                         aProperties.begin(),
1042                         aProperties.end(),
1043                         FindPropertyByName( copyProperty->Name )
1044                     );
1045                     if ( previous == aProperties.end() )
1046                     {
1047                         aProperties.push_back( *copyProperty );
1048                         continue;
1049                     }
1050
1051                     // there already was another (previous) handler which supported this property.
1052                     // Don't add it to aProperties, again.
1053
1054                     // Also, ensure that handlers which previously expressed interest in *changes*
1055                     // of this property are not notified.
1056                     // This is 'cause we have a new handler which is responsible for this property,
1057                     // which means it can give it a completely different meaning than the previous
1058                     // handler for this property is prepared for.
1059                     ::std::pair< PropertyHandlerMultiRepository::iterator, PropertyHandlerMultiRepository::iterator >
1060                         aDepHandlers = m_aDependencyHandlers.equal_range( copyProperty->Name );
1061                     m_aDependencyHandlers.erase( aDepHandlers.first, aDepHandlers.second );
1062                 }
1063
1064                 // determine the superseded properties
1065                 StlSyntaxSequence< ::rtl::OUString > aSupersededByThisHandler = (*aHandler)->getSupersededProperties();
1066                 for (   StlSyntaxSequence< ::rtl::OUString >::const_iterator superseded = aSupersededByThisHandler.begin();
1067                         superseded != aSupersededByThisHandler.end();
1068                         ++superseded
1069                     )
1070                 {
1071                     ::std::vector< Property >::iterator existent = ::std::find_if(
1072                         aProperties.begin(),
1073                         aProperties.end(),
1074                         FindPropertyByName( *superseded )
1075                     );
1076                     if ( existent != aProperties.end() )
1077                         // one of the properties superseded by this handler was supported by a previous
1078                         // one -> erase
1079                         aProperties.erase( existent );
1080                 }
1081
1082                 // be notified of changes which this handler is responsible for
1083                 (*aHandler)->addPropertyChangeListener( this );
1084
1085                 // remember this handler for every of the properties which it is responsible
1086                 // for
1087                 for (   StlSyntaxSequence< Property >::const_iterator remember = aThisHandlersProperties.begin();
1088                         remember != aThisHandlersProperties.end();
1089                         ++remember
1090                     )
1091                 {
1092                     m_aPropertyHandlers[ remember->Name ] = *aHandler;
1093                     // note that this implies that if two handlers support the same property,
1094                     // the latter wins
1095                 }
1096
1097                 // see if the handler expresses interest in any actuating properties
1098                 StlSyntaxSequence< ::rtl::OUString > aInterestingActuations = (*aHandler)->getActuatingProperties();
1099                 for (   StlSyntaxSequence< ::rtl::OUString >::const_iterator aLoop = aInterestingActuations.begin();
1100                         aLoop != aInterestingActuations.end();
1101                         ++aLoop
1102                     )
1103                 {
1104                     m_aDependencyHandlers.insert( PropertyHandlerMultiRepository::value_type(
1105                         *aLoop, *aHandler ) );
1106                 }
1107
1108                 ++aHandler;
1109             }
1110
1111             // create a new composer for UI requests coming from the handlers
1112             m_pUIRequestComposer.reset( new ComposedPropertyUIUpdate( getInspectorUI(), this ) );
1113
1114             // sort the properties by relative position, as indicated by the model
1115             for (   ::std::vector< Property >::const_iterator sourceProps = aProperties.begin();
1116                     sourceProps != aProperties.end();
1117                     ++sourceProps
1118                 )
1119             {
1120                 sal_Int32 nRelativePropertyOrder = sourceProps - aProperties.begin();
1121                 if ( m_xModel.is() )
1122                     nRelativePropertyOrder = m_xModel->getPropertyOrderIndex( sourceProps->Name );
1123                 while ( m_aProperties.find( nRelativePropertyOrder ) != m_aProperties.end() )
1124                     ++nRelativePropertyOrder;
1125                 m_aProperties[ nRelativePropertyOrder ] = *sourceProps;
1126             }
1127
1128             // be notified when one of our inspectees dies
1129             impl_toggleInspecteeListening_nothrow( true );
1130         }
1131         catch(Exception&)
1132         {
1133             DBG_ERROR("OPropertyBrowserController::doInspection : caught an exception !");
1134         }
1135     }
1136
1137     //------------------------------------------------------------------------
1138     ::com::sun::star::awt::Size SAL_CALL OPropertyBrowserController::getMinimumSize() throw (::com::sun::star::uno::RuntimeException)
1139     {
1140         ::com::sun::star::awt::Size aSize;
1141         if( m_pView )
1142             return m_pView->getMinimumSize();
1143         else
1144             return aSize;
1145     }
1146
1147     //------------------------------------------------------------------------
1148     ::com::sun::star::awt::Size SAL_CALL OPropertyBrowserController::getPreferredSize() throw (::com::sun::star::uno::RuntimeException)
1149     {
1150         return getMinimumSize();
1151     }
1152
1153     //------------------------------------------------------------------------
1154     ::com::sun::star::awt::Size SAL_CALL OPropertyBrowserController::calcAdjustedSize( const ::com::sun::star::awt::Size& _rNewSize ) throw (::com::sun::star::uno::RuntimeException)
1155     {
1156         awt::Size aMinSize = getMinimumSize( );
1157         awt::Size aAdjustedSize( _rNewSize );
1158         if ( aAdjustedSize.Width < aMinSize.Width )
1159             aAdjustedSize.Width = aMinSize.Width;
1160         if ( aAdjustedSize.Height < aMinSize.Height )
1161             aAdjustedSize.Height = aMinSize.Height;
1162         return aAdjustedSize;
1163     }
1164
1165     //------------------------------------------------------------------------
1166     void OPropertyBrowserController::describePropertyLine( const Property& _rProperty, OLineDescriptor& _rDescriptor ) SAL_THROW((Exception))
1167     {
1168         try
1169         {
1170             PropertyHandlerRepository::const_iterator handler = m_aPropertyHandlers.find( _rProperty.Name );
1171             if ( handler == m_aPropertyHandlers.end() )
1172                 throw RuntimeException();   // caught below
1173
1174             _rDescriptor.assignFrom( handler->second->describePropertyLine( _rProperty.Name, this ) );
1175
1176             //////////////////////////////////////////////////////////////////////
1177
1178             _rDescriptor.xPropertyHandler = handler->second;
1179             _rDescriptor.sName = _rProperty.Name;
1180             _rDescriptor.aValue = _rDescriptor.xPropertyHandler->getPropertyValue( _rProperty.Name );
1181
1182             if ( !_rDescriptor.DisplayName.getLength() )
1183             {
1184             #ifdef DBG_UTIL
1185                 ::rtl::OString sMessage( "OPropertyBrowserController::describePropertyLine: handler did not provide a display name for '" );
1186                 sMessage += ::rtl::OString( _rProperty.Name.getStr(), _rProperty.Name.getLength(), RTL_TEXTENCODING_ASCII_US );
1187                 sMessage += ::rtl::OString( "'!" );
1188                 DBG_ASSERT( _rDescriptor.DisplayName.getLength(), sMessage );
1189             #endif
1190                 _rDescriptor.DisplayName = _rProperty.Name;
1191             }
1192
1193             PropertyState   ePropertyState( _rDescriptor.xPropertyHandler->getPropertyState( _rProperty.Name ) );
1194             if ( PropertyState_AMBIGUOUS_VALUE == ePropertyState )
1195             {
1196                 _rDescriptor.bUnknownValue = true;
1197                 _rDescriptor.aValue.clear();
1198             }
1199
1200             _rDescriptor.bReadOnly = impl_isReadOnlyModel_throw();
1201         }
1202         catch( const Exception& )
1203         {
1204             OSL_ENSURE( sal_False, "OPropertyBrowserController::describePropertyLine: caught an exception!" );
1205         }
1206     }
1207
1208     //------------------------------------------------------------------------
1209     void OPropertyBrowserController::impl_buildCategories_throw()
1210     {
1211         OSL_PRECOND( m_aPageIds.empty(), "OPropertyBrowserController::impl_buildCategories_throw: duplicate call!" );
1212
1213         StlSyntaxSequence< PropertyCategoryDescriptor > aCategories;
1214         if ( m_xModel.is() )
1215             aCategories = m_xModel->describeCategories();
1216
1217         for (   StlSyntaxSequence< PropertyCategoryDescriptor >::const_iterator category = aCategories.begin();
1218                 category != aCategories.end();
1219                 ++category
1220             )
1221         {
1222             OSL_ENSURE( m_aPageIds.find( category->ProgrammaticName ) == m_aPageIds.end(),
1223                 "OPropertyBrowserController::impl_buildCategories_throw: duplicate programmatic name!" );
1224
1225             m_aPageIds[ category->ProgrammaticName ] =
1226                 getPropertyBox().AppendPage( category->UIName, HelpIdUrl::getHelpId( category->HelpURL ) );
1227         }
1228     }
1229
1230     //------------------------------------------------------------------------
1231     void OPropertyBrowserController::UpdateUI()
1232     {
1233         try
1234         {
1235             if ( !haveView() )
1236                 // too early, will return later
1237                 return;
1238
1239             getPropertyBox().DisableUpdate();
1240
1241             sal_Bool bHaveFocus = getPropertyBox().HasChildPathFocus();
1242
1243             // create our tab pages
1244             impl_buildCategories_throw();
1245             // (and allow for pages to be actually unused)
1246             ::std::set< sal_uInt16 > aUsedPages;
1247
1248             // when building the UI below, remember which properties are actuating,
1249             // to allow for a initial actuatinPropertyChanged call
1250             ::std::vector< ::rtl::OUString > aActuatingProperties;
1251             ::std::vector< Any > aActuatingPropertyValues;
1252
1253             // ask the handlers to describe the property UI, and insert the resulting
1254             // entries into our list boxes
1255             OrderedPropertyMap::const_iterator property( m_aProperties.begin() );
1256             for ( ; property != m_aProperties.end(); ++property )
1257             {
1258                 OLineDescriptor aDescriptor;
1259                 describePropertyLine( property->second, aDescriptor );
1260
1261                 bool bIsActuatingProperty = impl_isActuatingProperty_nothrow( property->second.Name );
1262
1263             #if OSL_DEBUG_LEVEL > 0
1264                 if ( !aDescriptor.Category.getLength() )
1265                 {
1266                     ::rtl::OString sMessage( "OPropertyBrowserController::UpdateUI: empty category provided for property '" );
1267                     sMessage += ::rtl::OString( property->second.Name.getStr(), property->second.Name.getLength(), osl_getThreadTextEncoding() );
1268                     sMessage += "'!";
1269                     OSL_ENSURE( false, sMessage );
1270                 }
1271             #endif
1272                 // finally insert this property control
1273                 sal_uInt16 nTargetPageId = impl_getPageIdForCategory_nothrow( aDescriptor.Category );
1274                 if ( nTargetPageId == (sal_uInt16)-1 )
1275                 {
1276                     // this category does not yet exist. This is allowed, as an inspector model might be lazy, and not provide
1277                     // any category information of its own. In this case, we have a fallback ...
1278                     m_aPageIds[ aDescriptor.Category ] =
1279                         getPropertyBox().AppendPage( aDescriptor.Category, SmartId() );
1280                     nTargetPageId = impl_getPageIdForCategory_nothrow( aDescriptor.Category );
1281                 }
1282
1283                 getPropertyBox().InsertEntry( aDescriptor, nTargetPageId );
1284                 aUsedPages.insert( nTargetPageId );
1285
1286                 // if it's an actuating property, remember it
1287                 if ( bIsActuatingProperty )
1288                 {
1289                     aActuatingProperties.push_back( property->second.Name );
1290                     aActuatingPropertyValues.push_back( impl_getPropertyValue_throw( property->second.Name ) );
1291                 }
1292             }
1293
1294             // update any dependencies for the actuating properties which we encountered
1295             {
1296                 ::std::vector< ::rtl::OUString >::const_iterator aProperty = aActuatingProperties.begin();
1297                 ::std::vector< Any >::const_iterator aPropertyValue = aActuatingPropertyValues.begin();
1298                 for ( ; aProperty != aActuatingProperties.end(); ++aProperty, ++aPropertyValue )
1299                     impl_broadcastPropertyChange_nothrow( *aProperty, *aPropertyValue, *aPropertyValue, true );
1300             }
1301
1302             // remove any unused pages (which we did not encounter properties for)
1303             HashString2Int16 aSurvivingPageIds;
1304             for (   HashString2Int16::iterator pageId = m_aPageIds.begin();
1305                     pageId != m_aPageIds.end();
1306                     ++pageId
1307                 )
1308             {
1309                 if ( aUsedPages.find( pageId->second ) == aUsedPages.end() )
1310                     getPropertyBox().RemovePage( pageId->second );
1311                 else
1312                     aSurvivingPageIds.insert( *pageId );
1313             }
1314             m_aPageIds.swap( aSurvivingPageIds );
1315
1316
1317             getPropertyBox().Show();
1318             getPropertyBox().EnableUpdate();
1319             if ( bHaveFocus )
1320                 getPropertyBox().GrabFocus();
1321
1322             // activate the first page
1323             if ( !m_aPageIds.empty() )
1324             {
1325                 Sequence< PropertyCategoryDescriptor > aCategories( m_xModel->describeCategories() );
1326                 if ( aCategories.getLength() )
1327                     m_pView->activatePage( m_aPageIds[ aCategories[0].ProgrammaticName ] );
1328                 else
1329                     // allowed: if we default-created the pages ...
1330                     m_pView->activatePage( m_aPageIds.begin()->second );
1331             }
1332
1333             // activate the previously active page (if possible)
1334             if ( m_sLastValidPageSelection.getLength() )
1335                 m_sPageSelection = m_sLastValidPageSelection;
1336             selectPageFromViewData();
1337         }
1338         catch( const Exception& )
1339         {
1340             DBG_UNHANDLED_EXCEPTION();
1341         }
1342     }
1343
1344     //------------------------------------------------------------------------
1345     void OPropertyBrowserController::Clicked( const ::rtl::OUString& _rName, sal_Bool _bPrimary )
1346     {
1347         try
1348         {
1349             // since the browse buttons do not get the focus when clicked with the mouse,
1350             // we need to commit the changes in the current property field
1351             getPropertyBox().CommitModified();
1352
1353             PropertyHandlerRepository::const_iterator handler = m_aPropertyHandlers.find( _rName );
1354             DBG_ASSERT( handler != m_aPropertyHandlers.end(), "OPropertyBrowserController::Clicked: a property without handler? This will crash!" );
1355
1356             ComposedUIAutoFireGuard aAutoFireGuard( *m_pUIRequestComposer );
1357
1358             Any aData;
1359             m_xInteractiveHandler = handler->second;
1360             InteractiveSelectionResult eResult =
1361                 handler->second->onInteractivePropertySelection( _rName, _bPrimary, aData,
1362                     m_pUIRequestComposer->getUIForPropertyHandler( handler->second ) );
1363
1364             switch ( eResult )
1365             {
1366             case InteractiveSelectionResult_Cancelled:
1367             case InteractiveSelectionResult_Success:
1368                 // okay, nothing to do
1369                 break;
1370             case InteractiveSelectionResult_ObtainedValue:
1371                 handler->second->setPropertyValue( _rName, aData );
1372                 break;
1373             case InteractiveSelectionResult_Pending:
1374                 // also okay, we expect that the handler has disabled the UI as necessary
1375                 break;
1376             default:
1377                 OSL_ENSURE( false, "OPropertyBrowserController::Clicked: unknown result value!" );
1378                 break;
1379             }
1380         }
1381         catch (Exception&)
1382         {
1383             DBG_UNHANDLED_EXCEPTION();
1384         }
1385         m_xInteractiveHandler = NULL;
1386     }
1387
1388     //------------------------------------------------------------------------
1389     sal_Bool SAL_CALL OPropertyBrowserController::hasPropertyByName( const ::rtl::OUString& _rName ) throw (RuntimeException)
1390     {
1391         for (   OrderedPropertyMap::const_iterator search = m_aProperties.begin();
1392                 search != m_aProperties.end();
1393                 ++search
1394             )
1395             if ( search->second.Name == _rName )
1396                 return true;
1397         return false;
1398     }
1399
1400     //------------------------------------------------------------------------
1401     void OPropertyBrowserController::Commit( const ::rtl::OUString& rName, const Any& _rValue )
1402     {
1403         try
1404         {
1405             rtl::OUString sPlcHolder = String( PcrRes( RID_EMBED_IMAGE_PLACEHOLDER ) );
1406             bool bIsPlaceHolderValue = false;
1407
1408             if ( rName.equals( PROPERTY_IMAGE_URL ) )
1409             {
1410                 // if the prop value is the PlaceHolder
1411                 // can ignore it
1412                 rtl::OUString sVal;
1413                 _rValue >>= sVal;
1414                 if ( sVal.equals( sPlcHolder ) )
1415                     bIsPlaceHolderValue = true;
1416             }
1417             m_sCommittingProperty = rName;
1418
1419             bool bIsActuatingProperty = impl_isActuatingProperty_nothrow( rName );
1420
1421             Any aOldValue;
1422             if ( bIsActuatingProperty )
1423                 aOldValue = impl_getPropertyValue_throw( rName );
1424
1425             // do we have a dedicated handler for this property, which we can delegate some tasks to?
1426             PropertyHandlerRef handler = impl_getHandlerForProperty_throw( rName );
1427
1428             //////////////////////////////////////////////////////////////////////
1429             // set the value ( only if it's not a placeholder )
1430             if ( !bIsPlaceHolderValue )
1431                 handler->setPropertyValue( rName, _rValue );
1432
1433             //////////////////////////////////////////////////////////////////////
1434             // re-retrieve the value
1435             Any aNormalizedValue = handler->getPropertyValue( rName );
1436
1437             // care for any inter-property dependencies
1438             if ( bIsActuatingProperty )
1439                 impl_broadcastPropertyChange_nothrow( rName, aNormalizedValue, aOldValue, false );
1440
1441             // and display it again. This ensures proper formatting
1442             getPropertyBox().SetPropertyValue( rName, aNormalizedValue, false );
1443         }
1444         catch(PropertyVetoException& eVetoException)
1445         {
1446             InfoBox(m_pView, eVetoException.Message).Execute();
1447             PropertyHandlerRef handler = impl_getHandlerForProperty_throw( rName );
1448             Any aNormalizedValue = handler->getPropertyValue( rName );
1449             getPropertyBox().SetPropertyValue( rName, aNormalizedValue, false );
1450         }
1451         catch(Exception&)
1452         {
1453             DBG_ERROR("OPropertyBrowserController::Commit : caught an exception !");
1454         }
1455
1456         m_sCommittingProperty = ::rtl::OUString();
1457     }
1458
1459     //--------------------------------------------------------------------
1460     namespace
1461     {
1462     }
1463
1464     //--------------------------------------------------------------------
1465     void OPropertyBrowserController::focusGained( const Reference< XPropertyControl >& _Control )
1466     {
1467         m_aControlObservers.notifyEach( &XPropertyControlObserver::focusGained, _Control );
1468     }
1469
1470     //--------------------------------------------------------------------
1471     void OPropertyBrowserController::valueChanged( const Reference< XPropertyControl >& _Control )
1472     {
1473         m_aControlObservers.notifyEach( &XPropertyControlObserver::valueChanged, _Control );
1474     }
1475
1476     //------------------------------------------------------------------------
1477     namespace
1478     {
1479         Reference< XPropertyHandler > lcl_createHandler( const ComponentContext& _rContext, const Any& _rFactoryDescriptor )
1480         {
1481             Reference< XPropertyHandler > xHandler;
1482
1483             ::rtl::OUString sServiceName;
1484             Reference< XSingleServiceFactory > xServiceFac;
1485             Reference< XSingleComponentFactory > xComponentFac;
1486
1487             if ( _rFactoryDescriptor >>= sServiceName )
1488                 _rContext.createComponent( sServiceName, xHandler );
1489             else if ( _rFactoryDescriptor >>= xServiceFac )
1490                 xHandler = xHandler.query( xServiceFac->createInstance() );
1491             else if ( _rFactoryDescriptor >>= xComponentFac )
1492                 xHandler = xHandler.query( xComponentFac->createInstanceWithContext( _rContext.getUNOContext() ) );
1493             OSL_ENSURE(xHandler.is(),"lcl_createHandler: Can not create handler");
1494             return xHandler;
1495         }
1496     }
1497
1498     //------------------------------------------------------------------------
1499     void OPropertyBrowserController::getPropertyHandlers( const InterfaceArray& _rObjects, PropertyHandlerArray& _rHandlers )
1500     {
1501         _rHandlers.resize( 0 );
1502         if ( _rObjects.empty() )
1503             return;
1504
1505         // create a component context for the handlers, containing some information about where
1506         // they live
1507         Reference< XComponentContext > xHandlerContext( m_aContext.getUNOContext() );
1508
1509         // if our own creator did not pass a dialog parent window, use our own view for this
1510         Reference< XWindow > xParentWindow( m_aContext.getContextValueByAsciiName( "DialogParentWindow" ), UNO_QUERY );
1511         if ( !xParentWindow.is() )
1512         {
1513             ::cppu::ContextEntry_Init aHandlerContextInfo[] =
1514             {
1515                 ::cppu::ContextEntry_Init( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DialogParentWindow" ) ), makeAny( VCLUnoHelper::GetInterface( m_pView ) ) )
1516             };
1517             xHandlerContext = ::cppu::createComponentContext(
1518                 aHandlerContextInfo, sizeof( aHandlerContextInfo ) / sizeof( aHandlerContextInfo[0] ),
1519                 m_aContext.getUNOContext() );
1520         }
1521
1522         Sequence< Any > aHandlerFactories;
1523         if ( m_xModel.is() )
1524             aHandlerFactories = m_xModel->getHandlerFactories();
1525
1526         const Any* pHandlerFactory = aHandlerFactories.getConstArray();
1527         const Any* pHandlerFactoryEnd = aHandlerFactories.getConstArray() + aHandlerFactories.getLength();
1528
1529         while ( pHandlerFactory != pHandlerFactoryEnd )
1530         {
1531             if ( _rObjects.size() == 1 )
1532             {   // we're inspecting only one object -> one handler
1533                 Reference< XPropertyHandler > xHandler( lcl_createHandler( m_aContext, *pHandlerFactory ) );
1534                 if ( xHandler.is() )
1535                 {
1536                     xHandler->inspect( _rObjects[0] );
1537                     _rHandlers.push_back( xHandler );
1538                 }
1539             }
1540             else
1541             {
1542                 // create a single handler for every single object
1543                 ::std::vector< Reference< XPropertyHandler > > aSingleHandlers( _rObjects.size() );
1544                 ::std::vector< Reference< XPropertyHandler > >::iterator pHandler = aSingleHandlers.begin();
1545
1546                 InterfaceArray::const_iterator pObject = _rObjects.begin();
1547                 InterfaceArray::const_iterator pObjectEnd = _rObjects.end();
1548
1549                 for ( ; pObject != pObjectEnd; ++pObject )
1550                 {
1551                     *pHandler = lcl_createHandler( m_aContext, *pHandlerFactory );
1552                     if ( pHandler->is() )
1553                     {
1554                         (*pHandler)->inspect( *pObject );
1555                         ++pHandler;
1556                     }
1557                 }
1558                 aSingleHandlers.resize( pHandler - aSingleHandlers.begin() );
1559
1560                 // then create a handler which composes information out of those single handlers
1561                 if ( !aSingleHandlers.empty() )
1562                     _rHandlers.push_back( new PropertyComposer( aSingleHandlers ) );
1563             }
1564
1565             ++pHandlerFactory;
1566         }
1567
1568         // note that the handlers will not be used by our caller, if they indicate that there are no
1569         // properties they feel responsible for
1570     }
1571
1572     //------------------------------------------------------------------------
1573     bool OPropertyBrowserController::impl_findObjectProperty_nothrow( const ::rtl::OUString& _rName, OrderedPropertyMap::const_iterator* _pProperty )
1574     {
1575         OrderedPropertyMap::const_iterator search = m_aProperties.begin();
1576         for ( ; search != m_aProperties.end(); ++search )
1577             if ( search->second.Name == _rName )
1578                 break;
1579         if ( _pProperty )
1580             *_pProperty = search;
1581         return ( search != m_aProperties.end() );
1582     }
1583
1584     //------------------------------------------------------------------------
1585     void OPropertyBrowserController::rebuildPropertyUI( const ::rtl::OUString& _rPropertyName ) throw (RuntimeException)
1586     {
1587         ::osl::MutexGuard aGuard( m_aMutex );
1588         if ( !haveView() )
1589             throw RuntimeException();
1590
1591         OrderedPropertyMap::const_iterator propertyPos;
1592         if ( !impl_findObjectProperty_nothrow( _rPropertyName, &propertyPos ) )
1593             return;
1594
1595         OLineDescriptor aDescriptor;
1596         try
1597         {
1598             describePropertyLine( propertyPos->second, aDescriptor );
1599         }
1600         catch( const Exception& )
1601         {
1602             OSL_ENSURE( sal_False, "OPropertyBrowserController::rebuildPropertyUI: caught an exception!" );
1603         }
1604
1605         getPropertyBox().ChangeEntry( aDescriptor );
1606    }
1607
1608     //------------------------------------------------------------------------
1609     void OPropertyBrowserController::enablePropertyUI( const ::rtl::OUString& _rPropertyName, sal_Bool _bEnable ) throw (RuntimeException)
1610     {
1611         ::osl::MutexGuard aGuard( m_aMutex );
1612         if ( !haveView() )
1613             throw RuntimeException();
1614
1615         if ( !impl_findObjectProperty_nothrow( _rPropertyName ) )
1616             return;
1617
1618         getPropertyBox().EnablePropertyLine( _rPropertyName, _bEnable );
1619     }
1620
1621     //------------------------------------------------------------------------
1622     void OPropertyBrowserController::enablePropertyUIElements( const ::rtl::OUString& _rPropertyName, sal_Int16 _nElements, sal_Bool _bEnable ) throw (RuntimeException)
1623     {
1624         ::osl::MutexGuard aGuard( m_aMutex );
1625         if ( !haveView() )
1626             throw RuntimeException();
1627
1628         if ( !impl_findObjectProperty_nothrow( _rPropertyName ) )
1629             return;
1630
1631         getPropertyBox().EnablePropertyControls( _rPropertyName, _nElements, _bEnable );
1632     }
1633
1634     //------------------------------------------------------------------------
1635     void OPropertyBrowserController::showPropertyUI( const ::rtl::OUString& _rPropertyName ) throw (RuntimeException)
1636     {
1637         ::osl::MutexGuard aGuard( m_aMutex );
1638         if ( !haveView() )
1639             throw RuntimeException();
1640
1641         // look up the property in our object properties
1642         OrderedPropertyMap::const_iterator propertyPos;
1643         if ( !impl_findObjectProperty_nothrow( _rPropertyName, &propertyPos ) )
1644             return;
1645
1646         if ( getPropertyBox().GetPropertyPos( _rPropertyName ) != LISTBOX_ENTRY_NOTFOUND )
1647         {
1648             rebuildPropertyUI( _rPropertyName );
1649             return;
1650         }
1651
1652         OLineDescriptor aDescriptor;
1653         describePropertyLine( propertyPos->second, aDescriptor );
1654
1655         // look for the position to insert the property
1656
1657         // side note: The methods GetPropertyPos and InsertEntry of the OPropertyEditor work
1658         // only on the current page. This implies that it's impossible to use this method here
1659         // to show property lines which are *not* on the current page.
1660         // This is sufficient for now, but should be changed in the future.
1661
1662         // by definition, the properties in m_aProperties are in the order in which they appear in the UI
1663         // So all we need is a predecessor of pProperty in m_aProperties
1664         sal_uInt16 nUIPos = LISTBOX_ENTRY_NOTFOUND;
1665         do
1666         {
1667             if ( propertyPos != m_aProperties.begin() )
1668                 --propertyPos;
1669             nUIPos = getPropertyBox().GetPropertyPos( propertyPos->second.Name );
1670         }
1671         while ( ( nUIPos == LISTBOX_ENTRY_NOTFOUND ) && ( propertyPos != m_aProperties.begin() ) );
1672
1673         if ( nUIPos == LISTBOX_ENTRY_NOTFOUND )
1674             // insert at the very top
1675             nUIPos = 0;
1676         else
1677             // insert right after the predecessor we found
1678             ++nUIPos;
1679
1680         getPropertyBox().InsertEntry(
1681             aDescriptor, impl_getPageIdForCategory_nothrow( aDescriptor.Category ), nUIPos );
1682     }
1683
1684     //------------------------------------------------------------------------
1685     void OPropertyBrowserController::hidePropertyUI( const ::rtl::OUString& _rPropertyName ) throw (RuntimeException)
1686     {
1687         ::osl::MutexGuard aGuard( m_aMutex );
1688         if ( !haveView() )
1689             throw RuntimeException();
1690
1691         if ( !impl_findObjectProperty_nothrow( _rPropertyName ) )
1692             return;
1693
1694         getPropertyBox().RemoveEntry( _rPropertyName );
1695     }
1696
1697     //------------------------------------------------------------------------
1698     void OPropertyBrowserController::showCategory( const ::rtl::OUString& _rCategory, sal_Bool _bShow ) throw (RuntimeException)
1699     {
1700         ::osl::MutexGuard aGuard( m_aMutex );
1701         if ( !haveView() )
1702             throw RuntimeException();
1703
1704         sal_uInt16 nPageId = impl_getPageIdForCategory_nothrow( _rCategory );
1705         OSL_ENSURE( nPageId != (sal_uInt16)-1, "OPropertyBrowserController::showCategory: invalid category!" );
1706
1707         getPropertyBox().ShowPropertyPage( nPageId, _bShow );
1708     }
1709
1710     //------------------------------------------------------------------------
1711     Reference< XPropertyControl > SAL_CALL OPropertyBrowserController::getPropertyControl( const ::rtl::OUString& _rPropertyName ) throw (RuntimeException)
1712     {
1713         ::osl::MutexGuard aGuard( m_aMutex );
1714         if ( !haveView() )
1715             throw RuntimeException();
1716
1717         Reference< XPropertyControl > xControl( getPropertyBox().GetPropertyControl( _rPropertyName ) );
1718         return xControl;
1719     }
1720
1721     //--------------------------------------------------------------------
1722     void SAL_CALL OPropertyBrowserController::registerControlObserver( const Reference< XPropertyControlObserver >& _Observer ) throw (RuntimeException)
1723     {
1724         m_aControlObservers.addInterface( _Observer );
1725     }
1726
1727     //--------------------------------------------------------------------
1728     void SAL_CALL OPropertyBrowserController::revokeControlObserver( const Reference< XPropertyControlObserver >& _Observer ) throw (RuntimeException)
1729     {
1730         m_aControlObservers.removeInterface( _Observer );
1731     }
1732
1733     //------------------------------------------------------------------------
1734     void SAL_CALL OPropertyBrowserController::setHelpSectionText( const ::rtl::OUString& _rHelpText ) throw (NoSupportException, RuntimeException)
1735     {
1736         ::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1737         ::osl::MutexGuard aGuard( m_aMutex );
1738
1739         if ( !haveView() )
1740             throw DisposedException();
1741
1742         if ( !getPropertyBox().HasHelpSection() )
1743             throw NoSupportException();
1744
1745         getPropertyBox().SetHelpText( _rHelpText );
1746     }
1747
1748     //------------------------------------------------------------------------
1749     void OPropertyBrowserController::impl_broadcastPropertyChange_nothrow( const ::rtl::OUString& _rPropertyName, const Any& _rNewValue, const Any& _rOldValue, bool _bFirstTimeInit ) const
1750     {
1751         // are there one or more handlers which are interested in the actuation?
1752         ::std::pair< PropertyHandlerMultiRepository::const_iterator, PropertyHandlerMultiRepository::const_iterator > aInterestedHandlers =
1753             m_aDependencyHandlers.equal_range( _rPropertyName );
1754         if ( aInterestedHandlers.first == aInterestedHandlers.second )
1755             // none of our handlers is interested in this
1756             return;
1757
1758         ComposedUIAutoFireGuard aAutoFireGuard( *m_pUIRequestComposer );
1759         try
1760         {
1761             // collect the responses from all interested handlers
1762             PropertyHandlerMultiRepository::const_iterator handler = aInterestedHandlers.first;
1763             while ( handler != aInterestedHandlers.second )
1764             {
1765                 handler->second->actuatingPropertyChanged( _rPropertyName, _rNewValue, _rOldValue,
1766                     m_pUIRequestComposer->getUIForPropertyHandler( handler->second ),
1767                     _bFirstTimeInit );
1768                 ++handler;
1769             }
1770         }
1771         catch( const Exception& )
1772         {
1773             DBG_UNHANDLED_EXCEPTION();
1774         }
1775     }
1776
1777 //............................................................................
1778 } // namespace pcr
1779 //............................................................................
1780
1781