/*
* Add an Trigger to the gmainloop world...
*/
GTRIGSource*
G_main_add_TriggerHandler(int priority,
gboolean (*dispatch)(gpointer user_data),
gpointer userdata, GDestroyNotify notify)
{
GTRIGSource* trig_src = NULL;
GSource * source = g_source_new(&G_TRIG_SourceFuncs, sizeof(GTRIGSource));
gboolean failed = FALSE;
trig_src = (GTRIGSource*)source;
trig_src->magno = MAG_GTRIGSOURCE;
trig_src->maxdispatchdelayms = DEFAULT_MAXDELAY;
trig_src->maxdispatchms = DEFAULT_MAXDISPATCH;
trig_src->dispatch = dispatch;
trig_src->udata = userdata;
trig_src->dnotify = notify;
lc_store((trig_src->detecttime), zero_longclock);
trig_src->manual_trigger = FALSE;
g_source_set_priority(source, priority);
g_source_set_can_recurse(source, FALSE);
if(!failed) {
trig_src->gsourceid = g_source_attach(source, NULL);
trig_src->description = "trigger";
if (trig_src->gsourceid < 1) {
cl_log(LOG_ERR, "G_main_add_TriggerHandler: Could not attach new source (%d)",
trig_src->gsourceid);
failed = TRUE;
}
}
if(failed) {
cl_log(LOG_ERR, "G_main_add_TriggerHandler: Trigger handler NOT added");
g_source_remove(trig_src->gsourceid);
g_source_unref(source);
source = NULL;
trig_src = NULL;
} else {
if (debug_level > 1) {
cl_log(LOG_DEBUG, "G_main_add_TriggerHandler: Added signal manual handler");
}
}
return trig_src;
}
guint
kms_loop_timeout_add_full (KmsLoop * self, gint priority, guint interval,
GSourceFunc function, gpointer data, GDestroyNotify notify)
{
GSource *source;
guint id;
if (!KMS_IS_LOOP (self))
return 0;
source = g_timeout_source_new (interval);
id = kms_loop_attach (self, source, priority, function, data, notify);
g_source_unref (source);
return id;
}
void osync_thread_exit(OSyncThread *thread, int retval)
{
GSource *source = NULL;
osync_trace(TRACE_ENTRY, "%s(%p, %i)", __func__, thread, retval);
osync_assert(thread);
source = g_idle_source_new();
g_source_set_callback(source, osyncThreadStopCallback, thread, NULL);
g_source_attach(source, thread->context);
g_source_unref(source);
thread->thread = NULL;
g_thread_exit(GINT_TO_POINTER(retval));
osync_trace(TRACE_EXIT, "%s", __func__);
}
/* adds the given source to the default GMainContext and to the list of sources to remove at plugin
* unloading time */
static guint plugin_source_add(GeanyPlugin *plugin, GSource *source, GSourceFunc func, gpointer data)
{
guint id;
PluginSourceData *psd = g_slice_alloc(sizeof *psd);
psd->plugin = plugin->priv;
psd->function = func;
psd->user_data = data;
g_source_set_callback(source, on_plugin_source_callback, psd, on_plugin_source_destroy);
psd_register(psd, source);
id = g_source_attach(source, NULL);
g_source_unref(source);
return id;
}
static GSource *
g_socket_output_stream_pollable_create_source (GPollableOutputStream *pollable,
GCancellable *cancellable)
{
GSocketOutputStream *output_stream = G_SOCKET_OUTPUT_STREAM (pollable);
GSource *socket_source, *pollable_source;
pollable_source = g_pollable_source_new (G_OBJECT (output_stream));
socket_source = g_socket_create_source (output_stream->priv->socket,
G_IO_OUT, cancellable);
g_source_set_dummy_callback (socket_source);
g_source_add_child_source (pollable_source, socket_source);
g_source_unref (socket_source);
return pollable_source;
}
GSource* gattlib_watch_connection_full(GIOChannel* io, GIOCondition condition,
GIOFunc func, gpointer user_data, GDestroyNotify notify)
{
// Create a main loop source
GSource *source = g_io_create_watch (io, condition);
assert(source != NULL);
g_source_set_callback (source, (GSourceFunc)func, user_data, notify);
// Attaches it to the main loop context
guint id = g_source_attach(source, g_gattlib_thread.loop_context);
g_source_unref (source);
assert(id != 0);
return source;
}
static gpointer
gst_task_pool_schedule_func (gpointer data)
{
GstTaskPool *pool = GST_TASK_POOL (data);
GSource *source;
source = g_idle_source_new ();
g_source_set_callback (source, (GSourceFunc) main_loop_running_cb, pool,
NULL);
g_source_attach (source, pool->priv->schedule_context);
g_source_unref (source);
g_main_loop_run (pool->priv->schedule_loop);
return NULL;
}
void
frida_shutdown (void)
{
GSource * source;
g_assert (main_loop != NULL);
source = g_idle_source_new ();
g_source_set_priority (source, G_PRIORITY_LOW);
g_source_set_callback (source, stop_main_loop, NULL, NULL);
g_source_attach (source, main_context);
g_source_unref (source);
g_thread_join (main_thread);
main_thread = NULL;
}
static void
_libnm_glib_schedule_single_callback (libnm_glib_ctx *ctx,
libnm_glib_callback *callback)
{
GSource *source;
g_return_if_fail (ctx != NULL);
g_return_if_fail (callback != NULL);
callback->libnm_glib_ctx = ctx;
source = g_idle_source_new ();
g_source_set_callback (source, _libnm_glib_callback_helper, callback, NULL);
g_source_attach (source, callback->gmain_ctx);
g_source_unref (source);
}
static CoglBool
cogl_gst_video_sink_stop (GstBaseSink *base_sink)
{
CoglGstVideoSink *sink = COGL_GST_VIDEO_SINK (base_sink);
CoglGstVideoSinkPrivate *priv = sink->priv;
if (priv->source)
{
GSource *source = (GSource *) priv->source;
g_source_destroy (source);
g_source_unref (source);
priv->source = NULL;
}
return TRUE;
}
static gboolean
_upnp_discovery_timeout (gpointer user_data)
{
FsRawUdpComponent *self = user_data;
GST_DEBUG ("UPnP timed out on component %d", self->priv->component);
FS_RAWUDP_COMPONENT_LOCK (self);
g_source_unref (self->priv->upnp_discovery_timeout_src);
self->priv->upnp_discovery_timeout_src = NULL;
FS_RAWUDP_COMPONENT_UNLOCK (self);
fs_rawudp_component_maybe_emit_local_candidates (self);
return FALSE;
}
static gpointer thread_func(gpointer user_data) {
int n_thread = GPOINTER_TO_INT(user_data);
int n;
GSource *source;
g_print("Countdown Thread gestartet\n");
for(;;) {
source = g_idle_source_new();
g_source_set_callback(source, refresh, NULL, NULL);
g_source_attach(source, context);
g_source_unref(source);
sleep(1); //TODO: Decrease
}
g_print("Fehler: Countdown Thread beendet\n");
return NULL;
}
static void
handle_current_async (GstDiscoverer * dc)
{
GSource *source;
static GSourceCallbackFuncs cb_funcs = {
_void_g_object_ref,
g_object_unref,
get_async_cb,
};
/* Attach a timeout to the main context */
source = g_timeout_source_new (dc->priv->timeout / GST_MSECOND);
g_source_set_callback_indirect (source, g_object_ref (dc), &cb_funcs);
dc->priv->timeoutid = g_source_attach (source, dc->priv->ctx);
g_source_unref (source);
}
static gboolean pty_chr_timer(gpointer opaque)
{
struct Chardev *chr = CHARDEV(opaque);
PtyChardev *s = PTY_CHARDEV(opaque);
qemu_mutex_lock(&chr->chr_write_lock);
s->timer_src = NULL;
g_source_unref(s->open_source);
s->open_source = NULL;
if (!s->connected) {
/* Next poll ... */
pty_chr_update_read_handler_locked(chr);
}
qemu_mutex_unlock(&chr->chr_write_lock);
return FALSE;
}
static gpointer iothread_g_main_context_init(gpointer opaque)
{
AioContext *ctx;
IOThread *iothread = opaque;
GSource *source;
iothread->worker_context = g_main_context_new();
ctx = iothread_get_aio_context(iothread);
source = aio_get_g_source(ctx);
g_source_attach(source, iothread->worker_context);
g_source_unref(source);
aio_notify(iothread->ctx);
return NULL;
}
gpointer wait_and_notify (gpointer user_data)
{
GEventSource *evsource = user_data;
int i;
for (i = 0; i < 3; i++) {
printf (".");
fflush (stdout);
g_usleep (1000000);
}
printf ("\n");
fflush (stdout);
g_event_source_notify (evsource);
g_source_unref ((GSource *) evsource);
return NULL;
}
void
rig_rpc_client_disconnect (RigRPCClient *rpc_client)
{
if (!rpc_client->pb_rpc_client)
return;
g_source_remove (rpc_client->source_id);
rpc_client->source_id = 0;
g_source_unref (rpc_client->protobuf_source);
rpc_client->protobuf_source = NULL;
#warning "TODO: need explicit rig_pb_rpc_client_disconnect() api"
rut_refable_unref (rpc_client->pb_rpc_client);
rpc_client->pb_rpc_client = NULL;
}
static void
g_network_monitor_base_finalize (GObject *object)
{
GNetworkMonitorBase *monitor = G_NETWORK_MONITOR_BASE (object);
g_ptr_array_free (monitor->priv->networks, TRUE);
if (monitor->priv->network_changed_source)
{
g_source_destroy (monitor->priv->network_changed_source);
g_source_unref (monitor->priv->network_changed_source);
}
if (monitor->priv->context)
g_main_context_unref (monitor->priv->context);
G_OBJECT_CLASS (g_network_monitor_base_parent_class)->finalize (object);
}
static GSource *
g_unix_input_stream_pollable_create_source (GPollableInputStream *stream,
GCancellable *cancellable)
{
GUnixInputStream *unix_stream = G_UNIX_INPUT_STREAM (stream);
GSource *inner_source, *pollable_source;
pollable_source = g_pollable_source_new (G_OBJECT (stream));
inner_source = _g_fd_source_new (unix_stream->priv->fd, G_IO_IN, cancellable);
g_source_set_dummy_callback (inner_source);
g_source_add_child_source (pollable_source, inner_source);
g_source_unref (inner_source);
return pollable_source;
}
static gboolean
update_clock (gpointer data)
{
GnomeWallClock *self = data;
GDesktopClockFormat clock_format;
gboolean show_full_date;
gboolean show_weekday;
gboolean show_seconds;
GSource *source;
GDateTime *now;
GDateTime *expiry;
clock_format = g_settings_get_enum (self->priv->desktop_settings, "clock-format");
show_weekday = !self->priv->time_only && g_settings_get_boolean (self->priv->desktop_settings, "clock-show-weekday");
show_full_date = !self->priv->time_only && g_settings_get_boolean (self->priv->desktop_settings, "clock-show-date");
show_seconds = g_settings_get_boolean (self->priv->desktop_settings, "clock-show-seconds");
now = g_date_time_new_now (self->priv->timezone);
if (show_seconds)
expiry = g_date_time_add_seconds (now, 1);
else
expiry = g_date_time_add_seconds (now, 60 - g_date_time_get_second (now));
if (self->priv->clock_update_id)
g_source_remove (self->priv->clock_update_id);
source = _gnome_datetime_source_new (now, expiry, TRUE);
g_source_set_priority (source, G_PRIORITY_HIGH);
g_source_set_callback (source, update_clock, self, NULL);
self->priv->clock_update_id = g_source_attach (source, NULL);
g_source_unref (source);
g_free (self->priv->clock_string);
self->priv->clock_string = gnome_wall_clock_string_for_datetime (self,
now,
clock_format,
show_weekday,
show_full_date,
show_seconds);
g_date_time_unref (now);
g_date_time_unref (expiry);
g_object_notify ((GObject*)self, "clock");
return FALSE;
}
/*
* Add an IPC_WaitConnection to the gmainloop world...
*/
GWCSource*
G_main_add_IPC_WaitConnection(int priority
, IPC_WaitConnection* wch
, IPC_Auth* auth_info
, gboolean can_recurse
, gboolean (*dispatch)(IPC_Channel* wch
, gpointer user_data)
, gpointer userdata
, GDestroyNotify notify)
{
GWCSource* wcp;
GSource * source = g_source_new(&G_WC_SourceFuncs,
sizeof(GWCSource));
wcp = (GWCSource*)source;
wcp->magno = MAG_GWCSOURCE;
wcp->maxdispatchdelayms = DEFAULT_MAXDELAY;
wcp->maxdispatchms = DEFAULT_MAXDISPATCH;
lc_store((wcp->detecttime), zero_longclock);
wcp->udata = userdata;
wcp->gpfd.fd = wch->ops->get_select_fd(wch);
wcp->gpfd.events = DEF_EVENTS;
wcp->gpfd.revents = 0;
wcp->wch = wch;
wcp->dnotify = notify;
wcp->auth_info = auth_info;
wcp->dispatch = dispatch;
g_source_add_poll(source, &wcp->gpfd);
g_source_set_priority(source, priority);
g_source_set_can_recurse(source, can_recurse);
wcp->gsourceid = g_source_attach(source, NULL);
wcp->description = "IPC wait for connection";
if (wcp->gsourceid == 0) {
g_source_remove_poll(source, &wcp->gpfd);
g_source_unref(source);
source = NULL;
wcp = NULL;
}
return wcp;
}
WaylandDisplay::~WaylandDisplay()
{
if (m_eventSource)
g_source_unref(m_eventSource);
m_eventSource = nullptr;
if (m_interfaces.compositor)
wl_compositor_destroy(m_interfaces.compositor);
if (m_interfaces.data_device_manager)
wl_data_device_manager_destroy(m_interfaces.data_device_manager);
if (m_interfaces.drm)
wl_drm_destroy(m_interfaces.drm);
if (m_interfaces.seat)
wl_seat_destroy(m_interfaces.seat);
if (m_interfaces.xdg)
xdg_shell_destroy(m_interfaces.xdg);
if (m_interfaces.ivi_application)
ivi_application_destroy(m_interfaces.ivi_application);
m_interfaces = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
if (m_registry)
wl_registry_destroy(m_registry);
m_registry = nullptr;
if (m_display)
wl_display_disconnect(m_display);
m_display = nullptr;
if (m_seatData.pointer.object)
wl_pointer_destroy(m_seatData.pointer.object);
if (m_seatData.keyboard.object)
wl_keyboard_destroy(m_seatData.keyboard.object);
if (m_seatData.touch.object)
wl_touch_destroy(m_seatData.touch.object);
if (m_seatData.xkb.context)
xkb_context_unref(m_seatData.xkb.context);
if (m_seatData.xkb.keymap)
xkb_keymap_unref(m_seatData.xkb.keymap);
if (m_seatData.xkb.state)
xkb_state_unref(m_seatData.xkb.state);
if (m_seatData.xkb.composeTable)
xkb_compose_table_unref(m_seatData.xkb.composeTable);
if (m_seatData.xkb.composeState)
xkb_compose_state_unref(m_seatData.xkb.composeState);
if (m_seatData.repeatData.eventSource)
g_source_remove(m_seatData.repeatData.eventSource);
m_seatData = SeatData{ };
}
SR_PRIV int usb_source_add(struct sr_session *session, struct sr_context *ctx,
int timeout, sr_receive_data_callback cb, void *cb_data)
{
GSource *source;
int ret;
source = usb_source_new(session, ctx->libusb_ctx, timeout);
if (!source)
return SR_ERR;
g_source_set_callback(source, (GSourceFunc)cb, cb_data, NULL);
ret = sr_session_source_add_internal(session, ctx->libusb_ctx, source);
g_source_unref(source);
return ret;
}
void
_clutter_backend_x11_events_uninit (ClutterBackend *backend)
{
ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend);
if (backend_x11->event_source)
{
CLUTTER_NOTE (EVENT, "Destroying the event source");
event_sources = g_list_remove (event_sources,
backend_x11->event_source);
g_source_destroy (backend_x11->event_source);
g_source_unref (backend_x11->event_source);
backend_x11->event_source = NULL;
}
}
int main(int argc, char *argv[])
{
GMainLoop *loop;
GSource *source;
loop = g_main_loop_new(NULL, FALSE);
source = g_timeout_source_new (2000);/* 2 seconds */
g_source_set_callback (source, quit_loop, loop, NULL);
g_source_attach (source, g_main_loop_get_context (loop));
g_source_unref (source);
g_main_loop_run (loop);
g_main_loop_unref (loop);
return 0;
}
static gboolean
log_reader_deinit(LogPipe *s)
{
LogReader *self = (LogReader *) s;
if (self->source)
{
g_source_destroy(&self->source->super);
g_source_unref(&self->source->super);
self->source = NULL;
}
if (!log_source_deinit(s))
return FALSE;
return TRUE;
}
static void
meta_clutter_init (void)
{
clutter_x11_set_display (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
clutter_x11_disable_event_retrieval ();
if (CLUTTER_INIT_SUCCESS == clutter_init (NULL, NULL))
{
GSource *source = g_source_new (&event_funcs, sizeof (GSource));
g_source_attach (source, NULL);
g_source_unref (source);
}
else
{
meta_fatal ("Unable to initialize Clutter.\n");
}
}
/**
* metadata_thread_main:
*
* Called from the metadatascan worker thread. If we're missing an
* object from one of them, we queue a request to the main thread to
* fetch it. When it's fetched, we get passed the object back and
* scan it.
*/
static gpointer
metadata_thread_main (gpointer user_data)
{
OtPullData *pull_data = user_data;
GSource *src;
pull_data->metadata_thread_context = g_main_context_new ();
pull_data->metadata_thread_loop = g_main_loop_new (pull_data->metadata_thread_context, TRUE);
src = ot_waitable_queue_create_source (pull_data->metadata_objects_to_scan);
g_source_set_callback (src, (GSourceFunc)on_metadata_objects_to_scan_ready, pull_data, NULL);
g_source_attach (src, pull_data->metadata_thread_context);
g_source_unref (src);
g_main_loop_run (pull_data->metadata_thread_loop);
return NULL;
}
void
BlockService::Shutdown()
{
TRACE_CALL();
if (m_initialized) {
g_source_destroy(m_shutdownSrc);
g_source_unref(m_shutdownSrc);
m_shutdownSrc = 0;
if (DnD_BlockIsReady(&m_blockCtrl)) {
DnD_UninitializeBlocking(&m_blockCtrl);
}
m_initialized = false;
}
}
static void
schedule_contexts_creation (GUPnPSimpleContextManager *manager)
{
manager->priv->idle_context_creation_src = NULL;
/* Create contexts in mainloop so that is happens after user has hooked
* to the "context-available" signal.
*/
manager->priv->idle_context_creation_src = g_idle_source_new ();
g_source_attach (manager->priv->idle_context_creation_src,
g_main_context_get_thread_default ());
g_source_set_callback (manager->priv->idle_context_creation_src,
create_contexts,
manager,
NULL);
g_source_unref (manager->priv->idle_context_creation_src);
}