NetlistEditor * netlist_editor_new_from_file (gchar * filename) { GtkSourceBuffer *buffer; gchar *content; gsize length; GError *error = NULL; NetlistEditor *editor; if (!filename) return NULL; if (!(g_file_test (filename, G_FILE_TEST_EXISTS))) { gchar *msg; // gettext support msg = g_strdup_printf (_("The file %s could not be found."), filename); oregano_error_with_title (_("Could not find the required file"), msg); g_free (msg); return NULL; } buffer = gtk_source_buffer_new (NULL); g_file_get_contents (filename, &content, &length, &error); gtk_text_buffer_set_text (GTK_TEXT_BUFFER (buffer), content, -1); editor = netlist_editor_new (buffer); return editor; }
src_view___::src_view___(GtkWidget* scrolled2, void* window):view___(scrolled2, window) { buf_ = GTK_SOURCE_BUFFER (gtk_source_buffer_new (NULL)); widget_ = gtk_source_view_new_with_buffer(buf_); gtk_container_add (GTK_CONTAINER (scrolled2), widget_); GtkSourceView* sv = handle__(); gtk_source_view_set_show_line_numbers(sv, true); gtk_source_view_set_tab_width(sv, 4); gtk_source_view_set_auto_indent (sv, true); gtk_source_view_set_smart_home_end(sv, GTK_SOURCE_SMART_HOME_END_ALWAYS); gtk_source_view_set_draw_spaces (sv, GTK_SOURCE_DRAW_SPACES_ALL); gtk_widget_set_can_focus(widget_, true); }
gint main (gint argc, gchar **argv) { GtkSourceBuffer *source_buffer; GtkTextBuffer *text_buffer; GtkTextIter iter; GTimer *timer; gint nb_actions; gint i; gtk_init (&argc, &argv); source_buffer = gtk_source_buffer_new (NULL); text_buffer = GTK_TEXT_BUFFER (source_buffer); gtk_text_buffer_get_start_iter (text_buffer, &iter); for (i = 0; i < NB_LINES; i++) { gtk_text_buffer_begin_user_action (text_buffer); gtk_text_buffer_insert (text_buffer, &iter, "A line of text to fill the text buffer. Is it long enough?\n", -1); gtk_text_buffer_end_user_action (text_buffer); } timer = g_timer_new (); nb_actions = test_undo_redo (source_buffer, NB_LINES / 10); g_timer_stop (timer); g_print ("Undo/Redo %d actions: %lf seconds.\n", nb_actions, g_timer_elapsed (timer, NULL)); g_timer_start (timer); nb_actions = test_undo_redo (source_buffer, NB_LINES); g_timer_stop (timer); g_print ("Undo/Redo %d actions: %lf seconds.\n", nb_actions, g_timer_elapsed (timer, NULL)); g_object_unref (source_buffer); g_timer_destroy (timer); return 0; }
static void wikipad_document_init (WikipadDocument *document) { GtkTargetList *target_list; /* private structure */ document->priv = WIKIPAD_DOCUMENT_GET_PRIVATE (document); /* initialize the variables */ document->priv->utf8_filename = NULL; document->priv->utf8_basename = NULL; document->priv->label = NULL; /* setup the scolled window */ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (document), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (document), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_hadjustment (GTK_SCROLLED_WINDOW (document), NULL); gtk_scrolled_window_set_vadjustment (GTK_SCROLLED_WINDOW (document), NULL); /* create a textbuffer */ document->buffer = GTK_TEXT_BUFFER (gtk_source_buffer_new (NULL)); /* initialize the file */ document->file = wikipad_file_new (document->buffer); /* connect signals to the file */ g_signal_connect_swapped (G_OBJECT (document->file), "filename-changed", G_CALLBACK (wikipad_document_filename_changed), document); /* create the highlight tag */ document->tag = gtk_text_buffer_create_tag (document->buffer, NULL, "background", "#ffff78", NULL); /* setup the textview */ document->textview = g_object_new (WIKIPAD_TYPE_VIEW, "buffer", document->buffer, NULL); gtk_container_add (GTK_CONTAINER (document), GTK_WIDGET (document->textview)); gtk_widget_show (GTK_WIDGET (document->textview)); /* also allow dropping of uris and tabs in the textview */ target_list = gtk_drag_dest_get_target_list (GTK_WIDGET (document->textview)); gtk_target_list_add_table (target_list, drop_targets, G_N_ELEMENTS (drop_targets)); /* attach signals to the text view and buffer */ g_signal_connect (G_OBJECT (document->buffer), "notify::cursor-position", G_CALLBACK (wikipad_document_notify_cursor_position), document); g_signal_connect (G_OBJECT (document->buffer), "notify::has-selection", G_CALLBACK (wikipad_document_notify_has_selection), document); g_signal_connect_swapped (G_OBJECT (document->buffer), "modified-changed", G_CALLBACK (wikipad_document_label_color), document); g_signal_connect_swapped (G_OBJECT (document->file), "readonly-changed", G_CALLBACK (wikipad_document_label_color), document); g_signal_connect (G_OBJECT (document->textview), "notify::overwrite", G_CALLBACK (wikipad_document_notify_overwrite), document); g_signal_connect (G_OBJECT (document->textview), "drag-data-received", G_CALLBACK (wikipad_document_drag_data_received), document); g_signal_connect (G_OBJECT (document->buffer), "notify::language", G_CALLBACK (wikipad_document_notify_language), document); }
static void test_buffer_ref (void) { GtkSourcePrintCompositor *compositor; GtkSourceBuffer *buffer = NULL; GtkSourceBuffer *buffer_original = NULL; buffer_original = gtk_source_buffer_new (NULL); compositor = gtk_source_print_compositor_new (buffer_original); buffer = gtk_source_print_compositor_get_buffer (compositor); g_assert (GTK_SOURCE_IS_BUFFER (buffer)); g_object_unref (G_OBJECT (buffer_original)); buffer = gtk_source_print_compositor_get_buffer (compositor); g_assert (GTK_SOURCE_IS_BUFFER (buffer)); }
GtkSourceBuffer * init_buffer(FileContainer *file_container) { GtkSourceBuffer *source_buffer = gtk_source_buffer_new(NULL); gtk_source_buffer_set_highlight_matching_brackets(source_buffer, FALSE); GtkTextBuffer *text_buffer = GTK_TEXT_BUFFER(source_buffer); gtk_text_buffer_set_text( text_buffer, file_container->data, file_container->size ); GtkTextIter start_of_buffer; gtk_text_buffer_get_start_iter(text_buffer, &start_of_buffer); gtk_text_buffer_place_cursor(text_buffer, &start_of_buffer); gtk_text_buffer_set_modified(text_buffer, FALSE); return source_buffer; }
void init_editor(GtkWidget *box) { //エディタ部分の外観の設定 GtkWidget *notebook = gtk_notebook_new(); scroll_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); buffer = gtk_source_buffer_new(NULL); view = gtk_source_view_new_with_buffer(buffer); set_file_name(""); name_label = gtk_label_new("編集中のファイル"); gtk_container_add(GTK_CONTAINER(scroll_window), view); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scroll_window, name_label); gtk_widget_set_has_tooltip(view, TRUE); gtk_widget_grab_focus(view); set_style(); gtk_box_pack_start(GTK_BOX(box), notebook, TRUE, TRUE, 0); //エディタ部分の動作の初期設定 gtk_source_buffer_set_highlight_matching_brackets(buffer, FALSE); gtk_widget_modify_font(view, pango_font_description_from_string(font_name)); gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(view), state & width_mask); if (state & wrap_mask) { gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_CHAR); } else { gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_NONE); } if (state & line_mask) { gtk_source_view_set_show_line_numbers(GTK_SOURCE_VIEW(view), TRUE); } else { gtk_source_view_set_show_line_numbers(GTK_SOURCE_VIEW(view), FALSE); } if (state & highlight_mask) { gtk_source_view_set_highlight_current_line(GTK_SOURCE_VIEW(view), TRUE); } else { gtk_source_view_set_highlight_current_line(GTK_SOURCE_VIEW(view), FALSE); } if (state & space_mask) { gtk_source_view_set_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW(view), TRUE); } else { gtk_source_view_set_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW(view), FALSE); } }
/* Helper function: search one documentation page */ static void search_documentation(DocText *doctext, I7SearchWindow *self) { I7_SEARCH_WINDOW_USE_PRIVATE(self, priv); GtkTreeIter result; GtkTextIter search_from, match_start, match_end; GtkTextBuffer *buffer = GTK_TEXT_BUFFER(gtk_source_buffer_new(NULL)); gtk_text_buffer_set_text(buffer, doctext->body, -1); gtk_text_buffer_get_start_iter(buffer, &search_from); while(find_no_wrap(&search_from, priv->text, TRUE, GTK_SOURCE_SEARCH_TEXT_ONLY | (priv->ignore_case? GTK_SOURCE_SEARCH_CASE_INSENSITIVE : 0), priv->algorithm, &match_start, &match_end)) { while(gtk_events_pending()) gtk_main_iteration(); search_from = match_end; gchar *context = extract_context(buffer, &match_start, &match_end); gchar *location = g_strconcat(doctext->section, ": ", doctext->title, NULL); gtk_list_store_append(priv->results, &result); gtk_list_store_set(priv->results, &result, I7_RESULT_CONTEXT_COLUMN, context, I7_RESULT_SORT_STRING_COLUMN, doctext->sort, I7_RESULT_FILE_COLUMN, doctext->file, I7_RESULT_ANCHOR_COLUMN, doctext->anchor, I7_RESULT_RESULT_TYPE_COLUMN, doctext->is_recipebook? I7_RESULT_TYPE_RECIPE_BOOK : I7_RESULT_TYPE_DOCUMENTATION, I7_RESULT_LOCATION_COLUMN, location, I7_RESULT_EXAMPLE_TITLE_COLUMN, doctext->example_title, I7_RESULT_BACKGROUND_COLOR_COLUMN, doctext->is_recipebook? "#ffffe0" : "#ffffff", -1); g_free(context); g_free(location); } g_object_unref(buffer); }
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; };
void Gobby::OperationOpen::start() { m_iconv.reset(new Glib::IConv("UTF-8", m_encoding)); try { m_file->read_async(sigc::mem_fun( *this, &OperationOpen::on_file_read)); m_message_handle = get_status_bar().add_info_message( Glib::ustring::compose( _("Opening document \"%1\"..."), m_file->get_uri())); m_parent.signal_node_removed().connect( sigc::mem_fun( *this, &OperationOpen::on_node_removed)); m_content = GTK_TEXT_BUFFER(gtk_source_buffer_new(NULL)); } catch(const Gio::Error& err) { error(err.what()); } }
void GUI::add_program_file(gchar * filepath){ if (this->is_empty_notebook){ this->is_empty_notebook = false; gtk_notebook_remove_page(GTK_NOTEBOOK(this->programs_notebook), this->empty_notebook_index); } GuiNotebookItem notebook_item; notebook_item.vmachine = NULL; notebook_item.filepath = filepath; // netobook label notebook_item.notebook_label_text = this->extract_file_name(notebook_item.filepath); notebook_item.notebook_label = gtk_label_new (notebook_item.notebook_label_text); // create inner notebook vbox notebook_item.notebook_vbox = gtk_vbox_new(FALSE, 0); // create scrolled_window notebook_item.notebook_scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (notebook_item.notebook_scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (notebook_item.notebook_vbox), notebook_item.notebook_scrolled_window, TRUE, // vbox gives widget all remaining space TRUE, // widget expands to fill given space 0); // pixel of padding around the widget // create notebook_source_view notebook_item.source_buffer = gtk_source_buffer_new (NULL); notebook_item.source_view = gtk_source_view_new_with_buffer(notebook_item.source_buffer); gtk_container_add (GTK_CONTAINER (notebook_item.notebook_scrolled_window), notebook_item.source_view); gtk_source_view_set_auto_indent ( GTK_SOURCE_VIEW (notebook_item.source_view), TRUE); // make a tab be two spaces gtk_source_view_set_indent_width (GTK_SOURCE_VIEW (notebook_item.source_view), 2); gtk_source_view_set_highlight_current_line (GTK_SOURCE_VIEW (notebook_item.source_view), TRUE); gtk_source_view_set_show_line_numbers ( GTK_SOURCE_VIEW (notebook_item.source_view), TRUE); gtk_source_view_set_right_margin_position ( GTK_SOURCE_VIEW (notebook_item.source_view), 80); // default is 70 chars gtk_source_view_set_show_right_margin ( GTK_SOURCE_VIEW (notebook_item.source_view), TRUE); gtk_text_view_set_wrap_mode ( GTK_TEXT_VIEW (notebook_item.source_view), GTK_WRAP_WORD_CHAR); gtk_text_view_set_editable ( GTK_TEXT_VIEW (notebook_item.source_view), FALSE); gtk_text_view_set_cursor_visible ( GTK_TEXT_VIEW (notebook_item.source_view), FALSE); /* setup view */ PangoFontDescription * font_desc = NULL; font_desc = pango_font_description_from_string ("monospace"); if (font_desc != NULL){ gtk_widget_modify_font (notebook_item.source_view, font_desc); pango_font_description_free (font_desc); } // get file content gchar * buffer; GError * error_here = NULL; if (g_file_get_contents (notebook_item.filepath, &buffer, NULL, &error_here)){ gtk_source_buffer_begin_not_undoable_action (notebook_item.source_buffer); gtk_source_buffer_begin_not_undoable_action (notebook_item.source_buffer); gtk_text_buffer_set_text (GTK_TEXT_BUFFER (notebook_item.source_buffer), buffer, -1); gtk_source_buffer_end_not_undoable_action (notebook_item.source_buffer); gtk_text_buffer_set_modified (GTK_TEXT_BUFFER (notebook_item.source_buffer), FALSE); /* move cursor to the beginning */ gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (notebook_item.source_buffer), ¬ebook_item.iter); gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (notebook_item.source_buffer), ¬ebook_item.iter); { GtkTextIter start, end; char *text; gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (notebook_item.source_buffer), &start, &end); text = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (notebook_item.source_buffer), &start, &end, TRUE); g_assert (!strcmp (text, buffer)); g_free (text); } g_free (buffer); GtkWidget * vm_frame; vm_frame = gtk_frame_new ("VM operations"); // create buttons notebook_item.notebook_button_hbox = gtk_hbox_new (FALSE, 0); notebook_item.run_step_button = gtk_button_new_with_label ("Run Step"); notebook_item.run_button = gtk_button_new_with_label ("Run"); notebook_item.view_vm_mem = gtk_button_new_with_label ("View Vm memory"); // create time out input notebook_item.timeout_field = gtk_entry_new_with_max_length(10); GtkWidget * timeout_label; timeout_label = gtk_label_new("Timeout:"); g_signal_connect (notebook_item.run_step_button, "clicked", G_CALLBACK (GUI::run_step_button_clicked), gpointer(this)); g_signal_connect (notebook_item.run_button, "clicked", G_CALLBACK (GUI::run_button_clicked), gpointer(this)); g_signal_connect (notebook_item.view_vm_mem, "clicked", G_CALLBACK (GUI::view_vm_mem_clicked), gpointer(this)); gtk_box_pack_start (GTK_BOX (notebook_item.notebook_button_hbox), notebook_item.view_vm_mem, FALSE, // vbox gives widget all remaining space FALSE, // widget expands to fill given space 5); // pixel of padding around the widget gtk_box_pack_start (GTK_BOX (notebook_item.notebook_button_hbox), notebook_item.run_step_button, FALSE, // vbox gives widget all remaining space FALSE, // widget expands to fill given space 5); // pixel of padding around the widget gtk_box_pack_start (GTK_BOX (notebook_item.notebook_button_hbox), timeout_label, FALSE, // vbox gives widget all remaining space FALSE, // widget expands to fill given space 5); // pixel of padding around the widget gtk_box_pack_start (GTK_BOX (notebook_item.notebook_button_hbox), notebook_item.timeout_field, FALSE, // vbox gives widget all remaining space FALSE, // widget expands to fill given space 5); // pixel of padding around the widget gtk_box_pack_start (GTK_BOX (notebook_item.notebook_button_hbox), notebook_item.run_button, FALSE, // vbox gives widget all remaining space FALSE, // widget expands to fill given space 5); // pixel of padding around the widget gtk_container_add(GTK_CONTAINER (vm_frame), notebook_item.notebook_button_hbox); gtk_box_pack_start (GTK_BOX (notebook_item.notebook_vbox), vm_frame, FALSE, // vbox gives widget all remaining space FALSE, // widget expands to fill given space 5); gtk_notebook_append_page( GTK_NOTEBOOK(this->programs_notebook), notebook_item.notebook_vbox, notebook_item.notebook_label); this->gui_notebook_item_list.push_back(notebook_item); gtk_widget_show_all(this->programs_notebook); } else { g_print("WRONG \n"); } }
static void extension_search_result(GFile *parent, GFileInfo *info, gpointer unused, I7SearchWindow *self) { I7_SEARCH_WINDOW_USE_PRIVATE(self, priv); GError *err = NULL; const char *basename = g_file_info_get_name(info); GFile *file = g_file_get_child(parent, basename); char *contents; GtkTextBuffer *buffer; GtkTreeIter result; GtkTextIter search_from, match_start, match_end; if(!g_file_load_contents(file, NULL, &contents, NULL, NULL, &err)) { char *author_display_name = file_get_display_name(parent); const char *ext_display_name = g_file_info_get_display_name(info); error_dialog_file_operation(GTK_WINDOW(self), file, err, I7_FILE_ERROR_OTHER, /* TRANSLATORS: Error opening EXTENSION_NAME by AUTHOR_NAME */ _("Error opening extension '%s' by '%s':"), author_display_name, ext_display_name); g_free(author_display_name); g_object_unref(file); return; } buffer = GTK_TEXT_BUFFER(gtk_source_buffer_new(NULL)); gtk_text_buffer_set_text(buffer, contents, -1); g_free(contents); gtk_text_buffer_get_start_iter(buffer, &search_from); start_spinner(self); while(find_no_wrap(&search_from, priv->text, TRUE, GTK_SOURCE_SEARCH_TEXT_ONLY | (priv->ignore_case? GTK_SOURCE_SEARCH_CASE_INSENSITIVE : 0), priv->algorithm, &match_start, &match_end)) { unsigned lineno; char *sort, *context; while(gtk_events_pending()) gtk_main_iteration(); search_from = match_end; /* Get the line number (counted from 0) */ lineno = gtk_text_iter_get_line(&match_start) + 1; context = extract_context(buffer, &match_start, &match_end); /* Make a sort string */ sort = g_strdup_printf("%s %04i", basename, lineno); gtk_list_store_append(priv->results, &result); gtk_list_store_set(priv->results, &result, I7_RESULT_CONTEXT_COLUMN, context, I7_RESULT_SORT_STRING_COLUMN, sort, I7_RESULT_FILE_COLUMN, file, I7_RESULT_RESULT_TYPE_COLUMN, I7_RESULT_TYPE_EXTENSION, I7_RESULT_LINE_NUMBER_COLUMN, lineno, -1); g_free(context); g_free(sort); } stop_spinner(self); g_object_unref(buffer); g_object_unref(file); }
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[]) { GtkSourceBuffer *buffer; GtkSourceSearchContext *search_context; GtkSourceSearchSettings *search_settings; GtkTextIter iter; GtkTextIter match_end; GTimer *timer; gint i; GtkTextSearchFlags flags; gchar *regex_pattern; gtk_init (&argc, &argv); buffer = gtk_source_buffer_new (NULL); gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter); for (i = 0; i < NB_LINES; i++) { gtk_text_buffer_insert (GTK_TEXT_BUFFER (buffer), &iter, "A line of text to fill the text buffer. Is it long enough?\n", -1); } gtk_text_buffer_insert (GTK_TEXT_BUFFER (buffer), &iter, "foo\n", -1); /* Basic search, no flags */ timer = g_timer_new (); gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter); flags = 0; while (gtk_text_iter_forward_search (&iter, "foo", flags, NULL, &match_end, NULL)) { iter = match_end; } g_timer_stop (timer); g_print ("basic forward search, no flags: %lf seconds.\n", g_timer_elapsed (timer, NULL)); /* Basic search, with flags always enabled by gsv */ g_timer_start (timer); gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter); flags = GTK_TEXT_SEARCH_VISIBLE_ONLY | GTK_TEXT_SEARCH_TEXT_ONLY; while (gtk_text_iter_forward_search (&iter, "foo", flags, NULL, &match_end, NULL)) { iter = match_end; } g_timer_stop (timer); g_print ("basic forward search, visible and text only flags: %lf seconds.\n", g_timer_elapsed (timer, NULL)); /* Basic search, with default flags in gsv */ g_timer_start (timer); gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter); flags = GTK_TEXT_SEARCH_VISIBLE_ONLY | GTK_TEXT_SEARCH_TEXT_ONLY | GTK_TEXT_SEARCH_CASE_INSENSITIVE; while (gtk_text_iter_forward_search (&iter, "foo", flags, NULL, &match_end, NULL)) { iter = match_end; } g_timer_stop (timer); g_print ("basic forward search, all flags: %lf seconds.\n", g_timer_elapsed (timer, NULL)); /* Smart forward search, with default flags in gsv */ search_settings = gtk_source_search_settings_new (); search_context = gtk_source_search_context_new (buffer, search_settings); g_timer_start (timer); gtk_source_search_settings_set_search_text (search_settings, "foo"); gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter); while (gtk_source_search_context_forward (search_context, &iter, NULL, &match_end, NULL)) { iter = match_end; } g_timer_stop (timer); g_print ("smart synchronous forward search, case insensitive: %lf seconds.\n", g_timer_elapsed (timer, NULL)); /* Smart forward search, case sensitive */ g_timer_start (timer); gtk_source_search_settings_set_search_text (search_settings, NULL); gtk_source_search_settings_set_case_sensitive (search_settings, TRUE); gtk_source_search_settings_set_search_text (search_settings, "foo"); gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter); while (gtk_source_search_context_forward (search_context, &iter, NULL, &match_end, NULL)) { iter = match_end; } g_timer_stop (timer); g_print ("smart synchronous forward search, case sensitive: %lf seconds.\n", g_timer_elapsed (timer, NULL)); /* Regex search: search "foo" */ g_timer_start (timer); gtk_source_search_settings_set_search_text (search_settings, NULL); gtk_source_search_settings_set_regex_enabled (search_settings, TRUE); gtk_source_search_settings_set_search_text (search_settings, "foo"); gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter); while (gtk_source_search_context_forward (search_context, &iter, NULL, &match_end, NULL)) { iter = match_end; } g_timer_stop (timer); g_print ("regex search: 'foo' (no partial matches): %lf seconds.\n", g_timer_elapsed (timer, NULL)); /* Regex search: search "fill" */ g_timer_start (timer); gtk_source_search_settings_set_search_text (search_settings, "fill"); gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter); while (gtk_source_search_context_forward (search_context, &iter, NULL, &match_end, NULL)) { iter = match_end; } g_timer_stop (timer); g_print ("regex search: 'fill' (no partial matches): %lf seconds.\n", g_timer_elapsed (timer, NULL)); /* Regex search: search single lines */ g_timer_start (timer); gtk_source_search_settings_set_search_text (search_settings, ".*"); gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter); while (gtk_source_search_context_forward (search_context, &iter, NULL, &match_end, NULL)) { iter = match_end; } g_timer_stop (timer); g_print ("regex search: match single lines (no partial matches): %lf seconds.\n", g_timer_elapsed (timer, NULL)); /* Regex search: search matches of 3 lines */ g_timer_start (timer); /* The space at the beginning of the pattern permits to not have contiguous * matches. There is a performance issue with contiguous matches. */ gtk_source_search_settings_set_search_text (search_settings, " (.*\n){3}"); gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter); while (gtk_source_search_context_forward (search_context, &iter, NULL, &match_end, NULL)) { iter = match_end; } g_timer_stop (timer); g_print ("regex search: matches of 3 lines (small partial matches): %lf seconds.\n", g_timer_elapsed (timer, NULL)); /* Regex search: search matches of really big chunks */ g_timer_start (timer); regex_pattern = g_strdup_printf (" (.*\n){%d}", NB_LINES / 10); gtk_source_search_settings_set_search_text (search_settings, regex_pattern); g_free (regex_pattern); gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter); while (gtk_source_search_context_forward (search_context, &iter, NULL, &match_end, NULL)) { iter = match_end; } g_timer_stop (timer); g_print ("regex search: 10 matches of %d lines (big partial matches): %lf seconds.\n", NB_LINES / 10, g_timer_elapsed (timer, NULL)); /* Smart search, case sensitive, asynchronous */ /* The asynchronous overhead doesn't depend on the search flags, it * depends on the maximum number of lines to scan in one batch, and * (obviously), on the buffer size. * You can tune SCAN_BATCH_SIZE in gtksourcesearchcontext.c to see a * difference in the overhead. */ g_signal_connect (search_context, "notify::occurrences-count", G_CALLBACK (on_notify_search_occurrences_count_cb), timer); g_timer_start (timer); gtk_source_search_settings_set_search_text (search_settings, NULL); gtk_source_search_settings_set_regex_enabled (search_settings, FALSE); gtk_source_search_settings_set_search_text (search_settings, "foo"); gtk_main (); return 0; }
/** * 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; }
GUIEditor * gui_editor_new (void) { GUIEditor *self; GPtrArray *dirs; const gchar * const *current_search_path; gchar **lang_spec_search_path; self = g_malloc0 (sizeof (GUIEditor)); self->buffer = gtk_source_buffer_new (NULL); self->widget = gtk_source_view_new_with_buffer (self->buffer); self->scroll = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (self->scroll), self->widget); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (self->scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gui_editor_set_font (self, DEFAULT_EDITOR_FONT); self->hltag = gtk_text_buffer_create_tag (GTK_TEXT_BUFFER(self->buffer), HIGHLIGHT_TAG, "background", COLOUR_BG_HL, NULL); self->lang_manager = gtk_source_language_manager_new (); self->style_scheme_manager = gtk_source_style_scheme_manager_get_default (); dirs = g_ptr_array_new(); current_search_path = gtk_source_language_manager_get_search_path(self->lang_manager); for (; current_search_path != NULL && *current_search_path != NULL; ++current_search_path) g_ptr_array_add(dirs, g_strdup(*current_search_path)); // look for spec file in our own directory g_ptr_array_add(dirs, g_strdup(PACKAGE_DATA_DIR)); // look for spec file in data directory when running from svn g_ptr_array_add(dirs, g_strdup("data")); // look for spec file in current directory, when running on windows g_ptr_array_add(dirs, g_strdup(".")); g_ptr_array_add(dirs, g_strdup(NULL)); lang_spec_search_path = (gchar **)g_ptr_array_free(dirs, FALSE); gtk_source_language_manager_set_search_path (self->lang_manager, lang_spec_search_path); gtk_source_style_scheme_manager_append_search_path (self->style_scheme_manager, "data"); gtk_source_style_scheme_manager_append_search_path (self->style_scheme_manager, "."); #if GTK_CHECK_VERSION(3, 0, 0) GtkSourceMarkAttributes *mark_attributes = gtk_source_mark_attributes_new (); gtk_source_mark_attributes_set_icon_name (mark_attributes, "gtk-no"); gtk_source_view_set_mark_attributes (GTK_SOURCE_VIEW (self->widget), MARKER_BREAKPOINT, mark_attributes, 0); #else GdkPixbuf *pixbuf; pixbuf = gui_editor_get_stock_icon (GTK_WIDGET(self->widget), GTK_STOCK_NO, GTK_ICON_SIZE_MENU); if (pixbuf) { gtk_source_view_set_mark_category_icon_from_pixbuf (GTK_SOURCE_VIEW (self->widget), MARKER_BREAKPOINT, pixbuf); g_object_unref (pixbuf); } #endif return self; }