extensions/source/propctrlr/standardcontrol.cxx

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