- intersection_line->line().p1();

    QPointF q_v2 = angle_line->line().p2();

    - angle_line->line().p1();

    Vector v1(q_v1.x(),q_v1.y());

    Vector v2(q_v2.x(),q_v2.y());

    cerr << "v1 = " << v1 << endl;

    cerr << "v2 = " << v2 << endl;

    rot_angle = v1.SignedAngle(v2);

    cerr << "Angle is " << rot_angle << endl;

    const QPointF &q_c(angle_line->line().p1());

    Vector center = Vector(q_c.x(), q_c.y()) / Cell::Factor() - Cell::Offset();

    cerr << "Center is " << center << endl;

    mesh.Rotate(rot_angle, center);

    delete angle_line;

    angle_line=0;

    delete intersection_line;

    intersection_line=0;

    viewport()->setMouseTracking( FALSE );

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

    return;

    }*/

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

      /*if ( (*it)->rtti() == imageRTTI ) {

	ImageItem *item= (ImageItem*)(*it);

	if ( !item->hit( p ) )

	continue;

	}*/

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

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

	//moving = dynamic_cast<NodeItem*>(*it);

	//moving = *it;

	//moving_start = p;

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

	  //static int old_stride=100;

	  //if (!c.Source()) {

	  /* if (!c.Source()) {

	     c.SetChemical(0,par.cellsource);

	     //flag=true;

	     //c.SetSource(0,par.cellsource);

	     //c.Fix();

	     //cerr << "Setting source\n";

	     } else { 

	     //c.UnsetSource();

	     cerr << "Unsetting source\n";

	     } */

	  // 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::contentsMouseMoveEvent(QMouseEvent* e)

void FigureEditor::mouseMoveEvent(QMouseEvent* e)

{

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

    //viewport()->setMouseTracking( FALSE );

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

	  FullRedraw();

    return;

  }

  if ( moving ) {

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

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

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

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

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

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

    scene()->update();

    } else { */

  if ( intersection_line ) {

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

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

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

      cerr << "Trying to cut leaf\n";

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

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

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

	cerr << "No cells detected :-( \n";

	return;

      }

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

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

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

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