testfc.c.svn-base

一款Linux手机上应用的文件管理器 系统要求就安装Gtk+2.0

#include <gemfilechooser.h>
#include <gemresource.h>
#include <gemenv.h>
#include <gtk/gtk.h>
#include <gpe/gpeskwindow.h>
#include <gpe/init.h>
#include <gpe/errorbox.h>
#include <gpe/pixmaps.h>
#include <gpe/picturebutton.h>
#include <gpe/question.h>
#include <gpe/gpeiconlistview.h>
#include <gpe/spacing.h>
#include <gpe/gpehelp.h>
#include <gdk/gdkx.h>
#include <X11/Xlib.h>
#include <string.h>
//#define _(x) dgettext(PACKAGE_NAME, x)

#define DEFAULT_TERMINAL "rxvt -e"
#include "../config.h"
#ifndef DBGING 
#define DBGING 1
#define DBG(x...) do { if(DBGING) { \
                           g_print("%s(%d):", __FUNCTION__, __LINE__); \
                           g_print(x);    \
                           g_print("\n"); \
                      } \
                      }while(0)
#endif
GList *file_clipboard = NULL;
GtkWidget *window = NULL;//= gpe_skwindow_new ();
gboolean MARK = FALSE;
gchar *virtual_root;
static GtkUIManager *ui_manager = NULL;
static GtkActionGroup *action_group = NULL;
static gboolean abort_transfer = FALSE;
static GtkWidget *progress_dialog = NULL;
static GList *dirlist = NULL;
static GnomeVFSResult
delete_directory_recursive (gchar *file_name);
static gint
transfer_callback (GnomeVFSXferProgressInfo * info, gpointer data);
gboolean
delete_cb_recursive ( const gchar * rel_path,
	              	    GnomeVFSFileInfo * info,
              		    gboolean recursing_will_loop,
		                  gpointer data, 
											gboolean * recurse
										);
static void
clip_one_file (gpointer data,gpointer user_data);
void 
paste_file_clip(GtkActionGroup *action_group,gpointer data);
static void
copy_one_file (gpointer file, gpointer userdata);
const gchar *
get_the_copy_name (gchar * the_copy_name);

static void
delete_one_file (gpointer data,gpointer user_data);
static void
clear_clipboard (void)
{
  GList *iter = file_clipboard;
  if (!file_clipboard)
    return;
  while (iter)
    iter = iter->next;
  g_list_free (file_clipboard);
  file_clipboard = NULL;
}

static void
progress_response (GtkDialog * dialog, gint arg1, gpointer user_data)
{
  abort_transfer = TRUE;
}
static GtkWidget *
progress_dialog_create (gchar * title)
{
  GtkWidget *dialog;
  GtkWidget *progress;
  window = gtk_window_new(GTK_WINDOW_POPUP);
  dialog = gtk_dialog_new_with_buttons ( title, GTK_WINDOW (window),
                                				 GTK_DIALOG_MODAL |
					                               GTK_DIALOG_DESTROY_WITH_PARENT,
					                               GTK_STOCK_CANCEL, 
																				 GTK_RESPONSE_CANCEL,
					                               NULL
																			 );
  progress = gtk_progress_bar_new ();
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),progress, FALSE, TRUE, 0);
  g_object_set_data (G_OBJECT (dialog), "bar", progress);
  g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (progress_response), NULL);
  gtk_widget_show_all (dialog);
  return dialog;
}
static void
cb_softkey_action (GpeSKWindow * window, gint nr, gpointer user_data)
{
  
	
  if (nr == 0)
  {
    const gchar *current_path = gem_file_chooser_get_current_path(user_data);	  
    GList *sel = NULL;
      sel = gem_file_chooser_get_current_selections(user_data);
    if(!strcmp(current_path,virtual_root))
    {
      GtkAction *action = gtk_action_group_get_action(action_group,"copy_file_or_dir");
      gtk_action_set_visible(action,FALSE);		
      action = gtk_action_group_get_action(action_group,"paste_file_or_dir");
      gtk_action_set_visible (action,FALSE);		
      action = gtk_action_group_get_action(action_group,"delete_file_or_dir");
      gtk_action_set_visible (action,FALSE);		
      action = gtk_action_group_get_action(action_group,"select");
      gtk_action_set_visible(action,FALSE);		
      
      action = gtk_action_group_get_action(action_group,"open_file_or_dir");
      gtk_action_set_visible(action,TRUE);		
      if(sel == NULL)
        gtk_action_set_sensitive(action,FALSE);		
      else
        gtk_action_set_sensitive(action,TRUE);		
      return;
    }
    else
    {
      GtkAction *action = gtk_action_group_get_action(action_group,"copy_file_or_dir");
      gtk_action_set_visible(action,TRUE);		
      action = gtk_action_group_get_action(action_group,"paste_file_or_dir");
      gtk_action_set_visible(action,TRUE);		
      action = gtk_action_group_get_action(action_group,"delete_file_or_dir");
      gtk_action_set_visible(action,TRUE);		
      action = gtk_action_group_get_action(action_group,"select");
      gtk_action_set_visible(action,TRUE);		

      if(sel == NULL)
      {
        action = gtk_action_group_get_action(action_group,"copy_file_or_dir");
        gtk_action_set_sensitive (action,FALSE);		
        action = gtk_action_group_get_action(action_group,"delete_file_or_dir");
        gtk_action_set_sensitive (action,FALSE);		
			  action = gtk_action_group_get_action(action_group,"open_file_or_dir");
        gtk_action_set_sensitive (action,FALSE);		
        action = gtk_action_group_get_action(action_group,"select");
        gtk_action_set_sensitive (action,FALSE);		
      }
      else
      {
			  action = gtk_action_group_get_action(action_group,"open_file_or_dir");
			  if(g_list_length(sel) > 1)
          gtk_action_set_sensitive (action,FALSE);		
			  else
          gtk_action_set_sensitive (action,TRUE);		
				
				action = gtk_action_group_get_action(action_group,"copy_file_or_dir");
        gtk_action_set_sensitive (action,TRUE);		
        action = gtk_action_group_get_action(action_group,"paste_file_or_dir");
        gtk_action_set_sensitive (action,TRUE);		
        action = gtk_action_group_get_action(action_group,"delete_file_or_dir");
        gtk_action_set_sensitive (action,TRUE);		
      }
	  }   
  }
  if (nr == 1)
  {   
    gnome_vfs_shutdown (); 
    gtk_exit(0);
  }
}

static GnomeVFSResult
delete_directory_recursive (gchar *file_name)
{
  gchar *path = g_strdup (file_name);
  GList *iter;
  gnome_vfs_directory_visit ( file_name,
			                        GNOME_VFS_FILE_INFO_DEFAULT,
			                        GNOME_VFS_DIRECTORY_VISIT_DEFAULT,
			                        (GnomeVFSDirectoryVisitFunc) delete_cb_recursive,
			                        path
														);
	DBG("path=%s",path);
 	g_free (path);
  iter = dirlist;
  while (iter)
  {
    gnome_vfs_remove_directory (iter->data);
    DBG("FREE %s",iter->data);
		g_free (iter->data);
    iter = iter->next;
  }
  g_list_free (dirlist);
  dirlist = NULL;
  GnomeVFSResult r=gnome_vfs_remove_directory_from_uri (gnome_vfs_uri_new (file_name));
  return r;
}


static void
open_with (GnomeVFSMimeApplication * application, gchar *filename)
{
  pid_t pid;
  if (application)
  {
    gchar *msg = g_strdup_printf ("%s %s", "Starting", application->name);
    Display *dpy = GDK_DISPLAY ();
    
    //gpe_popup_infoprint (dpy, msg);
    g_free (msg);
    pid = fork ();
    switch (pid)
  	{
	    case    -1:
	            return;		/* failed */
	            break;
	    case    0:
	            if (application->requires_terminal)
							{
							  DBG("************************application->command=%s",application->command);
                DBG("filename=%s",filename);
								execlp (DEFAULT_TERMINAL, DEFAULT_TERMINAL, application->command, filename, NULL);
							  perror("111_______________________");  
							}
	            else
							{
							  DBG("****************application->command=%s",application->command);
                DBG("filename=%s",filename);
								execlp (application->command, application->command, filename, NULL);
							  perror("22222222222_______________________");  
							}
	            exit (-1);		/* die in case of failing to exec */
	            break;
	    default:
	            break;
	  }
  }
}

static void
popup_ask_open_file(GtkActionGroup *action_group,gpointer user_data)
{

  GtkWidget *dialog_window, *combo, *label, *entry;
  GtkWidget *open_button, *cancel_button;
  GList *applications = NULL;
  GList *appnames = NULL;
  gchar *s;
	GList *sel = NULL;
	sel = gem_file_chooser_get_current_selections_vfs_file_info(user_data);
	if((sel ==  NULL)||(g_list_length(sel) > 1))
		return;
  const gchar *current_path = gem_file_chooser_get_current_path(user_data); 
  
	DBG("CP=%s",current_path);
	GList *first = NULL;
	first = g_list_first(sel);
	if(first == NULL)
		return;
	GnomeVFSFileInfo *vfs_file_info = first->data;

	gchar *file_name = g_strdup_printf("%s/%s",current_path,vfs_file_info->name);
	DBG("FILE_NAME=%s",file_name);
  if(vfs_file_info->type == GNOME_VFS_FILE_TYPE_DIRECTORY)
  {
    gem_file_chooser_set_current_path(user_data,file_name);
	  return;	
	}
	dialog_window = gtk_dialog_new ();
  gtk_window_set_title (GTK_WINDOW (dialog_window), "Open With...");
  gtk_window_set_transient_for (GTK_WINDOW (dialog_window),
				GTK_WINDOW (window));
  gtk_window_set_modal (GTK_WINDOW (dialog_window), TRUE);

  label = gtk_label_new (NULL);
  s = g_strdup_printf ("<b>%s</b>", "Open with program");
  gtk_label_set_markup (GTK_LABEL (label), s);
  g_free (s);

  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);

  entry = gtk_entry_new ();

  combo = gtk_combo_new ();
  gtk_combo_set_value_in_list (GTK_COMBO (combo), TRUE, FALSE);

  cancel_button = gtk_dialog_add_button (GTK_DIALOG (dialog_window),
					 GTK_STOCK_CANCEL,
					 GTK_RESPONSE_CANCEL);

  open_button =
    gtk_dialog_add_button (GTK_DIALOG (dialog_window), GTK_STOCK_OK,
			   GTK_RESPONSE_OK);
 // gtk_container_set_border_width (GTK_CONTAINER
//				  (GTK_DIALOG (dialog_window)->vbox),
//				  gpe_get_border ());
//  gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
//		       gpe_get_boxspacing ());
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox), label, TRUE,
		      TRUE, 0);
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox), combo, TRUE,
		      TRUE, 0);
  GTK_WIDGET_SET_FLAGS (open_button, GTK_CAN_DEFAULT);
  gtk_widget_grab_default (open_button);

	if (vfs_file_info->mime_type)
  {
		DBG("MIME_TYPE=%s",vfs_file_info->mime_type);
		applications = gnome_vfs_application_registry_get_applications (vfs_file_info-> mime_type);
    if (applications)		/* translate list, get app info */
	  { 
	    GList *iter;
	    for (iter = applications; iter; iter = iter->next)
        iter->data = gnome_vfs_application_registry_get_mime_application (iter->data);
	  }
    else
	  applications = gnome_vfs_mime_get_short_list_applications (vfs_file_info->mime_type);
  }
  else
	{
	  DBG("NO MIME APPLICATIONS,find app by yourself");
		applications = gnome_vfs_mime_get_all_applications (vfs_file_info->mime_type);
	}

  /* fill combo with application names */
  if (applications)
  {
    GnomeVFSMimeApplication *app;
    GList *iter = applications;

    while (iter)
	  {
	    app = (GnomeVFSMimeApplication *) (iter->data);
	    appnames = g_list_append (appnames, app->name);
	    iter = iter->next;
	  }
    gtk_combo_set_popdown_strings (GTK_COMBO (combo), appnames);
  }
  else
  {
    gchar *s;
    gtk_widget_set_sensitive (combo, FALSE);
    gtk_widget_set_sensitive (open_button, FALSE);

    s = g_strdup_printf ("<b>%s</b>", "No available applications");
    gtk_label_set_markup (GTK_LABEL (label), s);
    g_free (s);
  }

  gtk_widget_show_all (dialog_window);

  /* run dialog */
  if (gtk_dialog_run (GTK_DIALOG (dialog_window)) == GTK_RESPONSE_OK)
  {
    GnomeVFSMimeApplication *app;
    GList *iter = applications;
    const gchar *selected_app =	gtk_entry_get_text (GTK_ENTRY (GTK_COMBO (combo)->entry));

    while (iter)
	 {
	   app = (GnomeVFSMimeApplication *) (((GList *) iter)->data);

	  if (!strcmp (selected_app, app->name))
	  {
			  open_with (app, file_name);
	      break;
	  }
	  iter = iter->next;
	}
}
  g_free(file_name);
  gtk_widget_destroy (dialog_window);
  g_list_free (appnames);



}
static void
popup_ask_delete_file(GtkActionGroup *action_group,gpointer user_data)
{
	GList *sel = NULL;
	sel = gem_file_chooser_get_current_selections_vfs_file_info(user_data);
	if(sel ==  NULL)
		return;
	g_list_foreach(sel,(GFunc)delete_one_file,user_data);
	
	const gchar *current_path = gem_file_chooser_get_current_path(user_data);
  gem_file_chooser_set_current_path(user_data,current_path);
}

static void
delete_one_file (gpointer data,gpointer user_data)
{
  gboolean isdir;
  GnomeVFSURI *uri;
  GnomeVFSResult r;
	GnomeVFSFileInfo *vfs_file_info =  NULL;
	vfs_file_info = data;
	const gchar *absolute_path = gem_file_chooser_get_current_path(user_data);
  gchar *file_name = g_strdup_printf("%s/%s",absolute_path,vfs_file_info->name);
  DBG("file_name=%s",file_name);
	if (vfs_file_info)
  {
    isdir = (vfs_file_info->type == GNOME_VFS_FILE_TYPE_DIRECTORY);
    if (isdir)
	  {  
	     DBG("is dir");
       r = delete_directory_recursive (file_name);
    }
    else
	  {
	    DBG("not dir");
			uri = gnome_vfs_uri_new (file_name);
	    r = gnome_vfs_unlink_from_uri (uri);
	    gnome_vfs_uri_unref (uri);
	  }
    if (r != GNOME_VFS_OK)
	  { 
       DBG(gnome_vfs_result_to_string (r));
    }
  }
  DBG("free file name:%s",file_name);
	g_free(file_name);
//  DBG("after free:%s",file_name);

}

gboolean
delete_cb_recursive ( const gchar * rel_path,