cogl: Add const to some pointer arguments

Some of the arguments to the material and path functions were taking a
pointer to a CoglColor or an array of floats that was not intended to
be written to but were not marked with const.

text: Use the ::settings-changed signal

Instead of the ::font-changed one.

x11: Add XSETTINGS watcher

If we want to be able to get live notification of system settings
changes, we need watch the window that the XSETTINGS client conjures
up for us.

text: Document and annotate :font-name for NULL values

Update the documentation of :font-name, to make it clear that by setting
it to NULL the Text actor will use the default font.

Also, set the annotation for the @font_name argument of the setter to be
allow-none, and allow passing NULL through bindings.

text: Update actors using the default font

If a ClutterText actor is using the default font from the backend then
we should track font name changes and update it accordingly. This only
applies to ClutterText actors with the :font-name property unset or
explicitly set to NULL.

clutter.modules: Update with the gdk-pixbuf split

Gdk-Pixbuf has been split back into its own module once again. This
means that Clutter doesn't have a build requirement on gtk+ any more.

settings: Emit Backend::font-changed

When the :font-name property changes, to maintain the invariant.

test-text-field: Use the system font instead of using Sans

Detail the font-name value in the font settings debug note

clutter-event-win32: Emit multiple events for WM_MOUSEWHEEL Messages

It's possible that a single WM_MOUSEWHEEL event can arrive with a
scroll amount greater than WHEEL_DELTA. Previously it would accumulate
these amounts but it would still only emit a single event per
message. For example, if a message arrived that is worth two
WHEEL_DELTAs then it would emit one event and leave scroll_pos as
+WHEEL_DELTA. If the wheel is then scrolled in the opposite direction
then wheel delta would end up as zero and the scroll event would get
lost.

This patch fixes it so that it always emits enough events to put
scroll_pos back to less than WHEEL_DELTA.

http://bugzilla.clutter-project.org/show_bug.cgi?id=2135

clutter-event-win32: Directly enqueue events in message_translate

Previously the window procedure for the stage window would always
create a ClutterEvent struct for every message and then pass that on
to message_translate to fill in the details. message_translate could
return FALSE to abandon the event. Instead of this, message_translate
now creates and queues the event itself whenever it sees a message
that could translate to an event. The function now returns void. This
has a number of advantages:

* It saves redundantly allocating events for messages that Clutter
  doesn't care about.

* A single message can now easily be translated into multiple events.

* There were some messages that were handled and did not fill in the
  event struct but did not cause the function to return FALSE. I think
  this would end up with a CLUTTER_NOTHING event being emitted.

http://bugzilla.clutter-project.org/show_bug.cgi?id=2135

state: avoid g_str_equal if a string might be NULL

test-conformance: Use -export-dynamic instead of -rdynamic

The -rdynamic linker option is specific to ELF so it was breaking
builds on systems with other object formats such as Windows and
Solaris. This patch replaces that option with -export-dynamic which is
a portable libtool option which should do the right thing on each
platform.

http://bugzilla.clutter-project.org/show_bug.cgi?id=1930

actor: Top-levels should always report a 255 opacity

The paint opacity should always assume a fully opaque top-level at the
end, otherwise the scene would be rendered fully transparent.

http://bugzilla.clutter-project.org/show_bug.cgi?id=2050

actor: Ignore the NOP paint at 0 opacity for top-levels

A top-level actor could still have 0 opacity (e.g. a Stage with the
:use-alpha property set to TRUE), but we want its children to still
be painted.

http://bugzilla.clutter-project.org/show_bug.cgi?id=2050

material: Avoid possibly reading invalid memory

in _cogl_material_prune_empty_layer_difference we sometimes unref the
given layer before dereferencing it to get a pointer to its parent. This
defers the unref until after we have fetched the parent pointer.

state: added more documentation

state: removed special handling of state named "default"

The "default" state used for unspecified source transitions is NULL.
Small update and some other fixes to documentation.

Improve clutter_text_get_chars doc

Explicitly explain that end_pos is not included with the resulting
string

http://bugzilla.clutter-project.org/show_bug.cgi?id=2081

docs: Fix example code in BindingPool

The code sample in the gtk-doc annotations for ClutterBindingPool shows
the arguments in the wrong order.

http://bugzilla.clutter-project.org/show_bug.cgi?id=2133

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

doap: Update after the infrastructure changes

Change the Bugzilla link in the configure script

docs: Change the mailing list link

cogl: Remove cogl-defines.h.in from the driver make files

Commit 7fae8ac051292 changed cogl-defines.h.in so there is only a
single copy in clutter/cogl/ instead of one for each driver. However
the old files were still mentioned in the EXTRA_DIST of the
Makefile.am so make distcheck was failing.

cogl-path: Disable texture coord arrays before drawing

It was possible that the texture co-ord arrays were left enabled during
stroking, which could possibly cause a crash.

clutter-animation: Fix for using fixed:: from clutter_actor_animatev

When using clutter_actor_animatev it would set a boolean whenever a
property begins with "fixed::". However it would never clear the
variable so it would end up marking all subsequent properties as
fixed.

http://bugzilla.openedhand.com/show_bug.cgi?id=2180

http://bugzilla.clutter-project.org/show_bug.cgi?id=2149

Revert 7e6b60270d1951f0789868740b8df6acfe677d57

You should not commit patches based on the bugzilla description alone.
You should not commit patches based on the bugzilla description alone.
You should not commit patches based on the bugzilla description alone.
...

Fix the libdir in the pkg-config file

texture-pixmap-x11: don't assume anything about the GLXFBConfig type

A pedantic change to get_fbconfig_for_depth() so that we don't need to
make any assumptions about the GLXFBConfig typedef or what values
we can overload to indicate an invalid config.

get_fbconfig_for_depth() now simply returns FALSE if it fails to find a
config.

drag-action: Disable picking during drag

While dragging we don't need to perform picking to determine the actor
underneath the pointer, for two reasons:

  • we use a capture on the stage to determine the motion delta.
  • we know the actor underneath the pointer because that's the
    actor we are dragging around.

This change should make dragging actors in complex scenes a bit faster.

Silence another compiler warning

cogl-texture-pixmap-x11: Use NULL instead of None for invalid GLXFBConfig

GLXFBConfigs are opaque pointers not XIDs so it doesn't make sense to
return None from get_fbconfig_for_depth. Instead it now returns NULL.

Add test-cogl-texture-pixmap-x11 to the ignore file

Silence some compiler warnings

docs: Fix release notes wording

docs: Fix links in the README

docs: Remove the 'copyright-waiver' section

There is no need to toggle the copyright-waiver flag on Bugzilla
any more.

Use -Bsymbolic-functions

The -Bsymbolic-functions linker flag allows to avoid intra-library
PLT jumps on ELF platforms. It is similar to the aliasing hack in
GLib and GTK+, but definitely less messy.

The configure script should look for the flags, in order to support
platforms/linkers that do not have it.

conform: Do not use deprecated API in test-clutter-units

Setting the DPI is done through the ClutterSettings:font-dpi property.

Do not hardcode paths in pkgconfig file

The pkgconfig file correctly sets $prefix to @prefix@, but the other
paths should be relative to $prefix.

Add a test case for CoglTexturePixmapX11

clutter-{glx,x11}-texture-pixmap: Use CoglTexturePixmapX11

The pixmap handling of both of the texture pixmap actors in Clutter is
now removed and instead it just creates a CoglTexturePixmapX11. Both
actors are now equivalent so there is no need to choose between the
two.

Add a CoglTexturePixmapX11 texture backend

This is a publicly exposed texture backend to create a texture which
contains the contents of an X11 pixmap. The API is currently marked as
experimental.

The backend internally holds a handle to another texture. All of the
backend virtuals simply redirect to the internal texture.

The texture can optionally be automatically updated if the
automatic_updates parameter is TRUE. If set then Cogl will listen for
damage events on the pixmap and update the texture accordingly.
Alternatively a damage object can be created externally and passed
down to Cogl.

The updates can be performed with XGetImage, XShmGetImage or the
GLX_EXT_texture_pixmap extension. If the TFP extension is used it will
optionally try to create a rectangle texture if the driver does not
support NPOTs or it is forced through the
COGL_PIXMAP_TEXTURE_RECTANGLE or CLUTTER_PIXMAP_TEXTURE_RECTANGLE
environment variables.

If the GLXFBConfig does not support mipmapping then it will fallback
to using X{Shm,}GetImage. It keeps a separate texture around for this
so that it can later start using the TFP texture again if the texture
is later drawn with mipmaps disabled.

test-pixmap: Use the 'm' key to toggle texture quality

When the 'm' key is pressed it will now recursively look for all
ClutterTexture subclasses on the stage and toggle the texture quality
between high and low. This is useful to test the mipmap fallback.

test-pixmap: Draw something more interesting when the mouse is clicked

When the mouse button is pressed it would previously draw a small
1-pixel wide fully transparent line to the pixmap. This is a useful
feature to help test the automatic updates but the line is quite hard
to see so it's to easy miss. This patch changes it to draw a thick
black circle. The circle is drawn at a different position every time
the button is clicked.

test-pixmap: Add a --disable-animation option

Sometimes the animation makes debugging awkward so this patch adds a
--disable-animation option to simplify the test.

test-pixmap: Enable automatic updates for the hand

The hand actor has a feature that if you click on the stage it will
draw a line to the actor. However it's not possible to see the results
of this because automatic updates were disabled so the texture would
never be updated.

test-pixmap: Implement the --disable-x11 option

test-pixmap has long had a --disable-x11 option that didn't do
anything. This patch adds the neccessary if (disable_x11) to disable
adding the ClutterX11TexturePixmap actor when the option is given.

Add -DCOGL_ENABLE_EXPERIMENTAL_API to Makefiles for Cogl and x11/glx

Cogl and Clutter should be able to use the experimental API so this
adds the required define to the CPPFLAGS in the Makefiles.

cogl-defines.h: Add a COGL_HAS_X11 define

This will be defined in cogl-defines.h whenever Cogl is built using a
winsys that supports X11. This implies CoglTexturePixmapX11 will be
available.

To make this work the two separate cogl-defines.h.in files have been
merged into one. The configure script now makes a @COGL_DEFINES@
substitution variable which contains the #define lines to put in
rather than directly having them in the seperate files.

cogl: Add _cogl_xlib_{,un}trap_errors

This is similar to clutter_x11_{,un}trap_errors except that it stores
the previous trap state in a caller-allocated struct so that it can be
re-entrant.

Make _cogl_xlib_trap_errors re-entrant

(this will be squashed into an earlier commit)

cogl-texture: Avoid premult conversion if the dst format has no alpha

The _cogl_texture_needs_premult_conversion function was already
checking whether the source format had an alpha channel before
returning TRUE, but it also doesn't make sense to do the premult
conversion if the destination format has no alpha. This patch adds
that check in too.

cogl: Add the infrastructure for checking for winsys extensions

This adds the framework needed to check for winsys specific extensions
(such as GLX extensions) using a similar mechanism to the
cogl-feature-functions header. There is a separate
cogl-winsys-feature-functions header which will contain macros to list
the extensions and functions. cogl_create_context_winsys now calls
_cogl_feature_check for each of these functions. _cogl_feature_check
has had to be changed to accept the driver prefix as the first
parameter so that it can prepend "GLX" rather than "GL" in this case.

Pass all Xlib events through Cogl

The Clutter X11 backend now passes all events through
_cogl_xlib_handle_event. This function can now internally be hooked
with _cogl_xlib_add_filter. These are added to a list of callbacks
which are all called in turn by _cogl_xlib_handle_event. This is
intended to be used internally in Cogl by any parts that need to see
Xlib events.

Cogl now also has an internally exposed function to set a pointer to
the Xlib display. This is stored in a global variable. The Clutter X11
backend sets this.

_cogl_xlib_handle_event and _cogl_xlib_set_display can be removed once
Cogl gains a proper window system abstraction.

cogl: Add a struct for winsys-specific data to CoglContext

This creates a separate struct to store the fields of the context that
are specific to the winsys. This is all stored in one file but ideally
this could work more like the CoglContextDriver struct and have a
different header for each winsys.

cogl: Add an internal CoglTextureRectangle backend

This adds an internal rectangle texture backend which is mostly based
on the CoglTexture2D backend. It will throw assert failures if any
operations are attempted that rectangle textures don't support, such
as mipmapping or hardware repeating.

cogl-texture: Replace the ensure_mipmaps virtual with pre_paint

Instead of the ensure_mipmaps virtual that is only called whenever the
texture is about to be rendered with a min filter that needs the
mipmap, there is now a pre_paint virtual that is always called when
the texture is about to be painted in any way. It has a flags
parameter which is used to specify whether the mipmap will be needed.

This is useful for CoglTexturePixmapX11 because it needs to do stuff
before painting that is unrelated to mipmapping.

cogl-texture: List texture subclass types rather than hardcoding them

Instead of having a hardcoded series of if-statements in
cogl_is_texture to determine which types should appear as texture
subclasses, they are now stored in a GSList attached to the Cogl
context. The list is amended to using a new cogl_texture_register_type
function. There is a convenience macro called COGL_TEXTURE_DEFINE
which uses COGL_HANDLE_DEFINE_WITH_CODE to register the texture type
when the _get_type() function is first called.

Add COGL_{OBJECT,HANDLE}_DEFINE_WITH_CODE

This macro is similar to COGL_HANDLE_DEFINE_WITH_CODE except that it
allows a snippet of code to be inserted into the _get_type()
function. This is similar to how G_DEFINE_TYPE_WITH_CODE
works. COGL_HANDLE_DEFINE is now just a wrapper around
COGL_HANDLE_DEFINE_WITH_CODE.

Add _cogl_texture_2d_externally_modified

_cogl_texture_2d_externally_modified is a function specific to the
CoglTexture2D texture backend that should be called whenever the
contents of the texture are modified without the backend knowing about
it. It simply marks the mipmap tree as invalid.

cogl: Fix the include path in driver/*/Makefile.am

The include path for the winsys and driver folder was given relative
to $(srcdir) so it would end up relative to the driver folder which is
wrong. It is now specified as $(srcdir)/../../winsys to get the right
location. The driver folder is removed because it is actually just
$(srcdir) and that is already included.

test-shader: guard GLES2 specific changes with COGL_HAS_GLES2

Previously we were using an internal only HAVE_COGL_GLES2 define to
guard GLES 2 specific changes so for instance the precision modifiers
weren't being emitted in the shader source.

http://bugzilla.o-hand.com/show_bug.cgi?id=2178

gles2: don't disable clip planes for GLES2

GLES2 doesn't provide user clip planes (you would have to use a vertex +
fragment shader to achieve the same kind of result) so we make sure not
to call glEnable/Disable with any of the GL_CLIP_PLANE0..3 defines.

http://bugzilla.o-hand.com/show_bug.cgi?id=2177

material: fix a typo in _cogl_material_journal_unref

The function had a line like:

CoglMaterial *material =
    material = _cogl_material_pointer_from_handle (material_handle);

where the duplicate "material =" wasn't intended, so this patch removes
it.

json: Bump up the requirement of json-glib

We're actually using a symbol (the JSON_NODE_HOLDS macro) that was
defined in json-glib 0.10, so we need to bump up the dependency.

json: Backport JSON_NODE_HOLDS macros

Unbreak the compilation with the internal copy of json-glib.

x11: Use the _clutter symbols for xsettings_* API

Instead of using the bare xsettings_* API; this maintains consistency.

backend: Undeprecated clutter_backend_get_resolution()

Since the Settings:font-dpi property is exposed as 1024 * real_dpi in
order to make the setting as neutral as possible (and allow XSETTINGS
to use it natively) we need a simple API returning the DPI using a
floating point value.

Deprecate the Backend settings

The Settings instance is the preferred way of accessing the settings.

Remove default settings from backends

The defaults are set in the Settings instance.

docs: Add Settings to the API reference

And document properties.

settings: freeze notification on XSETTINGS notify

x11: Add the XSETTINGS machinery

Use the XSETTINGS machinery to get notification from foreign
environments about settings that might interest Clutter itself - namely:
the default font name, the font DPI, and the Xft font options that can
be mapped on cairo_font_options_t.

settings: Migrate Backend settings to a new object

Instead of storing settings inside the Backend instance we should use a
separate public object.

configure.ac only explicitly add -lGL if no pkgconfig file

When configuring the glx flavour we were always explicitly adding -lGL
to the linker flags even when a pkg-config file was found which should
take care of that option for us.

configure.ac: Use pkg-config for gles1/2 if available

When building for gles1/2 we now always try and look for a libglesv1_cm
or libglesv2 .pc file with details about where to find the library and
headers.

egl: Consolidates eglx and eglnative into one "egl" winsys

This remove quite a lot of redundant code by consolidating the eglx and
eglnative window system backends.

tslib: Add USE_TSLIB conditional for clutter-event-tslib.c

This adds an automake USE_TSLIB condition to decide when we should
compile clutter-event-tslib.c. This is in preparation for consolidating
the eglx and eglnative backends.

egl: rename clutter-event-egl.c -> clutter-event-tslib.c

clutter-event-egl had nothing to do with EGL, it's code for opening
tslib devices and creating a GSource for touch screen events. It just
happens that this only ever gets used with the eglnative backend.

clutter event egl: fixes lots of compiler warnings

The way the #ifdef HAVE_TSLIB guards were spread around it meant there
were lots of warnings about unused variables when building without
tslib.

egl: support creating OpenGL contexts

Right before we create the EGL context, we check if we were built with
OpenGL or OpenGLES support and it was OpenGL then we call eglBindAPI
(EGL_OPENGL_API); This also explicitly requests a EGL_RENDERABLE_TYPE
supporting the EGL_OPENGL_BIT.

This will let us add a new ./configure flavour that combines OpenGL and
EGL instead of OpenGL and GLX.

egl: Unify the eglx and eglnative backends

Without actually consolidating the two backends this patch brings their
code within a cats whisker of each other in preparation for
consolidation.

build: Adds a new opengl-egl-xlib build flavour

With this patch if you ./configure clutter using
--with-flavour=opengl-egl-xlib then it will use EGL + OpenGL instead of
the default GLX and OpenGL.

These days upstream driver work is more focused on improving EGL than it
is GLX so likewise we want to make sure Clutter has good support for
EGL.

build: distinguish CLUTTER_WINSYS and CLUTTER_SONAME_INFIX

This adds a separate variable name "CLUTTER_SONAME_INFIX" to define the
infix for the clutter library that gets linked. Currently the WINSYS
corresponds to the directory we enter when building to compile the
window system and input support, but it is desirable to be able to
define multiple flavours that use the same WINSYS but should result in
different library names.

For example we are planning to combine the eglx and eglnative window
systems into one "egl" winsys but we will need to preserve the current
library names for the eglx and eglnative flavours.

configure.ac: avoid some duplication

When we check the flavour we now just set boolean variables for the
following things:

SUPPORT_X11=1
SUPPORT_XLIB=1
SUPPORT_GLX=1
SUPPORT_EGL=1
SUPPORT_EGL_POWERVR_X11=1
SUPPORT_EGL_POWERVR_NULL=1

This lets us avoid some duplication and also some error prone tests for
lists of flavours used, for example, to determine when we need to check
for x libraries.

configure.ac: distinguish CLUTTER_FLAVOUR and CLUTTER_WINSYS

It's desirable to have a separation between the "flavour" and the
"winsys". The flavour is a concept internal to the configure script and
is a convenient name to represent the users choice of window system,
opengl driver and input backend. The CLUTTER_WINSYS currently defines
the subdirectory under clutter/ that should be compiled to handle the
window system and input.

With a separation we could add a flavour with no correspondence to which
clutter/subdirectory needs to be built.

configure.ac: move the special handling of the fruity flavour

After checking the flavour option the user gives we were checking for
the fruity flavour to override the glesversion. Now that the glsl
checking has been moved this can instead just wait until the AS_CASE
that handles all the flavour configuration.

configure.ac: move gles checks after the flavour checks

The flavour AS_CASE should define whether a flavour uses the gl or gles
COGL_DRIVER and so we shouldn't need to have an expanding list of
tests to gate when we check for a gles driver because if we move the
checks for gles after the flavour checks we can just look at
$COGL_DRIVER.

configure.ac: don't have so many XYX_{LIBS,CFLAGS} vars

This removes EGL_{LIBS,CFLAGS}, GLX_{LIBS,CFLAGS}, OSX_{LIBS,CFLAGS},
WIN32_{LIBS,CFLAGS}, and GLES_{LIBS,CFLAGS} and instead we just append
to FLAVOUR_{LIBS,CFLAGS}.

This makes more of the file relocatable because there were previously
dependencies on the order that some variables were setup in.

clutter-stage: Use g_array_free instead of g_array_unref

g_array_unref was only added in GLib 2.22 so we should really update
the requirements in the configure script if we want to use that
function. However the array doesn't appear to have any extra reference
taken on it anywhere so it should be safe to use g_array_free instead.

cogl-context: Use the function pointer for glActiveUnit

Under WGL, any functions that were defined after GL 1.1 are not
directly exported in the DLL so we need to reference them via the
function pointers. A new call to glActiveUnit was missed in
cogl-context.c

cogl-material: Don't use the symbol 'near'

The window headers contain the line

 #define near

so it's not possible to use the symbol 'near' in code that's portable
to Windows. This replaces it with 'near_val'.

I think the define is meant to improve compatibility with code written
for Windows 3.1 where near would be a keyword to make it a smaller
pointer size.

actor: Parse actions, constraints and effects members

ClutterActor should allow attaching actions, constraints and effects
just like it allows behaviours, e.g.:

  {
    ...
    "constraints" : [
      {
        "type" : "ClutterAlignConstraint",
        "source" : "stage",
        "align-axis" : "x-axis",
        "factor" : 0.5
      },
      {
        "type" : "ClutterAlignConstraint",
        "source" : "stage",
        "align-axis" : "y-axis",
        "factor" : 0.5
      }
    ],
    ...
  }

or:

  {
    ...
    "actions" : [
      {
        "type" : "ClutterDragAction",
        "signals" : [
          { "name" : "drag-end", "handler" : "on_drag_end" }
        ]
      }
    ],
    ...
  }

In order to do so, we use the Scriptable interface implementation and
add three new custom properties accepting an array; then we parse each
member of the array as a new object.

constraints: Allow Align and Bind sources to be NULL

Since constructing AlignConstraint and BindConstraint instances could be
deferred (think ClutterScript) we need to make their :source properties
setters accept NULL. This does not break the constraints because they
need to handle that condition in case they actor to which they are
applied is destroyed and somebody is holding a reference on them anyway.

script-parser: Expose extracting the id from a node

The get_id_from_node() internal function should be exposed inside
Clutter (as a private function) because it can be useful to other
custom parsing code. The code is pretty trivial, but it would be
pointless to re-implement it.

actor: Disable the layout cycle warning with debug disabled

If Clutter has been configured with --enable-debug set to 'no' then we
hide most of the warnings.

bind-constraint: Add accessor methods

ClutterBindConstraint should have accessor methods for its properties,
to allow direct manipulation instead of going through GObject's API.

state: add a duration property

Adding a duration property to ClutterState allows the json parsing
to parse the default transition duration with the generic code paths.

state: avoid walking off empty list

When removing the last key in a list, the last part of the for statement
could cause dereferencing (NULL)->next and thus segfaulting.

animator: avoid walking off empty list

When removing the last key in a list, the last part of the for statement
could cause dereferencing (NULL)->next and thus segfaulting.