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;

    while (1) {

      //int this_option_optind = optind ? optind : 1;

      int option_index = 0;

      static struct option long_options[] = {

      };

      // short option 'p' creates trouble for non-commandline usage on MacOSX. Option -p changed to -P (capital)

		       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 '?':

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

    }

  } else {

        main_window=new MainBase(canvas, mesh);

 }

    canvas.setSceneRect(QRectF());

    if (!batch) {

      QObject::connect( qApp, SIGNAL(lastWindowClosed()), qApp, SLOT(quit()) );

    }

	  // Load plugins

	  /*QVector<SimPluginInterface *> plugins = LoadPlugins();

	  InstallPlugin(plugins[0], main_window);

	  cerr << "List of models:" << endl;

	  foreach (SimPluginInterface *p, plugins) {

		  cerr << p->ModelID().toStdString() << endl;

	  }

	  */

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

#

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

#

CONFIG += qt

QMAKE_CXXFLAGS += -fexceptions

QMAKE_CXXFLAGS_DEBUG += -g3

QMAKE_CXXFLAGS_DEBUG += -DQDEBUG

#REACTIONS = reactions_auxin_growth.h 

#REACTIONS = reactions_meinhardt.h

#REACTIONS = reactions_pce_growth.h

DEFINES += QTGRAPHICS

DEFINES += REACTIONS_HEADER=$${REACTIONS}

DEFINES += REACTIONS_HEADER_STRING=\"$${REACTIONS}\"

DEFINES += FLEMING

PERLDIR = ./perl

BINDIR = ../bin

DESTDIR = $$BINDIR

TARGET = VirtualLeaf

TEMPLATE = app

PARTMPL = $${TARGET}par.tmpl

MAINSRC = $${TARGET}.cpp

QT -= network sql xml

QT += qt3support

 *

 *  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 "modelcatalogue.h"

#include <QVariant>

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

	mesh = _mesh;

	mainwin = _mainwin;

}

void ModelCatalogue::LoadPlugins() {

	QDir pluginDir(QApplication::applicationDirPath()); 

	QStringList plugin_filters; // filter for plugins, i.e "*.dll", "*.dylib"

#if defined(Q_OS_WIN) 

	if (pluginDir.dirName().toLower() =="debug" 

		||pluginDir.dirName().toLower() =="release") 

		pluginDir.cdUp(); 

	plugin_filters << "*.dll";

	#elif defined(Q_OS_MAC) 

	if (pluginDir.dirName() =="MacOS"){ 

		pluginDir.cdUp(); 

		pluginDir.cdUp(); 

		pluginDir.cdUp(); 

	} 

	plugin_filters << "*.dylib";

#endif 

	pluginDir.setNameFilters(plugin_filters);

	if (!pluginDir.cd("models")) {

		MyWarning::error("Directory 'models' not found!");

	}

	foreach (QString fileName, pluginDir.entryList(QDir::Files)){ 

		QPluginLoader loader(pluginDir.absoluteFilePath(fileName)); 

		if (SimPluginInterface *plugin = 

			qobject_cast<SimPluginInterface *>(loader.instance())) {

			models.append(plugin); 

		} else {

			MyWarning::warning("Could not load plugin %s",fileName.toStdString().c_str());

		}

	}

}

void ModelCatalogue::InstallFirstModel() {

	InstallModel(models[0]);

}

void ModelCatalogue::PopulateModelMenu() {

	foreach (SimPluginInterface *model, models) {

		QAction *modelaction = new QAction(model->ModelID(), mainwin); 

		QVariant data;

		data.setValue(model);

		modelaction->setData(data);

		mainwin->modelmenu->addAction(modelaction);

	}

	connect(mainwin->modelmenu, SIGNAL(triggered(QAction *)), this, SLOT(InstallModel(QAction *)) );

}	

void ModelCatalogue::InstallModel(QAction *modelaction) {

	QVariant data = modelaction->data();

	SimPluginInterface *model = data.value<SimPluginInterface *>();

	cerr << "You chose model " << model->ModelID().toStdString() << "!\n";

	mesh->Clean();

	InstallModel(model);

}

void ModelCatalogue::InstallModel(SimPluginInterface *plugin) {

	// make sure both main and plugin use the same static datamembers (ncells, nchems...)

	plugin->SetCellsStaticDatamembers(CellBase::GetStaticDataMemberPointer());

	mesh->SetSimPlugin(plugin);

	Cell::SetNChem(plugin->NChem());

	plugin->SetParameters(&par);

}

 *  Copyright 2010 Roeland Merks.

 *

 */

#ifndef _MODELCATALOGUE_H_

#define _MODELCATALOGUE_H_

#include "warning.h"

#include "cell.h"

#include "mesh.h"

#include "simplugin.h"

#include "canvas.h"

#include <QPluginLoader>

#include <Q3PopupMenu>

#include <QAction>

#include <QDir>

#include <QApplication>

#include <QObject>

#include <QAction>

#include <QMenu>

class ModelCatalogue : public QObject {

Q_OBJECT

public:

	void LoadPlugins(); 

	void InstallFirstModel();

	void PopulateModelMenu();	

public slots:

	void InstallModel(SimPluginInterface *model);	

	void InstallModel(QAction *modelaction);

private:

	QVector<SimPluginInterface *> models;

	Mesh *mesh;

	Main *mainwin;

};

    va_list ap;

    va_start(ap, fmt);

    vfprintf(stderr, fmt, ap);		/* invoke interface to printf       */

    fprintf(stderr,"\n");     /* automatic \n by Roeland */

    fflush(stderr);			/* drain std error buffer 	    */

    va_end(ap);

    exit(1);				/* quit with error status	    */

}

#else

//#include <qmessagebox.h>

#include "UniqueMessage.h"

void MyWarning::error(const char *fmt, ...)

{

  va_list ap;

  if (Quiet) return;

  char *message = new char[1000];

  va_start(ap, fmt);

  vsnprintf(message, 999, fmt, ap);		/* invoke interface to printf       */

  va_end(ap);

  QString qmess(message);

    // batch mode: print the message to stderr

    fprintf(stderr, "Fatal error: %s\n",qmess.toStdString().c_str());

    exit(1);

  } else { // issue a dialog box

    /* Solve this with signal and slot...! */

	  //extern MainBase *main_window;

    //((Main *)main_window)->stopSimulation();

	QMessageBox::critical( 0 , "Fatal error", qmess, QMessageBox::Abort, QMessageBox::NoButton, QMessageBox::NoButton );

    fprintf(stderr, "Error: %s\n",qmess.toStdString().c_str());

    QCoreApplication::exit(1);

    std::exit(1);

  }

  delete[] message;

}

#endif

/*

 * EPRINTF: scream, but don't die yet.

 * Roeland changed this to "warning" (21/10/1998)

 * and added an automatic "\n"

 */

  va_start(ap, fmt);

  vfprintf(stderr, fmt, ap);		/* invoke interface to printf       */

  fprintf(stderr,"\n");     /* automatic \n by Roeland */

  fflush(stderr);			/* drain std error buffer 	    */

  va_end(ap);

}

#else 

#include <qmessagebox.h>

void MyWarning::warning(const char *fmt, ...)

{

  va_list ap;

  if (Quiet) return;

  char *message = new char[1000];

  va_start(ap, fmt);

  vsnprintf(message, 999, fmt, ap);		/* invoke interface to printf       */

  va_end(ap);

  QString qmess(message);

    // batch mode: print the message to stderr

    fprintf(stderr, "Warning: %s\n",qmess.toStdString().c_str());

  } else { // issue a dialog box

	  UniqueMessageBox msgBox( QString("Warning"), qmess );

	  msgBox.exec();

  }

  delete[] message;

}

#endif

/*! Issues a warning only once,

  by comparing it to a list of warnings issued previously. */

void MyWarning::unique_warning(const char *fmt, ...) {

  va_list ap;

  if (Quiet) return;

  char *message = new char[1000];

  va_start(ap, fmt);

  vsnprintf(message, 999, fmt, ap);		/* invoke interface to printf       */

  va_end(ap);

  static vector<string> previous_warnings;