static gboolean gtkui_connections_scroll(gpointer data)
{
if((int)data == 1 && textview1 && endmark1 && textview2 && endmark2) {
/* scroll split data views to bottom */
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW (textview1), endmark1, 0, FALSE, 0, 0);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW (textview2), endmark2, 0, FALSE, 0, 0);
} else if(textview3 && endmark3) {
/* scroll joined data view to bottom */
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW (textview3), endmark3, 0, FALSE, 0, 0);
}
/* only execute once, don't repeat */
return(FALSE);
}
void write(std::string stringToInsert)
{
const char *charToInsert;
charToInsert = stringToInsert.c_str();
gtk_text_buffer_insert (dialogBuffer, &endIter, charToInsert, -1);
gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (dialogText), endMark, 0.0, FALSE, 0.0, 1.0);
};
extern void show_message_history(const char *history)
{
GtkTextBuffer *historybuffer = NULL;
GtkTextIter end;
GtkTextMark *mark;
historybuffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(history_view) );
if(history)
{
//TODO not checking if historybuffer is non-NULL because I think gtktextview always has a gtktextbuffer
gtk_text_buffer_set_text( historybuffer, history, -1 ); //-1 cuz text is terminated
/*scroll down*/
gtk_text_buffer_get_end_iter( historybuffer, &end );
mark = gtk_text_mark_new( NULL, FALSE );
gtk_text_buffer_add_mark( historybuffer, mark, &end );
gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(history_view), mark, 0, FALSE, 1.0, 1.0 );
}
else
{
gtk_text_buffer_set_text( historybuffer, "<No recent chats found>", -1 ); //-1 cuz text is terminated
}
return;
}
void upload_cb(GtkWidget *tool, GtkTextView *output)
{
if (project_path->str == NULL)
return;
FILE *make;
char tmp[BUF_LEN];
GtkTextBuffer *text_buffer;
GtkTextIter end;
GtkTextMark *mk;
text_buffer = gtk_text_view_get_buffer(output);
make = popen("make upload 2>&1", "r");
if (make == NULL) {
fprintf(stderr, "Failed to call 'make clean'\n");
return;
}
while (fgets(tmp, BUF_LEN, make) != NULL) {
gtk_text_buffer_get_end_iter(text_buffer, &end);
gtk_text_buffer_insert(text_buffer, &end, tmp, -1);
}
mk = gtk_text_buffer_get_mark (text_buffer, "insert");
gtk_text_view_scroll_to_mark (output, mk, 0.0, FALSE, 0.0, 0.0);
}
static gint
progress_log_cb(GWEN_GUI *gwen_gui, guint32 id, GWEN_LOGGER_LEVEL level,
const gchar *text)
{
GncGWENGui *gui = GETDATA_GUI(gwen_gui);
GtkTextBuffer *tb;
GtkTextView *tv;
g_return_val_if_fail(gui, -1);
ENTER("gui=%p, text=%s", gui, text ? text : "(null)");
tv = GTK_TEXT_VIEW(gui->log_text);
tb = gtk_text_view_get_buffer(tv);
gtk_text_buffer_insert_at_cursor(tb, text, -1);
gtk_text_buffer_insert_at_cursor(tb, "\n", -1);
/* Scroll to the end of the buffer */
gtk_text_view_scroll_to_mark(tv, gtk_text_buffer_get_insert(tb),
0.0, FALSE, 0.0, 0.0);
/* Cache loglevel */
if (level < gui->min_loglevel)
gui->min_loglevel = level;
LEAVE(" ");
return !keep_alive(gui);
}
void chatbox_insert_msg(chatbox_t *chatbox, char *sender, time_t *tm, char *msg) {
char buf[65535];
GtkTextView *output_textview;
GtkTextBuffer *output_buffer;
GtkTextIter start;
GtkTextIter end;
GtkTextMark *mark;
chatbox = (chatbox_t*)(chatbox);
output_textview = chatbox->display_textview;
output_buffer = gtk_text_view_get_buffer(output_textview);
sprintf(buf, "%s(%s):\n", sender, my_ctime(tm));
gtk_text_buffer_get_end_iter(output_buffer, &end);
gtk_text_buffer_insert_with_tags_by_name(output_buffer, &end,
buf, -1, "blue_fg", "lmarg", "title_font", NULL);
insert_msg_with_emotion_to_textview(output_textview, msg);
gtk_text_buffer_get_end_iter(output_buffer, &end);
mark = gtk_text_buffer_create_mark(output_buffer, NULL, &end, FALSE);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(output_textview), mark,
0.0, TRUE, 0.0, 0.0);
gtk_text_buffer_delete_mark(output_buffer, mark);
}
void ctk_help_set_page(CtkHelp *ctk_help, GtkTextBuffer *buffer)
{
GtkTextBuffer *b;
GtkTextIter iter;
GtkTextView *view;
GtkTextMark *mark;
if (buffer) {
b = buffer;
} else {
b = ctk_help->default_help;
}
view = GTK_TEXT_VIEW(ctk_help->text_viewer);
/* set the buffer in the TextView */
gtk_text_view_set_buffer(view, b);
/* ensure that the top of the buffer is displayed */
gtk_text_buffer_get_start_iter(b, &iter);
mark = gtk_text_buffer_create_mark(b, NULL, &iter, TRUE);
gtk_text_view_scroll_to_mark(view, mark, 0.0, TRUE, 0.0, 0.0);
gtk_text_buffer_place_cursor(b, &iter);
}
static gint scroll_to_top()
{
GtkTextIter iter;
GtkTextMark *mark;
LOG(LOG_DEBUG, "IN : scroll_to_top()");
gtk_text_buffer_get_start_iter (text_buffer, &iter);
mark = gtk_text_buffer_create_mark(text_buffer,
"start",
&iter,
TRUE);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(popup_view),
mark,
0.0,
TRUE,
0.0, 0.0);
gtk_text_buffer_delete_mark(text_buffer, mark);
LOG(LOG_DEBUG, "OUT : scroll_to_top()");
return(0);
}
gint
add_text(gpointer data)
{
GtkTextBuffer *text_buffer = gtk_text_view_get_buffer(
GTK_TEXT_VIEW(text_view));
GtkTextIter text_iter;
gtk_text_buffer_get_end_iter(text_buffer, &text_iter);
if (count == 0) {
gtk_text_buffer_insert(text_buffer, &text_iter, "First line\n", -1);
}
else if (count % 5 == 0) {
gtk_text_buffer_insert(text_buffer, &text_iter, "world\n", -1);
}
else {
gtk_text_buffer_insert(text_buffer, &text_iter, "hello\n", -1);
}
count++;
/* - - DOES NOT WORK LIKE I EXPECT */
GtkTextMark *mark = gtk_text_buffer_get_insert(text_buffer);
gtk_text_buffer_move_mark(text_buffer, mark, &text_iter);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(text_view), mark, 0.0,
FALSE, 0, 0);
/* - - */
return TRUE;
}
void scroll_to_the_end(struct text_view_info *viewinfo){
GtkTextIter end;
gtk_text_buffer_get_end_iter(viewinfo->view1_buffer,&end);
GtkTextMark *mark=gtk_text_buffer_create_mark(viewinfo->view1_buffer,NULL,&end,1);
gtk_text_buffer_move_mark(viewinfo->view1_buffer,mark,&end);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(viewinfo->view1),mark,0,1,1,1);
}
//================================================================
int GUI_edi_scroll_s (MemObj *mo) {
//================================================================
/// scroll to active insert-mark
/// makes unselect ?
GtkTextMark *mk1;
GtkTextIter it1;
// printf("GUI_edi_scroll_s \n");
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// scroll to insert-mark:
mk1 = gtk_text_buffer_get_mark (GUI_ed1_buff, "insert");
// gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW(wTx->view), &it1,
gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (GUI_ed1_view), mk1,
0.1, // within_margin
FALSE, // use_align
0.5, 0.0); // xalign,yalign
// ohne foc selection nicht sichbar !!
GUI_edi_Focus (NULL);
return 0;
}
static VALUE
textview_scroll_to_mark(VALUE self, VALUE mark, VALUE within_margin, VALUE use_align, VALUE xalign, VALUE yalign)
{
gtk_text_view_scroll_to_mark(_SELF(self), RVAL2MARK(mark),
NUM2DBL(within_margin), RVAL2CBOOL(use_align),
NUM2DBL(xalign), NUM2DBL(yalign));
return self;
}
/*
* Function: refresh_textview_from_fd
*
* This function is called when data are readable from our pipe.
* It reads the data and adds it to the GTK textview.
*/
gboolean refresh_textview_from_fd(GIOChannel * channel,
GIOCondition condition, gpointer data)
{
GtkTextView *view = GTK_TEXT_VIEW(data);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
gchar buf[1024];
gsize len;
GError *error = NULL;
gint status;
while ((status =
g_io_channel_read_chars(channel, buf, 1024, &len, &error))
== G_IO_STATUS_AGAIN) {
while (gtk_events_pending())
gtk_main_iteration();
}
if (status != G_IO_STATUS_NORMAL) {
/* status = G_IO_STATUS_ERROR or G_IO_STATUS_EOF */
if (error) {
fprintf(stderr, _("Error while reading sub-child output : %s"),
error->message);
g_error_free(error);
error = NULL;
}
return FALSE;
}
if (len > 0) {
GtkTextIter end;
GtkTextMark *mark;
gchar *utftext;
gsize localelen;
gsize utflen;
gtk_text_buffer_get_end_iter(buffer, &end);
if (!g_utf8_validate(buf, len, NULL)) {
utftext =
g_convert_with_fallback(buf, len, "UTF-8",
"ISO-8859-1", NULL, &localelen,
&utflen, NULL);
gtk_text_buffer_insert(buffer, &end, utftext, utflen);
g_free(utftext);
} else {
gtk_text_buffer_insert(buffer, &end, buf, len);
}
/* Scroll down TextView */
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(view), mark, 0.0, FALSE,
0.0, 1.0);
}
return TRUE;
}
static void
tab_scroll_down(Chattab *tab)
{
GtkAdjustment *adj;
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(tab->tview), tab->mk,
0.0, FALSE, 0.0, 0.0);
adj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(tab->scrolled));
gtk_adjustment_set_value(adj, adj->upper);
} /* tab_scroll_down */
extern void append_to_history_view( const char *buffer, const char *sender )
{
GtkTextBuffer *historybuffer = NULL;
GtkTextIter start;
GtkTextIter end;
GtkTextMark *mark;
char *history = NULL;
unsigned int char_count;
char *to_append = NULL;
gboolean need_newline = TRUE;
historybuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(history_view));
/*check for "<No recent chats found>" at the top of historybuffer and remove it*/
char_count = gtk_text_buffer_get_char_count(historybuffer);
if( char_count == strlen("<No recent chats found>") )
{
gtk_text_buffer_get_bounds( historybuffer, &start, &end );
//TODO check if history needs to be free()d (look at source of gtk_text_buffer)
history = gtk_text_buffer_get_text( historybuffer, &start, &end, FALSE );
if( strcmp( history, "<No recent chats found>" ) == 0 )
{
gtk_text_buffer_delete( historybuffer, &start, &end );
need_newline = FALSE;
}
free(history);
}
/*"<No recent chats found>" is not or no longer at the top of historybuffer*/
/*prepend a '\n' to buffer and insert into historybuffer*/
if(need_newline)
{
to_append = calloc( 1 + strlen(sender) + 2 + strlen(buffer) + 1, sizeof(char) );
*to_append = '\n';
strncpy( to_append+1, sender, strlen(sender)+1 );
strncat( to_append, ": ", strlen(": ") );
strncat( to_append, buffer, strlen(buffer) );
}
else
{
to_append = calloc( strlen(sender) + 2 + strlen(buffer) + 1, sizeof(char) );
strncpy( to_append, sender, strlen(sender)+1 );//TODO there was no +1 at first, that's not good or? (~10 lines above there was +1)
strncat( to_append, ": ", strlen(": ") );
strncat( to_append, buffer, strlen(buffer) );
}
gtk_text_buffer_get_end_iter( historybuffer, &end );
gtk_text_buffer_insert( historybuffer, &end, to_append, -1 );
/*scroll down*/
gtk_text_buffer_get_end_iter( historybuffer, &end );
mark = gtk_text_mark_new( NULL, FALSE );
gtk_text_buffer_add_mark( historybuffer, mark, &end );
gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW(history_view), mark, 0, FALSE, 1.0, 1.0 );
return;
}
void write(int intToInsert)
{
const char *charToInsert;
std::stringstream tempStringStream;
tempStringStream << intToInsert;
std::string tempString = tempStringStream.str();
charToInsert = tempString.c_str();
gtk_text_buffer_insert (dialogBuffer, &endIter, charToInsert, -1);
gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (dialogText), endMark, 0.0, FALSE, 0.0, 1.0);
};
/*
* 'Search Backward'
*/
void av_editor_search_backward(const av_editor *editor)
{
GtkTextIter iter_search_start, iter_search_end;
GtkTextIter iter_match_start, iter_match_end;
GtkTextIter iter_end;
GtkTextSearchFlags flags_search;
gchar *text_search = NULL;
gboolean found = FALSE;
gboolean status = FALSE;
g_return_if_fail(editor != NULL && editor->textbuf != NULL);
status = gtk_text_buffer_get_selection_bounds(GTK_TEXT_BUFFER(editor->textbuf),
&iter_search_start,
&iter_search_end);
g_return_if_fail(status == TRUE);
text_search = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(editor->textbuf),
&iter_search_start,
&iter_search_end,
FALSE);
g_return_if_fail(text_search != NULL);
iter_end = iter_search_start;
flags_search = GTK_TEXT_SEARCH_VISIBLE_ONLY | GTK_TEXT_SEARCH_TEXT_ONLY;
found = editor_search_backward(editor,
text_search,
flags_search,
NULL,
&iter_end,
&iter_match_start,
&iter_match_end);
if (found)
{
gtk_text_buffer_place_cursor(GTK_TEXT_BUFFER(editor->textbuf), &iter_match_start);
gtk_text_buffer_move_mark_by_name (GTK_TEXT_BUFFER(editor->textbuf),
AV_EDITOR_MARK_NAME_SELECTION_BOUND,
&iter_match_end);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(editor->textview),
gtk_text_buffer_get_insert(editor->textbuf),
AV_EDITOR_VIEW_SCROLL_MARGIN,
FALSE,
AV_EDITOR_VIEW_SCROLL_XALIGN,
AV_EDITOR_VIEW_SCROLL_YALIGN);
}
else
{
// Do nothing here
AV_DBG("%s: search text backward: %s: not found\n", __func__, text_search);
}
}
//处理接收到的数据，加入接收框内
void deal_message(char *data)
{
GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(textRecv));
char msg[1024];
char *p;
char *delim = ":|";
time_t t;
p = strtok(data, delim);
if (strcmp(p, "message") != 0)
{
return;
}
int i = 0;
while((p = strtok(NULL, delim)))
{
switch (i)
{
case 0:
strcpy(msg, p);
strcat(msg, "\t");
break;
case 1:
t = atoi(p);
strcat(msg, ctime(&t));
break;
case 3:
strcat(msg, p);
strcat(msg, "\n\n");
break;
default:
break;
}
i++;
}
int msg_len = strlen(msg);
GtkTextIter start;
GtkTextIter end;
gtk_text_buffer_get_start_iter (buffer, &start);
gtk_text_buffer_get_end_iter (buffer, &end);
//消息框文本达到最大长度
if (length + msg_len >= MAXSIZE)
{
gtk_text_buffer_delete (buffer, &start, &end);
gtk_text_buffer_insert(buffer, &end, (gchar*)msg, strlen(msg));
length = msg_len;
}
else
{
gtk_text_buffer_insert (buffer, &end,(gchar *)msg, strlen(msg));
length += msg_len;
}
GtkTextMark *mk = gtk_text_buffer_get_insert (buffer);
gtk_text_view_scroll_to_mark (textRecv, mk, 0.0, FALSE, 0,0);
}
static gboolean
gb_vim_jump_to_line (GtkWidget *active_widget,
const gchar *command,
const gchar *options,
GError **error)
{
g_assert (GTK_IS_WIDGET (active_widget));
if (IDE_IS_EDITOR_VIEW (active_widget))
{
GtkSourceView *source_view = GTK_SOURCE_VIEW (IDE_EDITOR_VIEW (active_widget)->frame1->source_view);
GtkTextBuffer *buffer;
gboolean extend_selection;
gint line;
if (!int32_parse (&line, options, 0, G_MAXINT32, "line number", error))
return FALSE;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view));
extend_selection = gtk_text_buffer_get_has_selection (buffer);
ide_source_view_set_count (IDE_SOURCE_VIEW (source_view), line);
if (line == 0)
{
GtkTextIter iter;
/*
* Zero is not a valid line number, and IdeSourceView treats
* that as a move to the end of the buffer. Instead, we want
* line 1 to be like vi/vim.
*/
gtk_text_buffer_get_start_iter (buffer, &iter);
gtk_text_buffer_select_range (buffer, &iter, &iter);
gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (source_view),
gtk_text_buffer_get_insert (buffer),
0.0, FALSE, 0.0, 0.0);
}
else
{
g_signal_emit_by_name (source_view,
"movement",
IDE_SOURCE_VIEW_MOVEMENT_NTH_LINE,
extend_selection, TRUE, TRUE);
}
ide_source_view_set_count (IDE_SOURCE_VIEW (source_view), 0);
g_signal_emit_by_name (source_view, "save-insert-mark");
return TRUE;
}
else
return gb_vim_set_source_view_error (error);
}
/* Set length to a positive number to enable line input; set to 0 to disable */
void gglk_text_line_input_set(GglkText *tb, int length,
const gunichar *text)
{
GtkTextIter b, e;
gchar *line_utf8;
if(tb->line_maxlen != 0) {
gglk_text_line_input_end(tb);
/* Clear out old text there */
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &e, tb->endedit);
gtk_text_buffer_delete(tb->buffer, &b, &e);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &tb->iter, tb->startedit);
}
tb->line_maxlen = length;
if(length == 0) {
gglk_text_line_input_end(tb);
return;
}
/* Add new text */
gtk_text_buffer_get_end_iter(tb->buffer, &b);
gtk_text_buffer_move_mark(tb->buffer, tb->startedit, &b);
line_utf8 = g_ucs4_to_utf8(text, -1, NULL, NULL, NULL);
gtk_text_buffer_insert(tb->buffer, &b, line_utf8, -1);
g_free(line_utf8);
/* Extra character at end to maintain editability */
gtk_text_buffer_get_end_iter(tb->buffer, &e);
gtk_text_buffer_insert(tb->buffer, &e, " ", -1);
/* Make editable */
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_apply_tag_by_name(tb->buffer, "Input", &b, &e);
gtk_text_buffer_apply_tag_by_name(tb->buffer, "editable", &b, &e);
/* Set end mark */
gtk_text_iter_backward_char(&e);
gtk_text_buffer_move_mark(tb->buffer, tb->endedit, &e);
gtk_text_buffer_place_cursor(tb->buffer, &e);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(tb), tb->endedit, 0,FALSE,0,0);
/* Add signals to handle user interaction */
tb->cursor_handler = g_signal_connect(
tb->buffer, "mark-set",
GTK_SIGNAL_FUNC(gglk_text_cursor_event), tb);
tb->update_handler = g_signal_connect(
tb->buffer, "end-user-action",
GTK_SIGNAL_FUNC(gglk_text_update_editable_region), tb);
}
void chat_scroll_to_end(GtkTextBuffer *buffer, GtkTextIter *location,
gchar *text, gint len, gpointer data)
{
Chat *chat = (Chat *) data;
GtkTextIter end;
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_create_mark(buffer, "end", &end, FALSE);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(chat->text_view),
gtk_text_buffer_get_mark(buffer, "end"),
0.0, TRUE, 0.0, 0.5);
}
/*******************************************************************************
* Advance the cursor n positions on the tutor text view
*/
gint
cursor_advance (gint n)
{
gint i;
gboolean cursor_out_screen;
GtkWidget *wg;
GtkTextBuffer *buf;
GtkTextIter new_start;
GtkTextIter old_start;
GtkTextIter end;
GtkTextMark *mark;
wg = get_wg ("text_tutor");
buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (wg));
/* Get current position for the iter old_start */
gtk_text_buffer_get_iter_at_mark (buf, &new_start, gtk_text_buffer_get_insert (buf));
old_start = new_start;
/* Get new position for the iter new_start */
if (n > 0)
for (i = 0; i < n && gtk_text_iter_forward_cursor_position (&new_start); i++);
else
for (i = 0; i > n && gtk_text_iter_backward_cursor_position (&new_start); i--);
/* Move cursor blinking */
end = new_start;
gtk_text_iter_forward_char (&end);
gtk_text_buffer_apply_tag_by_name (buf, "cursor_blink", &new_start, &end);
end = old_start;
gtk_text_iter_forward_char (&end);
gtk_text_buffer_remove_tag_by_name (buf, "cursor_blink", &old_start, &end);
/* Move cursor */
gtk_text_buffer_place_cursor (buf, &new_start);
/* Check need for auto-scrolling */
if (i == n)
{
end = new_start;
gtk_text_iter_forward_line (&end);
mark = gtk_text_buffer_create_mark (buf, "aux", &end, FALSE);
cursor_out_screen = gtk_text_view_move_mark_onscreen (GTK_TEXT_VIEW (wg), mark);
if (cursor_out_screen)
{
gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (wg),
gtk_text_buffer_get_insert (buf), 0.0, TRUE, 0.5, 0.12);
}
}
return (i);
}
int32_t startwin_puts(const char *str)
{
GtkWidget *textview;
GtkTextBuffer *textbuffer;
GtkTextIter enditer;
GtkTextMark *mark;
const char *aptr, *bptr;
if (!gtkenabled || !str) return 0;
if (!stwidgets.startwin) return 1;
if (!(textview = stwidgets.messagestext)) return -1;
textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_get_end_iter(textbuffer, &enditer);
for (aptr = bptr = str; *aptr != 0;)
{
switch (*bptr)
{
case '\b':
if (bptr > aptr)
gtk_text_buffer_insert(textbuffer, &enditer, (const gchar *)aptr, (gint)(bptr-aptr)-1);
#if GTK_CHECK_VERSION(2,6,0)
gtk_text_buffer_backspace(textbuffer, &enditer, FALSE, TRUE);
#else
{
GtkTextIter iter2 = enditer;
gtk_text_iter_backward_cursor_position(&iter2);
//FIXME: this seems be deleting one too many chars somewhere!
if (!gtk_text_iter_equal(&iter2, &enditer))
gtk_text_buffer_delete_interactive(textbuffer, &iter2, &enditer, TRUE);
}
#endif
aptr = ++bptr;
break;
case 0:
if (bptr > aptr)
gtk_text_buffer_insert(textbuffer, &enditer, (const gchar *)aptr, (gint)(bptr-aptr));
aptr = bptr;
break;
case '\r': // FIXME
default:
bptr++;
break;
}
}
mark = gtk_text_buffer_create_mark(textbuffer, NULL, &enditer, 1);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(textview), mark, 0.0, FALSE, 0.0, 1.0);
gtk_text_buffer_delete_mark(textbuffer, mark);
return 0;
}
static void update_dialog(void)
{
if (dialog_textbuffer != NULL)
{
GtkTextMark *mark;
GtkTextView *textview = g_object_get_data(G_OBJECT(dialog_textbuffer), "textview");
gtk_text_buffer_set_text(dialog_textbuffer, log_buffer->str, log_buffer->len);
/* scroll to the end of the messages as this might be most interesting */
mark = gtk_text_buffer_get_insert(dialog_textbuffer);
gtk_text_view_scroll_to_mark(textview, mark, 0.0, FALSE, 0.0, 0.0);
}
}
void src_view___::scroll2__(GtkTextIter* ti) {
gtk_text_buffer_place_cursor(buf2__(), ti);
GtkTextIter i1,i2;
gtk_text_buffer_get_selection_bounds (buf2__(), &i1,&i2);
GdkRectangle rect;
gtk_text_view_get_visible_rect (handle2__(), &rect);
int y = -1;
int height = -1;
gtk_text_view_get_line_yrange (handle2__(), &i1, &y, &height);
if (y < rect.y + rect.height + 16)
gtk_text_view_scroll_to_mark (handle2__(), gtk_text_buffer_get_insert(buf2__()), 0, false, 0, 0);
}
static void bmark_popup_menu_goto_lcb(GtkWidget * widget, gpointer user_data)
{
Tbmark *b;
GtkTextIter it;
if (!user_data)
return;
b = get_current_bmark(BFWIN(user_data));
if (!b)
return;
if (b->filepath && !b->doc) {
/* check if that document _is_ open */
Tdocument *tmpdoc;
GList *doclist = return_allwindows_documentlist();
tmpdoc = documentlist_return_document_from_filename(doclist, b->filepath);
g_list_free(doclist);
if (tmpdoc == NULL) {
if (!g_file_test(b->filepath, G_FILE_TEST_EXISTS)) {
gchar *string = g_strdup_printf(_("Could not find the file \"%s\"."), b->filepath);
error_dialog(BFWIN(user_data)->main_window, string,
_("This bookmark is set in a file that no longer exists."));
g_free(string);
return;
}
tmpdoc = doc_new_with_file(BFWIN(user_data), b->filepath, FALSE, TRUE);
}
/* now I have to check all bookmarks */
bmark_set_for_doc(tmpdoc);
}
if (b->doc) {
GdkRectangle visirect;
GtkTextIter visi_so, visi_eo;
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(b->doc->view),&visirect);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(b->doc->view), &visi_so, visirect.x, visirect.y);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(b->doc->view), &visi_eo, visirect.x + visirect.width, visirect.y + visirect.height);
gtk_text_buffer_get_iter_at_mark(b->doc->buffer, &it, b->mark);
gtk_text_buffer_place_cursor(b->doc->buffer, &it);
if (!gtk_text_iter_in_range(&it,&visi_so,&visi_eo)) {
DEBUG_MSG("bmark_popup_menu_goto_lcb, cursor NOT visible!\n");
/* gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(b->doc->view), b->mark); */
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(b->doc->view),b->mark,0.0,
TRUE,0.5,0.5);
}
if (b->doc != BFWIN(user_data)->current_document)
switch_to_document_by_pointer(BFWIN(user_data), b->doc);
gtk_widget_grab_focus(b->doc->view);
}
}
void
gimp_error_console_add (GimpErrorConsole *console,
GimpMessageSeverity severity,
const gchar *domain,
const gchar *message)
{
const gchar *desc;
GtkTextIter end;
GtkTextMark *end_mark;
GdkPixbuf *pixbuf;
gchar *str;
g_return_if_fail (GIMP_IS_ERROR_CONSOLE (console));
g_return_if_fail (domain != NULL);
g_return_if_fail (message != NULL);
gimp_enum_get_value (GIMP_TYPE_MESSAGE_SEVERITY, severity,
NULL, NULL, &desc, NULL);
gtk_text_buffer_get_end_iter (console->text_buffer, &end);
pixbuf = gtk_widget_render_icon (console->text_view,
gimp_get_message_stock_id (severity),
GTK_ICON_SIZE_BUTTON, NULL);
gtk_text_buffer_insert_pixbuf (console->text_buffer, &end, pixbuf);
g_object_unref (pixbuf);
gtk_text_buffer_insert (console->text_buffer, &end, " ", -1);
str = g_strdup_printf ("%s %s", domain, desc);
gtk_text_buffer_insert_with_tags_by_name (console->text_buffer, &end,
str, -1,
"title",
NULL);
g_free (str);
gtk_text_buffer_insert (console->text_buffer, &end, "\n", -1);
gtk_text_buffer_insert_with_tags_by_name (console->text_buffer, &end,
message, -1,
"message",
NULL);
gtk_text_buffer_insert (console->text_buffer, &end, "\n\n", -1);
end_mark = gtk_text_buffer_create_mark (console->text_buffer,
NULL, &end, TRUE);
gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (console->text_view), end_mark,
FALSE, TRUE, 1.0, 0.0);
gtk_text_buffer_delete_mark (console->text_buffer, end_mark);
}
void gglk_text_auto_scroll(GglkText *tb)
{
if(!tb->should_scroll)
return;
tb->should_scroll = FALSE;
if(tb->vadjust)
g_signal_handler_block(tb->vadjust, tb->scroll_handler);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(tb),
tb->scrollmark, 0.1,
TRUE, 0.0, 0.0);
if(tb->vadjust)
g_signal_handler_unblock(tb->vadjust, tb->scroll_handler);
}
/*
* print a USER_MSG() extracting it from the queue
*/
static void gtkui_msg(const char *msg)
{
GtkTextIter iter;
gchar *unicode = NULL;
DEBUG_MSG("gtkui_msg: %s", msg);
if((unicode = gtkui_utf8_validate((char *)msg)) == NULL)
return;
gtk_text_buffer_get_end_iter(msgbuffer, &iter);
gtk_text_buffer_insert(msgbuffer, &iter, unicode, -1);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW (textview),
endmark, 0, FALSE, 0, 0);
return;
}
void shoes_native_edit_box_scroll_to_end(SHOES_CONTROL_REF ref) {
GtkWidget *textview;
GTK_CHILD(textview, ref);
GtkTextIter end;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_get_end_iter (buffer, &end);
/* get the current ( cursor )mark name */
GtkTextMark *insert_mark = gtk_text_buffer_get_insert (buffer);
/* move mark and selection bound to the end */
gtk_text_buffer_place_cursor(buffer, &end);
/* scroll to the end view */
gtk_text_view_scroll_to_mark( GTK_TEXT_VIEW (textview),
insert_mark, 0.0, TRUE, 0.0, 1.0);
}
