static void log_window_clip(LogWindow *logwin, guint clip_length)
{
guint length;
guint point;
GtkTextBuffer *textbuf = logwin->buffer;
GtkTextIter start_iter, end_iter;
length = gtk_text_buffer_get_line_count(textbuf);
/* debug_print("Log window length: %u\n", length); */
if (length > clip_length) {
/* find the end of the first line after the cut off
* point */
point = length - clip_length;
gtk_text_buffer_get_iter_at_line(textbuf, &end_iter, point);
if (!gtk_text_iter_forward_to_line_end(&end_iter))
return;
gtk_text_buffer_get_start_iter(textbuf, &start_iter);
gtk_text_buffer_delete(textbuf, &start_iter, &end_iter);
if (logwin->has_error) {
gtk_text_buffer_get_start_iter(textbuf, &start_iter);
if (mainwindow_get_mainwindow() && !gtk_text_iter_forward_to_tag_toggle(&start_iter, logwin->error_tag)) {
mainwindow_clear_error(mainwindow_get_mainwindow());
logwin->has_error = FALSE;
}
}
}
}
void Amt::LoggerImpl::insertLine(const char* _ctime, const char* _mess, unsigned _type, bool newString ){
if (_type >= riku::logger::NUM_ERR_MESS_TYPE )
return;
if (!_in_textbuffer || !_in_textview)
return;
GtkTextIter iter;
/*Добавим новое сообщение*/
gtk_text_buffer_get_end_iter (_in_textbuffer, &iter );
gtk_text_buffer_insert_with_tags ( _in_textbuffer, &iter, _ctime, -1, _in_tagArr[_type], NULL );
gtk_text_buffer_insert ( _in_textbuffer, &iter, " ", -1 );
gtk_text_buffer_insert_with_tags(_in_textbuffer, &iter, _mess, -1, _in_tagArr[_type], NULL );
if (newString)
gtk_text_buffer_insert(_in_textbuffer, &iter, "\n", -1);
/*Передвинем маркер скроллинга, и прокрутим список*/
GtkTextMark *mark = gtk_text_buffer_get_mark (_in_textbuffer, "scroll");
gtk_text_buffer_move_mark (_in_textbuffer, mark, &iter);
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW(_in_textview), mark);
/*Удалим записи, если их стало больше чем maxLines*/
if (_in_maxLines < gtk_text_buffer_get_line_count(_in_textbuffer) ){
GtkTextIter startI, endI;
gtk_text_buffer_get_iter_at_line(_in_textbuffer, &endI, 9);
gtk_text_buffer_get_iter_at_line(_in_textbuffer, &startI, 9);
gtk_text_iter_forward_line(&endI );
gtk_text_buffer_delete(_in_textbuffer, &startI, &endI);
}
}
void textbuffer_get_lines(GtkTextBuffer * buffer, vector < ustring > &lines, bool trimline)
// Reads all the lines in the textbuffer.
{
// We need to know the number of lines.
int number_of_lines = gtk_text_buffer_get_line_count(buffer);
GtkTextIter iterator;
GtkTextIter endofline;
// Get all lines.
for (int i = 0; i < number_of_lines; i++) {
gtk_text_buffer_get_iter_at_line(buffer, &iterator, i);
// Ensure that also the last line, without a newline character, gets taken.
if (i + 1 == number_of_lines) {
gtk_text_buffer_get_end_iter(buffer, &endofline);
} else {
gtk_text_buffer_get_iter_at_line(buffer, &endofline, i + 1);
gtk_text_iter_backward_char(&endofline);
}
// Get the line.
gchar *txt = gtk_text_buffer_get_text(buffer, &iterator, &endofline, false);
ustring line = txt;
g_free(txt); // Postiff: plug memory leak
// Trim it.
if (trimline)
line = trim(line);
// Store it.
lines.push_back(line);
}
}
//==========================================================================
long GUI_edi_getLsta (MemObj *mo, long lNr) {
//==========================================================================
/// get startPos of Line; -1=line does not exist.
GtkTextIter it1;
long cpos1;
// set GUI_ed1_view GUI_ed1_buff
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
--lNr; // first line = 1 !
if(lNr < 0) return (-1L);
// check eof
if(lNr >= gtk_text_buffer_get_line_count (GUI_ed1_buff)) {
gtk_text_buffer_get_end_iter (GUI_ed1_buff, &it1);
} else {
// does not find if lNr exists !
// get iter at startPos of line from LineNr
gtk_text_buffer_get_iter_at_line (GUI_ed1_buff, &it1, lNr);
}
// offset from iter
cpos1 = gtk_text_iter_get_offset (&it1);
// printf("ex GUI_edi_getLsta %ld %ld\n",cpos1,lNr);
return cpos1;
}
/* If @line is bigger than the lines of the document, the cursor is moved
* to the last line and FALSE is returned.
*/
gboolean
gedit_document_goto_line (GeditDocument *doc,
gint line)
{
gboolean ret = TRUE;
guint line_count;
GtkTextIter iter;
gedit_debug (DEBUG_DOCUMENT);
g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
g_return_val_if_fail (line >= -1, FALSE);
line_count = gtk_text_buffer_get_line_count (GTK_TEXT_BUFFER (doc));
if (line >= line_count)
{
ret = FALSE;
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc),
&iter);
}
else
{
gtk_text_buffer_get_iter_at_line (GTK_TEXT_BUFFER (doc),
&iter,
line);
}
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc), &iter);
return ret;
}
static gboolean twitter_conv_icon_displaying_chat_cb(PurpleAccount * account, const char *who, char **message, PurpleConversation * conv, PurpleMessageFlags flags, void *account_signal)
{
GtkIMHtml *imhtml;
GtkTextBuffer *text_buffer;
gint linenumber = 0;
if (account != account_signal)
return FALSE;
purple_debug_info(PLUGIN_ID, "called %s\n", G_STRFUNC);
/* get text buffer */
imhtml = GTK_IMHTML(PIDGIN_CONVERSATION(conv)->imhtml);
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(imhtml));
/* store number of lines */
linenumber = gtk_text_buffer_get_line_count(text_buffer);
//this is just used to pass the current line number (before the insertion of the new text)
//to the _displayed_chat_cb func.
//Since pidgin is (mostly) single threaded, this is probably overkill and we could just use
//a single global int.
//On another note, we don't insert the icon here because the message may not end up being displayed
//based on what other plugins do
purple_conversation_set_data(conv, PLUGIN_ID "-icon-ln", GINT_TO_POINTER(linenumber));
return FALSE;
}
/**
* \fn void external_link_catch(GtkWidget *w, GObject *link)
* \brief This function catch the signal when a clic is made on a note.
* \param w The widget which triggered the call.
* \param link ev_link_action.
* \param editor The GUI structure.
*/
void external_link_catch(GtkWidget *widget, GObject *link, BrailleMusicEditor *editor) {
EvLinkAction *l = EV_LINK_ACTION(link);
ev_view_copy_link_address(EV_VIEW(widget), l);
//get line:column link
const gchar * lc = ev_link_action_get_uri(l);
int line, column;
int i = 0;
char c = ' ', temp[2048];
while(c != ':' || i >= strlen(lc)) {
c = lc[i];
temp[i] = c;
i++;
}
temp[i+1]='\0';
line = atoi(temp);
line--;
column = atoi(lc+i);
GtkTextIter it;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor->textview));
if(gtk_text_buffer_get_line_count(buffer) < line ) {
line = 0;
column = 0;
}
gtk_text_buffer_get_iter_at_line(buffer, &it, line);
while(column >0 && !gtk_text_iter_ends_line(&it)) {
gtk_text_iter_forward_char(&it);
column--;
}
gtk_widget_grab_focus(editor->textview);
gtk_text_buffer_place_cursor(buffer, &it);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(editor->textview), &it, 0.0, FALSE, 0.5, 0.5);
}
static gboolean
displaying_im_cb(PurpleAccount *account, const char *who, char **message,
PurpleConversation *conv, PurpleMessageFlags flags,
void *unused)
{
GtkIMHtml *imhtml;
GtkTextBuffer *text_buffer;
gint service = get_service_type(conv);
gint linenumber = 0;
twitter_debug("called\n");
if(service == unknown_service) {
twitter_debug("neither twitter nor wassr conv\n");
return FALSE;
}
/* get text buffer */
imhtml = GTK_IMHTML(PIDGIN_CONVERSATION(conv)->imhtml);
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(imhtml));
/* store number of lines */
linenumber = gtk_text_buffer_get_line_count(text_buffer);
g_hash_table_insert(conv_hash, conv, GINT_TO_POINTER(linenumber));
twitter_debug("conv = %p linenumber = %d\n", conv, linenumber);
return FALSE;
}
//================================================================
int GUI_edi_setLnr (MemObj *mo, long lNr) {
//================================================================
GtkTextIter it1;
// printf("GUI_edi_setLnr %ld\n",lNr);
--lNr; // first line = 1 // 2012-07-13
// set GUI_ed1_view GUI_ed1_buff
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// set iter from lNr
if(lNr == gtk_text_buffer_get_line_count (GUI_ed1_buff)) {
gtk_text_buffer_get_end_iter (GUI_ed1_buff, &it1);
} else {
gtk_text_buffer_get_iter_at_line (GUI_ed1_buff, &it1, lNr);
}
// moves the "insert" and "selection_bound" marks simultaneously
gtk_text_buffer_place_cursor (GUI_ed1_buff, &it1);
// scroll & focus
GUI_edi_scroll_s (NULL);
return 0;
}
static void
docinfo_real (CeditDocument *doc,
DocInfoDialog *dialog)
{
GtkTextIter start, end;
gint words = 0;
gint chars = 0;
gint white_chars = 0;
gint lines = 0;
gint bytes = 0;
gchar *tmp_str;
gchar *doc_name;
cedit_debug (DEBUG_PLUGINS);
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (doc),
&start,
&end);
lines = gtk_text_buffer_get_line_count (GTK_TEXT_BUFFER (doc));
calculate_info (doc,
&start, &end,
&chars, &words, &white_chars, &bytes);
if (chars == 0)
lines = 0;
cedit_debug_message (DEBUG_PLUGINS, "Chars: %d", chars);
cedit_debug_message (DEBUG_PLUGINS, "Lines: %d", lines);
cedit_debug_message (DEBUG_PLUGINS, "Words: %d", words);
cedit_debug_message (DEBUG_PLUGINS, "Chars non-space: %d", chars - white_chars);
cedit_debug_message (DEBUG_PLUGINS, "Bytes: %d", bytes);
doc_name = cedit_document_get_short_name_for_display (doc);
tmp_str = g_strdup_printf ("<span weight=\"bold\">%s</span>", doc_name);
gtk_label_set_markup (GTK_LABEL (dialog->file_name_label), tmp_str);
g_free (doc_name);
g_free (tmp_str);
tmp_str = g_strdup_printf("%d", lines);
gtk_label_set_text (GTK_LABEL (dialog->lines_label), tmp_str);
g_free (tmp_str);
tmp_str = g_strdup_printf("%d", words);
gtk_label_set_text (GTK_LABEL (dialog->words_label), tmp_str);
g_free (tmp_str);
tmp_str = g_strdup_printf("%d", chars);
gtk_label_set_text (GTK_LABEL (dialog->chars_label), tmp_str);
g_free (tmp_str);
tmp_str = g_strdup_printf("%d", chars - white_chars);
gtk_label_set_text (GTK_LABEL (dialog->chars_ns_label), tmp_str);
g_free (tmp_str);
tmp_str = g_strdup_printf("%d", bytes);
gtk_label_set_text (GTK_LABEL (dialog->bytes_label), tmp_str);
g_free (tmp_str);
}
static void
recalculate_size (GtkSourceGutterRendererLines *renderer)
{
gint num_lines;
gint num_digits = 0;
GtkTextBuffer *buffer;
buffer = get_buffer (renderer);
num_lines = gtk_text_buffer_get_line_count (buffer);
num_digits = count_num_digits (num_lines);
if (num_digits != renderer->priv->num_line_digits)
{
gchar markup[24];
gint size;
renderer->priv->num_line_digits = num_digits;
num_lines = MAX (num_lines, 99);
g_snprintf (markup, sizeof markup, "<b>%d</b>", num_lines);
gtk_source_gutter_renderer_text_measure_markup (GTK_SOURCE_GUTTER_RENDERER_TEXT (renderer),
markup,
&size,
NULL);
gtk_source_gutter_renderer_set_size (GTK_SOURCE_GUTTER_RENDERER (renderer),
size);
}
}
static void
dma_chunk_view_move_cursor (GtkTextView *text_view,
GtkMovementStep step,
gint count,
gboolean extend_selection)
{
DmaChunkView *view = DMA_CHUNK_VIEW (text_view);
GtkTextMark *mark;
GtkTextBuffer *buffer;
GtkTextIter cur;
gint line;
gdouble value, step_increment;
switch (step)
{
case GTK_MOVEMENT_LOGICAL_POSITIONS:
case GTK_MOVEMENT_VISUAL_POSITIONS:
case GTK_MOVEMENT_WORDS:
case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
case GTK_MOVEMENT_HORIZONTAL_PAGES:
break;
case GTK_MOVEMENT_DISPLAY_LINES:
case GTK_MOVEMENT_PARAGRAPHS:
case GTK_MOVEMENT_PARAGRAPH_ENDS:
buffer = gtk_text_view_get_buffer (text_view);
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
line = gtk_text_iter_get_line (&cur);
step_increment = gtk_adjustment_get_step_increment (view->vadjustment);
if ((count < 0) && (line == 0))
{
value += count * step_increment;
set_adjustment_clamped (view->vadjustment, value);
return;
}
else if ((count > 0) && (line == gtk_text_buffer_get_line_count(buffer) - 1))
{
value += count * step_increment;
set_adjustment_clamped (view->vadjustment, value);
return;
}
break;
case GTK_MOVEMENT_PAGES:
value += count * gtk_adjustment_get_page_increment (view->vadjustment);
set_adjustment_clamped (view->vadjustment, value);
return;
case GTK_MOVEMENT_BUFFER_ENDS:
set_adjustment_clamped (view->vadjustment,
count < 0 ? gtk_adjustment_get_lower (view->vadjustment) : gtk_adjustment_get_upper (view->vadjustment));
return;
default:
break;
}
GTK_TEXT_VIEW_CLASS (parent_class)->move_cursor (text_view,
step, count,
extend_selection);
}
void Gobby::GotoDialog::on_changed()
{
g_assert(m_current_view != NULL);
GtkTextBuffer* buffer = GTK_TEXT_BUFFER(
m_current_view->get_text_buffer());
m_entry_line.set_range(1, gtk_text_buffer_get_line_count(buffer));
}
/* Removes indent that is mean to be changes and inserts
* tabs and/or spaces insted */
static void
gbp_retab_editor_page_addin_retab (GtkTextBuffer *buffer,
gint line,
gint tab_width,
gint indent,
gboolean to_spaces)
{
g_autoptr(GString) new_indent = g_string_new (NULL);
GtkTextIter iter;
GtkTextIter begin;
GtkTextIter end;
gint tab_num = 0;
gint space_num = 0;
g_assert (GTK_IS_TEXT_BUFFER (buffer));
g_assert (line >= 0 && line < gtk_text_buffer_get_line_count(buffer));
g_assert (tab_width != 0);
g_assert (new_indent != NULL);
gtk_text_buffer_get_iter_at_line (buffer, &iter, line);
while (!gtk_text_iter_ends_line (&iter) &&
g_unichar_isspace(gtk_text_iter_get_char (&iter)))
{
if (gtk_text_iter_get_char (&iter) == ' ')
++space_num;
else if (gtk_text_iter_get_char (&iter) == '\t')
++tab_num;
gtk_text_iter_forward_char (&iter);
}
if (to_spaces)
{
for (gint tab = 0; tab < tab_num * tab_width; ++tab)
g_string_append_c(new_indent, ' ');
for (gint space = 0; space < space_num; ++space)
g_string_append_c(new_indent, ' ');
}
else
{
for (gint tab = 0; tab < tab_num + (space_num / tab_width); ++tab)
g_string_append_c(new_indent, '\t');
for (gint space = 0; space < space_num % tab_width; ++space)
g_string_append_c(new_indent, ' ');
}
gtk_text_buffer_get_iter_at_line(buffer, &begin, line);
gtk_text_buffer_get_iter_at_line_offset (buffer, &end, line, indent);
gtk_text_buffer_delete (buffer, &begin, &end);
if (new_indent->len)
gtk_text_buffer_insert (buffer, &begin, new_indent->str, new_indent->len);
}
/**
* Print the current contents of a text buffer.
* @param buffer text buffer to print information about
*/
void mk_print_GtkTextBuffer_info(GtkTextBuffer* buffer)
{
GtkTextIter start;
GtkTextIter end;
gtk_text_buffer_get_bounds(buffer, &start, &end);
const gchar* text = gtk_text_buffer_get_text(buffer, &start, &end, 0);
gint lines = gtk_text_buffer_get_line_count(buffer);
g_printf("\t%d\n%s", lines, text);
}
static char *
generate_syntax (const struct comment_dialog *cd)
{
gint i;
GString *str;
gchar *text;
GtkWidget *tv = get_widget_assert (cd->xml, "comments-textview1");
GtkWidget *check = get_widget_assert (cd->xml, "comments-checkbutton1");
GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tv));
str = g_string_new ("\n* Data File Comments.\n\n");
if (dict_get_documents (cd->dict->dict) != NULL)
g_string_append (str, "DROP DOCUMENTS.\n");
g_string_append (str, "ADD DOCUMENT\n");
for (i = 0 ; i < gtk_text_buffer_get_line_count (buffer) ; ++i )
{
struct string tmp;
GtkTextIter start;
char *line;
gtk_text_buffer_get_iter_at_line (buffer, &start, i);
if (gtk_text_iter_ends_line (&start))
line = g_strdup ("");
else
{
GtkTextIter end = start;
gtk_text_iter_forward_to_line_end (&end);
line = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
}
ds_init_empty (&tmp);
syntax_gen_string (&tmp, ss_cstr (line));
g_free (line);
g_string_append_printf (str, " %s\n", ds_cstr (&tmp));
ds_destroy (&tmp);
}
g_string_append (str, " .\n");
if ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check)))
g_string_append (str, "DISPLAY DOCUMENTS.\n");
text = str->str;
g_string_free (str, FALSE);
return text;
}
static gint on_last_line (GtkWidget *cview)
{
GtkTextBuffer *buf;
GtkTextIter iter;
buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(cview));
gtk_text_buffer_get_iter_at_mark(buf, &iter, gtk_text_buffer_get_insert(buf));
return (gtk_text_iter_get_line(&iter) ==
gtk_text_buffer_get_line_count(buf) - 1);
}
void LeftMargin::updateTextInfo(GtkTextView *textView)
{
char str[8];
snprintf(str, sizeof(str), "%d",
gtk_text_buffer_get_line_count(gtk_text_view_get_buffer(textView)));
pango_layout_set_text(mMarginLayout, str, -1);
pango_layout_get_pixel_size(mMarginLayout, &mTextWidth, NULL);
int len = strlen(str);
if(len > 0)
mPixPerChar = mTextWidth / len;
else
mPixPerChar = 10;
}
static void entry_changed_cb(GtkTextBuffer *buffer, void *data)
{
char *xmlstr, *str;
GtkTextIter iter;
int wrapped_lines;
int lines;
GdkRectangle oneline;
int height;
int pad_top, pad_inside, pad_bottom;
GtkTextIter start, end;
xmlnode *node;
wrapped_lines = 1;
gtk_text_buffer_get_start_iter(buffer, &iter);
gtk_text_view_get_iter_location(GTK_TEXT_VIEW(console->entry), &iter, &oneline);
while (gtk_text_view_forward_display_line(GTK_TEXT_VIEW(console->entry), &iter))
wrapped_lines++;
lines = gtk_text_buffer_get_line_count(buffer);
/* Show a maximum of 64 lines */
lines = MIN(lines, 6);
wrapped_lines = MIN(wrapped_lines, 6);
pad_top = gtk_text_view_get_pixels_above_lines(GTK_TEXT_VIEW(console->entry));
pad_bottom = gtk_text_view_get_pixels_below_lines(GTK_TEXT_VIEW(console->entry));
pad_inside = gtk_text_view_get_pixels_inside_wrap(GTK_TEXT_VIEW(console->entry));
height = (oneline.height + pad_top + pad_bottom) * lines;
height += (oneline.height + pad_inside) * (wrapped_lines - lines);
gtk_widget_set_size_request(console->sw, -1, height + 6);
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
str = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
if (!str)
return;
xmlstr = g_strdup_printf("<xml>%s</xml>", str);
node = xmlnode_from_str(xmlstr, -1);
if (node) {
gtk_imhtml_clear_formatting(GTK_IMHTML(console->entry));
} else {
gtk_imhtml_toggle_background(GTK_IMHTML(console->entry), "#ffcece");
}
g_free(str);
g_free(xmlstr);
if (node)
xmlnode_free(node);
}
/* TODO: Move to ConboyNoteBuffer */
void note_format_title(GtkTextBuffer *buffer)
{
GtkTextIter start, end;
/* Set end iter depending on if we have one or more lines */
if (gtk_text_buffer_get_line_count(buffer) == 1) {
gtk_text_buffer_get_end_iter(buffer, &end);
} else {
gtk_text_buffer_get_iter_at_line(buffer, &end, 1);
gtk_text_iter_backward_char(&end);
}
/* Set start iter, remove all tags and add _title tags */
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_remove_all_tags(buffer, &start, &end);
gtk_text_buffer_apply_tag_by_name(buffer, "_title", &start, &end);
}
/* TODO: Move to ConboyNoteBuffer
* The return value needs to be freed by the caller.
*/
gchar* note_extract_title_from_buffer(GtkTextBuffer *buffer)
{
GtkTextIter start, end;
gchar* title;
/* Set end iter depending on if we have one or more lines */
if (gtk_text_buffer_get_line_count(buffer) == 1) {
gtk_text_buffer_get_end_iter(buffer, &end);
} else {
gtk_text_buffer_get_iter_at_line(buffer, &end, 1);
gtk_text_iter_backward_char(&end);
}
gtk_text_buffer_get_start_iter(buffer, &start);
title = gtk_text_iter_get_text(&start, &end);
return title;
}
/*---------------------------------------------------------------------*/
void
hop_console_adjust() {
GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW( console ) );
int count = gtk_text_buffer_get_line_count( console_buffer );
if( count > HOP_CONSOLE_MAX_LINE ) {
GtkTextIter start_del;
GtkTextIter end_del;
int l = count - HOP_CONSOLE_MAX_LINE;
gtk_text_buffer_get_iter_at_offset( console_buffer, &start_del, 0 );
gtk_text_buffer_get_iter_at_line_offset( console_buffer, &end_del, l, 0 );
gtk_text_buffer_delete( console_buffer, &start_del, &end_del );
}
/* gtk_adjustment_set_value( adj, adj->upper ); */
}
//================================================================
long GUI_edi_RdLn (char *sOut, int sSiz, long lNr, MemObj *mo) {
//================================================================
/// \code
/// GUI_edi_RdLn get line (copy)
/// RetCod: size of line or -1 (EOF)
/// \endcode
// was GUI_Ed_RdLnAct
int i1;
GtkTextIter it1, it2;
// set GUI_ed1_view GUI_ed1_buff
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// printf("GUI_edi_RdLn %ld\n",lNr);
// printf(" lMax=%d\n",gtk_text_buffer_get_line_count (GUI_ed1_buff));
i1 = gtk_text_buffer_get_line_count (GUI_ed1_buff);
// printf("GUI_edi_RdLn %ld tot=%d\n",lNr,i1);
if(lNr > i1) {
return -1; // past EOF
} else if(lNr == i1) {
// last line
gtk_text_buffer_get_end_iter (GUI_ed1_buff, &it2);
} else {
gtk_text_buffer_get_iter_at_line (GUI_ed1_buff, &it2, lNr);
}
--lNr;
gtk_text_buffer_get_iter_at_line (GUI_ed1_buff, &it1, lNr);
return GUI_edi_Rd2it (sOut, sSiz, &it1, &it2, NULL);
}
/*
* 'Go To Line'
*/
void av_editor_goto_line(const av_editor *editor, guint line)
{
guint line_cnt = 0;
GtkTextIter iter;
g_return_if_fail(editor != NULL && editor->textbuf != NULL);
line_cnt = gtk_text_buffer_get_line_count(editor->textbuf);
if (line >= line_cnt)
{
gtk_text_buffer_get_end_iter(editor->textbuf, &iter);
}
else
{
gtk_text_buffer_get_iter_at_line (editor->textbuf, &iter, line - 1);
}
/* Go to the line */
gtk_text_buffer_place_cursor(editor->textbuf, &iter);
}
//================================================================
long GUI_edi_getLnMax (MemObj *mo) {
//================================================================
/// GUI_edi_getLnMax get total-lines-nr
long lNr;
// set GUI_ed1_view GUI_ed1_buff
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// check eof
lNr = gtk_text_buffer_get_line_count (GUI_ed1_buff);
// printf("ex GUI_edi_getLnMax %ld\n",lNr);
return (lNr);
}
/* affichage des commentaires dans la sous fenetre buffer text*/
void affiche_comment(GtkTextBuffer *buffer, type_noeud_comment *comment)
{
GtkTextIter iter;
if (comment == NULL)
{
return;
}
gtk_text_buffer_get_line_count(buffer);
gtk_text_buffer_set_text(buffer, comment->chaine, -1);
gtk_text_buffer_get_end_iter(buffer, &iter);
comment = comment->suiv;
while (comment != NULL)
{
gtk_text_buffer_insert(buffer, &iter, comment->chaine, -1);
comment = comment->suiv;
}
}
//================================================================
int GUI_edi_mod_ln (MemObj *mo, long lNr, char *newLn) {
//================================================================
/// change line lNr into <newLn>
GtkTextIter it1, it2;
// printf("GUI_edi_mod_ln %ld |%s|\n",lNr,newLn);
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// DOES NOT WORK FOR LAST LINE !
// also used in GUI_edi_RdLn
if(lNr == gtk_text_buffer_get_line_count (GUI_ed1_buff)) {
gtk_text_buffer_get_end_iter (GUI_ed1_buff, &it2);
} else {
gtk_text_buffer_get_iter_at_line (GUI_ed1_buff, &it2, lNr);
gtk_text_iter_backward_char (&it2); // skip '\n'
}
--lNr;
gtk_text_buffer_get_iter_at_line (GUI_ed1_buff, &it1, lNr);
// del
gtk_text_buffer_delete (GUI_ed1_buff, &it1, &it2);
// insert at iterPos
gtk_text_buffer_insert (GUI_ed1_buff, &it1, newLn, -1);
return 0;
}
void
InfoWinDrawInfoText(const char *str)
{
GtkTextBuffer *buf;
GtkTextIter iter;
gint len;
GtkTextMark *mark;
if (str == NULL)
return;
if (NgraphApp.InfoWin.Win == NULL) {
return;
}
if (NgraphApp.InfoWin.data.text == NULL) {
return;
}
buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(NgraphApp.InfoWin.data.text));
gtk_text_buffer_get_end_iter(buf, &iter);
gtk_text_buffer_insert(buf, &iter, str, -1);
len = gtk_text_buffer_get_line_count(buf);
if (len > Menulocal.info_size) {
GtkTextIter start, end;
gtk_text_buffer_get_start_iter(buf, &start);
gtk_text_buffer_get_iter_at_line(buf, &end, len - Menulocal.info_size);
gtk_text_buffer_delete(buf, &start, &end);
}
gtk_text_buffer_get_end_iter(buf, &iter);
gtk_text_buffer_place_cursor(buf, &iter);
mark = gtk_text_buffer_get_selection_bound(buf);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(NgraphApp.InfoWin.data.text), mark);
}
void gTextArea::setLine(int vl)
{
int col = column();
GtkTextIter *iter = getIterAt();
if (vl < 0)
{
setPosition(0);
return;
}
else if (vl >= gtk_text_buffer_get_line_count(_buffer))
{
setPosition(length());
return;
}
gtk_text_iter_set_line(iter, vl);
if (gtk_text_iter_get_chars_in_line(iter) <= col)
col = gtk_text_iter_get_chars_in_line(iter) - 1;
gtk_text_iter_set_line_offset(iter, col);
gtk_text_buffer_place_cursor(_buffer, iter);
ensureVisible();
}
static void
show_parsing_error (GtkCssProvider *provider,
const gchar *path,
guint line,
guint position,
const GError *error,
GtkTextBuffer *buffer)
{
GtkTextIter start, end;
const char *tag_name;
gtk_text_buffer_get_iter_at_line (buffer, &start, line - 1);
if (gtk_text_buffer_get_line_count (buffer) <= line)
gtk_text_buffer_get_end_iter (buffer, &end);
else
gtk_text_buffer_get_iter_at_line (buffer, &end, line);
if (g_error_matches (error, GTK_CSS_PROVIDER_ERROR, GTK_CSS_PROVIDER_ERROR_DEPRECATED))
tag_name = "warning";
else
tag_name = "error";
gtk_text_buffer_apply_tag_by_name (buffer, tag_name, &start, &end);
}
