gemfilechooser.c.svn-base

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

    /*find parent path*/
    if (g_utf8_collate(name, "..") == 0)
		{
      gchar *temp = g_strdup(filechooser->current_path);
      if(strcmp(temp,virtual_root))
      {
        gchar *t = g_strrstr(temp,"/");
        if(t)
          *t='\0';
      }
      gchar *parent_str=g_strdup(temp);
      if(temp)
        g_free(temp);
			g_print("%s(): change to parent %s\n",
							__FUNCTION__,
							parent_str ? parent_str : "null");

			gem_file_chooser_set_current_path(filechooser,
																				parent_str);
      g_free(parent_str);
		}
		else/*not ..*/
		{
      /*change alias My Music to the real file name music*/
      {
        /*for virtual root mechnism*/
        int i = 0;
        if (!strcmp (filechooser->current_path, virtual_root))
        {
          
          for (i = 0; i < VIRTUAL_TOPDIR_COUNT; i++)
          {
	          if (!strcmp (virtual_topdirs[i].alias, name))
            {  
              if(name)
              {
                g_free(name);
                name = g_strdup(virtual_topdirs[i].path);
              }
              break;
            }
          }
        }  
      }
      gchar * absolute_path = NULL;
			absolute_path = g_build_filename( filechooser->current_path,
																			  name,
																			  NULL );
	     		
    
      /*test if the file exists*/
      GnomeVFSURI *uri = gnome_vfs_uri_new(absolute_path);
      
      if (!gnome_vfs_uri_exists (uri))
      {
        g_print("non-exist uri");
        return;
      }
      gnome_vfs_uri_unref (uri);
			if (is_folder)
			{
				gem_file_chooser_set_current_path(filechooser,absolute_path);
			}
#if	0				
			else/*is_file*/
			{
					GtkTreeIter iter;
					if (gtk_tree_model_get_iter(model,
																			&iter,
																			path) == TRUE)
					{
						GdkPixbuf * pixbuf = NULL,*pb = NULL;
						gchar * picpath = NULL;
						gboolean selected = FALSE;
						
						gtk_tree_model_get(model,
															 &iter,
															 GEM_FC_COL_CHECK,
															 &selected,
															 -1);
						selected = !selected;
						
						if (selected)
						{
							picpath = g_build_filename(gem_resource_path,
																				 "pixmaps",
																				 "file_selected.png",
																				 NULL);
						  if (gem_resource_load_pic(picpath,
																			GEM_PIC_NORMAL) == TRUE)
						  {
							  pixbuf = gem_resource_find_pic(picpath,
																						 GEM_PIC_NORMAL);
						  }
						  g_free(picpath);
						}
						else
						{
               gchar *mime_icon =  find_mime_icon(vfs_file_info,absolute_path);
               pixbuf = get_pixbuf(mime_icon);
						}
            pb = gdk_pixbuf_scale_simple (pixbuf, 32, 32, GDK_INTERP_BILINEAR);
						gtk_list_store_set(GTK_LIST_STORE(model),
															 &iter,
															 GEM_FC_COL_CHECK,
															 TRUE,
															 -1);
					}
					g_signal_emit(G_OBJECT(filechooser),
												file_chooser_signals[FILE_SELECTED],
												0);
			}
#endif
			g_free(absolute_path);
		}
		g_free(name);
	}
	
	return;
}
#endif 
static void
gem_file_chooser_init (GemFileChooser * filechooser)
{
	GtkWidget * treeview = NULL;
	GtkListStore * liststore = NULL;
	GtkCellRenderer * renderer = NULL;
	GtkTreeViewColumn	* col = NULL;
  gem_resource_path = gem_env_get_resource_path();
	liststore = gtk_list_store_new(GEM_FC_NUMS_COLS,
																 G_TYPE_BOOLEAN,
																 GDK_TYPE_PIXBUF,
																 G_TYPE_STRING,
																 G_TYPE_BOOLEAN,
                                 G_TYPE_POINTER,
																 G_TYPE_BOOLEAN
                                 );
	treeview = gem_tree_view_get_view(GEM_TREE_VIEW(filechooser));
		
	
  /* column checkbox*/
  col = gtk_tree_view_column_new ();
  gtk_tree_view_column_set_title (col, "Check_Box");
  renderer = gtk_cell_renderer_toggle_new ();
  gtk_tree_view_column_pack_start (col, renderer, TRUE);
	//gtk_cell_renderer_set_fixed_size(renderer, 16, 16);
  gtk_tree_view_column_add_attribute (col, renderer, "active", GEM_FC_COL_CHECK_BOX);
  gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
  
  g_signal_connect (G_OBJECT (renderer), "toggled",G_CALLBACK (mark_toggled_cb),(gpointer)filechooser);
  gtk_cell_renderer_toggle_set_active((GtkCellRendererToggle*)renderer,FALSE);
  filechooser->check_box = col;  
  
  /* column pic */
	col = gtk_tree_view_column_new();
	gtk_tree_view_column_set_title(col, "Picutre");
	gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), col);
		
	renderer = gtk_cell_renderer_pixbuf_new();
	gtk_cell_renderer_set_fixed_size(renderer, 32, 32);
	gtk_tree_view_column_pack_start(col, renderer, TRUE);
	gtk_tree_view_column_add_attribute(col,
																		 renderer,
																		 "pixbuf",
																		 GEM_FC_COL_PIC);
	
	/* column name */
	col = gtk_tree_view_column_new();
	gtk_tree_view_column_set_title(col, "Name");
	gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), col);
		
	renderer = gtk_cell_renderer_text_new();
	gtk_cell_renderer_set_fixed_size(renderer, 130, -1);
	g_object_set(G_OBJECT(renderer), "ypad", 5, NULL);
	gtk_tree_view_column_pack_start(col, renderer, TRUE);
	gtk_tree_view_column_add_attribute(col,
																		 renderer,
																		 "text",
																		 GEM_FC_COL_NAME);
	
	/* set model */	
	gem_tree_view_set_model(GEM_TREE_VIEW(filechooser),
												  GTK_TREE_MODEL(liststore));
	
	gem_tree_view_set_search_column(GEM_TREE_VIEW(filechooser),
																	GEM_FC_COL_NAME,
																	GTK_SORT_ASCENDING,
																	gemgem_file_chooser_sort_func);

	g_signal_connect(G_OBJECT(treeview),
									 "row-activated",
									 G_CALLBACK(gem_file_chooser_tree_view_row_activated),
									 (gpointer)filechooser);

  gem_file_chooser_set_selectable(filechooser,FALSE);
  gchar *env=getenv("GEM_FC_VROOT");
  if(env)
  {
    virtual_root = g_strdup(env);   
  }
  
  gem_file_chooser_set_current_path(filechooser,
																		virtual_root);
	return;
}

static void
gem_file_chooser_set_selection_all (GemFileChooser		*filechooser,
																		gboolean					 tag)
{
	GtkTreeModel * model = NULL;
	gint count = 0;
	gint i;

	if (filechooser->selectable == FALSE)
	{
		DBG("in non-selectable mode.\n");
		return;
	}

	model = gem_tree_view_get_model(GEM_TREE_VIEW(filechooser));
	if (model == NULL)
	{
		return;
	}
	
	count = gtk_tree_model_iter_n_children(model, NULL);
	for (i = 1; i < count; i++)
	{
		GtkTreeIter iter;
				
		if (gtk_tree_model_iter_nth_child(model,
																			&iter,
																			NULL,
																			i) == TRUE)
		{
				gtk_list_store_set(GTK_LIST_STORE(model),
													 &iter,
													 GEM_FC_COL_CHECK,
													 tag,
													 GEM_FC_COL_CHECK_BOX,
													 tag,
													 -1);

		}
	}
	
	return;	
}

/* Public API
 */
GtkWidget*
gem_file_chooser_new (void)
{
  
  gnome_vfs_init();
  gnome_vfs_mime_info_reload ();
  return g_object_new(GEM_TYPE_FILE_CHOOSER,NULL);
  
}

static gboolean
do_scheduled_refresh (gpointer fchooser)
{
  DBG("Fresh");
  const gchar *current_path = gem_file_chooser_get_current_path (fchooser);
  gem_file_chooser_set_current_path (fchooser,current_path);
  refresh_scheduled = FALSE ;
  return FALSE;
}
void
directory_changed ( GnomeVFSMonitorHandle * handle,
   	                const gchar * monitor_uri,
  	                const gchar * info_uri,
  	                GnomeVFSMonitorEventType event_type, gpointer user_data )
{
  /* schedule timeout if necessary */
  //if ((!refresh_scheduled)&&((GNOME_VFS_MONITOR_EVENT_DELETED)||(GNOME_VFS_MONITOR_EVENT_CREATED)))
  DBG("Dir changed deteted...........................................................");
  if (!refresh_scheduled)
  {
    g_timeout_add (2000, (GSourceFunc) do_scheduled_refresh, user_data);
    refresh_scheduled = TRUE;
  }
  DBG("##############################333");
}

/**
 * gem_file_chooser_set_current_path:
 * 
 * @filechooser	:	a #GemFileChooser object
 * @pathstr			:	a file path to set as the current path of
 * 								#GemFileChooser object
 **/
void
gem_file_chooser_set_current_path (GemFileChooser			*filechooser,
																	 const gchar				*pathstr)
{
  GdkPixbuf * icons[GEM_FC_NUMS_ICONS] = {
                                           NULL,
                                           NULL,
                                           NULL,
                                           NULL,
                                           NULL,
                                           NULL
                                          };
  

	
  GtkTreeModel * model = NULL;
  if (pathstr == NULL)
	{
		return;
	}
  
  GnomeVFSURI *uri = gnome_vfs_uri_new(pathstr);
  if (!gnome_vfs_uri_exists (uri))
  {
    g_print("non-exist uri");
    return;
  }
  gnome_vfs_uri_unref (uri);

  gchar *current_path = g_strdup(pathstr);
  if(!strcmp(pathstr,"/"))
  {
    if(current_path)
    { 
      g_free((gchar *)current_path);
    }
    current_path = g_strdup(virtual_root);
  }
	model = gem_tree_view_get_model(GEM_TREE_VIEW(filechooser));
	if (model)
	{
		GSList * iter = NULL;
    loaded_icons = g_hash_table_new (g_str_hash, g_str_equal);
    
    /*free the pre tree model*/
    {
#if 1
      GtkTreeIter iter;
      gchar *name=NULL;
      gint i=1;
      GdkPixbuf *pixbuf=NULL;
      GnomeVFSFileInfo *vfs_file_info = gnome_vfs_file_info_new();
			gint count = gtk_tree_model_iter_n_children(model, NULL);
			for (i = 1; i < count; i++)
			{
				GtkTreeIter iter;
				if (gtk_tree_model_iter_nth_child(model,
																					&iter,
																					NULL,
																					i) == TRUE)
        {
          gtk_tree_model_get( GTK_TREE_MODEL(model),
					  								  &iter,
						  						    GEM_FC_COL_NAME,
                              &name, 
								  						GEM_FC_COL_PIC,
									  					&pixbuf,
                              GEM_FC_COL_VFS_FILE_INFO,
                              &vfs_file_info,
												  	  -1);
					if (name)
          {
            g_free(name);
          }
	        gdk_pixbuf_unref (pixbuf);
          gnome_vfs_file_info_unref(vfs_file_info);    
        }
      }
#endif
      gtk_list_store_clear(GTK_LIST_STORE(model));
    }
		DBG("ADD MONITOR");
    /*add monitor to the current directory*/
    if (TRUE)
		{
    /* monitor current directory */
      if (dir_monitor)
        gnome_vfs_monitor_cancel (dir_monitor);
      if (gnome_vfs_monitor_add ( &dir_monitor, current_path,
			                            GNOME_VFS_MONITOR_DIRECTORY,
                                  (GnomeVFSMonitorCallback) directory_changed,
			                            filechooser ) != GNOME_VFS_OK )
      { 
        dir_monitor = NULL;
        DBG("curre_path monitor not added.................=%s",current_path);
      }
      else
      {
        DBG("curre_path monitor  added ............................=%s",current_path);
      }
    } 
    if (TRUE)
		{
			gchar * fname[] = {
		                   		"music.png",
                   				"photo.png",
                  				"ringtone.png",
                  				"video.png",
                  				"sd.png",
                  				"parent.png",
                          "collection.png",
                          "normal.png"
                  			};
			gint i;
			for (i = 0; i < GEM_FC_NUMS_ICONS; i++)
			{
				gchar * picpath = NULL;
				picpath = g_build_filename( gem_resource_path,
																	  "pixmaps",
																	  fname[i],
																	  NULL 
                                  );
				if (gem_resource_load_pic( picpath, GEM_PIC_NORMAL) == TRUE )
				{
					icons[i] = gem_resource_find_pic( picpath, GEM_PIC_NORMAL );
				}
				g_free(picpath);
			}
		}
		/*
		 * we need a ".." item to act as
		 * the parent of current path, to supply 
		 * a possiblity to user to go backward
		 */
    
    if (strcmp (current_path, virtual_root))
		{
      GtkTreeIter iter;
	   	gtk_list_store_append(GTK_LIST_STORE(model),&iter);
		  gtk_list_store_set( GTK_LIST_STORE(model),
			        					  &iter,
							        	  GEM_FC_COL_NAME,
					         			  "..",
								          GEM_FC_COL_PIC,
		       							  icons[PARENT],
					        			  GEM_FC_COL_IS_FOLDER,
								          TRUE,
						        		  GEM_FC_COL_CHECK_BOX,
                          FALSE,
								          -1
                         );
		}
    else
    {
      GtkTreeIter iter;
	   	gtk_list_store_append(GTK_LIST_STORE(model),&iter);
		  gtk_list_store_set( GTK_LIST_STORE(model),
			        					  &iter,
							        	  GEM_FC_COL_NAME,
					         			  "My Collections",
								          GEM_FC_COL_PIC,
		       							  icons[COLLECTION],
					        			  GEM_FC_COL_IS_FOLDER,
								          TRUE,
						        		  GEM_FC_COL_CHECK_BOX,
								          FALSE,
                          -1
                         );
    }
    {  
          
      GnomeVFSDirectoryHandle *handle = NULL;
      GnomeVFSFileInfo *vfs_file_info = NULL;
	    GtkTreeIter  tree_iter;
      gchar *name;
      GnomeVFSResult result = GNOME_VFS_OK, open_dir_result;
      open_dir_result =gnome_vfs_directory_open ( &handle, current_path,
			                                             GNOME_VFS_FILE_INFO_DEFAULT
                                   		 	           | GNOME_VFS_FILE_INFO_FOLLOW_LINKS
                                                   | GNOME_VFS_FILE_INFO_GET_MIME_TYPE );

      while (open_dir_result == GNOME_VFS_OK)
      {
        vfs_file_info = gnome_vfs_file_info_new ();
        result = gnome_vfs_directory_read_next (handle, vfs_file_info);
        if (result != GNOME_VFS_OK)
	      {
          gnome_vfs_file_info_unref(vfs_file_info);
          gnome_vfs_directory_close (handle);
	        break;
	      }
        if (vfs_file_info->name != NULL && vfs_file_info->name[0] != '.')
	      {
          GdkPixbuf *pixbuf = NULL;
          GdkPixbuf *pb;
          gchar *mime_icon;