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; }