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