static void
ide_highlight_engine__bind_buffer_cb (IdeHighlightEngine *self,
IdeBuffer *buffer,
EggSignalGroup *group)
{
GtkTextBuffer *text_buffer = (GtkTextBuffer *)buffer;
GtkTextIter begin;
GtkTextIter end;
IDE_ENTRY;
g_assert (IDE_IS_HIGHLIGHT_ENGINE (self));
g_assert (IDE_IS_BUFFER (buffer));
g_assert (EGG_IS_SIGNAL_GROUP (group));
ide_set_weak_pointer (&self->buffer, buffer);
g_object_set_qdata (G_OBJECT (buffer), gEngineQuark, self);
gtk_text_buffer_get_bounds (text_buffer, &begin, &end);
self->invalid_begin = gtk_text_buffer_create_mark (text_buffer, NULL, &begin, TRUE);
self->invalid_end = gtk_text_buffer_create_mark (text_buffer, NULL, &end, FALSE);
ide_highlight_engine_reload (self);
IDE_EXIT;
}
void
_ide_project_edit_prepare (IdeProjectEdit *self,
IdeBuffer *buffer)
{
IdeProjectEditPrivate *priv = ide_project_edit_get_instance_private (self);
IdeSourceLocation *begin;
IdeSourceLocation *end;
GtkTextIter begin_iter;
GtkTextIter end_iter;
g_assert (IDE_IS_PROJECT_EDIT (self));
g_assert (IDE_IS_BUFFER (buffer));
begin = ide_source_range_get_begin (priv->range);
end = ide_source_range_get_end (priv->range);
ide_buffer_get_iter_at_source_location (buffer, &begin_iter, begin);
ide_buffer_get_iter_at_source_location (buffer, &end_iter, end);
priv->begin_mark = gtk_text_buffer_create_mark (GTK_TEXT_BUFFER (buffer),
NULL,
&begin_iter,
TRUE);
priv->end_mark = gtk_text_buffer_create_mark (GTK_TEXT_BUFFER (buffer),
NULL,
&end_iter,
FALSE);
}
void
gb_beautifier_process_launch_async (GbBeautifierWorkbenchAddin *self,
IdeSourceView *source_view,
GtkTextIter *begin,
GtkTextIter *end,
GbBeautifierConfigEntry *entry,
GAsyncReadyCallback callback,
GCancellable *cancellable,
gpointer user_data)
{
GtkTextBuffer *buffer;
ProcessState *state;
g_autoptr(GTask) task = NULL;
const gchar *lang_id;
g_assert (GB_IS_BEAUTIFIER_WORKBENCH_ADDIN (self));
g_assert (IDE_IS_SOURCE_VIEW (source_view));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
g_assert (entry != NULL);
g_assert (callback != NULL);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view));
lang_id = gb_beautifier_helper_get_lang_id (self, source_view);
if (begin == NULL)
gtk_text_buffer_get_start_iter (buffer, begin);
if (end == NULL)
gtk_text_buffer_get_end_iter (buffer, begin);
g_assert (gtk_text_iter_get_buffer (begin) == buffer);
g_assert (gtk_text_iter_get_buffer (end) == buffer);
state = g_slice_new0 (ProcessState);
state->self = self;
state->source_view = source_view;
gtk_text_iter_order (begin, end);
state->text = gtk_text_buffer_get_text (buffer, begin, end, FALSE);
state->begin_mark = gtk_text_buffer_create_mark (buffer, NULL, begin, TRUE);
state->end_mark = gtk_text_buffer_create_mark (buffer, NULL, end, FALSE);
state->command = entry->command;
state->lang_id = g_strdup (lang_id);
if (G_IS_FILE (entry->config_file))
state->config_file = g_file_dup (entry->config_file);
if (entry->command_args != NULL)
state->command_args = command_args_copy (entry->command_args);
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_source_tag (task, gb_beautifier_process_launch_async);
g_task_set_task_data (task, state, process_state_free);
gb_beautifier_helper_create_tmp_file_async (self,
state->text,
create_tmp_file_cb,
cancellable,
g_steal_pointer (&task));
}
gboolean
ide_source_snippet_begin (IdeSourceSnippet *self,
GtkTextBuffer *buffer,
GtkTextIter *iter)
{
IdeSourceSnippetContext *context;
IdeSourceSnippetChunk *chunk;
const gchar *text;
gboolean ret;
gint len;
gint i;
g_return_val_if_fail (IDE_IS_SOURCE_SNIPPET (self), FALSE);
g_return_val_if_fail (!self->buffer, FALSE);
g_return_val_if_fail (!self->mark_begin, FALSE);
g_return_val_if_fail (!self->mark_end, FALSE);
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
g_return_val_if_fail (iter, FALSE);
self->inserted = TRUE;
context = ide_source_snippet_get_context (self);
ide_source_snippet_update_context (self);
ide_source_snippet_context_emit_changed (context);
ide_source_snippet_update_context (self);
self->buffer = g_object_ref (buffer);
self->mark_begin = gtk_text_buffer_create_mark (buffer, NULL, iter, TRUE);
g_object_add_weak_pointer (G_OBJECT (self->mark_begin),
(gpointer *) &self->mark_begin);
gtk_text_buffer_begin_user_action (buffer);
for (i = 0; i < self->chunks->len; i++)
{
chunk = g_ptr_array_index (self->chunks, i);
if ((text = ide_source_snippet_chunk_get_text (chunk)))
{
len = g_utf8_strlen (text, -1);
g_array_append_val (self->runs, len);
gtk_text_buffer_insert (buffer, iter, text, -1);
}
}
self->mark_end = gtk_text_buffer_create_mark (buffer, NULL, iter, FALSE);
g_object_add_weak_pointer (G_OBJECT (self->mark_end),
(gpointer *) &self->mark_end);
g_object_ref (self->mark_begin);
g_object_ref (self->mark_end);
gtk_text_buffer_end_user_action (buffer);
ret = ide_source_snippet_move_next (self);
return ret;
}
static void
gb_vim_do_substitute (GtkTextBuffer *buffer,
GtkTextIter *begin,
GtkTextIter *end,
const gchar *search_text,
const gchar *replace_text,
gboolean is_global,
gboolean should_search_all_lines)
{
GtkTextIter begin_tmp;
GtkTextIter end_tmp;
GtkTextMark *last_line;
GtkTextIter *current_line;
GtkTextMark *end_mark;
GtkTextMark *insert;
g_assert (search_text);
g_assert (replace_text);
g_assert ((!begin && !end) || (begin && end));
insert = gtk_text_buffer_get_insert (buffer);
if (!begin)
{
if (should_search_all_lines)
gtk_text_buffer_get_start_iter (buffer, &begin_tmp);
else
gtk_text_buffer_get_iter_at_mark (buffer, &begin_tmp, insert);
begin = &begin_tmp;
}
if (!end)
{
if (should_search_all_lines)
gtk_text_buffer_get_end_iter (buffer, &end_tmp);
else
gtk_text_buffer_get_iter_at_mark (buffer, &end_tmp, insert);
end = &end_tmp;
}
current_line = begin;
last_line = gtk_text_buffer_create_mark (buffer, NULL, current_line, FALSE);
end_mark = gtk_text_buffer_create_mark (buffer, NULL, end, FALSE);
for (guint line = gtk_text_iter_get_line (current_line);
line <= gtk_text_iter_get_line (end);
line++)
{
gb_vim_do_substitute_line (buffer, current_line, search_text, replace_text, is_global);
gtk_text_buffer_get_iter_at_mark (buffer, current_line, last_line);
gtk_text_buffer_get_iter_at_mark (buffer, end, end_mark);
gtk_text_iter_set_line (current_line, line + 1);
}
gtk_text_buffer_delete_mark (buffer, last_line);
gtk_text_buffer_delete_mark (buffer, end_mark);
}
static void twitter_conv_icon_displayed_chat_cb(PurpleAccount * account, const char *who, char *message, PurpleConversation * conv, PurpleMessageFlags flags, void *account_signal)
{
GtkIMHtml *imhtml;
GtkTextBuffer *text_buffer;
GtkTextIter insertion_point;
gint linenumber;
TwitterConvIcon *conv_icon;
PurpleConnection *gc;
TwitterConnectionData *twitter;
if (account != account_signal)
return;
gc = purple_account_get_connection(account);
if (!gc) {
return;
}
twitter = gc->proto_data;
purple_debug_info(PLUGIN_ID, "%s\n", G_STRFUNC);
/* insert icon */
imhtml = GTK_IMHTML(PIDGIN_CONVERSATION(conv)->imhtml);
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(imhtml));
/* get GtkTextIter in the target line */
linenumber = GPOINTER_TO_INT(purple_conversation_get_data(conv, PLUGIN_ID "-icon-ln"));
gtk_text_buffer_get_iter_at_line(text_buffer, &insertion_point, linenumber);
conv_icon = twitter_conv_icon_find(account, who);
/* if we don't have the icon for this user, put a mark instead and
* request the icon */
if (!conv_icon) {
conv_icon = twitter_conv_icon_new(account, who);
twitter_conv_icon_add_conv(conv_icon, conv);
g_hash_table_insert(twitter->icons, g_strdup(purple_normalize(account, who)), conv_icon);
mark_icon_for_user(gtk_text_buffer_create_mark(text_buffer, NULL, &insertion_point, FALSE), conv_icon);
return;
}
twitter_conv_icon_add_conv(conv_icon, conv);
/* if we have the icon for this user, insert the icon immediately */
if (TRUE) {
if (conv_icon->pixbuf) {
gtk_text_buffer_insert_pixbuf(text_buffer, &insertion_point, conv_icon->pixbuf);
} else {
mark_icon_for_user(gtk_text_buffer_create_mark(text_buffer, NULL, &insertion_point, FALSE), conv_icon);
}
}
purple_debug_info(PLUGIN_ID, "end %s\n", G_STRFUNC);
}
/* vers=0: right == NOOPS*/
static void doc_shift_selection( Tdocument *doc, gboolean vers ) {
GtkTextIter itstart, itend;
if ( gtk_text_buffer_get_selection_bounds( doc->buffer, &itstart, &itend ) ) {
GtkTextMark * end;
doc_unbind_signals( doc );
doc_unre_new_group( doc );
/* we have a selection, now we loop trough the characters, and for every newline
we add or remove a tab, we set the end with a mark */
end = gtk_text_buffer_create_mark( doc->buffer, NULL, &itend, TRUE );
/* set to: the fist char of the fist line */
if ( gtk_text_iter_get_line_offset( &itstart ) > 0 ) {
gtk_text_iter_set_line_index( &itstart, 0 );
}
/* remove one line from current selection for each step*/
while ( gtk_text_iter_compare( &itstart, &itend ) < 0 ) {
GtkTextMark * cur;
cur = gtk_text_buffer_create_mark( doc->buffer, NULL, &itstart, TRUE );
if ( vers ) {
itend = itstart;
gtk_text_iter_forward_chars( &itend, 1 );
gchar *buf = gtk_text_buffer_get_text( doc->buffer, &itstart, &itend, FALSE );
if ( !strstr( buf, "\n" ) ) {
gint offsetstart, offsetend;
offsetstart = gtk_text_iter_get_offset( &itstart );
offsetend = gtk_text_iter_get_offset( &itend );
gtk_text_buffer_delete( doc->buffer, &itstart, &itend );
doc_unre_add( doc, buf, offsetstart, offsetend, UndoDelete );
}
g_free( buf );
}
gtk_text_buffer_get_iter_at_mark( doc->buffer, &itstart, cur );
gtk_text_buffer_get_iter_at_mark( doc->buffer, &itend, end );
gtk_text_buffer_delete_mark( doc->buffer, cur );
/* forward one more line */
gtk_text_iter_forward_line( &itstart );
}
gtk_text_buffer_delete_mark( doc->buffer, end );
doc_bind_signals( doc );
doc_set_modified( doc, 1 );
} else {
/* there is no selection, work on the current line */
GtkTextIter iter;
gtk_text_buffer_get_iter_at_mark( doc->buffer, &iter, gtk_text_buffer_get_insert( doc->buffer ) );
if ( vers ) {
GtkTextIter itend;
gtk_text_iter_set_line_offset( &iter, 0 );
itend = iter;
gtk_text_iter_forward_chars( &itend, 1 );
gtk_text_buffer_delete( doc->buffer, &iter, &itend );
}
}
}
void chatbox_insert_msg(chatbox_t *chatbox, char *sender, time_t *tm, char *msg) {
char buf[65535];
GtkTextView *output_textview;
GtkTextBuffer *output_buffer;
GtkTextIter start;
GtkTextIter end;
GtkTextMark *mark;
chatbox = (chatbox_t*)(chatbox);
output_textview = chatbox->display_textview;
output_buffer = gtk_text_view_get_buffer(output_textview);
sprintf(buf, "%s(%s):\n", sender, my_ctime(tm));
gtk_text_buffer_get_end_iter(output_buffer, &end);
gtk_text_buffer_insert_with_tags_by_name(output_buffer, &end,
buf, -1, "blue_fg", "lmarg", "title_font", NULL);
insert_msg_with_emotion_to_textview(output_textview, msg);
gtk_text_buffer_get_end_iter(output_buffer, &end);
mark = gtk_text_buffer_create_mark(output_buffer, NULL, &end, FALSE);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(output_textview), mark,
0.0, TRUE, 0.0, 0.0);
gtk_text_buffer_delete_mark(output_buffer, mark);
}
IRC_Client_GUI_MessageHandler::IRC_Client_GUI_MessageHandler (Common_UI_GTKState* GTKState_in,
GtkTextView* view_in)
: CBData_ ()
, displayQueue_ ()
, lock_ ()
, eventSourceID_ (0)
, isFirstMemberListMsg_ (true)
, parent_ (NULL)
, view_ (view_in)
{
RPG_TRACE (ACE_TEXT ("IRC_Client_GUI_MessageHandler::IRC_Client_GUI_MessageHandler"));
// sanity check(s)
ACE_ASSERT (GTKState_in);
ACE_ASSERT (view_in);
// initialize cb data
CBData_.id.clear ();
CBData_.GTKState = GTKState_in;
CBData_.controller = NULL;
// setup auto-scrolling
GtkTextIter iterator;
gtk_text_buffer_get_end_iter (gtk_text_view_get_buffer (view_),
&iterator);
gtk_text_buffer_create_mark (gtk_text_view_get_buffer (view_),
ACE_TEXT_ALWAYS_CHAR ("scroll"),
&iterator,
TRUE);
}
static void handle_ggz_chat_event(GGZMod * ggzmod, GGZModEvent e,
const void *data)
{
const GGZChat *chat = data;
ChatWidgets *list;
char message[1024];
GtkTextBuffer *buf;
GtkTextIter i;
GtkTextMark *mark;
snprintf(message, sizeof(message), "\n%s : %s",
chat->player, chat->message);
for (list = chats; list; list = list->next) {
if (!list->container)
continue;
buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(list->text));
gtk_text_buffer_get_end_iter(buf, &i);
gtk_text_buffer_insert(buf, &i, message, -1);
/* have to use a mark, or this won't work properly */
gtk_text_buffer_get_end_iter(buf, &i);
mark = gtk_text_buffer_create_mark(buf, NULL, &i, FALSE);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW
(list->text), mark);
gtk_text_buffer_delete_mark(buf, mark);
}
}
void interface_echo_message(SESSION_STATE * session, gchar * text)
{
GtkTextView *out;
GtkTextBuffer *buffer;
GtkTextIter start, end;
GtkTextMark *mark;
GtkTextTag *tag;
out =
(GtkTextView *) interface_get_widget(GTK_WIDGET(session->tab),
"output1");
buffer = gtk_text_view_get_buffer(out);
// save position
gtk_text_buffer_get_end_iter(buffer, &end);
mark = gtk_text_buffer_create_mark(buffer, NULL, &end, TRUE);
// insert text
gtk_text_buffer_insert(buffer, &end, text, -1);
// Put some color on it
tag =
get_fg_color_tag(buffer, 128 * RED + 128 * GREEN + 255 * BLUE);
gtk_text_buffer_get_iter_at_mark(buffer, &start, mark);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
// insert newline
gtk_text_buffer_insert(buffer, &end, "\n", -1);
//scroll to bottom
output_scroll_to_bottom(session->tab);
}
GtkWidget*
hybrid_chat_textview_create(void)
{
GtkWidget *textview;
GtkTextBuffer *buffer;
GtkTextIter end_iter;
textview = gtk_text_view_new();
gtk_widget_set_size_request(textview, 0, 100);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_CHAR);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), FALSE);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_create_tag(buffer, "blue", "foreground", "#639900", NULL);
gtk_text_buffer_create_tag(buffer, "grey", "foreground", "#808080", NULL);
gtk_text_buffer_create_tag(buffer, "green", "foreground", "#0088bf", NULL);
gtk_text_buffer_create_tag(buffer, "bold", "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_create_tag(buffer, "lm10", "left_margin", 3, NULL);
gtk_text_buffer_create_tag(buffer, "wrap", "wrap-mode", GTK_WRAP_WORD_CHAR, NULL);
gtk_text_buffer_create_tag(buffer, "small", "size-points", 9.0, NULL);
gtk_text_buffer_get_end_iter(buffer, &end_iter);
gtk_text_buffer_create_mark(buffer, "scroll", &end_iter, FALSE);
return textview;
}
/* this function will simply add the bookmark as defined in the arguments
*
* will use offset if itoffset is NULL
* will use itoffset if not NULL
*/
static void bmark_add_backend(Tdocument *doc, GtkTextIter *itoffset, gint offset, const gchar *name, const gchar *text, gboolean is_temp) {
Tbmark *m;
gchar *displaytext = NULL;
GtkTextIter it;
m = g_new0(Tbmark, 1);
m->doc = doc;
if (itoffset) {
it = *itoffset;
m->offset = gtk_text_iter_get_offset(&it);
} else {
gtk_text_buffer_get_iter_at_offset(doc->buffer,&it,offset);
m->offset = offset;
}
m->mark = gtk_text_buffer_create_mark(doc->buffer, NULL, &it, TRUE);
m->filepath = g_strdup(doc->filename);
m->is_temp = is_temp;
m->text = g_strdup(text);
m->name = (name) ? g_strdup(name) : g_strdup("");
m->description = g_strdup("");
/* insert into tree */
bmark_get_iter_at_tree_position(doc->bfwin, m);
displaytext = bmark_display_text(m->name, m->text);
gtk_tree_store_set(BFWIN(doc->bfwin)->bookmarkstore, &m->iter, NAME_COLUMN, displaytext, PTR_COLUMN, m, -1);
g_free (displaytext);
/* and store */
if (!m->is_temp) {
bmark_store(BFWIN(doc->bfwin), m);
}
}
void
ide_source_snippet_after_delete_range (IdeSourceSnippet *self,
GtkTextBuffer *buffer,
GtkTextIter *begin,
GtkTextIter *end)
{
GtkTextMark *here;
g_return_if_fail (IDE_IS_SOURCE_SNIPPET (self));
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (begin);
g_return_if_fail (end);
here = gtk_text_buffer_create_mark (buffer, NULL, begin, TRUE);
ide_source_snippet_update_context (self);
ide_source_snippet_update_context (self);
ide_source_snippet_rewrite_updated_chunks (self);
gtk_text_buffer_get_iter_at_mark (buffer, begin, here);
gtk_text_buffer_get_iter_at_mark (buffer, end, here);
gtk_text_buffer_delete_mark (buffer, here);
#if 0
ide_source_snippet_context_dump (self->snippet_context);
#endif
}
GtkWidget *
nh_message_new()
{
GtkWidget *message_h;
GtkWidget *sw;
GtkTextIter iter;
GtkTextBuffer *t;
message_h = gtk_handle_box_new();
GTK_HANDLE_BOX(message_h)->shrink_on_detach = 1;
message_text = gtk_text_view_new();
gtk_widget_show(message_text);
GTK_WIDGET_UNSET_FLAGS(message_text, GTK_CAN_FOCUS);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(message_text), GTK_WRAP_WORD);
t = gtk_text_view_get_buffer(GTK_TEXT_VIEW(message_text));
gtk_text_buffer_create_tag(t, "warning", "foreground", "red", NULL);
gtk_text_buffer_get_end_iter(t, &iter);
gtk_text_buffer_create_mark(t, "nh_end", &iter, FALSE);
sw = nh_gtk_new_and_add(gtk_scrolled_window_new(NULL, NULL), message_h, "");
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(sw), message_text);
return message_h;
}
static gint scroll_to_top()
{
GtkTextIter iter;
GtkTextMark *mark;
LOG(LOG_DEBUG, "IN : scroll_to_top()");
gtk_text_buffer_get_start_iter (text_buffer, &iter);
mark = gtk_text_buffer_create_mark(text_buffer,
"start",
&iter,
TRUE);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(popup_view),
mark,
0.0,
TRUE,
0.0, 0.0);
gtk_text_buffer_delete_mark(text_buffer, mark);
LOG(LOG_DEBUG, "OUT : scroll_to_top()");
return(0);
}
static void
add_tracker (GtkTextBuffer *buffer,
GtkTextIter *iter,
GtkSourceMark *bookmark,
InsertData *data)
{
GSList *item;
InsertTracker *tracker;
for (item = data->trackers; item; item = g_slist_next (item))
{
tracker = item->data;
if (tracker->bookmark == bookmark)
{
return;
}
}
tracker = g_slice_new (InsertTracker);
tracker->bookmark = bookmark;
tracker->mark = gtk_text_buffer_create_mark (buffer,
NULL,
iter,
FALSE);
data->trackers = g_slist_prepend (data->trackers, tracker);
}
void scroll_to_the_end(struct text_view_info *viewinfo){
GtkTextIter end;
gtk_text_buffer_get_end_iter(viewinfo->view1_buffer,&end);
GtkTextMark *mark=gtk_text_buffer_create_mark(viewinfo->view1_buffer,NULL,&end,1);
gtk_text_buffer_move_mark(viewinfo->view1_buffer,mark,&end);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(viewinfo->view1),mark,0,1,1,1);
}
void
gsc_utils_replace_word (GtkTextBuffer *text_buffer,
GtkTextIter *iter,
const gchar *text,
gint len)
{
GtkTextBuffer *buffer;
gchar *word;
GtkTextIter word_start;
GtkTextIter word_end;
GtkTextMark *mark;
g_return_if_fail (GTK_IS_TEXT_BUFFER (text_buffer));
buffer = GTK_TEXT_BUFFER (text_buffer);
gtk_text_buffer_begin_user_action (buffer);
mark = gtk_text_buffer_create_mark (buffer, NULL, iter, TRUE);
word = gsc_utils_get_word_iter (text_buffer, iter, &word_start, &word_end);
g_free (word);
gtk_text_buffer_delete (buffer, &word_start, &word_end);
if (text != NULL)
{
gtk_text_buffer_insert (buffer, &word_start, text, len);
}
/* Reinitialize iter */
gtk_text_buffer_get_iter_at_mark (buffer, iter, mark);
gtk_text_buffer_delete_mark (buffer, mark);
gtk_text_buffer_end_user_action (buffer);
}
void ctk_help_set_page(CtkHelp *ctk_help, GtkTextBuffer *buffer)
{
GtkTextBuffer *b;
GtkTextIter iter;
GtkTextView *view;
GtkTextMark *mark;
if (buffer) {
b = buffer;
} else {
b = ctk_help->default_help;
}
view = GTK_TEXT_VIEW(ctk_help->text_viewer);
/* set the buffer in the TextView */
gtk_text_view_set_buffer(view, b);
/* ensure that the top of the buffer is displayed */
gtk_text_buffer_get_start_iter(b, &iter);
mark = gtk_text_buffer_create_mark(b, NULL, &iter, TRUE);
gtk_text_view_scroll_to_mark(view, mark, 0.0, TRUE, 0.0, 0.0);
gtk_text_buffer_place_cursor(b, &iter);
}
static void
gt_twitch_chat_view_init(GtTwitchChatView* self)
{
GtTwitchChatViewPrivate* priv = gt_twitch_chat_view_get_instance_private(self);
gtk_widget_init_template(GTK_WIDGET(self));
priv->action_group = g_simple_action_group_new();
priv->dark_theme_action = g_property_action_new("dark-theme", self, "dark-theme");
g_action_map_add_action(G_ACTION_MAP(priv->action_group), G_ACTION(priv->dark_theme_action));
priv->chat_css_provider = gtk_css_provider_new();
gtk_style_context_add_provider(gtk_widget_get_style_context(GTK_WIDGET(self)),
GTK_STYLE_PROVIDER(priv->chat_css_provider),
GTK_STYLE_PROVIDER_PRIORITY_USER);
priv->chat_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(priv->chat_view));
priv->tag_table = gtk_text_buffer_get_tag_table(priv->chat_buffer);
priv->twitch_emotes = g_hash_table_new(g_direct_hash, g_direct_equal);
gtk_text_buffer_get_end_iter(priv->chat_buffer, &priv->bottom_iter);
priv->bottom_mark = gtk_text_buffer_create_mark(priv->chat_buffer, "end", &priv->bottom_iter, TRUE);
priv->chat = gt_twitch_chat_client_new();
priv->cur_chan = NULL;
priv->joined_channel = FALSE;
g_signal_connect(priv->chat_entry, "key-press-event", G_CALLBACK(key_press_cb), self);
g_signal_connect(self, "hierarchy-changed", G_CALLBACK(anchored_cb), self);
g_source_set_callback((GSource*) priv->chat->source, (GSourceFunc) twitch_chat_source_cb, self, NULL);
ADD_STYLE_CLASS(self, "gt-twitch-chat-view");
}
/* Format->Comment Out Selection */
void
action_comment_out_selection(GtkAction *action, I7Document *document)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER(i7_document_get_buffer(document));
GtkTextIter start, end;
if(!gtk_text_buffer_get_selection_bounds(buffer, &start, &end))
return;
gchar *text = gtk_text_buffer_get_text(buffer, &start, &end, TRUE);
/* Treat it as one single undo action */
gtk_text_buffer_begin_user_action(buffer);
/* Delete the entire text and reinsert it inside brackets, in order to
avoid excessively recalculating the syntax highlighting */
gtk_text_buffer_delete(buffer, &start, &end);
gchar *newtext = g_strconcat("[", text, "]", NULL);
GtkTextMark *tempmark = gtk_text_buffer_create_mark(buffer, NULL, &end, TRUE);
gtk_text_buffer_insert(buffer, &end, newtext, -1);
gtk_text_buffer_end_user_action(buffer);
g_free(text);
g_free(newtext);
/* Select the text again, including [] */
gtk_text_buffer_get_iter_at_mark(buffer, &start, tempmark);
gtk_text_buffer_select_range(buffer, &start, &end);
gtk_text_buffer_delete_mark(buffer, tempmark);
}
/*****************************************************************************
Appends the string to the chat output window. The string should be
inserted on its own line, although it will have no newline.
*****************************************************************************/
void real_luaconsole_append(const char *astring,
const struct text_tag_list *tags)
{
GtkTextBuffer *buf;
GtkTextIter iter;
GtkTextMark *mark;
ft_offset_t text_start_offset;
struct luaconsole_data *pdialog = luaconsole_dialog_get();
fc_assert_ret(pdialog);
buf = pdialog->message_buffer;
gtk_text_buffer_get_end_iter(buf, &iter);
gtk_text_buffer_insert(buf, &iter, "\n", -1);
mark = gtk_text_buffer_create_mark(buf, NULL, &iter, TRUE);
if (gui_gtk2_show_chat_message_time) {
char timebuf[64];
time_t now;
struct tm *now_tm;
now = time(NULL);
now_tm = localtime(&now);
strftime(timebuf, sizeof(timebuf), "[%H:%M:%S] ", now_tm);
gtk_text_buffer_insert(buf, &iter, timebuf, -1);
}
text_start_offset = gtk_text_iter_get_offset(&iter);
gtk_text_buffer_insert(buf, &iter, astring, -1);
text_tag_list_iterate(tags, ptag) {
apply_text_tag(ptag, buf, text_start_offset, astring);
} text_tag_list_iterate_end;
static void
load_images(MarkdownTextView * self)
{
GtkTextBuffer *buffer;
GtkTextIter iter;
GSList *tags, *tagp;
gchar *image_path;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(self));
gtk_text_buffer_get_start_iter(buffer, &iter);
do {
tags = gtk_text_iter_get_tags(&iter);
for (tagp = tags; tagp != NULL; tagp = tagp->next) {
GtkTextTag *tag = tagp->data;
gint is_underline = 0;
gchar *lang = NULL;
g_object_get(G_OBJECT(tag),
"underline", &is_underline,
"language", &lang,
NULL);
if (is_underline == 2 && lang) {
GdkPixbuf *pixbuf;
gchar *path;
image_path = egg_markdown_get_link_uri(self->markdown, atoi(lang));
path = g_build_filename(self->image_directory, image_path, NULL);
pixbuf = gdk_pixbuf_new_from_file(path, NULL);
if (pixbuf) {
GtkTextMark *mark;
GtkTextIter start;
mark = gtk_text_buffer_create_mark(buffer, NULL, &iter, FALSE);
gtk_text_buffer_get_iter_at_mark(buffer, &start, mark);
gtk_text_iter_forward_to_tag_toggle(&iter, tag);
gtk_text_buffer_delete(buffer, &start, &iter);
gtk_text_buffer_insert_pixbuf(buffer, &iter, pixbuf);
g_object_unref(pixbuf);
gtk_text_buffer_delete_mark(buffer, mark);
}
g_free(image_path);
g_free(lang);
g_free(path);
break;
}
g_free(lang);
}
if (tags)
g_slist_free(tags);
} while (gtk_text_iter_forward_to_tag_toggle(&iter, NULL));
}
static gboolean scroll_to_end(GtkTextView *w){
GtkTextBuffer *buffer=gtk_text_view_get_buffer(w);
GtkTextIter iter;
gtk_text_buffer_get_end_iter(buffer,&iter);
GtkTextMark *mark=gtk_text_buffer_create_mark(buffer,NULL,&iter,FALSE);
gtk_text_view_scroll_mark_onscreen(w,mark);
return FALSE;
}
/**
* gtkspell_new_attach:
* @view: The #GtkTextView to attach to.
* @lang: The language to use, in a form pspell understands (it appears to
* be a locale specifier?).
* @error: Return location for error.
*
* Create a new #GtkSpell object attached to @view with language @lang.
*
* Returns: a new #GtkSpell object, or %NULL on error.
*/
GtkSpell*
gtkspell_new_attach(GtkTextView *view, const gchar *lang, GError **error) {
GtkTextBuffer *buffer;
GtkTextIter start, end;
GtkSpell *spell;
if (error)
g_return_val_if_fail(*error == NULL, NULL);
spell = g_object_get_data(G_OBJECT(view), GTKSPELL_OBJECT_KEY);
g_assert(spell == NULL);
/* attach to the widget */
spell = g_new0(GtkSpell, 1);
spell->view = view;
if (!gtkspell_set_language_internal(spell, lang, error)) {
g_free(spell);
return NULL;
}
g_object_set_data(G_OBJECT(view), GTKSPELL_OBJECT_KEY, spell);
g_signal_connect_swapped(G_OBJECT(view), "destroy",
G_CALLBACK(gtkspell_free), spell);
g_signal_connect(G_OBJECT(view), "button-press-event",
G_CALLBACK(button_press_event), spell);
g_signal_connect(G_OBJECT(view), "populate-popup",
G_CALLBACK(populate_popup), spell);
buffer = gtk_text_view_get_buffer(view);
g_signal_connect(G_OBJECT(buffer),
"insert-text",
G_CALLBACK(insert_text_before), spell);
g_signal_connect_after(G_OBJECT(buffer),
"insert-text",
G_CALLBACK(insert_text_after), spell);
g_signal_connect_after(G_OBJECT(buffer),
"delete-range",
G_CALLBACK(delete_range_after), spell);
spell->tag_highlight = gtk_text_buffer_create_tag(buffer,
"gtkspell-misspelled",
"foreground", "red",
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
/* we create the mark here, but we don't use it until text is
* inserted, so we don't really care where iter points. */
gtk_text_buffer_get_bounds(buffer, &start, &end);
spell->mark_insert = gtk_text_buffer_create_mark(buffer,
"gtkspell-insert",
&start, TRUE);
/* now check the entire text buffer. */
gtkspell_recheck_all(spell);
return spell;
}
static void console_scroll_to_end (GtkWidget *cview,
GtkTextBuffer *buf,
GtkTextIter *end)
{
GtkTextMark *mark;
mark = gtk_text_buffer_create_mark(buf, NULL, end, FALSE);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(cview), mark);
gtk_text_buffer_delete_mark(buf, mark);
}
void gglk_text_init_tags(GglkText *tb)
{
PangoContext *context;
PangoFontMetrics *metrics;
PangoFontDescription *font_desc = NULL;
GtkTextTag *tag;
tb->buffer = gtk_text_view_get_buffer(&tb->view);
gtk_text_buffer_get_end_iter(tb->buffer, &tb->iter);
tb->startedit=gtk_text_buffer_create_mark(tb->buffer,NULL,&tb->iter,TRUE);
tb->endedit =gtk_text_buffer_create_mark(tb->buffer,NULL,&tb->iter,FALSE);
tb->scrollmark=gtk_text_buffer_create_mark(tb->buffer,NULL,&tb->iter,TRUE);
tb->endmark =gtk_text_buffer_create_mark(tb->buffer,NULL,&tb->iter,FALSE);
tb->hypermark=gtk_text_buffer_create_mark(tb->buffer,NULL,&tb->iter,TRUE);
tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(tb->buffer),
"Normal");
if(!tag) return;
gglk_text_set_style(tb, tag);
/* Measure default font size */
g_object_get(G_OBJECT(tag), "font-desc", &font_desc, NULL);
font_desc = pango_font_description_copy(font_desc);
pango_font_description_merge(font_desc,
GTK_WIDGET(tb)->style->font_desc,FALSE);
context = gtk_widget_get_pango_context(GTK_WIDGET(tb));
metrics = pango_context_get_metrics(context,
font_desc,
pango_context_get_language(context));
pango_font_description_free(font_desc);
tb->xunits = PANGO_PIXELS(pango_font_metrics_get_approximate_digit_width(
metrics));
tb->yunits = PANGO_PIXELS(pango_font_metrics_get_ascent(metrics) +
pango_font_metrics_get_descent(metrics));
pango_font_metrics_unref(metrics);
}
Thtml_diag *html_diag_new(Tbfwin *bfwin, gchar *title) {
Thtml_diag *dg;
dg = g_malloc(sizeof(Thtml_diag));
/* kyanh, removed, 20050225,
dg->tobedestroyed = FALSE;
*/
DEBUG_MSG("html_diag_new, dg=%p\n",dg);
dg->dialog = window_full2(title, GTK_WIN_POS_MOUSE, 12,G_CALLBACK(html_diag_destroy_cb), dg, TRUE/* escape key close the winow */, bfwin ? bfwin->main_window : NULL);
gtk_window_set_type_hint(GTK_WINDOW(dg->dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_role(GTK_WINDOW(dg->dialog), "html_dialog");
dg->vbox = gtk_vbox_new(FALSE, 1);
gtk_container_add(GTK_CONTAINER(dg->dialog), dg->vbox);
{
if (!gtk_text_buffer_get_mark(bfwin->current_document->buffer,"diag_ins")) {
GtkTextIter iter;
GtkTextMark* mark = gtk_text_buffer_get_mark(bfwin->current_document->buffer,"insert");
gtk_text_buffer_get_iter_at_mark(bfwin->current_document->buffer,&iter,mark);
dg->mark_ins = gtk_text_buffer_create_mark(bfwin->current_document->buffer,"diag_ins",&iter,TRUE);
mark = gtk_text_buffer_get_mark(bfwin->current_document->buffer,"selection_bound");
gtk_text_buffer_get_iter_at_mark(bfwin->current_document->buffer,&iter,mark);
dg->mark_sel = gtk_text_buffer_create_mark(bfwin->current_document->buffer,"diag_sel",&iter,TRUE);
} else {
dg->mark_ins = dg->mark_sel = NULL;
}
}
/*
dg->range.pos = -1;
dg->range.end = -1;
*/
if (main_v->props.view_bars & MODE_MAKE_LATEX_TRANSIENT) {
/* must be set before realizing */
DEBUG_MSG("html_diag_finish, setting dg->dialog=%p transient!\n", dg->dialog);
gtk_window_set_transient_for(GTK_WINDOW(dg->dialog), GTK_WINDOW(bfwin->main_window));
}
gtk_widget_realize(dg->dialog);
dg->bfwin = bfwin;
dg->doc = bfwin->current_document;
return dg;
}
void chat_scroll_to_end(GtkTextBuffer *buffer, GtkTextIter *location,
gchar *text, gint len, gpointer data)
{
Chat *chat = (Chat *) data;
GtkTextIter end;
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_create_mark(buffer, "end", &end, FALSE);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(chat->text_view),
gtk_text_buffer_get_mark(buffer, "end"),
0.0, TRUE, 0.0, 0.5);
}
