NodeSet *node_set = new NodeSet;

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

	   it != intersected_cells.end();

	   it++) {

	//(*it)->Mark();

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

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

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

      }

      node_set->CleanUp();

      mesh.AddNodeSet(node_set);

      cerr << "Done DivideOverGivenLine\n";

      mesh.TestIllegalWalls();

      // Do the actual cutting and removing

      if (intersected_cells.size()) {

	//      Mesh &m(intersected_cells.front()->getCell().getMesh());

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

	}

	cerr << "Done CutAwayBelowLine\n";

	mesh.TestIllegalWalls();

	mesh.RepairBoundaryPolygon();

	cerr << "Done RepairBoundaryPolygon\n";

	mesh.TestIllegalWalls();

	mesh.CleanUpWalls();

	cerr << "Done CleanUpWalls\n";

	mesh.TestIllegalWalls();

      }

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

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

    }

  } else 

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

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

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

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

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

	viewport()->setMouseTracking( TRUE );

	/* angle_line = new QGraphicsLineItem( 0, scene() );

	angle_line->setPen( QPen( QColor("Blue"), 3, Qt::DashLine ) );

	angle_line->setLine( QLineF(sp, p) );

	angle_line->setZValue( 100 );

	angle_line->show();

	*/

      } 

    }

}

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

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

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

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

    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)

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

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

	view->setItemChecked(only_boundary_id, FALSE);

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

  options = new Q3PopupMenu( menu );

  /* dbf_id = options->insertItem("Double buffer", this, SLOT(toggleDoubleBuffer()));

     options->setItemChecked(dbf_id, TRUE);*/

  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->insertItem("&About", this, SLOT(help()) ); //, Key_F1);

  //help->insertItem( "What's &This", this , SLOT(whatsThis()), SHIFT+Key_F1);

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

  //QSlider *flux_arrow_slider = new QSlider( 0, 10000, 1, 100, Qt::Horizontal, this, "flux arrow size");

  //QSpinBox *stride  = new QSpinBox( 1, 1000, 1, this, "stride");

  //QGridLayout *controlgrid = new QGridLayout( this, 1, 2, 10);

  // 2x1, 10 pixel border

  //controlgrid->addWidget( stride, 0, 0);

  //controlgrid->addWidget( flux_arrow_slider, 0, 1);

  //controlgrid->setColStretch( 1, 10 );

  //flux_arrow_size = 1.;

  //flux_arrow_slider -> setMinimumSize( 200,50);

  //connect( flux_arrow_slider, SIGNAL( valueChanged( int ) ), this, SLOT( setFluxArrowSize(int) ) );

  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;

	// A little bit of PSB/CWI decoration ;-)

	/*dockwindow = new Q3DockWindow();

	addDockWindow(dockwindow);

	QLabel *viblab = new QLabel; viblab->setPixmap(QPixmap(cwi_xpm));

	QString virtleafstring("<h1>The Virtual Leaf</h1>\n<center><b>Model:</b> <i>%1</i></center>");

	QLabel *virtleaf = new QLabel(virtleafstring.arg(mesh.ModelID()));

	QLabel *psblab = new QLabel; psblab->setPixmap(QPixmap(PSB_xpm));

	dockwindow->setHorizontalStretchable(true);

	dockwindow->boxLayout()->addWidget(viblab);//,Qt::AlignLeft);

	dockwindow->boxLayout()->addStretch();

	dockwindow->boxLayout()->addWidget(virtleaf);//, Qt::AlignHCenter);

	dockwindow->boxLayout()->addStretch();

	dockwindow->boxLayout()->addWidget(psblab);//, Qt::AlignRight);*/

	//QString virtleafstring("<h1>The Virtual Leaf</h1>\n<center><b>Model:</b> <i>%1</i></center>");

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

  // bool timer_active;

  /* if (timer_active=timer->isActive())

  }

  void Main::zoomIn()

  {

    QMatrix m = editor->matrix();

    m.scale( 1.1, 1.1 );

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

      cerr << "bbll = " << bbll << endl;

      cerr << "bbur = " << bbur << endl;

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

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

      QPainter pp(printer);

      QRect vp=pp.viewport();

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

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

    // 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\n";

      //    extern Mesh mesh;

      mesh.Clear();

      Init();

		Plot();

		editor->FullRedraw();

    } 

    //startSimulation();

  }

  /*

    void Main::SaveToGifAnim(void) {

    if (gifanim) {

    QPixmap image(canvas.width(), canvas.height());

    QPainter im(&image);

    canvas.drawArea(QRect(0,0,canvas.width(),canvas.height()),&im,FALSE);

    QFile conversionpipe;

    conversionpipe.open ( IO_WriteOnly, popen("pngtopnm | ppmtogif > tmp.gif", "w") );

    image.save( &conversionpipe, "PNG");

    conversionpipe.close();

    QFile readconvertedimage("tmp.gif");

    readconvertedimage.open(IO_ReadOnly);

    int c;

    while ( (c=readconvertedimage.getch())!=-1) {

    gifanim->putch(c);

    }

    }

    }*/

  /* void Main::StartGifAnim(QString fname) {

  if (gifanim) {

  QMessageBox::information( this, "Animation",

  "Already making another animation."

  "Please end it and try again.",

  QMessageBox::Ok );

  } else {

  QString cmdline("gifsicle --multifile - > ");

  cmdline += fname;

  gifanim = new QFile;

  gifanim->open( IO_WriteOnly, 

  popen((const char *)cmdline, "w") );

  */   /* QStringList cmdline;

	  cmdline << "gifsicle" << "--multifile" << "-";

	  gifanim = new QProcess( cmdline );

	  cmdline.clear();

	  cmdline << "pngtopnm";

	  pngtopnm = new QProcess( cmdline );

	  pngtopnm->start();

	  cmdline.clear();

	  cmdline << "ppmtogif";

	  ppmtogif = new QProcess( cmdline );

	  ppmtogif->start();*/

       /*  }

       }*/

       /*void Main::EndGifAnim(void) {

       if (gifanim)

       gifanim->close();

       }*/

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