void peacock_file_select_all (PeacockFile *file) { GtkTextIter start; GtkTextIter end; g_return_if_fail (file != NULL); g_return_if_fail (PEACOCK_IS_FILE (file)); /* Get start and end iters */ gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (file), &start, &end); /* Select all the text. */ peacock_file_set_selection (PEACOCK_FILE (file), &start, &end); }
void on_save_operation_finished(bool success) { GtkTextBuffer* buffer = GTK_TEXT_BUFFER(m_view.get_text_buffer()); if(success) m_sync_time = m_save_op->get_start_time(); m_save_op = NULL; // Schedule the next save operation in case the buffer has // been modified since the save operation was started. if(gtk_text_buffer_get_modified(buffer)) schedule(); }
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); }
static void remove_tag_to_word (PlumaAutomaticSpellChecker *spell, const gchar *word) { GtkTextIter iter; GtkTextIter match_start, match_end; gboolean found; gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (spell->doc), &iter, 0); found = TRUE; while (found) { found = gtk_text_iter_forward_search (&iter, word, GTK_TEXT_SEARCH_VISIBLE_ONLY | GTK_TEXT_SEARCH_TEXT_ONLY, &match_start, &match_end, NULL); if (found) { if (gtk_text_iter_starts_word (&match_start) && gtk_text_iter_ends_word (&match_end)) { gtk_text_buffer_remove_tag (GTK_TEXT_BUFFER (spell->doc), spell->tag_highlight, &match_start, &match_end); } iter = match_end; } } }
void gui_editor_toggle_mark (GUIEditor * self) { g_assert (self); gint y_buf; GtkTextIter line_start, line_end; GtkTextMark *insert; GSList *marker_list; GtkSourceMark *marker; insert = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER(self->buffer)); gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER(self->buffer), &(self->iter), insert); y_buf = gtk_text_iter_get_line(&(self->iter)); /* get line bounds */ gtk_text_buffer_get_iter_at_line (GTK_TEXT_BUFFER (self->buffer), &line_start, y_buf); line_end = line_start; gtk_text_iter_forward_to_line_end (&line_end); /* get the breakpoint markers already in the line */ marker_list = gtk_source_buffer_get_source_marks_at_line (self->buffer, y_buf, MARKER_BREAKPOINT); if (marker_list != NULL && g_slist_length(marker_list)!=0) { /* markers were found, so delete them */ gtk_source_buffer_remove_source_marks (self->buffer, &line_start, &line_end, MARKER_BREAKPOINT); } else { /* no marker found -> create one */ marker = gtk_source_buffer_create_source_mark (self->buffer, NULL, MARKER_BREAKPOINT, &(self->iter)); } g_slist_free (marker_list); }
static void text_open_callback (GnomeVFSAsyncHandle *handle, GnomeVFSResult result, gpointer cdata) { gchar *buffer; g_return_if_fail (GTK_IS_TEXT_BUFFER (cdata)); if (result != GNOME_VFS_OK) { gchar *message; message = g_strdup_printf ("Error: %s", gnome_vfs_result_to_string (result)); g_return_if_fail (message != NULL); gtk_text_buffer_set_text (GTK_TEXT_BUFFER(cdata), message, -1); g_free (message); } buffer = g_new (gchar, TEXT_BUFFER_SIZE); g_return_if_fail (buffer != NULL); gtk_text_buffer_create_tag (GTK_TEXT_BUFFER(cdata), "default-tag", "font", "terminal 10", NULL); gnome_vfs_async_read (handle, buffer, TEXT_BUFFER_SIZE, text_read_callback, cdata); }
void Gobby::StatusBar::on_document_removed(SessionView& view) { if(m_current_view == &view) { GtkTextBuffer* buffer = GTK_TEXT_BUFFER( m_current_view->get_text_buffer()); g_signal_handler_disconnect(buffer, m_mark_set_handler); g_signal_handler_disconnect(buffer, m_changed_handler); g_signal_handler_disconnect(m_current_view->get_text_view(), m_toverwrite_handler); m_current_view = NULL; } }
void gb_color_picker_document_monitor_set_color_tag_at_cursor (GbColorPickerDocumentMonitor *self, GstyleColor *color) { GtkTextMark *insert; GtkTextIter cursor; g_return_if_fail (GB_IS_COLOR_PICKER_DOCUMENT_MONITOR (self)); g_return_if_fail (GSTYLE_IS_COLOR (color)); g_return_if_fail (self->buffer != NULL); insert = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER(self->buffer)); gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER(self->buffer), &cursor, insert); if (!self->is_in_user_action) { gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER (self->buffer)); self->is_in_user_action = TRUE; } block_signals (self, self->buffer); gb_color_picker_helper_set_color_tag_at_iter (&cursor, color, TRUE); unblock_signals (self, self->buffer); }
static void ide_xml_highlighter_bind_buffer_cb (IdeXmlHighlighter *self, IdeBuffer *buffer, EggSignalGroup *group) { GtkTextIter begin; g_assert (IDE_IS_XML_HIGHLIGHTER (self)); g_assert (IDE_IS_BUFFER (buffer)); g_assert (EGG_IS_SIGNAL_GROUP (group)); ide_set_weak_pointer (&self->buffer, GTK_TEXT_BUFFER (buffer)); gtk_text_buffer_get_start_iter (self->buffer, &begin); self->iter_mark = gtk_text_buffer_create_mark (self->buffer, NULL, &begin, TRUE); }
G_MODULE_EXPORT void on_menu_edit_activate(GtkWidget *widget, void *user) { if (g_active_editor == NULL) return; if (gtk_text_buffer_get_has_selection (GTK_TEXT_BUFFER(g_active_editor->buffer))) { gtk_widget_set_sensitive(GTK_WIDGET(gui->menugui->menu_cut), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(gui->menugui->menu_copy), TRUE); return; } gtk_widget_set_sensitive(GTK_WIDGET(gui->menugui->menu_cut), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(gui->menugui->menu_copy), FALSE); }
static void text_buffer_undo_delete_text (GObject *object, gint position_start, gint position_end) { GtkTextBuffer *text_buffer; GtkTextIter start_iter, end_iter; g_return_if_fail (GTK_IS_TEXT_BUFFER (object)); text_buffer = GTK_TEXT_BUFFER (object); gtk_text_buffer_get_iter_at_offset (text_buffer, &start_iter, position_start); gtk_text_buffer_get_iter_at_offset (text_buffer, &end_iter, position_end); gtk_text_buffer_delete (text_buffer, &start_iter, &end_iter); }
static void gimp_text_style_editor_color_changed (GimpColorButton *button, GimpTextStyleEditor *editor) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER (editor->buffer); GtkTextIter start, end; GimpRGB color; if (! gtk_text_buffer_get_selection_bounds (buffer, &start, &end)) { return; } gimp_color_button_get_color (button, &color); gimp_text_buffer_set_color (editor->buffer, &start, &end, &color); }
static void gimp_text_style_editor_font_changed (GimpContext *context, GimpFont *font, GimpTextStyleEditor *editor) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER (editor->buffer); GtkTextIter start, end; if (! gtk_text_buffer_get_selection_bounds (buffer, &start, &end)) { return; } gimp_text_buffer_set_font (editor->buffer, &start, &end, gimp_context_get_font_name (context)); }
static void widget_undo_place_cursor_at (GObject *object, gint char_pos) { if (GTK_IS_EDITABLE (object)) gtk_editable_set_position (GTK_EDITABLE (object), char_pos); else if (GTK_IS_TEXT_BUFFER (object)) { GtkTextBuffer *buffer; GtkTextIter pos; buffer = GTK_TEXT_BUFFER (object); gtk_text_buffer_get_iter_at_offset (buffer, &pos, char_pos); gtk_text_buffer_place_cursor (buffer, &pos); } }
bool Gobby::FindDialog::replace_all() { // TODO: Add helper function to get textsessionview? Maybe even add // to Folder? SessionView* view = m_folder->get_current_document(); TextSessionView* text_view = dynamic_cast<TextSessionView*>(view); g_assert(text_view != NULL); GtkTextIter begin; GtkTextBuffer* buffer = GTK_TEXT_BUFFER(text_view->get_text_buffer()); gtk_text_buffer_get_start_iter(buffer, &begin); unsigned int replace_count = 0; GtkTextIter match_start, match_end; while(find_range(&begin, NULL, SEARCH_FORWARD, &match_start, &match_end)) { Glib::ustring replace_text = get_replace_text(); gtk_text_buffer_delete(buffer, &match_start, &match_end); gtk_text_buffer_insert(buffer, &match_start, replace_text.c_str(), replace_text.bytes()); ++ replace_count; begin = match_start; } Glib::ustring message; bool result; if(replace_count == 0) { message = _("No occurrence has been replaced"); result = false; } else { message = Glib::ustring::compose( ngettext("%1 occurrence has been replaced", "%1 occurrences have been replaced", replace_count), replace_count); result = true; } m_status_bar->add_info_message(message, 5); return result; }
void gimp_text_tool_editor_button_press (GimpTextTool *text_tool, gdouble x, gdouble y, GimpButtonPressType press_type) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer); GtkTextIter cursor; GtkTextIter selection; gimp_text_tool_xy_to_iter (text_tool, x, y, &cursor); selection = cursor; text_tool->select_start_iter = cursor; text_tool->select_words = FALSE; text_tool->select_lines = FALSE; switch (press_type) { case GIMP_BUTTON_PRESS_NORMAL: gtk_text_buffer_place_cursor (buffer, &cursor); break; case GIMP_BUTTON_PRESS_DOUBLE: text_tool->select_words = TRUE; if (! gtk_text_iter_starts_word (&cursor)) gtk_text_iter_backward_visible_word_starts (&cursor, 1); if (! gtk_text_iter_ends_word (&selection) && ! gtk_text_iter_forward_visible_word_ends (&selection, 1)) gtk_text_iter_forward_to_line_end (&selection); gtk_text_buffer_select_range (buffer, &cursor, &selection); break; case GIMP_BUTTON_PRESS_TRIPLE: text_tool->select_lines = TRUE; gtk_text_iter_set_line_offset (&cursor, 0); gtk_text_iter_forward_to_line_end (&selection); gtk_text_buffer_select_range (buffer, &cursor, &selection); break; } }
GtkTextTag * gimp_text_buffer_get_color_tag (GimpTextBuffer *buffer, const GimpRGB *color) { GList *list; GtkTextTag *tag; gchar name[256]; GdkColor gdk_color; guchar r, g, b; gimp_rgb_get_uchar (color, &r, &g, &b); for (list = buffer->color_tags; list; list = g_list_next (list)) { GimpRGB tag_color; guchar tag_r, tag_g, tag_b; tag = list->data; gimp_text_tag_get_color (tag, &tag_color); gimp_rgb_get_uchar (&tag_color, &tag_r, &tag_g, &tag_b); /* Do not compare the alpha channel, since it's unused */ if (tag_r == r && tag_g == g && tag_b == b) { return tag; } } g_snprintf (name, sizeof (name), "color-#%02x%02x%02x", r, g, b); gimp_rgb_get_gdk_color (color, &gdk_color); tag = gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (buffer), name, "foreground-gdk", &gdk_color, "foreground-set", TRUE, NULL); buffer->color_tags = g_list_prepend (buffer->color_tags, tag); return tag; }
static GtkWidget* mk_page_main (t_tea_project *p) { GtkWidget *page = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (page); ent_project_name = tea_text_entry (GTK_WIDGET(page), _("Project name"), p->project_name); ent_dir_makefile = tea_dir_selector (page, _("Makefile directory"), p->dir_makefile); ent_dir_source = tea_dir_selector (page, _("Source directory"), p->dir_source); ent_file_executable = tea_text_entry (page, _("Target executable"), p->file_executable); gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(buffer_projet), "\n\n", -1); gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(buffer_projet), "\nfile_executable=", -1); gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(buffer_projet), p->file_executable, -1); gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(buffer_projet), "\nproject_name=", -1); gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(buffer_projet), p->project_name, -1); gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(buffer_projet), "\ndir_makefile=", -1); gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(buffer_projet), p->dir_makefile, -1); gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(buffer_projet), "\ndir_source=", -1); gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(buffer_projet), p->dir_source, -1); return page; }
static void saved_query_info_cb (GFile *location, GAsyncResult *result, GeditDocument *doc) { GeditDocumentPrivate *priv; GFileInfo *info; const gchar *content_type = NULL; GError *error = NULL; priv = gedit_document_get_instance_private (doc); info = g_file_query_info_finish (location, result, &error); if (error != NULL) { g_warning ("Document saving: query info error: %s", error->message); g_error_free (error); error = NULL; } if (info != NULL && g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE)) { content_type = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE); } set_content_type (doc, content_type); if (info != NULL) { /* content_type (owned by info) is no longer needed. */ g_object_unref (info); } g_get_current_time (&priv->time_of_last_save_or_load); priv->create = FALSE; gtk_text_buffer_set_modified (GTK_TEXT_BUFFER (doc), FALSE); save_encoding_metadata (doc); /* Async operation finished. */ g_object_unref (doc); }
/* * Deletion and external modification is only checked for local files. */ gboolean _gedit_document_needs_saving (GeditDocument *doc) { g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE); if (gtk_text_buffer_get_modified (GTK_TEXT_BUFFER (doc))) { return TRUE; } if (gedit_document_is_local (doc)) { check_file_on_disk (doc); } return (doc->priv->externally_modified || doc->priv->deleted) && !doc->priv->create; }
static GtkTextTag * create_tag_from_style (IdeHighlightEngine *self, const gchar *style_name) { GtkSourceStyleScheme *style_scheme; GtkTextTag *tag; g_assert (IDE_IS_HIGHLIGHT_ENGINE (self)); g_assert (IDE_IS_BUFFER (self->buffer)); g_assert (style_name != NULL); tag = gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (self->buffer), style_name, NULL); style_scheme = gtk_source_buffer_get_style_scheme (GTK_SOURCE_BUFFER (self->buffer)); sync_tag_style (style_scheme, tag); return tag; }
Gobby::OperationSave::OperationSave(Operations& operations, TextSessionView& view, const Glib::RefPtr<Gio::File>& file, const std::string& encoding, DocumentInfoStorage::EolStyle eol_style): Operation(operations), m_file(file), m_view(&view), m_start_time(std::time(NULL)), m_current_line_index(0), m_encoding(encoding), m_eol_style(eol_style), m_storage_key(view.get_info_storage_key()), m_iconv(encoding.c_str(), "UTF-8"), m_buffer_size(0), m_buffer_index(0) { const Folder& folder = get_folder_manager().get_text_folder(); folder.signal_document_removed().connect( sigc::mem_fun(*this, &OperationSave::on_document_removed)); // Load content so that the session can go on while saving GtkTextBuffer* buffer = GTK_TEXT_BUFFER(view.get_text_buffer()); GtkTextIter prev; GtkTextIter pos; GtkTextIter old_pos; gtk_text_buffer_get_start_iter(buffer, &prev); pos = prev; if(!gtk_text_iter_ends_line(&pos)) gtk_text_iter_forward_to_line_end(&pos); do { Line line; line.first = gtk_text_buffer_get_text(buffer, &prev, &pos, TRUE); line.second = gtk_text_iter_get_line_index(&pos); m_lines.push_back(line); //if(gtk_text_iter_is_end(&prev)) // break; old_pos = pos; gtk_text_iter_forward_line(&prev); gtk_text_iter_forward_to_line_end(&pos); } while(!gtk_text_iter_equal(&pos, &old_pos)); m_current_line = m_lines.begin(); }
void buffer_to_pdf (Ebook * ebook) { GtkTextBuffer * buffer; GtkTextIter start, end; Pqueue queue; gchar * size, *editor_font; /* A4 initial */ queue.ebook = ebook; queue.pos = 0; queue.page_count = 1; queue.width = 8.3 * POINTS; queue.height = 11.7 * POINTS; queue.page_height = 40.0; g_return_if_fail (ebook); g_return_if_fail (ebook->filename); size = gconf_client_get_string (ebook->client, ebook->paper_size.key, NULL); buffer = GTK_TEXT_BUFFER(gtk_builder_get_object (ebook->builder, "textbuffer1")); queue.progressbar = GTK_PROGRESS_BAR(gtk_builder_get_object (ebook->builder, "progressbar")); queue.statusbar = GTK_STATUSBAR(gtk_builder_get_object (ebook->builder, "statusbar")); gtk_text_buffer_get_bounds (buffer, &start, &end); queue.text = g_strdup(gtk_text_buffer_get_text (buffer, &start, &end, TRUE)); editor_font = gconf_client_get_string(ebook->client, ebook->editor_font.key, NULL); if (0 == g_strcmp0 (size, "A5")) { queue.width = a5_width * POINTS; queue.height = a5_height * POINTS; } if (0 == g_strcmp0 (size, "B5")) { queue.width = b5_width * POINTS; queue.height = b5_height * POINTS; } queue.surface = cairo_pdf_surface_create (ebook->filename, queue.width, queue.height); queue.cr = cairo_create (queue.surface); queue.context = pango_cairo_create_context (queue.cr); /* pango_cairo_create_layout is wasteful with a lot of text. */ queue.desc = pango_font_description_from_string (editor_font); queue.layout = make_new_page (queue.context, queue.desc, queue.height, queue.width); pango_layout_set_text (queue.layout, queue.text, -1); cairo_move_to (queue.cr, SIDE_MARGIN / 2, EDGE_MARGIN / 2); gtk_progress_bar_set_fraction (queue.progressbar, 0.0); queue.lines_per_page = pango_layout_get_line_count (queue.layout); queue.iter = pango_layout_get_iter (queue.layout); create_pages (&queue); }
void gimp_text_tool_editor_button_release (GimpTextTool *text_tool) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer); if (gtk_text_buffer_get_has_selection (buffer)) { GimpTool *tool = GIMP_TOOL (text_tool); GimpDisplayShell *shell = gimp_display_get_shell (tool->display); GtkClipboard *clipboard; clipboard = gtk_widget_get_clipboard (GTK_WIDGET (shell), GDK_SELECTION_PRIMARY); gtk_text_buffer_copy_clipboard (buffer, clipboard); } }
static VALUE rg_wait_for_rich_text(VALUE self, VALUE buffer) { GdkAtom format; gsize length; guint8* data = gtk_clipboard_wait_for_rich_text(_SELF(self), GTK_TEXT_BUFFER(RVAL2GOBJ(buffer)), &format, &length); if (data){ VALUE str = rb_str_new((char*)data, length); g_free(data); return rb_assoc_new(str, BOXED2RVAL(format, GDK_TYPE_ATOM)); } else { return rb_assoc_new(Qnil, BOXED2RVAL(format, GDK_TYPE_ATOM)); } }
static void gimp_text_tool_change_size (GimpTextTool *text_tool, gdouble amount) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer); GtkTextIter start; GtkTextIter end; if (! gtk_text_buffer_get_selection_bounds (buffer, &start, &end)) { return; } gtk_text_iter_order (&start, &end); gimp_text_buffer_change_size (text_tool->buffer, &start, &end, amount * PANGO_SCALE); }
void iofunctions_save_file (GuIOFunc* io, gchar* filename, gchar *text) { gchar* status = NULL; status = g_strdup_printf (_("Saving %s..."), filename); statusbar_set_message (status); g_free (status); GObject *savecontext = g_object_new(G_TYPE_OBJECT, NULL); g_object_set_data (savecontext, "filename", filename); g_object_set_data (savecontext, "text", text); g_signal_emit_by_name (io->sig_hook, "document-write", savecontext); gtk_text_buffer_set_modified (GTK_TEXT_BUFFER(gummi_get_active_editor()->buffer), FALSE); }
/** runs once per page */ static void set_text (Ebook * ebook, gchar * text, gboolean lines_state, gboolean page_state, gboolean hyphens_state) { GtkTextView * textview; GtkTextBuffer * buffer; GtkTextIter start, end; gssize size, old; GError * err; err = NULL; if (lines_state) text = g_regex_replace (ebook->line, text, -1, 0, " \\1",0 , &err); if (err) g_warning ("line replace: %s", err->message); if (page_state) text = g_regex_replace_literal (ebook->page, text, -1, 0, " ",0 , &err); if (err) g_warning ("page replace: %s", err->message); if (hyphens_state) text = g_regex_replace (ebook->hyphen, text, -1, 0, "\\1",0 , &err); if (err) g_warning ("hyphen replace: %s", err->message); if (!ebook->builder) ebook->builder = load_builder_xml (NULL); if (!ebook->builder) return; old = strlen (text); text = g_utf8_normalize (text, old, G_NORMALIZE_ALL); size = strlen (text); if (size < old) ebook->utf8_count += (old - size); textview = GTK_TEXT_VIEW(gtk_builder_get_object (ebook->builder, "textview")); buffer = GTK_TEXT_BUFFER(gtk_builder_get_object (ebook->builder, "textbuffer1")); gtk_text_buffer_get_bounds (buffer, &start, &end); if ((text != NULL) && (g_utf8_validate (text, size, NULL))) { gtk_text_buffer_insert (buffer, &end, text, size); gtk_text_buffer_set_modified (buffer, TRUE); } gtk_widget_show (GTK_WIDGET(textview)); }
/* Search the project file for the string 'text' */ void i7_search_window_search_project(I7SearchWindow *self) { I7_SEARCH_WINDOW_USE_PRIVATE(self, priv); GtkTreeIter result; GtkTextIter search_from, match_start, match_end; GtkTextBuffer *buffer = GTK_TEXT_BUFFER(i7_document_get_buffer(priv->document)); 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)) { while(gtk_events_pending()) gtk_main_iteration(); search_from = match_end; /* Get the line number (counted from 0) */ guint lineno = gtk_text_iter_get_line(&match_start) + 1; gchar *context = extract_context(buffer, &match_start, &match_end); /* Make a sort string */ gchar *sort = g_strdup_printf("%04i", lineno); /* Put the full path to the project in */ GFile *file = i7_document_get_file(priv->document); 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_PROJECT, I7_RESULT_LINE_NUMBER_COLUMN, lineno, -1); g_free(context); g_free(sort); g_object_unref(file); } stop_spinner(self); }
void iofunctions_load_default_text (gboolean loopedonce) { GError* readerr = NULL; GError* copyerr = NULL; gchar* text = NULL; GuEditor* ec = gummi_get_active_editor(); if (!g_file_get_contents (C_WELCOMETEXT, &text, NULL, &readerr)) { slog (L_WARNING, "Could not find default welcome text, resetting..\n"); utils_copy_file (C_DEFAULTTEXT, C_WELCOMETEXT, ©err); if (!loopedonce) return iofunctions_load_default_text (TRUE); } if (text) editor_fill_buffer (ec, text); gtk_text_buffer_set_modified (GTK_TEXT_BUFFER (ec->buffer), FALSE); g_free (text); }