mirror of
https://github.com/UberGames/GtkRadiant.git
synced 2024-11-29 15:11:54 +00:00
8037810110
git-svn-id: svn://svn.icculus.org/gtkradiant/GtkRadiant/branches/ZeroRadiant@177 8a3a26a2-13c4-0310-b231-cf6edde360e5
4987 lines
142 KiB
C
4987 lines
142 KiB
C
/* GTK - The GIMP Toolkit
|
|
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
/*
|
|
* Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
|
|
* file for a list of people on the GTK+ Team. See the ChangeLog
|
|
* files for a list of changes. These files are distributed with
|
|
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
|
|
*/
|
|
#define LEO
|
|
|
|
#ifdef LEO
|
|
#define _(a) a
|
|
|
|
static char * back_xpm[] = {
|
|
"14 14 33 1",
|
|
" c None",
|
|
". c #000000",
|
|
"+ c #C6D7C6",
|
|
"@ c #E7EBE7",
|
|
"# c #FFFFFF",
|
|
"$ c #DEEBDE",
|
|
"% c #F7F7F7",
|
|
"& c #DEE7DE",
|
|
"* c #EFF3EF",
|
|
"= c #101810",
|
|
"- c #B5C7AD",
|
|
"; c #EFEFEF",
|
|
"> c #D6E3D6",
|
|
", c #213021",
|
|
"' c #315931",
|
|
") c #52824A",
|
|
"! c #739A6B",
|
|
"~ c #84A673",
|
|
"{ c #7BA673",
|
|
"] c #84AA73",
|
|
"^ c #84AA7B",
|
|
"/ c #84AE7B",
|
|
"( c #63925A",
|
|
"_ c #526D4A",
|
|
": c #4A7D42",
|
|
"< c #739E6B",
|
|
"[ c #739A63",
|
|
"} c #4A7539",
|
|
"| c #638E52",
|
|
"1 c #427139",
|
|
"2 c #6BA663",
|
|
"3 c #5A8A52",
|
|
"4 c #315929",
|
|
" ..",
|
|
" ..+.",
|
|
" ..@#+.",
|
|
" ..$#%%+.",
|
|
" ..&#%*%%+.",
|
|
" .=&#******+.",
|
|
"..-#;>&@****+,",
|
|
"..')!~{]^/^/(.",
|
|
" .._:<^~^/^(.",
|
|
" ..':[]~/(.",
|
|
" ..}:[~|.",
|
|
" ..123.",
|
|
" ..4.",
|
|
" .."};
|
|
|
|
static char * up_xpm[] = {
|
|
"14 14 36 1",
|
|
" c None",
|
|
". c #000000",
|
|
"+ c #181C18",
|
|
"@ c #D6DBD6",
|
|
"# c #94AA8C",
|
|
"$ c #000400",
|
|
"% c #DEDFDE",
|
|
"& c #94AA84",
|
|
"* c #E7E3E7",
|
|
"= c #94B28C",
|
|
"- c #6B865A",
|
|
"; c #EFEBEF",
|
|
"> c #9CB694",
|
|
", c #8CA684",
|
|
"' c #EFEFEF",
|
|
") c #F7EFF7",
|
|
"! c #9CB68C",
|
|
"~ c #63865A",
|
|
"{ c #94B684",
|
|
"] c #94AE84",
|
|
"^ c #739263",
|
|
"/ c #F7F3F7",
|
|
"( c #94B284",
|
|
"_ c #849E73",
|
|
": c #8CAE7B",
|
|
"< c #8CAA84",
|
|
"[ c #7B966B",
|
|
"} c #8CA67B",
|
|
"| c #DEDBD6",
|
|
"1 c #E7E7E7",
|
|
"2 c #8CAE84",
|
|
"3 c #8CAA7B",
|
|
"4 c #738E63",
|
|
"5 c #BDBEB5",
|
|
"6 c #BDC3BD",
|
|
"7 c #637D52",
|
|
" .. ",
|
|
" .. ",
|
|
" +@#$ ",
|
|
" .%&. ",
|
|
" .**=-. ",
|
|
" .;;>,. ",
|
|
" .*')!&~. ",
|
|
" .;)){]^. ",
|
|
" .*')/(]_-. ",
|
|
" .;)//::<[. ",
|
|
" .*')//:::}-. ",
|
|
" .|1;;12]3}4. ",
|
|
".556666^^^^-7.",
|
|
".............."};
|
|
|
|
static char * forward_xpm[] = {
|
|
"14 14 36 1",
|
|
" c None",
|
|
". c #000000",
|
|
"+ c #E7EBDE",
|
|
"@ c #FFFFFF",
|
|
"# c #F7F7EF",
|
|
"$ c #D6E3D6",
|
|
"% c #F7F7F7",
|
|
"& c #EFF3EF",
|
|
"* c #CEDFCE",
|
|
"= c #CEDBC6",
|
|
"- c #E7EFE7",
|
|
"; c #181818",
|
|
"> c #292829",
|
|
", c #E7EBE7",
|
|
"' c #DEE7DE",
|
|
") c #B5C7AD",
|
|
"! c #9CBA94",
|
|
"~ c #8CAE84",
|
|
"{ c #84AA7B",
|
|
"] c #7BA673",
|
|
"^ c #84A67B",
|
|
"/ c #739A6B",
|
|
"( c #5A824A",
|
|
"_ c #395931",
|
|
": c #9CBA8C",
|
|
"< c #84AE7B",
|
|
"[ c #739E6B",
|
|
"} c #527D4A",
|
|
"| c #425942",
|
|
"1 c #84A673",
|
|
"2 c #4A7142",
|
|
"3 c #94B284",
|
|
"4 c #395D31",
|
|
"5 c #5A8652",
|
|
"6 c #315929",
|
|
"7 c #396531",
|
|
".. ",
|
|
".+.. ",
|
|
".@#$.. ",
|
|
".@%&#*.. ",
|
|
".@%%&&%=.. ",
|
|
".@&&&&&-#=;. ",
|
|
">@&&&&,'$'&)..",
|
|
".!~{~{{]^/(_..",
|
|
".:{<{^{[}|.. ",
|
|
".:<1{/}2.. ",
|
|
".31/}4.. ",
|
|
".{56.. ",
|
|
".7.. ",
|
|
".. "};
|
|
|
|
static char * refresh_xpm[] = {
|
|
"16 16 11 1",
|
|
" c None",
|
|
". c #000000",
|
|
"+ c #526942",
|
|
"@ c #4A6139",
|
|
"# c #526542",
|
|
"$ c #5A7142",
|
|
"% c #425531",
|
|
"& c #314529",
|
|
"* c #425131",
|
|
"= c #425931",
|
|
"- c #5A754A",
|
|
" . ",
|
|
" .. ",
|
|
" .+@... ",
|
|
" .#$##@%.. ",
|
|
" .+#...%%. ",
|
|
" . .. .&. ",
|
|
" . . .&. ",
|
|
" .. .. ",
|
|
" .. .. ",
|
|
" .*. . . ",
|
|
" .*. .. . ",
|
|
" .%@...#=. ",
|
|
" ..##-#@#. ",
|
|
" ...@%. ",
|
|
" .. ",
|
|
" . "};
|
|
|
|
#endif
|
|
|
|
#ifndef LEO
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/param.h>
|
|
#include <dirent.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <pwd.h>
|
|
#include <grp.h>
|
|
#include <time.h>
|
|
|
|
#include "fnmatch.h"
|
|
|
|
#if (defined TORRIE_DEBUG || defined LEO)
|
|
#include <gdk/gdkkeysyms.h>
|
|
#include <gtk/gtkbutton.h>
|
|
#include <gtk/gtkentry.h>
|
|
#include "gtkfilesel-linux.h"
|
|
#include <gtk/gtkhbox.h>
|
|
#include <gtk/gtkhbbox.h>
|
|
#include <gtk/gtklabel.h>
|
|
#include <gtk/gtklist.h>
|
|
#include <gtk/gtklistitem.h>
|
|
#include <gtk/gtkmain.h>
|
|
#include <gtk/gtkscrolledwindow.h>
|
|
#include <gtk/gtksignal.h>
|
|
#include <gtk/gtkvbox.h>
|
|
#include <gtk/gtkmenu.h>
|
|
#include <gtk/gtkmenuitem.h>
|
|
#include <gtk/gtkoptionmenu.h>
|
|
#include <gtk/gtkclist.h>
|
|
#include <gtk/gtkdialog.h>
|
|
#include <gtk/gtkcombo.h>
|
|
#include <gtk/gtkframe.h>
|
|
#include <gtk/gtkhpaned.h>
|
|
#include <gtk/gtktable.h>
|
|
#include <gtk/gtkpixmap.h>
|
|
#include <gtk/gtknotebook.h>
|
|
#include <gtk/gtkhseparator.h>
|
|
#include <gtk/gtktogglebutton.h>
|
|
#else
|
|
#include "gdk/gdkkeysyms.h"
|
|
#include "gtkbutton.h"
|
|
#include "gtkentry.h"
|
|
#include "gtkfilesel.h"
|
|
#include "gtkhbox.h"
|
|
#include "gtkhbbox.h"
|
|
#include "gtklabel.h"
|
|
#include "gtklist.h"
|
|
#include "gtklistitem.h"
|
|
#include "gtkmain.h"
|
|
#include "gtkscrolledwindow.h"
|
|
#include "gtksignal.h"
|
|
#include "gtkvbox.h"
|
|
#include "gtkmenu.h"
|
|
#include "gtkmenuitem.h"
|
|
#include "gtkoptionmenu.h"
|
|
#include "gtkclist.h"
|
|
#include "gtkdialog.h"
|
|
#include "gtkcombo.h"
|
|
#include "gtkframe.h"
|
|
#include "gtkhpaned.h"
|
|
#include "gtktable.h"
|
|
#include "gtkpixmap.h"
|
|
#include "gtknotebook.h"
|
|
#include "gtkhseparator.h"
|
|
#include "gtktogglebutton.h"
|
|
#endif
|
|
|
|
#ifndef LEO
|
|
#include "gtkintl.h"
|
|
|
|
#include "back.xpm"
|
|
#include "up.xpm"
|
|
#include "forward.xpm"
|
|
#include "refresh.xpm"
|
|
#endif
|
|
|
|
#define DIR_LIST_WIDTH 180
|
|
#define DIR_LIST_HEIGHT 180
|
|
#define FILE_LIST_WIDTH 180
|
|
#define FILE_LIST_HEIGHT 180
|
|
#define BOOKMARK_FILE "/.gtkfilesel_bookmarks"
|
|
#define MASK_FILE "/.gtkfilesel_masks"
|
|
#define TIME_STRING_BUF 50
|
|
|
|
/* I've put this here so it doesn't get confused with the
|
|
* file completion interface */
|
|
typedef struct _HistoryCallbackArg HistoryCallbackArg;
|
|
|
|
struct _HistoryCallbackArg
|
|
{
|
|
gchar *directory;
|
|
GtkWidget *menu_item;
|
|
};
|
|
|
|
|
|
typedef struct _BookmarkMenuStruct BookmarkMenuStruct;
|
|
struct _BookmarkMenuStruct {
|
|
GtkWidget *menu_item;
|
|
gchar *desc;
|
|
gchar *path;
|
|
};
|
|
|
|
typedef struct _CompletionState CompletionState;
|
|
typedef struct _CompletionDir CompletionDir;
|
|
typedef struct _CompletionDirSent CompletionDirSent;
|
|
typedef struct _CompletionDirEntry CompletionDirEntry;
|
|
typedef struct _CompletionUserDir CompletionUserDir;
|
|
typedef struct _PossibleCompletion PossibleCompletion;
|
|
|
|
/* Non-external file completion decls and structures */
|
|
|
|
/* A contant telling PRCS how many directories to cache. Its actually
|
|
* kept in a list, so the geometry isn't important. */
|
|
#define CMPL_DIRECTORY_CACHE_SIZE 10
|
|
|
|
/* A constant used to determine whether a substring was an exact
|
|
* match by first_diff_index()
|
|
*/
|
|
#define PATTERN_MATCH -1
|
|
/* The arguments used by all fnmatch() calls below
|
|
*/
|
|
#define FNMATCH_FLAGS (FNM_PATHNAME | FNM_PERIOD)
|
|
|
|
#define CMPL_ERRNO_TOO_LONG ((1<<16)-1)
|
|
|
|
/* This structure contains all the useful information about a directory
|
|
* for the purposes of filename completion. These structures are cached
|
|
* in the CompletionState struct. CompletionDir's are reference counted.
|
|
*/
|
|
struct _CompletionDirSent
|
|
{
|
|
ino_t inode;
|
|
time_t mtime;
|
|
dev_t device;
|
|
|
|
gint entry_count;
|
|
gchar *name_buffer; /* memory segment containing names of all entries */
|
|
|
|
struct _CompletionDirEntry *entries;
|
|
};
|
|
|
|
struct _CompletionDir
|
|
{
|
|
CompletionDirSent *sent;
|
|
|
|
gchar *fullname;
|
|
gint fullname_len;
|
|
|
|
struct _CompletionDir *cmpl_parent;
|
|
gint cmpl_index;
|
|
gchar *cmpl_text;
|
|
};
|
|
|
|
/* This structure contains pairs of directory entry names with a flag saying
|
|
* whether or not they are a valid directory. NOTE: This information is used
|
|
* to provide the caller with information about whether to update its completions
|
|
* or try to open a file. Since directories are cached by the directory mtime,
|
|
* a symlink which points to an invalid file (which will not be a directory),
|
|
* will not be reevaluated if that file is created, unless the containing
|
|
* directory is touched. I consider this case to be worth ignoring (josh).
|
|
*/
|
|
struct _CompletionDirEntry
|
|
{
|
|
gint is_dir;
|
|
gchar *entry_name;
|
|
};
|
|
|
|
struct _CompletionUserDir
|
|
{
|
|
gchar *login;
|
|
gchar *homedir;
|
|
};
|
|
|
|
struct _PossibleCompletion
|
|
{
|
|
/* accessible fields, all are accessed externally by functions
|
|
* declared above
|
|
*/
|
|
gchar *text;
|
|
gint is_a_completion;
|
|
gint is_directory;
|
|
|
|
gint file_size;
|
|
gint file_time;
|
|
gint uid;
|
|
gint gid;
|
|
/* Private fields
|
|
*/
|
|
gint text_alloc;
|
|
};
|
|
|
|
struct _CompletionState
|
|
{
|
|
gint last_valid_char;
|
|
gchar *updated_text;
|
|
gint updated_text_len;
|
|
gint updated_text_alloc;
|
|
gint re_complete;
|
|
|
|
gchar *user_dir_name_buffer;
|
|
gint user_directories_len;
|
|
|
|
gchar *last_completion_text;
|
|
|
|
gint user_completion_index; /* if >= 0, currently completing ~user */
|
|
|
|
struct _CompletionDir *completion_dir; /* directory completing from */
|
|
struct _CompletionDir *active_completion_dir;
|
|
|
|
struct _PossibleCompletion the_completion;
|
|
|
|
struct _CompletionDir *reference_dir; /* initial directory */
|
|
|
|
GList* directory_storage;
|
|
GList* directory_sent_storage;
|
|
|
|
struct _CompletionUserDir *user_directories;
|
|
};
|
|
|
|
/* Widgets from the Properties Dialog */
|
|
typedef struct _PropertiesPrivate PropertiesPrivate;
|
|
|
|
struct _PropertiesPrivate
|
|
{
|
|
GtkWidget *mode_label;
|
|
GtkWidget *mode_buttons[12];
|
|
};
|
|
|
|
/* pixmap creation function */
|
|
GtkWidget* create_pixmap (GtkWidget *widget,
|
|
const gchar *pixmap_char);
|
|
|
|
/* File completion functions which would be external, were they used
|
|
* outside of this file.
|
|
*/
|
|
|
|
static CompletionState* cmpl_init_state (void);
|
|
static void cmpl_free_state (CompletionState *cmpl_state);
|
|
static gint cmpl_state_okay (CompletionState* cmpl_state);
|
|
static gchar* cmpl_strerror (gint);
|
|
|
|
static PossibleCompletion* cmpl_completion_matches(gchar *text_to_complete,
|
|
gchar **remaining_text,
|
|
CompletionState *cmpl_state);
|
|
|
|
/* Returns a name for consideration, possibly a completion, this name
|
|
* will be invalid after the next call to cmpl_next_completion.
|
|
*/
|
|
static char* cmpl_this_completion (PossibleCompletion*);
|
|
|
|
/* True if this completion matches the given text. Otherwise, this
|
|
* output can be used to have a list of non-completions.
|
|
*/
|
|
static gint cmpl_is_a_completion (PossibleCompletion*);
|
|
|
|
/* True if the completion is a directory
|
|
*/
|
|
static gint cmpl_is_directory (PossibleCompletion*);
|
|
|
|
/* Obtains the next completion, or NULL
|
|
*/
|
|
static PossibleCompletion* cmpl_next_completion (CompletionState*);
|
|
|
|
/* Updating completions: the return value of cmpl_updated_text() will
|
|
* be text_to_complete completed as much as possible after the most
|
|
* recent call to cmpl_completion_matches. For the present
|
|
* application, this is the suggested replacement for the user's input
|
|
* string. You must CALL THIS AFTER ALL cmpl_text_completions have
|
|
* been received.
|
|
*/
|
|
static gchar* cmpl_updated_text (CompletionState* cmpl_state);
|
|
|
|
/* After updating, to see if the completion was a directory, call
|
|
* this. If it was, you should consider re-calling completion_matches.
|
|
*/
|
|
static gint cmpl_updated_dir (CompletionState* cmpl_state);
|
|
|
|
/* Current location: if using file completion, return the current
|
|
* directory, from which file completion begins. More specifically,
|
|
* the cwd concatenated with all exact completions up to the last
|
|
* directory delimiter('/').
|
|
*/
|
|
static gchar* cmpl_reference_position (CompletionState* cmpl_state);
|
|
|
|
/* backing up: if cmpl_completion_matches returns NULL, you may query
|
|
* the index of the last completable character into cmpl_updated_text.
|
|
*/
|
|
static gint cmpl_last_valid_char (CompletionState* cmpl_state);
|
|
|
|
/* When the user selects a non-directory, call cmpl_completion_fullname
|
|
* to get the full name of the selected file.
|
|
*/
|
|
static gchar* cmpl_completion_fullname (gchar*, CompletionState* cmpl_state);
|
|
|
|
|
|
/* Directory operations. */
|
|
static CompletionDir* open_ref_dir (gchar* text_to_complete,
|
|
gchar** remaining_text,
|
|
CompletionState* cmpl_state);
|
|
static gboolean check_dir (gchar *dir_name,
|
|
struct stat *result,
|
|
gboolean *stat_subdirs);
|
|
static CompletionDir* open_dir (gchar* dir_name,
|
|
CompletionState* cmpl_state);
|
|
static CompletionDir* open_user_dir (gchar* text_to_complete,
|
|
CompletionState *cmpl_state);
|
|
static CompletionDir* open_relative_dir (gchar* dir_name, CompletionDir* dir,
|
|
CompletionState *cmpl_state);
|
|
static CompletionDirSent* open_new_dir (gchar* dir_name,
|
|
struct stat* sbuf,
|
|
gboolean stat_subdirs);
|
|
static gint correct_dir_fullname (CompletionDir* cmpl_dir);
|
|
static gint correct_parent (CompletionDir* cmpl_dir,
|
|
struct stat *sbuf);
|
|
static gchar* find_parent_dir_fullname (gchar* dirname);
|
|
static CompletionDir* attach_dir (CompletionDirSent* sent,
|
|
gchar* dir_name,
|
|
CompletionState *cmpl_state);
|
|
static void free_dir_sent (CompletionDirSent* sent);
|
|
static void free_dir (CompletionDir *dir);
|
|
static void prune_memory_usage(CompletionState *cmpl_state);
|
|
|
|
/* Completion operations */
|
|
static PossibleCompletion* attempt_homedir_completion(gchar* text_to_complete,
|
|
CompletionState *cmpl_state);
|
|
static PossibleCompletion* attempt_file_completion(CompletionState *cmpl_state);
|
|
static CompletionDir* find_completion_dir(gchar* text_to_complete,
|
|
gchar** remaining_text,
|
|
CompletionState* cmpl_state);
|
|
static PossibleCompletion* append_completion_text(gchar* text,
|
|
CompletionState* cmpl_state);
|
|
static gint get_pwdb(CompletionState* cmpl_state);
|
|
static gint first_diff_index(gchar* pat, gchar* text);
|
|
static gint compare_user_dir(const void* a, const void* b);
|
|
static gint compare_cmpl_dir(const void* a, const void* b);
|
|
static void update_cmpl(PossibleCompletion* poss,
|
|
CompletionState* cmpl_state);
|
|
|
|
static void gtk_file_selection_class_init (GtkFileSelectionClass *klass);
|
|
static void gtk_file_selection_init (GtkFileSelection *filesel);
|
|
static void gtk_file_selection_realize (GtkWidget *widget);
|
|
static void gtk_file_selection_destroy (GtkObject *object);
|
|
static gint gtk_file_selection_key_press (GtkWidget *widget,
|
|
GdkEventKey *event,
|
|
gpointer user_data);
|
|
|
|
static void gtk_file_selection_file_button (GtkWidget *widget,
|
|
gint row,
|
|
gint column,
|
|
GdkEventButton *bevent,
|
|
gpointer user_data);
|
|
|
|
static void gtk_file_selection_dir_button (GtkWidget *widget,
|
|
gint row,
|
|
gint column,
|
|
GdkEventButton *bevent,
|
|
gpointer data);
|
|
|
|
static void gtk_file_selection_undir_button (GtkWidget *widget,
|
|
gint row,
|
|
gint column,
|
|
GdkEventButton *bevent,
|
|
gpointer data);
|
|
|
|
static void gtk_file_selection_populate (GtkFileSelection *fs,
|
|
gchar *rel_path,
|
|
gint try_complete);
|
|
static void gtk_file_selection_abort (GtkFileSelection *fs);
|
|
|
|
static void gtk_file_selection_update_history_menu (GtkFileSelection *fs,
|
|
gchar *current_dir);
|
|
|
|
static void gtk_file_selection_create_dir (gpointer data);
|
|
static void gtk_file_selection_delete_file (gpointer data);
|
|
static void gtk_file_selection_rename_file (gpointer data);
|
|
static void gtk_file_selection_properties (gpointer data);
|
|
static void gtk_file_selection_properties_update_mode (GtkWidget *widget, gpointer data);
|
|
static mode_t gtk_file_selection_properties_get_mode (PropertiesPrivate* private);
|
|
|
|
static gboolean gtk_file_selection_history_combo_callback (GtkWidget *widget, GdkEventKey *event, gpointer data);
|
|
static gboolean gtk_file_selection_history_combo_list_key_handler(GtkWidget *widget,
|
|
GdkEventKey *event,
|
|
gpointer user_data);
|
|
static gboolean gtk_file_selection_history_combo_list_callback (GtkWidget *thelist,
|
|
GdkEventButton *event,
|
|
|
|
gpointer user_data);
|
|
static void gtk_file_selection_bookmark_callback (GtkWidget *widget, gpointer data);
|
|
static void gtk_file_selection_mask_entry_callback (GtkWidget *widget, gpointer data);
|
|
static gint gtk_file_selection_mask_entry_key_callback (GtkWidget *widget, GdkEventKey *event, gpointer data);
|
|
static gint gtk_file_selection_mask_entry_button_callback (GtkWidget *widget, GdkEventButton *event, gpointer data);
|
|
|
|
//static void gtk_file_selection_home_button (GtkWidget *widget, gpointer data);
|
|
static void gtk_file_selection_bookmark_button (GtkWidget *widget,
|
|
GtkFileSelection *fs);
|
|
|
|
static void gtk_file_selection_up_button (GtkWidget *widget, gpointer data);
|
|
static void gtk_file_selection_prev_button (GtkWidget *widget, gpointer data);
|
|
static void gtk_file_selection_next_button (GtkWidget *widget, gpointer data);
|
|
static void gtk_file_selection_refresh_button (GtkWidget *widget, gpointer data);
|
|
|
|
static gint gtk_file_selection_files_list_key_callback (GtkWidget *widget, GdkEventKey *event, gpointer data);
|
|
|
|
|
|
static gint gtk_file_selection_match_char (gchar, gchar *mask);
|
|
static gint gtk_file_selection_match_mask (gchar *,gchar *);
|
|
|
|
static void gtk_file_selection_load_bookmarks(GtkFileSelection *fs);
|
|
static void gtk_file_selection_add_bookmark (GtkFileSelection *fs, gchar *desc, gchar *path);
|
|
gint gtk_file_selection_save_bookmarks (GtkFileSelection *fs);
|
|
|
|
static void gtk_file_selection_load_masks(GtkFileSelection *fs);
|
|
|
|
static gint gtk_file_selection_show_fileop_menu (GtkCList *clist,
|
|
GdkEvent *event,
|
|
GtkFileSelection *fs);
|
|
|
|
|
|
static GtkWindowClass *parent_class = NULL;
|
|
|
|
/* Saves errno when something cmpl does fails. */
|
|
static gint cmpl_errno;
|
|
|
|
#ifdef G_WITH_CYGWIN
|
|
/*
|
|
* Take the path currently in the file selection
|
|
* entry field and translate as necessary from
|
|
* a WIN32 style to CYGWIN32 style path. For
|
|
* instance translate:
|
|
* x:\somepath\file.jpg
|
|
* to:
|
|
* //x/somepath/file.jpg
|
|
*
|
|
* Replace the path in the selection text field.
|
|
* Return a boolean value concerning whether a
|
|
* translation had to be made.
|
|
*/
|
|
int
|
|
translate_win32_path (GtkFileSelection *filesel)
|
|
{
|
|
int updated = 0;
|
|
gchar *path;
|
|
|
|
/*
|
|
* Retrieve the current path
|
|
*/
|
|
path = gtk_entry_get_text (GTK_ENTRY (filesel->selection_entry));
|
|
|
|
/*
|
|
* Translate only if this looks like a DOS-ish
|
|
* path... First handle any drive letters.
|
|
*/
|
|
if (isalpha (path[0]) && (path[1] == ':')) {
|
|
/*
|
|
* This part kind of stinks... It isn't possible
|
|
* to know if there is enough space in the current
|
|
* string for the extra character required in this
|
|
* conversion. Assume that there isn't enough space
|
|
* and use the set function on the text field to
|
|
* set the newly created string.
|
|
*/
|
|
gchar *newPath = g_strdup_printf ("//%c/%s", path[0], (path + 3));
|
|
gtk_entry_set_text (GTK_ENTRY (filesel->selection_entry), newPath);
|
|
|
|
path = newPath;
|
|
updated = 1;
|
|
}
|
|
|
|
/*
|
|
* Now, replace backslashes with forward slashes
|
|
* if necessary.
|
|
*/
|
|
if (strchr (path, '\\'))
|
|
{
|
|
int index;
|
|
for (index = 0; path[index] != '\0'; index++)
|
|
if (path[index] == '\\')
|
|
path[index] = '/';
|
|
|
|
updated = 1;
|
|
}
|
|
|
|
return updated;
|
|
}
|
|
#endif
|
|
|
|
/* General notes:
|
|
* Make prev and next inactive if their respective *
|
|
* histories are empty.
|
|
* Add facilities for handling hidden files and *
|
|
* directories *
|
|
* Add an api to access the mask, and hidden files *
|
|
* check box? (prob not in 1.2.x series) *
|
|
*/
|
|
|
|
/* Routine for applying mask to filenames *
|
|
* Need to be optimized to minimize recursion *
|
|
* help the for loop by looking for the next *
|
|
* instance of the mask character following *
|
|
* the '*'. ei *.c -- look for '.' *
|
|
* Also, swap all *? pairs (-> ?*), as that *
|
|
* will make it possible to look ahead (? *
|
|
* makes it very nondeterministic as in *?.c *
|
|
* which really is ?*.c *
|
|
* *
|
|
*/
|
|
static gint gtk_file_selection_match_char (gchar text, gchar *mask)
|
|
{
|
|
gchar *maskc;
|
|
gint x;
|
|
gint s;
|
|
gchar lastc;
|
|
gchar nextc;
|
|
|
|
if (mask[0] == '[')
|
|
{
|
|
if (!strchr (mask,']')) return 0;
|
|
lastc = 0;
|
|
|
|
maskc = g_strdup(mask + 1); /* get the portion of mask inside []*/
|
|
(*(strchr (maskc + 1,']'))) = 0;
|
|
s = strlen ((char *)maskc);
|
|
|
|
for (x = 0 ; x < s ; x ++){
|
|
if (maskc[x] == '-')
|
|
{
|
|
if (x == s) return 1;
|
|
nextc = maskc[x + 1];
|
|
|
|
if (nextc > lastc)
|
|
{
|
|
if ((lastc <= text) && (nextc >= text))
|
|
{
|
|
g_free (maskc);
|
|
return s + 2;
|
|
}
|
|
}
|
|
else if ((lastc >= text) && (nextc <= text))
|
|
{
|
|
g_free (maskc);
|
|
return s + 2;
|
|
}
|
|
}
|
|
else if (text == maskc[x])
|
|
{
|
|
g_free (maskc);
|
|
return s + 2;
|
|
}
|
|
lastc = maskc[x];
|
|
}
|
|
g_free (maskc);
|
|
|
|
return 0;
|
|
}
|
|
|
|
if (mask[0] == '?') return 1;
|
|
if (mask[0] == text) return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static gint gtk_file_selection_match_mask1 (gchar *text, gchar *mask)
|
|
{
|
|
|
|
int mc;
|
|
int tc;
|
|
|
|
tc = 0; mc = 0;
|
|
|
|
if (mask[0] == 0 && text[0] == 0) return 1;
|
|
|
|
if (mask[0] == '*')
|
|
{
|
|
for (tc = 0; tc <= strlen(text); tc++)
|
|
{
|
|
if (gtk_file_selection_match_mask1 (text + tc, mask + 1))
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
mc = gtk_file_selection_match_char (text[0], mask);
|
|
|
|
if(mc)
|
|
return gtk_file_selection_match_mask1 (text + 1, mask + mc);
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
static gint gtk_file_selection_match_mask (gchar *text, gchar *mask)
|
|
{
|
|
gchar *masks;
|
|
gchar *bmask;
|
|
gchar *emask;
|
|
|
|
masks=g_strdup(mask);
|
|
|
|
emask=strchr(masks,'<');
|
|
if(emask){
|
|
bmask=emask+1;
|
|
emask=strchr(bmask,'>');
|
|
if(emask){
|
|
*emask=0;
|
|
}
|
|
}else{
|
|
bmask=masks;
|
|
}
|
|
|
|
do{
|
|
if((emask=strchr(bmask,',')) || (emask=strchr(bmask,';'))){
|
|
*emask=0;
|
|
if (gtk_file_selection_match_mask1 (text, bmask)){
|
|
g_free(masks);
|
|
return 1;
|
|
}
|
|
|
|
bmask=emask+1;
|
|
}
|
|
}while(emask);
|
|
|
|
if(gtk_file_selection_match_mask1 (text, bmask)){
|
|
g_free(masks);
|
|
return 1;
|
|
}
|
|
g_free(masks);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_load_bookmarks(GtkFileSelection *fs)
|
|
{
|
|
GList *list;
|
|
gchar *bookmark_file;
|
|
gchar *bookmark_data;
|
|
struct stat file_info;
|
|
gint file;
|
|
gint lp;
|
|
gint cp;
|
|
BookmarkMenuStruct *item;
|
|
|
|
|
|
if(fs->bookmark_list){ //erase
|
|
list=fs->bookmark_list;
|
|
while(list){
|
|
item=list->data;
|
|
g_free(item->desc);
|
|
g_free(item->path);
|
|
g_free(item);
|
|
list=list->next;
|
|
}
|
|
g_list_free (fs->bookmark_list);
|
|
fs->bookmark_list = NULL;
|
|
gtk_widget_destroy (fs->bookmark_menu);
|
|
}
|
|
|
|
fs->bookmark_menu=gtk_menu_new();
|
|
|
|
/* spacer */
|
|
item=g_malloc(sizeof(item));
|
|
item->menu_item = gtk_menu_item_new();
|
|
gtk_widget_show(item->menu_item);
|
|
gtk_menu_append (GTK_MENU(fs->bookmark_menu), item->menu_item);
|
|
|
|
item=g_malloc(sizeof(item));
|
|
item->desc=g_strdup("Add bookmark");
|
|
item->path=g_strdup(".");
|
|
item->menu_item=gtk_menu_item_new_with_label (item->desc);
|
|
gtk_widget_show(item->menu_item);
|
|
//fs->bookmark_list=g_list_append(fs->bookmark_list,item);
|
|
//set signal here!!
|
|
gtk_menu_append (GTK_MENU(fs->bookmark_menu), item->menu_item);
|
|
|
|
item=g_malloc(sizeof(item));
|
|
item->desc=g_strdup("Edit bookmark");
|
|
item->path=g_strdup(".");
|
|
item->menu_item=gtk_menu_item_new_with_label (item->desc);
|
|
gtk_widget_show(item->menu_item);
|
|
//fs->bookmark_list=g_list_append(fs->bookmark_list,item);
|
|
//set signal here!!
|
|
gtk_menu_append (GTK_MENU(fs->bookmark_menu), item->menu_item);
|
|
|
|
bookmark_file=g_strconcat(g_get_home_dir(), BOOKMARK_FILE ,NULL);
|
|
if(!stat(bookmark_file,&file_info) && (file = open(bookmark_file, O_RDONLY )) > 0)
|
|
{
|
|
if(file_info.st_size <65536 )
|
|
{
|
|
bookmark_data=g_malloc(file_info.st_size);
|
|
|
|
if(file && read(file, bookmark_data, file_info.st_size))
|
|
{
|
|
cp=lp=0;
|
|
|
|
while (cp < file_info.st_size)
|
|
{
|
|
while (cp < file_info.st_size && bookmark_data[cp] != '<' )
|
|
cp++;
|
|
bookmark_data[cp]=0;
|
|
item=g_malloc(sizeof(BookmarkMenuStruct));
|
|
item->desc=g_strdup(bookmark_data+lp);
|
|
lp=++cp;
|
|
|
|
while (cp < file_info.st_size && bookmark_data[cp] != '>' )
|
|
cp++;
|
|
|
|
bookmark_data[cp]=0;
|
|
//create menu items
|
|
item->path=g_strdup(bookmark_data+lp);
|
|
gtk_file_selection_add_bookmark ((gpointer) fs, (gpointer) item->desc, (gpointer) item->path);
|
|
|
|
cp++;
|
|
|
|
while(cp < file_info.st_size && bookmark_data[cp] < 33 )
|
|
cp++;
|
|
lp=cp;
|
|
}
|
|
}
|
|
|
|
close(file);
|
|
}
|
|
} else {
|
|
|
|
/* Add some default items, then save off to bookmarks file */
|
|
|
|
gtk_file_selection_add_bookmark ((gpointer) fs, "Home", "~/");
|
|
gtk_file_selection_add_bookmark ((gpointer) fs, "Root", "/");
|
|
|
|
gtk_file_selection_save_bookmarks ((gpointer) fs);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_add_bookmark (GtkFileSelection *fs, gchar *desc, gchar *path)
|
|
{
|
|
/* Add item to menu */
|
|
BookmarkMenuStruct *item;
|
|
item=g_malloc(sizeof(item));
|
|
item->desc = (gpointer) desc;
|
|
item->path = (gpointer) path;
|
|
item->menu_item=gtk_menu_item_new_with_label (item->desc);
|
|
gtk_widget_show(item->menu_item);
|
|
fs->bookmark_list=g_list_append(fs->bookmark_list,item);
|
|
gtk_signal_connect (GTK_OBJECT(item->menu_item), "activate",
|
|
(GtkSignalFunc) gtk_file_selection_bookmark_callback,
|
|
(gpointer) fs);
|
|
gtk_menu_insert (GTK_MENU(fs->bookmark_menu), item->menu_item, g_list_length(fs->bookmark_list) -1);
|
|
}
|
|
|
|
gint
|
|
gtk_file_selection_save_bookmarks (GtkFileSelection *fs)
|
|
{
|
|
BookmarkMenuStruct *item;
|
|
gchar *bookmark_file;
|
|
gchar *item_data;
|
|
gint file;
|
|
GList *list;
|
|
|
|
bookmark_file=g_strconcat(g_get_home_dir(), BOOKMARK_FILE ,NULL);
|
|
|
|
if ((file = open(bookmark_file, O_CREAT | O_WRONLY | O_TRUNC, 0600)) > 0)
|
|
{
|
|
for (list = g_list_first (fs->bookmark_list); list != NULL; list = g_list_next(list)) {
|
|
item = list->data;
|
|
item_data = g_strconcat(item->desc, " <", item->path, ">\n", NULL);
|
|
if (write (file, item_data, strlen(item_data)) != strlen(item_data)) {
|
|
return TRUE;
|
|
}
|
|
g_free(item_data);
|
|
}
|
|
|
|
close(file);
|
|
} else {
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_load_masks(GtkFileSelection *fs)
|
|
{
|
|
/*
|
|
GList *list;
|
|
gchar *masks_file;
|
|
gchar *masks_data;
|
|
struct stat file_info;
|
|
gint file;
|
|
gint lp;
|
|
gint cp;
|
|
|
|
if(fs->masks){
|
|
list=fs->masks;
|
|
while(list){
|
|
g_free(list->data);
|
|
list=list->next;
|
|
}
|
|
fs->masks = NULL;
|
|
}
|
|
|
|
masks_file=g_strconcat(g_get_home_dir(), MASK_FILE,NULL); //put in #define
|
|
if(!stat(masks_file,&file_info))
|
|
{
|
|
if(file_info.st_size <65536 )
|
|
{
|
|
masks_data=g_malloc(file_info.st_size);
|
|
|
|
file = open(masks_file, O_RDONLY );
|
|
|
|
if(file && read(file, masks_data, file_info.st_size))
|
|
{
|
|
cp=lp=0;
|
|
|
|
while (cp < file_info.st_size)
|
|
{
|
|
while (cp < file_info.st_size && masks_data[cp] != '>' )
|
|
cp++;
|
|
|
|
masks_data[++cp]=0;
|
|
if (masks_data[lp]=='<') { //if there was no description, strip off brackets
|
|
lp++;
|
|
masks_data[cp-1]=0;
|
|
}
|
|
// g_print("%s\n",masks_data+lp);
|
|
fs->masks = g_list_append(fs->masks, g_strdup(masks_data+lp));
|
|
|
|
while(cp < file_info.st_size && masks_data[cp] < 33 )
|
|
cp++;
|
|
lp=cp;
|
|
}
|
|
}
|
|
|
|
close(file);
|
|
}
|
|
}
|
|
*/
|
|
if (!fs->masks) {
|
|
/* masks is still null, fill it with default data... */
|
|
/*
|
|
fs->masks = g_list_append(fs->masks, "all files <*>");
|
|
fs->masks = g_list_append(fs->masks, "mp3s/playlists <*.mp3,*.m3u>");
|
|
fs->masks = g_list_append(fs->masks, "src/hdr <*.[CcHh],*.[Cc][Cc],*.[Hh][Hh],*.cpp>");
|
|
fs->masks = g_list_append(fs->masks, "html docs <*.html,*.htm,*.HTM,*.php*,*.inc>");
|
|
fs->masks = g_list_append(fs->masks, "images <*.png,*.jpg,*.jpeg,*.gif,*.xpm,*.tiff>");
|
|
fs->masks = g_list_append(fs->masks, "package <*.rpm,*.deb>");
|
|
fs->masks = g_list_append(fs->masks, "archive <*.tgz,*.tb2,*.tar*,*.zip,*.rar>");
|
|
fs->masks = g_list_append(fs->masks, "compressed <*.Z,*.gz,*.bz2>");
|
|
*/
|
|
}
|
|
}
|
|
|
|
void gtk_file_selection_clear_masks (GtkFileSelection *filesel)
|
|
{
|
|
GList *list;
|
|
|
|
g_return_if_fail (filesel != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
|
|
|
|
list = filesel->masks;
|
|
while (list)
|
|
{
|
|
g_free (list->data);
|
|
list = list->next;
|
|
}
|
|
filesel->masks = NULL;
|
|
|
|
gtk_list_clear_items (GTK_LIST (GTK_COMBO (filesel->mask_entry)->list), 0, -1);
|
|
}
|
|
|
|
void gtk_file_selection_set_masks (GtkFileSelection *filesel, const gchar **masks)
|
|
{
|
|
g_return_if_fail (filesel != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
|
|
|
|
while (*masks)
|
|
{
|
|
filesel->masks = g_list_append (filesel->masks, (gpointer)*masks);
|
|
masks++;
|
|
}
|
|
|
|
if (filesel->masks)
|
|
gtk_combo_set_popdown_strings (GTK_COMBO (filesel->mask_entry), filesel->masks);
|
|
}
|
|
|
|
GtkType
|
|
gtk_file_selection_get_type (void)
|
|
{
|
|
static GtkType file_selection_type = 0;
|
|
|
|
if (!file_selection_type)
|
|
{
|
|
static const GtkTypeInfo filesel_info =
|
|
{
|
|
"GtkFileSelection",
|
|
sizeof (GtkFileSelection),
|
|
sizeof (GtkFileSelectionClass),
|
|
(GtkClassInitFunc) gtk_file_selection_class_init,
|
|
(GtkObjectInitFunc) gtk_file_selection_init,
|
|
/* reserved_1 */ NULL,
|
|
/* reserved_2 */ NULL,
|
|
(GtkClassInitFunc) NULL,
|
|
};
|
|
|
|
file_selection_type = gtk_type_unique (GTK_TYPE_WINDOW, &filesel_info);
|
|
}
|
|
|
|
return file_selection_type;
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_class_init (GtkFileSelectionClass *class)
|
|
{
|
|
GtkObjectClass *object_class;
|
|
GtkWidgetClass *widget_class;
|
|
|
|
object_class = (GtkObjectClass*) class;
|
|
|
|
parent_class = gtk_type_class (GTK_TYPE_WINDOW);
|
|
|
|
widget_class = GTK_WIDGET_CLASS (class);
|
|
|
|
widget_class->realize = gtk_file_selection_realize;
|
|
object_class->destroy = gtk_file_selection_destroy;
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_init (GtkFileSelection *filesel)
|
|
{
|
|
GtkWidget *entry_vbox;
|
|
GtkWidget *label;
|
|
GtkWidget *list_vbox;
|
|
GtkWidget *confirm_area;
|
|
GtkWidget *vbox;
|
|
GtkWidget *hbox;
|
|
GtkWidget *hbox2;
|
|
GtkWidget *table;
|
|
GtkWidget *pulldown_hbox;
|
|
GtkWidget *scrolled_win;
|
|
GtkWidget *mask_label;
|
|
GtkWidget *bigframe;
|
|
GtkWidget *button;
|
|
GtkWidget *hpaned;
|
|
GtkWidget *menu_item;
|
|
GtkWidget *pixmap;
|
|
|
|
char *dir_title [2];
|
|
char *file_title [2];
|
|
|
|
filesel->cmpl_state = cmpl_init_state ();
|
|
|
|
filesel->mask=NULL;
|
|
filesel->prev_history=NULL;
|
|
filesel->next_history=NULL;
|
|
filesel->saved_entry=NULL;
|
|
filesel->bookmark_list=NULL;
|
|
filesel->masks=NULL;
|
|
filesel->selection_text = NULL;
|
|
filesel->fileop_data = NULL;
|
|
|
|
gtk_file_selection_load_masks(filesel);
|
|
gtk_file_selection_load_bookmarks(filesel);
|
|
|
|
/* The dialog-sized vertical box */
|
|
filesel->main_vbox = gtk_vbox_new (FALSE, 0);
|
|
gtk_container_set_border_width (GTK_CONTAINER (filesel), 0);
|
|
gtk_container_add (GTK_CONTAINER (filesel), filesel->main_vbox);
|
|
gtk_widget_show (filesel->main_vbox);
|
|
|
|
/* hbox for pulldown menu */
|
|
pulldown_hbox = gtk_hbox_new (FALSE, 0);
|
|
gtk_box_pack_start (GTK_BOX (filesel->main_vbox), pulldown_hbox, FALSE, FALSE, 0);
|
|
gtk_widget_show (pulldown_hbox);
|
|
|
|
/* The horizontal box containing create, rename etc. buttons */
|
|
|
|
/*
|
|
filesel->button_area = gtk_hbutton_box_new ();
|
|
gtk_button_box_set_layout(GTK_BUTTON_BOX(filesel->button_area), GTK_BUTTONBOX_START);
|
|
gtk_button_box_set_spacing(GTK_BUTTON_BOX(filesel->button_area), 0);
|
|
gtk_box_pack_start (GTK_BOX (pulldown_hbox), filesel->button_area,
|
|
FALSE, FALSE, 0);
|
|
gtk_button_box_set_child_size(GTK_BUTTON_BOX(filesel->button_area),0,0);
|
|
gtk_button_box_set_child_ipadding(GTK_BUTTON_BOX(filesel->button_area),0,0);
|
|
*/
|
|
|
|
filesel->button_area = gtk_hbox_new (TRUE,0);
|
|
//gtk_box_pack_start (GTK_BOX (pulldown_hbox), filesel->button_area,
|
|
// FALSE, FALSE, 0);
|
|
|
|
//gtk_widget_show (filesel->button_area);
|
|
|
|
gtk_file_selection_show_fileop_buttons(filesel);
|
|
/* frame to put the following hbox in */
|
|
bigframe = gtk_frame_new (NULL);
|
|
gtk_box_pack_start (GTK_BOX (filesel->main_vbox), bigframe, TRUE, TRUE, 0);
|
|
gtk_frame_set_shadow_type (GTK_FRAME (bigframe), GTK_SHADOW_OUT);
|
|
gtk_widget_show (bigframe);
|
|
|
|
|
|
list_vbox = gtk_vbox_new (FALSE,3);
|
|
gtk_widget_show(list_vbox);
|
|
gtk_container_add (GTK_CONTAINER(bigframe), list_vbox);
|
|
gtk_container_set_border_width (GTK_CONTAINER (list_vbox),2);
|
|
gtk_widget_show (list_vbox);
|
|
|
|
/* The horizontal box containing the directory and file listboxes */
|
|
// list_hbox = gtk_hbox_new (FALSE, 3);
|
|
//gtk_container_add (GTK_CONTAINER(bigframe), list_hbox);
|
|
//gtk_container_set_border_width (GTK_CONTAINER (list_hbox), 3);
|
|
// gtk_box_pack_start(GTK_BOX(list_vbox), list_hbox, FALSE,FALSE,0);
|
|
// gtk_widget_show (list_hbox);
|
|
|
|
hpaned=gtk_hpaned_new();
|
|
gtk_widget_show(hpaned);
|
|
gtk_container_set_border_width (GTK_CONTAINER (hpaned), 1);
|
|
gtk_paned_set_gutter_size (GTK_PANED (hpaned), 10);
|
|
gtk_box_pack_start (GTK_BOX(list_vbox), hpaned,TRUE,TRUE,0);
|
|
|
|
/* vbox to put the buttons and directory listing in */
|
|
vbox = gtk_vbox_new (FALSE, 3);
|
|
gtk_widget_show (vbox);
|
|
gtk_container_add(GTK_CONTAINER(hpaned),vbox);
|
|
//gtk_box_pack_start (GTK_BOX (hpaned), vbox, FALSE, FALSE, 0);
|
|
|
|
hbox = gtk_hbox_new (FALSE, 4);
|
|
gtk_widget_show (hbox);
|
|
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
|
|
|
|
// home_button = gtk_button_new_with_label (_("Home"));
|
|
// gtk_widget_show (home_button);
|
|
// gtk_signal_connect (GTK_OBJECT (home_button), "clicked",
|
|
// (GtkSignalFunc) gtk_file_selection_home_button,
|
|
// (gpointer) filesel);
|
|
// gtk_box_pack_start (GTK_BOX (hbox), home_button, TRUE,TRUE, 0);
|
|
|
|
/* Here we add the bookmark menu button */
|
|
#define If we're going to make bookmark a menu, we don't need
|
|
#define to keep it in the filesel structure
|
|
button=gtk_button_new_with_label(_("Bookmarks"));
|
|
gtk_widget_show(button);
|
|
gtk_box_pack_start (GTK_BOX(hbox), button, FALSE,FALSE,0);
|
|
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_file_selection_bookmark_button,
|
|
(gpointer) filesel);
|
|
|
|
hbox2 = gtk_hbox_new (FALSE, 2);
|
|
gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0);
|
|
gtk_widget_show(hbox2);
|
|
|
|
/* Prev button */
|
|
button = gtk_button_new ();
|
|
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_file_selection_prev_button,
|
|
(gpointer) filesel);
|
|
gtk_widget_show (button);
|
|
gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE,FALSE, 0);
|
|
pixmap = create_pixmap (filesel->main_vbox, (gpointer) back_xpm);
|
|
gtk_widget_show (pixmap);
|
|
gtk_container_add (GTK_CONTAINER (button), pixmap);
|
|
|
|
/* Up button */
|
|
button = gtk_button_new ();
|
|
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_file_selection_up_button,
|
|
(gpointer) filesel);
|
|
gtk_widget_show (button);
|
|
gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE,FALSE, 0);
|
|
pixmap = create_pixmap (filesel->main_vbox, (gpointer) up_xpm);
|
|
gtk_widget_show (pixmap);
|
|
gtk_container_add (GTK_CONTAINER (button), pixmap);
|
|
|
|
/* next button */
|
|
button = gtk_button_new ();
|
|
gtk_widget_show (button);
|
|
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_file_selection_next_button,
|
|
(gpointer) filesel);
|
|
gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE,FALSE, 0);
|
|
pixmap = create_pixmap (filesel->main_vbox, (gpointer) forward_xpm);
|
|
gtk_widget_show (pixmap);
|
|
gtk_container_add (GTK_CONTAINER (button), pixmap);
|
|
|
|
/* refresh button */
|
|
button = gtk_button_new ();
|
|
gtk_widget_show (button);
|
|
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_file_selection_refresh_button,
|
|
(gpointer) filesel);
|
|
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE,FALSE, 0);
|
|
pixmap = create_pixmap (filesel->main_vbox, (gpointer) refresh_xpm);
|
|
gtk_widget_show (pixmap);
|
|
gtk_container_add (GTK_CONTAINER (button), pixmap);
|
|
|
|
/* menu for right click file operations */
|
|
filesel->fileop_menu = gtk_menu_new();
|
|
|
|
menu_item = gtk_menu_item_new_with_label ("Rename...");
|
|
gtk_widget_show(menu_item);
|
|
gtk_signal_connect_object (GTK_OBJECT (menu_item), "activate",
|
|
(GtkSignalFunc) gtk_file_selection_rename_file,
|
|
(gpointer) filesel);
|
|
gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
|
|
|
|
menu_item = gtk_menu_item_new_with_label ("Delete");
|
|
gtk_widget_show(menu_item);
|
|
gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
|
|
gtk_signal_connect_object (GTK_OBJECT (menu_item), "activate",
|
|
(GtkSignalFunc) gtk_file_selection_delete_file,
|
|
(gpointer) filesel);
|
|
|
|
menu_item = gtk_menu_item_new ();
|
|
gtk_widget_show(menu_item);
|
|
gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
|
|
|
|
menu_item = gtk_menu_item_new_with_label ("Create Directory...");
|
|
gtk_signal_connect_object (GTK_OBJECT (menu_item), "activate",
|
|
(GtkSignalFunc) gtk_file_selection_create_dir,
|
|
(gpointer) filesel);
|
|
gtk_widget_show(menu_item);
|
|
gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
|
|
|
|
menu_item = gtk_menu_item_new ();
|
|
gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
|
|
gtk_widget_show(menu_item);
|
|
|
|
menu_item = gtk_menu_item_new_with_label ("Properties...");
|
|
gtk_signal_connect_object (GTK_OBJECT (menu_item), "activate",
|
|
(GtkSignalFunc) gtk_file_selection_properties,
|
|
(gpointer) filesel);
|
|
gtk_menu_append (GTK_MENU (filesel->fileop_menu), menu_item);
|
|
gtk_widget_show(menu_item);
|
|
|
|
/* The directories clist */
|
|
dir_title[0] = _("Directories");
|
|
dir_title[1] = NULL;
|
|
filesel->dir_list = gtk_clist_new_with_titles (1, (gchar**) dir_title);
|
|
gtk_widget_set_usize (filesel->dir_list, DIR_LIST_WIDTH, DIR_LIST_HEIGHT);
|
|
gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "select_row",
|
|
(GtkSignalFunc) gtk_file_selection_dir_button,
|
|
(gpointer) filesel);
|
|
gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "unselect_row",
|
|
(GtkSignalFunc) gtk_file_selection_undir_button,
|
|
(gpointer) filesel);
|
|
gtk_signal_connect (GTK_OBJECT (filesel->dir_list), "button_press_event",
|
|
GTK_SIGNAL_FUNC(gtk_file_selection_show_fileop_menu),
|
|
(gpointer) filesel);
|
|
|
|
gtk_clist_column_titles_passive (GTK_CLIST (filesel->dir_list));
|
|
|
|
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
|
|
gtk_container_add (GTK_CONTAINER (scrolled_win), filesel->dir_list);
|
|
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
|
|
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
|
|
gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE,TRUE, 0);
|
|
//gtk_container_add(GTK_CONTAINER(hpaned), scrolled_win);
|
|
|
|
gtk_widget_show (filesel->dir_list);
|
|
gtk_widget_show (scrolled_win);
|
|
|
|
vbox = gtk_vbox_new (FALSE, 3);
|
|
gtk_widget_show (vbox);
|
|
gtk_container_add(GTK_CONTAINER(hpaned),vbox);
|
|
/* vbox area for mask entry and files clist */
|
|
|
|
hbox = gtk_hbox_new (FALSE, 2);
|
|
gtk_widget_show (hbox);
|
|
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
|
|
|
|
mask_label = gtk_label_new (_("Mask:"));
|
|
gtk_widget_show (mask_label);
|
|
gtk_box_pack_start (GTK_BOX (hbox), mask_label, FALSE, FALSE, 2);
|
|
|
|
/*
|
|
filesel->mask_entry = gtk_entry_new ();
|
|
gtk_widget_show (filesel->mask_entry);
|
|
gtk_signal_connect(GTK_OBJECT(filesel->mask_entry),"activate",
|
|
(GtkSignalFunc) gtk_file_4_mask_entry_callback,
|
|
(gpointer) filesel);
|
|
gtk_box_pack_start (GTK_BOX (hbox),filesel->mask_entry, TRUE, TRUE, 0);
|
|
*/
|
|
|
|
filesel->mask_entry = gtk_combo_new ();
|
|
gtk_widget_show (filesel->mask_entry);
|
|
gtk_combo_set_value_in_list(GTK_COMBO(filesel->mask_entry),FALSE,FALSE);
|
|
gtk_signal_connect(GTK_OBJECT(GTK_COMBO(filesel->mask_entry)->entry),"activate",
|
|
(GtkSignalFunc) gtk_file_selection_mask_entry_callback,
|
|
(gpointer) filesel);
|
|
gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->mask_entry)->entry),"key-press-event",
|
|
(GtkSignalFunc) gtk_file_selection_mask_entry_key_callback,
|
|
(gpointer) filesel);
|
|
|
|
gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->mask_entry)->list),"button-release-event",
|
|
(GtkSignalFunc) gtk_file_selection_mask_entry_button_callback,
|
|
(gpointer) filesel);
|
|
gtk_box_pack_start (GTK_BOX (hbox),filesel->mask_entry, TRUE, TRUE, 0);
|
|
|
|
if (filesel->masks)
|
|
gtk_combo_set_popdown_strings (GTK_COMBO (filesel->mask_entry), filesel->masks);
|
|
|
|
|
|
/* The files clist */
|
|
file_title[0] = _("Files");
|
|
file_title[1] = NULL;
|
|
filesel->file_list = gtk_clist_new_with_titles (1, (gchar**) file_title);
|
|
gtk_widget_set_usize (filesel->file_list, FILE_LIST_WIDTH, FILE_LIST_HEIGHT);
|
|
gtk_signal_connect (GTK_OBJECT (filesel->file_list), "select_row",
|
|
(GtkSignalFunc) gtk_file_selection_file_button,
|
|
(gpointer) filesel);
|
|
gtk_signal_connect (GTK_OBJECT (filesel->file_list), "key-press-event",
|
|
(GtkSignalFunc) gtk_file_selection_files_list_key_callback,
|
|
(gpointer) filesel);
|
|
|
|
gtk_signal_connect (GTK_OBJECT (filesel->file_list), "button_press_event",
|
|
GTK_SIGNAL_FUNC(gtk_file_selection_show_fileop_menu),
|
|
(gpointer) filesel);
|
|
|
|
gtk_clist_column_titles_passive (GTK_CLIST (filesel->file_list));
|
|
|
|
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
|
|
gtk_container_add (GTK_CONTAINER (scrolled_win), filesel->file_list);
|
|
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
|
|
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
|
|
gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
|
|
gtk_widget_show (filesel->file_list);
|
|
gtk_widget_show (scrolled_win);
|
|
|
|
/* action area for packing buttons into. */
|
|
filesel->action_area = gtk_hbox_new (TRUE, 0);
|
|
gtk_box_pack_start (GTK_BOX (filesel->main_vbox), filesel->action_area,
|
|
FALSE, FALSE, 2);
|
|
gtk_widget_show (filesel->action_area);
|
|
|
|
/*
|
|
hbox=gtk_hbox_new(FALSE,0);
|
|
gtk_box_pack_end (GTK_BOX (filesel->main_vbox), hbox, FALSE,FALSE, 0);
|
|
gtk_widget_show (hbox);
|
|
*/
|
|
|
|
/* The selection entry widget */
|
|
|
|
entry_vbox = gtk_vbox_new (FALSE, 0);
|
|
gtk_box_pack_end (GTK_BOX (filesel->main_vbox), entry_vbox, FALSE, FALSE, 0);
|
|
gtk_widget_show (entry_vbox);
|
|
|
|
table = gtk_table_new ( 2, 2, FALSE );
|
|
gtk_box_pack_start (GTK_BOX (entry_vbox), table, TRUE, TRUE, 0);
|
|
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
|
|
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
|
|
|
|
|
|
label = gtk_label_new (_("Selection:"));
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
|
|
(GtkAttachOptions) (0),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_widget_show (label);
|
|
|
|
|
|
filesel->selection_entry = gtk_entry_new ();
|
|
gtk_signal_connect (GTK_OBJECT (filesel->selection_entry), "key_press_event",
|
|
(GtkSignalFunc) gtk_file_selection_key_press, filesel);
|
|
gtk_table_attach (GTK_TABLE (table), filesel->selection_entry, 1, 2, 0, 1,
|
|
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_widget_show (filesel->selection_entry);
|
|
|
|
|
|
label = gtk_label_new (_("Directory:"));
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
|
|
(GtkAttachOptions) (0),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_widget_show (label);
|
|
|
|
|
|
filesel->history_combo = gtk_combo_new();
|
|
gtk_combo_set_value_in_list(GTK_COMBO(filesel->history_combo),FALSE,FALSE);
|
|
gtk_table_attach (GTK_TABLE (table), filesel->history_combo, 1, 2, 1, 2,
|
|
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_widget_show(filesel->history_combo);
|
|
|
|
gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->history_combo)->entry),"key-press-event",
|
|
(GtkSignalFunc) gtk_file_selection_history_combo_callback,
|
|
(gpointer) filesel);
|
|
|
|
gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->history_combo)->list),"button-press-event",
|
|
(GtkSignalFunc) gtk_file_selection_history_combo_list_callback,
|
|
(gpointer) filesel);
|
|
|
|
gtk_signal_connect(GTK_OBJECT(((GtkCombo *)filesel->history_combo)->list),"key-press-event",
|
|
(GtkSignalFunc) gtk_file_selection_history_combo_list_key_handler,
|
|
(gpointer) filesel);
|
|
|
|
filesel->selection_text = NULL;
|
|
|
|
|
|
/* The OK/Cancel button area */
|
|
confirm_area = gtk_hbutton_box_new ();
|
|
gtk_button_box_set_layout(GTK_BUTTON_BOX(confirm_area), GTK_BUTTONBOX_END);
|
|
gtk_button_box_set_spacing(GTK_BUTTON_BOX(confirm_area), 5);
|
|
gtk_box_pack_end (GTK_BOX (entry_vbox), confirm_area, FALSE, FALSE, 0);
|
|
gtk_widget_show (confirm_area);
|
|
|
|
/* The OK button */
|
|
filesel->ok_button = gtk_button_new_with_label (_("OK"));
|
|
GTK_WIDGET_SET_FLAGS (filesel->ok_button, GTK_CAN_DEFAULT);
|
|
gtk_box_pack_start (GTK_BOX (confirm_area), filesel->ok_button, TRUE, TRUE, 0);
|
|
gtk_signal_connect_object (GTK_OBJECT (filesel->selection_entry), "focus_in_event",
|
|
(GtkSignalFunc) gtk_widget_grab_default,
|
|
GTK_OBJECT (filesel->ok_button));
|
|
gtk_signal_connect_object (GTK_OBJECT (filesel->selection_entry), "activate",
|
|
(GtkSignalFunc) gtk_button_clicked,
|
|
GTK_OBJECT (filesel->ok_button));
|
|
gtk_widget_grab_default (filesel->ok_button);
|
|
gtk_widget_show (filesel->ok_button);
|
|
|
|
/* The Cancel button */
|
|
filesel->cancel_button = gtk_button_new_with_label (_("Cancel"));
|
|
GTK_WIDGET_SET_FLAGS (filesel->cancel_button, GTK_CAN_DEFAULT);
|
|
gtk_box_pack_start (GTK_BOX (confirm_area), filesel->cancel_button, TRUE, TRUE, 0);
|
|
gtk_widget_show (filesel->cancel_button);
|
|
|
|
gtk_widget_show(table);
|
|
|
|
|
|
/*
|
|
filesel->selection_text = label = gtk_label_new ("");
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
|
|
gtk_box_pack_start (GTK_BOX (entry_vbox), label, FALSE, FALSE, 0);
|
|
gtk_widget_show (label);
|
|
*/
|
|
|
|
|
|
if (!cmpl_state_okay (filesel->cmpl_state))
|
|
{
|
|
gchar err_buf[256];
|
|
|
|
sprintf (err_buf, _("Directory unreadable: %s"), cmpl_strerror (cmpl_errno));
|
|
|
|
/*
|
|
gtk_label_set_text (GTK_LABEL (filesel->selection_text), err_buf);
|
|
*/
|
|
}
|
|
else
|
|
{
|
|
gtk_file_selection_populate (filesel, "", FALSE);
|
|
}
|
|
|
|
gtk_widget_grab_focus (filesel->selection_entry);
|
|
}
|
|
|
|
GtkWidget*
|
|
gtk_file_selection_new (const gchar *title)
|
|
{
|
|
GtkFileSelection *filesel;
|
|
|
|
filesel = gtk_type_new (GTK_TYPE_FILE_SELECTION);
|
|
gtk_window_set_title (GTK_WINDOW (filesel), title);
|
|
/* !!! put check here to figure out if screen > 640x480, if true
|
|
We need to make the file selection dialog bigger. much bigger..
|
|
or maybe we should keep it at a certan percentage of the screen
|
|
size? */
|
|
|
|
gtk_window_set_default_size(GTK_WINDOW (filesel), 520, 420);
|
|
return GTK_WIDGET (filesel);
|
|
}
|
|
|
|
void
|
|
gtk_file_selection_show_fileop_buttons (GtkFileSelection *filesel)
|
|
{
|
|
g_return_if_fail (filesel != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
|
|
|
|
return;
|
|
|
|
/* delete, create directory, and rename */
|
|
/*
|
|
if (!filesel->fileop_c_dir)
|
|
{
|
|
filesel->fileop_c_dir = gtk_button_new_with_label (_("MkDir"));
|
|
gtk_signal_connect (GTK_OBJECT (filesel->fileop_c_dir), "clicked",
|
|
(GtkSignalFunc) gtk_file_selection_create_dir,
|
|
(gpointer) filesel);
|
|
gtk_box_pack_start (GTK_BOX (filesel->button_area),
|
|
filesel->fileop_c_dir, TRUE,TRUE, 0);
|
|
gtk_widget_show (filesel->fileop_c_dir);
|
|
}
|
|
|
|
if (!filesel->fileop_del_file)
|
|
{
|
|
filesel->fileop_del_file = gtk_button_new_with_label (_("Delete"));
|
|
gtk_signal_connect (GTK_OBJECT (filesel->fileop_del_file), "clicked",
|
|
(GtkSignalFunc) gtk_file_selection_delete_file,
|
|
(gpointer) filesel);
|
|
gtk_box_pack_start (GTK_BOX (filesel->button_area),
|
|
filesel->fileop_del_file, TRUE,TRUE, 0);
|
|
gtk_widget_show (filesel->fileop_del_file);
|
|
}
|
|
|
|
if (!filesel->fileop_ren_file)
|
|
{
|
|
filesel->fileop_ren_file = gtk_button_new_with_label (_("Rename"));
|
|
gtk_signal_connect (GTK_OBJECT (filesel->fileop_ren_file), "clicked",
|
|
(GtkSignalFunc) gtk_file_selection_rename_file,
|
|
(gpointer) filesel);
|
|
gtk_box_pack_start (GTK_BOX (filesel->button_area),
|
|
filesel->fileop_ren_file, TRUE,TRUE, 0);
|
|
gtk_widget_show (filesel->fileop_ren_file);
|
|
}
|
|
|
|
gtk_widget_queue_resize(GTK_WIDGET(filesel));
|
|
*/
|
|
}
|
|
|
|
void
|
|
gtk_file_selection_hide_fileop_buttons (GtkFileSelection *filesel)
|
|
{
|
|
g_return_if_fail (filesel != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
|
|
|
|
return;
|
|
/*
|
|
if (filesel->fileop_ren_file)
|
|
{
|
|
gtk_widget_destroy (filesel->fileop_ren_file);
|
|
filesel->fileop_ren_file = NULL;
|
|
}
|
|
|
|
if (filesel->fileop_del_file)
|
|
{
|
|
gtk_widget_destroy (filesel->fileop_del_file);
|
|
filesel->fileop_del_file = NULL;
|
|
}
|
|
|
|
if (filesel->fileop_c_dir)
|
|
{
|
|
gtk_widget_destroy (filesel->fileop_c_dir);
|
|
filesel->fileop_c_dir = NULL;
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
|
|
void
|
|
gtk_file_selection_set_filename (GtkFileSelection *filesel,
|
|
const gchar *filename)
|
|
{
|
|
char buf[MAXPATHLEN];
|
|
const char *name, *last_slash;
|
|
|
|
g_return_if_fail (filesel != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
|
|
g_return_if_fail (filename != NULL);
|
|
|
|
last_slash = strrchr (filename, '/');
|
|
|
|
if (!last_slash)
|
|
{
|
|
buf[0] = 0;
|
|
name = filename;
|
|
}
|
|
else
|
|
{
|
|
gint len = MIN (MAXPATHLEN - 1, last_slash - filename + 1);
|
|
|
|
strncpy (buf, filename, len);
|
|
buf[len] = 0;
|
|
|
|
name = last_slash + 1;
|
|
}
|
|
|
|
gtk_file_selection_populate (filesel, buf, FALSE);
|
|
|
|
if (filesel->selection_entry)
|
|
gtk_entry_set_text (GTK_ENTRY (filesel->selection_entry), name);
|
|
}
|
|
|
|
gchar*
|
|
gtk_file_selection_get_filename (GtkFileSelection *filesel)
|
|
{
|
|
static char nothing[2] = "";
|
|
char *text;
|
|
char *filename;
|
|
|
|
g_return_val_if_fail (filesel != NULL, nothing);
|
|
g_return_val_if_fail (GTK_IS_FILE_SELECTION (filesel), nothing);
|
|
|
|
text = gtk_entry_get_text (GTK_ENTRY (filesel->selection_entry));
|
|
if (text)
|
|
{
|
|
filename = cmpl_completion_fullname (text, filesel->cmpl_state);
|
|
return filename;
|
|
}
|
|
|
|
return nothing;
|
|
}
|
|
|
|
void
|
|
gtk_file_selection_complete (GtkFileSelection *filesel,
|
|
const gchar *pattern)
|
|
{
|
|
gchar *new_pattern;
|
|
gint x;
|
|
|
|
g_return_if_fail (filesel != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (filesel));
|
|
g_return_if_fail (pattern != NULL);
|
|
|
|
if (filesel->selection_entry)
|
|
gtk_entry_set_text (GTK_ENTRY (filesel->selection_entry), pattern);
|
|
|
|
if(strchr(pattern,'*') || strchr(pattern,'?'))
|
|
{
|
|
for(x=strlen(pattern);x>=0;x--)
|
|
{
|
|
if(pattern[x]=='/') break;
|
|
}
|
|
gtk_entry_set_text(GTK_ENTRY(filesel->mask_entry),g_strdup(pattern+x+1));
|
|
|
|
if(filesel->mask) g_free(filesel->mask);
|
|
|
|
filesel->mask=g_strdup(pattern+x+1);
|
|
new_pattern=g_strdup(pattern);
|
|
new_pattern[x+1]=0;
|
|
gtk_file_selection_populate (filesel, (gchar*) new_pattern, TRUE);
|
|
g_free(new_pattern);
|
|
}
|
|
else
|
|
{
|
|
gtk_file_selection_populate (filesel, (gchar*) pattern, TRUE);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_realize (GtkWidget *widget)
|
|
{
|
|
GtkFileSelection *filesel;
|
|
const gchar *masks[] = { "All Files <*>", NULL };
|
|
|
|
g_return_if_fail (widget != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (widget));
|
|
|
|
filesel = GTK_FILE_SELECTION (widget);
|
|
|
|
/* make sure that we have at least one mask */
|
|
if (!filesel->masks)
|
|
gtk_file_selection_set_masks (filesel, masks);
|
|
|
|
filesel->mask = g_strdup ((gchar*) filesel->masks->data);
|
|
gtk_file_selection_populate (filesel, "", FALSE);
|
|
|
|
|
|
if (GTK_WIDGET_CLASS (parent_class)->realize)
|
|
(* GTK_WIDGET_CLASS (parent_class)->realize) (widget);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_destroy (GtkObject *object)
|
|
{
|
|
GtkFileSelection *filesel;
|
|
GList *list;
|
|
|
|
g_return_if_fail (object != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (object));
|
|
|
|
filesel = GTK_FILE_SELECTION (object);
|
|
|
|
if (filesel->fileop_dialog)
|
|
gtk_widget_destroy (filesel->fileop_dialog);
|
|
|
|
if (filesel->next_history)
|
|
{
|
|
list = filesel->next_history;
|
|
while (list)
|
|
{
|
|
g_free (list->data);
|
|
list = list->next;
|
|
}
|
|
}
|
|
g_list_free (filesel->next_history);
|
|
filesel->next_history = NULL;
|
|
|
|
if (filesel->prev_history)
|
|
{
|
|
list = filesel->prev_history;
|
|
while (list)
|
|
{
|
|
g_free (list->data);
|
|
list = list->next;
|
|
}
|
|
}
|
|
g_list_free (filesel->prev_history);
|
|
filesel->prev_history = NULL;
|
|
|
|
if (filesel->mask)
|
|
{
|
|
g_free (filesel->mask);
|
|
filesel->mask = NULL;
|
|
}
|
|
|
|
cmpl_free_state (filesel->cmpl_state);
|
|
filesel->cmpl_state = NULL;
|
|
|
|
if (GTK_OBJECT_CLASS (parent_class)->destroy)
|
|
(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
|
|
}
|
|
|
|
/* Begin file operations callbacks */
|
|
|
|
static gint
|
|
gtk_file_selection_show_fileop_menu (GtkCList *clist, GdkEvent *event, GtkFileSelection *fs)
|
|
{
|
|
GdkEventButton *event_button;
|
|
|
|
g_return_val_if_fail (clist != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_IS_CLIST (clist), FALSE);
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
g_return_val_if_fail (fs != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_FILE_SELECTION (fs), FALSE);
|
|
|
|
if (event->type == GDK_BUTTON_PRESS)
|
|
{
|
|
event_button = (GdkEventButton *) event;
|
|
if (event_button->button == 3)
|
|
{
|
|
|
|
gtk_menu_popup (GTK_MENU (fs->fileop_menu), NULL, NULL, NULL, NULL,
|
|
event_button->button, event_button->time);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_fileop_error (GtkFileSelection *fs, gchar *error_message)
|
|
{
|
|
GtkWidget *label;
|
|
GtkWidget *vbox;
|
|
GtkWidget *button;
|
|
GtkWidget *dialog;
|
|
|
|
g_return_if_fail (error_message != NULL);
|
|
|
|
/* main dialog */
|
|
dialog = gtk_dialog_new ();
|
|
/*
|
|
gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
|
|
(GtkSignalFunc) gtk_file_selection_fileop_destroy,
|
|
(gpointer) fs);
|
|
*/
|
|
gtk_window_set_title (GTK_WINDOW (dialog), _("Error"));
|
|
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
|
|
|
|
/* If file dialog is grabbed, make this dialog modal too */
|
|
/* When error dialog is closed, file dialog will be grabbed again */
|
|
if (GTK_WINDOW(fs)->modal)
|
|
gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
|
|
|
|
vbox = gtk_vbox_new(FALSE, 0);
|
|
gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
|
|
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
|
|
FALSE, FALSE, 0);
|
|
gtk_widget_show(vbox);
|
|
|
|
label = gtk_label_new(error_message);
|
|
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
|
|
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
|
|
gtk_widget_show(label);
|
|
|
|
/* yes, we free it */
|
|
g_free (error_message);
|
|
|
|
/* close button */
|
|
button = gtk_button_new_with_label (_("Close"));
|
|
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_widget_destroy,
|
|
(gpointer) dialog);
|
|
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
|
|
button, TRUE, TRUE, 0);
|
|
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
|
|
gtk_widget_grab_default(button);
|
|
gtk_widget_show (button);
|
|
|
|
gtk_widget_show (dialog);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_fileop_destroy (GtkWidget *widget, gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
fs->fileop_dialog = NULL;
|
|
g_free (fs->fileop_data);
|
|
fs->fileop_data = NULL;
|
|
}
|
|
|
|
|
|
static void
|
|
gtk_file_selection_create_dir_confirmed (GtkWidget *widget, gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
gchar *dirname;
|
|
gchar *path;
|
|
gchar *full_path;
|
|
gchar *buf;
|
|
CompletionState *cmpl_state;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
dirname = gtk_entry_get_text (GTK_ENTRY (fs->fileop_entry));
|
|
cmpl_state = (CompletionState*) fs->cmpl_state;
|
|
path = cmpl_reference_position (cmpl_state);
|
|
|
|
full_path = g_strconcat (path, "/", dirname, NULL);
|
|
if ( (mkdir (full_path, 0755) < 0) )
|
|
{
|
|
buf = g_strconcat ("Error creating directory \"", dirname, "\": ",
|
|
g_strerror(errno), NULL);
|
|
gtk_file_selection_fileop_error (fs, buf);
|
|
}
|
|
g_free (full_path);
|
|
|
|
gtk_widget_destroy (fs->fileop_dialog);
|
|
gtk_file_selection_populate (fs, "", FALSE);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_create_dir (gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
GtkWidget *label;
|
|
GtkWidget *dialog;
|
|
GtkWidget *vbox;
|
|
GtkWidget *button;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
if (fs->fileop_dialog)
|
|
return;
|
|
|
|
/* main dialog */
|
|
fs->fileop_dialog = dialog = gtk_dialog_new ();
|
|
gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
|
|
(GtkSignalFunc) gtk_file_selection_fileop_destroy,
|
|
(gpointer) fs);
|
|
gtk_window_set_title (GTK_WINDOW (dialog), _("Create Directory"));
|
|
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
|
|
|
|
/* If file dialog is grabbed, grab option dialog */
|
|
/* When option dialog is closed, file dialog will be grabbed again */
|
|
if (GTK_WINDOW(fs)->modal)
|
|
gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
|
|
|
|
vbox = gtk_vbox_new(FALSE, 0);
|
|
gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
|
|
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
|
|
FALSE, FALSE, 0);
|
|
gtk_widget_show(vbox);
|
|
|
|
label = gtk_label_new(_("Directory name:"));
|
|
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
|
|
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
|
|
gtk_widget_show(label);
|
|
|
|
/* The directory entry widget */
|
|
fs->fileop_entry = gtk_entry_new ();
|
|
gtk_box_pack_start (GTK_BOX (vbox), fs->fileop_entry,
|
|
TRUE, TRUE, 5);
|
|
GTK_WIDGET_SET_FLAGS(fs->fileop_entry, GTK_CAN_DEFAULT);
|
|
gtk_widget_show (fs->fileop_entry);
|
|
|
|
/* buttons */
|
|
button = gtk_button_new_with_label (_("Create"));
|
|
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_file_selection_create_dir_confirmed,
|
|
(gpointer) fs);
|
|
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
|
|
button, TRUE, TRUE, 0);
|
|
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
|
|
gtk_widget_show(button);
|
|
|
|
button = gtk_button_new_with_label (_("Cancel"));
|
|
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_widget_destroy,
|
|
(gpointer) dialog);
|
|
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
|
|
button, TRUE, TRUE, 0);
|
|
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
|
|
gtk_widget_grab_default(button);
|
|
gtk_widget_show (button);
|
|
|
|
gtk_widget_show (dialog);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_delete_file_confirmed (GtkWidget *widget, gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
CompletionState *cmpl_state;
|
|
gchar *path;
|
|
gchar *full_path;
|
|
gchar *buf;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
cmpl_state = (CompletionState*) fs->cmpl_state;
|
|
path = cmpl_reference_position (cmpl_state);
|
|
|
|
full_path = g_strconcat (path, "/", fs->fileop_file, NULL);
|
|
if ( (unlink (full_path) < 0) )
|
|
{
|
|
buf = g_strconcat ("Error deleting file \"", fs->fileop_file, "\": ",
|
|
g_strerror(errno), NULL);
|
|
gtk_file_selection_fileop_error (fs, buf);
|
|
}
|
|
g_free (full_path);
|
|
|
|
gtk_widget_destroy (fs->fileop_dialog);
|
|
gtk_file_selection_populate (fs, "", FALSE);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_delete_file (gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
GtkWidget *label;
|
|
GtkWidget *vbox;
|
|
GtkWidget *button;
|
|
GtkWidget *dialog;
|
|
gchar *filename;
|
|
gchar *buf;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
if (fs->fileop_dialog)
|
|
return;
|
|
|
|
filename = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
|
|
if (strlen(filename) < 1)
|
|
return;
|
|
|
|
fs->fileop_file = filename;
|
|
|
|
/* main dialog */
|
|
fs->fileop_dialog = dialog = gtk_dialog_new ();
|
|
gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
|
|
(GtkSignalFunc) gtk_file_selection_fileop_destroy,
|
|
(gpointer) fs);
|
|
gtk_window_set_title (GTK_WINDOW (dialog), _("Delete File"));
|
|
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
|
|
|
|
/* If file dialog is grabbed, grab option dialog */
|
|
/* When option dialog is closed, file dialog will be grabbed again */
|
|
if (GTK_WINDOW(fs)->modal)
|
|
gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
|
|
|
|
vbox = gtk_vbox_new(FALSE, 0);
|
|
gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
|
|
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
|
|
FALSE, FALSE, 0);
|
|
gtk_widget_show(vbox);
|
|
|
|
buf = g_strconcat ("Really delete file \"", filename, "\" ?", NULL);
|
|
label = gtk_label_new(buf);
|
|
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
|
|
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
|
|
gtk_widget_show(label);
|
|
g_free(buf);
|
|
|
|
/* buttons */
|
|
button = gtk_button_new_with_label (_("Delete"));
|
|
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_file_selection_delete_file_confirmed,
|
|
(gpointer) fs);
|
|
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
|
|
button, TRUE, TRUE, 0);
|
|
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
|
|
gtk_widget_show(button);
|
|
|
|
button = gtk_button_new_with_label (_("Cancel"));
|
|
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_widget_destroy,
|
|
(gpointer) dialog);
|
|
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
|
|
button, TRUE, TRUE, 0);
|
|
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
|
|
gtk_widget_grab_default(button);
|
|
gtk_widget_show (button);
|
|
|
|
gtk_widget_show (dialog);
|
|
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_rename_file_confirmed (GtkWidget *widget, gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
gchar *buf;
|
|
gchar *file;
|
|
gchar *path;
|
|
gchar *new_filename;
|
|
gchar *old_filename;
|
|
CompletionState *cmpl_state;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
file = gtk_entry_get_text (GTK_ENTRY (fs->fileop_entry));
|
|
cmpl_state = (CompletionState*) fs->cmpl_state;
|
|
path = cmpl_reference_position (cmpl_state);
|
|
|
|
new_filename = g_strconcat (path, "/", file, NULL);
|
|
old_filename = g_strconcat (path, "/", fs->fileop_file, NULL);
|
|
|
|
if (strcmp (new_filename, old_filename))
|
|
if ((rename (old_filename, new_filename)) < 0)
|
|
{
|
|
buf = g_strconcat ("Error renaming file \"", file, "\": ",
|
|
g_strerror(errno), NULL);
|
|
gtk_file_selection_fileop_error (fs, buf);
|
|
}
|
|
g_free (new_filename);
|
|
g_free (old_filename);
|
|
|
|
gtk_widget_destroy (fs->fileop_dialog);
|
|
gtk_file_selection_populate (fs, "", FALSE);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_file_mode_confirmed (GtkWidget *widget, gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
PropertiesPrivate *priv = fs->fileop_data;
|
|
CompletionState *cmpl_state;
|
|
gchar *filename, *file, *path;
|
|
mode_t mode;
|
|
|
|
mode = gtk_file_selection_properties_get_mode (priv);
|
|
|
|
file = gtk_entry_get_text (GTK_ENTRY (fs->fileop_entry));
|
|
cmpl_state = (CompletionState*) fs->cmpl_state;
|
|
path = cmpl_reference_position (cmpl_state);
|
|
|
|
filename = g_strconcat (path, "/", file, NULL);
|
|
if (chmod (filename, mode) == -1)
|
|
{
|
|
gchar *buf = g_strconcat ("Error changing file mode of \"", filename, "\": ",
|
|
g_strerror (errno), NULL);
|
|
gtk_file_selection_fileop_error (fs, buf);
|
|
gtk_widget_destroy (fs->fileop_dialog);
|
|
gtk_file_selection_populate (fs, "", FALSE);
|
|
}
|
|
else
|
|
gtk_file_selection_rename_file_confirmed (widget, data);
|
|
|
|
g_free (filename);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_rename_file (gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
GtkWidget *label;
|
|
GtkWidget *dialog;
|
|
GtkWidget *vbox;
|
|
GtkWidget *button;
|
|
gchar *buf;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
if (fs->fileop_dialog)
|
|
return;
|
|
|
|
fs->fileop_file = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
|
|
if (strlen(fs->fileop_file) < 1)
|
|
return;
|
|
|
|
/* main dialog */
|
|
fs->fileop_dialog = dialog = gtk_dialog_new ();
|
|
gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
|
|
(GtkSignalFunc) gtk_file_selection_fileop_destroy,
|
|
(gpointer) fs);
|
|
gtk_window_set_title (GTK_WINDOW (dialog), _("Rename File"));
|
|
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
|
|
|
|
/* If file dialog is grabbed, grab option dialog */
|
|
/* When option dialog closed, file dialog will be grabbed again */
|
|
if (GTK_WINDOW(fs)->modal)
|
|
gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
|
|
|
|
vbox = gtk_vbox_new(FALSE, 0);
|
|
gtk_container_set_border_width (GTK_CONTAINER(vbox), 8);
|
|
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox,
|
|
FALSE, FALSE, 0);
|
|
gtk_widget_show(vbox);
|
|
|
|
buf = g_strconcat ("Rename file \"", fs->fileop_file, "\" to:", NULL);
|
|
label = gtk_label_new(buf);
|
|
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
|
|
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 5);
|
|
gtk_widget_show(label);
|
|
g_free(buf);
|
|
|
|
/* New filename entry */
|
|
fs->fileop_entry = gtk_entry_new ();
|
|
gtk_box_pack_start (GTK_BOX (vbox), fs->fileop_entry,
|
|
TRUE, TRUE, 5);
|
|
GTK_WIDGET_SET_FLAGS(fs->fileop_entry, GTK_CAN_DEFAULT);
|
|
gtk_widget_show (fs->fileop_entry);
|
|
|
|
gtk_entry_set_text (GTK_ENTRY (fs->fileop_entry), fs->fileop_file);
|
|
gtk_editable_select_region (GTK_EDITABLE (fs->fileop_entry),
|
|
0, strlen (fs->fileop_file));
|
|
|
|
/* buttons */
|
|
button = gtk_button_new_with_label (_("Rename"));
|
|
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_file_selection_rename_file_confirmed,
|
|
(gpointer) fs);
|
|
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
|
|
button, TRUE, TRUE, 0);
|
|
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
|
|
gtk_widget_show(button);
|
|
|
|
button = gtk_button_new_with_label (_("Cancel"));
|
|
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_widget_destroy,
|
|
(gpointer) dialog);
|
|
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
|
|
button, TRUE, TRUE, 0);
|
|
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
|
|
gtk_widget_grab_default(button);
|
|
gtk_widget_show (button);
|
|
|
|
gtk_widget_show (dialog);
|
|
}
|
|
|
|
static mode_t
|
|
gtk_file_selection_properties_get_mode (PropertiesPrivate* priv)
|
|
{
|
|
mode_t mode = 0;
|
|
|
|
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[0])))
|
|
mode |= S_IRUSR;
|
|
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[1])))
|
|
mode |= S_IWUSR;
|
|
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[2])))
|
|
mode |= S_IXUSR;
|
|
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[3])))
|
|
mode |= S_ISUID;
|
|
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[4])))
|
|
mode |= S_IRGRP;
|
|
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[5])))
|
|
mode |= S_IWGRP;
|
|
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[6])))
|
|
mode |= S_IXGRP;
|
|
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[7])))
|
|
mode |= S_ISGID;
|
|
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[8])))
|
|
mode |= S_IROTH;
|
|
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[9])))
|
|
mode |= S_IWOTH;
|
|
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[10])))
|
|
mode |= S_IXOTH;
|
|
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->mode_buttons[11])))
|
|
mode |= S_ISVTX;
|
|
|
|
return mode;
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_properties_update_mode (GtkWidget *widget, gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
PropertiesPrivate *priv = fs->fileop_data;
|
|
gchar str[8];
|
|
|
|
sprintf (str, "(%.4o)", gtk_file_selection_properties_get_mode (priv));
|
|
gtk_label_set (GTK_LABEL (priv->mode_label), str);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_properties (gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
GtkWidget *label;
|
|
GtkWidget *dialog;
|
|
GtkWidget *vbox;
|
|
GtkWidget *hbox;
|
|
GtkWidget *button;
|
|
GtkWidget *notebook;
|
|
GtkWidget *table;
|
|
GtkWidget *hseparator;
|
|
GtkWidget *entry;
|
|
GtkWidget *togglebutton;
|
|
struct stat statbuf;
|
|
struct passwd *pw;
|
|
struct group *gp;
|
|
gchar *buf;
|
|
gchar *path;
|
|
gchar *filename;
|
|
gchar timeBuf[TIME_STRING_BUF];
|
|
gint pagenum = 0;
|
|
PropertiesPrivate *priv;
|
|
int i;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
if (fs->fileop_dialog)
|
|
return;
|
|
|
|
/* main dialog */
|
|
fs->fileop_dialog = dialog = gtk_dialog_new ();
|
|
gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
|
|
(GtkSignalFunc) gtk_file_selection_fileop_destroy,
|
|
(gpointer) fs);
|
|
priv = fs->fileop_data = g_malloc (sizeof (PropertiesPrivate));
|
|
|
|
gtk_window_set_title (GTK_WINDOW (dialog), ("Properties"));
|
|
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
|
|
|
|
/* If file dialog is grabbed, grab option dialog */
|
|
/* When option dialog closed, file dialog will be grabbed again */
|
|
if (GTK_WINDOW(fs)->modal)
|
|
gtk_window_set_modal (GTK_WINDOW(dialog), TRUE);
|
|
|
|
/* Dialog guts go here */
|
|
notebook = gtk_notebook_new ();
|
|
gtk_widget_show (notebook);
|
|
gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0);
|
|
gtk_container_set_border_width (GTK_CONTAINER (notebook), 8);
|
|
|
|
path = cmpl_reference_position(fs->cmpl_state);
|
|
fs->fileop_file = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
|
|
filename = g_strconcat(path, "/", fs->fileop_file, NULL);
|
|
if (strlen(fs->fileop_file) > 0 && !(stat(filename, &statbuf)))
|
|
{
|
|
/* stats page */
|
|
table = gtk_table_new (9, 2, FALSE);
|
|
gtk_widget_show (table);
|
|
gtk_container_add (GTK_CONTAINER (notebook), table);
|
|
gtk_container_set_border_width (GTK_CONTAINER (table), 5);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
|
|
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
|
|
|
|
label = gtk_label_new (_("Statistics"));
|
|
gtk_widget_show (label);
|
|
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), pagenum), label);
|
|
pagenum++;
|
|
/* path and filename */
|
|
label = gtk_label_new (_("Path:"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
label = gtk_label_new (_(path));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
label = gtk_label_new (_("File Name:"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
fs->fileop_entry = entry = gtk_entry_new ();
|
|
gtk_widget_show (entry);
|
|
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_entry_set_text (GTK_ENTRY (entry), fs->fileop_file);
|
|
if (access (filename, W_OK))
|
|
gtk_widget_set_sensitive( GTK_WIDGET (entry), FALSE);
|
|
|
|
hseparator = gtk_hseparator_new ();
|
|
gtk_widget_show (hseparator);
|
|
gtk_table_attach (GTK_TABLE (table), hseparator, 0, 2, 2, 3,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (GTK_FILL), 0, 0);
|
|
|
|
/* file type and size */
|
|
label = gtk_label_new (_("Type:"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
switch (statbuf.st_mode & S_IFMT)
|
|
{
|
|
case S_IFSOCK:
|
|
buf = g_strdup ("Socket");
|
|
break;
|
|
case S_IFLNK:
|
|
buf = g_strdup ("Symbolic link");
|
|
break;
|
|
case S_IFREG:
|
|
buf = g_strdup ("File");
|
|
break;
|
|
case S_IFBLK:
|
|
buf = g_strdup ("Block device");
|
|
break;
|
|
case S_IFDIR:
|
|
buf = g_strdup ("Directory");
|
|
break;
|
|
case S_IFCHR:
|
|
buf = g_strdup ("Character device");
|
|
break;
|
|
case S_IFIFO:
|
|
buf = g_strdup ("First-in/first-out pipe");
|
|
break;
|
|
default:
|
|
buf = g_strdup ("Unknown");
|
|
}
|
|
|
|
|
|
label = gtk_label_new (buf);
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 3, 4,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
label = gtk_label_new (_("Size:"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
label = gtk_label_new (_(g_strdup_printf ("%ld bytes", statbuf.st_size)));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 4, 5,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
hseparator = gtk_hseparator_new ();
|
|
gtk_widget_show (hseparator);
|
|
gtk_table_attach (GTK_TABLE (table), hseparator, 0, 2, 5, 6,
|
|
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
|
|
(GtkAttachOptions) (GTK_FILL), 0, 0);
|
|
|
|
/* file dates */
|
|
label = gtk_label_new (_("Created:"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 6, 7,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
strftime (timeBuf, TIME_STRING_BUF, "%a %b %d %X %Y", localtime(&statbuf.st_mtime));
|
|
label = gtk_label_new (_(timeBuf));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 6, 7,
|
|
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
|
|
|
|
label = gtk_label_new (_("Modified:"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 7, 8,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
strftime (timeBuf, TIME_STRING_BUF, "%a %b %d %X %Y", localtime(&statbuf.st_mtime));
|
|
label = gtk_label_new (_(timeBuf));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 7, 8,
|
|
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
|
|
label = gtk_label_new (_("Accessed:"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 8, 9,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
strftime (timeBuf, TIME_STRING_BUF, "%a %b %d %X %Y", localtime(&statbuf.st_atime));
|
|
label = gtk_label_new (_(timeBuf));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 8, 9,
|
|
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
/* permissions page */
|
|
vbox = gtk_vbox_new (FALSE, 4);
|
|
gtk_widget_show (vbox);
|
|
gtk_container_add (GTK_CONTAINER (notebook), vbox);
|
|
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
|
|
|
|
label = gtk_label_new (_("Permissions"));
|
|
gtk_widget_show (label);
|
|
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), pagenum), label);
|
|
pagenum++;
|
|
|
|
/* owner / group */
|
|
table = gtk_table_new (2, 2, FALSE);
|
|
gtk_widget_show (table);
|
|
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, TRUE, 0);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
|
|
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
|
|
|
|
label = gtk_label_new (_("Owner:"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
entry = gtk_entry_new();
|
|
gtk_widget_show (entry);
|
|
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 0, 1,
|
|
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
if ((pw = getpwuid(statbuf.st_uid)))
|
|
gtk_entry_set_text(GTK_ENTRY (entry), pw->pw_name);
|
|
else
|
|
gtk_entry_set_text(GTK_ENTRY (entry), (gpointer) statbuf.st_uid);
|
|
if (access (filename, W_OK) || (getuid() != 0))
|
|
gtk_widget_set_sensitive( GTK_WIDGET (entry), FALSE);
|
|
|
|
|
|
label = gtk_label_new (_("Group:"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
entry = gtk_entry_new();
|
|
gtk_widget_show (entry);
|
|
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, 1, 2,
|
|
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
if ((gp = getgrgid(statbuf.st_gid)))
|
|
gtk_entry_set_text(GTK_ENTRY (entry), gp->gr_name);
|
|
else
|
|
gtk_entry_set_text(GTK_ENTRY (entry), (gpointer) statbuf.st_gid);
|
|
if (access (filename, W_OK) || (getuid() != 0))
|
|
gtk_widget_set_sensitive( GTK_WIDGET (entry), FALSE);
|
|
|
|
|
|
hseparator = gtk_hseparator_new ();
|
|
gtk_widget_show (hseparator);
|
|
gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, TRUE, 0);
|
|
|
|
/* permissions */
|
|
table = gtk_table_new (4, 5, TRUE);
|
|
gtk_widget_show (table);
|
|
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
|
|
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
|
|
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
|
|
if (access (filename, W_OK) || ((getuid() != statbuf.st_uid) && getuid() != 0))
|
|
gtk_widget_set_sensitive (GTK_WIDGET (table), FALSE);
|
|
|
|
hbox = gtk_hbox_new (FALSE, 1);
|
|
gtk_widget_show (hbox);
|
|
gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, 0, 1,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (GTK_FILL), 0, 0);
|
|
|
|
priv->mode_label = label = gtk_label_new ("(0000)");
|
|
gtk_widget_show (label);
|
|
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
|
|
|
|
label = gtk_label_new (_("Read"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 1, 2, 0, 1,
|
|
(GtkAttachOptions) (0),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
|
|
label = gtk_label_new (_("Write"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
|
|
(GtkAttachOptions) (0),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
|
|
label = gtk_label_new (_("Exec"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 3, 4, 0, 1,
|
|
(GtkAttachOptions) (0),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
|
|
label = gtk_label_new (_("Special"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 4, 5, 0, 1,
|
|
(GtkAttachOptions) (0),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
|
|
|
|
label = gtk_label_new (_("User:"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
priv->mode_buttons[0] = togglebutton = gtk_toggle_button_new_with_label ("");
|
|
gtk_widget_show (togglebutton);
|
|
gtk_table_attach (GTK_TABLE (table), togglebutton, 1, 2, 1, 2,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
if ((statbuf.st_mode & ~(S_IFMT)) & S_IRUSR)
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
|
|
|
|
priv->mode_buttons[1] = togglebutton = gtk_toggle_button_new_with_label ("");
|
|
gtk_widget_show (togglebutton);
|
|
gtk_table_attach (GTK_TABLE (table), togglebutton, 2, 3, 1, 2,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
if ((statbuf.st_mode & ~(S_IFMT)) & S_IWUSR)
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
|
|
|
|
priv->mode_buttons[2] = togglebutton = gtk_toggle_button_new_with_label ("");
|
|
gtk_widget_show (togglebutton);
|
|
gtk_table_attach (GTK_TABLE (table), togglebutton, 3, 4, 1, 2,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
if ((statbuf.st_mode & ~(S_IFMT)) & S_IXUSR)
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
|
|
|
|
priv->mode_buttons[3] = togglebutton = gtk_toggle_button_new_with_label ("");
|
|
gtk_widget_show (togglebutton);
|
|
gtk_table_attach (GTK_TABLE (table), togglebutton, 4, 5, 1, 2,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
if ((statbuf.st_mode & ~(S_IFMT)) & S_ISUID)
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
|
|
|
|
|
|
|
|
label = gtk_label_new (_("Group:"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
priv->mode_buttons[4] = togglebutton = gtk_toggle_button_new_with_label ("");
|
|
gtk_widget_show (togglebutton);
|
|
gtk_table_attach (GTK_TABLE (table), togglebutton, 1, 2, 2, 3,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
if ((statbuf.st_mode & ~(S_IFMT)) & S_IRGRP)
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
|
|
|
|
priv->mode_buttons[5] = togglebutton = gtk_toggle_button_new_with_label ("");
|
|
gtk_widget_show (togglebutton);
|
|
gtk_table_attach (GTK_TABLE (table), togglebutton, 2, 3, 2, 3,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
if ((statbuf.st_mode & ~(S_IFMT)) & S_IWGRP)
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
|
|
|
|
priv->mode_buttons[6] = togglebutton = gtk_toggle_button_new_with_label ("");
|
|
gtk_widget_show (togglebutton);
|
|
gtk_table_attach (GTK_TABLE (table), togglebutton, 3, 4, 2, 3,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
if ((statbuf.st_mode & ~(S_IFMT)) & S_IXGRP)
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
|
|
|
|
priv->mode_buttons[7] = togglebutton = gtk_toggle_button_new_with_label ("");
|
|
gtk_widget_show (togglebutton);
|
|
gtk_table_attach (GTK_TABLE (table), togglebutton, 4, 5, 2, 3,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
if ((statbuf.st_mode & ~(S_IFMT)) & S_ISGID)
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
|
|
|
|
label = gtk_label_new (_("Other:"));
|
|
gtk_widget_show (label);
|
|
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
|
|
|
|
priv->mode_buttons[8] = togglebutton = gtk_toggle_button_new_with_label ("");
|
|
gtk_widget_show (togglebutton);
|
|
gtk_table_attach (GTK_TABLE (table), togglebutton, 1, 2, 3, 4,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
if ((statbuf.st_mode & ~(S_IFMT)) & S_IROTH)
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
|
|
|
|
priv->mode_buttons[9] = togglebutton = gtk_toggle_button_new_with_label ("");
|
|
gtk_widget_show (togglebutton);
|
|
gtk_table_attach (GTK_TABLE (table), togglebutton, 2, 3, 3, 4,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
if ((statbuf.st_mode & ~(S_IFMT)) & S_IWOTH)
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
|
|
|
|
priv->mode_buttons[10] = togglebutton = gtk_toggle_button_new_with_label ("");
|
|
gtk_widget_show (togglebutton);
|
|
gtk_table_attach (GTK_TABLE (table), togglebutton, 3, 4, 3, 4,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
if ((statbuf.st_mode & ~(S_IFMT)) & S_IXOTH)
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
|
|
|
|
priv->mode_buttons[11] = togglebutton = gtk_toggle_button_new_with_label ("");
|
|
gtk_widget_show (togglebutton);
|
|
gtk_table_attach (GTK_TABLE (table), togglebutton, 4, 5, 3, 4,
|
|
(GtkAttachOptions) (GTK_FILL),
|
|
(GtkAttachOptions) (0), 0, 0);
|
|
if ((statbuf.st_mode & ~(S_IFMT)) & S_ISVTX)
|
|
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (togglebutton), TRUE);
|
|
|
|
for (i = 0; i < 12; i++)
|
|
gtk_signal_connect (GTK_OBJECT (priv->mode_buttons[i]), "toggled",
|
|
GTK_SIGNAL_FUNC (gtk_file_selection_properties_update_mode), fs);
|
|
gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (priv->mode_buttons[0]));
|
|
}
|
|
/* global page */
|
|
vbox = gtk_vbox_new (FALSE, 0);
|
|
gtk_widget_show (vbox);
|
|
gtk_container_add (GTK_CONTAINER (notebook), vbox);
|
|
|
|
label = gtk_label_new (_("Global"));
|
|
gtk_widget_show (label);
|
|
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), pagenum), label);
|
|
pagenum++;
|
|
|
|
label = gtk_label_new (_("dialog preferances will go here"));
|
|
gtk_widget_show (label);
|
|
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
|
|
|
|
/* end of dialog guts */
|
|
|
|
/* buttons */
|
|
button = gtk_button_new_with_label (_("OK"));
|
|
// gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
|
// (GtkSignalFunc) gtk_file_selection_rename_file_confirmed,
|
|
// (gpointer) fs);
|
|
gtk_signal_connect (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_file_selection_file_mode_confirmed,
|
|
(gpointer) fs);
|
|
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
|
|
button, TRUE, TRUE, 0);
|
|
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
|
|
gtk_widget_show(button);
|
|
|
|
button = gtk_button_new_with_label (_("Cancel"));
|
|
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
|
|
(GtkSignalFunc) gtk_widget_destroy,
|
|
(gpointer) dialog);
|
|
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
|
|
button, TRUE, TRUE, 0);
|
|
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
|
|
gtk_widget_grab_default(button);
|
|
gtk_widget_show (button);
|
|
|
|
g_free (filename);
|
|
gtk_widget_show (dialog);
|
|
}
|
|
|
|
static gint
|
|
gtk_file_selection_key_press (GtkWidget *widget,
|
|
GdkEventKey *event,
|
|
gpointer user_data)
|
|
{
|
|
|
|
GtkFileSelection *fs;
|
|
char *text;
|
|
|
|
g_return_val_if_fail (widget != NULL, FALSE);
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
fs = GTK_FILE_SELECTION (user_data);
|
|
|
|
if (fs->saved_entry)
|
|
{
|
|
gtk_clist_unselect_all ((GtkCList *) (fs->dir_list));
|
|
gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),fs->saved_entry);
|
|
g_free (fs->saved_entry);
|
|
fs->saved_entry = NULL;
|
|
}
|
|
if (event->keyval == GDK_Tab)
|
|
{
|
|
text = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
|
|
|
|
text = g_strdup (text);
|
|
|
|
gtk_file_selection_populate (fs, text, TRUE);
|
|
|
|
g_free (text);
|
|
|
|
gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
static void
|
|
gtk_file_selection_home_button (GtkWidget *widget, gpointer data){
|
|
GList *list;
|
|
|
|
GtkFileSelection *fs=data;
|
|
|
|
list = fs->next_history;
|
|
if (list)
|
|
{
|
|
g_free (list->data);
|
|
list = list->next;
|
|
}
|
|
g_list_free (fs->next_history);
|
|
fs->next_history = NULL;
|
|
|
|
gtk_file_selection_populate (fs,"~/",FALSE);
|
|
}
|
|
*/
|
|
static void
|
|
gtk_file_selection_bookmark_button (GtkWidget *widget,
|
|
GtkFileSelection *fs)
|
|
{
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_FILE_SELECTION (fs));
|
|
|
|
gtk_menu_popup (GTK_MENU (fs->bookmark_menu), NULL, NULL, NULL, NULL,
|
|
0, 0);
|
|
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_up_button (GtkWidget *widget, gpointer data){
|
|
GtkFileSelection *fs = data;
|
|
GList *list;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
list = fs->next_history;
|
|
if (list)
|
|
{
|
|
g_free (list->data);
|
|
list = list->next;
|
|
}
|
|
g_list_free (fs->next_history);
|
|
fs->next_history = NULL;
|
|
|
|
gtk_file_selection_populate (fs, "../", FALSE); /*change directories. */
|
|
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_prev_button (GtkWidget *widget, gpointer data){
|
|
GtkFileSelection *fs = data;
|
|
GList *list;
|
|
GList *first;
|
|
gchar *path;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
list = fs->prev_history;
|
|
|
|
if (list && g_list_length(list) > 1)
|
|
{
|
|
first = list; /* get first element */
|
|
list = list->next; /* pop off current directory */
|
|
|
|
list->prev = NULL; /* make this the new head. */
|
|
|
|
fs->prev_history = list; /* update prev_history list */
|
|
fs->next_history = g_list_prepend(fs->next_history,first->data); /* put it on next_history */
|
|
|
|
first->next = NULL; /* orphan the old first node */
|
|
g_list_free (first); /* free the node (data is now in use by next_history) */
|
|
|
|
|
|
|
|
path = g_malloc(strlen(list->data)+4); /* plenty of space */
|
|
strcpy(path,list->data); /* get the 2nd path in the history */
|
|
strcat(path,"/"); /* append a '/' */
|
|
gtk_file_selection_populate (fs, path, FALSE); /* change directories. */
|
|
g_free (path);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_next_button (GtkWidget *widget, gpointer data){
|
|
GtkFileSelection *fs = data;
|
|
GList *list;
|
|
GList *first;
|
|
gchar *path;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
list = fs->next_history;
|
|
|
|
if (list && g_list_length(list) > 0)
|
|
{
|
|
first = list; /*get first element*/
|
|
list = list->next; /*pop off current directory*/
|
|
|
|
if (list)
|
|
list->prev = NULL;
|
|
|
|
fs->next_history = list; /*update prev_history list*/
|
|
|
|
path = g_malloc(strlen(first->data)+4); /*plenty of space*/
|
|
strcpy(path,first->data);
|
|
strcat(path,"/"); /*append a / */
|
|
gtk_file_selection_populate (fs, path, FALSE); /*change directories.*/
|
|
g_free(path);
|
|
|
|
first->next = NULL; /* orphan the old first node */
|
|
g_list_free (first); /* free the node (data is now in use by next_history) */
|
|
|
|
}
|
|
}
|
|
|
|
void static
|
|
gtk_file_selection_refresh_button (GtkWidget *widget, gpointer data){
|
|
GtkFileSelection *fs = data;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
gtk_file_selection_populate (fs,"",FALSE);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_mask_entry_callback (GtkWidget *widget, gpointer data){
|
|
GtkFileSelection *fs = data;
|
|
|
|
if(fs->mask)
|
|
g_free (fs->mask);
|
|
|
|
fs->mask = g_strdup(gtk_entry_get_text (GTK_ENTRY(GTK_COMBO(fs->mask_entry)->entry)));
|
|
|
|
if (strlen(fs->mask) == 0)
|
|
{
|
|
g_free (fs->mask);
|
|
fs->mask = NULL;
|
|
}
|
|
|
|
gtk_file_selection_refresh_button (widget,data);
|
|
}
|
|
|
|
static gint gtk_file_selection_files_list_key_callback (GtkWidget *widget, GdkEventKey *event, gpointer data){
|
|
GtkFileSelection *fs=data;
|
|
gchar *saved;
|
|
gchar key[2];
|
|
|
|
// g_print("Key event: %d\n",event->keyval);
|
|
//we need some sort of timeout.
|
|
|
|
//if the key is a normal character then
|
|
//add to our saved_entry1
|
|
//if it's backspace then remove one character
|
|
//otherwise let it through (and erase our buffer.
|
|
|
|
if(event->keyval > GDK_space && event->keyval <= GDK_Korean_Won) {
|
|
key[1]=0;
|
|
key[0]=event->keyval;
|
|
saved=fs->saved_entry1;
|
|
if(fs->saved_entry1){
|
|
fs->saved_entry1=g_strconcat(saved,key,NULL);
|
|
g_free(saved);
|
|
}else{
|
|
fs->saved_entry1=g_strdup(key);
|
|
}
|
|
g_print("complete: %s\n",fs->saved_entry1);
|
|
/*gtk_label_set_text(GTK_LABEL(fs->completion_label), fs->saved_entry1); */
|
|
|
|
saved=g_strdup(gtk_entry_get_text(GTK_ENTRY(fs->selection_entry)));
|
|
gtk_file_selection_complete(fs,fs->saved_entry1);
|
|
gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),saved);
|
|
g_free(saved);
|
|
}else if (event->keyval == GDK_BackSpace) {
|
|
if(strlen(fs->saved_entry1)){
|
|
fs->saved_entry1[strlen(fs->saved_entry1)-1]=0;
|
|
g_print("complete: %s\n",fs->saved_entry1);
|
|
/*gtk_label_set_text(GTK_LABEL(fs->completion_label),fs->saved_entry1); */
|
|
saved=g_strdup(gtk_entry_get_text(GTK_ENTRY(fs->selection_entry)));
|
|
gtk_file_selection_complete(fs,fs->saved_entry1);
|
|
gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),saved);
|
|
g_free(saved);
|
|
}
|
|
}else if (event->keyval == GDK_Tab) {
|
|
saved=g_strdup(gtk_entry_get_text(GTK_ENTRY(fs->selection_entry)));
|
|
gtk_file_selection_populate(fs,fs->saved_entry1,TRUE);
|
|
g_free(fs->saved_entry1);
|
|
fs->saved_entry1=gtk_entry_get_text(GTK_ENTRY(fs->selection_entry));
|
|
gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),saved);
|
|
g_free(saved);
|
|
|
|
g_print("complete: %s\n",fs->saved_entry1);
|
|
/* gtk_label_set_text(GTK_LABEL(fs->completion_label),fs->saved_entry1);*/
|
|
|
|
gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
|
|
}else {
|
|
if(fs->saved_entry1){
|
|
g_free(fs->saved_entry1);
|
|
fs->saved_entry1=NULL;
|
|
}
|
|
/* gtk_label_set_text(GTK_LABEL(fs->completion_label)," "); */
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static gint gtk_file_selection_mask_entry_key_callback (GtkWidget *widget, GdkEventKey *event, gpointer data)
|
|
{
|
|
GtkEntry *entry=(GtkEntry *)widget;
|
|
GtkFileSelection *fs=data;
|
|
|
|
g_return_val_if_fail (fs != NULL,FALSE);
|
|
g_return_val_if_fail (GTK_IS_FILE_SELECTION (fs),FALSE);
|
|
|
|
|
|
if (event->keyval == GDK_Return || event->keyval == GDK_Tab)
|
|
{
|
|
if(fs->mask)
|
|
g_free(fs->mask);
|
|
|
|
fs->mask=g_strdup(gtk_entry_get_text(entry));
|
|
gtk_file_selection_refresh_button(widget,fs);
|
|
|
|
if (event->keyval == GDK_Return)
|
|
gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
static gint gtk_file_selection_mask_entry_button_callback (GtkWidget *widget, GdkEventButton *event, gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
|
|
if(fs->mask)
|
|
g_free(fs->mask);
|
|
|
|
fs->mask=g_strdup(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(fs->mask_entry)->entry)));
|
|
gtk_file_selection_refresh_button(widget,fs);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
static gboolean gtk_file_selection_history_combo_list_key_handler(GtkWidget *widget,
|
|
GdkEventKey *event,
|
|
gpointer user_data)
|
|
{
|
|
/*
|
|
g_print("Key pressed! \n");
|
|
*/
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean gtk_file_selection_history_combo_list_callback (GtkWidget *thelist,
|
|
GdkEventButton *event,
|
|
gpointer user_data)
|
|
{
|
|
|
|
GtkFileSelection *fs = user_data;
|
|
GList *list;
|
|
gchar *path;
|
|
|
|
list = fs->next_history;
|
|
if(list)
|
|
{
|
|
g_free (list->data);
|
|
list = list->next;
|
|
}
|
|
g_list_free (fs->next_history);
|
|
fs->next_history = NULL;
|
|
|
|
path = g_malloc(strlen(gtk_entry_get_text(GTK_ENTRY (((GtkCombo *)fs->history_combo)->entry)))+4);
|
|
strcpy (path,gtk_entry_get_text(GTK_ENTRY( ((GtkCombo *)fs->history_combo)->entry)));
|
|
strcat (path,"/");
|
|
|
|
gtk_file_selection_populate (fs,path,TRUE);
|
|
|
|
g_free (path);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gtk_file_selection_history_combo_callback (GtkWidget *widget, GdkEventKey *event, gpointer data)
|
|
{
|
|
GtkEntry *entry=(GtkEntry *)widget;
|
|
GtkFileSelection *fs=data;
|
|
GList *list;
|
|
gchar *path;
|
|
|
|
g_return_val_if_fail (fs != NULL,FALSE);
|
|
g_return_val_if_fail (GTK_IS_FILE_SELECTION (fs),FALSE);
|
|
|
|
|
|
if (event->keyval == GDK_Return)
|
|
{
|
|
list = fs->next_history;
|
|
if (list)
|
|
{
|
|
g_free (list->data);
|
|
list = list->next;
|
|
}
|
|
g_list_free (fs->next_history);
|
|
fs->next_history = NULL;
|
|
|
|
path = g_malloc(strlen(gtk_entry_get_text(entry))+4);
|
|
strcpy (path,gtk_entry_get_text(entry));
|
|
strcat (path,"/");
|
|
gtk_file_selection_populate (fs,path,TRUE);
|
|
g_free (path);
|
|
gtk_signal_emit_stop_by_name (GTK_OBJECT (widget), "key_press_event");
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
static void gtk_file_selection_bookmark_callback (GtkWidget *widget, gpointer data)
|
|
{
|
|
GtkFileSelection *fs = data;
|
|
BookmarkMenuStruct *item;
|
|
GList *list;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
//g_print ("Callback\n");
|
|
list = fs->bookmark_list;
|
|
while(list) {
|
|
item = list->data;
|
|
if (item->menu_item == widget) {
|
|
if(strcmp(item->path,"./")) {
|
|
gtk_file_selection_populate (fs, item->path, FALSE);
|
|
}
|
|
break;
|
|
}
|
|
list=list->next;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_update_history_menu (GtkFileSelection *fs,
|
|
gchar *current_directory)
|
|
{
|
|
gchar *current_dir;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
g_return_if_fail (current_directory != NULL);
|
|
|
|
current_dir = g_strdup (current_directory);
|
|
|
|
if(fs->prev_history)
|
|
{
|
|
if (strcmp((fs->prev_history)->data,current_dir))
|
|
{ /*if this item isn't on the top of the list */
|
|
fs->prev_history = g_list_prepend(fs->prev_history,g_strdup(current_dir));
|
|
}
|
|
} else {
|
|
fs->prev_history = g_list_prepend(fs->prev_history,g_strdup(current_dir));
|
|
}
|
|
|
|
gtk_combo_set_popdown_strings (GTK_COMBO (fs->history_combo),fs->prev_history);
|
|
|
|
g_free (current_dir);
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_file_button (GtkWidget *widget,
|
|
gint row,
|
|
gint column,
|
|
GdkEventButton *bevent,
|
|
gpointer user_data)
|
|
{
|
|
GtkFileSelection *fs = NULL;
|
|
gchar *filename, *temp = NULL;
|
|
|
|
g_return_if_fail (GTK_IS_CLIST (widget));
|
|
|
|
fs = user_data;
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
gtk_clist_get_text (GTK_CLIST (fs->file_list), row, 0, &temp);
|
|
filename = g_strdup (temp);
|
|
|
|
if (filename)
|
|
{
|
|
if (fs->saved_entry)
|
|
{
|
|
gtk_clist_unselect_all ((GtkCList *) (fs->dir_list));
|
|
gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),fs->saved_entry);
|
|
g_free (fs->saved_entry);
|
|
fs->saved_entry = NULL;
|
|
}
|
|
if(fs->saved_entry1){
|
|
g_free(fs->saved_entry1);
|
|
fs->saved_entry1=NULL;
|
|
}
|
|
/* gtk_label_set_text(GTK_LABEL(fs->completion_label)," "); */
|
|
|
|
|
|
if (bevent)
|
|
switch (bevent->type)
|
|
{
|
|
case GDK_2BUTTON_PRESS:
|
|
gtk_button_clicked (GTK_BUTTON (fs->ok_button));
|
|
break;
|
|
|
|
default:
|
|
/*
|
|
if (bevent->button && GDK_BUTTON2_MASK)
|
|
{
|
|
g_print("Right click! -- %d\n",bevent->button);
|
|
}
|
|
else
|
|
{
|
|
*/
|
|
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
|
|
/*}*/
|
|
break;
|
|
}
|
|
else
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
|
|
|
|
g_free (filename);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_dir_button (GtkWidget *widget,
|
|
gint row,
|
|
gint column,
|
|
GdkEventButton *bevent,
|
|
gpointer user_data)
|
|
{
|
|
GList *list;
|
|
GtkFileSelection *fs = NULL;
|
|
gchar *filename, *temp = NULL;
|
|
|
|
g_return_if_fail (GTK_IS_CLIST (widget));
|
|
|
|
fs = GTK_FILE_SELECTION (user_data);
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
gtk_clist_get_text (GTK_CLIST (fs->dir_list), row, 0, &temp);
|
|
filename = g_strdup (temp);
|
|
|
|
if (filename)
|
|
{
|
|
if (bevent)
|
|
switch (bevent->type)
|
|
{
|
|
case GDK_2BUTTON_PRESS:
|
|
list = fs->next_history;
|
|
if (list)
|
|
{
|
|
g_free (list->data);
|
|
list = list->next;
|
|
}
|
|
g_list_free (fs->next_history);
|
|
fs->next_history = NULL;
|
|
|
|
gtk_file_selection_populate (fs, filename, FALSE);
|
|
gtk_entry_set_text(GTK_ENTRY(fs->selection_entry),fs->saved_entry);
|
|
g_free (fs->saved_entry);
|
|
fs->saved_entry = NULL;
|
|
break;
|
|
|
|
default:
|
|
/* here we need to add the "filename" to the beginning of what's already
|
|
in the entry. Save what's in the entry, then restore it on the double click
|
|
*/
|
|
if (fs->saved_entry) g_free (fs->saved_entry);
|
|
fs->saved_entry=g_strdup(gtk_entry_get_text(GTK_ENTRY (fs->selection_entry)));
|
|
|
|
temp=g_strconcat(filename,fs->saved_entry,NULL);
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), temp);
|
|
g_free (temp);
|
|
|
|
break;
|
|
}
|
|
else
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename);
|
|
|
|
g_free (filename);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_undir_button (GtkWidget *widget,
|
|
gint row,
|
|
gint column,
|
|
GdkEventButton *bevent,
|
|
gpointer user_data)
|
|
{
|
|
GtkFileSelection *fs = NULL;
|
|
gchar *filename, *temp = NULL;
|
|
|
|
g_return_if_fail (GTK_IS_CLIST (widget));
|
|
|
|
fs = GTK_FILE_SELECTION (user_data);
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
gtk_clist_get_text (GTK_CLIST (fs->dir_list), row, 0, &temp);
|
|
filename = g_strdup (temp);
|
|
|
|
if (filename)
|
|
{
|
|
if (bevent)
|
|
switch (bevent->type)
|
|
{
|
|
default:
|
|
/* here we need to add the "filename" to the beginning of what's already
|
|
in the entry. Save what's in the entry, then restore it on the double click
|
|
*/
|
|
if (fs->saved_entry)
|
|
{
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry),fs->saved_entry);
|
|
g_free (fs->saved_entry);
|
|
fs->saved_entry = NULL;
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), filename); //?????
|
|
|
|
g_free (filename);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_populate (GtkFileSelection *fs,
|
|
gchar *rel_path,
|
|
gint try_complete)
|
|
{
|
|
CompletionState *cmpl_state;
|
|
PossibleCompletion* poss;
|
|
gchar* filename;
|
|
gint row;
|
|
gchar* rem_path = rel_path;
|
|
gchar* sel_text;
|
|
gchar* text[2];
|
|
gint did_recurse = FALSE;
|
|
gint possible_count = 0;
|
|
gint selection_index = -1;
|
|
gint file_list_width;
|
|
gint dir_list_width;
|
|
|
|
g_return_if_fail (fs != NULL);
|
|
g_return_if_fail (GTK_IS_FILE_SELECTION (fs));
|
|
|
|
cmpl_state = (CompletionState*) fs->cmpl_state;
|
|
poss = cmpl_completion_matches (rel_path, &rem_path, cmpl_state);
|
|
|
|
if (!cmpl_state_okay (cmpl_state))
|
|
{
|
|
/* Something went wrong. */
|
|
gtk_file_selection_abort (fs);
|
|
return;
|
|
}
|
|
|
|
g_assert (cmpl_state->reference_dir);
|
|
|
|
gtk_clist_freeze (GTK_CLIST (fs->dir_list));
|
|
gtk_clist_clear (GTK_CLIST (fs->dir_list));
|
|
gtk_clist_freeze (GTK_CLIST (fs->file_list));
|
|
gtk_clist_clear (GTK_CLIST (fs->file_list));
|
|
|
|
/* Set the dir_list to include ./ and ../ */
|
|
/* Actually, no let's not.
|
|
text[1] = NULL;
|
|
text[0] = "./";
|
|
row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
|
|
*/
|
|
|
|
text[0] = "../"; //Do we need ..?
|
|
row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
|
|
|
|
/*reset the max widths of the lists*/
|
|
dir_list_width = gdk_string_width(fs->dir_list->style->font,"../");
|
|
gtk_clist_set_column_width(GTK_CLIST(fs->dir_list),0,dir_list_width);
|
|
file_list_width = 1;
|
|
gtk_clist_set_column_width(GTK_CLIST(fs->file_list),0,file_list_width);
|
|
|
|
while (poss)
|
|
{
|
|
if (cmpl_is_a_completion (poss))
|
|
{
|
|
possible_count += 1;
|
|
|
|
filename = cmpl_this_completion (poss);
|
|
|
|
text[0] = filename;
|
|
|
|
if (cmpl_is_directory (poss))
|
|
{
|
|
if (strcmp (filename, "./") != 0 &&
|
|
strcmp (filename, "../") != 0)
|
|
{
|
|
int width = gdk_string_width(fs->dir_list->style->font,
|
|
filename);
|
|
row = gtk_clist_append (GTK_CLIST (fs->dir_list), text);
|
|
if(width > dir_list_width)
|
|
{
|
|
dir_list_width = width;
|
|
gtk_clist_set_column_width(GTK_CLIST(fs->dir_list),0,
|
|
width);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(fs->mask)
|
|
{
|
|
if (gtk_file_selection_match_mask(filename,fs->mask))
|
|
{
|
|
int width = gdk_string_width(fs->file_list->style->font,
|
|
filename);
|
|
row = gtk_clist_append (GTK_CLIST (fs->file_list), text);
|
|
if(width > file_list_width)
|
|
{
|
|
file_list_width = width;
|
|
gtk_clist_set_column_width(GTK_CLIST(fs->file_list),0,
|
|
width);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int width = gdk_string_width(fs->file_list->style->font,
|
|
filename);
|
|
row = gtk_clist_append (GTK_CLIST (fs->file_list), text);
|
|
if(width > file_list_width)
|
|
{
|
|
file_list_width = width;
|
|
gtk_clist_set_column_width(GTK_CLIST(fs->file_list),0,
|
|
width);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
poss = cmpl_next_completion (cmpl_state);
|
|
}
|
|
|
|
gtk_clist_thaw (GTK_CLIST (fs->dir_list));
|
|
gtk_clist_thaw (GTK_CLIST (fs->file_list));
|
|
|
|
/* File lists are set. */
|
|
|
|
g_assert (cmpl_state->reference_dir);
|
|
|
|
if (try_complete)
|
|
{
|
|
|
|
/* User is trying to complete filenames, so advance the user's input
|
|
* string to the updated_text, which is the common leading substring
|
|
* of all possible completions, and if its a directory attempt
|
|
* attempt completions in it. */
|
|
|
|
if (cmpl_updated_text (cmpl_state)[0])
|
|
{
|
|
|
|
if (cmpl_updated_dir (cmpl_state))
|
|
{
|
|
gchar* dir_name = g_strdup (cmpl_updated_text (cmpl_state));
|
|
|
|
did_recurse = TRUE;
|
|
|
|
gtk_file_selection_populate (fs, dir_name, TRUE);
|
|
|
|
g_free (dir_name);
|
|
}
|
|
else
|
|
{
|
|
if (fs->selection_entry)
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry),
|
|
cmpl_updated_text (cmpl_state));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
selection_index = cmpl_last_valid_char (cmpl_state) -
|
|
(strlen (rel_path) - strlen (rem_path));
|
|
if (fs->selection_entry)
|
|
gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), rem_path);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (fs->selection_entry)
|
|
/* Here we need to take the old filename and keep it!*/
|
|
/*gtk_entry_set_text (GTK_ENTRY (fs->selection_entry), "");*/
|
|
;
|
|
}
|
|
|
|
if (!did_recurse)
|
|
{
|
|
if (fs->selection_entry)
|
|
gtk_entry_set_position (GTK_ENTRY (fs->selection_entry), selection_index);
|
|
|
|
if (fs->selection_entry)
|
|
{
|
|
sel_text = g_strconcat (_("Selection: "),
|
|
cmpl_reference_position (cmpl_state),
|
|
NULL);
|
|
|
|
/*
|
|
gtk_label_set_text (GTK_LABEL (fs->selection_text), sel_text);
|
|
*/
|
|
g_free (sel_text);
|
|
}
|
|
|
|
gtk_file_selection_update_history_menu (fs, cmpl_reference_position (cmpl_state));
|
|
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_file_selection_abort (GtkFileSelection *fs)
|
|
{
|
|
gchar err_buf[256];
|
|
|
|
sprintf (err_buf, _("Directory unreadable: %s"), cmpl_strerror (cmpl_errno));
|
|
|
|
/* BEEP gdk_beep(); */
|
|
|
|
/*
|
|
if (fs->selection_entry)
|
|
gtk_label_set_text (GTK_LABEL (fs->selection_text), err_buf);
|
|
*/
|
|
}
|
|
|
|
/**********************************************************************/
|
|
/* External Interface */
|
|
/**********************************************************************/
|
|
|
|
/* The four completion state selectors
|
|
*/
|
|
static gchar*
|
|
cmpl_updated_text (CompletionState* cmpl_state)
|
|
{
|
|
return cmpl_state->updated_text;
|
|
}
|
|
|
|
static gint
|
|
cmpl_updated_dir (CompletionState* cmpl_state)
|
|
{
|
|
return cmpl_state->re_complete;
|
|
}
|
|
|
|
static gchar*
|
|
cmpl_reference_position (CompletionState* cmpl_state)
|
|
{
|
|
return cmpl_state->reference_dir->fullname;
|
|
}
|
|
|
|
static gint
|
|
cmpl_last_valid_char (CompletionState* cmpl_state)
|
|
{
|
|
return cmpl_state->last_valid_char;
|
|
}
|
|
|
|
static gchar*
|
|
cmpl_completion_fullname (gchar* text, CompletionState* cmpl_state)
|
|
{
|
|
static char nothing[2] = "";
|
|
|
|
if (!cmpl_state_okay (cmpl_state))
|
|
{
|
|
return nothing;
|
|
}
|
|
else if (text[0] == '/')
|
|
{
|
|
strcpy (cmpl_state->updated_text, text);
|
|
}
|
|
else if (text[0] == '~')
|
|
{
|
|
CompletionDir* dir;
|
|
char* slash;
|
|
|
|
dir = open_user_dir (text, cmpl_state);
|
|
|
|
if (!dir)
|
|
{
|
|
/* spencer says just return ~something, so
|
|
* for now just do it. */
|
|
strcpy (cmpl_state->updated_text, text);
|
|
}
|
|
else
|
|
{
|
|
|
|
strcpy (cmpl_state->updated_text, dir->fullname);
|
|
|
|
slash = strchr (text, '/');
|
|
|
|
if (slash)
|
|
strcat (cmpl_state->updated_text, slash);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
strcpy (cmpl_state->updated_text, cmpl_state->reference_dir->fullname);
|
|
if (strcmp (cmpl_state->reference_dir->fullname, "/") != 0)
|
|
strcat (cmpl_state->updated_text, "/");
|
|
strcat (cmpl_state->updated_text, text);
|
|
}
|
|
|
|
return cmpl_state->updated_text;
|
|
}
|
|
|
|
/* The three completion selectors
|
|
*/
|
|
static gchar*
|
|
cmpl_this_completion (PossibleCompletion* pc)
|
|
{
|
|
return pc->text;
|
|
}
|
|
|
|
static gint
|
|
cmpl_is_directory (PossibleCompletion* pc)
|
|
{
|
|
return pc->is_directory;
|
|
}
|
|
|
|
static gint
|
|
cmpl_is_a_completion (PossibleCompletion* pc)
|
|
{
|
|
return pc->is_a_completion;
|
|
}
|
|
|
|
/**********************************************************************/
|
|
/* Construction, deletion */
|
|
/**********************************************************************/
|
|
|
|
static CompletionState*
|
|
cmpl_init_state (void)
|
|
{
|
|
gchar getcwd_buf[2*MAXPATHLEN];
|
|
CompletionState *new_state;
|
|
|
|
new_state = g_new (CompletionState, 1);
|
|
|
|
/* We don't use getcwd() on SUNOS, because, it does a popen("pwd")
|
|
* and, if that wasn't bad enough, hangs in doing so.
|
|
*/
|
|
#if defined(sun) && !defined(__SVR4)
|
|
if (!getwd (getcwd_buf))
|
|
#else
|
|
if (!getcwd (getcwd_buf, MAXPATHLEN))
|
|
#endif
|
|
{
|
|
/* Oh joy, we can't get the current directory. Um..., we should have
|
|
* a root directory, right? Right? (Probably not portable to non-Unix)
|
|
*/
|
|
strcpy (getcwd_buf, "/");
|
|
}
|
|
|
|
tryagain:
|
|
|
|
new_state->reference_dir = NULL;
|
|
new_state->completion_dir = NULL;
|
|
new_state->active_completion_dir = NULL;
|
|
new_state->directory_storage = NULL;
|
|
new_state->directory_sent_storage = NULL;
|
|
new_state->last_valid_char = 0;
|
|
new_state->updated_text = g_new (gchar, MAXPATHLEN);
|
|
new_state->updated_text_alloc = MAXPATHLEN;
|
|
new_state->the_completion.text = g_new (gchar, MAXPATHLEN);
|
|
new_state->the_completion.text_alloc = MAXPATHLEN;
|
|
new_state->user_dir_name_buffer = NULL;
|
|
new_state->user_directories = NULL;
|
|
|
|
new_state->reference_dir = open_dir (getcwd_buf, new_state);
|
|
|
|
if (!new_state->reference_dir)
|
|
{
|
|
/* Directories changing from underneath us, grumble */
|
|
strcpy (getcwd_buf, "/");
|
|
goto tryagain;
|
|
}
|
|
|
|
return new_state;
|
|
}
|
|
|
|
static void
|
|
cmpl_free_dir_list(GList* dp0)
|
|
{
|
|
GList *dp = dp0;
|
|
|
|
while (dp) {
|
|
free_dir (dp->data);
|
|
dp = dp->next;
|
|
}
|
|
|
|
g_list_free(dp0);
|
|
}
|
|
|
|
static void
|
|
cmpl_free_dir_sent_list(GList* dp0)
|
|
{
|
|
GList *dp = dp0;
|
|
|
|
while (dp) {
|
|
free_dir_sent (dp->data);
|
|
dp = dp->next;
|
|
}
|
|
|
|
g_list_free(dp0);
|
|
}
|
|
|
|
static void
|
|
cmpl_free_state (CompletionState* cmpl_state)
|
|
{
|
|
cmpl_free_dir_list (cmpl_state->directory_storage);
|
|
cmpl_free_dir_sent_list (cmpl_state->directory_sent_storage);
|
|
|
|
if (cmpl_state->user_dir_name_buffer)
|
|
g_free (cmpl_state->user_dir_name_buffer);
|
|
if (cmpl_state->user_directories)
|
|
g_free (cmpl_state->user_directories);
|
|
if (cmpl_state->the_completion.text)
|
|
g_free (cmpl_state->the_completion.text);
|
|
if (cmpl_state->updated_text)
|
|
g_free (cmpl_state->updated_text);
|
|
|
|
g_free (cmpl_state);
|
|
}
|
|
|
|
static void
|
|
free_dir(CompletionDir* dir)
|
|
{
|
|
g_free(dir->fullname);
|
|
g_free(dir);
|
|
}
|
|
|
|
static void
|
|
free_dir_sent(CompletionDirSent* sent)
|
|
{
|
|
g_free(sent->name_buffer);
|
|
g_free(sent->entries);
|
|
g_free(sent);
|
|
}
|
|
|
|
static void
|
|
prune_memory_usage(CompletionState *cmpl_state)
|
|
{
|
|
GList* cdsl = cmpl_state->directory_sent_storage;
|
|
GList* cdl = cmpl_state->directory_storage;
|
|
GList* cdl0 = cdl;
|
|
gint len = 0;
|
|
|
|
for(; cdsl && len < CMPL_DIRECTORY_CACHE_SIZE; len += 1)
|
|
cdsl = cdsl->next;
|
|
|
|
if (cdsl) {
|
|
cmpl_free_dir_sent_list(cdsl->next);
|
|
cdsl->next = NULL;
|
|
}
|
|
|
|
cmpl_state->directory_storage = NULL;
|
|
while (cdl) {
|
|
if (cdl->data == cmpl_state->reference_dir)
|
|
cmpl_state->directory_storage = g_list_prepend(NULL, cdl->data);
|
|
else
|
|
free_dir (cdl->data);
|
|
cdl = cdl->next;
|
|
}
|
|
|
|
g_list_free(cdl0);
|
|
}
|
|
|
|
/**********************************************************************/
|
|
/* The main entrances. */
|
|
/**********************************************************************/
|
|
|
|
static PossibleCompletion*
|
|
cmpl_completion_matches (gchar* text_to_complete,
|
|
gchar** remaining_text,
|
|
CompletionState* cmpl_state)
|
|
{
|
|
gchar* first_slash;
|
|
PossibleCompletion *poss;
|
|
|
|
prune_memory_usage(cmpl_state);
|
|
|
|
g_assert (text_to_complete != NULL);
|
|
|
|
cmpl_state->user_completion_index = -1;
|
|
cmpl_state->last_completion_text = text_to_complete;
|
|
cmpl_state->the_completion.text[0] = 0;
|
|
cmpl_state->last_valid_char = 0;
|
|
cmpl_state->updated_text_len = -1;
|
|
cmpl_state->updated_text[0] = 0;
|
|
cmpl_state->re_complete = FALSE;
|
|
|
|
first_slash = strchr (text_to_complete, '/');
|
|
|
|
if (text_to_complete[0] == '~' && !first_slash)
|
|
{
|
|
/* Text starts with ~ and there is no slash, show all the
|
|
* home directory completions.
|
|
*/
|
|
poss = attempt_homedir_completion (text_to_complete, cmpl_state);
|
|
|
|
update_cmpl(poss, cmpl_state);
|
|
|
|
return poss;
|
|
}
|
|
|
|
cmpl_state->reference_dir =
|
|
open_ref_dir (text_to_complete, remaining_text, cmpl_state);
|
|
|
|
if(!cmpl_state->reference_dir)
|
|
return NULL;
|
|
|
|
cmpl_state->completion_dir =
|
|
find_completion_dir (*remaining_text, remaining_text, cmpl_state);
|
|
|
|
cmpl_state->last_valid_char = *remaining_text - text_to_complete;
|
|
|
|
if(!cmpl_state->completion_dir)
|
|
return NULL;
|
|
|
|
cmpl_state->completion_dir->cmpl_index = -1;
|
|
cmpl_state->completion_dir->cmpl_parent = NULL;
|
|
cmpl_state->completion_dir->cmpl_text = *remaining_text;
|
|
|
|
cmpl_state->active_completion_dir = cmpl_state->completion_dir;
|
|
|
|
cmpl_state->reference_dir = cmpl_state->completion_dir;
|
|
|
|
poss = attempt_file_completion(cmpl_state);
|
|
|
|
update_cmpl(poss, cmpl_state);
|
|
|
|
return poss;
|
|
}
|
|
|
|
static PossibleCompletion*
|
|
cmpl_next_completion (CompletionState* cmpl_state)
|
|
{
|
|
PossibleCompletion* poss = NULL;
|
|
|
|
cmpl_state->the_completion.text[0] = 0;
|
|
|
|
if(cmpl_state->user_completion_index >= 0)
|
|
poss = attempt_homedir_completion(cmpl_state->last_completion_text, cmpl_state);
|
|
else
|
|
poss = attempt_file_completion(cmpl_state);
|
|
|
|
update_cmpl(poss, cmpl_state);
|
|
|
|
return poss;
|
|
}
|
|
|
|
/**********************************************************************/
|
|
/* Directory Operations */
|
|
/**********************************************************************/
|
|
|
|
/* Open the directory where completion will begin from, if possible. */
|
|
static CompletionDir*
|
|
open_ref_dir(gchar* text_to_complete,
|
|
gchar** remaining_text,
|
|
CompletionState* cmpl_state)
|
|
{
|
|
gchar* first_slash;
|
|
CompletionDir *new_dir;
|
|
|
|
first_slash = strchr(text_to_complete, '/');
|
|
|
|
if (text_to_complete[0] == '~')
|
|
{
|
|
new_dir = open_user_dir(text_to_complete, cmpl_state);
|
|
|
|
if(new_dir)
|
|
{
|
|
if(first_slash)
|
|
*remaining_text = first_slash + 1;
|
|
else
|
|
*remaining_text = text_to_complete + strlen(text_to_complete);
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
else if (text_to_complete[0] == '/' || !cmpl_state->reference_dir)
|
|
{
|
|
gchar *tmp = g_strdup(text_to_complete);
|
|
gchar *p;
|
|
|
|
p = tmp;
|
|
while (*p && *p != '*' && *p != '?')
|
|
p++;
|
|
|
|
*p = '\0';
|
|
p = strrchr(tmp, '/');
|
|
if (p)
|
|
{
|
|
if (p == tmp)
|
|
p++;
|
|
|
|
*p = '\0';
|
|
|
|
new_dir = open_dir(tmp, cmpl_state);
|
|
|
|
if(new_dir)
|
|
*remaining_text = text_to_complete +
|
|
((p == tmp + 1) ? (p - tmp) : (p + 1 - tmp));
|
|
}
|
|
else
|
|
{
|
|
/* If no possible candidates, use the cwd */
|
|
gchar *curdir = g_get_current_dir ();
|
|
|
|
new_dir = open_dir(curdir, cmpl_state);
|
|
|
|
if (new_dir)
|
|
*remaining_text = text_to_complete;
|
|
|
|
g_free (curdir);
|
|
}
|
|
|
|
g_free (tmp);
|
|
}
|
|
else
|
|
{
|
|
*remaining_text = text_to_complete;
|
|
|
|
new_dir = open_dir(cmpl_state->reference_dir->fullname, cmpl_state);
|
|
}
|
|
|
|
if(new_dir)
|
|
{
|
|
new_dir->cmpl_index = -1;
|
|
new_dir->cmpl_parent = NULL;
|
|
}
|
|
|
|
return new_dir;
|
|
}
|
|
|
|
/* open a directory by user name */
|
|
static CompletionDir*
|
|
open_user_dir(gchar* text_to_complete,
|
|
CompletionState *cmpl_state)
|
|
{
|
|
gchar *first_slash;
|
|
gint cmp_len;
|
|
|
|
g_assert(text_to_complete && text_to_complete[0] == '~');
|
|
|
|
first_slash = strchr(text_to_complete, '/');
|
|
|
|
if (first_slash)
|
|
cmp_len = first_slash - text_to_complete - 1;
|
|
else
|
|
cmp_len = strlen(text_to_complete + 1);
|
|
|
|
if(!cmp_len)
|
|
{
|
|
/* ~/ */
|
|
gchar *homedir = g_get_home_dir ();
|
|
|
|
if (homedir)
|
|
return open_dir(homedir, cmpl_state);
|
|
else
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
/* ~user/ */
|
|
char* copy = g_new(char, cmp_len + 1);
|
|
struct passwd *pwd;
|
|
strncpy(copy, text_to_complete + 1, cmp_len);
|
|
copy[cmp_len] = 0;
|
|
pwd = getpwnam(copy);
|
|
g_free(copy);
|
|
if (!pwd)
|
|
{
|
|
cmpl_errno = errno;
|
|
return NULL;
|
|
}
|
|
|
|
return open_dir(pwd->pw_dir, cmpl_state);
|
|
}
|
|
}
|
|
|
|
/* open a directory relative the the current relative directory */
|
|
static CompletionDir*
|
|
open_relative_dir(gchar* dir_name,
|
|
CompletionDir* dir,
|
|
CompletionState *cmpl_state)
|
|
{
|
|
gchar path_buf[2*MAXPATHLEN];
|
|
|
|
if(dir->fullname_len + strlen(dir_name) + 2 >= MAXPATHLEN)
|
|
{
|
|
cmpl_errno = CMPL_ERRNO_TOO_LONG;
|
|
return NULL;
|
|
}
|
|
|
|
strcpy(path_buf, dir->fullname);
|
|
|
|
if(dir->fullname_len > 1)
|
|
{
|
|
path_buf[dir->fullname_len] = '/';
|
|
strcpy(path_buf + dir->fullname_len + 1, dir_name);
|
|
}
|
|
else
|
|
{
|
|
strcpy(path_buf + dir->fullname_len, dir_name);
|
|
}
|
|
|
|
return open_dir(path_buf, cmpl_state);
|
|
}
|
|
|
|
/* after the cache lookup fails, really open a new directory */
|
|
static CompletionDirSent*
|
|
open_new_dir(gchar* dir_name, struct stat* sbuf, gboolean stat_subdirs)
|
|
{
|
|
CompletionDirSent* sent;
|
|
DIR* directory;
|
|
gchar *buffer_ptr;
|
|
struct dirent *dirent_ptr;
|
|
gint buffer_size = 0;
|
|
gint entry_count = 0;
|
|
gint i;
|
|
struct stat ent_sbuf;
|
|
char path_buf[MAXPATHLEN*2];
|
|
gint path_buf_len;
|
|
|
|
sent = g_new(CompletionDirSent, 1);
|
|
sent->mtime = sbuf->st_mtime;
|
|
sent->inode = sbuf->st_ino;
|
|
sent->device = sbuf->st_dev;
|
|
|
|
path_buf_len = strlen(dir_name);
|
|
|
|
if (path_buf_len > MAXPATHLEN)
|
|
{
|
|
cmpl_errno = CMPL_ERRNO_TOO_LONG;
|
|
return NULL;
|
|
}
|
|
|
|
strcpy(path_buf, dir_name);
|
|
|
|
directory = opendir(dir_name);
|
|
|
|
if(!directory)
|
|
{
|
|
cmpl_errno = errno;
|
|
return NULL;
|
|
}
|
|
|
|
while((dirent_ptr = readdir(directory)) != NULL)
|
|
{
|
|
int entry_len = strlen(dirent_ptr->d_name);
|
|
buffer_size += entry_len + 1;
|
|
entry_count += 1;
|
|
|
|
if(path_buf_len + entry_len + 2 >= MAXPATHLEN)
|
|
{
|
|
cmpl_errno = CMPL_ERRNO_TOO_LONG;
|
|
closedir(directory);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
sent->name_buffer = g_new(gchar, buffer_size);
|
|
sent->entries = g_new(CompletionDirEntry, entry_count);
|
|
sent->entry_count = entry_count;
|
|
|
|
buffer_ptr = sent->name_buffer;
|
|
|
|
rewinddir(directory);
|
|
|
|
for(i = 0; i < entry_count; i += 1)
|
|
{
|
|
dirent_ptr = readdir(directory);
|
|
|
|
if(!dirent_ptr)
|
|
{
|
|
cmpl_errno = errno;
|
|
closedir(directory);
|
|
return NULL;
|
|
}
|
|
|
|
strcpy(buffer_ptr, dirent_ptr->d_name);
|
|
sent->entries[i].entry_name = buffer_ptr;
|
|
buffer_ptr += strlen(dirent_ptr->d_name);
|
|
*buffer_ptr = 0;
|
|
buffer_ptr += 1;
|
|
|
|
path_buf[path_buf_len] = '/';
|
|
strcpy(path_buf + path_buf_len + 1, dirent_ptr->d_name);
|
|
|
|
if (stat_subdirs)
|
|
{
|
|
if(stat(path_buf, &ent_sbuf) >= 0 && S_ISDIR(ent_sbuf.st_mode))
|
|
sent->entries[i].is_dir = 1;
|
|
else
|
|
/* stat may fail, and we don't mind, since it could be a
|
|
* dangling symlink. */
|
|
sent->entries[i].is_dir = 0;
|
|
}
|
|
else
|
|
sent->entries[i].is_dir = 1;
|
|
}
|
|
|
|
qsort(sent->entries, sent->entry_count, sizeof(CompletionDirEntry), compare_cmpl_dir);
|
|
|
|
closedir(directory);
|
|
|
|
return sent;
|
|
}
|
|
|
|
static gboolean
|
|
check_dir(gchar *dir_name, struct stat *result, gboolean *stat_subdirs)
|
|
{
|
|
/* A list of directories that we know only contain other directories.
|
|
* Trying to stat every file in these directories would be very
|
|
* expensive.
|
|
*/
|
|
|
|
static struct {
|
|
gchar *name;
|
|
gboolean present;
|
|
struct stat statbuf;
|
|
} no_stat_dirs[] = {
|
|
{ "/afs", FALSE, { 0 } },
|
|
{ "/net", FALSE, { 0 } }
|
|
};
|
|
|
|
static const gint n_no_stat_dirs = sizeof(no_stat_dirs) / sizeof(no_stat_dirs[0]);
|
|
static gboolean initialized = FALSE;
|
|
|
|
gint i;
|
|
|
|
if (!initialized)
|
|
{
|
|
initialized = TRUE;
|
|
for (i = 0; i < n_no_stat_dirs; i++)
|
|
{
|
|
if (stat (no_stat_dirs[i].name, &no_stat_dirs[i].statbuf) == 0)
|
|
no_stat_dirs[i].present = TRUE;
|
|
}
|
|
}
|
|
|
|
if(stat(dir_name, result) < 0)
|
|
{
|
|
cmpl_errno = errno;
|
|
return FALSE;
|
|
}
|
|
|
|
*stat_subdirs = TRUE;
|
|
for (i=0; i<n_no_stat_dirs; i++)
|
|
{
|
|
if (no_stat_dirs[i].present &&
|
|
(no_stat_dirs[i].statbuf.st_dev == result->st_dev) &&
|
|
(no_stat_dirs[i].statbuf.st_ino == result->st_ino))
|
|
{
|
|
*stat_subdirs = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* open a directory by absolute pathname */
|
|
static CompletionDir*
|
|
open_dir(gchar* dir_name, CompletionState* cmpl_state)
|
|
{
|
|
struct stat sbuf;
|
|
gboolean stat_subdirs;
|
|
CompletionDirSent *sent;
|
|
GList* cdsl;
|
|
|
|
if (!check_dir (dir_name, &sbuf, &stat_subdirs))
|
|
return NULL;
|
|
|
|
cdsl = cmpl_state->directory_sent_storage;
|
|
|
|
while (cdsl)
|
|
{
|
|
sent = cdsl->data;
|
|
|
|
if(sent->inode == sbuf.st_ino &&
|
|
sent->mtime == sbuf.st_mtime &&
|
|
sent->device == sbuf.st_dev)
|
|
return attach_dir(sent, dir_name, cmpl_state);
|
|
|
|
cdsl = cdsl->next;
|
|
}
|
|
|
|
sent = open_new_dir(dir_name, &sbuf, stat_subdirs);
|
|
|
|
if (sent) {
|
|
cmpl_state->directory_sent_storage =
|
|
g_list_prepend(cmpl_state->directory_sent_storage, sent);
|
|
|
|
return attach_dir(sent, dir_name, cmpl_state);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static CompletionDir*
|
|
attach_dir(CompletionDirSent* sent, gchar* dir_name, CompletionState *cmpl_state)
|
|
{
|
|
CompletionDir* new_dir;
|
|
|
|
new_dir = g_new(CompletionDir, 1);
|
|
|
|
cmpl_state->directory_storage =
|
|
g_list_prepend(cmpl_state->directory_storage, new_dir);
|
|
|
|
new_dir->sent = sent;
|
|
new_dir->fullname = g_strdup(dir_name);
|
|
new_dir->fullname_len = strlen(dir_name);
|
|
|
|
return new_dir;
|
|
}
|
|
|
|
static gint
|
|
correct_dir_fullname(CompletionDir* cmpl_dir)
|
|
{
|
|
gint length = strlen(cmpl_dir->fullname);
|
|
struct stat sbuf;
|
|
|
|
if (strcmp(cmpl_dir->fullname + length - 2, "/.") == 0)
|
|
{
|
|
if (length == 2)
|
|
{
|
|
strcpy(cmpl_dir->fullname, "/");
|
|
cmpl_dir->fullname_len = 1;
|
|
return TRUE;
|
|
} else {
|
|
cmpl_dir->fullname[length - 2] = 0;
|
|
}
|
|
}
|
|
else if (strcmp(cmpl_dir->fullname + length - 3, "/./") == 0)
|
|
cmpl_dir->fullname[length - 2] = 0;
|
|
else if (strcmp(cmpl_dir->fullname + length - 3, "/..") == 0)
|
|
{
|
|
if(length == 3)
|
|
{
|
|
strcpy(cmpl_dir->fullname, "/");
|
|
cmpl_dir->fullname_len = 1;
|
|
return TRUE;
|
|
}
|
|
|
|
if(stat(cmpl_dir->fullname, &sbuf) < 0)
|
|
{
|
|
cmpl_errno = errno;
|
|
return FALSE;
|
|
}
|
|
|
|
cmpl_dir->fullname[length - 2] = 0;
|
|
|
|
if(!correct_parent(cmpl_dir, &sbuf))
|
|
return FALSE;
|
|
}
|
|
else if (strcmp(cmpl_dir->fullname + length - 4, "/../") == 0)
|
|
{
|
|
if(length == 4)
|
|
{
|
|
strcpy(cmpl_dir->fullname, "/");
|
|
cmpl_dir->fullname_len = 1;
|
|
return TRUE;
|
|
}
|
|
|
|
if(stat(cmpl_dir->fullname, &sbuf) < 0)
|
|
{
|
|
cmpl_errno = errno;
|
|
return FALSE;
|
|
}
|
|
|
|
cmpl_dir->fullname[length - 3] = 0;
|
|
|
|
if(!correct_parent(cmpl_dir, &sbuf))
|
|
return FALSE;
|
|
}
|
|
|
|
cmpl_dir->fullname_len = strlen(cmpl_dir->fullname);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gint
|
|
correct_parent(CompletionDir* cmpl_dir, struct stat *sbuf)
|
|
{
|
|
struct stat parbuf;
|
|
gchar *last_slash;
|
|
gchar *new_name;
|
|
gchar c = 0;
|
|
|
|
last_slash = strrchr(cmpl_dir->fullname, '/');
|
|
|
|
g_assert(last_slash);
|
|
|
|
if(last_slash != cmpl_dir->fullname)
|
|
{ /* last_slash[0] = 0; */ }
|
|
else
|
|
{
|
|
c = last_slash[1];
|
|
last_slash[1] = 0;
|
|
}
|
|
|
|
if (stat(cmpl_dir->fullname, &parbuf) < 0)
|
|
{
|
|
cmpl_errno = errno;
|
|
return FALSE;
|
|
}
|
|
|
|
if (parbuf.st_ino == sbuf->st_ino && parbuf.st_dev == sbuf->st_dev)
|
|
/* it wasn't a link */
|
|
return TRUE;
|
|
|
|
if(c)
|
|
last_slash[1] = c;
|
|
/* else
|
|
last_slash[0] = '/'; */
|
|
|
|
/* it was a link, have to figure it out the hard way */
|
|
|
|
new_name = find_parent_dir_fullname(cmpl_dir->fullname);
|
|
|
|
if (!new_name)
|
|
return FALSE;
|
|
|
|
g_free(cmpl_dir->fullname);
|
|
|
|
cmpl_dir->fullname = new_name;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gchar*
|
|
find_parent_dir_fullname(gchar* dirname)
|
|
{
|
|
gchar buffer[MAXPATHLEN];
|
|
gchar buffer2[MAXPATHLEN];
|
|
|
|
#if defined(sun) && !defined(__SVR4)
|
|
if(!getwd(buffer))
|
|
#else
|
|
if(!getcwd(buffer, MAXPATHLEN))
|
|
#endif
|
|
{
|
|
cmpl_errno = errno;
|
|
return NULL;
|
|
}
|
|
|
|
if(chdir(dirname) != 0 || chdir("..") != 0)
|
|
{
|
|
cmpl_errno = errno;
|
|
return NULL;
|
|
}
|
|
|
|
#if defined(sun) && !defined(__SVR4)
|
|
if(!getwd(buffer2))
|
|
#else
|
|
if(!getcwd(buffer2, MAXPATHLEN))
|
|
#endif
|
|
{
|
|
chdir(buffer);
|
|
cmpl_errno = errno;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
if(chdir(buffer) != 0)
|
|
{
|
|
cmpl_errno = errno;
|
|
return NULL;
|
|
}
|
|
|
|
return g_strdup(buffer2);
|
|
}
|
|
|
|
/**********************************************************************/
|
|
/* Completion Operations */
|
|
/**********************************************************************/
|
|
|
|
static PossibleCompletion*
|
|
attempt_homedir_completion(gchar* text_to_complete,
|
|
CompletionState *cmpl_state)
|
|
{
|
|
gint index, length;
|
|
|
|
if (!cmpl_state->user_dir_name_buffer &&
|
|
!get_pwdb(cmpl_state))
|
|
return NULL;
|
|
length = strlen(text_to_complete) - 1;
|
|
|
|
cmpl_state->user_completion_index += 1;
|
|
|
|
while(cmpl_state->user_completion_index < cmpl_state->user_directories_len)
|
|
{
|
|
index = first_diff_index(text_to_complete + 1,
|
|
cmpl_state->user_directories
|
|
[cmpl_state->user_completion_index].login);
|
|
|
|
switch(index)
|
|
{
|
|
case PATTERN_MATCH:
|
|
break;
|
|
default:
|
|
if(cmpl_state->last_valid_char < (index + 1))
|
|
cmpl_state->last_valid_char = index + 1;
|
|
cmpl_state->user_completion_index += 1;
|
|
continue;
|
|
}
|
|
|
|
cmpl_state->the_completion.is_a_completion = 1;
|
|
cmpl_state->the_completion.is_directory = 1;
|
|
|
|
append_completion_text("~", cmpl_state);
|
|
|
|
append_completion_text(cmpl_state->
|
|
user_directories[cmpl_state->user_completion_index].login,
|
|
cmpl_state);
|
|
|
|
return append_completion_text("/", cmpl_state);
|
|
}
|
|
|
|
if(text_to_complete[1] ||
|
|
cmpl_state->user_completion_index > cmpl_state->user_directories_len)
|
|
{
|
|
cmpl_state->user_completion_index = -1;
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
cmpl_state->user_completion_index += 1;
|
|
cmpl_state->the_completion.is_a_completion = 1;
|
|
cmpl_state->the_completion.is_directory = 1;
|
|
|
|
return append_completion_text("~/", cmpl_state);
|
|
}
|
|
}
|
|
|
|
/* returns the index (>= 0) of the first differing character,
|
|
* PATTERN_MATCH if the completion matches */
|
|
static gint
|
|
first_diff_index(gchar* pat, gchar* text)
|
|
{
|
|
gint diff = 0;
|
|
|
|
while(*pat && *text && *text == *pat)
|
|
{
|
|
pat += 1;
|
|
text += 1;
|
|
diff += 1;
|
|
}
|
|
|
|
if(*pat)
|
|
return diff;
|
|
|
|
return PATTERN_MATCH;
|
|
}
|
|
|
|
static PossibleCompletion*
|
|
append_completion_text(gchar* text, CompletionState* cmpl_state)
|
|
{
|
|
gint len, i = 1;
|
|
|
|
if(!cmpl_state->the_completion.text)
|
|
return NULL;
|
|
|
|
len = strlen(text) + strlen(cmpl_state->the_completion.text) + 1;
|
|
|
|
if(cmpl_state->the_completion.text_alloc > len)
|
|
{
|
|
strcat(cmpl_state->the_completion.text, text);
|
|
return &cmpl_state->the_completion;
|
|
}
|
|
|
|
while(i < len) { i <<= 1; }
|
|
|
|
cmpl_state->the_completion.text_alloc = i;
|
|
|
|
cmpl_state->the_completion.text = (gchar*)g_realloc(cmpl_state->the_completion.text, i);
|
|
|
|
if(!cmpl_state->the_completion.text)
|
|
return NULL;
|
|
else
|
|
{
|
|
strcat(cmpl_state->the_completion.text, text);
|
|
return &cmpl_state->the_completion;
|
|
}
|
|
}
|
|
|
|
static CompletionDir*
|
|
find_completion_dir(gchar* text_to_complete,
|
|
gchar** remaining_text,
|
|
CompletionState* cmpl_state)
|
|
{
|
|
gchar* first_slash = strchr(text_to_complete, '/');
|
|
CompletionDir* dir = cmpl_state->reference_dir;
|
|
CompletionDir* next;
|
|
*remaining_text = text_to_complete;
|
|
|
|
while(first_slash)
|
|
{
|
|
gint len = first_slash - *remaining_text;
|
|
gint found = 0;
|
|
gchar *found_name = NULL; /* Quiet gcc */
|
|
gint i;
|
|
gchar* pat_buf = g_new (gchar, len + 1);
|
|
|
|
strncpy(pat_buf, *remaining_text, len);
|
|
pat_buf[len] = 0;
|
|
|
|
for(i = 0; i < dir->sent->entry_count; i += 1)
|
|
{
|
|
if(dir->sent->entries[i].is_dir &&
|
|
fnmatch(pat_buf, dir->sent->entries[i].entry_name,
|
|
FNMATCH_FLAGS)!= FNM_NOMATCH)
|
|
{
|
|
if(found)
|
|
{
|
|
g_free (pat_buf);
|
|
return dir;
|
|
}
|
|
else
|
|
{
|
|
found = 1;
|
|
found_name = dir->sent->entries[i].entry_name;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
/* Perhaps we are trying to open an automount directory */
|
|
found_name = pat_buf;
|
|
}
|
|
|
|
next = open_relative_dir(found_name, dir, cmpl_state);
|
|
|
|
if(!next)
|
|
{
|
|
g_free (pat_buf);
|
|
return NULL;
|
|
}
|
|
|
|
next->cmpl_parent = dir;
|
|
|
|
dir = next;
|
|
|
|
if(!correct_dir_fullname(dir))
|
|
{
|
|
g_free(pat_buf);
|
|
return NULL;
|
|
}
|
|
|
|
*remaining_text = first_slash + 1;
|
|
first_slash = strchr(*remaining_text, '/');
|
|
|
|
g_free (pat_buf);
|
|
}
|
|
|
|
return dir;
|
|
}
|
|
|
|
static void
|
|
update_cmpl(PossibleCompletion* poss, CompletionState* cmpl_state)
|
|
{
|
|
gint cmpl_len;
|
|
|
|
if(!poss || !cmpl_is_a_completion(poss))
|
|
return;
|
|
|
|
cmpl_len = strlen(cmpl_this_completion(poss));
|
|
|
|
if(cmpl_state->updated_text_alloc < cmpl_len + 1)
|
|
{
|
|
cmpl_state->updated_text =
|
|
(gchar*)g_realloc(cmpl_state->updated_text,
|
|
cmpl_state->updated_text_alloc);
|
|
cmpl_state->updated_text_alloc = 2*cmpl_len;
|
|
}
|
|
|
|
if(cmpl_state->updated_text_len < 0)
|
|
{
|
|
strcpy(cmpl_state->updated_text, cmpl_this_completion(poss));
|
|
cmpl_state->updated_text_len = cmpl_len;
|
|
cmpl_state->re_complete = cmpl_is_directory(poss);
|
|
}
|
|
else if(cmpl_state->updated_text_len == 0)
|
|
{
|
|
cmpl_state->re_complete = FALSE;
|
|
}
|
|
else
|
|
{
|
|
gint first_diff =
|
|
first_diff_index(cmpl_state->updated_text,
|
|
cmpl_this_completion(poss));
|
|
|
|
cmpl_state->re_complete = FALSE;
|
|
|
|
if(first_diff == PATTERN_MATCH)
|
|
return;
|
|
|
|
if(first_diff > cmpl_state->updated_text_len)
|
|
strcpy(cmpl_state->updated_text, cmpl_this_completion(poss));
|
|
|
|
cmpl_state->updated_text_len = first_diff;
|
|
cmpl_state->updated_text[first_diff] = 0;
|
|
}
|
|
}
|
|
|
|
static PossibleCompletion*
|
|
attempt_file_completion(CompletionState *cmpl_state)
|
|
{
|
|
gchar *pat_buf, *first_slash;
|
|
CompletionDir *dir = cmpl_state->active_completion_dir;
|
|
|
|
dir->cmpl_index += 1;
|
|
|
|
if(dir->cmpl_index == dir->sent->entry_count)
|
|
{
|
|
if(dir->cmpl_parent == NULL)
|
|
{
|
|
cmpl_state->active_completion_dir = NULL;
|
|
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
cmpl_state->active_completion_dir = dir->cmpl_parent;
|
|
|
|
return attempt_file_completion(cmpl_state);
|
|
}
|
|
}
|
|
|
|
g_assert(dir->cmpl_text);
|
|
|
|
first_slash = strchr(dir->cmpl_text, '/');
|
|
|
|
if(first_slash)
|
|
{
|
|
gint len = first_slash - dir->cmpl_text;
|
|
|
|
pat_buf = g_new (gchar, len + 1);
|
|
strncpy(pat_buf, dir->cmpl_text, len);
|
|
pat_buf[len] = 0;
|
|
}
|
|
else
|
|
{
|
|
gint len = strlen(dir->cmpl_text);
|
|
|
|
pat_buf = g_new (gchar, len + 2);
|
|
strcpy(pat_buf, dir->cmpl_text);
|
|
strcpy(pat_buf + len, "*");
|
|
}
|
|
|
|
if(first_slash)
|
|
{
|
|
if(dir->sent->entries[dir->cmpl_index].is_dir)
|
|
{
|
|
if(fnmatch(pat_buf, dir->sent->entries[dir->cmpl_index].entry_name,
|
|
FNMATCH_FLAGS) != FNM_NOMATCH)
|
|
{
|
|
CompletionDir* new_dir;
|
|
|
|
new_dir = open_relative_dir(dir->sent->entries[dir->cmpl_index].entry_name,
|
|
dir, cmpl_state);
|
|
|
|
if(!new_dir)
|
|
{
|
|
g_free (pat_buf);
|
|
return NULL;
|
|
}
|
|
|
|
new_dir->cmpl_parent = dir;
|
|
|
|
new_dir->cmpl_index = -1;
|
|
new_dir->cmpl_text = first_slash + 1;
|
|
|
|
cmpl_state->active_completion_dir = new_dir;
|
|
|
|
g_free (pat_buf);
|
|
return attempt_file_completion(cmpl_state);
|
|
}
|
|
else
|
|
{
|
|
g_free (pat_buf);
|
|
return attempt_file_completion(cmpl_state);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
g_free (pat_buf);
|
|
return attempt_file_completion(cmpl_state);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(dir->cmpl_parent != NULL)
|
|
{
|
|
append_completion_text(dir->fullname +
|
|
strlen(cmpl_state->completion_dir->fullname) + 1,
|
|
cmpl_state);
|
|
append_completion_text("/", cmpl_state);
|
|
}
|
|
|
|
append_completion_text(dir->sent->entries[dir->cmpl_index].entry_name, cmpl_state);
|
|
|
|
cmpl_state->the_completion.is_a_completion =
|
|
(fnmatch(pat_buf, dir->sent->entries[dir->cmpl_index].entry_name,
|
|
FNMATCH_FLAGS) != FNM_NOMATCH);
|
|
|
|
cmpl_state->the_completion.is_directory = dir->sent->entries[dir->cmpl_index].is_dir;
|
|
if(dir->sent->entries[dir->cmpl_index].is_dir)
|
|
append_completion_text("/", cmpl_state);
|
|
|
|
g_free (pat_buf);
|
|
return &cmpl_state->the_completion;
|
|
}
|
|
}
|
|
|
|
|
|
static gint
|
|
get_pwdb(CompletionState* cmpl_state)
|
|
{
|
|
struct passwd *pwd_ptr;
|
|
gchar* buf_ptr;
|
|
gint len = 0, i, count = 0;
|
|
|
|
if(cmpl_state->user_dir_name_buffer)
|
|
return TRUE;
|
|
setpwent ();
|
|
|
|
while ((pwd_ptr = getpwent()) != NULL)
|
|
{
|
|
len += strlen(pwd_ptr->pw_name);
|
|
len += strlen(pwd_ptr->pw_dir);
|
|
len += 2;
|
|
count += 1;
|
|
}
|
|
|
|
setpwent ();
|
|
|
|
cmpl_state->user_dir_name_buffer = g_new(gchar, len);
|
|
cmpl_state->user_directories = g_new(CompletionUserDir, count);
|
|
cmpl_state->user_directories_len = count;
|
|
|
|
buf_ptr = cmpl_state->user_dir_name_buffer;
|
|
|
|
for(i = 0; i < count; i += 1)
|
|
{
|
|
pwd_ptr = getpwent();
|
|
if(!pwd_ptr)
|
|
{
|
|
cmpl_errno = errno;
|
|
goto error;
|
|
}
|
|
|
|
strcpy(buf_ptr, pwd_ptr->pw_name);
|
|
cmpl_state->user_directories[i].login = buf_ptr;
|
|
buf_ptr += strlen(buf_ptr);
|
|
buf_ptr += 1;
|
|
strcpy(buf_ptr, pwd_ptr->pw_dir);
|
|
cmpl_state->user_directories[i].homedir = buf_ptr;
|
|
buf_ptr += strlen(buf_ptr);
|
|
buf_ptr += 1;
|
|
}
|
|
|
|
qsort(cmpl_state->user_directories,
|
|
cmpl_state->user_directories_len,
|
|
sizeof(CompletionUserDir),
|
|
compare_user_dir);
|
|
|
|
endpwent();
|
|
|
|
return TRUE;
|
|
|
|
error:
|
|
|
|
if(cmpl_state->user_dir_name_buffer)
|
|
g_free(cmpl_state->user_dir_name_buffer);
|
|
if(cmpl_state->user_directories)
|
|
g_free(cmpl_state->user_directories);
|
|
|
|
cmpl_state->user_dir_name_buffer = NULL;
|
|
cmpl_state->user_directories = NULL;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
compare_user_dir(const void* a, const void* b)
|
|
{
|
|
return strcmp((((CompletionUserDir*)a))->login,
|
|
(((CompletionUserDir*)b))->login);
|
|
}
|
|
|
|
static gint
|
|
compare_cmpl_dir(const void* a, const void* b)
|
|
{
|
|
return strcmp((((CompletionDirEntry*)a))->entry_name,
|
|
(((CompletionDirEntry*)b))->entry_name);
|
|
}
|
|
|
|
static gint
|
|
cmpl_state_okay(CompletionState* cmpl_state)
|
|
{
|
|
return cmpl_state && cmpl_state->reference_dir;
|
|
}
|
|
|
|
static gchar*
|
|
cmpl_strerror(gint err)
|
|
{
|
|
if(err == CMPL_ERRNO_TOO_LONG)
|
|
return "Name too long";
|
|
else
|
|
return g_strerror (err);
|
|
}
|
|
|
|
/* This is an internally used function to create pixmaps. */
|
|
GtkWidget*
|
|
create_pixmap(GtkWidget *widget, const gchar *pixmap_char)
|
|
{
|
|
GdkPixmap *gdkpixmap;
|
|
GdkBitmap *mask;
|
|
GtkWidget *pixmap;
|
|
GdkColormap *colormap;
|
|
|
|
colormap = gtk_widget_get_colormap (widget);
|
|
|
|
gdkpixmap = gdk_pixmap_colormap_create_from_xpm_d (GTK_WIDGET(widget)->window,
|
|
colormap,
|
|
&mask,
|
|
NULL,
|
|
(gpointer) pixmap_char);
|
|
if (gdkpixmap == NULL)
|
|
{
|
|
g_warning ("Error loading pixmap: %s", pixmap_char);
|
|
return NULL;
|
|
}
|
|
pixmap = gtk_pixmap_new (gdkpixmap, mask);
|
|
gdk_pixmap_unref (gdkpixmap);
|
|
gdk_bitmap_unref (mask);
|
|
return pixmap;
|
|
}
|
|
|
|
|
|
/* Testing area */
|
|
#ifdef TORRIE_DEBUG
|
|
|
|
/* Get the selected filename and print it to the console */
|
|
void file_ok_sel( GtkWidget *w,
|
|
GtkFileSelection *fs )
|
|
{
|
|
g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
|
|
}
|
|
|
|
void destroy( GtkWidget *widget,
|
|
gpointer data )
|
|
{
|
|
gtk_main_quit ();
|
|
}
|
|
|
|
int main( int argc,
|
|
char *argv[] )
|
|
{
|
|
GtkWidget *filew;
|
|
const gchar *masks[] = { "mp3s/playlists <*.mp3,*.m3u>",
|
|
"src/hdr <*.[CcHh],*.[Cc][Cc],*.[Hh][Hh],*.cpp>",
|
|
NULL };
|
|
|
|
gtk_init (&argc, &argv);
|
|
|
|
/* Create a new file selection widget */
|
|
filew = gtk_file_selection_new ("Spiffy File Selector");
|
|
// gtk_file_selection_complete(GTK_FILE_SELECTION(filew),"bob");
|
|
|
|
gtk_file_selection_set_masks (GTK_FILE_SELECTION (filew), masks);
|
|
|
|
gtk_signal_connect (GTK_OBJECT (filew), "destroy",
|
|
(GtkSignalFunc) destroy, &filew);
|
|
/* Connect the ok_button to file_ok_sel function */
|
|
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
|
|
"clicked", (GtkSignalFunc) file_ok_sel, filew );
|
|
|
|
/* Connect the cancel_button to destroy the widget */
|
|
gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION
|
|
(filew)->cancel_button),
|
|
"clicked", (GtkSignalFunc) gtk_widget_destroy,
|
|
GTK_OBJECT (filew));
|
|
|
|
|
|
gtk_widget_show(filew);
|
|
|
|
/*
|
|
g_print("%d",gtk_file_selection_match_mask("mask.c","m*.c"));
|
|
g_print("%d",gtk_file_selection_match_mask("mask.c","m???.c"));
|
|
g_print("%d",gtk_file_selection_match_mask("mask.c","m??*.c"));
|
|
g_print("%d",gtk_file_selection_match_mask("mask.cout","m*.c"));
|
|
g_print("%d",gtk_file_selection_match_mask("mask.cout","m*.c???"));
|
|
g_print("%d",gtk_file_selection_match_mask("mask.cout","m*.c*"));
|
|
g_print("%d",gtk_file_selection_match_mask("mask.cout","n*.c???"));
|
|
g_print("%d",gtk_file_selection_match_mask("mask.c","[mn]*"));
|
|
g_print("%d",gtk_file_selection_match_mask("COPYING","*.xpm"));
|
|
*/
|
|
gtk_main ();
|
|
|
|
return 0;
|
|
}
|
|
/* example-end */
|
|
#endif
|