static gboolean
looks_like_makefile (IdeBuffer *buffer)
{
GtkSourceLanguage *language;
const gchar *path;
IdeFile *file;
g_assert (IDE_IS_BUFFER (buffer));
file = ide_buffer_get_file (buffer);
path = ide_file_get_path (file);
if (path != NULL)
{
if (g_str_has_suffix (path, "Makefile.am") || g_str_has_suffix (path, ".mk"))
return TRUE;
}
language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (buffer));
if (language != NULL)
{
const gchar *lang_id;
lang_id = gtk_source_language_get_id (language);
if (ide_str_equal0 (lang_id, "automake") || ide_str_equal0 (lang_id, "makefile"))
return TRUE;
}
return FALSE;
}
static void
gb_editor_tab_apply_settings (GbEditorTab *tab)
{
GbEditorTabPrivate *priv;
GtkSourceLanguage *lang;
const gchar *name;
gchar *path;
g_return_if_fail (GB_IS_EDITOR_TAB (tab));
priv = tab->priv;
g_clear_object (&priv->settings);
lang = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (priv->document));
if (lang) {
name = gtk_source_language_get_id (lang);
} else {
name = "plaintext";
}
path = g_strdup_printf ("/org/gnome/builder/preferences/editor/language/%s/", name);
priv->settings = g_settings_new_with_path ("org.gnome.builder.preferences.editor.language", path);
g_free (path);
g_settings_bind (priv->settings, "highlight-matching-brackets", priv->document, "highlight-matching-brackets", G_SETTINGS_BIND_GET);
g_settings_bind (priv->settings, "highlight-current-line", priv->text_view, "highlight-current-line", G_SETTINGS_BIND_GET);
g_settings_bind (priv->settings, "insert-spaces-instead-of-tabs", priv->text_view, "insert-spaces-instead-of-tabs", G_SETTINGS_BIND_GET);
g_settings_bind (priv->settings, "right-margin-position", priv->text_view, "right-margin-position", G_SETTINGS_BIND_GET);
g_settings_bind (priv->settings, "show-line-marks", priv->text_view, "show-line-marks", G_SETTINGS_BIND_GET);
g_settings_bind (priv->settings, "show-line-numbers", priv->text_view, "show-line-numbers", G_SETTINGS_BIND_GET);
g_settings_bind (priv->settings, "show-right-margin", priv->text_view, "show-right-margin", G_SETTINGS_BIND_GET);
g_settings_bind (priv->settings, "tab-width", priv->text_view, "tab-width", G_SETTINGS_BIND_GET);
}
static void
ide_editor_view__extension_added (PeasExtensionSet *set,
PeasPluginInfo *info,
PeasExtension *exten,
gpointer user_data)
{
IdeEditorView *self = user_data;
IdeEditorViewAddin *addin = (IdeEditorViewAddin *)exten;
g_assert (PEAS_IS_EXTENSION_SET (set));
g_assert (info != NULL);
g_assert (IDE_IS_EDITOR_VIEW_ADDIN (addin));
g_assert (IDE_IS_EDITOR_VIEW (self));
ide_editor_view_addin_load (addin, self);
if (self->document != NULL)
{
GtkSourceLanguage *language;
language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (self->document));
if (language != NULL)
{
const gchar *language_id;
language_id = gtk_source_language_get_id (language);
ide_editor_view_addin_language_changed (addin, language_id);
}
}
}
static const gchar *
get_language_string (GeditDocument *doc)
{
GtkSourceLanguage *lang = gedit_document_get_language (doc);
return lang != NULL ? gtk_source_language_get_id (lang) : NO_LANGUAGE_NAME;
}
static void
gb_editor_view_actions_preview (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
GbEditorView *self = user_data;
GtkSourceLanguage *language;
const gchar *lang_id = NULL;
g_autoptr(GbDocument) document = NULL;
g_assert (GB_IS_EDITOR_VIEW (self));
language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (self->document));
if (!language)
return;
lang_id = gtk_source_language_get_id (language);
if (!lang_id)
return;
#if 0
if (g_str_equal (lang_id, "html"))
{
document = g_object_new (GB_TYPE_HTML_DOCUMENT,
"buffer", self->document,
NULL);
}
else if (g_str_equal (lang_id, "markdown"))
{
document = g_object_new (GB_TYPE_HTML_DOCUMENT,
"buffer", self->document,
NULL);
gb_html_document_set_transform_func (GB_HTML_DOCUMENT (document),
gb_html_markdown_transform);
}
#endif
if (document)
{
GtkWidget *parent = gtk_widget_get_parent (GTK_WIDGET (self));
while (parent && !GB_IS_VIEW_GRID (parent))
parent = gtk_widget_get_parent (parent);
if (parent == NULL)
{
while (parent && !GB_IS_VIEW_STACK (parent))
parent = gtk_widget_get_parent (parent);
g_assert (GB_IS_VIEW_STACK (parent));
gb_view_stack_focus_document (GB_VIEW_STACK (parent), document);
return;
}
g_assert (GB_IS_VIEW_GRID (parent));
gb_view_grid_focus_document (GB_VIEW_GRID (parent), document);
}
}
static gboolean
check_previous (GtkSourceView *view,
ModelineOptions *previous,
ModelineSet set)
{
GtkSourceBuffer *buffer = GTK_SOURCE_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
/* Do not restore default when this is the first time */
if (!previous)
return FALSE;
/* Do not restore default when previous was not set */
if (!(previous->set & set))
return FALSE;
/* Only restore default when setting has not changed */
switch (set)
{
case MODELINE_SET_INSERT_SPACES:
return gtk_source_view_get_insert_spaces_instead_of_tabs (view) ==
previous->insert_spaces;
break;
case MODELINE_SET_TAB_WIDTH:
return gtk_source_view_get_tab_width (view) == previous->tab_width;
break;
case MODELINE_SET_INDENT_WIDTH:
return gtk_source_view_get_indent_width (view) == previous->indent_width;
break;
case MODELINE_SET_WRAP_MODE:
return gtk_text_view_get_wrap_mode (GTK_TEXT_VIEW (view)) ==
previous->wrap_mode;
break;
case MODELINE_SET_RIGHT_MARGIN_POSITION:
return gtk_source_view_get_right_margin_position (view) ==
previous->right_margin_position;
break;
case MODELINE_SET_SHOW_RIGHT_MARGIN:
return gtk_source_view_get_show_right_margin (view) ==
previous->display_right_margin;
break;
case MODELINE_SET_LANGUAGE:
{
GtkSourceLanguage *language = gtk_source_buffer_get_language (buffer);
return (language == NULL && previous->language_id == NULL) ||
(language != NULL && g_strcmp0 (gtk_source_language_get_id (language),
previous->language_id) == 0);
}
break;
default:
return FALSE;
break;
}
}
static void
ide_highlight_engine__notify_language_cb (IdeHighlightEngine *self,
GParamSpec *pspec,
IdeBuffer *buffer)
{
GtkSourceLanguage *language;
const gchar *lang_id = NULL;
g_assert (IDE_IS_HIGHLIGHT_ENGINE (self));
g_assert (IDE_IS_BUFFER (buffer));
if ((language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (buffer))))
lang_id = gtk_source_language_get_id (language);
ide_extension_adapter_set_value (self->extension, lang_id);
}
static void
ide_editor_view__buffer_notify_language (IdeEditorView *self,
GParamSpec *pspec,
IdeBuffer *document)
{
g_assert (IDE_IS_EDITOR_VIEW (self));
g_assert (IDE_IS_BUFFER (document));
if (self->extensions != NULL)
{
GtkSourceLanguage *language;
const gchar *language_id;
language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (document));
language_id = language ? gtk_source_language_get_id (language) : NULL;
peas_extension_set_foreach (self->extensions,
notify_language_foreach,
(gchar *)language_id);
}
}
void
gb_editor_view_actions_update (GbEditorView *self)
{
GtkSourceLanguage *language;
const gchar *lang_id = NULL;
GActionGroup *group;
GAction *action;
gboolean enabled;
g_assert (GB_IS_EDITOR_VIEW (self));
group = gtk_widget_get_action_group (GTK_WIDGET (self), "view");
if (!G_IS_SIMPLE_ACTION_GROUP (group))
return;
/* update preview sensitivity */
language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (self->document));
if (language)
lang_id = gtk_source_language_get_id (language);
enabled = ((g_strcmp0 (lang_id, "html") == 0) ||
(g_strcmp0 (lang_id, "markdown") == 0));
action = g_action_map_lookup_action (G_ACTION_MAP (group), "preview");
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), enabled);
}
void save_as_file(GtkButton *button) {
/** Save the current editor content as the choosen file. **/
#ifdef DEBUG
DEBUG_FUNC_MARK
#endif
GtkWidget *file_chooser = gtk_file_chooser_dialog_new( _("Save as file"),
GTK_WINDOW(gui->main_window),
GTK_FILE_CHOOSER_ACTION_SAVE,
_("Cancel"), GTK_RESPONSE_CANCEL,
_("Save as"), GTK_RESPONSE_ACCEPT,
NULL) ;
/** Retrieve the stored filepath: **/
gpointer stored_filepath = g_object_get_data(G_OBJECT(current_editor.current_buffer), "filepath") ;
/** Storing last opened file folder. **/
if (open_file_dirname != NULL) {
g_free(open_file_dirname) ;
}
open_file_dirname = g_strdup(g_path_get_dirname(stored_filepath)) ;
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), open_file_dirname );
gint res;
GtkFileChooser *chooser;
chooser = GTK_FILE_CHOOSER(file_chooser);
gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE);
res = gtk_dialog_run(GTK_DIALOG(file_chooser)) ;
if (res == GTK_RESPONSE_ACCEPT) {
char *filepath ;
filepath = gtk_file_chooser_get_filename(chooser);
/** Getting current editor content **/
GtkTextIter iter_start, iter_end ;
GError *error = NULL ;
gtk_text_buffer_get_start_iter(current_editor.current_buffer, &iter_start);
gtk_text_buffer_get_end_iter(current_editor.current_buffer, &iter_end);
gchar *file_content = gtk_text_buffer_get_text(current_editor.current_buffer, &iter_start, &iter_end, FALSE) ;
if (! g_file_set_contents(filepath, file_content, -1, &error) ) {
/** Failed to save editor content as file, display an error message and return. **/
char *msg = g_strdup_printf(_("Failed to save file:\n%s"), filepath) ;
display_message_dialog(_("Cannot save file !!!"), msg, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE) ;
free(msg) ;
return ;
}
/** Mark the TextBuffer as not modfied. **/
gtk_text_buffer_set_modified(current_editor.current_buffer, FALSE) ;
/** Only useful if the content type has changed like a new file saved as a *.c file. **/
GtkSourceLanguage *source_language = NULL ;
GtkSourceLanguageManager *source_language_manager = gtk_source_language_manager_get_default();
gboolean result_uncertain ;
gchar *content_type ;
content_type = g_content_type_guess( g_path_get_basename(filepath), (const guchar *) file_content, strlen(file_content), &result_uncertain) ;
if (content_type && source_language_manager) {
source_language = gtk_source_language_manager_guess_language(source_language_manager, g_path_get_basename(filepath), content_type);
if (source_language) {
set_syntax_highlight_radio(gtk_source_language_get_id(source_language)) ;
gtk_source_buffer_set_language(GTK_SOURCE_BUFFER(current_editor.current_buffer), source_language) ;
g_object_set_data(G_OBJECT(current_editor.current_textview), "lang_id", (char *) gtk_source_language_get_id(source_language)) ;
}
g_free(content_type) ;
}
/** Update the notebook label tab **/
GtkWidget *notebook_tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(gui->editor_notebook), current_editor.current_notebook_page);
/** The tab contains an mimetype icon, the filename and the page closing button. **/
GList *tab_compound_list = gtk_container_get_children(GTK_CONTAINER(notebook_tab)) ;
tab_compound_list = g_list_first(tab_compound_list) ;
while (tab_compound_list->data != NULL) {
/** We iterate over the notebook tab component **/
if (g_object_get_data(G_OBJECT(tab_compound_list->data), "tab_filename_widget")) {
/** Set the new filename in the tab. **/
gtk_label_set_text(GTK_LABEL(tab_compound_list->data), g_path_get_basename(filepath)) ;
}
if (g_object_get_data(G_OBJECT(tab_compound_list->data), "tab_icon") && source_language) {
uint8_t c ;
for ( c=0 ; ; c++) {
if (gtk_source_language_get_mime_types(source_language) == NULL) {
break ;
}
char *mimetype = gtk_source_language_get_mime_types(source_language)[c] ;
if (mimetype == NULL) {
/** don't find an specific mimetype for this new file extension use default icon. **/
g_object_set(G_OBJECT(tab_compound_list->data),"file", PATH_TO_MIMETYPE_ICON "unknown.png", NULL) ;
break ;
}
/** We search for an image filename ending with the corresponding mimetype: **/
char *ptr = strchr(mimetype, '/') ;
if (ptr != NULL) {
/** Simply pointer arithmetic to exchange the '/' (used in mimetypes) and the '-' (used in the images names) character **/
mimetype[ptr - mimetype] = '-' ;
gchar *filepath = g_strdup_printf("%s%s.png", PATH_TO_MIMETYPE_ICON, mimetype) ;
if ( g_file_test(filepath, G_FILE_TEST_EXISTS) ) {
/** We found an corresponding image for this mimetype. **/
g_object_set(G_OBJECT(tab_compound_list->data),"file", filepath, NULL) ;
free(filepath) ;
break ;
}
free(filepath) ;
}
}
}
if (tab_compound_list->next == NULL) {
break ;
}
tab_compound_list = tab_compound_list->next ;
}
g_free(file_content) ;
/** Storing filepath for further saving operations. **/
g_object_set_data(G_OBJECT(current_editor.current_buffer), "filepath", filepath) ;
/** setting the base filename in the bottom bar. **/
gtk_label_set_text(GTK_LABEL(gui->bottom_bar->filename_label), g_path_get_basename(filepath)) ;
if (settings.rm_trailing_spaces) {
/** Deleting trailing spaces. **/
char *trailing_spaces_deleting ;
trailing_spaces_deleting = g_strdup_printf("sed -i 's/[[:space:]]$//' '%s'", (char *) filepath) ;
int ret ;
if ((ret = system(trailing_spaces_deleting)) == -1) {
g_warning( _("Removing trailing space failure:\n%s\n"), trailing_spaces_deleting) ;
}
free(trailing_spaces_deleting) ;
}
File_Editor *file_editor = (File_Editor *) g_object_get_data(G_OBJECT(current_editor.current_textview), "file_editor") ;
gtk_notebook_set_menu_label_text(GTK_NOTEBOOK(gui->editor_notebook), file_editor->scrolled_window, g_path_get_basename(filepath) ) ;
#ifdef RELOADING_FUNC
/** Update Last modification timestamp. **/
File_Editor *file_editor = (File_Editor *) g_object_get_data(G_OBJECT(current_editor.current_textview), "file_editor") ;
g_stat(filepath, &file_editor->file_info) ;
#endif
}
/** @NOTE: the filepath must not be free because it is set as data from the file_editor->buffer for further use. **/
gtk_widget_destroy(file_chooser);
}
/**
* gb_view_source_init:
* @: (in): A #GbViewSource.
*
* Initializes the newly created #GbViewSource instance.
*/
static void
gb_view_source_init (GbViewSource *source)
{
GbViewSourcePrivate *priv;
GtkWidget *overlay;
ENTRY;
source->priv = priv =
G_TYPE_INSTANCE_GET_PRIVATE(source,
GB_TYPE_VIEW_SOURCE,
GbViewSourcePrivate);
g_object_set(source,
"icon-name", GTK_STOCK_FILE,
"name", _("Unsaved Document"),
NULL);
priv->buffer = gtk_source_buffer_new(NULL);
g_signal_connect_swapped(priv->buffer,
"notify::cursor-position",
G_CALLBACK(gb_view_source_notify_cursor),
source);
g_signal_connect_swapped(priv->buffer, "modified-changed",
G_CALLBACK(gb_view_source_buffer_modified_changed),
source);
overlay = g_object_new(GTK_TYPE_OVERLAY,
"visible", TRUE,
NULL);
g_signal_connect(overlay, "get-child-position",
G_CALLBACK(gb_view_source_position_progress),
NULL);
gtk_container_add_with_properties(GTK_CONTAINER(source), overlay,
"left-attach", 0,
"width", 1,
"top-attach", 0,
"height", 1,
NULL);
priv->vpaned = g_object_new(GTK_TYPE_VPANED,
"visible", TRUE,
NULL);
gtk_container_add(GTK_CONTAINER(overlay), priv->vpaned);
priv->progress = g_object_new(GB_TYPE_PROGRESS_BAR,
"visible", FALSE,
NULL);
gtk_overlay_add_overlay(GTK_OVERLAY(overlay), priv->progress);
priv->scroller1 = g_object_new(gb_get_scrolled_window_gtype(),
"expand", TRUE,
"visible", TRUE,
NULL);
gtk_container_add_with_properties(GTK_CONTAINER(priv->vpaned), priv->scroller1,
"shrink", FALSE,
"resize", TRUE,
NULL);
priv->source1 = gb_view_source_create_source_view(source);
gtk_container_add(GTK_CONTAINER(priv->scroller1), priv->source1);
{
GtkSourceLanguageManager *langs = gtk_source_language_manager_get_default();
const gchar * const * ids = gtk_source_language_manager_get_language_ids(langs);
GtkSourceLanguage *lang;
const gchar *section;
GHashTable *section_menu;
GPtrArray *sorted;
GtkWidget *controls = gb_view_get_controls(GB_VIEW(source));
GtkWidget *menu;
GtkWidget *mitem;
GtkWidget *submenu;
guint i;
section_menu = g_hash_table_new(g_str_hash, g_str_equal);
menu = gtk_menu_new();
sorted = g_ptr_array_new();
for (i = 0; ids[i]; i++) {
lang = gtk_source_language_manager_get_language(langs, ids[i]);
g_ptr_array_add(sorted, lang);
}
g_ptr_array_sort(sorted, lang_sort_func);
for (i = 0; i < sorted->len; i++) {
lang = g_ptr_array_index(sorted, i);
section = gtk_source_language_get_section(lang);
if (!(submenu = g_hash_table_lookup(section_menu, section))) {
submenu = gtk_menu_new();
mitem = g_object_new(GTK_TYPE_MENU_ITEM,
"label", section,
"submenu", submenu,
"visible", TRUE,
NULL);
gtk_container_add(GTK_CONTAINER(menu), mitem);
g_hash_table_insert(section_menu, (gchar*)section, submenu);
}
mitem = g_object_new(GTK_TYPE_MENU_ITEM,
"label", gtk_source_language_get_name(lang),
"visible", TRUE,
NULL);
g_signal_connect_swapped(mitem, "activate",
G_CALLBACK(gb_view_source_lang_activate),
source);
g_object_set_data(G_OBJECT(mitem), "language-id",
(gchar *)gtk_source_language_get_id(lang));
gtk_container_add(GTK_CONTAINER(submenu), mitem);
}
g_ptr_array_free(sorted, TRUE);
priv->lang_combo = g_object_new(GB_TYPE_MENU_BUTTON,
"hexpand", FALSE,
"label", "",
"menu", menu,
"tooltip-text", _("Set source language."),
"visible", TRUE,
NULL);
gb_widget_shrink_font(
gb_menu_button_get_label_widget(
GB_MENU_BUTTON(priv->lang_combo)));
gtk_style_context_add_class(gtk_widget_get_style_context(priv->lang_combo),
GB_STYLE_CLASS_TOP_BAR);
gtk_container_add_with_properties(GTK_CONTAINER(controls), priv->lang_combo,
"expand", FALSE,
NULL);
g_hash_table_unref(section_menu);
}
{
GtkWidget *controls = gb_view_get_controls(GB_VIEW(source));
GtkWidget *b;
GtkWidget *item;
GtkWidget *menu;
GtkWidget *group = NULL;
gboolean active;
gchar *str;
int tabs[] = { 2, 3, 4, 5, 8, 0 };
int i;
b = g_object_new(GB_TYPE_MENU_BUTTON,
"hexpand", FALSE,
"label", "4",
"tooltip-text", _("Set tab-character width."),
"visible", TRUE,
"width-request", 45,
NULL);
menu = gtk_menu_new();
for (i = 0; tabs[i]; i++) {
str = g_strdup_printf("%d", tabs[i]);
item = g_object_new(GTK_TYPE_RADIO_MENU_ITEM,
"group", group,
"label", str,
"visible", TRUE,
NULL);
if (!group) {
group = item;
}
active = (tabs[i] == gtk_source_view_get_tab_width(
GTK_SOURCE_VIEW(priv->source1)));
g_object_set(item, "active", active, NULL);
if (active) {
g_object_set(b, "label", str, NULL);
}
g_signal_connect(item, "activate",
G_CALLBACK(gb_view_source_tab_size_activate),
source);
gtk_container_add(GTK_CONTAINER(menu), item);
g_free(str);
}
g_object_set(b, "menu", menu, NULL);
item = g_object_new(GTK_TYPE_SEPARATOR_MENU_ITEM,
"visible", TRUE,
NULL);
gtk_container_add(GTK_CONTAINER(menu), item);
item = g_object_new(GTK_TYPE_CHECK_MENU_ITEM,
"active", TRUE,
"label", _("Use Spaces"),
"visible", TRUE,
NULL);
g_signal_connect(item, "toggled",
G_CALLBACK(gb_view_source_spaces_toggled),
source);
gtk_container_add(GTK_CONTAINER(menu), item);
gb_widget_shrink_font(gb_menu_button_get_label_widget(GB_MENU_BUTTON(b)));
gtk_style_context_add_class(gtk_widget_get_style_context(b),
GB_STYLE_CLASS_TOP_BAR);
gtk_container_add_with_properties(GTK_CONTAINER(controls), b,
"expand", FALSE,
NULL);
priv->size_combo = b;
}
{
GtkWidget *controls = gb_view_get_controls(GB_VIEW(source));
GtkWidget *img;
GtkWidget *b;
img = g_object_new(GTK_TYPE_IMAGE,
"icon-name", "gb-split",
"icon-size", GTK_ICON_SIZE_MENU,
"visible", TRUE,
NULL);
b = g_object_new(GTK_TYPE_TOGGLE_BUTTON,
"child", img,
"tooltip-text", _("Split the editor into two views."),
"visible", TRUE,
NULL);
gtk_style_context_add_class(gtk_widget_get_style_context(b),
GB_STYLE_CLASS_TOP_BAR);
gtk_container_add_with_properties(GTK_CONTAINER(controls), b,
"expand", FALSE,
NULL);
g_signal_connect(b, "toggled",
G_CALLBACK(split_toggled),
source);
}
{
GtkWidget *hbox;
GtkWidget *vp;
GtkWidget *c;
hbox = g_object_new(GTK_TYPE_HBOX,
"height-request", 30,
"visible", TRUE,
NULL);
gtk_container_add_with_properties(GTK_CONTAINER(source), hbox,
"height", 1,
"left-attach", 0,
"top-attach", 1,
"width", 1,
NULL);
gtk_container_add(GTK_CONTAINER(hbox),
(c = g_object_new(GTK_TYPE_COMBO_BOX,
"visible", TRUE,
NULL)));
gtk_style_context_add_class(gtk_widget_get_style_context(c),
GB_STYLE_CLASS_BOTTOM_BAR);
vp = g_object_new(GTK_TYPE_VIEWPORT,
"visible", TRUE,
NULL);
gtk_style_context_add_class(gtk_widget_get_style_context(vp),
GB_STYLE_CLASS_BOTTOM_BAR);
gtk_container_add_with_properties(GTK_CONTAINER(hbox), vp,
"expand", FALSE,
"fill", TRUE,
NULL);
priv->pos_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Line 1, Column 1"),
"visible", TRUE,
"xalign", 1.0f,
"xpad", 6,
NULL);
gb_widget_shrink_font(priv->pos_label);
gtk_container_add(GTK_CONTAINER(vp), priv->pos_label);
}
priv->theme_handler =
g_signal_connect_swapped(gtk_settings_get_default(),
"notify::gtk-application-prefer-dark-theme",
G_CALLBACK(gb_view_source_update_style),
source);
EXIT;
}
static void
populate_cache (EggTaskCache *cache,
gconstpointer key,
GTask *task,
gpointer user_data)
{
IdeGettextDiagnosticProvider *self = user_data;
g_autoptr(IdeUnsavedFile) unsaved_file = NULL;
g_autoptr(GSubprocess) subprocess = NULL;
GtkSourceLanguage *language;
const gchar *language_id;
const gchar *xgettext_lang;
const gchar *temp_path;
TranslationUnit *unit;
IdeFile *file = (IdeFile *)key;
GCancellable *cancellable;
GError *error = NULL;
GPtrArray *args;
g_assert (EGG_IS_TASK_CACHE (cache));
g_assert (IDE_IS_FILE (file));
g_assert (IDE_IS_GETTEXT_DIAGNOSTIC_PROVIDER (self));
cancellable = g_task_get_cancellable (task);
if (NULL == (unsaved_file = get_unsaved_file (self, file)))
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_NOT_FOUND,
"Failed to locate file contents");
return;
}
if (NULL == (language = ide_file_get_language (file)) ||
NULL == (language_id = gtk_source_language_get_id (language)) ||
NULL == (xgettext_lang = id_to_xgettext_language (language_id)))
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_NOT_SUPPORTED,
"Failed to determine language type");
return;
}
if (!ide_unsaved_file_persist (unsaved_file, cancellable, &error))
{
g_task_return_error (task, error);
return;
}
temp_path = ide_unsaved_file_get_temp_path (unsaved_file);
g_assert (temp_path != NULL);
args = g_ptr_array_new ();
g_ptr_array_add (args, "xgettext");
g_ptr_array_add (args, "--check=ellipsis-unicode");
g_ptr_array_add (args, "--check=quote-unicode");
g_ptr_array_add (args, "--check=space-ellipsis");
g_ptr_array_add (args, "-k_");
g_ptr_array_add (args, "-kN_");
g_ptr_array_add (args, "-L");
g_ptr_array_add (args, (gchar *)xgettext_lang);
g_ptr_array_add (args, "-o");
g_ptr_array_add (args, "-");
g_ptr_array_add (args, (gchar *)temp_path);
g_ptr_array_add (args, NULL);
#ifdef IDE_ENABLE_TRACE
{
g_autofree gchar *str = NULL;
str = g_strjoinv (" ", (gchar **)args->pdata);
IDE_TRACE_MSG ("Launching '%s'", str);
}
#endif
subprocess = g_subprocess_newv ((const gchar * const *)args->pdata,
G_SUBPROCESS_FLAGS_STDIN_PIPE
| G_SUBPROCESS_FLAGS_STDOUT_PIPE
| G_SUBPROCESS_FLAGS_STDERR_PIPE,
&error);
g_ptr_array_free (args, TRUE);
if (subprocess == NULL)
{
g_task_return_error (task, error);
return;
}
unit = g_slice_new0 (TranslationUnit);
unit->file = g_object_ref (file);
unit->unsaved_file = ide_unsaved_file_ref (unsaved_file);
g_task_set_task_data (task, unit, (GDestroyNotify)translation_unit_free);
g_subprocess_wait_async (subprocess,
cancellable,
subprocess_wait_cb,
g_object_ref (task));
}
Gobby::MenuManager::MenuManager(GtkSourceLanguageManager* language_manager)
{
Glib::RefPtr<Gtk::Builder> builder =
Gtk::Builder::create_from_resource(
"/de/0x539/gobby/ui/menu.ui");
m_app_menu = Glib::RefPtr<Gio::Menu>::cast_dynamic(
builder->get_object("appmenu"));
m_menu = Glib::RefPtr<Gio::Menu>::cast_dynamic(
builder->get_object("winmenu"));
Glib::RefPtr<Gio::Menu> highlight_mode_menu = get_highlight_mode_menu();
const gchar* const* language_ids =
gtk_source_language_manager_get_language_ids(
language_manager);
if(language_ids != NULL)
{
typedef std::list<GtkSourceLanguage*> LanguageList;
typedef std::map<std::string, LanguageList> LanguageMap;
LanguageMap languages;
for(const gchar* const* id = language_ids; *id != NULL; ++id)
{
GtkSourceLanguage* language =
gtk_source_language_manager_get_language(
language_manager, *id);
if(gtk_source_language_get_hidden(language)) continue;
const std::string section =
gtk_source_language_get_section(language);
languages[section].push_back(language);
}
for(LanguageMap::iterator iter = languages.begin();
iter != languages.end(); ++iter)
{
Glib::RefPtr<Gio::Menu> submenu(Gio::Menu::create());
LanguageList& list = iter->second;
list.sort(language_sort_func);
for(LanguageList::const_iterator liter = list.begin();
liter != list.end(); ++liter)
{
GtkSourceLanguage* language = *liter;
const std::string id =
gtk_source_language_get_id(language);
const std::string name =
gtk_source_language_get_name(language);
Glib::RefPtr<Gio::MenuItem> item(
Gio::MenuItem::create(
name, Glib::ustring::compose(
"win.highlight-mode"
"('%1')", id)));
submenu->append_item(item);
}
highlight_mode_menu->append_submenu(
iter->first, submenu);
}
}
}
