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); }