UnoControls/source/controls/progressbar.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 "progressbar.hxx"
  21
  22 #include <com/sun/star/awt/GradientStyle.hpp>
  23 #include <com/sun/star/awt/RasterOperation.hpp>
  24 #include <com/sun/star/awt/Gradient.hpp>
  25 #include <com/sun/star/awt/XGraphics.hpp>
  26 #include <tools/debug.hxx>
  27 #include <cppuhelper/typeprovider.hxx>
  28
  29 #include <math.h>
  30 #include <limits.h>
  31
  32 using namespace ::cppu                  ;
  33 using namespace ::osl                   ;
  34 using namespace ::rtl                   ;
  35 using namespace ::com::sun::star::uno   ;
  36 using namespace ::com::sun::star::lang  ;
  37 using namespace ::com::sun::star::awt   ;
  38
  39 namespace unocontrols{
  40
  41 //____________________________________________________________________________________________________________
  42 //  construct/destruct
  43 //____________________________________________________________________________________________________________
  44
  45 ProgressBar::ProgressBar( const Reference< XComponentContext >& rxContext )
  46     : BaseControl           (    rxContext                   )
  47     , m_bHorizontal         (    PROGRESSBAR_DEFAULT_HORIZONTAL         )
  48     , m_aBlockSize          (    PROGRESSBAR_DEFAULT_BLOCKDIMENSION     )
  49     , m_nForegroundColor    (    PROGRESSBAR_DEFAULT_FOREGROUNDCOLOR    )
  50     , m_nBackgroundColor    (    PROGRESSBAR_DEFAULT_BACKGROUNDCOLOR    )
  51     , m_nMinRange           (    PROGRESSBAR_DEFAULT_MINRANGE           )
  52     , m_nMaxRange           (    PROGRESSBAR_DEFAULT_MAXRANGE           )
  53     , m_nBlockValue         (    PROGRESSBAR_DEFAULT_BLOCKVALUE         )
  54     , m_nValue              (    PROGRESSBAR_DEFAULT_VALUE              )
  55 {
  56 }
  57
  58 ProgressBar::~ProgressBar()
  59 {
  60 }
  61
  62 //____________________________________________________________________________________________________________
  63 //  XInterface
  64 //____________________________________________________________________________________________________________
  65
  66 Any SAL_CALL ProgressBar::queryInterface( const Type& rType ) throw( RuntimeException )
  67 {
  68     // Attention:
  69     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
  70     Any aReturn ;
  71     Reference< XInterface > xDel = BaseControl::impl_getDelegator();
  72     if ( xDel.is() )
  73     {
  74         // If an delegator exist, forward question to his queryInterface.
  75         // Delegator will ask his own queryAggregation!
  76         aReturn = xDel->queryInterface( rType );
  77     }
  78     else
  79     {
  80         // If an delegator unknown, forward question to own queryAggregation.
  81         aReturn = queryAggregation( rType );
  82     }
  83
  84     return aReturn ;
  85 }
  86
  87 //____________________________________________________________________________________________________________
  88 //  XInterface
  89 //____________________________________________________________________________________________________________
  90
  91 void SAL_CALL ProgressBar::acquire() throw()
  92 {
  93     // Attention:
  94     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
  95
  96     // Forward to baseclass
  97     BaseControl::acquire();
  98 }
  99
 100 //____________________________________________________________________________________________________________
 101 //  XInterface
 102 //____________________________________________________________________________________________________________
 103
 104 void SAL_CALL ProgressBar::release() throw()
 105 {
 106     // Attention:
 107     //  Don't use mutex or guard in this method!!! Is a method of XInterface.
 108
 109     // Forward to baseclass
 110     BaseControl::release();
 111 }
 112
 113 //____________________________________________________________________________________________________________
 114 //  XTypeProvider
 115 //____________________________________________________________________________________________________________
 116
 117 Sequence< Type > SAL_CALL ProgressBar::getTypes() throw( RuntimeException )
 118 {
 119     // Optimize this method !
 120     // We initialize a static variable only one time. And we don't must use a mutex at every call!
 121     // For the first call; pTypeCollection is NULL - for the second call pTypeCollection is different from NULL!
 122     static OTypeCollection* pTypeCollection = NULL ;
 123
 124     if ( pTypeCollection == NULL )
 125     {
 126         // Ready for multithreading; get global mutex for first call of this method only! see before
 127         MutexGuard aGuard( Mutex::getGlobalMutex() );
 128
 129         // Control these pointer again ... it can be, that another instance will be faster then these!
 130         if ( pTypeCollection == NULL )
 131         {
 132             // Create a static typecollection ...
 133             static OTypeCollection aTypeCollection  ( ::getCppuType(( const Reference< XControlModel >*) NULL ) ,
 134                                                       ::getCppuType(( const Reference< XProgressBar  >*) NULL ) ,
 135                                                       BaseControl::getTypes()
 136                                                     );
 137             // ... and set his address to static pointer!
 138             pTypeCollection = &aTypeCollection ;
 139         }
 140     }
 141
 142     return pTypeCollection->getTypes();
 143 }
 144
 145 //____________________________________________________________________________________________________________
 146 //  XAggregation
 147 //____________________________________________________________________________________________________________
 148
 149 Any SAL_CALL ProgressBar::queryAggregation( const Type& aType ) throw( RuntimeException )
 150 {
 151     // Ask for my own supported interfaces ...
 152     // Attention: XTypeProvider and XInterface are supported by OComponentHelper!
 153     Any aReturn ( ::cppu::queryInterface(   aType                                   ,
 154                                             static_cast< XControlModel* > ( this )  ,
 155                                             static_cast< XProgressBar*  > ( this )
 156                                         )
 157                 );
 158
 159     // If searched interface not supported by this class ...
 160     if ( aReturn.hasValue() == sal_False )
 161     {
 162         // ... ask baseclasses.
 163         aReturn = BaseControl::queryAggregation( aType );
 164     }
 165
 166     return aReturn ;
 167 }
 168
 169 //____________________________________________________________________________________________________________
 170 //  XProgressBar
 171 //____________________________________________________________________________________________________________
 172
 173 void SAL_CALL ProgressBar::setForegroundColor( sal_Int32 nColor ) throw( RuntimeException )
 174 {
 175     // Ready for multithreading
 176     MutexGuard  aGuard (m_aMutex) ;
 177
 178     // Safe color for later use.
 179     m_nForegroundColor = nColor ;
 180
 181     // Repaint control
 182     impl_paint ( 0, 0, impl_getGraphicsPeer() ) ;
 183 }
 184
 185 //____________________________________________________________________________________________________________
 186 //  XProgressBar
 187 //____________________________________________________________________________________________________________
 188
 189 void SAL_CALL ProgressBar::setBackgroundColor ( sal_Int32 nColor ) throw( RuntimeException )
 190 {
 191     // Ready for multithreading
 192     MutexGuard  aGuard (m_aMutex) ;
 193
 194     // Safe color for later use.
 195     m_nBackgroundColor = nColor ;
 196
 197     // Repaint control
 198     impl_paint ( 0, 0, impl_getGraphicsPeer() ) ;
 199 }
 200
 201 //____________________________________________________________________________________________________________
 202 //  XProgressBar
 203 //____________________________________________________________________________________________________________
 204
 205 void SAL_CALL ProgressBar::setValue ( sal_Int32 nValue ) throw( RuntimeException )
 206 {
 207     // This method is defined for follow things:
 208     //      1) Values >= _nMinRange
 209     //      2) Values <= _nMaxRange
 210
 211     // Ready for multithreading
 212     MutexGuard aGuard (m_aMutex) ;
 213
 214     // save impossible cases
 215     // This method is only defined for valid values
 216     DBG_ASSERT ( (( nValue >= m_nMinRange ) && ( nValue <= m_nMaxRange )), "ProgressBar::setValue()\nNot valid value.\n" ) ;
 217
 218     // If new value not valid ... do nothing in release version!
 219     if (
 220         ( nValue >= m_nMinRange ) &&
 221         ( nValue <= m_nMaxRange )
 222        )
 223     {
 224         // New value is ok => save this
 225         m_nValue = nValue ;
 226
 227         // Repaint to display changes
 228         impl_paint ( 0, 0, impl_getGraphicsPeer() ) ;
 229     }
 230 }
 231
 232 //____________________________________________________________________________________________________________
 233 //  XProgressBar
 234 //____________________________________________________________________________________________________________
 235
 236 void SAL_CALL ProgressBar::setRange ( sal_Int32 nMin, sal_Int32 nMax ) throw( RuntimeException )
 237 {
 238     // This method is defined for follow things:
 239     //      1) All values of sal_Int32
 240     //      2) Min < Max
 241     //      3) Min > Max
 242
 243     // save impossible cases
 244     // This method is only defined for valid values
 245     // If you ignore this, the release version wil produce an error "division by zero" in "ProgressBar::setValue()"!
 246     DBG_ASSERT ( ( nMin != nMax ) , "ProgressBar::setRange()\nValues for MIN and MAX are the same. This is not allowed!\n" ) ;
 247
 248     // Ready for multithreading
 249     MutexGuard  aGuard (m_aMutex) ;
 250
 251     // control the values for min and max
 252     if ( nMin < nMax )
 253     {
 254         // Take correct Min and Max
 255         m_nMinRange = nMin  ;
 256         m_nMaxRange = nMax  ;
 257     }
 258     else
 259     {
 260         // Change Min and Max automaticly
 261         m_nMinRange = nMax  ;
 262         m_nMaxRange = nMin  ;
 263     }
 264
 265     // assure that m_nValue is within the range
 266     if (!(m_nMinRange < m_nValue  &&  m_nValue < m_nMaxRange))
 267         m_nValue = m_nMinRange;
 268
 269     impl_recalcRange () ;
 270
 271     // Do not repaint the control at this place!!!
 272     // An old "m_nValue" is set and can not be correct for this new range.
 273     // Next call of "ProgressBar::setValue()" do this.
 274 }
 275
 276 //____________________________________________________________________________________________________________
 277 //  XProgressBar
 278 //____________________________________________________________________________________________________________
 279
 280 sal_Int32 SAL_CALL ProgressBar::getValue () throw( RuntimeException )
 281 {
 282     // Ready for multithreading
 283     MutexGuard aGuard (m_aMutex) ;
 284
 285     return ( m_nValue ) ;
 286 }
 287
 288 //____________________________________________________________________________________________________________
 289 //  XWindow
 290 //____________________________________________________________________________________________________________
 291
 292 void SAL_CALL ProgressBar::setPosSize (
 293     sal_Int32 nX,
 294     sal_Int32 nY,
 295     sal_Int32 nWidth,
 296     sal_Int32 nHeight,
 297     sal_Int16 nFlags
 298 ) throw( RuntimeException )
 299 {
 300     // Take old size BEFORE you set the new values at baseclass!
 301     // You will control changes. At the other way, the values are the same!
 302     Rectangle aBasePosSize = getPosSize () ;
 303     BaseControl::setPosSize (nX, nY, nWidth, nHeight, nFlags) ;
 304
 305     // Do only, if size has changed.
 306     if (
 307         ( nWidth  != aBasePosSize.Width     ) ||
 308         ( nHeight != aBasePosSize.Height    )
 309        )
 310     {
 311         impl_recalcRange    (                           ) ;
 312         impl_paint          ( 0, 0, impl_getGraphicsPeer () ) ;
 313     }
 314 }
 315
 316 //____________________________________________________________________________________________________________
 317 //  XControl
 318 //____________________________________________________________________________________________________________
 319
 320 sal_Bool SAL_CALL ProgressBar::setModel( const Reference< XControlModel >& /*xModel*/ ) throw( RuntimeException )
 321 {
 322     // A model is not possible for this control.
 323     return sal_False ;
 324 }
 325
 326 //____________________________________________________________________________________________________________
 327 //  XControl
 328 //____________________________________________________________________________________________________________
 329
 330 Reference< XControlModel > SAL_CALL ProgressBar::getModel() throw( RuntimeException )
 331 {
 332     // A model is not possible for this control.
 333     return Reference< XControlModel >();
 334 }
 335
 336 //____________________________________________________________________________________________________________
 337 //  impl but public method to register service
 338 //____________________________________________________________________________________________________________
 339
 340 const Sequence< OUString > ProgressBar::impl_getStaticSupportedServiceNames()
 341 {
 342     MutexGuard aGuard( Mutex::getGlobalMutex() );
 343     Sequence< OUString > seqServiceNames( 1 );
 344     seqServiceNames.getArray() [0] = SERVICENAME_PROGRESSBAR;
 345     return seqServiceNames ;
 346 }
 347
 348 //____________________________________________________________________________________________________________
 349 //  impl but public method to register service
 350 //____________________________________________________________________________________________________________
 351
 352 const OUString ProgressBar::impl_getStaticImplementationName()
 353 {
 354     return OUString(IMPLEMENTATIONNAME_PROGRESSBAR );
 355 }
 356
 357 //____________________________________________________________________________________________________________
 358 //  protected method
 359 //____________________________________________________________________________________________________________
 360
 361 void ProgressBar::impl_paint ( sal_Int32 nX, sal_Int32 nY, const Reference< XGraphics > & rGraphics )
 362 {
 363     // save impossible cases
 364     DBG_ASSERT ( rGraphics.is(), "ProgressBar::paint()\nCalled with invalid Reference< XGraphics > ." ) ;
 365
 366     // This paint method ist not buffered !!
 367     // Every request paint the completely control. ( but only, if peer exist )
 368      if ( rGraphics.is () )
 369     {
 370         MutexGuard  aGuard (m_aMutex) ;
 371
 372         // Clear background
 373         // (same color for line and fill)
 374         rGraphics->setFillColor ( m_nBackgroundColor                        ) ;
 375         rGraphics->setLineColor ( m_nBackgroundColor                        ) ;
 376         rGraphics->drawRect     ( nX, nY, impl_getWidth(), impl_getHeight() ) ;
 377
 378         // same color for line and fill for blocks
 379         rGraphics->setFillColor ( m_nForegroundColor ) ;
 380         rGraphics->setLineColor ( m_nForegroundColor ) ;
 381
 382         sal_Int32   nBlockStart     =   0                                                                           ;   // = left site of new block
 383         sal_Int32   nBlockCount     =   m_nBlockValue!=0.00 ? (sal_Int32)((m_nValue-m_nMinRange)/m_nBlockValue) : 0 ;   // = number of next block
 384
 385         // Draw horizontal progressbar
 386         // decision in "recalcRange()"
 387         if (m_bHorizontal)
 388         {
 389             // Step to left side of window
 390             nBlockStart = nX ;
 391
 392             for ( sal_Int16 i=1; i<=nBlockCount; ++i )
 393             {
 394                 // step free field
 395                 nBlockStart +=  PROGRESSBAR_FREESPACE   ;
 396                 // paint block
 397                 rGraphics->drawRect (nBlockStart, nY+PROGRESSBAR_FREESPACE, m_aBlockSize.Width, m_aBlockSize.Height) ;
 398                 // step next free field
 399                 nBlockStart +=  m_aBlockSize.Width ;
 400             }
 401         }
 402         // draw vertikal progressbar
 403         // decision in "recalcRange()"
 404         else
 405         {
 406             // step to bottom side of window
 407             nBlockStart  =  nY+impl_getHeight() ;
 408             nBlockStart -=  m_aBlockSize.Height ;
 409
 410             for ( sal_Int16 i=1; i<=nBlockCount; ++i )
 411             {
 412                 // step free field
 413                 nBlockStart -=  PROGRESSBAR_FREESPACE   ;
 414                 // paint block
 415                 rGraphics->drawRect (nX+PROGRESSBAR_FREESPACE, nBlockStart, m_aBlockSize.Width, m_aBlockSize.Height) ;
 416                 // step next free field
 417                 nBlockStart -=  m_aBlockSize.Height;
 418             }
 419         }
 420
 421         // Paint shadow border around the progressbar
 422         rGraphics->setLineColor ( PROGRESSBAR_LINECOLOR_SHADOW                          ) ;
 423         rGraphics->drawLine     ( nX, nY, impl_getWidth(), nY               ) ;
 424         rGraphics->drawLine     ( nX, nY, nX             , impl_getHeight() ) ;
 425
 426         rGraphics->setLineColor ( PROGRESSBAR_LINECOLOR_BRIGHT                                                              ) ;
 427         rGraphics->drawLine     ( impl_getWidth()-1, impl_getHeight()-1, impl_getWidth()-1, nY                  ) ;
 428         rGraphics->drawLine     ( impl_getWidth()-1, impl_getHeight()-1, nX               , impl_getHeight()-1  ) ;
 429     }
 430 }
 431
 432 //____________________________________________________________________________________________________________
 433 //  protected method
 434 //____________________________________________________________________________________________________________
 435
 436 void ProgressBar::impl_recalcRange ()
 437 {
 438     MutexGuard  aGuard (m_aMutex) ;
 439
 440     sal_Int32 nWindowWidth  = impl_getWidth()  ;
 441     sal_Int32 nWindowHeight = impl_getHeight() ;
 442     double    fBlockHeight                     ;
 443     double    fBlockWidth                      ;
 444     double    fMaxBlocks                       ;
 445
 446     if( nWindowWidth > nWindowHeight )
 447     {
 448         m_bHorizontal = sal_True                            ;
 449         fBlockHeight  = (nWindowHeight-(2*PROGRESSBAR_FREESPACE))       ;
 450         fBlockWidth   = fBlockHeight                        ;
 451         fMaxBlocks    = nWindowWidth/(fBlockWidth+PROGRESSBAR_FREESPACE);
 452     }
 453     else
 454     {
 455         m_bHorizontal = sal_False                             ;
 456         fBlockWidth   = (nWindowWidth-(2*PROGRESSBAR_FREESPACE))          ;
 457         fBlockHeight  = fBlockWidth                           ;
 458         fMaxBlocks    = nWindowHeight/(fBlockHeight+PROGRESSBAR_FREESPACE);
 459     }
 460
 461     double fRange       = m_nMaxRange-m_nMinRange    ;
 462     double fBlockValue  = fRange/fMaxBlocks          ;
 463
 464     m_nBlockValue       = fBlockValue            ;
 465     m_aBlockSize.Height = (sal_Int32)fBlockHeight;
 466     m_aBlockSize.Width  = (sal_Int32)fBlockWidth ;
 467 }
 468
 469 }   // namespace unocontrols
 470
 471 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */