void
gmdb_sql_save_query(GladeXML *xml, gchar *file_path)
{
FILE *out;
GtkWidget *textview;
GtkTextBuffer *txtbuffer;
GtkTextIter start, end;
gchar *buf;
if (!(out=fopen(file_path, "w"))) {
GtkWidget* dlg = gtk_message_dialog_new (NULL,
GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE,
_("Unable to open file."));
gtk_dialog_run (GTK_DIALOG (dlg));
gtk_widget_destroy (dlg);
return;
}
textview = glade_xml_get_widget(xml, "sql_textview");
txtbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_get_start_iter(txtbuffer, &start);
gtk_text_buffer_get_end_iter(txtbuffer, &end);
buf = gtk_text_buffer_get_text(txtbuffer, &start, &end, FALSE);
fprintf(out,"%s\n",buf);
fclose(out);
gmdb_sql_set_file(xml, file_path);
}
static void
on_retrieve_clicked (GtkButton *button,
Widgets *w)
{
g_return_if_fail (GTK_IS_TEXT_VIEW(w->textview));
GtkTextBuffer *buffer;
GtkTextIter start = {0,};
GtkTextIter end = {0,};
gchar *text;
/*
* The selected text provides us with two iterators, which we use to display
* the substring from buffer to stdout.
*/
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(w->textview));
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
/*
* Let's check whether our text selection is non-empty.
*/
if (gtk_text_iter_equal(&start, &end))
{
return;
}
text = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
create_message_dialog (w, "Text retrieved", text);
}
gboolean
ghb_background_refresh_x264Option(signal_user_data_t *ud)
{
const char *opt;
opt = ghb_dict_get_string(ud->settings, "x264Option");
GtkWidget *widget;
GtkTextBuffer *buffer;
GtkTextIter start, end;
gchar *str;
widget = GHB_WIDGET(ud->builder, "x264Option");
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
gtk_text_buffer_get_bounds(buffer, &start, &end);
str = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
// If the value has changed, then update it
if (opt != NULL)
{
if (str == NULL || strcmp(str, opt))
{
ud->dont_clear_presets = 1;
ghb_ui_update(ud, "x264Option", ghb_string_value(opt));
ud->dont_clear_presets = 0;
}
}
free(str);
return FALSE;
}
static void
replace_word(GtkWidget *menuitem, GtkSpell *spell) {
char *oldword;
const char *newword;
GtkTextIter start, end;
GtkTextBuffer *buffer;
buffer = gtk_text_view_get_buffer(spell->view);
get_cur_word_extents(buffer, &start, &end);
oldword = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
newword = gtk_label_get_text(GTK_LABEL(GTK_BIN(menuitem)->child));
if (debug) {
g_print("old word: '%s'\n", oldword);
print_iter("s", &start); print_iter("e", &end);
g_print("\nnew word: '%s'\n", newword);
}
gtk_text_buffer_delete(buffer, &start, &end);
gtk_text_buffer_insert(buffer, &start, newword, -1);
aspell_speller_store_replacement(spell->speller,
oldword, strlen(oldword),
newword, strlen(newword));
g_free(oldword);
}
static gchar *
get_content_type_from_content (GeditDocument *doc)
{
gchar *content_type;
gchar *data;
GtkTextBuffer *buffer;
GtkTextIter start;
GtkTextIter end;
buffer = GTK_TEXT_BUFFER (doc);
gtk_text_buffer_get_start_iter (buffer, &start);
end = start;
gtk_text_iter_forward_chars (&end, 255);
data = gtk_text_buffer_get_text (buffer, &start, &end, TRUE);
content_type = g_content_type_guess (NULL,
(const guchar *)data,
strlen (data),
NULL);
g_free (data);
return content_type;
}
static void
btn_ok_callback(GtkWidget *button, /* Ignored */
t_winfo *winfo) /* Window information */
/*
* Called when the OK button is pressed. We must save the contents of
* the buffer back to the 'notes'.
*/
{
GtkTextIter start; /* Start of the buffer */
GtkTextIter end; /* End of the buffer */
gchar **notes; /* Contents of buffer */
gchar *new_notes; /* New buffer */
/* --- First get the contents of the buffer --- */
gtk_text_buffer_get_bounds(winfo->buffer, &start, &end);
new_notes = gtk_text_buffer_get_text(winfo->buffer,
&start, &end, FALSE);
changed();
notes = winfo->notes; /* Remember where notes go! */
FREE(*notes); /* Free the old ones */
if(is_empty(new_notes)) /* Nothing or white space? */
FREE(new_notes) /* Free the buffer space */
else
*notes = new_notes; /* Replace with new ones */
gtk_widget_destroy(GTK_WIDGET(winfo->win));/* Close the window */
} /* btn_ok_callback() */
static void
buffer_end_user_action (GtkTextBuffer *buffer, GtrContextPanel *panel)
{
GtkTextIter start, end;
gchar *text;
GtrContextPanelPrivate *priv;
GtrPo *po;
GtrPoState po_state;
priv = gtr_context_panel_get_instance_private(panel);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->context));
gtk_text_buffer_get_bounds (buffer, &start, &end);
text = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
gtr_msg_set_comment (priv->current_msg, text);
g_free (text);
/* Update the po state if needed after adding a comment */
po = gtr_tab_get_po (priv->tab);
po_state = gtr_po_get_state (po);
if (po_state != GTR_PO_STATE_MODIFIED)
gtr_po_set_state (po, GTR_PO_STATE_MODIFIED);
}
static gchar*
ev_view_accessible_get_text (AtkText *text,
gint start_pos,
gint end_pos)
{
GtkWidget *widget;
GtkTextIter start, end;
GtkTextBuffer *buffer;
gchar *retval;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
/* State is defunct */
return NULL;
buffer = ev_view_accessible_get_text_buffer (EV_VIEW_ACCESSIBLE (text), EV_VIEW (widget));
if (!buffer)
return NULL;
gtk_text_buffer_get_iter_at_offset (buffer, &start, start_pos);
gtk_text_buffer_get_iter_at_offset (buffer, &end, end_pos);
retval = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
return retval;
}
static gchar*
ev_view_accessible_get_selection (AtkText *text,
gint selection_num,
gint *start_pos,
gint *end_pos)
{
GtkWidget *widget;
GtkTextBuffer *buffer;
GtkTextIter start, end;
gchar *retval = NULL;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
/* State is defunct */
return NULL;
if (selection_num != 0)
return NULL;
buffer = ev_view_accessible_get_text_buffer (EV_VIEW_ACCESSIBLE (text), EV_VIEW (widget));
if (!buffer)
return NULL;
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
*start_pos = gtk_text_iter_get_offset (&start);
*end_pos = gtk_text_iter_get_offset (&end);
if (*start_pos != *end_pos)
retval = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
return retval;
}
/* Callback for send button */
void
al_apretar_boton (GtkWidget *button, gpointer user_data)
{
MyWidgets *widgets;
GtkTextBuffer *buffer;
GtkTextBuffer *buffer_resp;
widgets = (MyWidgets *)user_data;
GtkTextIter start;
GtkTextIter end;
gchar *text;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widgets->view));
/* Obtain iters for the start and end of points of the buffer */
gtk_text_buffer_get_start_iter (buffer, &start);
gtk_text_buffer_get_end_iter (buffer, &end);
/* Get the entire buffer text. */
text = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
/* Print the text */
// g_print ("%s \n", text);
buffer_resp = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widgets->resp));
gtk_text_buffer_insert_at_cursor (buffer_resp, "Server: ", -1);
gtk_text_buffer_insert_at_cursor(buffer_resp, text, -1); // Agrega el texto tipeado a la pantalla
gtk_text_buffer_insert_at_cursor(buffer_resp, "\n", -1); // pasa nueva linea
/* limpia el bufer de texto ingresado para comenzar a ingresar un nuevo mensaje. */
gtk_text_buffer_set_text (buffer, "", -1);
g_free (text);
}
static void
matedialog_text_dialog_response (GtkWidget *widget, int response, gpointer data)
{
MateDialogData *zen_data = data;
switch (response) {
case GTK_RESPONSE_CLOSE:
if (zen_text_data->editable) {
GtkTextIter start, end;
gchar *text;
gtk_text_buffer_get_bounds (zen_text_data->buffer, &start, &end);
text = gtk_text_buffer_get_text (zen_text_data->buffer, &start, &end, 0);
g_print ("%s", text);
g_free (text);
}
zen_data->exit_code = matedialog_util_return_exit_code (MATEDIALOG_OK);
break;
default:
/* Esc dialog */
zen_data->exit_code = matedialog_util_return_exit_code (MATEDIALOG_ESC);
break;
}
gtk_main_quit ();
}
/*
* facq_log_file_update_text_buffer:
* @buffer: A #GtkTextBuffer.
* @log_content: The log content.
* @n_prev_lines: Number of previous lines to keep in the buffer.
*
* This function is called, when the number of new lines available in the log
* is minor than the number of lines requested by the user to be displayed, but
* this time the buffer has enough free lines to show all the new lines,
* and also can show @n_prev_lines of the previous iteration, and the number
* of empty lines in the buffer is minor than the total number of lines read.
*/
static void facq_log_file_update_text_buffer(GtkTextBuffer *buffer,gchar *log_content,guint n_prev_lines)
{
GtkTextIter startIter, endIter;
gchar *text_buffer_content = NULL;
gchar **prev_lines = NULL;
guint n_lines_in_buffer = 0;
GString *string_buffer = NULL;
guint i = 0;
gtk_text_buffer_get_start_iter(buffer,&startIter);
gtk_text_buffer_get_end_iter(buffer,&endIter);
text_buffer_content =
gtk_text_buffer_get_text(buffer,&startIter,&endIter,FALSE);
prev_lines = g_strsplit(text_buffer_content,"\n",-1);
n_lines_in_buffer = g_strv_length(prev_lines);
string_buffer = g_string_new(NULL);
for(i = (n_lines_in_buffer - n_prev_lines -1);i < n_lines_in_buffer;i++){
g_string_append(string_buffer,prev_lines[i]);
g_string_append(string_buffer,"\n");
}
g_string_append(string_buffer,log_content);
gtk_text_buffer_set_text(buffer,string_buffer->str,-1);
g_string_free(string_buffer,TRUE);
g_free(text_buffer_content);
g_strfreev(prev_lines);
}
// saves the selected file from notebook
void save_file() {
GError *error = NULL;
GtkWidget *view;
GtkTextBuffer *buffer;
GtkTextIter start, end;
gchar *text;
gboolean return_value;
gchar *filename;
filename = g_list_nth_data(opened_files, notebook_current_file_number());
// get current text view from notebook
view = notebook_current_view();
// disable text view
gtk_widget_set_sensitive(view, FALSE);
// get buffer of text view
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
// get start and end iter
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
// get text from buffer
text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
gtk_text_buffer_set_modified(buffer, FALSE);
// write text to file
return_value = g_file_set_contents(filename, text, -1, &error);
if (return_value == FALSE) {
g_error_free(error);
}
// enable text view
gtk_widget_set_sensitive(view, TRUE);
// free text's memory
g_free(text);
}
static gboolean
modify_edit_end(GtkWidget *widget, GdkEventFocus *event, gpointer data)
{
GtkTextView *view = GTK_TEXT_VIEW(widget);
DiaObject *obj = (DiaObject*)data;
GQuark quark = g_quark_from_string(PROP_TYPE_TEXT);
const PropDescription *props = obj->ops->describe_props(obj);
int i;
printf("Ending focus\n");
for (i = 0; props[i].name != NULL; i++) {
printf("Testing to remove: %s\n", props[i].name);
if (props[i].type_quark == quark) {
GPtrArray *textprops = g_ptr_array_sized_new(1);
TextProperty *textprop;
Property *prop = props[i].ops->new_prop(&props[i], pdtpp_true);
GtkTextBuffer *buf;
GtkTextIter start, end;
printf("Going to stop %d\n", i);
buf = gtk_text_view_get_buffer(view);
g_ptr_array_add(textprops, prop);
obj->ops->get_props(obj, textprops);
textprop = (TextProperty*)prop;
if (textprop->text_data != NULL) g_free(textprop->text_data);
gtk_text_buffer_get_bounds(buf, &start, &end);
textprop->text_data = gtk_text_buffer_get_text(buf, &start, &end, TRUE);
printf("Setting text %s\n", textprop->text_data);
obj->ops->set_props(obj, textprops);
gtk_widget_destroy(widget);
}
}
return FALSE;
}
/* debug_on_message_send */
static void _debug_on_message_send(gpointer data)
{
ModemPlugin * modem = data;
Debug * debug = modem;
GtkTextBuffer * tbuf;
GtkTextIter start;
GtkTextIter end;
gchar * content;
debug->event_message.message.type = MODEM_EVENT_TYPE_MESSAGE;
debug->event_message.message.id++;
debug->event_message.message.date = time(NULL);
debug->event_message.message.number = gtk_entry_get_text(GTK_ENTRY(
debug->me_number));
debug->event_message.message.folder = gtk_combo_box_get_active(
GTK_COMBO_BOX(debug->me_folder));
debug->event_message.message.status = MODEM_MESSAGE_STATUS_NEW;
debug->event_message.message.encoding = MODEM_MESSAGE_ENCODING_UTF8;
tbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(debug->me_message));
gtk_text_buffer_get_start_iter(tbuf, &start);
gtk_text_buffer_get_end_iter(tbuf, &end);
content = gtk_text_buffer_get_text(tbuf, &start, &end, FALSE);
debug->event_message.message.length = strlen(content);
debug->event_message.message.content = content;
debug->helper->event(debug->helper->modem, &debug->event_message);
g_free(content);
}
gTextAreaAction *gTextAreaAction::deleteAction(GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end)
{
GtkTextIter insert_iter;
int insert_offset;
GtkTextMark *mark;
gTextAreaAction *action = new gTextAreaAction;
char *text;
action->type = ACTION_DELETE;
text = gtk_text_buffer_get_text(buffer, start, end, FALSE);
action->text = g_string_new(text);
action->length = g_utf8_strlen(action->text->str, action->text->len);
g_free(text);
action->start = gtk_text_iter_get_offset(start);
action->end = gtk_text_iter_get_offset(end);
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &insert_iter, mark);
insert_offset = gtk_text_iter_get_offset(&insert_iter);
action->delete_key_used = insert_offset < action->start;
action->mergeable = (action->length == 1) && *(action->text->str) != '\r' && *(action->text->str) != '\n' && *(action->text->str) != ' ';
return action;
}
void WAttTextGtk::set_attr_value()
{
int size = input_max_length + 1;
pwr_tStatus sts;
gchar *text, *textutf8;
unsigned char* s;
if (editmode) {
GtkTextIter start_iter, end_iter;
gtk_text_buffer_get_start_iter(textbuffer, &start_iter);
gtk_text_buffer_get_end_iter(textbuffer, &end_iter);
textutf8
= gtk_text_buffer_get_text(textbuffer, &start_iter, &end_iter, FALSE);
text = g_convert(textutf8, -1, "ISO8859-1", "UTF-8", NULL, NULL, NULL);
g_free(textutf8);
if (text) {
// Replace ctrl characters with space
for (s = (unsigned char*)text; *s; s++) {
if (*s < ' ' && *s != 10 && *s != 13)
*s = ' ';
}
sts = ldh_SetObjectPar(ldhses, aref.Objid, "DevBody", aname, text, size);
g_free(text);
} else
wow->DisplayError("Input error", "Invalid character");
}
}
void snippet_info_sync_group (GuSnippetInfo* info, GuEditor* ec) {
if (!info->current ||
GU_SNIPPET_EXPAND_INFO(info->current->data)->group_number == -1)
return;
GuSnippetExpandInfo* active = GU_SNIPPET_EXPAND_INFO (info->current->data);
GList* current = g_list_first (info->einfo);
gchar* text = NULL;
GtkTextIter start, end;
gtk_text_buffer_get_iter_at_mark (ec_buffer, &start, active->left_mark);
gtk_text_buffer_get_iter_at_mark (ec_buffer, &end, active->right_mark);
text = gtk_text_buffer_get_text (ec_buffer, &start, &end, TRUE);
while (current) {
GuSnippetExpandInfo* einfo = GU_SNIPPET_EXPAND_INFO (current->data);
if (einfo != active && einfo->group_number == active->group_number) {
gtk_text_buffer_get_iter_at_mark (ec_buffer, &start,
einfo->left_mark);
gtk_text_buffer_get_iter_at_mark (ec_buffer, &end,
einfo->right_mark);
gtk_text_buffer_delete (ec_buffer, &start, &end);
gtk_text_buffer_insert (ec_buffer, &start, text, -1);
}
current = g_list_next (current);
}
g_free (text);
}
/* returns the number of bytes
that are already present in the text.
this is used to avoid for example inserting "return;" in a location where ';' is already the
character directly beyond the insert position.
*/
static gint
get_existing_end_len(BluefishTextView * btv, const gchar *string, gint prefix_bytelen)
{
gchar *tmp;
GtkTextIter it1, it2;
gint i,len;
gint string_len = g_utf8_strlen(string, -1);
gtk_text_buffer_get_iter_at_mark(btv->buffer, &it1, gtk_text_buffer_get_insert(btv->buffer));
it2 = it1;
DBG_AUTOCOMP("get_existing_end_len, forward %d chars\n",string_len - prefix_bytelen);
gtk_text_iter_forward_chars(&it2,string_len - prefix_bytelen);
DBG_AUTOCOMP("get the text %d:%d\n",gtk_text_iter_get_offset(&it1),gtk_text_iter_get_offset(&it2));
tmp = gtk_text_buffer_get_text(btv->buffer, &it1, &it2, TRUE);
/*g_print("got tmp='%s'\n",tmp);*/
len = strlen(tmp);
i = len-1;
do {
DBG_AUTOCOMP("get_existing_end_len, compare %d characters of %s and %s\n",i,string+prefix_bytelen+len-i,tmp);
if (strncmp(string+prefix_bytelen+len-i, tmp, i)==0) {
DBG_AUTOCOMP("get_existing_end_len, found %d existing characters\n",i);
g_free(tmp);
return i;
}
i--;
} while(i>0);
g_free(tmp);
DBG_AUTOCOMP("get_existing_end_len, found no existing characters\n");
return 0;
}
int
update_fuzai_config(GtkWidget *view,gboolean enter) {
GtkWidget *window;
GtkWidget *entry;
GtkWidget *text_view;
int max_index;
int max_message;
int index;
int rc;
gchar *title;
gchar *message;
GtkTreeModel *model;
GtkTreeIter titer;
GtkTextIter siter;
GtkTextIter eiter;
GtkTreeSelection *sel;
GtkTextBuffer *txt_buf;
size_t len;
int text_line;
if (!view)
return -EINVAL;
rc=0;
entry=GTK_WIDGET(lookup_widget(view,"AbsenceTitleEntry"));
g_assert(entry);
text_view=GTK_WIDGET(lookup_widget(view,"fuzaiText"));
g_assert(text_view);
sel=gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
if (gtk_tree_selection_get_selected(sel, &model, &titer))
{
gtk_tree_model_get (model, &titer,
1, &index,
-1);
dbg_out("Index:%d\n",index);
title=(char *)gtk_entry_get_text(GTK_ENTRY(entry));
rc=hostinfo_set_ipmsg_absent_title(index,title);
if (rc<0)
goto error_out;
txt_buf=gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));
gtk_text_buffer_get_bounds(txt_buf,&siter,&eiter);
message=gtk_text_buffer_get_text(txt_buf,&siter,&eiter,FALSE);
rc=hostinfo_set_ipmsg_absent_message(index,message);
g_free(message); /*成功,不成功にかかわらず開放は実施 */
if (rc<0)
goto error_out;
if (enter) { /* 不在モードへ移行 */
hostinfo_set_absent_id(index);
hostinfo_set_ipmsg_absent(TRUE);
ipmsg_send_br_absence(udp_con,0);
}
rc=0;
}
error_out:
return rc;
}
/* Callback for send button */
void
al_apretar_boton_old (GtkWidget *button, GtkTextBuffer *buffer)
{
GtkTextIter start;
GtkTextIter end;
gchar *text;
/* Obtain iters for the start and end of points of the buffer */
gtk_text_buffer_get_start_iter (buffer, &start);
gtk_text_buffer_get_end_iter (buffer, &end);
/* Get the entire buffer text. */
text = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
/* Print the text */
g_print ("%s \n", text);
g_free (text);
// gtk_text_buffer_set_text (buffer_resp, "Server: ", -1);
/* limpia el bufer de texto ingresado para comenzar a ingresar un nuevo mensaje. */
gtk_text_buffer_set_text (buffer, "", -1);
}
int XAttOneGtk::set_value()
{
char *text;
int sts;
char buff[1024];
if ( input_open) {
if ( input_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);
text = gtk_text_buffer_get_text( cmd_scrolled_buffer, &start_iter, &end_iter,
FALSE);
}
else {
text = gtk_editable_get_chars( GTK_EDITABLE(cmd_input), 0, -1);
}
sts = XNav::attr_string_to_value( atype, text, buff, sizeof(buff),
asize);
g_free( text);
if ( EVEN(sts)) {
message( 'E', "Input syntax error");
return sts;
}
sts = gdh_SetObjectInfoAttrref( &aref, buff, asize);
if ( EVEN(sts)) {
message( 'E', "Unable to set value");
return sts;
}
message( ' ', "");
}
return XATT__SUCCESS;
}
static void
populate_popup(GtkTextView *textview, GtkMenu *menu, GtkSpell *spell) {
GtkWidget *img, *mi;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(textview);
GtkTextIter start, end;
char *word;
/* we need to figure out if they picked a misspelled word. */
get_cur_word_extents(buffer, &start, &end);
/* if our highlight algorithm ever messes up,
* this isn't correct, either. */
if (!gtk_text_iter_has_tag(&start, spell->tag_highlight))
return; /* word wasn't misspelled. */
/* menu separator comes first. */
mi = gtk_menu_item_new();
gtk_widget_show(mi);
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), mi);
/* then, on top of it, the suggestions menu. */
img = gtk_image_new_from_stock(GTK_STOCK_SPELL_CHECK, GTK_ICON_SIZE_MENU);
mi = gtk_image_menu_item_new_with_label("Spelling Suggestions");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), img);
word = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(mi),
build_suggestion_menu(spell, buffer, word));
g_free(word);
gtk_widget_show_all(mi);
gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), mi);
}
void
link_dialog_run(GtkWindow *win, JamDoc *doc) {
STACK(LinkDialog, ld);
GtkTextBuffer *buffer;
GtkTextIter start, end;
char *sel = NULL;
char *link;
JamAccount *acc = jam_doc_get_account(doc);
make_link_dialog(ld, win, JAM_ACCOUNT_IS_LJ(acc));
buffer = jam_doc_get_text_buffer(doc);
if (gtk_text_buffer_get_selection_bounds(buffer, &start, &end))
sel = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
prepopulate_fields(ld, sel);
g_free(sel);
if (gtk_dialog_run(GTK_DIALOG(ld->dlg)) != GTK_RESPONSE_OK) {
gtk_widget_destroy(ld->dlg);
return;
}
link = get_link(ld, acc);
gtk_widget_destroy(ld->dlg);
if (link) {
gtk_text_buffer_begin_user_action(buffer);
gtk_text_buffer_delete(buffer, &start, &end);
gtk_text_buffer_insert(buffer, &start, link, -1);
gtk_text_buffer_end_user_action(buffer);
g_free(link);
}
}
static void addkeeper_prefs_save_func(PrefsPage * _page)
{
struct AddressKeeperPrefsPage *page = (struct AddressKeeperPrefsPage *) _page;
const gchar *text;
GtkTextBuffer *buffer;
GtkTextIter start, end;
text = gtk_entry_get_text(GTK_ENTRY(page->addressbook_folder));
addkeeperprefs.addressbook_folder = g_strdup(text);
addkeeperprefs.keep_to_addrs = gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON(page->keep_to_addrs_check));
addkeeperprefs.keep_cc_addrs = gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON(page->keep_cc_addrs_check));
addkeeperprefs.keep_bcc_addrs = gtk_toggle_button_get_active(
GTK_TOGGLE_BUTTON(page->keep_bcc_addrs_check));
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(page->block_matching_addrs));
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
g_free(addkeeperprefs.block_matching_addrs);
addkeeperprefs.block_matching_addrs = g_malloc(2 * strlen(text) + 1);
pref_get_escaped_pref(addkeeperprefs.block_matching_addrs, text);
addkeeper_save_config();
g_free(addkeeperprefs.block_matching_addrs);
addkeeperprefs.block_matching_addrs = (gchar *)text;
}
void MultilineOptionView::_onAccept() const {
GtkTextIter start, end;
gtk_text_buffer_get_bounds(myTextBuffer, &start, &end);
gchar *value = gtk_text_buffer_get_text(myTextBuffer, &start, &end, true);
((ZLMultilineOptionEntry&)*myOption).onAccept(value);
g_free(value);
}
void
netlist_editor_save (GtkWidget * widget, NetlistEditor * nle)
{
char *name;
name = dialog_netlist_file ((SchematicView *)NULL);
if (name != NULL) {
GtkTextView *tview;
GtkTextBuffer *buffer;
GtkTextIter start, end;
FILE *fp;
tview = nle->priv->view;
buffer = gtk_text_view_get_buffer (tview);
gtk_text_buffer_get_start_iter (buffer, &start);
gtk_text_buffer_get_end_iter (buffer, &end);
fp = fopen (name, "wt");
if (!fp) {
gchar *msg;
msg = g_strdup_printf (_("The file %s could not be saved"), name);
oregano_error_with_title (_("Could not save temporary netlist file"), msg);
g_free (msg);
return;
}
fputs (gtk_text_buffer_get_text (buffer, &start, &end, FALSE), fp);
fclose (fp);
g_free (name);
}
}
/*
* Get Buffer from TextArea and send tweet if user press ENTER on keyboard
*
*/
gboolean send_tweet_gtk(GtkWidget *TextArea, GdkEventKey *pKey, GtkTextBuffer *tweetBuffer){
GtkTextIter start,
end;
char *msg = NULL;
/* Get start position of cursor and final position */
gtk_text_buffer_get_start_iter (tweetBuffer, &start);
gtk_text_buffer_get_end_iter (tweetBuffer, &end);
/* Casting buffer to char */
msg = gtk_text_buffer_get_text(tweetBuffer, &start, &end, TRUE);
/* If user press ENTER on keyboard Send Tweet and clean TextArea*/
if(pKey->keyval == GDK_Return){
//SendTweet
send_tweet(msg);
//Clean TextArea
gtk_text_buffer_delete(tweetBuffer, &start, &end);
return 1; // fix cursor (return to previous line)
}
return 0;
}
/* Links can also be activated by clicking */
static void
follow_if_link (GtkWidget *text_view, GtkTextIter *iter)
{
GSList *tags = NULL, *tagp = NULL;
tags = gtk_text_iter_get_tags (iter);
for (tagp = tags; tagp != NULL; tagp = tagp->next)
{
gchar *tag_name;
GtkTextTag *tag = tagp->data;
g_object_get (G_OBJECT (tag), "name", &tag_name, NULL);
if ( g_ascii_strcasecmp(tag_name, "link") == 0)
{
GtkTextIter iter_end = *iter;
GtkTextIter iter_start = iter_end;
gtk_text_iter_backward_sentence_start(&iter_start);
gtk_text_iter_forward_to_line_end(&iter_end);
char *result = \
escape(gtk_text_buffer_get_text(buffer,
&iter_start,
&iter_end,
0));
gtk_show_uri(NULL, result, GDK_CURRENT_TIME, NULL);
g_free(result);
}
}
if(tags)
g_slist_free (tags);
}
JNIEXPORT jstring JNICALL
Java_gnu_java_awt_peer_gtk_GtkTextAreaPeer_getText
(JNIEnv *env, jobject obj)
{
void *ptr;
char *contents = NULL;
jstring jcontents;
GtkWidget *text = NULL;
GtkTextBuffer *buf;
GtkTextIter start, end;
gdk_threads_enter ();
ptr = NSA_GET_PTR (env, obj);
text = textarea_get_widget (GTK_WIDGET (ptr));
buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
gtk_text_buffer_get_start_iter (buf, &start);
gtk_text_buffer_get_end_iter (buf, &end);
contents = gtk_text_buffer_get_text (buf, &start, &end, FALSE);
jcontents = (*env)->NewStringUTF (env, contents);
g_free (contents);
gdk_threads_leave ();
return jcontents;
}
