saveloadwindow.cc

UNIX下使用的基于模糊Ｃ聚类分析的原码

//**************************************************************
//*   filename: saveloadwindow.cc                              *
//*                                                            *
//**************************************************************
//* programmed by: Thomas Wagner                               *
//* last change:  (XXX: not updated)                           *
//**************************************************************

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <X11/Xlib.h>

#include "saveloadwindow.h"
#include "quicksort.h"
#include "mainwindow.h"

extern unsigned long buttonpix, blackpix, shadowpix, lightpix;
extern Cursor maincursor;

SaveLoadWindow::SaveLoadWindow (Display * initdisplay,
		GC initgc,
		MainWindow * initMain,
		XFontStruct * fontstruct,
		int initx, int inity,
		int initokactionnumber,
		char *text,
		unsigned short initstatus):
BigWindow (initdisplay,
	   initgc,
	   DefaultRootWindow (initdisplay),
	   fontstruct,
	   initx, inity, 200, 200,
	   text, DEFAULT_BDWIDTH)
{
  status = initstatus;
  SelectWindowInfo *fileinfo;
  fileselectwindow = NULL;
  Main = initMain;
  okactionnumber = initokactionnumber;
  short depth, filenumber = 0, textheight = fontstruct->max_bounds.ascent +
  fontstruct->max_bounds.descent, textwidth = 150, fileselectheight = 200;

  path = (char *) malloc (sizeof (char) * 3);
  sprintf (path, "./");

  selectedfile = new TextBox (display,
			      gc,
			      this,
			      fontstruct,
			      LOADSAVEOUTSIDEBORDER, LOADSAVEOUTSIDEBORDER,
			      textwidth, textheight,
			      3, NULL, 1,
			      TEXTOPTION_DARK
			      | TEXTOPTION_GIVENXPOS
			      | TEXTOPTION_TEXTINPUT,
			      0, SAVELOAD_SELECTED_OK);
//SAVELOAD_TEXTDOUBLECLICKED);

  height = selectedfile->Gety () + selectedfile->Getheight () + LOADSAVEINSIDEBORDER;
  width = textwidth + 2 * LOADSAVEOUTSIDEBORDER;

  fileinfo = Loaddirectory (&filenumber);
  fileselectwindow
    = new SelectWindow (display,
			gc,
			this,
			fontstruct,
			LOADSAVEOUTSIDEBORDER, height,
			textwidth, fileselectheight,
			fileinfo,
			filenumber,
		 SAVELOAD_CHANGESELECTED_ACTION, SAVELOAD_TEXTDOUBLECLICKED,
			SELECTWINDOWOPTION_EXCLUSIVESELECTION);

  height = fileselectwindow->Gety () + fileselectwindow->Getheight () + LOADSAVEINSIDEBORDER;

  Cancel = new ActionIcon (display,
			   gc,
			   this,
			   fontstruct, 105, height, 40, 30,
	   "Cancel", NULL, 0, 0, SAVELOAD_SELECTED_CANCEL, ICON_SELECTABLE);

  OK = new ActionIcon (display,
		       gc,
		       this,
		       fontstruct, 35, height, 40, 30,
		   "Ok", NULL, 0, 0, SAVELOAD_SELECTED_OK, ICON_SELECTABLE);

  height = OK->Gety () + OK->Getheight () + LOADSAVEOUTSIDEBORDER;
  SizeMe (textwidth + 2 * LOADSAVEOUTSIDEBORDER, height);

  short newiconxpos = (width - 2 * OK->Getwidth ()) / 4;
  OK->PlaceMe (newiconxpos, OK->Gety ());
  Cancel->PlaceMe (width - newiconxpos - Cancel->Getwidth (), Cancel->Gety ());

  depth = DefaultDepth (display, DefaultScreen (display));
  pixmap = XCreatePixmap (display, window, width, height, depth);

  XSetForeground (display, gc, buttonpix);
  XFillRectangle (display, pixmap, gc, 0, 0, width, height);
  DrawBorder (pixmap, 0, 0, width, height, 0, 0, "", HIGH);
  DrawBorder (pixmap,
	      LOADSAVEOUTSIDEBORDER - 2, LOADSAVEOUTSIDEBORDER - 2,
	      textwidth + 6, textheight + 6, 0, 0, "", LOW);
  XDefineCursor (display, window, maincursor);
  FixMySize ();
  SetSelectedInput (ExposureMask);
}

void 
SaveLoadWindow::ChangeFunction (unsigned short newstatus,
				BigWindow * newParent,
				int newokactionnumber,
				char *newtext)
{
  status = newstatus;
  Parent = newParent;
  okactionnumber = newokactionnumber;
  text = newtext;
  SetWindowName (text);
}

SelectWindowInfo *
SaveLoadWindow::Loaddirectory (short *newfilenumber)
{
  *newfilenumber = 0;
  SelectWindowInfo *newfileinfo;
  DIR *dir = opendir (path);

  if (dir != NULL) {
    short pathnumber = 0, filenumber = 0, counter;
    short pathcounter = 0, filecounter = 0;
    dirent *ep;
    char **filenames = NULL, **pathnames = NULL;

    while ((ep = readdir (dir))) {
      {
	char *testpath;
	short length = strlen (ep->d_name) + strlen (path) + 1;
	testpath = (char *) malloc (sizeof (char) * length);
	sprintf (testpath, "%s%s", path, ep->d_name);
	DIR *testdir = opendir (testpath);
	free (testpath);
	if (testdir != NULL) {
	  pathnumber++;
	  closedir (testdir);
	} else
	  filenumber++;
      }
    }

    if (filenumber > 0)
      filenames = (char **) malloc (sizeof (char *) * filenumber);
    if (pathnumber > 0)
      pathnames = (char **) malloc (sizeof (char *) * pathnumber);

    *newfilenumber = pathnumber + filenumber;
    newfileinfo = (SelectWindowInfo *) malloc (sizeof (SelectWindowInfo) * (*newfilenumber));
    rewinddir (dir);
    while ((ep = readdir (dir))) {
      short length = strlen (ep->d_name) + 1;
      {
	char *testpath;
	short pathlength = strlen (ep->d_name) + strlen (path) + 1;
	testpath = (char *) malloc (sizeof (char) * pathlength);
	sprintf (testpath, "%s%s", path, ep->d_name);
	DIR *testdir = opendir (testpath);
	if (testdir != NULL) {
	  pathnames[pathcounter] = (char *) malloc (sizeof (char) * (length + 1));
	  sprintf (pathnames[pathcounter++], "%s/", ep->d_name);
	  closedir (testdir);
	} else {
	  filenames[filecounter] = (char *) malloc (sizeof (char) * length);
	  strcpy (filenames[filecounter++], ep->d_name);
	}
      }
    }

    quicksort (filenames, filenumber);
    quicksort (pathnames, pathnumber);

    for (counter = 0; counter < pathnumber; counter++) {
      newfileinfo[counter].Selecttext = pathnames[counter];
      newfileinfo[counter].options = (int) TEXTOPTION_SELECTABLE
	| TEXTOPTION_DOUBLECLICK
	| TEXTOPTION_TEXTISPATH
	| TEXTOPTION_GIVENXPOS;
      newfileinfo[counter].info = (unsigned short) counter;
    }

// ./ -> ../  ../ -> ./
    newfileinfo[0].Selecttext = pathnames[1];
    newfileinfo[1].Selecttext = pathnames[0];

    for (counter = pathnumber; counter < *newfilenumber; counter++) {
      newfileinfo[counter].Selecttext = filenames[counter - pathnumber];
      newfileinfo[counter].options = (int) TEXTOPTION_SELECTABLE
	| TEXTOPTION_DOUBLECLICK
	| TEXTOPTION_GIVENXPOS;
      newfileinfo[counter].info = (unsigned short) counter;
    }

    if (filenames != NULL) {
      free (filenames);
      filenames = 0;
    }
    if (pathnames != NULL) {
      free (pathnames);
      pathnames = 0;
    }
    closedir (dir);

    return newfileinfo;
  } else
    return NULL;
}

SaveLoadWindow::~SaveLoadWindow ()
{
  XFreePixmap (display, pixmap);
  delete OK;
  delete Cancel;
  delete fileselectwindow;
}

void 
SaveLoadWindow::MapMe ()
{
  Relaoddirectory ();
  XMapWindow (display, window);
}

char 
SaveLoadWindow::Fileexists (char *filename)
{
  FILE *in;
  if ((in = fopen (filename, "r")) == NULL)
    return FALSE;
  else {
    fclose (in);
    return TRUE;
  }
}

char *
SaveLoadWindow::Getfullfilename ()
{
  char *fullname;

  short strlength = strlen (path) + strlen (selectedfile->Gettext ()) + 2;
  fullname = (char *) malloc (sizeof (char) * strlength);
  strcpy (fullname, path);
  strcat (fullname, selectedfile->Gettext ());
  return fullname;
}

void 
SaveLoadWindow::Onepathup ()
{
  short length = strlen (path);
  if (path[length - 2] != '.')	// not ./ or ../ at end
   {
    short counter, newlength = 0;
    for (counter = length - 2; counter >= 0; counter--) {
      if (path[counter] == '/') {
	newlength = counter + 1;
	break;
      }
    }
    char *newpath = (char *) malloc (sizeof (char) * (newlength + 2));
    for (counter = 0; counter < newlength; counter++)
      newpath[counter] = path[counter];
    newpath[newlength] = path[length];
    free (path);
    path = newpath;
  } else {
    short plength = strlen ("../") + strlen (path);
    char *newpath = (char *) malloc (sizeof (char) * plength);
    sprintf (newpath, "%s%s", path, "../");
    free (path);
    path = newpath;
  }
}

void 
SaveLoadWindow::Relaoddirectory ()
{
  SelectWindowInfo *fileinfo;
  short filenumber;
  fileinfo = Loaddirectory (&filenumber);
  fileselectwindow->ChangeInfo (fileinfo, filenumber);
}

void 
SaveLoadWindow::Action (int Actionnumber, int value)
{
  char buildsavedialog = FALSE;
  switch (Actionnumber) {
  case SAVELOAD_DIALOG_CONFIRMED:
    switch (value) {
    case DIALOG_YES_ACTION:
      Parent->Action (okactionnumber, (int) Getfullfilename ());
      break;

    case DIALOG_CANCEL_ACTION:
      Parent->Action (okactionnumber, (int) (NULL));
      break;

    case DIALOG_NO_ACTION:
      MapMe ();
      break;
    }
    break;

  case SAVELOAD_SELECTED_OK:
    switch (status) {
    case WORK_AS_LOAD_SELECTOR:
      if (Fileexists (Getfullfilename ()))
	Parent->Action (okactionnumber, (int) Getfullfilename ());
      else {
	Main->printError ("File does not exist!");
	Parent->Action (okactionnumber, (int) (NULL));
      }
      break;

    case WORK_AS_SAVE_SELECTOR:
      if (!Fileexists (Getfullfilename ()))
	Parent->Action (okactionnumber, (int) Getfullfilename ());
      else
	buildsavedialog = TRUE;
      break;
    }
    UnmapMe ();
    break;

  case SAVELOAD_SELECTED_CANCEL:
    Parent->Action (okactionnumber, (int) (NULL));
    UnmapMe ();
    break;

  case SAVELOAD_CHANGESELECTED_ACTION:
    if (!(((TextBox *) value)->GetStatus () & TEXTOPTION_TEXTISPATH))
      selectedfile->ChangeText (((TextBox *) value)->Gettext ());
    break;

  case SAVELOAD_TEXTDOUBLECLICKED:
    if (((TextBox *) value)->GetStatus () & TEXTOPTION_TEXTISPATH) {
      if (strcmp (((TextBox *) value)->Gettext (), "./")) {
	if (strcmp (((TextBox *) value)->Gettext (), "../")) {
	  short length = strlen (((TextBox *) value)->Gettext ()) +
	    strlen (path) + 1;
	  char *newpath = (char *) malloc (sizeof (char) * length);
	  sprintf (newpath, "%s%s", path, ((TextBox *) value)->Gettext ());
	  path = newpath;
	} else
	  Onepathup ();
      } else {
	free (path);
	path = strdup ("./");
      }
      Relaoddirectory ();
    } else {
      UnmapMe ();
      switch (status) {
      case WORK_AS_LOAD_SELECTOR:
	Parent->Action (okactionnumber, (int) (Getfullfilename ()));
	break;

      case WORK_AS_SAVE_SELECTOR:
	buildsavedialog = TRUE;
	break;
      }
    }
    break;
  }
  if (buildsavedialog == TRUE) {
    char *dtext1 = "File already exists! Overwrite it?!";
    char *dtext2;

    short strlength = strlen (dtext1) + strlen (selectedfile->Gettext ()) + 5;
    dtext2 = (char *) malloc (sizeof (char) * strlength);
    sprintf (dtext2, "File %s already exists! Overwrite it?!", selectedfile->Gettext ());
    Dialog *dialog = new Dialog (display,
				 gc,
				 this,
				 fontstruct,
				 10, 10, 200, 80,
				 dtext2,
				 DISPLAY_YES | DISPLAY_NO | DISPLAY_CANCEL,
				 SAVELOAD_DIALOG_CONFIRMED);
    dialog->MapMe ();
  }
}

void 
SaveLoadWindow::HandleEvent (XEvent * Event)
{
  switch (Event->type) {
  case Expose:
    XCopyArea (display, pixmap, window, gc,
	       Event->xgraphicsexpose.x, Event->xgraphicsexpose.y,
	       Event->xgraphicsexpose.width, Event->xgraphicsexpose.height,
	       Event->xgraphicsexpose.x, Event->xgraphicsexpose.y);
    break;
  }
}