void misc_test() { GPollFunc func = g_main_context_get_poll_func(context); g_assert(func != NULL); g_main_context_set_poll_func(context,dummy_poll_func); func = g_main_context_get_poll_func(context); g_assert(func == dummy_poll_func); }
static void restore_poll_func(VALUE data) { if (g_main_context_get_poll_func(NULL) == (GPollFunc)rbglib_poll) { g_main_context_set_poll_func(NULL, default_poll_func); } }
nsresult nsAppShell::Init() { #ifdef PR_LOGGING if (!gWidgetLog) gWidgetLog = PR_NewLogModule("Widget"); if (!gWidgetFocusLog) gWidgetFocusLog = PR_NewLogModule("WidgetFocus"); if (!gWidgetDragLog) gWidgetDragLog = PR_NewLogModule("WidgetDrag"); if (!gWidgetDrawLog) gWidgetDrawLog = PR_NewLogModule("WidgetDraw"); #endif if (!sPollFunc) { sPollFunc = g_main_context_get_poll_func(NULL); g_main_context_set_poll_func(NULL, &PollWrapper); } if (PR_GetEnv("MOZ_DEBUG_PAINTS")) gdk_window_set_debug_updates(TRUE); int err = pipe(mPipeFDs); if (err) return NS_ERROR_OUT_OF_MEMORY; GIOChannel *ioc; GSource *source; // make the pipe nonblocking int flags = fcntl(mPipeFDs[0], F_GETFL, 0); if (flags == -1) goto failed; err = fcntl(mPipeFDs[0], F_SETFL, flags | O_NONBLOCK); if (err == -1) goto failed; flags = fcntl(mPipeFDs[1], F_GETFL, 0); if (flags == -1) goto failed; err = fcntl(mPipeFDs[1], F_SETFL, flags | O_NONBLOCK); if (err == -1) goto failed; ioc = g_io_channel_unix_new(mPipeFDs[0]); source = g_io_create_watch(ioc, G_IO_IN); g_io_channel_unref(ioc); g_source_set_callback(source, (GSourceFunc)EventProcessorCallback, this, nullptr); g_source_set_can_recurse(source, TRUE); mTag = g_source_attach(source, nullptr); g_source_unref(source); return nsBaseAppShell::Init(); failed: close(mPipeFDs[0]); close(mPipeFDs[1]); mPipeFDs[0] = mPipeFDs[1] = 0; return NS_ERROR_FAILURE; }
gint g_io_channel_win32_poll (GPollFD *fds, gint n_fds, gint timeout) { int result; g_return_val_if_fail (n_fds >= 0, 0); result = (*g_main_context_get_poll_func (NULL)) (fds, n_fds, timeout); return result; }
CAMLprim value lwt_glib_iter(value may_block) { GMainContext *gc; gint max_priority, timeout; GPollFD *pollfds = NULL; gint pollfds_size = 0; gint nfds; gint i; /* Get the main context. */ gc = g_main_context_default(); /* Try to acquire it. */ if (!g_main_context_acquire(gc)) caml_failwith("Lwt_glib.iter"); /* Dispatch pending events. */ g_main_context_dispatch(gc); /* Prepare the context for polling. */ g_main_context_prepare(gc, &max_priority); /* Get all file descriptors to poll. */ while (pollfds_size < (nfds = g_main_context_query(gc, max_priority, &timeout, pollfds, pollfds_size))) { free(pollfds); pollfds_size = nfds; pollfds = lwt_unix_malloc(pollfds_size * sizeof (GPollFD)); } /* Clear all revents fields. */ for (i = 0; i < nfds; i++) pollfds[i].revents = 0; /* Set the timeout to 0 if we do not want to block. */ if (!Bool_val(may_block)) timeout = 0; /* Do the blocking call. */ caml_enter_blocking_section(); g_main_context_get_poll_func(gc)(pollfds, nfds, timeout); caml_leave_blocking_section(); /* Let glib parse the result. */ g_main_context_check(gc, max_priority, pollfds, nfds); /* Release the context. */ g_main_context_release(gc); free(pollfds); return Val_unit; }
gint gtk_module_init (gint argc, gchar *argv[]) { GDBusConnection *dbus; gchar *address; const gchar *socket; GError *error = NULL; ENTRY; if (!(socket = g_getenv("GDKEVENT_SOCKET"))) { CRITICAL(Gdk, "Failed to load gdkevent socket."); RETURN(-1); } address = g_strdup_printf("unix:path=%s", socket); dbus = g_dbus_connection_new_for_address_sync(address, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT, NULL, NULL, &error); g_free(address); if (!dbus) { CRITICAL(Gdk, "Failed to load IPC socket: %s", error->message); g_error_free(error); RETURN(-1); } connection = dbus; gdk_event_handler_set(gdkevent_dispatcher, dbus, gdkevent_module_unloaded); g_get_current_time(&last_time); poll_func = g_main_context_get_poll_func(g_main_context_default()); g_main_context_set_poll_func(g_main_context_default(), gdkevent_poll); RETURN(0); }
int main (int argc, char *argv[]) { const gchar *dir; GeditCommandLine *command_line; gboolean ret; gboolean service = FALSE; #ifdef G_OS_UNIX GeditDBus *dbus; GeditDBusResult dbusret; #endif #ifdef OS_OSX GPollFunc orig_poll_func; GPollFunc gdk_poll_func; #endif #ifndef ENABLE_GVFS_METADATA const gchar *cache_dir; gchar *metadata_filename; #endif /* Setup debugging */ gedit_debug_init (); gedit_debug_message (DEBUG_APP, "Startup"); /* Setup locale/gettext */ setlocale (LC_ALL, ""); gedit_dirs_init (); dir = gedit_dirs_get_gedit_locale_dir (); bindtextdomain (GETTEXT_PACKAGE, dir); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); #ifndef ENABLE_GVFS_METADATA /* Setup metadata-manager */ cache_dir = gedit_dirs_get_user_cache_dir (); metadata_filename = g_build_filename (cache_dir, METADATA_FILE, NULL); gedit_metadata_manager_init (metadata_filename); g_free (metadata_filename); #endif #ifdef OS_OSX orig_poll_func = g_main_context_get_poll_func (NULL); #endif /* Parse command line arguments */ command_line = gedit_command_line_get_default (); ret = gedit_command_line_parse (command_line, &argc, &argv); if (!ret) { g_object_unref (command_line); return 1; } #ifdef G_OS_UNIX #ifdef OS_OSX /* Note: this is a bit of a hack. What happens here is that we are going to * store the poll function installed by gdk (happens in post-parse of options) * and replace it with the original main loop poll handler. We do this because * the gedit dbus stuff is going to run some main loops to run async gdbus calls. * The problem is that for OS X, the gdk poll func in the main context (which * will be run due to the fact that the main loops in our dbus code iterate the * main context) is going to process events from NSApp, INCLUDING apple events * such as OpenFiles. Since we are not setup yet, we are going to miss these * events. By swapping out the gdk poll func, and swapping it back in later, * we prevent this from happening. Note that we only do this when building * on OS X to prevent any possible future problems for other platforms. * This is a dirty hack, but it works for now. */ gdk_poll_func = g_main_context_get_poll_func (NULL); g_main_context_set_poll_func (NULL, orig_poll_func); #endif /* Run over dbus */ dbus = gedit_dbus_new (); dbusret = gedit_dbus_run (dbus); #ifdef OS_OSX g_main_context_set_poll_func (NULL, gdk_poll_func); #endif switch (dbusret) { case GEDIT_DBUS_RESULT_SUCCESS: case GEDIT_DBUS_RESULT_FAILED: /* fallthrough */ g_object_unref (command_line); g_object_unref (dbus); return dbusret == GEDIT_DBUS_RESULT_SUCCESS ? 0 : 1; break; case GEDIT_DBUS_RESULT_PROCEED_SERVICE: service = TRUE; break; case GEDIT_DBUS_RESULT_PROCEED: break; } #endif gedit_main (service); #ifdef G_OS_UNIX g_object_unref (dbus); #endif g_object_unref (command_line); return 0; }
CAMLprim value lwt_glib_poll(value val_fds, value val_count, value val_timeout) { gint timeout, lwt_timeout; long count; int i; GPollFD *gpollfd; gint events, revents; CAMLparam3(val_fds, val_count, val_timeout); CAMLlocal5(node, src, node_result, src_result, tmp); count = Long_val(val_count); g_main_context_dispatch(gc); g_main_context_prepare(gc, &max_priority); while (fds_count < count + (n_fds = g_main_context_query(gc, max_priority, &timeout, gpollfds, fds_count))) { free(gpollfds); fds_count = n_fds + count; gpollfds = lwt_unix_malloc(fds_count * sizeof (GPollFD)); } /* Clear all revents fields. */ for (i = 0; i < n_fds + count; i++) gpollfds[i].revents = 0; /* Add all Lwt fds. */ for (i = n_fds, node = val_fds; i < n_fds + count; i++, node = Field(node, 1)) { src = Field(node, 0); gpollfd = gpollfds + i; #if defined(LWT_ON_WINDOWS) gpollfd->fd = Handle_val(Field(src, 0)); #else gpollfd->fd = Int_val(Field(src, 0)); #endif events = 0; if (Bool_val(Field(src, 1))) events |= G_IO_IN; if (Bool_val(Field(src, 2))) events |= G_IO_OUT; gpollfd->events = events; } lwt_timeout = Int_val(val_timeout); if (timeout < 0 || (lwt_timeout >= 0 && lwt_timeout < timeout)) timeout = lwt_timeout; /* Do the blocking call. */ caml_enter_blocking_section(); g_main_context_get_poll_func(gc)(gpollfds, n_fds + count, timeout); caml_leave_blocking_section(); g_main_context_check(gc, max_priority, gpollfds, n_fds); /* Build the result. */ node_result = Val_int(0); for (i = n_fds, node = val_fds; i < n_fds + count; i++, node = Field(node, 1)) { gpollfd = gpollfds + i; src_result = caml_alloc_tuple(3); src = Field(node, 0); Field(src_result, 0) = Field(src, 0); revents = gpollfd->revents; if (revents & G_IO_HUP) { /* Treat HUP as ready. There's no point continuing to wait on this FD. */ if (gpollfd->events & G_IO_IN) revents |= G_IO_IN; if (gpollfd->events & G_IO_OUT) revents |= G_IO_OUT; } Field(src_result, 1) = Val_bool(revents & G_IO_IN); Field(src_result, 2) = Val_bool(revents & G_IO_OUT); tmp = caml_alloc_tuple(2); Field(tmp, 0) = src_result; Field(tmp, 1) = node_result; node_result = tmp; } CAMLreturn(node_result); }
bool wxApp::Initialize(int& argc, wxChar **argv) { bool init_result; #if wxUSE_THREADS if (!g_thread_supported()) g_thread_init(NULL); wxgs_poll_func = g_main_context_get_poll_func(NULL); g_main_context_set_poll_func(NULL, wxapp_poll_func); #endif // wxUSE_THREADS gtk_set_locale(); // We should have the wxUSE_WCHAR_T test on the _outside_ #if wxUSE_WCHAR_T // gtk+ 2.0 supports Unicode through UTF-8 strings wxConvCurrent = &wxConvUTF8; #else // !wxUSE_WCHAR_T if (!wxOKlibc()) wxConvCurrent = (wxMBConv*) NULL; #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T // decide which conversion to use for the file names // (1) this variable exists for the sole purpose of specifying the encoding // of the filenames for GTK+ programs, so use it if it is set wxString encName(wxGetenv(_T("G_FILENAME_ENCODING"))); encName = encName.BeforeFirst(_T(',')); if (encName.CmpNoCase(_T("@locale")) == 0) encName.clear(); encName.MakeUpper(); #if wxUSE_INTL if (encName.empty()) { // (2) if a non default locale is set, assume that the user wants his // filenames in this locale too encName = wxLocale::GetSystemEncodingName().Upper(); // (3) finally use UTF-8 by default if (encName.empty() || encName == _T("US-ASCII")) encName = _T("UTF-8"); wxSetEnv(_T("G_FILENAME_ENCODING"), encName); } #else if (encName.empty()) encName = _T("UTF-8"); #endif // wxUSE_INTL #if wxUSE_WCHAR_T static wxConvBrokenFileNames fileconv(encName); wxConvFileName = &fileconv; #endif // wxUSE_WCHAR_T #if wxUSE_UNICODE // gtk_init() wants UTF-8, not wchar_t, so convert int i; char **argvGTK = new char *[argc + 1]; for ( i = 0; i < argc; i++ ) { argvGTK[i] = wxStrdupA(wxConvUTF8.cWX2MB(argv[i])); } argvGTK[argc] = NULL; int argcGTK = argc; #ifdef __WXGPE__ init_result = true; // is there a _check() version of this? gpe_application_init( &argcGTK, &argvGTK ); #else init_result = gtk_init_check( &argcGTK, &argvGTK ); #endif if ( argcGTK != argc ) { // we have to drop the parameters which were consumed by GTK+ for ( i = 0; i < argcGTK; i++ ) { while ( strcmp(wxConvUTF8.cWX2MB(argv[i]), argvGTK[i]) != 0 ) { memmove(argv + i, argv + i + 1, (argc - i)*sizeof(*argv)); } } argc = argcGTK; } //else: gtk_init() didn't modify our parameters // free our copy for ( i = 0; i < argcGTK; i++ ) { free(argvGTK[i]); } delete [] argvGTK; #else // !wxUSE_UNICODE // gtk_init() shouldn't actually change argv itself (just its contents) so // it's ok to pass pointer to it init_result = gtk_init_check( &argc, &argv ); #endif // wxUSE_UNICODE/!wxUSE_UNICODE if (!init_result) { wxLogError(wxT("Unable to initialize gtk, is DISPLAY set properly?")); return false; } // update internal arg[cv] as GTK+ may have removed processed options: this->argc = argc; this->argv = argv; // we can not enter threads before gtk_init is done gdk_threads_enter(); if ( !wxAppBase::Initialize(argc, argv) ) { gdk_threads_leave(); return false; } wxSetDetectableAutoRepeat( true ); #if wxUSE_INTL wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding()); #endif return true; }
nsresult nsAppShell::Init() { #ifdef PR_LOGGING if (!gWidgetLog) gWidgetLog = PR_NewLogModule("Widget"); if (!gWidgetFocusLog) gWidgetFocusLog = PR_NewLogModule("WidgetFocus"); if (!gWidgetDragLog) gWidgetDragLog = PR_NewLogModule("WidgetDrag"); if (!gWidgetDrawLog) gWidgetDrawLog = PR_NewLogModule("WidgetDraw"); #endif if (!sPollFunc) { sPollFunc = g_main_context_get_poll_func(NULL); g_main_context_set_poll_func(NULL, &PollWrapper); } if (PR_GetEnv("MOZ_DEBUG_PAINTS")) gdk_window_set_debug_updates(TRUE); // Disable JasPer module (jpeg2000) in GDK-PixBuf. // Also disable known buggy TGA and icns formats GSList* pixbufFormats = gdk_pixbuf_get_formats(); for (GSList* iter = pixbufFormats; iter; iter = iter->next) { GdkPixbufFormat* format = static_cast<GdkPixbufFormat*>(iter->data); gchar* name = gdk_pixbuf_format_get_name(format); if (strcmp(name, "jpeg2000") == 0 || strcmp(name, "tga") == 0 || strcmp(name, "icns") == 0) { gdk_pixbuf_format_set_disabled(format, TRUE); } g_free(name); } g_slist_free(pixbufFormats); int err = pipe(mPipeFDs); if (err) return NS_ERROR_OUT_OF_MEMORY; GIOChannel *ioc; GSource *source; // make the pipe nonblocking int flags = fcntl(mPipeFDs[0], F_GETFL, 0); if (flags == -1) goto failed; err = fcntl(mPipeFDs[0], F_SETFL, flags | O_NONBLOCK); if (err == -1) goto failed; flags = fcntl(mPipeFDs[1], F_GETFL, 0); if (flags == -1) goto failed; err = fcntl(mPipeFDs[1], F_SETFL, flags | O_NONBLOCK); if (err == -1) goto failed; ioc = g_io_channel_unix_new(mPipeFDs[0]); source = g_io_create_watch(ioc, G_IO_IN); g_io_channel_unref(ioc); g_source_set_callback(source, (GSourceFunc)EventProcessorCallback, this, nullptr); g_source_set_can_recurse(source, TRUE); mTag = g_source_attach(source, nullptr); g_source_unref(source); return nsBaseAppShell::Init(); failed: close(mPipeFDs[0]); close(mPipeFDs[1]); mPipeFDs[0] = mPipeFDs[1] = 0; return NS_ERROR_FAILURE; }
/* ``plug'' our polling function into the glib: */ void lwt_glib_setup() { old_poll_func = g_main_context_get_poll_func(NULL); g_main_context_set_poll_func(NULL, lwt_glib_poll); }