/* Format->Indent */
void
action_indent(GtkAction *action, I7Document *document)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER(i7_document_get_buffer(document));
/* Shift the selected lines in the buffer one tab to the right */
/* Adapted from gtksourceview.c */
GtkTextIter start, end;
gtk_text_buffer_get_selection_bounds(buffer, &start, &end);
/* Find out which lines to indent */
gint start_line = gtk_text_iter_get_line(&start);
gint end_line = gtk_text_iter_get_line(&end);
gint i;
/* if the end of the selection is before the first character on a line,
don't indent it */
if((gtk_text_iter_get_visible_line_offset(&end) == 0) && (end_line > start_line))
end_line--;
/* Treat it as one single undo action */
gtk_text_buffer_begin_user_action(buffer);
for(i = start_line; i <= end_line; i++) {
GtkTextIter iter;
gtk_text_buffer_get_iter_at_line(buffer, &iter, i);
/* don't add indentation on empty lines */
if(gtk_text_iter_ends_line(&iter))
continue;
gtk_text_buffer_insert(buffer, &iter, "\t", -1);
}
gtk_text_buffer_end_user_action(buffer);
}
/* Format->Unindent */
void
action_unindent(GtkAction *action, I7Document *document)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER(i7_document_get_buffer(document));
/* Shift the selected lines in the buffer one tab to the left */
/* Adapted from gtksourceview.c */
GtkTextIter start, end;
gtk_text_buffer_get_selection_bounds(buffer, &start, &end);
/* Find out which lines to unindent */
gint start_line = gtk_text_iter_get_line(&start);
gint end_line = gtk_text_iter_get_line(&end);
gint i;
/* if the end of the selection is before the first character on a line,
don't unindent it */
if((gtk_text_iter_get_visible_line_offset(&end) == 0) && (end_line > start_line))
end_line--;
/* Treat it as one single undo action */
gtk_text_buffer_begin_user_action(buffer);
for(i = start_line; i <= end_line; i++) {
GtkTextIter iter, iter2;
gtk_text_buffer_get_iter_at_line(buffer, &iter, i);
if(gtk_text_iter_get_char(&iter) == '\t') {
iter2 = iter;
gtk_text_iter_forward_char(&iter2);
gtk_text_buffer_delete(buffer, &iter, &iter2);
}
}
gtk_text_buffer_end_user_action(buffer);
}
void indent_multi_line_indent(GtkTextBuffer *buffer)
{
GtkTextIter start_iter, end_iter, iter;
gint start_line, end_line, i;
gboolean pos;
gtk_text_buffer_get_selection_bounds(buffer, &start_iter, &end_iter);
start_line = gtk_text_iter_get_line(&start_iter);
end_line = gtk_text_iter_get_line(&end_iter);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, gtk_text_buffer_get_insert(buffer));
pos = gtk_text_iter_equal(&iter, &start_iter);
for (i = start_line; i < end_line; i++) {
gtk_text_buffer_get_iter_at_line(buffer, &iter, i);
gtk_text_buffer_place_cursor(buffer, &iter);
g_signal_emit_by_name(G_OBJECT(buffer), "begin-user-action");
gtk_text_buffer_insert(buffer, &iter, "\t", 1);
g_signal_emit_by_name(G_OBJECT(buffer), "end-user-action");
undo_set_sequency(TRUE);
}
undo_set_sequency(FALSE);
gtk_text_buffer_get_iter_at_line(buffer, &start_iter, start_line);
gtk_text_buffer_get_iter_at_line(buffer, &end_iter, end_line);
if (pos) {
gtk_text_buffer_place_cursor(buffer, &end_iter);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &start_iter);
} else {
gtk_text_buffer_place_cursor(buffer, &start_iter);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &end_iter);
}
}
void dump_code_vars()
{
int i;
GtkTextIter aniter;
GtkTextMark *mark;
GdkRectangle coderect;
int vbuf_start, vbuf_end;
printf("+++ CODE +++\n");
printf("selected_code_line=%d, Selected_Code_Addr=%04X, Code_Selected=%d\n",
selected_code_line, Selected_Code_Addr, Code_Selected);
printf("ram=%04X, SP=%04X, PC=%04X\n",
(WORD)ram, (WORD)(STACK - ram),
(WORD)(PC - ram));
do_break("\n");
// printf("Codeline table\n");
// for (i = 0; i < 4; i++)
// printf("addr=%04X line=%d\n", i, codelines[i]);
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(codetext), &coderect);
gtk_text_view_get_line_at_y(GTK_TEXT_VIEW(codetext),
&aniter, coderect.y, NULL);
vbuf_start = gtk_text_iter_get_line(&aniter);
gtk_text_view_get_line_at_y(GTK_TEXT_VIEW(codetext),
&aniter, coderect.y+coderect.height, NULL);
vbuf_end = gtk_text_iter_get_line(&aniter);
printf("coderect: x=%d y=%d width=%d height=%d\n",
coderect.x, coderect.y, coderect.width, coderect.height);
printf("visible: start=%d end=%d\n", vbuf_start, vbuf_end);
printf("--- CODE ---\n");
}
static void
gb_vim_do_substitute (GtkTextBuffer *buffer,
GtkTextIter *begin,
GtkTextIter *end,
const gchar *search_text,
const gchar *replace_text,
gboolean is_global,
gboolean should_search_all_lines)
{
GtkTextIter begin_tmp;
GtkTextIter end_tmp;
GtkTextMark *last_line;
GtkTextIter *current_line;
GtkTextMark *end_mark;
GtkTextMark *insert;
g_assert (search_text);
g_assert (replace_text);
g_assert ((!begin && !end) || (begin && end));
insert = gtk_text_buffer_get_insert (buffer);
if (!begin)
{
if (should_search_all_lines)
gtk_text_buffer_get_start_iter (buffer, &begin_tmp);
else
gtk_text_buffer_get_iter_at_mark (buffer, &begin_tmp, insert);
begin = &begin_tmp;
}
if (!end)
{
if (should_search_all_lines)
gtk_text_buffer_get_end_iter (buffer, &end_tmp);
else
gtk_text_buffer_get_iter_at_mark (buffer, &end_tmp, insert);
end = &end_tmp;
}
current_line = begin;
last_line = gtk_text_buffer_create_mark (buffer, NULL, current_line, FALSE);
end_mark = gtk_text_buffer_create_mark (buffer, NULL, end, FALSE);
for (guint line = gtk_text_iter_get_line (current_line);
line <= gtk_text_iter_get_line (end);
line++)
{
gb_vim_do_substitute_line (buffer, current_line, search_text, replace_text, is_global);
gtk_text_buffer_get_iter_at_mark (buffer, current_line, last_line);
gtk_text_buffer_get_iter_at_mark (buffer, end, end_mark);
gtk_text_iter_set_line (current_line, line + 1);
}
gtk_text_buffer_delete_mark (buffer, last_line);
gtk_text_buffer_delete_mark (buffer, end_mark);
}
static void
gbp_retab_editor_page_addin_action (GSimpleAction *action,
GVariant *variant,
gpointer user_data)
{
GbpRetabEditorPageAddin *self = user_data;
IdeSourceView *source_view;
GtkTextBuffer *buffer;
IdeCompletion *completion;
guint tab_width;
gint start_line;
gint end_line;
gint indent;
GtkTextIter begin;
GtkTextIter end;
gboolean editable;
gboolean to_spaces;
g_assert (GBP_IS_RETAB_EDITOR_PAGE_ADDIN (self));
g_assert (G_IS_SIMPLE_ACTION (action));
buffer = GTK_TEXT_BUFFER (ide_editor_page_get_buffer (self->editor_view));
source_view = ide_editor_page_get_view (self->editor_view);
g_assert (IDE_IS_SOURCE_VIEW (source_view));
editable = gtk_text_view_get_editable (GTK_TEXT_VIEW (source_view));
completion = ide_source_view_get_completion (IDE_SOURCE_VIEW (source_view));
tab_width = gtk_source_view_get_tab_width(GTK_SOURCE_VIEW (source_view));
to_spaces = gtk_source_view_get_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW (source_view));
if (!editable)
return;
gtk_text_buffer_get_selection_bounds (buffer, &begin, &end);
gtk_text_iter_order (&begin, &end);
if (!gtk_text_iter_equal (&begin, &end) && gtk_text_iter_starts_line (&end))
gtk_text_iter_backward_char (&end);
start_line = gtk_text_iter_get_line (&begin);
end_line = gtk_text_iter_get_line (&end);
ide_completion_block_interactive (completion);
gtk_text_buffer_begin_user_action (buffer);
for (gint line = start_line; line <= end_line; ++line)
{
indent = get_buffer_range_indent (buffer, line, to_spaces);
if (indent > 0)
gbp_retab_editor_page_addin_retab (buffer, line, tab_width, indent, to_spaces);
}
gtk_text_buffer_end_user_action (buffer);
ide_completion_unblock_interactive (completion);
}
//!
//! @brief Pagination algorithm to calculate how many pages are needed
//! @param operation Unused GtkPrintOperation
//! @param context Pointer co a GtkPrintContext to draw on
//! @param page_nr Integer of the current page number being draw
//! @param data Painter to a PageInfo struct to use for information
//! @return Return true when pagination finishes
//! @sa _done() _begin_print() draw() _begin_print()
//!
static gboolean _paginate (GtkPrintOperation *operation,
GtkPrintContext *context,
GwPrintData *data )
{
printf("paginate!\n");
//Declarations
GwPageInfo *page;
GwPageInfo *prev_page;
GList *iter;
GtkTextIter end_bound;
GtkTextIter start_bound;
GtkTextView *view;
GtkTextBuffer *buffer;
//Initializations
view = gw_searchwindow_get_current_textview (data->window);
buffer = gtk_text_view_get_buffer (view);
//Get the draw bounds
if (gtk_text_buffer_get_has_selection (buffer))
{
gtk_text_buffer_get_selection_bounds (buffer, &start_bound, &end_bound);
}
else
{
gtk_text_buffer_get_start_iter (buffer, &start_bound);
gtk_text_buffer_get_end_iter (buffer, &end_bound);
}
//Create the first page
if (data->pages == NULL)
{
page = gw_pageinfo_new (start_bound, end_bound);
_draw_page_results (context, page, data);
data->pages = g_list_append (data->pages, page);
return FALSE;
}
iter = g_list_last (data->pages);
prev_page = GW_PAGEINFO (iter->data);
//Finish paginating
if (gtk_text_iter_get_line (&(prev_page->end)) == gtk_text_iter_get_line (&end_bound))
{
gtk_print_operation_set_n_pages (operation, g_list_length (data->pages));
return TRUE;
}
//Add another page
page = gw_pageinfo_new (prev_page->end, end_bound);
_draw_page_results (context, page, data);
data->pages = g_list_append (data->pages, page);
return FALSE;
}
/* Always process start and end by init_boudaries before */
static GHashTable *
gbp_spell_navigator_count_words (GbpSpellNavigator *self,
GtkTextIter *start,
GtkTextIter *end)
{
GHashTable *table;
GtkSourceRegion *words_count_region;
WordsCountState *state;
GtkTextIter start_subregion;
GtkTextIter end_subregion;
gint line_start;
gint line_end;
gint nb_subregion;
g_assert (GBP_IS_SPELL_NAVIGATOR (self));
g_assert (start != NULL);
g_assert (end != NULL);
words_count_region = gtk_source_region_new (self->buffer);
line_start = gtk_text_iter_get_line (start);
line_end = gtk_text_iter_get_line (end);
nb_subregion = (line_end - line_start + 1) / SPELLCHECKER_SUBREGION_LENGTH;
if (nb_subregion > 1)
{
for (gint i = 0; i < nb_subregion; ++i)
{
line_end = line_start + SPELLCHECKER_SUBREGION_LENGTH - 1;
gtk_text_buffer_get_iter_at_line_offset (self->buffer, &start_subregion, line_start, 0);
gtk_text_buffer_get_iter_at_line_offset (self->buffer, &end_subregion, line_end, 0);
if (!gtk_text_iter_ends_line (&end_subregion))
gtk_text_iter_forward_to_line_end (&end_subregion);
gtk_source_region_add_subregion (words_count_region, &start_subregion, &end_subregion);
line_start = line_end + 1;
}
}
gtk_text_buffer_get_iter_at_line_offset (self->buffer, &start_subregion, line_start, 0);
gtk_source_region_add_subregion (words_count_region, &start_subregion, end);
table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
state = g_slice_new0 (WordsCountState);
state->navigator = g_object_ref (self);
state->words_count_region = words_count_region;
gtk_source_region_get_start_region_iter (words_count_region, &state->iter);
g_idle_add_full (G_PRIORITY_LOW,
(GSourceFunc)gbp_spell_navigator_words_count_cb,
state,
(GDestroyNotify)words_count_state_free);
return table;
}
void run_dialog_jump_to(GtkWidget *textview)
{
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *table;
GtkWidget *label;
GtkWidget *spinner;
GtkAdjustment *spinner_adj;
GtkTextIter iter;
gint num, max_num;
GtkTextBuffer *textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_get_iter_at_mark(textbuffer, &iter,
gtk_text_buffer_get_insert(textbuffer));
num = gtk_text_iter_get_line(&iter) + 1;
gtk_text_buffer_get_end_iter(textbuffer, &iter);
max_num = gtk_text_iter_get_line(&iter) + 1;
dialog = gtk_dialog_new_with_buttons(_("Jump To"),
GTK_WINDOW(gtk_widget_get_toplevel(textview)),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
button = create_button_with_stock_image(_("_Jump"), GTK_STOCK_JUMP_TO);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button, GTK_RESPONSE_OK);
table = gtk_table_new(1, 2, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), 8);
gtk_container_set_border_width (GTK_CONTAINER(table), 8);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic(_("_Line number:"));
spinner_adj = (GtkAdjustment *) gtk_adjustment_new(num, 1, max_num, 1, 1, 0);
spinner = gtk_spin_button_new(spinner_adj, 1, 0);
gtk_entry_set_width_chars(GTK_ENTRY(spinner), 8);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), spinner);
gtk_entry_set_activates_default(GTK_ENTRY(spinner), TRUE);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table), spinner, 1, 2, 0, 1);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_widget_show_all(dialog);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) {
gtk_text_buffer_get_iter_at_line(textbuffer, &iter,
gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spinner)) - 1);
gtk_text_buffer_place_cursor(textbuffer, &iter);
// gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textview), &iter, 0.1, FALSE, 0.5, 0.5);
scroll_to_cursor(textbuffer, 0.25);
}
gtk_widget_destroy (dialog);
}
/* TODO:
can we make this function faster? when adding bookmarks from a search this function uses
a lot of time, perhaps that can be improved
*/
static Tbmark *bmark_get_bmark_at_line(Tdocument *doc, gint offset) {
GtkTextIter sit, eit;
GtkTreeIter tmpiter;
gint linenum;
gtk_text_buffer_get_iter_at_offset(doc->buffer,&sit,offset);
linenum = gtk_text_iter_get_line(&sit);
eit = sit;
gtk_text_iter_set_line_offset(&sit, 0);
gtk_text_iter_forward_to_line_end(&eit);
#ifdef DEBUG
{
gchar *tmp = gtk_text_buffer_get_text(doc->buffer, &sit,&eit,FALSE);
DEBUG_MSG("bmark_get_bmark_at_line, searching bookmarks at line %d between offsets %d - %d --> '%s'\n",linenum,gtk_text_iter_get_offset(&sit),gtk_text_iter_get_offset(&eit),tmp);
g_free(tmp);
}
#endif
/* check for existing bookmark in this place */
if (DOCUMENT(doc)->bmark_parent) {
GtkTextIter testit;
Tbmark *m, *m2;
m = bmark_find_bookmark_before_offset(BFWIN(doc->bfwin), offset, doc->bmark_parent);
if (m == NULL) {
DEBUG_MSG("bmark_get_bmark_at_line, m=NULL, get first child\n");
if (gtk_tree_model_iter_children(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter,doc->bmark_parent)) {
gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter, PTR_COLUMN, &m2, -1);
gtk_text_buffer_get_iter_at_mark(doc->buffer, &testit,m2->mark);
if (gtk_text_iter_get_line(&testit) == linenum) {
return m2;
}
}
} else {
gtk_text_buffer_get_iter_at_mark(doc->buffer, &testit,m->mark);
DEBUG_MSG("bmark_get_bmark_at_line, m=%p, has linenum=%d\n",m,gtk_text_iter_get_line(&testit));
if (gtk_text_iter_get_line(&testit) == linenum) {
return m;
}
tmpiter = m->iter;
if (gtk_tree_model_iter_next(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore),&tmpiter)) {
gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter, PTR_COLUMN, &m2, -1);
gtk_text_buffer_get_iter_at_mark(doc->buffer, &testit,m2->mark);
if (gtk_text_iter_get_line(&testit) == linenum) {
return m2;
}
}
}
DEBUG_MSG("bmark_get_bmark_at_line, nothing found at this line, return NULL\n");
return NULL;
}
DEBUG_MSG("bmark_get_bmark_at_line, no existing bookmark found, return NULL\n");
return NULL;
}
//選択された範囲の行を全てインデントする
void set_indent_all(void)
{
int line_start, line_end, i;
GtkTextIter start, end;
gtk_text_buffer_get_selection_bounds(GTK_TEXT_BUFFER(buffer), &start, &end);
line_start = gtk_text_iter_get_line(&start);
line_end = gtk_text_iter_get_line(&end);
for (i = line_start; i <= line_end; i++) {
int depth = get_indent_depth(i - 1);
set_indent_depth(i, depth);
}
}
static gchar *
get_word_at_iter (GscProviderDevhelp *devhelp,
GtkTextIter *iter)
{
GtkTextIter start = *iter;
gint line = gtk_text_iter_get_line (iter);
gboolean went_back = TRUE;
GtkTextMark *mark;
if (!gtk_text_iter_backward_char (&start))
{
return NULL;
}
while (went_back &&
line == gtk_text_iter_get_line (&start) &&
is_word_char (gtk_text_iter_get_char (&start)))
{
went_back = gtk_text_iter_backward_char (&start);
}
if (went_back)
{
gtk_text_iter_forward_char (&start);
}
if (gtk_text_iter_equal (iter, &start))
{
return NULL;
}
mark = gtk_text_buffer_get_mark (gtk_text_iter_get_buffer (iter),
MARK_NAME);
if (mark)
{
gtk_text_buffer_move_mark (gtk_text_iter_get_buffer (iter),
mark,
&start);
}
else
{
mark = gtk_text_buffer_create_mark (gtk_text_iter_get_buffer (iter),
MARK_NAME,
&start,
TRUE);
}
return gtk_text_iter_get_text (&start, iter);
}
static void
gb_vim_do_substitute_line (GtkTextBuffer *buffer,
GtkTextIter *begin,
const gchar *search_text,
const gchar *replace_text,
gboolean is_global)
{
GtkSourceSearchContext *search_context;
GtkSourceSearchSettings *search_settings;
GtkTextIter match_begin;
GtkTextIter match_end;
gboolean has_wrapped = FALSE;
GError *error = NULL;
gint line_number;
g_assert(buffer);
g_assert(begin);
g_assert(search_text);
g_assert(replace_text);
search_settings = gtk_source_search_settings_new ();
search_context = gtk_source_search_context_new (GTK_SOURCE_BUFFER (buffer), search_settings);
line_number = gtk_text_iter_get_line(begin);
gtk_text_iter_set_line_offset(begin, 0);
gtk_source_search_settings_set_search_text (search_settings, search_text);
gtk_source_search_settings_set_case_sensitive (search_settings, TRUE);
while (gtk_source_search_context_forward (search_context, begin, &match_begin, &match_end, &has_wrapped) && !has_wrapped)
{
if (gtk_text_iter_get_line (&match_end) != line_number)
break;
if (!gtk_source_search_context_replace (search_context, &match_begin, &match_end, replace_text, -1, &error))
{
g_warning ("%s", error->message);
g_clear_error (&error);
break;
}
*begin = match_end;
if (!is_global)
break;
}
g_clear_object (&search_settings);
g_clear_object (&search_context);
}
static gboolean
is_single_line_selection (const GtkTextIter *begin,
const GtkTextIter *end)
{
if (gtk_text_iter_compare (begin, end) < 0)
return ((gtk_text_iter_get_line_offset (begin) == 0) &&
(gtk_text_iter_get_line_offset (end) == 0) &&
((gtk_text_iter_get_line (begin) + 1) ==
gtk_text_iter_get_line (end)));
else
return ((gtk_text_iter_get_line_offset (begin) == 0) &&
(gtk_text_iter_get_line_offset (end) == 0) &&
((gtk_text_iter_get_line (end) + 1) ==
gtk_text_iter_get_line (begin)));
}
static std::vector<LineInfo> getLinesInfo(GtkTextView* textView, int height)
{
std::vector<LineInfo> linesInfo;
int y1 = 0;
int y2 = height;
gtk_text_view_window_to_buffer_coords(textView, GTK_TEXT_WINDOW_LEFT,
0, y1, NULL, &y1);
gtk_text_view_window_to_buffer_coords(textView, GTK_TEXT_WINDOW_LEFT,
0, y2, NULL, &y2);
GtkTextIter iter;
gtk_text_view_get_line_at_y(textView, &iter, y1, NULL);
while(!gtk_text_iter_is_end(&iter))
{
int y, height;
gtk_text_view_get_line_yrange(textView, &iter, &y, &height);
int line = gtk_text_iter_get_line(&iter);
linesInfo.push_back(LineInfo(line+1, y));
if((y + height) >= y2)
{
break;
}
gtk_text_iter_forward_line(&iter);
}
if(linesInfo.size() == 0)
{
linesInfo.push_back(LineInfo(1, 1));
}
return linesInfo;
}
gint
gui_editor_get_line (GUIEditor * self)
{
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER(self->buffer), &(self->iter), self->mark);
return gtk_text_iter_get_line (&(self->iter));
}
static void
buffer_insert_text_after_cb (GbpGitBufferChangeMonitor *self,
GtkTextIter *location,
gchar *text,
gint len,
IdeBuffer *buffer)
{
guint line;
g_assert (GBP_IS_GIT_BUFFER_CHANGE_MONITOR (self));
g_assert (location != NULL);
g_assert (text != NULL);
g_assert (IDE_IS_BUFFER (buffer));
/*
* We need to recalculate the diff when text is inserted if:
*
* 1) A newline is included in the text.
* 2) The line currently has flags of NONE.
*
* Technically we need to do it on every change to be more correct, but that
* wastes a lot of power. So instead, we'll be a bit lazy about it here and
* pick up the other changes on a much more conservative timeout
*/
line = gtk_text_iter_get_line (location);
if (self->cache == NULL ||
NULL != memmem (text, len, "\n", 1) ||
!line_cache_get_mark (self->cache, line))
gbp_git_buffer_change_monitor_queue_update (self, FAST);
}
void moveBMsForPage(pageStruct *page,unsigned dowhat)
{
unsigned thisid;
unsigned len;
bookMarksNew *bookmarkdata;
GtkTextIter newiter;
if(page!=NULL)
{
thisid=page->pageID;
if(newBookMarksList!=NULL)
{
len=g_list_length(newBookMarksList);
for(unsigned j=0;j<len;j++)
{
bookmarkdata=(bookMarksNew*)g_list_nth_data (newBookMarksList,j);
if(bookmarkdata->pageID==thisid)
{
switch(dowhat)
{
case 0:
gtk_text_buffer_get_iter_at_line_offset((GtkTextBuffer*)page->buffer,&newiter,bookmarkdata->line,0);
gtk_text_buffer_move_mark_by_name((GtkTextBuffer*)page->buffer,bookmarkdata->markName,&newiter);
break;
case 1:
gtk_text_buffer_get_iter_at_mark((GtkTextBuffer*)page->buffer,&newiter,(GtkTextMark*)bookmarkdata->mark);
bookmarkdata->line=gtk_text_iter_get_line(&newiter);
break;
}
}
}
}
}
}
static void
gb_view_source_notify_cursor (GbViewSource *source,
GParamSpec *pspec,
GtkTextBuffer *buffer)
{
GbViewSourcePrivate *priv;
GtkTextIter iter;
guint col;
guint line;
guint position;
gchar *s;
g_return_if_fail(GB_IS_VIEW_SOURCE(source));
g_return_if_fail(pspec != NULL);
g_return_if_fail(GTK_SOURCE_IS_BUFFER(buffer));
priv = source->priv;
g_object_get(buffer, "cursor-position", &position, NULL);
gtk_text_buffer_get_iter_at_offset(buffer, &iter, position);
line = gtk_text_iter_get_line(&iter);
col = gtk_source_view_get_visual_column(GTK_SOURCE_VIEW(priv->source1),
&iter);
s = g_strdup_printf(_("Line %d, Column %d"), line + 1, col + 1);
g_object_set(priv->pos_label, "label", s, NULL);
g_free(s);
}
static void
update_statusbar (GtkTextBuffer *buffer,
GtkStatusbar *statusbar)
{
gchar *msg;
gint row, col;
gint count;
GtkTextIter iter;
/* clear any previous message, underflow is allowed */
gtk_statusbar_pop (statusbar, 0);
count = gtk_text_buffer_get_char_count (buffer);
gtk_text_buffer_get_iter_at_mark (buffer,
&iter,
gtk_text_buffer_get_insert (buffer));
row = gtk_text_iter_get_line (&iter);
col = gtk_text_iter_get_line_offset (&iter);
msg = g_strdup_printf ("Cursor at row %d column %d - %d chars in document",
row, col, count);
gtk_statusbar_push (statusbar, 0, msg);
g_free (msg);
}
static void
wikipad_document_notify_cursor_position (GtkTextBuffer *buffer,
GParamSpec *pspec,
WikipadDocument *document)
{
GtkTextIter iter;
gint line, column, selection;
gint tab_size;
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (WIKIPAD_IS_DOCUMENT (document));
/* get the current iter position */
gtk_text_buffer_get_iter_at_mark (buffer, &iter, gtk_text_buffer_get_insert (buffer));
/* get the current line number */
line = gtk_text_iter_get_line (&iter) + 1;
/* get the tab size */
tab_size = WIKIPAD_SETTING_GET_INT (TAB_WIDTH);
/* get the column */
column = wikipad_util_get_real_line_offset (&iter, tab_size);
/* get length of the selection */
selection = wikipad_view_get_selection_length (document->textview, NULL);
/* emit the signal */
g_signal_emit (G_OBJECT (document), document_signals[CURSOR_CHANGED], 0, line, column, selection);
}
static void
ide_line_change_gutter_renderer_draw (GtkSourceGutterRenderer *renderer,
cairo_t *cr,
GdkRectangle *bg_area,
GdkRectangle *cell_area,
GtkTextIter *begin,
GtkTextIter *end,
GtkSourceGutterRendererState state)
{
IdeLineChangeGutterRenderer *self = (IdeLineChangeGutterRenderer *)renderer;
guint line;
g_assert (IDE_IS_LINE_CHANGE_GUTTER_RENDERER (self));
g_assert (cr != NULL);
g_assert (bg_area != NULL);
g_assert (cell_area != NULL);
g_assert (begin != NULL);
g_assert (end != NULL);
if (self->lines == NULL)
return;
line = gtk_text_iter_get_line (begin);
if ((line - self->begin_line) < self->lines->len)
{
LineInfo *info = &g_array_index (self->lines, LineInfo, line - self->begin_line);
if (IS_LINE_CHANGE (info))
draw_line_change (self, cr, cell_area, info, state);
}
}
static void
ide_source_view_movements_line_percentage (Movement *mv)
{
GtkTextBuffer *buffer;
GtkTextIter end;
guint end_line;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
gtk_text_buffer_get_end_iter (buffer, &end);
end_line = gtk_text_iter_get_line (&end);
if (!mv->count)
{
gtk_text_iter_set_line (&mv->insert, 0);
}
else
{
guint line;
mv->count = MAX (1, mv->count);
line = (float)end_line * (mv->count / 100.0);
gtk_text_iter_set_line (&mv->insert, line);
}
mv->count = 0;
ide_source_view_movements_first_nonspace_char (mv);
}
static void
update_statusbar (void)
{
gchar *msg;
gint row, col;
GtkTextIter iter;
const char *print_str;
gtk_statusbar_pop (GTK_STATUSBAR (statusbar), 0);
gtk_text_buffer_get_iter_at_mark (buffer,
&iter,
gtk_text_buffer_get_insert (buffer));
row = gtk_text_iter_get_line (&iter);
col = gtk_text_iter_get_line_offset (&iter);
print_str = "";
if (active_prints)
{
GtkPrintOperation *op = active_prints->data;
print_str = gtk_print_operation_get_status_string (op);
}
msg = g_strdup_printf ("%d, %d%s %s",
row, col,
file_changed?" - Modified":"",
print_str);
gtk_statusbar_push (GTK_STATUSBAR (statusbar), 0, msg);
g_free (msg);
}
static IdeBufferLineChange
ide_git_buffer_change_monitor_get_change (IdeBufferChangeMonitor *monitor,
const GtkTextIter *iter)
{
IdeGitBufferChangeMonitor *self = (IdeGitBufferChangeMonitor *)monitor;
gpointer key;
gpointer value;
g_return_val_if_fail (IDE_IS_GIT_BUFFER_CHANGE_MONITOR (self), IDE_BUFFER_LINE_CHANGE_NONE);
g_return_val_if_fail (iter, IDE_BUFFER_LINE_CHANGE_NONE);
if (!self->state)
{
/*
* If the file is within the working directory, synthesize line addition.
*/
if (self->is_child_of_workdir)
return IDE_BUFFER_LINE_CHANGE_ADDED;
return IDE_BUFFER_LINE_CHANGE_NONE;
}
key = GINT_TO_POINTER (gtk_text_iter_get_line (iter) + 1);
value = g_hash_table_lookup (self->state, key);
return GPOINTER_TO_INT (value);
}
/****** 'text_tags' function *************************************************/
gint text_tags(GtkTextBuffer *buffer, const gchar *text)
{
GtkTextTag *tag;
GtkTextIter start,
match_end,
match_start;
gtk_text_buffer_get_iter_at_line_offset(buffer, &start,
char_line,
char_line_offset);
if(gtk_text_iter_forward_search(&start, text,
GTK_TEXT_SEARCH_CASE_INSENSITIVE,
&match_start, &match_end, NULL))
{
tag = gtk_text_buffer_create_tag(buffer, NULL,
"font", "italic 12",
"weight", 650, "underline",
PANGO_UNDERLINE_SINGLE,
NULL);
gtk_text_buffer_apply_tag(buffer, tag, &match_start, &match_end);
char_line = gtk_text_iter_get_line(&match_end);
char_line_offset = gtk_text_iter_get_line_offset(&match_end);
return 0;
}
else
{
return -1;
}
}
static void
gutter_renderer_query_data (GtkSourceGutterRenderer *renderer,
GtkTextIter *start,
GtkTextIter *end,
GtkSourceGutterRendererState state)
{
GtkSourceGutterRendererLines *lines = GTK_SOURCE_GUTTER_RENDERER_LINES (renderer);
gchar text[24];
gint line;
gint len;
gboolean current_line;
line = gtk_text_iter_get_line (start) + 1;
current_line = (state & GTK_SOURCE_GUTTER_RENDERER_STATE_CURSOR) &&
lines->priv->cursor_visible;
if (current_line)
{
len = g_snprintf (text, sizeof text, "<b>%d</b>", line);
}
else
{
len = g_snprintf (text, sizeof text, "%d", line);
}
gtk_source_gutter_renderer_text_set_markup (GTK_SOURCE_GUTTER_RENDERER_TEXT (renderer),
text,
len);
}
gboolean gglk_text_mouse(GtkTextTag *unused,
GObject *object,
GdkEvent *event,
GtkTextIter *iter,
gpointer user_data)
{
GglkText *tb;
int x = gtk_text_iter_get_line_offset(iter);
int y = gtk_text_iter_get_line(iter);
if(!IS_GGLK_TEXT(object))
return FALSE;
tb = GGLK_TEXT(object);
if(event->type == GDK_BUTTON_PRESS) {
tb->click_x = x;
tb->click_y = y;
} else if(event->type == GDK_BUTTON_RELEASE) {
if(tb->click_x == x && tb->click_y == y)
g_signal_emit(tb, gglk_text_signals[MOUSE_SIGNAL], 0, x, y);
} else if(event->type == GDK_2BUTTON_PRESS && user_data) {
int hyperval = GPOINTER_TO_INT(user_data);
g_signal_emit(tb, gglk_text_signals[HYPER_SIGNAL], 0, hyperval);
return TRUE;
}
return FALSE;
}
static void
position_save (Position *pos,
const GtkTextIter *iter)
{
pos->line = gtk_text_iter_get_line (iter);
pos->line_offset = gtk_text_iter_get_line_offset (iter);
}
/* Trap mark movement events in a Text, so that if line input is
in progress, the user can use C-a or C-e to move to the beginning /
end of the line input, not the beginning / end of the current line */
static void gglk_text_cursor_event(GtkTextBuffer *unused_widget,
GtkTextIter *unused_iter,
GtkTextMark *unused_mark,
gpointer user_data)
{
GglkText *tb = user_data;
GtkTextIter b, e;
int i;
gboolean moved[2] = { FALSE, FALSE };
g_signal_handler_block(tb->buffer, tb->cursor_handler);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &e, tb->endedit);
for(i = 0; i < 2; i++) {
GtkTextMark *this_mark = gtk_text_buffer_get_mark(
tb->buffer, i ? "selection_bound" : "insert");
GtkTextIter current;
gtk_text_buffer_get_iter_at_mark(tb->buffer, ¤t, this_mark);
/* If past the end mark, move back. */
if(gtk_text_iter_compare(¤t, &e) > 0) {
gtk_text_buffer_move_mark(tb->buffer, this_mark, &e);
moved[i] = TRUE;
}
/* If on the same line as the input, but before the region,
* move forward */
if(gtk_text_iter_get_line(¤t) == gtk_text_iter_get_line(&b) &&
gtk_text_iter_compare(¤t, &b) < 0) {
gtk_text_buffer_move_mark(tb->buffer, this_mark, &b);
moved[i] = TRUE;
}
}
if(moved[0]) {
/* This will make the cursor appear immediately */
g_signal_emit_by_name(tb, "move-cursor",
GTK_MOVEMENT_LOGICAL_POSITIONS, 0, TRUE);
}
g_signal_handler_unblock(tb->buffer, tb->cursor_handler);
}
