static void
relation_arrow_finalize (GObject *object)
{
PlannerRelationArrow *arrow = PLANNER_RELATION_ARROW (object);
PlannerRelationArrowPriv *priv;
priv = arrow->priv;
if (priv->predecessor) {
g_object_remove_weak_pointer (G_OBJECT (priv->predecessor),
(gpointer)&priv->predecessor);
}
if (priv->successor) {
g_object_remove_weak_pointer (G_OBJECT (priv->successor),
(gpointer)&priv->successor);
}
g_free (priv);
arrow->priv = NULL;
if (G_OBJECT_CLASS (parent_class)->finalize) {
(* G_OBJECT_CLASS (parent_class)->finalize) (object);
}
}
static void
ide_source_snippet_dispose (GObject *object)
{
IdeSourceSnippet *self = (IdeSourceSnippet *)object;
if (self->mark_begin)
{
g_object_remove_weak_pointer (G_OBJECT (self->mark_begin),
(gpointer *) &self->mark_begin);
gtk_text_buffer_delete_mark (self->buffer, self->mark_begin);
self->mark_begin = NULL;
}
if (self->mark_end)
{
g_object_remove_weak_pointer (G_OBJECT (self->mark_end),
(gpointer *) &self->mark_end);
gtk_text_buffer_delete_mark (self->buffer, self->mark_end);
self->mark_end = NULL;
}
g_clear_pointer (&self->runs, (GDestroyNotify) g_array_unref);
g_clear_pointer (&self->chunks, (GDestroyNotify) g_ptr_array_unref);
g_clear_object (&self->buffer);
g_clear_object (&self->snippet_context);
g_free(self->language);
g_free(self->description);
}
static void
gtk_source_file_saver_dispose (GObject *object)
{
GtkSourceFileSaver *saver = GTK_SOURCE_FILE_SAVER (object);
reset (saver);
if (saver->priv->source_buffer != NULL)
{
g_object_remove_weak_pointer (G_OBJECT (saver->priv->source_buffer),
(gpointer *)&saver->priv->source_buffer);
saver->priv->source_buffer = NULL;
}
if (saver->priv->file != NULL)
{
g_object_remove_weak_pointer (G_OBJECT (saver->priv->file),
(gpointer *)&saver->priv->file);
saver->priv->file = NULL;
}
g_clear_object (&saver->priv->location);
G_OBJECT_CLASS (gtk_source_file_saver_parent_class)->dispose (object);
}
static void
gtk_source_file_loader_dispose (GObject *object)
{
GtkSourceFileLoader *loader = GTK_SOURCE_FILE_LOADER (object);
reset (loader);
if (loader->priv->source_buffer != NULL)
{
g_object_remove_weak_pointer (G_OBJECT (loader->priv->source_buffer),
(gpointer *)&loader->priv->source_buffer);
loader->priv->source_buffer = NULL;
}
if (loader->priv->file != NULL)
{
g_object_remove_weak_pointer (G_OBJECT (loader->priv->file),
(gpointer *)&loader->priv->file);
loader->priv->file = NULL;
}
g_clear_object (&loader->priv->location);
g_clear_object (&loader->priv->input_stream_property);
g_slist_free (loader->priv->candidate_encodings);
loader->priv->candidate_encodings = NULL;
G_OBJECT_CLASS (gtk_source_file_loader_parent_class)->dispose (object);
}
static void
disconnect_view (GtkSourceMap *map)
{
GtkSourceMapPrivate *priv;
GtkAdjustment *vadj;
priv = gtk_source_map_get_instance_private (map);
if (priv->view == NULL)
{
return;
}
disconnect_buffer (map);
if (priv->buffer_binding != NULL)
{
g_object_remove_weak_pointer (G_OBJECT (priv->buffer_binding),
(gpointer *)&priv->buffer_binding);
g_binding_unbind (priv->buffer_binding);
priv->buffer_binding = NULL;
}
if (priv->indent_width_binding != NULL)
{
g_object_remove_weak_pointer (G_OBJECT (priv->indent_width_binding),
(gpointer *)&priv->indent_width_binding);
g_binding_unbind (priv->indent_width_binding);
priv->indent_width_binding = NULL;
}
if (priv->tab_width_binding != NULL)
{
g_object_remove_weak_pointer (G_OBJECT (priv->tab_width_binding),
(gpointer *)&priv->tab_width_binding);
g_binding_unbind (priv->tab_width_binding);
priv->tab_width_binding = NULL;
}
if (priv->view_notify_buffer_handler != 0)
{
g_signal_handler_disconnect (priv->view, priv->view_notify_buffer_handler);
priv->view_notify_buffer_handler = 0;
}
vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (priv->view));
if (vadj != NULL)
{
g_signal_handler_disconnect (vadj, priv->view_vadj_value_changed_handler);
priv->view_vadj_value_changed_handler = 0;
g_signal_handler_disconnect (vadj, priv->view_vadj_notify_upper_handler);
priv->view_vadj_notify_upper_handler = 0;
}
g_object_remove_weak_pointer (G_OBJECT (priv->view), (gpointer *)&priv->view);
priv->view = NULL;
}
static void
gail_focus_notify (GtkWidget *widget)
{
AtkObject *atk_obj;
gboolean transient;
if (widget != _focus_widget)
{
if (_focus_widget)
{
void *vp_focus_widget = &_focus_widget;
g_object_remove_weak_pointer (G_OBJECT (_focus_widget), vp_focus_widget);
}
_focus_widget = widget;
if (_focus_widget)
{
void *vp_focus_widget = &_focus_widget;
g_object_add_weak_pointer (G_OBJECT (_focus_widget), vp_focus_widget);
/*
* The UI may not have been updated yet; e.g. in gtkhtml2
* html_view_layout() is called in a idle handler
*/
if (_focus_widget == focus_before_menu)
{
void *vp_focus_before_menu = &focus_before_menu;
g_object_remove_weak_pointer (G_OBJECT (focus_before_menu), vp_focus_before_menu);
focus_before_menu = NULL;
}
}
gail_focus_notify_when_idle (_focus_widget);
}
else
{
if (_focus_widget)
atk_obj = get_accessible_for_widget (_focus_widget, &transient);
else
atk_obj = NULL;
/*
* Do not report focus on redundant object
*/
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
if (atk_obj &&
(atk_object_get_role(atk_obj) != ATK_ROLE_REDUNDANT_OBJECT))
atk_focus_tracker_notify (atk_obj);
G_GNUC_END_IGNORE_DEPRECATIONS;
if (atk_obj && transient)
g_object_unref (atk_obj);
if (subsequent_focus_widget)
{
GtkWidget *tmp_widget = subsequent_focus_widget;
subsequent_focus_widget = NULL;
gail_focus_notify_when_idle (tmp_widget);
}
}
}
/**
* seahorse_object_dispose:
* @obj: A #SeahorseObject to dispose
*
* Before this object is disposed, all it's children get new parents
*
*/
static void
seahorse_object_dispose (GObject *obj)
{
SeahorseObject *self = SEAHORSE_OBJECT (obj);
SeahorseObject *parent;
GList *l, *children;
if (self->pv->context != NULL) {
seahorse_context_remove_object (self->pv->context, self);
g_assert (self->pv->context == NULL);
}
if (self->pv->source != NULL) {
g_object_remove_weak_pointer (G_OBJECT (self->pv->source), (gpointer*)&self->pv->source);
self->pv->source = NULL;
}
if (self->pv->preferred != NULL) {
g_object_remove_weak_pointer (G_OBJECT (self->pv->source), (gpointer*)&self->pv->preferred);
self->pv->preferred = NULL;
}
/*
* When an object is destroyed, we reparent all
* children to this objects parent. If no parent
* of this object, all children become root objects.
*/
parent = self->pv->parent;
if (parent)
g_object_ref (parent);
children = g_list_copy (self->pv->children);
for (l = children; l; l = g_list_next (l)) {
g_return_if_fail (SEAHORSE_IS_OBJECT (l->data));
seahorse_object_set_parent (l->data, parent);
}
g_list_free (children);
if (parent)
g_object_unref (parent);
g_assert (self->pv->children == NULL);
/* Now remove this object from its parent */
seahorse_object_set_parent (self, NULL);
G_OBJECT_CLASS (seahorse_object_parent_class)->dispose (obj);
}
static void
gtk_icon_view_item_accessible_finalize (GObject *object)
{
GtkIconViewItemAccessible *item;
item = GTK_ICON_VIEW_ITEM_ACCESSIBLE (object);
if (item->widget)
g_object_remove_weak_pointer (G_OBJECT (item->widget), (gpointer) &item->widget);
if (item->state_set)
g_object_unref (item->state_set);
g_free (item->text);
g_free (item->action_description);
g_free (item->image_description);
if (item->action_idle_handler)
{
g_source_remove (item->action_idle_handler);
item->action_idle_handler = 0;
}
G_OBJECT_CLASS (_gtk_icon_view_item_accessible_parent_class)->finalize (object);
}
static void
plugin_dispose (GObject *object)
{
GigglePluginPriv *priv = GET_PRIV (object);
if (priv->manager) {
g_object_remove_weak_pointer (G_OBJECT (priv->manager),
(gpointer) &priv->manager);
priv->manager = NULL;
}
if (priv->builder) {
g_object_unref (priv->builder);
priv->builder = NULL;
}
if (priv->module) {
g_module_close (priv->module);
priv->module = NULL;
}
g_ptr_array_foreach (priv->action_groups, (GFunc) g_object_unref, NULL);
G_OBJECT_CLASS (giggle_plugin_parent_class)->dispose (object);
}
static void
gtk_tooltip_set_last_window (GtkTooltip *tooltip,
GdkWindow *window)
{
GtkWidget *window_widget = NULL;
if (tooltip->last_window == window)
return;
if (tooltip->last_window)
g_object_remove_weak_pointer (G_OBJECT (tooltip->last_window),
(gpointer *) &tooltip->last_window);
tooltip->last_window = window;
if (window)
g_object_add_weak_pointer (G_OBJECT (tooltip->last_window),
(gpointer *) &tooltip->last_window);
if (window)
gdk_window_get_user_data (window, (gpointer *) &window_widget);
if (window_widget)
window_widget = gtk_widget_get_toplevel (window_widget);
if (window_widget &&
window_widget != tooltip->window &&
gtk_widget_is_toplevel (window_widget) &&
GTK_IS_WINDOW (window_widget))
gtk_window_set_transient_for (GTK_WINDOW (tooltip->window),
GTK_WINDOW (window_widget));
else
gtk_window_set_transient_for (GTK_WINDOW (tooltip->window), NULL);
}
static void
gtk_icon_view_accessible_notify_gtk (GObject *obj,
GParamSpec *pspec)
{
GtkIconView *icon_view;
GtkWidget *widget;
AtkObject *atk_obj;
GtkIconViewAccessible *view;
if (strcmp (pspec->name, "model") == 0)
{
widget = GTK_WIDGET (obj);
atk_obj = gtk_widget_get_accessible (widget);
view = (GtkIconViewAccessible*)atk_obj;
if (view->model)
{
g_object_remove_weak_pointer (G_OBJECT (view->model),
(gpointer *)&view->model);
gtk_icon_view_accessible_disconnect_model_signals (view->model, widget);
}
gtk_icon_view_accessible_clear_cache (view);
icon_view = GTK_ICON_VIEW (obj);
view->model = icon_view->priv->model;
/* If there is no model the GtkIconView is probably being destroyed */
if (view->model)
{
g_object_add_weak_pointer (G_OBJECT (view->model), (gpointer *)&view->model);
gtk_icon_view_accessible_connect_model_signals (icon_view);
}
}
return;
}
static void
set_buffer (GeglSampler *self, GeglBuffer *buffer)
{
if (self->buffer != buffer)
{
if (GEGL_IS_BUFFER (self->buffer))
{
g_signal_handlers_disconnect_by_func (self->buffer,
G_CALLBACK (buffer_contents_changed),
self);
g_object_remove_weak_pointer ((GObject*) self->buffer, (void**) &self->buffer);
}
if (GEGL_IS_BUFFER (buffer))
{
self->buffer = buffer;
g_object_add_weak_pointer ((GObject*) self->buffer, (void**) &self->buffer);
g_signal_connect (buffer, "changed",
G_CALLBACK (buffer_contents_changed),
self);
}
else
self->buffer = NULL;
buffer_contents_changed (buffer, NULL, self);
}
}
static int
gs_grab_get_keyboard (GSGrab *grab,
GdkWindow *window,
GdkScreen *screen)
{
GdkGrabStatus status;
g_return_val_if_fail (window != NULL, FALSE);
g_return_val_if_fail (screen != NULL, FALSE);
gs_debug ("Grabbing keyboard widget=%X", (guint32) GDK_WINDOW_XID (window));
status = gdk_keyboard_grab (window, FALSE, GDK_CURRENT_TIME);
if (status == GDK_GRAB_SUCCESS) {
if (grab->priv->keyboard_grab_window != NULL) {
g_object_remove_weak_pointer (G_OBJECT (grab->priv->keyboard_grab_window),
(gpointer *) &grab->priv->keyboard_grab_window);
}
grab->priv->keyboard_grab_window = window;
g_object_add_weak_pointer (G_OBJECT (grab->priv->keyboard_grab_window),
(gpointer *) &grab->priv->keyboard_grab_window);
grab->priv->keyboard_grab_screen = screen;
} else {
gs_debug ("Couldn't grab keyboard! (%s)", grab_string (status));
}
return status;
}
void
e_composer_private_dispose (EMsgComposer *composer)
{
if (composer->priv->shell != NULL) {
g_object_remove_weak_pointer (
G_OBJECT (composer->priv->shell),
&composer->priv->shell);
composer->priv->shell = NULL;
}
if (composer->priv->editor != NULL) {
g_object_unref (composer->priv->editor);
composer->priv->editor = NULL;
}
if (composer->priv->header_table != NULL) {
g_object_unref (composer->priv->header_table);
composer->priv->header_table = NULL;
}
if (composer->priv->attachment_paned != NULL) {
g_object_unref (composer->priv->attachment_paned);
composer->priv->attachment_paned = NULL;
}
if (composer->priv->focus_tracker != NULL) {
g_object_unref (composer->priv->focus_tracker);
composer->priv->focus_tracker = NULL;
}
if (composer->priv->window_group != NULL) {
g_object_unref (composer->priv->window_group);
composer->priv->window_group = NULL;
}
if (composer->priv->async_actions != NULL) {
g_object_unref (composer->priv->async_actions);
composer->priv->async_actions = NULL;
}
if (composer->priv->charset_actions != NULL) {
g_object_unref (composer->priv->charset_actions);
composer->priv->charset_actions = NULL;
}
if (composer->priv->composer_actions != NULL) {
g_object_unref (composer->priv->composer_actions);
composer->priv->composer_actions = NULL;
}
if (composer->priv->gallery_scrolled_window != NULL) {
g_object_unref (composer->priv->gallery_scrolled_window);
composer->priv->gallery_scrolled_window = NULL;
}
if (composer->priv->redirect != NULL) {
g_object_unref (composer->priv->redirect);
composer->priv->redirect = NULL;
}
}
void
_ide_tree_builder_set_tree (IdeTreeBuilder *builder,
IdeTree *tree)
{
IdeTreeBuilderPrivate *priv = ide_tree_builder_get_instance_private (builder);
g_return_if_fail (IDE_IS_TREE_BUILDER (builder));
g_return_if_fail (priv->tree == NULL || IDE_IS_TREE (priv->tree));
g_return_if_fail (IDE_IS_TREE (tree));
if (priv->tree != tree)
{
if (priv->tree != NULL)
{
g_object_remove_weak_pointer (G_OBJECT (priv->tree), (gpointer *)&priv->tree);
priv->tree = NULL;
}
if (tree != NULL)
{
priv->tree = tree;
g_object_add_weak_pointer (G_OBJECT (priv->tree), (gpointer *)&priv->tree);
}
g_object_notify_by_pspec (G_OBJECT (builder), properties [PROP_TREE]);
}
}
static void
mx_deform_bow_tie_dispose (GObject *object)
{
MxDeformBowTiePrivate *priv = MX_DEFORM_BOW_TIE (object)->priv;
if (priv->back_id && priv->back)
{
g_signal_handler_disconnect (priv->back, priv->back_id);
priv->back_id = 0;
}
if (priv->back)
{
CoglHandle material;
/* Reset layer matrix */
material = clutter_texture_get_cogl_material (priv->back);
if (material)
{
CoglMatrix matrix;
cogl_matrix_init_identity (&matrix);
cogl_material_set_layer_matrix (material, 0, &matrix);
}
g_object_remove_weak_pointer (G_OBJECT (priv->back),
(gpointer *)&priv->back);
priv->back = NULL;
}
G_OBJECT_CLASS (mx_deform_bow_tie_parent_class)->dispose (object);
}
static void
mongo_cursor_finalize (GObject *object)
{
MongoCursorPrivate *priv;
ENTRY;
priv = MONGO_CURSOR(object)->priv;
if (priv->connection) {
g_object_remove_weak_pointer(G_OBJECT(priv->connection),
(gpointer *)&priv->connection);
priv->connection = NULL;
}
g_free(priv->collection);
priv->collection = NULL;
if (priv->fields) {
mongo_bson_unref(priv->fields);
priv->fields = NULL;
}
if (priv->query) {
mongo_bson_unref(priv->query);
priv->query = NULL;
}
G_OBJECT_CLASS(mongo_cursor_parent_class)->finalize(object);
EXIT;
}
/**
* pkg_graph_set_renderer:
* @graph: A #PkgGraph.
*
* Sets the #PkgRenderer for the graph.
*
* Returns: None.
* Side effects: None.
*/
void
pkg_graph_set_renderer (PkgGraph *graph,
PkgRenderer *renderer)
{
PkgGraphPrivate *priv;
g_return_if_fail(PKG_IS_GRAPH(graph));
g_return_if_fail(PKG_IS_RENDERER(renderer));
priv = graph->priv;
if (priv->renderer) {
clutter_container_remove_actor(CLUTTER_CONTAINER(graph),
CLUTTER_ACTOR(priv->renderer));
g_object_remove_weak_pointer(G_OBJECT(priv->renderer),
(gpointer *)&priv->renderer);
}
priv->renderer = CLUTTER_ACTOR(renderer);
g_object_add_weak_pointer(G_OBJECT(renderer),
(gpointer *)&priv->renderer);
clutter_container_add_actor(CLUTTER_CONTAINER(graph),
CLUTTER_ACTOR(renderer));
pkg_graph_place_child(graph, CLUTTER_ACTOR(renderer));
}
static void
gkm_object_dispose (GObject *obj)
{
GkmObject *self = GKM_OBJECT (obj);
GkmObjectTransient *transient;
if (self->pv->manager) {
if (self->pv->exposed)
gkm_object_expose (self, FALSE);
g_return_if_fail (!self->pv->exposed);
g_object_remove_weak_pointer (G_OBJECT (self->pv->manager),
(gpointer*)&(self->pv->manager));
self->pv->manager = NULL;
}
g_object_set (self, "store", NULL, NULL);
g_assert (self->pv->store == NULL);
if (self->pv->transient) {
transient = self->pv->transient;
if (transient->timer)
gkm_timer_cancel (transient->timer);
transient->timer = NULL;
}
G_OBJECT_CLASS (gkm_object_parent_class)->dispose (obj);
}
/*< private >*/
void
_gdk_gl_context_set_gl_drawable (GdkGLContext *glcontext,
GdkGLDrawable *gldrawable)
{
GdkGLContextImplWin32 *impl = GDK_GL_CONTEXT_IMPL_WIN32 (glcontext->impl);
GDK_GL_NOTE_FUNC_PRIVATE ();
if (impl->gldrawable == gldrawable)
return;
if (impl->gldrawable != NULL)
{
g_object_remove_weak_pointer (G_OBJECT (impl->gldrawable),
(gpointer *) &(impl->gldrawable));
impl->gldrawable = NULL;
}
if (gldrawable != NULL && GDK_IS_GL_DRAWABLE (gldrawable))
{
impl->gldrawable = gldrawable;
g_object_add_weak_pointer (G_OBJECT (impl->gldrawable),
(gpointer *) &(impl->gldrawable));
}
}
static void
avatar_cache_loader_finish (GiggleAvatarCacheLoader *loader,
GError *error)
{
if (loader->cache) {
g_object_remove_weak_pointer
(G_OBJECT (loader->cache),
(gpointer) &loader->cache);
}
if (loader->cancellable) {
g_cancellable_cancel (loader->cancellable);
g_object_unref (loader->cancellable);
}
if (loader->pixbuf_loader) {
gdk_pixbuf_loader_close (loader->pixbuf_loader, NULL);
g_object_unref (loader->pixbuf_loader);
}
if (loader->pixbuf) {
g_simple_async_result_set_op_res_gpointer
(loader->result, g_object_ref (loader->pixbuf),
g_object_unref);
} else {
g_simple_async_result_set_from_error (loader->result, error);
g_error_free (error);
}
g_simple_async_result_complete_in_idle (loader->result);
g_object_unref (loader->result);
g_slice_free (GiggleAvatarCacheLoader, loader);
}
static void
gucharmap_chartable_accessible_destroyed (GtkWidget *widget,
AtkObject *obj)
{
GucharmapChartableAccessible *accessible = GUCHARMAP_CHARTABLE_ACCESSIBLE (obj);
GucharmapChartableAccessiblePrivate *priv = GET_PRIVATE (accessible);
if (priv->vadjustment)
{
GtkAdjustment **adjustment_ptr = &priv->vadjustment;
g_object_remove_weak_pointer (G_OBJECT (priv->vadjustment),
(gpointer *) adjustment_ptr);
g_signal_handlers_disconnect_by_func (priv->vadjustment,
G_CALLBACK (adjustment_changed),
obj);
priv->vadjustment = NULL;
}
g_signal_handlers_disconnect_by_func (widget,
G_CALLBACK (gucharmap_chartable_accessible_set_scroll_adjustments),
obj);
g_signal_handlers_disconnect_by_func (widget,
G_CALLBACK (sync_adjustment),
obj);
g_signal_handlers_disconnect_by_func (widget,
G_CALLBACK (size_allocated),
obj);
g_signal_handlers_disconnect_by_func (widget,
G_CALLBACK (sync_active_char),
obj);
}
static void
shell_searchbar_dispose (GObject *object)
{
EShellSearchbarPrivate *priv;
priv = E_SHELL_SEARCHBAR (object)->priv;
if (priv->shell_view != NULL) {
g_object_remove_weak_pointer (
G_OBJECT (priv->shell_view), &priv->shell_view);
priv->shell_view = NULL;
}
if (priv->search_option != NULL) {
g_signal_handlers_disconnect_matched (
priv->search_option, G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, object);
g_object_unref (priv->search_option);
priv->search_option = NULL;
}
if (priv->state_group) {
g_free (priv->state_group);
priv->state_group = NULL;
}
/* Chain up to parent's dispose() method. */
G_OBJECT_CLASS (e_shell_searchbar_parent_class)->dispose (object);
}
static void
gb_command_provider_set_workbench (GbCommandProvider *provider,
GbWorkbench *workbench)
{
GbCommandProviderPrivate *priv = gb_command_provider_get_instance_private (provider);
g_return_if_fail (GB_IS_COMMAND_PROVIDER (provider));
g_return_if_fail (!workbench || GB_IS_WORKBENCH (workbench));
if (priv->workbench != workbench)
{
if (priv->workbench)
{
gb_command_provider_disconnect (provider, workbench);
g_object_remove_weak_pointer (G_OBJECT (priv->workbench),
(gpointer *)&priv->workbench);
priv->workbench = NULL;
}
if (workbench)
{
priv->workbench = workbench;
g_object_add_weak_pointer (G_OBJECT (priv->workbench),
(gpointer *)&priv->workbench);
gb_command_provider_connect (provider, workbench);
}
g_object_notify_by_pspec (G_OBJECT (provider),
gParamSpecs [PROP_WORKBENCH]);
}
}
static void
nautilus_query_editor_dispose (GObject *object)
{
NautilusQueryEditor *editor;
editor = NAUTILUS_QUERY_EDITOR (object);
if (editor->details->typing_timeout_id) {
g_source_remove (editor->details->typing_timeout_id);
editor->details->typing_timeout_id = 0;
}
if (editor->details->bar != NULL) {
g_signal_handlers_disconnect_by_func (editor->details->entry,
entry_activate_cb,
editor);
g_signal_handlers_disconnect_by_func (editor->details->entry,
entry_changed_cb,
editor);
nautilus_search_bar_return_entry (editor->details->bar);
g_object_remove_weak_pointer (G_OBJECT (editor->details->bar),
(gpointer *) &editor->details->bar);
editor->details->bar = NULL;
}
G_OBJECT_CLASS (nautilus_query_editor_parent_class)->dispose (object);
}
static void
gb_command_provider_set_active_view (GbCommandProvider *provider,
GbView *tab)
{
GbCommandProviderPrivate *priv = gb_command_provider_get_instance_private (provider);
g_return_if_fail (GB_IS_COMMAND_PROVIDER (provider));
g_return_if_fail (!tab || GB_IS_VIEW (tab));
if (priv->active_view)
{
g_object_remove_weak_pointer (G_OBJECT (priv->active_view),
(gpointer *)&priv->active_view);
priv->active_view = NULL;
}
if (tab)
{
priv->active_view = tab;
g_object_add_weak_pointer (G_OBJECT (priv->active_view),
(gpointer *)&priv->active_view);
}
g_object_notify_by_pspec (G_OBJECT (provider),
gParamSpecs [PROP_ACTIVE_VIEW]);
}
static void
clear_current_request (SoupConnection *conn)
{
SoupConnectionPrivate *priv = SOUP_CONNECTION_GET_PRIVATE (conn);
g_object_freeze_notify (G_OBJECT (conn));
if (priv->state == SOUP_CONNECTION_IN_USE) {
/* We don't use soup_connection_set_state here since
* it may call clear_current_request()...
*/
priv->state = SOUP_CONNECTION_IDLE;
g_object_notify (G_OBJECT (conn), "state");
}
start_idle_timer (conn);
if (priv->cur_req) {
SoupMessage *cur_req = priv->cur_req;
g_object_remove_weak_pointer (G_OBJECT (priv->cur_req),
(gpointer)&priv->cur_req);
priv->cur_req = NULL;
g_object_notify (G_OBJECT (conn), "message");
if (!soup_message_is_keepalive (cur_req))
soup_connection_disconnect (conn);
else
soup_message_io_stop (cur_req);
}
g_object_thaw_notify (G_OBJECT (conn));
}
static void
gdl_dock_tablabel_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GdlDockTablabel *tablabel;
GtkBin *bin;
tablabel = GDL_DOCK_TABLABEL (object);
switch (prop_id) {
case PROP_ITEM:
if (tablabel->item) {
g_object_remove_weak_pointer (G_OBJECT (tablabel->item),
(gpointer *) &tablabel->item);
g_signal_handlers_disconnect_by_func (
tablabel->item, gdl_dock_tablabel_item_notify, tablabel);
};
tablabel->item = g_value_get_object (value);
if (tablabel->item) {
gboolean locked;
gchar *long_name;
g_object_add_weak_pointer (G_OBJECT (tablabel->item),
(gpointer *) &tablabel->item);
g_signal_connect (tablabel->item, "notify::locked",
G_CALLBACK (gdl_dock_tablabel_item_notify),
tablabel);
g_signal_connect (tablabel->item, "notify::long_name",
G_CALLBACK (gdl_dock_tablabel_item_notify),
tablabel);
g_signal_connect (tablabel->item, "notify::grip_size",
G_CALLBACK (gdl_dock_tablabel_item_notify),
tablabel);
g_object_get (tablabel->item,
"locked", &locked,
"long-name", &long_name,
"grip-size", &tablabel->drag_handle_size,
NULL);
if (locked)
tablabel->drag_handle_size = 0;
bin = GTK_BIN (tablabel);
if (gtk_bin_get_child (bin) && g_object_class_find_property (
G_OBJECT_GET_CLASS (gtk_bin_get_child (bin)), "label"))
g_object_set (gtk_bin_get_child (bin), "label", long_name, NULL);
g_free (long_name);
};
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_search_bar_set_entry (GtkSearchBar *bar,
GtkEntry *entry)
{
GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar);
if (priv->entry != NULL)
{
if (GTK_IS_SEARCH_ENTRY (priv->entry))
g_signal_handlers_disconnect_by_func (priv->entry, stop_search_cb, bar);
else
g_signal_handlers_disconnect_by_func (priv->entry, entry_key_pressed_event_cb, bar);
g_object_remove_weak_pointer (G_OBJECT (priv->entry), (gpointer *) &priv->entry);
}
priv->entry = GTK_WIDGET (entry);
if (priv->entry != NULL)
{
g_object_add_weak_pointer (G_OBJECT (priv->entry), (gpointer *) &priv->entry);
if (GTK_IS_SEARCH_ENTRY (priv->entry))
g_signal_connect (priv->entry, "stop-search",
G_CALLBACK (stop_search_cb), bar);
else
g_signal_connect (priv->entry, "key-press-event",
G_CALLBACK (entry_key_pressed_event_cb), bar);
}
}
static void qcad_layer_track_new_object (QCADLayer *layer, QCADDesignObject *obj, GList *llDeSel, QCADDesignObject *parent)
{
gboolean bTransfer = FALSE ;
OBJECT_TRACK_STRUCT *ots = NULL ;
if (NULL == layer || NULL == obj) return ;
ots = g_object_get_data (G_OBJECT (obj), "ots") ;
// We only transfer an object from other layers if the rules allow us to do so. The rules are observed above.
// By now, if (NULL != ots) then the layers are guaranteed not to match, because the matching case is handled
// before the rules. Thus if (NULL != ots) then we are certainly transferring an object from another layer here.
if (!(bTransfer = (NULL != ots)))
{
ots = g_malloc0 (sizeof (OBJECT_TRACK_STRUCT)) ;
g_object_set_data (G_OBJECT (obj), "ots", ots) ;
/* g_signal_connect (G_OBJECT (obj), "selected", (GCallback)qcad_design_object_selected, ots) ;*/
g_object_weak_ref (G_OBJECT (obj), qcad_design_object_destroyed, ots) ;
}
ots->llDeSel = llDeSel ;
// Before setting ots->layer, we need to remove the weak reference to the current containing layer
if (bTransfer && NULL != ots->layer)
g_object_remove_weak_pointer (G_OBJECT (ots->layer), (gpointer *)&(ots->layer)) ;
ots->layer = layer ;
ots->parent = parent ;
/* DBG_REFS (fprintf (stderr, "Ref-ing object 0x%08X so as to newly add it to layer 0x%08X\n", (int)obj, (int)layer)) ;*/
g_object_ref (G_OBJECT (obj)) ;
g_object_add_weak_pointer (G_OBJECT (layer), (gpointer *)&(ots->layer)) ;
// Simulate a selected event on the object so we may NULL out the appropriate list link
/* qcad_design_object_selected (obj, ots) ;*/
}
