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)

	  //canvas(c)

{

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

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

  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("&Fill canvas", this, SLOT(init()), Qt::CTRL+Qt::Key_F);

	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->insertItem("&New view", this, SLOT(newView()), Qt::CTRL+Qt::Key_N);

   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->insertItem("Read &parameters", this, SLOT(readPars()));

  //file->insertItem("&Write parameters", this, SLOT(savePars()));

	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("Randomize PIN1 Transporters", this, SLOT( RandomizeMesh()) );

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

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

  run = new Q3PopupMenu( menu );

  //  edit->insertItem("Add &Polygon", this, SLOT(addPolygon()), ALT+Key_P);

  //edit->insertItem("Add &Line", this, SLOT(addLine()), ALT+Key_L);

  running = false;

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

  run->setItemChecked(paused_id, FALSE);

  //run->insertItem("&Divide Cell", this, SLOT(Divide()), Qt::CTRL+Qt::Key_D);

 // run->insertItem("&Restart Simulation", this, SLOT(RestartSim())); 

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

  view = new Q3PopupMenu( menu );

  //view->insertItem("&Enlarge", this, SLOT(enlarge()), SHIFT+CTRL+Key_Plus);

  //view->insertItem("Shr&ink", this, SLOT(shrink()), SHIFT+CTRL+Key_Minus);

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

  //view->insertItem("Cell monitor", this, SLOT(cellmonitor()));

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

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

  view->setItemChecked(cell_number_id, TRUE);

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

  //only_boundary_id = view->insertItem("Show only leaf &boundary", 0,0);

	view->insertSeparator();

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

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

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

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

  cerr << "scale_factor = " << scale_factor << endl;

  cerr << "scale_factor_x = " << scale_factor_x << endl;

  cerr << "scale_factor_y = " << scale_factor_y << endl;

  m.scale( scale_factor, scale_factor );

  editor->setMatrix( m );

  editor->show();

}

  void Main::PauseIfRunning(void) {

    if (running) {

      timer->stop();

    }

  }

  void Main::ContIfRunning(void) {

    if (running) {

      timer->start( 0 );

    }

  }

void Main::FitLeafToCanvas(void) {

  Vector ll,ur;

  mesh.BoundingBox(ll, ur);

  ll*=Cell::Magnification(); ur*=Cell::Magnification();

  // give the leaf some space

  Vector border = ((ur-ll)/5.);

  QRectF bb( ll.x - border.x, ll.y - border.y, ur.x-ll.x + 2*border.x, ur.y-ll.y + 2*border.y );

  // cerr << ur << ", " << ll << endl;

  editor->fitInView(bb, Qt::KeepAspectRatio);

}

void Main::CleanMesh(void) {

	mesh.setTime(0);

  //  repaint();

}

void Main::RandomizeMesh(void) {

  vector<double> max_chem(Cell::NChem());

  vector<double> max_transporters(Cell::NChem());

  for (int i=0;i<Cell::NChem();i++) {

    max_transporters[i]=0.;

    max_chem[i]=par.initval[i];

  }

  // Amount of PIN1 at walls

  max_transporters[1] = 0.01;

  mesh.RandomizeChemicals(max_chem, max_transporters);

  Plot();

}

void Main::XMLReadSettings(xmlNode *settings) {

  MainBase::XMLReadSettings(settings);

  view->setItemChecked(com_id, showcentersp);

  view->setItemChecked(mesh_id, showmeshp);

  view->setItemChecked(border_id, showbordercellp);

  view->setItemChecked(node_number_id, shownodenumbersp);

  view->setItemChecked(cell_number_id, showcellnumbersp);

  view->setItemChecked(cell_axes_id, showcellsaxesp);

  view->setItemChecked(cell_strain_id, showcellstrainp);

  view->setItemChecked(movie_frames_id, movieframesp);

  view->setItemChecked(only_boundary_id, showboundaryonlyp);

  view->setItemChecked(fluxes_id, showfluxesp);

  view->setItemChecked(hide_cells_id, hidecellsp);

  options->setItemChecked(dyn_cells_id, dynamicscellsp);

  view->setItemChecked( cell_walls_id, showwallsp);

	view->setItemChecked( apoplasts_id, showapoplastsp);

}

xmlNode *Main::XMLSettingsTree(void) {

  showcentersp = view->isItemChecked(com_id);

  showmeshp = view->isItemChecked(mesh_id);

  showbordercellp =  view->isItemChecked(border_id);

  shownodenumbersp =  view->isItemChecked(node_number_id);

  showcellnumbersp =  view->isItemChecked(cell_number_id);

  showcellsaxesp = view->isItemChecked( cell_axes_id );

  showcellstrainp = view->isItemChecked( cell_strain_id );

  movieframesp = view->isItemChecked(movie_frames_id);;

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

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

  void snapshot();

  void savePars();

  void readPars();

  void clear();

  void init();

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

/*   void cellmonitor() { */

/*     PlotDialog *plot = new PlotDialog(this); */

/*     cerr << "Attempting to launch a cell monitor\n"; */

/*   } */

  //void addPolygon();

  //void addLine();

  void enlarge();

  void shrink();

  void zoomIn();

  void zoomOut();

  void CleanMesh();

  void RandomizeMesh();

 signals:

  void SimulationDone(void);

  void ParsChanged(void);

 protected:

  Mesh &mesh;

 private:

  NodeSet *node_set;

  FigureEditor *editor;

  //QCanvas& canvas;

  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;

  to the boundary polygon.

*/

void Mesh::DeleteLooseWalls(void) {

  list<Wall *>::iterator w=walls.begin();

  while (w!=walls.end()) {

    // if both cells of the wall are dead, remove the wall

    if ((*w)->C1()->DeadP() || (*w)->C2()->DeadP()) {

      if ((*w)->C1()->DeadP() && (*w)->C2()->DeadP()) {

	delete *w;

	w=walls.erase(w);

      } else {

	if ((*w)->C1()->DeadP())

	  (*w)->c1 = boundary_polygon;

	else

	  (*w)->c2 = boundary_polygon;

	w++;

      }

    } else {

      w++;

    }

  }

}

/*void Mesh::FitLeafToCanvas(double width, double height) {

  Vector bbll,bbur;

  BoundingBox(bbll,bbur);

  double scale_x = width/(bbur.x-bbll.x);

  double scale_y = height/(bbur.y-bbll.y);

  double factor = scale_x<scale_y ? scale_x:scale_y;

  Cell::SetMagnification(factor); // smallest of scale_x and scale_y

  double offset_x = (width/Cell::Magnification()-(bbur.x-bbll.x))/2.;  

  double offset_y = (height/Cell::Magnification()-(bbur.y-bbll.y))/2.;

  Cell::setOffset(offset_x, offset_y);

  }*/

}

void Mesh::RandomizeChemicals(const vector<double> &max_chem, const vector<double> &max_transporters) {

  if (max_chem.size()!=(unsigned)Cell::NChem() || max_transporters.size()!=(unsigned)Cell::NChem()) {

    throw "Run time error in Mesh::CleanChemicals: size of max_chem and max_transporters should be equal to Cell::NChem()";

  }

  for (vector<Cell *>::iterator c=cells.begin();

       c!=cells.end();

       c++) {

    for (int i=0;i<Cell::NChem();i++) {

      (*c)->SetChemical(i,max_chem[i]*RANDOM());

    }

    (*c)->SetNewChemToChem();

  }

  // randomize transporters

  for (list<Wall *>::iterator w=walls.begin();

       w!=walls.end();

       w++) {

    for (int i=0;i<Cell::NChem();i++) {

      (*w)->setTransporters1(i,max_transporters[i] * RANDOM()); (*w)->setNewTransporters1(i, (*w)->Transporters1(i) );

      (*w)->setTransporters2(i,max_transporters[i] * RANDOM()); (*w)->setNewTransporters2(i, (*w)->Transporters1(i) );

    }

  }

}

//!\brief Calculates a vector with derivatives of all variables, which

// we can pass to an ODESolver. 

void Mesh::Derivatives(double *derivs) {

  int nwalls = walls.size();

  int ncells = cells.size();

  int nchems = Cell::NChem();

  // two eqs per chemical for each walls, and one eq per chemical for each cell

  // This is for generality. For a specific model you may optimize

  // this by removing superfluous (empty) equations.

  int neqs = 2 * nwalls * nchems + ncells * nchems;

  //static double *derivs = 0; 

  // derivs is allocated by RungeKutta class.

  for (int i=0;i<neqs;i++) { derivs[i]=0.;}

    item->setZValue(5);

    item->show();

    item ->setPos(((Cell::offset[0]+i->x)*Cell::factor),

		  ((Cell::offset[1]+i->y)*Cell::factor) );

  }

}

/*! Returns the sum of protein "ch" of a cycling protein in cells and walls */

double Mesh::CalcProtCellsWalls(int ch) const {

  double sum_prot=0.;

  // At membranes

  for (list<Wall *>::const_iterator w=walls.begin();

       w!=walls.end();

       w++) {

    sum_prot += (*w)->Transporters1(ch);

    sum_prot += (*w)->Transporters2(ch);

  }

  // At cells

  for (vector<Cell *>::const_iterator c=cells.begin();

       c!=cells.end();

       c++) {

    sum_prot += (*c)->Chemical(ch);

  }

  return sum_prot;

}

void Mesh::SettoInitVals(void) {

  vector<double> clean_chem(Cell::NChem());

  vector<double> clean_transporters(Cell::NChem());

  for (int i=0;i<Cell::NChem();i++) {

    clean_transporters[i]=0.;

    clean_chem[i]=par.initval[i];