[Compbench-devel] CompBenchmarks++/Qt-4/Compiler CompilerHolder.cpp, NONE, 1.1 CompilerHolder.h, NONE, 1.1 CompilerInfo.cpp, NONE, 1.1 CompilerInfo.h, NONE, 1.1 CompilerList.cpp, NONE, 1.1 CompilerList.h, NONE, 1.1 CompilerManager.cpp, NONE, 1.1 CompilerManager.h, NONE, 1.1

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

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

Added Files:
	CompilerHolder.cpp CompilerHolder.h CompilerInfo.cpp 
	CompilerInfo.h CompilerList.cpp CompilerList.h 
	CompilerManager.cpp CompilerManager.h 
Log Message:
First import.

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

using namespace CQT;

CompilerHolder::CompilerHolder(CBM::Compiler *_compiler)
{
  compiler=_compiler;
}

CBM::Compiler *CompilerHolder::Compiler(void)
{
  return(compiler);
}

CompilerHolder::~CompilerHolder()
{
}

--- NEW FILE: CompilerHolder.h ---
#ifndef H_CQT_COMPILERHOLDER
#define H_CQT_COMPILERHOLDER

#include <Compiler/Compiler.h>

#include <QMetaType>

Q_DECLARE_METATYPE(CBM::Compiler*)

namespace CQT {

  class CompilerHolder {
  private:
    CBM::Compiler *compiler;
  protected:
    CompilerHolder(CBM::Compiler *_compiler);
  public:
    virtual CBM::Compiler *Compiler(void);
    virtual ~CompilerHolder();
  };

}

#endif

--- NEW FILE: CompilerManager.cpp ---
#include <Compiler/CompilerManager.h>
#include <QHBoxLayout>

using namespace CQT;

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

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

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

  /* info=new CompilerInfo();
     lay->addWidget(info);
  */

  setLayout(lay);

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

  connect(this, SIGNAL(sigCompilersRefresh()),
	  this, SLOT(doCompilersRefresh()),
	  Qt::QueuedConnection);
}

void CompilerManager::doCompilersRefresh(void)
{
  //  list->compilersRefresh();
}

void CompilerManager::doCompilerRegister(CBM::Compiler *_compiler)
{
  list->doCompilerRegister(_compiler);
}

void CompilerManager::doCompilerUnregister(CBM::Compiler *_compiler)
{
  list->doCompilerUnregister(_compiler);
}

void CompilerManager::compilersRefresh(void)
{
  emit sigCompilersRefresh();
}

CompilerManager::~CompilerManager()
{
}

--- NEW FILE: CompilerManager.h ---
#ifndef H_CQT_COMPILERMANAGER
#define H_CQT_COMPILERMANAGER

#include <Compiler/CompilerList.h>
#include <Compiler/CompilerInfo.h>


namespace CQT {

  class CompilerManager : public QWidget
  {
  Q_OBJECT
  private:
    CompilerList  *list;
    CompilerInfo  *info;
  protected:
  signals:
    void sigCompilersRefresh(void);

  public slots:
    void doCompilersRefresh(void);
    void doCompilerRegister(CBM::Compiler *_compiler);
    void doCompilerUnregister(CBM::Compiler *_compiler);

  public:
    CompilerManager(QWidget *parent = 0);

    virtual void compilersRefresh(void);

    virtual ~CompilerManager();
  };

}

#endif

--- NEW FILE: CompilerInfo.cpp ---
#include <Compiler/CompilerInfo.h>
#include <Compiler/CompilerList.h>
#include <Compiler/Compiler-Option-Description.h>

using namespace CQT;

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

  layIndex=0;
  setLayout(lay);
}

QLineEdit *CompilerInfoTab::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 *CompilerInfoTab::Layout(void)
{
  return(lay);
}

CompilerInfoTab::~CompilerInfoTab()
{
}

CompilerInfo::CompilerInfo(QWidget *parent)
  : QTabWidget(parent)
{
  CompilerInfoTab *main = new CompilerInfoTab();

  addTab(main, tr("General"));
  compilerName=main->addInfo(tr("Compiler :").toStdString(), "");
  compilerVersion=main->addInfo(tr("Version :").toStdString(), "");
  compilerLanguage=main->addInfo(tr("Language :").toStdString(), "");
  compilerBinary=main->addInfo(tr("Binary :").toStdString(), "");

  CompilerInfoTab *meta = new CompilerInfoTab();

  addTab(meta, tr("Meta-informations"));
  compilerDescriptionDirectory=meta->addInfo(tr("Nearest compatible branch :").toStdString(),
					     "");

  compilerOptions=meta->addInfo(tr("Option number :").toStdString(),
				"");
  
}

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

  CompilerListItem *I = (CompilerListItem*) current;
  CBM::Compiler    *C;

  if (!I) {
    compilerName->setText("");
    compilerVersion->setText("");
    compilerLanguage->setText("");
    compilerBinary->setText("");
    compilerDescriptionDirectory->setText("");
    return;
  }

  C=I->Compiler();

  compilerName->setText(C->Name().c_str());
  compilerVersion->setText(C->Version().c_str());
  compilerLanguage->setText(C->Language().c_str());
  compilerBinary->setText(C->Binary().c_str());
  compilerDescriptionDirectory->setText(C->relativeDescriptionDirectory().c_str());

  CBM::CompilerOptionDescriptions *OD = C->OptionDescriptions();

  QString n;
  n.setNum(OD->DescriptionNumber());
  compilerOptions->setText(n);
  // delete(OD);
}

CompilerInfo::~CompilerInfo()
{
}

--- NEW FILE: CompilerInfo.h ---
#ifndef H_CQT_COMPILERINFO
#define H_CQT_COMPILERINFO

#include <Compiler/CompilerHolder.h>
#include <QListWidget>
#include <QGridLayout>
#include <QLabel>
#include <QLineEdit>
#include <QTextEdit>
#include <QTabWidget>

namespace CQT {

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

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

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

    virtual QGridLayout *Layout(void);

    virtual ~CompilerInfoTab();
  };

  class CompilerInfo : public QTabWidget
  {
  Q_OBJECT
  private:
    QLineEdit    *compilerName;
    QLineEdit    *compilerVersion;
    QLineEdit    *compilerLanguage;
    QLineEdit    *compilerBinary;

    QLineEdit    *compilerDescriptionDirectory;
    QLineEdit    *compilerOptions;

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


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

}

#endif

--- NEW FILE: CompilerList.h ---
#ifndef H_CQT_COMPILERLIST
#define H_CQT_COMPILERLIST

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

#include <Compiler/CompilerHolder.h>

namespace CQT {

  class CompilerListContextMenuEvent : public QContextMenuEvent,
                                      public CompilerHolder
  {
   public:
    CompilerListContextMenuEvent(Reason        reason,
				 const QPoint  &globalPos,
				 CBM::Compiler *_compiler);

    virtual ~CompilerListContextMenuEvent();
  };

  class CompilerListContextMenu : public QMenu,
                                  public CompilerHolder
  {
    Q_OBJECT

   protected slots:
    void compilerUnregister(void);

  public:
    CompilerListContextMenu(CBM::Compiler *_compiler);

    virtual ~CompilerListContextMenu();
  };

  class CompilerListItem : public QListWidgetItem,
                           public CompilerHolder
  {
   public:
    CompilerListItem(CBM::Compiler *_compiler);

    virtual ~CompilerListItem();
  };

  class CompilerList : public QListWidget
  {
    Q_OBJECT
      private:
  protected:
    virtual void contextMenuEvent(QContextMenuEvent *event);

  signals:
    void sigCompilersRefresh(void);

  public slots:
    void doCompilersRefresh(void);
    void doCompilerRegister(CBM::Compiler *_compiler);
    void doCompilerUnregister(CBM::Compiler *_compiler);

  public:
    CompilerList(QWidget *parent = 0);

    virtual void compilersRefresh(void);

    virtual ~CompilerList();
  };
}

#endif

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

#include <main.h>
#include <Compiler/CompilerList.h>
#include <System/System.h>

using namespace CQT;

CompilerListContextMenuEvent::CompilerListContextMenuEvent(Reason        reason,
							   const QPoint  &globalPos,
							   CBM::Compiler *_compiler)
  : QContextMenuEvent(reason, globalPos),
    CompilerHolder(_compiler)
{
}

CompilerListContextMenuEvent::~CompilerListContextMenuEvent()
{
}

CompilerListContextMenu::CompilerListContextMenu(CBM::Compiler *_compiler)
  : QMenu("Compiler management"),
    CompilerHolder(_compiler)
{

  addAction(QIcon(":/icons/add.png"), "Add",
	    App, SLOT(doCompilerRegisterManual()));

  if (_compiler)
    addAction(QIcon(":/icons/remove.png"), "Remove",
	      this, SLOT(compilerUnregister()));

  addAction(QIcon(":/icons/find.png"), "Auto-detect",
	    App, SLOT(doCompilerAutodetect()));
}

void CompilerListContextMenu::compilerUnregister(void)
{
  App->compilerUnregister(Compiler());
}

CompilerListContextMenu::~CompilerListContextMenu()
{
}

CompilerListItem::CompilerListItem(CBM::Compiler *_compiler)
  : QListWidgetItem(_compiler->Name().c_str()),
  CompilerHolder(_compiler)
{
  /* if (Compiler()->getStatus()<CBM::Compiler::Preconfigured)
     setIcon(QIcon(":/icons/error.png"));
     else
  */
  setIcon(QIcon(":/icons/success.png"));
}

CompilerListItem::~CompilerListItem()
{
}

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

  connect(this, SIGNAL(sigCompilersRefresh()),
	  this, SLOT(doCompilersRefresh()),
	  Qt::QueuedConnection);

  compilersRefresh();
}

void CompilerList::compilersRefresh(void)
{
  emit sigCompilersRefresh();
}

void CompilerList::contextMenuEvent(QContextMenuEvent *event)
{
  CompilerListItem *I = (CompilerListItem*) currentItem();
  CBM::Compiler    *C = 0;

  if (I)
    C=I->Compiler();

  CompilerListContextMenu m(C);
  m.exec(event->globalPos());
}

void CompilerList::doCompilersRefresh(void)
{
  /*
  int                i, n;
  CBM::Compiler       *P;

  int psel = currentRow();

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

  n=CBM::cbmSystem->compilerNumber();
  for(i=0; i<n; i++) {
    P=CBM::cbmSystem->Compiler(i);
    addItem(new CompilerListItem(P));
  }
  sortItems();

  setCurrentRow(psel);
  */
}

void CompilerList::doCompilerRegister(CBM::Compiler *_compiler)
{
  addItem(new CompilerListItem(_compiler));
}

void CompilerList::doCompilerUnregister(CBM::Compiler *_compiler)
{
  int              i, n = count();
  CompilerListItem *I;

  for(i=0;i<n;i++) {
    I=(CompilerListItem*) item(i);
    if (I->Compiler()->Binary()==_compiler->Binary()) {
      I=(CompilerListItem*) takeItem(i);
      delete(I);
      break;
    }
  }
}

CompilerList::~CompilerList()
{
}