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 : #include <toolkit/awt/vclxwindows.hxx>
21 : #include "toolkit/awt/scrollabledialog.hxx"
22 : #include <com/sun/star/awt/ScrollBarOrientation.hpp>
23 : #include <com/sun/star/graphic/GraphicProvider.hpp>
24 : #include <com/sun/star/graphic/XGraphicProvider.hpp>
25 : #include <toolkit/helper/vclunohelper.hxx>
26 : #include <toolkit/helper/macros.hxx>
27 : #include <toolkit/helper/property.hxx>
28 : #include <toolkit/helper/convert.hxx>
29 : #include <cppuhelper/typeprovider.hxx>
30 : #include <cppuhelper/queryinterface.hxx>
31 : #include <com/sun/star/awt/VisualEffect.hpp>
32 : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
33 : #include <com/sun/star/system/SystemShellExecute.hpp>
34 : #include <com/sun/star/system/SystemShellExecuteFlags.hpp>
35 : #include <com/sun/star/resource/XStringResourceResolver.hpp>
36 : #include <com/sun/star/awt/ImageScaleMode.hpp>
37 : #include <com/sun/star/awt/XItemList.hpp>
38 : #include <comphelper/namedvaluecollection.hxx>
39 : #include <comphelper/processfactory.hxx>
40 :
41 : #include <vcl/button.hxx>
42 : #include <vcl/lstbox.hxx>
43 : #include <vcl/combobox.hxx>
44 : #include <vcl/field.hxx>
45 : #include <vcl/fixedhyper.hxx>
46 : #include <vcl/longcurr.hxx>
47 : #include <vcl/imgctrl.hxx>
48 : #include <vcl/dialog.hxx>
49 : #include <vcl/msgbox.hxx>
50 : #include <vcl/scrbar.hxx>
51 : #include <vcl/svapp.hxx>
52 : #include <vcl/tabpage.hxx>
53 : #include <vcl/tabctrl.hxx>
54 : #include <vcl/settings.hxx>
55 : #include <tools/diagnose_ex.h>
56 :
57 : #include <boost/bind.hpp>
58 : #include <boost/function.hpp>
59 :
60 : #include <vcl/group.hxx>
61 :
62 : #include "helper/accessibilityclient.hxx"
63 : #include "helper/imagealign.hxx"
64 : #include "helper/tkresmgr.hxx"
65 : #include "vclxwindows_internal.hxx"
66 :
67 : using ::com::sun::star::uno::Any;
68 : using ::com::sun::star::uno::Reference;
69 : using ::com::sun::star::uno::makeAny;
70 : using ::com::sun::star::uno::RuntimeException;
71 : using ::com::sun::star::lang::EventObject;
72 : using ::com::sun::star::awt::ItemListEvent;
73 : using ::com::sun::star::awt::XItemList;
74 : using ::com::sun::star::graphic::XGraphic;
75 : using ::com::sun::star::graphic::XGraphicProvider;
76 :
77 : using namespace ::com::sun::star;
78 : using namespace ::com::sun::star::awt::VisualEffect;
79 : namespace ImageScaleMode = ::com::sun::star::awt::ImageScaleMode;
80 :
81 0 : static double ImplCalcLongValue( double nValue, sal_uInt16 nDigits )
82 : {
83 0 : double n = nValue;
84 0 : for ( sal_uInt16 d = 0; d < nDigits; d++ )
85 0 : n *= 10;
86 0 : return n;
87 : }
88 :
89 0 : static double ImplCalcDoubleValue( double nValue, sal_uInt16 nDigits )
90 : {
91 0 : double n = nValue;
92 0 : for ( sal_uInt16 d = 0; d < nDigits; d++ )
93 0 : n /= 10;
94 0 : return n;
95 : }
96 :
97 : namespace toolkit
98 : {
99 : /** sets the "face color" for button like controls (scroll bar, spin button)
100 : */
101 2 : void setButtonLikeFaceColor( vcl::Window* _pWindow, const ::com::sun::star::uno::Any& _rColorValue )
102 : {
103 2 : AllSettings aSettings = _pWindow->GetSettings();
104 4 : StyleSettings aStyleSettings = aSettings.GetStyleSettings();
105 :
106 2 : if ( !_rColorValue.hasValue() )
107 : {
108 2 : const StyleSettings& aAppStyle = Application::GetSettings().GetStyleSettings();
109 2 : aStyleSettings.SetFaceColor( aAppStyle.GetFaceColor( ) );
110 2 : aStyleSettings.SetCheckedColor( aAppStyle.GetCheckedColor( ) );
111 2 : aStyleSettings.SetLightBorderColor( aAppStyle.GetLightBorderColor() );
112 2 : aStyleSettings.SetLightColor( aAppStyle.GetLightColor() );
113 2 : aStyleSettings.SetShadowColor( aAppStyle.GetShadowColor() );
114 2 : aStyleSettings.SetDarkShadowColor( aAppStyle.GetDarkShadowColor() );
115 : }
116 : else
117 : {
118 0 : sal_Int32 nBackgroundColor = 0;
119 0 : _rColorValue >>= nBackgroundColor;
120 0 : aStyleSettings.SetFaceColor( nBackgroundColor );
121 :
122 : // for the real background (everything except the buttons and the thumb),
123 : // use an average between the desired color and "white"
124 0 : Color aWhite( COL_WHITE );
125 0 : Color aBackground( nBackgroundColor );
126 0 : aBackground.SetRed( ( aBackground.GetRed() + aWhite.GetRed() ) / 2 );
127 0 : aBackground.SetGreen( ( aBackground.GetGreen() + aWhite.GetGreen() ) / 2 );
128 0 : aBackground.SetBlue( ( aBackground.GetBlue() + aWhite.GetBlue() ) / 2 );
129 0 : aStyleSettings.SetCheckedColor( aBackground );
130 :
131 0 : sal_Int32 nBackgroundLuminance = Color( nBackgroundColor ).GetLuminance();
132 0 : sal_Int32 nWhiteLuminance = Color( COL_WHITE ).GetLuminance();
133 :
134 0 : Color aLightShadow( nBackgroundColor );
135 0 : aLightShadow.IncreaseLuminance( (sal_uInt8)( ( nWhiteLuminance - nBackgroundLuminance ) * 2 / 3 ) );
136 0 : aStyleSettings.SetLightBorderColor( aLightShadow );
137 :
138 0 : Color aLight( nBackgroundColor );
139 0 : aLight.IncreaseLuminance( (sal_uInt8)( ( nWhiteLuminance - nBackgroundLuminance ) * 1 / 3 ) );
140 0 : aStyleSettings.SetLightColor( aLight );
141 :
142 0 : Color aShadow( nBackgroundColor );
143 0 : aShadow.DecreaseLuminance( (sal_uInt8)( nBackgroundLuminance * 1 / 3 ) );
144 0 : aStyleSettings.SetShadowColor( aShadow );
145 :
146 0 : Color aDarkShadow( nBackgroundColor );
147 0 : aDarkShadow.DecreaseLuminance( (sal_uInt8)( nBackgroundLuminance * 2 / 3 ) );
148 0 : aStyleSettings.SetDarkShadowColor( aDarkShadow );
149 : }
150 :
151 2 : aSettings.SetStyleSettings( aStyleSettings );
152 4 : _pWindow->SetSettings( aSettings, true );
153 2 : }
154 :
155 0 : Any getButtonLikeFaceColor( const vcl::Window* _pWindow )
156 : {
157 0 : sal_Int32 nBackgroundColor = _pWindow->GetSettings().GetStyleSettings().GetFaceColor().GetColor();
158 0 : return makeAny( nBackgroundColor );
159 : }
160 :
161 450 : static void adjustBooleanWindowStyle( const Any& _rValue, vcl::Window* _pWindow, WinBits _nBits, bool _bInverseSemantics )
162 : {
163 450 : WinBits nStyle = _pWindow->GetStyle();
164 450 : bool bValue( false );
165 450 : OSL_VERIFY( _rValue >>= bValue );
166 450 : if ( bValue != _bInverseSemantics )
167 118 : nStyle |= _nBits;
168 : else
169 332 : nStyle &= ~_nBits;
170 450 : _pWindow->SetStyle( nStyle );
171 450 : }
172 :
173 56 : static void setVisualEffect( const Any& _rValue, vcl::Window* _pWindow )
174 : {
175 56 : AllSettings aSettings = _pWindow->GetSettings();
176 112 : StyleSettings aStyleSettings = aSettings.GetStyleSettings();
177 :
178 56 : sal_Int16 nStyle = LOOK3D;
179 56 : OSL_VERIFY( _rValue >>= nStyle );
180 56 : switch ( nStyle )
181 : {
182 : case FLAT:
183 10 : aStyleSettings.SetOptions( aStyleSettings.GetOptions() | StyleSettingsOptions::Mono );
184 10 : break;
185 : case LOOK3D:
186 : default:
187 46 : aStyleSettings.SetOptions( aStyleSettings.GetOptions() & ~StyleSettingsOptions::Mono );
188 : }
189 56 : aSettings.SetStyleSettings( aStyleSettings );
190 112 : _pWindow->SetSettings( aSettings );
191 56 : }
192 :
193 0 : static Any getVisualEffect( vcl::Window* _pWindow )
194 : {
195 0 : Any aEffect;
196 :
197 0 : StyleSettings aStyleSettings = _pWindow->GetSettings().GetStyleSettings();
198 0 : if ( (aStyleSettings.GetOptions() & StyleSettingsOptions::Mono) )
199 0 : aEffect <<= (sal_Int16)FLAT;
200 : else
201 0 : aEffect <<= (sal_Int16)LOOK3D;
202 0 : return aEffect;
203 : }
204 : }
205 :
206 :
207 : // class VCLXGraphicControl
208 :
209 :
210 147 : void VCLXGraphicControl::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
211 : {
212 147 : VCLXWindow::ImplGetPropertyIds( rIds );
213 147 : }
214 :
215 108 : void VCLXGraphicControl::ImplSetNewImage()
216 : {
217 : OSL_PRECOND( GetWindow(), "VCLXGraphicControl::ImplSetNewImage: window is required to be not-NULL!" );
218 108 : VclPtr< Button > pButton = GetAsDynamic< Button >();
219 108 : pButton->SetModeImage( GetImage() );
220 108 : }
221 :
222 143 : void VCLXGraphicControl::setPosSize( sal_Int32 X, sal_Int32 Y, sal_Int32 Width, sal_Int32 Height, short Flags ) throw(::com::sun::star::uno::RuntimeException, std::exception)
223 : {
224 143 : SolarMutexGuard aGuard;
225 :
226 143 : if ( GetWindow() )
227 : {
228 143 : Size aOldSize = GetWindow()->GetSizePixel();
229 143 : VCLXWindow::setPosSize( X, Y, Width, Height, Flags );
230 143 : if ( ( aOldSize.Width() != Width ) || ( aOldSize.Height() != Height ) )
231 15 : ImplSetNewImage();
232 143 : }
233 143 : }
234 :
235 6221 : void VCLXGraphicControl::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
236 : {
237 6221 : SolarMutexGuard aGuard;
238 :
239 6221 : if ( !GetWindow() )
240 6221 : return;
241 :
242 6221 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
243 6221 : switch ( nPropType )
244 : {
245 : case BASEPROPERTY_GRAPHIC:
246 : {
247 105 : Reference< XGraphic > xGraphic;
248 105 : OSL_VERIFY( Value >>= xGraphic );
249 105 : maImage = Image( xGraphic );
250 105 : ImplSetNewImage();
251 : }
252 105 : break;
253 :
254 : case BASEPROPERTY_IMAGEALIGN:
255 : {
256 51 : WindowType eType = GetWindow()->GetType();
257 51 : if ( ( eType == WINDOW_PUSHBUTTON )
258 0 : || ( eType == WINDOW_RADIOBUTTON )
259 0 : || ( eType == WINDOW_CHECKBOX )
260 : )
261 : {
262 51 : sal_Int16 nAlignment = sal_Int16();
263 51 : if ( Value >>= nAlignment )
264 51 : GetAs< Button >()->SetImageAlign( static_cast< ImageAlign >( nAlignment ) );
265 : }
266 : }
267 51 : break;
268 : case BASEPROPERTY_IMAGEPOSITION:
269 : {
270 107 : WindowType eType = GetWindow()->GetType();
271 107 : if ( ( eType == WINDOW_PUSHBUTTON )
272 56 : || ( eType == WINDOW_RADIOBUTTON )
273 28 : || ( eType == WINDOW_CHECKBOX )
274 : )
275 : {
276 107 : sal_Int16 nImagePosition = 2;
277 107 : OSL_VERIFY( Value >>= nImagePosition );
278 107 : GetAs<Button>()->SetImageAlign( ::toolkit::translateImagePosition( nImagePosition ) );
279 : }
280 : }
281 107 : break;
282 : default:
283 5958 : VCLXWindow::setProperty( PropertyName, Value );
284 5958 : break;
285 6221 : }
286 : }
287 :
288 0 : ::com::sun::star::uno::Any VCLXGraphicControl::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
289 : {
290 0 : SolarMutexGuard aGuard;
291 :
292 0 : ::com::sun::star::uno::Any aProp;
293 0 : if ( !GetWindow() )
294 0 : return aProp;
295 :
296 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
297 0 : switch ( nPropType )
298 : {
299 : case BASEPROPERTY_GRAPHIC:
300 0 : aProp <<= maImage.GetXGraphic();
301 0 : break;
302 : case BASEPROPERTY_IMAGEALIGN:
303 : {
304 0 : WindowType eType = GetWindow()->GetType();
305 0 : if ( ( eType == WINDOW_PUSHBUTTON )
306 0 : || ( eType == WINDOW_RADIOBUTTON )
307 0 : || ( eType == WINDOW_CHECKBOX )
308 : )
309 : {
310 0 : aProp <<= ::toolkit::getCompatibleImageAlign(
311 0 : GetAs<Button>()->GetImageAlign() );
312 : }
313 : }
314 0 : break;
315 : case BASEPROPERTY_IMAGEPOSITION:
316 : {
317 0 : WindowType eType = GetWindow()->GetType();
318 0 : if ( ( eType == WINDOW_PUSHBUTTON )
319 0 : || ( eType == WINDOW_RADIOBUTTON )
320 0 : || ( eType == WINDOW_CHECKBOX )
321 : )
322 : {
323 0 : aProp <<= ::toolkit::translateImagePosition(
324 0 : GetAs< Button >()->GetImageAlign() );
325 : }
326 : }
327 0 : break;
328 : default:
329 : {
330 0 : aProp <<= VCLXWindow::getProperty( PropertyName );
331 : }
332 0 : break;
333 : }
334 0 : return aProp;
335 : }
336 :
337 :
338 : // class VCLXButton
339 :
340 :
341 64 : void VCLXButton::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
342 : {
343 : PushPropertyIds( rIds,
344 : BASEPROPERTY_BACKGROUNDCOLOR,
345 : BASEPROPERTY_DEFAULTBUTTON,
346 : BASEPROPERTY_DEFAULTCONTROL,
347 : BASEPROPERTY_ENABLED,
348 : BASEPROPERTY_ENABLEVISIBLE,
349 : BASEPROPERTY_FONTDESCRIPTOR,
350 : BASEPROPERTY_GRAPHIC,
351 : BASEPROPERTY_HELPTEXT,
352 : BASEPROPERTY_HELPURL,
353 : BASEPROPERTY_IMAGEALIGN,
354 : BASEPROPERTY_IMAGEPOSITION,
355 : BASEPROPERTY_IMAGEURL,
356 : BASEPROPERTY_LABEL,
357 : BASEPROPERTY_PRINTABLE,
358 : BASEPROPERTY_PUSHBUTTONTYPE,
359 : BASEPROPERTY_REPEAT,
360 : BASEPROPERTY_REPEAT_DELAY,
361 : BASEPROPERTY_STATE,
362 : BASEPROPERTY_TABSTOP,
363 : BASEPROPERTY_TOGGLE,
364 : BASEPROPERTY_FOCUSONCLICK,
365 : BASEPROPERTY_MULTILINE,
366 : BASEPROPERTY_ALIGN,
367 : BASEPROPERTY_VERTICALALIGN,
368 : BASEPROPERTY_WRITING_MODE,
369 : BASEPROPERTY_CONTEXT_WRITING_MODE,
370 : BASEPROPERTY_REFERENCE_DEVICE,
371 64 : 0);
372 64 : VCLXGraphicControl::ImplGetPropertyIds( rIds );
373 64 : }
374 :
375 51 : VCLXButton::VCLXButton()
376 : :maActionListeners( *this )
377 51 : ,maItemListeners( *this )
378 : {
379 51 : }
380 :
381 102 : VCLXButton::~VCLXButton()
382 : {
383 102 : }
384 :
385 1 : ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXButton::CreateAccessibleContext()
386 : {
387 1 : return getAccessibleFactory().createAccessibleContext( this );
388 : }
389 :
390 102 : void VCLXButton::dispose() throw(::com::sun::star::uno::RuntimeException, std::exception)
391 : {
392 102 : SolarMutexGuard aGuard;
393 :
394 204 : ::com::sun::star::lang::EventObject aObj;
395 102 : aObj.Source = static_cast<cppu::OWeakObject*>(this);
396 102 : maActionListeners.disposeAndClear( aObj );
397 102 : maItemListeners.disposeAndClear( aObj );
398 204 : VCLXGraphicControl::dispose();
399 102 : }
400 :
401 50 : void VCLXButton::addActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l )throw(::com::sun::star::uno::RuntimeException, std::exception)
402 : {
403 50 : SolarMutexGuard aGuard;
404 50 : maActionListeners.addInterface( l );
405 50 : }
406 :
407 1 : void VCLXButton::removeActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
408 : {
409 1 : SolarMutexGuard aGuard;
410 1 : maActionListeners.removeInterface( l );
411 1 : }
412 :
413 53 : void VCLXButton::addItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l )throw(::com::sun::star::uno::RuntimeException, std::exception)
414 : {
415 53 : SolarMutexGuard aGuard;
416 53 : maItemListeners.addInterface( l );
417 53 : }
418 :
419 0 : void VCLXButton::removeItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
420 : {
421 0 : SolarMutexGuard aGuard;
422 0 : maItemListeners.removeInterface( l );
423 0 : }
424 :
425 0 : void VCLXButton::setLabel( const OUString& rLabel ) throw(::com::sun::star::uno::RuntimeException, std::exception)
426 : {
427 0 : SolarMutexGuard aGuard;
428 :
429 0 : vcl::Window* pWindow = GetWindow();
430 0 : if ( pWindow )
431 0 : pWindow->SetText( rLabel );
432 0 : }
433 :
434 55 : void VCLXButton::setActionCommand( const OUString& rCommand ) throw(::com::sun::star::uno::RuntimeException, std::exception)
435 : {
436 55 : SolarMutexGuard aGuard;
437 :
438 55 : maActionCommand = rCommand;
439 55 : }
440 :
441 5 : ::com::sun::star::awt::Size VCLXButton::getMinimumSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
442 : {
443 5 : SolarMutexGuard aGuard;
444 :
445 5 : Size aSz;
446 10 : VclPtr< PushButton > pButton = GetAs< PushButton >();
447 5 : if ( pButton )
448 5 : aSz = pButton->CalcMinimumSize();
449 10 : return AWTSize(aSz);
450 : }
451 :
452 3 : ::com::sun::star::awt::Size VCLXButton::getPreferredSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
453 : {
454 3 : ::com::sun::star::awt::Size aSz = getMinimumSize();
455 3 : aSz.Width += 16;
456 3 : aSz.Height += 10;
457 3 : return aSz;
458 : }
459 :
460 2 : ::com::sun::star::awt::Size VCLXButton::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException, std::exception)
461 : {
462 2 : SolarMutexGuard aGuard;
463 :
464 2 : Size aSz = VCLSize(rNewSize);
465 4 : VclPtr< PushButton > pButton = GetAs< PushButton >();
466 2 : if ( pButton )
467 : {
468 2 : Size aMinSz = pButton->CalcMinimumSize();
469 : // no text, thus image
470 2 : if ( pButton->GetText().isEmpty() )
471 : {
472 2 : if ( aSz.Width() < aMinSz.Width() )
473 0 : aSz.Width() = aMinSz.Width();
474 2 : if ( aSz.Height() < aMinSz.Height() )
475 0 : aSz.Height() = aMinSz.Height();
476 : }
477 : else
478 : {
479 0 : if ( ( aSz.Width() > aMinSz.Width() ) && ( aSz.Height() < aMinSz.Height() ) )
480 0 : aSz.Height() = aMinSz.Height();
481 : else
482 0 : aSz = aMinSz;
483 : }
484 : }
485 4 : return AWTSize(aSz);
486 : }
487 :
488 3066 : void VCLXButton::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
489 : {
490 3066 : SolarMutexGuard aGuard;
491 :
492 6132 : VclPtr< Button > pButton = GetAs< Button >();
493 3066 : if ( pButton )
494 : {
495 3066 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
496 3066 : switch ( nPropType )
497 : {
498 : case BASEPROPERTY_FOCUSONCLICK:
499 51 : ::toolkit::adjustBooleanWindowStyle( Value, pButton, WB_NOPOINTERFOCUS, true );
500 51 : break;
501 :
502 : case BASEPROPERTY_TOGGLE:
503 51 : ::toolkit::adjustBooleanWindowStyle( Value, pButton, WB_TOGGLE, false );
504 51 : break;
505 :
506 : case BASEPROPERTY_DEFAULTBUTTON:
507 : {
508 51 : WinBits nStyle = pButton->GetStyle() | WB_DEFBUTTON;
509 51 : bool b = bool();
510 51 : if ( ( Value >>= b ) && !b )
511 51 : nStyle &= ~WB_DEFBUTTON;
512 51 : pButton->SetStyle( nStyle );
513 : }
514 51 : break;
515 : case BASEPROPERTY_STATE:
516 : {
517 57 : if ( GetWindow()->GetType() == WINDOW_PUSHBUTTON )
518 : {
519 57 : sal_Int16 n = sal_Int16();
520 57 : if ( Value >>= n )
521 57 : static_cast<PushButton*>(pButton.get())->SetState( (TriState)n );
522 : }
523 : }
524 57 : break;
525 : default:
526 : {
527 2856 : VCLXGraphicControl::setProperty( PropertyName, Value );
528 : }
529 : }
530 3066 : }
531 3066 : }
532 :
533 0 : ::com::sun::star::uno::Any VCLXButton::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
534 : {
535 0 : SolarMutexGuard aGuard;
536 :
537 0 : ::com::sun::star::uno::Any aProp;
538 0 : VclPtr< Button > pButton = GetAs< Button >();
539 0 : if ( pButton )
540 : {
541 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
542 0 : switch ( nPropType )
543 : {
544 : case BASEPROPERTY_FOCUSONCLICK:
545 0 : aProp <<= ( ( pButton->GetStyle() & WB_NOPOINTERFOCUS ) == 0 );
546 0 : break;
547 :
548 : case BASEPROPERTY_TOGGLE:
549 0 : aProp <<= ( ( pButton->GetStyle() & WB_TOGGLE ) != 0 );
550 0 : break;
551 :
552 : case BASEPROPERTY_DEFAULTBUTTON:
553 : {
554 0 : aProp <<= ( pButton->GetStyle() & WB_DEFBUTTON ) != 0;
555 : }
556 0 : break;
557 : case BASEPROPERTY_STATE:
558 : {
559 0 : if ( GetWindow()->GetType() == WINDOW_PUSHBUTTON )
560 : {
561 0 : aProp <<= (sal_Int16)static_cast<PushButton*>(pButton.get())->GetState();
562 : }
563 : }
564 0 : break;
565 : default:
566 : {
567 0 : aProp <<= VCLXGraphicControl::getProperty( PropertyName );
568 : }
569 : }
570 : }
571 0 : return aProp;
572 : }
573 :
574 340 : void VCLXButton::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
575 : {
576 340 : switch ( rVclWindowEvent.GetId() )
577 : {
578 : case VCLEVENT_BUTTON_CLICK:
579 : {
580 1 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
581 : // since we call listeners below, there is a potential that we will be destroyed
582 : // during the listener call. To prevent the resulting crashs, we keep us
583 : // alive as long as we're here
584 :
585 1 : if ( maActionListeners.getLength() )
586 : {
587 1 : ::com::sun::star::awt::ActionEvent aEvent;
588 1 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
589 1 : aEvent.ActionCommand = maActionCommand;
590 :
591 : Callback aCallback = ::boost::bind(
592 : &ActionListenerMultiplexer::actionPerformed,
593 : &maActionListeners,
594 : aEvent
595 2 : );
596 2 : ImplExecuteAsyncWithoutSolarLock( aCallback );
597 1 : }
598 : }
599 1 : break;
600 :
601 : case VCLEVENT_PUSHBUTTON_TOGGLE:
602 : {
603 0 : PushButton& rButton = dynamic_cast< PushButton& >( *rVclWindowEvent.GetWindow() );
604 :
605 0 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
606 0 : if ( maItemListeners.getLength() )
607 : {
608 0 : ::com::sun::star::awt::ItemEvent aEvent;
609 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
610 0 : aEvent.Selected = ( rButton.GetState() == TRISTATE_TRUE ) ? 1 : 0;
611 0 : maItemListeners.itemStateChanged( aEvent );
612 0 : }
613 : }
614 0 : break;
615 :
616 : default:
617 339 : VCLXGraphicControl::ProcessWindowEvent( rVclWindowEvent );
618 339 : break;
619 : }
620 340 : }
621 :
622 :
623 : // class VCLXImageControl
624 :
625 :
626 27 : void VCLXImageControl::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
627 : {
628 : PushPropertyIds( rIds,
629 : BASEPROPERTY_BACKGROUNDCOLOR,
630 : BASEPROPERTY_BORDER,
631 : BASEPROPERTY_BORDERCOLOR,
632 : BASEPROPERTY_DEFAULTCONTROL,
633 : BASEPROPERTY_ENABLED,
634 : BASEPROPERTY_ENABLEVISIBLE,
635 : BASEPROPERTY_GRAPHIC,
636 : BASEPROPERTY_HELPTEXT,
637 : BASEPROPERTY_HELPURL,
638 : BASEPROPERTY_IMAGEURL,
639 : BASEPROPERTY_PRINTABLE,
640 : BASEPROPERTY_SCALEIMAGE,
641 : BASEPROPERTY_IMAGE_SCALE_MODE,
642 : BASEPROPERTY_TABSTOP,
643 : BASEPROPERTY_WRITING_MODE,
644 : BASEPROPERTY_CONTEXT_WRITING_MODE,
645 27 : 0);
646 27 : VCLXGraphicControl::ImplGetPropertyIds( rIds );
647 27 : }
648 :
649 14 : VCLXImageControl::VCLXImageControl()
650 : {
651 14 : }
652 :
653 28 : VCLXImageControl::~VCLXImageControl()
654 : {
655 28 : }
656 :
657 12 : void VCLXImageControl::ImplSetNewImage()
658 : {
659 : OSL_PRECOND( GetWindow(), "VCLXImageControl::ImplSetNewImage: window is required to be not-NULL!" );
660 12 : VclPtr<ImageControl> pControl = GetAs< ImageControl >();
661 12 : pControl->SetImage( GetImage() );
662 12 : }
663 :
664 9 : ::com::sun::star::awt::Size VCLXImageControl::getMinimumSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
665 : {
666 9 : SolarMutexGuard aGuard;
667 :
668 9 : Size aSz = GetImage().GetSizePixel();
669 9 : aSz = ImplCalcWindowSize( aSz );
670 :
671 9 : return AWTSize(aSz);
672 : }
673 :
674 3 : ::com::sun::star::awt::Size VCLXImageControl::getPreferredSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
675 : {
676 3 : return getMinimumSize();
677 : }
678 :
679 3 : ::com::sun::star::awt::Size VCLXImageControl::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException, std::exception)
680 : {
681 3 : SolarMutexGuard aGuard;
682 :
683 3 : ::com::sun::star::awt::Size aSz = rNewSize;
684 3 : ::com::sun::star::awt::Size aMinSz = getMinimumSize();
685 3 : if ( aSz.Width < aMinSz.Width )
686 0 : aSz.Width = aMinSz.Width;
687 3 : if ( aSz.Height < aMinSz.Height )
688 0 : aSz.Height = aMinSz.Height;
689 3 : return aSz;
690 : }
691 :
692 500 : void VCLXImageControl::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
693 : {
694 500 : SolarMutexGuard aGuard;
695 :
696 1000 : VclPtr< ImageControl > pImageControl = GetAs< ImageControl >();
697 :
698 500 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
699 500 : switch ( nPropType )
700 : {
701 : case BASEPROPERTY_IMAGE_SCALE_MODE:
702 : {
703 28 : sal_Int16 nScaleMode( ImageScaleMode::ANISOTROPIC );
704 28 : if ( pImageControl && ( Value >>= nScaleMode ) )
705 : {
706 28 : pImageControl->SetScaleMode( nScaleMode );
707 : }
708 : }
709 28 : break;
710 :
711 : case BASEPROPERTY_SCALEIMAGE:
712 : {
713 : // this is for compatibility only, nowadays, the ImageScaleMode property should be used
714 27 : bool bScaleImage = false;
715 27 : if ( pImageControl && ( Value >>= bScaleImage ) )
716 : {
717 27 : pImageControl->SetScaleMode( bScaleImage ? ImageScaleMode::ANISOTROPIC : ImageScaleMode::NONE );
718 : }
719 : }
720 27 : break;
721 :
722 : default:
723 445 : VCLXGraphicControl::setProperty( PropertyName, Value );
724 445 : break;
725 500 : }
726 500 : }
727 :
728 0 : ::com::sun::star::uno::Any VCLXImageControl::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
729 : {
730 0 : SolarMutexGuard aGuard;
731 :
732 0 : ::com::sun::star::uno::Any aProp;
733 0 : VclPtr< ImageControl > pImageControl = GetAs< ImageControl >();
734 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
735 :
736 0 : switch ( nPropType )
737 : {
738 : case BASEPROPERTY_IMAGE_SCALE_MODE:
739 0 : aProp <<= ( pImageControl ? pImageControl->GetScaleMode() : ImageScaleMode::ANISOTROPIC );
740 0 : break;
741 :
742 : case BASEPROPERTY_SCALEIMAGE:
743 0 : aProp <<= ( pImageControl && pImageControl->GetScaleMode() != ImageScaleMode::NONE ) ? sal_True : sal_False;
744 0 : break;
745 :
746 : default:
747 0 : aProp = VCLXGraphicControl::getProperty( PropertyName );
748 0 : break;
749 : }
750 0 : return aProp;
751 : }
752 :
753 :
754 : // class VCLXCheckBox
755 :
756 :
757 :
758 27 : void VCLXCheckBox::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
759 : {
760 : PushPropertyIds( rIds,
761 : BASEPROPERTY_DEFAULTCONTROL,
762 : BASEPROPERTY_ENABLED,
763 : BASEPROPERTY_ENABLEVISIBLE,
764 : BASEPROPERTY_FONTDESCRIPTOR,
765 : BASEPROPERTY_GRAPHIC,
766 : BASEPROPERTY_HELPTEXT,
767 : BASEPROPERTY_HELPURL,
768 : BASEPROPERTY_IMAGEPOSITION,
769 : BASEPROPERTY_IMAGEURL,
770 : BASEPROPERTY_LABEL,
771 : BASEPROPERTY_PRINTABLE,
772 : BASEPROPERTY_STATE,
773 : BASEPROPERTY_TABSTOP,
774 : BASEPROPERTY_TRISTATE,
775 : BASEPROPERTY_VISUALEFFECT,
776 : BASEPROPERTY_MULTILINE,
777 : BASEPROPERTY_BACKGROUNDCOLOR,
778 : BASEPROPERTY_ALIGN,
779 : BASEPROPERTY_VERTICALALIGN,
780 : BASEPROPERTY_WRITING_MODE,
781 : BASEPROPERTY_CONTEXT_WRITING_MODE,
782 : BASEPROPERTY_REFERENCE_DEVICE,
783 27 : 0);
784 27 : VCLXGraphicControl::ImplGetPropertyIds( rIds );
785 27 : }
786 :
787 24 : VCLXCheckBox::VCLXCheckBox() : maActionListeners( *this ), maItemListeners( *this )
788 : {
789 24 : }
790 :
791 : // ::com::sun::star::uno::XInterface
792 4460 : ::com::sun::star::uno::Any VCLXCheckBox::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
793 : {
794 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
795 : (static_cast< ::com::sun::star::awt::XButton* >(this)),
796 4460 : (static_cast< ::com::sun::star::awt::XCheckBox* >(this)) );
797 4460 : return (aRet.hasValue() ? aRet : VCLXGraphicControl::queryInterface( rType ));
798 : }
799 :
800 : // ::com::sun::star::lang::XTypeProvider
801 0 : IMPL_XTYPEPROVIDER_START( VCLXCheckBox )
802 0 : cppu::UnoType<com::sun::star::awt::XButton>::get(),
803 0 : cppu::UnoType<com::sun::star::awt::XCheckBox>::get(),
804 : VCLXGraphicControl::getTypes()
805 0 : IMPL_XTYPEPROVIDER_END
806 :
807 3 : ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXCheckBox::CreateAccessibleContext()
808 : {
809 3 : return getAccessibleFactory().createAccessibleContext( this );
810 : }
811 :
812 48 : void VCLXCheckBox::dispose() throw(::com::sun::star::uno::RuntimeException, std::exception)
813 : {
814 48 : SolarMutexGuard aGuard;
815 :
816 96 : ::com::sun::star::lang::EventObject aObj;
817 48 : aObj.Source = static_cast<cppu::OWeakObject*>(this);
818 48 : maItemListeners.disposeAndClear( aObj );
819 96 : VCLXGraphicControl::dispose();
820 48 : }
821 :
822 23 : void VCLXCheckBox::addItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
823 : {
824 23 : SolarMutexGuard aGuard;
825 23 : maItemListeners.addInterface( l );
826 23 : }
827 :
828 0 : void VCLXCheckBox::removeItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
829 : {
830 0 : SolarMutexGuard aGuard;
831 0 : maItemListeners.removeInterface( l );
832 0 : }
833 :
834 1 : void VCLXCheckBox::addActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l )throw(::com::sun::star::uno::RuntimeException, std::exception)
835 : {
836 1 : SolarMutexGuard aGuard;
837 1 : maActionListeners.addInterface( l );
838 1 : }
839 :
840 0 : void VCLXCheckBox::removeActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
841 : {
842 0 : SolarMutexGuard aGuard;
843 0 : maActionListeners.removeInterface( l );
844 0 : }
845 :
846 23 : void VCLXCheckBox::setActionCommand( const OUString& rCommand ) throw(::com::sun::star::uno::RuntimeException, std::exception)
847 : {
848 23 : SolarMutexGuard aGuard;
849 23 : maActionCommand = rCommand;
850 23 : }
851 :
852 0 : void VCLXCheckBox::setLabel( const OUString& rLabel ) throw(::com::sun::star::uno::RuntimeException, std::exception)
853 : {
854 0 : SolarMutexGuard aGuard;
855 :
856 0 : vcl::Window* pWindow = GetWindow();
857 0 : if ( pWindow )
858 0 : pWindow->SetText( rLabel );
859 0 : }
860 :
861 41 : void VCLXCheckBox::setState( short n ) throw(::com::sun::star::uno::RuntimeException, std::exception)
862 : {
863 41 : SolarMutexGuard aGuard;
864 :
865 82 : VclPtr< CheckBox> pCheckBox = GetAs< CheckBox >();
866 41 : if ( pCheckBox)
867 : {
868 : TriState eState;
869 41 : switch ( n )
870 : {
871 11 : case 0: eState = TRISTATE_FALSE; break;
872 14 : case 1: eState = TRISTATE_TRUE; break;
873 10 : case 2: eState = TRISTATE_INDET; break;
874 6 : default: eState = TRISTATE_FALSE;
875 : }
876 41 : pCheckBox->SetState( eState );
877 :
878 : // #105198# call C++ click listeners (needed for accessibility)
879 : // pCheckBox->GetClickHdl().Call( pCheckBox );
880 :
881 : // #107218# Call same virtual methods and listeners like VCL would do after user interaction
882 41 : SetSynthesizingVCLEvent( true );
883 41 : pCheckBox->Toggle();
884 41 : pCheckBox->Click();
885 41 : SetSynthesizingVCLEvent( false );
886 41 : }
887 41 : }
888 :
889 12 : short VCLXCheckBox::getState() throw(::com::sun::star::uno::RuntimeException, std::exception)
890 : {
891 12 : SolarMutexGuard aGuard;
892 :
893 12 : short nState = -1;
894 24 : VclPtr< CheckBox > pCheckBox = GetAs< CheckBox >();
895 12 : if ( pCheckBox )
896 : {
897 12 : switch ( pCheckBox->GetState() )
898 : {
899 12 : case TRISTATE_FALSE: nState = 0; break;
900 0 : case TRISTATE_TRUE: nState = 1; break;
901 0 : case TRISTATE_INDET: nState = 2; break;
902 : default: OSL_FAIL( "VCLXCheckBox::getState(): unknown TriState!" );
903 : }
904 : }
905 :
906 24 : return nState;
907 : }
908 :
909 0 : void VCLXCheckBox::enableTriState( sal_Bool b ) throw(::com::sun::star::uno::RuntimeException, std::exception)
910 : {
911 0 : SolarMutexGuard aGuard;
912 :
913 0 : VclPtr< CheckBox > pCheckBox = GetAs< CheckBox >();
914 0 : if ( pCheckBox)
915 0 : pCheckBox->EnableTriState( b );
916 0 : }
917 :
918 4 : ::com::sun::star::awt::Size VCLXCheckBox::getMinimumSize() throw(::com::sun::star::uno::RuntimeException, std::exception)
919 : {
920 4 : SolarMutexGuard aGuard;
921 :
922 4 : Size aSz;
923 8 : VclPtr< CheckBox > pCheckBox = GetAs< CheckBox >();
924 4 : if ( pCheckBox )
925 4 : aSz = pCheckBox->CalcMinimumSize();
926 8 : return AWTSize(aSz);
927 : }
928 :
929 2 : ::com::sun::star::awt::Size VCLXCheckBox::getPreferredSize() throw(::com::sun::star::uno::RuntimeException, std::exception)
930 : {
931 2 : return getMinimumSize();
932 : }
933 :
934 2 : ::com::sun::star::awt::Size VCLXCheckBox::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException, std::exception)
935 : {
936 2 : SolarMutexGuard aGuard;
937 :
938 2 : Size aSz = VCLSize(rNewSize);
939 4 : VclPtr< CheckBox > pCheckBox = GetAs< CheckBox >();
940 2 : if ( pCheckBox )
941 : {
942 2 : Size aMinSz = pCheckBox->CalcMinimumSize();
943 2 : if ( ( aSz.Width() > aMinSz.Width() ) && ( aSz.Height() < aMinSz.Height() ) )
944 0 : aSz.Height() = aMinSz.Height();
945 : else
946 2 : aSz = aMinSz;
947 : }
948 4 : return AWTSize(aSz);
949 : }
950 :
951 1536 : void VCLXCheckBox::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
952 : {
953 1536 : SolarMutexGuard aGuard;
954 :
955 3072 : VclPtr< CheckBox > pCheckBox = GetAs< CheckBox >();
956 1536 : if ( pCheckBox )
957 : {
958 1536 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
959 1536 : switch ( nPropType )
960 : {
961 : case BASEPROPERTY_VISUALEFFECT:
962 28 : ::toolkit::setVisualEffect( Value, pCheckBox );
963 28 : break;
964 :
965 : case BASEPROPERTY_TRISTATE:
966 : {
967 30 : bool b = bool();
968 30 : if ( Value >>= b )
969 30 : pCheckBox->EnableTriState( b );
970 : }
971 30 : break;
972 : case BASEPROPERTY_STATE:
973 : {
974 41 : sal_Int16 n = sal_Int16();
975 41 : if ( Value >>= n )
976 41 : setState( n );
977 : }
978 41 : break;
979 : default:
980 : {
981 1437 : VCLXGraphicControl::setProperty( PropertyName, Value );
982 : }
983 : }
984 1536 : }
985 1536 : }
986 :
987 0 : ::com::sun::star::uno::Any VCLXCheckBox::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
988 : {
989 0 : SolarMutexGuard aGuard;
990 :
991 0 : ::com::sun::star::uno::Any aProp;
992 0 : VclPtr< CheckBox > pCheckBox = GetAs< CheckBox >();
993 0 : if ( pCheckBox )
994 : {
995 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
996 0 : switch ( nPropType )
997 : {
998 : case BASEPROPERTY_VISUALEFFECT:
999 0 : aProp = ::toolkit::getVisualEffect( pCheckBox );
1000 0 : break;
1001 : case BASEPROPERTY_TRISTATE:
1002 0 : aProp <<= pCheckBox->IsTriStateEnabled();
1003 0 : break;
1004 : case BASEPROPERTY_STATE:
1005 0 : aProp <<= (sal_Int16)pCheckBox->GetState();
1006 0 : break;
1007 : default:
1008 : {
1009 0 : aProp <<= VCLXGraphicControl::getProperty( PropertyName );
1010 : }
1011 : }
1012 : }
1013 0 : return aProp;
1014 : }
1015 :
1016 472 : void VCLXCheckBox::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
1017 : {
1018 472 : switch ( rVclWindowEvent.GetId() )
1019 : {
1020 : case VCLEVENT_CHECKBOX_TOGGLE:
1021 : {
1022 0 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
1023 : // since we call listeners below, there is a potential that we will be destroyed
1024 : // in during the listener call. To prevent the resulting crashs, we keep us
1025 : // alive as long as we're here
1026 :
1027 0 : VclPtr< CheckBox > pCheckBox = GetAs< CheckBox >();
1028 0 : if ( pCheckBox )
1029 : {
1030 0 : if ( maItemListeners.getLength() )
1031 : {
1032 0 : ::com::sun::star::awt::ItemEvent aEvent;
1033 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
1034 0 : aEvent.Highlighted = 0;
1035 0 : aEvent.Selected = pCheckBox->GetState();
1036 0 : maItemListeners.itemStateChanged( aEvent );
1037 : }
1038 0 : if ( !IsSynthesizingVCLEvent() && maActionListeners.getLength() )
1039 : {
1040 0 : ::com::sun::star::awt::ActionEvent aEvent;
1041 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
1042 0 : aEvent.ActionCommand = maActionCommand;
1043 0 : maActionListeners.actionPerformed( aEvent );
1044 : }
1045 0 : }
1046 : }
1047 0 : break;
1048 :
1049 : default:
1050 472 : VCLXGraphicControl::ProcessWindowEvent( rVclWindowEvent );
1051 472 : break;
1052 : }
1053 472 : }
1054 :
1055 :
1056 : // class VCLXRadioButton
1057 :
1058 29 : void VCLXRadioButton::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
1059 : {
1060 : PushPropertyIds( rIds,
1061 : BASEPROPERTY_DEFAULTCONTROL,
1062 : BASEPROPERTY_ENABLED,
1063 : BASEPROPERTY_ENABLEVISIBLE,
1064 : BASEPROPERTY_FONTDESCRIPTOR,
1065 : BASEPROPERTY_GRAPHIC,
1066 : BASEPROPERTY_HELPTEXT,
1067 : BASEPROPERTY_HELPURL,
1068 : BASEPROPERTY_IMAGEPOSITION,
1069 : BASEPROPERTY_IMAGEURL,
1070 : BASEPROPERTY_LABEL,
1071 : BASEPROPERTY_PRINTABLE,
1072 : BASEPROPERTY_STATE,
1073 : BASEPROPERTY_TABSTOP,
1074 : BASEPROPERTY_VISUALEFFECT,
1075 : BASEPROPERTY_MULTILINE,
1076 : BASEPROPERTY_BACKGROUNDCOLOR,
1077 : BASEPROPERTY_ALIGN,
1078 : BASEPROPERTY_VERTICALALIGN,
1079 : BASEPROPERTY_WRITING_MODE,
1080 : BASEPROPERTY_CONTEXT_WRITING_MODE,
1081 : BASEPROPERTY_REFERENCE_DEVICE,
1082 : BASEPROPERTY_GROUPNAME,
1083 29 : 0);
1084 29 : VCLXGraphicControl::ImplGetPropertyIds( rIds );
1085 29 : }
1086 :
1087 :
1088 36 : VCLXRadioButton::VCLXRadioButton() : maItemListeners( *this ), maActionListeners( *this )
1089 : {
1090 36 : }
1091 :
1092 : // ::com::sun::star::uno::XInterface
1093 4949 : ::com::sun::star::uno::Any VCLXRadioButton::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1094 : {
1095 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
1096 : (static_cast< ::com::sun::star::awt::XRadioButton* >(this)),
1097 4949 : (static_cast< ::com::sun::star::awt::XButton* >(this)) );
1098 4949 : return (aRet.hasValue() ? aRet : VCLXGraphicControl::queryInterface( rType ));
1099 : }
1100 :
1101 : // ::com::sun::star::lang::XTypeProvider
1102 0 : IMPL_XTYPEPROVIDER_START( VCLXRadioButton )
1103 0 : cppu::UnoType<com::sun::star::awt::XRadioButton>::get(),
1104 0 : cppu::UnoType<com::sun::star::awt::XButton>::get(),
1105 : VCLXGraphicControl::getTypes()
1106 0 : IMPL_XTYPEPROVIDER_END
1107 :
1108 15 : ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXRadioButton::CreateAccessibleContext()
1109 : {
1110 15 : return getAccessibleFactory().createAccessibleContext( this );
1111 : }
1112 :
1113 72 : void VCLXRadioButton::dispose() throw(::com::sun::star::uno::RuntimeException, std::exception)
1114 : {
1115 72 : SolarMutexGuard aGuard;
1116 :
1117 144 : ::com::sun::star::lang::EventObject aObj;
1118 72 : aObj.Source = static_cast<cppu::OWeakObject*>(this);
1119 72 : maItemListeners.disposeAndClear( aObj );
1120 144 : VCLXGraphicControl::dispose();
1121 72 : }
1122 :
1123 1575 : void VCLXRadioButton::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
1124 : {
1125 1575 : SolarMutexGuard aGuard;
1126 :
1127 3150 : VclPtr< RadioButton > pButton = GetAs< RadioButton >();
1128 1575 : if ( pButton )
1129 : {
1130 1575 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
1131 1575 : switch ( nPropType )
1132 : {
1133 : case BASEPROPERTY_VISUALEFFECT:
1134 28 : ::toolkit::setVisualEffect( Value, pButton );
1135 28 : break;
1136 :
1137 : case BASEPROPERTY_STATE:
1138 : {
1139 41 : sal_Int16 n = sal_Int16();
1140 41 : if ( Value >>= n )
1141 : {
1142 41 : bool b = n != 0;
1143 41 : if ( pButton->IsRadioCheckEnabled() )
1144 20 : pButton->Check( b );
1145 : else
1146 21 : pButton->SetState( b );
1147 : }
1148 : }
1149 41 : break;
1150 : case BASEPROPERTY_AUTOTOGGLE:
1151 : {
1152 23 : bool b = bool();
1153 23 : if ( Value >>= b )
1154 23 : pButton->EnableRadioCheck( b );
1155 : }
1156 23 : break;
1157 : default:
1158 : {
1159 1483 : VCLXGraphicControl::setProperty( PropertyName, Value );
1160 : }
1161 : }
1162 1575 : }
1163 1575 : }
1164 :
1165 0 : ::com::sun::star::uno::Any VCLXRadioButton::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1166 : {
1167 0 : SolarMutexGuard aGuard;
1168 :
1169 0 : ::com::sun::star::uno::Any aProp;
1170 0 : VclPtr< RadioButton > pButton = GetAs< RadioButton >();
1171 0 : if ( pButton )
1172 : {
1173 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
1174 0 : switch ( nPropType )
1175 : {
1176 : case BASEPROPERTY_VISUALEFFECT:
1177 0 : aProp = ::toolkit::getVisualEffect( pButton );
1178 0 : break;
1179 : case BASEPROPERTY_STATE:
1180 0 : aProp <<= (sal_Int16) ( pButton->IsChecked() ? 1 : 0 );
1181 0 : break;
1182 : case BASEPROPERTY_AUTOTOGGLE:
1183 0 : aProp <<= pButton->IsRadioCheckEnabled();
1184 0 : break;
1185 : default:
1186 : {
1187 0 : aProp <<= VCLXGraphicControl::getProperty( PropertyName );
1188 : }
1189 : }
1190 : }
1191 0 : return aProp;
1192 : }
1193 :
1194 23 : void VCLXRadioButton::addItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1195 : {
1196 23 : SolarMutexGuard aGuard;
1197 23 : maItemListeners.addInterface( l );
1198 23 : }
1199 :
1200 0 : void VCLXRadioButton::removeItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1201 : {
1202 0 : SolarMutexGuard aGuard;
1203 0 : maItemListeners.removeInterface( l );
1204 0 : }
1205 :
1206 1 : void VCLXRadioButton::addActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l )throw(::com::sun::star::uno::RuntimeException, std::exception)
1207 : {
1208 1 : SolarMutexGuard aGuard;
1209 1 : maActionListeners.addInterface( l );
1210 1 : }
1211 :
1212 0 : void VCLXRadioButton::removeActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1213 : {
1214 0 : SolarMutexGuard aGuard;
1215 0 : maActionListeners.removeInterface( l );
1216 0 : }
1217 :
1218 0 : void VCLXRadioButton::setLabel( const OUString& rLabel ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1219 : {
1220 0 : SolarMutexGuard aGuard;
1221 :
1222 0 : vcl::Window* pWindow = GetWindow();
1223 0 : if ( pWindow )
1224 0 : pWindow->SetText( rLabel );
1225 0 : }
1226 :
1227 23 : void VCLXRadioButton::setActionCommand( const OUString& rCommand ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1228 : {
1229 23 : SolarMutexGuard aGuard;
1230 23 : maActionCommand = rCommand;
1231 23 : }
1232 :
1233 0 : void VCLXRadioButton::setState( sal_Bool b ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1234 : {
1235 0 : SolarMutexGuard aGuard;
1236 :
1237 0 : VclPtr< RadioButton > pRadioButton = GetAs< RadioButton >();
1238 0 : if ( pRadioButton)
1239 : {
1240 0 : pRadioButton->Check( b );
1241 : // #102717# item listeners are called, but not C++ click listeners in StarOffice code => call click hdl
1242 : // But this is needed in old code because Accessibility API uses it.
1243 : // pRadioButton->GetClickHdl().Call( pRadioButton );
1244 :
1245 : // #107218# Call same virtual methods and listeners like VCL would do after user interaction
1246 0 : SetSynthesizingVCLEvent( true );
1247 0 : pRadioButton->Click();
1248 0 : SetSynthesizingVCLEvent( false );
1249 0 : }
1250 0 : }
1251 :
1252 15 : sal_Bool VCLXRadioButton::getState() throw(::com::sun::star::uno::RuntimeException, std::exception)
1253 : {
1254 15 : SolarMutexGuard aGuard;
1255 :
1256 30 : VclPtr< RadioButton > pRadioButton = GetAs< RadioButton >();
1257 30 : return pRadioButton ? pRadioButton->IsChecked() : sal_False;
1258 : }
1259 :
1260 4 : ::com::sun::star::awt::Size VCLXRadioButton::getMinimumSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1261 : {
1262 4 : SolarMutexGuard aGuard;
1263 :
1264 4 : Size aSz;
1265 8 : VclPtr< RadioButton > pRadioButton = GetAs< RadioButton >();
1266 4 : if ( pRadioButton )
1267 4 : aSz = pRadioButton->CalcMinimumSize();
1268 8 : return AWTSize(aSz);
1269 : }
1270 :
1271 2 : ::com::sun::star::awt::Size VCLXRadioButton::getPreferredSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1272 : {
1273 2 : return getMinimumSize();
1274 : }
1275 :
1276 2 : ::com::sun::star::awt::Size VCLXRadioButton::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1277 : {
1278 2 : SolarMutexGuard aGuard;
1279 :
1280 2 : Size aSz = VCLSize(rNewSize);
1281 4 : VclPtr< RadioButton > pRadioButton = GetAs< RadioButton >();
1282 2 : if ( pRadioButton )
1283 : {
1284 2 : Size aMinSz = pRadioButton->CalcMinimumSize();
1285 2 : if ( ( aSz.Width() > aMinSz.Width() ) && ( aSz.Height() < aMinSz.Height() ) )
1286 0 : aSz.Height() = aMinSz.Height();
1287 : else
1288 2 : aSz = aMinSz;
1289 : }
1290 4 : return AWTSize(aSz);
1291 : }
1292 :
1293 518 : void VCLXRadioButton::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
1294 : {
1295 518 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
1296 : // since we call listeners below, there is a potential that we will be destroyed
1297 : // in during the listener call. To prevent the resulting crashs, we keep us
1298 : // alive as long as we're here
1299 :
1300 518 : switch ( rVclWindowEvent.GetId() )
1301 : {
1302 : case VCLEVENT_BUTTON_CLICK:
1303 0 : if ( !IsSynthesizingVCLEvent() && maActionListeners.getLength() )
1304 : {
1305 0 : ::com::sun::star::awt::ActionEvent aEvent;
1306 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
1307 0 : aEvent.ActionCommand = maActionCommand;
1308 0 : maActionListeners.actionPerformed( aEvent );
1309 : }
1310 0 : ImplClickedOrToggled( false );
1311 0 : break;
1312 :
1313 : case VCLEVENT_RADIOBUTTON_TOGGLE:
1314 0 : ImplClickedOrToggled( true );
1315 0 : break;
1316 :
1317 : default:
1318 518 : VCLXGraphicControl::ProcessWindowEvent( rVclWindowEvent );
1319 518 : break;
1320 518 : }
1321 518 : }
1322 :
1323 0 : void VCLXRadioButton::ImplClickedOrToggled( bool bToggled )
1324 : {
1325 : // In the formulars, RadioChecked is not enabled, call itemStateChanged only for click
1326 : // In the dialog editor, RadioChecked is enabled, call itemStateChanged only for bToggled
1327 0 : VclPtr< RadioButton > pRadioButton = GetAs< RadioButton >();
1328 0 : if ( pRadioButton && ( pRadioButton->IsRadioCheckEnabled() == bToggled ) && ( bToggled || pRadioButton->IsStateChanged() ) && maItemListeners.getLength() )
1329 : {
1330 0 : ::com::sun::star::awt::ItemEvent aEvent;
1331 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
1332 0 : aEvent.Highlighted = 0;
1333 0 : aEvent.Selected = pRadioButton->IsChecked() ? 1 : 0;
1334 0 : maItemListeners.itemStateChanged( aEvent );
1335 0 : }
1336 0 : }
1337 :
1338 :
1339 : // class VCLXSpinField
1340 :
1341 0 : void VCLXSpinField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
1342 : {
1343 : PushPropertyIds( rIds,
1344 : BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
1345 0 : 0 );
1346 0 : VCLXEdit::ImplGetPropertyIds( rIds );
1347 0 : }
1348 :
1349 98 : VCLXSpinField::VCLXSpinField() : maSpinListeners( *this )
1350 : {
1351 98 : }
1352 :
1353 : // ::com::sun::star::uno::XInterface
1354 29767 : ::com::sun::star::uno::Any VCLXSpinField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1355 : {
1356 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
1357 29767 : (static_cast< ::com::sun::star::awt::XSpinField* >(this)) );
1358 29767 : return (aRet.hasValue() ? aRet : VCLXEdit::queryInterface( rType ));
1359 : }
1360 :
1361 : // ::com::sun::star::lang::XTypeProvider
1362 0 : IMPL_XTYPEPROVIDER_START( VCLXSpinField )
1363 0 : cppu::UnoType<com::sun::star::awt::XSpinField>::get(),
1364 : VCLXEdit::getTypes()
1365 0 : IMPL_XTYPEPROVIDER_END
1366 :
1367 11 : void VCLXSpinField::addSpinListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XSpinListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1368 : {
1369 11 : SolarMutexGuard aGuard;
1370 11 : maSpinListeners.addInterface( l );
1371 11 : }
1372 :
1373 11 : void VCLXSpinField::removeSpinListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XSpinListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1374 : {
1375 11 : SolarMutexGuard aGuard;
1376 11 : maSpinListeners.removeInterface( l );
1377 11 : }
1378 :
1379 22 : void VCLXSpinField::up() throw(::com::sun::star::uno::RuntimeException, std::exception)
1380 : {
1381 22 : SolarMutexGuard aGuard;
1382 :
1383 44 : VclPtr< SpinField > pSpinField = GetAs< SpinField >();
1384 22 : if ( pSpinField )
1385 44 : pSpinField->Up();
1386 22 : }
1387 :
1388 11 : void VCLXSpinField::down() throw(::com::sun::star::uno::RuntimeException, std::exception)
1389 : {
1390 11 : SolarMutexGuard aGuard;
1391 :
1392 22 : VclPtr< SpinField > pSpinField = GetAs< SpinField >();
1393 11 : if ( pSpinField )
1394 22 : pSpinField->Down();
1395 11 : }
1396 :
1397 11 : void VCLXSpinField::first() throw(::com::sun::star::uno::RuntimeException, std::exception)
1398 : {
1399 11 : SolarMutexGuard aGuard;
1400 :
1401 22 : VclPtr< SpinField > pSpinField = GetAs< SpinField >();
1402 11 : if ( pSpinField )
1403 22 : pSpinField->First();
1404 11 : }
1405 :
1406 11 : void VCLXSpinField::last() throw(::com::sun::star::uno::RuntimeException, std::exception)
1407 : {
1408 11 : SolarMutexGuard aGuard;
1409 :
1410 22 : VclPtr< SpinField > pSpinField = GetAs< SpinField >();
1411 11 : if ( pSpinField )
1412 22 : pSpinField->Last();
1413 11 : }
1414 :
1415 128 : void VCLXSpinField::enableRepeat( sal_Bool bRepeat ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1416 : {
1417 128 : SolarMutexGuard aGuard;
1418 :
1419 128 : vcl::Window* pWindow = GetWindow();
1420 128 : if ( pWindow )
1421 : {
1422 128 : WinBits nStyle = pWindow->GetStyle();
1423 128 : if ( bRepeat )
1424 11 : nStyle |= WB_REPEAT;
1425 : else
1426 117 : nStyle &= ~WB_REPEAT;
1427 128 : pWindow->SetStyle( nStyle );
1428 128 : }
1429 128 : }
1430 :
1431 3458 : void VCLXSpinField::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
1432 : {
1433 3458 : switch ( rVclWindowEvent.GetId() )
1434 : {
1435 : case VCLEVENT_SPINFIELD_UP:
1436 : case VCLEVENT_SPINFIELD_DOWN:
1437 : case VCLEVENT_SPINFIELD_FIRST:
1438 : case VCLEVENT_SPINFIELD_LAST:
1439 : {
1440 55 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
1441 : // since we call listeners below, there is a potential that we will be destroyed
1442 : // in during the listener call. To prevent the resulting crashs, we keep us
1443 : // alive as long as we're here
1444 :
1445 55 : if ( maSpinListeners.getLength() )
1446 : {
1447 44 : ::com::sun::star::awt::SpinEvent aEvent;
1448 44 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
1449 44 : switch ( rVclWindowEvent.GetId() )
1450 : {
1451 11 : case VCLEVENT_SPINFIELD_UP: maSpinListeners.up( aEvent );
1452 11 : break;
1453 11 : case VCLEVENT_SPINFIELD_DOWN: maSpinListeners.down( aEvent );
1454 11 : break;
1455 11 : case VCLEVENT_SPINFIELD_FIRST: maSpinListeners.first( aEvent );
1456 11 : break;
1457 11 : case VCLEVENT_SPINFIELD_LAST: maSpinListeners.last( aEvent );
1458 11 : break;
1459 44 : }
1460 :
1461 55 : }
1462 : }
1463 55 : break;
1464 :
1465 : default:
1466 3403 : VCLXEdit::ProcessWindowEvent( rVclWindowEvent );
1467 3403 : break;
1468 : }
1469 3458 : }
1470 :
1471 :
1472 :
1473 : // class VCLXListBox
1474 :
1475 23 : void VCLXListBox::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
1476 : {
1477 : PushPropertyIds( rIds,
1478 : BASEPROPERTY_BACKGROUNDCOLOR,
1479 : BASEPROPERTY_BORDER,
1480 : BASEPROPERTY_BORDERCOLOR,
1481 : BASEPROPERTY_DEFAULTCONTROL,
1482 : BASEPROPERTY_DROPDOWN,
1483 : BASEPROPERTY_ENABLED,
1484 : BASEPROPERTY_ENABLEVISIBLE,
1485 : BASEPROPERTY_FONTDESCRIPTOR,
1486 : BASEPROPERTY_HELPTEXT,
1487 : BASEPROPERTY_HELPURL,
1488 : BASEPROPERTY_LINECOUNT,
1489 : BASEPROPERTY_MULTISELECTION,
1490 : BASEPROPERTY_MULTISELECTION_SIMPLEMODE,
1491 : BASEPROPERTY_ITEM_SEPARATOR_POS,
1492 : BASEPROPERTY_PRINTABLE,
1493 : BASEPROPERTY_SELECTEDITEMS,
1494 : BASEPROPERTY_STRINGITEMLIST,
1495 : BASEPROPERTY_TABSTOP,
1496 : BASEPROPERTY_READONLY,
1497 : BASEPROPERTY_ALIGN,
1498 : BASEPROPERTY_WRITING_MODE,
1499 : BASEPROPERTY_CONTEXT_WRITING_MODE,
1500 : BASEPROPERTY_REFERENCE_DEVICE,
1501 : BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
1502 23 : 0);
1503 23 : VCLXWindow::ImplGetPropertyIds( rIds );
1504 23 : }
1505 :
1506 :
1507 43 : VCLXListBox::VCLXListBox()
1508 : : maActionListeners( *this ),
1509 43 : maItemListeners( *this )
1510 : {
1511 43 : }
1512 :
1513 86 : void VCLXListBox::dispose() throw(::com::sun::star::uno::RuntimeException, std::exception)
1514 : {
1515 86 : SolarMutexGuard aGuard;
1516 :
1517 172 : ::com::sun::star::lang::EventObject aObj;
1518 86 : aObj.Source = static_cast<cppu::OWeakObject*>(this);
1519 86 : maItemListeners.disposeAndClear( aObj );
1520 86 : maActionListeners.disposeAndClear( aObj );
1521 172 : VCLXWindow::dispose();
1522 86 : }
1523 :
1524 21 : void VCLXListBox::addItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1525 : {
1526 21 : SolarMutexGuard aGuard;
1527 21 : maItemListeners.addInterface( l );
1528 21 : }
1529 :
1530 0 : void VCLXListBox::removeItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1531 : {
1532 0 : SolarMutexGuard aGuard;
1533 0 : maItemListeners.removeInterface( l );
1534 0 : }
1535 :
1536 1 : void VCLXListBox::addActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1537 : {
1538 1 : SolarMutexGuard aGuard;
1539 1 : maActionListeners.addInterface( l );
1540 1 : }
1541 :
1542 0 : void VCLXListBox::removeActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1543 : {
1544 0 : SolarMutexGuard aGuard;
1545 0 : maActionListeners.removeInterface( l );
1546 0 : }
1547 :
1548 0 : void VCLXListBox::addItem( const OUString& aItem, sal_Int16 nPos ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1549 : {
1550 0 : SolarMutexGuard aGuard;
1551 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1552 0 : if ( pBox )
1553 0 : pBox->InsertEntry( aItem, nPos );
1554 0 : }
1555 :
1556 0 : void VCLXListBox::addItems( const ::com::sun::star::uno::Sequence< OUString>& aItems, sal_Int16 nPos ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1557 : {
1558 0 : SolarMutexGuard aGuard;
1559 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1560 0 : if ( pBox )
1561 : {
1562 0 : sal_uInt16 nP = nPos;
1563 0 : const OUString* pItems = aItems.getConstArray();
1564 0 : const OUString* pItemsEnd = aItems.getConstArray() + aItems.getLength();
1565 0 : while ( pItems != pItemsEnd )
1566 : {
1567 0 : if ( (sal_uInt16)nP == 0xFFFF )
1568 : {
1569 : OSL_FAIL( "VCLXListBox::addItems: too many entries!" );
1570 : // skip remaining entries, list cannot hold them, anyway
1571 0 : break;
1572 : }
1573 :
1574 0 : pBox->InsertEntry( *pItems++, nP++ );
1575 : }
1576 0 : }
1577 0 : }
1578 :
1579 0 : void VCLXListBox::removeItems( sal_Int16 nPos, sal_Int16 nCount ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1580 : {
1581 0 : SolarMutexGuard aGuard;
1582 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1583 0 : if ( pBox )
1584 : {
1585 0 : for ( sal_uInt16 n = nCount; n; )
1586 0 : pBox->RemoveEntry( nPos + (--n) );
1587 0 : }
1588 0 : }
1589 :
1590 0 : sal_Int16 VCLXListBox::getItemCount() throw(::com::sun::star::uno::RuntimeException, std::exception)
1591 : {
1592 0 : SolarMutexGuard aGuard;
1593 :
1594 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1595 0 : return pBox ? pBox->GetEntryCount() : 0;
1596 : }
1597 :
1598 0 : OUString VCLXListBox::getItem( sal_Int16 nPos ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1599 : {
1600 0 : SolarMutexGuard aGuard;
1601 :
1602 0 : OUString aItem;
1603 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1604 0 : if ( pBox )
1605 0 : aItem = pBox->GetEntry( nPos );
1606 0 : return aItem;
1607 : }
1608 :
1609 0 : ::com::sun::star::uno::Sequence< OUString> VCLXListBox::getItems() throw(::com::sun::star::uno::RuntimeException, std::exception)
1610 : {
1611 0 : SolarMutexGuard aGuard;
1612 :
1613 0 : ::com::sun::star::uno::Sequence< OUString> aSeq;
1614 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1615 0 : if ( pBox )
1616 : {
1617 0 : sal_uInt16 nEntries = pBox->GetEntryCount();
1618 0 : aSeq = ::com::sun::star::uno::Sequence< OUString>( nEntries );
1619 0 : for ( sal_uInt16 n = nEntries; n; )
1620 : {
1621 0 : --n;
1622 0 : aSeq.getArray()[n] = OUString( pBox->GetEntry( n ) );
1623 : }
1624 : }
1625 0 : return aSeq;
1626 : }
1627 :
1628 0 : sal_Int16 VCLXListBox::getSelectedItemPos() throw(::com::sun::star::uno::RuntimeException, std::exception)
1629 : {
1630 0 : SolarMutexGuard aGuard;
1631 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1632 0 : return pBox ? pBox->GetSelectEntryPos() : 0;
1633 : }
1634 :
1635 0 : ::com::sun::star::uno::Sequence<sal_Int16> VCLXListBox::getSelectedItemsPos() throw(::com::sun::star::uno::RuntimeException, std::exception)
1636 : {
1637 0 : SolarMutexGuard aGuard;
1638 :
1639 0 : ::com::sun::star::uno::Sequence<sal_Int16> aSeq;
1640 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1641 0 : if ( pBox )
1642 : {
1643 0 : sal_uInt16 nSelEntries = pBox->GetSelectEntryCount();
1644 0 : aSeq = ::com::sun::star::uno::Sequence<sal_Int16>( nSelEntries );
1645 0 : for ( sal_uInt16 n = 0; n < nSelEntries; n++ )
1646 0 : aSeq.getArray()[n] = pBox->GetSelectEntryPos( n );
1647 : }
1648 0 : return aSeq;
1649 : }
1650 :
1651 0 : OUString VCLXListBox::getSelectedItem() throw(::com::sun::star::uno::RuntimeException, std::exception)
1652 : {
1653 0 : SolarMutexGuard aGuard;
1654 :
1655 0 : OUString aItem;
1656 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1657 0 : if ( pBox )
1658 0 : aItem = pBox->GetSelectEntry();
1659 0 : return aItem;
1660 : }
1661 :
1662 0 : ::com::sun::star::uno::Sequence< OUString> VCLXListBox::getSelectedItems() throw(::com::sun::star::uno::RuntimeException, std::exception)
1663 : {
1664 0 : SolarMutexGuard aGuard;
1665 :
1666 0 : ::com::sun::star::uno::Sequence< OUString> aSeq;
1667 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1668 0 : if ( pBox )
1669 : {
1670 0 : sal_uInt16 nSelEntries = pBox->GetSelectEntryCount();
1671 0 : aSeq = ::com::sun::star::uno::Sequence< OUString>( nSelEntries );
1672 0 : for ( sal_uInt16 n = 0; n < nSelEntries; n++ )
1673 0 : aSeq.getArray()[n] = OUString( pBox->GetSelectEntry( n ) );
1674 : }
1675 0 : return aSeq;
1676 : }
1677 :
1678 0 : void VCLXListBox::selectItemPos( sal_Int16 nPos, sal_Bool bSelect ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1679 : {
1680 0 : SolarMutexGuard aGuard;
1681 :
1682 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1683 0 : if ( pBox && ( pBox->IsEntryPosSelected( nPos ) != bool(bSelect) ) )
1684 : {
1685 0 : pBox->SelectEntryPos( nPos, bSelect );
1686 :
1687 : // VCL doesn't call select handler after API call.
1688 : // ImplCallItemListeners();
1689 :
1690 : // #107218# Call same listeners like VCL would do after user interaction
1691 0 : SetSynthesizingVCLEvent( true );
1692 0 : pBox->Select();
1693 0 : SetSynthesizingVCLEvent( false );
1694 0 : }
1695 0 : }
1696 :
1697 53 : void VCLXListBox::selectItemsPos( const ::com::sun::star::uno::Sequence<sal_Int16>& aPositions, sal_Bool bSelect ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1698 : {
1699 53 : SolarMutexGuard aGuard;
1700 :
1701 106 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1702 53 : if ( pBox )
1703 : {
1704 53 : bool bChanged = false;
1705 245 : for ( sal_uInt16 n = (sal_uInt16)aPositions.getLength(); n; )
1706 : {
1707 139 : sal_uInt16 nPos = (sal_uInt16) aPositions.getConstArray()[--n];
1708 139 : if ( pBox->IsEntryPosSelected( nPos ) != bool(bSelect) )
1709 : {
1710 139 : pBox->SelectEntryPos( nPos, bSelect );
1711 139 : bChanged = true;
1712 : }
1713 : }
1714 :
1715 53 : if ( bChanged )
1716 : {
1717 : // VCL doesn't call select handler after API call.
1718 : // ImplCallItemListeners();
1719 :
1720 : // #107218# Call same listeners like VCL would do after user interaction
1721 53 : SetSynthesizingVCLEvent( true );
1722 53 : pBox->Select();
1723 53 : SetSynthesizingVCLEvent( false );
1724 : }
1725 53 : }
1726 53 : }
1727 :
1728 0 : void VCLXListBox::selectItem( const OUString& rItemText, sal_Bool bSelect ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1729 : {
1730 0 : SolarMutexGuard aGuard;
1731 :
1732 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1733 0 : if ( pBox )
1734 : {
1735 0 : OUString aItemText( rItemText );
1736 0 : selectItemPos( pBox->GetEntryPos( aItemText ), bSelect );
1737 0 : }
1738 0 : }
1739 :
1740 0 : void VCLXListBox::setDropDownLineCount( sal_Int16 nLines ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1741 : {
1742 0 : SolarMutexGuard aGuard;
1743 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1744 0 : if ( pBox )
1745 0 : pBox->SetDropDownLineCount( nLines );
1746 0 : }
1747 :
1748 0 : sal_Int16 VCLXListBox::getDropDownLineCount() throw(::com::sun::star::uno::RuntimeException, std::exception)
1749 : {
1750 0 : SolarMutexGuard aGuard;
1751 :
1752 0 : sal_Int16 nLines = 0;
1753 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1754 0 : if ( pBox )
1755 0 : nLines = pBox->GetDropDownLineCount();
1756 0 : return nLines;
1757 : }
1758 :
1759 0 : sal_Bool VCLXListBox::isMutipleMode() throw(::com::sun::star::uno::RuntimeException, std::exception)
1760 : {
1761 0 : SolarMutexGuard aGuard;
1762 0 : bool bMulti = false;
1763 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1764 0 : if ( pBox )
1765 0 : bMulti = pBox->IsMultiSelectionEnabled();
1766 0 : return bMulti;
1767 : }
1768 :
1769 0 : void VCLXListBox::setMultipleMode( sal_Bool bMulti ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1770 : {
1771 0 : SolarMutexGuard aGuard;
1772 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1773 0 : if ( pBox )
1774 0 : pBox->EnableMultiSelection( bMulti );
1775 0 : }
1776 :
1777 0 : void VCLXListBox::makeVisible( sal_Int16 nEntry ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1778 : {
1779 0 : SolarMutexGuard aGuard;
1780 0 : VclPtr< ListBox > pBox = GetAs< ListBox >();
1781 0 : if ( pBox )
1782 0 : pBox->SetTopEntry( nEntry );
1783 0 : }
1784 :
1785 9427 : void VCLXListBox::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
1786 : {
1787 9427 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
1788 : // since we call listeners below, there is a potential that we will be destroyed
1789 : // in during the listener call. To prevent the resulting crashs, we keep us
1790 : // alive as long as we're here
1791 :
1792 9427 : switch ( rVclWindowEvent.GetId() )
1793 : {
1794 : case VCLEVENT_LISTBOX_SELECT:
1795 : {
1796 12 : VclPtr< ListBox > pListBox = GetAs< ListBox >();
1797 12 : if( pListBox )
1798 : {
1799 12 : bool bDropDown = ( pListBox->GetStyle() & WB_DROPDOWN ) != 0;
1800 12 : if ( bDropDown && !IsSynthesizingVCLEvent() && maActionListeners.getLength() )
1801 : {
1802 : // Call ActionListener on DropDown event
1803 0 : ::com::sun::star::awt::ActionEvent aEvent;
1804 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
1805 0 : aEvent.ActionCommand = pListBox->GetSelectEntry();
1806 0 : maActionListeners.actionPerformed( aEvent );
1807 : }
1808 :
1809 12 : if ( maItemListeners.getLength() )
1810 : {
1811 0 : ImplCallItemListeners();
1812 : }
1813 12 : }
1814 : }
1815 12 : break;
1816 :
1817 : case VCLEVENT_LISTBOX_DOUBLECLICK:
1818 0 : if ( GetWindow() && maActionListeners.getLength() )
1819 : {
1820 0 : ::com::sun::star::awt::ActionEvent aEvent;
1821 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
1822 0 : aEvent.ActionCommand = GetAs<ListBox>()->GetSelectEntry();
1823 0 : maActionListeners.actionPerformed( aEvent );
1824 : }
1825 0 : break;
1826 :
1827 : default:
1828 9415 : VCLXWindow::ProcessWindowEvent( rVclWindowEvent );
1829 9415 : break;
1830 9427 : }
1831 9427 : }
1832 :
1833 5 : ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXListBox::CreateAccessibleContext()
1834 : {
1835 5 : SolarMutexGuard aGuard;
1836 :
1837 5 : return getAccessibleFactory().createAccessibleContext( this );
1838 : }
1839 :
1840 1807 : void VCLXListBox::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
1841 : {
1842 1807 : SolarMutexGuard aGuard;
1843 3614 : VclPtr< ListBox > pListBox = GetAs< ListBox >();
1844 1807 : if ( pListBox )
1845 : {
1846 1807 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
1847 1807 : switch ( nPropType )
1848 : {
1849 : case BASEPROPERTY_ITEM_SEPARATOR_POS:
1850 : {
1851 21 : sal_Int16 nSeparatorPos(0);
1852 21 : if ( Value >>= nSeparatorPos )
1853 0 : pListBox->SetSeparatorPos( nSeparatorPos );
1854 : }
1855 21 : break;
1856 : case BASEPROPERTY_READONLY:
1857 : {
1858 29 : bool b = bool();
1859 29 : if ( Value >>= b )
1860 29 : pListBox->SetReadOnly( b);
1861 : }
1862 29 : break;
1863 : case BASEPROPERTY_MULTISELECTION:
1864 : {
1865 33 : bool b = bool();
1866 33 : if ( Value >>= b )
1867 33 : pListBox->EnableMultiSelection( b );
1868 : }
1869 33 : break;
1870 : case BASEPROPERTY_MULTISELECTION_SIMPLEMODE:
1871 28 : ::toolkit::adjustBooleanWindowStyle( Value, pListBox, WB_SIMPLEMODE, false );
1872 28 : break;
1873 : case BASEPROPERTY_LINECOUNT:
1874 : {
1875 25 : sal_Int16 n = sal_Int16();
1876 25 : if ( Value >>= n )
1877 25 : pListBox->SetDropDownLineCount( n );
1878 : }
1879 25 : break;
1880 : case BASEPROPERTY_STRINGITEMLIST:
1881 : {
1882 0 : ::com::sun::star::uno::Sequence< OUString> aItems;
1883 0 : if ( Value >>= aItems )
1884 : {
1885 0 : pListBox->Clear();
1886 0 : addItems( aItems, 0 );
1887 0 : }
1888 : }
1889 0 : break;
1890 : case BASEPROPERTY_SELECTEDITEMS:
1891 : {
1892 87 : ::com::sun::star::uno::Sequence<sal_Int16> aItems;
1893 87 : if ( Value >>= aItems )
1894 : {
1895 276 : for ( sal_uInt16 n = pListBox->GetEntryCount(); n; )
1896 102 : pListBox->SelectEntryPos( --n, false );
1897 :
1898 87 : if ( aItems.getLength() )
1899 53 : selectItemsPos( aItems, sal_True );
1900 : else
1901 34 : pListBox->SetNoSelection();
1902 :
1903 87 : if ( !pListBox->GetSelectEntryCount() )
1904 84 : pListBox->SetTopEntry( 0 );
1905 87 : }
1906 : }
1907 87 : break;
1908 : default:
1909 : {
1910 1584 : VCLXWindow::setProperty( PropertyName, Value );
1911 : }
1912 : }
1913 1807 : }
1914 1807 : }
1915 :
1916 0 : ::com::sun::star::uno::Any VCLXListBox::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1917 : {
1918 0 : SolarMutexGuard aGuard;
1919 0 : ::com::sun::star::uno::Any aProp;
1920 0 : VclPtr< ListBox > pListBox = GetAs< ListBox >();
1921 0 : if ( pListBox )
1922 : {
1923 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
1924 0 : switch ( nPropType )
1925 : {
1926 : case BASEPROPERTY_ITEM_SEPARATOR_POS:
1927 0 : aProp <<= sal_Int16( pListBox->GetSeparatorPos() );
1928 0 : break;
1929 : case BASEPROPERTY_READONLY:
1930 : {
1931 0 : aProp <<= pListBox->IsReadOnly();
1932 : }
1933 0 : break;
1934 : case BASEPROPERTY_MULTISELECTION:
1935 : {
1936 0 : aProp <<= pListBox->IsMultiSelectionEnabled();
1937 : }
1938 0 : break;
1939 : case BASEPROPERTY_MULTISELECTION_SIMPLEMODE:
1940 : {
1941 0 : aProp <<= ( ( pListBox->GetStyle() & WB_SIMPLEMODE ) == 0 );
1942 : }
1943 0 : break;
1944 : case BASEPROPERTY_LINECOUNT:
1945 : {
1946 0 : aProp <<= (sal_Int16) pListBox->GetDropDownLineCount();
1947 : }
1948 0 : break;
1949 : case BASEPROPERTY_STRINGITEMLIST:
1950 : {
1951 0 : sal_uInt16 nItems = pListBox->GetEntryCount();
1952 0 : ::com::sun::star::uno::Sequence< OUString> aSeq( nItems );
1953 0 : OUString* pStrings = aSeq.getArray();
1954 0 : for ( sal_uInt16 n = 0; n < nItems; n++ )
1955 0 : pStrings[n] = pListBox->GetEntry( n );
1956 0 : aProp <<= aSeq;
1957 :
1958 : }
1959 0 : break;
1960 : default:
1961 : {
1962 0 : aProp <<= VCLXWindow::getProperty( PropertyName );
1963 : }
1964 : }
1965 : }
1966 0 : return aProp;
1967 : }
1968 :
1969 0 : ::com::sun::star::awt::Size VCLXListBox::getMinimumSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1970 : {
1971 0 : SolarMutexGuard aGuard;
1972 0 : Size aSz;
1973 0 : VclPtr< ListBox > pListBox = GetAs< ListBox >();
1974 0 : if ( pListBox )
1975 0 : aSz = pListBox->CalcMinimumSize();
1976 0 : return AWTSize(aSz);
1977 : }
1978 :
1979 0 : ::com::sun::star::awt::Size VCLXListBox::getPreferredSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1980 : {
1981 0 : SolarMutexGuard aGuard;
1982 0 : Size aSz;
1983 0 : VclPtr< ListBox > pListBox = GetAs< ListBox >();
1984 0 : if ( pListBox )
1985 : {
1986 0 : aSz = pListBox->CalcMinimumSize();
1987 0 : if ( pListBox->GetStyle() & WB_DROPDOWN )
1988 0 : aSz.Height() += 4;
1989 : }
1990 0 : return AWTSize(aSz);
1991 : }
1992 :
1993 0 : ::com::sun::star::awt::Size VCLXListBox::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException, std::exception)
1994 : {
1995 0 : SolarMutexGuard aGuard;
1996 0 : Size aSz = VCLSize(rNewSize);
1997 0 : VclPtr< ListBox > pListBox = GetAs< ListBox >();
1998 0 : if ( pListBox )
1999 0 : aSz = pListBox->CalcAdjustedSize( aSz );
2000 0 : return AWTSize(aSz);
2001 : }
2002 :
2003 0 : ::com::sun::star::awt::Size VCLXListBox::getMinimumSize( sal_Int16 nCols, sal_Int16 nLines ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2004 : {
2005 0 : SolarMutexGuard aGuard;
2006 0 : Size aSz;
2007 0 : VclPtr< ListBox > pListBox = GetAs< ListBox >();
2008 0 : if ( pListBox )
2009 0 : aSz = pListBox->CalcBlockSize( nCols, nLines );
2010 0 : return AWTSize(aSz);
2011 : }
2012 :
2013 0 : void VCLXListBox::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2014 : {
2015 0 : SolarMutexGuard aGuard;
2016 0 : nCols = nLines = 0;
2017 0 : VclPtr< ListBox > pListBox = GetAs< ListBox >();
2018 0 : if ( pListBox )
2019 : {
2020 : sal_uInt16 nC, nL;
2021 0 : pListBox->GetMaxVisColumnsAndLines( nC, nL );
2022 0 : nCols = nC;
2023 0 : nLines = nL;
2024 0 : }
2025 0 : }
2026 :
2027 0 : void VCLXListBox::ImplCallItemListeners()
2028 : {
2029 0 : VclPtr< ListBox > pListBox = GetAs< ListBox >();
2030 0 : if ( pListBox && maItemListeners.getLength() )
2031 : {
2032 0 : ::com::sun::star::awt::ItemEvent aEvent;
2033 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
2034 0 : aEvent.Highlighted = 0;
2035 :
2036 : // Set to 0xFFFF on multiple selection, selected entry ID otherwise
2037 0 : aEvent.Selected = (pListBox->GetSelectEntryCount() == 1 ) ? pListBox->GetSelectEntryPos() : 0xFFFF;
2038 :
2039 0 : maItemListeners.itemStateChanged( aEvent );
2040 0 : }
2041 0 : }
2042 : namespace
2043 : {
2044 149 : Image lcl_getImageFromURL( const OUString& i_rImageURL )
2045 : {
2046 149 : if ( i_rImageURL.isEmpty() )
2047 149 : return Image();
2048 :
2049 : try
2050 : {
2051 0 : Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
2052 0 : Reference< XGraphicProvider > xProvider(graphic::GraphicProvider::create(xContext));
2053 0 : ::comphelper::NamedValueCollection aMediaProperties;
2054 0 : aMediaProperties.put( "URL", i_rImageURL );
2055 0 : Reference< XGraphic > xGraphic = xProvider->queryGraphic( aMediaProperties.getPropertyValues() );
2056 0 : return Image( xGraphic );
2057 : }
2058 0 : catch( const uno::Exception& )
2059 : {
2060 : DBG_UNHANDLED_EXCEPTION();
2061 : }
2062 0 : return Image();
2063 : }
2064 : }
2065 0 : void SAL_CALL VCLXListBox::listItemInserted( const ItemListEvent& i_rEvent ) throw (RuntimeException, std::exception)
2066 : {
2067 0 : SolarMutexGuard aGuard;
2068 0 : VclPtr< ListBox > pListBox = GetAs< ListBox >();
2069 :
2070 0 : ENSURE_OR_RETURN_VOID( pListBox, "VCLXListBox::listItemInserted: no ListBox?!" );
2071 0 : ENSURE_OR_RETURN_VOID( ( i_rEvent.ItemPosition >= 0 ) && ( i_rEvent.ItemPosition <= sal_Int32( pListBox->GetEntryCount() ) ),
2072 : "VCLXListBox::listItemInserted: illegal (inconsistent) item position!" );
2073 : pListBox->InsertEntry(
2074 : i_rEvent.ItemText.IsPresent ? i_rEvent.ItemText.Value : OUString(),
2075 : i_rEvent.ItemImageURL.IsPresent ? TkResMgr::getImageFromURL( i_rEvent.ItemImageURL.Value ) : Image(),
2076 0 : i_rEvent.ItemPosition );
2077 : }
2078 :
2079 0 : void SAL_CALL VCLXListBox::listItemRemoved( const ItemListEvent& i_rEvent ) throw (RuntimeException, std::exception)
2080 : {
2081 0 : SolarMutexGuard aGuard;
2082 0 : VclPtr< ListBox > pListBox = GetAs< ListBox >();
2083 :
2084 0 : ENSURE_OR_RETURN_VOID( pListBox, "VCLXListBox::listItemRemoved: no ListBox?!" );
2085 0 : ENSURE_OR_RETURN_VOID( ( i_rEvent.ItemPosition >= 0 ) && ( i_rEvent.ItemPosition < sal_Int32( pListBox->GetEntryCount() ) ),
2086 : "VCLXListBox::listItemRemoved: illegal (inconsistent) item position!" );
2087 :
2088 0 : pListBox->RemoveEntry( i_rEvent.ItemPosition );
2089 : }
2090 :
2091 0 : void SAL_CALL VCLXListBox::listItemModified( const ItemListEvent& i_rEvent ) throw (RuntimeException, std::exception)
2092 : {
2093 0 : SolarMutexGuard aGuard;
2094 0 : VclPtr< ListBox > pListBox = GetAs< ListBox >();
2095 :
2096 0 : ENSURE_OR_RETURN_VOID( pListBox, "VCLXListBox::listItemModified: no ListBox?!" );
2097 0 : ENSURE_OR_RETURN_VOID( ( i_rEvent.ItemPosition >= 0 ) && ( i_rEvent.ItemPosition < sal_Int32( pListBox->GetEntryCount() ) ),
2098 : "VCLXListBox::listItemModified: illegal (inconsistent) item position!" );
2099 :
2100 : // VCL's ListBox does not support changing an entry's text or image, so remove and re-insert
2101 :
2102 0 : const OUString sNewText = i_rEvent.ItemText.IsPresent ? i_rEvent.ItemText.Value : OUString( pListBox->GetEntry( i_rEvent.ItemPosition ) );
2103 0 : const Image aNewImage( i_rEvent.ItemImageURL.IsPresent ? TkResMgr::getImageFromURL( i_rEvent.ItemImageURL.Value ) : pListBox->GetEntryImage( i_rEvent.ItemPosition ) );
2104 :
2105 0 : pListBox->RemoveEntry( i_rEvent.ItemPosition );
2106 0 : pListBox->InsertEntry( sNewText, aNewImage, i_rEvent.ItemPosition );
2107 : }
2108 :
2109 0 : void SAL_CALL VCLXListBox::allItemsRemoved( const EventObject& i_rEvent ) throw (RuntimeException, std::exception)
2110 : {
2111 0 : SolarMutexGuard aGuard;
2112 :
2113 0 : VclPtr< ListBox > pListBox = GetAs< ListBox >();
2114 0 : ENSURE_OR_RETURN_VOID( pListBox, "VCLXListBox::listItemModified: no ListBox?!" );
2115 :
2116 0 : pListBox->Clear();
2117 :
2118 0 : (void)i_rEvent;
2119 : }
2120 :
2121 40 : void SAL_CALL VCLXListBox::itemListChanged( const EventObject& i_rEvent ) throw (RuntimeException, std::exception)
2122 : {
2123 40 : SolarMutexGuard aGuard;
2124 :
2125 80 : VclPtr< ListBox > pListBox = GetAs< ListBox >();
2126 80 : ENSURE_OR_RETURN_VOID( pListBox, "VCLXListBox::listItemModified: no ListBox?!" );
2127 :
2128 40 : pListBox->Clear();
2129 :
2130 80 : uno::Reference< beans::XPropertySet > xPropSet( i_rEvent.Source, uno::UNO_QUERY_THROW );
2131 80 : uno::Reference< beans::XPropertySetInfo > xPSI( xPropSet->getPropertySetInfo(), uno::UNO_QUERY_THROW );
2132 80 : uno::Reference< resource::XStringResourceResolver > xStringResourceResolver;
2133 40 : if ( xPSI->hasPropertyByName("ResourceResolver") )
2134 : {
2135 : xStringResourceResolver.set(
2136 5 : xPropSet->getPropertyValue("ResourceResolver"),
2137 : uno::UNO_QUERY
2138 5 : );
2139 : }
2140 :
2141 :
2142 80 : Reference< XItemList > xItemList( i_rEvent.Source, uno::UNO_QUERY_THROW );
2143 80 : uno::Sequence< beans::Pair< OUString, OUString > > aItems = xItemList->getAllItems();
2144 96 : for ( sal_Int32 i=0; i<aItems.getLength(); ++i )
2145 : {
2146 56 : OUString aLocalizationKey( aItems[i].First );
2147 56 : if ( xStringResourceResolver.is() && aLocalizationKey.startsWith("&") )
2148 : {
2149 0 : aLocalizationKey = xStringResourceResolver->resolveString(aLocalizationKey.copy( 1 ));
2150 : }
2151 56 : pListBox->InsertEntry( aLocalizationKey, lcl_getImageFromURL( aItems[i].Second ) );
2152 96 : }
2153 : }
2154 :
2155 5 : void SAL_CALL VCLXListBox::disposing( const EventObject& i_rEvent ) throw (RuntimeException, std::exception)
2156 : {
2157 : // just disambiguate
2158 5 : VCLXWindow::disposing( i_rEvent );
2159 5 : }
2160 :
2161 :
2162 : // class VCLXMessageBox
2163 :
2164 :
2165 0 : void VCLXMessageBox::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2166 : {
2167 0 : VCLXTopWindow::ImplGetPropertyIds( rIds );
2168 0 : }
2169 :
2170 0 : VCLXMessageBox::VCLXMessageBox()
2171 : {
2172 0 : }
2173 :
2174 0 : VCLXMessageBox::~VCLXMessageBox()
2175 : {
2176 0 : }
2177 :
2178 : // ::com::sun::star::uno::XInterface
2179 0 : ::com::sun::star::uno::Any VCLXMessageBox::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2180 : {
2181 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
2182 0 : (static_cast< ::com::sun::star::awt::XMessageBox* >(this)) );
2183 0 : return (aRet.hasValue() ? aRet : VCLXTopWindow::queryInterface( rType ));
2184 : }
2185 :
2186 : // ::com::sun::star::lang::XTypeProvider
2187 0 : IMPL_XTYPEPROVIDER_START( VCLXMessageBox )
2188 0 : cppu::UnoType<com::sun::star::awt::XMessageBox>::get(),
2189 : VCLXTopWindow::getTypes()
2190 0 : IMPL_XTYPEPROVIDER_END
2191 :
2192 0 : void VCLXMessageBox::setCaptionText( const OUString& rText ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2193 : {
2194 0 : SolarMutexGuard aGuard;
2195 :
2196 0 : vcl::Window* pWindow = GetWindow();
2197 0 : if ( pWindow )
2198 0 : pWindow->SetText( rText );
2199 0 : }
2200 :
2201 0 : OUString VCLXMessageBox::getCaptionText() throw(::com::sun::star::uno::RuntimeException, std::exception)
2202 : {
2203 0 : SolarMutexGuard aGuard;
2204 :
2205 0 : OUString aText;
2206 0 : vcl::Window* pWindow = GetWindow();
2207 0 : if ( pWindow )
2208 0 : aText = pWindow->GetText();
2209 0 : return aText;
2210 : }
2211 :
2212 0 : void VCLXMessageBox::setMessageText( const OUString& rText ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2213 : {
2214 0 : SolarMutexGuard aGuard;
2215 0 : VclPtr< MessBox > pBox = GetAs< MessBox >();
2216 0 : if ( pBox )
2217 0 : pBox->SetMessText( rText );
2218 0 : }
2219 :
2220 0 : OUString VCLXMessageBox::getMessageText() throw(::com::sun::star::uno::RuntimeException, std::exception)
2221 : {
2222 0 : SolarMutexGuard aGuard;
2223 0 : OUString aText;
2224 0 : VclPtr< MessBox > pBox = GetAs< MessBox >();
2225 0 : if ( pBox )
2226 0 : aText = pBox->GetMessText();
2227 0 : return aText;
2228 : }
2229 :
2230 0 : sal_Int16 VCLXMessageBox::execute() throw(::com::sun::star::uno::RuntimeException, std::exception)
2231 : {
2232 0 : SolarMutexGuard aGuard;
2233 0 : VclPtr< MessBox > pBox = GetAs< MessBox >();
2234 0 : return pBox ? pBox->Execute() : 0;
2235 : }
2236 :
2237 0 : ::com::sun::star::awt::Size SAL_CALL VCLXMessageBox::getMinimumSize() throw(::com::sun::star::uno::RuntimeException, std::exception)
2238 : {
2239 0 : SolarMutexGuard aGuard;
2240 0 : return ::com::sun::star::awt::Size( 250, 100 );
2241 : }
2242 :
2243 :
2244 : // class VCLXDialog
2245 :
2246 0 : void VCLXDialog::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2247 : {
2248 0 : VCLXTopWindow::ImplGetPropertyIds( rIds );
2249 0 : }
2250 :
2251 9 : VCLXDialog::VCLXDialog()
2252 : {
2253 : OSL_TRACE("XDialog created");
2254 9 : }
2255 :
2256 18 : VCLXDialog::~VCLXDialog()
2257 : {
2258 : OSL_TRACE ("%s", __FUNCTION__);
2259 18 : }
2260 :
2261 : // ::com::sun::star::uno::XInterface
2262 296 : ::com::sun::star::uno::Any VCLXDialog::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2263 : {
2264 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
2265 : (static_cast< ::com::sun::star::awt::XDialog2* >(this)),
2266 296 : (static_cast< ::com::sun::star::awt::XDialog* >(this)) );
2267 296 : return (aRet.hasValue() ? aRet : VCLXTopWindow::queryInterface( rType ));
2268 : }
2269 :
2270 : // ::com::sun::star::lang::XTypeProvider
2271 0 : IMPL_XTYPEPROVIDER_START( VCLXDialog )
2272 0 : cppu::UnoType<com::sun::star::awt::XDialog2>::get(),
2273 0 : cppu::UnoType<com::sun::star::awt::XDialog>::get(),
2274 : VCLXTopWindow::getTypes()
2275 0 : IMPL_XTYPEPROVIDER_END
2276 :
2277 0 : void SAL_CALL VCLXDialog::endDialog( ::sal_Int32 i_result ) throw (RuntimeException, std::exception)
2278 : {
2279 0 : SolarMutexGuard aGuard;
2280 0 : VclPtr<Dialog> pDialog = GetAsDynamic< Dialog >();
2281 0 : if ( pDialog )
2282 0 : pDialog->EndDialog( i_result );
2283 0 : }
2284 :
2285 0 : void SAL_CALL VCLXDialog::setHelpId( const OUString& rId ) throw (RuntimeException, std::exception)
2286 : {
2287 0 : SolarMutexGuard aGuard;
2288 0 : VclPtr< vcl::Window > pWindow = GetWindow();
2289 0 : if ( pWindow )
2290 0 : pWindow->SetHelpId( OUStringToOString( rId, RTL_TEXTENCODING_UTF8 ) );
2291 0 : }
2292 :
2293 0 : void VCLXDialog::setTitle( const OUString& Title ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2294 : {
2295 0 : SolarMutexGuard aGuard;
2296 0 : VclPtr< vcl::Window > pWindow = GetWindow();
2297 0 : if ( pWindow )
2298 0 : pWindow->SetText( Title );
2299 0 : }
2300 :
2301 0 : OUString VCLXDialog::getTitle() throw(::com::sun::star::uno::RuntimeException, std::exception)
2302 : {
2303 0 : SolarMutexGuard aGuard;
2304 :
2305 0 : OUString aTitle;
2306 0 : VclPtr< vcl::Window > pWindow = GetWindow();
2307 0 : if ( pWindow )
2308 0 : aTitle = pWindow->GetText();
2309 0 : return aTitle;
2310 : }
2311 :
2312 0 : sal_Int16 VCLXDialog::execute() throw(::com::sun::star::uno::RuntimeException, std::exception)
2313 : {
2314 0 : SolarMutexGuard aGuard;
2315 :
2316 0 : sal_Int16 nRet = 0;
2317 0 : if ( GetWindow() )
2318 : {
2319 0 : VclPtr< Dialog > pDlg = GetAs< Dialog >();
2320 0 : vcl::Window* pParent = pDlg->GetWindow( GetWindowType::ParentOverlap );
2321 0 : vcl::Window* pOldParent = NULL;
2322 0 : vcl::Window* pSetParent = NULL;
2323 0 : if ( pParent && !pParent->IsReallyVisible() )
2324 : {
2325 0 : pOldParent = pDlg->GetParent();
2326 0 : vcl::Window* pFrame = pDlg->GetWindow( GetWindowType::Frame );
2327 0 : if( pFrame != pDlg )
2328 : {
2329 0 : pDlg->SetParent( pFrame );
2330 0 : pSetParent = pFrame;
2331 : }
2332 : }
2333 :
2334 0 : nRet = pDlg->Execute();
2335 :
2336 : // set the parent back only in case no new parent was set from outside
2337 : // in other words, revert only own changes
2338 0 : if ( pOldParent && pDlg->GetParent() == pSetParent )
2339 0 : pDlg->SetParent( pOldParent );
2340 : }
2341 0 : return nRet;
2342 : }
2343 :
2344 0 : void VCLXDialog::endExecute() throw(::com::sun::star::uno::RuntimeException, std::exception)
2345 : {
2346 0 : endDialog(0);
2347 0 : }
2348 :
2349 0 : void SAL_CALL VCLXDialog::draw( sal_Int32 nX, sal_Int32 nY ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2350 : {
2351 0 : SolarMutexGuard aGuard;
2352 0 : VclPtr< vcl::Window > pWindow = GetWindow();
2353 0 : if ( pWindow )
2354 : {
2355 0 : OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( getGraphics() );
2356 0 : if ( !pDev )
2357 0 : pDev = pWindow->GetParent();
2358 :
2359 0 : Size aSize = pDev->PixelToLogic( pWindow->GetSizePixel() );
2360 0 : Point aPos = pDev->PixelToLogic( Point( nX, nY ) );
2361 :
2362 0 : pWindow->Draw( pDev, aPos, aSize, DrawFlags::NoControls );
2363 0 : }
2364 0 : }
2365 :
2366 0 : ::com::sun::star::awt::DeviceInfo VCLXDialog::getInfo() throw(::com::sun::star::uno::RuntimeException, std::exception)
2367 : {
2368 0 : ::com::sun::star::awt::DeviceInfo aInfo = VCLXDevice::getInfo();
2369 :
2370 0 : SolarMutexGuard aGuard;
2371 0 : VclPtr< Dialog > pDlg = GetAs< Dialog >();
2372 0 : if ( pDlg )
2373 0 : pDlg->GetDrawWindowBorder( aInfo.LeftInset, aInfo.TopInset, aInfo.RightInset, aInfo.BottomInset );
2374 :
2375 0 : return aInfo;
2376 : }
2377 :
2378 212 : void SAL_CALL VCLXDialog::setProperty(
2379 : const OUString& PropertyName,
2380 : const ::com::sun::star::uno::Any& Value )
2381 : throw(::com::sun::star::uno::RuntimeException, std::exception)
2382 : {
2383 212 : SolarMutexGuard aGuard;
2384 424 : VclPtr< Dialog > pDialog = GetAs< Dialog >();
2385 212 : if ( pDialog )
2386 : {
2387 212 : bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
2388 :
2389 212 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
2390 212 : switch ( nPropType )
2391 : {
2392 : case BASEPROPERTY_GRAPHIC:
2393 : {
2394 4 : Reference< XGraphic > xGraphic;
2395 4 : if (( Value >>= xGraphic ) && xGraphic.is() )
2396 : {
2397 0 : Image aImage( xGraphic );
2398 :
2399 0 : Wallpaper aWallpaper( aImage.GetBitmapEx());
2400 0 : aWallpaper.SetStyle( WALLPAPER_SCALE );
2401 0 : pDialog->SetBackground( aWallpaper );
2402 : }
2403 4 : else if ( bVoid || !xGraphic.is() )
2404 : {
2405 4 : Color aColor = pDialog->GetControlBackground().GetColor();
2406 4 : if ( aColor == COL_AUTO )
2407 0 : aColor = pDialog->GetSettings().GetStyleSettings().GetDialogColor();
2408 :
2409 4 : Wallpaper aWallpaper( aColor );
2410 4 : pDialog->SetBackground( aWallpaper );
2411 4 : }
2412 : }
2413 4 : break;
2414 :
2415 : default:
2416 : {
2417 208 : VCLXContainer::setProperty( PropertyName, Value );
2418 : }
2419 : }
2420 212 : }
2421 212 : }
2422 :
2423 :
2424 :
2425 : // class VCLXTabPage
2426 :
2427 0 : VCLXMultiPage::VCLXMultiPage() : maTabListeners( *this ), mTabId( 1 )
2428 : {
2429 : OSL_TRACE("VCLXMultiPage::VCLXMultiPage()" );
2430 0 : }
2431 :
2432 0 : void VCLXMultiPage::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2433 : {
2434 : PushPropertyIds( rIds,
2435 : BASEPROPERTY_BACKGROUNDCOLOR,
2436 : BASEPROPERTY_DEFAULTCONTROL,
2437 : BASEPROPERTY_ENABLED,
2438 : BASEPROPERTY_MULTIPAGEVALUE,
2439 : BASEPROPERTY_ENABLEVISIBLE,
2440 : BASEPROPERTY_FONTDESCRIPTOR,
2441 : BASEPROPERTY_GRAPHIC,
2442 : BASEPROPERTY_HELPTEXT,
2443 : BASEPROPERTY_HELPURL,
2444 : BASEPROPERTY_IMAGEALIGN,
2445 : BASEPROPERTY_IMAGEPOSITION,
2446 : BASEPROPERTY_IMAGEURL,
2447 : BASEPROPERTY_PRINTABLE,
2448 : BASEPROPERTY_TABSTOP,
2449 : BASEPROPERTY_FOCUSONCLICK,
2450 0 : 0);
2451 0 : VCLXContainer::ImplGetPropertyIds( rIds );
2452 0 : }
2453 :
2454 0 : VCLXMultiPage::~VCLXMultiPage()
2455 : {
2456 0 : }
2457 0 : void SAL_CALL VCLXMultiPage::dispose() throw(::com::sun::star::uno::RuntimeException, std::exception)
2458 : {
2459 0 : SolarMutexGuard aGuard;
2460 :
2461 0 : ::com::sun::star::lang::EventObject aObj;
2462 0 : aObj.Source = static_cast<cppu::OWeakObject*>(this);
2463 0 : maTabListeners.disposeAndClear( aObj );
2464 0 : VCLXContainer::dispose();
2465 0 : }
2466 0 : ::com::sun::star::uno::Any SAL_CALL VCLXMultiPage::queryInterface(const ::com::sun::star::uno::Type & rType )
2467 : throw(::com::sun::star::uno::RuntimeException, std::exception)
2468 : {
2469 0 : uno::Any aRet = ::cppu::queryInterface( rType, static_cast< awt::XSimpleTabController*>( this ) );
2470 :
2471 0 : return ( aRet.hasValue() ? aRet : VCLXContainer::queryInterface( rType ) );
2472 : }
2473 :
2474 : // ::com::sun::star::lang::XTypeProvider
2475 0 : IMPL_XTYPEPROVIDER_START( VCLXMultiPage )
2476 : VCLXContainer::getTypes()
2477 0 : IMPL_XTYPEPROVIDER_END
2478 :
2479 : // ::com::sun::star::awt::XView
2480 0 : void SAL_CALL VCLXMultiPage::draw( sal_Int32 nX, sal_Int32 nY )
2481 : throw(::com::sun::star::uno::RuntimeException, std::exception)
2482 : {
2483 0 : SolarMutexGuard aGuard;
2484 0 : VclPtr< vcl::Window > pWindow = GetWindow();
2485 :
2486 0 : if ( pWindow )
2487 : {
2488 0 : OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( getGraphics() );
2489 0 : if ( !pDev )
2490 0 : pDev = pWindow->GetParent();
2491 :
2492 0 : Size aSize = pDev->PixelToLogic( pWindow->GetSizePixel() );
2493 0 : Point aPos = pDev->PixelToLogic( Point( nX, nY ) );
2494 :
2495 0 : pWindow->Draw( pDev, aPos, aSize, DrawFlags::NoControls );
2496 0 : }
2497 0 : }
2498 :
2499 : // ::com::sun::star::awt::XDevice,
2500 0 : ::com::sun::star::awt::DeviceInfo SAL_CALL VCLXMultiPage::getInfo()
2501 : throw(::com::sun::star::uno::RuntimeException, std::exception)
2502 : {
2503 0 : ::com::sun::star::awt::DeviceInfo aInfo = VCLXDevice::getInfo();
2504 0 : return aInfo;
2505 : }
2506 :
2507 0 : uno::Any SAL_CALL VCLXMultiPage::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2508 : {
2509 0 : SolarMutexGuard aGuard;
2510 : OSL_TRACE(" **** VCLXMultiPage::getProperty( %s )",
2511 : OUStringToOString( PropertyName,
2512 : RTL_TEXTENCODING_UTF8 ).getStr() );
2513 0 : ::com::sun::star::uno::Any aProp;
2514 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
2515 0 : switch ( nPropType )
2516 : {
2517 :
2518 : case BASEPROPERTY_MULTIPAGEVALUE:
2519 : {
2520 0 : aProp <<= getActiveTabID();
2521 : }
2522 0 : break;
2523 : default:
2524 0 : aProp <<= VCLXContainer::getProperty( PropertyName );
2525 : }
2526 0 : return aProp;
2527 : }
2528 :
2529 0 : void SAL_CALL VCLXMultiPage::setProperty(
2530 : const OUString& PropertyName,
2531 : const ::com::sun::star::uno::Any& Value )
2532 : throw(::com::sun::star::uno::RuntimeException, std::exception)
2533 : {
2534 0 : SolarMutexGuard aGuard;
2535 : OSL_TRACE(" **** VCLXMultiPage::setProperty( %s )", OUStringToOString( PropertyName, RTL_TEXTENCODING_UTF8 ).getStr() );
2536 :
2537 0 : VclPtr< TabControl > pTabControl = GetAs< TabControl >();
2538 0 : if ( pTabControl )
2539 : {
2540 0 : bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
2541 :
2542 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
2543 0 : switch ( nPropType )
2544 : {
2545 : case BASEPROPERTY_MULTIPAGEVALUE:
2546 : {
2547 : OSL_TRACE("***MULTIPAGE VALUE");
2548 0 : sal_Int32 nId(0);
2549 0 : Value >>= nId;
2550 : // when the multipage is created we attempt to set the activepage
2551 : // but no pages created
2552 0 : if ( nId && nId <= getWindows().getLength() )
2553 0 : activateTab( nId );
2554 0 : break;
2555 : }
2556 : case BASEPROPERTY_GRAPHIC:
2557 : {
2558 0 : Reference< XGraphic > xGraphic;
2559 0 : if (( Value >>= xGraphic ) && xGraphic.is() )
2560 : {
2561 0 : Image aImage( xGraphic );
2562 :
2563 0 : Wallpaper aWallpaper( aImage.GetBitmapEx());
2564 0 : aWallpaper.SetStyle( WALLPAPER_SCALE );
2565 0 : pTabControl->SetBackground( aWallpaper );
2566 : }
2567 0 : else if ( bVoid || !xGraphic.is() )
2568 : {
2569 0 : Color aColor = pTabControl->GetControlBackground().GetColor();
2570 0 : if ( aColor == COL_AUTO )
2571 0 : aColor = pTabControl->GetSettings().GetStyleSettings().GetDialogColor();
2572 :
2573 0 : Wallpaper aWallpaper( aColor );
2574 0 : pTabControl->SetBackground( aWallpaper );
2575 0 : }
2576 : }
2577 0 : break;
2578 :
2579 : default:
2580 : {
2581 0 : VCLXContainer::setProperty( PropertyName, Value );
2582 : }
2583 : }
2584 0 : }
2585 0 : }
2586 :
2587 0 : TabControl *VCLXMultiPage::getTabControl() const throw (uno::RuntimeException)
2588 : {
2589 0 : VclPtr<TabControl> pTabControl = GetAsDynamic< TabControl >();
2590 0 : if ( pTabControl )
2591 0 : return pTabControl;
2592 0 : throw uno::RuntimeException();
2593 : }
2594 0 : sal_Int32 SAL_CALL VCLXMultiPage::insertTab() throw (uno::RuntimeException, std::exception)
2595 : {
2596 0 : TabControl *pTabControl = getTabControl();
2597 0 : VclPtrInstance<TabPage> pTab( pTabControl );
2598 0 : OUString title ("");
2599 0 : return static_cast< sal_Int32 >( insertTab( pTab, title ) );
2600 : }
2601 :
2602 0 : sal_uInt16 VCLXMultiPage::insertTab( TabPage* pPage, OUString& sTitle )
2603 : {
2604 0 : TabControl *pTabControl = getTabControl();
2605 0 : sal_uInt16 id = sal::static_int_cast< sal_uInt16 >( mTabId++ );
2606 0 : pTabControl->InsertPage( id, sTitle, TAB_APPEND );
2607 0 : pTabControl->SetTabPage( id, pPage );
2608 0 : return id;
2609 : }
2610 :
2611 0 : void SAL_CALL VCLXMultiPage::removeTab( sal_Int32 ID ) throw (uno::RuntimeException, lang::IndexOutOfBoundsException, std::exception)
2612 : {
2613 0 : TabControl *pTabControl = getTabControl();
2614 0 : if ( pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >( ID ) ) == NULL )
2615 0 : throw lang::IndexOutOfBoundsException();
2616 0 : pTabControl->RemovePage( sal::static_int_cast< sal_uInt16 >( ID ) );
2617 0 : }
2618 :
2619 0 : void SAL_CALL VCLXMultiPage::activateTab( sal_Int32 ID ) throw (uno::RuntimeException, lang::IndexOutOfBoundsException, std::exception)
2620 : {
2621 0 : TabControl *pTabControl = getTabControl();
2622 : SAL_INFO(
2623 : "toolkit",
2624 : "Attempting to activate tab " << ID << ", active tab is "
2625 : << getActiveTabID() << ", numtabs is " << getWindows().getLength());
2626 0 : if ( pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >( ID ) ) == NULL )
2627 0 : throw lang::IndexOutOfBoundsException();
2628 0 : pTabControl->SelectTabPage( sal::static_int_cast< sal_uInt16 >( ID ) );
2629 0 : }
2630 :
2631 0 : sal_Int32 SAL_CALL VCLXMultiPage::getActiveTabID() throw (uno::RuntimeException, std::exception)
2632 : {
2633 0 : return getTabControl()->GetCurPageId( );
2634 : }
2635 :
2636 0 : void SAL_CALL VCLXMultiPage::addTabListener( const uno::Reference< awt::XTabListener >& xListener ) throw (uno::RuntimeException, std::exception)
2637 : {
2638 0 : SolarMutexGuard aGuard;
2639 0 : maTabListeners.addInterface( xListener );
2640 0 : }
2641 :
2642 0 : void SAL_CALL VCLXMultiPage::removeTabListener( const uno::Reference< awt::XTabListener >& xListener ) throw (uno::RuntimeException, std::exception)
2643 : {
2644 0 : SolarMutexGuard aGuard;
2645 0 : maTabListeners.addInterface( xListener );
2646 0 : }
2647 :
2648 0 : void SAL_CALL VCLXMultiPage::setTabProps( sal_Int32 ID, const uno::Sequence< beans::NamedValue >& Properties ) throw (uno::RuntimeException, lang::IndexOutOfBoundsException, std::exception)
2649 : {
2650 0 : SolarMutexGuard aGuard;
2651 0 : TabControl *pTabControl = getTabControl();
2652 0 : if ( pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >( ID ) ) == NULL )
2653 0 : throw lang::IndexOutOfBoundsException();
2654 :
2655 0 : for (sal_Int32 i = 0; i < Properties.getLength(); ++i)
2656 : {
2657 0 : const OUString &name = Properties[i].Name;
2658 0 : const uno::Any &value = Properties[i].Value;
2659 :
2660 0 : if (name == "Title")
2661 : {
2662 0 : OUString title = value.get<OUString>();
2663 0 : pTabControl->SetPageText( sal::static_int_cast< sal_uInt16 >( ID ), title );
2664 : }
2665 0 : }
2666 0 : }
2667 :
2668 0 : uno::Sequence< beans::NamedValue > SAL_CALL VCLXMultiPage::getTabProps( sal_Int32 ID )
2669 : throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
2670 : {
2671 0 : SolarMutexGuard aGuard;
2672 0 : TabControl *pTabControl = getTabControl();
2673 0 : if ( pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >( ID ) ) == NULL )
2674 0 : throw lang::IndexOutOfBoundsException();
2675 :
2676 : #define ADD_PROP( seq, i, name, val ) { \
2677 : beans::NamedValue value; \
2678 : value.Name = name; \
2679 : value.Value = uno::makeAny( val ); \
2680 : seq[i] = value; \
2681 : }
2682 :
2683 0 : uno::Sequence< beans::NamedValue > props( 2 );
2684 0 : ADD_PROP( props, 0, "Title", OUString( pTabControl->GetPageText( sal::static_int_cast< sal_uInt16 >( ID ) ) ) );
2685 0 : ADD_PROP( props, 1, "Position", pTabControl->GetPagePos( sal::static_int_cast< sal_uInt16 >( ID ) ) );
2686 : #undef ADD_PROP
2687 0 : return props;
2688 : }
2689 0 : void VCLXMultiPage::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
2690 : {
2691 0 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
2692 0 : switch ( rVclWindowEvent.GetId() )
2693 : {
2694 : case VCLEVENT_TABPAGE_DEACTIVATE:
2695 : {
2696 0 : sal_uLong nPageID = reinterpret_cast<sal_uLong>( rVclWindowEvent.GetData() );
2697 0 : maTabListeners.deactivated( nPageID );
2698 0 : break;
2699 :
2700 : }
2701 : case VCLEVENT_TABPAGE_ACTIVATE:
2702 : {
2703 0 : sal_uLong nPageID = reinterpret_cast<sal_uLong>( rVclWindowEvent.GetData() );
2704 0 : maTabListeners.activated( nPageID );
2705 0 : break;
2706 : }
2707 : default:
2708 0 : VCLXContainer::ProcessWindowEvent( rVclWindowEvent );
2709 0 : break;
2710 0 : }
2711 0 : }
2712 :
2713 :
2714 : // class VCLXTabPage
2715 :
2716 0 : VCLXTabPage::VCLXTabPage()
2717 : {
2718 0 : }
2719 :
2720 0 : void VCLXTabPage::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
2721 : {
2722 : PushPropertyIds( rIds,
2723 : BASEPROPERTY_BACKGROUNDCOLOR,
2724 : BASEPROPERTY_DEFAULTCONTROL,
2725 : BASEPROPERTY_ENABLED,
2726 : BASEPROPERTY_ENABLEVISIBLE,
2727 : BASEPROPERTY_FONTDESCRIPTOR,
2728 : BASEPROPERTY_GRAPHIC,
2729 : BASEPROPERTY_HELPTEXT,
2730 : BASEPROPERTY_HELPURL,
2731 : BASEPROPERTY_IMAGEALIGN,
2732 : BASEPROPERTY_IMAGEPOSITION,
2733 : BASEPROPERTY_IMAGEURL,
2734 : BASEPROPERTY_PRINTABLE,
2735 : BASEPROPERTY_TABSTOP,
2736 : BASEPROPERTY_FOCUSONCLICK,
2737 0 : 0);
2738 0 : VCLXContainer::ImplGetPropertyIds( rIds );
2739 0 : }
2740 :
2741 0 : VCLXTabPage::~VCLXTabPage()
2742 : {
2743 0 : }
2744 :
2745 0 : ::com::sun::star::uno::Any SAL_CALL VCLXTabPage::queryInterface(const ::com::sun::star::uno::Type & rType )
2746 : throw(::com::sun::star::uno::RuntimeException, std::exception)
2747 : {
2748 0 : return VCLXContainer::queryInterface( rType );
2749 : }
2750 :
2751 : // ::com::sun::star::lang::XTypeProvider
2752 0 : IMPL_XTYPEPROVIDER_START( VCLXTabPage )
2753 : VCLXContainer::getTypes()
2754 0 : IMPL_XTYPEPROVIDER_END
2755 :
2756 : // ::com::sun::star::awt::XView
2757 0 : void SAL_CALL VCLXTabPage::draw( sal_Int32 nX, sal_Int32 nY )
2758 : throw(::com::sun::star::uno::RuntimeException, std::exception)
2759 : {
2760 0 : SolarMutexGuard aGuard;
2761 0 : VclPtr< vcl::Window > pWindow = GetWindow();
2762 :
2763 0 : if ( pWindow )
2764 : {
2765 0 : OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( getGraphics() );
2766 0 : if ( !pDev )
2767 0 : pDev = pWindow->GetParent();
2768 :
2769 0 : Size aSize = pDev->PixelToLogic( pWindow->GetSizePixel() );
2770 0 : Point aPos = pDev->PixelToLogic( Point( nX, nY ) );
2771 :
2772 0 : pWindow->Draw( pDev, aPos, aSize, DrawFlags::NoControls );
2773 0 : }
2774 0 : }
2775 :
2776 : // ::com::sun::star::awt::XDevice,
2777 0 : ::com::sun::star::awt::DeviceInfo SAL_CALL VCLXTabPage::getInfo()
2778 : throw(::com::sun::star::uno::RuntimeException, std::exception)
2779 : {
2780 0 : ::com::sun::star::awt::DeviceInfo aInfo = VCLXDevice::getInfo();
2781 0 : return aInfo;
2782 : }
2783 :
2784 0 : void SAL_CALL VCLXTabPage::setProperty(
2785 : const OUString& PropertyName,
2786 : const ::com::sun::star::uno::Any& Value )
2787 : throw(::com::sun::star::uno::RuntimeException, std::exception)
2788 : {
2789 0 : SolarMutexGuard aGuard;
2790 0 : VclPtr< TabPage > pTabPage = GetAs< TabPage >();
2791 0 : if ( pTabPage )
2792 : {
2793 0 : bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
2794 :
2795 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
2796 0 : switch ( nPropType )
2797 : {
2798 : case BASEPROPERTY_GRAPHIC:
2799 : {
2800 0 : Reference< XGraphic > xGraphic;
2801 0 : if (( Value >>= xGraphic ) && xGraphic.is() )
2802 : {
2803 0 : Image aImage( xGraphic );
2804 :
2805 0 : Wallpaper aWallpaper( aImage.GetBitmapEx());
2806 0 : aWallpaper.SetStyle( WALLPAPER_SCALE );
2807 0 : pTabPage->SetBackground( aWallpaper );
2808 : }
2809 0 : else if ( bVoid || !xGraphic.is() )
2810 : {
2811 0 : Color aColor = pTabPage->GetControlBackground().GetColor();
2812 0 : if ( aColor == COL_AUTO )
2813 0 : aColor = pTabPage->GetSettings().GetStyleSettings().GetDialogColor();
2814 :
2815 0 : Wallpaper aWallpaper( aColor );
2816 0 : pTabPage->SetBackground( aWallpaper );
2817 0 : }
2818 : }
2819 0 : break;
2820 : case BASEPROPERTY_TITLE:
2821 : {
2822 0 : OUString sTitle;
2823 0 : if ( Value >>= sTitle )
2824 : {
2825 0 : pTabPage->SetText(sTitle);
2826 0 : }
2827 : }
2828 0 : break;
2829 :
2830 : default:
2831 : {
2832 0 : VCLXContainer::setProperty( PropertyName, Value );
2833 : }
2834 : }
2835 0 : }
2836 0 : }
2837 :
2838 0 : TabPage *VCLXTabPage::getTabPage() const throw (uno::RuntimeException)
2839 : {
2840 0 : VclPtr< TabPage > pTabPage = GetAsDynamic< TabPage >();
2841 0 : if ( pTabPage )
2842 0 : return pTabPage;
2843 0 : throw uno::RuntimeException();
2844 : }
2845 :
2846 :
2847 : // class VCLXFixedHyperlink
2848 :
2849 :
2850 0 : VCLXFixedHyperlink::VCLXFixedHyperlink() :
2851 :
2852 0 : maActionListeners( *this )
2853 :
2854 : {
2855 0 : }
2856 :
2857 0 : VCLXFixedHyperlink::~VCLXFixedHyperlink()
2858 : {
2859 0 : }
2860 :
2861 : // ::com::sun::star::uno::XInterface
2862 0 : ::com::sun::star::uno::Any VCLXFixedHyperlink::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2863 : {
2864 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
2865 0 : (static_cast< ::com::sun::star::awt::XFixedHyperlink* >(this)) );
2866 0 : return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
2867 : }
2868 :
2869 0 : void VCLXFixedHyperlink::dispose() throw(::com::sun::star::uno::RuntimeException, std::exception)
2870 : {
2871 0 : SolarMutexGuard aGuard;
2872 :
2873 0 : ::com::sun::star::lang::EventObject aObj;
2874 0 : aObj.Source = static_cast<cppu::OWeakObject*>(this);
2875 0 : maActionListeners.disposeAndClear( aObj );
2876 0 : VCLXWindow::dispose();
2877 0 : }
2878 :
2879 : // ::com::sun::star::lang::XTypeProvider
2880 0 : IMPL_XTYPEPROVIDER_START( VCLXFixedHyperlink )
2881 0 : cppu::UnoType<com::sun::star::awt::XFixedHyperlink>::get(),
2882 : VCLXWindow::getTypes()
2883 0 : IMPL_XTYPEPROVIDER_END
2884 :
2885 0 : void VCLXFixedHyperlink::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
2886 : {
2887 0 : switch ( rVclWindowEvent.GetId() )
2888 : {
2889 : case VCLEVENT_BUTTON_CLICK:
2890 : {
2891 0 : if ( maActionListeners.getLength() )
2892 : {
2893 0 : ::com::sun::star::awt::ActionEvent aEvent;
2894 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
2895 0 : maActionListeners.actionPerformed( aEvent );
2896 : }
2897 : else
2898 : {
2899 : // open the URL
2900 0 : OUString sURL;
2901 0 : VclPtr< FixedHyperlink > pBase = GetAs< FixedHyperlink >();
2902 0 : if ( pBase )
2903 0 : sURL = pBase->GetURL();
2904 : Reference< ::com::sun::star::system::XSystemShellExecute > xSystemShellExecute( ::com::sun::star::system::SystemShellExecute::create(
2905 0 : ::comphelper::getProcessComponentContext() ) );
2906 0 : if ( !sURL.isEmpty() )
2907 : {
2908 : try
2909 : {
2910 : // start browser
2911 0 : xSystemShellExecute->execute(
2912 0 : sURL, OUString(), ::com::sun::star::system::SystemShellExecuteFlags::URIS_ONLY );
2913 : }
2914 0 : catch( uno::Exception& )
2915 : {
2916 : }
2917 0 : }
2918 : }
2919 : }
2920 : //fall-through
2921 : default:
2922 0 : VCLXWindow::ProcessWindowEvent( rVclWindowEvent );
2923 0 : break;
2924 : }
2925 0 : }
2926 :
2927 0 : ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXFixedHyperlink::CreateAccessibleContext()
2928 : {
2929 0 : return getAccessibleFactory().createAccessibleContext( this );
2930 : }
2931 :
2932 0 : void VCLXFixedHyperlink::setText( const OUString& Text ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2933 : {
2934 0 : SolarMutexGuard aGuard;
2935 0 : VclPtr< FixedHyperlink > pBase = GetAs< FixedHyperlink >();
2936 0 : if (pBase)
2937 0 : pBase->SetText(Text);
2938 0 : }
2939 :
2940 0 : OUString VCLXFixedHyperlink::getText() throw(::com::sun::star::uno::RuntimeException, std::exception)
2941 : {
2942 0 : SolarMutexGuard aGuard;
2943 :
2944 0 : OUString aText;
2945 0 : VclPtr< vcl::Window > pWindow = GetWindow();
2946 0 : if ( pWindow )
2947 0 : aText = pWindow->GetText();
2948 0 : return aText;
2949 : }
2950 :
2951 0 : void VCLXFixedHyperlink::setURL( const OUString& URL ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2952 : {
2953 0 : SolarMutexGuard aGuard;
2954 0 : VclPtr< FixedHyperlink > pBase = GetAs< FixedHyperlink >();
2955 0 : if ( pBase )
2956 0 : pBase->SetURL( URL );
2957 0 : }
2958 :
2959 0 : OUString VCLXFixedHyperlink::getURL( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2960 : {
2961 0 : SolarMutexGuard aGuard;
2962 :
2963 0 : OUString aText;
2964 0 : VclPtr< FixedHyperlink > pBase = GetAs< FixedHyperlink >();
2965 0 : if ( pBase )
2966 0 : aText = pBase->GetURL();
2967 0 : return aText;
2968 : }
2969 :
2970 0 : void VCLXFixedHyperlink::setAlignment( short nAlign ) throw(::com::sun::star::uno::RuntimeException, std::exception)
2971 : {
2972 0 : SolarMutexGuard aGuard;
2973 :
2974 0 : VclPtr< vcl::Window > pWindow = GetWindow();
2975 0 : if ( pWindow )
2976 : {
2977 0 : WinBits nNewBits = 0;
2978 0 : if ( nAlign == ::com::sun::star::awt::TextAlign::LEFT )
2979 0 : nNewBits = WB_LEFT;
2980 0 : else if ( nAlign == ::com::sun::star::awt::TextAlign::CENTER )
2981 0 : nNewBits = WB_CENTER;
2982 : else
2983 0 : nNewBits = WB_RIGHT;
2984 :
2985 0 : WinBits nStyle = pWindow->GetStyle();
2986 0 : nStyle &= ~(WB_LEFT|WB_CENTER|WB_RIGHT);
2987 0 : pWindow->SetStyle( nStyle | nNewBits );
2988 0 : }
2989 0 : }
2990 :
2991 0 : short VCLXFixedHyperlink::getAlignment() throw(::com::sun::star::uno::RuntimeException, std::exception)
2992 : {
2993 0 : SolarMutexGuard aGuard;
2994 :
2995 0 : short nAlign = 0;
2996 0 : VclPtr< vcl::Window > pWindow = GetWindow();
2997 0 : if ( pWindow )
2998 : {
2999 0 : WinBits nStyle = pWindow->GetStyle();
3000 0 : if ( nStyle & WB_LEFT )
3001 0 : nAlign = ::com::sun::star::awt::TextAlign::LEFT;
3002 0 : else if ( nStyle & WB_CENTER )
3003 0 : nAlign = ::com::sun::star::awt::TextAlign::CENTER;
3004 : else
3005 0 : nAlign = ::com::sun::star::awt::TextAlign::RIGHT;
3006 : }
3007 0 : return nAlign;
3008 : }
3009 :
3010 0 : void VCLXFixedHyperlink::addActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l )throw(::com::sun::star::uno::RuntimeException, std::exception)
3011 : {
3012 0 : SolarMutexGuard aGuard;
3013 0 : maActionListeners.addInterface( l );
3014 0 : }
3015 :
3016 0 : void VCLXFixedHyperlink::removeActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3017 : {
3018 0 : SolarMutexGuard aGuard;
3019 0 : maActionListeners.removeInterface( l );
3020 0 : }
3021 :
3022 0 : ::com::sun::star::awt::Size VCLXFixedHyperlink::getMinimumSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3023 : {
3024 0 : SolarMutexGuard aGuard;
3025 0 : Size aSz;
3026 0 : VclPtr< FixedText > pFixedText = GetAs< FixedText >();
3027 0 : if ( pFixedText )
3028 0 : aSz = pFixedText->CalcMinimumSize();
3029 0 : return AWTSize(aSz);
3030 : }
3031 :
3032 0 : ::com::sun::star::awt::Size VCLXFixedHyperlink::getPreferredSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3033 : {
3034 0 : return getMinimumSize();
3035 : }
3036 :
3037 0 : ::com::sun::star::awt::Size VCLXFixedHyperlink::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3038 : {
3039 0 : SolarMutexGuard aGuard;
3040 :
3041 0 : ::com::sun::star::awt::Size aSz = rNewSize;
3042 0 : ::com::sun::star::awt::Size aMinSz = getMinimumSize();
3043 0 : if ( aSz.Height != aMinSz.Height )
3044 0 : aSz.Height = aMinSz.Height;
3045 :
3046 0 : return aSz;
3047 : }
3048 :
3049 0 : void VCLXFixedHyperlink::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
3050 : {
3051 0 : SolarMutexGuard aGuard;
3052 :
3053 0 : VclPtr< FixedHyperlink > pBase = GetAs< FixedHyperlink >();
3054 0 : if ( pBase )
3055 : {
3056 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
3057 0 : switch ( nPropType )
3058 : {
3059 : case BASEPROPERTY_LABEL:
3060 : {
3061 0 : OUString sNewLabel;
3062 0 : if ( Value >>= sNewLabel )
3063 0 : pBase->SetText(sNewLabel);
3064 0 : break;
3065 : }
3066 :
3067 : case BASEPROPERTY_URL:
3068 : {
3069 0 : OUString sNewURL;
3070 0 : if ( Value >>= sNewURL )
3071 0 : pBase->SetURL( sNewURL );
3072 0 : break;
3073 : }
3074 :
3075 : default:
3076 : {
3077 0 : VCLXWindow::setProperty( PropertyName, Value );
3078 : }
3079 : }
3080 0 : }
3081 0 : }
3082 :
3083 0 : ::com::sun::star::uno::Any VCLXFixedHyperlink::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3084 : {
3085 0 : SolarMutexGuard aGuard;
3086 :
3087 0 : ::com::sun::star::uno::Any aProp;
3088 0 : VclPtr< FixedHyperlink > pBase = GetAs< FixedHyperlink >();
3089 0 : if ( pBase )
3090 : {
3091 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
3092 0 : switch ( nPropType )
3093 : {
3094 : case BASEPROPERTY_URL:
3095 : {
3096 0 : aProp = makeAny( OUString( pBase->GetURL() ) );
3097 0 : break;
3098 : }
3099 :
3100 : default:
3101 : {
3102 0 : aProp <<= VCLXWindow::getProperty( PropertyName );
3103 : }
3104 : }
3105 : }
3106 0 : return aProp;
3107 : }
3108 :
3109 1 : void VCLXFixedHyperlink::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
3110 : {
3111 : PushPropertyIds( rIds,
3112 : BASEPROPERTY_ALIGN,
3113 : BASEPROPERTY_BACKGROUNDCOLOR,
3114 : BASEPROPERTY_BORDER,
3115 : BASEPROPERTY_BORDERCOLOR,
3116 : BASEPROPERTY_DEFAULTCONTROL,
3117 : BASEPROPERTY_ENABLED,
3118 : BASEPROPERTY_ENABLEVISIBLE,
3119 : BASEPROPERTY_FONTDESCRIPTOR,
3120 : BASEPROPERTY_HELPTEXT,
3121 : BASEPROPERTY_HELPURL,
3122 : BASEPROPERTY_LABEL,
3123 : BASEPROPERTY_MULTILINE,
3124 : BASEPROPERTY_NOLABEL,
3125 : BASEPROPERTY_PRINTABLE,
3126 : BASEPROPERTY_TABSTOP,
3127 : BASEPROPERTY_VERTICALALIGN,
3128 : BASEPROPERTY_URL,
3129 : BASEPROPERTY_WRITING_MODE,
3130 : BASEPROPERTY_CONTEXT_WRITING_MODE,
3131 1 : 0);
3132 1 : VCLXWindow::ImplGetPropertyIds( rIds );
3133 1 : }
3134 :
3135 :
3136 : // class VCLXFixedText
3137 :
3138 77 : void VCLXFixedText::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
3139 : {
3140 : PushPropertyIds( rIds,
3141 : BASEPROPERTY_ALIGN,
3142 : BASEPROPERTY_BACKGROUNDCOLOR,
3143 : BASEPROPERTY_BORDER,
3144 : BASEPROPERTY_BORDERCOLOR,
3145 : BASEPROPERTY_DEFAULTCONTROL,
3146 : BASEPROPERTY_ENABLED,
3147 : BASEPROPERTY_ENABLEVISIBLE,
3148 : BASEPROPERTY_FONTDESCRIPTOR,
3149 : BASEPROPERTY_HELPTEXT,
3150 : BASEPROPERTY_HELPURL,
3151 : BASEPROPERTY_LABEL,
3152 : BASEPROPERTY_MULTILINE,
3153 : BASEPROPERTY_NOLABEL,
3154 : BASEPROPERTY_PRINTABLE,
3155 : BASEPROPERTY_TABSTOP,
3156 : BASEPROPERTY_VERTICALALIGN,
3157 : BASEPROPERTY_WRITING_MODE,
3158 : BASEPROPERTY_CONTEXT_WRITING_MODE,
3159 : BASEPROPERTY_REFERENCE_DEVICE,
3160 77 : 0);
3161 77 : VCLXWindow::ImplGetPropertyIds( rIds );
3162 77 : }
3163 :
3164 2 : VCLXFixedText::VCLXFixedText()
3165 : {
3166 2 : }
3167 :
3168 4 : VCLXFixedText::~VCLXFixedText()
3169 : {
3170 4 : }
3171 :
3172 : // ::com::sun::star::uno::XInterface
3173 114 : ::com::sun::star::uno::Any VCLXFixedText::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3174 : {
3175 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
3176 114 : (static_cast< ::com::sun::star::awt::XFixedText* >(this)) );
3177 114 : return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
3178 : }
3179 :
3180 : // ::com::sun::star::lang::XTypeProvider
3181 0 : IMPL_XTYPEPROVIDER_START( VCLXFixedText )
3182 0 : cppu::UnoType<com::sun::star::awt::XFixedText>::get(),
3183 : VCLXWindow::getTypes()
3184 0 : IMPL_XTYPEPROVIDER_END
3185 :
3186 1 : ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXFixedText::CreateAccessibleContext()
3187 : {
3188 1 : return getAccessibleFactory().createAccessibleContext( this );
3189 : }
3190 :
3191 0 : void VCLXFixedText::setText( const OUString& Text ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3192 : {
3193 0 : SolarMutexGuard aGuard;
3194 :
3195 0 : VclPtr< vcl::Window > pWindow = GetWindow();
3196 0 : if ( pWindow )
3197 0 : pWindow->SetText( Text );
3198 0 : }
3199 :
3200 0 : OUString VCLXFixedText::getText() throw(::com::sun::star::uno::RuntimeException, std::exception)
3201 : {
3202 0 : SolarMutexGuard aGuard;
3203 :
3204 0 : OUString aText;
3205 0 : VclPtr< vcl::Window > pWindow = GetWindow();
3206 0 : if ( pWindow )
3207 0 : aText = pWindow->GetText();
3208 0 : return aText;
3209 : }
3210 :
3211 0 : void VCLXFixedText::setAlignment( short nAlign ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3212 : {
3213 0 : SolarMutexGuard aGuard;
3214 :
3215 0 : VclPtr< vcl::Window > pWindow = GetWindow();
3216 0 : if ( pWindow )
3217 : {
3218 0 : WinBits nNewBits = 0;
3219 0 : if ( nAlign == ::com::sun::star::awt::TextAlign::LEFT )
3220 0 : nNewBits = WB_LEFT;
3221 0 : else if ( nAlign == ::com::sun::star::awt::TextAlign::CENTER )
3222 0 : nNewBits = WB_CENTER;
3223 : else
3224 0 : nNewBits = WB_RIGHT;
3225 :
3226 0 : WinBits nStyle = pWindow->GetStyle();
3227 0 : nStyle &= ~(WB_LEFT|WB_CENTER|WB_RIGHT);
3228 0 : pWindow->SetStyle( nStyle | nNewBits );
3229 0 : }
3230 0 : }
3231 :
3232 0 : short VCLXFixedText::getAlignment() throw(::com::sun::star::uno::RuntimeException, std::exception)
3233 : {
3234 0 : SolarMutexGuard aGuard;
3235 :
3236 0 : short nAlign = 0;
3237 0 : VclPtr< vcl::Window > pWindow = GetWindow();
3238 0 : if ( pWindow )
3239 : {
3240 0 : WinBits nStyle = pWindow->GetStyle();
3241 0 : if ( nStyle & WB_LEFT )
3242 0 : nAlign = ::com::sun::star::awt::TextAlign::LEFT;
3243 0 : else if ( nStyle & WB_CENTER )
3244 0 : nAlign = ::com::sun::star::awt::TextAlign::CENTER;
3245 : else
3246 0 : nAlign = ::com::sun::star::awt::TextAlign::RIGHT;
3247 : }
3248 0 : return nAlign;
3249 : }
3250 :
3251 2 : ::com::sun::star::awt::Size VCLXFixedText::getMinimumSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3252 : {
3253 2 : SolarMutexGuard aGuard;
3254 :
3255 2 : Size aSz;
3256 4 : VclPtr< FixedText > pFixedText = GetAs< FixedText >();
3257 2 : if ( pFixedText )
3258 2 : aSz = pFixedText->CalcMinimumSize();
3259 4 : return AWTSize(aSz);
3260 : }
3261 :
3262 1 : ::com::sun::star::awt::Size VCLXFixedText::getPreferredSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3263 : {
3264 1 : return getMinimumSize();
3265 : }
3266 :
3267 1 : ::com::sun::star::awt::Size VCLXFixedText::calcAdjustedSize( const ::com::sun::star::awt::Size& rMaxSize ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3268 : {
3269 1 : SolarMutexGuard aGuard;
3270 :
3271 1 : Size aAdjustedSize( VCLUnoHelper::ConvertToVCLSize( rMaxSize ) );
3272 2 : VclPtr< FixedText > pFixedText = GetAs< FixedText >();
3273 1 : if ( pFixedText )
3274 1 : aAdjustedSize = pFixedText->CalcMinimumSize( rMaxSize.Width );
3275 2 : return VCLUnoHelper::ConvertToAWTSize( aAdjustedSize );
3276 : }
3277 :
3278 :
3279 : // class VCLXScrollBar
3280 :
3281 11 : void VCLXScrollBar::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
3282 : {
3283 : PushPropertyIds( rIds,
3284 : BASEPROPERTY_BACKGROUNDCOLOR,
3285 : BASEPROPERTY_BLOCKINCREMENT,
3286 : BASEPROPERTY_BORDER,
3287 : BASEPROPERTY_BORDERCOLOR,
3288 : BASEPROPERTY_DEFAULTCONTROL,
3289 : BASEPROPERTY_ENABLED,
3290 : BASEPROPERTY_ENABLEVISIBLE,
3291 : BASEPROPERTY_HELPTEXT,
3292 : BASEPROPERTY_HELPURL,
3293 : BASEPROPERTY_LINEINCREMENT,
3294 : BASEPROPERTY_LIVE_SCROLL,
3295 : BASEPROPERTY_ORIENTATION,
3296 : BASEPROPERTY_PRINTABLE,
3297 : BASEPROPERTY_REPEAT_DELAY,
3298 : BASEPROPERTY_SCROLLVALUE,
3299 : BASEPROPERTY_SCROLLVALUE_MAX,
3300 : BASEPROPERTY_SCROLLVALUE_MIN,
3301 : BASEPROPERTY_SYMBOL_COLOR,
3302 : BASEPROPERTY_TABSTOP,
3303 : BASEPROPERTY_VISIBLESIZE,
3304 : BASEPROPERTY_WRITING_MODE,
3305 : BASEPROPERTY_CONTEXT_WRITING_MODE,
3306 11 : 0);
3307 11 : VCLXWindow::ImplGetPropertyIds( rIds );
3308 11 : }
3309 :
3310 20 : VCLXScrollBar::VCLXScrollBar() : maAdjustmentListeners( *this )
3311 : {
3312 20 : }
3313 :
3314 : // ::com::sun::star::uno::XInterface
3315 177 : ::com::sun::star::uno::Any VCLXScrollBar::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3316 : {
3317 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
3318 177 : (static_cast< ::com::sun::star::awt::XScrollBar* >(this)) );
3319 177 : return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
3320 : }
3321 :
3322 : // ::com::sun::star::lang::XTypeProvider
3323 0 : IMPL_XTYPEPROVIDER_START( VCLXScrollBar )
3324 0 : cppu::UnoType<com::sun::star::awt::XScrollBar>::get(),
3325 : VCLXWindow::getTypes()
3326 0 : IMPL_XTYPEPROVIDER_END
3327 :
3328 15 : ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXScrollBar::CreateAccessibleContext()
3329 : {
3330 15 : return getAccessibleFactory().createAccessibleContext( this );
3331 : }
3332 :
3333 : // ::com::sun::star::lang::XComponent
3334 40 : void VCLXScrollBar::dispose() throw(::com::sun::star::uno::RuntimeException, std::exception)
3335 : {
3336 40 : SolarMutexGuard aGuard;
3337 :
3338 80 : ::com::sun::star::lang::EventObject aObj;
3339 40 : aObj.Source = static_cast<cppu::OWeakObject*>(this);
3340 40 : maAdjustmentListeners.disposeAndClear( aObj );
3341 80 : VCLXWindow::dispose();
3342 40 : }
3343 :
3344 : // ::com::sun::star::awt::XScrollbar
3345 2 : void VCLXScrollBar::addAdjustmentListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XAdjustmentListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3346 : {
3347 2 : SolarMutexGuard aGuard;
3348 2 : maAdjustmentListeners.addInterface( l );
3349 2 : }
3350 :
3351 0 : void VCLXScrollBar::removeAdjustmentListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XAdjustmentListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3352 : {
3353 0 : SolarMutexGuard aGuard;
3354 0 : maAdjustmentListeners.removeInterface( l );
3355 0 : }
3356 :
3357 0 : void VCLXScrollBar::setValue( sal_Int32 n ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3358 : {
3359 0 : SolarMutexGuard aGuard;
3360 :
3361 0 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3362 0 : if ( pScrollBar )
3363 0 : pScrollBar->DoScroll( n );
3364 0 : }
3365 :
3366 0 : void VCLXScrollBar::setValues( sal_Int32 nValue, sal_Int32 nVisible, sal_Int32 nMax ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3367 : {
3368 0 : SolarMutexGuard aGuard;
3369 :
3370 0 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3371 0 : if ( pScrollBar )
3372 : {
3373 0 : pScrollBar->SetVisibleSize( nVisible );
3374 0 : pScrollBar->SetRangeMax( nMax );
3375 0 : pScrollBar->DoScroll( nValue );
3376 0 : }
3377 0 : }
3378 :
3379 0 : sal_Int32 VCLXScrollBar::getValue() throw(::com::sun::star::uno::RuntimeException, std::exception)
3380 : {
3381 0 : SolarMutexGuard aGuard;
3382 :
3383 0 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3384 0 : return pScrollBar ? pScrollBar->GetThumbPos() : 0;
3385 : }
3386 :
3387 1 : void VCLXScrollBar::setMaximum( sal_Int32 n ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3388 : {
3389 1 : SolarMutexGuard aGuard;
3390 :
3391 2 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3392 1 : if ( pScrollBar )
3393 2 : pScrollBar->SetRangeMax( n );
3394 1 : }
3395 :
3396 0 : sal_Int32 VCLXScrollBar::getMaximum() throw(::com::sun::star::uno::RuntimeException, std::exception)
3397 : {
3398 0 : SolarMutexGuard aGuard;
3399 :
3400 0 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3401 0 : return pScrollBar ? pScrollBar->GetRangeMax() : 0;
3402 : }
3403 :
3404 1 : void VCLXScrollBar::setMinimum( sal_Int32 n ) throw(::com::sun::star::uno::RuntimeException)
3405 : {
3406 1 : SolarMutexGuard aGuard;
3407 :
3408 2 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3409 1 : if ( pScrollBar )
3410 2 : pScrollBar->SetRangeMin( n );
3411 1 : }
3412 :
3413 0 : sal_Int32 VCLXScrollBar::getMinimum() throw(::com::sun::star::uno::RuntimeException)
3414 : {
3415 0 : SolarMutexGuard aGuard;
3416 :
3417 0 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3418 0 : return pScrollBar ? pScrollBar->GetRangeMin() : 0;
3419 : }
3420 :
3421 1 : void VCLXScrollBar::setLineIncrement( sal_Int32 n ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3422 : {
3423 1 : SolarMutexGuard aGuard;
3424 :
3425 2 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3426 1 : if ( pScrollBar )
3427 2 : pScrollBar->SetLineSize( n );
3428 1 : }
3429 :
3430 0 : sal_Int32 VCLXScrollBar::getLineIncrement() throw(::com::sun::star::uno::RuntimeException, std::exception)
3431 : {
3432 0 : SolarMutexGuard aGuard;
3433 :
3434 0 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3435 0 : return pScrollBar ? pScrollBar->GetLineSize() : 0;
3436 : }
3437 :
3438 1 : void VCLXScrollBar::setBlockIncrement( sal_Int32 n ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3439 : {
3440 1 : SolarMutexGuard aGuard;
3441 :
3442 2 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3443 1 : if ( pScrollBar )
3444 2 : pScrollBar->SetPageSize( n );
3445 1 : }
3446 :
3447 0 : sal_Int32 VCLXScrollBar::getBlockIncrement() throw(::com::sun::star::uno::RuntimeException, std::exception)
3448 : {
3449 0 : SolarMutexGuard aGuard;
3450 :
3451 0 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3452 0 : return pScrollBar ? pScrollBar->GetPageSize() : 0;
3453 : }
3454 :
3455 0 : void VCLXScrollBar::setVisibleSize( sal_Int32 n ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3456 : {
3457 0 : SolarMutexGuard aGuard;
3458 :
3459 0 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3460 0 : if ( pScrollBar )
3461 0 : pScrollBar->SetVisibleSize( n );
3462 0 : }
3463 :
3464 0 : sal_Int32 VCLXScrollBar::getVisibleSize() throw(::com::sun::star::uno::RuntimeException, std::exception)
3465 : {
3466 0 : SolarMutexGuard aGuard;
3467 :
3468 0 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3469 0 : return pScrollBar ? pScrollBar->GetVisibleSize() : 0;
3470 : }
3471 :
3472 1 : void VCLXScrollBar::setOrientation( sal_Int32 n ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3473 : {
3474 1 : SolarMutexGuard aGuard;
3475 :
3476 2 : VclPtr< vcl::Window > pWindow = GetWindow();
3477 1 : if ( pWindow )
3478 : {
3479 1 : WinBits nStyle = pWindow->GetStyle();
3480 1 : nStyle &= ~(WB_HORZ|WB_VERT);
3481 1 : if ( n == ::com::sun::star::awt::ScrollBarOrientation::HORIZONTAL )
3482 1 : nStyle |= WB_HORZ;
3483 : else
3484 0 : nStyle |= WB_VERT;
3485 :
3486 1 : pWindow->SetStyle( nStyle );
3487 1 : pWindow->Resize();
3488 1 : }
3489 1 : }
3490 :
3491 23 : sal_Int32 VCLXScrollBar::getOrientation() throw(::com::sun::star::uno::RuntimeException, std::exception)
3492 : {
3493 23 : SolarMutexGuard aGuard;
3494 :
3495 23 : sal_Int32 n = 0;
3496 46 : VclPtr< vcl::Window > pWindow = GetWindow();
3497 23 : if ( pWindow )
3498 : {
3499 23 : WinBits nStyle = pWindow->GetStyle();
3500 23 : if ( nStyle & WB_HORZ )
3501 9 : n = ::com::sun::star::awt::ScrollBarOrientation::HORIZONTAL;
3502 : else
3503 14 : n = ::com::sun::star::awt::ScrollBarOrientation::VERTICAL;
3504 : }
3505 46 : return n;
3506 :
3507 : }
3508 :
3509 : // ::com::sun::star::awt::VclWindowPeer
3510 32 : void VCLXScrollBar::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
3511 : {
3512 32 : SolarMutexGuard aGuard;
3513 :
3514 64 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3515 32 : if ( pScrollBar )
3516 : {
3517 32 : bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
3518 :
3519 32 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
3520 32 : switch ( nPropType )
3521 : {
3522 : case BASEPROPERTY_LIVE_SCROLL:
3523 : {
3524 1 : bool bDo = false;
3525 1 : if ( !bVoid )
3526 : {
3527 1 : OSL_VERIFY( Value >>= bDo );
3528 : }
3529 1 : AllSettings aSettings( pScrollBar->GetSettings() );
3530 2 : StyleSettings aStyle( aSettings.GetStyleSettings() );
3531 1 : DragFullOptions nDragOptions = aStyle.GetDragFullOptions();
3532 1 : if ( bDo )
3533 0 : nDragOptions |= DragFullOptions::Scroll;
3534 : else
3535 1 : nDragOptions &= ~DragFullOptions::Scroll;
3536 1 : aStyle.SetDragFullOptions( nDragOptions );
3537 1 : aSettings.SetStyleSettings( aStyle );
3538 2 : pScrollBar->SetSettings( aSettings );
3539 : }
3540 1 : break;
3541 :
3542 : case BASEPROPERTY_SCROLLVALUE:
3543 : {
3544 1 : if ( !bVoid )
3545 : {
3546 0 : sal_Int32 n = 0;
3547 0 : if ( Value >>= n )
3548 0 : setValue( n );
3549 : }
3550 : }
3551 1 : break;
3552 : case BASEPROPERTY_SCROLLVALUE_MAX:
3553 : case BASEPROPERTY_SCROLLVALUE_MIN:
3554 : {
3555 2 : if ( !bVoid )
3556 : {
3557 2 : sal_Int32 n = 0;
3558 2 : if ( Value >>= n )
3559 : {
3560 2 : if ( nPropType == BASEPROPERTY_SCROLLVALUE_MAX )
3561 1 : setMaximum( n );
3562 : else
3563 1 : setMinimum( n );
3564 : }
3565 : }
3566 : }
3567 2 : break;
3568 : case BASEPROPERTY_LINEINCREMENT:
3569 : {
3570 1 : if ( !bVoid )
3571 : {
3572 1 : sal_Int32 n = 0;
3573 1 : if ( Value >>= n )
3574 1 : setLineIncrement( n );
3575 : }
3576 : }
3577 1 : break;
3578 : case BASEPROPERTY_BLOCKINCREMENT:
3579 : {
3580 1 : if ( !bVoid )
3581 : {
3582 1 : sal_Int32 n = 0;
3583 1 : if ( Value >>= n )
3584 1 : setBlockIncrement( n );
3585 : }
3586 : }
3587 1 : break;
3588 : case BASEPROPERTY_VISIBLESIZE:
3589 : {
3590 1 : if ( !bVoid )
3591 : {
3592 0 : sal_Int32 n = 0;
3593 0 : if ( Value >>= n )
3594 0 : setVisibleSize( n );
3595 : }
3596 : }
3597 1 : break;
3598 : case BASEPROPERTY_ORIENTATION:
3599 : {
3600 1 : if ( !bVoid )
3601 : {
3602 1 : sal_Int32 n = 0;
3603 1 : if ( Value >>= n )
3604 1 : setOrientation( n );
3605 : }
3606 : }
3607 1 : break;
3608 :
3609 : case BASEPROPERTY_BACKGROUNDCOLOR:
3610 : {
3611 : // the default implementation of the base class doesn't work here, since our
3612 : // interpretation for this property is slightly different
3613 1 : ::toolkit::setButtonLikeFaceColor( pScrollBar, Value);
3614 : }
3615 1 : break;
3616 :
3617 : default:
3618 : {
3619 23 : VCLXWindow::setProperty( PropertyName, Value );
3620 : }
3621 : }
3622 32 : }
3623 32 : }
3624 :
3625 0 : ::com::sun::star::uno::Any VCLXScrollBar::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3626 : {
3627 0 : SolarMutexGuard aGuard;
3628 :
3629 0 : ::com::sun::star::uno::Any aProp;
3630 0 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3631 0 : if ( pScrollBar )
3632 : {
3633 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
3634 :
3635 0 : switch ( nPropType )
3636 : {
3637 : case BASEPROPERTY_LIVE_SCROLL:
3638 : {
3639 0 : aProp <<= bool( pScrollBar->GetSettings().GetStyleSettings().GetDragFullOptions() & DragFullOptions::Scroll );
3640 : }
3641 0 : break;
3642 : case BASEPROPERTY_SCROLLVALUE:
3643 : {
3644 0 : aProp <<= (sal_Int32) getValue();
3645 : }
3646 0 : break;
3647 : case BASEPROPERTY_SCROLLVALUE_MAX:
3648 : {
3649 0 : aProp <<= (sal_Int32) getMaximum();
3650 : }
3651 0 : break;
3652 : case BASEPROPERTY_SCROLLVALUE_MIN:
3653 : {
3654 0 : aProp <<= (sal_Int32) getMinimum();
3655 : }
3656 0 : break;
3657 : case BASEPROPERTY_LINEINCREMENT:
3658 : {
3659 0 : aProp <<= (sal_Int32) getLineIncrement();
3660 : }
3661 0 : break;
3662 : case BASEPROPERTY_BLOCKINCREMENT:
3663 : {
3664 0 : aProp <<= (sal_Int32) getBlockIncrement();
3665 : }
3666 0 : break;
3667 : case BASEPROPERTY_VISIBLESIZE:
3668 : {
3669 0 : aProp <<= (sal_Int32) getVisibleSize();
3670 : }
3671 0 : break;
3672 : case BASEPROPERTY_ORIENTATION:
3673 : {
3674 0 : aProp <<= (sal_Int32) getOrientation();
3675 : }
3676 0 : break;
3677 : case BASEPROPERTY_BACKGROUNDCOLOR:
3678 : {
3679 : // the default implementation of the base class doesn't work here, since our
3680 : // interpretation for this property is slightly different
3681 0 : aProp = ::toolkit::getButtonLikeFaceColor( pScrollBar );
3682 : }
3683 0 : break;
3684 :
3685 : default:
3686 : {
3687 0 : aProp <<= VCLXWindow::getProperty( PropertyName );
3688 : }
3689 : }
3690 : }
3691 0 : return aProp;
3692 : }
3693 :
3694 65 : void VCLXScrollBar::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
3695 : {
3696 65 : switch ( rVclWindowEvent.GetId() )
3697 : {
3698 : case VCLEVENT_SCROLLBAR_SCROLL:
3699 : {
3700 2 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
3701 : // since we call listeners below, there is a potential that we will be destroyed
3702 : // in during the listener call. To prevent the resulting crashs, we keep us
3703 : // alive as long as we're here
3704 :
3705 2 : if ( maAdjustmentListeners.getLength() )
3706 : {
3707 0 : VclPtr< ScrollBar > pScrollBar = GetAs< ScrollBar >();
3708 :
3709 0 : if( pScrollBar )
3710 : {
3711 0 : ::com::sun::star::awt::AdjustmentEvent aEvent;
3712 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
3713 0 : aEvent.Value = pScrollBar->GetThumbPos();
3714 :
3715 : // set adjustment type
3716 0 : ScrollType aType = pScrollBar->GetType();
3717 0 : if ( aType == SCROLL_LINEUP || aType == SCROLL_LINEDOWN )
3718 : {
3719 0 : aEvent.Type = ::com::sun::star::awt::AdjustmentType_ADJUST_LINE;
3720 : }
3721 0 : else if ( aType == SCROLL_PAGEUP || aType == SCROLL_PAGEDOWN )
3722 : {
3723 0 : aEvent.Type = ::com::sun::star::awt::AdjustmentType_ADJUST_PAGE;
3724 : }
3725 0 : else if ( aType == SCROLL_DRAG )
3726 : {
3727 0 : aEvent.Type = ::com::sun::star::awt::AdjustmentType_ADJUST_ABS;
3728 : }
3729 :
3730 0 : maAdjustmentListeners.adjustmentValueChanged( aEvent );
3731 0 : }
3732 2 : }
3733 : }
3734 2 : break;
3735 :
3736 : default:
3737 63 : VCLXWindow::ProcessWindowEvent( rVclWindowEvent );
3738 63 : break;
3739 : }
3740 65 : }
3741 :
3742 0 : ::com::sun::star::awt::Size SAL_CALL VCLXScrollBar::implGetMinimumSize( vcl::Window* p ) throw(::com::sun::star::uno::RuntimeException)
3743 : {
3744 0 : long n = p->GetSettings().GetStyleSettings().GetScrollBarSize();
3745 0 : return ::com::sun::star::awt::Size( n, n );
3746 : }
3747 :
3748 0 : ::com::sun::star::awt::Size SAL_CALL VCLXScrollBar::getMinimumSize() throw(::com::sun::star::uno::RuntimeException, std::exception)
3749 : {
3750 0 : SolarMutexGuard aGuard;
3751 0 : return implGetMinimumSize( GetWindow() );
3752 : }
3753 :
3754 :
3755 :
3756 : // class VCLXEdit
3757 :
3758 :
3759 15 : void VCLXEdit::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
3760 : {
3761 : PushPropertyIds( rIds,
3762 : BASEPROPERTY_ALIGN,
3763 : BASEPROPERTY_BACKGROUNDCOLOR,
3764 : BASEPROPERTY_BORDER,
3765 : BASEPROPERTY_BORDERCOLOR,
3766 : BASEPROPERTY_DEFAULTCONTROL,
3767 : BASEPROPERTY_ECHOCHAR,
3768 : BASEPROPERTY_ENABLED,
3769 : BASEPROPERTY_ENABLEVISIBLE,
3770 : BASEPROPERTY_FONTDESCRIPTOR,
3771 : BASEPROPERTY_HARDLINEBREAKS,
3772 : BASEPROPERTY_HELPTEXT,
3773 : BASEPROPERTY_HELPURL,
3774 : BASEPROPERTY_HSCROLL,
3775 : BASEPROPERTY_LINE_END_FORMAT,
3776 : BASEPROPERTY_MAXTEXTLEN,
3777 : BASEPROPERTY_MULTILINE,
3778 : BASEPROPERTY_PRINTABLE,
3779 : BASEPROPERTY_READONLY,
3780 : BASEPROPERTY_TABSTOP,
3781 : BASEPROPERTY_TEXT,
3782 : BASEPROPERTY_VSCROLL,
3783 : BASEPROPERTY_HIDEINACTIVESELECTION,
3784 : BASEPROPERTY_PAINTTRANSPARENT,
3785 : BASEPROPERTY_AUTOHSCROLL,
3786 : BASEPROPERTY_AUTOVSCROLL,
3787 : BASEPROPERTY_VERTICALALIGN,
3788 : BASEPROPERTY_WRITING_MODE,
3789 : BASEPROPERTY_CONTEXT_WRITING_MODE,
3790 15 : 0);
3791 15 : VCLXWindow::ImplGetPropertyIds( rIds );
3792 15 : }
3793 :
3794 2655 : VCLXEdit::VCLXEdit() : maTextListeners( *this )
3795 : {
3796 2655 : }
3797 :
3798 : // ::com::sun::star::uno::XInterface
3799 53165 : ::com::sun::star::uno::Any VCLXEdit::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3800 : {
3801 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
3802 : (static_cast< ::com::sun::star::awt::XTextComponent* >(this)),
3803 : (static_cast< ::com::sun::star::awt::XTextEditField* >(this)),
3804 53165 : (static_cast< ::com::sun::star::awt::XTextLayoutConstrains* >(this)) );
3805 53165 : return (aRet.hasValue() ? aRet : VCLXWindow::queryInterface( rType ));
3806 : }
3807 :
3808 : // ::com::sun::star::lang::XTypeProvider
3809 0 : IMPL_XTYPEPROVIDER_START( VCLXEdit )
3810 0 : cppu::UnoType<com::sun::star::awt::XTextComponent>::get(),
3811 0 : cppu::UnoType<com::sun::star::awt::XTextEditField>::get(),
3812 0 : cppu::UnoType<com::sun::star::awt::XTextLayoutConstrains>::get(),
3813 : VCLXWindow::getTypes()
3814 0 : IMPL_XTYPEPROVIDER_END
3815 :
3816 8 : ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXEdit::CreateAccessibleContext()
3817 : {
3818 8 : return getAccessibleFactory().createAccessibleContext( this );
3819 : }
3820 :
3821 2856 : void VCLXEdit::dispose() throw(::com::sun::star::uno::RuntimeException, std::exception)
3822 : {
3823 2856 : SolarMutexGuard aGuard;
3824 :
3825 5712 : ::com::sun::star::lang::EventObject aObj;
3826 2856 : aObj.Source = static_cast<cppu::OWeakObject*>(this);
3827 2856 : maTextListeners.disposeAndClear( aObj );
3828 5712 : VCLXWindow::dispose();
3829 2856 : }
3830 :
3831 192 : void VCLXEdit::addTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3832 : {
3833 192 : SolarMutexGuard aGuard;
3834 192 : GetTextListeners().addInterface( l );
3835 192 : }
3836 :
3837 0 : void VCLXEdit::removeTextListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XTextListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3838 : {
3839 0 : SolarMutexGuard aGuard;
3840 0 : GetTextListeners().removeInterface( l );
3841 0 : }
3842 :
3843 304 : void VCLXEdit::setText( const OUString& aText ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3844 : {
3845 304 : SolarMutexGuard aGuard;
3846 :
3847 608 : VclPtr< Edit > pEdit = GetAs< Edit >();
3848 304 : if ( pEdit )
3849 : {
3850 304 : pEdit->SetText( aText );
3851 :
3852 : // #107218# Call same listeners like VCL would do after user interaction
3853 304 : SetSynthesizingVCLEvent( true );
3854 304 : pEdit->SetModifyFlag();
3855 304 : pEdit->Modify();
3856 304 : SetSynthesizingVCLEvent( false );
3857 304 : }
3858 304 : }
3859 :
3860 0 : void VCLXEdit::insertText( const ::com::sun::star::awt::Selection& rSel, const OUString& aText ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3861 : {
3862 0 : SolarMutexGuard aGuard;
3863 :
3864 0 : VclPtr< Edit > pEdit = GetAs< Edit >();
3865 0 : if ( pEdit )
3866 : {
3867 0 : pEdit->SetSelection( Selection( rSel.Min, rSel.Max ) );
3868 0 : pEdit->ReplaceSelected( aText );
3869 :
3870 : // #107218# Call same listeners like VCL would do after user interaction
3871 0 : SetSynthesizingVCLEvent( true );
3872 0 : pEdit->SetModifyFlag();
3873 0 : pEdit->Modify();
3874 0 : SetSynthesizingVCLEvent( false );
3875 0 : }
3876 0 : }
3877 :
3878 24 : OUString VCLXEdit::getText() throw(::com::sun::star::uno::RuntimeException, std::exception)
3879 : {
3880 24 : SolarMutexGuard aGuard;
3881 :
3882 24 : OUString aText;
3883 48 : VclPtr< vcl::Window > pWindow = GetWindow();
3884 24 : if ( pWindow )
3885 24 : aText = pWindow->GetText();
3886 48 : return aText;
3887 : }
3888 :
3889 15 : OUString VCLXEdit::getSelectedText() throw(::com::sun::star::uno::RuntimeException, std::exception)
3890 : {
3891 15 : SolarMutexGuard aGuard;
3892 :
3893 15 : OUString aText;
3894 30 : VclPtr< Edit > pEdit = GetAs< Edit >();
3895 15 : if ( pEdit)
3896 15 : aText = pEdit->GetSelected();
3897 30 : return aText;
3898 :
3899 : }
3900 :
3901 60 : void VCLXEdit::setSelection( const ::com::sun::star::awt::Selection& aSelection ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3902 : {
3903 60 : SolarMutexGuard aGuard;
3904 :
3905 120 : VclPtr< Edit > pEdit = GetAs< Edit >();
3906 60 : if ( pEdit )
3907 120 : pEdit->SetSelection( Selection( aSelection.Min, aSelection.Max ) );
3908 60 : }
3909 :
3910 63 : ::com::sun::star::awt::Selection VCLXEdit::getSelection() throw(::com::sun::star::uno::RuntimeException, std::exception)
3911 : {
3912 63 : SolarMutexGuard aGuard;
3913 :
3914 63 : Selection aSel;
3915 126 : VclPtr< Edit > pEdit = GetAs< Edit >();
3916 63 : if ( pEdit )
3917 63 : aSel = pEdit->GetSelection();
3918 126 : return ::com::sun::star::awt::Selection( aSel.Min(), aSel.Max() );
3919 : }
3920 :
3921 15 : sal_Bool VCLXEdit::isEditable() throw(::com::sun::star::uno::RuntimeException, std::exception)
3922 : {
3923 15 : SolarMutexGuard aGuard;
3924 :
3925 30 : VclPtr< Edit > pEdit = GetAs< Edit >();
3926 30 : return ( pEdit && !pEdit->IsReadOnly() && pEdit->IsEnabled() ) ? sal_True : sal_False;
3927 : }
3928 :
3929 16 : void VCLXEdit::setEditable( sal_Bool bEditable ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3930 : {
3931 16 : SolarMutexGuard aGuard;
3932 :
3933 32 : VclPtr< Edit > pEdit = GetAs< Edit >();
3934 16 : if ( pEdit )
3935 32 : pEdit->SetReadOnly( !bEditable );
3936 16 : }
3937 :
3938 :
3939 16 : void VCLXEdit::setMaxTextLen( sal_Int16 nLen ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3940 : {
3941 16 : SolarMutexGuard aGuard;
3942 :
3943 32 : VclPtr< Edit > pEdit = GetAs< Edit >();
3944 16 : if ( pEdit )
3945 32 : pEdit->SetMaxTextLen( nLen );
3946 16 : }
3947 :
3948 0 : sal_Int16 VCLXEdit::getMaxTextLen() throw(::com::sun::star::uno::RuntimeException, std::exception)
3949 : {
3950 0 : SolarMutexGuard aGuard;
3951 :
3952 0 : VclPtr< Edit > pEdit = GetAs< Edit >();
3953 0 : return pEdit ? pEdit->GetMaxTextLen() : 0;
3954 : }
3955 :
3956 0 : void VCLXEdit::setEchoChar( sal_Unicode cEcho ) throw(::com::sun::star::uno::RuntimeException, std::exception)
3957 : {
3958 0 : SolarMutexGuard aGuard;
3959 :
3960 0 : VclPtr< Edit > pEdit = GetAs< Edit >();
3961 0 : if ( pEdit )
3962 0 : pEdit->SetEchoChar( cEcho );
3963 0 : }
3964 :
3965 15980 : void VCLXEdit::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
3966 : {
3967 15980 : SolarMutexGuard aGuard;
3968 :
3969 31960 : VclPtr< Edit > pEdit = GetAs< Edit >();
3970 15980 : if ( pEdit )
3971 : {
3972 15980 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
3973 15980 : switch ( nPropType )
3974 : {
3975 : case BASEPROPERTY_HIDEINACTIVESELECTION:
3976 228 : ::toolkit::adjustBooleanWindowStyle( Value, pEdit, WB_NOHIDESELECTION, true );
3977 228 : if ( pEdit->GetSubEdit() )
3978 92 : ::toolkit::adjustBooleanWindowStyle( Value, pEdit->GetSubEdit(), WB_NOHIDESELECTION, true );
3979 228 : break;
3980 :
3981 : case BASEPROPERTY_READONLY:
3982 : {
3983 258 : bool b = bool();
3984 258 : if ( Value >>= b )
3985 258 : pEdit->SetReadOnly( b );
3986 : }
3987 258 : break;
3988 : case BASEPROPERTY_ECHOCHAR:
3989 : {
3990 56 : sal_Int16 n = sal_Int16();
3991 56 : if ( Value >>= n )
3992 56 : pEdit->SetEchoChar( n );
3993 : }
3994 56 : break;
3995 : case BASEPROPERTY_MAXTEXTLEN:
3996 : {
3997 127 : sal_Int16 n = sal_Int16();
3998 127 : if ( Value >>= n )
3999 127 : pEdit->SetMaxTextLen( n );
4000 : }
4001 127 : break;
4002 : default:
4003 : {
4004 15311 : VCLXWindow::setProperty( PropertyName, Value );
4005 : }
4006 : }
4007 15980 : }
4008 15980 : }
4009 :
4010 52 : ::com::sun::star::uno::Any VCLXEdit::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4011 : {
4012 52 : SolarMutexGuard aGuard;
4013 :
4014 52 : ::com::sun::star::uno::Any aProp;
4015 104 : VclPtr< Edit > pEdit = GetAs< Edit >();
4016 52 : if ( pEdit )
4017 : {
4018 52 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
4019 52 : switch ( nPropType )
4020 : {
4021 : case BASEPROPERTY_HIDEINACTIVESELECTION:
4022 0 : aProp <<= ( ( pEdit->GetStyle() & WB_NOHIDESELECTION ) == 0 );
4023 0 : break;
4024 : case BASEPROPERTY_READONLY:
4025 0 : aProp <<= pEdit->IsReadOnly();
4026 0 : break;
4027 : case BASEPROPERTY_ECHOCHAR:
4028 0 : aProp <<= (sal_Int16) pEdit->GetEchoChar();
4029 0 : break;
4030 : case BASEPROPERTY_MAXTEXTLEN:
4031 0 : aProp <<= (sal_Int16) pEdit->GetMaxTextLen();
4032 0 : break;
4033 : default:
4034 : {
4035 52 : aProp = VCLXWindow::getProperty( PropertyName );
4036 : }
4037 : }
4038 : }
4039 104 : return aProp;
4040 : }
4041 :
4042 26 : ::com::sun::star::awt::Size VCLXEdit::getMinimumSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4043 : {
4044 26 : SolarMutexGuard aGuard;
4045 :
4046 26 : Size aSz;
4047 52 : VclPtr< Edit > pEdit = GetAs< Edit >();
4048 26 : if ( pEdit )
4049 26 : aSz = pEdit->CalcMinimumSize();
4050 52 : return AWTSize(aSz);
4051 : }
4052 :
4053 14 : ::com::sun::star::awt::Size VCLXEdit::getPreferredSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4054 : {
4055 14 : SolarMutexGuard aGuard;
4056 :
4057 14 : Size aSz;
4058 28 : VclPtr< Edit > pEdit = GetAs< Edit >();
4059 14 : if ( pEdit )
4060 : {
4061 14 : aSz = pEdit->CalcMinimumSize();
4062 14 : aSz.Height() += 4;
4063 : }
4064 28 : return AWTSize(aSz);
4065 : }
4066 :
4067 13 : ::com::sun::star::awt::Size VCLXEdit::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4068 : {
4069 13 : SolarMutexGuard aGuard;
4070 :
4071 13 : ::com::sun::star::awt::Size aSz = rNewSize;
4072 13 : ::com::sun::star::awt::Size aMinSz = getMinimumSize();
4073 13 : if ( aSz.Height != aMinSz.Height )
4074 13 : aSz.Height = aMinSz.Height;
4075 :
4076 13 : return aSz;
4077 : }
4078 :
4079 14 : ::com::sun::star::awt::Size VCLXEdit::getMinimumSize( sal_Int16 nCols, sal_Int16 ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4080 : {
4081 14 : SolarMutexGuard aGuard;
4082 :
4083 14 : Size aSz;
4084 28 : VclPtr< Edit > pEdit = GetAs< Edit >();
4085 14 : if ( pEdit )
4086 : {
4087 14 : if ( nCols )
4088 1 : aSz = pEdit->CalcSize( nCols );
4089 : else
4090 13 : aSz = pEdit->CalcMinimumSize();
4091 : }
4092 28 : return AWTSize(aSz);
4093 : }
4094 :
4095 13 : void VCLXEdit::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4096 : {
4097 13 : SolarMutexGuard aGuard;
4098 :
4099 13 : nLines = 1;
4100 13 : nCols = 0;
4101 26 : VclPtr< Edit > pEdit = GetAs< Edit >();
4102 13 : if ( pEdit )
4103 26 : nCols = pEdit->GetMaxVisChars();
4104 13 : }
4105 :
4106 171457 : void VCLXEdit::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
4107 : {
4108 171457 : switch ( rVclWindowEvent.GetId() )
4109 : {
4110 : case VCLEVENT_EDIT_MODIFY:
4111 : {
4112 168 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
4113 : // since we call listeners below, there is a potential that we will be destroyed
4114 : // during the listener call. To prevent the resulting crashs, we keep us
4115 : // alive as long as we're here
4116 :
4117 168 : if ( GetTextListeners().getLength() )
4118 : {
4119 168 : ::com::sun::star::awt::TextEvent aEvent;
4120 168 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
4121 168 : GetTextListeners().textChanged( aEvent );
4122 168 : }
4123 : }
4124 168 : break;
4125 :
4126 : default:
4127 171289 : VCLXWindow::ProcessWindowEvent( rVclWindowEvent );
4128 171289 : break;
4129 : }
4130 171457 : }
4131 :
4132 :
4133 : // class VCLXComboBox
4134 :
4135 :
4136 35 : void VCLXComboBox::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
4137 : {
4138 : PushPropertyIds( rIds,
4139 : BASEPROPERTY_AUTOCOMPLETE,
4140 : BASEPROPERTY_BACKGROUNDCOLOR,
4141 : BASEPROPERTY_BORDER,
4142 : BASEPROPERTY_BORDERCOLOR,
4143 : BASEPROPERTY_DEFAULTCONTROL,
4144 : BASEPROPERTY_DROPDOWN,
4145 : BASEPROPERTY_ENABLED,
4146 : BASEPROPERTY_ENABLEVISIBLE,
4147 : BASEPROPERTY_FONTDESCRIPTOR,
4148 : BASEPROPERTY_HELPTEXT,
4149 : BASEPROPERTY_HELPURL,
4150 : BASEPROPERTY_LINECOUNT,
4151 : BASEPROPERTY_MAXTEXTLEN,
4152 : BASEPROPERTY_PRINTABLE,
4153 : BASEPROPERTY_READONLY,
4154 : BASEPROPERTY_STRINGITEMLIST,
4155 : BASEPROPERTY_TABSTOP,
4156 : BASEPROPERTY_TEXT,
4157 : BASEPROPERTY_HIDEINACTIVESELECTION,
4158 : BASEPROPERTY_ALIGN,
4159 : BASEPROPERTY_WRITING_MODE,
4160 : BASEPROPERTY_CONTEXT_WRITING_MODE,
4161 : BASEPROPERTY_REFERENCE_DEVICE,
4162 : BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
4163 35 : 0);
4164 : // no, don't call VCLXEdit here - it has properties which we do *not* want to have at combo box
4165 : // #i92690# / 2008-08-12 / frank.schoenheit@sun.com
4166 : // VCLXEdit::ImplGetPropertyIds( rIds );
4167 35 : VCLXWindow::ImplGetPropertyIds( rIds );
4168 35 : }
4169 :
4170 2498 : VCLXComboBox::VCLXComboBox()
4171 2498 : : maActionListeners( *this ), maItemListeners( *this )
4172 : {
4173 2498 : }
4174 :
4175 4960 : VCLXComboBox::~VCLXComboBox()
4176 : {
4177 : OSL_TRACE ("%s", __FUNCTION__);
4178 4960 : }
4179 :
4180 5 : ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXComboBox::CreateAccessibleContext()
4181 : {
4182 5 : SolarMutexGuard aGuard;
4183 :
4184 5 : return getAccessibleFactory().createAccessibleContext( this );
4185 : }
4186 :
4187 2532 : void VCLXComboBox::dispose() throw(::com::sun::star::uno::RuntimeException, std::exception)
4188 : {
4189 2532 : SolarMutexGuard aGuard;
4190 :
4191 5064 : ::com::sun::star::lang::EventObject aObj;
4192 2532 : aObj.Source = static_cast<cppu::OWeakObject*>(this);
4193 2532 : maItemListeners.disposeAndClear( aObj );
4194 2532 : maActionListeners.disposeAndClear( aObj );
4195 5064 : VCLXEdit::dispose();
4196 2532 : }
4197 :
4198 :
4199 3 : void VCLXComboBox::addItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4200 : {
4201 3 : SolarMutexGuard aGuard;
4202 3 : maItemListeners.addInterface( l );
4203 3 : }
4204 :
4205 0 : void VCLXComboBox::removeItemListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XItemListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4206 : {
4207 0 : SolarMutexGuard aGuard;
4208 0 : maItemListeners.removeInterface( l );
4209 0 : }
4210 :
4211 3 : void VCLXComboBox::addActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4212 : {
4213 3 : SolarMutexGuard aGuard;
4214 3 : maActionListeners.addInterface( l );
4215 3 : }
4216 :
4217 0 : void VCLXComboBox::removeActionListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XActionListener > & l ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4218 : {
4219 0 : SolarMutexGuard aGuard;
4220 0 : maActionListeners.removeInterface( l );
4221 0 : }
4222 :
4223 0 : void VCLXComboBox::addItem( const OUString& aItem, sal_Int16 nPos ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4224 : {
4225 0 : SolarMutexGuard aGuard;
4226 :
4227 0 : VclPtr< ComboBox > pBox = GetAs< ComboBox >();
4228 0 : if ( pBox )
4229 0 : pBox->InsertEntry( aItem, nPos );
4230 0 : }
4231 :
4232 0 : void VCLXComboBox::addItems( const ::com::sun::star::uno::Sequence< OUString>& aItems, sal_Int16 nPos ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4233 : {
4234 0 : SolarMutexGuard aGuard;
4235 :
4236 0 : VclPtr< ComboBox > pBox = GetAs< ComboBox >();
4237 0 : if ( pBox )
4238 : {
4239 0 : sal_uInt16 nP = nPos;
4240 0 : for ( sal_Int32 n = 0; n < aItems.getLength(); n++ )
4241 : {
4242 0 : pBox->InsertEntry( aItems.getConstArray()[n], nP );
4243 0 : if ( nP == 0xFFFF )
4244 : {
4245 : OSL_FAIL( "VCLXComboBox::addItems: too many entries!" );
4246 : // skip remaining entries, list cannot hold them, anyway
4247 0 : break;
4248 : }
4249 : }
4250 0 : }
4251 0 : }
4252 :
4253 0 : void VCLXComboBox::removeItems( sal_Int16 nPos, sal_Int16 nCount ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4254 : {
4255 0 : SolarMutexGuard aGuard;
4256 :
4257 0 : VclPtr< ComboBox > pBox = GetAs< ComboBox >();
4258 0 : if ( pBox )
4259 : {
4260 0 : for ( sal_uInt16 n = nCount; n; )
4261 0 : pBox->RemoveEntryAt( nPos + (--n) );
4262 0 : }
4263 0 : }
4264 :
4265 0 : sal_Int16 VCLXComboBox::getItemCount() throw(::com::sun::star::uno::RuntimeException, std::exception)
4266 : {
4267 0 : SolarMutexGuard aGuard;
4268 :
4269 0 : VclPtr< ComboBox > pBox = GetAs< ComboBox >();
4270 0 : return pBox ? pBox->GetEntryCount() : 0;
4271 : }
4272 :
4273 0 : OUString VCLXComboBox::getItem( sal_Int16 nPos ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4274 : {
4275 0 : SolarMutexGuard aGuard;
4276 :
4277 0 : OUString aItem;
4278 0 : VclPtr< ComboBox > pBox = GetAs< ComboBox >();
4279 0 : if ( pBox )
4280 0 : aItem = pBox->GetEntry( nPos );
4281 0 : return aItem;
4282 : }
4283 :
4284 0 : ::com::sun::star::uno::Sequence< OUString> VCLXComboBox::getItems() throw(::com::sun::star::uno::RuntimeException, std::exception)
4285 : {
4286 0 : SolarMutexGuard aGuard;
4287 :
4288 0 : ::com::sun::star::uno::Sequence< OUString> aSeq;
4289 0 : VclPtr< ComboBox > pBox = GetAs< ComboBox >();
4290 0 : if ( pBox )
4291 : {
4292 0 : sal_uInt16 nEntries = pBox->GetEntryCount();
4293 0 : aSeq = ::com::sun::star::uno::Sequence< OUString>( nEntries );
4294 0 : for ( sal_uInt16 n = nEntries; n; )
4295 : {
4296 0 : --n;
4297 0 : aSeq.getArray()[n] = pBox->GetEntry( n );
4298 : }
4299 : }
4300 0 : return aSeq;
4301 : }
4302 :
4303 0 : void VCLXComboBox::setDropDownLineCount( sal_Int16 nLines ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4304 : {
4305 0 : SolarMutexGuard aGuard;
4306 :
4307 0 : VclPtr< ComboBox > pBox = GetAs< ComboBox >();
4308 0 : if ( pBox )
4309 0 : pBox->SetDropDownLineCount( nLines );
4310 0 : }
4311 :
4312 0 : sal_Int16 VCLXComboBox::getDropDownLineCount() throw(::com::sun::star::uno::RuntimeException, std::exception)
4313 : {
4314 0 : SolarMutexGuard aGuard;
4315 :
4316 0 : sal_Int16 nLines = 0;
4317 0 : VclPtr< ComboBox > pBox = GetAs< ComboBox >();
4318 0 : if ( pBox )
4319 0 : nLines = pBox->GetDropDownLineCount();
4320 0 : return nLines;
4321 : }
4322 :
4323 2082 : void VCLXComboBox::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
4324 : {
4325 2082 : SolarMutexGuard aGuard;
4326 :
4327 4164 : VclPtr< ComboBox > pComboBox = GetAs< ComboBox >();
4328 2082 : if ( pComboBox )
4329 : {
4330 2082 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
4331 2082 : switch ( nPropType )
4332 : {
4333 : case BASEPROPERTY_LINECOUNT:
4334 : {
4335 34 : sal_Int16 n = sal_Int16();
4336 34 : if ( Value >>= n )
4337 34 : pComboBox->SetDropDownLineCount( n );
4338 : }
4339 34 : break;
4340 : case BASEPROPERTY_AUTOCOMPLETE:
4341 : {
4342 36 : sal_Int16 n = sal_Int16();
4343 36 : if ( Value >>= n )
4344 0 : pComboBox->EnableAutocomplete( n != 0, true );
4345 : else
4346 : {
4347 36 : bool b = bool();
4348 36 : if ( Value >>= b )
4349 36 : pComboBox->EnableAutocomplete( b, true );
4350 : }
4351 : }
4352 36 : break;
4353 : case BASEPROPERTY_STRINGITEMLIST:
4354 : {
4355 0 : ::com::sun::star::uno::Sequence< OUString> aItems;
4356 0 : if ( Value >>= aItems )
4357 : {
4358 0 : pComboBox->Clear();
4359 0 : addItems( aItems, 0 );
4360 0 : }
4361 : }
4362 0 : break;
4363 : default:
4364 : {
4365 2012 : VCLXEdit::setProperty( PropertyName, Value );
4366 :
4367 : // #109385# SetBorderStyle is not virtual
4368 2012 : if ( nPropType == BASEPROPERTY_BORDER )
4369 : {
4370 28 : sal_uInt16 nBorder = sal_uInt16();
4371 28 : if ( (Value >>= nBorder) && nBorder != 0 )
4372 28 : pComboBox->SetBorderStyle( static_cast<WindowBorderStyle>(nBorder) );
4373 : }
4374 : }
4375 : }
4376 2082 : }
4377 2082 : }
4378 :
4379 0 : ::com::sun::star::uno::Any VCLXComboBox::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4380 : {
4381 0 : SolarMutexGuard aGuard;
4382 :
4383 0 : ::com::sun::star::uno::Any aProp;
4384 0 : VclPtr< ComboBox > pComboBox = GetAs< ComboBox >();
4385 0 : if ( pComboBox )
4386 : {
4387 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
4388 0 : switch ( nPropType )
4389 : {
4390 : case BASEPROPERTY_LINECOUNT:
4391 : {
4392 0 : aProp <<= (sal_Int16) pComboBox->GetDropDownLineCount();
4393 : }
4394 0 : break;
4395 : case BASEPROPERTY_AUTOCOMPLETE:
4396 : {
4397 0 : aProp <<= pComboBox->IsAutocompleteEnabled();
4398 : }
4399 0 : break;
4400 : case BASEPROPERTY_STRINGITEMLIST:
4401 : {
4402 0 : sal_uInt16 nItems = pComboBox->GetEntryCount();
4403 0 : ::com::sun::star::uno::Sequence< OUString> aSeq( nItems );
4404 0 : OUString* pStrings = aSeq.getArray();
4405 0 : for ( sal_uInt16 n = 0; n < nItems; n++ )
4406 0 : pStrings[n] = pComboBox->GetEntry( n );
4407 0 : aProp <<= aSeq;
4408 :
4409 : }
4410 0 : break;
4411 : default:
4412 : {
4413 0 : aProp <<= VCLXEdit::getProperty( PropertyName );
4414 : }
4415 : }
4416 : }
4417 0 : return aProp;
4418 : }
4419 :
4420 167078 : void VCLXComboBox::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
4421 : {
4422 167078 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
4423 : // since we call listeners below, there is a potential that we will be destroyed
4424 : // during the listener call. To prevent the resulting crashs, we keep us
4425 : // alive as long as we're here
4426 :
4427 167078 : switch ( rVclWindowEvent.GetId() )
4428 : {
4429 : case VCLEVENT_COMBOBOX_SELECT:
4430 0 : if ( maItemListeners.getLength() )
4431 : {
4432 0 : VclPtr< ComboBox > pComboBox = GetAs< ComboBox >();
4433 0 : if( pComboBox )
4434 : {
4435 0 : if ( !pComboBox->IsTravelSelect() )
4436 : {
4437 0 : ::com::sun::star::awt::ItemEvent aEvent;
4438 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
4439 0 : aEvent.Highlighted = 0;
4440 :
4441 : // Set to 0xFFFF on multiple selection, selected entry ID otherwise
4442 0 : aEvent.Selected = pComboBox->GetEntryPos( pComboBox->GetText() );
4443 :
4444 0 : maItemListeners.itemStateChanged( aEvent );
4445 : }
4446 0 : }
4447 : }
4448 0 : break;
4449 :
4450 : case VCLEVENT_COMBOBOX_DOUBLECLICK:
4451 0 : if ( maActionListeners.getLength() )
4452 : {
4453 0 : ::com::sun::star::awt::ActionEvent aEvent;
4454 0 : aEvent.Source = static_cast<cppu::OWeakObject*>(this);
4455 : // aEvent.ActionCommand = ...;
4456 0 : maActionListeners.actionPerformed( aEvent );
4457 : }
4458 0 : break;
4459 :
4460 : default:
4461 167078 : VCLXEdit::ProcessWindowEvent( rVclWindowEvent );
4462 167078 : break;
4463 167078 : }
4464 167078 : }
4465 :
4466 2 : ::com::sun::star::awt::Size VCLXComboBox::getMinimumSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4467 : {
4468 2 : SolarMutexGuard aGuard;
4469 :
4470 2 : Size aSz;
4471 4 : VclPtr< ComboBox > pComboBox = GetAs< ComboBox >();
4472 2 : if ( pComboBox )
4473 2 : aSz = pComboBox->CalcMinimumSize();
4474 4 : return AWTSize(aSz);
4475 : }
4476 :
4477 2 : ::com::sun::star::awt::Size VCLXComboBox::getPreferredSize( ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4478 : {
4479 2 : SolarMutexGuard aGuard;
4480 :
4481 2 : Size aSz;
4482 4 : VclPtr< ComboBox > pComboBox = GetAs< ComboBox >();
4483 2 : if ( pComboBox )
4484 : {
4485 2 : aSz = pComboBox->CalcMinimumSize();
4486 2 : if ( pComboBox->GetStyle() & WB_DROPDOWN )
4487 0 : aSz.Height() += 4;
4488 : }
4489 4 : return AWTSize(aSz);
4490 : }
4491 :
4492 2 : ::com::sun::star::awt::Size VCLXComboBox::calcAdjustedSize( const ::com::sun::star::awt::Size& rNewSize ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4493 : {
4494 2 : SolarMutexGuard aGuard;
4495 :
4496 2 : Size aSz = VCLSize(rNewSize);
4497 4 : VclPtr< ComboBox > pComboBox = GetAs< ComboBox >();
4498 2 : if ( pComboBox )
4499 2 : aSz = pComboBox->CalcAdjustedSize( aSz );
4500 4 : return AWTSize(aSz);
4501 : }
4502 :
4503 2 : ::com::sun::star::awt::Size VCLXComboBox::getMinimumSize( sal_Int16 nCols, sal_Int16 nLines ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4504 : {
4505 2 : SolarMutexGuard aGuard;
4506 :
4507 2 : Size aSz;
4508 4 : VclPtr< ComboBox > pComboBox = GetAs< ComboBox >();
4509 2 : if ( pComboBox )
4510 2 : aSz = pComboBox->CalcBlockSize( nCols, nLines );
4511 4 : return AWTSize(aSz);
4512 : }
4513 :
4514 2 : void VCLXComboBox::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4515 : {
4516 2 : SolarMutexGuard aGuard;
4517 :
4518 2 : nCols = nLines = 0;
4519 4 : VclPtr< ComboBox > pComboBox = GetAs< ComboBox >();
4520 2 : if ( pComboBox )
4521 : {
4522 : sal_uInt16 nC, nL;
4523 2 : pComboBox->GetMaxVisColumnsAndLines( nC, nL );
4524 2 : nCols = nC;
4525 2 : nLines = nL;
4526 2 : }
4527 2 : }
4528 0 : void SAL_CALL VCLXComboBox::listItemInserted( const ItemListEvent& i_rEvent ) throw (RuntimeException, std::exception)
4529 : {
4530 0 : SolarMutexGuard aGuard;
4531 :
4532 0 : VclPtr< ComboBox > pComboBox = GetAsDynamic< ComboBox >();
4533 :
4534 0 : ENSURE_OR_RETURN_VOID( pComboBox, "VCLXComboBox::listItemInserted: no ComboBox?!" );
4535 0 : ENSURE_OR_RETURN_VOID( ( i_rEvent.ItemPosition >= 0 ) && ( i_rEvent.ItemPosition <= sal_Int32( pComboBox->GetEntryCount() ) ),
4536 : "VCLXComboBox::listItemInserted: illegal (inconsistent) item position!" );
4537 : pComboBox->InsertEntryWithImage(
4538 : i_rEvent.ItemText.IsPresent ? i_rEvent.ItemText.Value : OUString(),
4539 : i_rEvent.ItemImageURL.IsPresent ? lcl_getImageFromURL( i_rEvent.ItemImageURL.Value ) : Image(),
4540 0 : i_rEvent.ItemPosition );
4541 : }
4542 :
4543 0 : void SAL_CALL VCLXComboBox::listItemRemoved( const ItemListEvent& i_rEvent ) throw (RuntimeException, std::exception)
4544 : {
4545 0 : SolarMutexGuard aGuard;
4546 :
4547 0 : VclPtr< ComboBox > pComboBox = GetAsDynamic< ComboBox >();
4548 :
4549 0 : ENSURE_OR_RETURN_VOID( pComboBox, "VCLXComboBox::listItemRemoved: no ComboBox?!" );
4550 0 : ENSURE_OR_RETURN_VOID( ( i_rEvent.ItemPosition >= 0 ) && ( i_rEvent.ItemPosition < sal_Int32( pComboBox->GetEntryCount() ) ),
4551 : "VCLXComboBox::listItemRemoved: illegal (inconsistent) item position!" );
4552 :
4553 0 : pComboBox->RemoveEntryAt( i_rEvent.ItemPosition );
4554 : }
4555 :
4556 0 : void SAL_CALL VCLXComboBox::listItemModified( const ItemListEvent& i_rEvent ) throw (RuntimeException, std::exception)
4557 : {
4558 0 : SolarMutexGuard aGuard;
4559 :
4560 0 : VclPtr< ComboBox > pComboBox = GetAsDynamic< ComboBox >();
4561 :
4562 0 : ENSURE_OR_RETURN_VOID( pComboBox, "VCLXComboBox::listItemModified: no ComboBox?!" );
4563 0 : ENSURE_OR_RETURN_VOID( ( i_rEvent.ItemPosition >= 0 ) && ( i_rEvent.ItemPosition < sal_Int32( pComboBox->GetEntryCount() ) ),
4564 : "VCLXComboBox::listItemModified: illegal (inconsistent) item position!" );
4565 :
4566 : // VCL's ComboBox does not support changing an entry's text or image, so remove and re-insert
4567 :
4568 0 : const OUString sNewText = i_rEvent.ItemText.IsPresent ? i_rEvent.ItemText.Value : OUString( pComboBox->GetEntry( i_rEvent.ItemPosition ) );
4569 0 : const Image aNewImage( i_rEvent.ItemImageURL.IsPresent ? lcl_getImageFromURL( i_rEvent.ItemImageURL.Value ) : pComboBox->GetEntryImage( i_rEvent.ItemPosition ) );
4570 :
4571 0 : pComboBox->RemoveEntryAt( i_rEvent.ItemPosition );
4572 0 : pComboBox->InsertEntryWithImage(sNewText, aNewImage, i_rEvent.ItemPosition);
4573 : }
4574 :
4575 0 : void SAL_CALL VCLXComboBox::allItemsRemoved( const EventObject& i_rEvent ) throw (RuntimeException, std::exception)
4576 : {
4577 0 : SolarMutexGuard aGuard;
4578 :
4579 0 : VclPtr< ComboBox > pComboBox = GetAsDynamic< ComboBox >();
4580 0 : ENSURE_OR_RETURN_VOID( pComboBox, "VCLXComboBox::listItemModified: no ComboBox?!" );
4581 :
4582 0 : pComboBox->Clear();
4583 :
4584 0 : (void)i_rEvent;
4585 : }
4586 :
4587 45 : void SAL_CALL VCLXComboBox::itemListChanged( const EventObject& i_rEvent ) throw (RuntimeException, std::exception)
4588 : {
4589 45 : SolarMutexGuard aGuard;
4590 :
4591 90 : VclPtr< ComboBox > pComboBox = GetAsDynamic< ComboBox >();
4592 90 : ENSURE_OR_RETURN_VOID( pComboBox, "VCLXComboBox::listItemModified: no ComboBox?!" );
4593 :
4594 45 : pComboBox->Clear();
4595 :
4596 90 : uno::Reference< beans::XPropertySet > xPropSet( i_rEvent.Source, uno::UNO_QUERY_THROW );
4597 90 : uno::Reference< beans::XPropertySetInfo > xPSI( xPropSet->getPropertySetInfo(), uno::UNO_QUERY_THROW );
4598 : // bool localize = xPSI->hasPropertyByName("ResourceResolver");
4599 90 : uno::Reference< resource::XStringResourceResolver > xStringResourceResolver;
4600 45 : if ( xPSI->hasPropertyByName("ResourceResolver") )
4601 : {
4602 : xStringResourceResolver.set(
4603 1 : xPropSet->getPropertyValue("ResourceResolver"),
4604 : uno::UNO_QUERY
4605 1 : );
4606 : }
4607 :
4608 :
4609 90 : Reference< XItemList > xItemList( i_rEvent.Source, uno::UNO_QUERY_THROW );
4610 90 : uno::Sequence< beans::Pair< OUString, OUString > > aItems = xItemList->getAllItems();
4611 138 : for ( sal_Int32 i=0; i<aItems.getLength(); ++i )
4612 : {
4613 93 : OUString aLocalizationKey( aItems[i].First );
4614 93 : if ( xStringResourceResolver.is() && !aLocalizationKey.isEmpty() && aLocalizationKey[0] == '&' )
4615 : {
4616 0 : aLocalizationKey = xStringResourceResolver->resolveString(aLocalizationKey.copy( 1 ));
4617 : }
4618 : pComboBox->InsertEntryWithImage(aLocalizationKey,
4619 93 : lcl_getImageFromURL(aItems[i].Second));
4620 138 : }
4621 : }
4622 5 : void SAL_CALL VCLXComboBox::disposing( const EventObject& i_rEvent ) throw (RuntimeException, std::exception)
4623 : {
4624 : // just disambiguate
4625 5 : VCLXEdit::disposing( i_rEvent );
4626 5 : }
4627 :
4628 :
4629 : // class VCLXFormattedSpinField
4630 :
4631 102 : void VCLXFormattedSpinField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
4632 : {
4633 : // Interestingly in the UnoControl API this is
4634 : // - not derived from XEdit ultimately, (correct ?) - so cut this here ...
4635 : // VCLXSpinField::ImplGetPropertyIds( rIds );
4636 102 : VCLXWindow::ImplGetPropertyIds( rIds );
4637 102 : }
4638 :
4639 63 : VCLXFormattedSpinField::VCLXFormattedSpinField()
4640 63 : : mpFormatter(NULL)
4641 : {
4642 63 : }
4643 :
4644 58 : VCLXFormattedSpinField::~VCLXFormattedSpinField()
4645 : {
4646 58 : }
4647 :
4648 0 : void VCLXFormattedSpinField::setStrictFormat( bool bStrict )
4649 : {
4650 0 : SolarMutexGuard aGuard;
4651 :
4652 0 : FormatterBase* pFormatter = GetFormatter();
4653 0 : if ( pFormatter )
4654 0 : pFormatter->SetStrictFormat( bStrict );
4655 0 : }
4656 :
4657 0 : bool VCLXFormattedSpinField::isStrictFormat()
4658 : {
4659 0 : FormatterBase* pFormatter = GetFormatter();
4660 0 : return pFormatter && pFormatter->IsStrictFormat();
4661 : }
4662 :
4663 :
4664 4553 : void VCLXFormattedSpinField::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
4665 : {
4666 4553 : SolarMutexGuard aGuard;
4667 :
4668 4553 : FormatterBase* pFormatter = GetFormatter();
4669 4553 : if ( pFormatter )
4670 : {
4671 4553 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
4672 4553 : switch ( nPropType )
4673 : {
4674 : case BASEPROPERTY_SPIN:
4675 : {
4676 52 : bool b = bool();
4677 52 : if ( Value >>= b )
4678 : {
4679 52 : WinBits nStyle = GetWindow()->GetStyle() | WB_SPIN;
4680 52 : if ( !b )
4681 38 : nStyle &= ~WB_SPIN;
4682 52 : GetWindow()->SetStyle( nStyle );
4683 : }
4684 : }
4685 52 : break;
4686 : case BASEPROPERTY_STRICTFORMAT:
4687 : {
4688 91 : bool b = bool();
4689 91 : if ( Value >>= b )
4690 : {
4691 91 : pFormatter->SetStrictFormat( b );
4692 : }
4693 : }
4694 91 : break;
4695 : default:
4696 : {
4697 4410 : VCLXSpinField::setProperty( PropertyName, Value );
4698 : }
4699 : }
4700 4553 : }
4701 4553 : }
4702 :
4703 46 : ::com::sun::star::uno::Any VCLXFormattedSpinField::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4704 : {
4705 46 : SolarMutexGuard aGuard;
4706 :
4707 46 : ::com::sun::star::uno::Any aProp;
4708 46 : FormatterBase* pFormatter = GetFormatter();
4709 46 : if ( pFormatter )
4710 : {
4711 46 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
4712 46 : switch ( nPropType )
4713 : {
4714 : case BASEPROPERTY_TABSTOP:
4715 : {
4716 0 : aProp <<= ( GetWindow()->GetStyle() & WB_SPIN ) != 0;
4717 : }
4718 0 : break;
4719 : case BASEPROPERTY_STRICTFORMAT:
4720 : {
4721 0 : aProp <<= pFormatter->IsStrictFormat();
4722 : }
4723 0 : break;
4724 : default:
4725 : {
4726 46 : aProp <<= VCLXSpinField::getProperty( PropertyName );
4727 : }
4728 : }
4729 : }
4730 46 : return aProp;
4731 : }
4732 :
4733 :
4734 :
4735 : // class VCLXDateField
4736 :
4737 :
4738 40 : void VCLXDateField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
4739 : {
4740 : PushPropertyIds( rIds,
4741 : BASEPROPERTY_ALIGN,
4742 : BASEPROPERTY_BACKGROUNDCOLOR,
4743 : BASEPROPERTY_BORDER,
4744 : BASEPROPERTY_BORDERCOLOR,
4745 : BASEPROPERTY_DATE,
4746 : BASEPROPERTY_DATEMAX,
4747 : BASEPROPERTY_DATEMIN,
4748 : BASEPROPERTY_DATESHOWCENTURY,
4749 : BASEPROPERTY_DEFAULTCONTROL,
4750 : BASEPROPERTY_DROPDOWN,
4751 : BASEPROPERTY_ENABLED,
4752 : BASEPROPERTY_ENABLEVISIBLE,
4753 : BASEPROPERTY_EXTDATEFORMAT,
4754 : BASEPROPERTY_FONTDESCRIPTOR,
4755 : BASEPROPERTY_HELPTEXT,
4756 : BASEPROPERTY_HELPURL,
4757 : BASEPROPERTY_PRINTABLE,
4758 : BASEPROPERTY_READONLY,
4759 : BASEPROPERTY_REPEAT,
4760 : BASEPROPERTY_REPEAT_DELAY,
4761 : BASEPROPERTY_SPIN,
4762 : BASEPROPERTY_STRICTFORMAT,
4763 : BASEPROPERTY_TABSTOP,
4764 : BASEPROPERTY_ENFORCE_FORMAT,
4765 : BASEPROPERTY_TEXT,
4766 : BASEPROPERTY_HIDEINACTIVESELECTION,
4767 : BASEPROPERTY_VERTICALALIGN,
4768 : BASEPROPERTY_WRITING_MODE,
4769 : BASEPROPERTY_CONTEXT_WRITING_MODE,
4770 : BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
4771 40 : 0);
4772 40 : VCLXFormattedSpinField::ImplGetPropertyIds( rIds );
4773 40 : }
4774 :
4775 34 : VCLXDateField::VCLXDateField()
4776 : {
4777 34 : }
4778 :
4779 32 : VCLXDateField::~VCLXDateField()
4780 : {
4781 32 : }
4782 :
4783 : //change the window type here to match the role
4784 0 : ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXDateField::CreateAccessibleContext()
4785 : {
4786 0 : VclPtr< vcl::Window > pWindow = GetWindow();
4787 0 : if ( pWindow )
4788 : {
4789 0 : pWindow->SetType( WINDOW_DATEFIELD );
4790 : }
4791 0 : return getAccessibleFactory().createAccessibleContext( this );
4792 : }
4793 :
4794 : // ::com::sun::star::uno::XInterface
4795 6328 : ::com::sun::star::uno::Any VCLXDateField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4796 : {
4797 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
4798 6328 : (static_cast< ::com::sun::star::awt::XDateField* >(this)) );
4799 6328 : return (aRet.hasValue() ? aRet : VCLXFormattedSpinField::queryInterface( rType ));
4800 : }
4801 :
4802 : // ::com::sun::star::lang::XTypeProvider
4803 0 : IMPL_XTYPEPROVIDER_START( VCLXDateField )
4804 0 : cppu::UnoType<com::sun::star::awt::XDateField>::get(),
4805 : VCLXFormattedSpinField::getTypes()
4806 0 : IMPL_XTYPEPROVIDER_END
4807 :
4808 2631 : void VCLXDateField::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
4809 : {
4810 2631 : SolarMutexGuard aGuard;
4811 :
4812 2631 : if ( GetWindow() )
4813 : {
4814 2631 : bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
4815 :
4816 2631 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
4817 2631 : switch ( nPropType )
4818 : {
4819 : case BASEPROPERTY_DATE:
4820 : {
4821 43 : if ( bVoid )
4822 : {
4823 23 : GetAs< DateField >()->EnableEmptyFieldValue( true );
4824 23 : GetAs< DateField >()->SetEmptyFieldValue();
4825 : }
4826 : else
4827 : {
4828 20 : util::Date d;
4829 20 : if ( Value >>= d )
4830 20 : setDate( d );
4831 : }
4832 : }
4833 43 : break;
4834 : case BASEPROPERTY_DATEMIN:
4835 : {
4836 44 : util::Date d;
4837 44 : if ( Value >>= d )
4838 44 : setMin( d );
4839 : }
4840 44 : break;
4841 : case BASEPROPERTY_DATEMAX:
4842 : {
4843 44 : util::Date d;
4844 44 : if ( Value >>= d )
4845 44 : setMax( d );
4846 : }
4847 44 : break;
4848 : case BASEPROPERTY_EXTDATEFORMAT:
4849 : {
4850 42 : sal_Int16 n = sal_Int16();
4851 42 : if ( Value >>= n )
4852 42 : GetAs< DateField >()->SetExtDateFormat( (ExtDateFieldFormat) n );
4853 : }
4854 42 : break;
4855 : case BASEPROPERTY_DATESHOWCENTURY:
4856 : {
4857 35 : bool b = bool();
4858 35 : if ( Value >>= b )
4859 6 : GetAs< DateField >()->SetShowDateCentury( b );
4860 : }
4861 35 : break;
4862 : case BASEPROPERTY_ENFORCE_FORMAT:
4863 : {
4864 43 : bool bEnforce( true );
4865 43 : OSL_VERIFY( Value >>= bEnforce );
4866 43 : GetAs< DateField >()->EnforceValidValue( bEnforce );
4867 : }
4868 43 : break;
4869 : default:
4870 : {
4871 2380 : VCLXFormattedSpinField::setProperty( PropertyName, Value );
4872 : }
4873 : }
4874 2631 : }
4875 2631 : }
4876 :
4877 30 : ::com::sun::star::uno::Any VCLXDateField::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4878 : {
4879 30 : SolarMutexGuard aGuard;
4880 :
4881 30 : ::com::sun::star::uno::Any aProp;
4882 30 : FormatterBase* pFormatter = GetFormatter();
4883 30 : if ( pFormatter )
4884 : {
4885 30 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
4886 30 : switch ( nPropType )
4887 : {
4888 : case BASEPROPERTY_DATE:
4889 : {
4890 0 : aProp <<= getDate();
4891 : }
4892 0 : break;
4893 : case BASEPROPERTY_DATEMIN:
4894 : {
4895 0 : aProp <<= getMin();
4896 : }
4897 0 : break;
4898 : case BASEPROPERTY_DATEMAX:
4899 : {
4900 0 : aProp <<= getMax();
4901 : }
4902 0 : break;
4903 : case BASEPROPERTY_DATESHOWCENTURY:
4904 : {
4905 0 : aProp <<= GetAs< DateField >()->IsShowDateCentury();
4906 : }
4907 0 : break;
4908 : case BASEPROPERTY_ENFORCE_FORMAT:
4909 : {
4910 4 : aProp <<= GetAs< DateField >()->IsEnforceValidValue( );
4911 : }
4912 4 : break;
4913 : default:
4914 : {
4915 26 : aProp <<= VCLXFormattedSpinField::getProperty( PropertyName );
4916 : }
4917 : }
4918 : }
4919 30 : return aProp;
4920 : }
4921 :
4922 :
4923 20 : void VCLXDateField::setDate( const util::Date& aDate ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4924 : {
4925 20 : SolarMutexGuard aGuard;
4926 :
4927 40 : VclPtr< DateField > pDateField = GetAs< DateField >();
4928 20 : if ( pDateField )
4929 : {
4930 20 : pDateField->SetDate( aDate );
4931 :
4932 : // #107218# Call same listeners like VCL would do after user interaction
4933 20 : SetSynthesizingVCLEvent( true );
4934 20 : pDateField->SetModifyFlag();
4935 20 : pDateField->Modify();
4936 20 : SetSynthesizingVCLEvent( false );
4937 20 : }
4938 20 : }
4939 :
4940 22 : util::Date VCLXDateField::getDate() throw(::com::sun::star::uno::RuntimeException, std::exception)
4941 : {
4942 22 : SolarMutexGuard aGuard;
4943 :
4944 44 : VclPtr< DateField > pDateField = GetAs< DateField >();
4945 22 : if ( pDateField )
4946 22 : return pDateField->GetDate().GetUNODate();
4947 : else
4948 22 : return util::Date();
4949 : }
4950 :
4951 44 : void VCLXDateField::setMin( const util::Date& aDate ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4952 : {
4953 44 : SolarMutexGuard aGuard;
4954 :
4955 88 : VclPtr< DateField > pDateField = GetAs< DateField >();
4956 44 : if ( pDateField )
4957 88 : pDateField->SetMin( aDate );
4958 44 : }
4959 :
4960 0 : util::Date VCLXDateField::getMin() throw(::com::sun::star::uno::RuntimeException, std::exception)
4961 : {
4962 0 : SolarMutexGuard aGuard;
4963 :
4964 0 : VclPtr< DateField > pDateField = GetAs< DateField >();
4965 0 : if ( pDateField )
4966 0 : return pDateField->GetMin().GetUNODate();
4967 : else
4968 0 : return util::Date();
4969 : }
4970 :
4971 44 : void VCLXDateField::setMax( const util::Date& aDate ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4972 : {
4973 44 : SolarMutexGuard aGuard;
4974 :
4975 88 : VclPtr< DateField > pDateField = GetAs< DateField >();
4976 44 : if ( pDateField )
4977 88 : pDateField->SetMax( aDate );
4978 44 : }
4979 :
4980 0 : util::Date VCLXDateField::getMax() throw(::com::sun::star::uno::RuntimeException, std::exception)
4981 : {
4982 0 : SolarMutexGuard aGuard;
4983 :
4984 0 : VclPtr< DateField > pDateField = GetAs< DateField >();
4985 0 : if ( pDateField )
4986 0 : return pDateField->GetMax().GetUNODate();
4987 : else
4988 0 : return util::Date();
4989 : }
4990 :
4991 38 : void VCLXDateField::setFirst( const util::Date& aDate ) throw(::com::sun::star::uno::RuntimeException, std::exception)
4992 : {
4993 38 : SolarMutexGuard aGuard;
4994 :
4995 76 : VclPtr< DateField > pDateField = GetAs< DateField >();
4996 38 : if ( pDateField )
4997 76 : pDateField->SetFirst( aDate );
4998 38 : }
4999 :
5000 0 : util::Date VCLXDateField::getFirst() throw(::com::sun::star::uno::RuntimeException, std::exception)
5001 : {
5002 0 : SolarMutexGuard aGuard;
5003 :
5004 0 : VclPtr< DateField > pDateField = GetAs< DateField >();
5005 0 : if ( pDateField )
5006 0 : return pDateField->GetFirst().GetUNODate();
5007 : else
5008 0 : return util::Date();
5009 : }
5010 :
5011 38 : void VCLXDateField::setLast( const util::Date& aDate ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5012 : {
5013 38 : SolarMutexGuard aGuard;
5014 :
5015 76 : VclPtr< DateField > pDateField = GetAs< DateField >();
5016 38 : if ( pDateField )
5017 76 : pDateField->SetLast( aDate );
5018 38 : }
5019 :
5020 0 : util::Date VCLXDateField::getLast() throw(::com::sun::star::uno::RuntimeException, std::exception)
5021 : {
5022 0 : SolarMutexGuard aGuard;
5023 :
5024 0 : VclPtr< DateField > pDateField = GetAs< DateField >();
5025 0 : if ( pDateField )
5026 0 : return pDateField->GetLast().GetUNODate();
5027 : else
5028 0 : return util::Date();
5029 : }
5030 :
5031 4 : void VCLXDateField::setLongFormat( sal_Bool bLong ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5032 : {
5033 4 : SolarMutexGuard aGuard;
5034 :
5035 8 : VclPtr< DateField > pDateField = GetAs< DateField >();
5036 4 : if ( pDateField )
5037 8 : pDateField->SetLongFormat( bLong );
5038 4 : }
5039 :
5040 0 : sal_Bool VCLXDateField::isLongFormat() throw(::com::sun::star::uno::RuntimeException, std::exception)
5041 : {
5042 0 : SolarMutexGuard aGuard;
5043 :
5044 0 : VclPtr< DateField > pDateField = GetAs< DateField >();
5045 0 : return pDateField ? pDateField->IsLongFormat() : sal_False;
5046 : }
5047 :
5048 2 : void VCLXDateField::setEmpty() throw(::com::sun::star::uno::RuntimeException, std::exception)
5049 : {
5050 2 : SolarMutexGuard aGuard;
5051 :
5052 4 : VclPtr< DateField > pDateField = GetAs< DateField >();
5053 2 : if ( pDateField )
5054 : {
5055 2 : pDateField->SetEmptyDate();
5056 :
5057 : // #107218# Call same listeners like VCL would do after user interaction
5058 2 : SetSynthesizingVCLEvent( true );
5059 2 : pDateField->SetModifyFlag();
5060 2 : pDateField->Modify();
5061 2 : SetSynthesizingVCLEvent( false );
5062 2 : }
5063 2 : }
5064 :
5065 28 : sal_Bool VCLXDateField::isEmpty() throw(::com::sun::star::uno::RuntimeException, std::exception)
5066 : {
5067 28 : SolarMutexGuard aGuard;
5068 :
5069 56 : VclPtr< DateField > pDateField = GetAs< DateField >();
5070 56 : return pDateField ? pDateField->IsEmptyDate() : sal_False;
5071 : }
5072 :
5073 0 : void VCLXDateField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5074 : {
5075 0 : VCLXFormattedSpinField::setStrictFormat( bStrict );
5076 0 : }
5077 :
5078 0 : sal_Bool VCLXDateField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException, std::exception)
5079 : {
5080 0 : return VCLXFormattedSpinField::isStrictFormat();
5081 : }
5082 :
5083 :
5084 :
5085 : // class VCLXTimeField
5086 :
5087 :
5088 16 : void VCLXTimeField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
5089 : {
5090 : PushPropertyIds( rIds,
5091 : BASEPROPERTY_ALIGN,
5092 : BASEPROPERTY_BACKGROUNDCOLOR,
5093 : BASEPROPERTY_BORDER,
5094 : BASEPROPERTY_BORDERCOLOR,
5095 : BASEPROPERTY_DEFAULTCONTROL,
5096 : BASEPROPERTY_ENABLED,
5097 : BASEPROPERTY_ENABLEVISIBLE,
5098 : BASEPROPERTY_EXTTIMEFORMAT,
5099 : BASEPROPERTY_FONTDESCRIPTOR,
5100 : BASEPROPERTY_HELPTEXT,
5101 : BASEPROPERTY_HELPURL,
5102 : BASEPROPERTY_PRINTABLE,
5103 : BASEPROPERTY_READONLY,
5104 : BASEPROPERTY_REPEAT,
5105 : BASEPROPERTY_REPEAT_DELAY,
5106 : BASEPROPERTY_SPIN,
5107 : BASEPROPERTY_STRICTFORMAT,
5108 : BASEPROPERTY_TABSTOP,
5109 : BASEPROPERTY_TIME,
5110 : BASEPROPERTY_TIMEMAX,
5111 : BASEPROPERTY_TIMEMIN,
5112 : BASEPROPERTY_ENFORCE_FORMAT,
5113 : BASEPROPERTY_TEXT,
5114 : BASEPROPERTY_HIDEINACTIVESELECTION,
5115 : BASEPROPERTY_VERTICALALIGN,
5116 : BASEPROPERTY_WRITING_MODE,
5117 : BASEPROPERTY_CONTEXT_WRITING_MODE,
5118 : BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
5119 16 : 0);
5120 16 : VCLXFormattedSpinField::ImplGetPropertyIds( rIds );
5121 16 : }
5122 :
5123 18 : VCLXTimeField::VCLXTimeField()
5124 : {
5125 18 : }
5126 :
5127 36 : VCLXTimeField::~VCLXTimeField()
5128 : {
5129 36 : }
5130 :
5131 : //change the window type here to match the role
5132 1 : ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXTimeField::CreateAccessibleContext()
5133 : {
5134 1 : VclPtr< vcl::Window > pWindow = GetWindow();
5135 1 : if ( pWindow )
5136 : {
5137 1 : pWindow->SetType( WINDOW_TIMEFIELD );
5138 : }
5139 1 : return getAccessibleFactory().createAccessibleContext( this );
5140 : }
5141 :
5142 : // ::com::sun::star::uno::XInterface
5143 5750 : ::com::sun::star::uno::Any VCLXTimeField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5144 : {
5145 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
5146 5750 : (static_cast< ::com::sun::star::awt::XTimeField* >(this)) );
5147 5750 : return (aRet.hasValue() ? aRet : VCLXFormattedSpinField::queryInterface( rType ));
5148 : }
5149 :
5150 : // ::com::sun::star::lang::XTypeProvider
5151 0 : IMPL_XTYPEPROVIDER_START( VCLXTimeField )
5152 0 : cppu::UnoType<com::sun::star::awt::XTimeField>::get(),
5153 : VCLXFormattedSpinField::getTypes()
5154 0 : IMPL_XTYPEPROVIDER_END
5155 :
5156 6 : void VCLXTimeField::setTime( const util::Time& aTime ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5157 : {
5158 6 : SolarMutexGuard aGuard;
5159 :
5160 12 : VclPtr< TimeField > pTimeField = GetAs< TimeField >();
5161 6 : if ( pTimeField )
5162 : {
5163 6 : pTimeField->SetTime( aTime );
5164 :
5165 : // #107218# Call same listeners like VCL would do after user interaction
5166 6 : SetSynthesizingVCLEvent( true );
5167 6 : pTimeField->SetModifyFlag();
5168 6 : pTimeField->Modify();
5169 6 : SetSynthesizingVCLEvent( false );
5170 6 : }
5171 6 : }
5172 :
5173 18 : util::Time VCLXTimeField::getTime() throw(::com::sun::star::uno::RuntimeException, std::exception)
5174 : {
5175 18 : SolarMutexGuard aGuard;
5176 :
5177 36 : VclPtr< TimeField > pTimeField = GetAs< TimeField >();
5178 18 : if ( pTimeField )
5179 18 : return pTimeField->GetTime().GetUNOTime();
5180 : else
5181 18 : return util::Time();
5182 : }
5183 :
5184 30 : void VCLXTimeField::setMin( const util::Time& aTime ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5185 : {
5186 30 : SolarMutexGuard aGuard;
5187 :
5188 60 : VclPtr< TimeField > pTimeField = GetAs< TimeField >();
5189 30 : if ( pTimeField )
5190 60 : pTimeField->SetMin( aTime );
5191 30 : }
5192 :
5193 0 : util::Time VCLXTimeField::getMin() throw(::com::sun::star::uno::RuntimeException, std::exception)
5194 : {
5195 0 : SolarMutexGuard aGuard;
5196 :
5197 0 : VclPtr< TimeField > pTimeField = GetAs< TimeField >();
5198 0 : if ( pTimeField )
5199 0 : return pTimeField->GetMin().GetUNOTime();
5200 : else
5201 0 : return util::Time();
5202 : }
5203 :
5204 30 : void VCLXTimeField::setMax( const util::Time& aTime ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5205 : {
5206 30 : SolarMutexGuard aGuard;
5207 :
5208 60 : VclPtr< TimeField > pTimeField = GetAs< TimeField >();
5209 30 : if ( pTimeField )
5210 60 : pTimeField->SetMax( aTime );
5211 30 : }
5212 :
5213 0 : util::Time VCLXTimeField::getMax() throw(::com::sun::star::uno::RuntimeException, std::exception)
5214 : {
5215 0 : SolarMutexGuard aGuard;
5216 :
5217 0 : VclPtr< TimeField > pTimeField = GetAs< TimeField >();
5218 0 : if ( pTimeField )
5219 0 : return pTimeField->GetMax().GetUNOTime();
5220 : else
5221 0 : return util::Time();
5222 : }
5223 :
5224 24 : void VCLXTimeField::setFirst( const util::Time& aTime ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5225 : {
5226 24 : SolarMutexGuard aGuard;
5227 :
5228 48 : VclPtr< TimeField > pTimeField = GetAs< TimeField >();
5229 24 : if ( pTimeField )
5230 48 : pTimeField->SetFirst( aTime );
5231 24 : }
5232 :
5233 0 : util::Time VCLXTimeField::getFirst() throw(::com::sun::star::uno::RuntimeException, std::exception)
5234 : {
5235 0 : SolarMutexGuard aGuard;
5236 :
5237 0 : VclPtr< TimeField > pTimeField = GetAs< TimeField >();
5238 0 : if ( pTimeField )
5239 0 : return pTimeField->GetFirst().GetUNOTime();
5240 : else
5241 0 : return util::Time();
5242 : }
5243 :
5244 20 : void VCLXTimeField::setLast( const util::Time& aTime ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5245 : {
5246 20 : SolarMutexGuard aGuard;
5247 :
5248 40 : VclPtr< TimeField > pTimeField = GetAs< TimeField >();
5249 20 : if ( pTimeField )
5250 40 : pTimeField->SetLast( aTime );
5251 20 : }
5252 :
5253 0 : util::Time VCLXTimeField::getLast() throw(::com::sun::star::uno::RuntimeException, std::exception)
5254 : {
5255 0 : SolarMutexGuard aGuard;
5256 :
5257 0 : VclPtr< TimeField > pTimeField = GetAs< TimeField >();
5258 0 : if ( pTimeField )
5259 0 : return pTimeField->GetLast().GetUNOTime();
5260 : else
5261 0 : return util::Time();
5262 : }
5263 :
5264 2 : void VCLXTimeField::setEmpty() throw(::com::sun::star::uno::RuntimeException, std::exception)
5265 : {
5266 2 : SolarMutexGuard aGuard;
5267 :
5268 4 : VclPtr< TimeField > pTimeField = GetAs< TimeField >();
5269 2 : if ( pTimeField )
5270 4 : pTimeField->SetEmptyTime();
5271 2 : }
5272 :
5273 22 : sal_Bool VCLXTimeField::isEmpty() throw(::com::sun::star::uno::RuntimeException, std::exception)
5274 : {
5275 22 : SolarMutexGuard aGuard;
5276 :
5277 44 : VclPtr< TimeField > pTimeField = GetAs< TimeField >();
5278 44 : return pTimeField ? pTimeField->IsEmptyTime() : sal_False;
5279 : }
5280 :
5281 0 : void VCLXTimeField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5282 : {
5283 0 : VCLXFormattedSpinField::setStrictFormat( bStrict );
5284 0 : }
5285 :
5286 0 : sal_Bool VCLXTimeField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException, std::exception)
5287 : {
5288 0 : return VCLXFormattedSpinField::isStrictFormat();
5289 : }
5290 :
5291 :
5292 1463 : void VCLXTimeField::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
5293 : {
5294 1463 : SolarMutexGuard aGuard;
5295 :
5296 1463 : if ( GetWindow() )
5297 : {
5298 1463 : bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
5299 :
5300 1463 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
5301 1463 : switch ( nPropType )
5302 : {
5303 : case BASEPROPERTY_TIME:
5304 : {
5305 21 : if ( bVoid )
5306 : {
5307 15 : GetAs< TimeField >()->EnableEmptyFieldValue( true );
5308 15 : GetAs< TimeField >()->SetEmptyFieldValue();
5309 : }
5310 : else
5311 : {
5312 6 : util::Time t;
5313 6 : if ( Value >>= t )
5314 6 : setTime( t );
5315 : }
5316 : }
5317 21 : break;
5318 : case BASEPROPERTY_TIMEMIN:
5319 : {
5320 30 : util::Time t;
5321 30 : if ( Value >>= t )
5322 30 : setMin( t );
5323 : }
5324 30 : break;
5325 : case BASEPROPERTY_TIMEMAX:
5326 : {
5327 30 : util::Time t;
5328 30 : if ( Value >>= t )
5329 30 : setMax( t );
5330 : }
5331 30 : break;
5332 : case BASEPROPERTY_EXTTIMEFORMAT:
5333 : {
5334 26 : sal_Int16 n = sal_Int16();
5335 26 : if ( Value >>= n )
5336 26 : GetAs< TimeField >()->SetExtFormat( (ExtTimeFieldFormat) n );
5337 : }
5338 26 : break;
5339 : case BASEPROPERTY_ENFORCE_FORMAT:
5340 : {
5341 27 : bool bEnforce( true );
5342 27 : OSL_VERIFY( Value >>= bEnforce );
5343 27 : GetAs< TimeField >()->EnforceValidValue( bEnforce );
5344 : }
5345 27 : break;
5346 : default:
5347 : {
5348 1329 : VCLXFormattedSpinField::setProperty( PropertyName, Value );
5349 : }
5350 : }
5351 1463 : }
5352 1463 : }
5353 :
5354 20 : ::com::sun::star::uno::Any VCLXTimeField::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5355 : {
5356 20 : SolarMutexGuard aGuard;
5357 :
5358 20 : ::com::sun::star::uno::Any aProp;
5359 20 : if ( GetWindow() )
5360 : {
5361 20 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
5362 20 : switch ( nPropType )
5363 : {
5364 : case BASEPROPERTY_TIME:
5365 : {
5366 0 : aProp <<= getTime();
5367 : }
5368 0 : break;
5369 : case BASEPROPERTY_TIMEMIN:
5370 : {
5371 0 : aProp <<= getMin();
5372 : }
5373 0 : break;
5374 : case BASEPROPERTY_TIMEMAX:
5375 : {
5376 0 : aProp <<= getMax();
5377 : }
5378 0 : break;
5379 : case BASEPROPERTY_ENFORCE_FORMAT:
5380 : {
5381 0 : aProp <<= GetAs< TimeField >()->IsEnforceValidValue( );
5382 : }
5383 0 : break;
5384 : default:
5385 : {
5386 20 : aProp <<= VCLXFormattedSpinField::getProperty( PropertyName );
5387 : }
5388 : }
5389 : }
5390 20 : return aProp;
5391 : }
5392 :
5393 :
5394 : // class VCLXNumericField
5395 :
5396 :
5397 16 : void VCLXNumericField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
5398 : {
5399 : PushPropertyIds( rIds,
5400 : BASEPROPERTY_ALIGN,
5401 : BASEPROPERTY_BACKGROUNDCOLOR,
5402 : BASEPROPERTY_BORDER,
5403 : BASEPROPERTY_BORDERCOLOR,
5404 : BASEPROPERTY_DECIMALACCURACY,
5405 : BASEPROPERTY_DEFAULTCONTROL,
5406 : BASEPROPERTY_ENABLED,
5407 : BASEPROPERTY_ENABLEVISIBLE,
5408 : BASEPROPERTY_FONTDESCRIPTOR,
5409 : BASEPROPERTY_HELPTEXT,
5410 : BASEPROPERTY_HELPURL,
5411 : BASEPROPERTY_NUMSHOWTHOUSANDSEP,
5412 : BASEPROPERTY_PRINTABLE,
5413 : BASEPROPERTY_READONLY,
5414 : BASEPROPERTY_REPEAT,
5415 : BASEPROPERTY_REPEAT_DELAY,
5416 : BASEPROPERTY_SPIN,
5417 : BASEPROPERTY_STRICTFORMAT,
5418 : BASEPROPERTY_TABSTOP,
5419 : BASEPROPERTY_VALUEMAX_DOUBLE,
5420 : BASEPROPERTY_VALUEMIN_DOUBLE,
5421 : BASEPROPERTY_VALUESTEP_DOUBLE,
5422 : BASEPROPERTY_VALUE_DOUBLE,
5423 : BASEPROPERTY_ENFORCE_FORMAT,
5424 : BASEPROPERTY_HIDEINACTIVESELECTION,
5425 : BASEPROPERTY_VERTICALALIGN,
5426 : BASEPROPERTY_WRITING_MODE,
5427 : BASEPROPERTY_CONTEXT_WRITING_MODE,
5428 : BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
5429 16 : 0);
5430 16 : VCLXFormattedSpinField::ImplGetPropertyIds( rIds );
5431 16 : }
5432 :
5433 3 : VCLXNumericField::VCLXNumericField()
5434 : {
5435 3 : }
5436 :
5437 0 : VCLXNumericField::~VCLXNumericField()
5438 : {
5439 0 : }
5440 :
5441 : // ::com::sun::star::uno::XInterface
5442 36 : ::com::sun::star::uno::Any VCLXNumericField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5443 : {
5444 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
5445 36 : (static_cast< ::com::sun::star::awt::XNumericField* >(this)) );
5446 36 : return (aRet.hasValue() ? aRet : VCLXFormattedSpinField::queryInterface( rType ));
5447 : }
5448 :
5449 : // ::com::sun::star::lang::XTypeProvider
5450 0 : IMPL_XTYPEPROVIDER_START( VCLXNumericField )
5451 0 : cppu::UnoType<com::sun::star::awt::XNumericField>::get(),
5452 : VCLXFormattedSpinField::getTypes()
5453 0 : IMPL_XTYPEPROVIDER_END
5454 :
5455 0 : void VCLXNumericField::setValue( double Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5456 : {
5457 0 : SolarMutexGuard aGuard;
5458 :
5459 0 : NumericFormatter* pNumericFormatter = static_cast<NumericFormatter*>(GetFormatter());
5460 0 : if ( pNumericFormatter )
5461 : {
5462 : // shift long value using decimal digits
5463 : // (e.g., input 105 using 2 digits returns 1,05)
5464 : // Thus, to set a value of 1,05, insert 105 and 2 digits
5465 : pNumericFormatter->SetValue(
5466 0 : (long)ImplCalcLongValue( Value, pNumericFormatter->GetDecimalDigits() ) );
5467 :
5468 : // #107218# Call same listeners like VCL would do after user interaction
5469 0 : VclPtr< Edit > pEdit = GetAs< Edit >();
5470 0 : if ( pEdit )
5471 : {
5472 0 : SetSynthesizingVCLEvent( true );
5473 0 : pEdit->SetModifyFlag();
5474 0 : pEdit->Modify();
5475 0 : SetSynthesizingVCLEvent( false );
5476 0 : }
5477 0 : }
5478 0 : }
5479 :
5480 0 : double VCLXNumericField::getValue() throw(::com::sun::star::uno::RuntimeException, std::exception)
5481 : {
5482 0 : SolarMutexGuard aGuard;
5483 :
5484 0 : NumericFormatter* pNumericFormatter = static_cast<NumericFormatter*>(GetFormatter());
5485 : return pNumericFormatter
5486 0 : ? ImplCalcDoubleValue( (double)pNumericFormatter->GetValue(), pNumericFormatter->GetDecimalDigits() )
5487 0 : : 0;
5488 : }
5489 :
5490 0 : void VCLXNumericField::setMin( double Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5491 : {
5492 0 : SolarMutexGuard aGuard;
5493 :
5494 0 : NumericFormatter* pNumericFormatter = static_cast<NumericFormatter*>(GetFormatter());
5495 0 : if ( pNumericFormatter )
5496 : pNumericFormatter->SetMin(
5497 0 : (long)ImplCalcLongValue( Value, pNumericFormatter->GetDecimalDigits() ) );
5498 0 : }
5499 :
5500 0 : double VCLXNumericField::getMin() throw(::com::sun::star::uno::RuntimeException, std::exception)
5501 : {
5502 0 : SolarMutexGuard aGuard;
5503 :
5504 0 : NumericFormatter* pNumericFormatter = static_cast<NumericFormatter*>(GetFormatter());
5505 : return pNumericFormatter
5506 0 : ? ImplCalcDoubleValue( (double)pNumericFormatter->GetMin(), pNumericFormatter->GetDecimalDigits() )
5507 0 : : 0;
5508 : }
5509 :
5510 0 : void VCLXNumericField::setMax( double Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5511 : {
5512 0 : SolarMutexGuard aGuard;
5513 :
5514 0 : NumericFormatter* pNumericFormatter = static_cast<NumericFormatter*>(GetFormatter());
5515 0 : if ( pNumericFormatter )
5516 : pNumericFormatter->SetMax(
5517 0 : (long)ImplCalcLongValue( Value, pNumericFormatter->GetDecimalDigits() ) );
5518 0 : }
5519 :
5520 0 : double VCLXNumericField::getMax() throw(::com::sun::star::uno::RuntimeException, std::exception)
5521 : {
5522 0 : SolarMutexGuard aGuard;
5523 :
5524 0 : NumericFormatter* pNumericFormatter = static_cast<NumericFormatter*>(GetFormatter());
5525 : return pNumericFormatter
5526 0 : ? ImplCalcDoubleValue( (double)pNumericFormatter->GetMax(), pNumericFormatter->GetDecimalDigits() )
5527 0 : : 0;
5528 : }
5529 :
5530 0 : void VCLXNumericField::setFirst( double Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5531 : {
5532 0 : SolarMutexGuard aGuard;
5533 :
5534 0 : VclPtr< NumericField > pNumericField = GetAs< NumericField >();
5535 0 : if ( pNumericField )
5536 0 : pNumericField->SetFirst(
5537 0 : (long)ImplCalcLongValue( Value, pNumericField->GetDecimalDigits() ) );
5538 0 : }
5539 :
5540 0 : double VCLXNumericField::getFirst() throw(::com::sun::star::uno::RuntimeException, std::exception)
5541 : {
5542 0 : SolarMutexGuard aGuard;
5543 :
5544 0 : VclPtr< NumericField > pNumericField = GetAs< NumericField >();
5545 : return pNumericField
5546 0 : ? ImplCalcDoubleValue( (double)pNumericField->GetFirst(), pNumericField->GetDecimalDigits() )
5547 0 : : 0;
5548 : }
5549 :
5550 0 : void VCLXNumericField::setLast( double Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5551 : {
5552 0 : SolarMutexGuard aGuard;
5553 :
5554 0 : VclPtr< NumericField > pNumericField = GetAs< NumericField >();
5555 0 : if ( pNumericField )
5556 0 : pNumericField->SetLast(
5557 0 : (long)ImplCalcLongValue( Value, pNumericField->GetDecimalDigits() ) );
5558 0 : }
5559 :
5560 0 : double VCLXNumericField::getLast() throw(::com::sun::star::uno::RuntimeException, std::exception)
5561 : {
5562 0 : SolarMutexGuard aGuard;
5563 :
5564 0 : VclPtr< NumericField > pNumericField = GetAs< NumericField >();
5565 : return pNumericField
5566 0 : ? ImplCalcDoubleValue( (double)pNumericField->GetLast(), pNumericField->GetDecimalDigits() )
5567 0 : : 0;
5568 : }
5569 :
5570 0 : void VCLXNumericField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5571 : {
5572 0 : VCLXFormattedSpinField::setStrictFormat( bStrict );
5573 0 : }
5574 :
5575 0 : sal_Bool VCLXNumericField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException, std::exception)
5576 : {
5577 0 : return VCLXFormattedSpinField::isStrictFormat();
5578 : }
5579 :
5580 :
5581 0 : void VCLXNumericField::setSpinSize( double Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5582 : {
5583 0 : SolarMutexGuard aGuard;
5584 :
5585 0 : VclPtr< NumericField > pNumericField = GetAs< NumericField >();
5586 0 : if ( pNumericField )
5587 0 : pNumericField->SetSpinSize(
5588 0 : (long)ImplCalcLongValue( Value, pNumericField->GetDecimalDigits() ) );
5589 0 : }
5590 :
5591 0 : double VCLXNumericField::getSpinSize() throw(::com::sun::star::uno::RuntimeException, std::exception)
5592 : {
5593 0 : SolarMutexGuard aGuard;
5594 :
5595 0 : VclPtr< NumericField > pNumericField = GetAs< NumericField >();
5596 : return pNumericField
5597 0 : ? ImplCalcDoubleValue( (double)pNumericField->GetSpinSize(), pNumericField->GetDecimalDigits() )
5598 0 : : 0;
5599 : }
5600 :
5601 0 : void VCLXNumericField::setDecimalDigits( sal_Int16 Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5602 : {
5603 0 : SolarMutexGuard aGuard;
5604 :
5605 0 : NumericFormatter* pNumericFormatter = static_cast<NumericFormatter*>(GetFormatter());
5606 0 : if ( pNumericFormatter )
5607 : {
5608 0 : double n = getValue();
5609 0 : pNumericFormatter->SetDecimalDigits( Value );
5610 0 : setValue( n );
5611 0 : }
5612 0 : }
5613 :
5614 0 : sal_Int16 VCLXNumericField::getDecimalDigits() throw(::com::sun::star::uno::RuntimeException, std::exception)
5615 : {
5616 0 : SolarMutexGuard aGuard;
5617 :
5618 0 : NumericFormatter* pNumericFormatter = static_cast<NumericFormatter*>(GetFormatter());
5619 0 : return pNumericFormatter ? pNumericFormatter->GetDecimalDigits() : 0;
5620 : }
5621 :
5622 0 : void VCLXNumericField::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
5623 : {
5624 0 : SolarMutexGuard aGuard;
5625 :
5626 0 : if ( GetWindow() )
5627 : {
5628 0 : bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
5629 :
5630 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
5631 0 : switch ( nPropType )
5632 : {
5633 : case BASEPROPERTY_VALUE_DOUBLE:
5634 : {
5635 0 : if ( bVoid )
5636 : {
5637 0 : GetAs< NumericField >()->EnableEmptyFieldValue( true );
5638 0 : GetAs< NumericField >()->SetEmptyFieldValue();
5639 : }
5640 : else
5641 : {
5642 0 : double d = 0;
5643 0 : if ( Value >>= d )
5644 0 : setValue( d );
5645 : }
5646 : }
5647 0 : break;
5648 : case BASEPROPERTY_VALUEMIN_DOUBLE:
5649 : {
5650 0 : double d = 0;
5651 0 : if ( Value >>= d )
5652 0 : setMin( d );
5653 : }
5654 0 : break;
5655 : case BASEPROPERTY_VALUEMAX_DOUBLE:
5656 : {
5657 0 : double d = 0;
5658 0 : if ( Value >>= d )
5659 0 : setMax( d );
5660 : }
5661 0 : break;
5662 : case BASEPROPERTY_VALUESTEP_DOUBLE:
5663 : {
5664 0 : double d = 0;
5665 0 : if ( Value >>= d )
5666 0 : setSpinSize( d );
5667 : }
5668 0 : break;
5669 : case BASEPROPERTY_DECIMALACCURACY:
5670 : {
5671 0 : sal_Int16 n = sal_Int16();
5672 0 : if ( Value >>= n )
5673 0 : setDecimalDigits( n );
5674 : }
5675 0 : break;
5676 : case BASEPROPERTY_NUMSHOWTHOUSANDSEP:
5677 : {
5678 0 : bool b = bool();
5679 0 : if ( Value >>= b )
5680 0 : GetAs< NumericField >()->SetUseThousandSep( b );
5681 : }
5682 0 : break;
5683 : default:
5684 : {
5685 0 : VCLXFormattedSpinField::setProperty( PropertyName, Value );
5686 : }
5687 : }
5688 0 : }
5689 0 : }
5690 :
5691 0 : ::com::sun::star::uno::Any VCLXNumericField::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5692 : {
5693 0 : SolarMutexGuard aGuard;
5694 :
5695 0 : ::com::sun::star::uno::Any aProp;
5696 0 : FormatterBase* pFormatter = GetFormatter();
5697 0 : if ( pFormatter )
5698 : {
5699 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
5700 0 : switch ( nPropType )
5701 : {
5702 : case BASEPROPERTY_VALUE_DOUBLE:
5703 : {
5704 0 : aProp <<= (double) getValue();
5705 : }
5706 0 : break;
5707 : case BASEPROPERTY_VALUEMIN_DOUBLE:
5708 : {
5709 0 : aProp <<= (double) getMin();
5710 : }
5711 0 : break;
5712 : case BASEPROPERTY_VALUEMAX_DOUBLE:
5713 : {
5714 0 : aProp <<= (double) getMax();
5715 : }
5716 0 : break;
5717 : case BASEPROPERTY_VALUESTEP_DOUBLE:
5718 : {
5719 0 : aProp <<= (double) getSpinSize();
5720 : }
5721 0 : break;
5722 : case BASEPROPERTY_NUMSHOWTHOUSANDSEP:
5723 : {
5724 0 : aProp <<= GetAs< NumericField >()->IsUseThousandSep();
5725 : }
5726 0 : break;
5727 : default:
5728 : {
5729 0 : aProp <<= VCLXFormattedSpinField::getProperty( PropertyName );
5730 : }
5731 : }
5732 : }
5733 0 : return aProp;
5734 : }
5735 :
5736 :
5737 : // ----------------------------------------------------
5738 : // class VCLXMetricField
5739 : // ----------------------------------------------------
5740 :
5741 0 : void VCLXMetricField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
5742 : {
5743 : PushPropertyIds( rIds,
5744 : BASEPROPERTY_ALIGN,
5745 : BASEPROPERTY_BACKGROUNDCOLOR,
5746 : BASEPROPERTY_BORDER,
5747 : BASEPROPERTY_BORDERCOLOR,
5748 : BASEPROPERTY_DECIMALACCURACY,
5749 : BASEPROPERTY_DEFAULTCONTROL,
5750 : BASEPROPERTY_ENABLED,
5751 : BASEPROPERTY_ENABLEVISIBLE,
5752 : BASEPROPERTY_FONTDESCRIPTOR,
5753 : BASEPROPERTY_HELPTEXT,
5754 : BASEPROPERTY_HELPURL,
5755 : BASEPROPERTY_NUMSHOWTHOUSANDSEP,
5756 : BASEPROPERTY_PRINTABLE,
5757 : BASEPROPERTY_READONLY,
5758 : BASEPROPERTY_REPEAT,
5759 : BASEPROPERTY_REPEAT_DELAY,
5760 : BASEPROPERTY_SPIN,
5761 : BASEPROPERTY_STRICTFORMAT,
5762 : BASEPROPERTY_TABSTOP,
5763 : BASEPROPERTY_ENFORCE_FORMAT,
5764 : BASEPROPERTY_HIDEINACTIVESELECTION,
5765 : BASEPROPERTY_UNIT,
5766 : BASEPROPERTY_CUSTOMUNITTEXT,
5767 : BASEPROPERTY_WRITING_MODE,
5768 : BASEPROPERTY_CONTEXT_WRITING_MODE,
5769 : BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
5770 0 : 0);
5771 0 : VCLXFormattedSpinField::ImplGetPropertyIds( rIds );
5772 0 : }
5773 :
5774 0 : VCLXMetricField::VCLXMetricField()
5775 : {
5776 0 : }
5777 :
5778 0 : VCLXMetricField::~VCLXMetricField()
5779 : {
5780 0 : }
5781 :
5782 0 : MetricFormatter *VCLXMetricField::GetMetricFormatter() throw(::com::sun::star::uno::RuntimeException)
5783 : {
5784 0 : MetricFormatter *pFormatter = static_cast<MetricFormatter *>(GetFormatter());
5785 0 : if (!pFormatter)
5786 0 : throw ::com::sun::star::uno::RuntimeException();
5787 0 : return pFormatter;
5788 : }
5789 :
5790 0 : MetricField *VCLXMetricField::GetMetricField() throw(::com::sun::star::uno::RuntimeException)
5791 : {
5792 0 : VclPtr< MetricField > pField = GetAs< MetricField >();
5793 0 : if (!pField)
5794 0 : throw ::com::sun::star::uno::RuntimeException();
5795 0 : return pField;
5796 : }
5797 :
5798 : // ::com::sun::star::uno::XInterface
5799 0 : ::com::sun::star::uno::Any VCLXMetricField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5800 : {
5801 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
5802 0 : (static_cast< ::com::sun::star::awt::XMetricField* >(this)) );
5803 0 : return (aRet.hasValue() ? aRet : VCLXFormattedSpinField::queryInterface( rType ));
5804 : }
5805 :
5806 : // ::com::sun::star::lang::XTypeProvider
5807 0 : IMPL_XTYPEPROVIDER_START( VCLXMetricField )
5808 0 : cppu::UnoType<com::sun::star::awt::XMetricField>::get(),
5809 : VCLXFormattedSpinField::getTypes()
5810 0 : IMPL_XTYPEPROVIDER_END
5811 :
5812 : // FIXME: later ...
5813 : #define MetricUnitUnoToVcl(a) ((FieldUnit)(a))
5814 :
5815 : #define METRIC_MAP_PAIR(method,parent) \
5816 : sal_Int64 VCLXMetricField::get##method( sal_Int16 nUnit ) throw (::com::sun::star::uno::RuntimeException, std::exception) \
5817 : { \
5818 : SolarMutexGuard aGuard; \
5819 : return GetMetric##parent()->Get##method( MetricUnitUnoToVcl( nUnit ) ); \
5820 : } \
5821 : void VCLXMetricField::set##method( sal_Int64 nValue, sal_Int16 nUnit ) throw (::com::sun::star::uno::RuntimeException, std::exception) \
5822 : { \
5823 : SolarMutexGuard aGuard; \
5824 : GetMetric##parent()->Set##method( nValue, MetricUnitUnoToVcl( nUnit ) ); \
5825 : }
5826 :
5827 0 : METRIC_MAP_PAIR(Min, Formatter)
5828 0 : METRIC_MAP_PAIR(Max, Formatter)
5829 0 : METRIC_MAP_PAIR(First, Field)
5830 0 : METRIC_MAP_PAIR(Last, Field)
5831 :
5832 : #undef METRIC_MAP_PAIR
5833 :
5834 0 : ::sal_Int64 VCLXMetricField::getValue( ::sal_Int16 nUnit ) throw (::com::sun::star::uno::RuntimeException, std::exception)
5835 : {
5836 0 : SolarMutexGuard aGuard;
5837 0 : return GetMetricFormatter()->GetValue( MetricUnitUnoToVcl( nUnit ) );
5838 : }
5839 :
5840 0 : ::sal_Int64 VCLXMetricField::getCorrectedValue( ::sal_Int16 nUnit ) throw (::com::sun::star::uno::RuntimeException, std::exception)
5841 : {
5842 0 : SolarMutexGuard aGuard;
5843 0 : return GetMetricFormatter()->GetCorrectedValue( MetricUnitUnoToVcl( nUnit ) );
5844 : }
5845 :
5846 : // FIXME: acute cut/paste evilness - move this to the parent Edit class ?
5847 0 : void VCLXMetricField::CallListeners()
5848 : {
5849 : // #107218# Call same listeners like VCL would do after user interaction
5850 0 : VclPtr< Edit > pEdit = GetAs< Edit >();
5851 0 : if ( pEdit )
5852 : {
5853 0 : SetSynthesizingVCLEvent( true );
5854 0 : pEdit->SetModifyFlag();
5855 0 : pEdit->Modify();
5856 0 : SetSynthesizingVCLEvent( false );
5857 0 : }
5858 0 : }
5859 :
5860 0 : void VCLXMetricField::setValue( ::sal_Int64 Value, ::sal_Int16 Unit ) throw (::com::sun::star::uno::RuntimeException, std::exception)
5861 : {
5862 0 : SolarMutexGuard aGuard;
5863 0 : GetMetricFormatter()->SetValue( Value, MetricUnitUnoToVcl( Unit ) );
5864 0 : CallListeners();
5865 0 : }
5866 :
5867 0 : void VCLXMetricField::setUserValue( ::sal_Int64 Value, ::sal_Int16 Unit ) throw (::com::sun::star::uno::RuntimeException, std::exception)
5868 : {
5869 0 : SolarMutexGuard aGuard;
5870 0 : GetMetricFormatter()->SetUserValue( Value, MetricUnitUnoToVcl( Unit ) );
5871 0 : CallListeners();
5872 0 : }
5873 :
5874 0 : void VCLXMetricField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5875 : {
5876 0 : VCLXFormattedSpinField::setStrictFormat( bStrict );
5877 0 : }
5878 :
5879 0 : sal_Bool VCLXMetricField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException, std::exception)
5880 : {
5881 0 : return VCLXFormattedSpinField::isStrictFormat();
5882 : }
5883 :
5884 0 : void VCLXMetricField::setSpinSize( sal_Int64 Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5885 : {
5886 0 : SolarMutexGuard aGuard;
5887 0 : GetMetricField()->SetSpinSize( Value );
5888 0 : }
5889 :
5890 0 : sal_Int64 VCLXMetricField::getSpinSize() throw(::com::sun::star::uno::RuntimeException, std::exception)
5891 : {
5892 0 : SolarMutexGuard aGuard;
5893 0 : return GetMetricField()->GetSpinSize();
5894 : }
5895 :
5896 0 : void VCLXMetricField::setDecimalDigits( sal_Int16 Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5897 : {
5898 0 : SolarMutexGuard aGuard;
5899 0 : GetMetricFormatter()->SetDecimalDigits( Value );
5900 0 : }
5901 :
5902 0 : sal_Int16 VCLXMetricField::getDecimalDigits() throw(::com::sun::star::uno::RuntimeException, std::exception)
5903 : {
5904 0 : SolarMutexGuard aGuard;
5905 :
5906 0 : NumericFormatter* pNumericFormatter = static_cast<NumericFormatter*>(GetFormatter());
5907 0 : return pNumericFormatter ? pNumericFormatter->GetDecimalDigits() : 0;
5908 : }
5909 :
5910 0 : void VCLXMetricField::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
5911 : {
5912 0 : SolarMutexGuard aGuard;
5913 :
5914 0 : if ( GetWindow() )
5915 : {
5916 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
5917 0 : switch ( nPropType )
5918 : {
5919 : case BASEPROPERTY_DECIMALACCURACY:
5920 : {
5921 0 : sal_Int16 n = 0;
5922 0 : if ( Value >>= n )
5923 0 : setDecimalDigits( n );
5924 0 : break;
5925 : }
5926 : case BASEPROPERTY_NUMSHOWTHOUSANDSEP:
5927 : {
5928 0 : bool b = false;
5929 0 : if ( Value >>= b )
5930 0 : GetAs< NumericField >()->SetUseThousandSep( b );
5931 : }
5932 0 : break;
5933 : case BASEPROPERTY_UNIT:
5934 : {
5935 0 : sal_uInt16 nVal = 0;
5936 0 : if ( Value >>= nVal )
5937 0 : GetAs< MetricField >()->SetUnit( (FieldUnit) nVal );
5938 0 : break;
5939 : }
5940 : case BASEPROPERTY_CUSTOMUNITTEXT:
5941 : {
5942 0 : OUString aStr;
5943 0 : if ( Value >>= aStr )
5944 0 : GetAs< MetricField >()->SetCustomUnitText( aStr );
5945 0 : break;
5946 : }
5947 : default:
5948 : {
5949 0 : VCLXFormattedSpinField::setProperty( PropertyName, Value );
5950 0 : break;
5951 : }
5952 : }
5953 0 : }
5954 0 : }
5955 :
5956 0 : ::com::sun::star::uno::Any VCLXMetricField::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
5957 : {
5958 0 : SolarMutexGuard aGuard;
5959 :
5960 0 : ::com::sun::star::uno::Any aProp;
5961 0 : FormatterBase* pFormatter = GetFormatter();
5962 0 : if ( pFormatter )
5963 : {
5964 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
5965 0 : switch ( nPropType )
5966 : {
5967 : case BASEPROPERTY_NUMSHOWTHOUSANDSEP:
5968 0 : aProp <<= GetAs< NumericField >()->IsUseThousandSep();
5969 0 : break;
5970 : case BASEPROPERTY_UNIT:
5971 0 : aProp <<= (sal_uInt16) (GetAs< MetricField >()->GetUnit());
5972 0 : break;
5973 : case BASEPROPERTY_CUSTOMUNITTEXT:
5974 0 : aProp <<= OUString( GetAs< MetricField >()->GetCustomUnitText() );
5975 0 : break;
5976 : default:
5977 : {
5978 0 : aProp <<= VCLXFormattedSpinField::getProperty( PropertyName );
5979 0 : break;
5980 : }
5981 : }
5982 : }
5983 0 : return aProp;
5984 : }
5985 :
5986 :
5987 :
5988 : // class VCLXCurrencyField
5989 :
5990 :
5991 15 : void VCLXCurrencyField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
5992 : {
5993 : PushPropertyIds( rIds,
5994 : BASEPROPERTY_ALIGN,
5995 : BASEPROPERTY_BACKGROUNDCOLOR,
5996 : BASEPROPERTY_BORDER,
5997 : BASEPROPERTY_BORDERCOLOR,
5998 : BASEPROPERTY_CURRENCYSYMBOL,
5999 : BASEPROPERTY_CURSYM_POSITION,
6000 : BASEPROPERTY_DECIMALACCURACY,
6001 : BASEPROPERTY_DEFAULTCONTROL,
6002 : BASEPROPERTY_ENABLED,
6003 : BASEPROPERTY_ENABLEVISIBLE,
6004 : BASEPROPERTY_FONTDESCRIPTOR,
6005 : BASEPROPERTY_HELPTEXT,
6006 : BASEPROPERTY_HELPURL,
6007 : BASEPROPERTY_NUMSHOWTHOUSANDSEP,
6008 : BASEPROPERTY_PRINTABLE,
6009 : BASEPROPERTY_READONLY,
6010 : BASEPROPERTY_REPEAT,
6011 : BASEPROPERTY_REPEAT_DELAY,
6012 : BASEPROPERTY_SPIN,
6013 : BASEPROPERTY_STRICTFORMAT,
6014 : BASEPROPERTY_TABSTOP,
6015 : BASEPROPERTY_VALUEMAX_DOUBLE,
6016 : BASEPROPERTY_VALUEMIN_DOUBLE,
6017 : BASEPROPERTY_VALUESTEP_DOUBLE,
6018 : BASEPROPERTY_VALUE_DOUBLE,
6019 : BASEPROPERTY_ENFORCE_FORMAT,
6020 : BASEPROPERTY_HIDEINACTIVESELECTION,
6021 : BASEPROPERTY_VERTICALALIGN,
6022 : BASEPROPERTY_WRITING_MODE,
6023 : BASEPROPERTY_CONTEXT_WRITING_MODE,
6024 : BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
6025 15 : 0);
6026 15 : VCLXFormattedSpinField::ImplGetPropertyIds( rIds );
6027 15 : }
6028 :
6029 0 : VCLXCurrencyField::VCLXCurrencyField()
6030 : {
6031 0 : }
6032 :
6033 0 : VCLXCurrencyField::~VCLXCurrencyField()
6034 : {
6035 0 : }
6036 :
6037 : // ::com::sun::star::uno::XInterface
6038 0 : ::com::sun::star::uno::Any VCLXCurrencyField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6039 : {
6040 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
6041 0 : (static_cast< ::com::sun::star::awt::XCurrencyField* >(this)) );
6042 0 : return (aRet.hasValue() ? aRet : VCLXFormattedSpinField::queryInterface( rType ));
6043 : }
6044 :
6045 : // ::com::sun::star::lang::XTypeProvider
6046 0 : IMPL_XTYPEPROVIDER_START( VCLXCurrencyField )
6047 0 : cppu::UnoType<com::sun::star::awt::XCurrencyField>::get(),
6048 : VCLXFormattedSpinField::getTypes()
6049 0 : IMPL_XTYPEPROVIDER_END
6050 :
6051 0 : void VCLXCurrencyField::setValue( double Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6052 : {
6053 0 : SolarMutexGuard aGuard;
6054 :
6055 0 : LongCurrencyFormatter* pCurrencyFormatter = static_cast<LongCurrencyFormatter*>(GetFormatter());
6056 0 : if ( pCurrencyFormatter )
6057 : {
6058 : // shift long value using decimal digits
6059 : // (e.g., input 105 using 2 digits returns 1,05)
6060 : // Thus, to set a value of 1,05, insert 105 and 2 digits
6061 : pCurrencyFormatter->SetValue(
6062 0 : ImplCalcLongValue( Value, pCurrencyFormatter->GetDecimalDigits() ) );
6063 :
6064 : // #107218# Call same listeners like VCL would do after user interaction
6065 0 : VclPtr< Edit > pEdit = GetAs< Edit >();
6066 0 : if ( pEdit )
6067 : {
6068 0 : SetSynthesizingVCLEvent( true );
6069 0 : pEdit->SetModifyFlag();
6070 0 : pEdit->Modify();
6071 0 : SetSynthesizingVCLEvent( false );
6072 0 : }
6073 0 : }
6074 0 : }
6075 :
6076 0 : double VCLXCurrencyField::getValue() throw(::com::sun::star::uno::RuntimeException, std::exception)
6077 : {
6078 0 : SolarMutexGuard aGuard;
6079 :
6080 0 : LongCurrencyFormatter* pCurrencyFormatter = static_cast<LongCurrencyFormatter*>(GetFormatter());
6081 : return pCurrencyFormatter
6082 0 : ? ImplCalcDoubleValue( (double)pCurrencyFormatter->GetValue(), pCurrencyFormatter->GetDecimalDigits() )
6083 0 : : 0;
6084 : }
6085 :
6086 0 : void VCLXCurrencyField::setMin( double Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6087 : {
6088 0 : SolarMutexGuard aGuard;
6089 :
6090 0 : LongCurrencyFormatter* pCurrencyFormatter = static_cast<LongCurrencyFormatter*>(GetFormatter());
6091 0 : if ( pCurrencyFormatter )
6092 : pCurrencyFormatter->SetMin(
6093 0 : ImplCalcLongValue( Value, pCurrencyFormatter->GetDecimalDigits() ) );
6094 0 : }
6095 :
6096 0 : double VCLXCurrencyField::getMin() throw(::com::sun::star::uno::RuntimeException, std::exception)
6097 : {
6098 0 : SolarMutexGuard aGuard;
6099 :
6100 0 : LongCurrencyFormatter* pCurrencyFormatter = static_cast<LongCurrencyFormatter*>(GetFormatter());
6101 : return pCurrencyFormatter
6102 0 : ? ImplCalcDoubleValue( (double)pCurrencyFormatter->GetMin(), pCurrencyFormatter->GetDecimalDigits() )
6103 0 : : 0;
6104 : }
6105 :
6106 0 : void VCLXCurrencyField::setMax( double Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6107 : {
6108 0 : SolarMutexGuard aGuard;
6109 :
6110 0 : LongCurrencyFormatter* pCurrencyFormatter = static_cast<LongCurrencyFormatter*>(GetFormatter());
6111 0 : if ( pCurrencyFormatter )
6112 : pCurrencyFormatter->SetMax(
6113 0 : ImplCalcLongValue( Value, pCurrencyFormatter->GetDecimalDigits() ) );
6114 0 : }
6115 :
6116 0 : double VCLXCurrencyField::getMax() throw(::com::sun::star::uno::RuntimeException, std::exception)
6117 : {
6118 0 : SolarMutexGuard aGuard;
6119 :
6120 0 : LongCurrencyFormatter* pCurrencyFormatter = static_cast<LongCurrencyFormatter*>(GetFormatter());
6121 : return pCurrencyFormatter
6122 0 : ? ImplCalcDoubleValue( (double)pCurrencyFormatter->GetMax(), pCurrencyFormatter->GetDecimalDigits() )
6123 0 : : 0;
6124 : }
6125 :
6126 0 : void VCLXCurrencyField::setFirst( double Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6127 : {
6128 0 : SolarMutexGuard aGuard;
6129 :
6130 0 : VclPtr< LongCurrencyField > pCurrencyField = GetAs< LongCurrencyField >();
6131 0 : if ( pCurrencyField )
6132 : pCurrencyField->SetFirst(
6133 0 : ImplCalcLongValue( Value, pCurrencyField->GetDecimalDigits() ) );
6134 0 : }
6135 :
6136 0 : double VCLXCurrencyField::getFirst() throw(::com::sun::star::uno::RuntimeException, std::exception)
6137 : {
6138 0 : SolarMutexGuard aGuard;
6139 :
6140 0 : VclPtr< LongCurrencyField > pCurrencyField = GetAs< LongCurrencyField >();
6141 : return pCurrencyField
6142 0 : ? ImplCalcDoubleValue( (double)pCurrencyField->GetFirst(), pCurrencyField->GetDecimalDigits() )
6143 0 : : 0;
6144 : }
6145 :
6146 0 : void VCLXCurrencyField::setLast( double Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6147 : {
6148 0 : SolarMutexGuard aGuard;
6149 :
6150 0 : VclPtr< LongCurrencyField > pCurrencyField = GetAs< LongCurrencyField >();
6151 0 : if ( pCurrencyField )
6152 : pCurrencyField->SetLast(
6153 0 : ImplCalcLongValue( Value, pCurrencyField->GetDecimalDigits() ) );
6154 0 : }
6155 :
6156 0 : double VCLXCurrencyField::getLast() throw(::com::sun::star::uno::RuntimeException, std::exception)
6157 : {
6158 0 : SolarMutexGuard aGuard;
6159 :
6160 0 : VclPtr< LongCurrencyField > pCurrencyField = GetAs< LongCurrencyField >();
6161 : return pCurrencyField
6162 0 : ? ImplCalcDoubleValue( (double)pCurrencyField->GetLast(), pCurrencyField->GetDecimalDigits() )
6163 0 : : 0;
6164 : }
6165 :
6166 0 : void VCLXCurrencyField::setSpinSize( double Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6167 : {
6168 0 : SolarMutexGuard aGuard;
6169 :
6170 0 : VclPtr< LongCurrencyField > pCurrencyField = GetAs< LongCurrencyField >();
6171 0 : if ( pCurrencyField )
6172 : pCurrencyField->SetSpinSize(
6173 0 : ImplCalcLongValue( Value, pCurrencyField->GetDecimalDigits() ) );
6174 0 : }
6175 :
6176 0 : double VCLXCurrencyField::getSpinSize() throw(::com::sun::star::uno::RuntimeException, std::exception)
6177 : {
6178 0 : SolarMutexGuard aGuard;
6179 :
6180 0 : VclPtr< LongCurrencyField > pCurrencyField = GetAs< LongCurrencyField >();
6181 : return pCurrencyField
6182 0 : ? ImplCalcDoubleValue( (double)pCurrencyField->GetSpinSize(), pCurrencyField->GetDecimalDigits() )
6183 0 : : 0;
6184 : }
6185 :
6186 0 : void VCLXCurrencyField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6187 : {
6188 0 : VCLXFormattedSpinField::setStrictFormat( bStrict );
6189 0 : }
6190 :
6191 0 : sal_Bool VCLXCurrencyField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException, std::exception)
6192 : {
6193 0 : return VCLXFormattedSpinField::isStrictFormat();
6194 : }
6195 :
6196 :
6197 0 : void VCLXCurrencyField::setDecimalDigits( sal_Int16 Value ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6198 : {
6199 0 : SolarMutexGuard aGuard;
6200 :
6201 0 : LongCurrencyFormatter* pCurrencyFormatter = static_cast<LongCurrencyFormatter*>(GetFormatter());
6202 0 : if ( pCurrencyFormatter )
6203 : {
6204 0 : double n = getValue();
6205 0 : pCurrencyFormatter->SetDecimalDigits( Value );
6206 0 : setValue( n );
6207 0 : }
6208 0 : }
6209 :
6210 0 : sal_Int16 VCLXCurrencyField::getDecimalDigits() throw(::com::sun::star::uno::RuntimeException, std::exception)
6211 : {
6212 0 : SolarMutexGuard aGuard;
6213 :
6214 0 : LongCurrencyFormatter* pCurrencyFormatter = static_cast<LongCurrencyFormatter*>(GetFormatter());
6215 0 : return pCurrencyFormatter ? pCurrencyFormatter->GetDecimalDigits() : 0;
6216 : }
6217 :
6218 0 : void VCLXCurrencyField::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
6219 : {
6220 0 : SolarMutexGuard aGuard;
6221 :
6222 0 : if ( GetWindow() )
6223 : {
6224 0 : bool bVoid = Value.getValueType().getTypeClass() == ::com::sun::star::uno::TypeClass_VOID;
6225 :
6226 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
6227 0 : switch ( nPropType )
6228 : {
6229 : case BASEPROPERTY_VALUE_DOUBLE:
6230 : {
6231 0 : if ( bVoid )
6232 : {
6233 0 : GetAs< LongCurrencyField >()->EnableEmptyFieldValue( true );
6234 0 : GetAs< LongCurrencyField >()->SetEmptyFieldValue();
6235 : }
6236 : else
6237 : {
6238 0 : double d = 0;
6239 0 : if ( Value >>= d )
6240 0 : setValue( d );
6241 : }
6242 : }
6243 0 : break;
6244 : case BASEPROPERTY_VALUEMIN_DOUBLE:
6245 : {
6246 0 : double d = 0;
6247 0 : if ( Value >>= d )
6248 0 : setMin( d );
6249 : }
6250 0 : break;
6251 : case BASEPROPERTY_VALUEMAX_DOUBLE:
6252 : {
6253 0 : double d = 0;
6254 0 : if ( Value >>= d )
6255 0 : setMax( d );
6256 : }
6257 0 : break;
6258 : case BASEPROPERTY_VALUESTEP_DOUBLE:
6259 : {
6260 0 : double d = 0;
6261 0 : if ( Value >>= d )
6262 0 : setSpinSize( d );
6263 : }
6264 0 : break;
6265 : case BASEPROPERTY_DECIMALACCURACY:
6266 : {
6267 0 : sal_Int16 n = sal_Int16();
6268 0 : if ( Value >>= n )
6269 0 : setDecimalDigits( n );
6270 : }
6271 0 : break;
6272 : case BASEPROPERTY_CURRENCYSYMBOL:
6273 : {
6274 0 : OUString aString;
6275 0 : if ( Value >>= aString )
6276 0 : GetAs< LongCurrencyField >()->SetCurrencySymbol( aString );
6277 : }
6278 0 : break;
6279 : case BASEPROPERTY_NUMSHOWTHOUSANDSEP:
6280 : {
6281 0 : bool b = bool();
6282 0 : if ( Value >>= b )
6283 0 : GetAs< LongCurrencyField >()->SetUseThousandSep( b );
6284 : }
6285 0 : break;
6286 : default:
6287 : {
6288 0 : VCLXFormattedSpinField::setProperty( PropertyName, Value );
6289 : }
6290 : }
6291 0 : }
6292 0 : }
6293 :
6294 0 : ::com::sun::star::uno::Any VCLXCurrencyField::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6295 : {
6296 0 : SolarMutexGuard aGuard;
6297 :
6298 0 : ::com::sun::star::uno::Any aProp;
6299 0 : FormatterBase* pFormatter = GetFormatter();
6300 0 : if ( pFormatter )
6301 : {
6302 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
6303 0 : switch ( nPropType )
6304 : {
6305 : case BASEPROPERTY_VALUE_DOUBLE:
6306 : {
6307 0 : aProp <<= (double) getValue();
6308 : }
6309 0 : break;
6310 : case BASEPROPERTY_VALUEMIN_DOUBLE:
6311 : {
6312 0 : aProp <<= (double) getMin();
6313 : }
6314 0 : break;
6315 : case BASEPROPERTY_VALUEMAX_DOUBLE:
6316 : {
6317 0 : aProp <<= (double) getMax();
6318 : }
6319 0 : break;
6320 : case BASEPROPERTY_VALUESTEP_DOUBLE:
6321 : {
6322 0 : aProp <<= (double) getSpinSize();
6323 : }
6324 0 : break;
6325 : case BASEPROPERTY_CURRENCYSYMBOL:
6326 : {
6327 0 : aProp <<= OUString( GetAs< LongCurrencyField >()->GetCurrencySymbol() );
6328 : }
6329 0 : break;
6330 : case BASEPROPERTY_NUMSHOWTHOUSANDSEP:
6331 : {
6332 0 : aProp <<= GetAs< LongCurrencyField >()->IsUseThousandSep();
6333 : }
6334 0 : break;
6335 : default:
6336 : {
6337 0 : aProp <<= VCLXFormattedSpinField::getProperty( PropertyName );
6338 : }
6339 : }
6340 : }
6341 0 : return aProp;
6342 : }
6343 :
6344 :
6345 : // class VCLXPatternField
6346 :
6347 :
6348 15 : void VCLXPatternField::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
6349 : {
6350 : PushPropertyIds( rIds,
6351 : BASEPROPERTY_ALIGN,
6352 : BASEPROPERTY_BACKGROUNDCOLOR,
6353 : BASEPROPERTY_BORDER,
6354 : BASEPROPERTY_BORDERCOLOR,
6355 : BASEPROPERTY_DEFAULTCONTROL,
6356 : BASEPROPERTY_EDITMASK,
6357 : BASEPROPERTY_ENABLED,
6358 : BASEPROPERTY_ENABLEVISIBLE,
6359 : BASEPROPERTY_FONTDESCRIPTOR,
6360 : BASEPROPERTY_HELPTEXT,
6361 : BASEPROPERTY_HELPURL,
6362 : BASEPROPERTY_LITERALMASK,
6363 : BASEPROPERTY_MAXTEXTLEN,
6364 : BASEPROPERTY_PRINTABLE,
6365 : BASEPROPERTY_READONLY,
6366 : BASEPROPERTY_STRICTFORMAT,
6367 : BASEPROPERTY_TABSTOP,
6368 : BASEPROPERTY_TEXT,
6369 : BASEPROPERTY_HIDEINACTIVESELECTION,
6370 : BASEPROPERTY_VERTICALALIGN,
6371 : BASEPROPERTY_WRITING_MODE,
6372 : BASEPROPERTY_CONTEXT_WRITING_MODE,
6373 : BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR,
6374 15 : 0);
6375 15 : VCLXFormattedSpinField::ImplGetPropertyIds( rIds );
6376 15 : }
6377 :
6378 8 : VCLXPatternField::VCLXPatternField()
6379 : {
6380 8 : }
6381 :
6382 16 : VCLXPatternField::~VCLXPatternField()
6383 : {
6384 16 : }
6385 :
6386 : // ::com::sun::star::uno::XInterface
6387 5659 : ::com::sun::star::uno::Any VCLXPatternField::queryInterface( const ::com::sun::star::uno::Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6388 : {
6389 : ::com::sun::star::uno::Any aRet = ::cppu::queryInterface( rType,
6390 5659 : (static_cast< ::com::sun::star::awt::XPatternField* >(this)) );
6391 5659 : return (aRet.hasValue() ? aRet : VCLXFormattedSpinField::queryInterface( rType ));
6392 : }
6393 :
6394 : // ::com::sun::star::lang::XTypeProvider
6395 0 : IMPL_XTYPEPROVIDER_START( VCLXPatternField )
6396 0 : cppu::UnoType<com::sun::star::awt::XPatternField>::get(),
6397 : VCLXFormattedSpinField::getTypes()
6398 0 : IMPL_XTYPEPROVIDER_END
6399 :
6400 81 : void VCLXPatternField::setMasks( const OUString& EditMask, const OUString& LiteralMask ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6401 : {
6402 81 : SolarMutexGuard aGuard;
6403 :
6404 162 : VclPtr< PatternField > pPatternField = GetAs< PatternField >();
6405 81 : if ( pPatternField )
6406 : {
6407 81 : pPatternField->SetMask( OUStringToOString(EditMask, RTL_TEXTENCODING_ASCII_US), LiteralMask );
6408 81 : }
6409 81 : }
6410 :
6411 0 : void VCLXPatternField::getMasks( OUString& EditMask, OUString& LiteralMask ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6412 : {
6413 0 : SolarMutexGuard aGuard;
6414 :
6415 0 : VclPtr< PatternField > pPatternField = GetAs< PatternField >();
6416 0 : if ( pPatternField )
6417 : {
6418 0 : EditMask = OStringToOUString(pPatternField->GetEditMask(), RTL_TEXTENCODING_ASCII_US);
6419 0 : LiteralMask = pPatternField->GetLiteralMask();
6420 0 : }
6421 0 : }
6422 :
6423 81 : void VCLXPatternField::setString( const OUString& Str ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6424 : {
6425 81 : SolarMutexGuard aGuard;
6426 162 : VclPtr< PatternField > pPatternField = GetAs< PatternField >();
6427 81 : if ( pPatternField )
6428 162 : pPatternField->SetString( Str );
6429 81 : }
6430 :
6431 0 : OUString VCLXPatternField::getString() throw(::com::sun::star::uno::RuntimeException, std::exception)
6432 : {
6433 0 : SolarMutexGuard aGuard;
6434 :
6435 0 : OUString aString;
6436 0 : VclPtr< PatternField > pPatternField = GetAs< PatternField >();
6437 0 : if ( pPatternField )
6438 0 : aString = pPatternField->GetString();
6439 0 : return aString;
6440 : }
6441 :
6442 0 : void VCLXPatternField::setStrictFormat( sal_Bool bStrict ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6443 : {
6444 0 : VCLXFormattedSpinField::setStrictFormat( bStrict );
6445 0 : }
6446 :
6447 0 : sal_Bool VCLXPatternField::isStrictFormat() throw(::com::sun::star::uno::RuntimeException, std::exception)
6448 : {
6449 0 : return VCLXFormattedSpinField::isStrictFormat();
6450 : }
6451 :
6452 844 : void VCLXPatternField::setProperty( const OUString& PropertyName, const ::com::sun::star::uno::Any& Value) throw(::com::sun::star::uno::RuntimeException, std::exception)
6453 : {
6454 844 : SolarMutexGuard aGuard;
6455 :
6456 844 : if ( GetWindow() )
6457 : {
6458 844 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
6459 844 : switch ( nPropType )
6460 : {
6461 : case BASEPROPERTY_EDITMASK:
6462 : case BASEPROPERTY_LITERALMASK:
6463 : {
6464 0 : OUString aString;
6465 0 : if ( Value >>= aString )
6466 : {
6467 0 : OUString aEditMask, aLiteralMask;
6468 0 : getMasks( aEditMask, aLiteralMask );
6469 0 : if ( nPropType == BASEPROPERTY_EDITMASK )
6470 0 : aEditMask = aString;
6471 : else
6472 0 : aLiteralMask = aString;
6473 0 : setMasks( aEditMask, aLiteralMask );
6474 0 : }
6475 : }
6476 0 : break;
6477 : default:
6478 : {
6479 844 : VCLXFormattedSpinField::setProperty( PropertyName, Value );
6480 : }
6481 : }
6482 844 : }
6483 844 : }
6484 :
6485 0 : ::com::sun::star::uno::Any VCLXPatternField::getProperty( const OUString& PropertyName ) throw(::com::sun::star::uno::RuntimeException, std::exception)
6486 : {
6487 0 : SolarMutexGuard aGuard;
6488 :
6489 0 : ::com::sun::star::uno::Any aProp;
6490 0 : if ( GetWindow() )
6491 : {
6492 0 : sal_uInt16 nPropType = GetPropertyId( PropertyName );
6493 0 : switch ( nPropType )
6494 : {
6495 : case BASEPROPERTY_EDITMASK:
6496 : case BASEPROPERTY_LITERALMASK:
6497 : {
6498 0 : OUString aEditMask, aLiteralMask;
6499 0 : getMasks( aEditMask, aLiteralMask );
6500 0 : if ( nPropType == BASEPROPERTY_EDITMASK )
6501 0 : aProp <<= aEditMask;
6502 : else
6503 0 : aProp <<= aLiteralMask;
6504 : }
6505 0 : break;
6506 : default:
6507 : {
6508 0 : aProp <<= VCLXFormattedSpinField::getProperty( PropertyName );
6509 : }
6510 : }
6511 : }
6512 0 : return aProp;
6513 : }
6514 :
6515 :
6516 : // class VCLXToolBox
6517 :
6518 19209 : VCLXToolBox::VCLXToolBox()
6519 : {
6520 19209 : }
6521 :
6522 34204 : VCLXToolBox::~VCLXToolBox()
6523 : {
6524 34204 : }
6525 :
6526 12 : ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessibleContext > VCLXToolBox::CreateAccessibleContext()
6527 : {
6528 12 : return getAccessibleFactory().createAccessibleContext( this );
6529 : }
6530 :
6531 :
6532 : // class VCLXFrame
6533 :
6534 0 : VCLXFrame::VCLXFrame()
6535 : {
6536 0 : }
6537 :
6538 0 : void VCLXFrame::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
6539 : {
6540 : PushPropertyIds( rIds,
6541 : BASEPROPERTY_BACKGROUNDCOLOR,
6542 : BASEPROPERTY_DEFAULTCONTROL,
6543 : BASEPROPERTY_ENABLED,
6544 : BASEPROPERTY_ENABLEVISIBLE,
6545 : BASEPROPERTY_FONTDESCRIPTOR,
6546 : BASEPROPERTY_GRAPHIC,
6547 : BASEPROPERTY_HELPTEXT,
6548 : BASEPROPERTY_HELPURL,
6549 : BASEPROPERTY_PRINTABLE,
6550 : BASEPROPERTY_LABEL,
6551 0 : 0);
6552 0 : VCLXContainer::ImplGetPropertyIds( rIds );
6553 0 : }
6554 :
6555 0 : VCLXFrame::~VCLXFrame()
6556 : {
6557 0 : }
6558 :
6559 0 : ::com::sun::star::uno::Any SAL_CALL VCLXFrame::queryInterface(const ::com::sun::star::uno::Type & rType )
6560 : throw(::com::sun::star::uno::RuntimeException, std::exception)
6561 : {
6562 0 : return VCLXContainer::queryInterface( rType );
6563 : }
6564 :
6565 : // ::com::sun::star::lang::XTypeProvider
6566 0 : IMPL_XTYPEPROVIDER_START( VCLXFrame )
6567 : VCLXContainer::getTypes()
6568 0 : IMPL_XTYPEPROVIDER_END
6569 :
6570 : // ::com::sun::star::awt::XView
6571 0 : void SAL_CALL VCLXFrame::draw( sal_Int32 nX, sal_Int32 nY )
6572 : throw(::com::sun::star::uno::RuntimeException, std::exception)
6573 : {
6574 0 : SolarMutexGuard aGuard;
6575 0 : VclPtr< vcl::Window > pWindow = GetWindow();
6576 :
6577 0 : if ( pWindow )
6578 : {
6579 0 : OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( getGraphics() );
6580 0 : if ( !pDev )
6581 0 : pDev = pWindow->GetParent();
6582 :
6583 0 : Size aSize = pDev->PixelToLogic( pWindow->GetSizePixel() );
6584 0 : Point aPos = pDev->PixelToLogic( Point( nX, nY ) );
6585 :
6586 0 : pWindow->Draw( pDev, aPos, aSize, DrawFlags::NoControls );
6587 0 : }
6588 0 : }
6589 :
6590 : // ::com::sun::star::awt::XDevice,
6591 0 : ::com::sun::star::awt::DeviceInfo SAL_CALL VCLXFrame::getInfo()
6592 : throw(::com::sun::star::uno::RuntimeException, std::exception)
6593 : {
6594 0 : ::com::sun::star::awt::DeviceInfo aInfo = VCLXDevice::getInfo();
6595 0 : return aInfo;
6596 : }
6597 :
6598 0 : void SAL_CALL VCLXFrame::setProperty(
6599 : const OUString& PropertyName,
6600 : const ::com::sun::star::uno::Any& Value )
6601 : throw(::com::sun::star::uno::RuntimeException, std::exception)
6602 : {
6603 0 : SolarMutexGuard aGuard;
6604 :
6605 0 : VCLXContainer::setProperty( PropertyName, Value );
6606 0 : }
6607 :
6608 0 : void VCLXFrame::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
6609 : {
6610 0 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > xKeepAlive( this );
6611 0 : VCLXContainer::ProcessWindowEvent( rVclWindowEvent );
6612 798 : }
6613 :
6614 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
