extensions/source/propctrlr/standardcontrol.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 "standardcontrol.hxx"
  21 #include "pcrcommon.hxx"
  22
  23 #include <com/sun/star/beans/IllegalTypeException.hpp>
  24 #include <com/sun/star/util/DateTime.hpp>
  25 #include <com/sun/star/util/Date.hpp>
  26 #include <com/sun/star/util/Time.hpp>
  27 #include <com/sun/star/util/Color.hpp>
  28 #include <com/sun/star/util/MeasureUnit.hpp>
  29 #include <com/sun/star/inspection/PropertyControlType.hpp>
  30 #include <comphelper/string.hxx>
  31 #include <o3tl/float_int_conversion.hxx>
  32 #include <rtl/math.hxx>
  33 #include <sfx2/objsh.hxx>
  34
  35
  36 // ugly dependencies for the OColorControl
  37 #include <svx/svxids.hrc>
  38 #include <svx/drawitem.hxx>
  39 #include <svx/xtable.hxx>
  40
  41 #include <vcl/floatwin.hxx>
  42 #include <svtools/svmedit.hxx>
  43 #include <svtools/colorcfg.hxx>
  44 #include <svl/zforlist.hxx>
  45 #include <unotools/syslocale.hxx>
  46 #include <unotools/datetime.hxx>
  47 #include <i18nlangtag/languagetag.hxx>
  48 #include <vcl/button.hxx>
  49 #include <vcl/event.hxx>
  50 #include <vcl/svapp.hxx>
  51 #include <vcl/settings.hxx>
  52 #include <vcl/ptrstyle.hxx>
  53
  54 #include <cstdlib>
  55 #include <limits>
  56 #include <memory>
  57
  58
  59 namespace pcr
  60 {
  61
  62
  63     using namespace ::com::sun::star;
  64     using namespace ::com::sun::star::uno;
  65     using namespace ::com::sun::star::awt;
  66     using namespace ::com::sun::star::lang;
  67     using namespace ::com::sun::star::util;
  68     using namespace ::com::sun::star::beans;
  69     using namespace ::com::sun::star::inspection;
  70
  71
  72     //= OTimeControl
  73
  74
  75     OTimeControl::OTimeControl( vcl::Window* pParent, WinBits nWinStyle )
  76         :OTimeControl_Base( PropertyControlType::TimeField, pParent, nWinStyle )
  77     {
  78         getTypedControlWindow()->SetStrictFormat( true );
  79         getTypedControlWindow()->SetFormat( TimeFieldFormat::F_SEC );
  80         getTypedControlWindow()->EnableEmptyFieldValue( true );
  81     }
  82
  83
  84     void SAL_CALL OTimeControl::setValue( const Any& _rValue )
  85     {
  86         util::Time aUNOTime;
  87         if ( !( _rValue >>= aUNOTime ) )
  88         {
  89             getTypedControlWindow()->SetText( "" );
  90             getTypedControlWindow()->SetEmptyTime();
  91         }
  92         else
  93         {
  94             getTypedControlWindow()->SetTime( ::tools::Time(aUNOTime) );
  95         }
  96     }
  97
  98
  99     Any SAL_CALL OTimeControl::getValue()
 100     {
 101         Any aPropValue;
 102         if ( !getTypedControlWindow()->GetText().isEmpty() )
 103         {
 104             aPropValue <<= getTypedControlWindow()->GetTime().GetUNOTime();
 105         }
 106         return aPropValue;
 107     }
 108
 109
 110     Type SAL_CALL OTimeControl::getValueType()
 111     {
 112         return ::cppu::UnoType<util::Time>::get();
 113     }
 114
 115
 116     //= ODateControl
 117
 118
 119     ODateControl::ODateControl( vcl::Window* pParent, WinBits nWinStyle )
 120         :ODateControl_Base( PropertyControlType::DateField, pParent, nWinStyle | WB_DROPDOWN )
 121     {
 122         CalendarField* pControlWindow = getTypedControlWindow();
 123         pControlWindow->SetStrictFormat(true);
 124
 125         pControlWindow->SetMin( ::Date( 1,1,1600 ) );
 126         pControlWindow->SetFirst( ::Date( 1,1,1600 ) );
 127         pControlWindow->SetLast( ::Date( 1, 1, 9999 ) );
 128         pControlWindow->SetMax( ::Date( 1, 1, 9999 ) );
 129
 130         pControlWindow->SetExtDateFormat( ExtDateFieldFormat::SystemShortYYYY );
 131         pControlWindow->EnableEmptyFieldValue( true );
 132     }
 133
 134
 135     void SAL_CALL ODateControl::setValue( const Any& _rValue )
 136     {
 137         util::Date aUNODate;
 138         if ( !( _rValue >>= aUNODate ) )
 139         {
 140             getTypedControlWindow()->SetText( "" );
 141             getTypedControlWindow()->SetEmptyDate();
 142         }
 143         else
 144         {
 145             ::Date aDate( aUNODate.Day, aUNODate.Month, aUNODate.Year );
 146             getTypedControlWindow()->SetDate( aDate );
 147         }
 148     }
 149
 150
 151     Any SAL_CALL ODateControl::getValue()
 152     {
 153         Any aPropValue;
 154         if ( !getTypedControlWindow()->GetText().isEmpty() )
 155         {
 156             ::Date aDate( getTypedControlWindow()->GetDate() );
 157             aPropValue <<= aDate.GetUNODate();
 158         }
 159         return aPropValue;
 160     }
 161
 162
 163     Type SAL_CALL ODateControl::getValueType()
 164     {
 165         return ::cppu::UnoType<util::Date>::get();
 166     }
 167
 168
 169     //= OEditControl
 170
 171
 172     OEditControl::OEditControl(vcl::Window* _pParent, bool _bPW, WinBits _nWinStyle)
 173         :OEditControl_Base( _bPW ? PropertyControlType::CharacterField : PropertyControlType::TextField, _pParent, _nWinStyle )
 174     {
 175         m_bIsPassword = _bPW;
 176
 177         if ( m_bIsPassword )
 178            getTypedControlWindow()->SetMaxTextLen( 1 );
 179     }
 180
 181
 182     void SAL_CALL OEditControl::setValue( const Any& _rValue )
 183     {
 184         OUString sText;
 185         if ( m_bIsPassword )
 186         {
 187             sal_Int16 nValue = 0;
 188             _rValue >>= nValue;
 189             if ( nValue )
 190             {
 191                 sText = OUString(static_cast<sal_Unicode>(nValue));
 192             }
 193         }
 194         else
 195             _rValue >>= sText;
 196
 197         getTypedControlWindow()->SetText( sText );
 198     }
 199
 200
 201     Any SAL_CALL OEditControl::getValue()
 202     {
 203         Any aPropValue;
 204
 205         OUString sText( getTypedControlWindow()->GetText() );
 206         if ( m_bIsPassword )
 207         {
 208             if ( !sText.isEmpty() )
 209                 aPropValue <<= static_cast<sal_Int16>(sText[0]);
 210         }
 211         else
 212             aPropValue <<= sText;
 213
 214         return aPropValue;
 215     }
 216
 217
 218     Type SAL_CALL OEditControl::getValueType()
 219     {
 220         return m_bIsPassword ? ::cppu::UnoType<sal_Int16>::get() : ::cppu::UnoType<OUString>::get();
 221     }
 222
 223
 224     void OEditControl::setModified()
 225     {
 226         OEditControl_Base::setModified();
 227
 228         // for password controls, we fire a commit for every single change
 229         if ( m_bIsPassword )
 230             notifyModifiedValue();
 231     }
 232
 233
 234     static long ImplCalcLongValue( double nValue, sal_uInt16 nDigits )
 235     {
 236         double n = nValue;
 237         for ( sal_uInt16 d = 0; d < nDigits; ++d )
 238             n *= 10;
 239
 240         if ( !o3tl::convertsToAtMost(n, std::numeric_limits< long >::max()) )
 241             return std::numeric_limits< long >::max();
 242         return static_cast<long>(n);
 243     }
 244
 245
 246     static double ImplCalcDoubleValue( long nValue, sal_uInt16 nDigits )
 247     {
 248         double n = nValue;
 249         for ( sal_uInt16 d = 0; d < nDigits; ++d )
 250             n /= 10;
 251         return n;
 252     }
 253
 254
 255     // class ODateTimeControl
 256
 257
 258     ODateTimeControl::ODateTimeControl( vcl::Window* _pParent, WinBits _nWinStyle)
 259         :ODateTimeControl_Base( PropertyControlType::DateTimeField, _pParent, _nWinStyle )
 260     {
 261         getTypedControlWindow()->EnableEmptyField( true );
 262
 263         // determine a default format
 264         LanguageType eSysLanguage = SvtSysLocale().GetLanguageTag().getLanguageType( false);
 265
 266         getTypedControlWindow()->SetFormatter( getTypedControlWindow()->StandardFormatter() );
 267         SvNumberFormatter* pFormatter = getTypedControlWindow()->GetFormatter();
 268         sal_uLong nStandardDateTimeFormat = pFormatter->GetStandardFormat( SvNumFormatType::DATETIME, eSysLanguage );
 269
 270         getTypedControlWindow()->SetFormatKey( nStandardDateTimeFormat );
 271     }
 272
 273
 274     void SAL_CALL ODateTimeControl::setValue( const Any& _rValue )
 275     {
 276         if ( !_rValue.hasValue() )
 277         {
 278             getTypedControlWindow()->SetText( "" );
 279         }
 280         else
 281         {
 282             util::DateTime aUNODateTime;
 283             OSL_VERIFY( _rValue >>= aUNODateTime );
 284
 285             ::DateTime aDateTime( ::DateTime::EMPTY );
 286             ::utl::typeConvert( aUNODateTime, aDateTime );
 287
 288             double nValue = aDateTime - ::DateTime( getTypedControlWindow()->GetFormatter()->GetNullDate() );
 289             getTypedControlWindow()->SetValue( nValue );
 290         }
 291     }
 292
 293
 294     Any SAL_CALL ODateTimeControl::getValue()
 295     {
 296         Any aPropValue;
 297         if ( !getTypedControlWindow()->GetText().isEmpty() )
 298         {
 299             double nValue = getTypedControlWindow()->GetValue();
 300
 301             ::DateTime aDateTime( getTypedControlWindow()->GetFormatter()->GetNullDate() );
 302
 303             // add the "days" part
 304             double nDays = floor( nValue );
 305             aDateTime.AddDays( nDays );
 306
 307             // add the "time" part
 308             double nTime = nValue - nDays;
 309             nTime = ::rtl::math::round( nTime * 86400.0 ) / 86400.0;
 310                 // we're not interested in 100th seconds, and this here prevents rounding errors
 311             aDateTime.AddTime( nTime );
 312
 313             util::DateTime aUNODateTime;
 314             ::utl::typeConvert( aDateTime, aUNODateTime );
 315
 316             aPropValue <<= aUNODateTime;
 317         }
 318         return aPropValue;
 319     }
 320
 321
 322     Type SAL_CALL ODateTimeControl::getValueType()
 323     {
 324         return ::cppu::UnoType<util::DateTime>::get();
 325     }
 326
 327
 328     //= HyperlinkInput
 329
 330
 331     HyperlinkInput::HyperlinkInput( vcl::Window* _pParent, WinBits _nWinStyle )
 332         :Edit( _pParent, _nWinStyle )
 333     {
 334         ::svtools::ColorConfig aColorConfig;
 335         ::svtools::ColorConfigValue aLinkColor( aColorConfig.GetColorValue( ::svtools::LINKS ) );
 336
 337         AllSettings aAllSettings( GetSettings() );
 338         StyleSettings aStyleSettings( aAllSettings.GetStyleSettings() );
 339
 340         vcl::Font aFieldFont( aStyleSettings.GetFieldFont() );
 341         aFieldFont.SetUnderline( LINESTYLE_SINGLE );
 342         aFieldFont.SetColor( aLinkColor.nColor );
 343         aStyleSettings.SetFieldFont( aFieldFont );
 344
 345         aStyleSettings.SetFieldTextColor( aLinkColor.nColor );
 346
 347         aAllSettings.SetStyleSettings( aStyleSettings );
 348         SetSettings( aAllSettings );
 349     }
 350
 351
 352     void HyperlinkInput::MouseMove( const ::MouseEvent& rMEvt )
 353     {
 354         Edit::MouseMove( rMEvt );
 355
 356         PointerStyle ePointerStyle( PointerStyle::Text );
 357
 358         if ( !rMEvt.IsLeaveWindow() )
 359         {
 360             if ( impl_textHitTest( rMEvt.GetPosPixel() ) )
 361                 ePointerStyle = PointerStyle::RefHand;
 362         }
 363
 364         SetPointer( ePointerStyle );
 365     }
 366
 367
 368     void HyperlinkInput::MouseButtonDown( const ::MouseEvent& rMEvt )
 369     {
 370         Edit::MouseButtonDown( rMEvt );
 371
 372         if ( impl_textHitTest( rMEvt.GetPosPixel() ) )
 373             m_aMouseButtonDownPos = rMEvt.GetPosPixel();
 374         else
 375         {
 376             m_aMouseButtonDownPos.setX(-1);
 377             m_aMouseButtonDownPos.setY(-1);
 378         }
 379     }
 380
 381
 382     void HyperlinkInput::MouseButtonUp( const ::MouseEvent& rMEvt )
 383     {
 384         Edit::MouseButtonUp( rMEvt );
 385
 386         impl_checkEndClick( rMEvt );
 387     }
 388
 389
 390     bool HyperlinkInput::impl_textHitTest( const ::Point& _rWindowPos )
 391     {
 392         sal_Int32 nPos = GetCharPos( _rWindowPos );
 393         return ( ( nPos != EDIT_NOLIMIT ) && ( nPos < GetText().getLength() ) );
 394     }
 395
 396
 397     void HyperlinkInput::impl_checkEndClick( const ::MouseEvent& rMEvt )
 398     {
 399         const MouseSettings& rMouseSettings( GetSettings().GetMouseSettings() );
 400         if  (   ( std::abs( rMEvt.GetPosPixel().X() - m_aMouseButtonDownPos.X() ) < rMouseSettings.GetStartDragWidth() )
 401             &&  ( std::abs( rMEvt.GetPosPixel().Y() - m_aMouseButtonDownPos.Y() ) < rMouseSettings.GetStartDragHeight() )
 402             )
 403             Application::PostUserEvent( m_aClickHandler );
 404     }
 405
 406
 407     void HyperlinkInput::Tracking( const TrackingEvent& rTEvt )
 408     {
 409         Edit::Tracking( rTEvt );
 410
 411         if ( rTEvt.IsTrackingEnded() )
 412             impl_checkEndClick( rTEvt.GetMouseEvent() );
 413     }
 414
 415
 416     //= OHyperlinkControl
 417
 418
 419     OHyperlinkControl::OHyperlinkControl( vcl::Window* _pParent, WinBits _nWinStyle )
 420         :OHyperlinkControl_Base( PropertyControlType::HyperlinkField, _pParent, _nWinStyle )
 421         ,m_aActionListeners( m_aMutex )
 422     {
 423         getTypedControlWindow()->SetClickHdl( LINK( this, OHyperlinkControl, OnHyperlinkClicked ) );
 424     }
 425
 426
 427     Any SAL_CALL OHyperlinkControl::getValue()
 428     {
 429         OUString sText = getTypedControlWindow()->GetText();
 430         return makeAny( sText );
 431     }
 432
 433
 434     void SAL_CALL OHyperlinkControl::setValue( const Any& _value )
 435     {
 436         OUString sText;
 437         _value >>= sText;
 438         getTypedControlWindow()->SetText( sText );
 439     }
 440
 441
 442     Type SAL_CALL OHyperlinkControl::getValueType()
 443     {
 444         return ::cppu::UnoType<OUString>::get();
 445     }
 446
 447
 448     void SAL_CALL OHyperlinkControl::addActionListener( const Reference< XActionListener >& listener )
 449     {
 450         if ( listener.is() )
 451             m_aActionListeners.addInterface( listener );
 452     }
 453
 454
 455     void SAL_CALL OHyperlinkControl::removeActionListener( const Reference< XActionListener >& listener )
 456     {
 457         m_aActionListeners.removeInterface( listener );
 458     }
 459
 460
 461     void SAL_CALL OHyperlinkControl::disposing()
 462     {
 463         OHyperlinkControl_Base::disposing();
 464
 465         EventObject aEvent( *this );
 466         m_aActionListeners.disposeAndClear( aEvent );
 467     }
 468
 469
 470     IMPL_LINK_NOARG( OHyperlinkControl, OnHyperlinkClicked, void*, void )
 471     {
 472         ActionEvent aEvent( *this, "clicked" );
 473         m_aActionListeners.forEach< XActionListener >(
 474             [&aEvent] (uno::Reference<awt::XActionListener> const& xListener)
 475                 { return xListener->actionPerformed(aEvent); });
 476     }
 477
 478
 479     //= ONumericControl
 480
 481
 482     ONumericControl::ONumericControl( vcl::Window* _pParent, WinBits _nWinStyle )
 483         :ONumericControl_Base( PropertyControlType::NumericField, _pParent, _nWinStyle )
 484         ,m_eValueUnit( FieldUnit::NONE )
 485         ,m_nFieldToUNOValueFactor( 1 )
 486     {
 487         MetricField::SetDefaultUnit( FieldUnit::NONE );
 488
 489         getTypedControlWindow()->EnableEmptyFieldValue( true );
 490         getTypedControlWindow()->SetStrictFormat( true );
 491         Optional< double > value( getMaxValue() );
 492         value.Value = -value.Value;
 493         setMinValue( value );
 494     }
 495
 496
 497     ::sal_Int16 SAL_CALL ONumericControl::getDecimalDigits()
 498     {
 499         return getTypedControlWindow()->GetDecimalDigits();
 500     }
 501
 502
 503     void SAL_CALL ONumericControl::setDecimalDigits( ::sal_Int16 _decimaldigits )
 504     {
 505         getTypedControlWindow()->SetDecimalDigits( _decimaldigits );
 506     }
 507
 508
 509     Optional< double > SAL_CALL ONumericControl::getMinValue()
 510     {
 511         Optional< double > aReturn( true, 0 );
 512
 513         sal_Int64 minValue = getTypedControlWindow()->GetMin();
 514         if ( minValue == std::numeric_limits< sal_Int64 >::min() )
 515             aReturn.IsPresent = false;
 516         else
 517             aReturn.Value = static_cast<double>(minValue);
 518
 519         return aReturn;
 520     }
 521
 522
 523     void SAL_CALL ONumericControl::setMinValue( const Optional< double >& _minvalue )
 524     {
 525         if ( !_minvalue.IsPresent )
 526             getTypedControlWindow()->SetMin( std::numeric_limits< sal_Int64 >::min() );
 527         else
 528             getTypedControlWindow()->SetMin( impl_apiValueToFieldValue_nothrow( _minvalue.Value ) , m_eValueUnit);
 529     }
 530
 531
 532     Optional< double > SAL_CALL ONumericControl::getMaxValue()
 533     {
 534         Optional< double > aReturn( true, 0 );
 535
 536         sal_Int64 maxValue = getTypedControlWindow()->GetMax();
 537         if ( maxValue == std::numeric_limits< sal_Int64 >::max() )
 538             aReturn.IsPresent = false;
 539         else
 540             aReturn.Value = static_cast<double>(maxValue);
 541
 542         return aReturn;
 543     }
 544
 545
 546     void SAL_CALL ONumericControl::setMaxValue( const Optional< double >& _maxvalue )
 547     {
 548         if ( !_maxvalue.IsPresent )
 549             getTypedControlWindow()->SetMax( std::numeric_limits< sal_Int64 >::max() );
 550         else
 551             getTypedControlWindow()->SetMax( impl_apiValueToFieldValue_nothrow( _maxvalue.Value ), m_eValueUnit );
 552     }
 553
 554
 555     ::sal_Int16 SAL_CALL ONumericControl::getDisplayUnit()
 556     {
 557         return VCLUnoHelper::ConvertToMeasurementUnit( getTypedControlWindow()->GetUnit(), 1 );
 558     }
 559
 560
 561     void SAL_CALL ONumericControl::setDisplayUnit( ::sal_Int16 _displayunit )
 562     {
 563         if ( ( _displayunit < MeasureUnit::MM_100TH ) || ( _displayunit > MeasureUnit::PERCENT ) )
 564             throw IllegalArgumentException();
 565         if  (   ( _displayunit == MeasureUnit::MM_100TH )
 566             ||  ( _displayunit == MeasureUnit::MM_10TH )
 567             ||  ( _displayunit == MeasureUnit::INCH_1000TH )
 568             ||  ( _displayunit == MeasureUnit::INCH_100TH )
 569             ||  ( _displayunit == MeasureUnit::INCH_10TH )
 570             ||  ( _displayunit == MeasureUnit::PERCENT )
 571             )
 572             throw IllegalArgumentException();
 573
 574         sal_Int16 nDummyFactor = 1;
 575         FieldUnit eFieldUnit = VCLUnoHelper::ConvertToFieldUnit( _displayunit, nDummyFactor );
 576         if ( nDummyFactor != 1 )
 577             // everything which survived the checks above should result in a factor of 1, i.e.,
 578             // it should have a direct counterpart as FieldUnit
 579             throw RuntimeException();
 580         getTypedControlWindow()->MetricFormatter::SetUnit( eFieldUnit );
 581     }
 582
 583
 584     ::sal_Int16 SAL_CALL ONumericControl::getValueUnit()
 585     {
 586         return VCLUnoHelper::ConvertToMeasurementUnit( m_eValueUnit, m_nFieldToUNOValueFactor );
 587     }
 588
 589
 590     void SAL_CALL ONumericControl::setValueUnit( ::sal_Int16 _valueunit )
 591     {
 592         if ( ( _valueunit < MeasureUnit::MM_100TH ) || ( _valueunit > MeasureUnit::PERCENT ) )
 593             throw IllegalArgumentException();
 594         m_eValueUnit = VCLUnoHelper::ConvertToFieldUnit( _valueunit, m_nFieldToUNOValueFactor );
 595     }
 596
 597
 598     void SAL_CALL ONumericControl::setValue( const Any& _rValue )
 599     {
 600         if ( !_rValue.hasValue() )
 601         {
 602             getTypedControlWindow()->SetText( "" );
 603             getTypedControlWindow()->SetEmptyFieldValue();
 604         }
 605         else
 606         {
 607             double nValue( 0 );
 608             OSL_VERIFY( _rValue >>= nValue );
 609             long nControlValue = impl_apiValueToFieldValue_nothrow( nValue );
 610             getTypedControlWindow()->SetValue( nControlValue, m_eValueUnit );
 611         }
 612     }
 613
 614
 615     long ONumericControl::impl_apiValueToFieldValue_nothrow( double _nApiValue ) const
 616     {
 617         long nControlValue = ImplCalcLongValue( _nApiValue, getTypedControlWindow()->GetDecimalDigits() );
 618         nControlValue /= m_nFieldToUNOValueFactor;
 619         return nControlValue;
 620     }
 621
 622
 623     double ONumericControl::impl_fieldValueToApiValue_nothrow( sal_Int64 _nFieldValue ) const
 624     {
 625         double nApiValue = ImplCalcDoubleValue( static_cast<long>(_nFieldValue), getTypedControlWindow()->GetDecimalDigits() );
 626         nApiValue *= m_nFieldToUNOValueFactor;
 627         return nApiValue;
 628     }
 629
 630
 631     Any SAL_CALL ONumericControl::getValue()
 632     {
 633         Any aPropValue;
 634         if ( !getTypedControlWindow()->GetText().isEmpty() )
 635         {
 636             double nValue = impl_fieldValueToApiValue_nothrow( getTypedControlWindow()->GetValue( m_eValueUnit ) );
 637             aPropValue <<= nValue;
 638         }
 639         return aPropValue;
 640     }
 641
 642
 643     Type SAL_CALL ONumericControl::getValueType()
 644     {
 645         return ::cppu::UnoType<double>::get();
 646     }
 647
 648
 649     //= OColorControl
 650
 651     #define LB_DEFAULT_COUNT 20
 652
 653     OColorControl::OColorControl(vcl::Window* pParent, WinBits nWinStyle)
 654         : OColorControl_Base(PropertyControlType::ColorListBox, pParent, nWinStyle)
 655     {
 656         getTypedControlWindow()->SetSlotId(SID_FM_CTL_PROPERTIES);
 657     }
 658
 659     void SAL_CALL OColorControl::setValue( const Any& _rValue )
 660     {
 661         css::util::Color nColor = sal_uInt32(COL_TRANSPARENT);
 662         if (_rValue.hasValue())
 663             _rValue >>= nColor;
 664         getTypedControlWindow()->SelectEntry(nColor);
 665     }
 666
 667     Any SAL_CALL OColorControl::getValue()
 668     {
 669         Any aPropValue;
 670         ::Color aRgbCol = getTypedControlWindow()->GetSelectEntryColor();
 671         if (aRgbCol == COL_TRANSPARENT)
 672             return aPropValue;
 673         aPropValue <<= aRgbCol;
 674         return aPropValue;
 675     }
 676
 677     Type SAL_CALL OColorControl::getValueType()
 678     {
 679         return ::cppu::UnoType<sal_Int32>::get();
 680     }
 681
 682     void OColorControl::setModified()
 683     {
 684         OColorControl_Base::setModified();
 685
 686         // fire a commit
 687         notifyModifiedValue();
 688     }
 689
 690     //= OListboxControl
 691
 692     OListboxControl::OListboxControl( vcl::Window* pParent, WinBits nWinStyle)
 693         :OListboxControl_Base( PropertyControlType::ListBox, pParent, nWinStyle )
 694     {
 695         getTypedControlWindow()->SetDropDownLineCount( LB_DEFAULT_COUNT );
 696         if ( ( nWinStyle & WB_READONLY ) != 0 )
 697         {
 698             getTypedControlWindow()->SetReadOnly();
 699             getTypedControlWindow()->Enable();
 700         }
 701     }
 702
 703
 704     Any SAL_CALL OListboxControl::getValue()
 705     {
 706         OUString sControlValue( getTypedControlWindow()->GetSelectedEntry() );
 707
 708         Any aPropValue;
 709         if ( !sControlValue.isEmpty() )
 710             aPropValue <<= sControlValue;
 711         return aPropValue;
 712     }
 713
 714
 715     Type SAL_CALL OListboxControl::getValueType()
 716     {
 717         return ::cppu::UnoType<OUString>::get();
 718     }
 719
 720
 721     void SAL_CALL OListboxControl::setValue( const Any& _rValue )
 722     {
 723         if ( !_rValue.hasValue() )
 724             getTypedControlWindow()->SetNoSelection();
 725         else
 726         {
 727             OUString sSelection;
 728             _rValue >>= sSelection;
 729
 730             if ( sSelection != getTypedControlWindow()->GetSelectedEntry() )
 731                 getTypedControlWindow()->SelectEntry( sSelection );
 732
 733             if ( !getTypedControlWindow()->IsEntrySelected( sSelection ) )
 734             {
 735                 getTypedControlWindow()->InsertEntry( sSelection, 0 );
 736                 getTypedControlWindow()->SelectEntry( sSelection );
 737             }
 738         }
 739     }
 740
 741
 742     void SAL_CALL OListboxControl::clearList()
 743     {
 744         getTypedControlWindow()->Clear();
 745     }
 746
 747
 748     void SAL_CALL OListboxControl::prependListEntry( const OUString& NewEntry )
 749     {
 750         getTypedControlWindow()->InsertEntry( NewEntry, 0 );
 751     }
 752
 753
 754     void SAL_CALL OListboxControl::appendListEntry( const OUString& NewEntry )
 755     {
 756         getTypedControlWindow()->InsertEntry( NewEntry );
 757     }
 758
 759     Sequence< OUString > SAL_CALL OListboxControl::getListEntries(  )
 760     {
 761         const sal_Int32 nCount = getTypedControlWindow()->GetEntryCount();
 762         Sequence< OUString > aRet(nCount);
 763         OUString* pIter = aRet.getArray();
 764         for (sal_Int32 i = 0; i < nCount ; ++i,++pIter)
 765             *pIter = getTypedControlWindow()->GetEntry(i);
 766
 767         return aRet;
 768     }
 769
 770
 771     void OListboxControl::setModified()
 772     {
 773         OListboxControl_Base::setModified();
 774
 775         if ( !getTypedControlWindow()->IsTravelSelect() )
 776             // fire a commit
 777             notifyModifiedValue();
 778     }
 779
 780
 781     //= OComboboxControl
 782
 783
 784     OComboboxControl::OComboboxControl( vcl::Window* pParent, WinBits nWinStyle)
 785         :OComboboxControl_Base( PropertyControlType::ComboBox, pParent, nWinStyle )
 786     {
 787         getTypedControlWindow()->SetDropDownLineCount( LB_DEFAULT_COUNT );
 788         getTypedControlWindow()->SetSelectHdl( LINK( this, OComboboxControl, OnEntrySelected ) );
 789     }
 790
 791
 792     void SAL_CALL OComboboxControl::setValue( const Any& _rValue )
 793     {
 794         OUString sText;
 795         _rValue >>= sText;
 796         getTypedControlWindow()->SetText( sText );
 797     }
 798
 799
 800     Any SAL_CALL OComboboxControl::getValue()
 801     {
 802         return makeAny( getTypedControlWindow()->GetText() );
 803     }
 804
 805
 806     Type SAL_CALL OComboboxControl::getValueType()
 807     {
 808         return ::cppu::UnoType<OUString>::get();
 809     }
 810
 811
 812     void SAL_CALL OComboboxControl::clearList()
 813     {
 814         getTypedControlWindow()->Clear();
 815     }
 816
 817
 818     void SAL_CALL OComboboxControl::prependListEntry( const OUString& NewEntry )
 819     {
 820         getTypedControlWindow()->InsertEntry( NewEntry, 0 );
 821     }
 822
 823
 824     void SAL_CALL OComboboxControl::appendListEntry( const OUString& NewEntry )
 825     {
 826         getTypedControlWindow()->InsertEntry( NewEntry );
 827     }
 828
 829     Sequence< OUString > SAL_CALL OComboboxControl::getListEntries(  )
 830     {
 831         const sal_Int32 nCount = getTypedControlWindow()->GetEntryCount();
 832         Sequence< OUString > aRet(nCount);
 833         OUString* pIter = aRet.getArray();
 834         for (sal_Int32 i = 0; i < nCount ; ++i,++pIter)
 835             *pIter = getTypedControlWindow()->GetEntry(i);
 836
 837         return aRet;
 838     }
 839
 840
 841     IMPL_LINK_NOARG( OComboboxControl, OnEntrySelected, ComboBox&, void )
 842     {
 843         if ( !getTypedControlWindow()->IsTravelSelect() )
 844             // fire a commit
 845             notifyModifiedValue();
 846     }
 847
 848
 849     //= OMultilineFloatingEdit
 850
 851     class OMultilineFloatingEdit : public FloatingWindow
 852     {
 853     private:
 854         VclPtr<MultiLineEdit>   m_aImplEdit;
 855
 856     protected:
 857         virtual void    Resize() override;
 858
 859     public:
 860         explicit        OMultilineFloatingEdit(vcl::Window* _pParen);
 861         virtual         ~OMultilineFloatingEdit() override;
 862         virtual void    dispose() override;
 863         MultiLineEdit&  getEdit() { return *m_aImplEdit.get(); }
 864
 865     protected:
 866         virtual bool    PreNotify(NotifyEvent& _rNEvt) override;
 867     };
 868
 869
 870     OMultilineFloatingEdit::OMultilineFloatingEdit(vcl::Window* _pParent)
 871         :FloatingWindow(_pParent, WB_BORDER)
 872         ,m_aImplEdit(VclPtr<MultiLineEdit>::Create(this, WB_VSCROLL|WB_IGNORETAB|WB_NOBORDER))
 873     {
 874         m_aImplEdit->Show();
 875     }
 876
 877     OMultilineFloatingEdit::~OMultilineFloatingEdit()
 878     {
 879         disposeOnce();
 880     }
 881
 882     void OMultilineFloatingEdit::dispose()
 883     {
 884         m_aImplEdit.disposeAndClear();
 885         FloatingWindow::dispose();
 886     }
 887
 888     void OMultilineFloatingEdit::Resize()
 889     {
 890         m_aImplEdit->SetSizePixel(GetOutputSizePixel());
 891     }
 892
 893
 894     bool OMultilineFloatingEdit::PreNotify(NotifyEvent& _rNEvt)
 895     {
 896         bool bResult = true;
 897
 898         MouseNotifyEvent nSwitch = _rNEvt.GetType();
 899         if (MouseNotifyEvent::KEYINPUT == nSwitch)
 900         {
 901             const vcl::KeyCode& aKeyCode = _rNEvt.GetKeyEvent()->GetKeyCode();
 902             sal_uInt16 nKey = aKeyCode.GetCode();
 903
 904             if  (   (   (KEY_RETURN == nKey)
 905                     && !aKeyCode.IsShift()
 906                     )
 907                 ||  (   (KEY_UP == nKey)
 908                     &&  aKeyCode.IsMod2()
 909                     )
 910                 )
 911             {
 912                 EndPopupMode();
 913             }
 914             else
 915                 bResult=FloatingWindow::PreNotify(_rNEvt);
 916         }
 917         else
 918             bResult=FloatingWindow::PreNotify(_rNEvt);
 919
 920         return bResult;
 921     }
 922
 923
 924     //= DropDownEditControl_Base
 925
 926
 927     DropDownEditControl::DropDownEditControl( vcl::Window* _pParent, WinBits _nStyle )
 928         :Edit( _pParent, _nStyle )
 929         ,m_pFloatingEdit( nullptr )
 930         ,m_pDropdownButton( nullptr )
 931         ,m_nOperationMode( eStringList )
 932         ,m_bDropdown(false)
 933         ,m_pHelper(nullptr)
 934     {
 935         SetCompoundControl( true );
 936
 937         m_pImplEdit = VclPtr<MultiLineEdit>::Create( this, WB_TABSTOP | WB_IGNORETAB | WB_NOBORDER | (_nStyle & WB_READONLY) );
 938         SetSubEdit( m_pImplEdit );
 939         m_pImplEdit->Show();
 940
 941         if ( _nStyle & WB_DROPDOWN )
 942         {
 943             m_pDropdownButton = VclPtr<PushButton>::Create( this, WB_NOLIGHTBORDER | WB_RECTSTYLE | WB_NOTABSTOP);
 944             m_pDropdownButton->SetSymbol(SymbolType::SPIN_DOWN);
 945             m_pDropdownButton->SetClickHdl( LINK( this, DropDownEditControl, DropDownHdl ) );
 946             m_pDropdownButton->Show();
 947         }
 948
 949         m_pFloatingEdit = VclPtr<OMultilineFloatingEdit>::Create(this);
 950
 951         m_pFloatingEdit->SetPopupModeEndHdl( LINK( this, DropDownEditControl, ReturnHdl ) );
 952         m_pFloatingEdit->getEdit().SetReadOnly( ( _nStyle & WB_READONLY ) != 0 );
 953     }
 954
 955
 956     void DropDownEditControl::setControlHelper( CommonBehaviourControlHelper& _rControlHelper )
 957     {
 958         m_pHelper = &_rControlHelper;
 959         m_pFloatingEdit->getEdit().SetModifyHdl( LINK( &_rControlHelper, CommonBehaviourControlHelper, EditModifiedHdl ) );
 960         m_pImplEdit->SetGetFocusHdl( LINK( &_rControlHelper, CommonBehaviourControlHelper, GetFocusHdl ) );
 961         m_pImplEdit->SetModifyHdl( LINK( &_rControlHelper, CommonBehaviourControlHelper, EditModifiedHdl ) );
 962         m_pImplEdit->SetLoseFocusHdl( LINK( &_rControlHelper, CommonBehaviourControlHelper, LoseFocusHdl ) );
 963     }
 964
 965
 966     DropDownEditControl::~DropDownEditControl()
 967     {
 968         disposeOnce();
 969     }
 970
 971     void DropDownEditControl::dispose()
 972     {
 973         SetSubEdit(nullptr);
 974         m_pImplEdit.disposeAndClear();
 975         m_pFloatingEdit.disposeAndClear();
 976         m_pDropdownButton.disposeAndClear();
 977         Edit::dispose();
 978     }
 979
 980
 981     void DropDownEditControl::Resize()
 982     {
 983         ::Size aOutSz = GetOutputSizePixel();
 984
 985         if (m_pDropdownButton!=nullptr)
 986         {
 987             long nSBWidth = GetSettings().GetStyleSettings().GetScrollBarSize();
 988             nSBWidth = CalcZoom( nSBWidth );
 989             m_pImplEdit->setPosSizePixel( 0, 1, aOutSz.Width() - nSBWidth, aOutSz.Height()-2 );
 990             m_pDropdownButton->setPosSizePixel( aOutSz.Width() - nSBWidth, 0, nSBWidth, aOutSz.Height() );
 991         }
 992         else
 993             m_pImplEdit->setPosSizePixel( 0, 1, aOutSz.Width(), aOutSz.Height()-2 );
 994     }
 995
 996
 997     bool DropDownEditControl::PreNotify( NotifyEvent& rNEvt )
 998     {
 999         bool bResult = true;
1000
1001         if (rNEvt.GetType() == MouseNotifyEvent::KEYINPUT)
1002         {
1003             const vcl::KeyCode& aKeyCode = rNEvt.GetKeyEvent()->GetKeyCode();
1004             sal_uInt16 nKey = aKeyCode.GetCode();
1005
1006             if ( nKey == KEY_RETURN && !aKeyCode.IsShift() )
1007             {
1008                 if ( m_pHelper )
1009                 {
1010                     m_pHelper->LoseFocusHdl( *m_pImplEdit.get() );
1011                     m_pHelper->activateNextControl();
1012                 }
1013             }
1014             else if ( nKey == KEY_DOWN && aKeyCode.IsMod2() )
1015             {
1016                 Invalidate();
1017                 ShowDropDown( true );
1018             }
1019             else if (   KEYGROUP_CURSOR == aKeyCode.GetGroup()
1020                     ||  nKey == KEY_HELP
1021                     ||  KEYGROUP_FKEYS == aKeyCode.GetGroup()
1022                     ||  m_nOperationMode == eMultiLineText
1023                     )
1024             {
1025                 bResult = Edit::PreNotify( rNEvt );
1026             }
1027             else if ( m_nOperationMode == eStringList )
1028             {
1029                 Selection aSel = m_pImplEdit->GetSelection();
1030                 if ( aSel.Min() != aSel.Max() )
1031                 {
1032                     aSel.Min() = FindPos( aSel.Min() );
1033                     aSel.Max() = FindPos( aSel.Max() );
1034                 }
1035                 else
1036                 {
1037                     aSel.Min() = FindPos( aSel.Min() );
1038                     aSel.Max() = aSel.Min();
1039                 }
1040                 Invalidate();
1041                 ShowDropDown( true );
1042                 m_pFloatingEdit->getEdit().GrabFocus();
1043                 m_pFloatingEdit->getEdit().SetSelection( aSel );
1044                 vcl::Window* pFocusWin = Application::GetFocusWindow();
1045                 pFocusWin->KeyInput( *rNEvt.GetKeyEvent() );
1046             }
1047         }
1048         else
1049             bResult = Edit::PreNotify(rNEvt);
1050
1051         return bResult;
1052     }
1053
1054
1055     namespace
1056     {
1057
1058         StlSyntaxSequence< OUString > lcl_convertMultiLineToList( const OUString& _rCompsedTextWithLineBreaks )
1059         {
1060             sal_Int32 nLines = comphelper::string::getTokenCount(_rCompsedTextWithLineBreaks, '\n');
1061             StlSyntaxSequence< OUString > aStrings( nLines );
1062             if (nLines)
1063             {
1064                 StlSyntaxSequence< OUString >::iterator stringItem = aStrings.begin();
1065                 sal_Int32 nIdx {0};
1066                 do
1067                 {
1068                     *stringItem = _rCompsedTextWithLineBreaks.getToken( 0, '\n', nIdx );
1069                     ++stringItem;
1070                 }
1071                 while (nIdx>0);
1072             }
1073             return aStrings;
1074         }
1075
1076         OUString lcl_convertListToMultiLine( const StlSyntaxSequence< OUString >& _rStrings )
1077         {
1078             OUStringBuffer sMultiLineText;
1079             for (   StlSyntaxSequence< OUString >::const_iterator item = _rStrings.begin();
1080                     item != _rStrings.end();
1081                 )
1082             {
1083                 sMultiLineText.append(*item);
1084                 if ( ++item != _rStrings.end() )
1085                     sMultiLineText.append("\n");
1086             }
1087             return sMultiLineText.makeStringAndClear();
1088         }
1089
1090
1091         OUString lcl_convertListToDisplayText( const StlSyntaxSequence< OUString >& _rStrings )
1092         {
1093             OUStringBuffer aComposed;
1094             for (   StlSyntaxSequence< OUString >::const_iterator strings = _rStrings.begin();
1095                     strings != _rStrings.end();
1096                     ++strings
1097                 )
1098             {
1099                 if ( strings != _rStrings.begin() )
1100                     aComposed.append( ';' );
1101                 aComposed.append( '\"' );
1102                 aComposed.append( *strings );
1103                 aComposed.append( '\"' );
1104             }
1105             return aComposed.makeStringAndClear();
1106         }
1107     }
1108
1109
1110     #define STD_HEIGHT  100
1111     void DropDownEditControl::ShowDropDown( bool bShow )
1112     {
1113         if (bShow)
1114         {
1115             ::Point aMePos= GetPosPixel();
1116             aMePos = GetParent()->OutputToScreenPixel( aMePos );
1117             ::Size aSize=GetSizePixel();
1118             ::tools::Rectangle aRect(aMePos,aSize);
1119             aSize.setHeight( STD_HEIGHT );
1120             m_pFloatingEdit->SetOutputSizePixel(aSize);
1121             m_pFloatingEdit->StartPopupMode( aRect, FloatWinPopupFlags::Down );
1122
1123             m_pFloatingEdit->Show();
1124             m_pFloatingEdit->getEdit().GrabFocus();
1125             m_pFloatingEdit->getEdit().SetSelection(Selection(m_pFloatingEdit->getEdit().GetText().getLength()));
1126             m_bDropdown = true;
1127             if ( m_nOperationMode == eMultiLineText )
1128                 m_pFloatingEdit->getEdit().SetText( m_pImplEdit->GetText() );
1129             m_pImplEdit->SetText("");
1130         }
1131         else
1132         {
1133             m_pFloatingEdit->Hide();
1134             m_pFloatingEdit->Invalidate();
1135             m_pFloatingEdit->Update();
1136
1137             // transfer the text from the floating edit to our own edit
1138             OUString sDisplayText( m_pFloatingEdit->getEdit().GetText() );
1139             if ( m_nOperationMode == eStringList )
1140                 sDisplayText = lcl_convertListToDisplayText( lcl_convertMultiLineToList( sDisplayText ) );
1141
1142             m_pImplEdit->SetText( sDisplayText );
1143             GetParent()->Invalidate( InvalidateFlags::Children );
1144             m_bDropdown = false;
1145             m_pImplEdit->GrabFocus();
1146         }
1147     }
1148
1149
1150     long DropDownEditControl::FindPos(long nSinglePos)
1151     {
1152         long nPos = 0;
1153         OUString aOutput;
1154         OUString aStr = m_pFloatingEdit->getEdit().GetText();
1155         OUString aStr1 = GetText();
1156
1157         if ((nSinglePos == 0) || (nSinglePos == aStr1.getLength()))
1158         {
1159             return nSinglePos;
1160         }
1161
1162         if (!aStr.isEmpty())
1163         {
1164             long nDiff=0;
1165
1166             sal_Int32 nIdx {0};
1167             OUString aInput = aStr.getToken(0, '\n', nIdx );
1168
1169             if (!aInput.isEmpty())
1170             {
1171                 aOutput += "\"" + aInput + "\"";
1172                 nDiff++;
1173             }
1174
1175             if (nSinglePos <= aOutput.getLength())
1176             {
1177                 nPos=nSinglePos-nDiff;
1178             }
1179             else
1180             {
1181                 while (nIdx>0)
1182                 {
1183                     aInput=aStr.getToken(0, '\n', nIdx);
1184                     if (!aInput.isEmpty())
1185                     {
1186                         aOutput += ";\"" + aInput + "\"";
1187                         nDiff += 2;
1188
1189                         if (nSinglePos <= aOutput.getLength())
1190                         {
1191                             nPos=nSinglePos-nDiff;
1192                             break;
1193                         }
1194                     }
1195                 }
1196             }
1197         }
1198         return nPos;
1199     }
1200
1201
1202     IMPL_LINK_NOARG( DropDownEditControl, ReturnHdl, FloatingWindow*, void)
1203     {
1204         OUString aStr = m_pFloatingEdit->getEdit().GetText();
1205         OUString aStr2 = GetText();
1206         ShowDropDown(false);
1207
1208         if (aStr!=aStr2 || ( m_nOperationMode == eStringList ) )
1209         {
1210             if ( m_pHelper )
1211                 m_pHelper->notifyModifiedValue();
1212         }
1213     }
1214
1215
1216     IMPL_LINK_NOARG( DropDownEditControl, DropDownHdl, Button*, void )
1217     {
1218         ShowDropDown(!m_bDropdown);
1219     }
1220
1221
1222     void DropDownEditControl::SetStringListValue( const StlSyntaxSequence< OUString >& _rStrings )
1223     {
1224         SetText( lcl_convertListToDisplayText( _rStrings ) );
1225         m_pFloatingEdit->getEdit().SetText( lcl_convertListToMultiLine( _rStrings ) );
1226     }
1227
1228
1229     StlSyntaxSequence< OUString > DropDownEditControl::GetStringListValue() const
1230     {
1231         return lcl_convertMultiLineToList( m_pFloatingEdit->getEdit().GetText() );
1232     }
1233
1234
1235     void DropDownEditControl::SetTextValue( const OUString& _rText )
1236     {
1237         OSL_PRECOND( m_nOperationMode == eMultiLineText, "DropDownEditControl::SetTextValue: illegal call!" );
1238
1239         m_pFloatingEdit->getEdit().SetText( _rText );
1240         SetText( _rText );
1241     }
1242
1243
1244     OUString DropDownEditControl::GetTextValue() const
1245     {
1246         OSL_PRECOND( m_nOperationMode == eMultiLineText, "DropDownEditControl::GetTextValue: illegal call!" );
1247         return GetText();
1248     }
1249
1250
1251     //= OMultilineEditControl
1252
1253
1254     OMultilineEditControl::OMultilineEditControl( vcl::Window* pParent, MultiLineOperationMode _eMode, WinBits nWinStyle )
1255         :OMultilineEditControl_Base( _eMode == eMultiLineText ? PropertyControlType::MultiLineTextField : PropertyControlType::StringListField
1256                                    , pParent
1257                                    , ( nWinStyle | WB_DIALOGCONTROL ) & ( ~WB_READONLY | ~WB_DROPDOWN )
1258                                    , false )
1259     {
1260         getTypedControlWindow()->setOperationMode( _eMode );
1261         getTypedControlWindow()->setControlHelper( *this );
1262     }
1263
1264
1265     void SAL_CALL OMultilineEditControl::setValue( const Any& _rValue )
1266     {
1267         impl_checkDisposed_throw();
1268
1269         switch ( getTypedControlWindow()->getOperationMode() )
1270         {
1271         case eMultiLineText:
1272         {
1273             OUString sText;
1274             if ( !( _rValue >>= sText ) && _rValue.hasValue() )
1275                 throw IllegalTypeException();
1276             getTypedControlWindow()->SetTextValue( sText );
1277         }
1278         break;
1279         case eStringList:
1280         {
1281             Sequence< OUString > aStringLines;
1282             if ( !( _rValue >>= aStringLines ) && _rValue.hasValue() )
1283                 throw IllegalTypeException();
1284             getTypedControlWindow()->SetStringListValue( StlSyntaxSequence<OUString>(aStringLines) );
1285         }
1286         break;
1287         }
1288     }
1289
1290
1291     Any SAL_CALL OMultilineEditControl::getValue()
1292     {
1293         impl_checkDisposed_throw();
1294
1295         Any aValue;
1296         switch ( getTypedControlWindow()->getOperationMode() )
1297         {
1298         case eMultiLineText:
1299             aValue <<= getTypedControlWindow()->GetTextValue();
1300             break;
1301         case eStringList:
1302             aValue <<= getTypedControlWindow()->GetStringListValue();
1303             break;
1304         }
1305         return aValue;
1306     }
1307
1308
1309     Type SAL_CALL OMultilineEditControl::getValueType()
1310     {
1311         if ( getTypedControlWindow()->getOperationMode() == eMultiLineText )
1312             return ::cppu::UnoType<OUString>::get();
1313         return cppu::UnoType<Sequence< OUString >>::get();
1314     }
1315
1316
1317 } // namespace pcr
1318
1319
1320 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */