static gboolean tracker_filter_model_update (gpointer gstore) { int i, n; int all = 0; int store_pos; GtkTreeIter iter; GObject * o = G_OBJECT (gstore); GtkTreeStore * store = GTK_TREE_STORE (gstore); GtkTreeModel * model = GTK_TREE_MODEL (gstore); GPtrArray * hosts = g_ptr_array_new (); GStringChunk * strings = g_string_chunk_new (4096); GHashTable * hosts_hash = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_free); GtkTreeModel * tmodel = GTK_TREE_MODEL (g_object_get_qdata (o, TORRENT_MODEL_KEY)); const int first_tracker_pos = 2; /* offset past the "All" and the separator */ g_object_steal_qdata (o, DIRTY_KEY); /* Walk through all the torrents, tallying how many matches there are * for the various categories. Also make a sorted list of all tracker * hosts s.t. we can merge it with the existing list */ if (gtk_tree_model_iter_nth_child (tmodel, &iter, NULL, 0)) do { tr_torrent * tor; const tr_info * inf; int keyCount; char ** keys; gtk_tree_model_get (tmodel, &iter, MC_TORRENT, &tor, -1); inf = tr_torrentInfo (tor); keyCount = 0; keys = g_new (char*, inf->trackerCount); for (i=0, n=inf->trackerCount; i<n; ++i) { int k; int * count; char buf[1024]; char * key; gtr_get_host_from_url (buf, sizeof (buf), inf->trackers[i].announce); key = g_string_chunk_insert_const (strings, buf); count = g_hash_table_lookup (hosts_hash, key); if (count == NULL) { count = tr_new0 (int, 1); g_hash_table_insert (hosts_hash, key, count); g_ptr_array_add (hosts, key); } for (k=0; k<keyCount; ++k) if (!g_strcmp0 (keys[k], key)) break; if (k==keyCount) keys[keyCount++] = key; } for (i=0; i<keyCount; ++i) { int * incrementme = g_hash_table_lookup (hosts_hash, keys[i]); ++*incrementme; } g_free (keys); ++all; }
/** * eel_accessibility_get_atk_object: * @object: a GObject of some sort * * gets an AtkObject associated with a GObject * * Return value: the associated accessible if one exists or NULL **/ AtkObject * eel_accessibility_get_atk_object (gpointer object) { return g_object_get_qdata (object, get_quark_accessible ()); }
static PrivateData* get_private_data( TrWindow * w ) { return g_object_get_qdata ( G_OBJECT( w ), get_private_data_key( ) ); }
GtkAction * _gtk_recent_chooser_get_related_action (GtkRecentChooser *recent_chooser) { return g_object_get_qdata (G_OBJECT (recent_chooser), quark_gtk_related_action); }
static GSList * get_size_groups (GtkWidget *widget) { return g_object_get_qdata (G_OBJECT (widget), size_groups_quark); }
static void xfdesktop_volume_icon_mount_finish(GObject *object, GAsyncResult *result, gpointer user_data) { XfdesktopVolumeIcon *icon = XFDESKTOP_VOLUME_ICON(user_data); GtkWidget *icon_view = xfdesktop_icon_peek_icon_view(XFDESKTOP_ICON(icon)); GtkWidget *toplevel = gtk_widget_get_toplevel(icon_view); GVolume *volume = G_VOLUME(object); GError *error = NULL; if(!g_volume_mount_finish(volume, result, &error)) { if(error->domain != G_IO_ERROR || error->code != G_IO_ERROR_FAILED_HANDLED) { gchar *volume_name = g_volume_get_name(volume); gchar *primary = g_markup_printf_escaped(_("Failed to mount \"%s\""), volume_name); xfce_message_dialog(toplevel ? GTK_WINDOW(toplevel) : NULL, _("Mount Failed"), GTK_STOCK_DIALOG_ERROR, primary, error->message, GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL); g_free(primary); g_free(volume_name); } g_error_free(error); } else { GMount *mount = g_volume_get_mount(volume); GFile *file = NULL; GFileInfo *info = NULL; if(mount) { file = g_mount_get_root(mount); info = g_file_query_info(file, XFDESKTOP_FILE_INFO_NAMESPACE, G_FILE_QUERY_INFO_NONE, NULL, NULL); g_object_unref(mount); } if(file && info) { gboolean activated = FALSE; if(icon->priv->file) g_object_unref(icon->priv->file); icon->priv->file = g_object_ref(file); xfdesktop_file_icon_update_file_info(XFDESKTOP_FILE_ICON(icon), info); activated = GPOINTER_TO_UINT(g_object_get_qdata(G_OBJECT(icon), xfdesktop_volume_icon_activated_quark)); if(activated) { XfdesktopIcon *icon_p = XFDESKTOP_ICON(icon); XFDESKTOP_ICON_CLASS(xfdesktop_volume_icon_parent_class)->activated(icon_p); } g_object_set_qdata(G_OBJECT(icon), xfdesktop_volume_icon_activated_quark, NULL); } else { if(icon->priv->file) g_object_unref(icon->priv->file); icon->priv->file = NULL; xfdesktop_file_icon_update_file_info(XFDESKTOP_FILE_ICON(icon), NULL); } if(file) g_object_unref(file); if(info) g_object_unref(info); } }
static GimpToolManager * tool_manager_get (Gimp *gimp) { return g_object_get_qdata (G_OBJECT (gimp), tool_manager_quark); }
static GstPadProbeReturn set_appsrc_caps (GstPad * pad, GstPadProbeInfo * info, gpointer httpep) { KmsHttpPostEndpoint *self = KMS_HTTP_POST_ENDPOINT (httpep); GstEvent *event = GST_PAD_PROBE_INFO_EVENT (info); GstCaps *audio_caps = NULL, *video_caps = NULL; GstElement *appsrc, *appsink, *agnosticbin; GstCaps *caps; gpointer data; if (GST_EVENT_TYPE (event) != GST_EVENT_CAPS) { return GST_PAD_PROBE_OK; } gst_event_parse_caps (event, &caps); if (caps == NULL) { GST_ERROR_OBJECT (pad, "Invalid caps received"); return GST_PAD_PROBE_OK; } GST_TRACE ("caps are %" GST_PTR_FORMAT, caps); data = g_object_get_qdata (G_OBJECT (pad), appsrc_data_quark ()); if (data != NULL) { goto end; } /* Get the proper agnosticbin */ audio_caps = gst_caps_from_string (KMS_AGNOSTIC_AUDIO_CAPS); video_caps = gst_caps_from_string (KMS_AGNOSTIC_VIDEO_CAPS); if (gst_caps_can_intersect (audio_caps, caps)) agnosticbin = kms_element_get_audio_agnosticbin (KMS_ELEMENT (self)); else if (gst_caps_can_intersect (video_caps, caps)) agnosticbin = kms_element_get_video_agnosticbin (KMS_ELEMENT (self)); else { GST_ELEMENT_WARNING (self, CORE, CAPS, ("Unsupported media received: %" GST_PTR_FORMAT, caps), ("Unsupported media received: %" GST_PTR_FORMAT, caps)); goto end; } /* Create appsrc element and link to agnosticbin */ appsrc = gst_element_factory_make ("appsrc", NULL); g_object_set (G_OBJECT (appsrc), "is-live", TRUE, "do-timestamp", FALSE, "min-latency", G_GUINT64_CONSTANT (0), "max-latency", G_GUINT64_CONSTANT (0), "format", GST_FORMAT_TIME, "caps", caps, NULL); gst_bin_add (GST_BIN (self), appsrc); if (!gst_element_link (appsrc, agnosticbin)) { GST_ERROR ("Could not link %s to element %s", GST_ELEMENT_NAME (appsrc), GST_ELEMENT_NAME (agnosticbin)); } /* Connect new-sample signal to callback */ appsink = gst_pad_get_parent_element (pad); g_signal_connect (appsink, "new-sample", G_CALLBACK (new_sample_post_handler), appsrc); g_object_unref (appsink); g_object_set_qdata (G_OBJECT (pad), appsrc_data_quark (), appsrc); gst_element_sync_state_with_parent (appsrc); end: if (audio_caps != NULL) gst_caps_unref (audio_caps); if (video_caps != NULL) gst_caps_unref (video_caps); return GST_PAD_PROBE_OK; }
static GstFlowReturn new_sample_post_handler (GstElement * appsink, gpointer user_data) { GstElement *appsrc = GST_ELEMENT (user_data); GstSample *sample = NULL; GstBuffer *buffer; GstFlowReturn ret; GstClockTime *base_time; g_signal_emit_by_name (appsink, "pull-sample", &sample); if (sample == NULL) return GST_FLOW_OK; buffer = gst_sample_get_buffer (sample); if (buffer == NULL) { ret = GST_FLOW_OK; goto end; } gst_buffer_ref (buffer); buffer = gst_buffer_make_writable (buffer); BASE_TIME_LOCK (GST_OBJECT_PARENT (appsrc)); base_time = g_object_get_qdata (G_OBJECT (GST_OBJECT_PARENT (appsrc)), base_time_data_quark ()); if (base_time == NULL) { GstClock *clock; clock = gst_element_get_clock (appsrc); base_time = g_slice_new0 (GstClockTime); g_object_set_qdata_full (G_OBJECT (GST_OBJECT_PARENT (appsrc)), base_time_data_quark (), base_time, release_gst_clock); *base_time = gst_clock_get_time (clock) - gst_element_get_base_time (appsrc); g_object_unref (clock); GST_DEBUG ("Setting base time to: %" G_GUINT64_FORMAT, *base_time); } if (GST_BUFFER_PTS_IS_VALID (buffer)) buffer->pts += *base_time; if (GST_BUFFER_DTS_IS_VALID (buffer)) buffer->dts += *base_time; BASE_TIME_UNLOCK (GST_OBJECT_PARENT (appsrc)); /* Pass the buffer through appsrc element which is */ /* placed in a different pipeline */ g_signal_emit_by_name (appsrc, "push-buffer", buffer, &ret); gst_buffer_unref (buffer); if (ret != GST_FLOW_OK) { /* something went wrong */ GST_ERROR ("Could not send buffer to appsrc %s. Cause %s", GST_ELEMENT_NAME (appsrc), gst_flow_get_name (ret)); } end: if (sample != NULL) gst_sample_unref (sample); return ret; }
static GtkFileChooser * get_delegate (GtkFileChooser *receiver) { return g_object_get_qdata (G_OBJECT (receiver), GTK_FILE_CHOOSER_DELEGATE_QUARK); }
/** * pango_shape: * @text: the text to process * @length: the length (in bytes) of @text * @analysis: #PangoAnalysis structure from pango_itemize() * @glyphs: glyph string in which to store results * * Given a segment of text and the corresponding * #PangoAnalysis structure returned from pango_itemize(), * convert the characters into glyphs. You may also pass * in only a substring of the item from pango_itemize(). */ void pango_shape (const gchar *text, gint length, const PangoAnalysis *analysis, PangoGlyphString *glyphs) { int i; int last_cluster; glyphs->num_glyphs = 0; if (G_LIKELY (analysis->shape_engine && analysis->font)) { _pango_engine_shape_shape (analysis->shape_engine, analysis->font, text, length, analysis, glyphs); if (G_UNLIKELY (glyphs->num_glyphs == 0)) { /* If a font has been correctly chosen, but no glyphs are output, * there's probably something wrong with the shaper, or the font. * * Trying to be informative, we print out the font description, * shaper name, and the text, but to not flood the terminal with * zillions of the message, we set a flag to only err once per * font/engine pair. * * To do the flag fast, we use the engine qname to qflag the font, * but also the font description to flag the engine. This is * supposed to be fast to check, but also avoid writing out * duplicate warnings when a new PangoFont is created. */ GType engine_type = G_OBJECT_TYPE (analysis->shape_engine); GQuark warned_quark = g_type_qname (engine_type); if (!g_object_get_qdata (G_OBJECT (analysis->font), warned_quark)) { PangoFontDescription *desc; char *font_name; const char *engine_name; desc = pango_font_describe (analysis->font); font_name = pango_font_description_to_string (desc); pango_font_description_free (desc); if (!g_object_get_data (G_OBJECT (analysis->shape_engine), font_name)) { engine_name = g_type_name (engine_type); if (!engine_name) engine_name = "(unknown)"; g_warning ("shaping failure, expect ugly output. shape-engine='%s', font='%s', text='%.*s'", engine_name, font_name, length == -1 ? (gint) strlen (text) : length, text); g_object_set_data_full (G_OBJECT (analysis->shape_engine), font_name, GINT_TO_POINTER (1), NULL); } g_free (font_name); g_object_set_qdata_full (G_OBJECT (analysis->font), warned_quark, GINT_TO_POINTER (1), NULL); } } } else glyphs->num_glyphs = 0; if (!glyphs->num_glyphs) { PangoEngineShape *fallback_engine = _pango_get_fallback_shaper (); _pango_engine_shape_shape (fallback_engine, analysis->font, text, length, analysis, glyphs); } /* make sure last_cluster is invalid */ last_cluster = glyphs->log_clusters[0] - 1; for (i = 0; i < glyphs->num_glyphs; i++) { /* Set glyphs[i].attr.is_cluster_start based on log_clusters[] */ if (glyphs->log_clusters[i] != last_cluster) { glyphs->glyphs[i].attr.is_cluster_start = TRUE; last_cluster = glyphs->log_clusters[i]; } else glyphs->glyphs[i].attr.is_cluster_start = FALSE; /* Shift glyph if width is negative, and negate width. * This is useful for rotated font matrices and shouldn't * harm in normal cases. */ if (glyphs->glyphs[i].geometry.width < 0) { glyphs->glyphs[i].geometry.width = -glyphs->glyphs[i].geometry.width; glyphs->glyphs[i].geometry.x_offset += glyphs->glyphs[i].geometry.width; } } }
/* Call this function holding the lock */ static inline gboolean is_dropping (GstPad * pad) { return GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (pad), dropping_until_key_frame_quark ())); }
const gchar * kms_utils_get_uuid (GObject * obj) { return (const gchar *) g_object_get_qdata (obj, kms_key_id_quark ()); }
static PrivateData* get_private_data (GtkWindow * w) { return g_object_get_qdata (G_OBJECT (w), private_data_quark ()); }
/* Returns a structure with information we will use to rendering given the * #PangoFont. This is computed once per font and cached for later retrieval. */ static ThaiFontInfo * thai_x_get_font_info (PangoFont *font) { static const char *charsets[] = { "tis620-2", "tis620-1", "tis620-0", "xtis620.2529-1", "xtis-0", "tis620.2533-1", "tis620.2529-1", "iso8859-11", "iso10646-1", }; static const int charset_types[] = { THAI_FONT_TIS_WIN, THAI_FONT_TIS_MAC, THAI_FONT_TIS, THAI_FONT_XTIS, THAI_FONT_XTIS, THAI_FONT_TIS, THAI_FONT_TIS, THAI_FONT_TIS, THAI_FONT_ISO10646 }; ThaiFontInfo *font_info; GQuark info_id = g_quark_from_string ("thai-font-info"); font_info = g_object_get_qdata (G_OBJECT (font), info_id); if (!font_info) { /* No cached information not found, so we need to compute it * from scratch */ PangoXSubfont *subfont_ids; gint *subfont_charsets; gint n_subfonts, i; font_info = g_new (ThaiFontInfo, 1); font_info->font = font; font_info->font_set = THAI_FONT_NONE; g_object_set_qdata_full (G_OBJECT (font), info_id, font_info, (GDestroyNotify)g_free); n_subfonts = pango_x_list_subfonts (font, (char **)charsets, G_N_ELEMENTS (charsets), &subfont_ids, &subfont_charsets); for (i=0; i < n_subfonts; i++) { ThaiFontSet font_set = charset_types[subfont_charsets[i]]; if (font_set != THAI_FONT_ISO10646 || pango_x_has_glyph (font, PANGO_X_MAKE_GLYPH (subfont_ids[i], 0xe01))) { font_info->font_set = font_set; font_info->subfont = subfont_ids[i]; break; } } g_free (subfont_ids); g_free (subfont_charsets); font_info->make_glyph = thai_x_make_glyph; font_info->make_unknown_glyph = thai_x_make_unknown_glyph; font_info->has_glyph = thai_x_has_glyph; } return font_info; }
GladeWidget * glade_editable_loaded_widget (GladeEditable *editable) { return g_object_get_qdata (G_OBJECT (editable), glade_editable_widget_quark); }
static __SOVPropArray * gdk_gl_overlay_get_sov_props (GdkScreen *screen) { __SOVPropArray *sov_props; GdkWindow *root_window; #ifdef GDKGLEXT_MULTIHEAD_SUPPORT GdkDisplay *display; #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ Display *xdisplay; Atom xa_sov; Status status; Atom actual_type; int actual_format; unsigned long nitems, bytes_after; unsigned char *prop = NULL; GDK_GL_NOTE_FUNC_PRIVATE (); #ifdef GDKGLEXT_MULTIHEAD_SUPPORT root_window = gdk_screen_get_root_window (screen); #else /* GDKGLEXT_MULTIHEAD_SUPPORT */ root_window = gdk_get_default_root_window (); #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ if (quark_sov_props == 0) quark_sov_props = g_quark_from_static_string (quark_sov_props_string); sov_props = g_object_get_qdata (G_OBJECT (root_window), quark_sov_props); if (sov_props != NULL) return sov_props; sov_props = g_malloc (sizeof (__SOVPropArray)); #ifdef GDKGLEXT_MULTIHEAD_SUPPORT display = gdk_screen_get_display (screen); xdisplay = GDK_DISPLAY_XDISPLAY (display); xa_sov = gdk_x11_get_xatom_by_name_for_display (display, "SERVER_OVERLAY_VISUALS"); #else /* GDKGLEXT_MULTIHEAD_SUPPORT */ xdisplay = gdk_x11_get_default_xdisplay (); xa_sov = gdk_x11_get_xatom_by_name ("SERVER_OVERLAY_VISUALS"); #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ status = XGetWindowProperty (xdisplay, GDK_WINDOW_XWINDOW (root_window), xa_sov, 0L, 1000000L, False, AnyPropertyType, &actual_type, &actual_format, &nitems, &bytes_after, &prop); if (status != Success || actual_type == None || actual_format != 32 || nitems < 4) { GDK_GL_NOTE (MISC, g_message (" -- SERVER_OVERLAY_VISUALS: not supported")); if (prop != NULL) XFree (prop); sov_props->prop = NULL; sov_props->num = 0; } else { GDK_GL_NOTE (MISC, g_message (" -- SERVER_OVERLAY_VISUALS: supported")); sov_props->prop = (__SOVProp *) prop; sov_props->num = nitems / (sizeof (__SOVProp) / 4); } g_object_set_qdata_full (G_OBJECT (root_window), quark_sov_props, sov_props, (GDestroyNotify) sov_prop_array_destroy); #ifdef G_ENABLE_DEBUG if (gdk_gl_debug_flags & GDK_GL_DEBUG_MISC) { #ifdef GDKGLEXT_MULTIHEAD_SUPPORT int screen_num = GDK_SCREEN_XNUMBER (screen); #else /* GDKGLEXT_MULTIHEAD_SUPPORT */ int screen_num = gdk_x11_get_default_screen (); #endif /* GDKGLEXT_MULTIHEAD_SUPPORT */ int i; g_message (" -- SERVER_OVERLAY_VISUALS: properties"); g_print ("screen\tvisual\ttype\tvalue\tlayer\n"); for (i = 0; i < sov_props->num; i++) { g_print ("%d\t0x%lx\t%lu\t%lu\t%ld\n", screen_num, (VisualID) (sov_props->prop[i].overlay_visual), (CARD32) (sov_props->prop[i].transparent_type), (CARD32) (sov_props->prop[i].value), (INT32) (sov_props->prop[i].layer)); } } #endif /* G_ENABLE_DEBUG */ return sov_props; }
gboolean glade_editable_loading (GladeEditable *editable) { return GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (editable), glade_editable_loading_quark)); }
static GBytes * lookup_assertion_key (GkmAssertion *assertion) { return g_object_get_qdata (G_OBJECT (assertion), QDATA_ASSERTION_KEY); }
/** * fm_icon_get_user_data * @icon: a #FmIcon object * * Retrieves user data that was set via fm_icon_set_user_data(). * * Returns: user data. * * Since: 0.1.0 * * Deprecated: 1.2.0: Use g_object_get_qdata() instead. */ gpointer fm_icon_get_user_data(FmIcon* icon) { return g_object_get_qdata(G_OBJECT(icon), fm_qdata_id); }
cairo_scaled_font_t * _pango_cairo_font_private_get_scaled_font (PangoCairoFontPrivate *cf_priv) { cairo_font_face_t *font_face; if (G_LIKELY (cf_priv->scaled_font)) return cf_priv->scaled_font; /* need to create it */ if (G_UNLIKELY (cf_priv->data == NULL)) { /* we have tried to create and failed before */ return NULL; } font_face = (* PANGO_CAIRO_FONT_GET_IFACE (cf_priv->cfont)->create_font_face) (cf_priv->cfont); if (G_UNLIKELY (font_face == NULL)) goto done; cf_priv->scaled_font = cairo_scaled_font_create (font_face, &cf_priv->data->font_matrix, &cf_priv->data->ctm, cf_priv->data->options); cairo_font_face_destroy (font_face); done: if (G_UNLIKELY (cf_priv->scaled_font == NULL || cairo_scaled_font_status (cf_priv->scaled_font) != CAIRO_STATUS_SUCCESS)) { cairo_scaled_font_t *scaled_font = cf_priv->scaled_font; PangoFont *font = PANGO_FONT (cf_priv->cfont); static GQuark warned_quark = 0; if (!warned_quark) warned_quark = g_quark_from_static_string ("pangocairo-scaledfont-warned"); if (!g_object_get_qdata (G_OBJECT (font), warned_quark)) { PangoFontDescription *desc; char *s; desc = pango_font_describe (font); s = pango_font_description_to_string (desc); pango_font_description_free (desc); g_warning ("failed to create cairo %s, expect ugly output. the offending font is '%s'", font_face ? "scaled font" : "font face", s); if (!font_face) g_warning ("font_face is NULL"); else g_warning ("font_face status is: %s", cairo_status_to_string (cairo_font_face_status (font_face))); if (!scaled_font) g_warning ("scaled_font is NULL"); else g_warning ("scaled_font status is: %s", cairo_status_to_string (cairo_scaled_font_status (scaled_font))); g_free (s); g_object_set_qdata_full (G_OBJECT (font), warned_quark, GINT_TO_POINTER (1), NULL); } } _pango_cairo_font_private_scaled_font_data_destroy (cf_priv->data); cf_priv->data = NULL; return cf_priv->scaled_font; }
static void interface_initialization_step (InitializationContext *ctx) { /* Don't run new steps if we're cancelled */ if (initialization_context_complete_and_free_if_cancelled (ctx)) return; switch (ctx->step) { case INITIALIZATION_STEP_FIRST: /* Setup quarks if we didn't do it before */ if (G_UNLIKELY (!support_checked_quark)) support_checked_quark = (g_quark_from_static_string ( SUPPORT_CHECKED_TAG)); if (G_UNLIKELY (!supported_quark)) supported_quark = (g_quark_from_static_string ( SUPPORTED_TAG)); /* Fall down to next step */ ctx->step++; case INITIALIZATION_STEP_CHECK_SUPPORT: if (!GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (ctx->self), support_checked_quark))) { /* Set the checked flag so that we don't run it again */ g_object_set_qdata (G_OBJECT (ctx->self), support_checked_quark, GUINT_TO_POINTER (TRUE)); /* Initially, assume we don't support it */ g_object_set_qdata (G_OBJECT (ctx->self), supported_quark, GUINT_TO_POINTER (FALSE)); if (MM_IFACE_MODEM_MESSAGING_GET_INTERFACE (ctx->self)->check_support && MM_IFACE_MODEM_MESSAGING_GET_INTERFACE (ctx->self)->check_support_finish) { MM_IFACE_MODEM_MESSAGING_GET_INTERFACE (ctx->self)->check_support ( ctx->self, (GAsyncReadyCallback)check_support_ready, ctx); return; } /* If there is no implementation to check support, assume we DON'T * support it. */ } /* Fall down to next step */ ctx->step++; case INITIALIZATION_STEP_FAIL_IF_UNSUPPORTED: if (!GPOINTER_TO_UINT (g_object_get_qdata (G_OBJECT (ctx->self), supported_quark))) { g_simple_async_result_set_error (ctx->result, MM_CORE_ERROR, MM_CORE_ERROR_UNSUPPORTED, "Messaging not supported"); initialization_context_complete_and_free (ctx); return; } /* Fall down to next step */ ctx->step++; case INITIALIZATION_STEP_LOAD_SUPPORTED_STORAGES: if (MM_IFACE_MODEM_MESSAGING_GET_INTERFACE (ctx->self)->load_supported_storages && MM_IFACE_MODEM_MESSAGING_GET_INTERFACE (ctx->self)->load_supported_storages_finish) { MM_IFACE_MODEM_MESSAGING_GET_INTERFACE (ctx->self)->load_supported_storages ( ctx->self, (GAsyncReadyCallback)load_supported_storages_ready, ctx); return; } /* Fall down to next step */ ctx->step++; case INITIALIZATION_STEP_LAST: /* We are done without errors! */ /* Handle method invocations */ g_signal_connect (ctx->skeleton, "handle-create", G_CALLBACK (handle_create), ctx->self); g_signal_connect (ctx->skeleton, "handle-delete", G_CALLBACK (handle_delete), ctx->self); g_signal_connect (ctx->skeleton, "handle-list", G_CALLBACK (handle_list), ctx->self); /* Finally, export the new interface */ mm_gdbus_object_skeleton_set_modem_messaging (MM_GDBUS_OBJECT_SKELETON (ctx->self), MM_GDBUS_MODEM_MESSAGING (ctx->skeleton)); g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE); initialization_context_complete_and_free (ctx); return; } g_assert_not_reached (); }
gboolean _gtk_recent_chooser_get_use_action_appearance (GtkRecentChooser *recent_chooser) { return !GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (recent_chooser), quark_gtk_use_action_appearance)); }
GtkWidget * gimp_editor_add_action_button (GimpEditor *editor, const gchar *group_name, const gchar *action_name, ...) { GimpActionGroup *group; GtkAction *action; GtkWidget *button; GtkWidget *old_child; GtkWidget *image; GtkIconSize button_icon_size; GtkReliefStyle button_relief; const gchar *stock_id; gchar *tooltip; const gchar *help_id; GList *extended = NULL; va_list args; g_return_val_if_fail (GIMP_IS_EDITOR (editor), NULL); g_return_val_if_fail (action_name != NULL, NULL); g_return_val_if_fail (editor->ui_manager != NULL, NULL); group = gimp_ui_manager_get_action_group (editor->ui_manager, group_name); g_return_val_if_fail (group != NULL, NULL); action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), action_name); g_return_val_if_fail (action != NULL, NULL); button_icon_size = gimp_editor_ensure_button_box (editor, &button_relief); if (GTK_IS_TOGGLE_ACTION (action)) button = gtk_toggle_button_new (); else button = gimp_button_new (); gtk_button_set_relief (GTK_BUTTON (button), button_relief); stock_id = gtk_action_get_stock_id (action); tooltip = g_strdup (gtk_action_get_tooltip (action)); old_child = gtk_bin_get_child (GTK_BIN (button)); if (old_child) gtk_container_remove (GTK_CONTAINER (button), old_child); image = gtk_image_new_from_stock (stock_id, button_icon_size); gtk_container_add (GTK_CONTAINER (button), image); gtk_widget_show (image); gtk_activatable_set_related_action (GTK_ACTIVATABLE (button), action); gtk_box_pack_start (GTK_BOX (editor->button_box), button, TRUE, TRUE, 0); gtk_widget_show (button); va_start (args, action_name); action_name = va_arg (args, const gchar *); while (action_name) { GdkModifierType mod_mask; mod_mask = va_arg (args, GdkModifierType); action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), action_name); if (action && mod_mask) { ExtendedAction *ext = g_slice_new (ExtendedAction); ext->mod_mask = mod_mask; ext->action = action; extended = g_list_prepend (extended, ext); if (tooltip) { const gchar *ext_tooltip = gtk_action_get_tooltip (action); if (ext_tooltip) { gchar *tmp = g_strconcat (tooltip, "\n<b>", gimp_get_mod_string (mod_mask), "</b> ", ext_tooltip, NULL); g_free (tooltip); tooltip = tmp; } } } action_name = va_arg (args, const gchar *); } va_end (args); if (extended) { g_object_set_data_full (G_OBJECT (button), "extended-actions", extended, (GDestroyNotify) gimp_editor_button_extended_actions_free); g_signal_connect (button, "extended-clicked", G_CALLBACK (gimp_editor_button_extended_clicked), NULL); } help_id = g_object_get_qdata (G_OBJECT (action), GIMP_HELP_ID); if (tooltip || help_id) gimp_help_set_help_data_with_markup (button, tooltip, help_id); g_free (tooltip); return button; }
static gboolean is_visited (gpointer object) { return g_object_get_qdata (object, visited_quark) != NULL; }
/** * gtk_text_buffer_deserialize: * @register_buffer: the #GtkTextBuffer @format is registered with * @content_buffer: the #GtkTextBuffer to deserialize into * @format: the rich text format to use for deserializing * @iter: insertion point for the deserialized text * @data: (array length=length): data to deserialize * @length: length of @data * @error: return location for a #GError * * This function deserializes rich text in format @format and inserts * it at @iter. * * @format<!-- -->s to be used must be registered using * gtk_text_buffer_register_deserialize_format() or * gtk_text_buffer_register_deserialize_tagset() beforehand. * * Return value: %TRUE on success, %FALSE otherwise. * * Since: 2.10 **/ gboolean gtk_text_buffer_deserialize (GtkTextBuffer *register_buffer, GtkTextBuffer *content_buffer, GdkAtom format, GtkTextIter *iter, const guint8 *data, gsize length, GError **error) { GList *formats; GList *list; g_return_val_if_fail (GTK_IS_TEXT_BUFFER (register_buffer), FALSE); g_return_val_if_fail (GTK_IS_TEXT_BUFFER (content_buffer), FALSE); g_return_val_if_fail (format != GDK_NONE, FALSE); g_return_val_if_fail (iter != NULL, FALSE); g_return_val_if_fail (data != NULL, FALSE); g_return_val_if_fail (length > 0, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); formats = g_object_get_qdata (G_OBJECT (register_buffer), deserialize_quark ()); for (list = formats; list; list = g_list_next (list)) { GtkRichTextFormat *fmt = list->data; if (fmt->atom == format) { GtkTextBufferDeserializeFunc function = fmt->function; gboolean success; GSList *split_tags; GSList *list; GtkTextMark *left_end = NULL; GtkTextMark *right_start = NULL; GSList *left_start_list = NULL; GSList *right_end_list = NULL; /* We don't want the tags that are effective at the insertion * point to affect the pasted text, therefore we remove and * remember them, so they can be re-applied left and right of * the inserted text after pasting */ split_tags = gtk_text_iter_get_tags (iter); list = split_tags; while (list) { GtkTextTag *tag = list->data; list = g_slist_next (list); /* If a tag begins at the insertion point, ignore it * because it doesn't affect the pasted text */ if (gtk_text_iter_begins_tag (iter, tag)) split_tags = g_slist_remove (split_tags, tag); } if (split_tags) { /* Need to remember text marks, because text iters * don't survive pasting */ left_end = gtk_text_buffer_create_mark (content_buffer, NULL, iter, TRUE); right_start = gtk_text_buffer_create_mark (content_buffer, NULL, iter, FALSE); for (list = split_tags; list; list = g_slist_next (list)) { GtkTextTag *tag = list->data; GtkTextIter *backward_toggle = gtk_text_iter_copy (iter); GtkTextIter *forward_toggle = gtk_text_iter_copy (iter); GtkTextMark *left_start = NULL; GtkTextMark *right_end = NULL; gtk_text_iter_backward_to_tag_toggle (backward_toggle, tag); left_start = gtk_text_buffer_create_mark (content_buffer, NULL, backward_toggle, FALSE); gtk_text_iter_forward_to_tag_toggle (forward_toggle, tag); right_end = gtk_text_buffer_create_mark (content_buffer, NULL, forward_toggle, TRUE); left_start_list = g_slist_prepend (left_start_list, left_start); right_end_list = g_slist_prepend (right_end_list, right_end); gtk_text_buffer_remove_tag (content_buffer, tag, backward_toggle, forward_toggle); gtk_text_iter_free (forward_toggle); gtk_text_iter_free (backward_toggle); } left_start_list = g_slist_reverse (left_start_list); right_end_list = g_slist_reverse (right_end_list); } success = function (register_buffer, content_buffer, iter, data, length, fmt->can_create_tags, fmt->user_data, error); if (!success && error != NULL && *error == NULL) g_set_error (error, 0, 0, _("Unknown error when trying to deserialize %s"), gdk_atom_name (format)); if (split_tags) { GSList *left_list; GSList *right_list; GtkTextIter left_e; GtkTextIter right_s; /* Turn the remembered marks back into iters so they * can by used to re-apply the remembered tags */ gtk_text_buffer_get_iter_at_mark (content_buffer, &left_e, left_end); gtk_text_buffer_get_iter_at_mark (content_buffer, &right_s, right_start); for (list = split_tags, left_list = left_start_list, right_list = right_end_list; list && left_list && right_list; list = g_slist_next (list), left_list = g_slist_next (left_list), right_list = g_slist_next (right_list)) { GtkTextTag *tag = list->data; GtkTextMark *left_start = left_list->data; GtkTextMark *right_end = right_list->data; GtkTextIter left_s; GtkTextIter right_e; gtk_text_buffer_get_iter_at_mark (content_buffer, &left_s, left_start); gtk_text_buffer_get_iter_at_mark (content_buffer, &right_e, right_end); gtk_text_buffer_apply_tag (content_buffer, tag, &left_s, &left_e); gtk_text_buffer_apply_tag (content_buffer, tag, &right_s, &right_e); gtk_text_buffer_delete_mark (content_buffer, left_start); gtk_text_buffer_delete_mark (content_buffer, right_end); } gtk_text_buffer_delete_mark (content_buffer, left_end); gtk_text_buffer_delete_mark (content_buffer, right_start); g_slist_free (split_tags); g_slist_free (left_start_list); g_slist_free (right_end_list); } return success; } } g_set_error (error, 0, 0, _("No deserialize function found for format %s"), gdk_atom_name (format)); return FALSE; }
/** * eel_accessibility_get_gobject: * @object: an AtkObject * * gets the GObject associated with the AtkObject, for which * @object provides accessibility support. * * Return value: the accessible's associated GObject **/ gpointer eel_accessibility_get_gobject (AtkObject *object) { return g_object_get_qdata (G_OBJECT (object), get_quark_gobject ()); }
/** * fm_app_chooser_dlg_dup_selected_app * @dlg: a widget * @set_default: location to get value that was used for fm_app_chooser_dlg_new() * * Retrieves a currently selected application from @dlg. * * Before 1.0.0 this call had name fm_app_chooser_dlg_get_selected_app. * * Returns: (transfer full): selected application. * * Since: 0.1.0 */ GAppInfo* fm_app_chooser_dlg_dup_selected_app(GtkDialog* dlg, gboolean* set_default) { GAppInfo* app = NULL; AppChooserData* data = (AppChooserData*)g_object_get_qdata(G_OBJECT(dlg), fm_qdata_id); switch( gtk_notebook_get_current_page(data->notebook) ) { case 0: /* all applications */ app = fm_app_menu_view_dup_selected_app(data->apps_view); break; case 1: /* custom cmd line */ { const char* cmdline = gtk_entry_get_text(data->cmdline); const char* app_name = gtk_entry_get_text(data->app_name); if(cmdline && cmdline[0]) { char* _cmdline = NULL; gboolean arg_found = FALSE; char* bin1 = get_binary(cmdline, &arg_found); g_debug("bin1 = %s", bin1); /* see if command line contains %f, %F, %u, or %U. */ if(!arg_found) /* append %f if no %f, %F, %u, or %U was found. */ cmdline = _cmdline = g_strconcat(cmdline, " %f", NULL); /* FIXME: is there any better way to do this? */ /* We need to ensure that no duplicated items are added */ if(data->mime_type) { MenuCache* menu_cache; /* see if the command is already in the list of known apps for this mime-type */ GList* apps = g_app_info_get_all_for_type(fm_mime_type_get_type(data->mime_type)); GList* l; for(l=apps;l;l=l->next) { GAppInfo* app2 = G_APP_INFO(l->data); const char* cmd = g_app_info_get_commandline(app2); char* bin2 = get_binary(cmd, NULL); if(g_strcmp0(bin1, bin2) == 0) { app = G_APP_INFO(g_object_ref(app2)); g_debug("found in app list"); g_free(bin2); break; } g_free(bin2); } g_list_foreach(apps, (GFunc)g_object_unref, NULL); g_list_free(apps); if(app) goto _out; /* see if this command can be found in menu cache */ menu_cache = menu_cache_lookup("applications.menu"); if(menu_cache) { #if MENU_CACHE_CHECK_VERSION(0, 4, 0) MenuCacheDir *root_dir = menu_cache_dup_root_dir(menu_cache); if(root_dir) #else if(menu_cache_get_root_dir(menu_cache)) #endif { GSList* all_apps = menu_cache_list_all_apps(menu_cache); GSList* l; for(l=all_apps;l;l=l->next) { MenuCacheApp* ma = MENU_CACHE_APP(l->data); const char *exec = menu_cache_app_get_exec(ma); char* bin2; if (exec == NULL) { g_warning("application %s has no Exec statement", menu_cache_item_get_id(MENU_CACHE_ITEM(ma))); continue; } bin2 = get_binary(exec, NULL); if(g_strcmp0(bin1, bin2) == 0) { app = G_APP_INFO(g_desktop_app_info_new(menu_cache_item_get_id(MENU_CACHE_ITEM(ma)))); g_debug("found in menu cache"); menu_cache_item_unref(MENU_CACHE_ITEM(ma)); g_free(bin2); break; } menu_cache_item_unref(MENU_CACHE_ITEM(ma)); g_free(bin2); } g_slist_free(all_apps); #if MENU_CACHE_CHECK_VERSION(0, 4, 0) menu_cache_item_unref(MENU_CACHE_ITEM(root_dir)); #endif } menu_cache_unref(menu_cache); } if(app) goto _out; } /* FIXME: g_app_info_create_from_commandline force the use of %f or %u, so this is not we need */ app = app_info_create_from_commandline(cmdline, app_name ? app_name : "", bin1, data->mime_type ? fm_mime_type_get_type(data->mime_type) : NULL, gtk_toggle_button_get_active(data->use_terminal), data->keep_open && gtk_toggle_button_get_active(data->keep_open)); _out: g_free(bin1); g_free(_cmdline); } } break; } if(set_default) *set_default = gtk_toggle_button_get_active(data->set_default); return app; }
static CarbonMenuItem * carbon_menu_item_get (GtkWidget *widget) { return g_object_get_qdata (G_OBJECT (widget), carbon_menu_item_quark); }
/** * fm_app_chooser_combo_box_get_custom_apps * @combo: a #GtkComboBox * * Retrieves a list of custom apps added with app-chooser. * The returned #GList is owned by the combo box and shouldn't be freed. * * Returns: (transfer none) (element-type GAppInfo): list of applications * * Since: 0.1.5 */ const GList* fm_app_chooser_combo_box_get_custom_apps(GtkComboBox* combo) { FmAppChooserComboBoxData* data = (FmAppChooserComboBoxData*)g_object_get_qdata(G_OBJECT(combo), fm_qdata_id); return data->custom_apps; }