static void
parse_language_with_id (ParserState *parser_state,
gchar *lang_id)
{
GtkSourceLanguageManager *lm;
GtkSourceLanguage *imported_language;
g_return_if_fail (parser_state->error == NULL);
lm = _gtk_source_language_get_language_manager (parser_state->language);
imported_language = gtk_source_language_manager_get_language (lm, lang_id);
if (imported_language == NULL)
{
g_set_error (&parser_state->error,
PARSER_ERROR,
PARSER_ERROR_WRONG_ID,
"unable to resolve language '%s'",
lang_id);
}
else
{
file_parse (imported_language->priv->lang_file_name,
parser_state->language,
parser_state->ctx_data,
parser_state->defined_regexes,
parser_state->styles_mapping,
parser_state->loaded_lang_ids,
parser_state->replacements,
&parser_state->error);
}
}
static gboolean
gb_vim_set_filetype (GtkSourceView *source_view,
const gchar *key,
const gchar *value,
GError **error)
{
GtkSourceLanguageManager *manager;
GtkSourceLanguage *language;
GtkTextBuffer *buffer;
if (0 == g_strcmp0 (value, "cs"))
value = "c-sharp";
else if (0 == g_strcmp0 (value, "xhmtl"))
value = "html";
else if (0 == g_strcmp0 (value, "javascript"))
value = "js";
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view));
manager = gtk_source_language_manager_get_default ();
language = gtk_source_language_manager_get_language (manager, value);
if (language == NULL)
{
g_set_error (error,
GB_VIM_ERROR,
GB_VIM_ERROR_UNKNOWN_OPTION,
_("Cannot find language '%s'"),
value);
return FALSE;
}
g_object_set (buffer, "language", language, NULL);
return TRUE;
}
static GtkWidget *
setup_editor (AppData *data)
{
GtkSourceBuffer *buffer;
GtkSourceLanguageManager *manager;
GtkSourceLanguage *lang;
GtkWidget *view;
manager = gtk_source_language_manager_get_default ();
lang = gtk_source_language_manager_get_language (manager, "hip");
buffer = gtk_source_buffer_new_with_language (lang);
view = gtk_source_view_new_with_buffer (buffer);
gtk_widget_modify_font (view,
pango_font_description_from_string ("monospace"));
g_object_set (view, "auto-indent", TRUE,
"indent-on-tab", TRUE,
"indent-width", 8,
"show-line-numbers", TRUE,
NULL);
/* Make it pretty ;) */
gtk_source_buffer_set_style_scheme (buffer,
gtk_source_style_scheme_manager_get_scheme (
gtk_source_style_scheme_manager_get_default (), "tango"));
gtk_widget_show (view);
g_object_unref (buffer);
data->text_buffer = GTK_TEXT_BUFFER (buffer);
return view;
}
static void
gb_view_source_lang_activate (GbViewSource *source,
GtkMenuItem *menu_item)
{
GbViewSourcePrivate *priv;
GtkSourceLanguageManager *lm;
GtkSourceLanguage *lang;
const gchar *lang_id;
ENTRY;
g_return_if_fail(GB_IS_VIEW_SOURCE(source));
g_return_if_fail(GTK_IS_MENU_ITEM(menu_item));
priv = source->priv;
if ((lang_id = g_object_get_data(G_OBJECT(menu_item), "language-id"))) {
lm = gtk_source_language_manager_get_default();
lang = gtk_source_language_manager_get_language(lm, lang_id);
gtk_source_buffer_set_language(priv->buffer, lang);
gb_menu_button_set_label(GB_MENU_BUTTON(priv->lang_combo),
gtk_source_language_get_name(lang));
}
EXIT;
}
GSList *
cedit_language_manager_list_languages_sorted (GtkSourceLanguageManager *lm,
gboolean include_hidden)
{
GSList *languages = NULL;
const gchar * const *ids;
ids = gtk_source_language_manager_get_language_ids (lm);
if (ids == NULL)
return NULL;
while (*ids != NULL)
{
GtkSourceLanguage *lang;
lang = gtk_source_language_manager_get_language (lm, *ids);
#if GTK_CHECK_VERSION (3, 0, 0)
g_return_val_if_fail (GTK_SOURCE_IS_LANGUAGE (lang), NULL);
#else
g_return_val_if_fail (GTK_IS_SOURCE_LANGUAGE (lang), NULL);
#endif
++ids;
if (include_hidden || !gtk_source_language_get_hidden (lang))
{
languages = g_slist_prepend (languages, lang);
}
}
return g_slist_sort (languages, (GCompareFunc)language_compare);
}
static void
ide_preferences_builtin_register_languages (IdePreferences *preferences)
{
GtkSourceLanguageManager *manager;
const gchar * const *language_ids;
g_autoptr(GHashTable) sections = NULL;
guint section_count = 0;
gint i;
sections = g_hash_table_new (g_str_hash, g_str_equal);
ide_preferences_add_page (preferences, "languages", _("Programming Languages"), 200);
manager = gtk_source_language_manager_get_default ();
language_ids = gtk_source_language_manager_get_language_ids (manager);
for (i = 0; language_ids [i]; i++)
{
IdePreferencesLanguageRow *row;
GtkSourceLanguage *language;
const gchar *name;
const gchar *section;
if (ide_str_equal0 (language_ids [i], "def"))
continue;
language = gtk_source_language_manager_get_language (manager, language_ids [i]);
name = gtk_source_language_get_name (language);
section = gtk_source_language_get_section (language);
if (!g_hash_table_contains (sections, section))
{
ide_preferences_add_list_group (preferences, "languages",
section, section, section_count++);
g_hash_table_insert (sections, (gchar *)section, NULL);
}
row = g_object_new (IDE_TYPE_PREFERENCES_LANGUAGE_ROW,
"id", language_ids [i],
"title", name,
"visible", TRUE,
NULL);
ide_preferences_add_custom (preferences, "languages", section, GTK_WIDGET (row), NULL, 0);
}
ide_preferences_add_page (preferences, "languages.id", NULL, 0);
ide_preferences_add_list_group (preferences, "languages.id", "basic", NULL, 0);
ide_preferences_add_switch (preferences, "languages.id", "basic", "org.gnome.builder.editor.language", "trim-trailing-whitespace", "/org/gnome/builder/editor/language/{id}/", NULL, _("Trim trailing whitespace"), _("Upon saving, trailing whitespace from modified lines will be trimmed."), NULL, 10);
ide_preferences_add_switch (preferences, "languages.id", "basic", "org.gnome.builder.editor.language", "overwrite-braces", "/org/gnome/builder/editor/language/{id}/", NULL, _("Overwrite Braces"), _("Overwrite closing braces"), NULL, 20);
ide_preferences_add_list_group (preferences, "languages.id", "margin", _("Margins"), 0);
ide_preferences_add_radio (preferences, "languages.id", "margin", "org.gnome.builder.editor.language", "show-right-margin", "/org/gnome/builder/editor/language/{id}/", NULL, _("Show right margin"), NULL, NULL, 0);
ide_preferences_add_spin_button (preferences, "languages.id", "margin", "org.gnome.builder.editor.language", "right-margin-position", "/org/gnome/builder/editor/language/{id}/", _("Right margin position"), _("Position in spaces for the right margin"), NULL, 10);
ide_preferences_add_list_group (preferences, "languages.id", "indentation", _("Indentation"), 100);
ide_preferences_add_spin_button (preferences, "languages.id", "indentation", "org.gnome.builder.editor.language", "tab-width", "/org/gnome/builder/editor/language/{id}/", _("Tab width"), _("Width of a tab character in spaces"), NULL, 10);
ide_preferences_add_radio (preferences, "languages.id", "indentation", "org.gnome.builder.editor.language", "insert-spaces-instead-of-tabs", "/org/gnome/builder/editor/language/{id}/", NULL, _("Insert spaces instead of tabs"), _("Prefer spaces over use of tabs"), NULL, 20);
ide_preferences_add_radio (preferences, "languages.id", "indentation", "org.gnome.builder.editor.language", "auto-indent", "/org/gnome/builder/editor/language/{id}/", NULL, _("Automatically indent"), _("Indent source code as you type"), NULL, 30);
}
SourceView::SourceView (const std::string& language, bool readOnly)
{
// Set the search path to the language and style files
gchar* directories[2];
std::string langFilesDir = GlobalRegistry().get(RKEY_APP_PATH) + "sourceviewer/";
directories[0] = const_cast<gchar*> (langFilesDir.c_str()); // stupid GtkSourceLanguageManager is expecting non-const gchar* pointer...
directories[1] = NULL;
GtkSourceStyleSchemeManager* styleSchemeManager = gtk_source_style_scheme_manager_get_default();
gtk_source_style_scheme_manager_set_search_path(styleSchemeManager, directories);
gtk_source_style_scheme_manager_force_rescan(styleSchemeManager);
_langManager = gtk_source_language_manager_new();
gtk_source_language_manager_set_search_path(_langManager, directories);
GtkSourceLanguage* lang = gtk_source_language_manager_get_language(_langManager, language.c_str());
if (lang == NULL) {
gtkutil::errorDialog(_("Cannot find language for source viewer"));
g_error("SourceView: Cannot find language %s\n", language.c_str());
throw std::runtime_error("SourceView: Cannot find language");
}
// Remember the pointers to the textbuffers
_buffer = gtk_source_buffer_new_with_language(lang);
gtk_source_buffer_set_highlight_syntax(_buffer, TRUE);
_view = GTK_SOURCE_VIEW(gtk_source_view_new_with_buffer(_buffer));
gtk_widget_set_size_request(GTK_WIDGET(_view), 0, -1); // allow shrinking
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(_view), GTK_WRAP_NONE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(_view), readOnly ? FALSE : TRUE);
gtk_source_view_set_show_line_numbers(_view, TRUE);
gtk_source_view_set_auto_indent(_view, TRUE);
// Use a fixed width font
PangoFontDescription* fontDesc = pango_font_description_from_string("Monospace");
if (fontDesc != NULL) {
gtk_widget_modify_font(GTK_WIDGET(_view), fontDesc);
}
// Use a tab size of 4
gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(_view), 4);
g_signal_connect(G_OBJECT(_view), "key_press_event", G_CALLBACK(escape_clear_focus_widget), 0);
_widget = gtkutil::ScrolledFrame(GTK_WIDGET(_view));
}
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;
}
void
gui_editor_show (GUIEditor * self)
{
gtk_widget_show (GTK_WIDGET (self->widget));
gtk_widget_show (GTK_WIDGET (self->scroll));
gtk_source_view_set_show_line_numbers (GTK_SOURCE_VIEW(self->widget), TRUE);
self->language = gtk_source_language_manager_get_language(self->lang_manager,"8085_asm");
if (self->language != NULL){
gtk_source_buffer_set_language (self->buffer, self->language);
gtk_source_buffer_set_style_scheme (self->buffer, gtk_source_style_scheme_manager_get_scheme(self->style_scheme_manager,"classic"));
gtk_source_buffer_set_highlight_syntax (self->buffer, TRUE);
}
self->mark = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER(self->buffer));
gtk_source_view_set_show_line_marks (GTK_SOURCE_VIEW(self->widget), TRUE);
}
void
_gtk_source_language_define_language_styles (GtkSourceLanguage *lang)
{
static const gchar *alias[][2] = {
{"Base-N Integer", "def:base-n-integer"},
{"Character", "def:character"},
{"Comment", "def:comment"},
{"Function", "def:function"},
{"Decimal", "def:decimal"},
{"Floating Point", "def:floating-point"},
{"Keyword", "def:keyword"},
{"Preprocessor", "def:preprocessor"},
{"String", "def:string"},
{"Specials", "def:specials"},
{"Data Type", "def:type"},
{NULL, NULL}};
gint i = 0;
GtkSourceLanguageManager *lm;
GtkSourceLanguage *def_lang;
while (alias[i][0] != NULL)
{
GtkSourceStyleInfo *info;
info = _gtk_source_style_info_new (alias[i][0], alias[i][1]);
g_hash_table_insert (lang->priv->styles,
g_strdup (alias[i][0]),
info);
++i;
}
/* We translate String to def:string, but def:string is mapped-to
* def:constant in def.lang, so we got to take style mappings from def.lang */
lm = _gtk_source_language_get_language_manager (lang);
def_lang = gtk_source_language_manager_get_language (lm, "def");
if (def_lang != NULL)
{
force_styles (def_lang);
g_hash_table_foreach (def_lang->priv->styles,
(GHFunc) copy_style_info,
lang->priv->styles);
}
}
GtkSourceLanguage *
gitg_utils_get_language(gchar const *content_type)
{
if (!gitg_utils_can_display_content_type(content_type))
return NULL;
gchar *mime = g_content_type_get_mime_type(content_type);
GtkSourceLanguageManager *manager = gtk_source_language_manager_get_default();
gchar const * const *ids = gtk_source_language_manager_get_language_ids(manager);
gchar const *ptr;
GtkSourceLanguage *ret;
while ((ptr = *ids++))
{
ret = gtk_source_language_manager_get_language(manager, ptr);
gchar **mime_types = gtk_source_language_get_mime_types(ret);
gchar **types = mime_types;
gchar *m;
if (types)
{
while ((m = *types++))
{
if (strcmp(mime, m) == 0)
{
g_free(mime);
g_strfreev(mime_types);
return ret;
}
}
g_strfreev(mime_types);
}
ret = NULL;
}
g_free(mime);
return NULL;
}
static void
ide_editor_view_actions_language (GSimpleAction *action,
GVariant *variant,
gpointer user_data)
{
IdeEditorView *self = user_data;
GtkSourceLanguageManager *manager;
GtkSourceLanguage *language;
GtkSourceBuffer *buffer;
const gchar *name;
g_assert (IDE_IS_EDITOR_VIEW (self));
manager = gtk_source_language_manager_get_default ();
name = g_variant_get_string (variant, NULL);
buffer = GTK_SOURCE_BUFFER (self->document);
if (name != NULL)
{
language = gtk_source_language_manager_get_language (manager, name);
gtk_source_buffer_set_language (buffer, language);
ide_editor_view_actions_update (self);
}
}
void
modeline_parser_apply_modeline (GtkSourceView *view)
{
ModelineOptions options;
GtkTextBuffer *buffer;
GtkTextIter iter, liter;
gint line_count;
GSettings *settings;
options.language_id = NULL;
options.set = MODELINE_SET_NONE;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
gtk_text_buffer_get_start_iter (buffer, &iter);
line_count = gtk_text_buffer_get_line_count (buffer);
/* Parse the modelines on the 10 first lines... */
while ((gtk_text_iter_get_line (&iter) < 10) &&
!gtk_text_iter_is_end (&iter))
{
gchar *line;
liter = iter;
gtk_text_iter_forward_to_line_end (&iter);
line = gtk_text_buffer_get_text (buffer, &liter, &iter, TRUE);
parse_modeline (line,
1 + gtk_text_iter_get_line (&iter),
line_count,
&options);
gtk_text_iter_forward_line (&iter);
g_free (line);
}
/* ...and on the 10 last ones (modelines are not allowed in between) */
if (!gtk_text_iter_is_end (&iter))
{
gint cur_line;
guint remaining_lines;
/* we are on the 11th line (count from 0) */
cur_line = gtk_text_iter_get_line (&iter);
/* g_assert (10 == cur_line); */
remaining_lines = line_count - cur_line - 1;
if (remaining_lines > 10)
{
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_iter_backward_lines (&iter, 9);
}
}
while (!gtk_text_iter_is_end (&iter))
{
gchar *line;
liter = iter;
gtk_text_iter_forward_to_line_end (&iter);
line = gtk_text_buffer_get_text (buffer, &liter, &iter, TRUE);
parse_modeline (line,
1 + gtk_text_iter_get_line (&iter),
line_count,
&options);
gtk_text_iter_forward_line (&iter);
g_free (line);
}
/* Try to set language */
if (has_option (&options, MODELINE_SET_LANGUAGE) && options.language_id)
{
if (g_ascii_strcasecmp (options.language_id, "text") == 0)
{
gedit_document_set_language (GEDIT_DOCUMENT (buffer),
NULL);
}
else
{
GtkSourceLanguageManager *manager;
GtkSourceLanguage *language;
manager = gedit_get_language_manager ();
language = gtk_source_language_manager_get_language
(manager, options.language_id);
if (language != NULL)
{
gedit_document_set_language (GEDIT_DOCUMENT (buffer),
language);
}
else
{
gedit_debug_message (DEBUG_PLUGINS,
"Unknown language `%s'",
options.language_id);
}
}
}
ModelineOptions *previous = g_object_get_data (G_OBJECT (buffer),
MODELINE_OPTIONS_DATA_KEY);
settings = g_settings_new ("org.gnome.gedit.preferences.editor");
/* Apply the options we got from modelines and restore defaults if
we set them before */
if (has_option (&options, MODELINE_SET_INSERT_SPACES))
{
gtk_source_view_set_insert_spaces_instead_of_tabs
(view, options.insert_spaces);
}
else if (check_previous (view, previous, MODELINE_SET_INSERT_SPACES))
{
gboolean insert_spaces;
insert_spaces = g_settings_get_boolean (settings, GEDIT_SETTINGS_INSERT_SPACES);
gtk_source_view_set_insert_spaces_instead_of_tabs (view, insert_spaces);
}
if (has_option (&options, MODELINE_SET_TAB_WIDTH))
{
gtk_source_view_set_tab_width (view, options.tab_width);
}
else if (check_previous (view, previous, MODELINE_SET_TAB_WIDTH))
{
guint tab_width;
g_settings_get (settings, GEDIT_SETTINGS_TABS_SIZE, "u", &tab_width);
gtk_source_view_set_tab_width (view, tab_width);
}
if (has_option (&options, MODELINE_SET_INDENT_WIDTH))
{
gtk_source_view_set_indent_width (view, options.indent_width);
}
else if (check_previous (view, previous, MODELINE_SET_INDENT_WIDTH))
{
gtk_source_view_set_indent_width (view, -1);
}
if (has_option (&options, MODELINE_SET_WRAP_MODE))
{
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), options.wrap_mode);
}
else if (check_previous (view, previous, MODELINE_SET_WRAP_MODE))
{
GtkWrapMode mode;
mode = g_settings_get_enum (settings,
GEDIT_SETTINGS_WRAP_MODE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), mode);
}
if (has_option (&options, MODELINE_SET_RIGHT_MARGIN_POSITION))
{
gtk_source_view_set_right_margin_position (view, options.right_margin_position);
}
else if (check_previous (view, previous, MODELINE_SET_RIGHT_MARGIN_POSITION))
{
guint right_margin_pos;
g_settings_get (settings, GEDIT_SETTINGS_RIGHT_MARGIN_POSITION, "u",
&right_margin_pos);
gtk_source_view_set_right_margin_position (view,
right_margin_pos);
}
if (has_option (&options, MODELINE_SET_SHOW_RIGHT_MARGIN))
{
gtk_source_view_set_show_right_margin (view, options.display_right_margin);
}
else if (check_previous (view, previous, MODELINE_SET_SHOW_RIGHT_MARGIN))
{
gboolean display_right_margin;
display_right_margin = g_settings_get_boolean (settings,
GEDIT_SETTINGS_DISPLAY_RIGHT_MARGIN);
gtk_source_view_set_show_right_margin (view, display_right_margin);
}
if (previous)
{
g_free (previous->language_id);
*previous = options;
previous->language_id = g_strdup (options.language_id);
}
else
{
previous = g_slice_new (ModelineOptions);
*previous = options;
previous->language_id = g_strdup (options.language_id);
g_object_set_data_full (G_OBJECT (buffer),
MODELINE_OPTIONS_DATA_KEY,
previous,
(GDestroyNotify)free_modeline_options);
}
g_object_unref (settings);
g_free (options.language_id);
}
NetlistEditor *
netlist_editor_new (GtkSourceBuffer * textbuffer) {
gchar** lang_files;
NetlistEditor * nle;
GladeXML * gui;
GtkWidget * toplevel;
GtkScrolledWindow * scroll;
GtkSourceView * source_view;
GtkSourceLanguageManager * lm;
GtkButton * save, * sim, * close, * print;
GtkSourceLanguage *lang=NULL;
const GSList *list;
if (!textbuffer)
return NULL;
nle = NETLIST_EDITOR (g_object_new (netlist_editor_get_type (), NULL));
netlist_editor_get_config (nle);
if (!g_file_test (OREGANO_GLADEDIR "/view-netlist.glade2", G_FILE_TEST_EXISTS)) {
gchar *msg;
msg = g_strdup_printf (
_("The file %s could not be found. You might need to reinstall Oregano to fix this."),
OREGANO_GLADEDIR "/view-netlist.glade2");
oregano_error_with_title (_("Could not create the netlist dialog"), msg);
g_free (msg);
return NULL;
}
gui = glade_xml_new (OREGANO_GLADEDIR "/view-netlist.glade2", NULL, NULL);
toplevel = glade_xml_get_widget (gui, "toplevel");
gtk_window_set_default_size (GTK_WINDOW (toplevel), 800, 600);
gtk_window_set_title (GTK_WINDOW (toplevel), "Net List Editor\n");
scroll = GTK_SCROLLED_WINDOW (glade_xml_get_widget (gui, "netlist-scrolled-window"));
source_view = GTK_SOURCE_VIEW (gtk_source_view_new ());
lm = GTK_SOURCE_LANGUAGE_MANAGER (gtk_source_language_manager_new ());
setup_language_manager_path (lm);
g_object_set_data_full (G_OBJECT (source_view), "language-manager",
lm, (GDestroyNotify) g_object_unref);
lang = gtk_source_language_manager_get_language (lm, "netlist");
if (lang) {
gtk_source_buffer_set_language (GTK_SOURCE_BUFFER (textbuffer), lang);
gtk_source_buffer_set_highlight_syntax (GTK_SOURCE_BUFFER (textbuffer), TRUE);
gtk_source_buffer_set_highlight_matching_brackets (GTK_SOURCE_BUFFER (textbuffer), TRUE);
} else {
g_warning ("Can't load netlist.lang in %s", OREGANO_LANGDIR "/netlist.lang");
}
gtk_text_view_set_editable (GTK_TEXT_VIEW (source_view), TRUE);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (source_view), GTK_TEXT_BUFFER (textbuffer));
gtk_container_add (GTK_CONTAINER (scroll), GTK_WIDGET (source_view));
close = GTK_BUTTON (glade_xml_get_widget (gui, "btn_close"));
g_signal_connect_swapped (G_OBJECT (close), "clicked", G_CALLBACK (g_object_unref), G_OBJECT (nle));
save = GTK_BUTTON (glade_xml_get_widget (gui, "btn_save"));
g_signal_connect (G_OBJECT (save), "clicked", G_CALLBACK (netlist_editor_save), nle);
sim = GTK_BUTTON (glade_xml_get_widget (gui, "btn_sim"));
g_signal_connect (G_OBJECT (sim), "clicked", G_CALLBACK (netlist_editor_simulate), nle);
print = GTK_BUTTON (glade_xml_get_widget (gui, "btn_print"));
g_signal_connect (G_OBJECT (print), "clicked", G_CALLBACK (netlist_editor_print), nle);
/*
* Set tab, fonts, wrap mode, colors, etc. according
* to preferences
*/
nle->priv->lm = lm;
nle->priv->view = GTK_TEXT_VIEW (source_view);
nle->priv->toplevel = GTK_WINDOW (toplevel);
nle->priv->sim = sim;
nle->priv->save = save;
nle->priv->close = close;
nle->priv->buffer = textbuffer;
gtk_widget_show_all (GTK_WIDGET (toplevel));
return nle;
}
static gboolean
add_ref (ParserState *parser_state,
const gchar *ref,
GtkSourceContextRefOptions options,
const gchar *style,
GError **error)
{
gboolean all = FALSE;
gchar *ref_id;
gchar *lang_id = NULL;
GError *tmp_error = NULL;
/* Return if an error is already set */
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
if (id_is_decorated (ref, &lang_id))
{
if (!lang_id_is_already_loaded (parser_state, lang_id))
{
GtkSourceLanguageManager *lm;
GtkSourceLanguage *imported_language;
lm = _gtk_source_language_get_language_manager (parser_state->language);
imported_language = gtk_source_language_manager_get_language (lm, lang_id);
if (imported_language == NULL)
{
g_set_error (&tmp_error,
PARSER_ERROR,
PARSER_ERROR_WRONG_ID,
"unable to resolve language '%s' in ref '%s'",
lang_id, ref);
}
else
{
file_parse (imported_language->priv->lang_file_name,
parser_state->language,
parser_state->ctx_data,
parser_state->defined_regexes,
parser_state->styles_mapping,
parser_state->loaded_lang_ids,
parser_state->replacements,
&tmp_error);
if (tmp_error != NULL)
{
GError *tmp_error2 = NULL;
g_set_error (&tmp_error2, PARSER_ERROR, tmp_error->code,
"In file '%s' referenced from '%s': %s",
imported_language->priv->lang_file_name,
parser_state->language->priv->lang_file_name,
tmp_error->message);
g_clear_error (&tmp_error);
tmp_error = tmp_error2;
}
}
}
ref_id = g_strdup (ref);
}
else
{
ref_id = decorate_id (parser_state, ref);
}
if (tmp_error == NULL && parser_state->ctx_data != NULL)
{
if (g_str_has_suffix (ref, ":*"))
{
all = TRUE;
ref_id [strlen (ref_id) - 2] = '\0';
}
if (all && (options & (GTK_SOURCE_CONTEXT_IGNORE_STYLE | GTK_SOURCE_CONTEXT_OVERRIDE_STYLE)))
{
g_set_error (&tmp_error, PARSER_ERROR,
PARSER_ERROR_WRONG_STYLE,
"style override used with wildcard context reference"
" in language '%s' in ref '%s'",
lang_id != NULL ? lang_id : parser_state->current_lang_id, ref);
}
}
if (tmp_error == NULL && parser_state->ctx_data != NULL)
{
gchar *container_id;
container_id = g_queue_peek_head (parser_state->curr_parents);
/* If the document is validated container_id is never NULL */
g_assert (container_id);
_gtk_source_context_data_add_ref (parser_state->ctx_data,
container_id,
ref_id,
options,
style,
all,
&tmp_error);
DEBUG (g_message ("appended %s in %s", ref_id, container_id));
}
g_free (lang_id);
g_free (ref_id);
if (tmp_error != NULL)
{
g_propagate_error (error, tmp_error);
return FALSE;
}
return TRUE;
}
/**
* 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;
}
void
modeline_parser_apply_modeline (GtkSourceView *view)
{
ModelineOptions options;
GtkTextBuffer *buffer;
GtkTextIter iter, liter;
gint line_count;
options.language_id = NULL;
options.set = MODELINE_SET_NONE;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
gtk_text_buffer_get_start_iter (buffer, &iter);
line_count = gtk_text_buffer_get_line_count (buffer);
/* Parse the modelines on the 10 first lines... */
while ((gtk_text_iter_get_line (&iter) < 10) &&
!gtk_text_iter_is_end (&iter))
{
gchar *line;
liter = iter;
gtk_text_iter_forward_to_line_end (&iter);
line = gtk_text_buffer_get_text (buffer, &liter, &iter, TRUE);
parse_modeline (line,
1 + gtk_text_iter_get_line (&iter),
line_count,
&options);
gtk_text_iter_forward_line (&iter);
g_free (line);
}
/* ...and on the 10 last ones (modelines are not allowed in between) */
if (!gtk_text_iter_is_end (&iter))
{
gint cur_line;
guint remaining_lines;
/* we are on the 11th line (count from 0) */
cur_line = gtk_text_iter_get_line (&iter);
/* g_assert (10 == cur_line); */
remaining_lines = line_count - cur_line - 1;
if (remaining_lines > 10)
{
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_iter_backward_lines (&iter, 9);
}
}
while (!gtk_text_iter_is_end (&iter))
{
gchar *line;
liter = iter;
gtk_text_iter_forward_to_line_end (&iter);
line = gtk_text_buffer_get_text (buffer, &liter, &iter, TRUE);
parse_modeline (line,
1 + gtk_text_iter_get_line (&iter),
line_count,
&options);
gtk_text_iter_forward_line (&iter);
g_free (line);
}
/* Try to set language */
if (has_option (&options, MODELINE_SET_LANGUAGE) && options.language_id)
{
GtkSourceLanguageManager *manager;
GtkSourceLanguage *language;
manager = pluma_get_language_manager ();
language = gtk_source_language_manager_get_language
(manager, options.language_id);
if (language != NULL)
{
gtk_source_buffer_set_language (GTK_SOURCE_BUFFER (buffer),
language);
}
}
ModelineOptions *previous = g_object_get_data (G_OBJECT (buffer),
MODELINE_OPTIONS_DATA_KEY);
/* Apply the options we got from modelines and restore defaults if
we set them before */
if (has_option (&options, MODELINE_SET_INSERT_SPACES))
{
gtk_source_view_set_insert_spaces_instead_of_tabs
(view, options.insert_spaces);
}
else if (check_previous (view, previous, MODELINE_SET_INSERT_SPACES))
{
gtk_source_view_set_insert_spaces_instead_of_tabs
(view,
pluma_prefs_manager_get_insert_spaces ());
}
if (has_option (&options, MODELINE_SET_TAB_WIDTH))
{
gtk_source_view_set_tab_width (view, options.tab_width);
}
else if (check_previous (view, previous, MODELINE_SET_TAB_WIDTH))
{
gtk_source_view_set_tab_width (view,
pluma_prefs_manager_get_tabs_size ());
}
if (has_option (&options, MODELINE_SET_INDENT_WIDTH))
{
gtk_source_view_set_indent_width (view, options.indent_width);
}
else if (check_previous (view, previous, MODELINE_SET_INDENT_WIDTH))
{
gtk_source_view_set_indent_width (view, -1);
}
if (has_option (&options, MODELINE_SET_WRAP_MODE))
{
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), options.wrap_mode);
}
else if (check_previous (view, previous, MODELINE_SET_WRAP_MODE))
{
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view),
pluma_prefs_manager_get_wrap_mode ());
}
if (has_option (&options, MODELINE_SET_RIGHT_MARGIN_POSITION))
{
gtk_source_view_set_right_margin_position (view, options.right_margin_position);
}
else if (check_previous (view, previous, MODELINE_SET_RIGHT_MARGIN_POSITION))
{
gtk_source_view_set_right_margin_position (view,
pluma_prefs_manager_get_right_margin_position ());
}
if (has_option (&options, MODELINE_SET_SHOW_RIGHT_MARGIN))
{
gtk_source_view_set_show_right_margin (view, options.display_right_margin);
}
else if (check_previous (view, previous, MODELINE_SET_SHOW_RIGHT_MARGIN))
{
gtk_source_view_set_show_right_margin (view,
pluma_prefs_manager_get_display_right_margin ());
}
if (previous)
{
*previous = options;
previous->language_id = g_strdup (options.language_id);
}
else
{
previous = g_slice_new (ModelineOptions);
*previous = options;
previous->language_id = g_strdup (options.language_id);
g_object_set_data_full (G_OBJECT (buffer),
MODELINE_OPTIONS_DATA_KEY,
previous,
(GDestroyNotify)free_modeline_options);
}
g_free (options.language_id);
}
AtlantisDocument* atlantis_document_construct (GType object_type, const char* path) {
#line 73 "document.c"
GError * _inner_error_;
AtlantisDocument * self;
char* _tmp0_;
char* _tmp1_;
GtkSourceLanguageManager* slm;
GtkSourceLanguage* lang;
GtkSourceLanguageManager* _tmp2_;
GtkSourceLanguage* _tmp3_;
#line 11 "document.vala"
g_return_val_if_fail (path != NULL, NULL);
#line 84 "document.c"
_inner_error_ = NULL;
self = g_object_newv (object_type, 0, NULL);
#line 13 "document.vala"
self->priv->fileName = (_tmp0_ = atlantis_document_uri_to_filename (self, path), _g_free0 (self->priv->fileName), _tmp0_);
#line 14 "document.vala"
self->priv->baseName = (_tmp1_ = g_path_get_basename (self->priv->fileName), _g_free0 (self->priv->baseName), _tmp1_);
#line 91 "document.c"
slm = NULL;
lang = NULL;
#line 18 "document.vala"
slm = (_tmp2_ = gtk_source_language_manager_new (), _g_object_unref0 (slm), _tmp2_);
#line 19 "document.vala"
lang = (_tmp3_ = _g_object_ref0 (gtk_source_language_manager_get_language (slm, "vala")), _g_object_unref0 (lang), _tmp3_);
#line 21 "document.vala"
if (lang != NULL) {
#line 100 "document.c"
char* content;
char* _tmp6_;
gboolean _tmp5_;
char* _tmp4_ = NULL;
content = NULL;
#line 24 "document.vala"
_tmp5_ = g_file_get_contents (self->priv->fileName, &_tmp4_, NULL, &_inner_error_);
#line 24 "document.vala"
content = (_tmp6_ = _tmp4_, _g_free0 (content), _tmp6_);
#line 24 "document.vala"
_tmp5_;
#line 112 "document.c"
if (_inner_error_ != NULL) {
_g_free0 (content);
_g_object_unref0 (slm);
_g_object_unref0 (lang);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return NULL;
}
#line 25 "document.vala"
g_object_set ((GtkTextBuffer*) self, "text", content, NULL);
#line 26 "document.vala"
gtk_source_buffer_set_language ((GtkSourceBuffer*) self, lang);
#line 27 "document.vala"
gtk_source_buffer_set_highlight_syntax ((GtkSourceBuffer*) self, TRUE);
#line 127 "document.c"
_g_free0 (content);
}
_g_object_unref0 (slm);
_g_object_unref0 (lang);
return self;
}
NetlistEditor *
netlist_editor_new (GtkSourceBuffer * textbuffer) {
NetlistEditor * nle;
GtkBuilder *gui;
GError *perror = NULL;
GtkWidget * toplevel;
GtkScrolledWindow * scroll;
GtkSourceView * source_view;
GtkSourceLanguageManager * lm;
GtkButton * save, * close;
GtkSourceLanguage *lang=NULL;
if (!textbuffer)
return NULL;
if ((gui = gtk_builder_new ()) == NULL) {
oregano_error (_("Could not create the netlist dialog"));
return NULL;
}
gtk_builder_set_translation_domain (gui, NULL);
nle = NETLIST_EDITOR (g_object_new (netlist_editor_get_type (), NULL));
if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/view-netlist.ui",
&perror) <= 0) {
gchar *msg;
msg = perror->message;
oregano_error_with_title (_("Could not create the netlist dialog"), msg);
g_error_free (perror);
return NULL;
}
toplevel = GTK_WIDGET (gtk_builder_get_object (gui, "toplevel"));
gtk_window_set_default_size (GTK_WINDOW (toplevel), 800, 600);
gtk_window_set_title (GTK_WINDOW (toplevel), "Net List Editor\n");
scroll = GTK_SCROLLED_WINDOW (gtk_builder_get_object (gui, "netlist-scrolled-window"));
source_view = GTK_SOURCE_VIEW (gtk_source_view_new ());
lm = GTK_SOURCE_LANGUAGE_MANAGER (gtk_source_language_manager_new ());
setup_language_manager_path (lm);
g_object_set_data_full (G_OBJECT (source_view), "language-manager",
lm, (GDestroyNotify) g_object_unref);
lang = gtk_source_language_manager_get_language (lm, "netlist");
if (lang) {
NG_DEBUG ("\"%s\" from \"%s\"", gtk_source_language_get_name (lang), OREGANO_LANGDIR "/netlist.lang");
gtk_source_buffer_set_language (GTK_SOURCE_BUFFER (textbuffer), lang);
gtk_source_buffer_set_highlight_syntax (GTK_SOURCE_BUFFER (textbuffer), TRUE);
gtk_source_buffer_set_highlight_matching_brackets (GTK_SOURCE_BUFFER (textbuffer), TRUE);
}
else {
g_warning ("Can't load netlist.lang in %s", OREGANO_LANGDIR "/netlist.lang");
}
gtk_text_view_set_editable (GTK_TEXT_VIEW (source_view), TRUE);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (source_view), GTK_TEXT_BUFFER (textbuffer));
gtk_container_add (GTK_CONTAINER (scroll), GTK_WIDGET (source_view));
close = GTK_BUTTON (gtk_builder_get_object (gui, "btn_close"));
g_signal_connect_swapped (G_OBJECT (close), "clicked",
G_CALLBACK (g_object_unref), G_OBJECT (nle));
save = GTK_BUTTON (gtk_builder_get_object (gui, "btn_save"));
g_signal_connect (G_OBJECT (save), "clicked",
G_CALLBACK (netlist_editor_save), nle);
// Set tab, fonts, wrap mode, colors, etc. according
// to preferences
nle->priv->view = GTK_TEXT_VIEW (source_view);
nle->priv->toplevel = GTK_WINDOW (toplevel);
nle->priv->save = save;
nle->priv->close = close;
nle->priv->buffer = textbuffer;
gtk_widget_show_all (GTK_WIDGET (toplevel));
return nle;
}
PUSS_EXPORT void* puss_plugin_create(Puss* app) {
GTree* sections;
GtkSourceLanguageManager* lm;
const gchar* const* ids;
const gchar* const* id;
GtkSourceLanguage* lang;
const gchar* name;
gchar* action_name;
GtkAction* action;
const gchar* section;
GList* section_list;
GtkUIManager* ui_mgr;
IToolMenuAction* tool_menu_interface;
GString* gstr;
gchar* ui_info;
GError* err;
tool_menu_interface = app->extend_query("puss_controls", INTERFACE_TOOL_MENU_ACTION);
if( !tool_menu_interface )
return 0;
bindtextdomain(TEXT_DOMAIN, app->get_locale_path());
bind_textdomain_codeset(TEXT_DOMAIN, "UTF-8");
g_self = g_new0(LanguageSelector, 1);
g_self->app = app;
g_self->action_group = gtk_action_group_new("puss_language_selector_action_group");
// set select language menu
sections = g_tree_new_full((GCompareDataFunc)&g_ascii_strcasecmp, 0, 0, (GDestroyNotify)g_list_free);
lm = gtk_source_language_manager_get_default();
ids = gtk_source_language_manager_get_language_ids(lm);
g_self->last_favory_lang = gtk_source_language_manager_get_language(lm, "cpp");
for( id=ids; *id; ++id ) {
lang = gtk_source_language_manager_get_language(lm, *id);
if( lang ) {
name = gtk_source_language_get_name(lang);
action_name = g_strdup_printf("pls_lang_%s", name);
action = gtk_action_new(action_name, name, NULL, NULL);
g_signal_connect(action, "activate", G_CALLBACK(&pls_lang_active), lang);
gtk_action_group_add_action(g_self->action_group, action);
g_object_unref(action);
g_free(action_name);
section = gtk_source_language_get_section(lang);
section_list = (GList*)g_tree_lookup(sections, section);
if( section_list ) {
g_tree_steal(sections, section);
} else {
action_name = g_strdup_printf("pls_sec_%s", section);
action = GTK_ACTION(gtk_action_new(action_name, section, NULL, NULL));
gtk_action_group_add_action(g_self->action_group, action);
g_object_unref(action);
g_free(action_name);
}
section_list = g_list_insert_sorted(section_list, (gchar*)name, (GCompareFunc)&g_ascii_strcasecmp);
g_tree_insert(sections, (gchar*)section, section_list);
}
}
// insert language selector menu-tool-button
//
action = gtk_action_new("language_selector_open", _("Language"), _("select high-light source language, default use last"), GTK_STOCK_SELECT_COLOR);
gtk_action_group_add_action(g_self->action_group, action);
g_object_unref(action);
action = GTK_ACTION( g_object_new(tool_menu_interface->get_type ()
, "name", "language_selector_toolmenu_open"
, "label", _("Language")
, "tooltip", _("select high-light source language, default use last")
, "stock-id", GTK_STOCK_SELECT_COLOR
, NULL) );
g_signal_connect(action, "activate", G_CALLBACK(&pls_lang_active), 0);
gtk_action_group_add_action(g_self->action_group, action);
g_object_unref(action);
ui_mgr = GTK_UI_MANAGER(gtk_builder_get_object(app->get_ui_builder(), "main_ui_manager"));
gtk_ui_manager_insert_action_group(ui_mgr, g_self->action_group, 0);
// main selector menu
gstr= g_string_new(NULL);
g_tree_foreach(sections, (GTraverseFunc)&fill_language_section, gstr);
g_tree_destroy(sections);
ui_info = g_strdup_printf(
"<ui>"
" <menubar name='main_menubar'>"
" <menu action='view_menu'>\n"
" <placeholder name='view_menu_extend_place'>"
" <menu action='language_selector_open'>"
" %s"
" <placeholder name='pls_favory_menu_place'>"
" </placeholder>"
" </menu>"
" </placeholder>"
" </menu>"
" </menubar>"
""
" <toolbar name='main_toolbar'>"
" <placeholder name='main_toolbar_view_place'>"
" <toolitem action='language_selector_toolmenu_open'>"
" <menu action='language_selector_toolmenu_open'>"
" %s"
" <placeholder name='pls_favory_toolmenu_place'>"
" </placeholder>"
" </menu>"
" </toolitem>"
" </placeholder>"
" </toolbar>"
"</ui>"
, gstr->str
, gstr->str
);
//g_print(ui_info);
err = 0;
g_self->merge_id = gtk_ui_manager_add_ui_from_string(ui_mgr, ui_info, -1, &err);
if( err ) {
g_printerr("%s", err->message);
g_error_free(err);
}
g_free(ui_info);
g_string_free(gstr, TRUE);
gtk_ui_manager_ensure_update(ui_mgr);
fill_favory_language_menu();
return g_self;
}
static void mape_edit_view_set_filename(MapeEditView* view,
const gchar* filename)
{
MapeMapgenType new_type;
GtkSourceBuffer* buf;
gchar* basename;
gchar* utf8_file;
gchar* utf8_file_casefold;
gchar* utf8_landscape_txt_casefold;
const gchar* lang_name;
const gchar* lang_filename;
GtkSourceLanguage* lang;
GtkSourceStyleScheme* style;
GtkWidget* error_dialog;
buf = GTK_SOURCE_BUFFER(
gtk_text_view_get_buffer(GTK_TEXT_VIEW(view->view) )
);
if (view->file_path != filename)
{
if(filename != NULL)
{
view->file_path = g_strdup(filename);
}
else
{
view->file_path = NULL;
}
}
if(filename != NULL)
{
basename = g_path_get_basename(filename);
/* Determine document type */
utf8_file = g_filename_to_utf8(
basename,
-1,
NULL,
NULL,
NULL
);
g_free(basename);
if(utf8_file != NULL)
{
utf8_file_casefold = g_utf8_casefold(utf8_file, -1);
utf8_landscape_txt_casefold = g_utf8_casefold("landscape.txt", -1);
g_free(utf8_file);
if(g_utf8_collate(utf8_file_casefold, utf8_landscape_txt_casefold) == 0)
new_type = MAPE_MAPGEN_LANDSCAPE_TXT;
else
new_type = MAPE_MAPGEN_MAP_C;
g_free(utf8_file_casefold);
g_free(utf8_landscape_txt_casefold);
}
}
else
{
new_type = MAPE_MAPGEN_MAP_C;
}
if(new_type != view->type)
{
view->type = new_type;
switch(view->type)
{
case MAPE_MAPGEN_LANDSCAPE_TXT:
lang_name = "c4landscape";
lang_filename = "Landscape.txt";
break;
case MAPE_MAPGEN_MAP_C:
lang_name = "c4mapscript";
lang_filename = "Map.c";
break;
default:
lang_name = NULL;
g_assert_not_reached();
break;
}
/* Set language according to document type */
lang = gtk_source_language_manager_get_language(
view->lang_manager,
lang_name
);
style = gtk_source_style_scheme_manager_get_scheme(
view->style_manager,
"mape"
);
if(lang == NULL || style == NULL)
{
/* TODO: Show location where we search in */
error_dialog = gtk_message_dialog_new(
NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"Syntax Highlighting Not Available"
);
gtk_message_dialog_format_secondary_text(
GTK_MESSAGE_DIALOG(error_dialog),
"The syntax highlighting file for %s files "
"could not be located. Perhaps mape has not "
"been properly installed. Syntax "
"highlighting is disabled.",
lang_filename
);
gtk_window_set_title(GTK_WINDOW(error_dialog), "Mape");
gtk_dialog_run(GTK_DIALOG(error_dialog) );
gtk_widget_destroy(error_dialog);
}
else
{
gtk_source_buffer_set_language(buf, lang);
gtk_source_buffer_set_style_scheme(buf, style);
}
}
}
SourceView::SourceView(const std::string& language, bool readOnly)
{
// Set the search path to the language and style files
gchar* directories[2];
#if defined(POSIX) && defined(PKGDATADIR)
std::string langFilesDir = std::string(PKGDATADIR) + "/sourceviewer/";
#else
std::string langFilesDir = GlobalRegistry().get(RKEY_APP_PATH) + "sourceviewer/";
#endif
directories[0] = const_cast<gchar*>(langFilesDir.c_str()); // stupid GtkSourceLanguageManager is expecting non-const gchar* pointer...
directories[1] = NULL;
GtkSourceStyleSchemeManager* styleSchemeManager = gtk_source_style_scheme_manager_get_default();
gtk_source_style_scheme_manager_set_search_path(styleSchemeManager, directories);
gtk_source_style_scheme_manager_force_rescan(styleSchemeManager);
_langManager = gtk_source_language_manager_new();
gtk_source_language_manager_set_search_path(_langManager, directories);
GtkSourceLanguage* lang = gtk_source_language_manager_get_language(_langManager, language.c_str());
if (lang == NULL)
{
globalErrorStream() << "SourceView: Cannot find language " << language << " in " << langFilesDir << std::endl;
}
// Remember the pointers to the textbuffers
if (lang != NULL)
{
_buffer = gtk_source_buffer_new_with_language(lang);
gtk_source_buffer_set_highlight_syntax(_buffer, TRUE);
}
else
{
_buffer = gtk_source_buffer_new(NULL);
gtk_source_buffer_set_highlight_syntax(_buffer, FALSE);
}
_view = GTK_SOURCE_VIEW(gtk_source_view_new_with_buffer(_buffer));
gtk_widget_set_size_request(GTK_WIDGET(_view), 0, -1); // allow shrinking
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(_view), GTK_WRAP_WORD);
gtk_text_view_set_editable(GTK_TEXT_VIEW(_view), readOnly ? FALSE : TRUE);
gtk_source_view_set_show_line_numbers(_view, TRUE);
gtk_source_view_set_auto_indent(_view, TRUE);
// Use a fixed width font
PangoFontDescription* fontDesc = pango_font_description_from_string("Monospace");
if (fontDesc != NULL)
{
gtk_widget_modify_font(GTK_WIDGET(_view), fontDesc);
}
// Use a tab size of 4
gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(_view), 4);
widget_connect_escape_clear_focus_widget(GTK_WIDGET(_view));
_widget = gtkutil::ScrolledFrame(GTK_WIDGET(_view));
}
int
main (int argc, char *argv[]){
GtkWidget *button = NULL,
*win = NULL,
*vbox = NULL,
*vbox2 = NULL,
*halign = NULL,
*buttonbox = NULL,
*scrl1 = NULL,
*scrl2 = NULL,
*sourceview = NULL;
GtkSourceLanguageManager *gsv_lm = NULL;
GtkSourceLanguage *gsv_lang = NULL;
gchar *searchpaths[] =
{"./","/usr/share/gtksourceview-2.0/language-specs/",0};
/* Initialize GTK+ */
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, (GLogFunc) gtk_false, NULL);
gtk_init (&argc, &argv);
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, g_log_default_handler, NULL);
/* Create the main window */
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width (GTK_CONTAINER (win), 8);
gtk_window_set_title (GTK_WINDOW (win), TITLE);
gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(win), 600, 0);
gtk_widget_realize (win);
g_signal_connect (G_OBJECT(win), "destroy", G_CALLBACK(destroy_wnd), NULL);
g_signal_connect (G_OBJECT(win), "delete_event", G_CALLBACK(delete_event),NULL);
/* Create a vertical box with buttons */
vbox = gtk_vbox_new(FALSE, 5);
vbox2 = gtk_vbox_new(TRUE, 5);
halign = gtk_alignment_new(1, 0, 0, 0);
scrl1 = gtk_scrolled_window_new(0,0);
scrl2 = gtk_scrolled_window_new(0,0);
buttonbox = gtk_hbutton_box_new();
gtk_container_add(GTK_CONTAINER(halign), buttonbox);
gtk_box_pack_start(GTK_BOX(vbox2), GTK_WIDGET(scrl1), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox2), GTK_WIDGET(scrl2), FALSE, TRUE, 0);
gtk_widget_set_size_request(GTK_WIDGET(vbox2), 0, 400);
gtk_container_add(GTK_CONTAINER(vbox), vbox2);
gtk_container_add(GTK_CONTAINER(win), vbox);
gtk_box_pack_start(GTK_BOX(vbox), halign, FALSE, FALSE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrl1),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrl2),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
/* Build the C buffer */
if (!(gsv_lm = gtk_source_language_manager_new())) exit(1);
gtk_source_language_manager_set_search_path(gsv_lm, searchpaths);
if (!(gsv_lang = gtk_source_language_manager_get_language(gsv_lm, "c"))) exit(2);
if (!(gsv_buffer_c = gtk_source_buffer_new_with_language(gsv_lang))) exit(3);
gtk_source_buffer_set_highlight_syntax(gsv_buffer_c, TRUE);
if (!(sourceview = gtk_source_view_new_with_buffer(gsv_buffer_c))) exit(4);
gtk_container_add(GTK_CONTAINER(scrl1), sourceview);
gtk_text_view_set_editable(GTK_TEXT_VIEW(sourceview), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(sourceview), FALSE);
/* Build the ASM buffer */
if (!(gsv_lm = gtk_source_language_manager_new())) exit(1);
gtk_source_language_manager_set_search_path(gsv_lm, searchpaths);
if (!(gsv_lang = gtk_source_language_manager_get_language(gsv_lm, "nasm"))) exit(2);
if (!(gsv_buffer_asm = gtk_source_buffer_new_with_language(gsv_lang))) exit(3);
gtk_source_buffer_set_highlight_syntax(gsv_buffer_asm, TRUE);
if (!(sourceview = gtk_source_view_new_with_buffer(gsv_buffer_asm))) exit(4);
gtk_container_add(GTK_CONTAINER(scrl2), sourceview);
/* Set the text of the buffers */
gtk_text_buffer_set_text(GTK_TEXT_BUFFER(gsv_buffer_c), question, strlen(question));
gtk_text_buffer_set_text(GTK_TEXT_BUFFER(gsv_buffer_asm), answer, strlen(answer));
/* Buttons */
button = gtk_button_new_from_stock (GTK_STOCK_DIALOG_INFO);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK(info_dialog), (gpointer) win);
gtk_box_pack_start (GTK_BOX (buttonbox), button, FALSE, FALSE, 0);
button = gtk_button_new_with_label("Test Answer");
g_signal_connect (button, "clicked", G_CALLBACK(test_answer), NULL);
gtk_box_pack_start (GTK_BOX (buttonbox), button, FALSE, FALSE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
g_signal_connect (button, "clicked", gtk_main_quit, NULL);
gtk_box_pack_start (GTK_BOX (buttonbox), button, FALSE, FALSE, 0);
srand(time(NULL));
/* Enter the main loop */
gtk_widget_show_all (win);
gtk_main ();
return 0;
}
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);
}
}
}
