static void handle_ggz_chat_event(GGZMod * ggzmod, GGZModEvent e,
const void *data)
{
const GGZChat *chat = data;
ChatWidgets *list;
char message[1024];
GtkTextBuffer *buf;
GtkTextIter i;
GtkTextMark *mark;
snprintf(message, sizeof(message), "\n%s : %s",
chat->player, chat->message);
for (list = chats; list; list = list->next) {
if (!list->container)
continue;
buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(list->text));
gtk_text_buffer_get_end_iter(buf, &i);
gtk_text_buffer_insert(buf, &i, message, -1);
/* have to use a mark, or this won't work properly */
gtk_text_buffer_get_end_iter(buf, &i);
mark = gtk_text_buffer_create_mark(buf, NULL, &i, FALSE);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW
(list->text), mark);
gtk_text_buffer_delete_mark(buf, mark);
}
}
void SourceView::goToLine (int lineNumber)
{
GtkTextIter iter;
gtk_text_buffer_get_iter_at_line(GTK_TEXT_BUFFER(_buffer), &iter, lineNumber);
gtk_text_buffer_place_cursor(GTK_TEXT_BUFFER(_buffer), &iter);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(_view), gtk_text_buffer_get_insert(GTK_TEXT_BUFFER(_buffer)));
}
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 pTextEdit::setCursorPosition(unsigned position) {
GtkTextMark *mark = gtk_text_buffer_get_mark(textBuffer, "insert");
GtkTextIter iter;
gtk_text_buffer_get_end_iter(textBuffer, &iter);
gtk_text_iter_set_offset(&iter, min(position, gtk_text_iter_get_offset(&iter)));
gtk_text_buffer_place_cursor(textBuffer, &iter);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(subWidget), mark);
}
static gboolean scroll_to_end(GtkTextView *w){
GtkTextBuffer *buffer=gtk_text_view_get_buffer(w);
GtkTextIter iter;
gtk_text_buffer_get_end_iter(buffer,&iter);
GtkTextMark *mark=gtk_text_buffer_create_mark(buffer,NULL,&iter,FALSE);
gtk_text_view_scroll_mark_onscreen(w,mark);
return FALSE;
}
void sg_set_cursor(GtkWidget *w, int position)
{
GtkTextIter pos;
GtkTextBuffer *buf;
buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(w));
gtk_text_buffer_get_iter_at_offset(buf, &pos, position - 1);
gtk_text_buffer_place_cursor(buf, &pos);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(w), gtk_text_buffer_get_insert(buf));
}
static void
go_forward_search_cb (G_GNUC_UNUSED GtkButton *button, TextSearch *tsearch)
{
if (tsearch->priv->current_mark && tsearch->priv->current_mark->next) {
tsearch->priv->current_mark = tsearch->priv->current_mark->next;
gtk_text_view_scroll_mark_onscreen (tsearch->priv->view,
GTK_TEXT_MARK (tsearch->priv->current_mark->data));
}
}
static void cb_end_user_action(GtkTextBuffer *buffer, GtkWidget *view)
{
if (view_scroll_flag) {
gtk_text_view_scroll_mark_onscreen( // TODO: require?
GTK_TEXT_VIEW(view),
gtk_text_buffer_get_insert(buffer));
view_scroll_flag = FALSE;
}
}
static void console_scroll_to_end (GtkWidget *cview,
GtkTextBuffer *buf,
GtkTextIter *end)
{
GtkTextMark *mark;
mark = gtk_text_buffer_create_mark(buf, NULL, end, FALSE);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(cview), mark);
gtk_text_buffer_delete_mark(buf, mark);
}
void
gui_editor_goto_line (GUIEditor * self, gint ln)
{
gtk_text_buffer_get_iter_at_line (GTK_TEXT_BUFFER(self->buffer), &(self->iter), (ln -1));
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER(self->buffer), &(self->iter));
gtk_text_buffer_move_mark (GTK_TEXT_BUFFER(self->buffer), self->mark, &(self->iter));
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW(self->widget), self->mark);
}
static void gglk_text_paste_clipboard(GtkTextView *view)
{
GglkText *tb = GGLK_TEXT(view);
GtkTextMark *insert = gtk_text_buffer_get_insert(tb->buffer);
GtkTextIter iter;
gtk_text_buffer_get_iter_at_mark(tb->buffer, &iter, insert);
gglk_text_paste_clipboard_selection(tb, GDK_SELECTION_CLIPBOARD, &iter);
gtk_text_view_scroll_mark_onscreen(view, insert);
}
void enter_text(){
app.mark = gtk_text_buffer_get_insert (app.buffer);
if (app.connected) {
app.test42 = gtk_entry_get_text (GTK_ENTRY (windowIO->entry));
enter_socket_text(app.nom_utilisateur);
enter_socket_text("\n\0");
memset(app.string_send,'\0',512);
strcpy(app.string_send, app.test42);
gtk_text_buffer_get_iter_at_mark (app.buffer, &app.end, app.mark); // Initialise l'itérateur 'end' a 'mark' ( Position du curseur -> Fin du buffer )
gtk_text_buffer_get_end_iter(app.buffer, &app.end);
//gtk_text_buffer_get_iter_at_line (app.buffer, &app.end, 0);
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW(windowIO->textview),app.mark);
gtk_text_buffer_insert (app.buffer, &app.end, app.test42, -1); // Ajoute le 'test42' dans le 'buffer' a l'emplacement de 'end' ( Fin du buffer )
//gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(windowIO->textview), app.mark, 0.0, FALSE, 1.0,1.0);
enter_socket_text("\n\n\0");
/*if( ! g_thread_supported() )
g_thread_init( NULL );
GError *error = NULL;
GThread * thread;
thread = g_thread_create( send_entered_text, NULL,
TRUE, &error );*/
send_entered_text();
// printf("%u\n",gtk_text_buffer_get_char_count(app.buffer));
}
gtk_entry_set_text(GTK_ENTRY(windowIO->entry), ""); // Vide le champs
}
static void
app_text_print (const char *line, PrintFormat format, gboolean newline)
{
GtkTextIter iter;
gtk_text_buffer_get_end_iter (app->text_buffer, &iter);
gtk_text_buffer_insert_with_tags (
app->text_buffer, &iter, line, -1, app->text_tags[format], NULL);
if (newline) {
gtk_text_buffer_insert (app->text_buffer, &iter, "\n", -1);
}
gtk_text_view_scroll_mark_onscreen (app->text_view, app->text_end);
}
/* Scroll to the bottom of the buffer.
*/
static gboolean
scroll_to_bottom (GtkTextView *textview)
{
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextMark *mark;
char *spaces;
static int count;
buffer = gtk_text_view_get_buffer (textview);
/* Get end iterator */
gtk_text_buffer_get_end_iter (buffer, &iter);
/* and insert some text at it, the iter will be revalidated
* after insertion to point to the end of inserted text
*/
spaces = g_strnfill (count++, ' ');
gtk_text_buffer_insert (buffer, &iter, "\n", -1);
gtk_text_buffer_insert (buffer, &iter, spaces, -1);
gtk_text_buffer_insert (buffer, &iter,
"Scroll to bottom scroll to bottom scroll "
"to bottom scroll to bottom",
-1);
g_free (spaces);
/* Move the iterator to the beginning of line, so we don't scroll
* in horizontal direction
*/
gtk_text_iter_set_line_offset (&iter, 0);
/* and place the mark at iter. the mark will stay there after we
* insert some text at the end because it has right gravity.
*/
mark = gtk_text_buffer_get_mark (buffer, "scroll");
gtk_text_buffer_move_mark (buffer, mark, &iter);
/* Scroll the mark onscreen.
*/
gtk_text_view_scroll_mark_onscreen (textview, mark);
/* Shift text back if we got enough to the right.
*/
if (count > 40)
count = 0;
return TRUE;
}
static void
_end_var_replacement(GtkSnippetsInPlaceParser *self)
{
GtkTextIter iter;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(self->priv->view);
GtkTextMark *mark = NULL;
if (self->priv->end_position_mark!=NULL)
mark = self->priv->end_position_mark;
else
mark = gtk_text_buffer_get_mark(buffer,SNIPPET_END_MARK);
gtk_text_buffer_get_iter_at_mark(buffer,&iter,mark);
gtk_text_view_scroll_mark_onscreen(self->priv->view,mark);
gtksnippets_inplaceparser_deactivate(self);
gtk_text_buffer_place_cursor(buffer,&iter);
}
static void
set_active_var(GtkSnippetsInPlaceParser *self)
{
self->priv->moving = TRUE;
GtkSnippetsGtvVar *var = GTKSNIPPETS_GTV_VAR(self->priv->active_var_pos->data);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(self->priv->view);
GtkTextMark *start_mark, *end_mark;
GtkTextIter start,end;
start_mark = gtksnippets_gtv_var_get_start_mark(var);
end_mark = gtksnippets_gtv_var_get_end_mark(var);
gtk_text_buffer_get_iter_at_mark(buffer,&start,start_mark);
gtk_text_buffer_get_iter_at_mark(buffer,&end,end_mark);
gtk_text_buffer_select_range(buffer,&start,&end);
gtk_text_view_scroll_mark_onscreen(self->priv->view,start_mark);
}
void
gui_chat_setup (GsClient *client)
{
if (client) {
gtk_widget_set_sensitive (page, TRUE);
GtkTextIter iter;
gtk_text_view_set_buffer (GTK_TEXT_VIEW (logview), client->chat_buffer);
gtk_text_buffer_get_end_iter (client->chat_buffer, &iter);
GtkTextMark *mark = gtk_text_buffer_create_mark (client->chat_buffer, NULL, &iter, TRUE);
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW (logview), mark);
gtk_text_buffer_delete_mark (client->chat_buffer, mark);
} else {
gtk_widget_set_sensitive (page, FALSE);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (logview), NULL);
}
}
void enter_socket_text(char * data){
app.mark = gtk_text_buffer_get_insert (app.buffer);
const gchar * text = (const gchar * )data;
gtk_text_buffer_get_iter_at_mark (app.buffer, &app.end, app.mark);
gtk_text_buffer_get_end_iter(app.buffer, &app.end);
//gtk_text_buffer_get_iter_at_line (app.buffer, &app.end, 0);
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW(windowIO->textview),app.mark);
gtk_text_buffer_insert (app.buffer, &app.end, text, -1);
//gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(windowIO->textview), app.mark, 0.0, FALSE, 1.0,1.0);
}
static void
ide_source_view_movements_select_range (Movement *mv)
{
GtkTextBuffer *buffer;
GtkTextMark *mark;
g_assert (mv);
g_assert (IDE_IS_SOURCE_VIEW (mv->self));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
if (mv->extend_selection)
gtk_text_buffer_select_range (buffer, &mv->insert, &mv->selection);
else
gtk_text_buffer_select_range (buffer, &mv->insert, &mv->insert);
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW (mv->self), mark);
}
void context_output(int fd, const char *text, gint length)
{
static int last_fd = -1;
GtkTextIter end;
gchar *utf8;
gtk_text_buffer_get_end_iter(context, &end);
if (last_fd == 3 && fd != 0)
gtk_text_buffer_insert(context, &end, "\n", 1);
if (fd != last_fd)
last_fd = fd;
if (length == -1)
length = strlen(text);
dc_chars += length;
utf8 = g_locale_to_utf8(text, length, NULL, NULL, NULL);
if (utf8)
{
gtk_text_buffer_insert_with_tags(context, &end, utf8, -1, fd_tags[fd], NULL);
g_free(utf8);
}
else
gtk_text_buffer_insert_with_tags(context, &end, text, length, fd_tags[fd], NULL);
if (dc_chars > DC_LIMIT + (DC_DELTA / 2))
{
GtkTextIter start, delta;
gtk_text_buffer_get_start_iter(context, &start);
gtk_text_buffer_get_iter_at_offset(context, &delta, DC_DELTA);
gtk_text_buffer_delete(context, &start, &delta);
gtk_text_buffer_get_end_iter(context, &end);
dc_chars = gtk_text_buffer_get_char_count(context);
}
gtk_text_buffer_place_cursor(context, &end);
gtk_text_view_scroll_mark_onscreen(debug_context, gtk_text_buffer_get_insert(context));
}
void log_window_show(LogWindow *logwin)
{
GtkTextView *text = GTK_TEXT_VIEW(logwin->text);
GtkTextBuffer *buffer = logwin->buffer;
GtkTextMark *mark;
logwin->hidden = FALSE;
if (logwin->never_shown)
gtk_text_view_set_buffer(GTK_TEXT_VIEW(logwin->text), logwin->buffer);
logwin->never_shown = FALSE;
mark = gtk_text_buffer_get_mark(buffer, "end");
gtk_text_view_scroll_mark_onscreen(text, mark);
gtk_window_deiconify(GTK_WINDOW(logwin->window));
gtk_widget_show(logwin->window);
gtk_window_present(GTK_WINDOW(logwin->window));
}
/* Scroll to the end of the buffer.
*/
static gboolean
scroll_to_end (GtkTextView *textview)
{
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextMark *mark;
char *spaces;
static int count;
buffer = gtk_text_view_get_buffer (textview);
/* Get "end" mark. It's located at the end of buffer because
* of right gravity
*/
mark = gtk_text_buffer_get_mark (buffer, "end");
gtk_text_buffer_get_iter_at_mark (buffer, &iter, mark);
/* and insert some text at its position, the iter will be
* revalidated after insertion to point to the end of inserted text
*/
spaces = g_strnfill (count++, ' ');
gtk_text_buffer_insert (buffer, &iter, "\n", -1);
gtk_text_buffer_insert (buffer, &iter, spaces, -1);
gtk_text_buffer_insert (buffer, &iter,
"Scroll to end scroll to end scroll "
"to end scroll to end ",
-1);
g_free (spaces);
/* Now scroll the end mark onscreen.
*/
gtk_text_view_scroll_mark_onscreen (textview, mark);
/* Emulate typewriter behavior, shift to the left if we
* are far enough to the right.
*/
if (count > 150)
count = 0;
return TRUE;
}
void indent_real(GtkWidget *text_view)
{
GtkTextIter iter;
gchar *ind, *str;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));
g_signal_emit_by_name(G_OBJECT(buffer), "begin-user-action");
gtk_text_buffer_delete_selection(buffer, TRUE, TRUE);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, gtk_text_buffer_get_insert(buffer));
ind = compute_indentation(buffer, &iter, gtk_text_iter_get_line(&iter));
str = g_strconcat("\n", ind, NULL);
gtk_text_buffer_insert(buffer, &iter, str, -1);
g_signal_emit_by_name(G_OBJECT(buffer), "end-user-action");
g_free(str);
g_free(ind);
gtk_text_view_scroll_mark_onscreen(
GTK_TEXT_VIEW(text_view),
gtk_text_buffer_get_insert(buffer));
}
void
hybrid_chat_textview_notify(GtkWidget *textview, const gchar *text, gint type)
{
GtkTextBuffer *recv_tb;
GtkTextIter end_iter;
GtkTextIter stop_iter;
GtkTextIter start_iter;
GtkTextMark *mark;
recv_tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_get_end_iter(recv_tb, &end_iter);
gtk_text_view_backward_display_line(GTK_TEXT_VIEW(textview), &end_iter);
gtk_text_buffer_get_end_iter(recv_tb, &stop_iter);
gtk_text_buffer_get_start_iter(recv_tb, &start_iter);
/* first line */
if (gtk_text_iter_equal(&end_iter, &stop_iter)) {
gtk_text_buffer_delete(recv_tb, &start_iter, &stop_iter);
} else {
gtk_text_buffer_delete(recv_tb, &end_iter, &stop_iter);
if (!gtk_text_iter_equal(&start_iter, &end_iter)) {
gtk_text_buffer_insert(recv_tb, &end_iter, "\n", -1);
}
}
gtk_text_buffer_get_end_iter(recv_tb, &end_iter);
if (type == MSG_NOTIFICATION_INPUT) {
gtk_text_buffer_insert_with_tags_by_name(recv_tb, &end_iter,
text, strlen(text), "grey", "small", "wrap", NULL);
}
mark = gtk_text_buffer_get_mark(recv_tb, "scroll");
gtk_text_buffer_move_mark(recv_tb, mark, &end_iter);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(textview), mark);
}
void fx_many_add_information(FxMany* fxmany , const char* text)
{
GtkTextIter iter;
GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(fxmany->recv_text));
gtk_text_buffer_get_end_iter(buffer , &iter );
gtk_text_buffer_insert_with_tags_by_name(buffer
, &iter , text , -1 , "blue" , NULL);
gtk_text_buffer_insert(buffer , &iter , "\n" , -1);
gtk_text_iter_set_line_offset (&iter, 0);
fxmany->mark = gtk_text_buffer_get_mark (buffer, "scroll");
gtk_text_buffer_move_mark (buffer, fxmany->mark, &iter);
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW(fxmany->recv_text), fxmany->mark);
}
void
nh_message_putstr(const char *str)
{
int len;
char *buf;
GtkTextIter iter, iter2;
GtkTextBuffer *t;
if (!message_text)
return;
t = gtk_text_view_get_buffer(GTK_TEXT_VIEW(message_text));
gtk_text_buffer_get_end_iter(t, &iter);
len = strlen(str);
buf = (char *)alloc(len + 2);
sprintf(buf, "\n%s", str);
if (nh_status_in_trouble())
gtk_text_buffer_insert_with_tags_by_name(t, &iter, buf, len + 1,
"warning", NULL);
else
gtk_text_buffer_insert(t, &iter, buf, len + 1);
free(buf);
len = gtk_text_buffer_get_char_count(t);
if (len > NH_TEXT_REMEMBER) {
gtk_text_buffer_get_iter_at_offset(t, &iter, len - NH_TEXT_REMEMBER);
gtk_text_buffer_get_iter_at_line(t, &iter2,
gtk_text_iter_get_line(&iter) + 1);
gtk_text_buffer_get_start_iter(t, &iter);
gtk_text_buffer_delete(t, &iter, &iter2);
}
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(message_text),
gtk_text_buffer_get_mark(t, "nh_end"));
}
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 linphone_gtk_push_text(GtkTextView *v, const char *from, const char *message, gboolean me){
GtkTextBuffer *b=gtk_text_view_get_buffer(v);
GtkTextIter iter,begin;
int off;
gtk_text_buffer_get_end_iter(b,&iter);
off=gtk_text_iter_get_offset(&iter);
gtk_text_buffer_insert(b,&iter,from,-1);
gtk_text_buffer_get_end_iter(b,&iter);
gtk_text_buffer_insert(b,&iter,":\t",-1);
gtk_text_buffer_get_end_iter(b,&iter);
gtk_text_buffer_get_iter_at_offset(b,&begin,off);
gtk_text_buffer_apply_tag_by_name(b,me ? "green" : "blue" ,&begin,&iter);
gtk_text_buffer_insert(b,&iter,message,-1);
gtk_text_buffer_get_end_iter(b,&iter);
gtk_text_buffer_insert(b,&iter,"\n",-1);
gtk_text_buffer_get_end_iter(b,&iter);
GtkTextMark *mark=gtk_text_buffer_create_mark(b,NULL,&iter,FALSE);
gtk_text_view_scroll_mark_onscreen(v,mark);
//gtk_text_buffer_get_end_iter(b,&iter);
//gtk_text_iter_forward_to_line_end(&iter);
//gtk_text_view_scroll_to_iter(v,&iter,0,TRUE,1.0,1.0);
}
static gboolean main_loop (gpointer data)
{
gboolean result;
int i;
/*
* Make sure we turn off the idle handler if the game isn't running. This
* shouldn't happen.
*/
if (!ms_is_running ())
{
g_warning ("main_loop was called while the game wasn't running");
mainIdleHandler = 0;
return FALSE;
}
for (i = 0; i < MAX_INSTRUCTIONS; i++)
{
result = ms_rungame ();
if (!result)
{
text_insert ("\n[End of session]\n");
mainIdleHandler = 0;
ms_flush ();
ms_stop ();
ms_freemem ();
gtk_text_view_scroll_mark_onscreen (
GTK_TEXT_VIEW (Gui.text_view),
gtk_text_buffer_get_insert (Gui.text_buffer));
break;
}
}
return result;
}
static void
combochange_log (const char *fmt,
...)
{
GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
GtkTextIter iter;
va_list vap;
char *msg;
GString *order_string;
GtkTextMark *tmp_mark;
int i;
va_start (vap, fmt);
msg = g_strdup_vprintf (fmt, vap);
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_insert (buffer, &iter, msg, -1);
order_string = g_string_new ("\n ");
for (i = 0; i < contents->len; i++)
{
if (i)
g_string_append_c (order_string, ' ');
g_string_append_c (order_string, g_array_index (contents, char, i));
}
g_string_append_c (order_string, '\n');
gtk_text_buffer_insert (buffer, &iter, order_string->str, -1);
g_string_free (order_string, TRUE);
tmp_mark = gtk_text_buffer_create_mark (buffer, NULL, &iter, FALSE);
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW (text_view), tmp_mark);
gtk_text_buffer_delete_mark (buffer, tmp_mark);
g_free (msg);
}
