QString path = docDir.filePath("gpl3.txt");

  if (!docDir.exists("gpl3.txt")){

    docDir = QApplication::applicationDirPath();

    docDir.cd("doc"); // Where Windows expects gpl3.txt

    path = docDir.filePath("gpl3.txt");

  }

  // At this point path points either to the linux variant, which

  // exists, or the windows variant, which may exist. Testing the

  // ifstream object will determine whether we've found gpl3.txt.

  std::ifstream file(path.toStdString().c_str());

  std::string str;

  if (file) {

    file.seekg(0, std::ios::end);   

    str.reserve(file.tellg());

    file.seekg(0, std::ios::beg);

    str.assign((std::istreambuf_iterator<char>(file)),

	       std::istreambuf_iterator<char>());

    gpl->setDetailedText(QString(str.c_str()));

  }

  gpl->setText(QString( "<h3>GNU GENERAL PUBLIC LICENSE</h3>"

			"<p>Version 3, 29 June 2007</p>"

			"<p>Copyright &copy; 2007 Free Software Foundation, Inc. "

			"&lt;<a href=\"http://fsf.org/\">http://fsf.org/</a>&gt;</p><p>"

			"Everyone is permitted to copy and distribute verbatim copies "

			"of this license document, but changing it is not allowed.</p>"

			"<h2>GNU GENERAL PUBLIC LICENSE</h2>"));

  gpl->setButtonText( 1, "Dismiss" );

  gpl->show();

}

void Main::aboutQt(){

  QMessageBox::aboutQt( this, "Virtual Leaf" );

}

void Main::toggleShowCellCenters()

{

  Plot();

}

void Main::toggleShowWalls()

{

  Plot();

}

void Main::toggleShowApoplasts()

{

  Plot();

}

void Main::toggleShowNodes()

{

  Plot();

}

void Main::toggleNodeNumbers(void)

{

  Plot();

}

void Main::toggleCellNumbers(void)

{

  Plot();

}

void Main::toggleCellAxes(void)

{

  Plot();

}

void Main::toggleCellStrain(void)

{

  Plot();

}

void Main::toggleShowFluxes(void)

{

  Plot();

}

void Main::toggleShowBorderCells()

{

  Plot();

}

void Main::toggleHideCells(void)

{

  Plot();

  editor->FullRedraw();

}

void Main::toggleMovieFrames(){}

void Main::toggleLeafBoundary(){}

void Main::toggleDynCells() {}

void Main::startSimulation(void)

{

  timer->start( 0 );

  statusBar()->message("Simulation started");

  running = true;

}

void Main::stopSimulation(void)

{

  timer->stop();

  cerr << "Stopping simulation" << endl;

  statusBar()->message("Simulation paused");

  running = false;

}

void Main::togglePaused()

{

  bool s = run->isItemChecked(paused_id);

  if (s) {

    cerr << "Calling start simulation" << endl;

    startSimulation();

  } else {

    cerr << "Calling stop simulation" << endl;

    stopSimulation();

  }

}

void Main::setFluxArrowSize(int size)

{

  flux_arrow_size = size/100.;

}

void Main::enlarge()

{

  canvas.setSceneRect( QRectF( 0,0, canvas.width()*4./3., canvas.height()*4./3.) );

}

void Main::shrink()

{

  canvas.setSceneRect( QRectF( 0,0, canvas.width()*3/4, canvas.height()*3/4) );

}

void Main::scale(double factor)

{

  QMatrix m = editor->matrix();

  m.scale(factor, factor);

  editor->setMatrix( m );

}

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

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

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

  }

}

void Main::TimeStepWrap(void)

{

  static int t;

  stringstream fname;

  TimeStep();

  t = (int)mesh.getTime();

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

    fname << par.datadir << "/" << par.export_fn_prefix;

    fname.fill('0');

    fname.width(6);

    fname << t << ".csv";

    this->exportCellData(QString(fname.str().c_str()));

  }

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

  editor->ensureVisible(bb);

  canvas.setSceneRect(bb);

  //editor->setTransform(viewport);

}

void Main::CleanMesh(void) 

{

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

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

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

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

    clean_transporters[i]=0.;		

  }

  mesh.CleanChemicals(clean_chem);

  mesh.CleanTransporters(clean_transporters);

  mesh.setTime(0);

  Plot();

  editor->FullRedraw();

}

void Main::CleanMeshChemicals(void) 

{

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

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

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

  }

  mesh.CleanChemicals(clean_chem);

  mesh.setTime(0);

  Plot();

  editor->FullRedraw();

}

void Main::CleanMeshTransporters(void) 

{

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

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

    clean_transporters[i]=0.;

  }

  mesh.CleanTransporters(clean_transporters);

  mesh.setTime(0);

  Plot();

  editor->FullRedraw();

}

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