/*
   ***************************************************************************
   *
   * Datei:
   *      RSysFindFile.c
   *
   * Inhalt:
   *
   *      --- Globale Routinen ---
   *
   *    void FindFile ( void );
   *    void HandleFindFileKeys ( ULONG code );
   *    void MakeDevEntry ( LIST *list , char *str );
   *
   *      --- Lokale  Routinen ---
   *
   *    static BOOL ClickedGadget ( void );
   *    static int OpenFindFileWindow ( void );
   *    static void *MyDevAllocRem ( long size );
   *    static void *MyFileAllocRem ( long size );
   *    static void HandleFindFileGadgets ( APTR object , ULONG code );
   *    static void MakeDevList ( void );
   *    static void MakeFileEntry ( char *str );
   *    static void refreshdevlists ( void );
   *    static void SaveFoundFiles ( void );
   *    static void SearchFile ( char *name );
   *
   * Bemerkungen:
   *      Disk-Format-Untersützung und Dateisuchroutinen.
   *
   * Erstellungsdatum:
   *      07-Jul-93     Rolf Böhme
   *
   * Änderungen:
   *      07-Jul-93     Rolf Böhme        Erstellung
   *
   ***************************************************************************
 */

#include "RSys.h"
#include "protos.h"

static int breakitx = FALSE;

static WINDOW *FindFileWnd = NULL;
static GADGET *FindFileGList = NULL;
static UWORD FindFileZoom[4];
static GADGET *FindFileGadgets[10];
static UWORD FindFileLeft = 153;
static UWORD FindFileTop = 27;
static UWORD FindFileWidth = 330;
static UWORD FindFileHeight = 200;
static UBYTE FindFileWdt[100];	/*GMD */
static UBYTE *CaseCYGad0Labels[] =
{
  (UBYTE *) "No case sense",
  (UBYTE *) "Case sense",
  NULL
};
static UBYTE *DirFileCYGad0Labels[] =
{
  (UBYTE *) "Dirs + Files",
  (UBYTE *) "Files",
  (UBYTE *) "Directories",
  NULL};

static LIST DevList;
static LIST SelDevList, FoundList;

REMEMBER *DevKey = NULL;
static REMEMBER *FileKey = NULL;

static char pat[PATTERNLEN], parsepat[PARSEPATLEN];
static int match_case = NO_CASE, match_type = DF;

static UWORD FindFileGTypes[] =
{
  LISTVIEW_KIND,
  LISTVIEW_KIND,
  STRING_KIND,
  BUTTON_KIND,
  LISTVIEW_KIND,
  BUTTON_KIND,
  BUTTON_KIND,
  BUTTON_KIND,
  CYCLE_KIND,
  CYCLE_KIND
};

static NEWGADGET FindFileNGad[] =
{
  4, 17, 157, 60, (UBYTE *) "Devices", NULL, GD_DeviceLV, PLACETEXT_ABOVE, NULL, NULL,
  168, 17, 157, 60, (UBYTE *) "Selected Devices", NULL, GD_SelDevLV, PLACETEXT_ABOVE | NG_HIGHLABEL, NULL, NULL,
  74, 113, 87, 13, (UBYTE *) "Pattern", NULL, GD_PatternGad, PLACETEXT_LEFT, NULL, NULL,
  4, 97, 157, 13, (UBYTE *) "Start/Stop Search", NULL, GD_StartStopGad, PLACETEXT_IN, NULL, NULL,
  4, 144, 321, 52, (UBYTE *) "Found files/dirs", NULL, GD_FoundLV, PLACETEXT_ABOVE | NG_HIGHLABEL, NULL, NULL,
  168, 97, 157, 13, (UBYTE *) "Save found list", NULL, GD_SaveFoundListGad, PLACETEXT_IN, NULL, NULL,
  168, 81, 77, 13, (UBYTE *) "Sel all", NULL, GD_AllGad, PLACETEXT_IN, NULL, NULL,
  248, 81, 77, 13, (UBYTE *) "Sel none", NULL, GD_NoneGad, PLACETEXT_IN, NULL, NULL,
  4, 81, 157, 13, NULL, NULL, GD_CaseCYGad, 0, NULL, NULL,
  168, 113, 157, 13, NULL, NULL, GD_DirFileCYGad, 0, NULL, NULL
};

static ULONG *FindFileGTags[] =
{
  (ULONG *) (GTLV_Labels), (ULONG *) & DevList, (ULONG *) (TAG_DONE),
  (ULONG *) (GTLV_Labels), (ULONG *) & SelDevList, (ULONG *) (TAG_DONE),
  (ULONG *) (GTST_MaxChars), (ULONG *) 256, (ULONG *) (TAG_DONE),
  (ULONG *) (GA_Disabled), (ULONG *) TRUE, (ULONG *) (TAG_DONE),
  (ULONG *) (GTLV_Labels), (ULONG *) & FoundList, (ULONG *) (GTLV_ReadOnly), (ULONG *) TRUE, (ULONG *) (TAG_DONE),
  (ULONG *) (TAG_DONE),
  (ULONG *) (TAG_DONE),
  (ULONG *) (TAG_DONE),
  (ULONG *) (GTCY_Labels), (ULONG *) & CaseCYGad0Labels[0], (ULONG *) (TAG_DONE),
  (ULONG *) (GTCY_Labels), (ULONG *) & DirFileCYGad0Labels[0], (ULONG *) (TAG_DONE)
};

static int gl[] =
{GD_DeviceLV - GD_DeviceLV,
 GD_SelDevLV - GD_DeviceLV,
 GD_PatternGad - GD_DeviceLV,
 GD_FoundLV - GD_DeviceLV};

 /*
  * OpenFindFileWindow() öffnet ein Window mit Gadgets, mit
  * denen die Auswahl- und Suchkriterien eingegeben werden
  * können
  */
static int
OpenFindFileWindow (void)
{
  NEWGADGET ng;
  GADGET *g;
  UWORD lc, tc;
  UWORD wleft = FindFileLeft, wtop = FindFileTop, ww, wh;

  DPOS;

  AdjustWindowDimensions (Scr, FindFileLeft, FindFileTop, FindFileWidth, FindFileHeight,
			  &wleft, &wtop, &ww, &wh);

  if (!(g = CreateContext (&FindFileGList)))
    return 1L;

  for (lc = 0, tc = 0; lc < FindFile_CNT; lc++)
    {
      CopyMem ((char *) &FindFileNGad[lc], (char *) &ng, (long) sizeof (NEWGADGET));

      ng.ng_VisualInfo = VisualInfo;
      ng.ng_TextAttr = Font;
      ng.ng_LeftEdge = OffX + ComputeX (ng.ng_LeftEdge);
      ng.ng_TopEdge = OffY + ComputeY (ng.ng_TopEdge);
      ng.ng_Width = ComputeX (ng.ng_Width);
      ng.ng_Height = ComputeY (ng.ng_Height);

      FindFileGadgets[lc] = g = CreateGadgetA ((ULONG) FindFileGTypes[lc], g, &ng, (TAGITEM *) & FindFileGTags[tc]);

      makelabelvisible (FindFileGadgets[lc]);

      while (FindFileGTags[tc])
	tc += 2;
      tc++;

      if (NOT g)
	return 2L;
    }

  strcpy (FindFileWdt, get_vers (" - Find File"));	/*GMD */

  FindFileZoom[2] = TextLength (&Scr->RastPort, (UBYTE *) FindFileWdt,
				strlen ((char *) FindFileWdt)) + 80;
  FindFileZoom[0] = FindFileZoom[1] = 0;
  FindFileZoom[3] = Scr->WBorTop + Scr->RastPort.TxHeight + 1;

  if (!(FindFileWnd = OpenWindowTags (NULL,
				      WA_Left, wleft,
				      WA_Top, wtop,
				      WA_Width, ww,
				      WA_Height, wh,
				      WA_IDCMP, IDCMP_VANILLAKEY |
				      LISTVIEWIDCMP |
				      STRINGIDCMP |
				      BUTTONIDCMP |
				      CYCLEIDCMP |
				      IDCMP_CLOSEWINDOW |
				      IDCMP_CHANGEWINDOW |
				      IDCMP_REFRESHWINDOW,
				      WA_Flags, WFLG_DRAGBAR |
				      WFLG_DEPTHGADGET |
				      WFLG_CLOSEGADGET |
				      WFLG_RMBTRAP |
				      WFLG_ACTIVATE |
				      WFLG_SMART_REFRESH,
				      WA_Title, FindFileWdt,
				      WA_Zoom, FindFileZoom,
				      WA_PubScreenFallBack, TRUE,
				      WA_PubScreen, Scr,
				      TAG_DONE)))
    return 4L;

  FindFileZoom[0] = FindFileWnd->LeftEdge;
  FindFileZoom[1] = FindFileWnd->TopEdge;
  FindFileZoom[2] = FindFileWnd->Width;
  FindFileZoom[3] = FindFileWnd->Height;

  RefreshRastPort (FindFileWnd, FindFileGadgets, gl, 4, FALSE, FindFileGList);

  return NULL;
}

 /*
  * MyDevAllocRem() reserviert Speicher aus einer Remember-Liste
  * für die Verzeichnis-Einträge
  */
static void *
MyDevAllocRem (long size)
{
  void *ptr = (void *) AllocRemember (DEVKEY, size, MEMF_CLEAR | MEMF_ANY);

  if (NOT (ptr))
    {
      ErrorHandle ("Device list", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
      Flags.quit_ff = 1;
    }

  return (ptr);
}

 /*
  * MyFileAllocRem() reserviert Speicher aus einer Remember-Liste
  * für die Datei-Einträge
  */
static void *
MyFileAllocRem (long size)
{
  void *ptr = (void *) AllocRemember (FILEKEY, size, MEMF_CLEAR | MEMF_ANY);

  if (NOT (ptr))
    {
      ErrorHandle ("File list", MEMORY_ERR, ALLOC_FAIL, NO_KILL);
      Flags.quit_ff = 1;
    }

  return (ptr);
}

 /*
  * refreshdevlists() erneuert die Anzeige der ListViews mit den
  * Inhalten der Listen der selektierten und der nicht selektierten
  * Devices
  */
static void
refreshdevlists (void)
{
  InitListView (FindFileWnd, FindFileGadgets[GD_DeviceLV - GD_DeviceLV], &DevList, UNSETLVPOS);
  InitListView (FindFileWnd, FindFileGadgets[GD_SelDevLV - GD_DeviceLV], &SelDevList, UNSETLVPOS);

  return;
}

 /*
  * MakeDevEntry() erzeugt einen neuen Listeneintrag in die
  * Liste der Devices
  */
void
MakeDevEntry (LIST * list, char *str)
{
  NODE *node = MyDevAllocRem (sizeof (NODE));

  if (NOT (node))
    return;

  node->ln_Pri = 0;
  node->ln_Type = NT_USER;

  node->ln_Name = MyDevAllocRem (strlen (str) + 1);
  if (NOT (node->ln_Name))
    return;

  strcpy (node->ln_Name, str);

  AddNodeSorted (list, node, 0);

  return;
}

 /*
  * MakeFileEntry() erzeugt einen Listeneintrag in die Liste der
  * gefundenen Dateien. Der Eintrag wird dann in die bestehende
  * Liste alphabetisch einsortiert
  */
static void
MakeFileEntry (char *str)
{
  NODE *node = MyFileAllocRem (sizeof (NODE));

  if (NOT (node))
    return;

  node->ln_Pri = 0;
  node->ln_Type = NT_USER;
  node->ln_Name = MyDevAllocRem (strlen (str) + 1);

  if (NOT (node->ln_Name))
    return;

  strcpy (node->ln_Name, str);

  AddNodeSorted (&FoundList, node, 0);

  InitListView (FindFileWnd, FindFileGadgets[GD_FoundLV - GD_DeviceLV], &FoundList, UNSETLVPOS);

  return;
}


 /*
  * MakeDevList() erzeugt eine Liste aus angemeldeten Devices
  * (Volumes) und Assigns. Die Devices werden der Reihe nach
  * ausgelesen und in die Liste einsortiert. Assigns werden mit
  * einem führenden "-" versehen, damit sie in der Liste
  * unterschieden werden können
  */
static void
MakeDevList (void)
{
  char dev[80], str[100];
  DOSLIST *dl;

  dl = LockDosList (LDF_VOLUMES | LDF_READ);

  while (dl = NextDosEntry (dl, LDF_VOLUMES | LDF_READ))
    {
      sprintf (str, " %s:", B2CStr (dev, dl->dol_Name));
      MakeDevEntry (&DevList, str);
    }

  UnLockDosList (LDF_VOLUMES | LDF_READ);

  dl = LockDosList (LDF_ASSIGNS | LDF_READ);

  while (dl = NextDosEntry (dl, LDF_ASSIGNS | LDF_READ))
    {
      sprintf (str, "\-%s:", B2CStr (dev, dl->dol_Name));
      MakeDevEntry (&DevList, str);
    }

  UnLockDosList (LDF_ASSIGNS | LDF_READ);

  return;
}


 /*
  * ClickedGadget() prüft, ob das Start/Stop-Gadget betätigt
  * wurde. Mit einem AutoRequester wird nachgefragt, ob die
  * Suche nach Dateien eingestellt werden soll
  */
static BOOL
ClickedGadget (void)
{
  INTUIMESSAGE *mess;
  ULONG class;
  APTR adr;
  BOOL ret = FALSE;

  while ((mess = (INTUIMESSAGE *) GT_GetIMsg (FindFileWnd->UserPort)) != NULL)
    {
      class = mess->Class;
      adr = mess->IAddress;

      GT_ReplyIMsg (mess);

      switch (class)
	{
	case IDCMP_CHANGEWINDOW:
	case IDCMP_REFRESHWINDOW:
	  RefreshRastPort (FindFileWnd, FindFileGadgets, gl, 4, TRUE, NULL);
	  MakeWindowRefresh (FindFileWnd);
	  break;

	case IDCMP_GADGETUP:
	  if ((adr == (APTR) FindFileGadgets[GD_StartStopGad - GD_DeviceLV]) &&
	    Question (FindFileWnd, "Do you want to cancel searching?", YES))
	    {
	      ret = TRUE;
	      breakitx = TRUE;
	    }
	  break;
	}
    }

  return ret;
}

 /*
  * SearchFile() wird rekursiv mit dem dem Namen eines
  * Verzeichnisses oder Devices aufgerufen. Es durchsucht dann
  * alle Verzeichnisse nach vorgegebenem Suchmuster. Die
  * gefundenen Einträge werden in die entsprechenden Listen
  * eingetragen
  */
static void
SearchFile (char *name)
{
  EXALLCONTROL *eac;
  EXALLDATA *EAData, *ead;
  int more;
  BPTR lock;
  UBYTE newdir[MAXFULLNAME], foundname[MAXFULLNAME];
  BOOL (*matchfunc[2]) (UBYTE *, UBYTE *) =
  {
    MatchPatternNoCase, MatchPattern
  };

  if (ClickedGadget () || breakitx || Flags.quit_ff)
    return;

  if (NOT (lock = Lock ((UBYTE *) name, ACCESS_READ)))
    return;

  if (eac = AllocDosObject (DOS_EXALLCONTROL, NULL))
    {
      eac->eac_LastKey = 0;

      EAData = MyAllocVec ((MAXLARGEMEM + 1) * sizeof (EXALLDATA),
			   MEMF_ANY | MEMF_CLEAR, NO_KILL);

      if (EAData)
	{
	  do
	    {
	      more = ExAll (lock, EAData, MAXLARGEMEM * sizeof (EXALLDATA),
			    ED_SIZE, eac);

	      if ((!more) && (IoErr () != ERROR_NO_MORE_ENTRIES))
		{
		  ErrorHandle (name, DOS_EXALL_ERR, EXALL_FAIL, NO_KILL);
		  break;
		}

	      if (eac->eac_Entries == 0)
		continue;

	      ead = EAData;

	      do
		{
		  if ((*matchfunc[match_case]) ((UBYTE *) parsepat,
					 FilePart ((UBYTE *) ead->ed_Name)))
		    {
		      strncpy ((char *) foundname, name, MAXFULLNAME);
		      if (AddPart (foundname, ead->ed_Name, MAXFULLNAME))
			{
			  if (ead->ed_Type > 0)
			    strcat ((char *) foundname, " (dir)");

			  if ((match_type == DF) || ((match_type == FI) && (ead->ed_Type <= 0)) ||
			      ((match_type == DI) && (ead->ed_Type > 0)))
			    MakeFileEntry ((char *) foundname);
			}
		    }

		  if (ead->ed_Type > 0)
		    {
		      strncpy ((char *) newdir, name, MAXFULLNAME);

		      if (AddPart (newdir, ead->ed_Name, MAXFULLNAME))
			SearchFile ((char *) newdir);
		    }

		  ead = ead->ed_Next;
		}
	      while (ead && NOT (ClickedGadget ()) && NOT (breakitx) && NOT (Flags.quit_ff));

	    }
	  while (more);

	  MyFreeVec (EAData);
	}

      FreeDosObject (DOS_EXALLCONTROL, eac);
    }
  else
    ErrorHandle ("ExAll()-Control", MEMORY_ERR, ALLOC_FAIL, NO_KILL);

  UnLock (lock);

  return;
}

 /*
  * SaveFoundFiles() speichert die Liste mit den gefunden
  * Dateien und Verzeichnissen in einer Datei ab
  */
static void
SaveFoundFiles (void)
{
  char head[PARSEPATLEN];

  if (GetFile (FindFileWnd, "RAM:", "RSys-FoundFiles.DAT", "#?.DAT",
	       "Select File for saving list", "Save"))
    {
      sprintf (head, "Found files (Pattern: %s)", pat);
      SaveList (FindFileWnd, (char *) _fullpath, head, &FoundList, FALSE);
    }

  return;
}

static void
HandleFindFileGadgets (APTR object, ULONG code)
{
  NODE *clicknode, *node, *remnode;
  int ID, i;
  LONG (*parse_func[2]) (UBYTE *, UBYTE *, long) =
  {
    ParsePatternNoCase, ParsePattern
  };

  DPOS;

  ID = ((GADGET *) object)->GadgetID;

  HandleHelp ((enum RSysNumbers) ID);

  switch (ID)
    {
    case GD_DeviceLV:
      clicknode = GetNode (&DevList, code);
      Remove (clicknode);
      AddTail (&SelDevList, clicknode);
      refreshdevlists ();

      if (strlen (pat))
	EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], TRUE);
      break;

    case GD_SelDevLV:
      clicknode = GetNode (&SelDevList, code);
      Remove (clicknode);
      AddNodeSorted (&DevList, clicknode, 0);
      refreshdevlists ();

      if (IsListEmpty (&SelDevList))
	EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
      break;

    case GD_PatternGad:
      strncpy (pat, gadgetbuff (FindFileGadgets[GD_PatternGad - GD_DeviceLV]), PATTERNLEN);

      if (strlen (pat) == 0)
	EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
      else if ((*parse_func[match_case]) ((UBYTE *) pat, (UBYTE *) parsepat, 162) < 0)
	EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
      else if (NOT (IsListEmpty (&SelDevList)))
	EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], TRUE);

      break;

    case GD_StartStopGad:
      if (NOT (IsListEmpty (&SelDevList)))
	{
	  if (NOT (IsListEmpty (&FoundList)) && Question (FindFileWnd, "File list not empty!\n"
					     "Do you want to save it?", NO))
	    SaveFoundFiles ();

	  InitListView (FindFileWnd, FindFileGadgets[GD_FoundLV - GD_DeviceLV], NULL, 0);

	  FreeRemember (FILEKEY, TRUE);
	  NewList (&FoundList);

	  InitListView (FindFileWnd, FindFileGadgets[GD_FoundLV - GD_DeviceLV], &FoundList, UNSETLVPOS);

	  for (i = GD_DeviceLV; i <= GD_DirFileCYGad; i++)
	    if ((i != GD_StartStopGad) && (i != GD_FoundLV))
	      EnableGadget (FindFileWnd, FindFileGadgets[i - GD_DeviceLV], FALSE);

	  breakitx = FALSE;

	  for (node = SelDevList.lh_Head; node->ln_Succ; node = node->ln_Succ)
	    SearchFile (&(node->ln_Name)[1]);

	  for (i = GD_DeviceLV; i <= GD_DirFileCYGad; i++)
	    if ((i != GD_StartStopGad) && (i != GD_FoundLV))
	      EnableGadget (FindFileWnd, FindFileGadgets[i - GD_DeviceLV], TRUE);
	}
      break;

    case GD_SaveFoundListGad:
      if (NOT (IsListEmpty (&FoundList)))
	SaveFoundFiles ();
      break;

    case GD_AllGad:
      if (IsListEmpty (&DevList))
	break;

      node = DevList.lh_Head;
      while (node->ln_Succ)
	{
	  remnode = node->ln_Succ;
	  Remove (node);
	  AddTail (&SelDevList, node);
	  node = remnode;
	}

      InitListView (FindFileWnd, FindFileGadgets[GD_DeviceLV - GD_DeviceLV], NULL, 0);
      NewList (&DevList);

      refreshdevlists ();
      if (strlen (pat))
	EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], TRUE);
      break;

    case GD_NoneGad:
      if (IsListEmpty (&SelDevList))
	break;

      node = SelDevList.lh_Head;
      while (node->ln_Succ)
	{
	  remnode = node->ln_Succ;
	  Remove (node);
	  AddNodeSorted (&DevList, node, 0);
	  node = remnode;
	}

      InitListView (FindFileWnd, FindFileGadgets[GD_SelDevLV - GD_DeviceLV], NULL, 0);
      NewList (&SelDevList);

      refreshdevlists ();
      EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);

      break;

    case GD_CaseCYGad:
      match_case = ((match_case == CASE) ? NO_CASE : CASE);
      if (strlen (pat) == 0)
	EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
      else if ((*parse_func[match_case]) ((UBYTE *) pat, (UBYTE *) parsepat, 162) < 0)
	EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], FALSE);
      else
	EnableGadget (FindFileWnd, FindFileGadgets[GD_StartStopGad - GD_DeviceLV], TRUE);
      break;

    case GD_DirFileCYGad:
      match_type = code;
      break;
    }

  return;
}

void
HandleFindFileKeys (ULONG code)
{
  if (code == ESC)
    {
      if (NOT (IsListEmpty (&FoundList)) && Question (FindFileWnd, "File list not empty!\n"
					     "Do you want to save it?", NO))
	SaveFoundFiles ();

      Flags.quit_ff = 1;
    }

  return;
}

 /*
  * FindFile() präsentiert eine Benutzeroberfläche, mit der die
  * Suchkriterien eingestellt und das Handling gemanagt wird
  */
void
FindFile (void)
{
  INTUIMESSAGE *message;
  ULONG class, code;
  APTR object;
  static int refr = TRUE;

  DPOS;

  HandleHelp (MN_FindFile);

  NewList (&DevList);
  NewList (&SelDevList);
  NewList (&FoundList);

  Flags.quit_ff = 0;

  if (OpenASysWindow (OpenFindFileWindow, NO_KILL))
    {
      LockMainWindow (WIN_LOCK);

      MakeDevList ();
      InitListView (FindFileWnd, FindFileGadgets[GD_DeviceLV - GD_DeviceLV], &DevList, UNSETLVPOS);

      do
	{
	  Wait (1L << FindFileWnd->UserPort->mp_SigBit);

	  while ((message = (INTUIMESSAGE *) GT_GetIMsg (FindFileWnd->UserPort)) != NULL)
	    {
	      object = message->IAddress;
	      class = message->Class;
	      code = message->Code;

	      GT_ReplyIMsg (message);

	      switch (class)
		{
		case IDCMP_GADGETUP:
		  HandleFindFileGadgets (object, code);
		  break;

		case IDCMP_VANILLAKEY:
		  HandleFindFileKeys (code);
		  break;

		case IDCMP_CHANGEWINDOW:
		case IDCMP_REFRESHWINDOW:
		  if (NOT (FindFileWnd->Flags & WFLG_ZOOMED))
		    {
		      /*
		       * Das Fenster soll nur EINMAL refreshed werden.
		       * Diese IDCMP-Message kommt aber auch dann, wenn ein
		       * Fenster verschoben wurde, weshalb ein Flag extra
		       * eingeführt wurde.
		       */
		      if (NOT (refr))
			{
			  RefreshRastPort (FindFileWnd, FindFileGadgets, gl, 4, TRUE, NULL);

			  refr = TRUE;
			}
		    }
		  else
		    refr = FALSE;

		  MakeWindowRefresh (FindFileWnd);
		  break;

		case IDCMP_CLOSEWINDOW:
		  if (NOT (IsListEmpty (&FoundList)) && Question (FindFileWnd, "File list not empty!\n"
					     "Do you want to save it?", NO))
		    SaveFoundFiles ();

		  Flags.quit_ff = 1;
		  break;
		}
	    }
	}
      while (NOT (Flags.quit_ff));

      FreeRemember (FILEKEY, TRUE);
      FreeRemember (DEVKEY, TRUE);

      CloseASysWindow (&FindFileWnd, &FindFileGList, NULL);

      LockMainWindow (WIN_UNLOCK);
    }

  return;
}