[Compbench-devel] CompBenchmarks++/Qt-4/Status Status.cpp, NONE, 1.1 Status.h, NONE, 1.1

[Frederic T. <xf...@us...>]

Update of /cvsroot/compbench/CompBenchmarks++/Qt-4/Status
In directory sc8-pr-cvs4.sourceforge.net:/tmp/cvs-serv15012/Status

Added Files:
	Status.cpp Status.h 
Log Message:
First import.

--- NEW FILE: Status.h ---
#ifndef H_CQT_STATUS
#define H_CQT_STATUS

#include <UI/UI.h>

#include <QWidget>
#include <QPixmap>
#include <QLabel>
#include <QGridLayout>
#include <QProgressBar>

#include <Package/PackageHolder.h>

Q_DECLARE_METATYPE(CBM::UI::State)

namespace CQT {

  class StatusWidget : public QWidget,
		       public CBM::UI
  {
  private:
    Q_OBJECT
    QLabel       *actionLabel;
    QProgressBar *progressBar;
  protected:
    QGridLayout  *layout;

  signals:
    virtual void sigProgressInit(QString what);
    virtual void sigProgress(float _p);
    virtual void sigProgressDone(void);
    virtual void sigUninstall(CBM::UI::State state);

  protected slots:
    virtual void progressInit(QString what);
    virtual void progress(float _p);
    virtual void progressDone(void);
    virtual void uninstall(CBM::UI::State state);

  public:
    StatusWidget(QWidget *parent = 0);

  public:
    virtual void ProgressInit(std::string what);
    virtual void Progress(float _p);
    virtual void ProgressDone(void);

    virtual int Information(CBM::UI::Info type,
			    std::string   msg,
			    CBM::UI::State state,
			    float _progress = 0);

  public:
    virtual ~StatusWidget();
  };

  class StatusLedText : public QWidget {
  private:
    Q_OBJECT

  public:
    typedef enum { Waiting,
		   Running,
		   OK,
                   KO } LedColor;
  private:
    QPixmap  pixmapWaiting;
    QPixmap  pixmapOK;
    QPixmap  pixmapKO;
    QPixmap  pixmapRunning;

    LedColor ledColor;
    QLabel   *icon;
    QLabel   *label;

    QPixmap  *pixmapObject(LedColor _color);

    
  public:
    StatusLedText(std::string _label,
		  LedColor _color = Waiting,
		  QWidget *_parent = 0);

  public slots:
    virtual void changeColor(LedColor _color);

  public:


    virtual ~StatusLedText();
  };

  class StatusInstall : public StatusWidget,
                        public PackageHolder
  {
  private:
    Q_OBJECT
    StatusLedText *ledDownloaded;
    StatusLedText *ledChecksum;
    StatusLedText *ledExtracted;
    StatusLedText *ledPatched;
    StatusLedText *ledPreconfigured;
    int           ledIndex;

    StatusLedText *ledCreate(std::string _label,
			     int         _done);

    CQT::StatusLedText::LedColor colorFor(CBM::UI::State state);

  signals:
    void sigDownload(CBM::UI::State state,
		     float          progress);
    void sigChecksum(CBM::UI::State state);
    void sigExtract(CBM::UI::State state);
    void sigPatch(CBM::UI::State state);
    void sigPreconfigure(CBM::UI::State state,
			 float          progress);

  protected slots:
    void download(CBM::UI::State state,
		  float          _progress);
    void checksum(CBM::UI::State state);
    void extract(CBM::UI::State state);
    void patch(CBM::UI::State state);
    void preconfigure(CBM::UI::State state,
		      float          _progress);

  public:
    StatusInstall(CBM::Package *_package, QWidget *parent = 0);
    
    // virtual void ProgressDone(void);
    virtual int Information(CBM::UI::Info type,
			    std::string   msg,
			    CBM::UI::State state,
			    float _progress = 0);

    ~StatusInstall();
  };
}

#endif

--- NEW FILE: Status.cpp ---
#include <Status/Status.h>

#include <QGridLayout>
#include <QHBoxLayout>
#include <QIcon>

#include <math.h>

using namespace CQT;

StatusWidget::StatusWidget(QWidget *parent)
  : QWidget(parent),
    CBM::UI()
{
  layout = new QGridLayout;

  actionLabel=new QLabel(tr(""));
  layout->addWidget(actionLabel, 0, 0, 1, 2);

  progressBar=new QProgressBar();
  progressBar->setRange(0,100);
  
  layout->addWidget(progressBar, 1, 0, 1, 2);
  setLayout(layout);
  setWindowTitle(tr("Progress"));
  // setWindowModality(Qt::ApplicationModal);

  progressBar->setRange(0,100);
  connect(this, SIGNAL(sigProgressInit(QString)),
	  this, SLOT(progressInit(QString)),
	  Qt::QueuedConnection);

  connect(this, SIGNAL(sigProgress(float)),
	  this, SLOT(progress(float)),
	  Qt::QueuedConnection);

  connect(this, SIGNAL(sigProgressDone()),
	  this, SLOT(progressDone()),
	  Qt::QueuedConnection);

  connect(this, SIGNAL(sigUninstall(CBM::UI::State)),
	  this, SLOT(uninstall(CBM::UI::State)),
	  Qt::QueuedConnection);
}

void StatusWidget::progressInit(QString what)
{
  actionLabel->setText(what);
  progressBar->setValue(0);
}

void StatusWidget::progress(float _p)
{
  int r = (int) round(_p);
  progressBar->setValue(r);
}

void StatusWidget::progressDone(void)
{
  progressBar->setValue(100);
}

void StatusWidget::ProgressInit(std::string what)
{
  emit sigProgressInit(what.c_str());
}

void StatusWidget::Progress(float _p)
{
  emit sigProgress(_p);
}

void StatusWidget::ProgressDone(void)
{
  emit sigProgressDone();
}

void StatusWidget::uninstall(CBM::UI::State state)
{
  actionLabel->setText("Uninstalling package...");
}

int StatusWidget::Information(CBM::UI::Info  type,
			      std::string    msg,
			      CBM::UI::State state,
			      float          _progress)
{
  switch(type) {
  case PackageUninstall:
    emit sigUninstall(state);
    break;
  default:
    break;
  }

  return(0);
}

StatusWidget::~StatusWidget()
{
}

StatusLedText::StatusLedText(std::string _label,
			     LedColor _color,
			     QWidget *_parent)
  : QWidget(_parent)
{
  QHBoxLayout *lay = new QHBoxLayout;

  QIcon I(":/icons/led-yellow.png");
  pixmapWaiting=I.pixmap(12);

  QIcon I2(":/icons/success.png");
  pixmapOK=I2.pixmap(12);

  QIcon I3(":/icons/error.png");
  pixmapKO=I3.pixmap(12);

  QIcon I4(":/icons/arrow-right.png");
  pixmapRunning=I4.pixmap(12);

  icon=new QLabel();
  icon->setPixmap(*pixmapObject(_color));
  lay->addWidget(icon);
  icon->setAlignment(Qt::AlignLeft | Qt::AlignVCenter);

  label=new QLabel(_label.c_str());
  lay->addWidget(label);
  label->setAlignment(Qt::AlignLeft | Qt::AlignVCenter);

  lay->setMargin(2);
  setLayout(lay);
}

QPixmap *StatusLedText::pixmapObject(LedColor _color)
{
  switch(_color) {
  case Waiting:
    return(&pixmapWaiting);
    break;
  case Running:
    return(&pixmapRunning);
    break;
  case OK:
    return(&pixmapOK);
    break;
  case KO:
    return(&pixmapKO);
    break;
  }
  return(0);
}

void StatusLedText::changeColor(LedColor _color)
{
  icon->setPixmap(*pixmapObject(_color));
}


StatusLedText::~StatusLedText()
{
}

StatusInstall::StatusInstall(CBM::Package *_package,
			     QWidget *parent)
  : StatusWidget(parent),
    PackageHolder(_package)
{
  std::string tit = "Installing package ";
  tit+=Package()->Name();
  ProgressInit(tit);
  ledIndex=1;

  ledDownloaded=ledCreate("Downloading",
			  (Package()->getStatus()>=CBM::Package::Downloaded));

  ledChecksum=ledCreate("Checksum",
			(Package()->getStatus()>=CBM::Package::Downloaded));

  ledExtracted=ledCreate("Extracting",
			 (Package()->getStatus()>=CBM::Package::Extracted));
  ledPatched=0;
  if (Package()->hasPatch()) {
    ledPatched=ledCreate("Patching",
       (Package()->getStatus()>=CBM::Package::Patched));
  }


  ledPreconfigured=ledCreate("Preconfiguring",
			     (Package()->getStatus()>=CBM::Package::Preconfigured));

  connect(this, SIGNAL(sigDownload(CBM::UI::State, float)),
	  this, SLOT(download(CBM::UI::State, float)),
	  Qt::QueuedConnection);

  connect(this, SIGNAL(sigChecksum(CBM::UI::State)),
	  this, SLOT(checksum(CBM::UI::State)),
	  Qt::QueuedConnection);

  connect(this, SIGNAL(sigExtract(CBM::UI::State)),
	  this, SLOT(extract(CBM::UI::State)),
	  Qt::QueuedConnection);

  connect(this, SIGNAL(sigPatch(CBM::UI::State)),
	  this, SLOT(patch(CBM::UI::State)),
	  Qt::QueuedConnection);

  connect(this, SIGNAL(sigPreconfigure(CBM::UI::State, float)),
	  this, SLOT(preconfigure(CBM::UI::State, float)),
	  Qt::QueuedConnection);
}


StatusLedText *StatusInstall::ledCreate(std::string _label,
					int         _done)
{
  StatusLedText *R;

  ledIndex++;
  R = new StatusLedText(_label,
			_done ? StatusLedText::OK : StatusLedText::Waiting);

  layout->addWidget(R, ledIndex, 1, 1, 1, Qt::AlignLeft);
  return(R);
}

CQT::StatusLedText::LedColor StatusInstall::colorFor(CBM::UI::State state)
{
  switch(state) {
  case CBM::UI::Start:
  case CBM::UI::Running:
    return(StatusLedText::Running);
    break;
  case CBM::UI::OK:
    return(StatusLedText::OK);
    break;
 case CBM::UI::Failed:
    return(StatusLedText::KO);
    break;
  default:
    return(StatusLedText::Waiting);
  }
  return(StatusLedText::Waiting);
}

void StatusInstall::download(CBM::UI::State state, float _progress)
{
  ledDownloaded->changeColor(colorFor(state));
  if (_progress>0)
    Progress(_progress);
}

void StatusInstall::checksum(CBM::UI::State state)
{
  ledChecksum->changeColor(colorFor(state));
}

void StatusInstall::extract(CBM::UI::State state)
{
  ledExtracted->changeColor(colorFor(state));
}

void StatusInstall::patch(CBM::UI::State state)
{
  ledPatched->changeColor(colorFor(state));
}

void StatusInstall::preconfigure(CBM::UI::State state, float _progress)
{
  ledPreconfigured->changeColor(colorFor(state));
  if (_progress>0)
    Progress(_progress);
}
/*
void StatusInstall::ProgressDone(void)
{
  StatusWidget::ProgressDone();
  emit sigDownloaded();
}
*/

int StatusInstall::Information(CBM::UI::Info  type,
			       std::string    msg,
			       CBM::UI::State state,
			       float          _progress)
{
  switch(type) {
  case Checksum:
    emit sigChecksum(state);
    break;
  case PackageDownload:
    emit sigDownload(state, _progress);
    break;
  case PackageExtract:
    emit sigExtract(state);
    break;
  case PackagePatch:
    emit sigPatch(state);
    break;
  case PackagePreconfigure:
    if (_progress==0)
      Progress(0);
    emit sigPreconfigure(state, _progress);
    break;
  default:
    break;
  }

  return(0);
}

StatusInstall::~StatusInstall()
{
}