1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_toolkit.hxx" 26 27 #include <com/sun/star/awt/WindowEvent.hpp> 28 #include <com/sun/star/awt/KeyEvent.hpp> 29 #include <com/sun/star/awt/KeyModifier.hpp> 30 #include <com/sun/star/awt/MouseEvent.hpp> 31 #include <com/sun/star/awt/MouseButton.hpp> 32 #include <com/sun/star/awt/MouseWheelBehavior.hpp> 33 #include <com/sun/star/awt/XTopWindow.hpp> 34 #include <com/sun/star/awt/Style.hpp> 35 #include <com/sun/star/accessibility/AccessibleRole.hpp> 36 #include <com/sun/star/awt/DockingEvent.hpp> 37 #include <com/sun/star/awt/EndDockingEvent.hpp> 38 #include <com/sun/star/awt/EndPopupModeEvent.hpp> 39 #include <com/sun/star/awt/XWindowListener2.hpp> 40 #include <com/sun/star/style/VerticalAlignment.hpp> 41 #include <com/sun/star/lang/DisposedException.hpp> 42 #include <com/sun/star/text/WritingMode2.hpp> 43 #include <toolkit/awt/vclxwindow.hxx> 44 #include <toolkit/awt/vclxpointer.hxx> 45 #include <toolkit/awt/vclxwindows.hxx> 46 #include <toolkit/helper/macros.hxx> 47 #include <toolkit/helper/vclunohelper.hxx> 48 #include <toolkit/helper/convert.hxx> 49 #include <toolkit/helper/macros.hxx> 50 #include <toolkit/helper/property.hxx> 51 #include <toolkit/helper/accessibilityclient.hxx> 52 #include <cppuhelper/typeprovider.hxx> 53 #include <rtl/memory.h> 54 #include <rtl/uuid.h> 55 #include <rtl/ustrbuf.hxx> 56 #include <vcl/svapp.hxx> 57 #include <vcl/window.hxx> 58 #include <tools/color.hxx> 59 #include <vcl/dockwin.hxx> 60 #include <vcl/pdfextoutdevdata.hxx> 61 #include <vcl/tabpage.hxx> 62 #include <vcl/button.hxx> 63 #include <comphelper/asyncnotification.hxx> 64 #include <comphelper/flagguard.hxx> 65 #include <toolkit/helper/solarrelease.hxx> 66 #include "stylesettings.hxx" 67 #include <tools/urlobj.hxx> 68 #include <toolkit/helper/unopropertyarrayhelper.hxx> 69 70 #include <boost/bind.hpp> 71 72 using namespace ::com::sun::star; 73 74 using ::com::sun::star::uno::Reference; 75 using ::com::sun::star::uno::UNO_QUERY; 76 using ::com::sun::star::uno::RuntimeException; 77 using ::com::sun::star::lang::EventObject; 78 using ::com::sun::star::awt::XWindowListener2; 79 using ::com::sun::star::awt::XDockableWindowListener; 80 using ::com::sun::star::awt::XDevice; 81 using ::com::sun::star::awt::XStyleSettings; 82 using ::com::sun::star::lang::DisposedException; 83 using ::com::sun::star::style::VerticalAlignment; 84 using ::com::sun::star::style::VerticalAlignment_TOP; 85 using ::com::sun::star::style::VerticalAlignment_MIDDLE; 86 using ::com::sun::star::style::VerticalAlignment_BOTTOM; 87 using ::com::sun::star::style::VerticalAlignment_MAKE_FIXED_SIZE; 88 89 namespace WritingMode2 = ::com::sun::star::text::WritingMode2; 90 namespace MouseWheelBehavior = ::com::sun::star::awt::MouseWheelBehavior; 91 92 using ::toolkit::ReleaseSolarMutex; 93 94 //==================================================================== 95 //= VCLXWindowImpl 96 //==================================================================== 97 class SAL_DLLPRIVATE VCLXWindowImpl 98 { 99 private: 100 typedef ::std::vector< VCLXWindow::Callback > CallbackArray; 101 102 private: 103 VCLXWindow& mrAntiImpl; 104 ::vos::IMutex& mrMutex; 105 ::toolkit::AccessibilityClient maAccFactory; 106 bool mbDisposed; 107 bool mbDrawingOntoParent; // no bit mask, is passed around by reference 108 sal_Bool mbEnableVisible; 109 sal_Bool mbDirectVisible; 110 111 ::osl::Mutex maListenerContainerMutex; 112 ::cppu::OInterfaceContainerHelper maWindow2Listeners; 113 ::cppu::OInterfaceContainerHelper maDockableWindowListeners; 114 EventListenerMultiplexer maEventListeners; 115 FocusListenerMultiplexer maFocusListeners; 116 WindowListenerMultiplexer maWindowListeners; 117 KeyListenerMultiplexer maKeyListeners; 118 MouseListenerMultiplexer maMouseListeners; 119 MouseMotionListenerMultiplexer maMouseMotionListeners; 120 PaintListenerMultiplexer maPaintListeners; 121 VclContainerListenerMultiplexer maContainerListeners; 122 TopWindowListenerMultiplexer maTopWindowListeners; 123 124 CallbackArray maCallbackEvents; 125 sal_uLong mnCallbackEventId; 126 127 public: 128 bool mbDisposing : 1; 129 bool mbDesignMode : 1; 130 bool mbSynthesizingVCLEvent : 1; 131 bool mbWithDefaultProps : 1; 132 133 sal_uLong mnListenerLockLevel; 134 sal_Int16 mnWritingMode; 135 sal_Int16 mnContextWritingMode; 136 137 UnoPropertyArrayHelper* mpPropHelper; 138 139 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XPointer > 140 mxPointer; 141 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > 142 mxAccessibleContext; 143 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XGraphics > 144 mxViewGraphics; 145 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XStyleSettings > 146 mxWindowStyleSettings; 147 148 public: 149 bool& getDrawingOntoParent_ref() { return mbDrawingOntoParent; } 150 151 public: 152 /** ctor 153 @param _pAntiImpl 154 the <type>VCLXWindow</type> instance which the object belongs to. Must 155 live longer then the object just being constructed. 156 */ 157 VCLXWindowImpl( VCLXWindow& _rAntiImpl, ::vos::IMutex& _rMutex, bool _bWithDefaultProps ); 158 159 /** synchronously mbEnableVisible 160 */ 161 void setEnableVisible( sal_Bool bEnableVisible ) { mbEnableVisible = bEnableVisible; } 162 sal_Bool isEnableVisible() { return mbEnableVisible; } 163 /** synchronously mbDirectVisible; 164 */ 165 void setDirectVisible( sal_Bool bDirectVisible ) { mbDirectVisible = bDirectVisible; } 166 sal_Bool isDirectVisible() { return mbDirectVisible; } 167 168 /** impl-version of VCLXWindow::ImplExecuteAsyncWithoutSolarLock 169 */ 170 void callBackAsync( const VCLXWindow::Callback& i_callback ); 171 172 /** notifies the object that its VCLXWindow is being disposed 173 */ 174 void disposing(); 175 176 inline ::toolkit::AccessibilityClient& getAccessibleFactory() 177 { 178 return maAccFactory; 179 } 180 181 Reference< XStyleSettings > getStyleSettings(); 182 183 /** returns the container of registered XWindowListener2 listeners 184 */ 185 inline ::cppu::OInterfaceContainerHelper& getWindow2Listeners() { return maWindow2Listeners; } 186 inline ::cppu::OInterfaceContainerHelper& getDockableWindowListeners(){ return maDockableWindowListeners; } 187 inline EventListenerMultiplexer& getEventListeners() { return maEventListeners; } 188 inline FocusListenerMultiplexer& getFocusListeners() { return maFocusListeners; } 189 inline WindowListenerMultiplexer& getWindowListeners() { return maWindowListeners; } 190 inline KeyListenerMultiplexer& getKeyListeners() { return maKeyListeners; } 191 inline MouseListenerMultiplexer& getMouseListeners() { return maMouseListeners; } 192 inline MouseMotionListenerMultiplexer& getMouseMotionListeners() { return maMouseMotionListeners; } 193 inline PaintListenerMultiplexer& getPaintListeners() { return maPaintListeners; } 194 inline VclContainerListenerMultiplexer& getContainerListeners() { return maContainerListeners; } 195 inline TopWindowListenerMultiplexer& getTopWindowListeners() { return maTopWindowListeners; } 196 197 virtual ~VCLXWindowImpl(); 198 199 protected: 200 virtual void SAL_CALL acquire(); 201 virtual void SAL_CALL release(); 202 203 private: 204 DECL_LINK( OnProcessCallbacks, void* ); 205 206 private: 207 VCLXWindowImpl(); // never implemented 208 VCLXWindowImpl( const VCLXWindowImpl& ); // never implemented 209 VCLXWindowImpl& operator=( const VCLXWindowImpl& ); // never implemented 210 }; 211 212 //-------------------------------------------------------------------- 213 VCLXWindowImpl::VCLXWindowImpl( VCLXWindow& _rAntiImpl, ::vos::IMutex& _rMutex, bool _bWithDefaultProps ) 214 :mrAntiImpl( _rAntiImpl ) 215 ,mrMutex( _rMutex ) 216 ,mbDisposed( false ) 217 ,mbDrawingOntoParent( false ) 218 ,mbEnableVisible(sal_True) 219 ,mbDirectVisible(sal_True) 220 ,maListenerContainerMutex( ) 221 ,maWindow2Listeners( maListenerContainerMutex ) 222 ,maDockableWindowListeners( maListenerContainerMutex ) 223 ,maEventListeners( _rAntiImpl ) 224 ,maFocusListeners( _rAntiImpl ) 225 ,maWindowListeners( _rAntiImpl ) 226 ,maKeyListeners( _rAntiImpl ) 227 ,maMouseListeners( _rAntiImpl ) 228 ,maMouseMotionListeners( _rAntiImpl ) 229 ,maPaintListeners( _rAntiImpl ) 230 ,maContainerListeners( _rAntiImpl ) 231 ,maTopWindowListeners( _rAntiImpl ) 232 ,mnCallbackEventId( 0 ) 233 ,mbDisposing( false ) 234 ,mbDesignMode( false ) 235 ,mbSynthesizingVCLEvent( false ) 236 ,mbWithDefaultProps( _bWithDefaultProps ) 237 ,mnListenerLockLevel( 0 ) 238 ,mnWritingMode( WritingMode2::CONTEXT ) 239 ,mnContextWritingMode( WritingMode2::CONTEXT ) 240 ,mpPropHelper( NULL ) 241 { 242 } 243 244 VCLXWindowImpl::~VCLXWindowImpl() 245 { 246 delete mpPropHelper; 247 } 248 249 //-------------------------------------------------------------------- 250 void VCLXWindowImpl::disposing() 251 { 252 ::vos::OGuard aGuard( mrMutex ); 253 if ( mnCallbackEventId ) 254 Application::RemoveUserEvent( mnCallbackEventId ); 255 mnCallbackEventId = 0; 256 257 mbDisposed= true; 258 259 ::com::sun::star::lang::EventObject aEvent; 260 aEvent.Source = mrAntiImpl; 261 262 maEventListeners.disposeAndClear( aEvent ); 263 maFocusListeners.disposeAndClear( aEvent ); 264 maWindowListeners.disposeAndClear( aEvent ); 265 maKeyListeners.disposeAndClear( aEvent ); 266 maMouseListeners.disposeAndClear( aEvent ); 267 maMouseMotionListeners.disposeAndClear( aEvent ); 268 maPaintListeners.disposeAndClear( aEvent ); 269 maContainerListeners.disposeAndClear( aEvent ); 270 maTopWindowListeners.disposeAndClear( aEvent ); 271 272 ::toolkit::WindowStyleSettings* pStyleSettings = static_cast< ::toolkit::WindowStyleSettings* >( mxWindowStyleSettings.get() ); 273 if ( pStyleSettings != NULL ) 274 pStyleSettings->dispose(); 275 mxWindowStyleSettings.clear(); 276 } 277 278 //-------------------------------------------------------------------- 279 void VCLXWindowImpl::callBackAsync( const VCLXWindow::Callback& i_callback ) 280 { 281 DBG_TESTSOLARMUTEX(); 282 maCallbackEvents.push_back( i_callback ); 283 if ( !mnCallbackEventId ) 284 { 285 // ensure our VCLXWindow is not destroyed while the event is underway 286 mrAntiImpl.acquire(); 287 mnCallbackEventId = Application::PostUserEvent( LINK( this, VCLXWindowImpl, OnProcessCallbacks ) ); 288 } 289 } 290 291 //---------------------------------------------------------------------------------------------------------------------- 292 IMPL_LINK( VCLXWindowImpl, OnProcessCallbacks, void*, EMPTYARG ) 293 { 294 const Reference< uno::XInterface > xKeepAlive( mrAntiImpl ); 295 296 // work on a copy of the callback array 297 CallbackArray aCallbacksCopy; 298 { 299 ::vos::OGuard aGuard( mrMutex ); 300 aCallbacksCopy = maCallbackEvents; 301 maCallbackEvents.clear(); 302 303 // we acquired our VCLXWindow once before posting the event, release this one ref now 304 mrAntiImpl.release(); 305 306 if ( !mnCallbackEventId ) 307 // we were disposed while waiting for the mutex to lock 308 return 1L; 309 310 mnCallbackEventId = 0; 311 } 312 313 { 314 ReleaseSolarMutex aReleaseSolar( ReleaseSolarMutex::RescheduleDuringAcquire ); 315 for ( CallbackArray::const_iterator loop = aCallbacksCopy.begin(); 316 loop != aCallbacksCopy.end(); 317 ++loop 318 ) 319 { 320 (*loop)(); 321 } 322 } 323 324 return 0L; 325 } 326 327 //-------------------------------------------------------------------- 328 void SAL_CALL VCLXWindowImpl::acquire() 329 { 330 mrAntiImpl.acquire(); 331 } 332 333 //-------------------------------------------------------------------- 334 void SAL_CALL VCLXWindowImpl::release() 335 { 336 mrAntiImpl.release(); 337 } 338 339 //-------------------------------------------------------------------- 340 Reference< XStyleSettings > VCLXWindowImpl::getStyleSettings() 341 { 342 ::vos::OGuard aGuard( mrMutex ); 343 if ( mbDisposed ) 344 throw DisposedException( ::rtl::OUString(), mrAntiImpl ); 345 if ( !mxWindowStyleSettings.is() ) 346 mxWindowStyleSettings = new ::toolkit::WindowStyleSettings( mrMutex, maListenerContainerMutex, mrAntiImpl ); 347 return mxWindowStyleSettings; 348 } 349 350 //==================================================================== 351 //==================================================================== 352 353 // Mit Out-Parameter besser als Rueckgabewert, wegen Ref-Objekt... 354 355 void ImplInitWindowEvent( ::com::sun::star::awt::WindowEvent& rEvent, Window* pWindow ) 356 { 357 Point aPos = pWindow->GetPosPixel(); 358 Size aSz = pWindow->GetSizePixel(); 359 360 rEvent.X = aPos.X(); 361 rEvent.Y = aPos.Y(); 362 363 rEvent.Width = aSz.Width(); 364 rEvent.Height = aSz.Height(); 365 366 pWindow->GetBorder( rEvent.LeftInset, rEvent.TopInset, rEvent.RightInset, rEvent.BottomInset ); 367 } 368 369 // ---------------------------------------------------- 370 // class VCLXWindow 371 // ---------------------------------------------------- 372 373 DBG_NAME(VCLXWindow); 374 375 VCLXWindow::VCLXWindow( bool _bWithDefaultProps ) 376 :mpImpl( NULL ) 377 { 378 DBG_CTOR( VCLXWindow, 0 ); 379 380 mpImpl = new VCLXWindowImpl( *this, GetMutex(), _bWithDefaultProps ); 381 } 382 383 VCLXWindow::~VCLXWindow() 384 { 385 DBG_DTOR( VCLXWindow, 0 ); 386 387 delete mpImpl; 388 389 if ( GetWindow() ) 390 { 391 GetWindow()->RemoveEventListener( LINK( this, VCLXWindow, WindowEventListener ) ); 392 GetWindow()->SetWindowPeer( NULL, NULL ); 393 GetWindow()->SetAccessible( NULL ); 394 } 395 } 396 397 //---------------------------------------------------------------------------------------------------------------------- 398 void VCLXWindow::ImplExecuteAsyncWithoutSolarLock( const Callback& i_callback ) 399 { 400 mpImpl->callBackAsync( i_callback ); 401 } 402 403 //---------------------------------------------------------------------------------------------------------------------- 404 ::toolkit::IAccessibleFactory& VCLXWindow::getAccessibleFactory() 405 { 406 return mpImpl->getAccessibleFactory().getFactory(); 407 } 408 409 void VCLXWindow::SetWindow( Window* pWindow ) 410 { 411 if ( GetWindow() ) 412 { 413 GetWindow()->RemoveEventListener( LINK( this, VCLXWindow, WindowEventListener ) ); 414 // GetWindow()->DbgAssertNoEventListeners(); 415 } 416 417 SetOutputDevice( pWindow ); 418 419 if ( GetWindow() ) 420 { 421 GetWindow()->AddEventListener( LINK( this, VCLXWindow, WindowEventListener ) ); 422 sal_Bool bDirectVisible = pWindow ? pWindow->IsVisible() : false; 423 mpImpl->setDirectVisible( bDirectVisible ); 424 } 425 426 } 427 428 void VCLXWindow::suspendVclEventListening( ) 429 { 430 ++mpImpl->mnListenerLockLevel; 431 } 432 433 void VCLXWindow::resumeVclEventListening( ) 434 { 435 DBG_ASSERT( mpImpl->mnListenerLockLevel, "VCLXWindow::resumeVclEventListening: not suspended!" ); 436 --mpImpl->mnListenerLockLevel; 437 } 438 439 void VCLXWindow::notifyWindowRemoved( Window& _rWindow ) 440 { 441 if ( mpImpl->getContainerListeners().getLength() ) 442 { 443 awt::VclContainerEvent aEvent; 444 aEvent.Source = *this; 445 aEvent.Child = static_cast< XWindow* >( _rWindow.GetWindowPeer() ); 446 mpImpl->getContainerListeners().windowRemoved( aEvent ); 447 } 448 } 449 450 IMPL_LINK( VCLXWindow, WindowEventListener, VclSimpleEvent*, pEvent ) 451 { 452 if ( mpImpl->mnListenerLockLevel ) 453 return 0L; 454 455 DBG_ASSERT( pEvent && pEvent->ISA( VclWindowEvent ), "Unknown WindowEvent!" ); 456 if ( pEvent && pEvent->ISA( VclWindowEvent ) ) 457 { 458 DBG_ASSERT( ((VclWindowEvent*)pEvent)->GetWindow() && GetWindow(), "Window???" ); 459 ProcessWindowEvent( *(VclWindowEvent*)pEvent ); 460 } 461 return 0; 462 } 463 464 namespace 465 { 466 struct CallWindow2Listener 467 { 468 CallWindow2Listener( ::cppu::OInterfaceContainerHelper& i_rWindow2Listeners, const bool i_bEnabled, const EventObject& i_rEvent ) 469 :m_rWindow2Listeners( i_rWindow2Listeners ) 470 ,m_bEnabled( i_bEnabled ) 471 ,m_aEvent( i_rEvent ) 472 { 473 } 474 475 void operator()() 476 { 477 m_rWindow2Listeners.notifyEach( m_bEnabled ? &XWindowListener2::windowEnabled : &XWindowListener2::windowDisabled, m_aEvent ); 478 } 479 480 ::cppu::OInterfaceContainerHelper& m_rWindow2Listeners; 481 const bool m_bEnabled; 482 const EventObject m_aEvent; 483 }; 484 } 485 486 void VCLXWindow::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent ) 487 { 488 ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xThis( (::cppu::OWeakObject*)this ); 489 490 switch ( rVclWindowEvent.GetId() ) 491 { 492 case VCLEVENT_WINDOW_ENABLED: 493 case VCLEVENT_WINDOW_DISABLED: 494 { 495 Callback aCallback = CallWindow2Listener( 496 mpImpl->getWindow2Listeners(), 497 ( VCLEVENT_WINDOW_ENABLED == rVclWindowEvent.GetId() ), 498 EventObject( *this ) 499 ); 500 ImplExecuteAsyncWithoutSolarLock( aCallback ); 501 } 502 break; 503 504 case VCLEVENT_WINDOW_PAINT: 505 { 506 if ( mpImpl->getPaintListeners().getLength() ) 507 { 508 ::com::sun::star::awt::PaintEvent aEvent; 509 aEvent.Source = (::cppu::OWeakObject*)this; 510 aEvent.UpdateRect = AWTRectangle( *(Rectangle*)rVclWindowEvent.GetData() ); 511 aEvent.Count = 0; 512 mpImpl->getPaintListeners().windowPaint( aEvent ); 513 } 514 } 515 break; 516 case VCLEVENT_WINDOW_MOVE: 517 { 518 if ( mpImpl->getWindowListeners().getLength() ) 519 { 520 ::com::sun::star::awt::WindowEvent aEvent; 521 aEvent.Source = (::cppu::OWeakObject*)this; 522 ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() ); 523 mpImpl->getWindowListeners().windowMoved( aEvent ); 524 } 525 } 526 break; 527 case VCLEVENT_WINDOW_RESIZE: 528 { 529 if ( mpImpl->getWindowListeners().getLength() ) 530 { 531 ::com::sun::star::awt::WindowEvent aEvent; 532 aEvent.Source = (::cppu::OWeakObject*)this; 533 ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() ); 534 mpImpl->getWindowListeners().windowResized( aEvent ); 535 } 536 } 537 break; 538 case VCLEVENT_WINDOW_SHOW: 539 { 540 if ( mpImpl->getWindowListeners().getLength() ) 541 { 542 ::com::sun::star::awt::WindowEvent aEvent; 543 aEvent.Source = (::cppu::OWeakObject*)this; 544 ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() ); 545 mpImpl->getWindowListeners().windowShown( aEvent ); 546 } 547 548 // For TopWindows this means opened... 549 if ( mpImpl->getTopWindowListeners().getLength() ) 550 { 551 ::com::sun::star::lang::EventObject aEvent; 552 aEvent.Source = (::cppu::OWeakObject*)this; 553 mpImpl->getTopWindowListeners().windowOpened( aEvent ); 554 } 555 } 556 break; 557 case VCLEVENT_WINDOW_HIDE: 558 { 559 if ( mpImpl->getWindowListeners().getLength() ) 560 { 561 ::com::sun::star::awt::WindowEvent aEvent; 562 aEvent.Source = (::cppu::OWeakObject*)this; 563 ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() ); 564 mpImpl->getWindowListeners().windowHidden( aEvent ); 565 } 566 567 // For TopWindows this means closed... 568 if ( mpImpl->getTopWindowListeners().getLength() ) 569 { 570 ::com::sun::star::lang::EventObject aEvent; 571 aEvent.Source = (::cppu::OWeakObject*)this; 572 mpImpl->getTopWindowListeners().windowClosed( aEvent ); 573 } 574 } 575 break; 576 case VCLEVENT_WINDOW_ACTIVATE: 577 { 578 if ( mpImpl->getTopWindowListeners().getLength() ) 579 { 580 ::com::sun::star::lang::EventObject aEvent; 581 aEvent.Source = (::cppu::OWeakObject*)this; 582 mpImpl->getTopWindowListeners().windowActivated( aEvent ); 583 } 584 } 585 break; 586 case VCLEVENT_WINDOW_DEACTIVATE: 587 { 588 if ( mpImpl->getTopWindowListeners().getLength() ) 589 { 590 ::com::sun::star::lang::EventObject aEvent; 591 aEvent.Source = (::cppu::OWeakObject*)this; 592 mpImpl->getTopWindowListeners().windowDeactivated( aEvent ); 593 } 594 } 595 break; 596 case VCLEVENT_WINDOW_CLOSE: 597 { 598 if ( mpImpl->getDockableWindowListeners().getLength() ) 599 { 600 ::com::sun::star::lang::EventObject aEvent; 601 aEvent.Source = (::cppu::OWeakObject*)this; 602 mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::closed, aEvent ); 603 } 604 if ( mpImpl->getTopWindowListeners().getLength() ) 605 { 606 ::com::sun::star::lang::EventObject aEvent; 607 aEvent.Source = (::cppu::OWeakObject*)this; 608 mpImpl->getTopWindowListeners().windowClosing( aEvent ); 609 } 610 } 611 break; 612 case VCLEVENT_CONTROL_GETFOCUS: 613 case VCLEVENT_WINDOW_GETFOCUS: 614 { 615 if ( ( rVclWindowEvent.GetWindow()->IsCompoundControl() 616 && rVclWindowEvent.GetId() == VCLEVENT_CONTROL_GETFOCUS 617 ) 618 || ( !rVclWindowEvent.GetWindow()->IsCompoundControl() 619 && rVclWindowEvent.GetId() == VCLEVENT_WINDOW_GETFOCUS 620 ) 621 ) 622 { 623 if ( mpImpl->getFocusListeners().getLength() ) 624 { 625 ::com::sun::star::awt::FocusEvent aEvent; 626 aEvent.Source = (::cppu::OWeakObject*)this; 627 aEvent.FocusFlags = rVclWindowEvent.GetWindow()->GetGetFocusFlags(); 628 aEvent.Temporary = sal_False; 629 mpImpl->getFocusListeners().focusGained( aEvent ); 630 } 631 } 632 } 633 break; 634 case VCLEVENT_CONTROL_LOSEFOCUS: 635 case VCLEVENT_WINDOW_LOSEFOCUS: 636 { 637 if ( ( rVclWindowEvent.GetWindow()->IsCompoundControl() 638 && rVclWindowEvent.GetId() == VCLEVENT_CONTROL_LOSEFOCUS 639 ) 640 || ( !rVclWindowEvent.GetWindow()->IsCompoundControl() 641 && rVclWindowEvent.GetId() == VCLEVENT_WINDOW_LOSEFOCUS 642 ) 643 ) 644 { 645 if ( mpImpl->getFocusListeners().getLength() ) 646 { 647 ::com::sun::star::awt::FocusEvent aEvent; 648 aEvent.Source = (::cppu::OWeakObject*)this; 649 aEvent.FocusFlags = rVclWindowEvent.GetWindow()->GetGetFocusFlags(); 650 aEvent.Temporary = sal_False; 651 652 Window* pNext = Application::GetFocusWindow(); 653 if ( pNext ) 654 { 655 // Bei zusammengesetzten Controls interessiert sich keiner fuer das Innenleben: 656 Window* pNextC = pNext; 657 while ( pNextC && !pNextC->IsCompoundControl() ) 658 pNextC = pNextC->GetParent(); 659 if ( pNextC ) 660 pNext = pNextC; 661 662 pNext->GetComponentInterface( sal_True ); 663 aEvent.NextFocus = (::cppu::OWeakObject*)pNext->GetWindowPeer(); 664 } 665 mpImpl->getFocusListeners().focusLost( aEvent ); 666 } 667 } 668 } 669 break; 670 case VCLEVENT_WINDOW_MINIMIZE: 671 { 672 if ( mpImpl->getTopWindowListeners().getLength() ) 673 { 674 ::com::sun::star::lang::EventObject aEvent; 675 aEvent.Source = (::cppu::OWeakObject*)this; 676 mpImpl->getTopWindowListeners().windowMinimized( aEvent ); 677 } 678 } 679 break; 680 case VCLEVENT_WINDOW_NORMALIZE: 681 { 682 if ( mpImpl->getTopWindowListeners().getLength() ) 683 { 684 ::com::sun::star::lang::EventObject aEvent; 685 aEvent.Source = (::cppu::OWeakObject*)this; 686 mpImpl->getTopWindowListeners().windowNormalized( aEvent ); 687 } 688 } 689 break; 690 case VCLEVENT_WINDOW_KEYINPUT: 691 { 692 if ( mpImpl->getKeyListeners().getLength() ) 693 { 694 ::com::sun::star::awt::KeyEvent aEvent( VCLUnoHelper::createKeyEvent( 695 *(KeyEvent*)rVclWindowEvent.GetData(), *this 696 ) ); 697 mpImpl->getKeyListeners().keyPressed( aEvent ); 698 } 699 } 700 break; 701 case VCLEVENT_WINDOW_KEYUP: 702 { 703 if ( mpImpl->getKeyListeners().getLength() ) 704 { 705 ::com::sun::star::awt::KeyEvent aEvent( VCLUnoHelper::createKeyEvent( 706 *(KeyEvent*)rVclWindowEvent.GetData(), *this 707 ) ); 708 mpImpl->getKeyListeners().keyReleased( aEvent ); 709 } 710 } 711 break; 712 case VCLEVENT_WINDOW_COMMAND: 713 { 714 CommandEvent* pCmdEvt = (CommandEvent*)rVclWindowEvent.GetData(); 715 if ( mpImpl->getMouseListeners().getLength() && ( pCmdEvt->GetCommand() == COMMAND_CONTEXTMENU ) ) 716 { 717 // COMMAND_CONTEXTMENU als mousePressed mit PopupTrigger = sal_True versenden... 718 Point aWhere = static_cast< CommandEvent* >( rVclWindowEvent.GetData() )->GetMousePosPixel(); 719 if ( !pCmdEvt->IsMouseEvent() ) 720 { // for keyboard events, we set the coordinates to -1,-1. This is a slight HACK, but the current API 721 // handles a context menu command as special case of a mouse event, which is simply wrong. 722 // Without extending the API, we would not have another chance to notify listeners of a 723 // keyboard-triggered context menu request 724 // 102205 - 16.08.2002 - fs@openoffice.org 725 aWhere = Point( -1, -1 ); 726 } 727 728 MouseEvent aMEvt( aWhere, 1, MOUSE_SIMPLECLICK, MOUSE_LEFT, 0 ); 729 awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( aMEvt, *this ) ); 730 aEvent.PopupTrigger = sal_True; 731 732 Callback aCallback = ::boost::bind( 733 &MouseListenerMultiplexer::mousePressed, 734 &mpImpl->getMouseListeners(), 735 aEvent 736 ); 737 ImplExecuteAsyncWithoutSolarLock( aCallback ); 738 } 739 } 740 break; 741 case VCLEVENT_WINDOW_MOUSEMOVE: 742 { 743 MouseEvent* pMouseEvt = (MouseEvent*)rVclWindowEvent.GetData(); 744 if ( mpImpl->getMouseListeners().getLength() && ( pMouseEvt->IsEnterWindow() || pMouseEvt->IsLeaveWindow() ) ) 745 { 746 awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( *pMouseEvt, *this ) ); 747 748 Callback aCallback = ::boost::bind( 749 pMouseEvt->IsEnterWindow() ? &MouseListenerMultiplexer::mouseEntered : &MouseListenerMultiplexer::mouseExited, 750 &mpImpl->getMouseListeners(), 751 aEvent 752 ); 753 ImplExecuteAsyncWithoutSolarLock( aCallback ); 754 } 755 756 if ( mpImpl->getMouseMotionListeners().getLength() && !pMouseEvt->IsEnterWindow() && !pMouseEvt->IsLeaveWindow() ) 757 { 758 awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( *pMouseEvt, *this ) ); 759 aEvent.ClickCount = 0; // #92138# 760 if ( pMouseEvt->GetMode() & MOUSE_SIMPLEMOVE ) 761 mpImpl->getMouseMotionListeners().mouseMoved( aEvent ); 762 else 763 mpImpl->getMouseMotionListeners().mouseDragged( aEvent ); 764 } 765 } 766 break; 767 case VCLEVENT_WINDOW_MOUSEBUTTONDOWN: 768 { 769 if ( mpImpl->getMouseListeners().getLength() ) 770 { 771 awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( *(MouseEvent*)rVclWindowEvent.GetData(), *this ) ); 772 Callback aCallback = ::boost::bind( 773 &MouseListenerMultiplexer::mousePressed, 774 &mpImpl->getMouseListeners(), 775 aEvent 776 ); 777 ImplExecuteAsyncWithoutSolarLock( aCallback ); 778 } 779 } 780 break; 781 case VCLEVENT_WINDOW_MOUSEBUTTONUP: 782 { 783 if ( mpImpl->getMouseListeners().getLength() ) 784 { 785 awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( *(MouseEvent*)rVclWindowEvent.GetData(), *this ) ); 786 Callback aCallback = ::boost::bind( 787 &MouseListenerMultiplexer::mouseReleased, 788 &mpImpl->getMouseListeners(), 789 aEvent 790 ); 791 ImplExecuteAsyncWithoutSolarLock( aCallback ); 792 } 793 } 794 break; 795 case VCLEVENT_WINDOW_STARTDOCKING: 796 { 797 if ( mpImpl->getDockableWindowListeners().getLength() ) 798 { 799 DockingData *pData = (DockingData*)rVclWindowEvent.GetData(); 800 801 if( pData ) 802 { 803 ::com::sun::star::awt::DockingEvent aEvent; 804 aEvent.Source = (::cppu::OWeakObject*)this; 805 aEvent.TrackingRectangle = AWTRectangle( pData->maTrackRect ); 806 aEvent.MousePos.X = pData->maMousePos.X(); 807 aEvent.MousePos.Y = pData->maMousePos.Y(); 808 aEvent.bLiveMode = pData->mbLivemode; 809 aEvent.bInteractive = pData->mbInteractive; 810 811 mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::startDocking, aEvent ); 812 } 813 } 814 } 815 break; 816 case VCLEVENT_WINDOW_DOCKING: 817 { 818 if ( mpImpl->getDockableWindowListeners().getLength() ) 819 { 820 DockingData *pData = (DockingData*)rVclWindowEvent.GetData(); 821 822 if( pData ) 823 { 824 ::com::sun::star::awt::DockingEvent aEvent; 825 aEvent.Source = (::cppu::OWeakObject*)this; 826 aEvent.TrackingRectangle = AWTRectangle( pData->maTrackRect ); 827 aEvent.MousePos.X = pData->maMousePos.X(); 828 aEvent.MousePos.Y = pData->maMousePos.Y(); 829 aEvent.bLiveMode = pData->mbLivemode; 830 aEvent.bInteractive = pData->mbInteractive; 831 832 Reference< XDockableWindowListener > xFirstListener; 833 ::cppu::OInterfaceIteratorHelper aIter( mpImpl->getDockableWindowListeners() ); 834 while ( aIter.hasMoreElements() && !xFirstListener.is() ) 835 { 836 xFirstListener.set( aIter.next(), UNO_QUERY ); 837 } 838 839 ::com::sun::star::awt::DockingData aDockingData = 840 xFirstListener->docking( aEvent ); 841 pData->maTrackRect = VCLRectangle( aDockingData.TrackingRectangle ); 842 pData->mbFloating = aDockingData.bFloating; 843 } 844 } 845 } 846 break; 847 case VCLEVENT_WINDOW_ENDDOCKING: 848 { 849 if ( mpImpl->getDockableWindowListeners().getLength() ) 850 { 851 EndDockingData *pData = (EndDockingData*)rVclWindowEvent.GetData(); 852 853 if( pData ) 854 { 855 ::com::sun::star::awt::EndDockingEvent aEvent; 856 aEvent.Source = (::cppu::OWeakObject*)this; 857 aEvent.WindowRectangle = AWTRectangle( pData->maWindowRect ); 858 aEvent.bFloating = pData->mbFloating; 859 aEvent.bCancelled = pData->mbCancelled; 860 mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::endDocking, aEvent ); 861 } 862 } 863 } 864 break; 865 case VCLEVENT_WINDOW_PREPARETOGGLEFLOATING: 866 { 867 if ( mpImpl->getDockableWindowListeners().getLength() ) 868 { 869 sal_Bool *p_bFloating = (sal_Bool*)rVclWindowEvent.GetData(); 870 871 ::com::sun::star::lang::EventObject aEvent; 872 aEvent.Source = (::cppu::OWeakObject*)this; 873 874 Reference< XDockableWindowListener > xFirstListener; 875 ::cppu::OInterfaceIteratorHelper aIter( mpImpl->getDockableWindowListeners() ); 876 while ( aIter.hasMoreElements() && !xFirstListener.is() ) 877 { 878 xFirstListener.set( aIter.next(), UNO_QUERY ); 879 } 880 881 *p_bFloating = xFirstListener->prepareToggleFloatingMode( aEvent ); 882 } 883 } 884 break; 885 case VCLEVENT_WINDOW_TOGGLEFLOATING: 886 { 887 if ( mpImpl->getDockableWindowListeners().getLength() ) 888 { 889 ::com::sun::star::lang::EventObject aEvent; 890 aEvent.Source = (::cppu::OWeakObject*)this; 891 mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::toggleFloatingMode, aEvent ); 892 } 893 } 894 break; 895 case VCLEVENT_WINDOW_ENDPOPUPMODE: 896 { 897 if ( mpImpl->getDockableWindowListeners().getLength() ) 898 { 899 EndPopupModeData *pData = (EndPopupModeData*)rVclWindowEvent.GetData(); 900 901 if( pData ) 902 { 903 ::com::sun::star::awt::EndPopupModeEvent aEvent; 904 aEvent.Source = (::cppu::OWeakObject*)this; 905 aEvent.FloatingPosition.X = pData->maFloatingPos.X(); 906 aEvent.FloatingPosition.Y = pData->maFloatingPos.Y(); 907 aEvent.bTearoff = pData->mbTearoff; 908 mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::endPopupMode, aEvent ); 909 } 910 } 911 } 912 break; 913 914 } 915 } 916 917 uno::Reference< accessibility::XAccessibleContext > VCLXWindow::CreateAccessibleContext() 918 { 919 ::vos::OGuard aGuard( GetMutex() ); 920 return getAccessibleFactory().createAccessibleContext( this ); 921 } 922 923 void VCLXWindow::SetSynthesizingVCLEvent( sal_Bool _b ) 924 { 925 mpImpl->mbSynthesizingVCLEvent = _b; 926 } 927 928 sal_Bool VCLXWindow::IsSynthesizingVCLEvent() const 929 { 930 return mpImpl->mbSynthesizingVCLEvent; 931 } 932 933 Size VCLXWindow::ImplCalcWindowSize( const Size& rOutSz ) const 934 { 935 Size aSz = rOutSz; 936 937 Window* pWindow = GetWindow(); 938 if ( pWindow ) 939 { 940 sal_Int32 nLeft, nTop, nRight, nBottom; 941 pWindow->GetBorder( nLeft, nTop, nRight, nBottom ); 942 aSz.Width() += nLeft+nRight; 943 aSz.Height() += nTop+nBottom; 944 } 945 return aSz; 946 } 947 948 949 // ::com::sun::star::lang::XUnoTunnel 950 IMPL_XUNOTUNNEL2( VCLXWindow, VCLXDevice ) 951 952 // ::com::sun::star::lang::Component 953 void VCLXWindow::dispose( ) throw(::com::sun::star::uno::RuntimeException) 954 { 955 ::vos::OGuard aGuard( GetMutex() ); 956 957 mpImpl->mxViewGraphics = NULL; 958 959 if ( !mpImpl->mbDisposing ) 960 { 961 mpImpl->mbDisposing = true; 962 963 mpImpl->disposing(); 964 965 if ( GetWindow() ) 966 { 967 OutputDevice* pOutDev = GetOutputDevice(); 968 SetWindow( NULL ); // Damit ggf. Handler abgemeldet werden (virtuell). 969 SetOutputDevice( pOutDev ); 970 DestroyOutputDevice(); 971 } 972 973 // #i14103# dispose the accessible context after the window has been destroyed, 974 // otherwise the old value in the child event fired in VCLXAccessibleComponent::ProcessWindowEvent() 975 // for VCLEVENT_WINDOW_CHILDDESTROYED contains a reference to an already disposed accessible object 976 try 977 { 978 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent > xComponent( mpImpl->mxAccessibleContext, ::com::sun::star::uno::UNO_QUERY ); 979 if ( xComponent.is() ) 980 xComponent->dispose(); 981 } 982 catch ( const ::com::sun::star::uno::Exception& ) 983 { 984 DBG_ERROR( "VCLXWindow::dispose: could not dispose the accessible context!" ); 985 } 986 mpImpl->mxAccessibleContext.clear(); 987 988 mpImpl->mbDisposing = false; 989 } 990 } 991 992 void VCLXWindow::addEventListener( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException) 993 { 994 ::vos::OGuard aGuard( GetMutex() ); 995 996 mpImpl->getEventListeners().addInterface( rxListener ); 997 } 998 999 void VCLXWindow::removeEventListener( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException) 1000 { 1001 ::vos::OGuard aGuard( GetMutex() ); 1002 1003 mpImpl->getEventListeners().removeInterface( rxListener ); 1004 } 1005 1006 1007 // ::com::sun::star::awt::XWindow 1008 void VCLXWindow::setPosSize( sal_Int32 X, sal_Int32 Y, sal_Int32 Width, sal_Int32 Height, sal_Int16 Flags ) throw(::com::sun::star::uno::RuntimeException) 1009 { 1010 ::vos::OGuard aGuard( GetMutex() ); 1011 1012 if ( GetWindow() ) 1013 { 1014 if( Window::GetDockingManager()->IsDockable( GetWindow() ) ) 1015 Window::GetDockingManager()->SetPosSizePixel( GetWindow() , X, Y, Width, Height, Flags ); 1016 else 1017 GetWindow()->SetPosSizePixel( X, Y, Width, Height, Flags ); 1018 } 1019 } 1020 1021 ::com::sun::star::awt::Rectangle VCLXWindow::getPosSize( ) throw(::com::sun::star::uno::RuntimeException) 1022 { 1023 ::vos::OGuard aGuard( GetMutex() ); 1024 1025 ::com::sun::star::awt::Rectangle aBounds; 1026 if ( GetWindow() ) 1027 { 1028 if( Window::GetDockingManager()->IsDockable( GetWindow() ) ) 1029 aBounds = AWTRectangle( Window::GetDockingManager()->GetPosSizePixel( GetWindow() ) ); 1030 else 1031 aBounds = AWTRectangle( Rectangle( GetWindow()->GetPosPixel(), GetWindow()->GetSizePixel() ) ); 1032 } 1033 1034 return aBounds; 1035 } 1036 1037 void VCLXWindow::setVisible( sal_Bool bVisible ) throw(::com::sun::star::uno::RuntimeException) 1038 { 1039 ::vos::OGuard aGuard( GetMutex() ); 1040 1041 Window* pWindow = GetWindow(); 1042 if ( pWindow ) 1043 { 1044 /* 1045 if ( bVisible ) 1046 { 1047 // #57167# TopWindows mit unsichtbaren Parent anzeigen... 1048 ::com::sun::star::uno::Any aTest = queryInterface( ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTopWindow >*) 0 ) ); 1049 if ( aTest.hasValue() ) 1050 { 1051 Window* pParent = pWindow->GetWindow( WINDOW_PARENTOVERLAP ); 1052 if ( pParent && !pParent->IsReallyVisible() ) 1053 pWindow->SetParent( pWindow->GetWindow( WINDOW_FRAME ) ); 1054 } 1055 } 1056 */ 1057 mpImpl->setDirectVisible( bVisible ); 1058 pWindow->Show( bVisible && mpImpl->isEnableVisible() ); 1059 } 1060 } 1061 1062 void VCLXWindow::setEnable( sal_Bool bEnable ) throw(::com::sun::star::uno::RuntimeException) 1063 { 1064 ::vos::OGuard aGuard( GetMutex() ); 1065 1066 Window* pWindow = GetWindow(); 1067 if ( pWindow ) 1068 { 1069 pWindow->Enable( bEnable, sal_False ); // #95824# without children! 1070 pWindow->EnableInput( bEnable ); 1071 } 1072 } 1073 1074 void VCLXWindow::setFocus( ) throw(::com::sun::star::uno::RuntimeException) 1075 { 1076 ::vos::OGuard aGuard( GetMutex() ); 1077 1078 if ( GetWindow() ) 1079 GetWindow()->GrabFocus(); 1080 } 1081 1082 void VCLXWindow::addWindowListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException) 1083 { 1084 ::vos::OGuard aGuard( GetMutex() ); 1085 1086 mpImpl->getWindowListeners().addInterface( rxListener ); 1087 1088 Reference< XWindowListener2 > xListener2( rxListener, UNO_QUERY ); 1089 if ( xListener2.is() ) 1090 mpImpl->getWindow2Listeners().addInterface( xListener2 ); 1091 1092 // #100119# Get all resize events, even if height or width 0, or invisible 1093 if ( GetWindow() ) 1094 GetWindow()->EnableAllResize( sal_True ); 1095 } 1096 1097 void VCLXWindow::removeWindowListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException) 1098 { 1099 ::vos::OGuard aGuard( GetMutex() ); 1100 1101 Reference< XWindowListener2 > xListener2( rxListener, UNO_QUERY ); 1102 if ( xListener2.is() ) 1103 mpImpl->getWindow2Listeners().removeInterface( xListener2 ); 1104 1105 mpImpl->getWindowListeners().removeInterface( rxListener ); 1106 } 1107 1108 void VCLXWindow::addFocusListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XFocusListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException) 1109 { 1110 ::vos::OGuard aGuard( GetMutex() ); 1111 mpImpl->getFocusListeners().addInterface( rxListener ); 1112 } 1113 1114 void VCLXWindow::removeFocusListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XFocusListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException) 1115 { 1116 ::vos::OGuard aGuard( GetMutex() ); 1117 mpImpl->getFocusListeners().removeInterface( rxListener ); 1118 } 1119 1120 void VCLXWindow::addKeyListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XKeyListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException) 1121 { 1122 ::vos::OGuard aGuard( GetMutex() ); 1123 mpImpl->getKeyListeners().addInterface( rxListener ); 1124 } 1125 1126 void VCLXWindow::removeKeyListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XKeyListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException) 1127 { 1128 ::vos::OGuard aGuard( GetMutex() ); 1129 mpImpl->getKeyListeners().removeInterface( rxListener ); 1130 } 1131 1132 void VCLXWindow::addMouseListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XMouseListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException) 1133 { 1134 ::vos::OGuard aGuard( GetMutex() ); 1135 mpImpl->getMouseListeners().addInterface( rxListener ); 1136 } 1137 1138 void VCLXWindow::removeMouseListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XMouseListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException) 1139 { 1140 ::vos::OGuard aGuard( GetMutex() ); 1141 mpImpl->getMouseListeners().removeInterface( rxListener ); 1142 } 1143 1144 void VCLXWindow::addMouseMotionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XMouseMotionListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException) 1145 { 1146 ::vos::OGuard aGuard( GetMutex() ); 1147 mpImpl->getMouseMotionListeners().addInterface( rxListener ); 1148 } 1149 1150 void VCLXWindow::removeMouseMotionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XMouseMotionListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException) 1151 { 1152 ::vos::OGuard aGuard( GetMutex() ); 1153 mpImpl->getMouseMotionListeners().removeInterface( rxListener ); 1154 } 1155 1156 void VCLXWindow::addPaintListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XPaintListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException) 1157 { 1158 ::vos::OGuard aGuard( GetMutex() ); 1159 mpImpl->getPaintListeners().addInterface( rxListener ); 1160 } 1161 1162 void VCLXWindow::removePaintListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XPaintListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException) 1163 { 1164 ::vos::OGuard aGuard( GetMutex() ); 1165 mpImpl->getPaintListeners().removeInterface( rxListener ); 1166 } 1167 1168 // ::com::sun::star::awt::XWindowPeer 1169 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XToolkit > VCLXWindow::getToolkit( ) throw(::com::sun::star::uno::RuntimeException) 1170 { 1171 // no guard. nothing to guard here. 1172 // 82463 - 12/21/00 - fs 1173 return Application::GetVCLToolkit(); 1174 } 1175 1176 void VCLXWindow::setPointer( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XPointer >& rxPointer ) throw(::com::sun::star::uno::RuntimeException) 1177 { 1178 ::vos::OGuard aGuard( GetMutex() ); 1179 1180 VCLXPointer* pPointer = VCLXPointer::GetImplementation( rxPointer ); 1181 if ( pPointer ) 1182 { 1183 mpImpl->mxPointer = rxPointer; 1184 if ( GetWindow() ) 1185 GetWindow()->SetPointer( pPointer->GetPointer() ); 1186 } 1187 } 1188 1189 void VCLXWindow::setBackground( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException) 1190 { 1191 ::vos::OGuard aGuard( GetMutex() ); 1192 1193 if ( GetWindow() ) 1194 { 1195 Color aColor( (sal_uInt32)nColor ); 1196 GetWindow()->SetBackground( aColor ); 1197 GetWindow()->SetControlBackground( aColor ); 1198 1199 WindowType eWinType = GetWindow()->GetType(); 1200 if ( ( eWinType == WINDOW_WINDOW ) || 1201 ( eWinType == WINDOW_WORKWINDOW ) || 1202 ( eWinType == WINDOW_FLOATINGWINDOW ) ) 1203 { 1204 GetWindow()->Invalidate(); 1205 } 1206 } 1207 } 1208 1209 void VCLXWindow::invalidate( sal_Int16 nInvalidateFlags ) throw(::com::sun::star::uno::RuntimeException) 1210 { 1211 ::vos::OGuard aGuard( GetMutex() ); 1212 1213 if ( GetWindow() ) 1214 GetWindow()->Invalidate( (sal_uInt16) nInvalidateFlags ); 1215 } 1216 1217 void VCLXWindow::invalidateRect( const ::com::sun::star::awt::Rectangle& rRect, sal_Int16 nInvalidateFlags ) throw(::com::sun::star::uno::RuntimeException) 1218 { 1219 ::vos::OGuard aGuard( GetMutex() ); 1220 1221 if ( GetWindow() ) 1222 GetWindow()->Invalidate( VCLRectangle(rRect), (sal_uInt16) nInvalidateFlags ); 1223 } 1224 1225 1226 // ::com::sun::star::awt::XVclWindowPeer 1227 sal_Bool VCLXWindow::isChild( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer >& rxPeer ) throw(::com::sun::star::uno::RuntimeException) 1228 { 1229 ::vos::OGuard aGuard( GetMutex() ); 1230 1231 sal_Bool bIsChild = sal_False; 1232 Window* pWindow = GetWindow(); 1233 if ( pWindow ) 1234 { 1235 Window* pPeerWindow = VCLUnoHelper::GetWindow( rxPeer ); 1236 bIsChild = pPeerWindow && pWindow->IsChild( pPeerWindow ); 1237 } 1238 1239 return bIsChild; 1240 } 1241 1242 void VCLXWindow::setDesignMode( sal_Bool bOn ) throw(::com::sun::star::uno::RuntimeException) 1243 { 1244 ::vos::OGuard aGuard( GetMutex() ); 1245 1246 mpImpl->mbDesignMode = bOn; 1247 } 1248 1249 sal_Bool VCLXWindow::isDesignMode( ) throw(::com::sun::star::uno::RuntimeException) 1250 { 1251 ::vos::OGuard aGuard( GetMutex() ); 1252 return mpImpl->mbDesignMode; 1253 } 1254 1255 void VCLXWindow::enableClipSiblings( sal_Bool bClip ) throw(::com::sun::star::uno::RuntimeException) 1256 { 1257 ::vos::OGuard aGuard( GetMutex() ); 1258 1259 if ( GetWindow() ) 1260 GetWindow()->EnableClipSiblings( bClip ); 1261 } 1262 1263 void VCLXWindow::setForeground( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException) 1264 { 1265 ::vos::OGuard aGuard( GetMutex() ); 1266 1267 if ( GetWindow() ) 1268 { 1269 Color aColor( (sal_uInt32)nColor ); 1270 GetWindow()->SetControlForeground( aColor ); 1271 } 1272 } 1273 1274 void VCLXWindow::setControlFont( const ::com::sun::star::awt::FontDescriptor& rFont ) throw(::com::sun::star::uno::RuntimeException) 1275 { 1276 ::vos::OGuard aGuard( GetMutex() ); 1277 1278 if ( GetWindow() ) 1279 GetWindow()->SetControlFont( VCLUnoHelper::CreateFont( rFont, GetWindow()->GetControlFont() ) ); 1280 } 1281 1282 void VCLXWindow::getStyles( sal_Int16 nType, ::com::sun::star::awt::FontDescriptor& Font, sal_Int32& ForegroundColor, sal_Int32& BackgroundColor ) throw(::com::sun::star::uno::RuntimeException) 1283 { 1284 ::vos::OGuard aGuard( GetMutex() ); 1285 1286 if ( GetWindow() ) 1287 { 1288 const StyleSettings& rStyleSettings = GetWindow()->GetSettings().GetStyleSettings(); 1289 1290 switch ( nType ) 1291 { 1292 case ::com::sun::star::awt::Style::FRAME: 1293 { 1294 Font = VCLUnoHelper::CreateFontDescriptor( rStyleSettings.GetAppFont() ); 1295 ForegroundColor = rStyleSettings.GetWindowTextColor().GetColor(); 1296 BackgroundColor = rStyleSettings.GetWindowColor().GetColor(); 1297 } 1298 break; 1299 case ::com::sun::star::awt::Style::DIALOG: 1300 { 1301 Font = VCLUnoHelper::CreateFontDescriptor( rStyleSettings.GetAppFont() ); 1302 ForegroundColor = rStyleSettings.GetDialogTextColor().GetColor(); 1303 BackgroundColor = rStyleSettings.GetDialogColor().GetColor(); 1304 } 1305 break; 1306 default: DBG_ERROR( "VCLWindow::getStyles() - unknown Type" ); 1307 } 1308 1309 } 1310 } 1311 1312 namespace toolkit 1313 { 1314 static void setColorSettings( Window* _pWindow, const ::com::sun::star::uno::Any& _rValue, 1315 void (StyleSettings::*pSetter)( const Color& ), const Color& (StyleSettings::*pGetter)( ) const ) 1316 { 1317 sal_Int32 nColor = 0; 1318 if ( !( _rValue >>= nColor ) ) 1319 nColor = (Application::GetSettings().GetStyleSettings().*pGetter)().GetColor(); 1320 1321 AllSettings aSettings = _pWindow->GetSettings(); 1322 StyleSettings aStyleSettings = aSettings.GetStyleSettings(); 1323 1324 (aStyleSettings.*pSetter)( Color( nColor ) ); 1325 1326 aSettings.SetStyleSettings( aStyleSettings ); 1327 _pWindow->SetSettings( aSettings, sal_True ); 1328 } 1329 } 1330 1331 // Terminated by BASEPROPERTY_NOTFOUND (or 0) 1332 void VCLXWindow::PushPropertyIds( std::list< sal_uInt16 > &rIds, 1333 int nFirstId, ...) 1334 { 1335 va_list pVarArgs; 1336 va_start( pVarArgs, nFirstId ); 1337 1338 for ( int nId = nFirstId; nId != BASEPROPERTY_NOTFOUND; 1339 nId = va_arg( pVarArgs, int ) ) 1340 rIds.push_back( (sal_uInt16) nId ); 1341 1342 va_end( pVarArgs ); 1343 } 1344 1345 void VCLXWindow::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds, bool bWithDefaults ) 1346 { 1347 // These are common across ~all VCLXWindow derived classes 1348 if( bWithDefaults ) 1349 PushPropertyIds( rIds, 1350 BASEPROPERTY_ALIGN, 1351 BASEPROPERTY_BACKGROUNDCOLOR, 1352 BASEPROPERTY_BORDER, 1353 BASEPROPERTY_BORDERCOLOR, 1354 BASEPROPERTY_DEFAULTCONTROL, 1355 BASEPROPERTY_ENABLED, 1356 BASEPROPERTY_FONTDESCRIPTOR, 1357 BASEPROPERTY_HELPTEXT, 1358 BASEPROPERTY_HELPURL, 1359 BASEPROPERTY_TEXT, 1360 BASEPROPERTY_PRINTABLE, 1361 BASEPROPERTY_ENABLEVISIBLE, // for visibility 1362 BASEPROPERTY_TABSTOP, 1363 0); 1364 1365 // lovely hack from: 1366 // void UnoControlModel::ImplRegisterProperty( sal_uInt16 nPropId ) 1367 std::list< sal_uInt16 >::const_iterator iter; 1368 for( iter = rIds.begin(); iter != rIds.end(); iter++) { 1369 if( *iter == BASEPROPERTY_FONTDESCRIPTOR ) 1370 { 1371 // some properties are not included in the FontDescriptor, but everytime 1372 // when we have a FontDescriptor we want to have these properties too. 1373 // => Easier to register the here, istead everywhere where I register the FontDescriptor... 1374 1375 rIds.push_back( BASEPROPERTY_TEXTCOLOR ); 1376 rIds.push_back( BASEPROPERTY_TEXTLINECOLOR ); 1377 rIds.push_back( BASEPROPERTY_FONTRELIEF ); 1378 rIds.push_back( BASEPROPERTY_FONTEMPHASISMARK ); 1379 break; 1380 } 1381 } 1382 } 1383 1384 void VCLXWindow::GetPropertyIds( std::list< sal_uInt16 >& _out_rIds ) 1385 { 1386 return ImplGetPropertyIds( _out_rIds, mpImpl->mbWithDefaultProps ); 1387 } 1388 1389 ::cppu::OInterfaceContainerHelper& VCLXWindow::GetContainerListeners() 1390 { 1391 return mpImpl->getContainerListeners(); 1392 } 1393 1394 ::cppu::OInterfaceContainerHelper& VCLXWindow::GetTopWindowListeners() 1395 { 1396 return mpImpl->getTopWindowListeners(); 1397 } 1398 1399 namespace 1400 { 1401 void lcl_updateWritingMode( Window& _rWindow, const sal_Int16 _nWritingMode, const sal_Int16 _nContextWritingMode ) 1402 { 1403 sal_Bool bEnableRTL = sal_False; 1404 switch ( _nWritingMode ) 1405 { 1406 case WritingMode2::LR_TB: bEnableRTL = sal_False; break; 1407 case WritingMode2::RL_TB: bEnableRTL = sal_True; break; 1408 case WritingMode2::CONTEXT: 1409 { 1410 // consult our ContextWritingMode. If it has an explicit RTL/LTR value, then use 1411 // it. If it doesn't (but is CONTEXT itself), then just ask the parent window of our 1412 // own window for its RTL mode 1413 switch ( _nContextWritingMode ) 1414 { 1415 case WritingMode2::LR_TB: bEnableRTL = sal_False; break; 1416 case WritingMode2::RL_TB: bEnableRTL = sal_True; break; 1417 case WritingMode2::CONTEXT: 1418 { 1419 const Window* pParent = _rWindow.GetParent(); 1420 OSL_ENSURE( pParent, "lcl_updateWritingMode: cannot determine context's writing mode!" ); 1421 if ( pParent ) 1422 bEnableRTL = pParent->IsRTLEnabled(); 1423 } 1424 break; 1425 } 1426 } 1427 break; 1428 default: 1429 OSL_ENSURE( false, "lcl_updateWritingMode: unsupported WritingMode!" ); 1430 } // switch ( nWritingMode ) 1431 1432 _rWindow.EnableRTL( bEnableRTL ); 1433 } 1434 } 1435 1436 void VCLXWindow::setProperty( const ::rtl::OUString& PropertyName, const ::com::sun::star::uno::Any& Value ) throw(::com::sun::star::uno::RuntimeException) 1437 { 1438 ::vos::OGuard aGuard( GetMutex() ); 1439 1440 Window* pWindow = GetWindow(); 1441 if ( !pWindow ) 1442 return; 1443 1444 sal_Bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID; 1445 1446 WindowType eWinType = pWindow->GetType(); 1447 sal_uInt16 nPropType = GetPropertyId( PropertyName ); 1448 switch ( nPropType ) 1449 { 1450 case BASEPROPERTY_REFERENCE_DEVICE: 1451 { 1452 Control* pControl = dynamic_cast< Control* >( pWindow ); 1453 OSL_ENSURE( pControl, "VCLXWindow::setProperty( RefDevice ): need a Control for this!" ); 1454 if ( !pControl ) 1455 break; 1456 Reference< XDevice > xDevice( Value, UNO_QUERY ); 1457 OutputDevice* pDevice = VCLUnoHelper::GetOutputDevice( xDevice ); 1458 pControl->SetReferenceDevice( pDevice ); 1459 } 1460 break; 1461 1462 case BASEPROPERTY_CONTEXT_WRITING_MODE: 1463 { 1464 OSL_VERIFY( Value >>= mpImpl->mnContextWritingMode ); 1465 if ( mpImpl->mnWritingMode == WritingMode2::CONTEXT ) 1466 lcl_updateWritingMode( *pWindow, mpImpl->mnWritingMode, mpImpl->mnContextWritingMode ); 1467 } 1468 break; 1469 1470 case BASEPROPERTY_WRITING_MODE: 1471 { 1472 sal_Bool bProperType = ( Value >>= mpImpl->mnWritingMode ); 1473 OSL_ENSURE( bProperType, "VCLXWindow::setProperty( 'WritingMode' ): illegal value type!" ); 1474 if ( bProperType ) 1475 lcl_updateWritingMode( *pWindow, mpImpl->mnWritingMode, mpImpl->mnContextWritingMode ); 1476 } 1477 break; 1478 1479 case BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR: 1480 { 1481 sal_uInt16 nWheelBehavior( MouseWheelBehavior::SCROLL_FOCUS_ONLY ); 1482 OSL_VERIFY( Value >>= nWheelBehavior ); 1483 1484 AllSettings aSettings = pWindow->GetSettings(); 1485 MouseSettings aMouseSettings = aSettings.GetMouseSettings(); 1486 1487 sal_uInt16 nVclBehavior( MOUSE_WHEEL_FOCUS_ONLY ); 1488 switch ( nWheelBehavior ) 1489 { 1490 case MouseWheelBehavior::SCROLL_DISABLED: nVclBehavior = MOUSE_WHEEL_DISABLE; break; 1491 case MouseWheelBehavior::SCROLL_FOCUS_ONLY: nVclBehavior = MOUSE_WHEEL_FOCUS_ONLY; break; 1492 case MouseWheelBehavior::SCROLL_ALWAYS: nVclBehavior = MOUSE_WHEEL_ALWAYS; break; 1493 default: 1494 OSL_ENSURE( false, "VCLXWindow::setProperty( 'MouseWheelBehavior' ): illegal property value!" ); 1495 } 1496 1497 aMouseSettings.SetWheelBehavior( nWheelBehavior ); 1498 aSettings.SetMouseSettings( aMouseSettings ); 1499 pWindow->SetSettings( aSettings, sal_True ); 1500 } 1501 break; 1502 1503 case BASEPROPERTY_NATIVE_WIDGET_LOOK: 1504 { 1505 sal_Bool bEnable( sal_True ); 1506 OSL_VERIFY( Value >>= bEnable ); 1507 pWindow->EnableNativeWidget( bEnable ); 1508 } 1509 break; 1510 1511 case BASEPROPERTY_PLUGINPARENT: 1512 { 1513 // set parent handle 1514 SetSystemParent_Impl( Value ); 1515 } 1516 break; 1517 1518 case BASEPROPERTY_ENABLED: 1519 { 1520 sal_Bool b = sal_Bool(); 1521 if ( Value >>= b ) 1522 setEnable( b ); 1523 } 1524 break; 1525 case BASEPROPERTY_ENABLEVISIBLE: 1526 { 1527 sal_Bool b = sal_False; 1528 if ( Value >>= b ) 1529 { 1530 if( b != mpImpl->isEnableVisible() ) 1531 { 1532 mpImpl->setEnableVisible( b ); 1533 pWindow->Show( b && mpImpl->isDirectVisible() ); 1534 } 1535 } 1536 } 1537 break; 1538 case BASEPROPERTY_TEXT: 1539 case BASEPROPERTY_LABEL: 1540 case BASEPROPERTY_TITLE: 1541 { 1542 ::rtl::OUString aText; 1543 if ( Value >>= aText ) 1544 { 1545 switch (eWinType) 1546 { 1547 case WINDOW_OKBUTTON: 1548 case WINDOW_CANCELBUTTON: 1549 case WINDOW_HELPBUTTON: 1550 // Standard Button: overwrite only if not empty. 1551 if (aText.getLength()) 1552 pWindow->SetText( aText ); 1553 break; 1554 1555 default: 1556 pWindow->SetText( aText ); 1557 break; 1558 } 1559 } 1560 } 1561 break; 1562 case BASEPROPERTY_ACCESSIBLENAME: 1563 { 1564 ::rtl::OUString aText; 1565 if ( Value >>= aText ) 1566 pWindow->SetAccessibleName( aText ); 1567 } 1568 break; 1569 case BASEPROPERTY_HELPURL: 1570 { 1571 ::rtl::OUString aURL; 1572 if ( Value >>= aURL ) 1573 { 1574 INetURLObject aHelpURL( aURL ); 1575 if ( aHelpURL.GetProtocol() == INET_PROT_HID ) 1576 pWindow->SetHelpId( rtl::OUStringToOString( aHelpURL.GetURLPath(), RTL_TEXTENCODING_UTF8 ) ); 1577 else 1578 pWindow->SetHelpId( rtl::OUStringToOString( aURL, RTL_TEXTENCODING_UTF8 ) ); 1579 } 1580 } 1581 break; 1582 case BASEPROPERTY_HELPTEXT: 1583 { 1584 ::rtl::OUString aHelpText; 1585 if ( Value >>= aHelpText ) 1586 { 1587 pWindow->SetQuickHelpText( aHelpText ); 1588 } 1589 } 1590 break; 1591 case BASEPROPERTY_FONTDESCRIPTOR: 1592 { 1593 if ( bVoid ) 1594 pWindow->SetControlFont( Font() ); 1595 else 1596 { 1597 ::com::sun::star::awt::FontDescriptor aFont; 1598 if ( Value >>= aFont ) 1599 pWindow->SetControlFont( VCLUnoHelper::CreateFont( aFont, pWindow->GetControlFont() ) ); 1600 } 1601 } 1602 break; 1603 case BASEPROPERTY_FONTRELIEF: 1604 { 1605 sal_Int16 n = sal_Int16(); 1606 if ( Value >>= n ) 1607 { 1608 Font aFont = pWindow->GetControlFont(); 1609 aFont.SetRelief( (FontRelief)n ); 1610 pWindow->SetControlFont( aFont ); 1611 } 1612 } 1613 break; 1614 case BASEPROPERTY_FONTEMPHASISMARK: 1615 { 1616 sal_Int16 n = sal_Int16(); 1617 if ( Value >>= n ) 1618 { 1619 Font aFont = pWindow->GetControlFont(); 1620 aFont.SetEmphasisMark( n ); 1621 pWindow->SetControlFont( aFont ); 1622 } 1623 } 1624 break; 1625 case BASEPROPERTY_BACKGROUNDCOLOR: 1626 if ( bVoid ) 1627 { 1628 switch ( eWinType ) 1629 { 1630 // set dialog color for default 1631 case WINDOW_DIALOG: 1632 case WINDOW_MESSBOX: 1633 case WINDOW_INFOBOX: 1634 case WINDOW_WARNINGBOX: 1635 case WINDOW_ERRORBOX: 1636 case WINDOW_QUERYBOX: 1637 case WINDOW_TABPAGE: 1638 { 1639 Color aColor = pWindow->GetSettings().GetStyleSettings().GetDialogColor(); 1640 pWindow->SetBackground( aColor ); 1641 pWindow->SetControlBackground( aColor ); 1642 break; 1643 } 1644 1645 case WINDOW_FIXEDTEXT: 1646 case WINDOW_CHECKBOX: 1647 case WINDOW_RADIOBUTTON: 1648 case WINDOW_GROUPBOX: 1649 case WINDOW_FIXEDLINE: 1650 { 1651 // support transparency only for special controls 1652 pWindow->SetBackground(); 1653 pWindow->SetControlBackground(); 1654 pWindow->SetPaintTransparent( sal_True ); 1655 break; 1656 } 1657 1658 default: 1659 { 1660 // default code which enables transparency for 1661 // compound controls. It's not real transparency 1662 // as most of these controls repaint their client 1663 // area completely new. 1664 if ( pWindow->IsCompoundControl() ) 1665 pWindow->SetBackground(); 1666 pWindow->SetControlBackground(); 1667 break; 1668 } 1669 } 1670 } 1671 else 1672 { 1673 sal_Int32 nColor = 0; 1674 if ( Value >>= nColor ) 1675 { 1676 Color aColor( nColor ); 1677 pWindow->SetControlBackground( aColor ); 1678 pWindow->SetBackground( aColor ); 1679 switch ( eWinType ) 1680 { 1681 // reset paint transparent mode 1682 case WINDOW_FIXEDTEXT: 1683 case WINDOW_CHECKBOX: 1684 case WINDOW_RADIOBUTTON: 1685 case WINDOW_GROUPBOX: 1686 case WINDOW_FIXEDLINE: 1687 pWindow->SetPaintTransparent( sal_False ); 1688 default: ; 1689 } 1690 pWindow->Invalidate(); // Falls das Control nicht drauf reagiert 1691 } 1692 } 1693 break; 1694 case BASEPROPERTY_TEXTCOLOR: 1695 if ( bVoid ) 1696 { 1697 pWindow->SetControlForeground(); 1698 } 1699 else 1700 { 1701 sal_Int32 nColor = 0; 1702 if ( Value >>= nColor ) 1703 { 1704 Color aColor( nColor ); 1705 pWindow->SetTextColor( aColor ); 1706 pWindow->SetControlForeground( aColor ); 1707 } 1708 } 1709 break; 1710 case BASEPROPERTY_TEXTLINECOLOR: 1711 if ( bVoid ) 1712 { 1713 pWindow->SetTextLineColor(); 1714 } 1715 else 1716 { 1717 sal_Int32 nColor = 0; 1718 if ( Value >>= nColor ) 1719 { 1720 Color aColor( nColor ); 1721 pWindow->SetTextLineColor( aColor ); 1722 } 1723 } 1724 break; 1725 case BASEPROPERTY_FILLCOLOR: 1726 if ( bVoid ) 1727 pWindow->SetFillColor(); 1728 else 1729 { 1730 sal_Int32 nColor = 0; 1731 if ( Value >>= nColor ) 1732 { 1733 Color aColor( nColor ); 1734 pWindow->SetFillColor( aColor ); 1735 } 1736 } 1737 break; 1738 case BASEPROPERTY_LINECOLOR: 1739 if ( bVoid ) 1740 pWindow->SetLineColor(); 1741 else 1742 { 1743 sal_Int32 nColor = 0; 1744 if ( Value >>= nColor ) 1745 { 1746 Color aColor( nColor ); 1747 pWindow->SetLineColor( aColor ); 1748 } 1749 } 1750 break; 1751 case BASEPROPERTY_BORDER: 1752 { 1753 WinBits nStyle = pWindow->GetStyle(); 1754 sal_uInt16 nBorder = 0; 1755 Value >>= nBorder; 1756 if ( !nBorder ) 1757 { 1758 pWindow->SetStyle( nStyle & ~WB_BORDER ); 1759 } 1760 else 1761 { 1762 pWindow->SetStyle( nStyle | WB_BORDER ); 1763 pWindow->SetBorderStyle( nBorder ); 1764 } 1765 } 1766 break; 1767 case BASEPROPERTY_TABSTOP: 1768 { 1769 WinBits nStyle = pWindow->GetStyle() & ~WB_TABSTOP; 1770 if ( !bVoid ) 1771 { 1772 sal_Bool bTab = false; 1773 Value >>= bTab; 1774 if ( bTab ) 1775 nStyle |= WB_TABSTOP; 1776 else 1777 nStyle |= WB_NOTABSTOP; 1778 } 1779 pWindow->SetStyle( nStyle ); 1780 } 1781 break; 1782 case BASEPROPERTY_VERTICALALIGN: 1783 { 1784 VerticalAlignment eAlign = VerticalAlignment_MAKE_FIXED_SIZE; 1785 WinBits nStyle = pWindow->GetStyle(); 1786 nStyle &= ~(WB_TOP|WB_VCENTER|WB_BOTTOM); 1787 if ( !bVoid ) 1788 Value >>= eAlign; 1789 switch ( eAlign ) 1790 { 1791 case VerticalAlignment_TOP: 1792 nStyle |= WB_TOP; 1793 break; 1794 case VerticalAlignment_MIDDLE: 1795 nStyle |= WB_VCENTER; 1796 break; 1797 case VerticalAlignment_BOTTOM: 1798 nStyle |= WB_BOTTOM; 1799 break; 1800 default: ; // for warning free code, MAKE_FIXED_SIZE 1801 } 1802 pWindow->SetStyle( nStyle ); 1803 } 1804 break; 1805 case BASEPROPERTY_ALIGN: 1806 { 1807 sal_Int16 nAlign = PROPERTY_ALIGN_LEFT; 1808 switch ( eWinType ) 1809 { 1810 case WINDOW_COMBOBOX: 1811 case WINDOW_BUTTON: 1812 case WINDOW_PUSHBUTTON: 1813 case WINDOW_OKBUTTON: 1814 case WINDOW_CANCELBUTTON: 1815 case WINDOW_HELPBUTTON: 1816 nAlign = PROPERTY_ALIGN_CENTER; 1817 // no break here! 1818 case WINDOW_FIXEDTEXT: 1819 case WINDOW_EDIT: 1820 case WINDOW_MULTILINEEDIT: 1821 case WINDOW_CHECKBOX: 1822 case WINDOW_RADIOBUTTON: 1823 case WINDOW_LISTBOX: 1824 { 1825 WinBits nStyle = pWindow->GetStyle(); 1826 nStyle &= ~(WB_LEFT|WB_CENTER|WB_RIGHT); 1827 if ( !bVoid ) 1828 Value >>= nAlign; 1829 if ( nAlign == PROPERTY_ALIGN_LEFT ) 1830 nStyle |= WB_LEFT; 1831 else if ( nAlign == PROPERTY_ALIGN_CENTER ) 1832 nStyle |= WB_CENTER; 1833 else 1834 nStyle |= WB_RIGHT; 1835 pWindow->SetStyle( nStyle ); 1836 } 1837 break; 1838 } 1839 } 1840 break; 1841 case BASEPROPERTY_MULTILINE: 1842 { 1843 if ( ( eWinType == WINDOW_FIXEDTEXT ) 1844 || ( eWinType == WINDOW_CHECKBOX ) 1845 || ( eWinType == WINDOW_RADIOBUTTON ) 1846 || ( eWinType == WINDOW_BUTTON ) 1847 || ( eWinType == WINDOW_PUSHBUTTON ) 1848 || ( eWinType == WINDOW_OKBUTTON ) 1849 || ( eWinType == WINDOW_CANCELBUTTON ) 1850 || ( eWinType == WINDOW_HELPBUTTON ) 1851 ) 1852 { 1853 WinBits nStyle = pWindow->GetStyle(); 1854 sal_Bool bMulti = false; 1855 Value >>= bMulti; 1856 if ( bMulti ) 1857 nStyle |= WB_WORDBREAK; 1858 else 1859 nStyle &= ~WB_WORDBREAK; 1860 pWindow->SetStyle( nStyle ); 1861 } 1862 } 1863 break; 1864 case BASEPROPERTY_ORIENTATION: 1865 { 1866 switch ( eWinType ) 1867 { 1868 case WINDOW_FIXEDLINE: 1869 { 1870 sal_Int32 nOrientation = 0; 1871 if ( Value >>= nOrientation ) 1872 { 1873 WinBits nStyle = pWindow->GetStyle(); 1874 nStyle &= ~(WB_HORZ|WB_VERT); 1875 if ( nOrientation == 0 ) 1876 nStyle |= WB_HORZ; 1877 else 1878 nStyle |= WB_VERT; 1879 1880 pWindow->SetStyle( nStyle ); 1881 } 1882 } 1883 break; 1884 } 1885 } 1886 break; 1887 case BASEPROPERTY_AUTOMNEMONICS: 1888 { 1889 sal_Bool bAutoMnemonics = false; 1890 Value >>= bAutoMnemonics; 1891 AllSettings aSettings = pWindow->GetSettings(); 1892 StyleSettings aStyleSettings = aSettings.GetStyleSettings(); 1893 if ( aStyleSettings.GetAutoMnemonic() != bAutoMnemonics ) 1894 { 1895 aStyleSettings.SetAutoMnemonic( bAutoMnemonics ); 1896 aSettings.SetStyleSettings( aStyleSettings ); 1897 pWindow->SetSettings( aSettings ); 1898 } 1899 } 1900 break; 1901 case BASEPROPERTY_MOUSETRANSPARENT: 1902 { 1903 sal_Bool bMouseTransparent = false; 1904 Value >>= bMouseTransparent; 1905 pWindow->SetMouseTransparent( bMouseTransparent ); 1906 } 1907 break; 1908 case BASEPROPERTY_PAINTTRANSPARENT: 1909 { 1910 sal_Bool bPaintTransparent = false; 1911 Value >>= bPaintTransparent; 1912 pWindow->SetPaintTransparent( bPaintTransparent ); 1913 // pWindow->SetBackground(); 1914 } 1915 break; 1916 1917 case BASEPROPERTY_REPEAT: 1918 { 1919 sal_Bool bRepeat( sal_False ); 1920 Value >>= bRepeat; 1921 1922 WinBits nStyle = pWindow->GetStyle(); 1923 if ( bRepeat ) 1924 nStyle |= WB_REPEAT; 1925 else 1926 nStyle &= ~WB_REPEAT; 1927 pWindow->SetStyle( nStyle ); 1928 } 1929 break; 1930 1931 case BASEPROPERTY_REPEAT_DELAY: 1932 { 1933 sal_Int32 nRepeatDelay = 0; 1934 if ( Value >>= nRepeatDelay ) 1935 { 1936 AllSettings aSettings = pWindow->GetSettings(); 1937 MouseSettings aMouseSettings = aSettings.GetMouseSettings(); 1938 1939 aMouseSettings.SetButtonRepeat( nRepeatDelay ); 1940 aSettings.SetMouseSettings( aMouseSettings ); 1941 1942 pWindow->SetSettings( aSettings, sal_True ); 1943 } 1944 } 1945 break; 1946 1947 case BASEPROPERTY_SYMBOL_COLOR: 1948 ::toolkit::setColorSettings( pWindow, Value, &StyleSettings::SetButtonTextColor, &StyleSettings::GetButtonTextColor ); 1949 break; 1950 1951 case BASEPROPERTY_BORDERCOLOR: 1952 ::toolkit::setColorSettings( pWindow, Value, &StyleSettings::SetMonoColor, &StyleSettings::GetMonoColor); 1953 break; 1954 case BASEPROPERTY_DEFAULTCONTROL: 1955 { 1956 rtl::OUString aName; 1957 Value >>= aName; 1958 break; 1959 } 1960 } 1961 } 1962 1963 ::com::sun::star::uno::Any VCLXWindow::getProperty( const ::rtl::OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException) 1964 { 1965 ::vos::OGuard aGuard( GetMutex() ); 1966 1967 ::com::sun::star::uno::Any aProp; 1968 if ( GetWindow() ) 1969 { 1970 WindowType eWinType = GetWindow()->GetType(); 1971 sal_uInt16 nPropType = GetPropertyId( PropertyName ); 1972 switch ( nPropType ) 1973 { 1974 case BASEPROPERTY_REFERENCE_DEVICE: 1975 { 1976 Control* pControl = dynamic_cast< Control* >( GetWindow() ); 1977 OSL_ENSURE( pControl, "VCLXWindow::setProperty( RefDevice ): need a Control for this!" ); 1978 if ( !pControl ) 1979 break; 1980 1981 VCLXDevice* pDevice = new VCLXDevice; 1982 pDevice->SetOutputDevice( pControl->GetReferenceDevice() ); 1983 aProp <<= Reference< XDevice >( pDevice ); 1984 } 1985 break; 1986 1987 case BASEPROPERTY_CONTEXT_WRITING_MODE: 1988 aProp <<= mpImpl->mnContextWritingMode; 1989 break; 1990 1991 case BASEPROPERTY_WRITING_MODE: 1992 aProp <<= mpImpl->mnWritingMode; 1993 break; 1994 1995 case BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR: 1996 { 1997 sal_uInt16 nVclBehavior = GetWindow()->GetSettings().GetMouseSettings().GetWheelBehavior(); 1998 sal_Int16 nBehavior = MouseWheelBehavior::SCROLL_FOCUS_ONLY; 1999 switch ( nVclBehavior ) 2000 { 2001 case MOUSE_WHEEL_DISABLE: nBehavior = MouseWheelBehavior::SCROLL_DISABLED; break; 2002 case MOUSE_WHEEL_FOCUS_ONLY: nBehavior = MouseWheelBehavior::SCROLL_FOCUS_ONLY; break; 2003 case MOUSE_WHEEL_ALWAYS: nBehavior = MouseWheelBehavior::SCROLL_ALWAYS; break; 2004 default: 2005 OSL_ENSURE( false, "VCLXWindow::getProperty( 'MouseWheelBehavior' ): illegal VCL value!" ); 2006 } 2007 aProp <<= nBehavior; 2008 } 2009 break; 2010 2011 case BASEPROPERTY_NATIVE_WIDGET_LOOK: 2012 aProp <<= (sal_Bool) GetWindow()->IsNativeWidgetEnabled(); 2013 break; 2014 2015 case BASEPROPERTY_ENABLED: 2016 aProp <<= (sal_Bool) GetWindow()->IsEnabled(); 2017 break; 2018 2019 case BASEPROPERTY_ENABLEVISIBLE: 2020 aProp <<= (sal_Bool) mpImpl->isEnableVisible(); 2021 break; 2022 2023 case BASEPROPERTY_HIGHCONTRASTMODE: 2024 aProp <<= (sal_Bool) GetWindow()->GetSettings().GetStyleSettings().GetHighContrastMode(); 2025 break; 2026 2027 case BASEPROPERTY_TEXT: 2028 case BASEPROPERTY_LABEL: 2029 case BASEPROPERTY_TITLE: 2030 { 2031 ::rtl::OUString aText = GetWindow()->GetText(); 2032 aProp <<= aText; 2033 } 2034 break; 2035 case BASEPROPERTY_ACCESSIBLENAME: 2036 { 2037 ::rtl::OUString aText = GetWindow()->GetAccessibleName(); 2038 aProp <<= aText; 2039 } 2040 break; 2041 case BASEPROPERTY_HELPTEXT: 2042 { 2043 ::rtl::OUString aText = GetWindow()->GetQuickHelpText(); 2044 aProp <<= aText; 2045 } 2046 break; 2047 case BASEPROPERTY_HELPURL: 2048 { 2049 rtl::OUString aHelpId( rtl::OStringToOUString( GetWindow()->GetHelpId(), RTL_TEXTENCODING_UTF8 ) ); 2050 aProp <<= ::rtl::OUString( aHelpId ); 2051 } 2052 break; 2053 case BASEPROPERTY_FONTDESCRIPTOR: 2054 { 2055 Font aFont = GetWindow()->GetControlFont(); 2056 ::com::sun::star::awt::FontDescriptor aFD = VCLUnoHelper::CreateFontDescriptor( aFont ); 2057 aProp <<= aFD; 2058 } 2059 break; 2060 case BASEPROPERTY_BACKGROUNDCOLOR: 2061 aProp <<= (sal_Int32) GetWindow()->GetControlBackground().GetColor(); 2062 break; 2063 case BASEPROPERTY_DISPLAYBACKGROUNDCOLOR: 2064 aProp <<= (sal_Int32) GetWindow()->GetDisplayBackground().GetColor().GetColor(); 2065 break; 2066 case BASEPROPERTY_FONTRELIEF: 2067 aProp <<= (sal_Int16) GetWindow()->GetControlFont().GetRelief(); 2068 break; 2069 case BASEPROPERTY_FONTEMPHASISMARK: 2070 aProp <<= (sal_Int16) GetWindow()->GetControlFont().GetEmphasisMark(); 2071 break; 2072 case BASEPROPERTY_TEXTCOLOR: 2073 aProp <<= (sal_Int32) GetWindow()->GetControlForeground().GetColor(); 2074 break; 2075 case BASEPROPERTY_TEXTLINECOLOR: 2076 aProp <<= (sal_Int32) GetWindow()->GetTextLineColor().GetColor(); 2077 break; 2078 case BASEPROPERTY_FILLCOLOR: 2079 aProp <<= (sal_Int32) GetWindow()->GetFillColor().GetColor(); 2080 break; 2081 case BASEPROPERTY_LINECOLOR: 2082 aProp <<= (sal_Int32) GetWindow()->GetLineColor().GetColor(); 2083 break; 2084 case BASEPROPERTY_BORDER: 2085 { 2086 sal_Int16 nBorder = 0; 2087 if ( GetWindow()->GetStyle() & WB_BORDER ) 2088 nBorder = GetWindow()->GetBorderStyle(); 2089 aProp <<= nBorder; 2090 } 2091 break; 2092 case BASEPROPERTY_TABSTOP: 2093 aProp <<= (sal_Bool) ( GetWindow()->GetStyle() & WB_TABSTOP ) ? sal_True : sal_False; 2094 break; 2095 case BASEPROPERTY_VERTICALALIGN: 2096 { 2097 WinBits nStyle = GetWindow()->GetStyle(); 2098 if ( nStyle & WB_TOP ) 2099 aProp <<= VerticalAlignment_TOP; 2100 else if ( nStyle & WB_VCENTER ) 2101 aProp <<= VerticalAlignment_MIDDLE; 2102 else if ( nStyle & WB_BOTTOM ) 2103 aProp <<= VerticalAlignment_BOTTOM; 2104 } 2105 break; 2106 case BASEPROPERTY_ALIGN: 2107 { 2108 switch ( eWinType ) 2109 { 2110 case WINDOW_FIXEDTEXT: 2111 case WINDOW_EDIT: 2112 case WINDOW_MULTILINEEDIT: 2113 case WINDOW_CHECKBOX: 2114 case WINDOW_RADIOBUTTON: 2115 case WINDOW_LISTBOX: 2116 case WINDOW_COMBOBOX: 2117 case WINDOW_BUTTON: 2118 case WINDOW_PUSHBUTTON: 2119 case WINDOW_OKBUTTON: 2120 case WINDOW_CANCELBUTTON: 2121 case WINDOW_HELPBUTTON: 2122 { 2123 WinBits nStyle = GetWindow()->GetStyle(); 2124 if ( nStyle & WB_LEFT ) 2125 aProp <<= (sal_Int16) PROPERTY_ALIGN_LEFT; 2126 else if ( nStyle & WB_CENTER ) 2127 aProp <<= (sal_Int16) PROPERTY_ALIGN_CENTER; 2128 else if ( nStyle & WB_RIGHT ) 2129 aProp <<= (sal_Int16) PROPERTY_ALIGN_RIGHT; 2130 } 2131 break; 2132 } 2133 } 2134 case BASEPROPERTY_MULTILINE: 2135 { 2136 if ( ( eWinType == WINDOW_FIXEDTEXT ) 2137 || ( eWinType == WINDOW_CHECKBOX ) 2138 || ( eWinType == WINDOW_RADIOBUTTON ) 2139 || ( eWinType == WINDOW_BUTTON ) 2140 || ( eWinType == WINDOW_PUSHBUTTON ) 2141 || ( eWinType == WINDOW_OKBUTTON ) 2142 || ( eWinType == WINDOW_CANCELBUTTON ) 2143 || ( eWinType == WINDOW_HELPBUTTON ) 2144 ) 2145 aProp <<= (sal_Bool) ( GetWindow()->GetStyle() & WB_WORDBREAK ) ? sal_True : sal_False; 2146 } 2147 break; 2148 case BASEPROPERTY_AUTOMNEMONICS: 2149 { 2150 sal_Bool bAutoMnemonics = GetWindow()->GetSettings().GetStyleSettings().GetAutoMnemonic(); 2151 aProp <<= bAutoMnemonics; 2152 } 2153 break; 2154 case BASEPROPERTY_MOUSETRANSPARENT: 2155 { 2156 sal_Bool bMouseTransparent = GetWindow()->IsMouseTransparent(); 2157 aProp <<= bMouseTransparent; 2158 } 2159 break; 2160 case BASEPROPERTY_PAINTTRANSPARENT: 2161 { 2162 sal_Bool bPaintTransparent = GetWindow()->IsPaintTransparent(); 2163 aProp <<= bPaintTransparent; 2164 } 2165 break; 2166 2167 case BASEPROPERTY_REPEAT: 2168 aProp <<= (sal_Bool)( 0 != ( GetWindow()->GetStyle() & WB_REPEAT ) ); 2169 break; 2170 2171 case BASEPROPERTY_REPEAT_DELAY: 2172 { 2173 sal_Int32 nButtonRepeat = GetWindow()->GetSettings().GetMouseSettings().GetButtonRepeat(); 2174 aProp <<= (sal_Int32)nButtonRepeat; 2175 } 2176 break; 2177 2178 case BASEPROPERTY_SYMBOL_COLOR: 2179 aProp <<= (sal_Int32)GetWindow()->GetSettings().GetStyleSettings().GetButtonTextColor().GetColor(); 2180 break; 2181 2182 case BASEPROPERTY_BORDERCOLOR: 2183 aProp <<= (sal_Int32)GetWindow()->GetSettings().GetStyleSettings().GetMonoColor().GetColor(); 2184 break; 2185 } 2186 } 2187 return aProp; 2188 } 2189 2190 2191 // ::com::sun::star::awt::XLayoutConstrains 2192 ::com::sun::star::awt::Size VCLXWindow::getMinimumSize( ) throw(::com::sun::star::uno::RuntimeException) 2193 { 2194 ::vos::OGuard aGuard( GetMutex() ); 2195 2196 // Diese Methode sollte nur fuer Componenten gerufen werden, die zwar 2197 // ueber das ::com::sun::star::awt::Toolkit erzeugt werden koennen, aber fuer die es 2198 // kein Interface gibt. 2199 2200 Size aSz; 2201 if ( GetWindow() ) 2202 { 2203 WindowType nWinType = GetWindow()->GetType(); 2204 switch ( nWinType ) 2205 { 2206 case WINDOW_CONTROL: 2207 aSz.Width() = GetWindow()->GetTextWidth( GetWindow()->GetText() )+2*12; 2208 aSz.Height() = GetWindow()->GetTextHeight()+2*6; 2209 break; 2210 2211 case WINDOW_PATTERNBOX: 2212 case WINDOW_NUMERICBOX: 2213 case WINDOW_METRICBOX: 2214 case WINDOW_CURRENCYBOX: 2215 case WINDOW_DATEBOX: 2216 case WINDOW_TIMEBOX: 2217 case WINDOW_LONGCURRENCYBOX: 2218 aSz.Width() = GetWindow()->GetTextWidth( GetWindow()->GetText() )+2*2; 2219 aSz.Height() = GetWindow()->GetTextHeight()+2*2; 2220 break; 2221 case WINDOW_SCROLLBARBOX: 2222 return VCLXScrollBar::implGetMinimumSize( GetWindow() ); 2223 default: 2224 aSz = GetWindow()->GetOptimalSize( WINDOWSIZE_MINIMUM ); 2225 } 2226 } 2227 2228 return ::com::sun::star::awt::Size( aSz.Width(), aSz.Height() ); 2229 } 2230 2231 ::com::sun::star::awt::Size VCLXWindow::getPreferredSize( ) throw(::com::sun::star::uno::RuntimeException) 2232 { 2233 return getMinimumSize(); 2234 } 2235 2236 ::com::sun::star::awt::Size VCLXWindow::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException) 2237 { 2238 ::vos::OGuard aGuard( GetMutex() ); 2239 2240 ::com::sun::star::awt::Size aNewSize( rNewSize ); 2241 ::com::sun::star::awt::Size aMinSize = getMinimumSize(); 2242 2243 if ( aNewSize.Width < aMinSize.Width ) 2244 aNewSize.Width = aMinSize.Width; 2245 if ( aNewSize.Height < aMinSize.Height ) 2246 aNewSize.Height = aMinSize.Height; 2247 2248 return aNewSize; 2249 } 2250 2251 2252 // ::com::sun::star::awt::XView 2253 sal_Bool VCLXWindow::setGraphics( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XGraphics >& rxDevice ) throw(::com::sun::star::uno::RuntimeException) 2254 { 2255 ::vos::OGuard aGuard( GetMutex() ); 2256 2257 if ( VCLUnoHelper::GetOutputDevice( rxDevice ) ) 2258 mpImpl->mxViewGraphics = rxDevice; 2259 else 2260 mpImpl->mxViewGraphics = NULL; 2261 2262 return mpImpl->mxViewGraphics.is(); 2263 } 2264 2265 ::com::sun::star::uno::Reference< ::com::sun::star::awt::XGraphics > VCLXWindow::getGraphics( ) throw(::com::sun::star::uno::RuntimeException) 2266 { 2267 ::vos::OGuard aGuard( GetMutex() ); 2268 2269 return mpImpl->mxViewGraphics; 2270 } 2271 2272 ::com::sun::star::awt::Size VCLXWindow::getSize( ) throw(::com::sun::star::uno::RuntimeException) 2273 { 2274 ::vos::OGuard aGuard( GetMutex() ); 2275 2276 Size aSz; 2277 if ( GetWindow() ) 2278 aSz = GetWindow()->GetSizePixel(); 2279 return ::com::sun::star::awt::Size( aSz.Width(), aSz.Height() ); 2280 } 2281 2282 void VCLXWindow::draw( sal_Int32 nX, sal_Int32 nY ) throw(::com::sun::star::uno::RuntimeException) 2283 { 2284 ::vos::OGuard aGuard( GetMutex() ); 2285 2286 Window* pWindow = GetWindow(); 2287 if ( !pWindow ) 2288 return; 2289 2290 if ( isDesignMode() || mpImpl->isEnableVisible() ) 2291 { 2292 TabPage* pTabPage = dynamic_cast< TabPage* >( pWindow ); 2293 if ( pTabPage ) 2294 { 2295 Point aPos( nX, nY ); 2296 Size aSize = pWindow->GetSizePixel(); 2297 2298 OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( mpImpl->mxViewGraphics ); 2299 aPos = pDev->PixelToLogic( aPos ); 2300 aSize = pDev->PixelToLogic( aSize ); 2301 2302 pTabPage->Draw( pDev, aPos, aSize, 0 ); 2303 return; 2304 } 2305 2306 OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( mpImpl->mxViewGraphics ); 2307 Point aPos( nX, nY ); 2308 2309 if ( !pDev ) 2310 pDev = pWindow->GetParent(); 2311 2312 if ( pWindow->GetParent() && !pWindow->IsSystemWindow() && ( pWindow->GetParent() == pDev ) ) 2313 { 2314 // #i40647# don't draw here if this is a recursive call 2315 // sometimes this is called recursively, because the Update call on the parent 2316 // (strangely) triggers another paint. Prevent a stack overflow here 2317 // Yes, this is only fixing symptoms for the moment .... 2318 // #i40647# / 2005-01-18 / frank.schoenheit@sun.com 2319 if ( !mpImpl->getDrawingOntoParent_ref() ) 2320 { 2321 ::comphelper::FlagGuard aDrawingflagGuard( mpImpl->getDrawingOntoParent_ref() ); 2322 2323 sal_Bool bWasVisible = pWindow->IsVisible(); 2324 Point aOldPos( pWindow->GetPosPixel() ); 2325 2326 if ( bWasVisible && aOldPos == aPos ) 2327 { 2328 pWindow->Update(); 2329 return; 2330 } 2331 2332 pWindow->SetPosPixel( aPos ); 2333 2334 // Erstmal ein Update auf den Parent, damit nicht beim Update 2335 // auf dieses Fenster noch ein Paint vom Parent abgearbeitet wird, 2336 // wo dann ggf. dieses Fenster sofort wieder gehidet wird. 2337 if( pWindow->GetParent() ) 2338 pWindow->GetParent()->Update(); 2339 2340 pWindow->Show(); 2341 pWindow->Update(); 2342 pWindow->SetParentUpdateMode( sal_False ); 2343 pWindow->Hide(); 2344 pWindow->SetParentUpdateMode( sal_True ); 2345 2346 pWindow->SetPosPixel( aOldPos ); 2347 if ( bWasVisible ) 2348 pWindow->Show( sal_True ); 2349 } 2350 } 2351 else if ( pDev ) 2352 { 2353 Size aSz = pWindow->GetSizePixel(); 2354 aSz = pDev->PixelToLogic( aSz ); 2355 Point aP = pDev->PixelToLogic( aPos ); 2356 2357 vcl::PDFExtOutDevData* pPDFExport = dynamic_cast<vcl::PDFExtOutDevData*>(pDev->GetExtOutDevData()); 2358 bool bDrawSimple = ( pDev->GetOutDevType() == OUTDEV_PRINTER ) 2359 || ( pDev->GetOutDevViewType() == OUTDEV_VIEWTYPE_PRINTPREVIEW ) 2360 || ( pPDFExport != NULL ); 2361 if ( bDrawSimple ) 2362 { 2363 pWindow->Draw( pDev, aP, aSz, WINDOW_DRAW_NOCONTROLS ); 2364 } 2365 else 2366 { 2367 sal_Bool bOldNW =pWindow->IsNativeWidgetEnabled(); 2368 if( bOldNW ) 2369 pWindow->EnableNativeWidget(sal_False); 2370 pWindow->PaintToDevice( pDev, aP, aSz ); 2371 if( bOldNW ) 2372 pWindow->EnableNativeWidget(sal_True); 2373 } 2374 } 2375 } 2376 } 2377 2378 void VCLXWindow::setZoom( float fZoomX, float /*fZoomY*/ ) throw(::com::sun::star::uno::RuntimeException) 2379 { 2380 ::vos::OGuard aGuard( GetMutex() ); 2381 2382 if ( GetWindow() ) 2383 { 2384 // Fraction::Fraction takes a double, but we have a float only. 2385 // The implicit conversion from float to double can result in a precision loss, i.e. 1.2 is converted to 2386 // 1.200000000047something. To prevent this, we convert explicitly to double, and round it. 2387 double nZoom( fZoomX ); 2388 nZoom = ::rtl::math::round( nZoom, 4 ); 2389 GetWindow()->SetZoom( Fraction( nZoom ) ); 2390 } 2391 } 2392 2393 // ::com::sun::star::lang::XEventListener 2394 void SAL_CALL VCLXWindow::disposing( const ::com::sun::star::lang::EventObject& _rSource ) throw (::com::sun::star::uno::RuntimeException) 2395 { 2396 ::vos::OGuard aGuard( GetMutex() ); 2397 2398 // check if it comes from our AccessibleContext 2399 uno::Reference< uno::XInterface > aAC( mpImpl->mxAccessibleContext, uno::UNO_QUERY ); 2400 uno::Reference< uno::XInterface > xSource( _rSource.Source, uno::UNO_QUERY ); 2401 2402 if ( aAC.get() == xSource.get() ) 2403 { // yep, it does 2404 mpImpl->mxAccessibleContext = uno::Reference< accessibility::XAccessibleContext >(); 2405 } 2406 } 2407 2408 // ::com::sun::star::accessibility::XAccessible 2409 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXWindow::getAccessibleContext( ) throw (::com::sun::star::uno::RuntimeException) 2410 { 2411 using namespace ::com::sun::star; 2412 2413 ::vos::OGuard aGuard( GetMutex() ); 2414 2415 // already disposed 2416 if( ! mpImpl ) 2417 return uno::Reference< accessibility::XAccessibleContext >(); 2418 2419 if ( !mpImpl->mxAccessibleContext.is() && GetWindow() ) 2420 { 2421 mpImpl->mxAccessibleContext = CreateAccessibleContext(); 2422 2423 // add as event listener to this component 2424 // in case somebody disposes it, we do not want to have a (though weak) reference to a dead 2425 // object 2426 uno::Reference< lang::XComponent > xComp( mpImpl->mxAccessibleContext, uno::UNO_QUERY ); 2427 if ( xComp.is() ) 2428 xComp->addEventListener( this ); 2429 } 2430 2431 return mpImpl->mxAccessibleContext; 2432 } 2433 2434 // ::com::sun::star::awt::XDockable 2435 void SAL_CALL VCLXWindow::addDockableWindowListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XDockableWindowListener >& xListener ) throw (::com::sun::star::uno::RuntimeException) 2436 { 2437 ::vos::OGuard aGuard( GetMutex() ); 2438 2439 if ( xListener.is() ) 2440 mpImpl->getDockableWindowListeners().addInterface( xListener ); 2441 2442 } 2443 2444 void SAL_CALL VCLXWindow::removeDockableWindowListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XDockableWindowListener >& xListener ) throw (::com::sun::star::uno::RuntimeException) 2445 { 2446 ::vos::OGuard aGuard( GetMutex() ); 2447 2448 mpImpl->getDockableWindowListeners().removeInterface( xListener ); 2449 } 2450 2451 void SAL_CALL VCLXWindow::enableDocking( sal_Bool bEnable ) throw (::com::sun::star::uno::RuntimeException) 2452 { 2453 ::vos::OGuard aGuard( GetMutex() ); 2454 2455 Window* pWindow = GetWindow(); 2456 if ( pWindow ) 2457 pWindow->EnableDocking( bEnable ); 2458 } 2459 2460 sal_Bool SAL_CALL VCLXWindow::isFloating( ) throw (::com::sun::star::uno::RuntimeException) 2461 { 2462 ::vos::OGuard aGuard( GetMutex() ); 2463 2464 Window* pWindow = GetWindow(); 2465 if( pWindow ) 2466 return Window::GetDockingManager()->IsFloating( pWindow ); 2467 else 2468 return sal_False; 2469 } 2470 2471 void SAL_CALL VCLXWindow::setFloatingMode( sal_Bool bFloating ) throw (::com::sun::star::uno::RuntimeException) 2472 { 2473 ::vos::OGuard aGuard( GetMutex() ); 2474 2475 Window* pWindow = GetWindow(); 2476 if( pWindow ) 2477 Window::GetDockingManager()->SetFloatingMode( pWindow, bFloating ); 2478 } 2479 2480 sal_Bool SAL_CALL VCLXWindow::isLocked( ) throw (::com::sun::star::uno::RuntimeException) 2481 { 2482 ::vos::OGuard aGuard( GetMutex() ); 2483 2484 Window* pWindow = GetWindow(); 2485 if( pWindow ) 2486 return Window::GetDockingManager()->IsLocked( pWindow ); 2487 else 2488 return sal_False; 2489 } 2490 2491 void SAL_CALL VCLXWindow::lock( ) throw (::com::sun::star::uno::RuntimeException) 2492 { 2493 ::vos::OGuard aGuard( GetMutex() ); 2494 2495 Window* pWindow = GetWindow(); 2496 if( pWindow && !Window::GetDockingManager()->IsFloating( pWindow ) ) 2497 Window::GetDockingManager()->Lock( pWindow ); 2498 } 2499 2500 void SAL_CALL VCLXWindow::unlock( ) throw (::com::sun::star::uno::RuntimeException) 2501 { 2502 ::vos::OGuard aGuard( GetMutex() ); 2503 2504 Window* pWindow = GetWindow(); 2505 if( pWindow && !Window::GetDockingManager()->IsFloating( pWindow ) ) 2506 Window::GetDockingManager()->Unlock( pWindow ); 2507 } 2508 void SAL_CALL VCLXWindow::startPopupMode( const ::com::sun::star::awt::Rectangle& ) throw (::com::sun::star::uno::RuntimeException) 2509 { 2510 // TODO: remove interface in the next incompatible build 2511 ::vos::OGuard aGuard( GetMutex() ); 2512 2513 } 2514 2515 sal_Bool SAL_CALL VCLXWindow::isInPopupMode( ) throw (::com::sun::star::uno::RuntimeException) 2516 { 2517 // TODO: remove interface in the next incompatible build 2518 ::vos::OGuard aGuard( GetMutex() ); 2519 return sal_False; 2520 } 2521 2522 2523 // ::com::sun::star::awt::XWindow2 2524 2525 void SAL_CALL VCLXWindow::setOutputSize( const ::com::sun::star::awt::Size& aSize ) throw (::com::sun::star::uno::RuntimeException) 2526 { 2527 ::vos::OGuard aGuard( GetMutex() ); 2528 Window *pWindow; 2529 if( (pWindow = GetWindow()) != NULL ) 2530 { 2531 DockingWindow *pDockingWindow = dynamic_cast< DockingWindow* >(pWindow); 2532 if( pDockingWindow ) 2533 pDockingWindow->SetOutputSizePixel( VCLSize( aSize ) ); 2534 else 2535 pWindow->SetOutputSizePixel( VCLSize( aSize ) ); 2536 } 2537 } 2538 2539 ::com::sun::star::awt::Size SAL_CALL VCLXWindow::getOutputSize( ) throw (::com::sun::star::uno::RuntimeException) 2540 { 2541 ::vos::OGuard aGuard( GetMutex() ); 2542 Window *pWindow; 2543 if( (pWindow = GetWindow()) != NULL ) 2544 { 2545 DockingWindow *pDockingWindow = dynamic_cast< DockingWindow* >(pWindow); 2546 if( pDockingWindow ) 2547 return AWTSize( pDockingWindow->GetOutputSizePixel() ); 2548 else 2549 return AWTSize( pWindow->GetOutputSizePixel() ); 2550 } 2551 else 2552 return ::com::sun::star::awt::Size(); 2553 } 2554 2555 sal_Bool SAL_CALL VCLXWindow::isVisible( ) throw (::com::sun::star::uno::RuntimeException) 2556 { 2557 ::vos::OGuard aGuard( GetMutex() ); 2558 if( GetWindow() ) 2559 return GetWindow()->IsVisible(); 2560 else 2561 return sal_False; 2562 } 2563 2564 sal_Bool SAL_CALL VCLXWindow::isActive( ) throw (::com::sun::star::uno::RuntimeException) 2565 { 2566 ::vos::OGuard aGuard( GetMutex() ); 2567 if( GetWindow() ) 2568 return GetWindow()->IsActive(); 2569 else 2570 return sal_False; 2571 2572 } 2573 2574 sal_Bool SAL_CALL VCLXWindow::isEnabled( ) throw (::com::sun::star::uno::RuntimeException) 2575 { 2576 ::vos::OGuard aGuard( GetMutex() ); 2577 if( GetWindow() ) 2578 return GetWindow()->IsEnabled(); 2579 else 2580 return sal_False; 2581 } 2582 2583 sal_Bool SAL_CALL VCLXWindow::hasFocus( ) throw (::com::sun::star::uno::RuntimeException) 2584 { 2585 ::vos::OGuard aGuard( GetMutex() ); 2586 if( GetWindow() ) 2587 return GetWindow()->HasFocus(); 2588 else 2589 return sal_False; 2590 } 2591 2592 // ::com::sun::star::beans::XPropertySetInfo 2593 2594 UnoPropertyArrayHelper * 2595 VCLXWindow::GetPropHelper() 2596 { 2597 ::vos::OGuard aGuard( GetMutex() ); 2598 if ( mpImpl->mpPropHelper == NULL ) 2599 { 2600 std::list< sal_uInt16 > aIDs; 2601 GetPropertyIds( aIDs ); 2602 mpImpl->mpPropHelper = new UnoPropertyArrayHelper( aIDs ); 2603 } 2604 return mpImpl->mpPropHelper; 2605 } 2606 2607 ::com::sun::star::uno::Sequence< ::com::sun::star::beans::Property > SAL_CALL 2608 VCLXWindow::getProperties() throw (::com::sun::star::uno::RuntimeException) 2609 { 2610 return GetPropHelper()->getProperties(); 2611 } 2612 ::com::sun::star::beans::Property SAL_CALL 2613 VCLXWindow::getPropertyByName( const ::rtl::OUString& rName ) throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::uno::RuntimeException) 2614 { 2615 return GetPropHelper()->getPropertyByName( rName ); 2616 } 2617 2618 ::sal_Bool SAL_CALL 2619 VCLXWindow::hasPropertyByName( const ::rtl::OUString& rName ) throw (::com::sun::star::uno::RuntimeException) 2620 { 2621 return GetPropHelper()->hasPropertyByName( rName ); 2622 } 2623 2624 Reference< XStyleSettings > SAL_CALL VCLXWindow::getStyleSettings() throw (RuntimeException) 2625 { 2626 return mpImpl->getStyleSettings(); 2627 } 2628