EI/VirtualLeaf Changeset - 59e38e5f05d2 · Centrum Wiskunde & Informatica (CWI)

Changeset - 59e38e5f05d2

Parent rev.

Child rev.

[Not reviewed]

default

0 15 0

Michael Guravage - 15 years ago 2010-06-23 16:21:32
michael.guravage@cwi.nl

Reverted NULL assignments to obviate compilation warnings.

--
user: Michael Guravage <michael.guravage@cwi.nl>
branch 'default'

changed src/ChangeLog
changed src/VirtualLeaf.cpp
changed src/apoplastitem.cpp
changed src/build_models/ChangeLog
changed src/build_models/auxingrowthplugin.cpp
changed src/build_models/meinhardtplugin.cpp
changed src/build_models/testplugin.cpp
changed src/canvas.cpp
changed src/cell.cpp
changed src/cellbase.h
changed src/forwardeuler.cpp
changed src/mainbase.h
changed src/nodeitem.cpp
changed src/qcanvasarrow.h
changed src/simitembase.cpp

15 files changed with 29 insertions and 53 deletions:

src/ChangeLog

src/VirtualLeaf.cpp

src/apoplastitem.cpp

src/build_models/ChangeLog

src/build_models/auxingrowthplugin.cpp

src/build_models/meinhardtplugin.cpp

src/build_models/testplugin.cpp

src/canvas.cpp

src/cell.cpp

src/cellbase.h

src/forwardeuler.cpp

src/mainbase.h

src/nodeitem.cpp

src/qcanvasarrow.h

src/simitembase.cpp

0 comments (0 inline, 0 general)

src/ChangeLog

➞

Show inline comments

 -06-23    <guravage@caterpie.sen.cwi.nl>
 	* simitembase.cpp: Removed NULL assignments to unused variables.
 	* VirtualLeaf.cpp: Ditto.
 	* apoplastitem.cpp: Ditto.
 	* canvas.cpp: Ditto.
 	* cell.cpp: Ditto.
 	* cellbase.h: Ditto.
 	* forwardeuler.cpp: Ditto.
 	* mainbase.h: Ditto.
 	* nodeitem.cpp: Ditto.
 	* qcanvasarrow.h: Ditto.
 	* simitembase.cpp: Ditto.
 	* 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.
 -06-22    <guravage@caterpie.sen.cwi.nl>
 	* Makefile (tutorials): Add tutorials target.
 -06-21    <guravage@caterpie.sen.cwi.nl>
 	* parameter.cpp: Added particular reassignment of datadir.
 	* canvas.cpp (gpl): Added GPL3 License text. Display detail text only if the source text file exists.
 -06-18    <guravage@caterpie.sen.cwi.nl>
 	* canvas.cpp (gpl): Added gpl slot to display GPL license.
 	* VirtualLeaf.pro: Changed default LIBXML2DIR, LIBICONVDIR and LIBZDIR to corresponding distribution lib directories.
 	* libplugin.pro: Ditto.
 	* Makefile (clean): add if stmt not to `touch` on windows.
 -06-17    <guravage@caterpie.sen.cwi.nl>
 	* VirtualLeaf.pro: Removed perl references.
 	* libplugin.pro: Ditto.
 -06-15    <guravage@caterpie.sen.cwi.nl>
 	* VirtualLeaf.pro: Removed xmlwritecode.cpp from SOURCES list.
 	* xmlwrite.cpp (XMLSave): Removed references to XMLWriteLeafSourceCode and XMLWriteReactionsCode.
 	* xmlwrite.h (XMLIO): Ditto!
 	* mesh.cpp (findNextBoundaryNode): Initialize Node *next_boundary_node = NULL;
 	* xmlwrite.cpp (XMLReadSimtime): Removed unused variable cur
 	(XMLReadWalls): viz_flux need not be declared twice; default value of 0.0.
 	(XMLReadCells): Removed unused count variable.
 	(XMLReadSimtime): Removed unused cur variable.
 	(XMLRead): Removed unused v_str variable.
 	* simitembase.cpp (userMove): Use assignment merely to obviate compilation warning.
 	(SimItemBase) Ditto.
 	* qcanvasarrow.h (QGraphicsLineItem): Use assignment merely to obviate compilation warning.
 	* output.cpp (OpenWriteFile): Removed unused par variable.
 	* nodeitem.cpp (paint): Use assignment merely to obviate compilation warning.
 	* forwardeuler.cpp (odeint): Use assignment merely to obviate compilation warning.
 	* cell.cpp (DivideOverGivenLine): Use assignment merely to obviate compilation warning.
 	* canvas.cpp (FigureEditor): Use assignments merely to obviate compilation errors.
 	(mousePressEvent): Removed unused item variable.
 	* apoplastitem.cpp
 	(ApoplastItem): Removed unused par variable.
 	(OnClick): Use NULL assignment merely to obviate compilation warning.
 	* mainbase.h (MainBase): Use assignment merely to obviate compilation warning.
 	* cellbase.h (CellsStaticDatamembers): Use assignment merely to obviate compilation warning.
 	* cell.cpp: Wrapped diagnostic output in QDEBUG blocks.
 	* VirtualLeaf.cpp ditto.
 	* canvas.cpp ditto.
 	* cell.cpp ditto.
 	* data_plot.cpp ditto.
 	* forwardeuler.cpp ditto.
 	* mesh.cpp ditto.
 	* mesh.h
 	* random.cpp ditto.
 	* wall.cpp ditto.
 	* wallbase.cpp ditto.
 	* wallitem.cpp ditto.
 -06-07    <guravage@caterpie.sen.cwi.nl>
 	* VirtualLeaf.pro: Removed explicit perl invocation to regerenerate parameter files.
 	* libplugin.pro: ditto.
 -06-03    <guravage@caterpie.sen.cwi.nl>
 	* pardialog.h: Added default versions of this automatically generated file.
 	* pardialog.cpp: ditto.
 	* parameter.h: ditto.
 	* parameter.cpp: ditto.
 	* VirtualLeaf.pro: delete/generate  parameter.{h,cpp}and pardialog.{h,cpp} only if perl is installed.
  	* libplugin.pro: dito.
 	* Makefile: Added top-level Makefile
 -05-10    <guravage@caterpie.sen.cwi.nl>
 	* VirtualLeaf.pro: Added -fPIC option to QMAKE_CXXFLAGS.

src/VirtualLeaf.cpp

➞

Show inline comments

@@ @@ -86,381 +86,378 @@ public: @@
       c.SetSource(0,par.source);
     } else {
       cerr << "Cell " << c.Index() << " is _not_ a source cell.\n";
+    }
+  }
 };
 class CellInfo {
 public:
   void operator() (Cell &c,std::ostream &os) const {
     os << "Cell " << c.index << " says: " << endl;
     os << "c.nodes.size() = " << c.nodes.size() << endl;
     for (list<Node *>::iterator i=c.nodes.begin(); i!=c.nodes.end(); i++) {
       cerr << (*i)->Index() << " ";
+    }
     cerr << endl;
+  }
 };
 double PINSum(Cell &c) {
   return c.Chemical(1) + c.SumTransporters(1);// + c.ReduceCellAndWalls<double>( complex_PijAj );
+}
 class DrawCell {
 public:
   void operator() (Cell &c,QGraphicsScene &canvas, MainBase &m) const {
     if (m.ShowBorderCellsP() || c.Boundary()==Cell::None) {
       if (!m.ShowBoundaryOnlyP() && !m.HideCellsP()) {
 	if (m.ShowToolTipsP()) {
 	  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);
+	}
+      }
       if (m.ShowCentersP()){
 	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) ) {
       FitLeafToCanvas();
+    }
+  }
   mesh.LoopCells(DrawCell(),canvas,*this);
   if (ShowNodeNumbersP())
     mesh.LoopNodes( bind2nd (mem_fun_ref ( &Node::DrawIndex), &canvas ) ) ;
   if (ShowCellNumbersP())
     mesh.LoopCells( bind2nd (mem_fun_ref ( &Cell::DrawIndex), &canvas ) ) ;
   if (ShowCellAxesP())
     mesh.LoopCells( bind2nd (mem_fun_ref ( &Cell::DrawAxis), &canvas ) );
   if (ShowCellStrainP())
     mesh.LoopCells( bind2nd (mem_fun_ref ( &Cell::DrawStrain), &canvas ) );
   if (ShowWallsP())
     mesh.LoopWalls( bind2nd( mem_fun_ref( &Wall::Draw ), &canvas ) );
   if (ShowApoplastsP())
     mesh.LoopWalls( bind2nd( mem_fun_ref( &Wall::DrawApoplast ), &canvas ) );
   if (ShowMeshP())
     mesh.DrawNodes(&canvas);
   if (ShowBoundaryOnlyP())
     mesh.DrawBoundary(&canvas);
   if ( ( batch || MovieFramesP() )) {
     static int frame = 0;
     // frame numbers are sequential for the most frequently written file type.
     // for the less frequently written file type they match the other type
     if (!(count%par.storage_stride) )  {
       stringstream fname;
       fname << par.datadir << "/leaf.";
       fname.fill('0');
       fname.width(6);
       fname << frame << ".jpg";
       if (par.storage_stride <= par.xml_storage_stride) {
 	frame++;
+      }
       // Write high-res JPG snapshot every plot step
       Save(fname.str().c_str(), "JPEG",1024,768);
+    }
     if (!(count%par.xml_storage_stride)) {
       stringstream fname;
       fname << par.datadir << "/leaf.";
       fname.fill('0');
       fname.width(6);
       fname << frame << ".xml";
       if (par.xml_storage_stride < par.storage_stride) {
 	frame++;
+      }
       // Write XML file every ten plot steps
       mesh.XMLSave(fname.str().c_str(), XMLSettingsTree());
+    }
+  }
+}
 INIT {
   //mesh.SetSimPlugin(plugin);
   if (leaffile) {
     xmlNode *settings;
     mesh.XMLRead(leaffile, &settings);
     main_window->XMLReadSettings(settings);
     xmlFree(settings);
     main_window->UserMessage(QString("Ready. Time is %1").arg(mesh.getTimeHours().c_str()));
   } else {
     mesh.StandardInit();
+  }
+}
 TIMESTEP {
   static int i=0;
   static int t=0;
   static int ncells;
   if (!batch) {
     UserMessage(QString("Time: %1").arg(mesh.getTimeHours().c_str()),0);
+  }
   ncells=mesh.NCells();
   double dh;
   if(DynamicCellsP()) {
     dh = mesh.DisplaceNodes();
     // Only allow for node insertion, cell division and cell growth
     // if the system has equillibrized
     // i.e. cell wall tension equillibrization is much faster
     // than biological processes, including division, cell wall yielding
     // and cell expansion
     mesh.InsertNodes(); // (this amounts to cell wall yielding)
     if ( (-dh) < par.energy_threshold) {
       mesh.IncreaseCellCapacityIfNecessary();
       mesh.DoCellHouseKeeping();
       //mesh.LoopCurrentCells(mem_fun(&plugin->CellHouseKeeping)); // this includes cell division
       // Reaction diffusion
       mesh.ReactDiffuse(par.rd_dt);
       t++;
       Plot(par.resize_stride);
+    }
   } else {
     mesh.ReactDiffuse(par.rd_dt);
     Plot(par.resize_stride);
+  }
   i++;
   return mesh.getTime();
+}
 /* Called if a cell is clicked */
 void Cell::OnClick(QMouseEvent *e)
+{
   e = NULL; // use assignment merely to obviate compilation warning
+}
 void Cell::OnClick(QMouseEvent *e){}
 /* 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);
     cerr << "Warning: " << msg << flush;
     break;
   case QtCriticalMsg:
     fprintf(stderr, "Critical: %s\n", msg);
     cerr << "Critical: " << msg << flush;
     break;
   case QtFatalMsg:
     //fprintf(stderr, "Fatal: %s\n", msg);
     cerr << "Fatal: " << msg << flush;
     abort();
+  }
+}
 Parameter par;
 int main(int argc,char **argv) {
   try {
     int c;
     char *leaffile=0;
     char *modelfile=0;
     while (1) {
       //int this_option_optind = optind ? optind : 1;
       int option_index = 0;
       static struct option long_options[] = {
 	{"batch", no_argument, NULL, 'b'},
 	{"leaffile", required_argument, NULL, 'l'},
 	{"model", required_argument, NULL, 'm'}
       };
       // short option 'p' creates trouble for non-commandline usage on MacOSX. Option -p changed to -P (capital)
       static char *short_options = "blm";
       c = getopt_long (argc, argv, "bl:m:",
 		       long_options, &option_index);
       if (c == -1)
 	break;
       if (c==0) {
 	printf ("option %s", long_options[option_index].name);
 	if (optarg)
 	  printf (" with arg %s", optarg);
 	printf ("\n");
 	c = short_options[option_index];
+      }
       switch (c) {
       case 'b':
 	cerr << "Running in batch mode\n";
 	batch=true;
 	break;
       case 'l':
 	leaffile=strdup(optarg);
 	if (!leaffile) {
 	  throw("Out of memory");
+	}
 	printf("Reading leaf state file '%s'\n", leaffile);
 	break;
       case 'm':
 	modelfile=strdup(optarg);
 	if (!modelfile) {
 	  throw("Out of memory");
+	}
 	break;
       case '?':
 	break;
       default:
 	printf ("?? getopt returned character code 0%o ??\n", c);
+      }
+    }
     if (optind < argc) {
       printf ("non-option ARGV-elements: ");
       while (optind < argc)
 	printf ("%s ", argv[optind++]);
       printf ("\n");
+    }
     bool useGUI = !batch;
     qInstallMsgHandler(vlMessageOutput); // custom message handler
     QApplication app(argc,argv,useGUI);
     QPalette tooltippalette = QToolTip::palette();
     QColor transparentcolor = QColor(tooltippalette.brush(QPalette::Window).color());
     tooltippalette.setBrush (QPalette::Window, QBrush (transparentcolor) );
     QToolTip::setPalette( tooltippalette );
     QGraphicsScene canvas(0,0,8000,6000);
     if (useGUI) {
       main_window=new Main(canvas, mesh);
       if ( QApplication::desktop()->width() > ((Main *)main_window)->width() + 10
 	   && QApplication::desktop()->height() > ((Main *)main_window)->height() +30 ) {
 	((Main *)main_window)->show();
 	((Main *)main_window)->resize( ((Main *)main_window)->sizeHint());
       } else {
         ((Main *)main_window)->showMaximized();
+      }
       // show "About" window at start up
       ((Main *)main_window)->about();
     } else {
       main_window=new MainBase(canvas, mesh);
+    }
     canvas.setSceneRect(QRectF());
     if (!batch) {
       QObject::connect( qApp, SIGNAL(lastWindowClosed()), qApp, SLOT(quit()) );
+    }
     // Install model or read catalogue of models
     ModelCatalogue model_catalogue(&mesh, useGUI?(Main *)main_window:0,modelfile);
     if (useGUI)
       model_catalogue.PopulateModelMenu();
     model_catalogue.InstallFirstModel();
     if (leaffile)
       main_window->Init(leaffile);
     Cell::SetMagnification(1);
     Cell::setOffset(0,0);
     main_window->FitLeafToCanvas();
     main_window->Plot();
     if (batch) {
       double t=0.;
       do {
 	t = main_window->TimeStep();
       } while (t < par.maxt);
     } else
       return app.exec();
   } catch (const char *message) {
     if (batch) {
       cerr << "Exception caught:" << endl;
       cerr << message << endl;
       abort();
     } else {
       QString qmess=QString("Exception caught: %1").arg(message);
       QMessageBox::critical(0, "Critical Error", qmess);
       abort();
+    }
   } catch (ios_base::failure) {
     stringstream error_message;
     error_message << "I/O failure: " << strerror(errno);
     if (batch) {
       cerr << error_message.str() <<endl;
       abort();
     } else {
       QString qmess(error_message.str().c_str());
       QMessageBox::critical(0, "I/O Error", qmess );
       abort();
+    }
+  }
+}
 /* finis */

src/apoplastitem.cpp

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
  *  The Virtual Leaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
  *  The Virtual Leaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <QGraphicsScene>
 #include "canvas.h"
 #include "parameter.h"
 #include "node.h"
 #include "apoplastitem.h"
 static const std::string _module_id("$Id$");
 ApoplastItem::ApoplastItem( Wall *w, QGraphicsScene *canvas )
   : QGraphicsLineItem( 0, canvas ), SimItemBase( w, canvas){
   setColor();
   // line with "PIN1"is a bit inside the cell wall
   Vector edgevec = (*(w->N2())) - (*(w->N1()));
   Vector perp = edgevec.Normalised().Perp2D();
   Vector offs = Cell::Offset();
   double factor = Cell::Factor();
   Vector from = ( offs + *(w->N1()) ) * factor;
   Vector to = ( offs + *(w->N2()) ) *factor;
   setLine(( from.x ),
 	  ( from.y ),
 	  ( to.x ),
 	  ( to.y ) );
   setZValue(12);
+}
 void ApoplastItem::setColor(void) {
   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) );
+}
 void ApoplastItem::OnClick(QMouseEvent *e) {
   e = NULL; // merely to obviate compilation warnings
+}
 void ApoplastItem::OnClick(QMouseEvent *e) {}
 /* finis*/

src/build_models/ChangeLog

➞

Show inline comments

 -06-23    <guravage@caterpie.sen.cwi.nl>
 	* auxingrowthplugin.cpp: Removed NULL assignments to unused variables.
 	* meinhardtplugin.cpp: Ditto.
 	* testplugin.cpp: Ditto.
 -06-22    <guravage@caterpie.sen.cwi.nl>
 	* Makefile (clean): Add windows equivalent of UNIX touch.
 -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.
 -06-15    <guravage@caterpie.sen.cwi.nl>
 	* testplugin.cpp (CelltoCellTransport) Use NULL assignment merely to obviate compilation warnings.
 	(WallDynamics): Ditto.
 	(CellDynamics): Ditto.
 	(OnDivide): Ditto.
 	* meinhardtplugin.cpp (OnDivide): Use NULL assignment merely to obviate compilation warnings.
 	* (WallDynamics): Ditto.
 	* auxingrowthplugin.cpp (OnDivide): Use NULL assignment merely to obviate compilation warnings.
 -06-03    <guravage@caterpie.sen.cwi.nl>
 	* Makefile: Added top-level Makefile.
 -05-10    <guravage@caterpie.sen.cwi.nl>
 	* plugin_test.pro: Added -fPIC option to QMAKE_CXXFLAGS.
 	* plugin_meinhardt.pro: ditto
 	* plugin_auxingrowth.pro: ditto

src/build_models/auxingrowthplugin.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
  *  The Virtual Leaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
  *  The Virtual Leaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include "../simplugin.h"
 #include "parameter.h"
 #include "wallbase.h"
 #include "cellbase.h"
 #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)
+{
   parent_info = NULL; // merely to obviate compile time error
   // 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]);
   // Reset transporter values of parent and daughter
   QList<WallBase *> walls;
   foreach(WallBase *w, walls) {
     w->setTransporter(daughter1, 1, 0.);
+  }
+}
 void AuxinGrowthPlugin::SetCellColor(CellBase *c, QColor *color)
+{
   // Red: PIN1
   // Green: Auxin
   if (c->CellType()==1)
     color->setNamedColor("Blue");
   else
     color->setRgb(c->Chemical(1)/(1+c->Chemical(1)) * 255.,(c->Chemical(0)/(1+c->Chemical(0)) * 255.), 0);
+}
 void AuxinGrowthPlugin::CellHouseKeeping(CellBase *c)
+{
   if (c->Boundary()==CellBase::None) {
     if (c->Area() > par->rel_cell_div_threshold * c->BaseArea() ) {
       c->SetChemical(0,0);
       c->Divide();
+    }
     if (c->Chemical(0)>0.6) {
       c->SetCellType(1);
+    }
     // expand according to auxin concentration
     c->EnlargeTargetArea(par->auxin_dependent_growth?(c->Chemical(0)/(1.+c->Chemical(0)))*par->cell_expansion_rate:par->cell_expansion_rate);
+  }
+}
 void AuxinGrowthPlugin::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2)
+{
   // leaf edge is const source of auxin
   // (Neumann boundary condition: we specify the influx)
   if (w->C2()->BoundaryPolP()) {
     if (w->AuxinSource()) {
       double aux_flux = par->leaf_tip_source * w->Length();
       dchem_c1[0]+= aux_flux;
       return;
     } else {
       return;
+    }
+  }
   if (w->C1()->BoundaryPolP()) {
     if (w->AuxinSource()) {
       double aux_flux = par->leaf_tip_source * w->Length();
       dchem_c2[0] += aux_flux;
       return;
     } else {
       if (w->AuxinSink()) {
 	// efflux into Shoot Apical meristem
 	// we assume all PINs are directed towards shoot apical meristem
 	dchem_c2[0] -= par->sam_efflux * w->C2()->Chemical(0) / (par->ka + w->C2()->Chemical(0));
 	return;
       } else
 	return;
+    }
+  }
   // Passive fluxes (Fick's law)
   // only auxin flux now
   // flux depends on edge length and concentration difference
   int c=0;
   double phi = w->Length() * ( par->D[c] ) * ( w->C2()->Chemical(c) - w->C1()->Chemical(c) );
   dchem_c1[c] += phi;
   dchem_c2[c] -= phi;
   // Active fluxes (PIN1 mediated transport)
   // (Transporters measured in moles, here)
   // efflux from cell 1 to cell 2
   double trans12 = ( par->transport * w->Transporters1(1) * w->C1()->Chemical(0) / (par->ka + w->C1()->Chemical(0)) );
   // efflux from cell 2 to cell 1
   double trans21 = ( par->transport * w->Transporters2(1) * w->C2()->Chemical(0) / (par->ka + w->C2()->Chemical(0)) );
   dchem_c1[0] += trans21 - trans12;
   dchem_c2[0] += trans12 - trans21;
+}
 void AuxinGrowthPlugin::WallDynamics(Wall *w, double *dw1, double *dw2)
+{
   // Cells polarize available PIN1 to Shoot Apical Meristem
   if (w->C2()->BoundaryPolP()) {
     if (w->AuxinSink()) {
       dw1[0] = 0.; dw2[0] = 0.;
       // assume high auxin concentration in SAM, to convince PIN1 to polarize to it
       // exocytosis regulated0
       double nb_auxin = par->sam_auxin;
       double receptor_level = nb_auxin * par->r / (par->kr + nb_auxin);
       dw1[1] = par->k1 * w->C1()->Chemical(1) * receptor_level /( par->km + w->C1()->Chemical(1) ) - par->k2 * w->Transporters1(1);
       dw2[1] = 0.;
       return;
     } else {
       dw1[0]=dw2[0]=dw1[1]=dw2[1];
       return;
+    }
+  }
   if (w->C1()->BoundaryPolP()) {
     if (w->AuxinSink())  {
       dw1[0] = 0.; dw2[0] = 0.;
       // assume high auxin concentration in SAM, to convince PIN1 to polarize to it
       // exocytosis regulated
       double nb_auxin = par->sam_auxin;
       double receptor_level = nb_auxin * par->r / (par->kr + nb_auxin);
       dw2[1] = par->k1 * w->C2()->Chemical(1) * receptor_level /( par->km + w->C2()->Chemical(1) ) - par->k2 * w->Transporters2(1);
       dw1[1] = 0.;
       return;
     }  else {
       dw1[0]=dw2[0]=dw1[1]=dw2[1];
       return;
+    }
+  }
   // PIN1 localization at wall 1
   // Note: chemical 0 is Auxin (intracellular storage only)
   // Chemical 1 is PIN1 (walls and intracellular storage)
   //! \f$ \frac{d Pij/dt}{dt} = k_1 A_j \frac{P_i}{L_ij} - k_2 P_{ij} \f$
   // Note that Pij is measured in term of concentration (mol/L)
   // Pi in terms of quantity (mol)
   double dPijdt1=0., dPijdt2=0.;
   // normal cell
   double  auxin2 = w->C2()->Chemical(0);
   double receptor_level1 = auxin2 * par->r / (par->kr + auxin2);
   dPijdt1 =
     // exocytosis regulated
     par->k1 * w->C1()->Chemical(1) * receptor_level1 / ( par->km + w->C1()->Chemical(1) ) - par->k2 * w->Transporters1(1);
   double  auxin1 = w->C1()->Chemical(0);
   double receptor_level2 = auxin1 * par->r / (par->kr + auxin1);
   // normal cell
   dPijdt2 =
     // exocytosis regulated
     par->k1 * w->C2()->Chemical(1) * receptor_level2 / ( par->km + w->C2()->Chemical(1) ) - par->k2 * w->Transporters2(1);
   /* PIN1 of neighboring vascular cell inhibits PIN1 endocytosis */
   dw1[0] = 0.; dw2[0] = 0.;
   dw1[1] = dPijdt1;
   dw2[1] = dPijdt2;
+}
 double AuxinGrowthPlugin::complex_PijAj(CellBase *here, CellBase *nb, Wall *w)
+{
   // gives the amount of complex "auxinreceptor-Pin1"  at the wall (at QSS)
   //return here.Chemical(1) * nb.Chemical(0) / ( par->km + here.Chemical(1));
   double nb_aux = (nb->BoundaryPolP() && w->AuxinSink()) ? par->sam_auxin : nb->Chemical(0);

src/build_models/meinhardtplugin.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
  *  The Virtual Leaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
  *  The Virtual Leaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include "../simplugin.h"
 #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::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) {
   parent_info = NULL;
   daughter1 = daughter2 = NULL;
+}
 void MeinhardtPlugin::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) {}
 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!!");
       color->setNamedColor("blue");
     } else {
       color->setRgb(c->Chemical(1)/(1+c->Chemical(1)) * 255.,(c->Chemical(0)/(1+c->Chemical(0)) * 255.),(c->Chemical(3)/(1+c->Chemical(3)) *255.) );
+    }
+  }
+}
 void MeinhardtPlugin::CellHouseKeeping(CellBase *c) {
   if (c->Area() > par->rel_cell_div_threshold * c->BaseArea() ) {
     c->Divide();
+  }
   // cell expansion is inhibited by substrate (chem 3)
   if (!par->constituous_expansion_limit || c->NCells()<par->constituous_expansion_limit) {
     c->EnlargeTargetArea(par->cell_expansion_rate );
   } else {
     if (c->Chemical(0)<0.5) {
       double tmp;
       c->EnlargeTargetArea((tmp=(1.-par->vessel_inh_level*c->Chemical(3))*par->cell_expansion_rate /* + c->Chemical(4)*/)<0?0:tmp);
     } else {
       c->EnlargeTargetArea(par->vessel_expansion_rate);
+    }
+  }
+}
 void MeinhardtPlugin::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2) {
   // No flux boundaries for all chemicals, except activator: boundary is sink
   if (w->C1()->BoundaryPolP() || w->C2()->BoundaryPolP()) {
     if (w->C1()->BoundaryPolP()) {
       dchem_c2[1] -=  w->Length() * ( par->D[1] ) * ( w->C2()->Chemical(1) );
     } else {
       dchem_c1[1] -=  w->Length() * ( par->D[1] ) * ( w->C1()->Chemical(1) );
+    }
     return;
+  }
   // 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) {
   w = NULL;
   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);
   dchem[0] = ( par->d * A - par->e * Y + Y*Y/(1 + par->f * Y*Y ) );
   dchem[1] = ( par->c * A*A*S/H - par->mu * A + par->rho0*Y );
   dchem[2] = ( par->c * A*A*S - par->nu*H + par->rho1*Y );
   dchem[3] = ( par->c0 - par->gamma*S - par->eps * Y * S );
+}
 Q_EXPORT_PLUGIN2(meinhardtplugin, MeinhardtPlugin)
 /* finis */

src/build_models/testplugin.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
  *  The Virtual Leaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
  *  The Virtual Leaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <QObject>
 #include <QtGui>
 #include "simplugin.h"
 #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::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) {
   parent_info = NULL;
   daughter1 = daughter2 = NULL;
+}
 void TestPlugin::OnDivide(ParentInfo *parent_info, CellBase *daughter1, CellBase *daughter2) {}
 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();
+  }
+}
 void TestPlugin::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2) {
   w = NULL;
   dchem_c1 = dchem_c2 = NULL;
+}
 void TestPlugin::CelltoCellTransport(Wall *w, double *dchem_c1, double *dchem_c2) {}
 void TestPlugin::WallDynamics(Wall *w, double *dw1, double *dw2) {
   w = NULL;
   dw1 = dw2 = NULL;
+}
 void TestPlugin::WallDynamics(Wall *w, double *dw1, double *dw2) {}
 void TestPlugin::CellDynamics(CellBase *c, double *dchem) {
   c = NULL;
   dchem=NULL;
+}
 void TestPlugin::CellDynamics(CellBase *c, double *dchem) {}
 Q_EXPORT_PLUGIN2(testplugin, TestPlugin)
 /* finis */

src/canvas.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
  *  The Virtual Leaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
  *  The Virtual Leaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <fstream>
 #include <streambuf>
 #include <QGraphicsScene>
 #include <QGraphicsView>
 #include <qdatetime.h>
 #include <q3mainwindow.h>
 #include <qstatusbar.h>
 #include <qmessagebox.h>
 #include <qmenubar.h>
 #include <qapplication.h>
 #include <qpainter.h>
 #include <qprinter.h>
 #include <qlabel.h>
 #include <qimage.h>
 #include <q3progressdialog.h>
 #include <qtimer.h>
 #include <qslider.h>
 #include <qpixmap.h>
 #include <qfile.h>
 #include <qdir.h>
 #include <q3filedialog.h>
 #include <QGraphicsItem>
 #include <QList>
 #include <QDir>
 #include <QDebug>
 #include <set>
 //Added by qt3to4:
 #include <Q3ValueList>
 #include <Q3PopupMenu>
 #include <QMouseEvent>
 #include <typeinfo>
 #include <cstring>
 #include <q3process.h>
 #include <qlayout.h>
 #include <qspinbox.h>
 #include <fstream>
 #include <sstream>
 #include "pardialog.h"
 #include "parameter.h"
 #include "canvas.h"
 #include "node.h"
 #include "nodeset.h"
 #include "nodeitem.h"
 #include "cellitem.h"
 #include "wallitem.h"
 #include "mesh.h"
 #include "xmlwrite.h"
 #include "miscq.h"
 #include "OptionFileDialog.h"
 #include <cstdlib>
 #include <cstdio>
 #include "modelcatalogue.h"
 #include <algorithm>
 // Include VIB and PSB logos
 #include "psb.xpm"
 #include "cwi.xpm"
 static const std::string _module_id("$Id$");
 // We use a global variable to save memory - all the brushes and pens in
 // the mesh are shared.
 #define QUOTE_ME(s) QUOTE_ME_2NDLEV(s)
 #define QUOTE_ME_2NDLEV(s) #s
 static QColor dark_red("darkRed");
 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)
+{
   name = NULL; // use these two assignments merely to obviate compile time warnings
   f = Qt::Widget;
   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();
   for (; it != list.end(); ++it) {
     delete *it;
+  }
+}
 void FigureEditor::wheelEvent(QWheelEvent *event)
+{
   scaleView(pow((double)2, -event->delta() / 240.0));
+}
 void FigureEditor::scaleView (qreal scaleFactor)
+{
   qreal factor = matrix().scale(scaleFactor, scaleFactor).mapRect(QRectF(0, 0, 1, 1)). width();
   if (factor < 0.07 || factor > 100) return;
   scale (scaleFactor, scaleFactor);
+}
 void FigureEditor::Save(const char *fname, const char *format, int sizex, int sizey)
+{
   QImage *image = new QImage(sizex, sizey, QImage::Format_RGB32);
   image->fill(QColor(Qt::white).rgb());
   QPainter *painter=new QPainter(image);
   render(painter);
   image->save(QString(fname),format);
   delete painter;
   delete image;
+}
 void FigureEditor::mousePressEvent(QMouseEvent* e)
+{
   static QList<Node*> selected;
   emit MousePressed();
   //QPointF p = matrix().inverted().map(e->pos());
   QPointF p = mapToScene(e->pos());
 #ifdef QDEBUG
   qDebug() << endl << "MousePressEvent location: (" << p.x() << "," << p.y() << ")." << endl;
   qDebug() << "Magnification:  " << Cell::Magnification() << endl;
   qDebug() << "Offsets:  " << Cell::Offset() << endl;
 #endif
   QList<QGraphicsItem *> l=scene()->items(p);
 #ifdef QDEBUG
   qDebug() << "MousePressEvents, items: " << l.size() << endl;
   qDebug() << "Mouse button modifier: " << e->modifiers() << endl;
 #endif
   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) {
 #ifdef QDEBUG
     qDebug() << typeid(**it).name() << endl;
 #endif
     if ( !strcmp(typeid(**it).name(),"8NodeItem")) {
       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());
 	// 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::mouseMoveEvent(QMouseEvent* e)
+{
   // User chooses "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() );
     dynamic_cast<Main *>(parent())->Plot(0);
     FullRedraw();
     return;
+  }
   if ( moving ) {
     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 ( intersection_line ) {
     QPointF sp = intersection_line -> line().p1(); // startpoint
     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 ) {
 #ifdef QDEBUG
       qDebug() << "Trying to cut leaf" << endl;
 #endif
       QPointF sp = intersection_line -> line().p1(); // startpoint
       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) {
 #ifdef QDEBUG
 	qDebug() << "No cells detected :-(" << endl;
 #endif
 	return;
+      }
       Vector startpoint = Vector(sp.x(), sp.y()) / Cell::Factor() - Cell::Offset();
       Vector endpoint = Vector(ep.x(), ep.y()) / Cell::Factor() - Cell::Offset();

src/cell.cpp

➞

Show inline comments

@@ @@ -1363,325 +1363,324 @@ void Cell::ConstructWalls(void) @@
       AddWall(  new Wall(*nb,*i,duplicates[0],duplicates[1]) );
       if (!duplicates[1]->BoundaryPolP()) {
 	neighbors.push_back(duplicates[1]);
+      }
     } else {
       AddWall ( new Wall(*nb,*i,duplicates[1],duplicates[0]) );
       if (!duplicates[0]->BoundaryPolP()) {
 	neighbors.push_back(duplicates[0]);
+      }
+    }
+  }
+}
 void BoundaryPolygon::Draw(QGraphicsScene *c, QString tooltip)
+{
   // Draw the BoundaryPolygon on a QCanvas object
   CellItem* p = new CellItem(this, c);
   QPolygonF pa(nodes.size());
   int cc=0;
   for (list<Node *>::const_iterator n=nodes.begin(); n!=nodes.end(); n++) {
     Node *i=*n;
     pa[cc++] = QPoint((int)((Offset().x+i->x)*Factor()), (int)((Offset().y+i->y)*Factor()) );
+  }
   p->setPolygon(pa);
   p->setPen(par.outlinewidth>=0?QPen( QColor(par.cell_outline_color),par.outlinewidth):QPen(Qt::NoPen));
   p->setBrush( Qt::NoBrush );
   p->setZValue(1);
   if (!tooltip.isEmpty())
     p->setToolTip(tooltip);
   p->show();
+}
 void Cell::Flux(double *flux, double *D)
+{
   // loop over cell edges
   for (int c=0;c<NChem();c++)
     flux[c]=0.;
   for (list<Wall *>::iterator i=walls.begin(); i!=walls.end(); i++) {
     // leaf cannot take up chemicals from environment ("no flux boundary")
     if ((*i)->c2->BoundaryPolP()) continue;
     // flux depends on edge length and concentration difference
     for (int c=0;c<NChem();c++) {
       double phi = (*i)->length * ( D[c] ) * ( ((Cell *)(*i)->c2)->chem[c] - chem[c] );
 #ifdef QDEBUG
       if ((*i)->c1!=this) {
 	qDebug() << "Warning, bad cells boundary: " << (*i)->c1->Index() << ", " << index << endl;
+      }
 #endif
       flux[c] += phi;
+    }
+  }
+}
 // graphics stuff, not compiled for batch versions
 #ifdef QTGRAPHICS
 #include "canvas.h"
 void Cell::Draw(QGraphicsScene *c, QString tooltip)
+{
   // Draw the cell on a QCanvas object
   if (DeadP()) {
 #ifdef QDEBUG
     qDebug() << "Cell " << index << " not drawn, because dead." << endl;
 #endif
     return;
+  }
   CellItem* p = new CellItem(this, c);
   QPolygonF pa(nodes.size());
   int cc=0;
   for (list<Node *>::const_iterator n=nodes.begin(); n!=nodes.end(); n++) {
     Node *i=*n;
     pa[cc++] = QPoint((int)((offset[0]+i->x)*factor),
 		      (int)((offset[1]+i->y)*factor) );
+  }
   QColor cell_color;
   m->plugin->SetCellColor(this,&cell_color);
   p->setPolygon(pa);
   p->setPen(par.outlinewidth>=0?QPen( QColor(par.cell_outline_color),par.outlinewidth):QPen(Qt::NoPen));
   p->setBrush( cell_color );
   p->setZValue(1);
   if (!tooltip.isEmpty())
     p->setToolTip(tooltip);
   p->show();
+}
 void Cell::DrawCenter(QGraphicsScene *c) const {
   // Maginfication derived similarly to that in nodeitem.cpp
   // Why not use Cell::Magnification()?
   const double mag = par.node_mag;
   // construct an ellipse
   QGraphicsEllipseItem *disk = new QGraphicsEllipseItem ( -1*mag, -1*mag, 2*mag, 2*mag, 0, c );
   disk->setBrush( QColor("forest green") );
   disk->setZValue(5);
   disk->show();
   Vector centroid=Centroid();
   disk -> setPos((offset[0]+centroid.x)*factor,(offset[1]+centroid.y)*factor);
+}
 void Cell::DrawNodes(QGraphicsScene *c) const {
   for (list<Node *>::const_iterator n=nodes.begin(); n!=nodes.end(); n++) {
     Node *i=*n;
     NodeItem *item = new NodeItem ( &(*i), c );
     item->setColor();
     item->setZValue(5);
     item->show();
     item ->setPos(((offset[0]+i->x)*factor), ((offset[1]+i->y)*factor) );
+  }
+}
 void Cell::DrawIndex(QGraphicsScene *c) const {
   DrawText( c, QString("%1").arg(index));
+}
 // Draw any text in the cell's center
 void Cell::DrawText(QGraphicsScene *c, const QString &text) const {
   Vector centroid = Centroid();
   QGraphicsSimpleTextItem *ctext = new QGraphicsSimpleTextItem ( text, 0, c );
   ctext->setPen( QPen(QColor(par.textcolor)) );
   ctext->setZValue(20);
   ctext->setFont( QFont( "Helvetica", par.cellnumsize, QFont::Bold) );
   ctext->show();
   ctext ->setPos(((offset[0]+centroid.x)*factor),
 		 ((offset[1]+centroid.y)*factor) );
+}
 void Cell::DrawAxis(QGraphicsScene *c) const {
   Vector long_axis;
   double width;
   Length(&long_axis, &width);
   //cerr << "Length is "  << length << endl;
   long_axis.Normalise();
   Vector short_axis=long_axis.Perp2D();
   Vector centroid = Centroid();
   Vector from = centroid - 0.5 * width * short_axis;
   Vector to = centroid + 0.5 * width *short_axis;
   QGraphicsLineItem *line = new QGraphicsLineItem(0, c);
   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 {
   c = NULL; // assignment merely to obviate compilation warning
   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();
   vec_flux *= arrowsize;
   QGraphicsArrowItem *arrow = new QGraphicsArrowItem(0,c);
   Vector centroid = Centroid();
   Vector from = centroid - vec_flux/2.;
   Vector to = centroid + vec_flux/2.;
   arrow->setPen( QPen(QColor(par.arrowcolor),par.outlinewidth));
   arrow->setZValue(2);
   arrow->setLine( ( (offset[0]+from.x)*factor ),
 		  ( (offset[1]+from.y)*factor ),
 		  ( (offset[0]+to.x)*factor ),
 		  ( (offset[1]+to.y)*factor ) );
   arrow->setZValue(10);
   arrow->show();
+}
 void Cell::DrawWalls(QGraphicsScene *c) const {
   for_each(walls.begin(), walls.end(), bind2nd ( mem_fun ( &Wall::Draw ) , c ) );
   // to see the cells connected the each wall (for debugging), uncomment the following
   //for_each(walls.begin(), walls.end(), bind2nd ( mem_fun ( &Wall::ShowStructure ), c ) );
+}
 void Cell::DrawValence(QGraphicsScene *c) const {
   DrawText(c, QString("%1").arg(walls.size()) );
+}
 #endif // QTGRAPHICS !
 /*! \brief Recalculate the lengths of the cell's Walls.
   Call this function after the Monte Carlo updates, and before doing the reaction-diffusion iterations.
 */
 void Cell::SetWallLengths(void)
+{
   for (list<Wall *>::iterator de=walls.begin(); de!=walls.end(); de++) {
     // Step 1: find the path of nodes leading along the Wall.
     // A Wall often represents a curved cell wall: we want the total
     // length _along_ the wall here...
     // Locate first and second nodes of the edge in list of nodes
     list<Node *>::const_iterator first_node_edge = find(nodes.begin(), nodes.end(), (*de)->n1);
     list<Node *>::const_iterator second_node_edge_plus_1 = ++find(nodes.begin(), nodes.end(), (*de)->n2);
     double sum_length = 0.;
     // Now, walk to the second node of the edge in the list of nodes
     for (list<Node *>::const_iterator n=++first_node_edge; n!=second_node_edge_plus_1; ++n ) {
       if (n==nodes.end())
 	n=nodes.begin(); /* wrap around */
       list<Node *>::const_iterator prev_n = n;
       if (prev_n==nodes.begin())
 	prev_n=nodes.end();
       --prev_n;
       // Note that Node derives from a Vector, so we can do vector calculus as defined in vector.h
       sum_length += (*(*prev_n) - *(*n)).Norm();
       //cerr << "Node " << *prev_n << " to " << *n << ", cumulative length = " << sum_length << endl;
+    }
     // We got the total length of the Wall now, store it:
     (*de)->length = sum_length;
     //cerr << endl;
     // goto next de
+  }
+}
 //! Add Wall w to the list of Walls
 void Cell::AddWall( Wall *w )
+{
   // if necessary, we could try later inserting it at the correct position
 #ifdef QDEBUG
   if (w->c1 == w->c2 ){
     qDebug() << "Wall between identical cells: " << w->c1->Index()<< endl;
+  }
 #endif
   // Add Wall to Cell's list
   walls.push_back( w );
   // Add wall to Mesh's list if it isn't there yet
   if (find ( m->walls.begin(), m->walls.end(), w ) == m->walls.end() ) { m->walls.push_back(w);
+  }
+}
 //! Remove Wall w from the list of Walls
 list<Wall *>::iterator Cell::RemoveWall( Wall *w )
+{
   // remove wall from Mesh's list
   m->walls.erase( find( m->walls.begin(), m->walls.end(), w ) );
   // remove wall from Cell's list
   return walls.erase (find( walls.begin(), walls.end(), w ));
+}
 void Cell::EmitValues(double t)
+{
   //  cerr << "Attempting to emit " << t << ", " << chem[0] << ", " << chem[1] << endl;
   emit ChemMonValue(t, chem);
+}
 /* finis */

src/cellbase.h

➞

Show inline comments

@@ @@ -264,199 +264,198 @@ class CellBase : public QObject, public @@
   inline bool Marked(void) const {
     return marked;
+  }
   //! Returns the sum of chemical "chem" of this CellBase's neighbors
   double SumChemicalsOfNeighbors(int chem)
+  {
     double sum=0.;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum +=  (*w)->Length() * ( (*w)->c1!=this ? (*w)->c1->Chemical(chem) : (*w)->c2->Chemical(chem) );
+    }
     return sum;
+  }
   //! Generalization of the previous member function
   template<class P, class Op> P ReduceNeighbors(Op f) {
     P sum=0;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum += (*w)->c1 != this ? f( *((*w)->c1) ) : f ( *((*w)->c2) );
+    }
     return sum;
+  }
   //! The same, but now for the walls
   template<class P, class Op> P ReduceWalls(Op f, P sum) {
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum += f( **w );
+    }
     return sum;
+  }
   //! The same, but now for the walls AND neighbors
   template<class P, class Op> P ReduceCellAndWalls(Op f)
+  {
     P sum = 0;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum += ((*w)->c1 == this) ?
 	f( ((*w)->c1), ((*w)->c2), *w ) :
 	f( ((*w)->c2), ((*w)->c1), *w );
+    }
     return sum;
+  }
   //! Sum transporters at this CellBase's side of the walls
   double SumTransporters(int ch)
+  {
     double sum=0.;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum += (*w)->getTransporter(this, ch);
+    }
     return sum;
+  }
   inline int NumberOfDivisions(void) { return div_counter; }
   //! Sum transporters at this CellBase's side of the walls
   double SumLengthTransporters(int ch)
+  {
     double sum=0.;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum += (*w)->getTransporter(this, ch) * (*w)->Length();
+    }
     return sum;
+  }
   double SumLengthTransportersChemical(int trch, int ch)
+  {
     double sum=0.;
     for (list<Wall *>::const_iterator w=walls.begin();
 	 w!=walls.end();
 	 w++) {
       sum += (*w)->getTransporter(this, trch) * ( (*w)->c1!=this ? (*w)->c1->Chemical(ch) : (*w)->c2->Chemical(ch) );
+    }
     return sum;
+  }
   inline int CellType(void) const { return cell_type; }
   inline void SetCellType(int ct) { cell_type = ct; }
   static void SetNChem(int new_nchem)
+  {
     if (NCells()) {
       MyWarning::error("CellBase::SetNChem says: not permitted, call SetNChem after deleting all cells.");
     } else {
       NChem() = new_nchem;
+    }
+  }
   inline double TargetLength() const { return target_length; }
   static inline CellsStaticDatamembers *GetStaticDataMemberPointer(void) { return static_data_members; }
  protected:
   // (define a list of Node* iterators)
   typedef list < list<Node *>::iterator > ItList;
   int index;
   inline void SetChemToNewchem(void)
+  {
     for (int c=0;c<CellBase::NChem();c++) {
       chem[c]=new_chem[c];
+    }
+  }
   inline void SetNewChemToChem(void)
+  {
     for (int c=0;c<CellBase::NChem();c++) {
       new_chem[c]=chem[c];
+    }
+  }
   inline double NewChem(int c) const { return new_chem[c]; }
  protected:
   list<Node *> nodes;
   void ConstructNeighborList(void);
   long wall_list_index (Wall *elem) const;
   // DATA MEMBERS
   // list of nodes, in clockwise order
   // a (non-ordered) list of neighboring cells (actually I think the
   // introduction of ConstructWalls() has made these
   // lists ordered (clockwise), but I am not yet 100% sure...).
   list<CellBase *> neighbors;
   list<Wall *> walls;
   double *chem;
   double *new_chem;
   boundary_type boundary;
   mutable double area;
   double target_area;
   double target_length;
   double lambda_celllength;
   double stiffness; // stiffness like in Hogeweg (2000)
   bool fixed;
   bool pin_fixed;
   bool at_boundary;
   bool dead;
   bool flag_for_divide;
   Vector *division_axis;
   int cell_type;
   // for length constraint
   mutable double intgrl_xx, intgrl_xy, intgrl_yy, intgrl_x, intgrl_y;
   bool source;
   Vector cellvec;
   // STATIC DATAMEMBERS MOVED TO CLASS
   static CellsStaticDatamembers *static_data_members;
   double source_conc;
   int source_chem;
   // PRIVATE MEMBER FUNCTIONS
   inline static void ClearNCells(void)
+  {
     NCells()=0;
+  }
   bool marked;
   int div_counter;
 };
 ostream &operator<<(ostream &os, const CellBase &v);
 inline Vector PINdir(CellBase *here, CellBase *nb, Wall *w)
+{
   nb = NULL; // assignment merely to obviate compilation warning
   return w->getTransporter( here, 1)  *  w->getInfluxVector(here);
+}
 #endif
 /* finis*/

src/forwardeuler.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
  *  The Virtual Leaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
  *  The Virtual Leaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <cmath>
 #include <iostream>
 #include "forwardeuler.h"
 #include "warning.h"
 #include "maxmin.h"
 #include <string>
 using namespace std;
 static const string _module_id("$Id$");
 // The value Errcon equals (5/Safety) raised to the power (1/PGrow), see use below.
 const double ForwardEuler::Safety  = 0.9;
 const double ForwardEuler::PGrow = -0.2;
 const double ForwardEuler::Pshrnk = -0.25;
 const double ForwardEuler::Errcon = 1.89e-4;
 const double ForwardEuler::Maxstp = 10000000;
 const double ForwardEuler::Tiny = 1.0e-30;
 /* User storage for intermediate results. Preset kmax and dxsav in the calling program. If kmax =
 results are stored at approximate intervals dxsav in the arrays xp[1..kount], yp[1..nvar]
    [1..kount], where kount is output by odeint. Defining declarations for these variables, with
    memoryallo cations xp[1..kmax] and yp[1..nvar][1..kmax] for the arrays, should be in
    the calling program.*/
 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;
   eps = hmin = 0.0; // use assignment merely to obviate compilation warning
   nbad = nok = NULL;
   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;
   for (int i=0;i<nvar;i++) y[i]=ystart[i];
   //if (kmax > 0) xsav=x-dxsav*2.0; //Assures storage of first step.
   dydx=new double[nvar];
   for (int nstp=0;nstp<Maxstp;nstp++) {
     derivs(x,y,dydx);
     if (kmax > 0 && kount < kmax-1) {
       xp[kount]=x; //Store intermediate results.
       for (int i=0;i<nvar;i++) yp[i][kount]=y[i];
       kount++;
       //xsav=x;
+    }
     for (int i=0;i<nvar;i++) {
       y[i]=y[i] + h1 * dydx[i];
+    }
     x = x + h1;
     if ((x-x2)*(x2-x1) >= 0.0) { //Are we done?
       goto done;
+    }
+  }
  done:
   for (int i=0;i<nvar;i++) ystart[i]=y[i];
   if (kmax) {
     xp[kount]=x; //Save final step.
     for (int i=0;i<nvar;i++) yp[i][kount]=y[i];
+  }
   delete[] dydx;
   delete[] y;
   return; //Normal exit.
+}
 /* finis */

src/mainbase.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
  *  The Virtual Leaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
  *  The Virtual Leaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _MAINBASE_H_
 #define _MAINBASE_H_
 #include <QGraphicsScene>
 #include <qpixmap.h>
 #include <q3picture.h>
 #include <qpainter.h>
 #include <qwidget.h>
 #include <iostream>
 #include <QGraphicsItem>
 #include <QPrinter>
 #include "mesh.h"
 #include "warning.h"
 using namespace std;
 /*! Implement these functions in your main application */
 class MainBase  {
  public:
  MainBase(QGraphicsScene &c, Mesh &m) : mesh(m), canvas(c) {
     // Standard options for batch version
     showcentersp =  false;
     showmeshp =  false;
     showbordercellp =  false;
     shownodenumbersp =  false;
     showcellnumbersp =  false;
     showcellsaxesp = false;
     showcellstrainp =  false;
     movieframesp = true;
     showboundaryonlyp =  false;
     showwallsp =  false;
     showfluxesp = false;
     dynamicscellsp = true;
     showtooltipsp = false;
     hidecellsp = false;
+  }
   virtual ~MainBase() {};
   virtual double TimeStep();
   virtual void Init(char *leaffile=0);
   virtual bool ShowCentersP(void) {return showcentersp;}
   virtual bool ShowMeshP(void) {return showmeshp; }
   virtual bool ShowBorderCellsP(void) {return showbordercellp; }
   virtual bool PausedP(void) {return false; }
   virtual bool ShowNodeNumbersP(void) {return shownodenumbersp; }
   virtual bool ShowCellNumbersP(void) {return showcellnumbersp;}
   virtual bool ShowCellAxesP(void) {return showcellsaxesp;}
   virtual bool ShowCellStrainP(void) {return showcellstrainp;}
   virtual bool MovieFramesP(void) {return movieframesp;}
   virtual bool ShowBoundaryOnlyP(void) {return showboundaryonlyp;}
   virtual bool ShowToolTipsP(void) {return showtooltipsp;}
   virtual bool ShowWallsP(void) {return showwallsp;}
   virtual bool ShowApoplastsP(void) { return showapoplastsp;}
   virtual bool ShowFluxesP(void) { return showfluxesp; }
   virtual bool DynamicCellsP(void) { return dynamicscellsp; }
   virtual void FitCanvasToWindow() {};
   virtual void FitLeafToCanvas() {};
   virtual bool HideCellsP(void) { return hidecellsp; }
   virtual void clear(void) {
     QList<QGraphicsItem *> list = canvas.items();
     QList<QGraphicsItem *>::Iterator it = list.begin();
     for (; it != list.end(); ++it) {
       if ( *it )
 	delete *it;
+    }
   };
   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) {
     timeout = 0; // merely to obviate 'warning unused parameter' message
     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;
   bool shownodenumbersp;
   bool showcellnumbersp;
   bool showcellsaxesp;
   bool showcellstrainp;
   bool movieframesp;
   bool showboundaryonlyp;
   bool showwallsp;
   bool showapoplastsp;
   bool showfluxesp;
   bool dynamicscellsp;
   bool showtooltipsp;
   bool hidecellsp;
 };
 //#include <qapplication.h>
 #define TIMESTEP double MainBase::TimeStep(void)
 #define INIT void MainBase::Init(char *leaffile)
 #endif
 /* finis */

src/nodeitem.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
  *  The Virtual Leaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
  *  The Virtual Leaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <QGraphicsScene>
 #include <QGraphicsItem>
 #include <QPainter>
 #include <QStyleOption>
 #include <Qt>
 #include "nodeitem.h"
 #include "parameter.h"
 static const std::string _module_id("$Id$");
 extern Parameter par;
 NodeItem::NodeItem( Node *n, QGraphicsScene *canvas )
   : QGraphicsItem( 0, canvas ), SimItemBase( n, canvas) {
   brush = Qt::darkGray;
   const double mag = par.node_mag;
   ellipsesize=QRectF(-1*mag, -1*mag, 2*mag, 2*mag);
+}
 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 *)
+{
   option = NULL; // use assignment merely to obviate compilation warning
   painter->setBrush(brush);
   painter->setPen(Qt::NoPen);
   painter->drawEllipse(ellipsesize);
+}
 QPainterPath NodeItem::shape() const
+{
   QPainterPath path;
   path.addEllipse(ellipsesize);
   return path;
+}
 QRectF NodeItem::boundingRect() const
+{
   qreal penwidth = 0;// painter->pen()->widthF();
   return QRectF(ellipsesize.x()-penwidth/2.,ellipsesize.y()-penwidth/2.,
 		ellipsesize.width()+penwidth, ellipsesize.height()+penwidth);
+}
 // polymorphic OnClick functions
 void NodeItem::OnClick(void)
+{
   Node *n = &getNode();
   n->toggleBoundary();
   setColor();
   update();
+}
 void NodeItem::OnClick(const Qt::MouseButton &mb)
+{
   if (mb == Qt::LeftButton) {
     Node *n = &getNode();
     n->toggleBoundary();
     setColor();
     update();
+  }
+}
 void NodeItem::setColor(void)
+{
   static QColor indian_red("IndianRed");
   static QColor deep_sky_blue("DeepSkyBlue");
   static QColor purple("Purple");
   Node &n=getNode();
   if (n.SamP()) {
     setBrush( purple );
   } else {
     if (n.BoundaryP()) {
       setBrush( deep_sky_blue );
+    }
     else {
       setBrush( indian_red );
+    }
+  }
+}
 /* finis */

src/qcanvasarrow.h

➞

Show inline comments

 /*
+ *
  *  $Id$
+ *
  *  This file is part of the Virtual Leaf.
+ *
  *  The Virtual Leaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
  *  The Virtual Leaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #ifndef _QCANVASARROW_H_
 #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 ) {
     widget = NULL; //use assignment merely to obviate compilation warning
     option = NULL;
     // 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
     double px=-vy/length;
     double py=vx/length;
     // Arrow head lines go from end point
     // to points about 3/4 of the total arrow, extending sideways about 1/4
     // of the arrow length.
     QPointF arwp1 = mid + QPointF( (int)( (length/4.)*px ),
 				   (int)( (length/4.)*py ) );
     QPointF arwp2 = mid - QPointF( (int)( (length/4.)*px ),
 				   (int)( (length/4.)*py ) );
     p->setPen(pen());
     // Draw arrow head
     p->drawLine( end, arwp1 );
     p->drawLine( end, arwp2 );
     // Draw arrow line
     p->drawLine( start, end);
+  }
 };
 #endif
 /* finis */

src/simitembase.cpp

➞

Show inline comments

 /*
+ *
  *  This file is part of the Virtual Leaf.
+ *
  *  The Virtual Leaf is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation, either version 3 of the License, or
  *  (at your option) any later version.
+ *
  *  The Virtual Leaf is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
+ *
  *  You should have received a copy of the GNU General Public License
  *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
  *  Copyright 2010 Roeland Merks.
+ *
  */
 #include <string>
 #include <QBrush>
 #include "simitembase.h"
 static const std::string _module_id("$Id$");
 SimItemBase::SimItemBase( void *v, QGraphicsScene *canvas )
+{
   canvas = NULL; // use assignment merely to obviate compilation warning
   obj=v;
 };
 SimItemBase::~SimItemBase(void) {};
 void SimItemBase::userMove(double dx, double dy)
+{
   dx = dy = 0.0; // use assignment merely to obviate compilation warning
 };
 void SimItemBase::userMove(double dx, double dy){};
 /* finis */

0 comments (0 inline, 0 general)