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 GtkWidget *
add_row (CcPrivacyPanel *self,
const gchar *label,
const gchar *dialog_id,
GtkWidget *status)
{
GtkWidget *box, *row, *w;
row = gtk_list_box_row_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 50);
gtk_container_add (GTK_CONTAINER (row), box);
g_object_set_data (G_OBJECT (row), "dialog-id", (gpointer)dialog_id);
gtk_widget_set_hexpand (box, TRUE);
gtk_container_add (GTK_CONTAINER (self->priv->list_box), row);
w = gtk_label_new (label);
gtk_widget_set_halign (w, GTK_ALIGN_START);
gtk_widget_set_margin_start (w, 20);
gtk_widget_set_margin_end (w, 20);
gtk_widget_set_margin_top (w, 12);
gtk_widget_set_margin_bottom (w, 12);
gtk_widget_set_halign (w, GTK_ALIGN_START);
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_widget_set_hexpand (w, TRUE);
gtk_box_pack_start (GTK_BOX (box), w, TRUE, TRUE, 0);
gtk_widget_set_margin_start (status, 20);
gtk_widget_set_margin_end (status, 20);
gtk_widget_set_halign (status, GTK_ALIGN_END);
gtk_widget_set_valign (status, GTK_ALIGN_CENTER);
gtk_box_pack_end (GTK_BOX (box), status, FALSE, FALSE, 0);
gtk_widget_show_all (row);
return row;
}
static void
create_box_window (void)
{
GtkWidget *window;
GtkWidget *box1, *box2, *box3;
GtkWidget *toggle;
GtkWidget *colorbox;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Boxes");
box1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
box3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (box1),
gtk_label_new ("VBox 1 Top"));
gtk_box_pack_start (GTK_BOX (box1),
box2);
gtk_box_pack_end (GTK_BOX (box1),
gtk_label_new ("VBox 1 Bottom"));
gtk_box_pack_start (GTK_BOX (box2),
gtk_label_new ("HBox 2 Left"));
gtk_box_pack_start (GTK_BOX (box2),
box3);
gtk_box_pack_end (GTK_BOX (box2),
gtk_label_new ("HBox 2 Right"));
gtk_box_pack_start (GTK_BOX (box3),
gtk_label_new ("VBox 3 Top"));
gtk_box_pack_end (GTK_BOX (box3),
gtk_label_new ("VBox 3 Bottom"));
colorbox = gtk_frame_new (NULL);
toggle = gtk_toggle_button_new_with_label ("H Expand");
gtk_widget_set_halign (toggle, GTK_ALIGN_CENTER);
gtk_widget_set_valign (toggle, GTK_ALIGN_CENTER);
g_object_set (toggle, "margin", 5, NULL);
g_signal_connect (G_OBJECT (toggle), "toggled",
G_CALLBACK (on_toggle_hexpand), NULL);
gtk_container_add (GTK_CONTAINER (colorbox), toggle);
gtk_box_pack_start (GTK_BOX (box3), colorbox);
colorbox = gtk_frame_new (NULL);
toggle = gtk_toggle_button_new_with_label ("V Expand");
gtk_widget_set_halign (toggle, GTK_ALIGN_CENTER);
gtk_widget_set_valign (toggle, GTK_ALIGN_CENTER);
g_object_set (toggle, "margin", 5, NULL);
g_signal_connect (G_OBJECT (toggle), "toggled",
G_CALLBACK (on_toggle_vexpand), NULL);
gtk_container_add (GTK_CONTAINER (colorbox), toggle);
gtk_box_pack_start (GTK_BOX (box3), colorbox);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (window);
}
static void
ekiga_window_init_dialpad (EkigaWindow *mw)
{
GtkWidget *dialpad = NULL;
GtkWidget *grid = NULL;
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 18);
gtk_container_set_border_width (GTK_CONTAINER (grid), 18);
dialpad = ekiga_dialpad_new (mw->priv->accel);
gtk_widget_set_hexpand (dialpad, FALSE);
gtk_widget_set_vexpand (dialpad, FALSE);
gtk_widget_set_halign (dialpad, GTK_ALIGN_CENTER);
gtk_widget_set_valign (dialpad, GTK_ALIGN_CENTER);
gtk_grid_attach (GTK_GRID (grid), dialpad, 0, 0, 1, 1);
g_signal_connect (dialpad, "button-clicked",
G_CALLBACK (dialpad_button_clicked_cb), mw);
mw->priv->entry = ekiga_window_uri_entry_new (mw);
gtk_widget_set_hexpand (dialpad, TRUE);
gtk_widget_set_vexpand (dialpad, TRUE);
gtk_widget_set_halign (mw->priv->entry, GTK_ALIGN_FILL);
gtk_widget_set_valign (mw->priv->entry, GTK_ALIGN_END);
gtk_grid_attach_next_to (GTK_GRID (grid), mw->priv->entry, dialpad,
GTK_POS_BOTTOM, 1, 1);
gtk_stack_add_named (GTK_STACK (mw->priv->main_stack), grid, "dialpad");
gtk_container_child_set (GTK_CONTAINER (mw->priv->main_stack),
grid,
"icon-name", "input-dialpad-symbolic", NULL);
g_signal_connect (mw, "key-press-event",
G_CALLBACK (key_press_event_cb), mw);
}
static void
photos_error_box_constructed (GObject *object)
{
PhotosErrorBox *self = PHOTOS_ERROR_BOX (object);
G_OBJECT_CLASS (photos_error_box_parent_class)->constructed (object);
gtk_widget_set_halign (GTK_WIDGET (self), GTK_ALIGN_CENTER);
gtk_widget_set_hexpand (GTK_WIDGET (self), TRUE);
gtk_widget_set_valign (GTK_WIDGET (self), GTK_ALIGN_CENTER);
gtk_widget_set_vexpand (GTK_WIDGET (self), TRUE);
gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (self), 12);
self->image = gtk_image_new_from_icon_name ("dialog-error", GTK_ICON_SIZE_INVALID);
gtk_image_set_pixel_size (GTK_IMAGE (self->image), 128);
gtk_widget_set_halign (self->image, GTK_ALIGN_CENTER);
gtk_widget_set_valign (self->image, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (self), self->image);
self->primary_label = gtk_label_new (NULL);
gtk_label_set_use_markup (GTK_LABEL (self->primary_label), TRUE);
gtk_widget_set_halign (self->primary_label, GTK_ALIGN_CENTER);
gtk_widget_set_valign (self->primary_label, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (self), self->primary_label);
self->secondary_label = gtk_label_new (NULL);
gtk_label_set_use_markup (GTK_LABEL (self->secondary_label), TRUE);
gtk_label_set_line_wrap (GTK_LABEL (self->secondary_label), TRUE);
gtk_widget_set_halign (self->secondary_label, GTK_ALIGN_CENTER);
gtk_widget_set_valign (self->secondary_label, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (self), self->secondary_label);
gtk_widget_show_all (GTK_WIDGET (self));
}
GtkWidget *
do_transparent (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *overlay;
GtkWidget *button;
GtkWidget *label;
GtkWidget *picture;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_display (GTK_WINDOW (window),
gtk_widget_get_display (do_widget));
gtk_window_set_default_size (GTK_WINDOW (window), 450, 450);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
gtk_window_set_title (GTK_WINDOW (window), "Transparency");
overlay = blur_overlay_new ();
gtk_container_add (GTK_CONTAINER (window), overlay);
button = gtk_button_new_with_label ("Don't click this button!");
label = gtk_bin_get_child (GTK_BIN (button));
g_object_set (label, "margin", 50, NULL);
gtk_widget_set_opacity (button, 0.7);
gtk_widget_set_halign (button, GTK_ALIGN_FILL);
gtk_widget_set_valign (button, GTK_ALIGN_START);
blur_overlay_add_overlay (BLUR_OVERLAY (overlay), button, 5.0);
button = gtk_button_new_with_label ("Maybe this one?");
label = gtk_bin_get_child (GTK_BIN (button));
g_object_set (label, "margin", 50, NULL);
gtk_widget_set_opacity (button, 0.7);
gtk_widget_set_halign (button, GTK_ALIGN_FILL);
gtk_widget_set_valign (button, GTK_ALIGN_END);
blur_overlay_add_overlay (BLUR_OVERLAY (overlay), button, 5.0);
picture = gtk_picture_new_for_resource ("/transparent/portland-rose.jpg");
gtk_container_add (GTK_CONTAINER (overlay), picture);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
return window;
}
void
setup_eyes (EyesApplet *eyes_applet)
{
int i;
eyes_applet->hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (eyes_applet->vbox), eyes_applet->hbox, TRUE, TRUE, 0);
eyes_applet->eyes = g_new0 (GtkWidget *, eyes_applet->num_eyes);
eyes_applet->pointer_last_x = g_new0 (gint, eyes_applet->num_eyes);
eyes_applet->pointer_last_y = g_new0 (gint, eyes_applet->num_eyes);
for (i = 0; i < eyes_applet->num_eyes; i++) {
eyes_applet->eyes[i] = gtk_image_new ();
if (eyes_applet->eyes[i] == NULL)
g_error ("Error creating geyes\n");
gtk_widget_set_size_request (GTK_WIDGET (eyes_applet->eyes[i]),
eyes_applet->eye_width,
eyes_applet->eye_height);
gtk_widget_show (eyes_applet->eyes[i]);
gtk_box_pack_start (GTK_BOX (eyes_applet->hbox),
eyes_applet->eyes [i],
TRUE,
TRUE,
0);
if ((eyes_applet->num_eyes != 1) && (i == 0)) {
gtk_widget_set_halign (eyes_applet->eyes[i], GTK_ALIGN_END);
gtk_widget_set_valign (eyes_applet->eyes[i], GTK_ALIGN_CENTER);
}
else if ((eyes_applet->num_eyes != 1) && (i == eyes_applet->num_eyes - 1)) {
gtk_widget_set_halign (eyes_applet->eyes[i], GTK_ALIGN_START);
gtk_widget_set_valign (eyes_applet->eyes[i], GTK_ALIGN_CENTER);
}
else {
gtk_widget_set_halign (eyes_applet->eyes[i], GTK_ALIGN_CENTER);
gtk_widget_set_valign (eyes_applet->eyes[i], GTK_ALIGN_CENTER);
}
gtk_widget_realize (eyes_applet->eyes[i]);
eyes_applet->pointer_last_x[i] = G_MAXINT;
eyes_applet->pointer_last_y[i] = G_MAXINT;
draw_eye (eyes_applet, i,
eyes_applet->eye_width / 2,
eyes_applet->eye_height / 2);
}
gtk_widget_show (eyes_applet->hbox);
}
static void
photos_delete_notification_constructed (GObject *object)
{
PhotosDeleteNotification *self = PHOTOS_DELETE_NOTIFICATION (object);
gchar *msg;
GtkWidget *close;
GtkWidget *image;
GtkWidget *label;
GtkWidget *undo;
guint length;
G_OBJECT_CLASS (photos_delete_notification_parent_class)->constructed (object);
length = g_list_length (self->items);
if (length == 1)
{
const gchar *name;
name = photos_base_item_get_name_with_fallback (PHOTOS_BASE_ITEM (self->items->data));
msg = g_strdup_printf (_("“%s” deleted"), name);
}
else
msg = g_strdup_printf (ngettext ("%d item deleted", "%d items deleted", length), length);
label = gtk_label_new (msg);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_hexpand (label, TRUE);
gtk_container_add (GTK_CONTAINER (self), label);
g_free (msg);
undo = gtk_button_new_with_label (_("Undo"));
gtk_widget_set_valign (undo, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (self), undo);
g_signal_connect_swapped (undo, "clicked", G_CALLBACK (photos_delete_notification_undo_clicked), self);
image = gtk_image_new_from_icon_name (PHOTOS_ICON_WINDOW_CLOSE_SYMBOLIC, GTK_ICON_SIZE_INVALID);
gtk_widget_set_margin_bottom (image, 2);
gtk_widget_set_margin_top (image, 2);
gtk_image_set_pixel_size (GTK_IMAGE (image), 16);
close = gtk_button_new ();
gtk_widget_set_valign (close, GTK_ALIGN_CENTER);
gtk_button_set_focus_on_click (GTK_BUTTON (close), FALSE);
gtk_button_set_relief (GTK_BUTTON (close), GTK_RELIEF_NONE);
gtk_button_set_image (GTK_BUTTON (close), image);
gtk_container_add (GTK_CONTAINER (self), close);
g_signal_connect_swapped (close, "clicked", G_CALLBACK (photos_delete_notification_delete_items), self);
photos_notification_manager_add_notification (PHOTOS_NOTIFICATION_MANAGER (self->ntfctn_mngr),
GTK_WIDGET (self));
self->timeout_id = g_timeout_add_seconds (DELETE_TIMEOUT, photos_delete_notification_timeout, self);
}
/* test custom positioning */
static GtkWidget *
test_relative (void)
{
GtkWidget *win;
GtkWidget *grid;
GtkWidget *overlay;
GtkWidget *text;
GtkWidget *child;
GdkRGBA color;
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (win), "Custom positioning");
overlay = gtk_overlay_new ();
gdk_rgba_parse (&color, "yellow");
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_widget_override_background_color (overlay, 0, &color);
G_GNUC_END_IGNORE_DEPRECATIONS
gtk_container_add (GTK_CONTAINER (win), overlay);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (overlay), grid);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Above"), 1, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Below"), 1, 2, 1, 1);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Left"), 0, 1, 1, 1);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Right"), 2, 1, 1, 1);
text = gtk_text_view_new ();
gtk_widget_set_size_request (text, 200, 200);
g_object_set (text, "margin", 5, NULL);
gtk_widget_set_hexpand (text, TRUE);
gtk_widget_set_vexpand (text, TRUE);
gtk_grid_attach (GTK_GRID (grid), text, 1, 1, 1, 1);
g_signal_connect (overlay, "get-child-position",
G_CALLBACK (get_child_position), text);
child = gtk_label_new ("Top left overlay");
gtk_widget_set_halign (child, GTK_ALIGN_START);
gtk_widget_set_valign (child, GTK_ALIGN_START);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_object_set (child, "margin", 1, NULL);
child = gtk_label_new ("Bottom right overlay");
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_widget_set_valign (child, GTK_ALIGN_END);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_object_set (child, "margin", 1, NULL);
return win;
}
/* test that margins and non-zero allocation x/y
* of the main widget are handled correctly
*/
static GtkWidget *
test_nonzerox (void)
{
GtkWidget *win;
GtkWidget *grid;
GtkWidget *overlay;
GtkWidget *text;
GtkWidget *child;
GdkRGBA color;
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (win), "Non-zero X");
grid = gtk_grid_new ();
g_object_set (grid, "margin", 5, NULL);
gtk_container_add (GTK_CONTAINER (win), grid);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Above"), 1, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Below"), 1, 2, 1, 1);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Left"), 0, 1, 1, 1);
gtk_grid_attach (GTK_GRID (grid), gtk_label_new ("Right"), 2, 1, 1, 1);
overlay = gtk_overlay_new ();
gdk_rgba_parse (&color, "red");
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_widget_override_background_color (overlay, 0, &color);
G_GNUC_END_IGNORE_DEPRECATIONS
gtk_grid_attach (GTK_GRID (grid), overlay, 1, 1, 1, 1);
text = gtk_text_view_new ();
gtk_widget_set_size_request (text, 200, 200);
gtk_widget_set_hexpand (text, TRUE);
gtk_widget_set_vexpand (text, TRUE);
gtk_container_add (GTK_CONTAINER (overlay), text);
child = gtk_label_new ("I'm the overlay");
gtk_widget_set_halign (child, GTK_ALIGN_START);
gtk_widget_set_valign (child, GTK_ALIGN_START);
g_object_set (child, "margin", 3, NULL);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
child = gtk_label_new ("No, I'm the overlay");
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_widget_set_valign (child, GTK_ALIGN_END);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_object_set (child, "margin", 3, NULL);
return win;
}
static void
gs_editor_refresh_choice (GsEditor *self)
{
GPtrArray *apps;
GtkContainer *container;
/* add all apps */
container = GTK_CONTAINER (gtk_builder_get_object (self->builder,
"flowbox_main"));
gs_container_remove_all (GTK_CONTAINER (container));
apps = as_store_get_apps (self->store);
for (guint i = 0; i < apps->len; i++) {
AsApp *item = g_ptr_array_index (apps, i);
GtkWidget *tile = NULL;
g_autoptr(GsApp) app = NULL;
app = gs_editor_convert_app (self, item);
tile = gs_summary_tile_new (app);
g_signal_connect (tile, "clicked",
G_CALLBACK (gs_editor_app_tile_clicked_cb),
self);
gtk_widget_set_visible (tile, TRUE);
gtk_widget_set_vexpand (tile, FALSE);
gtk_widget_set_hexpand (tile, FALSE);
gtk_widget_set_size_request (tile, 300, 50);
gtk_widget_set_valign (tile, GTK_ALIGN_START);
gtk_container_add (GTK_CONTAINER (container), tile);
}
}
static GtkWidget*
menu_contents (void)
{
GtkWidget *vbox;
GtkWidget *mi;
int i;
GtkWidget *frame;
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame),
GTK_SHADOW_OUT);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
i = 0;
while (i < 10)
{
char *str = g_strdup_printf (_("Fake menu item %d\n"), i + 1);
mi = gtk_label_new (str);
gtk_widget_set_halign (mi, GTK_ALIGN_START);
gtk_widget_set_valign (mi, GTK_ALIGN_CENTER);
g_free (str);
gtk_box_pack_start (GTK_BOX (vbox), mi, FALSE, FALSE, 0);
++i;
}
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show_all (frame);
return frame;
}
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
photos_print_notification_init (PhotosPrintNotification *self)
{
PhotosPrintNotificationPrivate *priv;
GtkWidget *image;
self->priv = photos_print_notification_get_instance_private (self);
priv = self->priv;
priv->ntfctn_mngr = g_object_ref_sink (photos_notification_manager_dup_singleton ());
priv->spinner = gtk_spinner_new ();
gtk_widget_set_size_request (priv->spinner, 16, 16);
gtk_container_add (GTK_CONTAINER (self), priv->spinner);
priv->status_label = gtk_label_new (NULL);
gtk_widget_set_halign (priv->status_label, GTK_ALIGN_START);
gtk_container_add (GTK_CONTAINER (self), priv->status_label);
image = gtk_image_new_from_icon_name (PHOTOS_ICON_PROCESS_STOP_SYMBOLIC, GTK_ICON_SIZE_INVALID);
gtk_widget_set_margin_bottom (image, 2);
gtk_widget_set_margin_top (image, 2);
gtk_image_set_pixel_size (GTK_IMAGE (image), 16);
priv->stop_button = gtk_button_new ();
gtk_widget_set_valign (priv->stop_button, GTK_ALIGN_CENTER);
gtk_button_set_image (GTK_BUTTON (priv->stop_button), image);
gtk_container_add (GTK_CONTAINER (self), priv->stop_button);
g_signal_connect_swapped (priv->stop_button,
"clicked",
G_CALLBACK (photos_print_notification_stop_clicked),
self);
}
GtkWidget *
gml_gtk_widget_new ()
{
GtkWidget *obj;
obj = g_object_new (GML_TYPE_GTK_WIDGET, NULL);
GmlGtkWidget *gml = GML_GTK_WIDGET (obj);
GtkGrid *grid = GTK_GRID (obj);
gml->clutter_widget = gtk_clutter_embed_new ();
gtk_widget_set_size_request (gml->clutter_widget, gml->width, gml->height);
gml->stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (gml->clutter_widget));
clutter_stage_set_color (CLUTTER_STAGE (gml->stage), &(gml->stage_color));
clutter_actor_show (gml->stage);
gtk_widget_set_vexpand (gml->clutter_widget, TRUE);
gtk_widget_set_valign (gml->clutter_widget, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (gml->clutter_widget, TRUE);
gtk_widget_set_halign (gml->clutter_widget, GTK_ALIGN_FILL);
gtk_grid_attach (grid, gml->clutter_widget, 0, 0, 1, 1);
return obj;
}
static GtkWidget*
dialog_contents (void)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *action_area;
GtkWidget *label;
GtkWidget *image;
GtkWidget *button;
vbox = gtk_vbox_new (FALSE, 0);
#if GTK_CHECK_VERSION (3, 0, 0)
action_area = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
#else
action_area = gtk_hbutton_box_new ();
#endif
gtk_button_box_set_layout (GTK_BUTTON_BOX (action_area),
GTK_BUTTONBOX_END);
button = gtk_button_new_from_stock (GTK_STOCK_OK);
gtk_box_pack_end (GTK_BOX (action_area),
button,
FALSE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (vbox), action_area,
FALSE, TRUE, 0);
update_spacings (vbox, action_area);
label = gtk_label_new (_("This is a sample message in a sample dialog"));
image = gtk_image_new_from_icon_name ("dialog-information",
GTK_ICON_SIZE_DIALOG);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_halign (image, GTK_ALIGN_CENTER);
gtk_widget_set_valign (image, GTK_ALIGN_START);
#else
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
#endif
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), image,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), label,
TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox),
hbox,
FALSE, FALSE, 0);
gtk_widget_show_all (vbox);
return vbox;
}
/* Function taken from gtkprintunixdialog.c */
static GtkWidget *
photos_print_setup_wrap_in_frame (const gchar *label, GtkWidget *child)
{
GtkWidget *frame;
GtkWidget *label_widget;
gchar *bold_text;
label_widget = gtk_label_new ("");
gtk_label_set_xalign (GTK_LABEL (label_widget), 0.0);
gtk_widget_show (label_widget);
bold_text = g_markup_printf_escaped ("<b>%s</b>", label);
gtk_label_set_markup (GTK_LABEL (label_widget), bold_text);
g_free (bold_text);
frame = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (frame), label_widget, FALSE, FALSE, 0);
gtk_widget_set_margin_start (child, 12);
gtk_widget_set_halign (child, GTK_ALIGN_FILL);
gtk_widget_set_valign (child, GTK_ALIGN_FILL);
gtk_box_pack_start (GTK_BOX (frame), child, FALSE, FALSE, 0);
gtk_widget_show (frame);
return frame;
}
static void
recursive_attach_view (int depth,
GtkTextView *view,
GtkTextChildAnchor *anchor)
{
GtkWidget *child_view;
GtkWidget *event_box;
GdkRGBA color;
if (depth > 4)
return;
child_view = gtk_text_view_new_with_buffer (gtk_text_view_get_buffer (view));
/* Event box is to add a black border around each child view */
event_box = gtk_event_box_new ();
gdk_rgba_parse (&color, "black");
gtk_widget_override_background_color (event_box, 0, &color);
gtk_widget_set_halign (child_view, GTK_ALIGN_FILL);
gtk_widget_set_valign (child_view, GTK_ALIGN_FILL);
gtk_container_add (GTK_CONTAINER (event_box), child_view);
gtk_text_view_add_child_at_anchor (view, event_box, anchor);
recursive_attach_view (depth + 1, GTK_TEXT_VIEW (child_view), anchor);
}
static void
photos_dropdown_add_manager (PhotosDropdown *self, PhotosBaseManager *mngr)
{
GMenu *menu;
GtkWidget *popover;
GtkWidget *w;
PhotosBaseModel *model;
model = photos_base_model_new (mngr);
self->models = g_list_prepend (self->models, g_object_ref (model));
/* HACK: see https://bugzilla.gnome.org/show_bug.cgi?id=733977 */
popover = gtk_popover_new (NULL);
menu = photos_base_model_get_model (model);
gtk_popover_bind_model (GTK_POPOVER (popover), G_MENU_MODEL (menu), "app");
w = g_object_ref (gtk_bin_get_child (GTK_BIN (popover)));
gtk_container_remove (GTK_CONTAINER (popover), w);
gtk_container_add (GTK_CONTAINER (self->grid), w);
g_object_unref (w);
gtk_widget_set_valign (w, GTK_ALIGN_START);
gtk_widget_set_vexpand (w, TRUE);
gtk_widget_destroy (popover);
g_object_unref (model);
}
/* test GTK_ALIGN_FILL handling */
static GtkWidget *
test_fullwidth (void)
{
GtkWidget *win;
GtkWidget *overlay;
GtkWidget *text;
GtkWidget *child;
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (win), "Full-width");
overlay = gtk_overlay_new ();
gtk_container_add (GTK_CONTAINER (win), overlay);
text = gtk_text_view_new ();
gtk_widget_set_size_request (text, 200, 200);
gtk_widget_set_hexpand (text, TRUE);
gtk_widget_set_vexpand (text, TRUE);
gtk_container_add (GTK_CONTAINER (overlay), text);
child = gtk_label_new ("Fullwidth top overlay");
gtk_widget_set_halign (child, GTK_ALIGN_FILL);
gtk_widget_set_valign (child, GTK_ALIGN_START);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_object_set (child, "margin", 4, NULL);
return win;
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_ratings_t *d = (dt_lib_ratings_t *)g_malloc0(sizeof(dt_lib_ratings_t));
self->data = (void *)d;
self->widget = gtk_drawing_area_new();
gtk_widget_set_halign(self->widget, GTK_ALIGN_CENTER);
gtk_widget_set_valign(self->widget, GTK_ALIGN_CENTER);
gtk_widget_set_events(self->widget, GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK
| GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
| GDK_STRUCTURE_MASK);
/* connect callbacks */
gtk_widget_set_app_paintable(self->widget, TRUE);
g_signal_connect(G_OBJECT(self->widget), "draw", G_CALLBACK(_lib_ratings_draw_callback), self);
g_signal_connect(G_OBJECT(self->widget), "button-press-event", G_CALLBACK(_lib_ratings_button_press_callback), self);
g_signal_connect(G_OBJECT(self->widget), "button-release-event", G_CALLBACK(_lib_ratings_button_release_callback),
self);
g_signal_connect(G_OBJECT(self->widget), "motion-notify-event", G_CALLBACK(_lib_ratings_motion_notify_callback), self);
g_signal_connect(G_OBJECT(self->widget), "leave-notify-event", G_CALLBACK(_lib_ratings_leave_notify_callback), self);
/* set size of navigation draw area */
gtk_widget_set_size_request(self->widget, (STAR_SIZE * 6) + (STAR_SPACING * 5), STAR_SIZE);
}
static void
setup_search (GtkAppChooserDialog *self)
{
gboolean use_header;
g_object_get (self, "use-header-bar", &use_header, NULL);
if (use_header)
{
GtkWidget *button;
GtkWidget *image;
GtkWidget *header;
button = gtk_toggle_button_new ();
gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
image = gtk_image_new_from_icon_name ("edit-find-symbolic", GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (button), image);
gtk_style_context_add_class (gtk_widget_get_style_context (button), "image-button");
gtk_style_context_remove_class (gtk_widget_get_style_context (button), "text-button");
gtk_widget_show (button);
header = gtk_dialog_get_header_bar (GTK_DIALOG (self));
gtk_header_bar_pack_end (GTK_HEADER_BAR (header), button);
g_object_bind_property (button, "active",
self->priv->search_bar, "search-mode-enabled",
G_BINDING_BIDIRECTIONAL);
g_object_bind_property (self->priv->search_entry, "sensitive",
button, "sensitive",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
}
}
static void
populate_action_arguments_grid (GtkWidget *grid,
GList *arguments,
GUPnPServiceActionArgDirection direction,
GUPnPServiceIntrospection *introspection)
{
GList *arg_node;
GtkWidget *last_aligner_grid = NULL;
g_assert (introspection != NULL);
prepare_action_arguments_grid (GTK_CONTAINER (grid),
direction,
arguments);
gtk_widget_set_size_request (dialog, 0, 0);
for (arg_node = arguments;
arg_node;
arg_node = arg_node->next) {
GUPnPServiceActionArgInfo *arg_info;
GtkWidget *aligner_grid;
GtkWidget *label;
GtkWidget *input_widget;
arg_info = (GUPnPServiceActionArgInfo *) arg_node->data;
/* First add the name */
/* GTK_ALIGN_START seems to have a bug in a size group:
* use a container for alignment */
aligner_grid = gtk_grid_new ();
gtk_grid_attach_next_to (GTK_GRID (grid),
aligner_grid,
last_aligner_grid,
GTK_POS_BOTTOM,
1, 1);
last_aligner_grid = aligner_grid;
label = gtk_label_new (arg_info->name);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_widget_set_vexpand (label, TRUE);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (aligner_grid), label,
0, 0, 1, 1);
gtk_size_group_add_widget (label_container_group,
aligner_grid);
gtk_widget_show_all (aligner_grid);
/* Then the input widget */
input_widget = create_widget_for_argument (arg_info,
introspection);
gtk_widget_set_hexpand (input_widget, TRUE);
gtk_grid_attach_next_to (GTK_GRID (grid),
input_widget,
aligner_grid,
GTK_POS_RIGHT,
1,1);
gtk_widget_show_all (input_widget);
}
}
GtkWidget *
do_css_accordion (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *container, *child;
GtkStyleProvider *provider;
GBytes *bytes;
gsize data_size;
const guint8 *data;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
gtk_window_set_default_size (GTK_WINDOW (window), 600, 300);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_set_halign (container, GTK_ALIGN_CENTER);
gtk_widget_set_valign (container, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (window), container);
child = gtk_button_new_with_label ("This");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("Is");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("A");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("CSS");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label ("Accordion");
gtk_container_add (GTK_CONTAINER (container), child);
child = gtk_button_new_with_label (":-)");
gtk_container_add (GTK_CONTAINER (container), child);
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
bytes = g_resources_lookup_data ("/css_accordion/css_accordion.css", 0, NULL);
data = g_bytes_get_data (bytes, &data_size);
gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (provider), (gchar *)data, data_size, NULL);
g_bytes_unref (bytes);
apply_css (window, provider);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
GtkWidget *
create_clipping_page (void)
{
GtkWidget *vbox, *scrolled_win, *canvas;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
g_object_set (vbox, "margin", 4, NULL);
gtk_widget_show (vbox);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_SHADOW_IN);
gtk_widget_show (scrolled_win);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_win);
gtk_widget_set_halign (scrolled_win, GTK_ALIGN_FILL);
gtk_widget_set_valign (scrolled_win, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (scrolled_win, TRUE);
gtk_widget_set_vexpand (scrolled_win, TRUE);
canvas = goo_canvas_new ();
gtk_widget_set_size_request (canvas, 600, 450);
goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 1000, 1000);
gtk_widget_show (canvas);
gtk_container_add (GTK_CONTAINER (scrolled_win), canvas);
setup_canvas (GOO_CANVAS (canvas));
return vbox;
}
static void
cc_search_panel_constructed (GObject *object)
{
CcSearchPanel *self = CC_SEARCH_PANEL (object);
GtkWidget *box, *widget, *search_box;
G_OBJECT_CLASS (cc_search_panel_parent_class)->constructed (object);
/* add the disable all switch */
search_box = WID ("search_vbox");
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
widget = gtk_switch_new ();
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 4);
g_settings_bind (self->priv->search_settings, "disable-external",
widget, "active",
G_SETTINGS_BIND_DEFAULT |
G_SETTINGS_BIND_INVERT_BOOLEAN);
g_object_bind_property (widget, "active",
search_box, "sensitive",
G_BINDING_DEFAULT |
G_BINDING_SYNC_CREATE);
gtk_widget_show_all (box);
cc_shell_embed_widget_in_header (cc_panel_get_shell (CC_PANEL (self)), box);
}
int main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *box;
GtkWidget *bu;
GtkWidget *w, *c;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add (GTK_CONTAINER (window), box);
w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 15);
gtk_box_pack_start (GTK_BOX (box), w, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (w), gtk_entry_new (), TRUE, TRUE, 0);
bu = gtk_button_new_with_label ("Bu");
gtk_box_pack_start (GTK_BOX (w), bu, TRUE, TRUE, 0);
c = gtk_switch_new ();
gtk_switch_set_active (GTK_SWITCH (c), TRUE);
gtk_widget_set_halign (c, GTK_ALIGN_CENTER);
gtk_widget_set_valign (c, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (box), c, TRUE, TRUE, 0);
g_signal_connect (bu, "clicked", G_CALLBACK (set_insensitive), w);
g_signal_connect (bu, "state-changed", G_CALLBACK (state_changed), NULL);
g_object_bind_property (c, "active", w, "sensitive", G_BINDING_BIDIRECTIONAL);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
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);
}
}
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
vertical_alignment_changed (GtkComboBox *box,
GtkFlowBox *flowbox)
{
GtkAlign alignment = gtk_combo_box_get_active (box);
gtk_widget_set_valign (GTK_WIDGET (flowbox), alignment);
}
