Exemple #1
0
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();
	}
Exemple #3
0
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;
		}
	}
}
Exemple #5
0
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);
	
}
Exemple #6
0
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);
}
Exemple #7
0
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);
}
Exemple #10
0
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);
}
Exemple #11
0
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);
}
Exemple #12
0
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);
}
Exemple #13
0
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));
}
Exemple #14
0
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);
	}
}
Exemple #15
0
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;
}
Exemple #16
0
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;
    }
}
Exemple #17
0
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;
}
Exemple #18
0
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;
}
Exemple #19
0
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);
}
Exemple #20
0
/*
 * 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;
}
Exemple #22
0
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();
}
Exemple #23
0
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);
}
Exemple #24
0
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);
    }
}
Exemple #25
0
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));
    }

}
Exemple #26
0
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);
}
Exemple #27
0
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);
}
Exemple #28
0
/** 
 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));
}
Exemple #29
0
/* 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);
}
Exemple #30
0
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, &copyerr);
        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);
}