static void
script_fu_console_response (GtkWidget *widget,
gint response_id,
ConsoleInterface *console)
{
GtkTextIter start, end;
switch (response_id)
{
case RESPONSE_CLEAR:
gtk_text_buffer_get_start_iter (console->console, &start);
gtk_text_buffer_get_end_iter (console->console, &end);
gtk_text_buffer_delete (console->console, &start, &end);
break;
case RESPONSE_SAVE:
script_fu_console_save_dialog (console);
break;
default:
gtk_main_quit ();
break;
}
}
static void text_insert_help(struct menu *menu)
{
GtkTextBuffer *buffer;
GtkTextIter start, end;
const char *prompt = _(menu_get_prompt(menu));
gchar *name;
const char *help;
help = menu_get_help(menu);
/* Gettextize if the help text not empty */
if ((help != 0) && (help[0] != 0))
help = _(help);
if (menu->sym && menu->sym->name)
name = g_strdup_printf(menu->sym->name);
else
name = g_strdup("");
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
gtk_text_buffer_get_bounds(buffer, &start, &end);
gtk_text_buffer_delete(buffer, &start, &end);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_w), 15);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_insert_with_tags(buffer, &end, prompt, -1, tag1,
NULL);
gtk_text_buffer_insert_at_cursor(buffer, " ", 1);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_insert_with_tags(buffer, &end, name, -1, tag1,
NULL);
gtk_text_buffer_insert_at_cursor(buffer, "\n\n", 2);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_insert_with_tags(buffer, &end, help, -1, tag2,
NULL);
}
/*
* called when debugger exits
*/
static void on_debugger_exited (int code)
{
/* remove marker for current instruction if was set */
if (stack)
{
remove_stack_markers();
g_list_foreach(stack, (GFunc)frame_free, NULL);
g_list_free(stack);
stack = NULL;
}
/* clear watch page */
clear_watch_values(GTK_TREE_VIEW(wtree));
/* clear autos page */
gtk_tree_store_clear(GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(atree))));
/* clear stack trace tree */
stree_clear();
/* clear debug terminal */
vte_terminal_reset(VTE_TERMINAL(terminal), TRUE, TRUE);
/* clear debug messages window */
GtkTextIter start, end;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(debugger_messages_textview));
gtk_text_buffer_get_bounds(buffer, &start, &end);
gtk_text_buffer_delete(buffer, &start, &end);
/* enable target page */
tpage_set_readonly(FALSE);
/* remove breaks readonly if current module doesn't support run-time breaks operation */
if (!(active_module->features & MF_ASYNC_BREAKS))
bptree_set_readonly(FALSE);
/* set files that was readonly during debug writable */
GList *iter = read_only_pages;
while (iter)
{
GeanyDocument *doc = document_find_by_real_path((const gchar*)iter->data);
if (doc)
scintilla_send_message(doc->editor->sci, SCI_SETREADONLY, 0, 0);
/* free file name */
g_free(iter->data);
iter = iter->next;
}
g_list_free(read_only_pages);
read_only_pages = NULL;
/* clear and destroy calltips cache */
g_hash_table_destroy(calltips);
calltips = NULL;
/* enable widgets */
enable_sensitive_widgets(TRUE);
/* update buttons panel state */
btnpanel_set_debug_state(DBS_IDLE);
/* update debug state */
debug_state = DBS_IDLE;
}
/****** 'display function' ***************************************************/
void display(GtkTextBuffer *buffer, GtkWidget *t_view)
{
GtkTextTag *tag;
GtkTextIter end,
start,
match_end,
match_start;
gint i,
j;
gchar *key,
*body,
*title,
*artist;
const gchar *song_section[] = {"Verse:", "Verse 1", "Verse 2:",
"Verse 3:","Bridge:", "Bridge 1:",
"Bridge 2:", "Bridge 3:", "Intro:",
"End:", "PreChorus:", "Verso:",
"Chorus:", "Coro:", "Puente:",
"Key Shift:", "Instrumental:", "Chorus 1:",
"Chorus 2:", "Chorus 3:", "Verso 1:",
"Verso 2:", "Verso 3:", "Tag:"};
//-----------------------------------------------------------------------------
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_delete(buffer, &start, &end);
gtk_text_view_set_editable(GTK_TEXT_VIEW(t_view), FALSE);
//-----------------------------------------------------------------------------
// Sets attributes for Title (line 0).
title = gtk_editable_get_chars(GTK_EDITABLE(entry_title), 0, -1);
gtk_text_buffer_get_iter_at_line(buffer, &start, 0);
gtk_text_buffer_place_cursor(buffer, &start);
gtk_text_buffer_insert_at_cursor(buffer, title, -1);
g_free(title);
gtk_text_buffer_get_iter_at_line(buffer, &start, 0);
gtk_text_buffer_get_iter_at_line(buffer, &end, 0);
gtk_text_iter_forward_to_line_end(&end);
tag = gtk_text_buffer_create_tag(buffer, NULL, "weight", 1000,
"font", "monospace 30",
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
//-----------------------------------------------------------------------------
// Inserts text 'by:' before artist with attributes.
tag = gtk_text_buffer_create_tag(buffer, NULL, "font",
"monospace 10",
"weight-set", TRUE,
"weight", 650, NULL);
gtk_text_buffer_get_iter_at_line(buffer, &start, 0);
gtk_text_iter_forward_to_line_end(&start);
gtk_text_buffer_place_cursor(buffer, &start);
// Have to insert '\n' to create next line
gtk_text_buffer_insert_at_cursor(buffer, "\n", -1);
gtk_text_buffer_get_iter_at_line(buffer, &start, 1);
gtk_text_buffer_place_cursor(buffer, &start);
gtk_text_buffer_insert_at_cursor(buffer, "Artist: ", -1);
gtk_text_buffer_get_iter_at_line(buffer, &start, 1);
gtk_text_buffer_get_iter_at_line(buffer, &end, 1);
gtk_text_iter_forward_to_line_end(&end);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
//-----------------------------------------------------------------------------
artist = gtk_editable_get_chars(GTK_EDITABLE(entry_artist), 0, -1);
gtk_text_buffer_get_iter_at_line_offset(buffer, &start, 1, 8);
gtk_text_buffer_place_cursor(buffer, &start);
gtk_text_buffer_insert_at_cursor(buffer, artist, -1);
g_free(artist);
// Sets attributes for Artist (line 1).
gtk_text_buffer_get_iter_at_line_offset(buffer, &start, 1, 8);
gtk_text_buffer_get_iter_at_line(buffer, &end, 1);
gtk_text_iter_forward_to_line_end(&end);
tag = gtk_text_buffer_create_tag(buffer, NULL, "weight", 500,
"weight-set", TRUE,
"font", "monospace italic 12", NULL);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
//-----------------------------------------------------------------------------
tag = gtk_text_buffer_create_tag(buffer, NULL, "font",
"monospace 10",
"weight", 650, NULL);
gtk_text_buffer_get_iter_at_line(buffer, &start, 1);
gtk_text_iter_forward_to_line_end(&start);
gtk_text_buffer_place_cursor(buffer, &start);
// Have to insert '\n' to create next line
gtk_text_buffer_insert_at_cursor(buffer, "\n", -1);
gtk_text_buffer_get_iter_at_line(buffer, &start, 2);
gtk_text_buffer_place_cursor(buffer, &start);
gtk_text_buffer_insert_at_cursor(buffer, "Key: ", -1);
gtk_text_buffer_get_iter_at_line(buffer, &start, 2);
gtk_text_buffer_get_iter_at_line(buffer, &end, 2);
gtk_text_iter_forward_to_line_end(&end);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
//-----------------------------------------------------------------------------
key = gtk_editable_get_chars(GTK_EDITABLE(entry_key), 0, -1);
gtk_text_buffer_get_iter_at_line_offset(buffer, &start, 2, 5);
gtk_text_buffer_place_cursor(buffer, &start);
gtk_text_buffer_insert_at_cursor(buffer, key, -1);
g_free(key);
gtk_text_buffer_get_iter_at_line_offset(buffer, &start, 2, 5);
gtk_text_buffer_get_iter_at_line(buffer, &end, 2);
gtk_text_iter_forward_to_line_end(&end);
tag = gtk_text_buffer_create_tag(buffer, NULL, "weight", 500,
"weight-set", TRUE,
"font", "monospace italic 12", NULL);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
//-----------------------------------------------------------------------------
gtk_text_buffer_get_iter_at_line(buffer, &start, 2);
gtk_text_iter_forward_to_line_end(&start);
gtk_text_buffer_place_cursor(buffer, &start);
// Have to insert '\n' to create next line
gtk_text_buffer_insert_at_cursor(buffer, "\n\n", -1);
gtk_text_buffer_get_start_iter(t_buffer_editor, &start);
gtk_text_buffer_get_end_iter(t_buffer_editor, &end);
body = gtk_text_buffer_get_text(t_buffer_editor, &start, &end, FALSE);
gtk_text_buffer_get_iter_at_line(buffer, &start, 4);
gtk_text_buffer_place_cursor(buffer, &start);
gtk_text_buffer_insert_at_cursor(buffer, body, -1);
//-----------------------------------------------------------------------------
gtk_text_buffer_get_iter_at_line(buffer, &start, 4);
gtk_text_buffer_get_end_iter(buffer, &end);
tag = gtk_text_buffer_create_tag(buffer, NULL, "font",
"monospace", NULL);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
line_count_C = gtk_text_buffer_get_line_count(buffer);
gtk_text_buffer_get_start_iter(buffer, &start);
if(gtk_text_iter_forward_search(&start, "[", 1,
&match_start, &match_end, NULL))
{
line_num_C = gtk_text_iter_get_line(&match_start);
}
for(i = 0; i == 0;)
{
i = set_chord_position(t_view, buffer);
}
//-----------------------------------------------------------------------------
// This section is for setting the attributes of the text
// 'Verse:', 'Chorus:'etc...
char_line = 0;
char_line_offset = 0;
for(i = 0; i < 24;)
{
for(j = 0; j == 0;)
{
j = text_tags(buffer, song_section[i]);
}
if(j != 0)
{
char_line = 0;
char_line_offset = 0;
i++;
}
}
//-----------------------------------------------------------------------------
//g_print("Function return: %d\n", set_chord_position(t_view, buffer));
//g_print("Line number of chord: %d\n", line_num_C);*/
}
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
process_communicate_utf8_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr (GSubprocess) process = (GSubprocess *)object;
g_autoptr (GTask) task = (GTask *)user_data;
g_autofree gchar *stdout_str = NULL;
g_autofree gchar *stderr_str = NULL;
g_autoptr(GError) error = NULL;
GtkSourceCompletion *completion;
GtkTextBuffer *buffer;
GtkTextIter begin;
GtkTextIter end;
ProcessState *state;
gboolean status;
g_assert (G_IS_SUBPROCESS (process));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (G_IS_TASK (task));
if (!g_subprocess_communicate_utf8_finish (process, result, &stdout_str, &stderr_str, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
return;
}
if (g_task_return_error_if_cancelled (task))
return;
state = (ProcessState *)g_task_get_task_data (task);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (state->source_view));
completion = gtk_source_view_get_completion (GTK_SOURCE_VIEW (state->source_view));
if (!ide_str_empty0 (stdout_str))
{
gtk_source_completion_block_interactive (completion);
gtk_text_buffer_begin_user_action (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &begin, state->begin_mark);
gtk_text_buffer_get_iter_at_mark (buffer, &end, state->end_mark);
gtk_text_buffer_delete (buffer, &begin, &end);
gtk_text_buffer_insert (buffer, &begin, stdout_str, -1);
/* Get valid iters from marks */
gtk_text_buffer_get_iter_at_mark (buffer, &begin, state->begin_mark);
gtk_text_buffer_get_iter_at_mark (buffer, &end, state->end_mark);
gtk_text_buffer_select_range (buffer, &begin, &end);
g_signal_emit_by_name (state->source_view, "selection-theatric", IDE_SOURCE_VIEW_THEATRIC_EXPAND);
gtk_text_buffer_end_user_action (buffer);
gtk_source_completion_unblock_interactive (completion);
g_task_return_boolean (task, TRUE);
}
else
g_warning ("beautify plugin: output empty");
if (g_subprocess_get_if_exited (process))
{
status = g_subprocess_get_exit_status (process);
if (status != 0 &&
stderr_str != NULL &&
!ide_str_empty0 (stderr_str))
{
g_warning ("beautify plugin stderr:\n%s", stderr_str);
}
}
}
/* clean the input text */
void clean_send_text()
{
GtkTextIter start,end;
gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(input_buffer),&start,&end);/*获得缓冲区开始和结束位置的Iter*/
gtk_text_buffer_delete(GTK_TEXT_BUFFER(input_buffer),&start,&end);/*插入到缓冲区*/
}
void XAttGtk::change_value(int set_focus)
{
int sts;
GtkWidget* text_w;
int multiline;
char* value;
int input_size;
if (input_open) {
g_object_set(cmd_input, "visible", FALSE, NULL);
g_object_set(cmd_scrolledinput, "visible", FALSE, NULL);
set_prompt("");
input_open = 0;
return;
}
sts = xattnav->check_attr(
&multiline, &input_node, input_name, &value, &input_size);
if (EVEN(sts)) {
if (sts == XATT__NOATTRSEL)
message('E', "No attribute is selected");
else
message('E', XNav::get_message(sts));
return;
}
if (multiline) {
text_w = cmd_scrolledinput;
g_object_set(text_w, "visible", TRUE, NULL);
int w, h;
gdk_drawable_get_size(pane->window, &w, &h);
gtk_paned_set_position(GTK_PANED(pane), h - 170);
if (set_focus)
gtk_widget_grab_focus(cmd_scrolledtextview);
input_max_length = input_size - 1;
input_multiline = 1;
} else {
text_w = cmd_input;
g_object_set(text_w, "visible", TRUE, "max-length", input_size - 1, NULL);
if (set_focus)
gtk_widget_grab_focus(cmd_input);
input_multiline = 0;
}
message(' ', "");
if (value) {
if (multiline) {
GtkTextIter start_iter, end_iter;
gtk_text_buffer_get_start_iter(cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_get_end_iter(cmd_scrolled_buffer, &end_iter);
gtk_text_buffer_delete(cmd_scrolled_buffer, &start_iter, &end_iter);
gtk_text_buffer_get_start_iter(cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_insert(cmd_scrolled_buffer, &start_iter, value, -1);
// Select the text
// gtk_text_buffer_get_start_iter( cmd_scrolled_buffer, &start_iter);
// gtk_text_buffer_get_end_iter( cmd_scrolled_buffer, &end_iter);
// gtk_text_buffer_select_range( cmd_scrolled_buffer, &start_iter,
// &end_iter);
} else {
gint pos = 0;
gtk_editable_delete_text(GTK_EDITABLE(cmd_input), 0, -1);
gtk_editable_insert_text(
GTK_EDITABLE(text_w), value, strlen(value), &pos);
// Select the text
gtk_editable_set_position(GTK_EDITABLE(cmd_input), -1);
gtk_editable_select_region(GTK_EDITABLE(cmd_input), 0, -1);
}
} else {
gtk_editable_delete_text(GTK_EDITABLE(cmd_input), 0, -1);
}
message(' ', "");
set_prompt(Lng::translate("value >"));
input_open = 1;
}
/**
* undo_redo:
* @w: not used
* @data: not used
*
* executes a redo request on the current document
**/
void undo_redo(UndoMain *undostruct)
{
UndoInfo *redoinfo;
GtkTextView *textview;
GtkTextBuffer *buffer;
GtkTextIter iter, start_iter, end_iter;
GtkTextMark *mark;
cm_return_if_fail(undostruct != NULL);
if (undostruct->redo == NULL) return;
redoinfo = (UndoInfo *)undostruct->redo->data;
cm_return_if_fail (redoinfo != NULL);
undostruct->undo = g_list_prepend(undostruct->undo, redoinfo);
undostruct->redo = g_list_remove(undostruct->redo, redoinfo);
textview = undostruct->textview;
buffer = gtk_text_view_get_buffer(textview);
undo_block(undostruct);
/* Check if there is a selection active */
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
gtk_text_buffer_place_cursor(buffer, &iter);
/* Move the view to the right position. */
gtk_adjustment_set_value(gtk_text_view_get_vadjustment(textview),
redoinfo->window_position);
switch (redoinfo->action) {
case UNDO_ACTION_INSERT:
gtk_text_buffer_get_iter_at_offset(buffer, &iter, redoinfo->start_pos);
gtk_text_buffer_insert(buffer, &iter, redoinfo->text, -1);
break;
case UNDO_ACTION_DELETE:
gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, redoinfo->start_pos);
gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, redoinfo->end_pos);
gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
break;
case UNDO_ACTION_REPLACE_DELETE:
gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, redoinfo->start_pos);
gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, redoinfo->end_pos);
gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
debug_print("UNDO_ACTION_REPLACE %s\n", redoinfo->text);
/* "pull" another data structure from the list */
redoinfo = (UndoInfo *)undostruct->redo->data;
cm_return_if_fail(redoinfo != NULL);
undostruct->undo = g_list_prepend(undostruct->undo, redoinfo);
undostruct->redo = g_list_remove(undostruct->redo, redoinfo);
cm_return_if_fail(redoinfo->action == UNDO_ACTION_REPLACE_INSERT);
gtk_text_buffer_insert(buffer, &start_iter, redoinfo->text, -1);
break;
case UNDO_ACTION_REPLACE_INSERT:
/* This is needed only if we redo from a middle-click button */
gtk_text_buffer_get_iter_at_offset(buffer, &iter, redoinfo->start_pos);
gtk_text_buffer_insert(buffer, &iter, redoinfo->text, -1);
break;
default:
g_assert_not_reached();
break;
}
undostruct->change_state_func(undostruct,
UNDO_STATE_TRUE, UNDO_STATE_UNCHANGED,
undostruct->change_state_data);
if (undostruct->redo == NULL)
undostruct->change_state_func(undostruct,
UNDO_STATE_UNCHANGED,
UNDO_STATE_FALSE,
undostruct->change_state_data);
undo_unblock(undostruct);
}
/**
* undo_undo:
* @w: not used
* @data: not used
*
* Executes an undo request on the current document
**/
void undo_undo(UndoMain *undostruct)
{
UndoInfo *undoinfo;
GtkTextView *textview;
GtkTextBuffer *buffer;
GtkTextIter iter, start_iter, end_iter;
GtkTextMark *mark;
cm_return_if_fail(undostruct != NULL);
if (undostruct->undo == NULL) return;
/* The undo data we need is always at the top op the
stack. So, therefore, the first one */
undoinfo = (UndoInfo *)undostruct->undo->data;
cm_return_if_fail(undoinfo != NULL);
undoinfo->mergeable = FALSE;
undostruct->redo = g_list_prepend(undostruct->redo, undoinfo);
undostruct->undo = g_list_remove(undostruct->undo, undoinfo);
textview = undostruct->textview;
buffer = gtk_text_view_get_buffer(textview);
undo_block(undostruct);
/* Check if there is a selection active */
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
gtk_text_buffer_place_cursor(buffer, &iter);
/* Move the view (scrollbars) to the correct position */
gtk_adjustment_set_value
(GTK_ADJUSTMENT(gtk_text_view_get_vadjustment(textview)),
undoinfo->window_position);
switch (undoinfo->action) {
case UNDO_ACTION_DELETE:
gtk_text_buffer_get_iter_at_offset(buffer, &iter, undoinfo->start_pos);
gtk_text_buffer_insert(buffer, &iter, undoinfo->text, -1);
break;
case UNDO_ACTION_INSERT:
gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, undoinfo->start_pos);
gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, undoinfo->end_pos);
gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
break;
case UNDO_ACTION_REPLACE_INSERT:
gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, undoinfo->start_pos);
gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, undoinfo->end_pos);
gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
/* "pull" another data structure from the list */
if (undostruct->undo){
undoinfo = (UndoInfo *)undostruct->undo->data;
undostruct->redo = g_list_prepend(undostruct->redo, undoinfo);
undostruct->undo = g_list_remove(undostruct->undo, undoinfo);
cm_return_if_fail(undoinfo != NULL);
cm_return_if_fail(undoinfo->action == UNDO_ACTION_REPLACE_DELETE);
gtk_text_buffer_insert(buffer, &start_iter, undoinfo->text, -1);
}
break;
case UNDO_ACTION_REPLACE_DELETE:
g_warning("This should not happen. UNDO_REPLACE_DELETE");
break;
default:
g_assert_not_reached();
break;
}
undostruct->change_state_func(undostruct,
UNDO_STATE_UNCHANGED, UNDO_STATE_TRUE,
undostruct->change_state_data);
if (undostruct->undo == NULL)
undostruct->change_state_func(undostruct,
UNDO_STATE_FALSE,
UNDO_STATE_UNCHANGED,
undostruct->change_state_data);
undo_unblock(undostruct);
}
static void
update_display (GdauiCloud *cloud)
{
GtkTextBuffer *tbuffer;
GtkTextIter start, end;
/* clean all */
tbuffer = cloud->priv->tbuffer;
gtk_text_buffer_get_start_iter (tbuffer, &start);
gtk_text_buffer_get_end_iter (tbuffer, &end);
gtk_text_buffer_delete (tbuffer, &start, &end);
if (cloud->priv->selected_tags) {
g_slist_foreach (cloud->priv->selected_tags, (GFunc) g_object_unref, NULL);
g_slist_free (cloud->priv->selected_tags);
cloud->priv->selected_tags = NULL;
sync_iter_with_selection (cloud);
g_signal_emit_by_name (cloud, "selection-changed");
}
if (!cloud->priv->model)
return;
if (cloud->priv->label_column < 0)
return;
/* check for the data model's column type */
GdaColumn *column;
column = gda_data_model_describe_column (cloud->priv->model, cloud->priv->label_column);
if (!column || (gda_column_get_g_type (column) != G_TYPE_STRING)) {
g_warning (_("Wrong column type for label: expecting a string and got a %s"),
gda_g_type_to_string (gda_column_get_g_type (column)));
return;
}
gint nrows, i;
nrows = gda_data_model_get_n_rows (cloud->priv->model);
/* compute scale range */
gdouble min_weight = G_MAXDOUBLE, max_weight = G_MINDOUBLE, wrange;
if ((cloud->priv->weight_column >= 0) || cloud->priv->weight_func) {
for (i = 0; i < nrows; i++) {
const GValue *cvalue;
gdouble weight = 1.;
if (cloud->priv->weight_func) {
weight = cloud->priv->weight_func (cloud->priv->model, i,
cloud->priv->weight_func_data);
min_weight = MIN (min_weight, weight);
max_weight = MAX (max_weight, weight);
}
else {
cvalue = gda_data_model_get_value_at (cloud->priv->model,
cloud->priv->weight_column, i, NULL);
if (cvalue) {
weight = g_ascii_strtod (gda_value_stringify (cvalue), NULL);
min_weight = MIN (min_weight, weight);
max_weight = MAX (max_weight, weight);
}
}
}
}
if (max_weight > min_weight)
wrange = (cloud->priv->max_scale - cloud->priv->min_scale) / (max_weight - min_weight);
else
wrange = 0.;
gtk_text_buffer_get_start_iter (tbuffer, &start);
for (i = 0; i < nrows; i++) {
const GValue *cvalue;
gdouble weight = 1.;
const gchar *ptr;
GString *string;
cvalue = gda_data_model_get_value_at (cloud->priv->model, cloud->priv->label_column, i, NULL);
if (!cvalue) {
TO_IMPLEMENT;
continue;
}
if (!g_value_get_string (cvalue))
continue;
/* convert spaces to non breaking spaces (0xC2 0xA0 as UTF8) */
string = g_string_new ("");
for (ptr = g_value_get_string (cvalue); *ptr; ptr++) {
if (*ptr == ' ') {
g_string_append_c (string, 0xC2);
g_string_append_c (string, 0xA0);
}
else
g_string_append_c (string, *ptr);
}
if ((cloud->priv->weight_column >= 0) || cloud->priv->weight_func) {
if (cloud->priv->weight_func) {
weight = cloud->priv->weight_func (cloud->priv->model, i,
cloud->priv->weight_func_data);
weight = cloud->priv->min_scale + wrange * (weight - min_weight);
}
else {
cvalue = gda_data_model_get_value_at (cloud->priv->model,
cloud->priv->weight_column, i, NULL);
if (cvalue) {
weight = g_ascii_strtod (gda_value_stringify (cvalue), NULL);
weight = cloud->priv->min_scale + wrange * (weight - min_weight);
}
}
}
GtkTextTag *tag;
tag = gtk_text_buffer_create_tag (cloud->priv->tbuffer, NULL,
"foreground", "#6161F2",
"scale", weight,
NULL);
g_object_set_data ((GObject*) tag, "row", GINT_TO_POINTER (i) + 1);
gtk_text_buffer_insert_with_tags (cloud->priv->tbuffer, &start, string->str, -1,
tag, NULL);
g_string_free (string, TRUE);
gtk_text_buffer_insert (cloud->priv->tbuffer, &start, " ", -1);
}
}
static void PopulateListBox (int deviceId)
{
Device *device;
char *string;
char *tempString;
int configNum;
int interfaceNum;
int endpointNum;
int deviceNumber = (deviceId >> 8);
int busNumber = (deviceId & 0x00ff);
GtkTextIter begin;
GtkTextIter end;
device = usb_find_device (deviceNumber, busNumber);
if (device == NULL) {
printf ("Can't seem to find device info to display\n");
return;
}
/* clear the textbox */
gtk_text_buffer_get_start_iter(textDescriptionBuffer,&begin);
gtk_text_buffer_get_end_iter(textDescriptionBuffer,&end);
gtk_text_buffer_delete (textDescriptionBuffer, &begin, &end);
/* freeze the display */
/* this keeps the annoying scroll from happening */
gtk_widget_freeze_child_notify(textDescriptionView);
string = (char *)g_malloc (1000);
/* add the name to the textbox if we have one*/
if (device->name != NULL) {
gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, device->name,strlen(device->name));
}
/* add the manufacturer if we have one */
if (device->manufacturer != NULL) {
sprintf (string, "\nManufacturer: %s", device->manufacturer);
gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));
}
/* add the serial number if we have one */
if (device->serialNumber != NULL) {
sprintf (string, "\nSerial Number: %s", device->serialNumber);
gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));
}
/* add speed */
switch (device->speed) {
case 1 : tempString = "1.5Mb/s (low)"; break;
case 12 : tempString = "12Mb/s (full)"; break;
case 480 : tempString = "480Mb/s (high)"; break; /* planning ahead... */
default : tempString = "unknown"; break;
}
sprintf (string, "\nSpeed: %s", tempString);
gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));
/* add ports if available */
if (device->maxChildren) {
sprintf (string, "\nNumber of Ports: %i", device->maxChildren);
gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));
}
/* add the bandwidth info if available */
if (device->bandwidth != NULL) {
sprintf (string, "\nBandwidth allocated: %i / %i (%i%%)", device->bandwidth->allocated, device->bandwidth->total, device->bandwidth->percent);
gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));
sprintf (string, "\nTotal number of interrupt requests: %i", device->bandwidth->numInterruptRequests);
gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));
sprintf (string, "\nTotal number of isochronous requests: %i", device->bandwidth->numIsocRequests);
gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));
}
/* add the USB version, device class, subclass, protocol, max packet size, and the number of configurations (if it is there) */
if (device->version) {
sprintf (string, "\nUSB Version: %s\nDevice Class: %s\nDevice Subclass: %s\nDevice Protocol: %s\n"
"Maximum Default Endpoint Size: %i\nNumber of Configurations: %i",
device->version, device->class, device->subClass, device->protocol,
device->maxPacketSize, device->numConfigs);
gtk_text_buffer_insert_at_cursor(textDescriptionBuffer, string,strlen(string));
}
/* original version taken from bluefish's (doc_indent_selection) */
gint func_indent( GtkWidget *widget, GdkEventKey *kevent, Tbfwin *bfwin, gint opt) {
Tdocument *doc = bfwin->current_document;
if (!doc) return 0;
gint unindent = opt & FUNC_VALUE_0;
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 );
if ( gtk_text_iter_get_line_offset( &itstart ) > 0 ) {
gtk_text_iter_set_line_index( &itstart, 0 );
}
while ( gtk_text_iter_compare( &itstart, &itend ) < 0 ) {
GtkTextMark * cur;
cur = gtk_text_buffer_create_mark( doc->buffer, NULL, &itstart, TRUE );
if ( unindent ) {
/* when unindenting we try to set itend to the end of the indenting step
which might be a tab or 'tabsize' spaces, then we delete that part */
gboolean cont = TRUE;
gchar *buf = NULL;
gunichar cchar = gtk_text_iter_get_char( &itstart );
if ( cchar == 9 ) { /* 9 is ascii for tab */
itend = itstart;
cont = gtk_text_iter_forward_char( &itend );
buf = g_strdup( "\t" );
} else if ( cchar == 32 ) { /* 32 is ascii for space */
gint i = 0;
itend = itstart;
gtk_text_iter_forward_chars( &itend, main_v->props.editor_tab_width );
buf = gtk_text_buffer_get_text( doc->buffer, &itstart, &itend, FALSE );
DEBUG_MSG( "func_indent: tab_width=%d, strlen(buf)=%d, buf='%s'\n", main_v->props.editor_tab_width, strlen( buf ), buf );
while ( cont && buf[ i ] != '\0' ) {
cont = ( buf[ i ] == ' ' );
DEBUG_MSG( "func_indent: buf[%d]='%c'\n", i, buf[ i ] );
i++;
}
if ( !cont ) {
g_free ( buf );
}
} else {
cont = FALSE;
}
if ( cont ) {
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 );
}
} else { /* indent */
gint offsetstart = gtk_text_iter_get_offset( &itstart );
gchar *indentstring;
gint indentlen;
if ( main_v->props.view_bars & MODE_INDENT_WITH_SPACES ) {
indentstring = bf_str_repeat( " ", main_v->props.editor_tab_width );
indentlen = main_v->props.editor_tab_width;
} else {
indentstring = g_strdup( "\t" );
indentlen = 1;
}
gtk_text_buffer_insert( doc->buffer, &itstart, indentstring, indentlen );
doc_unre_add( doc, indentstring, offsetstart, offsetstart + indentlen, UndoInsert );
g_free( indentstring );
}
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 );
gtk_text_iter_forward_line( &itstart );
DEBUG_MSG( "func_indent: itstart at %d, itend at %d\n", gtk_text_iter_get_offset( &itstart ), gtk_text_iter_get_offset( &itend ) );
}
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 ) );
gtk_text_iter_set_line_offset( &iter, 0 );
if ( unindent ) {
gint deletelen = 0;
gchar *tmpstr, *tmp2str;
GtkTextIter itend = iter;
gtk_text_iter_forward_chars( &itend, main_v->props.editor_tab_width );
tmpstr = gtk_text_buffer_get_text( doc->buffer, &iter, &itend, FALSE );
tmp2str = bf_str_repeat( " ", main_v->props.editor_tab_width );
if ( tmpstr[ 0 ] == '\t' ) {
deletelen = 1;
} else if ( tmpstr && strncmp( tmpstr, tmp2str, main_v->props.editor_tab_width ) == 0 ) {
deletelen = main_v->props.editor_tab_width;
}
g_free( tmpstr );
g_free( tmp2str );
if ( deletelen ) {
itend = iter;
gtk_text_iter_forward_chars( &itend, deletelen );
gtk_text_buffer_delete( doc->buffer, &iter, &itend );
}
} else { /* indent */
gchar *indentstring;
gint indentlen;
if ( main_v->props.view_bars & MODE_INDENT_WITH_SPACES ) {
indentstring = bf_str_repeat( " ", main_v->props.editor_tab_width );
indentlen = main_v->props.editor_tab_width;
} else {
indentstring = g_strdup( "\t" );
indentlen = 1;
}
gtk_text_buffer_insert( doc->buffer, &iter, indentstring, indentlen );
g_free( indentstring );
}
}
return 1;
}
static void
load_buffer(gchar *file, gchar *file_type, void *unused)
{
GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
xmlDocPtr doc;
xmlNodePtr node;
GtkTextIter iter_start, iter_end;
/* parse the new file and put the result into newdoc */
doc = xmlParseFile(file);
/* in case something went wrong */
if(!doc)
return;
/* Get the root element node */
node = xmlDocGetRootElement(doc);
for(node = node; node != NULL; node = node->next)
if ( g_ascii_strcasecmp((char *)node->name, "html") == 0 &&
node->children )
break;
if(!node)
goto done;
for(node = node->children; node != NULL; node = node->next)
{
if ( g_ascii_strcasecmp((char *)node->name, "head") == 0 &&
node->children )
{
/* Search and apply the saved style in the META */
xmlNodePtr snode;
for(snode = node->children; snode != NULL; snode = snode->next)
{
if ( ( g_ascii_strcasecmp((char *)snode->name, "meta") == 0 ) &&
xmlHasProp(snode, BAD_CAST "http-equiv") )
{
xmlChar *key = xmlGetProp(snode, BAD_CAST "http-equiv");
xmlChar *content = xmlGetProp(snode, BAD_CAST "content");
if(g_ascii_strcasecmp((char *)key, "GCompris-doctype") == 0)
{
int style_index = get_style_index(gettext((char *)content));
apply_style(style_index);
gtk_combo_box_set_active(GTK_COMBO_BOX(gtk_combo_styles),
style_index);
}
if(g_ascii_strcasecmp((char *)key, "GCompris-color-style") == 0)
{
int cstyle_index = get_color_style_index(gettext((char *)content));
apply_color_style(cstyle_index);
gtk_combo_box_set_active(GTK_COMBO_BOX(gtk_combo_colors),
cstyle_index);
}
xmlFree(key);
xmlFree(content);
}
}
}
if ( g_ascii_strcasecmp((char *)node->name, "body") == 0 &&
node->children )
break;
}
if(!node)
goto done;
gtk_text_buffer_get_start_iter(buffer,
&iter_start);
gtk_text_buffer_get_end_iter(buffer,
&iter_end);
gtk_text_buffer_delete(buffer,
&iter_start,
&iter_end);
gtk_text_buffer_get_start_iter(buffer,
&iter_start);
for(node = node->children; node != NULL; node = node->next)
{
if ( g_ascii_strcasecmp((char *)node->name, "h1") == 0 ||
g_ascii_strcasecmp((char *)node->name, "h2") == 0 ||
g_ascii_strcasecmp((char *)node->name, "h3") == 0 ||
g_ascii_strcasecmp((char *)node->name, "link") == 0 ||
g_ascii_strcasecmp((char *)node->name, "p") == 0 )
{
xmlChar *content;
content = xmlNodeGetContent(node);
gtk_text_buffer_insert_with_tags_by_name(buffer,
&iter_start,
(char *)content,
strlen((char *)content),
(char *)node->name,
NULL);
xmlFree(content);
gtk_text_buffer_get_end_iter(buffer,
&iter_start);
gtk_text_buffer_insert(buffer,&iter_start, "\n", 1);
gtk_text_buffer_get_end_iter(buffer,
&iter_start);
}
}
done:
xmlFreeDoc(doc);
}
static gint console_key_handler (GtkWidget *cview, GdkEventKey *event,
gpointer p)
{
guint keyval = event->keyval;
guint upkey = gdk_keyval_to_upper(keyval);
GtkTextIter ins, end;
GtkTextBuffer *buf;
GtkTextMark *mark;
gint ctrl = 0;
#ifdef MAC_NATIVE
if (cmd_key(event)) {
if (upkey == GDK_C || upkey == GDK_X) {
/* allow regular copy/cut behavior */
return FALSE;
}
}
#endif
if (event->state & GDK_CONTROL_MASK) {
if (keyval == GDK_Control_L || keyval == GDK_Control_R) {
return FALSE;
} else if (upkey == GDK_C || upkey == GDK_X) {
/* allow regular copy/cut behavior */
return FALSE;
} else {
ctrl = 1;
}
}
buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(cview));
/* first find out where the insertion point and end are */
mark = gtk_text_buffer_get_insert(buf);
gtk_text_buffer_get_iter_at_mark(buf, &ins, mark);
gtk_text_buffer_get_end_iter(buf, &end);
/* if the insertion point is not on the last line, move it */
if (gtk_text_iter_get_line(&ins) != gtk_text_iter_get_line(&end)) {
gtk_text_buffer_place_cursor(buf, &end);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(cview), TRUE);
gtk_text_buffer_get_end_iter(buf, &ins);
}
if (keyval == GDK_Home && (event->state & GDK_SHIFT_MASK)) {
/* "select to start of line" */
GtkTextIter start = ins;
gtk_text_iter_set_line_index(&start, 2);
gtk_text_buffer_select_range(buf, &start, &ins);
return TRUE;
}
if (IS_BACKKEY(keyval)) {
/* if we're at the start of the input line, block backspacing */
if (gtk_text_iter_get_line_index(&ins) < 3) {
return TRUE;
}
} else if (keyval == GDK_Home || (ctrl && upkey == GDK_A)) {
/* go to start of typing area */
gtk_text_iter_set_line_index(&ins, 2);
gtk_text_buffer_place_cursor(buf, &ins);
return TRUE;
}
/* At this point 'ins' indicates the insertion point and
'end' points to the end of the current line of input,
These may or may not be the same thing.
*/
if (keyval == GDK_Return) {
/* execute the command, unless backslash-continuation
is happening */
ExecState *state;
gchar *thisline;
int contd = 0, err = 0;
state = g_object_get_data(G_OBJECT(cview), "ExecState");
thisline = console_get_current_line(buf, &ins);
if (thisline != NULL) {
g_strstrip(thisline);
contd = command_continues(state->line, thisline, &err);
g_free(thisline);
}
if (err) {
gui_errmsg(err);
} else if (contd) {
console_insert_prompt(buf, &end, "\n> ");
console_scroll_to_end(cview, buf, &end);
} else {
/* request execution of the completed command */
command_entered = 1;
}
event->keyval = GDK_End;
return FALSE;
}
if (keyval == GDK_Up || keyval == GDK_Down) {
/* up/down arrows: navigate the command history */
GtkTextIter start = ins;
const char *histline;
if (hpos == hlines && keyval == GDK_Up) {
g_free(hist0);
hist0 = console_get_current_line(buf, &ins);
}
histline = fetch_history_line(keyval);
if (histline != NULL || keyval == GDK_Down) {
gtk_text_iter_set_line_index(&start, 2);
gtk_text_buffer_delete(buf, &start, &end);
if (histline != NULL) {
gtk_text_buffer_insert(buf, &start, histline, -1);
} else if (hpos == hlines && hist0 != NULL) {
gtk_text_buffer_insert(buf, &start, hist0, -1);
}
}
return TRUE;
}
if (keyval == GDK_Tab) {
/* tab completion for gretl commands, variable names */
return console_complete_word(buf, &ins);
}
return FALSE;
}
/* Format->Renumber All Sections */
void
action_renumber_all_sections(GtkAction *action, I7Document *document)
{
GtkTextIter pos, end;
int volume = 1, book = 1, part = 1, chapter = 1, section = 1;
GtkTextBuffer *buffer = GTK_TEXT_BUFFER(i7_document_get_buffer(document));
gtk_text_buffer_get_start_iter(buffer, &pos);
/* Renumbering sections counts as one action for Undo */
gtk_text_buffer_begin_user_action(buffer);
while(gtk_text_iter_get_char(&pos) != 0) {
if(gtk_text_iter_get_char(&pos) != '\n') {
gtk_text_iter_forward_line(&pos);
continue;
}
gtk_text_iter_forward_line(&pos);
end = pos;
gboolean not_last = gtk_text_iter_forward_line(&end);
if(!not_last || gtk_text_iter_get_char(&end) == '\n') {
/* Preceded and followed by a blank line,
or only preceded by one and current line is last line */
/* Get the entire line and its line number, chop the \n */
gchar *text = gtk_text_iter_get_text(&pos, &end);
gchar *lcase = g_utf8_strdown(text, -1);
gchar *title = strchr(text, '-');
if(title && g_str_has_suffix(title, "\n"))
*(strrchr(title, '\n')) = '\0'; /* remove trailing \n */
gchar *newtitle;
if(g_str_has_prefix(lcase, "volume")) {
newtitle = g_strdup_printf("Volume %d %s\n", volume++, title);
gtk_text_buffer_delete(buffer, &pos, &end);
gtk_text_buffer_insert(buffer, &pos, newtitle, -1);
g_free(newtitle);
book = part = chapter = section = 1;
} else if(g_str_has_prefix(lcase, "book")) {
newtitle = g_strdup_printf("Book %d %s\n", book++, title);
gtk_text_buffer_delete(buffer, &pos, &end);
gtk_text_buffer_insert(buffer, &pos, newtitle, -1);
g_free(newtitle);
part = chapter = section = 1;
} else if(g_str_has_prefix(lcase, "part")) {
newtitle = g_strdup_printf("Part %d %s\n", part++, title);
gtk_text_buffer_delete(buffer, &pos, &end);
gtk_text_buffer_insert(buffer, &pos, newtitle, -1);
g_free(newtitle);
chapter = section = 1;
} else if(g_str_has_prefix(lcase, "chapter")) {
newtitle = g_strdup_printf("Chapter %d %s\n", chapter++, title);
gtk_text_buffer_delete(buffer, &pos, &end);
gtk_text_buffer_insert(buffer, &pos, newtitle, -1);
g_free(newtitle);
section = 1;
} else if(g_str_has_prefix(lcase, "section")) {
newtitle = g_strdup_printf("Section %d %s\n", section++, title);
gtk_text_buffer_delete(buffer, &pos, &end);
gtk_text_buffer_insert(buffer, &pos, newtitle, -1);
g_free(newtitle);
}
g_free(text);
g_free(lcase);
}
}
gtk_text_buffer_end_user_action(buffer);
}
void Gobby::OperationOpen::read_finish()
{
// If the last character is a newline character, remove it.
GtkTextIter end_iter, test_iter;
gtk_text_buffer_get_end_iter(m_content, &end_iter);
test_iter = end_iter;
if(gtk_text_iter_backward_char(&test_iter))
{
if(gtk_text_iter_get_char(&test_iter) == '\n')
{
gtk_text_buffer_delete(
m_content, &test_iter, &end_iter);
}
}
gtk_text_buffer_set_modified(m_content, FALSE);
GtkTextIter insert_iter;
GtkTextMark* insert = gtk_text_buffer_get_insert(m_content);
gtk_text_buffer_get_iter_at_mark(m_content, &insert_iter, insert);
InfUser* user = INF_USER(g_object_new(
INF_TEXT_TYPE_USER,
"id", 1,
"flags", INF_USER_LOCAL,
"name", m_preferences.user.name.get().c_str(),
/* The user is made active when the user
* switches to the document. */
"status", INF_USER_INACTIVE,
"hue", m_preferences.user.hue.get(),
"caret-position", gtk_text_iter_get_offset(&insert_iter),
static_cast<void*>(NULL)));
InfUserTable* user_table = inf_user_table_new();
inf_user_table_add_user(user_table, user);
g_object_unref(user);
InfTextGtkBuffer* text_gtk_buffer =
inf_text_gtk_buffer_new(m_content, user_table);
g_object_unref(user_table);
ConnectionManager& connection_manager =
get_browser().get_connection_manager();
InfCommunicationManager* communication_manager =
connection_manager.get_communication_manager();
InfBrowser* browser = m_parent.get_browser();
InfIo* io;
g_object_get(G_OBJECT(browser), "io", &io, NULL);
InfTextSession* session = inf_text_session_new_with_user_table(
communication_manager, INF_TEXT_BUFFER(text_gtk_buffer), io,
user_table, INF_SESSION_RUNNING, NULL, NULL);
g_object_unref(io);
g_object_unref(text_gtk_buffer);
InfRequest* request = inf_browser_add_note(
m_parent.get_browser(), m_parent.get_browser_iter(),
m_name.c_str(), "InfText", NULL,
INF_SESSION(session), TRUE,
on_request_finished_static, this);
g_object_unref(session);
if(request != NULL)
{
m_request = request;
g_object_ref(m_request);
// TODO: We can remove the node watch here, but need to have
// the browser available in on_request_finished then. Maybe
// just disconnect the signal, or bind it.
}
}
static void* fx_many_sms_send_func(void* data)
{
FxMany* fxmany = (FxMany*)data;
GtkTreeModel *model;
GtkTreeIter iter;
gchar *sipuri;
gchar *name;
GtkTextIter begin;
GtkTextIter end;
const gchar *text;
gchar alertmsg[1024];
Conversation *conv;
gint daycount;
gint monthcount;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(fxmany->selected));
gtk_text_buffer_get_start_iter(fxmany->send_buffer , &begin);
gtk_text_buffer_get_end_iter(fxmany->send_buffer , &end);
text = gtk_text_buffer_get_text(fxmany->send_buffer , &begin , &end , TRUE);
if(*text == '\0') {
gdk_threads_enter();
fx_many_add_information(fxmany , _("Please input the contents of message"));
gdk_threads_leave();
g_thread_exit(0);
}
gdk_threads_enter();
gtk_text_buffer_delete(fxmany->send_buffer , &begin , &end);
gdk_threads_leave();
if(gtk_tree_model_get_iter_root(model , &iter)){
do{
gtk_tree_model_get(model, &iter, C_NAME_COL
, &name, C_SIPURI_COL, &sipuri, -1);
conv = fetion_conversation_new(fxmany->fxmain->user,
sipuri, NULL);
if(fetion_conversation_send_sms_to_phone_with_reply(conv,
text, &daycount, &monthcount) > 0)
sprintf(alertmsg , _("Mesage \"%s\" has been"
" sent to \"%s\". You have sent %d today and "
"%d this month\n"),
text , name , daycount , monthcount);
else
sprintf(alertmsg,
_("Mesage \"%s\" did not send to \"%s\"\n"),
text , name);
gdk_threads_enter();
fx_many_add_information(fxmany , alertmsg);
gdk_threads_leave();
g_free(conv);
g_free(name);
g_free(sipuri);
}while(gtk_tree_model_iter_next(model , &iter));
}
return NULL;
}
type_noeud_comment *validate_comments(type_noeud_comment *anchor_comment, GtkWidget * entry)
{
GtkTextIter start, end, iter;
GtkTextBuffer *buffer;
char *text;
gboolean is_not_the_end;
type_noeud_comment *pt_comment;
int longueur;
type_noeud_comment *pt_prec = NULL, *pt_fin = NULL;
pt_comment = anchor_comment;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(entry));
gtk_text_buffer_get_line_count(buffer);
gtk_text_buffer_get_bounds(buffer, &start, &end);
iter = start;
do
{
is_not_the_end = gtk_text_iter_forward_line(&iter);
text = gtk_text_iter_get_text(&start, &iter);
start = iter;
if (pt_comment == NULL)
{
pt_comment = ALLOCATION(type_noeud_comment);
pt_comment->suiv = NULL;
if (anchor_comment == NULL)
{
anchor_comment = pt_comment;
}
else
{
pt_prec->suiv = pt_comment;
}
}
longueur = strlen(text) + 1;
if (longueur > TAILLE_CHAINE)
{
printf("WARNING: la chaine de char: %s a ete tronquee dans validate_comments car sa taille est superieure a %d\n", text, TAILLE_CHAINE);
longueur = TAILLE_CHAINE;
}
/* recopie dans le champs comment en rajoutant un % au debut s'il a ete oublie */
/* on ne fait rien pour les lignes vides */
if (test_comment(text) == 1 || empty_line(text) == 1)
{
memcpy(pt_comment->chaine, text, longueur * sizeof(char));
}
else
{
pt_comment->chaine[0] = '%';
memcpy(&(pt_comment->chaine[1]), text, longueur * sizeof(char));
}
pt_prec = pt_comment;
pt_comment = pt_comment->suiv;
g_free (text);
}
while (is_not_the_end == TRUE);
if (strlen(pt_prec->chaine) > 0 && pt_prec->chaine[strlen(pt_prec->chaine)-1] != '\n')
{
strcat(pt_prec->chaine, "\n");
}
/* Suppression des donnees du buffer */
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_delete(buffer, &start, &end);
/* Suppression du reste de la liste chainee des commentaire ==> utile si on a supprime des commentaires*/
pt_fin = pt_prec;
while (pt_comment != NULL)
{
pt_prec = pt_comment;
pt_comment = pt_comment->suiv;
free(pt_prec);
}
pt_fin->suiv = NULL;
return anchor_comment;
}
static gboolean
editor_application_window_key_press_event (GtkWidget *widget,
GdkEventKey *event)
{
EditorApplicationWindow *window = EDITOR_APPLICATION_WINDOW (widget);
if (event->keyval == GDK_KEY_KP_Tab || event->keyval == GDK_KEY_Tab)
{
GtkTextMark *mark;
smie_gtk_source_buffer_context_t context;
gint indent, current_indent;
GtkTextIter iter, start_iter, end_iter;
memset (&context, 0, sizeof (smie_gtk_source_buffer_context_t));
context.buffer = window->buffer;
mark = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (window->buffer));
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (window->buffer),
&iter,
mark);
gtk_text_iter_assign (&context.iter, &iter);
indent = smie_indenter_calculate (window->indenter, &context);
if (indent < 0)
{
g_printf ("indent: undetermined\n");
return TRUE;
}
else
g_printf ("indent: %d\n", indent);
/* Point START_ITER to the beginning of the line. */
gtk_text_iter_assign (&start_iter, &iter);
while (!gtk_text_iter_is_start (&start_iter)
&& !gtk_text_iter_starts_line (&start_iter)
&& gtk_text_iter_backward_char (&start_iter))
;
/* Point END_ITER to the end of the indent and count the offset. */
gtk_text_iter_assign (&end_iter, &start_iter);
current_indent = 0;
while (!gtk_text_iter_is_end (&end_iter)
&& !gtk_text_iter_ends_line (&end_iter)
&& g_unichar_isspace (gtk_text_iter_get_char (&end_iter))
&& gtk_text_iter_forward_char (&end_iter))
current_indent++;
/* Replace the current indent if it doesn't match the computed one. */
if (indent < current_indent)
{
gtk_text_iter_forward_chars (&start_iter, indent);
gtk_text_buffer_delete (GTK_TEXT_BUFFER (window->buffer),
&start_iter, &end_iter);
}
else if (indent > current_indent)
{
gchar *text = g_new0 (gchar, indent - current_indent);
memset (text, ' ', indent * sizeof (gchar));
gtk_text_buffer_insert (GTK_TEXT_BUFFER (window->buffer),
&start_iter,
text,
indent - current_indent);
g_free (text);
}
return TRUE;
}
return GTK_WIDGET_CLASS (editor_application_window_parent_class)->key_press_event (widget, event);
}
static void about_update_stats(void)
{
if (stats_text_buffer != NULL)
{
GtkTextIter start, end, iter;
gchar buf[1024];
gtk_text_buffer_get_start_iter(stats_text_buffer, &start);
gtk_text_buffer_get_end_iter(stats_text_buffer, &end);
gtk_text_buffer_delete(stats_text_buffer, &start, &end);
gtk_text_buffer_get_iter_at_offset(stats_text_buffer, &iter, 0);
gtk_text_buffer_insert_with_tags_by_name(stats_text_buffer, &iter,
(_("Session statistics\n")), -1,
"underlined-list-title", NULL);
if (prefs_common.date_format) {
struct tm *lt;
gint len = 100;
gchar date[len];
lt = localtime(&session_stats.time_started);
fast_strftime(date, len, prefs_common.date_format, lt);
g_snprintf(buf, sizeof(buf), _("Started: %s\n"),
lt ? date : ctime(&session_stats.time_started));
} else
g_snprintf(buf, sizeof(buf), _("Started: %s\n"),
ctime(&session_stats.time_started));
gtk_text_buffer_insert_with_tags_by_name(stats_text_buffer, &iter, buf, -1,
"indented-list-item", NULL);
gtk_text_buffer_insert(stats_text_buffer, &iter, "\n", 1);
gtk_text_buffer_insert_with_tags_by_name(stats_text_buffer, &iter,
(_("Incoming traffic\n")), -1,
"underlined-list-title", NULL);
g_snprintf(buf, sizeof(buf), _("Received messages: %d\n"),
session_stats.received);
gtk_text_buffer_insert_with_tags_by_name(stats_text_buffer, &iter, buf, -1,
"indented-list-item", "bold", NULL);
gtk_text_buffer_insert(stats_text_buffer, &iter, "\n", 1);
gtk_text_buffer_insert_with_tags_by_name(stats_text_buffer, &iter,
(_("Outgoing traffic\n")), -1,
"underlined-list-title", NULL);
g_snprintf(buf, sizeof(buf), _("New/redirected messages: %d\n"),
session_stats.sent);
gtk_text_buffer_insert_with_tags_by_name(stats_text_buffer, &iter, buf, -1,
"indented-list-item", NULL);
g_snprintf(buf, sizeof(buf), _("Replied messages: %d\n"),
session_stats.replied);
gtk_text_buffer_insert_with_tags_by_name(stats_text_buffer, &iter, buf, -1,
"indented-list-item", NULL);
g_snprintf(buf, sizeof(buf), _("Forwarded messages: %d\n"),
session_stats.forwarded);
gtk_text_buffer_insert_with_tags_by_name(stats_text_buffer, &iter, buf, -1,
"indented-list-item", NULL);
g_snprintf(buf, sizeof(buf), _("Total outgoing messages: %d\n"),
(session_stats.sent + session_stats.replied +
session_stats.forwarded));
gtk_text_buffer_insert_with_tags_by_name(stats_text_buffer, &iter, buf, -1,
"indented-list-item", "bold", NULL);
}
}
void
gtk_c_update_hexview(GtkTreeSelection *selection, gpointer userdata)
{
GtkWidget *textview;
GtkTextBuffer *buffer;
GtkTreeIter iter;
GtkTextIter iter2, start, end;
GtkTreeModel *model;
struct gtk_s_helper *helper;
u_int8_t row, mode, *packet;
u_int16_t length, oset;
int32_t j, line;
register u_int i;
register int s1, s2;
register int nshorts;
char hexstuff[HEXDUMP_SHORTS_PER_LINE*HEXDUMP_HEXSTUFF_PER_SHORT+1], *hsp;
char asciistuff[ASCII_LINELENGTH+1], *asp;
char tmp_str[70];
u_int32_t maxlength = HEXDUMP_SHORTS_PER_LINE;
gchar *out;
j = 0;
line = 0;
oset = 0;
length = 0;
packet = NULL;
helper = (struct gtk_s_helper *) userdata;
textview = lookup_widget(GTK_WIDGET(helper->notebook), "main_vhv2_texthex");
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview));
/* First delete the buffer */
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (buffer), &start, 0);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (buffer), &end,
gtk_text_buffer_get_char_count (GTK_TEXT_BUFFER (buffer)));
gtk_text_buffer_delete (GTK_TEXT_BUFFER (buffer), &start, &end);
/* We need to get the pointer to the packet selected in the other window */
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
gtk_tree_model_get(model, &iter, 0, &row, -1);
} else {/* TODO: do a proper select */
row = 0;
}
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (buffer), &iter2, 0);
mode = gtk_notebook_get_current_page(GTK_NOTEBOOK(helper->notebook));
packet = protocols[mode].stats[row].packet;
length = (protocols[mode].stats[row].header->len < SNAPLEN) ? protocols[mode].stats[row].header->len : SNAPLEN;
nshorts = length / sizeof(u_int16_t);
i = 0;
hsp = hexstuff; asp = asciistuff;
while (--nshorts >= 0) {
s1 = *packet++;
s2 = *packet++;
(void)snprintf(hsp, sizeof(hexstuff) - (hsp - hexstuff),
" %02x%02x", s1, s2);
hsp += HEXDUMP_HEXSTUFF_PER_SHORT;
*(asp++) = (isgraph(s1) ? s1 : '.');
*(asp++) = (isgraph(s2) ? s2 : '.');
i++;
if (i >= maxlength) {
*hsp = *asp = '\0';
snprintf(tmp_str, 70, "0x%04x: %-*s %s\n",
oset, HEXDUMP_HEXSTUFF_PER_LINE,
hexstuff, asciistuff);
/* We need to convert to valid UTF-8; if not, it is not displayed :( */
out = g_convert(tmp_str, -1,"UTF-8","ISO8859-1",NULL,NULL,NULL);
if (out == NULL) {
return; /* handle error */
}
gtk_text_buffer_insert(buffer, &iter2, out, -1);
g_free(out);
i = 0; hsp = hexstuff; asp = asciistuff;
oset += HEXDUMP_BYTES_PER_LINE;
j++;
}
}
if (length & 1) {
s1 = *packet++;
(void)snprintf(hsp, sizeof(hexstuff) - (hsp - hexstuff),
" %02x", s1);
hsp += 3;
*(asp++) = (isgraph(s1) ? s1 : '.');
++i;
}
if (i > 0) {
*hsp = *asp = '\0';
snprintf(tmp_str, 70, "0x%04x: %-*s %s\n",
oset, HEXDUMP_HEXSTUFF_PER_LINE,
hexstuff, asciistuff);
/* We need to convert to valid UTF-8; if not, it is not displayed :( */
out = g_convert(tmp_str, -1,"UTF-8","ISO8859-1",NULL,NULL,NULL);
if (out == NULL) {
return; /* handle error */
}
gtk_text_buffer_insert(buffer, &iter2, out, -1);
g_free(out);
}
}
static void
dialog_response(GtkWidget *dialog,
gint response_id,
gpointer user_data)
{
switch(response_id)
{
case CONNECT_TO_WORLD:
{
GtkWidget *tree = user_data;
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
GList *selected_rows = gtk_tree_selection_get_selected_rows(selection, NULL);
GtkTreePath *path = selected_rows->data;
//gint *path_ind = gtk_tree_path_get_indices(path);
GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree));
GtkTreeIter iter;
gtk_tree_model_get_iter(model, &iter, path);
GValue hostname_value = {0};
GValue port_value = {0};
gtk_tree_model_get_value(model, &iter, WORLD_HOSTNAME, &hostname_value);
gtk_tree_model_get_value(model, &iter, WORLD_PORT, &port_value);
char *hostname = strdup(g_value_get_string(&hostname_value));
unsigned short port = g_value_get_int(&port_value);
g_value_unset(&hostname_value);
g_value_unset(&port_value);
/* save off old tab_completion file */
tab_complete_save();
/* set up the tab completion file */
char *home_dir = getenv("HOME");
int len = strlen(home_dir) + MAX_LINE_LEN + 18 + 1;
char *tab_complete_name = malloc(sizeof(*tab_complete_name) * len);
/* create each level of the directory structure since a -p
* type option doesn't exist AFAIK */
snprintf(tab_complete_name, len, "%s/.mudc/worlds/%s", home_dir, hostname);
mkdir(tab_complete_name, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
snprintf(tab_complete_name, len, "%s/.mudc/worlds/%s/tab", home_dir, hostname);
FILE *tmp_file = fopen(tab_complete_name, "r");
if( !tmp_file )
tmp_file = fopen(tab_complete_name, "w");
fclose(tmp_file);
tab_complete_set_wordlist_file(tab_complete_name);
/* load macro definitions */
len = strlen(home_dir) + MAX_LINE_LEN + 21 + 1;
char *macros_filename = malloc(sizeof(*macros_filename) * len);
snprintf(macros_filename, len, "%s/.mudc/worlds/%s/macros", home_dir, hostname);
tmp_file = fopen(tab_complete_name, "r");
if( !tmp_file )
tmp_file = fopen(tab_complete_name, "w");
fclose(tmp_file);
macros_load(macros_filename);
/* disconnect from current telnet connection */
telnet_close(MUDC.telnet);
MUDC.telnet = NULL;
/* clear text buffer */
GtkTextIter start, end;
gtk_text_buffer_get_start_iter(MUDC.widgets.text_buffer, &start);
gtk_text_buffer_get_end_iter(MUDC.widgets.text_buffer, &end);
gtk_text_buffer_delete(MUDC.widgets.text_buffer, &start, &end);
/* fire up the telnet connection */
MUDC.telnet = telnet_connect(hostname, port);
if(MUDC.telnet == NULL)
{
GtkWidget * dialog2 = gtk_message_dialog_new(GTK_WINDOW(dialog),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Error connecting to %s:%d",
hostname, port);
gtk_dialog_run(GTK_DIALOG(dialog2));
gtk_widget_destroy(dialog2);
}
free(hostname);
gtk_widget_destroy(dialog);
break;
}
case ADD_WORLD:
{
GtkWidget *dialog2 = gtk_dialog_new_with_buttons("Add World",
GTK_WINDOW(MUDC.widgets.main_window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
"Add", ADD_WORLD,
"Cancel", CANCEL,
NULL);
gtk_window_set_default_size(GTK_WINDOW(dialog2), 320, 200);
GtkWidget *content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog2));
GtkWidget *ts1 = gtk_table_new(3, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(ts1), 10);
gtk_table_set_col_spacings(GTK_TABLE(ts1), 10);
gtk_box_pack_start(GTK_BOX(content_area), ts1, TRUE, FALSE, 0);
gtk_table_attach_defaults(GTK_TABLE(ts1), gtk_label_new("World Name"), 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(ts1), gtk_label_new("Hostname"), 0, 1, 1, 2);
gtk_table_attach_defaults(GTK_TABLE(ts1), gtk_label_new("Port"), 0, 1, 2, 3);
GtkWidget *name_entry = gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(ts1), name_entry, 1, 2, 0, 1);
GtkWidget *hostname_entry = gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(ts1), hostname_entry, 1, 2, 1, 2);
GtkWidget *port_entry = gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(ts1), port_entry, 1, 2, 2, 3);
GtkWidget *widgets[] = {user_data, name_entry, hostname_entry, port_entry};
g_signal_connect(dialog2, "response",
G_CALLBACK(add_world_response),
widgets);
gtk_widget_show_all(dialog2);
gtk_dialog_run(GTK_DIALOG(dialog2));
gtk_widget_destroy(dialog2);
break;
}
case REMOVE_WORLD:
{
GtkWidget *tree = user_data;
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
GList *selected_rows = gtk_tree_selection_get_selected_rows(selection, NULL);
GtkTreePath *path = selected_rows->data;
GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree));
GtkTreeIter iter;
gtk_tree_model_get_iter(model, &iter, path);
gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
write_to_config(GTK_LIST_STORE(model));
break;
}
};
}
/**
* class_properties_set_class:
* @cprop: a #ClassProperties widget
* @classname: a DN to display information for
*
* Adjusts the display to show @classname's properties
*/
void
class_properties_set_class (ClassProperties *cprop, const gchar *classname)
{
g_return_if_fail (IS_CLASS_PROPERTIES (cprop));
GtkTextBuffer *tbuffer;
GtkTextIter start, end;
GdaLdapClass *lcl;
GtkTextIter current;
guint i;
tbuffer = cprop->priv->text;
gtk_text_buffer_get_start_iter (tbuffer, &start);
gtk_text_buffer_get_end_iter (tbuffer, &end);
gtk_text_buffer_delete (tbuffer, &start, &end);
if (!classname || !*classname)
return;
lcl = t_connection_get_class_info (cprop->priv->tcnc, classname);
if (!lcl) {
ui_show_message (GTK_WINDOW (gtk_widget_get_toplevel ((GtkWidget*) cprop)),
"%s", _("Could not get information about LDAP class"));
return;
}
gtk_text_buffer_get_start_iter (tbuffer, ¤t);
/* Description */
if (lcl->description) {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
_("Description:"), -1,
"section", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, " ", -1, "starter", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, lcl->description, -1,
"data", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
}
/* OID */
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
_("Class OID:"), -1,
"section", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, " ", -1, "starter", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, lcl->oid, -1,
"data", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
/* Kind */
const gchar *kind;
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
_("Class kind:"), -1,
"section", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", 1);
gtk_text_buffer_insert_pixbuf (tbuffer, ¤t, ui_connection_ldap_icon_for_class_kind (lcl->kind));
kind = ui_connection_ldap_class_kind_to_string (lcl->kind);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, " ", -1, "starter", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, kind, -1,
"data", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
/* Class name */
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
ngettext ("Class name:", "Class names:", lcl->nb_names), -1,
"section", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
for (i = 0; i < lcl->nb_names; i++) {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, " ", -1, "starter", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, lcl->names[i], -1,
"data", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
}
/* obsolete */
if (lcl->obsolete) {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
_("This LDAP class is obsolete"), -1,
"error", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
}
/* req. attributes */
if (lcl->nb_req_attributes > 0) {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
ngettext ("Required attribute:",
"Required attributes:",
lcl->nb_req_attributes), -1,
"section", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
for (i = 0; i < lcl->nb_req_attributes; i++) {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, " ", -1, "starter", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, lcl->req_attributes[i], -1,
"data", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
}
}
/* opt. attributes */
if (lcl->nb_opt_attributes > 0) {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
ngettext ("Optional attribute:",
"Optional attributes:",
lcl->nb_opt_attributes), -1,
"section", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
for (i = 0; i < lcl->nb_opt_attributes; i++) {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, " ", -1, "starter", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, lcl->opt_attributes[i], -1,
"data", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
}
}
/* children */
if (lcl->children) {
gint nb;
GSList *list;
nb = g_slist_length (lcl->children);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
ngettext ("Children class:",
"Children classes:",
nb), -1,
"section", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
for (list = lcl->children; list; list = list->next) {
GdaLdapClass *olcl;
gchar *tmp;
GtkTextTag *tag;
olcl = (GdaLdapClass*) list->data;
gtk_text_buffer_insert_pixbuf (tbuffer, ¤t,
ui_connection_ldap_icon_for_class_kind (olcl->kind));
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, " ", -1, "starter", NULL);
tag = gtk_text_buffer_create_tag (tbuffer, NULL,
"foreground", "blue",
"weight", PANGO_WEIGHT_NORMAL,
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
tmp = olcl->names [0];
g_object_set_data_full (G_OBJECT (tag), "class",
g_strdup (tmp), g_free);
gtk_text_buffer_insert_with_tags (tbuffer, ¤t,
tmp, -1,
tag, NULL);
if (olcl->description) {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
" (", -1,
"data", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
olcl->description, -1,
"data", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
")", -1,
"data", NULL);
}
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
}
}
/* parents */
if (lcl->parents) {
gint nb;
GSList *list;
nb = g_slist_length (lcl->parents);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
ngettext ("Inherited class:",
"Inherited classes:",
nb), -1,
"section", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
for (list = lcl->parents; list; list = list->next) {
GdaLdapClass *olcl;
gchar *tmp;
GtkTextTag *tag;
olcl = (GdaLdapClass*) list->data;
gtk_text_buffer_insert_pixbuf (tbuffer, ¤t,
ui_connection_ldap_icon_for_class_kind (olcl->kind));
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, " ", -1, "starter", NULL);
tag = gtk_text_buffer_create_tag (tbuffer, NULL,
"foreground", "blue",
"weight", PANGO_WEIGHT_NORMAL,
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
tmp = olcl->names [0];
g_object_set_data_full (G_OBJECT (tag), "class",
g_strdup (tmp), g_free);
gtk_text_buffer_insert_with_tags (tbuffer, ¤t,
tmp, -1,
tag, NULL);
if (olcl->description) {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
" (", -1,
"data", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
olcl->description, -1,
"data", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
")", -1,
"data", NULL);
}
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
}
}
if (cprop->priv->text_search && gtk_widget_get_visible (cprop->priv->text_search))
text_search_rerun (TEXT_SEARCH (cprop->priv->text_search));
}
/**
* undo_redo:
* @w: not used
* @data: not used
*
* executes a redo request on the current document
**/
void undo_redo(UndoMain *undostruct)
{
UndoInfo *redoinfo;
GtkTextView *textview;
GtkTextBuffer *buffer;
GtkTextIter iter, start_iter, end_iter;
GtkTextMark *mark;
g_return_if_fail(undostruct != NULL);
if (undostruct->redo == NULL) return;
redoinfo = (UndoInfo *)undostruct->redo->data;
g_return_if_fail (redoinfo != NULL);
undostruct->undo = g_list_prepend(undostruct->undo, redoinfo);
undostruct->redo = g_list_remove(undostruct->redo, redoinfo);
textview = undostruct->textview;
buffer = gtk_text_view_get_buffer(textview);
undo_block(undostruct);
/* Check if there is a selection active */
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
gtk_text_buffer_place_cursor(buffer, &iter);
/* Move the view to the right position. */
gtk_adjustment_set_value(textview->vadjustment,
redoinfo->window_position);
switch (redoinfo->action) {
case UNDO_ACTION_INSERT:
gtk_text_buffer_get_iter_at_offset
(buffer, &iter, redoinfo->start_pos);
gtk_text_buffer_insert(buffer, &iter, redoinfo->text, -1);
debug_print("redo: UNDO_ACTION_DELETE: %d: %s\n",
redoinfo->start_pos, redoinfo->text);
break;
case UNDO_ACTION_DELETE:
gtk_text_buffer_get_iter_at_offset
(buffer, &start_iter, redoinfo->start_pos);
gtk_text_buffer_get_iter_at_offset
(buffer, &end_iter, redoinfo->end_pos);
gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
debug_print("redo: UNDO_ACTION_INSERT: %d: delete %d chars\n",
redoinfo->start_pos,
redoinfo->end_pos - redoinfo->start_pos);
break;
case UNDO_ACTION_REPLACE_DELETE:
gtk_text_buffer_get_iter_at_offset
(buffer, &start_iter, redoinfo->start_pos);
gtk_text_buffer_get_iter_at_offset
(buffer, &end_iter, redoinfo->end_pos);
gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
debug_print("redo: UNDO_ACTION_REPLACE: %d: %s\n",
redoinfo->start_pos, redoinfo->text);
/* "pull" another data structure from the list */
redoinfo = (UndoInfo *)undostruct->redo->data;
g_return_if_fail(redoinfo != NULL);
undostruct->undo = g_list_prepend(undostruct->undo, redoinfo);
undostruct->redo = g_list_remove(undostruct->redo, redoinfo);
g_return_if_fail(redoinfo->action == UNDO_ACTION_REPLACE_INSERT);
gtk_text_buffer_insert(buffer, &start_iter, redoinfo->text, -1);
debug_print("redo: UNDO_ACTION_REPLACE: %d: %s\n",
redoinfo->start_pos, redoinfo->text);
break;
case UNDO_ACTION_REPLACE_INSERT:
g_warning("redo: this should not happen: UNDO_REPLACE_INSERT");
break;
default:
g_assert_not_reached();
break;
}
gtk_widget_queue_draw(GTK_WIDGET(textview));
undostruct->change_state_func(undostruct,
UNDO_STATE_TRUE, UNDO_STATE_UNCHANGED,
undostruct->change_state_data);
if (undostruct->redo == NULL)
undostruct->change_state_func(undostruct,
UNDO_STATE_UNCHANGED,
UNDO_STATE_FALSE,
undostruct->change_state_data);
undo_unblock(undostruct);
}
static void
message_send(HybridConversation *conv)
{
GtkTextBuffer *send_tb;
GtkTextIter start_iter;
GtkTextIter stop_iter;
GtkTextView *textview;
GSList *pos;
HybridChatWindow *chat;
gint current_page;
gchar *text;
HybridBuddy *buddy;
HybridAccount *account;
HybridModule *module;
HybridIMOps *ops;
/* find the current chat panel. */
current_page = gtk_notebook_current_page(GTK_NOTEBOOK(conv->notebook));
for (pos = conv->chat_buddies; pos; pos = pos->next) {
chat = (HybridChatWindow*)pos->data;
if (current_page == gtk_notebook_page_num(
GTK_NOTEBOOK(conv->notebook), chat->vbox)) {
goto chat_found;
}
}
hybrid_debug_error("conv", "FATAL, can't find chat panel");
return;
chat_found:
textview = GTK_TEXT_VIEW(chat->sendtext);
send_tb = gtk_text_view_get_buffer(textview);
gtk_text_buffer_get_start_iter(send_tb, &start_iter);
gtk_text_buffer_get_end_iter(send_tb, &stop_iter);
text = gtk_text_buffer_get_text(send_tb, &start_iter, &stop_iter, TRUE);
if (*text == '\0') {
/* Yes, nothing was input, just return. */
return;
}
gtk_text_buffer_delete(send_tb, &start_iter, &stop_iter);
account = chat->account;
/* Add message to the textview. */
text_ops->append(chat->textview, account, NULL, text, time(NULL));
hybrid_logs_write(chat->logs, account->nickname, text, TRUE);
/* Call the protocol hook function. */
if (IS_SYSTEM_CHAT(chat)) {
buddy = chat->data;
module = account->proto;
ops = module->info->im_ops;
if (chat->typing_source) {
g_source_remove(chat->typing_source);
chat->typing_source = 0;
chat->is_typing = FALSE;
}
if (ops->chat_send_typing) {
ops->chat_send_typing(account, buddy, INPUT_STATE_ACTIVE);
}
if (ops->chat_send) {
ops->chat_send(account, buddy, text);
}
}
if (IS_USER_DEFINED_CHAT(chat)) {
if (chat->callback) {
chat->callback(account, text);
}
}
}
/**
Sprawdzenie słowa, na którym aktualnie znajduje się kursor. Ewentualne dodanie do słownika.
@param[in] item element menu.
@param[in] data wskaźnik na wartość.
*/
static void WhatCheck (GtkMenuItem *item, gpointer data) {
GtkWidget *dialog;
GtkTextIter start, end;
char *word;
gunichar *wword;
//load_dictionary_from_menu(&dict);
// Znajdujemy pozycję kursora
gtk_text_buffer_get_iter_at_mark(editor_buf, &start,
gtk_text_buffer_get_insert(editor_buf));
// Jeśli nie wewnątrz słowa, kończymy
if (!gtk_text_iter_inside_word(&start)) {
dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"Kursor musi być w środku słowa");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return;
}
// Znajdujemy początek i koniec słowa, a potem samo słowo
end = start;
gtk_text_iter_backward_word_start(&start);
gtk_text_iter_forward_word_end(&end);
word = gtk_text_iter_get_text(&start, &end);
// Zamieniamy na wide char (no prawie)
wword = g_utf8_to_ucs4_fast(word, -1, NULL);
if (!make_lowercase(wword)) {
dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
"Podane słowo nie jest słowem słownikowym.");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
else {
// Sprawdzamy
if (dictionary_find(dict, (wchar_t *)wword)) {
dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,
"Wszystko w porządku,\nśpij spokojnie");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
else {
// Czas korekty
GtkWidget *vbox, *label, *combo;
struct word_list hints;
int i;
wchar_t **words;
dictionary_hints(dict, (wchar_t *)wword, &hints);
words = (wchar_t **) word_list_get(&hints);
dialog = gtk_dialog_new_with_buttons("Korekta", NULL, 0,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
GTK_STOCK_ADD,
GTK_RESPONSE_APPLY,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
NULL);
// W treści dialogu dwa elementy
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
// Tekst
label = gtk_label_new("Słowo nie znajduje się w słowniku. Wybierz \njedną z propozycji lub dodaj słowa do słownika.");
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 1);
// Spuszczane menu
combo = gtk_combo_box_text_new();
for (i = 0; i < word_list_size(&hints); i++) {
// Combo box lubi mieć Gtk
char *uword = g_ucs4_to_utf8((gunichar *)words[i], -1, NULL, NULL, NULL);
// Dodajemy kolejny element
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), uword);
g_free(uword);
}
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
gtk_box_pack_start(GTK_BOX(vbox), combo, FALSE, FALSE, 1);
gtk_widget_show(combo);
gint click = gtk_dialog_run(GTK_DIALOG(dialog));
if (click == GTK_RESPONSE_ACCEPT) {
char *korekta =
gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo));
// Usuwamy stare
gtk_text_buffer_delete(editor_buf, &start, &end);
// Wstawiamy nowe
gtk_text_buffer_insert(editor_buf, &start, korekta, -1);
g_free(korekta);
}
// Proponujemy dodanie słowa do słownika
else if (click == GTK_RESPONSE_APPLY)
dictionary_insert(dict, wword);
gtk_widget_destroy(dialog);
}
}
g_free(word);
g_free(wword);
}
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);
}
int XAttOneGtk::change_value(int set_focus)
{
int sts;
GtkWidget* text_w;
char* value = 0;
int input_size;
char aval[1024];
char buf[1024];
int len;
sts = gdh_GetAttributeCharAttrref(&aref, &atype, &asize, &aoffs, &aelem);
if (EVEN(sts))
return sts;
switch (atype) {
case pwr_eType_String:
case pwr_eType_Text:
input_size = asize;
break;
default:
input_size = 80;
}
sts = gdh_GetObjectInfoAttrref(&aref, aval, sizeof(aval));
if (EVEN(sts))
return sts;
if (atype == pwr_eType_Text)
value = aval;
else {
XNav::attrvalue_to_string(
atype, atype, &aval, buf, sizeof(buf), &len, NULL, 0);
value = buf;
}
if (!access_rw) {
gtk_label_set_text(GTK_LABEL(cmd_label), buf);
} else {
if (atype == pwr_eType_Text) {
text_w = cmd_scrolledinput;
g_object_set(cmd_input, "visible", FALSE, NULL);
g_object_set(cmd_scrolledinput, "visible", TRUE, NULL);
// int w, h;
// gdk_drawable_get_size( pane->window, &w, &h);
// gtk_paned_set_position( GTK_PANED(pane), h - 170);
if (set_focus)
gtk_widget_grab_focus(cmd_scrolledtextview);
input_multiline = 1;
if (value) {
GtkTextIter start_iter, end_iter;
gtk_text_buffer_get_start_iter(cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_get_end_iter(cmd_scrolled_buffer, &end_iter);
gtk_text_buffer_delete(cmd_scrolled_buffer, &start_iter, &end_iter);
gtk_text_buffer_get_start_iter(cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_insert(cmd_scrolled_buffer, &start_iter, value, -1);
} else {
GtkTextIter start_iter, end_iter;
gtk_text_buffer_get_start_iter(cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_get_end_iter(cmd_scrolled_buffer, &end_iter);
gtk_text_buffer_delete(cmd_scrolled_buffer, &start_iter, &end_iter);
}
} else {
text_w = cmd_input;
g_object_set(cmd_input, "visible", TRUE, NULL);
g_object_set(cmd_scrolledinput, "visible", FALSE, NULL);
if (set_focus)
gtk_widget_grab_focus(cmd_input);
input_multiline = 0;
gtk_entry_set_max_length(GTK_ENTRY(text_w), input_size - 1);
gint pos = 0;
gtk_editable_delete_text(GTK_EDITABLE(cmd_input), 0, -1);
if (value) {
gtk_editable_insert_text(
GTK_EDITABLE(text_w), value, strlen(value), &pos);
// Select the text
gtk_editable_set_position(GTK_EDITABLE(cmd_input), -1);
gtk_editable_select_region(GTK_EDITABLE(cmd_input), 0, -1);
}
}
message(' ', "");
set_prompt(Lng::translate("value >"));
input_open = 1;
}
return XATT__SUCCESS;
}
/**
* Handles the keypress events from webview and inputbox.
*/
VbResult ex_keypress(int key)
{
GtkTextIter start, end;
GtkTextBuffer *buffer = vb.gui.buffer;
GtkTextMark *mark;
/* delegate call to the submode */
if (RESULT_COMPLETE == hints_keypress(key)) {
return RESULT_COMPLETE;
}
switch (key) {
case KEY_TAB:
complete(1);
break;
case KEY_SHIFT_TAB:
complete(-1);
break;
case CTRL('['):
case CTRL('C'):
mode_enter('n');
vb_set_input_text("");
break;
case KEY_CR:
input_activate();
break;
case KEY_UP:
history(true);
break;
case KEY_DOWN:
history(false);
break;
/* basic command line editing */
case CTRL('H'):
/* delete the last char before the cursor */
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &start, mark);
gtk_text_buffer_backspace(buffer, &start, true, true);
break;
case CTRL('W'):
/* delete word backward from cursor */
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &end, mark);
/* copy the iter to build start and end point for deletion */
start = end;
/* move the iterator to the beginning of previous word */
if (gtk_text_iter_backward_word_start(&start)) {
gtk_text_buffer_delete(buffer, &start, &end);
}
break;
case CTRL('B'):
/* move the cursor direct behind the prompt */
gtk_text_buffer_get_iter_at_offset(buffer, &start, strlen(vb.state.prompt));
gtk_text_buffer_place_cursor(buffer, &start);
break;
case CTRL('E'):
/* move the cursor to the end of line */
gtk_text_buffer_get_end_iter(buffer, &start);
gtk_text_buffer_place_cursor(buffer, &start);
break;
case CTRL('U'):
/* remove everythings between cursor and prompt */
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &end, mark);
gtk_text_buffer_get_iter_at_offset(buffer, &start, strlen(vb.state.prompt));
gtk_text_buffer_delete(buffer, &start, &end);
break;
default:
/* if is printable ascii char, than write it at the cursor
* position into input box */
if (key >= 0x20 && key <= 0x7e) {
gtk_text_buffer_insert_at_cursor(buffer, (char[2]){key, 0}, 1);
} else {
