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

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

//double auxin_account = 0.;

#ifdef XFIGGRAPHICS

#define TIMESTEP double Graphics::TimeStep(void)

#endif

      cerr << "Cell " << c.Index() << " is _not_ a source cell.\n";

    }

  }

};

};

double PINSum(Cell &c) {

	return c.Chemical(1) + c.SumTransporters(1);// + c.ReduceCellAndWalls<double>( complex_PijAj );

}

	  QString info_string=QString("Cell %1, chemicals: ( %2, %3, %4, %5, %6)\n %7 of PIN1 at walls.\n Area is %8\n PIN sum is %9\n Circumference is %10\n Boundary type is %11").arg(c.Index()).arg(c.Chemical(0)).arg(c.Chemical(1)).arg(c.Chemical(2)).arg(c.Chemical(3)).arg(c.Chemical(4)).arg(c.SumTransporters(1)).arg(c.Area()).arg(PINSum(c)).arg(c.Circumference()).arg(c.BoundaryStr());

	  info_string += "\n" + c.printednodelist();

	  c.Draw(&canvas, info_string);

	} else {

	  c.Draw(&canvas);

	c.DrawCenter(&canvas);

    if (m.ShowFluxesP())

	c.DrawFluxes(&canvas, par.arrowsize);

       }

  }

};

Mesh mesh;

bool batch=false;

void MainBase::Plot(int resize_stride) {

  clear();

  static int count=0;

  if (resize_stride) {

    if ( !((++count)%resize_stride) ) {

    mesh.LoopCells( bind2nd (mem_fun_ref ( &Cell::DrawStrain), &canvas ) );

  if (ShowWallsP())

    mesh.LoopWalls( bind2nd( mem_fun_ref( &Wall::Draw ), &canvas ) );

	if (ShowApoplastsP()) 

  if (ShowBoundaryOnlyP()) 

    mesh.DrawBoundary(&canvas);

	if ( ( batch || MovieFramesP() )) {

		static int frame = 0;

			// Write high-res JPG snapshot every plot step

			Save(fname.str().c_str(), "JPEG",1024,768);

		}

		if (!(count%par.xml_storage_stride)) {

			// Write XML file every ten plot steps

			mesh.XMLSave(fname.str().c_str(), XMLSettingsTree());

		}

	}

}

      mesh.ReactDiffuse(par.rd_dt);

      t++;

      Plot(par.resize_stride);

  }

  i++;

  return mesh.getTime();

    main_window->FitLeafToCanvas();

    main_window->Plot();

    if (batch) {

      double t=0.;

      do {

      abort();

    }

  }

}

QMAKE = qmake

plugin_auxingrowth: Makefile.plugin_auxingrowth

	make -f Makefile.plugin_auxingrowth

Makefile.plugin_auxingrowth: plugin_auxingrowth.pro

	$(QMAKE) -makefile -o $@ $< 

plugin_meinhardt: Makefile.plugin_meinhardt

	make -f Makefile.plugin_meinhardt

clean:

	make -f Makefile.plugin_auxingrowth clean

	make -f Makefile.plugin_meinhardt clean

	make -f Makefile.plugin_test clean

	touch plugin_auxingrowth.pro

	touch plugin_meinhardt.pro

	touch plugin_test.pro

#include <q3filedialog.h>

#include <QGraphicsItem>

#include <QList>

#include <set>

	if ( !item->hit( p ) )

	continue;

	}*/

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

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

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

    if (intersection_line ) {

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

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

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

      // no cells selected, do nothing

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

	return;

      }

	// quickly dragging and releasing division lines...

	scene()->update();

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

      }

      node_set->CleanUp();

      mesh.AddNodeSet(node_set);

      mesh.TestIllegalWalls();

      // Do the actual cutting and removing

      if (intersected_cells.size()) {

	mesh.TestIllegalWalls();

	mesh.RepairBoundaryPolygon();

	mesh.TestIllegalWalls();

	mesh.CleanUpWalls();

	mesh.TestIllegalWalls();

      }

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

    }

  } else 

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

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

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

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

	  //canvas(c)

{

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

  working_dir = 0;

  QObject::connect( editor, SIGNAL(MousePressed()), this, SLOT(PauseIfRunning()));

  QObject::connect( editor, SIGNAL(MouseReleased()), this, SLOT(ContIfRunning()));

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

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

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

  try {

    xmlNode *settings;

    mesh.XMLRead((const char *)filename, &settings, geometry, pars, simtime);

    XMLReadSettings(settings);

    xmlFree(settings);

    Cell::SetMagnification(1);

	setCaption(caption_with_file.arg(filename));

    statusBar()->message(status_message);

    emit ParsChanged();

    return 0;

  } catch (const char *error_message) {

    QMessageBox mb( "Read leaf from XML file",

  //  extern Mesh mesh;

  stopSimulation();

  OptionFileDialog *fd = new OptionFileDialog( this, "read dialog", TRUE );

  fd->setMode( OptionFileDialog::ExistingFile );

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

  void Main::stopSimulation(void) {

    //run->setItemChecked(paused_id, true);

    timer->stop();

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

    running = false;

  }

  {

    bool s = run->isItemChecked(paused_id);

    if (s) {

      startSimulation();

    } else {

      stopSimulation();

    }

  }

      //    extern Mesh mesh;

      Vector bbll,bbur;

      mesh.BoundingBox(bbll,bbur);

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

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

      QPainter pp(printer);

      QRect vp=pp.viewport();

      // Note that Cell is also translated...

      pp.translate(-bbur.x,-bbur.y);

				  "Are you sure?"),

							   QMessageBox::Yes | QMessageBox::No, QMessageBox::NoButton ) == QMessageBox::Yes ) {

      //    extern Mesh mesh;

      mesh.Clear();

      Init();

  double scale_factor = scale_factor_x > scale_factor_y ? scale_factor_x : scale_factor_y;

  QMatrix m = editor->matrix();

  m.scale( scale_factor, scale_factor );

  editor->setMatrix( m );

  editor->show();

 *

 */

#include <string>

#include "cell.h"

#include "node.h"

#include "qcanvasarrow.h"

#include "parameter.h"

static const std::string _module_id("$Id$");

void Cell::Apoptose(void) {

	// First kill walls

	}

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

		 w!=walls.end();

			(*w)->c2 = m->boundary_polygon;

		}

		if (illegal_flag && (*w)->c1==(*w)->c2) {

		}

		if ( ((*w)->N1()->DeadP() || (*w)->N2()->DeadP()) ||

			((*w)->C1() == (*w)->C2() ) ){

			// kill wall

			(*w)->Kill();

			if ((*w)) {

			}

			(*w)=0;

		} else {

		}

	}

	walls.remove(0);

	// check each edge for intersection with the line

	ItList new_node_locations;

	for (list<Node *>::iterator i=nodes.begin();

		 i!=nodes.end();

		 i++) {

		} 

	}

	if (new_node_locations.size()<2) { 

		return false;

	}

	ItList::iterator i = new_node_locations.begin();

	list< Node *>::iterator j;

	++i;

	j = *i; 

	if (j==nodes.begin()) j=nodes.end(); j--;

	if ( **new_node_locations.begin() == *j ) {

		return false;

	}

	DivideWalls(new_node_locations, v1, v2, fix_cellwall, node_set);

		// Cell somewhere in the middle of Mesh::Cells the indices will

		// get totally messed up...! (e.g. the indices used in Nodes::cells)

		m->cells.pop_back();

		Cell::NCells()--;

		m->shuffled_cells.pop_back();

			new_node_flag[nnc]=1;

			new_node[nnc] = *(**i);

			new_node_ind[nnc] = **i;

		} else 

			if ( (*(*nb) - *n).Norm() < collapse_node_threshold * elem_length ) {

				new_node_flag[nnc]=2;

			} while ( w!=walls.end() && !(*w)->IntersectsWithDivisionPlaneP( from, to ) ); // go on until we find the right one.

			if (w == walls.end()) {

			} else {

				// 2. Split it up, if we should (sometimes, the new node coincides with an existing node so

					(*i)->owners.end(),

				bind2nd(mem_fun_ref( &Neighbor::CellEquals ),this->Index() )  );

			if (neighb_with_this_cell==(*i)->owners.end()) {

				abort();

			}

		for (int c=0;c<NChem();c++) {

			double phi = (*i)->length * ( D[c] ) * ( ((Cell *)(*i)->c2)->chem[c] - chem[c] );

			if ((*i)->c1!=this) {

			}

			flux[c] += phi;

		}    

	// Draw the cell on a QCanvas object

	if (DeadP()) { 

		return;

	}

void Cell::AddWall( Wall *w ) {

	// if necessary, we could try later inserting it at the correct position

	if (w->c1 == w->c2 ){

	}

	// Add Wall to Cell's list

	walls.push_back( w );

		ncells = 0;

		nchem = 0;

		base_area = 0.;

	}

	~CellsStaticDatamembers() {

	}

	int ncells;

	int nchem;

#include <QDialog>

#include <QString>

#include <QStringList>

#include <iostream>

#include "data_plot.h"

//

//  Initialize main window

    curves[i].attach(this);

    curves[i].setPen(QPen(curvecolors[i]));

    QString col(curvecolors[i]);

    curves[i].setRawData(d_t, d_x[i], PLOT_SIZE);

  }

#include "maxmin.h"

#include <string>

// The value Errcon equals (5/Safety) raised to the power (1/PGrow), see use below.

{

  static bool warning_issued = false;

  if (!warning_issued) {

    warning_issued=true;

    //MyWarning::warning("Using inaccurate method ForwardEuler");

  }

		n1);

  AddNodeToCell(boundary_polygon, *it_n1, 

		n4,

	 cerr << "Meshed cleared: cells: " << cells.size() << ", nodes: " << nodes.size() << endl;

	 */

}

double Mesh::DisplaceNodes(void) {

  Vector perp = (endpoint-startpoint).Perp2D().Normalised();

  TestIllegalWalls();

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

       i!=cells.end();

    }

  }

  TestIllegalWalls();

  CleanUpCellNodeLists();

       w!=walls.end();

       w++) {

    if ((*w)->IllegalP() ) {