file-selector-callbacks.c

一个功能全面的电子邮件客户端

/* TradeClient <http://tradeclient.sourceforge.net>
 * $Id: file-selector-callbacks.c,v 1.8 2001/03/20 22:19:33 ttabner Exp $
 *
 * Copyright (C) 1999-2000 Bynari Inc.
 * Copyright (C) 2001 Project TradeClient
 *
 * LGPL
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Library 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 Library
 * General Public License for more details.
 *
 * You should have received a copy of the GNU Library 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.
 */


#include "puma.h"

GtkCTreeNode *cur_node=NULL;
guint clist_row=-1;

int strnrcmp (char *str1, char *str2, int len) {
	int i, slen1, slen2;

	slen1=strlen (str1);
	slen2=strlen (str2);
	if (slen1 < len || slen1 < len) {
		return FALSE;
	}

	for (i=0; i<=len; i++) {
		if (str1[slen1-i]!=str2[slen2-i]) {
			return FALSE;
		}
	}
	return TRUE;
}

int file_selector_iswild (char *wildcard, char *str) {
	char *tmps1;
	if (!wildcard) return TRUE;
	if (strlen (wildcard)==1 && wildcard[0]=='*') return TRUE;
	if (wildcard[0]=='*')
		tmps1=wildcard+1;
	else
		tmps1=wildcard;

	if (strnrcmp (tmps1, str, strlen (tmps1))) return TRUE;

	return FALSE;
}

void set_curnode (GtkCTreeNode *node) {
	cur_node=node;
}

void file_selector_destroy (GtkWidget *widget, GdkEvent *event, gpointer data) {
	gtk_widget_destroy (lookup_widget (widget, "win"));
}



void 
file_selector_tree_expand (GtkCTree *ctree, GtkCTreeNode *node_ret) {
  fs_node_info *data=gtk_ctree_node_get_row_data (ctree, node_ret);
  fs_node_info *info;
  GtkCTreeNode *node, *node2;
  char *period=".";
  int depthcount=0;
  DIR *tdir;
  struct dirent *de;
  struct stat *st=(struct stat *)calloc(1, sizeof(struct stat));
  char *fname=(char *)calloc (1, 1024);
  char *rel_fname=(char *)calloc (1, 1024);


  if (!data->recursed) {
    if (data->dummychild) {
      gtk_ctree_remove_node (ctree, data->dummychild);
      data->dummychild=NULL;
    }
    data->recursed=TRUE;
    tdir=opendir (data->name);
    if (tdir)
      while( (tdir) && (de = readdir(tdir)) ) {
	snprintf (fname, 1024, "%s/%s", data->name, de->d_name);
	snprintf (rel_fname, 1024, "%s", de->d_name);
	stat (fname, st);
	if (S_ISDIR (st->st_mode)) {
	  if( (strcmp(rel_fname, ".") != 0) && (strcmp(rel_fname, "..") != 0) ) {
	    info=(fs_node_info *)calloc (1, sizeof (fs_node_info));
	    info->recursed=FALSE;
	    info->name=strdup (fname);
	    node=gtk_ctree_insert_node (ctree,
					node_ret, NULL, &rel_fname, 5, close_pix, close_mask, open_pix, open_mask, FALSE, FALSE);
	    node2=gtk_ctree_insert_node (ctree,
					 node, NULL, &period, 0, NULL, NULL, NULL, NULL, FALSE, FALSE);
	    gtk_ctree_node_set_row_data (ctree, node, info);
	    info->dummychild=node2;
	    gtk_ctree_node_set_row_data (ctree, node, info);
	    gtk_ctree_node_set_row_data (ctree, node2, info);
	    depthcount++;
	  }
	}
      }
    if (depthcount==0) {
      gtk_ctree_collapse (ctree, node_ret);
    }
  }
  free (st);
  free (fname);
  free (rel_fname);

  return ;
}



void 
file_selector_tree_select_row (GtkWidget *widget, GtkCTreeNode *node, gint column) {
  GtkCList *clist=GTK_CLIST (lookup_widget (widget, "fs_filelist"));
  fs_node_info *data=gtk_ctree_node_get_row_data (GTK_CTREE (widget), node);
  char *rel_fname=(char *)calloc (1, 1025);
  char *fname=(char *)calloc (1, 1025);
  char *tmp;
  struct dirent *de;
  char *cl_data[3];
  struct stat st;
  DIR *tdir;
  int i;


  /* Free and clear the previous list contents */
  cur_node=node;
  gtk_clist_freeze (clist);
  for (i=0;i<clist->rows;i++) {
    free( gtk_clist_get_row_data( clist, i ) ) ;
  }
  gtk_clist_clear (clist);

  /* Now, open the directory */
  tdir=opendir (data->name);
  if (tdir) {
    while( (tdir) && (de = readdir(tdir)) ) {
      if (file_selector_iswild (gt (widget, "fs_curdir"), de->d_name)) {
	snprintf (fname, 1024, "%s/%s", data->name, de->d_name);
	snprintf (rel_fname, 1024, "%s", de->d_name);
	stat (fname, &st);
	if (S_ISREG (st.st_mode)) {
	  if (access (fname, R_OK)==0) {
	    cl_data[0]=strdup (rel_fname);
	    cl_data[1]=strdup( ctime (&st.st_atime) ) ;
	    cl_data[2]=(char *)calloc (1, 25);

	    snprintf (cl_data[2], 25, "%d", (int)st.st_size);
	    tmp=strdup (fname);

	    gtk_clist_set_row_data (clist, gtk_clist_append (clist, cl_data), (gpointer)tmp);

	    free (cl_data[0]);
	    free (cl_data[1]);
	    free (cl_data[2]);
	  }
	}
      }
    }
  }
  gtk_clist_thaw (clist);
  set_cwd (data->name);
  free (rel_fname);
  free (fname);

  return ;
}



void file_selector_tree_unselect_row (GtkCTree *widget, GtkCTreeNode *node, gint column) {}

void file_selector_mask_activate (GtkWidget *widget) {
	GtkWidget *ctree=lw (widget, "fs_dirtree");
	file_selector_tree_select_row (ctree, cur_node, 0);
}

void file_selector_file_selected (GtkWidget *widget, gint row, gint column, GdkEventButton *event, gpointer data2) {
	char *data=gtk_clist_get_row_data (GTK_CLIST (widget), row);
	int depthcount=count_delimiters (data, '/');
	char *filename=cut_string (data, '/', 2, depthcount);
	clist_row=row;

	unprot2 (widget, "fs_renamefile");
	unprot2 (widget, "fs_deletefile");

	gtk_entry_set_text (GTK_ENTRY (lookup_widget (widget, "fs_filename")), filename);

	if ( (event->type==GDK_2BUTTON_PRESS) ||
	     (event->type==GDK_3BUTTON_PRESS) ) {
	  gtk_button_clicked (GTK_BUTTON (lookup_widget (widget, "fs_ok_button")));
	}
	free (filename);

	return ;
}


void 
file_selector_file_unselected (GtkWidget *widget) {
  if( widget && (clist_row >= 0) ) {
    prot2 (widget, "fs_renamefile");
    prot2 (widget, "fs_deletefile");
    clist_row = -1 ;
  }

  return ;
}

void file_selector_accept (GtkWidget *widget, gpointer data) {
	fs_accept_info *accept=data;
	GtkWidget *filesel = lookup_widget (widget, "win");
	char *fname = gtk_file_selection_get_filename (GTK_FILE_SELECTION(filesel));
	if (accept->func)
		accept->func (GTK_FILE_SELECTION (filesel), strdup (fname), accept->data);

	gtk_widget_destroy (filesel);
}

void file_selector_cancel (GtkWidget *widget, gpointer data) {
	gtk_widget_destroy (lookup_widget (widget, "win"));
}

void file_selector_newdir_accept (GtkWidget *widget, GtkCTree *ctree) {
	char *dir=gt (widget, "entry");
	char *cdir=get_cwd ();
	char *ndir;
	if (dir && cdir && cur_node) {
		fs_node_info *info=gtk_ctree_node_get_row_data (ctree, cur_node);
		ndir=(char *)calloc (strlen (dir)+strlen (cdir)+5, sizeof (char));
		sprintf (ndir, "%s/%s", cdir, dir);		
		if (info->recursed) {
			GtkCTreeNode *node, *node2;
			char *period=".";
			info=(fs_node_info *)calloc (1, sizeof (fs_node_info));
			info->name=ndir;
			info->recursed=FALSE;
			node=gtk_ctree_insert_node (ctree, cur_node, NULL, &dir, 5, close_pix, 
			                            close_mask, open_pix, open_mask, FALSE, FALSE);
			node2=gtk_ctree_insert_node (ctree, node, NULL, &period, 0, NULL, 
			                             NULL, NULL, NULL, FALSE, FALSE);
			info->dummychild=node2;
			gtk_ctree_node_set_row_data (ctree, node, info);
			gtk_ctree_node_set_row_data (ctree, node2, info);			
		}
		mkdir (ndir, S_IREAD | S_IWRITE | S_IEXEC);
	}
	gtk_widget_destroy (lw (widget, "fs_ndir"));
}

void file_selector_newdir_cancel (GtkWidget *widget) {
	gtk_widget_destroy (lw (widget, "fs_ndir"));
}

void file_selector_rename_accept (GtkWidget *widget, GtkCList *clist) {
	char *data, *filename, *path, *nfile, *npath;
	int dc;
	if (clist_row==-1) {
		gtk_widget_destroy (lw (widget, "fs_ndir"));
		return;
	}
	data=gtk_clist_get_row_data (clist, clist_row);
	dc=count_delimiters (data, '/');
	filename=cut_string (data, '/', 2, dc);
	path=cut_string (data, '/', 1, dc);
	nfile=gt (widget, "entry");
	npath=(char *)calloc (strlen (path) + strlen (nfile), sizeof (char));
	sprintf (npath, "%s/%s", path, nfile);
	if (rename (data, npath)!=-1) {
		gtk_clist_set_row_data (clist, clist_row, npath);
		gtk_clist_set_text (clist, clist_row, 0, nfile);
	} else {
		insert_error ("Unable to rename file!\n");
	}
	free (data);
	free (filename);
	free (path);
	gtk_widget_destroy (lw (widget, "fs_ndir"));
}

void file_selector_rename_cancel (GtkWidget *widget) {
	gtk_widget_destroy (lw (widget, "fs_ndir"));
}

void file_selector_delete_accept (GtkWidget *widget, GtkCList *clist) {
	char *filename=gtk_clist_get_row_data (clist, clist_row);
	gtk_widget_destroy  (lw (widget, "yesno"));
	if (unlink (filename) != -1) {
		gtk_clist_remove (clist, clist_row);
		clist_row=-1;
	} else {
		insert_error ("Unable to delete file\n");
	}
}

void file_selector_delete (GtkWidget *widget) {
	GtkCList *clist=GTK_CLIST (lw (widget, "fs_filelist"));
	ws (create_yesno ("Delete File", "Are you sure you want to delete the selected file?", GTK_SIGNAL_FUNC (file_selector_delete_accept), clist));
}


/*
 * Sets the current working director to be the user's home directory
 * and forces a list refresh.
 */
void 
fs_goto_homedir( GtkWidget *widget ) {
  int i ;
  DIR *tdir ;
  char *home ;
  char *fname ;
  char *rel_fname ;
  GtkCList *clist ;
  struct stat st ;
  char *cl_data[3] ;
  struct dirent *de ;
  

  /* Now, locate our widget list and free everything in it! */
  clist = GTK_CLIST( lookup_widget( widget, "fs_filelist" ) ) ;
  gtk_clist_freeze (clist);
  for( i = 0; i < clist->rows ; i++ ) {
    free( gtk_clist_get_row_data( clist, i ) ) ;
  }
  gtk_clist_clear (clist);

  /* Set our current work directory since we've selected HOME! */
  home = getenv( "HOME" ) ;
  set_cwd( home ) ;

  /* Now, open that directory */
  tdir = opendir( home ) ;
  if( tdir ) {
    fname = malloc( 1025 ) ;
    rel_fname = malloc( 1025 ) ;
    while( (de = readdir( tdir ) ) ) {
      if (file_selector_iswild (gt (widget, "fs_curdir"), de->d_name)) {
	snprintf( fname, 1024, "%s/%s", home, de->d_name ) ;
	snprintf( rel_fname, 1024, "%s", de->d_name ) ;
#ifdef DEBUG
	printf( "fname = '%s', rel_fname = '%s'\n", fname, rel_fname ) ;
#endif
	stat( fname, &st ) ;
	if (S_ISREG (st.st_mode)) {
	  if (access (fname, R_OK)==0) {
	    cl_data[0]=strdup (rel_fname);
	    cl_data[1]=strdup( ctime (&st.st_atime) ) ;
	    cl_data[2]=(char *)calloc (1, 25);
	    
	    snprintf (cl_data[2], 25, "%d", (int)st.st_size);
	    
	    gtk_clist_set_row_data (clist, gtk_clist_append (clist, cl_data), (gpointer)strdup(fname) ) ;
#ifdef DEBUG
	    printf( "row data is '%s'.\n", fname ) ;
#endif

	    free (cl_data[0]);
	    free (cl_data[1]);
	    free (cl_data[2]);
	  }
	}
      }
    }
    if( fname ) free( fname ) ;
    if( rel_fname ) free( rel_fname ) ;
  }
  gtk_clist_thaw( clist ) ;

  return ;
}