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