static gboolean parasite_python_shell_key_press_cb(GtkWidget *textview, GdkEventKey *event, GtkWidget *python_shell) { if (event->keyval == GDK_KEY_Return) { parasite_python_shell_process_line(python_shell); return TRUE; } else if (event->keyval == GDK_KEY_Up) { parasite_python_shell_replace_input(python_shell, parasite_python_shell_get_history_back(python_shell)); return TRUE; } else if (event->keyval == GDK_KEY_Down) { parasite_python_shell_replace_input(python_shell, parasite_python_shell_get_history_forward(python_shell)); return TRUE; } else if (event->string != NULL) { ParasitePythonShellPrivate *priv = PARASITE_PYTHON_SHELL(python_shell)->priv; GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(priv->textview)); GtkTextMark *insert_mark = gtk_text_buffer_get_insert(buffer); GtkTextMark *selection_mark = gtk_text_buffer_get_selection_bound(buffer); GtkTextIter insert_iter; GtkTextIter selection_iter; GtkTextIter start_iter; gint cmp_start_insert; gint cmp_start_select; gint cmp_insert_select; gtk_text_buffer_get_iter_at_mark(buffer, &start_iter, priv->line_start_mark); gtk_text_buffer_get_iter_at_mark(buffer, &insert_iter, insert_mark); gtk_text_buffer_get_iter_at_mark(buffer, &selection_iter, selection_mark); cmp_start_insert = gtk_text_iter_compare(&start_iter, &insert_iter); cmp_start_select = gtk_text_iter_compare(&start_iter, &selection_iter); cmp_insert_select = gtk_text_iter_compare(&insert_iter, &selection_iter); if (cmp_start_insert == 0 && cmp_start_select == 0 && (event->keyval == GDK_KEY_BackSpace || event->keyval == GDK_KEY_Left)) { return TRUE; } if (cmp_start_insert <= 0 && cmp_start_select <= 0) { return FALSE; } else if (cmp_start_insert > 0 && cmp_start_select > 0) { gtk_text_buffer_place_cursor(buffer, &start_iter); } else if (cmp_insert_select < 0) { gtk_text_buffer_move_mark(buffer, insert_mark, &start_iter); } else if (cmp_insert_select > 0) { gtk_text_buffer_move_mark(buffer, selection_mark, &start_iter); } } return FALSE; }
/** * undo_redo: * @w: not used * @data: not used * * executes a redo request on the current document **/ void undo_redo(UndoMain *undostruct) { UndoInfo *redoinfo; GtkTextView *textview; GtkTextBuffer *buffer; GtkTextIter iter, start_iter, end_iter; GtkTextMark *mark; cm_return_if_fail(undostruct != NULL); if (undostruct->redo == NULL) return; redoinfo = (UndoInfo *)undostruct->redo->data; cm_return_if_fail (redoinfo != NULL); undostruct->undo = g_list_prepend(undostruct->undo, redoinfo); undostruct->redo = g_list_remove(undostruct->redo, redoinfo); textview = undostruct->textview; buffer = gtk_text_view_get_buffer(textview); undo_block(undostruct); /* Check if there is a selection active */ mark = gtk_text_buffer_get_insert(buffer); gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark); gtk_text_buffer_place_cursor(buffer, &iter); /* Move the view to the right position. */ gtk_adjustment_set_value(gtk_text_view_get_vadjustment(textview), redoinfo->window_position); switch (redoinfo->action) { case UNDO_ACTION_INSERT: gtk_text_buffer_get_iter_at_offset(buffer, &iter, redoinfo->start_pos); gtk_text_buffer_insert(buffer, &iter, redoinfo->text, -1); break; case UNDO_ACTION_DELETE: gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, redoinfo->start_pos); gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, redoinfo->end_pos); gtk_text_buffer_delete(buffer, &start_iter, &end_iter); break; case UNDO_ACTION_REPLACE_DELETE: gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, redoinfo->start_pos); gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, redoinfo->end_pos); gtk_text_buffer_delete(buffer, &start_iter, &end_iter); debug_print("UNDO_ACTION_REPLACE %s\n", redoinfo->text); /* "pull" another data structure from the list */ redoinfo = (UndoInfo *)undostruct->redo->data; cm_return_if_fail(redoinfo != NULL); undostruct->undo = g_list_prepend(undostruct->undo, redoinfo); undostruct->redo = g_list_remove(undostruct->redo, redoinfo); cm_return_if_fail(redoinfo->action == UNDO_ACTION_REPLACE_INSERT); gtk_text_buffer_insert(buffer, &start_iter, redoinfo->text, -1); break; case UNDO_ACTION_REPLACE_INSERT: /* This is needed only if we redo from a middle-click button */ gtk_text_buffer_get_iter_at_offset(buffer, &iter, redoinfo->start_pos); gtk_text_buffer_insert(buffer, &iter, redoinfo->text, -1); break; default: g_assert_not_reached(); break; } undostruct->change_state_func(undostruct, UNDO_STATE_TRUE, UNDO_STATE_UNCHANGED, undostruct->change_state_data); if (undostruct->redo == NULL) undostruct->change_state_func(undostruct, UNDO_STATE_UNCHANGED, UNDO_STATE_FALSE, undostruct->change_state_data); undo_unblock(undostruct); }
/** * Clear the text from the text page. */ static void text_page_clear(GtkWidget *page) { GtkTextBuffer *buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(g_object_get_data(G_OBJECT(page), TEXT_KEY))); gtk_text_buffer_set_text(buf, "", 0); }
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); }
GtkWidget *bbox; GtkWidget *ok_bt, *cancel_bt, *help_bt; GtkTextBuffer *buffer; addr_resolution_dlg_w = dlg_window_new ("Address Resolution"); gtk_widget_set_size_request (addr_resolution_dlg_w, 750, 350); gtk_window_set_resizable (GTK_WINDOW (addr_resolution_dlg_w), TRUE); gtk_container_set_border_width (GTK_CONTAINER (addr_resolution_dlg_w), DLG_OUTER_MARGIN); vbox = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, DLG_UNRELATED_SPACING, FALSE); gtk_container_add (GTK_CONTAINER (addr_resolution_dlg_w), vbox); gtk_widget_show (vbox); view = gtk_text_view_new (); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_WORD); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(view, user_font_get_regular()); #else gtk_widget_modify_font(view, user_font_get_regular()); #endif gtk_widget_show (view); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scroll), view); gtk_widget_show(scroll); gtk_box_pack_start(GTK_BOX (vbox), scroll, TRUE, TRUE, 0); /* Get the address list */
GtkWidget * fill_stream_info(proto_type type, unsigned int pid, unsigned int seq_id) { GtkWidget *vbox; GtkWidget *hbox; GtkWidget *sw; GtkWidget *treeview; GtkWidget *next_button, *apply_button, *quit_button; GtkTreeModel *stream_model; GtkWidget *frame; GtkWidget *text_view; frame = gtk_frame_new(NULL); gtk_frame_set_label_align(GTK_FRAME(frame), 0.5, 0.5); gtk_widget_set_size_request(frame, 300, 200); vbox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(frame), vbox); gtk_box_pack_start(GTK_BOX(vbox), gtk_label_new("Edit Protocol fields"), FALSE, FALSE, 0); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0); /* create models */ stream_model = create_stream_model(type, pid, seq_id); /* create tree view */ treeview = gtk_tree_view_new_with_model(stream_model); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), GTK_SELECTION_SINGLE); add_proto_values_column(GTK_TREE_VIEW(treeview), stream_model); /* Create a multiline text widget. */ text_view = gtk_text_view_new(); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_view), 20); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(text_view), 20); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW( text_view), GTK_WRAP_WORD_CHAR); gtk_text_view_set_pixels_inside_wrap(GTK_TEXT_VIEW(text_view), 0); gtk_widget_set_tooltip_text(GTK_WIDGET(text_view), "[L4 HEADER + PAYLOAD]\nInput only hex values(0123456789ABCDEF)"); /* Obtaining the buffer associated with the widget. */ l4_pl_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view)); /* Set the default buffer text. */ if (type == TYPE_UDP) { udp_reference = g_object_ref(treeview); udp_treeview = treeview; udp_sw = sw; usr_def_reference = g_object_ref(text_view); l4_text_view = text_view; l4_buffer = l4_pl_buffer; } g_object_unref(stream_model); gtk_container_add(GTK_CONTAINER(sw), treeview); /* some buttons */ hbox = gtk_hbox_new(TRUE, 4); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); next_button = gtk_button_new_with_label("Next"); g_signal_connect(next_button, "clicked", G_CALLBACK(switch_stream_editor_page), notebook); gtk_box_pack_start(GTK_BOX(hbox), next_button, TRUE, TRUE, 0); apply_button = gtk_button_new_with_label("Apply"); g_signal_connect(apply_button, "clicked", G_CALLBACK(apply_stream_callback), NULL); gtk_box_pack_start(GTK_BOX(hbox), apply_button, TRUE, TRUE, 0); quit_button = gtk_button_new_with_label("Close"); g_signal_connect(quit_button, "clicked", G_CALLBACK(close_window_callback), G_OBJECT(stream_window)); gtk_box_pack_start(GTK_BOX(hbox), quit_button, TRUE, TRUE, 0); /* put everything into a scrolled window */ return GTK_WIDGET(frame); }
static void do_appwindow (GSimpleAction *action, GVariant *parameter, gpointer user_data) { GtkWidget *window; GtkWidget *grid; GtkWidget *statusbar; GtkWidget *contents; GtkWidget *sw; GtkTextBuffer *buffer; GSimpleActionGroup *action_group; GtkBuilder *builder; GMenuModel *model; GtkWidget *menubar; GtkWidget *toolbar; /* Create the toplevel window */ ++window_count; aspect_on = FALSE; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Application Window"); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy_cb), NULL); grid = gtk_grid_new (); gtk_widget_set_vexpand (grid, TRUE); gtk_widget_set_hexpand (grid, TRUE); gtk_container_add (GTK_CONTAINER (window), grid); action_group = g_simple_action_group_new (); builder = gtk_builder_new_from_string (xml, -1); g_action_map_add_action_entries (G_ACTION_MAP (action_group), demo_entries, G_N_ELEMENTS (demo_entries), window); gtk_widget_insert_action_group (window, "demo", G_ACTION_GROUP (action_group)); /* Create the menubar */ model = G_MENU_MODEL (gtk_builder_get_object (builder, "menubar")); menubar = gtk_menu_bar_new_from_model (model); gtk_grid_attach (GTK_GRID (grid), menubar, 0, 0, 1, 1); gtk_widget_set_hexpand (menubar, TRUE); /* Create the toolbar */ toolbar = create_toolbar (); gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 1, 1, 1); gtk_widget_set_hexpand (toolbar, TRUE); /* Create document */ contents = gtk_text_view_new (); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_grid_attach (GTK_GRID (grid), sw, 0, 2, 1, 1); gtk_widget_set_hexpand (sw, TRUE); gtk_widget_set_vexpand (sw, TRUE); gtk_window_set_default_size (GTK_WINDOW (window), 200, 200); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents), PANGO_WRAP_WORD); gtk_container_add (GTK_CONTAINER (sw), contents); /* Create statusbar */ statusbar = gtk_statusbar_new (); gtk_grid_attach (GTK_GRID (grid), statusbar, 0, 3, 1, 1); gtk_widget_set_hexpand (statusbar, TRUE); /* Show text widget info in the statusbar */ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents)); gtk_text_buffer_set_text (buffer, "This demo demonstrates various kinds of windows that " "window managers and window manager themes should handle. " "Be sure to tear off the menu and toolbar, those are also " "a special kind of window.", -1); g_signal_connect_object (buffer, "changed", G_CALLBACK (update_statusbar), statusbar, 0); g_signal_connect_object (buffer, "mark_set", /* cursor moved */ G_CALLBACK (mark_set_callback), statusbar, 0); update_statusbar (buffer, GTK_STATUSBAR (statusbar)); gtk_widget_show_all (window); g_object_unref (action_group); g_object_unref (builder); }
static void gs_editor_refresh_details (GsEditor *self) { AsAppKind app_kind = AS_APP_KIND_UNKNOWN; GtkWidget *widget; const gchar *css = NULL; g_autoptr(GError) error = NULL; g_autoptr(GsApp) app = NULL; /* ignore changed events */ self->is_in_refresh = TRUE; /* create a GsApp for the AsApp */ if (self->selected_item != NULL) { app = gs_editor_convert_app (self, self->selected_item); g_debug ("refreshing details for %s", gs_app_get_id (app)); } /* get kind */ if (self->selected_item != NULL) app_kind = as_app_get_kind (self->selected_item); /* feature tiles */ if (app_kind != AS_APP_KIND_OS_UPGRADE) { if (self->selected_item != NULL) { gs_app_tile_set_app (GS_APP_TILE (self->featured_tile1), app); gtk_widget_set_sensitive (self->featured_tile1, TRUE); } else { gtk_widget_set_sensitive (self->featured_tile1, FALSE); } gtk_widget_set_visible (self->featured_tile1, TRUE); } else { gtk_widget_set_visible (self->featured_tile1, FALSE); } /* upgrade banner */ if (app_kind == AS_APP_KIND_OS_UPGRADE) { if (self->selected_item != NULL) { gs_upgrade_banner_set_app (GS_UPGRADE_BANNER (self->upgrade_banner), app); gtk_widget_set_sensitive (self->upgrade_banner, TRUE); } else { gtk_widget_set_sensitive (self->upgrade_banner, FALSE); } gtk_widget_set_visible (self->upgrade_banner, TRUE); } else { gtk_widget_set_visible (self->upgrade_banner, FALSE); } /* name */ widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "box_name")); if (self->selected_item != NULL) { const gchar *tmp; gtk_widget_set_visible (widget, app_kind == AS_APP_KIND_OS_UPGRADE); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "entry_name")); tmp = as_app_get_name (self->selected_item, NULL); if (tmp != NULL) gtk_entry_set_text (GTK_ENTRY (widget), tmp); } else { gtk_widget_set_visible (widget, FALSE); } /* summary */ widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "box_summary")); if (self->selected_item != NULL) { const gchar *tmp; gtk_widget_set_visible (widget, app_kind == AS_APP_KIND_OS_UPGRADE); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "entry_summary")); tmp = as_app_get_comment (self->selected_item, NULL); if (tmp != NULL) gtk_entry_set_text (GTK_ENTRY (widget), tmp); } else { gtk_widget_set_visible (widget, FALSE); } /* kudos */ widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "box_kudos")); if (self->selected_item != NULL) { gtk_widget_set_visible (widget, app_kind != AS_APP_KIND_OS_UPGRADE); } else { gtk_widget_set_visible (widget, TRUE); } /* category featured */ widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "checkbutton_category_featured")); if (self->selected_item != NULL) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), as_app_has_category (self->selected_item, "Featured")); gtk_widget_set_sensitive (widget, TRUE); } else { gtk_widget_set_sensitive (widget, FALSE); } /* kudo popular */ widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "checkbutton_editors_pick")); if (self->selected_item != NULL) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), as_app_has_kudo (self->selected_item, "GnomeSoftware::popular")); gtk_widget_set_sensitive (widget, TRUE); } else { gtk_widget_set_sensitive (widget, FALSE); } /* featured */ widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "textview_css")); if (self->selected_item != NULL) { GtkTextBuffer *buffer; GtkTextIter iter_end; GtkTextIter iter_start; g_autofree gchar *css_existing = NULL; if (app_kind == AS_APP_KIND_OS_UPGRADE) { css = as_app_get_metadata_item (self->selected_item, "GnomeSoftware::UpgradeBanner-css"); } else { css = as_app_get_metadata_item (self->selected_item, "GnomeSoftware::FeatureTile-css"); } if (css == NULL) css = ""; buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget)); gtk_text_buffer_get_bounds (buffer, &iter_start, &iter_end); css_existing = gtk_text_buffer_get_text (buffer, &iter_start, &iter_end, FALSE); if (g_strcmp0 (css_existing, css) != 0) gtk_text_buffer_set_text (buffer, css, -1); gtk_widget_set_sensitive (widget, TRUE); } else { gtk_widget_set_sensitive (widget, FALSE); } /* desktop ID */ widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "entry_desktop_id")); if (self->selected_item != NULL) { const gchar *id = as_app_get_id (self->selected_item); if (id == NULL) id = ""; gtk_entry_set_text (GTK_ENTRY (widget), id); gtk_widget_set_sensitive (widget, TRUE); } else { gtk_entry_set_text (GTK_ENTRY (widget), ""); gtk_widget_set_sensitive (widget, FALSE); } /* validate CSS */ if (css == NULL) { widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "label_infobar_css")); gtk_label_set_label (GTK_LABEL (widget), ""); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "infobar_css")); gtk_info_bar_set_message_type (GTK_INFO_BAR (widget), GTK_MESSAGE_OTHER); } else if (!gs_design_validate_css (self, css, &error)) { g_autofree gchar *msg = g_strdup (error->message); g_strdelimit (msg, "\n\r<>", '\0'); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "label_infobar_css")); gtk_label_set_label (GTK_LABEL (widget), msg); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "infobar_css")); gtk_info_bar_set_message_type (GTK_INFO_BAR (widget), GTK_MESSAGE_WARNING); } else { widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "label_infobar_css")); gtk_label_set_label (GTK_LABEL (widget), _("CSS validated OK!")); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "infobar_css")); gtk_info_bar_set_message_type (GTK_INFO_BAR (widget), GTK_MESSAGE_OTHER); } /* do not ignore changed events */ self->is_in_refresh = FALSE; }
static void gs_editor_startup_cb (GtkApplication *application, GsEditor *self) { GtkTextBuffer *buffer; GtkWidget *main_window; GtkWidget *widget; gboolean ret; guint retval; g_autoptr(GError) error = NULL; /* get UI */ retval = gtk_builder_add_from_resource (self->builder, "/org/gnome/Software/Editor/gs-editor.ui", &error); if (retval == 0) { g_warning ("failed to load ui: %s", error->message); return; } /* load all system appstream */ as_store_set_add_flags (self->store_global, AS_STORE_ADD_FLAG_USE_MERGE_HEURISTIC); ret = as_store_load (self->store_global, AS_STORE_LOAD_FLAG_IGNORE_INVALID | AS_STORE_LOAD_FLAG_APP_INFO_SYSTEM | AS_STORE_LOAD_FLAG_APPDATA | AS_STORE_LOAD_FLAG_DESKTOP, self->cancellable, &error); if (!ret) { g_warning ("failed to load global store: %s", error->message); return; } /* load all the IDs into the completion model */ gs_editor_load_completion_model (self); self->featured_tile1 = gs_feature_tile_new (NULL); self->upgrade_banner = gs_upgrade_banner_new (); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "box_featured")); gtk_container_add (GTK_CONTAINER (widget), self->featured_tile1); gtk_container_add (GTK_CONTAINER (widget), self->upgrade_banner); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "textview_css")); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget)); g_signal_connect (buffer, "changed", G_CALLBACK (gs_design_dialog_buffer_changed_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "flowbox_main")); gtk_flow_box_set_sort_func (GTK_FLOW_BOX (widget), gs_editor_flow_box_sort_cb, self, NULL); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_save")); g_signal_connect (widget, "clicked", G_CALLBACK (gs_editor_button_save_clicked_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_new_feature")); g_signal_connect (widget, "clicked", G_CALLBACK (gs_editor_button_new_feature_clicked_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_new_os_upgrade")); g_signal_connect (widget, "clicked", G_CALLBACK (gs_editor_button_new_os_upgrade_clicked_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_new")); g_signal_connect (widget, "clicked", G_CALLBACK (gs_editor_button_new_clicked_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_remove")); g_signal_connect (widget, "clicked", G_CALLBACK (gs_editor_button_remove_clicked_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_import")); g_signal_connect (widget, "clicked", G_CALLBACK (gs_editor_button_import_clicked_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_back")); g_signal_connect (widget, "clicked", G_CALLBACK (gs_editor_button_back_clicked_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_menu")); g_signal_connect (widget, "clicked", G_CALLBACK (gs_editor_button_menu_clicked_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_notification_dismiss")); g_signal_connect (widget, "clicked", G_CALLBACK (gs_editor_button_notification_dismiss_clicked_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "button_notification_undo_remove")); g_signal_connect (widget, "clicked", G_CALLBACK (gs_editor_button_undo_remove_clicked_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "checkbutton_editors_pick")); g_signal_connect (widget, "toggled", G_CALLBACK (gs_editor_checkbutton_editors_pick_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "checkbutton_category_featured")); g_signal_connect (widget, "toggled", G_CALLBACK (gs_editor_checkbutton_category_featured_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "entry_desktop_id")); g_signal_connect (widget, "notify::text", G_CALLBACK (gs_editor_entry_desktop_id_notify_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "entry_name")); g_signal_connect (widget, "notify::text", G_CALLBACK (gs_editor_entry_name_notify_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "entry_summary")); g_signal_connect (widget, "notify::text", G_CALLBACK (gs_editor_entry_summary_notify_cb), self); widget = GTK_WIDGET (gtk_builder_get_object (self->builder, "window_main")); g_signal_connect (widget, "delete_event", G_CALLBACK (gs_editor_delete_event_cb), self); /* clear entries */ gs_editor_refresh_choice (self); gs_editor_refresh_details (self); gs_editor_refresh_file (self, NULL); /* set the appropriate page */ gs_editor_set_page (self, "none"); main_window = GTK_WIDGET (gtk_builder_get_object (self->builder, "window_main")); gtk_application_add_window (application, GTK_WINDOW (main_window)); gtk_widget_show (main_window); }
/* ==================================== */ static GooCanvasItem *wordprocessor_create() { GooCanvasItem *item = NULL; GdkPixbuf *pixmap; double y; boardRootItem = goo_canvas_group_new (goo_canvas_get_root_item(gcomprisBoard->canvas), NULL); selected_tag = NULL; view = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), GTK_WRAP_WORD); /* Change left margin throughout the widget */ gtk_text_view_set_left_margin (GTK_TEXT_VIEW (view), 1); g_signal_connect (view, "key-release-event", G_CALLBACK (key_release_event), NULL); g_signal_connect (view, "event-after", G_CALLBACK (event_after), NULL); g_signal_connect (view, "motion-notify-event", G_CALLBACK (motion_notify_event), NULL); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_add (GTK_CONTAINER (sw), view); item = goo_canvas_widget_new (boardRootItem, GTK_WIDGET(sw), word_area_x1, word_area_y1, word_area_width, word_area_height, "anchor", GTK_ANCHOR_NW, NULL); gtk_widget_show(GTK_WIDGET(view)); gtk_widget_show(GTK_WIDGET(sw)); /* * Create the default style tags */ doctype_list[0] = &type_text; doctype_list[1] = &type_normal; doctype_list[2] = &type_letter; doctype_list[3] = &type_small; doctype_list[4] = &type_big; // doctype_list[5] = &type_link; y = 20.0; /* * The save button */ pixmap = gc_pixmap_load("wordprocessor/tool-save.png"); item = \ goo_canvas_image_new (boardRootItem, pixmap, 17.0, y, NULL); #if GDK_PIXBUF_MAJOR <= 2 && GDK_PIXBUF_MINOR <= 24 gdk_pixbuf_unref(pixmap); #else g_object_unref(pixmap); #endif g_signal_connect(item, "button_press_event", (GCallback) save_event, buffer); gc_item_focus_init(item, NULL); /* * The load button */ pixmap = gc_pixmap_load("wordprocessor/tool-load.png"); item = \ goo_canvas_image_new (boardRootItem, pixmap, 60.0, y, NULL); #if GDK_PIXBUF_MAJOR <= 2 && GDK_PIXBUF_MINOR <= 24 gdk_pixbuf_unref(pixmap); #else g_object_unref(pixmap); #endif g_signal_connect(item, "button_press_event", (GCallback) load_event, buffer); gc_item_focus_init(item, NULL); y += 45; /* * Display the style buttons */ y = display_style_buttons(boardRootItem, 20.0, y); y += 20; display_style_selector(boardRootItem, y); y += 40; display_color_style_selector(boardRootItem, y); /* Now we can create the tags */ create_tags(buffer, doctype_list[0]); gtk_widget_grab_focus(view); return NULL; }
/* Catch all typing events to apply the proper tags * */ static gboolean key_release_event (GtkWidget *text_view, GdkEventKey *event) { GtkTextIter iter_start, iter_end; GtkTextBuffer *buffer; { GSList *tags = NULL, *tagp = NULL; buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)); gtk_text_buffer_get_iter_at_mark(buffer, &iter_start, gtk_text_buffer_get_insert (buffer)); gtk_text_iter_set_line_offset(&iter_start, 0); iter_end = iter_start; gtk_text_iter_forward_to_line_end(&iter_end); tags = gtk_text_iter_get_tags (&iter_start); if(g_slist_length(tags) == 0) { gtk_text_iter_backward_char (&iter_end); tags = gtk_text_iter_get_tags (&iter_end); gtk_text_iter_forward_char (&iter_end); } for (tagp = tags; tagp != NULL; tagp = tagp->next) { GtkTextTag *tag = tagp->data; gchar *name; g_object_get (G_OBJECT (tag), "name", &name, NULL); set_default_tag(buffer, tag); gtk_text_buffer_apply_tag_by_name(buffer, name, &iter_start, &iter_end); g_free(name); selected_tag = NULL; } if (tags) g_slist_free (tags); else { /* Set the default style */ if(selected_tag) { set_default_tag(buffer, selected_tag); gtk_text_buffer_apply_tag(buffer, selected_tag, &iter_start, &iter_end); } else { set_default_tag(buffer, tag_list[NUMBER_OF_STYLE-1]); gtk_text_buffer_apply_tag(buffer, tag_list[NUMBER_OF_STYLE-1], &iter_start, &iter_end); } } } return FALSE; }
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); }
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; }
static void parasite_python_shell_init (ParasitePythonShell *python_shell) { GtkWidget *swin; GtkTextBuffer *buffer; GtkTextIter iter; PangoFontDescription *font_desc; python_shell->priv = parasite_python_shell_get_instance_private (python_shell); python_shell->priv->history = g_queue_new(); gtk_box_set_spacing(GTK_BOX(python_shell), 6); swin = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(swin); gtk_box_pack_start(GTK_BOX(python_shell), swin, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin), GTK_SHADOW_IN); python_shell->priv->textview = gtk_text_view_new(); gtk_widget_show(python_shell->priv->textview); gtk_container_add(GTK_CONTAINER(swin), python_shell->priv->textview); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(python_shell->priv->textview), TRUE); gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(python_shell->priv->textview), 3); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(python_shell->priv->textview), 3); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(python_shell->priv->textview), 3); g_signal_connect(python_shell->priv->textview, "key_press_event", G_CALLBACK(parasite_python_shell_key_press_cb), python_shell); /* Make the textview monospaced */ font_desc = pango_font_description_from_string("monospace"); pango_font_description_set_size(font_desc, 8 * PANGO_SCALE); gtk_widget_override_font(python_shell->priv->textview, font_desc); pango_font_description_free(font_desc); /* Create the end-of-buffer mark */ buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(python_shell->priv->textview)); gtk_text_buffer_get_end_iter(buffer, &iter); python_shell->priv->scroll_mark = gtk_text_buffer_create_mark(buffer, "scroll_mark", &iter, FALSE); /* Create the beginning-of-line mark */ python_shell->priv->line_start_mark = gtk_text_buffer_create_mark(buffer, "line_start_mark", &iter, TRUE); /* Register some tags */ gtk_text_buffer_create_tag(buffer, "stdout", NULL); gtk_text_buffer_create_tag(buffer, "stderr", "foreground", "red", "paragraph-background", "#FFFFE0", NULL); gtk_text_buffer_create_tag(buffer, "prompt", "foreground", "blue", NULL); parasite_python_shell_write_prompt(GTK_WIDGET(python_shell)); }
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; } }
static void create_calendar(void) { static CalendarData calendar_data; GtkWidget *window, *hpaned, *vbox, *rpane, *hbox; GtkWidget *calendar, *toggle, *scroller, *button; GtkWidget *frame, *label, *bbox, *details; GtkSizeGroup *size; GtkStyleContext *context; PangoFontDescription *font_desc; gchar *font; gint i; struct { gboolean init; char *label; } flags[] = { { TRUE, "Show _Heading" }, { TRUE, "Show Day _Names" }, { FALSE, "No Month _Change" }, { TRUE, "Show _Week Numbers" }, { FALSE, "Week Start _Monday" }, { TRUE, "Show De_tails" }, }; calendar_data.window = NULL; calendar_data.font_dialog = NULL; calendar_data.details_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); for (i = 0; i < G_N_ELEMENTS (calendar_data.settings); i++) calendar_data.settings[i] = 0; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_hide_on_close (GTK_WINDOW (window), TRUE); gtk_window_set_title (GTK_WINDOW (window), "GtkCalendar Example"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); /* Calendar widget */ calendar = gtk_calendar_new (); calendar_data.calendar_widget = calendar; frame = create_frame ("<b>Calendar</b>", calendar, GTK_ALIGN_CENTER, GTK_ALIGN_CENTER); gtk_paned_pack1 (GTK_PANED (hpaned), frame, TRUE, FALSE); calendar_data.window = calendar; calendar_set_flags(&calendar_data); gtk_calendar_mark_day (GTK_CALENDAR (calendar), 19); g_signal_connect (calendar, "month_changed", G_CALLBACK (calendar_month_changed), &calendar_data); g_signal_connect (calendar, "day_selected", G_CALLBACK (calendar_day_selected), &calendar_data); g_signal_connect (calendar, "day_selected_double_click", G_CALLBACK (calendar_day_selected_double_click), &calendar_data); g_signal_connect (calendar, "prev_month", G_CALLBACK (calendar_prev_month), &calendar_data); g_signal_connect (calendar, "next_month", G_CALLBACK (calendar_next_month), &calendar_data); g_signal_connect (calendar, "prev_year", G_CALLBACK (calendar_prev_year), &calendar_data); g_signal_connect (calendar, "next_year", G_CALLBACK (calendar_next_year), &calendar_data); rpane = gtk_box_new (GTK_ORIENTATION_VERTICAL, DEF_PAD_SMALL); gtk_paned_pack2 (GTK_PANED (hpaned), rpane, FALSE, FALSE); /* Build the right font-button */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, DEF_PAD_SMALL); frame = create_frame ("<b>Options</b>", vbox, GTK_ALIGN_FILL, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (rpane), frame); size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); context = gtk_widget_get_style_context (calendar); gtk_style_context_get (context, GTK_STYLE_PROPERTY_FONT, &font_desc, NULL); font = pango_font_description_to_string (font_desc); button = gtk_font_button_new_with_font (font); g_free (font); pango_font_description_free (font_desc); g_signal_connect (button, "font-set", G_CALLBACK(calendar_select_font), &calendar_data); label = gtk_label_new_with_mnemonic ("_Font:"); gtk_label_set_mnemonic_widget (GTK_LABEL (label), button); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_valign (label, GTK_ALIGN_CENTER); gtk_size_group_add_widget (size, label); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, DEF_PAD_SMALL); gtk_box_pack_start (GTK_BOX (hbox), label); gtk_box_pack_start (GTK_BOX (hbox), button); gtk_box_pack_start (GTK_BOX (vbox), hbox); /* Build the width entry */ button = gtk_spin_button_new_with_range (0, 127, 1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (button), gtk_calendar_get_detail_width_chars (GTK_CALENDAR (calendar))); g_signal_connect (button, "value-changed", G_CALLBACK (detail_width_changed), &calendar_data); label = gtk_label_new_with_mnemonic ("Details W_idth:"); gtk_label_set_mnemonic_widget (GTK_LABEL (label), button); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_valign (label, GTK_ALIGN_CENTER); gtk_size_group_add_widget (size, label); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, DEF_PAD_SMALL); gtk_box_pack_start (GTK_BOX (hbox), label); gtk_box_pack_start (GTK_BOX (hbox), button); gtk_box_pack_start (GTK_BOX (vbox), hbox); /* Build the height entry */ button = gtk_spin_button_new_with_range (0, 127, 1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (button), gtk_calendar_get_detail_height_rows (GTK_CALENDAR (calendar))); g_signal_connect (button, "value-changed", G_CALLBACK (detail_height_changed), &calendar_data); label = gtk_label_new_with_mnemonic ("Details H_eight:"); gtk_label_set_mnemonic_widget (GTK_LABEL (label), button); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_valign (label, GTK_ALIGN_CENTER); gtk_size_group_add_widget (size, label); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, DEF_PAD_SMALL); gtk_box_pack_start (GTK_BOX (hbox), label); gtk_box_pack_start (GTK_BOX (hbox), button); gtk_box_pack_start (GTK_BOX (vbox), hbox); /* Build the right details frame */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, DEF_PAD_SMALL); frame = create_frame ("<b>Details</b>", vbox, GTK_ALIGN_FILL, GTK_ALIGN_FILL); gtk_box_pack_start (GTK_BOX (rpane), frame); details = gtk_text_view_new(); calendar_data.details_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (details)); calendar_data.details_changed = g_signal_connect (calendar_data.details_buffer, "changed", G_CALLBACK (calendar_details_changed), &calendar_data); scroller = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scroller), details); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroller), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroller), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), scroller); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, DEF_PAD_SMALL); gtk_widget_set_halign (hbox, GTK_ALIGN_START); gtk_widget_set_valign (hbox, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (vbox), hbox); button = gtk_button_new_with_mnemonic ("Demonstrate _Details"); g_signal_connect_swapped (button, "clicked", G_CALLBACK (demonstrate_details), &calendar_data); gtk_box_pack_start (GTK_BOX (hbox), button); button = gtk_button_new_with_mnemonic ("_Reset Details"); g_signal_connect_swapped (button, "clicked", G_CALLBACK (reset_details), &calendar_data); gtk_box_pack_start (GTK_BOX (hbox), button); toggle = gtk_check_button_new_with_mnemonic ("_Use Details"); g_signal_connect (toggle, "toggled", G_CALLBACK(calendar_toggle_details), &calendar_data); gtk_box_pack_start (GTK_BOX (vbox), toggle); /* Build the Right frame with the flags in */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); frame = create_expander ("<b>Flags</b>", vbox, GTK_ALIGN_FILL, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (rpane), frame); for (i = 0; i < G_N_ELEMENTS (calendar_data.settings); i++) { toggle = gtk_check_button_new_with_mnemonic(flags[i].label); gtk_box_pack_start (GTK_BOX (vbox), toggle); calendar_data.flag_checkboxes[i] = toggle; g_signal_connect (toggle, "toggled", G_CALLBACK (calendar_toggle_flag), &calendar_data); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), flags[i].init); } /* * Build the Signal-event part. */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, DEF_PAD_SMALL); gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE); frame = create_frame ("<b>Signal Events</b>", vbox, GTK_ALIGN_FILL, GTK_ALIGN_CENTER); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); gtk_box_pack_start (GTK_BOX (vbox), hbox); label = gtk_label_new ("Signal:"); gtk_box_pack_start (GTK_BOX (hbox), label); calendar_data.last_sig = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), calendar_data.last_sig); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); gtk_box_pack_start (GTK_BOX (vbox), hbox); label = gtk_label_new ("Previous signal:"); gtk_box_pack_start (GTK_BOX (hbox), label); calendar_data.prev_sig = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), calendar_data.prev_sig); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3); gtk_box_pack_start (GTK_BOX (vbox), hbox); label = gtk_label_new ("Second previous signal:"); gtk_box_pack_start (GTK_BOX (hbox), label); calendar_data.prev2_sig = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), calendar_data.prev2_sig); /* * Glue everything together */ bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); button = gtk_button_new_with_label ("Close"); g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL); gtk_container_add (GTK_CONTAINER (bbox), button); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, DEF_PAD_SMALL); gtk_box_pack_start (GTK_BOX (vbox), hpaned); gtk_box_pack_start (GTK_BOX (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL)); gtk_box_pack_start (GTK_BOX (vbox), frame); gtk_box_pack_start (GTK_BOX (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL)); gtk_box_pack_start (GTK_BOX (vbox), bbox); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_set_can_default (button, TRUE); gtk_widget_grab_default (button); gtk_window_set_default_size (GTK_WINDOW (window), 600, 0); gtk_widget_show (window); }
GtkWidget * do_textview (GtkWidget *do_widget) { static GtkWidget *window = NULL; if (!window) { GtkWidget *vpaned; GtkWidget *view1; GtkWidget *view2; GtkWidget *sw; GtkTextBuffer *buffer; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_default_size (GTK_WINDOW (window), 450, 450); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "TextView"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); vpaned = gtk_vpaned_new (); gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5); gtk_container_add (GTK_CONTAINER (window), vpaned); /* For convenience, we just use the autocreated buffer from * the first text view; you could also create the buffer * by itself with gtk_text_buffer_new(), then later create * a view widget. */ view1 = gtk_text_view_new (); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view1)); view2 = gtk_text_view_new_with_buffer (buffer); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add1 (GTK_PANED (vpaned), sw); gtk_container_add (GTK_CONTAINER (sw), view1); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add2 (GTK_PANED (vpaned), sw); gtk_container_add (GTK_CONTAINER (sw), view2); create_tags (buffer); insert_text (buffer); attach_widgets (GTK_TEXT_VIEW (view1)); attach_widgets (GTK_TEXT_VIEW (view2)); gtk_widget_show_all (vpaned); } if (!gtk_widget_get_visible (window)) { gtk_widget_show (window); } else { gtk_widget_destroy (window); window = NULL; } return window; }
static GtkWidget *create_dialog(void) { GtkWidget *dialog; GtkWidget *header_image; GtkWidget *header_label; GtkWidget *label_info; GtkWidget *codename_label; GtkWidget *builddate_label; GtkWidget *url_button; GtkWidget *cop_label; GtkWidget *label; GtkWidget *license_textview; GtkWidget *notebook; GtkWidget *box; GtkWidget *credits_scrollwin; GtkWidget *table; GtkWidget *license_scrollwin; GtkWidget *info_box; GtkWidget *header_hbox; GtkWidget *header_eventbox; GtkTextBuffer* tb; gchar *license_text = NULL; gchar buffer[512]; gchar buffer2[128]; guint i, row = 0; gchar *build_date; dialog = gtk_dialog_new(); /* configure dialog */ gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window)); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany")); gtk_window_set_icon_name(GTK_WINDOW(dialog), "geany"); gtk_widget_set_name(dialog, "GeanyDialog"); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL); /* create header */ header_eventbox = gtk_event_box_new(); gtk_widget_show(header_eventbox); header_hbox = gtk_hbox_new(FALSE, 12); gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4); gtk_widget_show(header_hbox); gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox); header_image = gtk_image_new_from_icon_name("geany", GTK_ICON_SIZE_DIALOG); gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0); header_label = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE); /* print the subversion revision generated by ./configure if it is available */ g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string()); gtk_label_set_markup(GTK_LABEL(header_label), buffer); gtk_widget_show(header_label); gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0); header_eventbox_style_set(header_eventbox); header_label_style_set(header_label); g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL); g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), header_eventbox, FALSE, FALSE, 0); /* create notebook */ notebook = gtk_notebook_new(); gtk_widget_show(notebook); gtk_container_set_border_width(GTK_CONTAINER(notebook), 2); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), notebook, TRUE, TRUE, 0); /* create "Info" tab */ info_box = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(info_box), 6); gtk_widget_show(info_box); label_info = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(label_info), TRUE); gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE); g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE")); gtk_label_set_markup(GTK_LABEL(label_info), buffer); gtk_misc_set_padding(GTK_MISC(label_info), 2, 11); gtk_widget_show(label_info); gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0); /* Codename label */ codename_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE); gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME); gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8); gtk_widget_show(codename_label); gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0); /* build date label */ builddate_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE); gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE); build_date = utils_parse_and_format_build_date(__DATE__); g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), build_date); g_free(build_date); g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2); gtk_label_set_markup(GTK_LABEL(builddate_label), buffer); gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2); gtk_widget_show(builddate_label); gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0); box = gtk_hbutton_box_new(); url_button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE); g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE); label = gtk_label_new(NULL); gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE); gtk_widget_show(label); gtk_container_add(GTK_CONTAINER(url_button), label); gtk_widget_show(url_button); gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0); gtk_widget_show(box); gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10); /* copyright label */ cop_label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER); gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE); gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE); gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT); gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10); gtk_widget_show(cop_label); gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0); /*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */ label = gtk_label_new(_("Info")); gtk_widget_show(label); gtk_widget_show_all(info_box); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label); /* create "Credits" tab */ credits_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 10); row = 0; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer")); ROW(buffer, row, 0, 0, 0, 1); row++; ROW("<[email protected]>", row, 0, 0, 0, 1); row++; ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < translators_len; i++) { ROW(translators[i][0], row, 0, 1, 4, 0); ROW(translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; for (i = 0; i < prev_translators_len; i++) { ROW(prev_translators[i][0], row, 0, 1, 4, 0); ROW(prev_translators[i][1], row, 1, 0, 4, 0); row++; } ROW("", row, 0, 0, 0, 0); row++; g_snprintf(buffer, sizeof(buffer), "<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors")); label = gtk_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; g_snprintf(buffer, sizeof(buffer), _("Some of the many contributors (for a more detailed list, see the file %s):"), #ifdef G_OS_WIN32 "Thanks.txt" #else "THANKS" #endif ); label = geany_wrap_label_new(buffer); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; label = geany_wrap_label_new(contributors); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, (GtkAttachOptions) (GTK_FILL | GTK_EXPAND), (GtkAttachOptions) (0), 0, 5); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); row++; gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table); gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE); gtk_widget_show_all(table); label = gtk_label_new(_("Credits")); gtk_widget_show(label); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label); /* create "License" tab */ license_scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_SHADOW_IN); license_textview = gtk_text_view_new(); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(license_textview), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(license_textview), 2); gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE); gtk_widget_show(license_textview); gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview); label = gtk_label_new(_("License")); gtk_widget_show(label); g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir); g_file_get_contents(buffer, &license_text, NULL, NULL); if (license_text == NULL) { license_text = g_strdup( _("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online.")); } tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview)); gtk_text_buffer_set_text(tb, license_text, -1); g_free(license_text); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label); gtk_widget_show_all(dialog); return dialog; }
static GtkWidget *bar_pane_keywords_new(const gchar *id, const gchar *title, const gchar *key, gboolean expanded) { PaneKeywordsData *pkd; GtkWidget *hbox; GtkWidget *scrolled; GtkTextBuffer *buffer; GtkTreeModel *store; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeIter iter; pkd = g_new0(PaneKeywordsData, 1); pkd->pane.pane_set_fd = bar_pane_keywords_set_fd; pkd->pane.pane_event = bar_pane_keywords_event; pkd->pane.pane_write_config = bar_pane_keywords_write_config; pkd->pane.title = bar_pane_expander_title(title); pkd->pane.id = g_strdup(id); pkd->pane.type = PANE_KEYWORDS; pkd->pane.expanded = expanded; pkd->key = g_strdup(key); pkd->expand_checked = TRUE; hbox = gtk_hbox_new(FALSE, PREF_PAD_GAP); pkd->widget = hbox; g_object_set_data(G_OBJECT(pkd->widget), "pane_data", pkd); g_signal_connect(G_OBJECT(pkd->widget), "destroy", G_CALLBACK(bar_pane_keywords_destroy), pkd); gtk_widget_show(hbox); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); pkd->keyword_view = gtk_text_view_new(); gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_view); g_signal_connect(G_OBJECT(pkd->keyword_view), "populate-popup", G_CALLBACK(bar_pane_keywords_populate_popup_cb), pkd); gtk_widget_show(pkd->keyword_view); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view)); g_signal_connect(G_OBJECT(buffer), "changed", G_CALLBACK(bar_pane_keywords_changed), pkd); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); if (!keyword_tree || !gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_tree), &iter)) { /* keyword tree does not exist or is empty - fill with defaults */ keyword_tree_new_default(); } store = gtk_tree_model_filter_new(GTK_TREE_MODEL(keyword_tree), NULL); gtk_tree_model_filter_set_modify_func(GTK_TREE_MODEL_FILTER(store), FILTER_KEYWORD_COLUMN_COUNT, filter_keyword_column_types, bar_pane_keywords_filter_modify, pkd, NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(store), bar_pane_keywords_filter_visible, store, NULL); pkd->keyword_treeview = gtk_tree_view_new_with_model(store); g_object_unref(store); gtk_widget_set_size_request(pkd->keyword_treeview, -1, 400); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(pkd->keyword_treeview), FALSE); // gtk_tree_view_set_search_column(GTK_TREE_VIEW(pkd->keyword_treeview), FILTER_KEYWORD_COLUMN_); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_MARK); gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); renderer = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "active", FILTER_KEYWORD_COLUMN_TOGGLE); gtk_tree_view_column_add_attribute(column, renderer, "visible", FILTER_KEYWORD_COLUMN_IS_KEYWORD); g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(bar_pane_keywords_keyword_toggle), pkd); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column); gtk_tree_view_set_expander_column(GTK_TREE_VIEW(pkd->keyword_treeview), column); gtk_drag_source_set(pkd->keyword_treeview, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK, bar_pane_keywords_drag_types, n_keywords_drag_types, GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_data_get", G_CALLBACK(bar_pane_keywords_dnd_get), pkd); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_begin", G_CALLBACK(bar_pane_keywords_dnd_begin), pkd); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_end", G_CALLBACK(bar_pane_keywords_dnd_end), pkd); gtk_drag_dest_set(pkd->keyword_treeview, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, bar_pane_keywords_drop_types, n_keywords_drop_types, GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_data_received", G_CALLBACK(bar_pane_keywords_dnd_receive), pkd); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_motion", G_CALLBACK(bar_pane_keywords_dnd_motion), pkd); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "button_release_event", G_CALLBACK(bar_pane_keywords_menu_cb), pkd); gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_treeview); gtk_widget_show(pkd->keyword_treeview); file_data_register_notify_func(bar_pane_keywords_notify_cb, pkd, NOTIFY_PRIORITY_LOW); return pkd->widget; }
static void editor_window_new(const gchar *src_path, const gchar *desktop_name) { EditorWindow *ew; GtkWidget *win_vbox; GtkWidget *hbox; GtkWidget *button; GtkWidget *ct_button; GtkWidget *button_hbox; GtkWidget *scrolled; GtkWidget *text_view; gchar *text; gsize size; ew = g_new0(EditorWindow, 1); ew->window = window_new(GTK_WINDOW_TOPLEVEL, "Desktop", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Desktop file")); DEBUG_NAME(ew->window); gtk_window_set_type_hint(GTK_WINDOW(ew->window), GDK_WINDOW_TYPE_HINT_DIALOG); g_signal_connect(G_OBJECT(ew->window), "delete_event", G_CALLBACK(editor_window_delete_cb), ew); gtk_window_set_default_size(GTK_WINDOW(ew->window), CONFIG_WINDOW_DEF_WIDTH, CONFIG_WINDOW_DEF_HEIGHT); gtk_window_set_resizable(GTK_WINDOW(ew->window), TRUE); gtk_container_set_border_width(GTK_CONTAINER(ew->window), PREF_PAD_BORDER); win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE); gtk_container_add(GTK_CONTAINER(ew->window), win_vbox); gtk_widget_show(win_vbox); hbox = gtk_hbox_new(FALSE, PREF_PAD_SPACE); gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); ew->entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(hbox), ew->entry, TRUE, TRUE, 0); ew->desktop_name = NULL; if (desktop_name) { gtk_entry_set_text(GTK_ENTRY(ew->entry), desktop_name); ew->desktop_name = g_strdup(desktop_name); } gtk_widget_show(ew->entry); g_signal_connect(G_OBJECT(ew->entry), "changed", G_CALLBACK(editor_window_entry_changed_cb), ew); button_hbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(button_hbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(button_hbox), PREF_PAD_BUTTON_GAP); gtk_box_pack_end(GTK_BOX(hbox), button_hbox, FALSE, FALSE, 0); gtk_widget_show(button_hbox); ew->save_button = pref_button_new(NULL, GTK_STOCK_SAVE, NULL, FALSE, G_CALLBACK(editor_window_save_cb), ew); gtk_container_add(GTK_CONTAINER(button_hbox), ew->save_button); gtk_widget_set_can_default(ew->save_button, TRUE); gtk_widget_set_sensitive(ew->save_button, FALSE); gtk_widget_show(ew->save_button); ct_button = ew->save_button; button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE, G_CALLBACK(editor_window_close_cb), ew); gtk_container_add(GTK_CONTAINER(button_hbox), button); gtk_widget_set_can_default(button, TRUE); gtk_widget_show(button); if (!generic_dialog_get_alternative_button_order(ew->window)) { gtk_box_reorder_child(GTK_BOX(button_hbox), ct_button, -1); } scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(win_vbox), scrolled, TRUE, TRUE, 5); gtk_widget_show(scrolled); text_view = gtk_text_view_new(); gtk_container_add(GTK_CONTAINER(scrolled), text_view); gtk_widget_show(text_view); ew->buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view)); if (g_file_get_contents(src_path, &text, &size, NULL)) { gtk_text_buffer_set_text(ew->buffer, text, size); } gtk_text_buffer_set_modified(ew->buffer, FALSE); g_signal_connect(G_OBJECT(ew->buffer), "modified-changed", G_CALLBACK(editor_window_text_modified_cb), ew); gtk_widget_show(ew->window); }
/////*************************************************************************** ///// 函数名称 : GtkWidget *edit_window (void) ///// ///// 函数功能 : 创 建 邮 件 编 辑 界 面 的 表 (30,30) ///// ///// 返 回 值 : table /////*************************************************************************** GtkWidget *edit_func (gpointer data) { GtkWidget *table; GtkWidget *text_view; //GtkWidget *vscrollbar,*hscrollbar; GtkWidget *menubar; GtkWidget *toolbar; GtkWidget *recevie_label;//////收件人标签 GtkWidget *theme_label;///////////主题标签 GtkWidget *chaos_label;/////////抄送label GtkWidget *mis_label;/////////密送label GtkWidget *addfile_label;/////////添加附件label GtkWidget *recevie_entry;//////收件人输入框 GtkWidget *theme_entry;///////////主题输入框 GtkWidget *chaos_entry;//////////抄送entry GtkWidget *mis_entry;/////////密送entry GtkWidget *addfile_entry; GtkWidget *statusbar; GtkWidget *tree; /*创建一个table构件*/ table = gtk_table_new (40, 40, FALSE); /* 调用函数 menu() 创建一个菜单栏构件,并在表内分配空间*/ menubar = menu1(); gtk_table_attach (GTK_TABLE (table), menubar, 0, 40, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); //stMail stEmailInfo; // stEmailInfo-> /* 调用函数 tool() 创建一个菜单栏构件,并在表内分配空间*/ toolbar = tool1(); gtk_table_attach (GTK_TABLE (table), toolbar, 0, 40,1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); ////*************创建 收件人 的label 及entry ***************/////// recevie_label = gtk_label_new("收件人(T):");/////用户名标签 gtk_table_attach (GTK_TABLE (table), recevie_label, 0, 2, 2, 3, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); //recevie_entry = gtk_entry_new(); SendEntry.Address=gtk_entry_new(); gtk_table_attach (GTK_TABLE (table), SendEntry.Address, 2, 39, 2, 3, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); ////*************创建 抄 送 的label 及entry ***************/////// chaos_label = gtk_label_new("抄 送 (C) :");/////抄送标签 gtk_table_attach (GTK_TABLE (table), chaos_label, 0, 2, 3, 4, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); //chaos_entry = gtk_entry_new(); SendEntry.CopyAddress=gtk_entry_new(); gtk_table_attach (GTK_TABLE (table), SendEntry.CopyAddress, 2, 39, 3, 4, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); ////*************创建 密 送 的label 及entry ***************/////// mis_label = gtk_label_new("密 送 (M) :");/////密送标签 gtk_table_attach (GTK_TABLE (table), mis_label, 0, 2, 4, 5, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); //mis_entry = gtk_entry_new(); SendEntry.SecretAddress=gtk_entry_new(); gtk_table_attach (GTK_TABLE (table), SendEntry.SecretAddress, 2, 39, 4, 5, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); ////*************创建 主 题 的label 及entry ***************/////// theme_label = gtk_label_new("主 题(U):");//////////主题标签 gtk_table_attach (GTK_TABLE (table), theme_label, 0, 2, 5, 6, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); //theme_entry = gtk_entry_new(); SendEntry.Theme=gtk_entry_new(); gtk_table_attach (GTK_TABLE (table), SendEntry.Theme, 2, 39, 5, 6, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); ////*************创建 附 件 的label 及entry ***************/////// addfile_label = gtk_label_new("附 件(F):");////////// gtk_table_attach (GTK_TABLE (table), addfile_label, 0, 2, 6, 7, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); //addfile_entry = gtk_entry_new(); SendEntry.Filepath=gtk_entry_new(); gtk_table_attach (GTK_TABLE (table), SendEntry.Filepath, 2, 39, 6, 7, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); /* 调用函数 build_scrolled_win() 创建一个 scrolled滚动窗口及文本框 构件,并在表内分配空间*/ text_view = build_scrolled_win(); gtk_table_attach (GTK_TABLE (table), text_view, 0, 38, 7, 39, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); /* 调用函数 create_view_and_model() 创建一个树视图,并在表内分配空间*/ tree = create_view_and_model1(); gtk_table_attach (GTK_TABLE (table), tree, 38, 40, 7, 39, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); /*创建一个状态栏构件,并在表内分配空间*/ statusbar = gtk_statusbar_new(); gtk_table_attach (GTK_TABLE (table), statusbar, 0, 40, 39, 40, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0); if(0==strcmp("respond",data)) { gtk_entry_set_text(GTK_ENTRY(SendEntry.Address),filename.target); //gtk_entry_set_text(GTK_ENTRY(SendEntry.Theme),filename.title); } if(0==strcmp("transmit",data)) { Send_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(Send_textview)); g_print("adadhufgbkjk%s\n",Send_buffer); gtk_text_buffer_set_text(Send_buffer,Send_buffer,-1); gtk_entry_set_text(GTK_ENTRY(SendEntry.Theme),filename.title); } return table; }
/* This test reads an RTF file into a string, and imports the RTF string into a GtkTextBuffer, failing if either of these operations fail. It then displays the RTF code and its rendered result side by side, asking the user whether the RTF code is rendered correctly. The test succeeds if the user answers Yes, and fails if the user answers No. */ static void rtf_parse_human_approval_case(gconstpointer name) { GError *error = NULL; GtkWidget *label, *pane, *codescroll, *codeview, *rtfscroll, *rtfview, *window, *vbox, *buttons, *yes, *no; GtkTextBuffer *rtfbuffer = gtk_text_buffer_new(NULL); gchar *text, *filename = build_filename(name); gboolean was_correct = FALSE; GFile *file = g_file_new_for_path(filename); /* Get RTF code */ if(!g_file_get_contents(filename, &text, NULL, &error)) g_test_message("Error message: %s", error->message); g_assert(error == NULL); /* Import RTF code into text buffer. Import it from a file, even though we have already loaded the RTF code to display in the left-hand pane, because the RTF code may contain references to images. */ if(!rtf_text_buffer_import_file(rtfbuffer, file, NULL, &error)) g_test_message("Error message: %s", error->message); g_assert(error == NULL); g_object_unref(file); /* Build the interface widgets */ label = gtk_label_new("Is the RTF code rendered correctly?"); pane = gtk_hpaned_new(); codescroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(codescroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); codeview = gtk_text_view_new(); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(codeview), GTK_WRAP_CHAR); gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(codeview)), text, -1); rtfscroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(rtfscroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); rtfview = gtk_text_view_new_with_buffer(rtfbuffer); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(rtfview), GTK_WRAP_WORD); buttons = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(buttons), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(buttons), 6); yes = gtk_button_new_with_mnemonic("_Yes"); no = gtk_button_new_with_mnemonic("_No"); vbox = gtk_vbox_new(FALSE, 0); /* Pack everything into containers */ gtk_container_add(GTK_CONTAINER(codescroll), codeview); gtk_container_add(GTK_CONTAINER(rtfscroll), rtfview); gtk_paned_add1(GTK_PANED(pane), codescroll); gtk_paned_add2(GTK_PANED(pane), rtfscroll); gtk_container_add(GTK_CONTAINER(buttons), yes); gtk_container_add(GTK_CONTAINER(buttons), no); gtk_box_pack_start(GTK_BOX(vbox), pane, TRUE, TRUE, 6); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 6); gtk_box_pack_start(GTK_BOX(vbox), buttons, FALSE, FALSE, 6); /* Build window */ window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), filename); gtk_window_set_modal(GTK_WINDOW(window), TRUE); gtk_window_set_default_size(GTK_WINDOW(window), 1000, 400); gtk_paned_set_position(GTK_PANED(pane), 500); gtk_container_add(GTK_CONTAINER(window), vbox); /* Connect signals */ g_signal_connect(yes, "clicked", G_CALLBACK(yes_clicked), &was_correct); g_signal_connect(no, "clicked", G_CALLBACK(yes_not_clicked), NULL); g_signal_connect(window, "delete-event", G_CALLBACK(yes_not_clicked), NULL); gtk_widget_show_all(window); g_free(filename); /* Run it */ gtk_main(); gtk_widget_destroy(window); g_free(text); g_assert(was_correct); }
int poigod_usl(GtkWidget *wpredok) { char strsql[512]; iceb_u_str repl; class poigod_usl_data data; data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1); sprintf(strsql,"%s %s",name_system,gettext("Распечатать список годов, за которые введена информация")); gtk_window_set_title(GTK_WINDOW(data.window),strsql); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(poigod_usl_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } GtkWidget *vbox=gtk_vbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(data.window), vbox); data.label=gtk_label_new(gettext("Ждите !!!")); gtk_box_pack_start(GTK_BOX(vbox),data.label,FALSE,FALSE,0); repl.plus(gettext("Распечатать список годов, за которые введена информация")); sprintf(strsql,"%s:%s %s\n",gettext("База данных"),imabaz,organ); repl.ps_plus(strsql); repl.plus(gettext("Учёт услуг")); GtkWidget *label=gtk_label_new(repl.ravno_toutf()); gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0); data.view=gtk_text_view_new(); gtk_widget_set_usize(GTK_WIDGET(data.view),450,300); gtk_text_view_set_editable(GTK_TEXT_VIEW(data.view),FALSE); //Запрет на редактирование текста //PangoFontDescription *font_pango=pango_font_description_from_string("Nimbus Mono L, Bold 12"); PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno()); gtk_widget_modify_font(GTK_WIDGET(data.view),font_pango); pango_font_description_free(font_pango); data.buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(data.view)); GtkWidget *sw=gtk_scrolled_window_new(NULL,NULL); //gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); //gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(sw),data.view); data.bar=gtk_progress_bar_new(); gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_CONTINUOUS); gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_LEFT_TO_RIGHT); gtk_box_pack_start (GTK_BOX (vbox), data.bar, FALSE, FALSE, 2); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka=gtk_button_new_with_label(strsql); GtkTooltips *tooltops=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltops,data.knopka,gettext("Завершение работы в этом окне"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka),"clicked",GTK_SIGNAL_FUNC(poigod_usl_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka),(gpointer)0); gtk_box_pack_start (GTK_BOX (vbox), data.knopka, FALSE, FALSE, 2); gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна gtk_widget_show_all(data.window); //gtk_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна //gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна gtk_idle_add((GtkFunction)poigod_usl1,&data); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
void go_ss_nbs(class go_rr *data_rr) { go_ss_nbs_r_data data; data.rek_r=data_rr; char strsql[512]; iceb_u_str soob; printf("go_ss_nbs\n"); if(iceb_rsdatp(&data.dn,&data.mn,&data.gn,data.rek_r->datan.ravno(), &data.dk,&data.mk,&data.gk,data.rek_r->datak.ravno(),NULL) != 0) return; data.godn=startgodb; if(startgodb == 0 || startgodb > data.gn) data.godn=data.gn; data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1); sprintf(strsql,"%s %s",name_system,gettext("Журнал ордер")); gtk_window_set_title(GTK_WINDOW(data.window),strsql); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(go_ss_nbs_r_key_press),&data); GtkWidget *vbox=gtk_vbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(data.window), vbox); data.label=gtk_label_new(gettext("Ждите !!!")); gtk_box_pack_start(GTK_BOX(vbox),data.label,FALSE,FALSE,0); sprintf(strsql,"%s %s",gettext("Расчет журнал-ордера по счету"),data.rek_r->shet.ravno()); soob.new_plus(strsql); sprintf(strsql,"%s %d.%d.%d => %d.%d.%d",gettext("Расчет за период"), data.dn,data.mn,data.gn, data.dk,data.mk,data.gk); soob.ps_plus(strsql); GtkWidget *label=gtk_label_new(soob.ravno_toutf()); gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0); data.view=gtk_text_view_new(); gtk_widget_set_usize(GTK_WIDGET(data.view),400,300); gtk_text_view_set_editable(GTK_TEXT_VIEW(data.view),FALSE); //Запрет на редактирование текста PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno()); gtk_widget_modify_font(GTK_WIDGET(data.view),font_pango); pango_font_description_free(font_pango); data.buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(data.view)); GtkWidget *sw=gtk_scrolled_window_new(NULL,NULL); //gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); //gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(sw),data.view); data.bar=gtk_progress_bar_new(); gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_CONTINUOUS); gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_LEFT_TO_RIGHT); gtk_box_pack_start (GTK_BOX (vbox), data.bar, FALSE, FALSE, 2); gtk_widget_show_all(data.window); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka=gtk_button_new_with_label(strsql); GtkTooltips *tooltops=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltops,data.knopka,gettext("Завершение работы в этом окне"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka),"clicked",GTK_SIGNAL_FUNC(go_ss_nbs_r_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka),(gpointer)0); gtk_box_pack_start (GTK_BOX (vbox), data.knopka, FALSE, FALSE, 2); //gtk_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна //gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна gtk_idle_add((GtkFunction)go_ss_nbs_r1,&data); gtk_main(); iceb_rabfil(&data.imaf,&data.naim,"",0,NULL); }
/** * undo_undo: * @w: not used * @data: not used * * Executes an undo request on the current document **/ void undo_undo(UndoMain *undostruct) { UndoInfo *undoinfo; GtkTextView *textview; GtkTextBuffer *buffer; GtkTextIter iter, start_iter, end_iter; GtkTextMark *mark; cm_return_if_fail(undostruct != NULL); if (undostruct->undo == NULL) return; /* The undo data we need is always at the top op the stack. So, therefore, the first one */ undoinfo = (UndoInfo *)undostruct->undo->data; cm_return_if_fail(undoinfo != NULL); undoinfo->mergeable = FALSE; undostruct->redo = g_list_prepend(undostruct->redo, undoinfo); undostruct->undo = g_list_remove(undostruct->undo, undoinfo); textview = undostruct->textview; buffer = gtk_text_view_get_buffer(textview); undo_block(undostruct); /* Check if there is a selection active */ mark = gtk_text_buffer_get_insert(buffer); gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark); gtk_text_buffer_place_cursor(buffer, &iter); /* Move the view (scrollbars) to the correct position */ gtk_adjustment_set_value (GTK_ADJUSTMENT(gtk_text_view_get_vadjustment(textview)), undoinfo->window_position); switch (undoinfo->action) { case UNDO_ACTION_DELETE: gtk_text_buffer_get_iter_at_offset(buffer, &iter, undoinfo->start_pos); gtk_text_buffer_insert(buffer, &iter, undoinfo->text, -1); break; case UNDO_ACTION_INSERT: gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, undoinfo->start_pos); gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, undoinfo->end_pos); gtk_text_buffer_delete(buffer, &start_iter, &end_iter); break; case UNDO_ACTION_REPLACE_INSERT: gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, undoinfo->start_pos); gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, undoinfo->end_pos); gtk_text_buffer_delete(buffer, &start_iter, &end_iter); /* "pull" another data structure from the list */ if (undostruct->undo){ undoinfo = (UndoInfo *)undostruct->undo->data; undostruct->redo = g_list_prepend(undostruct->redo, undoinfo); undostruct->undo = g_list_remove(undostruct->undo, undoinfo); cm_return_if_fail(undoinfo != NULL); cm_return_if_fail(undoinfo->action == UNDO_ACTION_REPLACE_DELETE); gtk_text_buffer_insert(buffer, &start_iter, undoinfo->text, -1); } break; case UNDO_ACTION_REPLACE_DELETE: g_warning("This should not happen. UNDO_REPLACE_DELETE"); break; default: g_assert_not_reached(); break; } undostruct->change_state_func(undostruct, UNDO_STATE_UNCHANGED, UNDO_STATE_TRUE, undostruct->change_state_data); if (undostruct->undo == NULL) undostruct->change_state_func(undostruct, UNDO_STATE_FALSE, UNDO_STATE_UNCHANGED, undostruct->change_state_data); undo_unblock(undostruct); }
/* * 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 fx_many_initialize(FxMany* fxmany) { GtkWidget *lt_frame , *lb_frame , *scrollwindow , *scrollwindow1 , *rbox , *lbox; GtkWidget *close_button , *send_button; GtkTreeModel *model , *model1; GtkWidget *action_area = NULL; GdkPixbuf *pb = NULL; fxmany->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); GtkWidget *vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (fxmany->window), vbox); pb = gdk_pixbuf_new_from_file(SKIN_DIR"groupsend.png" , NULL); if(pb != NULL){ gtk_window_set_icon(GTK_WINDOW(fxmany->window) , pb); g_object_unref(pb); } gtk_window_set_title(GTK_WINDOW(fxmany->window) , _("SMS To Many")); gtk_widget_set_usize(fxmany->window , 660 , 520); g_signal_connect(fxmany->window , "key-press-event" , G_CALLBACK(key_press_func) , fxmany); gtk_container_set_border_width(GTK_CONTAINER(fxmany->window) , 5); fxmany->hbox = gtk_hbox_new(FALSE , 0); gtk_box_pack_start(GTK_BOX(vbox) , fxmany->hbox , TRUE , TRUE , 0); rbox = gtk_vbox_new(FALSE , 0); lbox = gtk_vbox_new(FALSE , 0); gtk_box_pack_start(GTK_BOX(fxmany->hbox) , rbox , TRUE , TRUE , 5); gtk_box_pack_start(GTK_BOX(fxmany->hbox) , lbox , FALSE , FALSE , 5); /*left top area*/ lt_frame = gtk_frame_new(_("Choose Contacts")); gtk_widget_set_usize(lt_frame , 180 , 0); model = fx_many_create_all_model(fxmany); fxmany->tree = gtk_tree_view_new_with_model(model); scrollwindow = gtk_scrolled_window_new(NULL , NULL); gtk_container_add(GTK_CONTAINER(scrollwindow) , fxmany->tree); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwindow) , GTK_POLICY_NEVER , GTK_POLICY_AUTOMATIC); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(fxmany->tree) , FALSE); //gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (fxmany->tree), TRUE); gtk_tree_view_set_level_indentation(GTK_TREE_VIEW(fxmany->tree) , -35); gtk_tree_view_set_hover_selection(GTK_TREE_VIEW(fxmany->tree) , TRUE); gtk_tree_view_columns_autosize(GTK_TREE_VIEW(fxmany->tree)); fx_many_create_all_column(fxmany); gtk_box_pack_start(GTK_BOX(lbox) , lt_frame , TRUE , TRUE , 5); gtk_container_add(GTK_CONTAINER(lt_frame) , scrollwindow); gtk_frame_set_shadow_type(GTK_FRAME(lt_frame) , GTK_SHADOW_IN); /*left bottom area*/ model1 = fx_many_create_choosed_model(); fxmany->selected = gtk_tree_view_new_with_model(model1); scrollwindow1 = gtk_scrolled_window_new(NULL , NULL); gtk_container_add(GTK_CONTAINER(scrollwindow1) , fxmany->selected); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwindow1) , GTK_POLICY_NEVER , GTK_POLICY_AUTOMATIC); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(fxmany->selected) , FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (fxmany->selected), TRUE); gtk_tree_view_set_level_indentation(GTK_TREE_VIEW(fxmany->selected) , 0); gtk_tree_view_set_hover_selection(GTK_TREE_VIEW(fxmany->selected) , TRUE); gtk_tree_view_columns_autosize(GTK_TREE_VIEW(fxmany->selected)); fx_many_create_selected_column(fxmany); lb_frame = gtk_frame_new(_("Contacts Selected")); gtk_widget_set_usize(lb_frame , 0 , 160); gtk_box_pack_start(GTK_BOX(lbox) , lb_frame , FALSE , FALSE , 5); gtk_container_add(GTK_CONTAINER(lb_frame) , scrollwindow1); /*right area*/ fxmany->label = gtk_label_new(""); gtk_label_set_markup(GTK_LABEL(fxmany->label) , _("Choosed [<span color=\"red\">0</span>] contacts, " "[<span color=\"red\">10000</span>] more available")); gtk_box_pack_start(GTK_BOX(rbox) , fxmany->label , FALSE , FALSE , 5); gtk_widget_set_usize(fxmany->label , 200 , 20); fxmany->recv_scroll = gtk_scrolled_window_new(NULL , NULL); gtk_box_pack_start(GTK_BOX(rbox) , fxmany->recv_scroll , TRUE , TRUE , 5); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(fxmany->recv_scroll) , GTK_POLICY_NEVER , GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(fxmany->recv_scroll) , GTK_SHADOW_ETCHED_IN); fxmany->recv_text = gtk_text_view_new(); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(fxmany->recv_text) , FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(fxmany->recv_text) , GTK_WRAP_CHAR); gtk_text_view_set_editable(GTK_TEXT_VIEW(fxmany->recv_text) , FALSE); gtk_container_add(GTK_CONTAINER(fxmany->recv_scroll) , fxmany->recv_text); fxmany->recv_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(fxmany->recv_text)); gtk_text_buffer_create_tag(fxmany->recv_buffer , "blue" , "foreground" , "blue" , NULL); gtk_text_buffer_create_tag(fxmany->recv_buffer , "red" , "foreground" , "red" , NULL); gtk_text_buffer_create_tag(fxmany->recv_buffer , "lm10" , "left_margin" , 10 , NULL); gtk_text_buffer_get_end_iter(fxmany->recv_buffer , &fxmany->recv_iter); gtk_text_buffer_create_mark(fxmany->recv_buffer , "scroll" , &fxmany->recv_iter , FALSE); fxmany->send_scroll = gtk_scrolled_window_new(NULL , NULL); gtk_box_pack_start(GTK_BOX(rbox) , fxmany->send_scroll , FALSE , FALSE , 5); gtk_widget_set_usize(fxmany->send_scroll , 0 , 120); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(fxmany->send_scroll) , GTK_POLICY_NEVER , GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(fxmany->send_scroll) , GTK_SHADOW_ETCHED_IN); fxmany->send_text = gtk_text_view_new(); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(fxmany->send_text) , GTK_WRAP_CHAR); // g_signal_connect(send_text , "key_press_event" , G_CALLBACK(ctrlpressed) , pthis); gtk_container_add(GTK_CONTAINER(fxmany->send_scroll) , fxmany->send_text); fxmany->send_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(fxmany->send_text)); gtk_text_buffer_get_iter_at_offset(fxmany->send_buffer , &fxmany->send_iter , 0); action_area = gtk_hbox_new(FALSE , 0); gtk_box_pack_start(GTK_BOX(vbox) , action_area , FALSE , FALSE , 10); close_button = gtk_button_new_with_label(_("Close")); gtk_widget_set_usize(close_button , 100 , 30); gtk_box_pack_end(GTK_BOX(action_area) , close_button , FALSE , TRUE , 2); g_signal_connect(close_button , "clicked" , G_CALLBACK(fx_many_on_close_clicked) , fxmany->window); send_button = gtk_button_new_with_label(_("Send")); gtk_widget_set_usize(send_button , 100 , 30); gtk_box_pack_end(GTK_BOX(action_area) , send_button , FALSE , TRUE , 2); g_signal_connect(send_button , "clicked" , G_CALLBACK(fx_many_on_send_clicked) , fxmany); gtk_window_set_position(GTK_WINDOW(fxmany->window) , GTK_WIN_POS_CENTER); GTK_WIDGET_SET_FLAGS(fxmany->send_text, GTK_CAN_FOCUS); gtk_widget_grab_focus(fxmany->send_text); gtk_widget_show_all(fxmany->window); }
static GtkWidget * do_appwindow (void) { GtkWidget *window; GtkWidget *table; GtkWidget *toolbar; GtkWidget *handlebox; GtkWidget *statusbar; GtkWidget *contents; GtkWidget *sw; GtkTextBuffer *buffer; #if GTK_CHECK_VERSION(3, 0, 0) GtkActionGroup *action_group; GtkUIManager *ui_manager; #else GtkAccelGroup *accel_group; GtkItemFactory *item_factory; #endif /* Create the toplevel window */ ++window_count; aspect_on = FALSE; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Application Window"); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy_cb), NULL); table = gtk_table_new (1, 4, FALSE); gtk_container_add (GTK_CONTAINER (window), table); #if GTK_CHECK_VERSION(3, 0, 0) action_group = gtk_action_group_new("ActionGroups"); gtk_action_group_add_actions(action_group, entries, G_N_ELEMENTS(entries), NULL); ui_manager = gtk_ui_manager_new(); gtk_ui_manager_insert_action_group(ui_manager, action_group, 0); gtk_ui_manager_add_ui_from_string(ui_manager, ui_definition, -1, NULL); gtk_table_attach (GTK_TABLE (table), gtk_ui_manager_get_widget (ui_manager, "/MainMenuBar"), /* X direction */ /* Y direction */ 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (ui_manager)); #else /* Create the menubar */ accel_group = gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); g_object_unref (accel_group); item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group); /* Set up item factory to go away with the window */ g_object_ref (item_factory); g_object_ref_sink (item_factory); g_object_unref (item_factory); g_object_set_data_full (G_OBJECT (window), "<main>", item_factory, (GDestroyNotify) g_object_unref); /* create menu items */ gtk_item_factory_create_items (item_factory, G_N_ELEMENTS (menu_items), menu_items, window); gtk_table_attach (GTK_TABLE (table), gtk_item_factory_get_widget (item_factory, "<main>"), /* X direction */ /* Y direction */ 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); #endif /* Create document */ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_table_attach (GTK_TABLE (table), sw, /* X direction */ /* Y direction */ 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_window_set_default_size (GTK_WINDOW (window), 200, 200); contents = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents), PANGO_WRAP_WORD); gtk_container_add (GTK_CONTAINER (sw), contents); /* Create the toolbar */ toolbar = gtk_toolbar_new (); GtkToolItem *newButton = gtk_tool_button_new_from_stock(GTK_STOCK_NEW); gtk_tool_item_set_tooltip_text(newButton, "Open another one of these windows"); g_signal_connect(G_OBJECT(newButton), "clicked", G_CALLBACK(do_appwindow), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), newButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *lockButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_tool_item_set_tooltip_text(lockButton, "This is a demo button that locks up the demo"); g_signal_connect(G_OBJECT(lockButton), "clicked", G_CALLBACK(sleep_cb), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), lockButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *decoButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_tool_item_set_tooltip_text(decoButton, "This is a demo button that toggles window decorations"); g_signal_connect(G_OBJECT(decoButton), "clicked", G_CALLBACK(toggle_decorated_cb), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), decoButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *lockRatioButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_tool_item_set_tooltip_text(lockRatioButton, "This is a demo button that locks the aspect ratio using a hint"); g_signal_connect(G_OBJECT(lockRatioButton), "clicked", G_CALLBACK(toggle_aspect_ratio), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), lockRatioButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *quitButton = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT); gtk_tool_item_set_tooltip_text(quitButton, "This is a demo button with a 'quit' icon"); g_signal_connect(G_OBJECT(quitButton), "clicked", G_CALLBACK(clicked_toolbar_cb), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), quitButton, -1); /*-1 means append to end of toolbar*/ handlebox = gtk_handle_box_new (); gtk_container_add (GTK_CONTAINER (handlebox), toolbar); gtk_table_attach (GTK_TABLE (table), handlebox, /* X direction */ /* Y direction */ 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Create statusbar */ statusbar = gtk_statusbar_new (); gtk_table_attach (GTK_TABLE (table), statusbar, /* X direction */ /* Y direction */ 0, 1, 3, 4, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Show text widget info in the statusbar */ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents)); gtk_text_buffer_set_text (buffer, "This demo demonstrates various kinds of windows that " "window managers and window manager themes should handle. " "Be sure to tear off the menu and toolbar, those are also " "a special kind of window.", -1); g_signal_connect_object (buffer, "changed", G_CALLBACK (update_statusbar), statusbar, 0); g_signal_connect_object (buffer, "mark_set", /* cursor moved */ G_CALLBACK (mark_set_callback), statusbar, 0); update_statusbar (buffer, GTK_STATUSBAR (statusbar)); gtk_widget_show_all (window); return window; }
static gboolean gb_vim_command_substitute (GtkWidget *active_widget, const gchar *command, const gchar *options, GError **error) { IdeSourceView *source_view; GtkTextBuffer *buffer; const gchar *search_begin = NULL; const gchar *search_end = NULL; const gchar *replace_begin = NULL; const gchar *replace_end = NULL; g_autofree gchar *search_text = NULL; g_autofree gchar *replace_text = NULL; GtkTextIter *substitute_begin = NULL; GtkTextIter *substitute_end = NULL; gunichar separator; gboolean replace_in_every_line = FALSE; gboolean replace_every_occurence_in_line = FALSE; gboolean replace_ask_for_confirmation = FALSE; GtkTextIter selection_begin, selection_end; g_assert (GTK_IS_WIDGET (active_widget)); g_assert (g_str_has_prefix (command, "%s") || g_str_has_prefix (command, "s")); if (IDE_IS_EDITOR_PAGE (active_widget)) source_view = ide_editor_page_get_view (IDE_EDITOR_PAGE (active_widget)); else return gb_vim_set_source_view_error (error); if (command[0] == '%') { replace_in_every_line = TRUE; command++; } command++; separator = g_utf8_get_char (command); if (!separator) goto invalid_request; search_begin = command = g_utf8_next_char (command); for (; *command; command = g_utf8_next_char (command)) { if (*command == '\\') { command = g_utf8_next_char (command); if (!*command) goto invalid_request; continue; } if (g_utf8_get_char (command) == separator) { search_end = command; break; } } if (search_end == NULL) { search_text = g_strdup (search_begin); replace_text = g_strdup (""); } else { search_text = g_strndup (search_begin, search_end - search_begin); replace_begin = command = g_utf8_next_char (command); for (; *command; command = g_utf8_next_char (command)) { if (*command == '\\') { command = g_utf8_next_char (command); if (!*command) goto invalid_request; continue; } if (g_utf8_get_char (command) == separator) { replace_end = command; break; } } if (replace_end == NULL) replace_text = g_strdup (replace_begin); else { replace_text = g_strndup (replace_begin, replace_end - replace_begin); command = g_utf8_next_char (command); } if (*command) { for (; *command; command++) { switch (*command) { case 'c': replace_ask_for_confirmation = TRUE; break; case 'g': replace_every_occurence_in_line = TRUE; break; /* what other options are supported? */ default: break; } } } } if (replace_ask_for_confirmation) { GVariant *variant; GVariantBuilder builder; g_variant_builder_init (&builder, G_VARIANT_TYPE_STRING_ARRAY); g_variant_builder_add (&builder, "s", search_text); g_variant_builder_add (&builder, "s", replace_text); variant = g_variant_builder_end (&builder); dzl_gtk_widget_action (active_widget, "editor-page", "replace-confirm", variant); return TRUE; } buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view)); if (gtk_text_buffer_get_has_selection (buffer)) { gtk_text_buffer_get_selection_bounds (buffer, &selection_begin, &selection_end); substitute_begin = &selection_begin; substitute_end = &selection_end; } gtk_text_buffer_begin_user_action (buffer); gb_vim_do_substitute (buffer, substitute_begin, substitute_end, search_text, replace_text, replace_every_occurence_in_line, replace_in_every_line); gtk_text_buffer_end_user_action (buffer); return TRUE; invalid_request: g_set_error (error, GB_VIM_ERROR, GB_VIM_ERROR_UNKNOWN_OPTION, _("Invalid search and replace request")); return FALSE; }
GtkWidget * do_css_multiplebgs (GtkWidget *do_widget) { if (!window) { GtkWidget *paned, *container, *child; GtkStyleProvider *provider; GtkTextBuffer *text; GBytes *bytes; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget)); gtk_window_set_default_size (GTK_WINDOW (window), 400, 300); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); container = gtk_overlay_new (); gtk_widget_add_events (container, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK); gtk_container_add (GTK_CONTAINER (window), container); child = gtk_drawing_area_new (); gtk_widget_set_name (child, "canvas"); g_signal_connect (child, "draw", G_CALLBACK (drawing_area_draw), NULL); gtk_container_add (GTK_CONTAINER (container), child); child = gtk_button_new (); gtk_widget_add_events (child, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK); gtk_overlay_add_overlay (GTK_OVERLAY (container), child); gtk_widget_set_name (child, "bricks-button"); gtk_widget_set_halign (child, GTK_ALIGN_CENTER); gtk_widget_set_valign (child, GTK_ALIGN_CENTER); gtk_widget_set_size_request (child, 200, 80); paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL); gtk_overlay_add_overlay (GTK_OVERLAY (container), paned); /* Need a filler so we get a handle */ child = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (paned), child); text = gtk_text_buffer_new (NULL); gtk_text_buffer_create_tag (text, "warning", "underline", PANGO_UNDERLINE_SINGLE, NULL); gtk_text_buffer_create_tag (text, "error", "underline", PANGO_UNDERLINE_ERROR, NULL); provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ()); container = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (paned), container); child = gtk_text_view_new_with_buffer (text); gtk_container_add (GTK_CONTAINER (container), child); g_signal_connect (text, "changed", G_CALLBACK (css_text_changed), provider); bytes = g_resources_lookup_data ("/css_multiplebgs/gtk.css", 0, NULL); gtk_text_buffer_set_text (text, g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes)); g_signal_connect (provider, "parsing-error", G_CALLBACK (show_parsing_error), gtk_text_view_get_buffer (GTK_TEXT_VIEW (child))); apply_css (window, provider); } if (!gtk_widget_get_visible (window)) gtk_widget_show_all (window); else { gtk_widget_destroy (window); window = NULL; } return window; }