Newer
Older
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,
PROPERTIES_PREFIX BRIGHTNESS_SLIDER_MIN_LEVEL, G_TYPE_INT,
G_OBJECT (button), BRIGHTNESS_SLIDER_MIN_LEVEL);
Simon Steinbeiss
committed
xfconf_g_property_bind (button->priv->channel, PROPERTIES_PREFIX SHOW_PANEL_LABEL, G_TYPE_INT,
G_OBJECT (button), SHOW_PANEL_LABEL);
return GTK_WIDGET (button);
}
power_manager_button_press_event (GtkWidget *widget, GdkEventButton *event)
PowerManagerButton *button = POWER_MANAGER_BUTTON (widget);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
power_manager_button_show_menu (button);
power_manager_button_size_changed_cb (XfcePanelPlugin *plugin, gint size, PowerManagerButton *button)
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);
/* 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;
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 ();
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_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
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);
Simon Steinbeiss
committed
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
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 (state == UP_DEVICE_STATE_CHARGING)
power_manager_button_set_label (button, percentage, time_to_full);
else if (state == UP_DEVICE_STATE_FULLY_CHARGED)
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);
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_expose),
battery_device->device);
/* 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);
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
static void
display_inhibitors (PowerManagerButton *button, GtkWidget *menu)
{
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))
{
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"), value);
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 ("gtk-info", 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);
}
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 */
GtkWidget * separator_mi = gtk_separator_menu_item_new ();
gtk_widget_show (separator_mi);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), separator_mi);
}
}
}
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);
TRACE("entering");
/* Release these grabs as they will cause a lockup if pkexec is called
* for the brightness helper */
gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
gtk_grab_remove (widget);
power_manager_button_show_menu (PowerManagerButton *button)
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);
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);
/* Presentation mode checkbox */
mi = gtk_check_menu_item_new_with_mnemonic (_("Presentation _mode"));
gtk_widget_set_sensitive (mi, TRUE);
gtk_widget_show (mi);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
xfconf_g_property_bind(button->priv->channel,
PROPERTIES_PREFIX PRESENTATION_MODE,
G_TYPE_BOOLEAN, G_OBJECT(mi), "active");
/* 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);
gtk_menu_popup (GTK_MENU (menu),
NULL,
NULL,
#ifdef XFCE_PLUGIN
xfce_panel_plugin_position_menu,
#else
NULL,
#endif
0,
gtk_get_current_event_time ());