/**
Kolorowanie słów.
Słowa nie znajdujące się w słowniku - potencjalnie błędne - zostają
oznaczone na czerwono.
*/
static void show_errors() {
GtkTextIter start, end, text_end;
int i, range;
char *word;
gunichar *wword;
gtk_text_buffer_create_tag(editor_buf, "red_fg",
"foreground", "red",
"weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_get_end_iter(editor_buf, &text_end);
gtk_text_buffer_get_start_iter(editor_buf, &end);
range = gtk_text_buffer_get_char_count(editor_buf);
while (!gtk_text_iter_is_end(&end)) {
gtk_text_iter_forward_word_end(&end);
start = end;
gtk_text_iter_backward_word_start(&start);
word = gtk_text_iter_get_text(&start, &end);
wword = g_utf8_to_ucs4_fast(word, -1, NULL);
if (make_lowercase(wword)) {
if (!dictionary_find(dict, wword))
gtk_text_buffer_apply_tag_by_name(editor_buf, "red_fg",
&start, &end);
}
g_free(word);
g_free(wword);
}
}
//==========================================================================
long GUI_edi_getEof (MemObj *mo) {
//==========================================================================
/// GUI_edi_getEof
/// get total nr of chars (not bytes)
/// gtk_text_buffer_get_char_count get nr of chars, not nr of bytes !
long fSiz, p1;
// set GUI_ed1_view GUI_ed1_buff
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// get nr of chars in buffer, not nr of bytes !
fSiz = gtk_text_buffer_get_char_count (GUI_ed1_buff);
// get startPos of text; gtk_text_iter_get_text
// fSiz = g_utf8_offset_to_pointer (ptrStart, nrChar);
// printf("ex GUI_Ed_getEof %ld\n",fSiz);
return fSiz;
}
gsize
xedit_document_input_stream_get_total_size (XeditDocumentInputStream *stream)
{
g_return_val_if_fail (XEDIT_IS_DOCUMENT_INPUT_STREAM (stream), 0);
return gtk_text_buffer_get_char_count (stream->priv->buffer);
}
static void
update_statusbar (GtkTextBuffer *buffer,
GtkStatusbar *statusbar)
{
gchar *msg;
gint row, col;
gint count;
GtkTextIter iter;
/* clear any previous message, underflow is allowed */
gtk_statusbar_pop (statusbar, 0);
count = gtk_text_buffer_get_char_count (buffer);
gtk_text_buffer_get_iter_at_mark (buffer,
&iter,
gtk_text_buffer_get_insert (buffer));
row = gtk_text_iter_get_line (&iter);
col = gtk_text_iter_get_line_offset (&iter);
msg = g_strdup_printf ("Cursor at row %d column %d - %d chars in document",
row, col, count);
gtk_statusbar_push (statusbar, 0, msg);
g_free (msg);
}
static void
timestamp_display(PurpleConversation *conv, time_t then, time_t now)
{
PidginConversation *gtk_conv = PIDGIN_CONVERSATION(conv);
GtkWidget *imhtml = gtk_conv->imhtml;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(imhtml));
GtkTextIter iter;
const char *mdate;
int y, height;
GdkRectangle rect;
/* display timestamp */
mdate = purple_utf8_strftime(then == 0 ? "%H:%M" : "\n%H:%M",
localtime(&now));
gtk_text_buffer_get_end_iter(buffer, &iter);
if (gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "TIMESTAMP") == NULL)
gtk_text_buffer_create_tag(buffer, "TIMESTAMP",
"foreground", "#888888", "justification", GTK_JUSTIFY_CENTER,
"weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, mdate,
strlen(mdate), "TIMESTAMP", NULL);
/* scroll view if necessary */
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(imhtml), &rect);
gtk_text_view_get_line_yrange(
GTK_TEXT_VIEW(imhtml), &iter, &y, &height);
if (((y + height) - (rect.y + rect.height)) > height &&
gtk_text_buffer_get_char_count(buffer)) {
gboolean smooth = purple_prefs_get_bool(
PIDGIN_PREFS_ROOT "/conversations/use_smooth_scrolling");
gtk_imhtml_scroll_to_end(GTK_IMHTML(imhtml), smooth);
}
}
static void
gail_scale_notify (GObject *obj,
GParamSpec *pspec)
{
GailScale *scale = GAIL_SCALE (obj);
if (strcmp (pspec->name, "accessible-value") == 0)
{
GtkWidget *widget;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (widget)
{
GtkScale *gtk_scale;
PangoLayout *layout;
const gchar *txt;
gtk_scale = GTK_SCALE (widget);
layout = gtk_scale_get_layout (gtk_scale);
if (layout)
{
txt = pango_layout_get_text (layout);
if (txt)
{
g_signal_emit_by_name (obj, "text_changed::delete", 0,
gtk_text_buffer_get_char_count (scale->textutil->buffer));
gail_text_util_text_setup (scale->textutil, txt);
g_signal_emit_by_name (obj, "text_changed::insert", 0,
g_utf8_strlen (txt, -1));
}
}
}
}
G_OBJECT_CLASS (gail_scale_parent_class)->notify (obj, pspec);
}
static void
put_text_in_textview_impl(const gchar * txt, GtkWidget * textview_output)
{
GtkTextBuffer * text_buffer;
GtkTextIter end;
GtkTextTag *tt;
GtkTextTagTable *tt_table;
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview_output));
tt_table = gtk_text_buffer_get_tag_table(text_buffer);
tt = gtk_text_tag_table_lookup(tt_table, "mono");
if (!tt)
{
#ifdef win32
tt = gtk_text_buffer_create_tag(text_buffer, "mono",
"font", "Courier", NULL);
#else
tt = gtk_text_buffer_create_tag(text_buffer, "mono", "font", "Mono",
"size-points", (double)8.0, NULL);
#endif
}
if (gtk_text_buffer_get_char_count(text_buffer) > 0)
{
GtkTextIter b, e;
gtk_text_buffer_get_start_iter(text_buffer, &b);
gtk_text_buffer_get_end_iter(text_buffer, &e);
gtk_text_buffer_delete(text_buffer, &b, &e);
}
gtk_text_buffer_get_end_iter(text_buffer, &end);
gtk_text_buffer_insert_with_tags(text_buffer, &end, txt, -1, tt, NULL);
}
void
viewlog (gpointer data)
{
char *tempstr, *txt, *pos;
gint textlen;
ssize_t len;
int fd;
#if GTK_MAJOR_VERSION > 1
GtkTextBuffer * textbuf;
GtkTextIter iter, iter2;
#endif
tempstr = g_strconcat (g_get_tmp_dir (), "/gftp-view.XXXXXXXXXX", NULL);
if ((fd = mkstemp (tempstr)) < 0)
{
ftp_log (gftp_logging_error, NULL,
_("Error: Cannot open %s for writing: %s\n"), tempstr,
g_strerror (errno));
g_free (tempstr);
return;
}
chmod (tempstr, S_IRUSR | S_IWUSR);
#if GTK_MAJOR_VERSION == 1
textlen = gtk_text_get_length (GTK_TEXT (logwdw));
txt = gtk_editable_get_chars (GTK_EDITABLE (logwdw), 0, -1);
#else
textbuf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (logwdw));
textlen = gtk_text_buffer_get_char_count (textbuf);
gtk_text_buffer_get_iter_at_offset (textbuf, &iter, 0);
gtk_text_buffer_get_iter_at_offset (textbuf, &iter2, textlen);
txt = gtk_text_buffer_get_text (textbuf, &iter, &iter2, 0);
/* gtk_text_buffer_get_char_count() returns the number of characters,
not bytes. So get the number of bytes that need to be written out */
textlen = strlen (txt);
#endif
pos = txt;
while (textlen > 0)
{
if ((len = write (fd, pos, textlen)) == -1)
{
ftp_log (gftp_logging_error, NULL,
_("Error: Error writing to %s: %s\n"),
tempstr, g_strerror (errno));
break;
}
textlen -= len;
pos += len;
}
fsync (fd);
lseek (fd, 0, SEEK_SET);
view_file (tempstr, fd, 1, 1, 0, 1, NULL, NULL);
close (fd);
g_free (tempstr);
g_free (txt);
}
static gunichar
ev_view_accessible_get_character_at_offset (AtkText *text,
gint offset)
{
GtkWidget *widget;
GtkTextIter start, end;
GtkTextBuffer *buffer;
gchar *string;
gunichar unichar;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
/* State is defunct */
return '\0';
buffer = ev_view_accessible_get_text_buffer (EV_VIEW_ACCESSIBLE (text), EV_VIEW (widget));
if (!buffer)
return '\0';
if (offset >= gtk_text_buffer_get_char_count (buffer))
return '\0';
gtk_text_buffer_get_iter_at_offset (buffer, &start, offset);
end = start;
gtk_text_iter_forward_char (&end);
string = gtk_text_buffer_get_slice (buffer, &start, &end, FALSE);
unichar = g_utf8_get_char (string);
g_free(string);
return unichar;
}
static void
input_buffer_changed(GtkTextBuffer *text_buffer, GtkWidget *send_button)
{
if (gtk_text_buffer_get_char_count(text_buffer) != 0)
gtk_widget_set_sensitive(send_button, TRUE);
else
gtk_widget_set_sensitive(send_button, FALSE);
}
gint
eel_accessibility_text_get_character_count (AtkText *text)
{
GailTextUtil *util = get_simple_text (text);
g_return_val_if_fail (util != NULL, -1);
return gtk_text_buffer_get_char_count (util->buffer);
}
static void
update_ui (GeditSpellPlugin *plugin)
{
GeditSpellPluginPrivate *priv;
GeditView *view;
GAction *check_spell_action;
GAction *config_spell_action;
GAction *auto_spell_action;
gedit_debug (DEBUG_PLUGINS);
priv = plugin->priv;
view = gedit_window_get_active_view (priv->window);
check_spell_action = g_action_map_lookup_action (G_ACTION_MAP (priv->window),
"check-spell");
g_simple_action_set_enabled (G_SIMPLE_ACTION (check_spell_action),
(view != NULL) &&
gtk_text_view_get_editable (GTK_TEXT_VIEW (view)));
config_spell_action = g_action_map_lookup_action (G_ACTION_MAP (priv->window),
"config-spell");
g_simple_action_set_enabled (G_SIMPLE_ACTION (config_spell_action),
(view != NULL) &&
gtk_text_view_get_editable (GTK_TEXT_VIEW (view)));
auto_spell_action = g_action_map_lookup_action (G_ACTION_MAP (priv->window),
"auto-spell");
g_simple_action_set_enabled (G_SIMPLE_ACTION (auto_spell_action),
(view != NULL) &&
gtk_text_view_get_editable (GTK_TEXT_VIEW (view)));
if (view != NULL)
{
GeditDocument *doc;
GeditTab *tab;
GeditTabState state;
gboolean autospell;
doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
tab = gedit_window_get_active_tab (priv->window);
state = gedit_tab_get_state (tab);
autospell = (doc != NULL &&
gedit_automatic_spell_checker_get_from_document (doc) != NULL);
/* If the document is loading we can't get the metadata so we
endup with an useless speller */
if (state == GEDIT_TAB_STATE_NORMAL)
{
g_action_change_state (auto_spell_action, g_variant_new_boolean (autospell));
}
g_simple_action_set_enabled (G_SIMPLE_ACTION (check_spell_action),
gtk_text_buffer_get_char_count (GTK_TEXT_BUFFER (doc)) > 0);
}
}
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;
}
static void
delete_text_cb(GtkTextBuffer *textbuffer, GtkTextIter *start_pos,
GtkTextIter *end_pos, gpointer user_data)
{
PurpleConversation *conv = (PurpleConversation *)user_data;
PidginConversation *gtkconv = PIDGIN_CONVERSATION(conv);
GtkWidget *box, *counter = NULL;
gchar *markup = NULL;
gint service = get_service_type(conv);
guint count = 0;
g_return_if_fail(gtkconv != NULL);
switch(service) {
case twitter_service:
case identica_service:
case jisko_service:
case ffeed_service:
count= gtk_text_buffer_get_char_count(textbuffer) -
(gtk_text_iter_get_offset(end_pos) -
gtk_text_iter_get_offset(start_pos));
markup = g_markup_printf_escaped("<span color=\"%s\">%u</span>",
count <= 140 ? "black" : "red", count);
break;
case wassr_service:
count= gtk_text_buffer_get_char_count(textbuffer) -
(gtk_text_iter_get_offset(end_pos) -
gtk_text_iter_get_offset(start_pos));
markup = g_markup_printf_escaped("<span color=\"%s\">%u</span>",
count <= 255 ? "black" : "red", count);
break;
default:
twitter_debug("unknown service\n");
break;
}
box = gtkconv->toolbar;
counter = g_object_get_data(G_OBJECT(box), PLUGIN_ID "-counter");
if(counter)
gtk_label_set_markup(GTK_LABEL(counter), markup);
g_free(markup);
}
gsize
_gtk_source_buffer_input_stream_get_total_size (GtkSourceBufferInputStream *stream)
{
g_return_val_if_fail (GTK_SOURCE_IS_BUFFER_INPUT_STREAM (stream), 0);
if (stream->priv->buffer == NULL)
{
return 0;
}
return gtk_text_buffer_get_char_count (stream->priv->buffer);
}
/*
this function is designed to return a GtkTextView object's text in agxbuf
send an initialized agxbuf and a GtkTextView object
null termination is taken care by agxbuf
*/
void get_gtktextview_text(GtkTextView * w, agxbuf * xbuf)
{
int charcnt;
GtkTextBuffer *gtkbuf;
GtkTextIter startit;
GtkTextIter endit;
gtkbuf = gtk_text_view_get_buffer(w);
charcnt = gtk_text_buffer_get_char_count(gtkbuf);
gtk_text_buffer_get_start_iter(gtkbuf, &startit);
gtk_text_buffer_get_end_iter(gtkbuf, &endit);
agxbput(xbuf, gtk_text_buffer_get_text(gtkbuf, &startit, &endit, 0));
}
static void linphone_gtk_display_log(GtkTextView *v, OrtpLogLevel lev, const char *msg){
GtkTextIter iter,begin;
int off;
GtkTextBuffer *b;
const char *lname="undef";
b=gtk_text_view_get_buffer(v);
switch(lev){
case ORTP_DEBUG:
lname="debug";
break;
case ORTP_MESSAGE:
lname="message";
break;
case ORTP_WARNING:
lname="warning";
break;
case ORTP_ERROR:
lname="error";
break;
case ORTP_FATAL:
lname="fatal";
break;
default:
g_error("Bad level !");
}
gtk_text_buffer_get_end_iter(b,&iter);
off=gtk_text_iter_get_offset(&iter);
gtk_text_buffer_insert(b,&iter,lname,-1);
gtk_text_buffer_get_end_iter(b,&iter);
gtk_text_buffer_insert(b,&iter,": ",-1);
gtk_text_buffer_get_end_iter(b,&iter);
gtk_text_buffer_insert(b,&iter,msg,-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_buffer_get_iter_at_offset(b,&begin,off);
if (lev==ORTP_ERROR || lev==ORTP_FATAL) gtk_text_buffer_apply_tag_by_name(b,"red",&begin,&iter);
else if (lev==ORTP_WARNING) gtk_text_buffer_apply_tag_by_name(b,"orange",&begin,&iter);
while(gtk_text_buffer_get_char_count(b)>LOG_MAX_CHARS){
GtkTextIter iter_line_after;
gtk_text_buffer_get_start_iter(b,&iter);
iter_line_after=iter;
if (gtk_text_iter_forward_line(&iter_line_after)){
gtk_text_buffer_delete(b,&iter,&iter_line_after);
}
}
}
void
ap_assistant_finish (GtkAssistant *assistant, gpointer user_data)
{
AcctPeriodInfo *info = user_data;
GtkTextBuffer * buffer;
GtkTextIter startiter, enditer;
gint len;
const char *btitle;
char *bnotes;
Timespec closing_date;
ENTER("info=%p", info);
btitle = gtk_entry_get_text (GTK_ENTRY(info->book_title));
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(info->book_notes));
len = gtk_text_buffer_get_char_count (buffer);
gtk_text_buffer_get_iter_at_offset(buffer, &startiter, 0);
gtk_text_buffer_get_iter_at_offset(buffer, &enditer, len);
bnotes = gtk_text_buffer_get_text(buffer, &startiter, &enditer , 0);
PINFO("Book title is - %s\n", btitle);
timespecFromTime64 (&closing_date,
gnc_time64_get_day_end_gdate (&info->closing_date));
g_free(bnotes);
/* Report the status back to the user. */
info->close_status = 0; /* XXX fixme success or failure? */
/* Find the next closing date ... */
info->prev_closing_date = info->closing_date;
recurrenceListNextInstance (info->period, &info->prev_closing_date,
&info->closing_date);
/* FIXME Test for valid closing date, not sure why it won't be!!! */
if (g_date_valid(&info->closing_date) == TRUE)
{
/* If the next closing date is in the future, then we are done. */
if (gnc_time (NULL) >
gnc_time64_get_day_end_gdate (&info->closing_date))
{
/* Load up the GUI for the next closing period. */
gnc_frequency_setup_recurrence (info->period_menu, NULL,
&info->closing_date);
/* Jump back to the Close Book page. */
gtk_assistant_set_current_page (GTK_ASSISTANT(info->window), 1);
}
}
}
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 gint
gail_scale_get_character_count (AtkText *text)
{
GtkWidget *widget;
GailScale *scale;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
/* State is defunct */
return 0;
scale = GAIL_SCALE (text);
if (scale->textutil->buffer)
return gtk_text_buffer_get_char_count (scale->textutil->buffer);
else
return 0;
}
/* Return TRUE if the dialog box's widgets' state are such that clicking OK
might not result in erroneous syntax being generated */
static gboolean
contents_plausible (gpointer data)
{
struct compute_dialog *cd = data;
GtkWidget *target = get_widget_assert (cd->xml, "compute-entry1");
GtkWidget *syntax_area = get_widget_assert (cd->xml, "compute-textview1");
GtkTextBuffer *buffer =
gtk_text_view_get_buffer (GTK_TEXT_VIEW (syntax_area));
if ( 0 == strcmp ("", gtk_entry_get_text (GTK_ENTRY (target))))
return FALSE;
if ( gtk_text_buffer_get_char_count (buffer) == 0 )
return FALSE;
return TRUE;
}
static void
update_marker_for_gtkconv(PidginConversation *gtkconv)
{
GtkTextIter iter;
GtkTextBuffer *buffer;
g_return_if_fail(gtkconv != NULL);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(gtkconv->imhtml));
if (!gtk_text_buffer_get_char_count(buffer))
return;
gtk_text_buffer_get_end_iter(buffer, &iter);
g_object_set_data(G_OBJECT(gtkconv->imhtml), "markerline",
GINT_TO_POINTER(gtk_text_iter_get_offset(&iter)));
gtk_widget_queue_draw(gtkconv->imhtml);
}
gboolean check_event_log(gpointer user_data)
{
struct s_gui_data *gui_data = (struct s_gui_data *)user_data;
zmq_msg_t message;
int msgsize;
char *strmsg;
char has_msg ;
zmq_msg_init(&message);
has_msg = !zmq_recv(gui_data->sub_event_log, &message, ZMQ_NOBLOCK);
gboolean found_msg = FALSE;
while(has_msg)
{
found_msg = TRUE;
msgsize = zmq_msg_size(&message);
strmsg = (char *)malloc(msgsize);
memcpy(strmsg, zmq_msg_data(&message), msgsize);
GtkTextIter logIter;
GtkTextMark *logMark = gtk_text_buffer_get_insert (gui_data->textbufferLog);
gtk_text_buffer_get_iter_at_mark (gui_data->textbufferLog, &logIter, logMark);
if (gtk_text_buffer_get_char_count(gui_data->textbufferLog))
gtk_text_buffer_insert (gui_data->textbufferLog, &logIter, "\n", 1);
gtk_text_buffer_insert (gui_data->textbufferLog, &logIter, strmsg, msgsize);
zmq_msg_close(&message);
zmq_msg_init(&message);
has_msg = !zmq_recv(gui_data->sub_event_log, &message, ZMQ_NOBLOCK);
}
if(found_msg != gui_data->logged_event)
{
gui_data->logged_event = found_msg;
if(found_msg)
{
gtk_status_icon_set_from_pixbuf(gui_data->systrayIcon, gtk_image_get_pixbuf(gui_data->image_started_event));
}
else
{
gtk_status_icon_set_from_pixbuf(gui_data->systrayIcon, gtk_image_get_pixbuf(gui_data->image_started));
}
}
if(gui_data->lstart.active)
return TRUE;
return FALSE;
}
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));
}
// cut off the beginning lines if we have too many
static void
warlock_view_trim (WarlockView *view)
{
int size;
// less than zero means unlimited
if (max_buffer_size < 0)
return;
size = gtk_text_buffer_get_char_count (view->text_buffer);
if (size > max_buffer_size) {
GtkTextIter start, end;
gtk_text_buffer_get_start_iter (view->text_buffer, &start);
gtk_text_buffer_get_iter_at_offset (view->text_buffer, &end,
size - max_buffer_size);
gtk_text_buffer_delete (view->text_buffer, &start, &end);
}
}
static gint
ev_view_accessible_get_character_count (AtkText *text)
{
GtkWidget *widget;
GtkTextBuffer *buffer;
gint retval;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
/* State is defunct */
return 0;
buffer = ev_view_accessible_get_text_buffer (EV_VIEW_ACCESSIBLE (text), EV_VIEW (widget));
if (!buffer)
return 0;
retval = gtk_text_buffer_get_char_count (buffer);
return retval;
}
void
clearlog (gpointer data)
{
gint len;
#if GTK_MAJOR_VERSION == 1
len = gtk_text_get_length (GTK_TEXT (logwdw));
gtk_text_set_point (GTK_TEXT (logwdw), len);
gtk_text_backward_delete (GTK_TEXT (logwdw), len);
#else
GtkTextBuffer * textbuf;
GtkTextIter iter, iter2;
textbuf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (logwdw));
len = gtk_text_buffer_get_char_count (textbuf);
gtk_text_buffer_get_iter_at_offset (textbuf, &iter, 0);
gtk_text_buffer_get_iter_at_offset (textbuf, &iter2, len);
gtk_text_buffer_delete (textbuf, &iter, &iter2);
#endif
}
static void gmdb_sql_dnd_datareceived_cb(
GtkWidget *w,
GdkDragContext *dc,
gint x, gint y,
GtkSelectionData *selection_data,
guint info, guint t,
GladeXML *xml)
{
GtkTextIter iter;
GtkTextBuffer *txtbuffer;
GtkWidget *textview;
textview = glade_xml_get_widget(xml, "sql_textview");
txtbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
if (gtk_text_buffer_get_char_count(txtbuffer)==0) {
gtk_text_buffer_get_iter_at_offset (txtbuffer, &iter, 0);
gtk_text_buffer_insert(txtbuffer, &iter, "select * from ", 14);
}
gtk_widget_grab_focus(GTK_WIDGET(textview));
}
void XAttGtk::action_text_inserted(
GtkTextBuffer* w, GtkTextIter* iter, gchar* str, gint len, gpointer data)
{
XAttGtk* xatt = (XAttGtk*)data;
int count = gtk_text_buffer_get_char_count(w);
if (count > xatt->input_max_length) {
// Remove inserted chars (note that iter now points at the end of the
// inserted text)
GtkTextIter start_iter;
int offs = gtk_text_iter_get_offset(iter);
gtk_text_buffer_get_iter_at_offset(w, &start_iter, offs - len);
gtk_text_buffer_delete(w, &start_iter, iter);
CoWowGtk wow(xatt->toplevel);
wow.DisplayError("Error message", "Attribute size exceeded");
}
}
void
append_output(const gchar * txt, GtkWidget * textview_output)
{
GtkTextBuffer * text_buffer;
GtkTextIter end;
GtkTextTag *tt;
GtkTextTagTable *tt_table;
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview_output));
tt_table = gtk_text_buffer_get_tag_table(text_buffer);
tt = gtk_text_tag_table_lookup(tt_table, "mono");
if (!tt)
{
#ifdef win32
const char *fnt = "Courier";
#else
const char *fnt = "Mono";
#endif
tt = gtk_text_buffer_create_tag(text_buffer, "mono",
"font", fnt, NULL);
}
if (gtk_text_buffer_get_char_count(text_buffer) > 0)
{
GtkTextIter b, e;
gtk_text_buffer_get_start_iter(text_buffer, &b);
gtk_text_buffer_get_end_iter(text_buffer, &e);
gtk_text_buffer_delete(text_buffer, &b, &e);
}
gtk_text_buffer_get_end_iter(text_buffer, &end);
gtk_text_buffer_insert_with_tags(text_buffer, &end, txt, -1, tt, NULL);
}
