2010-06-25    <guravage@caterpie.sen.cwi.nl>

	* tutorial3.pro: Added -Wno-write-strings and -Wno-unused-parameter to QMAKE_CXXFLAGS.

2010-06-23    <guravage@caterpie.sen.cwi.nl>

	* tutorial3.pro: Corrected windows library path.

 *  the Free Software Foundation, either version 3 of the License, or

 *  (at your option) any later version.

 *

 *  The Virtual Leaf is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.

 *

 *  Copyright 2010 Roeland Merks.

 *

 */

#include <QObject>

#include <QtGui>

#include <QString>

#include "simplugin.h"

class Tutorial3 : public QObject, SimPluginInterface {

	Q_OBJECT

	Q_INTERFACES(SimPluginInterface);

public:

	virtual QString ModelID(void);

	// Executed after the cellular mechanics steps have equillibrized

	virtual void CellHouseKeeping (CellBase *c);

	// Differential equations describing transport of chemicals from cell to cell

	virtual void CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2);

	// Differential equations describing chemical reactions taking place at or near the cell walls

	// (e.g. PIN accumulation)

	virtual void WallDynamics(Wall *w, double *dw1, double *dw2);

	// Differential equations describing chemical reactions inside the cells

	virtual void CellDynamics(CellBase *c, double *dchem);

	// to be executed after a cell division

	virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2);

	// to be executed for coloring a cell

	virtual void SetCellColor(CellBase *c, QColor *color);	

	// return number of chemicals

	virtual int NChem(void);

};

2010-06-25    <guravage@caterpie.sen.cwi.nl>

	* tutorial4.pro: Added -Wno-write-strings and -Wno-unused-parameter to QMAKE_CXXFLAGS.

2010-06-23    <guravage@caterpie.sen.cwi.nl>

	* tutorial4.pro: Corrected windows library path.

 *

 *  The Virtual Leaf is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.

 *

 *  Copyright 2010 Roeland Merks.

 *

 */

#include <QObject>

#include <QtGui>

#include <QString>

#include "simplugin.h"

class Tutorial4 : public QObject, SimPluginInterface {

	Q_OBJECT

	Q_INTERFACES(SimPluginInterface);

public:

	virtual QString ModelID(void);

	// Executed after the cellular mechanics steps have equillibrized

	virtual void CellHouseKeeping (CellBase *c);

	// Differential equations describing transport of chemicals from cell to cell

	virtual void CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2);

	// Differential equations describing chemical reactions taking place at or near the cell walls

	// (e.g. PIN accumulation)

	virtual void WallDynamics(Wall *w, double *dw1, double *dw2);

	// Differential equations describing chemical reactions inside the cells

	virtual void CellDynamics(CellBase *c, double *dchem);

	// to be executed after a cell division

	virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2);

	// to be executed for coloring a cell

	virtual void SetCellColor(CellBase *c, QColor *color);	

	// return number of chemicals

	virtual int NChem(void);

	virtual double PINflux(CellBase *this_cell, CellBase *adjacent_cell, Wall *w); 

};

2010-06-25    <guravage@caterpie.sen.cwi.nl>

	* tutorial5.pro: Added -Wno-write-strings and -Wno-unused-parameter to QMAKE_CXXFLAGS.

2010-06-23    <guravage@caterpie.sen.cwi.nl>

	* tutorial5.pro: Corrected windows library path.

 *

 *  The Virtual Leaf is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.

 *

 *  Copyright 2010 Roeland Merks.

 *

 */

#include <QObject>

#include <QtGui>

#include <QString>

#include "simplugin.h"

class Tutorial5 : public QObject, SimPluginInterface {

	Q_OBJECT

	Q_INTERFACES(SimPluginInterface);

public:

	virtual QString ModelID(void);

	// Executed after the cellular mechanics steps have equillibrized

	virtual void CellHouseKeeping (CellBase *c);

	// Differential equations describing transport of chemicals from cell to cell

	virtual void CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2);

	// Differential equations describing chemical reactions taking place at or near the cell walls

	// (e.g. PIN accumulation)

	virtual void WallDynamics(Wall *w, double *dw1, double *dw2);

	// Differential equations describing chemical reactions inside the cells

	virtual void CellDynamics(CellBase *c, double *dchem);

	// to be executed after a cell division

	virtual void OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2);

	// to be executed for coloring a cell

	virtual void SetCellColor(CellBase *c, QColor *color);	

	// return number of chemicals

	virtual int NChem(void);

	virtual double PINflux(CellBase *this_cell, CellBase *adjacent_cell, Wall *w); 

};

dt = 0.1 / double 

rd_dt = 1.0 / double

datadir = . / directory 

movie = false / bool

nit = 100000 / int

maxt = 1000. / double

storage_stride = 10 / int

xml_storage_stride = 500 / int

rseed = -1 / int

#label = / label

#label = <b>Parameters for new chemical</b> / label

#glvproduction = 0. / double

#glvdecay = 0. / double

#glvdiffthreshold = 0. / double

label = / label

label = <b>Meinhardt leaf venation model</b> / label

constituous_expansion_limit = 16 / int

vessel_inh_level = 1 / double

vessel_expansion_rate = 0.25 / double

d = 0. / double

e = 0. / double

f = 0. / double

c = 0. / double

mu = 0. / double

nu = 0. / double

rho0 = 0. / double

rho1 = 0. / double

c0 = 0. / double

gamma = 0. / double

eps = 0. / double

label = / label

label = <b>User-defined parameters</b> / label

k = 0., 0.0, 0.0, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0. / doublelist

i1 = 0 / int

i2 = 0 / int

i3 = 0 / int

i4 = 0 / int

i5 = 0 / int

s1 =  / string

s2 =  / string

s3 =  / string

b1 = false / bool

b2 = false / bool

b3 = false / bool

b4 = false / bool

dir1 = . / directory

dir2 = . / directory

export_interval = 0 / int

#include <QGraphicsItem>

#include <QList>

#include <QDir>

#include <QDebug>

#include <set>

//Added by qt3to4:

#include <Q3ValueList>

#include <Q3PopupMenu>

#include <QMouseEvent>

#include <typeinfo>

#include <cstring>

#include <q3process.h>

#include <qlayout.h>

#include <qspinbox.h>

#include <fstream>

#include <sstream>

#include "pardialog.h"

#include "parameter.h"

#include "canvas.h"

#include "node.h"

#include "nodeset.h"

#include "nodeitem.h"

#include "cellitem.h"

#include "wallitem.h"

#include "mesh.h"

#include "xmlwrite.h"

#include "miscq.h"

#include "OptionFileDialog.h"

#include <cstdlib>

#include <cstdio>

#include "modelcatalogue.h"

#include <algorithm>

// Include VIB and PSB logos

#include "psb.xpm"

#include "cwi.xpm"

static const std::string _module_id("$Id$");

using namespace std;

// We use a global variable to save memory - all the brushes and pens in

// the mesh are shared.

#define QUOTE_ME(s) QUOTE_ME_2NDLEV(s)

#define QUOTE_ME_2NDLEV(s) #s

static QColor dark_red("darkRed");

static const int imageRTTI = 984376;

extern Parameter par;

const QString Main::caption("Virtual leaf");

const QString Main::caption_with_file("Virtual leaf: %1");

FigureEditor::FigureEditor(

			   QGraphicsScene& c, Mesh &m, QWidget* parent,

			   const char* name, Qt::WindowFlags f) :

  QGraphicsView(&c,parent), mesh(m)

{

  intersection_line = 0;

  //angle_line = 0;

  setInteractive(true);

  moving = 0;  

  rotation_mode = false;

}

void FigureEditor::clear()

{

  QList<QGraphicsItem *> list = scene()->items();

  QList<QGraphicsItem *>::Iterator it = list.begin();

  for (; it != list.end(); ++it) {

    delete *it;

  }

}

void FigureEditor::wheelEvent(QWheelEvent *event)

{

  scaleView(pow((double)2, -event->delta() / 240.0));

}

void FigureEditor::scaleView (qreal scaleFactor)

{

  qreal factor = matrix().scale(scaleFactor, scaleFactor).mapRect(QRectF(0, 0, 1, 1)). width();

  if (factor < 0.07 || factor > 100) return;

  scale (scaleFactor, scaleFactor);

}

void FigureEditor::Save(const char *fname, const char *format, int sizex, int sizey)

{

      break;

    }

  }

  return nodeItem;

}

void FigureEditor::insertNode(QPointF p)

{

  Node *node = new Node(p.x(), p.y(), 0);

  mesh.AddNode(node);

  scene()->clearSelection();

  dynamic_cast<Main *>(parent())->Plot();

  FullRedraw();

#ifdef QDEBUG  

  qDebug() << "Node: " << p << endl;

#endif

}

static uint mainCount = 0;

Main::Main(QGraphicsScene& c, Mesh &m, QWidget* parent, const char* name, Qt::WindowFlags f) :

  Q3MainWindow(parent,name,f),

  MainBase(c,m),

  mesh(m)

{

  editor = new FigureEditor(canvas,mesh, this);

#ifdef QDEBUG

  qDebug() << "Interactive = " << editor->isEnabled();

#endif

  working_dir = 0;

  QObject::connect( editor, SIGNAL(MousePressed()), this, SLOT(PauseIfRunning()));

  QObject::connect( editor, SIGNAL(MouseReleased()), this, SLOT(ContIfRunning()));

  QMenuBar* menu = menuBar();

  Q3PopupMenu* file = new Q3PopupMenu( menu );

  file->insertItem("&Read leaf", this, SLOT(readStateXML()));

  file->insertItem("&Save leaf", this, SLOT(saveStateXML()));

  file->insertItem("Snapshot", this, SLOT(snapshot()), Qt::CTRL+Qt::SHIFT+Qt::Key_S);

  file->insertSeparator();

  file->insertItem("Read next leaf", this, SLOT(readNextStateXML()), Qt::Key_PageDown);

  file->insertItem("Read previous leaf", this, SLOT(readPrevStateXML()), Qt::Key_PageUp);

  file->insertItem("Read last leaf", this, SLOT(readLastStateXML()), Qt::Key_End);

  file->insertItem("Read first leaf", this, SLOT(readFirstStateXML()), Qt::Key_Home);

  file->insertSeparator();

  file->insertItem("&Print...", this, SLOT(print()), Qt::CTRL+Qt::Key_P);

  file->insertSeparator();

  file->insertItem("E&xit", qApp, SLOT(quit()), Qt::CTRL+Qt::Key_Q);

  menu->insertItem("&File", file);

  Q3PopupMenu* edit = new Q3PopupMenu( menu );

  edit->insertItem("Reset Chemicals and Transporters", this, SLOT( CleanMesh()), Qt::CTRL+Qt::Key_R );

  edit->insertItem("Reset Chemicals", this, SLOT( CleanMeshChemicals()) );

  edit->insertItem("Reset Transporters", this, SLOT( CleanMeshTransporters()) );

  edit->insertItem("Randomize PIN1 Transporters", this, SLOT( RandomizeMesh()) );

  edit->insertItem("Cut away SAM", this, SLOT( CutSAM() ));

  menu->insertItem("&Edit", edit);

  run = new Q3PopupMenu( menu );

  running = false;

  paused_id = run->insertItem("&Simulation paused", this, SLOT(togglePaused()), Qt::Key_S);

  run->setItemChecked(paused_id, FALSE);

  menu->insertItem("&Run", run);

  view = new Q3PopupMenu( menu );

  view->insertItem("&Zoom in", this, SLOT(zoomIn()), Qt::CTRL+Qt::Key_Equal);

  view->insertItem("Zoom &out", this, SLOT(zoomOut()), Qt::CTRL+Qt::Key_Minus);

  view->insertSeparator();

  com_id = view->insertItem("Show cell &centers", this, SLOT(toggleShowCellCenters()));

  view->setItemChecked(com_id, FALSE);

  mesh_id = view->insertItem("Show &nodes", this, SLOT(toggleShowNodes()), Qt::CTRL+Qt::SHIFT+Qt::Key_N);

  view->setItemChecked(mesh_id, TRUE);

  node_number_id = view->insertItem("Show node numbers", this, SLOT(toggleNodeNumbers()), Qt::CTRL+Qt::SHIFT+Qt::Key_M);

  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);

  editor->setMatrix( m );

}

void Main::zoomOut()

{

  QMatrix m = editor->matrix();

  m.scale( 0.9, 0.9 );

  editor->setMatrix( m );

}

void Main::print()

{

  if ( !printer ) printer = new QPrinter;

  if ( printer->setup(this) ) {

    //    extern Mesh mesh;

    Vector bbll,bbur;

    mesh.BoundingBox(bbll,bbur);

#ifdef QDEBUG

    qDebug() << "bbll = " << bbll << endl;

    qDebug() << "bbur = " << bbur << endl;

#endif

    double cw = (bbur.x - bbll.x);

    double ch = (bbur.y - bbll.y);

    QPainter pp(printer);

    QRect vp=pp.viewport();

#ifdef QDEBUG

    qDebug() << "Paper width = " << vp.width() << " x " << vp.height() << endl;

#endif

    // Note that Cell is also translated...

    pp.translate(-bbur.x,-bbur.y);

    if (cw>ch) {

      pp.scale(vp.width()/(2*cw*Cell::Magnification()), vp.width()/(2*cw*Cell::Magnification()));

    } else {

      pp.scale(vp.height()/(2*ch*Cell::Magnification()), vp.height()/(2*ch*Cell::Magnification()));

    }

    canvas.render(&pp, QRectF(), QRectF(0.,0.,canvas.width(),canvas.height()));

  }

}

void Main::TimeStepWrap(void)

{

  static int t=0;

  TimeStep();

  t++;

  if ((par.export_interval > 0) && ((t % par.export_interval) == 0)){

  }

  // check number of timesteps

  if (t==par.nit) {

    emit SimulationDone();

  }

}

void Main::RestartSim(void)

{

  stopSimulation();

  if ( QMessageBox::question(

			     this,

			     tr("Restart simulation?"),

			     tr("Restart simulation.\n"

				"Are you sure?"),

			     QMessageBox::Yes | QMessageBox::No, QMessageBox::NoButton ) == QMessageBox::Yes ) {

    cerr << "Restarting simulation" << endl;

    //    extern Mesh mesh;

    mesh.Clear();

    Init();

    Plot();

    editor->FullRedraw();

  } 

  //startSimulation();

}

void Main::FitCanvasToWindow(void)

{

  double scale_factor_x = (double)editor->width()/(double)canvas.width();

  double scale_factor_y = (double)editor->height()/(double)canvas.height();

  double scale_factor = scale_factor_x > scale_factor_y ? scale_factor_x : scale_factor_y;

  QMatrix m = editor->matrix();

#ifdef QDEBUG  

  qDebug() << "editor->width() = " << editor->width() << endl;

  qDebug() << "editor->height() = " << editor->height() << endl;

  qDebug() << "scale_factor = " << scale_factor << endl;

  qDebug() << "scale_factor_x = " << scale_factor_x << endl;

  qDebug() << "scale_factor_y = " << scale_factor_y << endl;

#endif

  m.scale( scale_factor, scale_factor );

  editor->setMatrix( m );

  editor->show();

}

void Main::PauseIfRunning(void)

{

  if (running) {

    timer->stop();

  }

  void ExitRotationMode(void)

  { 

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

    options->setItemChecked(rotation_mode_id, false); 

    if (editor)

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

    editor->setMouseTracking(false);

  }

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

  void Refresh(void) { Plot(); }

  void PauseIfRunning(void);

  void ContIfRunning(void);

  virtual void XMLReadSettings(xmlNode *settings);

  private slots:

  void aboutQt();

  void newView();

  void EditParameters();

  void readStateXML();

  int readStateXML(const char *filename, bool geometry = true, bool pars=true, bool simtime = true);

  void readNextStateXML();

  void readPrevStateXML();

  void readFirstStateXML();

  void readLastStateXML();

  void exportCellData();

  void exportCellData(QString);

  void saveStateXML();

  void snapshot();

  void savePars();

  void readPars();

  void clear();

  void init();

  virtual void CutSAM() { MainBase::CutSAM(); Refresh();}

  void enlarge();

  void shrink();

  void zoomIn();

  void zoomOut();

  void CleanMesh();

  void CleanMeshChemicals(void);

  void CleanMeshTransporters(void);

  void RandomizeMesh();

 signals:

  void SimulationDone(void);

  void ParsChanged(void);

 protected:

  Mesh &mesh;

 private:

  NodeSet *node_set;

  FigureEditor *editor;

  Q3PopupMenu* options;

  Q3PopupMenu *view;

  Q3PopupMenu *run;

  QMenu *modelmenu;

  Q3PopupMenu *helpmenu;

  QPrinter* printer;

  const QDir *working_dir;

  QString currentFile;

  //  toggle item states 

  int dbf_id; // options->Double Buffer

  int com_id; // view->Show centers

  int mesh_id; // view->Show mesh

  int node_number_id; // view->Show Node numbers

  int cell_number_id; // view->Show Cell numbers

  int border_id; // view->Show border cells

  int paused_id; // run->Simulation paused

  int cell_axes_id; // view->Show cell axes

  int cell_strain_id; // view->Show cell strain

  int only_boundary_id; // view ->Show only leaf boundary

  int cell_walls_id; // view -> Show transporters

  //int apoplasts_id; // view -> Show apoplasts

  int tooltips_id; // help -> Show Cell Info

  int hide_cells_id; // view->Hide Cells

  double flux_arrow_size;

  int movie_frames_id;

  int fluxes_id;

  int dyn_cells_id;

  int rotation_mode_id;

  int insert_mode_id;

  QTimer *timer;

  QFile *gifanim;

  bool running;

  virtual xmlNode *XMLSettingsTree(void);

  static const QString caption;

  static const QString caption_with_file;

  InfoBar *infobar;

};

/*

 *

 *  This file is part of the Virtual Leaf.

 *

 *  VirtualLeaf is free software: you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation, either version 3 of the License, or

 *  (at your option) any later version.

 *

 *  VirtualLeaf is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.

 *

 *  Copyright 2010 Roeland Merks.

 *

 */

// Do not edit. All edits will be discarded.

#include "parameter.h"

#include <cstdio>

#include <cstring>

#include <cstdlib>

#include <cerrno>

#include <iostream>

#include <sstream>

#include "output.h"

#include "parse.h"

#include "xmlwrite.h"

#include "warning.h"

#include <QLocale>

#include <QDir>

#include <QStringList>

using namespace std;

static const std::string _module_id("$Id$");

Parameter::Parameter() {

  arrowcolor = strdup("white");

  arrowsize = 100;

  textcolor = strdup("red");

  cellnumsize = 1;

  nodenumsize = 1;

  node_mag = 1.0;

  outlinewidth = 1.0;

  cell_outline_color = strdup("forestgreen");

  resize_stride = 0;

  T = 1.0;

  lambda_length = 100.;

  lambda_celllength = 0.;

  target_length = 60.;

  cell_expansion_rate = 1.;

  cell_div_expansion_rate = 0.;

  auxin_dependent_growth = true;

  ode_accuracy = 1e-4;

  mc_stepsize = 0.4;

  mc_cell_stepsize = 0.2;

  energy_threshold = 1000.;

  bend_lambda = 0.;

  alignment_lambda = 0.;

  rel_cell_div_threshold = 2.;

  rel_perimeter_stiffness = 2;

  collapse_node_threshold = 0.05;

  morphogen_div_threshold = 0.2;

  morphogen_expansion_threshold = 0.01;

  copy_wall = true;

  maxt = 1000.;

  storage_stride = 10;

  xml_storage_stride = 500;

  rseed = -1;

  constituous_expansion_limit = 16;

  vessel_inh_level = 1;

  vessel_expansion_rate = 0.25;

  d = 0.;

  e = 0.;

  f = 0.;

  c = 0.;

  mu = 0.;

  nu = 0.;

  rho0 = 0.;

  rho1 = 0.;

  c0 = 0.;

  gamma = 0.;

  eps = 0.;

  k = new double[15];

  k[0] = 0.;

  k[1] = 0.0;

  k[2] = 0.0;

  k[3] = 0.;

  k[4] = 0.;

  k[5] = 0.;

  k[6] = 0.;

  k[7] = 0.;

  k[8] = 0.;

  k[9] = 0.;

  k[10] = 0.;

  k[11] = 0.;

  k[12] = 0.;

  k[13] = 0.;

  k[14] = 0.;

  i1 = 0;

  i2 = 0;

  i3 = 0;

  i4 = 0;

  i5 = 0;

  s1 = strdup("");

  s2 = strdup("");

  s3 = strdup("");

  b1 = false;

  b2 = false;

  b3 = false;

  b4 = false;

  dir1 = strdup(".");

  dir2 = strdup(".");

}

Parameter::~Parameter() {

// destruct parameter object

// free string parameter

CleanUp();

}

void Parameter::CleanUp(void) {

  if (arrowcolor) 

     free(arrowcolor);

  if (textcolor)