extensions/source/propctrlr/browserlistbox.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 "browserlistbox.hxx"
  21 #include "propresid.hrc"
  22 #include "proplinelistener.hxx"
  23 #include "propcontrolobserver.hxx"
  24 #include "linedescriptor.hxx"
  25 #include "inspectorhelpwindow.hxx"
  26
  27 #include <com/sun/star/lang/DisposedException.hpp>
  28 #include <com/sun/star/lang/XComponent.hpp>
  29 #include <com/sun/star/inspection/PropertyControlType.hpp>
  30 #include <tools/debug.hxx>
  31 #include <tools/diagnose_ex.h>
  32 #include <comphelper/asyncnotification.hxx>
  33 #include <cppuhelper/implbase.hxx>
  34 #include <vcl/svapp.hxx>
  35 #include <osl/mutex.hxx>
  36
  37
  38 namespace pcr
  39 {
  40
  41
  42     #define FRAME_OFFSET 4
  43         // TODO: find out what this is really for ... and check if it does make sense in the new
  44         // browser environment
  45     #define LAYOUT_HELP_WINDOW_DISTANCE_APPFONT 3
  46
  47     using ::com::sun::star::uno::Any;
  48     using ::com::sun::star::uno::Exception;
  49     using ::com::sun::star::inspection::XPropertyControlContext;
  50     using ::com::sun::star::uno::Reference;
  51     using ::com::sun::star::inspection::XPropertyControl;
  52     using ::com::sun::star::uno::RuntimeException;
  53     using ::com::sun::star::lang::DisposedException;
  54     using ::com::sun::star::lang::XComponent;
  55     using ::com::sun::star::uno::UNO_QUERY;
  56
  57     namespace PropertyControlType = ::com::sun::star::inspection::PropertyControlType;
  58
  59     enum ControlEventType
  60     {
  61         FOCUS_GAINED,
  62         VALUE_CHANGED,
  63         ACTIVATE_NEXT
  64     };
  65
  66     struct ControlEvent : public ::comphelper::AnyEvent
  67     {
  68         Reference< XPropertyControl >   xControl;
  69         ControlEventType                eType;
  70
  71         ControlEvent( const Reference< XPropertyControl >& _rxControl, ControlEventType _eType )
  72             :xControl( _rxControl )
  73             ,eType( _eType )
  74         {
  75         }
  76     };
  77
  78     class SharedNotifier
  79     {
  80     private:
  81         static ::osl::Mutex&                                        getMutex();
  82         static ::rtl::Reference< ::comphelper::AsyncEventNotifier > s_pNotifier;
  83
  84     public:
  85         SharedNotifier(const SharedNotifier&) = delete;
  86         SharedNotifier& operator=(const SharedNotifier&) = delete;
  87         static const ::rtl::Reference< ::comphelper::AsyncEventNotifier >&
  88             getNotifier();
  89     };
  90
  91
  92     ::rtl::Reference< ::comphelper::AsyncEventNotifier > SharedNotifier::s_pNotifier;
  93
  94
  95     ::osl::Mutex& SharedNotifier::getMutex()
  96     {
  97         static ::osl::Mutex s_aMutex;
  98         return s_aMutex;
  99     }
 100
 101
 102     const ::rtl::Reference< ::comphelper::AsyncEventNotifier >& SharedNotifier::getNotifier()
 103     {
 104         ::osl::MutexGuard aGuard( getMutex() );
 105         if ( !s_pNotifier.is() )
 106         {
 107             s_pNotifier.set(
 108                 new ::comphelper::AsyncEventNotifier("browserlistbox"));
 109             s_pNotifier->launch();
 110                 //TODO: a protocol is missing how to join with the launched
 111                 // thread before exit(3), to ensure the thread is no longer
 112                 // relying on any infrastructure while that infrastructure is
 113                 // being shut down in atexit handlers
 114         }
 115         return s_pNotifier;
 116     }
 117
 118
 119     /** implementation for of <type scope="css::inspection">XPropertyControlContext</type>
 120         which forwards all events to a non-UNO version of this interface
 121     */
 122     typedef ::cppu::WeakImplHelper< XPropertyControlContext > PropertyControlContext_Impl_Base;
 123     class PropertyControlContext_Impl   :public PropertyControlContext_Impl_Base
 124                                         ,public ::comphelper::IEventProcessor
 125     {
 126     public:
 127         enum NotificationMode
 128         {
 129             eSynchronously,
 130             eAsynchronously
 131         };
 132
 133     private:
 134         VclPtr<OBrowserListBox>     m_pContext;
 135         NotificationMode            m_eMode;
 136
 137     public:
 138         /** creates an instance
 139             @param _rContextImpl
 140                 the instance to delegate events to
 141         */
 142         explicit PropertyControlContext_Impl( OBrowserListBox& _rContextImpl );
 143
 144         /** disposes the context.
 145
 146             When you call this method, all subsequent callbacks to the
 147             <type scope="css::inspection">XPropertyControlContext</type> methods
 148             will throw a <type scope="css::lang">DisposedException</type>.
 149         */
 150         void SAL_CALL dispose();
 151
 152         /** sets the notification mode, so that notifications received from the controls are
 153             forwarded to our OBrowserListBox either synchronously or asynchronously
 154             @param  _eMode
 155                 the new notification mode
 156         */
 157         void setNotificationMode( NotificationMode _eMode );
 158
 159         virtual void SAL_CALL acquire() throw() override;
 160         virtual void SAL_CALL release() throw() override;
 161
 162     protected:
 163         virtual ~PropertyControlContext_Impl() override;
 164
 165         // XPropertyControlObserver
 166         virtual void SAL_CALL focusGained( const Reference< XPropertyControl >& Control ) override;
 167         virtual void SAL_CALL valueChanged( const Reference< XPropertyControl >& Control ) override;
 168         // XPropertyControlContext
 169         virtual void SAL_CALL activateNextControl( const Reference< XPropertyControl >& CurrentControl ) override;
 170
 171         // IEventProcessor
 172         virtual void processEvent( const ::comphelper::AnyEvent& _rEvent ) override;
 173
 174     private:
 175         /** processes the given event, i.e. notifies it to our OBrowserListBox
 176             @param  _rEvent
 177                 the event no notify
 178             @precond
 179                 our mutex (well, the SolarMutex) is locked
 180         */
 181         void impl_processEvent_throw( const ::comphelper::AnyEvent& _rEvent );
 182
 183         /** checks whether the instance is already disposed
 184         */
 185         bool impl_isDisposed_nothrow() const { return m_pContext.get() == nullptr; }
 186
 187         /** notifies the given event originating from the given control
 188         @throws DisposedException
 189         @param  _rxControl
 190         @param  _eType
 191         */
 192         void impl_notify_throw( const Reference< XPropertyControl >& _rxControl, ControlEventType _eType );
 193     };
 194
 195
 196     PropertyControlContext_Impl::PropertyControlContext_Impl( OBrowserListBox& _rContextImpl )
 197         :m_pContext( &_rContextImpl )
 198         ,m_eMode( eAsynchronously )
 199     {
 200     }
 201
 202
 203     PropertyControlContext_Impl::~PropertyControlContext_Impl()
 204     {
 205         if ( !impl_isDisposed_nothrow() )
 206             dispose();
 207     }
 208
 209
 210     void SAL_CALL PropertyControlContext_Impl::dispose()
 211     {
 212         SolarMutexGuard aGuard;
 213         if ( impl_isDisposed_nothrow() )
 214             return;
 215
 216         SharedNotifier::getNotifier()->removeEventsForProcessor( this );
 217         m_pContext = nullptr;
 218     }
 219
 220
 221     void PropertyControlContext_Impl::setNotificationMode( NotificationMode _eMode )
 222     {
 223         SolarMutexGuard aGuard;
 224         m_eMode = _eMode;
 225     }
 226
 227
 228     void PropertyControlContext_Impl::impl_notify_throw( const Reference< XPropertyControl >& _rxControl, ControlEventType _eType )
 229     {
 230         ::comphelper::AnyEventRef pEvent;
 231
 232         {
 233             SolarMutexGuard aGuard;
 234             if ( impl_isDisposed_nothrow() )
 235                  throw DisposedException( OUString(), *this );
 236             pEvent = new ControlEvent( _rxControl, _eType );
 237
 238             if ( m_eMode == eSynchronously )
 239             {
 240                 impl_processEvent_throw( *pEvent );
 241                 return;
 242             }
 243         }
 244
 245         SharedNotifier::getNotifier()->addEvent( pEvent, this );
 246     }
 247
 248
 249     void SAL_CALL PropertyControlContext_Impl::focusGained( const Reference< XPropertyControl >& Control )
 250     {
 251         impl_notify_throw( Control, FOCUS_GAINED );
 252     }
 253
 254
 255     void SAL_CALL PropertyControlContext_Impl::valueChanged( const Reference< XPropertyControl >& Control )
 256     {
 257         impl_notify_throw( Control, VALUE_CHANGED );
 258     }
 259
 260
 261     void SAL_CALL PropertyControlContext_Impl::activateNextControl( const Reference< XPropertyControl >& CurrentControl )
 262     {
 263         impl_notify_throw( CurrentControl, ACTIVATE_NEXT );
 264     }
 265
 266
 267     void SAL_CALL PropertyControlContext_Impl::acquire() throw()
 268     {
 269         PropertyControlContext_Impl_Base::acquire();
 270     }
 271
 272
 273     void SAL_CALL PropertyControlContext_Impl::release() throw()
 274     {
 275         PropertyControlContext_Impl_Base::release();
 276     }
 277
 278
 279     void PropertyControlContext_Impl::processEvent( const ::comphelper::AnyEvent& _rEvent )
 280     {
 281         SolarMutexGuard aGuard;
 282         if ( impl_isDisposed_nothrow() )
 283             return;
 284
 285         try
 286         {
 287             impl_processEvent_throw( _rEvent );
 288         }
 289         catch( const Exception& )
 290         {
 291             // can't handle otherwise, since our caller (the notification thread) does not allow
 292             // for exceptions (it could itself abort only)
 293             DBG_UNHANDLED_EXCEPTION();
 294         }
 295     }
 296
 297
 298     void PropertyControlContext_Impl::impl_processEvent_throw( const ::comphelper::AnyEvent& _rEvent )
 299     {
 300         const ControlEvent& rControlEvent = static_cast< const ControlEvent& >( _rEvent );
 301         switch ( rControlEvent.eType )
 302         {
 303         case FOCUS_GAINED:
 304             m_pContext->focusGained( rControlEvent.xControl );
 305             break;
 306         case VALUE_CHANGED:
 307             m_pContext->valueChanged( rControlEvent.xControl );
 308             break;
 309         case ACTIVATE_NEXT:
 310             m_pContext->activateNextControl( rControlEvent.xControl );
 311             break;
 312         }
 313     }
 314
 315     OBrowserListBox::OBrowserListBox( vcl::Window* pParent)
 316             :Control(pParent, WB_DIALOGCONTROL | WB_CLIPCHILDREN)
 317             ,m_aLinesPlayground(VclPtr<vcl::Window>::Create(this,WB_DIALOGCONTROL | WB_CLIPCHILDREN))
 318             ,m_aVScroll(VclPtr<ScrollBar>::Create(this,WB_VSCROLL|WB_REPEAT|WB_DRAG))
 319             ,m_pHelpWindow( VclPtr<InspectorHelpWindow>::Create( this ) )
 320             ,m_pLineListener(nullptr)
 321             ,m_pControlObserver( nullptr )
 322             ,m_nYOffset(0)
 323             ,m_nCurrentPreferredHelpHeight(0)
 324             ,m_nTheNameSize(0)
 325             ,m_bIsActive(false)
 326             ,m_bUpdate(true)
 327             ,m_pControlContextImpl( new PropertyControlContext_Impl( *this ) )
 328     {
 329         ScopedVclPtrInstance<ListBox> aListBox(this, WB_DROPDOWN);
 330         ScopedVclPtrInstance<Edit> aEditBox(this);
 331         m_nRowHeight = std::max(aListBox->get_preferred_size().Height(),
 332                                 aEditBox->get_preferred_size().Height());
 333         m_nRowHeight += 2;
 334         SetBackground( pParent->GetBackground() );
 335         m_aLinesPlayground->SetBackground( GetBackground() );
 336
 337         m_aLinesPlayground->SetPosPixel(Point(0,0));
 338         m_aLinesPlayground->SetPaintTransparent(true);
 339         m_aLinesPlayground->Show();
 340         m_aVScroll->Hide();
 341         m_aVScroll->SetScrollHdl(LINK(this, OBrowserListBox, ScrollHdl));
 342     }
 343
 344     OBrowserListBox::~OBrowserListBox()
 345     {
 346         disposeOnce();
 347     }
 348
 349     void OBrowserListBox::dispose()
 350     {
 351         OSL_ENSURE( !IsModified(), "OBrowserListBox::~OBrowserListBox: still modified - should have been committed before!" );
 352             // doing the commit here, while we, as well as our owner, as well as some other components,
 353             // are already "half dead" (means within their dtor) is potentially dangerous.
 354             // By definition, CommitModified has to be called (if necessary) before destruction
 355
 356         m_pControlContextImpl->dispose();
 357         m_pControlContextImpl.clear();
 358
 359         Hide();
 360         Clear();
 361         m_aLinesPlayground.disposeAndClear();
 362         m_aVScroll.disposeAndClear();
 363         m_pHelpWindow.disposeAndClear();
 364         Control::dispose();
 365     }
 366
 367
 368     bool OBrowserListBox::IsModified( ) const
 369     {
 370         bool bModified = false;
 371
 372         if ( m_bIsActive && m_xActiveControl.is() )
 373             bModified = m_xActiveControl->isModified();
 374
 375         return bModified;
 376     }
 377
 378
 379     void OBrowserListBox::CommitModified( )
 380     {
 381         if ( IsModified() && m_xActiveControl.is() )
 382         {
 383             // for the time of this commit, notify all events synchronously
 384             // #i63814#
 385             m_pControlContextImpl->setNotificationMode( PropertyControlContext_Impl::eSynchronously );
 386             try
 387             {
 388                 m_xActiveControl->notifyModifiedValue();
 389             }
 390             catch( const Exception& )
 391             {
 392                 DBG_UNHANDLED_EXCEPTION();
 393             }
 394             m_pControlContextImpl->setNotificationMode( PropertyControlContext_Impl::eAsynchronously );
 395         }
 396     }
 397
 398
 399     void OBrowserListBox::ActivateListBox(bool _bActive)
 400     {
 401         m_bIsActive = _bActive;
 402         if (m_bIsActive)
 403         {
 404             // TODO: what's the sense of this?
 405             m_aVScroll->SetThumbPos(100);
 406             MoveThumbTo(0);
 407             Resize();
 408         }
 409     }
 410
 411
 412     long OBrowserListBox::impl_getPrefererredHelpHeight()
 413     {
 414         return HasHelpSection() ? m_pHelpWindow->GetOptimalHeightPixel() : 0;
 415     }
 416
 417
 418     void OBrowserListBox::Resize()
 419     {
 420         tools::Rectangle aPlayground( Point( 0, 0 ), GetOutputSizePixel() );
 421         Size aHelpWindowDistance( LogicToPixel( Size( 0, LAYOUT_HELP_WINDOW_DISTANCE_APPFONT ), MapUnit::MapAppFont ) );
 422
 423         long nHelpWindowHeight = m_nCurrentPreferredHelpHeight = impl_getPrefererredHelpHeight();
 424         bool bPositionHelpWindow = ( nHelpWindowHeight != 0 );
 425
 426         tools::Rectangle aLinesArea( aPlayground );
 427         if ( bPositionHelpWindow )
 428         {
 429             aLinesArea.Bottom() -= nHelpWindowHeight;
 430             aLinesArea.Bottom() -= aHelpWindowDistance.Height();
 431         }
 432         m_aLinesPlayground->SetPosSizePixel( aLinesArea.TopLeft(), aLinesArea.GetSize() );
 433
 434         UpdateVScroll();
 435
 436         bool bNeedScrollbar = m_aLines.size() > (sal_uInt32)CalcVisibleLines();
 437         if ( !bNeedScrollbar )
 438         {
 439             if ( m_aVScroll->IsVisible() )
 440                 m_aVScroll->Hide();
 441             // scroll to top
 442             m_nYOffset = 0;
 443             m_aVScroll->SetThumbPos( 0 );
 444         }
 445         else
 446         {
 447             Size aVScrollSize( m_aVScroll->GetSizePixel() );
 448
 449             // adjust the playground's width
 450             aLinesArea.Right() -= aVScrollSize.Width();
 451             m_aLinesPlayground->SetPosSizePixel( aLinesArea.TopLeft(), aLinesArea.GetSize() );
 452
 453             // position the scrollbar
 454             aVScrollSize.Height() = aLinesArea.GetHeight();
 455             Point aVScrollPos( aLinesArea.GetWidth(), 0 );
 456             m_aVScroll->SetPosSizePixel( aVScrollPos, aVScrollSize );
 457         }
 458
 459         for ( ListBoxLines::size_type i = 0; i < m_aLines.size(); ++i )
 460             m_aOutOfDateLines.insert( i );
 461
 462         // repaint
 463         EnablePaint(false);
 464         UpdatePlayGround();
 465         EnablePaint(true);
 466
 467         // show the scrollbar
 468         if ( bNeedScrollbar )
 469             m_aVScroll->Show();
 470
 471         // position the help window
 472         if ( bPositionHelpWindow )
 473         {
 474             tools::Rectangle aHelpArea( aPlayground );
 475             aHelpArea.Top() = aLinesArea.Bottom() + aHelpWindowDistance.Height();
 476             m_pHelpWindow->SetPosSizePixel( aHelpArea.TopLeft(), aHelpArea.GetSize() );
 477         }
 478     }
 479
 480
 481     void OBrowserListBox::SetListener( IPropertyLineListener* _pListener )
 482     {
 483         m_pLineListener = _pListener;
 484     }
 485
 486
 487     void OBrowserListBox::SetObserver( IPropertyControlObserver* _pObserver )
 488     {
 489         m_pControlObserver = _pObserver;
 490     }
 491
 492
 493     void OBrowserListBox::EnableHelpSection( bool _bEnable )
 494     {
 495         m_pHelpWindow->Show( _bEnable );
 496         Resize();
 497     }
 498
 499
 500     bool OBrowserListBox::HasHelpSection() const
 501     {
 502         return m_pHelpWindow->IsVisible();
 503     }
 504
 505
 506     void OBrowserListBox::SetHelpText( const OUString& _rHelpText )
 507     {
 508         OSL_ENSURE( HasHelpSection(), "OBrowserListBox::SetHelpText: help section not visible!" );
 509         m_pHelpWindow->SetText( _rHelpText );
 510         if ( m_nCurrentPreferredHelpHeight != impl_getPrefererredHelpHeight() )
 511             Resize();
 512     }
 513
 514
 515     void OBrowserListBox::SetHelpLineLimites( sal_Int32 _nMinLines, sal_Int32 _nMaxLines )
 516     {
 517         m_pHelpWindow->SetLimits( _nMinLines, _nMaxLines );
 518     }
 519
 520
 521     sal_uInt16 OBrowserListBox::CalcVisibleLines()
 522     {
 523         Size aSize(m_aLinesPlayground->GetOutputSizePixel());
 524         sal_uInt16 nResult = 0;
 525         if (0 != m_nRowHeight)
 526             nResult = (sal_uInt16) aSize.Height()/m_nRowHeight;
 527
 528         return nResult;
 529     }
 530
 531
 532     void OBrowserListBox::UpdateVScroll()
 533     {
 534         sal_uInt16 nLines = CalcVisibleLines();
 535         m_aVScroll->SetPageSize(nLines-1);
 536         m_aVScroll->SetVisibleSize(nLines-1);
 537
 538         size_t nCount = m_aLines.size();
 539         if (nCount>0)
 540         {
 541             m_aVScroll->SetRange(Range(0,nCount-1));
 542             m_nYOffset = -m_aVScroll->GetThumbPos()*m_nRowHeight;
 543         }
 544         else
 545         {
 546             m_aVScroll->SetRange(Range(0,0));
 547             m_nYOffset = 0;
 548         }
 549     }
 550
 551
 552     void OBrowserListBox::PositionLine( ListBoxLines::size_type _nIndex )
 553     {
 554         Size aSize(m_aLinesPlayground->GetOutputSizePixel());
 555         Point aPos(0, m_nYOffset);
 556
 557         aSize.Height() = m_nRowHeight;
 558
 559         aPos.Y() += _nIndex * m_nRowHeight;
 560
 561         if ( _nIndex < m_aLines.size() )
 562         {
 563             BrowserLinePointer pLine = m_aLines[ _nIndex ].pLine;
 564
 565             pLine->SetPosSizePixel( aPos, aSize );
 566             pLine->SetTitleWidth( m_nTheNameSize + 2 * FRAME_OFFSET );
 567
 568             // show the line if necessary
 569             if ( !pLine->IsVisible() )
 570                 pLine->Show();
 571         }
 572     }
 573
 574
 575     void OBrowserListBox::UpdatePosNSize()
 576     {
 577         for ( auto const & aLoop: m_aOutOfDateLines )
 578         {
 579             DBG_ASSERT( aLoop < m_aLines.size(), "OBrowserListBox::UpdatePosNSize: invalid line index!" );
 580             if ( aLoop < m_aLines.size() )
 581                 PositionLine( aLoop );
 582         }
 583         m_aOutOfDateLines.clear();
 584     }
 585
 586
 587     void OBrowserListBox::UpdatePlayGround()
 588     {
 589         sal_Int32 nThumbPos = m_aVScroll->GetThumbPos();
 590         sal_Int32 nLines = CalcVisibleLines();
 591
 592         ListBoxLines::size_type nEnd = nThumbPos + nLines;
 593         if (nEnd >= m_aLines.size())
 594             nEnd = m_aLines.size()-1;
 595
 596         if ( !m_aLines.empty() )
 597         {
 598             for ( ListBoxLines::size_type i = nThumbPos; i <= nEnd; ++i )
 599                 m_aOutOfDateLines.insert( i );
 600             UpdatePosNSize();
 601         }
 602     }
 603
 604
 605     void OBrowserListBox::DisableUpdate()
 606     {
 607         m_bUpdate = false;
 608     }
 609
 610
 611     void OBrowserListBox::EnableUpdate()
 612     {
 613         m_bUpdate = true;
 614         Resize();
 615     }
 616
 617
 618     void OBrowserListBox::SetPropertyValue(const OUString& _rEntryName, const Any& _rValue, bool _bUnknownValue )
 619     {
 620         ListBoxLines::iterator line = m_aLines.begin();
 621         for ( ; line != m_aLines.end() && ( line->aName != _rEntryName ); ++line )
 622             ;
 623
 624         if ( line != m_aLines.end() )
 625         {
 626             if ( _bUnknownValue )
 627             {
 628                 Reference< XPropertyControl > xControl( line->pLine->getControl() );
 629                 OSL_ENSURE( xControl.is(), "OBrowserListBox::SetPropertyValue: illegal control!" );
 630                 if ( xControl.is() )
 631                     xControl->setValue( Any() );
 632             }
 633             else
 634                 impl_setControlAsPropertyValue( *line, _rValue );
 635         }
 636     }
 637
 638
 639     sal_uInt16 OBrowserListBox::GetPropertyPos( const OUString& _rEntryName ) const
 640     {
 641         sal_uInt16 nRet = EDITOR_LIST_ENTRY_NOTFOUND;
 642         for ( ListBoxLines::const_iterator linePos = m_aLines.begin();
 643               linePos != m_aLines.end();
 644               ++linePos
 645             )
 646         {
 647             if ( linePos->aName == _rEntryName )
 648             {
 649                 nRet = (sal_uInt16)( linePos - m_aLines.begin() );
 650                 break;
 651             }
 652         }
 653
 654         return nRet;
 655     }
 656
 657
 658     bool OBrowserListBox::impl_getBrowserLineForName( const OUString& _rEntryName, BrowserLinePointer& _out_rpLine ) const
 659     {
 660         ListBoxLines::const_iterator line = m_aLines.begin();
 661         for ( ; line != m_aLines.end() && ( line->aName != _rEntryName ); ++line )
 662             ;
 663
 664         if ( line != m_aLines.end() )
 665             _out_rpLine = line->pLine;
 666         else
 667             _out_rpLine.reset();
 668         return ( nullptr != _out_rpLine.get() );
 669     }
 670
 671
 672     void OBrowserListBox::EnablePropertyControls( const OUString& _rEntryName, sal_Int16 _nControls, bool _bEnable )
 673     {
 674         BrowserLinePointer pLine;
 675         if ( impl_getBrowserLineForName( _rEntryName, pLine ) )
 676             pLine->EnablePropertyControls( _nControls, _bEnable );
 677     }
 678
 679
 680     void OBrowserListBox::EnablePropertyLine( const OUString& _rEntryName, bool _bEnable )
 681     {
 682         BrowserLinePointer pLine;
 683         if ( impl_getBrowserLineForName( _rEntryName, pLine ) )
 684             pLine->EnablePropertyLine( _bEnable );
 685     }
 686
 687
 688     Reference< XPropertyControl > OBrowserListBox::GetPropertyControl( const OUString& _rEntryName )
 689     {
 690         BrowserLinePointer pLine;
 691         if ( impl_getBrowserLineForName( _rEntryName, pLine ) )
 692             return pLine->getControl();
 693         return nullptr;
 694     }
 695
 696
 697     void OBrowserListBox::InsertEntry(const OLineDescriptor& _rPropertyData, sal_uInt16 _nPos)
 698     {
 699         // create a new line
 700         BrowserLinePointer pBrowserLine( new OBrowserLine( _rPropertyData.sName, m_aLinesPlayground.get() ) );
 701
 702         // check that the name is unique
 703         ListBoxLines::iterator it = m_aLines.begin();
 704         for ( ; it != m_aLines.end() && ( it->aName != _rPropertyData.sName ); ++it )
 705             ;
 706         OSL_ENSURE( it == m_aLines.end(), "OBrowserListBox::InsertEntry: already have another line for this name!" );
 707
 708         ListBoxLine aNewLine( _rPropertyData.sName, pBrowserLine, _rPropertyData.xPropertyHandler );
 709         ListBoxLines::size_type nInsertPos = _nPos;
 710         if ( _nPos >= m_aLines.size() )
 711         {
 712             nInsertPos = m_aLines.size();
 713             m_aLines.push_back( aNewLine );
 714         }
 715         else
 716             m_aLines.insert( m_aLines.begin() + _nPos, aNewLine );
 717
 718         pBrowserLine->SetTitleWidth(m_nTheNameSize);
 719         if (m_bUpdate)
 720         {
 721             UpdateVScroll();
 722             Invalidate();
 723         }
 724
 725         // initialize the entry
 726         ChangeEntry(_rPropertyData, nInsertPos);
 727
 728         // update the positions of possibly affected lines
 729         ListBoxLines::size_type nUpdatePos = nInsertPos;
 730         while ( nUpdatePos < m_aLines.size() )
 731             m_aOutOfDateLines.insert( nUpdatePos++ );
 732         UpdatePosNSize( );
 733     }
 734
 735
 736     sal_Int32 OBrowserListBox::GetMinimumWidth()
 737     {
 738         return m_nTheNameSize + 2 * FRAME_OFFSET + (m_nRowHeight - 4) * 8;
 739     }
 740
 741
 742     sal_Int32 OBrowserListBox::GetMinimumHeight()
 743     {
 744         // assume that we want to display 5 rows, at least
 745         sal_Int32 nMinHeight = m_nRowHeight * 5;
 746
 747         if ( HasHelpSection() )
 748         {
 749             Size aHelpWindowDistance( LogicToPixel( Size( 0, LAYOUT_HELP_WINDOW_DISTANCE_APPFONT ), MapUnit::MapAppFont ) );
 750             nMinHeight += aHelpWindowDistance.Height();
 751
 752             nMinHeight += m_pHelpWindow->GetMinimalHeightPixel();
 753         }
 754
 755         return nMinHeight;
 756     }
 757
 758
 759     void OBrowserListBox::ShowEntry(sal_uInt16 _nPos)
 760     {
 761         if ( _nPos < m_aLines.size() )
 762         {
 763             sal_Int32 nThumbPos = m_aVScroll->GetThumbPos();
 764
 765             if (_nPos < nThumbPos)
 766                 MoveThumbTo(_nPos);
 767             else
 768             {
 769                 sal_Int32 nLines = CalcVisibleLines();
 770                 if (_nPos >= nThumbPos + nLines)
 771                     MoveThumbTo(_nPos - nLines + 1);
 772             }
 773         }
 774
 775     }
 776
 777
 778     void OBrowserListBox::MoveThumbTo(sal_Int32 _nNewThumbPos)
 779     {
 780         // disable painting to prevent flicker
 781         m_aLinesPlayground->EnablePaint(false);
 782
 783         sal_Int32 nDelta = _nNewThumbPos - m_aVScroll->GetThumbPos();
 784         // adjust the scrollbar
 785         m_aVScroll->SetThumbPos(_nNewThumbPos);
 786         sal_Int32 nThumbPos = _nNewThumbPos;
 787
 788         m_nYOffset = -m_aVScroll->GetThumbPos() * m_nRowHeight;
 789
 790         sal_Int32 nLines = CalcVisibleLines();
 791         ListBoxLines::size_type nEnd = nThumbPos + nLines;
 792
 793         m_aLinesPlayground->Scroll(0, -nDelta * m_nRowHeight, ScrollFlags::Children);
 794
 795         if (1 == nDelta)
 796         {
 797             // TODO: what's the sense of this two PositionLines? Why not just one call?
 798             PositionLine(nEnd-1);
 799             PositionLine(nEnd);
 800         }
 801         else if (-1 == nDelta)
 802         {
 803             PositionLine(nThumbPos);
 804         }
 805         else if (0 != nDelta)
 806         {
 807             UpdatePlayGround();
 808         }
 809
 810         m_aLinesPlayground->EnablePaint(true);
 811         m_aLinesPlayground->Invalidate(InvalidateFlags::Children);
 812     }
 813
 814
 815     IMPL_LINK(OBrowserListBox, ScrollHdl, ScrollBar*, _pScrollBar, void )
 816     {
 817         DBG_ASSERT(_pScrollBar == m_aVScroll.get(), "OBrowserListBox::ScrollHdl: where does this come from?");
 818         (void)_pScrollBar;
 819
 820         // disable painting to prevent flicker
 821         m_aLinesPlayground->EnablePaint(false);
 822
 823         sal_Int32 nThumbPos = m_aVScroll->GetThumbPos();
 824
 825         sal_Int32 nDelta = m_aVScroll->GetDelta();
 826         m_nYOffset = -nThumbPos * m_nRowHeight;
 827
 828         ListBoxLines::size_type nEnd = nThumbPos + CalcVisibleLines();
 829
 830         m_aLinesPlayground->Scroll(0, -nDelta * m_nRowHeight, ScrollFlags::Children);
 831
 832         if (1 == nDelta)
 833         {
 834             PositionLine(nEnd-1);
 835             PositionLine(nEnd);
 836         }
 837         else if (nDelta==-1)
 838         {
 839             PositionLine(nThumbPos);
 840         }
 841         else if (nDelta!=0 || m_aVScroll->GetType() == ScrollType::DontKnow)
 842         {
 843             UpdatePlayGround();
 844         }
 845
 846         m_aLinesPlayground->EnablePaint(true);
 847     }
 848
 849
 850     void OBrowserListBox::buttonClicked( OBrowserLine* _pLine, bool _bPrimary )
 851     {
 852         DBG_ASSERT( _pLine, "OBrowserListBox::buttonClicked: invalid browser line!" );
 853         if ( _pLine && m_pLineListener )
 854         {
 855             m_pLineListener->Clicked( _pLine->GetEntryName(), _bPrimary );
 856         }
 857     }
 858
 859
 860     void OBrowserListBox::impl_setControlAsPropertyValue( const ListBoxLine& _rLine, const Any& _rPropertyValue )
 861     {
 862         Reference< XPropertyControl > xControl( _rLine.pLine->getControl() );
 863         try
 864         {
 865             if ( _rPropertyValue.getValueType().equals( _rLine.pLine->getControl()->getValueType() ) )
 866             {
 867                 xControl->setValue( _rPropertyValue );
 868             }
 869             else
 870             {
 871     #ifdef DBG_UTIL
 872                 if ( !_rLine.xHandler.is() )
 873                 {
 874                     OString sMessage( "OBrowserListBox::impl_setControlAsPropertyValue: no handler -> no conversion (property: '" );
 875                     OUString sPropertyName( _rLine.pLine->GetEntryName() );
 876                     sMessage += OString( sPropertyName.getStr(), sPropertyName.getLength(), RTL_TEXTENCODING_ASCII_US );
 877                     sMessage += OString( "')!" );
 878                     OSL_FAIL( sMessage.getStr() );
 879                 }
 880     #endif
 881                 if ( _rLine.xHandler.is() )
 882                 {
 883                     Any aControlValue = _rLine.xHandler->convertToControlValue(
 884                         _rLine.pLine->GetEntryName(), _rPropertyValue, xControl->getValueType() );
 885                     xControl->setValue( aControlValue );
 886                 }
 887             }
 888         }
 889         catch( const Exception& )
 890         {
 891             DBG_UNHANDLED_EXCEPTION();
 892         }
 893     }
 894
 895
 896     Any OBrowserListBox::impl_getControlAsPropertyValue( const ListBoxLine& _rLine )
 897     {
 898         Reference< XPropertyControl > xControl( _rLine.pLine->getControl() );
 899         Any aPropertyValue;
 900         try
 901         {
 902         #ifdef DBG_UTIL
 903             if ( !_rLine.xHandler.is() )
 904             {
 905                 OString sMessage( "OBrowserListBox::impl_getControlAsPropertyValue: no handler -> no conversion (property: '" );
 906                 OUString sPropertyName( _rLine.pLine->GetEntryName() );
 907                 sMessage += OString( sPropertyName.getStr(), sPropertyName.getLength(), RTL_TEXTENCODING_ASCII_US );
 908                 sMessage += OString( "')!" );
 909                 OSL_FAIL( sMessage.getStr() );
 910             }
 911         #endif
 912             if ( _rLine.xHandler.is() )
 913                 aPropertyValue = _rLine.xHandler->convertToPropertyValue( _rLine.pLine->GetEntryName(), xControl->getValue() );
 914             else
 915                 aPropertyValue = xControl->getValue();
 916         }
 917         catch( const Exception& )
 918         {
 919             DBG_UNHANDLED_EXCEPTION();
 920         }
 921         return aPropertyValue;
 922     }
 923
 924
 925     sal_uInt16 OBrowserListBox::impl_getControlPos( const Reference< XPropertyControl >& _rxControl ) const
 926     {
 927         for ( ListBoxLines::const_iterator search = m_aLines.begin(); search != m_aLines.end(); ++search )
 928             if ( search->pLine->getControl().get() == _rxControl.get() )
 929                 return sal_uInt16( search - m_aLines.begin() );
 930
 931         OSL_FAIL( "OBrowserListBox::impl_getControlPos: invalid control - not part of any of our lines!" );
 932         return (sal_uInt16)-1;
 933     }
 934
 935
 936     void SAL_CALL OBrowserListBox::focusGained( const Reference< XPropertyControl >& _rxControl )
 937     {
 938         DBG_TESTSOLARMUTEX();
 939
 940         DBG_ASSERT( _rxControl.is(), "OBrowserListBox::focusGained: invalid event source!" );
 941         if ( !_rxControl.is() )
 942             return;
 943
 944         if ( m_pControlObserver )
 945             m_pControlObserver->focusGained( _rxControl );
 946
 947         m_xActiveControl = _rxControl;
 948         ShowEntry( impl_getControlPos( m_xActiveControl ) );
 949     }
 950
 951
 952     void SAL_CALL OBrowserListBox::valueChanged( const Reference< XPropertyControl >& _rxControl )
 953     {
 954         DBG_TESTSOLARMUTEX();
 955
 956         DBG_ASSERT( _rxControl.is(), "OBrowserListBox::valueChanged: invalid event source!" );
 957         if ( !_rxControl.is() )
 958             return;
 959
 960         if ( m_pControlObserver )
 961             m_pControlObserver->valueChanged( _rxControl );
 962
 963         if ( m_pLineListener )
 964         {
 965             const ListBoxLine& rLine = m_aLines[ impl_getControlPos( _rxControl ) ];
 966             m_pLineListener->Commit(
 967                 rLine.pLine->GetEntryName(),
 968                 impl_getControlAsPropertyValue( rLine )
 969             );
 970         }
 971     }
 972
 973
 974     void SAL_CALL OBrowserListBox::activateNextControl( const Reference< XPropertyControl >& _rxCurrentControl )
 975     {
 976         DBG_TESTSOLARMUTEX();
 977
 978         sal_uInt16 nLine = impl_getControlPos( _rxCurrentControl );
 979
 980         // cycle forwards, 'til we've the next control which can grab the focus
 981         ++nLine;
 982         while ( static_cast< size_t >( nLine ) < m_aLines.size() )
 983         {
 984             if ( m_aLines[nLine].pLine->GrabFocus() )
 985                 break;
 986             ++nLine;
 987         }
 988
 989         // wrap around?
 990         if ( ( static_cast< size_t >( nLine ) >= m_aLines.size() ) && ( m_aLines.size() > 0 ) )
 991             m_aLines[0].pLine->GrabFocus();
 992     }
 993
 994
 995     namespace
 996     {
 997
 998         void lcl_implDisposeControl_nothrow( const Reference< XPropertyControl >& _rxControl )
 999         {
1000             if ( !_rxControl.is() )
1001                 return;
1002             try
1003             {
1004                 _rxControl->setControlContext( nullptr );
1005                 Reference< XComponent > xControlComponent( _rxControl, UNO_QUERY );
1006                 if ( xControlComponent.is() )
1007                     xControlComponent->dispose();
1008             }
1009             catch( const Exception& )
1010             {
1011                 DBG_UNHANDLED_EXCEPTION();
1012             }
1013         }
1014     }
1015
1016
1017     void OBrowserListBox::Clear()
1018     {
1019         for ( ListBoxLines::iterator loop = m_aLines.begin(); loop != m_aLines.end(); ++loop )
1020         {
1021             // hide the line
1022             loop->pLine->Hide();
1023             // reset the listener
1024             lcl_implDisposeControl_nothrow( loop->pLine->getControl() );
1025         }
1026
1027         clearContainer( m_aLines );
1028     }
1029
1030
1031     bool OBrowserListBox::RemoveEntry( const OUString& _rName )
1032     {
1033         ListBoxLines::size_type nPos = 0;
1034         ListBoxLines::iterator it = m_aLines.begin();
1035         for ( ; it != m_aLines.end() && ( it->aName != _rName ); ++it, ++nPos )
1036             ;
1037
1038         if ( it == m_aLines.end() )
1039             return false;
1040
1041         m_aLines.erase( it );
1042         m_aOutOfDateLines.erase( m_aLines.size() );
1043
1044         // update the positions of possibly affected lines
1045         while ( nPos < m_aLines.size() )
1046             m_aOutOfDateLines.insert( nPos++ );
1047         UpdatePosNSize( );
1048
1049         return true;
1050     }
1051
1052
1053     void OBrowserListBox::ChangeEntry( const OLineDescriptor& _rPropertyData, ListBoxLines::size_type nPos )
1054     {
1055         OSL_PRECOND( _rPropertyData.Control.is(), "OBrowserListBox::ChangeEntry: invalid control!" );
1056         if ( !_rPropertyData.Control.is() )
1057             return;
1058
1059         if ( nPos == EDITOR_LIST_REPLACE_EXISTING )
1060             nPos = GetPropertyPos( _rPropertyData.sName );
1061
1062         if ( nPos < m_aLines.size() )
1063         {
1064             vcl::Window* pRefWindow = nullptr;
1065             if ( nPos > 0 )
1066                 pRefWindow = m_aLines[nPos-1].pLine->GetRefWindow();
1067
1068             // the current line and control
1069             ListBoxLine& rLine = m_aLines[nPos];
1070
1071             // the old control and some data about it
1072             Reference< XPropertyControl > xControl = rLine.pLine->getControl();
1073             vcl::Window* pControlWindow = rLine.pLine->getControlWindow();
1074             Point aControlPos;
1075             if ( pControlWindow )
1076                 aControlPos = pControlWindow->GetPosPixel();
1077
1078             // clean up the old control
1079             lcl_implDisposeControl_nothrow( xControl );
1080
1081             // set the new control at the line
1082             rLine.pLine->setControl( _rPropertyData.Control );
1083             xControl = rLine.pLine->getControl();
1084
1085             if ( xControl.is() )
1086                 xControl->setControlContext( m_pControlContextImpl.get() );
1087
1088             // the initial property value
1089             if ( _rPropertyData.bUnknownValue )
1090                 xControl->setValue( Any() );
1091             else
1092                 impl_setControlAsPropertyValue( rLine, _rPropertyData.aValue );
1093
1094             rLine.pLine->SetTitle(_rPropertyData.DisplayName);
1095             rLine.xHandler = _rPropertyData.xPropertyHandler;
1096
1097             sal_uInt16 nTextWidth = (sal_uInt16)m_aLinesPlayground->GetTextWidth(_rPropertyData.DisplayName);
1098             if (m_nTheNameSize< nTextWidth)
1099                 m_nTheNameSize = nTextWidth;
1100
1101             if ( _rPropertyData.HasPrimaryButton )
1102             {
1103                 if ( !_rPropertyData.PrimaryButtonImageURL.isEmpty() )
1104                     rLine.pLine->ShowBrowseButton( _rPropertyData.PrimaryButtonImageURL, true );
1105                 else if ( _rPropertyData.PrimaryButtonImage.is() )
1106                     rLine.pLine->ShowBrowseButton( Image( _rPropertyData.PrimaryButtonImage ), true );
1107                 else
1108                     rLine.pLine->ShowBrowseButton( true );
1109
1110                 if ( _rPropertyData.HasSecondaryButton )
1111                 {
1112                     if ( !_rPropertyData.SecondaryButtonImageURL.isEmpty() )
1113                         rLine.pLine->ShowBrowseButton( _rPropertyData.SecondaryButtonImageURL, false );
1114                     else if ( _rPropertyData.SecondaryButtonImage.is() )
1115                         rLine.pLine->ShowBrowseButton( Image( _rPropertyData.SecondaryButtonImage ), false );
1116                     else
1117                         rLine.pLine->ShowBrowseButton( false );
1118                 }
1119                 else
1120                     rLine.pLine->HideBrowseButton( false );
1121
1122                 rLine.pLine->SetClickListener( this );
1123             }
1124             else
1125             {
1126                 rLine.pLine->HideBrowseButton( true );
1127                 rLine.pLine->HideBrowseButton( false );
1128             }
1129
1130             DBG_ASSERT( ( _rPropertyData.IndentLevel == 0 ) || ( _rPropertyData.IndentLevel == 1 ),
1131                 "OBrowserListBox::ChangeEntry: unsupported indent level!" );
1132             rLine.pLine->IndentTitle( _rPropertyData.IndentLevel > 0 );
1133
1134             if ( nPos > 0 )
1135                 rLine.pLine->SetTabOrder( pRefWindow, ZOrderFlags::Behind );
1136             else
1137                 rLine.pLine->SetTabOrder( pRefWindow, ZOrderFlags::First );
1138
1139             m_aOutOfDateLines.insert( nPos );
1140             rLine.pLine->SetComponentHelpIds(
1141                 HelpIdUrl::getHelpId( _rPropertyData.HelpURL )
1142             );
1143
1144             if ( _rPropertyData.bReadOnly )
1145             {
1146                 rLine.pLine->SetReadOnly( true );
1147
1148                 // user controls (i.e. the ones not provided by the usual
1149                 // XPropertyControlFactory) have no chance to know that they should be read-only,
1150                 // since XPropertyHandler::describePropertyLine does not transport this
1151                 // information.
1152                 // So, we manually switch this to read-only.
1153                 if ( xControl.is() && ( xControl->getControlType() == PropertyControlType::Unknown ) )
1154                 {
1155                     vcl::Window *pWindow = rLine.pLine->getControlWindow();
1156                     Edit* pControlWindowAsEdit = dynamic_cast<Edit*>(pWindow);
1157                     if (pControlWindowAsEdit)
1158                         pControlWindowAsEdit->SetReadOnly();
1159                     else
1160                         pWindow->Enable(false);
1161                 }
1162             }
1163         }
1164     }
1165
1166
1167     bool OBrowserListBox::PreNotify( NotifyEvent& _rNEvt )
1168     {
1169         switch ( _rNEvt.GetType() )
1170         {
1171             case MouseNotifyEvent::KEYINPUT:
1172             {
1173                 const KeyEvent* pKeyEvent = _rNEvt.GetKeyEvent();
1174                 if  (   ( pKeyEvent->GetKeyCode().GetModifier() != 0 )
1175                     ||  (   ( pKeyEvent->GetKeyCode().GetCode() != KEY_PAGEUP )
1176                         &&  ( pKeyEvent->GetKeyCode().GetCode() != KEY_PAGEDOWN )
1177                         )
1178                     )
1179                     break;
1180
1181                 long nScrollOffset = 0;
1182                 if ( m_aVScroll->IsVisible() )
1183                 {
1184                     if ( pKeyEvent->GetKeyCode().GetCode() == KEY_PAGEUP )
1185                         nScrollOffset = -m_aVScroll->GetPageSize();
1186                     else if ( pKeyEvent->GetKeyCode().GetCode() == KEY_PAGEDOWN )
1187                         nScrollOffset = m_aVScroll->GetPageSize();
1188                 }
1189
1190                 if ( nScrollOffset )
1191                 {
1192                     long nNewThumbPos = m_aVScroll->GetThumbPos() + nScrollOffset;
1193                     nNewThumbPos = std::max( nNewThumbPos, m_aVScroll->GetRangeMin() );
1194                     nNewThumbPos = std::min( nNewThumbPos, m_aVScroll->GetRangeMax() );
1195                     m_aVScroll->DoScroll( nNewThumbPos );
1196                     nNewThumbPos = m_aVScroll->GetThumbPos();
1197
1198                     sal_uInt16 nFocusControlPos = 0;
1199                     sal_uInt16 nActiveControlPos = impl_getControlPos( m_xActiveControl );
1200                     if ( nActiveControlPos < nNewThumbPos )
1201                         nFocusControlPos = (sal_uInt16)nNewThumbPos;
1202                     else if ( nActiveControlPos >= nNewThumbPos + CalcVisibleLines() )
1203                         nFocusControlPos = (sal_uInt16)nNewThumbPos + CalcVisibleLines() - 1;
1204                     if ( nFocusControlPos )
1205                     {
1206                         if ( nFocusControlPos < m_aLines.size() )
1207                         {
1208                             m_aLines[ nFocusControlPos ].pLine->GrabFocus();
1209                         }
1210                         else
1211                             OSL_FAIL( "OBrowserListBox::PreNotify: internal error, invalid focus control position!" );
1212                     }
1213                 }
1214
1215                 return true;
1216                 // handled this. In particular, we also consume PageUp/Down events if we do not use them for scrolling,
1217                 // otherwise they would be used to scroll the document view, which does not sound like it is desired by
1218                 // the user.
1219             }
1220             default:
1221                 break;
1222         }
1223         return Control::PreNotify( _rNEvt );
1224     }
1225
1226     bool OBrowserListBox::EventNotify( NotifyEvent& _rNEvt )
1227     {
1228         if ( _rNEvt.GetType() == MouseNotifyEvent::COMMAND)
1229         {
1230             const CommandEvent* pCommand = _rNEvt.GetCommandEvent();
1231             if  (   ( CommandEventId::Wheel == pCommand->GetCommand() )
1232                 ||  ( CommandEventId::StartAutoScroll == pCommand->GetCommand() )
1233                 ||  ( CommandEventId::AutoScroll == pCommand->GetCommand() )
1234                 )
1235             {
1236                 // interested in scroll events if we have a scrollbar
1237                 if ( m_aVScroll->IsVisible() )
1238                 {
1239                     HandleScrollCommand( *pCommand, nullptr, m_aVScroll.get() );
1240                 }
1241             }
1242         }
1243         return Control::EventNotify(_rNEvt);
1244     }
1245
1246
1247 } // namespace pcr
1248
1249
1250 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */