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