/** Invoked when we get NumberBatteriesChanged
*/
static void
gpm_phone_num_batteries_changed (DBusGProxy *proxy, guint number, GpmPhone *phone)
{
g_return_if_fail (GPM_IS_PHONE (phone));
egg_debug ("got NumberBatteriesChanged %i", number);
if (number > 1) {
egg_warning ("number not 0 or 1, not valid!");
return;
}
/* are we removed? */
if (number == 0) {
phone->priv->present = FALSE;
phone->priv->percentage = 0;
phone->priv->onac = FALSE;
egg_debug ("emitting device-removed : (%i)", 0);
g_signal_emit (phone, signals [DEVICE_REMOVED], 0, 0);
return;
}
if (phone->priv->present) {
egg_warning ("duplicate NumberBatteriesChanged with no change");
return;
}
/* reset to defaults until we get BatteryStateChanged */
phone->priv->present = TRUE;
phone->priv->percentage = 0;
phone->priv->onac = FALSE;
egg_debug ("emitting device-added : (%i)", 0);
g_signal_emit (phone, signals [DEVICE_ADDED], 0, 0);
}
/**
* gpk_log_get_old_transactions_cb
**/
static void
gpk_log_get_old_transactions_cb (GObject *object, GAsyncResult *res, gpointer user_data)
{
// PkClient *client = PK_CLIENT (object);
GError *error = NULL;
PkResults *results = NULL;
PkError *error_code = NULL;
/* get the results */
results = pk_client_generic_finish (client, res, &error);
if (results == NULL) {
egg_warning ("failed to get old transactions: %s", error->message);
g_error_free (error);
goto out;
}
/* check error code */
error_code = pk_results_get_error_code (results);
if (error_code != NULL) {
egg_warning ("failed to get old transactions: %s, %s", pk_error_enum_to_text (pk_error_get_code (error_code)), pk_error_get_details (error_code));
goto out;
}
/* get the list */
if (transactions != NULL)
g_ptr_array_unref (transactions);
transactions = pk_results_get_transaction_array (results);
gpk_log_refilter ();
out:
if (error_code != NULL)
g_object_unref (error_code);
if (results != NULL)
g_object_unref (results);
}
/**
* gpm_session_is_suspend_inhibited:
**/
static gboolean
gpm_session_is_suspend_inhibited (GpmSession *session)
{
gboolean ret;
gboolean is_inhibited = FALSE;
GError *error = NULL;
/* no mate-session */
if (session->priv->proxy == NULL) {
egg_warning ("no mate-session");
goto out;
}
/* find out if this change altered the inhibited state */
ret = dbus_g_proxy_call (session->priv->proxy, "IsInhibited", &error,
G_TYPE_UINT, GPM_SESSION_INHIBIT_MASK_SUSPEND,
G_TYPE_INVALID,
G_TYPE_BOOLEAN, &is_inhibited,
G_TYPE_INVALID);
if (!ret) {
egg_warning ("failed to get inhibit status: %s", error->message);
g_error_free (error);
is_inhibited = FALSE;
}
out:
return is_inhibited;
}
void
up_devd_init (UpBackend *backend)
{
int event_fd;
struct sockaddr_un addr;
event_fd = socket(PF_UNIX, SOCK_STREAM, 0);
if (event_fd < 0) {
egg_warning("failed to create event socket: '%s'", g_strerror(errno));
up_devd_inited = FALSE;
return;
}
addr.sun_family = AF_UNIX;
strncpy (addr.sun_path, UP_DEVD_SOCK_PATH, sizeof(addr.sun_path));
if (connect (event_fd, (struct sockaddr *)&addr, sizeof(addr)) == 0) {
GIOChannel *channel;
channel = g_io_channel_unix_new (event_fd);
g_io_add_watch (channel, G_IO_IN, up_devd_event_cb, backend);
g_io_channel_unref (channel);
up_devd_inited = TRUE;
} else {
egg_warning ("failed to connect to %s: '%s'", UP_DEVD_SOCK_PATH,
g_strerror(errno));
close (event_fd);
up_devd_inited = FALSE;
}
}
/**
* gpm_networkmanager_wake:
*
* Tell NetworkManager to wake up all the network devices
*
* Return value: TRUE if NetworkManager is now awake.
**/
gboolean
gpm_networkmanager_wake (void)
{
DBusGConnection *connection = NULL;
DBusGProxy *nm_proxy = NULL;
GError *error = NULL;
connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
if (error) {
egg_warning ("%s", error->message);
g_error_free (error);
return FALSE;
}
nm_proxy = dbus_g_proxy_new_for_name (connection,
NM_LISTENER_SERVICE,
NM_LISTENER_PATH,
NM_LISTENER_INTERFACE);
if (!nm_proxy) {
egg_warning ("Failed to get name owner");
return FALSE;
}
dbus_g_proxy_call_no_reply (nm_proxy, "wake", G_TYPE_INVALID);
g_object_unref (G_OBJECT (nm_proxy));
return TRUE;
}
/**
* gpm_session_is_idle:
**/
static gboolean
gpm_session_is_idle (GpmSession *session)
{
gboolean ret;
gboolean is_idle = FALSE;
GError *error = NULL;
GValue *value;
/* no mate-session */
if (session->priv->proxy_prop == NULL) {
egg_warning ("no mate-session");
goto out;
}
value = g_new0(GValue, 1);
/* find out if this change altered the inhibited state */
ret = dbus_g_proxy_call (session->priv->proxy_prop, "Get", &error,
G_TYPE_STRING, GPM_SESSION_MANAGER_PRESENCE_INTERFACE,
G_TYPE_STRING, "status",
G_TYPE_INVALID,
G_TYPE_VALUE, value,
G_TYPE_INVALID);
if (!ret) {
egg_warning ("failed to get idle status: %s", error->message);
g_error_free (error);
is_idle = FALSE;
goto out;
}
is_idle = (g_value_get_uint (value) == GPM_SESSION_STATUS_ENUM_IDLE);
g_free (value);
out:
return is_idle;
}
/**
* gpm_inhibit_applet_dbus_connect:
**/
gboolean
gpm_inhibit_applet_dbus_connect (GpmInhibitApplet *applet)
{
GError *error = NULL;
if (applet->connection == NULL) {
egg_debug ("get connection\n");
g_clear_error (&error);
applet->connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
if (error != NULL) {
egg_warning ("Could not connect to DBUS daemon: %s", error->message);
g_error_free (error);
applet->connection = NULL;
return FALSE;
}
}
if (applet->proxy == NULL) {
egg_debug ("get proxy\n");
g_clear_error (&error);
applet->proxy = dbus_g_proxy_new_for_name_owner (applet->connection,
GS_DBUS_SERVICE,
GS_DBUS_PATH,
GS_DBUS_INTERFACE,
&error);
if (error != NULL) {
egg_warning ("Cannot connect, maybe the daemon is not running: %s\n", error->message);
g_error_free (error);
applet->proxy = NULL;
return FALSE;
}
}
return TRUE;
}
/**
* gpm_applet_set_brightness:
* Return value: Success value, or zero for failure
**/
static gboolean
gpm_applet_set_brightness (GpmBrightnessApplet *applet)
{
GError *error = NULL;
gboolean ret;
if (applet->proxy == NULL) {
egg_warning ("not connected");
return FALSE;
}
ret = dbus_g_proxy_call (applet->proxy, "SetBrightness", &error,
G_TYPE_UINT, applet->level,
G_TYPE_INVALID,
G_TYPE_INVALID);
if (error) {
egg_debug ("ERROR: %s", error->message);
g_error_free (error);
}
if (!ret) {
/* abort as the DBUS method failed */
egg_warning ("SetBrightness failed!");
}
return ret;
}
/**
* gpm_applet_get_brightness:
* Return value: Success value, or zero for failure
**/
static gboolean
gpm_applet_get_brightness (GpmBrightnessApplet *applet)
{
GError *error = NULL;
gboolean ret;
guint policy_brightness;
if (applet->proxy == NULL) {
egg_warning ("not connected\n");
return FALSE;
}
ret = dbus_g_proxy_call (applet->proxy, "GetBrightness", &error,
G_TYPE_INVALID,
G_TYPE_UINT, &policy_brightness,
G_TYPE_INVALID);
if (error) {
egg_debug ("ERROR: %s\n", error->message);
g_error_free (error);
}
if (ret) {
applet->level = policy_brightness;
} else {
/* abort as the DBUS method failed */
egg_warning ("GetBrightness failed!\n");
}
return ret;
}
/**
* gpm_session_end_session_response:
**/
gboolean
gpm_session_end_session_response (GpmSession *session, gboolean is_okay, const gchar *reason)
{
gboolean ret = FALSE;
GError *error = NULL;
g_return_val_if_fail (GPM_IS_SESSION (session), FALSE);
g_return_val_if_fail (session->priv->proxy_client_private != NULL, FALSE);
/* no mate-session */
if (session->priv->proxy_client_private == NULL) {
egg_warning ("no mate-session proxy");
goto out;
}
/* send response */
ret = dbus_g_proxy_call (session->priv->proxy_client_private, "EndSessionResponse", &error,
G_TYPE_BOOLEAN, is_okay,
G_TYPE_STRING, reason,
G_TYPE_INVALID,
G_TYPE_INVALID);
if (!ret) {
egg_warning ("failed to send session response: %s", error->message);
g_error_free (error);
goto out;
}
out:
return ret;
}
/**
* gpm_session_register_client:
**/
gboolean
gpm_session_register_client (GpmSession *session, const gchar *app_id, const gchar *client_startup_id)
{
gboolean ret = FALSE;
gchar *client_id = NULL;
GError *error = NULL;
DBusGConnection *connection;
g_return_val_if_fail (GPM_IS_SESSION (session), FALSE);
/* no mate-session */
if (session->priv->proxy == NULL) {
egg_warning ("no mate-session");
goto out;
}
/* find out if this change altered the inhibited state */
ret = dbus_g_proxy_call (session->priv->proxy, "RegisterClient", &error,
G_TYPE_STRING, app_id,
G_TYPE_STRING, client_startup_id,
G_TYPE_INVALID,
DBUS_TYPE_G_OBJECT_PATH, &client_id,
G_TYPE_INVALID);
if (!ret) {
egg_warning ("failed to register client '%s': %s", client_startup_id, error->message);
g_error_free (error);
goto out;
}
/* get org.mate.Session.ClientPrivate interface */
connection = dbus_g_bus_get (DBUS_BUS_SESSION, NULL);
session->priv->proxy_client_private = dbus_g_proxy_new_for_name_owner (connection, GPM_SESSION_MANAGER_SERVICE,
client_id, GPM_SESSION_MANAGER_CLIENT_PRIVATE_INTERFACE, &error);
if (session->priv->proxy_client_private == NULL) {
egg_warning ("DBUS error: %s", error->message);
g_error_free (error);
goto out;
}
/* get Stop */
dbus_g_proxy_add_signal (session->priv->proxy_client_private, "Stop", G_TYPE_INVALID);
dbus_g_proxy_connect_signal (session->priv->proxy_client_private, "Stop", G_CALLBACK (gpm_session_stop_cb), session, NULL);
/* get QueryEndSession */
dbus_g_proxy_add_signal (session->priv->proxy_client_private, "QueryEndSession", G_TYPE_UINT, G_TYPE_INVALID);
dbus_g_proxy_connect_signal (session->priv->proxy_client_private, "QueryEndSession", G_CALLBACK (gpm_session_query_end_session_cb), session, NULL);
/* get EndSession */
dbus_g_proxy_add_signal (session->priv->proxy_client_private, "EndSession", G_TYPE_UINT, G_TYPE_INVALID);
dbus_g_proxy_connect_signal (session->priv->proxy_client_private, "EndSession", G_CALLBACK (gpm_session_end_session_cb), session, NULL);
egg_debug ("registered startup '%s' to client id '%s'", client_startup_id, client_id);
out:
g_free (client_id);
return ret;
}
/**
* gpm_phone_service_appeared_cb:
*/
static void
gpm_phone_service_appeared_cb (GDBusConnection *connection,
const gchar *name, const gchar *name_owner,
GpmPhone *phone)
{
GError *error = NULL;
g_return_if_fail (GPM_IS_PHONE (phone));
if (phone->priv->connection == NULL) {
egg_debug ("get connection");
g_clear_error (&error);
phone->priv->connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
if (error != NULL) {
egg_warning ("Could not connect to DBUS daemon: %s", error->message);
g_error_free (error);
phone->priv->connection = NULL;
return;
}
}
if (phone->priv->proxy == NULL) {
egg_debug ("get proxy");
g_clear_error (&error);
phone->priv->proxy = dbus_g_proxy_new_for_name_owner (phone->priv->connection,
MATE_PHONE_MANAGER_DBUS_SERVICE,
MATE_PHONE_MANAGER_DBUS_PATH,
MATE_PHONE_MANAGER_DBUS_INTERFACE,
&error);
if (error != NULL) {
egg_warning ("Cannot connect, maybe the daemon is not running: %s", error->message);
g_error_free (error);
phone->priv->proxy = NULL;
return;
}
/* complicated type. ick */
dbus_g_object_register_marshaller(gpm_marshal_VOID__UINT_UINT_BOOLEAN,
G_TYPE_NONE, G_TYPE_UINT, G_TYPE_UINT,
G_TYPE_BOOLEAN, G_TYPE_INVALID);
/* get BatteryStateChanged */
dbus_g_proxy_add_signal (phone->priv->proxy, "BatteryStateChanged",
G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN, G_TYPE_INVALID);
dbus_g_proxy_connect_signal (phone->priv->proxy, "BatteryStateChanged",
G_CALLBACK (gpm_phone_battery_state_changed),
phone, NULL);
/* get NumberBatteriesChanged */
dbus_g_proxy_add_signal (phone->priv->proxy, "NumberBatteriesChanged",
G_TYPE_UINT, G_TYPE_INVALID);
dbus_g_proxy_connect_signal (phone->priv->proxy, "NumberBatteriesChanged",
G_CALLBACK (gpm_phone_num_batteries_changed),
phone, NULL);
}
}
/**
* mcm_utils_is_package_installed:
**/
gboolean
mcm_utils_is_package_installed (const gchar *package_name)
{
GDBusConnection *connection;
GVariant *args = NULL;
GVariant *response = NULL;
GError *error = NULL;
gboolean installed = TRUE;
g_return_val_if_fail (package_name != NULL, FALSE);
#ifndef MCM_USE_PACKAGEKIT
egg_warning ("cannot query %s: this package was not compiled with --enable-packagekit", package_name);
return TRUE;
#endif
/* get a session bus connection */
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (connection == NULL) {
/* TRANSLATORS: no DBus session bus */
g_print ("%s %s\n", _("Failed to connect to session bus:"), error->message);
g_error_free (error);
goto out;
}
/* execute sync method */
args = g_variant_new ("(ss)", package_name, "timeout=5");
response = g_dbus_connection_call_sync (connection,
PK_DBUS_SERVICE,
PK_DBUS_PATH,
PK_DBUS_INTERFACE_QUERY,
"IsInstalled",
args,
G_VARIANT_TYPE ("(b)"),
G_DBUS_CALL_FLAGS_NONE,
G_MAXINT, NULL, &error);
if (response == NULL) {
/* TRANSLATORS: the DBus method failed */
egg_warning ("%s %s\n", _("The request failed:"), error->message);
g_error_free (error);
goto out;
}
/* get value */
g_variant_get (response, "(b)", &installed);
out:
if (args != NULL)
g_variant_unref (args);
if (response != NULL)
g_variant_unref (response);
return installed;
}
/**
* pk_filter_bitfield_from_text:
* @filters: the enumerated constant value, e.g. "available;~gui"
*
* Converts text representation to its enumerated type bitfield, or 0 for invalid
*
* Return value: The enumerated type values
**/
PkBitfield
pk_filter_bitfield_from_text (const gchar *filters)
{
PkBitfield filters_enum = 0;
gchar **split;
guint length;
guint i;
PkFilterEnum filter;
split = g_strsplit (filters, ";", 0);
if (split == NULL) {
egg_warning ("unable to split");
goto out;
}
length = g_strv_length (split);
for (i=0; i<length; i++) {
filter = pk_filter_enum_from_text (split[i]);
if (filter == PK_FILTER_ENUM_UNKNOWN) {
filters_enum = 0;
break;
}
filters_enum += pk_bitfield_value (filter);
}
out:
g_strfreev (split);
return filters_enum;
}
/**
* pk_filter_bitfield_to_text:
* @filters: The enumerated type values
*
* Converts a enumerated type bitfield to its text representation
*
* Return value: the enumerated constant value, e.g. "available;~gui"
**/
gchar *
pk_filter_bitfield_to_text (PkBitfield filters)
{
GString *string;
guint i;
/* shortcut */
if (filters == 0)
return g_strdup (pk_filter_enum_to_text (PK_FILTER_ENUM_NONE));
string = g_string_new ("");
for (i=0; i<PK_FILTER_ENUM_LAST; i++) {
if ((filters & pk_bitfield_value (i)) == 0)
continue;
g_string_append_printf (string, "%s;", pk_filter_enum_to_text (i));
}
/* do we have a 'none' filter? \n */
if (string->len == 0) {
egg_warning ("not valid!");
g_string_append (string, pk_filter_enum_to_text (PK_FILTER_ENUM_NONE));
} else {
/* remove last \n */
g_string_set_size (string, string->len - 1);
}
return g_string_free (string, FALSE);
}
/**
* pk_role_bitfield_from_text:
* @roles: the enumerated constant value, e.g. "available;~gui"
*
* Converts text representation to its enumerated type bitfield
*
* Return value: The enumerated type values, or 0 for invalid
**/
PkBitfield
pk_role_bitfield_from_text (const gchar *roles)
{
PkBitfield roles_enum = 0;
gchar **split;
guint length;
guint i;
PkRoleEnum role;
split = g_strsplit (roles, ";", 0);
if (split == NULL) {
egg_warning ("unable to split");
goto out;
}
length = g_strv_length (split);
for (i=0; i<length; i++) {
role = pk_role_enum_from_text (split[i]);
if (role == PK_ROLE_ENUM_UNKNOWN) {
roles_enum = 0;
break;
}
roles_enum += pk_bitfield_value (role);
}
out:
g_strfreev (split);
return roles_enum;
}
/**
* mcm_calibrate_dialog_set_image_filename_private:
**/
static void
mcm_calibrate_dialog_set_image_filename_private (McmCalibrateDialog *calibrate_dialog, const gchar *image_filename)
{
GtkWidget *widget;
gchar *filename = NULL;
GdkPixbuf *pixbuf;
GError *error = NULL;
McmCalibrateDialogPrivate *priv = calibrate_dialog->priv;
/* set the image */
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "image_generic"));
if (image_filename != NULL) {
filename = g_build_filename (MCM_DATA, "icons", image_filename, NULL);
pixbuf = gdk_pixbuf_new_from_file_at_size (filename, 200, 400, &error);
if (pixbuf == NULL) {
egg_warning ("failed to load image: %s", error->message);
g_error_free (error);
gtk_widget_hide (widget);
} else {
gtk_image_set_from_pixbuf (GTK_IMAGE (widget), pixbuf);
gtk_widget_show (widget);
}
g_free (filename);
} else {
gtk_widget_hide (widget);
}
}
static gboolean
gpm_applet_uninhibit (GpmInhibitApplet *applet,
guint cookie)
{
GError *error = NULL;
gboolean ret;
if (applet->proxy == NULL) {
egg_warning ("not connected");
return FALSE;
}
ret = dbus_g_proxy_call (applet->proxy, "Uninhibit", &error,
G_TYPE_UINT, cookie,
G_TYPE_INVALID,
G_TYPE_INVALID);
if (error) {
g_debug ("ERROR: %s", error->message);
g_error_free (error);
}
if (!ret) {
/* abort as the DBUS method failed */
g_warning ("Uninhibit failed!");
}
return ret;
}
/**
* pk_group_bitfield_from_text:
* @groups: the enumerated constant value, e.g. "available;~gui"
*
* Converts text representation to its enumerated type bitfield
*
* Return value: The enumerated type values, or 0 for invalid
**/
PkBitfield
pk_group_bitfield_from_text (const gchar *groups)
{
PkBitfield groups_enum = 0;
gchar **split;
guint length;
guint i;
PkGroupEnum group;
split = g_strsplit (groups, ";", 0);
if (split == NULL) {
egg_warning ("unable to split");
goto out;
}
length = g_strv_length (split);
for (i=0; i<length; i++) {
group = pk_group_enum_from_text (split[i]);
if (group == PK_GROUP_ENUM_UNKNOWN) {
groups_enum = 0;
break;
}
groups_enum += pk_bitfield_value (group);
}
out:
g_strfreev (split);
return groups_enum;
}
/**
* up_device_coldplug:
*
* Return %TRUE on success, %FALSE if we failed to get data and should be removed
**/
gboolean
up_device_coldplug (UpDevice *device, UpDaemon *daemon, GObject *native)
{
gboolean ret;
const gchar *native_path;
UpDeviceClass *klass = UP_DEVICE_GET_CLASS (device);
gchar *id = NULL;
g_return_val_if_fail (UP_IS_DEVICE (device), FALSE);
/* save */
device->priv->native = g_object_ref (native);
device->priv->daemon = g_object_ref (daemon);
native_path = up_native_get_native_path (native);
device->priv->native_path = g_strdup (native_path);
/* stop signals and callbacks */
g_object_freeze_notify (G_OBJECT(device));
device->priv->during_coldplug = TRUE;
/* coldplug source */
if (klass->coldplug != NULL) {
ret = klass->coldplug (device);
if (!ret) {
egg_debug ("failed to coldplug %s", device->priv->native_path);
goto out;
}
}
/* only put on the bus if we succeeded */
ret = up_device_register_device (device);
if (!ret) {
egg_warning ("failed to register device %s", device->priv->native_path);
goto out;
}
/* force a refresh, although failure isn't fatal */
ret = up_device_refresh_internal (device);
if (!ret) {
egg_debug ("failed to refresh %s", device->priv->native_path);
/* TODO: refresh should really have seporate
* success _and_ changed parameters */
ret = TRUE;
goto out;
}
/* get the id so we can load the old history */
id = up_device_get_id (device);
if (id != NULL)
up_history_set_id (device->priv->history, id);
out:
/* start signals and callbacks */
g_object_thaw_notify (G_OBJECT(device));
device->priv->during_coldplug = FALSE;
g_free (id);
return ret;
}
/**
* gpk_prefs_update_combo_changed:
**/
static void
gpk_prefs_update_combo_changed (GtkWidget *widget, gpointer data)
{
gchar *value;
const gchar *action;
GpkUpdateEnum update = GPK_UPDATE_ENUM_UNKNOWN;
GConfClient *client;
client = gconf_client_get_default ();
value = gtk_combo_box_get_active_text (GTK_COMBO_BOX (widget));
if (value == NULL) {
egg_warning ("value NULL");
return;
}
if (strcmp (value, PK_UPDATE_ALL_TEXT) == 0) {
update = GPK_UPDATE_ENUM_ALL;
} else if (strcmp (value, PK_UPDATE_SECURITY_TEXT) == 0) {
update = GPK_UPDATE_ENUM_SECURITY;
} else if (strcmp (value, PK_UPDATE_NONE_TEXT) == 0) {
update = GPK_UPDATE_ENUM_NONE;
} else {
g_assert (FALSE);
}
action = gpk_update_enum_to_text (update);
egg_debug ("Changing %s to %s", GPK_CONF_AUTO_UPDATE, action);
gconf_client_set_string (client, GPK_CONF_AUTO_UPDATE, action, NULL);
g_free (value);
g_object_unref (client);
}
/**
* pk_strcmp_sections:
* @id1: the first item of text to test
* @id2: the second item of text to test
* @parts: the number of parts each id should have
* @compare: the leading number of parts to compare
*
* We only want to compare some first sections, not all the data when
* comparing package_id's and transaction_id's.
*
* Return value: %TRUE if the strings can be considered the same.
*
**/
static gboolean
pk_strcmp_sections (const gchar *id1, const gchar *id2, guint parts, guint compare)
{
gchar **sections1;
gchar **sections2;
gboolean ret = FALSE;
guint i;
if (id1 == NULL || id2 == NULL) {
egg_warning ("package id compare invalid '%s' and '%s'", id1, id2);
return FALSE;
}
if (compare > parts) {
egg_warning ("compare %i > parts %i", compare, parts);
return FALSE;
}
if (compare == parts) {
return (g_strcmp0 (id1, id2) == 0);
}
/* split, NULL will be returned if error */
sections1 = pk_strsplit (id1, parts);
sections2 = pk_strsplit (id2, parts);
/* check we split okay */
if (sections1 == NULL) {
egg_warning ("string id compare sections1 invalid '%s'", id1);
goto out;
}
if (sections2 == NULL) {
egg_warning ("string id compare sections2 invalid '%s'", id2);
goto out;
}
/* only compare preceeding sections */
for (i=0; i<compare; i++) {
if (g_strcmp0 (sections1[i], sections2[i]) != 0) {
goto out;
}
}
ret = TRUE;
out:
g_strfreev (sections1);
g_strfreev (sections2);
return ret;
}
/**
* gpm_backlight_button_pressed_cb:
* @power: The power class instance
* @type: The button type, e.g. "power"
* @state: The state, where TRUE is depressed or closed
* @brightness: This class instance
**/
static void
gpm_backlight_button_pressed_cb (GpmButton *button, const gchar *type, GpmBacklight *backlight)
{
gboolean ret;
GError *error = NULL;
guint percentage;
gboolean hw_changed;
egg_debug ("Button press event type=%s", type);
if (strcmp (type, GPM_BUTTON_BRIGHT_UP) == 0) {
/* go up one step */
ret = gpm_brightness_up (backlight->priv->brightness, &hw_changed);
/* show the new value */
if (ret) {
gpm_brightness_get (backlight->priv->brightness, &percentage);
gpm_backlight_dialog_init (backlight);
gsd_media_keys_window_set_volume_level (GSD_MEDIA_KEYS_WINDOW (backlight->priv->popup),
percentage);
gpm_backlight_dialog_show (backlight);
/* save the new percentage */
backlight->priv->master_percentage = percentage;
}
/* we emit a signal for the brightness applet */
if (ret && hw_changed) {
egg_debug ("emitting brightness-changed : %i", percentage);
g_signal_emit (backlight, signals [BRIGHTNESS_CHANGED], 0, percentage);
}
} else if (strcmp (type, GPM_BUTTON_BRIGHT_DOWN) == 0) {
/* go up down step */
ret = gpm_brightness_down (backlight->priv->brightness, &hw_changed);
/* show the new value */
if (ret) {
gpm_brightness_get (backlight->priv->brightness, &percentage);
gpm_backlight_dialog_init (backlight);
gsd_media_keys_window_set_volume_level (GSD_MEDIA_KEYS_WINDOW (backlight->priv->popup),
percentage);
gpm_backlight_dialog_show (backlight);
/* save the new percentage */
backlight->priv->master_percentage = percentage;
}
/* we emit a signal for the brightness applet */
if (ret && hw_changed) {
egg_debug ("emitting brightness-changed : %i", percentage);
g_signal_emit (backlight, signals [BRIGHTNESS_CHANGED], 0, percentage);
}
} else if (strcmp (type, GPM_BUTTON_LID_OPEN) == 0) {
/* make sure we undim when we lift the lid */
gpm_backlight_brightness_evaluate_and_set (backlight, FALSE);
/* ensure backlight is on */
ret = gpm_dpms_set_mode (backlight->priv->dpms, GPM_DPMS_MODE_ON, &error);
if (!ret) {
egg_warning ("failed to turn on DPMS: %s", error->message);
g_error_free (error);
}
}
}
/**
* mcm_profile_store_add_profile:
**/
static gboolean
mcm_profile_store_add_profile (McmProfileStore *profile_store, GFile *file)
{
gboolean ret = FALSE;
McmProfile *profile = NULL;
McmProfile *profile_tmp = NULL;
GError *error = NULL;
gchar *filename = NULL;
const gchar *checksum;
McmProfileStorePrivate *priv = profile_store->priv;
/* already added? */
filename = g_file_get_path (file);
profile = mcm_profile_store_get_by_filename (profile_store, filename);
if (profile != NULL)
goto out;
/* parse the profile name */
profile = mcm_profile_default_new ();
ret = mcm_profile_parse (profile, file, &error);
if (!ret) {
egg_warning ("failed to add profile '%s': %s", filename, error->message);
g_error_free (error);
goto out;
}
/* check the profile has not been added already */
checksum = mcm_profile_get_checksum (profile);
profile_tmp = mcm_profile_store_get_by_checksum (profile_store, checksum);
if (profile_tmp != NULL) {
/* we value a local file higher than the shared file */
if (mcm_profile_get_can_delete (profile_tmp)) {
egg_debug ("already added a deletable profile %s, cannot add %s",
mcm_profile_get_filename (profile_tmp), filename);
goto out;
}
/* remove the old profile in favour of the new one */
mcm_profile_store_remove_profile (profile_store, profile_tmp);
}
/* add to array */
egg_debug ("parsed new profile '%s'", filename);
g_ptr_array_add (priv->profile_array, g_object_ref (profile));
g_signal_connect (profile, "notify::filename", G_CALLBACK(mcm_profile_store_notify_filename_cb), profile_store);
/* emit a signal */
egg_debug ("emit added (and changed): %s", filename);
g_signal_emit (profile_store, signals[SIGNAL_ADDED], 0, profile);
g_signal_emit (profile_store, signals[SIGNAL_CHANGED], 0);
out:
g_free (filename);
if (profile_tmp != NULL)
g_object_unref (profile_tmp);
if (profile != NULL)
g_object_unref (profile);
return ret;
}
/**
* pk_object_register:
* @connection: What we want to register to
* @object: The GObject we want to register
*
* Register org.freedesktop.PackageKit on the system bus.
* This function MUST be called before DBUS service will work.
*
* Return value: success
**/
G_GNUC_WARN_UNUSED_RESULT static gboolean
pk_object_register (DBusGConnection *connection, GObject *object, GError **error)
{
DBusGProxy *bus_proxy = NULL;
guint request_name_result;
gboolean ret;
gchar *message;
bus_proxy = dbus_g_proxy_new_for_name (connection,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS);
ret = dbus_g_proxy_call (bus_proxy, "RequestName", error,
G_TYPE_STRING, PK_DBUS_SERVICE,
G_TYPE_UINT, 0,
G_TYPE_INVALID,
G_TYPE_UINT, &request_name_result,
G_TYPE_INVALID);
/* free the bus_proxy */
g_object_unref (G_OBJECT (bus_proxy));
/* abort as the DBUS method failed */
if (!ret) {
egg_warning ("RequestName failed!");
g_clear_error (error);
message = g_strdup_printf ("%s\n%s\n* %s\n* %s '%s'\n",
/* TRANSLATORS: failed due to DBus security */
_("Startup failed due to security policies on this machine."),
/* TRANSLATORS: only two ways this can fail... */
_("This can happen for two reasons:"),
/* TRANSLATORS: only allowed to be owned by root */
_("The correct user is not launching the executable (usually root)"),
/* TRANSLATORS: or we are installed in a prefix */
_("The org.freedesktop.PackageKit.conf file is not "
"installed in the system directory:"),
"/etc/dbus-1/system.d");
g_set_error (error, PK_ENGINE_ERROR, PK_ENGINE_ERROR_DENIED, "%s", message);
g_free (message);
return FALSE;
}
/* already running */
if (request_name_result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
g_set_error (error, PK_ENGINE_ERROR, PK_ENGINE_ERROR_DENIED,
"Already running on this machine");
return FALSE;
}
dbus_g_object_type_install_info (PK_TYPE_ENGINE, &dbus_glib_pk_engine_object_info);
dbus_g_error_domain_register (PK_ENGINE_ERROR, NULL, PK_ENGINE_TYPE_ERROR);
dbus_g_error_domain_register (PK_TRANSACTION_ERROR, NULL, PK_TRANSACTION_TYPE_ERROR);
dbus_g_connection_register_g_object (connection, PK_DBUS_PATH, object);
return TRUE;
}
/**
* mcm_dump_profile_filename:
**/
static gboolean
mcm_dump_profile_filename (const gchar *filename)
{
gboolean ret;
GError *error = NULL;
McmProfile *profile;
guint profile_kind;
guint colorspace;
guint size;
gboolean has_vcgt;
const gchar *description;
const gchar *copyright;
const gchar *manufacturer;
const gchar *model;
const gchar *datetime;
GFile *file = NULL;
/* parse profile */
profile = mcm_profile_default_new ();
file = g_file_new_for_path (filename);
ret = mcm_profile_parse (profile, file, &error);
if (!ret) {
egg_warning ("failed to parse: %s", error->message);
g_error_free (error);
goto out;
}
/* print what we know */
profile_kind = mcm_profile_get_kind (profile);
g_print ("Kind:\t%s\n", mcm_profile_kind_to_string (profile_kind));
colorspace = mcm_profile_get_colorspace (profile);
g_print ("Colorspace:\t%s\n", mcm_colorspace_to_string (colorspace));
size = mcm_profile_get_size (profile);
g_print ("Size:\t%i bytes\n", size);
has_vcgt = mcm_profile_get_has_vcgt (profile);
g_print ("Has VCGT:\t%s\n", has_vcgt ? "Yes" : "No");
description = mcm_profile_get_description (profile);
if (description != NULL)
g_print ("Description:\t%s\n", description);
copyright = mcm_profile_get_copyright (profile);
if (copyright != NULL)
g_print ("Copyright:\t%s\n", copyright);
manufacturer = mcm_profile_get_manufacturer (profile);
if (manufacturer != NULL)
g_print ("Manufacturer:\t%s\n", manufacturer);
model = mcm_profile_get_model (profile);
if (model != NULL)
g_print ("Model:\t%s\n", model);
datetime = mcm_profile_get_datetime (profile);
if (datetime != NULL)
g_print ("Created:\t%s\n", datetime);
out:
if (file != NULL)
g_object_unref (file);
g_object_unref (profile);
return ret;
}
/**
* gpk_package_entry_completion_model_new:
*
* Creates a tree model containing completions from the system package list
**/
static GtkTreeModel *
gpk_package_entry_completion_model_new (void)
{
GPtrArray *list;
guint i;
PkPackage *item;
GHashTable *hash;
gpointer data;
GtkListStore *store;
GtkTreeIter iter;
gchar **split;
store = gtk_list_store_new (1, G_TYPE_STRING);
hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
list = gpk_package_entry_completion_get_names_from_file (PK_SYSTEM_PACKAGE_LIST_FILENAME);
if (list == NULL) {
egg_warning ("no package list, try refreshing");
return NULL;
}
egg_debug ("loading %i autocomplete items", list->len);
for (i=0; i<list->len; i++) {
item = g_ptr_array_index (list, i);
if (item == NULL || pk_package_get_id (item) == NULL) {
egg_warning ("item invalid!");
break;
}
split = pk_package_id_split (pk_package_get_id (item));
data = g_hash_table_lookup (hash, (gpointer) split[PK_PACKAGE_ID_NAME]);
if (data == NULL) {
/* append just the name */
g_hash_table_insert (hash, g_strdup (split[PK_PACKAGE_ID_NAME]), GINT_TO_POINTER (1));
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, split[PK_PACKAGE_ID_NAME], -1);
}
g_strfreev (split);
}
g_hash_table_unref (hash);
g_ptr_array_unref (list);
return GTK_TREE_MODEL (store);
}
/**
* pk_task_list_get_item:
**/
PkTaskListItem *
pk_task_list_get_item (PkTaskList *tlist, guint item)
{
g_return_val_if_fail (PK_IS_TASK_LIST (tlist), NULL);
if (item >= tlist->priv->task_list->len) {
egg_warning ("item too large!");
return NULL;
}
return g_ptr_array_index (tlist->priv->task_list, item);
}
/**
* ai_generate_create_icon_directories:
**/
static gboolean
ai_generate_create_icon_directories (const gchar *directory)
{
gboolean ret;
GError *error = NULL;
GFile *file;
gchar *path;
guint i;
/* create main directory */
ret = g_file_test (directory, G_FILE_TEST_IS_DIR);
if (!ret) {
file = g_file_new_for_path (directory);
ret = g_file_make_directory (file, NULL, &error);
g_object_unref (file);
if (!ret) {
egg_warning ("cannot create %s: %s", directory, error->message);
g_error_free (error);
goto out;
}
}
/* make sub directories */
for (i=0; icon_sizes[i] != NULL; i++) {
path = g_build_filename (directory, icon_sizes[i], NULL);
ret = g_file_test (path, G_FILE_TEST_IS_DIR);
if (!ret) {
egg_debug ("creating %s", path);
file = g_file_new_for_path (path);
ret = g_file_make_directory (file, NULL, &error);
if (!ret) {
egg_warning ("cannot create %s: %s", path, error->message);
g_clear_error (&error);
}
g_object_unref (file);
}
g_free (path);
}
out:
return ret;
}
/**
* ai_generate_copy_icons:
**/
static gboolean
ai_generate_copy_icons (const gchar *root, const gchar *directory, const gchar *icon_name)
{
gboolean ret;
GError *error = NULL;
GFile *file;
GFile *remote;
gchar *dest;
gchar *iconpath;
gchar *icon_name_full;
guint i;
gboolean found_any_icons = FALSE;
egg_debug ("looking for %s", icon_name);
/* copy all icon sizes if they exist */
for (i=0; icon_sizes[i] != NULL; i++) {
/* get the icon name */
if (g_strstr_len (icon_name, -1, ".") != NULL)
icon_name_full = g_strdup (icon_name);
else if (g_strcmp0 (icon_sizes[i], "scalable") == 0)
icon_name_full = g_strdup_printf ("%s.svg", icon_name);
else
icon_name_full = g_strdup_printf ("%s.png", icon_name);
/* build the icon path */
iconpath = g_build_filename (root, ICONS_DIR, "hicolor", icon_sizes[i], "apps", icon_name_full, NULL);
ret = g_file_test (iconpath, G_FILE_TEST_EXISTS);
if (ret) {
dest = g_build_filename (directory, icon_sizes[i], icon_name_full, NULL);
egg_debug ("copying file %s to %s", iconpath, dest);
file = g_file_new_for_path (iconpath);
remote = g_file_new_for_path (dest);
ret = g_file_copy (file, remote, G_FILE_COPY_TARGET_DEFAULT_PERMS | G_FILE_COPY_OVERWRITE, NULL, NULL, NULL, &error);
if (!ret) {
egg_warning ("cannot copy %s: %s", dest, error->message);
g_clear_error (&error);
}
/* success */
found_any_icons = TRUE;
g_object_unref (file);
g_object_unref (remote);
g_free (dest);
} else {
egg_debug ("does not exist: %s, so not copying", iconpath);
}
g_free (iconpath);
g_free (icon_name_full);
}
return found_any_icons;
}
