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