Newer
Older
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);
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);
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
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
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);
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");
/* 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 ());