//________________________________________________________________________________
gboolean ToolBarStateData::childEnterNotifyEvent( GtkWidget* widget, GdkEventCrossing*, gpointer data )
{
#if OXYGEN_DEBUG
std::cerr
<< "Oxygen::ToolBarStateData::childEnterNotifyEvent -"
<< " " << widget << " (" << G_OBJECT_TYPE_NAME( widget ) << ")"
<< std::endl;
#endif
static_cast<ToolBarStateData*>( data )->updateState( widget, true, false );
return FALSE;
}
//________________________________________________________________________________
gboolean ToolBarStateData::leaveNotifyEvent( GtkWidget* widget, GdkEventCrossing*, gpointer pointer )
{
#if OXYGEN_DEBUG
std::cerr
<< "Oxygen::ToolBarStateData::leaveNotifyEvent -"
<< " " << widget << " (" << G_OBJECT_TYPE_NAME( widget ) << ")"
<< std::endl;
#endif
ToolBarStateData& data( *static_cast<ToolBarStateData*>( pointer ) );
if( data._current.isValid() ) data.updateState( data._current._widget, false, false );
return FALSE;
}
static void
extension_subclass_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
g_debug ("Getting '%s:%s'",
G_OBJECT_TYPE_NAME (object),
g_param_spec_get_name (pspec));
G_OBJECT_CLASS (get_parent_class (object))->get_property (object, prop_id,
value, pspec);
}
static void
log_new_element_stats (GstElementStats * stats, GstElement * element,
GstClockTime elapsed)
{
gst_tracer_log_trace (gst_structure_new ("new-element",
"thread-id", G_TYPE_UINT, GPOINTER_TO_UINT (g_thread_self ()),
"ts", G_TYPE_UINT64, elapsed,
"ix", G_TYPE_UINT, stats->index,
"parent-ix", G_TYPE_UINT, stats->parent_ix,
"name", G_TYPE_STRING, GST_OBJECT_NAME (element),
"type", G_TYPE_STRING, G_OBJECT_TYPE_NAME (element),
"is-bin", G_TYPE_BOOLEAN, GST_IS_BIN (element), NULL));
}
void
unit_abandon (Unit *unit)
{
g_return_if_fail (unit != NULL);
if (!UNIT_GET_CLASS (unit)->start_transient)
{
g_warning ("%s does not implement StartTransient", G_OBJECT_TYPE_NAME (unit));
return;
}
return UNIT_GET_CLASS (unit)->abandon (unit);
}
static void cb_child_added(GstChildProxy *child_proxy, GObject *object, TSMFGstreamerDecoder* mdecoder)
{
DEBUG_TSMF("NAME: %s", G_OBJECT_TYPE_NAME(object));
if (!g_strcmp0(G_OBJECT_TYPE_NAME(object), "GstXvImageSink") || !g_strcmp0(G_OBJECT_TYPE_NAME(object), "GstXImageSink") || !g_strcmp0(G_OBJECT_TYPE_NAME(object), "GstFluVAAutoSink"))
{
gst_base_sink_set_max_lateness((GstBaseSink *) object, 10000000); /* nanoseconds */
g_object_set(G_OBJECT(object), "sync", TRUE, NULL); /* synchronize on the clock */
g_object_set(G_OBJECT(object), "async", TRUE, NULL); /* no async state changes */
}
else if (!g_strcmp0(G_OBJECT_TYPE_NAME(object), "GstAlsaSink") || !g_strcmp0(G_OBJECT_TYPE_NAME(object), "GstPulseSink"))
{
gst_base_sink_set_max_lateness((GstBaseSink *) object, 10000000); /* nanoseconds */
g_object_set(G_OBJECT(object), "slave-method", 1, NULL);
g_object_set(G_OBJECT(object), "buffer-time", (gint64) 20000, NULL); /* microseconds */
g_object_set(G_OBJECT(object), "drift-tolerance", (gint64) 20000, NULL); /* microseconds */
g_object_set(G_OBJECT(object), "latency-time", (gint64) 10000, NULL); /* microseconds */
g_object_set(G_OBJECT(object), "sync", TRUE, NULL); /* synchronize on the clock */
g_object_set(G_OBJECT(object), "async", TRUE, NULL); /* no async state changes */
}
}
static void
ide_device_provider_real_load_async (IdeDeviceProvider *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_task_report_new_error (self, callback, user_data,
ide_device_provider_real_load_async,
G_IO_ERROR,
G_IO_ERROR_NOT_SUPPORTED,
"%s does not implement load_async",
G_OBJECT_TYPE_NAME (self));
}
static void
log_new_pad_stats (GstPadStats * stats, GstPad * pad)
{
gst_tracer_log_trace (gst_structure_new ("new-pad",
"thread-id", G_TYPE_UINT, GPOINTER_TO_UINT (g_thread_self ()),
"ix", G_TYPE_UINT, stats->index,
"parent-ix", G_TYPE_UINT, stats->parent_ix,
"name", G_TYPE_STRING, GST_OBJECT_NAME (pad),
"type", G_TYPE_STRING, G_OBJECT_TYPE_NAME (pad),
"is-ghostpad", G_TYPE_BOOLEAN, GST_IS_GHOST_PAD (pad),
"pad-direction", GST_TYPE_PAD_DIRECTION, GST_PAD_DIRECTION (pad),
NULL));
}
static void
chooser_file_activated_cb (GtkFileChooser *chooser,
gpointer user_data)
{
gchar *folder, *filename;
folder = gtk_file_chooser_get_current_folder_uri (chooser);
filename = gtk_file_chooser_get_uri (chooser);
g_message ("%s::file-activated\n\tFolder: `%s'\n\tFilename: `%s'\nDone.\n",
G_OBJECT_TYPE_NAME (chooser), folder, filename);
g_free (folder);
g_free (filename);
}
/* A scroll event occured in workspace selector (e.g. by mouse-wheel) */
static gboolean _xfdashboard_workspace_selector_on_scroll_event(ClutterActor *inActor,
ClutterEvent *inEvent,
gpointer inUserData)
{
XfdashboardWorkspaceSelector *self;
XfdashboardWorkspaceSelectorPrivate *priv;
gint direction;
gint currentWorkspace;
gint maxWorkspace;
XfdashboardWindowTrackerWorkspace *workspace;
g_return_val_if_fail(XFDASHBOARD_IS_WORKSPACE_SELECTOR(inActor), CLUTTER_EVENT_PROPAGATE);
g_return_val_if_fail(inEvent, CLUTTER_EVENT_PROPAGATE);
self=XFDASHBOARD_WORKSPACE_SELECTOR(inActor);
priv=self->priv;
/* Get direction of scroll event */
switch(clutter_event_get_scroll_direction(inEvent))
{
case CLUTTER_SCROLL_UP:
case CLUTTER_SCROLL_LEFT:
direction=-1;
break;
case CLUTTER_SCROLL_DOWN:
case CLUTTER_SCROLL_RIGHT:
direction=1;
break;
/* Unhandled directions */
default:
g_debug("Cannot handle scroll direction %d in %s",
clutter_event_get_scroll_direction(inEvent),
G_OBJECT_TYPE_NAME(self));
return(CLUTTER_EVENT_PROPAGATE);
}
/* Get next workspace in scroll direction */
currentWorkspace=xfdashboard_window_tracker_workspace_get_number(priv->activeWorkspace);
maxWorkspace=xfdashboard_window_tracker_get_workspaces_count(priv->windowTracker);
currentWorkspace+=direction;
if(currentWorkspace<0 || currentWorkspace>=maxWorkspace) return(CLUTTER_EVENT_STOP);
/* Activate new workspace */
workspace=xfdashboard_window_tracker_get_workspace_by_number(priv->windowTracker, currentWorkspace);
xfdashboard_window_tracker_workspace_activate(workspace);
return(CLUTTER_EVENT_STOP);
}
static void
check_gst_log_handler (GstDebugCategory * category,
GstDebugLevel level, const gchar * file, const gchar * function, gint line,
GObject * object, GstDebugMessage * _message, gpointer data)
{
const gchar *message = gst_debug_message_get (_message);
gchar *msg, *obj_str;
const gchar *level_str, *cat_str;
GstClockTime elapsed;
//-- check message contents
if (__check_method && (strstr (function, __check_method) != NULL)
&& __check_test && (strstr (message, __check_test) != NULL))
__check_error_trapped = TRUE;
else if (__check_method && (strstr (function, __check_method) != NULL)
&& !__check_test)
__check_error_trapped = TRUE;
else if (__check_test && (strstr (message, __check_test) != NULL)
&& !__check_method)
__check_error_trapped = TRUE;
if (level > gst_debug_category_get_threshold (category))
return;
elapsed =
GST_CLOCK_DIFF (_priv_bt_info_start_time, gst_util_get_timestamp ());
level_str = gst_debug_level_get_name (level);
cat_str = gst_debug_category_get_name (category);
if (object) {
if (GST_IS_OBJECT (object)) {
obj_str = g_strdup_printf ("<%s,%" G_OBJECT_REF_COUNT_FMT ">",
GST_OBJECT_NAME (object), G_OBJECT_LOG_REF_COUNT (object));
} else if (GST_IS_OBJECT (object)) {
obj_str = g_strdup_printf ("<%s,%" G_OBJECT_REF_COUNT_FMT ">",
G_OBJECT_TYPE_NAME (object), G_OBJECT_LOG_REF_COUNT (object));
} else {
obj_str = g_strdup_printf ("%p", object);
}
} else {
obj_str = g_strdup ("");
}
msg = g_alloca (95 + strlen (cat_str) + strlen (level_str) + strlen (message)
+ strlen (file) + strlen (function) + strlen (obj_str));
g_sprintf (msg,
"%" GST_TIME_FORMAT " %" PID_FMT " %" PTR_FMT " %-7s %20s %s:%d:%s:%s %s",
GST_TIME_ARGS (elapsed), getpid (), g_thread_self (),
level_str, cat_str, file, line, function, obj_str, message);
g_free (obj_str);
check_print_handler (msg);
}
static void
gtk_recent_action_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkRecentAction *action = GTK_RECENT_ACTION (gobject);
GtkRecentActionPrivate *priv = action->priv;
switch (prop_id)
{
case PROP_SHOW_NUMBERS:
priv->show_numbers = g_value_get_boolean (value);
break;
case GTK_RECENT_CHOOSER_PROP_SHOW_PRIVATE:
priv->show_private = g_value_get_boolean (value);
break;
case GTK_RECENT_CHOOSER_PROP_SHOW_NOT_FOUND:
priv->show_not_found = g_value_get_boolean (value);
break;
case GTK_RECENT_CHOOSER_PROP_SHOW_TIPS:
priv->show_tips = g_value_get_boolean (value);
break;
case GTK_RECENT_CHOOSER_PROP_SHOW_ICONS:
priv->show_icons = g_value_get_boolean (value);
break;
case GTK_RECENT_CHOOSER_PROP_LIMIT:
priv->limit = g_value_get_int (value);
break;
case GTK_RECENT_CHOOSER_PROP_LOCAL_ONLY:
priv->local_only = g_value_get_boolean (value);
break;
case GTK_RECENT_CHOOSER_PROP_SORT_TYPE:
priv->sort_type = g_value_get_enum (value);
break;
case GTK_RECENT_CHOOSER_PROP_FILTER:
set_current_filter (action, g_value_get_object (value));
break;
case GTK_RECENT_CHOOSER_PROP_SELECT_MULTIPLE:
g_warning ("%s: Choosers of type `%s' do not support selecting multiple items.",
G_STRFUNC,
G_OBJECT_TYPE_NAME (gobject));
return;
case GTK_RECENT_CHOOSER_PROP_RECENT_MANAGER:
set_recent_manager (action, g_value_get_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
return;
}
}
static void
draw_flat_box (GtkStyle *style,
GdkWindow *window,
GtkStateType state,
GtkShadowType shadow,
GdkRectangle *area,
GtkWidget *widget,
const gchar *detail,
gint x,
gint y,
gint width,
gint height)
{
ThemeMatchData match_data;
g_return_if_fail (style != NULL);
g_return_if_fail (window != NULL);
/* FIXME: memory leak */
LOG ("widget=%s, primitive=flat_box, state=%s, shadow=%s, detail='%s', name='%s'",
G_OBJECT_TYPE_NAME (widget),
enum_value_to_string (gtk_state_type_get_type (), state),
enum_value_to_string (gtk_shadow_type_get_type (), shadow),
detail,
gtk_widget_get_name (widget));
/* Hack because Gtk doesn't give us the correct widget state */
if (widget && GTK_IS_ENTRY(widget))
{
if (!gtk_widget_is_sensitive (widget))
state = GTK_STATE_INSENSITIVE;
if (gtk_widget_has_focus (widget))
state = GTK_STATE_ACTIVE;
}
match_data.function = TOKEN_D_FLAT_BOX;
match_data.detail = (gchar *)detail;
match_data.flags = THEME_MATCH_SHADOW | THEME_MATCH_STATE;
match_data.shadow = shadow;
match_data.state = state;
/* Special handling for treeview cursor row */
if (GTK_IS_TREE_VIEW (widget))
maybe_check_cursor_position (GTK_TREE_VIEW (widget), x, y, width, height, &match_data);
if (!draw_simple_image (style, window, area, widget, &match_data, TRUE,
x, y, width, height))
GTK_STYLE_CLASS (sapwood_style_parent_class)->draw_flat_box (
style, window, state, shadow, area, widget, detail, x, y, width, height);
}
static char *
get_xml_class_name (GObject * object)
{
const char *class_name = G_OBJECT_TYPE_NAME (object);
if (strncmp (class_name, "Gst", 3) == 0) {
class_name += 3;
} else if (strncmp (class_name, "Gss", 3) == 0) {
class_name += 3;
} else if (strncmp (class_name, "Ew", 2) == 0) {
class_name += 2;
}
return g_ascii_strdown (class_name, -1);
}
//________________________________________________________________________________
void ComboBoxEntryData::setEntry( GtkWidget* widget )
{
if( _entry._widget == widget ) return;
assert( !_entry._widget );
#if OXYGEN_DEBUG
std::cerr << "Oxygen::ComboBoxEntryData::setEntry - " << widget << " (" << G_OBJECT_TYPE_NAME( widget ) << ")" << std::endl;
#endif
_entry._destroyId.connect( G_OBJECT(widget), "destroy", G_CALLBACK( childDestroyNotifyEvent ), this );
_entry._enterId.connect( G_OBJECT(widget), "enter-notify-event", (GCallback)enterNotifyEvent, this );
_entry._leaveId.connect( G_OBJECT(widget), "leave-notify-event", (GCallback)leaveNotifyEvent, this );
_entry._widget = widget;
}
gchar *
_gdk_win32_drawable_description (GdkDrawable *d)
{
gint width, height, depth;
gdk_drawable_get_size (d, &width, &height);
depth = gdk_drawable_get_depth (d);
return static_printf
("%s:%p:%dx%dx%d",
G_OBJECT_TYPE_NAME (d),
GDK_DRAWABLE_HANDLE (d),
width, height, depth);
}
/**
* ags_recall_resolve_dependencies:
* @recall an #AgsRecall
*
* A signal indicating that the inheriting object should resolve
* it's dependencies.
*/
void
ags_recall_resolve_dependencies(AgsRecall *recall)
{
g_return_if_fail(AGS_IS_RECALL(recall));
#ifdef AGS_DEBUG
g_message("resolving %s\0", G_OBJECT_TYPE_NAME(recall));
#endif
g_object_ref(G_OBJECT(recall));
g_signal_emit(G_OBJECT(recall),
recall_signals[RESOLVE_DEPENDENCIES], 0);
g_object_unref(G_OBJECT(recall));
}
static gboolean
start_source (GClueLocationSource *source)
{
source->priv->active_counter++;
if (source->priv->active_counter > 1) {
g_debug ("%s already active, not starting.",
G_OBJECT_TYPE_NAME (source));
return FALSE;
}
if (source->priv->compute_movement) {
source->priv->compass = gclue_compass_get_singleton ();
source->priv->heading_changed_id = g_signal_connect
(G_OBJECT (source->priv->compass),
"notify::heading",
G_CALLBACK (on_compass_heading_changed),
source);
}
g_object_notify (G_OBJECT (source), "active");
g_debug ("%s now active", G_OBJECT_TYPE_NAME (source));
return TRUE;
}
void
nagp_reader_read_start( const NAIFactoryProvider *provider, void *reader_data, const NAIFactoryObject *object, GSList **messages )
{
static const gchar *thisfn = "nagp_reader_read_start";
g_return_if_fail( NA_IS_IFACTORY_PROVIDER( provider ));
g_return_if_fail( NAGP_IS_GCONF_PROVIDER( provider ));
g_return_if_fail( NA_IS_IFACTORY_OBJECT( object ));
if( !NAGP_GCONF_PROVIDER( provider )->private->dispose_has_run ){
g_debug( "%s: provider=%p (%s), reader_data=%p, object=%p (%s), messages=%p",
thisfn,
( void * ) provider, G_OBJECT_TYPE_NAME( provider ),
( void * ) reader_data,
( void * ) object, G_OBJECT_TYPE_NAME( object ),
( void * ) messages );
if( NA_IS_OBJECT_PROFILE( object )){
read_start_profile_attach_profile( provider, NA_OBJECT_PROFILE( object ), ( ReaderData * ) reader_data, messages );
}
}
}
static gboolean
ar_card_theme_sliced_prerender_scalable (ArCardThemeSliced *theme)
{
ArCardThemePreimage *preimage_card_theme = (ArCardThemePreimage *) theme;
g_assert (theme->source == NULL);
_games_profile_start ("prerendering source pixbuf for %s card theme %s", G_OBJECT_TYPE_NAME (theme), ((ArCardTheme*)theme)->theme_info->display_name);
theme->source = games_preimage_render (preimage_card_theme->cards_preimage,
preimage_card_theme->card_size.width * 13,
preimage_card_theme->card_size.height * 5);
_games_profile_end ("prerendering source pixbuf for %s card theme %s", G_OBJECT_TYPE_NAME (theme), ((ArCardTheme*)theme)->theme_info->display_name);
if (!theme->source)
return FALSE;
theme->subsize.width = gdk_pixbuf_get_width (theme->source) / 13;
theme->subsize.height = gdk_pixbuf_get_height (theme->source) / 5;
return TRUE;
}
/*
* _clutter_meta_group_remove_meta:
* @group: a #ClutterMetaGroup
* @meta: a #ClutterActorMeta to remove
*
* Removes @meta from @group and releases the reference being held on it
*/
void
_clutter_meta_group_remove_meta (ClutterMetaGroup *group,
ClutterActorMeta *meta)
{
if (meta->priv->actor != group->actor)
{
g_warning ("The meta of type '%s' with name '%s' is not "
"attached to the actor '%s'",
G_OBJECT_TYPE_NAME (meta),
meta->priv->name != NULL
? meta->priv->name
: "<unknown>",
clutter_actor_get_name (group->actor) != NULL
? clutter_actor_get_name (group->actor)
: G_OBJECT_TYPE_NAME (group->actor));
return;
}
_clutter_actor_meta_set_actor (meta, NULL);
group->meta = g_list_remove (group->meta, meta);
g_object_unref (meta);
}
static void
_object_finalized (gpointer data,
GObject *obj)
{
G_LOCK (gobject_list);
if (display_filter (DISPLAY_FLAG_CREATE))
{
g_print (" -- Finalized object %p, %s\n", obj, G_OBJECT_TYPE_NAME (obj));
print_trace();
/* Only care about the object which were already existing during last
* check point. */
if (g_hash_table_lookup (gobject_list_state.added, obj) == NULL)
g_hash_table_insert (gobject_list_state.removed, obj,
g_strdup (G_OBJECT_TYPE_NAME (obj)));
}
g_hash_table_remove (gobject_list_state.objects, obj);
g_hash_table_remove (gobject_list_state.added, obj);
G_UNLOCK (gobject_list);
}
static void
chooser_update_preview_cb (GtkFileChooser *chooser,
gpointer user_data)
{
gchar *filename;
filename = gtk_file_chooser_get_preview_uri (chooser);
if (filename != NULL)
{
g_message ("%s::update-preview\n\tPreview Filename: `%s'\nDone.\n",
G_OBJECT_TYPE_NAME (chooser), filename);
g_free (filename);
}
}
void
unit_start_transient (Unit *unit,
GVariant *properties)
{
g_return_if_fail (unit != NULL);
if (!UNIT_GET_CLASS (unit)->start_transient)
{
g_warning ("%s does not implement StartTransient", G_OBJECT_TYPE_NAME (unit));
return;
}
return UNIT_GET_CLASS (unit)->start_transient (unit, properties);
}
/* Register a new drop target */
static void _xfdashboard_drop_action_register_target(XfdashboardDropAction *self)
{
g_return_if_fail(XFDASHBOARD_IS_DROP_ACTION(self));
/* Check if target is already registered */
if(g_slist_find(_xfdashboard_drop_action_targets, self))
{
g_warning(_("Target %s is already registered"), G_OBJECT_TYPE_NAME(self));
return;
}
/* Add object to list of dropable targets */
_xfdashboard_drop_action_targets=g_slist_prepend(_xfdashboard_drop_action_targets, self);
}
//________________________________________________________________________________
gboolean ScrolledWindowData::leaveNotifyEvent( GtkWidget* widget, GdkEventCrossing* event, gpointer data )
{
#if OXYGEN_DEBUG
std::cerr << "Oxygen::ScrolledWindowData::leaveNotifyEvent -"
<< " " << widget << " (" << G_OBJECT_TYPE_NAME( widget ) << ")"
<< std::endl;
#endif
if( !(event->state & (GDK_BUTTON1_MASK|GDK_BUTTON2_MASK) ) )
{ static_cast<ScrolledWindowData*>( data )->setHovered( widget, false ); }
return FALSE;
}
static int
get_sort_order_for_device (NMDevice *device)
{
const char *type;
int i;
type = G_OBJECT_TYPE_NAME (device);
for (i = 0; i < device_sort_order_len; i++) {
if (!strcmp (type, device_sort_order[i]))
return i;
}
return -1;
}
/*
* _clutter_meta_group_add_meta:
* @group: a #ClutterMetaGroup
* @meta: a #ClutterActorMeta to add
*
* Adds @meta to @group
*
* This function will remove the floating reference of @meta or, if the
* floating reference has already been sunk, add a reference to it
*/
void
_clutter_meta_group_add_meta (ClutterMetaGroup *group,
ClutterActorMeta *meta)
{
if (meta->priv->actor != NULL)
{
g_warning ("The meta of type '%s' with name '%s' is "
"already attached to actor '%s'",
G_OBJECT_TYPE_NAME (meta),
meta->priv->name != NULL
? meta->priv->name
: "<unknown>",
clutter_actor_get_name (meta->priv->actor) != NULL
? clutter_actor_get_name (meta->priv->actor)
: G_OBJECT_TYPE_NAME (meta->priv->actor));
return;
}
group->meta = g_list_append (group->meta, meta);
g_object_ref_sink (meta);
_clutter_actor_meta_set_actor (meta, group->actor);
}
static void
ibus_object_finalize (IBusObject *obj)
{
#ifdef DEBUG_MEMORY
guint count;
_count --;
count = GPOINTER_TO_UINT (g_hash_table_lookup (_count_table, (gpointer)G_OBJECT_TYPE (obj)));
g_hash_table_replace (_count_table, (gpointer)G_OBJECT_TYPE (obj), GUINT_TO_POINTER (--count));
g_debug ("Finalize %s, count = %d, all = %d", G_OBJECT_TYPE_NAME (obj), count, _count);
#endif
G_OBJECT_CLASS(ibus_object_parent_class)->finalize (G_OBJECT (obj));
}
static gboolean handle_timeout (gpointer data)
{
TimeoutData *td = data;
g_object_weak_unref (td->object, handle_object_finalized, data);
if (td->func)
td->func (td->object, td->data);
else
g_error ("object %p [%s] exceeded allowed lifetime [data=%p]",
G_OBJECT (td->object), G_OBJECT_TYPE_NAME (td->object), td->data);
if (td->destroy)
td->destroy(td->data);
g_free (td);
return FALSE;
}
