sc/inc/progress.hxx

   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: progress.hxx,v $
  10  * $Revision: 1.3.32.1 $
  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 #ifndef SC_PROGRESS_HXX
  32 #define SC_PROGRESS_HXX
  33
  34 #include <sfx2/progress.hxx>
  35 #include "scdllapi.h"
  36
  37 class ScDocument;
  38
  39 class SC_DLLPUBLIC ScProgress
  40 {
  41 private:
  42         static  SfxProgress*    pGlobalProgress;
  43         static  ULONG                   nGlobalRange;
  44         static  ULONG                   nGlobalPercent;
  45         static  BOOL                    bGlobalNoUserBreak;
  46         static  ScProgress*             pInterpretProgress;
  47         static  ScProgress*             pOldInterpretProgress;
  48         static  ULONG                   nInterpretProgress;
  49         static  BOOL                    bAllowInterpretProgress;
  50         static  ScDocument*             pInterpretDoc;
  51         static  BOOL                    bIdleWasDisabled;
  52
  53                         SfxProgress*    pProgress;
  54
  55                                                         // not implemented
  56                                                         ScProgress( const ScProgress& );
  57                         ScProgress&             operator=( const ScProgress& );
  58
  59         static  void                    CalcGlobalPercent( ULONG nVal )
  60                                                                 {
  61                                                                         nGlobalPercent = nGlobalRange ?
  62                                                                                 nVal * 100 / nGlobalRange : 0;
  63                                                                 }
  64
  65 public:
  66         static  SfxProgress*    GetGlobalSfxProgress() { return pGlobalProgress; }
  67         static  BOOL                    IsUserBreak() { return !bGlobalNoUserBreak; }
  68         static  void                    CreateInterpretProgress( ScDocument* pDoc,
  69                                                                                                         BOOL bWait = TRUE );
  70         static  ScProgress*             GetInterpretProgress() { return pInterpretProgress; }
  71         static  void                    DeleteInterpretProgress();
  72         static  ULONG                   GetInterpretCount() { return nInterpretProgress; }
  73         static  ULONG                   GetGlobalRange()        { return nGlobalRange; }
  74         static  ULONG                   GetGlobalPercent()      { return nGlobalPercent; }
  75
  76                                                         ScProgress( SfxObjectShell* pObjSh,
  77                                                                                  const String& rText,
  78                                                                                  ULONG nRange, BOOL bAllDocs = FALSE,
  79                                                                                  BOOL bWait = TRUE );
  80                                                         ~ScProgress();
  81
  82 #ifdef SC_PROGRESS_CXX
  83                                                         // nur fuer DummyInterpret, sonst nie benutzen!!!
  84                                                         ScProgress();
  85 #endif
  86                                                         // kann NULL sein!
  87                         SfxProgress*    GetSfxProgress() const { return pProgress; }
  88
  89                         BOOL                    SetStateText( ULONG nVal, const String &rVal, ULONG nNewRange = 0 )
  90                                                                 {
  91                                                                         if ( pProgress )
  92                                                                         {
  93                                                                                 if ( nNewRange )
  94                                                                                         nGlobalRange = nNewRange;
  95                                                                                 CalcGlobalPercent( nVal );
  96                                                                                 if ( !pProgress->SetStateText( nVal, rVal, nNewRange ) )
  97                                                                                         bGlobalNoUserBreak = FALSE;
  98                                                                                 return bGlobalNoUserBreak;
  99                                                                         }
 100                                                                         return TRUE;
 101                                                                 }
 102                         BOOL                    SetState( ULONG nVal, ULONG nNewRange = 0 )
 103                                                                 {
 104                                                                         if ( pProgress )
 105                                                                         {
 106                                                                                 if ( nNewRange )
 107                                                                                         nGlobalRange = nNewRange;
 108                                                                                 CalcGlobalPercent( nVal );
 109                                                                                 if ( !pProgress->SetState( nVal, nNewRange ) )
 110                                                                                         bGlobalNoUserBreak = FALSE;
 111                                                                                 return bGlobalNoUserBreak;
 112                                                                         }
 113                                                                         return TRUE;
 114                                                                 }
 115                         BOOL                    SetStateCountDown( ULONG nVal )
 116                                                                 {
 117                                                                         if ( pProgress )
 118                                                                         {
 119                                                                                 CalcGlobalPercent( nGlobalRange - nVal );
 120                                                                                 if ( !pProgress->SetState( nGlobalRange - nVal ) )
 121                                                                                         bGlobalNoUserBreak = FALSE;
 122                                                                                 return bGlobalNoUserBreak;
 123                                                                         }
 124                                                                         return TRUE;
 125                                                                 }
 126                         BOOL                    SetStateOnPercent( ULONG nVal )
 127                                                                 {       // nur wenn Prozent mehr als vorher
 128                                                                         if ( nGlobalRange && (nVal * 100 /
 129                                                                                         nGlobalRange) > nGlobalPercent )
 130                                                                                 return SetState( nVal );
 131                                                                         return TRUE;
 132                                                                 }
 133                         BOOL                    SetStateCountDownOnPercent( ULONG nVal )
 134                                                                 {       // nur wenn Prozent mehr als vorher
 135                                                                         if ( nGlobalRange &&
 136                                                                                         ((nGlobalRange - nVal) * 100 /
 137                                                                                         nGlobalRange) > nGlobalPercent )
 138                                                                                 return SetStateCountDown( nVal );
 139                                                                         return TRUE;
 140                                                                 }
 141                         ULONG                   GetState()
 142                                                                 {
 143                                                                         if ( pProgress )
 144                                                                                 return pProgress->GetState();
 145                                                                         return 0;
 146                                                                 }
 147 };
 148
 149
 150 #endif
 151