Das Fenster zur Steuerung der Anlage

Das Fenster zur Steuerung der Beregnungsanlage ist das Hauptfenster der Anwendung. Über dieses Fenster kann der Benutzer zwischen automatischem und manuellem Betrieb wechseln und im manuellen Betrieb die Beregnung der einzelnen Zonen ein- und ausschalten.

Um diese Aufgabe zu bewältigen, enhthält das Fenster eine Vielzahl von Buttons, über die der Anwender die Anlage steuern kann, sowie mehrere Grafiken, über die der Anwender vom Status der Anlage informiert wird.

Quellcode

Headerdatei des Objekts

#ifndef __mainform_h
	#define __mainform_h
	#include <qwidget.h>
	#include <qlayout.h>
	#include <qpushbutton.h>
	#include <qpopupmenu.h>
	#include <qmenubar.h>
	#include <qtimer.h>
	#include <qlabel.h>
	#include <qpixmap.h>
	#include <qcheckbox.h>
	#include "parcomm.h"
	#include "portwahl.h"
	#include "modeminterpreter.h"
	#include "definitionen.h"

	class Konsole: public QWidget
	{
		Q_OBJECT
				
		public:
			Konsole (bool use_modem, QWidget *parent = 0, const char *name = 0);
			~Konsole();
			void getStatus (int*, int*, int*, int*, int*, int*);
			void writeLog (const char*);

		private:
			QPushButton *manual, *automatic, *strauch, *rasen, *blume, *biotop, *ende, 
				    *info;
			QLabel *q_regen, *q_brunnen, *q_leitung, *regen, *r_regen, *r_brunnen, 
			       *r_leitung, *r_strauch, *r_rasen, *r_blume, *r_biotop, *g_regen,
			       *g_brunnen, *g_leitung, *g_strauch, *g_rasen, *g_blume, *g_biotop,
			       *y_regen, *y_brunnen, *y_leitung, *titelbild, *logo, *garten;
			QCheckBox *smsallow;
			QGridLayout *mainlayout;
			QTimer *timer;
			ParComm *communication;
			PortWahl *pw;
			ModemInterpreter *modem;
			QPixmap *hellgelb, *dunkelgelb, *hellrot, *dunkelrot, *hellgruen, *dunkelgruen;
			char avail_regen, ein_regen, ein_brunnen, ein_leitung, ein_rasen,
			     ein_strauch, ein_blumen, ein_biotop;
			tStatus systemstatus, alterstatus;
			int logdatei;

		signals:
			void manualmode();
			void automaticmode();
			void terminate();
			void update(tStatus*);
			void rasen_on();
			void rasen_off();
			void blumen_on();
			void blumen_off();
			void strauch_on();
			void strauch_off();
			void biotop_on();
			void biotop_off();

		private slots:
			void toggle_auto (bool);
			void toggle_manu (bool);
			void showaboutdialog();
			void strauch_click (bool);
			void rasen_click (bool);
			void blume_click (bool);
			void biotop_click (bool);
			void sms_rasen (bool);
			void sms_strauch (bool);
			void sms_biotop (bool);
			void sms_blumen (bool);
			void sms_auto ();
			void onUpdate ();
	};
#endif

Implementierung des Objekts

#include "mainform.h"
#include <stdio.h>
#include "sercomm.h"
#include "dialogform.h"
#include <qobject.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>

Konsole::Konsole (bool use_modem, QWidget *parent, const char *name)
	:QWidget (parent, name), avail_regen(0), ein_regen(0), ein_brunnen(0), ein_rasen(0),
	ein_strauch(0), ein_blumen(0), ein_biotop(0)
{
	setCaption ("Beregnungsanlage");

	automatic = new QPushButton ("Automatik", this);
	automatic->setToggleButton (TRUE);
	automatic->setOn(TRUE);
	connect (automatic, SIGNAL(toggled(bool)), this, SLOT(toggle_auto(bool)));
	
	manual = new QPushButton ("Handbetrieb", this);
	manual->setToggleButton (TRUE);
	connect (manual, SIGNAL(toggled(bool)), this, SLOT(toggle_manu(bool)));

	hellrot = new QPixmap (HELLROT);
	dunkelrot = new QPixmap (DUNKELROT);
	hellgelb = new QPixmap (HELLGELB);
	dunkelgelb = new QPixmap (DUNKELGELB);
	hellgruen = new QPixmap (HELLGRUEN);
	dunkelgruen = new QPixmap (DUNKELGRUEN);

	q_regen = new QLabel ("Regenwasser", this);
	r_regen = new QLabel (this);
	r_regen->setPixmap (*hellrot);
	g_regen = new QLabel (this);
	g_regen->setPixmap (*dunkelgruen);
	y_regen = new QLabel (this);
	y_regen->setPixmap (*dunkelgelb);
	
	q_brunnen = new QLabel ("Brunnen", this);
	r_brunnen = new QLabel (this);
	r_brunnen->setPixmap (*dunkelrot);
	g_brunnen = new QLabel (this);
	g_brunnen->setPixmap (*hellgruen);
	y_brunnen = new QLabel (this);
	y_brunnen->setPixmap (*dunkelgelb);
	
	q_leitung = new QLabel ("Wasserleitung", this);
	r_leitung = new QLabel (this);
	r_leitung->setPixmap (*dunkelrot);
	g_leitung = new QLabel (this);
	g_leitung->setPixmap (*hellgruen);
	y_leitung = new QLabel (this);
	y_leitung->setPixmap (*dunkelgelb);

	regen = new QLabel (ST_KEINREGEN, this);

	strauch = new QPushButton ("Sträucher", this);
	strauch->setToggleButton(TRUE);
	strauch->setEnabled(FALSE);
	connect (strauch, SIGNAL(toggled(bool)), this, SLOT(strauch_click(bool)));
	r_strauch = new QLabel (this);
	r_strauch->setPixmap(*hellrot);
	g_strauch = new QLabel (this);
	g_strauch->setPixmap(*dunkelgruen);

	rasen = new QPushButton ("Rasen", this);
	rasen->setToggleButton(TRUE);
	rasen->setEnabled(FALSE);
	connect (rasen, SIGNAL(toggled(bool)), this, SLOT(rasen_click(bool)));
	r_rasen = new QLabel (this);
	r_rasen->setPixmap(*hellrot);
	g_rasen = new QLabel (this);
	g_rasen->setPixmap(*dunkelgruen);

	blume = new QPushButton ("Blumen", this);
	blume->setToggleButton(TRUE);
	blume->setEnabled(FALSE);
	connect (blume, SIGNAL(toggled(bool)), this, SLOT(blume_click(bool)));
	r_blume = new QLabel (this);
	r_blume->setPixmap(*hellrot);
	g_blume = new QLabel (this);
	g_blume->setPixmap (*dunkelgruen);

	biotop = new QPushButton ("Biotop", this);
	biotop->setToggleButton(TRUE);
	biotop->setEnabled(FALSE);
	connect (biotop, SIGNAL(toggled(bool)), this, SLOT(biotop_click(bool)));
	r_biotop = new QLabel (this);
	r_biotop->setPixmap(*hellrot);
	g_biotop = new QLabel (this);
	g_biotop->setPixmap(*dunkelgruen);

	smsallow = new QCheckBox ("Reagiere auf SMS", this);
	if (use_modem)
		smsallow->setChecked(TRUE);
	else
	{
		smsallow->setChecked(FALSE);
		smsallow->setEnabled(FALSE);
	}

	if ((logdatei = open (LOGFILE, O_WRONLY|O_APPEND|O_CREAT)) == -1)
		perror ("Error opening logfile");
	else
		writeLog ((use_modem) ? "Beregnungsanlage mit Modemunterstützung gestartet" : "Beregnungsanlage ohne Modemunterstützung gestartet");

	ende = new QPushButton ("Beenden", this);
	connect (ende, SIGNAL(clicked()), this, SLOT(close()));

	info = new QPushButton ("Info...", this);
	connect (info, SIGNAL(clicked()), this, SLOT(showaboutdialog()));

	titelbild = new QLabel (this);
	titelbild->setPixmap(QPixmap("images/titel.png"));

	logo = new QLabel (this);
	logo->setPixmap(QPixmap("images/logo.png"));

	garten = new QLabel (this);
	garten->setPixmap(QPixmap("images/garten.png"));

	mainlayout = new QGridLayout (this, 9, 8, 5, 5);

	mainlayout->addMultiCellWidget (titelbild, 0, 0, 0, 5);
	mainlayout->addMultiCellWidget (logo, 0, 0, 6, 7);
	
	mainlayout->addMultiCellWidget (automatic, 1, 1, 0, 3);
	mainlayout->addMultiCellWidget (manual, 1, 1, 4, 7);

	mainlayout->addWidget (q_regen, 2, 0);
	mainlayout->addWidget (r_regen, 2, 1);
	mainlayout->addWidget (g_regen, 2, 2);
	mainlayout->addWidget (y_regen, 2, 3);

	mainlayout->addWidget (q_brunnen, 3, 0);
	mainlayout->addWidget (r_brunnen, 3, 1);
	mainlayout->addWidget (g_brunnen, 3, 2);
	mainlayout->addWidget (y_brunnen, 3, 3);

	mainlayout->addWidget (q_leitung, 4, 0);
	mainlayout->addWidget (r_leitung, 4, 1);
	mainlayout->addWidget (g_leitung, 4, 2);
	mainlayout->addWidget (y_leitung, 4, 3);

	mainlayout->addMultiCellWidget (regen, 5, 5, 0, 3);
	mainlayout->addMultiCellWidget (smsallow, 6, 6, 0, 3);

	mainlayout->addWidget (strauch, 2, 4);
	mainlayout->addWidget (r_strauch, 2, 5);
	mainlayout->addWidget (g_strauch, 2, 6);

	mainlayout->addWidget (rasen, 3, 4);
	mainlayout->addWidget (r_rasen, 3, 5);
	mainlayout->addWidget (g_rasen, 3, 6);

	mainlayout->addWidget (blume, 4, 4);
	mainlayout->addWidget (r_blume, 4, 5);
	mainlayout->addWidget (g_blume, 4, 6);

	mainlayout->addWidget (biotop, 5, 4);
	mainlayout->addWidget (r_biotop, 5, 5);
	mainlayout->addWidget (g_biotop, 5, 6);

	mainlayout->addMultiCellWidget (info, 6, 6, 4, 5);

	mainlayout->addMultiCellWidget (garten, 7, 7, 0, 7, Qt::AlignCenter);
	mainlayout->addMultiCellWidget (ende, 8, 8, 0, 7);

	pw = new PortWahl();
	pw->init("Parallelport wählen", "Parallele Schnittstelle 1", "Parallele Schnittstelle 2", PAR1, PAR2);
	pw->exec();
	communication = ParComm::getPort(pw->ergebnis);
#ifndef TEST_PAR
	if (communication == NULL)
	{
		perror ("Zugriff auf parallele Schnittstelle nicht erlaubt");
		exit (-1);
	}
	connect (this, SIGNAL(manualmode()), communication, SLOT(automatik_aus()));
	connect (this, SIGNAL(automaticmode()), communication, SLOT(automatik_ein()));
	connect (this, SIGNAL(update(tStatus*)), communication, SLOT(pruefen(tStatus*)));
	connect (this, SIGNAL(rasen_on()), communication, SLOT(rasen_ein()));
	connect (this, SIGNAL(rasen_off()), communication, SLOT(rasen_aus()));
	connect (this, SIGNAL(blumen_on()), communication, SLOT(blume_ein()));
	connect (this, SIGNAL(blumen_off()), communication, SLOT(blume_aus()));
	connect (this, SIGNAL(strauch_on()), communication, SLOT(strauch_ein()));
	connect (this, SIGNAL(strauch_off()), communication, SLOT(strauch_aus()));
	connect (this, SIGNAL(biotop_on()), communication, SLOT(biotop_ein()));
	connect (this, SIGNAL(biotop_off()), communication, SLOT(biotop_aus()));
#endif
	if (use_modem)
	{
		pw->init("Serielle wählen", "Serielle Schnittstelle 1", "Serielle Schnittstelle 2", SER1, SER2);
		pw->exec();

#ifndef TEST_SER
		SerComm *scomm = new SerComm (pw->ergebnis, this);
		modem = new ModemInterpreter (scomm, (QObject*)this);
		connect (modem, SIGNAL(strauch(bool)), this, SLOT(sms_strauch(bool)));
		connect (modem, SIGNAL(rasen(bool)), this, SLOT(sms_rasen(bool)));
		connect (modem, SIGNAL(blumen(bool)), this, SLOT(sms_blumen(bool)));
		connect (modem, SIGNAL(biotop(bool)), this, SLOT(sms_biotop(bool)));
		connect (modem, SIGNAL(automatic()), this, SLOT(sms_auto()));
#endif
	}
	delete pw;
	show();
	timer = new QTimer (this);
	connect (timer, SIGNAL(timeout()), this, SLOT(onUpdate()));
	timer->start(1000, FALSE);
}

Konsole::~Konsole ()
{
	if (logdatei != -1)
	{
		writeLog ("Anlage wird abgeschaltet.");
		close (logdatei);
	}
}

void Konsole::toggle_auto (bool automatic_mode)
{
	if (automatic_mode)
	{
		automatic->setOn(TRUE);
		manual->setOn(FALSE);
		strauch->setOn(FALSE);
		strauch->setEnabled(FALSE);
		rasen->setOn(FALSE);
		rasen->setEnabled(FALSE);
		blume->setOn(FALSE);
		blume->setEnabled(FALSE);
		biotop->setOn(FALSE);
		biotop->setEnabled(FALSE);
		if (ein_rasen)
		{
			ein_rasen = 0;
			r_rasen->setPixmap (*hellrot);
			g_rasen->setPixmap (*dunkelgruen);
		}
		if (ein_strauch)
		{
			ein_strauch = 0;
			r_strauch->setPixmap (*hellrot);
			g_strauch->setPixmap (*dunkelgruen);
		}
		if (ein_blumen)
		{
			ein_blumen = 0;
			r_blume->setPixmap (*hellrot);
			g_blume->setPixmap (*dunkelgruen);
		}
		if (ein_biotop)
		{
			ein_biotop = 0;
			r_biotop->setPixmap (*hellrot);
			g_biotop->setPixmap (*dunkelgruen);
		}
		emit automaticmode();
		writeLog ("Anlage wird in automatischen Betrieb geschaltet.");
	
	else
	{
		automatic->setOn(FALSE);
		manual->setOn(TRUE);
		strauch->setEnabled(TRUE);
		rasen->setEnabled(TRUE);
		blume->setEnabled(TRUE);
		biotop->setEnabled(TRUE);
		r_rasen->setPixmap (*hellrot);
		g_rasen->setPixmap (*dunkelgruen);
		r_strauch->setPixmap (*hellrot);
		g_strauch->setPixmap (*dunkelgruen);
		r_blume->setPixmap (*hellrot);
		g_blume->setPixmap (*dunkelgruen);
		r_biotop->setPixmap (*hellrot);
		g_biotop->setPixmap (*dunkelgruen);
		emit manualmode();
		writeLog ("Anlage wird in manuellen Betrieb geschaltet.");
	}
}

void Konsole::toggle_manu (bool manual_mode)
{
	toggle_auto (!manual_mode);
}

void Konsole::showaboutdialog()
{
	MyAboutDialog *aboutdialog = new MyAboutDialog (this);
	aboutdialog->setInfo ("Beregner-Regelung", 
			"Programm zur Regelung eines Beregners\nErstellt an der GOB Bozen\n(C)2000-2001");
	aboutdialog->exec();
	delete aboutdialog;
}

void Konsole::strauch_click (bool on)
{
	if (on)
	{
		if (!(biotop->isOn()))
		{
			r_strauch->setPixmap(*dunkelrot);
			g_strauch->setPixmap(*hellgruen);
			ein_strauch = 1;
			emit strauch_on();
		}
		else
			strauch->setOn(FALSE);
	}
	else
	{
		r_strauch->setPixmap(*hellrot);
		g_strauch->setPixmap(*dunkelgruen);
		ein_strauch = 0;
		emit strauch_off();
	}
}

void Konsole::rasen_click (bool on)
{
	if (on)
	{
		if (!(biotop->isOn()))
		{
			r_rasen->setPixmap(*dunkelrot);
			g_rasen->setPixmap(*hellgruen);
			ein_rasen = 1;
			emit rasen_on();
		}
		else
			rasen->setOn(FALSE);
	}
	else
	{
		r_rasen->setPixmap(*hellrot);
		g_rasen->setPixmap(*dunkelgruen);
		ein_rasen = 0;
		emit rasen_off();
	}
}

void Konsole::blume_click (bool on)
{
	if (on)
	{
		if (!(biotop->isOn()))
		{
			r_blume->setPixmap(*dunkelrot);
			g_blume->setPixmap(*hellgruen);
			ein_blumen = 1;
			emit blumen_on();
		}
		else
			blume->setOn(FALSE);
	}
	else
	{
		r_blume->setPixmap(*hellrot);
		g_blume->setPixmap(*dunkelgruen);
		ein_blumen = 0;
		emit blumen_off();
	}
}

void Konsole::biotop_click (bool on)
{
	if (on)
	{
		if ((!(rasen->isOn())) && (!(strauch->isOn())) && (!(blume->isOn())))
		{
			r_biotop->setPixmap(*dunkelrot);
			g_biotop->setPixmap(*hellgruen);
			ein_biotop = 1;
			emit biotop_on();
		}
		else
			biotop->setOn(FALSE);
	}
	else
	{
		r_biotop->setPixmap(*hellrot);
		g_biotop->setPixmap(*dunkelgruen);
		ein_biotop = 0;
		emit biotop_off();
	}
}

void Konsole::sms_rasen (bool ein)
{
	if (smsallow->isChecked())
	{
		if (automatic->isOn())
			automatic->setOn(FALSE);
		rasen->setOn(ein);
	}
}

void Konsole::sms_strauch (bool ein)
{
	if (smsallow->isChecked())
	{
		if (automatic->isOn())
			automatic->setOn(FALSE);
		strauch->setOn(ein);
	}
}

void Konsole::sms_blumen (bool ein)
{
	if (smsallow->isChecked())
	{
		if (automatic->isOn())
			automatic->setOn(FALSE);
		blume->setOn(ein);
	}
}

void Konsole::sms_biotop (bool ein)
{
	if (smsallow->isChecked())
	{
		if (automatic->isOn())
			automatic->setOn(FALSE);
		blume->setOn(ein);
	}
}

void Konsole::sms_auto ()
{
	if (smsallow->isChecked())
	{
		if (!automatic->isOn())
			automatic->setOn(TRUE);
	}
}

void Konsole::onUpdate ()
{
	memcpy (&alterstatus, &systemstatus, sizeof(systemstatus));
	update (&systemstatus);
	if (alterstatus.regen != systemstatus.regen)
		writeLog ((systemstatus.regen) ? "Es beginnt zu regnen." : "Es hat aufgehoert zu regnen.");
	if (alterstatus.quelle != systemstatus.quelle)
		writeLog ((systemstatus.quelle == QUELLE_BRUNNEN) ? "Neue Wasserquelle: Brunnen." : (systemstatus.quelle == QUELLE_REGEN) ? "Neue Wasserquelle: Regenwasser." : (systemstatus.quelle == QUELLE_LEITUNG) ? "Neue Wasserquelle: Leitungswasser." : "Keine Wasserquelle aktiviert.");
	if (alterstatus.strauch != systemstatus.strauch)
		writeLog ((systemstatus.strauch) ? "Beregnung der Straeucher eingeschaltet." : "Beregnung der Straeucher ausgeschaltet.");
	if (alterstatus.blumen != systemstatus.blumen)
		writeLog ((systemstatus.blumen) ? "Beregnung der Blumen eingeschaltet." : "Beregnung der Blumen ausgeschaltet.");
	if (alterstatus.rasen != systemstatus.rasen)
		writeLog ((systemstatus.rasen) ? "Beregnung des Rasens eingeschaltet." : "Beregnung des Rasens ausgeschaltet.");
	if (alterstatus.biotop != systemstatus.biotop)
		writeLog ((systemstatus.biotop) ? "Biotop wird aufgefuellt." : "Biotop ist wieder voll.");
	if (systemstatus.regen && !strcmp (regen->text().latin1(), ST_KEINREGEN))
		regen->setText (ST_REGEN);
	if (!systemstatus.regen && !strcmp (regen->text().latin1(), ST_REGEN))
		regen->setText (ST_KEINREGEN);
	if (systemstatus.regenwasser)
	{
		if (!avail_regen)
		{
			r_regen->setPixmap(*dunkelrot);
			g_regen->setPixmap(*hellgruen);
			avail_regen = 1;
		}
	}
	else
	{
		if (avail_regen)
		{
			r_regen->setPixmap(*hellrot);
			g_regen->setPixmap(*dunkelgruen);
			avail_regen = 0;
		}
	}
	switch (systemstatus.quelle)
	{
		case QUELLE_REGEN:	if (!ein_regen)
					{
						y_regen->setPixmap (*hellgelb);
						ein_regen = 1;
					}
					if (ein_brunnen)
					{
						y_brunnen->setPixmap (*dunkelgelb);
						ein_brunnen = 0;
					}
					if (ein_leitung)
					{
						y_leitung->setPixmap (*dunkelgelb);
						ein_leitung = 0;
					}
					break;
		case QUELLE_BRUNNEN:	if (ein_regen)
					{
						y_regen->setPixmap (*dunkelgelb);
						ein_regen = 0;
					}
					if (!ein_brunnen)
					{
						y_brunnen->setPixmap (*hellgelb);
						ein_brunnen = 1;
					}
					if (ein_leitung)
					{
						y_leitung->setPixmap (*dunkelgelb);
						ein_leitung = 0;
					}
					break;
		case QUELLE_LEITUNG:	if (ein_regen)
					{
						y_regen->setPixmap (*dunkelgelb);
						ein_regen = 0;
					}
					if (ein_brunnen)
					{
						y_brunnen->setPixmap (*dunkelgelb);
						ein_brunnen = 0;
					}
					if (!ein_leitung)
					{
						y_leitung->setPixmap (*hellgelb);
						ein_leitung = 1;
					}
					break;
		case AUS:		if (ein_regen)
					{
						y_regen->setPixmap (*dunkelgelb);
						ein_regen = 0;
					}
					if (ein_brunnen)
					{
						y_brunnen->setPixmap (*dunkelgelb);
						ein_brunnen = 0;
					}
					if (ein_leitung)
					{
						y_leitung->setPixmap (*dunkelgelb);
						ein_leitung = 0;
					}
					break;
	}
	/* wenn sich die Anlage im Automatikbetrieb befindet, muessen auch die LEDs fuer die einzelnen
	 * Beregnungszonen gesetzt werden. */
	if (automatic->isOn())
	{
		if (systemstatus.rasen)
		{
			if (!ein_rasen)
			{
				ein_rasen = 1;
				r_rasen->setPixmap(*dunkelrot);
				g_rasen->setPixmap(*hellgruen);
			}
		}
		else
		{
			if (ein_rasen)
			{
				ein_rasen = 0;
				r_rasen->setPixmap(*hellrot);
				g_rasen->setPixmap(*dunkelgruen);
			}
		}
		if (systemstatus.strauch)
		{
			if (!ein_strauch)
			{
				ein_strauch = 1;
				r_strauch->setPixmap(*dunkelrot);
				g_strauch->setPixmap(*hellgruen);
			}
		}
		else
		{
			if (ein_strauch)
			{
				ein_strauch = 0;
				r_strauch->setPixmap(*hellrot);
				g_strauch->setPixmap(*dunkelgruen);
			}
		}
		if (systemstatus.blumen)
		{
			if (!ein_blumen)
			{
				ein_blumen = 1;
				r_blume->setPixmap(*dunkelrot);
				g_blume->setPixmap(*hellgruen);
			}
		}
		else
		{
			if (ein_blumen)
			{
				ein_blumen = 0;
				r_blume->setPixmap(*hellrot);
				g_blume->setPixmap(*dunkelgruen);
			}
		}
		if (systemstatus.biotop)
		{
			if (!ein_biotop)
			{
				ein_biotop = 1;
				r_biotop->setPixmap(*dunkelrot);
				g_biotop->setPixmap(*hellgruen);
			}
		}
		else
		{
			if (ein_biotop)
			{
				ein_biotop = 0;
				r_biotop->setPixmap(*hellrot);
				g_biotop->setPixmap(*dunkelgruen);
			}
		}
	}
}

void Konsole::getStatus (int *s_rasen, int *s_blumen, int *s_strauch, int *s_biotop, int *s_auto,
		int *s_regen)
{
	(*s_rasen) = alterstatus.rasen;
	printf ("alterstatus.rasen: %i\n(*s_rasen): %i\n", alterstatus.rasen, *s_rasen);
	(*s_blumen) = alterstatus.blumen;
	(*s_strauch) = alterstatus.strauch;
	(*s_biotop) = alterstatus.biotop;
	(*s_auto) = automatic->isOn();
	(*s_regen) = alterstatus.regen;
}

void Konsole::writeLog (const char *line)
{
	if (logdatei != -1)
	{
		time_t zeit;
		char buff[300];
		zeit = time (NULL);
		strcpy (buff, ctime(&zeit));
		buff[strlen(buff)-1] = 0;
		strcat (buff, ": ");
		strcat (buff, line);
		strcat (buff, "\n");
		write (logdatei, buff, strlen(buff));
	}
}

Erklärung

Die Klasse enthält neben den oben bereits erklärten Buttons und Labels einen Timer, ein Objekt der Klasse MyAboutDialog, ein Objekt der Klasse ParComm zur Steuerung der Anlage über die parallele Schnittstelle und ein Objekt der Klasse ModemInterpreter zur Kommunikation mit dem Modem.

Im Konstruktor werden alle Komponenten des Objekts angelegt und initialisiert. Die einzige Ausnahme bildet das Info-Fenster, das erst angelegt wird, bevor es angezeigt werden soll. Bevor das Hauptfenster durch Aufruf der Methode show() angezeigt wird, werden die Dialoge zum Wählen der Schnittstellen angezeigt und entsprechend der Auswahl des Anwenders die Kommunikationsobjekte angelegt und initialisiert.

Tritt beim Herstellen der Verbindung zu den Schnittstellen ein Fehler auf, so wird das Programm mit einer Fehlermeldung abgebrochen. Ein Fehler kann hier etwa auftreten, wenn der Anwender nicht über genügend Rechte zum Arbeiten mit den Systemschnittstellen besitzt: diese Kanäle sind dem Systemadministrator vorbehalten.

Die Methode writeLog (char*) ergänzt den ihr übergebenen String mit einer aktuellen Datums- und Zeitangabe und schreibt ihn in die Logdatei.

Eine Erklärung aller Signale und Slots, die von dieser Klasse definiert und verwendet werden, würde den Umfang dieses Dokumentes sprengen - die vergebenen Namen sind ohnedies recht aussagekräftig, so dass eine Dokumentation jedes einzelnen Signals / Slots nicht als notwendig erscheint.