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;
}