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

	* VirtualLeaf-install.nsi: Grab gpl3.txt from doc directory.

	* VirtualLeaf-install.nsi: Add VirtualLeaf doc directory.

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

	* gpl3.txt: Moved gpl3.txt from doc to src directory.

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

	* libplugin.pro: Ditto.

	* parameter.cpp: Result of adding datadir changes to make_parameter_source.pl.

	* parameter.h: Ditto.

	* output.h: Declared new function (AppendHomeDirIfPathRelative).

	* output.cpp (AppendHomeDirIfPathRelative): Added new function.

	* canvas.cpp (gpl): Moving gpl3.txt from doc to src obviates the need to docDir.cd("../doc").

	* VirtualLeaf-install.nsi: Grab gpl3.txt from src directory.

	Add missing libiconv/bin, libxml2bin and libz/bin directories.

	Copy libiconv-2.dll, libxml2.dll and zlib1.dll from relative paths.

	* VirtualLeaf.pro: copy gpl3.txt as part of QMAKE_POST_LINK.

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

	* libplugin.pro: Use correct library path.

	* VirtualLeaf.pro: Ditto.

	* VirtualLeaf.cpp (DrawCell): Iterate over NChem to construct info_string.

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

	* simitembase.cpp: Removed NULL assignments to unused variables.

	* VirtualLeaf.cpp: Ditto.

	* apoplastitem.cpp: Ditto.

	* canvas.cpp: Ditto.

	* cell.cpp: Ditto.

	* cellbase.h: Ditto.

	* forwardeuler.cpp: Ditto.

	* mainbase.h: Ditto.

	* nodeitem.cpp: Ditto.

	* qcanvasarrow.h: Ditto.

	* simitembase.cpp: Ditto.

	* Makefile (clean): Add -f Makefile argument to each make invocation.

	* VirtualLeaf-install.nsi: New gpl license text.

	* VirtualLeaf.pro: Disabled console mode.

	* mesh.cpp (Clear): Added parentheses to qDebug statments.

	(TestIllegalWalls): Replaced qDebug().

	* canvas.cpp (mouseReleaseEvent): Replaced qDebug() with cerr since qDebug complains about *node_set.

	* wall.cpp (CorrectWall): Rplaced gDebug() with cerr in transform call and when printing *this.

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

	* Makefile (tutorials): Add tutorials target.

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

	* parameter.cpp: Added particular reassignment of datadir.

	* canvas.cpp (gpl): Added GPL3 License text. Display detail text only if the source text file exists.

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

	* canvas.cpp (gpl): Added gpl slot to display GPL license.

	* VirtualLeaf.pro: Changed default LIBXML2DIR, LIBICONVDIR and LIBZDIR to corresponding distribution lib directories.

	* libplugin.pro: Ditto.

	* Makefile (clean): add if stmt not to `touch` on windows.

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

	* VirtualLeaf.pro: Removed perl references.

	* libplugin.pro: Ditto.

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

	* VirtualLeaf.pro: Removed xmlwritecode.cpp from SOURCES list.

	* xmlwrite.cpp (XMLSave): Removed references to XMLWriteLeafSourceCode and XMLWriteReactionsCode.

	* xmlwrite.h (XMLIO): Ditto!

	* mesh.cpp (findNextBoundaryNode): Initialize Node *next_boundary_node = NULL;

	* xmlwrite.cpp (XMLReadSimtime): Removed unused variable cur

	(XMLReadWalls): viz_flux need not be declared twice; default value of 0.0.

	(XMLReadCells): Removed unused count variable.

	(XMLReadSimtime): Removed unused cur variable.

	(XMLRead): Removed unused v_str variable.

	* simitembase.cpp (userMove): Use assignment merely to obviate compilation warning.

	(SimItemBase) Ditto.

	* qcanvasarrow.h (QGraphicsLineItem): Use assignment merely to obviate compilation warning.

	* output.cpp (OpenWriteFile): Removed unused par variable.

	* nodeitem.cpp (paint): Use assignment merely to obviate compilation warning.

	* forwardeuler.cpp (odeint): Use assignment merely to obviate compilation warning.

	* cell.cpp (DivideOverGivenLine): Use assignment merely to obviate compilation warning.

	* canvas.cpp (FigureEditor): Use assignments merely to obviate compilation errors.

	(mousePressEvent): Removed unused item variable.

	* apoplastitem.cpp

	(ApoplastItem): Removed unused par variable.

	(OnClick): Use NULL assignment merely to obviate compilation warning.

	* mainbase.h (MainBase): Use assignment merely to obviate compilation warning.

	* cellbase.h (CellsStaticDatamembers): Use assignment merely to obviate compilation warning.

	* cell.cpp: Wrapped diagnostic output in QDEBUG blocks.

	* VirtualLeaf.cpp ditto.

	* canvas.cpp ditto.

	* cell.cpp ditto.

	* data_plot.cpp ditto.

	* forwardeuler.cpp ditto.

	* mesh.cpp ditto.

	* mesh.h

	* random.cpp ditto.

	* wall.cpp ditto.

	* wallbase.cpp ditto.

	* wallitem.cpp ditto.

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

	* VirtualLeaf.pro: Removed explicit perl invocation to regerenerate parameter files.

	* libplugin.pro: ditto.

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

	* pardialog.h: Added default versions of this automatically generated file.

	* pardialog.cpp: ditto.

	* parameter.h: ditto.

	* parameter.cpp: ditto.

	* VirtualLeaf.pro: delete/generate  parameter.{h,cpp}and pardialog.{h,cpp} only if perl is installed.

 	* libplugin.pro: dito.

	* Makefile: Added top-level Makefile

2010-05-10    <guravage@caterpie.sen.cwi.nl>

	* VirtualLeaf.pro: Added -fPIC option to QMAKE_CXXFLAGS.

/*

 *

 *  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.

 *

 */

#include <string>

#include <fstream>

#include <streambuf>

#include <QGraphicsScene>

#include <QGraphicsView>

#include <qdatetime.h>

#include <q3mainwindow.h>

#include <qstatusbar.h>

#include <qmessagebox.h>

#include <qmenubar.h>

#include <qapplication.h>

#include <qpainter.h>

#include <qprinter.h>

#include <qlabel.h>

#include <qimage.h>

#include <q3progressdialog.h>

#include <qtimer.h>

#include <qslider.h>

#include <qpixmap.h>

#include <qfile.h>

#include <qdir.h>

#include <q3filedialog.h>

#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$");

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

{

  QImage *image = new QImage(sizex, sizey, QImage::Format_RGB32);

  image->fill(QColor(Qt::white).rgb());

  QPainter *painter=new QPainter(image);

  render(painter);

  image->save(QString(fname),format);

  delete painter;

  delete image;

}

void FigureEditor::mousePressEvent(QMouseEvent* e)

{

  static QList<Node*> selected;

  emit MousePressed();

  //QPointF p = matrix().inverted().map(e->pos());

  QPointF p = mapToScene(e->pos());

#ifdef QDEBUG  

  qDebug() << endl << "MousePressEvent location: (" << p.x() << "," << p.y() << ")." << endl;

  qDebug() << "Magnification:  " << Cell::Magnification() << endl;

  qDebug() << "Offsets:  " << Cell::Offset() << endl;

#endif

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

#ifdef QDEBUG  

  qDebug() << "MousePressEvents, items: " << l.size() << endl;

  qDebug() << "Mouse button modifier: " << e->modifiers() << endl;

#endif

  if (e->button()==Qt::RightButton || l.size()==0) {

    //cerr << "Drawing an intersection line from " << p.x() << ", " << p.y() << endl;

    intersection_line = new QGraphicsLineItem( 0, scene() );

    intersection_line->setPen( QPen( QColor("red"), 3, Qt::DashLine ) );

    intersection_line->setLine( QLineF(p,p) );

    intersection_line->setZValue( 100 );

    intersection_line->show();

  }

  for (QList<QGraphicsItem *>::Iterator it=l.begin(); it!=l.end(); ++it) {

#ifdef QDEBUG

    qDebug() << typeid(**it).name() << endl;

#endif

    if ( !strcmp(typeid(**it).name(),"8NodeItem")) {

      stringstream data_strstream;

      data_strstream << (dynamic_cast<NodeItem*>(*it))->getNode();

      dynamic_cast<Main *>(parent())->UserMessage(QString(data_strstream.str().c_str()));

      (dynamic_cast<NodeItem*>(*it))->OnClick(e->button());

    }

    else 

      if ( !strcmp(typeid(**it).name(),"8CellItem") ) {

	Cell &c=((dynamic_cast<CellItem *>(*it))->getCell());      

	// OnClick to be defined in end-user code

	c.OnClick(e);

      } else {

	if ( !strcmp(typeid(**it).name(),"8WallItem") ) {

	  (dynamic_cast<WallItem *>(*it))->OnClick(e);

	} 

      }

  }

  FullRedraw();

  moving = 0;

}

void FigureEditor::mouseMoveEvent(QMouseEvent* e)

{

  // User chooses "rotation mode" and we can rotate the object around its center of mass

  if (dynamic_cast<Main *>(parent())->RotationModeP()) {

    QPointF p = mapToScene(e->pos());

    p.setX(p.x() / Cell::Magnification());

    p.setY(p.y() / Cell::Magnification());

    // get object's center of mass

    QPointF rotation_midpoint = mesh.Centroid()*Cell::Factor() - Cell::Offset();

    // calculate rotation angle

    double dy = (rotation_midpoint.y() - p.y());

    double dx = (rotation_midpoint.x() - p.x());

    double new_rot_angle = atan2(dx, dy);

    double d_alpha = new_rot_angle - rot_angle;

    rot_angle = new_rot_angle;

    mesh.Rotate(d_alpha, ( Vector(rotation_midpoint) + Cell::Offset() ) / Cell::Factor() );

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

    FullRedraw();

    return;

  }

  if ( moving ) {

    QPointF p = mapToScene(e->pos());

    moving->userMove(p.x() - moving_start.x(),

		     p.y() - moving_start.y());

    moving_start = p;

    scene()->update();

  }

  //cerr << "event";

  // keep track of intersection line to interactively cut a growing leaf

  if ( intersection_line ) {

    QPointF sp = intersection_line -> line().p1(); // startpoint

    QPointF ep = mapToScene(e->pos()); // endpoint

    intersection_line -> setLine( QLineF(sp, ep) ); 

    scene()->update();

    // Need this for Mac

    FullRedraw();

  }

}

//void FigureEditor::contentsMouseReleaseEvent(QMouseEvent* e)

void FigureEditor::mouseReleaseEvent(QMouseEvent* e)

{

  emit MouseReleased();

  // intersection line for leaf was finished now.

  if (e->button()==Qt::LeftButton) { 

    if (intersection_line ) {

#ifdef QDEBUG

      qDebug() << "Trying to cut leaf" << endl;

#endif

      QPointF sp = intersection_line -> line().p1(); // startpoint

      QPointF ep = mapToScene(e->pos());

      intersection_line -> setLine( QLineF(sp, ep) ); 

      intersection_line -> show();

      vector <CellItem *> intersected_cells = getIntersectedCells();

      // no cells selected, do nothing

      if (intersected_cells.size()==0) {

#ifdef QDEBUG

	qDebug() << "No cells detected :-(" << endl;

#endif

	return;

      }

      Vector startpoint = Vector(sp.x(), sp.y()) / Cell::Factor() - Cell::Offset();

      Vector endpoint = Vector(ep.x(), ep.y()) / Cell::Factor() - Cell::Offset();

      NodeSet *node_set = new NodeSet;

      for (vector<CellItem *>::iterator it = intersected_cells.begin(); it != intersected_cells.end(); it++) {

	(*it)->setBrush(QBrush("purple"));

	Cell &c=(*it)->getCell();

	// sometimes the cell hasn't properly divided yet before the

	// next division is called?  so check for it?  let's find a way

	// to do this later. Note that this functionality currently

	// might result in a segmentation fault for users who are

	// quickly dragging and releasing division lines...

	scene()->update();

#ifdef QDEBUG

	qDebug() << "Dividing Cell " << c.Index() << endl;

#endif

	c.DivideOverGivenLine( startpoint, endpoint, true, node_set);

      }

      node_set->CleanUp();

      mesh.AddNodeSet(node_set);

#ifdef QDEBUG

      qDebug() << "Done DivideOverGivenLine" << endl;

#endif

      mesh.TestIllegalWalls();

      // Do the actual cutting and removing

      if (intersected_cells.size()) {

	mesh.CutAwayBelowLine( startpoint, endpoint ); 

	// Correct flags of nodeset

	for (NodeSet::iterator i = node_set->begin(); i != node_set->end(); i++) {

	  (*i)->SetSAM();

	  (*i)->SetBoundary();

	}

	// Make cells attached to nodeset part of the boundary

	// This is a temporary solution for the following:

	//   If a cell attached to a NodeSet divides (with a division plane intersecting the node set), 

	//   we must insert a new node into the node set.

	// For now, we add a layer of "virtual cells" inbetween. 

	list<Cell *> cells_attached_to_nodeset = node_set->getCells();

	for ( list<Cell *>::iterator c = cells_attached_to_nodeset.begin(); c != cells_attached_to_nodeset.end(); c++) {

	  (*c)->SetBoundary(Cell::SAM);

	}

#ifdef QDEBUG

	qDebug() << "Done CutAwayBelowLine" << endl;

#endif

	mesh.TestIllegalWalls();

	mesh.RepairBoundaryPolygon();

#ifdef QDEBUG

	qDebug() << "Done RepairBoundaryPolygon" << endl;

#endif

	mesh.TestIllegalWalls();

	mesh.CleanUpWalls();

#ifdef QDEBUG

	qDebug() << "Done CleanUpWalls" << endl;

#endif

	mesh.TestIllegalWalls();

      }

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

#ifdef QDEBUG

      cerr << "NodeSet of cutting line: " << *node_set << endl;

#endif

    }

  } else 

    if (e->button()==Qt::RightButton) {

      if (intersection_line /* && !angle_line*/) {

	QPointF p = mapToScene(e->pos());

	QPointF sp = intersection_line->line().p1();

	viewport()->setMouseTracking( TRUE );

      } 

    }

}

// returns a vector of pointer to cells colliding with intersection line

vector <CellItem *> FigureEditor::getIntersectedCells(void)

{ 

  vector <CellItem *> colliding_cells;

  QList<QGraphicsItem *> l = intersection_line->collidingItems( );

#ifdef QDEBUG

  qDebug() <<  "l.size() = " << l.size() << endl;

#endif

  for (QList<QGraphicsItem *>::Iterator it=l.begin(); it!=l.end(); ++it) {

#ifdef QDEBUG

    qDebug() << typeid(**it).name() << endl;

#endif

    if ( !strcmp(typeid(**it).name(),"8CellItem") ) {

      colliding_cells.push_back(dynamic_cast<CellItem *>(*it));

    }

  }

  delete intersection_line;

  intersection_line = 0;

  return colliding_cells;

}

void FigureEditor::FullRedraw(void)

{

  QList<QRectF> rl;

  rl << sceneRect();

  updateScene(rl);   

}

NodeItem *FigureEditor::selectedNodeItem(QList<QGraphicsItem *> graphicItems) const

{

  NodeItem *nodeItem = 0;

  // graphicItems is a list of the QgraphicItems under the mouse click event 

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

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

    if ( !strcmp(typeid(**it).name(),"8NodeItem")) {

      // the object under the mouse click is a Nodeitem

      nodeItem = dynamic_cast<NodeItem *>(*it);

      // indicate we've selected it

      nodeItem->setBrush(dark_red);

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

  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("&LICENSE", this, SLOT(gpl()) );

  helpmenu->insertItem("About", this, SLOT(about()) ); //, Key_F1);

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

  }

  //EndGifAnim();

}

void Main::newView()

{

  // Open a new view... have it delete when closed.

  Main *m = new Main(canvas, mesh, 0, 0, Qt::WDestructiveClose);

  qApp->setMainWidget(m);

  m->show();

  qApp->setMainWidget(0);

}

void Main::EditParameters()

{

  ParameterDialog *pardial = new ParameterDialog(this, "stridediag");

  // Make sure the values in the parameter dialog are updated after a file is read 

  // each method changing the parameters (reading XML or PAR files) should

  // emit this signal

  QObject::connect(   this, SIGNAL( ParsChanged() ), pardial, SLOT( Reset() ) );

}

void Main::savePars()

{

  stopSimulation();

  Q3FileDialog *fd = new Q3FileDialog( this, "file dialog", TRUE );

  fd->setMode( Q3FileDialog::AnyFile );

  fd->setFilter( "Parameter files (*.par)");

  QString fileName;

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

    fileName = fd->selectedFile();

    ofstream parfile((const char *)fileName);

    par.Write(parfile);

  }

  startSimulation();

}

void Main::readPars()

{

  stopSimulation();

  Q3FileDialog *fd = new Q3FileDialog( this, "file dialog", TRUE );

  fd->setMode( Q3FileDialog::ExistingFile );

  fd->setFilter( "Parameter files (*.par)");

  QString fileName;

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

    fileName = fd->selectedFile();

    par.Read((const char *)fileName);

  }

  emit ParsChanged();

}

void Main::saveStateXML()

{

  stopSimulation();

  Q3FileDialog *fd = new Q3FileDialog( this, "file dialog", TRUE );

  fd->setMode( Q3FileDialog::AnyFile );

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

  QString fileName;

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