/* PowerWindows external preferences Scanner */

#include <OSIncludes.h>

#pragma header

#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include "config.h"
#define NOPROTOS
#define NOVARS
#include "PowerWindows.h"
#include "PWDevelopper.h"


/* Defines */

#define ConfigFile1 "PowerWindows.config"
#define ConfigFile2 "S:PowerWindows.config"

/* Strukturen */

struct StringMatch
{
	STRPTR string;
	LONG	 data;
};

struct BoolMatch
{
	STRPTR string;
	BOOL	 &var;
};

struct LongMatch
{
	STRPTR string;
	APTR   var;
	WORD   varlen;
};

/* Vars */

static struct Library *DOSBase;
static struct IntuitionBase *IntuitionBase;
static struct Library *DiskfontBase;

static WORD LinePos;
static LONG TaskSpeicherLen;
static LONG IconifyTaskSpeicherLen;
static LONG l;

static BPTR MyHandle;

static char s[257];
static char s2[257];


static BOOL KeyWordFound;

static struct ConfigData MyConfig;


static struct BoolMatch BoolArray[]=
{
	{"ALLPLANES",MyConfig.AllPlanes},
	{"SCANSCREENS",MyConfig.ScanIt},
	{"CASESENSITIVE",MyConfig.CaseSensitive},
	{"ICONIFYCASESENSITIVE",MyConfig.IconifyCaseSensitive},
	{"ICONIFYGADGET",MyConfig.DoIconify},
	{"NOMOUSEFREEZE",MyConfig.NoMouseFreeze},
	{"SAFEMOVEWINDOW",MyConfig.SafeMoveWindow},
	{"SAFELOCKLAYER",MyConfig.SafeLockLayer},
	{"NOICONS",MyConfig.NoIcons},
	{"DONTICONIFYWB",MyConfig.NoWBWindows},
	{"NOREQPATCH",MyConfig.NoReq},
	{"AVOIDDOUBLECLICKS",MyConfig.AvoidDoubleClicks},
	{"WBICONPOPUP",MyConfig.WBIconPOP},
	{"ICONACTIVATE",MyConfig.IconsActivateWin},
	{"NO_OUTOFSCREEN",MyConfig.StandardDragging},
	{"POPTOFRONT",MyConfig.PopToFront},
	{"NOREFRESHKILL",MyConfig.NoRefreshKill},
	{"SMARTWIN",MyConfig.SmartWin},
	{"ICONCLOSEGAD",MyConfig.IconCloseGad},
	{"OPAQUEMOVE",MyConfig.Opaque},
	{"MAGICMENU_SH",MyConfig.MagicMenu},
	{"OPAQUE_NOSMART",MyConfig.OpaqueNOSMART},
	{"OPAQUE_NOSIMPLE",MyConfig.OpaqueNOSIMPLE},
	{"OPAQUE_NOSUPER",MyConfig.OpaqueNOSUPER},
	{"MULTICX_SM",MyConfig.MultiCX_SM},
	{"SAFEOPAQUE",MyConfig.SafeOpaque},
	{"REFRESHIT",MyConfig.RefreshIconTitles},
	{"NOICONDRAG",MyConfig.NoIconDrag},
	{"NODGPATCH",MyConfig.NoDGPatch},
	{"FORCEAUTOADJUST",MyConfig.ForceAutoAdjust},
	{0,MyConfig.SafeOpaque}
};

static struct LongMatch LongArray[] = 
{
	{"MAXSPPERIOD",&MyConfig.IO_MaxMoveCounter,sizeof(MyConfig.IO_MaxMoveCounter)},
	{"ICONIFYOFFSET",&MyConfig.IconifyOffset,sizeof(MyConfig.IconifyOffset)},
	{"DEADLOCK_SEC",&MyConfig.LockDelay_Sec,sizeof(MyConfig.LockDelay_Sec)},
	{"DEADLOCK_MIC",&MyConfig.LockDelay_Mic,sizeof(MyConfig.LockDelay_Mic)},
	{"DEADLOCK_PRI",&MyConfig.HunterPri,sizeof(MyConfig.HunterPri)},
	{"MOUSEFACTOR",&MyConfig.MouseFaktor,sizeof(MyConfig.MouseFaktor)},
	{"MINICONWIDTH",&MyConfig.MinIconWidth,sizeof(MyConfig.MinIconWidth)},
	{"ICONPOS_OFFX",&MyConfig.IconOffX,sizeof(MyConfig.IconOffX)},
	{"ICONPOS_OFFY",&MyConfig.IconOffY,sizeof(MyConfig.IconOffY)},
	{"ICONPOS_SPACEX",&MyConfig.IconSpaceX,sizeof(MyConfig.IconSpaceX)},
	{"ICONPOS_SPACEY",&MyConfig.IconSpaceY,sizeof(MyConfig.IconSpaceY)},
	{"MINWINWIDTH",&MyConfig.MinWinWidth,sizeof(MyConfig.MinWinWidth)},
	{"SDEPTH_OFFSET",&MyConfig.SDepthOffset,sizeof(MyConfig.SDepthOffset)},
	{"OPAQUE_SPEED",&MyConfig.OpaqueSPEED,sizeof(MyConfig.OpaqueSPEED)},
	{"OPAQUE_MAXDEPTH",&MyConfig.OpaqueMAXDEPTH,sizeof(MyConfig.OpaqueMAXDEPTH)},
	{"OPAQUE_MAXPIXELS",&MyConfig.OpaqueMAXPIXELS,sizeof(MyConfig.OpaqueMAXPIXELS)},
	{"OPAQUE_MAXBYTES",&MyConfig.OpaqueMAXBYTES,sizeof(MyConfig.OpaqueMAXBYTES)},
	{0,0}
};

/*===================================================*/

static void Init(struct ConfigMsg *msg)
{
	DOSBase=msg->DOSBase;
	IntuitionBase=msg->IntuitionBase;
	DiskfontBase=msg->DiskfontBase;
}

static int IntNachricht(char *body,char *auswahl)
{
	struct EasyStruct es = {sizeof(es),
		                     0,
		                     "PowerWindows",
		                     body,
		                     auswahl};
	

	if (!IntuitionBase) return -1;

	return EasyRequestArgs(0,&es,0,0);
}

static void Hinweis(char *body)
{
	if (IntuitionBase)
	{
		IntNachricht(body,"I see!");
	} else {
		printf("PowerWindows: %s",body);
	}
}

static void ReAlloc(APTR &Old,ULONG size,ULONG size2,ULONG flags)
{
	APTR neu;
	
	if ((neu=AllocVec(size+size2,flags)))
	{
		CopyMem(Old,neu,size);
		FreeVec(Old);
		Old=neu;
	}
}

/*===================================================*/

void ScanQualifier(char *s,UWORD &quali,BOOL &doquali)
{
	UWORD w;
	BOOL ok;
	WORD i;
	char s2[255];
	
	if (strcmp(s,"OFF")==0 || strcmp(s,"NONE")==0)
	{
		doquali=FALSE;
		return;
	}
	w=0;
	ok=FALSE;
	do {
		i=Pos('+',s);
		if (i>=0)
		{
			if (i>0) strncpy(s2,s,i);
			s2[i]=0; 				/* s2=Copy(s,1,i-1) */
			memmove(s,&s[i+1],strlen(s)-i);	/* Delete(s,1,i) */
		} else {
			strcpy(s2,s);
			ok=TRUE;
		}
		if (strcmp(s2,"LSHIFT")==0) w=w|IEQUALIFIER_LSHIFT; else
		if (strcmp(s2,"RSHIFT")==0) w=w|IEQUALIFIER_RSHIFT; else
		if (strcmp(s2,"SHIFT")==0) w=w|IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT; else
		if (strcmp(s2,"CAPSLOCK")==0) w=w|IEQUALIFIER_CAPSLOCK; else
		if (strcmp(s2,"CONTROL")==0) w=w|IEQUALIFIER_CONTROL; else
		if (strcmp(s2,"LALT")==0) w=w|IEQUALIFIER_LALT; else
		if (strcmp(s2,"RALT")==0) w=w|IEQUALIFIER_RALT; else
		if (strcmp(s2,"ALT")==0) w=w|IEQUALIFIER_LALT|IEQUALIFIER_RALT; else
		if (strcmp(s2,"LCOMMAND")==0) w=w|IEQUALIFIER_LCOMMAND; else
		if (strcmp(s2,"RCOMMAND")==0) w=w|IEQUALIFIER_RCOMMAND; else
		if (strcmp(s2,"COMMAND")==0) w=w|IEQUALIFIER_LCOMMAND|IEQUALIFIER_RCOMMAND; else
		if (strcmp(s2,"MIDBUTTON")==0) w=w|IEQUALIFIER_MIDBUTTON;
	} while (!ok);
	quali=w;
	doquali=(w!=0);
}

static LONG FindStringMatch(char *s,struct StringMatch *sm)
{
	WORD i=0;
	LONG rc=-1;
	
	for (;;)
	{
		if (!sm[i].string) break;
		if (strcmp(s,sm[i].string)==0)
		{
			rc=sm[i].data;
			break;
		}
		i++;
	}
	return rc;
}

static void SetButton (char *s,UWORD &KeyDOWN,UWORD &KeyUP)
{
	LONG i;
	
	static struct StringMatch sm[] =
	{
		{"LEFT",IECODE_LBUTTON},
		{"RIGHT",IECODE_RBUTTON},
		{"MIDDLE",IECODE_MBUTTON},
		{0,0}
	};

	if ((i=FindStringMatch(s,sm))!= -1)
	{
		KeyDOWN=i;
	}

	KeyUP=KeyDOWN|IECODE_UP_PREFIX;
}

static void SetIconWidth(char *s)
{
	ULONG l;
	char *s2;
	
	if ((s2=strchr(s,'/')))
	{
		*s2++ = 0;
		l=strtol(s2,0,10);
		if (l>0)
		{
			MyConfig.DoIconWidthDiv=TRUE;
			MyConfig.IconWidthDiv=l;
		}
	} else MyConfig.DoIconWidthDiv=FALSE;

	if (strstr(s,"WINWIDTH"))
	{
		MyConfig.IconWidthFac=IW_WINWIDTH;
	} else {
		MyConfig.IconWidthFac=strtol(s,0,10);
	}
}

static void SetIconPos(char *s)
{
	LONG i;

	static struct StringMatch sm[] =
	{
		{"UPPERLEFT",IP_UPPERLEFT},
		{"UPPERRIGHT",IP_UPPERRIGHT},
		{"LOWERLEFT",IP_LOWERLEFT},
		{"LOWERRIGHT",IP_LOWERRIGHT},
		{"CENTER",IP_CENTER},
		{"AUTO_BOTTOMLEFT",IP_AUTOBOTTOMLEFT},
		{"AUTO_BOTTOMRIGHT",IP_AUTOBOTTOMRIGHT},
		{"AUTO_TOPLEFT",IP_AUTOTOPLEFT},
		{"AUTO_TOPRIGHT",IP_AUTOTOPRIGHT},
		{"AUTO_LEFTTOP",IP_AUTOLEFTTOP},
		{"AUTO_LEFTBOTTOM",IP_AUTOLEFTBOTTOM},
		{"AUTO_RIGHTTOP",IP_AUTORIGHTTOP},
		{"AUTO_RIGHTBOTTOM",IP_AUTORIGHTBOTTOM},
		{0,0}
	};
	
	if ((i=FindStringMatch(s,sm))!= -1)
	{
		MyConfig.IconPosition=i;
	}
}

static void SetIGLook(char *s)
{
	LONG i;
	
	static struct StringMatch sm[] =
	{
		{"NORMAL",ICONIMAGE_NORMAL},
		{"NICE",ICONIMAGE_NICE},
		{"SYSI",ICONIMAGE_SYSI},
		{"SYSINICE",ICONIMAGE_SYSINICE},
		{"SYSIMUI",ICONIMAGE_SYSIMUI},
		{"VISUALPREFS",ICONIMAGE_VISUALPREFS},
		{0,0}
	};
	
	if ((i=FindStringMatch(s,sm))!= -1)
	{
		MyConfig.IconImageType=i;
	}

}

static void FindBool(char *match,BOOL &v,BOOL value)
{
	if (!KeyWordFound)
	{
		if (strcmp(s,match)==0)
		{
			KeyWordFound=TRUE;
			v=value;
		}
	}
}

static void FindLong(char *match,APTR v,WORD varlen)
{
	LONG val;
	
	if (!KeyWordFound)
	{
		if (strcmp(s2,match)==0)
		{
			val=strtol(s,0,10);

			KeyWordFound=TRUE;
			switch(varlen)
			{
				case 1:
					*(BYTE *)v=val;
					break;

				case 2:
					*(WORD *)v=val;
					break;
					
				case 4:
					*(LONG *)v=val;
					break;		
			}
		}
	}
}

static void SetTooltype(char *match,char *ziel)
{
	if (!KeyWordFound)
	{
		if (strcmp(s2,match)==0)
		{
			KeyWordFound=TRUE;
			strncpy(ziel,s,50);
		}
	}
}

static void SetExtRoutine(BPTR &segment,void (* &Routine)(void),ULONG typ)
{
	struct csInit InitMsg={CS_INIT,_ProgVersion_,_ProgRevision_,_ProgSubRevision_,0};
	struct Ext_Header *ext;
	char	*param;

	LONG err;
	BOOL OK;
	
	if (segment)
	{
		Hinweis ("You have specified two filenames for one external\nroutine. Remove one of the entries in the Config-File!");
		return;
	}
	
	if ((param=strchr(s,',')))
	{
		*param++ =0;
		InitMsg.Parameters=param;
	}
	
	segment=NewLoadSeg(s,0);
	if (!segment)
	{
		err=IoErr();
		Fault(err,"Can't load external routine!\n\nDOS-Error",s,255);
		Hinweis(s);
	} else {
		ext=(struct Ext_Header *)BADDR(segment);
		if (ext->Recognition != typ)
		{
			switch (typ)
			{
				case EXT_CHECKSCREEN:
					sprintf(s2,"\"%s\" is not a legal Screen-Checker!",s);
					break;
					
				case EXT_CHECKWINDOW:
					sprintf(s2,"\"%s\" is not a legal Window-Checker!",s);
					break;
					
				case EXT_RENDERICON:
					sprintf(s2,"\"%s\" is not a legal Icon-Renderer!",s);
					break;
	
				default:
					sprintf(s2,"\"%s\" is not a legal Routine!",s);
					break;
	
			}
			Hinweis(s2);
			UnLoadSeg(segment);segment=0;
		} /* Recognition != typ */
		
		if (segment)
		{
			Routine=ext->Routine;
			OK=TRUE;
			switch (typ)
			{
				case EXT_CHECKSCREEN:
					if (MyConfig.ScreenChecker((Msg)&InitMsg)==0)
					{
						sprintf(s2,"Initialisation of ext. Screen-Checker \"%s\" failed!",s);
						OK=FALSE;
					}
					break;
						
				case EXT_CHECKWINDOW:
					if (MyConfig.WindowChecker((Msg)&InitMsg)==0)
					{
						sprintf(s2,"Initialisation of ext. Window-Checker \"%s\" failed!",s);
						OK=FALSE;
					}
					break;
		
				case EXT_RENDERICON:
					if (MyConfig.IconRenderer((Msg)&InitMsg)==0)
					{
						sprintf(s2,"Initialisation of Icon-Renderer \"%s\" failed!",s);
						OK=FALSE;
					};
					break;
			} /* switch typ */
			if (!OK)
			{
				Routine=0;
				UnLoadSeg(segment);segment=0;
			}
		} /* if segment */
	}	/* if segment */
}

static void DoSetFont (struct TextFont *& font,BYTE &style)
{
	struct TextAttr tattr;
	char	*t,*t2;
	char	FehlerS[257];
	
	if (font)
	{
		CloseFont(font);font=0;
	}
	
	if (!(t=strchr(s,'/')))
	{
		sprintf(s2,"You forgot to specify the font size. Line %ld\n",LinePos);
		Hinweis(s2);
		return;
	}


	if ((t2=strchr(t+1,'/')))
	{
		if (strchr(t2+1,'B')) style|=FSF_BOLD;
		if (strchr(t2+1,'I')) style|=FSF_ITALIC;
		if (strchr(t2+1,'U')) style|=FSF_UNDERLINED;
		printf(">> %ld <<\n",tattr.ta_Style);
		*t2=0;
	}
	
	tattr.ta_YSize=strtol(t+1,0,10);
	*t=0;
	if (!strstr(s,".font"))
	{
		strcat(s,".font");
	}
	tattr.ta_Style=0;
	tattr.ta_Name=s;
	tattr.ta_Flags=0;
	
	
	if (!(font=OpenDiskFont(&tattr)))
	{
		Fault(IoErr(),0,s2,255);
		sprintf(FehlerS,"Error while trying to open font \"%s\" size %ld (Line %ld):\n\n%s",tattr.ta_Name,tattr.ta_YSize,LinePos,s2);
		Hinweis(FehlerS);		
	}
}

static BOOL AddTaskEntry(struct TaskEntry *& tpos,struct Node **& NodePTR,BOOL sensitive,BOOL &AnyThere)
{
	WORD i2,i3;
	STRPTR ss=s;
	
	if (s[0] == '!') ss++;

	i2=strlen(ss)*2+4;
	switch (sensitive)
	{
		case FALSE: i3=ParsePatternNoCase(ss,&tpos->te_Pattern,i2);
						break;
		case TRUE:  i3=ParsePattern(ss,&tpos->te_Pattern,i2);
						break;
	}
	if (i3 != -1)
	{
		*NodePTR++=(struct Node *)tpos;
		switch (i3)
		{
			case 0: tpos->te_MatchType=MATCH_NORMAL;
					  break;
			case 1: tpos->te_MatchType=MATCH_PATTERN;
					  break;
		}

		if (ss != (STRPTR)s) tpos->te_Flags=TEF_DONTPATCHANYTHING;

		AnyThere=TRUE;
		(UBYTE *)tpos+= (i2+sizeof(struct TaskEntry));
		if ((LONG)tpos & 1) (UBYTE *)tpos++;
		return TRUE;
	}
	
	return FALSE;
}


static void NewMemPos(UBYTE *& Speicher,struct TaskEntry * SpeicherPos,struct Node ** Nodes,struct List *& list)
{
	struct Node **NodePTR;

	UBYTE *OldSpeicher;
	LONG  l;

	OldSpeicher=Speicher;
	l=(ULONG)SpeicherPos-(ULONG)Speicher;
	if (l>4) ReAlloc(Speicher,l,4,MEMF_CLEAR|MEMF_PUBLIC);

	l=Speicher-OldSpeicher;
	NodePTR=Nodes;
	
	while(*NodePTR)
	{
		AddTail(list,(struct Node *)(ULONG(*NodePTR)+l));
		NodePTR++;
	}
}

void ScanPrefs(struct ConfigMsg *msg)
{
	struct TaskEntry *TaskPos,*IconifyTaskPos;
	struct Node **TNodes,**TNodePTR,
					**INodes,**INodePTR;

	BPTR MyHandle;
	UBYTE *Speicher;
	char *SPos;
	char c;
	LONG FileLen;
	WORD i,i2,LineLen;
	BOOL IsFound,DoUpper,
		  KillSP,Done,bol;		/* IsFound steht fuer "="-Found !! */
	

	Init(msg);
	MyConfig=*msg->config;

	if (msg->filename[0])
	{
		MyHandle=Open(msg->filename,MODE_OLDFILE);
	} else {
		MyHandle=Open(ConfigFile1,MODE_OLDFILE);
		if (!MyHandle) MyHandle=Open(ConfigFile2,MODE_OLDFILE);
	}

	if (!MyHandle)
	{
		Fault(IoErr(),"Can't open Config-File",s2,255);
		Hinweis(s2);
		return;
	}
	
	FileLen=Seek(MyHandle,0,OFFSET_END);
	FileLen=Seek(MyHandle,0,OFFSET_BEGINNING);

	TaskSpeicherLen=FileLen*4;
	IconifyTaskSpeicherLen=FileLen*4;

	Speicher=(UBYTE *)AllocVec(FileLen+1,MEMF_CLEAR);
	MyConfig.TaskSpeicher=(UBYTE *)AllocVec(FileLen*4,msg->OSVersion>=39 ? MEMF_CLEAR|MEMF_PUBLIC|MEMF_REVERSE : MEMF_CLEAR|MEMF_PUBLIC);
	MyConfig.IconifyTaskSpeicher=(UBYTE *)AllocVec(FileLen*4,msg->OSVersion>=39 ? MEMF_CLEAR|MEMF_PUBLIC|MEMF_REVERSE : MEMF_CLEAR|MEMF_PUBLIC);
	TNodes=AllocVec(2000,msg->OSVersion>=39 ? MEMF_CLEAR|MEMF_PUBLIC|MEMF_REVERSE : MEMF_CLEAR|MEMF_PUBLIC);
	INodes=AllocVec(2000,msg->OSVersion>=39 ? MEMF_CLEAR|MEMF_PUBLIC|MEMF_REVERSE : MEMF_CLEAR|MEMF_PUBLIC);

	if ((!Speicher) || (!MyConfig.TaskSpeicher) || (!MyConfig.IconifyTaskSpeicher) || (!TNodes) || (!INodes))
	{
		if (Speicher) FreeVec(Speicher);
		if (MyConfig.TaskSpeicher) FreeVec(MyConfig.TaskSpeicher);
		if (MyConfig.IconifyTaskSpeicher) FreeVec(MyConfig.IconifyTaskSpeicher);
		if (TNodes) FreeVec(TNodes);
		if (INodes) FreeVec(INodes);
		Close(MyHandle);
		return;
	}

	TNodePTR=TNodes;
	INodePTR=INodes;
	
	l=Read(MyHandle,Speicher,FileLen);
	Close(MyHandle);

	if (l!=FileLen)
	{
		if (Speicher) FreeVec(Speicher);
		if (MyConfig.TaskSpeicher) FreeVec(MyConfig.TaskSpeicher);
		if (MyConfig.IconifyTaskSpeicher) FreeVec(MyConfig.IconifyTaskSpeicher);
		if (TNodes) FreeVec(TNodes);
		if (INodes) FreeVec(INodes);
		return;
	}

	Done=FALSE;
	SPos=(char *)Speicher;
	TaskPos=(struct TaskEntry *)MyConfig.TaskSpeicher;
	IconifyTaskPos=(struct TaskEntry *)MyConfig.IconifyTaskSpeicher;
	s[0]=0;
	LinePos=0;
	LineLen=0;
	do {
		c = *SPos;
		switch (c)
		{
			case 0:
				Done=TRUE;

			case 10:
				LinePos++;
				i2=strlen(s);
				if (i2>0) if ((s[0]!=';') && (s[0]!='*') && (s[0]!='\t') && (s[0]!=' '))
				{
					i=0;s2[0]=0;
					DoUpper=TRUE;
					IsFound=FALSE;
					KillSP=TRUE;

					while (i<i2)
					{
						if ((s[i]=='=') && (!IsFound))
						{
							IsFound=TRUE;
							strcpy(s2,s);s2[i]=0;
							if ((strcmp(s2,"TASK")==0) ||
								 (strcmp(s2,"ICONIFYTASK")==0) ||
								 (strstr(s2,"HOT_")) ||
								 (strstr(s2,"FONT"))) DoUpper=FALSE;

						} else {						
							if (s[i]>='a' && s[i]<='z' && DoUpper) s[i]=toupper(s[i]);
							if (s[i]==9 || s[i]==' ' || s[i]=='"')
							{
								if (s[i]=='"') KillSP= !KillSP;
								if (KillSP || (s[i]=='"'))
								{
									memmove(&s[i],&s[i+1],strlen(s)-i);
									--i2;
									--i;
								}
							}
						}
						i++;
					}


/* Kill End-Of-Line Rems */

					i=strlen(s)-1;
					while (i>=0)
					{
						if (s[i]==';')
						{
							s[i]=0;
							break;
						}
						i--;
					}
					
					
					KeyWordFound=FALSE;

					i=Pos('=',s);
					if (i>0)
					{
						if (i<strlen(s)-1)
						{
							memmove(s,&s[i+1],strlen(s)-i);
						} else s[0]=0;

						if (strcmp(s2,"TASK")==0)
						{
							AddTaskEntry(TaskPos,TNodePTR,MyConfig.CaseSensitive,MyConfig.AnyTasksThere);
						} else if (strcmp(s2,"ICONIFYTASK")==0)
						{
							AddTaskEntry(IconifyTaskPos,INodePTR,MyConfig.IconifyCaseSensitive,MyConfig.AnyIconifyTasksThere);
						} else if (strcmp(s2,"MARKER")==0)
						{
							if (strcmp(s,"OFF")==0) MyConfig.MarkerTyp=MARKER_NONE; else
							if (strcmp(s,"GADGET")==0) MyConfig.MarkerTyp=MARKER_GADGET; else
							if (strcmp(s,"EXTENDED")==0) MyConfig.MarkerTyp=MARKER_EXTENDED;
						} else if (strcmp(s2,"NORMALQUALIFIER")==0)
						{
							ScanQualifier(s,MyConfig.NormalQuali,MyConfig.DoNormalQuali);
						} else if (strcmp(s2,"FORCEQUALIFIER")==0)
						{
							ScanQualifier(s,MyConfig.ForceQuali,MyConfig.DoForceQuali);
						} else if (strcmp(s2,"MULTIQUALIFIER")==0)
						{
							ScanQualifier(s,MyConfig.MultiQuali,MyConfig.DoMultiQuali);
						} else if (strcmp(s2,"NORMALBUTTON")==0)
						{
							SetButton(s,MyConfig.ButtonDOWN,MyConfig.ButtonUP);
						} else if (strcmp(s2,"FORCEBUTTON")==0)
						{
							SetButton(s,MyConfig.ForceButtonDOWN,MyConfig.ForceButtonUP);
						} else if (strcmp(s2,"MULTIBUTTON")==0)
						{
							SetButton(s,MyConfig.MultiButtonDOWN,MyConfig.MultiButtonUP);
						} else if (strcmp(s2,"ICONPOS")==0)
						{
							SetIconPos(s);
						} else if (strcmp(s2,"ICONWIDTH")==0) 
						{
							SetIconWidth(s);
						} else if (strcmp(s2,"IGLOOK")==0)
						{
							SetIGLook(s);
						} else if (strcmp(s2,"EXT_WINDOWCHECKER")==0)
						{
							SetExtRoutine(MyConfig.WindowChecker_Seg,(void (*)(void))MyConfig.WindowChecker,EXT_CHECKWINDOW);
						} else if (strcmp(s2,"EXT_SCREENCHECKER")==0)
						{
							SetExtRoutine(MyConfig.ScreenChecker_Seg,(void (*)(void))MyConfig.ScreenChecker,EXT_CHECKSCREEN);
						} else if (strcmp(s2,"EXT_ICONRENDERER")==0)
						{
							SetExtRoutine(MyConfig.IconRenderer_Seg,(void (*)(void))MyConfig.IconRenderer,EXT_RENDERICON);
						} else if (strcmp(s2,"ICONDEPTH")==0)
						{
							if (strcmp(s,"ALWAYSFRONT")==0) MyConfig.IconDepth=ID_ALWAYSFRONT;
							if (strcmp(s,"NORMAL")==0) MyConfig.IconDepth=ID_NORMAL;
							if (strcmp(s,"NORMALBEHIND")==0) MyConfig.IconDepth=ID_NORMALBEHIND;
						} else if (strcmp(s2,"INPUTPRI")==0)
						{
							MyConfig.InputPri=(BYTE)strtol(s,0,10);
						} else if (strcmp(s2,"DP")==0)	/* DONT PATCH <NUMMER IN PATCHTABLE> */
						{
							i2=strtol(s,0,10);
							if ((i2>0) && (i2<msg->numpatches))
							{
								MyConfig.PatchTable[i2].DoPatch=FALSE;
							}
						} else if (strcmp(s2,"ICONFONT")==0)
						{
							DoSetFont(MyConfig.IconFont,MyConfig.IconFontStyle);
						} else {
							SetTooltype("HOT_ICONSTOFRONT",MyConfig.IconFrontHotKey);
							SetTooltype("HOT_ICONSTOBACK",MyConfig.IconBackHotKey);
							SetTooltype("HOT_DEICONIFYALL",MyConfig.DeIconifyAllHotKey);
							SetTooltype("HOT_WINDOWIN",MyConfig.WindowsInHotKey);
							SetTooltype("HOT_ALLWINDOWSIN",MyConfig.WindowsInAllHotKey);
							SetTooltype("HOT_ICONIFY",MyConfig.IconifyHotKey);
							SetTooltype("HOT_PATCHSCREEN",MyConfig.PatchScrHotKey);
							SetTooltype("HOT_UNPATCHSCREEN",MyConfig.UnPatchScrHotKey);

							if (!KeyWordFound)
							{
								i=0;
								for (;;)
								{
									if (!LongArray[i].string) break;
									FindLong(LongArray[i].string,LongArray[i].var,LongArray[i].varlen);
									if (KeyWordFound) break;
									i++;
								}
							}

							if (!KeyWordFound)
							{
								sprintf(s,"Keyword \"%s\" in Config-File (Line %ld) is unknown!\n",s2,LinePos);
								Hinweis(s);
							}
						}
							
					} else {
						i=0;
						for (;;)
						{
							if (!BoolArray[i].string) break;
							FindBool(BoolArray[i].string,BoolArray[i].var,TRUE);
							if (KeyWordFound) break;
							i++;
						}
							
						if (!KeyWordFound)
						{
							bol=FALSE;FindBool("TASKSONLY",bol,TRUE);if (bol) MyConfig.TaskXOR=1;
							bol=FALSE;FindBool("ICONIFYTASKSONLY",bol,TRUE);if (bol) MyConfig.IconifyTaskXOR=1;

							if (!KeyWordFound)
							{
								sprintf(s2,"Keyword \"%s\" in Config-File (Line %ld) is unknown!\n",s,LinePos);
								Hinweis(s2);
							}
						}
					}
				}
				LineLen=0;
				s[0]=0;
				break;

			default:
				s[LineLen]=c;s[++LineLen]=0;
		}
		SPos++;
	} while (!Done);
	FreeVec(Speicher);
	
	NewMemPos(MyConfig.TaskSpeicher,TaskPos,TNodes,MyConfig.TaskList);
	NewMemPos(MyConfig.IconifyTaskSpeicher,IconifyTaskPos,INodes,MyConfig.IconifyTaskList);
	
	FreeVec(TNodes);
	FreeVec(INodes);


#ifdef DebugMe
	TaskPos=(struct TaskEntry *)TaskList.lh_Head;
	while (TaskPos->te_Node.mln_Succ)
	{
		printf("TaskList: %s\n",&TaskPos->te_Pattern);
		TaskPos=(struct TaskEntry *)TaskPos->te_Node.mln_Succ;
	}
	TaskPos=(struct TaskEntry *)IconifyTaskList.lh_Head;
	while (TaskPos->te_Node.mln_Succ)
	{
		printf("Iconify-TaskList: %s\n",&TaskPos->te_Pattern);
		TaskPos=(struct TaskEntry *)TaskPos->te_Node.mln_Succ;
	}
#endif

	*msg->config=MyConfig;
}