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