extensions/source/propctrlr/propcontroller.cxx

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