/* Dispose this object */
static void _xfdashboard_view_selector_dispose(GObject *inObject)
{
XfdashboardViewSelector *self=XFDASHBOARD_VIEW_SELECTOR(inObject);
XfdashboardViewSelectorPrivate *priv=self->priv;
ClutterActorIter iter;
ClutterActor *child;
gpointer view;
/* Release allocated resources */
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(self));
while(clutter_actor_iter_next(&iter, &child))
{
/* Check if child is a button otherwise continue iterating */
if(!XFDASHBOARD_IS_TOGGLE_BUTTON(child)) continue;
/* If button has reference to a view remove signal handlers it */
view=g_object_get_data(G_OBJECT(child), "view");
if(view) g_signal_handlers_disconnect_by_data(view, child);
}
if(priv->viewpad)
{
g_signal_handlers_disconnect_by_data(priv->viewpad, self);
g_object_unref(priv->viewpad);
priv->viewpad=NULL;
}
/* Call parent's class dispose method */
G_OBJECT_CLASS(xfdashboard_view_selector_parent_class)->dispose(inObject);
}
static void
uni_image_view_finalize (GObject * object)
{
UniImageView *view = UNI_IMAGE_VIEW (object);
if (view->hadj)
{
g_signal_handlers_disconnect_by_data (G_OBJECT (view->hadj), view);
g_object_unref (view->hadj);
view->hadj = NULL;
}
if (view->vadj)
{
g_signal_handlers_disconnect_by_data (G_OBJECT (view->vadj), view);
g_object_unref (view->vadj);
view->vadj = NULL;
}
if (view->pixbuf)
{
g_object_unref (view->pixbuf);
view->pixbuf = NULL;
}
g_object_unref (view->tool);
/* Chain up. */
G_OBJECT_CLASS (uni_image_view_parent_class)->finalize (object);
}
static void
wnck_action_menu_dispose (GObject *object)
{
WnckActionMenu *menu;
menu = WNCK_ACTION_MENU (object);
if (menu->priv->idle_handler)
{
g_source_remove (menu->priv->idle_handler);
menu->priv->idle_handler = 0;
}
if (WNCK_IS_WINDOW (menu->priv->window))
{
g_object_weak_unref (G_OBJECT (menu->priv->window), window_weak_notify, menu);
g_signal_handlers_disconnect_by_data (menu->priv->window, menu);
WnckScreen *screen = wnck_window_get_screen (menu->priv->window);
g_signal_handlers_disconnect_by_data (screen, menu);
menu->priv->window = NULL;
}
G_OBJECT_CLASS (wnck_action_menu_parent_class)->dispose (object);
}
static void
uni_image_view_set_scroll_adjustments (UniImageView * view,
GtkAdjustment * hadj,
GtkAdjustment * vadj)
{
if (hadj && view->hadj && view->hadj != hadj)
{
g_signal_handlers_disconnect_by_data (G_OBJECT (view->hadj), view);
g_object_unref (view->hadj);
g_signal_connect (G_OBJECT (hadj),
"value_changed",
G_CALLBACK (uni_image_view_hadj_changed_cb), view);
view->hadj = hadj;
g_object_ref_sink (view->hadj);
}
if (vadj && view->vadj && view->vadj != vadj)
{
g_signal_handlers_disconnect_by_data (G_OBJECT (view->vadj), view);
g_object_unref (view->vadj);
g_signal_connect (G_OBJECT (vadj),
"value_changed",
G_CALLBACK (uni_image_view_vadj_changed_cb), view);
view->vadj = vadj;
g_object_ref_sink (view->vadj);
}
}
static void
_gtk_text_handle_set_scrollable (GtkTextHandle *handle,
GtkScrollable *scrollable)
{
GtkTextHandlePrivate *priv;
priv = handle->priv;
if (priv->parent_scrollable)
{
if (priv->vadj)
{
g_signal_handlers_disconnect_by_data (priv->vadj, handle);
g_object_unref (priv->vadj);
priv->vadj = NULL;
}
if (priv->hadj)
{
g_signal_handlers_disconnect_by_data (priv->hadj, handle);
g_object_unref (priv->hadj);
priv->hadj = NULL;
}
g_object_remove_weak_pointer (G_OBJECT (priv->parent_scrollable), (gpointer *) &priv->parent_scrollable);
}
priv->parent_scrollable = scrollable;
if (scrollable)
{
g_object_add_weak_pointer (G_OBJECT (priv->parent_scrollable), (gpointer *) &priv->parent_scrollable);
priv->vadj = gtk_scrollable_get_vadjustment (scrollable);
priv->hadj = gtk_scrollable_get_hadjustment (scrollable);
if (priv->vadj)
{
g_object_ref (priv->vadj);
g_signal_connect (priv->vadj, "changed",
G_CALLBACK (adjustment_changed_cb), handle);
g_signal_connect (priv->vadj, "value-changed",
G_CALLBACK (adjustment_changed_cb), handle);
}
if (priv->hadj)
{
g_object_ref (priv->hadj);
g_signal_connect (priv->hadj, "changed",
G_CALLBACK (adjustment_changed_cb), handle);
g_signal_connect (priv->hadj, "value-changed",
G_CALLBACK (adjustment_changed_cb), handle);
}
}
}
static void destroy_tasklist(GtkWidget* widget, TasklistData* tasklist)
{
g_signal_handlers_disconnect_by_data (G_OBJECT (tasklist->applet), tasklist);
g_signal_handlers_disconnect_by_data (tasklist->settings, tasklist);
g_object_unref(tasklist->settings);
if (tasklist->properties_dialog)
gtk_widget_destroy(tasklist->properties_dialog);
g_free(tasklist);
}
static gboolean run_datachannel_test(const gchar *label, OwrDataChannel *left, OwrDataChannel *right)
{
GAsyncQueue *msg_queue = g_async_queue_new();
gchar *received_message;
gint expected_message_count = 4;
const gchar *binary_message;
int i;
g_print("[%s] starting\n", label);
g_signal_connect(left, "on-data", G_CALLBACK(on_data), msg_queue);
g_signal_connect(right, "on-data", G_CALLBACK(on_data), msg_queue);
g_signal_connect(left, "on-binary-data", G_CALLBACK(on_binary_data), msg_queue);
g_signal_connect(right, "on-binary-data", G_CALLBACK(on_binary_data), msg_queue);
g_print("[%s] sending messages\n", label);
owr_data_channel_send(left, "text: left->right");
owr_data_channel_send(right, "text: right->left");
binary_message = "binary: left->right";
owr_data_channel_send_binary(left, (const guint8 *) binary_message, strlen(binary_message));
binary_message = "binary: right->left";
owr_data_channel_send_binary(right, (const guint8 *) binary_message, strlen(binary_message));
g_print("[%s] expecting messages\n", label);
for (i = 0; i < expected_message_count; i++) {
received_message = g_async_queue_timeout_pop(msg_queue, 5000000);
if (received_message) {
g_print("[%s] received message: %s\n", label, received_message);
g_free(received_message);
} else {
g_print("[%s] *** timeout while waiting for message\n", label);
break;
}
}
g_signal_handlers_disconnect_by_data(left, msg_queue);
g_signal_handlers_disconnect_by_data(right, msg_queue);
g_async_queue_unref(msg_queue);
if (i >= expected_message_count) {
g_print("[%s] Success, ", label);
} else {
g_print("[%s] Failure, ", label);
}
g_print("received %d / %d messages\n", i, expected_message_count);
return i >= expected_message_count;
}
static void
on_progress_info_started (NautilusProgressInfo *info,
NautilusToolbar *self)
{
g_signal_handlers_disconnect_by_data (info, self);
schedule_operations_start (self);
}
/* Dispose this object */
static void _xfdashboard_application_tracker_dispose(GObject *inObject)
{
XfdashboardApplicationTracker *self=XFDASHBOARD_APPLICATION_TRACKER(inObject);
XfdashboardApplicationTrackerPrivate *priv=self->priv;
/* Release allocated resources */
if(priv->runningApps)
{
g_list_free_full(priv->runningApps, (GDestroyNotify)_xfdashboard_application_tracker_item_free);
priv->runningApps=NULL;
}
if(priv->windowTracker)
{
g_signal_handlers_disconnect_by_data(priv->windowTracker, self);
g_object_unref(priv->windowTracker);
priv->windowTracker=NULL;
}
if(priv->appDatabase)
{
g_object_unref(priv->appDatabase);
priv->appDatabase=NULL;
}
/* Unset singleton */
if(G_LIKELY(G_OBJECT(_xfdashboard_application_tracker)==inObject))
{
_xfdashboard_application_tracker=NULL;
}
/* Call parent's class dispose method */
G_OBJECT_CLASS(xfdashboard_application_tracker_parent_class)->dispose(inObject);
}
static void
dispose (GObject *object)
{
NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (object);
if (priv->iface_proxy)
g_signal_handlers_disconnect_by_data (priv->iface_proxy, NM_SUPPLICANT_INTERFACE (object));
g_clear_object (&priv->iface_proxy);
if (priv->init_cancellable)
g_cancellable_cancel (priv->init_cancellable);
g_clear_object (&priv->init_cancellable);
if (priv->other_cancellable)
g_cancellable_cancel (priv->other_cancellable);
g_clear_object (&priv->other_cancellable);
g_clear_object (&priv->wpas_proxy);
g_clear_pointer (&priv->bss_proxies, (GDestroyNotify) g_hash_table_destroy);
g_clear_pointer (&priv->net_path, g_free);
g_clear_pointer (&priv->dev, g_free);
g_clear_pointer (&priv->object_path, g_free);
g_clear_pointer (&priv->current_bss, g_free);
g_clear_object (&priv->cfg);
/* Chain up to the parent class */
G_OBJECT_CLASS (nm_supplicant_interface_parent_class)->dispose (object);
}
GriloRegistry::~GriloRegistry() {
foreach (const QString &source, m_sources) {
GrlSource *src = lookupSource(source);
if (src) {
g_signal_handlers_disconnect_by_data(src, this);
}
}
static void
gth_category_selection_finalize (GObject *object)
{
GthCategorySelection *category_sel;
category_sel = GTH_CATEGORY_SELECTION (object);
if (category_sel->priv != NULL) {
if (category_sel->priv->dialog != NULL)
g_signal_handlers_disconnect_by_data (category_sel->priv->dialog, category_sel);
g_free (category_sel->priv->categories);
category_sel->priv->categories = NULL;
if (category_sel->priv->gui != NULL) {
g_object_unref (category_sel->priv->gui);
category_sel->priv->gui = NULL;
}
g_free (category_sel->priv);
category_sel->priv = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
/* Finalize this object */
static void cookie_permission_manager_finalize(GObject *inObject)
{
CookiePermissionManager *self=COOKIE_PERMISSION_MANAGER(inObject);
CookiePermissionManagerPrivate *priv=self->priv;
GList *browsers, *browser;
GList *tabs, *tab;
WebKitWebView *webkitView;
/* Dispose allocated resources */
if(priv->databaseFilename)
{
g_free(priv->databaseFilename);
priv->databaseFilename=NULL;
g_object_notify_by_pspec(inObject, CookiePermissionManagerProperties[PROP_DATABASE_FILENAME]);
}
if(priv->database)
{
sqlite3_close(priv->database);
priv->database=NULL;
g_object_notify_by_pspec(inObject, CookiePermissionManagerProperties[PROP_DATABASE]);
}
g_signal_handler_disconnect(priv->cookieJar, priv->cookieJarChangedID);
g_object_steal_data(G_OBJECT(priv->cookieJar), "cookie-permission-manager");
g_signal_handlers_disconnect_by_data(priv->application, self);
browsers=midori_app_get_browsers(priv->application);
for(browser=browsers; browser; browser=g_list_next(browser))
{
g_signal_handlers_disconnect_by_data(browser->data, self);
tabs=midori_browser_get_tabs(MIDORI_BROWSER(browser->data));
for(tab=tabs; tab; tab=g_list_next(tab))
{
webkitView=WEBKIT_WEB_VIEW(midori_view_get_web_view(MIDORI_VIEW(tab->data)));
g_signal_handlers_disconnect_by_data(webkitView, self);
}
g_list_free(tabs);
}
g_list_free(browsers);
/* Call parent's class finalize method */
G_OBJECT_CLASS(cookie_permission_manager_parent_class)->finalize(inObject);
}
static void
mate_panel_applet_destroy (GtkWidget *widget,
AppletInfo *info)
{
g_return_if_fail (info != NULL);
g_signal_handlers_disconnect_by_data(info->settings,widget);
info->widget = NULL;
if (info->settings) {
g_object_unref (info->settings);
info->settings = NULL;
}
registered_applets = g_slist_remove (registered_applets, info);
queued_position_saves =
g_slist_remove (queued_position_saves, info);
if (info->type == PANEL_OBJECT_DRAWER) {
Drawer *drawer = info->data;
if (drawer->toplevel) {
PanelWidget *panel_widget;
panel_widget = panel_toplevel_get_panel_widget (
drawer->toplevel);
panel_widget->master_widget = NULL;
gtk_widget_destroy (GTK_WIDGET (drawer->toplevel));
drawer->toplevel = NULL;
}
}
if (info->type != PANEL_OBJECT_APPLET)
panel_lockdown_notify_remove (G_CALLBACK (mate_panel_applet_recreate_menu),
info);
if (info->menu) {
g_signal_handlers_disconnect_by_func (info->menu, G_CALLBACK (applet_menu_show), info);
g_signal_handlers_disconnect_by_func (info->menu, G_CALLBACK (applet_menu_deactivate), info);
g_object_unref (info->menu);
}
info->menu = NULL;
if (info->data_destroy)
info->data_destroy (info->data);
info->data = NULL;
mate_panel_applet_clear_user_menu (info);
g_free (info->id);
info->id = NULL;
g_free (info);
}
static void
on_transport_init (CockpitWebService *service,
gpointer user_data)
{
GSimpleAsyncResult *result = user_data;
g_signal_handlers_disconnect_by_data (service, result);
g_simple_async_result_complete_in_idle (result);
g_object_unref (result);
}
static void
handoff_cb (GstElement * fakesink, GstBuffer * buff, GstPad * pad,
gpointer user_data)
{
calculate_latency (pad, buff);
g_idle_add ((GSourceFunc) quit_main_loop, user_data);
g_signal_handlers_disconnect_by_data (fakesink, user_data);
}
static void
disconnect_progress_infos (NautilusToolbar *self)
{
GList *progress_infos;
GList *l;
progress_infos = nautilus_progress_info_manager_get_all_infos (self->priv->progress_manager);
for (l = progress_infos; l != NULL; l = l->next) {
g_signal_handlers_disconnect_by_data (l->data, self);
}
}
static void
companion_cleanup (NMDeviceOlpcMesh *self)
{
NMDeviceOlpcMeshPrivate *priv = NM_DEVICE_OLPC_MESH_GET_PRIVATE (self);
if (priv->companion) {
g_signal_handlers_disconnect_by_data (priv->companion, self);
g_clear_object (&priv->companion);
}
g_object_notify (G_OBJECT (self), NM_DEVICE_OLPC_MESH_COMPANION);
}
static void
liferea_htmlview_finalize (GObject *object)
{
LifereaHtmlView *htmlview = LIFEREA_HTMLVIEW (object);
browser_history_free (htmlview->priv->history);
g_signal_handlers_disconnect_by_data (network_monitor_get (), object);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
nautilus_progress_info_widget_dispose (GObject *obj)
{
NautilusProgressInfoWidget *self = NAUTILUS_PROGRESS_INFO_WIDGET (obj);
if (self->priv->info != NULL) {
g_signal_handlers_disconnect_by_data (self->priv->info, self);
}
g_clear_object (&self->priv->info);
G_OBJECT_CLASS (nautilus_progress_info_widget_parent_class)->dispose (obj);
}
static void
set_state (NMSupplicantInterface *self, guint32 new_state)
{
NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);
guint32 old_state = priv->state;
g_return_if_fail (new_state < NM_SUPPLICANT_INTERFACE_STATE_LAST);
if (new_state == priv->state)
return;
/* DOWN is a terminal state */
g_return_if_fail (priv->state != NM_SUPPLICANT_INTERFACE_STATE_DOWN);
/* Cannot regress to READY, STARTING, or INIT from higher states */
if (priv->state >= NM_SUPPLICANT_INTERFACE_STATE_READY)
g_return_if_fail (new_state > NM_SUPPLICANT_INTERFACE_STATE_READY);
if (new_state == NM_SUPPLICANT_INTERFACE_STATE_READY) {
if (priv->other_cancellable) {
g_warn_if_fail (priv->other_cancellable == NULL);
g_cancellable_cancel (priv->other_cancellable);
g_clear_object (&priv->other_cancellable);
}
priv->other_cancellable = g_cancellable_new ();
} else if (new_state == NM_SUPPLICANT_INTERFACE_STATE_DOWN) {
if (priv->init_cancellable)
g_cancellable_cancel (priv->init_cancellable);
g_clear_object (&priv->init_cancellable);
if (priv->other_cancellable)
g_cancellable_cancel (priv->other_cancellable);
g_clear_object (&priv->other_cancellable);
if (priv->iface_proxy)
g_signal_handlers_disconnect_by_data (priv->iface_proxy, self);
}
priv->state = new_state;
if ( priv->state == NM_SUPPLICANT_INTERFACE_STATE_SCANNING
|| old_state == NM_SUPPLICANT_INTERFACE_STATE_SCANNING)
priv->last_scan = nm_utils_get_monotonic_timestamp_s ();
/* Disconnect reason is no longer relevant when not in the DISCONNECTED state */
if (priv->state != NM_SUPPLICANT_INTERFACE_STATE_DISCONNECTED)
priv->disconnect_reason = 0;
g_signal_emit (self, signals[STATE], 0,
priv->state,
old_state,
priv->disconnect_reason);
}
/* Dispose this object */
static void _xfdashboard_live_workspace_dispose(GObject *inObject)
{
XfdashboardLiveWorkspace *self=XFDASHBOARD_LIVE_WORKSPACE(inObject);
XfdashboardLiveWorkspacePrivate *priv=self->priv;
/* Dispose allocated resources */
if(priv->windowTracker)
{
g_signal_handlers_disconnect_by_data(priv->windowTracker, self);
g_object_unref(priv->windowTracker);
priv->windowTracker=NULL;
}
if(priv->workspace)
{
g_signal_handlers_disconnect_by_data(priv->workspace, self);
priv->workspace=NULL;
}
/* Call parent's class dispose method */
G_OBJECT_CLASS(xfdashboard_live_workspace_parent_class)->dispose(inObject);
}
virtual ~wxTextAutoCompleteData()
{
// Note that we must not use m_entry here because this could result in
// using an already half-destroyed wxTextEntry when we're destroyed
// from its dtor (which is executed after wxTextCtrl dtor, which had
// already destroyed the actual entry). So use the stored widget
// instead and only after checking that it is still valid.
if ( GTK_IS_ENTRY(m_widgetEntry) )
{
gtk_entry_set_completion(m_widgetEntry, NULL);
g_signal_handlers_disconnect_by_data(m_widgetEntry, this);
}
}
static void
window_archive_loaded_cb (FrWindow *window,
gboolean success,
GtkWidget *file_sel)
{
if (success) {
g_signal_handlers_disconnect_by_data (window, file_sel);
gtk_widget_destroy (file_sel);
}
else {
FrWindow *original_window = g_object_get_data (G_OBJECT (file_sel), "fr_window");
if (window != original_window)
fr_window_destroy_with_error_dialog (window);
}
}
/* Dispose this object */
static void _xfdashboard_window_tracker_monitor_dispose(GObject *inObject)
{
XfdashboardWindowTrackerMonitor *self=XFDASHBOARD_WINDOW_TRACKER_MONITOR(inObject);
XfdashboardWindowTrackerMonitorPrivate *priv=self->priv;
/* Release allocated resources */
if(priv->screen)
{
g_signal_handlers_disconnect_by_data(priv->screen, self);
priv->screen=NULL;
}
/* Call parent's class dispose method */
G_OBJECT_CLASS(xfdashboard_window_tracker_monitor_parent_class)->dispose(inObject);
}
/* called when the main dialog is closed. */
static void
destroy_cb (GtkWidget *widget,
DialogData *data)
{
if (data->pixop != NULL) {
if (data->dialog_preview)
g_signal_handlers_disconnect_by_data (data->pixop, data);
g_object_unref (data->pixop);
}
g_object_unref (data->image);
g_object_unref (data->orig_pixbuf);
g_object_unref (data->new_pixbuf);
g_object_unref (data->gui);
g_free (data);
}
static void
impl_dispose (GObject *object)
{
RBDisplayPageMenu *menu;
menu = RB_DISPLAY_PAGE_MENU (object);
if (menu->priv->model) {
g_signal_handlers_disconnect_by_data (menu->priv->model, menu);
g_clear_object (&menu->priv->model);
}
g_clear_object (&menu->priv->root_page);
G_OBJECT_CLASS (rb_display_page_menu_parent_class)->dispose (object);
}
static void
fr_file_selector_dialog_finalize (GObject *object)
{
FrFileSelectorDialog *self;
self = FR_FILE_SELECTOR_DIALOG (object);
g_signal_handlers_disconnect_by_data (g_volume_monitor_get (), self);
g_object_unref (self->priv->builder);
_g_object_unref (self->priv->current_folder);
g_object_unref (self->priv->settings);
G_OBJECT_CLASS (fr_file_selector_dialog_parent_class)->finalize (object);
}
static void
soup_connection_finalize (GObject *object)
{
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (object);
g_clear_pointer (&priv->remote_uri, soup_uri_free);
g_clear_pointer (&priv->proxy_uri, soup_uri_free);
g_clear_pointer (&priv->socket_props, soup_socket_properties_unref);
g_clear_object (&priv->current_msg);
if (priv->socket) {
g_signal_handlers_disconnect_by_data (priv->socket, object);
g_object_unref (priv->socket);
}
G_OBJECT_CLASS (soup_connection_parent_class)->finalize (object);
}
static void
finalize (GObject *object)
{
NMBluezDevicePrivate *priv = NM_BLUEZ_DEVICE_GET_PRIVATE (object);
nm_log_dbg (LOGD_BT, "bluez[%s]: finalize NMBluezDevice", priv->path);
g_free (priv->path);
g_free (priv->address);
g_free (priv->name);
g_free (priv->bt_iface);
if (priv->proxy)
g_signal_handlers_disconnect_by_data (priv->proxy, object);
g_clear_object (&priv->proxy);
G_OBJECT_CLASS (nm_bluez_device_parent_class)->finalize (object);
}
