static void dispose (GObject *object) { GypsyServerPrivate *priv = GET_PRIVATE (object); if (priv->connection) { dbus_g_connection_unref (priv->connection); priv->connection = NULL; } ((GObjectClass *) gypsy_server_parent_class)->dispose (object); }
void teardown() { g_object_unref(source); source = NULL; g_object_unref(player); player = NULL; g_object_unref(demux); demux = NULL; dbus_g_connection_unref(connection); connection = NULL; }
NS_IMETHODIMP nsGIOService::OrgFreedesktopFileManager1ShowItems(const nsACString& aPath) { #ifndef MOZ_ENABLE_DBUS return NS_ERROR_FAILURE; #else GError* error = nullptr; static bool org_freedesktop_FileManager1_exists = true; if (!org_freedesktop_FileManager1_exists) { return NS_ERROR_NOT_AVAILABLE; } DBusGConnection* dbusGConnection = dbus_g_bus_get(DBUS_BUS_SESSION, &error); if (!dbusGConnection) { if (error) { g_printerr("Failed to open connection to session bus: %s\n", error->message); g_error_free(error); } return NS_ERROR_FAILURE; } char *uri = g_filename_to_uri(PromiseFlatCString(aPath).get(), nullptr, nullptr); if (uri == nullptr) { return NS_ERROR_FAILURE; } DBusConnection* dbusConnection = dbus_g_connection_get_connection(dbusGConnection); // Make sure we do not exit the entire program if DBus connection get lost. dbus_connection_set_exit_on_disconnect(dbusConnection, false); DBusGProxy* dbusGProxy = dbus_g_proxy_new_for_name(dbusGConnection, "org.freedesktop.FileManager1", "/org/freedesktop/FileManager1", "org.freedesktop.FileManager1"); const char *uris[2] = { uri, nullptr }; gboolean rv_dbus_call = dbus_g_proxy_call (dbusGProxy, "ShowItems", nullptr, G_TYPE_STRV, uris, G_TYPE_STRING, "", G_TYPE_INVALID, G_TYPE_INVALID); g_object_unref(dbusGProxy); dbus_g_connection_unref(dbusGConnection); g_free(uri); if (!rv_dbus_call) { org_freedesktop_FileManager1_exists = false; return NS_ERROR_NOT_AVAILABLE; } return NS_OK; #endif }
/* To support the BOT */ BT_EXPORT_API int bluetooth_obex_server_init_without_agent(const char *dst_path) { DBG("+\n"); int ret = BLUETOOTH_ERROR_NONE; DBusGConnection *conn = NULL; _bluetooth_internal_session_init(); if (FALSE == _bluetooth_internal_is_adapter_enabled()) { DBG("Adapter not enabled"); return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED; } if (g_obex_server_info.obex_server_agent) { DBG("Agent already registered"); return BLUETOOTH_ERROR_AGENT_ALREADY_EXIST; } if (NULL == dst_path) { DBG("Invalid Param"); return BLUETOOTH_ERROR_INVALID_PARAM; } /* Get the session bus. This bus reff will be unref during deinit */ conn = dbus_g_bus_get(DBUS_BUS_SESSION, NULL); if (conn == NULL) { DBG("conn is NULL\n"); return BLUETOOTH_ERROR_NO_RESOURCES; } /* Send deinit signal (To deinit the native Obex server) */ __bt_send_deinit_message(); g_dst_path = g_strdup(dst_path); ret = __bt_obex_agent_register(&g_obex_server_info, conn); if (ret != BLUETOOTH_ERROR_NONE) { g_free(g_dst_path); dbus_g_connection_unref(conn); g_obex_server_info.bus = NULL; g_dst_path = NULL; } else { ret = __register_agent_authorize_signal(&g_obex_server_info); } DBG("- \n"); return ret; }
static void dispose (GObject *object) { NMSettingsServicePrivate *priv = NM_SETTINGS_SERVICE_GET_PRIVATE (object); if (!priv->disposed) { priv->disposed = TRUE; if (priv->bus) dbus_g_connection_unref (priv->bus); } G_OBJECT_CLASS (nm_settings_service_parent_class)->dispose (object); }
/* To support the BOT */ BT_EXPORT_API int bluetooth_obex_server_reject_connection(void) { DBG("+"); int ret = BLUETOOTH_ERROR_NONE; DBusGConnection *conn = NULL; DBusGProxy *agent_proxy = NULL; conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, NULL); if (conn == NULL) { DBG("conn is NULL\n"); return BLUETOOTH_ERROR_NO_RESOURCES; } agent_proxy = dbus_g_proxy_new_for_name(conn, "org.bluez.frwk_agent", "/org/bluez/agent/frwk_agent", "org.bluez.Agent"); if (agent_proxy == NULL) { DBG("agent proxy is NULL"); dbus_g_connection_unref(conn); return BLUETOOTH_ERROR_INTERNAL; } if (!dbus_g_proxy_call(agent_proxy, "ReplyAuthorize", NULL, G_TYPE_UINT, BT_REJECT, G_TYPE_INVALID, G_TYPE_INVALID)) { DBG("Fail to ReplyAuthorize"); ret = BLUETOOTH_ERROR_INTERNAL; } g_object_unref(agent_proxy); dbus_g_connection_unref(conn); DBG("-"); return ret; }
static char * get_session (pid_t calling_pid) { DBusGConnection *connection; DBusGProxy *proxy; char *session_id; GError *error = NULL; gboolean ret; connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error); if (error != NULL) { g_warning ("Failed to get bus: %s", error->message); g_error_free (error); return NULL; } proxy = dbus_g_proxy_new_for_name (connection, "org.freedesktop.ConsoleKit", "/org/freedesktop/ConsoleKit/Manager", "org.freedesktop.ConsoleKit.Manager"); ret = dbus_g_proxy_call (proxy, "GetSessionForUnixProcess", &error, G_TYPE_UINT, calling_pid, G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH, &session_id, G_TYPE_INVALID); if (!ret) { /* DBus might time out, which is okay */ if (g_error_matches (error, DBUS_GERROR, DBUS_GERROR_NO_REPLY)) { g_debug ("DBUS timed out, but recovering"); goto out; } /* an actual error */ g_warning ("Couldn't sent GetSessionForUnixProcess: %s", error->message); session_id = NULL; goto out; } session_id = g_strdup (session_id); out: if (error != NULL) g_error_free (error); if (connection != NULL) dbus_g_connection_unref (connection); if (proxy != NULL) g_object_unref (proxy); return session_id; }
static void names_model_set_connection (NamesModel *names_model, DBusGConnection *connection) { g_return_if_fail (IS_NAMES_MODEL (names_model)); if (connection == names_model->connection) return; if (names_model->connection) { dbus_g_proxy_disconnect_signal (names_model->driver_proxy, "NameOwnerChanged", G_CALLBACK (name_owner_changed), names_model); g_object_unref (names_model->driver_proxy); names_model->driver_proxy = NULL; dbus_g_connection_unref (names_model->connection); names_model->connection = NULL; } if (connection) { names_model->connection = connection; dbus_g_connection_ref (names_model->connection); names_model->driver_proxy = dbus_g_proxy_new_for_name (names_model->connection, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS); g_assert (names_model->driver_proxy); dbus_g_proxy_add_signal (names_model->driver_proxy, "NameOwnerChanged", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal (names_model->driver_proxy, "NameOwnerChanged", G_CALLBACK (name_owner_changed), names_model, NULL); } names_model_reload (names_model); }
static void xfpm_info_free (XfpmInfo *info) { if ( info->bus ) dbus_g_connection_unref (info->bus); if ( info->power_proxy ) g_object_unref (info->power_proxy); if ( info->wakeups_proxy ) g_object_unref (info->wakeups_proxy); g_free (info); }
static void mnb_panel_oop_dispose (GObject *self) { MnbPanelOopPrivate *priv = MNB_PANEL_OOP (self)->priv; DBusGProxy *proxy = priv->proxy; if (proxy) { dbus_g_proxy_disconnect_signal (proxy, "RequestFocus", G_CALLBACK (mnb_panel_oop_request_focus_cb), self); dbus_g_proxy_disconnect_signal (proxy, "RequestButtonStyle", G_CALLBACK (mnb_panel_oop_request_button_style_cb), self); dbus_g_proxy_disconnect_signal (proxy, "RequestButtonState", G_CALLBACK (mnb_panel_oop_request_button_state_cb), self); dbus_g_proxy_disconnect_signal (proxy, "RequestModality", G_CALLBACK (mnb_panel_oop_request_modality_cb), self); dbus_g_proxy_disconnect_signal (proxy, "RequestTooltip", G_CALLBACK (mnb_panel_oop_request_tooltip_cb), self); g_object_unref (proxy); priv->proxy = NULL; } if (priv->proxy_for_owner) g_object_weak_unref (G_OBJECT (priv->proxy_for_owner), mnb_panel_oop_dbus_proxy_weak_notify_cb, self); if (priv->dbus_conn) { dbus_g_connection_unref (priv->dbus_conn); priv->dbus_conn = NULL; } if (priv->button) { priv->button = NULL; } g_signal_emit (self, signals[DESTROY], 0); G_OBJECT_CLASS (mnb_panel_oop_parent_class)->dispose (self); }
/** * Finalize this object. */ static void glim_counter_factory_finalize (GObject *obj) { GlimCounterFactory *self = GLIM_COUNTER_FACTORY (obj); // Deallocate allocated fields if (self->connection != NULL) { dbus_g_connection_unref (self->connection); self->connection = NULL; } (G_OBJECT_CLASS (glim_counter_factory_parent_class))->finalize (obj); } // glim_counter_factory_finalize
static void hd_search_service_dispose (GObject *object) { HDSearchService *search_service = HD_SEARCH_SERVICE (object); HDSearchServicePrivate *priv = search_service->priv; if (priv->tracker_proxy) priv->tracker_proxy = (g_object_unref (priv->tracker_proxy), NULL); if (priv->session_dbus) priv->session_dbus = (dbus_g_connection_unref (priv->session_dbus), NULL); G_OBJECT_CLASS (hd_search_service_parent_class)->dispose (object); }
static void galeon_dbus_shutdown (GaleonDbus *dbus) { GaleonDbusPrivate *priv = dbus->priv; // LOG ("GaleonDbus shutdown"); if (priv->session_reconnect_timeout_id != 0) { g_source_remove (priv->session_reconnect_timeout_id); priv->session_reconnect_timeout_id = 0; } if (priv->system_reconnect_timeout_id != 0) { g_source_remove (priv->system_reconnect_timeout_id); priv->system_reconnect_timeout_id = 0; } if (priv->session_bus) { dbus_connection_remove_filter (dbus_g_connection_get_connection (priv->session_bus), session_filter_func, dbus); dbus_g_connection_unref (priv->session_bus); priv->session_bus = NULL; } if (priv->system_bus) { dbus_connection_remove_filter (dbus_g_connection_get_connection (priv->system_bus), system_filter_func, dbus); dbus_g_connection_unref (priv->system_bus); priv->system_bus = NULL; } }
static gboolean get_all_connections (void) { GError *error = NULL; DBusGConnection *bus; DBusGProxy *proxy = NULL; GPtrArray *paths = NULL; int i; gboolean sucess = FALSE; bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error); if (error || !bus) { g_warning ("error: could not connect to dbus"); goto out; } proxy = dbus_g_proxy_new_for_name (bus, NM_DBUS_SERVICE, NM_DBUS_PATH_SETTINGS, NM_DBUS_IFACE_SETTINGS); if (!proxy) { g_warning ("error: failed to create DBus proxy for settings service"); goto out; } if (!dbus_g_proxy_call (proxy, "ListConnections", &error, G_TYPE_INVALID, DBUS_TYPE_G_ARRAY_OF_OBJECT_PATH, &paths, G_TYPE_INVALID)) { /* No connections or settings service may not be running */ g_clear_error (&error); goto out; } connections = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref); for (i = 0; paths && (i < paths->len); i++) get_one_connection (bus, g_ptr_array_index (paths, i), connections); sucess = TRUE; out: if (bus) dbus_g_connection_unref (bus); if (proxy) g_object_unref (proxy); return sucess; }
static void vim_widget_finalize (GObject *object) { VimWidget* widget = VIM_WIDGET (object); VimWidgetClass* klass = VIM_WIDGET_CLASS (g_type_class_peek (VIM_TYPE_WIDGET)); VimWidgetPrivate *priv = widget->priv; dbus_g_connection_unref (priv->conn); g_object_unref (priv->dbus_proxy); g_object_unref (priv->proxy); g_free (widget->priv); klass->widget = NULL; parent_class->finalize (object); }
int main() { g_type_init(); ctx = JSGlobalContextCreate(NULL); DBusGConnection *con = dbus_g_bus_get(DBUS_BUS_SESSION, NULL); JSObjectRef obj = get_dbus_object(ctx, con, "org.gnome.Shell", "/org/gnome/Shell", "org.gnome.Shell"); dbus_g_connection_unref(con); JSGlobalContextRelease(ctx); /*dbus_object_info_free(info);*/ }
int main (int argc, char *argv[]) { DBusGConnection *bus; NMClient *client; const GPtrArray *devices; int i; /* Initialize GType system */ g_type_init (); /* Get system bus */ bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, NULL); /* Get NMClient object */ client = nm_client_new (); if (!client) { dbus_g_connection_unref (bus); g_message ("Error: Could not create NMClient."); return EXIT_FAILURE; } /* Get all devices managed by NetworkManager */ devices = nm_client_get_devices (client); /* Go through the array and process Wi-Fi devices */ for (i = 0; devices && (i < devices->len); i++) { NMDevice *device = g_ptr_array_index (devices, i); if (NM_IS_DEVICE_WIFI (device)) show_wifi_device_info (device); } g_object_unref (client); dbus_g_connection_unref (bus); return EXIT_SUCCESS; }
static void modem_tones_finalize(GObject *object) { ModemTones *self = MODEM_TONES(object); ModemTonesPrivate *priv = self->priv; g_timer_destroy(priv->timer); ngf_client_destroy(priv->ngf); g_hash_table_destroy(priv->notify_map); dbus_g_connection_unref(priv->connection); memset(priv, 0, (sizeof *priv)); G_OBJECT_CLASS(modem_tones_parent_class)->finalize(object); }
gboolean kone_dbus_server_connect(KoneDBusServer *dbus_server) { DBusGConnection *connection; GError *error = NULL; connection = dbus_g_bus_get(DBUS_BUS_SESSION, &error); if (!connection) { g_warning(_("Could not get dbus: %s"), error->message); return FALSE; } dbus_g_connection_register_g_object(connection, KONE_DBUS_SERVER_PATH, (GObject *)dbus_server); dbus_g_connection_unref(connection); return TRUE; }
static void device_removed (const char *bdaddr) { GError *error = NULL; DBusGConnection *bus; RemoveInfo *info; struct ether_addr *addr; NmaBtDevice *device; g_message ("Device '%s' was removed; deleting connections", bdaddr); /* Remove any connections associated with the deleted device */ addr = ether_aton (bdaddr); if (!addr) { g_warning ("Failed to convert Bluetooth address '%s'", bdaddr); return; } bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error); if (error || !bus) { g_warning ("%s: failed to get a connection to D-Bus! %s", __func__, error ? error->message : "(unknown)"); g_clear_error (&error); return; } info = g_malloc0 (sizeof (RemoveInfo)); info->settings = nm_remote_settings_new (bus); info->bdaddr = g_byte_array_sized_new (ETH_ALEN); g_byte_array_append (info->bdaddr, (const guint8 *) addr->ether_addr_octet, ETH_ALEN); info->str_bdaddr = g_strdup (bdaddr); info->timeout_id = g_timeout_add_seconds (15, remove_timeout, info); g_signal_connect (info->settings, NM_REMOTE_SETTINGS_CONNECTIONS_READ, G_CALLBACK (remove_connections_read), info); dbus_g_connection_unref (bus); /* Kill the device */ device = get_device (bdaddr); if (device) remove_device (device); }
gboolean gupnp_network_manager_is_available (GMainContext *main_context) { DBusConnection *connection; DBusError derror; DBusGConnection *gconnection; DBusGProxy *dbus_proxy; GError *error = NULL; gboolean ret = FALSE; /* Do fake open to initialize types */ dbus_g_connection_open ("", NULL); dbus_error_init (&derror); connection = dbus_bus_get_private (DBUS_BUS_SYSTEM, &derror); if (connection == NULL) { g_message ("Failed to connect to System Bus: %s", derror.message); return FALSE; } dbus_connection_setup_with_g_main (connection, main_context); gconnection = dbus_connection_get_g_connection (connection); dbus_proxy = dbus_g_proxy_new_for_name (gconnection, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS); if (!dbus_g_proxy_call (dbus_proxy, "NameHasOwner", &error, G_TYPE_STRING, DBUS_SERVICE_NM, G_TYPE_INVALID, G_TYPE_BOOLEAN, &ret, G_TYPE_INVALID)) { g_warning ("%s.NameHasOwner() failed: %s", DBUS_INTERFACE_DBUS, error->message); g_error_free (error); } g_object_unref (dbus_proxy); dbus_connection_close (connection); dbus_g_connection_unref (gconnection); return ret; }
static void dispose (GObject *object) { SCPluginIfcfg *plugin = SC_PLUGIN_IFCFG (object); SCPluginIfcfgPrivate *priv = SC_PLUGIN_IFCFG_GET_PRIVATE (plugin); NMInotifyHelper *ih; if (priv->bus) { dbus_g_connection_unref (priv->bus); priv->bus = NULL; } if (priv->ih_event_id) { ih = nm_inotify_helper_get (); g_signal_handler_disconnect (ih, priv->ih_event_id); priv->ih_event_id = 0; if (priv->sc_network_wd >= 0) nm_inotify_helper_remove_watch (ih, priv->sc_network_wd); } if (priv->hostname_monitor) { if (priv->hostname_monitor_id) g_signal_handler_disconnect (priv->hostname_monitor, priv->hostname_monitor_id); g_file_monitor_cancel (priv->hostname_monitor); g_object_unref (priv->hostname_monitor); } g_free (priv->hostname); if (priv->connections) { g_hash_table_destroy (priv->connections); priv->connections = NULL; } if (priv->ifcfg_monitor) { if (priv->ifcfg_monitor_id) g_signal_handler_disconnect (priv->ifcfg_monitor, priv->ifcfg_monitor_id); g_file_monitor_cancel (priv->ifcfg_monitor); g_object_unref (priv->ifcfg_monitor); } G_OBJECT_CLASS (sc_plugin_ifcfg_parent_class)->dispose (object); }
int main() { DBusGConnection *connection; GError *error; DBusGProxy *proxy; DBusGProxyCall* call; gint res; gint res1 = 0; g_type_init (); error = NULL; connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error); if (connection == NULL) { std_log(LOG_FILENAME_LINE, "Failed to open connection to bus: %s\n", error->message); g_error_free (error); create_xml(1); exit (1); } proxy = dbus_g_proxy_new_for_name (connection, "com.example.DBusGlibObject1", "/com/example/DBusGlibObject1", "com.example.DBusGlibObject1"); call = dbus_g_proxy_begin_call_with_timeout(proxy, "Simple_method", simple_method_reply_handler, &res1, NULL, 10000, G_TYPE_INT, 5, G_TYPE_INVALID, G_TYPE_INT, &res, G_TYPE_INVALID); mainLoop = g_main_loop_new(NULL,FALSE); g_main_loop_run(mainLoop); std_log(LOG_FILENAME_LINE, "res = %d, res1 = %d", res, res1); if(res1 != 9090) { std_log(LOG_FILENAME_LINE, "return value is not matching."); create_xml(1); return 1; } dbus_g_connection_unref(connection); std_log(LOG_FILENAME_LINE, "Test Successful"); create_xml(0); return 0; }
static gboolean dbus_init (GMainLoop * loop) { DBusGConnection *connection; DBusGProxy *proxy; GError *err = NULL; int request_name_result; connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &err); if (!connection) { g_warning ("Could not get the system bus. Make sure " "the message bus daemon is running! Message: %s", err->message); g_error_free (err); return FALSE; } proxy = dbus_g_proxy_new_for_name (connection, DBUS_FDO_NAME, DBUS_FDO_PATH, DBUS_FDO_INTERFACE); if (!dbus_g_proxy_call (proxy, "RequestName", &err, G_TYPE_STRING, MBM_DBUS_SERVICE, G_TYPE_UINT, DBUS_NAME_FLAG_DO_NOT_QUEUE, G_TYPE_INVALID, G_TYPE_UINT, &request_name_result, G_TYPE_INVALID)) { g_warning ("Could not acquire the %s service.\n" " Message: '%s'", MBM_DBUS_SERVICE, err->message); g_error_free (err); goto err; } if (request_name_result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) { g_warning ("Could not acquire the MBM GPS service " "as it is already taken. Return: %d", request_name_result); goto err; } g_signal_connect (proxy, "destroy", G_CALLBACK (destroy_cb), loop); return TRUE; err:dbus_g_connection_unref (connection); g_object_unref (proxy); return FALSE; }
static DBusHandlerResult signal_filter(DBusConnection *connection, DBusMessage *message, void *user_data) { if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) { g_message("Disconnected from DBus"); g_object_unref(udisks_proxy); udisks_proxy = NULL; dbus_g_connection_unref(dbus_bus); dbus_bus = NULL; g_timeout_add(1000, reinit_udisks_connection, NULL); return DBUS_HANDLER_RESULT_HANDLED; } return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
static DBusGProxy * connect_gnome_screensaverd (MexScreensaver *self) { MexScreensaverPrivate *priv = MEX_SCREENSAVER (self)->priv; DBusGConnection *dbus_connection; DBusGProxy *proxy; GError *error=NULL; dbus_connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error); if (dbus_connection == NULL) { g_warning ("Failed to connect to dbus %s\n", (error) ? error->message : ""); if (error) g_error_free (error); return NULL; } /* Try with gnome 2 api first. gnome_version 0 is the default * representing the undetermined state */ if (priv->gnome_version == 2 || priv->gnome_version == 0) { proxy = dbus_g_proxy_new_for_name (dbus_connection, "org.gnome.ScreenSaver", "/org/gnome/ScreenSaver", "org.gnome.ScreenSaver"); } /* The gnome 2 api didn't work and we've been called again with version 3 */ if (priv->gnome_version == 3) { proxy = dbus_g_proxy_new_for_name (dbus_connection, "org.gnome.SessionManager", "/org/gnome/SessionManager", "org.gnome.SessionManager"); } dbus_g_connection_unref (dbus_connection); return proxy; }
static void cdma_device_info_free (gpointer data) { CdmaDeviceInfo *info = data; if (info->props_proxy) g_object_unref (info->props_proxy); if (info->cdma_proxy) g_object_unref (info->cdma_proxy); if (info->bus) dbus_g_connection_unref (info->bus); if (info->poll_id) g_source_remove (info->poll_id); if (info->mobile_providers_database) g_object_unref (info->mobile_providers_database); g_free (info->provider_name); memset (info, 0, sizeof (CdmaDeviceInfo)); g_free (info); }
/** * urf_killswitch_dispose: **/ static void urf_killswitch_dispose (GObject *object) { UrfKillswitch *killswitch = URF_KILLSWITCH (object); UrfKillswitchPrivate *priv = killswitch->priv; if (priv->connection) { dbus_g_connection_unref (priv->connection); priv->connection = NULL; } if (priv->devices) { g_list_foreach (priv->devices, (GFunc) g_object_unref, NULL); g_list_free (priv->devices); priv->devices = NULL; } G_OBJECT_CLASS (urf_killswitch_parent_class)->dispose (object); }
void theme_install_file(GtkWindow* parent, const gchar* path) { DBusGConnection* connection; DBusGProxy* proxy; GError* error = NULL; gboolean ret; connection = dbus_g_bus_get(DBUS_BUS_SESSION, NULL); if (connection == NULL) { g_warning("Could not get session bus"); return; } proxy = dbus_g_proxy_new_for_name(connection, "org.freedesktop.PackageKit", "/org/freedesktop/PackageKit", "org.freedesktop.PackageKit"); ret = dbus_g_proxy_call(proxy, "InstallProvideFile", &error, G_TYPE_STRING, path, G_TYPE_INVALID, G_TYPE_INVALID); g_object_unref(proxy); if (!ret) { GtkWidget* dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Could not install theme engine")); gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG (dialog), "%s", error->message); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); g_error_free(error); } dbus_g_connection_unref(connection); }
static void mojito_client_service_dispose (GObject *object) { MojitoClientServicePrivate *priv = GET_PRIVATE (object); gint i = 0; if (priv->connection) { dbus_g_connection_unref (priv->connection); priv->connection = NULL; } for (i = 0; i < LAST_IFACE; i++) { g_object_unref (priv->proxies[i]); priv->proxies[i] = NULL; } G_OBJECT_CLASS (mojito_client_service_parent_class)->dispose (object); }