clutter 2.0.0-x86-mingw32

data/vendor/local/include/cogl/cogl/cogl-display.h

@@ -0,0 +1,192 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2010 Intel Corporation.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *  Robert Bragg <robert@linux.intel.com>
+ *
+ */
+
+#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
+#error "Only <cogl/cogl.h> can be included directly."
+#endif
+
+#ifndef __COGL_DISPLAY_H__
+#define __COGL_DISPLAY_H__
+
+#include <cogl/cogl-renderer.h>
+#include <cogl/cogl-onscreen-template.h>
+
+COGL_BEGIN_DECLS
+
+#ifdef COGL_HAS_EGL_PLATFORM_GDL_SUPPORT
+#include <libgdl.h>
+#endif
+
+/**
+ * SECTION:cogl-display
+ * @short_description: Common aspects of a display pipeline
+ *
+ * The basic intention for this object is to let the application
+ * configure common display preferences before creating a context, and
+ * there are a few different aspects to this...
+ *
+ * Firstly there are options directly relating to the physical display
+ * pipeline that is currently being used including the digital to
+ * analogue conversion hardware and the screens the user sees.
+ *
+ * Another aspect is that display options may constrain or affect how
+ * onscreen framebuffers should later be configured. The original
+ * rationale for the display object in fact was to let us handle GLX
+ * and EGLs requirements that framebuffers must be "compatible" with
+ * the config associated with the current context meaning we have to
+ * force the user to describe how they would like to create their
+ * onscreen windows before we can choose a suitable fbconfig and
+ * create a GLContext.
+ */
+
+typedef struct _CoglDisplay	      CoglDisplay;
+
+#define COGL_DISPLAY(OBJECT) ((CoglDisplay *)OBJECT)
+
+/**
+ * cogl_display_new:
+ * @renderer: A #CoglRenderer
+ * @onscreen_template: A #CoglOnscreenTemplate
+ *
+ * Explicitly allocates a new #CoglDisplay object to encapsulate the
+ * common state of the display pipeline that applies to the whole
+ * application.
+ *
+ * <note>Many applications don't need to explicitly use
+ * cogl_display_new() and can just jump straight to cogl_context_new()
+ * and pass a %NULL display argument so Cogl will automatically
+ * connect and setup a renderer and display.</note>
+ *
+ * A @display can only be made for a specific choice of renderer which
+ * is why this takes the @renderer argument.
+ *
+ * A common use for explicitly allocating a display object is to
+ * define a template for allocating onscreen framebuffers which is
+ * what the @onscreen_template argument is for.
+ *
+ * When a display is first allocated via cogl_display_new() it is in a
+ * mutable configuration mode. It's designed this way so we can
+ * extend the apis available for configuring a display without
+ * requiring huge numbers of constructor arguments.
+ *
+ * When you have finished configuring a display object you can
+ * optionally call cogl_display_setup() to explicitly apply the
+ * configuration and check for errors. Alternaitvely you can pass the
+ * display to cogl_context_new() and Cogl will implicitly apply your
+ * configuration but if there are errors then the application will
+ * abort with a message. For simple applications with no fallback
+ * options then relying on the implicit setup can be fine.
+ *
+ * Return value: A newly allocated #CoglDisplay object in a mutable
+ *               configuration mode.
+ * Since: 1.10
+ * Stability: unstable
+ */
+CoglDisplay *
+cogl_display_new (CoglRenderer *renderer,
+                  CoglOnscreenTemplate *onscreen_template);
+
+/**
+ * cogl_display_get_renderer:
+ * @display: a #CoglDisplay
+ *
+ * Queries the #CoglRenderer associated with the given @display.
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+CoglRenderer *
+cogl_display_get_renderer (CoglDisplay *display);
+
+/**
+ * cogl_display_setup:
+ * @display: a #CoglDisplay
+ * @error: return location for a #CoglError
+ *
+ * Explicitly sets up the given @display object. Use of this api is
+ * optional since Cogl will internally setup the display if not done
+ * explicitly.
+ *
+ * When a display is first allocated via cogl_display_new() it is in a
+ * mutable configuration mode. This allows us to extend the apis
+ * available for configuring a display without requiring huge numbers
+ * of constructor arguments.
+ *
+ * Its possible to request a configuration that might not be
+ * supportable on the current system and so this api provides a means
+ * to apply the configuration explicitly but if it fails then an
+ * exception will be returned so you can handle the error gracefully
+ * and perhaps fall back to an alternative configuration.
+ *
+ * If you instead rely on Cogl implicitly calling cogl_display_setup()
+ * for you then if there is an error with the configuration you won't
+ * get an opportunity to handle that and the application may abort
+ * with a message.  For simple applications that don't have any
+ * fallback options this behaviour may be fine.
+ *
+ * Return value: Returns %TRUE if there was no error, else it returns
+ *               %FALSE and returns an exception via @error.
+ * Since: 1.10
+ * Stability: unstable
+ */
+CoglBool
+cogl_display_setup (CoglDisplay *display,
+                    CoglError **error);
+
+#ifdef COGL_HAS_EGL_PLATFORM_GDL_SUPPORT
+/**
+ * cogl_gdl_display_set_plane:
+ * @display: a #CoglDisplay
+ * @plane: the GDL plane id
+ *
+ * Request that Cogl output to a specific GDL overlay @plane.
+ *
+ * Since: 1.10
+ * Stability: unstable
+ */
+void
+cogl_gdl_display_set_plane (CoglDisplay *display,
+                            gdl_plane_id_t plane);
+#endif
+
+/**
+ * cogl_is_display:
+ * @object: A #CoglObject pointer
+ *
+ * Gets whether the given object references a #CoglDisplay.
+ *
+ * Return value: %TRUE if the object references a #CoglDisplay
+ *   and %FALSE otherwise.
+ * Since: 1.10
+ * Stability: unstable
+ */
+CoglBool
+cogl_is_display (void *object);
+
+COGL_END_DECLS
+
+#endif /* __COGL_DISPLAY_H__ */
+

data/vendor/local/include/cogl/cogl/cogl-enum-types.h

@@ -0,0 +1,100 @@
+
+/* Generated data (by glib-mkenums) */
+
+#ifndef __COGL_ENUM_TYPES_H__
+#define __COGL_ENUM_TYPES_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+/* enumerations from "./cogl-bitmap.h" */
+GType cogl_bitmap_error_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_BITMAP_ERROR (cogl_bitmap_error_get_type())
+
+/* enumerations from "./cogl-material-compat.h" */
+GType cogl_material_filter_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_MATERIAL_FILTER (cogl_material_filter_get_type())
+
+GType cogl_material_wrap_mode_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_MATERIAL_WRAP_MODE (cogl_material_wrap_mode_get_type())
+
+GType cogl_material_alpha_func_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_MATERIAL_ALPHA_FUNC (cogl_material_alpha_func_get_type())
+
+GType cogl_material_layer_type_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_MATERIAL_LAYER_TYPE (cogl_material_layer_type_get_type())
+
+/* enumerations from "./cogl-path.h" */
+GType cogl_path_fill_rule_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_PATH_FILL_RULE (cogl_path_fill_rule_get_type())
+
+/* enumerations from "./cogl-shader.h" */
+GType cogl_shader_type_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_SHADER_TYPE (cogl_shader_type_get_type())
+
+/* enumerations from "./cogl-texture.h" */
+GType cogl_texture_error_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_TEXTURE_ERROR (cogl_texture_error_get_type())
+
+GType cogl_texture_type_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_TEXTURE_TYPE (cogl_texture_type_get_type())
+
+/* enumerations from "./cogl-types.h" */
+GType cogl_pixel_format_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_PIXEL_FORMAT (cogl_pixel_format_get_type())
+
+GType cogl_feature_flags_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_FEATURE_FLAGS (cogl_feature_flags_get_type())
+
+GType cogl_buffer_target_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_BUFFER_TARGET (cogl_buffer_target_get_type())
+
+GType cogl_texture_flags_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_TEXTURE_FLAGS (cogl_texture_flags_get_type())
+
+GType cogl_fog_mode_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_FOG_MODE (cogl_fog_mode_get_type())
+
+GType cogl_blend_string_error_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_BLEND_STRING_ERROR (cogl_blend_string_error_get_type())
+
+GType cogl_system_error_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_SYSTEM_ERROR (cogl_system_error_get_type())
+
+GType cogl_attribute_type_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_ATTRIBUTE_TYPE (cogl_attribute_type_get_type())
+
+GType cogl_indices_type_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_INDICES_TYPE (cogl_indices_type_get_type())
+
+GType cogl_vertices_mode_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_VERTICES_MODE (cogl_vertices_mode_get_type())
+
+GType cogl_depth_test_function_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_DEPTH_TEST_FUNCTION (cogl_depth_test_function_get_type())
+
+GType cogl_renderer_error_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_RENDERER_ERROR (cogl_renderer_error_get_type())
+
+GType cogl_winsys_feature_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_WINSYS_FEATURE (cogl_winsys_feature_get_type())
+
+GType cogl_color_mask_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_COLOR_MASK (cogl_color_mask_get_type())
+
+GType cogl_winding_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_WINDING (cogl_winding_get_type())
+
+GType cogl_buffer_bit_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_BUFFER_BIT (cogl_buffer_bit_get_type())
+
+GType cogl_read_pixels_flags_get_type (void) G_GNUC_CONST;
+#define COGL_TYPE_READ_PIXELS_FLAGS (cogl_read_pixels_flags_get_type())
+
+G_END_DECLS
+
+#endif /* __COGL_ENUM_TYPES_H__ */
+
+/* Generated data ends here */
+

data/vendor/local/include/cogl/cogl/cogl-error.h

@@ -0,0 +1,176 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2012 Intel Corporation.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
+#error "Only <cogl/cogl.h> can be included directly."
+#endif
+
+#ifndef __COGL_ERROR_H__
+#define __COGL_ERROR_H__
+
+#include "cogl-types.h"
+
+/**
+ * SECTION:cogl-error
+ * @short_description: A way for Cogl to throw exceptions
+ *
+ * As a general rule Cogl shields non-recoverable errors from
+ * developers, such as most heap allocation failures (unless for
+ * exceptionally large resources which we might reasonably expect to
+ * fail) and this reduces the burden on developers.
+ *
+ * There are some Cogl apis though that can fail for exceptional
+ * reasons that can also potentially be recovered from at runtime
+ * and for these apis we use a standard convention for reporting
+ * runtime recoverable errors.
+ *
+ * As an example if we look at the cogl_context_new() api which
+ * takes an error argument:
+ * |[
+ *   CoglContext *
+ *   cogl_context_new (CoglDisplay *display, CoglError **error);
+ * ]|
+ *
+ * A caller interested in catching any runtime error when creating a
+ * new #CoglContext would pass the address of a #CoglError pointer
+ * that has first been initialized to %NULL as follows:
+ *
+ * |[
+ *   CoglError *error = NULL;
+ *   CoglContext *context;
+ *
+ *   context = cogl_context_new (NULL, &error);
+ * ]|
+ *
+ * The return status should usually be enough to determine if there
+ * was an error set (in this example we can check if context == %NULL)
+ * but if it's not possible to tell from the function's return status
+ * you can instead look directly at the error pointer which you
+ * initialized to %NULL. In this example we now check the error,
+ * report any error to the user, free the error and then simply
+ * abort without attempting to recover.
+ *
+ * |[
+ *   if (context == NULL)
+ *     {
+ *       fprintf (stderr, "Failed to create a Cogl context: %s\n",
+ *                error->message);
+ *       cogl_error_free (error);
+ *       abort ();
+ *     }
+ * ]|
+ *
+ * All Cogl APIs that accept an error argument can also be passed a
+ * %NULL pointer. In this case if an exceptional error condition is hit
+ * then Cogl will simply log the error message and abort the
+ * application. This can be compared to language execeptions where the
+ * developer has not attempted to catch the exception. This means the
+ * above example is essentially redundant because it's what Cogl would
+ * have done automatically and so, similarly, if your application has
+ * no way to recover from a particular error you might just as well
+ * pass a %NULL #CoglError pointer to save a bit of typing.
+ *
+ * <note>If you are used to using the GLib API you will probably
+ * recognize that #CoglError is just like a #GError. In fact if Cogl
+ * has been built with --enable-glib then it is safe to cast a
+ * #CoglError to a #GError.</note>
+ *
+ * <note>An important detail to be aware of if you are used to using
+ * GLib's GError API is that Cogl deviates from the GLib GError
+ * conventions in one noteable way which is that a %NULL error pointer
+ * does not mean you want to ignore the details of an error, it means
+ * you are not trying to catch any exceptional errors the function might
+ * throw which will result in the program aborting with a log message
+ * if an error is thrown.</note>
+ */
+
+#ifdef COGL_HAS_GLIB_SUPPORT
+#define CoglError GError
+#else
+/**
+ * CoglError:
+ * @domain: A high-level domain identifier for the error
+ * @code: A specific error code within a specified domain
+ * @message: A human readable error message
+ */
+typedef struct _CoglError {
+  uint32_t domain;
+  int code;
+  char *message;
+} CoglError;
+#endif /* COGL_HAS_GLIB_SUPPORT */
+
+/**
+ * cogl_error_free:
+ * @error: A #CoglError thrown by the Cogl api
+ *
+ * Frees a #CoglError and associated resources.
+ */
+void
+cogl_error_free (CoglError *error);
+
+/**
+ * cogl_error_copy:
+ * @error: A #CoglError thrown by the Cogl api
+ *
+ * Makes a copy of @error which can later be freed using
+ * cogl_error_free().
+ *
+ * Return value: A newly allocated #CoglError initialized to match the
+ *               contents of @error.
+ */
+CoglError *
+cogl_error_copy (CoglError *error);
+
+/**
+ * cogl_error_matches:
+ * @error: A #CoglError thrown by the Cogl api or %NULL
+ * @domain: The error domain
+ * @code: The error code
+ *
+ * Returns %TRUE if error matches @domain and @code, %FALSE otherwise.
+ * In particular, when error is %NULL, FALSE will be returned.
+ *
+ * Return value: whether the @error corresponds to the given @domain
+ *               and @code.
+ */
+CoglBool
+cogl_error_matches (CoglError *error,
+                    uint32_t domain,
+                    int code);
+
+/**
+ * COGL_GLIB_ERROR:
+ * @COGL_ERROR: A #CoglError thrown by the Cogl api or %NULL
+ *
+ * Simply casts a #CoglError to a #CoglError
+ *
+ * If Cogl is built with GLib support then it can safely be assumed
+ * that a CoglError is a GError and can be used directly with the
+ * GError api.
+ */
+#ifdef COGL_HAS_GLIB_SUPPORT
+#define COGL_GLIB_ERROR(COGL_ERROR) ((CoglError *)COGL_ERROR)
+#endif
+
+#endif /* __COGL_ERROR_H__ */