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