/* Menu_ChangePrgConfig
 * Dieses Menu öffnet ein Fenster, in dem die
 * Programmeinstellungen verändert werden können.
 * Rückgabewert: TRUE=Einstellungen aktiviert, FALSE=Abgebrochen
 */
#define	NEUEREINTRAG	"-= Neuer Eintrag =-"
#define	KEINENUMMER		"-= Keine Nummer =-"
BOOL	Menu_ChangePrgConfig(void)
{
struct	LayoutHandle	*Handle;
int	n;
BOOL	use = FALSE;
struct	List	NewAliasList;

enum	{CPC_Gadgets = 1000,
			CPC_PAGE0,
			CPC_LoadAll,
			CPC_Dev21, CPC_Dev22, CPC_Dev23, CPC_Dev24, CPC_Dev25, CPC_Dev26, CPC_Dev27, CPC_Dev28, 
			CPC_Geb21, CPC_Geb22, CPC_Geb23, CPC_Geb24, CPC_Geb25, CPC_Geb26, CPC_Geb27, CPC_Geb28, 
			CPC_UnitCost, CPC_DMname,
			CPC_Name, CPC_Number, CPC_LV, CPC_New, CPC_Sort, CPC_Del, CPC_UseAliasList, CPC_AliasList,
			CPC_LastGadget};

	NewList(&NewAliasList);
	if(!IsListEmpty(&IC_AliasList))
	{
	struct	IC_Alias	*s = (struct IC_Alias *)IC_AliasList.lh_Head;
	struct	IC_Alias	*d;

		while(s->Node.ln_Succ)
		{
			if(d = AllocVec(sizeof(struct IC_Alias), MEMF_CLEAR))
			{
				memcpy(d, s, sizeof(struct IC_Alias));
				d->Node.ln_Name = d->Text;
				AddTail(&NewAliasList, (struct Node *)d);
			}
			else
				printf("Not enough memory error!!!\n");
			s = (struct IC_Alias *)s->Node.ln_Succ;
		}
	}

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

		LT_New(Handle, LA_Type, VERTICAL_KIND, TAG_DONE);
		{
		static	STRPTR	Labels[] = {"Allgemeines", "Geräte", "Gebühren", "Rufnummern", NULL};
			LT_New(Handle, LA_Type, TAB_KIND, LATB_Labels, Labels, LATB_Active, 0, LATB_AutoPageID, CPC_PAGE0, LATB_TabKey, TRUE, TAG_DONE);
			{
				LT_New(Handle, LA_Type, VERTICAL_KIND, LA_ID, CPC_PAGE0, LAGR_ActivePage, 0, LAGR_SameSize, TRUE, TAG_DONE);
				{
				static	STRPTR	DevLabels[] = {"Gerät 2_1:", "Gerät 2_2:", "Gerät 2_3:", "Gerät 2_4:", "Gerät 2_5:", "Gerät 2_6:", "Gerät 2_7:", "Gerät 2_8:"};
					/* Allgemeines */
					LT_New(Handle, LA_Type, VERTICAL_KIND, TAG_DONE);
					{
						LT_New(Handle, LA_Type, CHECKBOX_KIND, LA_ID, CPC_LoadAll, LA_LabelText, "Alles einladen", GTCB_Checked, PrgConfig.LoadAll, TAG_DONE);
					}
					LT_EndGroup(Handle);
					/* Geräte */
					LT_New(Handle, LA_Type, VERTICAL_KIND, TAG_DONE);
					{
						for(n = 0 ; n < 8 ; n++)
							LT_New(Handle, LA_Type, STRING_KIND, LA_ID, CPC_Dev21 + n, LA_LabelText, DevLabels[n], LA_Chars, 11, GTST_MaxChars, 10, GTST_String, IC_DeviceNames.Names[n], TAG_DONE);
					}
					LT_EndGroup(Handle);
					/* Gebühren */
					LT_New(Handle, LA_Type, VERTICAL_KIND, TAG_DONE);
					{
					static	STRPTR	Labels[] = {PrgConfig.DMname, "Einheiten", NULL};
						LT_New(Handle, LA_Type, VERTICAL_KIND, LAGR_Frame, TRUE, LA_LabelText, "Gebühren anzeigen als", TAG_DONE);
							for(n = 0 ; n < 8 ; n++)
								LT_New(Handle, LA_Type, POPUP_KIND, LA_ID, CPC_Geb21 + n, LA_LabelText, DevLabels[n], LAPU_Labels, Labels, LAPU_Active, (IC_Charge.ChargeType[n]) ? 0 : 1, TAG_DONE);
						LT_EndGroup(Handle);
						LT_New(Handle, LA_Type, VERTICAL_KIND, TAG_DONE);
						LT_New(Handle, LA_Type, INTEGER_KIND, LA_ID, CPC_UnitCost, LA_LabelText, "Kosten/Einheit:", LAIN_Min, 1, LAIN_Max, 99, GTIN_Number, PrgConfig.UnitCost, LA_Chars, 3, TAG_DONE);
						LT_New(Handle, LA_Type, STRING_KIND, LA_ID, CPC_DMname, LA_LabelText, "Einheit", LA_Chars, 5, GTST_MaxChars, 4, GTST_String, PrgConfig.DMname, LA_STRPTR, PrgConfig.DMname, TAG_DONE);
						LT_EndGroup(Handle);
					}
					LT_EndGroup(Handle);
					/* Rufnummern */
					LT_New(Handle, LA_Type, VERTICAL_KIND, TAG_DONE);
					{
						LT_New(Handle, LA_Type, LISTVIEW_KIND, LA_ID, CPC_LV, LALV_Lines, 10, LALV_MinLines, 10, GTLV_Labels, &NewAliasList, LALV_ResizeY, TRUE, LA_Chars, 39, LALV_Link, NIL_LINK, LALV_CursorKey, TRUE, TAG_DONE);
						LT_New(Handle, LA_Type, VERTICAL_KIND, TAG_DONE);
							LT_New(Handle, LA_Type, STRING_KIND, LA_ID, CPC_Name, LA_LabelText, "Name:", LA_Chars, 20, GTST_MaxChars, 19, TAG_DONE);
							LT_New(Handle, LA_Type, STRING_KIND, LA_ID, CPC_Number, LA_LabelText, "Nummer:", LA_Chars, 20, GTST_MaxChars, 19, LAST_LastGadget, TRUE, TAG_DONE);
						LT_EndGroup(Handle);
						LT_New(Handle, LA_Type, XBAR_KIND, TAG_DONE);
						LT_New(Handle, LA_Type, HORIZONTAL_KIND, LAGR_Spread, TRUE, TAG_DONE);
							LT_New(Handle, LA_Type, BUTTON_KIND, LA_ID, CPC_New , LA_LabelText, "Neu", TAG_DONE);
//							LT_New(Handle, LA_Type, BUTTON_KIND, LA_ID, CPC_Sort , LA_LabelText, "Sort", TAG_DONE);
							LT_New(Handle, LA_Type, BUTTON_KIND, LA_ID, CPC_Del , LA_LabelText, "Löschen", TAG_DONE);
						LT_EndGroup(Handle);
						LT_New(Handle, LA_Type, XBAR_KIND, TAG_DONE);
						LT_New(Handle, LA_Type, VERTICAL_KIND, TAG_DONE);
							LT_New(Handle, LA_Type, HORIZONTAL_KIND, TAG_DONE);
								LT_New(Handle, LA_Type, CHECKBOX_KIND, LA_ID, CPC_UseAliasList, LA_LabelText, "Alias_Liste benutzen", GTCB_Checked, strlen(PrgConfig.AliasListeName), TAG_DONE);
							LT_EndGroup(Handle);
							LT_New(Handle, LA_Type, STRING_KIND, LA_ID, CPC_AliasList, LA_LabelText, "_Dateiname", LA_Chars, 40, GTST_MaxChars, 98, GTST_String, PrgConfig.AliasListeName, GA_Disabled, !strlen(PrgConfig.AliasListeName), LAST_Picker, TRUE, LAST_LastGadget, TRUE, TAG_DONE);
						LT_EndGroup(Handle);
					}
					LT_EndGroup(Handle);
				}
				LT_EndGroup(Handle);
			}
			LT_New(Handle, LA_Type, XBAR_KIND, LAXB_FullSize, TRUE);
			LT_New(Handle, LA_Type, HORIZONTAL_KIND, LAGR_Spread, TRUE, LAGR_SameSize, TRUE, TAG_DONE);
				LT_New(Handle, LA_Type, BUTTON_KIND, LA_LabelText, "Speichern", LA_ID, GAD_Save, LA_ExtraFat, TRUE, LABT_ReturnKey, TRUE, TAG_DONE);
				LT_New(Handle, LA_Type, BUTTON_KIND, LA_LabelText, "Benutzen", LA_ID, GAD_Use,	LA_ExtraFat, TRUE, TAG_DONE);
				LT_New(Handle, LA_Type, BUTTON_KIND, LA_LabelText, "Abbrechen", LA_ID, GAD_Cancel, LA_ExtraFat, TRUE, LABT_EscKey, TRUE, TAG_DONE);
			LT_EndGroup(Handle);
		}
		LT_EndGroup(Handle);

		if(Window = LT_Build(Handle,
									LAWN_Title,			WinTitle,
									LAWN_IDCMP,			LISTVIEWIDCMP|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))
			{
			struct	IC_Alias	*ActiveAl = NULL;
				MsgClass			= Message->Class;
				MsgCode			= Message->Code;
				MsgQualifier	= Message->Qualifier;
				MsgGadget		= Message->IAddress;

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

				{
				int	x = LT_GetAttributes(Handle, CPC_LV, TAG_DONE);
					if(!IsListEmpty(&NewAliasList))
					{
						if(x >= 0)
							ActiveAl = (struct IC_Alias *)(&NewAliasList)->lh_Head;
						if(x >= 0)
							while(x--)
							{
								if(ActiveAl->Node.ln_Succ)
									ActiveAl = (struct IC_Alias *)ActiveAl->Node.ln_Succ;
								else
									ActiveAl = NULL, x = 0;
							}
					}
					else
						ActiveAl = NULL;
				}
				switch(MsgClass)
				{
					case	IDCMP_CLOSEWINDOW:
						use = FALSE;
						done = TRUE;
						break;
					case	IDCMP_GADGETUP:
						switch(MsgGadget->GadgetID)
						{
							case	GAD_Save:
							case	GAD_Use:
								use = TRUE;
								{
								struct	IC_Alias	*s, *d;
									for(n = 0 ; n < 8 ; n++)
										if(strlen((char *)LT_GetAttributes(Handle, CPC_Dev21 + n, TAG_DONE)))
											strcpy(IC_DeviceNames.Names[n], (char *)LT_GetAttributes(Handle, CPC_Dev21 + n, TAG_DONE));
									PrgConfig.UnitCost = LT_GetAttributes(Handle, CPC_UnitCost, TAG_DONE);
									for(n = 0 ; n < 8 ; n++)
										IC_Charge.ChargeType[n] = LT_GetAttributes(Handle, CPC_Geb21 + n , TAG_DONE) ? 0 : PrgConfig.UnitCost;
									s = (struct IC_Alias *)NewAliasList.lh_Head;
									d = (struct IC_Alias *)IC_AliasList.lh_Head;
									while((d) && (d->Node.ln_Succ))
									{
									struct	IC_Alias	*x = d;
										Remove((struct Node *)d);
										d = (struct IC_Alias *)d->Node.ln_Succ;
										FreeVec(x);
									}
									/* Liste freigeben, bevor sie veraendert wird */
									LT_SetAttributes(Handle, CPC_LV, GTLV_Labels, ~NULL, TAG_DONE);
									while((s) && (s->Node.ln_Succ))
									{
									struct	IC_Alias	*x = s;
										s = (struct IC_Alias *)s->Node.ln_Succ;
										Remove((struct Node *)x);
										AddTail(&IC_AliasList, (struct Node *)x);
									}
								}
								if(LT_GetAttributes(Handle, CPC_UseAliasList, TAG_DONE))
									strcpy(PrgConfig.AliasListeName, (char *)LT_GetAttributes(Handle, CPC_AliasList, TAG_DONE));
								done = TRUE;
								if(MsgGadget->GadgetID == GAD_Use)
									break;
								/* Daten ins Icon schreiben */
								{
								UBYTE	*Mem = AllocVec(20000, MEMF_CLEAR);
									if(Mem)
									{
									STRPTR	*TT = (STRPTR *)Mem;
									STRPTR	 Text = Mem + 1000;
									int		 i = 0, n = 0;
									struct	IC_Alias	*al = (struct IC_Alias *)IC_AliasList.lh_Head;

										for(n = 0 ; n < 8 ; n++)
										{
											sprintf(Text, "Gerät%ld=%s", n + 21, IC_DeviceNames.Names[n]);
											TT[i++] = Text; Text += strlen(Text) + 2;
										}
										sprintf(Text, "AllesLaden=%s", PrgConfig.LoadAll ? "Ja" : "Nein");
										TT[i++] = Text; Text += strlen(Text) + 2;
										sprintf(Text, "GebührenName=%s", PrgConfig.DMname);
										TT[i++] = Text; Text += strlen(Text) + 2;
										sprintf(Text, "GebührenJeEinheit=%ld", PrgConfig.UnitCost);
										TT[i++] = Text; Text += strlen(Text) + 2;
										sprintf(Text, "GebührenAnsicht=%c%c%c%c%c%c%c%c", IC_Charge.ChargeType[0] ? '+' : '-', IC_Charge.ChargeType[1] ? '+' : '-', IC_Charge.ChargeType[2] ? '+' : '-', IC_Charge.ChargeType[3] ? '+' : '-', IC_Charge.ChargeType[4] ? '+' : '-', IC_Charge.ChargeType[5] ? '+' : '-', IC_Charge.ChargeType[6] ? '+' : '-', IC_Charge.ChargeType[7] ? '+' : '-');
										TT[i++] = Text; Text += strlen(Text) + 2;
										{
										BPTR	fh = NULL;
											if(LT_GetAttributes(Handle, CPC_UseAliasList, TAG_DONE))
												fh = Open(PrgConfig.AliasListeName, MODE_NEWFILE);
											if(fh)
											{
												FPuts(fh, "Diese Datei enthält Aliase für das Programm UFT-Istec\n");
												FPuts(fh, "Sie kann frei geändert werden. Aufbau:\n");
												FPuts(fh, "Rufnummer,Name\n\n");
											}

											while(al->Node.ln_Succ)
											{
												if((strcmp(al->Name, NEUEREINTRAG))		&&
													(strcmp(al->Number, KEINENUMMER))	&&
													(strlen(al->Name))									&&
													(strlen(al->Number)))
												{
													if(!fh)
													{
														sprintf(Text, "Alias=%s,%s", al->Number, al->Name);
														TT[i++] = Text; Text += strlen(Text) + 2;
													}
													else
													{
														sprintf(Text, "%s,%s\n", al->Number, al->Name);
														FPuts(fh, Text);
													}
												}
												al = (struct IC_Alias *)al->Node.ln_Succ;
											}
											if(fh) Close(fh);
										}
										if(diskobj)
										{
										STRPTR	*OldTT = diskobj->do_ToolTypes;
										STRPTR	*CopyTT = diskobj->do_ToolTypes;
										int		 n = 0;

											while(CopyTT[n])
											{
												if((strnicmp(CopyTT[n], "Alias=", strlen("Alias=")))										&&
													(strnicmp(CopyTT[n], "(Alias=", strlen("(Alias=")))									&&
													(strnicmp(CopyTT[n], "GERÄT", strlen("GERÄT")))											&&
													(strnicmp(CopyTT[n], "(GERÄT", strlen("(GERÄT")))										&&
													(strnicmp(CopyTT[n], "Gerät", strlen("Gerät")))											&&
													(strnicmp(CopyTT[n], "(Gerät", strlen("(Gerät")))										&&
													(strnicmp(CopyTT[n], "AllesLaden=", strlen("AllesLaden=")))							&&
													(strnicmp(CopyTT[n], "(AllesLaden=", strlen("(AllesLaden=")))						&&
													(strnicmp(CopyTT[n], "GEBÜHRENNAME=", strlen("GEBÜHRENNAME=")))					&&
													(strnicmp(CopyTT[n], "(GEBÜHRENNAME=", strlen("(GEBÜHRENNAME=")))					&&
													(strnicmp(CopyTT[n], "GebührenName=", strlen("GebührenName=")))					&&
													(strnicmp(CopyTT[n], "(GebührenName=", strlen("(GebührenName=")))					&&
													(strnicmp(CopyTT[n], "GEBÜHRENJEEINHEIT=", strlen("GEBÜHRENJEEINHEIT=")))		&&
													(strnicmp(CopyTT[n], "(GEBÜHRENJEEINHEIT=", strlen("(GEBÜHRENJEEINHEIT=")))	&&
													(strnicmp(CopyTT[n], "GebührenJeEinheit=", strlen("GebührenJeEinheit=")))		&&
													(strnicmp(CopyTT[n], "(GebührenJeEinheit=", strlen("(GebührenJeEinheit=")))	&&
													(strnicmp(CopyTT[n], "GEBÜHRENANSICHT=", strlen("GEBÜHRENANSICHT=")))			&&
													(strnicmp(CopyTT[n], "(GEBÜHRENANSICHT=", strlen("(GEBÜHRENANSICHT=")))			&&
													(strnicmp(CopyTT[n], "GebührenAnsicht=", strlen("GebührenAnsicht=")))			&&
													(strnicmp(CopyTT[n], "(GebührenAnsicht=", strlen("(GebührenAnsicht="))))
													TT[i++] = CopyTT[n];
												n++;
											}
											diskobj->do_ToolTypes = TT;
											PutDiskObject(SysBase->ThisTask->tc_Node.ln_Name, diskobj);
											diskobj->do_ToolTypes = OldTT;
										
										}
										FreeVec(Mem);
									}
									else
										printf("Memory allocation failed!\n");
								}
								break;
							case	GAD_Cancel:
								done = TRUE;
								use = FALSE;
								break;
							case	CPC_LoadAll:
								PrgConfig.LoadAll = LT_GetAttributes(Handle, MsgGadget->GadgetID, TAG_DONE);
								break;
							case	CPC_DMname:
								{
								static	STRPTR	Labels[] = {PrgConfig.DMname, "Einheiten", NULL};
									if(!strlen(PrgConfig.DMname))
									{
										strcpy(PrgConfig.DMname, "DM");
										LT_SetAttributes(Handle, CPC_DMname, GTST_String, "DM", TAG_DONE);
									}
									for(n = 0 ; n < 8 ; n++)
										LT_SetAttributes(Handle, CPC_Geb21 + n, LAPU_Labels, Labels, TAG_DONE);
								}
								break;
							case	CPC_Name:
								if(ActiveAl)
								{
								char *t = (char *)LT_GetAttributes(Handle, CPC_Name, TAG_DONE);
								struct	IC_Alias	*al = (struct IC_Alias *)NewAliasList.lh_Head;
								BOOL		doit = TRUE;
									while(al -> Node.ln_Succ)
									{
										if(al != ActiveAl)
											if(!stricmp(al->Name, t))
												doit = FALSE;
										al = (struct IC_Alias *)al -> Node.ln_Succ;
									}
									if((doit) && (strlen(t)))
									{
										LT_SetAttributes(Handle, CPC_LV, GTLV_Labels, ~NULL, TAG_DONE);
										strcpy(ActiveAl->Name, t);
										sprintf(ActiveAl->Text, "%19s:%-19s", ActiveAl->Name, ActiveAl->Number);
										LT_SetAttributes(Handle, CPC_LV, GTLV_Labels, &NewAliasList, TAG_DONE);
									}
									else
										LT_SetAttributes(Handle, CPC_Name, GTST_String, strcmp(ActiveAl->Name, NEUEREINTRAG) ? ActiveAl->Name : "", TAG_DONE);
									if(!doit)
									{
									char	*Lines[] = {"Der Name wird schon benutzt,", "bitte waehlen Sie einen anderen Namen", NULL};
										INFOrequest(NULL, NULL, "Einstellungen - Rufnummern", Lines);
										LT_Activate(Handle, CPC_Name);
									}
								}
								break;
							case	CPC_Number:
								if(ActiveAl)
								{
								int	n;
								char *t = (char *)LT_GetAttributes(Handle, CPC_Number, TAG_DONE);
								struct	IC_Alias	*al = (struct IC_Alias *)NewAliasList.lh_Head;
								BOOL		doit = TRUE;
									for(n = 0 ; n < strlen(t) ; n++)
										if(!isdigit(t[n]))
											doit = FALSE;
									while(al -> Node.ln_Succ)
									{
										if(al != ActiveAl)
											if(!stricmp(al->Number, t))
												doit = FALSE;
										al = (struct IC_Alias *)al -> Node.ln_Succ;
									}
									if((doit) && (strlen(t)))
									{
										LT_SetAttributes(Handle, CPC_LV, GTLV_Labels, ~NULL, TAG_DONE);
										strcpy(ActiveAl->Number, t);
										sprintf(ActiveAl->Text, "%19s:%-19s", ActiveAl->Name, ActiveAl->Number);
										LT_SetAttributes(Handle, CPC_LV, GTLV_Labels, &NewAliasList, TAG_DONE);
									}
									else
										LT_SetAttributes(Handle, CPC_Number, GTST_String, strcmp(ActiveAl->Number, KEINENUMMER) ? ActiveAl->Number : "", TAG_DONE);
									if(!doit)
									{
									char	*Lines[] = {"Die Rufnummer wird schon benutzt,", "bitte waehlen Sie eine andere Rufnummer", NULL};
										INFOrequest(NULL, NULL, "Einstellungen - Rufnummern", Lines);
										LT_Activate(Handle, CPC_Number);
									}
								}
								break;
							case	CPC_LV:
								if(ActiveAl)
								{
									if(strcmp(ActiveAl->Name, NEUEREINTRAG))
										LT_SetAttributes(Handle, CPC_Name, GTST_String, ActiveAl->Name, TAG_DONE);
									else
										LT_SetAttributes(Handle, CPC_Name, GTST_String, "", TAG_DONE);
									if(strcmp(ActiveAl->Number, KEINENUMMER))
										LT_SetAttributes(Handle, CPC_Number, GTST_String, ActiveAl->Number, TAG_DONE);
									else
										LT_SetAttributes(Handle, CPC_Number, GTST_String, "", TAG_DONE);
								}
								break;
							case	CPC_New:
								{
								struct	IC_Alias	*al = AllocVec(sizeof(struct IC_Alias), MEMF_CLEAR);
								int	n = 0;
									if(al)
									{
										al->Node.ln_Name = al->Text;
										strcpy(al->Name, NEUEREINTRAG);
										strcpy(al->Number, KEINENUMMER);
										sprintf(al->Text, "%19s:%-19s", al->Name, al->Number);
										LT_SetAttributes(Handle, CPC_LV, GTLV_Labels, ~NULL, TAG_DONE);
										AddTail(&NewAliasList, (struct Node *)al);
										al = (struct IC_Alias *)NewAliasList.lh_Head;
										while(al->Node.ln_Succ)
											n++, al = (struct IC_Alias *)al->Node.ln_Succ;
										LT_SetAttributes(Handle, CPC_LV, GTLV_Labels, &NewAliasList, GTLV_Selected, ~NULL, GTLV_MakeVisible, n, TAG_DONE);
									}
									else
										printf("Memory allocation failed!\n");
								}
								break;
							case	CPC_Sort:
								break;
							case	CPC_Del:
								if(ActiveAl)
								{
									LT_SetAttributes(Handle, CPC_LV, GTLV_Labels, ~NULL, TAG_DONE);
									Remove((struct Node *)ActiveAl);
									FreeVec(ActiveAl);
									LT_SetAttributes(Handle, CPC_LV, GTLV_Labels, &NewAliasList, GTLV_Selected, ~NULL, TAG_DONE);
								}
								break;
							case	CPC_UseAliasList:
								LT_SetAttributes(Handle, CPC_AliasList, GA_Disabled, !LT_GetAttributes(Handle, CPC_UseAliasList, TAG_DONE), TAG_DONE);
								break;
						}
						break;
					case	IDCMP_IDCMPUPDATE:
						switch(MsgGadget->GadgetID)
						{
							case	CPC_AliasList:
								{
								struct	FileRequester	*freq;
									if(freq = AllocFileRequest())
									{
									char	dir[100];
									char	name[100];
										strcpy(name, FilePart(PrgConfig.AliasListeName));
										strcpy(dir, PrgConfig.AliasListeName); if(PathPart(dir)) *(PathPart(dir)) = '\0';
										if(AslRequestTags(freq, ASLFR_RejectIcons, TRUE, ASLFR_InitialHeight, 999, ASLFR_InitialFile, name, ASLFR_InitialDrawer, dir, TAG_DONE))
										{
											strcpy(name, freq->fr_Drawer);
											AddPart(name, freq->fr_File, 98);
											LT_SetAttributes(Handle, CPC_AliasList, GTST_String, name, TAG_DONE);
										}
										FreeFileRequest(freq);
									}
								
								}
								break;
						}
						break;
				}
				LT_SetAttributes(Handle, CPC_Name, GA_Disabled,		!ActiveAl ? TRUE : FALSE, TAG_DONE);
				LT_SetAttributes(Handle, CPC_Number, GA_Disabled,	!ActiveAl ? TRUE : FALSE, TAG_DONE);
				LT_SetAttributes(Handle, CPC_Del, GA_Disabled,		!ActiveAl ? TRUE : FALSE, TAG_DONE);
			}
		}
		while(!done);

		LT_DeleteHandle(Handle);
	}
	if(!IsListEmpty(&NewAliasList))
	{
	struct	IC_Alias	*d = (struct IC_Alias *)NewAliasList.lh_Head;
		while(d->Node.ln_Succ)
		{
		struct	IC_Alias	*x = d;

			d = (struct IC_Alias *)d->Node.ln_Succ;
			FreeVec(x);
		}
	}
	return (use);
}