/* Menu_ViewCharge
 * Dieses Menu öffnet ein Fenster, in dem
 * die Gebühren aller Geräte angezeigt werden
 */
void	Menu_ViewCharge(void);

/* Menu_Save
 * Speichert die aktuelle Konfiguration in eine Datei ab
 */
void	Menu_Save(void);

/* Menu_Load
 * Ladet eine Konfiguration aus einer Datei ein
 * Rueckgabewert = TRUE=Laden war erfolgreich
 */
BOOL	Menu_Load(void);

/* ICConfigReset
 * Setzt alle internen Konfigurationen wieder auf den Zustand
 * zurueck, der auch nach einem Anlagenreset vorliegen wuerde
 */
void	ICConfigReset(void);






#define	ID_ISTC			MAKE_ID('I', 'S', 'T', 'C')
#define	ID_ICVR			MAKE_ID('I', 'C', 'V', 'R')
#define	ID_BASE			MAKE_ID('B', 'A', 'S', 'E')
#define	ID_DEV0			MAKE_ID('D', 'E', 'V', '0')
#define	ID_SN00			MAKE_ID('S', 'N', '0', '0')
#define	ID_ANNO			MAKE_ID('A', 'N', 'N', 'O')

/* Menu_ViewCharge
 * Dieses Menu öffnet ein Fenster, in dem
 * die Gebühren aller Geräte angezeigt werden
 */
void	Menu_ViewCharge(void)
{
struct	LayoutHandle	*Handle;
int	n;
	if(Handle = LT_CreateHandleTags(NULL, LH_AutoActivate, FALSE, TAG_DONE))
	{
	struct	Window	*Window;
	BOOL					 done = FALSE;
	char					 ChargeText[12][50];
	STRPTR				 ChargeLabels[13];
	int					 Summe = 0;
	char					 WinTitle[] = PRGNAME ": Gebühren";

		sprintf(ChargeText[0], " Gerät     Einh.    Betrag");
		sprintf(ChargeText[1], "--------------------------");
		for(n = 0 ; n < 8 ; n++)
		{
		int	Charge = IC_Charge.Charge[n];
			Summe += Charge;
			sprintf(ChargeText[n + 2], "%10s  %4ld  %3ld.%02ldDM", IC_DeviceNames.Names[n], Charge, Charge * PrgConfig.UnitCost / 100, Charge * PrgConfig.UnitCost % 100);
		}
		sprintf(ChargeText[10], "--------------------------");
		sprintf(ChargeText[11], "Gesamt:   %4ld  %3ld.%02ldDM", Summe, Summe * PrgConfig.UnitCost / 100, Summe * PrgConfig.UnitCost % 100);
		for(n = 0 ; n < 12 ; n++)
			ChargeLabels[n] = ChargeText[n];
		ChargeLabels[n] = NULL;
		LT_New(Handle, LA_Type, VERTICAL_KIND, TAG_DONE);
			LT_New(Handle,
				LA_Type,			BOX_KIND,
				LABX_Lines,		ChargeLabels,
				TAG_DONE);
			LT_New(Handle, LA_Type, XBAR_KIND, LAXB_FullSize, TRUE);
			LT_New(Handle, LA_Type, HORIZONTAL_KIND, TAG_DONE);
				LT_New(Handle, LA_Type, BUTTON_KIND, LA_LabelText, "Beenden", LA_ID, GAD_Cancel, TAG_DONE);
			LT_EndGroup(Handle);
		LT_EndGroup(Handle);

		if(Window = LT_Build(Handle,
									LAWN_Title,			WinTitle,
									LAWN_IDCMP,			IDCMP_CLOSEWINDOW|IDCMP_GADGETDOWN|IDCMP_GADGETUP|IDCMP_RAWKEY|IDCMP_REFRESHWINDOW,
									LAWN_Zoom,			TRUE,
									LAWN_SmartZoom,	TRUE,
									WA_CloseGadget,	TRUE,
									WA_DragBar,			TRUE,
									WA_Activate,		TRUE,
									WA_DepthGadget,	TRUE,
									TAG_DONE))
		do
		{
			WaitPort(Window -> UserPort);
			while(Message = GT_GetIMsg(Window->UserPort))
			{
				MsgClass			= Message->Class;
				MsgCode			= Message->Code;
				MsgQualifier	= Message->Qualifier;
				MsgGadget		= Message->IAddress;

				GT_ReplyIMsg(Message);
				LT_HandleInput(Handle, MsgQualifier, &MsgClass, &MsgCode, &MsgGadget);

				switch(MsgClass)
				{
					case	IDCMP_CLOSEWINDOW:
						done = TRUE;
						break;
					case	IDCMP_GADGETUP:
						switch(MsgGadget->GadgetID)
						{
							case	GAD_Cancel:
								done = TRUE;
							break;
						}
						break;
				}
			}
		}
		while(!done);

		LT_DeleteHandle(Handle);
	}
}

/* Menu_Save
 * Speichert die aktuelle Konfiguration in eine Datei ab
 */
void	Menu_Save(void)
{
struct	IFFHandle	*iff = NULL;
UWORD		Versions[10]; /* Versionen für Basis, Endgeräte, Kurzwahlen, offen, offen, ... */
int		i;
ULONG		id;
struct	LayoutHandle	*ThisHandle;
char		gad_Anno[80];
char		gad_FName[256];
BOOL		save = FALSE;
BOOL		savebase = TRUE, savedev = IC_Loaded.DevConfig, saveruf = IC_Loaded.RufConfig;


	for(i = 0 ; i < 10 ; i++)
		Versions[i] = 9999;

	strcpy(gad_Anno, "");
	strcpy(gad_FName, ".uic");

	if(ThisHandle = LT_CreateHandleTags(NULL, TAG_DONE))
	{
	struct	Window	*Window;
	BOOL					 done = FALSE;
	char					 WinTitle[] = PRGNAME ": Anlagenkonfiguration speichern...";

		LT_New(ThisHandle, LA_Type, VERTICAL_KIND, TAG_DONE);
			LT_New(ThisHandle, LA_Type, VERTICAL_KIND, LAGR_Frame, TRUE, LA_LabelText, "Folgende Konfiguration(en) werden gespeichert", TAG_DONE);
				LT_New(ThisHandle, LA_Type, CHECKBOX_KIND, LA_LabelText, "Anlagenkonfiguration:",		GTCB_Checked, savebase, LA_BOOL, &savebase, TAG_DONE);
				LT_New(ThisHandle, LA_Type, CHECKBOX_KIND, LA_LabelText, "Endgerätekonfiguration:",	GTCB_Checked, savedev,  LA_BOOL, &savedev,  TAG_DONE);
				LT_New(ThisHandle, LA_Type, CHECKBOX_KIND, LA_LabelText, "Kurzwahlverzeichnis:",		GTCB_Checked, saveruf,  LA_BOOL, &saveruf,  TAG_DONE);
			LT_EndGroup(ThisHandle);
			LT_New(ThisHandle, LA_Type, VERTICAL_KIND, TAG_DONE);
				LT_New(ThisHandle, LA_Type, STRING_KIND, LA_ID, 10, LA_Chars, 61, GTST_MaxChars, 60, GTST_String, gad_Anno, LA_LabelText, "Anmerkung:", LA_STRPTR, gad_Anno, TAG_DONE);
				LT_New(ThisHandle, LA_Type, XBAR_KIND, TAG_DONE);
				LT_New(ThisHandle, LA_Type, STRING_KIND, LA_ID, 20, LA_Chars, 58, GTST_MaxChars, 250, GTST_String, gad_Anno, LA_LabelText, "_Datei:", LAST_Picker, TRUE, LA_STRPTR, gad_FName, TAG_DONE);
			LT_EndGroup(ThisHandle);
				LT_New(ThisHandle, LA_Type, XBAR_KIND, LAXB_FullSize, TRUE, TAG_DONE);
			LT_New(ThisHandle, LA_Type, HORIZONTAL_KIND, LAGR_SameSize, TRUE, LAGR_Spread, TRUE, TAG_DONE);
				LT_New(ThisHandle, LA_Type, BUTTON_KIND, LA_ID, GAD_Save, LA_LabelText, "Speichern", LA_ExtraFat, TRUE, LABT_ReturnKey, TRUE, TAG_DONE);
				LT_New(ThisHandle, LA_Type, BUTTON_KIND, LA_ID, GAD_Cancel, LA_LabelText, "Abbrechen", LA_ExtraFat, TRUE, LABT_EscKey, TRUE, TAG_DONE);
			LT_EndGroup(ThisHandle);
		LT_EndGroup(ThisHandle);

		if(Window = LT_Build(ThisHandle,
									LAWN_Title,			WinTitle,
									LAWN_IDCMP,			IDCMP_CLOSEWINDOW|IDCMP_GADGETDOWN|IDCMP_GADGETUP|IDCMP_RAWKEY|IDCMP_REFRESHWINDOW,
									LAWN_Zoom,			TRUE,
									LAWN_SmartZoom,	TRUE,
									WA_CloseGadget,	TRUE,
									WA_DragBar,			TRUE,
									WA_Activate,		TRUE,
									WA_DepthGadget,	TRUE,
									TAG_DONE))
		do
		{
			WaitPort(Window -> UserPort);
			while(Message = GT_GetIMsg(Window->UserPort))
			{
				MsgClass			= Message->Class;
				MsgCode			= Message->Code;
				MsgQualifier	= Message->Qualifier;
				MsgGadget		= Message->IAddress;

				GT_ReplyIMsg(Message);
				LT_HandleInput(ThisHandle, MsgQualifier, &MsgClass, &MsgCode, &MsgGadget);

				switch(MsgClass)
				{
					case	IDCMP_CLOSEWINDOW:
						done = TRUE;
						break;
					case	IDCMP_GADGETUP:
						switch(MsgGadget->GadgetID)
						{
							case	GAD_Save:
								save = TRUE;
							case	GAD_Cancel:
								done = TRUE;
								break;
							case	20:
								if(stricmp(".uic", &gad_FName[strlen(gad_FName) - 4]))
									strcpy(&gad_FName[strlen(gad_FName)], ".uic");
								LT_SetAttributes(ThisHandle, 20, GTST_String, gad_FName, TAG_DONE);
								break;
						}
						break;
					case	IDCMP_IDCMPUPDATE:
						switch(MsgGadget->GadgetID)
						{
							case	20:	/* Dateiname per Picker */
								{
								struct	FileRequester	*freq;
								char		gad_FDir[256];
								char		gad_FNam[256];
								STRPTR	dummy;
									LT_LockWindow(Window);
									if(freq = AllocFileRequest())
									{
										strcpy(gad_FDir, gad_FName);
										dummy = FilePart(gad_FDir); if(dummy) *dummy = 0x00;
										strcpy(gad_FNam, FilePart(gad_FName));
										if(AslRequestTags(freq, ASLFR_RejectIcons, TRUE, ASLFR_InitialHeight, 999, ASLFR_InitialPattern, "#?.uic", ASLFR_InitialFile, gad_FNam, ASLFR_InitialDrawer, gad_FDir, ASLFR_RejectIcons, TRUE, ASLFR_DoPatterns, TRUE, TAG_DONE))
										{
											strcpy(gad_FName, freq->fr_Drawer);
											AddPart(gad_FName, freq->fr_File, 158);
											LT_SetAttributes(ThisHandle, 20, GTST_String, gad_FName, TAG_DONE);
										}
										FreeFileRequest(freq);
									}
									LT_UnlockWindow(Window);
								}
								break;
						}
						break;
				}
			}
		}
		while(!done);

		LT_UpdateStrings(ThisHandle);
		LT_DeleteHandle(ThisHandle);
	}

	if((save == TRUE) && (iff = AllocIFF()))
	{
		if(savedev)
		{
			if(!(IC_Loaded.DevConfig))
				if(!SerialError)
					ICReadDevices(&IC_DevConfig[0], TRUE);
			IC_Loaded.DevConfig	= TRUE;
		}
		if(saveruf)
		{
			if(!(IC_Loaded.RufConfig))
				if(!SerialError)
				{
				int	n;
					LT_SetAttributes(MainHandle, GAD_RufConfig_LV, GTLV_Labels, ~NULL, TAG_DONE);
					for(n = 0 ; n < 60 ; n++)
					{
						if(ICGetRufConfig(&IC_RufConfig[n], n+1, TRUE))
						{
							AddTail(&IC_ShortList, (struct Node *)&IC_RufConfig[n]);
							ICSetRC_LV(&IC_ShortList, &IC_RufConfig[n]);
						}
						else
							break;
					}
					LT_SetAttributes(MainHandle, GAD_RufConfig_LV, GTLV_Labels, &IC_ShortList, GTLV_Selected, 0, TAG_DONE);
					ICSetRC_Gadgets(&IC_RufConfig[LT_GetAttributes(MainHandle, GAD_RufConfig_LV, TAG_DONE)]);
				}
			IC_Loaded.RufConfig = TRUE;
		}

		if(iff->iff_Stream = Open(gad_FName, MODE_NEWFILE))
		{
			InitIFFasDOS(iff);
			OpenIFF(iff, IFFF_WRITE);

			PushChunk(iff, ID_ISTC, ID_FORM, IFFSIZE_UNKNOWN);

			if(strlen(gad_Anno))
			{
				PushChunk(iff, ID_ISTC, ID_ANNO, IFFSIZE_UNKNOWN);
				WriteChunkBytes(iff, gad_Anno, strlen(gad_Anno) + 1);
				PopChunk(iff);
			}

			if(savebase)
			{
				PushChunk(iff, ID_ISTC, ID_BASE, IFFSIZE_UNKNOWN);
				WriteChunkBytes(iff, &IC_BaseConfig, sizeof(struct IC_BaseConfig));
				PopChunk(iff);
				Versions[0] = 1;
			}

			if(savedev)
				for(i = 0 ; i < 8 ; i++)
				{
					id = ID_DEV0 + i;
					PushChunk(iff, ID_ISTC, id, IFFSIZE_UNKNOWN);
					WriteChunkBytes(iff, &IC_DevConfig[i], sizeof(struct IC_DevConfig));
					PopChunk(iff);
					Versions[1] = 1;
				}

			if(saveruf)
				for(i = 0 ; i < 60 ; i++)
				{
					id = ID_SN00 + ((i / 10) << 8) + (i % 10);
					PushChunk(iff, ID_ISTC, id, IFFSIZE_UNKNOWN);
					WriteChunkBytes(iff, &IC_RufConfig[i].Number[0], sizeof(struct IC_RufConfig) - sizeof(struct Node));
					PopChunk(iff);
					Versions[2] = 1;
				}

			PushChunk(iff, ID_ISTC, ID_ICVR, IFFSIZE_UNKNOWN);
			WriteChunkBytes(iff, Versions, sizeof(Versions));
			PopChunk(iff);

			PopChunk(iff);

			CloseIFF(iff);
			Close(iff->iff_Stream);
		}
		else
			Requester(NULL, PRGNAME": Fehler!", "Fehler!\nKonnte die Konfiguration nicht speichern!!!", "Ok", NULL, NULL);
		FreeIFF(iff);
	}
	else
		if(save)
			Requester(NULL, PRGNAME": Fehler!", "Fehler!\nKonnte die Konfiguration nicht speichern!!!", "Ok", NULL, NULL);
}

/* Menu_Load
 * Ladet eine Konfiguration aus einer Datei ein
 * Rueckgabewert = TRUE=Laden war erfolgreich
 */
BOOL	Menu_Load(void)
{
struct	IFFHandle	*iff = NULL;
UWORD		Versions[10]; /* Versionen für Basis, Endgeräte, Kurzwahlen, offen, offen, ... */
int		i;
struct	LayoutHandle	*Handle;
char		gad_Anno[80];
char		gad_FName[256];
char		gad_FNameCopy[256];
BOOL		LoadBase = FALSE;
BOOL		LoadDev  = FALSE;
BOOL		LoadRuf  = FALSE;
BOOL		load = FALSE;
BOOL		loadok = FALSE;

	for(i = 0 ; i < 10 ; i++)
		Versions[i] = 9999;

	strcpy(gad_Anno, "");
	strcpy(gad_FName, ".uic");
	strcpy(gad_FNameCopy, gad_FName);

	if(Handle = LT_CreateHandleTags(NULL, TAG_DONE))
	{
	struct	Window	*Window;
	BOOL					 done = FALSE;
	char					 WinTitle[] = PRGNAME ": Anlagenkonfiguration laden...";

		LT_New(Handle, LA_Type, VERTICAL_KIND, TAG_DONE);
			LT_New(Handle, LA_Type, VERTICAL_KIND, LAGR_Frame, TRUE, LA_LabelText, "Folgende Konfiguration(en) werden geladen", TAG_DONE);
				LT_New(Handle, LA_Type, CHECKBOX_KIND, LA_ID, 100, LA_LabelText, "Anlagenkonfiguration:",		LA_BOOL, &LoadBase, GA_Disabled, TRUE, TAG_DONE);
				LT_New(Handle, LA_Type, CHECKBOX_KIND, LA_ID, 101, LA_LabelText, "Endgerätekonfiguration:",	LA_BOOL, &LoadDev,  GA_Disabled, TRUE, TAG_DONE);
				LT_New(Handle, LA_Type, CHECKBOX_KIND, LA_ID, 102, LA_LabelText, "Kurzwahlverzeichnis:",		LA_BOOL, &LoadRuf,  GA_Disabled, TRUE, TAG_DONE);
			LT_EndGroup(Handle);
			LT_New(Handle, LA_Type, VERTICAL_KIND, TAG_DONE);
				LT_New(Handle, LA_Type, TEXT_KIND, LA_ID, 10, LA_Chars, 61, GTTX_Text, gad_Anno, LA_LabelText, "Anmerkung:", GTTX_Border, TRUE, TAG_DONE);
				LT_New(Handle, LA_Type, XBAR_KIND, TAG_DONE);
				LT_New(Handle, LA_Type, STRING_KIND, LA_ID, 20, LA_Chars, 58, GTST_MaxChars, 250, GTST_String, gad_Anno, LA_LabelText, "_Datei:", LAST_Picker, TRUE, LA_STRPTR, gad_FName, TAG_DONE);
			LT_EndGroup(Handle);
				LT_New(Handle, LA_Type, XBAR_KIND, LAXB_FullSize, TRUE, TAG_DONE);
			LT_New(Handle, LA_Type, HORIZONTAL_KIND, LAGR_SameSize, TRUE, LAGR_Spread, TRUE, TAG_DONE);
				LT_New(Handle, LA_Type, BUTTON_KIND, LA_ID, GAD_Load, LA_LabelText, "Laden", LA_ExtraFat, TRUE, LABT_ReturnKey, TRUE, TAG_DONE);
				LT_New(Handle, LA_Type, BUTTON_KIND, LA_ID, GAD_Cancel, LA_LabelText, "Abbrechen", LA_ExtraFat, TRUE, LABT_EscKey, TRUE, TAG_DONE);
			LT_EndGroup(Handle);
		LT_EndGroup(Handle);

		if(Window = LT_Build(Handle,
									LAWN_Title,			WinTitle,
									LAWN_IDCMP,			IDCMP_CLOSEWINDOW|IDCMP_GADGETDOWN|IDCMP_GADGETUP|IDCMP_RAWKEY|IDCMP_REFRESHWINDOW,
									LAWN_Zoom,			TRUE,
									LAWN_SmartZoom,	TRUE,
									WA_CloseGadget,	TRUE,
									WA_DragBar,			TRUE,
									WA_Activate,		TRUE,
									WA_DepthGadget,	TRUE,
									TAG_DONE))
		do
		{
			WaitPort(Window -> UserPort);
			while(Message = GT_GetIMsg(Window->UserPort))
			{
				MsgClass			= Message->Class;
				MsgCode			= Message->Code;
				MsgQualifier	= Message->Qualifier;
				MsgGadget		= Message->IAddress;

				GT_ReplyIMsg(Message);
				LT_HandleInput(Handle, MsgQualifier, &MsgClass, &MsgCode, &MsgGadget);

				switch(MsgClass)
				{
					case	IDCMP_CLOSEWINDOW:
						done = TRUE;
						break;
					case	IDCMP_GADGETUP:
						switch(MsgGadget->GadgetID)
						{
							case	GAD_Load:
								load = TRUE;
							case	GAD_Cancel:
								done = TRUE;
								break;
						}
						break;
					case	IDCMP_IDCMPUPDATE:
						switch(MsgGadget->GadgetID)
						{
							case	20:	/* Dateiname per Picker */
								{
								struct	FileRequester	*freq;
								char		gad_FDir[256];
								char		gad_FNam[256];
								STRPTR	dummy;
									LT_LockWindow(Window);
									if(freq = AllocFileRequest())
									{
										strcpy(gad_FDir, gad_FName);
										dummy = FilePart(gad_FDir); if(dummy) *dummy = 0x00;
										strcpy(gad_FNam, FilePart(gad_FName));
										if(AslRequestTags(freq, ASLFR_RejectIcons, TRUE, ASLFR_InitialHeight, 999, ASLFR_InitialPattern, "#?.uic", ASLFR_InitialFile, gad_FNam, ASLFR_InitialDrawer, gad_FDir, ASLFR_RejectIcons, TRUE, ASLFR_DoPatterns, TRUE, TAG_DONE))
										{
											strcpy(gad_FName, freq->fr_Drawer);
											AddPart(gad_FName, freq->fr_File, 158);
											LT_SetAttributes(Handle, 20, GTST_String, gad_FName, TAG_DONE);
										}
										FreeFileRequest(freq);
									}
									LT_UnlockWindow(Window);
								}
								break;
						}
						break;
				}
			}
			LT_UpdateStrings(Handle);
			if(strcmp(gad_FName, gad_FNameCopy))
			{
				for(i = 0 ; i < 10 ; i++)
					Versions[i] = 9999;
				strcpy(gad_FNameCopy, gad_FName);
				if(iff = AllocIFF())
				{
					if(iff->iff_Stream = Open(gad_FName, MODE_OLDFILE))
					{
						InitIFFasDOS(iff);
						if(!OpenIFF(iff, IFFF_READ))
						{
						struct	StoredProperty	*sp;
							PropChunk(iff, ID_ISTC, ID_ANNO);
							StopChunk(iff, ID_ISTC, ID_ICVR);
							if(!ParseIFF(iff, IFFPARSE_SCAN))
							{
								ReadChunkBytes(iff, Versions, sizeof(Versions));

								if(sp = FindProp(iff, ID_ISTC, ID_ANNO))
								{
									strcpy(gad_Anno, sp->sp_Data);
								}
								else
									strcpy(gad_Anno, "");
								LT_SetAttributes(Handle, 10, GTTX_Text, gad_Anno, TAG_DONE);
							}
							else
								Requester(NULL, PRGNAME": Fehler!", "Fehler!\nParseIFF() fehlgeschlagen!!!", "Ok", NULL, NULL);
							CloseIFF(iff);
						}
						else
							Requester(NULL, PRGNAME": Fehler!", "Fehler!\nOpenIFF() fehlgeschlagen!!!", "Ok", NULL, NULL);
						Close(iff->iff_Stream);
					}
					else
						Requester(NULL, PRGNAME": Fehler!", "Fehler!\nKonnte Datei nicht öffnen!!!", "Ok", NULL, NULL);
					FreeIFF(iff);
				}
				else
					Requester(NULL, PRGNAME": Fehler!", "Fehler!\nAllocIFF() fehlgeschlagen!!!", "Ok", NULL, NULL);

				LT_SetAttributes(Handle, 100, GTCB_Checked, (Versions[0] <= 1) ? TRUE : FALSE, GA_Disabled, !(Versions[0] <= 1) ? TRUE : FALSE, TAG_DONE);
				LT_SetAttributes(Handle, 101, GTCB_Checked, (Versions[1] <= 1) ? TRUE : FALSE, GA_Disabled, !(Versions[1] <= 1) ? TRUE : FALSE, TAG_DONE);
				LT_SetAttributes(Handle, 102, GTCB_Checked, (Versions[2] <= 1) ? TRUE : FALSE, GA_Disabled, !(Versions[2] <= 1) ? TRUE : FALSE, TAG_DONE);
			}
		}
		while(!done);

		LT_DeleteHandle(Handle);
	}

	iff = NULL;
	if((load == TRUE) && (iff = AllocIFF()))
	{
		if(iff->iff_Stream = Open(gad_FName, MODE_OLDFILE))
		{
			InitIFFasDOS(iff);
			if(!OpenIFF(iff, IFFF_READ))
			{
			struct	StoredProperty	*sp;
				PropChunk(iff, ID_ISTC, ID_ANNO);
				PropChunk(iff, ID_ISTC, ID_BASE);
				for(i = 0 ; i < 8 ; i++)
					PropChunk(iff, ID_ISTC, ID_DEV0 + i);
				for(i = 0 ; i < 60 ; i++)
					PropChunk(iff, ID_ISTC, ID_SN00 + ((i / 10) << 8) + (i % 10));
				StopChunk(iff, ID_ISTC, ID_ICVR);
				if(!ParseIFF(iff, IFFPARSE_SCAN))
				{
					ReadChunkBytes(iff, Versions, sizeof(Versions));
					loadok = TRUE;

					/* Basiskonfig */
					if((Versions[0] <= 1) && (LoadBase) && (sp = FindProp(iff, ID_ISTC, ID_BASE)))
					{
						memcpy(&IC_BaseConfig, sp->sp_Data, sizeof(IC_BaseConfig));
						IC_Changed.BaseConfig = TRUE;
						ICReadBaseConfig(&IC_BaseConfig, FALSE, FALSE);
					}

					/* Endgeräte */
					if((Versions[1] <= 1) && (LoadDev))
						for(i = 0 ; i < 8 ; i++)
						{
							if(sp = FindProp(iff, ID_ISTC, ID_DEV0 + i))
							{
								memcpy(&IC_DevConfig[i], sp->sp_Data, sizeof(struct IC_DevConfig));
								IC_Loaded.DevConfig = TRUE;
								IC_Changed.DevConfig[i] = TRUE;
							}
						}

					/* Kurzwahlen */
					if((Versions[2] <= 1) && (LoadRuf))
					{
						LT_SetAttributes(MainHandle, GAD_RufConfig_LV, GTLV_Labels, ~NULL, TAG_DONE);
						if(!IC_Loaded.RufConfig)
						{
							for(i = 0 ; i < 60 ; i++)
							{
								AddTail(&IC_ShortList, (struct Node *)&IC_RufConfig[i]);
								IC_RufConfig[i].Node.ln_Name = IC_RufConfig[i].Number;
							}
						}
						for(i = 0 ; i < 60 ; i++)
						{
							if(sp = FindProp(iff, ID_ISTC, ID_SN00 + ((i / 10) << 8) + (i % 10)))
							{
								memcpy(&IC_RufConfig[i].Number[0], sp->sp_Data, sizeof(struct IC_RufConfig) - sizeof(struct Node));
								IC_Loaded.RufConfig = TRUE;
								IC_Changed.RufConfig[i] = TRUE;
							}
						}
						LT_SetAttributes(MainHandle, GAD_RufConfig_LV, GTLV_Labels, &IC_ShortList, GTLV_Selected, 0, TAG_DONE);
						ICSetRC_LV(&IC_ShortList, &IC_RufConfig[0]);
						ICSetRC_Gadgets(&IC_RufConfig[0]);
					}
				}
				else
					Requester(NULL, PRGNAME": Fehler!", "Fehler!\nParseIFF() fehlgeschlagen!!!", "Ok", NULL, NULL);
				CloseIFF(iff);
			}
			else
				Requester(NULL, PRGNAME": Fehler!", "Fehler!\nOpenIFF() fehlgeschlagen!!!", "Ok", NULL, NULL);
			Close(iff->iff_Stream);
		}
		else
			Requester(NULL, PRGNAME": Fehler!", "Fehler!\nKonnte die Datei nicht öffnen!!!", "Ok", NULL, NULL);
		FreeIFF(iff);
	}
	else
		if(load)
			Requester(NULL, PRGNAME": Fehler!", "Fehler!\nAllocIFF() fehlgeschlagen!!!", "Ok", NULL, NULL);

	return(loadok);
}

/* ICConfigReset
 * Setzt alle internen Konfigurationen wieder auf den Zustand
 * zurueck, der auch nach einem Anlagenreset vorliegen wuerde
 */
void	ICConfigReset(void)
{
UBYTE	BaseConfig[] =	{0x17, 0x00, 0x08, 0x01, 0x02, 0x0D, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
							 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
							 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
							 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
							 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
							 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31,
							 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
							 0x00, 0x00, 0x00, 0x00, 0x00};
UBYTE	DevConfig[] =	{0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
							 0xFF, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00};
UBYTE RufConfig[] =	{0x33, 0x30, 0x31, 0x20, 0x20, 0x20, 0x2D, 0x2D, 0x20, 0x4B, 0x65, 0x69, 0x6E, 0x65, 0x20, 0x4E,
							 0x75, 0x6D, 0x6D, 0x65, 0x72, 0x20, 0x2D, 0x2D, 0x20, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
							 0x4B, 0x20, 0x4E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
							 0x00, 0x00, 0xCC, 0x08, 0x03, 0x01, 0x00, 0x00, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00,
							 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
							 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
							 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
							 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
							 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
							 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
int	i;

	/* Anlagenkonfig */
	memcpy(&IC_BaseConfig, BaseConfig, sizeof(BaseConfig));
	IC_Changed.BaseConfig = TRUE;
	ICReadBaseConfig(&IC_BaseConfig, FALSE, FALSE);
	/* Endgeräte */
	for(i = 0 ; i < 8 ; i++)
	{
		DevConfig[1] = i;
		memcpy(&IC_DevConfig[i], DevConfig, sizeof(DevConfig));
		IC_Changed.DevConfig[i] = TRUE;
	}
	IC_Loaded.DevConfig = TRUE;
	/* Kurzwahlen */
	LT_SetAttributes(Handle, GAD_RufConfig_LV, GTLV_Labels, ~NULL, TAG_DONE);
	if(!IC_Loaded.RufConfig)
	{
		for(i = 0 ; i < 60 ; i++)
		{
			AddTail(&IC_ShortList, (struct Node *)&IC_RufConfig[i]);
			IC_RufConfig[i].Node.ln_Name = IC_RufConfig[i].Number;
		}
	}
	/* Gebühren */
	for(i = 0 ; i < 8 ; i++)
		IC_Charge.Charge[i] = 0;
	IC_Changed.Charge = TRUE;
	IC_Loaded.Charge = TRUE;
	/* Kurzwahlen */
	for(i = 1 ; i <= 60 ; i++)
	{
		RufConfig[1]  = (i / 10) + '0';
		RufConfig[2]  = (i % 10) + '0';
		RufConfig[53] = i;
		memcpy(&IC_RufConfig[i-1].Number, RufConfig, sizeof(RufConfig));
		IC_Changed.RufConfig[i-1] = TRUE;
	}
	IC_Loaded.RufConfig = TRUE;
	LT_SetAttributes(Handle, GAD_RufConfig_LV, GTLV_Labels, &IC_ShortList, GTLV_Selected, 0, TAG_DONE);
	ICSetRC_Gadgets(&IC_RufConfig[LT_GetAttributes(Handle, GAD_RufConfig_LV, TAG_DONE)]);
}