static JSBool gjs_main_loop_run(JSContext *context, JSObject *obj, uintN argc, jsval *argv, jsval *retval) { char *cancel_id; GMainLoop *main_loop; if (!gjs_parse_args(context, "run", "s", argc, argv, "cancelId", &cancel_id)) return JS_FALSE; main_loop = g_hash_table_lookup(pending_main_loops, cancel_id); if (!main_loop) { main_loop = g_main_loop_new(NULL, FALSE); g_hash_table_replace(pending_main_loops, g_strdup(cancel_id), main_loop); } else { g_main_loop_ref(main_loop); } gjs_debug(GJS_DEBUG_MAINLOOP, "main loop %s being run in context %p", cancel_id, context); g_free(cancel_id); g_main_loop_run(main_loop); g_main_loop_unref(main_loop); return JS_TRUE; }
int main(int argc, char *argv[]) { g_type_init(); g_thread_init(NULL); /* Set signal handlers */ signal(SIGINT, main_signal_handler); signal(SIGTERM, main_signal_handler); mainloop = g_main_loop_new(NULL, FALSE); g_main_loop_ref(mainloop); maxfd = sib_maxfd_new(); rm_handler = nota_rm_handler_new( maxfd ); control = create_control(rm_handler); if(!control) { printf("\n\nCould not create control channel to sib-daemon, daemon running properly?\n"); exit(1); } g_main_loop_run(mainloop); g_main_loop_unref(mainloop); printf("\n\nExiting normally\n\n"); exit (0); }
static void bus_acquired_cb (GDBusConnection *connection, const gchar *name, gpointer user_data) { GMainLoop *loop = (GMainLoop *) user_data; guint registration_id; GError *error = NULL; if (!introspection_data) introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL); registration_id = g_dbus_connection_register_object (connection, EV_DBUS_DAEMON_OBJECT_PATH, introspection_data->interfaces[0], &interface_vtable, g_main_loop_ref (loop), (GDestroyNotify) g_main_loop_unref, &error); if (registration_id == 0) { g_printerr ("Failed to register object: %s\n", error->message); g_error_free (error); if (g_main_loop_is_running (loop)) g_main_loop_quit (loop); } }
/** \brief Initialize the main loop \param loop If loop is not NULL the given main loop is used, otherwise this function will create a new one. */ void mbus_init( GMainLoop * loop ) { if ( loop == NULL ) { __loop = g_main_loop_new( NULL, FALSE ); } else { g_main_loop_ref( loop ); __loop = loop; } }
static inline GMainLoop * pyg_save_current_main_loop (GMainLoop *main_loop) { GMainLoop *retval = pyg_current_main_loop; g_return_val_if_fail(main_loop != NULL, NULL); pyg_current_main_loop = g_main_loop_ref(main_loop); return retval; }
GMainLoop * push_main_loop (void) { loop_list = g_slist_prepend (loop_list, loop); loop = g_main_loop_new (NULL, TRUE); main_loop_poll (0); /* Add a second reference that is passed to Smalltalk. */ g_main_loop_ref (loop); return loop; }
static void handle_control_c(GMainLoop* loop) { sigset_t mask; sigemptyset(&mask); sigaddset(&mask, SIGINT); sigaddset(&mask, SIGTERM); if (sigprocmask(SIG_BLOCK, &mask, NULL) < 0) { LogError("Failed to set signal mask"); } else { int fd = signalfd(-1, &mask, 0); if (fd < 0) { LogError("Failed to create signal descriptor"); } else { GIOChannel *channel = g_io_channel_unix_new(fd); if (channel == NULL) { close(fd); LogError("Failed to create IO channel"); } else { g_io_channel_set_close_on_unref(channel, TRUE); g_io_channel_set_encoding(channel, NULL, NULL); g_io_channel_set_buffered(channel, FALSE); g_event_source_id = g_io_add_watch( channel, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, signal_handler, loop ); if (g_event_source_id == 0) { LogError("g_io_add_watch failed"); } g_main_loop_ref(loop); g_io_channel_unref(channel); } } } }
static inline GMainLoop * pyg_save_current_main_loop (GMainLoop *main_loop) { GMainLoop *retval; g_return_val_if_fail(main_loop != NULL, NULL); if (pyg_current_main_loop_key == -1) pyg_current_main_loop_key = PyThread_create_key(); retval = PyThread_get_key_value(pyg_current_main_loop_key); PyThread_delete_key_value(pyg_current_main_loop_key); PyThread_set_key_value(pyg_current_main_loop_key, g_main_loop_ref(main_loop)); return retval; }
/** * Create the SIBService singleton if it doesn't exist. Otherwise returns * the pointer to the service singleton. * * @return SIBService* */ static SIBService* sib_service_new() { whiteboard_log_debug_fb(); if (service_singleton == NULL) { service_singleton = g_new0(SIBService, 1); g_return_val_if_fail(service_singleton != NULL, NULL); service_singleton->controller = sib_service_create_controller(service_singleton); service_singleton->ctrl_running = FALSE; service_singleton->main_loop = g_main_loop_new(NULL, FALSE); g_main_loop_ref(service_singleton->main_loop); service_singleton->mutex = g_mutex_new(); } whiteboard_log_debug_fe(); return service_singleton; }
gint main (gint argc, gchar **argv) { GMainLoop *loop; guint owner_id; g_set_prgname ("atril-daemon"); g_type_init (); loop = g_main_loop_new (NULL, FALSE); pending_invocations = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify)g_free, NULL); owner_id = g_bus_own_name (G_BUS_TYPE_SESSION, EV_DBUS_DAEMON_NAME, G_BUS_NAME_OWNER_FLAGS_NONE, bus_acquired_cb, name_acquired_cb, name_lost_cb, g_main_loop_ref (loop), (GDestroyNotify) g_main_loop_unref); g_main_loop_run (loop); g_bus_unown_name (owner_id); g_main_loop_unref (loop); if (introspection_data) g_dbus_node_info_unref (introspection_data); g_list_foreach (ev_daemon_docs, (GFunc)ev_doc_free, NULL); g_list_free (ev_daemon_docs); g_hash_table_destroy (pending_invocations); return 0; }
static gpointer loop_thread_init (gpointer data) { KmsLoop *self = KMS_LOOP (data); GMainLoop *loop; GMainContext *context; KMS_LOOP_LOCK (self); self->priv->context = g_main_context_new (); context = g_main_context_ref (self->priv->context); self->priv->loop = g_main_loop_new (context, FALSE); loop = g_main_loop_ref (self->priv->loop); KMS_LOOP_UNLOCK (self); /* unlock main process because context is already initialized */ g_mutex_lock (&self->priv->mutex); self->priv->initialized = TRUE; g_cond_signal (&self->priv->cond); g_mutex_unlock (&self->priv->mutex); if (!g_main_context_acquire (context)) { GST_ERROR ("Can not acquire context"); goto end; } GST_DEBUG ("Running main loop"); g_main_loop_run (loop); g_main_context_release (context); end: GST_DEBUG ("Thread finished"); g_main_loop_unref (loop); g_main_context_unref (context); return NULL; }
static gpointer provider_thread (gpointer data) { GstV4l2DeviceProvider *provider = data; GMainContext *context = NULL; GMainLoop *loop = NULL; GUdevClient *client; GList *devices; static const gchar *subsystems[] = { "video4linux", NULL }; GST_OBJECT_LOCK (provider); if (provider->context) context = g_main_context_ref (provider->context); if (provider->loop) loop = g_main_loop_ref (provider->loop); if (context == NULL || loop == NULL) { provider->started = TRUE; g_cond_broadcast (&provider->started_cond); GST_OBJECT_UNLOCK (provider); return NULL; } GST_OBJECT_UNLOCK (provider); g_main_context_push_thread_default (context); client = g_udev_client_new (subsystems); g_signal_connect (client, "uevent", G_CALLBACK (uevent_cb), provider); devices = g_udev_client_query_by_subsystem (client, "video4linux"); while (devices) { GUdevDevice *udev_device = devices->data; GstDevice *gstdev; devices = g_list_remove (devices, udev_device); if (g_udev_device_get_property_as_int (udev_device, "ID_V4L_VERSION") == 2) { gstdev = gst_v4l2_device_provider_device_from_udev (provider, udev_device); if (gstdev) gst_device_provider_device_add (GST_DEVICE_PROVIDER (provider), gstdev); } g_object_unref (udev_device); } GST_OBJECT_LOCK (provider); provider->started = TRUE; g_cond_broadcast (&provider->started_cond); GST_OBJECT_UNLOCK (provider); g_main_loop_run (loop); g_main_loop_unref (loop); g_object_unref (client); g_main_context_unref (context); gst_object_unref (provider); return NULL; }
int main (int argc, char **argv) { GError *error; GOptionContext *opt_context; GMainLoop *main_loop; gint ret; guint name_owner_id; GIOChannel *stdin_channel; ret = 1; opt_context = NULL; name_owner_id = 0; stdin_channel = NULL; introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL); g_assert (introspection_data != NULL); opt_context = g_option_context_new ("gnome-shell calendar server"); g_option_context_add_main_entries (opt_context, opt_entries, NULL); error = NULL; if (!g_option_context_parse (opt_context, &argc, &argv, &error)) { g_printerr ("Error parsing options: %s", error->message); g_error_free (error); goto out; } main_loop = g_main_loop_new (NULL, FALSE); stdin_channel = g_io_channel_unix_new (STDIN_FILENO); g_io_add_watch_full (stdin_channel, G_PRIORITY_DEFAULT, G_IO_HUP, stdin_channel_io_func, g_main_loop_ref (main_loop), (GDestroyNotify) g_main_loop_unref); name_owner_id = g_bus_own_name (G_BUS_TYPE_SESSION, BUS_NAME, G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | (opt_replace ? G_BUS_NAME_OWNER_FLAGS_REPLACE : 0), on_bus_acquired, on_name_acquired, on_name_lost, g_main_loop_ref (main_loop), (GDestroyNotify) g_main_loop_unref); g_main_loop_run (main_loop); g_main_loop_unref (main_loop); ret = 0; out: if (stdin_channel != NULL) g_io_channel_unref (stdin_channel); if (_global_app != NULL) app_free (_global_app); if (name_owner_id != 0) g_bus_unown_name (name_owner_id); if (opt_context != NULL) g_option_context_free (opt_context); return ret; }
template <> GMainLoop* refGPtr(GMainLoop* ptr) { if (ptr) g_main_loop_ref(ptr); return ptr; }
MiniBrowser::MiniBrowser(GMainLoop* mainLoop, Mode mode, int width, int height, int viewportHorizontalDisplacement, int viewportVerticalDisplacement) : m_context(AdoptWK, WKContextCreate()) , m_pageGroup(AdoptWK, (WKPageGroupCreateWithIdentifier(WKStringCreateWithUTF8CString("MiniBrowser")))) , m_window(new LinuxWindow(this, width, height)) , m_view(0) , m_mainLoop(mainLoop) , m_lastClickTime(0) , m_lastClickX(0) , m_lastClickY(0) , m_lastClickButton(kWKEventMouseButtonNoButton) , m_clickCount(0) , m_touchMocker(0) , m_mode(mode) , m_displayUpdateScheduled(false) , m_gestureRecognizer(GestureRecognizer(this)) , m_postponeTextInputUpdates(true) , m_shouldFocusEditableArea(false) , m_shouldRestoreViewportWhenLosingFocus(false) , m_pageHandlesTouchEvents(false) , m_viewportMinScale(0.25) , m_viewportMaxScale(5) , m_viewportUserScalable(true) , m_viewportInitScale(1) { g_main_loop_ref(m_mainLoop); WKPreferencesRef preferences = WKPageGroupGetPreferences(m_pageGroup.get()); WKPreferencesSetAcceleratedCompositingEnabled(preferences, true); WKPreferencesSetFrameFlatteningEnabled(preferences, true); WKPreferencesSetDeveloperExtrasEnabled(preferences, true); m_view = NIXViewCreate(m_context.get(), m_pageGroup.get()); NIXViewClient viewClient; memset(&viewClient, 0, sizeof(NIXViewClient)); viewClient.version = kNIXViewClientCurrentVersion; viewClient.clientInfo = this; viewClient.viewNeedsDisplay = MiniBrowser::viewNeedsDisplay; viewClient.webProcessCrashed = MiniBrowser::webProcessCrashed; viewClient.webProcessRelaunched = MiniBrowser::webProcessRelaunched; viewClient.doneWithTouchEvent = MiniBrowser::doneWithTouchEvent; viewClient.doneWithGestureEvent = MiniBrowser::doneWithGestureEvent; viewClient.pageDidRequestScroll = MiniBrowser::pageDidRequestScroll; viewClient.didChangeContentsSize = MiniBrowser::didChangeContentsSize; viewClient.didChangeViewportAttributes = MiniBrowser::didChangeViewportAttributes; viewClient.didFindZoomableArea = MiniBrowser::didFindZoomableArea; viewClient.updateTextInputState = MiniBrowser::updateTextInputState; NIXViewSetViewClient(m_view, &viewClient); NIXViewInitialize(m_view); WKPageLoaderClient loaderClient; memset(&loaderClient, 0, sizeof(loaderClient)); loaderClient.version = kWKPageLoaderClientCurrentVersion; loaderClient.clientInfo = this; loaderClient.didStartProgress = MiniBrowser::didStartProgress; WKPageSetPageLoaderClient(pageRef(), &loaderClient); if (m_mode == MobileMode) WKPageSetUseFixedLayout(pageRef(), true); WKSize size = m_window->size(); m_viewRect = WKRectMake(viewportHorizontalDisplacement, viewportVerticalDisplacement, size.width - viewportHorizontalDisplacement, size.height - viewportVerticalDisplacement); NIXViewSetSize(m_view, m_viewRect.size); if (viewportHorizontalDisplacement || viewportVerticalDisplacement) { NIXMatrix transform = NIXMatrixMakeTranslation(viewportHorizontalDisplacement, viewportVerticalDisplacement); NIXViewSetUserViewportTransformation(m_view, &transform); } NIXViewSetFocused(m_view, true); NIXViewSetVisible(m_view, true); NIXViewSetActive(m_view, true); }
void main_loop_test() { GMainContext *default_context; int depth; int id; GTimeVal time ={0,}; int user_data = 0,fd_data = 0; GPollFD pollfd; GSource *source3; GSourceFuncs SourceFuncs = { prepare, check, dispatch, NULL }; GSourceFuncs fd_SourceFuncs = { fd_prepare, fd_check, fd_dispatch, NULL }; e1_complete = FALSE; e2_complete = FALSE; pipe(fd); pollfd.fd = fd[0]; pollfd.events = G_IO_IN | G_IO_HUP | G_IO_ERR; pollfd.revents = 0; pthread_create(&thread1, NULL, thread_function, NULL); context = g_main_context_new(); //g_main_context_add_poll(context,&pollfd,0); source1 = g_source_new(&SourceFuncs,sizeof(GSource)); g_source_set_callback(source1,(GSourceFunc)my_callback,&user_data,NULL); id = g_source_attach(source1,context); g_assert(g_source_get_id(source1) == id); g_source_set_priority(source1,0); g_assert(g_source_get_priority(source1) == 0); loop = g_main_loop_new(context, FALSE); default_context = g_main_loop_get_context(loop); //checks g_main_loop_get_context g_assert(default_context == context); //checks g_main_loop_is_running g_assert(g_main_loop_is_running(loop) == FALSE); depth = g_main_depth(); //checks g_main_depth g_assert(depth == 0); g_source_get_current_time(source1,&time); g_assert(time.tv_usec > 0); g_source_set_can_recurse(source1,TRUE); g_assert(g_source_get_can_recurse(source1) == TRUE); source2 = g_source_new(&fd_SourceFuncs,sizeof(GSource)); g_source_set_callback(source2,(GSourceFunc)fd_callback,&fd_data,NULL); g_source_add_poll(source2,&pollfd); g_source_remove_poll(source2,&pollfd); // checks g_source_remove_poll g_assert(source2->poll_fds == NULL); g_source_add_poll(source2,&pollfd); // checks whether g_source_add_poll is successful. // one more check is done in fd_callback. // If that function is callled we are sure that add poll was successful g_assert(source2->poll_fds->data == &pollfd); source3 = g_source_ref(source2); g_assert(source3 == source2 && source2->ref_count == 2); g_source_unref(source3); id = g_source_attach(source2,context); //checks g_main_context_pending g_assert(g_main_context_pending(context)); g_main_loop_run(loop); // ref is called here. Thats why two unrefs are called. If the 2nd unref is // callled with the unref, code should crash g_main_loop_ref(loop); g_main_loop_unref(loop); g_main_loop_unref(loop); //checks the number of times the call back function is called g_assert(user_data == 100); // checks whether set poll was successful and call back for the same // was called g_assert(fd_data == 1); }
/** * gda_worker_do_job: (skip) * @worker: a #GdaWorker object * @context: (allow-none): a #GMainContext to execute a main loop in (while waiting), or %NULL * @timeout_ms: the maximum number of milisecons to wait before returning, or %0 for unlimited wait * @out_result: (allow-none): a place to store the result, if any, of @func's execution, or %NULL * @out_job_id: (allow-none): a place to store the ID of the job having been submitted, or %NULL * @func: the function to call from the worker thread * @data: (allow-none): the data to pass to @func, or %NULL * @data_destroy_func: (allow-none): a function to destroy @data, or %NULL * @result_destroy_func: (allow-none): a function to destroy the result, if any, of @func's execution, or %NULL * @error: (allow-none): a place to store errors, or %NULL. * * Request that the worker thread call @func with the @data argument, much like gda_worker_submit_job(), * but waits (starting a #GMainLoop) for a maximum of @timeout_ms miliseconds for @func to be executed. * * If this function is called from within @worker's worker thread, then this function simply calls @func with @data and does not * use @context. * * The following cases are possible if this function is not called from within @worker's worker thread: * <itemizedlist> * <listitem><para>the call to @func took less than @timeout_ms miliseconds: the return value is %TRUE and * @out_result contains the result of the @func's execution, and @out_job_id contains %NULL. Note in this * case that @error may still contain an error code if @func's execution produced an error. Also note that in this case * any setting defined by gda_worker_set_callback() is not applied (as the result is immediately returned)</para></listitem> * <listitem><para>The call to @func takes more then @timeout_ms miliseconds: the return value is %TRUE and * @out_result is %NULL and @out_job_id contains the ID of the job as if it had been submitted using gda_worker_submit_job(). * If @out_job_id is %NULL, and if no setting has been defined using gda_worker_set_callback(), then the job will be discarded * (as if gda_worker_forget_job() had been called). * </para></listitem> * <listitem><para>The call to @func could not be done (some kind of plumbing error for instance): the returned value is %FALSE * and @out_result and @out_job_id are set to %NULL (if they are not %NULL)</para></listitem> * </itemizedlist> * * Notes: * <itemizedlist> * <listitem><para>@result_destroy_func is needed in case @out_result is %NULL (to avoid memory leaks)</para></listitem> * <listitem><para>passing %NULL for @context is similar to passing the result of g_main_context_ref_thread_default()</para></listitem> * </itemizedlist> * * Returns: %TRUE if no error occurred * * Since: 6.0 */ gboolean gda_worker_do_job (GdaWorker *worker, GMainContext *context, gint timeout_ms, gpointer *out_result, guint *out_job_id, GdaWorkerFunc func, gpointer data, GDestroyNotify data_destroy_func, GDestroyNotify result_destroy_func, GError **error) { if (out_result) *out_result = NULL; if (out_job_id) *out_job_id = 0; g_return_val_if_fail (worker, FALSE); g_return_val_if_fail (func, FALSE); if (!worker->callbacks_hash || !worker->jobs_hash) { g_warning ("GdaWorker has been destroyed\n"); return FALSE; } if (gda_worker_thread_is_worker (worker)) { /* we are called from within the worker thread => call the function directly */ gpointer result; result = func (data, error); if (data_destroy_func) data_destroy_func (data); if (out_result) *out_result = result; else if (result && result_destroy_func) result_destroy_func (result); return TRUE; } guint jid, itsid, timer = 0; /* determine which GMainContext to use */ GMainContext *co; gboolean unref_co = FALSE; co = context; if (!co) { co = g_main_context_ref_thread_default (); unref_co = TRUE; } /* prepare main loop */ GMainLoop *loop; loop = g_main_loop_new (co, FALSE); /* prepare ITSignaler to be notified */ ITSignaler *its; its = itsignaler_new (); itsid = itsignaler_add (its, co, (ITSignalerFunc) do_itsignaler_cb, g_main_loop_ref (loop), (GDestroyNotify) g_main_loop_unref); /* push job */ g_rec_mutex_lock (& worker->rmutex); /* required to call _gda_worker_submit_job_with_its() */ jid = _gda_worker_submit_job_with_its (worker, its, func, data, data_destroy_func, result_destroy_func, error); g_rec_mutex_unlock (& worker->rmutex); if (jid == 0) { /* an error occurred */ g_assert (itsignaler_remove (its, co, itsid)); itsignaler_unref (its); g_main_loop_unref (loop); if (unref_co) g_main_context_unref (co); return FALSE; } /* check if result is already here */ WorkerJob *job; job = itsignaler_pop_notification (its, 0); if (!job) { if (timeout_ms > 0) { /* start timer to limit waiting time */ GSource *timer_src; timer_src = g_timeout_source_new (timeout_ms); g_source_set_callback (timer_src, (GSourceFunc) do_timer_cb, loop, NULL); timer = g_source_attach (timer_src, co); g_source_unref (timer_src); } g_main_loop_run (loop); /* either timer has arrived or job has been done */ job = itsignaler_pop_notification (its, 0); } g_main_loop_unref (loop); g_assert (itsignaler_remove (its, co, itsid)); itsignaler_unref (its); if (job) { /* job done before the timer, if any, elapsed */ if (timer > 0) g_assert (g_source_remove (timer)); g_assert (gda_worker_fetch_job_result (worker, jid, out_result, error)); } else { /* timer came first, job is not yet finished */ /* apply settings from gda_worker_set_callback(), if any */ g_rec_mutex_lock (&worker->rmutex); DeclaredCallback *dc; dc = g_hash_table_lookup (worker->callbacks_hash, co); if (dc) { job = g_hash_table_lookup (worker->jobs_hash, &jid); g_assert (job); g_assert (!job->reply_its); job->reply_its = itsignaler_ref (dc->its); } g_rec_mutex_unlock (& worker->rmutex); /* cleanups */ if (out_job_id) *out_job_id = jid; else if (!dc) /* forget all about the job */ gda_worker_forget_job (worker, jid); } if (unref_co) g_main_context_unref (co); return TRUE; }