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