[Compbench-devel] CompBenchmarks++/Qt-4/Package PackageHolder.cpp, NONE, 1.1 PackageHolder.h, NONE, 1.1 PackageInfo.cpp, NONE, 1.1 PackageInfo.h, NONE, 1.1 PackageList.cpp, NONE, 1.1 PackageList.h, NONE, 1.1 PackageManager.cpp, NONE, 1.1 PackageManager.h, NONE, 1.1

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

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

Added Files:
	PackageHolder.cpp PackageHolder.h PackageInfo.cpp 
	PackageInfo.h PackageList.cpp PackageList.h PackageManager.cpp 
	PackageManager.h 
Log Message:
First import.

--- NEW FILE: PackageManager.cpp ---
#include <Package/PackageManager.h>
#include <QHBoxLayout>

using namespace CQT;

PackageManager::PackageManager(QWidget *parent)
  : QWidget(parent)
{
  QHBoxLayout *lay;
  lay=new QHBoxLayout;
  list=new PackageList;
  lay->addWidget(list);

  /*  list->setSelection(0); */

  info=new PackageInfo();
  lay->addWidget(info);

  setLayout(lay);

  connect(list, SIGNAL(currentItemChanged(QListWidgetItem*,
					  QListWidgetItem*)),
	  info, SLOT(doSelectionChanged(QListWidgetItem*,
					QListWidgetItem*)),
	  Qt::QueuedConnection);

  connect(this, SIGNAL(sigPackagesRefresh()),
	  this, SLOT(doPackagesRefresh()),
	  Qt::QueuedConnection);
}

void PackageManager::doPackagesRefresh(void)
{
  list->packagesRefresh();
}

void PackageManager::packagesRefresh(void)
{
  emit sigPackagesRefresh();
}

PackageManager::~PackageManager()
{
}

--- NEW FILE: PackageInfo.h ---
#ifndef H_CQT_PACKAGEINFO
#define H_CQT_PACKAGEINFO

#include <Package/PackageHolder.h>
#include <QListWidget>
#include <QGridLayout>
#include <QLabel>
#include <QLineEdit>
#include <QTextEdit>
#include <QTabWidget>

namespace CQT {

  class PackageInfoTab : public QWidget
  {
    Q_OBJECT
  private:
    QGridLayout *lay;
    int         layIndex;

  protected:
  public:
    PackageInfoTab(QWidget *parent = 0);

    virtual QLineEdit *addInfo(std::string _label,
			       std::string _value);

    virtual QGridLayout *Layout(void);

    virtual ~PackageInfoTab();
  };

  class PackageInfo : public QTabWidget
  {
  Q_OBJECT
  private:
    QLineEdit    *packageName;
    QLineEdit    *packageVersion;
    QLineEdit    *packageLanguage;
    QLineEdit    *packageAuthors;
    QLineEdit    *packageLicense;

    QTextEdit    *packageComments;

    QLineEdit    *packageStatus;
    QLineEdit    *packagePatch;
    QLineEdit    *packageTestsuite;
    QLineEdit    *packageBenchmarks;

    QLineEdit    *packageHomepage;
    QLineEdit    *packageDownloadURL;
  protected:
  protected slots:
    virtual void doSelectionChanged(QListWidgetItem *current,
				    QListWidgetItem *previous);


  public:
    PackageInfo(QWidget *parent = 0);
    virtual ~PackageInfo();
  };

}

#endif

--- NEW FILE: PackageList.cpp ---
#include <QLabel>

#include <main.h>
#include <Package/PackageList.h>
#include <System/System.h>

using namespace CQT;

PackageListContextMenuEvent::PackageListContextMenuEvent(Reason reason,
							 const QPoint &globalPos,
							 CBM::Package *_package)
  : QContextMenuEvent(reason, globalPos),
    PackageHolder(_package)
{
}

PackageListContextMenuEvent::~PackageListContextMenuEvent()
{
}

PackageListContextMenu::PackageListContextMenu(CBM::Package *_package)
  : QMenu("Package management"),
    PackageHolder(_package)
{
  if (Package()->getStatus()<CBM::Package::Preconfigured) {
    addAction(QIcon(":/icons/downloads.png"), "Install",
	      this, SLOT(packageInstall()));
  }
  if (Package()->getStatus()>CBM::Package::Unknown) {
    addAction(QIcon(":/icons/trash.png"), "Uninstall",
	      this, SLOT(packageUninstall()));
  }
}

void PackageListContextMenu::packageInstall(void)
{
  App->packageInstallation(Package());
}

void PackageListContextMenu::packageUninstall(void)
{
  App->packageUninstallation(Package());
}


PackageListContextMenu::~PackageListContextMenu()
{
}

PackageListItem::PackageListItem(CBM::Package *_package)
  : QListWidgetItem(_package->Name().c_str()),
  PackageHolder(_package)
{
  if (Package()->getStatus()<CBM::Package::Preconfigured)
    setIcon(QIcon(":/icons/error.png"));
  else
    setIcon(QIcon(":/icons/success.png"));
}

PackageListItem::~PackageListItem()
{
}

PackageList::PackageList(QWidget *parent)
  : QListWidget(parent)
{
  setContextMenuPolicy(Qt::DefaultContextMenu);

  connect(this, SIGNAL(sigPackagesRefresh()),
	  this, SLOT(doPackagesRefresh()),
	  Qt::QueuedConnection);

  packagesRefresh();
}

void PackageList::packagesRefresh(void)
{
  emit sigPackagesRefresh();
}

void PackageList::contextMenuEvent(QContextMenuEvent *event)
{
  PackageListItem *I = (PackageListItem*) currentItem();
  CBM::Package    *P = 0;

  if (I)
    P=I->Package();

  if (P) {
    PackageListContextMenu m(P);
    m.exec(event->globalPos());
  }
}

long PackageList::bytesToDownload(QList<CBM::Package*> &list)
{
  int          n = list.size();
  int          i;
  CBM::Package *P;
  long         result = 0;

  for(i=0; i<n; i++) {
    P=list[i];
    if (P->getStatus()<CBM::Package::Downloaded) {
      result+=P->Size();
    }
  }

  return(result);
}

void PackageList::doPackagesRefresh(void)
{
  int                i, n;
  CBM::Package       *P;

  int psel = currentRow();

  clear();
  setContextMenuPolicy(Qt::DefaultContextMenu);

  n=CBM::cbmSystem->packageNumber();
  for(i=0; i<n; i++) {
    P=CBM::cbmSystem->Package(i);
    addItem(new PackageListItem(P));
  }
  sortItems();

  setCurrentRow(psel);
}

PackageList::~PackageList()
{
}

--- NEW FILE: PackageList.h ---
#ifndef H_CQT_PACKAGELIST
#define H_CQT_PACKAGELIST

#include <QListWidget>
#include <QMenu>
#include <QContextMenuEvent>

#include <Package/PackageHolder.h>

namespace CQT {

  class PackageListContextMenuEvent : public QContextMenuEvent,
                                      public PackageHolder
  {
   public:
    PackageListContextMenuEvent(Reason reason,
				const QPoint &globalPos,
				CBM::Package *_package);

    virtual ~PackageListContextMenuEvent();
  };

  class PackageListContextMenu : public QMenu,
                                 public PackageHolder
  {
    Q_OBJECT

   protected slots:
    void packageInstall(void);
    void packageUninstall(void);

   public:
    PackageListContextMenu(CBM::Package *_package);

    virtual ~PackageListContextMenu();
  };

  class PackageListItem : public QListWidgetItem,
                          public PackageHolder
  {
   public:
    PackageListItem(CBM::Package *_package);

    virtual ~PackageListItem();
  };

  class PackageList : public QListWidget
  {
    Q_OBJECT
      private:
  protected:
    virtual void contextMenuEvent(QContextMenuEvent *event);
    virtual long bytesToDownload(QList<CBM::Package*> &list);

  signals:
    void sigPackagesRefresh(void);

  public slots:
    void doPackagesRefresh(void);

  public:
    PackageList(QWidget *parent = 0);

    virtual void packagesRefresh(void);

    virtual ~PackageList();
  };
}

#endif

--- NEW FILE: PackageHolder.h ---
#ifndef H_CQT_PACKAGEHOLDER
#define H_CQT_PACKAGEHOLDER

#include <Benchmark/Package.h>

#include <QMetaType>

Q_DECLARE_METATYPE(CBM::Package*)

namespace CQT {

  class PackageHolder {
  private:
    CBM::Package *package;
  protected:
    PackageHolder(CBM::Package *_package);
  public:
    virtual CBM::Package *Package(void);
    virtual ~PackageHolder();
  };

}

#endif

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

using namespace CQT;

PackageHolder::PackageHolder(CBM::Package *_package)
{
  package=_package;
}

CBM::Package *PackageHolder::Package(void)
{
  return(package);
}

PackageHolder::~PackageHolder()
{
}

--- NEW FILE: PackageManager.h ---
#ifndef H_CQT_PACKAGEMANAGER
#define H_CQT_PACKAGEMANAGER

#include <Package/PackageList.h>
#include <Package/PackageInfo.h>


namespace CQT {

  class PackageManager : public QWidget
  {
  Q_OBJECT
  private:
    PackageList  *list;
    PackageInfo  *info;
  protected:
  signals:
    void sigPackagesRefresh(void);

  public slots:
    void doPackagesRefresh(void);
    
  public:
    PackageManager(QWidget *parent = 0);

    virtual void packagesRefresh(void);

    //    virtual void packageSelected(CBM::Package *_package);

    virtual ~PackageManager();
  };

}

#endif

--- NEW FILE: PackageInfo.cpp ---
#include <Package/PackageInfo.h>
#include <Package/PackageList.h>

using namespace CQT;

PackageInfoTab::PackageInfoTab(QWidget *parent)
  : QWidget(parent)
{
  lay=new QGridLayout;

  layIndex=0;
  setLayout(lay);
}

QLineEdit *PackageInfoTab::addInfo(std::string _label,
				   std::string _value)
{
  QLabel      *l;
  QLineEdit   *v;

  l=new QLabel(tr(_label.c_str()));
  v=new QLineEdit(_value.c_str());
  v->setReadOnly(true);
  lay->addWidget(l, layIndex, 0);
  lay->addWidget(v, layIndex, 1);
  layIndex++;
  return(v);
}

QGridLayout *PackageInfoTab::Layout(void)
{
  return(lay);
}

PackageInfoTab::~PackageInfoTab()
{
}

PackageInfo::PackageInfo(QWidget *parent)
  : QTabWidget(parent)
{
  PackageInfoTab *main = new PackageInfoTab();

  addTab(main, "General");
  packageName=main->addInfo("Package :", "");
  packageVersion=main->addInfo("Version :", "");
  packageLanguage=main->addInfo("Language :", "");
  packageAuthors=main->addInfo("Author(s) :", "");
  packageLicense=main->addInfo("License :", "");
 
  PackageInfoTab *comments = new PackageInfoTab();
  addTab(comments, "Comments");
  packageComments = new QTextEdit("");
  packageComments->setReadOnly(true);
  comments->Layout()->addWidget(packageComments, 0, 0);  

  PackageInfoTab *meta = new PackageInfoTab();
  addTab(meta, "Meta-informations");
  packageStatus=meta->addInfo("Status :", "");
  packagePatch=meta->addInfo("Need patch :", "");
  packageTestsuite=meta->addInfo("Embbeded testsuite :", "");
  packageBenchmarks=meta->addInfo("Embbeded benchmarks :", "");

  PackageInfoTab *links = new PackageInfoTab();
  addTab(links, "Links");
  packageHomepage=links->addInfo("Home page :", "");
  packageDownloadURL=links->addInfo("Download URL :", "");
}

void PackageInfo::doSelectionChanged(QListWidgetItem *current,
				     QListWidgetItem *previous)
{

  PackageListItem *I = (PackageListItem*) current;
  CBM::Package    *P;

  if (!I)
    return;

  P=I->Package();

  packageName->setText(P->Name().c_str());
  packageVersion->setText(P->Version().c_str());
  packageLanguage->setText(P->language().c_str());
  packageAuthors->setText(P->author().c_str());
  packageLicense->setText(P->license().c_str());

  packageComments->setText(P->Comments().c_str());

  packageStatus->setText(P->getStatusStr().c_str());
  packagePatch->setText(P->hasPatch() ? "Yes" : "No");
  packageTestsuite->setText(P->hasTest() ? "Yes" : "No");
  QString n;
  n.setNum(P->benchmarkNumber());
  packageBenchmarks->setText(n);

  packageHomepage->setText(P->homePage().c_str());
  packageDownloadURL->setText(P->downloadURL().c_str());
}

PackageInfo::~PackageInfo()
{
}