static void pls_lang_active(GtkAction* action, GtkSourceLanguage* lang) { gint page_num; GtkTextBuffer* buf; page_num = gtk_notebook_get_current_page(puss_get_doc_panel(g_self->app)); if( page_num < 0 ) return; buf = g_self->app->doc_get_buffer_from_page_num(page_num); #if GTK_MAJOR_VERSION==2 if( !buf || !GTK_IS_SOURCE_BUFFER(buf) ) return; #else if( !buf || !GTK_SOURCE_IS_BUFFER(buf) ) return; #endif if( lang ) { gtk_source_buffer_set_language(GTK_SOURCE_BUFFER(buf), lang); add_fill_favory_language(lang); } else { gtk_source_buffer_set_language(GTK_SOURCE_BUFFER(buf), g_self->last_favory_lang); } }
static void set_language (GeditDocument *doc, GtkSourceLanguage *lang, gboolean set_by_user) { GeditDocumentPrivate *priv; GtkSourceLanguage *old_lang; gedit_debug (DEBUG_DOCUMENT); priv = gedit_document_get_instance_private (doc); old_lang = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (doc)); if (old_lang == lang) { return; } gtk_source_buffer_set_language (GTK_SOURCE_BUFFER (doc), lang); if (set_by_user) { const gchar *language = get_language_string (doc); gedit_document_set_metadata (doc, GEDIT_METADATA_ATTRIBUTE_LANGUAGE, language, NULL); } priv->language_set_by_user = set_by_user; }
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; }
void set_language(){ if(cfg_lang()){ GtkSourceLanguageManager *lm; lm=gtk_source_language_manager_new(); char* currentfile=(char*)tpad_fp_get_current(); if(currentfile!=NULL){ long unsigned int i= 0,pos= 0; size_t mlewn = sizeof(currentfile)/sizeof(currentfile[1]); size_t blew = strlen(currentfile) + 1; if(blew > mlewn) mlewn = blew; char fil[mlewn]; for(i=0; currentfile[i]; i++){ if(currentfile[i]=='\\') fil[pos++]='\\'; fil[pos++]=currentfile[i]; } fil[pos]=0; gboolean result_uncertain; gchar *content_type; content_type = g_content_type_guess (fil, NULL, 0, &result_uncertain); if (result_uncertain){ g_free (content_type); content_type = NULL; } GtkSourceLanguage *lang = NULL; lang = gtk_source_language_manager_guess_language (lm, fil, content_type); gtk_source_buffer_set_language (GTK_SOURCE_BUFFER(mBuff),GTK_SOURCE_LANGUAGE(lang)); gtk_source_buffer_set_highlight_matching_brackets (GTK_SOURCE_BUFFER(mBuff), (gboolean) cfg_lang()); if(cfg_lang()) (lang) ? gtk_source_buffer_set_highlight_syntax(GTK_SOURCE_BUFFER(mBuff),TRUE) : gtk_source_buffer_set_highlight_syntax(GTK_SOURCE_BUFFER(mBuff),FALSE); if(content_type) g_free (content_type); } } else { gtk_source_buffer_set_language(GTK_SOURCE_BUFFER(mBuff),NULL); gtk_source_buffer_set_highlight_syntax(GTK_SOURCE_BUFFER(mBuff),FALSE); } if(cfg_undo() >= 1 && cfg_undo() <= UNDO_MAX) gtk_source_buffer_set_max_undo_levels ((GtkSourceBuffer *)mBuff,(gint)cfg_undo()); else { gtk_source_buffer_set_max_undo_levels ((GtkSourceBuffer *)mBuff,(gint)-1); cfg_set_undo(0); } (cfg_line_wrap()) ? gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view),GTK_WRAP_WORD) : gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view),GTK_WRAP_NONE); }
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); }
/** * peacock_file_construct: * @file: * * Sort of a post constructor, constructor. **/ static void peacock_file_construct (PeacockFile *file) { GtkSourceLanguagesManager *lang_manager; GtkSourceLanguage *lang; /* * Get the highlighting style for HTML and apply it to * the GtkSourceBuffer. */ lang_manager = gtk_source_languages_manager_new (); lang = gtk_source_languages_manager_get_language_from_mime_type ( lang_manager, "text/html"); gtk_source_buffer_set_language (GTK_SOURCE_BUFFER (file), lang); gtk_source_buffer_set_highlight (GTK_SOURCE_BUFFER (file), TRUE); }
static void set_language (GeditDocument *doc, GtkSourceLanguage *lang, gboolean set_by_user) { GtkSourceLanguage *old_lang; gedit_debug (DEBUG_DOCUMENT); old_lang = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (doc)); if (old_lang == lang) { return; } gtk_source_buffer_set_language (GTK_SOURCE_BUFFER (doc), lang); if (lang != NULL) { gboolean syntax_hl; syntax_hl = g_settings_get_boolean (doc->priv->editor_settings, GEDIT_SETTINGS_SYNTAX_HIGHLIGHTING); gtk_source_buffer_set_highlight_syntax (GTK_SOURCE_BUFFER (doc), syntax_hl); } else { gtk_source_buffer_set_highlight_syntax (GTK_SOURCE_BUFFER (doc), FALSE); } if (set_by_user) { const gchar *language = get_language_string (doc); gedit_document_set_metadata (doc, GEDIT_METADATA_ATTRIBUTE_LANGUAGE, language, NULL); } doc->priv->language_set_by_user = set_by_user; }
static void load_ready (GObject *source_object, GAsyncResult *res, gpointer user_data) { GtkSourceFileLoader *loader = GTK_SOURCE_FILE_LOADER (source_object); EditorApplicationWindow *window = EDITOR_APPLICATION_WINDOW (user_data); GtkTextIter iter; GFile *location; GtkSourceLanguageManager *manager; GtkSourceLanguage *language; gchar *filename; GError *error = NULL; if (!gtk_source_file_loader_load_finish (loader, res, &error)) { g_warning ("Error while loading the file: %s", error->message); g_error_free (error); g_clear_object (&window->file); goto out; } gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (window->buffer), &iter); gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (window->buffer), &iter); location = gtk_source_file_loader_get_location (loader); filename = g_file_get_path (location); manager = gtk_source_language_manager_get_default (); language = gtk_source_language_manager_guess_language (manager, filename, NULL); g_free (filename); if (language) gtk_source_buffer_set_language (window->buffer, language); if (grammar_filename) set_indenter (window, grammar_filename); out: g_object_unref (loader); gtk_window_present (GTK_WINDOW (window)); }
static module_t *add_module(const char *Name) { // printf("Adding module: %s\n", Name); gdk_threads_enter(); module_t *Module = new(module_t); Module->Name = Name; Module->Source = gtk_source_buffer_new(SourceTags); gtk_source_buffer_set_language(Module->Source, SourceLanguage); gtk_source_buffer_set_style_scheme(Module->Source, StyleScheme); gtk_text_view_set_buffer(SourceView, Module->Source); GtkTreeIter Iter; gtk_list_store_append(Modules, &Iter); gtk_list_store_set(Modules, &Iter, 0, Name, 1, Module, -1); Module->ModulePath = gtk_tree_model_get_path(Modules, &Iter); DisplayedModule = Module; gtk_tree_store_append(Globals, &Iter, 0); gtk_tree_store_set(Globals, &Iter, 0, Module->Name, 1, 0, 2, 0, 3, 0, 5, -1, -1); Module->GlobalsPath = gtk_tree_model_get_path(Globals, &Iter); //Module->Breakpoints = Riva$Memory$alloc_atomic(1); //Module->Breakpoints[0] = BreakOnNewModule; //Module->MaxBreakpoint = 1; gdk_threads_leave(); return Module; };
static void gb_editor_tab_guess_language (GbEditorTab *tab) { GtkSourceLanguageManager *manager; GbEditorTabPrivate *priv; GtkSourceLanguage *lang; gboolean result_uncertain; gchar *content_type; gchar *filename; g_return_if_fail (GB_IS_EDITOR_TAB (tab)); priv = tab->priv; if (!priv->file) { return; } manager = gtk_source_language_manager_get_default (); filename = g_file_get_path (priv->file); content_type = g_content_type_guess (filename, NULL, 0, &result_uncertain); if (result_uncertain) { g_free (content_type); content_type = NULL; } lang = gtk_source_language_manager_guess_language (manager, filename, content_type); gtk_source_buffer_set_language (GTK_SOURCE_BUFFER (priv->document), lang); gb_editor_tab_reload_snippets (tab, lang); g_free (content_type); g_free (filename); }
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); } }
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); } } }
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; }
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) { 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; }
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); }
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); }
static void gb_view_source_set_file_attribs (GbViewSource *source, GFile *file) { GtkSourceLanguageManager *lm; GbViewSourcePrivate *priv; GtkSourceLanguage *lang; const gchar *icon_name; GFileInfo *info; gchar *path; ENTRY; g_return_if_fail(GB_IS_VIEW_SOURCE(source)); g_return_if_fail(G_IS_FILE(file)); priv = source->priv; if (!(path = g_file_get_path(file))) { path = g_file_get_uri(file); } if ((icon_name = gb_path_get_icon_name(path))) { gb_view_set_icon_name(GB_VIEW(source), icon_name); } info = g_file_query_info(file, "standard::*", 0, NULL, NULL); /* * Get the relative path to the file from the project. */ { const gchar *directory; GtkWidget *window; GbProject *project; gb_view_set_name(GB_VIEW(source), path); window = gtk_widget_get_toplevel(GTK_WIDGET(source)); if (GB_IS_WINDOW(window)) { project = gb_window_get_project(GB_WINDOW(window)); directory = gb_project_get_directory(project); if (g_str_has_prefix(path, directory)) { gb_view_set_name(GB_VIEW(source), path + strlen(directory)); } } } lm = gtk_source_language_manager_get_default(); lang = gtk_source_language_manager_guess_language( lm, path, g_file_info_get_content_type(info)); if (lang) { gb_menu_button_set_label(GB_MENU_BUTTON(priv->lang_combo), gtk_source_language_get_name(lang)); } else { gb_menu_button_set_label(GB_MENU_BUTTON(priv->lang_combo), ""); } gtk_source_buffer_set_language(priv->buffer, lang); g_object_unref(info); g_free(path); EXIT; }