#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 <new.h>
#include <stdio.h>
#include <limits.h>
#include "MTList.h"
#include "MTLocale.h"
#include "MTToolType.h"
#include "Datenbank.h"
#include "Einstellungen.h"
#include "KontenPos.h"
#include "LocaleStrings.h"
#include "MTARexx.h"

extern OpenLocaleClass	*MyLocalePTR;
extern MTToolType			*MyToolTypesPTR;

extern FillAppStrings	*MyAppStringsPTR;

extern KontenPos			*MyKontenPosPTR;

// ARexx-Port Auswertung
extern MTARexx				MyARexx;

Prefs::Prefs(STRPTR Dateiname, STRPTR Datenbankbez, UWORD User ) : DataBase( Dateiname, Datenbankbez, User, sizeof(PrefsDaten), 4450 )
{
	TEXT Druckpfadplus[265];
	struct AnchorPath *MyAnchor;
	LONG i, j, k;

	for(i = 0; i < 11; DruDockList[i++]	= new ListenClass(40) );

	ZuAbList		= new ListenClass(45);
	ArtGrpList	= new ListenClass(20);
//	UBYTE MWStListLaenge[] = {20,40};
//	MWStList		= new ListenClass(MWStListLaenge, 2);
	MWStList		= new ListenClass(61);
	MEList		= new ListenClass(15);
	KundKatList	= new ListenClass(20);

	Daten = (PrefsDaten *)UserData;
	if( ElementeVorhanden() > 0 )
		GetFirstElement();
	else
		NeuerDatensatz();

	for(i = 0; i < 10; i++)
	{
		MyAppStringsPTR->GetCycleWert( AppStrings[MSG_ZuAbTyp], ZuAbTypText[i], i );
	}

	CyZuAb();
	CyArtGrp();

	CyMWStPlus();

	CyME();
	CyKundKat();

	sprintf(CycleWaehrung, AppStrings[MSG_Waehrung],	MyLocalePTR->Thislocale->loc_MonIntCS,
																		MyLocalePTR->Thislocale->loc_MonIntCS,
																		Daten->Waehrung2_Symbol,
																		Daten->Waehrung2_Symbol);

	WaehrungPTR[0]		= MyLocalePTR->Thislocale->loc_MonIntCS;
	WaehrungPTR[1]		= MyLocalePTR->Thislocale->loc_MonIntCS;
	WaehrungPTR[2]		= Daten->Waehrung2_Symbol;
	WaehrungPTR[3]		= Daten->Waehrung2_Symbol;

	MyAnchor = (struct AnchorPath *)new TEXT[ (sizeof(struct AnchorPath) + 4096) ];

	TEXT SuchExtension[11][64];
	ParsePatternNoCase( "#?.adrpri", SuchExtension[0],		64l );
	ParsePatternNoCase( "#?.cuspri", SuchExtension[1],		64l );
	ParsePatternNoCase( "#?.emppri", SuchExtension[2],		64l );
	ParsePatternNoCase( "#?.brapri", SuchExtension[3],		64l );
	ParsePatternNoCase( "#?.suppri", SuchExtension[4],		64l );
	ParsePatternNoCase( "#?.artpri", SuchExtension[5],		64l );
	ParsePatternNoCase( "#?.outpri", SuchExtension[6],		64l );
	ParsePatternNoCase( "#?.inbpri", SuchExtension[7],		64l );
	ParsePatternNoCase( "#?.stopri", SuchExtension[8],		64l );
	ParsePatternNoCase( "#?.accpri", SuchExtension[9],		64l );
	ParsePatternNoCase( "#?.boopri", SuchExtension[10],	64l );

	TEXT RexxExtension[11][64];
	ParsePatternNoCase( "#?.adrrexx", RexxExtension[0],	64l );
	ParsePatternNoCase( "#?.cusrexx", RexxExtension[1],	64l );
	ParsePatternNoCase( "#?.emprexx", RexxExtension[2],	64l );
	ParsePatternNoCase( "#?.brarexx", RexxExtension[3],	64l );
	ParsePatternNoCase( "#?.suprexx", RexxExtension[4],	64l );
	ParsePatternNoCase( "#?.artrexx", RexxExtension[5],	64l );
	ParsePatternNoCase( "#?.outrexx", RexxExtension[6],	64l );
	ParsePatternNoCase( "#?.inbrexx", RexxExtension[7],	64l );
	ParsePatternNoCase( "#?.storexx", RexxExtension[8],	64l );
	ParsePatternNoCase( "#?.accrexx", RexxExtension[9],	64l );
	ParsePatternNoCase( "#?.boorexx", RexxExtension[10],	64l );

	for( j = 0; j < 11; j++ )
	{
		LaengeDruDocks[j] = 2;
		DruDockList[j]->EntferneAlle();
	}

	strcpy( Druckpfadplus, MyToolTypesPTR->MTTTVorgaben[10].Wert );
	strcat( Druckpfadplus, "#?pri" );
	MyAnchor->ap_Strlen = 4096;
	MyAnchor->ap_BreakBits = 0;
	i = MatchFirst( Druckpfadplus, MyAnchor );
	while( i == 0 )
	{
		j = -1;
		for(k = 0; (k < 11) && (j == -1); k++)
		{
			if( MatchPatternNoCase( SuchExtension[k], (STRPTR)MyAnchor->ap_Info.fib_FileName ) )
			{
				j = k;
				DruDockList[j]->NeuerNode( MyAnchor->ap_Info.fib_FileName );
				LaengeDruDocks[j] += ( strlen( (const char *)MyAnchor->ap_Info.fib_FileName ) + 1 );
			}
		}
		i = MatchNext( MyAnchor );
	}

	strcpy( Druckpfadplus, MyToolTypesPTR->MTTTVorgaben[15].Wert );
	strcat( Druckpfadplus, "#?rexx" );
	MyAnchor->ap_Strlen = 4096;
	MyAnchor->ap_BreakBits = 0;
	i = MatchFirst( Druckpfadplus, MyAnchor );
	while( i == 0 )
	{
		j = -1;
		for(k = 0; (k < 11) && (j == -1); k++)
		{
			if( MatchPatternNoCase( RexxExtension[k], (STRPTR)MyAnchor->ap_Info.fib_FileName ) )
			{
				j = k;
				DruDockList[j]->NeuerNode( MyAnchor->ap_Info.fib_FileName );
				LaengeDruDocks[j] += ( strlen( (const char *)MyAnchor->ap_Info.fib_FileName ) + 1 );
			}
		}
		i = MatchNext( MyAnchor );
	}

	delete [(sizeof(struct AnchorPath) + 4096)] (STRPTR)MyAnchor;

	for( j = 0; j < 11; DruDockList[j++]->Sort() );

	CycleDruDocksA = new TEXT[(LaengeDruDocks[6])];
	CycleDruDocksA[0] = '-';
	if( DruDockList[6]->Anzahl == 0 )
		CycleDruDocksA[1] = 0;
	else
	{
		CycleDruDocksA[1] = '\n';
		DruDockList[6]->ListToString( &CycleDruDocksA[2] );
	}

	CycleDruDocksE = new TEXT[(LaengeDruDocks[7])];
	CycleDruDocksE[0] = '-';
	if( DruDockList[7]->Anzahl == 0 )
		CycleDruDocksE[1] = 0;
	else
	{
		CycleDruDocksE[1] = '\n';
		DruDockList[7]->ListToString( &CycleDruDocksE[2] );
	}
};

Prefs::~Prefs()
{
	delete ArtGrpList;
	delete ZuAbList;
	delete MWStList;

	for(ULONG i = 0; i < 11; delete DruDockList[i++]);
	delete [(LaengeDruDocks[7])] CycleDruDocksE;
	delete [(LaengeDruDocks[6])] CycleDruDocksA;
};

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

	((PrefsDaten *)InitDaten)->ScreenAutoScroll		= FALSE;
	((PrefsDaten *)InitDaten)->WinPosSave				= TRUE;
	((PrefsDaten *)InitDaten)->Umrechnungskurs		= 1.95583;
	((PrefsDaten *)InitDaten)->Waehrung2_Symbol[0]	= 'E';
	((PrefsDaten *)InitDaten)->Waehrung2_Symbol[1]	= 'U';
	((PrefsDaten *)InitDaten)->Waehrung2_Symbol[2]	= 'R';
	((PrefsDaten *)InitDaten)->Waehrung_KZ				= 1;
	((PrefsDaten *)InitDaten)->SchnellDruckFragen	= TRUE;
	((PrefsDaten *)InitDaten)->Nachkomma				= 3;
	((PrefsDaten *)InitDaten)->Nachkomma_Prozent		= 3;
	((PrefsDaten *)InitDaten)->Nr_Laenge				= 0;
	((PrefsDaten *)InitDaten)->ME_Belegt				= 16;

	for( ULONG i = 0; i < 16; i++ )
	{
		MyAppStringsPTR->GetCycleWert( AppStrings[MSG_ME], ((PrefsDaten *)InitDaten)->ME[i], i );
	}
};

void Prefs::UpdateSatz( STRPTR AlteVersion )
{
	Daten = (PrefsDaten *)UserData;

	if( AlteVersion[1] == '.' ||
		 strncmp(AlteVersion, " 1.04", 5) < 0 )
	{
		if( Daten->ZuAbBelegt == 0)
		{ 
			strcpy(Daten->ZuAbBezeich[0], "Nachlass %");
			Daten->ZuAbTyp[0]				= 5;
			Daten->ZuAbBelegt				= 1;
		}
		for(ULONG i = 0; i < Daten->ZuAbBelegt; i++ )
		{
			if( Daten->ZuAbTyp[i] == 0 ||
				 Daten->ZuAbTyp[i] == 5 )
			{
				Daten->ZuAb_Limit_Von[0]	= 0.0;
				Daten->ZuAb_Limit_Bis[0]	= 99.0;
			}
			else
			{
				Daten->ZuAb_Limit_Von[0]	= 0.0;
				Daten->ZuAb_Limit_Bis[0]	= 999999.0;
			}
		}
	}

	if( AlteVersion[1] == '.' ||
		 strncmp(AlteVersion, " 1.06", 5) < 0 )
		Daten->ME_Belegt						= 16;

};

void Prefs::CyZuAb()
{
	TEXT Buffer[45];

	CycleZuAb[0]	= '-';
	CycleZuAb[1]	= '\n';
	ZuAbList->EntferneAlle();
	for(ULONG i = 0; i < Daten->ZuAbBelegt; i++)
	{
		strcpy((char *)Buffer, (const char *)ZuAbTypText[(Daten->ZuAbTyp[i])]);
		strcat((char *)Buffer, " | ");
		strcat((char *)Buffer, (const char *)Daten->ZuAbBezeich[i]);
		ZuAbList->NeuerNode( Buffer );
	}
	ZuAbList->ListToString( &CycleZuAb[2] );
};

void Prefs::CyArtGrp()
{
	CycleArtGrp[0]	= '-';
	if( Daten->ArtikelGruppeBelegt == 0 )
		CycleArtGrp[1]	= 0;
	else
	{
		CycleArtGrp[1]	= '\n';
		ArtGrpList->EntferneAlle();
		for(ULONG i = 0; i < Daten->ArtikelGruppeBelegt; ArtGrpList->NeuerNode( Daten->ArtikelGruppe[i++] ));
		ArtGrpList->ListToString( &CycleArtGrp[2] );
	}
};

void Prefs::CyMWSt()
{
	ULONG Justi[] = {WZRDPLACE_RIGHT, WZRDPLACE_LEFT};
//	STRPTR Listeintraege[2];
	MWStList->EntferneAlle();
	for(ULONG i = 0; i < 10; i++)
	{
		strcpy((char *)CycleMWSt, (const char *)MWST[i]);
		strcat((char *)CycleMWSt, " ");
		strcat((char *)CycleMWSt, (const char *)Daten->MWSt_Bez[i]);
		MWStList->NeuerNode( CycleMWSt );
//		Listeintraege[0] = MWST[i];
//		Listeintraege[1] = Daten->MWSt_Bez[i];
//		MWStList->NeuerNode( Listeintraege, Justi );
	}
	sprintf( CycleMWSt, "%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s",	MWST[0],
																						MWST[1],
																						MWST[2],
																						MWST[3],
																						MWST[4],
																						MWST[5],
																						MWST[6],
																						MWST[7],
																						MWST[8],
																						MWST[9] );
};

void Prefs::CyMWStPlus()
{
	for(ULONG i = 0; i < 10; i++)
	{
		if( Daten->MWSt[i] < 10 )
		{
			MWST[i][0] = ' ';
			MyLocalePTR->FormatNumber( (STRPTR)&MWST[i][1], Daten->MWSt[i], Daten->Nachkomma_Prozent);
		}
		else
			MyLocalePTR->FormatNumber( (STRPTR)MWST[i], Daten->MWSt[i], Daten->Nachkomma_Prozent);
	}
	CyMWSt();
};

void Prefs::CyME()
{
	if( Daten->ME_Belegt == 0 )
		CycleME[0]	= 0;
	else
	{
		MEList->EntferneAlle();
		for(ULONG i = 0; i < Daten->ME_Belegt; MEList->NeuerNode( Daten->ME[i++] ));
		MEList->ListToString( CycleME );
	}
};

void Prefs::CyKundKat()
{
	CycleKundKat[0]	= '-';
	if( Daten->KundKat_Belegt == 0 )
		CycleKundKat[1]	= 0;
	else
	{
		CycleKundKat[1]	= '\n';
		KundKatList->EntferneAlle();
		for(ULONG i = 0; i < Daten->KundKat_Belegt; KundKatList->NeuerNode( Daten->KundKat[i++] ));
		KundKatList->ListToString( &CycleKundKat[2] );
	}
};

void Prefs::UpDateElement()
{
	ULONG i;

	AltDaten				= (PrefsDaten *)UnDoBuffer[UnDoUsed];

	for( i = 0; i < 6; i++ )
	{
		if( Daten->Umrech_ZuAb[i]		> 0 )
		{
			if( Daten->Umrech_ZuAbWert[i]			< Daten->ZuAb_Limit_Von[(Daten->Umrech_ZuAb[i] - 1)] )
				Daten->Umrech_ZuAbWert[i]			= Daten->ZuAb_Limit_Von[(Daten->Umrech_ZuAb[i] - 1)];
			else if( Daten->Umrech_ZuAbWert[i]	> Daten->ZuAb_Limit_Bis[(Daten->Umrech_ZuAb[i] - 1)] )
				Daten->Umrech_ZuAbWert[i]			= Daten->ZuAb_Limit_Bis[(Daten->Umrech_ZuAb[i] - 1)];
		}
	}

	DataBase::UpDateElement();
	sprintf(CycleWaehrung,	AppStrings[MSG_Waehrung],
									MyLocalePTR->Thislocale->loc_MonIntCS,
									MyLocalePTR->Thislocale->loc_MonIntCS,
									Daten->Waehrung2_Symbol,
									Daten->Waehrung2_Symbol);
	CyMWStPlus();
	CyZuAb();
	CyArtGrp();
	CyME();
	CyKundKat();
};

void Prefs::UnDo()
{
	DataBase::UnDo();
	sprintf(CycleWaehrung,	AppStrings[MSG_Waehrung],
									MyLocalePTR->Thislocale->loc_MonIntCS,
									MyLocalePTR->Thislocale->loc_MonIntCS,
									Daten->Waehrung2_Symbol,
									Daten->Waehrung2_Symbol);
	CyMWStPlus();
	CyZuAb();
	CyArtGrp();
	CyME();
	CyKundKat();
};

void Prefs::ReDo()
{
	DataBase::ReDo();
	sprintf(CycleWaehrung,	AppStrings[MSG_Waehrung],
									MyLocalePTR->Thislocale->loc_MonIntCS,
									MyLocalePTR->Thislocale->loc_MonIntCS,
									Daten->Waehrung2_Symbol,
									Daten->Waehrung2_Symbol);
	CyMWStPlus();
	CyZuAb();
	CyArtGrp();
	CyME();
	CyKundKat();
};


ULONG Prefs::GetRexx(struct RexxMsg *rxmsg, ULONG Position)
{
	ULONG ReturnWert = 0, i;
	TEXT Buffer[80];
	TEXT Buffer2[80];

	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.SCREEN.PUBNAME", (STRPTR)Daten->ScreenPubName, strlen(Daten->ScreenPubName) );

	sprintf(Buffer, "%lu", Daten->ScreenDisplayID);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.SCREEN.DISPLAYID", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->ScreenDisplayDepth);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.SCREEN.DISPLAYDEEPTH", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", Daten->ScreenWidth);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.SCREEN.WIDTH", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", Daten->ScreenHight);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.SCREEN.HIGHT", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->ScreenOverscanType);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.SCREEN.OVERSCANTYPE", (STRPTR)Buffer, strlen(Buffer) );

	Buffer[1] = 0;
	if( Daten->ScreenAutoScroll )
		Buffer[0] = 'Y';
	else
		Buffer[0] = 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.SCREEN.AUTOSCROLL", (STRPTR)Buffer, strlen(Buffer) );

	if( Daten->WinPosSave )
		Buffer[0] = 'Y';
	else
		Buffer[0] = 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.WINPOSSAVE", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->Druckrand_X);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.PRINTOFFSET_X", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->Druckrand_Y);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.PRINTOFFSET_Y", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->AutoBestellen);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.AUTOORDER", (STRPTR)Buffer, strlen(Buffer) );

	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.ORDERFORMULAR", (STRPTR)Daten->Bestelldokument, strlen(Daten->Bestelldokument) );

	sprintf(Buffer, "%lu", (ULONG)Daten->AutoMahnen);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.AUTODUNNING", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->MahnNachTagen[0]);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.DUNAFTERDAYS.0", (STRPTR)Buffer, strlen(Buffer) );
	sprintf(Buffer, "%lu", (ULONG)Daten->MahnNachTagen[1]);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.DUNAFTERDAYS.1", (STRPTR)Buffer, strlen(Buffer) );
	sprintf(Buffer, "%lu", (ULONG)Daten->MahnNachTagen[2]);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.DUNAFTERDAYS.2", (STRPTR)Buffer, strlen(Buffer) );

	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.DUNFORMULAR.0", (STRPTR)Daten->Mahndokument[0], strlen(Daten->Mahndokument[0]) );
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.DUNFORMULAR.1", (STRPTR)Daten->Mahndokument[1], strlen(Daten->Mahndokument[1]) );
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.DUNFORMULAR.2", (STRPTR)Daten->Mahndokument[2], strlen(Daten->Mahndokument[2]) );

	for( i = 0; i < 10; i++ )
	{
		// Mehrwertsteuer-Prozentsatz
		sprintf(Buffer2, "PREFS.VALUEPERCENT.%lu", i);
		sprintf(Buffer, "%f", Daten->MWSt[i]);
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (STRPTR)Buffer, strlen(Buffer) );

		// Mehrwertsteuer-Typ								(V1.04)
		sprintf(Buffer2, "PREFS.VALUETYPE.%lu", i);
		Buffer[0] = '0' + Daten->MWSt_Typ[i];
		Buffer[1] = 0;
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (STRPTR)Buffer, strlen(Buffer) );

		// Mehrwertsteuer-Bezeichnung						(V1.04)
		sprintf(Buffer2, "PREFS.VALUENAME.%lu", i);
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (STRPTR)Daten->MWSt_Bez[i], strlen(Daten->MWSt_Bez[i]) );

		// Mehrwertsteuer Konto für Vorsteuer			(V1.04)
		sprintf(Buffer2, "PREFS.VALUEACCOUNT_IN.%lu", i);
		sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(Daten->MWSt_Konto_VSt[i]));
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (STRPTR)Buffer, strlen(Buffer) );

		// Mehrwertsteuer Konto für Umsatzsteuer		(V1.04)
		sprintf(Buffer2, "PREFS.VALUEACCOUNT_OUT.%lu", i);
		sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(Daten->MWSt_Konto_USt[i]));
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (STRPTR)Buffer, strlen(Buffer) );
	}

	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.CURRENCYSYMBOL", (STRPTR)Daten->Waehrung2_Symbol, strlen(Daten->Waehrung2_Symbol) );

	sprintf(Buffer, "%f", Daten->Umrechnungskurs);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.CONVERSIONFACTOR", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->Waehrung_KZ);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.CURRENCY_USED", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->ARechArt);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.OUTBILL_ART", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->ERechArt);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.INBILL_ART", (STRPTR)Buffer, strlen(Buffer) );

	ReturnWert += MyARexx.RexxBetrag2( "PREFS.CREDITLIMIT", Daten->KreditLimit, Daten->Waehrung_KZ );

	Buffer[1] = 0;
	if( Daten->SchnellDruckFragen )
		Buffer[0] = 'Y';
	else
		Buffer[0] = 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.ASK_FASTPRINT", (STRPTR)Buffer, 1 );

	if( Daten->Jahr_vier )
		Buffer[0] = 'Y';
	else
		Buffer[0] = 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.YEAR_4DIGIT", (STRPTR)Buffer, 1 );

	sprintf(Buffer, "%lu", (ULONG)Daten->Nachkomma);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.FRAC_DIGITS", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->Nachkomma_Prozent);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.FRAC_DIGITS_PERCENT", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->Nr_Laenge);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.NUMBER_DIGITS", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->KundNr);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.CLIENT_CODE", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->ZuAbBelegt);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.ADD_RED_USED", (STRPTR)Buffer, strlen(Buffer) );

	for( i = 0; i < 50; i++ )
	{
		sprintf(Buffer2, "PREFS.ADD_RED_TEXT.%lu", i);
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (STRPTR)Daten->ZuAbBezeich[i], strlen(Daten->ZuAbBezeich[i]) );

		sprintf(Buffer2, "PREFS.ADD_RED_TYPE.%lu", i);
		sprintf(Buffer, "%lu", Daten->ZuAbTyp[i]);
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (STRPTR)Buffer, strlen(Buffer) );

		// Zu-Abschlags Buchungskonto Eingänge (V1.04)
		sprintf(Buffer2, "PREFS.ACCOUNT_ADD_RED_IN.%lu", i);
		sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(Daten->Konto_ZuAb_Ein[i]));
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (STRPTR)Buffer, strlen(Buffer) );

		// Zu-Abschlags Buchungskonto Ausgänge (V1.04)
		sprintf(Buffer2, "PREFS.ACCOUNT_ADD_RED_OUT.%lu", i);
		sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(Daten->Konto_ZuAb_Aus[i]));
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (STRPTR)Buffer, strlen(Buffer) );

		// Zu-Abschlags unteres Limit (V1.04)
		sprintf(Buffer2, "PREFS.ADD_RED_LIMIT_FROM.%lu", i);
		sprintf(Buffer, "%f", Daten->ZuAb_Limit_Von[i]);
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (STRPTR)Buffer, strlen(Buffer) );

		// Zu-Abschlags oberes Limit (V1.04)
		sprintf(Buffer2, "PREFS.ADD_RED_LIMIT_TO.%lu", i);
		sprintf(Buffer, "%f", Daten->ZuAb_Limit_Bis[i]);
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (STRPTR)Buffer, strlen(Buffer) );
	}

	sprintf(Buffer, "%u", Daten->ArtikelGruppeBelegt);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.ARTICLE_GROUP_USED", (STRPTR)Buffer, strlen(Buffer) );

	// Anzahl belegter Kundenkathegorien (V1.06)
	sprintf(Buffer, "%u", Daten->KundKat_Belegt);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.CUSTOMER_GROUP_USED", (STRPTR)Buffer, strlen(Buffer) );

	for( i = 0; i < 100; i++ )
	{
		sprintf(Buffer2, "PREFS.ARTICLE_GROUP.%lu", i);
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (STRPTR)Daten->ArtikelGruppe[i], strlen(Daten->ArtikelGruppe[i]) );

		// KundenKathegorie (V1.06)
		sprintf(Buffer2, "PREFS.CUSTOMER_GROUP.%lu", i);
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (STRPTR)Daten->KundKat[i], strlen(Daten->KundKat[i]) );
	}

	Buffer[1]		= 0;
	if( Daten->Umrech_KH )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.CALC_CT", (STRPTR)Buffer, 1 );

	if( Daten->Umrech_KL )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.CALC_CS", (STRPTR)Buffer, 1 );

	if( Daten->Umrech_HK )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.CALC_TC", (STRPTR)Buffer, 1 );

	if( Daten->Umrech_HL )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.CALC_TS", (STRPTR)Buffer, 1 );

	if( Daten->Umrech_LK )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.CALC_SC", (STRPTR)Buffer, 1 );

	if( Daten->Umrech_LH )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.CALC_ST", (STRPTR)Buffer, 1 );

	if( Daten->Umrech_Runden[0] )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.CALC_ROUND_S", (STRPTR)Buffer, 1 );

	if( Daten->Umrech_Runden[1] )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.CALC_ROUND_T", (STRPTR)Buffer, 1 );

	if( Daten->Umrech_Runden[2] )
		Buffer[0]	= 'Y';
	else
		Buffer[0]	= 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.CALC_ROUND_C", (STRPTR)Buffer, 1 );

	// Negative Bestände erlauben?										(V1.07)
	if( Daten->NegativBestand )
		Buffer[0] = 'Y';
	else
		Buffer[0] = 'N';
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.NEGSTOCK", (STRPTR)Buffer, 1 );

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

	ReturnWert += MyARexx.RexxBetrag( "PREFS.CALC_ROUND_FROM", Daten->Umrech_RundenVon[0], Daten->Umrech_RundenVon[1], Daten->Umrech_RundenVon[2], Daten->Umrech_RundenVon[3] );

	ReturnWert += MyARexx.RexxBetrag( "PREFS.CALC_ROUND_TO", Daten->Umrech_RundenBis[0], Daten->Umrech_RundenBis[1], Daten->Umrech_RundenBis[2], Daten->Umrech_RundenBis[3] );

	ReturnWert += MyARexx.RexxBetrag( "PREFS.CALC_ROUND_NEW", Daten->Umrech_RundenZu[0], Daten->Umrech_RundenZu[1], Daten->Umrech_RundenZu[2], Daten->Umrech_RundenZu[3] );

	sprintf(Buffer, "%lu", (ULONG)Daten->MWSt_Versand_E);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.DISPATCH_VALUE_IN", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->MWSt_Zusatz_E);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.ADDITION_VALUE_IN", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->MWSt_Versand_A);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.DISPATCH_VALUE_OUT", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->MWSt_Zusatz_A);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.ADDITION_VALUE_OUT", (STRPTR)Buffer, strlen(Buffer) );

	sprintf(Buffer, "%lu", (ULONG)Daten->MWSt_Artikel);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.ARTICLE_VALUE", (STRPTR)Buffer, strlen(Buffer) );

	// Buchungskonto Versandkosten Eingangsbelege					(V1.04)
	sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(Daten->Konto_Versand_Ein));
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)"PREFS.ACCOUNT_DISP_IN", (STRPTR)Buffer, strlen(Buffer) );

	// Buchungskonto Versandzusatzkosten Eingangsbelege			(V1.04)
	sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(Daten->Konto_Zusatz_Ein));
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)"PREFS.ACCOUNT_ADD_IN", (STRPTR)Buffer, strlen(Buffer) );

	// Buchungskonto für die Zahlung von Eingangsbelegen			(V1.04)
	sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(Daten->Konto_Zahlung_Ein));
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)"PREFS.ACCOUNT_PAY_IN", (STRPTR)Buffer, strlen(Buffer) );

	// Buchungskonto für Abschreibungen bei Eingangsbelegen		(V1.04)
	sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(Daten->Konto_Abgeschrieben_Ein));
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)"PREFS.ACCOUNT_WOFF_IN", (STRPTR)Buffer, strlen(Buffer) );

	// Buchungskonto für Skonto bei Eingangsbelegen					(V1.04)
	sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(Daten->Konto_Skonto_Ein));
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)"PREFS.ACCOUNT_DISCOUNT_IN", (STRPTR)Buffer, strlen(Buffer) );

	// Buchungskonto Versandkosten Ausgangsbelege					(V1.04)
	sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(Daten->Konto_Versand_Aus));
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)"PREFS.ACCOUNT_DISP_OUT", (STRPTR)Buffer, strlen(Buffer) );

	// Buchungskonto für die Zahlung von Ausgangsbelegen			(V1.04)
	sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(Daten->Konto_Zahlung_Aus));
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)"PREFS.ACCOUNT_PAY_OUT", (STRPTR)Buffer, strlen(Buffer) );

	// Buchungskonto für Abschreibungen bei Ausgangsbelegen		(V1.04)
	sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(Daten->Konto_Abgeschrieben_Aus));
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)"PREFS.ACCOUNT_WOFF_OUT", (STRPTR)Buffer, strlen(Buffer) );

	// Buchungskonto für Skonto bei Ausgangsbelegen					(V1.04)
	sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(Daten->Konto_Skonto_Aus));
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)"PREFS.ACCOUNT_DISCOUNT_OUT", (STRPTR)Buffer, strlen(Buffer) );

	// Buchungskonto für Währungsdifferenzen							(V1.04)
	sprintf(Buffer, "%u", MyKontenPosPTR->ToCycle(Daten->Konto_Waehr_Diff));
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)"PREFS.ACCOUNT_CURRENCY_DIFF", (STRPTR)Buffer, strlen(Buffer) );

	// Anzahl belegter Mengeneinheiten									(V1.06)
	sprintf(Buffer, "%u", Daten->ME_Belegt);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.QUANTITY_UNIT_USED", (STRPTR)Buffer, strlen(Buffer) );

	for( i = 0; i < 30; i++ )
	{
		// Mengeneinheiten													(V1.06)
		sprintf(Buffer2, "PREFS.QUANTITY_UNIT.%lu", i);
		ReturnWert += SetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (STRPTR)Daten->ME[i], strlen(Daten->ME[i]) );
	}

	// Formularvorlage für das Kassenmodul                      (V1.06)
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.TILL_FORMULAR", (STRPTR)Daten->Kassenbon, strlen(Daten->Kassenbon) );

	// Zusatztext für den Druck aus dem Kassenmodul             (V1.06)
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.TILL_TEXT", (STRPTR)Daten->Kassentext, strlen(Daten->Kassentext) );

	// Pseudoversandart fürs Kassenmodul								(V1.06)
	sprintf(Buffer, "%u", Daten->KassenVersandart);
	ReturnWert += SetRexxVar( (struct Message *)rxmsg, "PREFS.TILL_DISPATCH", (STRPTR)Buffer, strlen(Buffer) );



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

ULONG Prefs::SetRexx(struct RexxMsg *rxmsg, ULONG Position)
{
	ULONG ReturnWert = 0, i;
	
	ULONG k = MyKontenPosPTR->AnzCyclePos;

	STRPTR Buffer;
	TEXT Buffer2[80];

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "PREFS.SCREEN.PUBNAME", (UBYTE **)&Buffer );
	strncpy( Daten->ScreenPubName, Buffer, 29);

	Daten->ScreenDisplayID		= MyARexx.GetRexxLong("PREFS.SCREEN.DISPLAYID", 0, LONG_MAX);

	Daten->ScreenDisplayDepth	= MyARexx.GetRexxLong("PREFS.SCREEN.DISPLAYDEEPTH", 0, USHRT_MAX);

	Daten->ScreenWidth			= MyARexx.GetRexxLong("PREFS.SCREEN.WIDTH", 0, LONG_MAX);

	Daten->ScreenHight			= MyARexx.GetRexxLong("PREFS.SCREEN.HIGHT", 0, LONG_MAX);

	Daten->ScreenOverscanType	= MyARexx.GetRexxLong("PREFS.SCREEN.OVERSCANTYPE", 0, USHRT_MAX);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "PREFS.SCREEN.AUTOSCROLL", (UBYTE **)&Buffer );
	Daten->ScreenAutoScroll		= (*Buffer == 'y' || *Buffer == 'Y');

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

	Daten->Druckrand_X			= MyARexx.GetRexxLong("PREFS.PRINTOFFSET_X", 0, LONG_MAX);

	Daten->Druckrand_Y			= MyARexx.GetRexxLong("PREFS.PRINTOFFSET_Y", 0, LONG_MAX);

	Daten->AutoBestellen			= MyARexx.GetRexxLong("PREFS.AUTOORDER", 0, 2);

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

	Daten->AutoMahnen				= MyARexx.GetRexxLong("PREFS.AUTODUNNING", 0, 2);

	Daten->MahnNachTagen[0]		= MyARexx.GetRexxLong("PREFS.DUNAFTERDAYS.0", 0, USHRT_MAX);
	Daten->MahnNachTagen[1]		= MyARexx.GetRexxLong("PREFS.DUNAFTERDAYS.1", 0, USHRT_MAX);
	Daten->MahnNachTagen[2]		= MyARexx.GetRexxLong("PREFS.DUNAFTERDAYS.2", 0, USHRT_MAX);

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "PREFS.DUNFORMULAR.0", (UBYTE **)&Buffer );
	strncpy( Daten->Mahndokument[0], Buffer, 29);
	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "PREFS.DUNFORMULAR.1", (UBYTE **)&Buffer );
	strncpy( Daten->Mahndokument[1], Buffer, 29);
	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "PREFS.DUNFORMULAR.2", (UBYTE **)&Buffer );
	strncpy( Daten->Mahndokument[2], Buffer, 29);

	for( i = 0; i < 10; i++ )
	{
		sprintf(Buffer2, "PREFS.VALUEPERCENT.%lu", i);
		ReturnWert += GetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (UBYTE **)&Buffer );
		Daten->MWSt[i]			= atof(Buffer);

		// Mehrwertsteuer-Typ								(V1.04)
		sprintf(Buffer2, "PREFS.VALUETYPE.%lu", i);
		Daten->MWSt_Typ[i]		= MyARexx.GetRexxLong(Buffer2, 0, 1);

		// Mehrwertsteuer-Bezeichnung						(V1.04)
		sprintf(Buffer2, "PREFS.VALUENAME.%lu", i);
		ReturnWert += GetRexxVar( (struct Message *)rxmsg, (STRPTR)Buffer2, (UBYTE **)&Buffer );
		strncpy( Daten->MWSt_Bez[i], Buffer, 39);

		// Mehrwertsteuer Konto für Vorsteuer			(V1.04)
		sprintf(Buffer2, "PREFS.VALUEACCOUNT_IN.%lu", i);
		Daten->MWSt_Konto_VSt[i]	= MyKontenPosPTR->FromCycle(MyARexx.GetRexxLong(Buffer2, 0, k));

		// Mehrwertsteuer Konto für Umsatzsteuer		(V1.04)
		sprintf(Buffer2, "PREFS.VALUEACCOUNT_OUT.%lu", i);
		Daten->MWSt_Konto_USt[i]	= MyKontenPosPTR->FromCycle(MyARexx.GetRexxLong(Buffer2, 0, k));
	}

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

	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "PREFS.CONVERSIONFACTOR", (UBYTE **)&Buffer );
	Daten->Umrechnungskurs = atof(Buffer);
	if( Daten->Umrechnungskurs == 0 )
		Daten->Umrechnungskurs = 1;

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

	Daten->ARechArt		= MyARexx.GetRexxLong("PREFS.OUTBILL_ART", 0, 2);
	Daten->ERechArt		= MyARexx.GetRexxLong("PREFS.INBILL_ART", 0, 3);

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

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

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

	Daten->Nachkomma				= MyARexx.GetRexxLong("PREFS.FRAC_DIGITS", 0, 9);
	Daten->Nachkomma_Prozent	= MyARexx.GetRexxLong("PREFS.FRAC_DIGITS_PERCENT", 0, 9);
	Daten->Nr_Laenge				= MyARexx.GetRexxLong("PREFS.NUMBER_DIGITS", 0, 12);

	Daten->KundNr					= MyARexx.GetRexxLong("PREFS.CLIENT_CODE", 0, 1);
	Daten->ZuAbBelegt				= MyARexx.GetRexxLong("PREFS.ADD_RED_USED", 0, 50);

	for( i = 0; i < 50; i++ )
	{
		sprintf(Buffer2, "PREFS.ADD_RED_TEXT.%lu", i);
		ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
		strncpy( Daten->ZuAbBezeich[i], Buffer, 39);

		sprintf(Buffer2, "PREFS.ADD_RED_TYPE.%lu", i);
		Daten->ZuAbTyp[i]			= MyARexx.GetRexxLong(Buffer2, 0, 9);

		// Zu-Abschlags Buchungskonto Eingänge (V1.04)
		sprintf(Buffer2, "PREFS.ACCOUNT_ADD_RED_IN.%lu", i);
		Daten->Konto_ZuAb_Ein[i]	= MyKontenPosPTR->FromCycle(MyARexx.GetRexxLong(Buffer2, 0, k));

		// Zu-Abschlags Buchungskonto Ausgänge (V1.04)
		sprintf(Buffer2, "PREFS.ACCOUNT_ADD_RED_OUT.%lu", i);
		Daten->Konto_ZuAb_Aus[i]	= MyKontenPosPTR->FromCycle(MyARexx.GetRexxLong(Buffer2, 0, k));

		// Zu-Abschlags unteres Limit (V1.04)
		sprintf(Buffer2, "PREFS.ADD_RED_LIMIT_FROM.%lu", i);
		ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
		Daten->ZuAb_Limit_Von[i]	= atof( Buffer );

		// Zu-Abschlags oberes Limit (V1.04)
		sprintf(Buffer2, "PREFS.ADD_RED_LIMIT_TO.%lu", i);
		ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
		Daten->ZuAb_Limit_Bis[i]	= atof( Buffer );
	}

	Daten->ArtikelGruppeBelegt	= MyARexx.GetRexxLong("PREFS.ARTICLE_GROUP_USED", 0, 100);

	for( i = 0; i < Daten->ArtikelGruppeBelegt; i++ )
	{
		sprintf(Buffer2, "PREFS.ARTICLE_GROUP.%lu", i);
		ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
		strncpy( Daten->ArtikelGruppe[i], Buffer, 19);
	}

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

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

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

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

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

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

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

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

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

	// Negative Bestände erlauben?										(V1.07)
	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "PREFS.NEGSTOCK", (UBYTE **)&Buffer );
	Daten->NegativBestand	= (*Buffer == 'y' || *Buffer == 'Y');

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

		sprintf(Buffer2, "PREFS.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, "PREFS.CALC_ROUND_FROM.%lu", i );
		ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
		Daten->Umrech_RundenVon[i]	= atof( Buffer );

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

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

	Daten->MWSt_Versand_E		= MyARexx.GetRexxLong("PREFS.DISPATCH_VALUE_IN", 0, 9);
	Daten->MWSt_Zusatz_E			= MyARexx.GetRexxLong("PREFS.ADDITION_VALUE_IN", 0, 9);
	Daten->MWSt_Versand_A		= MyARexx.GetRexxLong("PREFS.DISPATCH_VALUE_OUT", 0, 9);
	Daten->MWSt_Zusatz_A			= MyARexx.GetRexxLong("PREFS.ADDITION_VALUE_OUT", 0, 9);
	Daten->MWSt_Artikel			= MyARexx.GetRexxLong("PREFS.ARTICLE_VALUE", 0, 9);

	// Buchungskonto Versandkosten Eingangsbelege					(V1.04)
	Daten->Konto_Versand_Ein	= MyKontenPosPTR->FromCycle(MyARexx.GetRexxLong("PREFS.ACCOUNT_DISP_IN", 0, k));

	// Buchungskonto Versandzusatzkosten Eingangsbelege			(V1.04)
	Daten->Konto_Zusatz_Ein		= MyKontenPosPTR->FromCycle(MyARexx.GetRexxLong("PREFS.ACCOUNT_ADD_IN", 0, k));

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

	// Buchungskonto für Abschreibungen bei Eingangsbelegen		(V1.04)
	Daten->Konto_Abgeschrieben_Ein	= MyKontenPosPTR->FromCycle(MyARexx.GetRexxLong("PREFS.ACCOUNT_WOFF_IN", 0, k));

	// Buchungskonto für Skonto bei Eingangsbelegen					(V1.04)
	Daten->Konto_Skonto_Ein		= MyKontenPosPTR->FromCycle(MyARexx.GetRexxLong("PREFS.ACCOUNT_DISCOUNT_IN", 0, k));

	// Buchungskonto Versandkosten Ausgangsbelege					(V1.04)
	Daten->Konto_Versand_Aus	= MyKontenPosPTR->FromCycle(MyARexx.GetRexxLong("PREFS.ACCOUNT_DISP_OUT", 0, k));

	// Buchungskonto für die Zahlung von Ausgangsbelegen			(V1.04)
	Daten->Konto_Zahlung_Aus	= MyKontenPosPTR->FromCycle(MyARexx.GetRexxLong("PREFS.ACCOUNT_PAY_OUT", 0, k));

	// Buchungskonto für Abschreibungen bei Ausgangsbelegen		(V1.04)
	Daten->Konto_Abgeschrieben_Aus	= MyKontenPosPTR->FromCycle(MyARexx.GetRexxLong("PREFS.ACCOUNT_WOFF_OUT", 0, k));

	// Buchungskonto für Skonto bei Ausgangsbelegen					(V1.04)
	Daten->Konto_Skonto_Aus		= MyKontenPosPTR->FromCycle(MyARexx.GetRexxLong("PREFS.ACCOUNT_DISCOUNT_OUT", 0, k));

	// Buchungskonto für Währungsdifferenzen							(V1.04)
	Daten->Konto_Waehr_Diff		= MyKontenPosPTR->FromCycle(MyARexx.GetRexxLong("PREFS.ACCOUNT_CURRENCY_DIFF", 0, k));

	// Anzahl belegter Mengeneinheiten									(V1.06)
	Daten->ME_Belegt				= MyARexx.GetRexxLong("PREFS.QUANTITY_UNIT_USED", 0, 30);

	for( i = 0; i < Daten->ME_Belegt; i++ )
	{
		// Mengeneinheiten													(V1.06)
		sprintf(Buffer2, "PREFS.QUANTITY_UNIT.%lu", i);
		ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
		strncpy( Daten->ME[i], Buffer, 14);
	}

	// Anzahl belegter Kundenkathegorien								(V1.06)
	Daten->KundKat_Belegt		= MyARexx.GetRexxLong("PREFS.CUSTOMER_GROUP_USED", 0, 100);

	for( i = 0; i < Daten->KundKat_Belegt; i++ )
	{
		// KundenKathegorie													(V1.06)
		sprintf(Buffer2, "PREFS.CUSTOMER_GROUP.%lu", i);
		ReturnWert += GetRexxVar( (struct Message *)rxmsg, Buffer2, (UBYTE **)&Buffer );
		strncpy( Daten->KundKat[i], Buffer, 14);
	}

	// Formularvorlage für das Kassenmodul                      (V1.06)
	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "PREFS.TILL_FORMULAR", (UBYTE **)&Buffer );
	strncpy( Daten->Kassenbon, Buffer, 31);

	// Zusatztext für den Druck aus dem Kassenmodul             (V1.06)
	ReturnWert += GetRexxVar( (struct Message *)rxmsg, "PREFS.TILL_TEXT", (UBYTE **)&Buffer );
	strncpy( Daten->Kassentext, Buffer, 159);

	// Pseudoversandart fürs Kassenmodul								(V1.06)
	Daten->KassenVersandart = MyARexx.GetRexxLong("PREFS.TILL_DISPATCH", 0, LONG_MAX);



	UpDateElement();

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


DOUBLE Prefs::WaehrungUmrechnen( DOUBLE MWSt, DOUBLE Betrag_alt, UBYTE Waehrung_alt, UBYTE Waehrung_neu, UBYTE MWSt_Typ)
{
	DOUBLE Betrag_neu, MWStRech;

	if( MWSt_Typ	== 1 )
	{
		if( MWSt		>= 100.0 )
			MWSt		= 99;
		MWStRech		= 1.0 / (1.0 - (MWSt / 100.0));
	}
	else
		MWStRech		= 1.0 + (MWSt / 100.0);

	switch( Waehrung_alt )
	{
		case 0:
			switch( Waehrung_neu )
			{
				case 0:
					Betrag_neu = Betrag_alt;
					break;
				case 1:
					Betrag_neu = Betrag_alt * MWStRech;
					break;
				case 2:
					Betrag_neu = Betrag_alt / Daten->Umrechnungskurs;
					break;
				case 3:
					Betrag_neu = (Betrag_alt * MWStRech) / Daten->Umrechnungskurs;
					break
			}
			break;
		case 1:
			switch( Waehrung_neu )
			{
				case 0:
					Betrag_neu = Betrag_alt / MWStRech;
					break;
				case 1:
					Betrag_neu = Betrag_alt;
					break;
				case 2:
					Betrag_neu = (Betrag_alt / MWStRech) / Daten->Umrechnungskurs;
					break;
				case 3:
					Betrag_neu = Betrag_alt / Daten->Umrechnungskurs;
					break;
			}
			break;
		case 2:
			switch( Waehrung_neu )
			{
				case 0:
					Betrag_neu = Betrag_alt * Daten->Umrechnungskurs;
					break;
				case 1:
					Betrag_neu = (Betrag_alt * MWStRech) * Daten->Umrechnungskurs;
					break;
				case 2:
					Betrag_neu = Betrag_alt;
					break;
				case 3:
					Betrag_neu = Betrag_alt * MWStRech;
					break
			}
			break;
		case 3:
			switch( Waehrung_neu )
			{
				case 0:
					Betrag_neu = (Betrag_alt / MWStRech) * Daten->Umrechnungskurs;
					break;
				case 1:
					Betrag_neu = Betrag_alt * Daten->Umrechnungskurs;
					break;
				case 2:
					Betrag_neu = Betrag_alt / MWStRech;
					break;
				case 3:
					Betrag_neu = Betrag_alt;
					break;
			}
			break;
	}

	return Betrag_neu;
};