framework/source/uielement/spinfieldtoolbarcontroller.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: spinfieldtoolbarcontroller.cxx,v $
  10  * $Revision: 1.9 $
  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_framework.hxx"
  33
  34 #include <stdio.h>
  35 #include <wchar.h>
  36
  37 #ifndef __FRAMEWORK_UIELEMENT_SPINFIELDTOOLBARCONTROLLER_HXX
  38 #include "uielement/spinfieldtoolbarcontroller.hxx"
  39 #endif
  40
  41 //_________________________________________________________________________________________________________________
  42 //      my own includes
  43 //_________________________________________________________________________________________________________________
  44
  45 #ifndef __FRAMEWORK_TOOLBAR_HXX_
  46 #include "uielement/toolbar.hxx"
  47 #endif
  48
  49 //_________________________________________________________________________________________________________________
  50 //      interface includes
  51 //_________________________________________________________________________________________________________________
  52 #include <com/sun/star/util/XURLTransformer.hpp>
  53 #include <com/sun/star/frame/XDispatchProvider.hpp>
  54 #include <com/sun/star/beans/PropertyValue.hpp>
  55 #include <com/sun/star/lang/DisposedException.hpp>
  56 #include <com/sun/star/frame/status/ItemStatus.hpp>
  57 #include <com/sun/star/frame/status/ItemState.hpp>
  58 #include <com/sun/star/frame/status/Visibility.hpp>
  59 #include <com/sun/star/frame/XControlNotificationListener.hpp>
  60
  61 //_________________________________________________________________________________________________________________
  62 //      other includes
  63 //_________________________________________________________________________________________________________________
  64 #include <svtools/toolboxcontroller.hxx>
  65 #include <vos/mutex.hxx>
  66 #include <vcl/svapp.hxx>
  67 #ifndef _VCL_MNEMONIC_HXX_
  68 #include <vcl/mnemonic.hxx>
  69 #endif
  70 #include <tools/urlobj.hxx>
  71 #ifdef WINNT
  72 #include <systools/win32/snprintf.h>
  73 #endif
  74
  75 using namespace ::com::sun::star;
  76 using namespace ::com::sun::star::uno;
  77 using namespace ::com::sun::star::beans;
  78 using namespace ::com::sun::star::lang;
  79 using namespace ::com::sun::star::frame;
  80 using namespace ::com::sun::star::frame::status;
  81 using namespace ::com::sun::star::util;
  82
  83 namespace framework
  84 {
  85
  86 // ------------------------------------------------------------------
  87
  88 // Wrapper class to notify controller about events from combobox.
  89 // Unfortunaltly the events are notifed through virtual methods instead
  90 // of Listeners.
  91
  92 class SpinfieldControl : public SpinField
  93 {
  94     public:
  95         SpinfieldControl( Window* pParent, WinBits nStyle, ISpinfieldListener* pSpinFieldListener );
  96         virtual ~SpinfieldControl();
  97
  98         virtual void Up();
  99         virtual void Down();
 100         virtual void First();
 101         virtual void Last();
 102         virtual void KeyInput( const ::KeyEvent& rKEvt );
 103         virtual void Modify();
 104         virtual void GetFocus();
 105         virtual void LoseFocus();
 106         virtual void StateChanged( StateChangedType nType );
 107         virtual void DataChanged( const DataChangedEvent& rDCEvt );
 108         virtual long PreNotify( NotifyEvent& rNEvt );
 109
 110     private:
 111         ISpinfieldListener* m_pSpinFieldListener;
 112 };
 113
 114 SpinfieldControl::SpinfieldControl( Window* pParent, WinBits nStyle, ISpinfieldListener* pSpinFieldListener ) :
 115     SpinField( pParent, nStyle )
 116     , m_pSpinFieldListener( pSpinFieldListener )
 117 {
 118 }
 119
 120 SpinfieldControl::~SpinfieldControl()
 121 {
 122     m_pSpinFieldListener = 0;
 123 }
 124
 125 void SpinfieldControl::Up()
 126 {
 127     SpinField::Up();
 128     if ( m_pSpinFieldListener )
 129         m_pSpinFieldListener->Up();
 130 }
 131
 132 void SpinfieldControl::Down()
 133 {
 134     SpinField::Down();
 135     if ( m_pSpinFieldListener )
 136         m_pSpinFieldListener->Down();
 137 }
 138
 139 void SpinfieldControl::First()
 140 {
 141     SpinField::First();
 142     if ( m_pSpinFieldListener )
 143         m_pSpinFieldListener->First();
 144 }
 145
 146 void SpinfieldControl::Last()
 147 {
 148     SpinField::First();
 149     if ( m_pSpinFieldListener )
 150         m_pSpinFieldListener->Last();
 151 }
 152
 153 void SpinfieldControl::KeyInput( const ::KeyEvent& rKEvt )
 154 {
 155     SpinField::KeyInput( rKEvt );
 156     if ( m_pSpinFieldListener )
 157         m_pSpinFieldListener->KeyInput( rKEvt );
 158 }
 159
 160 void SpinfieldControl::Modify()
 161 {
 162     SpinField::Modify();
 163     if ( m_pSpinFieldListener )
 164         m_pSpinFieldListener->Modify();
 165 }
 166
 167 void SpinfieldControl::GetFocus()
 168 {
 169     SpinField::GetFocus();
 170     if ( m_pSpinFieldListener )
 171         m_pSpinFieldListener->GetFocus();
 172 }
 173
 174 void SpinfieldControl::LoseFocus()
 175 {
 176     SpinField::GetFocus();
 177     if ( m_pSpinFieldListener )
 178         m_pSpinFieldListener->GetFocus();
 179 }
 180
 181 void SpinfieldControl::StateChanged( StateChangedType nType )
 182 {
 183     SpinField::StateChanged( nType );
 184     if ( m_pSpinFieldListener )
 185         m_pSpinFieldListener->StateChanged( nType );
 186 }
 187
 188 void SpinfieldControl::DataChanged( const DataChangedEvent& rDCEvt )
 189 {
 190     SpinField::DataChanged( rDCEvt );
 191     if ( m_pSpinFieldListener )
 192         m_pSpinFieldListener->DataChanged( rDCEvt );
 193 }
 194
 195 long SpinfieldControl::PreNotify( NotifyEvent& rNEvt )
 196 {
 197     long nRet( 0 );
 198     if ( m_pSpinFieldListener )
 199         nRet = m_pSpinFieldListener->PreNotify( rNEvt );
 200     if ( nRet == 0 )
 201         nRet = SpinField::PreNotify( rNEvt );
 202
 203     return nRet;
 204 }
 205
 206 // ------------------------------------------------------------------
 207
 208 SpinfieldToolbarController::SpinfieldToolbarController(
 209     const Reference< XMultiServiceFactory >& rServiceManager,
 210     const Reference< XFrame >&               rFrame,
 211     ToolBox*                                 pToolbar,
 212     USHORT                                   nID,
 213     sal_Int32                                nWidth,
 214     const ::rtl::OUString&                          aCommand ) :
 215     ComplexToolbarController( rServiceManager, rFrame, pToolbar, nID, aCommand )
 216     ,   m_bFloat( false )
 217     ,   m_bMaxSet( false )
 218     ,   m_bMinSet( false )
 219     ,   m_nMax( 0.0 )
 220     ,   m_nMin( 0.0 )
 221     ,   m_nValue( 0.0 )
 222     ,   m_nStep( 0.0 )
 223     ,   m_pSpinfieldControl( 0 )
 224 {
 225     m_pSpinfieldControl = new SpinfieldControl( m_pToolbar, WB_SPIN|WB_BORDER, this );
 226     if ( nWidth == 0 )
 227         nWidth = 100;
 228
 229     // Calculate height of the spin field according to the application font height
 230     sal_Int32 nHeight = getFontSizePixel( m_pSpinfieldControl ) + 5 + 1;
 231
 232     m_pSpinfieldControl->SetSizePixel( ::Size( nWidth, nHeight ));
 233     m_pToolbar->SetItemWindow( m_nID, m_pSpinfieldControl );
 234 }
 235
 236 // ------------------------------------------------------------------
 237
 238 SpinfieldToolbarController::~SpinfieldToolbarController()
 239 {
 240 }
 241
 242 // ------------------------------------------------------------------
 243
 244 void SAL_CALL SpinfieldToolbarController::dispose()
 245 throw ( RuntimeException )
 246 {
 247     vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() );
 248
 249     m_pToolbar->SetItemWindow( m_nID, 0 );
 250     delete m_pSpinfieldControl;
 251
 252     ComplexToolbarController::dispose();
 253
 254     m_pSpinfieldControl = 0;
 255 }
 256
 257 // ------------------------------------------------------------------
 258 Sequence<PropertyValue> SpinfieldToolbarController::getExecuteArgs(sal_Int16 KeyModifier) const
 259 {
 260     Sequence<PropertyValue> aArgs( 2 );
 261     ::rtl::OUString aSpinfieldText = m_pSpinfieldControl->GetText();
 262
 263     // Add key modifier to argument list
 264     aArgs[0].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "KeyModifier" ));
 265     aArgs[0].Value <<= KeyModifier;
 266     aArgs[1].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Value" ));
 267     if ( m_bFloat )
 268         aArgs[1].Value <<= aSpinfieldText.toDouble();
 269     else
 270         aArgs[1].Value <<= aSpinfieldText.toInt32();
 271     return aArgs;
 272 }
 273
 274 // ------------------------------------------------------------------
 275
 276 void SpinfieldToolbarController::Up()
 277 {
 278     double nValue = m_nValue + m_nStep;
 279     if ( m_bMaxSet && nValue > m_nMax )
 280         return;
 281
 282     m_nValue = nValue;
 283
 284     rtl::OUString aText = impl_formatOutputString( m_nValue );
 285     m_pSpinfieldControl->SetText( aText );
 286     execute( 0 );
 287 }
 288
 289 void SpinfieldToolbarController::Down()
 290 {
 291     double nValue = m_nValue - m_nStep;
 292     if ( m_bMinSet && nValue < m_nMin )
 293         return;
 294
 295     m_nValue = nValue;
 296
 297     rtl::OUString aText = impl_formatOutputString( m_nValue );
 298     m_pSpinfieldControl->SetText( aText );
 299     execute( 0 );
 300 }
 301
 302 void SpinfieldToolbarController::First()
 303 {
 304     if ( m_bMinSet )
 305     {
 306         m_nValue = m_nMin;
 307
 308         rtl::OUString aText = impl_formatOutputString( m_nValue );
 309         m_pSpinfieldControl->SetText( aText );
 310         execute( 0 );
 311     }
 312 }
 313
 314 void SpinfieldToolbarController::Last()
 315 {
 316     if ( m_bMaxSet )
 317     {
 318         m_nValue = m_nMax;
 319
 320         rtl::OUString aText = impl_formatOutputString( m_nValue );
 321         m_pSpinfieldControl->SetText( aText );
 322         execute( 0 );
 323     }
 324 }
 325
 326 void SpinfieldToolbarController::Modify()
 327 {
 328     notifyTextChanged( m_pSpinfieldControl->GetText() );
 329 }
 330
 331 void SpinfieldToolbarController::KeyInput( const ::KeyEvent& /*rKEvt*/ )
 332 {
 333 }
 334
 335 void SpinfieldToolbarController::GetFocus()
 336 {
 337     notifyFocusGet();
 338 }
 339
 340 void SpinfieldToolbarController::LoseFocus()
 341 {
 342     notifyFocusLost();
 343 }
 344
 345 void SpinfieldToolbarController::StateChanged( StateChangedType /*nType*/ )
 346 {
 347 }
 348
 349 void SpinfieldToolbarController::DataChanged( const DataChangedEvent& /*rDCEvt*/ )
 350 {
 351 }
 352
 353 long SpinfieldToolbarController::PreNotify( NotifyEvent& rNEvt )
 354 {
 355     if( rNEvt.GetType() == EVENT_KEYINPUT )
 356     {
 357         const ::KeyEvent* pKeyEvent = rNEvt.GetKeyEvent();
 358         const KeyCode& rKeyCode = pKeyEvent->GetKeyCode();
 359         if(( rKeyCode.GetModifier() | rKeyCode.GetCode()) == KEY_RETURN )
 360         {
 361             // Call execute only with non-empty text
 362             if ( m_pSpinfieldControl->GetText().Len() > 0 )
 363                 execute( rKeyCode.GetModifier() );
 364             return 1;
 365         }
 366     }
 367
 368     return 0;
 369 }
 370
 371 // --------------------------------------------------------
 372
 373 void SpinfieldToolbarController::executeControlCommand( const ::com::sun::star::frame::ControlCommand& rControlCommand )
 374 {
 375     rtl::OUString aValue;
 376     rtl::OUString aMax;
 377     rtl::OUString aMin;
 378     rtl::OUString aStep;
 379     bool          bFloatValue( false );
 380
 381     if ( rControlCommand.Command.equalsAsciiL( "SetStep", 7 ))
 382     {
 383         for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
 384         {
 385             sal_Int32   nValue;
 386             double      fValue;
 387             bool        bFloat( false );
 388
 389             if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "Step", 4 ))
 390             {
 391                 if ( impl_getValue( rControlCommand.Arguments[i].Value, nValue, fValue, bFloat ))
 392                     aStep = bFloat ? ::rtl::OUString::valueOf( fValue ) :
 393                                      ::rtl::OUString::valueOf( nValue );
 394                 break;
 395             }
 396         }
 397     }
 398     else if ( rControlCommand.Command.equalsAsciiL( "SetValue", 8 ))
 399     {
 400         for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
 401         {
 402             if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "Value", 5 ))
 403             {
 404                 sal_Int32   nValue;
 405                 double      fValue;
 406                 bool        bFloat( false );
 407
 408                 if ( impl_getValue( rControlCommand.Arguments[i].Value, nValue, fValue, bFloat ))
 409                 {
 410                     aValue = bFloat ? ::rtl::OUString::valueOf( fValue ) : ::rtl::OUString::valueOf( nValue );
 411                     bFloatValue = bFloat;
 412                 }
 413                 break;
 414             }
 415         }
 416     }
 417     else if ( rControlCommand.Command.equalsAsciiL( "SetValues", 9 ))
 418     {
 419         for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
 420         {
 421             sal_Int32   nValue;
 422             double      fValue;
 423             bool        bFloat( false );
 424
 425             rtl::OUString aName = rControlCommand.Arguments[i].Name;
 426             if ( impl_getValue( rControlCommand.Arguments[i].Value, nValue, fValue, bFloat ))
 427             {
 428                 if ( aName.equalsAsciiL( "Value", 5 ))
 429                 {
 430                     aValue = bFloat ? ::rtl::OUString::valueOf( fValue ) : ::rtl::OUString::valueOf( nValue );
 431                     bFloatValue = bFloat;
 432                 }
 433                 else if ( aName.equalsAsciiL( "Step", 4 ))
 434                     aStep = bFloat ? ::rtl::OUString::valueOf( fValue ) :
 435                                      ::rtl::OUString::valueOf( nValue );
 436                 else if ( aName.equalsAsciiL( "LowerLimit", 10 ))
 437                     aMin = bFloat ? ::rtl::OUString::valueOf( fValue ) :
 438                                     ::rtl::OUString::valueOf( nValue );
 439                 else if ( aName.equalsAsciiL( "UpperLimit", 10 ))
 440                     aMax = bFloat ? ::rtl::OUString::valueOf( fValue ) :
 441                                     ::rtl::OUString::valueOf( nValue );
 442             }
 443             else if ( aName.equalsAsciiL( "OutputFormat", 12 ))
 444                 rControlCommand.Arguments[i].Value >>= m_aOutFormat;
 445         }
 446     }
 447     else if ( rControlCommand.Command.equalsAsciiL( "SetLowerLimit", 13 ))
 448     {
 449         for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
 450         {
 451             sal_Int32   nValue;
 452             double      fValue;
 453             bool        bFloat( false );
 454
 455             if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "LowerLimit", 10 ))
 456             {
 457                 if ( impl_getValue( rControlCommand.Arguments[i].Value, nValue, fValue, bFloat ))
 458                     aMin = bFloat ? ::rtl::OUString::valueOf( fValue ) :
 459                                     ::rtl::OUString::valueOf( nValue );
 460                 break;
 461             }
 462         }
 463     }
 464     else if ( rControlCommand.Command.equalsAsciiL( "SetUpperLimit", 13 ))
 465     {
 466         for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
 467         {
 468             sal_Int32   nValue;
 469             double      fValue;
 470             bool        bFloat( false );
 471
 472             if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "UpperLimit", 10 ))
 473             {
 474                 if ( impl_getValue( rControlCommand.Arguments[i].Value, nValue, fValue, bFloat ))
 475                     aMax = bFloat ? ::rtl::OUString::valueOf( fValue ) :
 476                                     ::rtl::OUString::valueOf( nValue );
 477                 break;
 478             }
 479         }
 480     }
 481     else if ( rControlCommand.Command.equalsAsciiL( "SetOutputFormat", 15 ))
 482     {
 483         for ( sal_Int32 i = 0; i < rControlCommand.Arguments.getLength(); i++ )
 484         {
 485             if ( rControlCommand.Arguments[i].Name.equalsAsciiL( "OutputFormat", 10 ))
 486             {
 487                 rControlCommand.Arguments[i].Value >>= m_aOutFormat;
 488                 break;
 489             }
 490         }
 491     }
 492
 493     // Check values and set members
 494     if ( aValue.getLength() > 0 )
 495     {
 496         m_bFloat = bFloatValue;
 497         m_nValue = aValue.toDouble();
 498
 499         rtl::OUString aOutString = impl_formatOutputString( m_nValue );
 500         m_pSpinfieldControl->SetText( aOutString );
 501         notifyTextChanged( aOutString );
 502     }
 503     if ( aMax.getLength() > 0 )
 504     {
 505         m_nMax = aMax.toDouble();
 506         m_bMaxSet = true;
 507     }
 508     if ( aMin.getLength() > 0 )
 509     {
 510         m_nMin = aMin.toDouble();
 511         m_bMinSet = true;
 512     }
 513     if ( aStep.getLength() > 0 )
 514         m_nStep = aStep.toDouble();
 515 }
 516
 517 bool SpinfieldToolbarController::impl_getValue(
 518     const Any& rAny, sal_Int32& nValue, double& fValue, bool& bFloat )
 519 {
 520     using ::com::sun::star::uno::TypeClass;
 521
 522     bool bValueValid( false );
 523
 524     bFloat = false;
 525     TypeClass aTypeClass = rAny.getValueTypeClass();
 526     if (( aTypeClass == TypeClass( typelib_TypeClass_LONG  )) ||
 527         ( aTypeClass == TypeClass( typelib_TypeClass_SHORT )) ||
 528         ( aTypeClass == TypeClass( typelib_TypeClass_BYTE  )))
 529         bValueValid = rAny >>= nValue;
 530     else if (( aTypeClass == TypeClass( typelib_TypeClass_FLOAT  )) ||
 531              ( aTypeClass == TypeClass( typelib_TypeClass_DOUBLE )))
 532     {
 533         bValueValid = rAny >>= fValue;
 534         bFloat = true;
 535     }
 536
 537     return bValueValid;
 538 }
 539
 540 rtl::OUString SpinfieldToolbarController::impl_formatOutputString( double fValue )
 541 {
 542     if ( m_aOutFormat.getLength() == 0 )
 543     {
 544         if ( m_bFloat )
 545             return rtl::OUString::valueOf( fValue );
 546         else
 547             return rtl::OUString::valueOf( sal_Int32( fValue ));
 548     }
 549     else
 550     {
 551 #ifdef WNT
 552         sal_Unicode aBuffer[128];
 553
 554         aBuffer[0] = 0;
 555         if ( m_bFloat )
 556             snwprintf( reinterpret_cast<wchar_t *>(aBuffer), 128, reinterpret_cast<const wchar_t *>(m_aOutFormat.getStr()), fValue );
 557         else
 558             snwprintf( reinterpret_cast<wchar_t *>(aBuffer), 128, reinterpret_cast<const wchar_t *>(m_aOutFormat.getStr()), sal_Int32( fValue ));
 559
 560         sal_Int32 nSize = rtl_ustr_getLength( aBuffer );
 561         return rtl::OUString( aBuffer, nSize );
 562 #else
 563         // Currently we have no support for a format string using sal_Unicode. wchar_t
 564         // is 32 bit on Unix platform!
 565         char aBuffer[128];
 566
 567         ::rtl::OString aFormat = OUStringToOString( m_aOutFormat, osl_getThreadTextEncoding() );
 568         if ( m_bFloat )
 569             snprintf( aBuffer, 128, aFormat.getStr(), fValue );
 570         else
 571             snprintf( aBuffer, 128, aFormat.getStr(), static_cast<long>( fValue ));
 572
 573         sal_Int32 nSize = strlen( aBuffer );
 574         rtl::OString aTmp( aBuffer, nSize );
 575         return rtl::OStringToOUString( aTmp, osl_getThreadTextEncoding() );
 576 #endif
 577     }
 578 }
 579
 580 } // namespace
 581