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;
}
int
main (int argc,
char **argv)
{
GdkPixbuf *pixbuf, *otherpix;
GtkWidget *image, *image2, *hbox, *vbox, *label, *toplevel;
GIcon *emblemed;
GEmblem *emblem;
gchar *str;
gtk_init (&argc, &argv);
pixbuf = gdk_pixbuf_new_from_file ("apple-red.png", NULL);
toplevel = gtk_window_new (GTK_WINDOW_TOPLEVEL);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_container_add (GTK_CONTAINER (toplevel), hbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
image = gtk_image_new_from_gicon (G_ICON (pixbuf), GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0);
label = gtk_label_new (NULL);
str = g_strdup_printf ("Normal icon, hash %u", g_icon_hash (G_ICON (pixbuf)));
gtk_label_set_label (GTK_LABEL (label), str);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
otherpix = gdk_pixbuf_new_from_file ("gnome-textfile.png", NULL);
emblem = g_emblem_new (G_ICON (otherpix));
emblemed = g_emblemed_icon_new (G_ICON (pixbuf), emblem);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
image2 = gtk_image_new_from_gicon (emblemed, GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start (GTK_BOX (vbox), image2, FALSE, FALSE, 0);
label = gtk_label_new (NULL);
str = g_strdup_printf ("Emblemed icon, hash %u", g_icon_hash (emblemed));
gtk_label_set_label (GTK_LABEL (label), str);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show_all (toplevel);
g_signal_connect (toplevel, "delete-event",
G_CALLBACK (gtk_main_quit), NULL);
gtk_main ();
return 0;
}
/* This function shows a menu for the user to select which item to launch. */
void show_menu(pqi inst)
{
menu_iter iter; int i = 0,
orient = mate_panel_applet_get_orient(inst->applet);
GtkMenu* menu = GTK_MENU(gtk_menu_new());
gboolean reverse;
if (inst->clicked && inst->items)
{
reverse = (orient == MATE_PANEL_APPLET_ORIENT_UP);
for (reverse? menu_iterate_rbegin(inst,&iter,inst->show_primary):menu_iterate_begin(inst,&iter,inst->show_primary); iter.valid; menu_iter_next(&iter))
{
GtkWidget *mi = gtk_image_menu_item_new(),
*lbl = gtk_label_new(iter.text),
*icon = gtk_image_new_from_gicon(iter.icon, GTK_ICON_SIZE_DND);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), icon);
gtk_image_menu_item_set_always_show_image(GTK_IMAGE_MENU_ITEM(mi), TRUE);
gtk_label_set_justify(GTK_LABEL(lbl),GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(lbl),0,0.5);
gtk_container_add(GTK_CONTAINER(mi),lbl);
gtk_widget_show_all(mi);
gtk_menu_insert(menu,mi,i++);
g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menu_launch), iter.si);
}
gtk_menu_attach_to_widget(menu,inst->box,NULL);
gtk_menu_popup(menu,NULL,NULL,set_to_corner, inst, 1, 0);
}
inst->clicked = FALSE;
}
static void
connect_proxy_cb (GtkActionGroup *action_group,
GtkAction *action,
GtkWidget *proxy,
gpointer dummy)
{
GtkLabel *label;
GIcon *icon;
if (!GTK_IS_MENU_ITEM (proxy))
return;
label = GTK_LABEL (gtk_bin_get_child (GTK_BIN (proxy)));
gtk_label_set_use_underline (label, FALSE);
gtk_label_set_ellipsize (label, PANGO_ELLIPSIZE_END);
gtk_label_set_max_width_chars (label, MENU_ITEM_MAX_WIDTH_CHARS);
icon = g_object_get_data (G_OBJECT (action), "menu-icon");
if (icon != NULL) {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy),
gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_MENU));
}
}
static GtkWidget *
menu_item_for_filename (UmPhotoDialog *um,
const char *filename)
{
GtkWidget *image, *menuitem;
GFile *file;
GIcon *icon;
file = g_file_new_for_path (filename);
icon = g_file_icon_new (file);
g_object_unref (file);
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
g_object_unref (icon);
menuitem = gtk_menu_item_new ();
gtk_container_add (GTK_CONTAINER (menuitem), image);
gtk_widget_show_all (menuitem);
g_object_set_data_full (G_OBJECT (menuitem), "filename",
g_strdup (filename), (GDestroyNotify) g_free);
g_signal_connect (G_OBJECT (menuitem), "activate",
G_CALLBACK (stock_icon_selected), um);
return menuitem;
}
static void
add_provider_to_list (GisGoaPage *page, const char *provider_type)
{
GisGoaPagePrivate *priv = gis_goa_page_get_instance_private (page);
GtkWidget *row;
GtkWidget *box;
GtkWidget *image;
GtkWidget *label;
GtkWidget *checkmark;
GtkWidget *account_label;
GIcon *icon;
gchar *markup;
GoaProvider *provider;
ProviderWidget *provider_widget;
provider = goa_provider_get_for_provider_type (provider_type);
if (provider == NULL)
return;
row = gtk_list_box_row_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_widget_set_hexpand (box, TRUE);
icon = goa_provider_get_provider_icon (provider, NULL);
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
markup = g_strdup_printf ("<b>%s</b>", goa_provider_get_provider_name (provider, NULL));
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), markup);
g_free (markup);
checkmark = gtk_image_new_from_icon_name ("object-select-symbolic", GTK_ICON_SIZE_MENU);
account_label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (box), image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
gtk_box_pack_end (GTK_BOX (box), checkmark, FALSE, FALSE, 8);
gtk_box_pack_end (GTK_BOX (box), account_label, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (row), box);
gtk_widget_show (label);
gtk_widget_show (image);
gtk_widget_show (box);
gtk_widget_show (row);
provider_widget = g_new0 (ProviderWidget, 1);
provider_widget->page = page;
provider_widget->provider = provider;
provider_widget->row = row;
provider_widget->checkmark = checkmark;
provider_widget->account_label = account_label;
g_object_set_data_full (G_OBJECT (row), "widget", provider_widget, g_free);
g_hash_table_insert (priv->providers, (char *) provider_type, provider_widget);
gtk_container_add (GTK_CONTAINER (priv->accounts_list), row);
}
static GtkWidget *
clone_image_menu_size (GtkImage *image)
{
GtkImageType storage_type = gtk_image_get_storage_type (image);
if (storage_type == GTK_IMAGE_STOCK)
{
gchar *stock_id;
GtkWidget *widget;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
gtk_image_get_stock (image, &stock_id, NULL);
widget = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);
G_GNUC_END_IGNORE_DEPRECATIONS;
return widget;
}
else if (storage_type == GTK_IMAGE_ICON_NAME)
{
const gchar *icon_name;
gtk_image_get_icon_name (image, &icon_name, NULL);
return gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
}
else if (storage_type == GTK_IMAGE_ICON_SET)
{
GtkWidget *widget;
GtkIconSet *icon_set;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
gtk_image_get_icon_set (image, &icon_set, NULL);
widget = gtk_image_new_from_icon_set (icon_set, GTK_ICON_SIZE_MENU);
G_GNUC_END_IGNORE_DEPRECATIONS;
return widget;
}
else if (storage_type == GTK_IMAGE_GICON)
{
GIcon *icon;
gtk_image_get_gicon (image, &icon, NULL);
return gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_MENU);
}
else if (storage_type == GTK_IMAGE_PIXBUF)
{
gint width, height;
if (gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &width, &height))
{
GdkPixbuf *src_pixbuf, *dest_pixbuf;
GtkWidget *cloned_image;
src_pixbuf = gtk_image_get_pixbuf (image);
dest_pixbuf = gdk_pixbuf_scale_simple (src_pixbuf, width, height,
GDK_INTERP_BILINEAR);
cloned_image = gtk_image_new_from_pixbuf (dest_pixbuf);
g_object_unref (dest_pixbuf);
return cloned_image;
}
}
return NULL;
}
static void
place_query_info_ready (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GtkWidget *row, *box, *w;
Place *place;
GFileInfo *info;
const gchar *desktop_path;
gchar *path;
info = g_file_query_info_finish (G_FILE (source), res, NULL);
if (!info)
return;
row = user_data;
place = g_object_get_data (G_OBJECT (row), "place");
g_clear_object (&place->cancellable);
box = gtk_bin_get_child (GTK_BIN (row));
/* FIXME: GLib is currently buggy and returns a non-existent icon name
* when asked for the desktop symbolic icon.
*/
desktop_path = g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP);
path = g_file_get_path (G_FILE (source));
if (g_strcmp0 (path, desktop_path) == 0)
place->icon = g_themed_icon_new ("folder-symbolic");
else
place->icon = g_object_ref (g_file_info_get_symbolic_icon (info));
if (g_strcmp0 (path, g_get_home_dir ()) == 0)
place->settings_key = TRACKER_KEY_SINGLE_DIRECTORIES;
else
place->settings_key = TRACKER_KEY_RECURSIVE_DIRECTORIES;
g_free (path);
w = gtk_image_new_from_gicon (place->icon, GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER (box), w);
w = gtk_label_new (place->display_name);
gtk_container_add (GTK_CONTAINER (box), w);
w = gtk_switch_new ();
gtk_box_pack_end (GTK_BOX (box), w, FALSE, FALSE, 0);
g_settings_bind_with_mapping (tracker_preferences, place->settings_key,
w, "active",
G_SETTINGS_BIND_DEFAULT,
switch_tracker_get_mapping,
switch_tracker_set_mapping,
place, NULL);
gtk_widget_show_all (row);
g_object_unref (info);
}
void
gdm_extension_list_add_extension (GdmExtensionList *extension_list,
GdmLoginExtension *extension)
{
GtkWidget *image;
GtkWidget *button;
GIcon *icon;
char *description;
if (extension_list->priv->extensions == NULL) {
button = gtk_radio_button_new (NULL);
} else {
GdmLoginExtension *previous_extension;
GtkRadioButton *previous_button;
previous_extension = GDM_LOGIN_EXTENSION (extension_list->priv->extensions->data);
previous_button = GTK_RADIO_BUTTON (g_object_get_data (G_OBJECT (previous_extension), "gdm-extension-list-button"));
button = gtk_radio_button_new_from_widget (previous_button);
}
g_object_set_data (G_OBJECT (extension), "gdm-extension-list-button", button);
g_object_set (G_OBJECT (button), "draw-indicator", FALSE, NULL);
g_object_set_data (G_OBJECT (button), "gdm-extension", extension);
g_signal_connect_swapped (button, "toggled",
G_CALLBACK (on_extension_toggled),
extension_list);
gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE);
gtk_widget_set_sensitive (button, gdm_login_extension_is_enabled (extension));
g_signal_connect_swapped (G_OBJECT (extension), "enabled",
G_CALLBACK (on_extension_enabled),
extension_list);
g_signal_connect_swapped (G_OBJECT (extension), "disabled",
G_CALLBACK (on_extension_disabled),
extension_list);
icon = gdm_login_extension_get_icon (extension);
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_SMALL_TOOLBAR);
g_object_unref (icon);
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (button), image);
description = gdm_login_extension_get_description (extension);
gtk_widget_set_tooltip_text (button, description);
g_free (description);
gtk_widget_show (button);
gtk_container_add (GTK_CONTAINER (extension_list->priv->box), button);
extension_list->priv->extensions = g_list_append (extension_list->priv->extensions,
g_object_ref (extension));
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) {
g_signal_emit (extension_list, signals[ACTIVATED], 0, extension);
}
}
GtkWidget *
get_icon (gchar *icon)
{
GIcon *gi;
GtkWidget *retval;
gi = g_themed_icon_new_with_default_fallbacks (icon);
retval = gtk_image_new_from_gicon (gi, GTK_ICON_SIZE_BUTTON);
g_object_unref (gi);
return retval;
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE image;
GtkWidget *widget = NULL;
rb_scan_args(argc, argv, "01", &image);
if (NIL_P(image)) {
widget = gtk_image_new();
} else if (TYPE(image) == T_HASH) {
VALUE stock, icon_name, icon_set, gicon, file, pixbuf, animation, size, buffer;
rbg_scan_options(image,
"stock", &stock,
"icon_name", &icon_name,
"icon_set", &icon_set,
"gicon", &gicon,
"file", &file,
"pixbuf", &pixbuf,
"animation", &animation,
"size", &size,
NULL);
if (!NIL_P(stock))
widget = gtk_image_new_from_stock(RVAL2GLIBID(stock, buffer), RVAL2GTKICONSIZE(size));
else if (!NIL_P(icon_name))
widget = gtk_image_new_from_icon_name(RVAL2CSTR(icon_name), RVAL2GTKICONSIZE(size));
else if (!NIL_P(icon_set))
widget = gtk_image_new_from_icon_set(RVAL2GTKICONSET(icon_set), RVAL2GTKICONSIZE(size));
else if (!NIL_P(gicon))
widget = gtk_image_new_from_gicon(RVAL2GICON(gicon), RVAL2GTKICONSIZE(size));
else if (!NIL_P(file))
widget = gtk_image_new_from_file(RVAL2CSTR(file));
else if (!NIL_P(pixbuf))
widget = gtk_image_new_from_pixbuf(RVAL2GDKPIXBUF(pixbuf));
else if (!NIL_P(animation))
widget = gtk_image_new_from_animation(RVAL2GDKPIXBUFANIMATION(animation));
} else {
GType gtype = RVAL2GTYPE(image);
if (gtype == GDK_TYPE_PIXBUF)
widget = gtk_image_new_from_pixbuf(RVAL2GDKPIXBUF(image));
else if (g_type_is_a(gtype, GDK_TYPE_PIXBUF_ANIMATION))
widget = gtk_image_new_from_animation(RVAL2GDKPIXBUFANIMATION(image));
}
if (!widget)
rb_raise(rb_eArgError, "Invalid arguments.");
RBGTK_INITIALIZE(self, widget);
return Qnil;
}
static GtkWidget *menu_item_new_with_icon_text(GIcon *icon, const char *text)
{
GtkWidget *menuitem = gtk_menu_item_new();
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
GtkWidget *image = gtk_image_new_from_gicon(icon, GTK_ICON_SIZE_LARGE_TOOLBAR);
GtkWidget *label = gtk_label_new(text);
gtk_image_set_pixel_size(GTK_IMAGE(image), 24);
gtk_box_pack_start(GTK_BOX(box), image, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(menuitem), box);
return menuitem;
}
/**
* gtk_action_create_icon:
* @action: the action object
* @icon_size: (type int): the size of the icon that should be created.
*
* This function is intended for use by action implementations to
* create icons displayed in the proxy widgets.
*
* Returns: (transfer none): a widget that displays the icon for this action.
*
* Since: 2.4
*/
GtkWidget *
gtk_action_create_icon (GtkAction *action, GtkIconSize icon_size)
{
g_return_val_if_fail (GTK_IS_ACTION (action), NULL);
if (action->private_data->stock_id &&
gtk_icon_factory_lookup_default (action->private_data->stock_id))
return gtk_image_new_from_stock (action->private_data->stock_id, icon_size);
else if (action->private_data->gicon)
return gtk_image_new_from_gicon (action->private_data->gicon, icon_size);
else if (action->private_data->icon_name)
return gtk_image_new_from_icon_name (action->private_data->icon_name, icon_size);
else
return NULL;
}
static void
setup_an_item (AppletUserMenu *menu,
GtkWidget *submenu,
int is_submenu)
{
GtkWidget *image = NULL;
menu->menuitem = gtk_image_menu_item_new_with_mnemonic (menu->text);
if (menu->gicon) {
image = gtk_image_new_from_gicon (menu->gicon,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu->menuitem),
image);
}
gtk_widget_show (menu->menuitem);
g_signal_connect (G_OBJECT (menu->menuitem), "destroy",
G_CALLBACK (gtk_widget_destroyed),
&menu->menuitem);
if(submenu)
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menu->menuitem);
/*if an item not a submenu*/
if (!is_submenu) {
g_signal_connect (menu->menuitem, "activate",
G_CALLBACK (applet_callback_callback),
menu);
g_signal_connect (submenu, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&menu->submenu);
/* if the item is a submenu and doesn't have it's menu
created yet*/
} else if (!menu->submenu) {
menu->submenu = gtk_menu_new ();
}
if(menu->submenu) {
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu->menuitem),
menu->submenu);
g_signal_connect (G_OBJECT (menu->submenu), "destroy",
G_CALLBACK (gtk_widget_destroyed),
&menu->submenu);
}
gtk_widget_set_sensitive(menu->menuitem,menu->sensitive);
}
static void set_icon(AnacondaDiskOverview *widget, const char *icon_name) {
GError *err = NULL;
GIcon *base_icon, *emblem_icon, *icon;
GEmblem *emblem = NULL;
gchar *file;
if (!icon_name)
return;
if (widget->priv->kind_icon)
gtk_widget_destroy(widget->priv->kind_icon);
if (widget->priv->chosen) {
base_icon = g_icon_new_for_string(icon_name, &err);
if (!base_icon) {
fprintf(stderr, "could not create icon: %s\n", err->message);
g_error_free(err);
return;
}
file = g_strdup_printf("%s/pixmaps/anaconda-selected-icon.svg", get_widgets_datadir());
emblem_icon = g_icon_new_for_string(file, &err);
g_free(file);
if (!emblem_icon) {
fprintf(stderr, "could not create emblem: %s\n", err->message);
g_error_free(err);
}
else {
emblem = g_emblem_new(emblem_icon);
}
icon = g_emblemed_icon_new(base_icon, emblem);
g_object_unref(base_icon);
}
else {
icon = g_icon_new_for_string(icon_name, &err);
if (!icon) {
fprintf(stderr, "could not create icon: %s\n", err->message);
g_error_free(err);
return;
}
}
widget->priv->kind_icon = gtk_image_new_from_gicon(icon, GTK_ICON_SIZE_DIALOG);
gtk_image_set_pixel_size(GTK_IMAGE(widget->priv->kind_icon), ICON_SIZE);
}
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
thunar_uca_editor_set_icon_name (ThunarUcaEditor *uca_editor,
const gchar *icon_name)
{
GIcon *icon = NULL;
GtkWidget *image;
GtkWidget *label;
g_return_if_fail (THUNAR_UCA_IS_EDITOR (uca_editor));
/* drop the previous button child */
if (gtk_bin_get_child (GTK_BIN (uca_editor->icon_button)) != NULL)
gtk_widget_destroy (gtk_bin_get_child (GTK_BIN (uca_editor->icon_button)));
/* setup the icon button */
if (icon_name != NULL)
icon = g_icon_new_for_string (icon_name, NULL);
if (G_LIKELY (icon != NULL))
{
/* setup an image for the icon */
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
g_object_set (image, "icon-size", GTK_ICON_SIZE_DND, NULL);
gtk_container_add (GTK_CONTAINER (uca_editor->icon_button), image);
gtk_widget_show (image);
/* remember the name for the icon */
g_object_set_data_full (G_OBJECT (uca_editor->icon_button), "thunar-uca-icon-name", g_strdup (icon_name), g_free);
/* release the icon */
g_object_unref (G_OBJECT (icon));
}
else
{
/* reset the remembered icon name */
g_object_set_data (G_OBJECT (uca_editor->icon_button), "thunar-uca-icon-name", NULL);
/* setup a label to tell that no icon was selected */
label = gtk_label_new (_("No icon"));
gtk_container_add (GTK_CONTAINER (uca_editor->icon_button), label);
gtk_widget_show (label);
}
}
static void
photos_dlna_renderers_dialog_add_renderer (PhotosDlnaRenderersDialog *self, PhotosDlnaRenderer *renderer)
{
PhotosDlnaRenderersDialogPrivate *priv = self->priv;
GIcon *icon;
GtkWidget *row;
GtkWidget *row_grid;
GtkWidget *image;
GtkWidget *label;
const gchar *name;
row = gtk_list_box_row_new ();
gtk_container_add (GTK_CONTAINER (priv->listbox), row);
row_grid = gtk_grid_new ();
gtk_container_set_border_width (GTK_CONTAINER (row_grid), 12);
gtk_orientable_set_orientation (GTK_ORIENTABLE (row_grid), GTK_ORIENTATION_HORIZONTAL);
gtk_grid_set_column_spacing (GTK_GRID (row_grid), 12);
gtk_container_add (GTK_CONTAINER (row), row_grid);
g_object_set_data_full (G_OBJECT (row), "renderer", renderer, g_object_unref);
name = photos_dlna_renderer_get_friendly_name (renderer);
icon = g_themed_icon_new_with_default_fallbacks (PHOTOS_ICON_VIDEO_DISPLAY_SYMBOLIC);
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
g_object_ref (image); /* keep a ref for the following async call and release it in the callback */
photos_dlna_renderer_get_icon (renderer,
"",
"",
GTK_ICON_SIZE_DIALOG,
NULL,
photos_dlna_renderers_dialog_set_icon_cb,
image);
gtk_container_add (GTK_CONTAINER (row_grid), image);
label = gtk_label_new (NULL);
gtk_label_set_text (GTK_LABEL (label), name);
gtk_container_add (GTK_CONTAINER (row_grid), label);
}
//gqk
static void
fcitx_im_widget_init(FcitxImWidget* self)
{
self->builder = gtk_builder_new();
gtk_builder_add_from_resource(self->builder, "/org/fcitx/fcitx-config-gtk3/im_widget.ui", NULL);
#define _GET_OBJECT(NAME) \
self->NAME = (typeof(self->NAME)) gtk_builder_get_object(self->builder, #NAME);
_GET_OBJECT(imstore)
_GET_OBJECT(imview)
_GET_OBJECT(addimbutton)
_GET_OBJECT(delimbutton)
_GET_OBJECT(moveupbutton)
_GET_OBJECT(movedownbutton)
_GET_OBJECT(configurebutton)
_GET_OBJECT(default_layout_button)
_GET_OBJECT(scrolledwindow)
_GET_OBJECT(toolbar)
GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->imview));
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(_fcitx_im_widget_im_selection_changed), self);
GtkStyleContext* context;
context = gtk_widget_get_style_context (self->scrolledwindow);
gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM);
context = gtk_widget_get_style_context (self->toolbar);
gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP);
gtk_style_context_add_class (context, "inline-toolbar");
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(self->addimbutton), gtk_image_new_from_gicon(g_themed_icon_new_with_default_fallbacks("list-add-symbolic"), GTK_ICON_SIZE_BUTTON));
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(self->delimbutton), gtk_image_new_from_gicon(g_themed_icon_new_with_default_fallbacks("list-remove-symbolic"), GTK_ICON_SIZE_BUTTON));
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(self->moveupbutton), gtk_image_new_from_gicon(g_themed_icon_new_with_default_fallbacks("go-up-symbolic"), GTK_ICON_SIZE_BUTTON));
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(self->movedownbutton), gtk_image_new_from_gicon(g_themed_icon_new_with_default_fallbacks("go-down-symbolic"), GTK_ICON_SIZE_BUTTON));
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(self->configurebutton), gtk_image_new_from_gicon(g_themed_icon_new_with_default_fallbacks("preferences-system-symbolic"), GTK_ICON_SIZE_BUTTON));
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(self->default_layout_button), gtk_image_new_from_gicon(g_themed_icon_new_with_default_fallbacks("input-keyboard-symbolic"), GTK_ICON_SIZE_BUTTON));
g_signal_connect(G_OBJECT(self->addimbutton), "clicked", G_CALLBACK(_fcitx_im_widget_addim_button_clicked), self);
g_signal_connect(G_OBJECT(self->delimbutton), "clicked", G_CALLBACK(_fcitx_im_widget_delim_button_clicked), self);
g_signal_connect(G_OBJECT(self->moveupbutton), "clicked", G_CALLBACK(_fcitx_im_widget_moveup_button_clicked), self);
g_signal_connect(G_OBJECT(self->movedownbutton), "clicked", G_CALLBACK(_fcitx_im_widget_movedown_button_clicked), self);
g_signal_connect(G_OBJECT(self->configurebutton), "clicked", G_CALLBACK(_fcitx_im_widget_configure_button_clicked), self);
g_signal_connect(G_OBJECT(self->default_layout_button), "clicked", G_CALLBACK(_fcitx_im_widget_default_layout_button_clicked), self);
g_signal_connect(G_OBJECT(self->imview), "row-activated", G_CALLBACK(_fcitx_im_widget_row_activated), self);
}
/* internal */
GtkWidget *get_close_tab_widget(Document *document)
{
GtkWidget *hbox;
GtkWidget *close_button;
hbox = gtk_hbox_new(FALSE, 0);
close_button = gedit_close_button_new ();
gtk_widget_set_tooltip_text(close_button, _("Close Tab"));
g_signal_connect(G_OBJECT(close_button), "clicked", G_CALLBACK(on_tab_close_activate), document);
/* load file icon */
GtkWidget *label;
GIcon *doc_icon;
g_object_get(document, "editor_label", &label, "icon", &doc_icon, NULL);
GtkWidget *icon= gtk_image_new_from_gicon (doc_icon, GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_widget_show (icon);
gtk_box_pack_start(GTK_BOX(hbox), icon, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
gtk_box_pack_end(GTK_BOX(hbox), close_button, FALSE, FALSE, 0);
gtk_widget_show(close_button);
gtk_widget_show(hbox);
return hbox;
}
GtkWidget *
do_images (GtkWidget *do_widget)
{
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *image;
GtkWidget *label;
GtkWidget *button;
GIcon *gicon;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Images");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
g_signal_connect (window, "destroy",
G_CALLBACK (cleanup_callback), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Image loaded from a file</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
image = gtk_image_new_from_icon_name ("gtk3-demo", GTK_ICON_SIZE_DIALOG);
gtk_container_add (GTK_CONTAINER (frame), image);
/* Animation */
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Animation loaded from a file</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
image = gtk_image_new_from_resource ("/images/floppybuddy.gif");
gtk_container_add (GTK_CONTAINER (frame), image);
/* Symbolic icon */
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Symbolic themed icon</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
gicon = g_themed_icon_new_with_default_fallbacks ("battery-caution-charging-symbolic");
image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_DIALOG);
gtk_container_add (GTK_CONTAINER (frame), image);
/* Progressive */
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Progressive image loading</u>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
/* Create an empty image for now; the progressive loader
* will create the pixbuf and fill it in.
*/
image = gtk_image_new_from_pixbuf (NULL);
gtk_container_add (GTK_CONTAINER (frame), image);
start_progressive_loading (image);
/* Sensitivity control */
button = gtk_toggle_button_new_with_mnemonic ("_Insensitive");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
g_signal_connect (button, "toggled",
G_CALLBACK (toggle_sensitivity_callback),
vbox);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
return window;
}
static void
bjb_empty_results_box_constructed (GObject *object)
{
BjbEmptyResultsBox *self;
BjbEmptyResultsBoxPrivate *priv;
GtkStyleContext *context;
GtkWidget *labels_grid;
gchar *label, *markup;
GFile *note_icon_file;
GIcon *icon;
G_OBJECT_CLASS (bjb_empty_results_box_parent_class)->constructed (object);
self = BJB_EMPTY_RESULTS_BOX (object);
priv = self->priv;
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_HORIZONTAL);
gtk_grid_set_column_spacing (GTK_GRID (self), 12);
context = gtk_widget_get_style_context (GTK_WIDGET (self));
gtk_style_context_add_class (context, "dim-label");
note_icon_file = g_file_new_for_uri ("resource://org/gnome/bijiben/note-symbolic.svg");
icon = g_file_icon_new (note_icon_file);
g_object_unref (note_icon_file);
priv->image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
g_object_unref (icon);
gtk_container_add (GTK_CONTAINER (self), priv->image);
labels_grid = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (labels_grid), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_row_spacing (GTK_GRID (labels_grid), 0);
gtk_widget_set_valign (labels_grid, GTK_ALIGN_START);
gtk_container_add (GTK_CONTAINER (self), labels_grid);
label = _("No notes");
markup = g_markup_printf_escaped ("<big><b>%s</b></big>", label);
priv->primary_label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (priv->primary_label), markup);
g_free (markup);
gtk_widget_set_halign (priv->primary_label, GTK_ALIGN_START);
gtk_widget_set_vexpand (priv->primary_label, TRUE);
gtk_label_set_use_markup (GTK_LABEL (priv->primary_label), TRUE);
gtk_container_add (GTK_CONTAINER (labels_grid), priv->primary_label);
self->priv->type = BJB_EMPTY_RESULTS_TYPE;
label = "";
self->priv->details_label = GTK_LABEL (gtk_label_new (label));
gtk_label_set_use_markup (GTK_LABEL (self->priv->details_label), TRUE);
gtk_widget_set_halign (priv->primary_label, GTK_ALIGN_START);
// xalign: 0,
// max_width_chars: 24,
// wrap: true
gtk_container_add (GTK_CONTAINER (labels_grid), GTK_WIDGET (self->priv->details_label));
gtk_widget_set_valign (priv->primary_label, GTK_ALIGN_CENTER);
gtk_widget_show_all (GTK_WIDGET (self));
}
static void
search_panel_add_one_app_info (CcSearchPanel *self,
GAppInfo *app_info,
gboolean default_enabled)
{
GtkWidget *row, *box, *w;
GIcon *icon;
/* gnome-control-center is special cased in the shell,
and is not configurable */
if (g_strcmp0 (g_app_info_get_id (app_info),
"gnome-control-center.desktop") == 0)
return;
/* reset valignment of the list box */
gtk_widget_set_valign (self->priv->list_box, GTK_ALIGN_FILL);
row = gtk_list_box_row_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_container_add (GTK_CONTAINER (row), box);
gtk_widget_set_hexpand (box, TRUE);
gtk_container_set_border_width (GTK_CONTAINER (box), 6);
g_object_set_data_full (G_OBJECT (row), "app-info",
g_object_ref (app_info), g_object_unref);
g_object_set_data (G_OBJECT (row), "self", self);
gtk_container_add (GTK_CONTAINER (self->priv->list_box), row);
icon = g_app_info_get_icon (app_info);
if (icon == NULL)
icon = g_themed_icon_new ("application-x-executable");
else
g_object_ref (icon);
w = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
gtk_container_add (GTK_CONTAINER (box), w);
g_object_unref (icon);
w = gtk_label_new (g_app_info_get_name (app_info));
gtk_container_add (GTK_CONTAINER (box), w);
w = gtk_switch_new ();
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_box_pack_end (GTK_BOX (box), w, FALSE, FALSE, 0);
if (default_enabled)
{
g_settings_bind_with_mapping (self->priv->search_settings, "disabled",
w, "active",
G_SETTINGS_BIND_DEFAULT,
switch_settings_mapping_get_default_enabled,
switch_settings_mapping_set_default_enabled,
row, NULL);
}
else
{
g_settings_bind_with_mapping (self->priv->search_settings, "enabled",
w, "active",
G_SETTINGS_BIND_DEFAULT,
switch_settings_mapping_get_default_disabled,
switch_settings_mapping_set_default_disabled,
row, NULL);
}
gtk_widget_show_all (row);
}
/* returns TRUE if a folder window should be opened */
static gboolean
do_autorun_for_content_type (GMount *mount,
const char *x_content_type,
CsdAutorunOpenWindow open_window_func,
gpointer user_data)
{
AutorunDialogData *data;
GtkWidget *dialog;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *combo_box;
GtkWidget *always_check_button;
GtkWidget *eject_button;
GtkWidget *image;
char *markup;
char *content_description;
char *mount_name;
GIcon *icon;
GdkPixbuf *pixbuf;
int icon_size;
gboolean user_forced_dialog;
gboolean pref_ask;
gboolean pref_start_app;
gboolean pref_ignore;
gboolean pref_open_folder;
char *media_greeting;
gboolean ret;
ret = FALSE;
mount_name = NULL;
if (g_content_type_is_a (x_content_type, "x-content/win32-software")) {
/* don't pop up the dialog anyway if the content type says
* windows software.
*/
goto out;
}
user_forced_dialog = is_shift_pressed ();
csd_autorun_get_preferences (x_content_type, &pref_start_app, &pref_ignore, &pref_open_folder);
pref_ask = !pref_start_app && !pref_ignore && !pref_open_folder;
if (user_forced_dialog) {
goto show_dialog;
}
if (!pref_ask && !pref_ignore && !pref_open_folder) {
GAppInfo *app_info;
app_info = g_app_info_get_default_for_type (x_content_type, FALSE);
if (app_info != NULL) {
csd_autorun_launch_for_mount (mount, app_info);
}
goto out;
}
if (pref_open_folder) {
ret = TRUE;
goto out;
}
if (pref_ignore) {
goto out;
}
show_dialog:
mount_name = g_mount_get_name (mount);
dialog = gtk_dialog_new ();
hbox = gtk_hbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
icon = g_mount_get_icon (mount);
icon_size = get_icon_size_for_stock_size (GTK_ICON_SIZE_DIALOG);
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
pixbuf = render_icon (icon, icon_size);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox), image, TRUE, TRUE, 0);
/* also use the icon on the dialog */
gtk_window_set_title (GTK_WINDOW (dialog), mount_name);
gtk_window_set_icon (GTK_WINDOW (dialog), pixbuf);
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
g_object_unref (icon);
if (pixbuf) {
g_object_unref (pixbuf);
}
vbox = gtk_vbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
label = gtk_label_new (NULL);
/* Customize greeting for well-known x-content types */
if (strcmp (x_content_type, "x-content/audio-cdda") == 0) {
media_greeting = _("You have just inserted an Audio CD.");
} else if (strcmp (x_content_type, "x-content/audio-dvd") == 0) {
media_greeting = _("You have just inserted an Audio DVD.");
} else if (strcmp (x_content_type, "x-content/video-dvd") == 0) {
media_greeting = _("You have just inserted a Video DVD.");
} else if (strcmp (x_content_type, "x-content/video-vcd") == 0) {
media_greeting = _("You have just inserted a Video CD.");
} else if (strcmp (x_content_type, "x-content/video-svcd") == 0) {
media_greeting = _("You have just inserted a Super Video CD.");
} else if (strcmp (x_content_type, "x-content/blank-cd") == 0) {
media_greeting = _("You have just inserted a blank CD.");
} else if (strcmp (x_content_type, "x-content/blank-dvd") == 0) {
media_greeting = _("You have just inserted a blank DVD.");
} else if (strcmp (x_content_type, "x-content/blank-cd") == 0) {
media_greeting = _("You have just inserted a blank Blu-Ray disc.");
} else if (strcmp (x_content_type, "x-content/blank-cd") == 0) {
media_greeting = _("You have just inserted a blank HD DVD.");
} else if (strcmp (x_content_type, "x-content/image-photocd") == 0) {
media_greeting = _("You have just inserted a Photo CD.");
} else if (strcmp (x_content_type, "x-content/image-picturecd") == 0) {
media_greeting = _("You have just inserted a Picture CD.");
} else if (strcmp (x_content_type, "x-content/image-dcf") == 0) {
media_greeting = _("You have just inserted a medium with digital photos.");
} else if (strcmp (x_content_type, "x-content/audio-player") == 0) {
media_greeting = _("You have just inserted a digital audio player.");
} else if (g_content_type_is_a (x_content_type, "x-content/software")) {
media_greeting = _("You have just inserted a medium with software intended to be automatically started.");
} else {
/* fallback to generic greeting */
media_greeting = _("You have just inserted a medium.");
}
markup = g_strdup_printf ("<big><b>%s %s</b></big>", media_greeting, _("Choose what application to launch."));
gtk_label_set_markup (GTK_LABEL (label), markup);
g_free (markup);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
label = gtk_label_new (NULL);
content_description = g_content_type_get_description (x_content_type);
markup = g_strdup_printf (_("Select how to open \"%s\" and whether to perform this action in the future for other media of type \"%s\"."), mount_name, content_description);
g_free (content_description);
gtk_label_set_markup (GTK_LABEL (label), markup);
g_free (markup);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
data = g_new0 (AutorunDialogData, 1);
data->dialog = dialog;
data->mount = g_object_ref (mount);
data->remember = !pref_ask;
data->selected_ignore = pref_ignore;
data->x_content_type = g_strdup (x_content_type);
data->selected_app = g_app_info_get_default_for_type (x_content_type, FALSE);
data->open_window_func = open_window_func;
data->user_data = user_data;
combo_box = gtk_app_chooser_button_new (x_content_type);
prepare_combo_box (combo_box, data);
g_signal_connect (G_OBJECT (combo_box),
"key-press-event",
G_CALLBACK (combo_box_enter_ok),
dialog);
gtk_box_pack_start (GTK_BOX (vbox), combo_box, TRUE, TRUE, 0);
always_check_button = gtk_check_button_new_with_mnemonic (_("_Always perform this action"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (always_check_button), data->remember);
g_signal_connect (G_OBJECT (always_check_button),
"toggled",
G_CALLBACK (autorun_always_toggled),
data);
gtk_box_pack_start (GTK_BOX (vbox), always_check_button, TRUE, TRUE, 0);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
if (g_mount_can_eject (mount)) {
GtkWidget *eject_image;
eject_button = gtk_button_new_with_mnemonic (_("_Eject"));
eject_image = gtk_image_new_from_icon_name ("media-eject", GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (eject_button), eject_image);
data->should_eject = TRUE;
} else {
eject_button = gtk_button_new_with_mnemonic (_("_Unmount"));
data->should_eject = FALSE;
}
gtk_dialog_add_action_widget (GTK_DIALOG (dialog), eject_button, AUTORUN_DIALOG_RESPONSE_EJECT);
gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dialog))), eject_button, TRUE);
/* show the dialog */
gtk_widget_show_all (dialog);
g_signal_connect (G_OBJECT (dialog),
"response",
G_CALLBACK (autorun_dialog_response),
data);
g_signal_connect (G_OBJECT (data->mount),
"unmounted",
G_CALLBACK (autorun_dialog_mount_unmounted),
data);
out:
g_free (mount_name);
return ret;
}
void main_window_enable_csd(MainWindow *wnd)
{
GIcon *open_icon;
GIcon *fullscreen_icon;
GIcon *menu_icon;
open_icon = g_themed_icon_new_with_default_fallbacks
("list-add-symbolic");
fullscreen_icon = g_themed_icon_new_with_default_fallbacks
("view-fullscreen-symbolic");
menu_icon = g_themed_icon_new_with_default_fallbacks
("view-list-symbolic");
wnd->playlist_width = PLAYLIST_DEFAULT_WIDTH+PLAYLIST_CSD_OFFSET;
wnd->open_hdr_btn = gtk_menu_button_new();
wnd->fullscreen_hdr_btn = gtk_button_new();
wnd->menu_hdr_btn = gtk_menu_button_new();
gtk_widget_set_can_focus(wnd->open_hdr_btn, FALSE);
gtk_widget_set_can_focus(wnd->fullscreen_hdr_btn, FALSE);
gtk_widget_set_can_focus(wnd->menu_hdr_btn, FALSE);
gtk_button_set_image
( GTK_BUTTON(wnd->fullscreen_hdr_btn),
gtk_image_new_from_gicon
(fullscreen_icon, GTK_ICON_SIZE_MENU ));
gtk_button_set_image
( GTK_BUTTON(wnd->open_hdr_btn),
gtk_image_new_from_gicon
(open_icon, GTK_ICON_SIZE_MENU ));
gtk_button_set_image
( GTK_BUTTON(wnd->menu_hdr_btn),
gtk_image_new_from_gicon
(menu_icon, GTK_ICON_SIZE_MENU ));
gtk_menu_button_set_menu_model
( GTK_MENU_BUTTON(wnd->open_hdr_btn),
G_MENU_MODEL(open_btn_build_menu()) );
gtk_menu_button_set_menu_model
( GTK_MENU_BUTTON(wnd->menu_hdr_btn),
G_MENU_MODEL(menu_btn_build_menu()) );
gtk_header_bar_pack_start
(GTK_HEADER_BAR(wnd->header_bar), wnd->open_hdr_btn);
gtk_header_bar_pack_end
(GTK_HEADER_BAR(wnd->header_bar), wnd->menu_hdr_btn);
gtk_header_bar_pack_end
(GTK_HEADER_BAR(wnd->header_bar), wnd->fullscreen_hdr_btn);
gtk_actionable_set_action_name
(GTK_ACTIONABLE(wnd->fullscreen_hdr_btn), "app.fullscreen");
gtk_paned_set_position( GTK_PANED(wnd->vid_area_paned),
MAIN_WINDOW_DEFAULT_WIDTH
-PLAYLIST_DEFAULT_WIDTH
-PLAYLIST_CSD_OFFSET );
gtk_window_set_titlebar(GTK_WINDOW(wnd), wnd->header_bar);
gtk_window_set_title(GTK_WINDOW(wnd), g_get_application_name());
}
void _fcitx_main_window_add_addon_page(FcitxMainWindow* self)
{
/* load addon */
FcitxAddon* addon;
utarray_new(self->addons, &addonicd);
FcitxAddonsLoad(self->addons);
GtkWidget* vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
/* advance check box */
self->advancecheckbox = gtk_check_button_new_with_label(_("Advance"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->advancecheckbox), FALSE);
g_signal_connect(G_OBJECT(self->advancecheckbox), "toggled", G_CALLBACK(_fcitx_main_window_checkbox_changed), self);
/* filter entry */
self->filterentry = gtk_entry_new();
gtk_entry_set_icon_from_gicon (GTK_ENTRY (self->filterentry),
GTK_ENTRY_ICON_SECONDARY,
g_themed_icon_new_with_default_fallbacks("edit-clear"));
g_object_set(G_OBJECT(self->filterentry), "margin", 5, NULL);
#if GTK_CHECK_VERSION(3,2,0)
gtk_entry_set_placeholder_text(GTK_ENTRY (self->filterentry), _("Search Addon"));
#endif
g_signal_connect(G_OBJECT(self->filterentry), "icon-press", G_CALLBACK (icon_press_cb), NULL);
/* list view */
self->addonstore = gtk_list_store_new(N_COLUMNS, G_TYPE_POINTER);
for (addon = (FcitxAddon *) utarray_front(self->addons);
addon != NULL;
addon = (FcitxAddon *) utarray_next(self->addons, addon)) {
GtkTreeIter iter;
gtk_list_store_append(self->addonstore, &iter);
gtk_list_store_set(self->addonstore, &iter, LIST_ADDON, addon, -1);
}
self->filtermodel = gtk_tree_model_filter_new(GTK_TREE_MODEL(self->addonstore), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(self->filtermodel),
(GtkTreeModelFilterVisibleFunc) _filter_addon_func,
self,
NULL);
self->addonview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(self->filtermodel));
/* add column check box */
self->togglecell = gtk_cell_renderer_toggle_new();
self->checkboxcolumn = gtk_tree_view_column_new_with_attributes("Enable", self->togglecell, NULL);
gtk_tree_view_column_set_visible(self->checkboxcolumn, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(self->addonview), self->checkboxcolumn);
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(self->checkboxcolumn),
self->togglecell,
_fcitx_main_window_enabled_data_func,
NULL,
NULL);
/* add column text */
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("Name", renderer, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(self->addonview), column);
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(column),
renderer,
_fcitx_main_window_name_data_func,
NULL,
NULL);
/* add addon list to vbox */
GtkWidget* swin = gtk_scrolled_window_new(NULL, NULL);
g_object_set(swin, "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
g_object_set(self->addonview, "headers-visible", FALSE, NULL);
gtk_container_add(GTK_CONTAINER(swin), self->addonview);
gtk_box_pack_start(GTK_BOX(vbox), swin, TRUE, TRUE, 0);
g_object_set(G_OBJECT(swin), "margin-left", 5, "margin-right", 5, "shadow-type", GTK_SHADOW_IN, NULL);
g_signal_connect(G_OBJECT(self->togglecell), "toggled",
G_CALLBACK(_fcitx_main_window_toggled_cb), GTK_TREE_MODEL(self->addonstore));
gtk_box_pack_start(GTK_BOX(vbox), self->advancecheckbox, FALSE, TRUE, 0);
g_object_set(G_OBJECT(self->advancecheckbox), "margin-left", 5, "margin-right", 5, NULL);
gtk_box_pack_start(GTK_BOX(vbox), self->filterentry, FALSE, TRUE, 5);
/* configure button */
GtkWidget* hbuttonbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(vbox), hbuttonbox, FALSE, TRUE, 0);
g_object_set(G_OBJECT(hbuttonbox), "margin", 5, NULL);
self->button = gtk_button_new_with_label(_("Configure"));
gtk_widget_set_sensitive(self->button, FALSE);
gtk_button_set_image(GTK_BUTTON(self->button), gtk_image_new_from_gicon(g_themed_icon_new_with_default_fallbacks("preferences-system"), GTK_ICON_SIZE_BUTTON));
gtk_box_pack_start(GTK_BOX(hbuttonbox), self->button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(self->button), "clicked", G_CALLBACK(_fcitx_main_window_configure_button_clicked), self);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->addonview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(_fcitx_main_window_addon_selection_changed), self);
g_signal_connect(G_OBJECT(self->filterentry), "changed", G_CALLBACK(_fcitx_main_window_filtertext_changed), self);
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(self->filtermodel));
g_signal_connect(G_OBJECT(self->addonview),
"row-activated",
G_CALLBACK(_fcitx_main_window_addon_row_activated), self);
_fcitx_main_window_add_page(self, _("Addon"), vbox);
}
int
main (int argc, char **argv)
{
GtkWidget *window, *grid;
GtkWidget *label, *image, *box;
GtkIconTheme *theme;
GdkPixbuf *pixbuf;
GtkIconSet *iconset;
GtkIconSource *iconsource;
gchar *icon_name = "gnome-terminal";
gchar *anim_filename = NULL;
GIcon *icon;
GFile *file;
gtk_init (&argc, &argv);
if (argc > 1)
icon_name = argv[1];
if (argc > 2)
anim_filename = argv[2];
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), grid);
label = gtk_label_new ("symbolic size");
gtk_grid_attach (GTK_GRID (grid), label, 1, 0, 1, 1);
label = gtk_label_new ("fixed size");
gtk_grid_attach (GTK_GRID (grid), label, 2, 0, 1, 1);
label = gtk_label_new ("GTK_IMAGE_PIXBUF");
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
theme = gtk_icon_theme_get_default ();
pixbuf = gtk_icon_theme_load_icon (theme, icon_name, 48, 0, NULL);
image = gtk_image_new_from_pixbuf (pixbuf);
box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (box), image);
gtk_grid_attach (GTK_GRID (grid), box, 2, 1, 1, 1);
gtk_drag_source_set (box, GDK_BUTTON1_MASK,
NULL, 0,
GDK_ACTION_COPY);
gtk_drag_source_add_image_targets (box);
g_signal_connect (box, "drag_begin", G_CALLBACK (drag_begin), image);
g_signal_connect (box, "drag_data_get", G_CALLBACK (drag_data_get), image);
gtk_drag_dest_set (box,
GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT |
GTK_DEST_DEFAULT_DROP,
NULL, 0, GDK_ACTION_COPY);
gtk_drag_dest_add_image_targets (box);
g_signal_connect (box, "drag_data_received",
G_CALLBACK (drag_data_received), image);
label = gtk_label_new ("GTK_IMAGE_STOCK");
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
image = gtk_image_new_from_stock (GTK_STOCK_REDO, GTK_ICON_SIZE_DIALOG);
gtk_grid_attach (GTK_GRID (grid), image, 1, 2, 1, 1);
label = gtk_label_new ("GTK_IMAGE_ICON_SET");
gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1);
iconsource = gtk_icon_source_new ();
gtk_icon_source_set_icon_name (iconsource, icon_name);
iconset = gtk_icon_set_new ();
gtk_icon_set_add_source (iconset, iconsource);
image = gtk_image_new_from_icon_set (iconset, GTK_ICON_SIZE_DIALOG);
gtk_grid_attach (GTK_GRID (grid), image, 1, 3, 1, 1);
label = gtk_label_new ("GTK_IMAGE_ICON_NAME");
gtk_grid_attach (GTK_GRID (grid), label, 0, 4, 1, 1);
image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG);
gtk_grid_attach (GTK_GRID (grid), image, 1, 4, 1, 1);
image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG);
gtk_image_set_pixel_size (GTK_IMAGE (image), 30);
gtk_grid_attach (GTK_GRID (grid), image, 2, 4, 1, 1);
label = gtk_label_new ("GTK_IMAGE_GICON");
gtk_grid_attach (GTK_GRID (grid), label, 0, 5, 1, 1);
icon = g_themed_icon_new_with_default_fallbacks ("folder-remote");
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
g_object_unref (icon);
gtk_grid_attach (GTK_GRID (grid), image, 1, 5, 1, 1);
file = g_file_new_for_path ("apple-red.png");
icon = g_file_icon_new (file);
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
g_object_unref (icon);
gtk_image_set_pixel_size (GTK_IMAGE (image), 30);
gtk_grid_attach (GTK_GRID (grid), image, 2, 5, 1, 1);
if (anim_filename)
{
label = gtk_label_new ("GTK_IMAGE_ANIMATION (from file)");
gtk_grid_attach (GTK_GRID (grid), label, 0, 6, 1, 1);
image = gtk_image_new_from_file (anim_filename);
gtk_image_set_pixel_size (GTK_IMAGE (image), 30);
gtk_grid_attach (GTK_GRID (grid), image, 2, 6, 1, 1);
/* produce high load */
g_signal_connect_after (image, "draw",
G_CALLBACK (anim_image_draw),
NULL);
}
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static void
brasero_project_type_chooser_build_recent (BraseroProjectTypeChooser *self,
GtkRecentManager *recent)
{
GtkSizeGroup *image_group;
GtkSizeGroup *group;
GList *list = NULL;
gchar *filename;
GList *recents;
GList *iter;
recents = gtk_recent_manager_get_items (recent);
for (iter = recents; iter; iter = iter->next) {
GtkRecentInfo *info;
const gchar *mime;
info = iter->data;
mime = gtk_recent_info_get_mime_type (info);
if (!mime)
continue;
/* filter those we want */
if (strcmp (mime, "application/x-brasero")
&& strcmp (mime, "application/x-cd-image")
&& strcmp (mime, "application/x-cdrdao-toc")
&& strcmp (mime, "application/x-toc")
&& strcmp (mime, "application/x-cue")
&& strcmp (mime, "audio/x-scpls")
&& strcmp (mime, "audio/x-ms-asx")
&& strcmp (mime, "audio/x-mp3-playlist")
&& strcmp (mime, "audio/x-mpegurl"))
continue;
/* sort */
list = g_list_insert_sorted (list,
info,
brasero_project_type_chooser_sort_recent);
if (g_list_length (list) > 5)
list = g_list_delete_link (list, g_list_last (list));
}
group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
image_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
/* If a project was left unfinished last time then add another entry */
filename = g_build_filename (g_get_user_config_dir (),
"brasero",
BRASERO_SESSION_TMP_PROJECT_PATH,
NULL);
if (g_file_test (filename, G_FILE_TEST_EXISTS)) {
gchar *uri;
GtkWidget *link;
GtkWidget *image;
uri = g_filename_to_uri (filename, NULL, NULL);
image = gtk_image_new_from_icon_name ("brasero", GTK_ICON_SIZE_BUTTON);
gtk_size_group_add_widget (image_group, image);
link = gtk_button_new_with_label (_("Last _Unsaved Project"));
g_object_set_data_full (G_OBJECT (link),
"BraseroButtonURI", uri,
g_free);
gtk_button_set_relief (GTK_BUTTON (link), GTK_RELIEF_NONE);
gtk_button_set_alignment (GTK_BUTTON (link), 0.0, 0.5);
gtk_button_set_focus_on_click (GTK_BUTTON (link), FALSE);
gtk_button_set_image (GTK_BUTTON (link), image);
gtk_button_set_use_underline (GTK_BUTTON (link), TRUE);
g_signal_connect (link,
"clicked",
G_CALLBACK (brasero_project_type_chooser_last_unsaved_clicked_cb),
self);
gtk_widget_show (link);
gtk_widget_set_tooltip_text (link, _("Load the last project that was not burned and not saved"));
gtk_box_pack_start (GTK_BOX (self->priv->recent_box), link, FALSE, TRUE, 0);
gtk_size_group_add_widget (group, link);
}
g_free (filename);
for (iter = list; iter; iter = iter->next) {
GtkRecentInfo *info;
GList *child_iter;
const gchar *name;
GIcon *icon;
GtkWidget *image;
const gchar *uri;
GtkWidget *child;
GtkWidget *link;
GList *children;
gchar *tooltip;
info = iter->data;
tooltip = gtk_recent_info_get_uri_display (info);
icon = gtk_recent_info_get_gicon (info);
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_BUTTON);
g_object_unref (icon);
gtk_size_group_add_widget (image_group, image);
gtk_widget_show (image);
gtk_widget_set_tooltip_text (image, tooltip);
name = gtk_recent_info_get_display_name (info);
uri = gtk_recent_info_get_uri (info);
/* Don't use mnemonics with filenames */
link = gtk_button_new_with_label (name);
g_object_set_data_full (G_OBJECT (link),
"BraseroButtonURI", g_strdup (uri),
g_free);
gtk_button_set_relief (GTK_BUTTON (link), GTK_RELIEF_NONE);
gtk_button_set_image (GTK_BUTTON (link), image);
gtk_button_set_alignment (GTK_BUTTON (link), 0.0, 0.5);
gtk_button_set_focus_on_click (GTK_BUTTON (link), FALSE);
g_signal_connect (link,
"clicked",
G_CALLBACK (brasero_project_type_chooser_recent_clicked_cb),
self);
gtk_widget_show (link);
gtk_widget_set_tooltip_text (link, tooltip);
gtk_box_pack_start (GTK_BOX (self->priv->recent_box), link, FALSE, TRUE, 0);
g_free (tooltip);
gtk_size_group_add_widget (group, link);
/* That's a tedious hack to avoid mnemonics which are hardcoded
* when you add an image to a button. BUG? */
if (!GTK_IS_BIN (link))
continue;
child = gtk_bin_get_child (GTK_BIN (link));
if (!GTK_IS_ALIGNMENT (child))
continue;
gtk_alignment_set (GTK_ALIGNMENT (child),
0.0,
0.5,
1.0,
1.0);
child = gtk_bin_get_child (GTK_BIN (child));
if (!GTK_IS_BOX (child))
continue;
children = gtk_container_get_children (GTK_CONTAINER (child));
for (child_iter = children; child_iter; child_iter = child_iter->next) {
GtkWidget *widget;
widget = child_iter->data;
if (GTK_IS_LABEL (widget)) {
gtk_label_set_use_underline (GTK_LABEL (widget), FALSE);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
/* Make sure that the name is not too long */
gtk_box_set_child_packing (GTK_BOX (child),
widget,
TRUE,
TRUE,
0,
GTK_PACK_START);
gtk_label_set_ellipsize (GTK_LABEL (widget),
PANGO_ELLIPSIZE_END);
break;
}
}
g_list_free (children);
}
g_object_unref (image_group);
g_object_unref (group);
if (!g_list_length (list)) {
GtkWidget *label;
gchar *string;
string = g_strdup_printf ("<i>%s</i>", _("No recently used project"));
label = gtk_label_new (string);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
g_free (string);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (self->priv->recent_box), label, FALSE, FALSE, 0);
}
g_list_free (list);
g_list_foreach (recents, (GFunc) gtk_recent_info_unref, NULL);
g_list_free (recents);
}
GtkWidget *
do_images (GtkWidget *do_widget)
{
GtkWidget *video;
GtkWidget *frame;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *base_vbox;
GtkWidget *image;
GtkWidget *picture;
GtkWidget *label;
GtkWidget *button;
GdkPaintable *paintable;
GIcon *gicon;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_display (GTK_WINDOW (window),
gtk_widget_get_display (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Images");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
g_signal_connect (window, "destroy",
G_CALLBACK (cleanup_callback), NULL);
base_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
g_object_set (base_vbox, "margin", 16, NULL);
gtk_container_add (GTK_CONTAINER (window), base_vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 16);
gtk_container_add (GTK_CONTAINER (base_vbox), hbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (hbox), vbox);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Image loaded from a file</u>");
gtk_container_add (GTK_CONTAINER (vbox), label);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (vbox), frame);
image = gtk_image_new_from_icon_name ("gtk3-demo");
gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
gtk_container_add (GTK_CONTAINER (frame), image);
/* Animation */
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Animation loaded from a file</u>");
gtk_container_add (GTK_CONTAINER (vbox), label);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (vbox), frame);
picture = gtk_picture_new_for_resource ("/images/floppybuddy.gif");
gtk_container_add (GTK_CONTAINER (frame), picture);
/* Symbolic icon */
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Symbolic themed icon</u>");
gtk_container_add (GTK_CONTAINER (vbox), label);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (vbox), frame);
gicon = g_themed_icon_new_with_default_fallbacks ("battery-caution-charging-symbolic");
image = gtk_image_new_from_gicon (gicon);
gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
gtk_container_add (GTK_CONTAINER (frame), image);
/* Progressive */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (hbox), vbox);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Progressive image loading</u>");
gtk_container_add (GTK_CONTAINER (vbox), label);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (vbox), frame);
/* Create an empty image for now; the progressive loader
* will create the pixbuf and fill it in.
*/
picture = gtk_picture_new ();
gtk_container_add (GTK_CONTAINER (frame), picture);
start_progressive_loading (picture);
/* Video */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (hbox), vbox);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>Displaying video</u>");
gtk_container_add (GTK_CONTAINER (vbox), label);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (vbox), frame);
video = gtk_video_new_for_resource ("/images/gtk-logo.webm");
gtk_media_stream_set_loop (gtk_video_get_media_stream (GTK_VIDEO (video)), TRUE);
gtk_container_add (GTK_CONTAINER (frame), video);
/* Widget paintables */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (hbox), vbox);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label),
"<u>GtkWidgetPaintable</u>");
gtk_container_add (GTK_CONTAINER (vbox), label);
paintable = gtk_widget_paintable_new (do_widget);
picture = gtk_picture_new_for_paintable (paintable);
gtk_widget_set_size_request (picture, 100, 100);
gtk_widget_set_valign (picture, GTK_ALIGN_START);
gtk_container_add (GTK_CONTAINER (vbox), picture);
/* Sensitivity control */
button = gtk_toggle_button_new_with_mnemonic ("_Insensitive");
gtk_container_add (GTK_CONTAINER (base_vbox), button);
g_signal_connect (button, "toggled",
G_CALLBACK (toggle_sensitivity_callback),
base_vbox);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
return window;
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window, *toolbar, *grid, *treeview, *scrolled_window;
GtkWidget *hbox, *hbox1, *hbox2, *checkbox, *option_menu, *menu;
gint i;
static const gchar *toolbar_styles[] = { "icons", "text", "both (vertical)",
"both (horizontal)" };
GtkToolItem *item;
GtkListStore *store;
GtkWidget *image;
GtkWidget *menuitem;
GtkWidget *button;
GtkWidget *label;
GIcon *gicon;
GSList *group;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), grid);
toolbar = gtk_toolbar_new ();
gtk_widget_set_vexpand (toolbar, TRUE);
gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 2, 1);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5);
gtk_widget_set_vexpand (hbox1, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox1, 1, 1, 1, 1);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 5);
gtk_widget_set_vexpand (hbox2, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox2, 1, 2, 1, 1);
checkbox = gtk_check_button_new_with_mnemonic("_Vertical");
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (change_orientation), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Show Arrow");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (change_show_arrow), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Set Toolbar Style:");
g_signal_connect (checkbox, "toggled", G_CALLBACK (set_toolbar_style_toggled), toolbar);
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
option_menu = gtk_combo_box_text_new ();
gtk_widget_set_sensitive (option_menu, FALSE);
g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
for (i = 0; i < G_N_ELEMENTS (toolbar_styles); i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), toolbar_styles[i]);
gtk_combo_box_set_active (GTK_COMBO_BOX (option_menu),
gtk_toolbar_get_style (GTK_TOOLBAR (toolbar)));
gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
g_signal_connect (option_menu, "changed",
G_CALLBACK (change_toolbar_style), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Set Icon Size:");
g_signal_connect (checkbox, "toggled", G_CALLBACK (set_icon_size_toggled), toolbar);
gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0);
option_menu = gtk_combo_box_text_new ();
g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
gtk_widget_set_sensitive (option_menu, FALSE);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "small toolbar");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "large toolbar");
gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
g_signal_connect (option_menu, "changed",
G_CALLBACK (icon_size_history_changed), toolbar);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_hexpand (scrolled_window, TRUE);
gtk_widget_set_vexpand (scrolled_window, TRUE);
gtk_grid_attach (GTK_GRID (grid), scrolled_window, 1, 3, 1, 1);
store = create_items_list (&treeview);
gtk_container_add (GTK_CONTAINER (scrolled_window), treeview);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-new");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Custom label");
add_item_to_list (store, item, "New");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb, item);
gtk_tool_item_set_expand (item, TRUE);
menu = gtk_menu_new ();
for (i = 0; i < 20; i++)
{
char *text;
text = g_strdup_printf ("Menuitem %d", i);
menuitem = gtk_menu_item_new_with_label (text);
g_free (text);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
item = gtk_menu_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-open");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Open");
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
add_item_to_list (store, item, "Open");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb1, item);
menu = gtk_menu_new ();
for (i = 0; i < 20; i++)
{
char *text;
text = g_strdup_printf ("A%d", i);
menuitem = gtk_menu_item_new_with_label (text);
g_free (text);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
item = gtk_menu_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back");
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
add_item_to_list (store, item, "BackWithHistory");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_icon_name ("dialog-warning", GTK_ICON_SIZE_DIALOG);
item = gtk_tool_item_new ();
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (item), image);
add_item_to_list (store, item, "(Custom Item)");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back");
add_item_to_list (store, item, "Back");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-next");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Forward");
add_item_to_list (store, item, "Forward");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-text-bold");
g_signal_connect (item, "toggled", G_CALLBACK (bold_toggled), NULL);
add_item_to_list (store, item, "Bold");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_tool_item_set_expand (item, TRUE);
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
g_assert (gtk_toolbar_get_nth_item (GTK_TOOLBAR (toolbar), 0) != 0);
item = gtk_radio_tool_button_new (NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-left");
group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
add_item_to_list (store, item, "Left");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_radio_tool_button_new (group);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-center");
make_prop_editor (G_OBJECT (item));
group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
add_item_to_list (store, item, "Center");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_radio_tool_button_new (group);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-right");
add_item_to_list (store, item, "Right");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (gtk_image_new_from_file ("apple-red.png"), "_Apple");
add_item_to_list (store, item, "Apple");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE);
gicon = g_content_type_get_icon ("video/ogg");
image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_LARGE_TOOLBAR);
g_object_unref (gicon);
item = gtk_tool_button_new (image, "Video");
add_item_to_list (store, item, "Video");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_icon_name ("utilities-terminal", GTK_ICON_SIZE_LARGE_TOOLBAR);
item = gtk_tool_button_new (image, "Terminal");
add_item_to_list (store, item, "Terminal");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_spinner_new ();
gtk_spinner_start (GTK_SPINNER (image));
item = gtk_tool_button_new (image, "Spinner");
add_item_to_list (store, item, "Spinner");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_widget_set_hexpand (hbox, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox, 1, 4, 1, 1);
button = gtk_button_new_with_label ("Drag me to the toolbar");
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
label = gtk_label_new ("Drop index:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
checkbox = gtk_check_button_new_with_mnemonic("_Right to left");
if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), FALSE);
g_signal_connect (checkbox, "toggled", G_CALLBACK (rtl_toggled), NULL);
gtk_box_pack_end (GTK_BOX (hbox), checkbox, FALSE, FALSE, 0);
gtk_drag_source_set (button, GDK_BUTTON1_MASK,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_MOVE);
gtk_drag_dest_set (toolbar, GTK_DEST_DEFAULT_DROP,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_MOVE);
g_signal_connect (toolbar, "drag_motion",
G_CALLBACK (toolbar_drag_motion), NULL);
g_signal_connect (toolbar, "drag_leave",
G_CALLBACK (toolbar_drag_leave), NULL);
g_signal_connect (toolbar, "drag_drop",
G_CALLBACK (toolbar_drag_drop), label);
gtk_widget_show_all (window);
make_prop_editor (G_OBJECT (toolbar));
g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (toolbar, "popup_context_menu", G_CALLBACK (popup_context_menu), NULL);
gtk_main ();
return 0;
}
