1998-12-02 15:55:27 +01:00
|
|
|
/* GLIB - Library of useful routines for C programming
|
|
|
|
|
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
|
|
|
|
*
|
|
|
|
|
* gmain.c: Main loop abstraction, timeouts, and idle functions
|
|
|
|
|
* Copyright 1998 Owen Taylor
|
|
|
|
|
*
|
|
|
|
|
* This library is free software; you can redistribute it and/or
|
2000-07-26 13:02:02 +02:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
1998-12-02 15:55:27 +01:00
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
2000-07-26 13:02:02 +02:00
|
|
|
* Lesser General Public License for more details.
|
1998-12-02 15:55:27 +01:00
|
|
|
*
|
2000-07-26 13:02:02 +02:00
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
1998-12-02 15:55:27 +01:00
|
|
|
* License along with this library; if not, write to the
|
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
|
* Boston, MA 02111-1307, USA.
|
|
|
|
|
*/
|
|
|
|
|
|
1999-02-24 07:14:27 +01:00
|
|
|
/*
|
2000-07-26 13:02:02 +02:00
|
|
|
* Modified by the GLib Team and others 1997-2000. See the AUTHORS
|
1999-02-24 07:14:27 +01:00
|
|
|
* file for a list of people on the GLib Team. See the ChangeLog
|
|
|
|
|
* files for a list of changes. These files are distributed with
|
|
|
|
|
* GLib at ftp://ftp.gtk.org/pub/gtk/.
|
|
|
|
|
*/
|
|
|
|
|
|
1998-12-15 06:28:02 +01:00
|
|
|
/*
|
|
|
|
|
* MT safe
|
|
|
|
|
*/
|
|
|
|
|
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
#include "config.h"
|
|
|
|
|
|
1999-07-24 20:50:58 +02:00
|
|
|
/* uncomment the next line to get poll() debugging info */
|
|
|
|
|
/* #define G_MAIN_POLL_DEBUG */
|
|
|
|
|
|
1998-12-02 15:55:27 +01:00
|
|
|
#include "glib.h"
|
2003-02-14 16:08:46 +01:00
|
|
|
#include "gthreadinit.h"
|
2004-02-18 23:55:15 +01:00
|
|
|
#include <signal.h>
|
1998-12-19 04:44:30 +01:00
|
|
|
#include <sys/types.h>
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
#include <time.h>
|
|
|
|
|
#ifdef HAVE_SYS_TIME_H
|
1998-12-02 15:55:27 +01:00
|
|
|
#include <sys/time.h>
|
1999-01-17 05:49:43 +01:00
|
|
|
#endif /* HAVE_SYS_TIME_H */
|
|
|
|
|
#ifdef GLIB_HAVE_SYS_POLL_H
|
1999-01-04 21:09:59 +01:00
|
|
|
# include <sys/poll.h>
|
|
|
|
|
# undef events /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */
|
|
|
|
|
# undef revents /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */
|
2004-03-14 19:02:37 +01:00
|
|
|
|
|
|
|
|
/* The poll() emulation on OS/X doesn't handle fds=NULL, nfds=0,
|
|
|
|
|
* so we prefer our own poll emulation.
|
|
|
|
|
*/
|
|
|
|
|
#ifdef _POLL_EMUL_H_
|
|
|
|
|
#undef HAVE_POLL
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-01-17 05:49:43 +01:00
|
|
|
#endif /* GLIB_HAVE_SYS_POLL_H */
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
#ifdef HAVE_UNISTD_H
|
1998-12-02 15:55:27 +01:00
|
|
|
#include <unistd.h>
|
1999-01-17 05:49:43 +01:00
|
|
|
#endif /* HAVE_UNISTD_H */
|
1998-12-15 06:28:02 +01:00
|
|
|
#include <errno.h>
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
|
1999-10-04 04:32:50 +02:00
|
|
|
#ifdef G_OS_WIN32
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
#define STRICT
|
|
|
|
|
#include <windows.h>
|
1999-10-04 04:32:50 +02:00
|
|
|
#endif /* G_OS_WIN32 */
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
|
1999-10-04 04:32:50 +02:00
|
|
|
#ifdef G_OS_BEOS
|
1999-05-08 09:40:44 +02:00
|
|
|
#include <net/socket.h>
|
1999-10-04 04:32:50 +02:00
|
|
|
#endif /* G_OS_BEOS */
|
1999-05-08 09:40:44 +02:00
|
|
|
|
2004-02-14 01:23:36 +01:00
|
|
|
#ifdef G_OS_UNIX
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
#include <sys/wait.h>
|
|
|
|
|
#endif
|
1998-12-02 15:55:27 +01:00
|
|
|
/* Types */
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
typedef struct _GTimeoutSource GTimeoutSource;
|
2004-02-14 01:23:36 +01:00
|
|
|
typedef struct _GChildWatchSource GChildWatchSource;
|
1998-12-02 15:55:27 +01:00
|
|
|
typedef struct _GPollRec GPollRec;
|
2000-12-05 21:45:33 +01:00
|
|
|
typedef struct _GSourceCallback GSourceCallback;
|
1998-12-02 15:55:27 +01:00
|
|
|
|
1998-12-17 05:06:27 +01:00
|
|
|
typedef enum
|
|
|
|
|
{
|
1998-12-02 15:55:27 +01:00
|
|
|
G_SOURCE_READY = 1 << G_HOOK_FLAG_USER_SHIFT,
|
|
|
|
|
G_SOURCE_CAN_RECURSE = 1 << (G_HOOK_FLAG_USER_SHIFT + 1)
|
|
|
|
|
} GSourceFlags;
|
|
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
#ifdef G_THREADS_ENABLED
|
|
|
|
|
typedef struct _GMainWaiter GMainWaiter;
|
|
|
|
|
|
|
|
|
|
struct _GMainWaiter
|
|
|
|
|
{
|
|
|
|
|
GCond *cond;
|
|
|
|
|
GMutex *mutex;
|
|
|
|
|
};
|
|
|
|
|
#endif
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
struct _GMainContext
|
1998-12-17 05:06:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
#ifdef G_THREADS_ENABLED
|
|
|
|
|
/* The following lock is used for both the list of sources
|
|
|
|
|
* and the list of poll records
|
|
|
|
|
*/
|
2001-06-30 21:56:47 +02:00
|
|
|
GStaticMutex mutex;
|
|
|
|
|
GCond *cond;
|
|
|
|
|
GThread *owner;
|
|
|
|
|
guint owner_count;
|
|
|
|
|
GSList *waiters;
|
2000-12-05 21:45:33 +01:00
|
|
|
#endif
|
|
|
|
|
|
2004-03-04 11:12:55 +01:00
|
|
|
gint ref_count;
|
2001-06-30 21:56:47 +02:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
GPtrArray *pending_dispatches;
|
|
|
|
|
gint timeout; /* Timeout for current iteration */
|
|
|
|
|
|
|
|
|
|
guint next_id;
|
|
|
|
|
GSource *source_list;
|
|
|
|
|
gint in_check_or_prepare;
|
|
|
|
|
|
|
|
|
|
GPollRec *poll_records;
|
|
|
|
|
GPollRec *poll_free_list;
|
|
|
|
|
GMemChunk *poll_chunk;
|
|
|
|
|
guint n_poll_records;
|
|
|
|
|
GPollFD *cached_poll_array;
|
Changes for 64-bit cleanliness, loosely based on patch from Mark Murnane.
Wed Jun 20 12:00:54 2001 Owen Taylor <otaylor@redhat.com>
Changes for 64-bit cleanliness, loosely based on patch
from Mark Murnane.
* gconvert.c (g_convert/g_convert_with_fallback): Remove
workarounds for since-fixed GNU libc bugs. Minor
doc fix.
* gconvert.[ch]: Change gint to gsize/gssize as
appropriate.
* gconvert.c (g_locale/filename_to/from_utf8): Fix incorrect
computation of bytes_read / bytes_written.
* gfileutils.[ch] (g_file_get_contents): Make length
out parameter 'gsize *len'.
* ghook.c (g_hook_compare_ids): Don't compare a
and b as 'a - b'.
* gmacros.h (GSIZE_TO_POINTER): Add GPOINTER_TO_SIZE,
GSIZE_TO_POINTER.
* gmain.c (g_timeout_prepare): Rewrite to avoid
overflows. (Fixes bug when system clock skews
backwards more than 24 days.)
* gmarkup.[ch]: Make lengths passed to callbacks
gsize, length for g_markup_parse-context_parse(),
g_markup_escape_text() gssize.
* gmessages.[ch] (g_printf_string_upper_bound): Change
return value to gsize.
* gmessages.c (printf_string_upper_bound): Remove
a ridiculous use of 'inline' on a 300 line function.
* gstring.[ch]: Represent size of string as a gsize,
not gint. Make parameters to functions take gsize,
or gssize where -1 is allowed.
* gstring.c (g_string_erase): Make
g_string_erase (string, pos, -1) a synonym for
g_string_truncate for consistency with other G*
APIs.
* gstrfuncs.[ch]: Make all functions taking a string
length, take a gsize, or gssize if -1 is allowed.
(g_strstr_len, g_strrstr_len). Also fix some boundary
conditions in g_str[r]str[_len].
* gutf8.c tests/unicode-encoding.c: Make parameters that
are byte lengths gsize, gssize as appropriate. Make
character offsets, other counts, glong.
* gasyncqueue.c gcompletion.c
timeloop.c timeloop-basic.c gutils.c gspawn.c.
Small 64 bit cleanliness fixups.
* glist.c (g_list_sort2, g_list_sort_real): Fix functions
that should have been static.
* gdate.c (g_date_fill_parse_tokens): Fix extra
declaration that was shadowing another.
* tests/module-test.c: Include string.h
Mon Jun 18 15:43:29 2001 Owen Taylor <otaylor@redhat.com>
* gutf8.c (g_get_charset): Make argument
G_CONST_RETURN char **.
2001-06-23 15:55:09 +02:00
|
|
|
guint cached_poll_array_size;
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
#ifdef G_THREADS_ENABLED
|
|
|
|
|
#ifndef G_OS_WIN32
|
|
|
|
|
/* this pipe is used to wake up the main loop when a source is added.
|
|
|
|
|
*/
|
|
|
|
|
gint wake_up_pipe[2];
|
|
|
|
|
#else /* G_OS_WIN32 */
|
|
|
|
|
HANDLE wake_up_semaphore;
|
|
|
|
|
#endif /* G_OS_WIN32 */
|
|
|
|
|
|
|
|
|
|
GPollFD wake_up_rec;
|
|
|
|
|
gboolean poll_waiting;
|
|
|
|
|
|
|
|
|
|
/* Flag indicating whether the set of fd's changed during a poll */
|
|
|
|
|
gboolean poll_changed;
|
|
|
|
|
#endif /* G_THREADS_ENABLED */
|
|
|
|
|
|
|
|
|
|
GPollFunc poll_func;
|
|
|
|
|
|
|
|
|
|
GTimeVal current_time;
|
|
|
|
|
gboolean time_is_current;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct _GSourceCallback
|
|
|
|
|
{
|
|
|
|
|
guint ref_count;
|
|
|
|
|
GSourceFunc func;
|
|
|
|
|
gpointer data;
|
|
|
|
|
GDestroyNotify notify;
|
1998-12-02 15:55:27 +01:00
|
|
|
};
|
|
|
|
|
|
1998-12-17 05:06:27 +01:00
|
|
|
struct _GMainLoop
|
|
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
GMainContext *context;
|
1998-12-18 03:23:33 +01:00
|
|
|
gboolean is_running;
|
2004-03-04 11:12:55 +01:00
|
|
|
gint ref_count;
|
1998-12-02 15:55:27 +01:00
|
|
|
};
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
struct _GTimeoutSource
|
1998-12-17 05:06:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
GSource source;
|
1998-12-02 15:55:27 +01:00
|
|
|
GTimeVal expiration;
|
2002-06-13 22:14:43 +02:00
|
|
|
guint interval;
|
1998-12-02 15:55:27 +01:00
|
|
|
};
|
|
|
|
|
|
2004-02-14 01:23:36 +01:00
|
|
|
struct _GChildWatchSource
|
|
|
|
|
{
|
|
|
|
|
GSource source;
|
|
|
|
|
GPid pid;
|
|
|
|
|
gint child_status;
|
2004-02-28 14:03:55 +01:00
|
|
|
#ifdef G_OS_WIN32
|
|
|
|
|
GPollFD poll;
|
|
|
|
|
#else /* G_OS_WIN32 */
|
2004-03-04 11:12:55 +01:00
|
|
|
gint count;
|
|
|
|
|
gboolean child_exited;
|
2004-02-28 14:03:55 +01:00
|
|
|
#endif /* G_OS_WIN32 */
|
2004-02-14 01:23:36 +01:00
|
|
|
};
|
|
|
|
|
|
1998-12-17 05:06:27 +01:00
|
|
|
struct _GPollRec
|
|
|
|
|
{
|
1998-12-02 15:55:27 +01:00
|
|
|
gint priority;
|
|
|
|
|
GPollFD *fd;
|
|
|
|
|
GPollRec *next;
|
|
|
|
|
};
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
#ifdef G_THREADS_ENABLED
|
2001-06-30 21:56:47 +02:00
|
|
|
#define LOCK_CONTEXT(context) g_static_mutex_lock (&context->mutex)
|
|
|
|
|
#define UNLOCK_CONTEXT(context) g_static_mutex_unlock (&context->mutex)
|
|
|
|
|
#define G_THREAD_SELF g_thread_self ()
|
2000-12-05 21:45:33 +01:00
|
|
|
#else
|
|
|
|
|
#define LOCK_CONTEXT(context) (void)0
|
|
|
|
|
#define UNLOCK_CONTEXT(context) (void)0
|
2001-06-30 21:56:47 +02:00
|
|
|
#define G_THREAD_SELF NULL
|
2000-12-05 21:45:33 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#define SOURCE_DESTROYED(source) (((source)->flags & G_HOOK_FLAG_ACTIVE) == 0)
|
2004-03-19 21:25:03 +01:00
|
|
|
#define SOURCE_BLOCKED(source) (((source)->flags & G_HOOK_FLAG_IN_CALL) != 0 && \
|
|
|
|
|
((source)->flags & G_SOURCE_CAN_RECURSE) == 0)
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
#define SOURCE_UNREF(source, context) \
|
|
|
|
|
G_STMT_START { \
|
|
|
|
|
if ((source)->ref_count > 1) \
|
|
|
|
|
(source)->ref_count--; \
|
|
|
|
|
else \
|
|
|
|
|
g_source_unref_internal ((source), (context), TRUE); \
|
|
|
|
|
} G_STMT_END
|
|
|
|
|
|
|
|
|
|
|
1998-12-02 15:55:27 +01:00
|
|
|
/* Forward declarations */
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
static void g_source_unref_internal (GSource *source,
|
|
|
|
|
GMainContext *context,
|
|
|
|
|
gboolean have_lock);
|
|
|
|
|
static void g_source_destroy_internal (GSource *source,
|
|
|
|
|
GMainContext *context,
|
|
|
|
|
gboolean have_lock);
|
|
|
|
|
static void g_main_context_poll (GMainContext *context,
|
|
|
|
|
gint timeout,
|
|
|
|
|
gint priority,
|
|
|
|
|
GPollFD *fds,
|
|
|
|
|
gint n_fds);
|
|
|
|
|
static void g_main_context_add_poll_unlocked (GMainContext *context,
|
|
|
|
|
gint priority,
|
|
|
|
|
GPollFD *fd);
|
|
|
|
|
static void g_main_context_remove_poll_unlocked (GMainContext *context,
|
|
|
|
|
GPollFD *fd);
|
2001-06-30 21:56:47 +02:00
|
|
|
static void g_main_context_wakeup_unlocked (GMainContext *context);
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
static gboolean g_timeout_prepare (GSource *source,
|
|
|
|
|
gint *timeout);
|
|
|
|
|
static gboolean g_timeout_check (GSource *source);
|
|
|
|
|
static gboolean g_timeout_dispatch (GSource *source,
|
|
|
|
|
GSourceFunc callback,
|
|
|
|
|
gpointer user_data);
|
2004-02-14 01:23:36 +01:00
|
|
|
static gboolean g_child_watch_prepare (GSource *source,
|
|
|
|
|
gint *timeout);
|
|
|
|
|
static gboolean g_child_watch_check (GSource *source);
|
|
|
|
|
static gboolean g_child_watch_dispatch (GSource *source,
|
|
|
|
|
GSourceFunc callback,
|
|
|
|
|
gpointer user_data);
|
2000-12-05 21:45:33 +01:00
|
|
|
static gboolean g_idle_prepare (GSource *source,
|
|
|
|
|
gint *timeout);
|
|
|
|
|
static gboolean g_idle_check (GSource *source);
|
|
|
|
|
static gboolean g_idle_dispatch (GSource *source,
|
|
|
|
|
GSourceFunc callback,
|
|
|
|
|
gpointer user_data);
|
|
|
|
|
|
1999-02-10 10:40:46 +01:00
|
|
|
G_LOCK_DEFINE_STATIC (main_loop);
|
2000-12-05 21:45:33 +01:00
|
|
|
static GMainContext *default_main_context;
|
2002-08-06 16:50:52 +02:00
|
|
|
static GSList *main_contexts_without_pipe = NULL;
|
1998-12-15 06:28:02 +01:00
|
|
|
|
2004-02-28 14:03:55 +01:00
|
|
|
#ifndef G_OS_WIN32
|
2004-02-14 01:23:36 +01:00
|
|
|
/* Child status monitoring code */
|
|
|
|
|
enum {
|
|
|
|
|
CHILD_WATCH_UNINITIALIZED,
|
|
|
|
|
CHILD_WATCH_INITIALIZED_SINGLE,
|
|
|
|
|
CHILD_WATCH_INITIALIZED_THREADED
|
|
|
|
|
};
|
|
|
|
|
static gint child_watch_init_state = CHILD_WATCH_UNINITIALIZED;
|
|
|
|
|
static gint child_watch_count = 0;
|
|
|
|
|
static gint child_watch_wake_up_pipe[2] = {0, 0};
|
2004-02-28 14:03:55 +01:00
|
|
|
#endif /* !G_OS_WIN32 */
|
2004-02-14 01:23:36 +01:00
|
|
|
G_LOCK_DEFINE_STATIC (main_context_list);
|
|
|
|
|
static GSList *main_context_list = NULL;
|
|
|
|
|
|
2001-09-04 00:12:51 +02:00
|
|
|
GSourceFuncs g_timeout_funcs =
|
1999-01-17 05:49:43 +01:00
|
|
|
{
|
1998-12-02 15:55:27 +01:00
|
|
|
g_timeout_prepare,
|
|
|
|
|
g_timeout_check,
|
|
|
|
|
g_timeout_dispatch,
|
2000-12-05 21:45:33 +01:00
|
|
|
NULL
|
1998-12-02 15:55:27 +01:00
|
|
|
};
|
|
|
|
|
|
2004-02-14 01:23:36 +01:00
|
|
|
GSourceFuncs g_child_watch_funcs =
|
|
|
|
|
{
|
|
|
|
|
g_child_watch_prepare,
|
|
|
|
|
g_child_watch_check,
|
|
|
|
|
g_child_watch_dispatch,
|
|
|
|
|
NULL
|
|
|
|
|
};
|
|
|
|
|
|
2001-09-04 00:12:51 +02:00
|
|
|
GSourceFuncs g_idle_funcs =
|
1999-01-17 05:49:43 +01:00
|
|
|
{
|
1998-12-02 15:55:27 +01:00
|
|
|
g_idle_prepare,
|
|
|
|
|
g_idle_check,
|
|
|
|
|
g_idle_dispatch,
|
2000-12-05 21:45:33 +01:00
|
|
|
NULL
|
1998-12-02 15:55:27 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#ifdef HAVE_POLL
|
1999-07-24 20:50:58 +02:00
|
|
|
/* SunOS has poll, but doesn't provide a prototype. */
|
|
|
|
|
# if defined (sun) && !defined (__SVR4)
|
|
|
|
|
extern gint poll (GPollFD *ufds, guint nfsd, gint timeout);
|
|
|
|
|
# endif /* !sun */
|
1998-12-17 05:06:27 +01:00
|
|
|
#else /* !HAVE_POLL */
|
2000-12-05 21:45:33 +01:00
|
|
|
|
1999-10-04 04:32:50 +02:00
|
|
|
#ifdef G_OS_WIN32
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
|
|
|
|
|
static gint
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
g_poll (GPollFD *fds,
|
|
|
|
|
guint nfds,
|
|
|
|
|
gint timeout)
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
{
|
|
|
|
|
HANDLE handles[MAXIMUM_WAIT_OBJECTS];
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
gboolean poll_msgs = FALSE;
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
GPollFD *f;
|
|
|
|
|
DWORD ready;
|
|
|
|
|
MSG msg;
|
|
|
|
|
UINT timer;
|
|
|
|
|
gint nhandles = 0;
|
|
|
|
|
|
|
|
|
|
for (f = fds; f < &fds[nfds]; ++f)
|
|
|
|
|
if (f->fd >= 0)
|
|
|
|
|
{
|
2002-10-27 00:53:21 +02:00
|
|
|
if (f->fd == G_WIN32_MSG_HANDLE)
|
|
|
|
|
poll_msgs = TRUE;
|
2003-08-15 07:06:16 +02:00
|
|
|
else if (nhandles == MAXIMUM_WAIT_OBJECTS)
|
|
|
|
|
{
|
|
|
|
|
g_warning (G_STRLOC ": Too many handles to wait for!\n");
|
|
|
|
|
break;
|
|
|
|
|
}
|
2002-10-27 00:53:21 +02:00
|
|
|
else
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
{
|
|
|
|
|
#ifdef G_MAIN_POLL_DEBUG
|
2002-10-27 00:53:21 +02:00
|
|
|
g_print ("g_poll: waiting for %#x\n", f->fd);
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
#endif
|
2002-10-27 00:53:21 +02:00
|
|
|
handles[nhandles++] = (HANDLE) f->fd;
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
}
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (timeout == -1)
|
|
|
|
|
timeout = INFINITE;
|
|
|
|
|
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
if (poll_msgs)
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
{
|
2001-01-25 22:16:46 +01:00
|
|
|
/* Waiting for messages, and maybe events
|
|
|
|
|
* -> First PeekMessage
|
|
|
|
|
*/
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
#ifdef G_MAIN_POLL_DEBUG
|
2001-01-25 22:16:46 +01:00
|
|
|
g_print ("PeekMessage\n");
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
#endif
|
2001-01-25 22:16:46 +01:00
|
|
|
if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
|
|
|
|
|
ready = WAIT_OBJECT_0 + nhandles;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (nhandles == 0)
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
{
|
2001-01-25 22:16:46 +01:00
|
|
|
/* Waiting just for messages */
|
|
|
|
|
if (timeout == INFINITE)
|
|
|
|
|
{
|
|
|
|
|
/* Infinite timeout
|
|
|
|
|
* -> WaitMessage
|
|
|
|
|
*/
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
#ifdef G_MAIN_POLL_DEBUG
|
2001-01-25 22:16:46 +01:00
|
|
|
g_print ("WaitMessage\n");
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
#endif
|
2001-01-25 22:16:46 +01:00
|
|
|
if (!WaitMessage ())
|
2003-06-06 00:18:27 +02:00
|
|
|
{
|
|
|
|
|
gchar *emsg = g_win32_error_message (GetLastError ());
|
|
|
|
|
g_warning (G_STRLOC ": WaitMessage() failed: %s", emsg);
|
|
|
|
|
g_free (emsg);
|
|
|
|
|
}
|
2001-01-25 22:16:46 +01:00
|
|
|
ready = WAIT_OBJECT_0 + nhandles;
|
|
|
|
|
}
|
|
|
|
|
else if (timeout == 0)
|
|
|
|
|
{
|
|
|
|
|
/* Waiting just for messages, zero timeout.
|
|
|
|
|
* If we got here, there was no message
|
|
|
|
|
*/
|
|
|
|
|
ready = WAIT_TIMEOUT;
|
|
|
|
|
}
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
else
|
2001-01-25 22:16:46 +01:00
|
|
|
{
|
|
|
|
|
/* Waiting just for messages, some timeout
|
|
|
|
|
* -> Set a timer, wait for message,
|
|
|
|
|
* kill timer, use PeekMessage
|
|
|
|
|
*/
|
2001-02-01 23:28:48 +01:00
|
|
|
timer = SetTimer (NULL, 0, timeout, NULL);
|
|
|
|
|
if (timer == 0)
|
2002-10-27 00:53:21 +02:00
|
|
|
{
|
2003-06-06 00:18:27 +02:00
|
|
|
gchar *emsg = g_win32_error_message (GetLastError ());
|
|
|
|
|
g_warning (G_STRLOC ": SetTimer() failed: %s", emsg);
|
|
|
|
|
g_free (emsg);
|
2002-10-27 00:53:21 +02:00
|
|
|
ready = WAIT_TIMEOUT;
|
|
|
|
|
}
|
2001-01-25 22:16:46 +01:00
|
|
|
else
|
|
|
|
|
{
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
#ifdef G_MAIN_POLL_DEBUG
|
2001-01-25 22:16:46 +01:00
|
|
|
g_print ("WaitMessage\n");
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
#endif
|
2001-01-25 22:16:46 +01:00
|
|
|
WaitMessage ();
|
|
|
|
|
KillTimer (NULL, timer);
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
#ifdef G_MAIN_POLL_DEBUG
|
2001-01-25 22:16:46 +01:00
|
|
|
g_print ("PeekMessage\n");
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
#endif
|
2001-01-25 22:16:46 +01:00
|
|
|
if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE)
|
|
|
|
|
&& msg.message != WM_TIMER)
|
|
|
|
|
ready = WAIT_OBJECT_0;
|
|
|
|
|
else
|
|
|
|
|
ready = WAIT_TIMEOUT;
|
|
|
|
|
}
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
}
|
|
|
|
|
}
|
2001-01-25 22:16:46 +01:00
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Wait for either message or event
|
|
|
|
|
* -> Use MsgWaitForMultipleObjects
|
|
|
|
|
*/
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
#ifdef G_MAIN_POLL_DEBUG
|
2001-01-25 22:16:46 +01:00
|
|
|
g_print ("MsgWaitForMultipleObjects(%d, %d)\n", nhandles, timeout);
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
#endif
|
2001-01-25 22:16:46 +01:00
|
|
|
ready = MsgWaitForMultipleObjects (nhandles, handles, FALSE,
|
|
|
|
|
timeout, QS_ALLINPUT);
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
|
2001-01-25 22:16:46 +01:00
|
|
|
if (ready == WAIT_FAILED)
|
2003-06-06 00:18:27 +02:00
|
|
|
{
|
|
|
|
|
gchar *emsg = g_win32_error_message (GetLastError ());
|
|
|
|
|
g_warning (G_STRLOC ": MsgWaitForMultipleObjects() failed: %s", emsg);
|
|
|
|
|
g_free (emsg);
|
|
|
|
|
}
|
2001-01-25 22:16:46 +01:00
|
|
|
}
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (nhandles == 0)
|
|
|
|
|
{
|
|
|
|
|
/* Wait for nothing (huh?) */
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Wait for just events
|
|
|
|
|
* -> Use WaitForMultipleObjects
|
|
|
|
|
*/
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
#ifdef G_MAIN_POLL_DEBUG
|
|
|
|
|
g_print ("WaitForMultipleObjects(%d, %d)\n", nhandles, timeout);
|
|
|
|
|
#endif
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
ready = WaitForMultipleObjects (nhandles, handles, FALSE, timeout);
|
|
|
|
|
if (ready == WAIT_FAILED)
|
2003-06-06 00:18:27 +02:00
|
|
|
{
|
|
|
|
|
gchar *emsg = g_win32_error_message (GetLastError ());
|
|
|
|
|
g_warning (G_STRLOC ": WaitForMultipleObjects() failed: %s", emsg);
|
|
|
|
|
g_free (emsg);
|
|
|
|
|
}
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
}
|
|
|
|
|
|
2001-01-25 22:16:46 +01:00
|
|
|
#ifdef G_MAIN_POLL_DEBUG
|
2002-10-27 00:53:21 +02:00
|
|
|
g_print ("wait returns %ld%s\n",
|
2001-01-25 22:16:46 +01:00
|
|
|
ready,
|
|
|
|
|
(ready == WAIT_FAILED ? " (WAIT_FAILED)" :
|
|
|
|
|
(ready == WAIT_TIMEOUT ? " (WAIT_TIMEOUT)" :
|
|
|
|
|
(poll_msgs && ready == WAIT_OBJECT_0 + nhandles ? " (msg)" : ""))));
|
|
|
|
|
#endif
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
for (f = fds; f < &fds[nfds]; ++f)
|
|
|
|
|
f->revents = 0;
|
|
|
|
|
|
|
|
|
|
if (ready == WAIT_FAILED)
|
|
|
|
|
return -1;
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
else if (ready == WAIT_TIMEOUT)
|
|
|
|
|
return 0;
|
|
|
|
|
else if (poll_msgs && ready == WAIT_OBJECT_0 + nhandles)
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
{
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
for (f = fds; f < &fds[nfds]; ++f)
|
|
|
|
|
if (f->fd >= 0)
|
|
|
|
|
{
|
|
|
|
|
if (f->events & G_IO_IN)
|
|
|
|
|
if (f->fd == G_WIN32_MSG_HANDLE)
|
|
|
|
|
f->revents |= G_IO_IN;
|
|
|
|
|
}
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
}
|
When the sublangid is SUBLANG_DEFAULT, return the locale of the language's
2001-09-24 Bruno Haible <haible@clisp.cons.org>
* glib/gwin32.c (g_win32_getlocale): When the sublangid is
SUBLANG_DEFAULT, return the locale of the language's main country,
not a country-neutral locale. E.g. "en_US" instead of "en". Add
handling of LANG_SORBIAN. Fix typo for SUBLANG_CHINESE_SIMPLIFIED
(China == CN, CH == Switzerland). Ignore empty environment
variable values.
2001-09-28 Tor Lillqvist <tml@iki.fi>
* glib/makefile.{mingw,msc}.in: Add localcharset.o. Just copy the
source file from libcharset and compile in this directory.
* glib/giochannel.c: Mark rest of g_set_error strings for
translation, too.
* glib/giowin32.c: Add some debugging output functions, call them
when debugging.
(create_events, g_io_win32_msg_write): Free message fetched with
g_win32_error_message ().
(g_io_win32_check): Indentation fixes.
(g_io_win32_fd_read,g_io_win32_sock_read): Don't always return
G_IO_STATUS_NORMAL. Do return G_IO_STATUS_EOF if we got 0 bytes,
like on Unix. This helps making the test programs run
successfully.
* glib/gmain.c (g_poll): Return the code ifdeffed out with
TEST_WITHOUT_THIS. Can't remember why it was ifdeffed out. Things
seem to work as previously with the code in place. Especially
spawn-test didn't work with the code ifdeffed out (Bug#61067).
* glib/grand.c (g_rand_new): Don't try to use /dev/urandom unless
on Unix.
* glib/gspawn-win32-helper.c (WinMain): Remove Sleep(10000)
accidentally left in.
gthread:
2001-09-28 Tor Lillqvist <tml@iki.fi>
* gthread-win32.c: Use an extra level of indirection for GMutex.
It is now a pointer either to a pointer to a CRITICAL_SECTION
struct, or to a mutex HANDLE. This is needed in case the user
defines G_ERRORCHECK_MUTEXES. G_MUTEX_SIZE must correctly reflect
the size of *GMutex, but this used to vary depending on whether we
at run-time chose to use CRITICAL_SECTIONs or mutexes.
(g_mutex_free_win32_cs_impl, g_cond_free_win32_impl): Call
DeleteCriticalSection() when done with it.
* gthread-impl.c (g_thread_init_with_errorcheck_mutexes): Call
g_thread_impl_init() before accessing
g_thread_functions_for_glib_use_default, as the
g_thread_impl_init() function might modify it.
po:
2001-09-28 Tor Lillqvist <tml@iki.fi>
* POTFILES.in: Add iochannel.c and giowin32.c.
* sv.po: Remove a bogus fuzziness indicator.
2001-09-28 00:07:00 +02:00
|
|
|
#if 1 /* TEST_WITHOUT_THIS */
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
else if (ready >= WAIT_OBJECT_0 && ready < WAIT_OBJECT_0 + nhandles)
|
|
|
|
|
for (f = fds; f < &fds[nfds]; ++f)
|
|
|
|
|
{
|
2002-10-27 00:53:21 +02:00
|
|
|
if ((f->events & (G_IO_IN | G_IO_OUT))
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
&& f->fd == (gint) handles[ready - WAIT_OBJECT_0])
|
|
|
|
|
{
|
2002-10-27 00:53:21 +02:00
|
|
|
if (f->events & G_IO_IN)
|
|
|
|
|
f->revents |= G_IO_IN;
|
|
|
|
|
else
|
|
|
|
|
f->revents |= G_IO_OUT;
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
#ifdef G_MAIN_POLL_DEBUG
|
|
|
|
|
g_print ("g_poll: got event %#x\n", f->fd);
|
|
|
|
|
#endif
|
|
|
|
|
#if 0
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
ResetEvent ((HANDLE) f->fd);
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
#endif
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
}
|
|
|
|
|
}
|
2001-01-25 22:16:46 +01:00
|
|
|
#endif
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
|
2001-01-25 22:16:46 +01:00
|
|
|
return 1;
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
}
|
|
|
|
|
|
1999-10-04 04:32:50 +02:00
|
|
|
#else /* !G_OS_WIN32 */
|
1998-12-02 15:55:27 +01:00
|
|
|
|
|
|
|
|
/* The following implementation of poll() comes from the GNU C Library.
|
|
|
|
|
* Copyright (C) 1994, 1996, 1997 Free Software Foundation, Inc.
|
|
|
|
|
*/
|
|
|
|
|
|
1998-12-08 08:11:54 +01:00
|
|
|
#include <string.h> /* for bzero on BSD systems */
|
|
|
|
|
|
1998-12-02 15:55:27 +01:00
|
|
|
#ifdef HAVE_SYS_SELECT_H
|
|
|
|
|
#include <sys/select.h>
|
1999-03-14 21:57:41 +01:00
|
|
|
#endif /* HAVE_SYS_SELECT_H */
|
1998-12-02 15:55:27 +01:00
|
|
|
|
1999-10-04 04:32:50 +02:00
|
|
|
#ifdef G_OS_BEOS
|
1999-05-08 09:40:44 +02:00
|
|
|
#undef NO_FD_SET
|
1999-10-04 04:32:50 +02:00
|
|
|
#endif /* G_OS_BEOS */
|
1999-05-08 09:40:44 +02:00
|
|
|
|
1998-12-02 15:55:27 +01:00
|
|
|
#ifndef NO_FD_SET
|
|
|
|
|
# define SELECT_MASK fd_set
|
1999-01-17 05:49:43 +01:00
|
|
|
#else /* !NO_FD_SET */
|
1999-07-24 20:50:58 +02:00
|
|
|
# ifndef _AIX
|
|
|
|
|
typedef long fd_mask;
|
|
|
|
|
# endif /* _AIX */
|
1999-01-17 05:49:43 +01:00
|
|
|
# ifdef _IBMR2
|
1998-12-02 15:55:27 +01:00
|
|
|
# define SELECT_MASK void
|
1999-01-17 05:49:43 +01:00
|
|
|
# else /* !_IBMR2 */
|
1998-12-02 15:55:27 +01:00
|
|
|
# define SELECT_MASK int
|
1999-01-17 05:49:43 +01:00
|
|
|
# endif /* !_IBMR2 */
|
|
|
|
|
#endif /* !NO_FD_SET */
|
1998-12-02 15:55:27 +01:00
|
|
|
|
|
|
|
|
static gint
|
1999-01-17 05:49:43 +01:00
|
|
|
g_poll (GPollFD *fds,
|
|
|
|
|
guint nfds,
|
|
|
|
|
gint timeout)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
|
|
|
|
struct timeval tv;
|
|
|
|
|
SELECT_MASK rset, wset, xset;
|
|
|
|
|
GPollFD *f;
|
|
|
|
|
int ready;
|
|
|
|
|
int maxfd = 0;
|
|
|
|
|
|
|
|
|
|
FD_ZERO (&rset);
|
|
|
|
|
FD_ZERO (&wset);
|
|
|
|
|
FD_ZERO (&xset);
|
|
|
|
|
|
|
|
|
|
for (f = fds; f < &fds[nfds]; ++f)
|
|
|
|
|
if (f->fd >= 0)
|
|
|
|
|
{
|
|
|
|
|
if (f->events & G_IO_IN)
|
|
|
|
|
FD_SET (f->fd, &rset);
|
|
|
|
|
if (f->events & G_IO_OUT)
|
|
|
|
|
FD_SET (f->fd, &wset);
|
|
|
|
|
if (f->events & G_IO_PRI)
|
|
|
|
|
FD_SET (f->fd, &xset);
|
1998-12-08 08:11:54 +01:00
|
|
|
if (f->fd > maxfd && (f->events & (G_IO_IN|G_IO_OUT|G_IO_PRI)))
|
1998-12-02 15:55:27 +01:00
|
|
|
maxfd = f->fd;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tv.tv_sec = timeout / 1000;
|
|
|
|
|
tv.tv_usec = (timeout % 1000) * 1000;
|
|
|
|
|
|
|
|
|
|
ready = select (maxfd + 1, &rset, &wset, &xset,
|
|
|
|
|
timeout == -1 ? NULL : &tv);
|
|
|
|
|
if (ready > 0)
|
|
|
|
|
for (f = fds; f < &fds[nfds]; ++f)
|
|
|
|
|
{
|
|
|
|
|
f->revents = 0;
|
|
|
|
|
if (f->fd >= 0)
|
|
|
|
|
{
|
|
|
|
|
if (FD_ISSET (f->fd, &rset))
|
|
|
|
|
f->revents |= G_IO_IN;
|
|
|
|
|
if (FD_ISSET (f->fd, &wset))
|
|
|
|
|
f->revents |= G_IO_OUT;
|
|
|
|
|
if (FD_ISSET (f->fd, &xset))
|
|
|
|
|
f->revents |= G_IO_PRI;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ready;
|
|
|
|
|
}
|
1999-01-17 05:49:43 +01:00
|
|
|
|
1999-10-04 04:32:50 +02:00
|
|
|
#endif /* !G_OS_WIN32 */
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
|
1998-12-17 05:06:27 +01:00
|
|
|
#endif /* !HAVE_POLL */
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
/**
|
|
|
|
|
* g_main_context_ref:
|
2001-09-10 17:50:26 +02:00
|
|
|
* @context: a #GMainContext
|
2001-06-30 21:56:47 +02:00
|
|
|
*
|
|
|
|
|
* Increases the reference count on a #GMainContext object by one.
|
|
|
|
|
**/
|
2001-04-02 18:34:08 +02:00
|
|
|
void
|
2001-06-30 21:56:47 +02:00
|
|
|
g_main_context_ref (GMainContext *context)
|
1999-01-07 21:12:19 +01:00
|
|
|
{
|
2001-06-30 21:56:47 +02:00
|
|
|
g_return_if_fail (context != NULL);
|
2004-03-04 11:12:55 +01:00
|
|
|
g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
|
2001-06-30 21:56:47 +02:00
|
|
|
|
2004-03-04 11:12:55 +01:00
|
|
|
g_atomic_int_inc (&context->ref_count);
|
2001-06-30 21:56:47 +02:00
|
|
|
}
|
|
|
|
|
|
2003-08-25 18:20:41 +02:00
|
|
|
/* If DISABLE_MEM_POOLS is defined, then freeing the
|
|
|
|
|
* mem chunk won't free the records, so we have to
|
|
|
|
|
* do it manually. The conditionalization here is
|
|
|
|
|
* an optimization; g_mem_chunk_free() is a no-op
|
|
|
|
|
* when DISABLE_MEM_POOLS is set.
|
|
|
|
|
*/
|
|
|
|
|
#ifdef DISABLE_MEM_POOLS
|
|
|
|
|
static void
|
|
|
|
|
poll_rec_list_free (GMainContext *context,
|
|
|
|
|
GPollRec *list)
|
|
|
|
|
{
|
|
|
|
|
while (list)
|
|
|
|
|
{
|
|
|
|
|
GPollRec *tmp_rec = list;
|
|
|
|
|
list = list->next;
|
|
|
|
|
g_chunk_free (tmp_rec, context->poll_chunk);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif /* DISABLE_MEM_POOLS */
|
|
|
|
|
|
2004-03-04 11:12:55 +01:00
|
|
|
/**
|
|
|
|
|
* g_main_context_unref:
|
|
|
|
|
* @context: a #GMainContext
|
|
|
|
|
*
|
|
|
|
|
* Decreases the reference count on a #GMainContext object by one. If
|
|
|
|
|
* the result is zero, free the context and free all associated memory.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_main_context_unref (GMainContext *context)
|
2001-06-30 21:56:47 +02:00
|
|
|
{
|
|
|
|
|
GSource *source;
|
2004-03-04 11:12:55 +01:00
|
|
|
g_return_if_fail (context != NULL);
|
|
|
|
|
g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
|
2001-06-30 21:56:47 +02:00
|
|
|
|
2004-03-04 11:12:55 +01:00
|
|
|
if (!g_atomic_int_dec_and_test (&context->ref_count))
|
|
|
|
|
return;
|
2001-06-30 21:56:47 +02:00
|
|
|
|
2004-02-14 01:23:36 +01:00
|
|
|
G_LOCK (main_context_list);
|
|
|
|
|
main_context_list = g_slist_remove (main_context_list, context);
|
|
|
|
|
G_UNLOCK (main_context_list);
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
source = context->source_list;
|
|
|
|
|
while (source)
|
|
|
|
|
{
|
|
|
|
|
GSource *next = source->next;
|
|
|
|
|
g_source_destroy_internal (source, context, TRUE);
|
|
|
|
|
source = next;
|
|
|
|
|
}
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
#ifdef G_THREADS_ENABLED
|
2001-06-30 21:56:47 +02:00
|
|
|
g_static_mutex_free (&context->mutex);
|
2000-12-05 21:45:33 +01:00
|
|
|
#endif
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
g_ptr_array_free (context->pending_dispatches, TRUE);
|
|
|
|
|
g_free (context->cached_poll_array);
|
2003-08-25 18:20:41 +02:00
|
|
|
|
|
|
|
|
#ifdef DISABLE_MEM_POLLS
|
|
|
|
|
poll_rec_list_free (context, context->poll_records);
|
|
|
|
|
poll_rec_list_free (context, context->poll_free_list);
|
|
|
|
|
#endif /* DISABLE_MEM_POOLS */
|
|
|
|
|
|
2003-07-10 01:31:20 +02:00
|
|
|
if (context->poll_chunk)
|
|
|
|
|
g_mem_chunk_destroy (context->poll_chunk);
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-13 05:23:45 +01:00
|
|
|
#ifdef G_THREADS_ENABLED
|
2000-12-05 21:45:33 +01:00
|
|
|
if (g_thread_supported())
|
|
|
|
|
{
|
|
|
|
|
#ifndef G_OS_WIN32
|
|
|
|
|
close (context->wake_up_pipe[0]);
|
|
|
|
|
close (context->wake_up_pipe[1]);
|
|
|
|
|
#else
|
|
|
|
|
CloseHandle (context->wake_up_semaphore);
|
|
|
|
|
#endif
|
2002-08-06 16:50:52 +02:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
main_contexts_without_pipe = g_slist_remove (main_contexts_without_pipe,
|
|
|
|
|
context);
|
2000-12-13 05:23:45 +01:00
|
|
|
#endif
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
g_free (context);
|
1999-01-07 21:12:19 +01:00
|
|
|
}
|
|
|
|
|
|
2002-08-06 16:50:52 +02:00
|
|
|
#ifdef G_THREADS_ENABLED
|
|
|
|
|
static void
|
|
|
|
|
g_main_context_init_pipe (GMainContext *context)
|
|
|
|
|
{
|
2004-02-26 00:48:22 +01:00
|
|
|
# ifndef G_OS_WIN32
|
2004-02-14 01:23:36 +01:00
|
|
|
if (context->wake_up_pipe[0] != -1)
|
|
|
|
|
return;
|
2002-08-06 16:50:52 +02:00
|
|
|
if (pipe (context->wake_up_pipe) < 0)
|
|
|
|
|
g_error ("Cannot create pipe main loop wake-up: %s\n",
|
|
|
|
|
g_strerror (errno));
|
|
|
|
|
|
|
|
|
|
context->wake_up_rec.fd = context->wake_up_pipe[0];
|
|
|
|
|
context->wake_up_rec.events = G_IO_IN;
|
|
|
|
|
# else
|
2004-02-26 00:48:22 +01:00
|
|
|
if (context->wake_up_semaphore != NULL)
|
|
|
|
|
return;
|
2002-08-06 16:50:52 +02:00
|
|
|
context->wake_up_semaphore = CreateSemaphore (NULL, 0, 100, NULL);
|
|
|
|
|
if (context->wake_up_semaphore == NULL)
|
|
|
|
|
g_error ("Cannot create wake-up semaphore: %s",
|
|
|
|
|
g_win32_error_message (GetLastError ()));
|
|
|
|
|
context->wake_up_rec.fd = (gint) context->wake_up_semaphore;
|
|
|
|
|
context->wake_up_rec.events = G_IO_IN;
|
|
|
|
|
# ifdef G_MAIN_POLL_DEBUG
|
|
|
|
|
g_print ("wake-up semaphore: %#x\n", (guint) context->wake_up_semaphore);
|
|
|
|
|
# endif
|
|
|
|
|
# endif
|
|
|
|
|
g_main_context_add_poll_unlocked (context, 0, &context->wake_up_rec);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void
|
2003-02-14 16:08:46 +01:00
|
|
|
_g_main_thread_init ()
|
2002-08-06 16:50:52 +02:00
|
|
|
{
|
|
|
|
|
GSList *curr = main_contexts_without_pipe;
|
|
|
|
|
while (curr)
|
|
|
|
|
{
|
|
|
|
|
g_main_context_init_pipe ((GMainContext *)curr->data);
|
|
|
|
|
curr = curr->next;
|
|
|
|
|
}
|
|
|
|
|
g_slist_free (main_contexts_without_pipe);
|
|
|
|
|
main_contexts_without_pipe = NULL;
|
|
|
|
|
}
|
|
|
|
|
#endif /* G_THREADS_ENABLED */
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
2001-06-30 21:56:47 +02:00
|
|
|
* g_main_context_new:
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
2001-06-30 21:56:47 +02:00
|
|
|
* Creates a new #GMainContext strcuture
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
2001-06-30 21:56:47 +02:00
|
|
|
* Return value: the new #GMainContext
|
2000-12-05 21:45:33 +01:00
|
|
|
**/
|
|
|
|
|
GMainContext *
|
2001-06-30 21:56:47 +02:00
|
|
|
g_main_context_new ()
|
2000-12-05 21:45:33 +01:00
|
|
|
{
|
2001-06-30 21:56:47 +02:00
|
|
|
GMainContext *context = g_new0 (GMainContext, 1);
|
2000-12-12 21:23:37 +01:00
|
|
|
|
|
|
|
|
#ifdef G_THREADS_ENABLED
|
2001-06-30 21:56:47 +02:00
|
|
|
g_static_mutex_init (&context->mutex);
|
2000-12-12 21:23:37 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
context->owner = NULL;
|
|
|
|
|
context->waiters = NULL;
|
2004-02-14 01:23:36 +01:00
|
|
|
|
2004-02-26 00:48:22 +01:00
|
|
|
# ifndef G_OS_WIN32
|
2004-02-14 01:23:36 +01:00
|
|
|
context->wake_up_pipe[0] = -1;
|
|
|
|
|
context->wake_up_pipe[1] = -1;
|
2004-02-26 00:48:22 +01:00
|
|
|
# else
|
|
|
|
|
context->wake_up_semaphore = NULL;
|
|
|
|
|
# endif
|
2004-02-18 10:14:17 +01:00
|
|
|
#endif
|
2004-02-14 01:23:36 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
context->ref_count = 1;
|
|
|
|
|
|
2002-08-06 16:50:52 +02:00
|
|
|
context->next_id = 1;
|
|
|
|
|
|
|
|
|
|
context->source_list = NULL;
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
#if HAVE_POLL
|
2002-08-06 16:50:52 +02:00
|
|
|
context->poll_func = (GPollFunc)poll;
|
2000-12-05 21:45:33 +01:00
|
|
|
#else
|
2002-08-06 16:50:52 +02:00
|
|
|
context->poll_func = g_poll;
|
2000-12-05 21:45:33 +01:00
|
|
|
#endif
|
2002-08-06 16:50:52 +02:00
|
|
|
|
|
|
|
|
context->cached_poll_array = NULL;
|
|
|
|
|
context->cached_poll_array_size = 0;
|
|
|
|
|
|
|
|
|
|
context->pending_dispatches = g_ptr_array_new ();
|
|
|
|
|
|
|
|
|
|
context->time_is_current = FALSE;
|
|
|
|
|
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
#ifdef G_THREADS_ENABLED
|
2002-08-06 16:50:52 +02:00
|
|
|
if (g_thread_supported ())
|
|
|
|
|
g_main_context_init_pipe (context);
|
|
|
|
|
else
|
|
|
|
|
main_contexts_without_pipe = g_slist_prepend (main_contexts_without_pipe,
|
|
|
|
|
context);
|
2000-12-05 21:45:33 +01:00
|
|
|
#endif
|
|
|
|
|
|
2004-02-14 01:23:36 +01:00
|
|
|
G_LOCK (main_context_list);
|
|
|
|
|
main_context_list = g_slist_append (main_context_list, context);
|
|
|
|
|
G_UNLOCK (main_context_list);
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
return context;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_main_context_default:
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Returns the default main context. This is the main context used
|
2000-12-05 21:45:33 +01:00
|
|
|
* for main loop functions when a main loop is not explicitly
|
|
|
|
|
* specified.
|
|
|
|
|
*
|
|
|
|
|
* Return value: the default main context.
|
|
|
|
|
**/
|
|
|
|
|
GMainContext *
|
|
|
|
|
g_main_context_default (void)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
/* Slow, but safe */
|
|
|
|
|
|
1998-12-16 06:38:35 +01:00
|
|
|
G_LOCK (main_loop);
|
1998-12-15 06:28:02 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (!default_main_context)
|
2001-06-30 21:56:47 +02:00
|
|
|
default_main_context = g_main_context_new ();
|
1998-12-15 06:28:02 +01:00
|
|
|
|
1998-12-16 06:38:35 +01:00
|
|
|
G_UNLOCK (main_loop);
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
return default_main_context;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/* Hooks for adding to the main loop */
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_source_new:
|
|
|
|
|
* @source_funcs: structure containing functions that implement
|
|
|
|
|
* the sources behavior.
|
2001-12-16 20:31:36 +01:00
|
|
|
* @struct_size: size of the #GSource structure to create.
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Creates a new #GSource structure. The size is specified to
|
|
|
|
|
* allow creating structures derived from #GSource that contain
|
2000-12-05 21:45:33 +01:00
|
|
|
* additional data. The size passed in must be at least
|
2001-12-16 20:31:36 +01:00
|
|
|
* <literal>sizeof (GSource)</literal>.
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
|
|
|
|
* The source will not initially be associated with any #GMainContext
|
Remove references to nonexisting functions
* glib/gmain.c: Remove references to nonexisting functions
g_source_set_callback_closure(), g_source_poll(), g_source_add()
from docs.
* glib/gdir.c (g_dir_open): Typo fix in docs.
* glib/gasyncqueue.c (g_async_queue_lock):
(g_async_queue_unref_and_unlock): Fix markup to avoid erroneous
<link>s in docs.
* glib/gwin32.c: Escape #'s leading to erroneous <link>s in docs.
* glib/gtree.c: Replace some occurances of Gtree by GTree in docs.
* glib/gstring.c (g_string_insert_unichar): Typo fix in docs.
* glib/tmpl/conversions.sgml: Add GIConv.
* glib/tmpl/main.sgml: Fix references to nonexisting functions
g_main_loop_destroy(), g_source_add(), g_source_connect().
* glib/glib-sections.txt: Add GIConv, g_str_has_prefix, g_str_has_suffix.
* glib/tmpl/linked_lists_single.sgml:
* glib/tmpl/linked_lists_double.sgml: GListAllocator doesn't exist.
* glib/glib-docs.sgml: Declare hash entity.
* glib/tmpl/macros.sgml: Escape # in #ifdef to suppress erroneous links.
* gobject/Makefile.am, gobject/gobject-docs.sgml, gobject/tmpl/*:
* glib/Makefile.am, glib/glib-docs.sgml, glib/tmpl/*: Produce XML,
not SGML.
2002-05-27 00:46:28 +02:00
|
|
|
* and must be added to one with g_source_attach() before it will be
|
2000-12-05 21:45:33 +01:00
|
|
|
* executed.
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Return value: the newly-created #GSource.
|
2000-12-05 21:45:33 +01:00
|
|
|
**/
|
|
|
|
|
GSource *
|
|
|
|
|
g_source_new (GSourceFuncs *source_funcs,
|
|
|
|
|
guint struct_size)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
GSource *source;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (source_funcs != NULL, NULL);
|
|
|
|
|
g_return_val_if_fail (struct_size >= sizeof (GSource), NULL);
|
1998-12-15 06:28:02 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
source = (GSource*) g_malloc0 (struct_size);
|
|
|
|
|
|
|
|
|
|
source->source_funcs = source_funcs;
|
|
|
|
|
source->ref_count = 1;
|
1998-12-15 06:28:02 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
source->priority = G_PRIORITY_DEFAULT;
|
1998-12-15 06:28:02 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
source->flags = G_HOOK_FLAG_ACTIVE;
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/* NULL/0 initialization for all other fields */
|
|
|
|
|
|
|
|
|
|
return source;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/* Holds context's lock
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
g_source_list_add (GSource *source,
|
|
|
|
|
GMainContext *context)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
GSource *tmp_source, *last_source;
|
|
|
|
|
|
|
|
|
|
last_source = NULL;
|
|
|
|
|
tmp_source = context->source_list;
|
|
|
|
|
while (tmp_source && tmp_source->priority <= source->priority)
|
|
|
|
|
{
|
|
|
|
|
last_source = tmp_source;
|
|
|
|
|
tmp_source = tmp_source->next;
|
|
|
|
|
}
|
1998-12-17 05:06:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
source->next = tmp_source;
|
|
|
|
|
if (tmp_source)
|
|
|
|
|
tmp_source->prev = source;
|
|
|
|
|
|
|
|
|
|
source->prev = last_source;
|
|
|
|
|
if (last_source)
|
|
|
|
|
last_source->next = source;
|
|
|
|
|
else
|
|
|
|
|
context->source_list = source;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/* Holds context's lock
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
g_source_list_remove (GSource *source,
|
|
|
|
|
GMainContext *context)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
if (source->prev)
|
|
|
|
|
source->prev->next = source->next;
|
|
|
|
|
else
|
|
|
|
|
context->source_list = source->next;
|
1998-12-15 06:28:02 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (source->next)
|
|
|
|
|
source->next->prev = source->prev;
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
source->prev = NULL;
|
|
|
|
|
source->next = NULL;
|
1999-01-17 05:49:43 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_source_attach:
|
|
|
|
|
* @source: a #GSource
|
|
|
|
|
* @context: a #GMainContext (if %NULL, the default context will be used)
|
|
|
|
|
*
|
|
|
|
|
* Adds a #GSource to a @context so that it will be executed within
|
|
|
|
|
* that context.
|
|
|
|
|
*
|
|
|
|
|
* Return value: the ID for the source within the #GMainContext
|
|
|
|
|
**/
|
|
|
|
|
guint
|
|
|
|
|
g_source_attach (GSource *source,
|
|
|
|
|
GMainContext *context)
|
1999-01-17 05:49:43 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
guint result = 0;
|
|
|
|
|
GSList *tmp_list;
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
g_return_val_if_fail (source->context == NULL, 0);
|
|
|
|
|
g_return_val_if_fail (!SOURCE_DESTROYED (source), 0);
|
|
|
|
|
|
|
|
|
|
if (!context)
|
|
|
|
|
context = g_main_context_default ();
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
LOCK_CONTEXT (context);
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
source->context = context;
|
2001-11-29 00:51:51 +01:00
|
|
|
result = source->source_id = context->next_id++;
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-07 21:29:58 +01:00
|
|
|
source->ref_count++;
|
2000-12-05 21:45:33 +01:00
|
|
|
g_source_list_add (source, context);
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
tmp_list = source->poll_fds;
|
|
|
|
|
while (tmp_list)
|
|
|
|
|
{
|
|
|
|
|
g_main_context_add_poll_unlocked (context, source->priority, tmp_list->data);
|
|
|
|
|
tmp_list = tmp_list->next;
|
|
|
|
|
}
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
#ifdef G_THREADS_ENABLED
|
|
|
|
|
/* Now wake up the main loop if it is waiting in the poll() */
|
2001-06-30 21:56:47 +02:00
|
|
|
g_main_context_wakeup_unlocked (context);
|
2000-12-05 21:45:33 +01:00
|
|
|
#endif
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
UNLOCK_CONTEXT (context);
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
return result;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
static void
|
|
|
|
|
g_source_destroy_internal (GSource *source,
|
|
|
|
|
GMainContext *context,
|
|
|
|
|
gboolean have_lock)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
if (!have_lock)
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
if (!SOURCE_DESTROYED (source))
|
|
|
|
|
{
|
2000-12-10 17:02:48 +01:00
|
|
|
GSList *tmp_list;
|
2000-12-05 21:45:33 +01:00
|
|
|
gpointer old_cb_data;
|
|
|
|
|
GSourceCallbackFuncs *old_cb_funcs;
|
|
|
|
|
|
|
|
|
|
source->flags &= ~G_HOOK_FLAG_ACTIVE;
|
1998-12-17 05:06:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
old_cb_data = source->callback_data;
|
|
|
|
|
old_cb_funcs = source->callback_funcs;
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
source->callback_data = NULL;
|
|
|
|
|
source->callback_funcs = NULL;
|
2000-08-31 22:56:42 +02:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (old_cb_funcs)
|
|
|
|
|
{
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
old_cb_funcs->unref (old_cb_data);
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
}
|
2004-03-19 21:25:03 +01:00
|
|
|
|
|
|
|
|
if (!SOURCE_BLOCKED (source))
|
2000-12-10 17:02:48 +01:00
|
|
|
{
|
2004-03-19 21:25:03 +01:00
|
|
|
tmp_list = source->poll_fds;
|
|
|
|
|
while (tmp_list)
|
|
|
|
|
{
|
|
|
|
|
g_main_context_remove_poll_unlocked (context, tmp_list->data);
|
|
|
|
|
tmp_list = tmp_list->next;
|
|
|
|
|
}
|
2000-12-10 17:02:48 +01:00
|
|
|
}
|
2004-03-19 21:25:03 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
g_source_unref_internal (source, context, TRUE);
|
|
|
|
|
}
|
Merge in current Win32 version. Almost no Unix code touched.
* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
1999-01-17 00:46:42 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (!have_lock)
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_source_destroy:
|
|
|
|
|
* @source: a #GSource
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Removes a source from its #GMainContext, if any, and mark it as
|
2000-12-05 21:45:33 +01:00
|
|
|
* destroyed. The source cannot be subsequently added to another
|
|
|
|
|
* context.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_source_destroy (GSource *source)
|
|
|
|
|
{
|
|
|
|
|
GMainContext *context;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (source != NULL);
|
|
|
|
|
|
|
|
|
|
context = source->context;
|
|
|
|
|
|
|
|
|
|
if (context)
|
|
|
|
|
g_source_destroy_internal (source, context, FALSE);
|
|
|
|
|
else
|
|
|
|
|
source->flags &= ~G_HOOK_FLAG_ACTIVE;
|
|
|
|
|
}
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_source_get_id:
|
|
|
|
|
* @source: a #GSource
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Returns the numeric ID for a particular source. The ID of a source
|
2000-12-05 21:45:33 +01:00
|
|
|
* is unique within a particular main loop context. The reverse
|
|
|
|
|
* mapping from ID to source is done by g_main_context_find_source_by_id().
|
|
|
|
|
*
|
|
|
|
|
* Return value: the ID for the source
|
|
|
|
|
**/
|
|
|
|
|
guint
|
|
|
|
|
g_source_get_id (GSource *source)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
guint result;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (source != NULL, 0);
|
|
|
|
|
g_return_val_if_fail (source->context != NULL, 0);
|
|
|
|
|
|
|
|
|
|
LOCK_CONTEXT (source->context);
|
2001-11-29 00:51:51 +01:00
|
|
|
result = source->source_id;
|
2000-12-05 21:45:33 +01:00
|
|
|
UNLOCK_CONTEXT (source->context);
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_source_get_context:
|
|
|
|
|
* @source: a #GSource
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Gets the #GMainContext with which the source is associated.
|
2000-12-05 21:45:33 +01:00
|
|
|
* Calling this function on a destroyed source is an error.
|
|
|
|
|
*
|
|
|
|
|
* Return value: the #GMainContext with which the source is associated,
|
|
|
|
|
* or %NULL if the context has not yet been added
|
|
|
|
|
* to a source.
|
|
|
|
|
**/
|
|
|
|
|
GMainContext *
|
|
|
|
|
g_source_get_context (GSource *source)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (!SOURCE_DESTROYED (source), NULL);
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
return source->context;
|
|
|
|
|
}
|
1998-12-15 06:28:02 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
2001-02-22 16:39:57 +01:00
|
|
|
* g_source_add_poll:
|
2000-12-05 21:45:33 +01:00
|
|
|
* @source:a #GSource
|
|
|
|
|
* @fd: a #GPollFD structure holding information about a file
|
|
|
|
|
* descriptor to watch.
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Adds a file descriptor to the set of file descriptors polled for
|
2000-12-05 21:45:33 +01:00
|
|
|
* this source. This is usually combined with g_source_new() to add an
|
|
|
|
|
* event source. The event source's check function will typically test
|
2001-12-16 20:31:36 +01:00
|
|
|
* the @revents field in the #GPollFD struct and return %TRUE if events need
|
2000-12-05 21:45:33 +01:00
|
|
|
* to be processed.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_source_add_poll (GSource *source,
|
|
|
|
|
GPollFD *fd)
|
|
|
|
|
{
|
|
|
|
|
GMainContext *context;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (source != NULL);
|
|
|
|
|
g_return_if_fail (fd != NULL);
|
Warn if no callback. Call callback correctly. (g_io_win32_create_watch):
2000-12-14 Tor Lillqvist <tml@iki.fi>
* giowin32.c (g_io_win32_dispatch): Warn if no callback. Call
callback correctly.
(g_io_win32_create_watch): Fix typo.
(g_io_win32_fd_create_watch): Ditto.
(g_io_channel_unix_new): If it is a file descriptor (i.e., a Unix
fd lookalike provided by the C library), call
g_io_channel_win32_new_fd(). If it is a socket (from WinSock),
call g_io_cahnnel_win32_new_stream_socket(). Hopefully sockets and
fds don't overlap. TODO: Implement also datagram sockets.
(g_io_channel_win32_poll): Call g_main_context_get_poll_func().
* gcompletion.h: Include <unistd.h> only on Unix. Is this
inclusion really needed here? OTOH, do include <stddef.h>, for
size_t.
* gmessages.c: (Win32) Don't define a function called "write" that
might clash with the prototype from <io.h>, use a #define.
* glib.def: Update.
* gmain.c (g_source_add_poll): Don't return a value from void
function.
(g_main_context_get_poll_func): Compile also for non-Win32, as
presumably was intended. The result var is a GPollFunc, not a
GPollFunc*. Return the result!
gobject:
2000-12-14 Tor Lillqvist <tml@iki.fi>
* makefile.mingw.in: Update, include parts from Makefile.am to
build gmarshal.[ch]. Some day, we won't need these separate
makefiles for Win32 compilation. I hope.
* makefile.msc.in: Update. No use trying to build gmarshal.[ch]
here, it would require Unixish tools. MSVC users building from CVS
sources are out of luck.
* gobject.def: Update.
2000-12-14 22:02:20 +01:00
|
|
|
g_return_if_fail (!SOURCE_DESTROYED (source));
|
2000-12-10 17:02:48 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
context = source->context;
|
1998-12-15 06:28:02 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (context)
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
source->poll_fds = g_slist_prepend (source->poll_fds, fd);
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (context)
|
|
|
|
|
{
|
2004-03-19 21:25:03 +01:00
|
|
|
if (!SOURCE_BLOCKED (source))
|
|
|
|
|
g_main_context_add_poll_unlocked (context, source->priority, fd);
|
2000-12-05 21:45:33 +01:00
|
|
|
UNLOCK_CONTEXT (context);
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2001-02-22 16:39:57 +01:00
|
|
|
/**
|
|
|
|
|
* g_source_remove_poll:
|
|
|
|
|
* @source:a #GSource
|
Remove references to nonexisting functions
* glib/gmain.c: Remove references to nonexisting functions
g_source_set_callback_closure(), g_source_poll(), g_source_add()
from docs.
* glib/gdir.c (g_dir_open): Typo fix in docs.
* glib/gasyncqueue.c (g_async_queue_lock):
(g_async_queue_unref_and_unlock): Fix markup to avoid erroneous
<link>s in docs.
* glib/gwin32.c: Escape #'s leading to erroneous <link>s in docs.
* glib/gtree.c: Replace some occurances of Gtree by GTree in docs.
* glib/gstring.c (g_string_insert_unichar): Typo fix in docs.
* glib/tmpl/conversions.sgml: Add GIConv.
* glib/tmpl/main.sgml: Fix references to nonexisting functions
g_main_loop_destroy(), g_source_add(), g_source_connect().
* glib/glib-sections.txt: Add GIConv, g_str_has_prefix, g_str_has_suffix.
* glib/tmpl/linked_lists_single.sgml:
* glib/tmpl/linked_lists_double.sgml: GListAllocator doesn't exist.
* glib/glib-docs.sgml: Declare hash entity.
* glib/tmpl/macros.sgml: Escape # in #ifdef to suppress erroneous links.
* gobject/Makefile.am, gobject/gobject-docs.sgml, gobject/tmpl/*:
* glib/Makefile.am, glib/glib-docs.sgml, glib/tmpl/*: Produce XML,
not SGML.
2002-05-27 00:46:28 +02:00
|
|
|
* @fd: a #GPollFD structure previously passed to g_source_add_poll().
|
2001-02-22 16:39:57 +01:00
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Removes a file descriptor from the set of file descriptors polled for
|
2001-02-22 16:39:57 +01:00
|
|
|
* this source.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_source_remove_poll (GSource *source,
|
|
|
|
|
GPollFD *fd)
|
|
|
|
|
{
|
|
|
|
|
GMainContext *context;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (source != NULL);
|
|
|
|
|
g_return_if_fail (fd != NULL);
|
|
|
|
|
g_return_if_fail (!SOURCE_DESTROYED (source));
|
|
|
|
|
|
|
|
|
|
context = source->context;
|
|
|
|
|
|
|
|
|
|
if (context)
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
source->poll_fds = g_slist_remove (source->poll_fds, fd);
|
|
|
|
|
|
|
|
|
|
if (context)
|
|
|
|
|
{
|
2004-03-19 21:25:03 +01:00
|
|
|
if (!SOURCE_BLOCKED (source))
|
|
|
|
|
g_main_context_remove_poll_unlocked (context, fd);
|
2001-02-22 16:39:57 +01:00
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_source_set_callback_indirect:
|
|
|
|
|
* @source: the source
|
|
|
|
|
* @callback_data: pointer to callback data "object"
|
2001-12-16 20:31:36 +01:00
|
|
|
* @callback_funcs: functions for reference counting @callback_data
|
2000-12-05 21:45:33 +01:00
|
|
|
* and getting the callback and data
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Sets the callback function storing the data as a refcounted callback
|
Remove references to nonexisting functions
* glib/gmain.c: Remove references to nonexisting functions
g_source_set_callback_closure(), g_source_poll(), g_source_add()
from docs.
* glib/gdir.c (g_dir_open): Typo fix in docs.
* glib/gasyncqueue.c (g_async_queue_lock):
(g_async_queue_unref_and_unlock): Fix markup to avoid erroneous
<link>s in docs.
* glib/gwin32.c: Escape #'s leading to erroneous <link>s in docs.
* glib/gtree.c: Replace some occurances of Gtree by GTree in docs.
* glib/gstring.c (g_string_insert_unichar): Typo fix in docs.
* glib/tmpl/conversions.sgml: Add GIConv.
* glib/tmpl/main.sgml: Fix references to nonexisting functions
g_main_loop_destroy(), g_source_add(), g_source_connect().
* glib/glib-sections.txt: Add GIConv, g_str_has_prefix, g_str_has_suffix.
* glib/tmpl/linked_lists_single.sgml:
* glib/tmpl/linked_lists_double.sgml: GListAllocator doesn't exist.
* glib/glib-docs.sgml: Declare hash entity.
* glib/tmpl/macros.sgml: Escape # in #ifdef to suppress erroneous links.
* gobject/Makefile.am, gobject/gobject-docs.sgml, gobject/tmpl/*:
* glib/Makefile.am, glib/glib-docs.sgml, glib/tmpl/*: Produce XML,
not SGML.
2002-05-27 00:46:28 +02:00
|
|
|
* "object". This is used internally. Note that calling
|
|
|
|
|
* g_source_set_callback_indirect() assumes
|
2000-12-05 21:45:33 +01:00
|
|
|
* an initial reference count on @callback_data, and thus
|
|
|
|
|
* @callback_funcs->unref will eventually be called once more
|
|
|
|
|
* than @callback_funcs->ref.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_source_set_callback_indirect (GSource *source,
|
|
|
|
|
gpointer callback_data,
|
|
|
|
|
GSourceCallbackFuncs *callback_funcs)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
GMainContext *context;
|
|
|
|
|
gpointer old_cb_data;
|
|
|
|
|
GSourceCallbackFuncs *old_cb_funcs;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (source != NULL);
|
|
|
|
|
g_return_if_fail (callback_funcs != NULL || callback_data == NULL);
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
context = source->context;
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (context)
|
|
|
|
|
LOCK_CONTEXT (context);
|
1998-12-15 06:28:02 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
old_cb_data = source->callback_data;
|
|
|
|
|
old_cb_funcs = source->callback_funcs;
|
1999-07-24 20:50:58 +02:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
source->callback_data = callback_data;
|
|
|
|
|
source->callback_funcs = callback_funcs;
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (context)
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
if (old_cb_funcs)
|
|
|
|
|
old_cb_funcs->unref (old_cb_data);
|
|
|
|
|
}
|
1998-12-18 03:23:33 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
static void
|
|
|
|
|
g_source_callback_ref (gpointer cb_data)
|
|
|
|
|
{
|
|
|
|
|
GSourceCallback *callback = cb_data;
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
callback->ref_count++;
|
|
|
|
|
}
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
g_source_callback_unref (gpointer cb_data)
|
|
|
|
|
{
|
|
|
|
|
GSourceCallback *callback = cb_data;
|
|
|
|
|
|
|
|
|
|
callback->ref_count--;
|
|
|
|
|
if (callback->ref_count == 0)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
if (callback->notify)
|
|
|
|
|
callback->notify (callback->data);
|
2001-01-23 08:35:52 +01:00
|
|
|
g_free (callback);
|
2000-12-05 21:45:33 +01:00
|
|
|
}
|
|
|
|
|
}
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
static void
|
|
|
|
|
g_source_callback_get (gpointer cb_data,
|
2001-09-04 00:12:51 +02:00
|
|
|
GSource *source,
|
2000-12-05 21:45:33 +01:00
|
|
|
GSourceFunc *func,
|
|
|
|
|
gpointer *data)
|
|
|
|
|
{
|
|
|
|
|
GSourceCallback *callback = cb_data;
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
*func = callback->func;
|
|
|
|
|
*data = callback->data;
|
|
|
|
|
}
|
1999-02-02 02:04:41 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
static GSourceCallbackFuncs g_source_callback_funcs = {
|
|
|
|
|
g_source_callback_ref,
|
|
|
|
|
g_source_callback_unref,
|
|
|
|
|
g_source_callback_get,
|
|
|
|
|
};
|
1999-02-02 02:04:41 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_source_set_callback:
|
|
|
|
|
* @source: the source
|
|
|
|
|
* @func: a callback function
|
|
|
|
|
* @data: the data to pass to callback function
|
|
|
|
|
* @notify: a function to call when @data is no longer in use, or %NULL.
|
|
|
|
|
*
|
2002-09-01 15:04:02 +02:00
|
|
|
* Sets the callback function for a source. The callback for a source is
|
|
|
|
|
* called from the source's dispatch function.
|
|
|
|
|
*
|
|
|
|
|
* The exact type of @func depends on the type of source; ie. you
|
|
|
|
|
* should not count on @func being called with @data as its first
|
|
|
|
|
* parameter.
|
|
|
|
|
*
|
|
|
|
|
* Typically, you won't use this function. Instead use functions specific
|
|
|
|
|
* to the type of source you are using.
|
2000-12-05 21:45:33 +01:00
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_source_set_callback (GSource *source,
|
|
|
|
|
GSourceFunc func,
|
|
|
|
|
gpointer data,
|
|
|
|
|
GDestroyNotify notify)
|
|
|
|
|
{
|
|
|
|
|
GSourceCallback *new_callback;
|
1999-02-02 02:04:41 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
g_return_if_fail (source != NULL);
|
1998-12-18 03:23:33 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
new_callback = g_new (GSourceCallback, 1);
|
2001-01-23 08:35:52 +01:00
|
|
|
|
|
|
|
|
new_callback->ref_count = 1;
|
2000-12-05 21:45:33 +01:00
|
|
|
new_callback->func = func;
|
|
|
|
|
new_callback->data = data;
|
|
|
|
|
new_callback->notify = notify;
|
|
|
|
|
|
|
|
|
|
g_source_set_callback_indirect (source, new_callback, &g_source_callback_funcs);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_source_set_priority:
|
|
|
|
|
* @source: a #GSource
|
|
|
|
|
* @priority: the new priority.
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Sets the priority of a source. While the main loop is being
|
2002-03-05 23:56:49 +01:00
|
|
|
* run, a source will be dispatched if it is ready to be dispatched and no sources
|
|
|
|
|
* at a higher (numerically smaller) priority are ready to be dispatched.
|
2000-12-05 21:45:33 +01:00
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_source_set_priority (GSource *source,
|
|
|
|
|
gint priority)
|
|
|
|
|
{
|
|
|
|
|
GSList *tmp_list;
|
|
|
|
|
GMainContext *context;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (source != NULL);
|
|
|
|
|
|
|
|
|
|
context = source->context;
|
|
|
|
|
|
|
|
|
|
if (context)
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
source->priority = priority;
|
|
|
|
|
|
|
|
|
|
if (context)
|
|
|
|
|
{
|
2004-03-19 21:25:03 +01:00
|
|
|
/* Remove the source from the context's source and then
|
|
|
|
|
* add it back so it is sorted in the correct plcae
|
|
|
|
|
*/
|
|
|
|
|
g_source_list_remove (source, source->context);
|
|
|
|
|
g_source_list_add (source, source->context);
|
|
|
|
|
|
|
|
|
|
if (!SOURCE_BLOCKED (source))
|
2000-12-05 21:45:33 +01:00
|
|
|
{
|
2004-03-19 21:25:03 +01:00
|
|
|
tmp_list = source->poll_fds;
|
|
|
|
|
while (tmp_list)
|
|
|
|
|
{
|
|
|
|
|
g_main_context_remove_poll_unlocked (context, tmp_list->data);
|
|
|
|
|
g_main_context_add_poll_unlocked (context, priority, tmp_list->data);
|
|
|
|
|
|
|
|
|
|
tmp_list = tmp_list->next;
|
|
|
|
|
}
|
2000-12-05 21:45:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
UNLOCK_CONTEXT (source->context);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_source_get_priority:
|
|
|
|
|
* @source: a #GSource
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Gets the priority of a source.
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
|
|
|
|
* Return value: the priority of the source
|
|
|
|
|
**/
|
|
|
|
|
gint
|
|
|
|
|
g_source_get_priority (GSource *source)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (source != NULL, 0);
|
|
|
|
|
|
|
|
|
|
return source->priority;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_source_set_can_recurse:
|
|
|
|
|
* @source: a #GSource
|
|
|
|
|
* @can_recurse: whether recursion is allowed for this source
|
|
|
|
|
*
|
|
|
|
|
* Sets whether a source can be called recursively. If @can_recurse is
|
|
|
|
|
* %TRUE, then while the source is being dispatched then this source
|
|
|
|
|
* will be processed normally. Otherwise, all processing of this
|
|
|
|
|
* source is blocked until the dispatch function returns.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_source_set_can_recurse (GSource *source,
|
|
|
|
|
gboolean can_recurse)
|
|
|
|
|
{
|
|
|
|
|
GMainContext *context;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (source != NULL);
|
|
|
|
|
|
|
|
|
|
context = source->context;
|
|
|
|
|
|
|
|
|
|
if (context)
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
if (can_recurse)
|
|
|
|
|
source->flags |= G_SOURCE_CAN_RECURSE;
|
|
|
|
|
else
|
|
|
|
|
source->flags &= ~G_SOURCE_CAN_RECURSE;
|
|
|
|
|
|
|
|
|
|
if (context)
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_source_get_can_recurse:
|
|
|
|
|
* @source: a #GSource
|
|
|
|
|
*
|
|
|
|
|
* Checks whether a source is allowed to be called recursively.
|
2001-12-16 20:31:36 +01:00
|
|
|
* see g_source_set_can_recurse().
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
|
|
|
|
* Return value: whether recursion is allowed.
|
|
|
|
|
**/
|
|
|
|
|
gboolean
|
|
|
|
|
g_source_get_can_recurse (GSource *source)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (source != NULL, FALSE);
|
|
|
|
|
|
|
|
|
|
return (source->flags & G_SOURCE_CAN_RECURSE) != 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_source_ref:
|
|
|
|
|
* @source: a #GSource
|
|
|
|
|
*
|
|
|
|
|
* Increases the reference count on a source by one.
|
|
|
|
|
*
|
|
|
|
|
* Return value: @source
|
|
|
|
|
**/
|
|
|
|
|
GSource *
|
|
|
|
|
g_source_ref (GSource *source)
|
|
|
|
|
{
|
|
|
|
|
GMainContext *context;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (source != NULL, NULL);
|
|
|
|
|
|
|
|
|
|
context = source->context;
|
|
|
|
|
|
|
|
|
|
if (context)
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
source->ref_count++;
|
|
|
|
|
|
|
|
|
|
if (context)
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
return source;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* g_source_unref() but possible to call within context lock
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
g_source_unref_internal (GSource *source,
|
|
|
|
|
GMainContext *context,
|
|
|
|
|
gboolean have_lock)
|
|
|
|
|
{
|
2001-01-03 17:05:39 +01:00
|
|
|
gpointer old_cb_data = NULL;
|
|
|
|
|
GSourceCallbackFuncs *old_cb_funcs = NULL;
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
g_return_if_fail (source != NULL);
|
|
|
|
|
|
|
|
|
|
if (!have_lock && context)
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
source->ref_count--;
|
|
|
|
|
if (source->ref_count == 0)
|
|
|
|
|
{
|
2001-01-03 17:05:39 +01:00
|
|
|
old_cb_data = source->callback_data;
|
|
|
|
|
old_cb_funcs = source->callback_funcs;
|
|
|
|
|
|
|
|
|
|
source->callback_data = NULL;
|
|
|
|
|
source->callback_funcs = NULL;
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (context && !SOURCE_DESTROYED (source))
|
|
|
|
|
{
|
|
|
|
|
g_warning (G_STRLOC ": ref_count == 0, but source is still attached to a context!");
|
|
|
|
|
source->ref_count++;
|
|
|
|
|
}
|
2000-12-10 17:02:48 +01:00
|
|
|
else if (context)
|
|
|
|
|
g_source_list_remove (source, context);
|
|
|
|
|
|
2001-06-30 22:06:16 +02:00
|
|
|
if (source->source_funcs->finalize)
|
|
|
|
|
source->source_funcs->finalize (source);
|
2000-12-10 17:02:48 +01:00
|
|
|
|
|
|
|
|
g_slist_free (source->poll_fds);
|
|
|
|
|
source->poll_fds = NULL;
|
|
|
|
|
g_free (source);
|
2000-12-05 21:45:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!have_lock && context)
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
2001-01-03 17:05:39 +01:00
|
|
|
if (old_cb_funcs)
|
2000-12-05 21:45:33 +01:00
|
|
|
{
|
|
|
|
|
if (have_lock)
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
2001-01-03 17:05:39 +01:00
|
|
|
old_cb_funcs->unref (old_cb_data);
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
if (have_lock)
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_source_unref:
|
|
|
|
|
* @source: a #GSource
|
|
|
|
|
*
|
|
|
|
|
* Decreases the reference count of a source by one. If the
|
|
|
|
|
* resulting reference count is zero the source and associated
|
|
|
|
|
* memory will be destroyed.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_source_unref (GSource *source)
|
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (source != NULL);
|
|
|
|
|
|
|
|
|
|
g_source_unref_internal (source, source->context, FALSE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_main_context_find_source_by_id:
|
|
|
|
|
* @context: a #GMainContext (if %NULL, the default context will be used)
|
2001-11-29 00:51:51 +01:00
|
|
|
* @source_id: the source ID, as returned by g_source_get_id()
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
|
|
|
|
* Finds a #GSource given a pair of context and ID
|
|
|
|
|
*
|
|
|
|
|
* Return value: the #GSource if found, otherwise, %NULL
|
|
|
|
|
**/
|
|
|
|
|
GSource *
|
|
|
|
|
g_main_context_find_source_by_id (GMainContext *context,
|
2001-11-29 00:51:51 +01:00
|
|
|
guint source_id)
|
2000-12-05 21:45:33 +01:00
|
|
|
{
|
|
|
|
|
GSource *source;
|
|
|
|
|
|
2003-03-06 23:41:03 +01:00
|
|
|
g_return_val_if_fail (source_id > 0, NULL);
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
if (context == NULL)
|
|
|
|
|
context = g_main_context_default ();
|
|
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
source = context->source_list;
|
|
|
|
|
while (source)
|
|
|
|
|
{
|
|
|
|
|
if (!SOURCE_DESTROYED (source) &&
|
2001-11-29 00:51:51 +01:00
|
|
|
source->source_id == source_id)
|
2000-12-05 21:45:33 +01:00
|
|
|
break;
|
|
|
|
|
source = source->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
return source;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_main_context_find_source_by_funcs_user_data:
|
|
|
|
|
* @context: a #GMainContext (if %NULL, the default context will be used).
|
|
|
|
|
* @funcs: the @source_funcs passed to g_source_new().
|
|
|
|
|
* @user_data: the user data from the callback.
|
|
|
|
|
*
|
|
|
|
|
* Finds a source with the given source functions and user data. If
|
|
|
|
|
* multiple sources exist with the same source function and user data,
|
|
|
|
|
* the first one found will be returned.
|
|
|
|
|
*
|
|
|
|
|
* Return value: the source, if one was found, otherwise %NULL
|
|
|
|
|
**/
|
|
|
|
|
GSource *
|
|
|
|
|
g_main_context_find_source_by_funcs_user_data (GMainContext *context,
|
|
|
|
|
GSourceFuncs *funcs,
|
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
GSource *source;
|
|
|
|
|
|
2003-03-06 23:41:03 +01:00
|
|
|
g_return_val_if_fail (funcs != NULL, NULL);
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
if (context == NULL)
|
|
|
|
|
context = g_main_context_default ();
|
|
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
source = context->source_list;
|
|
|
|
|
while (source)
|
|
|
|
|
{
|
|
|
|
|
if (!SOURCE_DESTROYED (source) &&
|
|
|
|
|
source->source_funcs == funcs &&
|
2001-09-19 22:39:21 +02:00
|
|
|
source->callback_funcs)
|
|
|
|
|
{
|
|
|
|
|
GSourceFunc callback;
|
|
|
|
|
gpointer callback_data;
|
|
|
|
|
|
|
|
|
|
source->callback_funcs->get (source->callback_data, source, &callback, &callback_data);
|
|
|
|
|
|
|
|
|
|
if (callback_data == user_data)
|
|
|
|
|
break;
|
|
|
|
|
}
|
2000-12-05 21:45:33 +01:00
|
|
|
source = source->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
return source;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_main_context_find_source_by_user_data:
|
|
|
|
|
* @context: a #GMainContext
|
|
|
|
|
* @user_data: the user_data for the callback.
|
|
|
|
|
*
|
|
|
|
|
* Finds a source with the given user data for the callback. If
|
|
|
|
|
* multiple sources exist with the same user data, the first
|
|
|
|
|
* one found will be returned.
|
|
|
|
|
*
|
|
|
|
|
* Return value: the source, if one was found, otherwise %NULL
|
|
|
|
|
**/
|
|
|
|
|
GSource *
|
|
|
|
|
g_main_context_find_source_by_user_data (GMainContext *context,
|
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
GSource *source;
|
|
|
|
|
|
|
|
|
|
if (context == NULL)
|
|
|
|
|
context = g_main_context_default ();
|
|
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
source = context->source_list;
|
|
|
|
|
while (source)
|
|
|
|
|
{
|
|
|
|
|
if (!SOURCE_DESTROYED (source) &&
|
2001-09-19 22:39:21 +02:00
|
|
|
source->callback_funcs)
|
|
|
|
|
{
|
|
|
|
|
GSourceFunc callback;
|
|
|
|
|
gpointer callback_data = NULL;
|
|
|
|
|
|
|
|
|
|
source->callback_funcs->get (source->callback_data, source, &callback, &callback_data);
|
|
|
|
|
|
|
|
|
|
if (callback_data == user_data)
|
|
|
|
|
break;
|
|
|
|
|
}
|
2000-12-05 21:45:33 +01:00
|
|
|
source = source->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
return source;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_source_remove:
|
|
|
|
|
* @tag: the id of the source to remove.
|
|
|
|
|
*
|
2004-02-14 01:23:36 +01:00
|
|
|
* Removes the source with the given id from the default main context. The id of
|
|
|
|
|
* a #GSource is given by g_source_get_id(), or will be returned by the
|
|
|
|
|
* functions g_source_attach(), g_idle_add(), g_idle_add_full(),
|
|
|
|
|
* g_timeout_add(), g_timeout_add_full(), g_child_watch_add(),
|
|
|
|
|
* g_child_watch_add_full(), g_io_add_watch(), and g_io_add_watch_full().
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
|
|
|
|
* See also g_source_destroy().
|
|
|
|
|
*
|
|
|
|
|
* Return value: %TRUE if the source was found and removed.
|
|
|
|
|
**/
|
|
|
|
|
gboolean
|
|
|
|
|
g_source_remove (guint tag)
|
|
|
|
|
{
|
|
|
|
|
GSource *source;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (tag > 0, FALSE);
|
|
|
|
|
|
|
|
|
|
source = g_main_context_find_source_by_id (NULL, tag);
|
|
|
|
|
if (source)
|
|
|
|
|
g_source_destroy (source);
|
|
|
|
|
|
|
|
|
|
return source != NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_source_remove_by_user_data:
|
|
|
|
|
* @user_data: the user_data for the callback.
|
|
|
|
|
*
|
|
|
|
|
* Removes a source from the default main loop context given the user
|
|
|
|
|
* data for the callback. If multiple sources exist with the same user
|
|
|
|
|
* data, only one will be destroyed.
|
|
|
|
|
*
|
|
|
|
|
* Return value: %TRUE if a source was found and removed.
|
|
|
|
|
**/
|
|
|
|
|
gboolean
|
|
|
|
|
g_source_remove_by_user_data (gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
GSource *source;
|
|
|
|
|
|
|
|
|
|
source = g_main_context_find_source_by_user_data (NULL, user_data);
|
|
|
|
|
if (source)
|
|
|
|
|
{
|
|
|
|
|
g_source_destroy (source);
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_source_remove_by_funcs_user_data:
|
|
|
|
|
* @funcs: The @source_funcs passed to g_source_new()
|
|
|
|
|
* @user_data: the user data for the callback
|
|
|
|
|
*
|
|
|
|
|
* Removes a source from the default main loop context given the
|
|
|
|
|
* source functions and user data. If multiple sources exist with the
|
|
|
|
|
* same source functions and user data, only one will be destroyed.
|
|
|
|
|
*
|
|
|
|
|
* Return value: %TRUE if a source was found and removed.
|
|
|
|
|
**/
|
|
|
|
|
gboolean
|
|
|
|
|
g_source_remove_by_funcs_user_data (GSourceFuncs *funcs,
|
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
GSource *source;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (funcs != NULL, FALSE);
|
|
|
|
|
|
|
|
|
|
source = g_main_context_find_source_by_funcs_user_data (NULL, funcs, user_data);
|
|
|
|
|
if (source)
|
|
|
|
|
{
|
|
|
|
|
g_source_destroy (source);
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_get_current_time:
|
|
|
|
|
* @result: #GTimeVal structure in which to store current time.
|
|
|
|
|
*
|
2003-07-25 23:32:47 +02:00
|
|
|
* Equivalent to the UNIX gettimeofday() function, but portable.
|
2000-12-05 21:45:33 +01:00
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_get_current_time (GTimeVal *result)
|
|
|
|
|
{
|
|
|
|
|
#ifndef G_OS_WIN32
|
|
|
|
|
struct timeval r;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (result != NULL);
|
|
|
|
|
|
|
|
|
|
/*this is required on alpha, there the timeval structs are int's
|
|
|
|
|
not longs and a cast only would fail horribly*/
|
|
|
|
|
gettimeofday (&r, NULL);
|
|
|
|
|
result->tv_sec = r.tv_sec;
|
|
|
|
|
result->tv_usec = r.tv_usec;
|
|
|
|
|
#else
|
|
|
|
|
/* Avoid calling time() except for the first time.
|
|
|
|
|
* GetTickCount() should be pretty fast and low-level?
|
|
|
|
|
* I could also use ftime() but it seems unnecessarily overheady.
|
|
|
|
|
*/
|
|
|
|
|
static DWORD start_tick = 0;
|
|
|
|
|
static time_t start_time;
|
|
|
|
|
DWORD tick;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (result != NULL);
|
|
|
|
|
|
|
|
|
|
if (start_tick == 0)
|
|
|
|
|
{
|
|
|
|
|
start_tick = GetTickCount ();
|
|
|
|
|
time (&start_time);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tick = GetTickCount ();
|
|
|
|
|
|
|
|
|
|
result->tv_sec = (tick - start_tick) / 1000 + start_time;
|
|
|
|
|
result->tv_usec = ((tick - start_tick) % 1000) * 1000;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Running the main loop */
|
|
|
|
|
|
2004-03-01 03:41:09 +01:00
|
|
|
static gint *
|
|
|
|
|
get_depth_pointer (void)
|
|
|
|
|
{
|
|
|
|
|
static GStaticPrivate depth_private = G_STATIC_PRIVATE_INIT;
|
|
|
|
|
gint *depth_pointer = g_static_private_get (&depth_private);
|
|
|
|
|
if (!depth_pointer)
|
|
|
|
|
{
|
|
|
|
|
depth_pointer = g_new (gint, 1);
|
|
|
|
|
*depth_pointer = 0;
|
|
|
|
|
g_static_private_set (&depth_private, depth_pointer, g_free);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return depth_pointer;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_main_depth:
|
|
|
|
|
*
|
|
|
|
|
* Return value: The main loop recursion level in the current thread
|
|
|
|
|
*
|
|
|
|
|
* Returns the depth of the stack of calls to
|
|
|
|
|
* g_main_context_dispatch() on any #GMainContext in the current thread.
|
|
|
|
|
* That is, when called from the toplevel, it gives 0. When
|
|
|
|
|
* called from within a callback from g_main_context_iteration()
|
|
|
|
|
* (or g_main_loop_run(), etc.) it returns 1. When called from within
|
|
|
|
|
* a callback to a recursive call to g_main_context_iterate(),
|
|
|
|
|
* it returns 2. And so forth.
|
|
|
|
|
*
|
|
|
|
|
* This function is useful in a situation like the following:
|
|
|
|
|
* Imagine an extremely simple "garbage collected" system.
|
|
|
|
|
*
|
|
|
|
|
* <example>
|
|
|
|
|
* static GList *free_list;
|
|
|
|
|
*
|
|
|
|
|
* gpointer
|
|
|
|
|
* allocate_memory (gsize size)
|
|
|
|
|
* {
|
|
|
|
|
* gpointer result = g_malloc (size);
|
|
|
|
|
* free_list = g_list_prepend (free_list, result);
|
|
|
|
|
* return result;
|
|
|
|
|
* }
|
|
|
|
|
*
|
|
|
|
|
* void
|
|
|
|
|
* free_allocated_memory (void)
|
|
|
|
|
* {
|
|
|
|
|
* GList *l;
|
|
|
|
|
* for (l = free_list; l; l = l->next);
|
|
|
|
|
* g_free (l->data);
|
|
|
|
|
* g_list_free (free_list);
|
|
|
|
|
* free_list = NULL;
|
|
|
|
|
* }
|
|
|
|
|
*
|
|
|
|
|
* [...]
|
|
|
|
|
*
|
|
|
|
|
* while (TRUE);
|
|
|
|
|
* {
|
|
|
|
|
* g_main_context_iteration (NULL, TRUE);
|
|
|
|
|
* free_allocated_memory();
|
|
|
|
|
* }
|
|
|
|
|
* </example>
|
|
|
|
|
*
|
|
|
|
|
* This works from an application, however, if you want to do the same
|
|
|
|
|
* thing from a library, it gets more difficult, since you no longer
|
|
|
|
|
* control the main loop. You might think you can simply use an idle
|
|
|
|
|
* function to make the call to free_allocated_memory(), but that
|
|
|
|
|
* doesn't work, since the idle function could be called from a
|
2004-03-01 03:45:15 +01:00
|
|
|
* recursive callback. This can be fixed by using g_main_depth()
|
2004-03-01 03:41:09 +01:00
|
|
|
*
|
|
|
|
|
* <example>
|
|
|
|
|
* gpointer
|
|
|
|
|
* allocate_memory (gsize size)
|
|
|
|
|
* {
|
|
|
|
|
* FreeListBlock *block = g_new (FreeListBlock, 1);\
|
|
|
|
|
* block->mem = g_malloc (size);
|
2004-03-01 03:45:15 +01:00
|
|
|
* block->depth = g_main_depth ();
|
2004-03-01 03:41:09 +01:00
|
|
|
* free_list = g_list_prepend (free_list, block);
|
|
|
|
|
* return block->mem;
|
|
|
|
|
* }
|
|
|
|
|
*
|
|
|
|
|
* void
|
|
|
|
|
* free_allocated_memory (void)
|
|
|
|
|
* {
|
|
|
|
|
* GList *l;
|
|
|
|
|
*
|
2004-03-01 03:45:15 +01:00
|
|
|
* int depth = g_main_depth ();
|
2004-03-01 03:41:09 +01:00
|
|
|
* for (l = free_list; l; );
|
|
|
|
|
* {
|
|
|
|
|
* GList *next = l->next;
|
|
|
|
|
* FreeListBlock *block = l->data;
|
2004-03-11 02:03:12 +01:00
|
|
|
* if (block->depth > depth)
|
2004-03-01 03:41:09 +01:00
|
|
|
* {
|
|
|
|
|
* g_free (block->mem);
|
|
|
|
|
* g_free (block);
|
|
|
|
|
* free_list = g_list_delete_link (free_list, l);
|
|
|
|
|
* }
|
|
|
|
|
*
|
|
|
|
|
* l = next;
|
|
|
|
|
* }
|
|
|
|
|
* }
|
|
|
|
|
* </example>
|
|
|
|
|
*
|
2004-03-01 03:45:15 +01:00
|
|
|
* There is a temptation to use g_main_depth() to solve
|
2004-03-01 03:41:09 +01:00
|
|
|
* problems with reentrancy. For instance, while waiting for data
|
|
|
|
|
* to be received from the network in response to a menu item,
|
|
|
|
|
* the menu item might be selected again. It might seem that
|
2004-03-01 15:20:30 +01:00
|
|
|
* one could make the menu item's callback return immediately
|
|
|
|
|
* and do nothing if g_main_depth() returns a value greater than 1.
|
|
|
|
|
* However, this should be avoided since the user then sees selecting
|
|
|
|
|
* the menu item do nothing. Furthermore, you'll find yourself adding
|
2004-03-01 03:41:09 +01:00
|
|
|
* these checks all over your code, since there are doubtless many,
|
|
|
|
|
* many things that the user could do. Instead, you can use the
|
|
|
|
|
* following techniques:
|
|
|
|
|
*
|
|
|
|
|
* <orderedlist>
|
|
|
|
|
* <listitem>
|
|
|
|
|
* <para>
|
|
|
|
|
* Use gtk_widget_set_sensitive() or modal dialogs to prevent
|
|
|
|
|
* the user from interacting with elements while the main
|
|
|
|
|
* loop is recursing.
|
|
|
|
|
* </para>
|
|
|
|
|
* </listitem>
|
|
|
|
|
* <listitem>
|
|
|
|
|
* <para>
|
|
|
|
|
* Avoid main loop recursion in situations where you can't handle
|
|
|
|
|
* arbitrary callbacks. Instead, structure your code so that you
|
|
|
|
|
* simply return to the main loop and then get called again when
|
|
|
|
|
* there is more work to do.
|
|
|
|
|
* </para>
|
|
|
|
|
* </listitem>
|
2004-03-02 01:05:36 +01:00
|
|
|
* </orderedlist>
|
2004-03-01 03:41:09 +01:00
|
|
|
**/
|
|
|
|
|
int
|
|
|
|
|
g_main_depth (void)
|
|
|
|
|
{
|
|
|
|
|
gint *depth = get_depth_pointer ();
|
|
|
|
|
return *depth;
|
|
|
|
|
}
|
|
|
|
|
|
2004-03-19 21:25:03 +01:00
|
|
|
/* Temporarily remove all this source's file descriptors from the
|
|
|
|
|
* poll(), so that if data comes available for one of the file descriptors
|
|
|
|
|
* we don't continually spin in the poll()
|
|
|
|
|
*/
|
|
|
|
|
/* HOLDS: source->context's lock */
|
|
|
|
|
void
|
|
|
|
|
block_source (GSource *source)
|
|
|
|
|
{
|
|
|
|
|
GSList *tmp_list;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (!SOURCE_BLOCKED (source));
|
|
|
|
|
|
|
|
|
|
tmp_list = source->poll_fds;
|
|
|
|
|
while (tmp_list)
|
|
|
|
|
{
|
|
|
|
|
g_main_context_remove_poll_unlocked (source->context, tmp_list->data);
|
|
|
|
|
tmp_list = tmp_list->next;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* HOLDS: source->context's lock */
|
|
|
|
|
void
|
|
|
|
|
unblock_source (GSource *source)
|
|
|
|
|
{
|
|
|
|
|
GSList *tmp_list;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (!SOURCE_BLOCKED (source)); /* Source already unblocked */
|
|
|
|
|
g_return_if_fail (!SOURCE_DESTROYED (source));
|
|
|
|
|
|
|
|
|
|
tmp_list = source->poll_fds;
|
|
|
|
|
while (tmp_list)
|
|
|
|
|
{
|
|
|
|
|
g_main_context_add_poll_unlocked (source->context, source->priority, tmp_list->data);
|
|
|
|
|
tmp_list = tmp_list->next;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/* HOLDS: context's lock */
|
|
|
|
|
static void
|
|
|
|
|
g_main_dispatch (GMainContext *context)
|
|
|
|
|
{
|
2004-03-01 03:41:09 +01:00
|
|
|
gint *depth = get_depth_pointer ();
|
Changes for 64-bit cleanliness, loosely based on patch from Mark Murnane.
Wed Jun 20 12:00:54 2001 Owen Taylor <otaylor@redhat.com>
Changes for 64-bit cleanliness, loosely based on patch
from Mark Murnane.
* gconvert.c (g_convert/g_convert_with_fallback): Remove
workarounds for since-fixed GNU libc bugs. Minor
doc fix.
* gconvert.[ch]: Change gint to gsize/gssize as
appropriate.
* gconvert.c (g_locale/filename_to/from_utf8): Fix incorrect
computation of bytes_read / bytes_written.
* gfileutils.[ch] (g_file_get_contents): Make length
out parameter 'gsize *len'.
* ghook.c (g_hook_compare_ids): Don't compare a
and b as 'a - b'.
* gmacros.h (GSIZE_TO_POINTER): Add GPOINTER_TO_SIZE,
GSIZE_TO_POINTER.
* gmain.c (g_timeout_prepare): Rewrite to avoid
overflows. (Fixes bug when system clock skews
backwards more than 24 days.)
* gmarkup.[ch]: Make lengths passed to callbacks
gsize, length for g_markup_parse-context_parse(),
g_markup_escape_text() gssize.
* gmessages.[ch] (g_printf_string_upper_bound): Change
return value to gsize.
* gmessages.c (printf_string_upper_bound): Remove
a ridiculous use of 'inline' on a 300 line function.
* gstring.[ch]: Represent size of string as a gsize,
not gint. Make parameters to functions take gsize,
or gssize where -1 is allowed.
* gstring.c (g_string_erase): Make
g_string_erase (string, pos, -1) a synonym for
g_string_truncate for consistency with other G*
APIs.
* gstrfuncs.[ch]: Make all functions taking a string
length, take a gsize, or gssize if -1 is allowed.
(g_strstr_len, g_strrstr_len). Also fix some boundary
conditions in g_str[r]str[_len].
* gutf8.c tests/unicode-encoding.c: Make parameters that
are byte lengths gsize, gssize as appropriate. Make
character offsets, other counts, glong.
* gasyncqueue.c gcompletion.c
timeloop.c timeloop-basic.c gutils.c gspawn.c.
Small 64 bit cleanliness fixups.
* glist.c (g_list_sort2, g_list_sort_real): Fix functions
that should have been static.
* gdate.c (g_date_fill_parse_tokens): Fix extra
declaration that was shadowing another.
* tests/module-test.c: Include string.h
Mon Jun 18 15:43:29 2001 Owen Taylor <otaylor@redhat.com>
* gutf8.c (g_get_charset): Make argument
G_CONST_RETURN char **.
2001-06-23 15:55:09 +02:00
|
|
|
guint i;
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
for (i = 0; i < context->pending_dispatches->len; i++)
|
|
|
|
|
{
|
|
|
|
|
GSource *source = context->pending_dispatches->pdata[i];
|
|
|
|
|
|
|
|
|
|
context->pending_dispatches->pdata[i] = NULL;
|
|
|
|
|
g_assert (source);
|
|
|
|
|
|
|
|
|
|
source->flags &= ~G_SOURCE_READY;
|
|
|
|
|
|
|
|
|
|
if (!SOURCE_DESTROYED (source))
|
|
|
|
|
{
|
|
|
|
|
gboolean was_in_call;
|
|
|
|
|
gpointer user_data = NULL;
|
|
|
|
|
GSourceFunc callback = NULL;
|
|
|
|
|
GSourceCallbackFuncs *cb_funcs;
|
|
|
|
|
gpointer cb_data;
|
|
|
|
|
gboolean need_destroy;
|
|
|
|
|
|
|
|
|
|
gboolean (*dispatch) (GSource *,
|
|
|
|
|
GSourceFunc,
|
|
|
|
|
gpointer);
|
|
|
|
|
|
|
|
|
|
dispatch = source->source_funcs->dispatch;
|
|
|
|
|
cb_funcs = source->callback_funcs;
|
|
|
|
|
cb_data = source->callback_data;
|
|
|
|
|
|
|
|
|
|
if (cb_funcs)
|
|
|
|
|
cb_funcs->ref (cb_data);
|
|
|
|
|
|
2004-03-19 21:25:03 +01:00
|
|
|
if ((source->flags & G_SOURCE_CAN_RECURSE) == 0)
|
|
|
|
|
block_source (source);
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
was_in_call = source->flags & G_HOOK_FLAG_IN_CALL;
|
|
|
|
|
source->flags |= G_HOOK_FLAG_IN_CALL;
|
|
|
|
|
|
|
|
|
|
if (cb_funcs)
|
2001-09-04 00:12:51 +02:00
|
|
|
cb_funcs->get (cb_data, source, &callback, &user_data);
|
2000-12-05 21:45:33 +01:00
|
|
|
|
2001-09-19 22:39:21 +02:00
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
2004-03-01 03:41:09 +01:00
|
|
|
(*depth)++;
|
2000-12-05 21:45:33 +01:00
|
|
|
need_destroy = ! dispatch (source,
|
|
|
|
|
callback,
|
|
|
|
|
user_data);
|
2004-03-01 03:41:09 +01:00
|
|
|
(*depth)--;
|
|
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
if (cb_funcs)
|
|
|
|
|
cb_funcs->unref (cb_data);
|
|
|
|
|
|
|
|
|
|
if (!was_in_call)
|
|
|
|
|
source->flags &= ~G_HOOK_FLAG_IN_CALL;
|
|
|
|
|
|
2004-03-19 21:25:03 +01:00
|
|
|
if ((source->flags & G_SOURCE_CAN_RECURSE) == 0 &&
|
|
|
|
|
!SOURCE_DESTROYED (source))
|
|
|
|
|
unblock_source (source);
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/* Note: this depends on the fact that we can't switch
|
|
|
|
|
* sources from one main context to another
|
|
|
|
|
*/
|
|
|
|
|
if (need_destroy && !SOURCE_DESTROYED (source))
|
|
|
|
|
{
|
|
|
|
|
g_assert (source->context == context);
|
|
|
|
|
g_source_destroy_internal (source, context, TRUE);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
SOURCE_UNREF (source, context);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
g_ptr_array_set_size (context->pending_dispatches, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Holds context's lock */
|
|
|
|
|
static inline GSource *
|
|
|
|
|
next_valid_source (GMainContext *context,
|
|
|
|
|
GSource *source)
|
|
|
|
|
{
|
|
|
|
|
GSource *new_source = source ? source->next : context->source_list;
|
|
|
|
|
|
|
|
|
|
while (new_source)
|
|
|
|
|
{
|
|
|
|
|
if (!SOURCE_DESTROYED (new_source))
|
|
|
|
|
{
|
|
|
|
|
new_source->ref_count++;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
new_source = new_source->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (source)
|
|
|
|
|
SOURCE_UNREF (source, context);
|
|
|
|
|
|
|
|
|
|
return new_source;
|
|
|
|
|
}
|
|
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
/**
|
|
|
|
|
* g_main_context_acquire:
|
|
|
|
|
* @context: a #GMainContext
|
|
|
|
|
*
|
|
|
|
|
* Tries to become the owner of the specified context.
|
|
|
|
|
* If some other context is the owner of the context,
|
|
|
|
|
* returns %FALSE immediately. Ownership is properly
|
|
|
|
|
* recursive: the owner can require ownership again
|
|
|
|
|
* and will release ownership when g_main_context_release()
|
|
|
|
|
* is called as many times as g_main_context_acquire().
|
|
|
|
|
*
|
|
|
|
|
* You must be the owner of a context before you
|
|
|
|
|
* can call g_main_context_prepare(), g_main_context_query(),
|
|
|
|
|
* g_main_context_check(), g_main_context_dispatch().
|
|
|
|
|
*
|
|
|
|
|
* Return value: %TRUE if the operation succeeded, and
|
|
|
|
|
* this thread is now the owner of @context.
|
|
|
|
|
**/
|
|
|
|
|
gboolean
|
|
|
|
|
g_main_context_acquire (GMainContext *context)
|
|
|
|
|
{
|
2001-10-31 14:49:53 +01:00
|
|
|
#ifdef G_THREADS_ENABLED
|
2001-06-30 21:56:47 +02:00
|
|
|
gboolean result = FALSE;
|
|
|
|
|
GThread *self = G_THREAD_SELF;
|
|
|
|
|
|
|
|
|
|
if (context == NULL)
|
|
|
|
|
context = g_main_context_default ();
|
|
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
if (!context->owner)
|
2001-07-17 10:49:23 +02:00
|
|
|
{
|
|
|
|
|
context->owner = self;
|
|
|
|
|
g_assert (context->owner_count == 0);
|
|
|
|
|
}
|
2001-06-30 21:56:47 +02:00
|
|
|
|
|
|
|
|
if (context->owner == self)
|
|
|
|
|
{
|
|
|
|
|
context->owner_count++;
|
|
|
|
|
result = TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
return result;
|
2001-10-31 14:49:53 +01:00
|
|
|
#else /* !G_THREADS_ENABLED */
|
2001-06-30 21:56:47 +02:00
|
|
|
return TRUE;
|
2001-10-31 14:49:53 +01:00
|
|
|
#endif /* G_THREADS_ENABLED */
|
2001-06-30 21:56:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_main_context_release:
|
|
|
|
|
* @context: a #GMainContext
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Releases ownership of a context previously acquired by this thread
|
2001-06-30 21:56:47 +02:00
|
|
|
* with g_main_context_acquire(). If the context was acquired multiple
|
|
|
|
|
* times, the only release ownership when g_main_context_release()
|
|
|
|
|
* is called as many times as it was acquired.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_main_context_release (GMainContext *context)
|
|
|
|
|
{
|
2001-10-31 14:49:53 +01:00
|
|
|
#ifdef G_THREADS_ENABLED
|
2001-06-30 21:56:47 +02:00
|
|
|
if (context == NULL)
|
|
|
|
|
context = g_main_context_default ();
|
|
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
context->owner_count--;
|
|
|
|
|
if (context->owner_count == 0)
|
|
|
|
|
{
|
|
|
|
|
context->owner = NULL;
|
|
|
|
|
|
|
|
|
|
if (context->waiters)
|
|
|
|
|
{
|
2001-07-17 10:49:23 +02:00
|
|
|
GMainWaiter *waiter = context->waiters->data;
|
|
|
|
|
gboolean loop_internal_waiter =
|
|
|
|
|
(waiter->mutex == g_static_mutex_get_mutex (&context->mutex));
|
2001-06-30 21:56:47 +02:00
|
|
|
context->waiters = g_slist_delete_link (context->waiters,
|
|
|
|
|
context->waiters);
|
2001-07-17 10:49:23 +02:00
|
|
|
if (!loop_internal_waiter)
|
|
|
|
|
g_mutex_lock (waiter->mutex);
|
|
|
|
|
|
|
|
|
|
g_cond_signal (waiter->cond);
|
|
|
|
|
|
|
|
|
|
if (!loop_internal_waiter)
|
|
|
|
|
g_mutex_unlock (waiter->mutex);
|
2001-06-30 21:56:47 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2001-07-17 10:49:23 +02:00
|
|
|
UNLOCK_CONTEXT (context);
|
2001-10-31 14:49:53 +01:00
|
|
|
#endif /* G_THREADS_ENABLED */
|
2001-06-30 21:56:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_main_context_wait:
|
|
|
|
|
* @context: a #GMainContext
|
|
|
|
|
* @cond: a condition variable
|
|
|
|
|
* @mutex: a mutex, currently held
|
|
|
|
|
*
|
|
|
|
|
* Tries to become the owner of the specified context,
|
2001-12-16 20:31:36 +01:00
|
|
|
* as with g_main_context_acquire(). But if another thread
|
|
|
|
|
* is the owner, atomically drop @mutex and wait on @cond until
|
|
|
|
|
* that owner releases ownership or until @cond is signaled, then
|
2001-06-30 21:56:47 +02:00
|
|
|
* try again (once) to become the owner.
|
|
|
|
|
*
|
|
|
|
|
* Return value: %TRUE if the operation succeeded, and
|
|
|
|
|
* this thread is now the owner of @context.
|
|
|
|
|
**/
|
|
|
|
|
gboolean
|
|
|
|
|
g_main_context_wait (GMainContext *context,
|
|
|
|
|
GCond *cond,
|
|
|
|
|
GMutex *mutex)
|
|
|
|
|
{
|
2001-10-31 14:49:53 +01:00
|
|
|
#ifdef G_THREADS_ENABLED
|
2001-06-30 21:56:47 +02:00
|
|
|
gboolean result = FALSE;
|
|
|
|
|
GThread *self = G_THREAD_SELF;
|
|
|
|
|
gboolean loop_internal_waiter;
|
|
|
|
|
|
|
|
|
|
if (context == NULL)
|
|
|
|
|
context = g_main_context_default ();
|
|
|
|
|
|
|
|
|
|
loop_internal_waiter = (mutex == g_static_mutex_get_mutex (&context->mutex));
|
|
|
|
|
|
|
|
|
|
if (!loop_internal_waiter)
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
if (context->owner && context->owner != self)
|
|
|
|
|
{
|
|
|
|
|
GMainWaiter waiter;
|
|
|
|
|
|
|
|
|
|
waiter.cond = cond;
|
|
|
|
|
waiter.mutex = mutex;
|
|
|
|
|
|
|
|
|
|
context->waiters = g_slist_append (context->waiters, &waiter);
|
|
|
|
|
|
|
|
|
|
if (!loop_internal_waiter)
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
g_cond_wait (cond, mutex);
|
|
|
|
|
if (!loop_internal_waiter)
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
context->waiters = g_slist_remove (context->waiters, &waiter);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!context->owner)
|
2001-07-17 10:49:23 +02:00
|
|
|
{
|
|
|
|
|
context->owner = self;
|
|
|
|
|
g_assert (context->owner_count == 0);
|
|
|
|
|
}
|
2001-06-30 21:56:47 +02:00
|
|
|
|
|
|
|
|
if (context->owner == self)
|
|
|
|
|
{
|
|
|
|
|
context->owner_count++;
|
|
|
|
|
result = TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!loop_internal_waiter)
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
return result;
|
2001-10-31 14:49:53 +01:00
|
|
|
#else /* !G_THREADS_ENABLED */
|
2001-06-30 21:56:47 +02:00
|
|
|
return TRUE;
|
2001-10-31 14:49:53 +01:00
|
|
|
#endif /* G_THREADS_ENABLED */
|
2001-06-30 21:56:47 +02:00
|
|
|
}
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_main_context_prepare:
|
|
|
|
|
* @context: a #GMainContext
|
|
|
|
|
* @priority: location to store priority of highest priority
|
|
|
|
|
* source already ready.
|
|
|
|
|
*
|
|
|
|
|
* Prepares to poll sources within a main loop. The resulting information
|
|
|
|
|
* for polling is determined by calling g_main_context_query ().
|
|
|
|
|
*
|
|
|
|
|
* Return value: %TRUE if some source is ready to be dispatched
|
|
|
|
|
* prior to polling.
|
|
|
|
|
**/
|
|
|
|
|
gboolean
|
|
|
|
|
g_main_context_prepare (GMainContext *context,
|
|
|
|
|
gint *priority)
|
|
|
|
|
{
|
2002-02-06 01:37:38 +01:00
|
|
|
gint i;
|
2000-12-05 21:45:33 +01:00
|
|
|
gint n_ready = 0;
|
|
|
|
|
gint current_priority = G_MAXINT;
|
|
|
|
|
GSource *source;
|
|
|
|
|
|
|
|
|
|
if (context == NULL)
|
|
|
|
|
context = g_main_context_default ();
|
|
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
context->time_is_current = FALSE;
|
|
|
|
|
|
|
|
|
|
if (context->in_check_or_prepare)
|
|
|
|
|
{
|
|
|
|
|
g_warning ("g_main_context_prepare() called recursively from within a source's check() or "
|
|
|
|
|
"prepare() member.");
|
2001-05-27 20:28:58 +02:00
|
|
|
UNLOCK_CONTEXT (context);
|
2000-12-05 21:45:33 +01:00
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef G_THREADS_ENABLED
|
|
|
|
|
if (context->poll_waiting)
|
|
|
|
|
{
|
|
|
|
|
g_warning("g_main_context_prepare(): main loop already active in another thread");
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
context->poll_waiting = TRUE;
|
2000-12-08 04:39:47 +01:00
|
|
|
#endif /* G_THREADS_ENABLED */
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
|
/* If recursing, finish up current dispatch, before starting over */
|
|
|
|
|
if (context->pending_dispatches)
|
|
|
|
|
{
|
|
|
|
|
if (dispatch)
|
|
|
|
|
g_main_dispatch (context, ¤t_time);
|
|
|
|
|
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* If recursing, clear list of pending dispatches */
|
2002-02-06 01:37:38 +01:00
|
|
|
|
|
|
|
|
for (i = 0; i < context->pending_dispatches->len; i++)
|
2002-02-06 20:45:56 +01:00
|
|
|
{
|
|
|
|
|
if (context->pending_dispatches->pdata[i])
|
|
|
|
|
SOURCE_UNREF ((GSource *)context->pending_dispatches->pdata[i], context);
|
|
|
|
|
}
|
2000-12-05 21:45:33 +01:00
|
|
|
g_ptr_array_set_size (context->pending_dispatches, 0);
|
|
|
|
|
|
|
|
|
|
/* Prepare all sources */
|
|
|
|
|
|
|
|
|
|
context->timeout = -1;
|
|
|
|
|
|
|
|
|
|
source = next_valid_source (context, NULL);
|
|
|
|
|
while (source)
|
|
|
|
|
{
|
|
|
|
|
gint source_timeout = -1;
|
|
|
|
|
|
|
|
|
|
if ((n_ready > 0) && (source->priority > current_priority))
|
|
|
|
|
{
|
|
|
|
|
SOURCE_UNREF (source, context);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2004-03-19 21:25:03 +01:00
|
|
|
if (SOURCE_BLOCKED (source))
|
2000-12-05 21:45:33 +01:00
|
|
|
goto next;
|
|
|
|
|
|
|
|
|
|
if (!(source->flags & G_SOURCE_READY))
|
|
|
|
|
{
|
|
|
|
|
gboolean result;
|
|
|
|
|
gboolean (*prepare) (GSource *source,
|
|
|
|
|
gint *timeout);
|
|
|
|
|
|
|
|
|
|
prepare = source->source_funcs->prepare;
|
|
|
|
|
context->in_check_or_prepare++;
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
result = (*prepare) (source, &source_timeout);
|
|
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
context->in_check_or_prepare--;
|
|
|
|
|
|
|
|
|
|
if (result)
|
|
|
|
|
source->flags |= G_SOURCE_READY;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (source->flags & G_SOURCE_READY)
|
|
|
|
|
{
|
|
|
|
|
n_ready++;
|
|
|
|
|
current_priority = source->priority;
|
|
|
|
|
context->timeout = 0;
|
|
|
|
|
}
|
1998-12-02 15:55:27 +01:00
|
|
|
|
|
|
|
|
if (source_timeout >= 0)
|
|
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
if (context->timeout < 0)
|
|
|
|
|
context->timeout = source_timeout;
|
1998-12-02 15:55:27 +01:00
|
|
|
else
|
2000-12-05 21:45:33 +01:00
|
|
|
context->timeout = MIN (context->timeout, source_timeout);
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
next:
|
|
|
|
|
source = next_valid_source (context, source);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
if (priority)
|
|
|
|
|
*priority = current_priority;
|
|
|
|
|
|
|
|
|
|
return (n_ready > 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_main_context_query:
|
|
|
|
|
* @context: a #GMainContext
|
|
|
|
|
* @max_priority: maximum priority source to check
|
2002-11-08 19:47:56 +01:00
|
|
|
* @timeout_: location to store timeout to be used in polling
|
2000-12-05 21:45:33 +01:00
|
|
|
* @fds: location to store #GPollFD records that need to be polled.
|
|
|
|
|
* @n_fds: length of @fds.
|
|
|
|
|
*
|
|
|
|
|
* Determines information necessary to poll this main loop.
|
|
|
|
|
*
|
2001-08-20 03:37:50 +02:00
|
|
|
* Return value: the number of records actually stored in @fds,
|
|
|
|
|
* or, if more than @n_fds records need to be stored, the number
|
|
|
|
|
* of records that need to be stored.
|
2000-12-05 21:45:33 +01:00
|
|
|
**/
|
|
|
|
|
gint
|
|
|
|
|
g_main_context_query (GMainContext *context,
|
|
|
|
|
gint max_priority,
|
|
|
|
|
gint *timeout,
|
|
|
|
|
GPollFD *fds,
|
|
|
|
|
gint n_fds)
|
|
|
|
|
{
|
|
|
|
|
gint n_poll;
|
|
|
|
|
GPollRec *pollrec;
|
|
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
pollrec = context->poll_records;
|
|
|
|
|
n_poll = 0;
|
|
|
|
|
while (pollrec && max_priority >= pollrec->priority)
|
|
|
|
|
{
|
|
|
|
|
if (pollrec->fd->events)
|
|
|
|
|
{
|
|
|
|
|
if (n_poll < n_fds)
|
|
|
|
|
{
|
|
|
|
|
fds[n_poll].fd = pollrec->fd->fd;
|
|
|
|
|
/* In direct contradiction to the Unix98 spec, IRIX runs into
|
|
|
|
|
* difficulty if you pass in POLLERR, POLLHUP or POLLNVAL
|
|
|
|
|
* flags in the events field of the pollfd while it should
|
|
|
|
|
* just ignoring them. So we mask them out here.
|
|
|
|
|
*/
|
|
|
|
|
fds[n_poll].events = pollrec->fd->events & ~(G_IO_ERR|G_IO_HUP|G_IO_NVAL);
|
|
|
|
|
fds[n_poll].revents = 0;
|
|
|
|
|
}
|
|
|
|
|
n_poll++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pollrec = pollrec->next;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-13 05:23:45 +01:00
|
|
|
#ifdef G_THREADS_ENABLED
|
2000-12-05 21:45:33 +01:00
|
|
|
context->poll_changed = FALSE;
|
2000-12-13 05:23:45 +01:00
|
|
|
#endif
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (timeout)
|
|
|
|
|
{
|
|
|
|
|
*timeout = context->timeout;
|
|
|
|
|
if (timeout != 0)
|
|
|
|
|
context->time_is_current = FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
return n_poll;
|
|
|
|
|
}
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_main_context_check:
|
|
|
|
|
* @context: a #GMainContext
|
|
|
|
|
* @max_priority: the maximum numerical priority of sources to check
|
|
|
|
|
* @fds: array of #GPollFD's that was passed to the last call to
|
|
|
|
|
* g_main_context_query()
|
|
|
|
|
* @n_fds: return value of g_main_context_query()
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Passes the results of polling back to the main loop.
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
|
|
|
|
* Return value: %TRUE if some sources are ready to be dispatched.
|
|
|
|
|
**/
|
|
|
|
|
gboolean
|
|
|
|
|
g_main_context_check (GMainContext *context,
|
|
|
|
|
gint max_priority,
|
|
|
|
|
GPollFD *fds,
|
|
|
|
|
gint n_fds)
|
|
|
|
|
{
|
|
|
|
|
GSource *source;
|
|
|
|
|
GPollRec *pollrec;
|
|
|
|
|
gint n_ready = 0;
|
|
|
|
|
gint i;
|
2000-01-26 05:29:06 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
LOCK_CONTEXT (context);
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (context->in_check_or_prepare)
|
|
|
|
|
{
|
|
|
|
|
g_warning ("g_main_context_check() called recursively from within a source's check() or "
|
|
|
|
|
"prepare() member.");
|
2001-05-27 20:28:58 +02:00
|
|
|
UNLOCK_CONTEXT (context);
|
2000-12-05 21:45:33 +01:00
|
|
|
return FALSE;
|
|
|
|
|
}
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
#ifdef G_THREADS_ENABLED
|
|
|
|
|
if (!context->poll_waiting)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
#ifndef G_OS_WIN32
|
2004-02-14 01:23:36 +01:00
|
|
|
gchar a;
|
|
|
|
|
read (context->wake_up_pipe[0], &a, 1);
|
2000-12-05 21:45:33 +01:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
context->poll_waiting = FALSE;
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/* If the set of poll file descriptors changed, bail out
|
|
|
|
|
* and let the main loop rerun
|
|
|
|
|
*/
|
|
|
|
|
if (context->poll_changed)
|
2001-05-27 20:28:58 +02:00
|
|
|
{
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2000-12-13 05:23:45 +01:00
|
|
|
#endif /* G_THREADS_ENABLED */
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
pollrec = context->poll_records;
|
|
|
|
|
i = 0;
|
|
|
|
|
while (i < n_fds)
|
|
|
|
|
{
|
|
|
|
|
if (pollrec->fd->events)
|
1999-01-02 02:32:37 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
pollrec->fd->revents = fds[i].revents;
|
|
|
|
|
i++;
|
1999-01-02 02:32:37 +01:00
|
|
|
}
|
2000-12-05 21:45:33 +01:00
|
|
|
pollrec = pollrec->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
source = next_valid_source (context, NULL);
|
|
|
|
|
while (source)
|
|
|
|
|
{
|
|
|
|
|
if ((n_ready > 0) && (source->priority > max_priority))
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
SOURCE_UNREF (source, context);
|
|
|
|
|
break;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
2004-03-19 21:25:03 +01:00
|
|
|
if (SOURCE_BLOCKED (source))
|
2000-12-05 21:45:33 +01:00
|
|
|
goto next;
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (!(source->flags & G_SOURCE_READY))
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
gboolean result;
|
|
|
|
|
gboolean (*check) (GSource *source);
|
1999-02-02 02:04:41 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
check = source->source_funcs->check;
|
1999-02-02 02:04:41 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
context->in_check_or_prepare++;
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
result = (*check) (source);
|
|
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
context->in_check_or_prepare--;
|
|
|
|
|
|
|
|
|
|
if (result)
|
|
|
|
|
source->flags |= G_SOURCE_READY;
|
1999-02-02 02:04:41 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (source->flags & G_SOURCE_READY)
|
1999-02-02 02:04:41 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
source->ref_count++;
|
|
|
|
|
g_ptr_array_add (context->pending_dispatches, source);
|
1998-12-18 03:23:33 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
n_ready++;
|
2002-02-13 23:37:26 +01:00
|
|
|
|
|
|
|
|
/* never dispatch sources with less priority than the first
|
|
|
|
|
* one we choose to dispatch
|
|
|
|
|
*/
|
|
|
|
|
max_priority = source->priority;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
next:
|
|
|
|
|
source = next_valid_source (context, source);
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
return n_ready > 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_main_context_dispatch:
|
|
|
|
|
* @context: a #GMainContext
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Dispatches all pending sources.
|
2000-12-05 21:45:33 +01:00
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_main_context_dispatch (GMainContext *context)
|
|
|
|
|
{
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
if (context->pending_dispatches->len > 0)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
g_main_dispatch (context);
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
1998-12-15 06:28:02 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
}
|
|
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
/* HOLDS context lock */
|
2000-12-05 21:45:33 +01:00
|
|
|
static gboolean
|
|
|
|
|
g_main_context_iterate (GMainContext *context,
|
|
|
|
|
gboolean block,
|
2001-06-30 21:56:47 +02:00
|
|
|
gboolean dispatch,
|
|
|
|
|
GThread *self)
|
2000-12-05 21:45:33 +01:00
|
|
|
{
|
|
|
|
|
gint max_priority;
|
|
|
|
|
gint timeout;
|
|
|
|
|
gboolean some_ready;
|
2001-06-30 21:56:47 +02:00
|
|
|
gint nfds, allocated_nfds;
|
|
|
|
|
GPollFD *fds = NULL;
|
2000-12-05 21:45:33 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
UNLOCK_CONTEXT (context);
|
2000-12-05 21:45:33 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
#ifdef G_THREADS_ENABLED
|
|
|
|
|
if (!g_main_context_acquire (context))
|
2000-12-05 21:45:33 +01:00
|
|
|
{
|
2001-06-30 21:56:47 +02:00
|
|
|
gboolean got_ownership;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (g_thread_supported (), FALSE);
|
2000-12-05 21:45:33 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
if (!block)
|
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
if (!context->cond)
|
|
|
|
|
context->cond = g_cond_new ();
|
|
|
|
|
|
|
|
|
|
got_ownership = g_main_context_wait (context,
|
|
|
|
|
context->cond,
|
|
|
|
|
g_static_mutex_get_mutex (&context->mutex));
|
|
|
|
|
|
|
|
|
|
if (!got_ownership)
|
2000-12-05 21:45:33 +01:00
|
|
|
{
|
2001-06-30 21:56:47 +02:00
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
return FALSE;
|
2000-12-05 21:45:33 +01:00
|
|
|
}
|
2001-06-30 21:56:47 +02:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
LOCK_CONTEXT (context);
|
2001-07-11 22:08:50 +02:00
|
|
|
#endif /* G_THREADS_ENABLED */
|
2001-06-30 21:56:47 +02:00
|
|
|
|
|
|
|
|
if (!context->cached_poll_array)
|
|
|
|
|
{
|
|
|
|
|
context->cached_poll_array_size = context->n_poll_records;
|
|
|
|
|
context->cached_poll_array = g_new (GPollFD, context->n_poll_records);
|
|
|
|
|
}
|
2000-12-05 21:45:33 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
allocated_nfds = context->cached_poll_array_size;
|
|
|
|
|
fds = context->cached_poll_array;
|
2000-12-05 21:45:33 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
2003-11-01 14:57:48 +01:00
|
|
|
g_main_context_prepare (context, &max_priority);
|
2001-06-30 21:56:47 +02:00
|
|
|
|
|
|
|
|
while ((nfds = g_main_context_query (context, max_priority, &timeout, fds,
|
|
|
|
|
allocated_nfds)) > allocated_nfds)
|
|
|
|
|
{
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
g_free (fds);
|
|
|
|
|
context->cached_poll_array_size = allocated_nfds = nfds;
|
|
|
|
|
context->cached_poll_array = fds = g_new (GPollFD, nfds);
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
2000-12-05 21:45:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!block)
|
|
|
|
|
timeout = 0;
|
|
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
g_main_context_poll (context, timeout, max_priority, fds, nfds);
|
2000-12-05 21:45:33 +01:00
|
|
|
|
2003-11-01 14:57:48 +01:00
|
|
|
some_ready = g_main_context_check (context, max_priority, fds, nfds);
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
if (dispatch)
|
|
|
|
|
g_main_context_dispatch (context);
|
2001-06-30 21:56:47 +02:00
|
|
|
|
|
|
|
|
#ifdef G_THREADS_ENABLED
|
|
|
|
|
g_main_context_release (context);
|
|
|
|
|
#endif /* G_THREADS_ENABLED */
|
|
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
return some_ready;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_main_context_pending:
|
|
|
|
|
* @context: a #GMainContext (if %NULL, the default context will be used)
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Checks if any sources have pending events for the given context.
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
|
|
|
|
* Return value: %TRUE if events are pending.
|
|
|
|
|
**/
|
1998-12-02 15:55:27 +01:00
|
|
|
gboolean
|
2000-12-05 21:45:33 +01:00
|
|
|
g_main_context_pending (GMainContext *context)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2001-06-30 21:56:47 +02:00
|
|
|
gboolean retval;
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (!context)
|
|
|
|
|
context = g_main_context_default();
|
2001-06-30 21:56:47 +02:00
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
retval = g_main_context_iterate (context, FALSE, FALSE, G_THREAD_SELF);
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
2000-12-05 21:45:33 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
return retval;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_main_context_iteration:
|
|
|
|
|
* @context: a #GMainContext (if %NULL, the default context will be used)
|
|
|
|
|
* @may_block: whether the call may block.
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Runs a single iteration for the given main loop. This involves
|
2000-12-05 21:45:33 +01:00
|
|
|
* checking to see if any event sources are ready to be processed,
|
|
|
|
|
* then if no events sources are ready and @may_block is %TRUE, waiting
|
|
|
|
|
* for a source to become ready, then dispatching the highest priority
|
|
|
|
|
* events sources that are ready. Note that even when @may_block is %TRUE,
|
|
|
|
|
* it is still possible for g_main_context_iteration() to return
|
|
|
|
|
* %FALSE, since the the wait may be interrupted for other
|
|
|
|
|
* reasons than an event source becoming ready.
|
|
|
|
|
*
|
|
|
|
|
* Return value: %TRUE if events were dispatched.
|
|
|
|
|
**/
|
1998-12-02 15:55:27 +01:00
|
|
|
gboolean
|
2000-12-05 21:45:33 +01:00
|
|
|
g_main_context_iteration (GMainContext *context, gboolean may_block)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2001-06-30 21:56:47 +02:00
|
|
|
gboolean retval;
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (!context)
|
|
|
|
|
context = g_main_context_default();
|
|
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
retval = g_main_context_iterate (context, may_block, TRUE, G_THREAD_SELF);
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
return retval;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_main_loop_new:
|
|
|
|
|
* @context: a #GMainContext (if %NULL, the default context will be used).
|
2001-12-16 20:31:36 +01:00
|
|
|
* @is_running: set to %TRUE to indicate that the loop is running. This
|
2002-02-03 02:04:32 +01:00
|
|
|
* is not very important since calling g_main_loop_run() will set this to
|
2001-12-16 20:31:36 +01:00
|
|
|
* %TRUE anyway.
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Creates a new #GMainLoop structure.
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Return value: a new #GMainLoop.
|
2000-12-05 21:45:33 +01:00
|
|
|
**/
|
|
|
|
|
GMainLoop *
|
|
|
|
|
g_main_loop_new (GMainContext *context,
|
|
|
|
|
gboolean is_running)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
1998-12-18 03:23:33 +01:00
|
|
|
GMainLoop *loop;
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
if (!context)
|
|
|
|
|
context = g_main_context_default();
|
|
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
g_main_context_ref (context);
|
|
|
|
|
|
1998-12-18 03:23:33 +01:00
|
|
|
loop = g_new0 (GMainLoop, 1);
|
2000-12-05 21:45:33 +01:00
|
|
|
loop->context = context;
|
1998-12-18 03:23:33 +01:00
|
|
|
loop->is_running = is_running != FALSE;
|
2001-01-03 21:18:40 +01:00
|
|
|
loop->ref_count = 1;
|
|
|
|
|
|
1998-12-18 03:23:33 +01:00
|
|
|
return loop;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2001-01-03 21:18:40 +01:00
|
|
|
/**
|
|
|
|
|
* g_main_loop_ref:
|
|
|
|
|
* @loop: a #GMainLoop
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Increases the reference count on a #GMainLoop object by one.
|
2001-01-03 21:18:40 +01:00
|
|
|
*
|
|
|
|
|
* Return value: @loop
|
|
|
|
|
**/
|
|
|
|
|
GMainLoop *
|
|
|
|
|
g_main_loop_ref (GMainLoop *loop)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (loop != NULL, NULL);
|
2004-03-04 11:12:55 +01:00
|
|
|
g_return_val_if_fail (g_atomic_int_get (&loop->ref_count) > 0, NULL);
|
2001-01-03 21:18:40 +01:00
|
|
|
|
2004-03-04 11:12:55 +01:00
|
|
|
g_atomic_int_inc (&loop->ref_count);
|
2001-01-03 21:18:40 +01:00
|
|
|
|
|
|
|
|
return loop;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_main_loop_unref:
|
|
|
|
|
* @loop: a #GMainLoop
|
|
|
|
|
*
|
|
|
|
|
* Decreases the reference count on a #GMainLoop object by one. If
|
|
|
|
|
* the result is zero, free the loop and free all associated memory.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_main_loop_unref (GMainLoop *loop)
|
|
|
|
|
{
|
|
|
|
|
g_return_if_fail (loop != NULL);
|
2004-03-04 11:12:55 +01:00
|
|
|
g_return_if_fail (g_atomic_int_get (&loop->ref_count) > 0);
|
2001-01-03 21:18:40 +01:00
|
|
|
|
2004-03-04 11:12:55 +01:00
|
|
|
if (!g_atomic_int_dec_and_test (&loop->ref_count))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
g_main_context_unref (loop->context);
|
|
|
|
|
g_free (loop);
|
2001-01-03 21:18:40 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_main_loop_run:
|
|
|
|
|
* @loop: a #GMainLoop
|
|
|
|
|
*
|
2002-02-03 02:04:32 +01:00
|
|
|
* Runs a main loop until g_main_loop_quit() is called on the loop.
|
2000-12-05 21:45:33 +01:00
|
|
|
* If this is called for the thread of the loop's #GMainContext,
|
|
|
|
|
* it will process events from the loop, otherwise it will
|
|
|
|
|
* simply wait.
|
|
|
|
|
**/
|
1998-12-02 15:55:27 +01:00
|
|
|
void
|
2000-12-05 21:45:33 +01:00
|
|
|
g_main_loop_run (GMainLoop *loop)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2001-06-30 21:56:47 +02:00
|
|
|
GThread *self = G_THREAD_SELF;
|
|
|
|
|
|
1998-12-18 03:23:33 +01:00
|
|
|
g_return_if_fail (loop != NULL);
|
2004-03-04 11:12:55 +01:00
|
|
|
g_return_if_fail (g_atomic_int_get (&loop->ref_count) > 0);
|
1998-12-18 03:23:33 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
#ifdef G_THREADS_ENABLED
|
2001-06-30 21:56:47 +02:00
|
|
|
if (!g_main_context_acquire (loop->context))
|
2000-12-05 21:45:33 +01:00
|
|
|
{
|
2001-06-30 21:56:47 +02:00
|
|
|
gboolean got_ownership = FALSE;
|
2001-01-03 21:18:40 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
/* Another thread owns this context */
|
2000-12-05 21:45:33 +01:00
|
|
|
if (!g_thread_supported ())
|
|
|
|
|
{
|
2002-02-03 02:05:55 +01:00
|
|
|
g_warning ("g_main_loop_run() was called from second thread but "
|
2000-12-05 21:45:33 +01:00
|
|
|
"g_thread_init() was never called.");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
LOCK_CONTEXT (loop->context);
|
2000-12-05 21:45:33 +01:00
|
|
|
|
2004-03-04 11:12:55 +01:00
|
|
|
g_atomic_int_inc (&loop->ref_count);
|
2001-06-30 21:56:47 +02:00
|
|
|
|
|
|
|
|
if (!loop->is_running)
|
|
|
|
|
loop->is_running = TRUE;
|
|
|
|
|
|
|
|
|
|
if (!loop->context->cond)
|
|
|
|
|
loop->context->cond = g_cond_new ();
|
|
|
|
|
|
2003-04-07 19:50:53 +02:00
|
|
|
while (loop->is_running && !got_ownership)
|
2001-06-30 21:56:47 +02:00
|
|
|
got_ownership = g_main_context_wait (loop->context,
|
|
|
|
|
loop->context->cond,
|
|
|
|
|
g_static_mutex_get_mutex (&loop->context->mutex));
|
|
|
|
|
|
|
|
|
|
if (!loop->is_running)
|
2000-12-05 21:45:33 +01:00
|
|
|
{
|
2001-07-17 10:49:23 +02:00
|
|
|
UNLOCK_CONTEXT (loop->context);
|
2001-06-30 21:56:47 +02:00
|
|
|
if (got_ownership)
|
|
|
|
|
g_main_context_release (loop->context);
|
2001-07-17 10:49:23 +02:00
|
|
|
g_main_loop_unref (loop);
|
2001-06-30 21:56:47 +02:00
|
|
|
return;
|
2000-12-05 21:45:33 +01:00
|
|
|
}
|
2001-06-30 21:56:47 +02:00
|
|
|
|
|
|
|
|
g_assert (got_ownership);
|
2001-01-03 21:18:40 +01:00
|
|
|
}
|
2001-06-30 21:56:47 +02:00
|
|
|
else
|
|
|
|
|
LOCK_CONTEXT (loop->context);
|
|
|
|
|
#endif /* G_THREADS_ENABLED */
|
2001-01-03 21:18:40 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
if (loop->context->in_check_or_prepare)
|
2001-01-03 21:18:40 +01:00
|
|
|
{
|
2002-02-03 02:05:55 +01:00
|
|
|
g_warning ("g_main_loop_run(): called recursively from within a source's "
|
2002-02-03 02:04:32 +01:00
|
|
|
"check() or prepare() member, iteration not possible.");
|
2001-06-30 21:56:47 +02:00
|
|
|
return;
|
1999-01-17 05:49:43 +01:00
|
|
|
}
|
2001-06-30 21:56:47 +02:00
|
|
|
|
2004-03-04 11:12:55 +01:00
|
|
|
g_atomic_int_inc (&loop->ref_count);
|
2001-06-30 21:56:47 +02:00
|
|
|
loop->is_running = TRUE;
|
|
|
|
|
while (loop->is_running)
|
|
|
|
|
g_main_context_iterate (loop->context, TRUE, TRUE, self);
|
|
|
|
|
|
2001-11-01 01:01:50 +01:00
|
|
|
UNLOCK_CONTEXT (loop->context);
|
|
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
#ifdef G_THREADS_ENABLED
|
|
|
|
|
g_main_context_release (loop->context);
|
|
|
|
|
#endif /* G_THREADS_ENABLED */
|
|
|
|
|
|
2001-11-01 01:01:50 +01:00
|
|
|
g_main_loop_unref (loop);
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_main_loop_quit:
|
|
|
|
|
* @loop: a #GMainLoop
|
|
|
|
|
*
|
|
|
|
|
* Stops a #GMainLoop from running. Any calls to g_main_loop_run()
|
|
|
|
|
* for the loop will return.
|
|
|
|
|
**/
|
1998-12-02 15:55:27 +01:00
|
|
|
void
|
2000-12-05 21:45:33 +01:00
|
|
|
g_main_loop_quit (GMainLoop *loop)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
1998-12-18 03:23:33 +01:00
|
|
|
g_return_if_fail (loop != NULL);
|
2004-03-04 11:12:55 +01:00
|
|
|
g_return_if_fail (g_atomic_int_get (&loop->ref_count) > 0);
|
1998-12-18 03:23:33 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
LOCK_CONTEXT (loop->context);
|
1998-12-18 03:23:33 +01:00
|
|
|
loop->is_running = FALSE;
|
2001-06-30 21:56:47 +02:00
|
|
|
g_main_context_wakeup_unlocked (loop->context);
|
2000-12-05 21:45:33 +01:00
|
|
|
|
2001-10-29 12:09:53 +01:00
|
|
|
#ifdef G_THREADS_ENABLED
|
2001-06-30 21:56:47 +02:00
|
|
|
if (loop->context->cond)
|
|
|
|
|
g_cond_broadcast (loop->context->cond);
|
2001-10-29 12:09:53 +01:00
|
|
|
#endif /* G_THREADS_ENABLED */
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
UNLOCK_CONTEXT (loop->context);
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_main_loop_is_running:
|
|
|
|
|
* @loop: a #GMainLoop.
|
|
|
|
|
*
|
2002-02-03 02:04:32 +01:00
|
|
|
* Checks to see if the main loop is currently being run via g_main_loop_run().
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
|
|
|
|
* Return value: %TRUE if the mainloop is currently being run.
|
|
|
|
|
**/
|
1998-12-18 03:23:33 +01:00
|
|
|
gboolean
|
2000-12-05 21:45:33 +01:00
|
|
|
g_main_loop_is_running (GMainLoop *loop)
|
1998-12-18 03:23:33 +01:00
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (loop != NULL, FALSE);
|
2004-03-04 11:12:55 +01:00
|
|
|
g_return_val_if_fail (g_atomic_int_get (&loop->ref_count) > 0, FALSE);
|
1998-12-18 03:23:33 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
return loop->is_running;
|
|
|
|
|
}
|
2000-12-05 21:45:33 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
/**
|
|
|
|
|
* g_main_loop_get_context:
|
|
|
|
|
* @loop: a #GMainLoop.
|
|
|
|
|
*
|
|
|
|
|
* Returns the #GMainContext of @loop.
|
|
|
|
|
*
|
|
|
|
|
* Return value: the #GMainContext of @loop
|
|
|
|
|
**/
|
|
|
|
|
GMainContext *
|
|
|
|
|
g_main_loop_get_context (GMainLoop *loop)
|
|
|
|
|
{
|
|
|
|
|
g_return_val_if_fail (loop != NULL, NULL);
|
2004-03-04 11:12:55 +01:00
|
|
|
g_return_val_if_fail (g_atomic_int_get (&loop->ref_count) > 0, NULL);
|
2001-06-30 21:56:47 +02:00
|
|
|
|
|
|
|
|
return loop->context;
|
1998-12-18 03:23:33 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/* HOLDS: context's lock */
|
1998-12-02 15:55:27 +01:00
|
|
|
static void
|
2000-12-05 21:45:33 +01:00
|
|
|
g_main_context_poll (GMainContext *context,
|
|
|
|
|
gint timeout,
|
|
|
|
|
gint priority,
|
|
|
|
|
GPollFD *fds,
|
|
|
|
|
gint n_fds)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
1999-07-24 20:50:58 +02:00
|
|
|
#ifdef G_MAIN_POLL_DEBUG
|
|
|
|
|
GTimer *poll_timer;
|
1998-12-02 15:55:27 +01:00
|
|
|
GPollRec *pollrec;
|
|
|
|
|
gint i;
|
2000-12-05 21:45:33 +01:00
|
|
|
#endif
|
1999-07-24 20:50:58 +02:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
GPollFunc poll_func;
|
1998-12-15 06:28:02 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (n_fds || timeout != 0)
|
1999-07-24 20:50:58 +02:00
|
|
|
{
|
|
|
|
|
#ifdef G_MAIN_POLL_DEBUG
|
2000-12-05 21:45:33 +01:00
|
|
|
g_print ("g_main_poll(%d) timeout: %d\n", n_fds, timeout);
|
1999-07-24 20:50:58 +02:00
|
|
|
poll_timer = g_timer_new ();
|
|
|
|
|
#endif
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
poll_func = context->poll_func;
|
1999-07-24 20:50:58 +02:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
if ((*poll_func) (fds, n_fds, timeout) < 0 && errno != EINTR)
|
2003-06-06 00:18:27 +02:00
|
|
|
{
|
|
|
|
|
#ifndef G_OS_WIN32
|
|
|
|
|
g_warning ("poll(2) failed due to: %s.",
|
|
|
|
|
g_strerror (errno));
|
|
|
|
|
#else
|
|
|
|
|
/* If g_poll () returns -1, it has already called g_warning() */
|
|
|
|
|
#endif
|
|
|
|
|
}
|
1999-07-24 20:50:58 +02:00
|
|
|
|
|
|
|
|
#ifdef G_MAIN_POLL_DEBUG
|
2000-12-05 21:45:33 +01:00
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
1999-07-24 20:50:58 +02:00
|
|
|
g_print ("g_main_poll(%d) timeout: %d - elapsed %12.10f seconds",
|
2000-12-05 21:45:33 +01:00
|
|
|
n_fds,
|
1999-07-24 20:50:58 +02:00
|
|
|
timeout,
|
|
|
|
|
g_timer_elapsed (poll_timer, NULL));
|
|
|
|
|
g_timer_destroy (poll_timer);
|
2000-12-05 21:45:33 +01:00
|
|
|
pollrec = context->poll_records;
|
1999-07-24 20:50:58 +02:00
|
|
|
i = 0;
|
2000-12-05 21:45:33 +01:00
|
|
|
while (i < n_fds)
|
1999-07-24 20:50:58 +02:00
|
|
|
{
|
|
|
|
|
if (pollrec->fd->events)
|
|
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
if (fds[i].revents)
|
1999-07-24 20:50:58 +02:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
g_print (" [%d:", fds[i].fd);
|
|
|
|
|
if (fds[i].revents & G_IO_IN)
|
1999-07-24 20:50:58 +02:00
|
|
|
g_print ("i");
|
2000-12-05 21:45:33 +01:00
|
|
|
if (fds[i].revents & G_IO_OUT)
|
1999-07-24 20:50:58 +02:00
|
|
|
g_print ("o");
|
2000-12-05 21:45:33 +01:00
|
|
|
if (fds[i].revents & G_IO_PRI)
|
1999-07-24 20:50:58 +02:00
|
|
|
g_print ("p");
|
2000-12-05 21:45:33 +01:00
|
|
|
if (fds[i].revents & G_IO_ERR)
|
1999-07-24 20:50:58 +02:00
|
|
|
g_print ("e");
|
2000-12-05 21:45:33 +01:00
|
|
|
if (fds[i].revents & G_IO_HUP)
|
1999-07-24 20:50:58 +02:00
|
|
|
g_print ("h");
|
2000-12-05 21:45:33 +01:00
|
|
|
if (fds[i].revents & G_IO_NVAL)
|
1999-07-24 20:50:58 +02:00
|
|
|
g_print ("n");
|
|
|
|
|
g_print ("]");
|
|
|
|
|
}
|
|
|
|
|
i++;
|
|
|
|
|
}
|
|
|
|
|
pollrec = pollrec->next;
|
|
|
|
|
}
|
|
|
|
|
g_print ("\n");
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
1999-07-24 20:50:58 +02:00
|
|
|
#endif
|
2000-12-05 21:45:33 +01:00
|
|
|
} /* if (n_fds || timeout != 0) */
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_main_context_add_poll:
|
|
|
|
|
* @context: a #GMainContext (or %NULL for the default context)
|
|
|
|
|
* @fd: a #GPollFD structure holding information about a file
|
|
|
|
|
* descriptor to watch.
|
|
|
|
|
* @priority: the priority for this file descriptor which should be
|
|
|
|
|
* the same as the priority used for g_source_attach() to ensure that the
|
|
|
|
|
* file descriptor is polled whenever the results may be needed.
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Adds a file descriptor to the set of file descriptors polled for
|
|
|
|
|
* this context. This will very seldomly be used directly. Instead
|
2000-12-05 21:45:33 +01:00
|
|
|
* a typical event source will use g_source_add_poll() instead.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_main_context_add_poll (GMainContext *context,
|
|
|
|
|
GPollFD *fd,
|
|
|
|
|
gint priority)
|
1998-12-15 06:28:02 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
if (!context)
|
|
|
|
|
context = g_main_context_default ();
|
|
|
|
|
|
2004-03-04 11:12:55 +01:00
|
|
|
g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
|
2001-06-30 21:56:47 +02:00
|
|
|
g_return_if_fail (fd);
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
g_main_context_add_poll_unlocked (context, priority, fd);
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
1998-12-15 06:28:02 +01:00
|
|
|
}
|
|
|
|
|
|
1998-12-16 10:34:30 +01:00
|
|
|
/* HOLDS: main_loop_lock */
|
1998-12-15 06:28:02 +01:00
|
|
|
static void
|
2000-12-05 21:45:33 +01:00
|
|
|
g_main_context_add_poll_unlocked (GMainContext *context,
|
|
|
|
|
gint priority,
|
|
|
|
|
GPollFD *fd)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
|
|
|
|
GPollRec *lastrec, *pollrec, *newrec;
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (!context->poll_chunk)
|
|
|
|
|
context->poll_chunk = g_mem_chunk_create (GPollRec, 32, G_ALLOC_ONLY);
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (context->poll_free_list)
|
1998-12-15 06:28:02 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
newrec = context->poll_free_list;
|
|
|
|
|
context->poll_free_list = newrec->next;
|
1998-12-15 06:28:02 +01:00
|
|
|
}
|
|
|
|
|
else
|
2000-12-05 21:45:33 +01:00
|
|
|
newrec = g_chunk_new (GPollRec, context->poll_chunk);
|
1998-12-15 06:28:02 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/* This file descriptor may be checked before we ever poll */
|
|
|
|
|
fd->revents = 0;
|
1998-12-02 15:55:27 +01:00
|
|
|
newrec->fd = fd;
|
|
|
|
|
newrec->priority = priority;
|
|
|
|
|
|
|
|
|
|
lastrec = NULL;
|
2000-12-05 21:45:33 +01:00
|
|
|
pollrec = context->poll_records;
|
1998-12-02 15:55:27 +01:00
|
|
|
while (pollrec && priority >= pollrec->priority)
|
|
|
|
|
{
|
|
|
|
|
lastrec = pollrec;
|
|
|
|
|
pollrec = pollrec->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (lastrec)
|
|
|
|
|
lastrec->next = newrec;
|
|
|
|
|
else
|
2000-12-05 21:45:33 +01:00
|
|
|
context->poll_records = newrec;
|
1998-12-02 15:55:27 +01:00
|
|
|
|
|
|
|
|
newrec->next = pollrec;
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
context->n_poll_records++;
|
1999-07-24 20:50:58 +02:00
|
|
|
|
|
|
|
|
#ifdef G_THREADS_ENABLED
|
2000-12-05 21:45:33 +01:00
|
|
|
context->poll_changed = TRUE;
|
1999-07-24 20:50:58 +02:00
|
|
|
|
|
|
|
|
/* Now wake up the main loop if it is waiting in the poll() */
|
2001-06-30 21:56:47 +02:00
|
|
|
g_main_context_wakeup_unlocked (context);
|
1999-07-24 20:50:58 +02:00
|
|
|
#endif
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_main_context_remove_poll:
|
|
|
|
|
* @context:a #GMainContext
|
|
|
|
|
* @fd: a #GPollFD descriptor previously added with g_main_context_add_poll()
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Removes file descriptor from the set of file descriptors to be
|
2000-12-05 21:45:33 +01:00
|
|
|
* polled for a particular context.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_main_context_remove_poll (GMainContext *context,
|
|
|
|
|
GPollFD *fd)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
if (!context)
|
|
|
|
|
context = g_main_context_default ();
|
|
|
|
|
|
2004-03-04 11:12:55 +01:00
|
|
|
g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
|
2001-06-30 21:56:47 +02:00
|
|
|
g_return_if_fail (fd);
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
LOCK_CONTEXT (context);
|
2000-12-05 21:45:33 +01:00
|
|
|
g_main_context_remove_poll_unlocked (context, fd);
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
g_main_context_remove_poll_unlocked (GMainContext *context,
|
|
|
|
|
GPollFD *fd)
|
|
|
|
|
{
|
|
|
|
|
GPollRec *pollrec, *lastrec;
|
|
|
|
|
|
1998-12-02 15:55:27 +01:00
|
|
|
lastrec = NULL;
|
2000-12-05 21:45:33 +01:00
|
|
|
pollrec = context->poll_records;
|
1998-12-02 15:55:27 +01:00
|
|
|
|
|
|
|
|
while (pollrec)
|
|
|
|
|
{
|
|
|
|
|
if (pollrec->fd == fd)
|
|
|
|
|
{
|
|
|
|
|
if (lastrec != NULL)
|
|
|
|
|
lastrec->next = pollrec->next;
|
|
|
|
|
else
|
2000-12-05 21:45:33 +01:00
|
|
|
context->poll_records = pollrec->next;
|
1998-12-02 15:55:27 +01:00
|
|
|
|
Add configure test for garbage collector friendliness for GLib. If
2000-04-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in, acconfig.h: Add configure test for garbage
collector friendliness for GLib. If enabled, ENABLE_GC_FRIENDLY
will be defined.
* garray.c, ghash.c, glist.c, gmain.c, gmem.c, gnode.c, gqueue.c,
gslist.c, gtree.c: If ENABLE_GC_FRIENDLY is defined, NULLify all
memory released by the user, but cached by GLib. This lets a
garbage collector have a more correct view of the actually used
memory.
2000-04-17 15:23:27 +02:00
|
|
|
#ifdef ENABLE_GC_FRIENDLY
|
|
|
|
|
pollrec->fd = NULL;
|
|
|
|
|
#endif /* ENABLE_GC_FRIENDLY */
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
pollrec->next = context->poll_free_list;
|
|
|
|
|
context->poll_free_list = pollrec;
|
1998-12-15 06:28:02 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
context->n_poll_records--;
|
1998-12-15 06:28:02 +01:00
|
|
|
break;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
lastrec = pollrec;
|
|
|
|
|
pollrec = pollrec->next;
|
|
|
|
|
}
|
|
|
|
|
|
1999-07-24 20:50:58 +02:00
|
|
|
#ifdef G_THREADS_ENABLED
|
2000-12-05 21:45:33 +01:00
|
|
|
context->poll_changed = TRUE;
|
1999-07-24 20:50:58 +02:00
|
|
|
|
|
|
|
|
/* Now wake up the main loop if it is waiting in the poll() */
|
2001-06-30 21:56:47 +02:00
|
|
|
g_main_context_wakeup_unlocked (context);
|
1999-07-24 20:50:58 +02:00
|
|
|
#endif
|
2000-12-05 21:45:33 +01:00
|
|
|
}
|
1999-07-24 20:50:58 +02:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_source_get_current_time:
|
|
|
|
|
* @source: a #GSource
|
|
|
|
|
* @timeval: #GTimeVal structure in which to store current time.
|
|
|
|
|
*
|
|
|
|
|
* Gets the "current time" to be used when checking
|
|
|
|
|
* this source. The advantage of calling this function over
|
|
|
|
|
* calling g_get_current_time() directly is that when
|
|
|
|
|
* checking multiple sources, GLib can cache a single value
|
|
|
|
|
* instead of having to repeatedly get the system time.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_source_get_current_time (GSource *source,
|
|
|
|
|
GTimeVal *timeval)
|
|
|
|
|
{
|
|
|
|
|
GMainContext *context;
|
|
|
|
|
|
|
|
|
|
g_return_if_fail (source->context != NULL);
|
|
|
|
|
|
|
|
|
|
context = source->context;
|
|
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
|
|
|
|
if (!context->time_is_current)
|
|
|
|
|
{
|
|
|
|
|
g_get_current_time (&context->current_time);
|
|
|
|
|
context->time_is_current = TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*timeval = context->current_time;
|
|
|
|
|
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_main_context_set_poll_func:
|
|
|
|
|
* @context: a #GMainContext
|
|
|
|
|
* @func: the function to call to poll all file descriptors
|
|
|
|
|
*
|
|
|
|
|
* Sets the function to use to handle polling of file descriptors. It
|
2003-07-25 23:32:47 +02:00
|
|
|
* will be used instead of the poll() system call
|
2001-12-16 20:31:36 +01:00
|
|
|
* (or GLib's replacement function, which is used where
|
2003-07-25 23:32:47 +02:00
|
|
|
* poll() isn't available).
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
|
|
|
|
* This function could possibly be used to integrate the GLib event
|
|
|
|
|
* loop with an external event loop.
|
|
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_main_context_set_poll_func (GMainContext *context,
|
|
|
|
|
GPollFunc func)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
if (!context)
|
|
|
|
|
context = g_main_context_default ();
|
|
|
|
|
|
2004-03-04 11:12:55 +01:00
|
|
|
g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
|
2001-06-30 21:56:47 +02:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
|
1998-12-02 15:55:27 +01:00
|
|
|
if (func)
|
2000-12-05 21:45:33 +01:00
|
|
|
context->poll_func = func;
|
1998-12-02 15:55:27 +01:00
|
|
|
else
|
2000-12-05 21:45:33 +01:00
|
|
|
{
|
1998-12-08 08:11:54 +01:00
|
|
|
#ifdef HAVE_POLL
|
2000-12-05 21:45:33 +01:00
|
|
|
context->poll_func = (GPollFunc) poll;
|
1998-12-08 08:11:54 +01:00
|
|
|
#else
|
2000-12-05 21:45:33 +01:00
|
|
|
context->poll_func = (GPollFunc) g_poll;
|
1998-12-08 08:11:54 +01:00
|
|
|
#endif
|
2000-12-05 21:45:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_main_context_get_poll_func:
|
|
|
|
|
* @context: a #GMainContext
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Gets the poll function set by g_main_context_set_poll_func().
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
|
|
|
|
* Return value: the poll function
|
|
|
|
|
**/
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
GPollFunc
|
2000-12-05 21:45:33 +01:00
|
|
|
g_main_context_get_poll_func (GMainContext *context)
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
{
|
Warn if no callback. Call callback correctly. (g_io_win32_create_watch):
2000-12-14 Tor Lillqvist <tml@iki.fi>
* giowin32.c (g_io_win32_dispatch): Warn if no callback. Call
callback correctly.
(g_io_win32_create_watch): Fix typo.
(g_io_win32_fd_create_watch): Ditto.
(g_io_channel_unix_new): If it is a file descriptor (i.e., a Unix
fd lookalike provided by the C library), call
g_io_channel_win32_new_fd(). If it is a socket (from WinSock),
call g_io_cahnnel_win32_new_stream_socket(). Hopefully sockets and
fds don't overlap. TODO: Implement also datagram sockets.
(g_io_channel_win32_poll): Call g_main_context_get_poll_func().
* gcompletion.h: Include <unistd.h> only on Unix. Is this
inclusion really needed here? OTOH, do include <stddef.h>, for
size_t.
* gmessages.c: (Win32) Don't define a function called "write" that
might clash with the prototype from <io.h>, use a #define.
* glib.def: Update.
* gmain.c (g_source_add_poll): Don't return a value from void
function.
(g_main_context_get_poll_func): Compile also for non-Win32, as
presumably was intended. The result var is a GPollFunc, not a
GPollFunc*. Return the result!
gobject:
2000-12-14 Tor Lillqvist <tml@iki.fi>
* makefile.mingw.in: Update, include parts from Makefile.am to
build gmarshal.[ch]. Some day, we won't need these separate
makefiles for Win32 compilation. I hope.
* makefile.msc.in: Update. No use trying to build gmarshal.[ch]
here, it would require Unixish tools. MSVC users building from CVS
sources are out of luck.
* gobject.def: Update.
2000-12-14 22:02:20 +01:00
|
|
|
GPollFunc result;
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
if (!context)
|
|
|
|
|
context = g_main_context_default ();
|
|
|
|
|
|
2004-03-04 11:12:55 +01:00
|
|
|
g_return_val_if_fail (g_atomic_int_get (&context->ref_count) > 0, NULL);
|
2001-06-30 21:56:47 +02:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
result = context->poll_func;
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
|
Warn if no callback. Call callback correctly. (g_io_win32_create_watch):
2000-12-14 Tor Lillqvist <tml@iki.fi>
* giowin32.c (g_io_win32_dispatch): Warn if no callback. Call
callback correctly.
(g_io_win32_create_watch): Fix typo.
(g_io_win32_fd_create_watch): Ditto.
(g_io_channel_unix_new): If it is a file descriptor (i.e., a Unix
fd lookalike provided by the C library), call
g_io_channel_win32_new_fd(). If it is a socket (from WinSock),
call g_io_cahnnel_win32_new_stream_socket(). Hopefully sockets and
fds don't overlap. TODO: Implement also datagram sockets.
(g_io_channel_win32_poll): Call g_main_context_get_poll_func().
* gcompletion.h: Include <unistd.h> only on Unix. Is this
inclusion really needed here? OTOH, do include <stddef.h>, for
size_t.
* gmessages.c: (Win32) Don't define a function called "write" that
might clash with the prototype from <io.h>, use a #define.
* glib.def: Update.
* gmain.c (g_source_add_poll): Don't return a value from void
function.
(g_main_context_get_poll_func): Compile also for non-Win32, as
presumably was intended. The result var is a GPollFunc, not a
GPollFunc*. Return the result!
gobject:
2000-12-14 Tor Lillqvist <tml@iki.fi>
* makefile.mingw.in: Update, include parts from Makefile.am to
build gmarshal.[ch]. Some day, we won't need these separate
makefiles for Win32 compilation. I hope.
* makefile.msc.in: Update. No use trying to build gmarshal.[ch]
here, it would require Unixish tools. MSVC users building from CVS
sources are out of luck.
* gobject.def: Update.
2000-12-14 22:02:20 +01:00
|
|
|
return result;
|
|
|
|
|
}
|
Finally, a new and improved IO Channel and condition watch implementation
2000-07-30 Tor Lillqvist <tml@iki.fi>
Finally, a new and improved IO Channel and condition watch
implementation for Win32. Based on code provided by Craig Setera.
When watching file descriptors, for which there is no select()
like functionality on Win32 that would work on all Win32 platforms
for all types of file descriptors (including anonymous pipes), we
start a new thread that blocks while trying to read from the file
descriptor. When the read returns, a Win32 Event is signalled that
the polling routine eventually notices. Meanwhile, the data being
read is stored in a circular buffer, from where the IO channel's
read() method picks it up.
If the buffer fills up the reading thread has to wait for space
becoming available. For this another Win32 Event is used. The IO
Channel's read() method signals this when it has read some data
out of the buffer.
The separate reader thread(s), and the circular buffer(s) with
associated events mean lots of possibilities for fun parallellism
errors. But it seems to work OK, i.e. GIMP runs.
* gmain.c: Small changes to the Win32 polling function.
(g_main_win32_get_poll_func): New function. Perhaps it would be a
good idea to provide this on all platforms.
* giowin32.c: The bulk of the new implementation.
(g_io_channel_win32_wait_for_condition): New function. To be used
where on Unix one does a select() on the channel's fd, like
libgimp's gimp_extension_process(). Could be provided on all
platforms.
* glib.h: Update documentation for IO Channels on Win32. Remove
the declarations for the as of now obsolete old functions related
to IO Channels for pipes with "wakeup" messages.
* glib.def: Some new functions.
* tests/gio-test.c: New file, to test GIOChannel and main loop.
* tests/Makefile.am
* tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/* HOLDS: context's lock */
|
1999-07-24 20:50:58 +02:00
|
|
|
/* Wake the main loop up from a poll() */
|
|
|
|
|
static void
|
2001-06-30 21:56:47 +02:00
|
|
|
g_main_context_wakeup_unlocked (GMainContext *context)
|
1999-07-24 20:50:58 +02:00
|
|
|
{
|
|
|
|
|
#ifdef G_THREADS_ENABLED
|
2000-12-05 21:45:33 +01:00
|
|
|
if (g_thread_supported() && context->poll_waiting)
|
1999-07-24 20:50:58 +02:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
context->poll_waiting = FALSE;
|
1999-10-04 04:32:50 +02:00
|
|
|
#ifndef G_OS_WIN32
|
2000-12-05 21:45:33 +01:00
|
|
|
write (context->wake_up_pipe[1], "A", 1);
|
1999-07-24 20:50:58 +02:00
|
|
|
#else
|
Warn if no callback. Call callback correctly. (g_io_win32_create_watch):
2000-12-14 Tor Lillqvist <tml@iki.fi>
* giowin32.c (g_io_win32_dispatch): Warn if no callback. Call
callback correctly.
(g_io_win32_create_watch): Fix typo.
(g_io_win32_fd_create_watch): Ditto.
(g_io_channel_unix_new): If it is a file descriptor (i.e., a Unix
fd lookalike provided by the C library), call
g_io_channel_win32_new_fd(). If it is a socket (from WinSock),
call g_io_cahnnel_win32_new_stream_socket(). Hopefully sockets and
fds don't overlap. TODO: Implement also datagram sockets.
(g_io_channel_win32_poll): Call g_main_context_get_poll_func().
* gcompletion.h: Include <unistd.h> only on Unix. Is this
inclusion really needed here? OTOH, do include <stddef.h>, for
size_t.
* gmessages.c: (Win32) Don't define a function called "write" that
might clash with the prototype from <io.h>, use a #define.
* glib.def: Update.
* gmain.c (g_source_add_poll): Don't return a value from void
function.
(g_main_context_get_poll_func): Compile also for non-Win32, as
presumably was intended. The result var is a GPollFunc, not a
GPollFunc*. Return the result!
gobject:
2000-12-14 Tor Lillqvist <tml@iki.fi>
* makefile.mingw.in: Update, include parts from Makefile.am to
build gmarshal.[ch]. Some day, we won't need these separate
makefiles for Win32 compilation. I hope.
* makefile.msc.in: Update. No use trying to build gmarshal.[ch]
here, it would require Unixish tools. MSVC users building from CVS
sources are out of luck.
* gobject.def: Update.
2000-12-14 22:02:20 +01:00
|
|
|
ReleaseSemaphore (context->wake_up_semaphore, 1, NULL);
|
1999-07-24 20:50:58 +02:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2001-06-30 21:56:47 +02:00
|
|
|
/**
|
|
|
|
|
* g_main_context_wakeup:
|
|
|
|
|
* @context: a #GMainContext
|
|
|
|
|
*
|
2003-07-25 23:32:47 +02:00
|
|
|
* If @context is currently waiting in a poll(), interrupt
|
|
|
|
|
* the poll(), and continue the iteration process.
|
2001-06-30 21:56:47 +02:00
|
|
|
**/
|
|
|
|
|
void
|
|
|
|
|
g_main_context_wakeup (GMainContext *context)
|
|
|
|
|
{
|
|
|
|
|
if (!context)
|
|
|
|
|
context = g_main_context_default ();
|
|
|
|
|
|
2004-03-04 11:12:55 +01:00
|
|
|
g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
|
2001-06-30 21:56:47 +02:00
|
|
|
|
|
|
|
|
LOCK_CONTEXT (context);
|
|
|
|
|
g_main_context_wakeup_unlocked (context);
|
|
|
|
|
UNLOCK_CONTEXT (context);
|
|
|
|
|
}
|
|
|
|
|
|
1998-12-02 15:55:27 +01:00
|
|
|
/* Timeouts */
|
|
|
|
|
|
2000-03-01 10:44:10 +01:00
|
|
|
static void
|
2000-12-05 21:45:33 +01:00
|
|
|
g_timeout_set_expiration (GTimeoutSource *timeout_source,
|
|
|
|
|
GTimeVal *current_time)
|
2000-03-01 10:44:10 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
guint seconds = timeout_source->interval / 1000;
|
|
|
|
|
guint msecs = timeout_source->interval - seconds * 1000;
|
2000-03-01 10:44:10 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
timeout_source->expiration.tv_sec = current_time->tv_sec + seconds;
|
|
|
|
|
timeout_source->expiration.tv_usec = current_time->tv_usec + msecs * 1000;
|
|
|
|
|
if (timeout_source->expiration.tv_usec >= 1000000)
|
2000-03-01 10:44:10 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
timeout_source->expiration.tv_usec -= 1000000;
|
|
|
|
|
timeout_source->expiration.tv_sec++;
|
2000-03-01 10:44:10 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
2000-12-05 21:45:33 +01:00
|
|
|
g_timeout_prepare (GSource *source,
|
|
|
|
|
gint *timeout)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
Changes for 64-bit cleanliness, loosely based on patch from Mark Murnane.
Wed Jun 20 12:00:54 2001 Owen Taylor <otaylor@redhat.com>
Changes for 64-bit cleanliness, loosely based on patch
from Mark Murnane.
* gconvert.c (g_convert/g_convert_with_fallback): Remove
workarounds for since-fixed GNU libc bugs. Minor
doc fix.
* gconvert.[ch]: Change gint to gsize/gssize as
appropriate.
* gconvert.c (g_locale/filename_to/from_utf8): Fix incorrect
computation of bytes_read / bytes_written.
* gfileutils.[ch] (g_file_get_contents): Make length
out parameter 'gsize *len'.
* ghook.c (g_hook_compare_ids): Don't compare a
and b as 'a - b'.
* gmacros.h (GSIZE_TO_POINTER): Add GPOINTER_TO_SIZE,
GSIZE_TO_POINTER.
* gmain.c (g_timeout_prepare): Rewrite to avoid
overflows. (Fixes bug when system clock skews
backwards more than 24 days.)
* gmarkup.[ch]: Make lengths passed to callbacks
gsize, length for g_markup_parse-context_parse(),
g_markup_escape_text() gssize.
* gmessages.[ch] (g_printf_string_upper_bound): Change
return value to gsize.
* gmessages.c (printf_string_upper_bound): Remove
a ridiculous use of 'inline' on a 300 line function.
* gstring.[ch]: Represent size of string as a gsize,
not gint. Make parameters to functions take gsize,
or gssize where -1 is allowed.
* gstring.c (g_string_erase): Make
g_string_erase (string, pos, -1) a synonym for
g_string_truncate for consistency with other G*
APIs.
* gstrfuncs.[ch]: Make all functions taking a string
length, take a gsize, or gssize if -1 is allowed.
(g_strstr_len, g_strrstr_len). Also fix some boundary
conditions in g_str[r]str[_len].
* gutf8.c tests/unicode-encoding.c: Make parameters that
are byte lengths gsize, gssize as appropriate. Make
character offsets, other counts, glong.
* gasyncqueue.c gcompletion.c
timeloop.c timeloop-basic.c gutils.c gspawn.c.
Small 64 bit cleanliness fixups.
* glist.c (g_list_sort2, g_list_sort_real): Fix functions
that should have been static.
* gdate.c (g_date_fill_parse_tokens): Fix extra
declaration that was shadowing another.
* tests/module-test.c: Include string.h
Mon Jun 18 15:43:29 2001 Owen Taylor <otaylor@redhat.com>
* gutf8.c (g_get_charset): Make argument
G_CONST_RETURN char **.
2001-06-23 15:55:09 +02:00
|
|
|
glong sec;
|
1998-12-02 15:55:27 +01:00
|
|
|
glong msec;
|
2000-12-05 21:45:33 +01:00
|
|
|
GTimeVal current_time;
|
2000-03-01 10:44:10 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
GTimeoutSource *timeout_source = (GTimeoutSource *)source;
|
|
|
|
|
|
|
|
|
|
g_source_get_current_time (source, ¤t_time);
|
|
|
|
|
|
Changes for 64-bit cleanliness, loosely based on patch from Mark Murnane.
Wed Jun 20 12:00:54 2001 Owen Taylor <otaylor@redhat.com>
Changes for 64-bit cleanliness, loosely based on patch
from Mark Murnane.
* gconvert.c (g_convert/g_convert_with_fallback): Remove
workarounds for since-fixed GNU libc bugs. Minor
doc fix.
* gconvert.[ch]: Change gint to gsize/gssize as
appropriate.
* gconvert.c (g_locale/filename_to/from_utf8): Fix incorrect
computation of bytes_read / bytes_written.
* gfileutils.[ch] (g_file_get_contents): Make length
out parameter 'gsize *len'.
* ghook.c (g_hook_compare_ids): Don't compare a
and b as 'a - b'.
* gmacros.h (GSIZE_TO_POINTER): Add GPOINTER_TO_SIZE,
GSIZE_TO_POINTER.
* gmain.c (g_timeout_prepare): Rewrite to avoid
overflows. (Fixes bug when system clock skews
backwards more than 24 days.)
* gmarkup.[ch]: Make lengths passed to callbacks
gsize, length for g_markup_parse-context_parse(),
g_markup_escape_text() gssize.
* gmessages.[ch] (g_printf_string_upper_bound): Change
return value to gsize.
* gmessages.c (printf_string_upper_bound): Remove
a ridiculous use of 'inline' on a 300 line function.
* gstring.[ch]: Represent size of string as a gsize,
not gint. Make parameters to functions take gsize,
or gssize where -1 is allowed.
* gstring.c (g_string_erase): Make
g_string_erase (string, pos, -1) a synonym for
g_string_truncate for consistency with other G*
APIs.
* gstrfuncs.[ch]: Make all functions taking a string
length, take a gsize, or gssize if -1 is allowed.
(g_strstr_len, g_strrstr_len). Also fix some boundary
conditions in g_str[r]str[_len].
* gutf8.c tests/unicode-encoding.c: Make parameters that
are byte lengths gsize, gssize as appropriate. Make
character offsets, other counts, glong.
* gasyncqueue.c gcompletion.c
timeloop.c timeloop-basic.c gutils.c gspawn.c.
Small 64 bit cleanliness fixups.
* glist.c (g_list_sort2, g_list_sort_real): Fix functions
that should have been static.
* gdate.c (g_date_fill_parse_tokens): Fix extra
declaration that was shadowing another.
* tests/module-test.c: Include string.h
Mon Jun 18 15:43:29 2001 Owen Taylor <otaylor@redhat.com>
* gutf8.c (g_get_charset): Make argument
G_CONST_RETURN char **.
2001-06-23 15:55:09 +02:00
|
|
|
sec = timeout_source->expiration.tv_sec - current_time.tv_sec;
|
|
|
|
|
msec = (timeout_source->expiration.tv_usec - current_time.tv_usec) / 1000;
|
|
|
|
|
|
|
|
|
|
/* We do the following in a rather convoluted fashion to deal with
|
|
|
|
|
* the fact that we don't have an integral type big enough to hold
|
|
|
|
|
* the difference of two timevals in millseconds.
|
|
|
|
|
*/
|
|
|
|
|
if (sec < 0 || (sec == 0 && msec < 0))
|
2000-03-01 10:44:10 +01:00
|
|
|
msec = 0;
|
Changes for 64-bit cleanliness, loosely based on patch from Mark Murnane.
Wed Jun 20 12:00:54 2001 Owen Taylor <otaylor@redhat.com>
Changes for 64-bit cleanliness, loosely based on patch
from Mark Murnane.
* gconvert.c (g_convert/g_convert_with_fallback): Remove
workarounds for since-fixed GNU libc bugs. Minor
doc fix.
* gconvert.[ch]: Change gint to gsize/gssize as
appropriate.
* gconvert.c (g_locale/filename_to/from_utf8): Fix incorrect
computation of bytes_read / bytes_written.
* gfileutils.[ch] (g_file_get_contents): Make length
out parameter 'gsize *len'.
* ghook.c (g_hook_compare_ids): Don't compare a
and b as 'a - b'.
* gmacros.h (GSIZE_TO_POINTER): Add GPOINTER_TO_SIZE,
GSIZE_TO_POINTER.
* gmain.c (g_timeout_prepare): Rewrite to avoid
overflows. (Fixes bug when system clock skews
backwards more than 24 days.)
* gmarkup.[ch]: Make lengths passed to callbacks
gsize, length for g_markup_parse-context_parse(),
g_markup_escape_text() gssize.
* gmessages.[ch] (g_printf_string_upper_bound): Change
return value to gsize.
* gmessages.c (printf_string_upper_bound): Remove
a ridiculous use of 'inline' on a 300 line function.
* gstring.[ch]: Represent size of string as a gsize,
not gint. Make parameters to functions take gsize,
or gssize where -1 is allowed.
* gstring.c (g_string_erase): Make
g_string_erase (string, pos, -1) a synonym for
g_string_truncate for consistency with other G*
APIs.
* gstrfuncs.[ch]: Make all functions taking a string
length, take a gsize, or gssize if -1 is allowed.
(g_strstr_len, g_strrstr_len). Also fix some boundary
conditions in g_str[r]str[_len].
* gutf8.c tests/unicode-encoding.c: Make parameters that
are byte lengths gsize, gssize as appropriate. Make
character offsets, other counts, glong.
* gasyncqueue.c gcompletion.c
timeloop.c timeloop-basic.c gutils.c gspawn.c.
Small 64 bit cleanliness fixups.
* glist.c (g_list_sort2, g_list_sort_real): Fix functions
that should have been static.
* gdate.c (g_date_fill_parse_tokens): Fix extra
declaration that was shadowing another.
* tests/module-test.c: Include string.h
Mon Jun 18 15:43:29 2001 Owen Taylor <otaylor@redhat.com>
* gutf8.c (g_get_charset): Make argument
G_CONST_RETURN char **.
2001-06-23 15:55:09 +02:00
|
|
|
else
|
2000-03-01 10:44:10 +01:00
|
|
|
{
|
Changes for 64-bit cleanliness, loosely based on patch from Mark Murnane.
Wed Jun 20 12:00:54 2001 Owen Taylor <otaylor@redhat.com>
Changes for 64-bit cleanliness, loosely based on patch
from Mark Murnane.
* gconvert.c (g_convert/g_convert_with_fallback): Remove
workarounds for since-fixed GNU libc bugs. Minor
doc fix.
* gconvert.[ch]: Change gint to gsize/gssize as
appropriate.
* gconvert.c (g_locale/filename_to/from_utf8): Fix incorrect
computation of bytes_read / bytes_written.
* gfileutils.[ch] (g_file_get_contents): Make length
out parameter 'gsize *len'.
* ghook.c (g_hook_compare_ids): Don't compare a
and b as 'a - b'.
* gmacros.h (GSIZE_TO_POINTER): Add GPOINTER_TO_SIZE,
GSIZE_TO_POINTER.
* gmain.c (g_timeout_prepare): Rewrite to avoid
overflows. (Fixes bug when system clock skews
backwards more than 24 days.)
* gmarkup.[ch]: Make lengths passed to callbacks
gsize, length for g_markup_parse-context_parse(),
g_markup_escape_text() gssize.
* gmessages.[ch] (g_printf_string_upper_bound): Change
return value to gsize.
* gmessages.c (printf_string_upper_bound): Remove
a ridiculous use of 'inline' on a 300 line function.
* gstring.[ch]: Represent size of string as a gsize,
not gint. Make parameters to functions take gsize,
or gssize where -1 is allowed.
* gstring.c (g_string_erase): Make
g_string_erase (string, pos, -1) a synonym for
g_string_truncate for consistency with other G*
APIs.
* gstrfuncs.[ch]: Make all functions taking a string
length, take a gsize, or gssize if -1 is allowed.
(g_strstr_len, g_strrstr_len). Also fix some boundary
conditions in g_str[r]str[_len].
* gutf8.c tests/unicode-encoding.c: Make parameters that
are byte lengths gsize, gssize as appropriate. Make
character offsets, other counts, glong.
* gasyncqueue.c gcompletion.c
timeloop.c timeloop-basic.c gutils.c gspawn.c.
Small 64 bit cleanliness fixups.
* glist.c (g_list_sort2, g_list_sort_real): Fix functions
that should have been static.
* gdate.c (g_date_fill_parse_tokens): Fix extra
declaration that was shadowing another.
* tests/module-test.c: Include string.h
Mon Jun 18 15:43:29 2001 Owen Taylor <otaylor@redhat.com>
* gutf8.c (g_get_charset): Make argument
G_CONST_RETURN char **.
2001-06-23 15:55:09 +02:00
|
|
|
glong interval_sec = timeout_source->interval / 1000;
|
|
|
|
|
glong interval_msec = timeout_source->interval % 1000;
|
|
|
|
|
|
|
|
|
|
if (msec < 0)
|
|
|
|
|
{
|
|
|
|
|
msec += 1000;
|
|
|
|
|
sec -= 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (sec > interval_sec ||
|
|
|
|
|
(sec == interval_sec && msec > interval_msec))
|
|
|
|
|
{
|
|
|
|
|
/* The system time has been set backwards, so we
|
|
|
|
|
* reset the expiration time to now + timeout_source->interval;
|
|
|
|
|
* this at least avoids hanging for long periods of time.
|
|
|
|
|
*/
|
|
|
|
|
g_timeout_set_expiration (timeout_source, ¤t_time);
|
2002-06-13 22:14:43 +02:00
|
|
|
msec = MIN (G_MAXINT, timeout_source->interval);
|
Changes for 64-bit cleanliness, loosely based on patch from Mark Murnane.
Wed Jun 20 12:00:54 2001 Owen Taylor <otaylor@redhat.com>
Changes for 64-bit cleanliness, loosely based on patch
from Mark Murnane.
* gconvert.c (g_convert/g_convert_with_fallback): Remove
workarounds for since-fixed GNU libc bugs. Minor
doc fix.
* gconvert.[ch]: Change gint to gsize/gssize as
appropriate.
* gconvert.c (g_locale/filename_to/from_utf8): Fix incorrect
computation of bytes_read / bytes_written.
* gfileutils.[ch] (g_file_get_contents): Make length
out parameter 'gsize *len'.
* ghook.c (g_hook_compare_ids): Don't compare a
and b as 'a - b'.
* gmacros.h (GSIZE_TO_POINTER): Add GPOINTER_TO_SIZE,
GSIZE_TO_POINTER.
* gmain.c (g_timeout_prepare): Rewrite to avoid
overflows. (Fixes bug when system clock skews
backwards more than 24 days.)
* gmarkup.[ch]: Make lengths passed to callbacks
gsize, length for g_markup_parse-context_parse(),
g_markup_escape_text() gssize.
* gmessages.[ch] (g_printf_string_upper_bound): Change
return value to gsize.
* gmessages.c (printf_string_upper_bound): Remove
a ridiculous use of 'inline' on a 300 line function.
* gstring.[ch]: Represent size of string as a gsize,
not gint. Make parameters to functions take gsize,
or gssize where -1 is allowed.
* gstring.c (g_string_erase): Make
g_string_erase (string, pos, -1) a synonym for
g_string_truncate for consistency with other G*
APIs.
* gstrfuncs.[ch]: Make all functions taking a string
length, take a gsize, or gssize if -1 is allowed.
(g_strstr_len, g_strrstr_len). Also fix some boundary
conditions in g_str[r]str[_len].
* gutf8.c tests/unicode-encoding.c: Make parameters that
are byte lengths gsize, gssize as appropriate. Make
character offsets, other counts, glong.
* gasyncqueue.c gcompletion.c
timeloop.c timeloop-basic.c gutils.c gspawn.c.
Small 64 bit cleanliness fixups.
* glist.c (g_list_sort2, g_list_sort_real): Fix functions
that should have been static.
* gdate.c (g_date_fill_parse_tokens): Fix extra
declaration that was shadowing another.
* tests/module-test.c: Include string.h
Mon Jun 18 15:43:29 2001 Owen Taylor <otaylor@redhat.com>
* gutf8.c (g_get_charset): Make argument
G_CONST_RETURN char **.
2001-06-23 15:55:09 +02:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2002-06-13 22:14:43 +02:00
|
|
|
msec = MIN (G_MAXINT, (guint)msec + 1000 * (guint)sec);
|
Changes for 64-bit cleanliness, loosely based on patch from Mark Murnane.
Wed Jun 20 12:00:54 2001 Owen Taylor <otaylor@redhat.com>
Changes for 64-bit cleanliness, loosely based on patch
from Mark Murnane.
* gconvert.c (g_convert/g_convert_with_fallback): Remove
workarounds for since-fixed GNU libc bugs. Minor
doc fix.
* gconvert.[ch]: Change gint to gsize/gssize as
appropriate.
* gconvert.c (g_locale/filename_to/from_utf8): Fix incorrect
computation of bytes_read / bytes_written.
* gfileutils.[ch] (g_file_get_contents): Make length
out parameter 'gsize *len'.
* ghook.c (g_hook_compare_ids): Don't compare a
and b as 'a - b'.
* gmacros.h (GSIZE_TO_POINTER): Add GPOINTER_TO_SIZE,
GSIZE_TO_POINTER.
* gmain.c (g_timeout_prepare): Rewrite to avoid
overflows. (Fixes bug when system clock skews
backwards more than 24 days.)
* gmarkup.[ch]: Make lengths passed to callbacks
gsize, length for g_markup_parse-context_parse(),
g_markup_escape_text() gssize.
* gmessages.[ch] (g_printf_string_upper_bound): Change
return value to gsize.
* gmessages.c (printf_string_upper_bound): Remove
a ridiculous use of 'inline' on a 300 line function.
* gstring.[ch]: Represent size of string as a gsize,
not gint. Make parameters to functions take gsize,
or gssize where -1 is allowed.
* gstring.c (g_string_erase): Make
g_string_erase (string, pos, -1) a synonym for
g_string_truncate for consistency with other G*
APIs.
* gstrfuncs.[ch]: Make all functions taking a string
length, take a gsize, or gssize if -1 is allowed.
(g_strstr_len, g_strrstr_len). Also fix some boundary
conditions in g_str[r]str[_len].
* gutf8.c tests/unicode-encoding.c: Make parameters that
are byte lengths gsize, gssize as appropriate. Make
character offsets, other counts, glong.
* gasyncqueue.c gcompletion.c
timeloop.c timeloop-basic.c gutils.c gspawn.c.
Small 64 bit cleanliness fixups.
* glist.c (g_list_sort2, g_list_sort_real): Fix functions
that should have been static.
* gdate.c (g_date_fill_parse_tokens): Fix extra
declaration that was shadowing another.
* tests/module-test.c: Include string.h
Mon Jun 18 15:43:29 2001 Owen Taylor <otaylor@redhat.com>
* gutf8.c (g_get_charset): Make argument
G_CONST_RETURN char **.
2001-06-23 15:55:09 +02:00
|
|
|
}
|
2000-03-01 10:44:10 +01:00
|
|
|
}
|
Changes for 64-bit cleanliness, loosely based on patch from Mark Murnane.
Wed Jun 20 12:00:54 2001 Owen Taylor <otaylor@redhat.com>
Changes for 64-bit cleanliness, loosely based on patch
from Mark Murnane.
* gconvert.c (g_convert/g_convert_with_fallback): Remove
workarounds for since-fixed GNU libc bugs. Minor
doc fix.
* gconvert.[ch]: Change gint to gsize/gssize as
appropriate.
* gconvert.c (g_locale/filename_to/from_utf8): Fix incorrect
computation of bytes_read / bytes_written.
* gfileutils.[ch] (g_file_get_contents): Make length
out parameter 'gsize *len'.
* ghook.c (g_hook_compare_ids): Don't compare a
and b as 'a - b'.
* gmacros.h (GSIZE_TO_POINTER): Add GPOINTER_TO_SIZE,
GSIZE_TO_POINTER.
* gmain.c (g_timeout_prepare): Rewrite to avoid
overflows. (Fixes bug when system clock skews
backwards more than 24 days.)
* gmarkup.[ch]: Make lengths passed to callbacks
gsize, length for g_markup_parse-context_parse(),
g_markup_escape_text() gssize.
* gmessages.[ch] (g_printf_string_upper_bound): Change
return value to gsize.
* gmessages.c (printf_string_upper_bound): Remove
a ridiculous use of 'inline' on a 300 line function.
* gstring.[ch]: Represent size of string as a gsize,
not gint. Make parameters to functions take gsize,
or gssize where -1 is allowed.
* gstring.c (g_string_erase): Make
g_string_erase (string, pos, -1) a synonym for
g_string_truncate for consistency with other G*
APIs.
* gstrfuncs.[ch]: Make all functions taking a string
length, take a gsize, or gssize if -1 is allowed.
(g_strstr_len, g_strrstr_len). Also fix some boundary
conditions in g_str[r]str[_len].
* gutf8.c tests/unicode-encoding.c: Make parameters that
are byte lengths gsize, gssize as appropriate. Make
character offsets, other counts, glong.
* gasyncqueue.c gcompletion.c
timeloop.c timeloop-basic.c gutils.c gspawn.c.
Small 64 bit cleanliness fixups.
* glist.c (g_list_sort2, g_list_sort_real): Fix functions
that should have been static.
* gdate.c (g_date_fill_parse_tokens): Fix extra
declaration that was shadowing another.
* tests/module-test.c: Include string.h
Mon Jun 18 15:43:29 2001 Owen Taylor <otaylor@redhat.com>
* gutf8.c (g_get_charset): Make argument
G_CONST_RETURN char **.
2001-06-23 15:55:09 +02:00
|
|
|
|
|
|
|
|
*timeout = (gint)msec;
|
2000-03-01 10:44:10 +01:00
|
|
|
|
|
|
|
|
return msec == 0;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
2000-12-05 21:45:33 +01:00
|
|
|
g_timeout_check (GSource *source)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
GTimeVal current_time;
|
|
|
|
|
GTimeoutSource *timeout_source = (GTimeoutSource *)source;
|
|
|
|
|
|
|
|
|
|
g_source_get_current_time (source, ¤t_time);
|
2000-03-01 10:44:10 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
return ((timeout_source->expiration.tv_sec < current_time.tv_sec) ||
|
|
|
|
|
((timeout_source->expiration.tv_sec == current_time.tv_sec) &&
|
|
|
|
|
(timeout_source->expiration.tv_usec <= current_time.tv_usec)));
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
2000-12-05 21:45:33 +01:00
|
|
|
g_timeout_dispatch (GSource *source,
|
|
|
|
|
GSourceFunc callback,
|
|
|
|
|
gpointer user_data)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
GTimeoutSource *timeout_source = (GTimeoutSource *)source;
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (!callback)
|
|
|
|
|
{
|
|
|
|
|
g_warning ("Timeout source dispatched without callback\n"
|
|
|
|
|
"You must call g_source_set_callback().");
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (callback (user_data))
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
GTimeVal current_time;
|
|
|
|
|
|
|
|
|
|
g_source_get_current_time (source, ¤t_time);
|
|
|
|
|
g_timeout_set_expiration (timeout_source, ¤t_time);
|
1998-12-18 18:52:18 +01:00
|
|
|
|
1998-12-02 15:55:27 +01:00
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_timeout_source_new:
|
|
|
|
|
* @interval: the timeout interval in milliseconds.
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Creates a new timeout source.
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
|
|
|
|
* The source will not initially be associated with any #GMainContext
|
|
|
|
|
* and must be added to one with g_source_attach() before it will be
|
|
|
|
|
* executed.
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Return value: the newly-created timeout source
|
2000-12-05 21:45:33 +01:00
|
|
|
**/
|
|
|
|
|
GSource *
|
|
|
|
|
g_timeout_source_new (guint interval)
|
|
|
|
|
{
|
2001-09-04 00:12:51 +02:00
|
|
|
GSource *source = g_source_new (&g_timeout_funcs, sizeof (GTimeoutSource));
|
2000-12-05 21:45:33 +01:00
|
|
|
GTimeoutSource *timeout_source = (GTimeoutSource *)source;
|
|
|
|
|
GTimeVal current_time;
|
|
|
|
|
|
|
|
|
|
timeout_source->interval = interval;
|
|
|
|
|
|
|
|
|
|
g_get_current_time (¤t_time);
|
|
|
|
|
g_timeout_set_expiration (timeout_source, ¤t_time);
|
|
|
|
|
|
|
|
|
|
return source;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_timeout_add_full:
|
|
|
|
|
* @priority: the priority of the idle source. Typically this will be in the
|
2001-12-16 20:31:36 +01:00
|
|
|
* range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
|
2000-12-05 21:45:33 +01:00
|
|
|
* @interval: the time between calls to the function, in milliseconds
|
2001-12-16 20:31:36 +01:00
|
|
|
* (1/1000ths of a second)
|
2000-12-05 21:45:33 +01:00
|
|
|
* @function: function to call
|
|
|
|
|
* @data: data to pass to @function
|
|
|
|
|
* @notify: function to call when the idle is removed, or %NULL
|
|
|
|
|
*
|
|
|
|
|
* Sets a function to be called at regular intervals, with the given
|
|
|
|
|
* priority. The function is called repeatedly until it returns
|
2001-12-16 20:31:36 +01:00
|
|
|
* %FALSE, at which point the timeout is automatically destroyed and
|
2000-12-05 21:45:33 +01:00
|
|
|
* the function will not be called again. The @notify function is
|
|
|
|
|
* called when the timeout is destroyed. The first call to the
|
|
|
|
|
* function will be at the end of the first @interval.
|
|
|
|
|
*
|
|
|
|
|
* Note that timeout functions may be delayed, due to the processing of other
|
|
|
|
|
* event sources. Thus they should not be relied on for precise timing.
|
|
|
|
|
* After each call to the timeout function, the time of the next
|
|
|
|
|
* timeout is recalculated based on the current time and the given interval
|
|
|
|
|
* (it does not try to 'catch up' time lost in delays).
|
|
|
|
|
*
|
|
|
|
|
* Return value: the id of event source.
|
|
|
|
|
**/
|
2000-03-01 10:44:10 +01:00
|
|
|
guint
|
1998-12-02 15:55:27 +01:00
|
|
|
g_timeout_add_full (gint priority,
|
2000-03-01 10:44:10 +01:00
|
|
|
guint interval,
|
1998-12-02 15:55:27 +01:00
|
|
|
GSourceFunc function,
|
|
|
|
|
gpointer data,
|
|
|
|
|
GDestroyNotify notify)
|
|
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
GSource *source;
|
2000-12-07 21:29:58 +01:00
|
|
|
guint id;
|
2000-12-05 21:45:33 +01:00
|
|
|
|
|
|
|
|
g_return_val_if_fail (function != NULL, 0);
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
source = g_timeout_source_new (interval);
|
1998-12-18 18:52:18 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
if (priority != G_PRIORITY_DEFAULT)
|
|
|
|
|
g_source_set_priority (source, priority);
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
g_source_set_callback (source, function, data, notify);
|
2000-12-07 21:29:58 +01:00
|
|
|
id = g_source_attach (source, NULL);
|
|
|
|
|
g_source_unref (source);
|
|
|
|
|
|
|
|
|
|
return id;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_timeout_add:
|
|
|
|
|
* @interval: the time between calls to the function, in milliseconds
|
2001-12-16 20:31:36 +01:00
|
|
|
* (1/1000ths of a second)
|
2000-12-05 21:45:33 +01:00
|
|
|
* @function: function to call
|
|
|
|
|
* @data: data to pass to @function
|
|
|
|
|
*
|
|
|
|
|
* Sets a function to be called at regular intervals, with the default
|
|
|
|
|
* priority, #G_PRIORITY_DEFAULT. The function is called repeatedly
|
2001-12-16 20:31:36 +01:00
|
|
|
* until it returns %FALSE, at which point the timeout is automatically
|
2002-07-26 01:04:22 +02:00
|
|
|
* destroyed and the function will not be called again. The first call
|
2000-12-05 21:45:33 +01:00
|
|
|
* to the function will be at the end of the first @interval.
|
|
|
|
|
*
|
|
|
|
|
* Note that timeout functions may be delayed, due to the processing of other
|
|
|
|
|
* event sources. Thus they should not be relied on for precise timing.
|
|
|
|
|
* After each call to the timeout function, the time of the next
|
|
|
|
|
* timeout is recalculated based on the current time and the given interval
|
|
|
|
|
* (it does not try to 'catch up' time lost in delays).
|
|
|
|
|
*
|
|
|
|
|
* Return value: the id of event source.
|
|
|
|
|
**/
|
1998-12-02 15:55:27 +01:00
|
|
|
guint
|
|
|
|
|
g_timeout_add (guint32 interval,
|
|
|
|
|
GSourceFunc function,
|
|
|
|
|
gpointer data)
|
|
|
|
|
{
|
1998-12-19 23:21:39 +01:00
|
|
|
return g_timeout_add_full (G_PRIORITY_DEFAULT,
|
|
|
|
|
interval, function, data, NULL);
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2004-02-14 01:23:36 +01:00
|
|
|
/* Child watch functions */
|
|
|
|
|
|
2004-02-28 14:03:55 +01:00
|
|
|
#ifdef G_OS_WIN32
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
g_child_watch_prepare (GSource *source,
|
|
|
|
|
gint *timeout)
|
|
|
|
|
{
|
|
|
|
|
*timeout = -1;
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
g_child_watch_check (GSource *source)
|
|
|
|
|
{
|
|
|
|
|
GChildWatchSource *child_watch_source;
|
|
|
|
|
gboolean child_exited;
|
|
|
|
|
|
|
|
|
|
child_watch_source = (GChildWatchSource *) source;
|
|
|
|
|
|
|
|
|
|
child_exited = child_watch_source->poll.revents & G_IO_IN;
|
|
|
|
|
|
|
|
|
|
if (child_exited)
|
|
|
|
|
{
|
|
|
|
|
DWORD child_status;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Note: We do _not_ check for the special value of STILL_ACTIVE
|
|
|
|
|
* since we know that the process has exited and doing so runs into
|
|
|
|
|
* problems if the child process "happens to return STILL_ACTIVE(259)"
|
|
|
|
|
* as Microsoft's Platform SDK puts it.
|
|
|
|
|
*/
|
|
|
|
|
if (!GetExitCodeProcess (child_watch_source->pid, &child_status))
|
|
|
|
|
{
|
|
|
|
|
gchar *emsg = g_win32_error_message (GetLastError ());
|
|
|
|
|
g_warning (G_STRLOC ": GetExitCodeProcess() failed: %s", emsg);
|
|
|
|
|
g_free (emsg);
|
|
|
|
|
|
|
|
|
|
child_watch_source->child_status = -1;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
child_watch_source->child_status = child_status;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return child_exited;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else /* G_OS_WIN32 */
|
|
|
|
|
|
2004-03-01 21:56:47 +01:00
|
|
|
static gboolean
|
2004-02-14 01:23:36 +01:00
|
|
|
check_for_child_exited (GSource *source)
|
|
|
|
|
{
|
|
|
|
|
GChildWatchSource *child_watch_source;
|
|
|
|
|
gint count;
|
|
|
|
|
|
|
|
|
|
/* protect against another SIGCHLD in the middle of this call */
|
|
|
|
|
count = child_watch_count;
|
|
|
|
|
|
|
|
|
|
child_watch_source = (GChildWatchSource *) source;
|
|
|
|
|
|
2004-03-01 21:56:47 +01:00
|
|
|
if (child_watch_source->child_exited)
|
|
|
|
|
return TRUE;
|
|
|
|
|
|
2004-02-14 01:23:36 +01:00
|
|
|
if (child_watch_source->count < count)
|
|
|
|
|
{
|
|
|
|
|
gint child_status;
|
|
|
|
|
|
|
|
|
|
if (waitpid (child_watch_source->pid, &child_status, WNOHANG) > 0)
|
|
|
|
|
{
|
|
|
|
|
child_watch_source->child_status = child_status;
|
|
|
|
|
child_watch_source->child_exited = TRUE;
|
|
|
|
|
}
|
|
|
|
|
child_watch_source->count = count;
|
|
|
|
|
}
|
2004-03-01 21:56:47 +01:00
|
|
|
|
|
|
|
|
return child_watch_source->child_exited;
|
2004-02-14 01:23:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
g_child_watch_prepare (GSource *source,
|
|
|
|
|
gint *timeout)
|
|
|
|
|
{
|
|
|
|
|
GChildWatchSource *child_watch_source;
|
|
|
|
|
*timeout = -1;
|
|
|
|
|
|
|
|
|
|
child_watch_source = (GChildWatchSource *) source;
|
|
|
|
|
|
2004-03-01 21:56:47 +01:00
|
|
|
return check_for_child_exited (source);
|
2004-02-14 01:23:36 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
g_child_watch_check (GSource *source)
|
|
|
|
|
{
|
|
|
|
|
GChildWatchSource *child_watch_source;
|
|
|
|
|
|
|
|
|
|
child_watch_source = (GChildWatchSource *) source;
|
|
|
|
|
|
2004-03-01 21:56:47 +01:00
|
|
|
return check_for_child_exited (source);
|
2004-02-14 01:23:36 +01:00
|
|
|
}
|
|
|
|
|
|
2004-02-28 14:03:55 +01:00
|
|
|
#endif /* G_OS_WIN32 */
|
|
|
|
|
|
2004-02-14 01:23:36 +01:00
|
|
|
static gboolean
|
|
|
|
|
g_child_watch_dispatch (GSource *source,
|
|
|
|
|
GSourceFunc callback,
|
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
GChildWatchSource *child_watch_source;
|
|
|
|
|
GChildWatchFunc child_watch_callback = (GChildWatchFunc) callback;
|
|
|
|
|
|
|
|
|
|
child_watch_source = (GChildWatchSource *) source;
|
|
|
|
|
|
|
|
|
|
if (!callback)
|
|
|
|
|
{
|
|
|
|
|
g_warning ("Child watch source dispatched without callback\n"
|
|
|
|
|
"You must call g_source_set_callback().");
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
(child_watch_callback) (child_watch_source->pid, child_watch_source->child_status, user_data);
|
|
|
|
|
|
|
|
|
|
/* We never keep a child watch source around as the child is gone */
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
2004-02-28 14:03:55 +01:00
|
|
|
#ifndef G_OS_WIN32
|
|
|
|
|
|
2004-02-14 01:23:36 +01:00
|
|
|
static void
|
|
|
|
|
g_child_watch_signal_handler (int signum)
|
|
|
|
|
{
|
|
|
|
|
child_watch_count ++;
|
|
|
|
|
|
|
|
|
|
if (child_watch_init_state == CHILD_WATCH_INITIALIZED_THREADED)
|
|
|
|
|
{
|
|
|
|
|
write (child_watch_wake_up_pipe[1], "B", 1);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* We count on the signal interrupting the poll in the same thread.
|
|
|
|
|
*/
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
g_child_watch_source_init_single (void)
|
|
|
|
|
{
|
|
|
|
|
g_assert (! g_thread_supported());
|
|
|
|
|
g_assert (child_watch_init_state == CHILD_WATCH_UNINITIALIZED);
|
|
|
|
|
|
|
|
|
|
child_watch_init_state = CHILD_WATCH_INITIALIZED_SINGLE;
|
|
|
|
|
|
|
|
|
|
signal (SIGCHLD, g_child_watch_signal_handler);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gpointer
|
|
|
|
|
child_watch_helper_thread (gpointer data)
|
|
|
|
|
{
|
|
|
|
|
GPollFD fds;
|
|
|
|
|
GPollFunc poll_func;
|
|
|
|
|
|
|
|
|
|
#ifdef HAVE_POLL
|
|
|
|
|
poll_func = (GPollFunc)poll;
|
|
|
|
|
#else
|
|
|
|
|
poll_func = g_poll;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
fds.fd = child_watch_wake_up_pipe[0];
|
|
|
|
|
fds.events = G_IO_IN;
|
|
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
gchar b[20];
|
|
|
|
|
GSList *list;
|
|
|
|
|
|
|
|
|
|
read (child_watch_wake_up_pipe[0], b, 20);
|
|
|
|
|
|
|
|
|
|
/* We were woken up. Wake up all other contexts in all other threads */
|
2004-03-04 11:12:55 +01:00
|
|
|
G_LOCK (main_context_list);
|
2004-02-14 01:23:36 +01:00
|
|
|
for (list = main_context_list; list; list = list->next)
|
|
|
|
|
{
|
|
|
|
|
GMainContext *context;
|
|
|
|
|
|
|
|
|
|
context = list->data;
|
2004-03-04 11:12:55 +01:00
|
|
|
if (g_atomic_int_get (&context->ref_count) > 0)
|
|
|
|
|
/* Due to racing conditions we can find ref_count == 0, in
|
|
|
|
|
* that case, however, the context is still not destroyed
|
|
|
|
|
* and no poll can be active, otherwise the ref_count
|
|
|
|
|
* wouldn't be 0 */
|
|
|
|
|
g_main_context_wakeup (context);
|
2004-02-14 01:23:36 +01:00
|
|
|
}
|
2004-03-04 11:12:55 +01:00
|
|
|
G_UNLOCK (main_context_list);
|
2004-02-14 01:23:36 +01:00
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
g_child_watch_source_init_multi_threaded (void)
|
|
|
|
|
{
|
|
|
|
|
GError *error = NULL;
|
|
|
|
|
|
|
|
|
|
g_assert (g_thread_supported());
|
|
|
|
|
|
|
|
|
|
if (pipe (child_watch_wake_up_pipe) < 0)
|
|
|
|
|
g_error ("Cannot create wake up pipe: %s\n", g_strerror (errno));
|
|
|
|
|
fcntl (child_watch_wake_up_pipe[1], F_SETFL, O_NONBLOCK | fcntl (child_watch_wake_up_pipe[1], F_GETFL));
|
|
|
|
|
|
|
|
|
|
/* We create a helper thread that polls on the wakeup pipe indefinitely */
|
|
|
|
|
/* FIXME: Think this through for races */
|
|
|
|
|
if (g_thread_create (child_watch_helper_thread, NULL, FALSE, &error) == NULL)
|
|
|
|
|
g_error ("Cannot create a thread to monitor child exit status: %s\n", error->message);
|
|
|
|
|
child_watch_init_state = CHILD_WATCH_INITIALIZED_THREADED;
|
|
|
|
|
signal (SIGCHLD, g_child_watch_signal_handler);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
g_child_watch_source_init_promote_single_to_threaded (void)
|
|
|
|
|
{
|
|
|
|
|
g_child_watch_source_init_multi_threaded ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
g_child_watch_source_init (void)
|
|
|
|
|
{
|
|
|
|
|
if (g_thread_supported())
|
|
|
|
|
{
|
|
|
|
|
if (child_watch_init_state == CHILD_WATCH_UNINITIALIZED)
|
|
|
|
|
g_child_watch_source_init_multi_threaded ();
|
|
|
|
|
else if (child_watch_init_state == CHILD_WATCH_INITIALIZED_SINGLE)
|
|
|
|
|
g_child_watch_source_init_promote_single_to_threaded ();
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (child_watch_init_state == CHILD_WATCH_UNINITIALIZED)
|
|
|
|
|
g_child_watch_source_init_single ();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2004-02-28 14:03:55 +01:00
|
|
|
#endif /* !G_OS_WIN32 */
|
|
|
|
|
|
2004-02-14 01:23:36 +01:00
|
|
|
/**
|
|
|
|
|
* g_child_watch_source_new:
|
2004-04-10 03:55:57 +02:00
|
|
|
* @pid: process id of a child process to watch. On Windows, a HANDLE
|
|
|
|
|
* for the process to watch (which actually doesn't have to be a child).
|
2004-02-14 01:23:36 +01:00
|
|
|
*
|
|
|
|
|
* Creates a new child_watch source.
|
|
|
|
|
*
|
|
|
|
|
* The source will not initially be associated with any #GMainContext
|
|
|
|
|
* and must be added to one with g_source_attach() before it will be
|
|
|
|
|
* executed.
|
|
|
|
|
*
|
2004-03-01 21:47:49 +01:00
|
|
|
* Note that on platforms where #GPid must be explicitely closed
|
|
|
|
|
* (see g_spawn_close_pid()) @pid must not be closed while the
|
|
|
|
|
* source is still active. Typically, you will want to call
|
|
|
|
|
* g_spawn_close_pid() in the callback function for the source.
|
|
|
|
|
*
|
2004-02-14 01:23:36 +01:00
|
|
|
* Return value: the newly-created child watch source
|
|
|
|
|
*
|
|
|
|
|
* Since: 2.4
|
|
|
|
|
**/
|
|
|
|
|
GSource *
|
|
|
|
|
g_child_watch_source_new (GPid pid)
|
|
|
|
|
{
|
|
|
|
|
GSource *source = g_source_new (&g_child_watch_funcs, sizeof (GChildWatchSource));
|
|
|
|
|
GChildWatchSource *child_watch_source = (GChildWatchSource *)source;
|
|
|
|
|
|
2004-02-28 14:03:55 +01:00
|
|
|
#ifdef G_OS_WIN32
|
|
|
|
|
child_watch_source->poll.fd = (int)pid;
|
|
|
|
|
child_watch_source->poll.events = G_IO_IN;
|
|
|
|
|
|
|
|
|
|
g_source_add_poll (source, &child_watch_source->poll);
|
|
|
|
|
#else /* G_OS_WIN32 */
|
2004-02-14 01:23:36 +01:00
|
|
|
g_child_watch_source_init ();
|
2004-02-28 14:03:55 +01:00
|
|
|
#endif /* G_OS_WIN32 */
|
2004-02-14 01:23:36 +01:00
|
|
|
|
|
|
|
|
child_watch_source->pid = pid;
|
|
|
|
|
|
|
|
|
|
return source;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_child_watch_add_full:
|
|
|
|
|
* @priority: the priority of the idle source. Typically this will be in the
|
|
|
|
|
* range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
|
|
|
|
|
* @pid: process id of a child process to watch
|
|
|
|
|
* @function: function to call
|
|
|
|
|
* @data: data to pass to @function
|
|
|
|
|
* @notify: function to call when the idle is removed, or %NULL
|
|
|
|
|
*
|
|
|
|
|
* Sets a function to be called when the child indicated by @pid exits, at a
|
|
|
|
|
* default priority, #G_PRIORITY_DEFAULT.
|
|
|
|
|
*
|
2004-03-01 21:47:49 +01:00
|
|
|
* Note that on platforms where #GPid must be explicitely closed
|
|
|
|
|
* (see g_spawn_close_pid()) @pid must not be closed while the
|
|
|
|
|
* source is still active. Typically, you will want to call
|
|
|
|
|
* g_spawn_close_pid() in the callback function for the source.
|
|
|
|
|
*
|
2004-02-14 01:23:36 +01:00
|
|
|
* Return value: the id of event source.
|
|
|
|
|
*
|
|
|
|
|
* Since: 2.4
|
|
|
|
|
**/
|
|
|
|
|
guint
|
|
|
|
|
g_child_watch_add_full (gint priority,
|
|
|
|
|
GPid pid,
|
|
|
|
|
GChildWatchFunc function,
|
|
|
|
|
gpointer data,
|
|
|
|
|
GDestroyNotify notify)
|
|
|
|
|
{
|
|
|
|
|
GSource *source;
|
|
|
|
|
guint id;
|
|
|
|
|
|
|
|
|
|
g_return_val_if_fail (function != NULL, 0);
|
|
|
|
|
|
|
|
|
|
source = g_child_watch_source_new (pid);
|
|
|
|
|
|
|
|
|
|
if (priority != G_PRIORITY_DEFAULT)
|
|
|
|
|
g_source_set_priority (source, priority);
|
|
|
|
|
|
|
|
|
|
g_source_set_callback (source, (GSourceFunc) function, data, notify);
|
|
|
|
|
id = g_source_attach (source, NULL);
|
|
|
|
|
g_source_unref (source);
|
|
|
|
|
|
|
|
|
|
return id;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* g_child_watch_add:
|
|
|
|
|
* @pid: process id of a child process to watch
|
|
|
|
|
* @function: function to call
|
|
|
|
|
* @data: data to pass to @function
|
|
|
|
|
*
|
|
|
|
|
* Sets a function to be called when the child indicated by @pid exits, at a
|
|
|
|
|
* default priority, #G_PRIORITY_DEFAULT.
|
|
|
|
|
*
|
2004-03-01 21:47:49 +01:00
|
|
|
* Note that on platforms where #GPid must be explicitely closed
|
|
|
|
|
* (see g_spawn_close_pid()) @pid must not be closed while the
|
|
|
|
|
* source is still active. Typically, you will want to call
|
|
|
|
|
* g_spawn_close_pid() in the callback function for the source.
|
|
|
|
|
*
|
2004-02-14 01:23:36 +01:00
|
|
|
* Return value: the id of event source.
|
|
|
|
|
*
|
|
|
|
|
* Since: 2.4
|
|
|
|
|
**/
|
|
|
|
|
guint
|
|
|
|
|
g_child_watch_add (GPid pid,
|
|
|
|
|
GChildWatchFunc function,
|
|
|
|
|
gpointer data)
|
|
|
|
|
{
|
|
|
|
|
return g_child_watch_add_full (G_PRIORITY_DEFAULT, pid, function, data, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
1998-12-02 15:55:27 +01:00
|
|
|
/* Idle functions */
|
|
|
|
|
|
|
|
|
|
static gboolean
|
2000-12-05 21:45:33 +01:00
|
|
|
g_idle_prepare (GSource *source,
|
|
|
|
|
gint *timeout)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-05-19 10:18:29 +02:00
|
|
|
*timeout = 0;
|
|
|
|
|
|
1998-12-02 15:55:27 +01:00
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
2000-12-05 21:45:33 +01:00
|
|
|
g_idle_check (GSource *source)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gboolean
|
2000-12-05 21:45:33 +01:00
|
|
|
g_idle_dispatch (GSource *source,
|
|
|
|
|
GSourceFunc callback,
|
|
|
|
|
gpointer user_data)
|
1998-12-02 15:55:27 +01:00
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
if (!callback)
|
|
|
|
|
{
|
|
|
|
|
g_warning ("Idle source dispatched without callback\n"
|
|
|
|
|
"You must call g_source_set_callback().");
|
|
|
|
|
return FALSE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return callback (user_data);
|
|
|
|
|
}
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_idle_source_new:
|
|
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Creates a new idle source.
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
|
|
|
|
* The source will not initially be associated with any #GMainContext
|
|
|
|
|
* and must be added to one with g_source_attach() before it will be
|
2003-08-07 20:19:23 +02:00
|
|
|
* executed. Note that the default priority for idle sources is
|
|
|
|
|
* %G_PRIORITY_DEFAULT_IDLE, as compared to other sources which
|
|
|
|
|
* have a default priority of %G_PRIORITY_DEFAULT.
|
2000-12-05 21:45:33 +01:00
|
|
|
*
|
2001-12-16 20:31:36 +01:00
|
|
|
* Return value: the newly-created idle source
|
2000-12-05 21:45:33 +01:00
|
|
|
**/
|
|
|
|
|
GSource *
|
|
|
|
|
g_idle_source_new (void)
|
|
|
|
|
{
|
2003-08-07 20:19:23 +02:00
|
|
|
GSource *source;
|
|
|
|
|
|
|
|
|
|
source = g_source_new (&g_idle_funcs, sizeof (GSource));
|
|
|
|
|
g_source_set_priority (source, G_PRIORITY_DEFAULT_IDLE);
|
|
|
|
|
|
|
|
|
|
return source;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_idle_add_full:
|
|
|
|
|
* @priority: the priority of the idle source. Typically this will be in the
|
|
|
|
|
* range btweeen #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
|
|
|
|
|
* @function: function to call
|
|
|
|
|
* @data: data to pass to @function
|
|
|
|
|
* @notify: function to call when the idle is removed, or %NULL
|
|
|
|
|
*
|
|
|
|
|
* Adds a function to be called whenever there are no higher priority
|
2001-12-16 20:31:36 +01:00
|
|
|
* events pending. If the function returns %FALSE it is automatically
|
2000-12-05 21:45:33 +01:00
|
|
|
* removed from the list of event sources and will not be called again.
|
|
|
|
|
*
|
|
|
|
|
* Return value: the id of the event source.
|
|
|
|
|
**/
|
1998-12-02 15:55:27 +01:00
|
|
|
guint
|
1999-01-17 05:49:43 +01:00
|
|
|
g_idle_add_full (gint priority,
|
1998-12-02 15:55:27 +01:00
|
|
|
GSourceFunc function,
|
|
|
|
|
gpointer data,
|
|
|
|
|
GDestroyNotify notify)
|
|
|
|
|
{
|
2000-12-05 21:45:33 +01:00
|
|
|
GSource *source;
|
2000-12-07 21:29:58 +01:00
|
|
|
guint id;
|
2000-12-05 21:45:33 +01:00
|
|
|
|
1999-01-17 05:49:43 +01:00
|
|
|
g_return_val_if_fail (function != NULL, 0);
|
1998-12-02 15:55:27 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
source = g_idle_source_new ();
|
|
|
|
|
|
2003-08-07 20:19:23 +02:00
|
|
|
if (priority != G_PRIORITY_DEFAULT_IDLE)
|
2000-12-05 21:45:33 +01:00
|
|
|
g_source_set_priority (source, priority);
|
|
|
|
|
|
|
|
|
|
g_source_set_callback (source, function, data, notify);
|
2000-12-07 21:29:58 +01:00
|
|
|
id = g_source_attach (source, NULL);
|
|
|
|
|
g_source_unref (source);
|
|
|
|
|
|
|
|
|
|
return id;
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
|
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_idle_add:
|
|
|
|
|
* @function: function to call
|
|
|
|
|
* @data: data to pass to @function.
|
|
|
|
|
*
|
|
|
|
|
* Adds a function to be called whenever there are no higher priority
|
|
|
|
|
* events pending to the default main loop. The function is given the
|
|
|
|
|
* default idle priority, #G_PRIORITY_DEFAULT_IDLE. If the function
|
2001-12-16 20:31:36 +01:00
|
|
|
* returns %FALSE it is automatically removed from the list of event
|
2000-12-05 21:45:33 +01:00
|
|
|
* sources and will not be called again.
|
|
|
|
|
*
|
|
|
|
|
* Return value: the id of the event source.
|
|
|
|
|
**/
|
1998-12-02 15:55:27 +01:00
|
|
|
guint
|
|
|
|
|
g_idle_add (GSourceFunc function,
|
|
|
|
|
gpointer data)
|
|
|
|
|
{
|
1998-12-19 23:21:39 +01:00
|
|
|
return g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, function, data, NULL);
|
1998-12-02 15:55:27 +01:00
|
|
|
}
|
1999-01-17 05:49:43 +01:00
|
|
|
|
2000-12-05 21:45:33 +01:00
|
|
|
/**
|
|
|
|
|
* g_idle_remove_by_data:
|
|
|
|
|
* @data: the data for the idle source's callback.
|
|
|
|
|
*
|
|
|
|
|
* Removes the idle function with the given data.
|
|
|
|
|
*
|
|
|
|
|
* Return value: %TRUE if an idle source was found and removed.
|
|
|
|
|
**/
|
1999-01-17 05:49:43 +01:00
|
|
|
gboolean
|
|
|
|
|
g_idle_remove_by_data (gpointer data)
|
|
|
|
|
{
|
2001-09-04 00:12:51 +02:00
|
|
|
return g_source_remove_by_funcs_user_data (&g_idle_funcs, data);
|
1999-01-17 05:49:43 +01:00
|
|
|
}
|
2000-12-05 21:45:33 +01:00
|
|
|
|
