/* lazy loading of language mappings */
static void
load_language_mappings (void)
{
gchar *fname;
GKeyFile *mappings;
GError *error = NULL;
fname = g_build_filename (modelines_data_dir,
MODELINES_LANGUAGE_MAPPINGS_FILE,
NULL);
mappings = g_key_file_new ();
if (g_key_file_load_from_file (mappings, fname, 0, &error))
{
gedit_debug_message (DEBUG_PLUGINS,
"Loaded language mappings from %s",
fname);
vim_languages = load_language_mappings_group (mappings, "vim");
emacs_languages = load_language_mappings_group (mappings, "emacs");
kate_languages = load_language_mappings_group (mappings, "kate");
}
else
{
gedit_debug_message (DEBUG_PLUGINS,
"Failed to loaded language mappings from %s: %s",
fname, error->message);
g_error_free (error);
}
g_key_file_free (mappings);
g_free (fname);
}
static void
gedit_main (gboolean service)
{
GeditPluginsEngine *engine;
GeditApp *app;
const gchar *dir;
gchar *icon_dir;
gedit_debug_message (DEBUG_APP, "Set icon");
dir = gedit_dirs_get_gedit_data_dir ();
icon_dir = g_build_filename (dir, "icons", NULL);
gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), icon_dir);
g_free (icon_dir);
/* Init plugins engine */
gedit_debug_message (DEBUG_APP, "Init plugins");
engine = gedit_plugins_engine_get_default ();
app = gedit_app_get_default ();
/* Initialize session management */
gedit_debug_message (DEBUG_APP, "Init session manager");
gedit_session_init ();
if (!service)
{
gboolean restored = FALSE;
if (gedit_session_is_restored ())
{
restored = gedit_session_load ();
}
if (!restored)
{
gedit_main_window ();
}
}
_gedit_app_ready (app);
gedit_debug_message (DEBUG_APP, "Start gtk-main");
gtk_main ();
/* Make sure settings are saved */
g_settings_sync ();
/* Cleanup */
g_object_unref (engine);
g_object_unref (app);
gedit_dirs_shutdown ();
#ifndef ENABLE_GVFS_METADATA
gedit_metadata_manager_shutdown ();
#endif
}
static GtkSourceLanguage *
guess_language (GeditDocument *doc)
{
GeditDocumentPrivate *priv;
gchar *data;
GtkSourceLanguageManager *manager = gtk_source_language_manager_get_default ();
GtkSourceLanguage *language = NULL;
priv = gedit_document_get_instance_private (doc);
data = gedit_document_get_metadata (doc, GEDIT_METADATA_ATTRIBUTE_LANGUAGE);
if (data != NULL)
{
gedit_debug_message (DEBUG_DOCUMENT, "Language from metadata: %s", data);
if (!g_str_equal (data, NO_LANGUAGE_NAME))
{
language = gtk_source_language_manager_get_language (manager, data);
}
g_free (data);
}
else
{
GFile *location;
gchar *basename = NULL;
location = gtk_source_file_get_location (priv->file);
gedit_debug_message (DEBUG_DOCUMENT, "Sniffing Language");
if (location != NULL)
{
basename = g_file_get_basename (location);
}
else if (priv->short_name != NULL)
{
basename = g_strdup (priv->short_name);
}
language = gtk_source_language_manager_guess_language (manager,
basename,
priv->content_type);
g_free (basename);
}
return language;
}
static GHashTable *
load_language_mappings_group (GKeyFile *key_file, const gchar *group)
{
GHashTable *table;
gchar **keys;
gsize length = 0;
int i;
table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
keys = g_key_file_get_keys (key_file, group, &length, NULL);
gedit_debug_message (DEBUG_PLUGINS,
"%" G_GSIZE_FORMAT " mappings in group %s",
length, group);
for (i = 0; i < length; i++)
{
/* steal the name string */
gchar *name = keys[i];
gchar *id = g_key_file_get_string (key_file, group, name, NULL);
g_hash_table_insert (table, name, id);
}
g_free (keys);
return table;
}
static void
gedit_spell_plugin_finalize (GObject *object)
{
gedit_debug_message (DEBUG_PLUGINS, "GeditSpellPlugin finalizing");
G_OBJECT_CLASS (gedit_spell_plugin_parent_class)->finalize (object);
}
static void
auto_spell_cb (GSimpleAction *action,
GVariant *state,
gpointer data)
{
GeditSpellPlugin *plugin = GEDIT_SPELL_PLUGIN (data);
GeditSpellPluginPrivate *priv = plugin->priv;
GeditView *view;
gboolean active;
gedit_debug (DEBUG_PLUGINS);
active = g_variant_get_boolean (state);
gedit_debug_message (DEBUG_PLUGINS, active ? "Auto Spell activated" : "Auto Spell deactivated");
view = gedit_window_get_active_view (priv->window);
if (view != NULL)
{
GeditDocument *doc;
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
gedit_document_set_metadata (doc,
GEDIT_METADATA_ATTRIBUTE_SPELL_ENABLED,
active ? "1" : NULL, NULL);
set_auto_spell (priv->window, view, active);
g_simple_action_set_state (action, g_variant_new_boolean (active));
}
}
/* Copied from nautilus */
static gchar *
get_direct_save_filename (GdkDragContext *context)
{
guchar *prop_text;
gint prop_len;
if (!gdk_property_get (gdk_drag_context_get_source_window (context), gdk_atom_intern ("XdndDirectSave0", FALSE),
gdk_atom_intern ("text/plain", FALSE), 0, 1024, FALSE, NULL, NULL,
&prop_len, &prop_text) && prop_text != NULL) {
return NULL;
}
/* Zero-terminate the string */
prop_text = g_realloc (prop_text, prop_len + 1);
prop_text[prop_len] = '\0';
/* Verify that the file name provided by the source is valid */
if (*prop_text == '\0' ||
strchr ((const gchar *) prop_text, G_DIR_SEPARATOR) != NULL) {
gedit_debug_message (DEBUG_UTILS, "Invalid filename provided by XDS drag site");
g_free (prop_text);
return NULL;
}
return (gchar *)prop_text;
}
static gchar *
get_current_word (GeditDocument *doc, gint *start, gint *end)
{
const CheckRange *range;
GtkTextIter end_iter;
GtkTextIter current_iter;
gint range_end;
gedit_debug (DEBUG_PLUGINS);
g_return_val_if_fail (doc != NULL, NULL);
g_return_val_if_fail (start != NULL, NULL);
g_return_val_if_fail (end != NULL, NULL);
range = get_check_range (doc);
g_return_val_if_fail (range != NULL, NULL);
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc),
&end_iter, range->end_mark);
range_end = gtk_text_iter_get_offset (&end_iter);
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc),
¤t_iter, range->current_mark);
end_iter = current_iter;
if (!gtk_text_iter_is_end (&end_iter))
{
gedit_debug_message (DEBUG_PLUGINS, "Current is not end");
gtk_text_iter_forward_word_end (&end_iter);
}
*start = gtk_text_iter_get_offset (¤t_iter);
*end = MIN (gtk_text_iter_get_offset (&end_iter), range_end);
gedit_debug_message (DEBUG_PLUGINS, "Current word extends [%d, %d]", *start, *end);
if (!(*start < *end))
return NULL;
return gtk_text_buffer_get_slice (GTK_TEXT_BUFFER (doc),
¤t_iter,
&end_iter,
TRUE);
}
/**
* gedit_debug:
* @section: debug section.
* @file: file name.
* @line: line number.
* @function: name of the function that is calling gedit_debug().
*
* If @section is enabled, then logs the trace information @file, @line, and
* @function.
*/
void
gedit_debug (GeditDebugSection section,
const gchar *file,
gint line,
const gchar *function)
{
gedit_debug_message (section, file, line, function, "%s", "");
}
/**
* gedit_debug_plugin_message:
* @file: file name.
* @line: line number.
* @function: name of the function that is calling gedit_debug_plugin_message().
* @message: a message.
*
* If the section %GEDIT_DEBUG_PLUGINS is enabled, then logs the trace
* information @file, @line, and @function along with @message.
*
* This function may be overridden by GObject Introspection language bindings
* to be more language-specific.
*
* <emphasis>Python</emphasis>
*
* A PyGObject override is provided that has the following signature:
* <informalexample>
* <programlisting>
* def debug_plugin_message(format_str, *format_args):
* #...
* </programlisting>
* </informalexample>
*
* It automatically supplies parameters @file, @line, and @function, and it
* formats <code>format_str</code> with the given format arguments. The syntax
* of the format string is the usual Python string formatting syntax described
* by <ulink url="http://docs.python.org/library/stdtypes.html#string-formatting">5.6.2. String Formatting Operations</ulink>.
*
* Since: 3.4
*/
void
gedit_debug_plugin_message (const gchar *file,
gint line,
const gchar *function,
const gchar *message)
{
gedit_debug_message (GEDIT_DEBUG_PLUGINS, file, line, function, "%s", message);
}
static void
gedit_word_completion_plugin_init (GeditWordCompletionPlugin *plugin)
{
gedit_debug_message (DEBUG_PLUGINS, "GeditWordCompletionPlugin initializing");
plugin->priv = G_TYPE_INSTANCE_GET_PRIVATE (plugin,
GEDIT_TYPE_WORD_COMPLETION_PLUGIN,
GeditWordCompletionPluginPrivate);
}
static void
gedit_spell_plugin_init (GeditSpellPlugin *plugin)
{
gedit_debug_message (DEBUG_PLUGINS, "GeditSpellPlugin initializing");
plugin->priv = G_TYPE_INSTANCE_GET_PRIVATE (plugin,
GEDIT_TYPE_SPELL_PLUGIN,
GeditSpellPluginPrivate);
}
static void
gedit_modeline_plugin_finalize (GObject *object)
{
gedit_debug_message (DEBUG_PLUGINS, "GeditModelinePlugin finalizing");
modeline_parser_shutdown ();
G_OBJECT_CLASS (gedit_modeline_plugin_parent_class)->finalize (object);
}
gboolean
gedit_utils_uri_exists (const gchar* text_uri)
{
GFile *gfile;
gboolean res;
g_return_val_if_fail (text_uri != NULL, FALSE);
gedit_debug_message (DEBUG_UTILS, "text_uri: %s", text_uri);
gfile = g_file_new_for_uri (text_uri);
res = g_file_query_exists (gfile, NULL);
g_object_unref (gfile);
gedit_debug_message (DEBUG_UTILS, res ? "TRUE" : "FALSE");
return res;
}
static void
new_window_activated (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GeditApp *app;
GeditWindow *window;
app = GEDIT_APP (user_data);
window = gedit_app_create_window (app, NULL);
gedit_debug_message (DEBUG_APP, "Show window");
gtk_widget_show (GTK_WIDGET (window));
gedit_debug_message (DEBUG_APP, "Create tab");
gedit_window_create_tab (window, TRUE);
gtk_window_present (GTK_WINDOW (window));
}
gchar *
gedit_utils_escape_search_text (const gchar* text)
{
GString *str;
gint length;
const gchar *p;
const gchar *end;
if (text == NULL)
return NULL;
gedit_debug_message (DEBUG_SEARCH, "Text: %s", text);
length = strlen (text);
/* no escape when typing.
* The short circuit works only for ascii, but we only
* care about not escaping a single '\' */
if (length == 1)
return g_strdup (text);
str = g_string_new ("");
p = text;
end = text + length;
while (p != end)
{
const gchar *next;
next = g_utf8_next_char (p);
switch (*p)
{
case '\n':
g_string_append (str, "\\n");
break;
case '\r':
g_string_append (str, "\\r");
break;
case '\t':
g_string_append (str, "\\t");
break;
case '\\':
g_string_append (str, "\\\\");
break;
default:
g_string_append_len (str, p, next - p);
break;
}
p = next;
}
return g_string_free (str, FALSE);
}
static void
gedit_spell_plugin_dispose (GObject *object)
{
GeditSpellPlugin *plugin = GEDIT_SPELL_PLUGIN (object);
gedit_debug_message (DEBUG_PLUGINS, "GeditSpellPlugin disposing");
g_clear_object (&plugin->priv->window);
G_OBJECT_CLASS (gedit_spell_plugin_parent_class)->dispose (object);
}
gchar *
gedit_convert_from_utf8 (const gchar *content,
gsize len,
const GeditEncoding *encoding,
gsize *new_len,
GError **error)
{
GError *conv_error = NULL;
gchar *converted_contents = NULL;
gsize bytes_written = 0;
gedit_debug (DEBUG_UTILS);
g_return_val_if_fail (content != NULL, NULL);
g_return_val_if_fail (g_utf8_validate (content, len, NULL), NULL);
g_return_val_if_fail (encoding != NULL, NULL);
if (len < 0)
len = strlen (content);
if (encoding == gedit_encoding_get_utf8 ())
return g_strndup (content, len);
converted_contents = g_convert (content,
len,
gedit_encoding_get_charset (encoding),
"UTF-8",
NULL,
&bytes_written,
&conv_error);
if (conv_error != NULL)
{
gedit_debug_message (DEBUG_UTILS, "Cannot convert from UTF-8 to %s",
gedit_encoding_get_charset (encoding));
if (converted_contents != NULL)
{
g_free (converted_contents);
converted_contents = NULL;
}
g_propagate_error (error, conv_error);
}
else
{
if (new_len != NULL)
*new_len = bytes_written;
}
return converted_contents;
}
/* Scan a line for vi(m)/emacs/kate modelines.
* Line numbers are counted starting at one.
*/
static void
parse_modeline (gchar *s,
gint line_number,
gint line_count,
ModelineOptions *options)
{
gchar prev;
/* look for the beginning of a modeline */
for (prev = ' '; (s != NULL) && (*s != '\0'); prev = *(s++))
{
if (!g_ascii_isspace (prev))
continue;
if ((line_number <= 3 || line_number > line_count - 3) &&
(strncmp (s, "ex:", 3) == 0 ||
strncmp (s, "vi:", 3) == 0 ||
strncmp (s, "vim:", 4) == 0))
{
gedit_debug_message (DEBUG_PLUGINS, "Vim modeline on line %d", line_number);
while (*s != ':') s++;
s = parse_vim_modeline (s + 1, options);
}
else if (line_number <= 2 && strncmp (s, "-*-", 3) == 0)
{
gedit_debug_message (DEBUG_PLUGINS, "Emacs modeline on line %d", line_number);
s = parse_emacs_modeline (s + 3, options);
}
else if ((line_number <= 10 || line_number > line_count - 10) &&
strncmp (s, "kate:", 5) == 0)
{
gedit_debug_message (DEBUG_PLUGINS, "Kate modeline on line %d", line_number);
s = parse_kate_modeline (s + 5, options);
}
}
}
static void
load_accels (void)
{
gchar *filename;
filename = g_build_filename (gedit_dirs_get_user_config_dir (),
"accels",
NULL);
if (filename != NULL)
{
gedit_debug_message (DEBUG_APP, "Loading keybindings from %s\n", filename);
gtk_accel_map_load (filename);
g_free (filename);
}
}
static void
on_content_type_changed (GeditDocument *doc,
GParamSpec *pspec,
gpointer useless)
{
if (!doc->priv->language_set_by_user)
{
GtkSourceLanguage *language = guess_language (doc);
gedit_debug_message (DEBUG_DOCUMENT, "Language: %s",
language != NULL ? gtk_source_language_get_name (language) : "None");
set_language (doc, language, FALSE);
}
}
static GeditWindow *
gedit_app_create_window_impl (GeditApp *app)
{
GeditWindow *window;
window = g_object_new (GEDIT_TYPE_WINDOW, "application", app, NULL);
gedit_debug_message (DEBUG_APP, "Window created");
g_signal_connect (window,
"delete_event",
G_CALLBACK (window_delete_event),
app);
return window;
}
static void
gedit_document_loaded_real (GeditDocument *doc)
{
GFile *location;
if (!doc->priv->language_set_by_user)
{
GtkSourceLanguage *language = guess_language (doc);
gedit_debug_message (DEBUG_DOCUMENT, "Language: %s",
language != NULL ? gtk_source_language_get_name (language) : "None");
set_language (doc, language, FALSE);
}
doc->priv->mtime_set = FALSE;
doc->priv->externally_modified = FALSE;
doc->priv->deleted = FALSE;
g_get_current_time (&doc->priv->time_of_last_save_or_load);
set_readonly (doc, FALSE);
gedit_document_set_content_type (doc, NULL);
location = gtk_source_file_get_location (doc->priv->file);
if (location != NULL)
{
/* Keep the doc alive during the async operation. */
g_object_ref (doc);
g_file_query_info_async (location,
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE ","
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
NULL,
(GAsyncReadyCallback) loaded_query_info_cb,
doc);
}
}
static void
gedit_app_shutdown (GApplication *app)
{
gedit_debug_message (DEBUG_APP, "Quitting\n");
/* Last window is gone... save some settings and exit */
ensure_user_config_dir ();
save_accels ();
save_page_setup (GEDIT_APP (app));
save_print_settings (GEDIT_APP (app));
/* GTK+ can still hold references to some gedit objects, for example
* GeditDocument for the clipboard. So the metadata-manager should be
* shutdown after.
*/
G_APPLICATION_CLASS (gedit_app_parent_class)->shutdown (app);
#ifndef ENABLE_GVFS_METADATA
gedit_metadata_manager_shutdown ();
#endif
gedit_dirs_shutdown ();
}
static void
auto_spell_cb (GtkAction *action,
GeditWindow *window)
{
GeditDocument *doc;
gboolean active;
gedit_debug (DEBUG_PLUGINS);
active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
gedit_debug_message (DEBUG_PLUGINS, active ? "Auto Spell activated" : "Auto Spell deactivated");
doc = gedit_window_get_active_document (window);
if (doc == NULL)
return;
gedit_document_set_metadata (doc,
GEDIT_METADATA_ATTRIBUTE_SPELL_ENABLED,
active ? "1" : NULL, NULL);
set_auto_spell (window, doc, active);
}
static void
gedit_main_window (void)
{
GSList *file_list;
GeditWindow *window;
GeditCommandLine *command_line;
GeditApp *app;
gboolean doc_created = FALSE;
const gchar *geometry;
app = gedit_app_get_default ();
gedit_debug_message (DEBUG_APP, "Create main window");
window = gedit_app_create_window (app, NULL);
command_line = gedit_command_line_get_default ();
file_list = gedit_command_line_get_file_list (command_line);
if (file_list != NULL)
{
GSList *loaded;
const GeditEncoding *encoding;
gint line_position;
gint column_position;
encoding = gedit_command_line_get_encoding (command_line);
line_position = gedit_command_line_get_line_position (command_line);
column_position = gedit_command_line_get_column_position (command_line);
gedit_debug_message (DEBUG_APP, "Load files");
loaded = _gedit_cmd_load_files_from_prompt (window,
file_list,
encoding,
line_position,
column_position);
doc_created = loaded != NULL;
g_slist_free (loaded);
}
if (gedit_utils_can_read_from_stdin ())
{
doc_created = gedit_main_load_from_stdin (window, !doc_created);
}
if (!doc_created || gedit_command_line_get_new_document (command_line))
{
gedit_debug_message (DEBUG_APP, "Create tab");
gedit_window_create_tab (window, TRUE);
}
geometry = gedit_command_line_get_geometry (command_line);
gedit_debug_message (DEBUG_APP, "Show window");
gtk_widget_show (GTK_WIDGET (window));
if (geometry)
{
gtk_window_parse_geometry (GTK_WINDOW (window),
geometry);
}
}
int
main (int argc, char *argv[])
{
const gchar *dir;
GeditCommandLine *command_line;
gboolean ret;
gboolean service = FALSE;
#ifdef G_OS_UNIX
GeditDBus *dbus;
GeditDBusResult dbusret;
#endif
#ifdef OS_OSX
GPollFunc orig_poll_func;
GPollFunc gdk_poll_func;
#endif
#ifndef ENABLE_GVFS_METADATA
const gchar *cache_dir;
gchar *metadata_filename;
#endif
/* Setup debugging */
gedit_debug_init ();
gedit_debug_message (DEBUG_APP, "Startup");
/* Setup locale/gettext */
setlocale (LC_ALL, "");
gedit_dirs_init ();
dir = gedit_dirs_get_gedit_locale_dir ();
bindtextdomain (GETTEXT_PACKAGE, dir);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#ifndef ENABLE_GVFS_METADATA
/* Setup metadata-manager */
cache_dir = gedit_dirs_get_user_cache_dir ();
metadata_filename = g_build_filename (cache_dir, METADATA_FILE, NULL);
gedit_metadata_manager_init (metadata_filename);
g_free (metadata_filename);
#endif
#ifdef OS_OSX
orig_poll_func = g_main_context_get_poll_func (NULL);
#endif
/* Parse command line arguments */
command_line = gedit_command_line_get_default ();
ret = gedit_command_line_parse (command_line, &argc, &argv);
if (!ret)
{
g_object_unref (command_line);
return 1;
}
#ifdef G_OS_UNIX
#ifdef OS_OSX
/* Note: this is a bit of a hack. What happens here is that we are going to
* store the poll function installed by gdk (happens in post-parse of options)
* and replace it with the original main loop poll handler. We do this because
* the gedit dbus stuff is going to run some main loops to run async gdbus calls.
* The problem is that for OS X, the gdk poll func in the main context (which
* will be run due to the fact that the main loops in our dbus code iterate the
* main context) is going to process events from NSApp, INCLUDING apple events
* such as OpenFiles. Since we are not setup yet, we are going to miss these
* events. By swapping out the gdk poll func, and swapping it back in later,
* we prevent this from happening. Note that we only do this when building
* on OS X to prevent any possible future problems for other platforms.
* This is a dirty hack, but it works for now.
*/
gdk_poll_func = g_main_context_get_poll_func (NULL);
g_main_context_set_poll_func (NULL, orig_poll_func);
#endif
/* Run over dbus */
dbus = gedit_dbus_new ();
dbusret = gedit_dbus_run (dbus);
#ifdef OS_OSX
g_main_context_set_poll_func (NULL, gdk_poll_func);
#endif
switch (dbusret)
{
case GEDIT_DBUS_RESULT_SUCCESS:
case GEDIT_DBUS_RESULT_FAILED: /* fallthrough */
g_object_unref (command_line);
g_object_unref (dbus);
return dbusret == GEDIT_DBUS_RESULT_SUCCESS ? 0 : 1;
break;
case GEDIT_DBUS_RESULT_PROCEED_SERVICE:
service = TRUE;
break;
case GEDIT_DBUS_RESULT_PROCEED:
break;
}
#endif
gedit_main (service);
#ifdef G_OS_UNIX
g_object_unref (dbus);
#endif
g_object_unref (command_line);
return 0;
}
static GCharsetConverter *
guess_encoding (GeditDocumentOutputStream *stream,
const void *inbuf,
gsize inbuf_size)
{
GCharsetConverter *conv = NULL;
if (inbuf == NULL || inbuf_size == 0)
{
stream->priv->is_utf8 = TRUE;
return NULL;
}
if (stream->priv->encodings != NULL &&
stream->priv->encodings->next == NULL)
{
stream->priv->use_first = TRUE;
}
/* We just check the first block */
while (TRUE)
{
const GeditEncoding *enc;
if (conv != NULL)
{
g_object_unref (conv);
conv = NULL;
}
/* We get an encoding from the list */
enc = get_encoding (stream);
/* if it is NULL we didn't guess anything */
if (enc == NULL)
{
break;
}
gedit_debug_message (DEBUG_UTILS, "trying charset: %s",
gedit_encoding_get_charset (stream->priv->current_encoding->data));
if (enc == gedit_encoding_get_utf8 ())
{
gsize remainder;
const gchar *end;
if (g_utf8_validate (inbuf, inbuf_size, &end) ||
stream->priv->use_first)
{
stream->priv->is_utf8 = TRUE;
break;
}
/* Check if the end is less than one char */
remainder = inbuf_size - (end - (gchar *)inbuf);
if (remainder < 6)
{
stream->priv->is_utf8 = TRUE;
break;
}
continue;
}
conv = g_charset_converter_new ("UTF-8",
gedit_encoding_get_charset (enc),
NULL);
/* If we tried all encodings we use the first one */
if (stream->priv->use_first)
{
break;
}
/* Try to convert */
if (try_convert (conv, inbuf, inbuf_size))
{
break;
}
}
if (conv != NULL)
{
g_converter_reset (G_CONVERTER (conv));
}
return conv;
}
static void
open_files (GApplication *application,
gboolean new_window,
gboolean new_document,
gchar *geometry,
gint line_position,
gint column_position,
const GtkSourceEncoding *encoding,
GInputStream *stdin_stream,
GSList *file_list,
GApplicationCommandLine *command_line)
{
GeditWindow *window = NULL;
GeditTab *tab;
gboolean doc_created = FALSE;
if (!new_window)
{
window = get_active_window (GTK_APPLICATION (application));
}
if (window == NULL)
{
gedit_debug_message (DEBUG_APP, "Create main window");
window = gedit_app_create_window (GEDIT_APP (application), NULL);
gedit_debug_message (DEBUG_APP, "Show window");
gtk_widget_show (GTK_WIDGET (window));
}
if (geometry)
{
gtk_window_parse_geometry (GTK_WINDOW (window), geometry);
}
if (stdin_stream)
{
gedit_debug_message (DEBUG_APP, "Load stdin");
tab = gedit_window_create_tab_from_stream (window,
stdin_stream,
encoding,
line_position,
column_position,
TRUE);
doc_created = tab != NULL;
if (doc_created && command_line)
{
set_command_line_wait (GEDIT_APP (application),
tab);
}
g_input_stream_close (stdin_stream, NULL, NULL);
}
if (file_list != NULL)
{
GSList *loaded;
gedit_debug_message (DEBUG_APP, "Load files");
loaded = _gedit_cmd_load_files_from_prompt (window,
file_list,
encoding,
line_position,
column_position);
doc_created = doc_created || loaded != NULL;
if (command_line)
{
g_slist_foreach (loaded, (GFunc)set_command_line_wait_doc, GEDIT_APP (application));
}
g_slist_free (loaded);
}
if (!doc_created || new_document)
{
gedit_debug_message (DEBUG_APP, "Create tab");
tab = gedit_window_create_tab (window, TRUE);
if (command_line)
{
set_command_line_wait (GEDIT_APP (application),
tab);
}
}
gtk_window_present (GTK_WINDOW (window));
}
static void
gedit_app_startup (GApplication *application)
{
GeditAppPrivate *priv;
GtkCssProvider *css_provider;
GtkSourceStyleSchemeManager *manager;
const gchar *dir;
gchar *icon_dir;
#ifndef ENABLE_GVFS_METADATA
const gchar *cache_dir;
gchar *metadata_filename;
#endif
priv = gedit_app_get_instance_private (GEDIT_APP (application));
G_APPLICATION_CLASS (gedit_app_parent_class)->startup (application);
/* Setup debugging */
gedit_debug_init ();
gedit_debug_message (DEBUG_APP, "Startup");
gedit_debug_message (DEBUG_APP, "Set icon");
dir = gedit_dirs_get_gedit_data_dir ();
icon_dir = g_build_filename (dir, "icons", NULL);
gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), icon_dir);
g_free (icon_dir);
setup_theme_extensions (GEDIT_APP (application));
#ifndef ENABLE_GVFS_METADATA
cache_dir = gedit_dirs_get_user_cache_dir ();
metadata_filename = g_build_filename (cache_dir, "gedit-metadata.xml", NULL);
gedit_metadata_manager_init (metadata_filename);
g_free (metadata_filename);
#endif
/* Load settings */
priv->settings = gedit_settings_new ();
priv->ui_settings = g_settings_new ("org.gnome.gedit.preferences.ui");
priv->window_settings = g_settings_new ("org.gnome.gedit.state.window");
/* initial lockdown state */
priv->lockdown = gedit_settings_get_lockdown (GEDIT_SETTINGS (priv->settings));
g_action_map_add_action_entries (G_ACTION_MAP (application),
app_entries,
G_N_ELEMENTS (app_entries),
application);
/* menus */
priv->window_menu = gtk_application_get_menubar (GTK_APPLICATION (application));
if (priv->window_menu == NULL)
{
priv->window_menu = get_menu_model (GEDIT_APP (application), "gear-menu");
}
else
{
g_object_ref (priv->window_menu);
}
priv->notebook_menu = get_menu_model (GEDIT_APP (application), "notebook-menu");
priv->tab_width_menu = get_menu_model (GEDIT_APP (application), "tab-width-menu");
priv->line_col_menu = get_menu_model (GEDIT_APP (application), "line-col-menu");
/* Accelerators */
add_accelerator (GTK_APPLICATION (application), "app.new-window", "<Primary>N");
add_accelerator (GTK_APPLICATION (application), "app.quit", "<Primary>Q");
add_accelerator (GTK_APPLICATION (application), "app.help", "F1");
add_accelerator (GTK_APPLICATION (application), "win.gear-menu", "F10");
add_accelerator (GTK_APPLICATION (application), "win.open", "<Primary>O");
add_accelerator (GTK_APPLICATION (application), "win.save", "<Primary>S");
add_accelerator (GTK_APPLICATION (application), "win.save-as", "<Primary><Shift>S");
add_accelerator (GTK_APPLICATION (application), "win.save-all", "<Primary><Shift>L");
add_accelerator (GTK_APPLICATION (application), "win.new-tab", "<Primary>T");
add_accelerator (GTK_APPLICATION (application), "win.reopen-closed-tab", "<Primary><Shift>T");
add_accelerator (GTK_APPLICATION (application), "win.close", "<Primary>W");
add_accelerator (GTK_APPLICATION (application), "win.close-all", "<Primary><Shift>W");
add_accelerator (GTK_APPLICATION (application), "win.print", "<Primary>P");
add_accelerator (GTK_APPLICATION (application), "win.find", "<Primary>F");
add_accelerator (GTK_APPLICATION (application), "win.find-next", "<Primary>G");
add_accelerator (GTK_APPLICATION (application), "win.find-prev", "<Primary><Shift>G");
add_accelerator (GTK_APPLICATION (application), "win.replace", "<Primary>H");
add_accelerator (GTK_APPLICATION (application), "win.clear-highlight", "<Primary><Shift>K");
add_accelerator (GTK_APPLICATION (application), "win.goto-line", "<Primary>I");
add_accelerator (GTK_APPLICATION (application), "win.focus-active-view", "Escape");
add_accelerator (GTK_APPLICATION (application), "win.side-panel", "F9");
add_accelerator (GTK_APPLICATION (application), "win.bottom-panel", "<Primary>F9");
add_accelerator (GTK_APPLICATION (application), "win.fullscreen", "F11");
add_accelerator (GTK_APPLICATION (application), "win.new-tab-group", "<Primary><Alt>N");
add_accelerator (GTK_APPLICATION (application), "win.previous-tab-group", "<Primary><Shift><Alt>Page_Up");
add_accelerator (GTK_APPLICATION (application), "win.next-tab-group", "<Primary><Shift><Alt>Page_Down");
add_accelerator (GTK_APPLICATION (application), "win.previous-document", "<Primary><Alt>Page_Up");
add_accelerator (GTK_APPLICATION (application), "win.next-document", "<Primary><Alt>Page_Down");
load_accels ();
/* Load custom css */
g_object_unref (load_css_from_resource ("gedit-style.css", TRUE));
css_provider = load_css_from_resource ("gedit-style-os.css", FALSE);
g_clear_object (&css_provider);
/*
* We use the default gtksourceview style scheme manager so that plugins
* can obtain it easily without a gedit specific api, but we need to
* add our search path at startup before the manager is actually used.
*/
manager = gtk_source_style_scheme_manager_get_default ();
gtk_source_style_scheme_manager_append_search_path (manager,
gedit_dirs_get_user_styles_dir ());
priv->engine = gedit_plugins_engine_get_default ();
priv->extensions = peas_extension_set_new (PEAS_ENGINE (priv->engine),
GEDIT_TYPE_APP_ACTIVATABLE,
"app", GEDIT_APP (application),
NULL);
g_signal_connect (priv->extensions,
"extension-added",
G_CALLBACK (extension_added),
application);
g_signal_connect (priv->extensions,
"extension-removed",
G_CALLBACK (extension_removed),
application);
peas_extension_set_foreach (priv->extensions,
(PeasExtensionSetForeachFunc) extension_added,
application);
}
