# $Id$

# Set $(MAKE) to the name of the make command on your machine, e.g. 'make' on Linux and 'mingw32-make' on windows.

MAKE =  make # mingw32-make

all: VirtualLeaf libplugin plugins

VirtualLeaf: Makefile.VirtualLeaf

	$(MAKE) -f Makefile.VirtualLeaf

Makefile.VirtualLeaf: VirtualLeaf.pro

	$(QMAKE) -makefile -o $@ $< 

libplugin: Makefile.libplugin

	$(MAKE) -f Makefile.libplugin

Makefile.libplugin: libplugin.pro

	$(QMAKE) -makefile -o $@ $< 

plugins:

	$(MAKE) -C build_models

clean:

	$(MAKE) -f Makefile.libplugin clean

	$(MAKE) -f Makefile.VirtualLeaf clean

	$(MAKE) -C build_models clean

ifeq ($(MAKE),make)

	touch VirtualLeaf.pro

	touch libplugin.pro

endif

#finis

      case 'm':

	modelfile=strdup(optarg);

	if (!modelfile) {

	  throw("Out of memory");

	}

	break;

      case '?':

	break;

      default:

	printf ("?? getopt returned character code 0%o ??\n", c);

      }

    }

    if (optind < argc) {

      printf ("non-option ARGV-elements: ");

      while (optind < argc)

	printf ("%s ", argv[optind++]);

      printf ("\n");

    }

    bool useGUI = !batch;

    qInstallMsgHandler(vlMessageOutput); // custom message handler

    QApplication app(argc,argv,useGUI);

    QPalette tooltippalette = QToolTip::palette();

    QColor transparentcolor = QColor(tooltippalette.brush(QPalette::Window).color());

    tooltippalette.setBrush (QPalette::Window, QBrush (transparentcolor) );

    QToolTip::setPalette( tooltippalette );

    QGraphicsScene canvas(0,0,8000,6000);

    if (useGUI) {

      main_window=new Main(canvas, mesh);

      if ( QApplication::desktop()->width() > ((Main *)main_window)->width() + 10

	   && QApplication::desktop()->height() > ((Main *)main_window)->height() +30 ) {

	((Main *)main_window)->show();

	((Main *)main_window)->resize( ((Main *)main_window)->sizeHint());

      } else {

        ((Main *)main_window)->showMaximized();

      }

    } else {

      main_window=new MainBase(canvas, mesh);

    }

    canvas.setSceneRect(QRectF());

    if (!batch) {

      QObject::connect( qApp, SIGNAL(lastWindowClosed()), qApp, SLOT(quit()) );

    }

    // Install model or read catalogue of models

    ModelCatalogue model_catalogue(&mesh, useGUI?(Main *)main_window:0,modelfile);

    if (useGUI)

      model_catalogue.PopulateModelMenu();

    model_catalogue.InstallFirstModel();

    if (leaffile) 

      main_window->Init(leaffile);

    Cell::SetMagnification(1);

    Cell::setOffset(0,0);

    main_window->FitLeafToCanvas();

    main_window->Plot();

    if (batch) {

      double t=0.;

      do {

	t = main_window->TimeStep();

      } while (t < par.maxt);

    } else

      return app.exec();

  } catch (const char *message) {

    if (batch) { 

      cerr << "Exception caught:" << endl;

      cerr << message << endl;

      abort();

    } else {

      QString qmess=QString("Exception caught: %1").arg(message);

      QMessageBox::critical(0, "Critical Error", qmess);

      abort();

    }

  } catch (ios_base::failure) {

    stringstream error_message;

    error_message << "I/O failure: " << strerror(errno);

    if (batch) {

      cerr << error_message.str() <<endl;

# $Id$

# Set $(MAKE) to the name of the make command on your machine, e.g. 'make' on Linux and 'mingw32-make' on windows.

MAKE = make # mingw32-make

all: plugin_auxingrowth plugin_meinhardt plugin_test

plugin_auxingrowth: Makefile.plugin_auxingrowth

	$(MAKE) -f Makefile.plugin_auxingrowth

Makefile.plugin_auxingrowth: plugin_auxingrowth.pro

	$(QMAKE) -makefile -o $@ $< 

plugin_meinhardt: Makefile.plugin_meinhardt

	$(MAKE) -f Makefile.plugin_meinhardt

Makefile.plugin_meinhardt: plugin_meinhardt.pro

	$(QMAKE) -makefile -o $@ $< 

plugin_test: Makefile.plugin_test

	$(MAKE) -f Makefile.plugin_test

Makefile.plugin_test: plugin_test.pro

	$(QMAKE) -makefile -o $@ $< 

clean:

	$(MAKE) -f Makefile.plugin_auxingrowth clean

	$(MAKE) -f Makefile.plugin_meinhardt clean

	$(MAKE) -f Makefile.plugin_test clean

ifeq ($(MAKE),make)

	touch plugin_auxingrowth.pro

	touch plugin_meinhardt.pro

	touch plugin_test.pro

endif

#finis

  view->setItemChecked(node_number_id, FALSE);

  cell_number_id = view->insertItem("Show cell numbers", this, SLOT(toggleCellNumbers()));

  view->setItemChecked(cell_number_id, FALSE);

  hide_cells_id = view->insertItem("Hide cells", this, SLOT(toggleHideCells()));

  view->setItemChecked(hide_cells_id, FALSE);

  border_id = view->insertItem("Show &border cells", this, SLOT(toggleShowBorderCells()));

  view->setItemChecked(border_id, FALSE);

  cell_axes_id = view->insertItem("Show cell &axes", this, SLOT(toggleCellAxes()));

  cell_strain_id = view->insertItem("Show cell &strain", this, SLOT(toggleCellStrain()));

  view->setItemChecked(cell_axes_id, FALSE);

  fluxes_id = view->insertItem("Show &fluxes", this, SLOT(toggleShowFluxes()));

  view->setItemChecked(fluxes_id, FALSE);

  cell_walls_id = view->insertItem("Show transporters", this, SLOT(toggleShowWalls()));

  view->setItemChecked(cell_walls_id, FALSE);

  apoplasts_id = view->insertItem("Show apoplasts", this, SLOT(toggleShowApoplasts()));

  view->setItemChecked(apoplasts_id, FALSE);

  view->insertSeparator();

  only_boundary_id = view->insertItem("Show only leaf &boundary", this, SLOT(toggleLeafBoundary()));

  view->insertSeparator();

  movie_frames_id = view->insertItem("Start saving movie &frames", this, SLOT(toggleMovieFrames()));

  view->setItemChecked(movie_frames_id, par.movie);

  view->setItemChecked(only_boundary_id, FALSE);

  menu->insertItem("&View", view);

  options = new Q3PopupMenu( menu );

  dyn_cells_id = options->insertItem("Cell growth", this, SLOT(toggleDynCells()));

  options->setItemChecked(dyn_cells_id, true);

  options->insertItem("Edit &parameters", this, SLOT(EditParameters()), Qt::CTRL+Qt::Key_E);

  rotation_mode_id = options->insertItem("Rotate leaf", this, SLOT(EnterRotationMode()), Qt::CTRL + Qt::SHIFT + Qt::Key_R);

  options->setItemChecked(rotation_mode_id, false);

  menu->insertItem("&Options",options);

  // Menu of models

  modelmenu = new QMenu( menu );

  menu->insertItem("&Models", modelmenu);

  menu->insertSeparator();

  helpmenu = new Q3PopupMenu( menu );

  tooltips_id = helpmenu->insertItem("Show Cell&Info", this, SLOT(Refresh()));

  helpmenu->setItemChecked(tooltips_id, true);

  helpmenu->insertSeparator();

  helpmenu->insertSeparator();

  helpmenu->insertItem("&GPL", this, SLOT(gpl()) );

  menu->insertItem("&Help",helpmenu);

  statusBar();

  setCentralWidget(editor);

  printer = 0;

  init();

  // Start timer which repetitively invokes

  // a simulation time step

  timer = new QTimer( this );

  connect( timer, SIGNAL(timeout()), SLOT(TimeStepWrap()) );

  stopSimulation();

  statusBar()->addWidget(new QLabel("Ready."));

  setCaption(caption);

  gifanim = 0;

  infobar = new InfoBar();

  addDockWindow(infobar);

}

void Main::RefreshInfoBar(void)

{

  infobar->SetText(mesh.ModelID());

}

void Main::UserMessage(QString message, int timeout)

{

  statusBar()->showMessage(message, timeout);

}

void Main::init()

{

  clear();

  static int r=24;

  srand(++r);

  mainCount++;

}

Main::~Main()

{

  delete printer;

  if ( !--mainCount ) {

    QStringList xml_files = working_dir->entryList("*.xml");

    QString currentFile_nopath = currentFile.section( '/', -1 );

    QString currentFile_path = currentFile.section( '/', 0, -2 );

    next_file = xml_files.front();

    next_file = currentFile_path+"/"+next_file;

    readStateXML((const char*)next_file);

  }

}

void Main::readStateXML()

{

  //  extern Mesh mesh;

  stopSimulation();

#ifdef QDEBUG

  qDebug() << "Trying to open an OptionFileDialog" << endl;

#endif

  OptionFileDialog *fd = new OptionFileDialog( this, "read dialog", TRUE );

  fd->setMode( OptionFileDialog::ExistingFile );

  fd->setFilter( "XML files (*.xml)");

  if (working_dir) {

    fd->setDir(*working_dir);

  }

  QString fileName;

  if ( fd->exec() == QDialog::Accepted ) {

    fileName = fd->selectedFile();

    if (working_dir) {

      delete working_dir;

    }

    working_dir = fd->dir();

    if (readStateXML((const char *)fileName,fd->readGeometryP(), fd->readParametersP()) )

      return readStateXML(); // user can try again

  }

}

void Main::clear()

{

  editor->clear();

}

{

  static QMessageBox* about = new QMessageBox

    ( "About",

      "<p>"

      "Ghent, Belgium <br>"

      QMessageBox::Information, 1, 0, 0, this, 0, FALSE );

  about->setButtonText( 1, "Dismiss" );

  about->show();

}

#include <string>

#include <fstream>

#include <streambuf>

void Main::gpl()

{

  static QMessageBox* gpl = new QMessageBox ( "License", "", 

      QMessageBox::Information, 1, 0, 0, this, 0, FALSE );

  std::ifstream t("../doc/GPL");

  std::string str;

  t.seekg(0, std::ios::end);   

  str.reserve(t.tellg());

  t.seekg(0, std::ios::beg);

  str.assign((std::istreambuf_iterator<char>(t)),

              std::istreambuf_iterator<char>());

  gpl->setText(QString("<h2>GNU GENERAL PUBLIC LICENSE</h2>"

		       "<h3>Version 2, June 1991</h3>"

                       "<p> Copyright (C) 1989, 1991 Free Software Foundation, Inc. "

                       "59 Temple Place, Suite 330, Boston, MA  02111-1307  USA: "

                       "Everyone is permitted to copy and distribute verbatim copies "

                       "of this license document, but changing it is not allowed.</p>"));

  gpl->setDetailedText(QString(str.c_str()));

  gpl->setButtonText( 1, "Dismiss" );

  gpl->show();

}

void Main::aboutQt(){

  QMessageBox::aboutQt( this, "Virtual Leaf" );

}

void Main::toggleShowCellCenters()

{

  Plot();

}

void Main::toggleShowWalls()

{

  Plot();

}

 private:

  //NodeItem* moving;

  SimItemBase *moving;

  QPointF moving_start;

  QGraphicsLineItem *intersection_line;

  bool rotation_mode;

  bool insert_mode;

  double rot_angle;

};

class Main : public Q3MainWindow, public MainBase {

  Q_OBJECT

    friend class ModelCatalogue; // needs to populate menu item models

 public:

  Main(QGraphicsScene&, Mesh&, QWidget* parent=0, const char* name=0, Qt::WFlags f=0);

  ~Main();

  virtual bool ShowCentersP(void) {return view->isItemChecked(com_id);}

  virtual bool ShowMeshP(void) {return view->isItemChecked(mesh_id);}

  virtual bool ShowBorderCellsP(void) {return view->isItemChecked(border_id);}

  virtual bool PausedP(void) {return run->isItemChecked(paused_id);}

  virtual bool ShowNodeNumbersP(void) {return view->isItemChecked(node_number_id);}

  virtual bool ShowCellNumbersP(void) {return view->isItemChecked(cell_number_id);}

  virtual bool ShowCellAxesP(void) {return view->isItemChecked(cell_axes_id);}

  virtual bool ShowCellStrainP(void) {return view->isItemChecked(cell_strain_id);}

  virtual bool MovieFramesP(void) {return view->isItemChecked(movie_frames_id);}

  virtual bool ShowBoundaryOnlyP(void) {return view->isItemChecked(only_boundary_id);}

  virtual bool ShowWallsP(void) {return view->isItemChecked(cell_walls_id);}

  virtual bool ShowApoplastsP(void) { return view->isItemChecked(apoplasts_id);}

  virtual bool ShowFluxesP(void) { return view->isItemChecked(fluxes_id); }

  virtual bool DynamicCellsP(void) { return options->isItemChecked(dyn_cells_id); }

  virtual bool RotationModeP(void) { return options->isItemChecked(rotation_mode_id); }

  virtual bool InsertModeP(void) { return options->isItemChecked(insert_mode_id); }

  virtual bool ShowToolTipsP(void) { return helpmenu->isItemChecked(tooltips_id); }

  virtual bool HideCellsP(void) { return view->isItemChecked(hide_cells_id); }

  void scale(double factor); 

  virtual double getFluxArrowsize(void)

  {

    return flux_arrow_size;

  }

  void FitCanvasToWindow();

  void FitLeafToCanvas(void);

  public slots:

  void gpl();

  void TimeStepWrap();

  void togglePaused();

  void setFluxArrowSize(int size);

  void RestartSim(void);

  void toggleShowCellCenters(void);

  void toggleShowNodes(void);

  void toggleShowBorderCells(void);

  void toggleShowFluxes(void);

  void toggleNodeNumbers(void);

  void toggleCellNumbers(void);

  void toggleCellAxes(void);

  void toggleCellStrain(void);

  void toggleShowWalls(void);

  void toggleShowApoplasts(void);

  void toggleDynCells(void);

  void toggleMovieFrames(void);

  void toggleLeafBoundary(void);

  void toggleHideCells(void);

  void print();

  void startSimulation(void);

  void stopSimulation(void);

  void RefreshInfoBar(void);

  void EnterRotationMode(void)

  {

    UserMessage("Rotation mode. Click mouse to exit.");

    if (editor) {

      editor->rot_angle = 0. ; 

      // Exit rotation mode if mouse is clicked

      connect(editor, SIGNAL(MousePressed()), this, SLOT(ExitRotationMode()));

    }

  }

  void ExitRotationMode(void)

  { 

    UserMessage("Exited rotation mode.",2000);

    options->setItemChecked(rotation_mode_id, false); 

    if (editor)

      disconnect(editor, SIGNAL(MousePressed()), this, SLOT(ExitRotationMode()));

  }

  virtual void UserMessage(QString message, int timeout=0);

  void Refresh(void) { Plot(); }

  void PauseIfRunning(void);