static void
gtk_text_mark_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
gchar *tmp;
GtkTextMark *mark = GTK_TEXT_MARK (object);
GtkTextLineSegment *seg = mark->segment;
switch (prop_id)
{
case PROP_NAME:
tmp = seg->body.mark.name;
seg->body.mark.name = g_value_dup_string (value);
g_free (tmp);
break;
case PROP_LEFT_GRAVITY:
if (g_value_get_boolean (value))
seg->type = >k_text_left_mark_type;
else
seg->type = >k_text_right_mark_type;
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
on_delete_range (GtkTextBuffer *buffer,
GtkTextIter *start,
GtkTextIter *end,
gpointer user_data)
{
GtkTextIter iter;
GSList *marks;
GSList *item;
iter = *start;
/* move to start of line */
gtk_text_iter_set_line_offset (&iter, 0);
/* remove any bookmarks that are collapsed on each other due to this */
marks = gtk_source_buffer_get_source_marks_at_iter (GTK_SOURCE_BUFFER (buffer),
&iter,
BOOKMARK_CATEGORY);
if (marks == NULL)
return;
/* remove all but the first mark */
for (item = marks->next; item; item = item->next)
gtk_text_buffer_delete_mark (buffer, GTK_TEXT_MARK (item->data));
g_slist_free (marks);
}
static void
gtk_text_mark_finalize (GObject *obj)
{
GtkTextMark *mark;
GtkTextLineSegment *seg;
mark = GTK_TEXT_MARK (obj);
seg = mark->segment;
if (seg)
{
if (seg->body.mark.tree != NULL)
g_warning ("GtkTextMark being finalized while still in the buffer; "
"someone removed a reference they didn't own! Crash "
"impending");
g_free (seg->body.mark.name);
g_free (seg);
mark->segment = NULL;
}
/* chain parent_class' handler */
G_OBJECT_CLASS (gtk_text_mark_parent_class)->finalize (obj);
}
void snippets_activate (GuSnippets* sc, GuEditor* ec, gchar* key) {
gchar* snippet = NULL;
GuSnippetInfo* new_info = NULL;
GtkTextIter start, end;
slog (L_DEBUG, "Snippet `%s' activated\n", key);
snippet = snippets_get_value (sc, key);
g_return_if_fail (snippet != NULL);
new_info = snippets_parse (snippet);
gtk_text_buffer_get_selection_bounds (ec_buffer, &start, &end);
new_info->start_offset = gtk_text_iter_get_offset (&start);
new_info->sel_text = gtk_text_iter_get_text (&start, &end);
GSList* marks = gtk_text_iter_get_marks (&start);
new_info->sel_start = *GTK_TEXT_MARK (marks->data);
g_slist_free (marks);
gtk_text_buffer_insert (ec_buffer, &start, new_info->expanded, -1);
snippet_info_create_marks (new_info, ec);
snippet_info_initial_expand (new_info, ec);
gtk_text_buffer_set_modified (ec_buffer, TRUE);
if (sc->info) {
snippet_info_sync_group (sc->info, ec);
sc->stackframe = g_list_append (sc->stackframe, sc->info);
}
sc->info = new_info;
if (!snippet_info_goto_next_placeholder (sc->info, ec))
snippets_deactivate (sc, ec);
}
static void
go_forward_search_cb (G_GNUC_UNUSED GtkButton *button, TextSearch *tsearch)
{
if (tsearch->priv->current_mark && tsearch->priv->current_mark->next) {
tsearch->priv->current_mark = tsearch->priv->current_mark->next;
gtk_text_view_scroll_mark_onscreen (tsearch->priv->view,
GTK_TEXT_MARK (tsearch->priv->current_mark->data));
}
}
static gint
sort_marks_by_priority (gconstpointer m1,
gconstpointer m2,
gpointer data)
{
GtkSourceMark *mark1 = GTK_SOURCE_MARK (m1);
GtkSourceMark *mark2 = GTK_SOURCE_MARK (m2);
GtkSourceView *view = GTK_SOURCE_VIEW (data);
GtkTextIter iter1, iter2;
gint line1;
gint line2;
gtk_text_buffer_get_iter_at_mark (gtk_text_mark_get_buffer (GTK_TEXT_MARK (mark1)),
&iter1,
GTK_TEXT_MARK (mark1));
gtk_text_buffer_get_iter_at_mark (gtk_text_mark_get_buffer (GTK_TEXT_MARK (mark2)),
&iter2,
GTK_TEXT_MARK (mark2));
line1 = gtk_text_iter_get_line (&iter1);
line2 = gtk_text_iter_get_line (&iter2);
if (line1 == line2)
{
gint priority1 = -1;
gint priority2 = -1;
gtk_source_view_get_mark_attributes (view,
gtk_source_mark_get_category (mark1),
&priority1);
gtk_source_view_get_mark_attributes (view,
gtk_source_mark_get_category (mark2),
&priority2);
return priority1 - priority2;
}
else
{
return line2 - line1;
}
}
static void
on_end_user_action (GtkTextBuffer *buffer,
InsertData *data)
{
GSList *item;
if (--data->user_action > 0)
{
return;
}
/* Remove trackers */
for (item = data->trackers; item; item = g_slist_next (item))
{
InsertTracker *tracker = item->data;
GtkTextIter curloc;
GtkTextIter newloc;
/* Move the category to the line where the mark now is */
gtk_text_buffer_get_iter_at_mark (buffer,
&curloc,
GTK_TEXT_MARK (tracker->bookmark));
gtk_text_buffer_get_iter_at_mark (buffer,
&newloc,
tracker->mark);
if (gtk_text_iter_get_line (&curloc) != gtk_text_iter_get_line (&newloc))
{
gtk_text_iter_set_line_offset (&newloc, 0);
gtk_text_buffer_move_mark (buffer,
GTK_TEXT_MARK (tracker->bookmark),
&newloc);
}
gtk_text_buffer_delete_mark (buffer, tracker->mark);
g_slice_free (InsertTracker, tracker);
}
g_slist_free (data->trackers);
data->trackers = NULL;
}
/**
* gtk_source_mark_prev:
* @mark: a #GtkSourceMark
* @category: a string specifying the mark category or %NULL
*
* Returns the previous #GtkSourceMark in the buffer or %NULL if the mark
* was not added to a buffer. If there is no previous mark, %NULL is returned.
*
* If @category is %NULL, looks for marks of any category
*
* Returns: the previous #GtkSourceMark or %NULL
*
* Since: 2.2
*/
GtkSourceMark *
gtk_source_mark_prev (GtkSourceMark *mark,
const gchar *category)
{
GtkTextBuffer *buffer;
g_return_val_if_fail (GTK_IS_SOURCE_MARK (mark), NULL);
buffer = gtk_text_mark_get_buffer (GTK_TEXT_MARK (mark));
if (buffer != NULL)
return _gtk_source_buffer_source_mark_prev (GTK_SOURCE_BUFFER (buffer),
mark, category);
else
return NULL;
}
static void
remove_bookmark (GtkSourceBuffer *buffer,
GtkTextIter *iter)
{
GtkTextIter start;
GtkSourceMark *bookmark;
bookmark = get_bookmark_and_iter (buffer, iter, &start);
if (bookmark != NULL)
{
gtk_text_buffer_delete_mark (GTK_TEXT_BUFFER (buffer),
GTK_TEXT_MARK (bookmark));
}
}
static void
gtk_text_mark_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkTextMark *mark = GTK_TEXT_MARK (object);
switch (prop_id)
{
case PROP_NAME:
g_value_set_string (value, gtk_text_mark_get_name (mark));
break;
case PROP_LEFT_GRAVITY:
g_value_set_boolean (value, gtk_text_mark_get_left_gravity (mark));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
hide_search_bar (TextSearch *tsearch)
{
GtkTextIter start, end;
GtkTextBuffer *buffer;
/* clean all previous search result */
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tsearch->priv->view));
gtk_text_buffer_get_bounds (buffer, &start, &end);
gtk_text_buffer_remove_tag_by_name (buffer, "search", &start, &end);
if (tsearch->priv->search_marks) {
GList *list;
for (list = tsearch->priv->search_marks; list; list = list->next)
gtk_text_buffer_delete_mark (buffer, GTK_TEXT_MARK (list->data));
g_list_free (tsearch->priv->search_marks);
tsearch->priv->search_marks = NULL;
}
tsearch->priv->current_mark = NULL;
gtk_widget_hide (GTK_WIDGET (tsearch));
}
VISIBLE void toggleBookmark(GtkWidget *widget,GtkTextIter *titer)
{
ERRDATA
pageStruct *page=getPageStructByIDFromPage(-1);
GtkWidget *menuitem;
GtkTextMark *mark;
GtkTextIter *iter;
GtkTextIter siter;
int line;
GtkTextIter startprev,endprev;
char *previewtext;
GSList *mark_list=NULL;
const gchar *mark_type;
GList *ptr=NULL;
bookMarksNew *bookmarkdata;
char *correctedpreview;
if(page==NULL)
return;
mark_type=MARK_TYPE_1;
if(titer==NULL)
{
mark=gtk_text_buffer_get_insert((GtkTextBuffer*)page->buffer);
gtk_text_buffer_get_iter_at_mark((GtkTextBuffer*)page->buffer,&siter,mark);
gtk_text_iter_set_line_offset(&siter,0);
iter=(GtkTextIter*)(&siter);
}
else
iter=titer;
mark_list=gtk_source_buffer_get_source_marks_at_line(page->buffer,gtk_text_iter_get_line(iter),mark_type);
if(mark_list!=NULL)
{
//remove entry from bookmark list
ptr=newBookMarksList;
while(ptr!=NULL)
{
if((gpointer)((bookMarksNew*)ptr->data)->mark==(gpointer)GTK_TEXT_MARK(mark_list->data))
{
ERRDATA debugFree(&((bookMarksNew*)ptr->data)->markName);
newBookMarksList=g_list_remove(newBookMarksList,ptr->data);
gtk_text_buffer_delete_mark(GTK_TEXT_BUFFER(page->buffer),GTK_TEXT_MARK(mark_list->data));
break;
}
ptr=g_list_next(ptr);
}
/* just take the first and delete it */
//rebuild bookmark menu
rebuildBookMarkMenu();
ptr=newBookMarksList;
while(ptr!=NULL)
{
menuitem=gtk_menu_item_new_with_label(((bookMarksNew*)ptr->data)->label);
gtk_menu_shell_append(GTK_MENU_SHELL(bookMarkSubMenu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(jumpToMark),ptr->data);
ptr=g_list_next(ptr);
}
gtk_widget_show_all(bookMarkMenu);
g_slist_free(mark_list);
}
else
{
/* no mark found: create one */
bookmarkdata=(bookMarksNew*)malloc(sizeof(bookMarksNew));
newBookMarksList=g_list_append(newBookMarksList,(gpointer)bookmarkdata);
bookmarkdata->page=page;
sinkReturn=asprintf(&bookmarkdata->markName,"%s-%i",BOOKMARK_LABEL,bmMarkNumber++);
bookmarkdata->mark=gtk_source_buffer_create_source_mark(page->buffer,bookmarkdata->markName,mark_type,iter);
bookmarkdata->pageID=page->pageID;
//preview text for menu
line=gtk_text_iter_get_line(iter);
gtk_text_buffer_get_iter_at_line((GtkTextBuffer*)page->buffer,&startprev,line);
gtk_text_buffer_get_iter_at_line((GtkTextBuffer*)page->buffer,&endprev,line+1);
previewtext=gtk_text_iter_get_text(&startprev,&endprev);
previewtext[strlen(previewtext)-1]=0;
g_strchug(previewtext);
g_strchomp(previewtext);
correctedpreview=truncateWithElipses(previewtext,maxBMChars);
ERRDATA debugFree(&previewtext);
previewtext=correctedpreview;
bookmarkdata->label=previewtext;
bookmarkdata->line=line;
menuitem=gtk_menu_item_new_with_label(bookmarkdata->label);
gtk_menu_shell_append(GTK_MENU_SHELL(bookMarkSubMenu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(jumpToMark),(void*)bookmarkdata);
gtk_widget_show_all(bookMarkMenu);
}
}
static void
search_text_changed_cb (GtkEntry *entry, TextSearch *tsearch)
{
GtkTextIter iter, siter, end;
GtkTextBuffer *buffer;
const gchar *search_text, *sptr;
gboolean sensitive;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tsearch->priv->view));
/* clean all previous search result */
gtk_text_buffer_get_bounds (buffer, &iter, &end);
gtk_text_buffer_remove_tag_by_name (buffer, "search", &iter, &end);
tsearch->priv->current_mark = NULL;
if (tsearch->priv->search_marks) {
GList *list;
for (list = tsearch->priv->search_marks; list; list = list->next)
gtk_text_buffer_delete_mark (buffer, GTK_TEXT_MARK (list->data));
g_list_free (tsearch->priv->search_marks);
tsearch->priv->search_marks = NULL;
}
gtk_text_buffer_get_start_iter (buffer, &iter);
search_text = gtk_entry_get_text (entry);
if (!search_text || !*search_text)
return;
sensitive = gtk_toggle_button_get_active (tsearch->priv->search_sensitive);
while (1) {
gboolean high = TRUE;
siter = iter;
sptr = search_text;
/* search for @search_text starting from the @siter position */
while (1) {
gunichar c1, c2;
c1 = gtk_text_iter_get_char (&siter);
c2 = g_utf8_get_char (sptr);
if (!sensitive) {
c1 = g_unichar_tolower (c1);
c2 = g_unichar_tolower (c2);
}
if (c1 != c2) {
high = FALSE;
break;
}
sptr = g_utf8_find_next_char (sptr, NULL);
if (!sptr || !*sptr)
break;
if (! gtk_text_iter_forward_char (&siter)) {
high = FALSE;
break;
}
}
if (high) {
if (gtk_text_iter_forward_char (&siter)) {
GtkTextMark *mark;
gtk_text_buffer_apply_tag_by_name (buffer, "search", &iter, &siter);
mark = gtk_text_buffer_create_mark (buffer, NULL, &iter, FALSE);
tsearch->priv->search_marks = g_list_prepend (tsearch->priv->search_marks,
mark);
}
iter = siter;
}
else {
if (! gtk_text_iter_forward_char (&iter))
break;
}
}
if (tsearch->priv->search_marks) {
tsearch->priv->search_marks = g_list_reverse (tsearch->priv->search_marks);
tsearch->priv->current_mark = tsearch->priv->search_marks;
gtk_text_view_scroll_mark_onscreen (tsearch->priv->view,
GTK_TEXT_MARK (tsearch->priv->current_mark->data));
}
}
GtkTextMark* cast_GtkTextMark(GObject* obj) {
return GTK_TEXT_MARK(obj);
}
