nyje
/
medit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added FAM back; rewrote a bit of MooFileWatch

master
Yevgen Muntyan 2006-12-08 14:55:46 -06:00
parent 8940dcee02
commit 752a4a24e9
11 changed files with 716 additions and 941 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
m4/moo-fam.m4
View File

@ -5,10 +5,11 @@ AC_DEFUN([MOO_AC_CHECK_FAM],[
save_CFLAGS="$CFLAGS"
save_LDFLAGS="$LDFLAGS"
CFLAGS="$CFLAGS $FAM_CFLAGS"
if test x$FAM_LIBS = x; then
FAM_LIBS=-lfam
fi
CFLAGS="$CFLAGS $FAM_CFLAGS"
LDFLAGS="$LDFLAGS $FAM_LIBS"
AC_CHECK_HEADERS(fam.h,[
@ -33,15 +34,18 @@ AC_DEFUN([MOO_AC_CHECK_FAM],[
AC_MSG_RESULT($FAM_LIBS)
fi
MOO_FAM_LIBS=$FAM_LIBS
MOO_FAM_CFLAGS="$FAM_CFLAGS"
MOO_FAM_LIBS="$FAM_LIBS"
ifelse([$1], , :, [$1])
else
unset FAM_CFLAGS
unset FAM_LIBS
MOO_FAM_LIBS=
MOO_FAM_CFLAGS=
ifelse([$2], , [AC_MSG_ERROR(libfam not found)], [$2])
fi
AC_SUBST(MOO_FAM_CFLAGS)
AC_SUBST(MOO_FAM_LIBS)
CFLAGS="$save_CFLAGS"
LDFLAGS="$save_LDFLAGS"
@ -51,26 +55,25 @@ AC_DEFUN([MOO_AC_CHECK_FAM],[
AC_DEFUN([MOO_AC_FAM],[
AC_REQUIRE([MOO_AC_CHECK_OS])
# AC_ARG_WITH([fam], AC_HELP_STRING([--with-fam], [whether to use fam or gamin for monitoring files in the editor (default = NO)]), [
# if test x$with_fam = "xyes"; then
# MOO_USE_FAM="yes"
# else
# MOO_USE_FAM="no"
# fi
# ],[
# MOO_USE_FAM="no"
# ])
AC_ARG_WITH([fam], AC_HELP_STRING([--with-fam], [whether to use fam or gamin for monitoring files in the editor (default = NO)]), [
if test x$with_fam = "xyes"; then
MOO_USE_FAM="yes"
else
MOO_USE_FAM="no"
fi
],[
MOO_USE_FAM="no"
])
# if test x$MOO_OS_UNIX = xyes -a x$MOO_USE_FAM = xyes; then
# MOO_AC_CHECK_FAM([moo_has_fam=yes],[moo_has_fam=no])
# if test x$moo_has_fam = xyes; then
# MOO_USE_FAM="yes"
# AC_DEFINE(MOO_USE_FAM, 1, [use libfam for monitoring files])
# else
# AC_MSG_ERROR([FAM or gamin not found.])
# fi
# fi
if test x$MOO_OS_UNIX = xyes -a x$MOO_USE_FAM = xyes; then
MOO_AC_CHECK_FAM([moo_has_fam=yes],[moo_has_fam=no])
if test x$moo_has_fam = xyes; then
MOO_USE_FAM="yes"
AC_DEFINE(MOO_USE_FAM, 1, [use libfam for monitoring files])
else
AC_MSG_ERROR([FAM or gamin not found.])
fi
fi
MOO_USE_FAM=no
AM_CONDITIONAL(MOO_USE_FAM, test x$MOO_USE_FAM = "xyes")
])

5
m4/moo-flags.m4
View File

@ -22,9 +22,10 @@ AC_DEFUN([MOO_AC_FLAGS],[
if test x$MOO_OS_MINGW = xyes; then
MOO_LIBS="$MOO_LIBS $GTHREAD_LIBS"
fi;
if test x$MOO_USE_FAM = xyes; then
MOO_LIBS="$MOO_LIBS $FAM_LIBS"
MOO_CFLAGS="$MOO_CFLAGS $MOO_FAM_CFLAGS"
MOO_LIBS="$MOO_LIBS $MOO_FAM_LIBS"
fi
MOO_CFLAGS="$MOO_CFLAGS -DMOO_DATA_DIR=\\\"${MOO_DATA_DIR}\\\" -DMOO_LIB_DIR=\\\"${MOO_LIB_DIR}\\\""

18
moo.mprj
View File

@ -11,6 +11,15 @@
</vars>
</configure>
</debug>
<gtk-cvs>
<build_dir>/home/muntyan/projects/gtk/build/moo</build_dir>
<configure>
<args>--enable-debug --enable-all-gcc-warnings --prefix=$PREFIX --with-fam</args>
<vars>
<var name="CFLAGS">-g</var>
</vars>
</configure>
</gtk-cvs>
<mingw>
<build_dir>build/mingw</build_dir>
</mingw>
@ -23,15 +32,6 @@
</vars>
</configure>
</optimized>
<gtk-cvs>
<build_dir>/home/muntyan/projects/gtk/build/moo</build_dir>
<configure>
<args>--enable-debug --enable-all-gcc-warnings --prefix=$PREFIX</args>
<vars>
<var name="CFLAGS">-g</var>
</vars>
</configure>
</gtk-cvs>
</configurations>
<run>
<args>--g-fatal-warnings --new-app</args>

3
moo/mooedit/mooedit-private.h
View File

@ -132,8 +132,7 @@ struct _MooEditPrivate {
MooEditStatus status;
MooEditOnExternalChanges file_watch_policy;
int file_monitor_id;
gulong file_watch_event_handler_id;
guint file_monitor_id;
gulong focus_in_handler_id;
gboolean modified_on_disk;
gboolean deleted_from_disk;

46
moo/mooedit/mooeditfileops.c
View File

@ -911,31 +911,30 @@ static void unblock_buffer_signals (MooEdit *edit)
static void
file_watch_event (G_GNUC_UNUSED MooFileWatch *watch,
MooFileWatchEvent *event,
MooEdit *edit)
file_watch_callback (G_GNUC_UNUSED MooFileWatch *watch,
MooFileEvent *event,
gpointer data)
{
if (event->monitor_id != edit->priv->file_monitor_id)
return;
MooEdit *edit = MOO_EDIT (data);
g_return_if_fail (event->monitor_id == edit->priv->file_monitor_id);
g_return_if_fail (edit->priv->filename != NULL);
g_return_if_fail (!(edit->priv->status & MOO_EDIT_CHANGED_ON_DISK));
switch (event->code)
{
case MOO_FILE_WATCH_EVENT_CHANGED:
case MOO_FILE_EVENT_CHANGED:
edit->priv->modified_on_disk = TRUE;
break;
case MOO_FILE_WATCH_EVENT_DELETED:
case MOO_FILE_EVENT_DELETED:
edit->priv->deleted_from_disk = TRUE;
edit->priv->file_monitor_id = 0;
break;
case MOO_FILE_WATCH_EVENT_CREATED:
case MOO_FILE_WATCH_EVENT_MOVED:
case MOO_FILE_WATCH_EVENT_ERROR:
g_return_if_reached ();
case MOO_FILE_EVENT_ERROR:
/* XXX and what to do now? */
break;
}
check_file_status (edit, TRUE);
@ -949,7 +948,7 @@ _moo_edit_start_file_watch (MooEdit *edit)
GError *error = NULL;
watch = _moo_editor_get_file_watch (edit->priv->editor);
g_return_if_fail (MOO_IS_FILE_WATCH (watch));
g_return_if_fail (watch != NULL);
if (edit->priv->file_monitor_id)
moo_file_watch_cancel_monitor (watch, edit->priv->file_monitor_id);
@ -958,9 +957,10 @@ _moo_edit_start_file_watch (MooEdit *edit)
g_return_if_fail ((edit->priv->status & MOO_EDIT_CHANGED_ON_DISK) == 0);
g_return_if_fail (edit->priv->filename != NULL);
edit->priv->file_monitor_id = moo_file_watch_monitor_file (watch,
edit->priv->filename,
edit, &error);
edit->priv->file_monitor_id =
moo_file_watch_create_monitor (watch, edit->priv->filename,
file_watch_callback,
edit, NULL, &error);
if (!edit->priv->file_monitor_id)
{
@ -976,12 +976,6 @@ _moo_edit_start_file_watch (MooEdit *edit)
return;
}
/* XXX watch errors too */
if (!edit->priv->file_watch_event_handler_id)
edit->priv->file_watch_event_handler_id =
g_signal_connect (watch, "event",
G_CALLBACK (file_watch_event), edit);
if (!edit->priv->focus_in_handler_id)
edit->priv->focus_in_handler_id =
g_signal_connect (edit, "focus-in-event",
@ -991,23 +985,17 @@ _moo_edit_start_file_watch (MooEdit *edit)
void
_moo_edit_stop_file_watch (MooEdit *edit)
_moo_edit_stop_file_watch (MooEdit *edit)
{
MooFileWatch *watch;
watch = _moo_editor_get_file_watch (edit->priv->editor);
g_return_if_fail (MOO_IS_FILE_WATCH (watch));
g_return_if_fail (watch != NULL);
if (edit->priv->file_monitor_id)
moo_file_watch_cancel_monitor (watch, edit->priv->file_monitor_id);
edit->priv->file_monitor_id = 0;
if (edit->priv->file_watch_event_handler_id)
{
g_signal_handler_disconnect (watch, edit->priv->file_watch_event_handler_id);
edit->priv->file_watch_event_handler_id = 0;
}
if (edit->priv->focus_in_handler_id)
{
g_signal_handler_disconnect (edit, edit->priv->focus_in_handler_id);

6
moo/mooedit/mooeditor.c
View File

@ -448,6 +448,7 @@ moo_editor_finalize (GObject *object)
if (editor->priv->file_watch)
{
GError *error = NULL;
if (!moo_file_watch_close (editor->priv->file_watch, &error))
{
g_warning ("%s: error in moo_file_watch_close", G_STRLOC);
@ -457,7 +458,8 @@ moo_editor_finalize (GObject *object)
g_error_free (error);
}
}
g_object_unref (editor->priv->file_watch);
moo_file_watch_unref (editor->priv->file_watch);
}
if (editor->priv->windows)
@ -545,7 +547,7 @@ _moo_editor_post_message (MooEditor *editor,
gpointer
_moo_editor_get_file_watch (MooEditor *editor)
_moo_editor_get_file_watch (MooEditor *editor)
{
g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);

57
moo/moofileview/moofile.c
View File

@ -112,7 +112,7 @@ struct _MooFolderPrivate {
Debug debug;
GTimer *timer;
MooFileWatch *fam;
int fam_request;
guint fam_request;
guint reload_idle;
};
@ -819,44 +819,31 @@ static void file_created (MooFolder *folder,
const char *name);
static void
fam_event (MooFolder *folder,
MooFileWatchEvent *event)
fam_callback (MooFileWatch *watch,
MooFileEvent *event,
gpointer data)
{
if (event->data != folder)
return;
MooFolder *folder = MOO_FOLDER (data);
g_return_if_fail (watch == folder->priv->fam);
g_return_if_fail (event->monitor_id == folder->priv->fam_request);
switch (event->code)
{
case MOO_FILE_WATCH_EVENT_CHANGED:
case MOO_FILE_EVENT_CHANGED:
file_changed (folder, event->filename);
break;
case MOO_FILE_WATCH_EVENT_DELETED:
case MOO_FILE_EVENT_DELETED:
file_deleted (folder, event->filename);
break;
case MOO_FILE_WATCH_EVENT_CREATED:
file_created (folder, event->filename);
break;
case MOO_FILE_WATCH_EVENT_ERROR:
/* XXX */
file_deleted (folder, folder->priv->path);
break;
case MOO_FILE_WATCH_EVENT_MOVED:
case MOO_FILE_EVENT_ERROR:
stop_monitor (folder);
file_changed (folder, folder->priv->path);
break;
}
}
static void
fam_error (MooFolder *folder,
GError *error)
{
g_print ("fam error: %s\n", error->message);
stop_monitor (folder);
}
static void
start_monitor (MooFolder *folder)
{
@ -868,22 +855,18 @@ start_monitor (MooFolder *folder)
g_return_if_fail (folder->priv->fam != NULL);
folder->priv->fam_request =
moo_file_watch_monitor_directory (folder->priv->fam,
folder->priv->path,
folder, &error);
moo_file_watch_create_monitor (folder->priv->fam,
folder->priv->path,
fam_callback, folder,
NULL, &error);
if (!folder->priv->fam_request)
{
g_warning ("%s: moo_fam_monitor_directory failed for path '%s'", G_STRLOC, folder->priv->path);
g_warning ("%s: moo_file_watch_create_monitor failed for path '%s'", G_STRLOC, folder->priv->path);
g_warning ("%s: %s", G_STRLOC, error->message);
g_error_free (error);
return;
}
g_signal_connect_swapped (folder->priv->fam, "event",
G_CALLBACK (fam_event), folder);
g_signal_connect_swapped (folder->priv->fam, "error",
G_CALLBACK (fam_error), folder);
}
@ -892,16 +875,8 @@ stop_monitor (MooFolder *folder)
{
if (folder->priv->fam_request)
{
g_signal_handlers_disconnect_by_func (folder->priv->fam,
(gpointer)fam_event,
folder);
g_signal_handlers_disconnect_by_func (folder->priv->fam,
(gpointer)fam_error,
folder);
moo_file_watch_cancel_monitor (folder->priv->fam,
folder->priv->fam_request);
folder->priv->fam = NULL;
folder->priv->fam_request = 0;
}

20
moo/moofileview/moofilesystem.c
View File

@ -158,7 +158,7 @@ moo_file_system_finalize (GObject *object)
if (fs->priv->fam)
{
moo_file_watch_close (fs->priv->fam, NULL);
g_object_unref (fs->priv->fam);
moo_file_watch_unref (fs->priv->fam);
}
g_free (fs->priv);
@ -302,19 +302,6 @@ _moo_file_system_get_absolute_path (MooFileSystem *fs,
}
static void
fam_error (MooFileWatch *fam,
GError *error,
MooFileSystem *fs)
{
g_return_if_fail (fs->priv->fam == fam);
g_warning ("%s: fam error", G_STRLOC);
g_warning ("%s: %s", G_STRLOC, error->message);
g_object_unref (fs->priv->fam);
fs->priv->fam = NULL;
}
MooFileWatch *
_moo_file_system_get_file_watch (MooFileSystem *fs)
{
@ -330,11 +317,6 @@ _moo_file_system_get_file_watch (MooFileSystem *fs)
g_warning ("%s: %s", G_STRLOC, error->message);
g_error_free (error);
}
else
{
g_signal_connect (fs->priv->fam, "error",
G_CALLBACK (fam_error), fs);
}
}
return fs->priv->fam;

62
moo/moopython/pygtk/mooutils-pygtk.defs
View File

@ -22,12 +22,10 @@
(gtype-id "MOO_TYPE_ENTRY")
)
(define-object FileWatch
(define-boxed FileWatch
(in-module "Moo")
(parent "GObject")
(c-name "MooFileWatch")
(gtype-id "MOO_TYPE_FILE_WATCH")
(final "true")
)
(define-object FilterMgr
@ -226,15 +224,15 @@
(release-func "moo_closure_unref")
)
(define-pointer FileWatchEvent
(define-boxed FileEvent
(in-module "Moo")
(c-name "MooFileWatchEvent")
(gtype-id "MOO_TYPE_FILE_WATCH_EVENT")
(c-name "MooFileEvent")
(gtype-id "MOO_TYPE_FILE_EVENT")
(fields
'("MooFileWatchEventCode" "code")
'("MooFileEventCode" "code")
'("int" "monitor_id")
'("char*" "filename")
'("gpointer" "data")
'("GError*" "error")
)
)
@ -256,16 +254,10 @@
(gtype-id "MOO_TYPE_FILE_DIALOG_TYPE")
)
(define-enum FileWatchMethod
(define-enum FileEventCode
(in-module "Moo")
(c-name "MooFileWatchMethod")
(gtype-id "MOO_TYPE_FILE_WATCH_METHOD")
)
(define-enum FileWatchEventCode
(in-module "Moo")
(c-name "MooFileWatchEventCode")
(gtype-id "MOO_TYPE_FILE_WATCH_EVENT_CODE")
(c-name "MooFileEventCode")
(gtype-id "MOO_TYPE_FILE_EVENT_CODE")
)
(define-enum PanePosition
@ -560,11 +552,6 @@
;; From ../mooutils/moofilewatch.h
;; (define-function moo_file_watch_error_quark
;; (c-name "moo_file_watch_error_quark")
;; (return-type "GQuark")
;; )
(define-function moo_file_watch_new
(c-name "moo_file_watch_new")
(is-constructor-of "MooFileWatch")
@ -583,24 +570,13 @@
)
)
(define-method monitor_directory
(define-method create_monitor
(of-object "MooFileWatch")
(c-name "moo_file_watch_monitor_directory")
(return-type "int")
(parameters
'("const-char*" "filename")
'("gpointer" "data")
'("GDestroyNotify" "data_notify")
'("GError**" "error")
)
)
(define-method monitor_file
(of-object "MooFileWatch")
(c-name "moo_file_watch_monitor_file")
(return-type "int")
(c-name "moo_file_watch_create_monitor")
(return-type "guint")
(parameters
'("const-char*" "filename")
'("MooFileWatchCallback" "callback")
'("gpointer" "data")
'("GDestroyNotify" "data_notify")
'("GError**" "error")
@ -612,7 +588,7 @@
(c-name "moo_file_watch_suspend_monitor")
(return-type "none")
(parameters
'("int" "monitor_id")
'("guint" "monitor_id")
)
)
@ -621,7 +597,7 @@
(c-name "moo_file_watch_resume_monitor")
(return-type "none")
(parameters
'("int" "monitor_id")
'("guint" "monitor_id")
)
)
@ -630,16 +606,10 @@
(c-name "moo_file_watch_cancel_monitor")
(return-type "none")
(parameters
'("int" "monitor_id")
'("guint" "monitor_id")
)
)
(define-method get_method
(of-object "MooFileWatch")
(c-name "moo_file_watch_get_method")
(return-type "MooFileWatchMethod")
)
;; From ../mooutils/moofiltermgr.h

1294
moo/mooutils/moofilewatch.c
View File

File diff suppressed because it is too large Load Diff

101
moo/mooutils/moofilewatch.h
View File

@ -40,99 +40,60 @@ typedef enum
GQuark moo_file_watch_error_quark (void);
#define MOO_TYPE_FILE_WATCH (moo_file_watch_get_type ())
#define MOO_FILE_WATCH(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), MOO_TYPE_FILE_WATCH, MooFileWatch))
#define MOO_FILE_WATCH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MOO_TYPE_FILE_WATCH, MooFileWatchClass))
#define MOO_IS_FILE_WATCH(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), MOO_TYPE_FILE_WATCH))
#define MOO_IS_FILE_WATCH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MOO_TYPE_FILE_WATCH))
#define MOO_FILE_WATCH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MOO_TYPE_FILE_WATCH, MooFileWatchClass))
#define MOO_TYPE_FILE_WATCH_EVENT (moo_file_watch_event_get_type ())
#define MOO_TYPE_FILE_WATCH_EVENT_CODE (moo_file_watch_event_code_get_type ())
#define MOO_TYPE_FILE_WATCH_METHOD (moo_file_watch_method_get_type ())
#define MOO_TYPE_FILE_WATCH (moo_file_watch_get_type ())
#define MOO_TYPE_FILE_EVENT (moo_file_event_get_type ())
#define MOO_TYPE_FILE_EVENT_CODE (moo_file_event_code_get_type ())
typedef enum {
MOO_FILE_WATCH_STAT,
MOO_FILE_WATCH_FAM,
MOO_FILE_WATCH_WIN32
} MooFileWatchMethod;
MOO_FILE_EVENT_CHANGED,
MOO_FILE_EVENT_DELETED,
MOO_FILE_EVENT_ERROR
} MooFileEventCode;
/* Stripped FAMEventCode enumeration */
typedef enum {
MOO_FILE_WATCH_EVENT_CHANGED = 1,
MOO_FILE_WATCH_EVENT_DELETED = 2,
MOO_FILE_WATCH_EVENT_CREATED = 3,
MOO_FILE_WATCH_EVENT_MOVED = 4,
MOO_FILE_WATCH_EVENT_ERROR = 5
} MooFileWatchEventCode;
/* The structure has the same meaning as the FAMEvent
(it is a simple copy of FAMEvent structure when
FAM is used). In the case when stat() is used, when
directory content is changed, MooFileWatch does not
try to learn what happened, and just emits CHANGED
event with filename set to directory name.
*/
struct _MooFileWatchEvent {
MooFileWatchEventCode code; /* FAMEventCode */
int monitor_id; /* FAMRequest */
char *filename;
GError *error;
gpointer data;
struct _MooFileEvent {
MooFileEventCode code;
guint monitor_id;
char *filename;
GError *error;
};
typedef struct _MooFileWatch MooFileWatch;
typedef struct _MooFileWatchPrivate MooFileWatchPrivate;
typedef struct _MooFileWatchClass MooFileWatchClass;
typedef struct _MooFileWatchEvent MooFileWatchEvent;
typedef struct _MooFileEvent MooFileEvent;
struct _MooFileWatch
{
GObject parent;
MooFileWatchPrivate *priv;
};
typedef void (*MooFileWatchCallback) (MooFileWatch *watch,
MooFileEvent *event,
gpointer user_data);
struct _MooFileWatchClass
{
GObjectClass parent_class;
void (*event) (MooFileWatch *watch,
MooFileWatchEvent *event);
void (*error) (MooFileWatch *watch,
GError *error);
};
GType moo_file_watch_get_type (void) G_GNUC_CONST;
GType moo_file_watch_event_get_type (void) G_GNUC_CONST;
GType moo_file_watch_event_code_get_type (void) G_GNUC_CONST;
GType moo_file_watch_method_get_type (void) G_GNUC_CONST;
GType moo_file_event_get_type (void) G_GNUC_CONST;
GType moo_file_event_code_get_type (void) G_GNUC_CONST;
/* FAMOpen */
MooFileWatch *moo_file_watch_new (GError **error);
MooFileWatch *moo_file_watch_ref (MooFileWatch *watch);
void moo_file_watch_unref (MooFileWatch *watch);
/* FAMClose */
gboolean moo_file_watch_close (MooFileWatch *watch,
GError **error);
/* FAMMonitorDirectory, FAMMonitorFile */
int moo_file_watch_monitor_directory (MooFileWatch *watch,
guint moo_file_watch_create_monitor (MooFileWatch *watch,
const char *filename,
MooFileWatchCallback callback,
gpointer data,
GDestroyNotify notify,
GError **error);
int moo_file_watch_monitor_file (MooFileWatch *watch,
const char *filename,
gpointer data,
GError **error);
/* FAMSuspendMonitor, FAMResumeMonitor, FAMCancelMonitor */
void moo_file_watch_suspend_monitor (MooFileWatch *watch,
int monitor_id);
void moo_file_watch_resume_monitor (MooFileWatch *watch,
int monitor_id);
/* FAMCancelMonitor */
void moo_file_watch_cancel_monitor (MooFileWatch *watch,
int monitor_id);
MooFileWatchMethod moo_file_watch_get_method (MooFileWatch *watch);
guint monitor_id);
/* FAMSuspendMonitor, FAMResumeMonitor */
void moo_file_watch_suspend_monitor (MooFileWatch *watch,
guint monitor_id);
void moo_file_watch_resume_monitor (MooFileWatch *watch,
guint monitor_id);
G_END_DECLS