testfc.c.svn-base

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

	              	    GnomeVFSFileInfo * info,
              		    gboolean recursing_will_loop,
		                  gpointer data, 
											gboolean * recurse
										)
{
  gchar *path = data;
  gchar *fn = g_strdup_printf ("%s/%s", path, rel_path);
  if (info->type == GNOME_VFS_FILE_TYPE_DIRECTORY)
  {
    *recurse = TRUE;
    GnomeVFSResult r = 0;
    if (!recursing_will_loop)
     	r = gnome_vfs_directory_visit ( fn, GNOME_VFS_FILE_INFO_DEFAULT,
                       				        GNOME_VFS_DIRECTORY_VISIT_DEFAULT,
                      				        (GnomeVFSDirectoryVisitFunc)delete_cb_recursive, 
                                      strdup (fn)
                                    );
      /* HACK: We collect the empty directories in a list to delete after 
         visiting the complete tree to prevent gnome-vfs from stopping
         visiting directories 
       */
    if (r == GNOME_VFS_OK)
   	{
      dirlist = g_list_append (dirlist, fn);
	  }
    else
	  {
      fprintf (stderr, "Err %s\n", gnome_vfs_result_to_string (r));
    }
  }
  else
  {
     gnome_vfs_unlink_from_uri (gnome_vfs_uri_new (fn));
     g_free (fn);
  }
  return TRUE;
}

static void
popup_copy_file_clip(GtkActionGroup *action_group,gpointer user_data)
{
  clear_clipboard();
	GList *sel = NULL;
	sel = gem_file_chooser_get_current_selections_vfs_file_info(user_data);
	if(sel ==  NULL)
		return;
	DBG("******************************fc=%p",user_data);
	g_list_foreach(sel,(GFunc)clip_one_file,user_data);
	gem_file_chooser_set_selectable(user_data,FALSE);
}

static void
clip_one_file (gpointer data,gpointer user_data)
{
  GnomeVFSFileInfo *vfs_file_info = data;
  DBG("vfs-->name = %s",vfs_file_info->name);
	const gchar *absolute_path = gem_file_chooser_get_current_path(user_data);
	DBG("******************************fc = %p",user_data);
  gchar *file_path = g_strdup_printf("%s/%s",absolute_path,vfs_file_info->name);
 	if (vfs_file_info)
  {				//handle local file,filename prefix is file://
    if (GNOME_VFS_FILE_INFO_LOCAL (vfs_file_info))
	  {
	    file_clipboard = g_list_append (file_clipboard,  gnome_vfs_get_uri_from_local_path (file_path) +  7);
	  }
    else
	    file_clipboard = g_list_append (file_clipboard, g_strdup (file_path));
  }
	g_free(file_path);
}
void paste_file_clip(GtkActionGroup *action_group, gpointer data)
{
  if (file_clipboard == NULL)
    return;
  const gchar *current_path = gem_file_chooser_get_current_path(data);
  g_list_foreach (file_clipboard,(GFunc)copy_one_file,data);
  gem_file_chooser_set_current_path(data,current_path);
}



void
copy_file (const gchar * src_uri_txt, const gchar * dest_uri_txt)
{
  GnomeVFSURI *uri_src = gnome_vfs_uri_new (src_uri_txt);
  GnomeVFSURI *uri_dest = gnome_vfs_uri_new (dest_uri_txt);
  GnomeVFSResult result;
  gchar *error;

  result = gnome_vfs_xfer_uri (uri_src,
			       uri_dest,
			       GNOME_VFS_XFER_FOLLOW_LINKS
			       | GNOME_VFS_XFER_RECURSIVE
			       | GNOME_VFS_XFER_EMPTY_DIRECTORIES,
			       GNOME_VFS_XFER_ERROR_MODE_QUERY,
			       GNOME_VFS_XFER_OVERWRITE_MODE_QUERY,
			       (GnomeVFSXferProgressCallback)
			       transfer_callback, NULL);

  if ((result != GNOME_VFS_OK) && (result != GNOME_VFS_ERROR_INTERRUPTED))
  {
    error = g_strdup_printf ("%s",gnome_vfs_result_to_string (result));
    DBG("ERROR:::%s",error);
	  g_free (error);
  }
  else
  {
    //gpe_popup_infoprint (GDK_DISPLAY (), _("File copied."));
		DBG("Flie Copied");
  }
  gnome_vfs_uri_unref (uri_src);
  gnome_vfs_uri_unref (uri_dest);
}
static void
copy_one_file (gpointer file, gpointer userdata)
{
  gchar *target_file;
	
  const gchar *current_directory = gem_file_chooser_get_current_path(userdata);
  DBG("file=%s",file);
  DBG("current_directory=%s",current_directory);
  DBG("base name=%s",g_path_get_basename (file));
	target_file =	g_strdup_printf ("%s/%s", current_directory, g_path_get_basename (file));
  DBG("target_file=%s",target_file);
	//we need to find a name for the copy... 
  target_file = g_strdup (get_the_copy_name (target_file));

  copy_file (file, target_file);
  g_free (target_file);
}

static gint
transfer_callback (GnomeVFSXferProgressInfo * info, gpointer data)
{
  GtkWidget *dialog;
  GtkWidget *label;
  gchar *text;
  int response;
  gboolean applytoall;

  window = gtk_window_new(GTK_WINDOW_POPUP);
  if (abort_transfer)
  {
    gtk_widget_destroy (progress_dialog);
    progress_dialog = NULL;
    abort_transfer = FALSE;
    return 0;
  }
  switch (info->status)
  {
    case GNOME_VFS_XFER_PROGRESS_STATUS_OK:
         if (progress_dialog == NULL)
       	   progress_dialog = progress_dialog_create ("Transfer progress");
         else if (info->bytes_total)
	       {
	         GtkWidget *bar = g_object_get_data (G_OBJECT (progress_dialog), "bar");
	         gtk_progress_bar_set_fraction ( GTK_PROGRESS_BAR (bar),
					                                 (gdouble) info->total_bytes_copied /(gdouble)(info->bytes_total)
																				 );
	       }
         if (info->phase == GNOME_VFS_XFER_PHASE_COMPLETED)
	       {
	          gtk_widget_destroy (progress_dialog);
	          progress_dialog = NULL;
	       }
         gtk_main_iteration_do (FALSE);
         return 1;
    break;
    case GNOME_VFS_XFER_PROGRESS_STATUS_VFSERROR:
      /* error query dialog */

          text = g_strdup_printf ("%s %s", "Error:",
			    gnome_vfs_result_to_string (info->vfs_status));
          dialog = gtk_dialog_new_with_buttons ( "Error", GTK_WINDOW (window),
					                                        GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
					                                        "_Skip", GTK_RESPONSE_HELP,
                                    					    "_Retry", GTK_RESPONSE_APPLY,
                                    					    GTK_STOCK_CANCEL,
                                         			    GTK_RESPONSE_CANCEL, NULL
																								);
          label = gtk_label_new (text);
          g_free (text);
          gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
          gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), label, FALSE, TRUE, 0);
          gtk_widget_show_all (dialog);
          response = gtk_dialog_run (GTK_DIALOG (dialog));
          gtk_widget_destroy (dialog);
          switch (response)
	        {
	          case   GTK_RESPONSE_CANCEL:
	                 gtk_widget_destroy (progress_dialog);
	                 progress_dialog = NULL;
	                 return GNOME_VFS_XFER_ERROR_ACTION_ABORT;
	          break;
	          case   GTK_RESPONSE_HELP:
	                 return GNOME_VFS_XFER_ERROR_ACTION_SKIP;
	          break;
	          case   GTK_RESPONSE_APPLY:
	                 return GNOME_VFS_XFER_ERROR_ACTION_RETRY;
	          break;
	          default:
	                 gtk_widget_destroy (progress_dialog);
	                 progress_dialog = NULL;
	                 return GNOME_VFS_XFER_ERROR_ACTION_ABORT;
	          break;
	        }
    break;
    case GNOME_VFS_XFER_PROGRESS_STATUS_OVERWRITE:
      /* overwrite query dialog */
         text = g_strdup_printf ("Overwrite file:\n%s", info->target_name);
         dialog =  gtk_dialog_new_with_buttons ("File exists", GTK_WINDOW (window),
				                                          GTK_DIALOG_MODAL |
                            				              GTK_DIALOG_DESTROY_WITH_PARENT,
                                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                       			      GTK_STOCK_YES, GTK_RESPONSE_YES,
                                      			      GTK_STOCK_NO, GTK_RESPONSE_NO, NULL);
          label = gtk_label_new (text);
          g_free (text);
          gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), label, FALSE, TRUE, 0);
          label = gtk_check_button_new_with_label ("Apply to all");
          gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (label), FALSE);
          gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), label, FALSE, TRUE, 0);
          gtk_widget_show_all (dialog);
          response = gtk_dialog_run (GTK_DIALOG (dialog));
          applytoall = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (label));
          gtk_widget_destroy (dialog);
          switch (response)
	        {
	          case  GTK_RESPONSE_CANCEL:
	                gtk_widget_destroy (progress_dialog);
	                progress_dialog = NULL;
	                return GNOME_VFS_XFER_OVERWRITE_ACTION_ABORT;
               	  break;
          	case  GTK_RESPONSE_YES:
                  if (applytoall)
            	      return GNOME_VFS_XFER_OVERWRITE_ACTION_REPLACE_ALL;
	                else
	                  return GNOME_VFS_XFER_OVERWRITE_ACTION_REPLACE;
	                break;
          	case  GTK_RESPONSE_NO:
	                if (applytoall)
	                  return GNOME_VFS_XFER_OVERWRITE_ACTION_SKIP_ALL;
	                else
	                  return GNOME_VFS_XFER_OVERWRITE_ACTION_SKIP;
	                break;
	          default:
	                gtk_widget_destroy (progress_dialog);
	                progress_dialog = NULL;
	                return GNOME_VFS_XFER_OVERWRITE_ACTION_ABORT;
	           break;
	         }
    break;
    default:
           return 1;			/* we should never get there */
           break;
  }
}
const gchar *
get_the_copy_name (gchar * the_copy_name)
{
  gint i = 1;
  const char *rbracket = "(";
  const char *dot = ".";
  gchar *tt, *ext;
  gchar *basename, *temp = NULL;
  basename = g_strdup (the_copy_name);
  ext = g_strrstr (basename, dot);
  if (ext != NULL)
  {
    *ext = '\0';
    ext++;
  }
  tt = g_strrstr (basename, rbracket);
  if (tt != NULL)
  {
    *tt = '\0';
  }

  GnomeVFSURI *uri = gnome_vfs_uri_new (the_copy_name);
  while (TRUE)
  {
    if ((gnome_vfs_uri_exists (uri)))
	  {
	    if (ext)
	      temp = g_strdup_printf ("%s(%d).%s", basename, i, ext);
	    else
	      temp = g_strdup_printf ("%s(%d)", basename, i);
	    i++;
	    uri = gnome_vfs_uri_new (temp);
	    g_free (temp);
	  }
    else
	  {
	    break;
	  }
  }
  g_free (basename);
  g_free (the_copy_name);
  return gnome_vfs_uri_get_path (uri);
}
void 
multi_select_enable(GtkActionGroup *action_group,gpointer data)
{
  MARK=~MARK;
  gem_file_chooser_set_selectable(data,MARK);
  return;
}
#if BLUETOOTH
static gchar *menu_item = " \
	<ui>\
		<popup  action=\"PopupLeft\">\
			<menuitem name=\"copy\"		        	 action=\"copy_file_or_dir\"/>\
			<menuitem name=\"paste\"			       action=\"paste_file_or_dir\"/>\
			<menuitem name=\"move\"		           action=\"move_file_or_dir\"/>\
			<menuitem name=\"rename\"			       action=\"rename_file_or_dir\"/>\
			<menuitem name=\"delete\"			       action=\"delete_file_or_dir\"/>\
			<menuitem name=\"creat_dir\"			   action=\"creat_new_dir\"/>\
			<menuitem name=\"select_all\"			   action=\"select_all\"/>\
			<menuitem name=\"select_all\"			   action=\"select_all\"/>\
			<menuitem name=\"send_via_bluetooth\"			action=\"send_via_bluetooth\"/>\
			<menuitem name=\"send_via_infrared\"			action=\"send_via_infrared\"/>\
		</popup>\
	</ui>\
";

static GtkActionEntry menu_actions[] = {
  {"copy_file_or_dir"   , NULL, "_Copy"              , "", "none", popup_copy_file_clip},
  {"paste_file_or_dir"  , NULL, "_Paste"             , "", "none", paste_file_clip},
  {"move_file_or_dir"   , NULL, "_Move"              , "", "none", popup_ask_move_file},
  {"rename_file_or_dir" , NULL, "_Rename"            , "", "none", popup_ask_rename_file},
  {"delete_file_or_dir" , NULL, "_Delete"            , "", "none", popup_ask_delete_file},
  {"creat_new_dir"      , NULL, "_Create"            , "", "none", create_directory_interactive},
  {"select_all"         , NULL, "_Select All"        , "", "none", do_select_all},
  {"send_via_bluetooth" , NULL, "_Send via Bluetooth", "", "none", send_with_bluetooth},
  {"send_via_infrared"  , NULL, "_Send via Infrared" , "", "none", send_with_irda},
  {"PopupLeft"          , NULL, "Popup"              , "", "none", NULL},
};
#else
static gchar *menu_item = " \
	<ui>\
		<popup  action=\"PopupLeft\">\
			<menuitem name=\"open\"		        	 action=\"open_file_or_dir\"/>\
			<menuitem name=\"copy\"		        	 action=\"copy_file_or_dir\"/>\
			<menuitem name=\"paste\"			       action=\"paste_file_or_dir\"/>\
			<menuitem name=\"delete\"			       action=\"delete_file_or_dir\"/>\
			<menuitem name=\"select\"   			   action=\"select\"/>\
		</popup>\
	</ui>\
";
static GtkActionEntry menu_actions[] = {
  {"open_file_or_dir"   , NULL, "Open"              , "", "open"   , popup_ask_open_file},
  {"copy_file_or_dir"   , NULL, "Copy"              , "", "copy"   , popup_copy_file_clip},
  {"paste_file_or_dir"  , NULL, "Paste"             , "", "paste"  , paste_file_clip},
  {"delete_file_or_dir" , NULL, "Delete"            , "", "delete" , popup_ask_delete_file},
  {"select"             , NULL, "Mark/Unmark"       , "", "mark"   , multi_select_enable},
  {"PopupLeft"          , NULL, "Popup"             , "", "none"   , NULL},
};

#endif 

int main( int   argc,
          char *argv[] )
{
  gtk_init (&argc, &argv);
  GtkWidget *vbox = NULL; 
 
  GtkWidget *fchooser = NULL;
  GError *error = NULL;
   
  window = gpe_skwindow_new ();
  vbox = gtk_vbox_new(FALSE, 0);
  fchooser = gem_file_chooser_new ();
  gem_file_chooser_set_current_path(fchooser,"/");
  gtk_box_pack_start ( GTK_BOX (vbox),
                           fchooser,
                            TRUE,
                            TRUE,
                             0);
  
  gtk_container_add (GTK_CONTAINER (window), vbox);
 
	action_group = gtk_action_group_new ("Actions");
  ui_manager = gtk_ui_manager_new ();
  gtk_action_group_add_actions (action_group,	menu_actions,	G_N_ELEMENTS (menu_actions), fchooser);

  gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
  if (!gtk_ui_manager_add_ui_from_string (GTK_UI_MANAGER (ui_manager), menu_item, -1, &error))
  {
    g_printerr ("Failed to parse menu data: %s\n", error->message);
    g_error_free (error);
    return 0;
  }
  
   gpe_skwindow_set_softkey_label (GPE_SKWINDOW (window), 1, "Back");
   gpe_skwindow_set_softkey_label (GPE_SKWINDOW (window), 0, "Option");
   /* test DBUS alive? */
   {
     gchar *env = getenv ("DBUS_SESSION_BUS_ADDRESS");
     if (env)
     {
	     gchar *db_skt;
 	     /* env format:  unix:abstract=/tmp/dbus-oPDqe55s2c,guid=58c26446325920ef5440736a57f10100 */
	     db_skt = strchr (env, '=');
	     if (db_skt && strstr (db_skt + 1, "/tmp/"))	/* the socket file might not exist! */
       {
	       GtkWidget *sk_menu = gtk_ui_manager_get_widget (ui_manager, "/PopupLeft");
	       gpe_skwindow_set_softkey_menu (GPE_SKWINDOW (window), 0, sk_menu);
  	     gpe_skwindow_set_softkey_label (GPE_SKWINDOW (window), 0, "Option");
         gpe_skwindow_set_softkey_label (GPE_SKWINDOW (window), 1, "Exit");
         g_signal_connect (GPE_SKWINDOW (window), "softkey_activated", G_CALLBACK (cb_softkey_action), fchooser);
	     }
	     else
	     {
	       g_print ("DBUS might not be running, pls check it.\n");
	     }
     }
     else
     {
	     g_print ("DBUS might not be running, pls check it.\n");
     }
   }
  
   gtk_signal_connect (GTK_OBJECT (window), "delete-event", GTK_SIGNAL_FUNC (gtk_exit), NULL);
   gtk_widget_realize (window);
   
   gtk_widget_show_all (window);
   gtk_main ();
}