LCOV - code coverage report
Current view: top level - extensions/source/propctrlr - standardcontrol.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 686 0.0 %
Date: 2014-04-14 Functions: 0 111 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10