#pragma +
// Name:						Einstellungen
// Programmtyp:			Hilfsroutine für
//								Fakturierprogramm
//	Programmiersprache:	C++ (AT&T Standard 3.0)
// Computersystem:		Commodore AMIGA
// Betriebssystem:		AMIGA OS3.0 oder höher
// Autor:					Manfred Tremmel
// © Copyright:			1997-2000 by MT Graphic & Design
// Version:					V1.08
//
//    Copyright (C) 1997-2000 Manfred Tremmel
//
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with this program; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA


// Includes:
#include <limits.h>
#include <new.h>
#include <clib/dos_protos.h>
#include <stdio.h>

#include "MTList.h"
#include "MTLocale.h"
#include "Datenbank.h"
#include "Adressen.h"
#include "Versand.h"
#include "Laender.h"
#include "Einstellungen.h"
#include "KontenPos.h"
#include "LocaleStrings.h"
#include "MTARexx.h"

extern FillAppStrings	*MyAppStringsPTR;

extern OpenLocaleClass	*MyLocalePTR;
extern Adress				*MyAdressPTR;
extern Niederlassung		*MyNiederlassungPTR;
extern Laender				*MyLaenderPTR;
extern Prefs				*MyPrefsPTR;
extern Versand				*MyVersandPTR;
extern KontenPos			*MyKontenPosPTR;

// ARexx-Port Auswertung
extern MTARexx				MyARexx;

Adress::Adress(STRPTR Dateiname, STRPTR Datenbankbez, UWORD User ) : DataBase( Dateiname, Datenbankbez, User, sizeof(AdressDaten), 720 )
{
	Daten = (AdressDaten *)UserData;
	Such_DB_Anzahl	= 30;
	Such_DB_Feld	= new void*[Such_DB_Anzahl];
	Such_DB_Typ		= new UBYTE[Such_DB_Anzahl];
	Such_DB_CS		= new STRPTR[Such_DB_Anzahl];

	Such_DB_Feld[0]	= NULL;
	Such_DB_Typ[0]		= 0;
	Such_DB_CS[0]		= NULL;
	Such_DB_Feld[1]	= (void *)&Daten->Kunde;
	Such_DB_Typ[1]		= 7;
	Such_DB_CS[1]		= NULL;
	Such_DB_Feld[2]	= (void *)&Daten->Niederlassung;
	Such_DB_Typ[2]		= 7;
	Such_DB_CS[2]		= NULL;
	Such_DB_Feld[3]	= (void *)&Daten->Mitarbeiter;
	Such_DB_Typ[3]		= 7;
	Such_DB_CS[3]		= NULL;
	Such_DB_Feld[4]	= (void *)&Daten->Lieferant;
	Such_DB_Typ[4]		= 7;
	Such_DB_CS[4]		= NULL;
	Such_DB_Feld[5]	= (void *)&Daten->Anrede;
	Such_DB_Typ[5]		= 5;
	Such_DB_CS[5]		= AppStrings[MSG_Anrede];
	Such_DB_Feld[6]	= (void *)Daten->Firma1;
	Such_DB_Typ[6]		= 0;
	Such_DB_CS[6]		= NULL;
	Such_DB_Feld[7]	= (void *)Daten->Firma2;
	Such_DB_Typ[7]		= 0;
	Such_DB_CS[7]		= NULL;
	Such_DB_Feld[8]	= (void *)Daten->Vorname;
	Such_DB_Typ[8]		= 0;
	Such_DB_CS[8]		= NULL;
	Such_DB_Feld[9]	= (void *)Daten->Name;
	Such_DB_Typ[9]		= 0;
	Such_DB_CS[9]		= NULL;
	Such_DB_Feld[10]	= (void *)Daten->Strasse;
	Such_DB_Typ[10]	= 0;
	Such_DB_CS[10]		= NULL;
	Such_DB_Feld[11]	= (void *)Daten->PLZ;
	Such_DB_Typ[11]	= 0;
	Such_DB_CS[11]		= NULL;
	Such_DB_Feld[12]	= (void *)Daten->Ort;
	Such_DB_Typ[12]	= 0;
	Such_DB_CS[12]		= NULL;
	Such_DB_Feld[13]	= (void *)&Daten->Land;
	Such_DB_Typ[13]	= 6;
	Such_DB_CS[13]		= MyLaenderPTR->CycleLaender;
	Such_DB_Feld[14]	= (void *)&Daten->Bundesland;
	Such_DB_Typ[14]	= 5;
	Such_DB_CS[14]		= NULL;
	Such_DB_Feld[15]	= (void *)Daten->Telefon;
	Such_DB_Typ[15]	= 0;
	Such_DB_CS[15]		= NULL;
	Such_DB_Feld[16]	= (void *)Daten->Fax;
	Such_DB_Typ[16]	= 0;
	Such_DB_CS[16]		= NULL;
	Such_DB_Feld[17]	= (void *)Daten->DFUE;
	Such_DB_Typ[17]	= 0;
	Such_DB_CS[17]		= NULL;
	Such_DB_Feld[18]	= (void *)Daten->EMail[0];
	Such_DB_Typ[18]	= 0;
	Such_DB_CS[18]		= NULL;
	Such_DB_Feld[19]	= (void *)&Daten->BLZ;
	Such_DB_Typ[19]	= 7;
	Such_DB_CS[19]		= NULL;
	Such_DB_Feld[20]	= (void *)Daten->Bankbezeich;
	Such_DB_Typ[20]	= 0;
	Such_DB_CS[20]		= NULL;
	Such_DB_Feld[21]	= (void *)Daten->Bankkurz;
	Such_DB_Typ[21]	= 0;
	Such_DB_CS[21]		= NULL;
	Such_DB_Feld[22]	= (void *)Daten->Kontonummer;
	Such_DB_Typ[22]	= 0;
	Such_DB_CS[22]		= NULL;
	Such_DB_Feld[23]	= (void *)&Daten->Geburtstag;
	Such_DB_Typ[23]	= 2;
	Such_DB_CS[23]		= NULL;
	Such_DB_Feld[24]	= (void *)&Daten->Aufnahmedatum;
	Such_DB_Typ[24]	= 2;
	Such_DB_CS[24]		= NULL;
	Such_DB_Feld[25]	= (void *)&Daten->Familienstand;
	Such_DB_Typ[25]	= 5;
	Such_DB_CS[25]		= AppStrings[MSG_FStand];
	Such_DB_Feld[26]	= (void *)Daten->TelefonPrivat;
	Such_DB_Typ[26]	= 0;
	Such_DB_CS[26]		= NULL;
	Such_DB_Feld[27]	= (void *)Daten->TelefonMobil;
	Such_DB_Typ[27]	= 0;
	Such_DB_CS[27]		= NULL;
	Such_DB_Feld[28]	= (void *)Daten->URL;
	Such_DB_Typ[28]	= 0;
	Such_DB_CS[28]		= NULL;
	Such_DB_Feld[29]	= (void *)Daten->Kommentar;
	Such_DB_Typ[29]	= 0;
	Such_DB_CS[29]		= NULL;

	Such_DB_Felder_Laenge = strlen( AppStrings[MSG_Such_Adr_Dummy] ) + 1 +
									strlen( AppStrings[MSG_Such_Adr_AdresseA] ) +
									strlen( AppStrings[MSG_Such_Adr_AdresseB] );
	Such_DB_Felder_String = new TEXT[Such_DB_Felder_Laenge];

	strcpy( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_Dummy] );
	strcat( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_AdresseA] );
	strcat( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_AdresseB] );

	Such_DB_Nr			= 0;

	struct DruWert AdressDruWert[] =
	{
		{"Adresse1",				"[", NULL, 500, "]", TRUE},
		{"Adresse2",				"[", NULL, 500, "]", TRUE},
		{"Adresse3",				"[", NULL, 500, "]", TRUE},
		{"KundenNr",				"(", NULL, 16, ")", TRUE},
		{"MitarbeiterNr",			"(", NULL, 16, ")", TRUE},
		{"NiederlassungNr",		"(", NULL, 16, ")", TRUE},
		{"LieferantenNr",			"(", NULL, 16, ")", TRUE},
		{"Anrede",					"(", NULL, 32, ")", TRUE},
		{"Name",						"(", NULL, 32, ")", TRUE},
		{"Vorname",					"(", NULL, 32, ")", TRUE},
		{"Firma1",					"(", NULL, 60, ")", TRUE},
		{"Firma2",					"(", NULL, 60, ")", TRUE},
		{"Strasse",					"(", NULL, 60, ")", TRUE},
		{"PLZ",						"(", NULL, 16, ")", TRUE},
		{"PLZ2",						"(", NULL, 16, ")", TRUE},
		{"Ort",						"(", NULL, 44, ")", TRUE},
		{"Land",						"(", NULL, 60, ")", TRUE},
		{"Bundesland",				"(", NULL, 60, ")", TRUE},
		{"Telefon",					"(", NULL, 40, ")", TRUE},
		{"Telefax",					"(", NULL, 40, ")", TRUE},
		{"DFUENr",					"(", NULL, 40, ")", TRUE},
		{"EMail1",					"(", NULL, 80, ")", TRUE},
		{"EMail2",					"(", NULL, 80, ")", FALSE},
		{"EMail3",					"(", NULL, 80, ")", FALSE},
		{"BLZ",						"(", NULL, 12, ")", FALSE},
		{"BLZ2",						"(", NULL, 12, ")", FALSE},
		{"Bank",						"(", NULL, 44, ")", FALSE},
		{"Bankkurz",				"(", NULL, 20, ")", FALSE},
		{"Konto",					"(", NULL, 20, ")", FALSE},
		{"Geburtstag",				"[", NULL, 80, "]", FALSE},
		{"Aufnahme",				"[", NULL, 80, "]", FALSE},
		{"Familienstand",			"(", NULL, 20, ")", FALSE},
		{"Kommentar",				"[", NULL, 360, "]", FALSE},
		{"TelefonPrivat",			"(", NULL, 40,	")", FALSE},
		{"TelefonMobil",			"(", NULL, 40,	")", FALSE},
		{"URL",						"(", NULL, 80, ")", FALSE},
		{"",							"",  NULL, 0, "", FALSE}
	};

	DruckWertInit( AdressDruWert );
};

void Adress::Initialisiere( STRPTR InitDaten )
{
	DataBase::Initialisiere( InitDaten );

	MyLocalePTR->AktDateTime(&((AdressDaten *)InitDaten)->Aufnahmedatum);

	((AdressDaten *)InitDaten)->Geburtstag.ds_Days		= 0;
	((AdressDaten *)InitDaten)->Geburtstag.ds_Minute	= -1;
	((AdressDaten *)InitDaten)->Geburtstag.ds_Tick		= -1;
}

void Adress::UpdateSatz( STRPTR AlteVersion )
{
	Daten = (AdressDaten *)UserData;

	if( (AlteVersion[1] == '.') ||
		 (strncmp(AlteVersion, " 1.02", 5) < 0) )
	{
		strcpy( Daten->EMail[0], Daten->TelefonPrivat );
		strcpy( Daten->EMail[1], &Daten->TelefonMobil[10] );
		strcpy( Daten->EMail[2], &Daten->URL[20] );
	}

	if( (AlteVersion[1] == '.') ||
		 (strncmp(AlteVersion, " 1.06", 5) < 0) )
	{
		for( ULONG i = 0; i < 20; i++ )
		{
			Daten->TelefonPrivat[i]	= '\0';
			Daten->TelefonMobil[i]	= '\0';
			Daten->URL[i]				= '\0';
			Daten->URL[i+20]			= '\0';
			Daten->URL[i+30]			= '\0';
		}
	}
}

void Adress::Datenaenderung()
{
	if( Daten->Niederlassung )
		MyNiederlassungPTR->CycleUpDate();
	if( (MyNiederlassungPTR->UserNiederlassung.Adresse == AktElementNr) &&
		 (MyLaenderPTR->AktDatenPos != (Daten->Land + 1)) )
	{
		MyLaenderPTR->GetElementNr( (Daten->Land + 1) );
		MyLaenderPTR->AktDatenPos = Daten->Land + 1;
		memcpy( (void *)&MyLaenderPTR->AktDaten, (const void *)MyLaenderPTR->Daten, sizeof(LaenderDaten) );
	}
}

void Adress::UpDateElement()
{
	DataBase::UpDateElement();
	Datenaenderung();
};

void Adress::UnDo()
{
	DataBase::UnDo();
	Datenaenderung();
};

void Adress::ReDo()
{
	DataBase::ReDo();
	Datenaenderung();
};

BOOL Adress::SuchVergleich( DataBaseSearch* SuchKlasse )
{
	BOOL Returnwert;
	ULONG i;

	switch( SuchKlasse->DatenbankfeldNr )
	{
		case 18:
			for( i = 0; (i < 3) && !Returnwert; i++ )
			{
				Returnwert = SuchKlasse->Vergleich( (void *)Daten->EMail[i] );
			}
			break;
		default:
			Returnwert = SuchKlasse->Vergleich();
			break;
	}
	return Returnwert;
};

void Adress::SuchListeAnhaengen(ListenClass* SuchListe)
{
	char TextWert[1024];

	sprintf( (char *)TextWert, "%lu; %s; %s; %s; %s; %s; %s; %s; %s",
																				AktElementNr,
																				Daten->Firma1,
																				Daten->Firma2,
																				Daten->Vorname,
																				Daten->Name,
																				Daten->Strasse,
																				Daten->PLZ,
																				Daten->Ort,
																				MyLaenderPTR->LaenderListe->SucheNode(Daten->Land));
	TextWert[255] = 0;
	SuchListe->NeuerNode( TextWert );
};

void Adress::Anschrift( UBYTE Version, ListenClass* AdressListe, STRPTR AdressString, BOOL PSDruck, AdressDaten* ADaten )
{
	UBYTE	Ebene				= 0;
	BOOL	Oder[10]			= { FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE };
	UWORD	Zaehler[10]		= { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
	TEXT	EText[10][256];
	STRPTR ESText[10]		= { EText[0], EText[1], EText[2], EText[3], EText[4],
									 EText[5], EText[6], EText[7], EText[8], EText[9] };
	TEXT	TelVorwahl[16];
	STRPTR ZWString1, ZWString2;
	UWORD	*Schablone;

	if( ADaten == NULL)
		ADaten = Daten;

	if( (ADaten->Name[0] + ADaten->Vorname[0] + ADaten->Firma1[0] + ADaten->Firma2[0] + ADaten->Strasse[0] + ADaten->PLZ[0] + ADaten->Ort[0]) == 0 )
		EText[0][0] = '\0';
	else
	{
		if( MyLaenderPTR->ElementeVorhanden() > 0 )
		{
			MyLaenderPTR->GetElementNr( (ADaten->Land + 1) );

			switch( Version )
			{
				case 0:
					if( ADaten->Anrede )
						Schablone = MyLaenderPTR->Daten->PAdresseeinez;
					else
						Schablone = MyLaenderPTR->Daten->GAdresseeinez;
					break;
				case 1:
					if( ADaten->Anrede )
						Schablone = MyLaenderPTR->Daten->PAdressekurz;
					else
						Schablone = MyLaenderPTR->Daten->GAdressekurz;
					break;
				default:
					if( ADaten->Anrede )
						Schablone = MyLaenderPTR->Daten->PAdresselang;
					else
						Schablone = MyLaenderPTR->Daten->GAdresselang;
					break;
			}

			// Vorwahl vorbereiten
			if( (ADaten->Land + 1) == MyLaenderPTR->AktDatenPos )
				strcpy( TelVorwahl, MyLaenderPTR->AktDaten.TelInland );
			else
			{
				strcpy( TelVorwahl, MyLaenderPTR->AktDaten.TelAusland );
				strcat( TelVorwahl, MyLaenderPTR->Daten->TelVonAusland );
			}

			*ESText[Ebene]	= 0;
			for(; *Schablone; Schablone++)
			{
				ZWString1 = NULL;
				switch( *Schablone )
				{
					case 0x0100:
						ESText[Ebene]	= MyAppStringsPTR->GetCycleWert( AppStrings[MSG_Anrede], ESText[Ebene], ADaten->Anrede );
						Zaehler[Ebene]++;
						break;
					case 0x0101:
						ZWString1 = ADaten->Name;
						break;
					case 0x0102:
						ZWString1 = ADaten->Vorname;
						break;
					case 0x0103:
						ZWString1 = ADaten->Firma1;
						break;
					case 0x0104:
						ZWString1 = ADaten->Firma2;
						break;
					case 0x0105:
						ZWString1 = ADaten->Strasse;
						break;
					case 0x0106:
						ZWString1 = ADaten->PLZ;
						break;
					case 0x0107:
						ZWString1 = ADaten->Ort;
						break;
					case 0x0108:
						if( *ADaten->Telefon )
							for( ZWString1 = TelVorwahl; *ZWString1; *ESText[Ebene]++ = *ZWString1++ );
						ZWString1 = ADaten->Telefon;
						break;
					case 0x0109:
						if( *ADaten->Fax )
							for( ZWString1 = TelVorwahl; *ZWString1; *ESText[Ebene]++ = *ZWString1++ );
						ZWString1 = ADaten->Fax;
						break;
					case 0x010a:
						if( *ADaten->DFUE )
							for( ZWString1 = TelVorwahl; *ZWString1; *ESText[Ebene]++ = *ZWString1++ );
						ZWString1 = ADaten->DFUE;
						break;
					case 0x010b:
						ZWString1 = ADaten->EMail[0];
						break;
					case 0x010c:
						ZWString1 = ADaten->EMail[1];
						break;
					case 0x010d:
						ZWString1 = ADaten->EMail[2];
						break;
					case 0x010e:
						ZWString1 = MyLaenderPTR->Daten->Land;
						break;
					case 0x010f:
						ZWString1 = MyLaenderPTR->Daten->LandKZ;
						break;
					case 0x0110:
						ZWString1 = MyLaenderPTR->Daten->Bundesland[ADaten->Bundesland];
						break;
					case 0x0200:
						if( Ebene < 10 )
						{
							Ebene++;
							ESText[Ebene]		= EText[Ebene];
						}
						break;
					case 0x0201:
					case 0x0202:
						if( Ebene > 0 )
						{
							if( !Oder[Ebene] && Zaehler[Ebene] )
							{
								ZWString2		= ESText[Ebene-1];
								for(ZWString1	= EText[Ebene]; *ZWString1; *ZWString2++ = *ZWString1++ );
								ESText[Ebene-1]= ZWString2;
								ZWString1 = NULL;
							}
							if( (*Schablone == 0x0202) && Zaehler[Ebene] )
								Oder[Ebene]		= TRUE;
							else
								Oder[Ebene]		= FALSE;
							Zaehler[Ebene-1]	+= Zaehler[Ebene];
							Zaehler[Ebene]		= 0;
							Ebene--;
						}
						break;
					default:
						if( *Schablone < 0x0100 )
							*ESText[Ebene]++ = *Schablone;
						break;
				}
				if( ZWString1 )
				{
					if( *ZWString1 )
					{
						Zaehler[Ebene]++;
						for(; *ZWString1; *ESText[Ebene]++ = *ZWString1++ );
					}
				}
				*ESText[Ebene] = 0;
			}
			for(; Ebene > 0; Ebene-- )
			{
				if( !Oder[Ebene] && Zaehler[Ebene] )
				{
					ZWString2		= ESText[Ebene-1];
					for(ZWString1	= ESText[Ebene]; *ZWString1; *ZWString2++ = *ZWString1++ );
					ESText[Ebene-1]= ZWString2;
				}
				Oder[Ebene]			= FALSE;
				ESText[Ebene]		= EText[Ebene];
				Zaehler[Ebene]		= 0;
			}
		}
		else
			EText[0][0] = '\0';
	}

	if( AdressListe )
		AdressListe->StringToList( EText[0] );

	if( AdressString )
	{
		ZWString2		= AdressString;
		if( PSDruck )
			PSAufbereitMZ(EText[0], ZWString2 );
		else
		{
			for(ZWString1 = EText[0]; *ZWString1; *ZWString2++ = *ZWString1++ );
			*ZWString2		= '\0';
		}
	}
};


void Adress::PrintString( ofstream* os, STRPTR start, AdressDaten* UebDaten )
{
	if( UebDaten )
		Daten = UebDaten;
	DataBase::PrintString( os, start );
	Daten = (AdressDaten *)UserData;
};

void Adress::PrintTabelle( ofstream* os, UBYTE Typ, ULONG von, ULONG bis, DataBaseSearch* Vergleichsfunktion, UWORD* Verknuepf, AdressDaten* UebDaten )
{
	if( UebDaten )
	{
		Daten = UebDaten;
		DataBase::PrintTabelle( os, Typ, von, 0, Vergleichsfunktion, Verknuepf );
		Daten = (AdressDaten *)UserData;
	}
	else
		DataBase::PrintTabelle( os, Typ, von, bis, Vergleichsfunktion, Verknuepf );
};

void Adress::PrintVorbereiten(  ofstream* os, UBYTE Art )
{
	TEXT Zwischenstring[256];
	TEXT Zwischenstring2[256];
	ULONG j = 0;

	MyLaenderPTR->GetElementNr( (Daten->Land + 1) );

	// Adresse Format 1
	Anschrift( 0, NULL, DruckWert[j++].Wert, TRUE, Daten);

	// Adresse Format 2
	Anschrift( 1, NULL, DruckWert[j++].Wert, TRUE, Daten);

	// Adresse Format 3
	Anschrift( 2, NULL, DruckWert[j++].Wert, TRUE, Daten);


	// Kundennummer
	// Mitarbeiternummer
	// Niederlassunsnummer
	// Lieferantennummer
	if( MyPrefsPTR->Daten->Nr_Laenge )
	{
		sprintf(DruckWert[j++].Wert, "%0*lu", MyPrefsPTR->Daten->Nr_Laenge, Daten->Kunde);
		sprintf(DruckWert[j++].Wert, "%0*lu", MyPrefsPTR->Daten->Nr_Laenge, Daten->Mitarbeiter);
		sprintf(DruckWert[j++].Wert, "%0*lu", MyPrefsPTR->Daten->Nr_Laenge, Daten->Niederlassung);
		sprintf(DruckWert[j++].Wert, "%0*lu", MyPrefsPTR->Daten->Nr_Laenge, Daten->Lieferant);
	}
	else
	{
		sprintf(DruckWert[j++].Wert, "%lu", Daten->Kunde);
		sprintf(DruckWert[j++].Wert, "%lu", Daten->Mitarbeiter);
		sprintf(DruckWert[j++].Wert, "%lu", Daten->Niederlassung);
		sprintf(DruckWert[j++].Wert, "%lu", Daten->Lieferant);
	}

	// Anrede
	MyAppStringsPTR->GetCycleWert( AppStrings[MSG_Anrede], Zwischenstring, Daten->Anrede );
	PSAufbereit(Zwischenstring, DruckWert[j++].Wert);

	// Name
	PSAufbereit(Daten->Name, DruckWert[j++].Wert);

	// Vorname
	PSAufbereit(Daten->Vorname, DruckWert[j++].Wert);

	// Firma1
	PSAufbereit(Daten->Firma1, DruckWert[j++].Wert);

	// Firma2
	PSAufbereit(Daten->Firma2, DruckWert[j++].Wert);

	// Strasse
	PSAufbereit(Daten->Strasse, DruckWert[j++].Wert);

	// Postleitzahl
	PSAufbereit(Daten->PLZ, DruckWert[j++].Wert);

	// PLZ + Laenderkennzeichen
	PSAufbereit(MyLaenderPTR->Daten->LandKZ, DruckWert[j].Wert);
	strcat( DruckWert[j].Wert, DruckWert[(j-1)].Wert );
	j++;

	// Ort
	PSAufbereit(Daten->Ort, DruckWert[j++].Wert);

	// Landesbezeichenung
	PSAufbereit(MyLaenderPTR->Daten->Land, DruckWert[j++].Wert);

	// Bundesland
	PSAufbereit(MyLaenderPTR->Daten->Bundesland[Daten->Bundesland], DruckWert[j++].Wert);

	// Vorwahl vorbereiten
	if( (Daten->Land + 1) == MyLaenderPTR->AktDatenPos )
		PSAufbereit(MyLaenderPTR->AktDaten.TelInland, Zwischenstring);
	else
	{
		PSAufbereit(MyLaenderPTR->AktDaten.TelAusland, Zwischenstring);
		PSAufbereit(MyLaenderPTR->Daten->TelVonAusland, Zwischenstring2);
		strcat( Zwischenstring, Zwischenstring2 );
	}

	// Telefon
	if( Daten->Telefon[0] == 0 )
		DruckWert[j++].Wert[0] = 0;
	else
	{
		PSAufbereit(Daten->Telefon, Zwischenstring2);
		strcpy( DruckWert[j].Wert, Zwischenstring );
		strcat( DruckWert[j++].Wert, Zwischenstring2 );
	}

	// Telefax
	if( Daten->Fax[0] == 0 )
		DruckWert[j++].Wert[0] = 0;
	else
	{
		PSAufbereit(Daten->Fax, Zwischenstring2);
		strcpy( DruckWert[j].Wert, Zwischenstring );
		strcat( DruckWert[j++].Wert, Zwischenstring2 );
	}

	// DFUE-Anwahl
	if( Daten->DFUE[0] == 0 )
		DruckWert[j++].Wert[0] = 0;
	else
	{
		PSAufbereit(Daten->DFUE, Zwischenstring2);
		strcpy( DruckWert[j].Wert, Zwischenstring );
		strcat( DruckWert[j++].Wert, Zwischenstring2 );
	}

	// EMails
	PSAufbereit(Daten->EMail[0], DruckWert[j++].Wert);
	PSAufbereit(Daten->EMail[1], DruckWert[j++].Wert);
	PSAufbereit(Daten->EMail[2], DruckWert[j++].Wert);

	// Bankleitzahl
	if( Daten->BLZ == 0 )
	{
		DruckWert[j++].Wert[0] = 0;
		DruckWert[j++].Wert[0] = 0;
	}
	else
	{
		sprintf( DruckWert[j++].Wert, "%08lu", Daten->BLZ );
		DruckWert[j].Wert[0] = DruckWert[24].Wert[0];
		DruckWert[j].Wert[1] = DruckWert[24].Wert[1];
		DruckWert[j].Wert[2] = DruckWert[24].Wert[2];
		DruckWert[j].Wert[3] = ' ';
		DruckWert[j].Wert[4] = DruckWert[24].Wert[3];
		DruckWert[j].Wert[5] = DruckWert[24].Wert[4];
		DruckWert[j].Wert[6] = DruckWert[24].Wert[5];
		DruckWert[j].Wert[7] = ' ';
		DruckWert[j].Wert[8] = DruckWert[24].Wert[6];
		DruckWert[j].Wert[9] = DruckWert[24].Wert[7];
		DruckWert[j++].Wert[10] = 0;
	}

	// Bankbezeichnung
	PSAufbereit(Daten->Bankbezeich, DruckWert[j++].Wert);
	PSAufbereit(Daten->Bankkurz, DruckWert[j++].Wert);

	// Kontonummer
	PSAufbereit(Daten->Kontonummer, DruckWert[j++].Wert);

	// Geburtstag
	PSDruckDatum( DruckWert[j++].Wert, &Daten->Geburtstag );

	// Aufnahmedatum
	PSDruckDatum( DruckWert[j++].Wert, &Daten->Aufnahmedatum );

	// Familienstand
	MyAppStringsPTR->GetCycleWert( AppStrings[MSG_FStand], Zwischenstring, Daten->Familienstand );
	PSAufbereit(Zwischenstring, DruckWert[j++].Wert);

	// Kommentar/Zusatztext
	PSAufbereitMZ(Daten->Kommentar, DruckWert[j++].Wert);

	// Telefon Privat
	if( Daten->TelefonPrivat[0] == 0 )
		DruckWert[j++].Wert[0] = 0;
	else
	{
		PSAufbereit(Daten->TelefonPrivat, Zwischenstring2);
		strcpy( DruckWert[j].Wert, Zwischenstring );
		strcat( DruckWert[j++].Wert, Zwischenstring2 );
	}

	// Telefon Mobil
	if( Daten->TelefonMobil[0] == 0 )
		DruckWert[j++].Wert[0] = 0;
	else
	{
		PSAufbereit(Daten->TelefonMobil, Zwischenstring2);
		strcpy( DruckWert[j].Wert, Zwischenstring );
		strcat( DruckWert[j++].Wert, Zwischenstring2 );
	}

	// URL
	PSAufbereit(Daten->URL, DruckWert[j++].Wert);

};

ULONG Adress::GetRexx(struct RexxMsg *rxmsg, ULONG Position, STRPTR Start, AdressDaten* UebDaten )
{
	ULONG ReturnWert = 0;
	TEXT Buffer[256];
	TEXT Buffer2[80];
	TEXT ZW_Vorwahl[30];
	ULONG i;

	AdressDaten* ZWDaten;

	TEXT Dummy = 0;
	if(Start == NULL)
		Start = &Dummy;
	
	if( UebDaten )
	{
		ZWDaten = UebDaten;
	}
	else
	{
		ZWDaten = Daten;
		GetElementNr( Position );
	}

	// Vorwahl vorbereiten
	if( (ZWDaten->Land + 1) == MyLaenderPTR->AktDatenPos )
		strcpy(ZW_Vorwahl, MyLaenderPTR->AktDaten.TelInland);
	else
	{
		MyLaenderPTR->GetElementNr( (ZWDaten->Land + 1) );
		strcpy(ZW_Vorwahl, MyLaenderPTR->AktDaten.TelAusland);
		strcat(ZW_Vorwahl, MyLaenderPTR->Daten->TelVonAusland);
	}

	sprintf(Buffer2, "%sADDRESS.STATE", Start );
	sprintf(Buffer, "%lu", ZWDaten->Status);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.CUSTOMER_NUMBER", Start );
	sprintf(Buffer, "%lu", ZWDaten->Kunde);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.EMPLOYEE_NUMBER", Start );
	sprintf(Buffer, "%lu", ZWDaten->Mitarbeiter);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.BRANCH_NUMBER", Start );
	sprintf(Buffer, "%lu", ZWDaten->Niederlassung);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.SUPPLIER_NUMBER", Start );
	sprintf(Buffer, "%lu", ZWDaten->Lieferant);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	// Adresse Format 1 - 3
	for( i = 0; i < 3; i++ )
	{
		sprintf(Buffer2, "%sADDRESS.ADDRESS.%lu", Start, i );
		Anschrift( i, NULL, Buffer, FALSE, ZWDaten);
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );
	}

	sprintf(Buffer2, "%sADDRESS.SALUTATION", Start );
	sprintf(Buffer, "%lu", (ULONG)ZWDaten->Anrede);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.SURNAME", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->Name, strlen(ZWDaten->Name) );

	sprintf(Buffer2, "%sADDRESS.PRENAME", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->Vorname, strlen(ZWDaten->Vorname) );

	sprintf(Buffer2, "%sADDRESS.COMPANY1", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->Firma1, strlen(ZWDaten->Firma1) );

	sprintf(Buffer2, "%sADDRESS.COMPANY2", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->Firma2, strlen(ZWDaten->Firma2) );

	sprintf(Buffer2, "%sADDRESS.STREET", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->Strasse, strlen(ZWDaten->Strasse) );

	sprintf(Buffer2, "%sADDRESS.ZIP", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->PLZ, strlen(ZWDaten->PLZ) );

	sprintf(Buffer2, "%sADDRESS.CITY", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->Ort, strlen(ZWDaten->Ort) );

	sprintf(Buffer2, "%sADDRESS.COUNTRY_NUMBER", Start );
	sprintf(Buffer, "%lu", (ULONG)ZWDaten->Land);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.STATE_NUMBER", Start );
	sprintf(Buffer, "%lu", (ULONG)ZWDaten->Bundesland);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.PHONE", Start);
	if( *ZWDaten->Telefon )
	{
		strcpy( Buffer, ZW_Vorwahl );
		strcat( Buffer, ZWDaten->Telefon );
	}
	else
		*Buffer = 0;
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.FAX", Start);
	if( *ZWDaten->Fax )
	{
		strcpy( Buffer, ZW_Vorwahl );
		strcat( Buffer, ZWDaten->Fax );
	}
	else
		*Buffer = 0;
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.EDI", Start);
	if( *ZWDaten->DFUE )
	{
		strcpy( Buffer, ZW_Vorwahl );
		strcat( Buffer, ZWDaten->DFUE );
	}
	else
		*Buffer = 0;
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.PHONE_PRIVATE", Start);
	if( *ZWDaten->TelefonPrivat )
	{
		strcpy( Buffer, ZW_Vorwahl );
		strcat( Buffer, ZWDaten->TelefonPrivat );
	}
	else
		*Buffer = 0;
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.PHONE_MOBILE", Start);
	if( *ZWDaten->TelefonMobil )
	{
		strcpy( Buffer, ZW_Vorwahl );
		strcat( Buffer, ZWDaten->TelefonMobil );
	}
	else
		*Buffer = 0;
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.EMAIL.0", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->EMail[0], strlen(ZWDaten->EMail[0]) );

	sprintf(Buffer2, "%sADDRESS.EMAIL.1", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->EMail[1], strlen(ZWDaten->EMail[1]) );

	sprintf(Buffer2, "%sADDRESS.EMAIL.2", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->EMail[2], strlen(ZWDaten->EMail[2]) );

	sprintf(Buffer2, "%sADDRESS.ADDITIONAL_TEXT", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->Kommentar, strlen(ZWDaten->Kommentar) );

	sprintf(Buffer2, "%sADDRESS.BANK_CODE_NUMBER", Start );
	sprintf(Buffer, "%lu", (ULONG)ZWDaten->BLZ);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.BANK_NAME", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->Bankbezeich, strlen(ZWDaten->Bankbezeich) );

	sprintf(Buffer2, "%sADDRESS.BANK_SHORT", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->Bankkurz, strlen(ZWDaten->Bankkurz) );

	sprintf(Buffer2, "%sADDRESS.ACCOUNT", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->Kontonummer, strlen(ZWDaten->Kontonummer) );

	sprintf(Buffer2, "%sADDRESS.BIRTHDAY", Start );
	MyLocalePTR->FormatDateC( Buffer, &ZWDaten->Geburtstag, "%Y%m%d");
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.RECEPTION_DATE", Start );
	MyLocalePTR->FormatDateC( Buffer, &ZWDaten->Aufnahmedatum, "%Y%m%d");
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sADDRESS.FAMILY_STATUS", Start );
	sprintf(Buffer, "%lu", (ULONG)ZWDaten->Familienstand);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	// URL für Homepage-Angaben (V1.06)
	sprintf(Buffer2, "%sADDRESS.URL", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->URL, strlen(ZWDaten->URL) );


	if( ReturnWert > 0 )
		ReturnWert = 2;
	return ReturnWert;
};

ULONG Adress::SetRexx(struct RexxMsg *rxmsg, ULONG Position)
{
	ULONG ReturnWert = 0;
	STRPTR Buffer = NULL;
	TEXT ZW_Vorwahl[30];
	ULONG Vorwahllaenge;

	GetElementNr( Position );

	// Vorwahl vorbereiten
	if( (Daten->Land + 1) == MyLaenderPTR->AktDatenPos )
		strcpy(ZW_Vorwahl, MyLaenderPTR->AktDaten.TelInland);
	else
	{
		MyLaenderPTR->GetElementNr( (Daten->Land + 1) );
		strcpy(ZW_Vorwahl, MyLaenderPTR->AktDaten.TelAusland);
		strcat(ZW_Vorwahl, MyLaenderPTR->Daten->TelVonAusland);
	}
	Vorwahllaenge = strlen( ZW_Vorwahl );

	Daten->Anrede					= MyARexx.GetRexxLong("ADDRESS.SALUTATION", 0, 5);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.SURNAME", (UBYTE **)&Buffer );
	strncpy( Daten->Name, Buffer, 19);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.PRENAME", (UBYTE **)&Buffer );
	strncpy( Daten->Vorname, Buffer, 19);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.COMPANY1", (UBYTE **)&Buffer );
	strncpy( Daten->Firma1, Buffer, 39);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.COMPANY2", (UBYTE **)&Buffer );
	strncpy( Daten->Firma2, Buffer, 39);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.STREET", (UBYTE **)&Buffer );
	strncpy( Daten->Strasse, Buffer, 39);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.ZIP", (UBYTE **)&Buffer );
	strncpy( Daten->PLZ, Buffer, 5);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.CITY", (UBYTE **)&Buffer );
	strncpy( Daten->Ort, Buffer, 29);

	Daten->Land						= MyARexx.GetRexxLong("ADDRESS.COUNTRY_NUMBER", 0, (MyLaenderPTR->ElementeVorhanden() - 1));

	Daten->Bundesland				= MyARexx.GetRexxLong("ADDRESS.STATE_NUMBER", 0, 63);
	if( Daten->Bundesland > 0 )
		MyLaenderPTR->GetElementNr( (Daten->Land + 1) );
	if( *MyLaenderPTR->Daten->Bundesland[Daten->Bundesland] == 0 )
		Daten->Bundesland			= 0;

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.PHONE", (UBYTE **)&Buffer );
	if( strncmp(Buffer, ZW_Vorwahl, Vorwahllaenge) == 0 )
		strncpy( Daten->Telefon, &Buffer[Vorwahllaenge], 19);
	else
		strncpy( Daten->Telefon, Buffer, 19);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.FAX", (UBYTE **)&Buffer );
	if( strncmp(Buffer, ZW_Vorwahl, Vorwahllaenge) == 0 )
		strncpy( Daten->Fax, &Buffer[Vorwahllaenge], 19);
	else
		strncpy( Daten->Fax, Buffer, 19);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.EDI", (UBYTE **)&Buffer );
	if( strncmp(Buffer, ZW_Vorwahl, Vorwahllaenge) == 0 )
		strncpy( Daten->DFUE, &Buffer[Vorwahllaenge], 19);
	else
		strncpy( Daten->DFUE, Buffer, 19);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.PHONE_PRIVATE", (UBYTE **)&Buffer );
	if( strncmp(Buffer, ZW_Vorwahl, Vorwahllaenge) == 0 )
		strncpy( Daten->TelefonPrivat, &Buffer[Vorwahllaenge], 19);
	else
		strncpy( Daten->TelefonPrivat, Buffer, 19);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.PHONE_MOBILE", (UBYTE **)&Buffer );
	if( strncmp(Buffer, ZW_Vorwahl, Vorwahllaenge) == 0 )
		strncpy( Daten->TelefonMobil, &Buffer[Vorwahllaenge], 19);
	else
		strncpy( Daten->TelefonMobil, Buffer, 19);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.EMAIL.0", (UBYTE **)&Buffer );
	strncpy( Daten->EMail[0], Buffer, 59);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.EMAIL.1", (UBYTE **)&Buffer );
	strncpy( Daten->EMail[1], Buffer, 59);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.EMAIL.2", (UBYTE **)&Buffer );
	strncpy( Daten->EMail[2], Buffer, 59);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.ADDITIONAL_TEXT", (UBYTE **)&Buffer );
	strncpy( Daten->Kommentar, Buffer, 255 );

	Daten->BLZ					= MyARexx.GetRexxLong("ADDRESS.BANK_CODE_NUMBER", 0, LONG_MAX);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.BANK_NAME", (UBYTE **)&Buffer );
	strncpy( Daten->Bankbezeich, Buffer, 29);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.BANK_SHORT", (UBYTE **)&Buffer );
	strncpy( Daten->Bankkurz, Buffer, 14);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.ACCOUNT", (UBYTE **)&Buffer );
	strncpy( Daten->Kontonummer, Buffer, 14);

	Daten->Geburtstag				= MyARexx.RexxDatum( "ADDRESS.BIRTHDAY" );

	Daten->Aufnahmedatum			= MyARexx.RexxDatum( "ADDRESS.RECEPTION_DATE" );

	Daten->Familienstand			= MyARexx.GetRexxLong("ADDRESS.FAMILY_STATUS", 0, 3);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "ADDRESS.URL", (UBYTE **)&Buffer );
	strncpy( Daten->URL, Buffer, 49);


	UpDateElement();

	if( ReturnWert > 0 )
		ReturnWert = 2;
	return ReturnWert;
};


Kunden::Kunden(STRPTR Dateiname, STRPTR Datenbankbez, UWORD User ) : DataBase( Dateiname, Datenbankbez, User, sizeof(KundenDaten), 68 )
{
	ULONG i;

	Daten = (KundenDaten *)UserData;

	Such_DB_Anzahl	= MyAdressPTR->Such_DB_Anzahl + 13;
	Such_DB_Feld	= new void*[Such_DB_Anzahl];
	Such_DB_Typ		= new UBYTE[Such_DB_Anzahl];
	Such_DB_CS		= new STRPTR[Such_DB_Anzahl];

	for(i = 0; i < MyAdressPTR->Such_DB_Anzahl; i++)
	{
		Such_DB_Feld[i]	= MyAdressPTR->Such_DB_Feld[i];
		Such_DB_Typ[i]		= MyAdressPTR->Such_DB_Typ[i];
		Such_DB_CS[i]		= MyAdressPTR->Such_DB_CS[i];
	}

	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl]		= (void *)Daten->KundenNr;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl]		= 0;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+1]	= (void *)&Daten->Kontostand;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+1]	= 11;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+1]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+2]	= (void *)&Daten->KreditLimit;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+2]	= 11;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+2]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+3]	= (void *)&Daten->Aufnahmedatum;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+3]	= 2;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+3]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+4]	= (void *)&Daten->Waehrung_KZ;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+4]	= 5;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+4]		= MyPrefsPTR->CycleWaehrung;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+5]	= (void *)&Daten->Preissystem;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+5]	= 5;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+5]		= AppStrings[MSG_PreisSys];
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+6]	= (void *)&Daten->MWStBefreit;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+6]	= 4;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+6]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+7]	= (void *)&Daten->ZuAbNummer;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+7]	= 5;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+7]		= MyPrefsPTR->CycleZuAb;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+8]	= (void *)&Daten->ZuAbWert;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+8]	= 11;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+8]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+9]	= (void *)&Daten->Versandart;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+9]	= 7;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+9]		= MyVersandPTR->CycleVersand;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+10]	= (void *)Daten->ILN;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+10]	= 0;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+10]	= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+11]	= (void *)&Daten->KundKat[0];
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+11]	= 5;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+11]	= MyPrefsPTR->CycleKundKat;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+12]	= (void *)Daten->Kommentar;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+12]	= 0;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+12]	= NULL;

	Such_DB_Felder_Laenge = strlen( AppStrings[MSG_Such_Adr_Dummy] ) + 1 +
									strlen( AppStrings[MSG_Such_Adr_AdresseA] ) +
									strlen( AppStrings[MSG_Such_Adr_AdresseB] ) +
									strlen( AppStrings[MSG_Such_Adr_Kunden] );
	Such_DB_Felder_String = new TEXT[Such_DB_Felder_Laenge];

	strcpy( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_Dummy] );
	strcat( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_AdresseA] );
	strcat( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_AdresseB] );
	strcat( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_Kunden] );

	Such_DB_Nr		= 1;

	struct DruWert KundenDruWert[] =
	{
		{"AdressenNr",				"(", NULL, 16, ")", FALSE},
		{"KundenNr2",				"(", NULL, 32, ")", FALSE},
		{"WaehrungKunde",			"", NULL, 4, "", FALSE},
		{"WaehrungKSymbol",		"(", NULL, 8, ")", FALSE},
		{"KontostandGef",			"", NULL, 8, "", FALSE},
		{"Kontostand",				"[", NULL, 80, "]", FALSE},
		{"ZuAbNr",					"", NULL, 8, "", FALSE},
		{"ZuAbWert",				"[", NULL, 80, "]", FALSE},
		{"Kundeseit",				"[", NULL, 80, "]", FALSE},
		{"KreditLimit",			"[", NULL, 80, "]", FALSE},
		{"Preissystem",			"", NULL, 4, "", FALSE},
		{"MWStBefreit",			"", NULL, 8, "", FALSE},
		{"ZuAbBezeich",			"(", NULL, 80, ")", FALSE},
		{"ZuAbTyp",					"", NULL, 8, "", FALSE},
		{"Kommentar",				"[", NULL, 360, "]", FALSE},
		{"KundenILN",				"(", NULL, 20, ")", FALSE},
		{"Kathegorie",				"[", NULL, 120, "]", FALSE},
		{"",							"",  NULL, 0, "", FALSE}
	};

	DruckWertInit( KundenDruWert );

	MerkAdress = NULL;
};

void Kunden::Initialisiere( STRPTR InitDaten )
{
	DataBase::Initialisiere( InitDaten );

	MyLocalePTR->AktDateTime(&((KundenDaten *)InitDaten)->Aufnahmedatum);
	((KundenDaten *)InitDaten)->LetzteBestellung.ds_Days		= 0;
	((KundenDaten *)InitDaten)->LetzteBestellung.ds_Minute	= -1;
	((KundenDaten *)InitDaten)->LetzteBestellung.ds_Tick		= -1;
	((KundenDaten *)InitDaten)->KreditLimit						= MyPrefsPTR->Daten->KreditLimit;
	((KundenDaten *)InitDaten)->Waehrung_KZ						= MyPrefsPTR->Daten->Waehrung_KZ;
	((KundenDaten *)InitDaten)->Adresse								= MyAdressPTR->AktElementNr;
};

void Kunden::UpdateSatz( STRPTR AlteVersion )
{
	Daten = (KundenDaten *)UserData;

	if( (AlteVersion[1] == '.') ||
		 (strncmp(AlteVersion, " 1.02", 5) < 0) )
	{
		if( Daten->ZuAbWert > 0.0 )
			Daten->ZuAbNummer = 1;
		else
			Daten->ZuAbNummer = 0;
	}
};

BOOL Kunden::SuchVergleich( DataBaseSearch* SuchKlasse )
{
	BOOL Returnwert = FALSE;

	if( SuchKlasse->DatenbankfeldNr < MyAdressPTR->Such_DB_Anzahl )
	{
		if( Daten->Adresse > 0)
			MyAdressPTR->GetElementNr( Daten->Adresse );
		Returnwert = MyAdressPTR->SuchVergleich( SuchKlasse );
	}
	else
	{
		switch( SuchKlasse->DatenbankfeldNr - MyAdressPTR->Such_DB_Anzahl )
		{
			case 11:
				{
					for( ULONG i = 0; (i < 3) && !Returnwert; i++ )
					{
						Returnwert = SuchKlasse->Vergleich( (void *)&Daten->KundKat[i] );
					}
				}
				break;
			default:
				Returnwert = SuchKlasse->Vergleich();
				break;
		}
	}
	return Returnwert;
};

void Kunden::SuchListeAnhaengen(ListenClass* SuchListe)
{
	char TextWert[1024];

	if( Daten->Adresse > 0)
		MyAdressPTR->GetElementNr( Daten->Adresse );

	sprintf( (char *)TextWert, "%lu; %s; %s; %s; %s; %s; %s; %s; %s; %s",
																				AktElementNr,
																				Daten->KundenNr,
																				MyAdressPTR->Daten->Firma1,
																				MyAdressPTR->Daten->Firma2,
																				MyAdressPTR->Daten->Vorname,
																				MyAdressPTR->Daten->Name,
																				MyAdressPTR->Daten->Strasse,
																				MyAdressPTR->Daten->PLZ,
																				MyAdressPTR->Daten->Ort,
																				MyLaenderPTR->LaenderListe->SucheNode(MyAdressPTR->Daten->Land));
	TextWert[255] = 0;
	SuchListe->NeuerNode( TextWert );
};

void Kunden::KundenNrErmitteln( STRPTR KundenNr, UBYTE Typ, ULONG LfdNr, KundenDaten* KundDat )
{
	if( KundDat == NULL )
		KundDat = Daten;

	switch( Typ )
	{
		case 1:	// 
			strcpy( KundenNr, KundDat->KundenNr );
			break;
		default:	// laufende Kundennummer
			sprintf( (char *)KundenNr, "%lu", LfdNr );
			break;
	}
};

BOOL Kunden::KundenLesen( STRPTR KundenText, UBYTE Typ )
{
	BOOL ReturnWert = FALSE;
	LONG LongWert;
	ULONG i;
	ULONG j = ElementeVorhanden();

	if( KundenText[0] != 0 )
	{
		switch( Typ )
		{
			case 1:	// Kundennummer 2
				GetFirstElement();
				for( i = 0; i < j; i++ )
				{
					if( strcmp( KundenText, Daten->KundenNr ) == 0 )
					{
						ReturnWert = TRUE;
						j = AktElementNr;
					}
					else
						GetNextElement();
				}
				break;
			default:	// laufende Kundennummer
				LongWert = atol( KundenText );
				if( LongWert < 1 )
					i = 0;
				else if( LongWert > j )
					i = j;
				else
					i = LongWert;
				if( i == 0 )
				{
					KundenText[0] = '0';
					KundenText[1] = 0;
				}
				else
				{
					GetElementNr( i );
					ReturnWert = TRUE;
					sprintf( (char *)KundenText, "%lu", AktElementNr );
				}
				break;
		}

	}

	return ReturnWert;
};

void Kunden::UpDateElement()
{
	if( Daten->Status == 0xffff )
		return;

	DOUBLE ZWDouble;

	AltDaten				= (KundenDaten *)UnDoBuffer[UnDoUsed];

	if( Daten->ZuAbNummer	> 0 &&
		 (Daten->ZuAbNummer	!= AltDaten->ZuAbNummer ||
		  Daten->ZuAbWert		!= AltDaten->ZuAbWert) )
	{
		ZWDouble		= MyPrefsPTR->WaehrungUmrechnen(	MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel],
																	MyPrefsPTR->Daten->ZuAb_Limit_Von[(Daten->ZuAbNummer - 1)],
																	MyPrefsPTR->Daten->Waehrung_KZ,
																	Daten->Waehrung_KZ,
																	MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel] );
		if( Daten->ZuAbWert		< ZWDouble )
			Daten->ZuAbWert		= ZWDouble;
		else
		{
			ZWDouble	= MyPrefsPTR->WaehrungUmrechnen(	MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel],
																	MyPrefsPTR->Daten->ZuAb_Limit_Bis[(Daten->ZuAbNummer - 1)],
																	MyPrefsPTR->Daten->Waehrung_KZ,
																	Daten->Waehrung_KZ,
																	MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel] );
			if( Daten->ZuAbWert	> ZWDouble )
				Daten->ZuAbWert	= ZWDouble;
		}
	}

	DataBase::UpDateElement();
};


void Kunden::PrintString( ofstream* os, STRPTR start, KundenDaten* UebDaten, AdressDaten* UebAdress )
{
	MerkAdress = UebAdress;
	if( UebDaten )
		Daten = UebDaten;
	DataBase::PrintString( os, start );
	Daten = (KundenDaten *)UserData;
	MerkAdress = NULL;
};

void Kunden::PrintTabelle( ofstream* os, UBYTE Typ, ULONG von, ULONG bis, DataBaseSearch* Vergleichsfunktion, UWORD* Verknuepf, KundenDaten* UebDaten, AdressDaten* UebAdress )
{
	MerkAdress = UebAdress;
	if( UebDaten )
	{
		Daten = UebDaten;
		DataBase::PrintTabelle( os, Typ, von, 0, Vergleichsfunktion, Verknuepf );
		Daten = (KundenDaten *)UserData;
	}
	else
		DataBase::PrintTabelle( os, Typ, von, bis, Vergleichsfunktion, Verknuepf );
	MerkAdress = NULL;
};

void Kunden::PrintVorbereiten( ofstream* os, UBYTE Art )
{
	TEXT Zwischenstring[256];
	STRPTR ZWString;
	ULONG i, j = 0;

	if( MerkAdress )
		MyAdressPTR->Daten = MerkAdress;
	else
		MyAdressPTR->GetElementNr( Daten->Adresse );
	switch( Art )
	{
		case '1':
			MyAdressPTR->DataBase::PrintString( os, Startstring );
			break;
		case '2':
		case '3':
			MyAdressPTR->DataBase::PrintTabelle( os, Art, Daten->Adresse, 0, NULL, NULL );
		 	break;
	}
	if( MerkAdress )
		MyAdressPTR->Daten = (AdressDaten *)MyAdressPTR->UserData;

	// Adressennummer
	if( MyPrefsPTR->Daten->Nr_Laenge )
	{
		sprintf(DruckWert[j++].Wert, "%0*lu", MyPrefsPTR->Daten->Nr_Laenge, Daten->Adresse);
	}
	else
		sprintf(DruckWert[j++].Wert, "%lu", Daten->Adresse);

	// Kundennumer2
	PSAufbereit(Daten->KundenNr, DruckWert[j++].Wert);

	// Waehrungskennzeichen Kunden
	DruckWert[j].Wert[0]		= (TEXT)'0' + (TEXT)Daten->Waehrung_KZ;
	DruckWert[j++].Wert[1]	= 0;

	// Waehrungssymbol Kunde
	PSAufbereit(MyPrefsPTR->WaehrungPTR[Daten->Waehrung_KZ], DruckWert[j++].Wert);

	// Kontostand
	if( Daten->Kontostand == 0 )
		strcpy( DruckWert[j++].Wert, "false" );
	else
		strcpy( DruckWert[j++].Wert, "true" );

	PSDruckBetrag( DruckWert[j++].Wert, MyPrefsPTR->WaehrungPTR,
						MyPrefsPTR->WaehrungUmrechnen( 0, Daten->Kontostand, Daten->Waehrung_KZ, 1, 0),
						MyPrefsPTR->WaehrungUmrechnen( 0, Daten->Kontostand, Daten->Waehrung_KZ, 3, 0) );

	// ZuAbNr
	sprintf(DruckWert[j++].Wert, "%lu", Daten->ZuAbNummer);
	
	// ZuAbWert
	if( Daten->ZuAbNummer )
	{
		switch( MyPrefsPTR->Daten->ZuAbTyp[(Daten->ZuAbNummer - 1)] )
		{
			case 0:
			case 5:
				MyLocalePTR->FormatNumber( DruckWert[j].Wert, Daten->ZuAbWert, MyPrefsPTR->Daten->Nachkomma_Prozent);
				ZWString = PSAufbereit( DruckWert[j].Wert, Zwischenstring );
				sprintf( DruckWert[j++].Wert, "(%s)(%s)", Zwischenstring, Zwischenstring );
				break;
			default:
				PSDruckBetrag( DruckWert[j++].Wert, MyPrefsPTR->WaehrungPTR,
									MyPrefsPTR->WaehrungUmrechnen(MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel],
																			Daten->ZuAbWert, Daten->Waehrung_KZ, 0,
																			MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel]),
									MyPrefsPTR->WaehrungUmrechnen(MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel],
																			Daten->ZuAbWert, Daten->Waehrung_KZ, 1,
																			MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel]),
									MyPrefsPTR->WaehrungUmrechnen(MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel],
																			Daten->ZuAbWert, Daten->Waehrung_KZ, 2,
																			MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel]),
									MyPrefsPTR->WaehrungUmrechnen(MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel],
																			Daten->ZuAbWert, Daten->Waehrung_KZ, 3,
																			MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel]) );
				break;
		}
	}
	else
		DruckWert[j++].Wert[0] = 0;

	// Kunde seit
	PSDruckDatum( DruckWert[j++].Wert, &Daten->Aufnahmedatum );
	
	// Kreditlimit
	PSDruckBetrag( DruckWert[j++].Wert, MyPrefsPTR->WaehrungPTR,
						MyPrefsPTR->WaehrungUmrechnen( 0, Daten->KreditLimit, Daten->Waehrung_KZ, 1, 0),
						MyPrefsPTR->WaehrungUmrechnen( 0, Daten->KreditLimit, Daten->Waehrung_KZ, 3, 0) );

	// Preissystem des Kunden
	DruckWert[j].Wert[0]		= (TEXT)'0' + (TEXT)Daten->Preissystem;
	DruckWert[j++].Wert[1]	= 0;

	// Mehrwertsteuerbefreit
	if( Daten->MWStBefreit )
		strcpy( DruckWert[j++].Wert, "true" );
	else
		strcpy( DruckWert[j++].Wert, "false" );

	// ZuAbBezeichnung
	// ZuAbTyp
	if( Daten->ZuAbNummer )
	{
		PSAufbereit(MyPrefsPTR->Daten->ZuAbBezeich[(Daten->ZuAbNummer - 1)], DruckWert[j++].Wert);
		sprintf(DruckWert[j++].Wert, "%lu", MyPrefsPTR->Daten->ZuAbTyp[(Daten->ZuAbNummer - 1)] );
	}
	else
	{
		DruckWert[j++].Wert[0]	= 0;
		DruckWert[j].Wert[0]		= '0';
		DruckWert[j++].Wert[1]	= 0;
	}

	// Kommentar/Zusatztext		(V1.05)
	PSAufbereitMZ(Daten->Kommentar, DruckWert[j++].Wert);

	// ILN							(V1.06)
	PSAufbereit(Daten->ILN, DruckWert[j++].Wert);

	// Kundkathegorie				(V1.06)
	ZWString = DruckWert[j++].Wert;
	for(i = 0; i < 3; i++)
	{
		*ZWString++ = '(';
		if( Daten->KundKat[i] > 0 )
			ZWString = PSAufbereit(MyPrefsPTR->Daten->KundKat[(Daten->KundKat[i] - 1)], ZWString);
		*ZWString++ = ')';
	}
	*ZWString++ = '\0';
};

ULONG Kunden::GetRexx(struct RexxMsg *rxmsg, ULONG Position, STRPTR Start, KundenDaten* UebDaten, AdressDaten* UebDatenAdr )
{
	ULONG ReturnWert = 0, i;
	TEXT Buffer[80];
	TEXT Buffer2[80];

	KundenDaten* ZWDaten;

	TEXT Dummy = 0;
	if(Start == NULL)
		Start = &Dummy;
	
	if( UebDaten )
	{
		ZWDaten = UebDaten;
	}
	else
	{
		ZWDaten = Daten;
		GetElementNr( Position );
	}

	strcpy( Buffer2, Start );
	strcat( Buffer2, "CUSTOMER." );
	MyAdressPTR->GetRexx( rxmsg, ZWDaten->Adresse, Buffer2, UebDatenAdr );

	sprintf(Buffer2, "%sCUSTOMER.STATE", Start );
	sprintf(Buffer, "%lu", ZWDaten->Status);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sCUSTOMER.ADDRESS_NUMBER", Start );
	sprintf(Buffer, "%lu", ZWDaten->Adresse);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sCUSTOMER.CLIENT_CODE", Start );
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->KundenNr, strlen(ZWDaten->KundenNr) );

	sprintf(Buffer2, "%sCUSTOMER.ACCOUNT_MONEY", Start );
	ReturnWert += MyARexx.RexxBetrag2( Buffer2, ZWDaten->Kontostand, ZWDaten->Waehrung_KZ );

	sprintf(Buffer2, "%sCUSTOMER.ADD_RED_VALUE", Start );
	if( ZWDaten->ZuAbNummer > 0 &&
		(MyPrefsPTR->Daten->ZuAbTyp[(ZWDaten->ZuAbNummer - 1)] == 0 ||
		 MyPrefsPTR->Daten->ZuAbTyp[(ZWDaten->ZuAbNummer - 1)] == 5) )
	{
		ReturnWert += MyARexx.RexxBetrag4( Buffer2, ZWDaten->ZuAbWert, ZWDaten->Waehrung_KZ, MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel], MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel] );
	}
	else
	{
		ReturnWert += MyARexx.RexxBetrag( Buffer2, ZWDaten->ZuAbWert, ZWDaten->ZuAbWert, ZWDaten->ZuAbWert, ZWDaten->ZuAbWert );
	}

	sprintf(Buffer2, "%sCUSTOMER.ADD_RED_USED", Start );
	sprintf(Buffer, "%lu", (ULONG)ZWDaten->ZuAbNummer);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sCUSTOMER.RECEPTION_DATE", Start );
	MyLocalePTR->FormatDateC( Buffer, &ZWDaten->Aufnahmedatum, "%Y%m%d");
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sCUSTOMER.CURRENCY_USED", Start );
	sprintf(Buffer, "%lu", ZWDaten->Waehrung_KZ);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sCUSTOMER.CREDITLIMIT", Start );
	ReturnWert += MyARexx.RexxBetrag2( Buffer2, ZWDaten->KreditLimit, ZWDaten->Waehrung_KZ );

	sprintf(Buffer2, "%sCUSTOMER.PRICE_SYSTEM", Start );
	Buffer[0] = '0' + ZWDaten->Preissystem;
	Buffer[1] = 0;
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sCUSTOMER.VALUE_FREE", Start );
	if( ZWDaten->MWStBefreit )
		Buffer[0] = 'Y';
	else
		Buffer[0] = 'N';
	Buffer[1] = 0;
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	// Versandart
	sprintf(Buffer2, "%sCUSTOMER.NUMBER_DISPATCH", Start );
	sprintf(Buffer, "%lu", ZWDaten->Versandart);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	// Zusatztext/Bemerkung				V1.05
	sprintf(Buffer2, "%sCUSTOMER.ADDITIONAL_TEXT", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->Kommentar, strlen(ZWDaten->Kommentar) );

	// ILN									V1.06
	sprintf(Buffer2, "%sCUSTOMER.ILN", Start);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->ILN, strlen(ZWDaten->ILN) );

	// Kundenkategorien					V1.06
	for( i = 0; i < 3; i++ )
	{
		sprintf(Buffer2, "%sCUSTOMER.CATEGORY.%lu", Start, i );
		sprintf(Buffer, "%u", ZWDaten->KundKat[i]);
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );
	}


	if( ReturnWert > 0 )
		ReturnWert = 2;
	return ReturnWert;
};

ULONG Kunden::SetRexx(struct RexxMsg *rxmsg, ULONG Position)
{
	ULONG ReturnWert = 0;
	STRPTR Buffer = NULL;
	TEXT Buffer2[80];

	GetElementNr( Position );

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "CUSTOMER.CLIENT_CODE", (UBYTE **)&Buffer );
	strncpy( Daten->KundenNr, Buffer, 19);

	Daten->Waehrung_KZ				= MyARexx.GetRexxLong("CUSTOMER.CURRENCY_USED", 0, 3);

	sprintf(Buffer2, "CUSTOMER.ACCOUNT_MONEY.%lu", (ULONG)(Daten->Waehrung_KZ / 2) );
	ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
	Daten->Kontostand					= atof( Buffer );

	Daten->ZuAbNummer					= MyARexx.GetRexxLong("CUSTOMER.ADD_RED_USED", 0, MyPrefsPTR->Daten->ZuAbBelegt);

	sprintf(Buffer2, "CUSTOMER.ADD_RED_VALUE.%lu", (ULONG)(Daten->Waehrung_KZ / 2) );
	ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
	Daten->ZuAbWert					= atof( Buffer );

	Daten->Aufnahmedatum				= MyARexx.RexxDatum( "CUSTOMER.RECEPTION_DATE" );

	sprintf(Buffer2, "CUSTOMER.CREDITLIMIT.%lu", (ULONG)(Daten->Waehrung_KZ / 2) );
	ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
	Daten->KreditLimit				= atof( Buffer );

	Daten->Preissystem				= MyARexx.GetRexxLong("CUSTOMER.PRICE_SYSTEM", 0, 3);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "CUSTOMER.VALUE_FREE", (UBYTE **)&Buffer );
	Daten->MWStBefreit				= (Buffer[0] == 'Y' || Buffer[0] == 'y');

	// Versandart							(V1.03)
	Daten->Versandart					= MyARexx.GetRexxLong("CUSTOMER.NUMBER_DISPATCH", 0, MyVersandPTR->ElementeVorhanden() );

	// Zusatztext/Bemerkung				(V1.05)
	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "CUSTOMER.ADDITIONAL_TEXT", (UBYTE **)&Buffer );
	strncpy( Daten->Kommentar, Buffer, 255 );

	// ILN									(V1.06)
	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "CUSTOMER.ILN", (UBYTE **)&Buffer );
	strncpy( Daten->ILN, Buffer, 13 );

	// Kundenkategorien					(V1.06)
	Daten->KundKat[0]		= MyARexx.GetRexxLong("CUSTOMER.CATEGORY.0", 0, MyPrefsPTR->Daten->KundKat_Belegt );
	Daten->KundKat[1]		= MyARexx.GetRexxLong("CUSTOMER.CATEGORY.1", 0, MyPrefsPTR->Daten->KundKat_Belegt );
	Daten->KundKat[2]		= MyARexx.GetRexxLong("CUSTOMER.CATEGORY.2", 0, MyPrefsPTR->Daten->KundKat_Belegt );


	UpDateElement();

	if( ReturnWert > 0 )
		ReturnWert = 2;
	return ReturnWert;
};

Mitarbeiter::Mitarbeiter(STRPTR Dateiname, STRPTR Datenbankbez, UWORD User ) : DataBase( Dateiname, Datenbankbez, User, sizeof(MitarbeiterDaten), 174 )
{
	ULONG i;
	Daten = (MitarbeiterDaten *)UserData;
	Such_DB_Anzahl	= MyAdressPTR->Such_DB_Anzahl + 14;
	Such_DB_Feld	= new void*[Such_DB_Anzahl];
	Such_DB_Typ		= new UBYTE[Such_DB_Anzahl];
	Such_DB_CS		= new STRPTR[Such_DB_Anzahl];

	for( i = 0; i < MyAdressPTR->Such_DB_Anzahl; i++ )
	{
		Such_DB_Feld[i]	= MyAdressPTR->Such_DB_Feld[i];
		Such_DB_Typ[i]		= MyAdressPTR->Such_DB_Typ[i];
		Such_DB_CS[i]		= MyAdressPTR->Such_DB_CS[i];
	}

	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl]		= (void *)&Daten->Niederlassung;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl]		= 7;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+1]	= (void *)Daten->PersonalNr;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+1]	= 0;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+1]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+2]	= (void *)&Daten->Eintrittsdatum;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+2]	= 2;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+2]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+3]	= (void *)&Daten->Austrittsdatum;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+3]	= 2;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+3]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+4]	= (void *)Daten->Taetigkeit;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+4]	= 0;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+4]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+5]	= (void *)&Daten->Tarifgruppe;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+5]	= 7;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+5]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+6]	= (void *)&Daten->Steuerklasse;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+6]	= 5;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+6]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+7]	= (void *)&Daten->Zusatzverguetung;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+7]	= 11;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+7]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+8]	= (void *)&Daten->AnzKinder;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+8]	= 5;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+8]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+9]	= (void *)&Daten->Jahresurlaub;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+9]	= 11;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+9]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+10]	= (void *)&Daten->AktuellerUrlaub;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+10]	= 11;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+10]	= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+11]	= (void *)&Daten->RestUrlaub;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+11]	= 11;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+11]	= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+12]	= (void *)Daten->User;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+12]	= 0;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+12]	= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+13]	= (void *)&Daten->Waehrung_KZ;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+13]	= 5;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+13]	= MyPrefsPTR->CycleWaehrung;

	Such_DB_Felder_Laenge = strlen( AppStrings[MSG_Such_Adr_Dummy] ) + 1 +
									strlen( AppStrings[MSG_Such_Adr_AdresseA] ) +
									strlen( AppStrings[MSG_Such_Adr_AdresseB] ) +
									strlen( AppStrings[MSG_Such_Adr_Mitarbeiter] );
	Such_DB_Felder_String = new TEXT[Such_DB_Felder_Laenge];

	Such_DB_Nr		= 2;

	strcpy( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_Dummy] );
	strcat( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_AdresseA] );
	strcat( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_AdresseB] );
	strcat( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_Mitarbeiter] );

	struct DruWert MitarbeiterDruWert[] =
	{
		{"AdressenNr",				"(", NULL, 16, ")", FALSE},
		{"MNiederlassungNr",		"(", NULL, 16, ")", FALSE},
		{"PersonalNr",				"(", NULL, 32, ")", FALSE},
		{"Taetigkeit",				"(", NULL, 40, ")", FALSE},
		{"MEintritt",				"[", NULL, 80, "]", FALSE},
		{"MAustritt",				"[", NULL, 80, "]", FALSE},
		{"Tarifgruppe",			"(", NULL, 16, ")", FALSE},
		{"WaehrungMA",				"", NULL, 4, "", FALSE},
		{"WaehrungMASymbol",		"(", NULL, 8, ")", FALSE},
		{"ZusatzverguetungGef",	"", NULL, 8, "", FALSE},
		{"Zusatzverguetung",		"[", NULL, 120, "]", FALSE},
		{"AnzahlKinder",			"(", NULL, 16, ")", FALSE},
		{"Steuerklasse",			"(", NULL, 16, ")", FALSE},
		{"Jahresurlaub",			"(", NULL, 40, ")", FALSE},
		{"AktuellerUrlaub",		"(", NULL, 40, ")", FALSE},
		{"RestUrlaub",				"(", NULL, 40, ")", FALSE},
		{"",							"",  NULL, 0, "", FALSE}
	};

	DruckWertInit( MitarbeiterDruWert );

	MerkAdress = NULL;
};

void Mitarbeiter::Initialisiere( STRPTR InitDaten )
{
	DataBase::Initialisiere( InitDaten );

	MyLocalePTR->AktDateTime(&((MitarbeiterDaten *)InitDaten)->Eintrittsdatum);
	strcpy( ((MitarbeiterDaten *)InitDaten)->User, MyAdressPTR->Daten->Name );
	strcpy( ((MitarbeiterDaten *)InitDaten)->Passwort, MyAdressPTR->Daten->Name );
	((MitarbeiterDaten *)InitDaten)->Austrittsdatum.ds_Days		= 0;
	((MitarbeiterDaten *)InitDaten)->Austrittsdatum.ds_Minute	= -1;
	((MitarbeiterDaten *)InitDaten)->Austrittsdatum.ds_Tick		= -1;
	((MitarbeiterDaten *)InitDaten)->Niederlassung					= 1;
	((MitarbeiterDaten *)InitDaten)->Waehrung_KZ						= MyPrefsPTR->Daten->Waehrung_KZ;
	((MitarbeiterDaten *)InitDaten)->Adresse							= MyAdressPTR->AktElementNr;

	if( ElementeVorhanden() == 0 )
	{
		((MitarbeiterDaten *)InitDaten)->Ber_Adressen				= 2;
		((MitarbeiterDaten *)InitDaten)->Ber_Kunden					= 2;
		((MitarbeiterDaten *)InitDaten)->Ber_Lieferanten			= 2;
		((MitarbeiterDaten *)InitDaten)->Ber_Mitarbeiter			= 2;
		((MitarbeiterDaten *)InitDaten)->Ber_Passwort				= 1;
		((MitarbeiterDaten *)InitDaten)->Ber_Niederlassung			= 2;
		((MitarbeiterDaten *)InitDaten)->Ber_ERechnung				= 2;
		((MitarbeiterDaten *)InitDaten)->Ber_ARechnung				= 2;
		((MitarbeiterDaten *)InitDaten)->Ber_Artikel					= 2;
		((MitarbeiterDaten *)InitDaten)->Ber_Laender					= 2;
		((MitarbeiterDaten *)InitDaten)->Ber_Prefs					= 2;
		((MitarbeiterDaten *)InitDaten)->Ber_Inventur				= 2;
		((MitarbeiterDaten *)InitDaten)->Ber_Kontenplan				= 2;
		((MitarbeiterDaten *)InitDaten)->Ber_Buchen					= 2;
	}
};

void Mitarbeiter::UpdateSatz( STRPTR AlteVersion )
{
	Daten = (MitarbeiterDaten *)UserData;

	if( (AlteVersion[1] == '.') ||
		 (strncmp(AlteVersion, " 1.04", 5) < 0) )
	{
		if( AktElementNr == 0 )
		{
			Daten->Ber_Inventur				= 2;
			Daten->Ber_Kontenplan			= 2;
			Daten->Ber_Buchen					= 2;
		}
	}
};

BOOL Mitarbeiter::SuchVergleich( DataBaseSearch* SuchKlasse )
{
	if( SuchKlasse->DatenbankfeldNr < MyAdressPTR->Such_DB_Anzahl )
	{
		if( Daten->Adresse > 0)
			MyAdressPTR->GetElementNr( Daten->Adresse );
		return MyAdressPTR->SuchVergleich( SuchKlasse );
	}
	else
		return SuchKlasse->Vergleich();
};

void Mitarbeiter::SuchListeAnhaengen(ListenClass* SuchListe)
{
	char TextWert[1024];

	if( Daten->Adresse > 0)
		MyAdressPTR->GetElementNr( Daten->Adresse );

	sprintf( (char *)TextWert, "%lu; %s; %s; %s; %s; %s; %s; %s; %s",
																				AktElementNr,
																				MyAdressPTR->Daten->Firma1,
																				MyAdressPTR->Daten->Firma2,
																				MyAdressPTR->Daten->Vorname,
																				MyAdressPTR->Daten->Name,
																				MyAdressPTR->Daten->Strasse,
																				MyAdressPTR->Daten->PLZ,
																				MyAdressPTR->Daten->Ort,
																				MyLaenderPTR->LaenderListe->SucheNode(MyAdressPTR->Daten->Land));
	TextWert[255] = 0;
	SuchListe->NeuerNode( TextWert );
}

void Mitarbeiter::UpDateElement()
{
	DataBase::UpDateElement();
	if( GetUser() == AktElementNr)
		memcpy((void *)&UserDaten, (const void *)Daten, sizeof(MitarbeiterDaten));
}

void Mitarbeiter::UnDo()
{
	DataBase::UnDo();
	if( GetUser() == AktElementNr)
		memcpy((void *)&UserDaten, (const void *)Daten, sizeof(MitarbeiterDaten));
}

void Mitarbeiter::ReDo()
{
	DataBase::ReDo();
	if( GetUser() == AktElementNr)
		memcpy((void *)&UserDaten, (const void *)Daten, sizeof(MitarbeiterDaten));
}

void Mitarbeiter::PrintString( ofstream* os, STRPTR start, MitarbeiterDaten* UebDaten, AdressDaten* UebAdress )
{
	MerkAdress = UebAdress;
	if( UebDaten )
		Daten = UebDaten;
	DataBase::PrintString( os, start );
	Daten = (MitarbeiterDaten *)UserData;
	MerkAdress = NULL;
};

void Mitarbeiter::PrintTabelle( ofstream* os, UBYTE Typ, ULONG von, ULONG bis, DataBaseSearch* Vergleichsfunktion, UWORD* Verknuepf, MitarbeiterDaten* UebDaten, AdressDaten* UebAdress )
{
	MerkAdress = UebAdress;
	if( UebDaten )
	{
		Daten = UebDaten;
		DataBase::PrintTabelle( os, Typ, von, 0, Vergleichsfunktion, Verknuepf );
		Daten = (MitarbeiterDaten *)UserData;
	}
	else
		DataBase::PrintTabelle( os, Typ, von, bis, Vergleichsfunktion, Verknuepf );
	MerkAdress = NULL;
};

void Mitarbeiter::PrintVorbereiten( ofstream* os, UBYTE Art )
{
	TEXT Zwischenstring[256];
	ULONG j = 0;

	if( MerkAdress )
		MyAdressPTR->Daten = MerkAdress;
	else
		MyAdressPTR->GetElementNr( Daten->Adresse );
	switch( Art )
	{
		case '1':
			MyAdressPTR->DataBase::PrintString( os, Startstring );
			break;
		case '2':
		case '3':
			MyAdressPTR->DataBase::PrintTabelle( os, Art, Daten->Adresse, 0, NULL, NULL );
		 	break;
	}
	if( MerkAdress )
		MyAdressPTR->Daten = (AdressDaten *)MyAdressPTR->UserData;

	// Adressennummer
	if( MyPrefsPTR->Daten->Nr_Laenge )
	{
		sprintf(DruckWert[j++].Wert, "%0*lu", MyPrefsPTR->Daten->Nr_Laenge, Daten->Adresse);
	}
	else
		sprintf(DruckWert[j++].Wert, "%lu", Daten->Adresse);

	// Niederlassung
	if( MyPrefsPTR->Daten->Nr_Laenge )
	{
		sprintf(DruckWert[j++].Wert, "%0*lu", MyPrefsPTR->Daten->Nr_Laenge, Daten->Niederlassung);
	}
	else
		sprintf(DruckWert[j++].Wert, "%lu", Daten->Niederlassung);

	// Personalnummer
	PSAufbereit(Daten->PersonalNr, DruckWert[j++].Wert);

	// Tätigkeit
	PSAufbereit(Daten->Taetigkeit, DruckWert[j++].Wert);

	// Eintrittsdatum
	PSDruckDatum( DruckWert[j++].Wert, &Daten->Eintrittsdatum );
	
	// Austrittsdatum
	PSDruckDatum( DruckWert[j++].Wert, &Daten->Austrittsdatum );

	// Tarifgruppe
	sprintf(DruckWert[j++].Wert, "%lu", (ULONG)Daten->Tarifgruppe);

	// Waehrungskennzeichen
	DruckWert[j].Wert[0]		= (TEXT)'0' + (TEXT)Daten->Waehrung_KZ;
	DruckWert[j++].Wert[1]	= 0;

	// Waehrungssymbol
	PSAufbereit(MyPrefsPTR->WaehrungPTR[Daten->Waehrung_KZ], DruckWert[j++].Wert);

	// Zusatzverguetung
	if( Daten->Zusatzverguetung == 0 )
		strcpy(DruckWert[j++].Wert, "false");
	else
		strcpy(DruckWert[j++].Wert, "true");

	PSDruckBetrag( DruckWert[j++].Wert, MyPrefsPTR->WaehrungPTR,
						MyPrefsPTR->WaehrungUmrechnen( 0, Daten->Zusatzverguetung, Daten->Waehrung_KZ, 1, 0),
						MyPrefsPTR->WaehrungUmrechnen( 0, Daten->Zusatzverguetung, Daten->Waehrung_KZ, 3, 0) );

	// AnzahlKinder
	sprintf(DruckWert[j++].Wert, "%lu", (ULONG)Daten->AnzKinder);

	// Steuerklasse
	sprintf(DruckWert[j++].Wert, "%lu", (ULONG)Daten->Steuerklasse);

	// Jahresurlaub
	MyLocalePTR->FormatNumber( Zwischenstring, Daten->Jahresurlaub, MyPrefsPTR->Daten->Nachkomma);
	PSAufbereit(Zwischenstring, DruckWert[j++].Wert);

	// Aktueller Urlaub
	MyLocalePTR->FormatNumber( Zwischenstring, Daten->AktuellerUrlaub, MyPrefsPTR->Daten->Nachkomma);
	PSAufbereit(Zwischenstring, DruckWert[j++].Wert);

	// Resturlaub
	MyLocalePTR->FormatNumber( Zwischenstring, Daten->RestUrlaub, MyPrefsPTR->Daten->Nachkomma);
	PSAufbereit(Zwischenstring, DruckWert[j++].Wert);
};

ULONG Mitarbeiter::GetRexx(struct RexxMsg *rxmsg, ULONG Position, STRPTR Start, MitarbeiterDaten* UebDaten, AdressDaten* UebDatenAdr )
{
	ULONG ReturnWert = 0;
	TEXT Buffer[80];
	TEXT Buffer2[80];

	MitarbeiterDaten* ZWDaten;

	TEXT Dummy = 0;
	if(Start == NULL)
		Start = &Dummy;
	
	if( UebDaten )
	{
		ZWDaten = UebDaten;
	}
	else
	{
		ZWDaten = Daten;
		GetElementNr( Position );
	}

	strcpy( Buffer2, Start );
	strcat( Buffer2, "EMPLOYEE." );
	MyAdressPTR->GetRexx( rxmsg, ZWDaten->Adresse, Buffer2, UebDatenAdr );

	sprintf(Buffer2, "%sEMPLOYEE.STATE", Start );
	sprintf(Buffer, "%lu", ZWDaten->Status);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.ADDRESS_NUMBER", Start );
	sprintf(Buffer, "%lu", ZWDaten->Adresse);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.BRANCHOFFICE_NUMBER", Start );
	sprintf(Buffer, "%lu", ZWDaten->Niederlassung);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.STUFF_NUMBER", Start );
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->PersonalNr, strlen(ZWDaten->PersonalNr) );

	sprintf(Buffer2, "%sEMPLOYEE.OCCUPATION", Start );
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->Taetigkeit, strlen(ZWDaten->Taetigkeit) );

	sprintf(Buffer2, "%sEMPLOYEE.RECEPTION_DATE", Start );
	MyLocalePTR->FormatDateC( Buffer, &ZWDaten->Eintrittsdatum, "%Y%m%d");
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.LEAVE_DATE", Start );
	MyLocalePTR->FormatDateC( Buffer, &ZWDaten->Austrittsdatum, "%Y%m%d");
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.AGREED_SCALE_GROUP", Start );
	sprintf(Buffer, "%lu", ZWDaten->Tarifgruppe);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.EXTRA_SALARY", Start );
	ReturnWert += MyARexx.RexxBetrag2( Buffer2, ZWDaten->Zusatzverguetung, ZWDaten->Waehrung_KZ );

	sprintf(Buffer2, "%sEMPLOYEE.CHILDREN_COUNT", Start );
	sprintf(Buffer, "%lu", ZWDaten->AnzKinder);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.TAX_BRACKET", Start );
	sprintf(Buffer, "%lu", ZWDaten->Steuerklasse);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.HOLLYDAY_YEAR", Start );
	sprintf(Buffer, "%f", ZWDaten->Jahresurlaub);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.HOLLYDAY_ACTUALLY", Start );
	sprintf(Buffer, "%f", ZWDaten->AktuellerUrlaub);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.HOLLYDAY_REST", Start );
	sprintf(Buffer, "%f", ZWDaten->RestUrlaub);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.CURRENCY_USED", Start );
	sprintf(Buffer, "%lu", ZWDaten->Waehrung_KZ);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.RIGHT_ADDRESS", Start );
	sprintf(Buffer, "%lu", ZWDaten->Ber_Adressen);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.RIGHT_CUSTOMER", Start );
	sprintf(Buffer, "%lu", ZWDaten->Ber_Kunden);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.RIGHT_SUPPLIER", Start );
	sprintf(Buffer, "%lu", ZWDaten->Ber_Lieferanten);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.RIGHT_EMPLOYEE", Start );
	sprintf(Buffer, "%lu", ZWDaten->Ber_Mitarbeiter);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.RIGHT_PASSWORD", Start );
	sprintf(Buffer, "%lu", ZWDaten->Ber_Passwort);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.RIGHT_BRANCHOFFICE", Start );
	sprintf(Buffer, "%lu", ZWDaten->Ber_Niederlassung);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.RIGHT_INBILL", Start );
	sprintf(Buffer, "%lu", ZWDaten->Ber_ERechnung);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.RIGHT_OUTBILL", Start );
	sprintf(Buffer, "%lu", ZWDaten->Ber_ARechnung);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.RIGHT_ARTICLE", Start );
	sprintf(Buffer, "%lu", ZWDaten->Ber_Artikel);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.RIGHT_COUNTRY", Start );
	sprintf(Buffer, "%lu", ZWDaten->Ber_Laender);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sEMPLOYEE.RIGHT_PREFS", Start );
	sprintf(Buffer, "%lu", ZWDaten->Ber_Prefs);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	// Inventurberechtigung	(V1.04)
	sprintf(Buffer2, "%sEMPLOYEE.RIGHT_STOCK", Start );
	sprintf(Buffer, "%lu", ZWDaten->Ber_Inventur);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	// Kontenrahmen			(V1.04)
	sprintf(Buffer2, "%sEMPLOYEE.RIGHT_ACCOUNT", Start );
	sprintf(Buffer, "%lu", ZWDaten->Ber_Kontenplan);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	// Buchführung				 (V1.04)
	sprintf(Buffer2, "%sEMPLOYEE.RIGHT_BOOK", Start );
	sprintf(Buffer, "%lu", ZWDaten->Ber_Buchen);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );


	if( ReturnWert > 0 )
		ReturnWert = 2;
	return ReturnWert;
};

ULONG Mitarbeiter::SetRexx(struct RexxMsg *rxmsg, ULONG Position)
{
	ULONG ReturnWert = 0;
	STRPTR Buffer = NULL;
	TEXT Buffer2[80];

	GetElementNr( Position );

	Daten->Niederlassung				= MyARexx.GetRexxLong("EMPLOYEE.BRANCHOFFICE_NUMBER", 0, MyNiederlassungPTR->ElementeVorhanden());

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "EMPLOYEE.STUFF_NUMBER", (UBYTE **)&Buffer );
	strncpy( Daten->PersonalNr, Buffer, 19);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "EMPLOYEE.OCCUPATION", (UBYTE **)&Buffer );
	strncpy( Daten->Taetigkeit, Buffer, 29);

	Daten->Eintrittsdatum			= MyARexx.RexxDatum( "EMPLOYEE.RECEPTION_DATE" );

	Daten->Austrittsdatum			= MyARexx.RexxDatum( "EMPLOYEE.LEAVE_DATE" );

	Daten->Tarifgruppe				= MyARexx.GetRexxLong("EMPLOYEE.AGREED_SCALE_GROUP", 0, LONG_MAX);

	Daten->Waehrung_KZ				= MyARexx.GetRexxLong("EMPLOYEE.CURRENCY_USED", 0, 3);

	sprintf(Buffer2, "EMPLOYEE.EXTRA_SALARY.%lu", (ULONG)(Daten->Waehrung_KZ / 2) );
	ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
	Daten->Zusatzverguetung			= atof( Buffer );

	Daten->AnzKinder					= MyARexx.GetRexxLong("EMPLOYEE.CHILDREN_COUNT", 0, 0xff);
	Daten->Steuerklasse				= MyARexx.GetRexxLong("EMPLOYEE.TAX_BRACKET", 0, 0xff);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "EMPLOYEE.HOLLYDAY_YEAR", (UBYTE **)&Buffer );
	Daten->Jahresurlaub				= atof( Buffer );

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "EMPLOYEE.HOLLYDAY_ACTUALLY", (UBYTE **)&Buffer );
	Daten->AktuellerUrlaub			= atof( Buffer );

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "EMPLOYEE.HOLLYDAY_REST", (UBYTE **)&Buffer );
	Daten->RestUrlaub					= atof( Buffer );

	Daten->Ber_Adressen				= MyARexx.GetRexxLong("EMPLOYEE.RIGHT_ADDRESS",			0, UserDaten.Ber_Adressen);
	Daten->Ber_Kunden					= MyARexx.GetRexxLong("EMPLOYEE.RIGHT_CUSTOMER",		0, UserDaten.Ber_Kunden);
	Daten->Ber_Lieferanten			= MyARexx.GetRexxLong("EMPLOYEE.RIGHT_SUPPLIER",		0, UserDaten.Ber_Lieferanten);
	Daten->Ber_Mitarbeiter			= MyARexx.GetRexxLong("EMPLOYEE.RIGHT_EMPLOYEE",		0, UserDaten.Ber_Mitarbeiter);
	Daten->Ber_Passwort				= MyARexx.GetRexxLong("EMPLOYEE.RIGHT_PASSWORD",		0, UserDaten.Ber_Passwort);
	Daten->Ber_Niederlassung		= MyARexx.GetRexxLong("EMPLOYEE.RIGHT_BRANCHOFFICE",	0, UserDaten.Ber_Niederlassung);
	Daten->Ber_ERechnung				= MyARexx.GetRexxLong("EMPLOYEE.RIGHT_INBILL",			0, UserDaten.Ber_ERechnung);
	Daten->Ber_ARechnung				= MyARexx.GetRexxLong("EMPLOYEE.RIGHT_OUTBILL",			0, UserDaten.Ber_ARechnung);
	Daten->Ber_Artikel				= MyARexx.GetRexxLong("EMPLOYEE.RIGHT_ARTICLE",			0, UserDaten.Ber_Artikel);
	Daten->Ber_Laender				= MyARexx.GetRexxLong("EMPLOYEE.RIGHT_COUNTRY",			0, UserDaten.Ber_Laender);
	Daten->Ber_Prefs					= MyARexx.GetRexxLong("EMPLOYEE.RIGHT_PREFS",			0, UserDaten.Ber_Prefs);
	Daten->Ber_Inventur				= MyARexx.GetRexxLong("EMPLOYEE.RIGHT_STOCK",			0, UserDaten.Ber_Inventur);		// V1.04
	Daten->Ber_Kontenplan			= MyARexx.GetRexxLong("EMPLOYEE.RIGHT_ACCOUNT",			0, UserDaten.Ber_Kontenplan);		// V1.04
	Daten->Ber_Buchen					= MyARexx.GetRexxLong("EMPLOYEE.RIGHT_BOOK",				0, UserDaten.Ber_Buchen);			// V1.04

	UpDateElement();

	if( ReturnWert > 0 )
		ReturnWert = 2;
	return ReturnWert;
};

Niederlassung::Niederlassung(STRPTR Dateiname, STRPTR Datenbankbez, UWORD User ) : DataBase( Dateiname, Datenbankbez, User, sizeof(NiederlassungDaten), 6 )
{
	ULONG i;
	Daten = (NiederlassungDaten *)UserData;

	NiederlDummy[0] = 0;

	NiederListe 		= new ListenClass(40);
	CycleNiederLaenge = (ElementeVorhanden() * 40) + 1;
	CycleNieder			= new TEXT[CycleNiederLaenge];
	*CycleNieder		= 0;

	if( ElementeVorhanden() > 0 )
	{
		i = 0;
		TEXT Buffer[40];
		GetFirstElement();
		while( i < AktElementNr )
		{
			MyAdressPTR->GetElementNr( Daten->Adresse );
			CycleWertErmitteln( Buffer );
			NiederListe->NeuerNode( (STRPTR)Buffer );
			strcat((char *)CycleNieder, (const char *)Buffer );
			if( AktElementNr < ElementeVorhanden() )
				strcat((char *)CycleNieder, "\n");

			i = AktElementNr;
			GetNextElement();
		}

		GetFirstElement();
		MyAdressPTR->GetFirstElement();
	}

	Such_DB_Anzahl	= MyAdressPTR->Such_DB_Anzahl + 6;
	Such_DB_Feld	= new void*[Such_DB_Anzahl];
	Such_DB_Typ		= new UBYTE[Such_DB_Anzahl];
	Such_DB_CS		= new STRPTR[Such_DB_Anzahl];

	for(i = 0; i < MyAdressPTR->Such_DB_Anzahl; i++)
	{
		Such_DB_Feld[i]	= MyAdressPTR->Such_DB_Feld[i];
		Such_DB_Typ[i]		= MyAdressPTR->Such_DB_Typ[i];
		Such_DB_CS[i]		= MyAdressPTR->Such_DB_CS[i];
	}

	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl]		= (void *)Daten->ILN;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl]		= 0;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+1]	= (void *)Daten->SteuerNr;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+1]	= 0;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+1]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+2]	= (void *)Daten->UStID;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+2]	= 0;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+2]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+3]	= (void *)Daten->HRB;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+3]	= 0;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+3]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+4]	= (void *)&Daten->Finanzamt;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+4]	= 7;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+4]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+5]	= (void *)&Daten->Gericht;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+5]	= 7;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+5]		= NULL;

	Such_DB_Nr		= 3;

	struct DruWert NiederlassungDruWert[] =
	{
		{"AdressenNr",				"(", NULL, 16, ")", FALSE},
		{"FinanzamtNr",			"(", NULL, 16, ")", FALSE},
		{"GerichtNr",				"(", NULL, 16, ")", FALSE},
		{"ILN",						"(", NULL, 44, ")", FALSE},
		{"Steuernr",				"(", NULL, 44, ")", FALSE},
		{"UstID",					"(", NULL, 44, ")", FALSE},
		{"HRB",						"(", NULL, 44, ")", FALSE},
		{"",							"",  NULL, 0, "", FALSE}
	};

	DruckWertInit( NiederlassungDruWert );

	MerkAdress = NULL;

	MyAdressPTR->Initialisiere( (STRPTR)&AdressMerker );

	Such_DB_Felder_Laenge = strlen( AppStrings[MSG_Such_Adr_Dummy] ) + 1 +
									strlen( AppStrings[MSG_Such_Adr_AdresseA] ) +
									strlen( AppStrings[MSG_Such_Adr_AdresseB] ) +
									strlen( AppStrings[MSG_Such_Adr_Niederlassung] );
	Such_DB_Felder_String = new TEXT[Such_DB_Felder_Laenge];

	strcpy( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_Dummy] );
	strcat( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_AdresseA] );
	strcat( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_AdresseB] );
	strcat( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_Niederlassung] );
};

Niederlassung::~Niederlassung()
{
	delete [CycleNiederLaenge] CycleNieder;
	delete NiederListe;
};

BOOL Niederlassung::SuchVergleich( DataBaseSearch* SuchKlasse )
{
	if( SuchKlasse->DatenbankfeldNr < MyAdressPTR->Such_DB_Anzahl )
	{
		if( Daten->Adresse > 0)
			MyAdressPTR->GetElementNr( Daten->Adresse );
		return MyAdressPTR->SuchVergleich( SuchKlasse );
	}
	else
		return SuchKlasse->Vergleich();
}

void Niederlassung::SuchListeAnhaengen(ListenClass* SuchListe)
{
	char TextWert[1024];

	if( Daten->Adresse > 0)
		MyAdressPTR->GetElementNr( Daten->Adresse );

	sprintf( (char *)TextWert, "%lu; %s; %s; %s; %s; %s; %s; %s; %s",
																				AktElementNr,
																				MyAdressPTR->Daten->Firma1,
																				MyAdressPTR->Daten->Firma2,
																				MyAdressPTR->Daten->Vorname,
																				MyAdressPTR->Daten->Name,
																				MyAdressPTR->Daten->Strasse,
																				MyAdressPTR->Daten->PLZ,
																				MyAdressPTR->Daten->Ort,
																				MyLaenderPTR->LaenderListe->SucheNode(MyAdressPTR->Daten->Land));
	TextWert[255] = 0;
	SuchListe->NeuerNode( TextWert );
}

void Niederlassung::Initialisiere( STRPTR InitDaten )
{
	DataBase::Initialisiere( InitDaten );

	((NiederlassungDaten *)InitDaten)->Adresse		= MyAdressPTR->AktElementNr;
}

void Niederlassung::UpDateElement()
{
	DataBase::UpDateElement();
	if( UserN_Pos == AktElementNr)
		memcpy((void *)&UserNiederlassung, (const void *)Daten, sizeof(NiederlassungDaten));
};

void Niederlassung::UnDo()
{
	DataBase::UnDo();
	if( UserN_Pos == AktElementNr)
		memcpy((void *)&UserNiederlassung, (const void *)Daten, sizeof(NiederlassungDaten));
};

void Niederlassung::ReDo()
{
	DataBase::ReDo();
	if( UserN_Pos == AktElementNr)
		memcpy((void *)&UserNiederlassung, (const void *)Daten, sizeof(NiederlassungDaten));
};

void Niederlassung::NeuerDatensatz()
{
	DataBase::NeuerDatensatz();

	TEXT Buffer[40];
	CycleWertErmitteln( Buffer );

	NiederListe->NeuerNode(Buffer);

	delete [CycleNiederLaenge] CycleNieder;
	CycleNiederLaenge += 40;
	CycleNieder = new TEXT[CycleNiederLaenge];

	NiederListe->ListToString( CycleNieder );
};

void Niederlassung::CycleUpDate()
{
	TEXT Buffer[40];

	CycleWertErmitteln( Buffer );
	NiederListe->ErsetzeNode( Buffer, (MyAdressPTR->Daten->Niederlassung - 1) );

	NiederListe->ListToString( CycleNieder );
};

void Niederlassung::CycleWertErmitteln( STRPTR Buffer )
{
	if( *MyAdressPTR->Daten->Firma1 )
			strcpy( Buffer, MyAdressPTR->Daten->Firma1 );
	else
	{
		strcpy( Buffer, MyAdressPTR->Daten->Name );
		strcat( Buffer, " " );
		strcat( Buffer, MyAdressPTR->Daten->Vorname );
	}
};

void Niederlassung::PrintString( ofstream* os, STRPTR start, NiederlassungDaten* UebDaten, AdressDaten* UebAdress )
{
	MerkAdress = UebAdress;
	if( UebDaten )
		Daten = UebDaten;
	DataBase::PrintString( os, start );
	Daten = (NiederlassungDaten *)UserData;
	MerkAdress = NULL;
};

void Niederlassung::PrintTabelle( ofstream* os, UBYTE Typ, ULONG von, ULONG bis, DataBaseSearch* Vergleichsfunktion, UWORD* Verknuepf, NiederlassungDaten* UebDaten, AdressDaten* UebAdress )
{
	MerkAdress = UebAdress;
	if( UebDaten )
	{
		Daten = UebDaten;
		DataBase::PrintTabelle( os, Typ, von, 0, Vergleichsfunktion, Verknuepf );
		Daten = (NiederlassungDaten *)UserData;
	}
	else
		DataBase::PrintTabelle( os, Typ, von, bis, Vergleichsfunktion, Verknuepf );
	MerkAdress = NULL;
};

void Niederlassung::PrintVorbereiten( ofstream* os, UBYTE Art )
{
	ULONG j = 0;

	if( MerkAdress )
		MyAdressPTR->Daten = MerkAdress;
	else
		MyAdressPTR->GetElementNr( Daten->Adresse );
	switch( Art )
	{
		case '1':
			MyAdressPTR->DataBase::PrintString( os, Startstring );

			if( MerkAdress )
				MyAdressPTR->Daten = (AdressDaten *)MyAdressPTR->UserData;

			// Finanzamt
			if( Daten->Finanzamt == 0 )
			{
				MyAdressPTR->PrintString( os, "/FA", &AdressMerker );
			}
			else
			{
				MyAdressPTR->GetElementNr( Daten->Finanzamt );
				MyAdressPTR->DataBase::PrintString( os, "/FA" );
			}

			// Gericht
			if( Daten->Gericht == 0 )
			{
				MyAdressPTR->PrintString( os, "/GER", &AdressMerker );
			}
			else
			{
				MyAdressPTR->GetElementNr( Daten->Gericht );
				MyAdressPTR->DataBase::PrintString( os, "/GER" );
			}
			break;
		case '2':
			MyAdressPTR->DataBase::PrintTabelle( os, Art, Daten->Adresse, 0, NULL, NULL );

			if( MerkAdress )
				MyAdressPTR->Daten = (AdressDaten *)MyAdressPTR->UserData;

			// Finanzamt
			if( Daten->Finanzamt == 0 )
			{
				MyAdressPTR->PrintTabelle( os, Art, Daten->Finanzamt, 0, NULL, NULL, &AdressMerker );
			}
			else
			{
				MyAdressPTR->GetElementNr( Daten->Finanzamt );
				MyAdressPTR->DataBase::PrintTabelle( os, Art, Daten->Finanzamt, 0, NULL, NULL );
			}

			// Gericht
			if( Daten->Gericht == 0 )
			{
				MyAdressPTR->PrintTabelle( os, Art, Daten->Gericht, 0, NULL, NULL, &AdressMerker );
			}
			else
			{
				MyAdressPTR->GetElementNr( Daten->Gericht );
				MyAdressPTR->DataBase::PrintTabelle( os, Art, Daten->Gericht, 0, NULL, NULL );
			}
		 	break;
		case '3':
			MyAdressPTR->DataBase::PrintTabelle( os, Art, Daten->Adresse, 0, NULL, NULL );

			if( MerkAdress )
				MyAdressPTR->Daten = (AdressDaten *)MyAdressPTR->UserData;
			break;
	}

	// Adressennummer
	// Finanzamt
	// Gericht
	if( MyPrefsPTR->Daten->Nr_Laenge )
	{
		sprintf(DruckWert[j++].Wert, "%0*lu", MyPrefsPTR->Daten->Nr_Laenge, Daten->Adresse);
		sprintf(DruckWert[j++].Wert, "%0*lu", MyPrefsPTR->Daten->Nr_Laenge, Daten->Finanzamt);
		sprintf(DruckWert[j++].Wert, "%0*lu", MyPrefsPTR->Daten->Nr_Laenge, Daten->Gericht);
	}
	else
	{
		sprintf(DruckWert[j++].Wert, "%lu", Daten->Adresse);
		sprintf(DruckWert[j++].Wert, "%lu", Daten->Finanzamt);
		sprintf(DruckWert[j++].Wert, "%lu", Daten->Gericht);
	}

	// ILN
	PSAufbereit(Daten->ILN, DruckWert[j++].Wert);

	// Steuernummer
	PSAufbereit(Daten->SteuerNr, DruckWert[j++].Wert);

	// UmsatzsteuerID
	PSAufbereit(Daten->UStID, DruckWert[j++].Wert);

	// HRB
	PSAufbereit(Daten->HRB, DruckWert[j++].Wert);
};

ULONG Niederlassung::GetRexx(struct RexxMsg *rxmsg, ULONG Position, STRPTR Start, NiederlassungDaten* UebDaten, AdressDaten* UebDatenAdr )
{
	ULONG ReturnWert = 0;
	TEXT Buffer[80];
	TEXT Buffer2[80];

	NiederlassungDaten* ZWDaten;

	TEXT Dummy = 0;
	if(Start == NULL)
		Start = &Dummy;
	
	if( UebDaten )
	{
		ZWDaten = UebDaten;
	}
	else
	{
		ZWDaten = Daten;
		GetElementNr( Position );
	}

	strcpy( Buffer2, Start );
	strcat( Buffer2, "OFFICE." );
	MyAdressPTR->GetRexx( rxmsg, ZWDaten->Adresse, Buffer2, UebDatenAdr );

	sprintf(Buffer2, "%sOFFICE.STATE", Start );
	sprintf(Buffer, "%lu", ZWDaten->Status);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sOFFICE.ADDRESS_NUMBER", Start );
	sprintf(Buffer, "%lu", ZWDaten->Adresse);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sOFFICE.ILN", Start );
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->ILN, strlen(ZWDaten->ILN) );

	sprintf(Buffer2, "%sOFFICE.TAX_NUMBER", Start );
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->SteuerNr, strlen(ZWDaten->SteuerNr) );

	sprintf(Buffer2, "%sOFFICE.VALLUE_ID", Start );
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->UStID, strlen(ZWDaten->UStID) );

	sprintf(Buffer2, "%sOFFICE.HRB", Start );
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->HRB, strlen(ZWDaten->HRB) );

	sprintf(Buffer2, "%sOFFICE.REVENUE_OFFICE_NUMBER", Start );
	sprintf(Buffer, "%lu", ZWDaten->Finanzamt);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sOFFICE.COURT_NUMBER", Start );
	sprintf(Buffer, "%lu", ZWDaten->Gericht);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	if( ReturnWert > 0 )
		ReturnWert = 2;
	return ReturnWert;
};

ULONG Niederlassung::SetRexx(struct RexxMsg *rxmsg, ULONG Position)
{
	ULONG ReturnWert = 0;
	STRPTR Buffer = NULL;

	GetElementNr( Position );

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "OFFICE.ILN", (UBYTE **)&Buffer );
	strncpy( Daten->ILN, Buffer, 29);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "OFFICE.TAX_NUMBER", (UBYTE **)&Buffer );
	strncpy( Daten->SteuerNr, Buffer, 29);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "OFFICE.VALLUE_ID", (UBYTE **)&Buffer );
	strncpy( Daten->UStID, Buffer, 29);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "OFFICE.HRB", (UBYTE **)&Buffer );
	strncpy( Daten->HRB, Buffer, 29);

	Daten->Finanzamt			= MyARexx.GetRexxLong("OFFICE.REVENUE_OFFICE_NUMBER",		0, MyAdressPTR->ElementeVorhanden());
	Daten->Gericht				= MyARexx.GetRexxLong("OFFICE.COURT_NUMBER",					0, MyAdressPTR->ElementeVorhanden());

	UpDateElement();

	if( ReturnWert > 0 )
		ReturnWert = 2;
	return ReturnWert;
};

Lieferanten::Lieferanten(STRPTR Dateiname, STRPTR Datenbankbez, UWORD User ) : DataBase( Dateiname, Datenbankbez, User, sizeof(LieferantenDaten), 46 )
{
	ULONG i;
	Daten = (LieferantenDaten *)UserData;
	Such_DB_Anzahl	= MyAdressPTR->Such_DB_Anzahl + 9;
	Such_DB_Feld	= new void*[Such_DB_Anzahl];
	Such_DB_Typ		= new UBYTE[Such_DB_Anzahl];
	Such_DB_CS		= new STRPTR[Such_DB_Anzahl];

	for(i = 0; i < MyAdressPTR->Such_DB_Anzahl; i++)
	{
		Such_DB_Feld[i]	= MyAdressPTR->Such_DB_Feld[i];
		Such_DB_Typ[i]		= MyAdressPTR->Such_DB_Typ[i];
		Such_DB_CS[i]		= MyAdressPTR->Such_DB_CS[i];
	}

	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl]		= (void *)Daten->Kundennummer;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl]		= 0;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+1]	= (void *)&Daten->MinBestWert;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+1]	= 11;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+1]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+2]	= (void *)&Daten->Waehrung_KZ;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+2]	= 5;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+2]		= MyPrefsPTR->CycleWaehrung;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+3]	= (void *)Daten->ILN;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+3]	= 0;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+3]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+4]	= (void *)&Daten->Preissystem;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+4]	= 5;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+4]		= AppStrings[MSG_PreisSys];
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+5]	= (void *)&Daten->MWStBefreit;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+5]	= 4;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+5]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+6]	= (void *)&Daten->ZuAbNummer;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+6]	= 5;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+6]		= MyPrefsPTR->CycleZuAb;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+7]	= (void *)&Daten->ZuAbWert;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+7]	= 11;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+7]		= NULL;
	Such_DB_Feld[MyAdressPTR->Such_DB_Anzahl+8]	= (void *)&Daten->Konto_Zahlung_Ein;
	Such_DB_Typ[MyAdressPTR->Such_DB_Anzahl+8]	= 6;
	Such_DB_CS[MyAdressPTR->Such_DB_Anzahl+8]		= MyKontenPosPTR->CycleKonto;

	Such_DB_Felder_Laenge = strlen( AppStrings[MSG_Such_Adr_Dummy] ) + 1 +
									strlen( AppStrings[MSG_Such_Adr_AdresseA] ) +
									strlen( AppStrings[MSG_Such_Adr_AdresseB] ) +
									strlen( AppStrings[MSG_Such_Adr_Lieferant] );
	Such_DB_Felder_String = new TEXT[Such_DB_Felder_Laenge];

	strcpy( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_Dummy] );
	strcat( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_AdresseA] );
	strcat( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_AdresseB] );
	strcat( Such_DB_Felder_String, AppStrings[MSG_Such_Adr_Lieferant] );

	Such_DB_Nr		= 4;

	struct DruWert LieferantenDruWert[] =
	{
		{"AdressenNr",				"(", NULL, 16, ")", FALSE},
		{"KundenNrLieferant",	"(", NULL, 40, ")", FALSE},
		{"WaehrungLieferant",	"", NULL, 4, "", FALSE},
		{"WaehrungLSymbol",		"(", NULL, 8, ")", FALSE},
		{"MinBestWertGef",		"", NULL, 8, "", FALSE},
		{"MinBestWert",			"[", NULL, 120, "]", FALSE},
		{"ILN",						"(", NULL, 40, ")", FALSE},
		{"Preissystem",			"", NULL, 4, "", FALSE},
		{"MWStBefreit",			"", NULL, 8, "", FALSE},
		{"ZuAbNr",					"", NULL, 8, "", FALSE},
		{"ZuAbWert",				"[", NULL, 80, "]", FALSE},
		{"ZuAbBezeich",			"(", NULL, 80, ")", FALSE},
		{"ZuAbTyp",					"", NULL, 8, "", FALSE},
		{"",							"", NULL, 0, "", FALSE}
	};

	DruckWertInit( LieferantenDruWert );

	MerkAdress = NULL;
};

void Lieferanten::Initialisiere( STRPTR InitDaten )
{
	DataBase::Initialisiere( InitDaten );

	((LieferantenDaten *)InitDaten)->Waehrung_KZ				= MyPrefsPTR->Daten->Waehrung_KZ;
	((LieferantenDaten *)InitDaten)->Adresse					= MyAdressPTR->AktElementNr;
	((LieferantenDaten *)InitDaten)->Preissystem				= 2;
	((LieferantenDaten *)InitDaten)->Umrech_KH				= MyPrefsPTR->Daten->Umrech_KH;
	((LieferantenDaten *)InitDaten)->Umrech_KL				= MyPrefsPTR->Daten->Umrech_KL;
	((LieferantenDaten *)InitDaten)->Umrech_HK				= MyPrefsPTR->Daten->Umrech_HK;
	((LieferantenDaten *)InitDaten)->Umrech_HL				= MyPrefsPTR->Daten->Umrech_HL;
	((LieferantenDaten *)InitDaten)->Umrech_LK				= MyPrefsPTR->Daten->Umrech_LK;
	((LieferantenDaten *)InitDaten)->Umrech_LH				= MyPrefsPTR->Daten->Umrech_LH;
	((LieferantenDaten *)InitDaten)->Umrech_ZuAb[0]			= MyPrefsPTR->Daten->Umrech_ZuAb[0];
	((LieferantenDaten *)InitDaten)->Umrech_ZuAb[1]			= MyPrefsPTR->Daten->Umrech_ZuAb[1];
	((LieferantenDaten *)InitDaten)->Umrech_ZuAb[2]			= MyPrefsPTR->Daten->Umrech_ZuAb[2];
	((LieferantenDaten *)InitDaten)->Umrech_ZuAb[3]			= MyPrefsPTR->Daten->Umrech_ZuAb[3];
	((LieferantenDaten *)InitDaten)->Umrech_ZuAb[4]			= MyPrefsPTR->Daten->Umrech_ZuAb[4];
	((LieferantenDaten *)InitDaten)->Umrech_ZuAb[5]			= MyPrefsPTR->Daten->Umrech_ZuAb[5];
	((LieferantenDaten *)InitDaten)->Umrech_ZuAbWert[0]	= MyPrefsPTR->Daten->Umrech_ZuAbWert[0];
	((LieferantenDaten *)InitDaten)->Umrech_ZuAbWert[1]	= MyPrefsPTR->Daten->Umrech_ZuAbWert[1];
	((LieferantenDaten *)InitDaten)->Umrech_ZuAbWert[2]	= MyPrefsPTR->Daten->Umrech_ZuAbWert[2];
	((LieferantenDaten *)InitDaten)->Umrech_ZuAbWert[3]	= MyPrefsPTR->Daten->Umrech_ZuAbWert[3];
	((LieferantenDaten *)InitDaten)->Umrech_ZuAbWert[4]	= MyPrefsPTR->Daten->Umrech_ZuAbWert[4];
	((LieferantenDaten *)InitDaten)->Umrech_ZuAbWert[5]	= MyPrefsPTR->Daten->Umrech_ZuAbWert[5];
	((LieferantenDaten *)InitDaten)->Umrech_Runden[0]		= MyPrefsPTR->Daten->Umrech_Runden[0];
	((LieferantenDaten *)InitDaten)->Umrech_Runden[1]		= MyPrefsPTR->Daten->Umrech_Runden[1];
	((LieferantenDaten *)InitDaten)->Umrech_Runden[2]		= MyPrefsPTR->Daten->Umrech_Runden[2];
	((LieferantenDaten *)InitDaten)->Umrech_RundenVon[0]	= MyPrefsPTR->Daten->Umrech_RundenVon[0];
	((LieferantenDaten *)InitDaten)->Umrech_RundenVon[1]	= MyPrefsPTR->Daten->Umrech_RundenVon[1];
	((LieferantenDaten *)InitDaten)->Umrech_RundenVon[2]	= MyPrefsPTR->Daten->Umrech_RundenVon[2];
	((LieferantenDaten *)InitDaten)->Umrech_RundenVon[3]	= MyPrefsPTR->Daten->Umrech_RundenVon[3];
	((LieferantenDaten *)InitDaten)->Umrech_RundenBis[0]	= MyPrefsPTR->Daten->Umrech_RundenBis[0];
	((LieferantenDaten *)InitDaten)->Umrech_RundenBis[1]	= MyPrefsPTR->Daten->Umrech_RundenBis[1];
	((LieferantenDaten *)InitDaten)->Umrech_RundenBis[2]	= MyPrefsPTR->Daten->Umrech_RundenBis[2];
	((LieferantenDaten *)InitDaten)->Umrech_RundenBis[3]	= MyPrefsPTR->Daten->Umrech_RundenBis[3];
	((LieferantenDaten *)InitDaten)->Umrech_RundenZu[0]	= MyPrefsPTR->Daten->Umrech_RundenZu[0];
	((LieferantenDaten *)InitDaten)->Umrech_RundenZu[1]	= MyPrefsPTR->Daten->Umrech_RundenZu[1];
	((LieferantenDaten *)InitDaten)->Umrech_RundenZu[2]	= MyPrefsPTR->Daten->Umrech_RundenZu[2];
	((LieferantenDaten *)InitDaten)->Umrech_RundenZu[3]	= MyPrefsPTR->Daten->Umrech_RundenZu[3];
	((LieferantenDaten *)InitDaten)->Konto_Zahlung_Ein		= MyPrefsPTR->Daten->Konto_Zahlung_Ein;
};

BOOL Lieferanten::SuchVergleich( DataBaseSearch* SuchKlasse )
{
	if( SuchKlasse->DatenbankfeldNr < MyAdressPTR->Such_DB_Anzahl )
	{
		if( Daten->Adresse > 0)
			MyAdressPTR->GetElementNr( Daten->Adresse );
		return MyAdressPTR->SuchVergleich( SuchKlasse );
	}
	else
		return SuchKlasse->Vergleich();
}


void Lieferanten::SuchListeAnhaengen(ListenClass* SuchListe)
{
	char TextWert[1024];

	if( Daten->Adresse > 0)
		MyAdressPTR->GetElementNr( Daten->Adresse );

	sprintf( (char *)TextWert, "%lu; %s; %s; %s; %s; %s; %s; %s; %s",
																				AktElementNr,
																				MyAdressPTR->Daten->Firma1,
																				MyAdressPTR->Daten->Firma2,
																				MyAdressPTR->Daten->Vorname,
																				MyAdressPTR->Daten->Name,
																				MyAdressPTR->Daten->Strasse,
																				MyAdressPTR->Daten->PLZ,
																				MyAdressPTR->Daten->Ort,
																				MyLaenderPTR->LaenderListe->SucheNode(MyAdressPTR->Daten->Land));
	TextWert[255] = 0;
	SuchListe->NeuerNode( TextWert );
}

void Lieferanten::UpDateElement()
{
	if( Daten->Status == 0xffff )
		return;

	ULONG i;
	DOUBLE ZWDouble;

	AltDaten				= (LieferantenDaten *)UnDoBuffer[UnDoUsed];

	if( Daten->ZuAbNummer	> 0 &&
		 (Daten->ZuAbNummer	!= AltDaten->ZuAbNummer ||
		  Daten->ZuAbWert		!= AltDaten->ZuAbWert) )
	{
		ZWDouble		= MyPrefsPTR->WaehrungUmrechnen(	MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel],
																	MyPrefsPTR->Daten->ZuAb_Limit_Von[(Daten->ZuAbNummer - 1)],
																	MyPrefsPTR->Daten->Waehrung_KZ,
																	Daten->Waehrung_KZ,
																	MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel] );
		if( Daten->ZuAbWert		< ZWDouble )
			Daten->ZuAbWert		= ZWDouble;
		else
		{
			ZWDouble	= MyPrefsPTR->WaehrungUmrechnen(	MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel],
																	MyPrefsPTR->Daten->ZuAb_Limit_Bis[(Daten->ZuAbNummer - 1)],
																	MyPrefsPTR->Daten->Waehrung_KZ,
																	Daten->Waehrung_KZ,
																	MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel] );
			if( Daten->ZuAbWert	> ZWDouble )
				Daten->ZuAbWert	= ZWDouble;
		}
	}

	for( i = 0; i < 6; i++ )
	{
		if( Daten->Umrech_ZuAb[i]			> 0 &&
			 (Daten->Umrech_ZuAb[i]			!= AltDaten->Umrech_ZuAb[1] ||
			  Daten->Umrech_ZuAbWert[i]	!= AltDaten->Umrech_ZuAbWert[1]) )
		{
			ZWDouble		= MyPrefsPTR->WaehrungUmrechnen(	MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel],
																		MyPrefsPTR->Daten->ZuAb_Limit_Von[(Daten->Umrech_ZuAb[i] - 1)],
																		MyPrefsPTR->Daten->Waehrung_KZ,
																		Daten->Waehrung_KZ,
																		MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel] );
			if( Daten->Umrech_ZuAbWert[i]		< ZWDouble )
				Daten->Umrech_ZuAbWert[i]		= ZWDouble;
			else
			{
				ZWDouble	= MyPrefsPTR->WaehrungUmrechnen(	MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel],
																		MyPrefsPTR->Daten->ZuAb_Limit_Bis[(Daten->Umrech_ZuAb[i] - 1)],
																		MyPrefsPTR->Daten->Waehrung_KZ,
																		Daten->Waehrung_KZ,
																		MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel] );
				if( Daten->Umrech_ZuAbWert[i]	> ZWDouble )
					Daten->Umrech_ZuAbWert[i]	= ZWDouble;
			}
		}
	}

	DataBase::UpDateElement();
};

void Lieferanten::PrintString( ofstream* os, STRPTR start, LieferantenDaten* UebDaten, AdressDaten* UebAdress )
{
	MerkAdress = UebAdress;
	if( UebDaten )
		Daten = UebDaten;
	DataBase::PrintString( os, start );
	Daten = (LieferantenDaten *)UserData;
	MerkAdress = NULL;
};

void Lieferanten::PrintTabelle( ofstream* os, UBYTE Typ, ULONG von, ULONG bis, DataBaseSearch* Vergleichsfunktion, UWORD* Verknuepf, LieferantenDaten* UebDaten, AdressDaten* UebAdress )
{
	MerkAdress = UebAdress;
	if( UebDaten )
	{
		Daten = UebDaten;
		DataBase::PrintTabelle( os, Typ, von, 0, Vergleichsfunktion, Verknuepf );
		Daten = (LieferantenDaten *)UserData;
	}
	else
		DataBase::PrintTabelle( os, Typ, von, bis, Vergleichsfunktion, Verknuepf );
	MerkAdress = NULL;
};

void Lieferanten::PrintVorbereiten( ofstream* os, UBYTE Art )
{
	TEXT Zwischenstring[80];
	STRPTR ZWString;
	ULONG j = 0;

	if( MerkAdress )
		MyAdressPTR->Daten = MerkAdress;
	else
		MyAdressPTR->GetElementNr( Daten->Adresse );
	switch( Art )
	{
		case '1':
			MyAdressPTR->DataBase::PrintString( os, Startstring );
			break;
		case '2':
		case '3':
			MyAdressPTR->DataBase::PrintTabelle( os, Art, Daten->Adresse, 0, NULL, NULL );
		 	break;
	}
	if( MerkAdress )
		MyAdressPTR->Daten = (AdressDaten *)MyAdressPTR->UserData;

	// Adressennummer
	if( MyPrefsPTR->Daten->Nr_Laenge )
	{
		sprintf(DruckWert[j++].Wert, "%0*lu", MyPrefsPTR->Daten->Nr_Laenge, Daten->Adresse);
	}
	else
		sprintf(DruckWert[j++].Wert, "%lu", Daten->Adresse);

	// Kundennummer
	PSAufbereit(Daten->Kundennummer, DruckWert[j++].Wert);

	// Waehrungskennzeichen
	DruckWert[j].Wert[0]		= (TEXT)'0' + (TEXT)Daten->Waehrung_KZ;
	DruckWert[j++].Wert[1]	= 0;

	// Waehrungssymbol
	PSAufbereit(MyPrefsPTR->WaehrungPTR[Daten->Waehrung_KZ], DruckWert[j++].Wert);

	// Mindest Bestellwert
	if( Daten->MinBestWert == 0 )
		strcpy( DruckWert[j++].Wert, "false" );
	else
		strcpy( DruckWert[j++].Wert, "true" );

	PSDruckBetrag( DruckWert[j++].Wert, MyPrefsPTR->WaehrungPTR,
						MyPrefsPTR->WaehrungUmrechnen( 0, Daten->MinBestWert, Daten->Waehrung_KZ, 1, 0),
						MyPrefsPTR->WaehrungUmrechnen( 0, Daten->MinBestWert, Daten->Waehrung_KZ, 3, 0) );

	// ILN
	PSAufbereit(Daten->ILN, DruckWert[j++].Wert);

	// Preissystem beim Lieferanten
	DruckWert[j].Wert[0]		= (TEXT)'0' + (TEXT)Daten->Preissystem;
	DruckWert[j++].Wert[1]	= 0;

	// Mehrwertsteuerbefreit
	if( Daten->MWStBefreit )
		strcpy( DruckWert[j++].Wert, "true" );
	else
		strcpy( DruckWert[j++].Wert, "false" );

	// ZuAbNr
	sprintf(DruckWert[j++].Wert, "%lu", Daten->ZuAbNummer);
	
	// ZuAbWert
	// ZuAbBezeichnung
	// ZuAbTyp
	if( Daten->ZuAbNummer )
	{
		switch( MyPrefsPTR->Daten->ZuAbTyp[(Daten->ZuAbNummer - 1)] )
		{
			case 0:
			case 5:
				MyLocalePTR->FormatNumber( DruckWert[j].Wert, Daten->ZuAbWert, MyPrefsPTR->Daten->Nachkomma_Prozent);
				ZWString = PSAufbereit( DruckWert[j].Wert, Zwischenstring );
				sprintf( DruckWert[j++].Wert, "(%s)(%s)", Zwischenstring, Zwischenstring );
				break;
			default:
				PSDruckBetrag( DruckWert[j++].Wert, MyPrefsPTR->WaehrungPTR,
									MyPrefsPTR->WaehrungUmrechnen(MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel],
																			Daten->ZuAbWert, Daten->Waehrung_KZ, 0,
																			MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel]),
									MyPrefsPTR->WaehrungUmrechnen(MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel],
																			Daten->ZuAbWert, Daten->Waehrung_KZ, 1,
																			MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel]),
									MyPrefsPTR->WaehrungUmrechnen(MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel],
																			Daten->ZuAbWert, Daten->Waehrung_KZ, 2,
																			MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel]),
									MyPrefsPTR->WaehrungUmrechnen(MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel],
																			Daten->ZuAbWert, Daten->Waehrung_KZ, 3,
																			MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel]) );
				break;
		}

		PSAufbereit(MyPrefsPTR->Daten->ZuAbBezeich[(Daten->ZuAbNummer - 1)], DruckWert[j++].Wert);
		sprintf(DruckWert[j++].Wert, "%lu", MyPrefsPTR->Daten->ZuAbTyp[(Daten->ZuAbNummer - 1)] );
	}
	else
	{
		DruckWert[j++].Wert[0]	= 0;
		DruckWert[j++].Wert[0]	= 0;
		DruckWert[j].Wert[0]		= '0';
		DruckWert[j++].Wert[1]	= 0;
	}
};

ULONG Lieferanten::GetRexx(struct RexxMsg *rxmsg, ULONG Position, STRPTR Start, LieferantenDaten* UebDaten, AdressDaten* UebDatenAdr )
{
	ULONG ReturnWert = 0, i;
	TEXT Buffer[80];
	TEXT Buffer2[80];

	LieferantenDaten* ZWDaten;

	TEXT Dummy = 0;
	if(Start == NULL)
		Start = &Dummy;
	
	if( UebDaten )
	{
		ZWDaten = UebDaten;
	}
	else
	{
		ZWDaten = Daten;
		GetElementNr( Position );
	}

	strcpy( Buffer2, Start );
	strcat( Buffer2, "SUPPLIER." );
	MyAdressPTR->GetRexx( rxmsg, ZWDaten->Adresse, Buffer2, UebDatenAdr );

	sprintf(Buffer2, "%sSUPPLIER.STATE", Start );
	sprintf(Buffer, "%lu", ZWDaten->Status);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sSUPPLIER.ADDRESS_NUMBER", Start );
	sprintf(Buffer, "%lu", ZWDaten->Adresse);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sSUPPLIER.CLIENT_CODE", Start );
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->Kundennummer, strlen(ZWDaten->Kundennummer) );

	sprintf(Buffer2, "%sSUPPLIER.MIN_ORDER_VALUE", Start );
	ReturnWert += MyARexx.RexxBetrag2( Buffer2, ZWDaten->MinBestWert, ZWDaten->Waehrung_KZ );

	sprintf(Buffer2, "%sSUPPLIER.CURRENCY_USED", Start );
	sprintf(Buffer, "%lu", ZWDaten->Waehrung_KZ);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sSUPPLIER.ILN", Start );
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)ZWDaten->ILN, strlen(ZWDaten->ILN) );

	sprintf(Buffer2, "%sSUPPLIER.ADD_RED_VALUE", Start );
	if( ZWDaten->ZuAbNummer > 0 &&
		(MyPrefsPTR->Daten->ZuAbTyp[(ZWDaten->ZuAbNummer - 1)] == 0 ||
		 MyPrefsPTR->Daten->ZuAbTyp[(ZWDaten->ZuAbNummer - 1)] == 5) )
	{
		ReturnWert += MyARexx.RexxBetrag4( Buffer2, ZWDaten->ZuAbWert, ZWDaten->Waehrung_KZ, MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel], MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel] );
	}
	else
	{
		ReturnWert += MyARexx.RexxBetrag( Buffer2, ZWDaten->ZuAbWert, ZWDaten->ZuAbWert, ZWDaten->ZuAbWert, ZWDaten->ZuAbWert );
	}

	sprintf(Buffer2, "%sSUPPLIER.ADD_RED_USED", Start );
	sprintf(Buffer, "%u", ZWDaten->ZuAbNummer);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer2, "%sSUPPLIER.PRICE_SYSTEM", Start );
	Buffer[0] = '0' + ZWDaten->Preissystem;
	Buffer[1] = 0;
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );

	Buffer[1]		= 0;
	sprintf(Buffer2, "%sSUPPLIER.VALUE_FREE", Start );
	if( ZWDaten->MWStBefreit )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, 1 );

	sprintf(Buffer2, "%sSUPPLIER.CALC_CT", Start );
	if( ZWDaten->Umrech_KH )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, 1 );

	sprintf(Buffer2, "%sSUPPLIER.CALC_CS", Start );
	if( ZWDaten->Umrech_KL )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, 1 );

	sprintf(Buffer2, "%sSUPPLIER.CALC_TC", Start );
	if( ZWDaten->Umrech_HK )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, 1 );

	sprintf(Buffer2, "%sSUPPLIER.CALC_TS", Start );
	if( ZWDaten->Umrech_HL )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, 1 );

	sprintf(Buffer2, "%sSUPPLIER.CALC_SC", Start );
	if( ZWDaten->Umrech_LK )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, 1 );

	sprintf(Buffer2, "%sSUPPLIER.CALC_ST", Start );
	if( ZWDaten->Umrech_LH )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, 1 );

	sprintf(Buffer2, "%sSUPPLIER.CALC_ROUND_S", Start );
	if( ZWDaten->Umrech_Runden[0] )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, 1 );

	sprintf(Buffer2, "%sSUPPLIER.CALC_ROUND_T", Start );
	if( ZWDaten->Umrech_Runden[1] )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, 1 );

	sprintf(Buffer2, "%sSUPPLIER.CALC_ROUND_C", Start );
	if( ZWDaten->Umrech_Runden[2] )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, 1 );

	for( i = 0; i < 6; i++ )
	{
		sprintf(Buffer2, "%sSUPPLIER.CALC_ADD_RED.%lu", Start, i );
		sprintf(Buffer, "%u", ZWDaten->Umrech_ZuAb[i]);
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );
		sprintf(Buffer2, "%sSUPPLIER.CALC_ADD_RED_VALUE.%lu", Start, i );
		if( ZWDaten->Umrech_ZuAb[i] > 0 &&
			(MyPrefsPTR->Daten->ZuAbTyp[(ZWDaten->Umrech_ZuAb[i] - 1)] == 0 ||
			 MyPrefsPTR->Daten->ZuAbTyp[(ZWDaten->Umrech_ZuAb[i] - 1)] == 5) )
		{
			ReturnWert += MyARexx.RexxBetrag4( Buffer2, ZWDaten->Umrech_ZuAbWert[i], ZWDaten->Waehrung_KZ, MyPrefsPTR->Daten->MWSt[MyPrefsPTR->Daten->MWSt_Artikel], MyPrefsPTR->Daten->MWSt_Typ[MyPrefsPTR->Daten->MWSt_Artikel] );
		}
		else
		{
			ReturnWert += MyARexx.RexxBetrag( Buffer2, ZWDaten->Umrech_ZuAbWert[i], ZWDaten->Umrech_ZuAbWert[i], ZWDaten->Umrech_ZuAbWert[i], ZWDaten->Umrech_ZuAbWert[i] );
		}
	}

	sprintf(Buffer2, "%sSUPPLIER.CALC_ROUND_FROM", Start );
	ReturnWert += MyARexx.RexxBetrag( Buffer2, ZWDaten->Umrech_RundenVon[0], ZWDaten->Umrech_RundenVon[1], ZWDaten->Umrech_RundenVon[2], ZWDaten->Umrech_RundenVon[3] );

	sprintf(Buffer2, "%sSUPPLIER.CALC_ROUND_TO", Start );
	ReturnWert += MyARexx.RexxBetrag( Buffer2, ZWDaten->Umrech_RundenBis[0], ZWDaten->Umrech_RundenBis[1], ZWDaten->Umrech_RundenBis[2], ZWDaten->Umrech_RundenBis[3] );

	sprintf(Buffer2, "%sSUPPLIER.CALC_ROUND_NEW", Start );
	ReturnWert += MyARexx.RexxBetrag( Buffer2, ZWDaten->Umrech_RundenZu[0], ZWDaten->Umrech_RundenZu[1], ZWDaten->Umrech_RundenZu[2], ZWDaten->Umrech_RundenZu[3] );

	// Zahlungskonto bei Rechnungseingängen		(V1.04)
	sprintf(Buffer2, "%sSUPPLIER.ACCOUNT_PAY_IN", Start );
	sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(ZWDaten->Konto_Zahlung_Ein));
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, Buffer2, (STRPTR)Buffer, strlen(Buffer) );



	if( ReturnWert > 0 )
		ReturnWert = 2;
	return ReturnWert;
};

ULONG Lieferanten::SetRexx(struct RexxMsg *rxmsg, ULONG Position)
{
	ULONG ReturnWert = 0, i;
	STRPTR Buffer = NULL;
	TEXT Buffer2[80];

	GetElementNr( Position );

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "SUPPLIER.CLIENT_CODE", (UBYTE **)&Buffer );
	strncpy( Daten->Kundennummer, Buffer, 29);

	Daten->Waehrung_KZ				= MyARexx.GetRexxLong("SUPPLIER.CURRENCY_USED", 0, 3);

	sprintf(Buffer2, "SUPPLIER.MIN_ORDER_VALUE.%lu", (ULONG)(Daten->Waehrung_KZ / 2) );
	ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
	Daten->MinBestWert				= atof( Buffer );

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "SUPPLIER.ILN", (UBYTE **)&Buffer );
	strncpy( Daten->ILN, Buffer, 29);

	Daten->ZuAbNummer					= MyARexx.GetRexxLong("SUPPLIER.ADD_RED_USED", 0, MyPrefsPTR->Daten->ZuAbBelegt);

	sprintf(Buffer2, "SUPPLIER.ADD_RED_VALUE.%lu", (ULONG)(Daten->Waehrung_KZ / 2) );
	ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
	Daten->ZuAbWert					= atof( Buffer );

	Daten->Preissystem				= MyARexx.GetRexxLong("SUPPLIER.PRICE_SYSTEM", 0, 3);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "SUPPLIER.VALUE_FREE", (UBYTE **)&Buffer );
	Daten->MWStBefreit	= (*Buffer == 'y' || *Buffer == 'Y');

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "SUPPLIER.CALC_CT", (UBYTE **)&Buffer );
	Daten->Umrech_KH		= (*Buffer == 'y' || *Buffer == 'Y');

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "SUPPLIER.CALC_CS", (UBYTE **)&Buffer );
	Daten->Umrech_KL		= (*Buffer == 'y' || *Buffer == 'Y');

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "SUPPLIER.CALC_TC", (UBYTE **)&Buffer );
	Daten->Umrech_HK		= (*Buffer == 'y' || *Buffer == 'Y');

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "SUPPLIER.CALC_TS", (UBYTE **)&Buffer );
	Daten->Umrech_HL		= (*Buffer == 'y' || *Buffer == 'Y');

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "SUPPLIER.CALC_SC", (UBYTE **)&Buffer );
	Daten->Umrech_LK		= (*Buffer == 'y' || *Buffer == 'Y');

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "SUPPLIER.CALC_ST", (UBYTE **)&Buffer );
	Daten->Umrech_LH		= (*Buffer == 'y' || *Buffer == 'Y');

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "SUPPLIER.CALC_ROUND_S", (UBYTE **)&Buffer );
	Daten->Umrech_Runden[0]	= (*Buffer == 'y' || *Buffer == 'Y');

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "SUPPLIER.CALC_ROUND_T", (UBYTE **)&Buffer );
	Daten->Umrech_Runden[1]	= (*Buffer == 'y' || *Buffer == 'Y');

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "SUPPLIER.CALC_ROUND_C", (UBYTE **)&Buffer );
	Daten->Umrech_Runden[2]	= (*Buffer == 'y' || *Buffer == 'Y');

	for( i = 0; i < 6; i++ )
	{
		sprintf(Buffer2, "SUPPLIER.CALC_ADD_RED.%lu", i );
		Daten->Umrech_ZuAb[i]		= MyARexx.GetRexxLong(Buffer2, 0, MyPrefsPTR->Daten->ZuAbBelegt);

		sprintf(Buffer2, "SUPPLIER.CALC_ADD_RED_VALUE.%lu.%lu", i, (ULONG)Daten->Waehrung_KZ );
		ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
		Daten->Umrech_ZuAbWert[i]	= atof( Buffer );
	}

	for( i = 0; i < 4; i++ )
	{
		sprintf(Buffer2, "SUPPLIER.CALC_ROUND_FROM.%lu", i );
		ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
		Daten->Umrech_RundenVon[i]	= atof( Buffer );

		sprintf(Buffer2, "SUPPLIER.CALC_ROUND_TO.%lu", i );
		ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
		Daten->Umrech_RundenBis[i]	= atof( Buffer );

		sprintf(Buffer2, "SUPPLIER.CALC_ROUND_NEW.%lu", i );
		ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
		Daten->Umrech_RundenZu[i]	= atof( Buffer );
	}

	// Buchungskonto für die Zahlung von Eingangsbelegen       (V1.04)
	Daten->Konto_Zahlung_Ein		= MyKontenPosPTR->FromCycle(MyARexx.GetRexxLong("SUPPLIER.ACCOUNT_PAY_IN", 0, MyKontenPosPTR->AnzCyclePos));


	UpDateElement();

	if( ReturnWert > 0 )
		ReturnWert = 2;
	return ReturnWert;
};