WAttTextGtk::WAttTextGtk(GtkWidget* wa_parent_wid, void* wa_parent_ctx, ldh_tSesContext wa_ldhses, pwr_sAttrRef wa_aref, int wa_editmode, pwr_tStatus* status) : WAttText(wa_parent_ctx, wa_ldhses, wa_aref, wa_editmode, status), parent_wid(wa_parent_wid), toplevel(0), init(1) { int sts; int size; char* namep; if (EVEN(*status)) return; sts = ldh_AttrRefToName(ldhses, &aref, ldh_eName_Hierarchy, &namep, &size); if (EVEN(sts)) { *status = sts; return; } toplevel = (GtkWidget*)g_object_new(GTK_TYPE_WINDOW, "default-height", 700, "default-width", 800, "title", CoWowGtk::convert_utf8(namep), NULL); g_signal_connect(toplevel, "delete_event", G_CALLBACK(delete_event), this); g_signal_connect(toplevel, "destroy", G_CALLBACK(destroy_event), this); g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this); CoWowGtk::SetWindowIcon(toplevel); // Menu // Accelerators GtkAccelGroup* accel_g = (GtkAccelGroup*)g_object_new(GTK_TYPE_ACCEL_GROUP, NULL); gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g); GtkMenuBar* menu_bar = (GtkMenuBar*)g_object_new(GTK_TYPE_MENU_BAR, NULL); // File entry GtkWidget* file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g); g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this); GtkWidget* file_save = gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE, accel_g); g_signal_connect(file_save, "activate", G_CALLBACK(activate_save), this); GtkWidget* file_saveandclose = gtk_menu_item_new_with_mnemonic("S_ave and close"); g_signal_connect( file_saveandclose, "activate", G_CALLBACK(activate_saveandclose), this); gtk_widget_add_accelerator(file_saveandclose, "activate", accel_g, 't', GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE); GtkMenu* file_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_save); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_saveandclose); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close); GtkWidget* file = gtk_menu_item_new_with_mnemonic("_File"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu)); // Edit entry GtkWidget* edit_copy = gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, accel_g); g_signal_connect(edit_copy, "activate", G_CALLBACK(activate_copy), this); GtkWidget* edit_cut = gtk_image_menu_item_new_from_stock(GTK_STOCK_CUT, accel_g); g_signal_connect(edit_cut, "activate", G_CALLBACK(activate_cut), this); GtkWidget* edit_paste = gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, accel_g); g_signal_connect(edit_paste, "activate", G_CALLBACK(activate_paste), this); GtkMenu* edit_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_copy); gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_cut); gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_paste); GtkWidget* edit = gtk_menu_item_new_with_mnemonic("_Edit"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), edit); gtk_menu_item_set_submenu(GTK_MENU_ITEM(edit), GTK_WIDGET(edit_menu)); // Help entry GtkWidget* help_help = gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g); g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this); GtkMenu* help_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL); gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help); GtkWidget* help = gtk_menu_item_new_with_mnemonic("_Help"); gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help); gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu)); if (((WUtility*)parent_ctx)->utype == wb_eUtility_WNav) parent_ctx = ((WNav*)parent_ctx)->parent_ctx; utility = ((WUtility*)parent_ctx)->utype; textbuffer = gtk_text_buffer_new(NULL); g_signal_connect_after( textbuffer, "insert-text", G_CALLBACK(action_text_inserted), this); g_signal_connect_after( textbuffer, "changed", G_CALLBACK(action_text_changed), this); textview = gtk_text_view_new_with_buffer(textbuffer); GtkWidget* viewport = gtk_viewport_new(NULL, NULL); GtkWidget* scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(viewport), textview); gtk_container_add(GTK_CONTAINER(scrolledwindow), viewport); button_ok = gtk_button_new_with_label("Ok"); gtk_widget_set_size_request(button_ok, 70, 25); g_signal_connect(button_ok, "clicked", G_CALLBACK(activate_ok), this); button_apply = gtk_button_new_with_label("Apply"); gtk_widget_set_size_request(button_apply, 70, 25); g_signal_connect(button_apply, "clicked", G_CALLBACK(activate_apply), this); button_cancel = gtk_button_new_with_label("Cancel"); gtk_widget_set_size_request(button_cancel, 70, 25); g_signal_connect(button_cancel, "clicked", G_CALLBACK(activate_cancel), this); GtkWidget* hboxbuttons = gtk_hbox_new(TRUE, 40); gtk_box_pack_start(GTK_BOX(hboxbuttons), button_ok, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hboxbuttons), button_apply, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(hboxbuttons), button_cancel, FALSE, FALSE, 0); msg_label = gtk_label_new(""); gtk_widget_set_size_request(msg_label, -1, 25); vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hboxbuttons, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(vbox), msg_label, FALSE, FALSE, 5); gtk_container_add(GTK_CONTAINER(toplevel), vbox); gtk_widget_show_all(toplevel); if (utility == wb_eUtility_Wtt) { ((Wtt*)parent_ctx) ->register_utility((void*)this, wb_eUtility_AttrTextEditor); } char* value; ldh_sAttrRefInfo ainfo; sts = ldh_GetAttrRefInfo(ldhses, &aref, &ainfo); if (EVEN(sts)) { *status = sts; return; } char* s = strchr(namep, '.'); if (!s) return; strncpy(aname, s + 1, sizeof(aname)); sts = ldh_GetObjectPar( ldhses, aref.Objid, "DevBody", aname, (char**)&value, &size); if (EVEN(sts)) { *status = sts; return; } input_max_length = ainfo.size - 1; GtkTextIter start_iter, end_iter; gtk_text_buffer_get_start_iter(textbuffer, &start_iter); gtk_text_buffer_get_end_iter(textbuffer, &end_iter); gtk_text_buffer_delete(textbuffer, &start_iter, &end_iter); gtk_text_buffer_get_start_iter(textbuffer, &start_iter); char* textutf8 = g_convert(value, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL); gtk_text_buffer_insert(textbuffer, &start_iter, textutf8, -1); g_free(textutf8); free(value); if (!editmode) { gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textview), FALSE); } wow = new CoWowGtk(toplevel); init = 0; }
gboolean document_search_real(GtkWidget *textview, gint direction) { GtkTextIter iter, match_start, match_end; gboolean res; GtkSourceSearchFlags search_flags = GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_TEXT_ONLY; GtkTextBuffer *textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); if (!string_find) return FALSE; if (!match_case) search_flags = search_flags | GTK_SOURCE_SEARCH_CASE_INSENSITIVE; // if (direction == 0 || !hlight_check_searched()) if (direction == 0 || (direction != 2 && !hlight_check_searched())) hlight_searched_strings(GTK_TEXT_VIEW(textview)->buffer, string_find); gtk_text_mark_set_visible( gtk_text_buffer_get_selection_bound( GTK_TEXT_VIEW(textview)->buffer), FALSE); gtk_text_buffer_get_iter_at_mark(textbuffer, &iter, gtk_text_buffer_get_insert(textbuffer)); if (direction < 0) { res = gtk_source_iter_backward_search( &iter, string_find, search_flags, &match_start, &match_end, NULL); if (gtk_text_iter_equal(&iter, &match_end)) { res = gtk_source_iter_backward_search( &match_start, string_find, search_flags, &match_start, &match_end, NULL); } } else { res = gtk_source_iter_forward_search( &iter, string_find, search_flags, &match_start, &match_end, NULL); } /* TODO: both gtk_(text/source)_iter_backward_search works not fine for multi-byte */ /* wrap */ /* TODO: define limit NULL -> proper value */ if (!res) { if (direction < 0) { gtk_text_buffer_get_end_iter(textbuffer, &iter); res = gtk_source_iter_backward_search( &iter, string_find, search_flags, &match_start, &match_end, NULL); } else { gtk_text_buffer_get_start_iter(textbuffer, &iter); res = gtk_source_iter_forward_search( &iter, string_find, search_flags, &match_start, &match_end, NULL); } } if (res) { gtk_text_buffer_place_cursor(textbuffer, &match_start); gtk_text_buffer_move_mark_by_name(textbuffer, "insert", &match_end); // gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textview), &match_start, 0.1, FALSE, 0.5, 0.5); scroll_to_cursor(textbuffer, 0.05); } else if (direction == 0) run_dialog_message(gtk_widget_get_toplevel(textview), GTK_MESSAGE_WARNING, _("Search string not found")); return res; }
void load_file (const gchar *demoname, const gchar *filename) { GtkTextBuffer *info_buffer, *source_buffer; GtkTextIter start, end; char *resource_filename; GError *err = NULL; int state = 0; gboolean in_para = 0; gchar **lines; GBytes *bytes; gint i; if (!g_strcmp0 (current_file, filename)) return; remove_data_tabs (); add_data_tab (demoname); g_free (current_file); current_file = g_strdup (filename); info_buffer = gtk_text_buffer_new (NULL); gtk_text_buffer_create_tag (info_buffer, "title", "font", "Sans 18", "pixels-below-lines", 10, NULL); source_buffer = gtk_text_buffer_new (NULL); gtk_text_buffer_create_tag (source_buffer, "source", "font", "monospace", NULL); gtk_text_buffer_create_tag (source_buffer, "comment", "foreground", "DodgerBlue", NULL); gtk_text_buffer_create_tag (source_buffer, "type", "foreground", "ForestGreen", NULL); gtk_text_buffer_create_tag (source_buffer, "string", "foreground", "RosyBrown", "weight", PANGO_WEIGHT_BOLD, NULL); gtk_text_buffer_create_tag (source_buffer, "control", "foreground", "purple", NULL); gtk_text_buffer_create_tag (source_buffer, "preprocessor", "style", PANGO_STYLE_OBLIQUE, "foreground", "burlywood4", NULL); gtk_text_buffer_create_tag (source_buffer, "function", "weight", PANGO_WEIGHT_BOLD, "foreground", "DarkGoldenrod4", NULL); resource_filename = g_strconcat ("/sources/", filename, NULL); bytes = g_resources_lookup_data (resource_filename, 0, &err); g_free (resource_filename); if (bytes == NULL) { g_warning ("Cannot open source for %s: %s\n", filename, err->message); g_error_free (err); return; } lines = g_strsplit (g_bytes_get_data (bytes, NULL), "\n", -1); g_bytes_unref (bytes); gtk_text_buffer_get_iter_at_offset (info_buffer, &start, 0); for (i = 0; lines[i] != NULL; i++) { gchar *p; gchar *q; gchar *r; /* Make sure \r is stripped at the end for the poor windows people */ lines[i] = g_strchomp (lines[i]); p = lines[i]; switch (state) { case 0: /* Reading title */ while (*p == '/' || *p == '*' || g_ascii_isspace (*p)) p++; r = p; while (*r != '\0') { while (*r != '/' && *r != ':' && *r != '\0') r++; if (*r == '/') { r++; p = r; } if (r[0] == ':' && r[1] == ':') *r = '\0'; } q = p + strlen (p); while (q > p && g_ascii_isspace (*(q - 1))) q--; if (q > p) { int len_chars = g_utf8_pointer_to_offset (p, q); end = start; g_assert (strlen (p) >= q - p); gtk_text_buffer_insert (info_buffer, &end, p, q - p); start = end; gtk_text_iter_backward_chars (&start, len_chars); gtk_text_buffer_apply_tag_by_name (info_buffer, "title", &start, &end); start = end; while (*p && *p != '\n') p++; state++; } break; case 1: /* Reading body of info section */ while (g_ascii_isspace (*p)) p++; if (*p == '*' && *(p + 1) == '/') { gtk_text_buffer_get_iter_at_offset (source_buffer, &start, 0); state++; } else { int len; while (*p == '*' || g_ascii_isspace (*p)) p++; len = strlen (p); while (g_ascii_isspace (*(p + len - 1))) len--; if (len > 0) { if (in_para) gtk_text_buffer_insert (info_buffer, &start, " ", 1); g_assert (strlen (p) >= len); gtk_text_buffer_insert (info_buffer, &start, p, len); in_para = 1; } else { gtk_text_buffer_insert (info_buffer, &start, "\n", 1); in_para = 0; } } break; case 2: /* Skipping blank lines */ while (g_ascii_isspace (*p)) p++; if (*p) { p = lines[i]; state++; /* Fall through */ } else break; case 3: /* Reading program body */ gtk_text_buffer_insert (source_buffer, &start, p, -1); if (lines[i+1] != NULL) gtk_text_buffer_insert (source_buffer, &start, "\n", 1); break; } } g_strfreev (lines); fontify (source_buffer); gtk_text_buffer_create_tag (source_buffer, "top-margin", "pixels-above-lines", 20, NULL); gtk_text_buffer_get_start_iter (source_buffer, &start); end = start; gtk_text_iter_forward_word_end (&end); gtk_text_buffer_apply_tag_by_name (source_buffer, "top-margin", &start, &end); gtk_text_buffer_create_tag (source_buffer, "bottom-margin", "pixels-below-lines", 20, NULL); gtk_text_buffer_get_end_iter (source_buffer, &end); start = end; gtk_text_iter_backward_word_start (&start); gtk_text_buffer_apply_tag_by_name (source_buffer, "bottom-margin", &start, &end); gtk_text_view_set_buffer (GTK_TEXT_VIEW (source_view), source_buffer); g_object_unref (source_buffer); gtk_text_buffer_create_tag (info_buffer, "top-margin", "pixels-above-lines", 20, NULL); gtk_text_buffer_get_start_iter (info_buffer, &start); end = start; gtk_text_iter_forward_word_end (&end); gtk_text_buffer_apply_tag_by_name (info_buffer, "top-margin", &start, &end); gtk_text_buffer_create_tag (info_buffer, "bottom-margin", "pixels-below-lines", 20, NULL); gtk_text_buffer_get_end_iter (info_buffer, &end); start = end; gtk_text_iter_backward_word_start (&start); gtk_text_buffer_apply_tag_by_name (info_buffer, "bottom-margin", &start, &end); gtk_text_view_set_buffer (GTK_TEXT_VIEW (info_view), info_buffer); g_object_unref (info_buffer); }
char* src_view___::text__() { GtkTextIter start, end; gtk_text_buffer_get_start_iter (buf2__(), &start); gtk_text_buffer_get_end_iter (buf2__(), &end); return gtk_text_buffer_get_text (buf2__(), &start, &end, FALSE); }
static gssize _gtk_source_buffer_input_stream_read (GInputStream *input_stream, void *buffer, gsize count, GCancellable *cancellable, GError **error) { GtkSourceBufferInputStream *stream; GtkTextIter iter; gssize space_left, read, n; stream = GTK_SOURCE_BUFFER_INPUT_STREAM (input_stream); if (count < 6) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NO_SPACE, "Not enougth space in destination"); return -1; } if (g_cancellable_set_error_if_cancelled (cancellable, error)) { return -1; } if (stream->priv->buffer == NULL) { return 0; } /* Initialize the mark to the first char in the text buffer */ if (!stream->priv->is_initialized) { gtk_text_buffer_get_start_iter (stream->priv->buffer, &iter); stream->priv->pos = gtk_text_buffer_create_mark (stream->priv->buffer, NULL, &iter, FALSE); stream->priv->is_initialized = TRUE; } space_left = count; read = 0; do { n = read_line (stream, (gchar *)buffer + read, space_left); read += n; space_left -= n; } while (space_left > 0 && n != 0 && stream->priv->bytes_partial == 0); /* Make sure that non-empty files are always terminated with \n (see bug #95676). * Note that we strip the trailing \n when loading the file */ gtk_text_buffer_get_iter_at_mark (stream->priv->buffer, &iter, stream->priv->pos); if (gtk_text_iter_is_end (&iter) && !gtk_text_iter_is_start (&iter) && stream->priv->add_trailing_newline) { gssize newline_size; newline_size = get_new_line_size (stream); if (space_left >= newline_size && !stream->priv->newline_added) { const gchar *newline; newline = get_new_line (stream); memcpy ((gchar *)buffer + read, newline, newline_size); read += newline_size; stream->priv->newline_added = TRUE; } } return read; }
void show_asf_meta_data(gchar * metadata_filename) { GtkWidget *metadata_dialog; GtkWidget *metadata_text; GtkWidget *metadata_label; GtkTextBuffer * text_buffer; FILE * metadata_file; gchar * label_text; const int use_fixed_width = TRUE; metadata_dialog = get_widget_checked("metadata_dialog"); metadata_text = get_widget_checked("metadata_text"); text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(metadata_text)); gtk_text_buffer_set_text(text_buffer, "", -1); label_text = (gchar *) g_malloc(sizeof(gchar) * (strlen(metadata_filename) + 1024)); metadata_file = fopen(metadata_filename, "rt"); if (metadata_file) { gchar * buffer = (gchar *) g_malloc(sizeof(gchar) * max_line_len); while (!feof(metadata_file)) { gchar *p = fgets(buffer, max_line_len, metadata_file); if (p) { GtkTextIter end; gtk_text_buffer_get_end_iter(text_buffer, &end); gtk_text_buffer_insert(text_buffer, &end, buffer, -1); } } fclose(metadata_file); g_free(buffer); /* change to a fixed-width font in the window */ if (use_fixed_width) { GtkTextIter start, end; static GtkTextTag *tt = NULL; if (!tt) { #ifdef win32 const char *fnt = "Courier"; #else const char *fnt = "Mono"; #endif tt = gtk_text_buffer_create_tag(text_buffer, "mono", "font", fnt, NULL); } gtk_text_buffer_get_start_iter(text_buffer, &start); gtk_text_buffer_get_end_iter(text_buffer, &end); gtk_text_buffer_apply_tag(text_buffer, tt, &start, &end); } metadata_label = get_widget_checked("metadata_label"); sprintf(label_text, "Meta Data File: %s", metadata_filename); gtk_label_set_text(GTK_LABEL(metadata_label), label_text); gtk_widget_show(metadata_dialog); /* user may have selected "Display Metadata" when the meta data window was already opened -- bring it to the top */ gtk_window_present(GTK_WINDOW(metadata_dialog)); } else { sprintf(label_text, "The ASF Metadata file was not found:\n %s\n\n" "The ASF Metadata file is generated by the import procedure, " "so you will need\nto process the data before this file is " "available.\n", metadata_filename); message_box(label_text); } g_free(label_text); }
static void gb_vim_do_search_and_replace (GtkTextBuffer *buffer, GtkTextIter *begin, GtkTextIter *end, const gchar *search_text, const gchar *replace_text, gboolean is_global) { GtkSourceSearchContext *search_context; GtkSourceSearchSettings *search_settings; GtkTextMark *mark; GtkTextIter tmp1; GtkTextIter tmp2; GtkTextIter match_begin; GtkTextIter match_end; gboolean has_wrapped = FALSE; GError *error = NULL; g_assert (search_text); g_assert (replace_text); g_assert ((!begin && !end) || (begin && end)); search_settings = gtk_source_search_settings_new (); search_context = gtk_source_search_context_new (GTK_SOURCE_BUFFER (buffer), search_settings); if (!begin) { gtk_text_buffer_get_start_iter (buffer, &tmp1); begin = &tmp1; } if (!end) { gtk_text_buffer_get_end_iter (buffer, &tmp2); end = &tmp2; } mark = gtk_text_buffer_create_mark (buffer, NULL, end, FALSE); gtk_source_search_settings_set_search_text (search_settings, search_text); gtk_source_search_settings_set_case_sensitive (search_settings, TRUE); while (gtk_source_search_context_forward2 (search_context, begin, &match_begin, &match_end, &has_wrapped) && !has_wrapped) { if (is_global || gb_vim_match_is_selected (buffer, &match_begin, &match_end)) { if (!gtk_source_search_context_replace2 (search_context, &match_begin, &match_end, replace_text, -1, &error)) { g_warning ("%s", error->message); g_clear_error (&error); break; } } *begin = match_end; gtk_text_buffer_get_iter_at_mark (buffer, end, mark); } gtk_text_buffer_delete_mark (buffer, mark); g_clear_object (&search_settings); g_clear_object (&search_context); }
void update_poi(GtkWidget *dialog) { GtkTextView *text_view; GtkTextBuffer *buffer; GtkTextIter start, end; GtkWidget *entry, *widget; const char *keyword, *idmd5; char *desc; char *sql; char *db; double lat_deg, lon_deg; int res; widget = lookup_widget(dialog, "label126"); idmd5 = gtk_label_get_text(GTK_LABEL(widget)); entry = lookup_widget(dialog, "entry17"); lat_deg = parse_degrees(gtk_entry_get_text(GTK_ENTRY(entry))); entry = lookup_widget(dialog, "entry18"); lon_deg = parse_degrees(gtk_entry_get_text(GTK_ENTRY(entry))); entry = lookup_widget(dialog, "entry19"); keyword = gtk_entry_get_text(GTK_ENTRY(entry)); text_view = GTK_TEXT_VIEW(lookup_widget(dialog, "textview2")); buffer = gtk_text_view_get_buffer(text_view); gtk_text_buffer_get_start_iter (buffer, &start); gtk_text_buffer_get_end_iter (buffer, &end); desc = gtk_text_buffer_get_text(buffer, &start, &end, TRUE); db = g_strconcat(foxtrotgps_dir, "/", POI_DB, NULL); sql = sqlite3_mprintf ( "UPDATE " "poi " "SET " "lat=%f," "lon=%f," "keywords=%Q," "desc=%Q" "WHERE " "idmd5='%s'" , lat_deg, lon_deg, keyword, desc, idmd5); res = sql_execute(db, sql, NULL); if(res==1) { sql_execute(db, POI_DB_CREATE, NULL); sql_execute(db, sql, NULL); } g_free(desc); sqlite3_free (sql); gtk_widget_destroy(dialog); }
void WAttGtk::change_value_close() { unsigned char *s; int sts; if ( input_open) { if ( input_multiline) { gchar *text, *textutf8; 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); textutf8 = gtk_text_buffer_get_text( cmd_scrolled_buffer, &start_iter, &end_iter, FALSE); text = g_convert( textutf8, -1, "ISO8859-1", "UTF-8", NULL, NULL, NULL); g_free( textutf8); // Replace ctrl characters with space for ( s = (unsigned char *) text; *s; s++) { if ( *s < ' ' && *s != 10 && *s != 13) *s = ' '; } sts = wattnav->set_attr_value( input_node, input_name, text); g_free( text); g_object_set( cmd_scrolledinput, "visible", FALSE, NULL); set_prompt( ""); input_open = 0; int w, h; gdk_drawable_get_size( pane->window, &w, &h); gtk_paned_set_position( GTK_PANED(pane), h - 50); wattnav->redraw(); wattnav->set_inputfocus(); } else { char *text, *textutf8; textutf8 = gtk_editable_get_chars( GTK_EDITABLE(cmd_input), 0, -1); text = g_convert( textutf8, -1, "ISO8859-1", "UTF-8", NULL, NULL, NULL); g_free( textutf8); sts = wattnav->set_attr_value( input_node, input_name, text); g_free( text); g_object_set( cmd_input, "visible", FALSE, NULL); set_prompt( ""); input_open = 0; if ( redraw_cb) (redraw_cb)( this); wattnav->set_inputfocus(); } if ( pending_close) { if ( close_cb) (close_cb)( this); else delete this; } } }
/* Verifies data for New & Properties dialogs. * Returns: FALSE if the user needs to change any data. */ static gboolean update_config(const PropertyDialogElements *e, gboolean new_project) { const gchar *name, *file_name, *base_path; gchar *locale_filename; gint name_len; gint err_code = 0; GeanyProject *p; g_return_val_if_fail(e != NULL, TRUE); name = gtk_entry_get_text(GTK_ENTRY(e->name)); name_len = strlen(name); if (name_len == 0) { SHOW_ERR(_("The specified project name is too short.")); gtk_widget_grab_focus(e->name); return FALSE; } else if (name_len > MAX_NAME_LEN) { SHOW_ERR1(_("The specified project name is too long (max. %d characters)."), MAX_NAME_LEN); gtk_widget_grab_focus(e->name); return FALSE; } if (new_project) file_name = gtk_entry_get_text(GTK_ENTRY(e->file_name)); else file_name = gtk_label_get_text(GTK_LABEL(e->file_name)); if (G_UNLIKELY(! NZV(file_name))) { SHOW_ERR(_("You have specified an invalid project filename.")); gtk_widget_grab_focus(e->file_name); return FALSE; } locale_filename = utils_get_locale_from_utf8(file_name); base_path = gtk_entry_get_text(GTK_ENTRY(e->base_path)); if (NZV(base_path)) { /* check whether the given directory actually exists */ gchar *locale_path = utils_get_locale_from_utf8(base_path); if (! g_path_is_absolute(locale_path)) { /* relative base path, so add base dir of project file name */ gchar *dir = g_path_get_dirname(locale_filename); setptr(locale_path, g_strconcat(dir, G_DIR_SEPARATOR_S, locale_path, NULL)); g_free(dir); } if (! g_file_test(locale_path, G_FILE_TEST_IS_DIR)) { gboolean create_dir; create_dir = dialogs_show_question_full(NULL, GTK_STOCK_OK, GTK_STOCK_CANCEL, _("Create the project's base path directory?"), _("The path \"%s\" does not exist."), base_path); if (create_dir) err_code = utils_mkdir(locale_path, TRUE); if (! create_dir || err_code != 0) { if (err_code != 0) SHOW_ERR1(_("Project base directory could not be created (%s)."), g_strerror(err_code)); gtk_widget_grab_focus(e->base_path); utils_free_pointers(2, locale_path, locale_filename, NULL); return FALSE; } } g_free(locale_path); } /* finally test whether the given project file can be written */ if ((err_code = utils_is_file_writable(locale_filename)) != 0 || (err_code = g_file_test(locale_filename, G_FILE_TEST_IS_DIR) ? EISDIR : 0) != 0) { SHOW_ERR1(_("Project file could not be written (%s)."), g_strerror(err_code)); gtk_widget_grab_focus(e->file_name); g_free(locale_filename); return FALSE; } g_free(locale_filename); if (app->project == NULL) { create_project(); new_project = TRUE; } p = app->project; setptr(p->name, g_strdup(name)); setptr(p->file_name, g_strdup(file_name)); /* use "." if base_path is empty */ setptr(p->base_path, g_strdup(NZV(base_path) ? base_path : "./")); if (! new_project) /* save properties specific fields */ { GtkTextIter start, end; GtkTextBuffer *buffer; GeanyDocument *doc = document_get_current(); GeanyBuildCommand *oldvalue; GeanyFiletype *ft = doc ? doc->file_type : NULL; GtkWidget *widget; gchar *tmp; GString *str; /* get and set the project description */ buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->description)); gtk_text_buffer_get_start_iter(buffer, &start); gtk_text_buffer_get_end_iter(buffer, &end); setptr(p->description, g_strdup(gtk_text_buffer_get_text(buffer, &start, &end, FALSE))); stash_group_update(indent_group, e->dialog); /* read the project build menu */ oldvalue = ft ? ft->projfilecmds : NULL; build_read_project(ft, e->build_properties); if (ft != NULL && ft->projfilecmds != oldvalue && ft->project_list_entry < 0) { if (p->build_filetypes_list == NULL) p->build_filetypes_list = g_ptr_array_new(); ft->project_list_entry = p->build_filetypes_list->len; g_ptr_array_add(p->build_filetypes_list, ft); } build_menu_update(doc); widget = ui_lookup_widget(e->dialog, "radio_long_line_disabled"); if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) p->long_line_behaviour = 0; else { widget = ui_lookup_widget(e->dialog, "radio_long_line_default"); if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) p->long_line_behaviour = 1; else /* "Custom" radio button must be checked */ p->long_line_behaviour = 2; } widget = ui_lookup_widget(e->dialog, "spin_long_line"); p->long_line_column = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget)); apply_editor_prefs(); /* get and set the project file patterns */ tmp = g_strdup(gtk_entry_get_text(GTK_ENTRY(e->patterns))); g_strfreev(p->file_patterns); g_strstrip(tmp); str = g_string_new(tmp); do {} while (utils_string_replace_all(str, " ", " ")); p->file_patterns = g_strsplit(str->str, " ", -1); g_string_free(str, TRUE); g_free(tmp); } update_ui(); return TRUE; }
void set_poi(GtkWidget *dialog) { GtkComboBox *combo_box; GtkTextView *text_view; GtkTextBuffer *buffer; GtkTextIter start, end; GtkWidget *entry, *radiobutton; const char *keyword; char *desc; char *sql; char *db; int visibility, price_range = 0, extended_open; int category, subcategory; double lat_deg, lon_deg; int res; double rand1, rand2; entry = lookup_widget(dialog, "entry14"); lat_deg = parse_degrees(gtk_entry_get_text(GTK_ENTRY(entry))); entry = lookup_widget(dialog, "entry15"); lon_deg = parse_degrees(gtk_entry_get_text(GTK_ENTRY(entry))); radiobutton = lookup_widget(dialog, "radiobutton11"); visibility = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobutton))) ? 1 : 0; combo_box = GTK_COMBO_BOX(lookup_widget(dialog, "combobox2")); category = gtk_combo_box_get_active(combo_box); subcategory = gtk_combo_box_get_active(GTK_COMBO_BOX(combobox_subcat)); entry = lookup_widget(dialog, "entry13"); keyword = gtk_entry_get_text(GTK_ENTRY(entry)); text_view = GTK_TEXT_VIEW(lookup_widget(dialog, "textview1")); buffer = gtk_text_view_get_buffer(text_view); gtk_text_buffer_get_start_iter (buffer, &start); gtk_text_buffer_get_end_iter (buffer, &end); desc = gtk_text_buffer_get_text(buffer, &start, &end, TRUE); radiobutton = lookup_widget(dialog, "radiobutton8"); price_range = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobutton))) ? 1 : price_range; radiobutton = lookup_widget(dialog, "radiobutton9"); price_range = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobutton))) ? 3 : price_range; radiobutton = lookup_widget(dialog, "radiobutton10"); price_range = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobutton))) ? 5 : price_range; radiobutton = lookup_widget(dialog, "checkbutton10"); extended_open = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobutton))) ? 1 : 0; rand1 = g_random_double_range (100000000,1000000000); rand2 = g_random_double_range (100000000,1000000000); db = g_strconcat(foxtrotgps_dir, "/", POI_DB, NULL); sql = sqlite3_mprintf ( "INSERT INTO poi " "(idmd5, lat, lon, visibility, cat, subcat, keywords, desc, price_range, extended_open) " "VALUES ('%.0f%.0f',%f,%f,%d,%d,%d,%Q,%Q,%d,%d)", rand1, rand2, lat_deg, lon_deg, visibility, category, subcategory, keyword, desc, price_range, extended_open); res = sql_execute(db, sql, NULL); if(res==1) { sql_execute(db, POI_DB_CREATE, NULL); sql_execute(db, sql, NULL); } g_free(desc); sqlite3_free (sql); gtk_widget_destroy(dialog); global_poi_cat = category; }
static gboolean chat_text_view_find_next (EmpathyChatView *view, const gchar *search_criteria, gboolean new_search, gboolean match_case) { EmpathyChatTextViewPriv *priv; GtkTextBuffer *buffer; GtkTextIter iter_at_mark; GtkTextIter iter_match_start; GtkTextIter iter_match_end; gboolean found; gboolean from_start = FALSE; g_return_val_if_fail (EMPATHY_IS_CHAT_TEXT_VIEW (view), FALSE); g_return_val_if_fail (search_criteria != NULL, FALSE); priv = GET_PRIV (view); buffer = priv->buffer; if (EMP_STR_EMPTY (search_criteria)) { if (priv->find_mark_next) { gtk_text_buffer_get_start_iter (buffer, &iter_at_mark); gtk_text_buffer_move_mark (buffer, priv->find_mark_next, &iter_at_mark); gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view), priv->find_mark_next, 0.0, TRUE, 0.0, 0.0); gtk_text_buffer_select_range (buffer, &iter_at_mark, &iter_at_mark); } return FALSE; } if (new_search) { from_start = TRUE; } if (!new_search && priv->find_mark_next) { gtk_text_buffer_get_iter_at_mark (buffer, &iter_at_mark, priv->find_mark_next); } else { gtk_text_buffer_get_start_iter (buffer, &iter_at_mark); from_start = TRUE; } priv->find_last_direction = TRUE; /* Use the standard GTK+ method for case sensitive searches. It can't do * case insensitive searches (see bug #61852), so keep the custom method * around for case insensitive searches. */ if (match_case) { found = gtk_text_iter_forward_search (&iter_at_mark, search_criteria, 0, &iter_match_start, &iter_match_end, NULL); } else { found = empathy_text_iter_forward_search (&iter_at_mark, search_criteria, &iter_match_start, &iter_match_end, NULL); } if (!found) { gboolean result = FALSE; if (from_start) { return result; } /* Here we wrap around. */ if (!new_search && !priv->find_wrapped) { priv->find_wrapped = TRUE; result = chat_text_view_find_next (view, search_criteria, FALSE, match_case); priv->find_wrapped = FALSE; } return result; } /* Set new mark and show on screen */ if (!priv->find_mark_next) { priv->find_mark_next = gtk_text_buffer_create_mark (buffer, NULL, &iter_match_end, TRUE); } else { gtk_text_buffer_move_mark (buffer, priv->find_mark_next, &iter_match_end); } if (!priv->find_mark_previous) { priv->find_mark_previous = gtk_text_buffer_create_mark (buffer, NULL, &iter_match_start, TRUE); } else { gtk_text_buffer_move_mark (buffer, priv->find_mark_previous, &iter_match_start); } gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view), priv->find_mark_next, 0.0, TRUE, 0.5, 0.5); gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &iter_match_start); gtk_text_buffer_move_mark_by_name (buffer, "insert", &iter_match_end); return TRUE; }
static void chat_text_view_find_abilities (EmpathyChatView *view, const gchar *search_criteria, gboolean match_case, gboolean *can_do_previous, gboolean *can_do_next) { EmpathyChatTextViewPriv *priv; GtkTextBuffer *buffer; GtkTextIter iter_at_mark; GtkTextIter iter_match_start; GtkTextIter iter_match_end; g_return_if_fail (EMPATHY_IS_CHAT_TEXT_VIEW (view)); g_return_if_fail (search_criteria != NULL); g_return_if_fail (can_do_previous != NULL && can_do_next != NULL); priv = GET_PRIV (view); buffer = priv->buffer; if (can_do_previous) { if (priv->find_mark_previous) { gtk_text_buffer_get_iter_at_mark (buffer, &iter_at_mark, priv->find_mark_previous); } else { gtk_text_buffer_get_start_iter (buffer, &iter_at_mark); } if (match_case) { *can_do_previous = gtk_text_iter_backward_search (&iter_at_mark, search_criteria, 0, &iter_match_start, &iter_match_end, NULL); } else { *can_do_previous = empathy_text_iter_backward_search (&iter_at_mark, search_criteria, &iter_match_start, &iter_match_end, NULL); } } if (can_do_next) { if (priv->find_mark_next) { gtk_text_buffer_get_iter_at_mark (buffer, &iter_at_mark, priv->find_mark_next); } else { gtk_text_buffer_get_start_iter (buffer, &iter_at_mark); } if (match_case) { *can_do_next = gtk_text_iter_forward_search (&iter_at_mark, search_criteria, 0, &iter_match_start, &iter_match_end, NULL); } else { *can_do_next = empathy_text_iter_forward_search (&iter_at_mark, search_criteria, &iter_match_start, &iter_match_end, NULL); } } }
/*! *\brief show crash dialog * *\param text Description *\param debug_output Output text by gdb * *\return GtkWidget * Dialog widget */ static GtkWidget *crash_dialog_show(const gchar *text, const gchar *debug_output) { GtkWidget *window1; GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *label1; GtkWidget *frame1; GtkWidget *scrolledwindow1; GtkWidget *text1; GtkWidget *hbuttonbox3; GtkWidget *hbuttonbox4; GtkWidget *button3; GtkWidget *button4; GtkWidget *button5; gchar *crash_report; GtkTextBuffer *buffer; GtkTextIter iter; window1 = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "crash"); gtk_container_set_border_width(GTK_CONTAINER(window1), 5); gtk_window_set_title(GTK_WINDOW(window1), _("Claws Mail has crashed")); gtk_window_set_position(GTK_WINDOW(window1), GTK_WIN_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(window1), TRUE); gtk_window_set_default_size(GTK_WINDOW(window1), 460, 272); vbox1 = gtk_vbox_new(FALSE, 2); gtk_widget_show(vbox1); gtk_container_add(GTK_CONTAINER(window1), vbox1); hbox1 = gtk_hbox_new(FALSE, 4); gtk_widget_show(hbox1); gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(hbox1), 4); label1 = gtk_label_new (g_strdup_printf(_("%s.\nPlease file a bug report and include the information below."), text)); gtk_widget_show(label1); gtk_box_pack_start(GTK_BOX(hbox1), label1, TRUE, TRUE, 0); gtk_misc_set_alignment(GTK_MISC(label1), 7.45058e-09, 0.5); frame1 = gtk_frame_new(_("Debug log")); gtk_widget_show(frame1); gtk_box_pack_start(GTK_BOX(vbox1), frame1, TRUE, TRUE, 0); scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow1); gtk_container_add(GTK_CONTAINER(frame1), scrolledwindow1); gtk_container_set_border_width(GTK_CONTAINER(scrolledwindow1), 3); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); text1 = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(text1), FALSE); gtk_widget_show(text1); gtk_container_add(GTK_CONTAINER(scrolledwindow1), text1); crash_report = g_strdup_printf( "Claws Mail version %s\n" "GTK+ version %d.%d.%d / GLib %d.%d.%d\n" "Locale: %s (charset: %s)\n" "Features:%s\n" "Operating system: %s\n" "C Library: %s\n--\n%s", VERSION, gtk_major_version, gtk_minor_version, gtk_micro_version, glib_major_version, glib_minor_version, glib_micro_version, conv_get_current_locale(), conv_get_locale_charset_str(), get_compiled_in_features(), get_operating_system(), get_lib_version(), debug_output); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text1)); gtk_text_buffer_get_start_iter(buffer, &iter); gtk_text_buffer_insert(buffer, &iter, crash_report, -1); hbuttonbox3 = gtk_hbutton_box_new(); gtk_widget_show(hbuttonbox3); gtk_box_pack_start(GTK_BOX(vbox1), hbuttonbox3, FALSE, FALSE, 0); hbuttonbox4 = gtk_hbutton_box_new(); gtk_widget_show(hbuttonbox4); gtk_box_pack_start(GTK_BOX(vbox1), hbuttonbox4, FALSE, FALSE, 0); button3 = gtk_button_new_with_label(_("Close")); gtk_widget_show(button3); gtk_container_add(GTK_CONTAINER(hbuttonbox4), button3); gtkut_widget_set_can_default(button3, TRUE); button4 = gtk_button_new_with_label(_("Save...")); gtk_widget_show(button4); gtk_container_add(GTK_CONTAINER(hbuttonbox4), button4); gtkut_widget_set_can_default(button4, TRUE); button5 = gtk_button_new_with_label(_("Create bug report")); gtk_widget_show(button5); gtk_container_add(GTK_CONTAINER(hbuttonbox4), button5); gtkut_widget_set_can_default(button5, TRUE); g_signal_connect(G_OBJECT(window1), "delete_event", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(G_OBJECT(button3), "clicked", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(G_OBJECT(button4), "clicked", G_CALLBACK(crash_save_crash_log), crash_report); g_signal_connect(G_OBJECT(button5), "clicked", G_CALLBACK(crash_create_bug_report), NULL); MANAGE_WINDOW_SIGNALS_CONNECT(window1); gtk_widget_show(window1); gtk_main(); return window1; }
/* * Links can be activated by pressing Enter. */ static gboolean key_press_event (GtkWidget *text_view, GdkEventKey *event, GdauiCloud *cloud) { GtkTextIter iter; GtkTextBuffer *buffer; switch (event->keyval) { case GDK_KEY_Return: case GDK_KEY_space: case GDK_KEY_KP_Enter: buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)); gtk_text_buffer_get_iter_at_mark (buffer, &iter, gtk_text_buffer_get_insert (buffer)); follow_if_link (text_view, &iter, cloud); return TRUE; case GDK_KEY_Up: case GDK_KEY_Down: case GDK_KEY_Left: case GDK_KEY_Right: if ((cloud->priv->selection_mode == GTK_SELECTION_SINGLE) || (cloud->priv->selection_mode == GTK_SELECTION_BROWSE)) { GtkTextIter iter; if (cloud->priv->selected_tags) { GtkTextMark *mark; mark = gtk_text_buffer_get_insert (cloud->priv->tbuffer); gtk_text_buffer_get_iter_at_mark (cloud->priv->tbuffer, &iter, mark); } else if ((event->keyval == GDK_KEY_Right) || (event->keyval == GDK_KEY_Down)) gtk_text_buffer_get_start_iter (cloud->priv->tbuffer, &iter); else gtk_text_buffer_get_end_iter (cloud->priv->tbuffer, &iter); gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (cloud->priv->tview), TRUE); while (1) { /* loop to move the cursor enough positions to change the selected item */ gboolean done = FALSE; GtkMovementStep mvt_type; gint mvt_amount; switch (event->keyval) { case GDK_KEY_Up: done = ! gtk_text_view_backward_display_line ((GtkTextView*)cloud->priv->tview, &iter); mvt_type = GTK_MOVEMENT_DISPLAY_LINES; mvt_amount = -1; break; case GDK_KEY_Down: done = ! gtk_text_view_forward_display_line ((GtkTextView*)cloud->priv->tview, &iter); mvt_type = GTK_MOVEMENT_DISPLAY_LINES; mvt_amount = 1; break; case GDK_KEY_Left: done = ! gtk_text_iter_backward_char (&iter); mvt_type = GTK_MOVEMENT_VISUAL_POSITIONS; mvt_amount = -1; break; default: case GDK_KEY_Right: done = ! gtk_text_iter_forward_char (&iter); mvt_type = GTK_MOVEMENT_VISUAL_POSITIONS; mvt_amount = 1; break; } if (done) break; /* end of treatment as no movement possible */ g_signal_emit_by_name (cloud->priv->tview, "move-cursor", mvt_type, mvt_amount, FALSE); GtkTextMark *mark; mark = gtk_text_buffer_get_insert (cloud->priv->tbuffer); gtk_text_buffer_get_iter_at_mark (cloud->priv->tbuffer, &iter, mark); GSList *tags, *tagp; done = FALSE; tags = gtk_text_iter_get_tags (&iter); for (tagp = tags; tagp; tagp = tagp->next) { GtkTextTag *tag = (GtkTextTag*) tagp->data; gint row; row = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tag), "row")) - 1; if (row >= 0) { if ((cloud->priv->selected_tags && (tag != cloud->priv->selected_tags->data)) || !cloud->priv->selected_tags) { row_clicked (cloud, row, tag); done = TRUE; break; } } } if (tags) g_slist_free (tags); if (done) { GtkTextMark *mark; mark = gtk_text_buffer_get_insert (cloud->priv->tbuffer); gtk_text_view_scroll_mark_onscreen ((GtkTextView*)cloud->priv->tview, mark); break; } } gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (cloud->priv->tview), FALSE); return TRUE; } default: break; } return FALSE; }
void WAttGtk::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 = wattnav->check_attr( &multiline, &input_node, input_name, &value, &input_size); if ( EVEN(sts)) { if ( sts == WATT__NOATTRSEL) message( 'E', "No attribute is selected"); else message( 'E', wnav_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); gtk_widget_grab_focus( cmd_scrolledtextview); input_max_length = input_size; input_multiline = 1; } else { text_w = cmd_input; g_object_set( text_w, "visible", TRUE, "max-length", input_size, NULL); 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); char *textutf8 = g_convert( value, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL); gtk_text_buffer_insert( cmd_scrolled_buffer, &start_iter, textutf8, -1); g_free( textutf8); // 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 { char *textutf8 = g_convert( value, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL); gint pos = 0; gtk_editable_delete_text( GTK_EDITABLE(cmd_input), 0, -1); gtk_editable_insert_text( GTK_EDITABLE(text_w), textutf8, strlen(textutf8), &pos); g_free( textutf8); // 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); } set_prompt( "value >"); input_open = 1; }
static void attach_widgets (GtkTextView *text_view) { GtkTextIter iter; GtkTextBuffer *buffer; int i; buffer = gtk_text_view_get_buffer (text_view); gtk_text_buffer_get_start_iter (buffer, &iter); i = 0; while (find_anchor (&iter)) { GtkTextChildAnchor *anchor; GtkWidget *widget; anchor = gtk_text_iter_get_child_anchor (&iter); if (i == 0) { widget = gtk_button_new_with_label ("Click Me"); g_signal_connect (widget, "clicked", G_CALLBACK (easter_egg_callback), NULL); } else if (i == 1) { widget = gtk_combo_box_new_text (); gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Option 1"); gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Option 2"); gtk_combo_box_append_text (GTK_COMBO_BOX (widget), "Option 3"); } else if (i == 2) { widget = gtk_hscale_new (NULL); gtk_range_set_range (GTK_RANGE (widget), 0, 100); gtk_widget_set_size_request (widget, 70, -1); } else if (i == 3) { gchar *filename = demo_find_file ("floppybuddy.gif", NULL); widget = gtk_image_new_from_file (filename); g_free (filename); } else if (i == 4) { widget = gtk_entry_new (); } else { widget = NULL; /* avoids a compiler warning */ g_assert_not_reached (); } gtk_text_view_add_child_at_anchor (text_view, widget, anchor); gtk_widget_show_all (widget); ++i; } }
void gretl_console (void) { char cbuf[MAXLINE]; windata_t *vwin; GtkTextBuffer *buf; GtkTextIter iter; ExecState *state; const gchar *intro = N_("gretl console: type 'help' for a list of commands"); if (console_main != NULL) { gtk_window_present(GTK_WINDOW(console_main)); return; } state = gretl_console_init(cbuf); if (state == NULL) { return; } console_state = state; vwin = console_window(78, 400); console_text = vwin->text; console_main = vwin->main; g_signal_connect(G_OBJECT(vwin->text), "paste-clipboard", G_CALLBACK(console_paste_handler), NULL); g_signal_connect(G_OBJECT(vwin->text), "button-press-event", G_CALLBACK(console_click_handler), NULL); g_signal_connect(G_OBJECT(vwin->text), "button-release-event", G_CALLBACK(console_mouse_handler), NULL); g_signal_connect(G_OBJECT(vwin->text), "key-press-event", G_CALLBACK(console_key_handler), NULL); g_signal_connect(G_OBJECT(vwin->main), "destroy", G_CALLBACK(console_quit), state); g_signal_connect(G_OBJECT(vwin->main), "destroy", G_CALLBACK(gtk_widget_destroyed), &console_main); g_signal_connect(G_OBJECT(vwin->main), "destroy", G_CALLBACK(gtk_widget_destroyed), &console_text); g_object_set_data(G_OBJECT(vwin->text), "ExecState", state); buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(vwin->text)); gtk_text_buffer_get_start_iter(buf, &iter); /* insert intro string and first prompt */ gtk_text_buffer_insert(buf, &iter, _(intro), -1); console_insert_prompt(buf, &iter, "\n? "); gtk_widget_grab_focus(vwin->text); set_debug_read_func(console_get_line); set_debug_output_func(console_update_callback); /* console command loop */ while (state->cmd->ci != QUIT) { console_get_line(state); if (state->cmd->ci != QUIT) { update_console(state, vwin->text); } } if (console_main != NULL) { /* the user actually typed quit/exit */ gtk_widget_destroy(vwin->main); } command_history_destroy(); gretl_print_destroy(state->prn); free(state); set_debug_read_func(NULL); set_debug_output_func(NULL); reset_console_globals(); #if CDEBUG fprintf(stderr, "gretl_console: returning\n"); #endif }
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; }
static void run_smartquotes(GtkTextBuffer *buffer) { GtkTextIter pos, nextpos; gunichar lastc = 0, c = 0, nextc; int balance[10] = {0}; /* max 10 levels of nesting. */ int curnesting = -1; gboolean insidetag = FALSE, closing; int quotes; /* this runs as the user is typing, so undo doesn't make much sense. gtk_text_buffer_begin_user_action(buffer); */ gtk_text_buffer_get_start_iter(buffer, &pos); while ((c = gtk_text_iter_get_char(&pos)) != 0) { nextpos = pos; gtk_text_iter_forward_char(&nextpos); nextc = gtk_text_iter_get_char(&nextpos); /*g_printf("ofs %d\n", gtk_text_iter_get_offset(&pos));*/ if (c == '<') insidetag = TRUE; else if (c == '>') insidetag = FALSE; quotes = count_quotes(c); if (insidetag || quotes == 0) { lastc = c; gtk_text_iter_forward_char(&pos); continue; } closing = (curnesting >= 0 && balance[curnesting] == quotes); if (quotes == 1 && g_unichar_isalnum(lastc) && (!closing || g_unichar_isalnum(nextc))) { /* an apostrophe. fix it up, but don't change nesting. */ /*g_print("n %d apos %c\n", curnesting, (char)c);*/ buffer_change_quote(buffer, &pos, &nextpos, c, UNICODE_RIGHTSINGLEQUOTE); } else if (closing) { /*g_print("n %d right %c\n", curnesting, (char)c);*/ buffer_change_quote(buffer, &pos, &nextpos, c, quotes == 1 ? UNICODE_RIGHTSINGLEQUOTE : UNICODE_RIGHTDOUBLEQUOTE); curnesting--; } else { /*g_print("n %d left %c\n", curnesting, (char)c);*/ buffer_change_quote(buffer, &pos, &nextpos, c, quotes == 1 ? UNICODE_LEFTSINGLEQUOTE : UNICODE_LEFTDOUBLEQUOTE); curnesting++; balance[curnesting] = quotes; } if (curnesting >= 9) { g_warning("too many nested quotes."); } lastc = c; gtk_text_iter_forward_char(&pos); } /* gtk_text_buffer_end_user_action(buffer); */ }
static void notify_name_change (AtkObject *atk_obj) { GtkLabel *label; GailLabel *gail_label; GtkWidget *widget; GObject *gail_obj; widget = GTK_ACCESSIBLE (atk_obj)->widget; if (widget == NULL) /* * State is defunct */ return; gail_obj = G_OBJECT (atk_obj); label = GTK_LABEL (widget); gail_label = GAIL_LABEL (atk_obj); if (gail_label->textutil == NULL) return; /* * Check whether the label has actually changed before emitting * notification. */ if (gail_label->textutil->buffer) { GtkTextIter start, end; const char *new_label; char *old_label; int same; gtk_text_buffer_get_start_iter (gail_label->textutil->buffer, &start); gtk_text_buffer_get_end_iter (gail_label->textutil->buffer, &end); old_label = gtk_text_buffer_get_text (gail_label->textutil->buffer, &start, &end, FALSE); new_label = gtk_label_get_text (label); same = strcmp (new_label, old_label); g_free (old_label); if (same == 0) return; } /* Create a delete text and an insert text signal */ g_signal_emit_by_name (gail_obj, "text_changed::delete", 0, gail_label->label_length); gail_label_init_text_util (gail_label, widget); g_signal_emit_by_name (gail_obj, "text_changed::insert", 0, gail_label->label_length); if (atk_obj->name == NULL) /* * The label has changed so notify a change in accessible-name */ g_object_notify (gail_obj, "accessible-name"); g_signal_emit_by_name (gail_obj, "visible_data_changed"); }
GtkWidget * font_color_prefs_show(void) { GtkWidget *main_vb, *main_grid, *label, *combo_box; GtkWidget *font_sample, *color_sample, *colorsel; static const gchar *mt[] = { "Marked packet foreground", /* MFG_IDX 0*/ "Marked packet background", /* MBG_IDX 1*/ "Ignored packet foreground", /* IFG_IDX 2*/ "Ignored packet background", /* IBG_IDX 3*/ "'Follow Stream' client foreground", /* CFG_IDX 4*/ "'Follow Stream' client background", /* CBG_IDX 5*/ "'Follow Stream' server foreground", /* SFG_IDX 6*/ "'Follow Stream' server background", /* SBG_IDX 7*/ "Valid filter text entry", /* FTV_IDX 8*/ "Invalid filter text entry", /* FTI_IDX 9*/ "Deprecated filter text entry" /* FTD_IDX 10*/ }; int mcount = sizeof(mt) / sizeof (gchar *); GtkTextBuffer *buf; GtkTextIter iter; GRand *rand_state = g_rand_new(); GString *preview_string = g_string_new(""); int i; #define GRID_FONT_ROW 0 #define GRID_COLOR_ROW 1 #define GRID_COLOR_SEL_ROW 3 /* The font hasn't been changed yet. */ font_changed = FALSE; color_t_to_gdkxxx(&tcolors[MFG_IDX], &prefs.gui_marked_fg); color_t_to_gdkxxx(&tcolors[MBG_IDX], &prefs.gui_marked_bg); color_t_to_gdkxxx(&tcolors[IFG_IDX], &prefs.gui_ignored_fg); color_t_to_gdkxxx(&tcolors[IBG_IDX], &prefs.gui_ignored_bg); color_t_to_gdkxxx(&tcolors[CFG_IDX], &prefs.st_client_fg); color_t_to_gdkxxx(&tcolors[CBG_IDX], &prefs.st_client_bg); color_t_to_gdkxxx(&tcolors[SFG_IDX], &prefs.st_server_fg); color_t_to_gdkxxx(&tcolors[SBG_IDX], &prefs.st_server_bg); color_t_to_gdkxxx(&tcolors[FTV_IDX], &prefs.gui_text_valid); color_t_to_gdkxxx(&tcolors[FTI_IDX], &prefs.gui_text_invalid); color_t_to_gdkxxx(&tcolors[FTD_IDX], &prefs.gui_text_deprecated); color_t_to_gdkxxx(&filter_text_fg, &filter_text_fg_color); #if ! GTK_CHECK_VERSION(3,4,0) for (i=0; i<MAX_IDX; i++) { tcolors_orig[i] = tcolors[i]; } #endif curcolor = &tcolors[CFG_IDX]; /* Enclosing containers for each row of widgets */ main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 5, FALSE); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); main_grid = ws_gtk_grid_new(); gtk_box_pack_start(GTK_BOX(main_vb), main_grid, FALSE, FALSE, 0); ws_gtk_grid_set_row_spacing(GTK_GRID(main_grid), 40); ws_gtk_grid_set_column_spacing(GTK_GRID(main_grid), 15); gtk_widget_show(main_grid); label = gtk_label_new("Main window font:"); gtk_misc_set_alignment(GTK_MISC(label), 1.0f, 0.5f); ws_gtk_grid_attach_extended(GTK_GRID(main_grid), label, 0, GRID_FONT_ROW, 1, 1, (GtkAttachOptions)(GTK_EXPAND|GTK_FILL), (GtkAttachOptions)0, 0, 0); gtk_widget_show(label); font_button = gtk_font_button_new_with_font(prefs.gui_gtk2_font_name); gtk_font_button_set_title(GTK_FONT_BUTTON(font_button), "Wireshark: Font"); ws_gtk_grid_attach(GTK_GRID(main_grid), font_button, 1, GRID_FONT_ROW, 1, 1); gtk_widget_show(font_button); g_string_printf(preview_string, " %s 0123456789", font_pangrams[g_rand_int_range(rand_state, 0, NUM_FONT_PANGRAMS)]); font_sample = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(font_sample), FALSE); buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(font_sample)); gtk_text_buffer_get_start_iter(buf, &iter); srand((unsigned int) time(NULL)); gtk_text_buffer_insert(buf, &iter, preview_string->str, -1); ws_gtk_grid_attach_extended(GTK_GRID(main_grid), font_sample, 2, GRID_FONT_ROW, 1, 1, (GtkAttachOptions)(GTK_EXPAND|GTK_FILL), (GtkAttachOptions)0, 0, 0); g_signal_connect(font_button, "font-set", G_CALLBACK(select_font), NULL); gtk_widget_show(font_sample); g_string_free(preview_string, TRUE); g_object_set_data(G_OBJECT(font_button), FONT_SAMPLE_KEY, font_sample); label = gtk_label_new("Colors:"); gtk_misc_set_alignment(GTK_MISC(label), 1.0f, 0.5f); ws_gtk_grid_attach_extended(GTK_GRID(main_grid), label, 0, GRID_COLOR_ROW, 1, 1, (GtkAttachOptions)(GTK_EXPAND|GTK_FILL), (GtkAttachOptions)0, 0,0); gtk_widget_show(label); /* We have to create this now, and configure it below. */ #if GTK_CHECK_VERSION(3,4,0) /* XXX: There appears to be a bug in the GTK3 GtkColorChooserWidget such that * when in the GtkColorChooserWidget "customize" mode (aka "color-edit" mode) * selecting a color doesn't trigger a "motify::rgba" callback. * The effect is that the sample text FG/BG colors don't update for the GTK3 * GtkColorChooserWidget in "custon color edit node"). * I expect use of the "customize mode" will be minimal and that the bug will * not be very noticeable. * (A GTK3 bug report has beem submitted. */ #endif colorsel = gtk_color_xxx_new(); combo_box = gtk_combo_box_text_new(); for (i = 0; i < mcount; i++){ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), mt[i]); } gtk_combo_box_set_active(GTK_COMBO_BOX(combo_box), CFG_IDX); g_signal_connect(combo_box, "changed", G_CALLBACK(update_current_color), colorsel); ws_gtk_grid_attach(GTK_GRID(main_grid), combo_box, 1, GRID_COLOR_ROW, 1, 1); gtk_widget_show(combo_box); color_sample = gtk_text_view_new(); update_font(user_font_get_regular(), font_sample, color_sample); gtk_text_view_set_editable(GTK_TEXT_VIEW(color_sample), FALSE); buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(color_sample)); gtk_text_buffer_get_start_iter(buf, &iter); gtk_text_buffer_create_tag(buf, "marked", TAG_PROP_FG_COLOR, &tcolors[MFG_IDX], TAG_PROP_BG_COLOR, &tcolors[MBG_IDX], NULL); gtk_text_buffer_create_tag(buf, "ignored", TAG_PROP_FG_COLOR, &tcolors[IFG_IDX], TAG_PROP_BG_COLOR, &tcolors[IBG_IDX], NULL); gtk_text_buffer_create_tag(buf, "client", TAG_PROP_FG_COLOR, &tcolors[CFG_IDX], TAG_PROP_BG_COLOR, &tcolors[CBG_IDX], NULL); gtk_text_buffer_create_tag(buf, "server", TAG_PROP_FG_COLOR, &tcolors[SFG_IDX], TAG_PROP_BG_COLOR, &tcolors[SBG_IDX], NULL); gtk_text_buffer_create_tag(buf, "text_valid", TAG_PROP_FG_COLOR, &filter_text_fg, TAG_PROP_BG_COLOR, &tcolors[FTV_IDX], NULL); gtk_text_buffer_create_tag(buf, "text_invalid", TAG_PROP_FG_COLOR, &filter_text_fg, TAG_PROP_BG_COLOR, &tcolors[FTI_IDX], NULL); gtk_text_buffer_create_tag(buf, "text_deprecated", TAG_PROP_FG_COLOR, &filter_text_fg, TAG_PROP_BG_COLOR, &tcolors[FTD_IDX], NULL); gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_MARKED_TEXT, -1, "marked", NULL); gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_IGNORED_TEXT, -1, "ignored", NULL); gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_CLIENT_TEXT, -1, "client", NULL); gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_SERVER_TEXT, -1, "server", NULL); gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_TEXT_VALID_TEXT, -1, "text_valid", NULL); gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_TEXT_INVALID_TEXT, -1, "text_invalid", NULL); gtk_text_buffer_insert_with_tags_by_name(buf, &iter, SAMPLE_TEXT_DEPRECATED_TEXT, -1, "text_deprecated", NULL); ws_gtk_grid_attach_extended(GTK_GRID(main_grid), color_sample, 2, GRID_COLOR_ROW, 1, 2, (GtkAttachOptions)(GTK_EXPAND|GTK_FILL), (GtkAttachOptions)0, 0, 0); gtk_widget_show(color_sample); gtk_color_xxx_set_yyy(GTK_COLOR_XXX(colorsel), curcolor); ws_gtk_grid_attach_extended(GTK_GRID(main_grid), colorsel, 1, GRID_COLOR_SEL_ROW, 2, 1, (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), (GtkAttachOptions)0, 0, 0); g_object_set_data(G_OBJECT(combo_box), COLOR_SAMPLE_KEY, color_sample); g_object_set_data(G_OBJECT(colorsel), COLOR_SAMPLE_KEY, color_sample); g_signal_connect(colorsel, COLOR_CHANGED_SIGNAL, G_CALLBACK(update_text_color), NULL); gtk_widget_show(colorsel); g_rand_free(rand_state); gtk_widget_show(main_vb); return main_vb; }
bool WindowCheckKeyterms::find_renderings (const ustring& text, const vector <ustring>& renderings, const vector <bool>& wholewords, const vector <bool>& casesensitives, vector <size_t> * startpositions, vector <size_t> * lengths) // Finds renderings in the text. // text: Text to be looked into. // renderings: Renderings to look for. // wholewords / casesensitives: Attributes of the renderings. // startpositions: If non-NULL, will be filled with the positions that each rendering starts at. // lengths: If non-NULL, will be filled with the lengths of the renderings found. // Returns whether one or more renderings were found in the verse. { if (startpositions) startpositions->clear(); if (lengths) lengths->clear(); GtkTextBuffer * textbuffer = gtk_text_buffer_new (NULL); gtk_text_buffer_set_text (textbuffer, text.c_str(), -1); GtkTextIter startiter; gtk_text_buffer_get_start_iter(textbuffer, &startiter); bool found = false; for (unsigned int i2 = 0; i2 < renderings.size(); i2++) { ustring rendering = renderings[i2]; bool wholeword = wholewords[i2]; bool casesensitive = casesensitives[i2]; ustring mytext; ustring myrendering; if (casesensitive) { mytext = text; myrendering = rendering; } else { mytext = text.casefold(); myrendering = rendering.casefold(); } size_t position = mytext.find(myrendering); while (position != string::npos) { bool temporally_approved = true; GtkTextIter approvedstart = startiter; GtkTextIter approvedend; gtk_text_iter_forward_chars(&approvedstart, position); approvedend = approvedstart; gtk_text_iter_forward_chars(&approvedend, rendering.length()); if (wholeword) { if (!gtk_text_iter_starts_word(&approvedstart)) temporally_approved = false; if (!gtk_text_iter_ends_word(&approvedend)) temporally_approved = false; } if (temporally_approved) { found = true; if (startpositions) startpositions->push_back (position); if (lengths) lengths->push_back (rendering.length()); } position = mytext.find(myrendering, ++position); } } g_object_unref (textbuffer); return found; }
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 document_replace_real(GtkWidget *textview) { GtkTextIter iter, match_start, match_end, rep_start; GtkTextMark *mark_init = NULL; gboolean res; gint num = 0, offset; GtkWidget *q_dialog = NULL; GtkSourceSearchFlags search_flags = GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_TEXT_ONLY; GtkTextBuffer *textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); if (!match_case) search_flags = search_flags | GTK_SOURCE_SEARCH_CASE_INSENSITIVE; if (replace_all) { gtk_text_buffer_get_iter_at_mark(textbuffer, &iter, gtk_text_buffer_get_insert(textbuffer)); mark_init = gtk_text_buffer_create_mark(textbuffer, NULL, &iter, FALSE); gtk_text_buffer_get_start_iter(textbuffer, &iter); gtk_text_buffer_get_end_iter(textbuffer, &match_end); // gtk_text_buffer_remove_tag_by_name(textbuffer, // "replaced", &iter, &match_end); gtk_text_buffer_remove_all_tags(textbuffer, &iter, &match_end); } else { hlight_searched_strings(textbuffer, string_find); hlight_toggle_searched(textbuffer); } do { if (replace_all) { res = gtk_source_iter_forward_search( &iter, string_find, search_flags, &match_start, &match_end, NULL); if (res) { gtk_text_buffer_place_cursor(textbuffer, &match_start); gtk_text_buffer_move_mark_by_name(textbuffer, "insert", &match_end); gtk_text_buffer_get_iter_at_mark( textbuffer, &iter, gtk_text_buffer_get_insert(textbuffer)); } } else // res = document_search_real(textview, 0); res = document_search_real(textview, 2); if (res) { if (!replace_all) { if (num == 0 && q_dialog == NULL) q_dialog = create_dialog_message_question( gtk_widget_get_toplevel(textview), _("Replace?")); #if GTK_CHECK_VERSION(2, 10, 0) GtkTextIter ins,bou; gtk_text_buffer_get_selection_bounds(textbuffer, &ins, &bou); #endif switch (gtk_dialog_run(GTK_DIALOG(q_dialog))) { case GTK_RESPONSE_YES: #if GTK_CHECK_VERSION(2, 10, 0) gtk_text_buffer_select_range(textbuffer, &ins, &bou); #endif break; case GTK_RESPONSE_NO: continue; // case GTK_RESPONSE_CANCEL: default: res = 0; if (num == 0) num = -1; continue; } } gtk_text_buffer_delete_selection(textbuffer, TRUE, TRUE); if (strlen(string_replace)) { gtk_text_buffer_get_iter_at_mark( textbuffer, &rep_start, gtk_text_buffer_get_insert(textbuffer)); offset = gtk_text_iter_get_offset(&rep_start); undo_set_sequency(TRUE); g_signal_emit_by_name(G_OBJECT(textbuffer), "begin-user-action"); gtk_text_buffer_insert_at_cursor(textbuffer, string_replace, strlen(string_replace)); g_signal_emit_by_name(G_OBJECT(textbuffer), "end-user-action"); gtk_text_buffer_get_iter_at_mark( textbuffer, &iter, gtk_text_buffer_get_insert(textbuffer)); gtk_text_buffer_get_iter_at_offset(textbuffer, &rep_start, offset); gtk_text_buffer_apply_tag_by_name(textbuffer, "replaced", &rep_start, &iter); } else gtk_text_buffer_get_iter_at_mark( textbuffer, &iter, gtk_text_buffer_get_insert(textbuffer)); num++; /* if (replace_all) undo_set_sequency(TRUE); else undo_set_sequency(FALSE);*/ undo_set_sequency(replace_all); } } while (res); if (!hlight_check_searched()) hlight_toggle_searched(textbuffer); if (q_dialog) gtk_widget_destroy(q_dialog); /* if (strlen(string_replace)) { replace_mode = TRUE; hlight_searched_strings(textbuffer, string_replace); } */ if (replace_all) { gtk_text_buffer_get_iter_at_mark(textbuffer, &iter, mark_init); gtk_text_buffer_place_cursor(textbuffer, &iter); run_dialog_message(gtk_widget_get_toplevel(textview), GTK_MESSAGE_INFO, _("%d strings replaced"), num); undo_set_sequency(FALSE); } return num; }
static void 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)); }
gint main(gint argc, gchar **argv) { Conf *conf; GtkItemFactory *ifactory; gchar *stdin_data = NULL; bindtextdomain(PACKAGE, LOCALEDIR); //bindtextdomain ?? bind_textdomain_codeset(PACKAGE, "UTF-8"); // ?? textdomain(PACKAGE); // ?? pub = g_malloc(sizeof(PublicData)); pub->fi = g_malloc(sizeof(FileInfo)); pub->fi->filename = NULL; pub->fi->charset = NULL; pub->fi->charset_flag = FALSE; pub->fi->lineend = LF; parse_args(argc, argv, pub->fi); gtk_init(&argc, &argv); //call before using any gtk fuction g_set_application_name(PACKAGE_NAME); g_print("%s\n", PACKAGE_NAME); #if !GTK_CHECK_VERSION(2, 6, 0) add_about_stock(); #endif pub->mw = create_main_window(); //Find create_main_window conf = g_malloc(sizeof(Conf)); //sends default vlues to load and overwrites in the function conf->width = 600; conf->height = 400; conf->fontname = g_strdup("Monospace 12"); conf->wordwrap = FALSE; conf->linenumbers = FALSE; conf->autoindent = FALSE; load_config_file(conf); //gtk options for GUI gtk_window_set_default_size( GTK_WINDOW(pub->mw->window), conf->width, conf->height); set_text_font_by_name(pub->mw->view, conf->fontname); ifactory = gtk_item_factory_from_widget(pub->mw->menubar); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM( gtk_item_factory_get_widget(ifactory, "/Options/Word Wrap")), conf->wordwrap); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM( gtk_item_factory_get_widget(ifactory, "/Options/Line Numbers")), conf->linenumbers); indent_refresh_tab_width(pub->mw->view); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM( gtk_item_factory_get_widget(ifactory, "/Options/Auto Indent")), conf->autoindent); gtk_widget_show_all(pub->mw->window); g_free(conf->fontname); g_free(conf); #ifdef ENABLE_EMACS check_emacs_key_theme(GTK_WINDOW(pub->mw->window), ifactory); #endif hlight_init(pub->mw->buffer); undo_init(pub->mw->view, gtk_item_factory_get_widget(ifactory, "/Edit/Undo"), gtk_item_factory_get_widget(ifactory, "/Edit/Redo")); // hlight_init(pub->mw->buffer); dnd_init(pub->mw->view); if (pub->fi->filename) file_open_real(pub->mw->view, pub->fi); #ifdef G_OS_UNIX else stdin_data = gedit_utils_get_stdin(); #endif if (stdin_data) { gchar *str; GtkTextIter iter; str = g_convert(stdin_data, -1, "UTF-8", get_default_charset(), NULL, NULL, NULL); g_free(stdin_data); // gtk_text_buffer_set_text(buffer, "", 0); gtk_text_buffer_get_start_iter(pub->mw->buffer, &iter); gtk_text_buffer_insert(pub->mw->buffer, &iter, str, strlen(str)); gtk_text_buffer_get_start_iter(pub->mw->buffer, &iter); gtk_text_buffer_place_cursor(pub->mw->buffer, &iter); gtk_text_buffer_set_modified(pub->mw->buffer, FALSE); gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(pub->mw->view), &iter, 0, FALSE, 0, 0); g_free(str); } if (jump_linenum) { GtkTextIter iter; gtk_text_buffer_get_iter_at_line(pub->mw->buffer, &iter, jump_linenum - 1); gtk_text_buffer_place_cursor(pub->mw->buffer, &iter); // gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textview), &iter, 0.1, FALSE, 0.5, 0.5); scroll_to_cursor(pub->mw->buffer, 0.25); } set_main_window_title(); // hlight_apply_all(pub->mw->buffer); gtk_main(); return 0; }
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); } }
orcaData orcaGtk::ex_get_data(orcaVM* vm, int n)/*{{{*/ { if (n < 1) vm->need_param(); orcaData key = vm->get_param(0); if (type == GUI_LIST || type == GUI_TREE) { if (is<TYPE_INT>(key)) { int nth = key.Integer(); GtkTreeIter iter; gtk_tree_model_get_iter_first(store, &iter); for (int i=0; i<nth; i++) { if (!gtk_tree_model_iter_next(store, &iter)) throw orcaException(vm, "orca.index", "out of index"); } orcaList* lp = new orcaList(); int width = gtk_tree_model_get_n_columns(store); for (int i=0; i<width; i++) { GValue value = { 0, }; gtk_tree_model_get_value(store, &iter, i, &value); GType t = value.g_type; if (t == G_TYPE_STRING) { char* cp = (char*)g_value_get_string(&value); if (cp == NULL) cp = (char*)""; lp->push_back(cp); } else if (t == G_TYPE_BOOLEAN) { bool r = g_value_get_boolean(&value); lp->push_back(r); } else { lp->push_back(NIL); } g_value_unset(&value); } return lp; } string str = key.String(); if (str == "begin") { orcaGtkIter* bp = new orcaGtkIter(); bp->m_gp = this; gtk_tree_model_get_iter_first(store, &bp->m_iter); if (type == GUI_LIST) bp->m_type = GUI_LIST; else bp->m_type = GUI_TREE; return bp; } else if (type == GUI_TREE && str == "branch") { orcaTuple* path = castobj<orcaTuple>(vm->get_param(1)); if (path == NULL) { return NIL; } orcaGtkIter* bp = new orcaGtkIter(); bp->m_gp = this; bp->m_type = GUI_TREE; GtkTreeIter iter; GtkTreeIter parent; for (int i=0; i<path->size(); i++) { if (i==0) { gtk_tree_model_get_iter_first(store, &iter); for (int j=0; j<path->at(0).Integer(); j++) { if (!gtk_tree_model_iter_next(store, &iter)) throw orcaException(vm, "orca.index", "out of index"); } parent = iter; bp->m_iter = iter; continue; } if (!gtk_tree_model_iter_nth_child(store, &iter, &parent, path->at(i).Integer())) throw orcaException(vm, "orca.index", "out of index"); parent = iter; bp->m_iter = iter; } return bp; } } else if (type == GUI_ENTRY) { if (key.String() == "text") { char* p = gtk_editable_get_chars(GTK_EDITABLE(handle), 0, -1); return p; } } else if (type == GUI_TEXT) { if (key.String() == "text") { GtkTextIter start_iter, end_iter; GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(handle)); gtk_text_buffer_get_start_iter(buffer, &start_iter); gtk_text_buffer_get_end_iter(buffer, &end_iter); char* p = gtk_text_buffer_get_text(buffer, &start_iter, &end_iter, FALSE); return p; } } return NIL; }
void MergeDialog::load_text(ustring text) { // Variables for loading text in the textview. size_t pos; GtkTextIter iter; // Preprocess empty replacements. preprocess_empty_replacements(text); // Goo through the text looking for markers and processing them. pos = text.find(merge_conflict_markup(1)); while (pos != string::npos) { // Insert the bit of text before the first conflict marker. gtk_text_buffer_get_end_iter(textbuffer, &iter); gtk_text_buffer_insert(textbuffer, &iter, text.substr(0, pos).c_str(), -1); text.erase(0, pos + merge_conflict_markup(1).length()); // Retrieve the first alternative. ustring alternative1; pos = text.find(merge_conflict_markup(2)); if (pos != string::npos) { alternative1 = text.substr(1, pos - 2); text.erase(0, pos + merge_conflict_markup(2).length()); if (alternative1.empty()) alternative1 = empty_text(); } // Insert a button with the first alternative as a label. gtk_text_buffer_get_end_iter(textbuffer, &iter); GtkTextChildAnchor *childanchor1 = gtk_text_buffer_create_child_anchor(textbuffer, &iter); GtkWidget *button1 = gtk_button_new_with_label(alternative1.c_str()); gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(textview), button1, childanchor1); gtk_widget_show_all(button1); g_signal_connect((gpointer) button1, "clicked", G_CALLBACK(on_mergebutton_clicked), gpointer(this)); // Store data about first alternative. MergeButton mergebutton1; mergebutton1.childanchor = childanchor1; mergebutton1.button = button1; mergebutton1.text = alternative1; // Retrieve the second alternative. ustring alternative2; pos = text.find(merge_conflict_markup(3)); if (pos != string::npos) { alternative2 = text.substr(1, pos - 2); text.erase(0, pos + merge_conflict_markup(3).length()); if (alternative2.empty()) alternative2 = empty_text(); } // Insert a button with the second alternative as a label. gtk_text_buffer_get_end_iter(textbuffer, &iter); GtkTextChildAnchor *childanchor2 = gtk_text_buffer_create_child_anchor(textbuffer, &iter); GtkWidget *button2 = gtk_button_new_with_label(alternative2.c_str()); gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(textview), button2, childanchor2); gtk_widget_show_all(button2); g_signal_connect((gpointer) button2, "clicked", G_CALLBACK(on_mergebutton_clicked), gpointer(this)); // Store data about second alternative. MergeButton mergebutton2; mergebutton2.childanchor = childanchor2; mergebutton2.button = button2; mergebutton2.text = alternative2; // Store the button pair. MergeButtonPair mergebuttonpair; mergebuttonpair.button1 = mergebutton1; mergebuttonpair.button2 = mergebutton2; buttonpairs.push_back(mergebuttonpair); // Next iteration. pos = text.find(merge_conflict_markup(1)); } // Load remaining text in textview. gtk_text_buffer_get_end_iter(textbuffer, &iter); gtk_text_buffer_insert(textbuffer, &iter, text.substr(0, pos).c_str(), -1); // Scroll to beginning of buffer. gtk_text_buffer_get_start_iter(textbuffer, &iter); gtk_text_buffer_place_cursor(textbuffer, &iter); screen_scroll_to_iterator(GTK_TEXT_VIEW(textview), &iter); }