mirror of
https://github.com/MidnightCommander/mc
synced 2024-12-23 12:56:51 +03:00
83ab2a7f65
* gnome-file-property-dialog.c: Many Many Many changes. Now it's pretty cool. You can set all meta-data but the icon now. Need to make gmc do the right thing with it, though.
1179 lines
39 KiB
C
1179 lines
39 KiB
C
/* gnome-file-property-dialog.c
|
|
* Copyright (C) 1999 J. Arthur Random
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include <gnome.h>
|
|
#include <time.h>
|
|
#include "gnome-file-property-dialog.h"
|
|
#include "dir.h"
|
|
#include "gdesktop.h"
|
|
#include <pwd.h>
|
|
#include <grp.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include "fileopctx.h"
|
|
#include "file.h"
|
|
|
|
static void gnome_file_property_dialog_init (GnomeFilePropertyDialog *file_property_dialog);
|
|
static void gnome_file_property_dialog_class_init (GnomeFilePropertyDialogClass *klass);
|
|
static void gnome_file_property_dialog_finalize (GtkObject *object);
|
|
|
|
static GnomeDialogClass *parent_class = NULL;
|
|
|
|
|
|
GtkType
|
|
gnome_file_property_dialog_get_type (void)
|
|
{
|
|
static GtkType file_property_dialog_type = 0;
|
|
|
|
if (!file_property_dialog_type)
|
|
{
|
|
static const GtkTypeInfo file_property_dialog_info =
|
|
{
|
|
"GnomeFilePropertyDialog",
|
|
sizeof (GnomeFilePropertyDialog),
|
|
sizeof (GnomeFilePropertyDialogClass),
|
|
(GtkClassInitFunc) gnome_file_property_dialog_class_init,
|
|
(GtkObjectInitFunc) gnome_file_property_dialog_init,
|
|
/* reserved_1 */ NULL,
|
|
/* reserved_2 */ NULL,
|
|
};
|
|
|
|
file_property_dialog_type = gtk_type_unique (gnome_dialog_get_type (), &file_property_dialog_info);
|
|
}
|
|
|
|
return file_property_dialog_type;
|
|
}
|
|
|
|
static void
|
|
gnome_file_property_dialog_class_init (GnomeFilePropertyDialogClass *klass)
|
|
{
|
|
GtkObjectClass *object_class;
|
|
|
|
object_class = (GtkObjectClass*) klass;
|
|
|
|
parent_class = gtk_type_class (gnome_dialog_get_type ());
|
|
object_class->finalize = gnome_file_property_dialog_finalize;
|
|
|
|
|
|
}
|
|
|
|
static void
|
|
gnome_file_property_dialog_init (GnomeFilePropertyDialog *file_property_dialog)
|
|
{
|
|
file_property_dialog->file_name = NULL;
|
|
file_property_dialog->file_entry = NULL;
|
|
file_property_dialog->group_name = NULL;
|
|
file_property_dialog->modifyable = TRUE;
|
|
file_property_dialog->user_name = NULL;
|
|
file_property_dialog->prop1_label = NULL;
|
|
file_property_dialog->prop2_label = NULL;
|
|
file_property_dialog->prop1_entry = NULL;
|
|
file_property_dialog->prop2_entry = NULL;
|
|
file_property_dialog->prop1_cbox = NULL;
|
|
file_property_dialog->prop2_cbox = NULL;
|
|
file_property_dialog->fm_open = NULL;
|
|
file_property_dialog->fm_view = NULL;
|
|
file_property_dialog->edit = NULL;
|
|
file_property_dialog->drop_target = NULL;
|
|
file_property_dialog->im = NULL;
|
|
}
|
|
static void
|
|
gnome_file_property_dialog_finalize (GtkObject *object)
|
|
{
|
|
GnomeFilePropertyDialog *gfpd;
|
|
|
|
g_return_if_fail (object != NULL);
|
|
g_return_if_fail (GNOME_IS_FILE_PROPERTY_DIALOG (object));
|
|
|
|
gfpd = GNOME_FILE_PROPERTY_DIALOG (object);
|
|
|
|
if (gfpd->file_name)
|
|
g_free (gfpd->file_name);
|
|
if (gfpd->im)
|
|
gdk_imlib_destroy_image (gfpd->im);
|
|
(* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
|
|
}
|
|
|
|
/* Create the pane */
|
|
|
|
static GtkWidget *
|
|
create_general_properties (GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
GtkWidget *vbox;
|
|
GtkWidget *hbox;
|
|
GtkWidget *label;
|
|
GtkWidget *align;
|
|
gchar *direc;
|
|
gchar *gen_string;
|
|
gchar size[50]; /* this is a HUGE file. (: */
|
|
gchar size2[20]; /* this is a HUGE file. (: */
|
|
file_entry *fe;
|
|
GtkWidget *icon;
|
|
struct tm *time;
|
|
GtkWidget *table;
|
|
int n;
|
|
|
|
vbox = gtk_vbox_new (FALSE, GNOME_PAD_SMALL);
|
|
gtk_container_set_border_width (GTK_CONTAINER (vbox), GNOME_PAD);
|
|
|
|
/* first, we set the icon */
|
|
direc = g_strdup (fp_dlg->file_name);
|
|
rindex (direc, '/')[0] = NULL;
|
|
fe = file_entry_from_file (fp_dlg->file_name);
|
|
fp_dlg->im = gicon_get_icon_for_file (direc, fe);
|
|
g_free (direc);
|
|
icon = gnome_pixmap_new_from_imlib (fp_dlg->im);
|
|
gtk_box_pack_start (GTK_BOX (vbox), icon, FALSE, FALSE, 0);
|
|
|
|
/* we set the file part */
|
|
gen_string = g_strconcat (_("Full Name: "), fp_dlg->file_name, NULL);
|
|
label = gtk_label_new (gen_string);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
|
|
g_free (gen_string);
|
|
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
|
|
/* if it's a symlink */
|
|
align = gtk_alignment_new (0.0, 0.5, 1.0, 1.0);
|
|
hbox = gtk_hbox_new (FALSE, 2);
|
|
label = gtk_label_new (_("File Name"));
|
|
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
|
|
fp_dlg->file_entry = gtk_entry_new ();
|
|
gen_string = rindex (fp_dlg->file_name, '/');
|
|
if (gen_string)
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->file_entry), gen_string + 1);
|
|
else
|
|
/* I don't think this should happen anymore, but it can't hurt in
|
|
* case this ever gets used outside gmc */
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->file_entry), fp_dlg->file_name);
|
|
/* We want to prevent editing of the file if
|
|
* the thing is a BLK, CHAR, or we don't own it */
|
|
/* FIXME: We can actually edit it if we're in the same grp of the file. */
|
|
if (fp_dlg->modifyable == FALSE)
|
|
gtk_widget_set_sensitive (fp_dlg->file_entry, FALSE);
|
|
gtk_box_pack_start (GTK_BOX (hbox), fp_dlg->file_entry, FALSE, FALSE, 0);
|
|
gtk_container_add (GTK_CONTAINER (align), hbox);
|
|
gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 0);
|
|
gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new (), FALSE, FALSE, 8);
|
|
|
|
/* File statistics */
|
|
/* File type first */
|
|
if (S_ISREG (fp_dlg->st.st_mode)) {
|
|
gen_string = g_strconcat (_("File Type: "),
|
|
gnome_mime_type (fp_dlg->file_name),
|
|
NULL);
|
|
label = gtk_label_new (gen_string);
|
|
g_free (gen_string);
|
|
} else if (S_ISLNK (fp_dlg->st.st_mode)) {
|
|
label = gtk_label_new (_("File Type: Symbolic Link"));
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
|
|
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
|
|
n = readlink (fp_dlg->file_name, size, 49);
|
|
if (n < 0)
|
|
label = gtk_label_new (_("Target Name: INVALID LINK"));
|
|
else {
|
|
size[n] = '\0';
|
|
gen_string = g_strconcat (_("Target Name: "), size, NULL);
|
|
label = gtk_label_new (gen_string);
|
|
g_free (gen_string);
|
|
}
|
|
}else if (S_ISDIR (fp_dlg->st.st_mode))
|
|
label = gtk_label_new (_("File Type: Directory"));
|
|
else if (S_ISCHR (fp_dlg->st.st_mode))
|
|
label = gtk_label_new (_("File Type: Character Device"));
|
|
else if (S_ISBLK (fp_dlg->st.st_mode))
|
|
label = gtk_label_new (_("File Type: Block Device"));
|
|
else if (S_ISSOCK (fp_dlg->st.st_mode))
|
|
label = gtk_label_new (_("File Type: Socket"));
|
|
else if (S_ISFIFO (fp_dlg->st.st_mode))
|
|
label = gtk_label_new (_("File Type: FIFO"));
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
|
|
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
|
|
|
|
/* Now file size */
|
|
if (S_ISDIR (fp_dlg->st.st_mode)
|
|
|| S_ISREG (fp_dlg->st.st_mode)
|
|
|| S_ISLNK (fp_dlg->st.st_mode)) {
|
|
if ((gint)fp_dlg->st.st_size < 1024) {
|
|
snprintf (size, 19, "%d", (gint) fp_dlg->st.st_size);
|
|
gen_string = g_strconcat (_("File Size: "), size, _(" bytes"), NULL);
|
|
} else if ((gint)fp_dlg->st.st_size < 1024 * 1024) {
|
|
snprintf (size, 19, "%.1f", (gfloat) fp_dlg->st.st_size / 1024.0);
|
|
snprintf (size2, 19, "%d", (gint) fp_dlg->st.st_size);
|
|
gen_string = g_strconcat (_("File Size: "), size, _(" KBytes ("),
|
|
size2, _(" bytes)"), NULL);
|
|
} else {
|
|
snprintf (size, 19, "%.1f", (gfloat) fp_dlg->st.st_size / (1024.0 * 1024.0));
|
|
snprintf (size2, 19, "%d", (gint) fp_dlg->st.st_size);
|
|
gen_string = g_strconcat (_("File Size: "), size, _(" MBytes ("),
|
|
size2, _(" bytes)"), NULL);
|
|
}
|
|
label = gtk_label_new (gen_string);
|
|
g_free (gen_string);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
|
|
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
|
|
} else {
|
|
label = gtk_label_new (_("File Size: N/A"));
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
|
|
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
|
|
}
|
|
|
|
gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new (), FALSE, FALSE, 8);
|
|
|
|
/* Time Fields */
|
|
table = gtk_table_new (3, 2, FALSE);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
|
|
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
|
|
label = gtk_label_new (_("File Created on: "));
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
|
|
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 0, 1);
|
|
time = gmtime (&(fp_dlg->st.st_ctime));
|
|
strftime (size, 49, "%a, %b %d %Y, %I:%M:%S %p", time);
|
|
label = gtk_label_new (size);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
|
|
gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 0, 1);
|
|
|
|
label = gtk_label_new (_("Last Modified on: "));
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
|
|
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 1, 2);
|
|
time = gmtime (&(fp_dlg->st.st_mtime));
|
|
strftime (size, 49, "%a, %b %d %Y, %I:%M:%S %p", time);
|
|
label = gtk_label_new (size);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
|
|
gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 1, 2);
|
|
|
|
label = gtk_label_new (_("Last Accessed on: "));
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
|
|
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 2, 3);
|
|
time = gmtime (&(fp_dlg->st.st_atime));
|
|
strftime (size, 49, "%a, %b %d %Y, %I:%M:%S %p", time);
|
|
label = gtk_label_new (size);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
|
|
gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 2, 3);
|
|
return vbox;
|
|
}
|
|
|
|
|
|
|
|
/* Settings Pane */
|
|
static void
|
|
metadata_toggled (GtkWidget *cbox, GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
if (fp_dlg->changing)
|
|
return;
|
|
if (cbox == fp_dlg->prop1_cbox) {
|
|
if (GTK_TOGGLE_BUTTON (cbox)->active) {
|
|
gtk_widget_set_sensitive (fp_dlg->prop1_entry, FALSE);
|
|
if (fp_dlg->executable && fp_dlg->mime_fm_open) {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop1_entry), fp_dlg->mime_fm_open);
|
|
} else if (!fp_dlg->executable && fp_dlg->mime_fm_view) {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop1_entry), fp_dlg->mime_fm_view);
|
|
} else {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop1_entry), "");
|
|
}
|
|
} else {
|
|
gtk_widget_set_sensitive (fp_dlg->prop1_entry, TRUE);
|
|
if (fp_dlg->executable && fp_dlg->fm_open) {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop1_entry), fp_dlg->fm_open);
|
|
} else if (!fp_dlg->executable && fp_dlg->fm_view) {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop1_entry), fp_dlg->fm_view);
|
|
}
|
|
}
|
|
} else {
|
|
if (GTK_TOGGLE_BUTTON (cbox)->active) {
|
|
gtk_widget_set_sensitive (fp_dlg->prop2_entry, FALSE);
|
|
if (fp_dlg->executable && fp_dlg->mime_drop_target) {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop2_entry), fp_dlg->mime_drop_target);
|
|
} else if (!fp_dlg->executable && fp_dlg->mime_edit) {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop2_entry), fp_dlg->mime_edit);
|
|
} else {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop2_entry), "");
|
|
}
|
|
} else {
|
|
gtk_widget_set_sensitive (fp_dlg->prop2_entry, TRUE);
|
|
if (fp_dlg->executable && fp_dlg->drop_target) {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop2_entry), fp_dlg->drop_target);
|
|
} else if (!fp_dlg->executable && fp_dlg->edit) {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop2_entry), fp_dlg->edit);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
static void
|
|
switch_metadata_box (GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
if (NULL == fp_dlg->prop1_label)
|
|
return;
|
|
fp_dlg->changing = TRUE;
|
|
if (fp_dlg->executable) {
|
|
gtk_label_set_text (GTK_LABEL (fp_dlg->prop1_label), "Open");
|
|
gtk_label_set_text (GTK_LABEL (fp_dlg->prop2_label), "Drop Action");
|
|
gtk_label_set_text (GTK_LABEL (GTK_BIN (fp_dlg->prop1_cbox)->child), "Use default Open options");
|
|
gtk_label_set_text (GTK_LABEL (GTK_BIN (fp_dlg->prop2_cbox)->child), "Use default Drop Action options");
|
|
if (fp_dlg->fm_open) {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop1_entry), fp_dlg->fm_open);
|
|
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (fp_dlg->prop1_cbox), FALSE);
|
|
gtk_widget_set_sensitive (fp_dlg->prop1_entry, TRUE);
|
|
} else if (fp_dlg->mime_fm_open) {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop1_entry), fp_dlg->mime_fm_open);
|
|
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (fp_dlg->prop1_cbox), TRUE);
|
|
gtk_widget_set_sensitive (fp_dlg->prop1_entry, FALSE);
|
|
} else {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop1_entry), "");
|
|
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (fp_dlg->prop1_cbox), TRUE);
|
|
gtk_widget_set_sensitive (fp_dlg->prop1_entry, FALSE);
|
|
}
|
|
if (fp_dlg->drop_target) {
|
|
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (fp_dlg->prop2_cbox), FALSE);
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop2_entry), fp_dlg->drop_target);
|
|
gtk_widget_set_sensitive (fp_dlg->prop2_entry, TRUE);
|
|
} else if (fp_dlg->mime_drop_target) {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop2_entry), fp_dlg->mime_drop_target);
|
|
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (fp_dlg->prop2_cbox), TRUE);
|
|
gtk_widget_set_sensitive (fp_dlg->prop2_entry, FALSE);
|
|
} else {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop2_entry), "");
|
|
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (fp_dlg->prop2_cbox), TRUE);
|
|
gtk_widget_set_sensitive (fp_dlg->prop2_entry, FALSE);
|
|
}
|
|
} else {
|
|
gtk_label_set_text (GTK_LABEL (fp_dlg->prop1_label), "View");
|
|
gtk_label_set_text (GTK_LABEL (fp_dlg->prop2_label), "Edit");
|
|
gtk_label_set_text (GTK_LABEL (GTK_BIN (fp_dlg->prop1_cbox)->child), "Use default View options");
|
|
gtk_label_set_text (GTK_LABEL (GTK_BIN (fp_dlg->prop2_cbox)->child), "Use default Edit options");
|
|
if (fp_dlg->fm_view) {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop1_entry), fp_dlg->fm_view);
|
|
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (fp_dlg->prop1_cbox), FALSE);
|
|
gtk_widget_set_sensitive (fp_dlg->prop1_entry, TRUE);
|
|
} else if (fp_dlg->mime_fm_view) {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop1_entry), fp_dlg->mime_fm_view);
|
|
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (fp_dlg->prop1_cbox), TRUE);
|
|
gtk_widget_set_sensitive (fp_dlg->prop1_entry, FALSE);
|
|
} else {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop1_entry), "");
|
|
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (fp_dlg->prop1_cbox), TRUE);
|
|
gtk_widget_set_sensitive (fp_dlg->prop1_entry, FALSE);
|
|
}
|
|
if (fp_dlg->edit) {
|
|
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (fp_dlg->prop2_cbox), FALSE);
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop2_entry), fp_dlg->edit);
|
|
gtk_widget_set_sensitive (fp_dlg->prop2_entry, TRUE);
|
|
} else if (fp_dlg->mime_edit) {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop2_entry), fp_dlg->mime_edit);
|
|
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (fp_dlg->prop2_cbox), TRUE);
|
|
gtk_widget_set_sensitive (fp_dlg->prop2_entry, FALSE);
|
|
} else {
|
|
gtk_entry_set_text (GTK_ENTRY (fp_dlg->prop2_entry), "");
|
|
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON (fp_dlg->prop2_cbox), TRUE);
|
|
gtk_widget_set_sensitive (fp_dlg->prop2_entry, FALSE);
|
|
}
|
|
}
|
|
fp_dlg->changing = FALSE;
|
|
}
|
|
|
|
/* Stolen from gnome-icon-entry.c */
|
|
/* - jrb */
|
|
static void
|
|
icon_selected_cb(GtkButton * button, GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
const gchar * icon;
|
|
GnomeIconSelection * gis;
|
|
|
|
gis = gtk_object_get_user_data(GTK_OBJECT(fp_dlg));
|
|
icon = gnome_icon_selection_get_icon(gis, TRUE);
|
|
|
|
if (icon != NULL) {
|
|
g_print ("icon:%s:\n",icon);
|
|
}
|
|
}
|
|
#if 0
|
|
static void
|
|
gil_icon_selected_cb(GnomeIconList *gil, gint num, GdkEvent *event, GnomeIconEntry *ientry)
|
|
{
|
|
if(event && event->type == GDK_2BUTTON_PRESS && ((GdkEventButton *)event)->button == 1) {
|
|
icon_selected_cb(NULL, ientry);
|
|
gtk_widget_hide(ientry->pick_dialog);
|
|
}
|
|
g_print ("in gil_icon_selected_cb callback \n");
|
|
}
|
|
#endif
|
|
static void
|
|
icon_sel_callback (GtkWidget *button, GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
GtkWidget *icon_sel;
|
|
|
|
if (fp_dlg->dlg)
|
|
fp_dlg->dlg = gnome_dialog_new("Select An Icon",
|
|
GNOME_STOCK_BUTTON_OK,
|
|
GNOME_STOCK_BUTTON_CANCEL,
|
|
NULL);
|
|
gnome_dialog_close_hides(GNOME_DIALOG(fp_dlg->dlg), TRUE);
|
|
gnome_dialog_set_close (GNOME_DIALOG(fp_dlg->dlg), TRUE);
|
|
|
|
gtk_window_set_policy(GTK_WINDOW(fp_dlg->dlg),
|
|
TRUE, TRUE, TRUE);
|
|
|
|
icon_sel = gnome_icon_selection_new();
|
|
|
|
gnome_icon_selection_add_directory(GNOME_ICON_SELECTION(icon_sel),
|
|
"/opt/gnome/share/pixmaps/");
|
|
|
|
|
|
gtk_container_add(GTK_CONTAINER(GNOME_DIALOG(fp_dlg->dlg)->vbox), icon_sel);
|
|
|
|
gtk_widget_show_all(fp_dlg->dlg);
|
|
|
|
gnome_icon_selection_show_icons(GNOME_ICON_SELECTION(icon_sel));
|
|
gtk_object_set_user_data(GTK_OBJECT(fp_dlg), icon_sel);
|
|
gnome_dialog_button_connect(GNOME_DIALOG(fp_dlg->dlg),
|
|
0, /* OK button */
|
|
GTK_SIGNAL_FUNC(icon_selected_cb),
|
|
fp_dlg);
|
|
#if 0
|
|
gtk_signal_connect_after(GTK_OBJECT(GNOME_ICON_SELECTION(iconsel)->gil), "select_icon",
|
|
GTK_SIGNAL_FUNC(gil_icon_selected_cb),
|
|
ientry);
|
|
#endif
|
|
|
|
}
|
|
static GtkWidget *
|
|
generate_icon_sel (GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
GtkWidget *retval;
|
|
GtkWidget *icon;
|
|
|
|
retval = gtk_button_new ();
|
|
gtk_widget_set_usize (retval, 64, 64);
|
|
icon = gnome_pixmap_new_from_imlib (fp_dlg->im);
|
|
gtk_container_add (GTK_CONTAINER (retval), icon);
|
|
gtk_signal_connect (GTK_OBJECT (retval), "clicked", icon_sel_callback, fp_dlg);
|
|
|
|
return retval;
|
|
}
|
|
static GtkWidget *
|
|
generate_actions_box (GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
GtkWidget *vbox;
|
|
GtkWidget *table;
|
|
|
|
/* Here's the Logic: */
|
|
/* If we are a file, and an Executable, we want to edit our "open" and "drop-target" */
|
|
/* Metadata, as it is meaningful to us. */
|
|
/* If we are non-executable, we want to edit our "edit" and "view" fields. */
|
|
/* Sym links want to have the same options as above, but use their Target's */
|
|
/* Executable/set bit in order to determine which one. */
|
|
/* Note, symlinks can set their own metadata, independent from their */
|
|
/* targets. */
|
|
|
|
table = gtk_table_new (5, 2, FALSE);
|
|
gtk_container_set_border_width (GTK_CONTAINER (table), GNOME_PAD_SMALL);
|
|
|
|
if (fp_dlg->executable)
|
|
fp_dlg->prop1_label = gtk_label_new (_("Open"));
|
|
else
|
|
fp_dlg->prop1_label = gtk_label_new (_("View"));
|
|
gtk_misc_set_alignment (GTK_MISC (fp_dlg->prop1_label), 0.0, 0.5);
|
|
gtk_misc_set_padding (GTK_MISC (fp_dlg->prop1_label), 2, 0);
|
|
gtk_table_attach_defaults (GTK_TABLE (table),
|
|
fp_dlg->prop1_label,
|
|
0, 1, 0, 1);
|
|
fp_dlg->prop1_entry = gtk_entry_new ();
|
|
gtk_table_attach_defaults (GTK_TABLE (table),
|
|
fp_dlg->prop1_entry,
|
|
1, 2, 0, 1);
|
|
if (fp_dlg->executable)
|
|
fp_dlg->prop1_cbox = gtk_check_button_new_with_label (_("Use default Open options"));
|
|
else
|
|
fp_dlg->prop1_cbox = gtk_check_button_new_with_label (_("Use default View options"));
|
|
gtk_signal_connect (GTK_OBJECT (fp_dlg->prop1_cbox), "toggled", metadata_toggled, fp_dlg);
|
|
gtk_table_attach_defaults (GTK_TABLE (table), fp_dlg->prop1_cbox, 0, 2, 1, 2);
|
|
|
|
vbox = gtk_vbox_new (FALSE, 0);
|
|
gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new (), FALSE, FALSE, GNOME_PAD_SMALL);
|
|
gtk_table_attach_defaults (GTK_TABLE (table), vbox, 0, 2, 2, 3);
|
|
|
|
if (fp_dlg->executable)
|
|
fp_dlg->prop2_label = gtk_label_new (_("Drop Action"));
|
|
else
|
|
fp_dlg->prop2_label = gtk_label_new (_("Edit"));
|
|
gtk_misc_set_alignment (GTK_MISC (fp_dlg->prop2_label), 0.0, 0.5);
|
|
gtk_misc_set_padding (GTK_MISC (fp_dlg->prop2_label), 2, 0);
|
|
gtk_table_attach_defaults (GTK_TABLE (table),
|
|
fp_dlg->prop2_label,
|
|
0, 1, 3, 4);
|
|
fp_dlg->prop2_entry = gtk_entry_new ();
|
|
gtk_table_attach_defaults (GTK_TABLE (table),
|
|
fp_dlg->prop2_entry,
|
|
1, 2, 3, 4);
|
|
if (fp_dlg->executable)
|
|
fp_dlg->prop2_cbox = gtk_check_button_new_with_label (_("Use default Drop Action options"));
|
|
else
|
|
fp_dlg->prop2_cbox = gtk_check_button_new_with_label (_("Use default Edit options"));
|
|
gtk_signal_connect (GTK_OBJECT (fp_dlg->prop2_cbox), "toggled", metadata_toggled, fp_dlg);
|
|
gtk_table_attach_defaults (GTK_TABLE (table), fp_dlg->prop2_cbox, 0, 2, 4, 5);
|
|
/* It's okay to do this now... */
|
|
switch_metadata_box (fp_dlg);
|
|
return table;
|
|
}
|
|
static GtkWidget *
|
|
create_settings_pane (GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
GtkWidget *vbox;
|
|
GtkWidget *hbox;
|
|
GtkWidget *vbox2;
|
|
GtkWidget *button;
|
|
GtkWidget *frame;
|
|
GtkWidget *align;
|
|
GtkWidget *table;
|
|
|
|
vbox = gtk_vbox_new (FALSE, GNOME_PAD_SMALL);
|
|
gtk_container_set_border_width (GTK_CONTAINER (vbox), GNOME_PAD);
|
|
|
|
frame = gtk_frame_new (_("Icon"));
|
|
vbox2 = gtk_vbox_new (FALSE, 0);
|
|
hbox = gtk_hbox_new (FALSE, 0);
|
|
align = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
|
|
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
|
|
button = generate_icon_sel (fp_dlg);
|
|
gtk_container_add (GTK_CONTAINER (frame), vbox2);
|
|
gtk_container_set_border_width (GTK_CONTAINER (vbox2), GNOME_PAD_SMALL);
|
|
gtk_box_pack_start (GTK_BOX (vbox2), hbox, TRUE, FALSE, 0);
|
|
gtk_box_pack_start (GTK_BOX (hbox), align, TRUE, FALSE, 0);
|
|
gtk_container_add (GTK_CONTAINER (align), button);
|
|
|
|
/* Are we a directory? If so, we do nothing else. */
|
|
if (!(S_ISREG (fp_dlg->st.st_mode) || S_ISLNK (fp_dlg->st.st_mode)))
|
|
return vbox;
|
|
/* We must be a file or a link. */
|
|
frame = gtk_frame_new (_("Actions"));
|
|
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
|
|
table = generate_actions_box (fp_dlg);
|
|
gtk_container_add (GTK_CONTAINER (frame), table);
|
|
return vbox;
|
|
}
|
|
|
|
/* Permissions Pane */
|
|
static GtkWidget *
|
|
label_new (char *text, double xalign, double yalign)
|
|
{
|
|
GtkWidget *label;
|
|
|
|
label = gtk_label_new (text);
|
|
gtk_misc_set_alignment (GTK_MISC (label), xalign, yalign);
|
|
gtk_widget_show (label);
|
|
|
|
return label;
|
|
}
|
|
|
|
static mode_t
|
|
perm_get_umode (GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
mode_t umode;
|
|
|
|
#define SETBIT(widget, flag) umode |= GTK_TOGGLE_BUTTON (widget)->active ? flag : 0
|
|
|
|
umode = 0;
|
|
|
|
SETBIT (fp_dlg->suid, S_ISUID);
|
|
SETBIT (fp_dlg->sgid, S_ISGID);
|
|
SETBIT (fp_dlg->svtx, S_ISVTX);
|
|
|
|
SETBIT (fp_dlg->rusr, S_IRUSR);
|
|
SETBIT (fp_dlg->wusr, S_IWUSR);
|
|
SETBIT (fp_dlg->xusr, S_IXUSR);
|
|
|
|
SETBIT (fp_dlg->rgrp, S_IRGRP);
|
|
SETBIT (fp_dlg->wgrp, S_IWGRP);
|
|
SETBIT (fp_dlg->xgrp, S_IXGRP);
|
|
|
|
SETBIT (fp_dlg->roth, S_IROTH);
|
|
SETBIT (fp_dlg->woth, S_IWOTH);
|
|
SETBIT (fp_dlg->xoth, S_IXOTH);
|
|
|
|
return umode;
|
|
|
|
#undef SETBIT
|
|
}
|
|
|
|
|
|
static void
|
|
perm_set_mode_label (GtkWidget *widget, gpointer data)
|
|
{
|
|
GnomeFilePropertyDialog *fp_dlg;
|
|
mode_t umode;
|
|
char s_mode[5];
|
|
|
|
fp_dlg = GNOME_FILE_PROPERTY_DIALOG (data);
|
|
umode = perm_get_umode (fp_dlg);
|
|
if (!fp_dlg->executable && (umode & (S_IXUSR | S_IXGRP | S_IXOTH))) {
|
|
fp_dlg->executable = TRUE;
|
|
switch_metadata_box (fp_dlg);
|
|
} else if (fp_dlg->executable && !(umode & (S_IXUSR | S_IXGRP | S_IXOTH))) {
|
|
fp_dlg->executable = FALSE;
|
|
switch_metadata_box (fp_dlg);
|
|
}
|
|
|
|
s_mode[0] = '0' + ((umode & (S_ISUID | S_ISGID | S_ISVTX)) >> 9);
|
|
s_mode[1] = '0' + ((umode & (S_IRUSR | S_IWUSR | S_IXUSR)) >> 6);
|
|
s_mode[2] = '0' + ((umode & (S_IRGRP | S_IWGRP | S_IXGRP)) >> 3);
|
|
s_mode[3] = '0' + ((umode & (S_IROTH | S_IWOTH | S_IXOTH)) >> 0);
|
|
s_mode[4] = 0;
|
|
gtk_label_set_text (GTK_LABEL (fp_dlg->mode_label), s_mode);
|
|
}
|
|
|
|
static GtkWidget *
|
|
perm_check_new (char *text, int state, GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
GtkWidget *check;
|
|
|
|
if (text)
|
|
check = gtk_check_button_new_with_label (text);
|
|
else
|
|
check = gtk_check_button_new ();
|
|
|
|
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (check), FALSE);
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), state ? TRUE : FALSE);
|
|
|
|
gtk_signal_connect (GTK_OBJECT (check), "toggled",
|
|
(GtkSignalFunc) perm_set_mode_label,
|
|
fp_dlg);
|
|
|
|
gtk_widget_show (check);
|
|
return check;
|
|
}
|
|
|
|
#define ATTACH(table, widget, left, right, top, bottom) \
|
|
gtk_table_attach (GTK_TABLE (table), widget, \
|
|
left, right, top, bottom, \
|
|
GTK_FILL | GTK_SHRINK, \
|
|
GTK_FILL | GTK_SHRINK, \
|
|
0, 0);
|
|
|
|
#define PERMSET(name, r, w, x, rmask, wmask, xmask, y) do { \
|
|
r = perm_check_new (NULL, fp_dlg->st.st_mode & rmask, fp_dlg); \
|
|
w = perm_check_new (NULL, fp_dlg->st.st_mode & wmask, fp_dlg); \
|
|
x = perm_check_new (NULL, fp_dlg->st.st_mode & xmask, fp_dlg); \
|
|
\
|
|
ATTACH (table, label_new (name, 0.0, 0.5), 0, 1, y, y + 1); \
|
|
ATTACH (table, r, 1, 2, y, y + 1); \
|
|
ATTACH (table, w, 2, 3, y, y + 1); \
|
|
ATTACH (table, x, 3, 4, y, y + 1); \
|
|
} while (0);
|
|
|
|
static GtkWidget *
|
|
perm_mode_new (GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
GtkWidget *frame;
|
|
GtkWidget *vbox;
|
|
GtkWidget *hbox;
|
|
GtkWidget *table;
|
|
gchar *mode;
|
|
|
|
frame = gtk_frame_new (_("File Permissions"));
|
|
|
|
vbox = gtk_vbox_new (FALSE, GNOME_PAD_SMALL);
|
|
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
|
|
gtk_container_add (GTK_CONTAINER (frame), vbox);
|
|
gtk_widget_show (vbox);
|
|
|
|
hbox = gtk_hbox_new (FALSE, 0);
|
|
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
|
|
gtk_widget_show (hbox);
|
|
|
|
gtk_box_pack_start (GTK_BOX (hbox), label_new (_("Current mode: "), 0.0, 0.5), FALSE, FALSE, 0);
|
|
|
|
fp_dlg->mode_label = label_new ("0000", 0.0, 0.5);
|
|
gtk_box_pack_start (GTK_BOX (hbox), fp_dlg->mode_label, FALSE, FALSE, 0);
|
|
|
|
table = gtk_table_new (4, 5, FALSE);
|
|
if (!fp_dlg->modifyable || S_ISLNK (fp_dlg->st.st_mode))
|
|
gtk_widget_set_sensitive (table, FALSE);
|
|
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
|
|
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
|
|
gtk_widget_show (table);
|
|
|
|
/* Headings */
|
|
|
|
ATTACH (table, label_new (_("Read"), 0.0, 0.5), 1, 2, 0, 1);
|
|
ATTACH (table, label_new (_("Write"), 0.0, 0.5), 2, 3, 0, 1);
|
|
ATTACH (table, label_new (_("Exec"), 0.0, 0.5), 3, 4, 0, 1);
|
|
ATTACH (table, label_new (_("Special"), 0.0, 0.5), 4, 5, 0, 1);
|
|
|
|
/* Permissions */
|
|
|
|
PERMSET (_("User"), fp_dlg->rusr, fp_dlg->wusr, fp_dlg->xusr, S_IRUSR, S_IWUSR, S_IXUSR, 1);
|
|
PERMSET (_("Group"), fp_dlg->rgrp, fp_dlg->wgrp, fp_dlg->xgrp, S_IRGRP, S_IWGRP, S_IXGRP, 2);
|
|
PERMSET (_("Other"), fp_dlg->roth, fp_dlg->woth, fp_dlg->xoth, S_IROTH, S_IWOTH, S_IXOTH, 3);
|
|
|
|
/* Special */
|
|
|
|
fp_dlg->suid = perm_check_new (_("Set UID"), fp_dlg->st.st_mode & S_ISUID, fp_dlg);
|
|
fp_dlg->sgid = perm_check_new (_("Set GID"), fp_dlg->st.st_mode & S_ISGID, fp_dlg);
|
|
fp_dlg->svtx = perm_check_new (_("Sticky"), fp_dlg->st.st_mode & S_ISVTX, fp_dlg);
|
|
|
|
ATTACH (table, fp_dlg->suid, 4, 5, 1, 2);
|
|
ATTACH (table, fp_dlg->sgid, 4, 5, 2, 3);
|
|
ATTACH (table, fp_dlg->svtx, 4, 5, 3, 4);
|
|
|
|
perm_set_mode_label (NULL, fp_dlg);
|
|
gtk_label_get (GTK_LABEL (fp_dlg->mode_label), &mode);
|
|
fp_dlg->mode_name = g_strdup (mode);
|
|
return frame;
|
|
}
|
|
|
|
#undef ATTACH
|
|
#undef PERMSET
|
|
|
|
static GtkWidget *
|
|
perm_owner_new (GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
GtkWidget *gentry;
|
|
struct passwd *passwd;
|
|
|
|
gentry = gtk_entry_new ();
|
|
|
|
if (fp_dlg->euid != 0)
|
|
gtk_widget_set_sensitive (gentry, FALSE);
|
|
passwd = getpwuid (fp_dlg->st.st_uid);
|
|
if (passwd) {
|
|
fp_dlg->user_name = passwd->pw_name;
|
|
gtk_entry_set_text (GTK_ENTRY (gentry), passwd->pw_name);
|
|
} else
|
|
gtk_entry_set_text (GTK_ENTRY (gentry), "<Unknown>");
|
|
|
|
return gentry;
|
|
}
|
|
static GtkWidget *
|
|
perm_group_new (GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
GtkWidget *gentry;
|
|
struct group *grp;
|
|
gchar grpnum [10];
|
|
gboolean grp_flag = FALSE;
|
|
gchar *grpname = NULL;
|
|
GList *templist;
|
|
GList *list = NULL;
|
|
|
|
|
|
/* Are we root? Do we own the file? */
|
|
/* In this case we can change it. */
|
|
/* A little bit of this was swiped from kfm. */
|
|
|
|
if ((fp_dlg->euid == 0) || (fp_dlg->st.st_uid == fp_dlg->euid)) {
|
|
gentry = gtk_combo_new ();
|
|
grp = getgrgid (fp_dlg->st.st_gid);
|
|
if (grp->gr_name)
|
|
fp_dlg->group_name = g_strdup (grp->gr_name);
|
|
else {
|
|
g_snprintf (grpnum, 9, "%d", grp->gr_gid);
|
|
fp_dlg->group_name = g_strdup (grpnum);
|
|
}
|
|
|
|
/* we change this, b/c we are able to set the egid, if we aren't in the group already */
|
|
grp = getgrgid (getegid());
|
|
if (grp) {
|
|
if (grp->gr_name)
|
|
grpname = grp->gr_name;
|
|
else {
|
|
g_snprintf (grpnum, 9, "%d", grp->gr_gid);
|
|
grpname = grpnum;
|
|
}
|
|
}
|
|
if (fp_dlg->euid != 0)
|
|
gtk_editable_set_editable (GTK_EDITABLE (GTK_COMBO (gentry)->entry), FALSE);
|
|
for (setgrent (); (grp = getgrent ()) != NULL;) {
|
|
if (!grp_flag && grpname && !strcmp (grp->gr_name, grpname)) {
|
|
list = g_list_insert_sorted (list, g_strdup (grp->gr_name), (GCompareFunc)strcmp);
|
|
grp_flag = TRUE;
|
|
continue;
|
|
}
|
|
if (fp_dlg->euid == 0) {
|
|
list = g_list_insert_sorted (list, g_strdup (grp->gr_name), (GCompareFunc)strcmp);
|
|
} else {
|
|
gchar **members = grp->gr_mem;
|
|
gchar *member;
|
|
while ((member = *members) != 0L) {
|
|
if (!strcmp (member, fp_dlg->user_name)) {
|
|
list = g_list_insert_sorted (list, g_strdup (grp->gr_name), (GCompareFunc)strcmp);
|
|
break;
|
|
}
|
|
++members;
|
|
}
|
|
}
|
|
}
|
|
endgrent ();
|
|
|
|
/* we also might want to add the egid to the list. */
|
|
if (!grp_flag)
|
|
list = g_list_insert_sorted (list, g_strdup (grpname), (GCompareFunc)strcmp);
|
|
|
|
/* Now we have a list. We should make our option menu. */
|
|
gtk_combo_set_popdown_strings (GTK_COMBO (gentry), list);
|
|
for (templist = list; templist; templist = templist->next) {
|
|
g_free (templist->data);
|
|
}
|
|
grp = getgrgid (fp_dlg->st.st_gid);
|
|
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (gentry)->entry), grp->gr_name);
|
|
g_list_free (list);
|
|
} else {
|
|
/* we're neither so we just put an entry down */
|
|
gentry = gtk_entry_new ();
|
|
gtk_widget_set_sensitive (gentry, FALSE);
|
|
grp = getgrgid (fp_dlg->st.st_gid);
|
|
gtk_entry_set_text (GTK_ENTRY (gentry), grp->gr_name);
|
|
}
|
|
return gentry;
|
|
}
|
|
|
|
static GtkWidget *
|
|
perm_ownership_new (GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
GtkWidget *frame;
|
|
GtkWidget *table;
|
|
|
|
frame = gtk_frame_new ("File ownership");
|
|
|
|
table = gtk_table_new (2, 2, FALSE);
|
|
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
|
|
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
|
|
gtk_container_add (GTK_CONTAINER (frame), table);
|
|
gtk_widget_show (table);
|
|
|
|
/* Owner */
|
|
|
|
gtk_table_attach (GTK_TABLE (table), label_new (_("Owner"), 0.0, 0.5),
|
|
0, 1, 0, 1,
|
|
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK,
|
|
0, 0);
|
|
|
|
fp_dlg->owner_entry = perm_owner_new (fp_dlg);
|
|
gtk_table_attach (GTK_TABLE (table), fp_dlg->owner_entry,
|
|
1, 2, 0, 1,
|
|
GTK_EXPAND | GTK_FILL | GTK_SHRINK,
|
|
GTK_FILL | GTK_SHRINK,
|
|
0, 0);
|
|
gtk_widget_show (fp_dlg->owner_entry);
|
|
|
|
/* Group */
|
|
|
|
gtk_table_attach (GTK_TABLE (table), label_new (_("Group"), 0.0, 0.5),
|
|
0, 1, 1, 2,
|
|
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK,
|
|
0, 0);
|
|
|
|
fp_dlg->group_entry = perm_group_new (fp_dlg);
|
|
gtk_table_attach (GTK_TABLE (table), fp_dlg->group_entry,
|
|
1, 2, 1, 2,
|
|
GTK_EXPAND | GTK_FILL | GTK_SHRINK,
|
|
GTK_FILL | GTK_SHRINK,
|
|
0, 0);
|
|
gtk_widget_show (fp_dlg->group_entry);
|
|
return frame;
|
|
}
|
|
|
|
static GtkWidget *
|
|
create_perm_properties (GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
GtkWidget *vbox;
|
|
|
|
vbox = gtk_vbox_new (FALSE, GNOME_PAD_SMALL);
|
|
gtk_container_set_border_width (GTK_CONTAINER (vbox), GNOME_PAD);
|
|
gtk_box_pack_start (GTK_BOX (vbox), perm_mode_new (fp_dlg), FALSE, FALSE, 0);
|
|
gtk_box_pack_start (GTK_BOX (vbox), perm_ownership_new (fp_dlg), TRUE, TRUE, 0);
|
|
return vbox;
|
|
}
|
|
/* finally the new dialog */
|
|
static void
|
|
init_metadata (GnomeFilePropertyDialog *fp_dlg)
|
|
{
|
|
gint size;
|
|
gchar *mime_type;
|
|
|
|
if (gnome_metadata_get (fp_dlg->file_name, "fm-open", &size, &fp_dlg->fm_open) != 0)
|
|
gnome_metadata_get (fp_dlg->file_name, "open", &size, &fp_dlg->fm_open);
|
|
if (gnome_metadata_get (fp_dlg->file_name, "fm-view", &size, &fp_dlg->fm_view) != 0)
|
|
gnome_metadata_get (fp_dlg->file_name, "view", &size, &fp_dlg->fm_view);
|
|
gnome_metadata_get (fp_dlg->file_name, "edit", &size, &fp_dlg->edit);
|
|
gnome_metadata_get (fp_dlg->file_name, "drop-target", &size, &fp_dlg->drop_target);
|
|
|
|
mime_type = gnome_mime_type_or_default (fp_dlg->file_name, NULL);
|
|
if (!mime_type)
|
|
return;
|
|
fp_dlg->mime_fm_open = gnome_mime_get_value (mime_type, "fm-open");
|
|
if (!fp_dlg->mime_fm_open)
|
|
fp_dlg->mime_fm_open = gnome_mime_get_value (mime_type, "open");
|
|
fp_dlg->mime_fm_view = gnome_mime_get_value (mime_type, "fm-view");
|
|
if (!fp_dlg->mime_fm_view)
|
|
fp_dlg->mime_fm_view = gnome_mime_get_value (mime_type, "view");
|
|
fp_dlg->mime_edit = gnome_mime_get_value (mime_type, "edit");
|
|
fp_dlg->mime_edit = gnome_mime_get_value (mime_type, "drop-target");
|
|
g_print ("mime_type:%s:\n", mime_type);
|
|
g_print ("fm-open:%s:\n", fp_dlg->fm_open);
|
|
g_print ("fm-view:%s:\n", fp_dlg->fm_view);
|
|
g_print ("edit:%s:\n", fp_dlg->edit);
|
|
g_print ("drop-target:%s:\n", fp_dlg->drop_target);
|
|
g_print ("mime-fm-open:%s:\n", fp_dlg->mime_fm_open);
|
|
g_print ("mime-fm-view:%s:\n", fp_dlg->mime_fm_view);
|
|
g_print ("mime-edit:%s:\n", fp_dlg->mime_edit);
|
|
g_print ("mime-drop-target:%s:\n", fp_dlg->mime_drop_target);
|
|
|
|
}
|
|
GtkWidget *
|
|
gnome_file_property_dialog_new (gchar *file_name)
|
|
{
|
|
GnomeFilePropertyDialog *fp_dlg;
|
|
GtkWidget *notebook;
|
|
gchar *title_string;
|
|
gint size;
|
|
|
|
|
|
g_return_val_if_fail (file_name != NULL, NULL);
|
|
fp_dlg = gtk_type_new (gnome_file_property_dialog_get_type ());
|
|
|
|
/* We set non-gui specific things first */
|
|
if (mc_lstat (file_name, &fp_dlg->st) == -1) {
|
|
/* Bad things man, bad things */
|
|
gtk_object_unref (GTK_OBJECT (fp_dlg));
|
|
return NULL;
|
|
}
|
|
|
|
|
|
if (fp_dlg->st.st_mode & (S_IXUSR | S_IXGRP |S_IXOTH)) {
|
|
fp_dlg->executable = TRUE;
|
|
} else {
|
|
fp_dlg->executable = FALSE;
|
|
}
|
|
|
|
fp_dlg->file_name = g_strdup (file_name);
|
|
fp_dlg->euid = geteuid ();
|
|
if (S_ISCHR (fp_dlg->st.st_mode) || S_ISBLK (fp_dlg->st.st_mode)
|
|
|| ((fp_dlg->euid != fp_dlg->st.st_uid) && (fp_dlg->euid != 0)))
|
|
fp_dlg->modifyable = FALSE;
|
|
init_metadata (fp_dlg);
|
|
|
|
/* and now, we set up the gui. */
|
|
notebook = gtk_notebook_new ();
|
|
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
|
|
create_general_properties (fp_dlg),
|
|
gtk_label_new (_("Statistics")));
|
|
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
|
|
create_settings_pane (fp_dlg),
|
|
gtk_label_new (_("Options")));
|
|
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
|
|
create_perm_properties (fp_dlg),
|
|
gtk_label_new (_("Permissions")));
|
|
gtk_box_pack_start (GTK_BOX (GNOME_DIALOG (fp_dlg)->vbox),
|
|
notebook, TRUE, TRUE, 0);
|
|
title_string = g_strconcat (rindex (file_name, '/') + 1, _(" Properties"), NULL);
|
|
gtk_window_set_title (GTK_WINDOW (fp_dlg), title_string);
|
|
g_free (title_string);
|
|
gnome_dialog_append_button ( GNOME_DIALOG(fp_dlg),
|
|
GNOME_STOCK_BUTTON_OK);
|
|
gnome_dialog_append_button ( GNOME_DIALOG(fp_dlg),
|
|
GNOME_STOCK_BUTTON_CANCEL);
|
|
gtk_widget_show_all (GNOME_DIALOG (fp_dlg)->vbox);
|
|
|
|
return GTK_WIDGET (fp_dlg);
|
|
}
|
|
static gint
|
|
apply_mode_change (GnomeFilePropertyDialog *fpd)
|
|
{
|
|
gchar *new_mode;
|
|
gtk_label_get (GTK_LABEL (fpd->mode_label), &new_mode);
|
|
if (strcmp (new_mode, fpd->mode_name)) {
|
|
mc_chmod (fpd->file_name, (mode_t) strtol(new_mode, (char **)NULL, 8));
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
static gint
|
|
apply_uid_group_change (GnomeFilePropertyDialog *fpd)
|
|
{
|
|
uid_t uid;
|
|
gid_t gid;
|
|
struct passwd *p;
|
|
struct group *g;
|
|
gchar *new_user_name = NULL;
|
|
gchar *new_group_name = NULL;
|
|
|
|
uid = fpd->st.st_uid;
|
|
gid = fpd->st.st_gid;
|
|
|
|
/* we only check if our euid == 0 */
|
|
if (fpd->euid == 0) {
|
|
new_user_name = gtk_entry_get_text (GTK_ENTRY (fpd->owner_entry));
|
|
if (new_user_name && strcmp (fpd->user_name, new_user_name)) {
|
|
/* now we need to get the new uid */
|
|
p = getpwnam (new_user_name);
|
|
if (!p) {
|
|
uid = atoi (new_user_name);
|
|
if (uid == 0) {
|
|
message (1, "Error", _("You entered an invalid username"));
|
|
uid = fpd->st.st_uid;
|
|
}
|
|
} else
|
|
uid = p->pw_uid;
|
|
}
|
|
|
|
}
|
|
|
|
/* now we check the group */
|
|
new_group_name = gtk_entry_get_text (GTK_ENTRY (GTK_COMBO (fpd->group_entry)->entry));
|
|
|
|
if (fpd->group_name && new_group_name && strcmp (fpd->group_name, new_group_name)) {
|
|
g = getgrnam (new_group_name);
|
|
if (!g) {
|
|
gid = atoi (new_group_name);
|
|
if (gid == 0) {
|
|
message (1, "Error", "You entered an invalid group name");
|
|
gid = fpd->st.st_gid;
|
|
}
|
|
} else
|
|
gid = g->gr_gid;
|
|
}
|
|
if ((uid != fpd->st.st_uid) || (gid != fpd->st.st_gid)) {
|
|
mc_chown (fpd->file_name, uid, gid);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
static gint
|
|
apply_name_change (GnomeFilePropertyDialog *fpd)
|
|
{
|
|
gchar *new_name;
|
|
gchar *base_name;
|
|
gchar *full_target;
|
|
FileOpContext *ctx;
|
|
long count = 0;
|
|
double bytes = 0;
|
|
|
|
new_name = gtk_entry_get_text (GTK_ENTRY (fpd->file_entry));
|
|
if (!*new_name) {
|
|
message (1, "Error", _("You must rename your file to something"));
|
|
return 0;
|
|
}
|
|
/* has it changed? */
|
|
if (strcmp (rindex(fpd->file_name, '/') + 1, new_name)) {
|
|
if (strchr (new_name, '/')) {
|
|
message (1, "Error", _("You cannot rename a file to something containing a '/' character"));
|
|
return 0;
|
|
} else {
|
|
/* create the files. */
|
|
base_name = g_strdup (fpd->file_name);
|
|
rindex (base_name, '/')[0] = '\0';
|
|
full_target = concat_dir_and_file (base_name, new_name);
|
|
|
|
ctx = file_op_context_new ();
|
|
file_op_context_create_ui (ctx, OP_MOVE, FALSE);
|
|
move_file_file (ctx, fpd->file_name, full_target, &count, &bytes);
|
|
file_op_context_destroy (ctx);
|
|
g_free (full_target);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
static gint
|
|
apply_metadata_change (GnomeFilePropertyDialog *fpd)
|
|
{
|
|
gchar *text;
|
|
if (fpd->executable) {
|
|
if (!GTK_TOGGLE_BUTTON (fpd->prop1_cbox)->active) {
|
|
text = gtk_entry_get_text (GTK_ENTRY (fpd->prop1_entry));
|
|
if (text && text[0])
|
|
gnome_metadata_set (fpd->file_name,
|
|
"fm_open",
|
|
strlen (text) + 1,
|
|
text);
|
|
else
|
|
gnome_metadata_remove (fpd->file_name,
|
|
"fm_open");
|
|
} else {
|
|
if (fpd->fm_open)
|
|
gnome_metadata_remove (fpd->file_name,
|
|
"fm_open");
|
|
}
|
|
if (!GTK_TOGGLE_BUTTON (fpd->prop2_cbox)->active) {
|
|
text = gtk_entry_get_text (GTK_ENTRY (fpd->prop2_entry));
|
|
if (text && text[0])
|
|
gnome_metadata_set (fpd->file_name,
|
|
"drop-target",
|
|
strlen (text) + 1,
|
|
text);
|
|
else
|
|
gnome_metadata_remove (fpd->file_name,
|
|
"drop-target");
|
|
} else {
|
|
if (fpd->drop_target)
|
|
gnome_metadata_remove (fpd->file_name,
|
|
"drop-target");
|
|
}
|
|
} else {
|
|
if (!GTK_TOGGLE_BUTTON (fpd->prop1_cbox)->active) {
|
|
text = gtk_entry_get_text (GTK_ENTRY (fpd->prop1_entry));
|
|
if (text && text[0])
|
|
gnome_metadata_set (fpd->file_name,
|
|
"fm-view",
|
|
strlen (text) + 1,
|
|
text);
|
|
else
|
|
gnome_metadata_remove (fpd->file_name,
|
|
"fm-view");
|
|
} else {
|
|
if (fpd->fm_view)
|
|
gnome_metadata_remove (fpd->file_name,
|
|
"fm-view");
|
|
}
|
|
if (!GTK_TOGGLE_BUTTON (fpd->prop2_cbox)->active) {
|
|
text = gtk_entry_get_text (GTK_ENTRY (fpd->prop2_entry));
|
|
if (text && text[0])
|
|
gnome_metadata_set (fpd->file_name,
|
|
"edit",
|
|
strlen (text) + 1,
|
|
text);
|
|
else
|
|
gnome_metadata_remove (fpd->file_name,
|
|
"edit");
|
|
} else {
|
|
if (fpd->edit)
|
|
gnome_metadata_remove (fpd->file_name,
|
|
"edit");
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* This function will apply what changes it can do. It is meant to be used in conjunction
|
|
* with a gnome_dialog_run_and_hide. Please note that doing a gnome_dialog_run
|
|
* will (obviously) cause greivious bogoness. */
|
|
|
|
gint
|
|
gnome_file_property_dialog_make_changes (GnomeFilePropertyDialog *file_property_dialog)
|
|
{
|
|
gint retval = 0;
|
|
g_return_val_if_fail (file_property_dialog != NULL, 1);
|
|
g_return_val_if_fail (GNOME_IS_FILE_PROPERTY_DIALOG (file_property_dialog), 1);
|
|
|
|
retval += apply_mode_change (file_property_dialog);
|
|
retval += apply_uid_group_change (file_property_dialog);
|
|
retval += apply_name_change (file_property_dialog);
|
|
retval += apply_metadata_change (file_property_dialog);
|
|
|
|
return retval;
|
|
}
|