int qemu_init_main_loop(Error **errp)
{
int ret;
GSource *src;
Error *local_error = NULL;
init_clocks(qemu_timer_notify_cb);
ret = qemu_signal_init(errp);
if (ret) {
return ret;
}
qemu_aio_context = aio_context_new(&local_error);
if (!qemu_aio_context) {
error_propagate(errp, local_error);
return -EMFILE;
}
qemu_notify_bh = qemu_bh_new(notify_event_cb, NULL);
gpollfds = g_array_new(FALSE, FALSE, sizeof(GPollFD));
src = aio_get_g_source(qemu_aio_context);
g_source_set_name(src, "aio-context");
g_source_attach(src, NULL);
g_source_unref(src);
src = iohandler_get_g_source();
g_source_set_name(src, "io-handler");
g_source_attach(src, NULL);
g_source_unref(src);
return 0;
}
/**
* pk_backend_job_call_vfunc:
*
* This method can be called in any thread, and the vfunc is guaranteed
* to be called idle in the main thread.
**/
static void
pk_backend_job_call_vfunc (PkBackendJob *job,
PkBackendJobSignal signal_kind,
gpointer object,
GDestroyNotify destroy_func)
{
PkBackendJobVFuncHelper *helper;
PkBackendJobVFuncItem *item;
guint priority = G_PRIORITY_DEFAULT_IDLE;
_cleanup_source_unref_ GSource *source = NULL;
/* call transaction vfunc if not disabled and set */
item = &job->priv->vfunc_items[signal_kind];
if (!item->enabled || item->vfunc == NULL)
return;
/* order this last if others are still pending */
if (signal_kind == PK_BACKEND_SIGNAL_FINISHED)
priority = G_PRIORITY_LOW;
/* emit idle */
helper = g_new0 (PkBackendJobVFuncHelper, 1);
helper->job = g_object_ref (job);
helper->signal_kind = signal_kind;
helper->object = object;
helper->destroy_func = destroy_func;
source = g_idle_source_new ();
g_source_set_priority (source, priority);
g_source_set_callback (source,
pk_backend_job_call_vfunc_idle_cb,
helper,
(GDestroyNotify) pk_backend_job_vfunc_event_free);
g_source_set_name (source, "[PkBackendJob] idle_event_cb");
g_source_attach (source, NULL);
}
/* Use g_source_unref() when done with the returned pointer. */
GSource *
e_canvas_item_show_area_delayed_ex (GnomeCanvasItem *item,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gint delay)
{
GSource *source;
DoubsAndCanvas *dac;
g_return_val_if_fail (item != NULL, NULL);
g_return_val_if_fail (GNOME_IS_CANVAS_ITEM (item), NULL);
gnome_canvas_item_i2w (item, &x1, &y1);
gnome_canvas_item_i2w (item, &x2, &y2);
dac = g_new (DoubsAndCanvas, 1);
dac->x1 = x1;
dac->y1 = y1;
dac->x2 = x2;
dac->y2 = y2;
dac->canvas = g_object_ref (item->canvas);
source = g_timeout_source_new (delay);
g_source_set_callback (source, show_area_timeout, dac, doubs_and_canvas_free);
g_source_set_name (source, G_STRFUNC);
g_source_attach (source, NULL);
return source;
}
static void string_job_init()
{
darktable.lua_state.string_job_queue = g_async_queue_new();
GSource *source = g_source_new (&string_job_funcs, sizeof (GSource));
g_source_set_name (source, "lua_string_job_source");
g_source_attach(source,darktable.lua_state.context);
}
GSource *
_clutter_x11_event_source_new (ClutterBackendX11 *backend_x11)
{
ClutterEventSource *event_source;
int connection_number;
GSource *source;
gchar *name;
connection_number = ConnectionNumber (backend_x11->xdpy);
CLUTTER_NOTE (EVENT, "Connection number: %d", connection_number);
source = g_source_new (&event_funcs, sizeof (ClutterEventSource));
event_source = (ClutterEventSource *) source;
name = g_strdup_printf ("Clutter X11 Event (connection: %d)",
connection_number);
g_source_set_name (source, name);
g_free (name);
event_source->backend = backend_x11;
event_source->event_poll_fd.fd = connection_number;
event_source->event_poll_fd.events = G_IO_IN;
g_source_add_poll (source, &event_source->event_poll_fd);
g_source_set_can_recurse (source, TRUE);
return source;
}
/**
* g_cancellable_source_new: (skip)
* @cancellable: (allow-none): a #GCancellable, or %NULL
*
* Creates a source that triggers if @cancellable is cancelled and
* calls its callback of type #GCancellableSourceFunc. This is
* primarily useful for attaching to another (non-cancellable) source
* with g_source_add_child_source() to add cancellability to it.
*
* For convenience, you can call this with a %NULL #GCancellable,
* in which case the source will never trigger.
*
* Return value: (transfer full): the new #GSource.
*
* Since: 2.28
*/
GSource *
g_cancellable_source_new (GCancellable *cancellable)
{
GSource *source;
GCancellableSource *cancellable_source;
source = g_source_new (&cancellable_source_funcs, sizeof (GCancellableSource));
g_source_set_name (source, "GCancellable");
cancellable_source = (GCancellableSource *)source;
if (cancellable)
{
cancellable_source->cancellable = g_object_ref (cancellable);
/* We intentionally don't use g_cancellable_connect() here,
* because we don't want the "at most once" behavior.
*/
cancellable_source->cancelled_handler =
g_signal_connect (cancellable, "cancelled",
G_CALLBACK (cancellable_source_cancelled),
source);
if (g_cancellable_is_cancelled (cancellable))
g_source_set_ready_time (source, 0);
}
return source;
}
std::unique_ptr<PlatformDisplayWayland> PlatformDisplayWayland::create()
{
struct wl_display* wlDisplay = wl_display_connect(nullptr);
if (!wlDisplay) {
WTFLogAlways("PlatformDisplayWayland initialization: failed to connect to the Wayland server socket. Check your WAYLAND_DISPLAY or WAYLAND_SOCKET environment variables.");
return nullptr;
}
std::unique_ptr<PlatformDisplayWayland> display(new PlatformDisplayWayland(wlDisplay));
if (!display->isInitialized()) {
WTFLogAlways("PlatformDisplayWayland initialization: failed to complete the initialization of the display.");
return nullptr;
}
GSource* baseSource = g_source_new(&EventSource::sourceFuncs, sizeof(EventSource));
auto* source = reinterpret_cast<EventSource*>(baseSource);
source->display = display->m_display;
source->pfd.fd = wl_display_get_fd(display->m_display);
source->pfd.events = G_IO_IN | G_IO_ERR | G_IO_HUP;
source->pfd.revents = 0;
g_source_add_poll(baseSource, &source->pfd);
g_source_set_name(baseSource, "[WebKit] WaylandDisplay");
g_source_set_priority(baseSource, G_PRIORITY_HIGH + 30);
g_source_set_can_recurse(baseSource, TRUE);
g_source_attach(baseSource, g_main_context_get_thread_default());
return display;
}
GSource *io_add_watch_poll(Chardev *chr,
QIOChannel *ioc,
IOCanReadHandler *fd_can_read,
QIOChannelFunc fd_read,
gpointer user_data,
GMainContext *context)
{
IOWatchPoll *iwp;
char *name;
iwp = (IOWatchPoll *) g_source_new(&io_watch_poll_funcs,
sizeof(IOWatchPoll));
iwp->fd_can_read = fd_can_read;
iwp->opaque = user_data;
iwp->ioc = ioc;
iwp->fd_read = (GSourceFunc) fd_read;
iwp->src = NULL;
name = g_strdup_printf("chardev-iowatch-%s", chr->label);
g_source_set_name((GSource *)iwp, name);
g_free(name);
g_source_attach(&iwp->parent, context);
g_source_unref(&iwp->parent);
return (GSource *)iwp;
}
GSource *
g_tls_connection_base_create_source (GTlsConnectionBase *tls,
GIOCondition condition,
GCancellable *cancellable)
{
GSource *source, *cancellable_source;
GTlsConnectionBaseSource *tls_source;
source = g_source_new (&tls_source_funcs, sizeof (GTlsConnectionBaseSource));
g_source_set_name (source, "GTlsConnectionBaseSource");
tls_source = (GTlsConnectionBaseSource *)source;
tls_source->tls = g_object_ref (tls);
tls_source->condition = condition;
if (condition & G_IO_IN)
tls_source->stream = G_OBJECT (tls->tls_istream);
else if (condition & G_IO_OUT)
tls_source->stream = G_OBJECT (tls->tls_ostream);
tls_source->op_waiting = (gboolean) -1;
tls_source->io_waiting = (gboolean) -1;
tls_source_sync (tls_source);
if (cancellable)
{
cancellable_source = g_cancellable_source_new (cancellable);
g_source_set_dummy_callback (cancellable_source);
g_source_add_child_source (source, cancellable_source);
g_source_unref (cancellable_source);
}
return source;
}
/**
* message_queue_source_new:
* @queue: the queue to check
* @destroy_message: (nullable): function to free a message, or %NULL
* @cancellable: (nullable): a #GCancellable, or %NULL
*
* Create a new #MessageQueueSource, a type of #GSource which dispatches for
* each message queued to it.
*
* If a callback function of type #MessageQueueSourceFunc is connected to the
* returned #GSource using g_source_set_callback(), it will be invoked for each
* message, with the message passed as its first argument. It is responsible for
* freeing the message. If no callback is set, messages are automatically freed
* as they are queued.
*
* Returns: (transfer full): a new #MessageQueueSource
*/
GSource *
message_queue_source_new (GAsyncQueue *queue,
GDestroyNotify destroy_message,
GCancellable *cancellable)
{
GSource *source; /* alias of @message_queue_source */
MessageQueueSource *message_queue_source; /* alias of @source */
g_return_val_if_fail (queue != NULL, NULL);
g_return_val_if_fail (cancellable == NULL ||
G_IS_CANCELLABLE (cancellable), NULL);
source = g_source_new (&message_queue_source_funcs,
sizeof (MessageQueueSource));
message_queue_source = (MessageQueueSource *) source;
/* The caller can overwrite this name with something more useful later. */
g_source_set_name (source, "MessageQueueSource");
message_queue_source->queue = g_async_queue_ref (queue);
message_queue_source->destroy_message = destroy_message;
/* Add a cancellable source. */
if (cancellable != NULL)
{
GSource *cancellable_source;
cancellable_source = g_cancellable_source_new (cancellable);
g_source_set_dummy_callback (cancellable_source);
g_source_add_child_source (source, cancellable_source);
g_source_unref (cancellable_source);
}
return source;
}
/**
* nice_component_source_new:
* @agent: a #NiceAgent
* @stream_id: The stream's id
* @component_id: The component's number
* @pollable_stream: a #GPollableInputStream or #GPollableOutputStream to pass
* to dispatched callbacks
* @cancellable: (allow-none): a #GCancellable, or %NULL
*
* Create a new #ComponentSource, a type of #GSource which proxies poll events
* from all sockets in the given @component.
*
* A callback function of type #GPollableSourceFunc must be connected to the
* returned #GSource using g_source_set_callback(). @pollable_stream is passed
* to all callbacks dispatched from the #GSource, and a reference is held on it
* by the #GSource.
*
* The #GSource will automatically update to poll sockets as they’re added to
* the @component (e.g. during peer discovery).
*
* Returns: (transfer full): a new #ComponentSource; unref with g_source_unref()
*/
GSource *
nice_component_input_source_new (NiceAgent *agent, guint stream_id,
guint component_id, GPollableInputStream *pollable_istream,
GCancellable *cancellable)
{
ComponentSource *component_source;
g_assert (G_IS_POLLABLE_INPUT_STREAM (pollable_istream));
component_source =
(ComponentSource *)
g_source_new (&component_source_funcs, sizeof (ComponentSource));
g_source_set_name ((GSource *) component_source, "ComponentSource");
component_source->component_socket_sources_age = 0;
component_source->pollable_stream = g_object_ref (pollable_istream);
g_weak_ref_init (&component_source->agent_ref, agent);
component_source->stream_id = stream_id;
component_source->component_id = component_id;
/* Add a cancellable source. */
if (cancellable != NULL) {
GSource *cancellable_source;
cancellable_source = g_cancellable_source_new (cancellable);
g_source_set_dummy_callback (cancellable_source);
g_source_add_child_source ((GSource *) component_source,
cancellable_source);
g_source_unref (cancellable_source);
}
return (GSource *) component_source;
}
void
_clutter_backend_x11_events_init (ClutterBackend *backend)
{
ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend);
GSource *source;
ClutterEventSource *event_source;
int connection_number;
gchar *name;
connection_number = ConnectionNumber (backend_x11->xdpy);
CLUTTER_NOTE (EVENT, "Connection number: %d", connection_number);
source = backend_x11->event_source = clutter_event_source_new (backend);
event_source = (ClutterEventSource *) source;
g_source_set_priority (source, CLUTTER_PRIORITY_EVENTS);
name = g_strdup_printf ("Clutter X11 Event (connection: %d)",
connection_number);
g_source_set_name (source, name);
g_free (name);
event_source->event_poll_fd.fd = connection_number;
event_source->event_poll_fd.events = G_IO_IN;
event_sources = g_list_prepend (event_sources, event_source);
g_source_add_poll (source, &event_source->event_poll_fd);
g_source_set_can_recurse (source, TRUE);
g_source_attach (source, NULL);
}
WaylandDisplay::WaylandDisplay()
{
m_display = wl_display_connect(nullptr);
m_registry = wl_display_get_registry(m_display);
wl_registry_add_listener(m_registry, &g_registryListener, &m_interfaces);
wl_display_roundtrip(m_display);
m_eventSource = g_source_new(&EventSource::sourceFuncs, sizeof(EventSource));
auto* source = reinterpret_cast<EventSource*>(m_eventSource);
source->display = m_display;
source->pfd.fd = wl_display_get_fd(m_display);
source->pfd.events = G_IO_IN | G_IO_ERR | G_IO_HUP;
source->pfd.revents = 0;
g_source_add_poll(m_eventSource, &source->pfd);
g_source_set_name(m_eventSource, "[WPE] WaylandDisplay");
g_source_set_priority(m_eventSource, G_PRIORITY_HIGH + 30);
g_source_set_can_recurse(m_eventSource, TRUE);
g_source_attach(m_eventSource, g_main_context_get_thread_default());
if (m_interfaces.xdg) {
xdg_shell_add_listener(m_interfaces.xdg, &g_xdgShellListener, nullptr);
xdg_shell_use_unstable_version(m_interfaces.xdg, 5);
}
wl_seat_add_listener(m_interfaces.seat, &g_seatListener, &m_seatData);
m_seatData.xkb.context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
m_seatData.xkb.composeTable = xkb_compose_table_new_from_locale(m_seatData.xkb.context, setlocale(LC_CTYPE, nullptr), XKB_COMPOSE_COMPILE_NO_FLAGS);
if (m_seatData.xkb.composeTable)
m_seatData.xkb.composeState = xkb_compose_state_new(m_seatData.xkb.composeTable, XKB_COMPOSE_STATE_NO_FLAGS);
}
WaylandDisplay::WaylandDisplay()
{
m_display = wl_display_connect(nullptr);
m_registry = wl_display_get_registry(m_display);
wl_registry_add_listener(m_registry, &g_registryListener, &m_interfaces);
wl_display_roundtrip(m_display);
m_eventSource = g_source_new(&EventSource::sourceFuncs, sizeof(EventSource));
auto* source = reinterpret_cast<EventSource*>(m_eventSource);
source->display = m_display;
source->pfd.fd = wl_display_get_fd(m_display);
source->pfd.events = G_IO_IN | G_IO_ERR | G_IO_HUP;
source->pfd.revents = 0;
g_source_add_poll(m_eventSource, &source->pfd);
g_source_set_name(m_eventSource, "[WPE] WaylandDisplay");
g_source_set_priority(m_eventSource, G_PRIORITY_HIGH + 30);
g_source_set_can_recurse(m_eventSource, TRUE);
g_source_attach(m_eventSource, g_main_context_get_thread_default());
if (m_interfaces.xdg) {
xdg_shell_add_listener(m_interfaces.xdg, &g_xdgShellListener, nullptr);
xdg_shell_use_unstable_version(m_interfaces.xdg, 5);
}
}
GSource *
gdk_x11_event_source_new (GdkDisplay *display)
{
GSource *source;
GdkEventSource *event_source;
GdkX11Display *display_x11;
int connection_number;
char *name;
source = g_source_new (&event_funcs, sizeof (GdkEventSource));
name = g_strdup_printf ("GDK X11 Event source (%s)",
gdk_display_get_name (display));
g_source_set_name (source, name);
g_free (name);
event_source = (GdkEventSource *) source;
event_source->display = display;
display_x11 = GDK_X11_DISPLAY (display);
connection_number = ConnectionNumber (display_x11->xdisplay);
event_source->event_poll_fd.fd = connection_number;
event_source->event_poll_fd.events = G_IO_IN;
g_source_add_poll (source, &event_source->event_poll_fd);
g_source_set_priority (source, GDK_PRIORITY_EVENTS);
g_source_set_can_recurse (source, TRUE);
g_source_attach (source, NULL);
event_sources = g_list_prepend (event_sources, source);
return source;
}
/**
* gb_frame_source_add:
* @frames_per_sec: (in): Target frames per second.
* @callback: (in) (scope notified): A #GSourceFunc to execute.
* @user_data: (in): User data for @callback.
*
* Creates a new frame source that will execute when the timeout interval
* for the source has elapsed. The timing will try to synchronize based
* on the end time of the animation.
*
* Returns: A source id that can be removed with g_source_remove().
*/
guint
gb_frame_source_add (guint frames_per_sec,
GSourceFunc callback,
gpointer user_data)
{
GbFrameSource *fsource;
GSource *source;
guint ret;
g_return_val_if_fail(frames_per_sec > 0, 0);
g_return_val_if_fail(frames_per_sec < 120, 0);
source = g_source_new(&source_funcs, sizeof(GbFrameSource));
fsource = (GbFrameSource *)source;
fsource->fps = frames_per_sec;
fsource->frame_count = 0;
fsource->start_time = g_get_monotonic_time() / 1000;
g_source_set_callback(source, callback, user_data, NULL);
g_source_set_name(source, "GbFrameSource");
ret = g_source_attach(source, NULL);
g_source_unref(source);
return ret;
}
ViewBackend::ViewBackend(struct wpe_view_backend* backend)
: backend(backend)
{
ipcHost.initialize(*this);
bcm_host_init();
displayHandle = vc_dispmanx_display_open(0);
graphics_get_display_size(DISPMANX_ID_HDMI, &width, &height);
updateFd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
if (updateFd == -1) {
fprintf(stderr, "ViewBackend: failed to create the update eventfd\n");
return;
}
updateSource = g_source_new(&UpdateSource::sourceFuncs, sizeof(UpdateSource));
auto& source = *reinterpret_cast<UpdateSource*>(updateSource);
source.backend = this;
source.pfd.fd = updateFd;
source.pfd.events = G_IO_IN | G_IO_ERR | G_IO_HUP;
source.pfd.revents = 0;
g_source_add_poll(updateSource, &source.pfd);
g_source_set_name(updateSource, "[WPE] BCMRPi update");
g_source_set_priority(updateSource, G_PRIORITY_HIGH + 30);
g_source_set_can_recurse(updateSource, TRUE);
g_source_attach(updateSource, g_main_context_get_thread_default());
}
static void
initialize_io (CockpitStream *self)
{
GInputStream *is;
GOutputStream *os;
g_return_if_fail (self->priv->in_source == NULL);
is = g_io_stream_get_input_stream (self->priv->io);
os = g_io_stream_get_output_stream (self->priv->io);
if (!G_IS_POLLABLE_INPUT_STREAM (is) ||
!g_pollable_input_stream_can_poll (G_POLLABLE_INPUT_STREAM (is)) ||
!G_IS_POLLABLE_OUTPUT_STREAM (os) ||
!g_pollable_output_stream_can_poll (G_POLLABLE_OUTPUT_STREAM (os)))
{
g_warning ("%s: stream is not pollable", self->priv->name);
close_immediately (self, "internal-error");
return;
}
if (self->priv->connecting)
{
g_object_unref (self->priv->connecting);
self->priv->connecting = NULL;
}
self->priv->in_source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (is), NULL);
g_source_set_name (self->priv->in_source, "stream-input");
g_source_set_callback (self->priv->in_source, (GSourceFunc)dispatch_input, self, NULL);
g_source_attach (self->priv->in_source, self->priv->context);
start_output (self);
}
static void
g_unix_input_stream_read_async (GInputStream *stream,
void *buffer,
gsize count,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSource *source;
GUnixInputStream *unix_stream;
ReadAsyncData *data;
unix_stream = G_UNIX_INPUT_STREAM (stream);
data = g_new0 (ReadAsyncData, 1);
data->count = count;
data->buffer = buffer;
data->callback = callback;
data->user_data = user_data;
data->cancellable = cancellable;
data->stream = unix_stream;
source = _g_fd_source_new (unix_stream->priv->fd,
G_IO_IN,
cancellable);
g_source_set_name (source, "GUnixInputStream");
g_source_set_callback (source, (GSourceFunc)read_async_cb, data, g_free);
g_source_attach (source, g_main_context_get_thread_default ());
g_source_unref (source);
}
GSource *
_gdk_wayland_display_event_source_new (GdkDisplay *display)
{
GSource *source;
GdkWaylandEventSource *wl_source;
GdkWaylandDisplay *display_wayland;
char *name;
source = g_source_new (&wl_glib_source_funcs,
sizeof (GdkWaylandEventSource));
name = g_strdup_printf ("GDK Wayland Event source (%s)", "display name");
g_source_set_name (source, name);
g_free (name);
wl_source = (GdkWaylandEventSource *) source;
display_wayland = GDK_WAYLAND_DISPLAY (display);
wl_source->display = display;
wl_source->pfd.fd = wl_display_get_fd(display_wayland->wl_display);
wl_source->pfd.events = G_IO_IN | G_IO_ERR | G_IO_HUP;
g_source_add_poll(source, &wl_source->pfd);
g_source_set_priority (source, GDK_PRIORITY_EVENTS);
g_source_set_can_recurse (source, TRUE);
g_source_attach (source, NULL);
event_sources = g_list_prepend (event_sources, source);
return source;
}
/**
* g_io_scheduler_job_send_to_mainloop_async:
* @job: a #GIOSchedulerJob
* @func: a #GSourceFunc callback that will be called in the original thread
* @user_data: data to pass to @func
* @notify: (nullable): a #GDestroyNotify for @user_data, or %NULL
*
* Used from an I/O job to send a callback to be run asynchronously in
* the thread that the job was started from. The callback will be run
* when the main loop is available, but at that time the I/O job might
* have finished. The return value from the callback is ignored.
*
* Note that if you are passing the @user_data from g_io_scheduler_push_job()
* on to this function you have to ensure that it is not freed before
* @func is called, either by passing %NULL as @notify to
* g_io_scheduler_push_job() or by using refcounting for @user_data.
*
* Deprecated: Use g_main_context_invoke().
**/
void
g_io_scheduler_job_send_to_mainloop_async (GIOSchedulerJob *job,
GSourceFunc func,
gpointer user_data,
GDestroyNotify notify)
{
GSource *source;
MainLoopProxy *proxy;
g_return_if_fail (job != NULL);
g_return_if_fail (func != NULL);
proxy = g_new0 (MainLoopProxy, 1);
proxy->func = func;
proxy->data = user_data;
proxy->notify = notify;
g_mutex_init (&proxy->ack_lock);
g_cond_init (&proxy->ack_condition);
source = g_idle_source_new ();
g_source_set_priority (source, G_PRIORITY_DEFAULT);
g_source_set_callback (source, mainloop_proxy_func, proxy,
(GDestroyNotify)mainloop_proxy_free);
g_source_set_name (source, "[gio] mainloop_proxy_func");
g_source_attach (source, job->context);
g_source_unref (source);
}
static GSource *
g_io_unix_create_watch (GIOChannel *channel,
GIOCondition condition)
{
GIOUnixChannel *unix_channel = (GIOUnixChannel *)channel;
GSource *source;
GIOUnixWatch *watch;
source = g_source_new (&g_io_watch_funcs, sizeof (GIOUnixWatch));
g_source_set_name (source, "GIOChannel (Unix)");
watch = (GIOUnixWatch *)source;
watch->channel = channel;
g_io_channel_ref (channel);
watch->condition = condition;
watch->pollfd.fd = unix_channel->fd;
watch->pollfd.events = condition;
g_source_add_poll (source, &watch->pollfd);
return source;
}
static void end_job_init()
{
GSource *source = g_source_new (&end_job_funcs, sizeof (GSource));
g_source_set_name (source, "lua_end_job_source");
// make sure to finish any non-blocking job before we quit
g_source_set_priority(source,G_PRIORITY_DEFAULT_IDLE);
g_source_attach(source,darktable.lua_state.context);
}
KeyboardEventRepeating::KeyboardEventRepeating(Client& client)
: m_client(client)
{
m_source = g_source_new(&sourceFuncs, sizeof(GSource));
g_source_set_name(m_source, "[WPE] KeyboardEventRepeating");
g_source_set_priority(m_source, G_PRIORITY_DEFAULT_IDLE);
g_source_set_callback(m_source, nullptr, this, nullptr);
g_source_attach(m_source, g_main_context_get_thread_default());
}
static void
start_output (CockpitPipe *self)
{
g_assert (self->priv->out_source == NULL);
self->priv->out_source = cockpit_unix_fd_source_new (self->priv->out_fd, G_IO_OUT);
g_source_set_name (self->priv->out_source, "pipe-output");
g_source_set_callback (self->priv->out_source, (GSourceFunc)dispatch_output, self, NULL);
g_source_attach (self->priv->out_source, self->priv->context);
}
/*
* clutter_clock_source_new:
* @master_clock: a #ClutterMasterClock for the source
*
* The #ClutterClockSource is an idle GSource that will queue a redraw
* if @master_clock has at least a running #ClutterTimeline. The redraw
* will cause @master_clock to advance all timelines, thus advancing all
* animations as well.
*
* Return value: the newly created #GSource
*/
static GSource *
clutter_clock_source_new (ClutterMasterClock *master_clock)
{
GSource *source = g_source_new (&clock_funcs, sizeof (ClutterClockSource));
ClutterClockSource *clock_source = (ClutterClockSource *) source;
g_source_set_name (source, "Clutter master clock");
clock_source->master_clock = master_clock;
return source;
}
void GMainLoopSource::scheduleIdleSource(const char* name, GSourceFunc sourceFunction, int priority, GMainContext* context)
{
ASSERT(m_status == Ready);
m_status = Scheduled;
g_source_set_name(m_context.source.get(), name);
if (priority != G_PRIORITY_DEFAULT_IDLE)
g_source_set_priority(m_context.source.get(), priority);
g_source_set_callback(m_context.source.get(), sourceFunction, this, nullptr);
g_source_attach(m_context.source.get(), context);
}
/* Called with chr_write_lock held. */
static void pty_chr_rearm_timer(Chardev *chr, int ms)
{
PtyChardev *s = PTY_CHARDEV(chr);
char *name;
pty_chr_timer_cancel(s);
name = g_strdup_printf("pty-timer-%s", chr->label);
s->timer_src = qemu_chr_timeout_add_ms(chr, ms, pty_chr_timer, chr);
g_source_set_name(s->timer_src, name);
g_free(name);
}
HeapTimer::HeapTimer(VM* vm)
: m_vm(vm)
, m_apiLock(&vm->apiLock())
, m_timer(adoptGRef(g_source_new(&heapTimerSourceFunctions, sizeof(GSource))))
{
g_source_set_name(m_timer.get(), "[JavaScriptCore] HeapTimer");
g_source_set_callback(m_timer.get(), [](gpointer userData) -> gboolean {
static_cast<HeapTimer*>(userData)->timerDidFire();
return G_SOURCE_CONTINUE;
}, this, nullptr);
g_source_attach(m_timer.get(), g_main_context_get_thread_default());
}
GSource *qio_channel_create_watch(QIOChannel *ioc,
GIOCondition condition)
{
QIOChannelClass *klass = QIO_CHANNEL_GET_CLASS(ioc);
GSource *ret = klass->io_create_watch(ioc, condition);
if (ioc->name) {
g_source_set_name(ret, ioc->name);
}
return ret;
}