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/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 0 : 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 165 : void setEnableVisible( bool bEnableVisible ) { mbEnableVisible = bEnableVisible; }
153 46261 : bool isEnableVisible() { return mbEnableVisible; }
154 : /** synchronously mbDirectVisible;
155 : */
156 128009 : void setDirectVisible( bool bDirectVisible ) { mbDirectVisible = bDirectVisible; }
157 52 : 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 248 : inline ::toolkit::AccessibilityClient& getAccessibleFactory()
168 : {
169 248 : return maAccFactory;
170 : }
171 :
172 : Reference< XStyleSettings > getStyleSettings();
173 :
174 : /** returns the container of registered XWindowListener2 listeners
175 : */
176 22988 : inline ::cppu::OInterfaceContainerHelper& getWindow2Listeners() { return maWindow2Listeners; }
177 9523 : inline ::cppu::OInterfaceContainerHelper& getDockableWindowListeners(){ return maDockableWindowListeners; }
178 145 : inline EventListenerMultiplexer& getEventListeners() { return maEventListeners; }
179 42489 : inline FocusListenerMultiplexer& getFocusListeners() { return maFocusListeners; }
180 406371 : inline WindowListenerMultiplexer& getWindowListeners() { return maWindowListeners; }
181 95 : inline KeyListenerMultiplexer& getKeyListeners() { return maKeyListeners; }
182 130 : inline MouseListenerMultiplexer& getMouseListeners() { return maMouseListeners; }
183 10 : inline MouseMotionListenerMultiplexer& getMouseMotionListeners() { return maMouseMotionListeners; }
184 10420 : inline PaintListenerMultiplexer& getPaintListeners() { return maPaintListeners; }
185 126858 : inline VclContainerListenerMultiplexer& getContainerListeners() { return maContainerListeners; }
186 141471 : inline TopWindowListenerMultiplexer& getTopWindowListeners() { return maTopWindowListeners; }
187 :
188 : ~VCLXWindowImpl();
189 :
190 : private:
191 : DECL_LINK( OnProcessCallbacks, void* );
192 : };
193 :
194 :
195 78885 : 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 78885 : ,mpPropHelper( NULL )
222 : {
223 78885 : }
224 :
225 135462 : VCLXWindowImpl::~VCLXWindowImpl()
226 : {
227 67731 : delete mpPropHelper;
228 67731 : }
229 :
230 :
231 82218 : void VCLXWindowImpl::disposing()
232 : {
233 82218 : SolarMutexGuard aGuard;
234 82218 : if ( mnCallbackEventId )
235 10896 : Application::RemoveUserEvent( mnCallbackEventId );
236 82218 : mnCallbackEventId = 0;
237 :
238 82218 : mbDisposed= true;
239 :
240 164436 : ::com::sun::star::lang::EventObject aEvent;
241 82218 : aEvent.Source = mrAntiImpl;
242 :
243 82218 : maDockableWindowListeners.disposeAndClear( aEvent );
244 82218 : maEventListeners.disposeAndClear( aEvent );
245 82218 : maFocusListeners.disposeAndClear( aEvent );
246 82218 : maWindowListeners.disposeAndClear( aEvent );
247 82218 : maKeyListeners.disposeAndClear( aEvent );
248 82218 : maMouseListeners.disposeAndClear( aEvent );
249 82218 : maMouseMotionListeners.disposeAndClear( aEvent );
250 82218 : maPaintListeners.disposeAndClear( aEvent );
251 82218 : maContainerListeners.disposeAndClear( aEvent );
252 82218 : maTopWindowListeners.disposeAndClear( aEvent );
253 :
254 82218 : ::toolkit::WindowStyleSettings* pStyleSettings = static_cast< ::toolkit::WindowStyleSettings* >( mxWindowStyleSettings.get() );
255 82218 : if ( pStyleSettings != NULL )
256 0 : pStyleSettings->dispose();
257 164436 : mxWindowStyleSettings.clear();
258 82218 : }
259 :
260 :
261 22261 : void VCLXWindowImpl::callBackAsync( const VCLXWindow::Callback& i_callback )
262 : {
263 : DBG_TESTSOLARMUTEX();
264 22261 : maCallbackEvents.push_back( i_callback );
265 22261 : if ( !mnCallbackEventId )
266 : {
267 : // ensure our VCLXWindow is not destroyed while the event is underway
268 11324 : mrAntiImpl.acquire();
269 11324 : mnCallbackEventId = Application::PostUserEvent( LINK( this, VCLXWindowImpl, OnProcessCallbacks ) );
270 : }
271 22261 : }
272 :
273 :
274 856 : IMPL_LINK_NOARG(VCLXWindowImpl, OnProcessCallbacks)
275 : {
276 428 : const Reference< uno::XInterface > xKeepAlive( mrAntiImpl );
277 :
278 : // work on a copy of the callback array
279 856 : CallbackArray aCallbacksCopy;
280 : {
281 428 : SolarMutexGuard aGuard;
282 428 : aCallbacksCopy = maCallbackEvents;
283 428 : maCallbackEvents.clear();
284 :
285 : // we acquired our VCLXWindow once before posting the event, release this one ref now
286 428 : mrAntiImpl.release();
287 :
288 428 : if ( !mnCallbackEventId )
289 : // we were disposed while waiting for the mutex to lock
290 0 : return 1L;
291 :
292 428 : mnCallbackEventId = 0;
293 : }
294 :
295 : {
296 428 : SolarMutexReleaser aReleaseSolar;
297 2745 : for ( CallbackArray::const_iterator loop = aCallbacksCopy.begin();
298 1830 : loop != aCallbacksCopy.end();
299 : ++loop
300 : )
301 : {
302 487 : (*loop)();
303 428 : }
304 : }
305 :
306 856 : return 0L;
307 : }
308 :
309 0 : Reference< XStyleSettings > VCLXWindowImpl::getStyleSettings()
310 : {
311 0 : SolarMutexGuard aGuard;
312 0 : if ( mbDisposed )
313 0 : throw DisposedException( OUString(), mrAntiImpl );
314 0 : if ( !mxWindowStyleSettings.is() )
315 0 : mxWindowStyleSettings = new ::toolkit::WindowStyleSettings( maListenerContainerMutex, mrAntiImpl );
316 0 : return mxWindowStyleSettings;
317 : }
318 :
319 :
320 :
321 :
322 : // Uses an out-parameter instead of return value, due to the object reference
323 :
324 64862 : void ImplInitWindowEvent( ::com::sun::star::awt::WindowEvent& rEvent, vcl::Window* pWindow )
325 : {
326 64862 : Point aPos = pWindow->GetPosPixel();
327 64862 : Size aSz = pWindow->GetSizePixel();
328 :
329 64862 : rEvent.X = aPos.X();
330 64862 : rEvent.Y = aPos.Y();
331 :
332 64862 : rEvent.Width = aSz.Width();
333 64862 : rEvent.Height = aSz.Height();
334 :
335 64862 : pWindow->GetBorder( rEvent.LeftInset, rEvent.TopInset, rEvent.RightInset, rEvent.BottomInset );
336 64862 : }
337 :
338 78885 : VCLXWindow::VCLXWindow( bool _bWithDefaultProps )
339 78885 : :mpImpl( NULL )
340 : {
341 78885 : mpImpl = new VCLXWindowImpl( *this, _bWithDefaultProps );
342 78885 : }
343 :
344 169483 : VCLXWindow::~VCLXWindow()
345 : {
346 67731 : delete mpImpl;
347 :
348 67731 : if ( GetWindow() )
349 : {
350 0 : GetWindow()->RemoveEventListener( LINK( this, VCLXWindow, WindowEventListener ) );
351 0 : GetWindow()->SetWindowPeer( NULL, NULL );
352 0 : GetWindow()->SetAccessible( NULL );
353 : }
354 101752 : }
355 :
356 :
357 22261 : void VCLXWindow::ImplExecuteAsyncWithoutSolarLock( const Callback& i_callback )
358 : {
359 22261 : mpImpl->callBackAsync( i_callback );
360 22261 : }
361 :
362 :
363 248 : ::toolkit::IAccessibleFactory& VCLXWindow::getAccessibleFactory()
364 : {
365 248 : return mpImpl->getAccessibleFactory().getFactory();
366 : }
367 :
368 200293 : void VCLXWindow::SetWindow( const VclPtr<vcl::Window> &pWindow )
369 : {
370 200293 : if ( GetWindow() )
371 : {
372 121408 : GetWindow()->RemoveEventListener( LINK( this, VCLXWindow, WindowEventListener ) );
373 : // GetWindow()->DbgAssertNoEventListeners();
374 : }
375 :
376 200293 : SetOutputDevice( pWindow );
377 :
378 200293 : if ( GetWindow() )
379 : {
380 78886 : GetWindow()->AddEventListener( LINK( this, VCLXWindow, WindowEventListener ) );
381 78886 : bool bDirectVisible = pWindow && pWindow->IsVisible();
382 78886 : mpImpl->setDirectVisible( bDirectVisible );
383 : }
384 200293 : }
385 :
386 4791 : void VCLXWindow::suspendVclEventListening( )
387 : {
388 4791 : ++mpImpl->mnListenerLockLevel;
389 4791 : }
390 :
391 4791 : void VCLXWindow::resumeVclEventListening( )
392 : {
393 : DBG_ASSERT( mpImpl->mnListenerLockLevel, "VCLXWindow::resumeVclEventListening: not suspended!" );
394 4791 : --mpImpl->mnListenerLockLevel;
395 4791 : }
396 :
397 126858 : void VCLXWindow::notifyWindowRemoved( vcl::Window& _rWindow )
398 : {
399 126858 : if ( mpImpl->getContainerListeners().getLength() )
400 : {
401 0 : awt::VclContainerEvent aEvent;
402 0 : aEvent.Source = *this;
403 0 : aEvent.Child = static_cast< XWindow* >( _rWindow.GetWindowPeer() );
404 0 : mpImpl->getContainerListeners().windowRemoved( aEvent );
405 : }
406 126858 : }
407 :
408 2211844 : IMPL_LINK( VCLXWindow, WindowEventListener, VclSimpleEvent*, pEvent )
409 : {
410 1105922 : if ( mpImpl->mnListenerLockLevel )
411 3056 : return 0L;
412 :
413 : DBG_ASSERT( pEvent && pEvent->ISA( VclWindowEvent ), "Unknown WindowEvent!" );
414 1102866 : if ( pEvent && pEvent->ISA( VclWindowEvent ) )
415 : {
416 : DBG_ASSERT( static_cast<VclWindowEvent*>(pEvent)->GetWindow() && GetWindow(), "Window???" );
417 1102866 : ProcessWindowEvent( *static_cast<VclWindowEvent*>(pEvent) );
418 : }
419 1102866 : return 0;
420 : }
421 :
422 : namespace
423 : {
424 290452 : struct CallWindow2Listener
425 : {
426 22260 : CallWindow2Listener( ::cppu::OInterfaceContainerHelper& i_rWindow2Listeners, const bool i_bEnabled, const EventObject& i_rEvent )
427 : :m_rWindow2Listeners( i_rWindow2Listeners )
428 : ,m_bEnabled( i_bEnabled )
429 22260 : ,m_aEvent( i_rEvent )
430 : {
431 22260 : }
432 :
433 486 : void operator()()
434 : {
435 486 : m_rWindow2Listeners.notifyEach( m_bEnabled ? &XWindowListener2::windowEnabled : &XWindowListener2::windowDisabled, m_aEvent );
436 486 : }
437 :
438 : ::cppu::OInterfaceContainerHelper& m_rWindow2Listeners;
439 : const bool m_bEnabled;
440 : const EventObject m_aEvent;
441 : };
442 : }
443 :
444 1102628 : void VCLXWindow::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
445 : {
446 1102628 : ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xThis( static_cast<cppu::OWeakObject*>(this) );
447 :
448 1102628 : switch ( rVclWindowEvent.GetId() )
449 : {
450 : case VCLEVENT_WINDOW_ENABLED:
451 : case VCLEVENT_WINDOW_DISABLED:
452 : {
453 : Callback aCallback = CallWindow2Listener(
454 22260 : mpImpl->getWindow2Listeners(),
455 22260 : ( VCLEVENT_WINDOW_ENABLED == rVclWindowEvent.GetId() ),
456 : EventObject( *this )
457 66780 : );
458 22260 : ImplExecuteAsyncWithoutSolarLock( aCallback );
459 : }
460 22260 : break;
461 :
462 : case VCLEVENT_WINDOW_PAINT:
463 : {
464 10420 : if ( mpImpl->getPaintListeners().getLength() )
465 : {
466 0 : ::com::sun::star::awt::PaintEvent aEvent;
467 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
468 0 : aEvent.UpdateRect = AWTRectangle( *static_cast<Rectangle*>(rVclWindowEvent.GetData()) );
469 0 : aEvent.Count = 0;
470 0 : mpImpl->getPaintListeners().windowPaint( aEvent );
471 : }
472 : }
473 10420 : break;
474 : case VCLEVENT_WINDOW_MOVE:
475 : {
476 111568 : if ( mpImpl->getWindowListeners().getLength() )
477 : {
478 17188 : ::com::sun::star::awt::WindowEvent aEvent;
479 17188 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
480 17188 : ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() );
481 17188 : mpImpl->getWindowListeners().windowMoved( aEvent );
482 : }
483 : }
484 111568 : break;
485 : case VCLEVENT_WINDOW_RESIZE:
486 : {
487 103127 : if ( mpImpl->getWindowListeners().getLength() )
488 : {
489 18518 : ::com::sun::star::awt::WindowEvent aEvent;
490 18518 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
491 18518 : ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() );
492 18518 : mpImpl->getWindowListeners().windowResized( aEvent );
493 : }
494 : }
495 103127 : break;
496 : case VCLEVENT_WINDOW_SHOW:
497 : {
498 51416 : if ( mpImpl->getWindowListeners().getLength() )
499 : {
500 18625 : ::com::sun::star::awt::WindowEvent aEvent;
501 18625 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
502 18625 : ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() );
503 18625 : mpImpl->getWindowListeners().windowShown( aEvent );
504 : }
505 :
506 : // For TopWindows this means opened...
507 51416 : if ( mpImpl->getTopWindowListeners().getLength() )
508 : {
509 6344 : ::com::sun::star::lang::EventObject aEvent;
510 6344 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
511 6344 : mpImpl->getTopWindowListeners().windowOpened( aEvent );
512 : }
513 : }
514 51416 : break;
515 : case VCLEVENT_WINDOW_HIDE:
516 : {
517 37787 : if ( mpImpl->getWindowListeners().getLength() )
518 : {
519 10531 : ::com::sun::star::awt::WindowEvent aEvent;
520 10531 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
521 10531 : ImplInitWindowEvent( aEvent, rVclWindowEvent.GetWindow() );
522 10531 : mpImpl->getWindowListeners().windowHidden( aEvent );
523 : }
524 :
525 : // For TopWindows this means closed...
526 37787 : if ( mpImpl->getTopWindowListeners().getLength() )
527 : {
528 5 : ::com::sun::star::lang::EventObject aEvent;
529 5 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
530 5 : mpImpl->getTopWindowListeners().windowClosed( aEvent );
531 : }
532 : }
533 37787 : break;
534 : case VCLEVENT_WINDOW_ACTIVATE:
535 : {
536 15420 : if ( mpImpl->getTopWindowListeners().getLength() )
537 : {
538 3552 : ::com::sun::star::lang::EventObject aEvent;
539 3552 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
540 3552 : mpImpl->getTopWindowListeners().windowActivated( aEvent );
541 : }
542 : }
543 15420 : break;
544 : case VCLEVENT_WINDOW_DEACTIVATE:
545 : {
546 6926 : if ( mpImpl->getTopWindowListeners().getLength() )
547 : {
548 230 : ::com::sun::star::lang::EventObject aEvent;
549 230 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
550 230 : mpImpl->getTopWindowListeners().windowDeactivated( aEvent );
551 : }
552 : }
553 6926 : break;
554 : case VCLEVENT_WINDOW_CLOSE:
555 : {
556 0 : if ( mpImpl->getDockableWindowListeners().getLength() )
557 : {
558 0 : ::com::sun::star::lang::EventObject aEvent;
559 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
560 0 : mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::closed, aEvent );
561 : }
562 0 : if ( mpImpl->getTopWindowListeners().getLength() )
563 : {
564 0 : ::com::sun::star::lang::EventObject aEvent;
565 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
566 0 : mpImpl->getTopWindowListeners().windowClosing( aEvent );
567 : }
568 : }
569 0 : break;
570 : case VCLEVENT_CONTROL_GETFOCUS:
571 : case VCLEVENT_WINDOW_GETFOCUS:
572 : {
573 24588 : if ( ( rVclWindowEvent.GetWindow()->IsCompoundControl()
574 6 : && rVclWindowEvent.GetId() == VCLEVENT_CONTROL_GETFOCUS
575 : )
576 36874 : || ( !rVclWindowEvent.GetWindow()->IsCompoundControl()
577 12288 : && rVclWindowEvent.GetId() == VCLEVENT_WINDOW_GETFOCUS
578 : )
579 : )
580 : {
581 12288 : if ( mpImpl->getFocusListeners().getLength() )
582 : {
583 2999 : ::com::sun::star::awt::FocusEvent aEvent;
584 2999 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
585 2999 : aEvent.FocusFlags = static_cast<sal_Int16>(rVclWindowEvent.GetWindow()->GetGetFocusFlags());
586 2999 : aEvent.Temporary = sal_False;
587 2999 : mpImpl->getFocusListeners().focusGained( aEvent );
588 : }
589 : }
590 : }
591 12294 : break;
592 : case VCLEVENT_CONTROL_LOSEFOCUS:
593 : case VCLEVENT_WINDOW_LOSEFOCUS:
594 : {
595 13266 : if ( ( rVclWindowEvent.GetWindow()->IsCompoundControl()
596 0 : && rVclWindowEvent.GetId() == VCLEVENT_CONTROL_LOSEFOCUS
597 : )
598 19896 : || ( !rVclWindowEvent.GetWindow()->IsCompoundControl()
599 6633 : && rVclWindowEvent.GetId() == VCLEVENT_WINDOW_LOSEFOCUS
600 : )
601 : )
602 : {
603 6630 : if ( mpImpl->getFocusListeners().getLength() )
604 : {
605 660 : ::com::sun::star::awt::FocusEvent aEvent;
606 660 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
607 660 : aEvent.FocusFlags = static_cast<sal_Int16>(rVclWindowEvent.GetWindow()->GetGetFocusFlags());
608 660 : aEvent.Temporary = sal_False;
609 :
610 660 : vcl::Window* pNext = Application::GetFocusWindow();
611 660 : if ( pNext )
612 : {
613 : // Don't care about internals if this control is compound
614 659 : vcl::Window* pNextC = pNext;
615 3300 : while ( pNextC && !pNextC->IsCompoundControl() )
616 1982 : pNextC = pNextC->GetParent();
617 659 : if ( pNextC )
618 0 : pNext = pNextC;
619 :
620 659 : pNext->GetComponentInterface( true );
621 659 : aEvent.NextFocus = static_cast<cppu::OWeakObject*>(pNext->GetWindowPeer());
622 : }
623 660 : mpImpl->getFocusListeners().focusLost( aEvent );
624 : }
625 : }
626 : }
627 6633 : break;
628 : case VCLEVENT_WINDOW_MINIMIZE:
629 : {
630 14 : if ( mpImpl->getTopWindowListeners().getLength() )
631 : {
632 4 : ::com::sun::star::lang::EventObject aEvent;
633 4 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
634 4 : mpImpl->getTopWindowListeners().windowMinimized( aEvent );
635 : }
636 : }
637 14 : break;
638 : case VCLEVENT_WINDOW_NORMALIZE:
639 : {
640 10 : if ( mpImpl->getTopWindowListeners().getLength() )
641 : {
642 2 : ::com::sun::star::lang::EventObject aEvent;
643 2 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
644 2 : mpImpl->getTopWindowListeners().windowNormalized( aEvent );
645 : }
646 : }
647 10 : break;
648 : case VCLEVENT_WINDOW_KEYINPUT:
649 : {
650 0 : if ( mpImpl->getKeyListeners().getLength() )
651 : {
652 : ::com::sun::star::awt::KeyEvent aEvent( VCLUnoHelper::createKeyEvent(
653 0 : *static_cast<KeyEvent*>(rVclWindowEvent.GetData()), *this
654 0 : ) );
655 0 : mpImpl->getKeyListeners().keyPressed( aEvent );
656 : }
657 : }
658 0 : break;
659 : case VCLEVENT_WINDOW_KEYUP:
660 : {
661 0 : if ( mpImpl->getKeyListeners().getLength() )
662 : {
663 : ::com::sun::star::awt::KeyEvent aEvent( VCLUnoHelper::createKeyEvent(
664 0 : *static_cast<KeyEvent*>(rVclWindowEvent.GetData()), *this
665 0 : ) );
666 0 : mpImpl->getKeyListeners().keyReleased( aEvent );
667 : }
668 : }
669 0 : break;
670 : case VCLEVENT_WINDOW_COMMAND:
671 : {
672 0 : CommandEvent* pCmdEvt = static_cast<CommandEvent*>(rVclWindowEvent.GetData());
673 0 : if ( mpImpl->getMouseListeners().getLength() && ( pCmdEvt->GetCommand() == CommandEventId::ContextMenu ) )
674 : {
675 : // CommandEventId::ContextMenu als mousePressed mit PopupTrigger = sal_True versenden...
676 0 : Point aWhere = static_cast< CommandEvent* >( rVclWindowEvent.GetData() )->GetMousePosPixel();
677 0 : 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 0 : aWhere = Point( -1, -1 );
683 : }
684 :
685 0 : MouseEvent aMEvt( aWhere, 1, MouseEventModifiers::SIMPLECLICK, MOUSE_LEFT, 0 );
686 0 : awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( aMEvt, *this ) );
687 0 : aEvent.PopupTrigger = sal_True;
688 :
689 : Callback aCallback = ::boost::bind(
690 : &MouseListenerMultiplexer::mousePressed,
691 0 : &mpImpl->getMouseListeners(),
692 : aEvent
693 0 : );
694 0 : ImplExecuteAsyncWithoutSolarLock( aCallback );
695 : }
696 : }
697 0 : break;
698 : case VCLEVENT_WINDOW_MOUSEMOVE:
699 : {
700 0 : MouseEvent* pMouseEvt = static_cast<MouseEvent*>(rVclWindowEvent.GetData());
701 0 : if ( mpImpl->getMouseListeners().getLength() && ( pMouseEvt->IsEnterWindow() || pMouseEvt->IsLeaveWindow() ) )
702 : {
703 0 : awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( *pMouseEvt, *this ) );
704 :
705 : Callback aCallback = ::boost::bind(
706 0 : pMouseEvt->IsEnterWindow() ? &MouseListenerMultiplexer::mouseEntered : &MouseListenerMultiplexer::mouseExited,
707 0 : &mpImpl->getMouseListeners(),
708 : aEvent
709 0 : );
710 0 : ImplExecuteAsyncWithoutSolarLock( aCallback );
711 : }
712 :
713 0 : if ( mpImpl->getMouseMotionListeners().getLength() && !pMouseEvt->IsEnterWindow() && !pMouseEvt->IsLeaveWindow() )
714 : {
715 0 : awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( *pMouseEvt, *this ) );
716 0 : aEvent.ClickCount = 0; // #92138#
717 0 : if ( pMouseEvt->GetMode() & MouseEventModifiers::SIMPLEMOVE )
718 0 : mpImpl->getMouseMotionListeners().mouseMoved( aEvent );
719 : else
720 0 : mpImpl->getMouseMotionListeners().mouseDragged( aEvent );
721 : }
722 : }
723 0 : break;
724 : case VCLEVENT_WINDOW_MOUSEBUTTONDOWN:
725 : {
726 0 : if ( mpImpl->getMouseListeners().getLength() )
727 : {
728 0 : awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( *static_cast<MouseEvent*>(rVclWindowEvent.GetData()), *this ) );
729 : Callback aCallback = ::boost::bind(
730 : &MouseListenerMultiplexer::mousePressed,
731 0 : &mpImpl->getMouseListeners(),
732 : aEvent
733 0 : );
734 0 : ImplExecuteAsyncWithoutSolarLock( aCallback );
735 : }
736 : }
737 0 : break;
738 : case VCLEVENT_WINDOW_MOUSEBUTTONUP:
739 : {
740 0 : if ( mpImpl->getMouseListeners().getLength() )
741 : {
742 0 : awt::MouseEvent aEvent( VCLUnoHelper::createMouseEvent( *static_cast<MouseEvent*>(rVclWindowEvent.GetData()), *this ) );
743 : Callback aCallback = ::boost::bind(
744 : &MouseListenerMultiplexer::mouseReleased,
745 0 : &mpImpl->getMouseListeners(),
746 : aEvent
747 0 : );
748 0 : ImplExecuteAsyncWithoutSolarLock( aCallback );
749 : }
750 : }
751 0 : break;
752 : case VCLEVENT_WINDOW_STARTDOCKING:
753 : {
754 0 : if ( mpImpl->getDockableWindowListeners().getLength() )
755 : {
756 0 : DockingData *pData = static_cast<DockingData*>(rVclWindowEvent.GetData());
757 :
758 0 : if( pData )
759 : {
760 0 : ::com::sun::star::awt::DockingEvent aEvent;
761 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
762 0 : aEvent.TrackingRectangle = AWTRectangle( pData->maTrackRect );
763 0 : aEvent.MousePos.X = pData->maMousePos.X();
764 0 : aEvent.MousePos.Y = pData->maMousePos.Y();
765 0 : aEvent.bLiveMode = pData->mbLivemode;
766 0 : aEvent.bInteractive = pData->mbInteractive;
767 :
768 0 : mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::startDocking, aEvent );
769 : }
770 : }
771 : }
772 0 : break;
773 : case VCLEVENT_WINDOW_DOCKING:
774 : {
775 0 : if ( mpImpl->getDockableWindowListeners().getLength() )
776 : {
777 0 : DockingData *pData = static_cast<DockingData*>(rVclWindowEvent.GetData());
778 :
779 0 : if( pData )
780 : {
781 0 : ::com::sun::star::awt::DockingEvent aEvent;
782 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
783 0 : aEvent.TrackingRectangle = AWTRectangle( pData->maTrackRect );
784 0 : aEvent.MousePos.X = pData->maMousePos.X();
785 0 : aEvent.MousePos.Y = pData->maMousePos.Y();
786 0 : aEvent.bLiveMode = pData->mbLivemode;
787 0 : aEvent.bInteractive = pData->mbInteractive;
788 :
789 0 : Reference< XDockableWindowListener > xFirstListener;
790 0 : ::cppu::OInterfaceIteratorHelper aIter( mpImpl->getDockableWindowListeners() );
791 0 : while ( aIter.hasMoreElements() && !xFirstListener.is() )
792 : {
793 0 : xFirstListener.set( aIter.next(), UNO_QUERY );
794 : }
795 :
796 : ::com::sun::star::awt::DockingData aDockingData =
797 0 : xFirstListener->docking( aEvent );
798 0 : pData->maTrackRect = VCLRectangle( aDockingData.TrackingRectangle );
799 0 : pData->mbFloating = aDockingData.bFloating;
800 : }
801 : }
802 : }
803 0 : break;
804 : case VCLEVENT_WINDOW_ENDDOCKING:
805 : {
806 0 : if ( mpImpl->getDockableWindowListeners().getLength() )
807 : {
808 0 : EndDockingData *pData = static_cast<EndDockingData*>(rVclWindowEvent.GetData());
809 :
810 0 : if( pData )
811 : {
812 0 : ::com::sun::star::awt::EndDockingEvent aEvent;
813 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
814 0 : aEvent.WindowRectangle = AWTRectangle( pData->maWindowRect );
815 0 : aEvent.bFloating = pData->mbFloating;
816 0 : aEvent.bCancelled = pData->mbCancelled;
817 0 : mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::endDocking, aEvent );
818 : }
819 : }
820 : }
821 0 : break;
822 : case VCLEVENT_WINDOW_PREPARETOGGLEFLOATING:
823 : {
824 0 : if ( mpImpl->getDockableWindowListeners().getLength() )
825 : {
826 0 : sal_Bool *p_bFloating = static_cast<sal_Bool*>(rVclWindowEvent.GetData());
827 :
828 0 : ::com::sun::star::lang::EventObject aEvent;
829 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
830 :
831 0 : Reference< XDockableWindowListener > xFirstListener;
832 0 : ::cppu::OInterfaceIteratorHelper aIter( mpImpl->getDockableWindowListeners() );
833 0 : while ( aIter.hasMoreElements() && !xFirstListener.is() )
834 : {
835 0 : xFirstListener.set( aIter.next(), UNO_QUERY );
836 : }
837 :
838 0 : *p_bFloating = xFirstListener->prepareToggleFloatingMode( aEvent );
839 : }
840 : }
841 0 : break;
842 : case VCLEVENT_WINDOW_TOGGLEFLOATING:
843 : {
844 0 : if ( mpImpl->getDockableWindowListeners().getLength() )
845 : {
846 0 : ::com::sun::star::lang::EventObject aEvent;
847 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
848 0 : mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::toggleFloatingMode, aEvent );
849 : }
850 : }
851 0 : break;
852 : case VCLEVENT_WINDOW_ENDPOPUPMODE:
853 : {
854 0 : if ( mpImpl->getDockableWindowListeners().getLength() )
855 : {
856 0 : EndPopupModeData *pData = static_cast<EndPopupModeData*>(rVclWindowEvent.GetData());
857 :
858 0 : if( pData )
859 : {
860 0 : ::com::sun::star::awt::EndPopupModeEvent aEvent;
861 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
862 0 : aEvent.FloatingPosition.X = pData->maFloatingPos.X();
863 0 : aEvent.FloatingPosition.Y = pData->maFloatingPos.Y();
864 0 : aEvent.bTearoff = pData->mbTearoff;
865 0 : mpImpl->getDockableWindowListeners().notifyEach( &XDockableWindowListener::endPopupMode, aEvent );
866 : }
867 : }
868 : }
869 0 : break;
870 :
871 1102628 : }
872 1102628 : }
873 :
874 182 : uno::Reference< accessibility::XAccessibleContext > VCLXWindow::CreateAccessibleContext()
875 : {
876 182 : SolarMutexGuard aGuard;
877 182 : return getAccessibleFactory().createAccessibleContext( this );
878 : }
879 :
880 884 : void VCLXWindow::SetSynthesizingVCLEvent( bool _b )
881 : {
882 884 : mpImpl->mbSynthesizingVCLEvent = _b;
883 884 : }
884 :
885 7 : bool VCLXWindow::IsSynthesizingVCLEvent() const
886 : {
887 7 : return mpImpl->mbSynthesizingVCLEvent;
888 : }
889 :
890 9 : Size VCLXWindow::ImplCalcWindowSize( const Size& rOutSz ) const
891 : {
892 9 : Size aSz = rOutSz;
893 :
894 9 : vcl::Window* pWindow = GetWindow();
895 9 : if ( pWindow )
896 : {
897 : sal_Int32 nLeft, nTop, nRight, nBottom;
898 9 : pWindow->GetBorder( nLeft, nTop, nRight, nBottom );
899 9 : aSz.Width() += nLeft+nRight;
900 9 : aSz.Height() += nTop+nBottom;
901 : }
902 9 : return aSz;
903 : }
904 :
905 :
906 : // ::com::sun::star::lang::XUnoTunnel
907 2663391 : IMPL_XUNOTUNNEL2( VCLXWindow, VCLXDevice )
908 :
909 : // ::com::sun::star::lang::Component
910 124931 : void VCLXWindow::dispose( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
911 : {
912 124931 : SolarMutexGuard aGuard;
913 :
914 124931 : mpImpl->mxViewGraphics = NULL;
915 :
916 124931 : if ( !mpImpl->mbDisposing )
917 : {
918 82218 : mpImpl->mbDisposing = true;
919 :
920 82218 : mpImpl->disposing();
921 :
922 82218 : if ( GetWindow() )
923 : {
924 42649 : VclPtr<OutputDevice> pOutDev = GetOutputDevice();
925 42649 : SetWindow( NULL ); // so that handlers are logged off, if necessary (virtual)
926 42649 : SetOutputDevice( pOutDev );
927 42649 : pOutDev.disposeAndClear();
928 42649 : 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 82218 : ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent > xComponent( mpImpl->mxAccessibleContext, ::com::sun::star::uno::UNO_QUERY );
937 82218 : if ( xComponent.is() )
938 248 : xComponent->dispose();
939 : }
940 0 : catch ( const ::com::sun::star::uno::Exception& )
941 : {
942 : OSL_FAIL( "VCLXWindow::dispose: could not dispose the accessible context!" );
943 : }
944 82218 : mpImpl->mxAccessibleContext.clear();
945 :
946 82218 : mpImpl->mbDisposing = false;
947 124931 : }
948 124931 : }
949 :
950 112 : 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 112 : SolarMutexGuard aGuard;
953 :
954 112 : mpImpl->getEventListeners().addInterface( rxListener );
955 112 : }
956 :
957 33 : 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 33 : SolarMutexGuard aGuard;
960 :
961 33 : mpImpl->getEventListeners().removeInterface( rxListener );
962 33 : }
963 :
964 :
965 : // ::com::sun::star::awt::XWindow
966 122710 : 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 122710 : SolarMutexGuard aGuard;
969 :
970 122710 : if ( GetWindow() )
971 : {
972 122710 : if( vcl::Window::GetDockingManager()->IsDockable( GetWindow() ) )
973 9522 : vcl::Window::GetDockingManager()->SetPosSizePixel( GetWindow() , X, Y, Width, Height, static_cast<PosSizeFlags>(Flags) );
974 : else
975 113188 : GetWindow()->setPosSizePixel( X, Y, Width, Height, static_cast<PosSizeFlags>(Flags) );
976 122710 : }
977 122710 : }
978 :
979 179980 : ::com::sun::star::awt::Rectangle VCLXWindow::getPosSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
980 : {
981 179980 : SolarMutexGuard aGuard;
982 :
983 179980 : ::com::sun::star::awt::Rectangle aBounds;
984 179980 : if ( GetWindow() )
985 : {
986 179980 : if( vcl::Window::GetDockingManager()->IsDockable( GetWindow() ) )
987 22041 : aBounds = AWTRectangle( vcl::Window::GetDockingManager()->GetPosSizePixel( GetWindow() ) );
988 : else
989 157939 : aBounds = AWTRectangle( Rectangle( GetWindow()->GetPosPixel(), GetWindow()->GetSizePixel() ) );
990 : }
991 :
992 179980 : return aBounds;
993 : }
994 :
995 49124 : void VCLXWindow::setVisible( sal_Bool bVisible ) throw(::com::sun::star::uno::RuntimeException, std::exception)
996 : {
997 49124 : SolarMutexGuard aGuard;
998 :
999 49124 : vcl::Window* pWindow = GetWindow();
1000 49124 : if ( pWindow )
1001 : {
1002 49123 : mpImpl->setDirectVisible( bVisible );
1003 49123 : pWindow->Show( bVisible && mpImpl->isEnableVisible() );
1004 49124 : }
1005 49124 : }
1006 :
1007 551 : void VCLXWindow::setEnable( sal_Bool bEnable ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1008 : {
1009 551 : SolarMutexGuard aGuard;
1010 :
1011 551 : vcl::Window* pWindow = GetWindow();
1012 551 : if ( pWindow )
1013 : {
1014 551 : pWindow->Enable( bEnable, false ); // #95824# without children!
1015 551 : pWindow->EnableInput( bEnable );
1016 551 : }
1017 551 : }
1018 :
1019 3216 : void VCLXWindow::setFocus( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1020 : {
1021 3216 : SolarMutexGuard aGuard;
1022 :
1023 3216 : if ( GetWindow() )
1024 3216 : GetWindow()->GrabFocus();
1025 3216 : }
1026 :
1027 23693 : 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 23693 : SolarMutexGuard aGuard;
1030 :
1031 23693 : mpImpl->getWindowListeners().addInterface( rxListener );
1032 :
1033 47386 : Reference< XWindowListener2 > xListener2( rxListener, UNO_QUERY );
1034 23693 : if ( xListener2.is() )
1035 364 : mpImpl->getWindow2Listeners().addInterface( xListener2 );
1036 :
1037 : // #100119# Get all resize events, even if height or width 0, or invisible
1038 23693 : if ( GetWindow() )
1039 47386 : GetWindow()->EnableAllResize( true );
1040 23693 : }
1041 :
1042 13918 : 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 13918 : SolarMutexGuard aGuard;
1045 :
1046 27836 : Reference< XWindowListener2 > xListener2( rxListener, UNO_QUERY );
1047 13918 : if ( xListener2.is() )
1048 364 : mpImpl->getWindow2Listeners().removeInterface( xListener2 );
1049 :
1050 27836 : mpImpl->getWindowListeners().removeInterface( rxListener );
1051 13918 : }
1052 :
1053 10015 : 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 10015 : SolarMutexGuard aGuard;
1056 10015 : mpImpl->getFocusListeners().addInterface( rxListener );
1057 10015 : }
1058 :
1059 9897 : 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 9897 : SolarMutexGuard aGuard;
1062 9897 : mpImpl->getFocusListeners().removeInterface( rxListener );
1063 9897 : }
1064 :
1065 93 : 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 93 : SolarMutexGuard aGuard;
1068 93 : mpImpl->getKeyListeners().addInterface( rxListener );
1069 93 : }
1070 :
1071 2 : 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 2 : SolarMutexGuard aGuard;
1074 2 : mpImpl->getKeyListeners().removeInterface( rxListener );
1075 2 : }
1076 :
1077 74 : 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 74 : SolarMutexGuard aGuard;
1080 74 : mpImpl->getMouseListeners().addInterface( rxListener );
1081 74 : }
1082 :
1083 56 : 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 56 : SolarMutexGuard aGuard;
1086 56 : mpImpl->getMouseListeners().removeInterface( rxListener );
1087 56 : }
1088 :
1089 9 : 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 9 : SolarMutexGuard aGuard;
1092 9 : mpImpl->getMouseMotionListeners().addInterface( rxListener );
1093 9 : }
1094 :
1095 1 : 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 1 : SolarMutexGuard aGuard;
1098 1 : mpImpl->getMouseMotionListeners().removeInterface( rxListener );
1099 1 : }
1100 :
1101 0 : 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 0 : SolarMutexGuard aGuard;
1104 0 : mpImpl->getPaintListeners().addInterface( rxListener );
1105 0 : }
1106 :
1107 0 : 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 0 : SolarMutexGuard aGuard;
1110 0 : mpImpl->getPaintListeners().removeInterface( rxListener );
1111 0 : }
1112 :
1113 : // ::com::sun::star::awt::XWindowPeer
1114 352 : ::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 352 : return Application::GetVCLToolkit();
1119 : }
1120 :
1121 0 : 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 0 : SolarMutexGuard aGuard;
1124 :
1125 0 : VCLXPointer* pPointer = VCLXPointer::GetImplementation( rxPointer );
1126 0 : if ( pPointer )
1127 : {
1128 0 : mpImpl->mxPointer = rxPointer;
1129 0 : if ( GetWindow() )
1130 0 : GetWindow()->SetPointer( pPointer->GetPointer() );
1131 0 : }
1132 0 : }
1133 :
1134 3278 : void VCLXWindow::setBackground( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1135 : {
1136 3278 : SolarMutexGuard aGuard;
1137 :
1138 3278 : if ( GetWindow() )
1139 : {
1140 3278 : Color aColor( (sal_uInt32)nColor );
1141 3278 : GetWindow()->SetBackground( aColor );
1142 3278 : GetWindow()->SetControlBackground( aColor );
1143 :
1144 3278 : WindowType eWinType = GetWindow()->GetType();
1145 3278 : if ( ( eWinType == WINDOW_WINDOW ) ||
1146 0 : ( eWinType == WINDOW_WORKWINDOW ) ||
1147 : ( eWinType == WINDOW_FLOATINGWINDOW ) )
1148 : {
1149 3278 : GetWindow()->Invalidate();
1150 : }
1151 3278 : }
1152 3278 : }
1153 :
1154 0 : void VCLXWindow::invalidate( sal_Int16 nInvalidateFlags ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1155 : {
1156 0 : SolarMutexGuard aGuard;
1157 :
1158 0 : if ( GetWindow() )
1159 0 : GetWindow()->Invalidate( static_cast<InvalidateFlags>(nInvalidateFlags) );
1160 0 : }
1161 :
1162 0 : void VCLXWindow::invalidateRect( const ::com::sun::star::awt::Rectangle& rRect, sal_Int16 nInvalidateFlags ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1163 : {
1164 0 : SolarMutexGuard aGuard;
1165 :
1166 0 : if ( GetWindow() )
1167 0 : GetWindow()->Invalidate( VCLRectangle(rRect), static_cast<InvalidateFlags>(nInvalidateFlags) );
1168 0 : }
1169 :
1170 :
1171 : // ::com::sun::star::awt::XVclWindowPeer
1172 0 : 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 0 : SolarMutexGuard aGuard;
1175 :
1176 0 : bool bIsChild = false;
1177 0 : vcl::Window* pWindow = GetWindow();
1178 0 : if ( pWindow )
1179 : {
1180 0 : vcl::Window* pPeerWindow = VCLUnoHelper::GetWindow( rxPeer );
1181 0 : bIsChild = pPeerWindow && pWindow->IsChild( pPeerWindow );
1182 : }
1183 :
1184 0 : return bIsChild;
1185 : }
1186 :
1187 4578 : void VCLXWindow::setDesignMode( sal_Bool bOn ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1188 : {
1189 4578 : SolarMutexGuard aGuard;
1190 :
1191 4578 : mpImpl->mbDesignMode = bOn;
1192 4578 : }
1193 :
1194 13708 : sal_Bool VCLXWindow::isDesignMode( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1195 : {
1196 13708 : SolarMutexGuard aGuard;
1197 13708 : return mpImpl->mbDesignMode;
1198 : }
1199 :
1200 0 : void VCLXWindow::enableClipSiblings( sal_Bool bClip ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1201 : {
1202 0 : SolarMutexGuard aGuard;
1203 :
1204 0 : if ( GetWindow() )
1205 0 : GetWindow()->EnableClipSiblings( bClip );
1206 0 : }
1207 :
1208 0 : void VCLXWindow::setForeground( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1209 : {
1210 0 : SolarMutexGuard aGuard;
1211 :
1212 0 : if ( GetWindow() )
1213 : {
1214 0 : Color aColor( (sal_uInt32)nColor );
1215 0 : GetWindow()->SetControlForeground( aColor );
1216 0 : }
1217 0 : }
1218 :
1219 0 : void VCLXWindow::setControlFont( const ::com::sun::star::awt::FontDescriptor& rFont ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1220 : {
1221 0 : SolarMutexGuard aGuard;
1222 :
1223 0 : if ( GetWindow() )
1224 0 : GetWindow()->SetControlFont( VCLUnoHelper::CreateFont( rFont, GetWindow()->GetControlFont() ) );
1225 0 : }
1226 :
1227 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, std::exception)
1228 : {
1229 0 : SolarMutexGuard aGuard;
1230 :
1231 0 : if ( GetWindow() )
1232 : {
1233 0 : const StyleSettings& rStyleSettings = GetWindow()->GetSettings().GetStyleSettings();
1234 :
1235 0 : switch ( nType )
1236 : {
1237 : case ::com::sun::star::awt::Style::FRAME:
1238 : {
1239 0 : Font = VCLUnoHelper::CreateFontDescriptor( rStyleSettings.GetAppFont() );
1240 0 : ForegroundColor = rStyleSettings.GetWindowTextColor().GetColor();
1241 0 : BackgroundColor = rStyleSettings.GetWindowColor().GetColor();
1242 : }
1243 0 : break;
1244 : case ::com::sun::star::awt::Style::DIALOG:
1245 : {
1246 0 : Font = VCLUnoHelper::CreateFontDescriptor( rStyleSettings.GetAppFont() );
1247 0 : ForegroundColor = rStyleSettings.GetDialogTextColor().GetColor();
1248 0 : BackgroundColor = rStyleSettings.GetDialogColor().GetColor();
1249 : }
1250 0 : break;
1251 : default: OSL_FAIL( "VCLWindow::getStyles() - unknown Type" );
1252 : }
1253 :
1254 0 : }
1255 0 : }
1256 :
1257 : namespace toolkit
1258 : {
1259 267 : 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 267 : sal_Int32 nColor = 0;
1263 267 : if ( !( _rValue >>= nColor ) )
1264 262 : nColor = (Application::GetSettings().GetStyleSettings().*pGetter)().GetColor();
1265 :
1266 267 : AllSettings aSettings = _pWindow->GetSettings();
1267 534 : StyleSettings aStyleSettings = aSettings.GetStyleSettings();
1268 :
1269 267 : (aStyleSettings.*pSetter)( Color( nColor ) );
1270 :
1271 267 : aSettings.SetStyleSettings( aStyleSettings );
1272 534 : _pWindow->SetSettings( aSettings, true );
1273 267 : }
1274 : }
1275 :
1276 : // Terminated by BASEPROPERTY_NOTFOUND (or 0)
1277 411 : void VCLXWindow::PushPropertyIds( std::list< sal_uInt16 > &rIds,
1278 : int nFirstId, ...)
1279 : {
1280 : va_list pVarArgs;
1281 411 : va_start( pVarArgs, nFirstId );
1282 :
1283 11905 : for ( int nId = nFirstId; nId != BASEPROPERTY_NOTFOUND;
1284 18056 : nId = va_arg( pVarArgs, int ) )
1285 9850 : rIds.push_back( (sal_uInt16) nId );
1286 :
1287 411 : va_end( pVarArgs );
1288 411 : }
1289 :
1290 411 : void VCLXWindow::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds, bool bWithDefaults )
1291 : {
1292 : // These are common across ~all VCLXWindow derived classes
1293 411 : 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 : 0);
1309 :
1310 : // lovely hack from:
1311 : // void UnoControlModel::ImplRegisterProperty( sal_uInt16 nPropId )
1312 411 : std::list< sal_uInt16 >::const_iterator iter;
1313 3726 : for( iter = rIds.begin(); iter != rIds.end(); ++iter) {
1314 3688 : 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 373 : rIds.push_back( BASEPROPERTY_TEXTCOLOR );
1321 373 : rIds.push_back( BASEPROPERTY_TEXTLINECOLOR );
1322 373 : rIds.push_back( BASEPROPERTY_FONTRELIEF );
1323 373 : rIds.push_back( BASEPROPERTY_FONTEMPHASISMARK );
1324 373 : break;
1325 : }
1326 : }
1327 411 : }
1328 :
1329 0 : void VCLXWindow::GetPropertyIds( std::list< sal_uInt16 >& _out_rIds )
1330 : {
1331 0 : return ImplGetPropertyIds( _out_rIds, mpImpl->mbWithDefaultProps );
1332 : }
1333 :
1334 0 : ::cppu::OInterfaceContainerHelper& VCLXWindow::GetContainerListeners()
1335 : {
1336 0 : return mpImpl->getContainerListeners();
1337 : }
1338 :
1339 19761 : ::cppu::OInterfaceContainerHelper& VCLXWindow::GetTopWindowListeners()
1340 : {
1341 19761 : return mpImpl->getTopWindowListeners();
1342 : }
1343 :
1344 : namespace
1345 : {
1346 891 : void lcl_updateWritingMode( vcl::Window& _rWindow, const sal_Int16 _nWritingMode, const sal_Int16 _nContextWritingMode )
1347 : {
1348 891 : bool bEnableRTL = false;
1349 891 : switch ( _nWritingMode )
1350 : {
1351 2 : case WritingMode2::LR_TB: bEnableRTL = false; break;
1352 0 : 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 677 : switch ( _nContextWritingMode )
1359 : {
1360 404 : case WritingMode2::LR_TB: bEnableRTL = false; break;
1361 84 : case WritingMode2::RL_TB: bEnableRTL = true; break;
1362 : case WritingMode2::CONTEXT:
1363 : {
1364 125 : const vcl::Window* pParent = _rWindow.GetParent();
1365 : OSL_ENSURE( pParent, "lcl_updateWritingMode: cannot determine context's writing mode!" );
1366 125 : if ( pParent )
1367 125 : bEnableRTL = pParent->IsRTLEnabled();
1368 : }
1369 125 : break;
1370 : }
1371 : }
1372 677 : break;
1373 : default:
1374 : OSL_FAIL( "lcl_updateWritingMode: unsupported WritingMode!" );
1375 : } // switch ( nWritingMode )
1376 :
1377 891 : _rWindow.EnableRTL( bEnableRTL );
1378 891 : }
1379 : }
1380 :
1381 28904 : 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 28904 : SolarMutexGuard aGuard;
1386 :
1387 28904 : vcl::Window* pWindow = GetWindow();
1388 28904 : if ( !pWindow )
1389 28904 : return;
1390 :
1391 28904 : bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
1392 :
1393 28904 : WindowType eWinType = pWindow->GetType();
1394 28904 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
1395 28904 : switch ( nPropType )
1396 : {
1397 : case BASEPROPERTY_REFERENCE_DEVICE:
1398 : {
1399 228 : Control* pControl = dynamic_cast< Control* >( pWindow );
1400 : OSL_ENSURE( pControl, "VCLXWindow::setProperty( RefDevice ): need a Control for this!" );
1401 228 : if ( !pControl )
1402 0 : break;
1403 228 : Reference< XDevice > xDevice( Value, UNO_QUERY );
1404 228 : OutputDevice* pDevice = VCLUnoHelper::GetOutputDevice( xDevice );
1405 228 : pControl->SetReferenceDevice( pDevice );
1406 : }
1407 228 : break;
1408 :
1409 : case BASEPROPERTY_CONTEXT_WRITING_MODE:
1410 : {
1411 479 : OSL_VERIFY( Value >>= mpImpl->mnContextWritingMode );
1412 479 : if ( mpImpl->mnWritingMode == WritingMode2::CONTEXT )
1413 406 : lcl_updateWritingMode( *pWindow, mpImpl->mnWritingMode, mpImpl->mnContextWritingMode );
1414 : }
1415 479 : break;
1416 :
1417 : case BASEPROPERTY_WRITING_MODE:
1418 : {
1419 485 : bool bProperType = ( Value >>= mpImpl->mnWritingMode );
1420 : OSL_ENSURE( bProperType, "VCLXWindow::setProperty( 'WritingMode' ): illegal value type!" );
1421 485 : if ( bProperType )
1422 485 : lcl_updateWritingMode( *pWindow, mpImpl->mnWritingMode, mpImpl->mnContextWritingMode );
1423 : }
1424 485 : break;
1425 :
1426 : case BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR:
1427 : {
1428 195 : sal_uInt16 nWheelBehavior( css::awt::MouseWheelBehavior::SCROLL_FOCUS_ONLY );
1429 195 : OSL_VERIFY( Value >>= nWheelBehavior );
1430 :
1431 195 : AllSettings aSettings = pWindow->GetSettings();
1432 390 : MouseSettings aMouseSettings = aSettings.GetMouseSettings();
1433 :
1434 195 : MouseWheelBehaviour nVclBehavior( MouseWheelBehaviour::FocusOnly );
1435 195 : switch ( nWheelBehavior )
1436 : {
1437 0 : case css::awt::MouseWheelBehavior::SCROLL_DISABLED: nVclBehavior = MouseWheelBehaviour::Disable; break;
1438 85 : case css::awt::MouseWheelBehavior::SCROLL_FOCUS_ONLY: nVclBehavior = MouseWheelBehaviour::FocusOnly; break;
1439 35 : case css::awt::MouseWheelBehavior::SCROLL_ALWAYS: nVclBehavior = MouseWheelBehaviour::ALWAYS; break;
1440 : default:
1441 : OSL_FAIL( "VCLXWindow::setProperty( 'MouseWheelBehavior' ): illegal property value!" );
1442 : }
1443 :
1444 195 : aMouseSettings.SetWheelBehavior( nVclBehavior );
1445 195 : aSettings.SetMouseSettings( aMouseSettings );
1446 390 : pWindow->SetSettings( aSettings, true );
1447 : }
1448 195 : break;
1449 :
1450 : case BASEPROPERTY_NATIVE_WIDGET_LOOK:
1451 : {
1452 466 : bool bEnable( true );
1453 466 : OSL_VERIFY( Value >>= bEnable );
1454 466 : pWindow->EnableNativeWidget( bEnable );
1455 : }
1456 466 : break;
1457 :
1458 : case BASEPROPERTY_PLUGINPARENT:
1459 : {
1460 : // set parent handle
1461 0 : SetSystemParent_Impl( Value );
1462 : }
1463 0 : break;
1464 :
1465 : case BASEPROPERTY_ENABLED:
1466 : {
1467 467 : bool b = bool();
1468 467 : if ( Value >>= b )
1469 467 : setEnable( b );
1470 : }
1471 467 : break;
1472 : case BASEPROPERTY_ENABLEVISIBLE:
1473 : {
1474 478 : bool b = false;
1475 478 : if ( Value >>= b )
1476 : {
1477 478 : if( b != mpImpl->isEnableVisible() )
1478 : {
1479 165 : mpImpl->setEnableVisible( b );
1480 165 : pWindow->Show( b && mpImpl->isDirectVisible() );
1481 : }
1482 : }
1483 : }
1484 478 : break;
1485 : case BASEPROPERTY_TEXT:
1486 : case BASEPROPERTY_LABEL:
1487 : case BASEPROPERTY_TITLE:
1488 : {
1489 155 : OUString aText;
1490 155 : if ( Value >>= aText )
1491 : {
1492 155 : switch (eWinType)
1493 : {
1494 : case WINDOW_OKBUTTON:
1495 : case WINDOW_CANCELBUTTON:
1496 : case WINDOW_HELPBUTTON:
1497 : // Standard Button: overwrite only if not empty.
1498 0 : if (!aText.isEmpty())
1499 0 : pWindow->SetText( aText );
1500 0 : break;
1501 :
1502 : default:
1503 155 : pWindow->SetText( aText );
1504 155 : break;
1505 : }
1506 155 : }
1507 : }
1508 155 : break;
1509 : case BASEPROPERTY_ACCESSIBLENAME:
1510 : {
1511 0 : OUString aText;
1512 0 : if ( Value >>= aText )
1513 0 : pWindow->SetAccessibleName( aText );
1514 : }
1515 0 : break;
1516 : case BASEPROPERTY_HELPURL:
1517 : {
1518 416 : OUString aURL;
1519 416 : if ( Value >>= aURL )
1520 : {
1521 416 : INetURLObject aHelpURL( aURL );
1522 416 : if ( aHelpURL.GetProtocol() == INetProtocol::Hid )
1523 0 : pWindow->SetHelpId( OUStringToOString( aHelpURL.GetURLPath(), RTL_TEXTENCODING_UTF8 ) );
1524 : else
1525 416 : pWindow->SetHelpId( OUStringToOString( aURL, RTL_TEXTENCODING_UTF8 ) );
1526 416 : }
1527 : }
1528 416 : break;
1529 : case BASEPROPERTY_HELPTEXT:
1530 : {
1531 504 : OUString aHelpText;
1532 504 : if ( Value >>= aHelpText )
1533 : {
1534 504 : pWindow->SetQuickHelpText( aHelpText );
1535 504 : }
1536 : }
1537 504 : break;
1538 : case BASEPROPERTY_FONTDESCRIPTOR:
1539 : {
1540 1311 : if ( bVoid )
1541 0 : pWindow->SetControlFont( vcl::Font() );
1542 : else
1543 : {
1544 1311 : ::com::sun::star::awt::FontDescriptor aFont;
1545 1311 : if ( Value >>= aFont )
1546 1311 : pWindow->SetControlFont( VCLUnoHelper::CreateFont( aFont, pWindow->GetControlFont() ) );
1547 : }
1548 : }
1549 1311 : break;
1550 : case BASEPROPERTY_FONTRELIEF:
1551 : {
1552 400 : sal_Int16 n = sal_Int16();
1553 400 : if ( Value >>= n )
1554 : {
1555 400 : vcl::Font aFont = pWindow->GetControlFont();
1556 400 : aFont.SetRelief( (FontRelief)n );
1557 400 : pWindow->SetControlFont( aFont );
1558 : }
1559 : }
1560 400 : break;
1561 : case BASEPROPERTY_FONTEMPHASISMARK:
1562 : {
1563 400 : sal_Int16 n = sal_Int16();
1564 400 : if ( Value >>= n )
1565 : {
1566 400 : vcl::Font aFont = pWindow->GetControlFont();
1567 400 : aFont.SetEmphasisMark( n );
1568 400 : pWindow->SetControlFont( aFont );
1569 : }
1570 : }
1571 400 : break;
1572 : case BASEPROPERTY_BACKGROUNDCOLOR:
1573 320 : if ( bVoid )
1574 : {
1575 281 : 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 2 : Color aColor = pWindow->GetSettings().GetStyleSettings().GetDialogColor();
1587 2 : pWindow->SetBackground( aColor );
1588 2 : pWindow->SetControlBackground( aColor );
1589 2 : 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 36 : pWindow->SetBackground();
1600 36 : pWindow->SetControlBackground();
1601 36 : pWindow->SetPaintTransparent( true );
1602 36 : 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 243 : if ( pWindow->IsCompoundControl() )
1612 93 : pWindow->SetBackground();
1613 243 : pWindow->SetControlBackground();
1614 243 : break;
1615 : }
1616 : }
1617 : }
1618 : else
1619 : {
1620 39 : sal_Int32 nColor = 0;
1621 39 : if ( Value >>= nColor )
1622 : {
1623 39 : Color aColor( nColor );
1624 39 : pWindow->SetControlBackground( aColor );
1625 39 : pWindow->SetBackground( aColor );
1626 39 : 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 8 : pWindow->SetPaintTransparent( false );
1635 : default: ;
1636 : }
1637 39 : pWindow->Invalidate(); // Invalidate if control does not respond to it
1638 : }
1639 : }
1640 320 : break;
1641 : case BASEPROPERTY_TEXTCOLOR:
1642 355 : if ( bVoid )
1643 : {
1644 317 : pWindow->SetControlForeground();
1645 : }
1646 : else
1647 : {
1648 38 : sal_Int32 nColor = 0;
1649 38 : if ( Value >>= nColor )
1650 : {
1651 38 : Color aColor( nColor );
1652 38 : pWindow->SetTextColor( aColor );
1653 38 : pWindow->SetControlForeground( aColor );
1654 : }
1655 : }
1656 355 : break;
1657 : case BASEPROPERTY_TEXTLINECOLOR:
1658 337 : if ( bVoid )
1659 : {
1660 337 : pWindow->SetTextLineColor();
1661 : }
1662 : else
1663 : {
1664 0 : sal_Int32 nColor = 0;
1665 0 : if ( Value >>= nColor )
1666 : {
1667 0 : Color aColor( nColor );
1668 0 : pWindow->SetTextLineColor( aColor );
1669 : }
1670 : }
1671 337 : break;
1672 : case BASEPROPERTY_FILLCOLOR:
1673 1 : if ( bVoid )
1674 1 : pWindow->SetFillColor();
1675 : else
1676 : {
1677 0 : sal_Int32 nColor = 0;
1678 0 : if ( Value >>= nColor )
1679 : {
1680 0 : Color aColor( nColor );
1681 0 : pWindow->SetFillColor( aColor );
1682 : }
1683 : }
1684 1 : break;
1685 : case BASEPROPERTY_LINECOLOR:
1686 0 : if ( bVoid )
1687 0 : pWindow->SetLineColor();
1688 : else
1689 : {
1690 0 : sal_Int32 nColor = 0;
1691 0 : if ( Value >>= nColor )
1692 : {
1693 0 : Color aColor( nColor );
1694 0 : pWindow->SetLineColor( aColor );
1695 : }
1696 : }
1697 0 : break;
1698 : case BASEPROPERTY_BORDER:
1699 : {
1700 283 : WinBits nStyle = pWindow->GetStyle();
1701 283 : sal_uInt16 nTmp = 0;
1702 283 : Value >>= nTmp;
1703 283 : WindowBorderStyle nBorder = static_cast<WindowBorderStyle>(nTmp);
1704 283 : if ( !bool(nBorder) )
1705 : {
1706 12 : pWindow->SetStyle( nStyle & ~WB_BORDER );
1707 : }
1708 : else
1709 : {
1710 271 : pWindow->SetStyle( nStyle | WB_BORDER );
1711 271 : pWindow->SetBorderStyle( nBorder );
1712 : }
1713 : }
1714 283 : break;
1715 : case BASEPROPERTY_TABSTOP:
1716 : {
1717 375 : WinBits nStyle = pWindow->GetStyle() & ~WB_TABSTOP;
1718 375 : if ( !bVoid )
1719 : {
1720 6 : bool bTab = false;
1721 6 : Value >>= bTab;
1722 6 : if ( bTab )
1723 6 : nStyle |= WB_TABSTOP;
1724 : else
1725 0 : nStyle |= WB_NOTABSTOP;
1726 : }
1727 375 : pWindow->SetStyle( nStyle );
1728 : }
1729 375 : break;
1730 : case BASEPROPERTY_VERTICALALIGN:
1731 : {
1732 275 : VerticalAlignment eAlign = VerticalAlignment_MAKE_FIXED_SIZE;
1733 275 : WinBits nStyle = pWindow->GetStyle();
1734 275 : nStyle &= ~(WB_TOP|WB_VCENTER|WB_BOTTOM);
1735 275 : if ( !bVoid )
1736 31 : Value >>= eAlign;
1737 275 : switch ( eAlign )
1738 : {
1739 : case VerticalAlignment_TOP:
1740 0 : nStyle |= WB_TOP;
1741 0 : break;
1742 : case VerticalAlignment_MIDDLE:
1743 31 : nStyle |= WB_VCENTER;
1744 31 : break;
1745 : case VerticalAlignment_BOTTOM:
1746 0 : nStyle |= WB_BOTTOM;
1747 0 : break;
1748 : default: ; // for warning free code, MAKE_FIXED_SIZE
1749 : }
1750 275 : pWindow->SetStyle( nStyle );
1751 : }
1752 275 : break;
1753 : case BASEPROPERTY_ALIGN:
1754 : {
1755 324 : sal_Int16 nAlign = PROPERTY_ALIGN_LEFT;
1756 324 : 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 79 : 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 209 : WinBits nStyle = pWindow->GetStyle();
1774 209 : nStyle &= ~(WB_LEFT|WB_CENTER|WB_RIGHT);
1775 209 : if ( !bVoid )
1776 209 : Value >>= nAlign;
1777 209 : if ( nAlign == PROPERTY_ALIGN_LEFT )
1778 133 : nStyle |= WB_LEFT;
1779 76 : else if ( nAlign == PROPERTY_ALIGN_CENTER )
1780 76 : nStyle |= WB_CENTER;
1781 : else
1782 0 : nStyle |= WB_RIGHT;
1783 209 : pWindow->SetStyle( nStyle );
1784 : }
1785 209 : break;
1786 : }
1787 : }
1788 324 : break;
1789 : case BASEPROPERTY_MULTILINE:
1790 : {
1791 184 : if ( ( eWinType == WINDOW_FIXEDTEXT )
1792 182 : || ( eWinType == WINDOW_CHECKBOX )
1793 161 : || ( eWinType == WINDOW_RADIOBUTTON )
1794 140 : || ( eWinType == WINDOW_BUTTON )
1795 140 : || ( eWinType == WINDOW_PUSHBUTTON )
1796 89 : || ( eWinType == WINDOW_OKBUTTON )
1797 89 : || ( eWinType == WINDOW_CANCELBUTTON )
1798 89 : || ( eWinType == WINDOW_HELPBUTTON )
1799 : )
1800 : {
1801 95 : WinBits nStyle = pWindow->GetStyle();
1802 95 : bool bMulti = false;
1803 95 : Value >>= bMulti;
1804 95 : if ( bMulti )
1805 21 : nStyle |= WB_WORDBREAK;
1806 : else
1807 74 : nStyle &= ~WB_WORDBREAK;
1808 95 : pWindow->SetStyle( nStyle );
1809 : }
1810 : }
1811 184 : break;
1812 : case BASEPROPERTY_ORIENTATION:
1813 : {
1814 0 : switch ( eWinType )
1815 : {
1816 : case WINDOW_FIXEDLINE:
1817 : {
1818 0 : sal_Int32 nOrientation = 0;
1819 0 : if ( Value >>= nOrientation )
1820 : {
1821 0 : WinBits nStyle = pWindow->GetStyle();
1822 0 : nStyle &= ~(WB_HORZ|WB_VERT);
1823 0 : if ( nOrientation == 0 )
1824 0 : nStyle |= WB_HORZ;
1825 : else
1826 0 : nStyle |= WB_VERT;
1827 :
1828 0 : pWindow->SetStyle( nStyle );
1829 : }
1830 : }
1831 0 : break;
1832 : }
1833 : }
1834 0 : break;
1835 : case BASEPROPERTY_AUTOMNEMONICS:
1836 : {
1837 0 : bool bAutoMnemonics = false;
1838 0 : Value >>= bAutoMnemonics;
1839 0 : AllSettings aSettings = pWindow->GetSettings();
1840 0 : StyleSettings aStyleSettings = aSettings.GetStyleSettings();
1841 0 : if ( aStyleSettings.GetAutoMnemonic() != bAutoMnemonics )
1842 : {
1843 0 : aStyleSettings.SetAutoMnemonic( bAutoMnemonics );
1844 0 : aSettings.SetStyleSettings( aStyleSettings );
1845 0 : pWindow->SetSettings( aSettings );
1846 0 : }
1847 : }
1848 0 : break;
1849 : case BASEPROPERTY_MOUSETRANSPARENT:
1850 : {
1851 0 : bool bMouseTransparent = false;
1852 0 : Value >>= bMouseTransparent;
1853 0 : pWindow->SetMouseTransparent( bMouseTransparent );
1854 : }
1855 0 : break;
1856 : case BASEPROPERTY_PAINTTRANSPARENT:
1857 : {
1858 1 : bool bPaintTransparent = false;
1859 1 : Value >>= bPaintTransparent;
1860 1 : pWindow->SetPaintTransparent( bPaintTransparent );
1861 : // pWindow->SetBackground();
1862 : }
1863 1 : break;
1864 :
1865 : case BASEPROPERTY_REPEAT:
1866 : {
1867 171 : bool bRepeat( false );
1868 171 : Value >>= bRepeat;
1869 :
1870 171 : WinBits nStyle = pWindow->GetStyle();
1871 171 : if ( bRepeat )
1872 43 : nStyle |= WB_REPEAT;
1873 : else
1874 128 : nStyle &= ~WB_REPEAT;
1875 171 : pWindow->SetStyle( nStyle );
1876 : }
1877 171 : break;
1878 :
1879 : case BASEPROPERTY_REPEAT_DELAY:
1880 : {
1881 198 : sal_Int32 nRepeatDelay = 0;
1882 198 : if ( Value >>= nRepeatDelay )
1883 : {
1884 198 : AllSettings aSettings = pWindow->GetSettings();
1885 396 : MouseSettings aMouseSettings = aSettings.GetMouseSettings();
1886 :
1887 198 : aMouseSettings.SetButtonRepeat( nRepeatDelay );
1888 198 : aSettings.SetMouseSettings( aMouseSettings );
1889 :
1890 396 : pWindow->SetSettings( aSettings, true );
1891 : }
1892 : }
1893 198 : break;
1894 :
1895 : case BASEPROPERTY_SYMBOL_COLOR:
1896 2 : ::toolkit::setColorSettings( pWindow, Value, &StyleSettings::SetButtonTextColor, &StyleSettings::GetButtonTextColor );
1897 2 : break;
1898 :
1899 : case BASEPROPERTY_BORDERCOLOR:
1900 265 : ::toolkit::setColorSettings( pWindow, Value, &StyleSettings::SetMonoColor, &StyleSettings::GetMonoColor);
1901 265 : break;
1902 : case BASEPROPERTY_DEFAULTCONTROL:
1903 : {
1904 496 : OUString aName;
1905 496 : Value >>= aName;
1906 496 : break;
1907 : }
1908 28904 : }
1909 : }
1910 :
1911 52 : ::com::sun::star::uno::Any VCLXWindow::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1912 : {
1913 52 : SolarMutexGuard aGuard;
1914 :
1915 52 : ::com::sun::star::uno::Any aProp;
1916 52 : if ( GetWindow() )
1917 : {
1918 52 : WindowType eWinType = GetWindow()->GetType();
1919 52 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
1920 52 : switch ( nPropType )
1921 : {
1922 : case BASEPROPERTY_REFERENCE_DEVICE:
1923 : {
1924 0 : VclPtr<Control> pControl = GetAsDynamic<Control >();
1925 : OSL_ENSURE( pControl, "VCLXWindow::setProperty( RefDevice ): need a Control for this!" );
1926 0 : if ( !pControl )
1927 0 : break;
1928 :
1929 0 : VCLXDevice* pDevice = new VCLXDevice;
1930 0 : pDevice->SetOutputDevice( pControl->GetReferenceDevice() );
1931 0 : aProp <<= Reference< XDevice >( pDevice );
1932 : }
1933 0 : break;
1934 :
1935 : case BASEPROPERTY_CONTEXT_WRITING_MODE:
1936 0 : aProp <<= mpImpl->mnContextWritingMode;
1937 0 : break;
1938 :
1939 : case BASEPROPERTY_WRITING_MODE:
1940 0 : aProp <<= mpImpl->mnWritingMode;
1941 0 : break;
1942 :
1943 : case BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR:
1944 : {
1945 0 : MouseWheelBehaviour nVclBehavior = GetWindow()->GetSettings().GetMouseSettings().GetWheelBehavior();
1946 0 : sal_uInt16 nBehavior = css::awt::MouseWheelBehavior::SCROLL_FOCUS_ONLY;
1947 0 : switch ( nVclBehavior )
1948 : {
1949 0 : case MouseWheelBehaviour::Disable: nBehavior = css::awt::MouseWheelBehavior::SCROLL_DISABLED; break;
1950 0 : case MouseWheelBehaviour::FocusOnly: nBehavior = css::awt::MouseWheelBehavior::SCROLL_FOCUS_ONLY; break;
1951 0 : case MouseWheelBehaviour::ALWAYS: nBehavior = css::awt::MouseWheelBehavior::SCROLL_ALWAYS; break;
1952 : default:
1953 : OSL_FAIL( "VCLXWindow::getProperty( 'MouseWheelBehavior' ): illegal VCL value!" );
1954 : }
1955 0 : aProp <<= nBehavior;
1956 : }
1957 0 : break;
1958 :
1959 : case BASEPROPERTY_NATIVE_WIDGET_LOOK:
1960 0 : aProp <<= GetWindow()->IsNativeWidgetEnabled();
1961 0 : break;
1962 :
1963 : case BASEPROPERTY_ENABLED:
1964 0 : aProp <<= GetWindow()->IsEnabled();
1965 0 : break;
1966 :
1967 : case BASEPROPERTY_ENABLEVISIBLE:
1968 0 : aProp <<= mpImpl->isEnableVisible();
1969 0 : break;
1970 :
1971 : case BASEPROPERTY_HIGHCONTRASTMODE:
1972 0 : aProp <<= GetWindow()->GetSettings().GetStyleSettings().GetHighContrastMode();
1973 0 : break;
1974 :
1975 : case BASEPROPERTY_TEXT:
1976 : case BASEPROPERTY_LABEL:
1977 : case BASEPROPERTY_TITLE:
1978 : {
1979 52 : OUString aText = GetWindow()->GetText();
1980 52 : aProp <<= aText;
1981 : }
1982 52 : break;
1983 : case BASEPROPERTY_ACCESSIBLENAME:
1984 : {
1985 0 : OUString aText = GetWindow()->GetAccessibleName();
1986 0 : aProp <<= aText;
1987 : }
1988 0 : break;
1989 : case BASEPROPERTY_HELPTEXT:
1990 : {
1991 0 : OUString aText = GetWindow()->GetQuickHelpText();
1992 0 : aProp <<= aText;
1993 : }
1994 0 : break;
1995 : case BASEPROPERTY_HELPURL:
1996 : {
1997 0 : OUString aHelpId( OStringToOUString( GetWindow()->GetHelpId(), RTL_TEXTENCODING_UTF8 ) );
1998 0 : aProp <<= OUString( aHelpId );
1999 : }
2000 0 : break;
2001 : case BASEPROPERTY_FONTDESCRIPTOR:
2002 : {
2003 0 : vcl::Font aFont = GetWindow()->GetControlFont();
2004 0 : ::com::sun::star::awt::FontDescriptor aFD = VCLUnoHelper::CreateFontDescriptor( aFont );
2005 0 : aProp <<= aFD;
2006 : }
2007 0 : break;
2008 : case BASEPROPERTY_BACKGROUNDCOLOR:
2009 0 : aProp <<= (sal_Int32) GetWindow()->GetControlBackground().GetColor();
2010 0 : break;
2011 : case BASEPROPERTY_DISPLAYBACKGROUNDCOLOR:
2012 0 : aProp <<= (sal_Int32) GetWindow()->GetDisplayBackground().GetColor().GetColor();
2013 0 : break;
2014 : case BASEPROPERTY_FONTRELIEF:
2015 0 : aProp <<= (sal_Int16) GetWindow()->GetControlFont().GetRelief();
2016 0 : break;
2017 : case BASEPROPERTY_FONTEMPHASISMARK:
2018 0 : aProp <<= (sal_Int16) GetWindow()->GetControlFont().GetEmphasisMark();
2019 0 : break;
2020 : case BASEPROPERTY_TEXTCOLOR:
2021 0 : aProp <<= (sal_Int32) GetWindow()->GetControlForeground().GetColor();
2022 0 : break;
2023 : case BASEPROPERTY_TEXTLINECOLOR:
2024 0 : aProp <<= (sal_Int32) GetWindow()->GetTextLineColor().GetColor();
2025 0 : break;
2026 : case BASEPROPERTY_FILLCOLOR:
2027 0 : aProp <<= (sal_Int32) GetWindow()->GetFillColor().GetColor();
2028 0 : break;
2029 : case BASEPROPERTY_LINECOLOR:
2030 0 : aProp <<= (sal_Int32) GetWindow()->GetLineColor().GetColor();
2031 0 : break;
2032 : case BASEPROPERTY_BORDER:
2033 : {
2034 0 : WindowBorderStyle nBorder = WindowBorderStyle::NONE;
2035 0 : if ( GetWindow()->GetStyle() & WB_BORDER )
2036 0 : nBorder = GetWindow()->GetBorderStyle();
2037 0 : aProp <<= static_cast<sal_uInt16>(nBorder);
2038 : }
2039 0 : break;
2040 : case BASEPROPERTY_TABSTOP:
2041 0 : aProp <<= ( GetWindow()->GetStyle() & WB_TABSTOP ) != 0;
2042 0 : break;
2043 : case BASEPROPERTY_VERTICALALIGN:
2044 : {
2045 0 : WinBits nStyle = GetWindow()->GetStyle();
2046 0 : if ( nStyle & WB_TOP )
2047 0 : aProp <<= VerticalAlignment_TOP;
2048 0 : else if ( nStyle & WB_VCENTER )
2049 0 : aProp <<= VerticalAlignment_MIDDLE;
2050 0 : else if ( nStyle & WB_BOTTOM )
2051 0 : aProp <<= VerticalAlignment_BOTTOM;
2052 : }
2053 0 : break;
2054 : case BASEPROPERTY_ALIGN:
2055 : {
2056 0 : 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 0 : WinBits nStyle = GetWindow()->GetStyle();
2072 0 : if ( nStyle & WB_LEFT )
2073 0 : aProp <<= (sal_Int16) PROPERTY_ALIGN_LEFT;
2074 0 : else if ( nStyle & WB_CENTER )
2075 0 : aProp <<= (sal_Int16) PROPERTY_ALIGN_CENTER;
2076 0 : else if ( nStyle & WB_RIGHT )
2077 0 : aProp <<= (sal_Int16) PROPERTY_ALIGN_RIGHT;
2078 : }
2079 0 : break;
2080 : }
2081 : }
2082 0 : break;
2083 : case BASEPROPERTY_MULTILINE:
2084 : {
2085 0 : if ( ( eWinType == WINDOW_FIXEDTEXT )
2086 0 : || ( eWinType == WINDOW_CHECKBOX )
2087 0 : || ( eWinType == WINDOW_RADIOBUTTON )
2088 0 : || ( eWinType == WINDOW_BUTTON )
2089 0 : || ( eWinType == WINDOW_PUSHBUTTON )
2090 0 : || ( eWinType == WINDOW_OKBUTTON )
2091 0 : || ( eWinType == WINDOW_CANCELBUTTON )
2092 0 : || ( eWinType == WINDOW_HELPBUTTON )
2093 : )
2094 0 : aProp <<= ( GetWindow()->GetStyle() & WB_WORDBREAK ) != 0;
2095 : }
2096 0 : break;
2097 : case BASEPROPERTY_AUTOMNEMONICS:
2098 : {
2099 0 : bool bAutoMnemonics = GetWindow()->GetSettings().GetStyleSettings().GetAutoMnemonic();
2100 0 : aProp <<= bAutoMnemonics;
2101 : }
2102 0 : break;
2103 : case BASEPROPERTY_MOUSETRANSPARENT:
2104 : {
2105 0 : bool bMouseTransparent = GetWindow()->IsMouseTransparent();
2106 0 : aProp <<= bMouseTransparent;
2107 : }
2108 0 : break;
2109 : case BASEPROPERTY_PAINTTRANSPARENT:
2110 : {
2111 0 : bool bPaintTransparent = GetWindow()->IsPaintTransparent();
2112 0 : aProp <<= bPaintTransparent;
2113 : }
2114 0 : break;
2115 :
2116 : case BASEPROPERTY_REPEAT:
2117 0 : aProp <<= ( 0 != ( GetWindow()->GetStyle() & WB_REPEAT ) );
2118 0 : break;
2119 :
2120 : case BASEPROPERTY_REPEAT_DELAY:
2121 : {
2122 0 : sal_Int32 nButtonRepeat = GetWindow()->GetSettings().GetMouseSettings().GetButtonRepeat();
2123 0 : aProp <<= (sal_Int32)nButtonRepeat;
2124 : }
2125 0 : break;
2126 :
2127 : case BASEPROPERTY_SYMBOL_COLOR:
2128 0 : aProp <<= (sal_Int32)GetWindow()->GetSettings().GetStyleSettings().GetButtonTextColor().GetColor();
2129 0 : break;
2130 :
2131 : case BASEPROPERTY_BORDERCOLOR:
2132 0 : aProp <<= (sal_Int32)GetWindow()->GetSettings().GetStyleSettings().GetMonoColor().GetColor();
2133 0 : break;
2134 : }
2135 : }
2136 52 : return aProp;
2137 : }
2138 :
2139 :
2140 : // ::com::sun::star::awt::XLayoutConstrains
2141 0 : ::com::sun::star::awt::Size VCLXWindow::getMinimumSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2142 : {
2143 0 : 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 0 : Size aSz;
2149 0 : if ( GetWindow() )
2150 : {
2151 0 : WindowType nWinType = GetWindow()->GetType();
2152 0 : switch ( nWinType )
2153 : {
2154 : case WINDOW_CONTROL:
2155 0 : aSz.Width() = GetWindow()->GetTextWidth( GetWindow()->GetText() )+2*12;
2156 0 : aSz.Height() = GetWindow()->GetTextHeight()+2*6;
2157 0 : 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 0 : aSz.Width() = GetWindow()->GetTextWidth( GetWindow()->GetText() )+2*2;
2167 0 : aSz.Height() = GetWindow()->GetTextHeight()+2*2;
2168 0 : break;
2169 : case WINDOW_SCROLLBARBOX:
2170 0 : return VCLXScrollBar::implGetMinimumSize( GetWindow() );
2171 : default:
2172 0 : aSz = GetWindow()->get_preferred_size();
2173 : }
2174 : }
2175 :
2176 0 : return ::com::sun::star::awt::Size( aSz.Width(), aSz.Height() );
2177 : }
2178 :
2179 0 : ::com::sun::star::awt::Size VCLXWindow::getPreferredSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2180 : {
2181 0 : return getMinimumSize();
2182 : }
2183 :
2184 0 : ::com::sun::star::awt::Size VCLXWindow::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2185 : {
2186 0 : SolarMutexGuard aGuard;
2187 :
2188 0 : ::com::sun::star::awt::Size aNewSize( rNewSize );
2189 0 : ::com::sun::star::awt::Size aMinSize = getMinimumSize();
2190 :
2191 0 : if ( aNewSize.Width < aMinSize.Width )
2192 0 : aNewSize.Width = aMinSize.Width;
2193 0 : if ( aNewSize.Height < aMinSize.Height )
2194 0 : aNewSize.Height = aMinSize.Height;
2195 :
2196 0 : return aNewSize;
2197 : }
2198 :
2199 :
2200 : // ::com::sun::star::awt::XView
2201 10075 : 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 10075 : SolarMutexGuard aGuard;
2204 :
2205 10075 : if ( VCLUnoHelper::GetOutputDevice( rxDevice ) )
2206 4852 : mpImpl->mxViewGraphics = rxDevice;
2207 : else
2208 5223 : mpImpl->mxViewGraphics = NULL;
2209 :
2210 10075 : return mpImpl->mxViewGraphics.is();
2211 : }
2212 :
2213 157 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XGraphics > VCLXWindow::getGraphics( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2214 : {
2215 157 : SolarMutexGuard aGuard;
2216 :
2217 157 : return mpImpl->mxViewGraphics;
2218 : }
2219 :
2220 0 : ::com::sun::star::awt::Size VCLXWindow::getSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2221 : {
2222 0 : SolarMutexGuard aGuard;
2223 :
2224 0 : Size aSz;
2225 0 : if ( GetWindow() )
2226 0 : aSz = GetWindow()->GetSizePixel();
2227 0 : return ::com::sun::star::awt::Size( aSz.Width(), aSz.Height() );
2228 : }
2229 :
2230 4462 : void VCLXWindow::draw( sal_Int32 nX, sal_Int32 nY ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2231 : {
2232 4462 : SolarMutexGuard aGuard;
2233 :
2234 4462 : vcl::Window* pWindow = GetWindow();
2235 4462 : if ( !pWindow )
2236 0 : return;
2237 :
2238 4462 : if ( isDesignMode() || mpImpl->isEnableVisible() )
2239 : {
2240 4462 : OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( mpImpl->mxViewGraphics );
2241 4462 : if (!pDev)
2242 0 : pDev = pWindow->GetParent();
2243 4462 : TabPage* pTabPage = dynamic_cast< TabPage* >( pWindow );
2244 4462 : if ( pTabPage )
2245 : {
2246 0 : Point aPos( nX, nY );
2247 0 : Size aSize = pWindow->GetSizePixel();
2248 :
2249 0 : aPos = pDev->PixelToLogic( aPos );
2250 0 : aSize = pDev->PixelToLogic( aSize );
2251 :
2252 0 : pTabPage->Draw( pDev, aPos, aSize, DrawFlags::NONE );
2253 0 : return;
2254 : }
2255 :
2256 4462 : Point aPos( nX, nY );
2257 :
2258 4462 : 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 0 : if ( !mpImpl->getDrawingOntoParent_ref() )
2266 : {
2267 0 : ::comphelper::FlagGuard aDrawingflagGuard( mpImpl->getDrawingOntoParent_ref() );
2268 :
2269 0 : bool bWasVisible = pWindow->IsVisible();
2270 0 : Point aOldPos( pWindow->GetPosPixel() );
2271 :
2272 0 : if ( bWasVisible && aOldPos == aPos )
2273 : {
2274 0 : pWindow->Update();
2275 0 : return;
2276 : }
2277 :
2278 0 : 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 0 : if( pWindow->GetParent() )
2284 0 : pWindow->GetParent()->Update();
2285 :
2286 0 : pWindow->Show();
2287 0 : pWindow->Update();
2288 0 : pWindow->SetParentUpdateMode( false );
2289 0 : pWindow->Hide();
2290 0 : pWindow->SetParentUpdateMode( true );
2291 :
2292 0 : pWindow->SetPosPixel( aOldPos );
2293 0 : if ( bWasVisible )
2294 0 : pWindow->Show( true );
2295 : }
2296 : }
2297 4462 : else if ( pDev )
2298 : {
2299 4462 : Size aSz = pWindow->GetSizePixel();
2300 4462 : aSz = pDev->PixelToLogic( aSz );
2301 4462 : Point aP = pDev->PixelToLogic( aPos );
2302 :
2303 4462 : vcl::PDFExtOutDevData* pPDFExport = dynamic_cast<vcl::PDFExtOutDevData*>(pDev->GetExtOutDevData());
2304 4462 : bool bDrawSimple = ( pDev->GetOutDevType() == OUTDEV_PRINTER )
2305 4462 : || ( pDev->GetOutDevViewType() == OUTDEV_VIEWTYPE_PRINTPREVIEW )
2306 8924 : || ( pPDFExport != NULL );
2307 4462 : if ( bDrawSimple )
2308 : {
2309 0 : pWindow->Draw( pDev, aP, aSz, DrawFlags::NoControls );
2310 : }
2311 : else
2312 : {
2313 4462 : bool bOldNW =pWindow->IsNativeWidgetEnabled();
2314 4462 : if( bOldNW )
2315 1526 : pWindow->EnableNativeWidget(false);
2316 4462 : pWindow->PaintToDevice( pDev, aP, aSz );
2317 4462 : if( bOldNW )
2318 1526 : pWindow->EnableNativeWidget(true);
2319 : }
2320 : }
2321 4462 : }
2322 : }
2323 :
2324 26602 : void VCLXWindow::setZoom( float fZoomX, float /*fZoomY*/ ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2325 : {
2326 26602 : SolarMutexGuard aGuard;
2327 :
2328 26602 : 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 26602 : double nZoom( fZoomX );
2334 26602 : Fraction aZoom(::rtl::math::round(nZoom, 4));
2335 26602 : aZoom.ReduceInaccurate(10); // to avoid runovers and BigInt mapping
2336 26602 : GetWindow()->SetZoom(aZoom);
2337 26602 : }
2338 26602 : }
2339 :
2340 : // ::com::sun::star::lang::XEventListener
2341 360 : void SAL_CALL VCLXWindow::disposing( const ::com::sun::star::lang::EventObject& _rSource ) throw (::com::sun::star::uno::RuntimeException, std::exception)
2342 : {
2343 360 : SolarMutexGuard aGuard;
2344 :
2345 : // check if it comes from our AccessibleContext
2346 720 : uno::Reference< uno::XInterface > aAC( mpImpl->mxAccessibleContext, uno::UNO_QUERY );
2347 720 : uno::Reference< uno::XInterface > xSource( _rSource.Source, uno::UNO_QUERY );
2348 :
2349 360 : if ( aAC.get() == xSource.get() )
2350 : { // yep, it does
2351 248 : mpImpl->mxAccessibleContext = uno::Reference< accessibility::XAccessibleContext >();
2352 360 : }
2353 360 : }
2354 :
2355 : // ::com::sun::star::accessibility::XAccessible
2356 1129 : ::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 1129 : SolarMutexGuard aGuard;
2361 :
2362 : // already disposed
2363 1129 : if( ! mpImpl )
2364 0 : return uno::Reference< accessibility::XAccessibleContext >();
2365 :
2366 1129 : if ( !mpImpl->mxAccessibleContext.is() && GetWindow() )
2367 : {
2368 248 : 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 248 : uno::Reference< lang::XComponent > xComp( mpImpl->mxAccessibleContext, uno::UNO_QUERY );
2374 248 : if ( xComp.is() )
2375 248 : xComp->addEventListener( this );
2376 : }
2377 :
2378 1129 : return mpImpl->mxAccessibleContext;
2379 : }
2380 :
2381 : // ::com::sun::star::awt::XDockable
2382 9522 : 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 9522 : SolarMutexGuard aGuard;
2385 :
2386 9522 : if ( xListener.is() )
2387 9522 : mpImpl->getDockableWindowListeners().addInterface( xListener );
2388 :
2389 9522 : }
2390 :
2391 1 : 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 1 : SolarMutexGuard aGuard;
2394 :
2395 1 : mpImpl->getDockableWindowListeners().removeInterface( xListener );
2396 1 : }
2397 :
2398 9522 : void SAL_CALL VCLXWindow::enableDocking( sal_Bool bEnable ) throw (::com::sun::star::uno::RuntimeException, std::exception)
2399 : {
2400 9522 : SolarMutexGuard aGuard;
2401 :
2402 9522 : vcl::Window* pWindow = GetWindow();
2403 9522 : if ( pWindow )
2404 9522 : pWindow->EnableDocking( bEnable );
2405 9522 : }
2406 :
2407 17721 : sal_Bool SAL_CALL VCLXWindow::isFloating( ) throw (::com::sun::star::uno::RuntimeException, std::exception)
2408 : {
2409 17721 : SolarMutexGuard aGuard;
2410 :
2411 17721 : vcl::Window* pWindow = GetWindow();
2412 17721 : if( pWindow )
2413 17721 : return vcl::Window::GetDockingManager()->IsFloating( pWindow );
2414 : else
2415 0 : return sal_False;
2416 : }
2417 :
2418 9522 : void SAL_CALL VCLXWindow::setFloatingMode( sal_Bool bFloating ) throw (::com::sun::star::uno::RuntimeException, std::exception)
2419 : {
2420 9522 : SolarMutexGuard aGuard;
2421 :
2422 9522 : vcl::Window* pWindow = GetWindow();
2423 9522 : if( pWindow )
2424 9522 : vcl::Window::GetDockingManager()->SetFloatingMode( pWindow, bFloating );
2425 9522 : }
2426 :
2427 0 : sal_Bool SAL_CALL VCLXWindow::isLocked( ) throw (::com::sun::star::uno::RuntimeException, std::exception)
2428 : {
2429 0 : SolarMutexGuard aGuard;
2430 :
2431 0 : vcl::Window* pWindow = GetWindow();
2432 0 : if( pWindow )
2433 0 : return vcl::Window::GetDockingManager()->IsLocked( pWindow );
2434 : else
2435 0 : return sal_False;
2436 : }
2437 :
2438 0 : void SAL_CALL VCLXWindow::lock( ) throw (::com::sun::star::uno::RuntimeException, std::exception)
2439 : {
2440 0 : SolarMutexGuard aGuard;
2441 :
2442 0 : vcl::Window* pWindow = GetWindow();
2443 0 : if( pWindow && !vcl::Window::GetDockingManager()->IsFloating( pWindow ) )
2444 0 : vcl::Window::GetDockingManager()->Lock( pWindow );
2445 0 : }
2446 :
2447 0 : void SAL_CALL VCLXWindow::unlock( ) throw (::com::sun::star::uno::RuntimeException, std::exception)
2448 : {
2449 0 : SolarMutexGuard aGuard;
2450 :
2451 0 : vcl::Window* pWindow = GetWindow();
2452 0 : if( pWindow && !vcl::Window::GetDockingManager()->IsFloating( pWindow ) )
2453 0 : vcl::Window::GetDockingManager()->Unlock( pWindow );
2454 0 : }
2455 0 : 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 0 : SolarMutexGuard aGuard;
2459 :
2460 0 : }
2461 :
2462 0 : 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 0 : SolarMutexGuard aGuard;
2466 0 : return sal_False;
2467 : }
2468 :
2469 :
2470 : // ::com::sun::star::awt::XWindow2
2471 :
2472 9522 : void SAL_CALL VCLXWindow::setOutputSize( const ::com::sun::star::awt::Size& aSize ) throw (::com::sun::star::uno::RuntimeException, std::exception)
2473 : {
2474 9522 : SolarMutexGuard aGuard;
2475 : vcl::Window *pWindow;
2476 9522 : if( (pWindow = GetWindow()) != NULL )
2477 : {
2478 9522 : DockingWindow *pDockingWindow = dynamic_cast< DockingWindow* >(pWindow);
2479 9522 : if( pDockingWindow )
2480 9522 : pDockingWindow->SetOutputSizePixel( VCLSize( aSize ) );
2481 : else
2482 0 : pWindow->SetOutputSizePixel( VCLSize( aSize ) );
2483 9522 : }
2484 9522 : }
2485 :
2486 0 : ::com::sun::star::awt::Size SAL_CALL VCLXWindow::getOutputSize( ) throw (::com::sun::star::uno::RuntimeException, std::exception)
2487 : {
2488 0 : SolarMutexGuard aGuard;
2489 : vcl::Window *pWindow;
2490 0 : if( (pWindow = GetWindow()) != NULL )
2491 : {
2492 0 : DockingWindow *pDockingWindow = dynamic_cast< DockingWindow* >(pWindow);
2493 0 : if( pDockingWindow )
2494 0 : return AWTSize( pDockingWindow->GetOutputSizePixel() );
2495 : else
2496 0 : return AWTSize( pWindow->GetOutputSizePixel() );
2497 : }
2498 : else
2499 0 : return ::com::sun::star::awt::Size();
2500 : }
2501 :
2502 19343 : sal_Bool SAL_CALL VCLXWindow::isVisible( ) throw (::com::sun::star::uno::RuntimeException, std::exception)
2503 : {
2504 19343 : SolarMutexGuard aGuard;
2505 19343 : if( GetWindow() )
2506 19343 : return GetWindow()->IsVisible();
2507 : else
2508 0 : return sal_False;
2509 : }
2510 :
2511 16070 : sal_Bool SAL_CALL VCLXWindow::isActive( ) throw (::com::sun::star::uno::RuntimeException, std::exception)
2512 : {
2513 16070 : SolarMutexGuard aGuard;
2514 16070 : if( GetWindow() )
2515 16070 : return GetWindow()->IsActive();
2516 : else
2517 0 : return sal_False;
2518 :
2519 : }
2520 :
2521 25 : sal_Bool SAL_CALL VCLXWindow::isEnabled( ) throw (::com::sun::star::uno::RuntimeException, std::exception)
2522 : {
2523 25 : SolarMutexGuard aGuard;
2524 25 : if( GetWindow() )
2525 25 : return GetWindow()->IsEnabled();
2526 : else
2527 0 : return sal_False;
2528 : }
2529 :
2530 0 : sal_Bool SAL_CALL VCLXWindow::hasFocus( ) throw (::com::sun::star::uno::RuntimeException, std::exception)
2531 : {
2532 0 : SolarMutexGuard aGuard;
2533 0 : if( GetWindow() )
2534 0 : return GetWindow()->HasFocus();
2535 : else
2536 0 : return sal_False;
2537 : }
2538 :
2539 : // ::com::sun::star::beans::XPropertySetInfo
2540 :
2541 : UnoPropertyArrayHelper *
2542 0 : VCLXWindow::GetPropHelper()
2543 : {
2544 0 : SolarMutexGuard aGuard;
2545 0 : if ( mpImpl->mpPropHelper == NULL )
2546 : {
2547 0 : std::list< sal_uInt16 > aIDs;
2548 0 : GetPropertyIds( aIDs );
2549 0 : mpImpl->mpPropHelper = new UnoPropertyArrayHelper( aIDs );
2550 : }
2551 0 : return mpImpl->mpPropHelper;
2552 : }
2553 :
2554 : ::com::sun::star::uno::Sequence< ::com::sun::star::beans::Property > SAL_CALL
2555 0 : VCLXWindow::getProperties() throw (::com::sun::star::uno::RuntimeException, std::exception)
2556 : {
2557 0 : return GetPropHelper()->getProperties();
2558 : }
2559 : ::com::sun::star::beans::Property SAL_CALL
2560 0 : VCLXWindow::getPropertyByName( const OUString& rName ) throw (::com::sun::star::beans::UnknownPropertyException, ::com::sun::star::uno::RuntimeException, std::exception)
2561 : {
2562 0 : return GetPropHelper()->getPropertyByName( rName );
2563 : }
2564 :
2565 : sal_Bool SAL_CALL
2566 0 : VCLXWindow::hasPropertyByName( const OUString& rName ) throw (::com::sun::star::uno::RuntimeException, std::exception)
2567 : {
2568 0 : return GetPropHelper()->hasPropertyByName( rName );
2569 : }
2570 :
2571 0 : Reference< XStyleSettings > SAL_CALL VCLXWindow::getStyleSettings() throw (RuntimeException, std::exception)
2572 : {
2573 0 : return mpImpl->getStyleSettings();
2574 798 : }
2575 :
2576 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
