Ejemplo n.º 1
0
/**
 * 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);
    }
}
Ejemplo n.º 2
0
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);
}
Ejemplo n.º 3
0
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());
}
Ejemplo n.º 4
0
	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();
			}
		}
	}
Ejemplo n.º 5
0
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);
    }
}
Ejemplo n.º 6
0
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);
}
Ejemplo n.º 7
0
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);
}
Ejemplo n.º 8
0
/**
 * @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);
}
Ejemplo n.º 9
0
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);
    }
}
Ejemplo n.º 10
0
/**
 * 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);
  }
}
Ejemplo n.º 11
0
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);
}
Ejemplo n.º 12
0
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);
}
Ejemplo n.º 14
0
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);
}
Ejemplo n.º 15
0
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;
}
Ejemplo n.º 16
0
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;
}
Ejemplo n.º 17
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;
}
Ejemplo n.º 18
0
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);
}
Ejemplo n.º 19
0
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;
}
Ejemplo n.º 22
0
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;
}
Ejemplo n.º 23
0
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");
    }
}
Ejemplo n.º 24
0
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;
}
Ejemplo n.º 26
0
void rclib_album_signal_disconnect(gulong handler_id)
{
    if(album_instance==NULL) return;
    g_signal_handler_disconnect(album_instance, handler_id);
}
Ejemplo n.º 27
0
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;
}
Ejemplo n.º 28
0
void _fm_icon_pixbuf_finalize()
{
    GtkIconTheme* theme = gtk_icon_theme_get_default();
    g_signal_handler_disconnect(theme, changed_handler);
}
Ejemplo n.º 29
0
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);
}
Ejemplo n.º 30
0
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);
}