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