/** * Called before SPKnot destruction. */ static void sp_knot_dispose(GObject *object) { SPKnot *knot = (SPKnot *) object; if ((knot->flags & SP_KNOT_GRABBED) && gdk_pointer_is_grabbed ()) { // This happens e.g. when deleting a node in node tool while dragging it gdk_pointer_ungrab (GDK_CURRENT_TIME); } if (knot->_event_handler_id > 0) { g_signal_handler_disconnect(G_OBJECT (knot->item), knot->_event_handler_id); knot->_event_handler_id = 0; } if (knot->item) { gtk_object_destroy (GTK_OBJECT (knot->item)); knot->item = NULL; } for (gint i = 0; i < SP_KNOT_VISIBLE_STATES; i++) { if (knot->cursor[i]) { gdk_cursor_unref(knot->cursor[i]); knot->cursor[i] = NULL; } } if (knot->tip) { g_free(knot->tip); knot->tip = NULL; } if (parent_class->dispose) { (*parent_class->dispose) (object); } }
static void unrealize (GtkWidget *widget) { CajaDesktopWindow *window; CajaDesktopWindowDetails *details; GdkWindow *root_window; window = CAJA_DESKTOP_WINDOW (widget); details = window->details; root_window = gdk_screen_get_root_window ( gtk_window_get_screen (GTK_WINDOW (window))); gdk_property_delete (root_window, gdk_atom_intern ("CAJA_DESKTOP_WINDOW_ID", TRUE)); if (details->size_changed_id != 0) { g_signal_handler_disconnect (gtk_window_get_screen (GTK_WINDOW (window)), details->size_changed_id); details->size_changed_id = 0; } GTK_WIDGET_CLASS (caja_desktop_window_parent_class)->unrealize (widget); }
void waitForCore (GObject * obj, const string& signalName, unsigned int timeout) { shared_ptr<GMainLoop> loop(g_main_loop_new(nullptr, false), &g_main_loop_unref); /* Our two exit criteria */ util::ResourcePtr<gulong, function<void(gulong)>> signal( g_signal_connect_swapped(obj, signalName.c_str(), G_CALLBACK(g_main_loop_quit), loop.get()), [obj](gulong s) { g_signal_handler_disconnect(obj, s); }); util::ResourcePtr<guint, function<void(guint)>> timer(g_timeout_add(timeout, [](gpointer user_data) -> gboolean { g_main_loop_quit((GMainLoop *)user_data); return G_SOURCE_CONTINUE; }, loop.get()), &g_source_remove); /* Wait for sync */ g_main_loop_run(loop.get()); }
void on_active_user_changed(InfUser* user) { if(m_active_user != NULL) { if(m_active) deactivate_user(); g_signal_handler_disconnect(G_OBJECT(m_active_user), m_notify_status_handle); } m_active_user = user; if(user != NULL) { InfUserStatus user_status = inf_user_get_status(INF_USER(user)); g_assert(user_status != INF_USER_UNAVAILABLE); m_notify_status_handle = g_signal_connect( G_OBJECT(user), "notify::status", G_CALLBACK(&on_user_notify_status_static), this ); if( (user_status == INF_USER_ACTIVE && !m_active)) { deactivate_user(); } else if(user_status == INF_USER_INACTIVE && m_active) { activate_user(); } } }
static void ntf_overlay_parent_set (ClutterActor *overlay, ClutterActor *old_parent) { NtfOverlayPrivate *priv = NTF_OVERLAY (overlay)->priv; ClutterActorClass *klass = CLUTTER_ACTOR_CLASS (ntf_overlay_parent_class); ClutterActor *parent = clutter_actor_get_parent (overlay); if (priv->stage_allocation_id) { g_signal_handler_disconnect (old_parent, priv->stage_allocation_id); priv->stage_allocation_id = 0; } if (klass->parent_set) klass->parent_set (overlay, old_parent); if (parent) { priv->stage_allocation_id = g_signal_connect (parent, "notify::allocation", G_CALLBACK (ntf_overlay_stage_allocation_cb), overlay); } }
static void GObject__dispose (GObject *object) { SCPluginIfupdown *plugin = SC_PLUGIN_IFUPDOWN (object); SCPluginIfupdownPrivate *priv = SC_PLUGIN_IFUPDOWN_GET_PRIVATE (plugin); NMInotifyHelper *inotify_helper = nm_inotify_helper_get (); g_signal_handler_disconnect (inotify_helper, priv->inotify_event_id); if (priv->inotify_system_hostname_wd >= 0) nm_inotify_helper_remove_watch (inotify_helper, priv->inotify_system_hostname_wd); if (priv->kernel_ifaces) g_hash_table_destroy(priv->kernel_ifaces); if (priv->eni_ifaces) g_hash_table_destroy(priv->eni_ifaces); if (priv->client) g_object_unref (priv->client); G_OBJECT_CLASS (sc_plugin_ifupdown_parent_class)->dispose (object); }
static void main_window_destroy_cb (GtkWidget *widget, EmpathyMainWindow *window) { GHashTableIter iter; gpointer key, value; /* Save user-defined accelerators. */ main_window_accels_save (); g_list_free (window->actions_connected); g_object_unref (window->account_manager); g_object_unref (window->list_store); g_hash_table_destroy (window->errors); /* disconnect all handlers of status-changed signal */ g_hash_table_iter_init (&iter, window->status_changed_handlers); while (g_hash_table_iter_next (&iter, &key, &value)) g_signal_handler_disconnect (TP_ACCOUNT (key), GPOINTER_TO_UINT (value)); g_hash_table_destroy (window->status_changed_handlers); g_signal_handlers_disconnect_by_func (window->event_manager, main_window_event_added_cb, window); g_signal_handlers_disconnect_by_func (window->event_manager, main_window_event_removed_cb, window); g_object_unref (window->event_manager); g_object_unref (window->ui_manager); g_object_unref (window->chatroom_manager); g_free (window); }
/** * @brief Change volume-adjustment used by \e GtkVlcPlayer * * The old adjustment will be unreferenced (and possibly destroyed) and a * reference to the new adjustment will be fetched. * * @sa gtk_vlc_player_get_volume_adjustment * * @param player \e GtkVlcPlayer instance * @param adj New \e GtkAdjustment to use as volume-adjustment. */ void gtk_vlc_player_set_volume_adjustment(GtkVlcPlayer *player, GtkAdjustment *adj) { if (player->priv->volume_adjustment == NULL) return; g_signal_handler_disconnect(G_OBJECT(player->priv->volume_adjustment), player->priv->vol_adj_on_value_changed_id); g_object_unref(player->priv->volume_adjustment); player->priv->volume_adjustment = GTK_OBJECT(adj); g_object_ref_sink(player->priv->volume_adjustment); gtk_adjustment_configure(GTK_ADJUSTMENT(player->priv->volume_adjustment), 1., 0., 1., GTK_VLC_PLAYER_VOL_ADJ_STEP, GTK_VLC_PLAYER_VOL_ADJ_PAGE, 0.); player->priv->vol_adj_on_value_changed_id = g_signal_connect(G_OBJECT(player->priv->volume_adjustment), "value-changed", G_CALLBACK(vol_adj_on_value_changed), player); }
static void extension_list_selection_changed (GtkTreeSelection *selection, GtkButton *about_button) { GtkTreeModel *model; GtkTreeIter iter; Extension *ext; gtk_widget_set_sensitive (GTK_WIDGET (about_button), FALSE); if (extension_about_id > 0) { g_signal_handler_disconnect (about_button, extension_about_id); extension_about_id = 0; } if (!gtk_tree_selection_get_selected (selection, &model, &iter)) return; gtk_tree_model_get (model, &iter, EXT_STRUCT_COLUMN, &ext, -1); if (ext != NULL) { gtk_widget_set_sensitive (GTK_WIDGET (about_button), TRUE); extension_about_id = g_signal_connect (about_button, "clicked", G_CALLBACK (extension_about_clicked), ext); } }
/** * hito_group_combo_connect_filter: * @combo: A #HitoGroupCombo * @filter: A #HitoContactModelFilter, or #NULL. * * Hook the selected group in the combo box to the filter model. If @filter is * #NULL, remove an existing connection. */ void hito_group_combo_connect_filter (HitoGroupCombo *combo, HitoContactModelFilter *filter) { HitoGroupComboPrivate *priv; g_return_if_fail (HITO_IS_GROUP_COMBO (combo)); priv = GET_PRIVATE (combo); if (priv->changed_id) { g_signal_handler_disconnect (combo, priv->changed_id); g_object_unref (priv->filter); priv->changed_id = 0; priv->filter = NULL; } if (filter) { priv->changed_id = g_signal_connect (combo, "changed", G_CALLBACK (on_group_changed), NULL); priv->filter = g_object_ref (filter); on_group_changed (combo); } }
void uber_line_graph_bind_label (UberLineGraph *graph, /* IN */ guint line, /* IN */ UberLabel *label) /* IN */ { UberLineGraphPrivate *priv; LineInfo *info; g_return_if_fail(UBER_IS_LINE_GRAPH(graph)); g_return_if_fail(UBER_IS_LABEL(label)); g_return_if_fail(line > 0); g_return_if_fail(line <= graph->priv->lines->len); priv = graph->priv; info = &g_array_index(priv->lines, LineInfo, line - 1); if (info->label_id) { g_signal_handler_disconnect(info->label, info->label_id); } info->label = label; info->label_id = g_signal_connect(label, "color-changed", G_CALLBACK(uber_line_graph_color_changed), graph); }
static void gtk_cell_view_dispose (GObject *object) { GtkCellView *cellview = GTK_CELL_VIEW (object); gtk_cell_view_set_model (cellview, NULL); if (cellview->priv->area) { g_object_unref (cellview->priv->area); cellview->priv->area = NULL; } if (cellview->priv->context) { g_signal_handler_disconnect (cellview->priv->context, cellview->priv->size_changed_id); g_object_unref (cellview->priv->context); cellview->priv->context = NULL; cellview->priv->size_changed_id = 0; } G_OBJECT_CLASS (gtk_cell_view_parent_class)->dispose (object); }
static void dispose (GObject *object) { NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (object); GSList *iter; if (priv->device && priv->device_state_id) { g_signal_handler_disconnect (priv->device, priv->device_state_id); priv->device_state_id = 0; } /* Clear any share rules */ if (priv->share_rules) { nm_act_request_set_shared (NM_ACT_REQUEST (object), FALSE); clear_share_rules (NM_ACT_REQUEST (object)); } /* Kill any in-progress secrets requests */ for (iter = priv->secrets_calls; iter; iter = g_slist_next (iter)) { GetSecretsInfo *info = iter->data; g_assert (priv->connection); nm_settings_connection_cancel_secrets (NM_SETTINGS_CONNECTION (priv->connection), info->call_id); g_free (info); } g_slist_free (priv->secrets_calls); priv->secrets_calls = NULL; g_free (priv->dbus_sender); priv->dbus_sender = NULL; g_clear_object (&priv->device); g_clear_object (&priv->connection); G_OBJECT_CLASS (nm_act_request_parent_class)->dispose (object); }
static void ecp_target_free (EConfig *ec, EConfigTarget *t) { struct _ECalConfigPrivate *p = _PRIVATE (ec); if (ec->target == t) { switch (t->type) { case EC_CONFIG_TARGET_SOURCE: { ECalConfigTargetSource *s = (ECalConfigTargetSource *)t; if (p->source_changed_id) { g_signal_handler_disconnect (s->source, p->source_changed_id); p->source_changed_id = 0; } break; } case EC_CONFIG_TARGET_PREFS: { /* ECalConfigTargetPrefs *s = (ECalConfigTargetPrefs *)t; */ break; } } } switch (t->type) { case EC_CONFIG_TARGET_SOURCE: { ECalConfigTargetSource *s = (ECalConfigTargetSource *)t; if (s->source) g_object_unref (s->source); break; } case EC_CONFIG_TARGET_PREFS: { ECalConfigTargetPrefs *s = (ECalConfigTargetPrefs *)t; if (s->gconf) g_object_unref (s->gconf); break; } } ((EConfigClass *) ecp_parent_class)->target_free (ec, t); }
bool cb_marks_view_key_press_event_add(GtkWidget* UNUSED(widget), GdkEventKey* event, girara_session_t* session) { g_return_val_if_fail(session != NULL, FALSE); g_return_val_if_fail(session->gtk.view != NULL, FALSE); g_return_val_if_fail(session->global.data != NULL, FALSE); zathura_t* zathura = (zathura_t*) session->global.data; /* reset signal handler */ g_signal_handler_disconnect(G_OBJECT(session->gtk.view), session->signals.view_key_pressed); session->signals.view_key_pressed = g_signal_connect(G_OBJECT(session->gtk.view), "key-press-event", G_CALLBACK(girara_callback_view_key_press_event), session); /* evaluate key */ if (((event->keyval >= 0x41 && event->keyval <= 0x5A) || (event->keyval >= 0x61 && event->keyval <= 0x7A)) == false) { return false; } mark_add(zathura, event->keyval); return true; }
void wxFrame::AttachMenuBar( wxMenuBar *menuBar ) { wxFrameBase::AttachMenuBar(menuBar); if (m_frameMenuBar) { #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2 hildon_window_set_menu(HILDON_WINDOW(m_widget), GTK_MENU(m_frameMenuBar->m_menubar)); #else // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2 m_frameMenuBar->SetParent(this); // menubar goes into top of vbox (m_mainWidget) gtk_box_pack_start( GTK_BOX(m_mainWidget), menuBar->m_widget, false, false, 0); gtk_box_reorder_child(GTK_BOX(m_mainWidget), menuBar->m_widget, 0); // disconnect wxWindowGTK "size_request" handler, // it interferes with sizing of detached GtkHandleBox gulong handler_id = g_signal_handler_find( menuBar->m_widget, GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA), g_signal_lookup("size_request", GTK_TYPE_WIDGET), 0, NULL, NULL, menuBar); if (handler_id != 0) g_signal_handler_disconnect(menuBar->m_widget, handler_id); // reset size request to allow native sizing to work gtk_widget_set_size_request(menuBar->m_widget, -1, -1); gtk_widget_show( m_frameMenuBar->m_widget ); #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2 } // make sure next size_allocate causes a wxSizeEvent m_oldClientWidth = 0; }
/* pop up the PIN entry window. */ static char *query_pin(GtkBuilder *builder) { GtkEntry *pin_entry = GTK_ENTRY(ui_object(builder, "login_pin_entry")); gtk_entry_set_text(pin_entry, ""); struct pin_ctx *pin_ctx = g_new(struct pin_ctx, 1); pin_ctx->done = false; pin_ctx->response = 0; GtkButton *complete_btn = GTK_BUTTON(ui_object(builder, "login_pin_ok_btn")), *cancel_btn = GTK_BUTTON(ui_object(builder, "login_pin_cancel_btn")); GtkDialog *pin_wnd = GTK_DIALOG(ui_object(builder, "login_pin_dialog")); gtk_dialog_set_default_response(pin_wnd, gtk_dialog_get_response_for_widget(pin_wnd, GTK_WIDGET(cancel_btn))); gulong resp = g_signal_connect(G_OBJECT(pin_wnd), "response", G_CALLBACK(&on_login_pin_response), pin_ctx); gtk_widget_show_all(GTK_WIDGET(pin_wnd)); gtk_dialog_run(pin_wnd); gtk_widget_hide(GTK_WIDGET(pin_wnd)); char *ret; if(pin_ctx->done && gtk_dialog_get_widget_for_response(pin_wnd, pin_ctx->response) == GTK_WIDGET(complete_btn)) { ret = g_strdup(gtk_entry_get_text(pin_entry)); } else { ret = NULL; } g_free(pin_ctx); g_signal_handler_disconnect(G_OBJECT(pin_wnd), resp); return ret; }
static void remove_menu(struct menu_priv *item, int recursive) { if (recursive) { struct menu_priv *next,*child=item->child; while (child) { next=child->sibling; remove_menu(child, recursive); child=next; } } if (item->action) { gtk_ui_manager_remove_ui(item->gui->menu_manager, item->merge_id); gtk_action_group_remove_action(item->gui->dyn_group, item->action); #if 0 if (item->callback) g_signal_handler_disconnect(item->action, item->handler_id); #endif g_object_unref(item->action); } g_free(item->path); g_free(item); }
void Gobby::EditCommands::on_sync_complete() { g_assert(m_current_view != NULL); InfTextSession* session = m_current_view->get_session(); InfAdoptedAlgorithm* algorithm = inf_adopted_session_get_algorithm( INF_ADOPTED_SESSION(session)); m_can_undo_changed_handler = g_signal_connect( G_OBJECT(algorithm), "can-undo-changed", G_CALLBACK(&on_can_undo_changed_static), this); m_can_redo_changed_handler = g_signal_connect( G_OBJECT(algorithm), "can-redo-changed", G_CALLBACK(&on_can_redo_changed_static), this); if(m_synchronization_complete_handler != 0) { g_signal_handler_disconnect( G_OBJECT(session), m_synchronization_complete_handler); m_synchronization_complete_handler = 0; } }
static void playing_source_changed_cb (RBShellPlayer *player, RBSource *source, RBIRadioSource *iradio_source) { GObject *backend; g_object_get (player, "player", &backend, NULL); if (source == RB_SOURCE (iradio_source) && (iradio_source->priv->info_available_id == 0)) { rb_debug ("connecting info-available signal handler"); iradio_source->priv->info_available_id = g_signal_connect_object (backend, "info", G_CALLBACK (info_available_cb), iradio_source, 0); } else if (iradio_source->priv->info_available_id) { rb_debug ("disconnecting info-available signal handler"); g_signal_handler_disconnect (backend, iradio_source->priv->info_available_id); iradio_source->priv->info_available_id = 0; } g_object_unref (backend); }
/* * This callback will be triggered by the widget re-mapping * itself in case of WM restarting. The point is to push all * remote texture parameters anew to the WM. */ static gboolean hildon_remote_texture_map_event (GtkWidget *widget, GdkEvent *event, gpointer user_data) { HildonRemoteTexture *self = HILDON_REMOTE_TEXTURE (user_data); HildonRemoteTexturePrivate *priv = HILDON_REMOTE_TEXTURE_GET_PRIVATE (self); hildon_remote_texture_send_all_messages (self); /* Disconnect the "map-event" handler after the "emergency resend all * actor parameters" drill is over. */ if (priv->map_event_cb_id) { g_signal_handler_disconnect (self, priv->map_event_cb_id); priv->map_event_cb_id = 0; } return FALSE; }
gboolean _g_assert_signal_received_run (gpointer object, const gchar *signal_name) { gulong handler_id; guint timeout_id; SignalReceivedData data; data.loop = g_main_loop_new (g_main_context_get_thread_default (), FALSE); data.timed_out = FALSE; handler_id = g_signal_connect_swapped (object, signal_name, G_CALLBACK (on_signal_received), &data); timeout_id = g_timeout_add_seconds (30, on_signal_received_timeout, &data); g_main_loop_run (data.loop); g_signal_handler_disconnect (object, handler_id); g_source_remove (timeout_id); g_main_loop_unref (data.loop); return data.timed_out; }
static void qtcScrolledWindowCleanup(GtkWidget *widget) { if (widget && g_object_get_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_SET")) { g_signal_handler_disconnect(G_OBJECT(widget), (gint)g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_DESTROY_ID")); g_signal_handler_disconnect(G_OBJECT(widget), (gint)g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_UNREALIZE_ID")); g_signal_handler_disconnect(G_OBJECT(widget), (gint)g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_STYLE_SET_ID")); if(ENTRY_MO) { g_signal_handler_disconnect(G_OBJECT(widget), (gint)g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_ENTER_ID")); g_signal_handler_disconnect(G_OBJECT(widget), (gint)g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_LEAVE_ID")); } g_signal_handler_disconnect(G_OBJECT(widget), (gint)g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_FOCUS_IN_ID")); g_signal_handler_disconnect(G_OBJECT(widget), (gint)g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_FOCUS_OUT_ID")); g_object_steal_data(G_OBJECT(widget), "QTC_SCROLLED_WINDOW_SET"); } }
inline static void drop_model (ETableSelectionModel *etsm) { if (etsm->model) { g_signal_handler_disconnect (G_OBJECT (etsm->model), etsm->model_pre_change_id); g_signal_handler_disconnect (G_OBJECT (etsm->model), etsm->model_changed_id); g_signal_handler_disconnect (G_OBJECT (etsm->model), etsm->model_row_changed_id); g_signal_handler_disconnect (G_OBJECT (etsm->model), etsm->model_cell_changed_id); g_signal_handler_disconnect (G_OBJECT (etsm->model), etsm->model_rows_inserted_id); g_signal_handler_disconnect (G_OBJECT (etsm->model), etsm->model_rows_deleted_id); g_object_unref (etsm->model); } etsm->model = NULL; }
static void unlink_model(EAddressbookReflowAdapter *adapter) { EAddressbookReflowAdapterPrivate *priv = adapter->priv; if (priv->model && priv->create_contact_id) g_signal_handler_disconnect (priv->model, priv->create_contact_id); if (priv->model && priv->remove_contact_id) g_signal_handler_disconnect (priv->model, priv->remove_contact_id); if (priv->model && priv->modify_contact_id) g_signal_handler_disconnect (priv->model, priv->modify_contact_id); if (priv->model && priv->model_changed_id) g_signal_handler_disconnect (priv->model, priv->model_changed_id); if (priv->model && priv->search_started_id) g_signal_handler_disconnect (priv->model, priv->search_started_id); if (priv->model && priv->search_result_id) g_signal_handler_disconnect (priv->model, priv->search_result_id); priv->create_contact_id = 0; priv->remove_contact_id = 0; priv->modify_contact_id = 0; priv->model_changed_id = 0; priv->search_started_id = 0; priv->search_result_id = 0; if (priv->model) g_object_unref (priv->model); priv->model = NULL; }
void rclib_album_signal_disconnect(gulong handler_id) { if(album_instance==NULL) return; g_signal_handler_disconnect(album_instance, handler_id); }
static void wibuti_watcher_find_window(WibutiWatcher *self) { WnckWorkspace *activeworkspace = wnck_screen_get_active_workspace(self->screen); WnckWindow *new_active = wnck_screen_get_active_window(self->screen); WnckWindow *new_tracked = NULL; // stop tracking the old active window if (G_IS_OBJECT(self->active)) { if (g_signal_handler_is_connected(G_OBJECT(self->active), self->handler_active_state_changed)) { g_signal_handler_disconnect(G_OBJECT(self->active), self->handler_active_state_changed); } } if (self->only_maximized) { // find upper maximized window GList *windows = wnck_screen_get_windows_stacked(self->screen); while (windows && windows->data) { if (!self->only_maximized || wnck_window_is_maximized(windows->data)) if (!wnck_window_is_minimized(windows->data) && !wnck_window_is_skip_pager(windows->data)) if (wnck_window_is_in_viewport(windows->data, activeworkspace)) new_tracked = windows->data; windows = windows->next; } // start tracking the new active window if (new_active) { self->handler_active_state_changed = g_signal_connect(G_OBJECT(new_active), "state-changed", G_CALLBACK(wibuti_watcher_window_state_changed_cb), self); } } else { new_tracked = new_active; } // stop tracking the old window if (G_IS_OBJECT(self->tracked)) { #ifdef WIBUTI_WITH_TITLE if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_name_changed)) { g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_name_changed); } if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_icon_changed)) { g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_icon_changed); } #endif // WIBUTI_WITH_TITLE if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_tracked_state_changed)) { g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_tracked_state_changed); } } // start tracking the new window if (new_tracked) { #ifdef WIBUTI_WITH_TITLE self->handler_name_changed = g_signal_connect(G_OBJECT(new_tracked), "name-changed", G_CALLBACK(wibuti_watcher_name_changed_cb), self); self->handler_icon_changed = g_signal_connect(G_OBJECT(new_tracked), "icon-changed", G_CALLBACK(wibuti_watcher_icon_changed_cb), self); #endif // WIBUTI_WITH_TITLE self->handler_tracked_state_changed = g_signal_connect(G_OBJECT(new_tracked), "state-changed", G_CALLBACK(wibuti_watcher_window_state_changed_cb), self); } self->tracked = new_tracked; self->active = new_active; }
void _fm_icon_pixbuf_finalize() { GtkIconTheme* theme = gtk_icon_theme_get_default(); g_signal_handler_disconnect(theme, changed_handler); }
static void cockpit_channel_response_close (CockpitChannelResponse *chesp, const gchar *problem) { CockpitWebResponding state; /* Ensure no more signals arrive about our response */ g_signal_handler_disconnect (chesp->transport, chesp->transport_recv); g_signal_handler_disconnect (chesp->transport, chesp->transport_control); g_signal_handler_disconnect (chesp->transport, chesp->transport_closed); /* The web response should not yet be complete */ state = cockpit_web_response_get_state (chesp->response); if (problem == NULL) { /* Closed without any data */ if (state == COCKPIT_WEB_RESPONSE_READY) { ensure_headers (chesp, 204, "OK"); cockpit_web_response_complete (chesp->response); g_debug ("%s: no content in external channel", chesp->logname); } else if (state < COCKPIT_WEB_RESPONSE_COMPLETE) { g_message ("%s: truncated data in external channel", chesp->logname); cockpit_web_response_abort (chesp->response); } else { g_debug ("%s: completed serving external channel", chesp->logname); } } else if (state == COCKPIT_WEB_RESPONSE_READY) { if (g_str_equal (problem, "not-found")) { g_debug ("%s: not found", chesp->logname); cockpit_web_response_error (chesp->response, 404, NULL, NULL); } else if (g_str_equal (problem, "no-host") || g_str_equal (problem, "no-cockpit") || g_str_equal (problem, "unknown-hostkey") || g_str_equal (problem, "authentication-failed")) { g_debug ("%s: remote server unavailable: %s", chesp->logname, problem); cockpit_web_response_error (chesp->response, 502, NULL, NULL); } else { g_message ("%s: external channel failed: %s", chesp->logname, problem); cockpit_web_response_error (chesp->response, 500, NULL, NULL); } } else { if (g_str_equal (problem, "disconnected")) g_debug ("%s: failure while serving external channel: %s", chesp->logname, problem); else g_message ("%s: failure while serving external channel: %s", chesp->logname, problem); cockpit_web_response_abort (chesp->response); } g_object_unref (chesp->response); g_object_unref (chesp->transport); g_hash_table_unref (chesp->headers); cockpit_channel_inject_free (chesp->inject); json_object_unref (chesp->open); g_free (chesp->channel); g_free (chesp); }
static void panel_place_menu_item_finalize (GObject *object) { PanelPlaceMenuItem *menuitem = (PanelPlaceMenuItem *) object; if (menuitem->priv->caja_desktop_settings) { g_object_unref (menuitem->priv->caja_desktop_settings); menuitem->priv->caja_desktop_settings = NULL; } if (menuitem->priv->caja_prefs_settings) { g_object_unref (menuitem->priv->caja_prefs_settings); menuitem->priv->caja_prefs_settings = NULL; } if (menuitem->priv->bookmarks_monitor != NULL) { g_file_monitor_cancel (menuitem->priv->bookmarks_monitor); g_object_unref (menuitem->priv->bookmarks_monitor); } menuitem->priv->bookmarks_monitor = NULL; if (menuitem->priv->drive_changed_id) g_signal_handler_disconnect (menuitem->priv->volume_monitor, menuitem->priv->drive_changed_id); menuitem->priv->drive_changed_id = 0; if (menuitem->priv->drive_connected_id) g_signal_handler_disconnect (menuitem->priv->volume_monitor, menuitem->priv->drive_connected_id); menuitem->priv->drive_connected_id = 0; if (menuitem->priv->drive_disconnected_id) g_signal_handler_disconnect (menuitem->priv->volume_monitor, menuitem->priv->drive_disconnected_id); menuitem->priv->drive_disconnected_id = 0; if (menuitem->priv->volume_added_id) g_signal_handler_disconnect (menuitem->priv->volume_monitor, menuitem->priv->volume_added_id); menuitem->priv->volume_added_id = 0; if (menuitem->priv->volume_changed_id) g_signal_handler_disconnect (menuitem->priv->volume_monitor, menuitem->priv->volume_changed_id); menuitem->priv->volume_changed_id = 0; if (menuitem->priv->volume_removed_id) g_signal_handler_disconnect (menuitem->priv->volume_monitor, menuitem->priv->volume_removed_id); menuitem->priv->volume_removed_id = 0; if (menuitem->priv->mount_added_id) g_signal_handler_disconnect (menuitem->priv->volume_monitor, menuitem->priv->mount_added_id); menuitem->priv->mount_added_id = 0; if (menuitem->priv->mount_changed_id) g_signal_handler_disconnect (menuitem->priv->volume_monitor, menuitem->priv->mount_changed_id); menuitem->priv->mount_changed_id = 0; if (menuitem->priv->mount_removed_id) g_signal_handler_disconnect (menuitem->priv->volume_monitor, menuitem->priv->mount_removed_id); menuitem->priv->mount_removed_id = 0; if (menuitem->priv->volume_monitor != NULL) g_object_unref (menuitem->priv->volume_monitor); menuitem->priv->volume_monitor = NULL; G_OBJECT_CLASS (panel_place_menu_item_parent_class)->finalize (object); }