static GtkWidget * cc_sharing_panel_new_media_sharing_row (const char *uri_or_path, CcSharingPanel *self) { GtkWidget *row, *box, *w; GUserDirectory dir = G_USER_N_DIRECTORIES; GIcon *icon; guint i; char *basename, *path; GFile *file; file = g_file_new_for_commandline_arg (uri_or_path); path = g_file_get_path (file); g_object_unref (file); row = gtk_list_box_row_new (); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_set_border_width (GTK_CONTAINER (box), 12); gtk_container_add (GTK_CONTAINER (row), box); /* Find the icon and create it */ for (i = 0; i < G_USER_N_DIRECTORIES; i++) { if (g_strcmp0 (path, g_get_user_special_dir (i)) == 0) { dir = i; break; } } icon = special_directory_get_gicon (dir); w = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_MENU); gtk_widget_set_margin_end (w, 12); gtk_container_add (GTK_CONTAINER (box), w); g_object_unref (icon); /* Label */ basename = g_filename_display_basename (path); w = gtk_label_new (basename); g_free (basename); gtk_container_add (GTK_CONTAINER (box), w); /* Remove button */ w = gtk_button_new_from_icon_name ("window-close-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_button_set_relief (GTK_BUTTON (w), GTK_RELIEF_NONE); gtk_widget_set_margin_top (w, 3); gtk_widget_set_margin_bottom (w, 3); gtk_widget_set_margin_end (w, 12); gtk_widget_set_valign (w, GTK_ALIGN_CENTER); gtk_box_pack_end (GTK_BOX (box), w, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (cc_sharing_panel_remove_folder), self); g_object_set_data (G_OBJECT (w), "row", row); g_object_set_data_full (G_OBJECT (row), "path", g_strdup (path), g_free); gtk_widget_show_all (row); return row; }
static void add_string (GtkInspectorStrvEditor *editor, const gchar *str) { GtkWidget *box; GtkWidget *entry; GtkWidget *button; box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_style_context_add_class (gtk_widget_get_style_context (box), "linked"); gtk_widget_show (box); entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry), str); gtk_widget_show (entry); gtk_box_pack_start (GTK_BOX (box), entry, FALSE, TRUE, 0); g_object_set_data (G_OBJECT (box), "entry", entry); g_signal_connect_swapped (entry, "notify::text", G_CALLBACK (emit_changed), editor); button = gtk_button_new_from_icon_name ("user-trash-symbolic", GTK_ICON_SIZE_MENU); gtk_style_context_add_class (gtk_widget_get_style_context (button), "image-button"); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (remove_string), editor); gtk_box_pack_start (GTK_BOX (editor->box), box, FALSE, FALSE, 0); gtk_widget_grab_focus (entry); emit_changed (editor); }
GtkWidget *cd_screenshot_build_options_widget (void) { GtkWidget *pHBox; const gchar *cTooltip; GtkWidget *pBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, CAIRO_DOCK_GUI_MARGIN); cTooltip = D_("in seconds."); pHBox = _add_label_in_new_hbox (D_("Delay"), cTooltip, pBox); GtkWidget *pScale; GtkAdjustment *pAdjustment = gtk_adjustment_new (0, 0, // min 10, // max 1, // step 1, // step 0); pScale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, GTK_ADJUSTMENT (pAdjustment)); gtk_scale_set_digits (GTK_SCALE (pScale), 0); g_object_set (pScale, "width-request", 100, NULL); gldi_dialog_set_widget_text_color (pScale); gtk_box_pack_end (GTK_BOX (pHBox), pScale, FALSE, FALSE, _MARGIN); g_object_set_data (G_OBJECT (pBox), "delay", pScale); gtk_widget_set_tooltip_text (pScale, cTooltip); cTooltip = D_("Grab the current window instead of the all screen"); pHBox = _add_label_in_new_hbox (D_("Grab the current window"), cTooltip, pBox); GtkWidget *pCheckButton = gtk_check_button_new (); gtk_box_pack_end (GTK_BOX (pHBox), pCheckButton, FALSE, FALSE, _MARGIN); g_object_set_data (G_OBJECT (pBox), "current", pCheckButton); gtk_widget_set_tooltip_text (pCheckButton, cTooltip); cTooltip = D_("Let empty to use the default one."); pHBox = _add_label_in_new_hbox (D_("File name"), cTooltip, pBox); GtkWidget *pEntry = gtk_entry_new (); gtk_box_pack_end (GTK_BOX (pHBox), pEntry, FALSE, FALSE, _MARGIN); g_object_set_data (G_OBJECT (pBox), "name", pEntry); gtk_widget_set_tooltip_text (pEntry, cTooltip); cTooltip = D_("Let empty to use the default one."); pHBox = _add_label_in_new_hbox (D_("Directory"), cTooltip, pBox); pEntry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (pEntry), myConfig.cDirPath ? myConfig.cDirPath : g_getenv ("HOME")); g_object_set_data (G_OBJECT (pBox), "dir", pEntry); GtkWidget *pButtonFileChooser = gtk_button_new_from_icon_name (GLDI_ICON_NAME_OPEN, GTK_ICON_SIZE_BUTTON); g_signal_connect (G_OBJECT (pButtonFileChooser), "clicked", G_CALLBACK (_cairo_dock_pick_a_file), pEntry); gtk_box_pack_end (GTK_BOX (pHBox), pButtonFileChooser, FALSE, FALSE, _MARGIN); gtk_box_pack_end (GTK_BOX (pHBox), pEntry, FALSE, FALSE, _MARGIN); gtk_widget_set_tooltip_text (pEntry, cTooltip); return pBox; }
void nautilus_floating_bar_add_action (NautilusFloatingBar *self, const gchar *icon_name, gint action_id) { GtkWidget *button; GtkStyleContext *context; button = gtk_button_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU); context = gtk_widget_get_style_context (button); gtk_button_set_relief (button, GTK_RELIEF_NONE); gtk_style_context_add_class (context, "circular"); gtk_style_context_add_class (context, "flat"); gtk_widget_set_valign (button, GTK_ALIGN_CENTER); gtk_box_pack_end (GTK_BOX (self), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "action-id", GINT_TO_POINTER (action_id)); g_signal_connect (button, "clicked", G_CALLBACK (action_button_clicked_cb), self); self->priv->is_interactive = TRUE; }
static void gtk_inspector_window_init (GtkInspectorWindow *iw) { GIOExtensionPoint *extension_point; GList *l, *extensions; gtk_widget_init_template (GTK_WIDGET (iw)); gtk_window_group_add_window (gtk_window_group_new (), GTK_WINDOW (iw)); extension_point = g_io_extension_point_lookup ("gtk-inspector-page"); extensions = g_io_extension_point_get_extensions (extension_point); for (l = extensions; l != NULL; l = l->next) { GIOExtension *extension = l->data; GType type; GtkWidget *widget; const char *name; char *title; GtkWidget *button; gboolean use_picker; type = g_io_extension_get_type (extension); widget = g_object_new (type, NULL); iw->extra_pages = g_list_prepend (iw->extra_pages, widget); name = g_io_extension_get_name (extension); g_object_get (widget, "title", &title, NULL); if (g_object_class_find_property (G_OBJECT_GET_CLASS (widget), "use-picker")) g_object_get (widget, "use-picker", &use_picker, NULL); else use_picker = FALSE; if (use_picker) { button = gtk_button_new_from_icon_name ("find-location-symbolic", GTK_ICON_SIZE_MENU); gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE); gtk_widget_set_halign (button, GTK_ALIGN_START); gtk_widget_set_valign (button, GTK_ALIGN_CENTER); g_signal_connect (button, "clicked", G_CALLBACK (gtk_inspector_on_inspect), iw); } else button = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_stack_add_titled (GTK_STACK (iw->top_stack), widget, name, title); gtk_stack_add_named (GTK_STACK (iw->button_stack), button, name); gtk_widget_show (widget); gtk_widget_show (button); g_free (title); } }
GtkWidget * _gtk_image_button_new_for_header_bar (const char *icon_name) { GtkWidget *button; button = gtk_button_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU); _gtk_menu_button_set_style_for_header_bar (button); return button; }
static void example_app_window_init (ExampleAppWindow *win) { gtk_widget_init_template (GTK_WIDGET (win)); ExampleAppWindowPrivate *priv = example_app_window_get_instance_private (win); gtk_header_bar_set_decoration_layout (GTK_HEADER_BAR (priv->header), ":"); priv->open_button = gtk_button_new_from_icon_name ("document-open-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_valign (priv->open_button, GTK_ALIGN_CENTER); gtk_header_bar_pack_start (GTK_HEADER_BAR (priv->header), priv->open_button); gtk_widget_show (priv->open_button); g_signal_connect (priv->open_button, "clicked", (GCallback) on_open_clicked, win); priv->save_button = gtk_button_new_from_icon_name ("document-save-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_valign (priv->save_button, GTK_ALIGN_CENTER); gtk_header_bar_pack_start (GTK_HEADER_BAR (priv->header), priv->save_button); gtk_widget_show (priv->save_button); g_signal_connect (priv->save_button, "clicked", (GCallback) on_save_clicked, win); priv->cancel_button = gtk_button_new_from_icon_name ("process-error-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_valign (priv->cancel_button, GTK_ALIGN_CENTER); gtk_header_bar_pack_end (GTK_HEADER_BAR (priv->header), priv->cancel_button); gtk_widget_show (priv->cancel_button); g_signal_connect (priv->cancel_button, "clicked", (GCallback) on_cancel_clicked, win); priv->destroy_button = gtk_button_new_from_icon_name ("edit-delete-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_valign (priv->destroy_button, GTK_ALIGN_CENTER); gtk_header_bar_pack_end (GTK_HEADER_BAR (priv->header), priv->destroy_button); gtk_widget_show (priv->destroy_button); g_signal_connect (priv->destroy_button, "clicked", (GCallback) on_destroy_clicked, win); }
static void setup_header_bar (GtkWidget *window, VteTerminal *vtterm, gboolean show_maximized_title) { /* * Using the default GtkHeaderBar title/subtitle widget makes the bar * too thick to look nice for a terminal, so set a custom widget. */ GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); const gchar *title = gtk_window_get_title (GTK_WINDOW (window)); GtkWidget *label = gtk_label_new (title ? title : "dwt"); g_object_bind_property (G_OBJECT (vtterm), "window-title", G_OBJECT (label), "label", G_BINDING_DEFAULT); GtkWidget *header = gtk_header_bar_new (); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (header), TRUE); gtk_header_bar_set_has_subtitle (GTK_HEADER_BAR (header), FALSE); gtk_header_bar_set_custom_title (GTK_HEADER_BAR (header), label); GtkWidget *button = gtk_button_new_from_icon_name ("tab-new-symbolic", GTK_ICON_SIZE_BUTTON); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_actionable_set_action_name (GTK_ACTIONABLE (button), "app.new-terminal"); gtk_header_bar_pack_start (GTK_HEADER_BAR (header), button); GtkWidget *revealer = gtk_revealer_new (); gtk_container_add (GTK_CONTAINER (revealer), gtk_image_new_from_icon_name ("software-update-urgent-symbolic", GTK_ICON_SIZE_BUTTON)); gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), 500); gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_CROSSFADE); gtk_header_bar_pack_end (GTK_HEADER_BAR (header), revealer); g_signal_connect (G_OBJECT (vtterm), "bell", G_CALLBACK (header_bar_term_beeped), revealer); g_object_bind_property (G_OBJECT (window), "urgency-hint", G_OBJECT (revealer), "reveal-child", G_BINDING_DEFAULT); gtk_window_set_titlebar (GTK_WINDOW (window), header); /* Hide the header bar when the window is maximized. */ if (!show_maximized_title) { g_object_bind_property (G_OBJECT (window), "is-maximized", G_OBJECT (header), "visible", G_BINDING_INVERT_BOOLEAN); } }
static void agreement_app_window_init(AgreementAppWindow *win) { gtk_window_set_title(GTK_WINDOW(win), "Agreement"); gtk_window_set_default_size(GTK_WINDOW(win), 800, 500); GtkWidget* grid; grid = gtk_grid_new(); gtk_container_add(GTK_CONTAINER(win), grid); GtkWidget *view; view = gtk_text_view_new(); gtk_widget_set_hexpand(view, true); gtk_widget_set_vexpand(view, true); gtk_grid_attach(GTK_GRID(grid), view, 0, 0, 1, 1); agreement_text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view)); gtk_text_buffer_set_text(agreement_text_buffer, "No file loaded", -1); GtkWidget *flow_box; flow_box = gtk_flow_box_new(); gtk_flow_box_set_min_children_per_line(GTK_FLOW_BOX(flow_box), 2); gtk_widget_set_halign(flow_box, GTK_ALIGN_CENTER); gtk_grid_attach(GTK_GRID(grid), flow_box, 0, 1, 1, 1); GtkWidget *no_button; no_button = gtk_button_new_from_icon_name("window-close", GTK_ICON_SIZE_BUTTON); gtk_button_set_always_show_image(GTK_BUTTON(no_button), true); gtk_button_set_label(GTK_BUTTON(no_button), "No, I do not agree"); gtk_container_add(GTK_CONTAINER(flow_box), no_button); GtkWidget *yes_button; yes_button = gtk_button_new_from_icon_name("go-next", GTK_ICON_SIZE_BUTTON); gtk_button_set_always_show_image(GTK_BUTTON(yes_button), true); gtk_button_set_label(GTK_BUTTON(yes_button), "Yes, I agree"); gtk_container_add(GTK_CONTAINER(flow_box), yes_button); gtk_widget_show_all(GTK_WIDGET(win)); }
static SeahorseKeyserverResultsRow* seahorse_keyserver_results_row_new (GObject *item) { g_autoptr(SeahorseKeyserverResultsRow) row = NULL; g_autoptr(GtkWidget) grid = NULL; g_autoptr(GtkWidget) label = NULL; g_autoptr(GtkWidget) import_button = NULL; gchar *item_label; gboolean item_exportable; g_object_get (item, "markup", &item_label, "exportable", &item_exportable, NULL); row = g_object_new (SEAHORSE_TYPE_KEYSERVER_RESULTS_ROW, NULL); gtk_list_box_row_set_selectable (GTK_LIST_BOX_ROW (row), FALSE); gtk_widget_set_sensitive (GTK_WIDGET (row), item_exportable); gtk_widget_show (GTK_WIDGET (row)); row->key = item; grid = gtk_grid_new (); g_object_set (grid, "margin", 6, NULL); gtk_widget_show (grid); label = gtk_label_new (item_label); gtk_widget_set_hexpand (label, TRUE); gtk_label_set_xalign (GTK_LABEL (label), 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), g_steal_pointer (&label), 0, 0, 1, 1); import_button = gtk_button_new_from_icon_name ("document-save-symbolic", GTK_ICON_SIZE_BUTTON); row->import_button = GTK_BUTTON (import_button); g_signal_connect_object (import_button, "clicked", G_CALLBACK (on_import_button_clicked), row, 0); gtk_widget_set_visible (import_button, TRUE); gtk_widget_set_valign (import_button, GTK_ALIGN_START); gtk_widget_set_halign (import_button, GTK_ALIGN_END); gtk_style_context_add_class (gtk_widget_get_style_context (import_button), "flat"); if (item_exportable) gtk_widget_set_tooltip_text (import_button, _("Import")); else gtk_widget_set_tooltip_text (import_button, _("Can’t import key")); gtk_grid_attach (GTK_GRID (grid), g_steal_pointer (&import_button), 1, 0, 1, 1); gtk_container_add (GTK_CONTAINER (row), g_steal_pointer (&grid)); return g_steal_pointer (&row); }
static GtkWidget* create_notebook_non_dragable_content (gchar **labels, const gchar *group, GtkPositionType pos) { GtkWidget *notebook, *title, *page, *action_widget; notebook = gtk_notebook_new (); gtk_widget_set_vexpand (notebook, TRUE); gtk_widget_set_hexpand (notebook, TRUE); action_widget = gtk_button_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_BUTTON); g_signal_connect (action_widget, "clicked", G_CALLBACK (action_clicked_cb), notebook); gtk_widget_show (action_widget); gtk_notebook_set_action_widget (GTK_NOTEBOOK (notebook), action_widget, GTK_PACK_END); g_signal_connect (notebook, "create-window", G_CALLBACK (window_creation_function), NULL); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), pos); gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_container_set_border_width (GTK_CONTAINER (notebook), 6); gtk_notebook_set_group_name (GTK_NOTEBOOK (notebook), group); while (*labels) { GtkWidget *button; button = gtk_button_new_with_label (*labels); /* Use GtkListBox since it bubbles up motion notify event, which can * experience more issues than GtkBox. */ page = gtk_list_box_new (); gtk_container_add (GTK_CONTAINER (page), button); title = gtk_label_new (*labels); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, title); gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (notebook), page, TRUE); gtk_notebook_set_tab_detachable (GTK_NOTEBOOK (notebook), page, TRUE); labels++; } g_signal_connect (GTK_NOTEBOOK (notebook), "page-reordered", G_CALLBACK (on_page_reordered), NULL); g_signal_connect_after (G_OBJECT (notebook), "drag-begin", G_CALLBACK (on_notebook_drag_begin), NULL); return notebook; }
static void gtk_inspector_strv_editor_init (GtkInspectorStrvEditor *editor) { gtk_orientable_set_orientation (GTK_ORIENTABLE (editor), GTK_ORIENTATION_VERTICAL); editor->box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (editor->box); editor->button = gtk_button_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_MENU); gtk_widget_set_focus_on_click (editor->button, FALSE); gtk_widget_set_halign (editor->button, GTK_ALIGN_END); gtk_widget_show (editor->button); g_signal_connect (editor->button, "clicked", G_CALLBACK (add_cb), editor); gtk_box_pack_start (GTK_BOX (editor), editor->box, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (editor), editor->button, FALSE, FALSE, 0); }
void cb_compose_images_load_image (CbComposeImages *self, const char *image_path) { GFile *file; GError *error = NULL; GdkTexture *texture; Image *image; #if DEBUG g_assert (!cb_compose_images_is_full (self)); #endif file = g_file_new_for_path (image_path); texture = gdk_texture_new_from_file (file, &error); if (error != NULL) { g_warning (G_STRLOC ": Couldn't load image %s: %s", image_path, error->message); g_object_unref (file); return; } g_array_set_size (self->images, self->images->len + 1); image = &g_array_index (self->images, Image, self->images->len - 1); image->path = g_strdup (image_path); image->fraction = 0.0; image->deleted = FALSE; image->image = gtk_image_new_from_paintable (GDK_PAINTABLE (g_steal_pointer (&texture))); gtk_image_set_can_shrink (GTK_IMAGE (image->image), TRUE); gtk_widget_set_size_request (image->image, -1, MIN_IMAGE_HEIGHT); gtk_widget_set_parent (image->image, GTK_WIDGET (self)); image->delete_button = gtk_button_new_from_icon_name ("window-close-symbolic"); gtk_style_context_add_class (gtk_widget_get_style_context (image->delete_button), "close-button"); g_signal_connect (image->delete_button, "clicked", G_CALLBACK (delete_button_clicked_cb), self); gtk_widget_set_parent (image->delete_button, GTK_WIDGET (self)); image->progressbar = gtk_progress_bar_new (); gtk_widget_hide (image->progressbar); gtk_widget_set_parent (image->progressbar, GTK_WIDGET (self)); g_object_unref (file); }
static GtkWidget* create_notebook (gchar **labels, const gchar *group, GtkPositionType pos) { GtkWidget *notebook, *title, *page, *action_widget; notebook = gtk_notebook_new (); gtk_widget_set_vexpand (notebook, TRUE); gtk_widget_set_hexpand (notebook, TRUE); action_widget = gtk_button_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_BUTTON); g_signal_connect (action_widget, "clicked", G_CALLBACK (action_clicked_cb), notebook); gtk_widget_show (action_widget); gtk_notebook_set_action_widget (GTK_NOTEBOOK (notebook), action_widget, GTK_PACK_END); g_signal_connect (notebook, "create-window", G_CALLBACK (window_creation_function), NULL); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), pos); gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_container_set_border_width (GTK_CONTAINER (notebook), 6); gtk_notebook_set_group_name (GTK_NOTEBOOK (notebook), group); while (*labels) { page = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (page), *labels); title = gtk_label_new (*labels); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, title); gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (notebook), page, TRUE); gtk_notebook_set_tab_detachable (GTK_NOTEBOOK (notebook), page, TRUE); labels++; } g_signal_connect (GTK_NOTEBOOK (notebook), "page-reordered", G_CALLBACK (on_page_reordered), NULL); g_signal_connect_after (G_OBJECT (notebook), "drag-begin", G_CALLBACK (on_notebook_drag_begin), NULL); return notebook; }
static RemminaPluginSpiceXferWidgets * remmina_plugin_spice_xfer_widgets_new(SpiceFileTransferTask *task) { TRACE_CALL(__func__); gchar *filename; RemminaPluginSpiceXferWidgets *widgets = g_new0(RemminaPluginSpiceXferWidgets, 1); widgets->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); widgets->hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); filename = spice_file_transfer_task_get_filename(task); widgets->label = gtk_label_new(filename); gtk_widget_set_halign(widgets->label, GTK_ALIGN_START); gtk_widget_set_valign(widgets->label, GTK_ALIGN_BASELINE); widgets->progress = gtk_progress_bar_new(); gtk_widget_set_hexpand(widgets->progress, TRUE); gtk_widget_set_valign(widgets->progress, GTK_ALIGN_CENTER); widgets->cancel = gtk_button_new_from_icon_name("gtk-cancel", GTK_ICON_SIZE_SMALL_TOOLBAR); g_signal_connect(widgets->cancel, "clicked", G_CALLBACK(remmina_plugin_spice_file_transfer_cancel_cb), task); gtk_widget_set_hexpand(widgets->cancel, FALSE); gtk_widget_set_valign(widgets->cancel, GTK_ALIGN_CENTER); gtk_box_pack_start(GTK_BOX(widgets->hbox), widgets->progress, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(widgets->hbox), widgets->cancel, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(widgets->vbox), widgets->label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(widgets->vbox), widgets->hbox, TRUE, TRUE, 0); gtk_widget_show_all(widgets->vbox); g_free(filename); return widgets; }
static void nemo_action_config_widget_init (NemoActionConfigWidget *self) { self->actions = NULL; self->bl_handler = g_signal_connect (nemo_plugin_preferences, "changed::" NEMO_PLUGIN_PREFERENCES_DISABLED_ACTIONS, G_CALLBACK (on_settings_changed), self); GtkWidget *label = nemo_config_base_widget_get_label (NEMO_CONFIG_BASE_WIDGET (self)); gchar *title = g_strdup (_("Actions")); gchar *markup = g_strdup_printf ("<b>%s</b>", title); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (title); g_free (markup); GtkWidget *widget = gtk_button_new_from_icon_name ("folder", GTK_ICON_SIZE_BUTTON); GtkWidget *bb = nemo_config_base_widget_get_buttonbox (NEMO_CONFIG_BASE_WIDGET (self)); gtk_box_pack_end (GTK_BOX (bb), widget, FALSE, FALSE, 0); gtk_widget_show (widget); g_signal_connect (widget, "clicked", G_CALLBACK (on_open_folder_clicked), self); g_signal_connect (nemo_config_base_widget_get_enable_button (NEMO_CONFIG_BASE_WIDGET (self)), "clicked", G_CALLBACK (on_enable_clicked), self); g_signal_connect (nemo_config_base_widget_get_disable_button (NEMO_CONFIG_BASE_WIDGET (self)), "clicked", G_CALLBACK (on_disable_clicked), self); g_signal_connect (NEMO_CONFIG_BASE_WIDGET (self)->listbox, "row-activated", G_CALLBACK (on_row_activated), self); refresh_widget (self); setup_dir_monitors (self); }
static GtkWidget * dict_create_word_row (IdeEditorSpellWidget *self, const gchar *word) { GtkWidget *row; GtkWidget *box; GtkWidget *label; GtkWidget *button; GtkStyleContext *style_context; g_assert (IDE_IS_EDITOR_SPELL_WIDGET (self)); g_assert (!ide_str_empty0 (word)); label = g_object_new (GTK_TYPE_LABEL, "label", word, "halign", GTK_ALIGN_START, NULL); button = gtk_button_new_from_icon_name ("window-close-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_can_focus (button, FALSE); g_signal_connect_swapped (button, "clicked", G_CALLBACK (dict_close_button_clicked_cb), self); style_context = gtk_widget_get_style_context (button); gtk_style_context_add_class (style_context, "close"); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (box), button, FALSE, FALSE, 0); row = gtk_list_box_row_new (); gtk_container_add (GTK_CONTAINER (row), box); g_object_set_data_full (G_OBJECT (row), "word", g_strdup (word), g_free); gtk_widget_show_all (row); return row; }
static void update_recordings_list(Data* data) { GList *children, *iter; children = gtk_container_get_children(GTK_CONTAINER(data->recordings_list_box)); for(iter = children; iter != NULL; iter = g_list_next(iter)) { gtk_widget_destroy(GTK_WIDGET(iter->data)); } g_list_free(children); if (!g_file_test(data->recordings_dir_path, G_FILE_TEST_IS_DIR)) { g_mkdir_with_parents(data->recordings_dir_path, 0666); } GDir* dir = g_dir_open(data->recordings_dir_path, 0, NULL); data->index = 0; GtkWidget* inner_box; GtkWidget* play_button; for (const gchar* filename = g_dir_read_name(dir); filename != NULL; filename = g_dir_read_name(dir)) { // only display .mp3 files if (strcmp(strrchr(filename, '.'), ".mp3") != 0) { continue; } data->index++; inner_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); play_button = gtk_button_new_from_icon_name("media-playback-start", GTK_ICON_SIZE_BUTTON); gtk_button_set_relief(GTK_BUTTON(play_button), GTK_RELIEF_NONE); char* full_filename = (char*) malloc((strlen(data->recordings_dir_path) + 1 + strlen(filename)) * sizeof(char)); sprintf(full_filename, "%s/%s", data->recordings_dir_path, filename); g_object_set_data(G_OBJECT(play_button), "full_filename", full_filename); g_signal_connect(GTK_BUTTON(play_button), "clicked", G_CALLBACK(on_play_button_clicked), data); gtk_box_pack_start(GTK_BOX(inner_box), gtk_label_new(filename), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(inner_box), play_button, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(data->recordings_list_box), inner_box); } g_dir_close(dir); gtk_widget_show_all(data->recordings_list_box); }
int main(int argc, char **argv) { gtk_init(&argc, &argv); GtkWidget *win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width(GTK_CONTAINER(win), 10); gtk_window_set_title(GTK_WINDOW(win), "JetSpace Pilot"); GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); GtkWidget *inp = gtk_entry_new(); GtkWidget *button = gtk_button_new_with_label(">"); v = gtk_button_new_from_icon_name("audio-input-microphone", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(box), v, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), inp, TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(box), button, FALSE, FALSE,0); mainbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10); gtk_box_pack_start(GTK_BOX(mainbox), box, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(win), mainbox); gtk_widget_show_all(win); //SIGNALS g_signal_connect(G_OBJECT(win), "destroy", G_CALLBACK(quit), NULL); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(trigger), inp); g_signal_connect(G_OBJECT(v), "clicked", G_CALLBACK(trigger_voice), inp); gtk_main(); return 0; }
/****************************************************************************** * Name * create_parallel_dialog * * Synopsis * #include "parallel_dialog.h" * * GtkWidget *create_parallel_dialog(void) * * Description * * * * Return value * GtkWidget * */ static GtkWidget *create_parallel_dialog(void) { GtkWidget *box_parallel_labels; GtkWidget *dialog_vbox25; GtkWidget *toolbar29; GtkWidget *dialog_action_area25; GtkWidget *hbuttonbox4; GtkWidget *btnDockInt; #ifndef USE_WEBKIT2 GtkWidget *scrolled_window; #endif gchar title[256]; sprintf(title, "%s - %s", settings.program_title, _("Parallel")); dialog_parallel = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(dialog_parallel), title); g_object_set_data(G_OBJECT(dialog_parallel), "dialog_parallel", dialog_parallel); gtk_window_resize(GTK_WINDOW(dialog_parallel), settings.parallel_width, settings.parallel_height); gtk_window_set_resizable(GTK_WINDOW(dialog_parallel), TRUE); dialog_vbox25 = gtk_dialog_get_content_area(GTK_DIALOG(dialog_parallel)); g_object_set_data(G_OBJECT(dialog_parallel), "dialog_vbox25", dialog_vbox25); gtk_widget_show(dialog_vbox25); UI_VBOX(vboxInt, FALSE, 0); gtk_widget_show(vboxInt); gtk_box_pack_start(GTK_BOX(dialog_vbox25), vboxInt, TRUE, TRUE, 0); toolbar29 = create_nav_toolbar(); gtk_widget_show(toolbar29); gtk_box_pack_start(GTK_BOX(vboxInt), toolbar29, FALSE, FALSE, 0); UI_HBOX(box_parallel_labels, TRUE, 2); gtk_widget_show(box_parallel_labels); gtk_box_pack_start(GTK_BOX(vboxInt), box_parallel_labels, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(box_parallel_labels), 2); #if 0 if (settings.parallel_list) { GtkWidget *plabel; gchar *label; gint modidx; for (modidx = 0; settings.parallel_list[modidx]; ++modidx) { plabel = gtk_label_new(NULL); gtk_widget_show(plabel); gtk_box_pack_start(GTK_BOX(box_parallel_labels), plabel, FALSE, FALSE, 0); gtk_label_set_use_markup(GTK_LABEL(plabel), TRUE); label = g_strdup_printf ("<span color='%s' weight='bold'>%s</span>", settings.bible_verse_num_color, settings.parallel_list[modidx]); gtk_label_set_markup(GTK_LABEL(plabel), label); g_free(label); } } #endif /* 0 */ #ifndef USE_WEBKIT2 scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolled_window); gtk_box_pack_start(GTK_BOX(vboxInt), scrolled_window, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type((GtkScrolledWindow *) scrolled_window, settings.shadow_type); #endif widgets.html_parallel_dialog = GTK_WIDGET(XIPHOS_HTML_NEW(NULL, FALSE, PARALLEL_TYPE)); gtk_widget_show(widgets.html_parallel_dialog); #ifdef USE_WEBKIT2 gtk_box_pack_start(GTK_BOX(vboxInt), widgets.html_parallel_dialog, TRUE, TRUE, 0); #else gtk_container_add(GTK_CONTAINER(scrolled_window), widgets.html_parallel_dialog); #endif g_signal_connect((gpointer)widgets.html_parallel_dialog, "popupmenu_requested", G_CALLBACK(_popupmenu_requested_cb), NULL); dialog_action_area25 = #ifdef HAVE_GTK_312 gtk_dialog_get_content_area(GTK_DIALOG(dialog_parallel)); #else gtk_dialog_get_action_area(GTK_DIALOG(dialog_parallel)); #endif g_object_set_data(G_OBJECT(dialog_parallel), "dialog_action_area25", dialog_action_area25); gtk_widget_show(dialog_action_area25); gtk_container_set_border_width(GTK_CONTAINER(dialog_action_area25), 10); #ifdef USE_GTK_3 hbuttonbox4 = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); #else hbuttonbox4 = gtk_hbutton_box_new(); #endif gtk_widget_show(hbuttonbox4); #ifdef HAVE_GTK_312 gtk_box_pack_start(GTK_BOX(dialog_action_area25), hbuttonbox4, FALSE, TRUE, 3); #else gtk_box_pack_start(GTK_BOX(dialog_action_area25), hbuttonbox4, TRUE, TRUE, 0); #endif gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox4), GTK_BUTTONBOX_END); btnDockInt = #ifdef HAVE_GTK_310 gtk_button_new_from_icon_name("window-close", GTK_ICON_SIZE_BUTTON); #else gtk_button_new_from_stock(GTK_STOCK_CLOSE); #endif gtk_widget_show(btnDockInt); gtk_container_add(GTK_CONTAINER(hbuttonbox4), btnDockInt); gtk_widget_set_can_default(btnDockInt, 1); g_signal_connect(G_OBJECT(dialog_parallel), "destroy", G_CALLBACK(on_dlgparallel_destroy), NULL); g_signal_connect(G_OBJECT(btnDockInt), "clicked", G_CALLBACK(gui_btnDockInt_clicked), NULL); g_signal_connect((gpointer)dialog_parallel, "configure_event", G_CALLBACK(on_parallel_configure_event), NULL); settings.display_parallel = 1; xml_set_value("Xiphos", "layout", "parallelopen", "1"); set_window_icon(GTK_WINDOW(dialog_parallel)); /* * (from xiphos.c) * a little paranoia: * clamp geometry values to a reasonable bound. * sometimes xiphos gets insane reconfig events as it dies, * especially if it's due to just shutting linux down. */ if ((settings.parallel_x < 0) || (settings.parallel_x > 2000)) settings.parallel_x = 40; if ((settings.parallel_y < 0) || (settings.parallel_y > 2000)) settings.parallel_y = 40; gtk_window_move(GTK_WINDOW(dialog_parallel), settings.parallel_x, settings.parallel_y); return dialog_parallel; }
static GtkWidget * nimf_settings_page_key_build_string_array (NimfSettingsPageKey *page_key) { GtkListStore *store; GtkWidget *treeview; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *scrolled_w; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *button1; GtkWidget *button2; gchar **strv; gchar *detailed_signal; GtkTreeIter iter; gint j; button1 = gtk_button_new_from_icon_name ("list-add", GTK_ICON_SIZE_SMALL_TOOLBAR); button2 = gtk_button_new_from_icon_name ("list-remove", GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_button_set_relief (GTK_BUTTON (button1), GTK_RELIEF_NONE); gtk_button_set_relief (GTK_BUTTON (button2), GTK_RELIEF_NONE); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); #if GTK_CHECK_VERSION (3, 12, 0) gtk_widget_set_margin_end (page_key->label, 15); #else gtk_widget_set_margin_right (page_key->label, 15); #endif gtk_box_pack_start (GTK_BOX (hbox), page_key->label, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (hbox), button2, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (hbox), button1, FALSE, FALSE, 0); store = gtk_list_store_new (1, G_TYPE_STRING); strv = g_settings_get_strv (page_key->gsettings, page_key->key); for (j = 0; strv[j] != NULL; j++) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, strv[j], -1); } treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Hotkeys", renderer, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); scrolled_w = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_w), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_w), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_add (GTK_CONTAINER (scrolled_w), treeview); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (vbox), scrolled_w, FALSE, FALSE, 0); page_key->treeview = treeview; detailed_signal = g_strdup_printf ("changed::%s", page_key->key); g_signal_connect (treeview, "realize", G_CALLBACK (on_tree_view_realize), scrolled_w); g_signal_connect (button1, "clicked", G_CALLBACK (on_button_clicked_add), page_key); g_signal_connect (button2, "clicked", G_CALLBACK (on_button_clicked_remove), page_key); g_signal_connect (page_key->gsettings, detailed_signal, G_CALLBACK (on_gsettings_changed), page_key->treeview); g_strfreev (strv); g_free (detailed_signal); return vbox; }
PocketvoxSetup* pocketvox_setup_new() { PocketvoxSetup *setup = (PocketvoxSetup *)g_object_new(TYPE_POCKETVOX_SETUP, NULL); setup->priv = G_TYPE_INSTANCE_GET_PRIVATE (setup, TYPE_POCKETVOX_SETUP, PocketvoxSetupPrivate); PocketvoxSetupPrivate *priv = setup->priv; bindtextdomain (GETTEXT_PACKAGE, PROGRAMNAME_LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain(GETTEXT_PACKAGE); priv->settings = g_settings_new("org.pocketvox.config"); //Build the window priv->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(priv->window), GTK_WIN_POS_CENTER_ALWAYS); gtk_window_set_title(GTK_WINDOW(priv->window), "pocketvox-gtk"); gtk_window_set_default_size(GTK_WINDOW(priv->window), 500, 350); gtk_window_set_icon_name(GTK_WINDOW(priv->window), "pocketvox"); gtk_container_set_border_width(GTK_CONTAINER(priv->window), 5); g_signal_connect_swapped(priv->window, "delete-event", G_CALLBACK(pocketvox_setup_save_and_quit), setup); GtkWidget *bar = gtk_header_bar_new(); gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(bar), TRUE); gtk_window_set_titlebar(GTK_WINDOW(priv->window), bar); //add a vertical box GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_add(GTK_CONTAINER(priv->window), box); //a button for all GtkWidget* button_notification = gtk_button_new_with_label(_("Notifications")); GtkWidget* button_user = gtk_button_new_with_label(_("Users")); GtkWidget* button_pocketsphinx = gtk_button_new_with_label(_("Pocketsphinx")); GtkWidget* button_gstreamer = gtk_button_new_with_label(_("Gstreamer")); gtk_widget_set_tooltip_text(button_notification, _("Display notifications parameters")); gtk_widget_set_tooltip_text(button_user, _("Display user parameters")); gtk_widget_set_tooltip_text(button_pocketsphinx, _("Display pocketsphinx parameters")); gtk_widget_set_tooltip_text(button_gstreamer, _("Display gstreamer parameters")); gtk_button_set_relief(GTK_BUTTON(button_notification), GTK_RELIEF_NONE); gtk_button_set_relief(GTK_BUTTON(button_user), GTK_RELIEF_NONE); gtk_button_set_relief(GTK_BUTTON(button_pocketsphinx), GTK_RELIEF_NONE); gtk_button_set_relief(GTK_BUTTON(button_gstreamer), GTK_RELIEF_NONE); GtkWidget *grid_button = gtk_grid_new(); gtk_grid_attach(GTK_GRID(grid_button), button_user, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(grid_button), button_notification, 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(grid_button), button_pocketsphinx, 0, 2, 1, 1); gtk_grid_attach(GTK_GRID(grid_button), button_gstreamer, 0, 3, 1, 1); GtkWidget* grid_notification = pocketvox_setup_get_notification_grid(setup); GtkWidget* grid_user = pocketvox_setup_get_user_grid(setup); GtkWidget* grid_pocketsphinx = pocketvox_setup_get_pocketsphinx_grid(setup); GtkWidget* grid_gstreamer = pocketvox_setup_get_gstreamer_grid(setup); //connect all signals (TODO) g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_show), grid_notification); g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide), grid_user); g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide), grid_pocketsphinx); g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer); g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification); g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_user); g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_show), grid_pocketsphinx); g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer); g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification); g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_show), grid_user); g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide), grid_pocketsphinx); g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer); g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification); g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide), grid_user); g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide), grid_pocketsphinx); g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_show), grid_gstreamer); //add GtkWidget* gridBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start(GTK_BOX(gridBox), grid_user, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(gridBox), grid_notification, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(gridBox), grid_pocketsphinx, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(gridBox), grid_gstreamer, TRUE, TRUE, 0); GtkWidget* separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL); gtk_widget_show(separator); GtkWidget *hgridBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start(GTK_BOX(hgridBox), grid_button, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hgridBox), separator, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(hgridBox), gridBox, TRUE, TRUE, 0); GtkWidget *stack = gtk_stack_new(); gtk_stack_set_transition_type(GTK_STACK(stack) , GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT); gtk_stack_set_transition_duration(GTK_STACK(stack), 1000); gtk_stack_add_titled(GTK_STACK(stack), hgridBox, "Setup", _("Configuration")); GtkWidget* scrolledWindow = gtk_scrolled_window_new(NULL, NULL); //return void pocketvox_setup_get_modules_grid(setup); gtk_container_add(GTK_CONTAINER(scrolledWindow), priv->listBox); gtk_widget_show_all(scrolledWindow); gtk_stack_add_titled(GTK_STACK(stack), scrolledWindow, "Modules", _("Modules")); //adding a task switcher GtkWidget* stackSwitcher = gtk_stack_switcher_new(); gtk_stack_switcher_set_stack(GTK_STACK_SWITCHER(stackSwitcher), GTK_STACK(stack)); gtk_header_bar_set_custom_title(GTK_HEADER_BAR(bar), stackSwitcher); GtkWidget *add_module_button = gtk_button_new_from_icon_name("gtk-new", GTK_ICON_SIZE_MENU); GtkWidget *remove_module_button = gtk_button_new_from_icon_name("gtk-delete", GTK_ICON_SIZE_MENU); gtk_button_set_relief(GTK_BUTTON(add_module_button), GTK_RELIEF_NONE); gtk_button_set_relief(GTK_BUTTON(remove_module_button), GTK_RELIEF_NONE); gtk_header_bar_pack_start(GTK_HEADER_BAR(bar), add_module_button); gtk_header_bar_pack_start(GTK_HEADER_BAR(bar), remove_module_button); g_signal_connect_swapped(remove_module_button, "clicked", G_CALLBACK(pocketvox_setup_remove_module), setup); g_signal_connect_swapped(add_module_button, "clicked", G_CALLBACK(pocketvox_setup_add_module_callback), setup); g_signal_connect_swapped(stack, "notify::visible-child", G_CALLBACK(pocketvox_stack_child_changed), add_module_button); g_signal_connect_swapped(stack, "notify::visible-child", G_CALLBACK(pocketvox_stack_child_changed), remove_module_button); //add them to the vbox gtk_box_pack_start(GTK_BOX(box), stack, TRUE, TRUE, 0); gtk_widget_show(grid_user); gtk_widget_hide(grid_notification); gtk_widget_hide(grid_pocketsphinx); gtk_widget_hide(grid_gstreamer); gtk_widget_show(gridBox); gtk_widget_show_all(grid_button); gtk_widget_show(hgridBox); gtk_widget_show(box); gtk_widget_show(stack); gtk_widget_show(stackSwitcher); gtk_widget_show_all(bar); //get the setup return setup; }
static GtkWidget *tab_widget_new(PASSAGE_TAB_INFO *tbinf, const gchar *label_text) { GtkWidget *box; #ifdef USE_GTK_3 // GdkRGBA color; #else GdkColor color; #endif g_return_val_if_fail(label_text != NULL, NULL); #ifdef HAVE_GTK_310 tbinf->button_close = gtk_button_new_from_icon_name("window-close-symbolic", GTK_ICON_SIZE_MENU); #else GtkWidget *tmp_toolbar_icon = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); tbinf->button_close = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(tbinf->button_close), tmp_toolbar_icon); gtk_button_set_relief(GTK_BUTTON(tbinf->button_close), GTK_RELIEF_NONE); #endif #ifndef USE_GTK_3 gtk_rc_parse_string("style \"tab-button-style\"\n" "{\n" " GtkWidget::focus-padding = 0\n" " GtkWidget::focus-line-width = 0\n" " xthickness = 0\n" " ythickness = 0\n" " GtkButton::internal-border = {0, 0, 0, 0}\n" " GtkButton::default-border = {0, 0, 0, 0}\n" " GtkButton::default-outside-border = {0, 0, 0, 0}\n" "}\n" "widget \"*.button-close\" style \"tab-button-style\""); gtk_widget_set_name(GTK_WIDGET(tbinf->button_close), "button-close"); #else gtk_widget_set_size_request(tbinf->button_close, 18, 16); #endif #ifndef USE_GTK_3 GtkRequisition r; gtk_widget_size_request(tbinf->button_close, &r); #endif gtk_widget_set_sensitive(tbinf->button_close, FALSE); gtk_widget_show(tbinf->button_close); tbinf->tab_label = GTK_LABEL(gtk_label_new(label_text)); gtk_widget_show(GTK_WIDGET(tbinf->tab_label)); #ifdef USE_GTK_3 #else color.red = 0; color.green = 0; color.blue = 0; gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_NORMAL, &color); gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_INSENSITIVE, &color); gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_ACTIVE, &color); gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_PRELIGHT, &color); gtk_widget_modify_fg(tbinf->button_close, GTK_STATE_SELECTED, &color); #endif UI_HBOX(box, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(tbinf->tab_label), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), tbinf->button_close, FALSE, FALSE, 0); gtk_widget_show(box); g_signal_connect(G_OBJECT(tbinf->button_close), "clicked", G_CALLBACK(on_notebook_main_close_page), tbinf); return box; }
GtkWidget *gui_create_display_informtion_dialog(void) { GtkWidget *dialog_vbox23; GtkWidget *hbox; GtkWidget *dialog_action_area23; GtkWidget *hbuttonbox2; GtkWidget *button_close; GtkWidget *image; dialog_display_info = gtk_dialog_new(); gtk_container_set_border_width(GTK_CONTAINER(dialog_display_info), 6); g_object_set_data(G_OBJECT(dialog_display_info), "dialog_display_info", dialog_display_info); gtk_window_set_title(GTK_WINDOW(dialog_display_info), " "); //GTK_WINDOW(dialog_display_info)->type = GTK_WINDOW_TOPLEVEL; gtk_window_set_default_size(GTK_WINDOW(dialog_display_info), 350, 200); gtk_window_set_resizable(GTK_WINDOW(dialog_display_info), TRUE); #ifndef USE_GTK_3 gtk_dialog_set_has_separator(GTK_DIALOG(dialog_display_info), FALSE); #endif dialog_vbox23 = gtk_dialog_get_content_area(GTK_DIALOG(dialog_display_info)); //GTK_DIALOG(dialog_display_info)->vbox; g_object_set_data(G_OBJECT(dialog_display_info), "dialog_vbox23", dialog_vbox23); gtk_widget_show(dialog_vbox23); UI_HBOX(hbox, FALSE, 12); gtk_widget_show(hbox); gtk_box_pack_start(GTK_BOX(dialog_vbox23), hbox, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(hbox), 6); image = #ifdef HAVE_GTK_310 gtk_image_new_from_icon_name("dialog-information", GTK_ICON_SIZE_DIALOG); #else gtk_image_new_from_stock(GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); #endif gtk_widget_show(image); gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, TRUE, 0); #ifndef HAVE_GTK_310 gtk_misc_set_alignment(GTK_MISC(image), 0.5, 0); #endif html_widget = GTK_WIDGET(XIPHOS_HTML_NEW(NULL, FALSE, 30)); //gtk_html_new(); gtk_widget_show(html_widget); gtk_box_pack_start(GTK_BOX(hbox), html_widget, TRUE, TRUE, 0); //gtk_container_add(GTK_CONTAINER(scrolledwindow70), html_widget); dialog_action_area23 = #ifdef HAVE_GTK_312 gtk_dialog_get_content_area(GTK_DIALOG(dialog_display_info)); #else gtk_dialog_get_action_area(GTK_DIALOG(dialog_display_info)); #endif g_object_set_data(G_OBJECT(dialog_display_info), "dialog_action_area23", dialog_action_area23); gtk_widget_show(dialog_action_area23); gtk_container_set_border_width(GTK_CONTAINER(dialog_action_area23), 10); #ifdef USE_GTK_3 hbuttonbox2 = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); #else hbuttonbox2 = gtk_hbutton_box_new(); #endif gtk_widget_show(hbuttonbox2); gtk_box_pack_start(GTK_BOX(dialog_action_area23), hbuttonbox2, TRUE, TRUE, 0); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox2), GTK_BUTTONBOX_END); button_close = #ifdef HAVE_GTK_310 gtk_button_new_from_icon_name("window-close", GTK_ICON_SIZE_BUTTON); #else gtk_button_new_from_stock(GTK_STOCK_CLOSE); #endif gtk_widget_show(button_close); gtk_container_add(GTK_CONTAINER(hbuttonbox2), button_close); gtk_widget_set_can_default(button_close, 1); g_signal_connect(G_OBJECT(button_close), "clicked", G_CALLBACK(button_close_clicked), NULL); g_signal_connect(G_OBJECT(dialog_display_info), "destroy", G_CALLBACK(on_dlgInformation_destroy), NULL); gtk_widget_show(dialog_display_info); gsI_isrunning = TRUE; return dialog_display_info; }
GtkWidget * dsn_config_new (void) { DsnConfigPrivate *priv; GtkWidget *dsn; GtkWidget *label; GtkWidget *sw; gchar *title; GdaDataModel *model; priv = g_new0 (DsnConfigPrivate, 1); dsn = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_widget_show (dsn); gtk_container_set_border_width (GTK_CONTAINER (dsn), 6); g_object_set_data_full (G_OBJECT (dsn), DSN_CONFIG_DATA, priv, (GDestroyNotify) free_private_data); /* title */ title = g_strdup_printf ("<b>%s</b>\n%s", _("Data Sources"), _("Data sources are the means by which database " "connections are identified: all " "the information needed to open a connection to " "a specific database using a 'provider' is referenced using " "a unique name.")); priv->title = gdaui_bar_new (title); g_free (title); gdaui_bar_set_icon_from_resource (GDAUI_BAR (priv->title), "/images/gdaui-generic.png"); gtk_box_pack_start (GTK_BOX (dsn), priv->title, FALSE, FALSE, 0); gtk_widget_show (priv->title); /* horizontal box for the provider list and its properties */ GtkWidget *hbox; hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (dsn), hbox, TRUE, TRUE, 0); /* left part */ GtkWidget *vbox; vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_set_size_request (vbox, 150, -1); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); /* create the data source list */ 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_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); model = gda_config_list_dsn (); priv->dsn_list = gdaui_raw_grid_new (model); gtk_tree_view_move_column_after (GTK_TREE_VIEW (priv->dsn_list), gtk_tree_view_get_column (GTK_TREE_VIEW (priv->dsn_list), 1), gtk_tree_view_get_column (GTK_TREE_VIEW (priv->dsn_list), 2)); g_object_unref (model); g_object_set_data (G_OBJECT (dsn), "grid", priv->dsn_list); gdaui_data_proxy_column_set_editable (GDAUI_DATA_PROXY (priv->dsn_list), 0, FALSE); gdaui_data_selector_set_column_visible (GDAUI_DATA_SELECTOR (priv->dsn_list), -1, FALSE); gdaui_data_selector_set_column_visible (GDAUI_DATA_SELECTOR (priv->dsn_list), 0, TRUE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->dsn_list), FALSE); g_object_set (priv->dsn_list, "info-cell-visible", FALSE, NULL); gtk_container_add (GTK_CONTAINER (sw), priv->dsn_list); g_signal_connect (priv->dsn_list, "selection-changed", G_CALLBACK (list_selection_changed_cb), dsn); g_signal_connect (priv->dsn_list, "populate-popup", G_CALLBACK (list_popup_cb), dsn); /* add/delete buttons */ GtkWidget *toolbar; toolbar = gtk_toolbar_new (); gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_style_context_add_class (gtk_widget_get_style_context (toolbar), "inline-toolbar"); gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0); GtkToolItem *titem; titem = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "list-add-symbolic"); gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.DatasourceNew"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1); titem = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "list-remove-symbolic"); gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.DatasourceDelete"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1); /* create the data source's properties */ GtkWidget *stack; stack = gtk_stack_new (); priv->stack = stack; gtk_box_pack_start (GTK_BOX (hbox), stack, TRUE, TRUE, 10); label = gtk_label_new (_("No data source selected.")); gtk_stack_add_named (GTK_STACK (stack), label, ST_NOPROP); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_stack_add_named (GTK_STACK (stack), vbox, ST_PROP); GtkWidget *form; form = gdaui_dsn_editor_new (); priv->dsn_editor = GDAUI_DSN_EDITOR (form); gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0); g_signal_connect (priv->dsn_editor, "changed", G_CALLBACK (dsn_editor_changed_cb), dsn); /* action buttons */ GtkWidget *hbox2; hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 6); GtkWidget *bbox; bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_hexpand (bbox, TRUE); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_CENTER); gtk_box_pack_start (GTK_BOX (hbox2), bbox, FALSE, FALSE, 6); GtkWidget *button; button = gtk_toggle_button_new_with_label (_("Definition")); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); priv->view_buttons [GDAUI_DSN_EDITOR_PANE_DEFINITION] = GTK_TOGGLE_BUTTON (button); g_signal_connect (button, "toggled", G_CALLBACK (view_toggled_cb), dsn); button = gtk_toggle_button_new_with_label (_("Parameters")); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); priv->view_buttons [GDAUI_DSN_EDITOR_PANE_PARAMS] = GTK_TOGGLE_BUTTON (button); g_signal_connect (button, "toggled", G_CALLBACK (view_toggled_cb), dsn); button = gtk_toggle_button_new_with_label (_("Authentication")); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); priv->view_buttons [GDAUI_DSN_EDITOR_PANE_AUTH] = GTK_TOGGLE_BUTTON (button); g_signal_connect (button, "toggled", G_CALLBACK (view_toggled_cb), dsn); button = gtk_button_new_from_icon_name ("document-save-symbolic", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0); priv->commit_button = button; gtk_widget_set_sensitive (button, FALSE); gtk_widget_set_tooltip_text (button, _("Write changes made to the DSN")); g_signal_connect (button, "clicked", G_CALLBACK (save_cb), dsn); gtk_widget_show_all (hbox); return dsn; }
void gui_create_search_sidebar(void) { GtkWidget *vbox1; GtkWidget *vbox90; GtkWidget *vbox5; GtkWidget *frame2; GtkWidget *vbox2; GtkWidget *frame3; GtkWidget *vbox3; GtkWidget *frame4; GtkWidget *vbox4; GtkWidget *table1; GtkWidget *label1; GtkWidget *label2; GtkWidget *scrolledwindow_search; GtkWidget *viewport_search; gchar *header; //GtkListStore *store; //ss = &sss; scrolledwindow_search = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow_search); gtk_container_add(GTK_CONTAINER(widgets.notebook_sidebar), scrolledwindow_search); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow_search), settings.shadow_type); gtk_container_set_border_width(GTK_CONTAINER(scrolledwindow_search), 2); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow_search), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); viewport_search = gtk_viewport_new(NULL, NULL); gtk_widget_show(viewport_search); gtk_container_add(GTK_CONTAINER(scrolledwindow_search), viewport_search); UI_VBOX(vbox1, FALSE, 4); gtk_widget_show(vbox1); gtk_container_add(GTK_CONTAINER(viewport_search), vbox1); UI_VBOX(vbox5, FALSE, 0); gtk_widget_show(vbox5); gtk_box_pack_start(GTK_BOX(vbox1), vbox5, FALSE, TRUE, 0); /* text entry */ ss.entrySearch = gtk_entry_new(); gtk_widget_show(ss.entrySearch); gtk_box_pack_start(GTK_BOX(vbox5), ss.entrySearch, TRUE, TRUE, 0); gtk_widget_set_size_request(ss.entrySearch, 130, -1); ; /* find button */ #ifdef HAVE_GTK_310 remember_search = gtk_button_new_from_icon_name("edit-find-symbolic", GTK_ICON_SIZE_BUTTON); #else remember_search = gtk_button_new_from_stock(GTK_STOCK_FIND); #endif gtk_widget_show(remember_search); gtk_box_pack_start(GTK_BOX(vbox5), remember_search, TRUE, FALSE, 0); gtk_widget_set_tooltip_text(remember_search, _("This is an inclusive (\"AND\") search:\nFind matches showing all words.")); gtk_button_set_relief(GTK_BUTTON(remember_search), GTK_RELIEF_HALF); /* progress bar */ ss.progressbar_search = gtk_progress_bar_new(); gtk_widget_show(ss.progressbar_search); gtk_box_pack_start(GTK_BOX(vbox5), ss.progressbar_search, FALSE, TRUE, 0); /* button to open advanced search */ ss.advanced_search = gtk_button_new_with_mnemonic(_("_Open Advanced Search")); gtk_widget_show(ss.advanced_search); gtk_box_pack_start(GTK_BOX(vbox5), ss.advanced_search, TRUE, FALSE, 0); gtk_widget_set_tooltip_text(ss.advanced_search, _("Open the separate Advanced Search dialog.")); gtk_button_set_relief(GTK_BUTTON(ss.advanced_search), GTK_RELIEF_HALF); ss.frame_module = gtk_frame_new(NULL); gtk_widget_show(ss.frame_module); gtk_box_pack_start(GTK_BOX(vbox1), ss.frame_module, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(ss.frame_module), 2); gtk_frame_set_shadow_type(GTK_FRAME(ss.frame_module), GTK_SHADOW_NONE); label1 = gtk_label_new(NULL); header = g_strdup_printf("<span weight=\"bold\">%s</span>", _("Search Module")); gtk_label_set_markup(GTK_LABEL(label1), header); g_free(header); gtk_widget_show(label1); gtk_frame_set_label_widget(GTK_FRAME(ss.frame_module), label1); UI_VBOX(vbox90, FALSE, 0); gtk_widget_show(vbox90); gtk_container_add(GTK_CONTAINER(ss.frame_module), vbox90); gtk_container_set_border_width(GTK_CONTAINER(vbox90), 4); ss.radiobutton_search_text = gtk_radio_button_new_with_label(NULL, _("Bible")); gtk_widget_show(ss.radiobutton_search_text); gtk_widget_set_size_request(ss.radiobutton_search_text, -1, 20); gtk_box_pack_start(GTK_BOX(vbox90), ss.radiobutton_search_text, FALSE, FALSE, 0); ss.radiobutton_search_comm = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.radiobutton_search_text), _("Commentary")); gtk_widget_show(ss.radiobutton_search_comm); gtk_widget_set_size_request(ss.radiobutton_search_comm, -1, 20); gtk_box_pack_start(GTK_BOX(vbox90), ss.radiobutton_search_comm, FALSE, FALSE, 0); frame2 = gtk_frame_new(NULL); gtk_widget_show(frame2); gtk_box_pack_start(GTK_BOX(vbox1), frame2, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(frame2), 2); gtk_frame_set_shadow_type(GTK_FRAME(frame2), GTK_SHADOW_NONE); label1 = gtk_label_new(NULL); header = g_strdup_printf("<span weight=\"bold\">%s</span>", _("Search Type")); gtk_label_set_markup(GTK_LABEL(label1), header); g_free(header); gtk_widget_show(label1); gtk_frame_set_label_widget(GTK_FRAME(frame2), label1); UI_VBOX(vbox2, TRUE, 0); gtk_widget_show(vbox2); gtk_container_add(GTK_CONTAINER(frame2), vbox2); gtk_container_set_border_width(GTK_CONTAINER(vbox2), 4); ss.rbMultiword = gtk_radio_button_new_with_label(NULL, _("Optimized (\"Lucene\")")); gtk_widget_show(ss.rbMultiword); gtk_box_pack_start(GTK_BOX(vbox2), ss.rbMultiword, FALSE, FALSE, 0); gtk_widget_set_size_request(ss.rbMultiword, -1, 20); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ss.rbMultiword), TRUE); ss.rbRegExp = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbMultiword), _("Regular expression")); gtk_widget_show(ss.rbRegExp); gtk_box_pack_start(GTK_BOX(vbox2), ss.rbRegExp, FALSE, FALSE, 0); gtk_widget_set_size_request(ss.rbRegExp, -1, 20); ss.rbPhraseSearch = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbMultiword), _("Exact phrase")); gtk_widget_show(ss.rbPhraseSearch); gtk_box_pack_start(GTK_BOX(vbox2), ss.rbPhraseSearch, FALSE, FALSE, 0); gtk_widget_set_size_request(ss.rbPhraseSearch, -1, 20); frame3 = gtk_frame_new(NULL); gtk_widget_show(frame3); gtk_box_pack_start(GTK_BOX(vbox1), frame3, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(frame3), 2); gtk_frame_set_shadow_type(GTK_FRAME(frame3), GTK_SHADOW_NONE); label1 = gtk_label_new(NULL); header = g_strdup_printf("<span weight=\"bold\">%s</span>", _("Search Options")); gtk_label_set_markup(GTK_LABEL(label1), header); g_free(header); gtk_widget_show(label1); gtk_frame_set_label_widget(GTK_FRAME(frame3), label1); UI_VBOX(vbox3, FALSE, 0); gtk_widget_show(vbox3); gtk_container_add(GTK_CONTAINER(frame3), vbox3); gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4); ss.ckbCaseSensitive = gtk_check_button_new_with_label(_("Match case")); gtk_widget_show(ss.ckbCaseSensitive); gtk_box_pack_start(GTK_BOX(vbox3), ss.ckbCaseSensitive, FALSE, FALSE, 0); gtk_widget_set_size_request(ss.ckbCaseSensitive, -1, 20); frame4 = gtk_frame_new(NULL); gtk_widget_show(frame4); gtk_box_pack_start(GTK_BOX(vbox1), frame4, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(frame4), 2); gtk_frame_set_shadow_type(GTK_FRAME(frame4), GTK_SHADOW_NONE); label1 = gtk_label_new(NULL); header = g_strdup_printf("<span weight=\"bold\">%s</span>", _("Search Scope")); gtk_label_set_markup(GTK_LABEL(label1), header); g_free(header); gtk_widget_show(label1); gtk_frame_set_label_widget(GTK_FRAME(frame4), label1); UI_VBOX(vbox4, TRUE, 0); gtk_widget_show(vbox4); gtk_container_add(GTK_CONTAINER(frame4), vbox4); gtk_container_set_border_width(GTK_CONTAINER(vbox4), 4); ss.rbNoScope = gtk_radio_button_new_with_label(NULL, _("No scope")); gtk_widget_show(ss.rbNoScope); gtk_box_pack_start(GTK_BOX(vbox4), ss.rbNoScope, FALSE, FALSE, 0); gtk_widget_set_size_request(ss.rbNoScope, -1, 20); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ss.rbNoScope), TRUE); ss.rrbUseBounds = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbNoScope), _("Use bounds")); gtk_widget_show(ss.rrbUseBounds); gtk_box_pack_start(GTK_BOX(vbox4), ss.rrbUseBounds, FALSE, FALSE, 0); gtk_widget_set_size_request(ss.rrbUseBounds, -1, 20); ss.rbLastSearch = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbNoScope), _("Last search")); gtk_widget_show(ss.rbLastSearch); gtk_box_pack_start(GTK_BOX(vbox4), ss.rbLastSearch, FALSE, FALSE, 0); gtk_widget_set_size_request(ss.rbLastSearch, -1, 20); ss.frame5 = gtk_frame_new(NULL); gtk_widget_show(ss.frame5); gtk_box_pack_start(GTK_BOX(vbox1), ss.frame5, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(ss.frame5), 2); gtk_widget_hide(ss.frame5); gtk_frame_set_shadow_type(GTK_FRAME(ss.frame5), GTK_SHADOW_NONE); label1 = gtk_label_new(NULL); header = g_strdup_printf("<span weight=\"bold\">%s</span>", _("Bounds")); gtk_label_set_markup(GTK_LABEL(label1), header); g_free(header); gtk_widget_show(label1); gtk_frame_set_label_widget(GTK_FRAME(ss.frame5), label1); #ifdef HAVE_GTK_34 table1 = gtk_grid_new(); gtk_widget_show(table1); gtk_container_add(GTK_CONTAINER(ss.frame5), table1); gtk_grid_set_row_spacing(GTK_GRID(table1), 3); gtk_grid_set_column_spacing(GTK_GRID(table1), 3); gtk_container_set_border_width(GTK_CONTAINER(table1), 8); label1 = gtk_label_new(_("Lower")); gtk_widget_show(label1); gtk_grid_attach(GTK_GRID(table1), label1, 0, 0, 1, 1); #ifndef HAVE_GTK_310 gtk_misc_set_alignment(GTK_MISC(label1), 1.0, 0.5); #endif ss.entryLower = gtk_combo_box_text_new_with_entry(); gtk_widget_show(ss.entryLower); gtk_grid_attach(GTK_GRID(table1), ss.entryLower, 1, 0, 1, 1); gtk_widget_set_size_request(ss.entryLower, 114, 22); label2 = gtk_label_new(_("Upper")); gtk_widget_show(label2); gtk_grid_attach(GTK_GRID(table1), label2, 0, 1, 1, 1); #ifndef HAVE_GTK_310 gtk_misc_set_alignment(GTK_MISC(label2), 1.0, 0.5); #endif ss.entryUpper = gtk_combo_box_text_new_with_entry(); gtk_widget_show(ss.entryUpper); gtk_grid_attach(GTK_GRID(table1), ss.entryUpper, 1, 1, 1, 1); gtk_widget_set_size_request(ss.entryUpper, 114, 22); #else table1 = gtk_table_new(2, 2, FALSE); gtk_widget_show(table1); gtk_container_add(GTK_CONTAINER(ss.frame5), table1); gtk_table_set_row_spacings(GTK_TABLE(table1), 3); gtk_table_set_col_spacings(GTK_TABLE(table1), 3); gtk_container_set_border_width(GTK_CONTAINER(table1), 8); label1 = gtk_label_new(_("Lower")); gtk_widget_show(label1); gtk_table_attach(GTK_TABLE(table1), label1, 0, 1, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label1), 1.0, 0.5); label2 = gtk_label_new(_("Upper")); gtk_widget_show(label2); gtk_table_attach(GTK_TABLE(table1), label2, 0, 1, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label2), 1.0, 0.5); #ifdef HAVE_GTK_224 ss.entryLower = gtk_combo_box_text_new_with_entry(); #else ss.entryLower = gtk_combo_box_entry_new_text(); #endif gtk_widget_show(ss.entryLower); gtk_table_attach(GTK_TABLE(table1), ss.entryLower, 1, 2, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_widget_set_size_request(ss.entryLower, 114, 22); #ifdef HAVE_GTK_224 ss.entryUpper = gtk_combo_box_text_new_with_entry(); #else ss.entryUpper = gtk_combo_box_entry_new_text(); #endif gtk_widget_show(ss.entryUpper); gtk_table_attach(GTK_TABLE(table1), ss.entryUpper, 1, 2, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_widget_set_size_request(ss.entryUpper, 114, 22); #endif g_signal_connect(G_OBJECT(ss.rrbUseBounds), "toggled", G_CALLBACK(on_rrbUseBounds_toggled), NULL); g_signal_connect(G_OBJECT(remember_search), "clicked", G_CALLBACK(on_search_button_clicked), NULL); g_signal_connect(G_OBJECT(ss.entrySearch), "activate", G_CALLBACK(on_search_button_clicked), NULL); g_signal_connect(G_OBJECT(ss.advanced_search), "clicked", G_CALLBACK(main_open_search_dialog), NULL); /* prep for toggle case sensitive availability per optimized */ g_signal_connect(ss.rbMultiword, "toggled", G_CALLBACK(sidebar_optimized_toggled), NULL); /* initialize it off */ gtk_widget_set_sensitive(ss.ckbCaseSensitive, FALSE); }
static void ephy_find_toolbar_init (EphyFindToolbar *toolbar) { GtkWidget *box; GtkSizeGroup *size_group; size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED); gtk_container_add (GTK_CONTAINER (toolbar), box); toolbar->entry = gtk_entry_new (); gtk_entry_set_width_chars (GTK_ENTRY (toolbar->entry), 32); gtk_entry_set_max_length (GTK_ENTRY (toolbar->entry), 512); gtk_entry_set_placeholder_text (GTK_ENTRY (toolbar->entry), _("Type to search…")); gtk_container_add (GTK_CONTAINER (box), toolbar->entry); /* Prev */ toolbar->prev = gtk_button_new_from_icon_name ("go-up-symbolic", GTK_ICON_SIZE_MENU); gtk_widget_set_tooltip_text (toolbar->prev, _("Find previous occurrence of the search string")); gtk_container_add (GTK_CONTAINER (box), toolbar->prev); gtk_widget_show_all (toolbar->prev); gtk_widget_set_sensitive (toolbar->prev, FALSE); /* Next */ toolbar->next = gtk_button_new_from_icon_name ("go-down-symbolic", GTK_ICON_SIZE_MENU); gtk_widget_set_tooltip_text (toolbar->next, _("Find next occurrence of the search string")); gtk_container_add (GTK_CONTAINER (box), toolbar->next); gtk_widget_set_sensitive (toolbar->next, FALSE); gtk_size_group_add_widget (size_group, toolbar->entry); gtk_size_group_add_widget (size_group, toolbar->next); gtk_size_group_add_widget (size_group, toolbar->prev); g_object_unref (size_group); /* connect signals */ g_signal_connect (toolbar->entry, "icon-release", G_CALLBACK (search_entry_clear_cb), toolbar); g_signal_connect (toolbar->entry, "key-press-event", G_CALLBACK (entry_key_press_event_cb), toolbar); g_signal_connect_after (toolbar->entry, "changed", G_CALLBACK (search_entry_changed_cb), toolbar); g_signal_connect (toolbar->entry, "activate", G_CALLBACK (entry_activate_cb), toolbar); g_signal_connect_swapped (toolbar->next, "clicked", G_CALLBACK (ephy_find_toolbar_find_next), toolbar); g_signal_connect_swapped (toolbar->prev, "clicked", G_CALLBACK (ephy_find_toolbar_find_previous), toolbar); gtk_search_bar_connect_entry (GTK_SEARCH_BAR (toolbar), GTK_ENTRY (toolbar->entry)); search_entry_changed_cb (GTK_ENTRY (toolbar->entry), toolbar); gtk_widget_show_all (GTK_WIDGET (toolbar)); }
/* Create a page for the main notebook. */ static GtkWidget* create_toolbar_page(BalsaToolbarModel * model, GActionMap * map) { GtkWidget *outer_box; GtkWidget *toolbar_frame, *toolbar_scroll; GtkWidget *toolbar_ctlbox; GtkWidget *lower_ctlbox, *button_box, *move_button_box, *center_button_box; GtkWidget *list_frame, *list_scroll; GtkWidget *destination_frame, *destination_scroll; GtkWidget *style_button; ToolbarPage *page; GtkTreeSelection *selection; page = g_new(ToolbarPage, 1); page->model = model; /* The "window itself" */ outer_box=gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); g_object_set_data_full(G_OBJECT(outer_box), BALSA_KEY_TOOLBAR_PAGE, page, g_free); /* Preview display */ toolbar_frame=gtk_frame_new(_("Preview")); gtk_container_set_border_width(GTK_CONTAINER(toolbar_frame), 5); gtk_box_pack_start(GTK_BOX(outer_box), toolbar_frame, FALSE, FALSE, 0); toolbar_ctlbox=gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_add(GTK_CONTAINER(toolbar_frame), toolbar_ctlbox); gtk_container_set_border_width(GTK_CONTAINER(toolbar_ctlbox), 5); /* The preview is an actual, fully functional toolbar */ page->toolbar = balsa_toolbar_new(model, map); gtk_widget_set_sensitive(page->toolbar, FALSE); /* embedded in a scrolled_window */ toolbar_scroll=gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(toolbar_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER); gtk_box_pack_start(GTK_BOX(toolbar_ctlbox), toolbar_scroll, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(toolbar_scroll), page->toolbar); /* Button box */ button_box = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); gtk_box_set_spacing(GTK_BOX(button_box), 5); gtk_box_pack_start(GTK_BOX(toolbar_ctlbox), button_box, FALSE, FALSE, 0); /* Standard button */ page->standard_button = gtk_button_new_with_mnemonic(_("_Restore toolbar to standard buttons")); gtk_container_add(GTK_CONTAINER(button_box), page->standard_button); /* Style button */ style_button = gtk_button_new_with_mnemonic(_("Toolbar _style…")); gtk_container_add(GTK_CONTAINER(button_box), style_button); /* Done with preview */ /* Box for lower half of window */ lower_ctlbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_container_set_border_width(GTK_CONTAINER(lower_ctlbox), 5); gtk_box_pack_start(GTK_BOX(outer_box), lower_ctlbox, TRUE, TRUE, 0); /* A list to show the available items */ list_scroll=gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(list_scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); list_frame=gtk_frame_new(_("Available buttons")); page->available = tp_list_new(); gtk_box_pack_start(GTK_BOX(lower_ctlbox), list_frame, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(list_frame), list_scroll); gtk_container_add(GTK_CONTAINER(list_scroll), page->available); /* Done with available list */ /* Another list to show the current tools */ destination_scroll=gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(destination_scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); destination_frame=gtk_frame_new(_("Current toolbar")); page->current = tp_list_new(); /* Done with destination list */ /* Button box */ center_button_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_box_set_homogeneous(GTK_BOX(center_button_box), TRUE); button_box=gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start(GTK_BOX(lower_ctlbox), center_button_box, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(center_button_box), button_box, FALSE, FALSE, 0); page->back_button = gtk_button_new_from_icon_name("go-up-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_tooltip_text(page->back_button, _("Move selected item up")); gtk_box_pack_start(GTK_BOX(button_box), page->back_button, FALSE, FALSE, 0); move_button_box=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start(GTK_BOX(button_box), move_button_box, FALSE, FALSE, 0); page->remove_button = gtk_button_new_from_icon_name("go-previous-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_tooltip_text(page->remove_button, _("Remove selected item from toolbar")); gtk_box_pack_start(GTK_BOX(move_button_box), page->remove_button, FALSE, FALSE, 0); page->add_button = gtk_button_new_from_icon_name("go-next-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_tooltip_text(page->add_button, _("Add selected item to toolbar")); gtk_box_pack_start(GTK_BOX(move_button_box), page->add_button, FALSE, FALSE, 0); page->forward_button = gtk_button_new_from_icon_name("go-down-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_tooltip_text(page->forward_button, _("Move selected item down")); gtk_box_pack_start(GTK_BOX(button_box), page->forward_button, FALSE, FALSE, 0); /* Pack destination list */ gtk_box_pack_start(GTK_BOX(lower_ctlbox), destination_frame, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(destination_frame), destination_scroll); gtk_container_add(GTK_CONTAINER(destination_scroll), page->current); /* UI signals */ g_signal_connect(G_OBJECT(page->available), "row-activated", G_CALLBACK(available_row_activated_cb), page); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(page->available)); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(available_selection_changed_cb), page); g_signal_connect(G_OBJECT(page->current), "row-activated", G_CALLBACK(current_row_activated_cb), page); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(page->current)); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(current_selection_changed_cb), page); g_signal_connect(G_OBJECT(page->add_button), "clicked", G_CALLBACK(add_button_cb), page); g_signal_connect(G_OBJECT(page->remove_button), "clicked", G_CALLBACK(remove_button_cb), page); g_signal_connect(G_OBJECT(page->forward_button), "clicked", G_CALLBACK(forward_button_cb), page); g_signal_connect(G_OBJECT(page->back_button), "clicked", G_CALLBACK(back_button_cb), page); g_signal_connect(G_OBJECT(page->standard_button), "clicked", G_CALLBACK(standard_button_cb), page); g_signal_connect(G_OBJECT(style_button), "clicked", G_CALLBACK(style_button_cb), page); gtk_widget_set_sensitive(page->add_button, FALSE); gtk_widget_set_sensitive(page->remove_button, FALSE); gtk_widget_set_sensitive(page->back_button, FALSE); gtk_widget_set_sensitive(page->forward_button, FALSE); gtk_widget_set_sensitive(page->standard_button, !balsa_toolbar_model_is_standard(model)); #ifndef BALSA_TOOLBAR_DEBUG_ACTIONS tp_page_refresh_available(page); #else /* BALSA_TOOLBAR_DEBUG_ACTIONS */ tp_page_refresh_available(page, map); #endif /* BALSA_TOOLBAR_DEBUG_ACTIONS */ tp_page_refresh_current(page); return outer_box; }
static void GyahtzeeCreateMainWindow (GApplication *app, gpointer user_data) { GtkWidget *hbox, *vbox; GtkWidget *toolbar; GtkWidget *tmp; GtkWidget *dicebox; GtkWidget *undo_button; GtkWidget *menu_button; GtkWidget *icon; GtkBuilder *builder; GMenuModel *appmenu; int i, j; window = gtk_application_window_new (application); gtk_window_set_application (GTK_WINDOW (window), application); gtk_window_set_title (GTK_WINDOW (window), _(appName)); gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (window), FALSE); gtk_window_set_icon_name (GTK_WINDOW (window), "org.gnome.Tali"); //games_conf_add_window (GTK_WINDOW (window), NULL); g_signal_connect (GTK_WIDGET (window), "key_press_event", G_CALLBACK (key_press), NULL); g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application); const gchar *vaccels_help[] = {"F1", NULL}; const gchar *vaccels_new[] = {"<Primary>n", NULL}; const gchar *vaccels_roll[] = {"<Primary>r", NULL}; const gchar *vaccels_undo[] = {"<Primary>z", NULL}; gtk_application_set_accels_for_action (application, "app.help", vaccels_help); gtk_application_set_accels_for_action (application, "app.new-game", vaccels_new); gtk_application_set_accels_for_action (application, "app.roll", vaccels_roll); gtk_application_set_accels_for_action (application, "app.undo", vaccels_undo); scores_action = g_action_map_lookup_action (G_ACTION_MAP (application), "scores"); undo_action = g_action_map_lookup_action (G_ACTION_MAP (application), "undo"); update_undo_sensitivity (); /*--- Headerbar ---*/ hbar = gtk_header_bar_new (); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (hbar), TRUE); gtk_header_bar_set_title (GTK_HEADER_BAR (hbar), _(appName)); gtk_widget_show (hbar); gtk_window_set_titlebar (GTK_WINDOW (window), hbar); if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL) undo_button = gtk_button_new_from_icon_name ("edit-undo-rtl-symbolic", GTK_ICON_SIZE_BUTTON); else undo_button = gtk_button_new_from_icon_name ("edit-undo-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_valign (undo_button, GTK_ALIGN_CENTER); gtk_actionable_set_action_name (GTK_ACTIONABLE (undo_button), "app.undo"); gtk_widget_set_tooltip_text (undo_button, _("Undo your most recent move")); gtk_widget_show (undo_button); gtk_header_bar_pack_start (GTK_HEADER_BAR (hbar), undo_button); builder = gtk_builder_new_from_resource ("/org/gnome/Tali/ui/menus.ui"); appmenu = (GMenuModel *) gtk_builder_get_object (builder, "app-menu"); menu_button = gtk_menu_button_new(); icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (menu_button), icon); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), appmenu); gtk_widget_show (menu_button); gtk_header_bar_pack_end (GTK_HEADER_BAR (hbar), menu_button); /*---- Content ----*/ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); /* Retreive dice pixmaps from memory or files */ LoadDicePixmaps (); /* Put all the dice in a vertical column */ dicebox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start (GTK_BOX (hbox), dicebox, FALSE, TRUE, 0); gtk_widget_show (dicebox); rollLabel = gtk_label_new (NULL); gtk_label_set_use_markup (GTK_LABEL (rollLabel), TRUE); gtk_widget_show (rollLabel); gtk_box_pack_start (GTK_BOX (dicebox), rollLabel, FALSE, TRUE, 5); mbutton = gtk_button_new_with_label (_("Roll!")); gtk_box_pack_end (GTK_BOX (dicebox), mbutton, FALSE, FALSE, 5); g_signal_connect (GTK_BUTTON (mbutton), "clicked", G_CALLBACK (roll_button_pressed_cb), NULL); gtk_widget_show (GTK_WIDGET (mbutton)); toolbar = gtk_toolbar_new (); gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar), GTK_ORIENTATION_VERTICAL); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS); gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), FALSE); gtk_box_pack_end (GTK_BOX (dicebox), toolbar, TRUE, TRUE, 0); for (i = 0; i < NUMBER_OF_DICE; i++) { tmp = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); for (j = 0; j < NUMBER_OF_PIXMAPS; j++) { gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_YAHTZEE], FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_KISMET], FALSE, FALSE, 0); } diceBox[i] = gtk_toggle_tool_button_new (); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (diceBox[i]), tmp); g_signal_connect (GTK_TOOL_BUTTON (diceBox[i]), "clicked", G_CALLBACK (modify_dice), &DiceValues[i]); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (diceBox[i]), -1); gtk_widget_show (GTK_WIDGET (diceBox[i])); gtk_widget_show (tmp); /*gtk_widget_show (dicePixmaps[i][0][game_type]);*/ } gtk_widget_show (toolbar); /* Scores displayed in score list */ ScoreList = create_score_list (); gtk_box_pack_end (GTK_BOX (hbox), ScoreList, TRUE, TRUE, 0); setup_score_list (ScoreList); gtk_widget_show (ScoreList); gtk_widget_show (hbox); gtk_widget_show (vbox); }
static GtkWidget * create_listbox_row (gpointer item, gpointer user_data) { PpJob *job = (PpJob *)item; GtkWidget *box; GtkWidget *widget; gchar *title; gchar *state_string = NULL; gint job_state; g_object_get (job, "title", &title, "state", &job_state, NULL); switch (job_state) { case IPP_JOB_PENDING: /* Translators: Job's state (job is waiting to be printed) */ state_string = g_strdup (C_("print job", "Pending")); break; case IPP_JOB_HELD: /* Translators: Job's state (job is held for printing) */ state_string = g_strdup (C_("print job", "Paused")); break; case IPP_JOB_PROCESSING: /* Translators: Job's state (job is currently printing) */ state_string = g_strdup (C_("print job", "Processing")); break; case IPP_JOB_STOPPED: /* Translators: Job's state (job has been stopped) */ state_string = g_strdup (C_("print job", "Stopped")); break; case IPP_JOB_CANCELED: /* Translators: Job's state (job has been canceled) */ state_string = g_strdup (C_("print job", "Canceled")); break; case IPP_JOB_ABORTED: /* Translators: Job's state (job has aborted due to error) */ state_string = g_strdup (C_("print job", "Aborted")); break; case IPP_JOB_COMPLETED: /* Translators: Job's state (job has completed successfully) */ state_string = g_strdup (C_("print job", "Completed")); break; } box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); g_object_set (box, "margin", 6, NULL); gtk_container_set_border_width (GTK_CONTAINER (box), 2); widget = gtk_label_new (title); gtk_widget_set_halign (widget, GTK_ALIGN_START); gtk_box_pack_start (GTK_BOX (box), widget, TRUE, TRUE, 10); widget = gtk_label_new (state_string); gtk_widget_set_halign (widget, GTK_ALIGN_END); gtk_widget_set_margin_end (widget, 64); gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 10); widget = gtk_button_new_from_icon_name (job_state == IPP_JOB_HELD ? "media-playback-start-symbolic" : "media-playback-pause-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR); g_signal_connect (widget, "clicked", G_CALLBACK (job_pause_cb), item); gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 4); widget = gtk_button_new_from_icon_name ("edit-delete-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR); g_signal_connect (widget, "clicked", G_CALLBACK (job_stop_cb), item); gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 4); gtk_widget_show_all (box); return box; }