toolkit/source/awt/vclxspinbutton.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <toolkit/awt/vclxspinbutton.hxx>
  21 #include <toolkit/helper/property.hxx>
  22 #include <com/sun/star/awt/ScrollBarOrientation.hpp>
  23
  24 #include <vcl/spin.hxx>
  25 #include <vcl/svapp.hxx>
  26 #include "vclxwindows_internal.hxx"
  27
  28 namespace toolkit
  29 {
  30
  31
  32     using namespace ::com::sun::star::uno;
  33     using namespace ::com::sun::star::awt;
  34     using namespace ::com::sun::star::lang;
  35     using namespace ::com::sun::star::beans;
  36
  37
  38     namespace
  39     {
  40         void lcl_modifyStyle( vcl::Window* _pWindow, WinBits _nStyleBits, bool _bShouldBePresent )
  41         {
  42             WinBits nStyle = _pWindow->GetStyle();
  43             if ( _bShouldBePresent )
  44                 nStyle |= _nStyleBits;
  45             else
  46                 nStyle &= ~_nStyleBits;
  47             _pWindow->SetStyle( nStyle );
  48         }
  49     }
  50
  51     VCLXSpinButton::VCLXSpinButton()
  52         :maAdjustmentListeners( *this )
  53     {
  54     }
  55
  56
  57     VCLXSpinButton::~VCLXSpinButton()
  58     {
  59     }
  60
  61
  62     IMPLEMENT_FORWARD_XINTERFACE2( VCLXSpinButton, VCLXWindow, VCLXSpinButton_Base )
  63
  64
  65     IMPLEMENT_FORWARD_XTYPEPROVIDER2( VCLXSpinButton, VCLXWindow, VCLXSpinButton_Base )
  66
  67
  68     void SAL_CALL VCLXSpinButton::dispose( )
  69     {
  70         {
  71             SolarMutexGuard aGuard;
  72
  73             EventObject aDisposeEvent;
  74             aDisposeEvent.Source = *this;
  75             maAdjustmentListeners.disposeAndClear( aDisposeEvent );
  76         }
  77
  78         VCLXWindow::dispose();
  79     }
  80
  81
  82     void SAL_CALL VCLXSpinButton::addAdjustmentListener( const Reference< XAdjustmentListener >& listener )
  83     {
  84         if ( listener.is() )
  85             maAdjustmentListeners.addInterface( listener );
  86     }
  87
  88
  89     void SAL_CALL VCLXSpinButton::removeAdjustmentListener( const Reference< XAdjustmentListener >& listener )
  90     {
  91         if ( listener.is() )
  92             maAdjustmentListeners.removeInterface( listener );
  93     }
  94
  95     namespace
  96     {
  97         typedef void (SpinButton::*SetSpinButtonValue) (long);
  98         typedef long (SpinButton::*GetSpinButtonValue) () const;
  99
 100
 101         void lcl_setSpinButtonValue(vcl::Window* _pWindow, SetSpinButtonValue _pSetter, sal_Int32 _nValue )
 102         {
 103             SolarMutexGuard aGuard;
 104             SpinButton* pSpinButton = static_cast< SpinButton* >( _pWindow );
 105             if ( pSpinButton )
 106                 (pSpinButton->*_pSetter)( _nValue );
 107         }
 108
 109
 110         sal_Int32 lcl_getSpinButtonValue(const vcl::Window* _pWindow, GetSpinButtonValue _pGetter )
 111         {
 112             SolarMutexGuard aGuard;
 113
 114             sal_Int32 nValue = 0;
 115
 116             const SpinButton* pSpinButton = static_cast< const SpinButton* >( _pWindow );
 117             if ( pSpinButton )
 118                 nValue = (pSpinButton->*_pGetter)( );
 119             return nValue;
 120         }
 121     }
 122
 123
 124     void SAL_CALL VCLXSpinButton::setValue( sal_Int32 n )
 125     {
 126         lcl_setSpinButtonValue( GetWindow(), &SpinButton::SetValue, n );
 127     }
 128
 129
 130     void SAL_CALL VCLXSpinButton::setValues( sal_Int32 minValue, sal_Int32 maxValue, sal_Int32 currentValue )
 131     {
 132         SolarMutexGuard aGuard;
 133
 134         setMinimum( minValue );
 135         setMaximum( maxValue );
 136         setValue( currentValue );
 137     }
 138
 139
 140     sal_Int32 SAL_CALL VCLXSpinButton::getValue(  )
 141     {
 142         return lcl_getSpinButtonValue( GetWindow(), &SpinButton::GetValue );
 143     }
 144
 145
 146     void SAL_CALL VCLXSpinButton::setMinimum( sal_Int32 minValue )
 147     {
 148         lcl_setSpinButtonValue( GetWindow(), &SpinButton::SetRangeMin, minValue );
 149     }
 150
 151
 152     void SAL_CALL VCLXSpinButton::setMaximum( sal_Int32 maxValue )
 153     {
 154         lcl_setSpinButtonValue( GetWindow(), &SpinButton::SetRangeMax, maxValue );
 155     }
 156
 157
 158     sal_Int32 SAL_CALL VCLXSpinButton::getMinimum(  )
 159     {
 160         return lcl_getSpinButtonValue( GetWindow(), &SpinButton::GetRangeMin );
 161     }
 162
 163
 164     sal_Int32 SAL_CALL VCLXSpinButton::getMaximum(  )
 165     {
 166         return lcl_getSpinButtonValue( GetWindow(), &SpinButton::GetRangeMax );
 167     }
 168
 169
 170     void SAL_CALL VCLXSpinButton::setSpinIncrement( sal_Int32 spinIncrement )
 171     {
 172         lcl_setSpinButtonValue( GetWindow(), &SpinButton::SetValueStep, spinIncrement );
 173     }
 174
 175
 176     sal_Int32 SAL_CALL VCLXSpinButton::getSpinIncrement(  )
 177     {
 178         return lcl_getSpinButtonValue( GetWindow(), &SpinButton::GetValueStep );
 179     }
 180
 181
 182     void SAL_CALL VCLXSpinButton::setOrientation( sal_Int32 orientation )
 183     {
 184         SolarMutexGuard aGuard;
 185
 186         lcl_modifyStyle( GetWindow(), WB_HSCROLL, orientation == ScrollBarOrientation::HORIZONTAL );
 187     }
 188
 189
 190     sal_Int32 SAL_CALL VCLXSpinButton::getOrientation(  )
 191     {
 192         return  ( 0 != ( GetWindow()->GetStyle() & WB_HSCROLL ) )
 193             ?   ScrollBarOrientation::HORIZONTAL
 194             :   ScrollBarOrientation::VERTICAL;
 195     }
 196
 197
 198     void VCLXSpinButton::ProcessWindowEvent( const VclWindowEvent& _rVclWindowEvent )
 199     {
 200         SolarMutexClearableGuard aGuard;
 201         Reference< XSpinValue > xKeepAlive( this );
 202         VclPtr<SpinButton> pSpinButton = GetAs<SpinButton>();
 203         if ( !pSpinButton )
 204             return;
 205
 206         switch ( _rVclWindowEvent.GetId() )
 207         {
 208             case VclEventId::SpinbuttonUp:
 209             case VclEventId::SpinbuttonDown:
 210                 if ( maAdjustmentListeners.getLength() )
 211                 {
 212                     AdjustmentEvent aEvent;
 213                     aEvent.Source = *this;
 214                     aEvent.Value = pSpinButton->GetValue();
 215
 216                     aGuard.clear();
 217                     maAdjustmentListeners.adjustmentValueChanged( aEvent );
 218                 }
 219                 break;
 220
 221             default:
 222                 xKeepAlive.clear();
 223                 aGuard.clear();
 224                 VCLXWindow::ProcessWindowEvent( _rVclWindowEvent );
 225                 break;
 226         }
 227     }
 228
 229
 230     void SAL_CALL VCLXSpinButton::setProperty( const OUString& PropertyName, const Any& Value )
 231     {
 232         SolarMutexGuard aGuard;
 233
 234         sal_Int32 nValue = 0;
 235         bool  bIsLongValue = ( Value >>= nValue );
 236
 237         if ( GetWindow() )
 238         {
 239             sal_uInt16 nPropertyId = GetPropertyId( PropertyName );
 240             switch ( nPropertyId )
 241             {
 242             case BASEPROPERTY_BACKGROUNDCOLOR:
 243                 // the default implementation of the base class doesn't work here, since our
 244                 // interpretation for this property is slightly different
 245                 setButtonLikeFaceColor( GetWindow(), Value);
 246                 break;
 247
 248             case BASEPROPERTY_SPINVALUE:
 249                 if ( bIsLongValue )
 250                     setValue( nValue );
 251                 break;
 252
 253             case BASEPROPERTY_SPINVALUE_MIN:
 254                 if ( bIsLongValue )
 255                     setMinimum( nValue );
 256                 break;
 257
 258             case BASEPROPERTY_SPINVALUE_MAX:
 259                 if ( bIsLongValue )
 260                     setMaximum( nValue );
 261                 break;
 262
 263             case BASEPROPERTY_SPININCREMENT:
 264                 if ( bIsLongValue )
 265                     setSpinIncrement( nValue );
 266                 break;
 267
 268             case BASEPROPERTY_ORIENTATION:
 269                 if ( bIsLongValue )
 270                     lcl_modifyStyle( GetWindow(), WB_HSCROLL, nValue == ScrollBarOrientation::HORIZONTAL );
 271                 break;
 272
 273             default:
 274                 VCLXWindow::setProperty( PropertyName, Value );
 275             }
 276         }
 277     }
 278
 279
 280     Any SAL_CALL VCLXSpinButton::getProperty( const OUString& PropertyName )
 281     {
 282         SolarMutexGuard aGuard;
 283
 284         Any aReturn;
 285
 286         if ( GetWindow() )
 287         {
 288             sal_uInt16 nPropertyId = GetPropertyId( PropertyName );
 289             switch ( nPropertyId )
 290             {
 291             case BASEPROPERTY_BACKGROUNDCOLOR:
 292                 // the default implementation of the base class doesn't work here, since our
 293                 // interpretation for this property is slightly different
 294                 aReturn = getButtonLikeFaceColor( GetWindow() );
 295                 break;
 296
 297             case BASEPROPERTY_SPINVALUE:
 298                 aReturn <<= getValue( );
 299                 break;
 300
 301             case BASEPROPERTY_SPINVALUE_MIN:
 302                 aReturn <<= getMinimum( );
 303                 break;
 304
 305             case BASEPROPERTY_SPINVALUE_MAX:
 306                 aReturn <<= getMaximum( );
 307                 break;
 308
 309             case BASEPROPERTY_SPININCREMENT:
 310                 aReturn <<= getSpinIncrement( );
 311                 break;
 312
 313             case BASEPROPERTY_ORIENTATION:
 314                 aReturn <<= static_cast<sal_Int32>(   ( 0 != ( GetWindow()->GetStyle() & WB_HSCROLL ) )
 315                     ?   ScrollBarOrientation::HORIZONTAL
 316                     :   ScrollBarOrientation::VERTICAL
 317                     );
 318                 break;
 319
 320             default:
 321                 aReturn = VCLXWindow::getProperty( PropertyName );
 322             }
 323         }
 324         return aReturn;
 325     }
 326
 327
 328 }   // namespace toolkit
 329
 330
 331 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */