static void add_dns_row (CEPageIP6 *page, const gchar *address) { GtkWidget *row; GtkWidget *row_box; GtkWidget *label; GtkWidget *widget; GtkWidget *delete_button; GtkWidget *image; row = gtk_list_box_row_new (); gtk_widget_set_can_focus (row, FALSE); row_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); label = gtk_label_new (_("Server")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_box_pack_start (GTK_BOX (row_box), label, FALSE, FALSE, 0); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "address", widget); gtk_entry_set_text (GTK_ENTRY (widget), address); gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_box_pack_start (GTK_BOX (row_box), widget, TRUE, TRUE, 0); delete_button = gtk_button_new (); gtk_style_context_add_class (gtk_widget_get_style_context (delete_button), "image-button"); g_signal_connect (delete_button, "clicked", G_CALLBACK (remove_row), page); image = gtk_image_new_from_icon_name ("user-trash-symbolic", GTK_ICON_SIZE_MENU); atk_object_set_name (gtk_widget_get_accessible (delete_button), _("Delete DNS Server")); gtk_button_set_image (GTK_BUTTON (delete_button), image); gtk_box_pack_start (GTK_BOX (row_box), delete_button, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (row), "delete-button", delete_button); gtk_widget_set_margin_left (row_box, 10); gtk_widget_set_margin_right (row_box, 10); gtk_widget_set_margin_top (row_box, 10); gtk_widget_set_margin_bottom (row_box, 10); gtk_widget_set_halign (row_box, GTK_ALIGN_FILL); gtk_container_add (GTK_CONTAINER (row), row_box); gtk_widget_show_all (row); gtk_container_add (GTK_CONTAINER (page->dns_list), row); update_row_sensitivity (page, page->dns_list); }
static void ido_source_menu_item_constructed (GObject *object) { IdoSourceMenuItem *item = IDO_SOURCE_MENU_ITEM (object); GtkWidget *grid; gint icon_width; gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &icon_width, NULL); item->icon = g_object_ref (gtk_image_new ()); gtk_widget_set_margin_left (item->icon, icon_width); gtk_widget_set_margin_right (item->icon, 6); item->label = g_object_ref (gtk_label_new ("")); gtk_label_set_max_width_chars (GTK_LABEL (item->label), 40); gtk_label_set_ellipsize (GTK_LABEL (item->label), PANGO_ELLIPSIZE_END); gtk_misc_set_alignment (GTK_MISC (item->label), 0.0, 0.5); item->detail = g_object_ref (ido_detail_label_new ("")); gtk_widget_set_halign (item->detail, GTK_ALIGN_END); gtk_widget_set_hexpand (item->detail, TRUE); gtk_style_context_add_class (gtk_widget_get_style_context (item->detail), "accelerator"); grid = gtk_grid_new (); gtk_grid_attach (GTK_GRID (grid), item->icon, 0, 0, 1, 1); gtk_grid_attach (GTK_GRID (grid), item->label, 1, 0, 1, 1); gtk_grid_attach (GTK_GRID (grid), item->detail, 2, 0, 1, 1); gtk_container_add (GTK_CONTAINER (object), grid); gtk_widget_show_all (grid); G_OBJECT_CLASS (ido_source_menu_item_parent_class)->constructed (object); }
static void gcr_viewer_window_constructed (GObject *obj) { GcrViewerWindow *self = GCR_VIEWER_WINDOW (obj); GtkWidget *bbox; GtkWidget *box; GtkWidget *button; G_OBJECT_CLASS (gcr_viewer_window_parent_class)->constructed (obj); bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_set_spacing (GTK_BOX (bbox), 12); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END); gtk_widget_show (bbox); self->pv->import = gcr_import_button_new (_("Import")); g_signal_connect_object (self->pv->import, "importing", G_CALLBACK (on_import_button_importing), self, 0); g_signal_connect_object (self->pv->import, "imported", G_CALLBACK (on_import_button_imported), self, 0); gtk_widget_show (GTK_WIDGET (self->pv->import)); button = gtk_button_new_with_mnemonic (_("_Close")); g_signal_connect_object (button, "clicked", G_CALLBACK (on_close_clicked), self, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (bbox), GTK_WIDGET (self->pv->import), FALSE, TRUE, 0); gtk_widget_set_halign (bbox, 0.5); gtk_widget_set_valign (bbox, 0.5); #if GTK_CHECK_VERSION (3, 12, 0) gtk_widget_set_margin_end (bbox, 12); #else gtk_widget_set_margin_right (bbox, 12); #endif self->pv->viewer = gcr_viewer_widget_new (); g_object_bind_property (self->pv->viewer, "display-name", self, "title", G_BINDING_SYNC_CREATE); g_signal_connect_object (self->pv->viewer, "added", G_CALLBACK (on_viewer_renderer_added), self, 0); gtk_widget_show (GTK_WIDGET (self->pv->viewer)); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (box); gtk_box_pack_start (GTK_BOX (box), GTK_WIDGET (self->pv->viewer), TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box), bbox, FALSE, FALSE, 6); gtk_container_add (GTK_CONTAINER (self), box); gtk_window_set_default_size (GTK_WINDOW (self), 250, 400); }
static void set_row_widget_margins (GtkWidget *widget) { gtk_widget_set_margin_left (widget, 20); gtk_widget_set_margin_right (widget, 20); gtk_widget_set_margin_top (widget, 6); gtk_widget_set_margin_bottom (widget, 6); }
static void gtk_technology_init(GtkTechnology *technology) { GtkTechnologyPrivate *priv; priv = G_TYPE_INSTANCE_GET_PRIVATE(technology, GTK_TYPE_TECHNOLOGY, GtkTechnologyPrivate); technology->priv = priv; priv->box = (GtkBox *) gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); priv->enabler = (GtkSwitch *) gtk_switch_new(); priv->name = (GtkLabel *) gtk_label_new(NULL); gtk_widget_set_margin_left((GtkWidget *)priv->enabler, 0); gtk_widget_set_margin_right((GtkWidget *)priv->enabler, 0); gtk_widget_set_margin_top((GtkWidget *)priv->enabler, 0); gtk_widget_set_margin_bottom((GtkWidget *)priv->enabler, 0); gtk_widget_set_margin_left((GtkWidget *)priv->name, 0); gtk_widget_set_margin_right((GtkWidget *)priv->name, 0); gtk_widget_set_margin_top((GtkWidget *)priv->name, 0); gtk_widget_set_margin_bottom((GtkWidget *)priv->name, 0); gtk_box_set_spacing(priv->box, 0); gtk_box_set_homogeneous(priv->box, TRUE); //gtk_widget_set_halign((GtkWidget *)priv->box, GTK_ALIGN_START); gtk_widget_set_halign((GtkWidget *)priv->name, GTK_ALIGN_START); //gtk_widget_set_halign((GtkWidget *)technology, GTK_ALIGN_START); gtk_box_pack_start(priv->box, (GtkWidget *)priv->enabler, FALSE, FALSE, 0); gtk_box_pack_start(priv->box, (GtkWidget *)priv->name, FALSE, FALSE, 0); gtk_widget_set_visible((GtkWidget *)priv->box, TRUE); gtk_widget_set_visible((GtkWidget *)priv->enabler, TRUE); gtk_widget_set_visible((GtkWidget *)priv->name, TRUE); gtk_container_add(GTK_CONTAINER(technology), (GtkWidget *)priv->box); gtk_widget_set_can_focus((GtkWidget *)priv->box, TRUE); gtk_widget_set_can_focus((GtkWidget *)priv->enabler, TRUE); }
static void ido_media_player_menu_item_init (IdoMediaPlayerMenuItem *self) { GtkWidget *grid; self->cancellable = g_cancellable_new (); self->player_icon = gtk_image_new(); gtk_widget_set_margin_right (self->player_icon, 6); gtk_widget_set_halign (self->player_icon, GTK_ALIGN_START); self->player_label = gtk_label_new (NULL); gtk_widget_set_halign (self->player_label, GTK_ALIGN_START); gtk_widget_set_hexpand (self->player_label, TRUE); self->album_art = gtk_image_new(); gtk_widget_set_size_request (self->album_art, ALBUM_ART_SIZE, ALBUM_ART_SIZE); gtk_widget_set_margin_right (self->album_art, 8); self->artist_label = track_info_label_new (); self->piece_label = track_info_label_new (); self->container_label = track_info_label_new (); gtk_widget_set_vexpand (self->container_label, TRUE); gtk_widget_set_valign (self->container_label, GTK_ALIGN_START); self->metadata_widget = gtk_grid_new (); gtk_grid_attach (GTK_GRID (self->metadata_widget), self->album_art, 0, 0, 1, 4); gtk_grid_attach (GTK_GRID (self->metadata_widget), self->piece_label, 1, 0, 1, 1); gtk_grid_attach (GTK_GRID (self->metadata_widget), self->artist_label, 1, 1, 1, 1); gtk_grid_attach (GTK_GRID (self->metadata_widget), self->container_label, 1, 2, 1, 1); grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 8); gtk_grid_attach (GTK_GRID (grid), self->player_icon, 0, 0, 1, 1); gtk_grid_attach (GTK_GRID (grid), self->player_label, 1, 0, 1, 1); gtk_grid_attach (GTK_GRID (grid), self->metadata_widget, 0, 1, 2, 1); gtk_container_add (GTK_CONTAINER (self), grid); gtk_widget_show_all (grid); /* hide metadata by defalut (player is not running) */ gtk_widget_hide (self->metadata_widget); }
void style_set_margin_end(GtkWidget *widget, gint margin) { #if (GTK_MAJOR_VERSION > 3) || (GTK_MINOR_VERSION >= 12) gtk_widget_set_margin_end(widget, margin); #else if(gtk_widget_get_direction(widget) == GTK_TEXT_DIR_RTL) gtk_widget_set_margin_left(widget, margin); else gtk_widget_set_margin_right(widget, margin); #endif }
static void create_properties_widget () { pwidget = gtk_vbox_new (FALSE, 10); GtkWidget *finish_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL(finish_label), "<b>When Finished:</b>"); GtkWidget *buttonbox = gtk_hbutton_box_new (); open = gtk_check_button_new_with_label ("Open File"); notify = gtk_check_button_new_with_label ("Show Notification"); open_location = gtk_check_button_new_with_label ("Open Location"); gtk_box_pack_start (GTK_BOX(buttonbox), notify, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(buttonbox), open, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(buttonbox), open_location, FALSE, FALSE, 0); GtkWidget *comment_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL(comment_label), "<b>Comment:</b>"); GtkWidget *text_view = gtk_text_view_new (); comment = gtk_text_view_get_buffer (GTK_TEXT_VIEW(text_view)); gtk_widget_set_size_request (text_view, -1, 60); gtk_text_view_set_left_margin (GTK_TEXT_VIEW(text_view), 10); gtk_text_view_set_right_margin (GTK_TEXT_VIEW(text_view), 10); gtk_box_pack_start (GTK_BOX(pwidget), finish_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(pwidget), buttonbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(pwidget), comment_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(pwidget), text_view, FALSE, FALSE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX(buttonbox), GTK_BUTTONBOX_START); gtk_misc_set_alignment (GTK_MISC(finish_label), 0.0, 0.5); gtk_misc_set_alignment (GTK_MISC(comment_label), 0.0, 0.5); gtk_widget_set_margin_left (pwidget, 15); gtk_widget_set_margin_left (buttonbox, 15); gtk_widget_set_margin_left (text_view, 15); gtk_widget_set_margin_right (text_view, 20); gtk_widget_set_margin_top (pwidget, 15); g_signal_connect (notify, "toggled", G_CALLBACK (on_toggle), GINT_TO_POINTER (G_DOWNLOADABLE_FINISH_ACTION_NOTIFY)); g_signal_connect (open, "toggled", G_CALLBACK (on_toggle), GINT_TO_POINTER (G_DOWNLOADABLE_FINISH_ACTION_OPEN)); g_signal_connect (open_location, "toggled", G_CALLBACK (on_toggle), GINT_TO_POINTER (G_DOWNLOADABLE_FINISH_ACTION_OPEN_LOCATION)); g_signal_connect (text_view, "focus-out-event", G_CALLBACK (on_comment_save), NULL); gtk_widget_show_all (pwidget); }
static void eog_statusbar_init (EogStatusbar *statusbar) { EogStatusbarPrivate *priv; GtkWidget *vbox; statusbar->priv = EOG_STATUSBAR_GET_PRIVATE (statusbar); priv = statusbar->priv; priv->img_num_label = gtk_label_new (NULL); gtk_widget_set_size_request (priv->img_num_label, 100, 10); gtk_widget_show (priv->img_num_label); gtk_box_pack_end (GTK_BOX (statusbar), priv->img_num_label, FALSE, TRUE, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_end (GTK_BOX (statusbar), vbox, FALSE, FALSE, 2); statusbar->priv->progressbar = gtk_progress_bar_new (); gtk_box_pack_end (GTK_BOX (vbox), priv->progressbar, TRUE, TRUE, 0); /* Set margins by hand to avoid causing redraws due to the statusbar * becoming too small for the progressbar */ gtk_widget_set_margin_left (priv->progressbar, 2); gtk_widget_set_margin_right (priv->progressbar, 2); gtk_widget_set_margin_top (priv->progressbar, 1); gtk_widget_set_margin_bottom (priv->progressbar, 1); gtk_widget_set_size_request (priv->progressbar, -1, 10); gtk_widget_show (vbox); gtk_widget_hide (statusbar->priv->progressbar); }
static GtkWidget * padded_label_new (char *text, gboolean narrow) { GtkWidget *widget; widget = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10); gtk_widget_set_halign (widget, GTK_ALIGN_CENTER); gtk_widget_set_margin_top (widget, 10); gtk_widget_set_margin_bottom (widget, 10); gtk_widget_set_margin_left (widget, narrow ? 10 : 80); gtk_widget_set_margin_right (widget, narrow ? 10 : 80); gtk_box_pack_start (GTK_BOX (widget), gtk_label_new (text), FALSE, FALSE, 0); return widget; }
static void add_application (CcNotificationsPanel *panel, Application *app) { GtkWidget *box, *w; GIcon *icon; icon = g_app_info_get_icon (app->app_info); if (icon == NULL) icon = g_themed_icon_new ("application-x-executable"); else g_object_ref (icon); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); g_object_set_qdata_full (G_OBJECT (box), application_quark (), app, (GDestroyNotify) application_free); gtk_container_add (GTK_CONTAINER (panel->list_box), box); w = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG); gtk_widget_set_margin_left (w, 12); gtk_container_add (GTK_CONTAINER (box), w); g_object_unref (icon); w = gtk_label_new (g_app_info_get_name (app->app_info)); gtk_container_add (GTK_CONTAINER (box), w); w = gtk_label_new (""); g_settings_bind_with_mapping (app->settings, "enable", w, "label", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_NO_SENSITIVITY, on_off_label_mapping_get, NULL, NULL, NULL); gtk_widget_set_margin_right (w, 12); gtk_widget_set_valign (w, GTK_ALIGN_CENTER); gtk_box_pack_end (GTK_BOX (box), w, FALSE, FALSE, 0); gtk_widget_show_all (box); g_hash_table_add (panel->known_applications, g_strdup (app->canonical_app_id)); }
static void setup_model (GnomeControlCenter *shell) { GnomeControlCenterPrivate *priv = shell->priv; gtk_widget_set_margin_top (shell->priv->main_vbox, 8); gtk_widget_set_margin_bottom (shell->priv->main_vbox, 8); gtk_widget_set_margin_left (shell->priv->main_vbox, 12); gtk_widget_set_margin_right (shell->priv->main_vbox, 12); gtk_container_set_focus_vadjustment (GTK_CONTAINER (shell->priv->main_vbox), gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (shell->priv->scrolled_window))); priv->store = (GtkListStore *) cc_shell_model_new (); priv->category_views = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); priv->menu_tree = gmenu_tree_new_for_path (MENUDIR "/gnomecc.menu", 0); reload_menu (shell); g_signal_connect (priv->menu_tree, "changed", G_CALLBACK (on_menu_changed), shell); }
static void main_window_real_size_allocate (GtkWidget* base, GtkAllocation* allocation) { MainWindow * self; GtkAllocation _tmp0_; GtkBox* _tmp1_; self = (MainWindow*) base; g_return_if_fail (allocation != NULL); _tmp0_ = *allocation; GTK_WIDGET_CLASS (main_window_parent_class)->size_allocate ((GtkWidget*) G_TYPE_CHECK_INSTANCE_CAST (self, GTK_TYPE_WINDOW, GtkWindow), &_tmp0_); _tmp1_ = self->priv->hbox; if (_tmp1_ != NULL) { GtkBox* _tmp2_; gint _tmp3_ = 0; gint _tmp4_ = 0; GtkBox* _tmp5_; gint _tmp6_ = 0; gint _tmp7_ = 0; GtkBox* _tmp8_; gint _tmp9_ = 0; gint _tmp10_ = 0; GtkBox* _tmp11_; gint _tmp12_ = 0; gint _tmp13_ = 0; _tmp2_ = self->priv->hbox; _tmp3_ = gtk_widget_get_allocated_width ((GtkWidget*) self); _tmp4_ = get_grid_offset (_tmp3_); gtk_widget_set_margin_left ((GtkWidget*) _tmp2_, _tmp4_ + grid_size); _tmp5_ = self->priv->hbox; _tmp6_ = gtk_widget_get_allocated_width ((GtkWidget*) self); _tmp7_ = get_grid_offset (_tmp6_); gtk_widget_set_margin_right ((GtkWidget*) _tmp5_, _tmp7_); _tmp8_ = self->priv->hbox; _tmp9_ = gtk_widget_get_allocated_height ((GtkWidget*) self); _tmp10_ = get_grid_offset (_tmp9_); gtk_widget_set_margin_top ((GtkWidget*) _tmp8_, _tmp10_); _tmp11_ = self->priv->hbox; _tmp12_ = gtk_widget_get_allocated_height ((GtkWidget*) self); _tmp13_ = get_grid_offset (_tmp12_); gtk_widget_set_margin_bottom ((GtkWidget*) _tmp11_, _tmp13_); } }
static void update_image_preview(void *filechooser, void *image) { #define MAX_PREVIEW_SIZE 256 char *filename = gtk_file_chooser_get_preview_filename(filechooser); if (!filename) return; // load preview void *pixbuf = gdk_pixbuf_new_from_file(filename, NULL); if (!pixbuf) { g_free_utox(filename); gtk_file_chooser_set_preview_widget_active(filechooser, false); return; } // if preview too big load smaller if (gdk_pixbuf_get_width(pixbuf) > MAX_PREVIEW_SIZE || gdk_pixbuf_get_height(pixbuf) > MAX_PREVIEW_SIZE) { g_object_unref(pixbuf); pixbuf = gdk_pixbuf_new_from_file_at_size(filename, MAX_PREVIEW_SIZE, MAX_PREVIEW_SIZE, NULL); } g_free_utox(filename); if (!pixbuf) { gtk_file_chooser_set_preview_widget_active(filechooser, false); return; } // pad to MAX_PREVIEW_SIZE + 3px margins int margin = (MAX_PREVIEW_SIZE + 6 - gdk_pixbuf_get_width(pixbuf)) / 2; gtk_widget_set_margin_left(image, margin); gtk_widget_set_margin_right(image, margin); // set preview gtk_image_set_from_pixbuf(image, pixbuf); g_object_unref(pixbuf); gtk_file_chooser_set_preview_widget_active(filechooser, true); }
static void nemo_toolbar_constructed (GObject *obj) { NemoToolbar *self = NEMO_TOOLBAR (obj); GtkWidget *toolbar; GtkWidget *hbox; GtkToolItem *tool_box; GtkWidget *box; GtkStyleContext *context; G_OBJECT_CLASS (nemo_toolbar_parent_class)->constructed (obj); gtk_style_context_set_junction_sides (gtk_widget_get_style_context (GTK_WIDGET (self)), GTK_JUNCTION_BOTTOM); self->priv->show_location_entry = g_settings_get_boolean (nemo_preferences, NEMO_PREFERENCES_SHOW_LOCATION_ENTRY); /* add the UI */ self->priv->ui_manager = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (self->priv->ui_manager, self->priv->action_group, 0); toolbar = gtk_toolbar_new (); self->priv->toolbar = toolbar; gtk_box_pack_start (GTK_BOX (self), self->priv->toolbar, TRUE, TRUE, 0); context = gtk_widget_get_style_context (GTK_WIDGET(toolbar)); gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR); /* Back/Forward/Up */ self->priv->navigation_box = gtk_tool_item_new (); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); self->priv->previous_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_BACK); gtk_container_add (GTK_CONTAINER (box), self->priv->previous_button); self->priv->next_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_FORWARD); gtk_container_add (GTK_CONTAINER (box), self->priv->next_button); self->priv->up_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_UP); gtk_container_add (GTK_CONTAINER (box), self->priv->up_button); 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 (self->priv->navigation_box), GTK_WIDGET (box)); gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->navigation_box)); gtk_widget_show_all (GTK_WIDGET (self->priv->navigation_box)); gtk_widget_set_margin_right (GTK_WIDGET (self->priv->navigation_box), 6); /* Refresh */ self->priv->refresh_box = gtk_tool_item_new (); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); self->priv->refresh_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_RELOAD); gtk_container_add (GTK_CONTAINER (box), self->priv->refresh_button); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED); gtk_container_add (GTK_CONTAINER (self->priv->refresh_box), GTK_WIDGET (box)); gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->refresh_box)); gtk_widget_show_all (GTK_WIDGET (self->priv->refresh_box)); gtk_widget_set_margin_right (GTK_WIDGET (self->priv->refresh_box), 6); /* Home/Computer */ self->priv->location_box = gtk_tool_item_new (); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); self->priv->home_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_HOME); gtk_container_add (GTK_CONTAINER (box), self->priv->home_button); self->priv->computer_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_COMPUTER); gtk_container_add (GTK_CONTAINER (box), self->priv->computer_button); 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 (self->priv->location_box), GTK_WIDGET (box)); gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->location_box)); gtk_widget_show_all (GTK_WIDGET (self->priv->location_box)); gtk_widget_set_margin_right (GTK_WIDGET (self->priv->location_box), 6); /* Container to hold the location and pathbars */ self->priv->stack = gtk_stack_new(); gtk_stack_set_transition_type (GTK_STACK (self->priv->stack), GTK_STACK_TRANSITION_TYPE_CROSSFADE); gtk_stack_set_transition_duration (GTK_STACK (self->priv->stack), 150); /* Regular Path Bar */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (self->priv->stack), TRUE, TRUE, 0); self->priv->path_bar = g_object_new (NEMO_TYPE_PATH_BAR, NULL); gtk_stack_add_named(GTK_STACK (self->priv->stack), GTK_WIDGET (self->priv->path_bar), "path_bar"); /* Entry-Like Location Bar */ self->priv->location_bar = nemo_location_bar_new (); gtk_stack_add_named(GTK_STACK (self->priv->stack), GTK_WIDGET (self->priv->location_bar), "location_bar"); gtk_widget_show_all (hbox); tool_box = gtk_tool_item_new (); gtk_tool_item_set_expand (tool_box, TRUE); gtk_container_add (GTK_CONTAINER (tool_box), hbox); gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (tool_box)); gtk_widget_show (GTK_WIDGET (tool_box)); /* Search/Open in Terminal/New Folder/Toggle Location */ self->priv->tools_box = gtk_tool_item_new (); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); self->priv->toggle_location_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_TOGGLE_LOCATION); gtk_container_add (GTK_CONTAINER (box), self->priv->toggle_location_button); self->priv->open_terminal_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_OPEN_IN_TERMINAL); gtk_container_add (GTK_CONTAINER (box), self->priv->open_terminal_button); self->priv->new_folder_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_NEW_FOLDER); gtk_container_add (GTK_CONTAINER (box), self->priv->new_folder_button); self->priv->search_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_SEARCH); gtk_container_add (GTK_CONTAINER (box), self->priv->search_button); 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 (self->priv->tools_box), GTK_WIDGET (box)); gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->tools_box)); gtk_widget_show_all (GTK_WIDGET (self->priv->tools_box)); gtk_widget_set_margin_left (GTK_WIDGET (self->priv->tools_box), 6); setup_root_info_bar (self); /* View Select */ self->priv->view_box = gtk_tool_item_new (); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); self->priv->icon_view_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_ICON_VIEW); gtk_container_add (GTK_CONTAINER (box), self->priv->icon_view_button); self->priv->list_view_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_LIST_VIEW); gtk_container_add (GTK_CONTAINER (box), self->priv->list_view_button); self->priv->compact_view_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_COMPACT_VIEW); gtk_container_add (GTK_CONTAINER (box), self->priv->compact_view_button); 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 (self->priv->view_box), GTK_WIDGET (box)); gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->view_box)); gtk_widget_show_all (GTK_WIDGET (self->priv->view_box)); gtk_widget_set_margin_left (GTK_WIDGET (self->priv->view_box), 6); /* nemo patch */ g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_PREVIOUS_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_NEXT_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_UP_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_EDIT_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_RELOAD_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_HOME_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_COMPUTER_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_SEARCH_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_NEW_FOLDER_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_OPEN_IN_TERMINAL_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_ICON_VIEW_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_LIST_VIEW_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_COMPACT_VIEW_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); toolbar_update_appearance (self); }
static NimfSettingsPage * nimf_settings_page_new (NimfSettings *nsettings, const gchar *schema_id) { NimfSettingsPage *page; GSettingsSchema *schema; GList *key_list = NULL; gchar **keys; GList *l; gint i; page = g_slice_new0 (NimfSettingsPage); page->gsettings = g_settings_new (schema_id); page->label = nimf_settings_page_build_label (page, schema_id); page->box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 15); page->page_keys = g_ptr_array_new_with_free_func ((GDestroyNotify) nimf_settings_page_key_free); #if GTK_CHECK_VERSION (3, 12, 0) gtk_widget_set_margin_start (page->box, 15); gtk_widget_set_margin_end (page->box, 15); #else gtk_widget_set_margin_left (page->box, 15); gtk_widget_set_margin_right (page->box, 15); #endif gtk_widget_set_margin_top (page->box, 15); gtk_widget_set_margin_bottom (page->box, 15); schema = g_settings_schema_source_lookup (nsettings->schema_source, schema_id, TRUE); #if GLIB_CHECK_VERSION (2, 46, 0) keys = g_settings_schema_list_keys (schema); #else keys = g_settings_list_keys (page->gsettings); #endif for (i = 0; keys[i] != NULL; i++) key_list = g_list_prepend (key_list, keys[i]); key_list = g_list_sort (key_list, (GCompareFunc) on_comparison); for (i = 0, l = key_list; l != NULL; l = l->next, i++) { GVariant *variant; GSettingsSchemaKey *schema_key = NULL; NimfSettingsPageKey *page_key; const GVariantType *type; const gchar *key; const gchar *summary; const gchar *desc; key = l->data; if (g_str_has_prefix (key, "hidden-")) continue; variant = g_settings_get_value (page->gsettings, key); type = g_variant_get_type (variant); schema_key = g_settings_schema_get_key (schema, key); summary = g_settings_schema_key_get_summary (schema_key); desc = g_settings_schema_key_get_description (schema_key); page_key = nimf_settings_page_key_new (page->gsettings, key, summary, desc); g_ptr_array_add (page->page_keys, page_key); if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN)) { GtkWidget *item; item = nimf_settings_page_key_build_boolean (page_key); gtk_box_pack_start (GTK_BOX (page->box), item, FALSE, FALSE, 0); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING)) { GtkWidget *item; item = nimf_settings_page_key_build_string (page_key, schema_id, key_list); gtk_box_pack_start (GTK_BOX (page->box), item, FALSE, FALSE, 0); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING_ARRAY)) { GtkWidget *item; item = nimf_settings_page_key_build_string_array (page_key); gtk_box_pack_start (GTK_BOX (page->box), item, FALSE, FALSE, 0); } else g_error (G_STRLOC ": %s: not supported variant type: \"%s\"", G_STRFUNC, (gchar *) type); g_settings_schema_key_unref (schema_key); g_variant_unref (variant); } g_strfreev (keys); g_list_free (key_list); g_settings_schema_unref (schema); return page; }
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; }
static void add_route_row (CEPageIP6 *page, const gchar *address, gint prefix, const gchar *gateway, gint metric) { GtkWidget *row; GtkWidget *row_grid; GtkWidget *label; GtkWidget *widget; GtkWidget *delete_button; GtkWidget *image; row = gtk_list_box_row_new (); row_grid = gtk_grid_new (); label = gtk_label_new (_("Address")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 1, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "address", widget); gtk_entry_set_text (GTK_ENTRY (widget), address); gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 1, 1, 1); label = gtk_label_new (_("Prefix")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 2, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "prefix", widget); if (prefix > 0) { gchar *s = g_strdup_printf ("%d", prefix); gtk_entry_set_text (GTK_ENTRY (widget), s); g_free (s); } gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 2, 1, 1); label = gtk_label_new (_("Gateway")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 3, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "gateway", widget); gtk_entry_set_text (GTK_ENTRY (widget), gateway); gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 3, 1, 1); /* Translators: Please see https://en.wikipedia.org/wiki/Metrics_(networking) */ label = gtk_label_new (C_("network parameters", "Metric")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 4, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "metric", widget); if (metric > 0) { gchar *s = g_strdup_printf ("%d", metric); gtk_entry_set_text (GTK_ENTRY (widget), s); g_free (s); } gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 4, 1, 1); delete_button = gtk_button_new (); gtk_style_context_add_class (gtk_widget_get_style_context (delete_button), "image-button"); g_signal_connect (delete_button, "clicked", G_CALLBACK (remove_row), page); image = gtk_image_new_from_icon_name ("user-trash-symbolic", GTK_ICON_SIZE_MENU); atk_object_set_name (gtk_widget_get_accessible (delete_button), _("Delete Route")); gtk_button_set_image (GTK_BUTTON (delete_button), image); gtk_widget_set_halign (delete_button, GTK_ALIGN_CENTER); gtk_widget_set_valign (delete_button, GTK_ALIGN_CENTER); gtk_grid_attach (GTK_GRID (row_grid), delete_button, 3, 1, 1, 4); g_object_set_data (G_OBJECT (row), "delete-button", delete_button); gtk_grid_set_row_spacing (GTK_GRID (row_grid), 10); gtk_widget_set_margin_left (row_grid, 10); gtk_widget_set_margin_right (row_grid, 10); gtk_widget_set_margin_top (row_grid, 10); gtk_widget_set_margin_bottom (row_grid, 10); gtk_widget_set_halign (row_grid, GTK_ALIGN_FILL); gtk_container_add (GTK_CONTAINER (row), row_grid); gtk_widget_show_all (row); gtk_container_add (GTK_CONTAINER (page->routes_list), row); update_row_sensitivity (page, page->routes_list); }
static void add_device_secondary (CcPowerPanel *panel, GVariant *device, guint *secondary_devices_cnt) { CcPowerPanelPrivate *priv = panel->priv; const gchar *icon_name = NULL; gdouble percentage; guint64 time; UpDeviceKind kind; UpDeviceState state; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *widget; GString *status; GString *description; gboolean show_caution = FALSE; g_variant_get (device, "(susdut)", NULL, &kind, NULL, &percentage, &state, &time); switch (kind) { case UP_DEVICE_KIND_UPS: icon_name = "uninterruptible-power-supply"; show_caution = TRUE; break; case UP_DEVICE_KIND_MOUSE: icon_name = "input-mouse"; break; case UP_DEVICE_KIND_KEYBOARD: icon_name = "input-keyboard"; break; case UP_DEVICE_KIND_TABLET: icon_name = "input-tablet"; break; case UP_DEVICE_KIND_PDA: icon_name = "pda"; break; case UP_DEVICE_KIND_PHONE: icon_name = "phone"; break; case UP_DEVICE_KIND_MEDIA_PLAYER: icon_name = "multimedia-player"; break; case UP_DEVICE_KIND_COMPUTER: icon_name = "computer"; show_caution = TRUE; break; default: icon_name = "battery"; break; } switch (kind) { case UP_DEVICE_KIND_MOUSE: /* TRANSLATORS: secondary battery */ description = g_string_new (_("Wireless mouse")); break; case UP_DEVICE_KIND_KEYBOARD: /* TRANSLATORS: secondary battery */ description = g_string_new (_("Wireless keyboard")); break; case UP_DEVICE_KIND_UPS: /* TRANSLATORS: secondary battery */ description = g_string_new (_("Uninterruptible power supply")); break; case UP_DEVICE_KIND_PDA: /* TRANSLATORS: secondary battery */ description = g_string_new (_("Personal digital assistant")); break; case UP_DEVICE_KIND_PHONE: /* TRANSLATORS: secondary battery */ description = g_string_new (_("Cellphone")); break; case UP_DEVICE_KIND_MEDIA_PLAYER: /* TRANSLATORS: secondary battery */ description = g_string_new (_("Media player")); break; case UP_DEVICE_KIND_TABLET: /* TRANSLATORS: secondary battery */ description = g_string_new (_("Tablet")); break; case UP_DEVICE_KIND_COMPUTER: /* TRANSLATORS: secondary battery */ description = g_string_new (_("Computer")); break; default: /* TRANSLATORS: secondary battery, misc */ description = g_string_new (_("Battery")); break; } g_string_prepend (description, "<b>"); g_string_append (description, "</b>"); switch (state) { case UP_DEVICE_STATE_CHARGING: case UP_DEVICE_STATE_PENDING_CHARGE: /* TRANSLATORS: secondary battery */ status = g_string_new(C_("Battery power", "Charging")); break; case UP_DEVICE_STATE_DISCHARGING: case UP_DEVICE_STATE_PENDING_DISCHARGE: if (percentage < 10 && show_caution) { /* TRANSLATORS: secondary battery */ status = g_string_new (C_("Battery power", "Caution")); } else if (percentage < 30) { /* TRANSLATORS: secondary battery */ status = g_string_new (C_("Battery power", "Low")); } else { /* TRANSLATORS: secondary battery */ status = g_string_new (C_("Battery power", "Good")); } break; case UP_DEVICE_STATE_FULLY_CHARGED: /* TRANSLATORS: primary battery */ status = g_string_new(C_("Battery power", "Charging - fully charged")); break; case UP_DEVICE_STATE_EMPTY: /* TRANSLATORS: primary battery */ status = g_string_new(C_("Battery power", "Empty")); break; default: status = g_string_new (up_device_state_to_string (state)); break; } g_string_prepend (status, "<small>"); g_string_append (status, "</small>"); /* create the new widget */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_widget_set_hexpand (hbox, TRUE); widget = gtk_image_new (); gtk_misc_set_alignment (GTK_MISC (widget), 0.5f, 0.0f); gtk_image_set_from_icon_name (GTK_IMAGE (widget), icon_name, GTK_ICON_SIZE_DND); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); widget = gtk_label_new (""); gtk_misc_set_alignment (GTK_MISC (widget), 0.0f, 0.5f); gtk_label_set_markup (GTK_LABEL (widget), description->str); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); widget = gtk_label_new (""); gtk_misc_set_alignment (GTK_MISC (widget), 0.0f, 0.5f); gtk_label_set_markup (GTK_LABEL (widget), status->str); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); widget = gtk_progress_bar_new (); gtk_widget_set_margin_right (widget, 32); gtk_widget_set_margin_top (widget, 3); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (widget), percentage / 100.0f); gtk_box_pack_start (GTK_BOX (vbox), widget, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); /* add to the grid */ widget = WID ("grid_secondary"); /* two devices wide */ gtk_grid_attach (GTK_GRID (widget), hbox, *secondary_devices_cnt % 2, (*secondary_devices_cnt / 2) - 1, 1, 1); (*secondary_devices_cnt)++; /* show panel */ widget = WID ("box_secondary"); gtk_widget_show_all (widget); g_string_free (description, TRUE); g_string_free (status, TRUE); }
static void remmina_string_list_init(RemminaStringList *gsl) { GtkWidget *widget; GtkWidget *image; GtkWidget *scrolled_window; GtkWidget *vbox; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *frame; //gtk_table_resize(GTK_TABLE(gsl), 3, 2); /* Create the frame and add a new scrolled window, followed by the group list */ frame = gtk_frame_new(NULL); gtk_widget_show(frame); gtk_widget_set_hexpand(frame, TRUE); gtk_widget_set_vexpand(frame, TRUE); #if GTK_CHECK_VERSION(3, 12, 0) gtk_widget_set_margin_end (GTK_FRAME(frame), 80); #else gtk_widget_set_margin_right (GTK_FRAME(frame), 80); #endif gtk_grid_attach(GTK_GRID(gsl), frame, 0, 0, 1, 1); scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolled_window); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(frame), scrolled_window); gsl->store = gtk_list_store_new(NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING); gsl->list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(gsl->store)); gtk_widget_show(gsl->list); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(gsl->list), FALSE); gtk_container_add(GTK_CONTAINER(scrolled_window), gsl->list); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL); g_signal_connect(renderer, "edited", G_CALLBACK(remmina_string_list_cell_edited), gsl); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_TEXT, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(gsl->list), column); /* buttons packed into a vbox */ #if GTK_VERSION == 3 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #elif GTK_VERSION == 2 vbox = gtk_vbox_new(FALSE, 0); #endif gtk_widget_show(vbox); gtk_grid_attach(GTK_GRID(gsl), vbox, 1, 0, 2, 1); image = gtk_image_new_from_icon_name("list-add", GTK_ICON_SIZE_MENU); gtk_widget_show(image); widget = gtk_button_new(); gtk_widget_show(widget); gtk_container_add(GTK_CONTAINER(widget), image); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_string_list_add), gsl); image = gtk_image_new_from_icon_name("list-remove", GTK_ICON_SIZE_MENU); gtk_widget_show(image); widget = gtk_button_new(); gtk_widget_show(widget); gtk_container_add(GTK_CONTAINER(widget), image); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_string_list_remove), gsl); image = gtk_image_new_from_icon_name("go-up", GTK_ICON_SIZE_MENU); gtk_widget_show(image); widget = gtk_button_new(); gtk_widget_show(widget); gtk_container_add(GTK_CONTAINER(widget), image); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_string_list_up), gsl); gsl->up_button = widget; image = gtk_image_new_from_icon_name("go-down", GTK_ICON_SIZE_MENU); gtk_widget_show(image); widget = gtk_button_new(); gtk_widget_show(widget); gtk_container_add(GTK_CONTAINER(widget), image); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(remmina_string_list_down), gsl); gsl->down_button = widget; /* The last status label */ gsl->status_label = gtk_label_new(NULL); gtk_widget_show(gsl->status_label); gtk_misc_set_alignment(GTK_MISC(gsl->status_label), 0.0, 0.5); gtk_widget_set_hexpand(gsl->status_label, TRUE); gtk_grid_attach(GTK_GRID(gsl), gsl->status_label, 0, 2, 2, 1); gsl->hints = NULL; gsl->validation_func = NULL; }
static void patrol_dialog_window_constructed (GObject *obj) { G_OBJECT_CLASS(patrol_dialog_window_parent_class)->constructed(obj); PatrolDialogWindow *self = PATROL_DIALOG_WINDOW(obj); PatrolDialogWindowPrivate *pv = self->pv; gtk_window_set_title(GTK_WINDOW(self), _("Certificate Patrol")); gtk_window_set_default_size(GTK_WINDOW(self), 500, 700); //gtk_window_set_position(GTK_WINDOW(self), GTK_WIN_POS_MOUSE); /* content area */ GtkWidget *content = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_widget_set_margin_left(GTK_WIDGET(content), 10); gtk_widget_set_margin_right(GTK_WIDGET(content), 10); gtk_container_add(GTK_CONTAINER(self), content); /* messages */ GtkWidget *msgbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start(GTK_BOX(content), msgbox, FALSE, FALSE, 6); pv->icon = gtk_image_new(); gtk_box_pack_start(GTK_BOX(msgbox), pv->icon, FALSE, FALSE, 6); pv->msg = gtk_label_new(NULL); gtk_label_set_line_wrap(GTK_LABEL(pv->msg), TRUE); gtk_widget_set_halign(GTK_WIDGET(pv->msg), GTK_ALIGN_START); gtk_widget_set_margin_top(GTK_WIDGET(pv->msg), 25); gtk_box_pack_start(GTK_BOX(msgbox), pv->msg, FALSE, FALSE, 6); msgbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start(GTK_BOX(content), msgbox, FALSE, FALSE, 6); pv->chain_icon = gtk_image_new(); gtk_box_pack_start(GTK_BOX(msgbox), pv->chain_icon, FALSE, FALSE, 6); pv->chain_msg = gtk_label_new(NULL); gtk_widget_set_halign(GTK_WIDGET(pv->chain_msg), GTK_ALIGN_START); gtk_box_pack_start(GTK_BOX(msgbox), pv->chain_msg, FALSE, FALSE, 6); #ifdef HAVE_GNUTLS_DANE msgbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start(GTK_BOX(content), msgbox, FALSE, FALSE, 6); pv->dane_icon = gtk_image_new(); gtk_box_pack_start(GTK_BOX(msgbox), pv->dane_icon, FALSE, FALSE, 6); pv->dane_msg = gtk_label_new(NULL); gtk_widget_set_halign(GTK_WIDGET(pv->dane_msg), GTK_ALIGN_START); gtk_box_pack_start(GTK_BOX(msgbox), pv->dane_msg, FALSE, FALSE, 6); #endif /* details: chains & cert viewer */ GtkWidget *details = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_box_pack_start(GTK_BOX(content), details, TRUE, TRUE, 6); GtkWidget *chains = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10); gtk_box_pack_start(GTK_BOX(details), chains, FALSE, FALSE, 0); GtkWidget *viewport = gtk_viewport_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(chains), viewport, FALSE, FALSE, 0); pv->new_chain = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_widget_set_margin_left(pv->new_chain, 5); gtk_widget_set_margin_top(pv->new_chain, 5); gtk_widget_set_margin_bottom(pv->new_chain, 5); //gtk_box_pack_start(GTK_BOX(chains), pv->new_chain, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(viewport), pv->new_chain); GtkWidget *frame = gtk_frame_new(NULL); gtk_box_pack_start(GTK_BOX(chains), frame, TRUE, TRUE, 0); GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(frame), scrolled_window); pv->old_chains = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10); gtk_widget_set_margin_left(pv->old_chains, 5); gtk_widget_set_margin_top(pv->old_chains, 5); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), GTK_WIDGET(pv->old_chains)); //gtk_box_pack_start(GTK_BOX(chains), pv->old_chains, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(details), GTK_WIDGET(pv->viewer), TRUE, TRUE, 0); /* button box */ GtkWidget *bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_halign(GTK_WIDGET(bbox), GTK_ALIGN_END); gtk_widget_set_margin_right(GTK_WIDGET(bbox), 6); gtk_box_set_spacing(GTK_BOX(bbox), 12); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_box_pack_end(GTK_BOX(content), bbox, FALSE, FALSE, 12); /* accept all checkbox */ GtkWidget *btn = gtk_check_button_new_with_mnemonic( _("Pin public key for all _hostnames the certificate is valid for " "(see Subject Name and Subject Alternative Names)")); gtk_widget_set_tooltip_text(btn, "TODO"); g_signal_connect_object(GTK_TOGGLE_BUTTON(btn), "toggled", G_CALLBACK(on_all_hostnames_toggled), self, 0); gtk_box_pack_end(GTK_BOX(content), btn, FALSE, FALSE, 0); /* additional pin checkbox */ btn = gtk_check_button_new_with_mnemonic( _("_Store additional pin instead of replacing existing ones")); g_signal_connect_object(GTK_TOGGLE_BUTTON(btn), "toggled", G_CALLBACK(on_add_pin_toggled), self, 0); gtk_box_pack_end(GTK_BOX(content), btn, FALSE, FALSE, 0); /* reject button */ btn = gtk_button_new_from_stock(GTK_STOCK_NO); gtk_button_set_label(GTK_BUTTON(btn), _("_Reject")); gtk_widget_set_tooltip_text(btn, _("Reject public key.\nCauses verification failure.")); gtk_box_pack_start(GTK_BOX(bbox), btn, FALSE, TRUE, 0); g_signal_connect_object (GTK_BUTTON(btn), "clicked", G_CALLBACK(on_reject_clicked), self, 0); /* continue button */ btn = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_button_set_label(GTK_BUTTON(btn), _("_Continue")); gtk_widget_set_tooltip_text(btn, _("Temporarily accept public key, but do not pin it.")); gtk_box_pack_start(GTK_BOX(bbox), btn, FALSE, TRUE, 0); g_signal_connect_object(GTK_BUTTON(btn), "clicked", G_CALLBACK(on_continue_clicked), self, 0); gtk_widget_grab_focus(btn); /* accept button */ btn = gtk_button_new_from_stock(GTK_STOCK_YES); gtk_button_set_label(GTK_BUTTON(btn), _("_Accept")); gtk_widget_set_tooltip_text(btn, _("Accept and pin public key.\nReplace or add pin depending on the above setting.")); gtk_box_pack_start(GTK_BOX(bbox), btn, FALSE, TRUE, 0); g_signal_connect_object(GTK_BUTTON(btn), "clicked", G_CALLBACK(on_accept_clicked), self, 0); gtk_widget_show_all(content); }
/************************************************************************** Creates a new dialog. It will be a tab or a window depending on the current user setting of 'gui_gtk3_enable_tabs'. Sets pdlg to point to the dialog once it is create, Zeroes pdlg on dialog destruction. user_data will be passed through response function check_top indicates if the layout deision should depend on the parent. **************************************************************************/ void gui_dialog_new(struct gui_dialog **pdlg, GtkNotebook *notebook, gpointer user_data, bool check_top) { struct gui_dialog *dlg; GtkWidget *vbox, *action_area; static int dialog_id_counter; dlg = fc_malloc(sizeof(*dlg)); dialog_list = g_list_prepend(dialog_list, dlg); dlg->source = pdlg; *pdlg = dlg; dlg->user_data = user_data; dlg->title = NULL; dlg->default_width = 200; dlg->default_height = 300; if (gui_gtk3_enable_tabs) { dlg->type = GUI_DIALOG_TAB; } else { dlg->type = GUI_DIALOG_WINDOW; } if (!gui_action) { gui_action = gtk_size_group_new(GTK_SIZE_GROUP_VERTICAL); } dlg->gui_button = gtk_size_group_new(GTK_SIZE_GROUP_BOTH); vbox = gtk_grid_new(); action_area = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(action_area), 4); gtk_grid_set_column_spacing(GTK_GRID(action_area), 4); if (gui_gtk3_enable_tabs && (check_top && notebook != GTK_NOTEBOOK(top_notebook)) && !gui_gtk3_small_display_layout) { /* We expect this to be short (as opposed to tall); maximise usable * height by putting buttons down the right hand side */ gtk_orientable_set_orientation(GTK_ORIENTABLE(action_area), GTK_ORIENTATION_VERTICAL); } else { /* We expect this to be reasonably tall; maximise usable width by * putting buttons along the bottom */ gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL); } gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER(vbox), action_area); gtk_widget_show(action_area); gtk_container_set_border_width(GTK_CONTAINER(vbox), 2); gtk_container_set_border_width(GTK_CONTAINER(action_area), 2); switch (dlg->type) { case GUI_DIALOG_WINDOW: { GtkWidget *window; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_name(window, "Freeciv"); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_MOUSE); setup_dialog(window, toplevel); gtk_container_add(GTK_CONTAINER(window), vbox); dlg->v.window = window; g_signal_connect(window, "delete_event", G_CALLBACK(gui_dialog_delete_handler), dlg); } break; case GUI_DIALOG_TAB: { GtkWidget *hbox, *label, *image, *button, *event_box; gint w, h; gchar *buf; gtk_icon_size_lookup_for_settings( gtk_settings_get_for_screen(gtk_widget_get_screen(vbox)), GTK_ICON_SIZE_MENU, &w, &h); hbox = gtk_grid_new(); label = gtk_label_new(NULL); gtk_widget_set_halign(label, GTK_ALIGN_START); gtk_widget_set_valign(label, GTK_ALIGN_CENTER); gtk_widget_set_margin_left(label, 4); gtk_widget_set_margin_right(label, 4); gtk_widget_set_margin_top(label, 0); gtk_widget_set_margin_bottom(label, 0); gtk_container_add(GTK_CONTAINER(hbox), label); button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect_swapped(button, "clicked", G_CALLBACK(gui_dialog_delete_tab_handler), dlg); buf = g_strdup_printf(_("Close Tab:\n%s"), _("Ctrl+W")); gtk_widget_set_tooltip_text(button, buf); g_free(buf); image = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); gtk_widget_set_margin_left(image, 0); gtk_widget_set_margin_right(image, 0); gtk_widget_set_margin_top(image, 0); gtk_widget_set_margin_bottom(image, 0); gtk_button_set_image(GTK_BUTTON(button), image); gtk_container_add(GTK_CONTAINER(hbox), button); gtk_widget_show_all(hbox); event_box = gtk_event_box_new(); gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box), FALSE); gtk_container_add(GTK_CONTAINER(event_box), hbox); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, event_box); dlg->v.tab.handler_id = g_signal_connect(notebook, "switch-page", G_CALLBACK(gui_dialog_switch_page_handler), dlg); dlg->v.tab.child = vbox; dlg->v.tab.label = label; dlg->v.tab.notebook = GTK_WIDGET(notebook); gtk_widget_add_events(event_box, GDK_BUTTON2_MOTION_MASK); g_signal_connect(event_box, "button-press-event", G_CALLBACK(click_on_tab_callback), dlg); } break; } dlg->vbox = vbox; dlg->action_area = action_area; dlg->response_callback = gui_dialog_destroyed; dlg->id = dialog_id_counter; dialog_id_counter++; dlg->return_dialog_id = -1; g_signal_connect(vbox, "destroy", G_CALLBACK(gui_dialog_destroy_handler), dlg); g_signal_connect(vbox, "key_press_event", G_CALLBACK(gui_dialog_key_press_handler), dlg); g_object_set_data(G_OBJECT(vbox), "gui-dialog-data", dlg); }
GtkWidget * pgd_page_create_widget (PopplerDocument *document) { PgdPageDemo *demo; GtkWidget *vbox; GtkWidget *hbox, *page_selector; GtkWidget *button; GtkWidget *frame; GtkWidget *table; GtkWidget *label; GtkWidget *thumnail_box; gchar *str; gint n_pages; gint row = 0; demo = g_new0 (PgdPageDemo, 1); demo->doc = g_object_ref (document); n_pages = poppler_document_get_n_pages (document); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_page_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); button = gtk_button_new_with_label ("Get Info"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_page_get_info), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<b>Page Properties</b>"); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_widget_show (label); table = gtk_grid_new (); gtk_widget_set_margin_top (table, 5); gtk_widget_set_margin_bottom (table, 5); #if GTK_CHECK_VERSION(3, 12, 0) gtk_widget_set_margin_start (table, 12); gtk_widget_set_margin_end (table, 5); #else gtk_widget_set_margin_left (table, 12); gtk_widget_set_margin_right (table, 5); #endif gtk_grid_set_column_spacing (GTK_GRID (table), 6); gtk_grid_set_row_spacing (GTK_GRID (table), 6); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Index:</b>", &(demo->index), NULL, &row); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Label:</b>", &(demo->label), NULL, &row); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Size:</b>", &(demo->size), NULL, &row); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Duration:</b>", &(demo->duration), NULL, &row); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<b>Page Thumbnail</b>"); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_widget_show (label); thumnail_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_widget_set_margin_top (thumnail_box, 5); gtk_widget_set_margin_bottom (thumnail_box, 5); #if GTK_CHECK_VERSION(3, 12, 0) gtk_widget_set_margin_start (thumnail_box, 12); gtk_widget_set_margin_end (thumnail_box, 5); #else gtk_widget_set_margin_left (thumnail_box, 12); gtk_widget_set_margin_right (thumnail_box, 5); #endif demo->thumbnail = gtk_image_new (); gtk_box_pack_start (GTK_BOX (thumnail_box), demo->thumbnail, TRUE, TRUE, 0); gtk_widget_show (demo->thumbnail); demo->thumbnail_size = gtk_label_new (NULL); g_object_set (G_OBJECT (demo->thumbnail_size), "xalign", 0.5, NULL); gtk_box_pack_start (GTK_BOX (thumnail_box), demo->thumbnail_size, TRUE, TRUE, 0); gtk_widget_show (demo->thumbnail_size); gtk_container_add (GTK_CONTAINER (frame), thumnail_box); gtk_widget_show (thumnail_box); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_page_free, (gpointer)demo); return vbox; }
static void gtk_tooltip_init (GtkTooltip *tooltip) { GtkStyleContext *context; GtkWidget *window; GtkWidget *box; GtkWidget *image; GtkWidget *label; GdkScreen *screen; GdkVisual *visual; tooltip->timeout_id = 0; tooltip->browse_mode_timeout_id = 0; tooltip->browse_mode_enabled = FALSE; tooltip->keyboard_mode_enabled = FALSE; tooltip->current_window = NULL; tooltip->keyboard_widget = NULL; tooltip->tooltip_widget = NULL; tooltip->toplevel_window = NULL; tooltip->last_window = NULL; window = gtk_window_new (GTK_WINDOW_POPUP); screen = gtk_widget_get_screen (window); visual = gdk_screen_get_rgba_visual (screen); if (visual != NULL) gtk_widget_set_visual (window, visual); gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_TOOLTIP); gtk_widget_set_app_paintable (window, TRUE); gtk_window_set_resizable (GTK_WINDOW (window), FALSE); gtk_widget_set_name (window, "gtk-tooltip"); g_signal_connect (window, "hide", G_CALLBACK (gtk_tooltip_window_hide), tooltip); context = gtk_widget_get_style_context (window); gtk_style_context_add_class (context, GTK_STYLE_CLASS_TOOLTIP); g_signal_connect_swapped (window, "draw", G_CALLBACK (gtk_tooltip_paint_window), tooltip); g_signal_connect_swapped (window, "realize", G_CALLBACK (gtk_tooltip_realize_window), tooltip); g_signal_connect_swapped (window, "composited-changed", G_CALLBACK (gtk_tooltip_composited_changed), tooltip); /* FIXME: don't hardcode the padding */ box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_widget_set_margin_left (box, 6); gtk_widget_set_margin_right (box, 6); gtk_widget_set_margin_top (box, 6); gtk_widget_set_margin_bottom (box, 6); gtk_container_add (GTK_CONTAINER (window), box); gtk_widget_show (box); image = gtk_image_new (); gtk_box_pack_start (GTK_BOX (box), image, FALSE, FALSE, 0); label = gtk_label_new (""); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); tooltip->window = window; tooltip->box = box; tooltip->image = image; tooltip->label = label; tooltip->custom_widget = NULL; }
MidiogreApp *midiogre_app_init(void) { MidiogreApp *app; GtkWidget *header; GtkWidget *separator; GtkWidget *scrolled; GtkWidget *label,*frame; GtkWidget *button; GtkBox *box; gint i; GError *err; /* Allocate app */ app = calloc(1, sizeof(MidiogreApp)); /* Setup window */ app->window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL)); gtk_window_set_default_size(GTK_WINDOW(app->window), 600, 400); g_signal_connect(app->window, "destroy", G_CALLBACK(gtk_widget_destroyed), NULL); g_signal_connect(app->window, "key-release-event", G_CALLBACK(key_event), NULL); gtk_window_set_icon(app->window,gdk_pixbuf_new_from_resource("/org/prozum/midiogre/midiogre_logo.png",&err)); /* Setup header bar */ header = gtk_header_bar_new(); gtk_header_bar_set_title (GTK_HEADER_BAR(header), "Midiogre"); gtk_window_set_titlebar(app->window, header); /* Setup close button */ button = gtk_button_new(); gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/window-close-symbolic.symbolic.png")); gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button); g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_main_quit), app->window); /* Add seperator */ separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL); gtk_header_bar_pack_end(GTK_HEADER_BAR(header), separator); /* Setup folder button */ button = gtk_button_new(); gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/document-open-symbolic.symbolic.png")); gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button); g_signal_connect_swapped(button, "clicked", G_CALLBACK(folder_chooser), app->window); /* Global horizontal box */ app->win_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(app->window), GTK_WIDGET(app->win_box)); /* Scroll container for sidepanel */ scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(app->win_box, scrolled, FALSE, FALSE, 0); /* Sidepanel box */ app->panel_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0)); gtk_container_add(GTK_CONTAINER (scrolled), GTK_WIDGET(app->panel_box)); gtk_container_set_border_width(GTK_CONTAINER(app->panel_box), 10); /* Frame with favorit info */ frame = gtk_frame_new("Favorite"); gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0); app->fav_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->fav_box)); /* Current favorite */ app->fav_title_label = GTK_LABEL(gtk_label_new("")); gtk_label_set_max_width_chars(app->fav_title_label, 20); gtk_label_set_width_chars(app->fav_title_label, 20); gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_title_label), FALSE, FALSE, 0); app->fav_artist_label = GTK_LABEL(gtk_label_new("No favorite selected!")); gtk_label_set_max_width_chars(app->fav_artist_label, 20); gtk_label_set_width_chars(app->fav_artist_label, 20); gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_artist_label), FALSE, FALSE, 0); app->fav_album_label = GTK_LABEL(gtk_label_new("")); gtk_label_set_max_width_chars(app->fav_album_label, 20); gtk_label_set_width_chars(app->fav_album_label, 20); gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_album_label), FALSE, FALSE, 0); /* Frame with search criteria widgets */ frame = gtk_frame_new("Search"); gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0); app->search_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 10)); gtk_container_set_border_width(GTK_CONTAINER(app->search_box), 10); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->search_box)); /* Title entry */ frame = gtk_frame_new("Title"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box)); gtk_container_set_border_width(GTK_CONTAINER(box), 10); app->title_entry = GTK_ENTRY(gtk_entry_new()); gtk_box_pack_start(box, GTK_WIDGET(app->title_entry), TRUE, FALSE, 0); /* Artist entry */ frame = gtk_frame_new("Artist"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(box), 10); box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box)); gtk_container_set_border_width(GTK_CONTAINER(box), 10); app->artist_entry = GTK_ENTRY(gtk_entry_new()); gtk_box_pack_start(box, GTK_WIDGET(app->artist_entry), TRUE, FALSE, 0); /* Album entry */ frame = gtk_frame_new("Album"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box)); gtk_container_set_border_width(GTK_CONTAINER(box), 10); app->album_entry = GTK_ENTRY(gtk_entry_new()); gtk_box_pack_start(box, GTK_WIDGET(app->album_entry), TRUE, FALSE, 0); /* Instrument class buttons */ frame = gtk_frame_new("Instrument Classes"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); app->instr_grid = GTK_GRID(gtk_grid_new()); #if GTK_MINOR_VERSION >= 12 gtk_widget_set_margin_start(GTK_WIDGET(app->instr_grid), 10); gtk_widget_set_margin_end(GTK_WIDGET(app->instr_grid), 10); #else gtk_widget_set_margin_left(GTK_WIDGET(app->instr_grid), 10); gtk_widget_set_margin_right(GTK_WIDGET(app->instr_grid), 10); #endif gtk_widget_set_margin_bottom(GTK_WIDGET(app->instr_grid), 10); gtk_widget_set_margin_top(GTK_WIDGET(app->instr_grid), 10); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->instr_grid)); for (i = 0; i < INSTR_CLASSES; i++) { label = gtk_label_new(instrument_classes[i]); gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START); gtk_grid_attach(app->instr_grid, label, 1, i + 1, 1, 1); app->instr_buttons[i] = GTK_CHECK_BUTTON(gtk_check_button_new()); gtk_widget_set_halign(GTK_WIDGET(app->instr_buttons[i]), GTK_ALIGN_END); gtk_grid_attach(app->instr_grid, GTK_WIDGET(app->instr_buttons[i]), 2, i + 1, 1, 1); } /* Result spinbutton */ frame = gtk_frame_new("Max result"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box)); gtk_container_set_border_width(GTK_CONTAINER(box), 10); app->result_spinbutton = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 100, 1)); gtk_spin_button_set_value(app->result_spinbutton, 25); gtk_box_pack_start(box, GTK_WIDGET(app->result_spinbutton), TRUE, TRUE, 0); /* Search button */ app->search_button = GTK_BUTTON(gtk_button_new_with_label("Search")); gtk_box_pack_start(app->search_box, GTK_WIDGET(app->search_button), FALSE, FALSE, 0); g_signal_connect_swapped(app->search_button, "clicked", G_CALLBACK(search_event), app); /* Songboxes notebook (Tabsview) */ app->song_notebook = GTK_NOTEBOOK(gtk_notebook_new()); gtk_widget_set_hexpand(GTK_WIDGET(app->song_notebook), TRUE); gtk_box_pack_start(app->win_box, GTK_WIDGET(app->song_notebook), TRUE, TRUE, 0); /* Add song boxes */ app->songboxes[SONGBOX_ALPHA] = songbox_new(app->song_notebook, "Alphabetical"); app->songboxes[SONGBOX_FPRNT] = songbox_new(app->song_notebook, "Fingerprint"); app->songboxes[SONGBOX_BEST] = songbox_new(app->song_notebook, "Best Match"); app->songboxes[SONGBOX_POP] = songbox_new(app->song_notebook, "Popularity"); app->songboxes[SONGBOX_NEW] = songbox_new(app->song_notebook, "Newest"); /* Show all widgets */ gtk_widget_show_all(GTK_WIDGET(app->window)); /* Allocate song queue */ app->songs[SONGBOX_ALPHA] = g_queue_new(); app->songs[SONGBOX_FPRNT] = g_queue_new(); app->songs[SONGBOX_BEST] = g_queue_new(); app->songs[SONGBOX_POP] = g_queue_new(); app->songs[SONGBOX_NEW] = g_queue_new(); return app; }
static void add_address_row (CEPageIP6 *page, const gchar *address, const gchar *network, const gchar *gateway) { GtkWidget *row; GtkWidget *row_grid; GtkWidget *label; GtkWidget *widget; GtkWidget *delete_button; GtkWidget *image; row = gtk_list_box_row_new (); row_grid = gtk_grid_new (); label = gtk_label_new (_("Address")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 1, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "address", widget); gtk_entry_set_text (GTK_ENTRY (widget), address); gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 1, 1, 1); label = gtk_label_new (_("Prefix")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 2, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "prefix", widget); gtk_entry_set_text (GTK_ENTRY (widget), network); gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 2, 1, 1); label = gtk_label_new (_("Gateway")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 3, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "gateway", widget); gtk_entry_set_text (GTK_ENTRY (widget), gateway); gtk_widget_set_margin_left (widget, 10); gtk_widget_set_margin_right (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 3, 1, 1); delete_button = gtk_button_new (); gtk_style_context_add_class (gtk_widget_get_style_context (delete_button), "image-button"); g_signal_connect (delete_button, "clicked", G_CALLBACK (remove_row), page); image = gtk_image_new_from_icon_name ("user-trash-symbolic", GTK_ICON_SIZE_MENU); atk_object_set_name (gtk_widget_get_accessible (delete_button), _("Delete Address")); gtk_button_set_image (GTK_BUTTON (delete_button), image); gtk_grid_attach (GTK_GRID (row_grid), delete_button, 3, 2, 1, 1); g_object_set_data (G_OBJECT (row), "delete-button", delete_button); gtk_grid_set_row_spacing (GTK_GRID (row_grid), 10); gtk_widget_set_margin_left (row_grid, 10); gtk_widget_set_margin_right (row_grid, 10); gtk_widget_set_margin_top (row_grid, 10); gtk_widget_set_margin_bottom (row_grid, 10); gtk_widget_set_halign (row_grid, GTK_ALIGN_FILL); gtk_container_add (GTK_CONTAINER (row), row_grid); gtk_widget_show_all (row); gtk_container_add (GTK_CONTAINER (page->address_list), row); update_row_sensitivity (page, page->address_list); }
static void gtk_color_editor_init (GtkColorEditor *editor) { GtkWidget *grid; GtkWidget *slider; GtkWidget *entry; GtkWidget *swatch; GtkAdjustment *h_adj, *s_adj, *v_adj, *a_adj; AtkObject *atk_obj; GdkRGBA transparent = { 0, 0, 0, 0 }; editor->priv = G_TYPE_INSTANCE_GET_PRIVATE (editor, GTK_TYPE_COLOR_EDITOR, GtkColorEditorPrivate); editor->priv->use_alpha = TRUE; editor->priv->h_adj = h_adj = gtk_adjustment_new (0, 0, 1, 0.01, 0.1, 0); editor->priv->s_adj = s_adj = gtk_adjustment_new (0, 0, 1, 0.01, 0.1, 0); editor->priv->v_adj = v_adj = gtk_adjustment_new (0, 0, 1, 0.01, 0.1, 0); editor->priv->a_adj = a_adj = gtk_adjustment_new (0, 0, 1, 0.01, 0.1, 0); g_object_ref_sink (h_adj); g_object_ref_sink (s_adj); g_object_ref_sink (v_adj); g_object_ref_sink (a_adj); g_signal_connect_swapped (h_adj, "value-changed", G_CALLBACK (hsv_changed), editor); g_signal_connect_swapped (s_adj, "value-changed", G_CALLBACK (hsv_changed), editor); g_signal_connect_swapped (v_adj, "value-changed", G_CALLBACK (hsv_changed), editor); g_signal_connect_swapped (a_adj, "value-changed", G_CALLBACK (hsv_changed), editor); gtk_widget_push_composite_child (); /* Construct the main UI */ editor->priv->swatch = swatch = gtk_color_swatch_new (); gtk_color_swatch_set_selectable (GTK_COLOR_SWATCH (editor->priv->swatch), FALSE); gtk_widget_set_events (swatch, gtk_widget_get_events (swatch) & ~(GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK)); gtk_widget_set_can_focus (swatch, FALSE); editor->priv->entry = entry = gtk_entry_new (); atk_obj = gtk_widget_get_accessible (entry); atk_object_set_role (atk_obj, ATK_ROLE_ENTRY); atk_object_set_name (atk_obj, _("Color Name")); g_signal_connect (entry, "activate", G_CALLBACK (entry_apply), editor); g_signal_connect (entry, "notify::text", G_CALLBACK (entry_text_changed), editor); g_signal_connect (entry, "focus-out-event", G_CALLBACK (entry_focus_out), editor); editor->priv->h_slider = slider = gtk_color_scale_new (h_adj, GTK_COLOR_SCALE_HUE); gtk_orientable_set_orientation (GTK_ORIENTABLE (slider), GTK_ORIENTATION_VERTICAL); if (gtk_widget_get_direction (slider) == GTK_TEXT_DIR_RTL) gtk_style_context_add_class (gtk_widget_get_style_context (slider), GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE); else gtk_style_context_add_class (gtk_widget_get_style_context (slider), GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW); editor->priv->sv_plane = gtk_color_plane_new (h_adj, s_adj, v_adj); gtk_widget_set_size_request (editor->priv->sv_plane, 300, 300); editor->priv->a_slider = slider = gtk_color_scale_new (a_adj, GTK_COLOR_SCALE_ALPHA); gtk_orientable_set_orientation (GTK_ORIENTABLE (slider), GTK_ORIENTATION_HORIZONTAL); gtk_style_context_add_class (gtk_widget_get_style_context (slider), GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE); editor->priv->grid = grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 12); gtk_grid_set_column_spacing (GTK_GRID (grid), 12); gtk_grid_attach (GTK_GRID (grid), editor->priv->swatch, 1, 0, 1, 1); gtk_grid_attach (GTK_GRID (grid), editor->priv->entry, 2, 0, 1, 1); gtk_grid_attach (GTK_GRID (grid), editor->priv->h_slider, 0, 1, 1, 1); gtk_grid_attach (GTK_GRID (grid), editor->priv->sv_plane, 1, 1, 2, 1); gtk_grid_attach (GTK_GRID (grid), editor->priv->a_slider, 1, 2, 2, 1); /* This extra margin is necessary so we have room to the sides * to place the popups as desired */ gtk_widget_set_margin_left (grid, 30); gtk_widget_set_margin_right (grid, 30); editor->priv->overlay = gtk_overlay_new (); gtk_widget_override_background_color (editor->priv->overlay, 0, &transparent); gtk_container_add (GTK_CONTAINER (editor->priv->overlay), grid); /* Construct the sv popup */ editor->priv->s_entry = entry = gtk_spin_button_new (scaled_adjustment (s_adj, 100), 1, 0); atk_obj = gtk_widget_get_accessible (entry); atk_object_set_name (atk_obj, C_("Color channel", "Saturation")); atk_object_set_role (atk_obj, ATK_ROLE_ENTRY); g_signal_connect (entry, "key-press-event", G_CALLBACK (popup_key_press), editor); editor->priv->v_entry = entry = gtk_spin_button_new (scaled_adjustment (v_adj, 100), 1, 0); atk_obj = gtk_widget_get_accessible (entry); atk_object_set_name (atk_obj, C_("Color channel", "Value")); atk_object_set_role (atk_obj, ATK_ROLE_ENTRY); g_signal_connect (entry, "key-press-event", G_CALLBACK (popup_key_press), editor); grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_grid_set_column_spacing (GTK_GRID (grid), 6); gtk_grid_attach (GTK_GRID (grid), gtk_label_new (C_("Color channel", "S")), 0, 0, 1, 1); gtk_grid_attach (GTK_GRID (grid), editor->priv->s_entry, 1, 0, 1, 1); gtk_grid_attach (GTK_GRID (grid), gtk_label_new (C_("Color channel", "V")), 0, 1, 1, 1); gtk_grid_attach (GTK_GRID (grid), editor->priv->v_entry, 1, 1, 1, 1); editor->priv->sv_popup = create_popup (editor, editor->priv->sv_plane, grid); /* Construct the h popup */ editor->priv->h_entry = entry = gtk_spin_button_new (scaled_adjustment (h_adj, 100), 1, 0); atk_obj = gtk_widget_get_accessible (entry); atk_object_set_name (atk_obj, C_("Color channel", "Hue")); atk_object_set_role (atk_obj, ATK_ROLE_ENTRY); g_signal_connect (entry, "key-press-event", G_CALLBACK (popup_key_press), editor); grid = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (grid), 6); gtk_grid_attach (GTK_GRID (grid), gtk_label_new (C_("Color channel", "H")), 0, 0, 1, 1); gtk_grid_attach (GTK_GRID (grid), editor->priv->h_entry, 1, 0, 1, 1); editor->priv->h_popup = create_popup (editor, editor->priv->h_slider, grid); /* Construct the a popup */ editor->priv->a_entry = entry = gtk_spin_button_new (scaled_adjustment (a_adj, 100), 1, 0); atk_obj = gtk_widget_get_accessible (entry); atk_object_set_name (atk_obj, C_("Color channel", "Alpha")); atk_object_set_role (atk_obj, ATK_ROLE_ENTRY); g_signal_connect (entry, "key-press-event", G_CALLBACK (popup_key_press), editor); grid = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (grid), 6); gtk_grid_attach (GTK_GRID (grid), gtk_label_new (C_("Color channel", "A")), 0, 0, 1, 1); gtk_grid_attach (GTK_GRID (grid), editor->priv->a_entry, 1, 0, 1, 1); editor->priv->a_popup = create_popup (editor, editor->priv->a_slider, grid); /* Hook up popup positioning */ g_signal_connect (editor->priv->overlay, "get-child-position", G_CALLBACK (get_child_position), editor); g_signal_connect (editor, "notify::visible", G_CALLBACK (dismiss_current_popup), NULL); gtk_widget_show_all (editor->priv->overlay); gtk_container_add (GTK_CONTAINER (editor), editor->priv->overlay); gtk_widget_pop_composite_child (); }
static void gd_main_toolbar_constructed (GObject *obj) { GdMainToolbar *self = GD_MAIN_TOOLBAR (obj); GtkToolbar *tb = GTK_TOOLBAR (obj); GtkWidget *grid; G_OBJECT_CLASS (gd_main_toolbar_parent_class)->constructed (obj); self->priv->vertical_size_group = get_vertical_size_group (); /* left section */ self->priv->left_group = gtk_tool_item_new (); gtk_widget_set_margin_right (GTK_WIDGET (self->priv->left_group), 12); gtk_toolbar_insert (tb, self->priv->left_group, -1); gtk_size_group_add_widget (self->priv->vertical_size_group, GTK_WIDGET (self->priv->left_group)); /* left button group */ self->priv->left_grid = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (self->priv->left_grid), 12); gtk_container_add (GTK_CONTAINER (self->priv->left_group), self->priv->left_grid); self->priv->back = get_symbolic_button ("go-previous-symbolic"); gtk_widget_set_no_show_all (self->priv->back, TRUE); gtk_container_add (GTK_CONTAINER (self->priv->left_grid), self->priv->back); g_signal_connect (self->priv->back, "clicked", G_CALLBACK (on_back_button_clicked), self); /* center section */ self->priv->center_group = gtk_tool_item_new (); gtk_tool_item_set_expand (self->priv->center_group, TRUE); gtk_toolbar_insert (tb, self->priv->center_group, -1); gtk_size_group_add_widget (self->priv->vertical_size_group, GTK_WIDGET (self->priv->center_group)); /* centered label group */ grid = gtk_grid_new (); gtk_widget_set_halign (grid, GTK_ALIGN_CENTER); gtk_widget_set_valign (grid, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (self->priv->center_group), grid); self->priv->title_label = gtk_label_new (NULL); gtk_label_set_ellipsize (GTK_LABEL (self->priv->title_label), PANGO_ELLIPSIZE_END); gtk_container_add (GTK_CONTAINER (grid), self->priv->title_label); self->priv->detail_label = gtk_label_new (NULL); gtk_widget_set_no_show_all (self->priv->detail_label, TRUE); gtk_widget_set_margin_left (self->priv->detail_label, 12); gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->detail_label), "dim-label"); gtk_container_add (GTK_CONTAINER (grid), self->priv->detail_label); /* right section */ self->priv->right_group = gtk_tool_item_new (); gtk_widget_set_margin_left (GTK_WIDGET (self->priv->right_group), 12); gtk_toolbar_insert (tb, self->priv->right_group, -1); gtk_size_group_add_widget (self->priv->vertical_size_group, GTK_WIDGET (self->priv->right_group)); self->priv->right_grid = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (self->priv->right_grid), 12); gtk_container_add (GTK_CONTAINER (self->priv->right_group), self->priv->right_grid); self->priv->size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); gtk_size_group_add_widget (self->priv->size_group, GTK_WIDGET (self->priv->left_group)); gtk_size_group_add_widget (self->priv->size_group, GTK_WIDGET (self->priv->right_group)); }
static void add_row (NetDeviceEthernet *device, NMConnection *connection) { GtkWidget *row; GtkWidget *widget; GtkWidget *box; GtkWidget *details; NMDevice *nmdev; NMActiveConnection *aconn; gboolean active; GtkWidget *image; active = FALSE; nmdev = net_device_get_nm_device (NET_DEVICE (device)); aconn = nm_device_get_active_connection (nmdev); if (aconn) { const gchar *path1, *path2; path1 = nm_active_connection_get_connection (aconn); path2 = nm_connection_get_path (connection); active = g_strcmp0 (path1, path2) == 0; } row = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (row), box, FALSE, TRUE, 0); widget = gtk_label_new (nm_connection_get_id (connection)); gtk_widget_set_margin_left (widget, 12); gtk_widget_set_margin_right (widget, 12); gtk_widget_set_margin_top (widget, 12); gtk_widget_set_margin_bottom (widget, 12); gtk_box_pack_start (GTK_BOX (box), widget, FALSE, TRUE, 0); if (active) { widget = gtk_image_new_from_icon_name ("object-select-symbolic", GTK_ICON_SIZE_MENU); gtk_widget_set_halign (widget, GTK_ALIGN_CENTER); gtk_widget_set_valign (widget, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (box), widget, FALSE, TRUE, 0); details = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (details), 10); gtk_grid_set_column_spacing (GTK_GRID (details), 10); gtk_box_pack_start (GTK_BOX (row), details, FALSE, TRUE, 0); add_details (details, nmdev, connection); } /* filler */ widget = gtk_label_new (""); gtk_widget_set_hexpand (widget, TRUE); gtk_box_pack_start (GTK_BOX (box), widget, TRUE, TRUE, 0); image = gtk_image_new_from_icon_name ("emblem-system-symbolic", GTK_ICON_SIZE_MENU); gtk_widget_show (image); widget = gtk_button_new (); gtk_style_context_add_class (gtk_widget_get_style_context (widget), "image-button"); gtk_widget_set_margin_left (widget, 12); gtk_widget_set_margin_right (widget, 12); gtk_widget_set_margin_top (widget, 12); gtk_widget_set_margin_bottom (widget, 12); gtk_widget_show (widget); gtk_container_add (GTK_CONTAINER (widget), image); gtk_widget_set_halign (widget, GTK_ALIGN_CENTER); gtk_widget_set_valign (widget, GTK_ALIGN_CENTER); atk_object_set_name (gtk_widget_get_accessible (widget), _("Options…")); gtk_box_pack_start (GTK_BOX (box), widget, FALSE, TRUE, 0); g_object_set_data (G_OBJECT (row), "edit", widget); g_object_set_data (G_OBJECT (widget), "row", row); g_signal_connect (widget, "clicked", G_CALLBACK (show_details_for_row), device); gtk_widget_show_all (row); g_object_set_data (G_OBJECT (row), "connection", connection); gtk_container_add (GTK_CONTAINER (device->list), row); }
/* * Class: org_java_gtk_gtk_Widget * Method: gtk_widget_set_margin_right * Signature: (JI)V */ JNIEXPORT void JNICALL Java_org_java_1gtk_gtk_Widget_gtk_1widget_1set_1margin_1right (JNIEnv *env, jclass cls, jlong widget, jint margin) { gtk_widget_set_margin_right((GtkWidget*)widget, (gint)margin); }