diff --git a/nautilus-selinux.patch b/nautilus-selinux.patch
new file mode 100644
index 0000000..7888c75
--- /dev/null
+++ b/nautilus-selinux.patch
@@ -0,0 +1,1749 @@
+diff -up nautilus-2.90.1/libnautilus-extension/nautilus-column.c.selinux nautilus-2.90.1/libnautilus-extension/nautilus-column.c
+--- nautilus-2.90.1/libnautilus-extension/nautilus-column.c.selinux	2009-04-17 09:12:30.000000000 -0400
++++ nautilus-2.90.1/libnautilus-extension/nautilus-column.c	2010-08-24 11:17:28.104547004 -0400
+@@ -34,6 +34,7 @@ enum {
+ 	PROP_LABEL,
+ 	PROP_DESCRIPTION,
+ 	PROP_XALIGN,
++	PROP_ELLIPSIZE,
+ 	LAST_PROP
+ };
+ 
+@@ -43,6 +44,7 @@ struct _NautilusColumnDetails {
+ 	char *label;
+ 	char *description;
+ 	float xalign;
++	gboolean ellipsize;
+ };
+ 
+ G_DEFINE_TYPE (NautilusColumn, nautilus_column, G_TYPE_OBJECT);
+@@ -110,6 +112,9 @@ nautilus_column_get_property (GObject *o
+ 	case PROP_XALIGN :
+ 		g_value_set_float (value, column->details->xalign);
+ 		break;
++	case PROP_ELLIPSIZE :
++		g_value_set_boolean (value, column->details->ellipsize);
++		break;
+ 	default :
+ 		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+ 		break;
+@@ -151,6 +156,10 @@ nautilus_column_set_property (GObject *o
+ 		column->details->xalign = g_value_get_float (value);
+ 		g_object_notify (object, "xalign");		
+ 		break;
++	case PROP_ELLIPSIZE :
++		column->details->ellipsize = g_value_get_boolean (value);
++		g_object_notify (object, "ellipsize");		
++		break;
+ 	default :
+ 		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+ 		break;
+@@ -178,6 +187,7 @@ nautilus_column_init (NautilusColumn *co
+ {
+ 	column->details = g_new0 (NautilusColumnDetails, 1);
+ 	column->details->xalign = 0.0;
++	column->details->ellipsize = FALSE;
+ }
+ 
+ static void
+@@ -232,5 +242,12 @@ nautilus_column_class_init (NautilusColu
+ 							     1.0,
+ 							     0.0,
+ 							     G_PARAM_READWRITE));
++	g_object_class_install_property (G_OBJECT_CLASS (class),
++					 PROP_ELLIPSIZE,
++					 g_param_spec_boolean ("ellipsize",
++							       "ellipsize",
++							       "Ellipsize text in the column if it's too long to display",
++							       FALSE,
++							       G_PARAM_READWRITE));
+ }
+ 
+diff -up nautilus-2.90.1/libnautilus-extension/nautilus-column.h.selinux nautilus-2.90.1/libnautilus-extension/nautilus-column.h
+--- nautilus-2.90.1/libnautilus-extension/nautilus-column.h.selinux	2009-04-17 09:12:30.000000000 -0400
++++ nautilus-2.90.1/libnautilus-extension/nautilus-column.h	2010-08-24 11:17:28.105547004 -0400
+@@ -64,6 +64,7 @@ NautilusColumn *  nautilus_column_new   
+  *   label (string)       - the user-visible label for the column
+  *   description (string) - a user-visible description of the column
+  *   xalign (float)       - x-alignment of the column 
++ *   ellipsize (boolean)  - ellipsize text in the column?
+  */
+ 
+ G_END_DECLS
+diff -up nautilus-2.90.1/libnautilus-private/nautilus-column-utilities.c.selinux nautilus-2.90.1/libnautilus-private/nautilus-column-utilities.c
+--- nautilus-2.90.1/libnautilus-private/nautilus-column-utilities.c.selinux	2010-08-12 06:20:55.000000000 -0400
++++ nautilus-2.90.1/libnautilus-private/nautilus-column-utilities.c	2010-08-24 11:17:28.106547004 -0400
+@@ -119,6 +119,7 @@ get_builtin_columns (void)
+ 					       "attribute", "selinux_context",
+ 					       "label", _("SELinux Context"),
+ 					       "description", _("The SELinux security context of the file."),
++					       "ellipsize", TRUE,
+ 					       NULL));
+ 	columns = g_list_append (columns,
+ 				 g_object_new (NAUTILUS_TYPE_COLUMN,
+diff -up nautilus-2.90.1/libnautilus-private/nautilus-file.c.selinux nautilus-2.90.1/libnautilus-private/nautilus-file.c
+--- nautilus-2.90.1/libnautilus-private/nautilus-file.c.selinux	2010-08-14 07:11:15.000000000 -0400
++++ nautilus-2.90.1/libnautilus-private/nautilus-file.c	2010-08-24 11:17:28.112547004 -0400
+@@ -2171,7 +2171,7 @@ update_info_internal (NautilusFile *file
+ 	file->details->is_mountpoint = is_mountpoint;
+ 
+ 	has_permissions = g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_UNIX_MODE);
+-	permissions = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE);;
++	permissions = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE);
+ 	if (file->details->has_permissions != has_permissions ||
+ 	    file->details->permissions != permissions) {
+ 		changed = TRUE;
+@@ -5076,7 +5076,7 @@ nautilus_file_can_get_selinux_context (N
+  * context
+  * @file: NautilusFile representing the file in question.
+  * 
+- * Returns: Newly allocated string ready to display to the user.
++ * Returns: Newly allocated string ready to display to the user, or NULL.
+  * 
+  **/
+ char *
+@@ -5109,6 +5109,114 @@ nautilus_file_get_selinux_context (Nauti
+ 	return translated;
+ }
+ 
++/**
++ * nautilus_file_get_selinux_matchpathcon:
++ * 
++ * Get a user-displayable string representing a file's default selinux
++ * context (as from matchpathcon). Only works on local files.
++ * @file: NautilusFile representing the file in question.
++ * 
++ * Returns: Newly allocated string ready to display to the user, or NULL.
++ * 
++ **/
++char *
++nautilus_file_get_selinux_matchpathcon (NautilusFile *file)
++{
++	char *translated;
++#ifdef HAVE_SELINUX
++	char *raw;
++	char *fname;
++	GFile *location;
++#endif
++	
++	g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
++
++	translated = NULL;
++#ifdef HAVE_SELINUX
++	location = nautilus_file_get_location (file);
++	fname = g_file_get_path (location);
++	
++	if (!fname) {
++	        return NULL;
++	}
++
++	raw = NULL;
++	if (matchpathcon (fname, file->details->permissions, &raw) == 0) {
++		if (selinux_raw_to_trans_context (raw, &translated) == 0) {
++			char *tmp;
++			tmp = g_strdup (translated);
++			freecon (translated);
++			translated = tmp;
++		}
++		freecon (raw);
++	}
++		      
++	g_free (fname);
++	g_object_unref (location);
++#endif
++	
++	return translated;
++}
++
++void
++nautilus_file_set_selinux_context (NautilusFile *file, 
++				   const char *selinux_context,
++				   NautilusFileOperationCallback callback,
++				   gpointer callback_data)
++{
++	GFileInfo *info;
++	GError *error;
++	char *rcontext;
++
++	rcontext = NULL;
++	
++	/* this is probably mostly right... */
++	if (!nautilus_file_can_set_permissions (file)) {
++		/* Claim that something changed even if the permission change failed.
++		 * This makes it easier for some clients who see the "reverting"
++		 * to the old permissions as "changing back".
++		 */
++		nautilus_file_changed (file);
++		error = g_error_new (G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
++				     _("Not allowed to set SELinux security context"));
++		(* callback) (file, NULL, error, callback_data);
++		g_error_free (error);
++		return;
++	}
++			       
++	/* Test the permissions-haven't-changed case explicitly
++	 * because we don't want to send the file-changed signal if
++	 * nothing changed.
++	 */
++	if (file->details->selinux_context != NULL &&
++	    strcmp(selinux_context, file->details->selinux_context) == 0) {
++		(* callback) (file, NULL, NULL, callback_data);
++		return;
++	}
++
++#ifdef HAVE_SELINUX
++	/* this is really const, but prototype is wrong, *sigh* */
++	if (selinux_trans_to_raw_context((char *)selinux_context, &rcontext)) {
++		error = g_error_new (G_IO_ERROR, G_IO_ERROR_INVAL,
++				     _("Invalid SELinux security context"));
++		(* callback) (file, NULL, error, callback_data);
++		g_error_free (error);
++		return;
++	}
++	selinux_context = rcontext;
++#endif
++			       
++	info = g_file_info_new ();
++	g_file_info_set_attribute_string (info, G_FILE_ATTRIBUTE_SELINUX_CONTEXT, selinux_context);
++	nautilus_file_set_attributes (file, info, callback, callback_data);
++	g_object_unref (info);
++
++#ifdef HAVE_SELINUX
++	freecon (rcontext);
++#endif
++}
++
++
+ static char *
+ get_real_name (const char *name, const char *gecos)
+ {
+diff -up nautilus-2.90.1/libnautilus-private/nautilus-file.h.selinux nautilus-2.90.1/libnautilus-private/nautilus-file.h
+--- nautilus-2.90.1/libnautilus-private/nautilus-file.h.selinux	2010-08-14 07:11:15.000000000 -0400
++++ nautilus-2.90.1/libnautilus-private/nautilus-file.h	2010-08-24 11:17:28.119547004 -0400
+@@ -245,6 +245,7 @@ GList *                 nautilus_get_all
+ GList *                 nautilus_file_get_settable_group_names          (NautilusFile                   *file);
+ gboolean                nautilus_file_can_get_selinux_context           (NautilusFile                   *file);
+ char *                  nautilus_file_get_selinux_context               (NautilusFile                   *file);
++char *                  nautilus_file_get_selinux_matchpathcon          (NautilusFile                   *file);
+ 
+ /* "Capabilities". */
+ gboolean                nautilus_file_can_read                          (NautilusFile                   *file);
+@@ -305,6 +306,10 @@ void                    nautilus_file_se
+ 									 guint32                         permissions,
+ 									 NautilusFileOperationCallback   callback,
+ 									 gpointer                        callback_data);
++void                    nautilus_file_set_selinux_context               (NautilusFile *file, 
++									 const char *selinux_context,
++									 NautilusFileOperationCallback callback,
++									 gpointer callback_data);
+ void                    nautilus_file_rename                            (NautilusFile                   *file,
+ 									 const char                     *new_name,
+ 									 NautilusFileOperationCallback   callback,
+diff -up nautilus-2.90.1/libnautilus-private/nautilus-file-operations.c.selinux nautilus-2.90.1/libnautilus-private/nautilus-file-operations.c
+--- nautilus-2.90.1/libnautilus-private/nautilus-file-operations.c.selinux	2010-08-22 09:15:27.000000000 -0400
++++ nautilus-2.90.1/libnautilus-private/nautilus-file-operations.c	2010-08-24 11:18:17.976547003 -0400
+@@ -66,6 +66,10 @@
+ #include "nautilus-file-utilities.h"
+ #include "nautilus-file-conflict-dialog.h"
+ 
++#ifdef HAVE_SELINUX
++    #include <selinux/selinux.h>
++#endif
++
+ /* TODO: TESTING!!! */
+ 
+ typedef struct {
+@@ -148,6 +152,7 @@ typedef struct {
+ 	guint32 file_mask;
+ 	guint32 dir_permissions;
+ 	guint32 dir_mask;
++	char *context;
+ } SetPermissionsJob;
+ 
+ typedef enum {
+@@ -5408,6 +5413,10 @@ set_permissions_job_done (gpointer user_
+ 		job->done_callback (job->done_callback_data);
+ 	}
+ 	
++	if (job->context) {
++		g_free (job->context);
++	}
++	
+ 	finalize_common ((CommonJob *)job);
+ 	return FALSE;
+ }
+@@ -5463,6 +5472,14 @@ set_permissions_file (SetPermissionsJob 
+ 					     current, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
+ 					     common->cancellable, NULL);
+ 	}
++
++#ifdef HAVE_SELINUX
++	if (!job_aborted (common) && (job->context)) {
++		g_file_set_attribute_string (file, G_FILE_ATTRIBUTE_SELINUX_CONTEXT, 
++					     job->context, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
++					     common->cancellable, NULL);
++	}
++#endif
+ 	
+ 	if (!job_aborted (common) &&
+ 	    g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY) {
+@@ -5526,6 +5543,7 @@ nautilus_file_set_permissions_recursive 
+ 					 guint32         file_mask,
+ 					 guint32         dir_permissions,
+ 					 guint32         dir_mask,
++					 const char     *context, 
+ 					 NautilusOpCallback  callback,
+ 					 gpointer  callback_data)
+ {
+@@ -5539,7 +5557,24 @@ nautilus_file_set_permissions_recursive 
+ 	job->dir_mask = dir_mask;
+ 	job->done_callback = callback;
+ 	job->done_callback_data = callback_data;
+-	
++
++	if (context) {
++		char *rcontext;
++
++		rcontext = job->context = NULL;
++#ifdef HAVE_SELINUX
++		/* this is really const, but prototype is wrong, *sigh* */
++		if (selinux_trans_to_raw_context((char *)context, &rcontext)) {
++			g_error ("selinux_trans_to_raw_context: failed to allocate bytes");
++			return;
++		}
++		job->context = g_strdup (rcontext);
++		freecon (rcontext);
++#endif
++	} else {
++		job->context = NULL;
++	}
++
+ 	g_io_scheduler_push_job (set_permissions_job,
+ 			   job,
+ 			   NULL,
+diff -up nautilus-2.90.1/libnautilus-private/nautilus-file-operations.h.selinux nautilus-2.90.1/libnautilus-private/nautilus-file-operations.h
+--- nautilus-2.90.1/libnautilus-private/nautilus-file-operations.h.selinux	2010-08-02 19:35:56.000000000 -0400
++++ nautilus-2.90.1/libnautilus-private/nautilus-file-operations.h	2010-08-24 11:17:28.127547004 -0400
+@@ -87,6 +87,7 @@ void nautilus_file_set_permissions_recur
+ 					      guint32                         file_mask,
+ 					      guint32                         folder_permissions,
+ 					      guint32                         folder_mask,
++					      const char                     *context,
+ 					      NautilusOpCallback              callback,
+ 					      gpointer                        callback_data);
+ 
+diff -up nautilus-2.90.1/src/file-manager/fm-error-reporting.c.selinux nautilus-2.90.1/src/file-manager/fm-error-reporting.c
+--- nautilus-2.90.1/src/file-manager/fm-error-reporting.c.selinux	2009-04-17 09:12:31.000000000 -0400
++++ nautilus-2.90.1/src/file-manager/fm-error-reporting.c	2010-08-24 11:17:28.129547004 -0400
+@@ -238,6 +238,31 @@ fm_report_error_setting_permissions (Nau
+ 	g_free (message);
+ }		
+ 
++void
++fm_report_error_setting_selinux (NautilusFile *file,
++		       	         GError *error,
++		       	         GtkWindow *parent_window)
++{
++	char *file_name;
++	char *message;
++
++	if (error == NULL) {
++		return;
++	}
++
++	file_name = nautilus_file_get_display_name (file);
++
++	message = g_strdup_printf (_("Sorry, couldn't change the permissions of \"%s\": %s"), file_name, error->message);
++
++	/*  Silently drop the error when called from selinux entry and is not finished yet */
++	if (! g_error_matches(error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT)) {
++		eel_show_error_dialog (_("The SELinux security context could not be changed."), message, parent_window);
++	}
++
++	g_free (file_name);
++	g_free (message);
++}
++
+ typedef struct _FMRenameData {
+ 	char *name;
+ 	NautilusFileOperationCallback callback;
+diff -up nautilus-2.90.1/src/file-manager/fm-error-reporting.h.selinux nautilus-2.90.1/src/file-manager/fm-error-reporting.h
+--- nautilus-2.90.1/src/file-manager/fm-error-reporting.h.selinux	2009-04-17 09:12:31.000000000 -0400
++++ nautilus-2.90.1/src/file-manager/fm-error-reporting.h	2010-08-24 11:17:28.130547004 -0400
+@@ -40,8 +40,11 @@ void fm_report_error_setting_permissions
+ 					  GError         *error,
+ 					  GtkWindow	 *parent_window);
+ void fm_report_error_setting_owner       (NautilusFile   *file,
+-					  GError         *error,  
++					  GError         *error,
+ 					  GtkWindow	 *parent_window);
++void fm_report_error_setting_selinux     (NautilusFile   *file,
++					  GError         *error,
++                                          GtkWindow      *parent_window);
+ void fm_report_error_setting_group       (NautilusFile   *file,
+ 					  GError         *error,
+ 					  GtkWindow	 *parent_window);
+diff -up nautilus-2.90.1/src/file-manager/fm-list-view.c.selinux nautilus-2.90.1/src/file-manager/fm-list-view.c
+--- nautilus-2.90.1/src/file-manager/fm-list-view.c.selinux	2010-08-22 09:15:27.000000000 -0400
++++ nautilus-2.90.1/src/file-manager/fm-list-view.c	2010-08-24 11:17:28.133547004 -0400
+@@ -1557,13 +1557,15 @@ create_and_set_up_tree_view (FMListView 
+ 		char *name;
+ 		char *label;
+ 		float xalign;
++		gboolean ellipsize;
+ 
+ 		nautilus_column = NAUTILUS_COLUMN (l->data);
+ 
+ 		g_object_get (nautilus_column, 
+ 			      "name", &name, 
+ 			      "label", &label,
+-			      "xalign", &xalign, NULL);
++			      "xalign", &xalign, 
++			      "ellipsize", &ellipsize, NULL);
+ 
+ 		column_num = fm_list_model_add_column (view->details->model,
+ 						       nautilus_column);
+@@ -1607,6 +1609,8 @@ create_and_set_up_tree_view (FMListView 
+ 		} else {		
+ 			cell = gtk_cell_renderer_text_new ();
+ 			g_object_set (cell, "xalign", xalign, NULL);
++			if (ellipsize)
++			    g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
+ 			view->details->cells = g_list_append (view->details->cells,
+ 							      cell);
+ 			column = gtk_tree_view_column_new_with_attributes (label,
+diff -up nautilus-2.90.1/src/file-manager/fm-properties-window.c.selinux nautilus-2.90.1/src/file-manager/fm-properties-window.c
+--- nautilus-2.90.1/src/file-manager/fm-properties-window.c.selinux	2010-08-14 07:11:15.000000000 -0400
++++ nautilus-2.90.1/src/file-manager/fm-properties-window.c	2010-08-24 11:17:28.139547004 -0400
+@@ -76,6 +76,10 @@
+ #define FREE_FILL_B  (0.811764706 * 65535)
+ 
+ 
++#ifdef HAVE_SELINUX
++# include <selinux/selinux.h>
++#endif
++
+ #define PREVIEW_IMAGE_WIDTH 96
+ 
+ #define ROW_PAD 6
+@@ -115,12 +119,15 @@ struct FMPropertiesWindowDetails {	
+ 	unsigned int  owner_change_timeout;
+ 
+ 	GList *permission_buttons;
+-	GList *permission_combos;
++	GList *permission_combos; /* how is this deallocated???? */
++	GList *selinux_combo;
+ 	GHashTable *initial_permissions;
+ 	gboolean has_recursive_apply;
+ 
+ 	GList *value_fields;
+ 
++	GList *edit_fields;
++
+ 	GList *mime_list;
+ 
+ 	gboolean deep_count_finished;
+@@ -203,6 +210,10 @@ static void permission_combo_update     
+ 						   GtkComboBox        *combo);
+ static void value_field_update                    (FMPropertiesWindow *window,
+ 						   GtkLabel           *field);
++static void edit_field_update                     (FMPropertiesWindow *window,
++						   GtkEntry           *field);
++static void popup_field_update                    (FMPropertiesWindow *window,
++						   GtkComboBox        *entry);
+ static void properties_window_update              (FMPropertiesWindow *window,
+ 						   GList              *files);
+ static void is_directory_ready_callback           (NautilusFile       *file,
+@@ -232,10 +243,36 @@ static GtkLabel *attach_ellipsizing_valu
+ 						   const char *initial_text);
+ 						   
+ static GtkWidget* create_pie_widget 		  (FMPropertiesWindow *window);
++  
++static void attach_selinux_data_edit_field        (GtkEntry *entry, 
++                                                   char *attr_value, 
++                                                   char *def_attr_value); 
++ 
++#ifdef HAVE_SELINUX 
++static void attach_selinux_data_popup_field       (GtkComboBox *comb, 
++                                                   char *attr_val, 
++                                                   char *def_attr_val); 
++#endif 
++
+ 
+ G_DEFINE_TYPE (FMPropertiesWindow, fm_properties_window, GTK_TYPE_DIALOG);
+ #define parent_class fm_properties_window_parent_class 
+ 
++static void
++maybe_gtk_entry_set_text (GtkEntry *entry, const char *val)
++{
++	char *old_val;
++
++	g_assert (GTK_IS_ENTRY (entry));
++
++	old_val = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
++
++	if (strcmp (old_val, val) != 0) {
++		gtk_entry_set_text (entry, val);
++	}
++	g_free(old_val);
++}
++
+ static gboolean
+ is_multi_file_window (FMPropertiesWindow *window)
+ {
+@@ -256,6 +293,111 @@ is_multi_file_window (FMPropertiesWindow
+ 	return FALSE;
+ }
+ 
++static gboolean
++all_can_get_permissions (GList *file_list)
++{
++	GList *l;
++	for (l = file_list; l != NULL; l = l->next) {
++		NautilusFile *file;
++		
++		file = NAUTILUS_FILE (l->data);
++		
++		if (!nautilus_file_can_get_permissions (file)) {
++			return FALSE;
++		}
++	}
++
++	return TRUE;
++}
++
++static gboolean
++all_can_set_permissions (GList *file_list)
++{
++	GList *l;
++	for (l = file_list; l != NULL; l = l->next) {
++		NautilusFile *file;
++		
++		file = NAUTILUS_FILE (l->data);
++
++		if (!nautilus_file_can_set_permissions (file)) {
++			return FALSE;
++		}
++	}
++
++	return TRUE;
++}
++
++#ifdef HAVE_SELINUX
++static gboolean
++multi_have_same_selinux_context (FMPropertiesWindow *window)
++{
++	GList *l;
++        char *cntx;
++
++	cntx = NULL;
++	for (l = window->details->original_files; l != NULL; l = l->next) {
++		NautilusFile *file;
++
++		file = NAUTILUS_FILE (l->data);
++		if (!nautilus_file_is_gone (file)) {
++		        char *tmp;
++
++			tmp = nautilus_file_get_string_attribute_with_default (file, "selinux_context");
++		        if (!cntx) {
++			         cntx = tmp;
++			} else if (strcmp (cntx, tmp)) {
++				 g_free (tmp);
++				 g_free (cntx);
++				 return FALSE;
++			}
++			else {
++			         g_free (tmp);
++			}
++		}
++	}
++
++	g_free (cntx);
++	
++	return TRUE;
++}
++#endif
++
++/* NOTE: This modifies cntx */
++static void
++selinux_split_cntx (char *cntx,
++		    const char **ret_attr_u,
++		    const char **ret_attr_r,
++		    const char **ret_attr_t,
++		    const char **ret_attr_s)
++{
++	const char *attr_u;
++	const char *attr_r;
++	const char *attr_t;
++	const char *attr_s;
++
++	attr_u = cntx;
++	if (!(attr_r = strchr (attr_u, ':'))) {
++	        attr_r = "object_r"; /* shouldn't happen */
++	} else {
++	        *((char *)attr_r++) = 0;
++	}
++	
++	if (!(attr_t = strchr (attr_r, ':'))) {
++	        attr_t = "file_t"; /* shouldn't happen */
++	} else {
++	        *((char *)attr_t++) = 0;
++	}
++
++	if ((attr_s = strchr (attr_t, ':'))) {
++	        *((char *)attr_s++) = 0;
++	}
++
++	*ret_attr_u = attr_u;
++	*ret_attr_r = attr_r;
++	*ret_attr_t = attr_t;
++	*ret_attr_s = attr_s;
++}
++
+ static int
+ get_not_gone_original_file_count (FMPropertiesWindow *window)
+ {
+@@ -631,11 +773,7 @@ set_name_field (FMPropertiesWindow *wind
+ 			 * currently showing. This causes minimal ripples (e.g.
+ 			 * selection change).
+ 			 */
+-			gchar *displayed_name = gtk_editable_get_chars (GTK_EDITABLE (window->details->name_field), 0, -1);
+-			if (strcmp (displayed_name, name) != 0) {
+-				gtk_entry_set_text (GTK_ENTRY (window->details->name_field), name);
+-			}
+-			g_free (displayed_name);
++		        maybe_gtk_entry_set_text (GTK_ENTRY (window->details->name_field), name);
+ 		}
+ 	}
+ }
+@@ -715,7 +853,6 @@ static void
+ name_field_restore_original_name (NautilusEntry *name_field)
+ {
+ 	const char *original_name;
+-	char *displayed_name;
+ 
+ 	original_name = (const char *) g_object_get_data (G_OBJECT (name_field),
+ 							  "original_name");
+@@ -724,14 +861,8 @@ name_field_restore_original_name (Nautil
+ 		return;
+ 	}
+ 
+-	displayed_name = gtk_editable_get_chars (GTK_EDITABLE (name_field), 0, -1);
+-
+-	if (strcmp (original_name, displayed_name) != 0) {
+-		gtk_entry_set_text (GTK_ENTRY (name_field), original_name);
+-	}
++	maybe_gtk_entry_set_text (GTK_ENTRY (name_field), original_name);
+ 	nautilus_entry_select_all (name_field);
+-
+-	g_free (displayed_name);
+ }
+ 
+ static void
+@@ -1027,6 +1158,14 @@ properties_window_update (FMPropertiesWi
+ 		for (l = window->details->value_fields; l != NULL; l = l->next) {
+ 			value_field_update (window, GTK_LABEL (l->data));
+ 		}
++		
++		for (l = window->details->edit_fields; l != NULL; l = l->next) {
++			edit_field_update (window, GTK_ENTRY (l->data));
++		}
++		
++		for (l = window->details->selinux_combo; l != NULL; l = l->next) {
++			popup_field_update (window, GTK_COMBO_BOX (l->data));
++		}		
+ 	}
+ 
+ 	mime_list = get_mime_list (window);
+@@ -1197,6 +1336,164 @@ value_field_update (FMPropertiesWindow *
+ 				      window->details->target_files));
+ }
+ 
++static void
++edit_field_update_internal (GtkEntry *entry, 
++			    GList *file_list)
++{
++	const char *attr_name;
++	char *attr_value;
++	char *def_attr_value;
++	char *inconsistent_string;
++	gboolean sensitive;
++	
++	g_assert (GTK_IS_ENTRY (entry));
++
++	attr_name = g_object_get_data (G_OBJECT (entry), "file_attribute");
++	inconsistent_string = g_object_get_data (G_OBJECT (entry),
++						 "inconsistent_string");
++	def_attr_value = g_object_get_data (G_OBJECT (entry),
++					    "matchpathcon_cntx");
++	
++	attr_value = file_list_get_string_attribute (file_list, attr_name,
++						     inconsistent_string);
++
++	maybe_gtk_entry_set_text (GTK_ENTRY (entry), attr_value);
++
++	/* JFIXME: this isn't generic, *sigh* ... */
++	attach_selinux_data_edit_field (entry, attr_value, def_attr_value);
++	g_free (attr_value);
++	
++	sensitive = all_can_set_permissions (file_list);
++#ifdef HAVE_SELINUX
++	sensitive = sensitive && is_selinux_enabled ();
++#endif
++	gtk_widget_set_sensitive (GTK_WIDGET (entry), sensitive);
++}
++
++static void
++edit_field_update (FMPropertiesWindow *window, GtkEntry *entry)
++{
++	gboolean use_original;	
++
++	if (gtk_widget_is_focus (GTK_WIDGET (entry))) {
++	        return;
++	}
++	
++	use_original = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (entry), "show_original"));
++
++	edit_field_update_internal (entry, 
++				    (use_original ?
++				     window->details->original_files : 
++				     window->details->target_files));
++}
++
++static void
++selinux_combo_update_value (GtkComboBox *combo, const char *new_value)
++{
++    GtkTreeModel *model;
++    GtkTreeIter iter;
++    char *cntx_type;
++    gulong handler;
++
++    g_assert (GTK_IS_COMBO_BOX (combo));
++    if (! new_value)
++	return;
++
++    model = gtk_combo_box_get_model (combo);
++    if (! gtk_tree_model_get_iter_first (model, &iter))
++    	return;
++
++    handler = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (combo), "handler_changed"));
++    g_signal_handler_block (G_OBJECT (combo), handler);
++
++    do {
++    	gtk_tree_model_get (model, &iter, 0, &cntx_type, -1);
++    	
++    	if (cntx_type && (g_ascii_strcasecmp (new_value, cntx_type) == 0)) {
++    	    gtk_combo_box_set_active_iter (combo, &iter);
++    	    break;
++    	}
++    }
++    while (gtk_tree_model_iter_next (model, &iter));
++    g_signal_handler_unblock (G_OBJECT (combo), handler);
++}
++
++static void
++popup_field_update_internal (GtkComboBox *combo,
++			     GList *file_list)
++{
++	const char *attr_name;
++	char *attr_value;
++	char *def_attr_value;
++	char *inconsistent_string;
++	char *cntx_type;
++	const char *attr_u;
++	const char *attr_r;
++	const char *attr_t;
++	const char *attr_s;
++	gboolean sensitive;
++	GtkTreeIter iter;
++
++
++	g_assert (GTK_IS_COMBO_BOX (combo));
++
++	if (gtk_widget_is_focus (GTK_WIDGET (combo))) {
++	        return;
++	}
++
++	
++	sensitive = all_can_set_permissions (file_list);
++#ifdef HAVE_SELINUX
++	sensitive = sensitive && is_selinux_enabled ();
++#endif
++	gtk_widget_set_sensitive (GTK_WIDGET (combo), sensitive);
++
++	
++	attr_name = g_object_get_data (G_OBJECT (combo), "file_attribute");
++	inconsistent_string = g_object_get_data (G_OBJECT (combo),
++						 "inconsistent_string");
++	def_attr_value = g_object_get_data (G_OBJECT (combo),
++					    "matchpathcon_cntx");
++	
++	attr_value = file_list_get_string_attribute (file_list, attr_name,
++						     inconsistent_string);
++
++	selinux_split_cntx (attr_value, &attr_u, &attr_r, &attr_t, &attr_s);
++	
++	/* JFIXME: this isn't generic, *sigh* ... */
++	if (gtk_combo_box_get_active_iter (combo, &iter)) {
++		GtkTreeModel *model = gtk_combo_box_get_model (combo);
++
++		/* don't update, if it's identical */
++		gtk_tree_model_get (model, &iter, 0, &cntx_type, -1);
++		if (cntx_type && strcmp (cntx_type, attr_t) == 0) {
++			g_free (attr_value);
++			return;
++		}
++	}
++
++	selinux_combo_update_value (combo, attr_t);
++	
++	g_free (attr_value);
++}
++
++static void
++popup_field_update (FMPropertiesWindow *window, GtkComboBox *combo)
++{
++	gboolean use_original;
++
++	if (! window->details->selinux_combo) {
++	        return;
++	}
++	
++	use_original = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (combo), "show_original"));
++
++	popup_field_update_internal (combo,
++				     (use_original ?
++				      window->details->original_files : 
++				      window->details->target_files));
++}
++
+ static GtkLabel *
+ attach_label (GtkTable *table,
+ 	      int row,
+@@ -1251,6 +1548,47 @@ attach_value_label (GtkTable *table,
+ 	return attach_label (table, row, column, initial_text, FALSE, FALSE, FALSE, TRUE, FALSE);
+ }
+ 
++#ifdef HAVE_SELINUX
++static GtkEntry *
++attach_edit (GtkTable *table,
++	     int row,
++	     int column,
++	     const char *initial_text,
++	     gboolean right_aligned,
++	     gboolean bold,
++	     gboolean ellipsize_text,
++	     gboolean selectable,
++	     gboolean mnemonic)
++{
++	GtkWidget *entry_field;
++
++	entry_field = nautilus_entry_new ();
++	gtk_entry_set_text (GTK_ENTRY (entry_field), initial_text);
++
++	gtk_entry_set_alignment (GTK_ENTRY (entry_field), right_aligned ? 1 : 0);
++	gtk_widget_show (entry_field);
++	gtk_table_attach (table, entry_field,
++			  column, column + 1,
++			  row, row + 1,
++			  ellipsize_text
++			    ? GTK_FILL | GTK_EXPAND
++			    : GTK_FILL,
++			  0,
++			  0, 0);
++
++	return GTK_ENTRY (entry_field);
++}	      
++
++static GtkEntry *
++attach_edit_label (GtkTable *table,
++		   int row,
++		   int column,
++		   const char *initial_text)
++{
++	return attach_edit (table, row, column, initial_text, FALSE, FALSE, FALSE, TRUE, FALSE);
++}
++#endif
++
+ static GtkLabel *
+ attach_ellipsizing_value_label (GtkTable *table,
+ 				int row,
+@@ -1309,6 +1647,647 @@ attach_value_field (FMPropertiesWindow *
+ 				     FALSE);
+ }
+ 
++static void
++start_long_operation (FMPropertiesWindow *window)
++{
++	if (window->details->long_operation_underway == 0) {
++		/* start long operation */
++		GdkCursor * cursor;
++		
++		cursor = gdk_cursor_new (GDK_WATCH);
++		gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (window)), cursor);
++		gdk_cursor_unref (cursor);
++	}
++	window->details->long_operation_underway ++;
++}
++
++static void
++end_long_operation (FMPropertiesWindow *window)
++{
++	if (gtk_widget_get_window (GTK_WIDGET (window)) != NULL &&
++	    window->details->long_operation_underway == 1) {
++		/* finished !! */
++		gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (window)), NULL);
++	}
++	window->details->long_operation_underway--;
++}
++
++#ifdef HAVE_SELINUX
++static void
++selinux_change_callback (NautilusFile *file,
++	       GFile         *result_location,
++	       GError        *error,
++	       gpointer       callback_data)
++{
++	FMPropertiesWindow *window;
++	g_assert (callback_data != NULL);
++
++	window = FM_PROPERTIES_WINDOW (callback_data);
++	end_long_operation (window);
++	
++	/* Report the error if it's an error. */
++	fm_report_error_setting_selinux (file, error, NULL);
++
++	g_object_unref (window);
++}
++
++static void
++selinux_done_editing (FMPropertiesWindow *window, char *selinux_context)
++{
++	GList *l;
++	
++	/* Accept changes. */
++	for (l = window->details->target_files; l != NULL; l = l->next) {
++		NautilusFile *file;
++
++		file = NAUTILUS_FILE (l->data);
++
++		start_long_operation (window);
++		g_object_ref (window);
++		nautilus_file_set_selinux_context (file, selinux_context,
++						   selinux_change_callback,
++						   window);
++	}
++}
++
++static gboolean
++selinux_focus_out (NautilusEntry *entry, GdkEventFocus *event, gpointer cb_data)
++{
++	g_assert (NAUTILUS_IS_ENTRY (entry));
++	g_assert (FM_IS_PROPERTIES_WINDOW (cb_data));
++
++	if (gtk_widget_get_state (entry)) {	
++		char *tmp;
++		
++		tmp = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
++		selinux_done_editing (FM_PROPERTIES_WINDOW (cb_data), tmp);
++		g_free (tmp);
++	}
++
++	return FALSE;
++}
++
++static void
++selinux_entry_activate (NautilusEntry *entry, gpointer cb_data)
++{
++	char *tmp;
++	
++	g_assert (NAUTILUS_IS_ENTRY (entry));
++	g_assert (FM_IS_PROPERTIES_WINDOW (cb_data));
++
++	tmp = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
++	selinux_done_editing (FM_PROPERTIES_WINDOW (cb_data), tmp);
++	g_free (tmp);
++	
++	nautilus_entry_select_all_at_idle (entry);
++}
++
++static void
++selinux_popup_activate (GtkComboBox *comb, gpointer cb_data)
++{
++	char *cntx_type;
++	char *orig_type;
++	const char *attr_u;
++	const char *attr_r;
++	const char *attr_t;
++	const char *attr_s;
++	char *tmp;
++	GtkTreeIter iter;
++	GtkTreeModel *model;
++	
++	g_assert (GTK_IS_COMBO_BOX (comb));
++	g_assert (FM_IS_PROPERTIES_WINDOW (cb_data));
++
++	if (!gtk_combo_box_get_active_iter (comb, &iter)) {
++	        return;
++	} else {
++		model = gtk_combo_box_get_model (comb);
++	        gtk_tree_model_get (model, &iter, 0, &cntx_type, -1);
++	}
++	
++	if (!(orig_type = g_object_get_data (G_OBJECT (comb), "original_cntx"))) {
++	        return;
++	}
++	orig_type = g_strdup (orig_type);
++	
++	selinux_split_cntx (orig_type, &attr_u, &attr_r, &attr_t, &attr_s);
++	tmp = g_strjoin (":", attr_u, attr_r, cntx_type, attr_s, NULL);
++	g_free (orig_type);
++	
++	selinux_done_editing (FM_PROPERTIES_WINDOW (cb_data), tmp);
++	g_free (tmp);
++}
++
++static char *
++cust_type_next_line (GIOChannel *ioc_ctypes)
++{
++	char *data;
++	gsize term;
++	GError *errc;
++
++	data = NULL;
++	term = 0;
++	errc = NULL;
++	
++	if (G_IO_STATUS_NORMAL == g_io_channel_read_line (ioc_ctypes, &data,
++							  NULL, &term, &errc)) {
++	        data[term] = 0;
++		return data;
++	}
++
++	return NULL;
++}
++#endif
++
++static GSList *
++selinux__type_list (void)
++{
++	static GSList *cust_types;
++	GSList *scan;
++#ifdef HAVE_SELINUX
++	static time_t file_mtime;
++	const char *fname_ctypes;
++	struct stat buf;
++	GIOChannel *ioc_ctypes;
++	GError *errc;
++	int fd;
++#endif
++	
++#ifndef HAVE_SELINUX
++	if (cust_types) {
++	        return cust_types;
++	}
++#else
++	fname_ctypes = selinux_customizable_types_path ();
++	if (cust_types && file_mtime && !stat (fname_ctypes, &buf) &&
++	    (file_mtime == buf.st_mtime)) {
++	        return cust_types;
++	}
++#endif
++
++	if (cust_types) {
++	        for (scan = cust_types; scan; scan = scan->next) {
++		        g_free (scan->data);
++		}
++		g_slist_free (cust_types);
++		cust_types = NULL;
++	}
++	
++	cust_types = g_slist_prepend (cust_types, g_strdup ("tmp_t"));
++	cust_types = g_slist_prepend (cust_types, g_strdup ("user_home_t"));
++	/* cust_types = g_slist_prepend (cust_types, g_strdup ("user_tmp_t")); */
++	
++#ifdef HAVE_SELINUX
++	/* read types, one per line... */
++	fname_ctypes = selinux_customizable_types_path ();
++	errc = NULL;
++	if ((ioc_ctypes = g_io_channel_new_file (fname_ctypes, "r", &errc))) {
++	        char *data = NULL;
++
++		while ((data = cust_type_next_line (ioc_ctypes))) {
++		        cust_types = g_slist_prepend (cust_types, data);
++		}
++
++		fd = g_io_channel_unix_get_fd (ioc_ctypes);
++		if (!fstat (fd, &buf)) {
++			file_mtime = buf.st_mtime;
++		}
++
++		g_io_channel_unref (ioc_ctypes);
++	}
++#endif
++
++	return cust_types;
++}
++
++static void
++attach_selinux_data_edit_field (GtkEntry *entry,
++				char *attr_val, char *def_attr_val)
++{
++	GtkEntryCompletion *comp;
++	GtkCellRenderer *cell;
++	const char *attr_u;
++	const char *attr_r;
++	const char *attr_t;
++	const char *attr_s;
++	const char *dattr_u;
++	const char *dattr_r;
++	const char *dattr_t;
++	const char *dattr_s;
++	GtkListStore *store;
++	GtkTreeIter iter;
++	GSList *scan;
++	int width;
++	int owidth;
++	int twidth;
++	
++	attr_val     = g_strdup (attr_val); /* so we can alter it... */
++	def_attr_val = g_strdup (def_attr_val); /* so we can alter it... */
++	
++	/* do completion, so you don't have to type everything... */
++	comp = gtk_entry_completion_new ();
++	store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
++	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
++					      0, GTK_SORT_ASCENDING);
++	
++	gtk_entry_completion_set_model (comp, GTK_TREE_MODEL (store));
++	cell = gtk_cell_renderer_pixbuf_new ();
++	gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (comp), cell, FALSE);
++	gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (comp), cell,
++					"stock-id", 1, NULL);
++	gtk_entry_completion_set_text_column (comp, 0);
++	gtk_entry_set_completion (entry, comp);
++
++	 /* FIXME: default doesn't do the right thing, should it? */
++	owidth = gtk_entry_get_width_chars (entry);
++	width = owidth;
++	
++	selinux_split_cntx (attr_val, &attr_u, &attr_r, &attr_t, &attr_s);
++	dattr_u = dattr_r = dattr_t = dattr_s = NULL;
++	if (def_attr_val) {
++	          selinux_split_cntx (def_attr_val, &dattr_u, &dattr_r,
++				      &dattr_t, &dattr_s);
++	}
++	
++	/* don't do it twice... */
++	if (attr_t && dattr_t && !strcmp (attr_t, dattr_t)) {
++	        dattr_t = NULL;
++	}
++
++	if (attr_t && gtk_widget_get_state (entry)) {
++	  /* highlight just the type to the end, so we can easily change it
++	   * FIXME: we also highlight any Sensitivity/MCS but completion will
++	   * let people put it back, and that's the only way we get completion
++	   * at all -- This sucks and we need to remove Sensitivity/MCS from
++	   * the edit box. Yah, more UI. */
++	        int beg =  attr_t      - attr_u;
++		gtk_editable_select_region (GTK_EDITABLE (entry), beg, -1);
++	}
++	
++	for (scan = selinux__type_list(); scan; scan = scan->next) {
++		char *tmp;
++
++		if (attr_t  && !strcmp (attr_t,  scan->data))
++		        continue; /* don't have two entries */
++
++		if (dattr_t && !strcmp (dattr_t, scan->data))
++		        continue; /* don't have two entries */
++
++		gtk_list_store_append (store, &iter);
++		tmp = g_strjoin (":", attr_u, attr_r, scan->data, attr_s, NULL);
++		gtk_list_store_set (store, &iter, 0, tmp, -1);
++
++		twidth = strlen (tmp);
++		width = MAX (twidth, width);
++		
++		g_free (tmp);
++	}
++
++	if (dattr_t) {
++		char *tmp;
++
++		gtk_list_store_append (store, &iter);
++		tmp = g_strjoin (":", dattr_u, dattr_r, dattr_t, dattr_s, NULL);
++		gtk_list_store_set (store, &iter, 0, tmp,
++				    1, GTK_STOCK_HOME, -1);
++
++		twidth = strlen (tmp);
++		width = MAX (twidth, width);
++
++		g_free (tmp);
++	}
++
++	if (attr_t) {
++		char *tmp;
++
++		gtk_list_store_append (store, &iter);
++		tmp = g_strjoin (":", attr_u, attr_r, attr_t, attr_s, NULL);
++		gtk_list_store_set (store, &iter, 0, tmp, 1, GTK_STOCK_OK, -1);
++
++		twidth = strlen (tmp);
++		width = MAX (twidth, width);
++
++		g_free (tmp);
++	}
++
++	g_free (attr_val);
++	g_free (def_attr_val);
++	g_object_unref (G_OBJECT (store));	
++	g_object_unref (G_OBJECT (comp));
++
++	if (width != owidth) {
++	        gtk_entry_set_width_chars (entry, width + 2);
++	}
++}
++
++#ifdef HAVE_SELINUX
++
++# define HACK_TYPE(x, y)				\
++	else if (!strcmp (nice_type, x)) nice_type = y
++
++/* hack to convert a selinux_context type into a readable string for the
++   user */
++static const char *
++selinux__hack_conv_type (const char *type)
++{ /* FIXME: hack attack, but nowhere else to put it. Because mathpathcon
++   * here now probably want a bunch of other types? */
++        const char *nice_type;
++
++	nice_type = type;
++	
++	if (0) { }
++	
++	HACK_TYPE("cupsd_etc_t", _("CUPS printer configuration"));
++	HACK_TYPE("cupsd_rw_etc_t", _("CUPS printer configuration (rw)"));
++	HACK_TYPE("cupsd_tmp_t", _("CUPS temporary data"));
++	HACK_TYPE("dhcp_etc_t", _("DHCP configuration"));
++	HACK_TYPE("dictd_etc_t", _("Dictd configuration"));
++	HACK_TYPE("dnssec_t", _("DNS secret"));
++	HACK_TYPE("etc_t", _("System configuration"));
++	HACK_TYPE("etc_aliases_t", _("Email aliases configuration"));
++	HACK_TYPE("etc_runtime_t", _("System configuration (rw)"));
++	HACK_TYPE("cvs_data_t", _("Read and write from CVS daemon"));
++	HACK_TYPE("httpd_config_t", _("Apache-httpd configuration"));
++	HACK_TYPE("httpd_php_tmp_t",
++		  _("Apache-httpd PHP module temporary data"));
++	HACK_TYPE("httpd_sys_content_t",
++		  _("Read from all httpd scripts and the daemon"));
++	HACK_TYPE("httpd_sys_htaccess_t",
++		  _("Apache-httpd .htaccess configuration"));
++	HACK_TYPE("httpd_sys_script_exec_t",
++		  _("CGI programs with default access"));
++	HACK_TYPE("httpd_sys_script_ra_t",
++		  _("CGI programs can read and append"));
++	HACK_TYPE("httpd_sys_script_ro_t",
++		  _("CGI programs can read"));
++	HACK_TYPE("httpd_sys_script_rw_t",
++		  _("CGI programs can read and write"));
++	HACK_TYPE("httpd_unconfined_script_exec_t",
++		  _("CGI programs without any SELinux protection"));
++	HACK_TYPE("httpd_tmp_t", _("Apache-httpd temporary data"));
++	HACK_TYPE("ice_tmp_t", _("ICE temporary data"));
++	HACK_TYPE("locale_t", _("Locale data"));
++	HACK_TYPE("mysql_tmp_t", _("MySQL temporary data"));
++	HACK_TYPE("named_conf_t", _("Nameserver configuration"));
++	HACK_TYPE("net_conf_t", _("Network configuration"));
++	HACK_TYPE("postgresql_tmp_t", _("Postgresql temporary data"));
++	HACK_TYPE("public_content_rw_t",
++		  _("Read and write from CIFS/ftp/http/nfs/rsync"));
++	HACK_TYPE("public_content_t", _("Read from CIFS/ftp/http/nfs/rsync"));
++	HACK_TYPE("samba_etc_t", _("Samba configuration"));
++	HACK_TYPE("samba_share_t", _("Shared via CIFS (samba)"));
++	HACK_TYPE("staff_home_t", _("Staff user data"));
++	HACK_TYPE("staff_home_dir_t", _("Staff user home directory"));
++	HACK_TYPE("swapfile_t", _("System swapfile"));
++	HACK_TYPE("sysadm_home_t", _("Sysadmin user data"));
++	HACK_TYPE("sysadm_home_dir_t", _("Sysadmin user home directory"));
++	HACK_TYPE("system_cron_spool_t", _("Cron data"));
++	HACK_TYPE("tmp_t", _("Temporary data"));
++	HACK_TYPE("user_tmp_t", _("User temporary data"));
++	HACK_TYPE("user_home_t", _("User data"));
++	HACK_TYPE("user_home_dir_t", _("User home directory"));
++	HACK_TYPE("var_log_t", _("Logfile"));
++	HACK_TYPE("xen_image_t", _("Xen image"));
++	
++	return nice_type;
++}
++#undef HACK_TYPE
++
++static void
++attach_selinux_data_popup_field (GtkComboBox *comb,
++				 char *attr_val,
++				 char *def_attr_val)
++{
++	const char *attr_u;
++	const char *attr_r;
++	const char *attr_t;
++	const char *attr_s;
++	const char *dattr_u;
++	const char *dattr_r;
++	const char *dattr_t;
++	const char *dattr_s;
++	GtkListStore *store;
++	GtkTreeIter iter;
++	GSList *scan;
++	
++	attr_val     = g_strdup (attr_val); /* so we can alter it... */
++	def_attr_val = g_strdup (def_attr_val);
++
++	/* do completion, so you don't have to type everything... */
++	store = gtk_list_store_new (3, G_TYPE_STRING,
++				    G_TYPE_STRING, G_TYPE_STRING);
++	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
++					      1, GTK_SORT_ASCENDING);
++	
++	gtk_combo_box_set_model (comb, GTK_TREE_MODEL (store));
++
++	selinux_split_cntx (attr_val, &attr_u, &attr_r, &attr_t, &attr_s);
++	dattr_u = dattr_r = dattr_t = dattr_s = NULL;
++	if (def_attr_val) {
++	          selinux_split_cntx (def_attr_val, &dattr_u, &dattr_r,
++				      &dattr_t, &dattr_s);
++	}
++	/* don't do it twice... */
++	if (attr_t && dattr_t && !strcmp (attr_t, dattr_t)) {
++	        dattr_t = NULL;
++	}
++
++	for (scan = selinux__type_list(); scan; scan = scan->next) {
++		const char *nice_type;
++		
++		if (attr_t  && !strcmp (attr_t,  scan->data))
++		        continue; /* don't have two entries */
++
++		if (dattr_t && !strcmp (dattr_t, scan->data))
++		        continue; /* don't have two entries */
++
++		nice_type = selinux__hack_conv_type(scan->data);
++		
++		gtk_list_store_append (store, &iter);
++		gtk_list_store_set (store, &iter, 0, scan->data,
++				    1, nice_type, -1);
++	}
++
++	if (dattr_t) {
++		const char *nice_type;
++		
++		gtk_list_store_append (store, &iter);
++		nice_type = selinux__hack_conv_type(dattr_t);
++	        gtk_list_store_set (store, &iter, 0, dattr_t, 1, nice_type,
++				    2, GTK_STOCK_HOME, -1);
++	}
++
++	if (attr_t) {
++		const char *nice_type;
++		
++		gtk_list_store_append (store, &iter);
++		nice_type = selinux__hack_conv_type(attr_t);
++	        gtk_list_store_set (store, &iter, 0,  attr_t, 1, nice_type,
++				    2, GTK_STOCK_OK, -1);
++		gtk_combo_box_set_active_iter (comb, &iter);
++	}
++
++	g_free (attr_val);
++	g_free (def_attr_val);
++	g_object_unref (G_OBJECT (store));
++}
++
++static char *
++selinux__matchpathcon (GList *file_list)
++{
++	GList *scan;
++
++        for (scan = file_list; scan != NULL; scan = scan->next) {
++	        NautilusFile *file;
++
++		file = NAUTILUS_FILE (scan->data);
++		if (!nautilus_file_is_gone (file)) {
++		        return nautilus_file_get_selinux_matchpathcon (file);
++		}
++	}
++
++	return NULL;
++}
++
++static void
++attach_selinux_edit_field (FMPropertiesWindow *window,
++			   GtkTable *table,
++			   int row,
++			   int column,
++			   const char *file_attribute_name,
++			   const char *inconsistent_string,
++			   gboolean show_original,
++			   GtkLabel *lab_title)
++{
++	GtkEntry *entry;
++	GList *file_list;
++	char *attr_value;
++	char *def_attr_value;
++	
++	if (show_original) {
++	        file_list = window->details->original_files;
++	} else {
++	        file_list = window->details->target_files;
++	}
++	
++	attr_value = file_list_get_string_attribute (file_list, 
++						     file_attribute_name,
++						     inconsistent_string);
++	if ( strcmp (attr_value, inconsistent_string) &&
++	    !strcmp (file_attribute_name, "selinux_context")) {
++	        def_attr_value = selinux__matchpathcon (file_list);
++	} else {
++	        def_attr_value = NULL;
++	}
++	
++	entry = attach_edit_label (table, row, column, attr_value);
++	gtk_label_set_mnemonic_widget (GTK_LABEL (lab_title),
++				       GTK_WIDGET (entry));
++
++  	/* Stash a copy of the file attribute name in this field for the callback's sake. */
++	g_object_set_data_full (G_OBJECT (entry), "file_attribute",
++				g_strdup (file_attribute_name), g_free);
++
++	g_object_set_data_full (G_OBJECT (entry), "inconsistent_string",
++				g_strdup (inconsistent_string), g_free);
++
++	g_object_set_data (G_OBJECT (entry), "show_original", GINT_TO_POINTER (show_original));
++	g_object_set_data (G_OBJECT (entry), "ellipsize_text", GINT_TO_POINTER (FALSE));
++
++	g_signal_connect_object (entry, "focus_out_event",
++				 G_CALLBACK (selinux_focus_out), window, 0);
++	g_signal_connect_object (entry, "activate",
++				 G_CALLBACK (selinux_entry_activate), window,0);
++
++	attach_selinux_data_edit_field (entry, attr_value, def_attr_value);
++	
++	g_object_set_data_full (G_OBJECT (entry), "original_cntx", attr_value,
++				g_free);
++
++	g_object_set_data_full (G_OBJECT (entry), "matchpathcon_cntx",
++				def_attr_value, g_free);
++
++	window->details->edit_fields = g_list_prepend (window->details->edit_fields,
++						       entry);
++}
++
++static void
++attach_selinux_popup_field (FMPropertiesWindow *window,
++			    GtkTable *table,
++			    int row,
++			    int column,
++			    const char *file_attribute_name,
++			    const char *inconsistent_string,
++			    gboolean show_original,
++			    GtkLabel *lab_title)
++{
++	GtkWidget *comb;
++	GtkCellRenderer *cell;
++	GList *file_list;
++	char *attr_value;
++	char *def_attr_value;
++	gulong handler;
++	
++	if (show_original) {
++	        file_list = window->details->original_files;
++	} else {
++	        file_list = window->details->target_files;
++	}
++	
++	attr_value = file_list_get_string_attribute (file_list, 
++						     file_attribute_name,
++						     inconsistent_string);
++	if ( strcmp (attr_value, inconsistent_string) &&
++	    !strcmp (file_attribute_name, "selinux_context")) {
++	        def_attr_value = selinux__matchpathcon (file_list);	
++	} else {
++	        def_attr_value = NULL;
++	}
++	
++	comb = gtk_combo_box_new ();
++	
++	gtk_table_attach (table, comb, column, column + 1, row, row + 1,
++			  GTK_FILL, 0, 0, 0);
++
++	
++	gtk_label_set_mnemonic_widget (GTK_LABEL (lab_title), comb);
++
++  	/* Stash a copy of the file attribute name in this field for the callback's sake. */
++	g_object_set_data_full (G_OBJECT (comb), "file_attribute",
++				g_strdup (file_attribute_name), g_free);
++
++	g_object_set_data (G_OBJECT (comb), "show_original", GINT_TO_POINTER (show_original));
++
++	g_object_set_data_full (G_OBJECT (comb), "original_cntx", attr_value,
++				g_free);
++
++	g_object_set_data_full (G_OBJECT (comb), "matchpathcon_cntx",
++				def_attr_value, g_free);
++
++	cell = gtk_cell_renderer_pixbuf_new ();
++	gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (comb), cell, FALSE);
++	gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (comb), cell,
++					"stock-id", 2, NULL);
++	cell = gtk_cell_renderer_text_new ();
++	gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (comb), cell, FALSE);
++	gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (comb), cell,
++					"text", 1, NULL);
++	gtk_widget_show (comb);
++
++	attach_selinux_data_popup_field (GTK_COMBO_BOX (comb),
++					 attr_value, def_attr_value);
++
++	handler = g_signal_connect_object (comb, "changed",
++				 G_CALLBACK (selinux_popup_activate), window, 0);
++	g_object_set_data (G_OBJECT (comb), "handler_changed", GUINT_TO_POINTER (handler));
++
++	g_assert (! window->details->selinux_combo);
++	
++	window->details->selinux_combo = 
++		g_list_prepend (window->details->selinux_combo, comb);
++}
++#endif
++
+ static GtkWidget*
+ attach_ellipsizing_value_field (FMPropertiesWindow *window,
+ 				GtkTable *table,
+@@ -2302,6 +3281,37 @@ append_title_value_pair (FMPropertiesWin
+ 	return last_row;
+ }
+ 
++#ifdef HAVE_SELINUX
++static guint
++append_title_selinux_edit_pair (FMPropertiesWindow *window,
++				GtkTable *table,
++				const char *title, 
++				const char *file_attribute_name,
++				const char *inconsistent_state,
++				gboolean show_original)
++{
++	guint last_row;
++	GtkLabel *lab_title;
++
++	lab_title = NULL;
++	last_row = append_title_field (table, title, &lab_title);
++
++	if (window->details->advanced_permissions) {
++	        attach_selinux_edit_field (window, table, last_row,
++					   VALUE_COLUMN, file_attribute_name,
++					   inconsistent_state,
++					   show_original, lab_title);
++	} else {
++	        attach_selinux_popup_field (window, table, last_row,
++					    VALUE_COLUMN, file_attribute_name,
++					    inconsistent_state,
++					    show_original, lab_title);	  
++	}
++	
++	return last_row;
++}
++#endif
++
+ static guint
+ append_title_and_ellipsizing_value (FMPropertiesWindow *window,
+ 				    GtkTable *table,
+@@ -3230,31 +4240,6 @@ files_has_file (FMPropertiesWindow *wind
+ }
+ 
+ static void
+-start_long_operation (FMPropertiesWindow *window)
+-{
+-	if (window->details->long_operation_underway == 0) {
+-		/* start long operation */
+-		GdkCursor * cursor;
+-		
+-		cursor = gdk_cursor_new (GDK_WATCH);
+-		gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (window)), cursor);
+-		gdk_cursor_unref (cursor);
+-	}
+-	window->details->long_operation_underway ++;
+-}
+-
+-static void
+-end_long_operation (FMPropertiesWindow *window)
+-{
+-	if (gtk_widget_get_window (GTK_WIDGET (window)) != NULL &&
+-	    window->details->long_operation_underway == 1) {
+-		/* finished !! */
+-		gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (window)), NULL);
+-	}
+-	window->details->long_operation_underway--;
+-}
+-
+-static void
+ permission_change_callback (NautilusFile *file,
+ 			    GFile *res_loc,
+ 			    GError *error,
+@@ -4037,39 +5022,6 @@ append_special_execution_flags (FMProper
+ 	gtk_table_set_row_spacing (table, nrows - 1, 18);
+ }
+ 
+-static gboolean
+-all_can_get_permissions (GList *file_list)
+-{
+-	GList *l;
+-	for (l = file_list; l != NULL; l = l->next) {
+-		NautilusFile *file;
+-		
+-		file = NAUTILUS_FILE (l->data);
+-		
+-		if (!nautilus_file_can_get_permissions (file)) {
+-			return FALSE;
+-		}
+-	}
+-
+-	return TRUE;
+-}
+-
+-static gboolean
+-all_can_set_permissions (GList *file_list)
+-{
+-	GList *l;
+-	for (l = file_list; l != NULL; l = l->next) {
+-		NautilusFile *file;
+-		
+-		file = NAUTILUS_FILE (l->data);
+-
+-		if (!nautilus_file_can_set_permissions (file)) {
+-			return FALSE;
+-		}
+-	}
+-
+-	return TRUE;
+-}
+ 
+ static GHashTable *
+ get_initial_permissions (GList *file_list)
+@@ -4417,7 +5369,9 @@ apply_recursive_clicked (GtkWidget *recu
+ 	guint32 file_permission, file_permission_mask;
+ 	guint32 dir_permission, dir_permission_mask;
+ 	guint32 vfs_mask, vfs_new_perm, p;
+-	GtkWidget *button, *combo;
++	char *context; 
++	GtkWidget *button; 
++	GtkComboBox *combo; 
+ 	gboolean active, is_folder, is_special, use_original;
+ 	GList *l;
+ 	GtkTreeModel *model;
+@@ -4461,9 +5415,9 @@ apply_recursive_clicked (GtkWidget *recu
+ 	}
+ 	/* Simple mode, minus exec checkbox */
+ 	for (l = window->details->permission_combos; l != NULL; l = l->next) {
+-		combo = l->data;
++		combo = GTK_COMBO_BOX (l->data);
+ 		
+-		if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo),  &iter)) {
++		if (!gtk_combo_box_get_active_iter (combo,  &iter)) {
+ 			continue;
+ 		}
+ 		
+@@ -4471,7 +5425,7 @@ apply_recursive_clicked (GtkWidget *recu
+ 		is_folder = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (combo),
+ 								"is-folder"));
+ 		
+-		model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo));
++		model = gtk_combo_box_get_model (combo);
+ 		gtk_tree_model_get (model, &iter, 1, &new_perm, 2, &use_original, -1);
+ 		if (use_original) {
+ 			continue;
+@@ -4494,12 +5448,53 @@ apply_recursive_clicked (GtkWidget *recu
+ 		}
+ 	}
+ 
++	/* get the SELinux context... */
++	context = NULL;
++	if (window->details->advanced_permissions &&
++	    window->details->edit_fields) { /* advanced mode */
++		GtkEditable *efield;
++
++		efield = window->details->edit_fields->data;
++	        context = gtk_editable_get_chars (GTK_EDITABLE (efield), 0, -1);
++	} else if (!window->details->advanced_permissions &&
++		   window->details->selinux_combo) { /* simple mode */
++	        char *cntx_type;
++	        char *orig_type;
++	        const char *attr_u;
++	        const char *attr_r;
++	        const char *attr_t;
++	        const char *attr_s;
++	  
++		combo = GTK_COMBO_BOX (window->details->selinux_combo->data);
++	        
++	        if (!gtk_combo_box_get_active_iter (combo, &iter)) {
++		        return;
++		} else {
++		        GtkTreeModel *model = gtk_combo_box_get_model (combo);
++			gtk_tree_model_get (model, &iter, 0, &cntx_type, -1);
++		}
++		if (!(orig_type = g_object_get_data (G_OBJECT (combo),
++						     "original_cntx"))) {
++		        return;
++		}
++		
++		orig_type = g_strdup (orig_type);
++	
++		selinux_split_cntx (orig_type,
++				    &attr_u, &attr_r, &attr_t, &attr_s);
++		context = g_strjoin (":",
++				     attr_u, attr_r, cntx_type, attr_s, NULL);
++		g_free (orig_type);
++	}
++	
+ 	for (l = window->details->target_files; l != NULL; l = l->next) {
+ 		NautilusFile *file;
+ 		char *uri;
+ 
+ 		file = NAUTILUS_FILE (l->data);
+ 
++		/* assume permissions setting allows context setting...
++		 * we can't really do much else due to race conditions anyway */
+ 		if (nautilus_file_is_directory (file) &&
+ 		    nautilus_file_can_set_permissions (file)) {
+ 			uri = nautilus_file_get_uri (file);
+@@ -4510,11 +5505,13 @@ apply_recursive_clicked (GtkWidget *recu
+ 								 file_permission_mask,
+ 								 dir_permission,
+ 								 dir_permission_mask,
++								 context,
+ 								 set_recursive_permissions_done,
+ 								 window);
+ 			g_free (uri);
+ 		}
+ 	}
++	g_free (context);
+ }
+ 
+ static void
+@@ -4565,10 +5562,16 @@ create_permissions_page (FMPropertiesWin
+ 		gtk_table_set_row_spacing (page_table, nrows - 1, 18);
+ 	
+ #ifdef HAVE_SELINUX
+-		append_title_value_pair
+-			(window, page_table, _("SELinux context:"), 
+-			 "selinux_context", INCONSISTENT_STATE_STRING,
+-			 FALSE);
++		if (!is_multi_file_window (window) || multi_have_same_selinux_context (window)) 
++			append_title_selinux_edit_pair (window, page_table, 
++							_("_SELinux Context:"),  
++							"selinux_context", INCONSISTENT_STATE_STRING,
++							FALSE); 
++		else /* Static text in this case. */ 
++			append_title_value_pair (window, page_table, 
++						 _("_SELinux Context:"),  
++						 "selinux_context", INCONSISTENT_STATE_STRING,
++						 FALSE); 
+ #endif
+ 		append_title_value_pair
+ 			(window, page_table, _("Last changed:"),