//================================================================
int GUI_edi_InsFile (MemObj *mo, char *fnam) {
//================================================================
/// GUI_edi_InsFile insert file at curPos, make text selected
// see also ED_add_File
// was GUI_Ed_Ins_f
GtkTextMark *mk1;
GtkTextIter it1, it2;
long fSiz, cPos1;
void *fBuf;
// set GUI_ed1_view GUI_ed1_buff
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// get file -> fBuf
MEM_alloc_file (&fBuf, &fSiz, fnam);
UTX_str_file (fBuf, &fSiz, fnam);
if(fSiz < 1) {
TX_Print("GUI_Ed_Ins_f E001 |%s|",fnam);
return -1;
}
// printf("fBuf=|%s|\n",(char*)fBuf);
// // get get iters for "insert" & "selection_bound"
// gtk_text_buffer_get_selection_bounds (wTx->text, &it1, &it2);
// // insert at iterPos
// gtk_text_buffer_insert (wTx->text, &it1, txbuf, -1);
// get iter it1 at CurPos
mk1 = gtk_text_buffer_get_mark (GUI_ed1_buff, "insert");
// iter at CurPos
gtk_text_buffer_get_iter_at_mark (GUI_ed1_buff, &it1, mk1);
cPos1 = gtk_text_iter_get_offset (&it1);
// insert text txbuf at curpos;
gtk_text_buffer_insert_at_cursor (GUI_ed1_buff, fBuf, fSiz);
// get iter it2 at new CurPos
mk1 = gtk_text_buffer_get_mark (GUI_ed1_buff, "insert");
gtk_text_buffer_get_iter_at_mark (GUI_ed1_buff, &it2, mk1);
// set to old curPos it1
gtk_text_buffer_get_iter_at_offset (GUI_ed1_buff, &it1, cPos1);
gtk_text_buffer_place_cursor (GUI_ed1_buff, &it1);
// select region curPos - it2
gtk_text_buffer_move_mark_by_name (GUI_ed1_buff, "selection_bound", &it2);
return 0;
}
//==========================================================================
long GUI_edi_getCpos (MemObj *mo) {
//==========================================================================
/// \code
/// get cursorposition as offset from start-of-file.
/// 0=startpos; Linedelimiters '\n' is one char.
/// cpos -> Zeilennummer: UTF_GetLnrPos
/// \endcode
GtkTextMark *mk1;
GtkTextIter it1;
long cpos;
// printf("GUI_edi_getCpos \n");
// set GUI_ed1_view GUI_ed1_buff
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// get mark at CurPos
mk1 = gtk_text_buffer_get_mark (GUI_ed1_buff, "insert");
// iter at CurPos
gtk_text_buffer_get_iter_at_mark (GUI_ed1_buff, &it1, mk1);
// get offset of CurPos
cpos = gtk_text_iter_get_offset (&it1);
// cpos = gtk_text_iter_get_line_index (&it1); // byte-offset in line
// printf("ex GUI_edi_getCpos %d\n",cpos);
return cpos;
}
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);
}
void
on_next_button_clicked (GtkWidget *next_button, GdkEventKey *event, AD data)
// 按下『F3』找下一個符合字串
// ＊因為無法把searchWord正確傳遞，所以無法正常使用此函式。
{
const gchar *text;
GtkTextBuffer *buffer;
GtkTextMark *last_pos;
GtkTextIter iter;
if( !strcmp( gdk_keyval_name( event->keyval ), "F3" ) ) {
text = "e" ; // 預設搜尋e
//text = data->searchWord;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (data->textview));
last_pos = gtk_text_buffer_get_mark (buffer, "last_pos");
if (last_pos == NULL)
gtk_text_buffer_get_start_iter (buffer, &iter); // 若無，就從頭搜尋
else
gtk_text_buffer_get_iter_at_mark (buffer, &iter, last_pos);
//find (GTK_TEXT_VIEW (data->textview), text, &iter);
find (GTK_TEXT_VIEW (data->textview), text, &iter);
}
}
void
on_search_okbutton_clicked (GtkWidget *search_button, AD data)
// 搜尋按鈕的功能，可連續搜尋
{
const gchar *text = "e";
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextMark *last_pos;
int result = 0 ;
gboolean found = FALSE;
data->searchWord = gtk_entry_get_text (GTK_ENTRY (data->entry)); // 取得輸入欄的字串
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (data->textview));
last_pos = gtk_text_buffer_get_mark (buffer, "last_pos"); // 查看有無last_pos的mark
if (last_pos == NULL)
gtk_text_buffer_get_start_iter (buffer, &iter); // 若無，就從頭搜尋
else
gtk_text_buffer_get_iter_at_mark (buffer, &iter, last_pos); // 若有，就從最後一個last_pos的後面開始搜尋
found = find (GTK_TEXT_VIEW (data->textview), data->searchWord, &iter);
if (!found)
gtk_text_buffer_delete_mark (buffer, last_pos); // 搜尋到最後可回到起點重新搜尋
}
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);
}
}
//================================================================
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;
}
void pHexEdit::constructor() {
gtkWidget = gtk_hbox_new(false, 0);
container = gtk_scrolled_window_new(0, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(container), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(container), GTK_SHADOW_ETCHED_IN);
subWidget = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(subWidget), false);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(subWidget), GTK_WRAP_NONE);
gtk_container_add(GTK_CONTAINER(container), subWidget);
g_signal_connect(G_OBJECT(subWidget), "key-press-event", G_CALLBACK(HexEdit_keyPress), (gpointer)&hexEdit);
scrollBar = gtk_vscrollbar_new((GtkAdjustment*)0);
gtk_range_set_range(GTK_RANGE(scrollBar), 0, 255);
gtk_range_set_increments(GTK_RANGE(scrollBar), 1, 16);
gtk_widget_set_sensitive(scrollBar, false);
g_signal_connect(G_OBJECT(scrollBar), "change-value", G_CALLBACK(HexEdit_scroll), (gpointer)&hexEdit);
gtk_box_pack_start(GTK_BOX(gtkWidget), container, true, true, 0);
gtk_box_pack_start(GTK_BOX(gtkWidget), scrollBar, false, false, 1);
textBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(subWidget));
textCursor = gtk_text_buffer_get_mark(textBuffer, "insert");
gtk_widget_show(scrollBar);
gtk_widget_show(subWidget);
gtk_widget_show(container);
}
void next_button_clicked (GtkWidget *next_button) {
GtkTextBuffer *buffer;
GtkTextMark *last_pos;
GtkTextIter iter;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor_view));
last_pos = gtk_text_buffer_get_mark(buffer, "last_pos");
if (last_pos == NULL) {
GtkWidget *message = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO,
GTK_BUTTONS_CLOSE,
"End of Search!!!! \n\n");
gtk_window_set_title(GTK_WINDOW(message), "Search");
gtk_dialog_run(GTK_DIALOG(message));
gtk_widget_destroy(message);
return;
}
gtk_text_buffer_get_iter_at_mark(buffer, &iter, last_pos);
find(GTK_TEXT_VIEW(editor_view),
gtk_entry_get_text(GTK_ENTRY(search_entry)),
&iter);
}
static void
ensure_anchor_selected (Movement *mv)
{
GtkTextBuffer *buffer;
GtkTextMark *selection_mark;
GtkTextMark *insert_mark;
GtkTextIter anchor_begin;
GtkTextIter anchor_end;
GtkTextIter insert_iter;
GtkTextIter selection_iter;
GtkTextMark *selection_anchor_begin;
GtkTextMark *selection_anchor_end;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
selection_anchor_begin = gtk_text_buffer_get_mark (buffer, ANCHOR_BEGIN);
selection_anchor_end = gtk_text_buffer_get_mark (buffer, ANCHOR_END);
if (!selection_anchor_begin || !selection_anchor_end)
return;
gtk_text_buffer_get_iter_at_mark (buffer, &anchor_begin, selection_anchor_begin);
gtk_text_buffer_get_iter_at_mark (buffer, &anchor_end, selection_anchor_end);
insert_mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &insert_iter, insert_mark);
selection_mark = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &selection_iter, selection_mark);
if ((gtk_text_iter_compare (&selection_iter, &anchor_end) < 0) &&
(gtk_text_iter_compare (&insert_iter, &anchor_end) < 0))
{
if (gtk_text_iter_compare (&insert_iter, &selection_iter) < 0)
select_range (mv, &insert_iter, &anchor_end);
else
select_range (mv, &anchor_end, &selection_iter);
}
else if ((gtk_text_iter_compare (&selection_iter, &anchor_begin) > 0) &&
(gtk_text_iter_compare (&insert_iter, &anchor_begin) > 0))
{
if (gtk_text_iter_compare (&insert_iter, &selection_iter) < 0)
select_range (mv, &anchor_begin, &selection_iter);
else
select_range (mv, &insert_iter, &anchor_begin);
}
}
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);
}
//==========================================================================
char GUI_edi_RdChr (MemObj *mo, int offset) {
//==========================================================================
/// \code
/// read char near cursor;
/// offset 0 = char right of cursor
/// offset -1 = char left of cursor
/// returns '\0' for out-of-file-positions.
/// returns -1 for a multibyte-character
/// \endcode
GtkTextMark *mk1;
GtkTextIter it1;
gboolean b1;
long uc;
// char c1;
// printf("GUI_edi_RdChr |%c| %d\n",c1,cpos);
// set GUI_ed1_view GUI_ed1_buff
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// get mark at CurPos
mk1 = gtk_text_buffer_get_mark (GUI_ed1_buff, "insert");
// iter at CurPos
gtk_text_buffer_get_iter_at_mark (GUI_ed1_buff, &it1, mk1);
// move iter back
if(offset < 0) {
b1 = gtk_text_iter_backward_chars (&it1, -offset);
// false if left of 1. char; returns Null !.
if(b1 == FALSE) return '\0';
}
// move iter forw
if(offset > 0) {
b1 = gtk_text_iter_forward_chars (&it1, offset);
// false if left of 1. char; returns Null !.
if(b1 == FALSE) return '\0';
}
// get unicode-char at curpos
uc = gtk_text_iter_get_char (&it1);
if((uc > 127)||(uc < 0)) return -1;
// printf("ex GUI_edi_RdChr |%ld|\n",uc);
return uc;
}
Thtml_diag *html_diag_new(Tbfwin *bfwin, gchar *title) {
Thtml_diag *dg;
dg = g_malloc(sizeof(Thtml_diag));
/* kyanh, removed, 20050225,
dg->tobedestroyed = FALSE;
*/
DEBUG_MSG("html_diag_new, dg=%p\n",dg);
dg->dialog = window_full2(title, GTK_WIN_POS_MOUSE, 12,G_CALLBACK(html_diag_destroy_cb), dg, TRUE/* escape key close the winow */, bfwin ? bfwin->main_window : NULL);
gtk_window_set_type_hint(GTK_WINDOW(dg->dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_role(GTK_WINDOW(dg->dialog), "html_dialog");
dg->vbox = gtk_vbox_new(FALSE, 1);
gtk_container_add(GTK_CONTAINER(dg->dialog), dg->vbox);
{
if (!gtk_text_buffer_get_mark(bfwin->current_document->buffer,"diag_ins")) {
GtkTextIter iter;
GtkTextMark* mark = gtk_text_buffer_get_mark(bfwin->current_document->buffer,"insert");
gtk_text_buffer_get_iter_at_mark(bfwin->current_document->buffer,&iter,mark);
dg->mark_ins = gtk_text_buffer_create_mark(bfwin->current_document->buffer,"diag_ins",&iter,TRUE);
mark = gtk_text_buffer_get_mark(bfwin->current_document->buffer,"selection_bound");
gtk_text_buffer_get_iter_at_mark(bfwin->current_document->buffer,&iter,mark);
dg->mark_sel = gtk_text_buffer_create_mark(bfwin->current_document->buffer,"diag_sel",&iter,TRUE);
} else {
dg->mark_ins = dg->mark_sel = NULL;
}
}
/*
dg->range.pos = -1;
dg->range.end = -1;
*/
if (main_v->props.view_bars & MODE_MAKE_LATEX_TRANSIENT) {
/* must be set before realizing */
DEBUG_MSG("html_diag_finish, setting dg->dialog=%p transient!\n", dg->dialog);
gtk_window_set_transient_for(GTK_WINDOW(dg->dialog), GTK_WINDOW(bfwin->main_window));
}
gtk_widget_realize(dg->dialog);
dg->bfwin = bfwin;
dg->doc = bfwin->current_document;
return dg;
}
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);
}
void textbuffer_changed(GtkTextBuffer *buffer, gpointer data)
{
GtkTextMark *insert, *end;
GtkTextIter end_iter;
GtkTextIter insert_iter;
gchar * text = NULL;
insert = gtk_text_buffer_get_insert (buffer);
end = gtk_text_buffer_get_mark (buffer,"end");
gtk_text_buffer_get_iter_at_mark(buffer,&insert_iter,insert);
gtk_text_buffer_get_iter_at_mark(buffer,&end_iter,end);
text = gtk_text_buffer_get_text(buffer,&insert_iter,&end_iter,TRUE);
}
void
html_diag_destroy_cb(GtkWidget * widget, Thtml_diag * dg)
{
dg->tobedestroyed = TRUE;
DEBUG_MSG("html_diag_destroy_cb, widget=%p, dg=%p, dg->dialog=%p\n", widget, dg, dg->dialog);
if (gtk_text_buffer_get_mark(dg->doc->buffer, "diag_ins") == dg->mark_ins) {
gtk_text_buffer_delete_mark(dg->doc->buffer, dg->mark_ins);
gtk_text_buffer_delete_mark(dg->doc->buffer, dg->mark_sel);
}
window_destroy(dg->dialog);
DEBUG_MSG("html_diag_destroy_cb, about to free dg=%p\n", dg);
g_free(dg);
}
static gchar *
get_word_at_iter (GscProviderDevhelp *devhelp,
GtkTextIter *iter)
{
GtkTextIter start = *iter;
gint line = gtk_text_iter_get_line (iter);
gboolean went_back = TRUE;
GtkTextMark *mark;
if (!gtk_text_iter_backward_char (&start))
{
return NULL;
}
while (went_back &&
line == gtk_text_iter_get_line (&start) &&
is_word_char (gtk_text_iter_get_char (&start)))
{
went_back = gtk_text_iter_backward_char (&start);
}
if (went_back)
{
gtk_text_iter_forward_char (&start);
}
if (gtk_text_iter_equal (iter, &start))
{
return NULL;
}
mark = gtk_text_buffer_get_mark (gtk_text_iter_get_buffer (iter),
MARK_NAME);
if (mark)
{
gtk_text_buffer_move_mark (gtk_text_iter_get_buffer (iter),
mark,
&start);
}
else
{
mark = gtk_text_buffer_create_mark (gtk_text_iter_get_buffer (iter),
MARK_NAME,
&start,
TRUE);
}
return gtk_text_iter_get_text (&start, iter);
}
/* 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);
}
/* Trap mark movement events in a Text, so that if line input is
in progress, the user can use C-a or C-e to move to the beginning /
end of the line input, not the beginning / end of the current line */
static void gglk_text_cursor_event(GtkTextBuffer *unused_widget,
GtkTextIter *unused_iter,
GtkTextMark *unused_mark,
gpointer user_data)
{
GglkText *tb = user_data;
GtkTextIter b, e;
int i;
gboolean moved[2] = { FALSE, FALSE };
g_signal_handler_block(tb->buffer, tb->cursor_handler);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &e, tb->endedit);
for(i = 0; i < 2; i++) {
GtkTextMark *this_mark = gtk_text_buffer_get_mark(
tb->buffer, i ? "selection_bound" : "insert");
GtkTextIter current;
gtk_text_buffer_get_iter_at_mark(tb->buffer, ¤t, this_mark);
/* If past the end mark, move back. */
if(gtk_text_iter_compare(¤t, &e) > 0) {
gtk_text_buffer_move_mark(tb->buffer, this_mark, &e);
moved[i] = TRUE;
}
/* If on the same line as the input, but before the region,
* move forward */
if(gtk_text_iter_get_line(¤t) == gtk_text_iter_get_line(&b) &&
gtk_text_iter_compare(¤t, &b) < 0) {
gtk_text_buffer_move_mark(tb->buffer, this_mark, &b);
moved[i] = TRUE;
}
}
if(moved[0]) {
/* This will make the cursor appear immediately */
g_signal_emit_by_name(tb, "move-cursor",
GTK_MOVEMENT_LOGICAL_POSITIONS, 0, TRUE);
}
g_signal_handler_unblock(tb->buffer, tb->cursor_handler);
}
static void
vivi_command_line_append_message (ViviApplication *app, guint type, const char *message, GtkTextView *view)
{
GtkTextBuffer *buffer = gtk_text_view_get_buffer (view);
GtkTextIter iter;
GtkTextMark *mark;
const char *tag_names[] = { "input", "output", "error" };
gtk_text_buffer_get_end_iter (buffer, &iter);
mark = gtk_text_buffer_get_mark (buffer, "end");
if (mark == NULL)
mark = gtk_text_buffer_create_mark (buffer, "end", &iter, FALSE);
if (gtk_text_buffer_get_char_count (buffer) > 0)
gtk_text_buffer_insert (buffer, &iter, "\n", 1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, message, -1, tag_names[type], NULL);
gtk_text_view_scroll_to_mark (view, mark, 0.0, TRUE, 0.0, 0.0);
}
static gboolean
t_text_tail_print (GIOChannel *source, GIOCondition condition, gpointer data)
{
GtkTextView *text_view;
GtkTextBuffer *buffer;
GtkTextIter iter;
gchar *line;
gsize len;
GError *err = NULL;
if (G_IO_STATUS_NORMAL != g_io_channel_read_line (source, &line, &len, NULL, &err)) {
if (len > 0)
g_free (line);
T_ERR_WARN (err);
return FALSE;
}
T_ERR_WARN (err);
if (!len) {
g_warning ("Empty line");
return TRUE;
}
text_view = GTK_TEXT_VIEW (data);
/* append text */
buffer = gtk_text_view_get_buffer (text_view);
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_insert (buffer, &iter, line, -1);
g_free (line);
/* move carret to the end */
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_move_mark_by_name (buffer, "insert", &iter);
/* scroll to carret */
gtk_text_view_scroll_to_mark (
text_view,
gtk_text_buffer_get_mark (buffer, "insert"),
0.0,
FALSE,
0.0,
0.0
);
return TRUE;
}
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
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);
}
//================================================================
long GUI_edi_getLnr (MemObj *mo) {
//================================================================
/// \code
/// GUI_edi_getLnr get LineNr of act.Curpos
/// First line = 1 !
/// \endcode
// die Filesize und cPos ist unterschiedlich, weil gtk Sonderzeichen nur
// als 1 char behandelt !!!
// Man darf daher die cPos nicht zum Positionieren im Mem benutzen !!!!
int lNr;
GtkTextMark *mk1;
GtkTextIter it1;
// printf("GUI_edi_getLnr \n");
// set GUI_ed1_view GUI_ed1_buff
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// get mark at CurPos
mk1 = gtk_text_buffer_get_mark (GUI_ed1_buff, "insert");
// iter at CurPos
gtk_text_buffer_get_iter_at_mark (GUI_ed1_buff, &it1, mk1);
// get LineNr from iter
lNr = gtk_text_iter_get_line (&it1);
// gCAd beginnt mit LineNr 1 !!!
++lNr;
// // offset from iter
// cpos1 = gtk_text_iter_get_offset (&it1);
// printf("ex GUI_edi_getLnr %d\n",lNr);
return lNr;
}
void compile_cb(GtkWidget *tool, GtkTextView *output)
{
FILE *make;
char tmp[BUF_LEN];
GtkTextBuffer *text_buffer;
GtkTextIter end;
GtkTextMark *mk;
if (project_path->str == NULL)
return;
text_buffer = gtk_text_view_get_buffer(output);
printf("Generating Makefile..\n");
generate_makefile();
printf("Done.\n");
make = popen("make clean 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);
}
sprintf(tmp, "make -j%d compile 2>&1", make_threads);
make = popen(tmp, "r");
if (make == NULL) {
fprintf(stderr, "Failed to call '%s'\n", tmp);
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);
}
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
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);
}
