Attachment #58432 for bug #91939




	if (gnome_vfs_volume_is_user_visible (volume)) {
		drive = gnome_vfs_volume_get_drive (volume);
		if (drive == NULL) {
			if (gnome_vfs_volume_get_volume_type (volume) != GNOME_VFS_VOLUME_TYPE_CONNECTED_SERVER) {
			file = computer_file_new (COMPUTER_VOLUME);
			name = gnome_vfs_volume_get_display_name (volume);
			file->file_name = build_file_name (name, ".volume");
			g_free (name);
			file->volume = gnome_vfs_volume_ref (volume);
			computer_file_add (dir, file);
			}
		} else {
			file = get_drive_file (dir, drive);
			if (file != NULL) {

	file->file_name = g_strdup ("Filesystem.desktop");
	computer_file_add (dir, file);
	
	/*
	file = computer_file_new (COMPUTER_NETWORK_LINK);
	file->file_name = g_strdup ("Network.desktop");
	computer_file_add (dir, file);
	*/
	volumes = gnome_vfs_volume_monitor_get_mounted_volumes (monitor);
	drives = gnome_vfs_volume_monitor_get_connected_drives (monitor);
	

		if (gnome_vfs_volume_is_user_visible (volume)) {
			drive = gnome_vfs_volume_get_drive (volume);
			if (drive == NULL) {
				if (gnome_vfs_volume_get_volume_type (volume) != GNOME_VFS_VOLUME_TYPE_CONNECTED_SERVER) {
				file = computer_file_new (COMPUTER_VOLUME);
				name = gnome_vfs_volume_get_display_name (volume);
				file->file_name = build_file_name (name, ".volume");
				g_free (name);
				file->volume = gnome_vfs_volume_ref (volume);
				computer_file_add (dir, file);
				}
			}
			gnome_vfs_drive_unref (drive);
		}




	char *icon;
	char *target_uri;
        char *filename;
	gint vol_id;
} NetworkLink;

typedef struct {

static char *
get_data_for_link (const char *uri, 
		   const char *display_name, 
		   const char *icon,
		   gint        vol_id)
{
	char *data;


				"Name=%s\n"
				"Type=FSDevice\n"
				"Icon=%s\n"
				"URL=%s\n"
				"%sX-Gnome-Volume=%d\n",
				display_name,
				icon,
				uri,
				vol_id >= 0 ? "" : "#",
				vol_id);
	return data;
}


add_link (const char *filename,
	  const char *target_uri,
	  const char *display_name,
	  const char *icon,
	  gint        vol_id)
{
	NetworkLink *link;


	link->target_uri = g_strdup (target_uri);
	link->display_name = g_strdup (display_name);
	link->icon = g_strdup (icon);
	link->vol_id = vol_id;

	active_links = g_list_prepend (active_links, link);
	do_link_event (filename,

	add_link (filename,
		  link_uri,
		  domain,
		  "gnome-fs-network",
		  -1);
	g_free (filename);
	g_free (link_uri);
}

{
	return get_data_for_link (link->target_uri, 
				  link->display_name, 
				  link->icon,
				  link->vol_id);
}

/* Call with lock held */


}

/* functions to handle volumes */
static char *
build_volume_filename (GnomeVFSVolume *volume)
{
	char *name, *escaped, *ret;

	name = gnome_vfs_volume_get_display_name (volume);
	escaped = gnome_vfs_escape_string (name);
	ret = g_strconcat ("volume-", escaped, NULL);
	g_free(escaped);
	g_free(name);

	return ret;
}

static void
volume_mounted (GnomeVFSVolumeMonitor *monitor,
		GnomeVFSVolume        *volume,
		gpointer               user_data)
{
	char *volume_file, *volume_uri;
	char *volume_name, *volume_icon;

	G_LOCK (network);
	if (gnome_vfs_volume_is_user_visible (volume) &&
	    gnome_vfs_volume_get_volume_type (volume) == GNOME_VFS_VOLUME_TYPE_CONNECTED_SERVER) {
		volume_file = build_volume_filename (volume);
		volume_uri = gnome_vfs_volume_get_activation_uri (volume);
		volume_name = gnome_vfs_volume_get_display_name (volume);
		volume_icon = gnome_vfs_volume_get_icon (volume);

		add_link (volume_file, volume_uri,
			  volume_name, volume_icon,
			  gnome_vfs_volume_get_id (volume));
		g_free (volume_icon);
		g_free (volume_name);
		g_free (volume_uri);
		g_free (volume_file);
	}
	G_UNLOCK (network);
}

static void
volume_unmounted (GnomeVFSVolumeMonitor *volume_monitor,
		  GnomeVFSVolume        *volume,
		  gpointer               user_data)
{
	char *volume_file;

	G_LOCK (network);

	volume_file = build_volume_filename (volume);
	remove_link (volume_file);
	g_free (volume_file);

	G_UNLOCK (network);
}

static GnomeVFSResult
do_open (GnomeVFSMethod *method,

	GConfClient *gconf_client;
	GnomeVFSURI *uri;
	char *workgroup_uri, *workgroup_escaped, *setting;
	GnomeVFSVolumeMonitor *monitor;
	GList *volumes, *l;
	
	gconf_client = gconf_client_get_default ();


		add_link ("smblink-root",
			  "smb://",
			  _("Windows Network"),
			  "gnome-fs-network",
			  -1);
	}

	/* add non-drive volumes to network:/// folder */
	monitor = gnome_vfs_get_volume_monitor ();
	volumes = gnome_vfs_volume_monitor_get_mounted_volumes (monitor);
	for (l = volumes; l != NULL; l = l->next) {
		GnomeVFSVolume *volume = l->data;

		if (gnome_vfs_volume_is_user_visible (volume) &&
		    gnome_vfs_volume_get_volume_type (volume) == GNOME_VFS_VOLUME_TYPE_CONNECTED_SERVER) {
			gchar *volume_file, *volume_uri;
			gchar *volume_name, *volume_icon;

			volume_file = build_volume_filename (volume);
			volume_uri = gnome_vfs_volume_get_activation_uri (volume);
			volume_name = gnome_vfs_volume_get_display_name (volume);
			volume_icon = gnome_vfs_volume_get_icon (volume);

			add_link (volume_file, volume_uri,
				  volume_name, volume_icon,
				  gnome_vfs_volume_get_id (volume));
			g_free (volume_icon);
			g_free (volume_name);
			g_free (volume_uri);
			g_free (volume_file);
		}
	}
	g_list_foreach (volumes, (GFunc) gnome_vfs_volume_unref, NULL);
	g_list_free (volumes);

	g_signal_connect (monitor, "volume_mounted",
			  G_CALLBACK (volume_mounted), NULL);
	g_signal_connect (monitor, "volume_unmounted",
			  G_CALLBACK (volume_unmounted), NULL);

	return &method;
}


Return to bug 91939

Lines 51-56 Link Here

(-)modules.orig/network-method.c (-8 / +109 lines)
51	char *icon;	51	char *icon;
52	char *target_uri;	52	char *target_uri;
53	char *filename;	53	char *filename;
		54	gint vol_id;
54	} NetworkLink;	55	} NetworkLink;
55		56
56	typedef struct {	57	typedef struct {
Lines 154-160 Link Here
154	static char *	155	static char *
155	get_data_for_link (const char *uri,	156	get_data_for_link (const char *uri,
156	const char *display_name,	157	const char *display_name,
157	const char *icon)	158	const char *icon,
		159	gint vol_id)
158	{	160	{
159	char *data;	161	char *data;
160		162
Lines 163-172 Link Here
163	"Name=%s\n"	165	"Name=%s\n"
164	"Type=FSDevice\n"	166	"Type=FSDevice\n"
165	"Icon=%s\n"	167	"Icon=%s\n"
166	"URL=%s\n",	168	"URL=%s\n"
		169	"%sX-Gnome-Volume=%d\n",
167	display_name,	170	display_name,
168	icon,	171	icon,
169	uri);	172	uri,
		173	vol_id >= 0 ? "" : "#",
		174	vol_id);
170	return data;	175	return data;
171	}	176	}
172		177
Lines 235-241 Link Here
235	add_link (const char *filename,	240	add_link (const char *filename,
236	const char *target_uri,	241	const char *target_uri,
237	const char *display_name,	242	const char *display_name,
238	const char *icon)	243	const char *icon,
		244	gint vol_id)
239	{	245	{
240	NetworkLink *link;	246	NetworkLink *link;
241		247
Lines 244-249 Link Here
244	link->target_uri = g_strdup (target_uri);	250	link->target_uri = g_strdup (target_uri);
245	link->display_name = g_strdup (display_name);	251	link->display_name = g_strdup (display_name);
246	link->icon = g_strdup (icon);	252	link->icon = g_strdup (icon);
		253	link->vol_id = vol_id;
247		254
248	active_links = g_list_prepend (active_links, link);	255	active_links = g_list_prepend (active_links, link);
249	do_link_event (filename,	256	do_link_event (filename,
Lines 264-270 Link Here
264	add_link (filename,	271	add_link (filename,
265	link_uri,	272	link_uri,
266	domain,	273	domain,
267	"gnome-fs-network");	274	"gnome-fs-network",
		275	-1);
268	g_free (filename);	276	g_free (filename);
269	g_free (link_uri);	277	g_free (link_uri);
270	}	278	}
Lines 356-362 Link Here
356	{	364	{
357	return get_data_for_link (link->target_uri,	365	return get_data_for_link (link->target_uri,
358	link->display_name,	366	link->display_name,
359	link->icon);	367	link->icon,
		368	link->vol_id);
360	}	369	}
361		370
362	/* Call with lock held */	371	/* Call with lock held */
Lines 477-482 Link Here
477		486
478	}	487	}
479		488
		489	/* functions to handle volumes */
		490	static char *
		491	build_volume_filename (GnomeVFSVolume *volume)
		492	{
		493	char name, escaped, *ret;
		494
		495	name = gnome_vfs_volume_get_display_name (volume);
		496	escaped = gnome_vfs_escape_string (name);
		497	ret = g_strconcat ("volume-", escaped, NULL);
		498	g_free(escaped);
		499	g_free(name);
		500
		501	return ret;
		502	}
		503
		504	static void
		505	volume_mounted (GnomeVFSVolumeMonitor *monitor,
		506	GnomeVFSVolume *volume,
		507	gpointer user_data)
		508	{
		509	char volume_file, volume_uri;
		510	char volume_name, volume_icon;
		511
		512	G_LOCK (network);
		513	if (gnome_vfs_volume_is_user_visible (volume) &&
		514	gnome_vfs_volume_get_volume_type (volume) == GNOME_VFS_VOLUME_TYPE_CONNECTED_SERVER) {
		515	volume_file = build_volume_filename (volume);
		516	volume_uri = gnome_vfs_volume_get_activation_uri (volume);
		517	volume_name = gnome_vfs_volume_get_display_name (volume);
		518	volume_icon = gnome_vfs_volume_get_icon (volume);
		519
		520	add_link (volume_file, volume_uri,
		521	volume_name, volume_icon,
		522	gnome_vfs_volume_get_id (volume));
		523	g_free (volume_icon);
		524	g_free (volume_name);
		525	g_free (volume_uri);
		526	g_free (volume_file);
		527	}
		528	G_UNLOCK (network);
		529	}
		530
		531	static void
		532	volume_unmounted (GnomeVFSVolumeMonitor *volume_monitor,
		533	GnomeVFSVolume *volume,
		534	gpointer user_data)
		535	{
		536	char *volume_file;
		537
		538	G_LOCK (network);
		539
		540	volume_file = build_volume_filename (volume);
		541	remove_link (volume_file);
		542	g_free (volume_file);
		543
		544	G_UNLOCK (network);
		545	}
480		546
481	static GnomeVFSResult	547	static GnomeVFSResult
482	do_open (GnomeVFSMethod *method,	548	do_open (GnomeVFSMethod *method,
Lines 1338-1343 Link Here
1338	GConfClient *gconf_client;	1404	GConfClient *gconf_client;
1339	GnomeVFSURI *uri;	1405	GnomeVFSURI *uri;
1340	char workgroup_uri, workgroup_escaped, *setting;	1406	char workgroup_uri, workgroup_escaped, *setting;
		1407	GnomeVFSVolumeMonitor *monitor;
		1408	GList volumes, l;
1341		1409
1342	gconf_client = gconf_client_get_default ();	1410	gconf_client = gconf_client_get_default ();
1343		1411
Lines 1394-1403 Link Here
1394	add_link ("smblink-root",	1462	add_link ("smblink-root",
1395	"smb://",	1463	"smb://",
1396	_("Windows Network"),	1464	_("Windows Network"),
1397	"gnome-fs-network");	1465	"gnome-fs-network",
		1466	-1);
1398	}	1467	}
1399		1468
1400		1469	/* add non-drive volumes to network:/// folder */
		1470	monitor = gnome_vfs_get_volume_monitor ();
		1471	volumes = gnome_vfs_volume_monitor_get_mounted_volumes (monitor);
		1472	for (l = volumes; l != NULL; l = l->next) {
		1473	GnomeVFSVolume *volume = l->data;
		1474
		1475	if (gnome_vfs_volume_is_user_visible (volume) &&
		1476	gnome_vfs_volume_get_volume_type (volume) == GNOME_VFS_VOLUME_TYPE_CONNECTED_SERVER) {
		1477	gchar volume_file, volume_uri;
		1478	gchar volume_name, volume_icon;
		1479
		1480	volume_file = build_volume_filename (volume);
		1481	volume_uri = gnome_vfs_volume_get_activation_uri (volume);
		1482	volume_name = gnome_vfs_volume_get_display_name (volume);
		1483	volume_icon = gnome_vfs_volume_get_icon (volume);
		1484
		1485	add_link (volume_file, volume_uri,
		1486	volume_name, volume_icon,
		1487	gnome_vfs_volume_get_id (volume));
		1488	g_free (volume_icon);
		1489	g_free (volume_name);
		1490	g_free (volume_uri);
		1491	g_free (volume_file);
		1492	}
		1493	}
		1494	g_list_foreach (volumes, (GFunc) gnome_vfs_volume_unref, NULL);
		1495	g_list_free (volumes);
		1496
		1497	g_signal_connect (monitor, "volume_mounted",
		1498	G_CALLBACK (volume_mounted), NULL);
		1499	g_signal_connect (monitor, "volume_unmounted",
		1500	G_CALLBACK (volume_unmounted), NULL);
		1501
1401	return &method;	1502	return &method;
1402	}	1503	}
1403		1504

Lines 260-271 Link Here

(-)modules.orig/computer-method.c (-1 / +6 lines)
260	if (gnome_vfs_volume_is_user_visible (volume)) {	260	if (gnome_vfs_volume_is_user_visible (volume)) {
261	drive = gnome_vfs_volume_get_drive (volume);	261	drive = gnome_vfs_volume_get_drive (volume);
262	if (drive == NULL) {	262	if (drive == NULL) {
		263	if (gnome_vfs_volume_get_volume_type (volume) != GNOME_VFS_VOLUME_TYPE_CONNECTED_SERVER) {
263	file = computer_file_new (COMPUTER_VOLUME);	264	file = computer_file_new (COMPUTER_VOLUME);
264	name = gnome_vfs_volume_get_display_name (volume);	265	name = gnome_vfs_volume_get_display_name (volume);
265	file->file_name = build_file_name (name, ".volume");	266	file->file_name = build_file_name (name, ".volume");
266	g_free (name);	267	g_free (name);
267	file->volume = gnome_vfs_volume_ref (volume);	268	file->volume = gnome_vfs_volume_ref (volume);
268	computer_file_add (dir, file);	269	computer_file_add (dir, file);
		270	}
269	} else {	271	} else {
270	file = get_drive_file (dir, drive);	272	file = get_drive_file (dir, drive);
271	if (file != NULL) {	273	if (file != NULL) {
Lines 360-369 Link Here
360	file->file_name = g_strdup ("Filesystem.desktop");	362	file->file_name = g_strdup ("Filesystem.desktop");
361	computer_file_add (dir, file);	363	computer_file_add (dir, file);
362		364
		365	/*
363	file = computer_file_new (COMPUTER_NETWORK_LINK);	366	file = computer_file_new (COMPUTER_NETWORK_LINK);
364	file->file_name = g_strdup ("Network.desktop");	367	file->file_name = g_strdup ("Network.desktop");
365	computer_file_add (dir, file);	368	computer_file_add (dir, file);
366		369	*/
367	volumes = gnome_vfs_volume_monitor_get_mounted_volumes (monitor);	370	volumes = gnome_vfs_volume_monitor_get_mounted_volumes (monitor);
368	drives = gnome_vfs_volume_monitor_get_connected_drives (monitor);	371	drives = gnome_vfs_volume_monitor_get_connected_drives (monitor);
369		372
Lines 384-395 Link Here
384	if (gnome_vfs_volume_is_user_visible (volume)) {	387	if (gnome_vfs_volume_is_user_visible (volume)) {
385	drive = gnome_vfs_volume_get_drive (volume);	388	drive = gnome_vfs_volume_get_drive (volume);
386	if (drive == NULL) {	389	if (drive == NULL) {
		390	if (gnome_vfs_volume_get_volume_type (volume) != GNOME_VFS_VOLUME_TYPE_CONNECTED_SERVER) {
387	file = computer_file_new (COMPUTER_VOLUME);	391	file = computer_file_new (COMPUTER_VOLUME);
388	name = gnome_vfs_volume_get_display_name (volume);	392	name = gnome_vfs_volume_get_display_name (volume);
389	file->file_name = build_file_name (name, ".volume");	393	file->file_name = build_file_name (name, ".volume");
390	g_free (name);	394	g_free (name);
391	file->volume = gnome_vfs_volume_ref (volume);	395	file->volume = gnome_vfs_volume_ref (volume);
392	computer_file_add (dir, file);	396	computer_file_add (dir, file);
		397	}
393	}	398	}
394	gnome_vfs_drive_unref (drive);	399	gnome_vfs_drive_unref (drive);
395	}	400	}