add some usefull functions

Framework Linux.vcxproj

@@ -139,6 +139,7 @@
     <ClCompile Include="Model2D.cpp" />
     <ClCompile Include="Model3D.cpp" />
     <ClCompile Include="Model3DList.cpp" />
+    <ClCompile Include="ObjFile.cpp" />
     <ClCompile Include="Prozess.cpp" />
     <ClCompile Include="Punkt.cpp" />
     <ClCompile Include="Rahmen.cpp" />
@@ -215,6 +216,7 @@
     <ClInclude Include="Model3D.h" />
     <ClInclude Include="Model3DCollection.h" />
     <ClInclude Include="Model3DList.h" />
+    <ClInclude Include="ObjFile.h" />
     <ClInclude Include="Pair.h" />
     <ClInclude Include="Prozess.h" />
     <ClInclude Include="Punkt.h" />

Framework Linux.vcxproj.filters

@@ -327,6 +327,9 @@
     <ClInclude Include="VecN.h">
       <Filter>Headerdateien\Framework\Grafik</Filter>
     </ClInclude>
+    <ClInclude Include="ObjFile.h">
+      <Filter>Headerdateien\Framework\OS\Datei</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Prozess.cpp">
@@ -509,5 +512,8 @@
     <ClCompile Include="Errors.cpp">
       <Filter>Quelldateien\Framework</Filter>
     </ClCompile>
+    <ClCompile Include="ObjFile.cpp">
+      <Filter>Quelldateien\Framework\OS\Datei</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

Kam3D.cpp

@@ -12,35 +12,36 @@ using namespace Framework;
 // Inhalt der Kam3D Klasse
 // Konstruktor
 Kam3D::Kam3D()
-    : ReferenceCounter(),
-    rend( 0 )
+	: ReferenceCounter(),
+	rend(0)
 {
-    openingAngle = (float)PI / 4;
-    minZ = 0.1f;
-    maxZ = 5000;
-    pos = Vec3< float >( 0, 0, -1000 );
-    rotX = 0;
-    rotY = 0;
-    rotZ = 0;
+	openingAngle = (float)PI / 4;
+	minZ = 0.1f;
+	maxZ = 5000;
+	pos = Vec3< float >(0, 0, -1000);
+	rotX = 0;
+	rotY = 0;
+	rotZ = 0;
 
-    viewport.x = 0;
-    viewport.y = 0;
-    viewport.front = 0.f;
-    viewport.back = 1.f;
-    viewport.width = 200;
-    viewport.height = 200;
+	viewport.x = 0;
+	viewport.y = 0;
+	viewport.front = 0.f;
+	viewport.back = 1.f;
+	viewport.width = 200;
+	viewport.height = 200;
 
-    welt = 0;
-    style = 0;
+	welt = 0;
+	style = 0;
+	speed = 1;
 
-    updateMatrix();
+	updateMatrix();
 }
 
 // Destruktor
 Kam3D::~Kam3D()
 {
-    if( welt )
-        welt->release();
+	if (welt)
+		welt->release();
 }
 
 // private
@@ -48,257 +49,263 @@ Kam3D::~Kam3D()
 // Aktualisiert die view und projektion matrizen
 void Kam3D::updateMatrix()
 {
-    view = view.rotationX( -rotX ) * view.rotationY( -rotY ) * view.rotationZ( -rotZ ) * view.translation( Vec3< float >( -pos.x, -pos.y, -pos.z ) );
-    proj = proj.projektion( openingAngle, viewport.width / viewport.height, minZ, maxZ );
+	view = view.rotationX(-rotX) * view.rotationY(-rotY) * view.rotationZ(-rotZ) * view.translation(Vec3< float >(-pos.x, -pos.y, -pos.z));
+	proj = proj.projektion(openingAngle, viewport.width / viewport.height, minZ, maxZ);
 }
 
 // Setzt die Position der Kamera in der 3D Welt
-void Kam3D::setPosition( Vec3< float > pos )
+void Kam3D::setPosition(Vec3< float > pos)
 {
-    this->pos = pos;
-    rend = 1;
-    updateMatrix();
+	this->pos = pos;
+	rend = 1;
+	updateMatrix();
 }
 
 // zoomt heran, indem sich die Kamera etwas auf das Blickziel zubewegt
 //  val: Die länge der Strecke um die sich die Kamera bewegen soll
-void Kam3D::scrollIn( float val )
+void Kam3D::scrollIn(float val)
 {
-    Vec3< float > n( 0, 0, 1 );
-    Mat4< float > tmp = tmp.rotationY( rotY ) * tmp.rotationX( rotX ) * tmp.rotationZ( rotZ );
-    n = tmp * n * val;
-    pos += n;
-    rend = 1;
-    updateMatrix();
+	Vec3< float > n(0, 0, 1);
+	Mat4< float > tmp = tmp.rotationY(rotY) * tmp.rotationX(rotX) * tmp.rotationZ(rotZ);
+	n = tmp * n * val;
+	pos += n;
+	rend = 1;
+	updateMatrix();
 }
 
 // zppmt heraus, indem sich die Kamera etwas von dem Blockziel entfernt
 //  val: Die länge der Strecke um die sich die Kamera bewegen soll
-void Kam3D::scrollOut( float val )
+void Kam3D::scrollOut(float val)
 {
-    Vec3< float > n( 0, 0, 1 );
-    Mat4< float > tmp = tmp.rotationY( rotY ) * tmp.rotationX( rotX ) * tmp.rotationZ( rotZ );
-    n = tmp * n * val;
-    pos -= n;
-    rend = 1;
-    updateMatrix();
+	Vec3< float > n(0, 0, 1);
+	Mat4< float > tmp = tmp.rotationY(rotY) * tmp.rotationX(rotX) * tmp.rotationZ(rotZ);
+	n = tmp * n * val;
+	pos -= n;
+	rend = 1;
+	updateMatrix();
 }
 
 // Richtet die Kamera so aus, dass sie genau auf einen bestimmten Punkt zeigt
 //  ziel: Der Punkt, auf den die Kamera zeigen soll
-void Kam3D::setAusrichtung( Vec3< float > ziel )
-{
-    Vec3< float > target = (ziel - pos).normalize();
-    if( Vec3< float >( 0, target.y, target.z ).getLength() == 0 )
-        rotX = 0;
-    else
-        rotX = -lowPrecisionACos( target.z / Vec3< float >( 0, target.y, target.z ).getLength() );
-    if( target.y < 0 )
-        rotX = -rotX;
-    if( Vec3< float >( target.x, 0, target.z ).getLength() == 0 )
-        rotY = 0;
-    else
-        rotY = lowPrecisionACos( abs( target.z ) / Vec3< float >( target.x, 0, target.z ).getLength() );
-    if( target.x < 0 )
-        rotY = -rotY;
-    rotZ = 0;
-    rend = 1;
-    updateMatrix();
+void Kam3D::setAusrichtung(Vec3< float > ziel)
+{
+	Vec3< float > target = (ziel - pos).normalize();
+	if (Vec3< float >(0, target.y, target.z).getLength() == 0)
+		rotX = 0;
+	else
+		rotX = -lowPrecisionACos(target.z / Vec3< float >(0, target.y, target.z).getLength());
+	if (target.y < 0)
+		rotX = -rotX;
+	if (Vec3< float >(target.x, 0, target.z).getLength() == 0)
+		rotY = 0;
+	else
+		rotY = lowPrecisionACos(abs(target.z) / Vec3< float >(target.x, 0, target.z).getLength());
+	if (target.x < 0)
+		rotY = -rotY;
+	rotZ = 0;
+	rend = 1;
+	updateMatrix();
 }
 
 //! Legt die Drehung der Kamera um die einzelnen Axen fest
 //! \param rotation Die Drehung um die einzelnen Axen
-void Kam3D::setRotation( Vec3< float > rotation )
+void Kam3D::setRotation(Vec3< float > rotation)
 {
-    rotX = rotation.x;
-    rotY = rotation.y;
-    rotZ = rotation.z;
-    rend = 1;
-    updateMatrix();
+	rotX = rotation.x;
+	rotY = rotation.y;
+	rotZ = rotation.z;
+	rend = 1;
+	updateMatrix();
 }
 
 // Setzt die Position des Bildes auf dem Bildschirm
 //  p: Ein Punkt mit x und y Koordinaten in Pixeln
-void Kam3D::setBildschirmPosition( Punkt p )
+void Kam3D::setBildschirmPosition(Punkt p)
 {
-    viewport.x = (float)p.x;
-    viewport.y = (float)p.y;
+	viewport.x = (float)p.x;
+	viewport.y = (float)p.y;
 }
 
 // Setzt die Position des Bildes auf dem Bildschirm
 //  x: Die x Koordinate in Pixeln
 //  y: Die y Koordinate in Pixeln
-void Kam3D::setBildschirmPosition( int x, int y )
+void Kam3D::setBildschirmPosition(int x, int y)
 {
-    viewport.x = (float)x;
-    viewport.y = (float)y;
+	viewport.x = (float)x;
+	viewport.y = (float)y;
 }
 
 // Setzt die Größe des Bildes auf dem Bildschirm
 //  p: Ein Punkt, mit x als Breite und y als Höhe in Pixlen
-void Kam3D::setBildschirmSize( Punkt p )
+void Kam3D::setBildschirmSize(Punkt p)
 {
-    viewport.width = (float)p.x;
-    viewport.height = (float)p.y;
-    updateMatrix();
+	viewport.width = (float)p.x;
+	viewport.height = (float)p.y;
+	updateMatrix();
 }
 
 // Setzt die Größe des Bildes auf dem Bildschirm
 //  br: Die Breite in Pixeln
 //  hö: Die Höhe in Pixeln
-void Kam3D::setBildschirmSize( int br, int hö )
+void Kam3D::setBildschirmSize(int br, int hö)
 {
-    viewport.width = (float)br;
-    viewport.height = (float)hö;
-    updateMatrix();
+	viewport.width = (float)br;
+	viewport.height = (float)hö;
+	updateMatrix();
 }
 
 // Setzt die Welt, die gezeichnet werden soll
 //  w: Die Welt
-void Kam3D::setWelt( Welt3D* w )
+void Kam3D::setWelt(Welt3D* w)
 {
-    if( welt )
-        welt->release();
-    welt = w;
+	if (welt)
+		welt->release();
+	welt = w;
 }
 
 // Setzt den Style der Kamera
 //  style: Der neue Style bestehend aus den Flags aus der zugehörigen Style Klasse
-void Kam3D::setStyle( __int64 style )
+void Kam3D::setStyle(__int64 style)
 {
-    this->style = style;
+	this->style = style;
 }
 
 // Setzt den Style der Kamera
 //  style: Alle Style Flags, die verändert werden sollen
 //  add_remove: 1, falls der Style hinzugefügt werden soll. 0, falls der Style entfernt weden soll
-void Kam3D::setStyle( __int64 style, bool add_remove )
+void Kam3D::setStyle(__int64 style, bool add_remove)
 {
-    if( add_remove )
-        this->style |= style;
-    else if( !add_remove )
-        this->style &= ~style;
+	if (add_remove)
+		this->style |= style;
+	else if (!add_remove)
+		this->style &= ~style;
 }
 
 // Fügt Style Flags hinzu
 //  style: Der Style, der hinzugefügt werden soll
-void Kam3D::addStyle( __int64 style )
+void Kam3D::addStyle(__int64 style)
 {
-    this->style |= style;
+	this->style |= style;
 }
 
 // Entfernt Style Flags
 //  style: Der Style, der entfernt werden soll
-void Kam3D::removeStyle( __int64 style )
+void Kam3D::removeStyle(__int64 style)
 {
-    this->style &= ~style;
+	this->style &= ~style;
+}
+
+//! Set the movement speed per second if the camera has style Movable
+void Kam3D::setMovementSpeed(float speed)
+{
+	this->speed = speed;
 }
 
 // Verarbeitet die vergangene Zeit
 //  tickval: Die zeit in sekunden, die seit dem letzten Aufruf der Funktion vergangen ist
 //  return: true, wenn sich das Bild neu gezeichnet werden muss, false sonnst.
-bool Kam3D::tick( double tv )
-{
-    bool ret = rend;
-    rend = 0;
-    if( hatStyle( Style::Rotatable ) )
-    {
-        if( getTastenStand( T_Oben ) )
-        {
-            rotX -= (float)tv;
-            ret = 1;
-        }
-        if( getTastenStand( T_Unten ) )
-        {
-            rotX += (float)tv;
-            ret = 1;
-        }
-        if( getTastenStand( T_Links ) )
-        {
-            rotY -= (float)tv;
-            ret = 1;
-        }
-        if( getTastenStand( T_Rechts ) )
-        {
-            rotY += (float)tv;
-            ret = 1;
-        }
-    }
-    if( hatStyle( Style::Movable ) )
-    {
-        Vec3< float > n( 0, 0, 1 );
-        Vec3< float > n2( 1, 0, 0 );
-        Vec3< float > n3( 0, 1, 0 );
-        Mat4< float > tmp = tmp.rotationY( rotY ) * tmp.rotationX( rotX );
-        n = tmp * n;
-        n = n * (float)tv * 60;
-        n2 = tmp * n2;
-        n2 = n2 * (float)tv * 60;
-        n3 = tmp * n3;
-        n3 = n3 * (float)tv * 60;
-        if( getTastenStand( 'w' ) )
-        {
-            pos += n;
-            ret = 1;
-        }
-        if( getTastenStand( 's' ) )
-        {
-            pos -= n;
-            ret = 1;
-        }
-        if( getTastenStand( 'd' ) )
-        {
-            pos += n2;
-            ret = 1;
-        }
-        if( getTastenStand( 'a' ) )
-        {
-            pos -= n2;
-            ret = 1;
-        }
-        if( getTastenStand( ' ' ) )
-        {
-            pos += n3;
-            ret = 1;
-        }
-        if( getTastenStand( T_Shift ) )
-        {
-            pos -= n3;
-            ret = 1;
-        }
-    }
-    updateMatrix();
-    if( welt && hatStyle( Style::Tick ) )
-        return welt->tick( tv ) || ret;
-    return ret;
+bool Kam3D::tick(double tv)
+{
+	bool ret = rend;
+	rend = 0;
+	if (hatStyle(Style::Rotatable))
+	{
+		if (getTastenStand(T_Oben))
+		{
+			rotX -= (float)tv;
+			ret = 1;
+		}
+		if (getTastenStand(T_Unten))
+		{
+			rotX += (float)tv;
+			ret = 1;
+		}
+		if (getTastenStand(T_Links))
+		{
+			rotY -= (float)tv;
+			ret = 1;
+		}
+		if (getTastenStand(T_Rechts))
+		{
+			rotY += (float)tv;
+			ret = 1;
+		}
+	}
+	if (hatStyle(Style::Movable))
+	{
+		Vec3< float > n(0, 0, 1);
+		Vec3< float > n2(1, 0, 0);
+		Vec3< float > n3(0, 1, 0);
+		Mat4< float > tmp = tmp.rotationY(rotY) * tmp.rotationX(rotX);
+		n = tmp * n;
+		n = n * (float)tv * speed;
+		n2 = tmp * n2;
+		n2 = n2 * (float)tv * speed;
+		n3 = tmp * n3;
+		n3 = n3 * (float)tv * speed;
+		if (getTastenStand('w'))
+		{
+			pos += n;
+			ret = 1;
+		}
+		if (getTastenStand('s'))
+		{
+			pos -= n;
+			ret = 1;
+		}
+		if (getTastenStand('d'))
+		{
+			pos += n2;
+			ret = 1;
+		}
+		if (getTastenStand('a'))
+		{
+			pos -= n2;
+			ret = 1;
+		}
+		if (getTastenStand(' '))
+		{
+			pos += n3;
+			ret = 1;
+		}
+		if (getTastenStand(T_Shift))
+		{
+			pos -= n3;
+			ret = 1;
+		}
+	}
+	updateMatrix();
+	if (welt && hatStyle(Style::Tick))
+		return welt->tick(tv) || ret;
+	return ret;
 }
 
 // Verarbeitet ein Mausereignis
 //  me: Das Mausereignis, das verarbeitet werden soll
-void Kam3D::doMausEreignis( MausEreignis& me )
-{
-    if( me.verarbeitet )
-        return;
-    if( me.mx > viewport.x && me.my > viewport.y && me.mx < viewport.x + viewport.width && me.my < viewport.y + viewport.height )
-    {
-        MausEreignis3D me3d;
-        me3d.id = me.id;
-        me3d.verarbeitet = me.verarbeitet;
-        Vec3< float > mausP = Vec3< float >( (me.mx - viewport.x) / (0.5f * viewport.width) - 1, (me.my - viewport.y) / (0.5f * viewport.height) - 1, 0 );
-        Vec3< float > mausT = Vec3< float >( mausP.x, mausP.y, 1 );
-        Mat4< float > mat = proj * view;
-        mat = mat.getInverse();
-        mausP = mat * mausP;
-        mausT = mat * mausT;
-        me3d.pos = mausP;
-        me3d.dir = mausT - mausP;
-        me.verarbeitet = 1;
-    }
+void Kam3D::doMausEreignis(MausEreignis& me)
+{
+	if (me.verarbeitet)
+		return;
+	if (me.mx > viewport.x && me.my > viewport.y && me.mx < viewport.x + viewport.width && me.my < viewport.y + viewport.height)
+	{
+		MausEreignis3D me3d;
+		me3d.id = me.id;
+		me3d.verarbeitet = me.verarbeitet;
+		Vec3< float > mausP = Vec3< float >((me.mx - viewport.x) / (0.5f * viewport.width) - 1, (me.my - viewport.y) / (0.5f * viewport.height) - 1, 0);
+		Vec3< float > mausT = Vec3< float >(mausP.x, mausP.y, 1);
+		Mat4< float > mat = proj * view;
+		mat = mat.getInverse();
+		mausP = mat * mausP;
+		mausT = mat * mausT;
+		me3d.pos = mausP;
+		me3d.dir = mausT - mausP;
+		me.verarbeitet = 1;
+	}
 }
 
 // Verarbeitet ein Tastaturereignis
 //  te: das Tastaturereignis, das verarbeitet werden soll
-void Kam3D::doTastaturEreignis( TastaturEreignis& te )
+void Kam3D::doTastaturEreignis(TastaturEreignis& te)
 {
 
 }
@@ -306,98 +313,98 @@ void Kam3D::doTastaturEreignis( TastaturEreignis& te )
 // Gibt zurück, ob bestimmte Styles gesetzt wurden
 //  style: Die Styles, die überprüft werden sollen
 //  return: 1, falls alle Styles in style gesetzt wurden
-bool Kam3D::hatStyle( __int64 style ) const
+bool Kam3D::hatStyle(__int64 style) const
 {
-    return (this->style | style) == this->style;
+	return (this->style | style) == this->style;
 }
 
 // Gibt zurück, ob bestimmte Styles nicht gesetzt wurden
 //  style: Die Styles, die geprüft werden sollen
 //  return: 1, falls alle Styles in style nicht gesetzt wurden
-bool Kam3D::hatStyleNicht( __int64 style ) const
+bool Kam3D::hatStyleNicht(__int64 style) const
 {
-    return (this->style | style) != this->style;
+	return (this->style | style) != this->style;
 }
 
 // Gibt einen Zeiger auf den Viewport zurück
 const ViewPort* Kam3D::zViewPort() const
 {
-    return &viewport;
+	return &viewport;
 }
 
 // Gibt die Position der Kamera in der Welt zurück
 const Vec3< float >& Kam3D::getWorldPosition() const
 {
-    return pos;
+	return pos;
 }
 
 // Gibt die Position in der Welt zurück
 //  screen: die Position auf dem Bildschirm, die übersetzt werden soll
-const Vec3< float > Kam3D::getWorldPosition( Punkt screen ) const
+const Vec3< float > Kam3D::getWorldPosition(Punkt screen) const
 {
-    Vec3< float > point = Vec3< float >( (screen.x - viewport.x) / (0.5f * viewport.width) - 1, (viewport.height - (screen.y - viewport.y)) / (0.5f * viewport.height) - 1, 0.1f );
-    Mat4< float > mat = getProjectionMatrix();
-    Mat4< float > inv = getViewMatrix().getInverse();
-    point.x = (point.x * 0.1f) / mat.elements[ 0 ][ 0 ];
-    point.y = (point.y * 0.1f) / mat.elements[ 1 ][ 1 ];
-    return inv * point;
+	Vec3< float > point = Vec3< float >((screen.x - viewport.x) / (0.5f * viewport.width) - 1, (viewport.height - (screen.y - viewport.y)) / (0.5f * viewport.height) - 1, 0.1f);
+	Mat4< float > mat = getProjectionMatrix();
+	Mat4< float > inv = getViewMatrix().getInverse();
+	point.x = (point.x * 0.1f) / mat.elements[0][0];
+	point.y = (point.y * 0.1f) / mat.elements[1][1];
+	return inv * point;
 }
 
 // Gibt die Richtung der Kamera in der Welt zurück
 //  screen: die Position auf dem Bildschirm, die übersetzt werden soll
-const Vec3< float > Kam3D::getWorldDirection( Punkt screen ) const
+const Vec3< float > Kam3D::getWorldDirection(Punkt screen) const
 {
-    Vec3< float > point = Vec3< float >( (screen.x - viewport.x) / (0.5f * viewport.width) - 1, (viewport.height - (screen.y - viewport.y)) / (0.5f * viewport.height) - 1, 0.1f );
-    Vec3< float > pointT = Vec3< float >( point.x, point.y, 1 );
-    Mat4< float > mat = getProjectionMatrix();
-    Mat4< float > inv = getViewMatrix().getInverse();
-    point.x = (point.x * 0.1f) / mat.elements[ 0 ][ 0 ];
-    point.y = (point.y * 0.1f) / mat.elements[ 1 ][ 1 ];
-    pointT.x = (pointT.x) / mat.elements[ 0 ][ 0 ];
-    pointT.y = (pointT.y) / mat.elements[ 1 ][ 1 ];
-    point = inv * point;
-    pointT = inv * pointT;
-    return pointT - point;
+	Vec3< float > point = Vec3< float >((screen.x - viewport.x) / (0.5f * viewport.width) - 1, (viewport.height - (screen.y - viewport.y)) / (0.5f * viewport.height) - 1, 0.1f);
+	Vec3< float > pointT = Vec3< float >(point.x, point.y, 1);
+	Mat4< float > mat = getProjectionMatrix();
+	Mat4< float > inv = getViewMatrix().getInverse();
+	point.x = (point.x * 0.1f) / mat.elements[0][0];
+	point.y = (point.y * 0.1f) / mat.elements[1][1];
+	pointT.x = (pointT.x) / mat.elements[0][0];
+	pointT.y = (pointT.y) / mat.elements[1][1];
+	point = inv * point;
+	pointT = inv * pointT;
+	return pointT - point;
 }
 
 // Gibt die Projektionsmatrix der Kamera zurück
 const Mat4< float >& Kam3D::getProjectionMatrix() const
 {
-    return proj;
+	return proj;
 }
 
 // Gibt die Ansichtsmatrix der Kamera zurück
 const Mat4< float >& Kam3D::getViewMatrix() const
 {
-    return view;
+	return view;
 }
 
 //! Gibt die Rotation um die einzelnen axen zurück
 const Vec3< float > Kam3D::getRotation() const
 {
-    return { rotX, rotY, rotZ };
+	return { rotX, rotY, rotZ };
 }
 
 //! Gibt die Position der Kamera auf dem Bildschirm zurück
 const Punkt Kam3D::getScreenPos() const
 {
-    return Punkt( (int)viewport.x, (int)viewport.y );
+	return Punkt((int)viewport.x, (int)viewport.y);
 }
 
 //! Gibt die Größe der Kamera auf dem Bildschirm zurück
 const Punkt Kam3D::getScreenSize() const
 {
-    return Punkt( (int)viewport.width, (int)viewport.height );
+	return Punkt((int)viewport.width, (int)viewport.height);
 }
 
 // Gibt die Welt zurück
 Welt3D* Kam3D::getWelt() const
 {
-    return welt ? dynamic_cast<Welt3D*>(welt->getThis()) : 0;
+	return welt ? dynamic_cast<Welt3D*>(welt->getThis()) : 0;
 }
 
 // Gibt die Welt zurück
 Welt3D* Kam3D::zWelt() const
 {
-    return welt;
+	return welt;
 }

Kam3D.h

@@ -10,144 +10,147 @@ struct D3D11_VIEWPORT;
 
 namespace Framework
 {
-    struct MausEreignis; //! MausEreignis.h
-    class Render3D; //! Render3D.h
-    class Welt3D; //! Welt3D.h
+	struct MausEreignis; //! MausEreignis.h
+	class Render3D; //! Render3D.h
+	class Welt3D; //! Welt3D.h
 
-    struct ViewPort
-    {
-        float x;
-        float y;
-        float width;
-        float height;
-        float front;
-        float back;
-    };
+	struct ViewPort
+	{
+		float x;
+		float y;
+		float width;
+		float height;
+		float front;
+		float back;
+	};
 
-    //! Eine 3d Kamera, die einen Ausschnitt einer 3D Welt in einen bestimmten Teil des Bildschirms zeichnet
-    class Kam3D : public virtual Framework::ReferenceCounter
-    {
-    public:
-        class Style
-        {
-        public:
-            const static __int64 Movable = 0x1;
-            const static __int64 Rotatable = 0x2;
-            const static __int64 Zoomable = 0x4;
-            const static __int64 Tick = 0x8;
-        };
-    protected:
-        bool rend;
+	//! Eine 3d Kamera, die einen Ausschnitt einer 3D Welt in einen bestimmten Teil des Bildschirms zeichnet
+	class Kam3D : public virtual Framework::ReferenceCounter
+	{
+	public:
+		class Style
+		{
+		public:
+			const static __int64 Movable = 0x1;
+			const static __int64 Rotatable = 0x2;
+			const static __int64 Zoomable = 0x4;
+			const static __int64 Tick = 0x8;
+		};
+	protected:
+		bool rend;
 
-    private:
-        Mat4< float > view;
-        Mat4< float > proj;
+	private:
+		Mat4< float > view;
+		Mat4< float > proj;
 
-        float openingAngle;
-        float minZ;
-        float maxZ;
-        Vec3< float > pos;
-        float rotX;
-        float rotY;
-        float rotZ;
+		float openingAngle;
+		float minZ;
+		float maxZ;
+		Vec3< float > pos;
+		float rotX;
+		float rotY;
+		float rotZ;
 
-        ViewPort viewport;
-        Welt3D *welt;
-        __int64 style;
+		ViewPort viewport;
+		Welt3D* welt;
+		__int64 style;
+		float speed;
 
-        //! Aktualisiert die view und projektion matrizen
-        void updateMatrix();
+		//! Aktualisiert die view und projektion matrizen
+		void updateMatrix();
 
-    public:
-        //! Konstruktor
-        DLLEXPORT Kam3D();
-        //! Destruktor
-        DLLEXPORT ~Kam3D();
-        //! Setzt die Position der Kamera in der 3D Welt
-        DLLEXPORT void setPosition( Vec3< float > pos );
-        //! zoomt heran, indem sich die Kamera etwas auf das Blickziel zubewegt
-        //! \param val Die länge der Strecke um die sich die Kamera bewegen soll
-        DLLEXPORT void scrollIn( float val );
-        //! zppmt heraus, indem sich die Kamera etwas von dem Blockziel entfernt
-        //! \param val Die länge der Strecke um die sich die Kamera bewegen soll
-        DLLEXPORT void scrollOut( float val );
-        //! Richtet die Kamera so aus, dass sie genau auf einen bestimmten Punkt zeigt
-        //! \param ziel Der Punkt, auf den die Kamera zeigen soll
-        DLLEXPORT void setAusrichtung( Vec3< float > ziel );
-        //! Legt die Drehung der Kamera um die einzelnen Axen fest
-        //! \param rotation Die Drehung um die einzelnen Axen
-        DLLEXPORT void setRotation( Vec3< float > rotation );
-        //! Setzt die Position des Bildes auf dem Bildschirm
-        //! \param p Ein Punkt mit x und y Koordinaten in Pixeln
-        DLLEXPORT void setBildschirmPosition( Punkt p );
-        //! Setzt die Position des Bildes auf dem Bildschirm
-        //! \param x Die x Koordinate in Pixeln
-        //! \param y Die y Koordinate in Pixeln
-        DLLEXPORT void setBildschirmPosition( int x, int y );
-        //! Setzt die Größe des Bildes auf dem Bildschirm
-        //! \param p Ein Punkt, mit x als Breite und y als Höhe in Pixlen
-        DLLEXPORT void setBildschirmSize( Punkt p );
-        //! Setzt die Größe des Bildes auf dem Bildschirm
-        //! \param br Die Breite in Pixeln
-        //! \param hi Die Höhe in Pixeln
-        DLLEXPORT void setBildschirmSize( int br, int hi );
-        //! Setzt die Welt, die gezeichnet werden soll
-        //! \param w Die Welt
-        DLLEXPORT void setWelt( Welt3D *w );
-        //! Setzt den Style der Kamera
-        //! \param style Der neue Style bestehend aus den Flags aus der zugehörigen Style Klasse
-        DLLEXPORT void setStyle( __int64 style );
-        //! Setzt den Style der Kamera
-        //! \param style Alle Style Flags, die verändert werden sollen
-        //!  add_remove: 1, falls der Style hinzugefügt werden soll. 0, falls der Style entfernt weden soll
-        DLLEXPORT void setStyle( __int64 style, bool add_remove );
-        //! Fügt Style Flags hinzu
-        //! \param style Der Style, der hinzugefügt werden soll
-        DLLEXPORT void addStyle( __int64 style );
-        //! Entfernt Style Flags
-        //! \param style Der Style, der entfernt werden soll
-        DLLEXPORT void removeStyle( __int64 style );
-        //! Verarbeitet die vergangene Zeit
-        //! \param tickval Die zeit in sekunden, die seit dem letzten Aufruf der Funktion vergangen ist
-        //! \return true, wenn sich das Bild neu gezeichnet werden muss, false sonnst.
-        DLLEXPORT virtual bool tick( double tv );
-        //! Verarbeitet ein Mausereignis
-        //! \param me Das Mausereignis, das verarbeitet werden soll
-        DLLEXPORT virtual void doMausEreignis( MausEreignis &me );
-        //! Verarbeitet ein Tastaturereignis
-        //! \param te das Tastaturereignis, das verarbeitet werden soll
-        DLLEXPORT virtual void doTastaturEreignis( TastaturEreignis &te );
-        //! Gibt zurück, ob bestimmte Styles gesetzt wurden
-        //! \param style Die Styles, die überprüft werden sollen
-        //! \return 1, falls alle Styles in style gesetzt wurden
-        DLLEXPORT bool hatStyle( __int64 style ) const;
-        //! Gibt zurück, ob bestimmte Styles nicht gesetzt wurden
-        //! \param style Die Styles, die geprüft werden sollen
-        //! \return 1, falls alle Styles in style nicht gesetzt wurden
-        DLLEXPORT bool hatStyleNicht( __int64 style ) const;
-        //! Gibt einen Zeiger auf den Viewport zurück
-        DLLEXPORT const ViewPort *zViewPort() const;
-        //! Gibt die Position der Kamera in der Welt zurück
-        DLLEXPORT const Vec3< float > &getWorldPosition() const;
-        //! Gibt die Position in der Welt zurück
-        //! \param screen die Position auf dem Bildschirm, die übersetzt werden soll
-        DLLEXPORT const Vec3< float > getWorldPosition( Punkt screen ) const;
-        //! Gibt die Richtung der Kamera in der Welt zurück
-        //! \param screen die Position auf dem Bildschirm, die übersetzt werden soll
-        DLLEXPORT const Vec3< float > getWorldDirection( Punkt screen ) const;
-        //! Gibt die Projektionsmatrix der Kamera zurück
-        DLLEXPORT const Mat4< float > &getProjectionMatrix() const;
-        //! Gibt die Ansichtsmatrix der Kamera zurück
-        DLLEXPORT const Mat4< float > &getViewMatrix() const;
-        //! Gibt die Rotation um die einzelnen axen zurück
-        DLLEXPORT const Vec3< float > getRotation() const;
-        //! Gibt die Position der Kamera auf dem Bildschirm zurück
-        DLLEXPORT const Punkt getScreenPos() const;
-        //! Gibt die Größe der Kamera auf dem Bildschirm zurück
-        DLLEXPORT const Punkt getScreenSize() const;
-        //! Gibt die Welt zurück
-        DLLEXPORT Welt3D *getWelt() const;
-        //! Gibt die Welt zurück
-        DLLEXPORT Welt3D *zWelt() const;
-    };
+	public:
+		//! Konstruktor
+		DLLEXPORT Kam3D();
+		//! Destruktor
+		DLLEXPORT ~Kam3D();
+		//! Setzt die Position der Kamera in der 3D Welt
+		DLLEXPORT void setPosition(Vec3< float > pos);
+		//! zoomt heran, indem sich die Kamera etwas auf das Blickziel zubewegt
+		//! \param val Die länge der Strecke um die sich die Kamera bewegen soll
+		DLLEXPORT void scrollIn(float val);
+		//! zppmt heraus, indem sich die Kamera etwas von dem Blockziel entfernt
+		//! \param val Die länge der Strecke um die sich die Kamera bewegen soll
+		DLLEXPORT void scrollOut(float val);
+		//! Richtet die Kamera so aus, dass sie genau auf einen bestimmten Punkt zeigt
+		//! \param ziel Der Punkt, auf den die Kamera zeigen soll
+		DLLEXPORT void setAusrichtung(Vec3< float > ziel);
+		//! Legt die Drehung der Kamera um die einzelnen Axen fest
+		//! \param rotation Die Drehung um die einzelnen Axen
+		DLLEXPORT void setRotation(Vec3< float > rotation);
+		//! Setzt die Position des Bildes auf dem Bildschirm
+		//! \param p Ein Punkt mit x und y Koordinaten in Pixeln
+		DLLEXPORT void setBildschirmPosition(Punkt p);
+		//! Setzt die Position des Bildes auf dem Bildschirm
+		//! \param x Die x Koordinate in Pixeln
+		//! \param y Die y Koordinate in Pixeln
+		DLLEXPORT void setBildschirmPosition(int x, int y);
+		//! Setzt die Größe des Bildes auf dem Bildschirm
+		//! \param p Ein Punkt, mit x als Breite und y als Höhe in Pixlen
+		DLLEXPORT void setBildschirmSize(Punkt p);
+		//! Setzt die Größe des Bildes auf dem Bildschirm
+		//! \param br Die Breite in Pixeln
+		//! \param hi Die Höhe in Pixeln
+		DLLEXPORT void setBildschirmSize(int br, int hi);
+		//! Setzt die Welt, die gezeichnet werden soll
+		//! \param w Die Welt
+		DLLEXPORT void setWelt(Welt3D* w);
+		//! Setzt den Style der Kamera
+		//! \param style Der neue Style bestehend aus den Flags aus der zugehörigen Style Klasse
+		DLLEXPORT void setStyle(__int64 style);
+		//! Setzt den Style der Kamera
+		//! \param style Alle Style Flags, die verändert werden sollen
+		//!  add_remove: 1, falls der Style hinzugefügt werden soll. 0, falls der Style entfernt weden soll
+		DLLEXPORT void setStyle(__int64 style, bool add_remove);
+		//! Fügt Style Flags hinzu
+		//! \param style Der Style, der hinzugefügt werden soll
+		DLLEXPORT void addStyle(__int64 style);
+		//! Entfernt Style Flags
+		//! \param style Der Style, der entfernt werden soll
+		DLLEXPORT void removeStyle(__int64 style);
+		//! Set the movement speed per second if the camera has style Movable
+		DLLEXPORT void setMovementSpeed(float speed);
+		//! Verarbeitet die vergangene Zeit
+		//! \param tickval Die zeit in sekunden, die seit dem letzten Aufruf der Funktion vergangen ist
+		//! \return true, wenn sich das Bild neu gezeichnet werden muss, false sonnst.
+		DLLEXPORT virtual bool tick(double tv);
+		//! Verarbeitet ein Mausereignis
+		//! \param me Das Mausereignis, das verarbeitet werden soll
+		DLLEXPORT virtual void doMausEreignis(MausEreignis& me);
+		//! Verarbeitet ein Tastaturereignis
+		//! \param te das Tastaturereignis, das verarbeitet werden soll
+		DLLEXPORT virtual void doTastaturEreignis(TastaturEreignis& te);
+		//! Gibt zurück, ob bestimmte Styles gesetzt wurden
+		//! \param style Die Styles, die überprüft werden sollen
+		//! \return 1, falls alle Styles in style gesetzt wurden
+		DLLEXPORT bool hatStyle(__int64 style) const;
+		//! Gibt zurück, ob bestimmte Styles nicht gesetzt wurden
+		//! \param style Die Styles, die geprüft werden sollen
+		//! \return 1, falls alle Styles in style nicht gesetzt wurden
+		DLLEXPORT bool hatStyleNicht(__int64 style) const;
+		//! Gibt einen Zeiger auf den Viewport zurück
+		DLLEXPORT const ViewPort* zViewPort() const;
+		//! Gibt die Position der Kamera in der Welt zurück
+		DLLEXPORT const Vec3< float >& getWorldPosition() const;
+		//! Gibt die Position in der Welt zurück
+		//! \param screen die Position auf dem Bildschirm, die übersetzt werden soll
+		DLLEXPORT const Vec3< float > getWorldPosition(Punkt screen) const;
+		//! Gibt die Richtung der Kamera in der Welt zurück
+		//! \param screen die Position auf dem Bildschirm, die übersetzt werden soll
+		DLLEXPORT const Vec3< float > getWorldDirection(Punkt screen) const;
+		//! Gibt die Projektionsmatrix der Kamera zurück
+		DLLEXPORT const Mat4< float >& getProjectionMatrix() const;
+		//! Gibt die Ansichtsmatrix der Kamera zurück
+		DLLEXPORT const Mat4< float >& getViewMatrix() const;
+		//! Gibt die Rotation um die einzelnen axen zurück
+		DLLEXPORT const Vec3< float > getRotation() const;
+		//! Gibt die Position der Kamera auf dem Bildschirm zurück
+		DLLEXPORT const Punkt getScreenPos() const;
+		//! Gibt die Größe der Kamera auf dem Bildschirm zurück
+		DLLEXPORT const Punkt getScreenSize() const;
+		//! Gibt die Welt zurück
+		DLLEXPORT Welt3D* getWelt() const;
+		//! Gibt die Welt zurück
+		DLLEXPORT Welt3D* zWelt() const;
+	};
 }

Model3D.cpp

@@ -434,7 +434,7 @@ void Model3DData::copyModel2D(Model2DData* model, float z)
 	{
 		clearModel();
 		int vAnz = 0;
-		for (Polygon2D& p : *model->polygons)
+		for (const Polygon2D& p : *model->polygons)
 			vAnz += p.vertex->getEintragAnzahl();
 		Vertex3D* vertexList = new Vertex3D[vAnz];
 		int index = 0;
@@ -453,7 +453,7 @@ void Model3DData::copyModel2D(Model2DData* model, float z)
 			{
 				for (auto k = j->zListe()->begin(); k; k++)
 				{
-					assert(index < vAnz, L"Das model ist kein valides 2D model");
+					assert(index < vAnz);
 					if (index < vAnz)
 					{
 						vertexList[index].pos = Vec3< float >(k->punkt->x, k->punkt->y, z);

Zeichnung3D.cpp

@@ -119,6 +119,7 @@ void Zeichnung3D::setAlpha(bool a)
 void Zeichnung3D::setSize(float size)
 {
 	this->size = size;
+	rend = 1;
 }
 
 // Errechnet die Matrizen aller Knochen des Skeletts der Zeichnung

Zeit.cpp

@@ -19,50 +19,50 @@
 
 struct timeval
 {
-    long tv_sec;        // Sekunden seit dem 1.1.1970
-    long tv_usec;       // und Mikrosekunden
+	long tv_sec;        // Sekunden seit dem 1.1.1970
+	long tv_usec;       // und Mikrosekunden
 };
 
 struct timezone
 {
-    int tz_minuteswest; // minutes W of Greenwich
-    int tz_dsttime;     // type of dst correction
+	int tz_minuteswest; // minutes W of Greenwich
+	int tz_dsttime;     // type of dst correction
 };
 
-int gettimeofday( struct timeval *tv, struct timezone *tz )
+int gettimeofday(struct timeval* tv, struct timezone* tz)
 {
-    FILETIME ft;
-    unsigned __int64 tmpres = 0;
-    static int tzflag;
+	FILETIME ft;
+	unsigned __int64 tmpres = 0;
+	static int tzflag;
 
-    if( NULL != tv )
-    {
-        GetSystemTimeAsFileTime( &ft );
+	if (NULL != tv)
+	{
+		GetSystemTimeAsFileTime(&ft);
 
-        tmpres |= ft.dwHighDateTime;
-        tmpres <<= 32;
-        tmpres |= ft.dwLowDateTime;
+		tmpres |= ft.dwHighDateTime;
+		tmpres <<= 32;
+		tmpres |= ft.dwLowDateTime;
 
-        //converting file time to unix epoch
-        tmpres -= DELTA_EPOCH_IN_MICROSECS;
-        tmpres /= 10;  //convert into microseconds
-        tv->tv_sec = (long)( tmpres / 1000000UL );
-        tv->tv_usec = (long)( tmpres % 1000000UL );
-    }
+		//converting file time to unix epoch
+		tmpres -= DELTA_EPOCH_IN_MICROSECS;
+		tmpres /= 10;  //convert into microseconds
+		tv->tv_sec = (long)(tmpres / 1000000UL);
+		tv->tv_usec = (long)(tmpres % 1000000UL);
+	}
 
-    if( NULL != tz )
-    {
-        if( !tzflag )
-        {
-            _tzset();
-            ++tzflag;
-        }
-        _get_timezone( (long *)&( tz->tz_minuteswest ) );
-        tz->tz_minuteswest /= 60;
-        _get_daylight( &( tz->tz_dsttime ) );
-    }
+	if (NULL != tz)
+	{
+		if (!tzflag)
+		{
+			_tzset();
+			++tzflag;
+		}
+		_get_timezone((long*)&(tz->tz_minuteswest));
+		tz->tz_minuteswest /= 60;
+		_get_daylight(&(tz->tz_dsttime));
+	}
 
-    return 0;
+	return 0;
 }
 
 #endif
@@ -74,1738 +74,1738 @@ using namespace Framework;
 // Privat 
 int Uhrzeit::update() // berechnet die neue Zeit
 {
-    int ret = 0;
-    while( sekunde >= 60 )
-    {
-        sekunde -= 60;
-        ++minute;
-    }
-    while( minute >= 60 )
-    {
-        minute -= 60;
-        ++stunde;
-    }
-    while( stunde >= 24 )
-    {
-        stunde -= 24;
-        ++ret;
-    }
-    while( sekunde < 0 )
-    {
-        sekunde += 60;
-        --minute;
-    }
-    while( minute < 0 )
-    {
-        minute += 60;
-        --stunde;
-    }
-    while( stunde < 0 )
-    {
-        stunde += 24;
-        --ret;
-    }
-    return ret;
+	int ret = 0;
+	while (sekunde >= 60)
+	{
+		sekunde -= 60;
+		++minute;
+	}
+	while (minute >= 60)
+	{
+		minute -= 60;
+		++stunde;
+	}
+	while (stunde >= 24)
+	{
+		stunde -= 24;
+		++ret;
+	}
+	while (sekunde < 0)
+	{
+		sekunde += 60;
+		--minute;
+	}
+	while (minute < 0)
+	{
+		minute += 60;
+		--stunde;
+	}
+	while (stunde < 0)
+	{
+		stunde += 24;
+		--ret;
+	}
+	return ret;
 }
 
 Uhrzeit::Uhrzeit()
-    : ReferenceCounter(),
-    stunde( 0 ),
-    minute( 0 ),
-    sekunde( 0 )
+	: ReferenceCounter(),
+	stunde(0),
+	minute(0),
+	sekunde(0)
 {}
 
-int Uhrzeit::setUhrzeit( Uhrzeit *zeit ) // setzt die Uhrzeit
+int Uhrzeit::setUhrzeit(Uhrzeit* zeit) // setzt die Uhrzeit
 {
-    stunde = zeit->getStunde();
-    minute = zeit->getMinute();
-    sekunde = zeit->getSekunde();
-    zeit->release();
-    return update();
+	stunde = zeit->getStunde();
+	minute = zeit->getMinute();
+	sekunde = zeit->getSekunde();
+	zeit->release();
+	return update();
 }
 
-int Uhrzeit::setUhrzeit( int stunde, int minute, int sekunde )
+int Uhrzeit::setUhrzeit(int stunde, int minute, int sekunde)
 {
-    this->stunde = stunde;
-    this->minute = minute;
-    this->sekunde = sekunde;
-    return update();
+	this->stunde = stunde;
+	this->minute = minute;
+	this->sekunde = sekunde;
+	return update();
 }
 
-int Uhrzeit::setUhrzeit( const char *format, const char *zeit ) // format Beispiele: "H:i:s", "H-i-s" (H=stunde,i=minute,s=sekunde)
+int Uhrzeit::setUhrzeit(const char* format, const char* zeit) // format Beispiele: "H:i:s", "H-i-s" (H=stunde,i=minute,s=sekunde)
 {
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'h':
-            stunde = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'i':
-            minute = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 's':
-            sekunde = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        default:
-            ++zeit;
-            break;
-        }
-    }
-    return update();
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'h':
+			stunde = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'i':
+			minute = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 's':
+			sekunde = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		default:
+			++zeit;
+			break;
+		}
+	}
+	return update();
 }
 
-int Uhrzeit::setUhrzeit( const char *format, Text *zeit )
+int Uhrzeit::setUhrzeit(const char* format, Text* zeit)
 {
-    int ret = setUhrzeit( format, zeit->getText() );
-    zeit->release();
-    return ret;
+	int ret = setUhrzeit(format, zeit->getText());
+	zeit->release();
+	return ret;
 }
 
-int Uhrzeit::setStunde( int stunde ) // setzt die Stunde
+int Uhrzeit::setStunde(int stunde) // setzt die Stunde
 {
-    this->stunde = stunde;
-    return update();
+	this->stunde = stunde;
+	return update();
 }
 
-int Uhrzeit::setMinute( int minute ) // setzt die Minute
+int Uhrzeit::setMinute(int minute) // setzt die Minute
 {
-    this->minute = minute;
-    return update();
+	this->minute = minute;
+	return update();
 }
 
-int Uhrzeit::setSekunde( int sekunde ) // setzt die Sekunde
+int Uhrzeit::setSekunde(int sekunde) // setzt die Sekunde
 {
-    this->sekunde = sekunde;
-    return update();
+	this->sekunde = sekunde;
+	return update();
 }
 
-int Uhrzeit::plusUhrzeit( Uhrzeit *zeit ) // addiert die zeiten
+int Uhrzeit::plusUhrzeit(Uhrzeit* zeit) // addiert die zeiten
 {
-    stunde += zeit->getStunde();
-    minute += zeit->getMinute();
-    sekunde += zeit->getSekunde();
-    return update();
+	stunde += zeit->getStunde();
+	minute += zeit->getMinute();
+	sekunde += zeit->getSekunde();
+	return update();
 }
 
-int Uhrzeit::plusUhrzeit( int stunde, int minute, int sekunde )
+int Uhrzeit::plusUhrzeit(int stunde, int minute, int sekunde)
 {
-    this->stunde += stunde;
-    this->minute += minute;
-    this->sekunde += sekunde;
-    return update();
+	this->stunde += stunde;
+	this->minute += minute;
+	this->sekunde += sekunde;
+	return update();
 }
 
-int Uhrzeit::plusUhrzeit( const char *format, const char *zeit )
+int Uhrzeit::plusUhrzeit(const char* format, const char* zeit)
 {
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'h':
-            stunde += TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'i':
-            minute += TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 's':
-            sekunde += TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        default:
-            ++zeit;
-            break;
-        }
-    }
-    return update();
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'h':
+			stunde += TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'i':
+			minute += TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 's':
+			sekunde += TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		default:
+			++zeit;
+			break;
+		}
+	}
+	return update();
 }
 
-int Uhrzeit::plusUhrzeit( const char *format, Text *zeit )
+int Uhrzeit::plusUhrzeit(const char* format, Text* zeit)
 {
-    int ret = plusUhrzeit( format, zeit->getText() );
-    zeit->release();
-    return ret;
+	int ret = plusUhrzeit(format, zeit->getText());
+	zeit->release();
+	return ret;
 }
 
-int Uhrzeit::plusStunde( int stunde ) // addiert stunde Stunden
+int Uhrzeit::plusStunde(int stunde) // addiert stunde Stunden
 {
-    this->stunde += stunde;
-    return update();
+	this->stunde += stunde;
+	return update();
 }
 
-int Uhrzeit::plusMinute( int minute ) // addiert minute Minuten
+int Uhrzeit::plusMinute(int minute) // addiert minute Minuten
 {
-    this->minute += minute;
-    return update();
+	this->minute += minute;
+	return update();
 }
 
-int Uhrzeit::plusSekunde( int sekunde ) // addiert sekunde Sekunden
+int Uhrzeit::plusSekunde(int sekunde) // addiert sekunde Sekunden
 {
-    this->sekunde += sekunde;
-    return update();
+	this->sekunde += sekunde;
+	return update();
 }
 
-int Uhrzeit::minusUhrzeit( Uhrzeit *zeit ) // subtrahiert die zeiten
+int Uhrzeit::minusUhrzeit(Uhrzeit* zeit) // subtrahiert die zeiten
 {
-    stunde -= zeit->getStunde();
-    minute -= zeit->getMinute();
-    sekunde -= zeit->getSekunde();
-    zeit->release();
-    return update();
+	stunde -= zeit->getStunde();
+	minute -= zeit->getMinute();
+	sekunde -= zeit->getSekunde();
+	zeit->release();
+	return update();
 }
 
-int Uhrzeit::minusUhrzeit( int stunde, int minute, int sekunde )
+int Uhrzeit::minusUhrzeit(int stunde, int minute, int sekunde)
 {
-    this->stunde -= stunde;
-    this->minute -= minute;
-    this->sekunde -= sekunde;
-    return update();
+	this->stunde -= stunde;
+	this->minute -= minute;
+	this->sekunde -= sekunde;
+	return update();
 }
 
-int Uhrzeit::minusUhrzeit( const char *format, const char *zeit )
+int Uhrzeit::minusUhrzeit(const char* format, const char* zeit)
 {
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'h':
-            stunde -= TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'i':
-            minute -= TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 's':
-            sekunde -= TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        default:
-            ++zeit;
-            break;
-        }
-    }
-    return update();
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'h':
+			stunde -= TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'i':
+			minute -= TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 's':
+			sekunde -= TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		default:
+			++zeit;
+			break;
+		}
+	}
+	return update();
 }
 
-int Uhrzeit::minusUhrzeit( const char *format, Text *zeit )
+int Uhrzeit::minusUhrzeit(const char* format, Text* zeit)
 {
-    int ret = plusUhrzeit( format, zeit->getText() );
-    zeit->release();
-    return ret;
+	int ret = plusUhrzeit(format, zeit->getText());
+	zeit->release();
+	return ret;
 }
 
-int Uhrzeit::minusStunde( int stunde ) // subtrahiert stunde Stunden
+int Uhrzeit::minusStunde(int stunde) // subtrahiert stunde Stunden
 {
-    this->stunde -= stunde;
-    return update();
+	this->stunde -= stunde;
+	return update();
 }
 
-int Uhrzeit::minusMinute( int minute ) // subtrahiert minute Minuten
+int Uhrzeit::minusMinute(int minute) // subtrahiert minute Minuten
 {
-    this->minute -= minute;
-    return update();
+	this->minute -= minute;
+	return update();
 }
 
-int Uhrzeit::minusSekunde( int sekunde ) // subtrahiert sekunde Sekunden
+int Uhrzeit::minusSekunde(int sekunde) // subtrahiert sekunde Sekunden
 {
-    this->sekunde -= sekunde;
-    return update();
+	this->sekunde -= sekunde;
+	return update();
 }
 
 // constant 
 int Uhrzeit::getStunde() const // gibt die Stunde zurück
 {
-    return stunde;
+	return stunde;
 }
 
 int Uhrzeit::getMinute() const // gibt die Minute zurück
 {
-    return minute;
+	return minute;
 }
 
 int Uhrzeit::getSekunde() const // gibt die Sekunde zurück
 {
-    return sekunde;
+	return sekunde;
 }
 
-Text *Uhrzeit::getUhrzeit( const char *format ) const // gibt die Uhrzeit als Text formatiert zurück
+Text* Uhrzeit::getUhrzeit(const char* format) const // gibt die Uhrzeit als Text formatiert zurück
 {
-    Text *ret = new Text( "" );
-    int flen = textLength( format );
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'h':
-            ret->append( stunde );
-            break;
-        case 'i':
-            ret->append( minute );
-            break;
-        case 's':
-            ret->append( sekunde );
-            break;
-        default:
-            ret->append( f, 1 );
-            break;
-        }
-    }
-    return ret;
-}
-
-bool Uhrzeit::istGleich( Uhrzeit *zeit ) const // prüft, ob die Uhrzeit gleich zeit ist
-{
-    bool ret = stunde == zeit->getStunde() &&
-        minute == zeit->getMinute() &&
-        sekunde == zeit->getSekunde();
-    zeit->release();
-    return ret;
+	Text* ret = new Text("");
+	int flen = textLength(format);
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'h':
+			ret->append(stunde);
+			break;
+		case 'i':
+			ret->append(minute);
+			break;
+		case 's':
+			ret->append(sekunde);
+			break;
+		default:
+			ret->append(f, 1);
+			break;
+		}
+	}
+	return ret;
+}
+
+bool Uhrzeit::istGleich(Uhrzeit* zeit) const // prüft, ob die Uhrzeit gleich zeit ist
+{
+	bool ret = stunde == zeit->getStunde() &&
+		minute == zeit->getMinute() &&
+		sekunde == zeit->getSekunde();
+	zeit->release();
+	return ret;
 }
 
-bool Uhrzeit::istGleich( const char *format, const char *zeit ) const
-{
-    int st = stunde, min = minute, sek = sekunde;
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'h':
-            st = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'i':
-            min = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 's':
-            sek = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        default:
-            ++zeit;
-            break;
-        }
-    }
-    bool ret = stunde == st &&
-        minute == min &&
-        sekunde == sek;
-    return ret;
-}
-
-bool Uhrzeit::istGleich( const char *format, Text *zeit ) const
-{
-    bool ret = istGleich( format, zeit->getText() );
-    zeit->release();
-    return ret;
-}
-
-bool Uhrzeit::istGleich( int stunde, int minute, int sekunde ) const
-{
-    return this->stunde == stunde &&
-        this->minute == minute &&
-        this->sekunde == sekunde;
-}
-
-bool Uhrzeit::stundeGleich( int stunde ) const // prüft, ob die Stunde gleich stunde ist
-{
-    return this->stunde == stunde;
-}
-
-bool Uhrzeit::minuteGleich( int minute ) const // prüft, ob die Minute gleich minute ist
-{
-    return this->minute == minute;
-}
-
-bool Uhrzeit::sekundeGleich( int sekunde ) const // prüft, ob die Sekunde gleich sekunde ist
-{
-    return this->sekunde == sekunde;
-}
-
-bool Uhrzeit::istKleiner( Uhrzeit *zeit ) const // prüft, ob die Zeit kleiner als zeit ist
-{
-    bool ret = istKleiner( zeit->getStunde(), zeit->getMinute(), zeit->getSekunde() );
-    zeit->release();
-    return ret;
-}
-
-bool Uhrzeit::istKleiner( int stunde, int minute, int sekunde ) const
-{
-    if( this->stunde < stunde )
-        return 1;
-    else if( this->stunde == stunde )
-    {
-        if( this->minute < minute )
-            return 1;
-        else if( this->minute == minute )
-        {
-            if( this->sekunde < sekunde )
-                return 1;
-            else if( this->sekunde == sekunde )
-                return 0;
-            else
-                return 0;
-        }
-        else
-            return 0;
-    }
-    else
-        return 0;
-}
-
-bool Uhrzeit::istKleiner( const char *format, const char *zeit ) const
-{
-    int st = stunde, min = minute, sek = sekunde;
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'h':
-            st = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'i':
-            min = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 's':
-            sek = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        default:
-            ++zeit;
-            break;
-        }
-    }
-    return istKleiner( st, min, sek );
-}
-
-bool Uhrzeit::istKleiner( const char *format, Text *zeit ) const
-{
-    bool ret = istKleiner( format, zeit->getText() );
-    zeit->release();
-    return ret;
-}
-
-bool Uhrzeit::istLater( Uhrzeit *zeit ) const // prüft, ob die Zeit größer als zeit ist
-{
-    bool ret = istLater( zeit->getStunde(), zeit->getMinute(), zeit->getSekunde() );
-    zeit->release();
-    return ret;
-}
-
-bool Uhrzeit::istLater( int stunde, int minute, int sekunde ) const
-{
-    if( this->stunde > stunde )
-        return 1;
-    else if( this->stunde == stunde )
-    {
-        if( this->minute > minute )
-            return 1;
-        else if( this->minute == minute )
-        {
-            if( this->sekunde > sekunde )
-                return 1;
-            else if( this->sekunde == sekunde )
-                return 0;
-            else
-                return 0;
-        }
-        else
-            return 0;
-    }
-    else
-        return 0;
-}
-
-bool Uhrzeit::istLater( const char *format, const char *zeit ) const
-{
-    int st = stunde, min = minute, sek = sekunde;
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'h':
-            st = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'i':
-            min = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 's':
-            sek = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        default:
-            ++zeit;
-            break;
-        }
-    }
-    return istLater( st, min, sek );
-}
-
-bool Uhrzeit::istLater( const char *format, Text *zeit ) const
-{
-    bool ret = istLater( format, zeit->getText() );
-    zeit->release();
-    return ret;
+bool Uhrzeit::istGleich(const char* format, const char* zeit) const
+{
+	int st = stunde, min = minute, sek = sekunde;
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'h':
+			st = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'i':
+			min = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 's':
+			sek = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		default:
+			++zeit;
+			break;
+		}
+	}
+	bool ret = stunde == st &&
+		minute == min &&
+		sekunde == sek;
+	return ret;
+}
+
+bool Uhrzeit::istGleich(const char* format, Text* zeit) const
+{
+	bool ret = istGleich(format, zeit->getText());
+	zeit->release();
+	return ret;
+}
+
+bool Uhrzeit::istGleich(int stunde, int minute, int sekunde) const
+{
+	return this->stunde == stunde &&
+		this->minute == minute &&
+		this->sekunde == sekunde;
+}
+
+bool Uhrzeit::stundeGleich(int stunde) const // prüft, ob die Stunde gleich stunde ist
+{
+	return this->stunde == stunde;
+}
+
+bool Uhrzeit::minuteGleich(int minute) const // prüft, ob die Minute gleich minute ist
+{
+	return this->minute == minute;
+}
+
+bool Uhrzeit::sekundeGleich(int sekunde) const // prüft, ob die Sekunde gleich sekunde ist
+{
+	return this->sekunde == sekunde;
+}
+
+bool Uhrzeit::istKleiner(Uhrzeit* zeit) const // prüft, ob die Zeit kleiner als zeit ist
+{
+	bool ret = istKleiner(zeit->getStunde(), zeit->getMinute(), zeit->getSekunde());
+	zeit->release();
+	return ret;
+}
+
+bool Uhrzeit::istKleiner(int stunde, int minute, int sekunde) const
+{
+	if (this->stunde < stunde)
+		return 1;
+	else if (this->stunde == stunde)
+	{
+		if (this->minute < minute)
+			return 1;
+		else if (this->minute == minute)
+		{
+			if (this->sekunde < sekunde)
+				return 1;
+			else if (this->sekunde == sekunde)
+				return 0;
+			else
+				return 0;
+		}
+		else
+			return 0;
+	}
+	else
+		return 0;
+}
+
+bool Uhrzeit::istKleiner(const char* format, const char* zeit) const
+{
+	int st = stunde, min = minute, sek = sekunde;
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'h':
+			st = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'i':
+			min = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 's':
+			sek = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		default:
+			++zeit;
+			break;
+		}
+	}
+	return istKleiner(st, min, sek);
+}
+
+bool Uhrzeit::istKleiner(const char* format, Text* zeit) const
+{
+	bool ret = istKleiner(format, zeit->getText());
+	zeit->release();
+	return ret;
+}
+
+bool Uhrzeit::istLater(Uhrzeit* zeit) const // prüft, ob die Zeit größer als zeit ist
+{
+	bool ret = istLater(zeit->getStunde(), zeit->getMinute(), zeit->getSekunde());
+	zeit->release();
+	return ret;
+}
+
+bool Uhrzeit::istLater(int stunde, int minute, int sekunde) const
+{
+	if (this->stunde > stunde)
+		return 1;
+	else if (this->stunde == stunde)
+	{
+		if (this->minute > minute)
+			return 1;
+		else if (this->minute == minute)
+		{
+			if (this->sekunde > sekunde)
+				return 1;
+			else if (this->sekunde == sekunde)
+				return 0;
+			else
+				return 0;
+		}
+		else
+			return 0;
+	}
+	else
+		return 0;
+}
+
+bool Uhrzeit::istLater(const char* format, const char* zeit) const
+{
+	int st = stunde, min = minute, sek = sekunde;
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'h':
+			st = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'i':
+			min = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 's':
+			sek = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		default:
+			++zeit;
+			break;
+		}
+	}
+	return istLater(st, min, sek);
+}
+
+bool Uhrzeit::istLater(const char* format, Text* zeit) const
+{
+	bool ret = istLater(format, zeit->getText());
+	zeit->release();
+	return ret;
 }
 
 // Inhalt der Datum Klasse aus Zeit.h
 // Privat 
 void Datum::update() // berechnet die neue Zeit
 {
-    while( monat > 12 )
-    {
-        monat -= 12;
-        ++jahr;
-    }
-    while( monat <= 0 )
-    {
-        monat += 12;
-        --jahr;
-    }
-    if( istSchaltjahr( jahr ) )
-        maxTage[ 1 ] = 29;
-    else
-        maxTage[ 1 ] = 28;
-    while( tag > maxTage[ monat - 1 ] )
-    {
-        tag -= maxTage[ monat - 1 ];
-        ++monat;
-        if( monat > 12 )
-        {
-            monat -= 12;
-            ++jahr;
-            if( istSchaltjahr( jahr ) )
-                maxTage[ 1 ] = 29;
-            else
-                maxTage[ 1 ] = 28;
-        }
-    }
-    while( tag <= 0 )
-    {
-        tag += maxTage[ ( monat - 2 > 0 ? monat - 2 : 11 ) ];
-        --monat;
-        if( monat <= 0 )
-        {
-            monat += 12;
-            --jahr;
-            if( istSchaltjahr( jahr ) )
-                maxTage[ 1 ] = 29;
-            else
-                maxTage[ 1 ] = 28;
-        }
-    }
+	while (monat > 12)
+	{
+		monat -= 12;
+		++jahr;
+	}
+	while (monat <= 0)
+	{
+		monat += 12;
+		--jahr;
+	}
+	if (istSchaltjahr(jahr))
+		maxTage[1] = 29;
+	else
+		maxTage[1] = 28;
+	while (tag > maxTage[monat - 1])
+	{
+		tag -= maxTage[monat - 1];
+		++monat;
+		if (monat > 12)
+		{
+			monat -= 12;
+			++jahr;
+			if (istSchaltjahr(jahr))
+				maxTage[1] = 29;
+			else
+				maxTage[1] = 28;
+		}
+	}
+	while (tag <= 0)
+	{
+		tag += maxTage[(monat - 2 > 0 ? monat - 2 : 11)];
+		--monat;
+		if (monat <= 0)
+		{
+			monat += 12;
+			--jahr;
+			if (istSchaltjahr(jahr))
+				maxTage[1] = 29;
+			else
+				maxTage[1] = 28;
+		}
+	}
 }
 
 // Konstruktor 
 Datum::Datum()
-    : ReferenceCounter(),
-    jahr( 0 ),
-    monat( 0 ),
-    tag( 0 )
+	: ReferenceCounter(),
+	jahr(0),
+	monat(0),
+	tag(0)
 {
-    int maxT[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
-    maxTage = new int[ 12 ];
-    memcpy( maxTage, maxT, 12 * sizeof( int ) );
+	int maxT[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+	maxTage = new int[12];
+	memcpy(maxTage, maxT, 12 * sizeof(int));
 }
 
 // Destruktor 
 Datum::~Datum()
 {
-    delete[] maxTage;
+	delete[] maxTage;
 }
 
 // nicht constant 
-void Datum::setDatum( Datum *datum ) // setzt das Datum
+void Datum::setDatum(Datum* datum) // setzt das Datum
 {
-    jahr = datum->getJahr();
-    monat = datum->getMonat();
-    tag = datum->getTag();
-    datum->release();
-    update();
+	jahr = datum->getJahr();
+	monat = datum->getMonat();
+	tag = datum->getTag();
+	datum->release();
+	update();
 }
 
-void Datum::setDatum( int jahr, int monat, int tag )
+void Datum::setDatum(int jahr, int monat, int tag)
 {
-    this->jahr = jahr;
-    this->monat = monat;
-    this->tag = tag;
-    update();
-}
-
-void Datum::setDatum( const char *format, const char *datum ) // format Beispiele: "Y:m:d", "Y-m-d" (Y=Jahr,m=Monat,d=tag)
+	this->jahr = jahr;
+	this->monat = monat;
+	this->tag = tag;
+	update();
+}
+
+void Datum::setDatum(const char* format, const char* datum) // format Beispiele: "Y:m:d", "Y-m-d" (Y=Jahr,m=Monat,d=tag)
 {
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'y':
-            jahr = TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        case 'm':
-            monat = TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        case 'd':
-            tag = TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        default:
-            ++datum;
-            break;
-        }
-    }
-    update();
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'y':
+			jahr = TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		case 'm':
+			monat = TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		case 'd':
+			tag = TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		default:
+			++datum;
+			break;
+		}
+	}
+	update();
 }
 
-void Datum::setDatum( const char *format, Text *datum )
+void Datum::setDatum(const char* format, Text* datum)
 {
-    setDatum( format, datum->getText() );
-    datum->release();
+	setDatum(format, datum->getText());
+	datum->release();
 }
 
-void Datum::setJahr( int jahr ) // setzt das Jahr
+void Datum::setJahr(int jahr) // setzt das Jahr
 {
-    this->jahr = jahr;
-    update();
+	this->jahr = jahr;
+	update();
 }
 
-void Datum::setMonat( int monat ) // setzt den Monat
+void Datum::setMonat(int monat) // setzt den Monat
 {
-    this->monat = monat;
-    update();
+	this->monat = monat;
+	update();
 }
 
-void Datum::setTag( int tag ) // setzt den Tag
+void Datum::setTag(int tag) // setzt den Tag
 {
-    this->tag = tag;
-    update();
+	this->tag = tag;
+	update();
 }
 
-void Datum::plusDatum( Datum *datum ) // addiert das datum
+void Datum::plusDatum(Datum* datum) // addiert das datum
 {
-    this->jahr += datum->getJahr();
-    this->monat += datum->getMonat();
-    this->tag += datum->getTag();
-    datum->release();
-    update();
+	this->jahr += datum->getJahr();
+	this->monat += datum->getMonat();
+	this->tag += datum->getTag();
+	datum->release();
+	update();
 }
 
-void Datum::plusDatum( int jahr, int monat, int tag )
+void Datum::plusDatum(int jahr, int monat, int tag)
 {
-    this->jahr += jahr;
-    this->monat += monat;
-    this->tag += tag;
-    update();
+	this->jahr += jahr;
+	this->monat += monat;
+	this->tag += tag;
+	update();
 }
 
-void Datum::plusDatum( const char *format, const char *datum )
+void Datum::plusDatum(const char* format, const char* datum)
 {
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'y':
-            jahr += TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        case 'm':
-            monat += TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        case 'd':
-            tag += TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        default:
-            ++datum;
-            break;
-        }
-    }
-    update();
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'y':
+			jahr += TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		case 'm':
+			monat += TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		case 'd':
+			tag += TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		default:
+			++datum;
+			break;
+		}
+	}
+	update();
 }
 
-void Datum::plusDatum( const char *format, Text *datum )
+void Datum::plusDatum(const char* format, Text* datum)
 {
-    plusDatum( format, datum->getText() );
-    datum->release();
+	plusDatum(format, datum->getText());
+	datum->release();
 }
 
-void Datum::plusJahr( int jahr ) // addiert jahr Jahre
+void Datum::plusJahr(int jahr) // addiert jahr Jahre
 {
-    this->jahr += jahr;
-    update();
+	this->jahr += jahr;
+	update();
 }
 
-void Datum::plusMonat( int monat ) // addiert monat Monate
+void Datum::plusMonat(int monat) // addiert monat Monate
 {
-    this->monat = monat;
-    update();
+	this->monat = monat;
+	update();
 }
 
-void Datum::plusTag( int tag ) // addiert tag Tage
+void Datum::plusTag(int tag) // addiert tag Tage
 {
-    this->tag += tag;
-    update();
+	this->tag += tag;
+	update();
 }
 
-void Datum::minusDatum( Datum *datum ) // subtrahiert das datum
+void Datum::minusDatum(Datum* datum) // subtrahiert das datum
 {
-    jahr -= datum->getJahr();
-    monat -= datum->getMonat();
-    tag -= datum->getTag();
-    datum->release();
-    update();
+	jahr -= datum->getJahr();
+	monat -= datum->getMonat();
+	tag -= datum->getTag();
+	datum->release();
+	update();
 }
 
-void Datum::minusDatum( int jahr, int monat, int tag )
+void Datum::minusDatum(int jahr, int monat, int tag)
 {
-    this->jahr -= jahr;
-    this->monat -= monat;
-    this->tag -= tag;
-    update();
+	this->jahr -= jahr;
+	this->monat -= monat;
+	this->tag -= tag;
+	update();
 }
 
-void Datum::minusDatum( const char *format, const char *datum )
+void Datum::minusDatum(const char* format, const char* datum)
 {
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'y':
-            jahr -= TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        case 'm':
-            monat -= TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        case 'd':
-            tag -= TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        default:
-            ++datum;
-            break;
-        }
-    }
-    update();
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'y':
+			jahr -= TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		case 'm':
+			monat -= TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		case 'd':
+			tag -= TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		default:
+			++datum;
+			break;
+		}
+	}
+	update();
 }
 
-void Datum::minusDatum( const char *format, Text *datum )
+void Datum::minusDatum(const char* format, Text* datum)
 {
-    minusDatum( format, datum->getText() );
-    datum->release();
+	minusDatum(format, datum->getText());
+	datum->release();
 }
 
-void Datum::minusJahr( int jahr ) // subtrahiert jahr Jahre
+void Datum::minusJahr(int jahr) // subtrahiert jahr Jahre
 {
-    this->jahr -= jahr;
-    update();
+	this->jahr -= jahr;
+	update();
 }
 
-void Datum::minusMonat( int monat ) // subtrahiert monat Monate
+void Datum::minusMonat(int monat) // subtrahiert monat Monate
 {
-    this->monat -= monat;
-    update();
+	this->monat -= monat;
+	update();
 }
 
-void Datum::minusTag( int tag ) // subtrahiert tag Tage
+void Datum::minusTag(int tag) // subtrahiert tag Tage
 {
-    this->tag -= tag;
-    update();
+	this->tag -= tag;
+	update();
 }
 
 // constant 
 int Datum::getJahr() const // gibt das Jahr zurück
 {
-    return jahr;
+	return jahr;
 }
 
 int Datum::getMonat() const // gibt der Monat zurück
 {
-    return monat;
+	return monat;
 }
 
 int Datum::getTag() const // gibt der Tag zurück
 {
-    return tag;
+	return tag;
 }
 
-Text *Datum::getDatum( const char *format ) const // gibt das Datum als Text formatiert zurück
+Text* Datum::getDatum(const char* format) const // gibt das Datum als Text formatiert zurück
 {
-    Text *ret = new Text( "" );
-    int flen = textLength( format );
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'y':
-            ret->append( jahr );
-            break;
-        case 'm':
-            ret->append( monat );
-            break;
-        case 'd':
-            ret->append( tag );
-            break;
-        default:
-            ret->append( f, 1 );
-            break;
-        }
-    }
-    return ret;
-}
-
-bool Datum::istGleich( Datum *datum ) const // prüft, ob das Datum gleich datum ist
-{
-    bool ret = jahr == datum->getJahr() &&
-        monat == datum->getMonat() &&
-        tag == datum->getTag();
-    datum->release();
-    return ret;
+	Text* ret = new Text("");
+	int flen = textLength(format);
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'y':
+			ret->append(jahr);
+			break;
+		case 'm':
+			ret->append(monat);
+			break;
+		case 'd':
+			ret->append(tag);
+			break;
+		default:
+			ret->append(f, 1);
+			break;
+		}
+	}
+	return ret;
+}
+
+bool Datum::istGleich(Datum* datum) const // prüft, ob das Datum gleich datum ist
+{
+	bool ret = jahr == datum->getJahr() &&
+		monat == datum->getMonat() &&
+		tag == datum->getTag();
+	datum->release();
+	return ret;
 }
 
-bool Datum::istGleich( const char *format, const char *datum ) const
-{
-    int j = jahr, m = monat, t = tag;
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'y':
-            j = TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        case 'm':
-            m = TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        case 'd':
-            t = TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        default:
-            ++datum;
-            break;
-        }
-    }
-    bool ret = jahr == j &&
-        monat == m &&
-        tag == t;
-    return ret;
-}
-
-bool Datum::istGleich( const char *format, Text *datum ) const
-{
-    bool ret = istGleich( format, datum->getText() );
-    datum->release();
-    return ret;
-}
-
-bool Datum::istGleich( int jahr, int monat, int tag ) const
-{
-    return this->jahr == jahr &&
-        this->monat == monat &&
-        this->tag == tag;
-}
-
-bool Datum::jahrGleich( int jahr ) const // prüft, ob das Jahr gleich jahr ist
-{
-    return this->jahr == jahr;
-}
-
-bool Datum::monatGleich( int monat ) const // prüft, ob der Monat gleich monat ist
-{
-    return this->monat == monat;
-}
-
-bool Datum::tagGleich( int tag ) const // prüft, ob der Tag gleich tag ist
-{
-    return this->tag == tag;
-}
-
-bool Datum::istKleiner( Datum *datum ) const // prüft, ob die Datum kleiner als datum ist
-{
-    bool ret = istKleiner( datum->getJahr(), datum->getMonat(), datum->getTag() );
-    datum->release();
-    return ret;
-}
-
-bool Datum::istKleiner( int jahr, int monat, int tag ) const
-{
-    if( this->jahr < jahr )
-        return 1;
-    else if( this->jahr == jahr )
-    {
-        if( this->monat < monat )
-            return 1;
-        else if( this->monat == monat )
-        {
-            if( this->tag < tag )
-                return 1;
-            else if( this->tag == tag )
-                return 0;
-            else
-                return 0;
-        }
-        else
-            return 0;
-    }
-    else
-        return 0;
-}
-
-bool Datum::istKleiner( const char *format, const char *datum ) const
-{
-    int j = jahr, m = monat, t = tag;
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'y':
-            j = TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        case 'm':
-            m = TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        case 'd':
-            t = TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        default:
-            ++datum;
-            break;
-        }
-    }
-    return istKleiner( j, m, t );
-}
-
-bool Datum::istKleiner( const char *format, Text *datum ) const
-{
-    bool ret = istKleiner( format, datum->getText() );
-    datum->release();
-    return ret;
-}
-
-bool Datum::istLater( Datum *datum ) const // prüft, ob die Datum größer als datum ist
-{
-    bool ret = istLater( datum->getJahr(), datum->getMonat(), datum->getTag() );
-    datum->release();
-    return ret;
-}
-
-bool Datum::istLater( int jahr, int monat, int tag ) const
-{
-    if( this->jahr > jahr )
-        return 1;
-    else if( this->jahr == jahr )
-    {
-        if( this->monat > monat )
-            return 1;
-        else if( this->monat == monat )
-        {
-            if( this->tag > tag )
-                return 1;
-            else if( this->tag == tag )
-                return 0;
-            else
-                return 0;
-        }
-        else
-            return 0;
-    }
-    else
-        return 0;
-}
-
-bool Datum::istLater( const char *format, const char *datum ) const
-{
-    int j = jahr, m = monat, t = tag;
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'y':
-            j = TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        case 'm':
-            m = TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        case 'd':
-            t = TextZuInt( (char *)datum, &ende, 10 );
-            datum = ende;
-            ende = 0;
-            break;
-        default:
-            ++datum;
-            break;
-        }
-    }
-    return istLater( j, m, t );
-}
-
-bool Datum::istLater( const char *format, Text *datum ) const
-{
-    bool ret = istLater( format, datum->getText() );
-    datum->release();
-    return ret;
+bool Datum::istGleich(const char* format, const char* datum) const
+{
+	int j = jahr, m = monat, t = tag;
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'y':
+			j = TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		case 'm':
+			m = TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		case 'd':
+			t = TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		default:
+			++datum;
+			break;
+		}
+	}
+	bool ret = jahr == j &&
+		monat == m &&
+		tag == t;
+	return ret;
+}
+
+bool Datum::istGleich(const char* format, Text* datum) const
+{
+	bool ret = istGleich(format, datum->getText());
+	datum->release();
+	return ret;
+}
+
+bool Datum::istGleich(int jahr, int monat, int tag) const
+{
+	return this->jahr == jahr &&
+		this->monat == monat &&
+		this->tag == tag;
+}
+
+bool Datum::jahrGleich(int jahr) const // prüft, ob das Jahr gleich jahr ist
+{
+	return this->jahr == jahr;
+}
+
+bool Datum::monatGleich(int monat) const // prüft, ob der Monat gleich monat ist
+{
+	return this->monat == monat;
+}
+
+bool Datum::tagGleich(int tag) const // prüft, ob der Tag gleich tag ist
+{
+	return this->tag == tag;
+}
+
+bool Datum::istKleiner(Datum* datum) const // prüft, ob die Datum kleiner als datum ist
+{
+	bool ret = istKleiner(datum->getJahr(), datum->getMonat(), datum->getTag());
+	datum->release();
+	return ret;
+}
+
+bool Datum::istKleiner(int jahr, int monat, int tag) const
+{
+	if (this->jahr < jahr)
+		return 1;
+	else if (this->jahr == jahr)
+	{
+		if (this->monat < monat)
+			return 1;
+		else if (this->monat == monat)
+		{
+			if (this->tag < tag)
+				return 1;
+			else if (this->tag == tag)
+				return 0;
+			else
+				return 0;
+		}
+		else
+			return 0;
+	}
+	else
+		return 0;
+}
+
+bool Datum::istKleiner(const char* format, const char* datum) const
+{
+	int j = jahr, m = monat, t = tag;
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'y':
+			j = TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		case 'm':
+			m = TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		case 'd':
+			t = TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		default:
+			++datum;
+			break;
+		}
+	}
+	return istKleiner(j, m, t);
+}
+
+bool Datum::istKleiner(const char* format, Text* datum) const
+{
+	bool ret = istKleiner(format, datum->getText());
+	datum->release();
+	return ret;
+}
+
+bool Datum::istLater(Datum* datum) const // prüft, ob die Datum größer als datum ist
+{
+	bool ret = istLater(datum->getJahr(), datum->getMonat(), datum->getTag());
+	datum->release();
+	return ret;
+}
+
+bool Datum::istLater(int jahr, int monat, int tag) const
+{
+	if (this->jahr > jahr)
+		return 1;
+	else if (this->jahr == jahr)
+	{
+		if (this->monat > monat)
+			return 1;
+		else if (this->monat == monat)
+		{
+			if (this->tag > tag)
+				return 1;
+			else if (this->tag == tag)
+				return 0;
+			else
+				return 0;
+		}
+		else
+			return 0;
+	}
+	else
+		return 0;
+}
+
+bool Datum::istLater(const char* format, const char* datum) const
+{
+	int j = jahr, m = monat, t = tag;
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'y':
+			j = TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		case 'm':
+			m = TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		case 'd':
+			t = TextZuInt((char*)datum, &ende, 10);
+			datum = ende;
+			ende = 0;
+			break;
+		default:
+			++datum;
+			break;
+		}
+	}
+	return istLater(j, m, t);
+}
+
+bool Datum::istLater(const char* format, Text* datum) const
+{
+	bool ret = istLater(format, datum->getText());
+	datum->release();
+	return ret;
 }
 
 // Inhalt der Zeit Klasse aus Zeit.h
 // Konstruktor 
 Zeit::Zeit()
-    : ReferenceCounter(),
-    datum( new Datum() ),
-    uhrzeit( new Uhrzeit() )
+	: ReferenceCounter(),
+	datum(new Datum()),
+	uhrzeit(new Uhrzeit())
 {}
 
 // Destruktor 
 Zeit::~Zeit()
 {
-    datum->release();
-    uhrzeit->release();
+	datum->release();
+	uhrzeit->release();
 }
 
 // nicht constant 
-void Zeit::setZeit( Zeit *zeit ) // setzt die Zeit
+void Zeit::setZeit(Zeit* zeit) // setzt die Zeit
 {
-    datum->setDatum( zeit->getDatum() );
-    datum->plusTag( uhrzeit->setUhrzeit( zeit->getUhrzeit() ) );
-    zeit->release();
+	datum->setDatum(zeit->getDatum());
+	datum->plusTag(uhrzeit->setUhrzeit(zeit->getUhrzeit()));
+	zeit->release();
 }
 
-void Zeit::setZeit( int jahr, int monat, int tag, int stunde, int minute, int sekunde )
+void Zeit::setZeit(int jahr, int monat, int tag, int stunde, int minute, int sekunde)
 {
-    datum->setDatum( jahr, monat, tag );
-    datum->plusTag( uhrzeit->setUhrzeit( stunde, minute, sekunde ) );
+	datum->setDatum(jahr, monat, tag);
+	datum->plusTag(uhrzeit->setUhrzeit(stunde, minute, sekunde));
 }
 
-void Zeit::setZeit( const char *format, const char *zeit ) // format Beispiele: "Y:m:d H-i-s", "Y-m-d H:i:s" (Y=Jahr,m=Monat,d=tag,H=stunde,i=minute,s=sekunde)
+void Zeit::setZeit(const char* format, const char* zeit) // format Beispiele: "Y:m:d H-i-s", "Y-m-d H:i:s" (Y=Jahr,m=Monat,d=tag,H=stunde,i=minute,s=sekunde)
 {
-    int y = datum->getJahr();
-    int m = datum->getMonat();
-    int d = datum->getTag();
-    int h = uhrzeit->getStunde();
-    int i = uhrzeit->getMinute();
-    int s = uhrzeit->getSekunde();
+	int y = datum->getJahr();
+	int m = datum->getMonat();
+	int d = datum->getTag();
+	int h = uhrzeit->getStunde();
+	int i = uhrzeit->getMinute();
+	int s = uhrzeit->getSekunde();
 
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'y':
-            y = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'm':
-            m = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'd':
-            d = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'h':
-            h = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'i':
-            i = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 's':
-            s = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        default:
-            ++zeit;
-            break;
-        }
-    }
-    datum->setDatum( y, m, d );
-    datum->plusTag( uhrzeit->setUhrzeit( h, i, s ) );
-}
-
-void Zeit::setZeit( const char *format, Text *zeit )
-{
-    setZeit( format, zeit->getText() );
-    zeit->release();
-}
-
-void Zeit::setJahr( int jahr ) // setzt das Jahr
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'y':
+			y = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'm':
+			m = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'd':
+			d = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'h':
+			h = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'i':
+			i = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 's':
+			s = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		default:
+			++zeit;
+			break;
+		}
+	}
+	datum->setDatum(y, m, d);
+	datum->plusTag(uhrzeit->setUhrzeit(h, i, s));
+}
+
+void Zeit::setZeit(const char* format, Text* zeit)
+{
+	setZeit(format, zeit->getText());
+	zeit->release();
+}
+
+void Zeit::setJahr(int jahr) // setzt das Jahr
 {
-    datum->setJahr( jahr );
+	datum->setJahr(jahr);
 }
 
-void Zeit::setMonat( int monat ) // setzt den Monat
+void Zeit::setMonat(int monat) // setzt den Monat
 {
-    datum->setMonat( monat );
+	datum->setMonat(monat);
 }
 
-void Zeit::setTag( int tag ) // setzt den Tag
+void Zeit::setTag(int tag) // setzt den Tag
 {
-    datum->setTag( tag );
+	datum->setTag(tag);
 }
 
-void Zeit::setStunde( int stunde ) // setzt die Stunde
+void Zeit::setStunde(int stunde) // setzt die Stunde
 {
-    datum->plusTag( uhrzeit->setStunde( stunde ) );
+	datum->plusTag(uhrzeit->setStunde(stunde));
 }
 
-void Zeit::setMinute( int minute ) // setzt die Minute
+void Zeit::setMinute(int minute) // setzt die Minute
 {
-    datum->plusTag( uhrzeit->setMinute( minute ) );
+	datum->plusTag(uhrzeit->setMinute(minute));
 }
 
-void Zeit::setSekunde( int sekunde ) // setzt die Sekunde
+void Zeit::setSekunde(int sekunde) // setzt die Sekunde
 {
-    datum->plusTag( uhrzeit->setSekunde( sekunde ) );
+	datum->plusTag(uhrzeit->setSekunde(sekunde));
 }
 
-void Zeit::plusZeit( Zeit *zeit ) // addiert die zeit
+void Zeit::plusZeit(Zeit* zeit) // addiert die zeit
 {
-    datum->plusDatum( zeit->getDatum() );
-    datum->plusTag( uhrzeit->plusUhrzeit( zeit->getUhrzeit() ) );
-    zeit->release();
+	datum->plusDatum(zeit->getDatum());
+	datum->plusTag(uhrzeit->plusUhrzeit(zeit->getUhrzeit()));
+	zeit->release();
 }
 
-void Zeit::plusZeit( int jahr, int monat, int tag, int stunde, int minute, int sekunde )
+void Zeit::plusZeit(int jahr, int monat, int tag, int stunde, int minute, int sekunde)
 {
-    datum->plusDatum( jahr, monat, tag );
-    datum->plusTag( uhrzeit->plusUhrzeit( stunde, minute, sekunde ) );
+	datum->plusDatum(jahr, monat, tag);
+	datum->plusTag(uhrzeit->plusUhrzeit(stunde, minute, sekunde));
 }
 
-void Zeit::plusZeit( const char *format, const char *zeit )
+void Zeit::plusZeit(const char* format, const char* zeit)
 {
-    int y = datum->getJahr();
-    int m = datum->getMonat();
-    int d = datum->getTag();
-    int h = uhrzeit->getStunde();
-    int i = uhrzeit->getMinute();
-    int s = uhrzeit->getSekunde();
+	int y = datum->getJahr();
+	int m = datum->getMonat();
+	int d = datum->getTag();
+	int h = uhrzeit->getStunde();
+	int i = uhrzeit->getMinute();
+	int s = uhrzeit->getSekunde();
 
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'y':
-            y += TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'm':
-            m += TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'd':
-            d += TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'h':
-            h += TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'i':
-            i += TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 's':
-            s += TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        default:
-            ++zeit;
-            break;
-        }
-    }
-    datum->setDatum( y, m, d );
-    datum->plusTag( uhrzeit->setUhrzeit( h, i, s ) );
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'y':
+			y += TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'm':
+			m += TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'd':
+			d += TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'h':
+			h += TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'i':
+			i += TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 's':
+			s += TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		default:
+			++zeit;
+			break;
+		}
+	}
+	datum->setDatum(y, m, d);
+	datum->plusTag(uhrzeit->setUhrzeit(h, i, s));
 }
 
-void Zeit::plusZeit( const char *format, Text *zeit )
+void Zeit::plusZeit(const char* format, Text* zeit)
 {
-    plusZeit( format, zeit->getText() );
-    zeit->release();
+	plusZeit(format, zeit->getText());
+	zeit->release();
 }
 
-void Zeit::plusJahr( int jahr ) // addiert jahr Jahre
+void Zeit::plusJahr(int jahr) // addiert jahr Jahre
 {
-    datum->plusJahr( jahr );
+	datum->plusJahr(jahr);
 }
 
-void Zeit::plusMonat( int monat ) // addiert monat Monate
+void Zeit::plusMonat(int monat) // addiert monat Monate
 {
-    datum->plusMonat( monat );
+	datum->plusMonat(monat);
 }
 
-void Zeit::plusTag( int tag ) // addiert tag Tage
+void Zeit::plusTag(int tag) // addiert tag Tage
 {
-    datum->plusTag( tag );
+	datum->plusTag(tag);
 }
 
-void Zeit::plusStunde( int stunde ) // addiert stunde Stunden
+void Zeit::plusStunde(int stunde) // addiert stunde Stunden
 {
-    datum->plusTag( uhrzeit->plusStunde( stunde ) );
+	datum->plusTag(uhrzeit->plusStunde(stunde));
 }
 
-void Zeit::plusMinute( int minute ) // addiert minute Minuten
+void Zeit::plusMinute(int minute) // addiert minute Minuten
 {
-    datum->plusTag( uhrzeit->plusMinute( minute ) );
+	datum->plusTag(uhrzeit->plusMinute(minute));
 }
 
-void Zeit::plusSekunde( int sekunde ) // addiert sekunde Sekunden
+void Zeit::plusSekunde(int sekunde) // addiert sekunde Sekunden
 {
-    datum->plusTag( uhrzeit->plusSekunde( sekunde ) );
+	datum->plusTag(uhrzeit->plusSekunde(sekunde));
 }
 
-void Zeit::minusZeit( Zeit *zeit ) // subtrahiert die zeit
+void Zeit::minusZeit(Zeit* zeit) // subtrahiert die zeit
 {
-    datum->minusDatum( zeit->getDatum() );
-    datum->plusTag( uhrzeit->minusUhrzeit( zeit->getUhrzeit() ) );
-    zeit->release();
+	datum->minusDatum(zeit->getDatum());
+	datum->plusTag(uhrzeit->minusUhrzeit(zeit->getUhrzeit()));
+	zeit->release();
 }
 
-void Zeit::minusZeit( int jahr, int monat, int tag, int stunde, int minute, int sekunde )
+void Zeit::minusZeit(int jahr, int monat, int tag, int stunde, int minute, int sekunde)
 {
-    datum->minusDatum( jahr, monat, tag );
-    datum->plusTag( uhrzeit->plusUhrzeit( stunde, minute, sekunde ) );
+	datum->minusDatum(jahr, monat, tag);
+	datum->plusTag(uhrzeit->plusUhrzeit(stunde, minute, sekunde));
 }
 
-void Zeit::minusZeit( const char *format, const char *zeit )
+void Zeit::minusZeit(const char* format, const char* zeit)
 {
-    int y = datum->getJahr();
-    int m = datum->getMonat();
-    int d = datum->getTag();
-    int h = uhrzeit->getStunde();
-    int i = uhrzeit->getMinute();
-    int s = uhrzeit->getSekunde();
+	int y = datum->getJahr();
+	int m = datum->getMonat();
+	int d = datum->getTag();
+	int h = uhrzeit->getStunde();
+	int i = uhrzeit->getMinute();
+	int s = uhrzeit->getSekunde();
 
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'y':
-            y -= TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'm':
-            m -= TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'd':
-            d -= TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'h':
-            h += TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'i':
-            i -= TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 's':
-            s -= TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        default:
-            ++zeit;
-            break;
-        }
-    }
-    datum->setDatum( y, m, d );
-    datum->plusTag( uhrzeit->setUhrzeit( h, i, s ) );
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'y':
+			y -= TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'm':
+			m -= TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'd':
+			d -= TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'h':
+			h += TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'i':
+			i -= TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 's':
+			s -= TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		default:
+			++zeit;
+			break;
+		}
+	}
+	datum->setDatum(y, m, d);
+	datum->plusTag(uhrzeit->setUhrzeit(h, i, s));
 }
 
-void Zeit::minusZeit( const char *format, Text *zeit )
+void Zeit::minusZeit(const char* format, Text* zeit)
 {
-    minusZeit( format, zeit->getText() );
-    zeit->release();
+	minusZeit(format, zeit->getText());
+	zeit->release();
 }
 
-void Zeit::minusJahr( int jahr ) // subtrahiert jahr Jahre
+void Zeit::minusJahr(int jahr) // subtrahiert jahr Jahre
 {
-    datum->minusJahr( jahr );
+	datum->minusJahr(jahr);
 }
 
-void Zeit::minusMonat( int monat ) // subtrahiert monat Monate
+void Zeit::minusMonat(int monat) // subtrahiert monat Monate
 {
-    datum->minusMonat( monat );
+	datum->minusMonat(monat);
 }
 
-void Zeit::minusTag( int tag ) // subtrahiert tag Tage
+void Zeit::minusTag(int tag) // subtrahiert tag Tage
 {
-    datum->minusTag( tag );
+	datum->minusTag(tag);
 }
 
-void Zeit::minusStunde( int stunde ) // subtrahiert stunde Stunden
+void Zeit::minusStunde(int stunde) // subtrahiert stunde Stunden
 {
-    datum->plusTag( uhrzeit->minusStunde( stunde ) );
+	datum->plusTag(uhrzeit->minusStunde(stunde));
 }
 
-void Zeit::minusMinute( int minute ) // subtrahiert minute Minuten
+void Zeit::minusMinute(int minute) // subtrahiert minute Minuten
 {
-    datum->plusTag( uhrzeit->minusMinute( minute ) );
+	datum->plusTag(uhrzeit->minusMinute(minute));
 }
 
-void Zeit::minusSekunde( int sekunde ) // subtrahiert sekunde Sekunden
+void Zeit::minusSekunde(int sekunde) // subtrahiert sekunde Sekunden
 {
-    datum->plusTag( uhrzeit->minusSekunde( sekunde ) );
+	datum->plusTag(uhrzeit->minusSekunde(sekunde));
 }
 
 // constant 
-Text *Zeit::getZeit( const char *format ) const // gibt die Zeit als Text formatiert zurück
-{
-    Text *ret = new Text( "" );
-    int flen = textLength( format );
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'y':
-            ret->append( datum->getJahr() );
-            break;
-        case 'm':
-            ret->append( datum->getMonat() );
-            break;
-        case 'd':
-            ret->append( datum->getTag() );
-            break;
-        case 'h':
-            ret->append( uhrzeit->getStunde() );
-            break;
-        case 'i':
-            ret->append( uhrzeit->getMinute() );
-            break;
-        case 's':
-            ret->append( uhrzeit->getSekunde() );
-            break;
-        default:
-            ret->append( f, 1 );
-        }
-    }
-    return ret;
-}
-
-bool Zeit::istGleich( Zeit *zeit ) const // prüft, ob die Uhrzeit gleich zeit ist
-{
-    bool ret = datum->istGleich( zeit->getDatum() ) && uhrzeit->istGleich( zeit->getUhrzeit() );
-    zeit->release();
-    return ret;
-}
-
-bool Zeit::istGleich( const char *format, const char *zeit ) const
-{
-    int y = datum->getJahr();
-    int m = datum->getMonat();
-    int d = datum->getTag();
-    int h = uhrzeit->getStunde();
-    int i = uhrzeit->getMinute();
-    int s = uhrzeit->getSekunde();
-
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'y':
-            y = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'm':
-            m = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'd':
-            d = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'h':
-            h = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'i':
-            i = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 's':
-            s = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        default:
-            ++zeit;
-            break;
-        }
-    }
-    return datum->istGleich( y, m, d ) && uhrzeit->istGleich( h, i, s );
-}
-
-bool Zeit::istGleich( const char *format, Text *zeit ) const
-{
-    bool ret = istGleich( format, zeit->getText() );
-    zeit->release();
-    return ret;
-}
-
-bool Zeit::istGleich( int jahr, int monat, int tag, int stunde, int minute, int sekunde ) const
-{
-    return datum->istGleich( jahr, monat, tag ) && uhrzeit->istGleich( stunde, minute, sekunde );
-}
-
-Datum *Zeit::getDatum() const // gibt das Datum zurück
-{
-    return dynamic_cast<Datum *>( datum->getThis() );
-}
-
-Datum *Zeit::zDatum() const
-{
-    return datum;
-}
-
-Uhrzeit *Zeit::getUhrzeit() const // gibt die Uhrzeit zurück
-{
-    return dynamic_cast<Uhrzeit *>( uhrzeit->getThis() );
-}
-
-Uhrzeit *Zeit::zUhrzeit() const
-{
-    return uhrzeit;
-}
-
-bool Zeit::istKleiner( Zeit *zeit ) const // prüft, ob die Zeit kleiner als zeit ist
-{
-    if( datum->istKleiner( zeit->getDatum() ) )
-    {
-        zeit->release();
-        return 1;
-    }
-    else if( datum->istGleich( zeit->getDatum() ) )
-    {
-        if( uhrzeit->istKleiner( zeit->getUhrzeit() ) )
-        {
-            zeit->release();
-            return 1;
-        }
-        else
-        {
-            zeit->release();
-            return 0;
-        }
-    }
-    else
-    {
-        zeit->release();
-        return 0;
-    }
-}
-
-bool Zeit::istKleiner( int jahr, int monat, int tag, int stunde, int minute, int sekunde ) const
-{
-    if( datum->istKleiner( jahr, monat, tag ) )
-        return 1;
-    else if( datum->istGleich( jahr, monat, tag ) )
-    {
-        if( uhrzeit->istKleiner( stunde, minute, sekunde ) )
-            return 1;
-        else
-            return 0;
-    }
-    else
-        return 0;
-}
-
-bool Zeit::istKleiner( const char *format, const char *zeit ) const
-{
-    int y = datum->getJahr();
-    int m = datum->getMonat();
-    int d = datum->getTag();
-    int h = uhrzeit->getStunde();
-    int i = uhrzeit->getMinute();
-    int s = uhrzeit->getSekunde();
-
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'y':
-            y = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'm':
-            m = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'd':
-            d = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'h':
-            h = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'i':
-            i = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 's':
-            s = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        default:
-            ++zeit;
-            break;
-        }
-    }
-    if( datum->istKleiner( y, m, d ) )
-        return 1;
-    else if( datum->istGleich( y, m, d ) )
-    {
-        if( uhrzeit->istKleiner( h, i, s ) )
-            return 1;
-        else
-            return 0;
-    }
-    else
-        return 0;
-}
-
-bool Zeit::istKleiner( const char *format, Text *zeit ) const
-{
-    bool ret = istKleiner( format, zeit->getText() );
-    zeit->release();
-    return ret;
-}
-
-bool Zeit::istLater( Zeit *zeit ) const // prüft, ob die Zeit größer als zeit ist
-{
-    if( datum->istLater( zeit->getDatum() ) )
-    {
-        zeit->release();
-        return 1;
-    }
-    else if( datum->istGleich( zeit->getDatum() ) )
-    {
-        if( uhrzeit->istLater( zeit->getUhrzeit() ) )
-        {
-            zeit->release();
-            return 1;
-        }
-        else
-        {
-            zeit->release();
-            return 0;
-        }
-    }
-    else
-    {
-        zeit->release();
-        return 0;
-    }
-}
-
-bool Zeit::istLater( int jahr, int monat, int tag, int stunde, int minute, int sekunde ) const
-{
-    if( datum->istLater( jahr, monat, tag ) )
-        return 1;
-    else if( datum->istGleich( jahr, monat, tag ) )
-    {
-        if( uhrzeit->istLater( stunde, minute, sekunde ) )
-            return 1;
-        else
-            return 0;
-    }
-    else
-        return 0;
-}
-
-bool Zeit::istLater( const char *format, const char *zeit ) const
-{
-    int y = datum->getJahr();
-    int m = datum->getMonat();
-    int d = datum->getTag();
-    int h = uhrzeit->getStunde();
-    int i = uhrzeit->getMinute();
-    int s = uhrzeit->getSekunde();
-
-    int flen = textLength( format );
-    char *ende = 0;
-    for( const char *f = format; f < format + flen; ++f )
-    {
-        switch( *f )
-        {
-        case 'y':
-            y = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'm':
-            m = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'd':
-            d = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'h':
-            h = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 'i':
-            i = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        case 's':
-            s = TextZuInt( (char *)zeit, &ende, 10 );
-            zeit = ende;
-            ende = 0;
-            break;
-        default:
-            ++zeit;
-            break;
-        }
-    }
-    if( datum->istLater( y, m, d ) )
-        return 1;
-    else if( datum->istGleich( y, m, d ) )
-    {
-        if( uhrzeit->istLater( h, i, s ) )
-            return 1;
-        else
-            return 0;
-    }
-    else
-        return 0;
-}
-
-bool Zeit::istLater( const char *format, Text *zeit ) const
-{
-    bool ret = istLater( format, zeit->getText() );
-    zeit->release();
-    return ret;
+Text* Zeit::getZeit(const char* format) const // gibt die Zeit als Text formatiert zurück
+{
+	Text* ret = new Text("");
+	int flen = textLength(format);
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'y':
+			ret->append(datum->getJahr());
+			break;
+		case 'm':
+			ret->append(datum->getMonat());
+			break;
+		case 'd':
+			ret->append(datum->getTag());
+			break;
+		case 'h':
+			ret->append(uhrzeit->getStunde());
+			break;
+		case 'i':
+			ret->append(uhrzeit->getMinute());
+			break;
+		case 's':
+			ret->append(uhrzeit->getSekunde());
+			break;
+		default:
+			ret->append(f, 1);
+		}
+	}
+	return ret;
+}
+
+bool Zeit::istGleich(Zeit* zeit) const // prüft, ob die Uhrzeit gleich zeit ist
+{
+	bool ret = datum->istGleich(zeit->getDatum()) && uhrzeit->istGleich(zeit->getUhrzeit());
+	zeit->release();
+	return ret;
+}
+
+bool Zeit::istGleich(const char* format, const char* zeit) const
+{
+	int y = datum->getJahr();
+	int m = datum->getMonat();
+	int d = datum->getTag();
+	int h = uhrzeit->getStunde();
+	int i = uhrzeit->getMinute();
+	int s = uhrzeit->getSekunde();
+
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'y':
+			y = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'm':
+			m = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'd':
+			d = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'h':
+			h = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'i':
+			i = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 's':
+			s = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		default:
+			++zeit;
+			break;
+		}
+	}
+	return datum->istGleich(y, m, d) && uhrzeit->istGleich(h, i, s);
+}
+
+bool Zeit::istGleich(const char* format, Text* zeit) const
+{
+	bool ret = istGleich(format, zeit->getText());
+	zeit->release();
+	return ret;
+}
+
+bool Zeit::istGleich(int jahr, int monat, int tag, int stunde, int minute, int sekunde) const
+{
+	return datum->istGleich(jahr, monat, tag) && uhrzeit->istGleich(stunde, minute, sekunde);
+}
+
+Datum* Zeit::getDatum() const // gibt das Datum zurück
+{
+	return dynamic_cast<Datum*>(datum->getThis());
+}
+
+Datum* Zeit::zDatum() const
+{
+	return datum;
+}
+
+Uhrzeit* Zeit::getUhrzeit() const // gibt die Uhrzeit zurück
+{
+	return dynamic_cast<Uhrzeit*>(uhrzeit->getThis());
+}
+
+Uhrzeit* Zeit::zUhrzeit() const
+{
+	return uhrzeit;
+}
+
+bool Zeit::istKleiner(Zeit* zeit) const // prüft, ob die Zeit kleiner als zeit ist
+{
+	if (datum->istKleiner(zeit->getDatum()))
+	{
+		zeit->release();
+		return 1;
+	}
+	else if (datum->istGleich(zeit->getDatum()))
+	{
+		if (uhrzeit->istKleiner(zeit->getUhrzeit()))
+		{
+			zeit->release();
+			return 1;
+		}
+		else
+		{
+			zeit->release();
+			return 0;
+		}
+	}
+	else
+	{
+		zeit->release();
+		return 0;
+	}
+}
+
+bool Zeit::istKleiner(int jahr, int monat, int tag, int stunde, int minute, int sekunde) const
+{
+	if (datum->istKleiner(jahr, monat, tag))
+		return 1;
+	else if (datum->istGleich(jahr, monat, tag))
+	{
+		if (uhrzeit->istKleiner(stunde, minute, sekunde))
+			return 1;
+		else
+			return 0;
+	}
+	else
+		return 0;
+}
+
+bool Zeit::istKleiner(const char* format, const char* zeit) const
+{
+	int y = datum->getJahr();
+	int m = datum->getMonat();
+	int d = datum->getTag();
+	int h = uhrzeit->getStunde();
+	int i = uhrzeit->getMinute();
+	int s = uhrzeit->getSekunde();
+
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'y':
+			y = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'm':
+			m = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'd':
+			d = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'h':
+			h = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'i':
+			i = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 's':
+			s = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		default:
+			++zeit;
+			break;
+		}
+	}
+	if (datum->istKleiner(y, m, d))
+		return 1;
+	else if (datum->istGleich(y, m, d))
+	{
+		if (uhrzeit->istKleiner(h, i, s))
+			return 1;
+		else
+			return 0;
+	}
+	else
+		return 0;
+}
+
+bool Zeit::istKleiner(const char* format, Text* zeit) const
+{
+	bool ret = istKleiner(format, zeit->getText());
+	zeit->release();
+	return ret;
+}
+
+bool Zeit::istLater(Zeit* zeit) const // prüft, ob die Zeit größer als zeit ist
+{
+	if (datum->istLater(zeit->getDatum()))
+	{
+		zeit->release();
+		return 1;
+	}
+	else if (datum->istGleich(zeit->getDatum()))
+	{
+		if (uhrzeit->istLater(zeit->getUhrzeit()))
+		{
+			zeit->release();
+			return 1;
+		}
+		else
+		{
+			zeit->release();
+			return 0;
+		}
+	}
+	else
+	{
+		zeit->release();
+		return 0;
+	}
+}
+
+bool Zeit::istLater(int jahr, int monat, int tag, int stunde, int minute, int sekunde) const
+{
+	if (datum->istLater(jahr, monat, tag))
+		return 1;
+	else if (datum->istGleich(jahr, monat, tag))
+	{
+		if (uhrzeit->istLater(stunde, minute, sekunde))
+			return 1;
+		else
+			return 0;
+	}
+	else
+		return 0;
+}
+
+bool Zeit::istLater(const char* format, const char* zeit) const
+{
+	int y = datum->getJahr();
+	int m = datum->getMonat();
+	int d = datum->getTag();
+	int h = uhrzeit->getStunde();
+	int i = uhrzeit->getMinute();
+	int s = uhrzeit->getSekunde();
+
+	int flen = textLength(format);
+	char* ende = 0;
+	for (const char* f = format; f < format + flen; ++f)
+	{
+		switch (*f)
+		{
+		case 'y':
+			y = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'm':
+			m = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'd':
+			d = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'h':
+			h = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 'i':
+			i = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		case 's':
+			s = TextZuInt((char*)zeit, &ende, 10);
+			zeit = ende;
+			ende = 0;
+			break;
+		default:
+			++zeit;
+			break;
+		}
+	}
+	if (datum->istLater(y, m, d))
+		return 1;
+	else if (datum->istGleich(y, m, d))
+	{
+		if (uhrzeit->istLater(h, i, s))
+			return 1;
+		else
+			return 0;
+	}
+	else
+		return 0;
+}
+
+bool Zeit::istLater(const char* format, Text* zeit) const
+{
+	bool ret = istLater(format, zeit->getText());
+	zeit->release();
+	return ret;
 }
 
 // Inhalt der ZeitMesser Klasse aus Zeit.h
 // Konstruktor 
 ZeitMesser::ZeitMesser()
-    : ReferenceCounter(),
-    start( 0 ),
-    ende( 0 ),
-    messung( 0 )
+	: ReferenceCounter(),
+	start(0),
+	ende(0),
+	messung(0)
 {}
 
 // Destruktor 
@@ -1817,104 +1817,110 @@ ZeitMesser::~ZeitMesser()
 // nicht constant 
 void ZeitMesser::messungStart() // legt des Startpunkt der Zeitmessung fest
 {
-    timeval tv;
-    gettimeofday( &tv, 0 );
-    start = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
+	timeval tv;
+	gettimeofday(&tv, 0);
+	start = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
 }
 
 void ZeitMesser::messungEnde() // legt des Endpunkt der Zeitmessung fest
 {
-    timeval tv;
-    gettimeofday( &tv, 0 );
-    ende = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
-    messung = ende - start;
+	timeval tv;
+	gettimeofday(&tv, 0);
+	ende = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
+	messung = ende - start;
 }
 
 // constant 
 double ZeitMesser::getSekunden() const // gibt den sekundenabstand zwischen start und ende der Messung zurück
 {
-    return messung;
+	return messung;
 }
 
 double ZeitMesser::getMinuten() const // gibt den minutenabstand zwischen start und ende der Messung zurück
 {
-    return messung / 60;
+	return messung / 60;
 }
 
 double ZeitMesser::getStunden() const // gibt den stundenabstand zwischen start und ende der Messung zurück
 {
-    return messung / 3600;
+	return messung / 3600;
+}
+
+//! gibt true zurück, wenn aktuell eine MEssung läuft
+DLLEXPORT bool ZeitMesser::isMeasuring() const
+{
+	return start != 0;
 }
 
 // Globale Funktionen 
-Uhrzeit *Framework::getUhrzeit() // gibt die aktuelle Uhrzeit zurück
+Uhrzeit* Framework::getUhrzeit() // gibt die aktuelle Uhrzeit zurück
 {
 #ifdef WIN32
-    Uhrzeit *ret = new Uhrzeit();
-    time_t Zeitstempel = time( 0 );
-    tm now;
-    localtime_s( &now, &Zeitstempel );
-    ret->setUhrzeit( now.tm_hour, now.tm_min, now.tm_sec );
-    return ret;
+	Uhrzeit* ret = new Uhrzeit();
+	time_t Zeitstempel = time(0);
+	tm now;
+	localtime_s(&now, &Zeitstempel);
+	ret->setUhrzeit(now.tm_hour, now.tm_min, now.tm_sec);
+	return ret;
 #else
-    Uhrzeit *ret = new Uhrzeit();
-    time_t Zeitstempel = time( 0 );
-    tm *now = localtime( &Zeitstempel );
-    ret->setUhrzeit( now->tm_hour, now->tm_min, now->tm_sec );
-    return ret;
+	Uhrzeit* ret = new Uhrzeit();
+	time_t Zeitstempel = time(0);
+	tm* now = localtime(&Zeitstempel);
+	ret->setUhrzeit(now->tm_hour, now->tm_min, now->tm_sec);
+	return ret;
 #endif
 }
 
-Datum *Framework::getDatum() // gibt das aktuelle Datum zurück
+Datum* Framework::getDatum() // gibt das aktuelle Datum zurück
 {
 #ifdef WIN32
-    Datum *ret = new Datum();
-    time_t Zeitstempel = time( 0 );
-    tm now;
-    localtime_s( &now, &Zeitstempel );
-    ret->setDatum( now.tm_year + 1900, now.tm_mon + 1, now.tm_mday );
-    return ret;
+	Datum* ret = new Datum();
+	time_t Zeitstempel = time(0);
+	tm now;
+	localtime_s(&now, &Zeitstempel);
+	ret->setDatum(now.tm_year + 1900, now.tm_mon + 1, now.tm_mday);
+	return ret;
 #else
-    Datum *ret = new Datum();
-    time_t Zeitstempel = time( 0 );
-    tm *now = localtime( &Zeitstempel );
-    ret->setDatum( now->tm_year + 1900, now->tm_mon + 1, now->tm_mday );
-    return ret;
+	Datum* ret = new Datum();
+	time_t Zeitstempel = time(0);
+	tm* now = localtime(&Zeitstempel);
+	ret->setDatum(now->tm_year + 1900, now->tm_mon + 1, now->tm_mday);
+	return ret;
 #endif
 }
 
-Zeit *Framework::getZeit() // gibt die aktuelle Zeit( Datum und Uhrzeit ) zurück
+Zeit* Framework::getZeit() // gibt die aktuelle Zeit( Datum und Uhrzeit ) zurück
 {
 #ifdef WIN32
-    Zeit *ret = new Zeit();
-    time_t Zeitstempel = time( 0 );
-    tm now;
-    localtime_s( &now, &Zeitstempel );
-    ret->setZeit( now.tm_year + 1900, now.tm_mon + 1, now.tm_mday, now.tm_hour, now.tm_min, now.tm_sec );
-    return ret;
+	Zeit* ret = new Zeit();
+	time_t Zeitstempel = time(0);
+	tm now;
+	localtime_s(&now, &Zeitstempel);
+	ret->setZeit(now.tm_year + 1900, now.tm_mon + 1, now.tm_mday, now.tm_hour, now.tm_min, now.tm_sec);
+	return ret;
 #else
-    Zeit *ret = new Zeit();
-    time_t Zeitstempel = time( 0 );
-    tm *now = localtime( &Zeitstempel );
-    ret->setZeit( now->tm_year + 1900, now->tm_mon + 1, now->tm_mday, now->tm_hour, now->tm_min, now->tm_sec );
-    return ret;
+	Zeit* ret = new Zeit();
+	time_t Zeitstempel = time(0);
+	tm* now = localtime(&Zeitstempel);
+	ret->setZeit(now->tm_year + 1900, now->tm_mon + 1, now->tm_mday, now->tm_hour, now->tm_min, now->tm_sec);
+	return ret;
 #endif
 }
 
-bool Framework::istSchaltjahr( int jahr ) // prüft, ob jahr ein Schaltjahr ist
-{
-    if( jahr % 4 == 0 )
-    {
-        if( jahr % 100 == 0 )
-        {
-            if( jahr % 400 == 0 )
-                return true;
-            else
-                return false;
-        }
-        else
-            return true;
-    }
-    else
-        return false;
+bool Framework::istSchaltjahr(int jahr) // prüft, ob jahr ein Schaltjahr ist
+{
+	if (jahr % 4 == 0)
+	{
+		if (jahr % 100 == 0)
+		{
+			if (jahr % 400 == 0)
+				return true;
+			else
+				return false;
+		}
+		else
+			return true;
+	}
+	else
+		return false;
 }

Zeit.h

@@ -7,678 +7,680 @@
 
 namespace Framework
 {
-    class Text; //! Text.h
-    class Uhrzeit; //! Aus dieser Datei
-    class Datum; //! Aus dieser Datei
-    class Zeit; //! Aus dieser Datei
-    class ZeitMesser; //! Aus dieser Datei
+	class Text; //! Text.h
+	class Uhrzeit; //! Aus dieser Datei
+	class Datum; //! Aus dieser Datei
+	class Zeit; //! Aus dieser Datei
+	class ZeitMesser; //! Aus dieser Datei
 
-    //! Diese Klasse speichert eine Uhrzeit in form von Stunden, Minuten und Sekunden
-    class Uhrzeit : public virtual ReferenceCounter
-    {
-    private:
-        int stunde, minute, sekunde;
-        int update();
+	//! Diese Klasse speichert eine Uhrzeit in form von Stunden, Minuten und Sekunden
+	class Uhrzeit : public virtual ReferenceCounter
+	{
+	private:
+		int stunde, minute, sekunde;
+		int update();
 
-    public:
-        //Erzeugt ein neues Uhrzeit Zeichnung mit den Standartwerten 00:00:00
-        DLLEXPORT Uhrzeit();
+	public:
+		//Erzeugt ein neues Uhrzeit Zeichnung mit den Standartwerten 00:00:00
+		DLLEXPORT Uhrzeit();
 
-        //Setzt die Uhrzeit durch kopieren.
-        //! \param zeit Aus diesem Zeichnung werden die Werte für Stunde, Minute und Sekunde kopiert.
-        DLLEXPORT int setUhrzeit( Uhrzeit *zeit );
-        //Setzt die Uhrzeit.
-        //! \param stunde Die Stunde der neuen Uhrzeit.
-        //! \param minute Die Minute der neuen Uhrzeit.
-        //! \param sekunde Die Sekunde der neuen Uhrzeit.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel: setUhrzeit( 30, 30, 30 ); return: 1, gespeichert: 6:30:30
-        DLLEXPORT int setUhrzeit( int stunde, int minute, int sekunde );
-        //Setzt die Uhrzeit.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
-        //! \param zeit Eine Zeichenfolge die die neue Uhrzeit enthält.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel: setUhrzeit( "h:i:s", "05:30:00" );
-        //! Beispiel: setUhrzeit( "h:i:s", "30:30:00" ); return: 1, gespeichert: 6:30:00
-        DLLEXPORT int setUhrzeit( const char *format, const char *zeit );
-        //Setzt die Uhrzeit.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
-        //! \param zeit Ein Text Zeichnung, dass die neue Uhrzeit enthält.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel: setUhrzeit( "h:i:s", new Text( "05:30:00" ) );
-        //! Beispiel: setUhrzeit( "h:i:s", new Text( "30:30:00" ) ); return: 1, gespeichert: 6:30:00
-        DLLEXPORT int setUhrzeit( const char *format, Text *zeit );
-        //! setzt die Stunde.
-        //! \param stunde Die Stunde, die gespeichert werden soll.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel: setStunde( 30 ); return: 1 Tag, gespeicherte Stunden: 6
-        DLLEXPORT int setStunde( int stunde );
-        //! setzt die Minute.
-        //! \param minute Die Minute, die gespeichert werden soll.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel: Alte Zeit: 23:50:10, setMinute( 80 ); return: 1, gespeicherte Zeit: 01:10:10
-        DLLEXPORT int setMinute( int minute );
-        //! setzt die Sekunde.
-        //! \param minute Die Sekunde, die gespeichert werden soll.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel: Alte Zeit: 23:59:10, setSekunde( 80 ); return: 1, gespeicherte Zeit: 00:00:30
-        DLLEXPORT int setSekunde( int sekunde );
-        //! errechnet die Summe von dieser und einer anderen Uhrzeit und speichert diese.
-        //! \param zeit Die Uhrzeit, deren Werte addiert werden sollen.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel: Alte Zeit: 19:40:18, plusZeit( (10:05:30) ); return 1, gespeicherte Zeit: 05:45:48
-        DLLEXPORT int plusUhrzeit( Uhrzeit *zeit );
-        //! errechnet die Summe von dieser und einer anderen Uhrzeit und speichert diese.
-        //! \param stunde Die Stunden die Werte addiert werden sollen.
-        //! \param minute Die Minute die Werte addiert werden sollen.
-        //! \param sekunde Die Sekunde die Werte addiert werden sollen.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel: Alte Zeit: 19:40:18, plusZeit( 10, 5, 30 ); return 1, gespeicherte Zeit: 05:45:48
-        DLLEXPORT int plusUhrzeit( int stunde, int minute, int sekunde );
-        //! errechnet die Summe von dieser und einer anderen Uhrzeit und speichert diese.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
-        //! \param zeit Eine Zeichenfolge die die neue Uhrzeit enthält.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel: plusUhrzeit( "h:i:s", "05:20:00" );
-        //! Beispiel: Alte Zeit: 19:40:18, plusZeit( "h:i:s", "10:05:30" ); return 1, gespeicherte Zeit: 05:45:48
-        DLLEXPORT int plusUhrzeit( const char *format, const char *zeit );
-        //! errechnet die Summe von dieser und einer anderen Uhrzeit und speichert diese.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
-        //! \param zeit Ein Text Zeichnung, welches die neue Uhrzeit enthält.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel: plusUhrzeit( "h:i:s", new Text( "05:20:00" ) );
-        //! Beispiel: Alte Zeit: 19:40:18, plusZeit( "h:i:s", new Text( "10:05:30" ) ); return 1, gespeicherte Zeit: 05:45:48
-        DLLEXPORT int plusUhrzeit( const char *format, Text *zeit );
-        //! errechnet die Summe von dieser und einer anderen Uhrzeit und speichert diese.
-        //! \param stunde die draufzurechnenden Stunden.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel: Alte Zeit: 20:50:30, plusStunde( 10 ); return 1, gespeicherte Zeit: 6:50:30
-        DLLEXPORT int plusStunde( int stunde );
-        //! errechnet die Summe von dieser und einer anderen Uhrzeit und speichert diese.
-        //! \param minute die draufzurechnenden Minuten.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel: Alte Zeit: 23:50:30, plusMinute( 11 ); return 1, gespeicherte Zeit: 00:01:30
-        DLLEXPORT int plusMinute( int minute );
-        //! errechnet die Summe von dieser und einer anderen Uhrzeit und speichert diese.
-        //! \param sekunde die draufzurechnenden Sekunden.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel: Alte Zeit: 23:59:30, plusSekunde( 40 ); return 1, gespeicherte Zeit: 00:00:10
-        DLLEXPORT int plusSekunde( int sekunde );
-        //! zieht eine gegebene Uhrzeit von dieser ab und speichert das Ergebnis.
-        //! \param zeit Die Uhrzeit, die von dieser abgezogen werden soll.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel Alte Zeit: 10:40:18, minusUhrzeit( (19:05:30) ); return -1, gespeicherte Zeit: 15:34:48
-        DLLEXPORT int minusUhrzeit( Uhrzeit *zeit );
-        //! zieht eine gegebene Uhrzeit von dieser ab und speichert das Ergebnis.
-        //! \param stunde Die Stunden, die von dieser Uhrzeit abgezogen werden sollen.
-        //! \param minute Die Minuten, die von dieser Uhrzeit abgezogen werden sollen.
-        //! \param sekunde Die Sekunden, die von dieser Uhrzeit abgezogen werden sollen.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel Alte Zeit: 10:40:18, minusUhrzeit( 19, 05, 30 ); return -1, gespeicherte Zeit: 15:34:48
-        DLLEXPORT int minusUhrzeit( int stunde, int minute, int sekunde );
-        //! zieht eine gegebene Uhrzeit von dieser ab und speichert das Ergebnis.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
-        //! \param zeit Eine Zeichenfolge die die neue Uhrzeit enthält.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel Alte Zeit: 10:40:18, minusUhrzeit( "h:i:s", "19:05:30" ); return -1, gespeicherte Zeit: 15:34:48
-        DLLEXPORT int minusUhrzeit( const char *format, const char *zeit );
-        //! zieht eine gegebene Uhrzeit von dieser ab und speichert das Ergebnis.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
-        //! \param zeit Ein Text Zeichnung, welches die neue Uhrzeit enthält.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel Alte Zeit: 10:40:18, minusUhrzeit( "h:i:s", new Text( "19:05:30" ) ); return -1, gespeicherte Zeit: 15:34:48
-        DLLEXPORT int minusUhrzeit( const char *format, Text *zeit );
-        //! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
-        //! \param stunde Die abzuziehenden Stunden.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel Alte Zeit: 10:40:18, minusStunde( 19 ); return -1, gespeicherte Zeit: 15:40:18
-        DLLEXPORT int minusStunde( int stunde );
-        //! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
-        //! \param minute Die abzuziehenden Minuten.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel Alte Zeit: 00:40:18, minusStunde( 50 ); return -1, gespeicherte Zeit: 23:50:18
-        DLLEXPORT int minusMinute( int minute );
-        //! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
-        //! \param sekunde Die abzuziehenden Sekunden.
-        //! \return Die Anzahl übriger Tage.
-        //! Beispiel Alte Zeit: 00:00:20, minusStunde( 50 ); return -1, gespeicherte Zeit: 23:59:30
-        DLLEXPORT int minusSekunde( int sekunde );
+		//Setzt die Uhrzeit durch kopieren.
+		//! \param zeit Aus diesem Zeichnung werden die Werte für Stunde, Minute und Sekunde kopiert.
+		DLLEXPORT int setUhrzeit(Uhrzeit* zeit);
+		//Setzt die Uhrzeit.
+		//! \param stunde Die Stunde der neuen Uhrzeit.
+		//! \param minute Die Minute der neuen Uhrzeit.
+		//! \param sekunde Die Sekunde der neuen Uhrzeit.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel: setUhrzeit( 30, 30, 30 ); return: 1, gespeichert: 6:30:30
+		DLLEXPORT int setUhrzeit(int stunde, int minute, int sekunde);
+		//Setzt die Uhrzeit.
+		//! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
+		//! \param zeit Eine Zeichenfolge die die neue Uhrzeit enthält.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel: setUhrzeit( "h:i:s", "05:30:00" );
+		//! Beispiel: setUhrzeit( "h:i:s", "30:30:00" ); return: 1, gespeichert: 6:30:00
+		DLLEXPORT int setUhrzeit(const char* format, const char* zeit);
+		//Setzt die Uhrzeit.
+		//! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
+		//! \param zeit Ein Text Zeichnung, dass die neue Uhrzeit enthält.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel: setUhrzeit( "h:i:s", new Text( "05:30:00" ) );
+		//! Beispiel: setUhrzeit( "h:i:s", new Text( "30:30:00" ) ); return: 1, gespeichert: 6:30:00
+		DLLEXPORT int setUhrzeit(const char* format, Text* zeit);
+		//! setzt die Stunde.
+		//! \param stunde Die Stunde, die gespeichert werden soll.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel: setStunde( 30 ); return: 1 Tag, gespeicherte Stunden: 6
+		DLLEXPORT int setStunde(int stunde);
+		//! setzt die Minute.
+		//! \param minute Die Minute, die gespeichert werden soll.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel: Alte Zeit: 23:50:10, setMinute( 80 ); return: 1, gespeicherte Zeit: 01:10:10
+		DLLEXPORT int setMinute(int minute);
+		//! setzt die Sekunde.
+		//! \param minute Die Sekunde, die gespeichert werden soll.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel: Alte Zeit: 23:59:10, setSekunde( 80 ); return: 1, gespeicherte Zeit: 00:00:30
+		DLLEXPORT int setSekunde(int sekunde);
+		//! errechnet die Summe von dieser und einer anderen Uhrzeit und speichert diese.
+		//! \param zeit Die Uhrzeit, deren Werte addiert werden sollen.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel: Alte Zeit: 19:40:18, plusZeit( (10:05:30) ); return 1, gespeicherte Zeit: 05:45:48
+		DLLEXPORT int plusUhrzeit(Uhrzeit* zeit);
+		//! errechnet die Summe von dieser und einer anderen Uhrzeit und speichert diese.
+		//! \param stunde Die Stunden die Werte addiert werden sollen.
+		//! \param minute Die Minute die Werte addiert werden sollen.
+		//! \param sekunde Die Sekunde die Werte addiert werden sollen.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel: Alte Zeit: 19:40:18, plusZeit( 10, 5, 30 ); return 1, gespeicherte Zeit: 05:45:48
+		DLLEXPORT int plusUhrzeit(int stunde, int minute, int sekunde);
+		//! errechnet die Summe von dieser und einer anderen Uhrzeit und speichert diese.
+		//! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
+		//! \param zeit Eine Zeichenfolge die die neue Uhrzeit enthält.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel: plusUhrzeit( "h:i:s", "05:20:00" );
+		//! Beispiel: Alte Zeit: 19:40:18, plusZeit( "h:i:s", "10:05:30" ); return 1, gespeicherte Zeit: 05:45:48
+		DLLEXPORT int plusUhrzeit(const char* format, const char* zeit);
+		//! errechnet die Summe von dieser und einer anderen Uhrzeit und speichert diese.
+		//! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
+		//! \param zeit Ein Text Zeichnung, welches die neue Uhrzeit enthält.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel: plusUhrzeit( "h:i:s", new Text( "05:20:00" ) );
+		//! Beispiel: Alte Zeit: 19:40:18, plusZeit( "h:i:s", new Text( "10:05:30" ) ); return 1, gespeicherte Zeit: 05:45:48
+		DLLEXPORT int plusUhrzeit(const char* format, Text* zeit);
+		//! errechnet die Summe von dieser und einer anderen Uhrzeit und speichert diese.
+		//! \param stunde die draufzurechnenden Stunden.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel: Alte Zeit: 20:50:30, plusStunde( 10 ); return 1, gespeicherte Zeit: 6:50:30
+		DLLEXPORT int plusStunde(int stunde);
+		//! errechnet die Summe von dieser und einer anderen Uhrzeit und speichert diese.
+		//! \param minute die draufzurechnenden Minuten.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel: Alte Zeit: 23:50:30, plusMinute( 11 ); return 1, gespeicherte Zeit: 00:01:30
+		DLLEXPORT int plusMinute(int minute);
+		//! errechnet die Summe von dieser und einer anderen Uhrzeit und speichert diese.
+		//! \param sekunde die draufzurechnenden Sekunden.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel: Alte Zeit: 23:59:30, plusSekunde( 40 ); return 1, gespeicherte Zeit: 00:00:10
+		DLLEXPORT int plusSekunde(int sekunde);
+		//! zieht eine gegebene Uhrzeit von dieser ab und speichert das Ergebnis.
+		//! \param zeit Die Uhrzeit, die von dieser abgezogen werden soll.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel Alte Zeit: 10:40:18, minusUhrzeit( (19:05:30) ); return -1, gespeicherte Zeit: 15:34:48
+		DLLEXPORT int minusUhrzeit(Uhrzeit* zeit);
+		//! zieht eine gegebene Uhrzeit von dieser ab und speichert das Ergebnis.
+		//! \param stunde Die Stunden, die von dieser Uhrzeit abgezogen werden sollen.
+		//! \param minute Die Minuten, die von dieser Uhrzeit abgezogen werden sollen.
+		//! \param sekunde Die Sekunden, die von dieser Uhrzeit abgezogen werden sollen.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel Alte Zeit: 10:40:18, minusUhrzeit( 19, 05, 30 ); return -1, gespeicherte Zeit: 15:34:48
+		DLLEXPORT int minusUhrzeit(int stunde, int minute, int sekunde);
+		//! zieht eine gegebene Uhrzeit von dieser ab und speichert das Ergebnis.
+		//! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
+		//! \param zeit Eine Zeichenfolge die die neue Uhrzeit enthält.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel Alte Zeit: 10:40:18, minusUhrzeit( "h:i:s", "19:05:30" ); return -1, gespeicherte Zeit: 15:34:48
+		DLLEXPORT int minusUhrzeit(const char* format, const char* zeit);
+		//! zieht eine gegebene Uhrzeit von dieser ab und speichert das Ergebnis.
+		//! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
+		//! \param zeit Ein Text Zeichnung, welches die neue Uhrzeit enthält.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel Alte Zeit: 10:40:18, minusUhrzeit( "h:i:s", new Text( "19:05:30" ) ); return -1, gespeicherte Zeit: 15:34:48
+		DLLEXPORT int minusUhrzeit(const char* format, Text* zeit);
+		//! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
+		//! \param stunde Die abzuziehenden Stunden.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel Alte Zeit: 10:40:18, minusStunde( 19 ); return -1, gespeicherte Zeit: 15:40:18
+		DLLEXPORT int minusStunde(int stunde);
+		//! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
+		//! \param minute Die abzuziehenden Minuten.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel Alte Zeit: 00:40:18, minusStunde( 50 ); return -1, gespeicherte Zeit: 23:50:18
+		DLLEXPORT int minusMinute(int minute);
+		//! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
+		//! \param sekunde Die abzuziehenden Sekunden.
+		//! \return Die Anzahl übriger Tage.
+		//! Beispiel Alte Zeit: 00:00:20, minusStunde( 50 ); return -1, gespeicherte Zeit: 23:59:30
+		DLLEXPORT int minusSekunde(int sekunde);
 
-        //! gibt die Stunde zurück.
-        DLLEXPORT int getStunde() const;
-        //! gibt die Minute zurück.
-        DLLEXPORT int getMinute() const;
-        //! gibt die Sekunde zurück.
-        DLLEXPORT int getSekunde() const;
-        //! gibt die Uhrzeit als Text formatiert zurück.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit zurückgegeben werden soll. h=Stunde, i=Minute,s=Sekunde.
-        //! Beispiel: Zeit: 5:40:39, getUhrzeit( "h:i:s" ); return: "5:40:39"
-        DLLEXPORT Text *getUhrzeit( const char *format ) const;
-        //! prüft, ob die Uhrzeit gleich zeit ist.
-        //! \param zeit Die Uhrzeit, mit der diese verglichen werden soll.
-        //! \return (true), wenn die beiden Zeiten geich sind. (false), wenn die Zeiten nicht gleich sind.
-        DLLEXPORT bool istGleich( Uhrzeit *zeit ) const;
-        //! prüft, ob die Uhrzeit gleich zeit ist.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
-        //! \param zeit Eine Zeichenfolge die die andere Uhrzeit enthält.
-        //! \return (true), wenn die beiden Zeiten geich sind. (false), wenn die Zeiten nicht gleich sind.
-        DLLEXPORT bool istGleich( const char *format, const char *zeit ) const;
-        //! prüft, ob die Uhrzeit gleich zeit ist.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
-        //! \param zeit Ein Text Zeichnung, welches die andere Uhrzeit enthält.
-        //! \return (true), wenn die beiden Zeiten geich sind. (false), wenn die Zeiten nicht gleich sind.
-        DLLEXPORT bool istGleich( const char *format, Text *zeit ) const;
-        //! prüft, ob die Uhrzeit gleich der übergebenen Zeit ist. Hier wird nicht beachtet, ob die gegebene Zeit eine gültige Uhrzeit ist.
-        //! \param stunde Die Stunden der zu überprüfenden Uhrzeit
-        //! \param minute Die Minuten der zu überprüfenden Uhrzeit
-        //! \param sekunde Die Sekunden der zu überprüfenden Uhrzeit
-        //! \return (true), wenn die beiden Zeiten geich sind. (false), wenn die Zeiten nicht gleich sind.
-        DLLEXPORT bool istGleich( int stunde, int minute, int sekunde ) const;
-        //! prüft, ob die Stunde gleich der gegebenen Stunde ist.
-        //! \param stunde die zu prüfende Stunde.
-        //! \return (true), wenn die Stunden gleich sind. (false), wenn sie nicht gleich sind.
-        DLLEXPORT bool stundeGleich( int stunde ) const;
-        //! prüft, ob die Minute gleich der gegebenen Minute ist.
-        //! \param minute die zu prüfende Minute.
-        //! \return (true), wenn die Minuten gleich sind. (false), wenn sie nicht gleich sind.
-        DLLEXPORT bool minuteGleich( int minute ) const;
-        //! prüft, ob die Sekunde gleich der gegebenen Sekunde ist.
-        //! \param sekunde die zu prüfende Sekunde.
-        //! \return (true), wenn die Sekunden gleich sind. (false), wenn sie nicht gleich sind.
-        DLLEXPORT bool sekundeGleich( int sekunde ) const;
-        //! prüft, ob die Uhrzeit kleiner als zeit ist.
-        //! \param zeit Die zu prüfende Uhrzeit.
-        //! \return (true), wenn die gespeicherte Zeit kleiner als die übergebene Zeit ist. (false) sonst.
-        //! Beispiel: (5:30:00).istKleiner( (10:40:29) ); return true
-        DLLEXPORT bool istKleiner( Uhrzeit *zeit ) const;
-        //! prüft, ob die Uhrzeit kleiner als die übergebene Zeit ist.
-        //! \param stunde Die Stunden der zu prüfenden Zeit.
-        //! \param minute Die Minute der zu prüfenden Zeit.
-        //! \param sekunde Die Sekunde der zu prüfenden Zeit.
-        //! \return (true), wenn die gespeicherte Zeit kleiner als die übergebene Zeit ist. (false) sonst.
-        //! Beispiel: (5:30:00).istKleiner( 10, 40, 29 ); return true
-        DLLEXPORT bool istKleiner( int stunde, int minute, int sekunde ) const;
-        //! prüft, ob die Uhrzeit kleiner als die übergebene Zeit ist.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
-        //! \param zeit Eine Zeichenfolge die die andere Uhrzeit enthält.
-        //! \return (true), wenn die gespeicherte Zeit kleiner als die übergebene Zeit ist. (false) sonst.
-        //! Beispiel: (5:30:00).istKleiner( "h:i:s", "10:40:29" ); return true
-        DLLEXPORT bool istKleiner( const char *format, const char *zeit ) const;
-        //! prüft, ob die Uhrzeit kleiner als die übergebene Zeit ist.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
-        //! \param zeit Ein Text Zeichnung, welches die andere Uhrzeit enthält.
-        //! \return (true), wenn die gespeicherte Zeit kleiner als die übergebene Zeit ist. (false) sonst.
-        //! Beispiel: (5:30:00).istKleiner( "h:i:s", "10:40:29" ); return true
-        DLLEXPORT bool istKleiner( const char *format, Text *zeit ) const;
-        //! prüft, ob die Uhrzeit größer als zeit ist.
-        //! \param zeit Die zu prüfende Uhrzeit.
-        //! \return (true), wenn die gespeicherte Zeit größer als die übergebene Zeit ist. (false) sonst.
-        //! Beispiel: (5:30:00).istGrößer( (10:40:29) ); return false
-        DLLEXPORT bool istLater( Uhrzeit *zeit ) const;
-        //! prüft, ob die Uhrzeit größer als die übergebene Zeit ist.
-        //! \param stunde Die Stunden der zu prüfenden Zeit.
-        //! \param minute Die Minute der zu prüfenden Zeit.
-        //! \param sekunde Die Sekunde der zu prüfenden Zeit.
-        //! \return (true), wenn die gespeicherte Zeit größer als die übergebene Zeit ist. (false) sonst.
-        //! Beispiel: (5:30:00).istGrößer( 10, 40, 29 ); return false
-        DLLEXPORT bool istLater( int stunde, int minute, int sekunde ) const;
-        //! prüft, ob die Uhrzeit größer als die übergebene Zeit ist.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
-        //! \param zeit Eine Zeichenfolge die die andere Uhrzeit enthält.
-        //! \return (true), wenn die gespeicherte Zeit größer als die übergebene Zeit ist. (false) sonst.
-        //! Beispiel: (5:30:00).istGrößer( "h:i:s", "10:40:29" ); return false
-        DLLEXPORT bool istLater( const char *format, const char *zeit ) const;
-        //! prüft, ob die Uhrzeit größer als die übergebene Zeit ist.
-        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
-        //! \param zeit Ein Text Zeichnung, welches die andere Uhrzeit enthält.
-        //! \return (true), wenn die gespeicherte Zeit größer als die übergebene Zeit ist. (false) sonst.
-        //! Beispiel: (5:30:00).istGrößer( "h:i:s", "10:40:29" ); return false
-        DLLEXPORT bool istLater( const char *format, Text *zeit ) const;
-    };
+		//! gibt die Stunde zurück.
+		DLLEXPORT int getStunde() const;
+		//! gibt die Minute zurück.
+		DLLEXPORT int getMinute() const;
+		//! gibt die Sekunde zurück.
+		DLLEXPORT int getSekunde() const;
+		//! gibt die Uhrzeit als Text formatiert zurück.
+		//! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit zurückgegeben werden soll. h=Stunde, i=Minute,s=Sekunde.
+		//! Beispiel: Zeit: 5:40:39, getUhrzeit( "h:i:s" ); return: "5:40:39"
+		DLLEXPORT Text* getUhrzeit(const char* format) const;
+		//! prüft, ob die Uhrzeit gleich zeit ist.
+		//! \param zeit Die Uhrzeit, mit der diese verglichen werden soll.
+		//! \return (true), wenn die beiden Zeiten geich sind. (false), wenn die Zeiten nicht gleich sind.
+		DLLEXPORT bool istGleich(Uhrzeit* zeit) const;
+		//! prüft, ob die Uhrzeit gleich zeit ist.
+		//! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
+		//! \param zeit Eine Zeichenfolge die die andere Uhrzeit enthält.
+		//! \return (true), wenn die beiden Zeiten geich sind. (false), wenn die Zeiten nicht gleich sind.
+		DLLEXPORT bool istGleich(const char* format, const char* zeit) const;
+		//! prüft, ob die Uhrzeit gleich zeit ist.
+		//! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
+		//! \param zeit Ein Text Zeichnung, welches die andere Uhrzeit enthält.
+		//! \return (true), wenn die beiden Zeiten geich sind. (false), wenn die Zeiten nicht gleich sind.
+		DLLEXPORT bool istGleich(const char* format, Text* zeit) const;
+		//! prüft, ob die Uhrzeit gleich der übergebenen Zeit ist. Hier wird nicht beachtet, ob die gegebene Zeit eine gültige Uhrzeit ist.
+		//! \param stunde Die Stunden der zu überprüfenden Uhrzeit
+		//! \param minute Die Minuten der zu überprüfenden Uhrzeit
+		//! \param sekunde Die Sekunden der zu überprüfenden Uhrzeit
+		//! \return (true), wenn die beiden Zeiten geich sind. (false), wenn die Zeiten nicht gleich sind.
+		DLLEXPORT bool istGleich(int stunde, int minute, int sekunde) const;
+		//! prüft, ob die Stunde gleich der gegebenen Stunde ist.
+		//! \param stunde die zu prüfende Stunde.
+		//! \return (true), wenn die Stunden gleich sind. (false), wenn sie nicht gleich sind.
+		DLLEXPORT bool stundeGleich(int stunde) const;
+		//! prüft, ob die Minute gleich der gegebenen Minute ist.
+		//! \param minute die zu prüfende Minute.
+		//! \return (true), wenn die Minuten gleich sind. (false), wenn sie nicht gleich sind.
+		DLLEXPORT bool minuteGleich(int minute) const;
+		//! prüft, ob die Sekunde gleich der gegebenen Sekunde ist.
+		//! \param sekunde die zu prüfende Sekunde.
+		//! \return (true), wenn die Sekunden gleich sind. (false), wenn sie nicht gleich sind.
+		DLLEXPORT bool sekundeGleich(int sekunde) const;
+		//! prüft, ob die Uhrzeit kleiner als zeit ist.
+		//! \param zeit Die zu prüfende Uhrzeit.
+		//! \return (true), wenn die gespeicherte Zeit kleiner als die übergebene Zeit ist. (false) sonst.
+		//! Beispiel: (5:30:00).istKleiner( (10:40:29) ); return true
+		DLLEXPORT bool istKleiner(Uhrzeit* zeit) const;
+		//! prüft, ob die Uhrzeit kleiner als die übergebene Zeit ist.
+		//! \param stunde Die Stunden der zu prüfenden Zeit.
+		//! \param minute Die Minute der zu prüfenden Zeit.
+		//! \param sekunde Die Sekunde der zu prüfenden Zeit.
+		//! \return (true), wenn die gespeicherte Zeit kleiner als die übergebene Zeit ist. (false) sonst.
+		//! Beispiel: (5:30:00).istKleiner( 10, 40, 29 ); return true
+		DLLEXPORT bool istKleiner(int stunde, int minute, int sekunde) const;
+		//! prüft, ob die Uhrzeit kleiner als die übergebene Zeit ist.
+		//! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
+		//! \param zeit Eine Zeichenfolge die die andere Uhrzeit enthält.
+		//! \return (true), wenn die gespeicherte Zeit kleiner als die übergebene Zeit ist. (false) sonst.
+		//! Beispiel: (5:30:00).istKleiner( "h:i:s", "10:40:29" ); return true
+		DLLEXPORT bool istKleiner(const char* format, const char* zeit) const;
+		//! prüft, ob die Uhrzeit kleiner als die übergebene Zeit ist.
+		//! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
+		//! \param zeit Ein Text Zeichnung, welches die andere Uhrzeit enthält.
+		//! \return (true), wenn die gespeicherte Zeit kleiner als die übergebene Zeit ist. (false) sonst.
+		//! Beispiel: (5:30:00).istKleiner( "h:i:s", "10:40:29" ); return true
+		DLLEXPORT bool istKleiner(const char* format, Text* zeit) const;
+		//! prüft, ob die Uhrzeit größer als zeit ist.
+		//! \param zeit Die zu prüfende Uhrzeit.
+		//! \return (true), wenn die gespeicherte Zeit größer als die übergebene Zeit ist. (false) sonst.
+		//! Beispiel: (5:30:00).istGrößer( (10:40:29) ); return false
+		DLLEXPORT bool istLater(Uhrzeit* zeit) const;
+		//! prüft, ob die Uhrzeit größer als die übergebene Zeit ist.
+		//! \param stunde Die Stunden der zu prüfenden Zeit.
+		//! \param minute Die Minute der zu prüfenden Zeit.
+		//! \param sekunde Die Sekunde der zu prüfenden Zeit.
+		//! \return (true), wenn die gespeicherte Zeit größer als die übergebene Zeit ist. (false) sonst.
+		//! Beispiel: (5:30:00).istGrößer( 10, 40, 29 ); return false
+		DLLEXPORT bool istLater(int stunde, int minute, int sekunde) const;
+		//! prüft, ob die Uhrzeit größer als die übergebene Zeit ist.
+		//! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
+		//! \param zeit Eine Zeichenfolge die die andere Uhrzeit enthält.
+		//! \return (true), wenn die gespeicherte Zeit größer als die übergebene Zeit ist. (false) sonst.
+		//! Beispiel: (5:30:00).istGrößer( "h:i:s", "10:40:29" ); return false
+		DLLEXPORT bool istLater(const char* format, const char* zeit) const;
+		//! prüft, ob die Uhrzeit größer als die übergebene Zeit ist.
+		//! \param format Eine Zeichenfolge, die bestimmt in welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
+		//! \param zeit Ein Text Zeichnung, welches die andere Uhrzeit enthält.
+		//! \return (true), wenn die gespeicherte Zeit größer als die übergebene Zeit ist. (false) sonst.
+		//! Beispiel: (5:30:00).istGrößer( "h:i:s", "10:40:29" ); return false
+		DLLEXPORT bool istLater(const char* format, Text* zeit) const;
+	};
 
-    //! Diese Klasse speichert ein Datum in Form von Jahr, Monat und Tagen
-    class Datum : public virtual ReferenceCounter
-    {
-    private:
-        int jahr, monat, tag;
-        int *maxTage;
-        void update();
+	//! Diese Klasse speichert ein Datum in Form von Jahr, Monat und Tagen
+	class Datum : public virtual ReferenceCounter
+	{
+	private:
+		int jahr, monat, tag;
+		int* maxTage;
+		void update();
 
-    public:
-        //! Erzeugt ein neues Datum Zeichnung mit den Standartwerten 0.0.0.
-        DLLEXPORT Datum();
-        //! Löscht das Datum.
-        DLLEXPORT ~Datum();
+	public:
+		//! Erzeugt ein neues Datum Zeichnung mit den Standartwerten 0.0.0.
+		DLLEXPORT Datum();
+		//! Löscht das Datum.
+		DLLEXPORT ~Datum();
 
-        //! Setzt das Datum durch kopieren.
-        //! \param datum Das zu speichernde Datum.
-        DLLEXPORT void setDatum( Datum *datum );
-        //! Setzt das Datum zu den übergebenen Werten.
-        //! \param jahr Das Jahr des neuen Datums.
-        //! \param monat Der Monat des neuen Datums.
-        //! \param tag Der Tag des neuen Datums.
-        DLLEXPORT void setDatum( int jahr, int monat, int tag );
-        //! Setzt das Datum zu dem übergebenen Wert.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Eine Zeichenkette, die das neue Datum enthält.
-        //! Beispiel: setDatum( "y-m-d", "2016-01-25" );
-        DLLEXPORT void setDatum( const char *format, const char *datum );
-        //! Setzt das Datum zu dem übergebenen Wert.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Ein Text Zeichnung, welches das neue Datum enthält.
-        //! Beispiel: setDatum( "y-m-d", new Text(  "2016-01-25" ) );
-        DLLEXPORT void setDatum( const char *format, Text *datum );
-        //! Ändert das Jahr des Datums.
-        //! \param jahr Das neue Jahr.
-        DLLEXPORT void setJahr( int jahr );
-        //! Ändert den Monat des Datums.
-        //! \param monat Der neue Monat.
-        DLLEXPORT void setMonat( int monat );
-        //! Ändert den Tag des Datums.
-        //! \param tag Der neue Tag.
-        DLLEXPORT void setTag( int tag );
-        //! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert das Ergebnis.
-        //! \param datum Das zu addierende Datum.
-        //! Beispiel: ( 1.11.1995 ).plusDatum( ( 5.2.7 ) ); neues Datum: 6.1.2003
-        DLLEXPORT void plusDatum( Datum *datum );
-        //! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert das Ergebnis.
-        //! \param jahr Das zu addierende Jahr.
-        //! \param monat Der zu addierende Monat.
-        //! \param tag Der zu addierende Tag.
-        //! Beispiel: ( 1.11.1995 ).plusDatum( ( 7, 2, 5 ) ); neues Datum: 6.1.2003
-        DLLEXPORT void plusDatum( int jahr, int monat, int tag );
-        //! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert das Ergebnis.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Eine Zeichenkette, die das zu addierende Datum enthält.
-        //! Beispiel: ( 1.11.1995 ).plusDatum( "d.m.y", "5.2.7" ); neues Datum: 6.1.2003
-        DLLEXPORT void plusDatum( const char *format, const char *datum );
-        //! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert das Ergebnis.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Ein Text Zeichnung, welches das zu addierende Datum enthält.
-        //! Beispiel: ( 1.11.1995 ).plusDatum( "d.m.y", new Text( "5.2.7" ) ); neues Datum: 6.1.2003
-        DLLEXPORT void plusDatum( const char *format, Text *datum );
-        //! Addiert zum aktuellen Datum das übergebene Jahr dazu und speichert das Ergebnis.
-        //! \param jahr Das zu addierende Jahr.
-        //! Beispiel: ( 1.11.1995 ).plusJahr( 21 ); neues Datum: 1.11.2016
-        DLLEXPORT void plusJahr( int jahr );
-        //! Addiert zum aktuellen Datum den übergebenen Monat dazu und speichert das Ergebnis.
-        //! \param monat Der zu addierende Monat.
-        //! Beispiel: ( 1.11.1995 ).plusMonat( 13 ); neues Datum: 1.12.1996
-        DLLEXPORT void plusMonat( int monat );
-        //! Addiert zum aktuellen Datum den übergebenen Tag dazu und speichert das Ergebnis.
-        //! \param tag Der zu addierende Tag.
-        //! Beispiel: ( 1.1.2000 ).plusTag( 32 ); neues Datum: 2.2.2000
-        DLLEXPORT void plusTag( int tag );
-        //! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das Ergebnis.
-        //! \param datum Das abzuzuehende Datum.
-        //! Beispiel: ( 2.12.1996 ).minusDatum( ( 1.1.1 ) ); neues Datum: 1.11.1995
-        DLLEXPORT void minusDatum( Datum *datum );
-        //! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das Ergebnis.
-        //! \param jahr Das abzuzuehende Jahr.
-        //! \param monat Der abzuzuehende Monat.
-        //! \param tag Der abzuzuehende Tag.
-        //! Beispiel: ( 2.12.1996 ).minusDatum( 1, 1, 1 ); neues Datum: 1.11.1995
-        DLLEXPORT void minusDatum( int jahr, int monat, int tag );
-        //! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das Ergebnis.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Eine Zeichenkette, die das abzuziehende Datum enthält.
-        //! Beispiel: ( 2.12.1996 ).minusDatum( "d.m.y", "1.1.1" ); neues Datum: 1.11.1995
-        DLLEXPORT void minusDatum( const char *format, const char *datum );
-        //! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das Ergebnis.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Ein Text Zeichnung, welches das abzuziehende Datum enthält.
-        //! Beispiel: ( 2.12.1996 ).minusDatum( "d.m.y", new Text( "1.1.1" ) ); neues Datum: 1.11.1995
-        DLLEXPORT void minusDatum( const char *format, Text *datum );
-        //! Zieht vom aktuellen Datum das übergebene Jahr ab und speichert das Ergebnis.
-        //! \param jahr Das abzuzuehende Jahr.
-        //! Beispiel: ( 1.11.1996 ).minusJahr( 1 ); neues Datum: 1.11.1995
-        DLLEXPORT void minusJahr( int jahr );
-        //! Zieht vom aktuellen Datum den übergebenen Monat ab und speichert das Ergebnis.
-        //! \param monat Der abzuzuehende Monat.
-        //! Beispiel: ( 1.12.1996 ).minusMonat( 13 ); neues Datum: 1.11.1995
-        DLLEXPORT void minusMonat( int monat );
-        //! Zieht vom aktuellen Datum den übergebenen Tag ab und speichert das Ergebnis.
-        //! \param monat Der abzuzuehende Tag.
-        //! Beispiel: ( 5.2.2016 ).minusMonat( 11 ); neues Datum: 25.1.2016
-        DLLEXPORT void minusTag( int tag );
+		//! Setzt das Datum durch kopieren.
+		//! \param datum Das zu speichernde Datum.
+		DLLEXPORT void setDatum(Datum* datum);
+		//! Setzt das Datum zu den übergebenen Werten.
+		//! \param jahr Das Jahr des neuen Datums.
+		//! \param monat Der Monat des neuen Datums.
+		//! \param tag Der Tag des neuen Datums.
+		DLLEXPORT void setDatum(int jahr, int monat, int tag);
+		//! Setzt das Datum zu dem übergebenen Wert.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
+		//! \param datum Eine Zeichenkette, die das neue Datum enthält.
+		//! Beispiel: setDatum( "y-m-d", "2016-01-25" );
+		DLLEXPORT void setDatum(const char* format, const char* datum);
+		//! Setzt das Datum zu dem übergebenen Wert.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
+		//! \param datum Ein Text Zeichnung, welches das neue Datum enthält.
+		//! Beispiel: setDatum( "y-m-d", new Text(  "2016-01-25" ) );
+		DLLEXPORT void setDatum(const char* format, Text* datum);
+		//! Ändert das Jahr des Datums.
+		//! \param jahr Das neue Jahr.
+		DLLEXPORT void setJahr(int jahr);
+		//! Ändert den Monat des Datums.
+		//! \param monat Der neue Monat.
+		DLLEXPORT void setMonat(int monat);
+		//! Ändert den Tag des Datums.
+		//! \param tag Der neue Tag.
+		DLLEXPORT void setTag(int tag);
+		//! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert das Ergebnis.
+		//! \param datum Das zu addierende Datum.
+		//! Beispiel: ( 1.11.1995 ).plusDatum( ( 5.2.7 ) ); neues Datum: 6.1.2003
+		DLLEXPORT void plusDatum(Datum* datum);
+		//! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert das Ergebnis.
+		//! \param jahr Das zu addierende Jahr.
+		//! \param monat Der zu addierende Monat.
+		//! \param tag Der zu addierende Tag.
+		//! Beispiel: ( 1.11.1995 ).plusDatum( ( 7, 2, 5 ) ); neues Datum: 6.1.2003
+		DLLEXPORT void plusDatum(int jahr, int monat, int tag);
+		//! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert das Ergebnis.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
+		//! \param datum Eine Zeichenkette, die das zu addierende Datum enthält.
+		//! Beispiel: ( 1.11.1995 ).plusDatum( "d.m.y", "5.2.7" ); neues Datum: 6.1.2003
+		DLLEXPORT void plusDatum(const char* format, const char* datum);
+		//! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert das Ergebnis.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
+		//! \param datum Ein Text Zeichnung, welches das zu addierende Datum enthält.
+		//! Beispiel: ( 1.11.1995 ).plusDatum( "d.m.y", new Text( "5.2.7" ) ); neues Datum: 6.1.2003
+		DLLEXPORT void plusDatum(const char* format, Text* datum);
+		//! Addiert zum aktuellen Datum das übergebene Jahr dazu und speichert das Ergebnis.
+		//! \param jahr Das zu addierende Jahr.
+		//! Beispiel: ( 1.11.1995 ).plusJahr( 21 ); neues Datum: 1.11.2016
+		DLLEXPORT void plusJahr(int jahr);
+		//! Addiert zum aktuellen Datum den übergebenen Monat dazu und speichert das Ergebnis.
+		//! \param monat Der zu addierende Monat.
+		//! Beispiel: ( 1.11.1995 ).plusMonat( 13 ); neues Datum: 1.12.1996
+		DLLEXPORT void plusMonat(int monat);
+		//! Addiert zum aktuellen Datum den übergebenen Tag dazu und speichert das Ergebnis.
+		//! \param tag Der zu addierende Tag.
+		//! Beispiel: ( 1.1.2000 ).plusTag( 32 ); neues Datum: 2.2.2000
+		DLLEXPORT void plusTag(int tag);
+		//! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das Ergebnis.
+		//! \param datum Das abzuzuehende Datum.
+		//! Beispiel: ( 2.12.1996 ).minusDatum( ( 1.1.1 ) ); neues Datum: 1.11.1995
+		DLLEXPORT void minusDatum(Datum* datum);
+		//! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das Ergebnis.
+		//! \param jahr Das abzuzuehende Jahr.
+		//! \param monat Der abzuzuehende Monat.
+		//! \param tag Der abzuzuehende Tag.
+		//! Beispiel: ( 2.12.1996 ).minusDatum( 1, 1, 1 ); neues Datum: 1.11.1995
+		DLLEXPORT void minusDatum(int jahr, int monat, int tag);
+		//! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das Ergebnis.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
+		//! \param datum Eine Zeichenkette, die das abzuziehende Datum enthält.
+		//! Beispiel: ( 2.12.1996 ).minusDatum( "d.m.y", "1.1.1" ); neues Datum: 1.11.1995
+		DLLEXPORT void minusDatum(const char* format, const char* datum);
+		//! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das Ergebnis.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
+		//! \param datum Ein Text Zeichnung, welches das abzuziehende Datum enthält.
+		//! Beispiel: ( 2.12.1996 ).minusDatum( "d.m.y", new Text( "1.1.1" ) ); neues Datum: 1.11.1995
+		DLLEXPORT void minusDatum(const char* format, Text* datum);
+		//! Zieht vom aktuellen Datum das übergebene Jahr ab und speichert das Ergebnis.
+		//! \param jahr Das abzuzuehende Jahr.
+		//! Beispiel: ( 1.11.1996 ).minusJahr( 1 ); neues Datum: 1.11.1995
+		DLLEXPORT void minusJahr(int jahr);
+		//! Zieht vom aktuellen Datum den übergebenen Monat ab und speichert das Ergebnis.
+		//! \param monat Der abzuzuehende Monat.
+		//! Beispiel: ( 1.12.1996 ).minusMonat( 13 ); neues Datum: 1.11.1995
+		DLLEXPORT void minusMonat(int monat);
+		//! Zieht vom aktuellen Datum den übergebenen Tag ab und speichert das Ergebnis.
+		//! \param monat Der abzuzuehende Tag.
+		//! Beispiel: ( 5.2.2016 ).minusMonat( 11 ); neues Datum: 25.1.2016
+		DLLEXPORT void minusTag(int tag);
 
-        //! gibt das Jahr zurück.
-        DLLEXPORT int getJahr() const;
-        //! gibt der Monat zurück.
-        DLLEXPORT int getMonat() const;
-        //! gibt der Tag zurück.
-        DLLEXPORT int getTag() const;
-        //! Gibt das Datum als Text Zeichnung zurück.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das Datum zurückgegeben werden soll. y=Jahr, m=Monat, d=Tag.
-        //! Beispiel: ( 1.11.1995 ).getDatum( "y-m-d" ); return: "1995-11-1"
-        DLLEXPORT Text *getDatum( const char *format ) const;
-        //! Prüft, ob das Datum gleich dem übergebenen Datum ist.
-        //! \param datum das zu prüfende Datum.
-        //! \return (true), wenn das übergebene Datum dem gespeicherten entspricht. (false) sonnst.
-        DLLEXPORT bool istGleich( Datum *datum ) const;
-        //! Prüft, ob das Datum gleich dem übergebenen Datum ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Eine Zeichenkette, die das zu überprüfende Datum enthält.
-        //! \return (true), wenn das übergebene Datum dem gespeicherten entspricht. (false) sonnst.
-        //! Beispiel: ( 1.11.1995 ).istGleich( "y-m-d", "1995-11-1" ); return: true
-        DLLEXPORT bool istGleich( const char *format, const char *datum ) const;
-        //! Prüft, ob das Datum gleich dem übergebenen Datum ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Ein Text Zeichnung, welches das zu überprüfende Datum enthält.
-        //! \return (true), wenn das übergebene Datum dem gespeicherten entspricht. (false) sonnst.
-        //! Beispiel: ( 1.11.1995 ).istGleich( "y-m-d", new Text( "1995-11-1" ) ); return: true
-        DLLEXPORT bool istGleich( const char *format, Text *datum ) const;
-        //! Prüft, ob das Datum gleich dem übergebenen Datum ist.
-        //! \param jahr Das Jahr des zu überprüfenden Datums.
-        //! \param monat Der Monat des zu überprüfenden Datums.
-        //! \param tag Der Tag des zu überprüfenden Datums.
-        //! \return (true), wenn das übergebene Datum dem gespeicherten entspricht. (false) sonnst.
-        //! Beispiel: ( 1.11.1995 ).istGleich( 1995, 11, 1 ); return: true
-        DLLEXPORT bool istGleich( int jahr, int monat, int tag ) const;
-        //! Prüft, ob das Jahr gleich dem übergebenen Jahr ist.
-        //! \param jahr Das zu prüfende Jahr.
-        //! \return (true), wenn das übergebene Jahr dem gespeicherten entspricht. (false) sonnst.
-        DLLEXPORT bool jahrGleich( int jahr ) const;
-        //! Prüft, ob der Monat gleich dem übergebenen Monat ist.
-        //! \param monat Der zu prüfende Monat.
-        //! \return (true), wenn der übergebene Monat dem gespeicherten entspricht. (false) sonnst.
-        DLLEXPORT bool monatGleich( int monat ) const;
-        //! Prüft, ob der Tag gleich dem übergebenen Tag ist.
-        //! \param tag Der zu prüfende Tag.
-        //! \return (true), wenn der übergebene Tag dem gespeicherten entspricht. (false) sonnst.
-        DLLEXPORT bool tagGleich( int tag ) const;
-        //! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
-        //! \param datum Das zu prüfende Datum.
-        //! \return (true), wenn das gespeicherte Datum vor dem übergebenen liegt. (false) sonnst.
-        //! Beispiel: ( 1.11.1995 ).istKleiner( ( 23.1.2016 ) ); return true
-        DLLEXPORT bool istKleiner( Datum *datum ) const;
-        //! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
-        //! \param jahr Das Jahr des zu prüfenden Datums.
-        //! \param monat Der Monat des zu prüfenden Datums.
-        //! \param tag Der Tag des zu prüfenden Datums.
-        //! \return (true), wenn das gespeicherte Datum vor dem übergebenen liegt. (false) sonnst.
-        //! Beispiel: ( 1.11.1995 ).istKleiner( 2016, 1, 23 ); return true
-        DLLEXPORT bool istKleiner( int jahr, int monat, int tag ) const;
-        //! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Eine Zeichenkette, die das zu überprüfende Datum enthält.
-        //! \return (true), wenn das gespeicherte Datum vor dem übergebenen liegt. (false) sonnst.
-        //! Beispiel: ( 1.11.1995 ).istKleiner( "y, m, d", "2016, 1, 23" ); return true
-        DLLEXPORT bool istKleiner( const char *format, const char *datum ) const;
-        //! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Ein Text Zeichnung, welches das zu überprüfende Datum enthält.
-        //! \return (true), wenn das gespeicherte Datum vor dem übergebenen liegt. (false) sonnst.
-        //! Beispiel: ( 1.11.1995 ).istKleiner( "y, m, d", new Text( "2016, 1, 23" ) ); return true
-        DLLEXPORT bool istKleiner( const char *format, Text *datum ) const;
-        //! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
-        //! \param datum Das zu prüfende Datum.
-        //! \return (true), wenn das gespeicherte Datum hinter dem übergebenen liegt. (false) sonnst.
-        //! Beispiel: ( 1.11.1995 ).istGrößer( ( 23.1.2016 ) ); return false
-        DLLEXPORT bool istLater( Datum *datum ) const;
-        //! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
-        //! \param jahr Das Jahr des zu prüfenden Datums.
-        //! \param monat Der Monat des zu prüfenden Datums.
-        //! \param tag Der Tag des zu prüfenden Datums.
-        //! \return (true), wenn das gespeicherte Datum hinter dem übergebenen liegt. (false) sonnst.
-        //! Beispiel: ( 1.11.1995 ).istGrößer( 2016, 1, 23 ); return false
-        DLLEXPORT bool istLater( int jahr, int monat, int tag ) const;
-        //! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Eine Zeichenkette, die das zu überprüfende Datum enthält.
-        //! \return (true), wenn das gespeicherte Datum hinter dem übergebenen liegt. (false) sonnst.
-        //! Beispiel: ( 1.11.1995 ).istGrößer( "y, m, d", "2016, 1, 23" ); return false
-        DLLEXPORT bool istLater( const char *format, const char *datum ) const;
-        //! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
-        //! \param datum Ein Text Zeichnung, welches das zu überprüfende Datum enthält.
-        //! \return (true), wenn das gespeicherte Datum hinter dem übergebenen liegt. (false) sonnst.
-        //! Beispiel: ( 1.11.1995 ).istGrößer( "y, m, d", new Text( "2016, 1, 23" ) ) ); return true
-        DLLEXPORT bool istLater( const char *format, Text *datum ) const;
-    };
+		//! gibt das Jahr zurück.
+		DLLEXPORT int getJahr() const;
+		//! gibt der Monat zurück.
+		DLLEXPORT int getMonat() const;
+		//! gibt der Tag zurück.
+		DLLEXPORT int getTag() const;
+		//! Gibt das Datum als Text Zeichnung zurück.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form das Datum zurückgegeben werden soll. y=Jahr, m=Monat, d=Tag.
+		//! Beispiel: ( 1.11.1995 ).getDatum( "y-m-d" ); return: "1995-11-1"
+		DLLEXPORT Text* getDatum(const char* format) const;
+		//! Prüft, ob das Datum gleich dem übergebenen Datum ist.
+		//! \param datum das zu prüfende Datum.
+		//! \return (true), wenn das übergebene Datum dem gespeicherten entspricht. (false) sonnst.
+		DLLEXPORT bool istGleich(Datum* datum) const;
+		//! Prüft, ob das Datum gleich dem übergebenen Datum ist.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
+		//! \param datum Eine Zeichenkette, die das zu überprüfende Datum enthält.
+		//! \return (true), wenn das übergebene Datum dem gespeicherten entspricht. (false) sonnst.
+		//! Beispiel: ( 1.11.1995 ).istGleich( "y-m-d", "1995-11-1" ); return: true
+		DLLEXPORT bool istGleich(const char* format, const char* datum) const;
+		//! Prüft, ob das Datum gleich dem übergebenen Datum ist.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
+		//! \param datum Ein Text Zeichnung, welches das zu überprüfende Datum enthält.
+		//! \return (true), wenn das übergebene Datum dem gespeicherten entspricht. (false) sonnst.
+		//! Beispiel: ( 1.11.1995 ).istGleich( "y-m-d", new Text( "1995-11-1" ) ); return: true
+		DLLEXPORT bool istGleich(const char* format, Text* datum) const;
+		//! Prüft, ob das Datum gleich dem übergebenen Datum ist.
+		//! \param jahr Das Jahr des zu überprüfenden Datums.
+		//! \param monat Der Monat des zu überprüfenden Datums.
+		//! \param tag Der Tag des zu überprüfenden Datums.
+		//! \return (true), wenn das übergebene Datum dem gespeicherten entspricht. (false) sonnst.
+		//! Beispiel: ( 1.11.1995 ).istGleich( 1995, 11, 1 ); return: true
+		DLLEXPORT bool istGleich(int jahr, int monat, int tag) const;
+		//! Prüft, ob das Jahr gleich dem übergebenen Jahr ist.
+		//! \param jahr Das zu prüfende Jahr.
+		//! \return (true), wenn das übergebene Jahr dem gespeicherten entspricht. (false) sonnst.
+		DLLEXPORT bool jahrGleich(int jahr) const;
+		//! Prüft, ob der Monat gleich dem übergebenen Monat ist.
+		//! \param monat Der zu prüfende Monat.
+		//! \return (true), wenn der übergebene Monat dem gespeicherten entspricht. (false) sonnst.
+		DLLEXPORT bool monatGleich(int monat) const;
+		//! Prüft, ob der Tag gleich dem übergebenen Tag ist.
+		//! \param tag Der zu prüfende Tag.
+		//! \return (true), wenn der übergebene Tag dem gespeicherten entspricht. (false) sonnst.
+		DLLEXPORT bool tagGleich(int tag) const;
+		//! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
+		//! \param datum Das zu prüfende Datum.
+		//! \return (true), wenn das gespeicherte Datum vor dem übergebenen liegt. (false) sonnst.
+		//! Beispiel: ( 1.11.1995 ).istKleiner( ( 23.1.2016 ) ); return true
+		DLLEXPORT bool istKleiner(Datum* datum) const;
+		//! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
+		//! \param jahr Das Jahr des zu prüfenden Datums.
+		//! \param monat Der Monat des zu prüfenden Datums.
+		//! \param tag Der Tag des zu prüfenden Datums.
+		//! \return (true), wenn das gespeicherte Datum vor dem übergebenen liegt. (false) sonnst.
+		//! Beispiel: ( 1.11.1995 ).istKleiner( 2016, 1, 23 ); return true
+		DLLEXPORT bool istKleiner(int jahr, int monat, int tag) const;
+		//! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
+		//! \param datum Eine Zeichenkette, die das zu überprüfende Datum enthält.
+		//! \return (true), wenn das gespeicherte Datum vor dem übergebenen liegt. (false) sonnst.
+		//! Beispiel: ( 1.11.1995 ).istKleiner( "y, m, d", "2016, 1, 23" ); return true
+		DLLEXPORT bool istKleiner(const char* format, const char* datum) const;
+		//! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
+		//! \param datum Ein Text Zeichnung, welches das zu überprüfende Datum enthält.
+		//! \return (true), wenn das gespeicherte Datum vor dem übergebenen liegt. (false) sonnst.
+		//! Beispiel: ( 1.11.1995 ).istKleiner( "y, m, d", new Text( "2016, 1, 23" ) ); return true
+		DLLEXPORT bool istKleiner(const char* format, Text* datum) const;
+		//! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
+		//! \param datum Das zu prüfende Datum.
+		//! \return (true), wenn das gespeicherte Datum hinter dem übergebenen liegt. (false) sonnst.
+		//! Beispiel: ( 1.11.1995 ).istGrößer( ( 23.1.2016 ) ); return false
+		DLLEXPORT bool istLater(Datum* datum) const;
+		//! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
+		//! \param jahr Das Jahr des zu prüfenden Datums.
+		//! \param monat Der Monat des zu prüfenden Datums.
+		//! \param tag Der Tag des zu prüfenden Datums.
+		//! \return (true), wenn das gespeicherte Datum hinter dem übergebenen liegt. (false) sonnst.
+		//! Beispiel: ( 1.11.1995 ).istGrößer( 2016, 1, 23 ); return false
+		DLLEXPORT bool istLater(int jahr, int monat, int tag) const;
+		//! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
+		//! \param datum Eine Zeichenkette, die das zu überprüfende Datum enthält.
+		//! \return (true), wenn das gespeicherte Datum hinter dem übergebenen liegt. (false) sonnst.
+		//! Beispiel: ( 1.11.1995 ).istGrößer( "y, m, d", "2016, 1, 23" ); return false
+		DLLEXPORT bool istLater(const char* format, const char* datum) const;
+		//! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
+		//! \param datum Ein Text Zeichnung, welches das zu überprüfende Datum enthält.
+		//! \return (true), wenn das gespeicherte Datum hinter dem übergebenen liegt. (false) sonnst.
+		//! Beispiel: ( 1.11.1995 ).istGrößer( "y, m, d", new Text( "2016, 1, 23" ) ) ); return true
+		DLLEXPORT bool istLater(const char* format, Text* datum) const;
+	};
 
-    //! Diese Klasse vereint die beiden Klassen Datum und Uhrzeit und speichert somit einen Zeitstempel mit Jahr, Monat, Tag, Stunde, Minute und Sekunde
-    class Zeit : public virtual ReferenceCounter
-    {
-    private:
-        Datum *datum;
-        Uhrzeit *uhrzeit;
+	//! Diese Klasse vereint die beiden Klassen Datum und Uhrzeit und speichert somit einen Zeitstempel mit Jahr, Monat, Tag, Stunde, Minute und Sekunde
+	class Zeit : public virtual ReferenceCounter
+	{
+	private:
+		Datum* datum;
+		Uhrzeit* uhrzeit;
 
-    public:
-        //! Erzeugt ein neues Zeichnung mit den Standartwerten 0.0.0 0:0:0.
-        DLLEXPORT Zeit();
-        //! Löscht das aktuelle Zeichnung.
-        DLLEXPORT ~Zeit();
-        //! Ändert die gespeicherte Zeit durch kopieren der Werte aus (zeit).
-        //! \param zeit Die neue Zeit.
-        DLLEXPORT void setZeit( Zeit *zeit );
-        //! Ändert die gespeicherte Zeit.
-        //! \param jahr Das neue Jahr.
-        //! \param monat Der neue Monat.
-        //! \param tag Det neue Tag.
-        //! \param stunde Die neue Stunde.
-        //! \param minute Die neue Minute.
-        //! \param sekunde Die neue Sekunde.
-        DLLEXPORT void setZeit( int jahr, int monat, int tag, int stunde, int minute, int sekunde );
-        //! Ändert die gespeicherte Zeit.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
-        //! \param zeit Eine Zeichenkette, die die neue Zeit enthält.
-        //! Beispiel: setZeit( "y-m-d h:i:s", "2016-1-25 21:59:30" );
-        DLLEXPORT void setZeit( const char *format, const char *zeit );
-        //! Ändert die gespeicherte Zeit.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
-        //! \param zeit Ein Text Zeichnung, welches die neue Zeit enthält.
-        //! Beispiel: setZeit( "y-m-d h:i:s", new Text( "2016-1-25 21:59:30" ) );
-        DLLEXPORT void setZeit( const char *format, Text *zeit );
-        //! Ändert das gespeicherte Jahr.
-        //! \param jahr Das neue Jahr.
-        DLLEXPORT void setJahr( int jahr );
-        //! Ändert den gespeicherten Monat.
-        //! \param monat Der neue Monat.
-        DLLEXPORT void setMonat( int monat );
-        //! Ändert den gespeicherten Tag.
-        //! \param tag Der neue Tag.
-        DLLEXPORT void setTag( int tag );
-        //! Ändert die gespeicherte Stunde.
-        //! \param stunde Die neue Stunde.
-        DLLEXPORT void setStunde( int stunde );
-        //! Ändert die gespeicherte Minute.
-        //! \param minute Die neue Minute.
-        DLLEXPORT void setMinute( int minute );
-        //! Ändert die gespeicherte Sekunde.
-        //! \param sekunde Die neue Sekunde.
-        DLLEXPORT void setSekunde( int sekunde );
-        //! Addiert die übergebene Zeit und speichert das Ergebnis.
-        //! \param zeit Die zu Addierende Zeit.
-        DLLEXPORT void plusZeit( Zeit *zeit );
-        //! Addiert die übergebene Zeit und speichert das Ergebnis.
-        //! \param jahr Das zu addierende Jahr.
-        //! \param monat Der zu addierende Monat.
-        //! \param tag Der zu addierende Tag.
-        //! \param stunde Die zu addierende Stunde.
-        //! \param minute Die zu addierende Minute.
-        //! \param sekunde Die zu addierende Sekunde.
-        DLLEXPORT void plusZeit( int jahr, int monat, int tag, int stunde, int minute, int sekunde );
-        //! Addiert die übergebene Zeit und speichert das Ergebnis.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
-        //! \param zeit Eine Zeichenkette, die die zu addierende Zeit enthält.
-        DLLEXPORT void plusZeit( const char *format, const char *zeit );
-        //! Addiert die übergebene Zeit und speichert das Ergebnis.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
-        //! \param zeit Ein Text Zeichnung, welches die zu addierende Zeit enthält.
-        DLLEXPORT void plusZeit( const char *format, Text *zeit );
-        //! Addiert die übergebene Zeit und speichert das Ergebnis.
-        //! \param jahr Das zu addierende Jahr.
-        DLLEXPORT void plusJahr( int jahr );
-        //! Addiert die übergebene Zeit und speichert das Ergebnis.
-        //! \param monat Der zu addierende Monat.
-        DLLEXPORT void plusMonat( int monat );
-        //! Addiert die übergebene Zeit und speichert das Ergebnis.
-        //! \param tag Der zu addierende Tag.
-        DLLEXPORT void plusTag( int tag );
-        //! Addiert die übergebene Zeit und speichert das Ergebnis.
-        //! \param stunde Die zu addierende Stunde.
-        DLLEXPORT void plusStunde( int stunde );
-        //! Addiert die übergebene Zeit und speichert das Ergebnis.
-        //! \param minute Die zu addierende Minute.
-        DLLEXPORT void plusMinute( int minute );
-        //! Addiert die übergebene Zeit und speichert das Ergebnis.
-        //! \param sekunde Die zu addierende Sekunde.
-        DLLEXPORT void plusSekunde( int sekunde );
-        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
-        //! \param zeit Die abzuziehende Zeit.
-        DLLEXPORT void minusZeit( Zeit *zeit );
-        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
-        //! \param jahr Das abzuziehende Jahr.
-        //! \param monat Der abzuziehende Monat.
-        //! \param tag Der abzuziehende Tag.
-        //! \param stunde Die abzuziehende Stunde.
-        //! \param minute Die abzuziehende Minute.
-        //! \param sekunde Die abzuziehende Sekunde.
-        DLLEXPORT void minusZeit( int jahr, int monat, int tag, int stunde, int minute, int sekunde );
-        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
-        //! \param zeit Eine Zeichenkette, die die abzuziehende Zeit enthält.
-        DLLEXPORT void minusZeit( const char *format, const char *zeit );
-        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
-        //! \param zeit Ein Text Zeichnung, welches die abzuziehende Zeit enthält.
-        DLLEXPORT void minusZeit( const char *format, Text *zeit );
-        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
-        //! \param jahr Das abzuziehende Jahr.
-        DLLEXPORT void minusJahr( int jahr );
-        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
-        //! \param monat Der abzuziehende Monat.
-        DLLEXPORT void minusMonat( int monat );
-        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
-        //! \param tag Der abzuziehende Tag.
-        DLLEXPORT void minusTag( int tag );
-        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
-        //! \param stunde Die abzuziehende Stunde.
-        DLLEXPORT void minusStunde( int stunde );
-        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
-        //! \param minute Die abzuziehende Minute.
-        DLLEXPORT void minusMinute( int minute );
-        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
-        //! \param sekunde Die abzuziehende Sekunde.
-        DLLEXPORT void minusSekunde( int sekunde );
-        //! Gibt die gespeicherte Zeit als Text zurück.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit zurückgegeben werden soll. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
-        DLLEXPORT Text *getZeit( const char *format ) const;
-        //! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
-        //! \param zeit die zu überprüfende Zeit.
-        //! \return (true), wenn die Zeiten gleich sind. (false) sonst.
-        DLLEXPORT bool istGleich( Zeit *zeit ) const;
-        //! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
-        //! \param zeit Eine Zeichenkette, die die zu überprüfende Zeit enthält.
-        //! \return (true), wenn die Zeiten gleich sind. (false) sonst.
-        DLLEXPORT bool istGleich( const char *format, const char *zeit ) const;
-        //! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
-        //! \param zeit Eine Text Zeichnung, welches die zu überprüfende Zeit enthält.
-        //! \return (true), wenn die Zeiten gleich sind. (false) sonst.
-        DLLEXPORT bool istGleich( const char *format, Text *zeit ) const;
-        //! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
-        //! \param jahr Das zu überprüfende Jahr.
-        //! \param monat Der zu überprüfende Monat.
-        //! \param tag Der zu überprüfende Tag.
-        //! \param stunde Die zu überprüfende Stunde.
-        //! \param minute Die zu überprüfende Minute.
-        //! \param sekunde Die zu überprüfende Sekunde.
-        //! \return (true), wenn die Zeiten gleich sind. (false) sonst.
-        DLLEXPORT bool istGleich( int jahr, int monat, int tag, int stunde, int minute, int sekunde ) const;
-        //! Gibt das Zeichnung zurück, in dem das Datum gespeichert wird mit erhöhtem Reference Counter.
-        DLLEXPORT Datum *getDatum() const;
-        //! Gibt das Zeichnung zurück, in dem das Datum gespeichert wird ohne erhöhten Reference Counter.
-        DLLEXPORT Datum *zDatum() const;
-        //! Gibt das Zeichnung zurück, in dem die Uhrzeit gespeichert wird mit erhöhtem Reference Counter.
-        DLLEXPORT Uhrzeit *getUhrzeit() const;
-        //! Gibt das Zeichnung zurück, in dem die uhrzeit gespeichert wird ohne erhöhten Reference Counter.
-        DLLEXPORT Uhrzeit *zUhrzeit() const;
-        //! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit ist.
-        //! \param zeit Die zu überprüfende Zeit.
-        //! \return (true) wenn die gespeicherte Zeit vor der übergebenen Zeit liegt. (false) sonnst.
-        DLLEXPORT bool istKleiner( Zeit *zeit ) const;
-        //! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit ist.
-        //! \param jahr Das zu überprüfende Jahr.
-        //! \param monat Der zu überprüfende Monat.
-        //! \param tag Der zu überprüfende Tag.
-        //! \param stunde Die zu überprüfende Stunde.
-        //! \param minute Die zu überprüfende Minute.
-        //! \param sekunde Die zu überprüfende Sekunde.
-        //! \return (true) wenn die gespeicherte Zeit vor der übergebenen Zeit liegt. (false) sonnst.
-        DLLEXPORT bool istKleiner( int jahr, int monat, int tag, int stunde, int minute, int sekunde ) const;
-        //! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
-        //! \param zeit Eine Zeichenkette, die die zu überprüfende Zeit enthält.
-        //! \return (true) wenn die gespeicherte Zeit vor der übergebenen Zeit liegt. (false) sonnst.
-        DLLEXPORT bool istKleiner( const char *format, const char *zeit ) const;
-        //! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
-        //! \param zeit Eine Text Zeichnung, welches die zu überprüfende Zeit enthält.
-        //! \return (true) wenn die gespeicherte Zeit vor der übergebenen Zeit liegt. (false) sonnst.
-        DLLEXPORT bool istKleiner( const char *format, Text *zeit ) const;
-        //! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit ist.
-        //! \param zeit Die zu überprüfende Zeit.
-        //! \return (true) wenn die gespeicherte Zeit nach der übergebenen Zeit liegt. (false) sonnst.
-        DLLEXPORT bool istLater( Zeit *zeit ) const;
-        //! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit ist.
-        //! \param jahr Das zu überprüfende Jahr.
-        //! \param monat Der zu überprüfende Monat.
-        //! \param tag Der zu überprüfende Tag.
-        //! \param stunde Die zu überprüfende Stunde.
-        //! \param minute Die zu überprüfende Minute.
-        //! \param sekunde Die zu überprüfende Sekunde.
-        //! \return (true) wenn die gespeicherte Zeit nach der übergebenen Zeit liegt. (false) sonnst.
-        DLLEXPORT bool istLater( int jahr, int monat, int tag, int stunde, int minute, int sekunde ) const;
-        //! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
-        //! \param zeit Eine Zeichenkette, die die zu überprüfende Zeit enthält.
-        //! \return (true) wenn die gespeicherte Zeit nach der übergebenen Zeit liegt. (false) sonnst.
-        DLLEXPORT bool istLater( const char *format, const char *zeit ) const;
-        //! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit ist.
-        //! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
-        //! \param zeit Eine Text Zeichnung, welches die zu überprüfende Zeit enthält.
-        //! \return (true) wenn die gespeicherte Zeit nach der übergebenen Zeit liegt. (false) sonnst.
-        DLLEXPORT bool istLater( const char *format, Text *zeit ) const;
-    };
+	public:
+		//! Erzeugt ein neues Zeichnung mit den Standartwerten 0.0.0 0:0:0.
+		DLLEXPORT Zeit();
+		//! Löscht das aktuelle Zeichnung.
+		DLLEXPORT ~Zeit();
+		//! Ändert die gespeicherte Zeit durch kopieren der Werte aus (zeit).
+		//! \param zeit Die neue Zeit.
+		DLLEXPORT void setZeit(Zeit* zeit);
+		//! Ändert die gespeicherte Zeit.
+		//! \param jahr Das neue Jahr.
+		//! \param monat Der neue Monat.
+		//! \param tag Det neue Tag.
+		//! \param stunde Die neue Stunde.
+		//! \param minute Die neue Minute.
+		//! \param sekunde Die neue Sekunde.
+		DLLEXPORT void setZeit(int jahr, int monat, int tag, int stunde, int minute, int sekunde);
+		//! Ändert die gespeicherte Zeit.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
+		//! \param zeit Eine Zeichenkette, die die neue Zeit enthält.
+		//! Beispiel: setZeit( "y-m-d h:i:s", "2016-1-25 21:59:30" );
+		DLLEXPORT void setZeit(const char* format, const char* zeit);
+		//! Ändert die gespeicherte Zeit.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
+		//! \param zeit Ein Text Zeichnung, welches die neue Zeit enthält.
+		//! Beispiel: setZeit( "y-m-d h:i:s", new Text( "2016-1-25 21:59:30" ) );
+		DLLEXPORT void setZeit(const char* format, Text* zeit);
+		//! Ändert das gespeicherte Jahr.
+		//! \param jahr Das neue Jahr.
+		DLLEXPORT void setJahr(int jahr);
+		//! Ändert den gespeicherten Monat.
+		//! \param monat Der neue Monat.
+		DLLEXPORT void setMonat(int monat);
+		//! Ändert den gespeicherten Tag.
+		//! \param tag Der neue Tag.
+		DLLEXPORT void setTag(int tag);
+		//! Ändert die gespeicherte Stunde.
+		//! \param stunde Die neue Stunde.
+		DLLEXPORT void setStunde(int stunde);
+		//! Ändert die gespeicherte Minute.
+		//! \param minute Die neue Minute.
+		DLLEXPORT void setMinute(int minute);
+		//! Ändert die gespeicherte Sekunde.
+		//! \param sekunde Die neue Sekunde.
+		DLLEXPORT void setSekunde(int sekunde);
+		//! Addiert die übergebene Zeit und speichert das Ergebnis.
+		//! \param zeit Die zu Addierende Zeit.
+		DLLEXPORT void plusZeit(Zeit* zeit);
+		//! Addiert die übergebene Zeit und speichert das Ergebnis.
+		//! \param jahr Das zu addierende Jahr.
+		//! \param monat Der zu addierende Monat.
+		//! \param tag Der zu addierende Tag.
+		//! \param stunde Die zu addierende Stunde.
+		//! \param minute Die zu addierende Minute.
+		//! \param sekunde Die zu addierende Sekunde.
+		DLLEXPORT void plusZeit(int jahr, int monat, int tag, int stunde, int minute, int sekunde);
+		//! Addiert die übergebene Zeit und speichert das Ergebnis.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
+		//! \param zeit Eine Zeichenkette, die die zu addierende Zeit enthält.
+		DLLEXPORT void plusZeit(const char* format, const char* zeit);
+		//! Addiert die übergebene Zeit und speichert das Ergebnis.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
+		//! \param zeit Ein Text Zeichnung, welches die zu addierende Zeit enthält.
+		DLLEXPORT void plusZeit(const char* format, Text* zeit);
+		//! Addiert die übergebene Zeit und speichert das Ergebnis.
+		//! \param jahr Das zu addierende Jahr.
+		DLLEXPORT void plusJahr(int jahr);
+		//! Addiert die übergebene Zeit und speichert das Ergebnis.
+		//! \param monat Der zu addierende Monat.
+		DLLEXPORT void plusMonat(int monat);
+		//! Addiert die übergebene Zeit und speichert das Ergebnis.
+		//! \param tag Der zu addierende Tag.
+		DLLEXPORT void plusTag(int tag);
+		//! Addiert die übergebene Zeit und speichert das Ergebnis.
+		//! \param stunde Die zu addierende Stunde.
+		DLLEXPORT void plusStunde(int stunde);
+		//! Addiert die übergebene Zeit und speichert das Ergebnis.
+		//! \param minute Die zu addierende Minute.
+		DLLEXPORT void plusMinute(int minute);
+		//! Addiert die übergebene Zeit und speichert das Ergebnis.
+		//! \param sekunde Die zu addierende Sekunde.
+		DLLEXPORT void plusSekunde(int sekunde);
+		//! Zieht die übergebene Zeit ab und speichert das Ergebnis.
+		//! \param zeit Die abzuziehende Zeit.
+		DLLEXPORT void minusZeit(Zeit* zeit);
+		//! Zieht die übergebene Zeit ab und speichert das Ergebnis.
+		//! \param jahr Das abzuziehende Jahr.
+		//! \param monat Der abzuziehende Monat.
+		//! \param tag Der abzuziehende Tag.
+		//! \param stunde Die abzuziehende Stunde.
+		//! \param minute Die abzuziehende Minute.
+		//! \param sekunde Die abzuziehende Sekunde.
+		DLLEXPORT void minusZeit(int jahr, int monat, int tag, int stunde, int minute, int sekunde);
+		//! Zieht die übergebene Zeit ab und speichert das Ergebnis.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
+		//! \param zeit Eine Zeichenkette, die die abzuziehende Zeit enthält.
+		DLLEXPORT void minusZeit(const char* format, const char* zeit);
+		//! Zieht die übergebene Zeit ab und speichert das Ergebnis.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
+		//! \param zeit Ein Text Zeichnung, welches die abzuziehende Zeit enthält.
+		DLLEXPORT void minusZeit(const char* format, Text* zeit);
+		//! Zieht die übergebene Zeit ab und speichert das Ergebnis.
+		//! \param jahr Das abzuziehende Jahr.
+		DLLEXPORT void minusJahr(int jahr);
+		//! Zieht die übergebene Zeit ab und speichert das Ergebnis.
+		//! \param monat Der abzuziehende Monat.
+		DLLEXPORT void minusMonat(int monat);
+		//! Zieht die übergebene Zeit ab und speichert das Ergebnis.
+		//! \param tag Der abzuziehende Tag.
+		DLLEXPORT void minusTag(int tag);
+		//! Zieht die übergebene Zeit ab und speichert das Ergebnis.
+		//! \param stunde Die abzuziehende Stunde.
+		DLLEXPORT void minusStunde(int stunde);
+		//! Zieht die übergebene Zeit ab und speichert das Ergebnis.
+		//! \param minute Die abzuziehende Minute.
+		DLLEXPORT void minusMinute(int minute);
+		//! Zieht die übergebene Zeit ab und speichert das Ergebnis.
+		//! \param sekunde Die abzuziehende Sekunde.
+		DLLEXPORT void minusSekunde(int sekunde);
+		//! Gibt die gespeicherte Zeit als Text zurück.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit zurückgegeben werden soll. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
+		DLLEXPORT Text* getZeit(const char* format) const;
+		//! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
+		//! \param zeit die zu überprüfende Zeit.
+		//! \return (true), wenn die Zeiten gleich sind. (false) sonst.
+		DLLEXPORT bool istGleich(Zeit* zeit) const;
+		//! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
+		//! \param zeit Eine Zeichenkette, die die zu überprüfende Zeit enthält.
+		//! \return (true), wenn die Zeiten gleich sind. (false) sonst.
+		DLLEXPORT bool istGleich(const char* format, const char* zeit) const;
+		//! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
+		//! \param zeit Eine Text Zeichnung, welches die zu überprüfende Zeit enthält.
+		//! \return (true), wenn die Zeiten gleich sind. (false) sonst.
+		DLLEXPORT bool istGleich(const char* format, Text* zeit) const;
+		//! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
+		//! \param jahr Das zu überprüfende Jahr.
+		//! \param monat Der zu überprüfende Monat.
+		//! \param tag Der zu überprüfende Tag.
+		//! \param stunde Die zu überprüfende Stunde.
+		//! \param minute Die zu überprüfende Minute.
+		//! \param sekunde Die zu überprüfende Sekunde.
+		//! \return (true), wenn die Zeiten gleich sind. (false) sonst.
+		DLLEXPORT bool istGleich(int jahr, int monat, int tag, int stunde, int minute, int sekunde) const;
+		//! Gibt das Zeichnung zurück, in dem das Datum gespeichert wird mit erhöhtem Reference Counter.
+		DLLEXPORT Datum* getDatum() const;
+		//! Gibt das Zeichnung zurück, in dem das Datum gespeichert wird ohne erhöhten Reference Counter.
+		DLLEXPORT Datum* zDatum() const;
+		//! Gibt das Zeichnung zurück, in dem die Uhrzeit gespeichert wird mit erhöhtem Reference Counter.
+		DLLEXPORT Uhrzeit* getUhrzeit() const;
+		//! Gibt das Zeichnung zurück, in dem die uhrzeit gespeichert wird ohne erhöhten Reference Counter.
+		DLLEXPORT Uhrzeit* zUhrzeit() const;
+		//! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit ist.
+		//! \param zeit Die zu überprüfende Zeit.
+		//! \return (true) wenn die gespeicherte Zeit vor der übergebenen Zeit liegt. (false) sonnst.
+		DLLEXPORT bool istKleiner(Zeit* zeit) const;
+		//! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit ist.
+		//! \param jahr Das zu überprüfende Jahr.
+		//! \param monat Der zu überprüfende Monat.
+		//! \param tag Der zu überprüfende Tag.
+		//! \param stunde Die zu überprüfende Stunde.
+		//! \param minute Die zu überprüfende Minute.
+		//! \param sekunde Die zu überprüfende Sekunde.
+		//! \return (true) wenn die gespeicherte Zeit vor der übergebenen Zeit liegt. (false) sonnst.
+		DLLEXPORT bool istKleiner(int jahr, int monat, int tag, int stunde, int minute, int sekunde) const;
+		//! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit ist.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
+		//! \param zeit Eine Zeichenkette, die die zu überprüfende Zeit enthält.
+		//! \return (true) wenn die gespeicherte Zeit vor der übergebenen Zeit liegt. (false) sonnst.
+		DLLEXPORT bool istKleiner(const char* format, const char* zeit) const;
+		//! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit ist.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
+		//! \param zeit Eine Text Zeichnung, welches die zu überprüfende Zeit enthält.
+		//! \return (true) wenn die gespeicherte Zeit vor der übergebenen Zeit liegt. (false) sonnst.
+		DLLEXPORT bool istKleiner(const char* format, Text* zeit) const;
+		//! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit ist.
+		//! \param zeit Die zu überprüfende Zeit.
+		//! \return (true) wenn die gespeicherte Zeit nach der übergebenen Zeit liegt. (false) sonnst.
+		DLLEXPORT bool istLater(Zeit* zeit) const;
+		//! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit ist.
+		//! \param jahr Das zu überprüfende Jahr.
+		//! \param monat Der zu überprüfende Monat.
+		//! \param tag Der zu überprüfende Tag.
+		//! \param stunde Die zu überprüfende Stunde.
+		//! \param minute Die zu überprüfende Minute.
+		//! \param sekunde Die zu überprüfende Sekunde.
+		//! \return (true) wenn die gespeicherte Zeit nach der übergebenen Zeit liegt. (false) sonnst.
+		DLLEXPORT bool istLater(int jahr, int monat, int tag, int stunde, int minute, int sekunde) const;
+		//! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit ist.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
+		//! \param zeit Eine Zeichenkette, die die zu überprüfende Zeit enthält.
+		//! \return (true) wenn die gespeicherte Zeit nach der übergebenen Zeit liegt. (false) sonnst.
+		DLLEXPORT bool istLater(const char* format, const char* zeit) const;
+		//! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit ist.
+		//! \param format Eine Zeichenkette, die angibt in welcher Form die neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde, i=Minute, s=Sekunde.
+		//! \param zeit Eine Text Zeichnung, welches die zu überprüfende Zeit enthält.
+		//! \return (true) wenn die gespeicherte Zeit nach der übergebenen Zeit liegt. (false) sonnst.
+		DLLEXPORT bool istLater(const char* format, Text* zeit) const;
+	};
 
-    //! Diese Klasse kann messen, wie viel Zeit zwischen zwei Zeitpunkten verstrichen ist
-    class ZeitMesser : public virtual ReferenceCounter
-    {
-    private:
-        double start;
-        double ende;
-        double messung;
+	//! Diese Klasse kann messen, wie viel Zeit zwischen zwei Zeitpunkten verstrichen ist
+	class ZeitMesser : public virtual ReferenceCounter
+	{
+	private:
+		double start;
+		double ende;
+		double messung;
 
-    public:
-        //! Erzeugt ein neues ZeitMesser Zeichnung
-        DLLEXPORT ZeitMesser();
-        //! Löscht das aktuelle Zeichnung
-        DLLEXPORT ~ZeitMesser();
-        //! legt den Startpunkt des zeitstoppens fest
-        DLLEXPORT void messungStart();
-        //! legt des Endpunkt der Zeitmessung fest
-        DLLEXPORT void messungEnde();
-        //! gibt den Abstand zwischen start und ende der Messung in Sekunden zurück
-        DLLEXPORT double getSekunden() const;
-        //! gibt den Abstand zwischen start und ende der Messung in Minuten zurück
-        DLLEXPORT double getMinuten() const;
-        //! gibt den Abstand zwischen start und ende der Messung in Stunden zurück
-        DLLEXPORT double getStunden() const;
-    };
+	public:
+		//! Erzeugt ein neues ZeitMesser Zeichnung
+		DLLEXPORT ZeitMesser();
+		//! Löscht das aktuelle Zeichnung
+		DLLEXPORT ~ZeitMesser();
+		//! legt den Startpunkt des zeitstoppens fest
+		DLLEXPORT void messungStart();
+		//! legt des Endpunkt der Zeitmessung fest
+		DLLEXPORT void messungEnde();
+		//! gibt den Abstand zwischen start und ende der Messung in Sekunden zurück
+		DLLEXPORT double getSekunden() const;
+		//! gibt den Abstand zwischen start und ende der Messung in Minuten zurück
+		DLLEXPORT double getMinuten() const;
+		//! gibt den Abstand zwischen start und ende der Messung in Stunden zurück
+		DLLEXPORT double getStunden() const;
+		//! gibt true zurück, wenn aktuell eine MEssung läuft
+		DLLEXPORT bool isMeasuring() const;
+	};
 
-    //! gibt die aktuelle Uhrzeit zurück.
-    DLLEXPORT Uhrzeit *getUhrzeit();
-    //! gibt das aktuelle Datum zurück.
-    DLLEXPORT Datum *getDatum();
-    //! gibt die aktuelle Zeit( Datum und Uhrzeit ) zurück.
-    DLLEXPORT Zeit *getZeit();
-    //! prüft, ob jahr ein Schaltjahr ist.
-    //! \param jahr Das zu überprüfende Jahr.
-    //! \return (true), wenn das übergebene jahr ein Schaltjahr ist. (false) sonst.
-    DLLEXPORT bool istSchaltjahr( int jahr );
+	//! gibt die aktuelle Uhrzeit zurück.
+	DLLEXPORT Uhrzeit* getUhrzeit();
+	//! gibt das aktuelle Datum zurück.
+	DLLEXPORT Datum* getDatum();
+	//! gibt die aktuelle Zeit( Datum und Uhrzeit ) zurück.
+	DLLEXPORT Zeit* getZeit();
+	//! prüft, ob jahr ein Schaltjahr ist.
+	//! \param jahr Das zu überprüfende Jahr.
+	//! \return (true), wenn das übergebene jahr ein Schaltjahr ist. (false) sonst.
+	DLLEXPORT bool istSchaltjahr(int jahr);
 }
 
 #endif