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