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

	* Makefile (clean): Add -f Makefile argument to each make invocation.

	* VirtualLeaf-install.nsi: New gpl license text.

	* VirtualLeaf.pro: Disabled console mode.

	* mesh.cpp (Clear): Added parentheses to qDebug statments.

	(TestIllegalWalls): Replaced qDebug().

	* canvas.cpp (mouseReleaseEvent): Replaced qDebug() with cerr since qDebug complains about *node_set.

	* wall.cpp (CorrectWall): Rplaced gDebug() with cerr in transform call and when printing *this.

    }

  } else {

    mesh.ReactDiffuse(par.rd_dt);

    Plot(par.resize_stride);

  }

  i++;

  return mesh.getTime();

}

/* Called if a cell is clicked */

/* Custom message handler - Default appends a newline character to the end of each line. */ 

void vlMessageOutput(QtMsgType type, const char *msg)

{

  switch (type) {

  case QtDebugMsg:

    //fprintf(stderr, "Debug: %s\n", msg);

    cerr << msg << flush;

    break;

  case QtWarningMsg:

    //fprintf(stderr, "Warning: %s\n", msg);

  QColor diffcolor;

  static const QColor purple("Purple");

  static const QColor blue("blue");

  Wall *w=&getWall();

  double val = w->getApoplast(2);

  diffcolor.setRgb( 0,0,(int)( ( val / (1 + val) )*255.));

  setPen (QPen(diffcolor, 20) );

}

/* finis*/

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

	* Makefile (clean): Add windows equivalent of UNIX touch.

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

	* plugin_auxingrowth.pro: Changed default LIBXML2DIR, LIBICONVDIR and LIBZDIR to corresponding distribution lib directories.

	* plugin_meinhardt.pro: Ditto.

	* plugin_test.pro: Ditto.

	* Makefile (clean): add if stmt not to `touch` on windows.

#include "auxingrowthplugin.h"

#include "far_mem_5.h"

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

bool batch = false;

// To be executed after cell division

void AuxinGrowthPlugin::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2)

{

  // Auxin distributes between parent and daughter according to area

  double area1 = daughter1->Area(), area2 = daughter2->Area();

  double tot_area = area1 + area2;

  daughter1->SetChemical(0,daughter1->Chemical(0)*(area1/tot_area));

  daughter2->SetChemical(0,daughter2->Chemical(0)*(area2/tot_area));

  // After divisions, parent and daughter cells get a standard stock of PINs.

  daughter1->SetChemical(1, par->initval[1]);

  daughter2->SetChemical(1, par->initval[1]);

#include "parameter.h"

#include "warning.h"

#include "wallbase.h"

#include "cellbase.h"

#include "meinhardtplugin.h"

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

bool batch = false;

// To be executed after cell division

void MeinhardtPlugin::SetCellColor(CellBase *c, QColor *color) { 

  if (fpclassify(c->Chemical(0))==FP_NAN) {

    // somehow the function isnan doesn't work properly on my system... SuSE Linux

    // 10.0 64-bits (isnan seems not be implemented using fpclassify).

    MyWarning::warning("Whoops! Numerical instability!!");

    color->setNamedColor("red");

  } else {

    double range_min = 0.;//, range_max = 1.;

    if (c->Chemical(0)<range_min) {

      MyWarning::warning("Whoops! Numerical instability!!");

  }

  // Passive fluxes (Fick's law)

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

    double phi = w->Length() * ( par->D[c] ) * ( w->C2()->Chemical(c) - w->C1()->Chemical(c) );

    dchem_c1[c] += phi; 

    dchem_c2[c] -= phi;

  }

}

void MeinhardtPlugin::WallDynamics(Wall *w, double *dw1, double *dw2) {

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

    dw1[c] = 0.; dw2[c] = 0.;

  }

}

void MeinhardtPlugin::CellDynamics(CellBase *c, double *dchem) {

  double Y = c->Chemical(0);

  double A = c->Chemical(1);

  double H = c->Chemical(2);

  double S = c->Chemical(3);

#include "parameter.h"

#include "wallbase.h"

#include "cellbase.h"

#include "testplugin.h"

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

bool batch = false;

// To be executed after cell division

void TestPlugin::SetCellColor(CellBase *c, QColor *color) { 

  static QStringList colors;

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

    colors << "red" << "green" << "blue";

  }

  color->setNamedColor(colors[c->Index()%colors.size()]);

}

void TestPlugin::CellHouseKeeping(CellBase *c) {

  c->EnlargeTargetArea(par->cell_expansion_rate);

  if (c->Area() > par->rel_cell_div_threshold * c->BaseArea() ) {

    c->Divide();

  }

}

Q_EXPORT_PLUGIN2(testplugin, TestPlugin)

/* finis */

static const int imageRTTI = 984376;

extern Parameter par;

const QString Main::caption("Virtual leaf");

const QString Main::caption_with_file("Virtual leaf: %1");

FigureEditor::FigureEditor(

			   QGraphicsScene& c, Mesh &m, QWidget* parent,

			   const char* name, Qt::WindowFlags f) :

  QGraphicsView(&c,parent), mesh(m)

{

  intersection_line = 0;

  //angle_line = 0;

  setInteractive(true);

  moving = 0;  

  rotation_mode = false;

}

void FigureEditor::clear()

{

  QList<QGraphicsItem *> list = scene()->items();

  QList<QGraphicsItem *>::Iterator it = list.begin();

  line->setPen( QPen(QColor(par.arrowcolor),2) );

  line->setZValue(2);

  line->setLine( ( (offset[0]+from.x)*factor ),

		 ( (offset[1]+from.y)*factor ), 

		 ( (offset[0]+to.x)*factor ),

		 ( (offset[1]+to.y)*factor ) );

  line->setZValue(10);

  line->show();

}

void Cell::DrawStrain(QGraphicsScene *c) const {

  MyWarning::warning("Sorry, Cell::DrawStrain temporarily not implemented.");

}

void Cell::DrawFluxes(QGraphicsScene *c, double arrowsize)

{

  // get the mean flux through this cell

  Vector vec_flux = ReduceCellAndWalls<Vector>( PINdir );

  vec_flux.Normalise();

  {

    NCells()=0;

  }

  bool marked;

  int div_counter;

};

ostream &operator<<(ostream &os, const CellBase &v);

inline Vector PINdir(CellBase *here, CellBase *nb, Wall *w)

{

  return w->getTransporter( here, 1)  *  w->getInfluxVector(here);

}

#endif

/* finis*/

void ForwardEuler::odeint(double *ystart, int nvar, double x1, double x2, double eps, double h1, double hmin, int *nok, int *nbad)

/* Runge-Kutta driver with adaptive stepsize control. Integrate starting values ystart[1..nvar]

   from x1 to x2 with accuracy eps, storing intermediate results in global variables. h1 should

   be set as a guessed first stepsize, hmin as the minimum allowed stepsize (can be zero). On

   output nok and nbad are the number of good and bad (but retried and fixed) steps taken, and

   ystart is replaced byv alues at the end of the integration interval. derivs is the user-supplied

   routine for calculating the right-hand side derivative, while rkqs is the name of the stepper

   routine to be used. */

{

  static bool warning_issued = false;

  if (!warning_issued) {

    cerr << "Using inaccurate method ForwardEuler\n";

    warning_issued=true;

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

  }

  // N.B. Not for serious use and not fully usage compatible with RungeKutta

  // simply for testing API of integrator.

  double *y,*dydx;

  y=new double[nvar];

  dydx=new double[nvar];

  double x=x1;

  };

  virtual void XMLReadSettings(xmlNode *settings);

  virtual void XMLReadViewport(xmlNode *viewport);

  virtual double getFluxArrowsize(void) { return 10.;}

  void Save(const char *fname, const char *format, int sizex=640, int sizey=480);

  void CutSAM(void);

  void Plot(int resize_stride=10);

  virtual void UserMessage(QString message, int timeout = 0) {

    cerr << message.toAscii().constData() << endl;

  }

  Mesh &mesh;

  QTransform viewport;

 protected:

  QGraphicsScene &canvas;

  virtual xmlNode *XMLSettingsTree(void) const;

  virtual xmlNode *XMLViewportTree(QTransform &transform) const;

 protected:

  bool showcentersp;

  bool showmeshp;

  bool showbordercellp;

void NodeItem::userMove(double dx, double dy)

{

  QGraphicsItem::moveBy( dx, dy );

  class_cast<Node *>(obj)->x += (dx/Cell::Magnification());

  class_cast<Node *>(obj)->y += (dy/Cell::Magnification());

}

void NodeItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *)

{

  painter->setBrush(brush);

  painter->setPen(Qt::NoPen);

  painter->drawEllipse(ellipsesize);

}

QPainterPath NodeItem::shape() const

{

  QPainterPath path;

  path.addEllipse(ellipsesize);

  return path;

}

#define _QCANVASARROW_H_

#include <QGraphicsScene>

class QGraphicsArrowItem : public QGraphicsLineItem {

 public:

 QGraphicsArrowItem(QGraphicsItem *parent, QGraphicsScene *c) : QGraphicsLineItem(parent, c) {};

  void paint ( QPainter *p, const QStyleOptionGraphicsItem *option,

	       QWidget *widget ) {

    // construct arrow head

    QPointF start=line().p1();

    QPointF end=line().p2();

    QPointF mid=start + (3./4.)*(end-start);

    double vx=end.x()-start.x();

    double vy=end.y()-start.y();

    double length = sqrt(vx*vx+vy*vy);

    if (length==0) return;

    // perpendicular vector

 *  Copyright 2010 Roeland Merks.

 *

 */

#include <string>

#include <QBrush>

#include "simitembase.h"

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

SimItemBase::SimItemBase( void *v, QGraphicsScene *canvas )

{

  obj=v;

};

SimItemBase::~SimItemBase(void) {};

/* finis */