/******************************************************************
 *                                                                *
 *         Nest version 2 - 3D Wasp Nest Simulator                *
 *            Copyright (C) 1997 Sylvain GUERIN                   *
 *        LIASC, ENST Bretagne & Santa Fe Institute               *
 *                                                                *
 ******************************************************************
 
 E-mail: Sylvain.Guerin@enst-bretagne.fr
 or: Sylvain Guerin
 13 rue des Monts Lorgeaux, 51460 L'EPINE, FRANCE
 
 ******************************************************************
 
 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-1307, USA.
 
 ******************************************************************
     
      Name          : file.c
      Component     : graphical interface and utility
      Fonctionality : contains code refering
                      to the files and directories manipulations
  
 ******************************************************************/


#include <stdio.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "file.h"
#include "nest2.h"

/*******************
 *                 *
 * Public methods  *
 *                 *
 *******************/


FileDatas::FileDatas (char* aHomeDirectory, char* aUser, char* aCurrentDir)
{
  /*  int i; */
  
  strcpy (filter, "*");
  strcpy (user, aUser);
  strcpy (userDirectory, aHomeDirectory);
  strcat (userDirectory, "/");

  numberOfSelectedFiles = 0;
  numberOfFiles = 0;
  numberOfDirectories = 0;

  pathLevelNumber = 0;
  hidesFilesEnabled = 0;
  dirIndex = -1;
  fileIndex = -1;
  
  if (setDirectory (aCurrentDir) == -1)
      {
	  printf ("Error: permission denied for FileDatas creation\n");
      }
}

FileDatas::~FileDatas ()
{
  cleanFilesAndDirectories ();
}

int FileDatas::changeDirectory (char* newPath)
{
  addPath (newPath);
  updateCompleteDirectory ();
  updateShortDirectory ();
  if (scanDisk () == -1)
      {
	  pathLevelNumber--;
	  updateCompleteDirectory ();
	  updateShortDirectory ();
	  scanDisk ();
	  return -1;
      }
  return 0;
}

int FileDatas::backDirectory ()
{

  if (pathLevelNumber > 0)
      {
	  pathLevelNumber--;
	  updateCompleteDirectory ();
	  updateShortDirectory ();
	  if (scanDisk () == -1)
	      {
		  scanDisk ();
		  return -1;
	      }
      }
  else
      {
	  printf ("ERROR: unable to go back: root node reached\n");
	  return -1;
      }
  return 0;
}

int FileDatas::scanDisk ()
{
  DIR *dirp;
  struct stat buf;
  struct dirent *direntp;
  char currentName[50];
  char currentPath[256];
  
  cleanFilesAndDirectories ();
  
  if ((dirp = opendir (completeDirectory)) == NULL)
      return -1;


  if ((pathLevelNumber > 0) && (hidesFilesEnabled == 0))
      addDirectory ("..");
    
  while ( (direntp = readdir (dirp)) != NULL )
      {
    
	  strcpy (currentName, direntp->d_name);
        
	  // printf("Nom courant : %s\n", currentName);
    
	  if ( (hidesFilesEnabled == 0) && (currentName[0] == '.'))
	      {
               /* on ne prend pas ce fichier */
	      }
	  else
	      {
      
		  strcpy (currentPath, completeDirectory);
		  strcat (currentPath, currentName);
		  stat (currentPath, &buf);
		  if (((int)buf.st_mode) & S_IFDIR)
		      { /* directory */
			  addDirectory (currentName);
		      }
		  else if (((int)buf.st_mode) & S_IFREG)
		      { /* file */
			  addFile (currentName);
		      }
		  else { /* other */}
	      }
    
      }
  
  closedir (dirp);

  updateSelectedFiles ();
  
  return 0;

}

void FileDatas::setFilter (char* aFilter)
{
    strcpy (filter, aFilter);
    updateSelectedFiles ();
}

void FileDatas::print ()
{
  int i;
  
  printf ("------------------- Current Directory ------------------------\n");
  printf (" User: %s\n", returnUserId ());
  if (hidesFilesEnabled)
      {
	  printf (" Hides files enabled\n");
      }
  else
      {
	  printf (" Hides files disabled\n");
      }  
  printf (" Level number: %d\n", pathLevel ());
  for (i=0; i<pathLevel (); i++)
      {
	  printf (" [%s]", pathName (i));
      }
  printf ("\n");
  printf (" Number of files: %d\n", filesNumber ());
  printf (" Number of directories: %d\n", directoriesNumber ());
  printf (" Number of selected files: %d\n", selectedFilesNumber ());
  printf (" User directory: %s\n", returnUserDirectory ());
  printf (" Complete directory: %s\n", returnCompleteDirectory ());
  printf (" Short directory: %s\n", returnShortDirectory ());
  printf (" Filter: %s\n", returnFilter ());
  printf (" Current files:\n");
  for (i=0; i<filesNumber (); i++)
      {
	  printf (" [%s]", file (i));
      }
  printf ("\n");
  printf (" Current directories:\n");
  for (i=0; i<directoriesNumber (); i++)
      {
	  printf (" [%s]", directory (i));
      }
  printf ("\n");
  printf (" Current selected files:\n");
  for (i=0; i<selectedFilesNumber (); i++)
      {
	  printf (" [%s]", selectedFile (i));
      }
  printf ("\n");
  printf ("--------------------------------------------------------------\n");
}


void FileDatas::enableHidesFiles ()
{
  hidesFilesEnabled = 1;
  scanDisk ();
}

void FileDatas::disableHidesFiles ()
{
  hidesFilesEnabled = 0;
  scanDisk ();
}

int FileDatas::pathLevel ()
{
  return pathLevelNumber;
}

char* FileDatas::returnCompleteDirectory ()
{
  return completeDirectory;
}

char* FileDatas::returnShortDirectory ()
{
  return shortDirectory;
}

char* FileDatas::returnUserId ()
{
  return user;
}

char* FileDatas::returnUserDirectory ()
{
  return userDirectory;
}

int FileDatas::filesNumber ()
{
  return numberOfFiles;
}

int FileDatas::directoriesNumber ()
{
  return numberOfDirectories;
}

char* FileDatas::file (int fileIndex)
{
  int i, j;
  int notFound;
  char* returnedFile;
  
  j = 0;
  i = 0;
  returnedFile = "";
  notFound = 1;
  
  while (notFound)
      {
	  if (isDirectory[i] == 0)
	      {
		  if (j == fileIndex)
		      {
			  notFound = 0;
			  returnedFile = currentFile[i];
		      }
		  else
		      {
			  j++;
		      }
	      }
	  i++;
      }

  return returnedFile;
}

char* FileDatas::directory (int fileIndex)
{
  int i, j;
  int notFound;
  char* returnedFile;
  
  j = 0;
  i = 0;
  returnedFile = "";
  notFound = 1;
  
  while (notFound)
      {
	  if (isDirectory[i] == 1)
	      {
		  if (j == fileIndex)
		      {
			  notFound = 0;
			  returnedFile = currentFile[i];
		      }
		  else
		      {
			  j++;
		      }
	      }
	  i++;
      }

  return returnedFile;
}

int FileDatas::selectedFilesNumber ()
{
  return numberOfSelectedFiles;
}

char* FileDatas::selectedFile (int fileIndex)
{
  int i, j;
  int notFound;
  char* returnedFile;

  j = 0;
  i = 0;
  returnedFile = "";  
  notFound = 1;
  
  while (notFound)
      {
	  if ((isDirectory[i] == 0) && (isFileSelected[i] == 1))
	      {
		  if (j == fileIndex)
		      {
			  notFound = 0;
			  returnedFile = currentFile[i];
		      }
		  else
		      {
			  j++;
		      }
	      }
	  i++;
      }
  
  return returnedFile;
}

char* FileDatas::returnFilter ()
{
  return filter;
}

int FileDatas::setDirectory (char* aDirectory)
{
  int i, j;
  char temp[256];
  char* currentDir;
  int len;
  int current; /* nombre de caracteres dont on s'est deja occupe */
  char workingDirectory[256];
  

  strcpy (workingDirectory, aDirectory);
  // printf ("workingDirectory: <%s>\n", workingDirectory);
  len = strlen (workingDirectory);

  if (workingDirectory[len-1] == '/')
      {
	  workingDirectory[len-1] = '\0';
	  current = 1;
      }
  else
      {
	  current = 0;
      }
  
  if (workingDirectory[0] == '~')
      {
    
	  if (strlen (workingDirectory) < strlen (user)+1)
	      {
	      printf ("ERROR: wrong format for directory\n");
	      return -1;
	      }
	  else
	      {
		  strcpy (temp, userDirectory);
		  strcat (temp, &(workingDirectory[strlen (user)+2]));
		  strcpy (workingDirectory, temp);
	      }
      }
  else
      {
	  if (workingDirectory[0] != '/')
	      {
		  printf ("ERROR: wrong format for directory\n");
		  return -1;
	      }
      }
  
  // printf ("Working dir: [%s]\n", workingDirectory);

  pathLevelNumber = 0;
  cleanFilesAndDirectories ();
  
  len = strlen (workingDirectory);

  currentDir = &(workingDirectory[1]);

  // printf ("Length: %d\nCurrent: %d\n", len, current);
  
  while (current < len-1)
      { /* -1 */
    
	  strcpy (temp, "");
	  i = 0;
	  while ((currentDir[i] != '/') && (i<(int)strlen (currentDir)))
	      {
		  i++;
		  current++;
	      }
	  current++;
	  for (j=0; j<i; j++)
	      {
		  temp[j] = currentDir[j];
	      }
	  temp[i] = '\0';
	  addPath (temp);
	  currentDir = &(currentDir[i+1]);
	  // printf ("i= %d  current = %d  currentDir = [%s]\n", i, current, currentDir);
	  
      }
  
  updateCompleteDirectory ();
  updateShortDirectory ();
  
  // printf ("ici\n");
  // print ();
  
  return (scanDisk ());
  
} 

void FileDatas::setDirIndex (int aDirIndex)
{
  dirIndex = aDirIndex;
}

void FileDatas::setFileIndex (int aFileIndex)
{
  fileIndex = aFileIndex;
}

int FileDatas::returnDirIndex ()
{
  return dirIndex;
}

int FileDatas::returnFileIndex ()
{
  return fileIndex;
}


/***********************
 *                     *
 * Protected  methods  *
 *                     *
 ***********************/


char* FileDatas::pathName (int pathIndex)
{
  return path[pathIndex];
}

void FileDatas::updateSelectedFiles ()
{
  int i;
  
  numberOfSelectedFiles = 0;
  for (i=0; i<numberOfFiles+numberOfDirectories; i++)
      {
	  if (isDirectory[i] == 1) /* directory */
	      { 
		  isFileSelected[i] = 0;
	      }
	  else /* file */
	      {
		  if (checkFileWithFilter (currentFile[i]))
		      {
			  isFileSelected[i] = 1;
			  numberOfSelectedFiles++;
		      }
		  else
		      {
			  isFileSelected[i] = 0;
		      }
	      }
      }
}

void FileDatas::updateCompleteDirectory ()
{
  int i;
  
  strcpy (completeDirectory, "/");
  
  for (i=0; i<pathLevelNumber; i++)
      {
	  strcat (completeDirectory, pathName (i));
	  strcat (completeDirectory, "/");    
	  // printf("completeDirectory = %s\n", completeDirectory);
      }
}

void FileDatas::updateShortDirectory ()
{
  int i;
  int j;
  
  /* on regarde avant si on est dans l'arborescence de l'utilisateur */
  
  j = -1;
  
  for (i=pathLevelNumber-1; i>=0; i--)
      {
	  if (!strcmp (pathName (i), user))
	      {
		  j = i;
	      }
      }
  if (j == -1)
      { /* pas dans l'arborescence */
	  updateCompleteDirectory ();
	  strcpy (shortDirectory, completeDirectory);
      }
  else
      {
	  strcpy (shortDirectory, "~");
	  for (i=j; i<pathLevelNumber; i++)
	      {
		  strcat (shortDirectory, pathName (i));
		  strcat (shortDirectory, "/");    
	      } 
      }
}

void FileDatas::addPath (char* aPath)
{
  if (pathLevelNumber < 49)
      {
	  strncpy (path[pathLevelNumber], aPath, 49);
	  path[pathLevelNumber][49] = '\0';
	  pathLevelNumber++;
      }
  else
      {
	  printf ("ERROR: too much levels in directory\n");
      }
}

void FileDatas::addFile (char* aFile)
{
  int number;

  number = numberOfFiles+numberOfDirectories;

  if (number < maxFiles)
      {
	  currentFile[number] = new char[strlen (aFile)+1];
	  strcpy (currentFile[number], aFile);
	  	  // currentFile[number] = strdup (aFile); would be nicer

	  isDirectory[number] = 0;
	  numberOfFiles++;
      }
  else
      {
	  printf ("ERROR: not enough space to store read file\n");
      }
}

void FileDatas::addDirectory (char* aDirectory)
{
  int number;

  number = numberOfFiles+numberOfDirectories;
  
  if (number < maxFiles)
      {
	  currentFile[number] = new char[strlen (aDirectory)+2];
	  strcpy (currentFile[number], aDirectory);
	  // printf ("Repertoire : %s, NumeroDuFichier : %d, Adresse : %x, Valeur : %s \n", aDirectory, number, currentFile[number], currentFile[number]);
	  
	  strcat (currentFile[number], "/");
	  isDirectory[number] = 1;
	  numberOfDirectories++;
      }
  else
      {
	  printf ("ERROR: not enough space to store read directory\n");
      }
}

void FileDatas::cleanFilesAndDirectories ()
{
  int number;
  int i;

  number = numberOfFiles+numberOfDirectories;
  
  for (i=0; i<number; i++)
      {
	  delete[] currentFile[i];
      }
  numberOfFiles = 0;
  numberOfSelectedFiles = 0;
  numberOfDirectories = 0;
}

int FileDatas::checkFileWithFilter (char* aFile)
{

  /* on cherche a savoir si le fichier aFile "matche" le filtre filter */

  char *p, c;
  int len;

  if (filter[0] == '*')
      {
	  if(filter[1] == '\0') return 1;
	  if(filter[strlen(filter)-1] == '*')
	      {
		  len = strlen(filter);
		  c = filter[len-1];
		  filter[len-1] = '\0';
		  p = strstr(aFile, filter + 1);
		  filter[len-1] = c;
		  
		  if(p == NULL) return 0;
		  else return 1;
	      }
	  p = aFile + strlen(aFile) - strlen(filter) +1;
	  
	  if(strcmp(filter+1, p) == 0)
	      return 1;
	  else return 0;
      }
  
  if (filter[strlen(filter)-1] == '*')
      {
	  if(strncmp(filter, aFile, strlen(filter)-1 ) == 0)
	      return 1;
	  else return 0;
      }
  
  if (strcmp(filter, aFile) == 0)
      return 1;
  
  return 0;
}

/* ---------------------------------------------------------- */

FileSelector::FileSelector (Interface* toBeRefreshedInterface,
			    int x0, int y0,
			    Display* aDisplay,
			    FileDatas* aFileDatas)
  :
  Interface (x0, y0, 620, 540, 1, 
	     "Load new files",
	     "Nest2", aDisplay)
{
  toBeRefreshed = toBeRefreshedInterface;

  currentFileDatas = aFileDatas;
  hidedFilesEnabled = 0;
  currentFileDatas->disableHidesFiles ();  
  
  strcpy (newPath, currentFileDatas->returnShortDirectory ());
  strcpy (newFilter, currentFileDatas->returnFilter ());  
  
  directoriesArrayContent = new ArrayContent (1, maxFiles+1);
  directoriesArrayContent->addColumn ("  Directories", CharType, 30);

  filesArrayContent = new ArrayContent (1, maxFiles+1);
  filesArrayContent->addColumn ("     Files", CharType, 30);

  directoriesArrayWindow = new ArrayWindow (this, 10, 110, 300, 370,
					    enabled, Grey,
					    directoriesArrayContent);
  
  filesArrayWindow = new ArrayWindow (this, 310, 110, 300, 370,
				      enabled, Grey,
				      filesArrayContent);
  
  pathInput = new TextInput (this, 40, 30, 35, "Path   ",
			     newPath, enabled);

  filterInput = new TextInput (this, 40, 55, 20, "Filter ",
			       newFilter, enabled);

  openButton = new Button (this, 15, 500, 90, 25, "Open",
			   centerJustified, enabled);
  backButton = new Button (this, 115, 500, 90, 25, "Back",
			     centerJustified, enabled);
  filterButton = new Button (this, 215, 500, 90, 25, "Filter",
			     centerJustified, enabled);
  rescanButton = new Button (this, 315, 500, 90, 25, "Rescan",
				centerJustified, enabled);
  hideButton = new Button (this, 415, 500, 90, 25, "Hide",
				centerJustified, enabled);
  showButton = new Button (this, 515, 500, 90, 25, "Show",
				centerJustified, enabled);

  loadAllButton = new Button (this, 480, 10, 120, 25, "Load all",
				centerJustified, enabled);
  loadFileButton = new Button (this, 480, 40, 120, 25, "Load file",
				centerJustified, enabled);
  cancelButton = new Button (this, 480, 70, 120, 25, "Cancel",
				centerJustified, enabled);
  showShareOrHomeButton = new SwapButton (this, 340, 52, 100, 25,
					  "Share", "Home", 
					  centerJustified, enabled);
  currentFileDatas->scanDisk ();
  updateDatas ();
  
}

FileSelector::~FileSelector ()
{
  delete filterInput;
  delete pathInput;
  delete filesArrayWindow;
  delete directoriesArrayWindow;
  delete filesArrayContent;
  delete directoriesArrayContent;

  delete loadAllButton;
  delete loadFileButton;
  delete cancelButton;
  delete showShareOrHomeButton;
  delete openButton;
  delete backButton;
  delete filterButton;
  delete rescanButton;
  delete hideButton;
  delete showButton;
}

void FileSelector::refresh ()
{
  loadAllButton->refresh ();
  loadFileButton->refresh ();
  cancelButton->refresh ();
  showShareOrHomeButton->refresh ();
  openButton->refresh ();
  backButton->refresh ();
  filterButton->refresh ();
  rescanButton->refresh ();
  hideButton->refresh ();
  showButton->refresh ();

  filterInput->refresh ();
  pathInput->refresh ();
  filesArrayWindow->refresh ();
  directoriesArrayWindow->refresh ();
}

unsigned int FileSelector::manageInterface (XEvent report)
{
  char tempPath[256];
  int i;
  char filterString[256];    
  char pathString[256];    
  /* long mask1; */ /* pour l'interface des fichiers */
  /* long mask2; */ /* pour le refresh des autres interfaces */
  int end=0;
  /* 3 comme returnedValue = on continue dans la boucle */
  int returnedValue = 3;
  
  if (cancelButton->manageEvent (report) == buttonPressed) {
    end = 1;
    returnedValue = 0;  /* cancel */
  }
      
  if (loadAllButton->manageEvent (report) == buttonPressed) {
    i = directoriesArrayWindow->getSelectedLine ();
    if (i != -1) currentFileDatas->setDirIndex (i);
    i = filesArrayWindow->getSelectedLine ();
    if (i != -1) currentFileDatas->setFileIndex (i);
    if (currentFileDatas->selectedFilesNumber () == 0) {
      displayDialogBox (toBeRefreshed, "Error", "Nest2",
			"    No file selected    ",
			"Continue");
    }
    else {
      end = 1;
      returnedValue = 1;  /* all files selected */
    }
  }
  
  if (loadFileButton->manageEvent (report) == buttonPressed) {
    i = directoriesArrayWindow->getSelectedLine ();
    if (i != -1) currentFileDatas->setDirIndex (i);
    i = filesArrayWindow->getSelectedLine ();
    if (i != -1) {
      currentFileDatas->setFileIndex (i);
      end = 1;
      returnedValue = 2;  /* one file selected */
    }
    else {
      displayDialogBox (toBeRefreshed, "Error", "Nest2",
			"    No file selected    ",
			"Continue");
    }
  }
 
  if (showShareOrHomeButton->manageEvent (report) == buttonPressed)
    {
      if (showShareOrHomeButton->isSwapped () == 0)
	{
	    if (currentFileDatas->setDirectory (homeDirectory) == -1)
		{
		    displayDialogBox (toBeRefreshed, "Error", "Nest2",
				      "Directory can't be opened",
				      "Continue");
		}
	}
      else
	  
	  {
	      /* la le code pour passer a Share */
	      if (currentFileDatas->setDirectory (shareDirectory) == -1)
		  {
		      displayDialogBox (toBeRefreshed, "Error", "Nest2",
					"Directory can't be opened",
					"Continue");
		  }
	}

      updateDatas ();
    }
  
  if (openButton->manageEvent (report) == buttonPressed) {
    i = directoriesArrayWindow->getSelectedLine ();
    if (i != -1) {
      strcpy (tempPath, currentFileDatas->directory (i));
      tempPath[strlen(tempPath)-1] = '\0';
      if (currentFileDatas->changeDirectory (tempPath) == -1) {
	displayDialogBox (toBeRefreshed, "Error", "Nest2",
			  "Directory can't be opened",
			  "Continue");
      }
      updateDatas ();
    }
  }
  
  if (backButton->manageEvent (report) == buttonPressed) {
    if (currentFileDatas->pathLevel () > 0) {
      currentFileDatas->backDirectory ();
      updateDatas ();
    }
  }
  
  if (filterButton->manageEvent (report) == buttonPressed) {
    strcpy (filterString, filterInput->returnCharValue ());
    currentFileDatas->setFilter (filterString);
    updateDatas ();
  }
  
  if (rescanButton->manageEvent (report) == buttonPressed) {
    currentFileDatas->scanDisk ();
    updateDatas ();
  }
  
  if (hideButton->manageEvent (report) == buttonPressed) {
    currentFileDatas->disableHidesFiles ();
    hidedFilesEnabled = 0;
    updateDatas ();
  }
      
  if (showButton->manageEvent (report) == buttonPressed) {
    currentFileDatas->enableHidesFiles ();
    hidedFilesEnabled = 1;
    updateDatas ();
  }
  
  if (pathInput->manageEvent (report) == returnPressed) {
    strcpy (pathString, pathInput->returnCharValue ());
    if (currentFileDatas->setDirectory (pathString) == -1) {
      displayDialogBox (toBeRefreshed, "Error", "Nest2",
			"Directory can't be opened",
			"Continue");
    }
    updateDatas ();      
  }
  
  if (filterInput->manageEvent (report) == returnPressed) {
    strcpy (filterString, filterInput->returnCharValue ());
    currentFileDatas->setFilter (filterString);
    updateDatas ();
  }
  
  if (directoriesArrayWindow->manageEvent (report) == doubleClick) {
    i = directoriesArrayWindow->getSelectedLine ();
    if (i != -1) {
      if (!strcmp (currentFileDatas->directory (i), "./")) {
	if (currentFileDatas->scanDisk () == -1) {
	  displayDialogBox (toBeRefreshed, "Error", "Nest2",
			    "Directory can't be opened",
			    "Continue");
	}
	updateDatas ();
      }
      else if (!strcmp (currentFileDatas->directory (i), "../")) {
	if (currentFileDatas->backDirectory () == -1) {
	  displayDialogBox (toBeRefreshed, "Error", "Nest2",
			    "Directory can't be opened",
			    "Continue");
	}
	
	updateDatas ();
      }
      else { /* cd */
	strcpy (tempPath, currentFileDatas->directory (i));
	tempPath[strlen(tempPath)-1] = '\0';
	if (currentFileDatas->changeDirectory (tempPath) == -1) {
	  displayDialogBox (toBeRefreshed, "Error", "Nest2",
			    "Directory can't be opened",
			    "Continue");
	}
	updateDatas ();
      }
    }
  }
      
  if (filesArrayWindow->manageEvent (report) == doubleClick) {
    i = directoriesArrayWindow->getSelectedLine ();
    if (i != -1) currentFileDatas->setDirIndex (i);
    i = filesArrayWindow->getSelectedLine ();
    if (i != -1) currentFileDatas->setFileIndex (i);
    end = 1;
    returnedValue = 2; /* one file selected */
  }
  
  return returnedValue;
}

void FileSelector::updateDatas ()
{
  int i;
  int line;
  int oldDirectoriesNumber;
  int oldFilesNumber;
  
  XUnmapSubwindows (display, directoriesArrayWindow->win);
  XUnmapSubwindows (display, filesArrayWindow->win);  

  oldDirectoriesNumber = directoriesArrayContent->getLinesNumber ();
  oldFilesNumber = filesArrayContent->getLinesNumber ();

  for (i=0; i<oldDirectoriesNumber; i++) {
    directoriesArrayContent->removeLine (i);
  }
  
  for (i=0; i<oldFilesNumber; i++) {
    filesArrayContent->removeLine (i); 
  }
  
  for (i=0; i<currentFileDatas->directoriesNumber (); i++) {
    line = directoriesArrayWindow->addLine ();
    directoriesArrayWindow->addData (line, 0,
				     currentFileDatas->directory (i));
  }
  
  for (i=0; i<currentFileDatas->selectedFilesNumber (); i++) {
    line = filesArrayWindow->addLine ();
    filesArrayWindow->addData (line, 0,
			       currentFileDatas->selectedFile (i));
  }
  
  directoriesArrayWindow->reset (); 
  filesArrayWindow->reset (); 
  directoriesArrayWindow->refreshAll (); 
  filesArrayWindow->refreshAll (); 

  XMapSubwindows (display, directoriesArrayWindow->win);
  XMapSubwindows (display, filesArrayWindow->win);  

  pathInput->changeCharValue (currentFileDatas->returnShortDirectory ());
  filterInput->changeCharValue (currentFileDatas->returnFilter ());

  
}