extensions/source/propctrlr/browserlistbox.cxx

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