void EditorActionInsertText::apply (GtkWidget *& to_focus)
{
GtkTextIter iter;
gtk_text_buffer_get_iter_at_offset (paragraph->textbuffer, &iter, offset);
gtk_text_buffer_insert (paragraph->textbuffer, &iter, text.c_str(), -1);
// Apply the paragraph style to the new inserted text.
// It is important that paragraph styles are applied first, and character styles last.
// Since this is new inserted text, there's no character style yet,
// so the paragraph style can be applied normally.
GtkTextIter startiter;
gtk_text_buffer_get_iter_at_offset (paragraph->textbuffer, &startiter, offset);
GtkTextIter enditer;
gtk_text_buffer_get_iter_at_offset (paragraph->textbuffer, &enditer, offset + text.length());
gtk_text_buffer_apply_tag_by_name (paragraph->textbuffer, paragraph->style.c_str(), &startiter, &enditer);
// Focus widget.
to_focus = paragraph->textview;
}
/* While not as cool as c-mode, this will do as a quick attempt at highlighting */
static void
fontify (GtkTextBuffer *source_buffer)
{
GtkTextIter start_iter, next_iter, tmp_iter;
gint state;
gchar *text;
gchar *start_ptr, *end_ptr;
gchar *tag;
state = STATE_NORMAL;
gtk_text_buffer_get_iter_at_offset (source_buffer, &start_iter, 0);
next_iter = start_iter;
while (gtk_text_iter_forward_line (&next_iter))
{
gboolean start = TRUE;
start_ptr = text = gtk_text_iter_get_text (&start_iter, &next_iter);
do
{
parse_chars (start_ptr, &end_ptr, &state, &tag, start);
start = FALSE;
if (end_ptr)
{
tmp_iter = start_iter;
gtk_text_iter_forward_chars (&tmp_iter, end_ptr - start_ptr);
}
else
{
tmp_iter = next_iter;
}
if (tag)
gtk_text_buffer_apply_tag_by_name (source_buffer, tag, &start_iter, &tmp_iter);
start_iter = tmp_iter;
start_ptr = end_ptr;
}
while (end_ptr);
g_free (text);
start_iter = next_iter;
}
}
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);
}
/**********************************************************************
* Turns off the cursor immediately
*/
void
cursor_switch_off ()
{
GtkTextView *wg_text;
GtkTextBuffer *buf;
GtkTextIter start;
GtkTextIter end;
wg_text = GTK_TEXT_VIEW (get_wg ("text_tutor"));
buf = gtk_text_view_get_buffer (wg_text);
gtk_text_buffer_get_iter_at_mark (buf, &start, gtk_text_buffer_get_insert (buf));
gtk_text_buffer_get_iter_at_mark (buf, &end, gtk_text_buffer_get_insert (buf));
gtk_text_iter_forward_char (&end);
if (tutor_get_correcting ())
gtk_text_buffer_apply_tag_by_name (buf, "cursor_blink", &start, &end);
else
gtk_text_buffer_remove_tag_by_name (buf, "cursor_blink", &start, &end);
}
// Koloruje słowa nie ze słownika na czerwono
static void ColorMistakes (GtkMenuItem *item, gpointer data) {
GtkTextIter start, end, buffEnd;
gtk_text_buffer_get_start_iter(editor_buf, &end);
//Teraz sztuczką przesuwamy końcowy iterator na koniec ostatniego słowa
gtk_text_buffer_get_end_iter(editor_buf, &buffEnd);
gtk_text_iter_backward_word_start(&buffEnd);
gtk_text_iter_forward_word_end(&buffEnd);
gtk_text_buffer_create_tag(editor_buf, "red_fg",
"foreground", "red",
"weight", PANGO_WEIGHT_BOLD, NULL);
// Aktualizacja słownika
if(update_actual_dict() < 0)
return;
start = end;
while (!gtk_text_iter_equal(&end, &buffEnd)) {
// Inkrementacja zmiennych
gtk_text_iter_forward_word_end(&end);
start = end;
gtk_text_iter_backward_word_start(&start);
// Usuwamy etykietkę ze słowa jeśli jest
gtk_text_buffer_remove_tag_by_name(editor_buf, "red_fg",
&start, &end);
// Separujemy słowo
char* word = gtk_text_iter_get_text(&start, &end);
gunichar* wword = g_utf8_to_ucs4_fast(word, -1, NULL);
// Jeśli znaleziono w słowniku to kolorujemy
if(!dictionary_find(dict, (const wchar_t*)wword))
gtk_text_buffer_apply_tag_by_name(editor_buf, "red_fg",
&start, &end);
g_free(word);
}
}
void
empathy_chat_text_view_append_body (EmpathyChatTextView *view,
const gchar *body,
const gchar *tag)
{
EmpathyChatTextViewPriv *priv = GET_PRIV (view);
EmpathyStringParser *parsers;
gboolean use_smileys;
GtkTextIter start_iter;
GtkTextIter iter;
GtkTextMark *mark;
/* Check if we have to parse smileys */
use_smileys = g_settings_get_boolean (priv->gsettings_chat,
EMPATHY_PREFS_CHAT_SHOW_SMILEYS);
if (use_smileys)
parsers = string_parsers_with_smiley;
else
parsers = string_parsers;
/* Create a mark at the place we'll start inserting */
gtk_text_buffer_get_end_iter (priv->buffer, &start_iter);
mark = gtk_text_buffer_create_mark (priv->buffer, NULL, &start_iter, TRUE);
/* Parse text for links/smileys and insert in the buffer */
empathy_string_parser_substr (body, -1, parsers, priv->buffer);
/* Insert a newline after the text inserted */
gtk_text_buffer_get_end_iter (priv->buffer, &iter);
gtk_text_buffer_insert (priv->buffer, &iter, "\n", 1);
/* Apply the style to the inserted text. */
gtk_text_buffer_get_iter_at_mark (priv->buffer, &start_iter, mark);
gtk_text_buffer_get_end_iter (priv->buffer, &iter);
gtk_text_buffer_apply_tag_by_name (priv->buffer, tag,
&start_iter,
&iter);
gtk_text_buffer_delete_mark (priv->buffer, mark);
}
static void
markup_text (GtkTextBuffer *buffer)
{
GtkTextIter start, end;
gchar *text;
gint i;
regmatch_t pmatch[2];
gboolean any;
const gchar *str;
gint offset = 0;
g_return_if_fail (buffer != NULL);
gtk_text_buffer_get_start_iter (buffer, &start);
gtk_text_buffer_get_end_iter (buffer, &end);
gtk_text_buffer_remove_tag_by_name (buffer, E_BUFFER_TAGGER_LINK_TAG, &start, &end);
text = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
str = text;
any = TRUE;
while (any) {
any = FALSE;
for (i = 0; i < G_N_ELEMENTS (mim); i++) {
if (mim[i].preg && !regexec (mim[i].preg, str, 2, pmatch, 0)) {
gtk_text_buffer_get_iter_at_offset (buffer, &start, offset + pmatch[0].rm_so);
gtk_text_buffer_get_iter_at_offset (buffer, &end, offset + pmatch[0].rm_eo);
gtk_text_buffer_apply_tag_by_name (buffer, E_BUFFER_TAGGER_LINK_TAG, &start, &end);
any = TRUE;
str += pmatch[0].rm_eo;
offset += pmatch[0].rm_eo;
break;
}
}
}
g_free (text);
}
static gboolean hlight_searched_strings(GtkTextBuffer *buffer, gchar *str)
{
GtkTextIter iter, start, end;
gboolean res, retval = FALSE;
GtkSourceSearchFlags search_flags =
GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_TEXT_ONLY;
if (!string_find)
return FALSE;
if (!match_case)
search_flags = search_flags | GTK_SOURCE_SEARCH_CASE_INSENSITIVE;
gtk_text_buffer_get_bounds(buffer, &start, &end);
/* gtk_text_buffer_remove_tag_by_name(buffer,
"searched", &start, &end);
gtk_text_buffer_remove_tag_by_name(buffer,
"replaced", &start, &end); */
gtk_text_buffer_remove_all_tags(buffer, &start, &end);
iter = start;
do {
res = gtk_source_iter_forward_search(
&iter, str, search_flags, &start, &end, NULL);
if (res) {
retval = TRUE;
gtk_text_buffer_apply_tag_by_name(buffer,
"searched", &start, &end);
// replace_mode ? "replaced" : "searched", &start, &end);
iter = end;
}
} while (res);
/* if (replace_mode)
replace_mode = FALSE;
else */
hlight_toggle_searched(buffer);
return retval;
}
void interface_output_append_line (GtkWidget * tab)
{
// the horizontal line currently consists of 40 spaces with strikethrough on
GtkTextView *out1 = GTK_TEXT_VIEW(interface_get_widget(tab, "output1"));
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(out1));
gchar spaces[41];
int i, offset;
GtkTextIter start, end;
gtk_text_buffer_get_end_iter(buffer, &end);
offset = gtk_text_iter_get_offset(&end);
for (i = 0; i < 40; i++) spaces[i] = ' ';
spaces[40] = '\0';
gtk_text_buffer_insert(buffer, &end, spaces, -1);
// apply some tags on inserted text
gtk_text_buffer_get_iter_at_offset(buffer, &start, offset);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_apply_tag_by_name (buffer, "horzline", &start, &end);
}
void linphone_gtk_call_log_update(GtkWidget *w){
GtkTextView *v=GTK_TEXT_VIEW(linphone_gtk_get_widget(w,"logtextview"));
GtkTextBuffer *b=gtk_text_view_get_buffer(v);
GtkTextIter iter,begin;
int off;
char *logmsg;
const MSList *logs;
for (logs=linphone_core_get_call_logs(linphone_gtk_get_core());logs!=NULL;logs=logs->next){
LinphoneCallLog *cl=(LinphoneCallLog*)logs->data;
logmsg=linphone_call_log_to_str(cl);
gtk_text_buffer_get_end_iter(b,&iter);
off=gtk_text_iter_get_offset(&iter);
gtk_text_buffer_insert(b,&iter,logmsg,-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);
gtk_text_buffer_apply_tag_by_name(b,cl->dir==LinphoneCallOutgoing ? "green" : "blue" ,&begin,&iter);
ms_free(logmsg);
}
gtk_text_buffer_get_end_iter(b,&iter);
gtk_text_view_scroll_to_iter(v,&iter,0,FALSE,0,0);
}
void
highlight_add_tag (GtkTextBuffer *buffer, GtkTextIter *startitr,
gint offset, gint len, gchar *tag)
{
/* Apply highlighting. */
gint start_offset;
gint end_offset;
GtkTextIter start, end;
start_offset = gtk_text_iter_get_offset (startitr) + offset;
end_offset = start_offset + len;
gtk_text_buffer_get_iter_at_offset (buffer, &start, start_offset);
gtk_text_buffer_get_iter_at_offset (buffer, &end, end_offset);
/* If needed tag is a error style, we shouldn't delete other tags. */
if (g_strcmp0 (tag, CODE_TAG_ERROR) != 0) {
gtk_text_buffer_remove_tag_by_name (buffer, CODE_TAG_PREPROCESSOR, &start, &end);
gtk_text_buffer_remove_tag_by_name (buffer, CODE_TAG_KEYWORD, &start, &end);
gtk_text_buffer_remove_tag_by_name (buffer, CODE_TAG_CONSTANT, &start, &end);
gtk_text_buffer_remove_tag_by_name (buffer, CODE_TAG_STRING, &start, &end);
gtk_text_buffer_remove_tag_by_name (buffer, CODE_TAG_COMMENT, &start, &end);
}
gtk_text_buffer_apply_tag_by_name (buffer, tag, &start, &end);
}
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 void
show_parsing_error (GtkCssProvider *provider,
const gchar *path,
guint line,
guint position,
const GError *error,
GtkTextBuffer *buffer)
{
GtkTextIter start, end;
const char *tag_name;
gtk_text_buffer_get_iter_at_line (buffer, &start, line - 1);
if (gtk_text_buffer_get_line_count (buffer) <= line)
gtk_text_buffer_get_end_iter (buffer, &end);
else
gtk_text_buffer_get_iter_at_line (buffer, &end, line);
if (g_error_matches (error, GTK_CSS_PROVIDER_ERROR, GTK_CSS_PROVIDER_ERROR_DEPRECATED))
tag_name = "warning";
else
tag_name = "error";
gtk_text_buffer_apply_tag_by_name (buffer, tag_name, &start, &end);
}
void
utl_gui_text_buffer_set_text_with_tags (GtkTextBuffer *buffer, const gchar *text, gboolean clear) {
GtkTextIter start, end;
GList *tags = NULL;
gchar **tokens;
gint count;
gchar tag_char_utf8[7] = {0};
if (!text)
return;
gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER (buffer));
if (clear == TRUE) {
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (buffer), &start, &end);
gtk_text_buffer_delete (GTK_TEXT_BUFFER (buffer), &start, &end);
}
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (buffer), &start, &end);
g_unichar_to_utf8 (TAG_CHAR, tag_char_utf8);
tokens = g_strsplit (text, tag_char_utf8, 0);
for (count = 0; tokens[count]; count++)
{
if (count % 2 == 0)
{
gint offset;
GList *j;
offset = gtk_text_iter_get_offset (&end);
gtk_text_buffer_insert (GTK_TEXT_BUFFER (buffer), &end, tokens[count], -1);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (buffer), &start, offset);
for (j = tags; j; j = j->next)
{
gtk_text_buffer_apply_tag_by_name (GTK_TEXT_BUFFER (buffer), j->data, &start, &end);
}
}
else
{
if (tokens[count][0] != '/')
{
tags = g_list_prepend (tags, tokens[count]);
}
else
{
GList *element = g_list_find_custom (tags, &(tokens[count][1]), (GCompareFunc) g_ascii_strcasecmp);
if (element)
{
tags = g_list_delete_link (tags, element);
}
}
}
}
gtk_text_buffer_end_user_action (GTK_TEXT_BUFFER (buffer));
g_strfreev (tokens);
}
static void about_textview_uri_update(GtkWidget *textview, gint x, gint y)
{
GtkTextBuffer *buffer;
GtkTextIter start_iter, end_iter;
gchar *uri = NULL;
gboolean same;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
if (x != -1 && y != -1) {
gint bx, by;
GtkTextIter iter;
GSList *tags;
GSList *cur;
gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(textview),
GTK_TEXT_WINDOW_WIDGET,
x, y, &bx, &by);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(textview),
&iter, bx, by);
tags = gtk_text_iter_get_tags(&iter);
for (cur = tags; cur != NULL; cur = cur->next) {
GtkTextTag *tag = cur->data;
char *name;
g_object_get(G_OBJECT(tag), "name", &name, NULL);
if (strcmp(name, "link") == 0
&& get_tag_range(&iter, tag, &start_iter, &end_iter)) {
uri = gtk_text_iter_get_text(&start_iter, &end_iter);
}
g_free(name);
if (uri) {
break;
}
}
g_slist_free(tags);
}
/* compare previous hovered link and this one
(here links must be unique in text buffer otherwise ClickableText structures should be
used as in textview.c) */
same = (uri != NULL && uri_hover != NULL
&& strcmp((char*)uri, (char*)uri_hover) == 0);
if (same == FALSE) {
GdkWindow *window;
if (uri_hover) {
gtk_text_buffer_remove_tag_by_name(buffer,
"link-hover",
&uri_hover_start_iter,
&uri_hover_end_iter);
}
uri_hover = uri;
if (uri) {
uri_hover_start_iter = start_iter;
uri_hover_end_iter = end_iter;
gtk_text_buffer_apply_tag_by_name(buffer,
"link-hover",
&start_iter,
&end_iter);
}
window = gtk_text_view_get_window(GTK_TEXT_VIEW(textview),
GTK_TEXT_WINDOW_TEXT);
if (!hand_cursor)
hand_cursor = gdk_cursor_new(GDK_HAND2);
if (!text_cursor)
text_cursor = gdk_cursor_new(GDK_XTERM);
gdk_window_set_cursor(window, uri ? hand_cursor : text_cursor);
}
}
void
empathy_chat_text_view_append_body (EmpathyChatTextView *view,
const gchar *body,
const gchar *tag)
{
EmpathyChatTextViewPriv *priv = GET_PRIV (view);
GtkTextIter start_iter, end_iter;
GtkTextMark *mark;
GtkTextIter iter;
GRegex *uri_regex;
GMatchInfo *match_info;
gboolean match;
gint last = 0;
gint s = 0, e = 0;
gchar *tmp;
priv = GET_PRIV (view);
gtk_text_buffer_get_end_iter (priv->buffer, &start_iter);
mark = gtk_text_buffer_create_mark (priv->buffer, NULL, &start_iter, TRUE);
uri_regex = empathy_uri_regex_dup_singleton ();
for (match = g_regex_match (uri_regex, body, 0, &match_info); match;
match = g_match_info_next (match_info, NULL)) {
if (!g_match_info_fetch_pos (match_info, 0, &s, &e))
continue;
if (s > last) {
tmp = empathy_substring (body, last, s);
gtk_text_buffer_get_end_iter (priv->buffer, &iter);
chat_text_view_insert_text_with_emoticons (view,
&iter,
tmp);
g_free (tmp);
}
tmp = empathy_substring (body, s, e);
gtk_text_buffer_get_end_iter (priv->buffer, &iter);
gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
&iter,
tmp,
-1,
EMPATHY_CHAT_TEXT_VIEW_TAG_LINK,
NULL);
g_free (tmp);
last = e;
}
g_match_info_free (match_info);
g_regex_unref (uri_regex);
if (last < strlen (body)) {
gtk_text_buffer_get_end_iter (priv->buffer, &iter);
chat_text_view_insert_text_with_emoticons (view,
&iter,
body + last);
}
gtk_text_buffer_get_end_iter (priv->buffer, &iter);
gtk_text_buffer_insert (priv->buffer, &iter, "\n", 1);
/* Apply the style to the inserted text. */
gtk_text_buffer_get_iter_at_mark (priv->buffer, &start_iter, mark);
gtk_text_buffer_get_end_iter (priv->buffer, &end_iter);
gtk_text_buffer_apply_tag_by_name (priv->buffer,
tag,
&start_iter,
&end_iter);
gtk_text_buffer_delete_mark (priv->buffer, mark);
}
static void gydp_ydp_commit_text(GydpYDPContext *context) {
GtkTextIter begin, end;
GtkTextMark *mark;
GydpYDPState *state;
/* skip if no text present in context */
if( !context->text->len )
return;
/* extract current code */
state = context->state->data;
/* convert text encoding (cp1250 or phonetic) */
gydp_convert_ydp_buffer(context->text->str, state->phonetic,
context->buffer->str);
/* get insert position and set mark */
gtk_text_buffer_get_end_iter(context->widget, &end);
mark = gtk_text_buffer_create_mark(context->widget, NULL, &end, TRUE);
/* insert text */
gtk_text_buffer_insert(context->widget, &end, context->buffer->str, -1);
/* extract begin iter and delete mark */
gtk_text_buffer_get_iter_at_mark(context->widget, &begin, mark);
gtk_text_buffer_delete_mark(context->widget, mark);
/*
* apply styles
*/
/* script */
switch( (GydpYDPScript)state->script ) {
case GYDP_YDP_SCRIPT_NORMAL:
gtk_text_buffer_apply_tag_by_name(context->widget,
GYDP_TAG_SCRIPT_NORMAL, &begin, &end);
break;
case GYDP_YDP_SCRIPT_SUPER:
gtk_text_buffer_apply_tag_by_name(context->widget,
GYDP_TAG_SCRIPT_SUPER, &begin, &end);
break;
case GYDP_YDP_SCRIPT_SUB:
gtk_text_buffer_apply_tag_by_name(context->widget,
GYDP_TAG_SCRIPT_SUB, &begin, &end);
break;
case GYDP_YDP_SCRIPT_NONE:
break;
default:
g_return_if_reached();
}
/* bold */
if( state->bold )
gtk_text_buffer_apply_tag_by_name(context->widget,
GYDP_TAG_BOLD, &begin, &end);
/* italic */
if( state->italic )
gtk_text_buffer_apply_tag_by_name(context->widget,
GYDP_TAG_ITALIC, &begin, &end);
/* align */
switch( (GydpYDPAlign)state->align ) {
case GYDP_YDP_ALIGN_CENTER:
gtk_text_buffer_apply_tag_by_name(context->widget,
GYDP_TAG_ALIGN_CENTER, &begin, &end);
break;
case GYDP_YDP_ALIGN_LEFT:
gtk_text_buffer_apply_tag_by_name(context->widget,
GYDP_TAG_ALIGN_LEFT, &begin, &end);
break;
case GYDP_YDP_ALIGN_NONE:
break;
default:
g_return_if_reached();
}
/* color */
switch( (GydpYDPColor)state->color ) {
case GYDP_YDP_COLOR_RED:
gtk_text_buffer_apply_tag_by_name(context->widget,
GYDP_TAG_COLOR_RED, &begin, &end);
break;
case GYDP_YDP_COLOR_GREEN:
gtk_text_buffer_apply_tag_by_name(context->widget,
GYDP_TAG_COLOR_GREEN, &begin, &end);
break;
case GYDP_YDP_COLOR_BLUE:
gtk_text_buffer_apply_tag_by_name(context->widget,
GYDP_TAG_COLOR_BLUE, &begin, &end);
break;
case GYDP_YDP_COLOR_NONE:
break;
default:
g_return_if_reached();
}
/* remove commited text */
g_string_truncate(context->text, 0);
}
void
load_file (const gchar *demoname,
const gchar *filename)
{
GtkTextBuffer *info_buffer, *source_buffer;
GtkTextIter start, end;
char *resource_filename;
GError *err = NULL;
int state = 0;
gboolean in_para = 0;
gchar **lines;
GBytes *bytes;
gint i;
if (!g_strcmp0 (current_file, filename))
return;
remove_data_tabs ();
add_data_tab (demoname);
g_free (current_file);
current_file = g_strdup (filename);
info_buffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (info_buffer, "title",
"font", "Sans 18",
"pixels-below-lines", 10,
NULL);
source_buffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (source_buffer, "comment",
"foreground", "DodgerBlue",
NULL);
gtk_text_buffer_create_tag (source_buffer, "type",
"foreground", "ForestGreen",
NULL);
gtk_text_buffer_create_tag (source_buffer, "string",
"foreground", "RosyBrown",
"weight", PANGO_WEIGHT_BOLD,
NULL);
gtk_text_buffer_create_tag (source_buffer, "control",
"foreground", "purple",
NULL);
gtk_text_buffer_create_tag (source_buffer, "preprocessor",
"style", PANGO_STYLE_OBLIQUE,
"foreground", "burlywood4",
NULL);
gtk_text_buffer_create_tag (source_buffer, "function",
"weight", PANGO_WEIGHT_BOLD,
"foreground", "DarkGoldenrod4",
NULL);
resource_filename = g_strconcat ("/sources/", filename, NULL);
bytes = g_resources_lookup_data (resource_filename, 0, &err);
g_free (resource_filename);
if (bytes == NULL)
{
g_warning ("Cannot open source for %s: %s\n", filename, err->message);
g_error_free (err);
return;
}
lines = g_strsplit (g_bytes_get_data (bytes, NULL), "\n", -1);
g_bytes_unref (bytes);
gtk_text_buffer_get_iter_at_offset (info_buffer, &start, 0);
for (i = 0; lines[i] != NULL; i++)
{
gchar *p;
gchar *q;
gchar *r;
/* Make sure \r is stripped at the end for the poor windows people */
lines[i] = g_strchomp (lines[i]);
p = lines[i];
switch (state)
{
case 0:
/* Reading title */
while (*p == '/' || *p == '*' || g_ascii_isspace (*p))
p++;
r = p;
while (*r != '\0')
{
while (*r != '/' && *r != ':' && *r != '\0')
r++;
if (*r == '/')
{
r++;
p = r;
}
if (r[0] == ':' && r[1] == ':')
*r = '\0';
}
q = p + strlen (p);
while (q > p && g_ascii_isspace (*(q - 1)))
q--;
if (q > p)
{
int len_chars = g_utf8_pointer_to_offset (p, q);
end = start;
g_assert (strlen (p) >= q - p);
gtk_text_buffer_insert (info_buffer, &end, p, q - p);
start = end;
gtk_text_iter_backward_chars (&start, len_chars);
gtk_text_buffer_apply_tag_by_name (info_buffer, "title", &start, &end);
start = end;
while (*p && *p != '\n') p++;
state++;
}
break;
case 1:
/* Reading body of info section */
while (g_ascii_isspace (*p))
p++;
if (*p == '*' && *(p + 1) == '/')
{
gtk_text_buffer_get_iter_at_offset (source_buffer, &start, 0);
state++;
}
else
{
int len;
while (*p == '*' || g_ascii_isspace (*p))
p++;
len = strlen (p);
while (g_ascii_isspace (*(p + len - 1)))
len--;
if (len > 0)
{
if (in_para)
gtk_text_buffer_insert (info_buffer, &start, " ", 1);
g_assert (strlen (p) >= len);
gtk_text_buffer_insert (info_buffer, &start, p, len);
in_para = 1;
}
else
{
gtk_text_buffer_insert (info_buffer, &start, "\n", 1);
in_para = 0;
}
}
break;
case 2:
/* Skipping blank lines */
while (g_ascii_isspace (*p))
p++;
if (*p)
{
p = lines[i];
state++;
/* Fall through */
}
else
break;
case 3:
/* Reading program body */
gtk_text_buffer_insert (source_buffer, &start, p, -1);
gtk_text_buffer_insert (source_buffer, &start, "\n", 1);
break;
}
}
fontify (source_buffer);
g_strfreev (lines);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (info_view), info_buffer);
g_object_unref (info_buffer);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (source_view), source_buffer);
g_object_unref (source_buffer);
}
void gif_receive_messages(void *server)
{
int server_sockfd = *(int *)server;
gifhdr_t *gifheader;
int rcv_status;
char *gifdata, *gifbuffer;
char PATHNAME[MAX_PATH_LENGTH];
pthread_t pthd = pthread_self();
while(1)
{
gifbuffer = (char *) malloc(BUFF_SIZE);
rcv_status = recv(server_sockfd, gifbuffer, BUFF_SIZE, 0);
if(rcv_status < 0) //发生错误
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO, strerror(errno));
gdk_threads_leave();
pthread_cancel(pthd); //非正常退出
}
else if(rcv_status == 0) //断开连接
{
contacts_chat_window_id_t *ptr;
GtkWidget *widget;
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO, "Server Disconnected");
gdk_threads_leave();
while(head != NULL) // freeing the allocated spaces for linked list
{
ptr = head;
head = head->next;
free(ptr);
}
gdk_threads_enter();
gtk_container_remove(GTK_CONTAINER(scrolledwindow1), tree);
widget = lookup_widget(gifmain, "butConnect");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuConnect");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuDisconect");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "butAdd");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuAdd");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuDelete");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "butConf");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "butOffline");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuOffline");
gtk_widget_set_sensitive(widget, FALSE);
gdk_threads_leave();
pthread_cancel(pthd);
}
gifheader = (gifhdr_t *) malloc(sizeof(gifhdr_t));
memcpy(gifheader, gifbuffer, HEADER_LENGTH);
if((gifheader->length) > 0)
{
gifdata = (char *) malloc(gifheader->length);
memcpy(gifdata, (gifbuffer + HEADER_LENGTH), gifheader->length);
}
else
{
gifdata = NULL;
}
switch(gifheader->type)
{
case GIF_ADDRLIST_MSG:
{
contacts_chat_window_id_t *ptr;
user_status_t *usrs;
int i, counter;
gdk_threads_enter();
GtkWidget *widget;
GtkTreeStore *store;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeIter parent_iter, child_iter;
GdkPixbuf *img;
GtkTreeSelection *select;
gdk_threads_leave();
if(gifheader->reserved == 1)
{
// removing the tree from the container for refresing
gdk_threads_enter();
gtk_container_remove(GTK_CONTAINER(scrolledwindow1), tree);
gdk_threads_leave();
while(head != NULL) // freeing the allocated spaces for linked list
{
ptr = head;
head = head->next;
free(ptr);
}
}
gdk_threads_enter();
widget = lookup_widget(gifmain, "butConnect");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuConnect");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuDisconect");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "butAdd");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuAdd");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuDelete");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "butConf");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "butOffline");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuOffline");
gtk_widget_set_sensitive(widget, TRUE);
gdk_threads_leave();
//creating a model
gdk_threads_enter();
store = gtk_tree_store_new(2, G_TYPE_STRING, GDK_TYPE_PIXBUF);
gdk_threads_leave();
//creating a view
gdk_threads_enter();
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gdk_threads_leave();
//adding the view to the scrolledwindow
gdk_threads_enter();
gtk_container_add(GTK_CONTAINER(scrolledwindow1), tree);
gdk_threads_leave();
//creating first column
gdk_threads_enter();
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes("Status", renderer, "pixbuf", STATUS_COLUMN_PIXMAP, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gdk_threads_leave();
//creating second column
gdk_threads_enter();
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Contacts", renderer, "text", CONTACTS_COLUMN_TEXT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gdk_threads_leave();
//Acquire a top-level iterator
gdk_threads_enter();
gtk_tree_store_append(store, &parent_iter, NULL);
if(gifheader->length != 0)
{
gtk_tree_store_set(store, &parent_iter, CONTACTS_COLUMN_TEXT, "Available", -1);
}
else
{
gtk_tree_store_set(store, &parent_iter, CONTACTS_COLUMN_TEXT, "Not Available", -1);
}
gdk_threads_leave();
i = counter = 0;
usrs = (user_status_t *) malloc(sizeof(user_status_t));
while(counter < (gifheader->length))
{
contacts_chat_window_id_t *ptr;
memcpy(usrs, (gifdata + (i * sizeof(user_status_t))), sizeof(user_status_t));
// setting the window id for each contacts and constructing a linked list
ptr = (contacts_chat_window_id_t *) malloc(sizeof(contacts_chat_window_id_t));
strcpy(ptr->contacts_name, usrs->loginid);
ptr->window_id = i;
ptr->window_open = 0;
if(head == NULL)
{
head = ptr;
ptr->next = NULL;
}
else
{
ptr->next = head;
head = ptr;
}
// setting the status image for online clients and offline clients
gdk_threads_enter();
if(usrs->status == 1)
{
get_full_path_name(PATHNAME,"ok.png",1,"client/pixmaps");
img = gdk_pixbuf_new_from_file(PATHNAME, NULL);
}
else
{
get_full_path_name(PATHNAME,"kill.png",1,"client/pixmaps");
img = gdk_pixbuf_new_from_file(PATHNAME, NULL);
}
gdk_threads_leave();
//Acquire a child iterator
gdk_threads_enter();
gtk_tree_store_append(store, &child_iter, &parent_iter);
gtk_tree_store_set(store, &child_iter, CONTACTS_COLUMN_TEXT, usrs->loginid, STATUS_COLUMN_PIXMAP, img, -1);
gdk_threads_leave();
i++;
counter = i * sizeof(user_status_t);
}
free(usrs);
gdk_threads_enter();
gtk_tree_view_expand_all(GTK_TREE_VIEW(tree));
gtk_widget_show(tree);
gdk_threads_leave();
// signal handling for "changed" event
gdk_threads_enter();
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(gif_call_client_for_chat), NULL);
gdk_threads_leave();
if((gifheader->length) != 0)
{
free(gifdata);
}
free(gifheader);
free(gifbuffer);
break;
}
case GIF_CHAT_MSG:
{
contacts_chat_window_id_t *ptr;
GtkWidget *display_text;
GtkTextBuffer *buff;
GtkTextIter start, end;
int line_no;
for(ptr = head; ptr != NULL; ptr = ptr->next)
{
if((strcmp(ptr->contacts_name, gifheader->sender)) == 0)
break;
else
continue;
}
if(ptr->window_open == 0)
{
GtkWidget *widget;
GtkTextBuffer *buff;
ptr->window_open = 1; // since the window is gonna be opened
gdk_threads_enter();
chat_window[ptr->window_id] = create_Chat();
widget =
lookup_widget(chat_window[ptr->window_id], "entInput");
gtk_window_set_focus(GTK_WINDOW
(chat_window[ptr->window_id]), widget);
gtk_window_set_title(GTK_WINDOW
(chat_window[ptr->window_id]),
gifheader->sender);
gtk_widget_show(chat_window[ptr->window_id]);
gdk_threads_leave();
// creating tags(foreground color) for the buffer
gdk_threads_enter();
widget =
lookup_widget(chat_window[ptr->window_id], "txtDisplay");
buff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
gtk_text_buffer_create_tag(buff, "red_foreground",
"foreground", "red", NULL);
gtk_text_buffer_create_tag(buff, "blue_foreground",
"foreground", "blue", NULL);
gdk_threads_leave();
}
gdk_threads_enter();
display_text =
lookup_widget(chat_window[ptr->window_id], "txtDisplay");
buff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(display_text));
gtk_text_buffer_insert_at_cursor(buff, gifheader->sender, -1);
gtk_text_buffer_insert_at_cursor(buff, " : ", -1);
gtk_text_buffer_insert_at_cursor(buff, gifdata, -1);
gdk_threads_leave();
// setting the color(blue) for client's name in the display text box
gdk_threads_enter();
line_no = gtk_text_buffer_get_line_count(buff);
gtk_text_buffer_get_iter_at_line(buff, &start, line_no);
gtk_text_buffer_get_iter_at_line_offset(buff, &end,
line_no,
strlen
(gifheader->sender));
gtk_text_buffer_apply_tag_by_name(buff,
"blue_foreground",
&start, &end);
gtk_text_buffer_insert_at_cursor(buff, "\n", -1);
gdk_threads_leave();
if((gifheader->length) != 0)
free(gifdata);
free(gifheader);
free(gifbuffer);
break;
}
case GIF_SUCCESS_N_ERROR_MSG:
{
switch(gifheader->reserved)
{
case GIF_ERROR_LOGIN_INCORRECT:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO, "Login Incorrect");
gdk_threads_leave();
break;
}
case GIF_SUCCESS_ADD_CONTACTS:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO, "Your new contact has been successfully added");
gdk_threads_leave();
break;
}
case GIF_ERROR_ADD_CONTACTS:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO,"The contact id you entered does not belong to a gchat user");
gdk_threads_leave();
break;
}
case GIF_SUCCESS_DELETE_CONTACTS:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO,"Deleted. See the new list after you re-login");
gdk_threads_leave();
break;
}
case GIF_ERROR_DELETE_CONTACTS_NOT_A_CONTACT:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO,"1. The id you entered is not in your contact list");
gdk_threads_leave();
break;
}
case GIF_ERROR_DELETE_CONTACTS_NOT_A_MEMBER:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO,"2. The id you entered is not in your contact list");
gdk_threads_leave();
break;
}
}
if((gifheader->length) != 0)
{
free(gifdata);
}
free(gifheader);
free(gifbuffer);
break;
}
case GIF_OFFLINE_MSG:
{
int counter;
char *message;
offline_msgs_send_t *omsgs_se;
gdk_threads_enter();
GtkWidget *widget;
GtkListStore *store;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeIter iter;
GdkPixbuf *img;
gdk_threads_leave();
if(gifheader->reserved == 1) //刷新联系人在线状态
{
offline_messages_count = 0;
//creating a model
gdk_threads_enter();
store = gtk_list_store_new(OFFLINE_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
offline_temp_store = store;
gdk_threads_leave();
//creating a view
gdk_threads_enter();
offline_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gdk_threads_leave();
//adding the view to the scrolledwindow
gdk_threads_enter();
gtk_container_add(GTK_CONTAINER(scrolledwindow4), offline_tree);
gdk_threads_leave();
//creating first column
gdk_threads_enter();
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes("New/Old", renderer, "pixbuf", OFFLINE_NEW_PIXMAP, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column);
gdk_threads_leave();
//creating second column
gdk_threads_enter();
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "foreground", "red", NULL);
column = gtk_tree_view_column_new_with_attributes("From", renderer, "text", OFFLINE_SENDER_TEXT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column);
gdk_threads_leave();
//creating third column
gdk_threads_enter();
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "foreground", "dark green", NULL);
column = gtk_tree_view_column_new_with_attributes("Date & Time", renderer, "text",OFFLINE_DATESERIAL_TEXT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column);
gdk_threads_leave();
//creating fourth column
gdk_threads_enter();
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Message", renderer, "text", OFFLINE_MSG_TEXT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column);
gdk_threads_leave();
}
else
{
_DEBUG("error: condition");
pthread_cancel(pthd);
return;
}
counter = 0;
omsgs_se =
(offline_msgs_send_t *) malloc(sizeof(offline_msgs_send_t));
while(counter < (gifheader->length))
{
gdk_threads_enter();
widget = lookup_widget(offline, "butOfflineDelete");
gtk_widget_set_sensitive(widget, TRUE);
gdk_threads_leave();
memcpy(omsgs_se, (gifdata + counter),
sizeof(offline_msgs_send_t));
counter = counter + sizeof(offline_msgs_send_t);
message = (char *) malloc(omsgs_se->length);
strncpy(message, (gifdata + counter), omsgs_se->length);
counter = counter + (omsgs_se->length);
// setting the status image for online clients and offline clients
gdk_threads_enter();
if(omsgs_se->new == 1)
{
get_full_path_name(PATHNAME,"ok.png",1,"client/pixmaps");
img = gdk_pixbuf_new_from_file(PATHNAME, NULL);
}
else
{
get_full_path_name(PATHNAME,"kill.png",1,"client/pixmaps");
img = gdk_pixbuf_new_from_file(PATHNAME, NULL);
}
gdk_threads_leave();
//Acquire a child iterator
gdk_threads_enter();
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
OFFLINE_NEW_PIXMAP, img,
OFFLINE_SENDER_TEXT,
omsgs_se->sender,
OFFLINE_DATESERIAL_TEXT,
omsgs_se->dateserial,
OFFLINE_MSG_TEXT, message, -1);
gdk_threads_leave();
offline_messages_count++;
free(message);
}
free(omsgs_se);
gdk_threads_enter();
gtk_widget_show(offline_tree);
gdk_threads_leave();
if(gifheader->reserved == 1)
{
GtkTreeSelection *select;
// signal handling for "changed" event
gdk_threads_enter();
select =
gtk_tree_view_get_selection(GTK_TREE_VIEW(offline_tree));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select), "changed",
G_CALLBACK
(gif_select_offline_messages), NULL);
gdk_threads_leave();
}
if((gifheader->length) != 0)
free(gifdata);
free(gifheader);
free(gifbuffer);
break;
}
}
}
void
load_file (const gchar *filename)
{
FILE *file;
GtkTextIter start, end;
char *full_filename;
GError *err = NULL;
GString *buffer = g_string_new (NULL);
int state = 0;
gboolean in_para = 0;
if (current_file && !strcmp (current_file, filename))
{
g_string_free (buffer, TRUE);
return;
}
g_free (current_file);
current_file = g_strdup (filename);
gtk_text_buffer_get_bounds (info_buffer, &start, &end);
gtk_text_buffer_delete (info_buffer, &start, &end);
gtk_text_buffer_get_bounds (source_buffer, &start, &end);
gtk_text_buffer_delete (source_buffer, &start, &end);
full_filename = demo_find_file (filename, &err);
if (!full_filename)
{
g_warning ("%s", err->message);
g_error_free (err);
return;
}
file = g_fopen (full_filename, "r");
if (!file)
g_warning ("Cannot open %s: %s\n", full_filename, g_strerror (errno));
g_free (full_filename);
if (!file)
return;
gtk_text_buffer_get_iter_at_offset (info_buffer, &start, 0);
while (read_line (file, buffer))
{
gchar *p = buffer->str;
gchar *q;
gchar *r;
switch (state)
{
case 0:
/* Reading title */
while (*p == '/' || *p == '*' || g_ascii_isspace (*p))
p++;
r = p;
while (*r != '/' && strlen (r))
r++;
if (strlen (r) > 0)
p = r + 1;
q = p + strlen (p);
while (q > p && g_ascii_isspace (*(q - 1)))
q--;
if (q > p)
{
int len_chars = g_utf8_pointer_to_offset (p, q);
end = start;
g_assert (strlen (p) >= q - p);
gtk_text_buffer_insert (info_buffer, &end, p, q - p);
start = end;
gtk_text_iter_backward_chars (&start, len_chars);
gtk_text_buffer_apply_tag_by_name (info_buffer, "title", &start, &end);
start = end;
state++;
}
break;
case 1:
/* Reading body of info section */
while (g_ascii_isspace (*p))
p++;
if (*p == '*' && *(p + 1) == '/')
{
gtk_text_buffer_get_iter_at_offset (source_buffer, &start, 0);
state++;
}
else
{
int len;
while (*p == '*' || g_ascii_isspace (*p))
p++;
len = strlen (p);
while (g_ascii_isspace (*(p + len - 1)))
len--;
if (len > 0)
{
if (in_para)
gtk_text_buffer_insert (info_buffer, &start, " ", 1);
g_assert (strlen (p) >= len);
gtk_text_buffer_insert (info_buffer, &start, p, len);
in_para = 1;
}
else
{
gtk_text_buffer_insert (info_buffer, &start, "\n", 1);
in_para = 0;
}
}
break;
case 2:
/* Skipping blank lines */
while (g_ascii_isspace (*p))
p++;
if (*p)
{
p = buffer->str;
state++;
/* Fall through */
}
else
break;
case 3:
/* Reading program body */
gtk_text_buffer_insert (source_buffer, &start, p, -1);
gtk_text_buffer_insert (source_buffer, &start, "\n", 1);
break;
}
}
fclose (file);
fontify ();
g_string_free (buffer, TRUE);
}
static void cb_button_parse(GtkButton *button, gpointer user_data)
{
int char_count = gtk_text_buffer_get_char_count (buffer);
int i;
load_ts_phrase();
char_count = gtk_text_buffer_get_char_count (buffer);
all_wrap();
dbg("parse char_count:%d\n", char_count);
for(i=0; i < char_count; ) {
int len;
for(len=MAX_PHRASE_LEN; len>=2 ; len--) {
u_char txt[MAX_PHRASE_LEN*CH_SZ + 1];
int txtN=0, u8chN=0;
gboolean b_ignore = FALSE;
int k;
for(k=0; k<len && i+k < char_count; k++) {
GtkTextIter start,end;
gtk_text_buffer_get_iter_at_offset (buffer, &start, i+k);
gtk_text_buffer_get_iter_at_offset (buffer, &end, i+k+1);
char *utf8 = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
if (!(utf8[0] & 128))
b_ignore = TRUE;
int wn = strlen(utf8);
memcpy(&txt[txtN], utf8, wn);
txtN+= wn;
u8chN++;
}
if (b_ignore || txtN < 2)
continue;
txt[txtN] = 0;
// dbg("try len:%d txtN:%d %s\n", len, txtN, txt);
if (!pharse_search((char *)txt))
continue;
// dbg("match .... %d %d\n", i, len);
GtkTextIter mstart,mend;
gtk_text_buffer_get_iter_at_offset (buffer, &mstart, i);
gtk_text_buffer_get_iter_at_offset (buffer, &mend, i+len);
gtk_text_buffer_apply_tag_by_name (buffer, "blue_background", &mstart, &mend);
#if 1
// why do I have to repeat this
gtk_text_buffer_get_iter_at_offset (buffer, &mstart, i);
gtk_text_buffer_get_iter_at_offset (buffer, &mend, i+len);
gtk_text_buffer_apply_tag_by_name (buffer, "blue_background", &mstart, &mend);
#endif
gdk_flush();
}
i+=len;
}
}
static gint document_replace_real(GtkWidget *textview)
{
GtkTextIter iter, match_start, match_end, rep_start;
GtkTextMark *mark_init = NULL;
gboolean res;
gint num = 0, offset;
GtkWidget *q_dialog = NULL;
GtkSourceSearchFlags search_flags = GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_TEXT_ONLY;
GtkTextBuffer *textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
if (!match_case)
search_flags = search_flags | GTK_SOURCE_SEARCH_CASE_INSENSITIVE;
if (replace_all) {
gtk_text_buffer_get_iter_at_mark(textbuffer,
&iter, gtk_text_buffer_get_insert(textbuffer));
mark_init = gtk_text_buffer_create_mark(textbuffer, NULL, &iter, FALSE);
gtk_text_buffer_get_start_iter(textbuffer, &iter);
gtk_text_buffer_get_end_iter(textbuffer, &match_end);
// gtk_text_buffer_remove_tag_by_name(textbuffer,
// "replaced", &iter, &match_end);
gtk_text_buffer_remove_all_tags(textbuffer,
&iter, &match_end);
} else {
hlight_searched_strings(textbuffer, string_find);
hlight_toggle_searched(textbuffer);
}
do {
if (replace_all) {
res = gtk_source_iter_forward_search(
&iter, string_find, search_flags, &match_start, &match_end, NULL);
if (res) {
gtk_text_buffer_place_cursor(textbuffer, &match_start);
gtk_text_buffer_move_mark_by_name(textbuffer, "insert", &match_end);
gtk_text_buffer_get_iter_at_mark(
textbuffer, &iter, gtk_text_buffer_get_insert(textbuffer));
}
}
else
// res = document_search_real(textview, 0);
res = document_search_real(textview, 2);
if (res) {
if (!replace_all) {
if (num == 0 && q_dialog == NULL)
q_dialog = create_dialog_message_question(
gtk_widget_get_toplevel(textview), _("Replace?"));
#if GTK_CHECK_VERSION(2, 10, 0)
GtkTextIter ins,bou;
gtk_text_buffer_get_selection_bounds(textbuffer, &ins, &bou);
#endif
switch (gtk_dialog_run(GTK_DIALOG(q_dialog))) {
case GTK_RESPONSE_YES:
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_text_buffer_select_range(textbuffer, &ins, &bou);
#endif
break;
case GTK_RESPONSE_NO:
continue;
// case GTK_RESPONSE_CANCEL:
default:
res = 0;
if (num == 0)
num = -1;
continue;
}
}
gtk_text_buffer_delete_selection(textbuffer, TRUE, TRUE);
if (strlen(string_replace)) {
gtk_text_buffer_get_iter_at_mark(
textbuffer, &rep_start,
gtk_text_buffer_get_insert(textbuffer));
offset = gtk_text_iter_get_offset(&rep_start);
undo_set_sequency(TRUE);
g_signal_emit_by_name(G_OBJECT(textbuffer),
"begin-user-action");
gtk_text_buffer_insert_at_cursor(textbuffer,
string_replace, strlen(string_replace));
g_signal_emit_by_name(G_OBJECT(textbuffer),
"end-user-action");
gtk_text_buffer_get_iter_at_mark(
textbuffer, &iter,
gtk_text_buffer_get_insert(textbuffer));
gtk_text_buffer_get_iter_at_offset(textbuffer,
&rep_start, offset);
gtk_text_buffer_apply_tag_by_name(textbuffer,
"replaced", &rep_start, &iter);
} else
gtk_text_buffer_get_iter_at_mark(
textbuffer, &iter,
gtk_text_buffer_get_insert(textbuffer));
num++;
/* if (replace_all)
undo_set_sequency(TRUE);
else
undo_set_sequency(FALSE);*/
undo_set_sequency(replace_all);
}
} while (res);
if (!hlight_check_searched())
hlight_toggle_searched(textbuffer);
if (q_dialog)
gtk_widget_destroy(q_dialog);
/* if (strlen(string_replace)) {
replace_mode = TRUE;
hlight_searched_strings(textbuffer, string_replace);
} */
if (replace_all) {
gtk_text_buffer_get_iter_at_mark(textbuffer, &iter, mark_init);
gtk_text_buffer_place_cursor(textbuffer, &iter);
run_dialog_message(gtk_widget_get_toplevel(textview), GTK_MESSAGE_INFO,
_("%d strings replaced"), num);
undo_set_sequency(FALSE);
}
return num;
}
static void
html_output_tag(struct html_output *output, const struct array *tag)
#if GTK_CHECK_VERSION(2,0,0)
{
static struct {
gboolean initialized;
short_string_t centre_line, nbsp, bullet, soft_hyphen, em_dash;
short_string_t list_item_prefix;
} special;
struct html_context *ctx;
const gchar *style, *text, *attr;
enum html_tag id;
gboolean closing;
GtkTextBuffer *buffer;
if (!special.initialized) {
special.initialized = TRUE;
special.bullet = utf8_char(0x2022);
special.centre_line = utf8_char(0xFE4E);
special.soft_hyphen = utf8_char(0x00AD);
special.nbsp = utf8_char(0x00A0);
special.em_dash = utf8_char(0x2014);
concat_strings(special.list_item_prefix.str,
sizeof special.list_item_prefix.str,
" ", special.bullet.str, " ", (void *) 0);
}
style = NULL;
text = NULL;
attr = NULL;
closing = html_tag_is_closing(tag);
ctx = html_output_get_udata(output);
id = html_parse_tag(tag);
buffer = gtk_text_view_get_buffer(ctx->html_view->widget);
switch (id) {
case HTML_TAG_BODY:
style = STYLE_TAG_WORD_WRAP;
break;
case HTML_TAG_A:
if (closing) {
if (ctx->start[id] && ctx->href) {
GtkTextIter start, end;
GtkTextTag *anchor;
anchor = gtk_text_buffer_create_tag(buffer, NULL, (void *) 0);
g_object_set_data(G_OBJECT(anchor), "href",
deconstify_gchar(ctx->href));
gtk_text_buffer_get_iter_at_mark(buffer,
&start, ctx->start[id]);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_apply_tag(buffer, anchor, &start, &end);
style = get_style_for_href(ctx->href);
ctx->href = NULL;
}
} else {
struct array value;
value = html_get_attribute(tag, HTML_ATTR_HREF);
if (value.data && value.size > 0) {
GtkTextIter iter;
ctx->href = g_strndup(value.data, value.size);
ctx->html_view->to_free = g_slist_prepend(
ctx->html_view->to_free, deconstify_gchar(ctx->href));
gtk_text_buffer_get_end_iter(buffer, &iter);
ctx->start[id] = gtk_text_buffer_create_mark(buffer,
NULL, &iter, TRUE);
g_object_set_data(G_OBJECT(ctx->start[id]), "href",
deconstify_gchar(ctx->href));
}
value = html_get_attribute(tag, HTML_ATTR_NAME);
if (value.data && value.size > 0) {
GtkTextTagTable *table;
gchar name[256];
size_t n;
n = sizeof name - 2;
n = MIN(value.size, n);
name[0] = '#';
memcpy(&name[1], value.data, n);
name[n + 1] = '\0';
table = gtk_text_buffer_get_tag_table(buffer);
if (NULL == gtk_text_tag_table_lookup(table, name)) {
GtkTextIter iter;
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_buffer_create_mark(buffer, name, &iter, TRUE);
}
}
}
break;
case HTML_TAG_B:
case HTML_TAG_STRONG:
case HTML_TAG_THEAD:
style = STYLE_TAG_BOLD;
break;
case HTML_TAG_TH:
if (closing)
text = "\t";
break;
case HTML_TAG_EM:
style = STYLE_TAG_UNDERLINE;
break;
case HTML_TAG_I:
case HTML_TAG_Q:
style = STYLE_TAG_ITALIC;
break;
case HTML_TAG_IMG:
if (!closing) {
struct array value;
static gchar alt[1024];
value = html_get_attribute(tag, HTML_ATTR_ALT);
if (value.data) {
gm_snprintf(alt, sizeof alt, "\n[image alt=\"%.*s\"]\n",
(int)value.size, value.data);
text = alt;
}
value = html_get_attribute(tag, HTML_ATTR_SRC);
if (value.data) {
GdkPixbuf *pixbuf;
gchar *filename;
GtkTextIter iter;
filename = h_strndup(value.data, value.size);
pixbuf = gdk_pixbuf_new_from_file(filename, NULL);
if (pixbuf) {
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_buffer_insert_pixbuf(buffer, &iter, pixbuf);
} else {
static gchar msg[1024];
gm_snprintf(msg, sizeof msg,
"\n[Image not found (\"%s\")]\n", filename);
text = msg;
}
HFREE_NULL(filename);
}
if (!text) {
text = "\n[image]\n";
}
}
attr = STYLE_TAG_BOLD;
break;
case HTML_TAG_TD:
if (closing)
text = "\t";
break;
case HTML_TAG_P:
case HTML_TAG_DIV:
text = closing ? "\n\n" : special.soft_hyphen.str;
break;
case HTML_TAG_DL:
case HTML_TAG_TABLE:
case HTML_TAG_TR:
case HTML_TAG_UL:
case HTML_TAG_OL:
case HTML_TAG_BR:
text = "\n";
break;
case HTML_TAG_DT:
case HTML_TAG_LI:
if (closing) {
GtkTextIter start, end;
GtkTextTag *margin;
PangoLayout *pl;
gint width;
pl = pango_layout_new(gtk_widget_get_pango_context(
GTK_WIDGET(ctx->html_view->widget)));
pango_layout_set_text(pl, special.list_item_prefix.str, -1);
pango_layout_get_pixel_size(pl, &width, NULL);
g_object_unref(G_OBJECT(pl));
margin = gtk_text_buffer_create_tag(buffer, NULL,
"left-margin", width * 2,
"left-margin-set", TRUE,
(void *) 0);
gtk_text_buffer_get_iter_at_mark(buffer, &start, ctx->start[id]);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_apply_tag(buffer, margin, &start, &end);
} else {
GtkTextIter iter;
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_buffer_insert(buffer, &iter, "\n", (-1));
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,
special.list_item_prefix.str, (-1),
STYLE_TAG_BOLD, (void *) 0);
gtk_text_buffer_get_end_iter(buffer, &iter);
ctx->start[id] = gtk_text_buffer_create_mark(buffer, NULL,
&iter, TRUE);
}
break;
case HTML_TAG_CODE:
case HTML_TAG_KBD:
case HTML_TAG_PRE:
case HTML_TAG_TT:
style = STYLE_TAG_MONOSPACE;
break;
case HTML_TAG_H1:
style = STYLE_TAG_HEADING_1;
text = closing ? "\n\n" : "\n";
break;
case HTML_TAG_H2:
style = STYLE_TAG_HEADING_2;
text = closing ? "\n\n" : "\n";
break;
case HTML_TAG_H3:
style = STYLE_TAG_HEADING_3;
text = closing ? "\n\n" : "\n";
break;
case HTML_TAG_H4:
case HTML_TAG_H5:
case HTML_TAG_H6:
style = STYLE_TAG_HEADING_4;
text = closing ? "\n\n" : "\n";
break;
case HTML_TAG_TITLE:
if (closing) {
if (ctx->title) {
GtkWidget *window;
window = gtk_widget_get_toplevel(
GTK_WIDGET(ctx->html_view->widget));
gtk_window_set_title(GTK_WINDOW(window), str_2c(ctx->title));
str_destroy_null(&ctx->title);
}
} else {
ctx->title = str_new(0);
}
break;
case HTML_TAG_HR:
{
GtkTextIter iter;
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,
"\n \n", (-1),
STYLE_TAG_CENTER, STYLE_TAG_UNDERLINE, (void *) 0);
}
text = "\n";
break;
case HTML_TAG_COMMENT:
#if 0
{
GtkTextIter iter;
/* Comments can be made visible this way */
ctx->start[id] = gtk_text_buffer_create_mark(buffer, NULL,
&iter, TRUE);
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,
tag->data, tag->size, STYLE_TAG_ITALIC, (void *) 0);
}
closing = TRUE;
text = "\n";
#endif
break;
case HTML_TAG_HTML:
if (closing) {
if (ctx->lang && ctx->start[id]) {
GtkTextIter start, end;
GtkTextTag *lang;
lang = gtk_text_buffer_create_tag(buffer, NULL,
"language", ctx->lang,
"language-set", TRUE,
(void *) 0);
gtk_text_buffer_get_iter_at_mark(buffer,
&start, ctx->start[id]);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_apply_tag(buffer, lang, &start, &end);
ctx->lang = NULL;
}
} else {
struct array value;
value = html_get_attribute(tag, HTML_ATTR_LANG);
if (value.data && value.size > 0) {
GtkTextIter iter;
ctx->lang = g_strndup(value.data, value.size);
ctx->html_view->to_free = g_slist_prepend(
ctx->html_view->to_free, deconstify_gchar(ctx->lang));
gtk_text_buffer_get_end_iter(buffer, &iter);
ctx->start[id] = gtk_text_buffer_create_mark(buffer,
NULL, &iter, TRUE);
}
}
case HTML_TAG_HEAD:
case HTML_TAG_META:
case HTML_TAG_SPAN:
case HTML_TAG_COL:
case HTML_TAG_DD:
case HTML_TAG_TBODY:
case HTML_TAG_DOCTYPE:
case HTML_TAG_UNKNOWN:
break;
case NUM_HTML_TAG:
g_assert_not_reached();
}
if (style) {
if (closing) {
if (ctx->start[id]) {
GtkTextIter start, end;
gtk_text_buffer_get_iter_at_mark(buffer,
&start, ctx->start[id]);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_apply_tag_by_name(buffer, style, &start, &end);
ctx->start[id] = NULL;
}
} else {
GtkTextIter iter;
gtk_text_buffer_get_end_iter(buffer, &iter);
ctx->start[id] = gtk_text_buffer_create_mark(buffer,
NULL, &iter, TRUE);
}
}
if (text) {
GtkTextIter iter;
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,
text, (-1), attr, (void *) 0);
}
}
static void
theme_boxes_maybe_append_header (EmpathyThemeBoxes *theme,
EmpathyMessage *msg)
{
EmpathyChatTextView *view = EMPATHY_CHAT_TEXT_VIEW (theme);
EmpathyThemeBoxesPriv*priv = GET_PRIV (theme);
EmpathyContact *contact;
EmpathyContact *last_contact;
GdkPixbuf *avatar = NULL;
GtkTextBuffer *buffer;
const gchar *name;
GtkTextIter iter;
GtkWidget *label1, *label2;
GtkTextChildAnchor *anchor;
GtkWidget *box;
gchar *str;
time_t time_;
gchar *tmp;
GtkTextIter start;
gboolean color_set;
GtkTextTagTable *table;
GtkTextTag *tag;
GString *str_obj;
gboolean consecutive;
contact = empathy_message_get_sender (msg);
name = empathy_contact_get_alias (contact);
last_contact = empathy_chat_text_view_get_last_contact (view);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (theme));
time_ = empathy_message_get_timestamp (msg);
consecutive = (time_ - empathy_chat_text_view_get_last_timestamp (view)
< MESSAGE_JOIN_PERIOD);
DEBUG ("Maybe add fancy header");
/* Only insert a header if
* - the previously inserted block is not the same as this one.
* - the delay between two messages is lower then MESSAGE_JOIN_PERIOD
*/
if (empathy_contact_equal (last_contact, contact) && consecutive) {
return;
}
empathy_chat_text_view_append_spacing (view);
/* Insert header line */
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_insert_with_tags_by_name (buffer,
&iter,
"\n",
-1,
EMPATHY_THEME_BOXES_TAG_HEADER_LINE,
NULL);
gtk_text_buffer_get_end_iter (buffer, &iter);
anchor = gtk_text_buffer_create_child_anchor (buffer, &iter);
/* Create a hbox for the header and resize it when the view allocation
* changes */
box = gtk_hbox_new (FALSE, 0);
g_signal_connect_object (view, "size-allocate",
G_CALLBACK (table_size_allocate_cb),
box, 0);
/* Add avatar to the box if needed */
if (priv->show_avatars) {
avatar = theme_boxes_get_avatar_pixbuf_with_cache (contact);
if (avatar) {
GtkWidget *image;
image = gtk_image_new_from_pixbuf (avatar);
gtk_box_pack_start (GTK_BOX (box), image,
FALSE, TRUE, 2);
}
}
/* Add contact alias */
str = g_markup_printf_escaped ("<b>%s</b>", name);
label1 = g_object_new (GTK_TYPE_LABEL,
"label", str,
"use-markup", TRUE,
"xalign", 0.0,
NULL);
g_free (str);
/* Add the message receive time */
tmp = empathy_time_to_string_local (time_,
EMPATHY_TIME_FORMAT_DISPLAY_SHORT);
str = g_strdup_printf ("<i>%s</i>", tmp);
label2 = g_object_new (GTK_TYPE_LABEL,
"label", str,
"use-markup", TRUE,
"xalign", 1.0,
NULL);
str_obj = g_string_new ("\n- ");
g_string_append (str_obj, name);
g_string_append (str_obj, ", ");
g_string_append (str_obj, tmp);
g_string_append (str_obj, " -");
g_free (tmp);
g_free (str);
/* Set foreground color of labels to the same color than the header tag. */
table = gtk_text_buffer_get_tag_table (buffer);
tag = gtk_text_tag_table_lookup (table, EMPATHY_THEME_BOXES_TAG_HEADER);
g_object_get (tag, "foreground-set", &color_set, NULL);
if (color_set) {
GdkColor *color;
g_object_get (tag, "foreground-gdk", &color, NULL);
gtk_widget_modify_fg (label1, GTK_STATE_NORMAL, color);
gtk_widget_modify_fg (label2, GTK_STATE_NORMAL, color);
gdk_color_free (color);
}
/* Pack labels into the box */
gtk_misc_set_alignment (GTK_MISC (label1), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC (label2), 1.0, 0.5);
gtk_box_pack_start (GTK_BOX (box), label1, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), label2, TRUE, TRUE, 0);
/* Add the header box to the text view */
g_object_set_data_full (G_OBJECT (box),
"str_obj",
g_string_free (str_obj, FALSE),
g_free);
gtk_text_view_add_child_at_anchor (GTK_TEXT_VIEW (view),
box,
anchor);
gtk_widget_show_all (box);
/* Insert a header line */
gtk_text_buffer_get_end_iter (buffer, &iter);
start = iter;
gtk_text_iter_backward_char (&start);
gtk_text_buffer_apply_tag_by_name (buffer,
EMPATHY_THEME_BOXES_TAG_HEADER,
&start, &iter);
gtk_text_buffer_insert_with_tags_by_name (buffer,
&iter,
"\n",
-1,
EMPATHY_THEME_BOXES_TAG_HEADER,
NULL);
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_insert_with_tags_by_name (buffer,
&iter,
"\n",
-1,
EMPATHY_THEME_BOXES_TAG_HEADER_LINE,
NULL);
}
static GtkTextChildAnchor *
insert_text (GtkTextBuffer *buffer)
{
GtkTextIter iter;
GtkTextIter start, end;
GtkTextMark *para_start;
GtkTextChildAnchor *anchor;
/* get start of buffer; each insertion will revalidate the
* iterator to point to just after the inserted text.
*/
gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
gtk_text_buffer_insert (buffer, &iter,
"This test shows text view rendering some text with rgba colors.\n\n", -1);
gtk_text_buffer_insert (buffer, &iter, "For example, you can have ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"italic translucent blue text", -1,
"italic",
"semi_blue_foreground",
"x-large",
NULL);
gtk_text_buffer_insert (buffer, &iter, ", or ", -1);
gtk_text_buffer_insert (buffer, &iter, ", ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"bold text with translucent red background", -1,
"bold",
"semi_red_background",
"x-large",
NULL);
gtk_text_buffer_insert (buffer, &iter, ".\n\n", -1);
anchor = gtk_text_buffer_create_child_anchor (buffer, &iter);
/* Store the beginning of the other paragraph */
para_start = gtk_text_buffer_create_mark (buffer, "para_start", &iter, TRUE);
gtk_text_buffer_insert (buffer, &iter,
"Paragraph background colors can also be set with rgba color values .\n", -1);
gtk_text_buffer_insert (buffer, &iter, "For instance, you can have ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"bold translucent blue text", -1,
"bold",
"semi_blue_foreground",
"x-large",
NULL);
gtk_text_buffer_insert (buffer, &iter, ", or ", -1);
gtk_text_buffer_insert (buffer, &iter, ", ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"italic text with translucent red background", -1,
"italic",
"semi_red_background",
"x-large",
NULL);
gtk_text_buffer_insert (buffer, &iter, " all rendered onto a translucent orange paragraph background.\n", -1);
gtk_text_buffer_get_bounds (buffer, &start, &end);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, para_start);
gtk_text_buffer_apply_tag_by_name (buffer, "semi_orange_paragraph_background", &iter, &end);
/* Apply word_wrap tag to whole buffer */
gtk_text_buffer_get_bounds (buffer, &start, &end);
gtk_text_buffer_apply_tag_by_name (buffer, "word_wrap", &start, &end);
return anchor;
}
void gglk_do_styles(GtkMenuItem *unused_menuitem,
gpointer unused_data)
{
static GtkWidget *dialog_styles;
GtkTreeView *tree;
GtkTreeStore *store;
GtkTreeSelection *select;
GtkTreeIter parent_iter, iter;
int i;
if(dialog_styles) {
gtk_window_present(GTK_WINDOW(dialog_styles));
return;
}
dialog_styles = create_dialog_styles();
g_signal_connect(dialog_styles, "destroy",
G_CALLBACK(gtk_widget_destroyed),
&dialog_styles);
g_signal_connect(dialog_styles, "response",
G_CALLBACK(gglk_style_response),
NULL);
if(!gglk_style_changeset) {
gglk_style_changeset = gconf_change_set_new();
} else {
gconf_change_set_clear(gglk_style_changeset);
}
{
GtkTextBuffer *buffer;
GtkTextIter text_start, text_end;
buffer = gtk_text_view_get_buffer(
GTK_TEXT_VIEW(lookup_widget(dialog_styles, "preview")));
gtk_text_buffer_create_tag(buffer, "default", NULL);
gtk_text_buffer_get_bounds(buffer, &text_start, &text_end);
gtk_text_buffer_apply_tag_by_name(buffer, "default",
&text_start, &text_end);
}
tree = GTK_TREE_VIEW(lookup_widget(dialog_styles, "treeview_styles"));
store = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_INT);
gtk_tree_view_set_model(tree, GTK_TREE_MODEL(store));
gtk_tree_view_insert_column_with_attributes(tree, -1, "Style",
gtk_cell_renderer_text_new(),
"text", 0,
NULL);
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(select, "changed",
G_CALLBACK(gglk_style_selection_changed),
dialog_styles);
gtk_tree_store_append(store, &parent_iter, NULL);
gtk_tree_store_set(store, &parent_iter,
0, gglk_get_tag(style_AllStyles),
1, style_AllStyles,
-1);
gtk_tree_selection_select_iter(select, &parent_iter);
for(i = 0; i < style_NUMSTYLES; i++) {
gtk_tree_store_append(store, &iter, &parent_iter);
gtk_tree_store_set(store, &iter,
0, gglk_get_tag(i),
1, i,
-1);
}
gtk_tree_store_append(store, &iter, NULL);
gtk_tree_store_set(store, &iter,
0, gglk_get_tag(style_TextGrid),
1, style_TextGrid,
-1);
gtk_tree_store_append(store, &iter, NULL);
gtk_tree_store_set(store, &iter,
0, gglk_get_tag(style_Hyperlinks),
1, style_Hyperlinks,
-1);
gtk_tree_view_expand_all(tree);
#if 0
g_signal_connect(lookup_widget(dialog_styles, "important_toggle"),
"clicked", G_CALLBACK(gglk_style_toggle), NULL);
#endif
gtk_widget_show(dialog_styles);
}
void
go_load_pango_attributes_into_buffer (PangoAttrList *markup, GtkTextBuffer *buffer, gchar const *str)
{
PangoAttrIterator * iter;
PangoAttrList *copied_markup;
PangoAttrList *our_markup;
if (markup == NULL)
return;
/* For some styles we create named tags. The names are taken from the Pango enums */
copied_markup = pango_attr_list_copy (markup);
our_markup = pango_attr_list_filter (copied_markup,
go_load_pango_attributes_into_buffer_named_filter,
NULL);
pango_attr_list_unref (copied_markup);
if (our_markup != NULL) {
iter = pango_attr_list_get_iterator (our_markup);
do {
GSList *attr = pango_attr_iterator_get_attrs (iter);
if (attr != NULL) {
GSList *ptr;
gint start, end;
GtkTextIter start_iter, end_iter;
char const *name;
pango_attr_iterator_range (iter, &start, &end);
start = go_load_pango_byte_to_char (str, start);
end = go_load_pango_byte_to_char (str, end);
gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, start);
gtk_text_buffer_get_iter_at_offset (buffer, &end_iter, end);
for (ptr = attr; ptr != NULL; ptr = ptr->next) {
PangoAttribute *attribute = ptr->data;
GtkTextTag *tag;
int val;
switch (attribute->klass->type) {
case PANGO_ATTR_STYLE:
name = (((PangoAttrInt *)attribute)->value
== PANGO_STYLE_NORMAL)
? "PANGO_STYLE_NORMAL" :
"PANGO_STYLE_ITALIC";
tag = gtk_text_tag_table_lookup
(gtk_text_buffer_get_tag_table (buffer),
name);
gtk_text_buffer_apply_tag (buffer, tag,
&start_iter, &end_iter);
break;
case PANGO_ATTR_STRIKETHROUGH:
name = (((PangoAttrInt *)attribute)->value) ?
"PANGO_STRIKETHROUGH_TRUE" :
"PANGO_STRIKETHROUGH_FALSE";
tag = gtk_text_tag_table_lookup
(gtk_text_buffer_get_tag_table (buffer),
name);
gtk_text_buffer_apply_tag (buffer, tag,
&start_iter, &end_iter);
break;
case PANGO_ATTR_UNDERLINE:
val = ((PangoAttrInt *)attribute)->value;
if (val == PANGO_UNDERLINE_NONE)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_NONE",
&start_iter, &end_iter);
else if (val == PANGO_UNDERLINE_SINGLE)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_SINGLE",
&start_iter, &end_iter);
else if (val == PANGO_UNDERLINE_DOUBLE)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_DOUBLE",
&start_iter, &end_iter);
else if (val == PANGO_UNDERLINE_LOW)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_LOW",
&start_iter, &end_iter);
else if (val == PANGO_UNDERLINE_ERROR)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_UNDERLINE_ERROR",
&start_iter, &end_iter);
break;
case PANGO_ATTR_WEIGHT:
val = ((PangoAttrInt *)attribute)->value;
if (val < (PANGO_WEIGHT_THIN + PANGO_WEIGHT_ULTRALIGHT)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_THIN",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_ULTRALIGHT + PANGO_WEIGHT_LIGHT)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_ULTRALIGHT",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_LIGHT + PANGO_WEIGHT_BOOK)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_LIGHT",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_BOOK + PANGO_WEIGHT_NORMAL)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_BOOK",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_NORMAL + PANGO_WEIGHT_MEDIUM)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_NORMAL",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_MEDIUM + PANGO_WEIGHT_SEMIBOLD)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_MEDIUM",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_SEMIBOLD + PANGO_WEIGHT_BOLD)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_SEMIBOLD",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_BOLD + PANGO_WEIGHT_ULTRABOLD)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_BOLD",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_ULTRABOLD + PANGO_WEIGHT_HEAVY)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_ULTRABOLD",
&start_iter, &end_iter);
else if (val < (PANGO_WEIGHT_HEAVY + PANGO_WEIGHT_ULTRAHEAVY)/2)
gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_HEAVY",
&start_iter, &end_iter);
else gtk_text_buffer_apply_tag_by_name (buffer,"PANGO_WEIGHT_ULTRAHEAVY",
&start_iter, &end_iter);
break;
default:
break;
}
}
g_slist_free_full (attr, (GDestroyNotify)pango_attribute_destroy);
}
} while (pango_attr_iterator_next (iter));
pango_attr_iterator_destroy (iter);
pango_attr_list_unref (our_markup);
}
/* For other styles (that are not at true/false type styles) we use unnamed styles */
copied_markup = pango_attr_list_copy (markup);
our_markup = pango_attr_list_filter (copied_markup,
go_load_pango_attributes_into_buffer_filter,
NULL);
pango_attr_list_unref (copied_markup);
if (our_markup != NULL) {
iter = pango_attr_list_get_iterator (our_markup);
do {
GSList *attr = pango_attr_iterator_get_attrs (iter);
if (attr != NULL) {
char *string;
GSList *ptr;
gint start, end;
GtkTextIter start_iter, end_iter;
GtkTextTag *tag = gtk_text_buffer_create_tag (buffer, NULL, NULL);
for (ptr = attr; ptr != NULL; ptr = ptr->next) {
PangoAttribute *attribute = ptr->data;
switch (attribute->klass->type) {
case PANGO_ATTR_FOREGROUND:
string = pango_color_to_string
(&((PangoAttrColor *)attribute)->color);
g_object_set (G_OBJECT (tag),
"foreground", string,
"foreground-set", TRUE,
NULL);
g_free (string);
break;
case PANGO_ATTR_RISE:
g_object_set (G_OBJECT (tag),
"rise",
((PangoAttrInt *)attribute)->value,
"rise-set", TRUE,
NULL);
break;
default:
break;
}
}
pango_attr_iterator_range (iter, &start, &end);
start = go_load_pango_byte_to_char (str, start);
end = go_load_pango_byte_to_char (str, end);
gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, start);
gtk_text_buffer_get_iter_at_offset (buffer, &end_iter, end);
gtk_text_buffer_apply_tag (buffer, tag, &start_iter, &end_iter);
g_slist_free_full (attr, (GDestroyNotify)pango_attribute_destroy);
}
} while (pango_attr_iterator_next (iter));
pango_attr_iterator_destroy (iter);
pango_attr_list_unref (our_markup);
}
}
/* Catch all typing events to apply the proper tags
*
*/
static gboolean
key_release_event (GtkWidget *text_view,
GdkEventKey *event)
{
GtkTextIter iter_start, iter_end;
GtkTextBuffer *buffer;
{
GSList *tags = NULL, *tagp = NULL;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
gtk_text_buffer_get_iter_at_mark(buffer,
&iter_start,
gtk_text_buffer_get_insert (buffer));
gtk_text_iter_set_line_offset(&iter_start, 0);
iter_end = iter_start;
gtk_text_iter_forward_to_line_end(&iter_end);
tags = gtk_text_iter_get_tags (&iter_start);
if(g_slist_length(tags) == 0)
{
gtk_text_iter_backward_char (&iter_end);
tags = gtk_text_iter_get_tags (&iter_end);
gtk_text_iter_forward_char (&iter_end);
}
for (tagp = tags; tagp != NULL; tagp = tagp->next)
{
GtkTextTag *tag = tagp->data;
gchar *name;
g_object_get (G_OBJECT (tag), "name", &name, NULL);
set_default_tag(buffer, tag);
gtk_text_buffer_apply_tag_by_name(buffer,
name,
&iter_start,
&iter_end);
g_free(name);
selected_tag = NULL;
}
if (tags)
g_slist_free (tags);
else
{
/* Set the default style */
if(selected_tag)
{
set_default_tag(buffer, selected_tag);
gtk_text_buffer_apply_tag(buffer,
selected_tag,
&iter_start,
&iter_end);
}
else
{
set_default_tag(buffer, tag_list[NUMBER_OF_STYLE-1]);
gtk_text_buffer_apply_tag(buffer,
tag_list[NUMBER_OF_STYLE-1],
&iter_start,
&iter_end);
}
}
}
return FALSE;
}
static void
insert_text (GtkTextBuffer *buffer, const gchar *text)
{
GtkTextMark *emph_point = NULL;
GtkTextMark *bold_point = NULL;
while (*text)
{
GtkTextIter here;
gchar *next;
gtk_text_buffer_get_end_iter (buffer, &here);
if ((*text == '\'') && (text[1] == '\'') && (text[2] == '\''))
{
if (!bold_point)
{
bold_point = gtk_text_buffer_create_mark (buffer, "bold",
&here, TRUE);
}
else
{
GtkTextIter past;
gtk_text_buffer_get_iter_at_mark (buffer, &past, bold_point);
gtk_text_buffer_apply_tag_by_name (buffer, "bold", &past, &here);
gtk_text_buffer_delete_mark (buffer, bold_point);
bold_point = NULL;
}
text += 3;
continue;
}
if ((*text == '\'') && (text[1] == '\''))
{
if (!emph_point)
{
emph_point = gtk_text_buffer_create_mark (buffer, "emph",
&here, TRUE);
}
else
{
GtkTextIter past;
gtk_text_buffer_get_iter_at_mark (buffer, &past, emph_point);
gtk_text_buffer_apply_tag_by_name (buffer, "emph", &past, &here);
gtk_text_buffer_delete_mark (buffer, emph_point);
emph_point = NULL;
}
text += 2;
continue;
}
for (next = g_utf8_next_char (text);
*next && (*next != '\'');
next = g_utf8_next_char (next));
gtk_text_buffer_insert (buffer, &here, text, next - text);
text = next;
}
}
static void
insert_text (GtkTextBuffer *buffer)
{
GtkTextIter iter;
GtkTextIter start, end;
GdkPixbuf *pixbuf;
GdkPixbuf *scaled;
GtkTextChildAnchor *anchor;
char *filename;
/* demo_find_file() looks in the current directory first,
* so you can run gtk-demo without installing GTK, then looks
* in the location where the file is installed.
*/
pixbuf = NULL;
filename = demo_find_file ("gtk-logo-rgb.gif", NULL);
if (filename)
{
pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
g_free (filename);
}
if (pixbuf == NULL)
{
g_printerr ("Failed to load image file gtk-logo-rgb.gif\n");
exit (1);
}
scaled = gdk_pixbuf_scale_simple (pixbuf, 32, 32, GDK_INTERP_BILINEAR);
g_object_unref (pixbuf);
pixbuf = scaled;
/* get start of buffer; each insertion will revalidate the
* iterator to point to just after the inserted text.
*/
gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
gtk_text_buffer_insert (buffer, &iter, "The text widget can display text with all kinds of nifty attributes. It also supports multiple views of the same buffer; this demo is showing the same buffer in two places.\n\n", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "Font styles. ", -1,
"heading", NULL);
gtk_text_buffer_insert (buffer, &iter, "For example, you can have ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"italic", -1,
"italic", NULL);
gtk_text_buffer_insert (buffer, &iter, ", ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"bold", -1,
"bold", NULL);
gtk_text_buffer_insert (buffer, &iter, ", or ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"monospace (typewriter)", -1,
"monospace", NULL);
gtk_text_buffer_insert (buffer, &iter, ", or ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"big", -1,
"big", NULL);
gtk_text_buffer_insert (buffer, &iter, " text. ", -1);
gtk_text_buffer_insert (buffer, &iter, "It's best not to hardcode specific text sizes; you can use relative sizes as with CSS, such as ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"xx-small", -1,
"xx-small", NULL);
gtk_text_buffer_insert (buffer, &iter, " or ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"x-large", -1,
"x-large", NULL);
gtk_text_buffer_insert (buffer, &iter, " to ensure that your program properly adapts if the user changes the default font size.\n\n", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "Colors. ", -1,
"heading", NULL);
gtk_text_buffer_insert (buffer, &iter, "Colors such as ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"a blue foreground", -1,
"blue_foreground", NULL);
gtk_text_buffer_insert (buffer, &iter, " or ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"a red background", -1,
"red_background", NULL);
gtk_text_buffer_insert (buffer, &iter, " or even ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"a stippled red background", -1,
"red_background",
"background_stipple",
NULL);
gtk_text_buffer_insert (buffer, &iter, " or ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"a stippled blue foreground on solid red background", -1,
"blue_foreground",
"red_background",
"foreground_stipple",
NULL);
gtk_text_buffer_insert (buffer, &iter, " (select that to read it) can be used.\n\n", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "Underline, strikethrough, and rise. ", -1,
"heading", NULL);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"Strikethrough", -1,
"strikethrough", NULL);
gtk_text_buffer_insert (buffer, &iter, ", ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"underline", -1,
"underline", NULL);
gtk_text_buffer_insert (buffer, &iter, ", ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"double underline", -1,
"double_underline", NULL);
gtk_text_buffer_insert (buffer, &iter, ", ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"superscript", -1,
"superscript", NULL);
gtk_text_buffer_insert (buffer, &iter, ", and ", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"subscript", -1,
"subscript", NULL);
gtk_text_buffer_insert (buffer, &iter, " are all supported.\n\n", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "Images. ", -1,
"heading", NULL);
gtk_text_buffer_insert (buffer, &iter, "The buffer can have images in it: ", -1);
gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
gtk_text_buffer_insert (buffer, &iter, " for example.\n\n", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "Spacing. ", -1,
"heading", NULL);
gtk_text_buffer_insert (buffer, &iter, "You can adjust the amount of space before each line.\n", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"This line has a whole lot of space before it.\n", -1,
"big_gap_before_line", "wide_margins", NULL);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"You can also adjust the amount of space after each line; this line has a whole lot of space after it.\n", -1,
"big_gap_after_line", "wide_margins", NULL);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"You can also adjust the amount of space between wrapped lines; this line has extra space between each wrapped line in the same paragraph. To show off wrapping, some filler text: the quick brown fox jumped over the lazy dog. Blah blah blah blah blah blah blah blah blah.\n", -1,
"double_spaced_line", "wide_margins", NULL);
gtk_text_buffer_insert (buffer, &iter, "Also note that those lines have extra-wide margins.\n\n", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "Editability. ", -1,
"heading", NULL);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"This line is 'locked down' and can't be edited by the user - just try it! You can't delete this line.\n\n", -1,
"not_editable", NULL);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "Wrapping. ", -1,
"heading", NULL);
gtk_text_buffer_insert (buffer, &iter,
"This line (and most of the others in this buffer) is word-wrapped, using the proper Unicode algorithm. Word wrap should work in all scripts and languages that GTK+ supports. Let's make this a long paragraph to demonstrate: blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah\n\n", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"This line has character-based wrapping, and can wrap between any two character glyphs. Let's make this a long paragraph to demonstrate: blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah\n\n", -1,
"char_wrap", NULL);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"This line has all wrapping turned off, so it makes the horizontal scrollbar appear.\n\n\n", -1,
"no_wrap", NULL);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "Justification. ", -1,
"heading", NULL);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"\nThis line has center justification.\n", -1,
"center", NULL);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"This line has right justification.\n", -1,
"right_justify", NULL);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
"\nThis line has big wide margins. Text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text text.\n", -1,
"wide_margins", NULL);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "Internationalization. ", -1,
"heading", NULL);
gtk_text_buffer_insert (buffer, &iter,
"You can put all sorts of Unicode text in the buffer.\n\nGerman (Deutsch S\303\274d) Gr\303\274\303\237 Gott\nGreek (\316\225\316\273\316\273\316\267\316\275\316\271\316\272\316\254) \316\223\316\265\316\271\316\254 \317\203\316\261\317\202\nHebrew \327\251\327\234\327\225\327\235\nJapanese (\346\227\245\346\234\254\350\252\236)\n\nThe widget properly handles bidirectional text, word wrapping, DOS/UNIX/Unicode paragraph separators, grapheme boundaries, and so on using the Pango internationalization framework.\n", -1);
gtk_text_buffer_insert (buffer, &iter, "Here's a word-wrapped quote in a right-to-left language:\n", -1);
gtk_text_buffer_insert_with_tags_by_name (buffer, &iter, "\331\210\331\202\330\257 \330\250\330\257\330\243 \330\253\331\204\330\247\330\253 \331\205\331\206 \330\243\331\203\330\253\330\261 \330\247\331\204\331\205\330\244\330\263\330\263\330\247\330\252 \330\252\331\202\330\257\331\205\330\247 \331\201\331\212 \330\264\330\250\331\203\330\251 \330\247\331\203\330\263\331\212\331\210\331\206 \330\250\330\261\330\247\331\205\330\254\331\207\330\247 \331\203\331\205\331\206\330\270\331\205\330\247\330\252 \331\204\330\247 \330\252\330\263\330\271\331\211 \331\204\331\204\330\261\330\250\330\255\330\214 \330\253\331\205 \330\252\330\255\331\210\331\204\330\252 \331\201\331\212 \330\247\331\204\330\263\331\206\331\210\330\247\330\252 \330\247\331\204\330\256\331\205\330\263 \330\247\331\204\331\205\330\247\330\266\331\212\330\251 \330\245\331\204\331\211 \331\205\330\244\330\263\330\263\330\247\330\252 \331\205\330\247\331\204\331\212\330\251 \331\205\331\206\330\270\331\205\330\251\330\214 \331\210\330\250\330\247\330\252\330\252 \330\254\330\262\330\241\330\247 \331\205\331\206 \330\247\331\204\331\206\330\270\330\247\331\205 \330\247\331\204\331\205\330\247\331\204\331\212 \331\201\331\212 \330\250\331\204\330\257\330\247\331\206\331\207\330\247\330\214 \331\210\331\204\331\203\331\206\331\207\330\247 \330\252\330\252\330\256\330\265\330\265 \331\201\331\212 \330\256\330\257\331\205\330\251 \331\202\330\267\330\247\330\271 \330\247\331\204\331\205\330\264\330\261\331\210\330\271\330\247\330\252 \330\247\331\204\330\265\330\272\331\212\330\261\330\251. \331\210\330\243\330\255\330\257 \330\243\331\203\330\253\330\261 \331\207\330\260\331\207 \330\247\331\204\331\205\330\244\330\263\330\263\330\247\330\252 \331\206\330\254\330\247\330\255\330\247 \331\207\331\210 \302\273\330\250\330\247\331\206\331\203\331\210\330\263\331\210\331\204\302\253 \331\201\331\212 \330\250\331\210\331\204\331\212\331\201\331\212\330\247.\n\n", -1,
"rtl_quote", NULL);
gtk_text_buffer_insert (buffer, &iter, "You can put widgets in the buffer: Here's a button: ", -1);
anchor = gtk_text_buffer_create_child_anchor (buffer, &iter);
gtk_text_buffer_insert (buffer, &iter, " and a menu: ", -1);
anchor = gtk_text_buffer_create_child_anchor (buffer, &iter);
gtk_text_buffer_insert (buffer, &iter, " and a scale: ", -1);
anchor = gtk_text_buffer_create_child_anchor (buffer, &iter);
gtk_text_buffer_insert (buffer, &iter, " and an animation: ", -1);
anchor = gtk_text_buffer_create_child_anchor (buffer, &iter);
gtk_text_buffer_insert (buffer, &iter, " finally a text entry: ", -1);
anchor = gtk_text_buffer_create_child_anchor (buffer, &iter);
gtk_text_buffer_insert (buffer, &iter, ".\n", -1);
gtk_text_buffer_insert (buffer, &iter, "\n\nThis demo doesn't demonstrate all the GtkTextBuffer features; it leaves out, for example: invisible/hidden text, tab stops, application-drawn areas on the sides of the widget for displaying breakpoints and such...", -1);
/* Apply word_wrap tag to whole buffer */
gtk_text_buffer_get_bounds (buffer, &start, &end);
gtk_text_buffer_apply_tag_by_name (buffer, "word_wrap", &start, &end);
g_object_unref (pixbuf);
}
