Newer
Older
#else
button->priv->inhibit = xfpm_inhibit_new ();
#endif
/* Sane defaults for the systray and panel icon */
#ifdef XFCE_PLUGIN
button->priv->panel_icon_name = g_strdup (PANEL_DEFAULT_ICON_SYMBOLIC);
#else
button->priv->panel_icon_name = g_strdup (PANEL_DEFAULT_ICON);
#endif
button->priv->panel_icon_width = 24;
/* Sane default Gtk style */
css_provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (css_provider,
"#xfce4-power-manager-plugin {"
"padding: 1px;"
"border-width: 1px;}",
-1, NULL);
gtk_style_context_add_provider (GTK_STYLE_CONTEXT (gtk_widget_get_style_context (GTK_WIDGET (button))),
GTK_STYLE_PROVIDER (css_provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
/* Intercept scroll events */
gtk_widget_add_events (GTK_WIDGET (button), GDK_SCROLL_MASK);
g_signal_connect (button->priv->upower, "device-added", G_CALLBACK (device_added_cb), button);
g_signal_connect (button->priv->upower, "device-removed", G_CALLBACK (device_removed_cb), button);
}
static void
power_manager_button_finalize (GObject *object)
button = POWER_MANAGER_BUTTON (object);
g_free(button->priv->panel_icon_name);
if (button->priv->set_level_timeout)
{
g_source_remove(button->priv->set_level_timeout);
button->priv->set_level_timeout = 0;
}
g_signal_handlers_disconnect_by_data (button->priv->upower, button);
power_manager_button_remove_all_devices (button);
g_object_unref (button->priv->plugin);
G_OBJECT_CLASS (power_manager_button_parent_class)->finalize (object);
power_manager_button_new (XfcePanelPlugin *plugin)
#ifdef XFPM_SYSTRAY
power_manager_button_new (void)
#endif
PowerManagerButton *button = NULL;
button = g_object_new (POWER_MANAGER_TYPE_BUTTON, NULL, NULL);
#ifdef XFCE_PLUGIN
button->priv->plugin = XFCE_PANEL_PLUGIN (g_object_ref (plugin));
#endif
xfconf_g_property_bind (button->priv->channel,
XFPM_PROPERTIES_PREFIX BRIGHTNESS_SLIDER_MIN_LEVEL, G_TYPE_INT,
G_OBJECT (button), BRIGHTNESS_SLIDER_MIN_LEVEL);
xfconf_g_property_bind (button->priv->channel, XFPM_PROPERTIES_PREFIX SHOW_PANEL_LABEL, G_TYPE_INT,
Simon Steinbeiss
committed
G_OBJECT (button), SHOW_PANEL_LABEL);
xfconf_g_property_bind (button->priv->channel, XFPM_PROPERTIES_PREFIX PRESENTATION_MODE, G_TYPE_BOOLEAN,
G_OBJECT (button), PRESENTATION_MODE);
xfconf_g_property_bind (button->priv->channel, XFPM_PROPERTIES_PREFIX SHOW_PRESENTATION_INDICATOR, G_TYPE_BOOLEAN,
G_OBJECT (button), SHOW_PRESENTATION_INDICATOR);
return GTK_WIDGET (button);
}
power_manager_button_press_event (GtkWidget *widget, GdkEventButton *event)
PowerManagerButton *button = POWER_MANAGER_BUTTON (widget);
if (event->button == 1 && !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
power_manager_button_show_menu (button);
return TRUE;
}
if (event->button == 2)
{
gboolean state;
state = xfconf_channel_get_bool (button->priv->channel, XFPM_PROPERTIES_PREFIX PRESENTATION_MODE, FALSE);
xfconf_channel_set_bool (button->priv->channel, XFPM_PROPERTIES_PREFIX PRESENTATION_MODE, !state);
return TRUE;
}
return FALSE;
power_manager_button_size_changed_cb (XfcePanelPlugin *plugin, gint size, PowerManagerButton *button)
#if !LIBXFCE4PANEL_CHECK_VERSION (4, 13, 0)
gint xthickness;
gint ythickness;
g_return_if_fail (POWER_MANAGER_IS_BUTTON (button));
g_return_if_fail (XFCE_IS_PANEL_PLUGIN (plugin));
g_return_if_fail (size > 0);
size /= xfce_panel_plugin_get_nrows (plugin);
#if LIBXFCE4PANEL_CHECK_VERSION (4, 13, 0)
button->priv->panel_icon_width = xfce_panel_plugin_get_icon_size (plugin);
#else
/* Calculate the size of the widget because the theme can override it */
context = gtk_widget_get_style_context (GTK_WIDGET (button));
gtk_style_context_get_padding (context, gtk_widget_get_state_flags (GTK_WIDGET (button)), &padding);
gtk_style_context_get_border (context, gtk_widget_get_state_flags (GTK_WIDGET (button)), &border);
xthickness = padding.left + padding.right + border.left + border.right;
ythickness = padding.top + padding.bottom + border.top + border.bottom;
/* Calculate the size of the space left for the icon */
width = size - 2 * MAX (xthickness, ythickness);
/* Since symbolic icons are usually only provided in 16px we
* try to be clever and use size steps */
if (width <= 21)
button->priv->panel_icon_width = 16;
else if (width >=22 && width <= 29)
button->priv->panel_icon_width = 24;
else if (width >= 30 && width <= 40)
button->priv->panel_icon_width = 32;
else
button->priv->panel_icon_width = width;
/* resize the plugin */
gtk_widget_set_size_request (GTK_WIDGET (plugin), size, size);
power_manager_button_set_icon (button);
/* resize the plugin button too */
gtk_widget_set_size_request (GTK_WIDGET (button), -1, -1);
power_manager_button_style_update_cb (XfcePanelPlugin *plugin, PowerManagerButton *button)
gtk_widget_reset_style (GTK_WIDGET (plugin));
power_manager_button_size_changed_cb (plugin, xfce_panel_plugin_get_size (plugin), button);
power_manager_button_free_data_cb (XfcePanelPlugin *plugin, PowerManagerButton *button)
{
gtk_widget_destroy (GTK_WIDGET (button));
}
static void
help_cb (GtkMenuItem *menuitem, gpointer user_data)
{
xfce_dialog_show_help_with_version (NULL, "xfce4-power-manager", "start", NULL, XFPM_VERSION_SHORT);
static void
about_cb (GtkMenuItem *menuitem, gpointer user_data)
{
xfpm_about ("xfce4-power-manager");
}
power_manager_button_show (PowerManagerButton *button)
Simon Steinbeiss
committed
GtkWidget *hbox;
GtkStyleContext *context;
GtkCssProvider *css_provider;
g_return_if_fail (POWER_MANAGER_IS_BUTTON (button));
xfce_panel_plugin_add_action_widget (button->priv->plugin, GTK_WIDGET (button));
xfce_panel_plugin_set_small (button->priv->plugin, TRUE);
button->priv->panel_icon_image = gtk_image_new ();
button->priv->panel_presentation_mode = gtk_image_new_from_icon_name (PRESENTATION_MODE_ICON, GTK_ICON_SIZE_BUTTON);
gtk_image_set_pixel_size (GTK_IMAGE (button->priv->panel_presentation_mode), button->priv->panel_icon_width);
context = gtk_widget_get_style_context (button->priv->panel_presentation_mode);
css_provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (css_provider,
".presentation-mode { color: @warning_color; }",
-1, NULL);
gtk_style_context_add_provider (context,
GTK_STYLE_PROVIDER (css_provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (css_provider);
gtk_style_context_add_class (context, "presentation-mode");
Simon Steinbeiss
committed
button->priv->panel_label = gtk_label_new ("");
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (button->priv->panel_presentation_mode), TRUE, FALSE, 0);
Simon Steinbeiss
committed
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (button->priv->panel_icon_image), TRUE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (button->priv->panel_label), TRUE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (button), GTK_WIDGET (hbox));
mi = gtk_menu_item_new_with_mnemonic (_("_Help"));
gtk_widget_set_sensitive (mi, TRUE);
gtk_widget_show (mi);
g_signal_connect (mi, "activate", G_CALLBACK (help_cb), button);
/* about dialog */
mi = gtk_menu_item_new_with_mnemonic (_("_About"));
gtk_widget_set_sensitive (mi, TRUE);
gtk_widget_show (mi);
g_signal_connect (mi, "activate", G_CALLBACK (about_cb), button);
xfce_panel_plugin_menu_insert_item (button->priv->plugin, GTK_MENU_ITEM (mi));
g_signal_connect (button->priv->plugin, "size-changed",
G_CALLBACK (power_manager_button_size_changed_cb), button);
g_signal_connect (button->priv->plugin, "style-updated",
G_CALLBACK (power_manager_button_style_update_cb), button);
g_signal_connect (button->priv->plugin, "free-data",
G_CALLBACK (power_manager_button_free_data_cb), button);
gtk_widget_show_all (GTK_WIDGET(button));
Simon Steinbeiss
committed
gtk_widget_set_visible (button->priv->panel_presentation_mode, button->priv->presentation_mode &&
button->priv->show_presentation_indicator);
Simon Steinbeiss
committed
power_manager_button_update_label (button, button->priv->display_device);
power_manager_button_set_tooltip (button);
/* Add all the devcies currently attached to the system */
power_manager_button_add_all_devices (button);
static void
power_manager_button_update_presentation_indicator (PowerManagerButton *button)
{
gtk_image_set_pixel_size (GTK_IMAGE (button->priv->panel_presentation_mode), button->priv->panel_icon_width);
gtk_widget_set_visible (button->priv->panel_presentation_mode, button->priv->presentation_mode &&
button->priv->show_presentation_indicator);
}
Simon Steinbeiss
committed
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
static void
power_manager_button_update_label (PowerManagerButton *button, UpDevice *device)
{
guint state;
gdouble percentage;
guint64 time_to_empty;
guint64 time_to_full;
if (!POWER_MANAGER_IS_BUTTON (button) || !UP_IS_DEVICE (device))
return;
#ifdef XFCE_PLUGIN
if (button->priv->show_panel_label <= 0 || button->priv->show_panel_label >3)
{
gtk_widget_hide (GTK_WIDGET (button->priv->panel_label));
power_manager_button_size_changed_cb (button->priv->plugin,
xfce_panel_plugin_get_size (button->priv->plugin),
button);
return;
}
else
gtk_widget_show (GTK_WIDGET (button->priv->panel_label));
#endif
g_object_get (device,
"state", &state,
"percentage", &percentage,
"time-to-empty", &time_to_empty,
"time-to-full", &time_to_full,
NULL);
/* Hide the label if the battery is fully charged,
* if the state is unknown (no battery available)
or if it's a desktop system */
Simon Steinbeiss
committed
if (state == UP_DEVICE_STATE_CHARGING)
power_manager_button_set_label (button, percentage, time_to_full);
else if (state == UP_DEVICE_STATE_FULLY_CHARGED
|| state == UP_DEVICE_STATE_UNKNOWN
|| g_strcmp0 (button->priv->panel_icon_name, "ac-adapter-symbolic") == 0)
Simon Steinbeiss
committed
gtk_widget_hide (GTK_WIDGET (button->priv->panel_label));
else
power_manager_button_set_label (button, percentage, time_to_empty);
}
menu_destroyed_cb(GtkMenuShell *menu, gpointer user_data)
PowerManagerButton *button = POWER_MANAGER_BUTTON (user_data);
/* menu destroyed, range slider is gone */
button->priv->range = NULL;
/* untoggle panel icon */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(button), FALSE);
gtk_menu_detach (GTK_MENU (button->priv->menu));
button->priv->menu = NULL;
}
static void
menu_item_destroyed_cb(GtkWidget *object, gpointer user_data)
{
PowerManagerButton *button = POWER_MANAGER_BUTTON (user_data);
GList *item;
for (item = g_list_first (button->priv->devices); item != NULL; item = g_list_next (item))
{
BatteryDevice *battery_device = item->data;
if (battery_device->menu_item == object)
{
battery_device->menu_item = NULL;
return;
}
}
}
static void
menu_item_activate_cb(GtkWidget *object, gpointer user_data)
{
PowerManagerButton *button = POWER_MANAGER_BUTTON (user_data);
GList *item;
for (item = g_list_first (button->priv->devices); item != NULL; item = g_list_next (item))
{
BatteryDevice *battery_device = item->data;
if (battery_device->menu_item == object)
{
/* Call xfpm settings with the device id */
xfpm_preferences_device_id (battery_device->object_path);
return;
}
}
}
power_manager_button_menu_add_device (PowerManagerButton *button, BatteryDevice *battery_device, gboolean append)
GtkWidget *mi, *label;
guint type = 0;
g_return_val_if_fail (POWER_MANAGER_IS_BUTTON (button), FALSE);
/* We need a menu to attach it to */
g_return_val_if_fail (button->priv->menu, FALSE);
if (UP_IS_DEVICE (battery_device->device))
{
g_object_get (battery_device->device,
"kind", &type,
NULL);
/* Don't add the display device or line power to the menu */
if (type == UP_DEVICE_KIND_LINE_POWER || battery_device->device == button->priv->display_device)
{
DBG("filtering device from menu (display or line power device)");
return FALSE;
}
}
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
mi = gtk_image_menu_item_new_with_label(battery_device->details);
G_GNUC_END_IGNORE_DEPRECATIONS
/* Make the menu item be bold and multi-line */
label = gtk_bin_get_child (GTK_BIN (mi));
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
battery_device->img = gtk_image_new_from_pixbuf (battery_device->pix);
g_object_ref (battery_device->img);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), battery_device->img);
G_GNUC_END_IGNORE_DEPRECATIONS
/* keep track of the menu item in the battery_device so we can update it */
battery_device->menu_item = mi;
g_signal_connect(G_OBJECT (mi), "destroy", G_CALLBACK (menu_item_destroyed_cb), button);
battery_device->expose_signal_id = g_signal_connect_after (G_OBJECT (battery_device->img),
G_CALLBACK (power_manager_button_device_icon_draw),
/* Active calls xfpm settings with the device's id to display details */
g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menu_item_activate_cb), button);
gtk_widget_show (mi);
gtk_menu_shell_append (GTK_MENU_SHELL(button->priv->menu), mi);
gtk_menu_shell_prepend (GTK_MENU_SHELL(button->priv->menu), mi);
static void
add_inhibitor_to_menu (PowerManagerButton *button, const gchar *text)
{
GtkWidget *mi, *img;
/* Translators this is to display which app is inhibiting
* power in the plugin menu. Example:
* VLC is currently inhibiting power management
*/
gchar *label = g_strdup_printf (_("%s is currently inhibiting power management"), text);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
mi = gtk_image_menu_item_new_with_label(label);
G_GNUC_END_IGNORE_DEPRECATIONS
/* add the image */
img = gtk_image_new_from_icon_name ("dialog-information", GTK_ICON_SIZE_MENU);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(mi), img);
G_GNUC_END_IGNORE_DEPRECATIONS
gtk_widget_set_can_focus (mi, FALSE);
gtk_widget_show (mi);
gtk_menu_shell_append (GTK_MENU_SHELL(button->priv->menu), mi);
g_free (label);
}
#ifdef XFCE_PLUGIN
static void
display_inhibitors (PowerManagerButton *button, GtkWidget *menu)
{
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
gboolean needs_seperator = FALSE;
g_return_if_fail (POWER_MANAGER_IS_BUTTON (button));
g_return_if_fail (GTK_IS_MENU (menu));
if (button->priv->inhibit_proxy)
{
GVariant *reply;
GError *error = NULL;
reply = g_dbus_proxy_call_sync (button->priv->inhibit_proxy,
"GetInhibitors",
g_variant_new ("()"),
G_DBUS_CALL_FLAGS_NONE,
1000,
NULL,
&error);
if (reply != NULL)
{
GVariantIter *iter;
gchar *value;
g_variant_get (reply, "(as)", &iter);
if (g_variant_iter_n_children (iter) > 0)
{
needs_seperator = TRUE;
}
/* Add the list of programs to the menu */
while (g_variant_iter_next (iter, "s", &value))
{
add_inhibitor_to_menu (button, value);
}
g_variant_iter_free (iter);
g_variant_unref (reply);
} else {
g_warning ("failed calling GetInhibitors: %s", error->message);
g_clear_error (&error);
}
if (needs_seperator)
{
/* add a separator */
separator_mi = gtk_separator_menu_item_new ();
gtk_widget_show (separator_mi);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), separator_mi);
}
}
}
#else
static void
display_inhibitors (PowerManagerButton *button, GtkWidget *menu)
{
const gchar **inhibitors;
g_return_if_fail (POWER_MANAGER_IS_BUTTON (button));
g_return_if_fail (GTK_IS_MENU (menu));
inhibitors = xfpm_inhibit_get_inhibit_list (button->priv->inhibit);
if (inhibitors != NULL && inhibitors[0] != NULL)
{
for (i=0; inhibitors[i] != NULL; i++)
{
add_inhibitor_to_menu (button, inhibitors[i]);
}
/* add a separator */
separator_mi = gtk_separator_menu_item_new ();
gtk_widget_show (separator_mi);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), separator_mi);
}
g_free (inhibitors);
}
#endif
static void
decrease_brightness (PowerManagerButton *button)
{
gint32 level;
TRACE("entering");
if ( !xfpm_brightness_has_hw (button->priv->brightness) )
return;
xfpm_brightness_get_level (button->priv->brightness, &level);
if ( level > button->priv->brightness_min_level )
{
xfpm_brightness_down (button->priv->brightness, &level);
if (button->priv->range)
gtk_range_set_value (GTK_RANGE (button->priv->range), level);
}
}
static void
increase_brightness (PowerManagerButton *button)
{
gint32 level, max_level;
TRACE("entering");
if (!xfpm_brightness_has_hw (button->priv->brightness))
return;
max_level = xfpm_brightness_get_max_level (button->priv->brightness);
xfpm_brightness_get_level (button->priv->brightness, &level);
if (level < max_level)
{
xfpm_brightness_up (button->priv->brightness, &level);
if (button->priv->range)
gtk_range_set_value (GTK_RANGE (button->priv->range), level);
}
}
brightness_set_level_with_timeout (PowerManagerButton *button)
{
gint32 range_level, hw_level;
TRACE("entering");
range_level = (gint32) gtk_range_get_value (GTK_RANGE (button->priv->range));
xfpm_brightness_get_level (button->priv->brightness, &hw_level);
{
xfpm_brightness_set_level (button->priv->brightness, range_level);
}
if (button->priv->set_level_timeout)
{
g_source_remove(button->priv->set_level_timeout);
button->priv->set_level_timeout = 0;
}
return FALSE;
}
static void
range_value_changed_cb (PowerManagerButton *button, GtkWidget *widget)
{
TRACE("entering");
if (button->priv->set_level_timeout)
return;
button->priv->set_level_timeout =
g_timeout_add (SET_LEVEL_TIMEOUT,
(GSourceFunc) brightness_set_level_with_timeout, button);
}
static void
range_scroll_cb (GtkWidget *widget, GdkEvent *event, PowerManagerButton *button)
{
GdkEventScroll *scroll_event;
TRACE("entering");
scroll_event = (GdkEventScroll*)event;
if (scroll_event->direction == GDK_SCROLL_UP)
increase_brightness (button);
else if (scroll_event->direction == GDK_SCROLL_DOWN)
decrease_brightness (button);
}
static void
range_show_cb (GtkWidget *widget, PowerManagerButton *button)
GdkDeviceManager* manager = gdk_display_get_device_manager (gdk_display_get_default());
GdkDevice* pointer = gdk_device_manager_get_client_pointer (manager);
#else
GdkSeat *seat = gdk_display_get_default_seat (gdk_display_get_default());
GdkDevice *pointer = gdk_seat_get_pointer (seat);
#endif
TRACE("entering");
/* Release these grabs as they will cause a lockup if pkexec is called
* for the brightness helper */
{
#if !GTK_CHECK_VERSION (3, 20, 0)
gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
#else
gdk_seat_ungrab (seat);
#endif
}
gtk_grab_remove (widget);
void
power_manager_button_toggle_presentation_mode (GtkMenuItem *mi, GtkSwitch *sw)
{
g_return_if_fail (GTK_IS_SWITCH (sw));
gtk_switch_set_active (sw, !gtk_switch_get_active (sw));
}
power_manager_button_show_menu (PowerManagerButton *button)
GtkWidget *box, *label, *sw;
gboolean show_separator_flag = FALSE;
gint32 max_level, current_level = 0;
TRACE("entering");
g_return_if_fail (POWER_MANAGER_IS_BUTTON (button));
if (gtk_widget_has_screen (GTK_WIDGET (button)))
gscreen = gtk_widget_get_screen(GTK_WIDGET(button));
else
gscreen = gdk_display_get_default_screen(gdk_display_get_default());
menu = gtk_menu_new ();
gtk_menu_set_screen(GTK_MENU(menu), gscreen);
/* keep track of the menu while it's being displayed */
button->priv->menu = menu;
g_signal_connect(GTK_MENU_SHELL(menu), "deactivate", G_CALLBACK(menu_destroyed_cb), button);
gtk_menu_attach_to_widget (GTK_MENU (menu), GTK_WIDGET (button), NULL);
for (item = g_list_first (button->priv->devices); item != NULL; item = g_list_next (item))
{
BatteryDevice *battery_device = item->data;
if (power_manager_button_menu_add_device (button, battery_device, TRUE))
{
/* If we add an item to the menu, show the separator */
show_separator_flag = TRUE;
}
if (show_separator_flag)
{
/* separator */
mi = gtk_separator_menu_item_new ();
gtk_widget_show (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
}
/* Display brightness slider - show if there's hardware support for it */
if ( xfpm_brightness_has_hw (button->priv->brightness) )
{
max_level = xfpm_brightness_get_max_level (button->priv->brightness);
mi = scale_menu_item_new_with_range (button->priv->brightness_min_level, max_level, 1);
scale_menu_item_set_description_label (SCALE_MENU_ITEM (mi), _("<b>Display brightness</b>"));
/* range slider */
button->priv->range = scale_menu_item_get_scale (SCALE_MENU_ITEM (mi));
/* update the slider to the current brightness level */
xfpm_brightness_get_level (button->priv->brightness, ¤t_level);
gtk_range_set_value (GTK_RANGE (button->priv->range), current_level);
g_signal_connect_swapped (mi, "value-changed", G_CALLBACK (range_value_changed_cb), button);
g_signal_connect (mi, "scroll-event", G_CALLBACK (range_scroll_cb), button);
g_signal_connect (menu, "show", G_CALLBACK (range_show_cb), button);
/* load and display the brightness icon and force it to 32px size */
img = gtk_image_new_from_icon_name (XFPM_DISPLAY_BRIGHTNESS_ICON, GTK_ICON_SIZE_DND);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(mi), img);
G_GNUC_END_IGNORE_DEPRECATIONS
gtk_image_set_pixel_size (GTK_IMAGE (img), 32);
gtk_widget_show_all (mi);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
mi = gtk_menu_item_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
label = gtk_label_new_with_mnemonic (_("Presentation _mode"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
sw = gtk_switch_new ();
gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), sw, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (mi), box);
gtk_widget_show_all (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
g_signal_connect (G_OBJECT (mi), "activate", G_CALLBACK (power_manager_button_toggle_presentation_mode), sw);
g_object_bind_property (G_OBJECT (button), PRESENTATION_MODE,
G_OBJECT (sw), "active",
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
/* Show any applications currently inhibiting now */
display_inhibitors (button, menu);
/* Power manager settings */
mi = gtk_menu_item_new_with_mnemonic (_("_Power manager settings..."));
gtk_widget_show (mi);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), mi);
g_signal_connect (G_OBJECT(mi), "activate", G_CALLBACK(xfpm_preferences), NULL);
#if GTK_CHECK_VERSION (3, 22, 0)
gtk_menu_popup_at_widget (GTK_MENU (menu),
GTK_WIDGET (button),
#ifdef XFCE_PLUGIN
xfce_panel_plugin_get_orientation (button->priv->plugin) == GTK_ORIENTATION_VERTICAL
? GDK_GRAVITY_WEST : GDK_GRAVITY_NORTH,
xfce_panel_plugin_get_orientation (button->priv->plugin) == GTK_ORIENTATION_VERTICAL
? GDK_GRAVITY_EAST : GDK_GRAVITY_SOUTH,
#else
GDK_GRAVITY_NORTH,
GDK_GRAVITY_SOUTH,
#endif
NULL);
#else
NULL,
#ifdef XFCE_PLUGIN
xfce_panel_plugin_position_menu,
#else
NULL,
#endif
0,
gtk_get_current_event_time ());
#ifdef XFCE_PLUGIN
xfce_panel_plugin_register_menu (button->priv->plugin,
GTK_MENU (menu));
#endif