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

Empty changelog

master
Yevgen Muntyan 2005-11-02 02:32:07 +00:00
parent b6dd14b1ba
commit fe553c035a
9 changed files with 403 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
moo/mooapp/mooapp.c
View File

@ -77,6 +77,8 @@ struct _MooAppPrivate {
guint quit_handler_id;
gboolean use_editor;
gboolean use_terminal;
char *tmpdir;
};
@ -738,7 +740,6 @@ void moo_app_hide_python_console (G_GNUC_UNUSED MooApp *app)
g_return_if_fail (moo_app_python != NULL);
gtk_widget_hide (GTK_WIDGET (moo_app_python->console));
}
#endif /* !MOO_USE_PYTHON */
static guint strv_length (char **argv)
@ -754,6 +755,7 @@ static guint strv_length (char **argv)
return len;
}
#endif /* !MOO_USE_PYTHON */
MooEditor *moo_app_get_editor (MooApp *app)
@ -779,36 +781,6 @@ moo_app_init_real (MooApp *app)
MooUIXML *ui_xml;
GError *error = NULL;
#if 0
if (app->priv->enable_options)
{
int argc = strv_length (app->priv->argv);
g_option_context_add_group (app->priv->option_ctx,
gtk_get_option_group (TRUE));
g_option_context_parse (app->priv->option_ctx, &argc,
&app->priv->argv, &error);
if (error || argc > 1)
{
if (error)
{
g_print ("%s\n", error->message);
g_error_free (error);
error = NULL;
}
else
{
g_print ("Unknown option %s\n", app->priv->argv[1]);
}
g_print ("Type '%s --help' for usage\n", g_get_prgname ());
exit (1);
}
}
#endif
#ifdef __WIN32__
app_dir = moo_app_get_application_dir (app);
#endif
@ -950,6 +922,17 @@ start_io (MooApp *app)
}
gboolean
moo_app_send_msg (MooApp *app,
const char *data,
int len)
{
g_return_val_if_fail (MOO_IS_APP (app), FALSE);
g_return_val_if_fail (data != NULL, FALSE);
return _moo_app_input_send_msg (app->priv->info->short_name, data, len);
}
static gboolean on_gtk_main_quit (MooApp *app)
{
app->priv->quit_handler_id = 0;
@ -982,6 +965,9 @@ static gboolean moo_app_try_quit_real (MooApp *app)
if (!app->priv->running)
return FALSE;
if (!moo_editor_close_all (app->priv->editor))
return TRUE;
list = g_slist_copy (app->priv->terminals);
for (l = list; l != NULL; l = l->next)
{
@ -993,9 +979,6 @@ static gboolean moo_app_try_quit_real (MooApp *app)
}
g_slist_free (list);
if (!moo_editor_close_all (app->priv->editor))
return TRUE;
return FALSE;
}
@ -1059,6 +1042,13 @@ static void moo_app_quit_real (MooApp *app)
gtk_quit_remove (app->priv->quit_handler_id);
gtk_main_quit ();
if (app->priv->tmpdir)
{
moo_rmdir (app->priv->tmpdir, TRUE);
g_free (app->priv->tmpdir);
app->priv->tmpdir = NULL;
}
}
@ -1211,6 +1201,10 @@ static void terminal_destroyed (MooTermWindow *term,
app->priv->terminals = g_slist_remove (app->priv->terminals,
term);
if (app->priv->term_window == term)
app->priv->term_window = app->priv->terminals ?
app->priv->terminals->data : NULL;
policy = app->priv->window_policy;
quit = (policy & MOO_APP_QUIT_ON_CLOSE_ALL_TERMINALS) ||
((policy & MOO_APP_QUIT_ON_CLOSE_ALL_WINDOWS) &&
@ -1230,6 +1224,9 @@ static MooTermWindow *new_terminal (MooApp *app)
NULL);
app->priv->terminals = g_slist_append (app->priv->terminals, term);
if (!app->priv->term_window)
app->priv->term_window = term;
g_signal_connect (term, "destroy",
G_CALLBACK (terminal_destroyed), app);
@ -1614,3 +1611,54 @@ moo_app_exec_cmd_real (MooApp *app,
g_warning ("%s: got unknown command %d", G_STRLOC, cmd);
}
}
char*
moo_app_tempnam (MooApp *app)
{
int i;
char *basename;
char *filename;
g_return_val_if_fail (MOO_IS_APP (app), NULL);
if (!app->priv->tmpdir)
{
char *dirname = NULL;
for (i = 0; i < 1000; ++i)
{
basename = g_strdup_printf ("%08x", g_random_int ());
dirname = g_build_filename (g_get_tmp_dir (), basename, NULL);
g_free (basename);
if (moo_mkdir (dirname))
{
g_free (dirname);
dirname = NULL;
}
else
{
break;
}
}
g_return_val_if_fail (dirname != NULL, NULL);
app->priv->tmpdir = dirname;
}
for (i = 0; i < 1000; ++i)
{
basename = g_strdup_printf ("%08x", g_random_int ());
filename = g_build_filename (app->priv->tmpdir, basename, NULL);
g_free (basename);
if (g_file_test (filename, G_FILE_TEST_EXISTS))
g_free (filename);
else
return filename;
}
g_warning ("%s: could not generate temp file name", G_STRLOC);
return NULL;
}

6
moo/mooapp/mooapp.h
View File

@ -115,6 +115,12 @@ MooUIXML *moo_app_get_ui_xml (MooApp *app);
void moo_app_set_ui_xml (MooApp *app,
MooUIXML *xml);
char *moo_app_tempnam (MooApp *app);
gboolean moo_app_send_msg (MooApp *app,
const char *data,
int len);
void _moo_app_exec_cmd (MooApp *app,
char cmd,
const char *data,

113
moo/mooapp/mooappinput.c
View File

@ -26,10 +26,12 @@
#include <unistd.h>
#include <stdlib.h>
#include <sys/poll.h>
#include <signal.h>
#endif /* !__WIN32__ */
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include "mooapp/mooappinput.h"
#include "mooapp/mooapp.h"
@ -241,6 +243,20 @@ gboolean moo_app_input_start (MooAppInput *ch)
}
gboolean
_moo_app_input_send_msg (const char *pipe_basename,
const char *data,
int len)
{
g_return_val_if_fail (pipe_basename != NULL, FALSE);
g_return_val_if_fail (data != NULL, FALSE);
#warning "Implement me"
return FALSE;
}
static gboolean read_input (GIOChannel *source,
GIOCondition condition,
MooAppInput *self)
@ -398,13 +414,15 @@ static DWORD WINAPI listener_main (ListenerInfo *info)
*/
#ifndef __WIN32__
#define NAME_PREFIX "%s_in."
/* TODO: could you finally learn non-blocking io? */
gboolean moo_app_input_start (MooAppInput *ch)
{
g_return_val_if_fail (!ch->ready, FALSE);
ch->pipe_name =
g_strdup_printf ("%s/%s_in.%d",
g_strdup_printf ("%s/" NAME_PREFIX "%d",
g_get_tmp_dir(),
ch->pipe_basename,
getpid ());
@ -442,6 +460,99 @@ gboolean moo_app_input_start (MooAppInput *ch)
}
gboolean
_moo_app_input_send_msg (const char *pipe_basename,
const char *data,
gssize data_len)
{
const char *tmpdir_name, *entry;
GDir *tmpdir = NULL;
char *prefix = NULL;
guint prefix_len;
gboolean success = FALSE;
g_return_val_if_fail (pipe_basename != NULL, FALSE);
g_return_val_if_fail (data != NULL, FALSE);
tmpdir_name = g_get_tmp_dir ();
tmpdir = g_dir_open (tmpdir_name, 0, NULL);
if (!tmpdir)
return FALSE;
prefix = g_strdup_printf (NAME_PREFIX, pipe_basename);
prefix_len = strlen (prefix);
while ((entry = g_dir_read_name (tmpdir)))
{
const char *pid_string;
GPid pid;
char *filename = NULL;
GIOChannel *chan;
GIOStatus status;
if (strncmp (entry, prefix, prefix_len))
goto cont;
pid_string = entry + prefix_len;
if (!pid_string[0])
goto cont;
errno = 0;
pid = strtol (entry + prefix_len, NULL, 10);
if (errno)
goto cont;
filename = g_build_filename (tmpdir_name, entry, NULL);
if (kill (pid, 0))
{
/* XXX unlink should file if it's not our file, but still.. */
unlink (filename);
goto cont;
}
chan = g_io_channel_new_file (filename, "w", NULL);
if (!chan)
goto cont;
g_io_channel_set_encoding (chan, NULL, NULL);
status = g_io_channel_set_flags (chan, G_IO_FLAG_NONBLOCK, NULL);
if (status != G_IO_STATUS_NORMAL)
{
g_io_channel_unref (chan);
goto cont;
}
status = g_io_channel_write_chars (chan, data, data_len, NULL, NULL);
if (status != G_IO_STATUS_NORMAL)
{
g_io_channel_unref (chan);
goto cont;
}
g_free (filename);
g_io_channel_unref (chan);
success = TRUE;
goto out;
cont:
g_free (filename);
}
out:
if (tmpdir)
g_dir_close (tmpdir);
g_free (prefix);
return success;
}
static gboolean
read_input (G_GNUC_UNUSED GIOChannel *source,
GIOCondition condition,

24
moo/mooapp/mooappinput.h
View File

@ -36,7 +36,7 @@ typedef enum
} MooAppCmdCode;
#ifdef WANT_MOO_APP_CMD_CHARS
#if defined(WANT_MOO_APP_CMD_STRINGS) || defined(WANT_MOO_APP_CMD_CHARS)
#define CMD_ZERO "\0"
#define CMD_PYTHON_STRING "s"
@ -46,6 +46,10 @@ typedef enum
#define CMD_DIE "d"
#define CMD_PRESENT "r"
#endif
#ifdef WANT_MOO_APP_CMD_CHARS
static const char *moo_app_cmd_chars =
CMD_ZERO
CMD_PYTHON_STRING
@ -79,16 +83,20 @@ struct _MooAppInput
};
MooAppInput *moo_app_input_new (const char *pipe_basename);
MooAppInput *moo_app_input_new (const char *pipe_basename);
MooAppInput *moo_app_input_ref (MooAppInput *ch);
void moo_app_input_unref (MooAppInput *ch);
MooAppInput *moo_app_input_ref (MooAppInput *ch);
void moo_app_input_unref (MooAppInput *ch);
gboolean moo_app_input_start (MooAppInput *ch);
void moo_app_input_shutdown (MooAppInput *ch);
gboolean moo_app_input_ready (MooAppInput *ch);
gboolean moo_app_input_start (MooAppInput *ch);
void moo_app_input_shutdown (MooAppInput *ch);
gboolean moo_app_input_ready (MooAppInput *ch);
const char *moo_app_input_get_name (MooAppInput *ch);
const char *moo_app_input_get_name (MooAppInput *ch);
gboolean _moo_app_input_send_msg (const char *pipe_basename,
const char *data,
int len);
G_END_DECLS

115
moo/mooedit/mooeditor.c
View File

@ -99,6 +99,9 @@ struct _MooEditorPrivate {
gboolean open_single;
gboolean allow_empty_window;
gboolean single_window;
GType window_type;
GType doc_type;
};
@ -332,8 +335,25 @@ moo_editor_instance (void)
}
static void set_single_window (MooEditor *editor,
gboolean single)
static GType
get_window_type (MooEditor *editor)
{
return editor->priv->window_type ?
editor->priv->window_type : MOO_TYPE_EDIT_WINDOW;
}
static GType
get_doc_type (MooEditor *editor)
{
return editor->priv->doc_type ?
editor->priv->doc_type : MOO_TYPE_EDIT;
}
static void
set_single_window (MooEditor *editor,
gboolean single)
{
/* XXX */
editor->priv->single_window = single;
@ -341,7 +361,8 @@ static void set_single_window (MooEditor *editor,
}
static MooEditWindow *get_top_window (MooEditor *editor)
static MooEditWindow*
get_top_window (MooEditor *editor)
{
GSList *list = NULL, *l;
GtkWindow *window;
@ -646,9 +667,10 @@ activate_history_item (MooEditor *editor,
/*****************************************************************************/
static MooEditWindow *create_window (MooEditor *editor)
static MooEditWindow*
create_window (MooEditor *editor)
{
MooEditWindow *window = g_object_new (MOO_TYPE_EDIT_WINDOW,
MooEditWindow *window = g_object_new (get_window_type (editor),
"editor", editor,
"ui-xml",
moo_editor_get_ui_xml (editor),
@ -661,11 +683,12 @@ static MooEditWindow *create_window (MooEditor *editor)
}
static void moo_editor_add_doc (MooEditor *editor,
MooEditWindow *window,
MooEdit *doc,
MooEditLoader *loader,
MooEditSaver *saver)
static void
moo_editor_add_doc (MooEditor *editor,
MooEditWindow *window,
MooEdit *doc,
MooEditLoader *loader,
MooEditSaver *saver)
{
WindowInfo *info = window_list_find (editor, window);
@ -690,7 +713,7 @@ MooEditWindow *moo_editor_new_window (MooEditor *editor)
if (!editor->priv->allow_empty_window)
{
doc = g_object_new (MOO_TYPE_EDIT, "editor", editor, NULL);
doc = g_object_new (get_doc_type (editor), "editor", editor, NULL);
_moo_edit_window_insert_doc (window, doc, -1);
moo_editor_add_doc (editor, window, doc,
moo_edit_loader_get_default (),
@ -710,7 +733,7 @@ MooEdit *moo_editor_new_doc (MooEditor *editor,
g_return_val_if_fail (MOO_IS_EDIT_WINDOW (window), NULL);
g_return_val_if_fail (window_list_find (editor, window) != NULL, NULL);
doc = g_object_new (MOO_TYPE_EDIT, "editor", editor, NULL);
doc = g_object_new (get_doc_type (editor), "editor", editor, NULL);
_moo_edit_window_insert_doc (window, doc, -1);
moo_editor_add_doc (editor, window, doc,
moo_edit_loader_get_default (),
@ -781,7 +804,7 @@ void moo_editor_open (MooEditor *editor,
if (!doc)
{
doc = g_object_new (MOO_TYPE_EDIT, "editor", editor, NULL);
doc = g_object_new (get_doc_type (editor), "editor", editor, NULL);
gtk_object_sink (g_object_ref (doc));
new_doc = TRUE;
}
@ -826,22 +849,42 @@ void moo_editor_open (MooEditor *editor,
}
MooEdit *moo_editor_get_active_doc (MooEditor *editor)
MooEdit*
moo_editor_get_active_doc (MooEditor *editor)
{
MooEditWindow *window = moo_editor_get_active_window (editor);
return window ? moo_edit_window_get_active_doc (window) : NULL;
}
MooEditWindow *moo_editor_get_active_window (MooEditor *editor)
MooEditWindow*
moo_editor_get_active_window (MooEditor *editor)
{
g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);
return get_top_window (editor);
}
void moo_editor_set_active_window (MooEditor *editor,
MooEditWindow *window)
void
moo_editor_present (MooEditor *editor)
{
MooEditWindow *window;
g_return_if_fail (MOO_IS_EDITOR (editor));
window = moo_editor_get_active_window (editor);
if (!window)
window = moo_editor_new_window (editor);
g_return_if_fail (window != NULL);
moo_window_present (GTK_WINDOW (window));
}
void
moo_editor_set_active_window (MooEditor *editor,
MooEditWindow *window)
{
WindowInfo *info;
@ -855,8 +898,9 @@ void moo_editor_set_active_window (MooEditor *editor,
}
void moo_editor_set_active_doc (MooEditor *editor,
MooEdit *doc)
void
moo_editor_set_active_doc (MooEditor *editor,
MooEdit *doc)
{
WindowInfo *info;
@ -871,8 +915,9 @@ void moo_editor_set_active_doc (MooEditor *editor,
}
gboolean moo_editor_close_window (MooEditor *editor,
MooEditWindow *window)
gboolean
moo_editor_close_window (MooEditor *editor,
MooEditWindow *window)
{
WindowInfo *info;
MooEditDialogResponse response;
@ -951,8 +996,9 @@ gboolean moo_editor_close_window (MooEditor *editor,
}
static void do_close_window (MooEditor *editor,
MooEditWindow *window)
static void
do_close_window (MooEditor *editor,
MooEditWindow *window)
{
WindowInfo *info;
GSList *l, *list;
@ -1031,7 +1077,8 @@ moo_editor_close_docs (MooEditor *editor,
if (!moo_edit_window_num_docs (info->window) &&
!editor->priv->allow_empty_window)
{
MooEdit *doc = g_object_new (MOO_TYPE_EDIT, "editor", editor, NULL);
MooEdit *doc = g_object_new (get_doc_type (editor),
"editor", editor, NULL);
_moo_edit_window_insert_doc (info->window, doc, -1);
moo_editor_add_doc (editor, info->window, doc,
moo_edit_loader_get_default (),
@ -1366,3 +1413,23 @@ moo_editor_get_lang_mgr (MooEditor *editor)
g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);
return editor->priv->lang_mgr;
}
void
moo_editor_set_window_type (MooEditor *editor,
GType type)
{
g_return_if_fail (MOO_IS_EDITOR (editor));
g_return_if_fail (g_type_is_a (type, MOO_TYPE_EDIT_WINDOW));
editor->priv->window_type = type;
}
void
moo_editor_set_edit_type (MooEditor *editor,
GType type)
{
g_return_if_fail (MOO_IS_EDITOR (editor));
g_return_if_fail (g_type_is_a (type, MOO_TYPE_EDIT));
editor->priv->doc_type = type;
}

7
moo/mooedit/mooeditor.h
View File

@ -76,6 +76,8 @@ void moo_editor_set_active_window (MooEditor *editor,
void moo_editor_set_active_doc (MooEditor *editor,
MooEdit *doc);
void moo_editor_present (MooEditor *editor);
GSList *moo_editor_list_windows (MooEditor *editor);
gboolean moo_editor_close_window (MooEditor *editor,
@ -100,6 +102,11 @@ MooEditor *moo_edit_window_get_editor (MooEditWindow *window);
MooLangMgr *moo_editor_get_lang_mgr (MooEditor *editor);
void moo_editor_set_window_type (MooEditor *editor,
GType type);
void moo_editor_set_edit_type (MooEditor *editor,
GType type);
#ifdef MOOEDIT_COMPILATION
void _moo_edit_window_insert_doc (MooEditWindow *window,

2
moo/mooutils/moomenumgr.c
View File

@ -189,6 +189,8 @@ moo_menu_mgr_finalize (GObject *object)
g_hash_table_destroy (mgr->priv->named_nodes);
g_free (mgr->priv);
G_OBJECT_CLASS(moo_menu_mgr_parent_class)->finalize (object);
}

84
moo/mooutils/mooutils-misc.c
View File

@ -19,12 +19,17 @@
#include <gtk/gtk.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#ifdef __WIN32__
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# include <shellapi.h>
#else
# include <sys/wait.h>
#endif
#if GLIB_CHECK_VERSION(2,6,0)
# include <glib/gstdio.h>
#endif
@ -43,6 +48,85 @@ moo_unlink (const char *filename)
}
int
moo_mkdir (const char *path)
{
g_return_val_if_fail (path != NULL, -1);
#if GLIB_CHECK_VERSION(2,6,0)
return g_mkdir (path, S_IRWXU);
#else
return mkdir (path, S_IRWXU);
#endif
}
#ifndef __WIN32__
static gboolean
rm_fr (const char *path)
{
GError *error = NULL;
char **argv;
char *child_err;
int status;
argv = g_new0 (char*, 5);
argv[0] = g_strdup ("/bin/rm");
argv[1] = g_strdup ("-fr");
argv[2] = g_strdup ("--");
argv[3] = g_strdup (path);
if (!g_spawn_sync (NULL, argv, NULL, G_SPAWN_STDOUT_TO_DEV_NULL,
NULL, NULL, NULL, &child_err, &status, &error))
{
g_warning ("%s: could not run 'rm' command: %s",
G_STRLOC, error->message);
g_error_free (error);
g_strfreev (argv);
return FALSE;
}
g_strfreev (argv);
if (!WIFEXITED (status) || WEXITSTATUS (status))
{
g_warning ("%s: 'rm' command failed: %s",
G_STRLOC, child_err ? child_err : "");
g_free (child_err);
return FALSE;
}
else
{
g_free (child_err);
return TRUE;
}
}
#endif /* __WIN32__ */
gboolean
moo_rmdir (const char *path,
gboolean recursive)
{
g_return_val_if_fail (path != NULL, -1);
if (!recursive)
{
#if GLIB_CHECK_VERSION(2,6,0)
return g_rmdir (path) == 0;
#else
return rmdir (path) == 0;
#endif
}
#ifndef __WIN32__
return rm_fr (path);
#else
#error "Implement me"
#endif
}
/* XXX fix this */
gboolean
moo_save_file_utf8 (const char *name,

3
moo/mooutils/mooutils-misc.h
View File

@ -24,6 +24,9 @@ gboolean moo_save_file_utf8 (const char *name,
gssize len,
GError **error);
int moo_unlink (const char *filename);
int moo_mkdir (const char *path);
gboolean moo_rmdir (const char *path,
gboolean recursive);
gboolean moo_open_url (const char *url);
gboolean moo_open_email (const char *address,