static void treeViewSelChanged(GtkTreeView* treeView, gpointer userData)
{
GtkTreePath* path = NULL;
GtkTreeViewColumn* col = NULL;
gtk_tree_view_get_cursor(treeView, &path, &col);
GtkTreeIter iter;
gtk_tree_model_get_iter(GTK_TREE_MODEL(treeModel), &iter, path);
vmime::component* comp = NULL;
gtk_tree_model_get(GTK_TREE_MODEL(treeModel), &iter, 1, &comp, -1);
GtkTextBuffer* textBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textArea));
GtkTextIter start, end;
gtk_text_buffer_get_iter_at_offset(textBuffer, &start, comp->getParsedOffset());
gtk_text_buffer_get_iter_at_offset(textBuffer, &end, comp->getParsedOffset() + comp->getParsedLength());
gtk_text_buffer_select_range(textBuffer, &start, &end);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textArea), &start, 0.0, FALSE, 0.0, 0.0);
gtk_tree_path_free(path);
}
static void stick_to_end(GtkTextView *v){
GtkTextBuffer *b;
GtkTextIter iter;
b=gtk_text_view_get_buffer(v);
gtk_text_buffer_get_end_iter(b,&iter);
gtk_text_view_scroll_to_iter(v,&iter,0,FALSE,1.0,0);
}
static G_GNUC_PRINTF(3, 4) void appendf(struct log_s *log, const char *colname,
const char *fmt, ...) {
va_list args;
va_start( args, fmt );
char *buf = g_strdup_vprintf(fmt, args);
va_end( args );
printf("%s", buf);
GtkTextTag *tag = NULL;
if(colname)
tag = gtk_text_buffer_create_tag(log->buffer, NULL,
"foreground", colname,
NULL);
GtkTextIter end;
gtk_text_buffer_get_end_iter(log->buffer, &end);
if(tag)
gtk_text_buffer_insert_with_tags(log->buffer, &end, buf, -1, tag, NULL);
else
gtk_text_buffer_insert(log->buffer, &end, buf, -1);
g_free(buf);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(log->view),
&end, 0.0, FALSE, 0, 0);
while(gtk_events_pending())
gtk_main_iteration();
}
void linphone_gtk_load_chatroom(LinphoneChatRoom *cr,const LinphoneAddress *uri,GtkWidget *chat_view){
GtkWidget *main_window=linphone_gtk_get_main_window ();
LinphoneChatRoom *cr2=(LinphoneChatRoom *)g_object_get_data(G_OBJECT(chat_view),"cr");
const LinphoneAddress *from=linphone_chat_room_get_peer_address(cr2);
char *from_str=linphone_address_as_string_uri_only(from);
char *uri_str=linphone_address_as_string(uri);
char *uri_only=linphone_address_as_string_uri_only(uri);
MSList *messages=NULL;
if(g_strcmp0(from_str,uri_only)!=0){
GtkTextView *text_view=GTK_TEXT_VIEW(linphone_gtk_get_widget(chat_view,"textview"));
GtkTextIter start;
GtkTextIter end;
GtkTextBuffer *text_buffer;
text_buffer=gtk_text_view_get_buffer(text_view);
gtk_text_buffer_get_bounds(text_buffer, &start, &end);
gtk_text_buffer_delete (text_buffer, &start, &end);
g_object_set_data(G_OBJECT(chat_view),"cr",cr);
g_object_set_data(G_OBJECT(linphone_gtk_get_widget(main_window,"contact_list")),"chatview",(gpointer)chat_view);
messages=linphone_chat_room_get_history(cr,NB_MSG_HIST);
g_object_set_data(G_OBJECT(chat_view),"from_message",g_strdup(uri_str));
display_history_message(chat_view,messages,uri);
gtk_text_buffer_get_end_iter(text_buffer,&end);
gtk_text_view_scroll_to_iter(text_view,&end,0,FALSE,1.0,0);
}
ms_free(from_str);
ms_free(uri_str);
ms_free(uri_only);
}
static void
search_text_changed (GtkEntry *entry)
{
ExampleAppWindow *win;
ExampleAppWindowPrivate *priv;
const gchar *text;
GtkWidget *tab;
GtkWidget *view;
GtkTextBuffer *buffer;
GtkTextIter start, match_start, match_end;
text = gtk_entry_get_text (entry);
if (text[0] == '\0')
return;
win = EXAMPLE_APP_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (entry)));
priv = example_app_window_get_instance_private (win);
tab = gtk_stack_get_visible_child (GTK_STACK (priv->stack));
view = gtk_bin_get_child (GTK_BIN (tab));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
/* Very simple-minded search implementation */
gtk_text_buffer_get_start_iter (buffer, &start);
if (gtk_text_iter_forward_search (&start, text, GTK_TEXT_SEARCH_CASE_INSENSITIVE,
&match_start, &match_end, NULL))
{
gtk_text_buffer_select_range (buffer, &match_start, &match_end);
gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW (view), &match_start,
0.0, FALSE, 0.0, 0.0);
}
}
void scroll_mainview_down(){
GtkTextIter iter;
GdkRectangle rect;
gint distance;
gint i;
LOG(LOG_DEBUG, "IN : scroll_mainview_down()");
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(main_view), &rect);
distance = rect.height - scroll_margin;
if(bsmooth_scroll == TRUE){
for(i=0 ; i < scroll_step; i ++){
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(main_view),
&iter,
rect.x,
rect.y+ (distance / scroll_step)*(i+1));
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(main_view),
&iter,
0.0,
TRUE,
0.0, 0.0);
#ifdef __WIN32__
Sleep(scroll_time / scroll_step / 1000);
#else
usleep(scroll_time / scroll_step);
#endif
}
} else {
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(main_view),
&iter,
rect.x,
rect.y+ distance);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(main_view),
&iter,
0.0,
TRUE,
0.0, 0.0);
}
LOG(LOG_DEBUG, "OUT : scroll_mainview_down()");
}
void
text_scroll_to_bottom(squidge_t *squidge)
{
GtkTextIter iter;
gtk_text_buffer_get_end_iter(squidge->ui.text_buffer, &iter);
gtk_text_view_scroll_to_iter(squidge->ui.log_textview, &iter, 0.0, FALSE, 0, 0);
}
static void help_window_load_text(GtkWidget *text, const gchar *path)
{
gchar *pathl;
FILE *f;
gchar s_buf[1024];
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextIter start, end;
if (!text || !path) return;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
gtk_text_buffer_get_bounds(buffer, &start, &end);
gtk_text_buffer_delete(buffer, &start, &end);
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
pathl = path_from_utf8(path);
f = fopen(pathl, "r");
g_free(pathl);
if (!f)
{
gchar *buf;
buf = g_strdup_printf(_("Unable to load:\n%s"), path);
gtk_text_buffer_insert(buffer, &iter, buf, -1);
g_free(buf);
}
else
{
while (fgets(s_buf, sizeof(s_buf), f))
{
gchar *buf;
gint l;
l = strlen(s_buf);
if (!g_utf8_validate(s_buf, l, NULL))
{
buf = g_locale_to_utf8(s_buf, l, NULL, NULL, NULL);
if (!buf) buf = g_strdup("\n");
}
else
{
buf = NULL;
}
gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,
(buf) ? buf : s_buf, -1,
"monospace", NULL);
g_free(buf);
}
fclose(f);
}
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
gtk_text_buffer_place_cursor(buffer, &iter);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(text), &iter, 0.0, TRUE, 0, 0);
}
void message (string message)
{
gtk_text_buffer_insert_at_cursor (buffer, message.c_str(), -1);
gtk_text_buffer_insert_at_cursor (buffer, "\n", -1);
GtkTextIter iter;
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW (textview), &iter, 0.1, true, 0.5, 0.5);
while (gtk_events_pending()) gtk_main_iteration();
}
static void log_window_jump_to_error(LogWindow *logwin)
{
GtkTextIter iter;
gtk_text_buffer_get_end_iter(logwin->buffer, &iter);
if (!gtk_text_iter_backward_to_tag_toggle(&iter, logwin->error_tag))
return;
gtk_text_iter_backward_line(&iter);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(logwin->text), &iter, 0, TRUE, 0, 0);
}
static gboolean remmina_chat_window_scroll_proc(RemminaChatWindow* window)
{
GtkTextBuffer* buffer;
GtkTextIter iter;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(window->history_text));
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(window->history_text), &iter, 0.0, FALSE, 0.0, 0.0);
return FALSE;
}
static gboolean
log_do_tail (EventLog *log)
{
GtkTextIter iter;
gtk_text_buffer_get_end_iter (log->log_text, &iter);
gtk_text_view_scroll_to_iter (log->text_view, &iter,
FALSE, FALSE, 0.0, 1.0);
log->idle_tail = 0;
return FALSE;
}
static gboolean remmina_log_scroll_to_end(gpointer data)
{
GtkTextIter iter;
if (log_window)
{
gtk_text_buffer_get_end_iter(REMMINA_LOG_WINDOW (log_window)->log_buffer, &iter);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(REMMINA_LOG_WINDOW (log_window)->log_view), &iter, 0.0, FALSE, 0.0,
0.0);
}
return FALSE;
}
/* searching */
static void
do_search (GtkWidget *e, GtkWidget *w)
{
static gchar *text = NULL;
static guint offset;
static GRegex *regex = NULL;
GMatchInfo *match = NULL;
GtkTextIter begin, end;
g_free (pattern);
pattern = g_strdup (gtk_entry_get_text (GTK_ENTRY (e)));
gtk_widget_destroy (w);
gtk_widget_queue_draw (text_view);
if (new_search || gtk_text_buffer_get_modified (text_buffer))
{
/* get the text */
g_free (text);
gtk_text_buffer_get_bounds (text_buffer, &begin, &end);
text = gtk_text_buffer_get_text (text_buffer, &begin, &end, FALSE);
offset = 0;
/* compile new regex */
if (regex)
g_regex_unref (regex);
regex = g_regex_new (pattern, G_REGEX_EXTENDED | G_REGEX_OPTIMIZE, G_REGEX_MATCH_NOTEMPTY, NULL);
new_search = FALSE;
}
/* search and select if found */
if (g_regex_match (regex, text + offset, G_REGEX_MATCH_NOTEMPTY, &match))
{
gint sp, ep, spos, epos;
g_match_info_fetch_pos (match, 0, &sp, &ep);
/* positions are in bytes, not character, so here we must normalize it*/
spos = g_utf8_pointer_to_offset (text, text + sp + offset);
epos = g_utf8_pointer_to_offset (text, text + ep + offset);
gtk_text_buffer_get_iter_at_offset (text_buffer, &begin, spos);
gtk_text_buffer_get_iter_at_offset (text_buffer, &end, epos);
gtk_text_buffer_select_range (text_buffer, &begin, &end);
gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW (text_view), &begin, 0, FALSE, 0, 0);
offset += epos;
g_match_info_free (match);
match = NULL;
}
else
new_search = TRUE;
}
void iceb_printw(const char *stroka,GtkTextBuffer *buffer,GtkWidget *view)
{
GtkTextIter iter;
gtk_text_buffer_get_iter_at_offset(buffer,&iter,-1);
gtk_text_buffer_insert(buffer,&iter,stroka,-1);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(view),&iter,0.0,TRUE,0.,1.);
//gtk_text_buffer_place_cursor(GTK_TEXT_BUFFER(buffer),&iter);
iceb_refresh();
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkTextAreaPeer_setCaretPosition
(JNIEnv *env, jobject obj, jint pos)
{
void *ptr;
GtkWidget *text = NULL;
GtkTextBuffer *buf;
GtkTextIter iter;
GtkTextMark *oldmark;
GtkTextIter olditer;
int oldpos;
gdk_threads_enter ();
ptr = NSA_GET_PTR (env, obj);
text = gtk_bin_get_child (GTK_BIN (ptr));
buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
/* Save old position. */
oldmark = gtk_text_buffer_get_insert (buf);
gtk_text_buffer_get_iter_at_mark (buf, &olditer, oldmark);
oldpos = gtk_text_iter_get_offset (&olditer);
/* Move to new position. */
gtk_text_buffer_get_iter_at_offset (buf, &iter, pos);
gtk_text_buffer_place_cursor (buf, &iter);
/* Scroll to new position. Alignment is determined
comparing the new position to the old position. */
if (oldpos > pos)
gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW (text),
&iter, 0, TRUE, 0, 0);
else if (oldpos < pos)
gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW (text),
&iter, 0, TRUE, 1, 1);
gdk_threads_leave ();
}
static void salida_imprimir(const char *value, GladeXML *xml) {
if(value) {
GString *valor = g_string_new("");
g_string_sprintf(valor, "%s\n", (char *)value);
GtkWidget* texto = glade_xml_get_widget(xml, "txt_salida");
GtkTextIter iter;
GtkTextBuffer * buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(texto));
gtk_text_buffer_get_iter_at_offset(buffer, &iter, -1);
gtk_text_buffer_insert(buffer, &iter, valor->str, -1);
g_string_free(valor, TRUE);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(texto), &iter, 0.0, FALSE, 1.0, 1.0);
}
}
/* decode signal callback
* puts the decoded result in the textbox
*/
static void decoded (GtkWidget *widget,
zbar_symbol_type_t symbol,
const char *result,
gpointer data)
{
GtkTextBuffer *resultbuf = gtk_text_view_get_buffer(results);
GtkTextIter end;
gtk_text_buffer_get_end_iter(resultbuf, &end);
gtk_text_buffer_insert(resultbuf, &end, zbar_get_symbol_name(symbol), -1);
gtk_text_buffer_insert(resultbuf, &end, ":", -1);
gtk_text_buffer_insert(resultbuf, &end, result, -1);
gtk_text_buffer_insert(resultbuf, &end, "\n", -1);
gtk_text_view_scroll_to_iter(results, &end, 0, FALSE, 0, 0);
}
static void
jump_to_markerline(PurpleConversation *conv, gpointer null)
{
PidginConversation *gtkconv = PIDGIN_CONVERSATION(conv);
int offset;
GtkTextIter iter;
if (!gtkconv)
return;
offset = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(gtkconv->imhtml), "markerline"));
gtk_text_buffer_get_iter_at_offset(GTK_IMHTML(gtkconv->imhtml)->text_buffer, &iter, offset);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(gtkconv->imhtml), &iter, 0, TRUE, 0, 0);
}
void output_scroll_to_bottom(GtkWidget * tab)
{
GtkTextView *out1, *out2;
GtkTextIter iter;
while (gtk_events_pending())
gtk_main_iteration();
// scroll to bottom
out1 = GTK_TEXT_VIEW(interface_get_widget(tab, "output1"));
out2 = GTK_TEXT_VIEW(interface_get_widget(tab, "output2"));
if (!(GTK_WIDGET_VISIBLE(out2))) {
//only scroll if the second output is not visible
//that means that we're scrolled to the very bottom ...
gtk_text_buffer_get_end_iter(gtk_text_view_get_buffer
(out1), &iter);
gtk_text_view_scroll_to_iter(out1, &iter, 0.0, TRUE, 0.0,
1.0);
}
//second output ALWAYS gets scrolled to the bottom
gtk_text_buffer_get_end_iter(gtk_text_view_get_buffer(out2),
&iter);
gtk_text_view_scroll_to_iter(out2, &iter, 0.0, TRUE, 0.0, 1.0);
}
static gboolean _find_match(GHtml * ghtml, char const * buf, char const * str,
size_t tlen)
{
size_t offset;
GtkTextIter start;
GtkTextIter end;
offset = str - buf;
ghtml->search = offset + 1;
gtk_text_buffer_get_iter_at_offset(ghtml->tbuffer, &start, offset);
gtk_text_buffer_get_iter_at_offset(ghtml->tbuffer, &end, offset + tlen);
gtk_text_buffer_select_range(ghtml->tbuffer, &start, &end);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(ghtml->view), &start, 0.0,
FALSE, 0.0, 0.0);
return TRUE;
}
void funcion_error(const char *nombre, const char *modulo, const char *textos) {
if(xml && nombre && textos && modulo) {
GString *valor = g_string_new("");
g_string_sprintf(valor, "%s [%s]: %s\n", strdup(nombre), strdup(modulo), strdup(textos));
// Sacar la salida por pantalla hace fácil redirigir el resultado de depuración
// a un archivo de texto: pipeline --timer=500 vision.xml > vision.log
printf("%s", valor->str);
GtkWidget* texto = glade_xml_get_widget(xml, "txt_error");
GtkTextIter iter;
GtkTextBuffer * buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(texto));
gtk_text_buffer_get_iter_at_offset(buffer, &iter, -1);
gtk_text_buffer_insert(buffer, &iter, valor->str, -1);
g_string_free(valor, TRUE);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(texto), &iter, 0.0, FALSE, 1.0, 1.0);
}
}
void search_btn_clicked(GtkWidget *wid,gpointer data){
SearchBox *search = (SearchBox*) data;
gchar const *txt_to_find;
txt_to_find = gtk_entry_get_text(GTK_ENTRY(search->find_entry));
if(gtk_text_iter_forward_search (&iStart, (gchar*)txt_to_find ,0,&iBegin, &iEnd, NULL)){
gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW(search->app->editor->source_view),&iStart,0,TRUE,0.5,0.5);
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER(search->app->editor->buffer),&iBegin);
gtk_text_buffer_select_range (GTK_TEXT_BUFFER(search->app->editor->buffer),&iBegin,&iEnd);
iStart = iEnd;
isFound = TRUE;
}else{
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER(search->app->editor->buffer),&iStart);
isFound = FALSE;
}
}
/*****************************************************************************
Scrolls the luaconsole all the way to the bottom.
If delayed is TRUE, it will be done in a idle_callback.
Modified copy of chatline_scroll_to_bottom().
*****************************************************************************/
static void luaconsole_dialog_scroll_to_bottom(void)
{
struct luaconsole_data *pdialog = luaconsole_dialog_get();
fc_assert_ret(pdialog);
if (pdialog->shell) {
GtkTextIter end;
fc_assert_ret(NULL != pdialog->message_buffer);
fc_assert_ret(NULL != pdialog->message_area);
gtk_text_buffer_get_end_iter(pdialog->message_buffer, &end);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(pdialog->message_area),
&end, 0.0, TRUE, 1.0, 0.0);
}
}
static void
SetText(
GtkWidget *widget,
WidgetData *wdata,
_Text *data)
{
GtkTextBuffer *buffer;
GtkTextIter iter;
ENTER_FUNC;
SetCommon(widget,wdata);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
gtk_text_buffer_set_text(buffer, data->text, strlen(data->text));
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(widget), &iter, 0, 0);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(widget), &iter,
0.0, TRUE, 0.0, 0.0);
LEAVE_FUNC;
}
static void help_window_scroll(GtkWidget *text, const gchar *key)
{
gchar *needle;
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextIter start, end;
if (!text || !key) return;
needle = g_strdup_printf("[section:%s]", key);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
if (gtk_text_iter_forward_search(&iter, needle, GTK_TEXT_SEARCH_TEXT_ONLY,
&start, &end, NULL))
{
gint line;
GtkTextMark *mark;
line = gtk_text_iter_get_line(&start);
gtk_text_buffer_get_iter_at_line_offset(buffer, &iter, line, 0);
gtk_text_buffer_place_cursor(buffer, &iter);
#if 0
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(text), &iter, 0.0, TRUE, 0, 0);
#endif
/* apparently only scroll_to_mark works when the textview is not visible yet */
/* if mark exists, move it instead of creating one for every scroll */
mark = gtk_text_buffer_get_mark(buffer, SCROLL_MARKNAME);
if (mark)
{
gtk_text_buffer_move_mark(buffer, mark, &iter);
}
else
{
mark = gtk_text_buffer_create_mark(buffer, SCROLL_MARKNAME, &iter, FALSE);
}
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(text), mark, 0.0, TRUE, 0, 0);
}
g_free(needle);
}
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);
gtk_text_view_scroll_to_iter(v,&iter,0,FALSE,0,0);
}
void
cainteoir_document_view_scroll_to_anchor(CainteoirDocumentView *view, const gchar *anchor)
{
GtkTextView *text_view = GTK_TEXT_VIEW(CAINTEOIR_DOCUMENT_VIEW_PRIVATE(view)->text_view);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(text_view);
GtkTextMark *mark = gtk_text_buffer_get_mark(buffer, anchor);
GtkTextIter position;
if (mark)
{
gtk_text_buffer_get_iter_at_mark(buffer, &position, mark);
gtk_text_iter_forward_char(&position);
}
else
gtk_text_buffer_get_start_iter(buffer, &position);
gtk_text_view_scroll_to_iter(text_view, &position, 0, TRUE, 0.0, 0.0);
}
void Dump_IOPort(int port)
{
char whole_buffer[IOOUTBUFLEN * 4]; /* 4x in case of Hex */
char bchar;
int i, ascptr;
GtkTextIter end;
whole_buffer[0] = 0; /* start with a clean buff */
if (IOPort[port] == NULL) /* struct exists? */
{
// fprintf(stderr, "Attempting to dump from non existing port %d\n", port);
return;
}
if (IOPort[port]->ishex) /* dump in hex? */
{
for (i = 0; i < IOPort[port]->out_ptr; i++)
{
sprintf(tstr, "%02X ", IOPort[port]->obuffer[i]);
strcat(whole_buffer, tstr);
}
}
else
{
ascptr = 0;
for (i = 0; i < IOPort[port]->out_ptr; i++)
{
bchar = IOPort[port]->obuffer[i];
if (
(bchar >= 0x20 && bchar < 0x7f) /* printable? */
|| (bchar == 0x0a)
)
whole_buffer[ascptr++] = bchar;
}
whole_buffer[ascptr] = (char)0; /* terminate string */
}
gtk_text_buffer_set_text(ioport_textbuffer, whole_buffer, -1);
gtk_text_buffer_get_end_iter(ioport_textbuffer, &end);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(ioporttext), &end, 0, FALSE, 0, 0);
}
void goto_local_label (const gchar *l)
{
gchar *t = g_utf8_find_next_char (l, NULL);
gchar *s = g_strconcat ("<a name=\"", t, NULL);
GtkTextIter iter;
GtkTextIter match_start;
GtkTextMark *m = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER(cur_text_doc->text_buffer));
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER(cur_text_doc->text_buffer), &iter, m);
if (gtk_text_iter_forward_search (&iter, s, GTK_TEXT_SEARCH_TEXT_ONLY, &match_start, NULL, NULL))
{
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER(cur_text_doc->text_buffer), &match_start );
gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW(cur_text_doc->text_view), &match_start, 0.0, TRUE, 0.0, 0.0 );
gtk_text_view_place_cursor_onscreen (GTK_TEXT_VIEW (cur_text_doc->text_view));
}
g_free (s);
}
