toolkit/source/controls/unocontrols.cxx

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