?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated core
[LibreOffice.git] / toolkit / source / controls / unocontrols.cxx
blobdfb3ea2b67b8a9d9a5c02a54193eb4e9d4266766
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 <com/sun/star/awt/XTextArea.hpp>
21 #include <com/sun/star/awt/XVclWindowPeer.hpp>
22 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
23 #include <com/sun/star/awt/PosSize.hpp>
24 #include <com/sun/star/awt/VisualEffect.hpp>
25 #include <com/sun/star/awt/LineEndFormat.hpp>
26 #include <com/sun/star/graphic/GraphicProvider.hpp>
27 #include <com/sun/star/graphic/XGraphicProvider.hpp>
28 #include <com/sun/star/graphic/GraphicObject.hpp>
29 #include <com/sun/star/util/Date.hpp>
30 #include <com/sun/star/awt/ImageScaleMode.hpp>
31
32
33 #include <toolkit/controls/formattedcontrol.hxx>
34 #include <toolkit/controls/roadmapcontrol.hxx>
35 #include <toolkit/controls/unocontrols.hxx>
36 #include <toolkit/controls/stdtabcontroller.hxx>
37 #include <toolkit/helper/property.hxx>
38 #include <toolkit/helper/unopropertyarrayhelper.hxx>
39 #include <toolkit/helper/servicenames.hxx>
40 #include <toolkit/helper/macros.hxx>
41 #include <toolkit/helper/imagealign.hxx>
42
43 // for introspection
44 #include <toolkit/awt/vclxwindows.hxx>
45 #include <cppuhelper/typeprovider.hxx>
46 #include <comphelper/componentcontext.hxx>
47 #include <comphelper/processfactory.hxx>
48 #include <comphelper/extract.hxx>
49 #include <vcl/wrkwin.hxx>
50 #include <vcl/svapp.hxx>
51 #include <vcl/edit.hxx>
52 #include <vcl/button.hxx>
53 #include <vcl/group.hxx>
54 #include <vcl/fixed.hxx>
55 #include <vcl/lstbox.hxx>
56 #include <vcl/combobox.hxx>
57 #include <tools/debug.hxx>
58 #include <tools/diagnose_ex.h>
59 #include <tools/date.hxx>
60 #include <tools/time.hxx>
61
62 #include <algorithm>
63 #include <functional>
64
65 using namespace css;
66 using namespace css::awt;
67 using namespace css::lang;
68 using namespace css::uno;
69 using ::com::sun::star::graphic::XGraphic;
70 using ::com::sun::star::uno::Reference;
71 using namespace ::toolkit;
72
73 #define IMPL_SERVICEINFO_DERIVED( ImplName, BaseClass, ServiceName ) \
74 OUString SAL_CALL ImplName::getImplementationName( ) throw(::com::sun::star::uno::RuntimeException) { return OUString( "stardiv.Toolkit." #ImplName ); } \
75 ::com::sun::star::uno::Sequence< OUString > SAL_CALL ImplName::getSupportedServiceNames() throw(::com::sun::star::uno::RuntimeException) \
76 { \
77 ::com::sun::star::uno::Sequence< OUString > aNames = BaseClass::getSupportedServiceNames( ); \
78 aNames.realloc( aNames.getLength() + 1 ); \
79 aNames[ aNames.getLength() - 1 ] = OUString::createFromAscii( ServiceName ); \
80 return aNames; \
81 } \
82
83
84 uno::Reference< graphic::XGraphic >
85 ImageHelper::getGraphicAndGraphicObjectFromURL_nothrow( uno::Reference< graphic::XGraphicObject >& xOutGraphicObj, const OUString& _rURL )
86 {
87 if ( _rURL.startsWith( UNO_NAME_GRAPHOBJ_URLPREFIX ) )
88 {
89 // graphic manager uniqueid
90 OUString sID = _rURL.copy( sizeof( UNO_NAME_GRAPHOBJ_URLPREFIX ) - 1 );
91 xOutGraphicObj = graphic::GraphicObject::createWithId( ::comphelper::getProcessComponentContext(), sID );
92 }
93 else // linked
94 xOutGraphicObj = NULL; // release the GraphicObject
95
96 return ImageHelper::getGraphicFromURL_nothrow( _rURL );
97 }
98
99 ::com::sun::star::uno::Reference< ::com::sun::star::graphic::XGraphic >
100 ImageHelper::getGraphicFromURL_nothrow( const OUString& _rURL )
101 {
102 uno::Reference< graphic::XGraphic > xGraphic;
103 if ( _rURL.isEmpty() )
104 return xGraphic;
105
106 try
107 {
108 uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
109 uno::Reference< graphic::XGraphicProvider > xProvider( graphic::GraphicProvider::create(xContext) );
110 uno::Sequence< beans::PropertyValue > aMediaProperties(1);
111 aMediaProperties[0].Name = OUString( "URL" );
112 aMediaProperties[0].Value <<= _rURL;
113 xGraphic = xProvider->queryGraphic( aMediaProperties );
114 }
115 catch (const Exception&)
116 {
117 DBG_UNHANDLED_EXCEPTION();
118 }
119
120 return xGraphic;
121 }
122 // ----------------------------------------------------
123 // class UnoControlEditModel
124 // ----------------------------------------------------
125 UnoControlEditModel::UnoControlEditModel( const Reference< XComponentContext >& rxContext )
126 :UnoControlModel( rxContext )
127 {
128 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXEdit );
129 }
130
131 OUString UnoControlEditModel::getServiceName( ) throw(::com::sun::star::uno::RuntimeException)
132 {
133 return OUString::createFromAscii( szServiceName_UnoControlEditModel );
134 }
135
136 uno::Any UnoControlEditModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
137 {
138 uno::Any aReturn;
139
140 switch ( nPropId )
141 {
142 case BASEPROPERTY_LINE_END_FORMAT:
143 aReturn <<= (sal_Int16)awt::LineEndFormat::LINE_FEED; // LF
144 break;
145 case BASEPROPERTY_DEFAULTCONTROL:
146 aReturn <<= OUString::createFromAscii( szServiceName_UnoControlEdit );
147 break;
148 default:
149 aReturn = UnoControlModel::ImplGetDefaultValue( nPropId );
150 break;
151 }
152 return aReturn;
153 }
154
155 ::cppu::IPropertyArrayHelper& UnoControlEditModel::getInfoHelper()
156 {
157 static UnoPropertyArrayHelper* pHelper = NULL;
158 if ( !pHelper )
159 {
160 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
161 pHelper = new UnoPropertyArrayHelper( aIDs );
162 }
163 return *pHelper;
164 }
165
166 // beans::XMultiPropertySet
167 uno::Reference< beans::XPropertySetInfo > UnoControlEditModel::getPropertySetInfo( ) throw(uno::RuntimeException)
168 {
169 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
170 return xInfo;
171 }
172
173
174 // ----------------------------------------------------
175 // class UnoEditControl
176 // ----------------------------------------------------
177 UnoEditControl::UnoEditControl()
178 :UnoControlBase()
179 ,maTextListeners( *this )
180 ,mnMaxTextLen( 0 )
181 ,mbSetTextInPeer( sal_False )
182 ,mbSetMaxTextLenInPeer( sal_False )
183 ,mbHasTextProperty( sal_False )
184 {
185 maComponentInfos.nWidth = 100;
186 maComponentInfos.nHeight = 12;
187 mnMaxTextLen = 0;
188 mbSetMaxTextLenInPeer = sal_False;
189 }
190
191 uno::Any SAL_CALL UnoEditControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
192 {
193 uno::Any aReturn = UnoControlBase::queryAggregation( rType );
194 if ( !aReturn.hasValue() )
195 aReturn = UnoEditControl_Base::queryInterface( rType );
196 return aReturn;
197 }
198
199 uno::Any SAL_CALL UnoEditControl::queryInterface( const uno::Type & rType ) throw(uno::RuntimeException)
200 {
201 return UnoControlBase::queryInterface( rType );
202 }
203
204 void SAL_CALL UnoEditControl::acquire( ) throw ()
205 {
206 UnoControlBase::acquire();
207 }
208
209 void SAL_CALL UnoEditControl::release( ) throw ()
210 {
211 UnoControlBase::release();
212 }
213
214 IMPLEMENT_FORWARD_XTYPEPROVIDER2( UnoEditControl, UnoControlBase, UnoEditControl_Base )
215
216 OUString UnoEditControl::GetComponentServiceName()
217 {
218 // by default, we want a simple edit field
219 OUString sName( "Edit" );
220
221 // but maybe we are to display multi-line text?
222 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_MULTILINE ) );
223 sal_Bool b = sal_Bool();
224 if ( ( aVal >>= b ) && b )
225 sName= OUString("MultiLineEdit");
226
227 return sName;
228 }
229
230 sal_Bool SAL_CALL UnoEditControl::setModel(const uno::Reference< awt::XControlModel >& _rModel) throw ( uno::RuntimeException )
231 {
232 sal_Bool bReturn = UnoControlBase::setModel( _rModel );
233 mbHasTextProperty = ImplHasProperty( BASEPROPERTY_TEXT );
234 return bReturn;
235 }
236
237 void UnoEditControl::ImplSetPeerProperty( const OUString& rPropName, const uno::Any& rVal )
238 {
239 sal_Bool bDone = sal_False;
240 if ( GetPropertyId( rPropName ) == BASEPROPERTY_TEXT )
241 {
242 // #96986# use setText(), or text listener will not be called.
243 uno::Reference < awt::XTextComponent > xTextComponent( getPeer(), uno::UNO_QUERY );
244 if ( xTextComponent.is() )
245 {
246 OUString sText;
247 rVal >>= sText;
248 ImplCheckLocalize( sText );
249 xTextComponent->setText( sText );
250 bDone = sal_True;
251 }
252 }
253
254 if ( !bDone )
255 UnoControlBase::ImplSetPeerProperty( rPropName, rVal );
256 }
257
258 void UnoEditControl::dispose() throw(uno::RuntimeException)
259 {
260 lang::EventObject aEvt( *this );
261 maTextListeners.disposeAndClear( aEvt );
262 UnoControl::dispose();
263 }
264
265 void UnoEditControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException)
266 {
267 UnoControl::createPeer( rxToolkit, rParentPeer );
268
269 uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
270 if ( xText.is() )
271 {
272 xText->addTextListener( this );
273
274 if ( mbSetMaxTextLenInPeer )
275 xText->setMaxTextLen( mnMaxTextLen );
276 if ( mbSetTextInPeer )
277 xText->setText( maText );
278 }
279 }
280
281 void UnoEditControl::textChanged(const awt::TextEvent& e) throw(uno::RuntimeException)
282 {
283 uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
284
285 if ( mbHasTextProperty )
286 {
287 uno::Any aAny;
288 aAny <<= xText->getText();
289 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TEXT ), aAny, sal_False );
290 }
291 else
292 {
293 maText = xText->getText();
294 }
295
296 if ( maTextListeners.getLength() )
297 maTextListeners.textChanged( e );
298 }
299
300 void UnoEditControl::addTextListener(const uno::Reference< awt::XTextListener > & l) throw(uno::RuntimeException)
301 {
302 maTextListeners.addInterface( l );
303 }
304
305 void UnoEditControl::removeTextListener(const uno::Reference< awt::XTextListener > & l) throw(uno::RuntimeException)
306 {
307 maTextListeners.removeInterface( l );
308 }
309
310 void UnoEditControl::setText( const OUString& aText ) throw(uno::RuntimeException)
311 {
312 if ( mbHasTextProperty )
313 {
314 uno::Any aAny;
315 aAny <<= aText;
316 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TEXT ), aAny, sal_True );
317 }
318 else
319 {
320 maText = aText;
321 mbSetTextInPeer = sal_True;
322 uno::Reference < awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
323 if ( xText.is() )
324 xText->setText( maText );
325 }
326
327 // Setting the property to the VCLXWindow doesn't call textChanged
328 if ( maTextListeners.getLength() )
329 {
330 awt::TextEvent aEvent;
331 aEvent.Source = *this;
332 maTextListeners.textChanged( aEvent );
333 }
334 }
335
336 namespace
337 {
338 static void lcl_normalize( awt::Selection& _rSel )
339 {
340 if ( _rSel.Min > _rSel.Max )
341 ::std::swap( _rSel.Min, _rSel.Max );
342 }
343 }
344
345 void UnoEditControl::insertText( const awt::Selection& rSel, const OUString& rNewText ) throw(uno::RuntimeException)
346 {
347 // normalize the selection - OUString::replaceAt has a strange behaviour if the min is greater than the max
348 awt::Selection aSelection( rSel );
349 lcl_normalize( aSelection );
350
351 // preserve the selection resp. cursor position
352 awt::Selection aNewSelection( getSelection() );
353 #ifdef ALSO_PRESERVE_COMPLETE_SELECTION
354 // (not sure - looks uglier ...)
355 sal_Int32 nDeletedCharacters = ( aSelection.Max - aSelection.Min ) - rNewText.getLength();
356 if ( aNewSelection.Min > aSelection.Min )
357 aNewSelection.Min -= nDeletedCharacters;
358 if ( aNewSelection.Max > aSelection.Max )
359 aNewSelection.Max -= nDeletedCharacters;
360 #else
361 aNewSelection.Max = ::std::min( aNewSelection.Min, aNewSelection.Max ) + rNewText.getLength();
362 aNewSelection.Min = aNewSelection.Max;
363 #endif
364
365 OUString aOldText = getText();
366 OUString aNewText = aOldText.replaceAt( aSelection.Min, aSelection.Max - aSelection.Min, rNewText );
367 setText( aNewText );
368
369 setSelection( aNewSelection );
370 }
371
372 OUString UnoEditControl::getText() throw(uno::RuntimeException)
373 {
374 OUString aText = maText;
375
376 if ( mbHasTextProperty )
377 aText = ImplGetPropertyValue_UString( BASEPROPERTY_TEXT );
378 else
379 {
380 uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
381 if ( xText.is() )
382 aText = xText->getText();
383 }
384
385 return aText;
386 }
387
388 OUString UnoEditControl::getSelectedText( void ) throw(uno::RuntimeException)
389 {
390 OUString sSelected;
391 uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
392 if ( xText.is() )
393 sSelected = xText->getSelectedText();
394
395 return sSelected;
396 }
397
398 void UnoEditControl::setSelection( const awt::Selection& aSelection ) throw(uno::RuntimeException)
399 {
400 uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
401 if ( xText.is() )
402 xText->setSelection( aSelection );
403 }
404
405 awt::Selection UnoEditControl::getSelection( void ) throw(uno::RuntimeException)
406 {
407 awt::Selection aSel;
408 uno::Reference< awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
409 if ( xText.is() )
410 aSel = xText->getSelection();
411 return aSel;
412 }
413
414 sal_Bool UnoEditControl::isEditable( void ) throw(uno::RuntimeException)
415 {
416 return !ImplGetPropertyValue_BOOL( BASEPROPERTY_READONLY );
417 }
418
419 void UnoEditControl::setEditable( sal_Bool bEditable ) throw(uno::RuntimeException)
420 {
421 uno::Any aAny;
422 aAny <<= (sal_Bool)!bEditable;
423 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_READONLY ), aAny, sal_True );
424 }
425
426 sal_Int16 UnoEditControl::getMaxTextLen() throw(uno::RuntimeException)
427 {
428 sal_Int16 nMaxLen = mnMaxTextLen;
429
430 if ( ImplHasProperty( BASEPROPERTY_MAXTEXTLEN ) )
431 nMaxLen = ImplGetPropertyValue_INT16( BASEPROPERTY_MAXTEXTLEN );
432
433 return nMaxLen;
434 }
435
436 void UnoEditControl::setMaxTextLen( sal_Int16 nLen ) throw(uno::RuntimeException)
437 {
438 if ( ImplHasProperty( BASEPROPERTY_MAXTEXTLEN) )
439 {
440 uno::Any aAny;
441 aAny <<= (sal_Int16)nLen;
442 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_MAXTEXTLEN ), aAny, sal_True );
443 }
444 else
445 {
446 mnMaxTextLen = nLen;
447 mbSetMaxTextLenInPeer = sal_True;
448 uno::Reference < awt::XTextComponent > xText( getPeer(), uno::UNO_QUERY );
449 if ( xText.is() )
450 xText->setMaxTextLen( mnMaxTextLen );
451 }
452 }
453
454 awt::Size UnoEditControl::getMinimumSize( ) throw(uno::RuntimeException)
455 {
456 return Impl_getMinimumSize();
457 }
458
459 awt::Size UnoEditControl::getPreferredSize( ) throw(uno::RuntimeException)
460 {
461 return Impl_getPreferredSize();
462 }
463
464 awt::Size UnoEditControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
465 {
466 return Impl_calcAdjustedSize( rNewSize );
467 }
468
469 awt::Size UnoEditControl::getMinimumSize( sal_Int16 nCols, sal_Int16 nLines ) throw(uno::RuntimeException)
470 {
471 return Impl_getMinimumSize( nCols, nLines );
472 }
473
474 void UnoEditControl::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(uno::RuntimeException)
475 {
476 Impl_getColumnsAndLines( nCols, nLines );
477 }
478
479 OUString UnoEditControl::getImplementationName( ) throw(uno::RuntimeException)
480 {
481 return OUString( "stardiv.Toolkit.UnoEditControl" );
482 }
483
484 uno::Sequence< OUString > UnoEditControl::getSupportedServiceNames() throw(uno::RuntimeException)
485 {
486 uno::Sequence< OUString > aNames = UnoControlBase::getSupportedServiceNames( );
487 aNames.realloc( aNames.getLength() + 1 );
488 aNames[ aNames.getLength() - 1 ] = OUString::createFromAscii( szServiceName2_UnoControlEdit );
489 return aNames;
490 }
491
492 // ----------------------------------------------------
493 // class UnoControlFileControlModel
494 // ----------------------------------------------------
495 UnoControlFileControlModel::UnoControlFileControlModel( const Reference< XComponentContext >& rxContext )
496 :UnoControlModel( rxContext )
497 {
498 ImplRegisterProperty( BASEPROPERTY_ALIGN );
499 ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
500 ImplRegisterProperty( BASEPROPERTY_BORDER );
501 ImplRegisterProperty( BASEPROPERTY_BORDERCOLOR );
502 ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
503 ImplRegisterProperty( BASEPROPERTY_ENABLED );
504 ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
505 ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR );
506 ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
507 ImplRegisterProperty( BASEPROPERTY_HELPURL );
508 ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
509 ImplRegisterProperty( BASEPROPERTY_READONLY );
510 ImplRegisterProperty( BASEPROPERTY_TABSTOP );
511 ImplRegisterProperty( BASEPROPERTY_TEXT );
512 ImplRegisterProperty( BASEPROPERTY_VERTICALALIGN );
513 ImplRegisterProperty( BASEPROPERTY_WRITING_MODE );
514 ImplRegisterProperty( BASEPROPERTY_CONTEXT_WRITING_MODE );
515 ImplRegisterProperty( BASEPROPERTY_HIDEINACTIVESELECTION );
516 }
517
518 OUString UnoControlFileControlModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
519 {
520 return OUString::createFromAscii( szServiceName_UnoControlFileControlModel );
521 }
522
523 uno::Any UnoControlFileControlModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
524 {
525 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
526 {
527 uno::Any aAny;
528 aAny <<= OUString::createFromAscii( szServiceName_UnoControlFileControl );
529 return aAny;
530 }
531 return UnoControlModel::ImplGetDefaultValue( nPropId );
532 }
533
534 ::cppu::IPropertyArrayHelper& UnoControlFileControlModel::getInfoHelper()
535 {
536 static UnoPropertyArrayHelper* pHelper = NULL;
537 if ( !pHelper )
538 {
539 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
540 pHelper = new UnoPropertyArrayHelper( aIDs );
541 }
542 return *pHelper;
543 }
544
545 // beans::XMultiPropertySet
546 uno::Reference< beans::XPropertySetInfo > UnoControlFileControlModel::getPropertySetInfo( ) throw(uno::RuntimeException)
547 {
548 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
549 return xInfo;
550 }
551
552 // ----------------------------------------------------
553 // class UnoFileControl
554 // ----------------------------------------------------
555 UnoFileControl::UnoFileControl()
556 :UnoEditControl()
557 {
558 }
559
560 OUString UnoFileControl::GetComponentServiceName()
561 {
562 return OUString("filecontrol");
563 }
564
565 // ----------------------------------------------------
566 // class GraphicControlModel
567 // ----------------------------------------------------
568 uno::Any GraphicControlModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
569 {
570 if ( nPropId == BASEPROPERTY_GRAPHIC )
571 return uno::makeAny( uno::Reference< graphic::XGraphic >() );
572
573 return UnoControlModel::ImplGetDefaultValue( nPropId );
574 }
575
576 void SAL_CALL GraphicControlModel::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const ::com::sun::star::uno::Any& rValue ) throw (::com::sun::star::uno::Exception)
577 {
578 UnoControlModel::setFastPropertyValue_NoBroadcast( nHandle, rValue );
579
580 // - ImageAlign and ImagePosition need to correspond to each other
581 // - Graphic and ImageURL need to correspond to each other
582 try
583 {
584 switch ( nHandle )
585 {
586 case BASEPROPERTY_IMAGEURL:
587 if ( !mbAdjustingGraphic && ImplHasProperty( BASEPROPERTY_GRAPHIC ) )
588 {
589 mbAdjustingGraphic = true;
590 OUString sImageURL;
591 OSL_VERIFY( rValue >>= sImageURL );
592 setDependentFastPropertyValue( BASEPROPERTY_GRAPHIC, uno::makeAny( ImageHelper::getGraphicFromURL_nothrow( sImageURL ) ) );
593 mbAdjustingGraphic = false;
594 }
595 break;
596
597 case BASEPROPERTY_GRAPHIC:
598 if ( !mbAdjustingGraphic && ImplHasProperty( BASEPROPERTY_IMAGEURL ) )
599 {
600 mbAdjustingGraphic = true;
601 setDependentFastPropertyValue( BASEPROPERTY_IMAGEURL, uno::makeAny( OUString() ) );
602 mbAdjustingGraphic = false;
603 }
604 break;
605
606 case BASEPROPERTY_IMAGEALIGN:
607 if ( !mbAdjustingImagePosition && ImplHasProperty( BASEPROPERTY_IMAGEPOSITION ) )
608 {
609 mbAdjustingImagePosition = true;
610 sal_Int16 nUNOValue = 0;
611 OSL_VERIFY( rValue >>= nUNOValue );
612 setDependentFastPropertyValue( BASEPROPERTY_IMAGEPOSITION, uno::makeAny( getExtendedImagePosition( nUNOValue ) ) );
613 mbAdjustingImagePosition = false;
614 }
615 break;
616 case BASEPROPERTY_IMAGEPOSITION:
617 if ( !mbAdjustingImagePosition && ImplHasProperty( BASEPROPERTY_IMAGEALIGN ) )
618 {
619 mbAdjustingImagePosition = true;
620 sal_Int16 nUNOValue = 0;
621 OSL_VERIFY( rValue >>= nUNOValue );
622 setDependentFastPropertyValue( BASEPROPERTY_IMAGEALIGN, uno::makeAny( getCompatibleImageAlign( translateImagePosition( nUNOValue ) ) ) );
623 mbAdjustingImagePosition = false;
624 }
625 break;
626 }
627 }
628 catch( const ::com::sun::star::uno::Exception& )
629 {
630 OSL_FAIL( "GraphicControlModel::setFastPropertyValue_NoBroadcast: caught an exception while aligning the ImagePosition/ImageAlign properties!" );
631 mbAdjustingImagePosition = sal_False;
632 }
633 }
634
635 // ----------------------------------------------------
636 // class UnoControlButtonModel
637 // ----------------------------------------------------
638 UnoControlButtonModel::UnoControlButtonModel( const Reference< XComponentContext >& rxContext )
639 :GraphicControlModel( rxContext )
640 {
641 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXButton );
642
643 osl_atomic_increment( &m_refCount );
644 {
645 setFastPropertyValue_NoBroadcast( BASEPROPERTY_IMAGEPOSITION, ImplGetDefaultValue( BASEPROPERTY_IMAGEPOSITION ) );
646 // this ensures that our ImagePosition is consistent with our ImageAlign property (since both
647 // defaults are not per se consistent), since both are coupled in setFastPropertyValue_NoBroadcast
648 }
649 osl_atomic_decrement( &m_refCount );
650 }
651
652 OUString UnoControlButtonModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
653 {
654 return OUString::createFromAscii( szServiceName_UnoControlButtonModel );
655 }
656
657 uno::Any UnoControlButtonModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
658 {
659 switch ( nPropId )
660 {
661 case BASEPROPERTY_DEFAULTCONTROL:
662 return uno::makeAny( OUString::createFromAscii( szServiceName_UnoControlButton ) );
663 case BASEPROPERTY_TOGGLE:
664 return uno::makeAny( (sal_Bool)sal_False );
665 case BASEPROPERTY_ALIGN:
666 return uno::makeAny( (sal_Int16)PROPERTY_ALIGN_CENTER );
667 case BASEPROPERTY_FOCUSONCLICK:
668 return uno::makeAny( (sal_Bool)sal_True );
669 }
670
671 return GraphicControlModel::ImplGetDefaultValue( nPropId );
672 }
673
674 ::cppu::IPropertyArrayHelper& UnoControlButtonModel::getInfoHelper()
675 {
676 static UnoPropertyArrayHelper* pHelper = NULL;
677 if ( !pHelper )
678 {
679 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
680 pHelper = new UnoPropertyArrayHelper( aIDs );
681 }
682 return *pHelper;
683 }
684
685 // beans::XMultiPropertySet
686 uno::Reference< beans::XPropertySetInfo > UnoControlButtonModel::getPropertySetInfo( ) throw(uno::RuntimeException)
687 {
688 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
689 return xInfo;
690 }
691
692 // ----------------------------------------------------
693 // class UnoButtonControl
694 // ----------------------------------------------------
695 UnoButtonControl::UnoButtonControl()
696 :UnoButtonControl_Base()
697 ,maActionListeners( *this )
698 ,maItemListeners( *this )
699 {
700 maComponentInfos.nWidth = 50;
701 maComponentInfos.nHeight = 14;
702 }
703
704 OUString UnoButtonControl::GetComponentServiceName()
705 {
706 OUString aName( "pushbutton" );
707 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_PUSHBUTTONTYPE ) );
708 sal_Int16 n = sal_Int16();
709 if ( ( aVal >>= n ) && n )
710 {
711 // Use PushButtonType later when available...
712 switch ( n )
713 {
714 case 1 /*PushButtonType::OK*/: aName= OUString("okbutton");
715 break;
716 case 2 /*PushButtonType::CANCEL*/: aName= OUString("cancelbutton");
717 break;
718 case 3 /*PushButtonType::HELP*/: aName= OUString("helpbutton");
719 break;
720 default:
721 {
722 OSL_FAIL( "Unknown Button Type!" );
723 }
724 }
725 }
726 return aName;
727 }
728
729 void UnoButtonControl::dispose() throw(uno::RuntimeException)
730 {
731 lang::EventObject aEvt;
732 aEvt.Source = (::cppu::OWeakObject*)this;
733 maActionListeners.disposeAndClear( aEvt );
734 maItemListeners.disposeAndClear( aEvt );
735 UnoControlBase::dispose();
736 }
737
738 void UnoButtonControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException)
739 {
740 UnoControlBase::createPeer( rxToolkit, rParentPeer );
741
742 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
743 xButton->setActionCommand( maActionCommand );
744 if ( maActionListeners.getLength() )
745 xButton->addActionListener( &maActionListeners );
746
747 uno::Reference< XToggleButton > xPushButton( getPeer(), uno::UNO_QUERY );
748 if ( xPushButton.is() )
749 xPushButton->addItemListener( this );
750 }
751
752 void UnoButtonControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
753 {
754 maActionListeners.addInterface( l );
755 if( getPeer().is() && maActionListeners.getLength() == 1 )
756 {
757 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
758 xButton->addActionListener( &maActionListeners );
759 }
760 }
761
762 void UnoButtonControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
763 {
764 if( getPeer().is() && maActionListeners.getLength() == 1 )
765 {
766 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
767 xButton->removeActionListener( &maActionListeners );
768 }
769 maActionListeners.removeInterface( l );
770 }
771
772 void UnoButtonControl::addItemListener(const uno::Reference< awt::XItemListener > & l) throw(uno::RuntimeException)
773 {
774 maItemListeners.addInterface( l );
775 }
776
777 void UnoButtonControl::removeItemListener(const uno::Reference< awt::XItemListener > & l) throw(uno::RuntimeException)
778 {
779 maItemListeners.removeInterface( l );
780 }
781
782 void SAL_CALL UnoButtonControl::disposing( const lang::EventObject& Source ) throw (uno::RuntimeException)
783 {
784 UnoControlBase::disposing( Source );
785 }
786
787 void SAL_CALL UnoButtonControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw (uno::RuntimeException)
788 {
789 // forward to model
790 uno::Any aAny;
791 aAny <<= (sal_Int16)rEvent.Selected;
792 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_False );
793
794 // multiplex
795 ItemEvent aEvent( rEvent );
796 aEvent.Source = *this;
797 maItemListeners.itemStateChanged( aEvent );
798 }
799
800 void UnoButtonControl::setLabel( const OUString& rLabel ) throw(uno::RuntimeException)
801 {
802 uno::Any aAny;
803 aAny <<= rLabel;
804 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True );
805 }
806
807 void UnoButtonControl::setActionCommand( const OUString& rCommand ) throw(uno::RuntimeException)
808 {
809 maActionCommand = rCommand;
810 if ( getPeer().is() )
811 {
812 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
813 xButton->setActionCommand( rCommand );
814 }
815 }
816
817 awt::Size UnoButtonControl::getMinimumSize( ) throw(uno::RuntimeException)
818 {
819 return Impl_getMinimumSize();
820 }
821
822 awt::Size UnoButtonControl::getPreferredSize( ) throw(uno::RuntimeException)
823 {
824 return Impl_getPreferredSize();
825 }
826
827 awt::Size UnoButtonControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
828 {
829 return Impl_calcAdjustedSize( rNewSize );
830 }
831
832 // ----------------------------------------------------
833 // class UnoControlImageControlModel
834 // ----------------------------------------------------
835 UnoControlImageControlModel::UnoControlImageControlModel( const Reference< XComponentContext >& rxContext )
836 :GraphicControlModel( rxContext )
837 ,mbAdjustingImageScaleMode( false )
838 {
839 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXImageControl );
840 }
841
842 OUString UnoControlImageControlModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
843 {
844 return OUString::createFromAscii( szServiceName_UnoControlImageControlModel );
845 }
846
847 uno::Any UnoControlImageControlModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
848 {
849 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
850 return uno::makeAny( OUString::createFromAscii( szServiceName_UnoControlImageControl ) );
851
852 if ( nPropId == BASEPROPERTY_IMAGE_SCALE_MODE )
853 return makeAny( awt::ImageScaleMode::Anisotropic );
854
855 return GraphicControlModel::ImplGetDefaultValue( nPropId );
856 }
857
858 ::cppu::IPropertyArrayHelper& UnoControlImageControlModel::getInfoHelper()
859 {
860 static UnoPropertyArrayHelper* pHelper = NULL;
861 if ( !pHelper )
862 {
863 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
864 pHelper = new UnoPropertyArrayHelper( aIDs );
865 }
866 return *pHelper;
867 }
868
869 // beans::XMultiPropertySet
870 uno::Reference< beans::XPropertySetInfo > UnoControlImageControlModel::getPropertySetInfo( ) throw(uno::RuntimeException)
871 {
872 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
873 return xInfo;
874 }
875
876 void SAL_CALL UnoControlImageControlModel::setFastPropertyValue_NoBroadcast( sal_Int32 _nHandle, const ::com::sun::star::uno::Any& _rValue ) throw (::com::sun::star::uno::Exception)
877 {
878 GraphicControlModel::setFastPropertyValue_NoBroadcast( _nHandle, _rValue );
879
880 // ScaleImage is an older (and less powerful) version of ScaleMode, but keep both in sync as far as possible
881 try
882 {
883 switch ( _nHandle )
884 {
885 case BASEPROPERTY_IMAGE_SCALE_MODE:
886 if ( !mbAdjustingImageScaleMode && ImplHasProperty( BASEPROPERTY_SCALEIMAGE ) )
887 {
888 mbAdjustingImageScaleMode = true;
889 sal_Int16 nScaleMode( awt::ImageScaleMode::Anisotropic );
890 OSL_VERIFY( _rValue >>= nScaleMode );
891 setDependentFastPropertyValue( BASEPROPERTY_SCALEIMAGE, uno::makeAny( sal_Bool( nScaleMode != awt::ImageScaleMode::None ) ) );
892 mbAdjustingImageScaleMode = false;
893 }
894 break;
895 case BASEPROPERTY_SCALEIMAGE:
896 if ( !mbAdjustingImageScaleMode && ImplHasProperty( BASEPROPERTY_IMAGE_SCALE_MODE ) )
897 {
898 mbAdjustingImageScaleMode = true;
899 sal_Bool bScale = sal_True;
900 OSL_VERIFY( _rValue >>= bScale );
901 setDependentFastPropertyValue( BASEPROPERTY_IMAGE_SCALE_MODE, uno::makeAny( bScale ? awt::ImageScaleMode::Anisotropic : awt::ImageScaleMode::None ) );
902 mbAdjustingImageScaleMode = false;
903 }
904 break;
905 }
906 }
907 catch( const Exception& )
908 {
909 mbAdjustingImageScaleMode = false;
910 throw;
911 }
912 }
913
914 // ----------------------------------------------------
915 // class UnoImageControlControl
916 // ----------------------------------------------------
917 UnoImageControlControl::UnoImageControlControl()
918 :UnoImageControlControl_Base()
919 ,maActionListeners( *this )
920 {
921 // TODO: Where should I look for defaults?
922 maComponentInfos.nWidth = 100;
923 maComponentInfos.nHeight = 100;
924 }
925
926 OUString UnoImageControlControl::GetComponentServiceName()
927 {
928 return OUString("fixedimage");
929 }
930
931 void UnoImageControlControl::dispose() throw(uno::RuntimeException)
932 {
933 lang::EventObject aEvt;
934 aEvt.Source = (::cppu::OWeakObject*)this;
935 maActionListeners.disposeAndClear( aEvt );
936 UnoControl::dispose();
937 }
938
939 sal_Bool UnoImageControlControl::isTransparent() throw(uno::RuntimeException)
940 {
941 return sal_True;
942 }
943
944 awt::Size UnoImageControlControl::getMinimumSize( ) throw(uno::RuntimeException)
945 {
946 return Impl_getMinimumSize();
947 }
948
949 awt::Size UnoImageControlControl::getPreferredSize( ) throw(uno::RuntimeException)
950 {
951 return Impl_getPreferredSize();
952 }
953
954 awt::Size UnoImageControlControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
955 {
956 return Impl_calcAdjustedSize( rNewSize );
957 }
958
959 // ----------------------------------------------------
960 // class UnoControlRadioButtonModel
961 // ----------------------------------------------------
962 UnoControlRadioButtonModel::UnoControlRadioButtonModel( const Reference< XComponentContext >& rxContext )
963 :GraphicControlModel( rxContext )
964 {
965 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXRadioButton );
966 }
967
968 OUString UnoControlRadioButtonModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
969 {
970 return OUString::createFromAscii( szServiceName_UnoControlRadioButtonModel );
971 }
972
973 uno::Any UnoControlRadioButtonModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
974 {
975 switch ( nPropId )
976 {
977 case BASEPROPERTY_DEFAULTCONTROL:
978 return uno::makeAny( OUString::createFromAscii( szServiceName_UnoControlRadioButton ) );
979
980 case BASEPROPERTY_VISUALEFFECT:
981 return uno::makeAny( (sal_Int16)awt::VisualEffect::LOOK3D );
982 }
983
984 return GraphicControlModel::ImplGetDefaultValue( nPropId );
985 }
986
987 ::cppu::IPropertyArrayHelper& UnoControlRadioButtonModel::getInfoHelper()
988 {
989 static UnoPropertyArrayHelper* pHelper = NULL;
990 if ( !pHelper )
991 {
992 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
993 pHelper = new UnoPropertyArrayHelper( aIDs );
994 }
995 return *pHelper;
996 }
997
998 // beans::XMultiPropertySet
999 uno::Reference< beans::XPropertySetInfo > UnoControlRadioButtonModel::getPropertySetInfo( ) throw(uno::RuntimeException)
1000 {
1001 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1002 return xInfo;
1003 }
1004
1005
1006
1007 // ----------------------------------------------------
1008 // class UnoRadioButtonControl
1009 // ----------------------------------------------------
1010 UnoRadioButtonControl::UnoRadioButtonControl()
1011 :UnoRadioButtonControl_Base()
1012 ,maItemListeners( *this )
1013 ,maActionListeners( *this )
1014 {
1015 maComponentInfos.nWidth = 100;
1016 maComponentInfos.nHeight = 12;
1017 }
1018
1019 OUString UnoRadioButtonControl::GetComponentServiceName()
1020 {
1021 return OUString("radiobutton");
1022 }
1023
1024 void UnoRadioButtonControl::dispose() throw(uno::RuntimeException)
1025 {
1026 lang::EventObject aEvt;
1027 aEvt.Source = (::cppu::OWeakObject*)this;
1028 maItemListeners.disposeAndClear( aEvt );
1029 UnoControlBase::dispose();
1030 }
1031
1032
1033 sal_Bool UnoRadioButtonControl::isTransparent() throw(uno::RuntimeException)
1034 {
1035 return sal_True;
1036 }
1037
1038 void UnoRadioButtonControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException)
1039 {
1040 UnoControlBase::createPeer( rxToolkit, rParentPeer );
1041
1042 uno::Reference < awt::XRadioButton > xRadioButton( getPeer(), uno::UNO_QUERY );
1043 xRadioButton->addItemListener( this );
1044
1045 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
1046 xButton->setActionCommand( maActionCommand );
1047 if ( maActionListeners.getLength() )
1048 xButton->addActionListener( &maActionListeners );
1049
1050 // as default, set the "AutoToggle" to true
1051 // (it is set to false in VCLXToolkit::ImplCreateWindow because of #87254#, but we want to
1052 // have it enabled by default because of 85071)
1053 uno::Reference< awt::XVclWindowPeer > xVclWindowPeer( getPeer(), uno::UNO_QUERY );
1054 if ( xVclWindowPeer.is() )
1055 xVclWindowPeer->setProperty( GetPropertyName( BASEPROPERTY_AUTOTOGGLE ), ::cppu::bool2any( sal_True ) );
1056 }
1057
1058 void UnoRadioButtonControl::addItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
1059 {
1060 maItemListeners.addInterface( l );
1061 }
1062
1063 void UnoRadioButtonControl::removeItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
1064 {
1065 maItemListeners.removeInterface( l );
1066 }
1067
1068 void UnoRadioButtonControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
1069 {
1070 maActionListeners.addInterface( l );
1071 if( getPeer().is() && maActionListeners.getLength() == 1 )
1072 {
1073 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
1074 xButton->addActionListener( &maActionListeners );
1075 }
1076 }
1077
1078 void UnoRadioButtonControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
1079 {
1080 if( getPeer().is() && maActionListeners.getLength() == 1 )
1081 {
1082 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
1083 xButton->removeActionListener( &maActionListeners );
1084 }
1085 maActionListeners.removeInterface( l );
1086 }
1087
1088 void UnoRadioButtonControl::setLabel( const OUString& rLabel ) throw(uno::RuntimeException)
1089 {
1090 uno::Any aAny;
1091 aAny <<= rLabel;
1092 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True );
1093 }
1094
1095 void UnoRadioButtonControl::setActionCommand( const OUString& rCommand ) throw(uno::RuntimeException)
1096 {
1097 maActionCommand = rCommand;
1098 if ( getPeer().is() )
1099 {
1100 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
1101 xButton->setActionCommand( rCommand );
1102 }
1103 }
1104
1105 void UnoRadioButtonControl::setState( sal_Bool bOn ) throw(uno::RuntimeException)
1106 {
1107 sal_Int16 nState = bOn ? 1 : 0;
1108 uno::Any aAny;
1109 aAny <<= nState;
1110 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_True );
1111 }
1112
1113 sal_Bool UnoRadioButtonControl::getState() throw(uno::RuntimeException)
1114 {
1115 sal_Int16 nState = 0;
1116 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ) );
1117 aVal >>= nState;
1118 return nState ? sal_True : sal_False;
1119 }
1120
1121 void UnoRadioButtonControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw(uno::RuntimeException)
1122 {
1123 uno::Any aAny;
1124 aAny <<= (sal_Int16)rEvent.Selected;
1125 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_False );
1126
1127 // compatibility:
1128 // in OOo 1.0.x, when the user clicked a radio button in a group of buttons, this resulted
1129 // in _one_ itemStateChanged call for exactly the radio button which's state changed from
1130 // "0" to "1".
1131 // Nowadays, since the listener handling changed a lot towards 1.1 (the VCLXWindow reacts on more
1132 // basic events from the VCL-windows, not anymore on the Link-based events like in 1.0.x), this
1133 // isn't the case anymore: For instance, this method here gets called for the radio button
1134 // which is being implicitily _de_selected, too. This is pretty bad for compatibility.
1135 // Thus, we suppress all events with a new state other than "1". This is unlogical, and weird, when looking
1136 // from a pure API perspective, but it's _compatible_ with older product versions, and this is
1137 // all which matters here.
1138 // #i14703#
1139 if ( 1 == rEvent.Selected )
1140 {
1141 if ( maItemListeners.getLength() )
1142 maItemListeners.itemStateChanged( rEvent );
1143 }
1144 // note that speaking stricly, this is wrong: When in 1.0.x, the user would have de-selected
1145 // a radio button _without_ selecing another one, this would have caused a notification.
1146 // With the change done here, this today won't cause a notification anymore.
1147 //
1148 // Fortunately, it's not possible for the user to de-select a radio button without selecting another on,
1149 // at least not via the regular UI. It _would_ be possible via the Accessibility API, which
1150 // counts as "user input", too. But in 1.0.x, there was no Accessibility API, so there is nothing
1151 // to be inconsistent with.
1152 }
1153
1154 awt::Size UnoRadioButtonControl::getMinimumSize( ) throw(uno::RuntimeException)
1155 {
1156 return Impl_getMinimumSize();
1157 }
1158
1159 awt::Size UnoRadioButtonControl::getPreferredSize( ) throw(uno::RuntimeException)
1160 {
1161 return Impl_getPreferredSize();
1162 }
1163
1164 awt::Size UnoRadioButtonControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
1165 {
1166 return Impl_calcAdjustedSize( rNewSize );
1167 }
1168
1169 // ----------------------------------------------------
1170 // class UnoControlCheckBoxModel
1171 // ----------------------------------------------------
1172 UnoControlCheckBoxModel::UnoControlCheckBoxModel( const Reference< XComponentContext >& rxContext )
1173 :GraphicControlModel( rxContext )
1174 {
1175 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXCheckBox );
1176 }
1177
1178 OUString UnoControlCheckBoxModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
1179 {
1180 return OUString::createFromAscii( szServiceName_UnoControlCheckBoxModel );
1181 }
1182
1183 uno::Any UnoControlCheckBoxModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
1184 {
1185 switch ( nPropId )
1186 {
1187 case BASEPROPERTY_DEFAULTCONTROL:
1188 return uno::makeAny( OUString::createFromAscii( szServiceName_UnoControlCheckBox ) );
1189
1190 case BASEPROPERTY_VISUALEFFECT:
1191 return uno::makeAny( (sal_Int16)awt::VisualEffect::LOOK3D );
1192 }
1193
1194 return GraphicControlModel::ImplGetDefaultValue( nPropId );
1195 }
1196
1197 ::cppu::IPropertyArrayHelper& UnoControlCheckBoxModel::getInfoHelper()
1198 {
1199 static UnoPropertyArrayHelper* pHelper = NULL;
1200 if ( !pHelper )
1201 {
1202 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
1203 pHelper = new UnoPropertyArrayHelper( aIDs );
1204 }
1205 return *pHelper;
1206 }
1207
1208 // beans::XMultiPropertySet
1209 uno::Reference< beans::XPropertySetInfo > UnoControlCheckBoxModel::getPropertySetInfo( ) throw(uno::RuntimeException)
1210 {
1211 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1212 return xInfo;
1213 }
1214
1215
1216
1217 // ----------------------------------------------------
1218 // class UnoCheckBoxControl
1219 // ----------------------------------------------------
1220 UnoCheckBoxControl::UnoCheckBoxControl()
1221 :UnoCheckBoxControl_Base()
1222 ,maItemListeners( *this ), maActionListeners( *this )
1223 {
1224 maComponentInfos.nWidth = 100;
1225 maComponentInfos.nHeight = 12;
1226 }
1227
1228 OUString UnoCheckBoxControl::GetComponentServiceName()
1229 {
1230 return OUString("checkbox");
1231 }
1232
1233 void UnoCheckBoxControl::dispose() throw(uno::RuntimeException)
1234 {
1235 lang::EventObject aEvt;
1236 aEvt.Source = (::cppu::OWeakObject*)this;
1237 maItemListeners.disposeAndClear( aEvt );
1238 UnoControlBase::dispose();
1239 }
1240
1241 sal_Bool UnoCheckBoxControl::isTransparent() throw(uno::RuntimeException)
1242 {
1243 return sal_True;
1244 }
1245
1246 void UnoCheckBoxControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException)
1247 {
1248 UnoControlBase::createPeer( rxToolkit, rParentPeer );
1249
1250 uno::Reference < awt::XCheckBox > xCheckBox( getPeer(), uno::UNO_QUERY );
1251 xCheckBox->addItemListener( this );
1252
1253 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
1254 xButton->setActionCommand( maActionCommand );
1255 if ( maActionListeners.getLength() )
1256 xButton->addActionListener( &maActionListeners );
1257 }
1258
1259 void UnoCheckBoxControl::addItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
1260 {
1261 maItemListeners.addInterface( l );
1262 }
1263
1264 void UnoCheckBoxControl::removeItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
1265 {
1266 maItemListeners.removeInterface( l );
1267 }
1268
1269 void UnoCheckBoxControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
1270 {
1271 maActionListeners.addInterface( l );
1272 if( getPeer().is() && maActionListeners.getLength() == 1 )
1273 {
1274 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
1275 xButton->addActionListener( &maActionListeners );
1276 }
1277 }
1278
1279 void UnoCheckBoxControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
1280 {
1281 if( getPeer().is() && maActionListeners.getLength() == 1 )
1282 {
1283 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
1284 xButton->removeActionListener( &maActionListeners );
1285 }
1286 maActionListeners.removeInterface( l );
1287 }
1288
1289 void UnoCheckBoxControl::setActionCommand( const OUString& rCommand ) throw(uno::RuntimeException)
1290 {
1291 maActionCommand = rCommand;
1292 if ( getPeer().is() )
1293 {
1294 uno::Reference < awt::XButton > xButton( getPeer(), uno::UNO_QUERY );
1295 xButton->setActionCommand( rCommand );
1296 }
1297 }
1298
1299
1300 void UnoCheckBoxControl::setLabel( const OUString& rLabel ) throw(uno::RuntimeException)
1301 {
1302 uno::Any aAny;
1303 aAny <<= rLabel;
1304 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True );
1305 }
1306
1307 void UnoCheckBoxControl::setState( short n ) throw(uno::RuntimeException)
1308 {
1309 uno::Any aAny;
1310 aAny <<= (sal_Int16)n;
1311 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_True );
1312 }
1313
1314 short UnoCheckBoxControl::getState() throw(uno::RuntimeException)
1315 {
1316 short nState = 0;
1317 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ) );
1318 aVal >>= nState;
1319 return nState;
1320 }
1321
1322 void UnoCheckBoxControl::enableTriState( sal_Bool b ) throw(uno::RuntimeException)
1323 {
1324 uno::Any aAny;
1325 aAny <<= b;
1326 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TRISTATE ), aAny, sal_True );
1327 }
1328
1329 void UnoCheckBoxControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw(uno::RuntimeException)
1330 {
1331 uno::Any aAny;
1332 aAny <<= (sal_Int16)rEvent.Selected;
1333 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STATE ), aAny, sal_False );
1334
1335 if ( maItemListeners.getLength() )
1336 maItemListeners.itemStateChanged( rEvent );
1337 }
1338
1339 awt::Size UnoCheckBoxControl::getMinimumSize( ) throw(uno::RuntimeException)
1340 {
1341 return Impl_getMinimumSize();
1342 }
1343
1344 awt::Size UnoCheckBoxControl::getPreferredSize( ) throw(uno::RuntimeException)
1345 {
1346 return Impl_getPreferredSize();
1347 }
1348
1349 awt::Size UnoCheckBoxControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
1350 {
1351 return Impl_calcAdjustedSize( rNewSize );
1352 }
1353
1354 // ----------------------------------------------------
1355 // class UnoControlFixedHyperlinkModel
1356 // ----------------------------------------------------
1357 UnoControlFixedHyperlinkModel::UnoControlFixedHyperlinkModel( const Reference< XComponentContext >& rxContext )
1358 :UnoControlModel( rxContext )
1359 {
1360 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXFixedHyperlink );
1361 }
1362
1363 OUString UnoControlFixedHyperlinkModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
1364 {
1365 return OUString::createFromAscii( szServiceName_UnoControlFixedHyperlinkModel );
1366 }
1367
1368 uno::Any UnoControlFixedHyperlinkModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
1369 {
1370 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
1371 {
1372 uno::Any aAny;
1373 aAny <<= OUString::createFromAscii( szServiceName_UnoControlFixedHyperlink );
1374 return aAny;
1375 }
1376 else if ( nPropId == BASEPROPERTY_BORDER )
1377 {
1378 uno::Any aAny;
1379 aAny <<= (sal_Int16)0;
1380 return aAny;
1381 }
1382 else if ( nPropId == BASEPROPERTY_URL )
1383 {
1384 uno::Any aAny;
1385 aAny <<= OUString();
1386 return aAny;
1387 }
1388
1389 return UnoControlModel::ImplGetDefaultValue( nPropId );
1390 }
1391
1392 ::cppu::IPropertyArrayHelper& UnoControlFixedHyperlinkModel::getInfoHelper()
1393 {
1394 static UnoPropertyArrayHelper* pHelper = NULL;
1395 if ( !pHelper )
1396 {
1397 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
1398 pHelper = new UnoPropertyArrayHelper( aIDs );
1399 }
1400 return *pHelper;
1401 }
1402
1403 // beans::XMultiPropertySet
1404 uno::Reference< beans::XPropertySetInfo > UnoControlFixedHyperlinkModel::getPropertySetInfo( ) throw(uno::RuntimeException)
1405 {
1406 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1407 return xInfo;
1408 }
1409
1410 // ----------------------------------------------------
1411 // class UnoFixedHyperlinkControl
1412 // ----------------------------------------------------
1413 UnoFixedHyperlinkControl::UnoFixedHyperlinkControl()
1414 :UnoControlBase()
1415 ,maActionListeners( *this )
1416 {
1417 maComponentInfos.nWidth = 100;
1418 maComponentInfos.nHeight = 12;
1419 }
1420
1421 OUString UnoFixedHyperlinkControl::GetComponentServiceName()
1422 {
1423 return OUString("fixedhyperlink");
1424 }
1425
1426 // uno::XInterface
1427 uno::Any UnoFixedHyperlinkControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
1428 {
1429 uno::Any aRet = ::cppu::queryInterface( rType,
1430 (static_cast< awt::XFixedHyperlink* >(this)),
1431 (static_cast< awt::XLayoutConstrains* >(this)) );
1432 return (aRet.hasValue() ? aRet : UnoControlBase::queryAggregation( rType ));
1433 }
1434
1435 // lang::XTypeProvider
1436 IMPL_XTYPEPROVIDER_START( UnoFixedHyperlinkControl )
1437 getCppuType( ( uno::Reference< awt::XFixedHyperlink>* ) NULL ),
1438 getCppuType( ( uno::Reference< awt::XLayoutConstrains>* ) NULL ),
1439 UnoControlBase::getTypes()
1440 IMPL_XTYPEPROVIDER_END
1441
1442 sal_Bool UnoFixedHyperlinkControl::isTransparent() throw(uno::RuntimeException)
1443 {
1444 return sal_True;
1445 }
1446
1447 void UnoFixedHyperlinkControl::setText( const OUString& Text ) throw(uno::RuntimeException)
1448 {
1449 uno::Any aAny;
1450 aAny <<= Text;
1451 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True );
1452 }
1453
1454 OUString UnoFixedHyperlinkControl::getText() throw(uno::RuntimeException)
1455 {
1456 return ImplGetPropertyValue_UString( BASEPROPERTY_LABEL );
1457 }
1458
1459 void UnoFixedHyperlinkControl::setURL( const OUString& URL ) throw(::com::sun::star::uno::RuntimeException)
1460 {
1461 uno::Any aAny;
1462 aAny <<= URL;
1463 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_URL ), aAny, sal_True );
1464 }
1465
1466 OUString UnoFixedHyperlinkControl::getURL( ) throw(::com::sun::star::uno::RuntimeException)
1467 {
1468 return ImplGetPropertyValue_UString( BASEPROPERTY_URL );
1469 }
1470
1471 void UnoFixedHyperlinkControl::setAlignment( short nAlign ) throw(uno::RuntimeException)
1472 {
1473 uno::Any aAny;
1474 aAny <<= (sal_Int16)nAlign;
1475 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_ALIGN ), aAny, sal_True );
1476 }
1477
1478 short UnoFixedHyperlinkControl::getAlignment() throw(uno::RuntimeException)
1479 {
1480 short nAlign = 0;
1481 if ( mxModel.is() )
1482 {
1483 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_ALIGN ) );
1484 aVal >>= nAlign;
1485 }
1486 return nAlign;
1487 }
1488
1489 awt::Size UnoFixedHyperlinkControl::getMinimumSize( ) throw(uno::RuntimeException)
1490 {
1491 return Impl_getMinimumSize();
1492 }
1493
1494 awt::Size UnoFixedHyperlinkControl::getPreferredSize( ) throw(uno::RuntimeException)
1495 {
1496 return Impl_getPreferredSize();
1497 }
1498
1499 awt::Size UnoFixedHyperlinkControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
1500 {
1501 return Impl_calcAdjustedSize( rNewSize );
1502 }
1503
1504 void UnoFixedHyperlinkControl::dispose() throw(uno::RuntimeException)
1505 {
1506 lang::EventObject aEvt;
1507 aEvt.Source = (::cppu::OWeakObject*)this;
1508 maActionListeners.disposeAndClear( aEvt );
1509 UnoControlBase::dispose();
1510 }
1511
1512 void UnoFixedHyperlinkControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException)
1513 {
1514 UnoControlBase::createPeer( rxToolkit, rParentPeer );
1515
1516 uno::Reference < awt::XFixedHyperlink > xFixedHyperlink( getPeer(), uno::UNO_QUERY );
1517 if ( maActionListeners.getLength() )
1518 xFixedHyperlink->addActionListener( &maActionListeners );
1519 }
1520
1521 void UnoFixedHyperlinkControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
1522 {
1523 maActionListeners.addInterface( l );
1524 if( getPeer().is() && maActionListeners.getLength() == 1 )
1525 {
1526 uno::Reference < awt::XFixedHyperlink > xFixedHyperlink( getPeer(), uno::UNO_QUERY );
1527 xFixedHyperlink->addActionListener( &maActionListeners );
1528 }
1529 }
1530
1531 void UnoFixedHyperlinkControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
1532 {
1533 if( getPeer().is() && maActionListeners.getLength() == 1 )
1534 {
1535 uno::Reference < awt::XFixedHyperlink > xFixedHyperlink( getPeer(), uno::UNO_QUERY );
1536 xFixedHyperlink->removeActionListener( &maActionListeners );
1537 }
1538 maActionListeners.removeInterface( l );
1539 }
1540
1541 // ----------------------------------------------------
1542 // class UnoControlFixedTextModel
1543 // ----------------------------------------------------
1544 UnoControlFixedTextModel::UnoControlFixedTextModel( const Reference< XComponentContext >& rxContext )
1545 :UnoControlModel( rxContext )
1546 {
1547 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXFixedText );
1548 }
1549
1550 OUString UnoControlFixedTextModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
1551 {
1552 return OUString::createFromAscii( szServiceName_UnoControlFixedTextModel );
1553 }
1554
1555 uno::Any UnoControlFixedTextModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
1556 {
1557 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
1558 {
1559 uno::Any aAny;
1560 aAny <<= OUString::createFromAscii( szServiceName_UnoControlFixedText );
1561 return aAny;
1562 }
1563 else if ( nPropId == BASEPROPERTY_BORDER )
1564 {
1565 uno::Any aAny;
1566 aAny <<= (sal_Int16)0;
1567 return aAny;
1568 }
1569
1570 return UnoControlModel::ImplGetDefaultValue( nPropId );
1571 }
1572
1573 ::cppu::IPropertyArrayHelper& UnoControlFixedTextModel::getInfoHelper()
1574 {
1575 static UnoPropertyArrayHelper* pHelper = NULL;
1576 if ( !pHelper )
1577 {
1578 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
1579 pHelper = new UnoPropertyArrayHelper( aIDs );
1580 }
1581 return *pHelper;
1582 }
1583
1584 // beans::XMultiPropertySet
1585 uno::Reference< beans::XPropertySetInfo > UnoControlFixedTextModel::getPropertySetInfo( ) throw(uno::RuntimeException)
1586 {
1587 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1588 return xInfo;
1589 }
1590
1591
1592 // ----------------------------------------------------
1593 // class UnoFixedTextControl
1594 // ----------------------------------------------------
1595 UnoFixedTextControl::UnoFixedTextControl()
1596 :UnoControlBase()
1597 {
1598 maComponentInfos.nWidth = 100;
1599 maComponentInfos.nHeight = 12;
1600 }
1601
1602 OUString UnoFixedTextControl::GetComponentServiceName()
1603 {
1604 return OUString("fixedtext");
1605 }
1606
1607 // uno::XInterface
1608 uno::Any UnoFixedTextControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
1609 {
1610 uno::Any aRet = ::cppu::queryInterface( rType,
1611 (static_cast< awt::XFixedText* >(this)),
1612 (static_cast< awt::XLayoutConstrains* >(this)) );
1613 return (aRet.hasValue() ? aRet : UnoControlBase::queryAggregation( rType ));
1614 }
1615
1616 // lang::XTypeProvider
1617 IMPL_XTYPEPROVIDER_START( UnoFixedTextControl )
1618 getCppuType( ( uno::Reference< awt::XFixedText>* ) NULL ),
1619 getCppuType( ( uno::Reference< awt::XLayoutConstrains>* ) NULL ),
1620 UnoControlBase::getTypes()
1621 IMPL_XTYPEPROVIDER_END
1622
1623 sal_Bool UnoFixedTextControl::isTransparent() throw(uno::RuntimeException)
1624 {
1625 return sal_True;
1626 }
1627
1628 void UnoFixedTextControl::setText( const OUString& Text ) throw(uno::RuntimeException)
1629 {
1630 uno::Any aAny;
1631 aAny <<= Text;
1632 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LABEL ), aAny, sal_True );
1633 }
1634
1635 OUString UnoFixedTextControl::getText() throw(uno::RuntimeException)
1636 {
1637 return ImplGetPropertyValue_UString( BASEPROPERTY_LABEL );
1638 }
1639
1640 void UnoFixedTextControl::setAlignment( short nAlign ) throw(uno::RuntimeException)
1641 {
1642 uno::Any aAny;
1643 aAny <<= (sal_Int16)nAlign;
1644 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_ALIGN ), aAny, sal_True );
1645 }
1646
1647 short UnoFixedTextControl::getAlignment() throw(uno::RuntimeException)
1648 {
1649 short nAlign = 0;
1650 if ( mxModel.is() )
1651 {
1652 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_ALIGN ) );
1653 aVal >>= nAlign;
1654 }
1655 return nAlign;
1656 }
1657
1658 awt::Size UnoFixedTextControl::getMinimumSize( ) throw(uno::RuntimeException)
1659 {
1660 return Impl_getMinimumSize();
1661 }
1662
1663 awt::Size UnoFixedTextControl::getPreferredSize( ) throw(uno::RuntimeException)
1664 {
1665 return Impl_getPreferredSize();
1666 }
1667
1668 awt::Size UnoFixedTextControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
1669 {
1670 return Impl_calcAdjustedSize( rNewSize );
1671 }
1672
1673 // ----------------------------------------------------
1674 // class UnoControlGroupBoxModel
1675 // ----------------------------------------------------
1676 UnoControlGroupBoxModel::UnoControlGroupBoxModel( const Reference< XComponentContext >& rxContext )
1677 :UnoControlModel( rxContext )
1678 {
1679 ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
1680 ImplRegisterProperty( BASEPROPERTY_ENABLED );
1681 ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
1682 ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR );
1683 ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
1684 ImplRegisterProperty( BASEPROPERTY_HELPURL );
1685 ImplRegisterProperty( BASEPROPERTY_LABEL );
1686 ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
1687 ImplRegisterProperty( BASEPROPERTY_WRITING_MODE );
1688 ImplRegisterProperty( BASEPROPERTY_CONTEXT_WRITING_MODE );
1689 }
1690
1691 OUString UnoControlGroupBoxModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
1692 {
1693 return OUString::createFromAscii( szServiceName_UnoControlGroupBoxModel );
1694 }
1695
1696 uno::Any UnoControlGroupBoxModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
1697 {
1698 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
1699 {
1700 uno::Any aAny;
1701 aAny <<= OUString::createFromAscii( szServiceName_UnoControlGroupBox );
1702 return aAny;
1703 }
1704 return UnoControlModel::ImplGetDefaultValue( nPropId );
1705 }
1706
1707 ::cppu::IPropertyArrayHelper& UnoControlGroupBoxModel::getInfoHelper()
1708 {
1709 static UnoPropertyArrayHelper* pHelper = NULL;
1710 if ( !pHelper )
1711 {
1712 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
1713 pHelper = new UnoPropertyArrayHelper( aIDs );
1714 }
1715 return *pHelper;
1716 }
1717
1718 // beans::XMultiPropertySet
1719 uno::Reference< beans::XPropertySetInfo > UnoControlGroupBoxModel::getPropertySetInfo( ) throw(uno::RuntimeException)
1720 {
1721 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1722 return xInfo;
1723 }
1724
1725 // ----------------------------------------------------
1726 // class UnoGroupBoxControl
1727 // ----------------------------------------------------
1728 UnoGroupBoxControl::UnoGroupBoxControl()
1729 :UnoControlBase()
1730 {
1731 maComponentInfos.nWidth = 100;
1732 maComponentInfos.nHeight = 100;
1733 }
1734
1735 OUString UnoGroupBoxControl::GetComponentServiceName()
1736 {
1737 return OUString("groupbox");
1738 }
1739
1740 sal_Bool UnoGroupBoxControl::isTransparent() throw(uno::RuntimeException)
1741 {
1742 return sal_True;
1743 }
1744
1745 // =====================================================================================================================
1746 // = UnoControlListBoxModel_Data
1747 // =====================================================================================================================
1748 struct ListItem
1749 {
1750 OUString ItemText;
1751 OUString ItemImageURL;
1752 Any ItemData;
1753
1754 ListItem()
1755 :ItemText()
1756 ,ItemImageURL()
1757 ,ItemData()
1758 {
1759 }
1760
1761 ListItem( const OUString& i_rItemText )
1762 :ItemText( i_rItemText )
1763 ,ItemImageURL()
1764 ,ItemData()
1765 {
1766 }
1767 };
1768
1769 typedef beans::Pair< OUString, OUString > UnoListItem;
1770
1771 struct StripItemData : public ::std::unary_function< ListItem, UnoListItem >
1772 {
1773 UnoListItem operator()( const ListItem& i_rItem )
1774 {
1775 return UnoListItem( i_rItem.ItemText, i_rItem.ItemImageURL );
1776 }
1777 };
1778
1779 struct UnoControlListBoxModel_Data
1780 {
1781 UnoControlListBoxModel_Data( UnoControlListBoxModel& i_rAntiImpl )
1782 :m_bSettingLegacyProperty( false )
1783 ,m_rAntiImpl( i_rAntiImpl )
1784 ,m_aListItems()
1785 {
1786 }
1787
1788 sal_Int32 getItemCount() const { return sal_Int32( m_aListItems.size() ); }
1789
1790 const ListItem& getItem( const sal_Int32 i_nIndex ) const
1791 {
1792 if ( ( i_nIndex < 0 ) || ( i_nIndex >= sal_Int32( m_aListItems.size() ) ) )
1793 throw IndexOutOfBoundsException( OUString(), m_rAntiImpl );
1794 return m_aListItems[ i_nIndex ];
1795 }
1796
1797 ListItem& getItem( const sal_Int32 i_nIndex )
1798 {
1799 return const_cast< ListItem& >( static_cast< const UnoControlListBoxModel_Data* >( this )->getItem( i_nIndex ) );
1800 }
1801
1802 ListItem& insertItem( const sal_Int32 i_nIndex )
1803 {
1804 if ( ( i_nIndex < 0 ) || ( i_nIndex > sal_Int32( m_aListItems.size() ) ) )
1805 throw IndexOutOfBoundsException( OUString(), m_rAntiImpl );
1806 return *m_aListItems.insert( m_aListItems.begin() + i_nIndex, ListItem() );
1807 }
1808
1809 Sequence< UnoListItem > getAllItems() const
1810 {
1811 Sequence< UnoListItem > aItems( sal_Int32( m_aListItems.size() ) );
1812 ::std::transform( m_aListItems.begin(), m_aListItems.end(), aItems.getArray(), StripItemData() );
1813 return aItems;
1814 }
1815
1816 void copyItems( const UnoControlListBoxModel_Data& i_copySource )
1817 {
1818 m_aListItems = i_copySource.m_aListItems;
1819 }
1820
1821 void setAllItems( const ::std::vector< ListItem >& i_rItems )
1822 {
1823 m_aListItems = i_rItems;
1824 }
1825
1826 void removeItem( const sal_Int32 i_nIndex )
1827 {
1828 if ( ( i_nIndex < 0 ) || ( i_nIndex >= sal_Int32( m_aListItems.size() ) ) )
1829 throw IndexOutOfBoundsException( OUString(), m_rAntiImpl );
1830 m_aListItems.erase( m_aListItems.begin() + i_nIndex );
1831 }
1832
1833 void removeAllItems()
1834 {
1835 ::std::vector< ListItem > aEmpty;
1836 m_aListItems.swap( aEmpty );
1837 }
1838
1839 public:
1840 bool m_bSettingLegacyProperty;
1841
1842 private:
1843 UnoControlListBoxModel& m_rAntiImpl;
1844 ::std::vector< ListItem > m_aListItems;
1845 };
1846
1847 // =====================================================================================================================
1848 // = UnoControlListBoxModel
1849 // =====================================================================================================================
1850 // ---------------------------------------------------------------------------------------------------------------------
1851 UnoControlListBoxModel::UnoControlListBoxModel( const Reference< XComponentContext >& rxContext, ConstructorMode const i_mode )
1852 :UnoControlListBoxModel_Base( rxContext )
1853 ,m_pData( new UnoControlListBoxModel_Data( *this ) )
1854 ,m_aItemListListeners( GetMutex() )
1855 {
1856 if ( i_mode == ConstructDefault )
1857 {
1858 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXListBox );
1859 }
1860 }
1861 // ---------------------------------------------------------------------------------------------------------------------
1862 UnoControlListBoxModel::UnoControlListBoxModel( const UnoControlListBoxModel& i_rSource )
1863 :UnoControlListBoxModel_Base( i_rSource )
1864 ,m_pData( new UnoControlListBoxModel_Data( *this ) )
1865 ,m_aItemListListeners( GetMutex() )
1866 {
1867 m_pData->copyItems( *i_rSource.m_pData );
1868 }
1869 UnoControlListBoxModel::~UnoControlListBoxModel()
1870 {
1871 }
1872 IMPL_SERVICEINFO_DERIVED( UnoControlListBoxModel, UnoControlModel, szServiceName2_UnoControlListBoxModel )
1873 // ---------------------------------------------------------------------------------------------------------------------
1874 OUString UnoControlListBoxModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
1875 {
1876 return OUString::createFromAscii( szServiceName_UnoControlListBoxModel );
1877 }
1878
1879 // ---------------------------------------------------------------------------------------------------------------------
1880 uno::Any UnoControlListBoxModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
1881 {
1882 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
1883 {
1884 uno::Any aAny;
1885 aAny <<= OUString::createFromAscii( szServiceName_UnoControlListBox );
1886 return aAny;
1887 }
1888 return UnoControlModel::ImplGetDefaultValue( nPropId );
1889 }
1890
1891 // ---------------------------------------------------------------------------------------------------------------------
1892 ::cppu::IPropertyArrayHelper& UnoControlListBoxModel::getInfoHelper()
1893 {
1894 static UnoPropertyArrayHelper* pHelper = NULL;
1895 if ( !pHelper )
1896 {
1897 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
1898 pHelper = new UnoPropertyArrayHelper( aIDs );
1899 }
1900 return *pHelper;
1901 }
1902
1903 // ---------------------------------------------------------------------------------------------------------------------
1904 // beans::XMultiPropertySet
1905 uno::Reference< beans::XPropertySetInfo > UnoControlListBoxModel::getPropertySetInfo( ) throw(uno::RuntimeException)
1906 {
1907 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
1908 return xInfo;
1909 }
1910
1911 // ---------------------------------------------------------------------------------------------------------------------
1912 namespace
1913 {
1914 struct CreateListItem : public ::std::unary_function< OUString, ListItem >
1915 {
1916 ListItem operator()( const OUString& i_rItemText )
1917 {
1918 return ListItem( i_rItemText );
1919 }
1920 };
1921 }
1922
1923 // ---------------------------------------------------------------------------------------------------------------------
1924 void SAL_CALL UnoControlListBoxModel::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const uno::Any& rValue ) throw (uno::Exception)
1925 {
1926 UnoControlModel::setFastPropertyValue_NoBroadcast( nHandle, rValue );
1927
1928 if ( nHandle == BASEPROPERTY_STRINGITEMLIST )
1929 {
1930 // reset selection
1931 uno::Sequence<sal_Int16> aSeq;
1932 uno::Any aAny;
1933 aAny <<= aSeq;
1934 setDependentFastPropertyValue( BASEPROPERTY_SELECTEDITEMS, aAny );
1935
1936 if ( !m_pData->m_bSettingLegacyProperty )
1937 {
1938 // synchronize the legacy StringItemList property with our list items
1939 Sequence< OUString > aStringItemList;
1940 Any aPropValue;
1941 getFastPropertyValue( aPropValue, BASEPROPERTY_STRINGITEMLIST );
1942 OSL_VERIFY( aPropValue >>= aStringItemList );
1943
1944 ::std::vector< ListItem > aItems( aStringItemList.getLength() );
1945 ::std::transform(
1946 aStringItemList.getConstArray(),
1947 aStringItemList.getConstArray() + aStringItemList.getLength(),
1948 aItems.begin(),
1949 CreateListItem()
1950 );
1951 m_pData->setAllItems( aItems );
1952
1953 // since an XItemListListener does not have a "all items modified" or some such method,
1954 // we simulate this by notifying removal of all items, followed by insertion of all new
1955 // items
1956 lang::EventObject aEvent;
1957 aEvent.Source = *this;
1958 m_aItemListListeners.notifyEach( &XItemListListener::itemListChanged, aEvent );
1959 // TODO: OPropertySetHelper calls into this method with the mutex locked ...
1960 // which is wrong for the above notifications ...
1961 }
1962 }
1963 }
1964
1965 // ---------------------------------------------------------------------------------------------------------------------
1966 void UnoControlListBoxModel::ImplNormalizePropertySequence( const sal_Int32 _nCount, sal_Int32* _pHandles,
1967 uno::Any* _pValues, sal_Int32* _pValidHandles ) const SAL_THROW(())
1968 {
1969 // dependencies we know:
1970 // BASEPROPERTY_STRINGITEMLIST->BASEPROPERTY_SELECTEDITEMS
1971 ImplEnsureHandleOrder( _nCount, _pHandles, _pValues, BASEPROPERTY_STRINGITEMLIST, BASEPROPERTY_SELECTEDITEMS );
1972
1973 UnoControlModel::ImplNormalizePropertySequence( _nCount, _pHandles, _pValues, _pValidHandles );
1974 }
1975
1976 // ---------------------------------------------------------------------------------------------------------------------
1977 ::sal_Int32 SAL_CALL UnoControlListBoxModel::getItemCount() throw (RuntimeException)
1978 {
1979 ::osl::MutexGuard aGuard( GetMutex() );
1980 return m_pData->getItemCount();
1981 }
1982
1983 // ---------------------------------------------------------------------------------------------------------------------
1984 void SAL_CALL UnoControlListBoxModel::insertItem( ::sal_Int32 i_nPosition, const OUString& i_rItemText, const OUString& i_rItemImageURL ) throw (IndexOutOfBoundsException, RuntimeException)
1985 {
1986 ::osl::ClearableMutexGuard aGuard( GetMutex() );
1987 // SYNCHRONIZED ----->
1988 ListItem& rItem( m_pData->insertItem( i_nPosition ) );
1989 rItem.ItemText = i_rItemText;
1990 rItem.ItemImageURL = i_rItemImageURL;
1991
1992 impl_handleInsert( i_nPosition, i_rItemText, i_rItemImageURL, aGuard );
1993 // <----- SYNCHRONIZED
1994 }
1995
1996 // ---------------------------------------------------------------------------------------------------------------------
1997 void SAL_CALL UnoControlListBoxModel::insertItemText( ::sal_Int32 i_nPosition, const OUString& i_rItemText ) throw (IndexOutOfBoundsException, RuntimeException)
1998 {
1999 ::osl::ClearableMutexGuard aGuard( GetMutex() );
2000 // SYNCHRONIZED ----->
2001 ListItem& rItem( m_pData->insertItem( i_nPosition ) );
2002 rItem.ItemText = i_rItemText;
2003
2004 impl_handleInsert( i_nPosition, i_rItemText, ::boost::optional< OUString >(), aGuard );
2005 // <----- SYNCHRONIZED
2006 }
2007
2008 // ---------------------------------------------------------------------------------------------------------------------
2009 void SAL_CALL UnoControlListBoxModel::insertItemImage( ::sal_Int32 i_nPosition, const OUString& i_rItemImageURL ) throw (IndexOutOfBoundsException, RuntimeException)
2010 {
2011 ::osl::ClearableMutexGuard aGuard( GetMutex() );
2012 // SYNCHRONIZED ----->
2013 ListItem& rItem( m_pData->insertItem( i_nPosition ) );
2014 rItem.ItemImageURL = i_rItemImageURL;
2015
2016 impl_handleInsert( i_nPosition, ::boost::optional< OUString >(), i_rItemImageURL, aGuard );
2017 // <----- SYNCHRONIZED
2018 }
2019
2020 // ---------------------------------------------------------------------------------------------------------------------
2021 void SAL_CALL UnoControlListBoxModel::removeItem( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException)
2022 {
2023 ::osl::ClearableMutexGuard aGuard( GetMutex() );
2024 // SYNCHRONIZED ----->
2025 m_pData->removeItem( i_nPosition );
2026
2027 impl_handleRemove( i_nPosition, aGuard );
2028 // <----- SYNCHRONIZED
2029 }
2030
2031 // ---------------------------------------------------------------------------------------------------------------------
2032 void SAL_CALL UnoControlListBoxModel::removeAllItems( ) throw (::com::sun::star::uno::RuntimeException)
2033 {
2034 ::osl::ClearableMutexGuard aGuard( GetMutex() );
2035 // SYNCHRONIZED ----->
2036 m_pData->removeAllItems();
2037
2038 impl_handleRemove( -1, aGuard );
2039 // <----- SYNCHRONIZED
2040 }
2041
2042 // ---------------------------------------------------------------------------------------------------------------------
2043 void SAL_CALL UnoControlListBoxModel::setItemText( ::sal_Int32 i_nPosition, const OUString& i_rItemText ) throw (IndexOutOfBoundsException, RuntimeException)
2044 {
2045 ::osl::ClearableMutexGuard aGuard( GetMutex() );
2046 // SYNCHRONIZED ----->
2047 ListItem& rItem( m_pData->getItem( i_nPosition ) );
2048 rItem.ItemText = i_rItemText;
2049
2050 impl_handleModify( i_nPosition, i_rItemText, ::boost::optional< OUString >(), aGuard );
2051 // <----- SYNCHRONIZED
2052 }
2053
2054 // ---------------------------------------------------------------------------------------------------------------------
2055 void SAL_CALL UnoControlListBoxModel::setItemImage( ::sal_Int32 i_nPosition, const OUString& i_rItemImageURL ) throw (IndexOutOfBoundsException, RuntimeException)
2056 {
2057 ::osl::ClearableMutexGuard aGuard( GetMutex() );
2058 // SYNCHRONIZED ----->
2059 ListItem& rItem( m_pData->getItem( i_nPosition ) );
2060 rItem.ItemImageURL = i_rItemImageURL;
2061
2062 impl_handleModify( i_nPosition, ::boost::optional< OUString >(), i_rItemImageURL, aGuard );
2063 // <----- SYNCHRONIZED
2064 }
2065
2066 // ---------------------------------------------------------------------------------------------------------------------
2067 void SAL_CALL UnoControlListBoxModel::setItemTextAndImage( ::sal_Int32 i_nPosition, const OUString& i_rItemText, const OUString& i_rItemImageURL ) throw (IndexOutOfBoundsException, RuntimeException)
2068 {
2069 ::osl::ClearableMutexGuard aGuard( GetMutex() );
2070 // SYNCHRONIZED ----->
2071 ListItem& rItem( m_pData->getItem( i_nPosition ) );
2072 rItem.ItemText = i_rItemText;
2073 rItem.ItemImageURL = i_rItemImageURL;
2074
2075 impl_handleModify( i_nPosition, i_rItemText, i_rItemImageURL, aGuard );
2076 // <----- SYNCHRONIZED
2077 }
2078
2079 // ---------------------------------------------------------------------------------------------------------------------
2080 void SAL_CALL UnoControlListBoxModel::setItemData( ::sal_Int32 i_nPosition, const Any& i_rDataValue ) throw (IndexOutOfBoundsException, RuntimeException)
2081 {
2082 ::osl::ClearableMutexGuard aGuard( GetMutex() );
2083 ListItem& rItem( m_pData->getItem( i_nPosition ) );
2084 rItem.ItemData = i_rDataValue;
2085 }
2086
2087 // ---------------------------------------------------------------------------------------------------------------------
2088 OUString SAL_CALL UnoControlListBoxModel::getItemText( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException)
2089 {
2090 ::osl::MutexGuard aGuard( GetMutex() );
2091 const ListItem& rItem( m_pData->getItem( i_nPosition ) );
2092 return rItem.ItemText;
2093 }
2094
2095 // ---------------------------------------------------------------------------------------------------------------------
2096 OUString SAL_CALL UnoControlListBoxModel::getItemImage( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException)
2097 {
2098 ::osl::MutexGuard aGuard( GetMutex() );
2099 const ListItem& rItem( m_pData->getItem( i_nPosition ) );
2100 return rItem.ItemImageURL;
2101 }
2102
2103 // ---------------------------------------------------------------------------------------------------------------------
2104 beans::Pair< OUString, OUString > SAL_CALL UnoControlListBoxModel::getItemTextAndImage( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException)
2105 {
2106 ::osl::MutexGuard aGuard( GetMutex() );
2107 const ListItem& rItem( m_pData->getItem( i_nPosition ) );
2108 return beans::Pair< OUString, OUString >( rItem.ItemText, rItem.ItemImageURL );
2109 }
2110
2111 // ---------------------------------------------------------------------------------------------------------------------
2112 Any SAL_CALL UnoControlListBoxModel::getItemData( ::sal_Int32 i_nPosition ) throw (IndexOutOfBoundsException, RuntimeException)
2113 {
2114 ::osl::ClearableMutexGuard aGuard( GetMutex() );
2115 const ListItem& rItem( m_pData->getItem( i_nPosition ) );
2116 return rItem.ItemData;
2117 }
2118
2119 // ---------------------------------------------------------------------------------------------------------------------
2120 Sequence< beans::Pair< OUString, OUString > > SAL_CALL UnoControlListBoxModel::getAllItems( ) throw (RuntimeException)
2121 {
2122 ::osl::MutexGuard aGuard( GetMutex() );
2123 return m_pData->getAllItems();
2124 }
2125
2126 // ---------------------------------------------------------------------------------------------------------------------
2127 void SAL_CALL UnoControlListBoxModel::addItemListListener( const uno::Reference< awt::XItemListListener >& i_Listener ) throw (uno::RuntimeException)
2128 {
2129 if ( i_Listener.is() )
2130 m_aItemListListeners.addInterface( i_Listener );
2131 }
2132
2133 // ---------------------------------------------------------------------------------------------------------------------
2134 void SAL_CALL UnoControlListBoxModel::removeItemListListener( const uno::Reference< awt::XItemListListener >& i_Listener ) throw (uno::RuntimeException)
2135 {
2136 if ( i_Listener.is() )
2137 m_aItemListListeners.removeInterface( i_Listener );
2138 }
2139
2140 // ---------------------------------------------------------------------------------------------------------------------
2141 void UnoControlListBoxModel::impl_getStringItemList( ::std::vector< OUString >& o_rStringItems ) const
2142 {
2143 Sequence< OUString > aStringItemList;
2144 Any aPropValue;
2145 getFastPropertyValue( aPropValue, BASEPROPERTY_STRINGITEMLIST );
2146 OSL_VERIFY( aPropValue >>= aStringItemList );
2147
2148 o_rStringItems.resize( size_t( aStringItemList.getLength() ) );
2149 ::std::copy(
2150 aStringItemList.getConstArray(),
2151 aStringItemList.getConstArray() + aStringItemList.getLength(),
2152 o_rStringItems.begin()
2153 );
2154 }
2155
2156 // ---------------------------------------------------------------------------------------------------------------------
2157 void UnoControlListBoxModel::impl_setStringItemList_nolck( const ::std::vector< OUString >& i_rStringItems )
2158 {
2159 Sequence< OUString > aStringItems( i_rStringItems.size() );
2160 ::std::copy(
2161 i_rStringItems.begin(),
2162 i_rStringItems.end(),
2163 aStringItems.getArray()
2164 );
2165 m_pData->m_bSettingLegacyProperty = true;
2166 try
2167 {
2168 setFastPropertyValue( BASEPROPERTY_STRINGITEMLIST, uno::makeAny( aStringItems ) );
2169 }
2170 catch( const Exception& )
2171 {
2172 m_pData->m_bSettingLegacyProperty = false;
2173 throw;
2174 }
2175 m_pData->m_bSettingLegacyProperty = false;
2176 }
2177
2178 // ---------------------------------------------------------------------------------------------------------------------
2179 void UnoControlListBoxModel::impl_handleInsert( const sal_Int32 i_nItemPosition, const ::boost::optional< OUString >& i_rItemText,
2180 const ::boost::optional< OUString >& i_rItemImageURL, ::osl::ClearableMutexGuard& i_rClearBeforeNotify )
2181 {
2182 // SYNCHRONIZED ----->
2183 // sync with legacy StringItemList property
2184 ::std::vector< OUString > aStringItems;
2185 impl_getStringItemList( aStringItems );
2186 OSL_ENSURE( size_t( i_nItemPosition ) <= aStringItems.size(), "UnoControlListBoxModel::impl_handleInsert" );
2187 if ( size_t( i_nItemPosition ) <= aStringItems.size() )
2188 {
2189 const OUString sItemText( !!i_rItemText ? *i_rItemText : OUString() );
2190 aStringItems.insert( aStringItems.begin() + i_nItemPosition, sItemText );
2191 }
2192
2193 i_rClearBeforeNotify.clear();
2194 // <----- SYNCHRONIZED
2195 impl_setStringItemList_nolck( aStringItems );
2196
2197 // notify ItemListListeners
2198 impl_notifyItemListEvent_nolck( i_nItemPosition, i_rItemText, i_rItemImageURL, &XItemListListener::listItemInserted );
2199 }
2200
2201 // ---------------------------------------------------------------------------------------------------------------------
2202 void UnoControlListBoxModel::impl_handleRemove( const sal_Int32 i_nItemPosition, ::osl::ClearableMutexGuard& i_rClearBeforeNotify )
2203 {
2204 // SYNCHRONIZED ----->
2205 const bool bAllItems = ( i_nItemPosition < 0 );
2206 // sync with legacy StringItemList property
2207 ::std::vector< OUString > aStringItems;
2208 impl_getStringItemList( aStringItems );
2209 if ( !bAllItems )
2210 {
2211 OSL_ENSURE( size_t( i_nItemPosition ) < aStringItems.size(), "UnoControlListBoxModel::impl_handleRemove" );
2212 if ( size_t( i_nItemPosition ) < aStringItems.size() )
2213 {
2214 aStringItems.erase( aStringItems.begin() + i_nItemPosition );
2215 }
2216 }
2217 else
2218 {
2219 aStringItems.resize(0);
2220 }
2221
2222 i_rClearBeforeNotify.clear();
2223 // <----- SYNCHRONIZED
2224 impl_setStringItemList_nolck( aStringItems );
2225
2226 // notify ItemListListeners
2227 if ( bAllItems )
2228 {
2229 EventObject aEvent( *this );
2230 m_aItemListListeners.notifyEach( &XItemListListener::allItemsRemoved, aEvent );
2231 }
2232 else
2233 {
2234 impl_notifyItemListEvent_nolck( i_nItemPosition, ::boost::optional< OUString >(), ::boost::optional< OUString >(),
2235 &XItemListListener::listItemRemoved );
2236 }
2237 }
2238
2239 // ---------------------------------------------------------------------------------------------------------------------
2240 void UnoControlListBoxModel::impl_handleModify( const sal_Int32 i_nItemPosition, const ::boost::optional< OUString >& i_rItemText,
2241 const ::boost::optional< OUString >& i_rItemImageURL, ::osl::ClearableMutexGuard& i_rClearBeforeNotify )
2242 {
2243 // SYNCHRONIZED ----->
2244 if ( !!i_rItemText )
2245 {
2246 // sync with legacy StringItemList property
2247 ::std::vector< OUString > aStringItems;
2248 impl_getStringItemList( aStringItems );
2249 OSL_ENSURE( size_t( i_nItemPosition ) < aStringItems.size(), "UnoControlListBoxModel::impl_handleModify" );
2250 if ( size_t( i_nItemPosition ) < aStringItems.size() )
2251 {
2252 aStringItems[ i_nItemPosition] = *i_rItemText;
2253 }
2254
2255 i_rClearBeforeNotify.clear();
2256 // <----- SYNCHRONIZED
2257 impl_setStringItemList_nolck( aStringItems );
2258 }
2259 else
2260 {
2261 i_rClearBeforeNotify.clear();
2262 // <----- SYNCHRONIZED
2263 }
2264
2265 // notify ItemListListeners
2266 impl_notifyItemListEvent_nolck( i_nItemPosition, i_rItemText, i_rItemImageURL, &XItemListListener::listItemModified );
2267 }
2268
2269 // ---------------------------------------------------------------------------------------------------------------------
2270 void UnoControlListBoxModel::impl_notifyItemListEvent_nolck( const sal_Int32 i_nItemPosition, const ::boost::optional< OUString >& i_rItemText,
2271 const ::boost::optional< OUString >& i_rItemImageURL,
2272 void ( SAL_CALL XItemListListener::*NotificationMethod )( const ItemListEvent& ) )
2273 {
2274 ItemListEvent aEvent;
2275 aEvent.Source = *this;
2276 aEvent.ItemPosition = i_nItemPosition;
2277 if ( !!i_rItemText )
2278 {
2279 aEvent.ItemText.IsPresent = sal_True;
2280 aEvent.ItemText.Value = *i_rItemText;
2281 }
2282 if ( !!i_rItemImageURL )
2283 {
2284 aEvent.ItemImageURL.IsPresent = sal_True;
2285 aEvent.ItemImageURL.Value = *i_rItemImageURL;
2286 }
2287
2288 m_aItemListListeners.notifyEach( NotificationMethod, aEvent );
2289 }
2290
2291 // ----------------------------------------------------
2292 // class UnoListBoxControl
2293 // ----------------------------------------------------
2294 UnoListBoxControl::UnoListBoxControl()
2295 :UnoListBoxControl_Base()
2296 ,maActionListeners( *this )
2297 ,maItemListeners( *this )
2298 {
2299 maComponentInfos.nWidth = 100;
2300 maComponentInfos.nHeight = 12;
2301 }
2302
2303 OUString UnoListBoxControl::GetComponentServiceName()
2304 {
2305 return OUString("listbox");
2306 }
2307 IMPL_SERVICEINFO_DERIVED( UnoListBoxControl, UnoControlBase, szServiceName2_UnoControlListBox )
2308
2309 void UnoListBoxControl::dispose() throw(uno::RuntimeException)
2310 {
2311 lang::EventObject aEvt;
2312 aEvt.Source = (::cppu::OWeakObject*)this;
2313 maActionListeners.disposeAndClear( aEvt );
2314 maItemListeners.disposeAndClear( aEvt );
2315 UnoControl::dispose();
2316 }
2317
2318 void UnoListBoxControl::ImplUpdateSelectedItemsProperty()
2319 {
2320 if ( getPeer().is() )
2321 {
2322 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY );
2323 DBG_ASSERT( xListBox.is(), "XListBox?" );
2324
2325 uno::Sequence<sal_Int16> aSeq = xListBox->getSelectedItemsPos();
2326 uno::Any aAny;
2327 aAny <<= aSeq;
2328 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_SELECTEDITEMS ), aAny, sal_False );
2329 }
2330 }
2331
2332 void UnoListBoxControl::updateFromModel()
2333 {
2334 UnoControlBase::updateFromModel();
2335
2336 Reference< XItemListListener > xItemListListener( getPeer(), UNO_QUERY );
2337 ENSURE_OR_RETURN_VOID( xItemListListener.is(), "UnoListBoxControl::updateFromModel: a peer which is no ItemListListener?!" );
2338
2339 EventObject aEvent( getModel() );
2340 xItemListListener->itemListChanged( aEvent );
2341
2342 // notify the change of the SelectedItems property, again. While our base class, in updateFromModel,
2343 // already did this, our peer(s) can only legitimately set the selection after they have the string
2344 // item list, which we just notified with the itemListChanged call.
2345 const OUString sSelectedItemsPropName( GetPropertyName( BASEPROPERTY_SELECTEDITEMS ) );
2346 ImplSetPeerProperty( sSelectedItemsPropName, ImplGetPropertyValue( sSelectedItemsPropName ) );
2347 }
2348
2349 void UnoListBoxControl::ImplSetPeerProperty( const OUString& rPropName, const uno::Any& rVal )
2350 {
2351 if ( rPropName == GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) )
2352 // do not forward this to our peer. We are a XItemListListener at our model, and changes in the string item
2353 // list (which is a legacy property) will, later, arrive as changes in the ItemList. Those latter changes
2354 // will be forwarded to the peer, which will update itself accordingly.
2355 return;
2356
2357 UnoControl::ImplSetPeerProperty( rPropName, rVal );
2358 }
2359
2360 void UnoListBoxControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException)
2361 {
2362 UnoControl::createPeer( rxToolkit, rParentPeer );
2363
2364 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY );
2365 xListBox->addItemListener( this );
2366
2367 if ( maActionListeners.getLength() )
2368 xListBox->addActionListener( &maActionListeners );
2369 }
2370
2371 void UnoListBoxControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
2372 {
2373 maActionListeners.addInterface( l );
2374 if( getPeer().is() && maActionListeners.getLength() == 1 )
2375 {
2376 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY );
2377 xListBox->addActionListener( &maActionListeners );
2378 }
2379 }
2380
2381 void UnoListBoxControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
2382 {
2383 if( getPeer().is() && maActionListeners.getLength() == 1 )
2384 {
2385 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY );
2386 xListBox->removeActionListener( &maActionListeners );
2387 }
2388 maActionListeners.removeInterface( l );
2389 }
2390
2391 void UnoListBoxControl::addItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
2392 {
2393 maItemListeners.addInterface( l );
2394 }
2395
2396 void UnoListBoxControl::removeItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
2397 {
2398 maItemListeners.removeInterface( l );
2399 }
2400
2401 void UnoListBoxControl::addItem( const OUString& aItem, sal_Int16 nPos ) throw(uno::RuntimeException)
2402 {
2403 uno::Sequence< OUString> aSeq( 1 );
2404 aSeq.getArray()[0] = aItem;
2405 addItems( aSeq, nPos );
2406 }
2407
2408 void UnoListBoxControl::addItems( const uno::Sequence< OUString>& aItems, sal_Int16 nPos ) throw(uno::RuntimeException)
2409 {
2410 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
2411 uno::Sequence< OUString> aSeq;
2412 aVal >>= aSeq;
2413 sal_uInt16 nNewItems = (sal_uInt16)aItems.getLength();
2414 sal_uInt16 nOldLen = (sal_uInt16)aSeq.getLength();
2415 sal_uInt16 nNewLen = nOldLen + nNewItems;
2416
2417 uno::Sequence< OUString> aNewSeq( nNewLen );
2418 OUString* pNewData = aNewSeq.getArray();
2419 OUString* pOldData = aSeq.getArray();
2420
2421 if ( ( nPos < 0 ) || ( nPos > nOldLen ) )
2422 nPos = (sal_uInt16) nOldLen;
2423
2424 sal_uInt16 n;
2425 // Items vor der Einfuege-Position
2426 for ( n = 0; n < nPos; n++ )
2427 pNewData[n] = pOldData[n];
2428
2429 // Neue Items
2430 for ( n = 0; n < nNewItems; n++ )
2431 pNewData[nPos+n] = aItems.getConstArray()[n];
2432
2433 // Rest der alten Items
2434 for ( n = nPos; n < nOldLen; n++ )
2435 pNewData[nNewItems+n] = pOldData[n];
2436
2437 uno::Any aAny;
2438 aAny <<= aNewSeq;
2439 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ), aAny, sal_True );
2440 }
2441
2442 void UnoListBoxControl::removeItems( sal_Int16 nPos, sal_Int16 nCount ) throw(uno::RuntimeException)
2443 {
2444 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
2445 uno::Sequence< OUString> aSeq;
2446 aVal >>= aSeq;
2447 sal_uInt16 nOldLen = (sal_uInt16)aSeq.getLength();
2448 if ( nOldLen && ( nPos < nOldLen ) )
2449 {
2450 if ( nCount > ( nOldLen-nPos ) )
2451 nCount = nOldLen-nPos;
2452
2453 sal_uInt16 nNewLen = nOldLen - nCount;
2454
2455 uno::Sequence< OUString> aNewSeq( nNewLen );
2456 OUString* pNewData = aNewSeq.getArray();
2457 OUString* pOldData = aSeq.getArray();
2458
2459 sal_uInt16 n;
2460 // Items vor der Entfern-Position
2461 for ( n = 0; n < nPos; n++ )
2462 pNewData[n] = pOldData[n];
2463
2464 // Rest der Items
2465 for ( n = nPos; n < (nOldLen-nCount); n++ )
2466 pNewData[n] = pOldData[n+nCount];
2467
2468 uno::Any aAny;
2469 aAny <<= aNewSeq;
2470 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ), aAny, sal_True );
2471 }
2472 }
2473
2474 sal_Int16 UnoListBoxControl::getItemCount() throw(uno::RuntimeException)
2475 {
2476 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
2477 uno::Sequence< OUString> aSeq;
2478 aVal >>= aSeq;
2479 return (sal_Int16)aSeq.getLength();
2480 }
2481
2482 OUString UnoListBoxControl::getItem( sal_Int16 nPos ) throw(uno::RuntimeException)
2483 {
2484 OUString aItem;
2485 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
2486 uno::Sequence< OUString> aSeq;
2487 aVal >>= aSeq;
2488 if ( nPos < aSeq.getLength() )
2489 aItem = aSeq.getConstArray()[nPos];
2490 return aItem;
2491 }
2492
2493 uno::Sequence< OUString> UnoListBoxControl::getItems() throw(uno::RuntimeException)
2494 {
2495 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
2496 uno::Sequence< OUString> aSeq;
2497 aVal >>= aSeq;
2498 return aSeq;
2499 }
2500
2501 sal_Int16 UnoListBoxControl::getSelectedItemPos() throw(uno::RuntimeException)
2502 {
2503 sal_Int16 n = -1;
2504 if ( getPeer().is() )
2505 {
2506 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY );
2507 n = xListBox->getSelectedItemPos();
2508 }
2509 return n;
2510 }
2511
2512 uno::Sequence<sal_Int16> UnoListBoxControl::getSelectedItemsPos() throw(uno::RuntimeException)
2513 {
2514 uno::Sequence<sal_Int16> aSeq;
2515 if ( getPeer().is() )
2516 {
2517 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY );
2518 aSeq = xListBox->getSelectedItemsPos();
2519 }
2520 return aSeq;
2521 }
2522
2523 OUString UnoListBoxControl::getSelectedItem() throw(uno::RuntimeException)
2524 {
2525 OUString aItem;
2526 if ( getPeer().is() )
2527 {
2528 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY );
2529 aItem = xListBox->getSelectedItem();
2530 }
2531 return aItem;
2532 }
2533
2534 uno::Sequence< OUString> UnoListBoxControl::getSelectedItems() throw(uno::RuntimeException)
2535 {
2536 uno::Sequence< OUString> aSeq;
2537 if ( getPeer().is() )
2538 {
2539 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY );
2540 aSeq = xListBox->getSelectedItems();
2541 }
2542 return aSeq;
2543 }
2544
2545 void UnoListBoxControl::selectItemPos( sal_Int16 nPos, sal_Bool bSelect ) throw(uno::RuntimeException)
2546 {
2547 if ( getPeer().is() )
2548 {
2549 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY );
2550 xListBox->selectItemPos( nPos, bSelect );
2551 }
2552 ImplUpdateSelectedItemsProperty();
2553 }
2554
2555 void UnoListBoxControl::selectItemsPos( const uno::Sequence<sal_Int16>& aPositions, sal_Bool bSelect ) throw(uno::RuntimeException)
2556 {
2557 if ( getPeer().is() )
2558 {
2559 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY );
2560 xListBox->selectItemsPos( aPositions, bSelect );
2561 }
2562 ImplUpdateSelectedItemsProperty();
2563 }
2564
2565 void UnoListBoxControl::selectItem( const OUString& aItem, sal_Bool bSelect ) throw(uno::RuntimeException)
2566 {
2567 if ( getPeer().is() )
2568 {
2569 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY );
2570 xListBox->selectItem( aItem, bSelect );
2571 }
2572 ImplUpdateSelectedItemsProperty();
2573 }
2574
2575 void UnoListBoxControl::makeVisible( sal_Int16 nEntry ) throw(uno::RuntimeException)
2576 {
2577 if ( getPeer().is() )
2578 {
2579 uno::Reference < awt::XListBox > xListBox( getPeer(), uno::UNO_QUERY );
2580 xListBox->makeVisible( nEntry );
2581 }
2582 }
2583
2584 void UnoListBoxControl::setDropDownLineCount( sal_Int16 nLines ) throw(uno::RuntimeException)
2585 {
2586 uno::Any aAny;
2587 aAny <<= (sal_Int16)nLines;
2588 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LINECOUNT ), aAny, sal_True );
2589 }
2590
2591 sal_Int16 UnoListBoxControl::getDropDownLineCount() throw(uno::RuntimeException)
2592 {
2593 return ImplGetPropertyValue_INT16( BASEPROPERTY_LINECOUNT );
2594 }
2595
2596 sal_Bool UnoListBoxControl::isMutipleMode() throw(uno::RuntimeException)
2597 {
2598 return ImplGetPropertyValue_BOOL( BASEPROPERTY_MULTISELECTION );
2599 }
2600
2601 void UnoListBoxControl::setMultipleMode( sal_Bool bMulti ) throw(uno::RuntimeException)
2602 {
2603 uno::Any aAny;
2604 aAny <<= bMulti;
2605 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_MULTISELECTION ), aAny, sal_True );
2606 }
2607
2608 void UnoListBoxControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw(uno::RuntimeException)
2609 {
2610 ImplUpdateSelectedItemsProperty();
2611 if ( maItemListeners.getLength() )
2612 {
2613 try
2614 {
2615 maItemListeners.itemStateChanged( rEvent );
2616 }
2617 catch( const Exception& e )
2618 {
2619 #if OSL_DEBUG_LEVEL == 0
2620 (void) e; // suppress warning
2621 #else
2622 OString sMessage( "UnoListBoxControl::itemStateChanged: caught an exception:\n" );
2623 sMessage += OString( e.Message.getStr(), e.Message.getLength(), RTL_TEXTENCODING_ASCII_US );
2624 OSL_FAIL( sMessage.getStr() );
2625 #endif
2626 }
2627 }
2628 }
2629
2630 awt::Size UnoListBoxControl::getMinimumSize( ) throw(uno::RuntimeException)
2631 {
2632 return Impl_getMinimumSize();
2633 }
2634
2635 awt::Size UnoListBoxControl::getPreferredSize( ) throw(uno::RuntimeException)
2636 {
2637 return Impl_getPreferredSize();
2638 }
2639
2640 awt::Size UnoListBoxControl::calcAdjustedSize( const awt::Size& rNewSize ) throw(uno::RuntimeException)
2641 {
2642 return Impl_calcAdjustedSize( rNewSize );
2643 }
2644
2645 awt::Size UnoListBoxControl::getMinimumSize( sal_Int16 nCols, sal_Int16 nLines ) throw(uno::RuntimeException)
2646 {
2647 return Impl_getMinimumSize( nCols, nLines );
2648 }
2649
2650 void UnoListBoxControl::getColumnsAndLines( sal_Int16& nCols, sal_Int16& nLines ) throw(uno::RuntimeException)
2651 {
2652 Impl_getColumnsAndLines( nCols, nLines );
2653 }
2654
2655 sal_Bool SAL_CALL UnoListBoxControl::setModel( const uno::Reference< awt::XControlModel >& i_rModel ) throw ( uno::RuntimeException )
2656 {
2657 ::osl::MutexGuard aGuard( GetMutex() );
2658
2659 const Reference< XItemList > xOldItems( getModel(), UNO_QUERY );
2660 OSL_ENSURE( xOldItems.is() || !getModel().is(), "UnoListBoxControl::setModel: illegal old model!" );
2661 const Reference< XItemList > xNewItems( i_rModel, UNO_QUERY );
2662 OSL_ENSURE( xNewItems.is() || !i_rModel.is(), "UnoListBoxControl::setModel: illegal new model!" );
2663
2664 if ( !UnoListBoxControl_Base::setModel( i_rModel ) )
2665 return sal_False;
2666
2667 if ( xOldItems.is() )
2668 xOldItems->removeItemListListener( this );
2669 if ( xNewItems.is() )
2670 xNewItems->addItemListListener( this );
2671
2672 return sal_True;
2673 }
2674
2675 void SAL_CALL UnoListBoxControl::listItemInserted( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException)
2676 {
2677 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2678 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::listItemInserted: invalid peer!" );
2679 if ( xPeerListener.is() )
2680 xPeerListener->listItemInserted( i_rEvent );
2681 }
2682
2683 void SAL_CALL UnoListBoxControl::listItemRemoved( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException)
2684 {
2685 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2686 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::listItemRemoved: invalid peer!" );
2687 if ( xPeerListener.is() )
2688 xPeerListener->listItemRemoved( i_rEvent );
2689 }
2690
2691 void SAL_CALL UnoListBoxControl::listItemModified( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException)
2692 {
2693 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2694 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::listItemModified: invalid peer!" );
2695 if ( xPeerListener.is() )
2696 xPeerListener->listItemModified( i_rEvent );
2697 }
2698
2699 void SAL_CALL UnoListBoxControl::allItemsRemoved( const lang::EventObject& i_rEvent ) throw (uno::RuntimeException)
2700 {
2701 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2702 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::allItemsRemoved: invalid peer!" );
2703 if ( xPeerListener.is() )
2704 xPeerListener->allItemsRemoved( i_rEvent );
2705 }
2706
2707 void SAL_CALL UnoListBoxControl::itemListChanged( const lang::EventObject& i_rEvent ) throw (uno::RuntimeException)
2708 {
2709 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2710 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoListBoxControl::itemListChanged: invalid peer!" );
2711 if ( xPeerListener.is() )
2712 xPeerListener->itemListChanged( i_rEvent );
2713 }
2714
2715 // ----------------------------------------------------
2716 // class UnoControlComboBoxModel
2717 // ----------------------------------------------------
2718 UnoControlComboBoxModel::UnoControlComboBoxModel( const Reference< XComponentContext >& rxContext )
2719 :UnoControlListBoxModel( rxContext, ConstructWithoutProperties )
2720 {
2721 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXComboBox );
2722 }
2723
2724 IMPL_SERVICEINFO_DERIVED( UnoControlComboBoxModel, UnoControlModel, szServiceName2_UnoControlComboBoxModel )
2725
2726 uno::Reference< beans::XPropertySetInfo > UnoControlComboBoxModel::getPropertySetInfo( ) throw(uno::RuntimeException)
2727 {
2728 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
2729 return xInfo;
2730 }
2731 // ---------------------------------------------------------------------------------------------------------------------
2732 ::cppu::IPropertyArrayHelper& UnoControlComboBoxModel::getInfoHelper()
2733 {
2734 static UnoPropertyArrayHelper* pHelper = NULL;
2735 if ( !pHelper )
2736 {
2737 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
2738 pHelper = new UnoPropertyArrayHelper( aIDs );
2739 }
2740 return *pHelper;
2741 }
2742
2743
2744 OUString UnoControlComboBoxModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
2745 {
2746 return OUString::createFromAscii( szServiceName_UnoControlComboBoxModel );
2747 }
2748 void SAL_CALL UnoControlComboBoxModel::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const uno::Any& rValue ) throw (uno::Exception)
2749 {
2750 UnoControlModel::setFastPropertyValue_NoBroadcast( nHandle, rValue );
2751
2752 if ( nHandle == BASEPROPERTY_STRINGITEMLIST && !m_pData->m_bSettingLegacyProperty)
2753 {
2754 // synchronize the legacy StringItemList property with our list items
2755 Sequence< OUString > aStringItemList;
2756 Any aPropValue;
2757 getFastPropertyValue( aPropValue, BASEPROPERTY_STRINGITEMLIST );
2758 OSL_VERIFY( aPropValue >>= aStringItemList );
2759
2760 ::std::vector< ListItem > aItems( aStringItemList.getLength() );
2761 ::std::transform(
2762 aStringItemList.getConstArray(),
2763 aStringItemList.getConstArray() + aStringItemList.getLength(),
2764 aItems.begin(),
2765 CreateListItem()
2766 );
2767 m_pData->setAllItems( aItems );
2768
2769 // since an XItemListListener does not have a "all items modified" or some such method,
2770 // we simulate this by notifying removal of all items, followed by insertion of all new
2771 // items
2772 lang::EventObject aEvent;
2773 aEvent.Source = *this;
2774 m_aItemListListeners.notifyEach( &XItemListListener::itemListChanged, aEvent );
2775 // TODO: OPropertySetHelper calls into this method with the mutex locked ...
2776 // which is wrong for the above notifications ...
2777 }
2778 }
2779
2780 uno::Any UnoControlComboBoxModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
2781 {
2782 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
2783 {
2784 uno::Any aAny;
2785 aAny <<= OUString::createFromAscii( szServiceName_UnoControlComboBox );
2786 return aAny;
2787 }
2788 return UnoControlModel::ImplGetDefaultValue( nPropId );
2789 }
2790
2791 // ----------------------------------------------------
2792 // class UnoComboBoxControl
2793 // ----------------------------------------------------
2794 UnoComboBoxControl::UnoComboBoxControl()
2795 :UnoEditControl()
2796 ,maActionListeners( *this )
2797 ,maItemListeners( *this )
2798 {
2799 maComponentInfos.nWidth = 100;
2800 maComponentInfos.nHeight = 12;
2801 }
2802 IMPL_SERVICEINFO_DERIVED( UnoComboBoxControl, UnoEditControl, szServiceName2_UnoControlComboBox )
2803
2804 OUString UnoComboBoxControl::GetComponentServiceName()
2805 {
2806 return OUString("combobox");
2807 }
2808
2809 void UnoComboBoxControl::dispose() throw(uno::RuntimeException)
2810 {
2811 lang::EventObject aEvt;
2812 aEvt.Source = (::cppu::OWeakObject*)this;
2813 maActionListeners.disposeAndClear( aEvt );
2814 maItemListeners.disposeAndClear( aEvt );
2815 UnoControl::dispose();
2816 }
2817 uno::Any UnoComboBoxControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
2818 {
2819 uno::Any aRet = ::cppu::queryInterface( rType,
2820 (static_cast< awt::XComboBox* >(this)) );
2821 if ( !aRet.hasValue() )
2822 {
2823 aRet = ::cppu::queryInterface( rType,
2824 (static_cast< awt::XItemListener* >(this)) );
2825 if ( !aRet.hasValue() )
2826 {
2827 aRet = ::cppu::queryInterface( rType,
2828 (static_cast< awt::XItemListListener* >(this)) );
2829 }
2830 }
2831 return (aRet.hasValue() ? aRet : UnoEditControl::queryAggregation( rType ));
2832 }
2833 // lang::XTypeProvider
2834 IMPL_XTYPEPROVIDER_START( UnoComboBoxControl )
2835 getCppuType( ( uno::Reference< awt::XComboBox>* ) NULL ),
2836 getCppuType( ( uno::Reference< awt::XItemListener>* ) NULL ),
2837 getCppuType( ( uno::Reference< awt::XItemListListener>* ) NULL ),
2838 UnoEditControl::getTypes()
2839 IMPL_XTYPEPROVIDER_END
2840
2841 void UnoComboBoxControl::updateFromModel()
2842 {
2843 UnoEditControl::updateFromModel();
2844
2845 Reference< XItemListListener > xItemListListener( getPeer(), UNO_QUERY );
2846 ENSURE_OR_RETURN_VOID( xItemListListener.is(), "UnoComboBoxControl::updateFromModel: a peer which is no ItemListListener?!" );
2847
2848 EventObject aEvent( getModel() );
2849 xItemListListener->itemListChanged( aEvent );
2850 }
2851 void UnoComboBoxControl::ImplSetPeerProperty( const OUString& rPropName, const uno::Any& rVal )
2852 {
2853 if ( rPropName == GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) )
2854 // do not forward this to our peer. We are a XItemListListener at our model, and changes in the string item
2855 // list (which is a legacy property) will, later, arrive as changes in the ItemList. Those latter changes
2856 // will be forwarded to the peer, which will update itself accordingly.
2857 return;
2858
2859 UnoEditControl::ImplSetPeerProperty( rPropName, rVal );
2860 }
2861 void UnoComboBoxControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException)
2862 {
2863 UnoEditControl::createPeer( rxToolkit, rParentPeer );
2864
2865 uno::Reference < awt::XComboBox > xComboBox( getPeer(), uno::UNO_QUERY );
2866 if ( maActionListeners.getLength() )
2867 xComboBox->addActionListener( &maActionListeners );
2868 if ( maItemListeners.getLength() )
2869 xComboBox->addItemListener( &maItemListeners );
2870 }
2871
2872 void UnoComboBoxControl::addActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
2873 {
2874 maActionListeners.addInterface( l );
2875 if( getPeer().is() && maActionListeners.getLength() == 1 )
2876 {
2877 uno::Reference < awt::XComboBox > xComboBox( getPeer(), uno::UNO_QUERY );
2878 xComboBox->addActionListener( &maActionListeners );
2879 }
2880 }
2881
2882 void UnoComboBoxControl::removeActionListener(const uno::Reference< awt::XActionListener > & l) throw(uno::RuntimeException)
2883 {
2884 if( getPeer().is() && maActionListeners.getLength() == 1 )
2885 {
2886 uno::Reference < awt::XComboBox > xComboBox( getPeer(), uno::UNO_QUERY );
2887 xComboBox->removeActionListener( &maActionListeners );
2888 }
2889 maActionListeners.removeInterface( l );
2890 }
2891
2892 void UnoComboBoxControl::addItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
2893 {
2894 maItemListeners.addInterface( l );
2895 if( getPeer().is() && maItemListeners.getLength() == 1 )
2896 {
2897 uno::Reference < awt::XComboBox > xComboBox( getPeer(), uno::UNO_QUERY );
2898 xComboBox->addItemListener( &maItemListeners );
2899 }
2900 }
2901
2902 void UnoComboBoxControl::removeItemListener(const uno::Reference < awt::XItemListener > & l) throw(uno::RuntimeException)
2903 {
2904 if( getPeer().is() && maItemListeners.getLength() == 1 )
2905 {
2906 // This call is prettier than creating a Ref and calling query
2907 uno::Reference < awt::XComboBox > xComboBox( getPeer(), uno::UNO_QUERY );
2908 xComboBox->removeItemListener( &maItemListeners );
2909 }
2910 maItemListeners.removeInterface( l );
2911 }
2912 void UnoComboBoxControl::itemStateChanged( const awt::ItemEvent& rEvent ) throw(uno::RuntimeException)
2913 {
2914 if ( maItemListeners.getLength() )
2915 {
2916 try
2917 {
2918 maItemListeners.itemStateChanged( rEvent );
2919 }
2920 catch( const Exception& e )
2921 {
2922 #if OSL_DEBUG_LEVEL == 0
2923 (void) e; // suppress warning
2924 #else
2925 OString sMessage( "UnoComboBoxControl::itemStateChanged: caught an exception:\n" );
2926 sMessage += OString( e.Message.getStr(), e.Message.getLength(), RTL_TEXTENCODING_ASCII_US );
2927 OSL_FAIL( sMessage.getStr() );
2928 #endif
2929 }
2930 }
2931 }
2932 sal_Bool SAL_CALL UnoComboBoxControl::setModel( const uno::Reference< awt::XControlModel >& i_rModel ) throw ( uno::RuntimeException )
2933 {
2934 ::osl::MutexGuard aGuard( GetMutex() );
2935
2936 const Reference< XItemList > xOldItems( getModel(), UNO_QUERY );
2937 OSL_ENSURE( xOldItems.is() || !getModel().is(), "UnoComboBoxControl::setModel: illegal old model!" );
2938 const Reference< XItemList > xNewItems( i_rModel, UNO_QUERY );
2939 OSL_ENSURE( xNewItems.is() || !i_rModel.is(), "UnoComboBoxControl::setModel: illegal new model!" );
2940
2941 if ( !UnoEditControl::setModel( i_rModel ) )
2942 return sal_False;
2943
2944 if ( xOldItems.is() )
2945 xOldItems->removeItemListListener( this );
2946 if ( xNewItems.is() )
2947 xNewItems->addItemListListener( this );
2948
2949 return sal_True;
2950 }
2951
2952 void SAL_CALL UnoComboBoxControl::listItemInserted( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException)
2953 {
2954 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2955 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::listItemInserted: invalid peer!" );
2956 if ( xPeerListener.is() )
2957 xPeerListener->listItemInserted( i_rEvent );
2958 }
2959
2960 void SAL_CALL UnoComboBoxControl::listItemRemoved( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException)
2961 {
2962 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2963 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::listItemRemoved: invalid peer!" );
2964 if ( xPeerListener.is() )
2965 xPeerListener->listItemRemoved( i_rEvent );
2966 }
2967
2968 void SAL_CALL UnoComboBoxControl::listItemModified( const awt::ItemListEvent& i_rEvent ) throw (uno::RuntimeException)
2969 {
2970 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2971 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::listItemModified: invalid peer!" );
2972 if ( xPeerListener.is() )
2973 xPeerListener->listItemModified( i_rEvent );
2974 }
2975
2976 void SAL_CALL UnoComboBoxControl::allItemsRemoved( const lang::EventObject& i_rEvent ) throw (uno::RuntimeException)
2977 {
2978 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2979 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::allItemsRemoved: invalid peer!" );
2980 if ( xPeerListener.is() )
2981 xPeerListener->allItemsRemoved( i_rEvent );
2982 }
2983
2984 void SAL_CALL UnoComboBoxControl::itemListChanged( const lang::EventObject& i_rEvent ) throw (uno::RuntimeException)
2985 {
2986 const Reference< XItemListListener > xPeerListener( getPeer(), UNO_QUERY );
2987 OSL_ENSURE( xPeerListener.is() || !getPeer().is(), "UnoComboBoxControl::itemListChanged: invalid peer!" );
2988 if ( xPeerListener.is() )
2989 xPeerListener->itemListChanged( i_rEvent );
2990 }
2991
2992 void UnoComboBoxControl::addItem( const OUString& aItem, sal_Int16 nPos ) throw(uno::RuntimeException)
2993 {
2994 uno::Sequence< OUString> aSeq( 1 );
2995 aSeq.getArray()[0] = aItem;
2996 addItems( aSeq, nPos );
2997 }
2998
2999 void UnoComboBoxControl::addItems( const uno::Sequence< OUString>& aItems, sal_Int16 nPos ) throw(uno::RuntimeException)
3000 {
3001 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
3002 uno::Sequence< OUString> aSeq;
3003 aVal >>= aSeq;
3004 sal_uInt16 nNewItems = (sal_uInt16)aItems.getLength();
3005 sal_uInt16 nOldLen = (sal_uInt16)aSeq.getLength();
3006 sal_uInt16 nNewLen = nOldLen + nNewItems;
3007
3008 uno::Sequence< OUString> aNewSeq( nNewLen );
3009 OUString* pNewData = aNewSeq.getArray();
3010 const OUString* pOldData = aSeq.getConstArray();
3011
3012 if ( ( nPos < 0 ) || ( nPos > nOldLen ) )
3013 nPos = (sal_uInt16) nOldLen;
3014
3015 sal_uInt16 n;
3016 // items before the insert position
3017 for ( n = 0; n < nPos; n++ )
3018 pNewData[n] = pOldData[n];
3019
3020 // New items
3021 for ( n = 0; n < nNewItems; n++ )
3022 pNewData[nPos+n] = aItems.getConstArray()[n];
3023
3024 // remainder of old items
3025 for ( n = nPos; n < nOldLen; n++ )
3026 pNewData[nNewItems+n] = pOldData[n];
3027
3028 uno::Any aAny;
3029 aAny <<= aNewSeq;
3030 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ), aAny, sal_True );
3031 }
3032
3033 void UnoComboBoxControl::removeItems( sal_Int16 nPos, sal_Int16 nCount ) throw(uno::RuntimeException)
3034 {
3035 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
3036 uno::Sequence< OUString> aSeq;
3037 aVal >>= aSeq;
3038 sal_uInt16 nOldLen = (sal_uInt16)aSeq.getLength();
3039 if ( nOldLen && ( nPos < nOldLen ) )
3040 {
3041 if ( nCount > ( nOldLen-nPos ) )
3042 nCount = nOldLen-nPos;
3043
3044 sal_uInt16 nNewLen = nOldLen - nCount;
3045
3046 uno::Sequence< OUString> aNewSeq( nNewLen );
3047 OUString* pNewData = aNewSeq.getArray();
3048 OUString* pOldData = aSeq.getArray();
3049
3050 sal_uInt16 n;
3051 // items before the deletion position
3052 for ( n = 0; n < nPos; n++ )
3053 pNewData[n] = pOldData[n];
3054
3055 // remainder of old items
3056 for ( n = nPos; n < (nOldLen-nCount); n++ )
3057 pNewData[n] = pOldData[n+nCount];
3058
3059 uno::Any aAny;
3060 aAny <<= aNewSeq;
3061 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ), aAny, sal_True );
3062 }
3063 }
3064
3065 sal_Int16 UnoComboBoxControl::getItemCount() throw(uno::RuntimeException)
3066 {
3067 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
3068 uno::Sequence< OUString> aSeq;
3069 aVal >>= aSeq;
3070 return (sal_Int16)aSeq.getLength();
3071 }
3072
3073 OUString UnoComboBoxControl::getItem( sal_Int16 nPos ) throw(uno::RuntimeException)
3074 {
3075 OUString aItem;
3076 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
3077 uno::Sequence< OUString> aSeq;
3078 aVal >>= aSeq;
3079 if ( nPos < aSeq.getLength() )
3080 aItem = aSeq.getConstArray()[nPos];
3081 return aItem;
3082 }
3083
3084 uno::Sequence< OUString> UnoComboBoxControl::getItems() throw(uno::RuntimeException)
3085 {
3086 uno::Any aVal = ImplGetPropertyValue( GetPropertyName( BASEPROPERTY_STRINGITEMLIST ) );
3087 uno::Sequence< OUString> aSeq;
3088 aVal >>= aSeq;
3089 return aSeq;
3090 }
3091
3092 void UnoComboBoxControl::setDropDownLineCount( sal_Int16 nLines ) throw(uno::RuntimeException)
3093 {
3094 uno::Any aAny;
3095 aAny <<= nLines;
3096 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LINECOUNT ), aAny, sal_True );
3097 }
3098
3099 sal_Int16 UnoComboBoxControl::getDropDownLineCount() throw(uno::RuntimeException)
3100 {
3101 return ImplGetPropertyValue_INT16( BASEPROPERTY_LINECOUNT );
3102 }
3103
3104
3105 // ----------------------------------------------------
3106 // UnoSpinFieldControl
3107 // ----------------------------------------------------
3108 UnoSpinFieldControl::UnoSpinFieldControl()
3109 :UnoEditControl()
3110 ,maSpinListeners( *this )
3111 {
3112 mbRepeat = sal_False;
3113 }
3114
3115 // uno::XInterface
3116 uno::Any UnoSpinFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
3117 {
3118 uno::Any aRet = ::cppu::queryInterface( rType,
3119 (static_cast< awt::XSpinField* >(this)) );
3120 return (aRet.hasValue() ? aRet : UnoEditControl::queryAggregation( rType ));
3121 }
3122
3123 // lang::XTypeProvider
3124 IMPL_XTYPEPROVIDER_START( UnoSpinFieldControl )
3125 getCppuType( ( uno::Reference< awt::XSpinField>* ) NULL ),
3126 UnoEditControl::getTypes()
3127 IMPL_XTYPEPROVIDER_END
3128
3129 void UnoSpinFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException)
3130 {
3131 UnoEditControl::createPeer( rxToolkit, rParentPeer );
3132
3133 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3134 xField->enableRepeat( mbRepeat );
3135 if ( maSpinListeners.getLength() )
3136 xField->addSpinListener( &maSpinListeners );
3137 }
3138
3139 // ::com::sun::star::awt::XSpinField
3140 void UnoSpinFieldControl::addSpinListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XSpinListener >& l ) throw(::com::sun::star::uno::RuntimeException)
3141 {
3142 maSpinListeners.addInterface( l );
3143 if( getPeer().is() && maSpinListeners.getLength() == 1 )
3144 {
3145 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3146 xField->addSpinListener( &maSpinListeners );
3147 }
3148 }
3149
3150 void UnoSpinFieldControl::removeSpinListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XSpinListener >& l ) throw(::com::sun::star::uno::RuntimeException)
3151 {
3152 if( getPeer().is() && maSpinListeners.getLength() == 1 )
3153 {
3154 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3155 xField->removeSpinListener( &maSpinListeners );
3156 }
3157 maSpinListeners.removeInterface( l );
3158 }
3159
3160 void UnoSpinFieldControl::up() throw(::com::sun::star::uno::RuntimeException)
3161 {
3162 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3163 if ( xField.is() )
3164 xField->up();
3165 }
3166
3167 void UnoSpinFieldControl::down() throw(::com::sun::star::uno::RuntimeException)
3168 {
3169 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3170 if ( xField.is() )
3171 xField->down();
3172 }
3173
3174 void UnoSpinFieldControl::first() throw(::com::sun::star::uno::RuntimeException)
3175 {
3176 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3177 if ( xField.is() )
3178 xField->first();
3179 }
3180
3181 void UnoSpinFieldControl::last() throw(::com::sun::star::uno::RuntimeException)
3182 {
3183 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3184 if ( xField.is() )
3185 xField->last();
3186 }
3187
3188 void UnoSpinFieldControl::enableRepeat( sal_Bool bRepeat ) throw(::com::sun::star::uno::RuntimeException)
3189 {
3190 mbRepeat = bRepeat;
3191
3192 uno::Reference < awt::XSpinField > xField( getPeer(), uno::UNO_QUERY );
3193 if ( xField.is() )
3194 xField->enableRepeat( bRepeat );
3195 }
3196
3197 // ----------------------------------------------------
3198 // class UnoControlDateFieldModel
3199 // ----------------------------------------------------
3200 UnoControlDateFieldModel::UnoControlDateFieldModel( const Reference< XComponentContext >& rxContext )
3201 :UnoControlModel( rxContext )
3202 {
3203 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXDateField );
3204 }
3205
3206 OUString UnoControlDateFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
3207 {
3208 return OUString::createFromAscii( szServiceName_UnoControlDateFieldModel );
3209 }
3210
3211 uno::Any UnoControlDateFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
3212 {
3213 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
3214 {
3215 uno::Any aAny;
3216 aAny <<= OUString::createFromAscii( szServiceName_UnoControlDateField );
3217 return aAny;
3218 }
3219 return UnoControlModel::ImplGetDefaultValue( nPropId );
3220 }
3221
3222
3223 ::cppu::IPropertyArrayHelper& UnoControlDateFieldModel::getInfoHelper()
3224 {
3225 static UnoPropertyArrayHelper* pHelper = NULL;
3226 if ( !pHelper )
3227 {
3228 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
3229 pHelper = new UnoPropertyArrayHelper( aIDs );
3230 }
3231 return *pHelper;
3232 }
3233
3234 // beans::XMultiPropertySet
3235 uno::Reference< beans::XPropertySetInfo > UnoControlDateFieldModel::getPropertySetInfo( ) throw(uno::RuntimeException)
3236 {
3237 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
3238 return xInfo;
3239 }
3240
3241
3242
3243 // ----------------------------------------------------
3244 // class UnoDateFieldControl
3245 // ----------------------------------------------------
3246 UnoDateFieldControl::UnoDateFieldControl()
3247 :UnoSpinFieldControl()
3248 {
3249 mnFirst = util::Date( 1, 1, 1900 );
3250 mnLast = util::Date( 31, 12, 2200 );
3251 mbLongFormat = 2;
3252 }
3253
3254 OUString UnoDateFieldControl::GetComponentServiceName()
3255 {
3256 return OUString("datefield");
3257 }
3258
3259 // uno::XInterface
3260 uno::Any UnoDateFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
3261 {
3262 uno::Any aRet = ::cppu::queryInterface( rType,
3263 (static_cast< awt::XDateField* >(this)) );
3264 return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType ));
3265 }
3266
3267 // lang::XTypeProvider
3268 IMPL_XTYPEPROVIDER_START( UnoDateFieldControl )
3269 getCppuType( ( uno::Reference< awt::XDateField>* ) NULL ),
3270 UnoSpinFieldControl::getTypes()
3271 IMPL_XTYPEPROVIDER_END
3272
3273 void UnoDateFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException)
3274 {
3275 UnoSpinFieldControl::createPeer( rxToolkit, rParentPeer );
3276
3277 uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY );
3278 xField->setFirst( mnFirst );
3279 xField->setLast( mnLast );
3280 if ( mbLongFormat != 2 ) // not set
3281 xField->setLongFormat( mbLongFormat );
3282 }
3283
3284
3285 void UnoDateFieldControl::textChanged( const awt::TextEvent& e ) throw(uno::RuntimeException)
3286 {
3287 uno::Reference< awt::XVclWindowPeer > xPeer( getPeer(), uno::UNO_QUERY );
3288
3289 // also change the text property (#i25106#)
3290 if ( xPeer.is() )
3291 {
3292 OUString sTextPropertyName = GetPropertyName( BASEPROPERTY_TEXT );
3293 ImplSetPropertyValue( sTextPropertyName, xPeer->getProperty( sTextPropertyName ), sal_False );
3294 }
3295
3296 // re-calc the Date property
3297 uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY );
3298 uno::Any aValue;
3299 if ( xField->isEmpty() )
3300 {
3301 // the field says it's empty
3302 sal_Bool bEnforceFormat = sal_True;
3303 if ( xPeer.is() )
3304 xPeer->getProperty( GetPropertyName( BASEPROPERTY_ENFORCE_FORMAT ) ) >>= bEnforceFormat;
3305 if ( !bEnforceFormat )
3306 {
3307 // and it also says that it is currently accepting invalid inputs, without
3308 // forcing it to a valid date
3309 uno::Reference< awt::XTextComponent > xText( xPeer, uno::UNO_QUERY );
3310 if ( xText.is() && xText->getText().getLength() )
3311 // and in real, the text of the peer is *not* empty
3312 // -> simulate an invalid date, which is different from "no date"
3313 aValue <<= util::Date();
3314 }
3315 }
3316 else
3317 aValue <<= xField->getDate();
3318
3319 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DATE ), aValue, sal_False );
3320
3321 // multiplex the event
3322 if ( GetTextListeners().getLength() )
3323 GetTextListeners().textChanged( e );
3324 }
3325
3326 void UnoDateFieldControl::setDate( const util::Date& Date ) throw(uno::RuntimeException)
3327 {
3328 uno::Any aAny;
3329 aAny <<= Date;
3330 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DATE ), aAny, sal_True );
3331 }
3332
3333 util::Date UnoDateFieldControl::getDate() throw(uno::RuntimeException)
3334 {
3335 return ImplGetPropertyValue_Date( BASEPROPERTY_DATE );
3336 }
3337
3338 void UnoDateFieldControl::setMin( const util::Date& Date ) throw(uno::RuntimeException)
3339 {
3340 uno::Any aAny;
3341 aAny <<= Date;
3342 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DATEMIN ), aAny, sal_True );
3343 }
3344
3345 util::Date UnoDateFieldControl::getMin() throw(uno::RuntimeException)
3346 {
3347 return ImplGetPropertyValue_Date( BASEPROPERTY_DATEMIN );
3348 }
3349
3350 void UnoDateFieldControl::setMax( const util::Date& Date ) throw(uno::RuntimeException)
3351 {
3352 uno::Any aAny;
3353 aAny <<= Date;
3354 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DATEMAX ), aAny, sal_True );
3355 }
3356
3357 util::Date UnoDateFieldControl::getMax() throw(uno::RuntimeException)
3358 {
3359 return ImplGetPropertyValue_Date( BASEPROPERTY_DATEMAX );
3360 }
3361
3362 void UnoDateFieldControl::setFirst( const util::Date& Date ) throw(uno::RuntimeException)
3363 {
3364 mnFirst = Date;
3365 if ( getPeer().is() )
3366 {
3367 uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY );
3368 xField->setFirst( Date );
3369 }
3370 }
3371
3372 util::Date UnoDateFieldControl::getFirst() throw(uno::RuntimeException)
3373 {
3374 return mnFirst;
3375 }
3376
3377 void UnoDateFieldControl::setLast( const util::Date& Date ) throw(uno::RuntimeException)
3378 {
3379 mnLast = Date;
3380 if ( getPeer().is() )
3381 {
3382 uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY );
3383 xField->setLast( Date );
3384 }
3385 }
3386
3387 util::Date UnoDateFieldControl::getLast() throw(uno::RuntimeException)
3388 {
3389 return mnLast;
3390 }
3391
3392 void UnoDateFieldControl::setLongFormat( sal_Bool bLong ) throw(uno::RuntimeException)
3393 {
3394 mbLongFormat = bLong;
3395 if ( getPeer().is() )
3396 {
3397 uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY );
3398 xField->setLongFormat( bLong );
3399 }
3400 }
3401
3402 sal_Bool UnoDateFieldControl::isLongFormat() throw(uno::RuntimeException)
3403 {
3404 return ( mbLongFormat != 2 ) ? mbLongFormat : sal_False;
3405 }
3406
3407 void UnoDateFieldControl::setEmpty() throw(uno::RuntimeException)
3408 {
3409 if ( getPeer().is() )
3410 {
3411 uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY );
3412 xField->setEmpty();
3413 }
3414 }
3415
3416 sal_Bool UnoDateFieldControl::isEmpty() throw(uno::RuntimeException)
3417 {
3418 sal_Bool bEmpty = sal_False;
3419 if ( getPeer().is() )
3420 {
3421 uno::Reference < awt::XDateField > xField( getPeer(), uno::UNO_QUERY );
3422 bEmpty = xField->isEmpty();
3423 }
3424 return bEmpty;
3425 }
3426
3427 void UnoDateFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException)
3428 {
3429 uno::Any aAny;
3430 aAny <<= bStrict;
3431 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True );
3432 }
3433
3434 sal_Bool UnoDateFieldControl::isStrictFormat() throw(uno::RuntimeException)
3435 {
3436 return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT );
3437 }
3438
3439 // ----------------------------------------------------
3440 // class UnoControlTimeFieldModel
3441 // ----------------------------------------------------
3442 UnoControlTimeFieldModel::UnoControlTimeFieldModel( const Reference< XComponentContext >& rxContext )
3443 :UnoControlModel( rxContext )
3444 {
3445 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXTimeField );
3446 }
3447
3448 OUString UnoControlTimeFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
3449 {
3450 return OUString::createFromAscii( szServiceName_UnoControlTimeFieldModel );
3451 }
3452
3453 uno::Any UnoControlTimeFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
3454 {
3455 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
3456 {
3457 uno::Any aAny;
3458 aAny <<= OUString::createFromAscii( szServiceName_UnoControlTimeField );
3459 return aAny;
3460 }
3461 return UnoControlModel::ImplGetDefaultValue( nPropId );
3462 }
3463
3464
3465 ::cppu::IPropertyArrayHelper& UnoControlTimeFieldModel::getInfoHelper()
3466 {
3467 static UnoPropertyArrayHelper* pHelper = NULL;
3468 if ( !pHelper )
3469 {
3470 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
3471 pHelper = new UnoPropertyArrayHelper( aIDs );
3472 }
3473 return *pHelper;
3474 }
3475
3476 // beans::XMultiPropertySet
3477 uno::Reference< beans::XPropertySetInfo > UnoControlTimeFieldModel::getPropertySetInfo( ) throw(uno::RuntimeException)
3478 {
3479 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
3480 return xInfo;
3481 }
3482
3483
3484
3485 // ----------------------------------------------------
3486 // class UnoTimeFieldControl
3487 // ----------------------------------------------------
3488 UnoTimeFieldControl::UnoTimeFieldControl()
3489 :UnoSpinFieldControl()
3490 {
3491 mnFirst = util::Time( 0, 0, 0, 0, false );
3492 mnLast = util::Time( 999999999, 59, 59, 23, false );
3493 }
3494
3495 OUString UnoTimeFieldControl::GetComponentServiceName()
3496 {
3497 return OUString("timefield");
3498 }
3499
3500 // uno::XInterface
3501 uno::Any UnoTimeFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
3502 {
3503 uno::Any aRet = ::cppu::queryInterface( rType,
3504 (static_cast< awt::XTimeField* >(this)) );
3505 return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType ));
3506 }
3507
3508 // lang::XTypeProvider
3509 IMPL_XTYPEPROVIDER_START( UnoTimeFieldControl )
3510 getCppuType( ( uno::Reference< awt::XTimeField>* ) NULL ),
3511 UnoSpinFieldControl::getTypes()
3512 IMPL_XTYPEPROVIDER_END
3513
3514 void UnoTimeFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException)
3515 {
3516 UnoSpinFieldControl::createPeer( rxToolkit, rParentPeer );
3517
3518 uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY );
3519 xField->setFirst( mnFirst );
3520 xField->setLast( mnLast );
3521 }
3522
3523 void UnoTimeFieldControl::textChanged( const awt::TextEvent& e ) throw(uno::RuntimeException)
3524 {
3525 // also change the text property (#i25106#)
3526 uno::Reference< awt::XVclWindowPeer > xPeer( getPeer(), uno::UNO_QUERY );
3527 OUString sTextPropertyName = GetPropertyName( BASEPROPERTY_TEXT );
3528 ImplSetPropertyValue( sTextPropertyName, xPeer->getProperty( sTextPropertyName ), sal_False );
3529
3530 // re-calc the Time property
3531 uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY );
3532 uno::Any aValue;
3533 if ( !xField->isEmpty() )
3534 aValue <<= xField->getTime();
3535 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TIME ), aValue, sal_False );
3536
3537 // multiplex the event
3538 if ( GetTextListeners().getLength() )
3539 GetTextListeners().textChanged( e );
3540 }
3541
3542 void UnoTimeFieldControl::setTime( const util::Time& Time ) throw(uno::RuntimeException)
3543 {
3544 uno::Any aAny;
3545 aAny <<= Time;
3546 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TIME ), aAny, sal_True );
3547 }
3548
3549 util::Time UnoTimeFieldControl::getTime() throw(uno::RuntimeException)
3550 {
3551 return ImplGetPropertyValue_Time( BASEPROPERTY_TIME );
3552 }
3553
3554 void UnoTimeFieldControl::setMin( const util::Time& Time ) throw(uno::RuntimeException)
3555 {
3556 uno::Any aAny;
3557 aAny <<= Time;
3558 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TIMEMIN ), aAny, sal_True );
3559 }
3560
3561 util::Time UnoTimeFieldControl::getMin() throw(uno::RuntimeException)
3562 {
3563 return ImplGetPropertyValue_Time( BASEPROPERTY_TIMEMIN );
3564 }
3565
3566 void UnoTimeFieldControl::setMax( const util::Time& Time ) throw(uno::RuntimeException)
3567 {
3568 uno::Any aAny;
3569 aAny <<= Time;
3570 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_TIMEMAX ), aAny, sal_True );
3571 }
3572
3573 util::Time UnoTimeFieldControl::getMax() throw(uno::RuntimeException)
3574 {
3575 return ImplGetPropertyValue_Time( BASEPROPERTY_TIMEMAX );
3576 }
3577
3578 void UnoTimeFieldControl::setFirst( const util::Time& Time ) throw(uno::RuntimeException)
3579 {
3580 mnFirst = Time;
3581 if ( getPeer().is() )
3582 {
3583 uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY );
3584 xField->setFirst( mnFirst );
3585 }
3586 }
3587
3588 util::Time UnoTimeFieldControl::getFirst() throw(uno::RuntimeException)
3589 {
3590 return mnFirst;
3591 }
3592
3593 void UnoTimeFieldControl::setLast( const util::Time& Time ) throw(uno::RuntimeException)
3594 {
3595 mnLast = Time;
3596 if ( getPeer().is() )
3597 {
3598 uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY );
3599 xField->setFirst( mnLast );
3600 }
3601 }
3602
3603 util::Time UnoTimeFieldControl::getLast() throw(uno::RuntimeException)
3604 {
3605 return mnLast;
3606 }
3607
3608 void UnoTimeFieldControl::setEmpty() throw(uno::RuntimeException)
3609 {
3610 if ( getPeer().is() )
3611 {
3612 uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY );
3613 xField->setEmpty();
3614 }
3615 }
3616
3617 sal_Bool UnoTimeFieldControl::isEmpty() throw(uno::RuntimeException)
3618 {
3619 sal_Bool bEmpty = sal_False;
3620 if ( getPeer().is() )
3621 {
3622 uno::Reference < awt::XTimeField > xField( getPeer(), uno::UNO_QUERY );
3623 bEmpty = xField->isEmpty();
3624 }
3625 return bEmpty;
3626 }
3627
3628 void UnoTimeFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException)
3629 {
3630 uno::Any aAny;
3631 aAny <<= bStrict;
3632 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True );
3633 }
3634
3635 sal_Bool UnoTimeFieldControl::isStrictFormat() throw(uno::RuntimeException)
3636 {
3637 return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT );
3638 }
3639
3640 // ----------------------------------------------------
3641 // class UnoControlNumericFieldModel
3642 // ----------------------------------------------------
3643 UnoControlNumericFieldModel::UnoControlNumericFieldModel( const Reference< XComponentContext >& rxContext )
3644 :UnoControlModel( rxContext )
3645 {
3646 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXNumericField );
3647 }
3648
3649 OUString UnoControlNumericFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
3650 {
3651 return OUString::createFromAscii( szServiceName_UnoControlNumericFieldModel );
3652 }
3653
3654 uno::Any UnoControlNumericFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
3655 {
3656 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
3657 {
3658 uno::Any aAny;
3659 aAny <<= OUString::createFromAscii( szServiceName_UnoControlNumericField );
3660 return aAny;
3661 }
3662 return UnoControlModel::ImplGetDefaultValue( nPropId );
3663 }
3664
3665
3666 ::cppu::IPropertyArrayHelper& UnoControlNumericFieldModel::getInfoHelper()
3667 {
3668 static UnoPropertyArrayHelper* pHelper = NULL;
3669 if ( !pHelper )
3670 {
3671 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
3672 pHelper = new UnoPropertyArrayHelper( aIDs );
3673 }
3674 return *pHelper;
3675 }
3676
3677 // beans::XMultiPropertySet
3678 uno::Reference< beans::XPropertySetInfo > UnoControlNumericFieldModel::getPropertySetInfo( ) throw(uno::RuntimeException)
3679 {
3680 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
3681 return xInfo;
3682 }
3683
3684
3685
3686 // ----------------------------------------------------
3687 // class UnoNumericFieldControl
3688 // ----------------------------------------------------
3689 UnoNumericFieldControl::UnoNumericFieldControl()
3690 :UnoSpinFieldControl()
3691 {
3692 mnFirst = 0;
3693 mnLast = 0x7FFFFFFF;
3694 }
3695
3696 OUString UnoNumericFieldControl::GetComponentServiceName()
3697 {
3698 return OUString("numericfield");
3699 }
3700
3701 // uno::XInterface
3702 uno::Any UnoNumericFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
3703 {
3704 uno::Any aRet = ::cppu::queryInterface( rType,
3705 (static_cast< awt::XNumericField* >(this)) );
3706 return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType ));
3707 }
3708
3709 // lang::XTypeProvider
3710 IMPL_XTYPEPROVIDER_START( UnoNumericFieldControl )
3711 getCppuType( ( uno::Reference< awt::XNumericField>* ) NULL ),
3712 UnoSpinFieldControl::getTypes()
3713 IMPL_XTYPEPROVIDER_END
3714
3715 void UnoNumericFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException)
3716 {
3717 UnoSpinFieldControl::createPeer( rxToolkit, rParentPeer );
3718
3719 uno::Reference < awt::XNumericField > xField( getPeer(), uno::UNO_QUERY );
3720 xField->setFirst( mnFirst );
3721 xField->setLast( mnLast );
3722 }
3723
3724
3725 void UnoNumericFieldControl::textChanged( const awt::TextEvent& e ) throw(uno::RuntimeException)
3726 {
3727 uno::Reference < awt::XNumericField > xField( getPeer(), uno::UNO_QUERY );
3728 uno::Any aAny;
3729 aAny <<= xField->getValue();
3730 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUE_DOUBLE ), aAny, sal_False );
3731
3732 if ( GetTextListeners().getLength() )
3733 GetTextListeners().textChanged( e );
3734 }
3735
3736 void UnoNumericFieldControl::setValue( double Value ) throw(uno::RuntimeException)
3737 {
3738 uno::Any aAny;
3739 aAny <<= Value;
3740 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUE_DOUBLE ), aAny, sal_True );
3741 }
3742
3743 double UnoNumericFieldControl::getValue() throw(uno::RuntimeException)
3744 {
3745 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUE_DOUBLE );
3746 }
3747
3748 void UnoNumericFieldControl::setMin( double Value ) throw(uno::RuntimeException)
3749 {
3750 uno::Any aAny;
3751 aAny <<= Value;
3752 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUEMIN_DOUBLE ), aAny, sal_True );
3753 }
3754
3755 double UnoNumericFieldControl::getMin() throw(uno::RuntimeException)
3756 {
3757 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUEMIN_DOUBLE );
3758 }
3759
3760 void UnoNumericFieldControl::setMax( double Value ) throw(uno::RuntimeException)
3761 {
3762 uno::Any aAny;
3763 aAny <<= Value;
3764 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUEMAX_DOUBLE ), aAny, sal_True );
3765 }
3766
3767 double UnoNumericFieldControl::getMax() throw(uno::RuntimeException)
3768 {
3769 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUEMAX_DOUBLE );
3770 }
3771
3772 void UnoNumericFieldControl::setFirst( double Value ) throw(uno::RuntimeException)
3773 {
3774 mnFirst = Value;
3775 if ( getPeer().is() )
3776 {
3777 uno::Reference < awt::XNumericField > xField( getPeer(), uno::UNO_QUERY );
3778 xField->setFirst( mnFirst );
3779 }
3780 }
3781
3782 double UnoNumericFieldControl::getFirst() throw(uno::RuntimeException)
3783 {
3784 return mnFirst;
3785 }
3786
3787 void UnoNumericFieldControl::setLast( double Value ) throw(uno::RuntimeException)
3788 {
3789 mnLast = Value;
3790 if ( getPeer().is() )
3791 {
3792 uno::Reference < awt::XNumericField > xField( getPeer(), uno::UNO_QUERY );
3793 xField->setLast( mnLast );
3794 }
3795 }
3796
3797 double UnoNumericFieldControl::getLast() throw(uno::RuntimeException)
3798 {
3799 return mnLast;
3800 }
3801
3802 void UnoNumericFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException)
3803 {
3804 uno::Any aAny;
3805 aAny <<= bStrict;
3806 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True );
3807 }
3808
3809 sal_Bool UnoNumericFieldControl::isStrictFormat() throw(uno::RuntimeException)
3810 {
3811 return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT );
3812 }
3813
3814 void UnoNumericFieldControl::setSpinSize( double Digits ) throw(uno::RuntimeException)
3815 {
3816 uno::Any aAny;
3817 aAny <<= Digits;
3818 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUESTEP_DOUBLE ), aAny, sal_True );
3819 }
3820
3821 double UnoNumericFieldControl::getSpinSize() throw(uno::RuntimeException)
3822 {
3823 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUESTEP_DOUBLE );
3824 }
3825
3826 void UnoNumericFieldControl::setDecimalDigits( sal_Int16 Digits ) throw(uno::RuntimeException)
3827 {
3828 uno::Any aAny;
3829 aAny <<= Digits;
3830 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DECIMALACCURACY ), aAny, sal_True );
3831 }
3832
3833 sal_Int16 UnoNumericFieldControl::getDecimalDigits() throw(uno::RuntimeException)
3834 {
3835 return ImplGetPropertyValue_INT16( BASEPROPERTY_DECIMALACCURACY );
3836 }
3837
3838 // ----------------------------------------------------
3839 // class UnoControlCurrencyFieldModel
3840 // ----------------------------------------------------
3841 UnoControlCurrencyFieldModel::UnoControlCurrencyFieldModel( const Reference< XComponentContext >& rxContext )
3842 :UnoControlModel( rxContext )
3843 {
3844 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXCurrencyField );
3845 }
3846
3847 OUString UnoControlCurrencyFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
3848 {
3849 return OUString::createFromAscii( szServiceName_UnoControlCurrencyFieldModel );
3850 }
3851
3852 uno::Any UnoControlCurrencyFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
3853 {
3854 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
3855 {
3856 uno::Any aAny;
3857 aAny <<= OUString::createFromAscii( szServiceName_UnoControlCurrencyField );
3858 return aAny;
3859 }
3860 if ( nPropId == BASEPROPERTY_CURSYM_POSITION )
3861 {
3862 uno::Any aAny;
3863 aAny <<= (sal_Bool)sal_False;
3864 return aAny;
3865 }
3866
3867 return UnoControlModel::ImplGetDefaultValue( nPropId );
3868 }
3869
3870 ::cppu::IPropertyArrayHelper& UnoControlCurrencyFieldModel::getInfoHelper()
3871 {
3872 static UnoPropertyArrayHelper* pHelper = NULL;
3873 if ( !pHelper )
3874 {
3875 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
3876 pHelper = new UnoPropertyArrayHelper( aIDs );
3877 }
3878 return *pHelper;
3879 }
3880
3881 // beans::XMultiPropertySet
3882 uno::Reference< beans::XPropertySetInfo > UnoControlCurrencyFieldModel::getPropertySetInfo( ) throw(uno::RuntimeException)
3883 {
3884 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
3885 return xInfo;
3886 }
3887
3888 // ----------------------------------------------------
3889 // class UnoCurrencyFieldControl
3890 // ----------------------------------------------------
3891 UnoCurrencyFieldControl::UnoCurrencyFieldControl()
3892 :UnoSpinFieldControl()
3893 {
3894 mnFirst = 0;
3895 mnLast = 0x7FFFFFFF;
3896 }
3897
3898 OUString UnoCurrencyFieldControl::GetComponentServiceName()
3899 {
3900 return OUString("longcurrencyfield");
3901 }
3902
3903 // uno::XInterface
3904 uno::Any UnoCurrencyFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
3905 {
3906 uno::Any aRet = ::cppu::queryInterface( rType,
3907 (static_cast< awt::XCurrencyField* >(this)) );
3908 return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType ));
3909 }
3910
3911 // lang::XTypeProvider
3912 IMPL_XTYPEPROVIDER_START( UnoCurrencyFieldControl )
3913 getCppuType( ( uno::Reference< awt::XCurrencyField>* ) NULL ),
3914 UnoSpinFieldControl::getTypes()
3915 IMPL_XTYPEPROVIDER_END
3916
3917 void UnoCurrencyFieldControl::createPeer( const uno::Reference< awt::XToolkit > & rxToolkit, const uno::Reference< awt::XWindowPeer > & rParentPeer ) throw(uno::RuntimeException)
3918 {
3919 UnoSpinFieldControl::createPeer( rxToolkit, rParentPeer );
3920
3921 uno::Reference < awt::XCurrencyField > xField( getPeer(), uno::UNO_QUERY );
3922 xField->setFirst( mnFirst );
3923 xField->setLast( mnLast );
3924 }
3925
3926 void UnoCurrencyFieldControl::textChanged( const awt::TextEvent& e ) throw(uno::RuntimeException)
3927 {
3928 uno::Reference < awt::XCurrencyField > xField( getPeer(), uno::UNO_QUERY );
3929 uno::Any aAny;
3930 aAny <<= xField->getValue();
3931 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUE_DOUBLE ), aAny, sal_False );
3932
3933 if ( GetTextListeners().getLength() )
3934 GetTextListeners().textChanged( e );
3935 }
3936
3937 void UnoCurrencyFieldControl::setValue( double Value ) throw(uno::RuntimeException)
3938 {
3939 uno::Any aAny;
3940 aAny <<= Value;
3941 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUE_DOUBLE ), aAny, sal_True );
3942 }
3943
3944 double UnoCurrencyFieldControl::getValue() throw(uno::RuntimeException)
3945 {
3946 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUE_DOUBLE );
3947 }
3948
3949 void UnoCurrencyFieldControl::setMin( double Value ) throw(uno::RuntimeException)
3950 {
3951 uno::Any aAny;
3952 aAny <<= Value;
3953 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUEMIN_DOUBLE ), aAny, sal_True );
3954 }
3955
3956 double UnoCurrencyFieldControl::getMin() throw(uno::RuntimeException)
3957 {
3958 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUEMIN_DOUBLE );
3959 }
3960
3961 void UnoCurrencyFieldControl::setMax( double Value ) throw(uno::RuntimeException)
3962 {
3963 uno::Any aAny;
3964 aAny <<= Value;
3965 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUEMAX_DOUBLE ), aAny, sal_True );
3966 }
3967
3968 double UnoCurrencyFieldControl::getMax() throw(uno::RuntimeException)
3969 {
3970 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUEMAX_DOUBLE );
3971 }
3972
3973 void UnoCurrencyFieldControl::setFirst( double Value ) throw(uno::RuntimeException)
3974 {
3975 mnFirst = Value;
3976 if ( getPeer().is() )
3977 {
3978 uno::Reference < awt::XCurrencyField > xField( getPeer(), uno::UNO_QUERY );
3979 xField->setFirst( mnFirst );
3980 }
3981 }
3982
3983 double UnoCurrencyFieldControl::getFirst() throw(uno::RuntimeException)
3984 {
3985 return mnFirst;
3986 }
3987
3988 void UnoCurrencyFieldControl::setLast( double Value ) throw(uno::RuntimeException)
3989 {
3990 mnLast = Value;
3991 if ( getPeer().is() )
3992 {
3993 uno::Reference < awt::XCurrencyField > xField( getPeer(), uno::UNO_QUERY );
3994 xField->setLast( mnLast );
3995 }
3996 }
3997
3998 double UnoCurrencyFieldControl::getLast() throw(uno::RuntimeException)
3999 {
4000 return mnLast;
4001 }
4002
4003 void UnoCurrencyFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException)
4004 {
4005 uno::Any aAny;
4006 aAny <<= bStrict;
4007 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True );
4008 }
4009
4010 sal_Bool UnoCurrencyFieldControl::isStrictFormat() throw(uno::RuntimeException)
4011 {
4012 return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT );
4013 }
4014
4015 void UnoCurrencyFieldControl::setSpinSize( double Digits ) throw(uno::RuntimeException)
4016 {
4017 uno::Any aAny;
4018 aAny <<= Digits;
4019 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_VALUESTEP_DOUBLE ), aAny, sal_True );
4020 }
4021
4022 double UnoCurrencyFieldControl::getSpinSize() throw(uno::RuntimeException)
4023 {
4024 return ImplGetPropertyValue_DOUBLE( BASEPROPERTY_VALUESTEP_DOUBLE );
4025 }
4026
4027 void UnoCurrencyFieldControl::setDecimalDigits( sal_Int16 Digits ) throw(uno::RuntimeException)
4028 {
4029 uno::Any aAny;
4030 aAny <<= Digits;
4031 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_DECIMALACCURACY ), aAny, sal_True );
4032 }
4033
4034 sal_Int16 UnoCurrencyFieldControl::getDecimalDigits() throw(uno::RuntimeException)
4035 {
4036 return ImplGetPropertyValue_INT16( BASEPROPERTY_DECIMALACCURACY );
4037 }
4038
4039 // ----------------------------------------------------
4040 // class UnoControlPatternFieldModel
4041 // ----------------------------------------------------
4042 UnoControlPatternFieldModel::UnoControlPatternFieldModel( const Reference< XComponentContext >& rxContext )
4043 :UnoControlModel( rxContext )
4044 {
4045 UNO_CONTROL_MODEL_REGISTER_PROPERTIES( VCLXPatternField );
4046 }
4047
4048 OUString UnoControlPatternFieldModel::getServiceName() throw(::com::sun::star::uno::RuntimeException)
4049 {
4050 return OUString::createFromAscii( szServiceName_UnoControlPatternFieldModel );
4051 }
4052
4053 uno::Any UnoControlPatternFieldModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
4054 {
4055 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
4056 {
4057 uno::Any aAny;
4058 aAny <<= OUString::createFromAscii( szServiceName_UnoControlPatternField );
4059 return aAny;
4060 }
4061 return UnoControlModel::ImplGetDefaultValue( nPropId );
4062 }
4063
4064 ::cppu::IPropertyArrayHelper& UnoControlPatternFieldModel::getInfoHelper()
4065 {
4066 static UnoPropertyArrayHelper* pHelper = NULL;
4067 if ( !pHelper )
4068 {
4069 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
4070 pHelper = new UnoPropertyArrayHelper( aIDs );
4071 }
4072 return *pHelper;
4073 }
4074
4075 // beans::XMultiPropertySet
4076 uno::Reference< beans::XPropertySetInfo > UnoControlPatternFieldModel::getPropertySetInfo( ) throw(uno::RuntimeException)
4077 {
4078 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
4079 return xInfo;
4080 }
4081
4082
4083 // ----------------------------------------------------
4084 // class UnoPatternFieldControl
4085 // ----------------------------------------------------
4086 UnoPatternFieldControl::UnoPatternFieldControl()
4087 :UnoSpinFieldControl()
4088 {
4089 }
4090
4091 OUString UnoPatternFieldControl::GetComponentServiceName()
4092 {
4093 return OUString("patternfield");
4094 }
4095
4096 void UnoPatternFieldControl::ImplSetPeerProperty( const OUString& rPropName, const uno::Any& rVal )
4097 {
4098 sal_uInt16 nType = GetPropertyId( rPropName );
4099 if ( ( nType == BASEPROPERTY_TEXT ) || ( nType == BASEPROPERTY_EDITMASK ) || ( nType == BASEPROPERTY_LITERALMASK ) )
4100 {
4101 // These masks cannot be set consecutively
4102 OUString Text = ImplGetPropertyValue_UString( BASEPROPERTY_TEXT );
4103 OUString EditMask = ImplGetPropertyValue_UString( BASEPROPERTY_EDITMASK );
4104 OUString LiteralMask = ImplGetPropertyValue_UString( BASEPROPERTY_LITERALMASK );
4105
4106 uno::Reference < awt::XPatternField > xPF( getPeer(), uno::UNO_QUERY );
4107 if (xPF.is())
4108 {
4109 // same comment as in UnoControl::ImplSetPeerProperty - see there
4110 OUString sText( Text );
4111 ImplCheckLocalize( sText );
4112 xPF->setString( sText );
4113 xPF->setMasks( EditMask, LiteralMask );
4114 }
4115 }
4116 else
4117 UnoSpinFieldControl::ImplSetPeerProperty( rPropName, rVal );
4118 }
4119
4120
4121 // uno::XInterface
4122 uno::Any UnoPatternFieldControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
4123 {
4124 uno::Any aRet = ::cppu::queryInterface( rType,
4125 (static_cast< awt::XPatternField* >(this)) );
4126 return (aRet.hasValue() ? aRet : UnoSpinFieldControl::queryAggregation( rType ));
4127 }
4128
4129 // lang::XTypeProvider
4130 IMPL_XTYPEPROVIDER_START( UnoPatternFieldControl )
4131 getCppuType( ( uno::Reference< awt::XPatternField>* ) NULL ),
4132 UnoSpinFieldControl::getTypes()
4133 IMPL_XTYPEPROVIDER_END
4134
4135 void UnoPatternFieldControl::setString( const OUString& rString ) throw(uno::RuntimeException)
4136 {
4137 setText( rString );
4138 }
4139
4140 OUString UnoPatternFieldControl::getString() throw(uno::RuntimeException)
4141 {
4142 return getText();
4143 }
4144
4145 void UnoPatternFieldControl::setMasks( const OUString& EditMask, const OUString& LiteralMask ) throw(uno::RuntimeException)
4146 {
4147 uno::Any aAny;
4148 aAny <<= EditMask;
4149 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_EDITMASK ), aAny, sal_True );
4150 aAny <<= LiteralMask;
4151 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_LITERALMASK ), aAny, sal_True );
4152 }
4153
4154 void UnoPatternFieldControl::getMasks( OUString& EditMask, OUString& LiteralMask ) throw(uno::RuntimeException)
4155 {
4156 EditMask = ImplGetPropertyValue_UString( BASEPROPERTY_EDITMASK );
4157 LiteralMask = ImplGetPropertyValue_UString( BASEPROPERTY_LITERALMASK );
4158 }
4159
4160 void UnoPatternFieldControl::setStrictFormat( sal_Bool bStrict ) throw(uno::RuntimeException)
4161 {
4162 uno::Any aAny;
4163 aAny <<= bStrict;
4164 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_STRICTFORMAT ), aAny, sal_True );
4165 }
4166
4167 sal_Bool UnoPatternFieldControl::isStrictFormat() throw(uno::RuntimeException)
4168 {
4169 return ImplGetPropertyValue_BOOL( BASEPROPERTY_STRICTFORMAT );
4170 }
4171
4172
4173 // ----------------------------------------------------
4174 // class UnoControlProgressBarModel
4175 // ----------------------------------------------------
4176 UnoControlProgressBarModel::UnoControlProgressBarModel( const Reference< XComponentContext >& rxContext )
4177 :UnoControlModel( rxContext )
4178 {
4179 ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
4180 ImplRegisterProperty( BASEPROPERTY_BORDER );
4181 ImplRegisterProperty( BASEPROPERTY_BORDERCOLOR );
4182 ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
4183 ImplRegisterProperty( BASEPROPERTY_ENABLED );
4184 ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
4185 ImplRegisterProperty( BASEPROPERTY_FILLCOLOR );
4186 ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
4187 ImplRegisterProperty( BASEPROPERTY_HELPURL );
4188 ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
4189 ImplRegisterProperty( BASEPROPERTY_PROGRESSVALUE );
4190 ImplRegisterProperty( BASEPROPERTY_PROGRESSVALUE_MAX );
4191 ImplRegisterProperty( BASEPROPERTY_PROGRESSVALUE_MIN );
4192 }
4193
4194 OUString UnoControlProgressBarModel::getServiceName( ) throw(::com::sun::star::uno::RuntimeException)
4195 {
4196 return OUString::createFromAscii( szServiceName_UnoControlProgressBarModel );
4197 }
4198
4199 uno::Any UnoControlProgressBarModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
4200 {
4201 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
4202 {
4203 uno::Any aAny;
4204 aAny <<= OUString::createFromAscii( szServiceName_UnoControlProgressBar );
4205 return aAny;
4206 }
4207
4208 return UnoControlModel::ImplGetDefaultValue( nPropId );
4209 }
4210
4211 ::cppu::IPropertyArrayHelper& UnoControlProgressBarModel::getInfoHelper()
4212 {
4213 static UnoPropertyArrayHelper* pHelper = NULL;
4214 if ( !pHelper )
4215 {
4216 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
4217 pHelper = new UnoPropertyArrayHelper( aIDs );
4218 }
4219 return *pHelper;
4220 }
4221
4222 // beans::XMultiPropertySet
4223 uno::Reference< beans::XPropertySetInfo > UnoControlProgressBarModel::getPropertySetInfo( ) throw(uno::RuntimeException)
4224 {
4225 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
4226 return xInfo;
4227 }
4228
4229
4230 // ----------------------------------------------------
4231 // class UnoProgressBarControl
4232 // ----------------------------------------------------
4233 UnoProgressBarControl::UnoProgressBarControl()
4234 :UnoControlBase()
4235 {
4236 }
4237
4238 OUString UnoProgressBarControl::GetComponentServiceName()
4239 {
4240 return OUString("ProgressBar");
4241 }
4242
4243 // uno::XInterface
4244 uno::Any UnoProgressBarControl::queryAggregation( const uno::Type & rType ) throw(uno::RuntimeException)
4245 {
4246 uno::Any aRet = ::cppu::queryInterface( rType,
4247 (static_cast< awt::XProgressBar* >(this)) );
4248 return (aRet.hasValue() ? aRet : UnoControlBase::queryAggregation( rType ));
4249 }
4250
4251 // lang::XTypeProvider
4252 IMPL_XTYPEPROVIDER_START( UnoProgressBarControl )
4253 getCppuType( ( uno::Reference< awt::XProgressBar>* ) NULL ),
4254 UnoControlBase::getTypes()
4255 IMPL_XTYPEPROVIDER_END
4256
4257 // ::com::sun::star::awt::XProgressBar
4258 void UnoProgressBarControl::setForegroundColor( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException)
4259 {
4260 uno::Any aAny;
4261 aAny <<= nColor;
4262 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_FILLCOLOR ), aAny, sal_True );
4263 }
4264
4265 void UnoProgressBarControl::setBackgroundColor( sal_Int32 nColor ) throw(::com::sun::star::uno::RuntimeException)
4266 {
4267 uno::Any aAny;
4268 aAny <<= nColor;
4269 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_BACKGROUNDCOLOR ), aAny, sal_True );
4270 }
4271
4272 void UnoProgressBarControl::setValue( sal_Int32 nValue ) throw(::com::sun::star::uno::RuntimeException)
4273 {
4274 uno::Any aAny;
4275 aAny <<= nValue;
4276 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_PROGRESSVALUE ), aAny, sal_True );
4277 }
4278
4279 void UnoProgressBarControl::setRange( sal_Int32 nMin, sal_Int32 nMax ) throw(::com::sun::star::uno::RuntimeException )
4280 {
4281 uno::Any aMin;
4282 uno::Any aMax;
4283
4284 if ( nMin < nMax )
4285 {
4286 // take correct min and max
4287 aMin <<= nMin;
4288 aMax <<= nMax;
4289 }
4290 else
4291 {
4292 // change min and max
4293 aMin <<= nMax;
4294 aMax <<= nMin;
4295 }
4296
4297 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_PROGRESSVALUE_MIN ), aMin, sal_True );
4298 ImplSetPropertyValue( GetPropertyName( BASEPROPERTY_PROGRESSVALUE_MAX ), aMax, sal_True );
4299 }
4300
4301 sal_Int32 UnoProgressBarControl::getValue() throw(::com::sun::star::uno::RuntimeException)
4302 {
4303 return ImplGetPropertyValue_INT32( BASEPROPERTY_PROGRESSVALUE );
4304 }
4305
4306
4307 // ----------------------------------------------------
4308 // class UnoControlFixedLineModel
4309 // ----------------------------------------------------
4310 UnoControlFixedLineModel::UnoControlFixedLineModel( const Reference< XComponentContext >& rxContext )
4311 :UnoControlModel( rxContext )
4312 {
4313 ImplRegisterProperty( BASEPROPERTY_BACKGROUNDCOLOR );
4314 ImplRegisterProperty( BASEPROPERTY_DEFAULTCONTROL );
4315 ImplRegisterProperty( BASEPROPERTY_ENABLED );
4316 ImplRegisterProperty( BASEPROPERTY_ENABLEVISIBLE );
4317 ImplRegisterProperty( BASEPROPERTY_FONTDESCRIPTOR );
4318 ImplRegisterProperty( BASEPROPERTY_HELPTEXT );
4319 ImplRegisterProperty( BASEPROPERTY_HELPURL );
4320 ImplRegisterProperty( BASEPROPERTY_LABEL );
4321 ImplRegisterProperty( BASEPROPERTY_ORIENTATION );
4322 ImplRegisterProperty( BASEPROPERTY_PRINTABLE );
4323 }
4324
4325 OUString UnoControlFixedLineModel::getServiceName( ) throw(::com::sun::star::uno::RuntimeException)
4326 {
4327 return OUString::createFromAscii( szServiceName_UnoControlFixedLineModel );
4328 }
4329
4330 uno::Any UnoControlFixedLineModel::ImplGetDefaultValue( sal_uInt16 nPropId ) const
4331 {
4332 if ( nPropId == BASEPROPERTY_DEFAULTCONTROL )
4333 {
4334 uno::Any aAny;
4335 aAny <<= OUString::createFromAscii( szServiceName_UnoControlFixedLine );
4336 return aAny;
4337 }
4338 return UnoControlModel::ImplGetDefaultValue( nPropId );
4339 }
4340
4341 ::cppu::IPropertyArrayHelper& UnoControlFixedLineModel::getInfoHelper()
4342 {
4343 static UnoPropertyArrayHelper* pHelper = NULL;
4344 if ( !pHelper )
4345 {
4346 uno::Sequence<sal_Int32> aIDs = ImplGetPropertyIds();
4347 pHelper = new UnoPropertyArrayHelper( aIDs );
4348 }
4349 return *pHelper;
4350 }
4351
4352 // beans::XMultiPropertySet
4353 uno::Reference< beans::XPropertySetInfo > UnoControlFixedLineModel::getPropertySetInfo( ) throw(uno::RuntimeException)
4354 {
4355 static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
4356 return xInfo;
4357 }
4358
4359 // ----------------------------------------------------
4360 // class UnoFixedLineControl
4361 // ----------------------------------------------------
4362 UnoFixedLineControl::UnoFixedLineControl()
4363 :UnoControlBase()
4364 {
4365 maComponentInfos.nWidth = 100; // ??
4366 maComponentInfos.nHeight = 100; // ??
4367 }
4368
4369 OUString UnoFixedLineControl::GetComponentServiceName()
4370 {
4371 return OUString("FixedLine");
4372 }
4373
4374 sal_Bool UnoFixedLineControl::isTransparent() throw(uno::RuntimeException)
4375 {
4376 return sal_True;
4377 }
4378
4379 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE