void
_g_debug_init (void)
{
const gchar *val;
_g_debug_initialized = TRUE;
val = g_getenv ("G_DEBUG");
if (val != NULL)
{
const GDebugKey keys[] = {
{"fatal_warnings", G_DEBUG_FATAL_WARNINGS},
{"fatal_criticals", G_DEBUG_FATAL_CRITICALS}
};
_g_debug_flags = g_parse_debug_string (val, keys, G_N_ELEMENTS (keys));
}
if (_g_debug_flags & G_DEBUG_FATAL_WARNINGS)
{
GLogLevelFlags fatal_mask;
fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
g_log_set_always_fatal (fatal_mask);
}
if (_g_debug_flags & G_DEBUG_FATAL_CRITICALS)
{
GLogLevelFlags fatal_mask;
fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
fatal_mask |= G_LOG_LEVEL_CRITICAL;
g_log_set_always_fatal (fatal_mask);
}
}
/**
* gtk_gl_parse_args:
* @argc: (inout): the number of command line arguments.
* @argv: (array length=argc) (inout) (allow-none): the array of command line arguments.
*
* Parses command line arguments, and initializes global
* attributes of GtkGLExt.
*
* Any arguments used by GtkGLExt are removed from the array and
* @argc and @argv are updated accordingly.
*
* You shouldn't call this function explicitely if you are using
* gtk_gl_init(), or gtk_gl_init_check().
**/
static void
gtk_gl_parse_args (int *argc,
char ***argv)
{
const gchar *env_string;
if (gtk_gl_initialized)
return;
/*
* If window manager doesn't watch the WM_COLORMAP_WINDOWS property on
* the top-level window, we have to set OpenGL window's colormap to the
* top-level window, especially in color index mode (color index mode
* uses own private colormap).
*/
env_string = g_getenv ("GTK_GL_INSTALL_COLORMAP");
if (env_string != NULL)
{
_gtk_gl_widget_install_toplevel_cmap = (atoi (env_string) != 0);
env_string = NULL;
}
#ifdef G_ENABLE_DEBUG
env_string = g_getenv ("GTK_GL_DEBUG");
if (env_string != NULL)
{
gtk_gl_debug_flags = g_parse_debug_string (env_string,
gtk_gl_debug_keys,
gtk_gl_ndebug_keys);
env_string = NULL;
}
#endif /* G_ENABLE_DEBUG */
if (argc && argv)
{
gint i, j, k;
for (i = 1; i < *argc;)
{
if (strcmp ("--gtk-gl-install-colormap", (*argv)[i]) == 0)
{
_gtk_gl_widget_install_toplevel_cmap = TRUE;
(*argv)[i] = NULL;
}
#ifdef G_ENABLE_DEBUG
else if ((strcmp ("--gtk-gl-debug", (*argv)[i]) == 0) ||
(strncmp ("--gtk-gl-debug=", (*argv)[i], 15) == 0))
{
gchar *equal_pos = strchr ((*argv)[i], '=');
if (equal_pos != NULL)
{
gtk_gl_debug_flags |= g_parse_debug_string (equal_pos+1,
gtk_gl_debug_keys,
gtk_gl_ndebug_keys);
}
else if ((i + 1) < *argc && (*argv)[i + 1])
{
gtk_gl_debug_flags |= g_parse_debug_string ((*argv)[i+1],
gtk_gl_debug_keys,
gtk_gl_ndebug_keys);
(*argv)[i] = NULL;
i += 1;
}
(*argv)[i] = NULL;
}
else if ((strcmp ("--gtk-gl-no-debug", (*argv)[i]) == 0) ||
(strncmp ("--gtk-gl-no-debug=", (*argv)[i], 18) == 0))
{
gchar *equal_pos = strchr ((*argv)[i], '=');
if (equal_pos != NULL)
{
gtk_gl_debug_flags &= ~g_parse_debug_string (equal_pos+1,
gtk_gl_debug_keys,
gtk_gl_ndebug_keys);
}
else if ((i + 1) < *argc && (*argv)[i + 1])
{
gtk_gl_debug_flags &= ~g_parse_debug_string ((*argv)[i+1],
gtk_gl_debug_keys,
gtk_gl_ndebug_keys);
(*argv)[i] = NULL;
i += 1;
}
(*argv)[i] = NULL;
}
#endif /* G_ENABLE_DEBUG */
i += 1;
}
for (i = 1; i < *argc; i++)
{
for (k = i; k < *argc; k++)
if ((*argv)[k] != NULL)
break;
if (k > i)
{
k -= i;
for (j = i + k; j < *argc; j++)
(*argv)[j-k] = (*argv)[j];
*argc -= k;
}
}
}
/* Set the 'initialized' flag. */
gtk_gl_initialized = TRUE;
}
static gboolean
gegl_post_parse_hook (GOptionContext *context,
GOptionGroup *group,
gpointer data,
GError **error)
{
glong time;
if (config)
return TRUE;
g_assert (global_time == 0);
global_time = gegl_ticks ();
g_type_init ();
gegl_instrument ("gegl", "gegl_init", 0);
config = (void*)gegl_config ();
if (cmd_gegl_swap)
g_object_set (config, "swap", cmd_gegl_swap, NULL);
if (cmd_gegl_quality)
config->quality = atof (cmd_gegl_quality);
if (cmd_gegl_cache_size)
config->cache_size = atoi (cmd_gegl_cache_size)*1024*1024;
if (cmd_gegl_chunk_size)
config->chunk_size = atoi (cmd_gegl_chunk_size);
if (cmd_gegl_tile_size)
{
const gchar *str = cmd_gegl_tile_size;
config->tile_width = atoi(str);
str = strchr (str, 'x');
if (str)
config->tile_height = atoi(str+1);
}
if (cmd_gegl_threads)
config->threads = atoi (cmd_gegl_threads);
if (cmd_babl_tolerance)
g_object_set (config, "babl-tolerance", atof(cmd_babl_tolerance), NULL);
#ifdef GEGL_ENABLE_DEBUG
{
const char *env_string;
env_string = g_getenv ("GEGL_DEBUG");
if (env_string != NULL)
{
gegl_debug_flags =
g_parse_debug_string (env_string,
gegl_debug_keys,
G_N_ELEMENTS (gegl_debug_keys));
env_string = NULL;
}
}
#endif /* GEGL_ENABLE_DEBUG */
time = gegl_ticks ();
babl_init ();
gegl_instrument ("gegl_init", "babl_init", gegl_ticks () - time);
gegl_init_i18n ();
time = gegl_ticks ();
if (!module_db)
{
const gchar *gegl_path = g_getenv ("GEGL_PATH");
module_db = gegl_module_db_new (FALSE);
if (gegl_path)
{
gegl_module_db_load (module_db, gegl_path);
}
else
{
gchar *module_path;
#ifdef G_OS_WIN32
{
gchar *prefix;
prefix = g_win32_get_package_installation_directory_of_module ( hLibGeglModule );
module_path = g_build_filename (prefix, "lib", GEGL_LIBRARY, NULL);
g_free(prefix);
}
#else
module_path = g_build_filename (LIBDIR, GEGL_LIBRARY, NULL);
#endif
gegl_module_db_load (module_db, module_path);
g_free (module_path);
/* also load plug-ins from ~/.local/share/gegl-0.0/plugins */
module_path = g_build_filename (g_get_user_data_dir (),
GEGL_LIBRARY,
"plug-ins",
NULL);
if (g_mkdir_with_parents (module_path,
S_IRUSR | S_IWUSR | S_IXUSR) == 0)
{
gchar *makefile_path = g_build_filename (module_path,
"Makefile",
NULL);
if (! g_file_test (makefile_path, G_FILE_TEST_EXISTS))
g_file_set_contents (makefile_path, makefile (), -1, NULL);
g_free (makefile_path);
}
gegl_module_db_load (module_db, module_path);
g_free (module_path);
}
gegl_instrument ("gegl_init", "load modules", gegl_ticks () - time);
}
gegl_instrument ("gegl", "gegl_init", gegl_ticks () - global_time);
if (g_getenv ("GEGL_SWAP"))
g_object_set (config, "swap", g_getenv ("GEGL_SWAP"), NULL);
if (g_getenv ("GEGL_QUALITY"))
{
const gchar *quality = g_getenv ("GEGL_QUALITY");
if (g_str_equal (quality, "fast"))
g_object_set (config, "quality", 0.0, NULL);
if (g_str_equal (quality, "good"))
g_object_set (config, "quality", 0.5, NULL);
if (g_str_equal (quality, "best"))
g_object_set (config, "quality", 1.0, NULL);
}
swap_clean ();
return TRUE;
}
/**
* gdk_gl_parse_args:
* @argc: the number of command line arguments.
* @argv: the array of command line arguments.
*
* Parses command line arguments, and initializes global
* attributes of GdkGLExt.
*
* Any arguments used by GdkGLExt are removed from the array and
* @argc and @argv are updated accordingly.
*
* You shouldn't call this function explicitely if you are using
* gdk_gl_init(), or gdk_gl_init_check().
**/
static void
gdk_gl_parse_args (int *argc,
char ***argv)
{
const gchar *env_string;
if (gdk_gl_initialized)
return;
env_string = g_getenv ("GDK_GL_FORCE_INDIRECT");
if (env_string != NULL)
{
_gdk_gl_context_force_indirect = !!g_ascii_strtoll (env_string, NULL, 0);
env_string = NULL;
}
#ifdef G_ENABLE_DEBUG
env_string = g_getenv ("GDK_GL_DEBUG");
if (env_string != NULL)
{
gdk_gl_debug_flags = g_parse_debug_string (env_string,
gdk_gl_debug_keys,
gdk_gl_ndebug_keys);
env_string = NULL;
}
#endif /* G_ENABLE_DEBUG */
if (argc && argv)
{
gint i, j, k;
for (i = 1; i < *argc;)
{
if (strcmp ("--gdk-gl-force-indirect", (*argv)[i]) == 0)
{
_gdk_gl_context_force_indirect = TRUE;
(*argv)[i] = NULL;
}
#ifdef G_ENABLE_DEBUG
else if ((strcmp ("--gdk-gl-debug", (*argv)[i]) == 0) ||
(strncmp ("--gdk-gl-debug=", (*argv)[i], 15) == 0))
{
gchar *equal_pos = strchr ((*argv)[i], '=');
if (equal_pos != NULL)
{
gdk_gl_debug_flags |= g_parse_debug_string (equal_pos+1,
gdk_gl_debug_keys,
gdk_gl_ndebug_keys);
}
else if ((i + 1) < *argc && (*argv)[i + 1])
{
gdk_gl_debug_flags |= g_parse_debug_string ((*argv)[i+1],
gdk_gl_debug_keys,
gdk_gl_ndebug_keys);
(*argv)[i] = NULL;
i += 1;
}
(*argv)[i] = NULL;
}
else if ((strcmp ("--gdk-gl-no-debug", (*argv)[i]) == 0) ||
(strncmp ("--gdk-gl-no-debug=", (*argv)[i], 18) == 0))
{
gchar *equal_pos = strchr ((*argv)[i], '=');
if (equal_pos != NULL)
{
gdk_gl_debug_flags &= ~g_parse_debug_string (equal_pos+1,
gdk_gl_debug_keys,
gdk_gl_ndebug_keys);
}
else if ((i + 1) < *argc && (*argv)[i + 1])
{
gdk_gl_debug_flags &= ~g_parse_debug_string ((*argv)[i+1],
gdk_gl_debug_keys,
gdk_gl_ndebug_keys);
(*argv)[i] = NULL;
i += 1;
}
(*argv)[i] = NULL;
}
#endif /* G_ENABLE_DEBUG */
i += 1;
}
for (i = 1; i < *argc; i++)
{
for (k = i; k < *argc; k++)
if ((*argv)[k] != NULL)
break;
if (k > i)
{
k -= i;
for (j = i + k; j < *argc; j++)
(*argv)[j-k] = (*argv)[j];
*argc -= k;
}
}
}
/* Set the 'initialized' flag. */
gdk_gl_initialized = TRUE;
}
GObex *g_obex_new(GIOChannel *io, GObexTransportType transport_type,
gssize io_rx_mtu, gssize io_tx_mtu)
{
GObex *obex;
GIOCondition cond;
if (gobex_debug == 0) {
const char *env = g_getenv("GOBEX_DEBUG");
if (env) {
gobex_debug = g_parse_debug_string(env, keys, 7);
g_setenv("G_MESSAGES_DEBUG", "gobex", FALSE);
} else
gobex_debug = G_OBEX_DEBUG_NONE;
}
g_obex_debug(G_OBEX_DEBUG_COMMAND, "");
if (io == NULL)
return NULL;
if (io_rx_mtu >= 0 && io_rx_mtu < G_OBEX_MINIMUM_MTU)
return NULL;
if (io_tx_mtu >= 0 && io_tx_mtu < G_OBEX_MINIMUM_MTU)
return NULL;
obex = g_new0(GObex, 1);
obex->io = g_io_channel_ref(io);
obex->ref_count = 1;
obex->conn_id = CONNID_INVALID;
obex->rx_last_op = G_OBEX_OP_NONE;
obex->io_rx_mtu = io_rx_mtu;
obex->io_tx_mtu = io_tx_mtu;
if (io_rx_mtu > G_OBEX_MAXIMUM_MTU)
obex->rx_mtu = G_OBEX_MAXIMUM_MTU;
else if (io_rx_mtu < G_OBEX_MINIMUM_MTU)
obex->rx_mtu = G_OBEX_DEFAULT_MTU;
else
obex->rx_mtu = io_rx_mtu;
obex->tx_mtu = G_OBEX_MINIMUM_MTU;
obex->tx_queue = g_queue_new();
obex->rx_buf = g_malloc(obex->rx_mtu);
obex->tx_buf = g_malloc(obex->tx_mtu);
switch (transport_type) {
case G_OBEX_TRANSPORT_STREAM:
obex->read = read_stream;
obex->write = write_stream;
break;
case G_OBEX_TRANSPORT_PACKET:
obex->use_srm = TRUE;
obex->read = read_packet;
obex->write = write_packet;
break;
default:
g_obex_unref(obex);
return NULL;
}
g_io_channel_set_encoding(io, NULL, NULL);
g_io_channel_set_buffered(io, FALSE);
cond = G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL;
obex->io_source = g_io_add_watch(io, cond, incoming_data, obex);
return obex;
}
static gboolean
gegl_post_parse_hook (GOptionContext *context,
GOptionGroup *group,
gpointer data,
GError **error)
{
GeglConfig *config;
g_assert (global_time == 0);
global_time = gegl_ticks ();
if (g_getenv ("GEGL_DEBUG_TIME") != NULL)
gegl_instrument_enable ();
gegl_instrument ("gegl", "gegl_init", 0);
config = gegl_config ();
gegl_config_parse_env (config);
babl_init ();
#ifdef GEGL_ENABLE_DEBUG
{
const char *env_string;
env_string = g_getenv ("GEGL_DEBUG");
if (env_string != NULL)
{
gegl_debug_flags =
g_parse_debug_string (env_string,
gegl_debug_keys,
G_N_ELEMENTS (gegl_debug_keys));
env_string = NULL;
}
}
#endif /* GEGL_ENABLE_DEBUG */
if (cmd_gegl_swap)
g_object_set (config, "swap", cmd_gegl_swap, NULL);
if (cmd_gegl_quality)
config->quality = atof (cmd_gegl_quality);
if (cmd_gegl_cache_size)
config->tile_cache_size = atoll (cmd_gegl_cache_size)*1024*1024;
if (cmd_gegl_chunk_size)
config->chunk_size = atoi (cmd_gegl_chunk_size);
if (cmd_gegl_tile_size)
{
const gchar *str = cmd_gegl_tile_size;
config->tile_width = atoi(str);
str = strchr (str, 'x');
if (str)
config->tile_height = atoi(str+1);
}
if (cmd_gegl_threads)
{
_gegl_threads = atoi (cmd_gegl_threads);
if (_gegl_threads > GEGL_MAX_THREADS)
{
g_warning ("Tried to use %i threads, max is %i",
_gegl_threads, GEGL_MAX_THREADS);
_gegl_threads = GEGL_MAX_THREADS;
}
}
if (cmd_gegl_disable_opencl)
gegl_cl_hard_disable ();
gegl_init_swap_dir ();
GEGL_INSTRUMENT_START();
gegl_operation_gtype_init ();
if (!module_db)
{
GSList *paths = gegl_get_default_module_paths ();
module_db = gegl_module_db_new (FALSE);
g_slist_foreach(paths, (GFunc)load_module_path, module_db);
g_slist_free_full (paths, g_free);
}
GEGL_INSTRUMENT_END ("gegl_init", "load modules");
gegl_instrument ("gegl", "gegl_init", gegl_ticks () - global_time);
swap_clean ();
g_signal_connect (G_OBJECT (config),
"notify::use-opencl",
G_CALLBACK (gegl_config_use_opencl_notify),
NULL);
g_object_set (config, "use-opencl", config->use_opencl, NULL);
g_signal_connect (G_OBJECT (config),
"notify::application-license",
G_CALLBACK (gegl_config_application_license_notify),
NULL);
gegl_operations_set_licenses_from_string (config->application_license);
return TRUE;
}