Progress.cpp

#include <sys/types.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
/* SPDX-License-Identifier: CC0-1.0 */
#include "Progress.h"
#include "Application.h"
#include "Preference.h"
 
using namespace std;
namespace Isis {
  Progress::Progress() {
    // Get user preferences
    int percent;
    bool printPercent;
    Isis::PvlGroup &group = Isis::Preference::Preferences().findGroup("UserInterface");
    percent = group["ProgressBarPercent"];
    QString temp = (QString) group["ProgressBar"];
    printPercent = temp.toUpper() == "ON";
 
    // Check for an error
    if((percent != 1) && (percent != 2) &&
        (percent != 5) && (percent != 10)) {
      string m = "Invalid preference for [ProgressBarPercent] in ";
      m += "group [UserInterface] must be 1, 2, 5, or 10";
      throw IException(IException::User, m, _FILEINFO_);
    }
 
    // Initialize private variables
    p_text = "Working";
    p_maximumSteps = 0;
    p_currentStep = 0;
    p_currentPercent = 0;
    p_percentIncrement = percent;
    p_printPercent = printPercent;
    p_autoDisplay = true;
  }
 
  Progress::~Progress() {
  }
 
  void Progress::SetText(const QString &text) {
    p_text = text;
  }
 
  QString Progress::Text() const {
    return p_text;
  }
 
  void Progress::SetMaximumSteps(const int steps) {
    if(steps < 0) {
      string m = "Value for [steps] must be greater than ";
      m += "or equal to zero in [Progress::SetMaximumSteps]";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }
    p_maximumSteps = steps;
    p_currentStep = 0;
    p_currentPercent = 0;
  }
 
  void Progress::CheckStatus() {
    // Error check
    //std::cout << p_currentStep << " / " << p_maximumSteps << std::endl;
    if(p_currentStep > p_maximumSteps) {
      string m = "Step exceeds maximumSteps in [Progress::CheckStatus]";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }
 
    if(p_currentStep == 0) {
      if(Isis::iApp != NULL) {
        if (p_autoDisplay) {
          Isis::iApp->UpdateProgress(p_text, p_printPercent);
        }
      }
      else {
        if(p_printPercent && p_autoDisplay) {
          cout << p_text << endl;
        }
      }
    }
 
    // See if the percent processed needs to be updated
    while(100.0 * p_currentStep / p_maximumSteps >= p_currentPercent) {
      if(Isis::iApp != NULL) {
        if (p_autoDisplay) {
          Isis::iApp->UpdateProgress(p_currentPercent, p_printPercent);
        }
      }
      else {
        if(p_printPercent && p_autoDisplay) {
          if(p_currentPercent < 100) {
            cout << p_currentPercent << "% Processed\r" << flush;
          }
          else {
            cout << p_currentPercent << "% Processed" << endl;
          }
        }
      }
      p_currentPercent += p_percentIncrement;
    }
 
    if(p_autoDisplay && Isis::iApp != NULL) {
      Isis::iApp->ProcessGuiEvents();
    }
 
    // Increment to the next step
    p_currentStep++;
 
    return;
  }
 
 
  void Progress::DisableAutomaticDisplay() {
    p_autoDisplay = false;
  }
 
  
  int Progress::MaximumSteps() const {
    return p_maximumSteps;
  }
 
 
  int Progress::CurrentStep() const {
    return p_currentStep;
  }
 
 
  void Progress::AddSteps(const int steps) {
    if(steps == 0) {
      string m = "Value for [steps] must not be zero in [Progress::AddSteps]";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }
 
    p_maximumSteps += steps;
 
    if(p_currentStep > p_maximumSteps) {
      string m = "Step exceeds maximumSteps in [Progress::AddSteps]";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }
 
    if(p_maximumSteps <= 0) {
      string m = "Maximum steps must be greater than zero in [Progress::AddSteps]";
      throw IException(IException::Programmer, m, _FILEINFO_);
    }
  }
} // end namespace isis