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