GtkTreeModel* get_dir_tree_model() { static PtkDirTree * dir_tree_model = NULL; if ( G_UNLIKELY( ! dir_tree_model ) ) { dir_tree_model = ptk_dir_tree_new( TRUE ); g_object_add_weak_pointer( G_OBJECT( dir_tree_model ), ( gpointer * ) (GtkWidget *) & dir_tree_model ); } else { g_object_ref( G_OBJECT( dir_tree_model ) ); } return GTK_TREE_MODEL( dir_tree_model ); }
GSGrab * gs_grab_new (void) { if (grab_object) { g_object_ref (grab_object); } else { grab_object = g_object_new (GS_TYPE_GRAB, NULL); g_object_add_weak_pointer (grab_object, (gpointer *) &grab_object); } return GS_GRAB (grab_object); }
static GObject * photos_application_constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { static GObject *self = NULL; if (self == NULL) { self = G_OBJECT_CLASS (photos_application_parent_class)->constructor (type, n_construct_params, construct_params); g_object_add_weak_pointer (self, (gpointer) &self); return self; } return g_object_ref (self); }
static GObject * empathy_connection_managers_constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { if (managers != NULL) return g_object_ref (managers); managers = G_OBJECT_CLASS (empathy_connection_managers_parent_class)->constructor (type, n_construct_params, construct_params); g_object_add_weak_pointer (managers, (gpointer) &managers); return managers; }
/** * pragha_database_get: * * Queries the global #PraghaDatabase instance, which is shared * by all modules. The function automatically takes a reference * for the caller, so you'll need to call g_object_unref() when * you're done with it. * * Return value: the global #PraghaDatabase instance. **/ PraghaDatabase* pragha_database_get (void) { static PraghaDatabase *database = NULL; if (G_UNLIKELY (database == NULL)) { database = g_object_new(PRAGHA_TYPE_DATABASE, NULL); g_object_add_weak_pointer(G_OBJECT (database), (gpointer) &database); } else { g_object_ref (G_OBJECT (database)); } return database; }
/** * _rb_action_group_add_source_actions: * @group: a #GtkActionGroup * @shell: the #RBShell * @actions: array of GtkActionEntry structures for the action group * @num_actions: number of actions in the @actions array * * Adds actions to an action group where the action callback is * called with the current selected source. This can safely be called * multiple times on the same action group. */ void _rb_action_group_add_source_actions (GtkActionGroup *group, GObject *shell, GtkActionEntry *actions, int num_actions) { int i; for (i = 0; i < num_actions; i++) { GtkAction *action; const char *label; const char *tooltip; SourceActionData *source_action_data; if (gtk_action_group_get_action (group, actions[i].name) != NULL) { /* action was already added */ continue; } label = gtk_action_group_translate_string (group, actions[i].label); tooltip = gtk_action_group_translate_string (group, actions[i].tooltip); action = gtk_action_new (actions[i].name, label, tooltip, NULL); if (actions[i].stock_id != NULL) { g_object_set (action, "stock-id", actions[i].stock_id, NULL); if (gtk_icon_theme_has_icon (gtk_icon_theme_get_default (), actions[i].stock_id)) { g_object_set (action, "icon-name", actions[i].stock_id, NULL); } } if (actions[i].callback) { GClosure *closure; source_action_data = g_slice_new0 (SourceActionData); source_action_data->callback = (SourceActionCallback) actions[i].callback; source_action_data->shell = shell; g_object_add_weak_pointer (shell, &source_action_data->shell); closure = g_cclosure_new (G_CALLBACK (source_action_cb), source_action_data, (GClosureNotify) source_action_data_destroy); g_signal_connect_closure (action, "activate", closure, FALSE); } gtk_action_group_add_action_with_accel (group, action, actions[i].accelerator); g_object_unref (action); } }
static PlumaSpinnerCache * pluma_spinner_cache_ref (void) { if (spinner_cache == NULL) { PlumaSpinnerCache **cache_ptr; spinner_cache = g_object_new (PLUMA_TYPE_SPINNER_CACHE, NULL); cache_ptr = &spinner_cache; g_object_add_weak_pointer (G_OBJECT (spinner_cache), (gpointer *) cache_ptr); return spinner_cache; } return g_object_ref (spinner_cache); }
/** * thunar_column_model_get_default: * * Returns the default, shared #ThunarColumnModel * instance. * * The caller is responsible to free the returned * object using g_object_unref() when no longer * needed. * * Return value: the default #ThunarColumnModel. **/ ThunarColumnModel* thunar_column_model_get_default (void) { static ThunarColumnModel *column_model = NULL; if (G_UNLIKELY (column_model == NULL)) { column_model = g_object_new (THUNAR_TYPE_COLUMN_MODEL, NULL); g_object_add_weak_pointer (G_OBJECT (column_model), (gpointer) &column_model); } else { g_object_ref (G_OBJECT (column_model)); } return column_model; }
/** * terminal_toolbars_model_get_default: * * Return value : **/ ExoToolbarsModel* terminal_toolbars_model_get_default (void) { static ExoToolbarsModel *model = NULL; if (G_UNLIKELY (model == NULL)) { model = g_object_new (TERMINAL_TYPE_TOOLBARS_MODEL, NULL); g_object_add_weak_pointer (G_OBJECT (model), (gpointer) &model); } else { g_object_ref (G_OBJECT (model)); } return model; }
/** * seahorse_object_set_preferred: * @self: the object to set the preferred object for * @value: the preferred object * * */ void seahorse_object_set_preferred (SeahorseObject *self, SeahorseObject *value) { g_return_if_fail (SEAHORSE_IS_OBJECT (self)); if (self->pv->preferred == value) return; if (self->pv->preferred) g_object_remove_weak_pointer (G_OBJECT (self->pv->preferred), (gpointer*)&self->pv->preferred); self->pv->preferred = value; if (self->pv->preferred != NULL) g_object_add_weak_pointer (G_OBJECT (self->pv->preferred), (gpointer*)&self->pv->preferred); g_object_notify (G_OBJECT (self), "preferred"); }
static GitgSpinnerCache * gitg_spinner_cache_ref (void) { if (spinner_cache == NULL) { GitgSpinnerCache **cache_ptr; spinner_cache = g_object_new (GITG_TYPE_SPINNER_CACHE, NULL); cache_ptr = &spinner_cache; g_object_add_weak_pointer (G_OBJECT (spinner_cache), (gpointer *) cache_ptr); return spinner_cache; } return g_object_ref (spinner_cache); }
/** * dfu_target_new: (skip) * @device: a #DfuDevice * @iface: a #GUsbInterface * * Creates a new DFU target, which represents an alt-setting on a * DFU-capable device. * * Return value: a #DfuTarget, or %NULL if @iface was not DFU-capable * * Since: 0.5.4 **/ DfuTarget * dfu_target_new (DfuDevice *device, GUsbInterface *iface) { DfuTargetPrivate *priv; DfuTarget *target; target = g_object_new (DFU_TYPE_TARGET, NULL); priv = GET_PRIVATE (target); priv->device = device; priv->alt_idx = g_usb_interface_get_index (iface); priv->alt_setting = g_usb_interface_get_alternate (iface); /* if we try to ref the target and destroy the device */ g_object_add_weak_pointer (G_OBJECT (priv->device), (gpointer *) &priv->device); return target; }
GtkActionGroup * seahorse_gpgme_key_actions_instance (void) { static GtkActionGroup *actions = NULL; if (actions == NULL) { actions = g_object_new (SEAHORSE_TYPE_GPGME_KEY_ACTIONS, "name", "gpgme-key", NULL); g_object_add_weak_pointer (G_OBJECT (actions), (gpointer *)&actions); } else { g_object_ref (actions); } return actions; }
/* Create static VerveDb instance and return a pointer to it */ VerveDb* verve_db_get (void) { static VerveDb *db = NULL; if (G_UNLIKELY (db == NULL)) { db = g_object_new (VERVE_TYPE_DB, NULL); g_object_add_weak_pointer (G_OBJECT (db), (gpointer) &db); } else { g_object_ref (G_OBJECT (db)); } return db; }
GtkActionGroup * seahorse_pgp_backend_actions_instance (void) { static GtkActionGroup *actions = NULL; if (actions == NULL) { actions = g_object_new (SEAHORSE_TYPE_PGP_BACKEND_ACTIONS, "name", "pgp-backend", NULL); g_object_add_weak_pointer (G_OBJECT (actions), (gpointer *)&actions); } else { g_object_ref (actions); } return actions; }
static EphySpinnerCache * ephy_spinner_cache_ref (void) { if (spinner_cache == NULL) { EphySpinnerCache **cache_ptr; spinner_cache = g_object_new (EPHY_TYPE_SPINNER_CACHE, NULL); cache_ptr = &spinner_cache; g_object_add_weak_pointer (G_OBJECT (spinner_cache), (gpointer) cache_ptr); return spinner_cache; } return g_object_ref (spinner_cache); }
static void test_fact_store_insert (void) { void* p; p = NULL; { OhmFactStore* fs; OhmFact* fact; fs = ohm_fact_store_new (); fact = ohm_fact_new ("org.test.match"); p = fact; g_object_add_weak_pointer (G_OBJECT (fact), &p); ohm_fact_store_insert (fs, fact); g_assert (p != NULL); (fs == NULL ? NULL : (fs = (g_object_unref (fs), NULL))); (fact == NULL ? NULL : (fact = (g_object_unref (fact), NULL))); } g_assert (p == NULL); }
static void gtk_tooltip_set_last_window (GtkTooltip *tooltip, GdkWindow *window) { 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); }
BuilderApplication* builder_application_get (void) { static BuilderApplication *application = NULL; if (G_UNLIKELY (application == NULL)) { application = g_object_new (BUILDER_TYPE_APPLICATION, NULL); g_object_add_weak_pointer (G_OBJECT (application), (gpointer) &application); } else { g_object_ref (G_OBJECT (application)); } return application; }
HDDesktop * hd_desktop_get (void) { static gpointer desktop = NULL; if (desktop == NULL) { desktop = g_object_new (HD_TYPE_DESKTOP, NULL); g_object_add_weak_pointer (desktop, &desktop); return desktop; } else { return g_object_ref (desktop); } }
/** * seahorse_object_set_source: * @self: The object to set a new source for * @value: The source to set * * sets the source for the object */ void seahorse_object_set_source (SeahorseObject *self, SeahorseSource *value) { g_return_if_fail (SEAHORSE_IS_OBJECT (self)); if (value == self->pv->source) return; if (self->pv->source) g_object_remove_weak_pointer (G_OBJECT (self->pv->source), (gpointer*)&self->pv->source); self->pv->source = value; if (self->pv->source != NULL) g_object_add_weak_pointer (G_OBJECT (self->pv->source), (gpointer*)&self->pv->source); g_object_notify (G_OBJECT (self), "source"); }
/** * thunar_vfs_volume_manager_get_default: * * Returns the default, shared #ThunarVfsVolumeManager instance * for this system. This function automatically determines, which * implementation of #ThunarVfsVolumeManager should be used for * the target system and returns an instance of that class, which * is shared among all modules using the volume manager facility. * * Call g_object_unref() on the returned object when you are * done with it. * * Return value: the shared #ThunarVfsVolumeManager instance. **/ ThunarVfsVolumeManager* thunar_vfs_volume_manager_get_default (void) { static ThunarVfsVolumeManager *manager = NULL; if (G_UNLIKELY (manager == NULL)) { manager = g_object_new (THUNAR_VFS_TYPE_VOLUME_MANAGER_IMPL, NULL); g_object_add_weak_pointer (G_OBJECT (manager), (gpointer) &manager); } else { g_object_ref (G_OBJECT (manager)); } return manager; }
/** * gst_type_find_register: * @plugin: (allow-none): A #GstPlugin, or NULL for a static typefind function * @name: The name for registering * @rank: The rank (or importance) of this typefind function * @func: The #GstTypeFindFunction to use * @extensions: (allow-none): Optional comma-separated list of extensions * that could belong to this type * @possible_caps: Optionally the caps that could be returned when typefinding * succeeds * @data: Optional user data. This user data must be available until the plugin * is unloaded. * @data_notify: a #GDestroyNotify that will be called on @data when the plugin * is unloaded. * * Registers a new typefind function to be used for typefinding. After * registering this function will be available for typefinding. * This function is typically called during an element's plugin initialization. * * Returns: TRUE on success, FALSE otherwise */ gboolean gst_type_find_register (GstPlugin * plugin, const gchar * name, guint rank, GstTypeFindFunction func, const gchar * extensions, GstCaps * possible_caps, gpointer data, GDestroyNotify data_notify) { GstTypeFindFactory *factory; g_return_val_if_fail (name != NULL, FALSE); GST_INFO ("registering typefind function for %s", name); factory = g_object_newv (GST_TYPE_TYPE_FIND_FACTORY, 0, NULL); GST_DEBUG_OBJECT (factory, "using new typefind factory for %s", name); g_assert (GST_IS_TYPE_FIND_FACTORY (factory)); gst_plugin_feature_set_name (GST_PLUGIN_FEATURE_CAST (factory), name); gst_plugin_feature_set_rank (GST_PLUGIN_FEATURE_CAST (factory), rank); if (factory->extensions) { g_strfreev (factory->extensions); factory->extensions = NULL; } if (extensions) factory->extensions = g_strsplit (extensions, ",", -1); gst_caps_replace (&factory->caps, possible_caps); factory->function = func; factory->user_data = data; factory->user_data_notify = data_notify; if (plugin && plugin->desc.name) { GST_PLUGIN_FEATURE_CAST (factory)->plugin_name = plugin->desc.name; /* interned string */ GST_PLUGIN_FEATURE_CAST (factory)->plugin = plugin; g_object_add_weak_pointer ((GObject *) plugin, (gpointer *) & GST_PLUGIN_FEATURE_CAST (factory)->plugin); } else { GST_PLUGIN_FEATURE_CAST (factory)->plugin_name = "NULL"; GST_PLUGIN_FEATURE_CAST (factory)->plugin = NULL; } GST_PLUGIN_FEATURE_CAST (factory)->loaded = TRUE; gst_registry_add_feature (gst_registry_get (), GST_PLUGIN_FEATURE_CAST (factory)); return TRUE; }
static void _gth_window_add_header_bar (GthWindow *self) { self->priv->headerbar = gtk_header_bar_new (); gtk_widget_show (self->priv->headerbar); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (self->priv->headerbar), TRUE); g_object_add_weak_pointer (G_OBJECT (self->priv->headerbar), &self->priv->headerbar); #if GTK_CHECK_VERSION(3,12,0) { gboolean shell_shows_app_menu; char *decoration_layout; g_object_get (gtk_settings_get_default (), "gtk-shell-shows-app-menu", &shell_shows_app_menu, "gtk-decoration-layout", &decoration_layout, NULL); if (! shell_shows_app_menu && ((decoration_layout == NULL) || (strstr (decoration_layout, "menu") == NULL))) { gboolean left_part_is_empty; char *new_layout; /* add 'menu' to the left */ left_part_is_empty = (decoration_layout == NULL) || (decoration_layout[0] == '\0') || (decoration_layout[0] == ':'); new_layout = g_strconcat ("menu", (left_part_is_empty ? "" : ","), decoration_layout, NULL); gtk_header_bar_set_decoration_layout (GTK_HEADER_BAR (self->priv->headerbar), new_layout); g_free (new_layout); } g_free (decoration_layout); } #endif self->priv->title = gth_window_title_new (); gtk_widget_show (self->priv->title); gtk_header_bar_set_custom_title (GTK_HEADER_BAR (self->priv->headerbar), self->priv->title); self->priv->headerbar_container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_widget_show (self->priv->headerbar_container); gtk_box_pack_start (GTK_BOX (self->priv->headerbar_container), self->priv->headerbar, TRUE, TRUE, 0); gtk_window_set_titlebar (GTK_WINDOW (self), self->priv->headerbar_container); }
static void gucharmap_chartable_accessible_initialize (AtkObject *obj, gpointer data) { GtkWidget *widget; AtkObject *focus_obj, *old_focus_obj; GucharmapChartableAccessible *accessible; GucharmapChartableAccessiblePrivate *priv; GucharmapChartable *chartable; GucharmapChartablePrivate *chartable_priv; ATK_OBJECT_CLASS (gucharmap_chartable_accessible_parent_class)->initialize (obj, data); widget = GTK_WIDGET (data); accessible = GUCHARMAP_CHARTABLE_ACCESSIBLE (obj); priv = GET_PRIVATE (accessible); chartable = GUCHARMAP_CHARTABLE (widget); chartable_priv = chartable->priv; if (chartable_priv->vadjustment) { GtkAdjustment **adjustment_ptr = &priv->vadjustment; priv->vadjustment = chartable_priv->vadjustment; g_object_add_weak_pointer (G_OBJECT (priv->vadjustment), (gpointer *) adjustment_ptr); g_signal_connect (chartable_priv->vadjustment, "value-changed", G_CALLBACK (adjustment_changed), obj); } g_signal_connect_after (chartable, "notify::hadjustment", G_CALLBACK (sync_adjustment), obj); g_signal_connect_after (chartable, "notify::vadjustment", G_CALLBACK (sync_adjustment), obj); g_signal_connect (widget, "size-allocate", G_CALLBACK (size_allocated), obj); g_signal_connect (chartable, "notify::active-character", G_CALLBACK (sync_active_char), obj); focus_obj = find_object (chartable, chartable_priv->active_cell, obj); old_focus_obj = priv->focus_obj; priv->focus_obj = focus_obj; /* adopts the reference from find_object */ if (old_focus_obj) g_object_unref (old_focus_obj); }
/** * gb_tree_builder_set_tree: * @builder: (in): A #GbTreeBuilder. * @tree: (in): A #GbTree. * * Sets the tree the builder is associated with. * * Returns: None. * Side effects: None. */ static void gb_tree_builder_set_tree (GbTreeBuilder *builder, GbTree *tree) { GbTreeBuilderPrivate *priv; g_return_if_fail(GB_IS_TREE_BUILDER(builder)); g_return_if_fail(builder->priv->tree == NULL); g_return_if_fail(GB_IS_TREE(tree)); priv = builder->priv; if (tree) { priv->tree = tree; g_object_add_weak_pointer(G_OBJECT(priv->tree), (gpointer *)&priv->tree); } }
static GObject * nemo_previewer_constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { GObject *retval; if (singleton != NULL) return G_OBJECT (singleton); retval = G_OBJECT_CLASS (nemo_previewer_parent_class)->constructor (type, n_construct_params, construct_params); singleton = NEMO_PREVIEWER (retval); g_object_add_weak_pointer (retval, (gpointer) &singleton); return retval; }
static GObject * goa_dlna_server_manager_constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { if (goa_dlna_server_manager_singleton == NULL) { goa_dlna_server_manager_singleton = G_OBJECT_CLASS (goa_dlna_server_manager_parent_class)->constructor (type, n_construct_params, construct_params); g_object_add_weak_pointer (goa_dlna_server_manager_singleton, (gpointer) &goa_dlna_server_manager_singleton); return goa_dlna_server_manager_singleton; } return g_object_ref (goa_dlna_server_manager_singleton); }
void balsa_mime_widget_image_resize_all(GtkWidget * widget, gpointer user_data) { if (GTK_IS_CONTAINER(widget)) gtk_container_foreach(GTK_CONTAINER(widget), balsa_mime_widget_image_resize_all, NULL); else if (GTK_IS_IMAGE(widget) && g_object_get_data(G_OBJECT(widget), "orig-width") && g_object_get_data(G_OBJECT(widget), "mime-body") && !GPOINTER_TO_INT(g_object_get_data (G_OBJECT(widget), "check_size_sched"))) { GtkWidget **widget_p = g_new(GtkWidget *, 1); g_object_set_data(G_OBJECT(widget), "check_size_sched", GINT_TO_POINTER(TRUE)); *widget_p = widget; g_object_add_weak_pointer(G_OBJECT(widget), (gpointer) widget_p); g_idle_add((GSourceFunc) img_check_size, widget_p); }
static GObject * photos_dlna_renderers_manager_constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { if (photos_dlna_renderers_manager_singleton == NULL) { photos_dlna_renderers_manager_singleton = G_OBJECT_CLASS (photos_dlna_renderers_manager_parent_class)->constructor (type, n_construct_params, construct_params); g_object_add_weak_pointer (photos_dlna_renderers_manager_singleton, (gpointer) &photos_dlna_renderers_manager_singleton); return photos_dlna_renderers_manager_singleton; } return g_object_ref (photos_dlna_renderers_manager_singleton); }