Compare commits

...

225 Commits

Author SHA1 Message Date
5f1410f968 clutter: remove deprecated ClutterStage/ClutterAnimator
Removing one without the other was quite the headache, so just remove
both of them together instead.
2018-11-18 11:52:50 +01:00
156aa3dd99 Clutter: remove deprecated ClutterBox 2018-11-18 11:26:03 +01:00
b590c90e90 clutter: Remove deprecated ClutterTableLayout 2018-11-17 14:51:05 +01:00
a8ee0d8b80 clutter: Remove deprecated ClutterGroup 2018-11-17 13:51:24 +01:00
19137361d7 clutter: remove deprecated ClutterShader 2018-11-17 13:51:24 +01:00
1c7472b24d clutter: remove unused deprecated types
They weren't being used anywhere, so they can be easily removed without
going into other files.
2018-11-17 13:51:24 +01:00
787bb4316d x11/window: Minor cleanup
Limit the scope of the 'monitor_rect' variable and break up a long line.

https://bugzilla.gnome.org/show_bug.cgi?id=790207
2018-11-14 16:04:10 +01:00
563c5b0612 monitor-unit-tests: Try resizing clients while headless
Prior to 6dcce19932 this test would crash.

https://bugzilla.gnome.org/show_bug.cgi?id=790207
2018-11-14 16:04:10 +01:00
c8a4e37e0c tests/test-client: Add "resize" command
The "resize" command resizes a window.

https://bugzilla.gnome.org/show_bug.cgi?id=790207
2018-11-14 16:04:10 +01:00
1266c20d4c monitor-unit-tests: Also run a X11 client while testing
We already ran a Wayland client to test various Wayland paths. What was
missing to also run a X11 client was to hook in the X11 async waiter
wires, so do that and run both types of clients.

https://bugzilla.gnome.org/show_bug.cgi?id=790207
2018-11-14 16:04:10 +01:00
76760bfd79 tests: Make all alarm filters use the same type
That'll make them more interchangable, would so ever be needed.

https://bugzilla.gnome.org/show_bug.cgi?id=790207
2018-11-14 16:04:10 +01:00
18c1d9672a gitlab-ci: Add test stage
The test stage runs the whole meson test suite inside Xvfb inside a dbus
session. Running inside Xvfb is required as the cogl, clutter and mutter
tests require to run on top of X11; the dbus session is required to make
mutter succeed in owning names on the bus.

This also updates the Dockerfile to include packages needed for running
tests.

https://gitlab.gnome.org/GNOME/mutter/issues/193
2018-11-14 15:56:16 +01:00
bd624e4dfb tests: Override X11 display number
As with the Wayland display name, to avoid clashes with already an
running Xwayland or Xorg instance, override the X11 display name to
something less likely to cause a clash.

https://gitlab.gnome.org/GNOME/mutter/issues/193
2018-11-14 15:55:45 +01:00
fe1d9fb4a7 tests: Override Wayland display name in test_init()
It's overridden by all test cases, but they all also call test_init() so
do it there instead.

https://gitlab.gnome.org/GNOME/mutter/issues/193
2018-11-14 15:55:45 +01:00
e2cd9abf46 Dockerfile: Align comment with command 2018-11-14 15:55:45 +01:00
a892e7a6aa clutter/tests: Remove events-touch test
The events-touch test tested that clutter could properly process evdev
touch events. It used uinput to post evdev touch events, thus only ran
when runnig the test as root. Running as non-root it'd just silently
pass. As Clutter doesn't process evdev touch events anymore,
libinput does, so the test is fairly pointless, so remove it.
2018-11-14 15:55:45 +01:00
5b3e439c5d cogl/tests: Increase the conform test timeout to 120 s
Running it on CI runners can take bit more time, so let it be for a bit
more until bailing out.
2018-11-14 15:55:45 +01:00
626c3745e2 clutter/master-clock: Destroy source when paused
Pausing the master clock didn't actually pause it if there was already a
scheduled frame in progress. This is problematic if one actually expects
to see no new frame scheduling to happen after pausing, for example it
caused actor 'pre-paint' to be signalled on actors, but nothing was ever
painted.

Avoid this by destroying the master clock source when pausing, and then
recreating it when resuming.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/309
2018-11-14 14:37:04 +01:00
bda9c359af wayland/output: Rotate physical dimensions as well
For Wayland outputs, we do not expose the actual transformation because
mutter does not support wl_surface.set_buffer_transform yet, instead we
swap the logical width and height when the output is rotated.

However, a client wishing to use the physical size would get confused,
so if the output is rotated, rotate the physical dimensions as well for
consistency.

Closes: https://gitlab.gnome.org/GNOME/mutter/issues/369
2018-11-14 12:10:47 +01:00
6c5baf89ed keybindings: Limit corner move to current monitor
Moving windows using `move-to-side-X` and `move-corner-XX` keybindings
should keep windows within the confines of current screen.

`move-to-monitor-XXX` keybindings can be used to move windows to other
monitors.

Closes: https://gitlab.gnome.org/GNOME/mutter/issues/320
2018-11-14 10:32:07 +02:00
9a12befd22 Bump version to 3.31.2
Update NEWS.
2018-11-14 02:01:25 +01:00
9f79cf8a60 Revert "clutter: Avoid redundant margin changes"
This reverts commit 59acb38951.
2018-11-14 01:56:47 +01:00
59acb38951 clutter: Avoid redundant margin changes
When profiling gnome-shell it was found that one of the main triggers
of `clutter_actor_queue_relayout` during animations was
`clutter_actor_set_margin_internal` continuously setting the same
zero margins. That's obviously pointless but also expensive since it
incurs full stage relayouts and reallocation. So just avoid redundant
margin changes.

Helps to further improve:
https://gitlab.gnome.org/GNOME/mutter/issues/233,
https://gitlab.gnome.org/GNOME/gnome-shell/issues/349
2018-11-13 14:21:31 +00:00
fa495286a1 window: Really force update monitor on hot plugs
Commit 8d3e05305 ("window: Force update monitor on hot plugs") added the
flag `META_WINDOW_UPDATE_MONITOR_FLAGS_FORCE` passed to
`update_monitor()` from `update_for_monitors_changed()`.

However, `update_for_monitors_changed()` may choose to call another code
path to `move_between_rects()` and `meta_window_move_resize_internal()`
eventually.

As `meta_window_move_resize_internal()` does not use the "force" flag,
we may still end up in case where the window->monitor is left unchanged.

To avoid that problem, add a new `MetaMoveResizeFlags` that
`update_for_monitors_changed()` can use to force the monitor update from
`meta_window_move_resize_internal()`.

Fixes: 8d3e05305 ("window: Force update monitor on hot plugs")
Closes: https://gitlab.gnome.org/GNOME/mutter/issues/189
2018-11-13 10:10:30 +01:00
0b9404dcbe clutter/device-manager/evdev: Fix constraint cb
As pointed out by @jadahl, this shouldn't matter too much, as the
`constraint_callback` should always be set when initializing the mutter
backend.
2018-11-12 15:38:04 +01:00
9fb46cca55 clutter/keyframe-transition: Properly compare keys 2018-11-12 15:36:29 +01:00
2a4f1be81b clutter/actor: Don't forget va_end if using varargs 2018-11-12 15:36:27 +01:00
1dff74e71c build: Fix libs and cflags in autotools .pc file
Similar to b86d87453d
2018-11-10 16:20:46 +00:00
25c53b2fb2 backend: Freeze frame clock when headless
Don't schedule redraws when being headless; there is nothing to draw so
don't attempt to draw. This also makes a flaky test become non-flaky, as
it previously spuriously got warnings due to windows being "painted"
when headless but lacking frame timings, as nothing was actually
painted.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/170
2018-11-09 11:16:30 +01:00
213ed80284 backends: Move clutter frame clock freeze/thaw API to ClutterSTage
It had nothing to do with EGL or the eglnative backend, and will be used
by non-native backends, so move it to a common place.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/170
2018-11-09 11:16:30 +01:00
9adf8826d2 backends/stage: Remove unused function declaration
https://gitlab.gnome.org/GNOME/mutter/merge_requests/170
2018-11-09 11:16:30 +01:00
19930c6577 backends/stage: Remove MetaStagePrivate
The empty MetaStage was in meta-stage-private.h for no reason, so lets
move it to the C file. This makes it pointless to have a private
instance struct, so just move the fields to the private struct
_MetaStage.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/170
2018-11-09 11:16:30 +01:00
80d5f326e8 clutter: Assume XGE is available at build time
Almost a decade old, lets just assume it's there. This makes the button
on cally-atktext-example work again when building with meson, and
probably other things too.
2018-11-08 18:40:53 +00:00
15732851bc clutter-shader: Don't include unistd.h
It isn't needed.
2018-11-08 18:40:53 +00:00
996949806a cogl: Silence some introspection warnings
Mostly skipping functions of non-introspected types, but also added a
missing callback scope.
2018-11-08 16:20:19 -02:00
c5ac3d6217 theme: Drop gtk_css_provider_get_default()
Instead of using gtk_css_provider_get_default(), add a
static GtkCssProvider and fetch it instead. Creating
GtkCssProviders consume a bit more memory, so keeping
a single one alive is slightly more memory saving.
2018-11-08 16:20:19 -02:00
3d23ecc456 clutter: Drop g_object_newv from ClutterScriptParser
Build an additional set of (GStrv, GValue[]) and pass it
to the non-deprecated g_object_new_with_properties().
2018-11-08 16:20:19 -02:00
cbf6e74915 tests: Remove deprecated ATK functions 2018-11-08 18:08:57 +00:00
b5c4437287 tests: Remove extra const 2018-11-08 18:08:57 +00:00
426d7f3bdf tests: Enumerate all possible events 2018-11-08 18:08:57 +00:00
3483be8566 tests: Remove unused variables 2018-11-08 18:08:57 +00:00
4a7a803c34 README: Mention usage by Gala 2018-11-08 17:11:27 +01:00
4673eeaf5f wayland/xdg-shell: Add toplevel tile state support
The second version of xdg_wm_base added toplevel tile states (top,
right, bottom, left), so lets communicate that.
2018-11-08 13:21:53 +01:00
4f3de88b3d wayland/legacy-xdg-shell: Use helper to fill state array 2018-11-08 13:21:53 +01:00
180bb02fa5 wayland/gtk-shell: Use helper to fill state array 2018-11-08 13:21:53 +01:00
d59cf98690 wayland/gtk-shell: Fix signedness of resource version variable
wl_resource_get_version() returns an int, not an unsigned int.
2018-11-08 13:21:49 +01:00
27fee69ca4 wayland/xdg-shell: Add helper for adding state enum values 2018-11-08 13:21:21 +01:00
640a04d0e4 window: Make edge constraint code more readable
It relied on indices in arrays determining tile direction and
non-obvious bitmask logic to translate to _GTK_EDGE_CONSTRAINTS. Change
this to explicitly named edge constraints, and clear translation methods
that converts between mutters and GTK+s edge constraint formats.
2018-11-08 13:21:21 +01:00
5fc07fcc23 window: Store tile mode as MetaTileMode
An unnecessary memory optimization, storing the tile mode as a 2 bit
unsigned integer, was used. While saving a few bytes, it made debugging
harder. Remove the useless byte packing.
2018-11-08 13:21:21 +01:00
f31cf0c3ef clutter-offscreen-effect: Disable if no texture
If texture allocation fails (e.g. on an old GPU with size limit 2048)
then `update_fbo` would return `FALSE` but leaves `priv->offscreen`
as non-NULL. So the next paint will try to use the offscreen with a
`NULL` texture and crashes. The solution is simply to ensure that
`priv->offscreen` is NULL if there is no `priv->texture`, so the default
(non-offscreen) paint path gets used instead.

Bug reported and fix provided by Gert van de Kraats.

https://launchpad.net/bugs/1795774
2018-11-08 10:18:25 +00:00
d21478b0f0 cogl-auto-texture: Avoid a double-free crash
If texture allocation fails (e.g. on an old GPU with size limit 2048)
then `cogl_texture_new_with_size` was trying to use the same CoglError
twice. The second time was after it had already been freed.

Bug reported and fix provided by Gert van de Kraats.

https://launchpad.net/bugs/1790525
2018-11-08 10:18:25 +00:00
b86d87453d build: Fix include and lib paths in autotools .pc files
Some hadn't been updated after lib/mutter/ changed to lib/mutter-N/.

Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/382
2018-11-07 14:29:30 +01:00
cf7c39e2c1 build: Add soversion to shared libraries
It's easier to add it now, then adding it later would so be needed.
2018-11-07 13:00:47 +00:00
7c774ab53e build: Also build mutter-restart-helper executable
Was left out by mistake. Lets add it.
2018-11-07 13:00:47 +00:00
c03a401f4c clutter: Install x11 related header files when using autotools again
clutter-x11.h and x11/clutter-x11-texture-pixmap.h were not installed
any longer. Fix that.
2018-11-07 12:54:41 +00:00
c7e6cd4e27 plugins/Makefile.am: Install libdefault.so in plugin directory
It was incorrectly installed directly in $(libdir)/mutter-N/ while it
should be installed in $(libdir)/mutter-N/plugins/
2018-11-07 12:54:41 +00:00
fc5b94e077 clutter: Install cally headers again when using autotools
The install step was accidentally removed.
2018-11-07 12:54:41 +00:00
4ce4a2b134 cogl: Expose more headers for introspection
This will allow CoglFramebuffer and its implementations to be exposed
to GJS and other language bindings. This is a necessary part of the
bigger work to make framebuffer management explicit.
2018-11-07 11:27:51 +00:00
93e20cf21c cogl/framebuffer: Mark CoglOffscreen as a CoglFramebuffer implementation
CoglOffscreen is effectively a CoglFramebuffer, but it isn't being marked as
such by the GType machinery. This makes it impossible for introspection to
correctly set this class up.

Fix that by adding a COGL_GTYPE_IMPLEMENT_INTERFACE() code into the declaration
of CoglOffscreen. This does not have any functional changes though.
2018-11-07 11:27:51 +00:00
a8e9f46ed8 Add .gitlab-ci.yml for build testing
This adds compilation testing using meson on the gitlab instance. It
uses a prebuild image built, described in .gitlab-ci/Dockerfile, based
on Fedora 29.

The image is build and published by running:

  cd .gitlab-ci/
  docker build -t registry.gitlab.gnome.org/gnome/mutter/master:v1 .
  docker push registry.gitlab.gnome.org/gnome/mutter/master:v1

Resolves: https://gitlab.gnome.org/GNOME/mutter/merge_requests/132
2018-11-07 11:24:28 +00:00
fe78467815 build: Make libmutter-cogl-path a dependency for test-journal
Otherwise, it might trigger the actual race condition that Continuous
is running into, and access the generated enum headers before they're
created.
2018-11-06 19:15:24 -02:00
d1c4c46281 build: Prefer dependencies instead of link_with
Meson uses the 'dependencies' field to determine and
parallelize build steps, but that isn't entirely true
with 'link_with'; this might cause a race condition
when generating header files while trying to build
them.

Fix that by only using 'dependencies' instead of 'link_with'.
2018-11-06 17:50:24 -02:00
d3dc7d6f49 gudev: Require 232
gudev and libudev might have different versions, and
since 361bf847 we require gudev >= 232 to be able to
use g_autoptr with gudev types.

Since the previous commit, however, the meson build
was using the same version for libudev and gudev.

Fix that by requiring different versions for gudev
(>= 232) and libudev (>= 228).
2018-11-06 17:04:12 -02:00
b607d35aad build: Make minimum udev version as 228
Continuous' latest udev version is 228, and that is
not going to change too soon. Since we do not depend
on udev 232 specific features or bugfixes, just lower
the minimum version and make Continouos happy.
2018-11-06 16:48:47 -02:00
ef85d1a643 Add meson build support
This commit adds meson build support to mutter. It takes a step away
from the three separate code bases with three different autotools setups
into a single meson build system. There are still places that can be
unified better, for example by removing various "config.h" style files
from cogl and clutter, centralizing debug C flags and other configurable
macros, and similar artifacts that are there only because they were once
separate code bases.

There are some differences between the autotools setup and the new
meson. Here are a few:

The meson setup doesn't generate wrapper scripts for various cogl and
clutter test cases. What these tests did was more or less generate a
tiny script that called an executable with a test name as the argument.
To run particular tests, just run the test executable with the name of
the test as the argument.

The meson setup doesn't install test files anymore. The autotools test
suite was designed towards working with installed tests, but it didn't
really still, and now with meson, it doesn't install anything at all,
but instead makes sure that everything runs with the uninstalled input
files, binaries and libraries when running the test suite. Installable
tests may come later.

Tests from cogl, clutter and mutter are run on 'meson test'. In
autotools, only cogl and clutter tests were run on 'make check'.
2018-11-06 18:51:44 +01:00
417c00b8fa wayland/eglstream: Don't build skeleton when disabled
Instead of calling no-op functions when EGLStream support isn't enabled,
make it clear at the call site that EGLStream support is optional.
2018-11-06 17:17:36 +01:00
6192e944b8 wayland/touch: Only handle touch when using the native backend
The touch handling code uses evdev API, thus will not work on other
backends. Thus, put touch handling code behind runtime backend checks
and only include the code when native backend support is enabled.
2018-11-06 17:17:36 +01:00
8f2680c612 wayland/tablet: Fix warnings when native backend is disabled 2018-11-06 17:17:36 +01:00
d686dc9f46 Fix compiler errors when Wayland support is disabled 2018-11-06 17:17:36 +01:00
f139360569 Make it possible to build without GLX support 2018-11-06 17:17:36 +01:00
bf42b54faa Make it possible to build without EGL support
This will avoid building anything related to EGL. For meson, this will
mean that both the native backend an the Wayland support must also be
disabled.
2018-11-06 17:17:36 +01:00
d48d56f831 autotools: Make install directories paths more consistent
Install include files in
$prefix/include/mutter-$apiversion/[clutter,cogl,...,meta]/, and
datafiles in /usr/share/mutter-$apiversion/.... We still would conflict
e.g. given that our gettext name is "mutter", and how keybindings are
installed, but it's a step in the right direction.
2018-11-06 17:17:36 +01:00
32f3bb02e1 tests: Move out test client path init into helper function
Makes the common test init function simpler to read.
2018-11-06 17:17:36 +01:00
d21022f562 tests/headless-start-test: Use common test init function
Outsource the initialization of GTest to the same function used by the
other tests.
2018-11-06 17:17:36 +01:00
2af229fe98 tests: Call g_test_init() in test-runner too
This makes the log handler that breaks test redundant, as GTest already
does this.
2018-11-06 17:17:36 +01:00
c65617cb5a Fix some of introspection comment issues
Missing colon and incorrect type reference in descriptions.
2018-11-06 17:17:36 +01:00
c663f4ae84 tests: Add env var to override plugin used for tests
This is so that the test suite can point at the non-installed version.
2018-11-06 17:17:36 +01:00
0afaf5262b plugin: Rename the .so file from plugin.so to libplugin.so
This is the filename convention you get when you define a shared module
in meson, and since there is no particular reason to not include the
"lib" prefix, lets make it easier to port it over. While at it,
de-duplicate the retrieval of the plugin name.
2018-11-06 17:17:36 +01:00
85fbf66179 Move meta-enum-type.*.in into meta/
It'll be installed in the meta/ directory, so put the template files in
the corresponding directory in the tarball. This will also simplify the
port to meson.
2018-11-06 17:17:36 +01:00
a97cc84b81 Fix warnings when building without verbose mode 2018-11-06 17:17:36 +01:00
bc32655c28 Pass -D_GNU_SOURCE instead of defining it in source 2018-11-06 17:17:36 +01:00
176e6fcded x11: Require XInput 2.3 at build time
The needed libXi version was released 5 years ago, so should be fine.
2018-11-06 17:17:36 +01:00
ecec99eedb x11: Require xrandr 1.5 at build time
While leaving the runtime checks in place, requiring xrandr 1.5 at build
time allows us to remove some seemingly unnecessary conditional
inclusion of functionality.
2018-11-06 17:17:36 +01:00
2f4a68c8c3 Clean up include macros mess
The order and way include macros were structured was chaotic, with no
real common thread between files. Try to tidy up the mess with some
common scheme, to make things look less messy.
2018-11-06 17:17:36 +01:00
92f4ffc0dd tests: Make testboxes an actual test
testboxes was a binary that did unit testing, but it wasn't integrated
to the test system, so in effect, it was never run. Instead integrate it
into the other mutter unit tests. This includes changing a few of
meta_warning()s into g_warning()s so that the GTest framework can handle
them.
2018-11-06 17:17:36 +01:00
8a03f1ad02 Always generate meta-default-modes.h
This adds a hard requirement on having cvt installed, which in the past
was soft, where the generated file was added to the repository.
2018-11-06 17:17:36 +01:00
e0727aba5f clutter/tests/micro-bench: Don't define unused macro
TESTS_DATA_DIR was not used by any of the tests, so no use defining it.
2018-11-06 17:17:36 +01:00
14be04a630 clutter/tests: Unconditionally include tests using gdk-pixbuf
We already have gdk-pixbuf as a dependency, so there is no reason to
make it conditional here.
2018-11-06 17:17:36 +01:00
0067f78155 clutter: Unconditionalize a few X11 extensions
We now require xcomposite, xkb, xi 2.2, at least at compile time.
2018-11-06 17:17:36 +01:00
3e03d1e38e clutter/configure.ac: Remove left-over gbm and drm dependencies
The gbm and drm facing code has since long been moved into mutter.
2018-11-06 17:17:36 +01:00
fe7a67f0e7 clutter/configure.ac: Remove unused gdk dependency 2018-11-06 17:17:36 +01:00
db77e2e187 clutter: Assume compiler supports visibility flag and attributes
Unconditionally pass -fvisibility=hidden to compiler and define
_CLUTTER_EXTERN to __attribute__((visibility("default"))) extern.
2018-11-06 17:17:36 +01:00
e3c6e3b84d clutter: Fix a couple of guard macros
Use #ifdef instead of #if in a couple of places.
2018-11-06 17:17:36 +01:00
0d9391e282 clutter: Remove examples
Running clutter apps standalone using mutters fork is not something
worth supporting.
2018-11-06 17:17:36 +01:00
1e2610e4f4 clutter: Remove useless OS_LINUX macro
It was unconditionally set to 1.
2018-11-06 17:17:36 +01:00
0095c2e340 clutter: Require full relative path when including 2018-11-06 17:17:36 +01:00
c90e63a91d clutter: Stop defining some unused macros 2018-11-06 17:17:36 +01:00
8c0e13ca7a clutter: Remove clutter specific version
Use the mutter version when something is still needed.
2018-11-06 17:17:36 +01:00
8894ec462a cogl: Pass unit-tests file to run-tests.sh
There are different unit-tests file generated containing lists of tests
the test-runner.sh should run. Running run-tests.sh read the unit-tests
in the current directory, which is inconvenient to do when using meson.
2018-11-06 17:17:36 +01:00
331e830cf6 cogl: Fix HAVE_COGL_GL guard
Macro was only defined when defined to 1.
2018-11-06 17:17:36 +01:00
d68fcbc887 cogl: Make cogl-config.h include check explicit
Don't rely on some combination of macros, but an explicit definition to
check whether cogl-config.h was included.
2018-11-06 17:17:36 +01:00
9dbdf6b724 cogl: Require relative full paths when including
I.e. including a OpenGL driver file, the path "driver/gl/..." must be
specified when including.
2018-11-06 17:17:36 +01:00
530861b24d cogl: Remove left-over WebGL paths 2018-11-06 17:17:36 +01:00
11f8b12a9d clutter: Unconditionally include clutter-build-config.h 2018-11-06 17:17:36 +01:00
0163a0b0cd cogl: Unconditionally include cogl-config.h 2018-11-06 17:17:36 +01:00
12171e413b cogl: Unconditionally depend on cairo 2018-11-06 17:17:36 +01:00
99fb79f4cb cogl: Unconditionally include "strings.h" 2018-11-06 17:17:36 +01:00
24d8d40deb cogl/tests: Mark failing test as known failure
This allows us to enable running the tests again. Not fixing the
failure is at least better than not running the tests at all.
2018-11-06 17:17:36 +01:00
97004e6114 cogl: Remove ARBfp pipeline support
As with fixed pipelines, we require the use of the GLSL pipeline in
mutter, and no point in supporting ARBfp anyway.
2018-11-06 17:17:36 +01:00
8f58ad02fb cogl: Remove fixed pipeline support
We require being able to use shaders so stop supporting a pipeline that
wouldn't work to begin with.
2018-11-06 17:17:36 +01:00
98af9bb251 cogl: Remove notion of a "cogl" version
Mutters copy of cogl isn't a separate library with its own version, so
remove the old version macros.
2018-11-06 17:17:36 +01:00
7b2eaa76a4 cogl: Remove support for GLESv1
We have no need for it in mutters cogl variant.
2018-11-06 17:17:36 +01:00
00a5523667 cogl: Remove some left over KMS backend stuff 2018-11-06 17:17:36 +01:00
f30cef3046 cogl: Always build CoglPango support 2018-11-06 17:17:36 +01:00
fba7d8c79c cogl: Always build CoglPath support 2018-11-06 17:17:36 +01:00
46942c24a3 cogl: Make various functions non-optional
Remove fallback implementations of some functions available in
gcc/clang and Linux/BSDs.
2018-11-06 17:17:36 +01:00
9846a4d812 cogl: Make _Static_assert non-optional 2018-11-06 17:17:36 +01:00
da741ead25 cogl-gles2/Makefile.am: Add cogl/ includedir
Otherwise cogl-egl-defines.h isn't found when building out-of-tree.
2018-11-06 17:17:36 +01:00
31f525d566 x11: close display in an idle function
Closing a GdkDisplay during an event handler is not currently supported by Gdk
and it will result in a crash when doing e.g. 'mutter --replace'. Using an idle
function will close it safely in a subsequent main loop iteration.

Fixes: https://gitlab.gnome.org/GNOME/gnome-shell/issues/595
2018-11-05 12:04:01 +00:00
92cccf53df workspace-manager: Allow workspace layout to be overridden
meta_workspace_manager_override_workspace_layout is implemented by
calling meta_workspace_manager_update_workspace_layout which
respects the workspace_layout_overridden flag.  After the first call
to meta_workspace_manager_override_workspace_layout all subsequent
calls fail silently.

Reset workspace_layout_overridden to FALSE before calling
meta_workspace_manager_update_workspace_layout.

https://gitlab.gnome.org/GNOME/mutter/issues/270
2018-10-30 10:54:57 +01:00
4282067e24 gpu-kms: assert on invalid flip attempts
drmModePageFlip() is guaranteed to fail for the invalid FB id 0.
Therefore it never makes sense to call this function with such argument.
Disabling a CRTC must be done with SetCrtc instead, for example.

Trying to flip to FB 0 not only fails, but it also causes Mutter to
never try page flip on this output again, using drmModeSetCrtc()
instead.
2018-10-25 09:57:39 +00:00
85e9784a22 renderer/native: fix next_fb_id race on CPU copy path
There was a race in setting next_fb_id when a secondary GPU was using
the CPU copy path. Losing this race caused the attempt to
drmModePageFlip () to FB ID 0 which is invalid and always fails. Failing
to flip causes Mutter to fall back to drmModeSetCrtc () permanently.

In meta_onscreen_native_swap_buffers_with_damage ():
- update_secondary_gpu_state_pre_swap_buffers ()
  - copy_shared_framebuffer_cpu () but only on the CPU copy path
    - secondary_gpu_state->gbm.next_fb_id is set
- wait_for_pending_flips ()
  - Waits for any remaining page flip events and executes and destroys
    the related page flip closures.
    - on_crtc_flipped ()
      - meta_onscreen_native_swap_drm_fb ()
        - swap_secondary_drm_fb ()
	  - secondary_gpu_state->gbm.next_fb_id = 0;
- meta_onscreen_native_flip_crtcs ()
  - meta_onscreen_native_flip_crtc ()
    - meta_gpu_kms_flip_crtc () gets called with fb_id = 0

This race was observed lost when running 'mutter --wayland' on a machine
with two outputs on Intel and one output on DisplayLink USB dock, and
wiggling around a weston-terminal window between the Intel and
DisplayLink outputs. It took from a second to a minute to trigger. For
testing with DisplayLink outputs Mutter also needed a patch to take the
DisplayLink output into use, as it would have otherwise been ignored
being a platform device rather than a PCI device.

Fix this race by first waiting for pending flips and only then
proceeding with the swap operations. This should be safe, because the
pending flips could have completed already before entering
meta_onscreen_native_swap_buffers_with_damage ().
2018-10-25 09:57:39 +00:00
49fea735aa wayland/text-input: Ignore text-input state commit when not focused
We might unset focus, or already be out of focus (e.g. an X11 client or
clutter text entry is focused) when a text-input state is committed by
the client. We handled this before, except when text input was
explicitly disabled by the client, the Wayland text-input was in focus
by the input method, and it focused itself out.

Simplify the logic a bit by just dropping the state on the floor in all
cases where after any potential focus changes were done, we are not
focused.

Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/353
2018-10-23 14:13:33 +02:00
8200995fdb shaped-texture: Clean up texture regions
We allocated texture regions, but didn't free them when finished,
causing a leak.

https://gitlab.gnome.org/GNOME/gnome-shell/issues/653
2018-10-20 15:47:50 +02:00
71a62bb18f constraints: Make current placement rule stack allocated
We're not going to keep it past the function scope, so no reason to put
it on the heap. We also didn't free it, so this'll fix a memory leak.

https://gitlab.gnome.org/GNOME/gnome-shell/issues/653
2018-10-20 15:46:37 +02:00
76abe87090 xprops: Make sure text_property_to_utf8() returns UTF8
Commit 840378ae68 changed the code to use XmbTextPropertyToTextList()
instead of gdk_text_property_to_utf8_list_for_display(), but didn't
take into account that the replacement returns text in the current
locale's encoding, while any callers (rightfully) expect UTF8.

Fix this by converting the text if necessary.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/227
2018-10-12 15:01:36 +02:00
62775d1913 x11/window-props: Do not convert WM_NAME
The WM_NAME property is of type TEXT_PROPERTY, which is supposed to be
returned as UTF-8. Commit 840378ae68 broke that assumption, resulting
in crashes with non-UTF8 locales; however the "fix" of converting from
LATIN1 to UTF8 is wrong as well, as the conversion will spit out garbage
when the input encoding isn't actually LATIN1.

Now that the original issue in text_property_to_utf8() has been fixed,
we can simply revert the relevant bits of commit d62491f46e.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/227
2018-10-12 15:01:29 +02:00
e24947a460 Revert "Characters of window title bar garbled"
For some reason Gitlab pushed the wrong commits when merging
https://gitlab.gnome.org/GNOME/mutter/merge_requests/227. Correct that.

This reverts commit d387aa428a.
2018-10-12 15:00:02 +02:00
d387aa428a Characters of window title bar garbled 2018-10-11 07:15:22 +00:00
3faaa9ce14 Bump version to 3.30.1
Update NEWS.
2018-10-08 20:55:50 +02:00
f19260bfde common: Replace left-over screen reference 2018-10-08 19:00:56 +02:00
df94a18791 clutter: Add clutter_input_method_forward_key() method.
This allows input methods to inject key events with specific keyval/keycode,
those events will be flagged with CLUTTER_EVENT_FLAG_INPUT_METHOD so they
won't be processed by the IM again.

https://gitlab.gnome.org/GNOME/gnome-shell/issues/531
2018-10-08 16:30:04 +00:00
2e18f6d793 wayland: Relax requirements for evdev events to have a evcode
There may be emulated events that don't contain those, it's fine to
go through the fallback paths for these.
2018-10-08 16:30:04 +00:00
67aab7c138 clutter: Do not latch modifiers on modifier keys
If the user maps eg. Alt+F2 to a pad button, the MetaInputSettings will
send the full Alt press, F2 press, F2 release, Alt release sequence.
However the keycode corresponding to Alt is found in level 1, so the
Shift modifier gets unintendedly latched in addition to the Alt key
press/release pair.

We could probably improve keycode lookup heuristics so level=0 (and
no modifier latching) is preferred, but we can do without it altogether
for modifier keys.
2018-10-08 16:24:11 +00:00
fa1add2ee6 window: Remember relative position after constraining with custom rule
In order to allow a window with a custom rule placement to be moved
together with its parent, the final rule used derived from the
constraining were used for subsequent constraints. This was not enough
as some constraining cannot be translated into a rule, such as sliding
across some axis.

Instead, make it a bit simpler and just remember the position relative
to the parent window, and use that the next time.

This is a rework of 5376c31a33 which
caused the unwanted side effects.

Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/332
2018-10-08 16:17:50 +00:00
6267732bec monitor-manager: use MonitorsConfig to track switch_config
When constructing MetaMonitorsConfig objects, store which type
of switch_config they are for (or UNKNOWN if it is not such
type of config).

Stop unconditionally setting current_switch_config to UNKNOWN when
handling monitors changed events. Instead, set it to the switch_config
type stored in the MonitorsConfig in the codepath that updates logical
state. In addition to being called in the hotplug case along the same
code flow that generates monitors changed events, this is also called
in the coldplug case where a secondary monitor was connected before
mutter was started.

When creating the default linear display config, create it as a
switch_config so that internal state gets updated to represent
linear mode when this config is used.

The previous behaviour of unconditionally resetting current_switch_config
to UNKNOWN was breaking the internal state machine for display config
switching, causing misbehaviour in gnome-shell's switchMonitor UI when
using display switch hotkeys. The lack of internal tracking when the
displays are already in the default "Join Displays" linear mode was
then causing the first display switch hotkey press to do nothing
(it would attempt to select "Join Displays" mode, but that was already
active).

Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/281
https://gitlab.gnome.org/GNOME/mutter/merge_requests/213
2018-10-08 15:53:45 +08:00
95649fd2bc wayland/data-device: Focus out when focus surface destroyed
When repicking after a surface was destroyed, if the destroyed surface
was the drag focus, we'd try to focus-out from it after it was
destroyed, causing a NULL pointer dereference.

Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/336
2018-10-07 18:12:18 +00:00
49780245f4 window/wayland: Don't initialize a window as showing
With Wayland, a window is not showing until it's shown. Until this
patch, the initial state of MetaWindow, on the other hand, was that a
window is initialized as showing. This means that for a window to
actually be classified as shown (MetaWindow::hidden set to FALSE),
something would first have to hide it.

Normally, this wasn't an issue, as normally we'd first create a window,
determine it shouldn't be visible (due to missing buffer), hide it
before the next paint, then eventually show it. This doesn't work if
mutter isn't drawing any frames at the moment (e.g. the user switched
VT), as we'd miss the hiding before showing as e result of a buffer
being attached. The most visible side effect is that a window can't be
moved as the window actor remains frozen.

This commit fixes this issue by correctly classifying a newly created
Wayland window as "hidden".

Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/331
2018-10-05 17:50:22 +02:00
ff08e19f52 shaped-texture: Transform clip and opaque region to texture space
The clip and opaque region are both in a translated stage coordinate
space, where the origin is in the top left corner of the painted
texture. The painting, however, is in the texture coordinate space,
so when the texture is scaled, the coordinate spaces differ.

Handle this by transforming the clip and opaque region to texture
coordinate space before computing the blend region and the opaque region
to paint.

Closes: https://gitlab.gnome.org/GNOME/mutter/issues/300
2018-10-04 15:06:10 +02:00
9c77e52ad3 region-utils: Add API to scale an integer region with a double
The added API lets the caller decide whether to shrink or grow the
rectangles if there are rounding issues.

Related: https://gitlab.gnome.org/GNOME/mutter/issues/300
2018-10-04 15:06:10 +02:00
0ae7ef4bc4 region-utils: Some whitespace fixes
Related: https://gitlab.gnome.org/GNOME/mutter/issues/300
2018-10-04 15:06:10 +02:00
556ed7b937 shaped-texture: Move variable declaration on top
Related: https://gitlab.gnome.org/GNOME/mutter/issues/300
2018-10-04 15:06:10 +02:00
b5a0068091 shaped-texture: Use ints for sizes
They were int before entering MetaShapedTexture, used as ints in the
cairo regions and rectangles, so there is no reason they should be
stored as unsigned.

Related: https://gitlab.gnome.org/GNOME/mutter/issues/300
2018-10-04 15:06:10 +02:00
a3d826c54b renderer/native: honour dumb buffer stride
meta_renderer_native_gles3_read_pixels() was assuming that the target
buffer stride == width * 4. This is not generally true. When a DRM
driver allocates a dumb buffer, it is free to choose a stride so that
the buffer can actually work on the hardware.

Record the driver chosen stride in MetaDumbBuffer, and use it in the CPU
copy path. This should fix any possible stride issues in
meta_renderer_native_gles3_read_pixels().
2018-10-04 11:57:35 +03:00
72e236106f renderer/native: assert dumb buffer size on CPU copy
Track the allocated dumb buffer size in MetaDumbBuffer. Assert that the
size is as expected in copy_shared_framebuffer_cpu().

This is just to ensure that Cogl and the real size match. The size from
Cogl was used in the copy, so getting that wrong might have written
beyond the allocation.

This is a safety measure and has not been observed to happen yet.
2018-10-04 11:57:35 +03:00
3e1ca62782 renderer/native: check format for drmModeAddFB fallback
If drmModeAddFB2() does not work, the fallback to drmModeAddFB() can
only handle a single specific format. Make sure the requested format is
that one format, and fail the operation otherwise.

This should at least makes the failure mode obvious on such old systems
where the kernel does not support AddFB2, rather than producing wrong
colors.
2018-10-04 11:57:35 +03:00
c71f6a18ad Updated Czech translation 2018-10-01 17:39:07 +02:00
f7c1f418ba Updated Czech translation 2018-10-01 17:36:18 +02:00
0210b95109 Update Serbian translation 2018-09-29 10:05:53 +00:00
68ec9ac017 wayland: No xdg-output events without a logical monitor
To avoid a known race condition in the wl_output protocol documented in
https://phabricator.freedesktop.org/T7722, mutter delays the `wl_output`
destruction but nullify the `logical_monitor` associated with the
`wl_output` and the binding routine `bind_output()` makes sure not to
send wl_output events if the `logical_monitor` is `NULL` (see commit
1923db97).

The binding routine for `xdg_output` however does not check for such a
condition, hence if the output configuration changes while a client is
binding to xdg-output (typically Xwayland at startup), mutter would
crash while trying to access the `logical_monitor` which was nullified
by the change in configuration.

Just like `bind_output()` does for wl_output, do not send xdg-output
events if there is no `logical_monitor` yet.

Closes: https://gitlab.gnome.org/GNOME/mutter/issues/194
2018-09-25 15:14:18 +02:00
8dcac664fa core: Preserve focus across decoration changes
Changes in window decoration result in the window being reparented
in and out its frame. This in turn causes unmap/map events, and
XI_FocusOut if the window happened to be focused.

In order to preserve the focused window across the decoration change,
add a flag so that the focus may be restored on MapNotify.

Closes: #273
2018-09-24 13:44:53 +00:00
2fb3db7659 compositor: Skip windows not visible to the compositor
The compositor will automatically unredirect the top most window which
is fully visible on screen. When unredirecting windows, it also shapes
the compositor overlay window (COW) so that other redirected windows
still shows correctly.

The function `get_top_visible_window_actor()` however will simply walks
down the window list, so if a window is placed on a layer above and
unredirected, then iconified by the client, it will still be picked up
by `get_top_visible_window_actor()` and he compositor will reckon it's
still unredirected while not in a visible state anymore, thus leaving a
black area on screen.

Make sure we skip the windows not known to the compositor while picking
the top visible window actor to avoid this issue.

Closes: https://gitlab.gnome.org/GNOME/mutter/issues/306
2018-09-21 18:50:06 +02:00
7d82cdeea3 window/wayland: Freeze updates until shown
Not until the window is shown do we know what monitor it's on, thus the
size, so freeze updates (shape etc) until the window is shown.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/229
2018-09-19 15:39:54 +00:00
e2e7296612 window: Move out 'updates frozen' state into implementations
Implementation of said state was just related to X11, so move it into
window-x11.c. The Wayland path always fell back on the returning TRUE,
so just do that for now.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/229
2018-09-19 15:39:54 +00:00
8685de9607 input-settings: detect trackball using udev ID_INPUT_TRACKBALL
Previously, trackballs were detected based on the presence of the
substring "trackball" in the device name. This had the downside of
missing devices, such as the Kensington Expert Mouse, which don't have
"trackball" in their names.

Rather than depending on the device name, use the ID_INPUT_TRACKBALL
property from udev to determine whether or not to treat a device as a
trackball.

This adds a new function, `is_trackball_device`, to MetaInputEvents, and
eliminates the `meta_input_device_is_trackball` function.

Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/258
2018-09-19 08:48:27 +00:00
a8a3c1017f actor: Also recompute paint volume if we recently dropped effects
Otherwise we'll be stuck with the same paint volume on the last
frame of the given effect, which could be wrong.
2018-09-18 19:39:12 +00:00
5d19aee23a actor: Always use get_paint_volume override for active effects
If an effect is active and it overrides the paint volume, we should
always recompute the paint volume when requested and not use the
cache, since the paint volume override can change from call to
call depending on what phase of painting we are in. For instance,
if we are part way through painting effects and request the
paint volume, the paint volume should only go up to the current
effect, but in a later call to compute repaint regions, the
paint volume needs to expand to accomadate the effect.

This still involves a lot of recomputation in the case of effects -
in a later clutter version it would be worth adding an API to
allow effects to explicitly recompute and return a new the paint
volume up to the current effect as opposed to recomputing
the cached one.
2018-09-18 19:39:12 +00:00
4270eef16e actor: Fix logic error in determining terminal effect for paint volume
Previously we were checking l->data != NULL || (l->data != NULL &&
l->data != priv->current_effect). This would continue the loop even
if l->data == priv->current_effect, since l->data != NULL, which was
not the intention of that loop.

We also don't need to check that l->data != NULL before checking if
it does not match the current_effect, since we already checked
that current_effect was non-NULL before entering the loop.
2018-09-18 19:39:12 +00:00
b443bd42ac window: unmanage dialog when clearing transient_for
On Wayland, xdg-foreign would leave a modal dialog managed even after
the imported surface is destroyed.

This is sub-optimal and this breaks the atomic relationship one would
expect between the parent and its modal dialog.

Make sure we unmanage the dialog if transient_for is unset even for
Wayland native windows.

Related: https://gitlab.gnome.org/GNOME/mutter/issues/174
Related: https://gitlab.gnome.org/GNOME/mutter/issues/221
2018-09-14 11:11:31 +02:00
267503b5f3 build: Fix non-wayland builds 2018-09-11 16:19:19 +00:00
a3d9f987c8 input-settings-x11: Push error trap
Pops are lonely without push, so add one for a happy error trap.

https://gitlab.gnome.org/GNOME/mutter/issues/294
2018-09-07 19:42:37 +02:00
9cfd185316 clutter: Handle grabs from CLUTTER_TABLET_DEVICE devices
Those would result in warnings. Actually, these should be dealt
similarly to pointers, as they get their own standalone pointer
cursor in Wayland.

Related: https://gitlab.gnome.org/GNOME/gnome-shell/issues/540
2018-09-07 15:17:36 +02:00
176117c5f7 device-manager-evdev: handle tablet axis motion before button and tip events
Some tablets have a noticable pointer jump on tip down/up, causing unintended
lines during drawing. Likewise, a button event may have an axis update that we
currently ignore. libinput provides tablet axis events only if no other state
changes, the client must instead get the current axis data from the tip/button
event. So let's do this, process the event axis data during tip/button as
well.

A libinput recording to reproduce is the 'dots.yml' in
https://gitlab.freedesktop.org/libinput/libinput/issues/128

Fixes #289
2018-09-07 19:54:06 +10:00
8083065579 Update Belarusian translation 2018-09-06 15:48:19 +00:00
34f5be726d Bump version to 3.30.0
Update NEWS.
2018-09-04 00:05:51 +02:00
b53707f8c4 Update Croatian translation 2018-09-02 16:40:57 +00:00
d9294e4eb0 Updated Danish translation 2018-09-01 18:46:09 +02:00
94f8acc8fe Updated Vietnamese translation
Signed-off-by: Trần Ngọc Quân <vnwildman@gmail.com>
2018-09-01 08:30:06 +07:00
4841c1b13e Update Latvian translation 2018-08-31 17:56:20 +00:00
1e00cd290d Update Hungarian translation 2018-08-31 13:05:10 +00:00
3daa2d2751 Update Galician translation 2018-08-29 22:24:03 +00:00
444af437a0 Bump version to 3.29.92
Update NEWS.
2018-08-29 18:42:02 +02:00
eebcf98284 Updated Czech translation 2018-08-29 07:30:18 +02:00
7d973ac538 Updated Czech translation 2018-08-29 07:29:26 +02:00
0ada04089c Update Brazilian Portuguese translation 2018-08-28 23:00:01 +00:00
85284acb00 clutter/x11: Implement keycode lookup from keysyms on virtual key devices
Unfortunately XKeysymToKeycode() falls short in that it coalesces keysyms
into keycodes pertaining to the first level (i.e. lowercase). Add a
ClutterKeymapX11 method (much alike its GdkKeymap counterpart) to look up
all matches for the given keysym.

Two other helper methods have been added so the virtual device can fetch
the current keyboard group, and latch modifiers for key emission. Combining
all this, the virtual device is now able to handle keycodes in further
levels.

Closes: https://gitlab.gnome.org/GNOME/gnome-shell/issues/135
2018-08-28 12:22:52 +02:00
388d065699 Update Swedish translation 2018-08-27 22:56:25 +00:00
e191c21e04 window/wayland: Don't recursive indefinitely when updating monitor
When we update the main monitor, there is a rule that makes it so that
popup windows use the same main monitor as their parent. In the commit
f4d07caa38 the call that updates and
fetches the main monitor of the toplevel accidentally changed to update
from itself, causing a indefinite recursion eventually resulting in a
crash.

Closes: https://gitlab.gnome.org/GNOME/mutter/issues/279
2018-08-27 17:49:52 +02:00
5376c31a33 window: Keep windows with placement rule attached to parent
A window placed using a placement rule should keep that relative
position even if the parent window moves, as the position tied to the
parent window, not to the stage. Thus, if the parent window moves, the
child window should move with it.

In the implementation in this commit, the constraints engine is not
used when repositioning the children; the window is simply positioned
according to the effective placement rule that was derived from the
initial constraining, as the a xdg_popup at the moment cannot move
(relative its parent) after being mapped.

Closes: https://gitlab.gnome.org/GNOME/mutter/issues/274
2018-08-27 12:15:06 +00:00
ca5b27baf5 wayland/gtk-shell: Handle requests after toplevel was unmanaged
As with xdg-toplevel, a gtk-surface can be unmanaged by the compositor
without the client knowing about it, meaning the client may still send
updates and make requests. Handle this gracefully by ignoring them. The
client needs to reset all the state anyway, if it wants to remap the
same surface.

https://gitlab.gnome.org/GNOME/mutter/issues/240
2018-08-27 11:43:53 +00:00
64df627688 wayland/legacy-xdg-shell: Handle requests after toplevel was unmanaged
As with xdg-toplevel proper, a legacy xdg-toplevel can be unmanaged by
the compositor without the client knowing about it, meaning the client
may still send updates and make requests. Handle this gracefully by
ignoring them. The client needs to reassign the surface the legacy
xdg-toplevel role again, if it wants to remap the same surface, meaning
all state would be reset anyway.

Closes: https://gitlab.gnome.org/GNOME/mutter/issues/240
2018-08-27 11:43:53 +00:00
a740f50cd7 wayland/legacy-xdg-shell: Cache frame callbacks if toplevel is unmanaged
A toplevel window can be unmanaged without the client knowing it (e.g. a
modal dialog being unmapped together with its parent. When this has
happened, take frame callbacks queued on a commit and cache them on the
generic surface queue. If the toplevel is to be remapped because the
surface was reassigned the toplevel role, the cached frame callbacks
will be queued on the surface actor and dispatched accordingly.

https://gitlab.gnome.org/GNOME/mutter/issues/240
2018-08-27 11:43:53 +00:00
5fd0f62a62 wayland/xdg-shell: Handle requests after toplevel was unmanaged
A window can be unmanaged without asking the client to do it, for
example as a side effect of a parent window being unmanaged, if the
child window was a attached dialog.

This means that the client might still make requests post updates to it
after that it was unmapped. Handle this gracefully by NULL-checking the
surface's MetaWindow pointer. We're not loosing any state due to this,
as if the client wants to map the same surface again, it needs to either
reassign it the toplevel role, or reset the xdg-toplevel, both resulting
in all state being lost anyway.

https://gitlab.gnome.org/GNOME/mutter/issues/240
2018-08-27 11:43:53 +00:00
80d420ff43 wayland/xdg-shell: Cache frame callbacks if toplevel is unmanaged
A toplevel window can be unmanaged without the client knowing it (e.g. a
modal dialog being unmapped together with its parent. When this has
happened, take frame callbacks queued on a commit and cache them on the
generic surface queue. If the toplevel is to be remapped, either because
the surface was reassigned the toplevel role, or if it was reset and
remapped, the cached frame callbacks will be queued on the surface actor
and dispatched accordingly.

https://gitlab.gnome.org/GNOME/mutter/issues/240
2018-08-27 11:43:53 +00:00
407d62943c wayland/xdg-shell: Cache pending frame callbacks on popup reset
A popup can be reset, and when that happens, window and actor are
destroyed, and won't be created again unless it is reassigned the
popup role.

If a client queued frame callbacks when resetting a popup, the frame
callbacks would be left in the pending state, as they were not queued on
the actor, meaning we'd hit an assert about the frame callbacks not
being handled. Fix this by caching them on the MetaWaylandSurface, so
that they either are cleaned up on destruction, or queued on the actor
would the surface be re-assigned the popup role.

https://gitlab.gnome.org/GNOME/mutter/issues/240
2018-08-27 11:43:53 +00:00
0ace58d05f wayland/surface: Add API to cache frame callbacks
Sometimes it may be useful for roles to put callbacks in the generic
surface frame callback queue. The surface frame callback queue will
either eventually be processed on the next surface role assignment that
places the frame callbacks in a role specific queue, processed at some
other point in time by a role, or cleaned up on surface destruction.

https://gitlab.gnome.org/GNOME/mutter/issues/240
2018-08-27 11:43:53 +00:00
d791710197 wayland/xdg-shell: Queue frame callbacks on new actor after resetting
When a xdg-toplevel is reset, the window and actor are recreated, and
all state is cleared. When this happened, we earlied out from the
xdg-toplevel commit handler, which would mean that if the client had
queued frame callbacks when resetting, they'd be left in the pending
commit state, later hitting an assert as they were not handled.

Fix this by queuing the frame callbacks no the new actor, so that they
are emitted whenever the actor is eventually painted.

https://gitlab.gnome.org/GNOME/mutter/issues/240
2018-08-27 11:43:53 +00:00
b30c907ef9 wayland: Use geometry_scale on opaque regions
This was done for input regions in commit 718a89eb2f (Thanks Jonas
for the archaeology!) but opaque regions follow the same scaling.
This brings less evident issues as opaque regions are just used for
culling optimizations.
2018-08-27 08:38:13 +00:00
784a774d9c wayland: Fix input/opaque regions calculation on hidpi
Commit 6a92c6f83 unintendedly broke input/opaque region calculations
on hidpi. Most visible side effect is that clicking is only allowed
in the upper-left quarter of windows.

The surface coordinates are returned in logical unscaled buffer
size. We're however interested in actor coordinates (thus real
pixels) here.

As it is a bit of a detour how the scale to be applied is calculated,
refactor a meta_wayland_actor_surface_get_geometry_scale() function
that we can use it here, and use it consistently for surface size and
the given regions.
2018-08-27 08:38:12 +00:00
8d3e053059 window: Force update monitor on hot plugs
Commit a3da4b8d5b changed updating of
window monitors to always use take affect when it was done from a
non-user operation. This could cause feed back loops when a non-user
driven operation would trigger the changing of a monitor, which itself
would trigger changing of the monitor again due to a window scale
change.

The reason for the change, was that when the window monitor changed due
to a hot plug, if it didn't actually change, eventually the window
monitor pointer would be pointing to freed memory.

Instead of force updating the monitor on all non-user operations, just
do it on hot plugs. This allows for the feedback loop preventing logic
to still do what its supposed to do, without risking dangling pointers
on hot plugs.

Related: https://gitlab.gnome.org/GNOME/mutter/issues/189
Closes: https://gitlab.gnome.org/GNOME/mutter/issues/192
2018-08-27 08:33:00 +00:00
f4d07caa38 window: Pass flag to meta_window_update_monitor() instead of bool
The bool determines whether the call was directly from a user operation
or not. To add more state into the call without having to add more
boolenas, change the boolean to a flag (so far with 'none' and 'user-op'
as possible values). No functional changes were made.

https://gitlab.gnome.org/GNOME/mutter/issues/192
2018-08-27 08:33:00 +00:00
8a6d502e68 Update Italian translation 2018-08-27 07:58:58 +00:00
b6c2eec487 Update Indonesian translation 2018-08-26 13:51:06 +00:00
093aa086af Update Korean translation 2018-08-26 03:59:00 +00:00
ebafc256a0 renderer/native: Check calculated transform when creating view
The "backends: Move MetaOutput::crtc field into private struct"
accidentally changed the view transform calculation code to assume that
"MetaCrtc::transform" corresponds to the transform of the CRTC; so is
not the case yet; one must calculate the transform from the logical
monitor, and check whether it is supported by the CRTC using
meta_monitor_manager_is_transform_handled(). This commit restores the
old behaviour that doesn't use MetaCrtc::transform when calculating the
view transform.

Fixes: https://gitlab.gnome.org/GNOME/mutter/issues/216
2018-08-24 11:51:36 +00:00
aaed7c9a4f clutter: Set can_show_preedit flag on ClutterText
It is certainly able to visualize preedit text inline, so it must
announce itself as such.
2018-08-23 20:03:51 +00:00
fa8930817e clutter: Refactor ClutterText IM focus in into separate function
A just focused ClutterInputFocus must set itself up correctly on
all situations. Refactor this into a function, so it can be used
for the case where a ClutterText gets editable while focused.
2018-08-23 20:03:51 +00:00
e741adb82e backends/x11: Only free cursor if it was created successfully
XcursorLibraryLoadCursor can return 'None' if the current cursor theme
is missing the requested icon. If XFreeCursor is then called on this
cursor, it generates a BadCursor error causing gnome-shell to crash.

Fixes https://gitlab.gnome.org/GNOME/mutter/issues/254
2018-08-21 16:39:41 +02:00
deb541ef5a monitor-manager-kms: Check if GPUs can have outputs
We need a way for mutter to exit if no available GPUs are going to work.
For example if gdm starts gnome-shell and we're using a DRM driver that
doesn't work with KMS then we should exit so that GDM can try with Xorg,
rather than operating in headless mode.

Related: https://gitlab.gnome.org/GNOME/mutter/issues/223
2018-08-21 13:16:22 +00:00
29cc526e2e gpu-kms: Handle drmModeGetResources() failing
Avoid dereferencing the NULL return value if it fails. We still create
the MetaGpu, but we treat it as if it has no outputs.

Closes: https://gitlab.gnome.org/GNOME/mutter/issues/223
2018-08-21 13:16:21 +00:00
6a92c6f83f wayland/actor-surface: Intersect input/opaque region with surface region
As per specification

> The compositor ignores the parts of the input region that
> fall outside of the surface.

> The compositor ignores the parts of the opaque region that
> fall outside of the surface

This fixes culling problems under certain conditions.
2018-08-21 12:24:02 +02:00
b8340f1355 clutter-text: Avoid clipping the wrong framebuffer
`ClutterText` painting for editable single_line_mode actors like `StEntry`
is always clipped by:

`cogl_framebuffer_push_rectangle_clip (fb, 0, 0, alloc_width, alloc_height)`

So it's difficult to get the rectangle wrong. However in cases where the
target framebuffer has changed (`cogl_push_framebuffer`) such as when
updating `ClutterOffscreenEffect` we had the wrong old value of `fb`. And
so would be clipping the wrong framebuffer, effectively not clipping at all.
2018-08-20 18:07:32 +00:00
c7db234c11 wayland/xdg-shell: Intersect set geometry with subsurface tree geometry
Currently xdg-shell applies a geometry set with set_window_geometry
unconditionally. But the specification requires:

> When applied, the effective window geometry will be
> the set window geometry clamped to the bounding rectangle of the
> combined geometry of the surface of the xdg_surface and the
> associated subsurfaces.

This is especially important to implement viewporter and
transformation.
2018-08-20 14:37:10 +00:00
db22c13c4f wayland: Use surface size helper functions
Use meta_wayland_surface_get_width / meta_wayland_surface_get_width
to determine the size of a surface.
2018-08-20 14:37:10 +00:00
ad864083f9 wayland/surface: Add get_width() and get_height() helper functions
With viewporter / transformations it get's more complicated to
figure out the dimensions of a surface. Bundle it in this helper-
functions.
2018-08-20 14:37:09 +00:00
5f99eeb926 Bump version to 3.29.91
Update NEWS.
2018-08-20 15:28:24 +02:00
e1513b6b00 clutter/x11: Detect auto-repeated key events
Detect auto-repeated key events using the XIKeyRepeat flag.
2018-08-20 10:16:33 +00:00
0cc3cd62ba keybindings: Ignore auto-repeat events for some keybindings
Detect auto-repeat events in process_event and ignore them if the
keybinding has the META_KEY_BINDING_IGNORE_AUTOREPEAT flag.

Fixes: gnome-shell#373
2018-08-20 10:16:33 +00:00
0f40541bb2 clutter/enum: Add CLUTTER_EVENT_FLAG_REPEATED for auto-repeated events 2018-08-20 10:16:33 +00:00
db604dda89 Update British English translation 2018-08-19 16:46:41 +00:00
21ce6f96f1 wayland/keyboard: Create a separate keymap shm file per resource
By using the shm file when sending the keymap to all clients, we
effectively allows any client to change the keymap, as any client has
the ability to change the content of the file. Sending a read-only file
descriptor, or making the file itself read-only before unlinking, can
be worked around by the client by using chmod(2) and open(2) on
/proc/<pid>/<fd>.

Using memfd could potentially solve this issue, but as the usage of
mmap with MAP_SHARED is wide spread among clients, such a change can
not be introduced without causing wide spread compatibility issues.

So, to avoid allowing clients to interfere with each other, create a
separate shm file for each wl_keyboard resource when sending the
keymap. We could eventually do this per client, but in most cases,
there will only be one wl_keyboard resource per client anyway.

https://bugzilla.gnome.org/show_bug.cgi?id=784206
2018-08-17 16:34:05 +02:00
323a806d35 wayland/keyboard: Indentation fix 2018-08-17 16:34:05 +02:00
84ac28cbee Update Friulian translation 2018-08-17 03:49:35 +00:00
2860adcf65 Update MSGID_BUGS_ADDRESS in po/Makevars 2018-08-16 20:23:26 +02:00
2dbacfa8d6 wayland/keyboard: Accept key down serial after key up for popups
If a client maps a popup in response to a key-down event, but the
mapping doesn't occur until after the user has already released the same
button, we'd immediately dismiss the popup. This is problematic, as one
often presses and releases a key quite quickly, meaning any popup mapped
on key-down are likely to be dismissed.

Avoid this race condition by accepting serials for key down events, if
the most recent key-up event had the same keycode.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/180
2018-08-15 08:51:14 +00:00
85e5b160ee wayland: Implement text-input from wayland-protocols
This protocol supersedes the internal gtk_text_input protocol that
was in place. Functionally it is very similar, with just some more
verbosity in both ways (text_change_cause, .done event), and some
improvements wrt the pre-edit text styling.
2018-08-14 15:43:21 +00:00
9510fbcbac wayland: Make gtk-text-input "legacy"
It is superseded by zwp_text_input_v3.
2018-08-14 15:43:21 +00:00
7c06e21e5a idle-monitor: Store either 1 or 0 in the inhibited gboolean
Wrap the flag checking in !!(..) to make sure we always either store
TRUE or FALSE in the gboolean.
2018-08-14 15:14:05 +00:00
1bfa20929b backends/x11: Improve grab-device clock updates
meta_backend_x11_grab_device is performing X server clock comparison
using the MAX macro, which comes down to a simple greater-than.

Use XSERVER_TIME_IS_BEFORE, which is a better macro for X server
clock comparisons, as it accounts for 32-bit wrap-around.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/174
2018-08-13 21:00:33 +02:00
bafc43ca26 Update Turkish translation 2018-08-12 10:20:43 +00:00
d37528f693 Update Chinese (Taiwan) translation 2018-08-12 10:18:57 +00:00
37eeda0320 Revert "gpu-kms: Handle drmModeGetResources() failing"
This reverts commit acf70a3561
2018-08-10 16:31:03 +00:00
acf70a3561 gpu-kms: Handle drmModeGetResources() failing
Avoid dereferencing the NULL return value if it fails. We still create
the MetaGpu, but we treat it as if it has no outputs.

Closes: https://gitlab.gnome.org/GNOME/mutter/issues/223
2018-08-10 16:35:17 +01:00
24aef44baf virtual-input/evdev: Translate from button internal codes to evdev
Sending button events to a ClutterVirtualInputDevice, the API expects
button codes to be of the internal clutter type. The evdev
implementation incorrectly assumed it was already prepared evdev event
codes, which was not the case. Fix the evdev implementation to translate
from the internal representation to evdev before passing it along to
ClutterSeatEvdev.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/190
2018-08-09 13:04:07 +00:00
f7af32a3ea renderer/native: Fallback to non-planar API if gbm_bo_get_handle_for_plane fails
Commit c0d9b08ef9 replaced the old GBM API calls
with the multi-plane GBM API. However, the call to gbm_bo_get_handle_for_plane
fails for some DRI drivers (in particular i915). Due to missing error checks,
the subsequent call to drmModeAddFB[2] fails and the screen output locks up.

This commit adds the missing error checks and falls back to the old GBM API
(non-planar) if necessary.

v5: test success of gbm_bo_get_handle_for_plane instead of errno

This commit adopts solution proposed by Daniel van Vugt to check the return
value of gbm_bo_get_handle_for_plane on plane 0 and fall back to old
non-planar method if the call fails. This removes the errno check (for
ENOSYS) that could abort if mesa ever sets a different value.

Related to: https://gitlab.gnome.org/GNOME/mutter/issues/127
2018-08-09 12:36:34 +00:00
913 changed files with 12553 additions and 37258 deletions

3
.gitignore vendored
View File

@ -94,6 +94,8 @@ src/xwayland-keyboard-grab-unstable-v1-protocol.c
src/xwayland-keyboard-grab-unstable-v1-server-protocol.h
src/tablet-unstable-v*-protocol.c
src/tablet-unstable-v*-server-protocol.h
src/text-input-unstable-v*-protocol.c
src/text-input-unstable-v*-server-protocol.h
src/keyboard-shortcuts-inhibit-unstable-v*-protocol.c
src/keyboard-shortcuts-inhibit-unstable-v*-server-protocol.h
src/linux-dmabuf-unstable-v*-protocol.c
@ -129,3 +131,4 @@ ltversion.m4
lt~obsolete.m4
.dirstamp
**/tags.*
build/

24
.gitlab-ci.yml Normal file
View File

@ -0,0 +1,24 @@
image: registry.gitlab.gnome.org/gnome/mutter/master:v1
stages:
- build
- test
build-mutter:
stage: build
script:
- meson . build -Degl_device=true -Dwayland_eglstream=true
- ninja -C build
- ninja -C build install
test-mutter:
stage: test
script:
- meson . build -Degl_device=true -Dwayland_eglstream=true
- ninja -C build
- glib-compile-schemas $PWD/build/data
- env XDG_RUNTIME_DIR=/tmp/ GSETTINGS_SCHEMA_DIR=$PWD/build/data dbus-run-session -- xvfb-run -s '+iglx -noreset' meson test -C build --verbose --no-stdsplit
artifacts:
paths:
- build/meson-logs
when: on_failure

14
.gitlab-ci/Dockerfile Normal file
View File

@ -0,0 +1,14 @@
FROM fedora:29
RUN dnf -y update && dnf -y upgrade && \
dnf install -y 'dnf-command(builddep)' && \
dnf builddep -y mutter && \
# Until Fedora catches up with meson build-deps
dnf install -y meson xorg-x11-server-Xorg gnome-settings-daemon-devel egl-wayland-devel xorg-x11-server-Xwayland && \
# For running unit tests
dnf install -y xorg-x11-server-Xvfb mesa-dri-drivers dbus dbus-x11 && \
dnf install -y intltool redhat-rpm-config make && \
dnf clean all

View File

@ -1,3 +1,5 @@
pkgdatadir = $(datadir)/mutter-$(LIBMUTTER_API_VERSION)
pkglibdir = $(libdir)/mutter-$(LIBMUTTER_API_VERSION)
SUBDIRS = cogl clutter data src po doc

77
NEWS
View File

@ -1,3 +1,80 @@
3.31.2
======
* Fix handling of non-UTF8 encodings [Florian; !227]
* Fix memory leaks introduced in 3.30.1 [Jonas; #653]
* Fix regression when overriding workspace layout [Ron; #270]
* Fix crash when restarting window manager [Andrea; gnome-shell#595]
* Add meson build support [Jonas; !167]
* Freeze clock when headless [Jonas; !170]
* Fix crash on monitor hotplug [Olivier; #189]
* Misc. bug fixes [Jonas; #353, !132, #382]
Contributors:
Jonas Ådahl, Andrea Azzarone, Olivier Fourdan, Niels De Graef,
Alexander Mikhaylenko, Florian Müllner, Akira Nakajima,
Georges Basile Stavracas Neto, Pekka Paalanen, Peter Uithoven,
Daniel van Vugt, Ron Yorston
3.30.1
======
* Improve trackball detection [Tony; #258]
* Fix clipping of scaled surfaces [Jonas; #300]
* Improve tracking of monitor switch configuration [Daniel; !213]
* Fix parent-relative positioning of constrained windows [Jonas; #332]
* Add clutter_input_method_forward_key() method [Carlos; gnome-shell#531]
* Various crash fixes [Olivier, Jonas; #194, #336]
* Misc. bug fixes [Carlos, Florian, Olivier, Jonas; gnome-shell#540, #294,
#221, !229, #30, #331]
Contributors:
Jonas Ådahl, Daniel Drake, Olivier Fourdan, Carlos Garnacho, Peter Hutterer,
Ting-Wei Lan, Florian Müllner, Tony Novak, Pekka Paalanen, Sam Spilsbury
Translators:
Yuras Shumovich [be], Марко Костић [sr], Marek Cernocky [cs]
3.30.0
======
Translators:
Fran Dieguez [gl], Balázs Meskó [hu], Rūdolfs Mazurs [lv],
Trần Ngọc Quân [vi], Ask Hjorth Larsen [da], gogo [hr]
3.29.92
=======
* Avoid crash when a cursor is not found [Sebastian; #254]
* Fix screen rotation regression [Jonas; #216]
* Handle requests to unmanaged windows gracefully [Jonas; #240]
* Move popups together with their parent [Jonas; #274]
* Fix non-lowercase letters on virtual key devices [Carlos; gnome-shell#135]
* Misc. bug fixes [Iain, Jonas; #223, #192, #279]
Contributors:
Jonas Ådahl, Carlos Garnacho, Sebastian Keller, Iain Lane, Robert Mader,
Daniel van Vugt
Translators:
Gwan-gyeong Mun [ko], Kukuh Syafaat [id], Milo Casagrande [it],
Anders Jonsson [sv], Rafael Fontenelle [pt_BR], Marek Cernocky [cs]
3.29.91
=======
* Various crash fixes [Olivier, Iain; #255, #223]
* Fix lock up with some DRI drivers [Alex; #127]
* Send correct button codes from virtual evdev devices [Jonas; !190]
* Improve grab-device clock updates on X11 [Jeff; !174]
* Fix popups closing immediately on key down [Jonas; !180]
* Prevent clients from modifying the shared keymap [Jonas; #784206]
Contributors:
Jonas Ådahl, Andrea Azzarone, Piotr Drąg, Olivier Fourdan, Carlos Garnacho,
Jan Grulich, Iain Lane, Alex Villacís Lasso, Jeff Smith, Daniel van Vugt
Translators:
Matej Urbančič [sl], Mario Blättermann [de], Piotr Drąg [pl],
Aurimas Černius [lt], Yi-Jyun Pan [zh_TW], Emin Tufan Çetin [tr],
Fabio Tomat [fur], Bruce Cowan [en_GB]
3.29.90
=======
* Various crash fixes [Olivier, Jonas, Florian; #189, #70, #194, #15, #130]

View File

@ -17,9 +17,10 @@ Internally it uses a fork of Cogl, a hardware acceleration abstraction library
used to simplify usage of OpenGL pipelines, as well as a fork af Clutter, a
scene graph and user interface toolkit.
Mutter is used by GNOME Shell, the GNOME core user interface. It can also be run
standalone, using the command "mutter", but just running plain mutter is only
intended for debugging purposes.
Mutter is used by, for example, GNOME Shell, the GNOME core user interface, and
by Gala, elementary OS's window manager. It can also be run standalone, using
the command "mutter", but just running plain mutter is only intended for
debugging purposes.
## License

1
clutter/.gitignore vendored
View File

@ -23,7 +23,6 @@ clutter-build-config.h.in
clutter-config.h
clutter-enum-types.[ch]
clutter-marshal.[ch]
clutter-version.h
gcov-report.txt
clutter-json.h
clutter-lcov.info

View File

@ -2,11 +2,7 @@ NULL =
SUBDIRS = build clutter tests
if BUILD_EXAMPLES
SUBDIRS += examples
endif
DIST_SUBDIRS = clutter tests examples build
DIST_SUBDIRS = clutter tests build
# XXX - this is a massive hack to make autoreconf honour the ACLOCAL_FLAGS
# that jhbuild sets while still retaining build/autotools as the authoritative

View File

@ -10,17 +10,13 @@ EXTRA_DIST =
BUILT_SOURCES =
AM_CPPFLAGS = \
-DCLUTTER_PREFIX=\""$(prefix)"\" \
-DCLUTTER_LIBDIR=\""$(libdir)"\" \
-DCLUTTER_DATADIR=\""$(datadir)"\" \
-DCLUTTER_LOCALEDIR=\""$(localedir)"\" \
-DCLUTTER_SYSCONFDIR=\""$(sysconfdir)"\" \
-DCLUTTER_COMPILATION=1 \
-DCOGL_DISABLE_DEPRECATION_WARNINGS \
-DG_LOG_DOMAIN=\"Clutter\" \
-fvisibility=hidden \
-I$(top_srcdir) \
-I$(top_srcdir)/clutter \
-I$(top_srcdir)/clutter/cally \
-I$(top_builddir) \
-I$(top_builddir)/clutter \
-I$(top_srcdir)/../cogl \
@ -28,7 +24,6 @@ AM_CPPFLAGS = \
-I$(top_builddir)/../cogl/cogl \
$(CLUTTER_DEPRECATED_CFLAGS) \
$(CLUTTER_DEBUG_CFLAGS) \
$(CLUTTER_HIDDEN_VISIBILITY_CFLAGS) \
$(NULL)
AM_CFLAGS = $(CLUTTER_CFLAGS) $(MAINTAINER_CFLAGS)
@ -37,7 +32,7 @@ AM_CFLAGS = $(CLUTTER_CFLAGS) $(MAINTAINER_CFLAGS)
INTROSPECTION_GIRS =
# the base include path for headers
clutter_base_includedir = $(includedir)/mutter/clutter-$(LIBMUTTER_API_VERSION)
clutter_base_includedir = $(includedir)/mutter-$(LIBMUTTER_API_VERSION)/clutter
clutter_includedir = $(clutter_base_includedir)/clutter
clutter_deprecateddir = $(clutter_base_includedir)/clutter/deprecated
@ -83,7 +78,6 @@ source_h = \
clutter-flow-layout.h \
clutter-gesture-action.h \
clutter-grid-layout.h \
clutter-group.h \
clutter-image.h \
clutter-input-device.h \
clutter-input-device-tool.h \
@ -263,7 +257,6 @@ deprecated_h = \
deprecated/clutter-alpha.h \
deprecated/clutter-animatable.h \
deprecated/clutter-animation.h \
deprecated/clutter-animator.h \
deprecated/clutter-backend.h \
deprecated/clutter-behaviour.h \
deprecated/clutter-behaviour-depth.h \
@ -273,27 +266,16 @@ deprecated_h = \
deprecated/clutter-behaviour-rotate.h \
deprecated/clutter-behaviour-scale.h \
deprecated/clutter-bin-layout.h \
deprecated/clutter-box.h \
deprecated/clutter-cairo-texture.h \
deprecated/clutter-container.h \
deprecated/clutter-frame-source.h \
deprecated/clutter-group.h \
deprecated/clutter-input-device.h \
deprecated/clutter-keysyms.h \
deprecated/clutter-list-model.h \
deprecated/clutter-main.h \
deprecated/clutter-media.h \
deprecated/clutter-model.h \
deprecated/clutter-rectangle.h \
deprecated/clutter-score.h \
deprecated/clutter-shader.h \
deprecated/clutter-stage-manager.h \
deprecated/clutter-stage.h \
deprecated/clutter-state.h \
deprecated/clutter-table-layout.h \
deprecated/clutter-texture.h \
deprecated/clutter-timeline.h \
deprecated/clutter-timeout-pool.h \
deprecated/clutter-util.h \
$(NULL)
@ -302,7 +284,6 @@ deprecated_c = \
deprecated/clutter-actor-deprecated.c \
deprecated/clutter-alpha.c \
deprecated/clutter-animation.c \
deprecated/clutter-animator.c \
deprecated/clutter-behaviour.c \
deprecated/clutter-behaviour-depth.c \
deprecated/clutter-behaviour-ellipse.c \
@ -310,33 +291,11 @@ deprecated_c = \
deprecated/clutter-behaviour-path.c \
deprecated/clutter-behaviour-rotate.c \
deprecated/clutter-behaviour-scale.c \
deprecated/clutter-box.c \
deprecated/clutter-cairo-texture.c \
deprecated/clutter-frame-source.c \
deprecated/clutter-group.c \
deprecated/clutter-input-device-deprecated.c \
deprecated/clutter-layout-manager-deprecated.c \
deprecated/clutter-list-model.c \
deprecated/clutter-media.c \
deprecated/clutter-model.c \
deprecated/clutter-rectangle.c \
deprecated/clutter-score.c \
deprecated/clutter-shader.c \
deprecated/clutter-state.c \
deprecated/clutter-table-layout.c \
deprecated/clutter-texture.c \
deprecated/clutter-timeout-pool.c \
$(NULL)
# deprecated private headers; these should not be installed
deprecated_h_priv = \
deprecated/clutter-model-private.h \
deprecated/clutter-timeout-interval.h \
$(NULL)
# deprecated private source code; these should not be introspected
deprecated_c_priv = \
deprecated/clutter-timeout-interval.c \
$(NULL)
# built sources
@ -355,10 +314,6 @@ built_source_h = \
DISTCLEANFILES += clutter-config.h
EXTRA_DIST += clutter-config.h.in
# version header
DISTCLEANFILES += clutter-version.h
EXTRA_DIST += clutter-version.h.in clutter-version.h
# key symbol update script
EXTRA_DIST += clutter-keysyms-update.pl
@ -498,9 +453,6 @@ backend_source_c_priv += $(evdev_c_priv)
backend_source_h_priv += $(evdev_h_priv)
backend_source_h += $(evdev_h)
clutterevdev_includedir = $(clutter_includedir)/evdev
clutterevdev_include_HEADERS = $(evdev_h)
backend_source_c += evdev/clutter-xkb-utils.c
backend_source_h_priv += evdev/clutter-xkb-utils.h
@ -520,15 +472,10 @@ backend_source_h += $(wayland_compositor_source_h)
backend_source_c += \
wayland/clutter-wayland-surface.c
wayland_compositor_includedir = $(clutter_includedir)/wayland
wayland_compositor_include_HEADERS = $(wayland_compositor_source_h)
backend_source_h += $(egl_source_h)
backend_source_c += $(egl_source_c)
backend_source_h_priv += $(egl_source_h_priv)
clutteregl_includedir = $(clutter_includedir)/egl
clutteregl_include_HEADERS = $(egl_source_h)
endif # SUPPORT_WAYLAND
# cally
@ -585,12 +532,12 @@ pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = $(pc_files)
DISTCLEANFILES += $(pc_files)
clutter_include_HEADERS = $(source_h) clutter.h clutter-version.h clutter-autocleanups.h clutter-mutter.h
clutter_include_HEADERS = $(source_h) clutter.h clutter-autocleanups.h clutter-mutter.h
nodist_clutter_include_HEADERS = clutter-config.h $(built_source_h)
clutter_deprecated_HEADERS = $(deprecated_h)
mutterlibdir = $(libdir)/mutter
mutterlibdir = $(libdir)/mutter-@LIBMUTTER_API_VERSION@
mutterlib_LTLIBRARIES = libmutter-clutter-@LIBMUTTER_API_VERSION@.la
libmutter_clutter_@LIBMUTTER_API_VERSION@_la_LIBADD = \
@ -612,8 +559,6 @@ libmutter_clutter_@LIBMUTTER_API_VERSION@_la_SOURCES = \
$(source_h_priv) \
$(deprecated_c) \
$(deprecated_h) \
$(deprecated_c_priv) \
$(deprecated_h_priv) \
$(cally_sources_c) \
$(cally_sources_h) \
$(cally_sources_private) \

View File

@ -67,9 +67,7 @@
*
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include <glib.h>
#include <clutter/clutter.h>

View File

@ -126,19 +126,19 @@ struct _CallyActorClass
gpointer _padding_dummy[32];
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType cally_actor_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
AtkObject* cally_actor_new (ClutterActor *actor);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
guint cally_actor_add_action (CallyActor *cally_actor,
const gchar *action_name,
const gchar *action_description,
const gchar *action_keybinding,
CallyActionFunc action_func);
CLUTTER_AVAILABLE_IN_1_6
CLUTTER_EXPORT
guint cally_actor_add_action_full (CallyActor *cally_actor,
const gchar *action_name,
const gchar *action_description,
@ -147,11 +147,11 @@ guint cally_actor_add_action_full (CallyActor *cally_actor,
gpointer user_data,
GDestroyNotify notify);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
gboolean cally_actor_remove_action (CallyActor *cally_actor,
gint action_id);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
gboolean cally_actor_remove_action_by_name (CallyActor *cally_actor,
const gchar *action_name);

View File

@ -74,9 +74,9 @@ struct _CallyCloneClass
gpointer _padding_dummy[8];
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType cally_clone_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
AtkObject *cally_clone_new (ClutterActor *actor);
G_END_DECLS

View File

@ -1,147 +0,0 @@
/* CALLY - The Clutter Accessibility Implementation Library
*
* Copyright (C) 2008 Igalia, S.L.
*
* Author: Alejandro Piñeiro Iglesias <apinheiro@igalia.com>
*
* Based on GailContainer from GAIL
* Copyright 2001, 2002, 2003 Sun Microsystems Inc.
*
* 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.
*/
/**
* SECTION:cally-group
* @Title: CallyGroup
* @short_description: Implementation of the ATK interfaces for a #ClutterGroup
* @see_also: #ClutterGroup
*
* #CallyGroup implements the required ATK interfaces of #ClutterGroup
* In particular it exposes each of the Clutter actors contained in the
* group.
*/
#include "clutter-build-config.h"
#include "cally-group.h"
#include "cally-actor-private.h"
static gint cally_group_get_n_children (AtkObject *obj);
static AtkObject* cally_group_ref_child (AtkObject *obj,
gint i);
static void cally_group_real_initialize (AtkObject *obj,
gpointer data);
G_DEFINE_TYPE (CallyGroup, cally_group, CALLY_TYPE_ACTOR)
static void
cally_group_class_init (CallyGroupClass *klass)
{
/* GObjectClass *gobject_class = G_OBJECT_CLASS (klass); */
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
class->get_n_children = cally_group_get_n_children;
class->ref_child = cally_group_ref_child;
class->initialize = cally_group_real_initialize;
}
static void
cally_group_init (CallyGroup *group)
{
/* nothing to do yet */
}
/**
* cally_group_new:
* @actor: a #ClutterGroup
*
* Creates a #CallyGroup for @actor
*
* Return value: the newly created #CallyGroup
*
* Since: 1.4
*/
AtkObject *
cally_group_new (ClutterActor *actor)
{
GObject *object = NULL;
AtkObject *accessible = NULL;
g_return_val_if_fail (CLUTTER_IS_GROUP (actor), NULL);
object = g_object_new (CALLY_TYPE_GROUP, NULL);
accessible = ATK_OBJECT (object);
atk_object_initialize (accessible, actor);
return accessible;
}
static gint
cally_group_get_n_children (AtkObject *obj)
{
ClutterActor *actor = NULL;
gint count = 0;
g_return_val_if_fail (CALLY_IS_GROUP (obj), count);
actor = CALLY_GET_CLUTTER_ACTOR (obj);
if (actor == NULL) /* defunct */
return 0;
g_return_val_if_fail (CLUTTER_IS_GROUP(actor), count);
count = clutter_actor_get_n_children (actor);
return count;
}
static AtkObject*
cally_group_ref_child (AtkObject *obj,
gint i)
{
AtkObject *accessible = NULL;
ClutterActor *actor = NULL;
ClutterActor *child = NULL;
g_return_val_if_fail (CALLY_IS_GROUP (obj), NULL);
g_return_val_if_fail ((i >= 0), NULL);
actor = CALLY_GET_CLUTTER_ACTOR (obj);
g_return_val_if_fail (CLUTTER_IS_GROUP(actor), NULL);
child = clutter_actor_get_child_at_index (actor, i);
if (!child)
return NULL;
accessible = clutter_actor_get_accessible (child);
if (accessible != NULL)
g_object_ref (accessible);
return accessible;
}
static void
cally_group_real_initialize (AtkObject *obj,
gpointer data)
{
ATK_OBJECT_CLASS (cally_group_parent_class)->initialize (obj, data);
obj->role = ATK_ROLE_PANEL;
}

View File

@ -1,87 +0,0 @@
/* CALLY - The Clutter Accessibility Implementation Library
*
* Copyright (C) 2008 Igalia, S.L.
*
* Author: Alejandro Piñeiro Iglesias <apinheiro@igalia.com>
*
* Based on GailContainer from GAIL
* Copyright 2001, 2002, 2003 Sun Microsystems Inc.
*
* 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/>.
*/
#ifndef __CALLY_GROUP_H__
#define __CALLY_GROUP_H__
#if !defined(__CALLY_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only <cally/cally.h> can be included directly."
#endif
#include <cally/cally-actor.h>
#include <clutter/clutter.h>
G_BEGIN_DECLS
#define CALLY_TYPE_GROUP (cally_group_get_type ())
#define CALLY_GROUP(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CALLY_TYPE_GROUP, CallyGroup))
#define CALLY_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CALLY_TYPE_GROUP, CallyGroupClass))
#define CALLY_IS_GROUP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CALLY_TYPE_GROUP))
#define CALLY_IS_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CALLY_TYPE_GROUP))
#define CALLY_GROUP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CALLY_TYPE_GROUP, CallyGroupClass))
typedef struct _CallyGroup CallyGroup;
typedef struct _CallyGroupClass CallyGroupClass;
typedef struct _CallyGroupPrivate CallyGroupPrivate;
/**
* CallyGroup:
*
* The <structname>CallyGroup</structname> structure contains only
* private data and should be accessed using the provided API
*
* Since: 1.4
*/
struct _CallyGroup
{
/*< private >*/
CallyActor parent;
CallyGroupPrivate *priv;
};
/**
* CallyGroupClass:
*
* The <structname>CallyGroupClass</structname> structure contains only
* private data
*
* Since: 1.4
*/
struct _CallyGroupClass
{
/*< private >*/
CallyActorClass parent_class;
/* padding for future expansion */
gpointer _padding_dummy[8];
};
CLUTTER_AVAILABLE_IN_1_4
GType cally_group_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
AtkObject* cally_group_new (ClutterActor *actor);
G_END_DECLS
#endif /* __CALLY_GROUP_H__ */

View File

@ -34,9 +34,9 @@
G_BEGIN_DECLS
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
gboolean cally_get_cally_initialized (void);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
gboolean cally_accessibility_init (void);
G_END_DECLS

View File

@ -74,9 +74,9 @@ struct _CallyRectangleClass
gpointer _padding_dummy[8];
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType cally_rectangle_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
AtkObject* cally_rectangle_new (ClutterActor *actor);
G_END_DECLS

View File

@ -74,9 +74,9 @@ struct _CallyRootClass
gpointer _padding_dummy[16];
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType cally_root_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
AtkObject *cally_root_new (void);
G_END_DECLS

View File

@ -63,7 +63,7 @@ struct _CallyStagePrivate
G_DEFINE_TYPE_WITH_CODE (CallyStage,
cally_stage,
CALLY_TYPE_GROUP,
CALLY_TYPE_ACTOR,
G_ADD_PRIVATE (CallyStage)
G_IMPLEMENT_INTERFACE (ATK_TYPE_WINDOW,
cally_stage_window_interface_init));

View File

@ -25,7 +25,7 @@
#error "Only <cally/cally.h> can be included directly."
#endif
#include <cally/cally-group.h>
#include <cally/cally-actor.h>
#include <clutter/clutter.h>
G_BEGIN_DECLS
@ -52,7 +52,7 @@ typedef struct _CallyStagePrivate CallyStagePrivate;
struct _CallyStage
{
/*< private >*/
CallyGroup parent;
CallyActor parent;
CallyStagePrivate *priv;
};
@ -68,15 +68,15 @@ struct _CallyStage
struct _CallyStageClass
{
/*< private >*/
CallyGroupClass parent_class;
CallyActorClass parent_class;
/* padding for future expansion */
gpointer _padding_dummy[16];
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType cally_stage_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
AtkObject *cally_stage_new (ClutterActor *actor);
G_END_DECLS

View File

@ -39,9 +39,7 @@
*
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "cally-text.h"
#include "cally-actor-private.h"

View File

@ -74,9 +74,9 @@ struct _CallyTextClass
gpointer _padding_dummy[8];
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType cally_text_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
AtkObject* cally_text_new (ClutterActor *actor);
G_END_DECLS

View File

@ -74,9 +74,9 @@ struct _CallyTextureClass
gpointer _padding_dummy[8];
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType cally_texture_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
AtkObject *cally_texture_new (ClutterActor *actor);
G_END_DECLS

View File

@ -38,9 +38,7 @@
* available any accessible object.
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include <stdlib.h>
#include <string.h>
@ -144,7 +142,7 @@ cally_util_get_toolkit_name (void)
static const gchar *
cally_util_get_toolkit_version (void)
{
return CLUTTER_VERSION_S;
return MUTTER_VERSION;
}
static guint

View File

@ -74,7 +74,7 @@ struct _CallyUtilClass
gpointer _padding_dummy[8];
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType cally_util_get_type (void) G_GNUC_CONST;
void _cally_util_override_atk_util (void);

View File

@ -29,16 +29,13 @@
*
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
#include "cally.h"
#include "cally-actor.h"
#include "cally-group.h"
#include "cally-stage.h"
#include "cally-text.h"
#include "cally-texture.h"
@ -55,7 +52,6 @@
/* factories initialization*/
CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_ACTOR, cally_actor, cally_actor_new)
CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_GROUP, cally_group, cally_group_new)
CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_STAGE, cally_stage, cally_stage_new)
CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_TEXT, cally_text, cally_text_new)
CALLY_ACCESSIBLE_FACTORY (CALLY_TYPE_TEXTURE, cally_texture, cally_texture_new)
@ -77,7 +73,6 @@ cally_accessibility_init (void)
{
/* setting the factories */
CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_ACTOR, cally_actor);
CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_GROUP, cally_group);
CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_STAGE, cally_stage);
CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_TEXT, cally_text);
CALLY_ACTOR_SET_FACTORY (CLUTTER_TYPE_TEXTURE, cally_texture);

View File

@ -26,7 +26,6 @@
#include "cally-actor.h"
#include "cally-clone.h"
#include "cally-factory.h"
#include "cally-group.h"
#include "cally-main.h"
#include "cally-rectangle.h"
#include "cally-root.h"

View File

@ -41,9 +41,7 @@
* #ClutterAction is available since Clutter 1.4
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-action.h"

View File

@ -78,32 +78,32 @@ struct _ClutterActionClass
void (* _clutter_action8) (void);
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType clutter_action_get_type (void) G_GNUC_CONST;
/* ClutterActor API */
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_add_action (ClutterActor *self,
ClutterAction *action);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_add_action_with_name (ClutterActor *self,
const gchar *name,
ClutterAction *action);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_remove_action (ClutterActor *self,
ClutterAction *action);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_remove_action_by_name (ClutterActor *self,
const gchar *name);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterAction *clutter_actor_get_action (ClutterActor *self,
const gchar *name);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GList * clutter_actor_get_actions (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_clear_actions (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
gboolean clutter_actor_has_actions (ClutterActor *self);
G_END_DECLS

View File

@ -1,6 +1,4 @@
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include <math.h>

View File

@ -41,9 +41,7 @@
* #ClutterActorMeta is available since Clutter 1.4
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-actor-meta-private.h"

View File

@ -97,21 +97,21 @@ struct _ClutterActorMetaClass
void (* _clutter_meta7) (void);
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType clutter_actor_meta_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_meta_set_name (ClutterActorMeta *meta,
const gchar *name);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
const gchar * clutter_actor_meta_get_name (ClutterActorMeta *meta);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_meta_set_enabled (ClutterActorMeta *meta,
gboolean is_enabled);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
gboolean clutter_actor_meta_get_enabled (ClutterActorMeta *meta);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterActor * clutter_actor_meta_get_actor (ClutterActorMeta *meta);
G_END_DECLS

View File

@ -841,6 +841,7 @@ struct _ClutterActorPrivate
guint needs_x_expand : 1;
guint needs_y_expand : 1;
guint needs_paint_volume_update : 1;
guint had_effects_on_last_paint_volume_update : 1;
};
enum
@ -1107,7 +1108,6 @@ static void clutter_actor_pop_in_cloned_branch (ClutterActor *self,
{ _transform; } \
cogl_matrix_translate ((m), -_tx, -_ty, -_tz); } G_STMT_END
static GQuark quark_shader_data = 0;
static GQuark quark_actor_layout_info = 0;
static GQuark quark_actor_transform_info = 0;
static GQuark quark_actor_animation_info = 0;
@ -3521,12 +3521,6 @@ _clutter_actor_update_last_paint_volume (ClutterActor *self)
priv->last_paint_volume_valid = TRUE;
}
static inline gboolean
actor_has_shader_data (ClutterActor *self)
{
return g_object_get_qdata (G_OBJECT (self), quark_shader_data) != NULL;
}
guint32
_clutter_actor_get_pick_id (ClutterActor *self)
{
@ -3768,7 +3762,6 @@ clutter_actor_paint (ClutterActor *self)
ClutterActorPrivate *priv;
ClutterPickMode pick_mode;
gboolean clip_set = FALSE;
gboolean shader_applied = FALSE;
ClutterStage *stage;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
@ -3939,13 +3932,6 @@ clutter_actor_paint (ClutterActor *self)
if (priv->effects == NULL)
{
if (pick_mode == CLUTTER_PICK_NONE &&
actor_has_shader_data (self))
{
_clutter_actor_shader_pre_paint (self, FALSE);
shader_applied = TRUE;
}
priv->next_effect_to_paint = NULL;
}
else
@ -3954,9 +3940,6 @@ clutter_actor_paint (ClutterActor *self)
clutter_actor_continue_paint (self);
if (shader_applied)
_clutter_actor_shader_post_paint (self);
if (G_UNLIKELY (clutter_paint_debug_flags & CLUTTER_DEBUG_PAINT_VOLUMES &&
pick_mode == CLUTTER_PICK_NONE))
_clutter_actor_draw_paint_volume (self);
@ -6296,7 +6279,6 @@ clutter_actor_class_init (ClutterActorClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
quark_shader_data = g_quark_from_static_string ("-clutter-actor-shader-data");
quark_actor_layout_info = g_quark_from_static_string ("-clutter-actor-layout-info");
quark_actor_transform_info = g_quark_from_static_string ("-clutter-actor-transform-info");
quark_actor_animation_info = g_quark_from_static_string ("-clutter-actor-animation-info");
@ -9023,7 +9005,7 @@ _clutter_actor_queue_only_relayout (ClutterActor *self)
priv->needs_allocation)
return; /* save some cpu cycles */
#if CLUTTER_ENABLE_DEBUG
#ifdef CLUTTER_ENABLE_DEBUG
if (!CLUTTER_ACTOR_IS_TOPLEVEL (self) && CLUTTER_ACTOR_IN_RELAYOUT (self))
{
g_warning ("The actor '%s' is currently inside an allocation "
@ -17485,7 +17467,7 @@ _clutter_actor_get_paint_volume_real (ClutterActor *self,
*/
effects = _clutter_meta_group_peek_metas (priv->effects);
for (l = effects;
l != NULL || (l != NULL && l->data != priv->current_effect);
l != NULL && l->data != priv->current_effect;
l = l->next)
{
if (!_clutter_effect_get_paint_volume (l->data, pv))
@ -17521,6 +17503,32 @@ _clutter_actor_get_paint_volume_real (ClutterActor *self,
return TRUE;
}
static gboolean
_clutter_actor_has_active_paint_volume_override_effects (ClutterActor *self)
{
const GList *l;
if (self->priv->effects == NULL)
return FALSE;
/* We just need to all effects current effect to see
* if anyone wants to override the paint volume. If so, then
* we need to recompute, since the paint volume returned can
* change from call to call. */
for (l = _clutter_meta_group_peek_metas (self->priv->effects);
l != NULL;
l = l->next)
{
ClutterEffect *effect = l->data;
if (clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect)) &&
_clutter_effect_has_custom_paint_volume (effect))
return TRUE;
}
return FALSE;
}
/* The public clutter_actor_get_paint_volume API returns a const
* pointer since we return a pointer directly to the cached
* PaintVolume associated with the actor and don't want the user to
@ -17531,17 +17539,33 @@ _clutter_actor_get_paint_volume_real (ClutterActor *self,
static ClutterPaintVolume *
_clutter_actor_get_paint_volume_mutable (ClutterActor *self)
{
gboolean has_paint_volume_override_effects;
ClutterActorPrivate *priv;
priv = self->priv;
has_paint_volume_override_effects = _clutter_actor_has_active_paint_volume_override_effects (self);
if (priv->paint_volume_valid)
{
if (!priv->needs_paint_volume_update)
/* If effects are applied, the actor paint volume
* needs to be recomputed on each paint, since those
* paint volumes could change over the duration of the
* effect.
*
* We also need to update the paint volume if we went
* from having effects to not having effects on the last
* paint volume update. */
if (!priv->needs_paint_volume_update &&
priv->current_effect == NULL &&
!has_paint_volume_override_effects &&
!priv->had_effects_on_last_paint_volume_update)
return &priv->paint_volume;
clutter_paint_volume_free (&priv->paint_volume);
}
priv->had_effects_on_last_paint_volume_update = has_paint_volume_override_effects;
if (_clutter_actor_get_paint_volume_real (self, &priv->paint_volume))
{
priv->paint_volume_valid = TRUE;
@ -21113,6 +21137,7 @@ clutter_actor_bind_model_with_properties (ClutterActor *self,
model_property = va_arg (args, char *);
}
va_end (args);
clutter_actor_bind_model (self, model, bind_child_with_properties, clos, bind_closure_free);
}

View File

@ -61,7 +61,7 @@ G_BEGIN_DECLS
* internal state.
*/
#define CLUTTER_ACTOR_SET_FLAGS(a,f) \
CLUTTER_MACRO_DEPRECATED_IN_1_24 \
CLUTTER_MACRO_DEPRECATED \
(((ClutterActor*)(a))->flags |= (f))
/**
@ -76,23 +76,23 @@ G_BEGIN_DECLS
* internal state.
*/
#define CLUTTER_ACTOR_UNSET_FLAGS(a,f) \
CLUTTER_MACRO_DEPRECATED_IN_1_24 \
CLUTTER_MACRO_DEPRECATED \
(((ClutterActor*)(a))->flags &= ~(f))
#define CLUTTER_ACTOR_IS_MAPPED(a) \
CLUTTER_MACRO_DEPRECATED_IN_1_24_FOR ("Deprecated macro. Use clutter_actor_is_mapped instead") \
CLUTTER_MACRO_DEPRECATED_FOR ("Deprecated macro. Use clutter_actor_is_mapped instead") \
((((ClutterActor*)(a))->flags & CLUTTER_ACTOR_MAPPED) != FALSE)
#define CLUTTER_ACTOR_IS_REALIZED(a) \
CLUTTER_MACRO_DEPRECATED_IN_1_24_FOR ("Deprecated macro. Use clutter_actor_is_realized instead") \
CLUTTER_MACRO_DEPRECATED_FOR ("Deprecated macro. Use clutter_actor_is_realized instead") \
((((ClutterActor*)(a))->flags & CLUTTER_ACTOR_REALIZED) != FALSE)
#define CLUTTER_ACTOR_IS_VISIBLE(a) \
CLUTTER_MACRO_DEPRECATED_IN_1_24_FOR ("Deprecated macro. Use clutter_actor_is_visible instead") \
CLUTTER_MACRO_DEPRECATED_FOR ("Deprecated macro. Use clutter_actor_is_visible instead") \
((((ClutterActor*)(a))->flags & CLUTTER_ACTOR_VISIBLE) != FALSE)
#define CLUTTER_ACTOR_IS_REACTIVE(a) \
CLUTTER_MACRO_DEPRECATED_IN_1_24_FOR ("Deprecated macro. Use clutter_actor_get_reactive instead") \
CLUTTER_MACRO_DEPRECATED_FOR ("Deprecated macro. Use clutter_actor_get_reactive instead") \
((((ClutterActor*)(a))->flags & CLUTTER_ACTOR_REACTIVE) != FALSE)
typedef struct _ClutterActorClass ClutterActorClass;
@ -322,97 +322,97 @@ struct _ClutterActorIter
gpointer CLUTTER_PRIVATE_FIELD (dummy5);
};
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
GType clutter_actor_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterActor * clutter_actor_new (void);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_flags (ClutterActor *self,
ClutterActorFlags flags);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_unset_flags (ClutterActor *self,
ClutterActorFlags flags);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterActorFlags clutter_actor_get_flags (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_show (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_hide (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_realize (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_unrealize (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_map (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_unmap (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_paint (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_continue_paint (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_queue_redraw (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_queue_redraw_with_clip (ClutterActor *self,
const cairo_rectangle_int_t *clip);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_queue_relayout (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_destroy (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_name (ClutterActor *self,
const gchar *name);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
const gchar * clutter_actor_get_name (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
AtkObject * clutter_actor_get_accessible (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_24
CLUTTER_EXPORT
gboolean clutter_actor_is_visible (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_24
CLUTTER_EXPORT
gboolean clutter_actor_is_mapped (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_24
CLUTTER_EXPORT
gboolean clutter_actor_is_realized (ClutterActor *self);
/* Size negotiation */
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_request_mode (ClutterActor *self,
ClutterRequestMode mode);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterRequestMode clutter_actor_get_request_mode (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_get_preferred_width (ClutterActor *self,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_get_preferred_height (ClutterActor *self,
gfloat for_width,
gfloat *min_height_p,
gfloat *natural_height_p);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_get_preferred_size (ClutterActor *self,
gfloat *min_width_p,
gfloat *min_height_p,
gfloat *natural_width_p,
gfloat *natural_height_p);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_allocate (ClutterActor *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_allocate_preferred_size (ClutterActor *self,
ClutterAllocationFlags flags);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_allocate_available_size (ClutterActor *self,
gfloat x,
gfloat y,
gfloat available_width,
gfloat available_height,
ClutterAllocationFlags flags);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_allocate_align_fill (ClutterActor *self,
const ClutterActorBox *box,
gdouble x_align,
@ -420,448 +420,448 @@ void clutter_actor_allocate_align_fill
gboolean x_fill,
gboolean y_fill,
ClutterAllocationFlags flags);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_allocation (ClutterActor *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_get_allocation_box (ClutterActor *self,
ClutterActorBox *box);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_get_allocation_vertices (ClutterActor *self,
ClutterActor *ancestor,
ClutterVertex verts[]);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_has_allocation (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_size (ClutterActor *self,
gfloat width,
gfloat height);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_get_size (ClutterActor *self,
gfloat *width,
gfloat *height);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_position (ClutterActor *self,
gfloat x,
gfloat y);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_get_position (ClutterActor *self,
gfloat *x,
gfloat *y);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_get_fixed_position_set (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_fixed_position_set (ClutterActor *self,
gboolean is_set);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_move_by (ClutterActor *self,
gfloat dx,
gfloat dy);
/* Actor geometry */
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gfloat clutter_actor_get_width (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gfloat clutter_actor_get_height (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_width (ClutterActor *self,
gfloat width);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_height (ClutterActor *self,
gfloat height);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gfloat clutter_actor_get_x (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gfloat clutter_actor_get_y (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_x (ClutterActor *self,
gfloat x);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_y (ClutterActor *self,
gfloat y);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_set_z_position (ClutterActor *self,
gfloat z_position);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
gfloat clutter_actor_get_z_position (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_layout_manager (ClutterActor *self,
ClutterLayoutManager *manager);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterLayoutManager * clutter_actor_get_layout_manager (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_x_align (ClutterActor *self,
ClutterActorAlign x_align);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterActorAlign clutter_actor_get_x_align (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_y_align (ClutterActor *self,
ClutterActorAlign y_align);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterActorAlign clutter_actor_get_y_align (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_margin_top (ClutterActor *self,
gfloat margin);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
gfloat clutter_actor_get_margin_top (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_margin_bottom (ClutterActor *self,
gfloat margin);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
gfloat clutter_actor_get_margin_bottom (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_margin_left (ClutterActor *self,
gfloat margin);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
gfloat clutter_actor_get_margin_left (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_margin_right (ClutterActor *self,
gfloat margin);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
gfloat clutter_actor_get_margin_right (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_margin (ClutterActor *self,
const ClutterMargin *margin);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_get_margin (ClutterActor *self,
ClutterMargin *margin);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_set_x_expand (ClutterActor *self,
gboolean expand);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
gboolean clutter_actor_get_x_expand (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_set_y_expand (ClutterActor *self,
gboolean expand);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
gboolean clutter_actor_get_y_expand (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
gboolean clutter_actor_needs_expand (ClutterActor *self,
ClutterOrientation orientation);
/* Paint */
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_clip (ClutterActor *self,
gfloat xoff,
gfloat yoff,
gfloat width,
gfloat height);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_remove_clip (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_has_clip (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_get_clip (ClutterActor *self,
gfloat *xoff,
gfloat *yoff,
gfloat *width,
gfloat *height);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_clip_to_allocation (ClutterActor *self,
gboolean clip_set);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_get_clip_to_allocation (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_opacity (ClutterActor *self,
guint8 opacity);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
guint8 clutter_actor_get_opacity (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
guint8 clutter_actor_get_paint_opacity (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_get_paint_visibility (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_actor_set_offscreen_redirect (ClutterActor *self,
ClutterOffscreenRedirect redirect);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
ClutterOffscreenRedirect clutter_actor_get_offscreen_redirect (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_should_pick_paint (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_is_in_clone_paint (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_get_paint_box (ClutterActor *self,
ClutterActorBox *box);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
gboolean clutter_actor_has_overlaps (ClutterActor *self);
/* Content */
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_content (ClutterActor *self,
ClutterContent *content);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterContent * clutter_actor_get_content (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_content_gravity (ClutterActor *self,
ClutterContentGravity gravity);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterContentGravity clutter_actor_get_content_gravity (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_content_scaling_filters (ClutterActor *self,
ClutterScalingFilter min_filter,
ClutterScalingFilter mag_filter);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_get_content_scaling_filters (ClutterActor *self,
ClutterScalingFilter *min_filter,
ClutterScalingFilter *mag_filter);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_set_content_repeat (ClutterActor *self,
ClutterContentRepeat repeat);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
ClutterContentRepeat clutter_actor_get_content_repeat (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_get_content_box (ClutterActor *self,
ClutterActorBox *box);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_background_color (ClutterActor *self,
const ClutterColor *color);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_get_background_color (ClutterActor *self,
ClutterColor *color);
CLUTTER_AVAILABLE_IN_1_6
CLUTTER_EXPORT
const ClutterPaintVolume * clutter_actor_get_paint_volume (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_6
CLUTTER_EXPORT
const ClutterPaintVolume * clutter_actor_get_transformed_paint_volume (ClutterActor *self,
ClutterActor *relative_to_ancestor);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
const ClutterPaintVolume * clutter_actor_get_default_paint_volume (ClutterActor *self);
/* Events */
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_reactive (ClutterActor *actor,
gboolean reactive);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_get_reactive (ClutterActor *actor);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_has_key_focus (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_grab_key_focus (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_event (ClutterActor *actor,
const ClutterEvent *event,
gboolean capture);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_has_pointer (ClutterActor *self);
/* Text */
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
PangoContext * clutter_actor_get_pango_context (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
PangoContext * clutter_actor_create_pango_context (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
PangoLayout * clutter_actor_create_pango_layout (ClutterActor *self,
const gchar *text);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_text_direction (ClutterActor *self,
ClutterTextDirection text_dir);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterTextDirection clutter_actor_get_text_direction (ClutterActor *self);
/* Actor hierarchy */
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_add_child (ClutterActor *self,
ClutterActor *child);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_insert_child_at_index (ClutterActor *self,
ClutterActor *child,
gint index_);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_insert_child_above (ClutterActor *self,
ClutterActor *child,
ClutterActor *sibling);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_insert_child_below (ClutterActor *self,
ClutterActor *child,
ClutterActor *sibling);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_replace_child (ClutterActor *self,
ClutterActor *old_child,
ClutterActor *new_child);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_remove_child (ClutterActor *self,
ClutterActor *child);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_remove_all_children (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_destroy_all_children (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
GList * clutter_actor_get_children (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
gint clutter_actor_get_n_children (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterActor * clutter_actor_get_child_at_index (ClutterActor *self,
gint index_);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterActor * clutter_actor_get_previous_sibling (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterActor * clutter_actor_get_next_sibling (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterActor * clutter_actor_get_first_child (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterActor * clutter_actor_get_last_child (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterActor * clutter_actor_get_parent (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
gboolean clutter_actor_contains (ClutterActor *self,
ClutterActor *descendant);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterActor* clutter_actor_get_stage (ClutterActor *actor);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_child_below_sibling (ClutterActor *self,
ClutterActor *child,
ClutterActor *sibling);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_child_above_sibling (ClutterActor *self,
ClutterActor *child,
ClutterActor *sibling);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_child_at_index (ClutterActor *self,
ClutterActor *child,
gint index_);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_iter_init (ClutterActorIter *iter,
ClutterActor *root);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
gboolean clutter_actor_iter_next (ClutterActorIter *iter,
ClutterActor **child);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
gboolean clutter_actor_iter_prev (ClutterActorIter *iter,
ClutterActor **child);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_iter_remove (ClutterActorIter *iter);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_iter_destroy (ClutterActorIter *iter);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
gboolean clutter_actor_iter_is_valid (const ClutterActorIter *iter);
/* Transformations */
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_is_rotated (ClutterActor *self);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_is_scaled (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_set_pivot_point (ClutterActor *self,
gfloat pivot_x,
gfloat pivot_y);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_get_pivot_point (ClutterActor *self,
gfloat *pivot_x,
gfloat *pivot_y);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_set_pivot_point_z (ClutterActor *self,
gfloat pivot_z);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
gfloat clutter_actor_get_pivot_point_z (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_set_rotation_angle (ClutterActor *self,
ClutterRotateAxis axis,
gdouble angle);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
gdouble clutter_actor_get_rotation_angle (ClutterActor *self,
ClutterRotateAxis axis);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_set_scale (ClutterActor *self,
gdouble scale_x,
gdouble scale_y);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_get_scale (ClutterActor *self,
gdouble *scale_x,
gdouble *scale_y);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_set_scale_z (ClutterActor *self,
gdouble scale_z);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
gdouble clutter_actor_get_scale_z (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_set_translation (ClutterActor *self,
gfloat translate_x,
gfloat translate_y,
gfloat translate_z);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_get_translation (ClutterActor *self,
gfloat *translate_x,
gfloat *translate_y,
gfloat *translate_z);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_set_transform (ClutterActor *self,
const ClutterMatrix *transform);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_get_transform (ClutterActor *self,
ClutterMatrix *transform);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_set_child_transform (ClutterActor *self,
const ClutterMatrix *transform);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_actor_get_child_transform (ClutterActor *self,
ClutterMatrix *transform);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_get_transformed_position (ClutterActor *self,
gfloat *x,
gfloat *y);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_get_transformed_size (ClutterActor *self,
gfloat *width,
gfloat *height);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_actor_transform_stage_point (ClutterActor *self,
gfloat x,
gfloat y,
gfloat *x_out,
gfloat *y_out);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_get_abs_allocation_vertices (ClutterActor *self,
ClutterVertex verts[]);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_apply_transform_to_point (ClutterActor *self,
const ClutterVertex *point,
ClutterVertex *vertex);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_actor_apply_relative_transform_to_point (ClutterActor *self,
ClutterActor *ancestor,
const ClutterVertex *point,
ClutterVertex *vertex);
/* Implicit animations */
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_save_easing_state (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_restore_easing_state (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_easing_mode (ClutterActor *self,
ClutterAnimationMode mode);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterAnimationMode clutter_actor_get_easing_mode (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_easing_duration (ClutterActor *self,
guint msecs);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
guint clutter_actor_get_easing_duration (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_set_easing_delay (ClutterActor *self,
guint msecs);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
guint clutter_actor_get_easing_delay (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterTransition * clutter_actor_get_transition (ClutterActor *self,
const char *name);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_add_transition (ClutterActor *self,
const char *name,
ClutterTransition *transition);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_remove_transition (ClutterActor *self,
const char *name);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_actor_remove_all_transitions (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_16
CLUTTER_EXPORT
gboolean clutter_actor_has_mapped_clones (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_22
CLUTTER_EXPORT
void clutter_actor_set_opacity_override (ClutterActor *self,
gint opacity);
CLUTTER_AVAILABLE_IN_1_22
CLUTTER_EXPORT
gint clutter_actor_get_opacity_override (ClutterActor *self);
/**
@ -883,13 +883,13 @@ gint clutter_actor_get_opacity_override
typedef ClutterActor * (* ClutterActorCreateChildFunc) (gpointer item,
gpointer user_data);
CLUTTER_AVAILABLE_IN_1_24
CLUTTER_EXPORT
void clutter_actor_bind_model (ClutterActor *self,
GListModel *model,
ClutterActorCreateChildFunc create_child_func,
gpointer user_data,
GDestroyNotify notify);
CLUTTER_AVAILABLE_IN_1_24
CLUTTER_EXPORT
void clutter_actor_bind_model_with_properties (ClutterActor *self,
GListModel *model,
GType child_type,

View File

@ -34,9 +34,7 @@
* #ClutterAlignConstraint is available since Clutter 1.4
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-align-constraint.h"

View File

@ -48,28 +48,28 @@ G_BEGIN_DECLS
typedef struct _ClutterAlignConstraint ClutterAlignConstraint;
typedef struct _ClutterAlignConstraintClass ClutterAlignConstraintClass;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType clutter_align_constraint_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterConstraint *clutter_align_constraint_new (ClutterActor *source,
ClutterAlignAxis axis,
gfloat factor);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_align_constraint_set_source (ClutterAlignConstraint *align,
ClutterActor *source);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterActor * clutter_align_constraint_get_source (ClutterAlignConstraint *align);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_align_constraint_set_align_axis (ClutterAlignConstraint *align,
ClutterAlignAxis axis);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterAlignAxis clutter_align_constraint_get_align_axis (ClutterAlignConstraint *align);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_align_constraint_set_factor (ClutterAlignConstraint *align,
gfloat factor);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
gfloat clutter_align_constraint_get_factor (ClutterAlignConstraint *align);
G_END_DECLS

View File

@ -45,9 +45,7 @@
* #ClutterAnimatable is available since Clutter 1.0
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#define CLUTTER_DISABLE_DEPRECATION_WARNINGS

View File

@ -95,21 +95,21 @@ struct _ClutterAnimatableIface
GValue *value);
};
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
GType clutter_animatable_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
GParamSpec *clutter_animatable_find_property (ClutterAnimatable *animatable,
const gchar *property_name);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
void clutter_animatable_get_initial_state (ClutterAnimatable *animatable,
const gchar *property_name,
GValue *value);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
void clutter_animatable_set_final_state (ClutterAnimatable *animatable,
const gchar *property_name,
const GValue *value);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
gboolean clutter_animatable_interpolate_value (ClutterAnimatable *animatable,
const gchar *property_name,
ClutterInterval *interval,

View File

@ -135,7 +135,7 @@ gboolean _clutter_backend_translate_event (Clutter
gpointer native,
ClutterEvent *event);
CLUTTER_AVAILABLE_IN_MUTTER
CLUTTER_EXPORT
void _clutter_backend_add_event_translator (ClutterBackend *backend,
ClutterEventTranslator *translator);
@ -150,7 +150,7 @@ gint32 _clutter_backend_get_units_serial (Clutter
PangoDirection _clutter_backend_get_keymap_direction (ClutterBackend *backend);
CLUTTER_AVAILABLE_IN_MUTTER
CLUTTER_EXPORT
void _clutter_backend_reset_cogl_framebuffer (ClutterBackend *backend);
void clutter_set_allowed_drivers (const char *drivers);

View File

@ -38,9 +38,7 @@
* #ClutterBackend is available since Clutter 0.4
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#define CLUTTER_ENABLE_EXPERIMENTAL_API
@ -53,7 +51,6 @@
#include "clutter-stage-manager-private.h"
#include "clutter-stage-private.h"
#include "clutter-stage-window.h"
#include "clutter-version.h"
#include "clutter-device-manager-private.h"
#define CLUTTER_DISABLE_DEPRECATION_WARNINGS

View File

@ -53,34 +53,34 @@ G_BEGIN_DECLS
typedef struct _ClutterBackend ClutterBackend;
typedef struct _ClutterBackendClass ClutterBackendClass;
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
GType clutter_backend_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterBackend * clutter_get_default_backend (void);
CLUTTER_AVAILABLE_IN_1_16
CLUTTER_EXPORT
void clutter_set_windowing_backend (const char *backend_type);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gdouble clutter_backend_get_resolution (ClutterBackend *backend);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_backend_set_font_options (ClutterBackend *backend,
const cairo_font_options_t *options);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
const cairo_font_options_t * clutter_backend_get_font_options (ClutterBackend *backend);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
CoglContext * clutter_backend_get_cogl_context (ClutterBackend *backend);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_backend_bell_notify (ClutterBackend *backend);
CLUTTER_AVAILABLE_IN_MUTTER
CLUTTER_EXPORT
ClutterInputMethod * clutter_backend_get_input_method (ClutterBackend *backend);
CLUTTER_AVAILABLE_IN_MUTTER
CLUTTER_EXPORT
void clutter_backend_set_input_method (ClutterBackend *backend,
ClutterInputMethod *method);
G_END_DECLS

View File

@ -30,9 +30,7 @@
* across the whole API.
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-types.h"
#include "clutter-private.h"

View File

@ -43,9 +43,7 @@
* #ClutterBinLayout is available since Clutter 1.2
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include <math.h>

View File

@ -74,10 +74,10 @@ struct _ClutterBinLayoutClass
ClutterLayoutManagerClass parent_class;
};
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
GType clutter_bin_layout_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
ClutterLayoutManager * clutter_bin_layout_new (ClutterBinAlignment x_align,
ClutterBinAlignment y_align);

View File

@ -80,9 +80,7 @@
* #ClutterBindConstraint is available since Clutter 1.4
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include <math.h>

View File

@ -48,28 +48,28 @@ G_BEGIN_DECLS
typedef struct _ClutterBindConstraint ClutterBindConstraint;
typedef struct _ClutterBindConstraintClass ClutterBindConstraintClass;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType clutter_bind_constraint_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterConstraint * clutter_bind_constraint_new (ClutterActor *source,
ClutterBindCoordinate coordinate,
gfloat offset);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_bind_constraint_set_source (ClutterBindConstraint *constraint,
ClutterActor *source);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterActor * clutter_bind_constraint_get_source (ClutterBindConstraint *constraint);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_bind_constraint_set_coordinate (ClutterBindConstraint *constraint,
ClutterBindCoordinate coordinate);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterBindCoordinate clutter_bind_constraint_get_coordinate (ClutterBindConstraint *constraint);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_bind_constraint_set_offset (ClutterBindConstraint *constraint,
gfloat offset);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
gfloat clutter_bind_constraint_get_offset (ClutterBindConstraint *constraint);
G_END_DECLS

View File

@ -94,9 +94,7 @@
* #ClutterBindingPool is available since Clutter 1.0
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-binding-pool.h"
#include "clutter-debug.h"

View File

@ -71,17 +71,17 @@ typedef gboolean (* ClutterBindingActionFunc) (GObject *gobject,
ClutterModifierType modifiers,
gpointer user_data);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
GType clutter_binding_pool_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
ClutterBindingPool * clutter_binding_pool_new (const gchar *name);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
ClutterBindingPool * clutter_binding_pool_get_for_class (gpointer klass);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
ClutterBindingPool * clutter_binding_pool_find (const gchar *name);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
void clutter_binding_pool_install_action (ClutterBindingPool *pool,
const gchar *action_name,
guint key_val,
@ -89,44 +89,44 @@ void clutter_binding_pool_install_action (ClutterBindingPool
GCallback callback,
gpointer data,
GDestroyNotify notify);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
void clutter_binding_pool_install_closure (ClutterBindingPool *pool,
const gchar *action_name,
guint key_val,
ClutterModifierType modifiers,
GClosure *closure);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
void clutter_binding_pool_override_action (ClutterBindingPool *pool,
guint key_val,
ClutterModifierType modifiers,
GCallback callback,
gpointer data,
GDestroyNotify notify);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
void clutter_binding_pool_override_closure (ClutterBindingPool *pool,
guint key_val,
ClutterModifierType modifiers,
GClosure *closure);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
const gchar * clutter_binding_pool_find_action (ClutterBindingPool *pool,
guint key_val,
ClutterModifierType modifiers);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
void clutter_binding_pool_remove_action (ClutterBindingPool *pool,
guint key_val,
ClutterModifierType modifiers);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
gboolean clutter_binding_pool_activate (ClutterBindingPool *pool,
guint key_val,
ClutterModifierType modifiers,
GObject *gobject);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
void clutter_binding_pool_block_action (ClutterBindingPool *pool,
const gchar *action_name);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
void clutter_binding_pool_unblock_action (ClutterBindingPool *pool,
const gchar *action_name);

View File

@ -37,9 +37,7 @@
#define CLUTTER_IS_BLUR_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_BLUR_EFFECT))
#define CLUTTER_BLUR_EFFECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_BLUR_EFFECT, ClutterBlurEffectClass))
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#define CLUTTER_ENABLE_EXPERIMENTAL_API

View File

@ -48,10 +48,10 @@ G_BEGIN_DECLS
typedef struct _ClutterBlurEffect ClutterBlurEffect;
typedef struct _ClutterBlurEffectClass ClutterBlurEffectClass;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType clutter_blur_effect_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterEffect *clutter_blur_effect_new (void);
G_END_DECLS

View File

@ -48,9 +48,7 @@
* #ClutterBoxLayout is available since Clutter 1.2
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include <math.h>

View File

@ -77,41 +77,41 @@ struct _ClutterBoxLayoutClass
ClutterLayoutManagerClass parent_class;
};
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
GType clutter_box_layout_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
ClutterLayoutManager * clutter_box_layout_new (void);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_box_layout_set_orientation (ClutterBoxLayout *layout,
ClutterOrientation orientation);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
ClutterOrientation clutter_box_layout_get_orientation (ClutterBoxLayout *layout);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
void clutter_box_layout_set_spacing (ClutterBoxLayout *layout,
guint spacing);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
guint clutter_box_layout_get_spacing (ClutterBoxLayout *layout);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
void clutter_box_layout_set_homogeneous (ClutterBoxLayout *layout,
gboolean homogeneous);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
gboolean clutter_box_layout_get_homogeneous (ClutterBoxLayout *layout);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
void clutter_box_layout_set_pack_start (ClutterBoxLayout *layout,
gboolean pack_start);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
gboolean clutter_box_layout_get_pack_start (ClutterBoxLayout *layout);
CLUTTER_DEPRECATED_IN_1_12_FOR(clutter_box_layout_set_orientation)
CLUTTER_DEPRECATED_FOR(clutter_box_layout_set_orientation)
void clutter_box_layout_set_vertical (ClutterBoxLayout *layout,
gboolean vertical);
CLUTTER_DEPRECATED_IN_1_12_FOR(clutter_box_layout_get_orientation)
CLUTTER_DEPRECATED_FOR(clutter_box_layout_get_orientation)
gboolean clutter_box_layout_get_vertical (ClutterBoxLayout *layout);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
void clutter_box_layout_pack (ClutterBoxLayout *layout,
ClutterActor *actor,
gboolean expand,
@ -119,48 +119,48 @@ void clutter_box_layout_pack (ClutterBoxLayou
gboolean y_fill,
ClutterBoxAlignment x_align,
ClutterBoxAlignment y_align);
CLUTTER_DEPRECATED_IN_1_12
CLUTTER_DEPRECATED
void clutter_box_layout_set_alignment (ClutterBoxLayout *layout,
ClutterActor *actor,
ClutterBoxAlignment x_align,
ClutterBoxAlignment y_align);
CLUTTER_DEPRECATED_IN_1_12
CLUTTER_DEPRECATED
void clutter_box_layout_get_alignment (ClutterBoxLayout *layout,
ClutterActor *actor,
ClutterBoxAlignment *x_align,
ClutterBoxAlignment *y_align);
CLUTTER_DEPRECATED_IN_1_12
CLUTTER_DEPRECATED
void clutter_box_layout_set_fill (ClutterBoxLayout *layout,
ClutterActor *actor,
gboolean x_fill,
gboolean y_fill);
CLUTTER_DEPRECATED_IN_1_12
CLUTTER_DEPRECATED
void clutter_box_layout_get_fill (ClutterBoxLayout *layout,
ClutterActor *actor,
gboolean *x_fill,
gboolean *y_fill);
CLUTTER_DEPRECATED_IN_1_12
CLUTTER_DEPRECATED
void clutter_box_layout_set_expand (ClutterBoxLayout *layout,
ClutterActor *actor,
gboolean expand);
CLUTTER_DEPRECATED_IN_1_12
CLUTTER_DEPRECATED
gboolean clutter_box_layout_get_expand (ClutterBoxLayout *layout,
ClutterActor *actor);
CLUTTER_DEPRECATED_IN_1_12
CLUTTER_DEPRECATED
void clutter_box_layout_set_use_animations (ClutterBoxLayout *layout,
gboolean animate);
CLUTTER_DEPRECATED_IN_1_12
CLUTTER_DEPRECATED
gboolean clutter_box_layout_get_use_animations (ClutterBoxLayout *layout);
CLUTTER_DEPRECATED_IN_1_12
CLUTTER_DEPRECATED
void clutter_box_layout_set_easing_mode (ClutterBoxLayout *layout,
gulong mode);
CLUTTER_DEPRECATED_IN_1_12
CLUTTER_DEPRECATED
gulong clutter_box_layout_get_easing_mode (ClutterBoxLayout *layout);
CLUTTER_DEPRECATED_IN_1_12
CLUTTER_DEPRECATED
void clutter_box_layout_set_easing_duration (ClutterBoxLayout *layout,
guint msecs);
CLUTTER_DEPRECATED_IN_1_12
CLUTTER_DEPRECATED
guint clutter_box_layout_get_easing_duration (ClutterBoxLayout *layout);
G_END_DECLS

View File

@ -37,9 +37,7 @@
#define CLUTTER_IS_BRIGHTNESS_CONTRAST_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_BRIGHTNESS_CONTRAST_EFFECT))
#define CLUTTER_BRIGHTNESS_CONTRAST_EFFECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_BRIGHTNESS_CONTRAST_EFFECT, ClutterBrightnessContrastEffectClass))
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include <math.h>

View File

@ -49,35 +49,35 @@ G_BEGIN_DECLS
typedef struct _ClutterBrightnessContrastEffect ClutterBrightnessContrastEffect;
typedef struct _ClutterBrightnessContrastEffectClass ClutterBrightnessContrastEffectClass;
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
GType clutter_brightness_contrast_effect_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterEffect * clutter_brightness_contrast_effect_new (void);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_brightness_contrast_effect_set_brightness_full (ClutterBrightnessContrastEffect *effect,
float red,
float green,
float blue);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_brightness_contrast_effect_set_brightness (ClutterBrightnessContrastEffect *effect,
float brightness);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_brightness_contrast_effect_get_brightness (ClutterBrightnessContrastEffect *effect,
float *red,
float *green,
float *blue);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_brightness_contrast_effect_set_contrast_full (ClutterBrightnessContrastEffect *effect,
float red,
float green,
float blue);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_brightness_contrast_effect_set_contrast (ClutterBrightnessContrastEffect *effect,
float contrast);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_brightness_contrast_effect_get_contrast (ClutterBrightnessContrastEffect *effect,
float *red,
float *green,

View File

@ -0,0 +1,14 @@
/* Mutter version */
#mesondefine MUTTER_VERSION
/* List of Cogl drivers */
#mesondefine CLUTTER_DRIVERS
/* Have evdev support for input handling */
#mesondefine HAVE_EVDEV
/* Building with libwacom for advanced tablet management */
#mesondefine HAVE_LIBWACOM
/* Supports PangoFt2 */
#mesondefine HAVE_PANGO_FT2

View File

@ -27,9 +27,7 @@
* Clutter provides some utility functions for using Cairo.
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-cairo.h"
#include "clutter-color.h"

View File

@ -50,9 +50,9 @@ G_BEGIN_DECLS
#define CLUTTER_CAIRO_FORMAT_ARGB32 (COGL_PIXEL_FORMAT_ARGB_8888_PRE)
#endif
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_cairo_clear (cairo_t *cr);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
void clutter_cairo_set_source_color (cairo_t *cr,
const ClutterColor *color);

View File

@ -42,9 +42,7 @@
* #ClutterCanvas is available since Clutter 1.10.
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include <cogl/cogl.h>
#include <cairo-gobject.h>

View File

@ -85,20 +85,20 @@ struct _ClutterCanvasClass
gpointer _padding[16];
};
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
GType clutter_canvas_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterContent * clutter_canvas_new (void);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
gboolean clutter_canvas_set_size (ClutterCanvas *canvas,
int width,
int height);
CLUTTER_AVAILABLE_IN_1_18
CLUTTER_EXPORT
void clutter_canvas_set_scale_factor (ClutterCanvas *canvas,
int scale);
CLUTTER_AVAILABLE_IN_1_18
CLUTTER_EXPORT
int clutter_canvas_get_scale_factor (ClutterCanvas *canvas);
G_END_DECLS

View File

@ -36,9 +36,8 @@
*
* #ClutterChildMeta is available since Clutter 0.8
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-child-meta.h"
#include "clutter-container.h"

View File

@ -109,12 +109,12 @@ struct _ClutterChildMetaClass
GObjectClass parent_class;
};
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
GType clutter_child_meta_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterContainer * clutter_child_meta_get_container (ClutterChildMeta *data);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterActor * clutter_child_meta_get_actor (ClutterChildMeta *data);
G_END_DECLS

View File

@ -92,9 +92,7 @@
* #ClutterClickAction is available since Clutter 1.4
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-click-action.h"

View File

@ -97,22 +97,22 @@ struct _ClutterClickActionClass
void (* _clutter_click_action7) (void);
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType clutter_click_action_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterAction * clutter_click_action_new (void);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
guint clutter_click_action_get_button (ClutterClickAction *action);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterModifierType clutter_click_action_get_state (ClutterClickAction *action);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_click_action_get_coords (ClutterClickAction *action,
gfloat *press_x,
gfloat *press_y);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_click_action_release (ClutterClickAction *action);
G_END_DECLS

View File

@ -37,9 +37,7 @@
* #ClutterClone is available since Clutter 1.0
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#define CLUTTER_ENABLE_EXPERIMENTAL_API
#include "clutter-actor-private.h"

View File

@ -78,15 +78,15 @@ struct _ClutterCloneClass
void (*_clutter_actor_clone4) (void);
};
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
GType clutter_clone_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
ClutterActor * clutter_clone_new (ClutterActor *source);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
void clutter_clone_set_source (ClutterClone *self,
ClutterActor *source);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
ClutterActor * clutter_clone_get_source (ClutterClone *self);
G_END_DECLS

View File

@ -33,9 +33,7 @@
* The alpha channel is fully opaque at 255 and fully transparent at 0.
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include <math.h>

View File

@ -68,76 +68,76 @@ struct _ClutterColor
*/
#define CLUTTER_COLOR_INIT(r,g,b,a) { (r), (g), (b), (a) }
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
GType clutter_color_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterColor *clutter_color_new (guint8 red,
guint8 green,
guint8 blue,
guint8 alpha);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
ClutterColor *clutter_color_alloc (void);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
ClutterColor *clutter_color_init (ClutterColor *color,
guint8 red,
guint8 green,
guint8 blue,
guint8 alpha);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterColor *clutter_color_copy (const ClutterColor *color);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_color_free (ClutterColor *color);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_color_add (const ClutterColor *a,
const ClutterColor *b,
ClutterColor *result);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_color_subtract (const ClutterColor *a,
const ClutterColor *b,
ClutterColor *result);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_color_lighten (const ClutterColor *color,
ClutterColor *result);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_color_darken (const ClutterColor *color,
ClutterColor *result);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_color_shade (const ClutterColor *color,
gdouble factor,
ClutterColor *result);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gchar * clutter_color_to_string (const ClutterColor *color);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
gboolean clutter_color_from_string (ClutterColor *color,
const gchar *str);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_color_to_hls (const ClutterColor *color,
gfloat *hue,
gfloat *luminance,
gfloat *saturation);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_color_from_hls (ClutterColor *color,
gfloat hue,
gfloat luminance,
gfloat saturation);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
guint32 clutter_color_to_pixel (const ClutterColor *color);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_color_from_pixel (ClutterColor *color,
guint32 pixel);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
guint clutter_color_hash (gconstpointer v);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_color_equal (gconstpointer v1,
gconstpointer v2);
CLUTTER_AVAILABLE_IN_1_6
CLUTTER_EXPORT
void clutter_color_interpolate (const ClutterColor *initial,
const ClutterColor *final,
gdouble progress,
@ -177,22 +177,22 @@ struct _ClutterParamSpecColor
ClutterColor *default_value;
};
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
void clutter_value_set_color (GValue *value,
const ClutterColor *color);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
const ClutterColor * clutter_value_get_color (const GValue *value);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
GType clutter_param_color_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
GParamSpec * clutter_param_spec_color (const gchar *name,
const gchar *nick,
const gchar *blurb,
const ClutterColor *default_value,
GParamFlags flags);
CLUTTER_AVAILABLE_IN_1_6
CLUTTER_EXPORT
const ClutterColor *clutter_color_get_static (ClutterStaticColor color);
G_END_DECLS

View File

@ -37,9 +37,7 @@
#define CLUTTER_IS_COLORIZE_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_COLORIZE_EFFECT))
#define CLUTTER_COLORIZE_EFFECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_COLORIZE_EFFECT, ClutterColorizeEffectClass))
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#define CLUTTER_ENABLE_EXPERIMENTAL_API

View File

@ -49,16 +49,16 @@ G_BEGIN_DECLS
typedef struct _ClutterColorizeEffect ClutterColorizeEffect;
typedef struct _ClutterColorizeEffectClass ClutterColorizeEffectClass;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType clutter_colorize_effect_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterEffect *clutter_colorize_effect_new (const ClutterColor *tint);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_colorize_effect_set_tint (ClutterColorizeEffect *effect,
const ClutterColor *tint);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_colorize_effect_get_tint (ClutterColorizeEffect *effect,
ClutterColor *tint);

View File

@ -43,7 +43,7 @@
*
* Constraints can be used with fixed layout managers, like
* #ClutterFixedLayout, or with actors implicitly using a fixed layout
* manager, like #ClutterGroup and #ClutterStage.
* manager, like #ClutterStage.
*
* Constraints provide a way to build user interfaces by using
* relations between #ClutterActors, without explicit fixed
@ -128,9 +128,7 @@
* can be recovered at any point using clutter_actor_meta_get_actor().
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include <string.h>

View File

@ -96,32 +96,32 @@ struct _ClutterConstraintClass
void (* _clutter_constraint7) (void);
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType clutter_constraint_get_type (void) G_GNUC_CONST;
/* ClutterActor API */
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_add_constraint (ClutterActor *self,
ClutterConstraint *constraint);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_add_constraint_with_name (ClutterActor *self,
const gchar *name,
ClutterConstraint *constraint);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_remove_constraint (ClutterActor *self,
ClutterConstraint *constraint);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_remove_constraint_by_name (ClutterActor *self,
const gchar *name);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GList * clutter_actor_get_constraints (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterConstraint *clutter_actor_get_constraint (ClutterActor *self,
const gchar *name);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_clear_constraints (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
gboolean clutter_actor_has_constraints (ClutterActor *self);
G_END_DECLS

View File

@ -26,9 +26,7 @@
* Author: Emmanuele Bassi <ebassi@openedhand.com>
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include <stdarg.h>
#include <glib-object.h>

View File

@ -141,52 +141,52 @@ struct _ClutterContainerIface
GParamSpec *pspec);
};
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
GType clutter_container_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterActor * clutter_container_find_child_by_name (ClutterContainer *container,
const gchar *child_name);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
GParamSpec * clutter_container_class_find_child_property (GObjectClass *klass,
const gchar *property_name);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
GParamSpec ** clutter_container_class_list_child_properties (GObjectClass *klass,
guint *n_properties);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_container_create_child_meta (ClutterContainer *container,
ClutterActor *actor);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_container_destroy_child_meta (ClutterContainer *container,
ClutterActor *actor);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterChildMeta * clutter_container_get_child_meta (ClutterContainer *container,
ClutterActor *actor);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_container_child_set_property (ClutterContainer *container,
ClutterActor *child,
const gchar * property,
const GValue *value);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_container_child_get_property (ClutterContainer *container,
ClutterActor *child,
const gchar *property,
GValue *value);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_container_child_set (ClutterContainer *container,
ClutterActor *actor,
const gchar *first_prop,
...) G_GNUC_NULL_TERMINATED;
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_container_child_get (ClutterContainer *container,
ClutterActor *actor,
const gchar *first_prop,
...) G_GNUC_NULL_TERMINATED;
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_container_child_notify (ClutterContainer *container,
ClutterActor *child,
GParamSpec *pspec);

View File

@ -36,9 +36,7 @@
* #ClutterContent is available since Clutter 1.10.
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-content-private.h"

View File

@ -88,14 +88,14 @@ struct _ClutterContentIface
void (* invalidate) (ClutterContent *content);
};
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
GType clutter_content_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
gboolean clutter_content_get_preferred_size (ClutterContent *content,
gfloat *width,
gfloat *height);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_content_invalidate (ClutterContent *content);
G_END_DECLS

View File

@ -51,9 +51,7 @@
* deformation algorithm.
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#define CLUTTER_ENABLE_EXPERIMENTAL_API
#include "clutter-deform-effect.h"

View File

@ -92,24 +92,24 @@ struct _ClutterDeformEffectClass
void (*_clutter_deform7) (void);
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType clutter_deform_effect_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_deform_effect_set_back_material (ClutterDeformEffect *effect,
CoglHandle material);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
CoglHandle clutter_deform_effect_get_back_material (ClutterDeformEffect *effect);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_deform_effect_set_n_tiles (ClutterDeformEffect *effect,
guint x_tiles,
guint y_tiles);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_deform_effect_get_n_tiles (ClutterDeformEffect *effect,
guint *x_tiles,
guint *y_tiles);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_deform_effect_invalidate (ClutterDeformEffect *effect);
G_END_DECLS

View File

@ -7,7 +7,6 @@
#include "deprecated/clutter-alpha.h"
#include "deprecated/clutter-animatable.h"
#include "deprecated/clutter-animation.h"
#include "deprecated/clutter-animator.h"
#include "deprecated/clutter-backend.h"
#include "deprecated/clutter-behaviour.h"
#include "deprecated/clutter-behaviour-depth.h"
@ -17,27 +16,16 @@
#include "deprecated/clutter-behaviour-rotate.h"
#include "deprecated/clutter-behaviour-scale.h"
#include "deprecated/clutter-bin-layout.h"
#include "deprecated/clutter-box.h"
#include "deprecated/clutter-cairo-texture.h"
#include "deprecated/clutter-container.h"
#include "deprecated/clutter-frame-source.h"
#include "deprecated/clutter-group.h"
#include "deprecated/clutter-input-device.h"
#include "deprecated/clutter-keysyms.h"
#include "deprecated/clutter-list-model.h"
#include "deprecated/clutter-main.h"
#include "deprecated/clutter-media.h"
#include "deprecated/clutter-model.h"
#include "deprecated/clutter-rectangle.h"
#include "deprecated/clutter-score.h"
#include "deprecated/clutter-shader.h"
#include "deprecated/clutter-stage-manager.h"
#include "deprecated/clutter-stage.h"
#include "deprecated/clutter-state.h"
#include "deprecated/clutter-table-layout.h"
#include "deprecated/clutter-texture.h"
#include "deprecated/clutter-timeline.h"
#include "deprecated/clutter-timeout-pool.h"
#include "deprecated/clutter-util.h"
#undef __CLUTTER_DEPRECATED_H_INSIDE__

View File

@ -39,9 +39,7 @@
#define CLUTTER_IS_DESATURATE_EFFECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_DESATURATE_EFFECT))
#define CLUTTER_DESATURATE_EFFECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_DESATURATE_EFFECT, ClutterDesaturateEffectClass))
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#define CLUTTER_ENABLE_EXPERIMENTAL_API

View File

@ -48,16 +48,16 @@ G_BEGIN_DECLS
typedef struct _ClutterDesaturateEffect ClutterDesaturateEffect;
typedef struct _ClutterDesaturateEffectClass ClutterDesaturateEffectClass;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType clutter_desaturate_effect_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterEffect *clutter_desaturate_effect_new (gdouble factor);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_desaturate_effect_set_factor (ClutterDesaturateEffect *effect,
gdouble factor);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
gdouble clutter_desaturate_effect_get_factor (ClutterDesaturateEffect *effect);
G_END_DECLS

View File

@ -36,9 +36,7 @@
* #ClutterDeviceManager is available since Clutter 1.2
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-backend-private.h"
#include "clutter-debug.h"

View File

@ -125,34 +125,34 @@ struct _ClutterDeviceManagerClass
gpointer _padding[6];
};
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
GType clutter_device_manager_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
ClutterDeviceManager *clutter_device_manager_get_default (void);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
GSList * clutter_device_manager_list_devices (ClutterDeviceManager *device_manager);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
const GSList * clutter_device_manager_peek_devices (ClutterDeviceManager *device_manager);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
ClutterInputDevice * clutter_device_manager_get_device (ClutterDeviceManager *device_manager,
gint device_id);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
ClutterInputDevice * clutter_device_manager_get_core_device (ClutterDeviceManager *device_manager,
ClutterInputDeviceType device_type);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterVirtualInputDevice *clutter_device_manager_create_virtual_device (ClutterDeviceManager *device_manager,
ClutterInputDeviceType device_type);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterVirtualDeviceType clutter_device_manager_get_supported_virtual_device_types (ClutterDeviceManager *device_manager);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_device_manager_set_kbd_a11y_settings (ClutterDeviceManager *device_manager,
ClutterKbdA11ySettings *settings);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_device_manager_get_kbd_a11y_settings (ClutterDeviceManager *device_manager,
ClutterKbdA11ySettings *settings);

View File

@ -63,9 +63,7 @@
* #ClutterDragAction is available since Clutter 1.4
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-drag-action.h"

View File

@ -105,45 +105,45 @@ struct _ClutterDragActionClass
void (* _clutter_drag_action4) (void);
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType clutter_drag_action_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterAction * clutter_drag_action_new (void);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_drag_action_set_drag_threshold (ClutterDragAction *action,
gint x_threshold,
gint y_threshold);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_drag_action_get_drag_threshold (ClutterDragAction *action,
guint *x_threshold,
guint *y_threshold);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_drag_action_set_drag_handle (ClutterDragAction *action,
ClutterActor *handle);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterActor * clutter_drag_action_get_drag_handle (ClutterDragAction *action);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_drag_action_set_drag_axis (ClutterDragAction *action,
ClutterDragAxis axis);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterDragAxis clutter_drag_action_get_drag_axis (ClutterDragAction *action);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_drag_action_get_press_coords (ClutterDragAction *action,
gfloat *press_x,
gfloat *press_y);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_drag_action_get_motion_coords (ClutterDragAction *action,
gfloat *motion_x,
gfloat *motion_y);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
gboolean clutter_drag_action_get_drag_area (ClutterDragAction *action,
ClutterRect *drag_area);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_drag_action_set_drag_area (ClutterDragAction *action,
const ClutterRect *drag_area);

View File

@ -58,9 +58,7 @@
* #ClutterDropAction is available since Clutter 1.8
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-drop-action.h"

View File

@ -104,10 +104,10 @@ struct _ClutterDropActionClass
void (*_clutter_drop_action8) (void);
};
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
GType clutter_drop_action_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
ClutterAction * clutter_drop_action_new (void);
G_END_DECLS

View File

@ -9,6 +9,7 @@ gboolean _clutter_effect_pre_paint (ClutterEffect
void _clutter_effect_post_paint (ClutterEffect *effect);
gboolean _clutter_effect_get_paint_volume (ClutterEffect *effect,
ClutterPaintVolume *volume);
gboolean _clutter_effect_has_custom_paint_volume (ClutterEffect *effect);
void _clutter_effect_paint (ClutterEffect *effect,
ClutterEffectPaintFlags flags);
void _clutter_effect_pick (ClutterEffect *effect,

View File

@ -160,9 +160,7 @@
* #ClutterEffect is available since Clutter 1.4
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-effect.h"
@ -308,6 +306,14 @@ _clutter_effect_get_paint_volume (ClutterEffect *effect,
return CLUTTER_EFFECT_GET_CLASS (effect)->get_paint_volume (effect, volume);
}
gboolean
_clutter_effect_has_custom_paint_volume (ClutterEffect *effect)
{
g_return_val_if_fail (CLUTTER_IS_EFFECT (effect), FALSE);
return CLUTTER_EFFECT_GET_CLASS (effect)->get_paint_volume != clutter_effect_real_get_paint_volume;
}
/**
* clutter_effect_queue_repaint:
* @effect: A #ClutterEffect which needs redrawing

View File

@ -91,38 +91,38 @@ struct _ClutterEffectClass
void (* _clutter_effect6) (void);
};
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GType clutter_effect_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_effect_queue_repaint (ClutterEffect *effect);
/*
* ClutterActor API
*/
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_add_effect (ClutterActor *self,
ClutterEffect *effect);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_add_effect_with_name (ClutterActor *self,
const gchar *name,
ClutterEffect *effect);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_remove_effect (ClutterActor *self,
ClutterEffect *effect);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_remove_effect_by_name (ClutterActor *self,
const gchar *name);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
GList * clutter_actor_get_effects (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
ClutterEffect *clutter_actor_get_effect (ClutterActor *self,
const gchar *name);
CLUTTER_AVAILABLE_IN_1_4
CLUTTER_EXPORT
void clutter_actor_clear_effects (ClutterActor *self);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
gboolean clutter_actor_has_effects (ClutterActor *self);
G_END_DECLS

View File

@ -17,7 +17,7 @@ G_BEGIN_DECLS
/*** END file-production ***/
/*** BEGIN value-header ***/
CLUTTER_AVAILABLE_IN_ALL GType @enum_name@_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT GType @enum_name@_get_type (void) G_GNUC_CONST;
#define CLUTTER_TYPE_@ENUMSHORT@ (@enum_name@_get_type())
/*** END value-header ***/

View File

@ -761,6 +761,7 @@ typedef enum { /*< prefix=CLUTTER_DRAG >*/
* ClutterEventFlags:
* @CLUTTER_EVENT_NONE: No flag set
* @CLUTTER_EVENT_FLAG_SYNTHETIC: Synthetic event
* @CLUTTER_EVENT_FLAG_REPEATED: Auto-repeated event
*
* Flags for the #ClutterEvent
*
@ -769,7 +770,8 @@ typedef enum { /*< prefix=CLUTTER_DRAG >*/
typedef enum { /*< flags prefix=CLUTTER_EVENT >*/
CLUTTER_EVENT_NONE = 0,
CLUTTER_EVENT_FLAG_SYNTHETIC = 1 << 0,
CLUTTER_EVENT_FLAG_INPUT_METHOD = 1 << 1
CLUTTER_EVENT_FLAG_INPUT_METHOD = 1 << 1,
CLUTTER_EVENT_FLAG_REPEATED = 1 << 2
} ClutterEventFlags;
/**

View File

@ -29,7 +29,7 @@ struct _ClutterEventTranslatorIface
ClutterEvent *translated);
};
CLUTTER_AVAILABLE_IN_MUTTER
CLUTTER_EXPORT
GType _clutter_event_translator_get_type (void) G_GNUC_CONST;
ClutterTranslateReturn _clutter_event_translator_translate_event (ClutterEventTranslator *translator,

View File

@ -23,9 +23,7 @@
*
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-backend-private.h"
#include "clutter-debug.h"

View File

@ -589,185 +589,185 @@ union _ClutterEvent
typedef gboolean (* ClutterEventFilterFunc) (const ClutterEvent *event,
gpointer user_data);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
GType clutter_event_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_20
CLUTTER_EXPORT
GType clutter_event_sequence_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_events_pending (void);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterEvent * clutter_event_get (void);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterEvent * clutter_event_peek (void);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_event_put (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_18
CLUTTER_EXPORT
guint clutter_event_add_filter (ClutterStage *stage,
ClutterEventFilterFunc func,
GDestroyNotify notify,
gpointer user_data);
CLUTTER_AVAILABLE_IN_1_18
CLUTTER_EXPORT
void clutter_event_remove_filter (guint id);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterEvent * clutter_event_new (ClutterEventType type);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterEvent * clutter_event_copy (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_event_free (ClutterEvent *event);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterEventType clutter_event_type (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_event_set_flags (ClutterEvent *event,
ClutterEventFlags flags);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
ClutterEventFlags clutter_event_get_flags (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_event_set_time (ClutterEvent *event,
guint32 time_);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
guint32 clutter_event_get_time (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_event_set_state (ClutterEvent *event,
ClutterModifierType state);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterModifierType clutter_event_get_state (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_16
CLUTTER_EXPORT
void clutter_event_get_state_full (const ClutterEvent *event,
ClutterModifierType *button_state,
ClutterModifierType *base_state,
ClutterModifierType *latched_state,
ClutterModifierType *locked_state,
ClutterModifierType *effective_state);
CLUTTER_AVAILABLE_IN_1_6
CLUTTER_EXPORT
void clutter_event_set_device (ClutterEvent *event,
ClutterInputDevice *device);
CLUTTER_AVAILABLE_IN_1_6
CLUTTER_EXPORT
ClutterInputDevice * clutter_event_get_device (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_6
CLUTTER_EXPORT
void clutter_event_set_source_device (ClutterEvent *event,
ClutterInputDevice *device);
CLUTTER_AVAILABLE_IN_1_6
CLUTTER_EXPORT
ClutterInputDevice * clutter_event_get_source_device (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_event_set_device_tool (ClutterEvent *event,
ClutterInputDeviceTool *tool);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterInputDeviceTool *clutter_event_get_device_tool (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_event_set_source (ClutterEvent *event,
ClutterActor *actor);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterActor * clutter_event_get_source (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_event_set_stage (ClutterEvent *event,
ClutterStage *stage);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterStage * clutter_event_get_stage (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gint clutter_event_get_device_id (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
ClutterInputDeviceType clutter_event_get_device_type (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_event_set_coords (ClutterEvent *event,
gfloat x,
gfloat y);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
void clutter_event_get_coords (const ClutterEvent *event,
gfloat *x,
gfloat *y);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
void clutter_event_get_position (const ClutterEvent *event,
ClutterPoint *position);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
float clutter_event_get_distance (const ClutterEvent *source,
const ClutterEvent *target);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
double clutter_event_get_angle (const ClutterEvent *source,
const ClutterEvent *target);
CLUTTER_AVAILABLE_IN_1_6
CLUTTER_EXPORT
gdouble * clutter_event_get_axes (const ClutterEvent *event,
guint *n_axes);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
gboolean clutter_event_has_shift_modifier (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
gboolean clutter_event_has_control_modifier (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_12
CLUTTER_EXPORT
gboolean clutter_event_is_pointer_emulated (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_event_set_key_symbol (ClutterEvent *event,
guint key_sym);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
guint clutter_event_get_key_symbol (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_event_set_key_code (ClutterEvent *event,
guint16 key_code);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
guint16 clutter_event_get_key_code (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_event_set_key_unicode (ClutterEvent *event,
gunichar key_unicode);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
gunichar clutter_event_get_key_unicode (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_event_set_button (ClutterEvent *event,
guint32 button);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
guint32 clutter_event_get_button (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
guint clutter_event_get_click_count (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_event_set_related (ClutterEvent *event,
ClutterActor *actor);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
ClutterActor * clutter_event_get_related (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_8
CLUTTER_EXPORT
void clutter_event_set_scroll_direction (ClutterEvent *event,
ClutterScrollDirection direction);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
ClutterScrollDirection clutter_event_get_scroll_direction (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_event_set_scroll_delta (ClutterEvent *event,
gdouble dx,
gdouble dy);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
void clutter_event_get_scroll_delta (const ClutterEvent *event,
gdouble *dx,
gdouble *dy);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
ClutterEventSequence * clutter_event_get_event_sequence (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
guint32 clutter_keysym_to_unicode (guint keyval);
CLUTTER_AVAILABLE_IN_1_10
CLUTTER_EXPORT
guint clutter_unicode_to_keysym (guint32 wc);
CLUTTER_AVAILABLE_IN_1_0
CLUTTER_EXPORT
guint32 clutter_get_current_event_time (void);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
const ClutterEvent * clutter_get_current_event (void);
CLUTTER_AVAILABLE_IN_1_24
CLUTTER_EXPORT
guint clutter_event_get_touchpad_gesture_finger_count (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_24
CLUTTER_EXPORT
gdouble clutter_event_get_gesture_pinch_angle_delta (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_24
CLUTTER_EXPORT
gdouble clutter_event_get_gesture_pinch_scale (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_24
CLUTTER_EXPORT
ClutterTouchpadGesturePhase clutter_event_get_gesture_phase (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_1_24
CLUTTER_EXPORT
void clutter_event_get_gesture_motion_delta (const ClutterEvent *event,
gdouble *dx,
gdouble *dy);
@ -775,10 +775,10 @@ void clutter_event_get_gesture_motion_delta (const Clut
ClutterScrollSource clutter_event_get_scroll_source (const ClutterEvent *event);
ClutterScrollFinishFlags clutter_event_get_scroll_finish_flags (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
guint clutter_event_get_mode_group (const ClutterEvent *event);
CLUTTER_AVAILABLE_IN_MUTTER
CLUTTER_EXPORT
gboolean clutter_event_get_pad_event_details (const ClutterEvent *event,
guint *number,
guint *mode,

View File

@ -37,9 +37,7 @@
* See also cogl_get_features() and #CoglFeatureFlags
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include <stdlib.h>
#include <string.h>

View File

@ -32,9 +32,9 @@
G_BEGIN_DECLS
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
gboolean clutter_feature_available (ClutterFeatureFlags feature);
CLUTTER_AVAILABLE_IN_ALL
CLUTTER_EXPORT
ClutterFeatureFlags clutter_feature_get_all (void);
G_END_DECLS

View File

@ -34,9 +34,7 @@
* #ClutterFixedLayout is available since Clutter 1.2
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-debug.h"
#include "clutter-fixed-layout.h"

View File

@ -71,10 +71,10 @@ struct _ClutterFixedLayoutClass
ClutterLayoutManagerClass parent_class;
};
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
GType clutter_fixed_layout_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
ClutterLayoutManager *clutter_fixed_layout_new (void);
G_END_DECLS

View File

@ -27,9 +27,7 @@
need to do anything on top of the ClutterOffscreenEffect class so
it only exists because that class is abstract */
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include "clutter-flatten-effect.h"
#include "clutter-private.h"

View File

@ -52,9 +52,7 @@
* #ClutterFlowLayout is available since Clutter 1.2
*/
#ifdef HAVE_CONFIG_H
#include "clutter-build-config.h"
#endif
#include <math.h>

View File

@ -74,54 +74,54 @@ struct _ClutterFlowLayoutClass
ClutterLayoutManagerClass parent_class;
};
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
GType clutter_flow_layout_get_type (void) G_GNUC_CONST;
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
ClutterLayoutManager * clutter_flow_layout_new (ClutterFlowOrientation orientation);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
void clutter_flow_layout_set_orientation (ClutterFlowLayout *layout,
ClutterFlowOrientation orientation);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
ClutterFlowOrientation clutter_flow_layout_get_orientation (ClutterFlowLayout *layout);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
void clutter_flow_layout_set_homogeneous (ClutterFlowLayout *layout,
gboolean homogeneous);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
gboolean clutter_flow_layout_get_homogeneous (ClutterFlowLayout *layout);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
void clutter_flow_layout_set_column_spacing (ClutterFlowLayout *layout,
gfloat spacing);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
gfloat clutter_flow_layout_get_column_spacing (ClutterFlowLayout *layout);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
void clutter_flow_layout_set_row_spacing (ClutterFlowLayout *layout,
gfloat spacing);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
gfloat clutter_flow_layout_get_row_spacing (ClutterFlowLayout *layout);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
void clutter_flow_layout_set_column_width (ClutterFlowLayout *layout,
gfloat min_width,
gfloat max_width);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
void clutter_flow_layout_get_column_width (ClutterFlowLayout *layout,
gfloat *min_width,
gfloat *max_width);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
void clutter_flow_layout_set_row_height (ClutterFlowLayout *layout,
gfloat min_height,
gfloat max_height);
CLUTTER_AVAILABLE_IN_1_2
CLUTTER_EXPORT
void clutter_flow_layout_get_row_height (ClutterFlowLayout *layout,
gfloat *min_height,
gfloat *max_height);
CLUTTER_AVAILABLE_IN_1_16
CLUTTER_EXPORT
void clutter_flow_layout_set_snap_to_grid (ClutterFlowLayout *layout,
gboolean snap_to_grid);
CLUTTER_AVAILABLE_IN_1_16
CLUTTER_EXPORT
gboolean clutter_flow_layout_get_snap_to_grid (ClutterFlowLayout *layout);
G_END_DECLS

Some files were not shown because too many files have changed in this diff Show More