muffin-6.4.1/ 0000775 0001750 0001750 00000000000 14723361714 011742 5 ustar fabio fabio muffin-6.4.1/debian/ 0000775 0001750 0001750 00000000000 14723361714 013164 5 ustar fabio fabio muffin-6.4.1/meson.build 0000664 0001750 0001750 00000035160 14723361714 014111 0 ustar fabio fabio project('muffin', 'c', version : '6.4.1', meson_version : '>=0.56.0', license : 'GPLv2+')
mutter_plugin_api_version = '3'
split_version = meson.project_version().split('.')
# Automatically increase API version each development cycle,
# starting with 0 in 3.23.x
api_version = 0
libmutter_api_version = '@0@'.format(api_version)
# generic version requirements
fribidi_req = '>= 1.0.0'
glib_req = '>= 2.67.3'
gi_req = '>= 0.9.5'
graphene_req = '>= 1.9.3'
gtk3_req = '>= 3.19.8'
gdk_pixbuf_req = '>= 2.0'
uprof_req = '>= 0.3'
pango_req = '>= 1.2.0'
cairo_req = '>= 1.10.0'
pangocairo_req = '>= 1.20'
json_glib_req = '>= 0.12.0'
upower_glib_req = '>= 0.99.0'
xcomposite_req = '>= 0.4'
xkbcommon_req = '>= 0.4.3'
xfixes_req = '>= 3'
xi_req = '>= 1.7.4'
xrandr_req = '>= 1.5.0'
libstartup_notification_req = '>= 0.7'
libcanberra_req = '>= 0.26'
libwacom_req = '>= 0.13'
atk_req = '>= 2.5.3'
# optional version requirements
udev_req = '>= 228'
gudev_req = '>= 232'
# wayland version requirements
wayland_server_req = '>= 1.13.0'
wayland_protocols_req = '>= 1.19'
# native backend version requirements
libinput_req = '>= 1.7'
gbm_req = '>= 10.3'
# screen cast version requirements
libpipewire_req = '>= 0.3.0'
# profiler requirements
sysprof_req = '>= 3.35.2'
gnome = import('gnome')
pkg = import('pkgconfig')
i18n = import('i18n')
cc = meson.get_compiler('c')
prefix = get_option('prefix')
bindir = join_paths(prefix, get_option('bindir'))
datadir = join_paths(prefix, get_option('datadir'))
libdir = join_paths(prefix, get_option('libdir'))
libexecdir = join_paths(prefix, get_option('libexecdir'))
includedir = join_paths(prefix, get_option('includedir'))
sysconfdir = get_option('sysconfdir')
pkgname = '@0@'.format(meson.project_name())
pkgdatadir = join_paths(datadir, pkgname)
pkglibdir = join_paths(libdir, pkgname)
pkgincludedir = join_paths(includedir, pkgname)
pcdir = join_paths(libdir, 'pkgconfig')
gettext_package = meson.project_name()
localedir = join_paths(datadir, 'locale')
libmutter_name = 'muffin'
mutter_installed_tests_datadir = join_paths(
datadir, 'installed-tests', libmutter_name)
mutter_installed_tests_libexecdir = join_paths(
libexecdir, 'installed-tests', libmutter_name)
m_dep = cc.find_library('m', required: true)
x11_dep = dependency('x11')
graphene_dep = dependency('graphene-gobject-1.0', version: graphene_req)
gtk3_dep = dependency('gtk+-3.0', version: gtk3_req)
gdk_pixbuf_dep = dependency('gdk-pixbuf-2.0')
pango_dep = dependency('pango', version: pango_req)
cairo_dep = dependency('cairo', version: cairo_req)
cairo_gobject_dep = dependency('cairo-gobject', version: cairo_req)
pangocairo_dep = dependency('pangocairo', version: pangocairo_req)
fribidi_dep = dependency('fribidi', version: fribidi_req)
glib_dep = dependency('glib-2.0', version: glib_req)
gio_dep = dependency('gio-unix-2.0', version: glib_req)
gio_unix_dep = dependency('gio-unix-2.0', version: glib_req)
gobject_dep = dependency('gobject-2.0', version: glib_req)
gthread_dep = dependency('gobject-2.0', version: glib_req)
gmodule_no_export_dep = dependency('gmodule-no-export-2.0', version: glib_req)
json_glib_dep = dependency('json-glib-1.0', version: json_glib_req)
cinnamon_desktop_dep = dependency('cinnamon-desktop', version: '>= 5.3')
xcomposite_dep = dependency('xcomposite', version: xcomposite_req)
xcursor_dep = dependency('xcursor')
xdamage_dep = dependency('xdamage')
xext_dep = dependency('xext')
xfixes_dep = dependency('xfixes', version: xfixes_req)
xi_dep = dependency('xi', version: xi_req)
xtst_dep = dependency('xtst')
xkbfile_dep = dependency('xkbfile')
xkeyboard_config_dep = dependency('xkeyboard-config')
xkbcommon_dep = dependency('xkbcommon', version: xkbcommon_req)
xkbcommon_x11_dep = dependency('xkbcommon-x11')
xrender_dep = dependency('xrender')
x11_xcb_dep = dependency('x11-xcb')
xrandr_dep = dependency('xrandr', version: xrandr_req)
xcb_randr_dep = dependency('xcb-randr')
xcb_res_dep = dependency('xcb-res')
xinerama_dep = dependency('xinerama')
xau_dep = dependency('xau')
ice_dep = dependency('ice')
atk_dep = dependency('atk', version: atk_req)
libcanberra_dep = dependency('libcanberra', version: libcanberra_req)
dbus_dep = dependency('dbus-1')
# For now always require X11 support
have_x11 = true
have_gl = get_option('opengl')
if have_gl
gl_dep = dependency('gl')
gl_libname = get_option('opengl_libname')
endif
have_egl = get_option('egl')
if have_egl
egl_dep = dependency('egl')
endif
have_glx = get_option('glx')
if have_glx
if not have_gl
error('GLX support requires OpenGL to be enabled')
endif
endif
have_egl_xlib = have_egl and have_x11
have_gles2 = get_option('gles2')
if have_gles2
gles2_dep = dependency('glesv2')
gles2_libname = get_option('gles2_libname')
if not have_egl
error('GLESv2 support requires EGL to be enabled')
endif
endif
have_wayland = get_option('wayland')
if have_wayland
wayland_server_dep = dependency('wayland-server', version: wayland_server_req)
wayland_client_dep = dependency('wayland-client', version: wayland_server_req)
wayland_protocols_dep = dependency('wayland-protocols',
version: wayland_protocols_req)
wayland_egl_dep = dependency('wayland-egl')
if not have_egl
error('Wayland support requires EGL to be enabled')
endif
endif
have_libgudev = get_option('udev')
if have_libgudev
libudev_dep = dependency('libudev', version: udev_req)
gudev_dep = dependency('gudev-1.0', version: gudev_req)
endif
have_native_backend = get_option('native_backend')
if have_native_backend
libdrm_dep = dependency('libdrm')
libgbm_dep = dependency('gbm', version: gbm_req)
libinput_dep = dependency('libinput', version: libinput_req)
libsystemd_dep = dependency('libsystemd', required: false)
if libsystemd_dep.found()
logind_provider_dep = libsystemd_dep
else
logind_provider_dep = dependency('libelogind')
endif
if not have_egl
error('The native backend requires EGL to be enabled')
endif
if not have_gles2
error('The native backend requires GLESv2 to be enabled')
endif
if not have_libgudev
error('The native backend requires udev to be enabled')
endif
endif
have_egl_device = get_option('egl_device')
have_wayland_eglstream = get_option('wayland_eglstream')
if have_wayland_eglstream
wayland_eglstream_protocols_dep = dependency('wayland-eglstream-protocols')
dl_dep = cc.find_library('dl', required: true)
if not have_wayland
error('Wayland EGLStream support requires Wayland to be enabled')
endif
endif
default_driver = get_option('default_driver')
have_sm = get_option('sm')
if have_sm
sm_dep = dependency('sm')
endif
have_libwacom = get_option('libwacom')
if have_libwacom
libwacom_dep = dependency('libwacom', version: libwacom_req)
endif
have_pango_ft2 = get_option('pango_ft2')
if have_pango_ft2
pangoft2_dep = dependency('pangoft2')
endif
have_startup_notification = get_option('startup_notification')
if have_startup_notification
libstartup_notification_dep = dependency('libstartup-notification-1.0',
version: libstartup_notification_req)
endif
have_remote_desktop = get_option('remote_desktop')
if have_remote_desktop
libpipewire_dep = dependency('libpipewire-0.3', version: libpipewire_req)
endif
have_introspection = get_option('introspection')
if have_introspection
gobject_introspection_dep = dependency('gobject-introspection-1.0')
introspection_args = [
'--quiet',
'-U_GNU_SOURCE',
]
endif
have_tests = get_option('tests')
have_core_tests = false
have_cogl_tests = false
have_clutter_tests = false
have_installed_tests = false
if have_tests
have_core_tests = get_option('core_tests')
if have_core_tests
if not have_wayland
error('Tests require Wayland to be enabled')
endif
endif
have_cogl_tests = get_option('cogl_tests')
have_clutter_tests = get_option('clutter_tests')
have_installed_tests = get_option('installed_tests')
endif
have_profiler = get_option('profiler')
if have_profiler
sysprof_dep = dependency('sysprof-capture-3', version: sysprof_req)
endif
required_functions = [
'ffs',
'clz',
'memmem',
]
foreach function : required_functions
if not cc.has_function(function)
error('Required function ' + function + ' missing')
endif
endforeach
if host_machine.cpu_family() == 'x86'
add_project_arguments('-ffloat-store', language: 'c')
endif
add_project_arguments('-D_GNU_SOURCE', language: 'c')
buildtype = get_option('buildtype')
if buildtype != 'plain'
all_warnings = [
'-fno-strict-aliasing',
'-Wpointer-arith',
'-Wmissing-declarations',
'-Wimplicit-function-declaration',
'-Wformat=2',
'-Wformat-nonliteral',
'-Wformat-security',
'-Wstrict-prototypes',
'-Wmissing-prototypes',
'-Wnested-externs',
'-Wold-style-definition',
'-Wundef',
'-Wunused',
'-Wcast-align',
'-Wmissing-noreturn',
'-Wmissing-format-attribute',
'-Wmissing-include-dirs',
'-Wlogical-op',
'-Wignored-qualifiers',
'-Werror=redundant-decls',
'-Werror=implicit',
'-Werror=nonnull',
'-Werror=init-self',
'-Werror=main',
'-Werror=missing-braces',
'-Werror=sequence-point',
'-Werror=return-type',
'-Werror=trigraphs',
'-Werror=array-bounds',
'-Werror=write-strings',
'-Werror=address',
'-Werror=int-to-pointer-cast',
'-Werror=pointer-to-int-cast',
'-Werror=empty-body',
'-Werror=write-strings',
]
supported_warnings = cc.get_supported_arguments(all_warnings)
add_project_arguments(supported_warnings, language: 'c')
endif
if get_option('debug')
debug_c_args = [
'-DG_ENABLE_DEBUG',
'-fno-omit-frame-pointer'
]
supported_debug_c_args = cc.get_supported_arguments(debug_c_args)
add_project_arguments(supported_debug_c_args, language: 'c')
endif
cc.compiles('void main (void) { __builtin_ffsl (0); __builtin_popcountl (0); }')
cdata = configuration_data()
cdata.set_quoted('GETTEXT_PACKAGE', gettext_package)
cdata.set_quoted('VERSION', meson.project_version())
cdata.set_quoted('PACKAGE_VERSION', meson.project_version())
cdata.set('HAVE_EGL', have_egl)
cdata.set('HAVE_WAYLAND', have_wayland)
cdata.set('HAVE_NATIVE_BACKEND', have_native_backend)
cdata.set('HAVE_REMOTE_DESKTOP', have_remote_desktop)
cdata.set('HAVE_EGL_DEVICE', have_egl_device)
cdata.set('HAVE_WAYLAND_EGLSTREAM', have_wayland_eglstream)
cdata.set('HAVE_LIBGUDEV', have_libgudev)
cdata.set('HAVE_LIBWACOM', have_libwacom)
cdata.set('HAVE_SM', have_sm)
cdata.set('HAVE_STARTUP_NOTIFICATION', have_startup_notification)
cdata.set('HAVE_INTROSPECTION', have_introspection)
cdata.set('HAVE_PROFILER', have_profiler)
xkb_base = xkeyboard_config_dep.get_variable(pkgconfig: 'xkb_base')
cdata.set_quoted('XKB_BASE', xkb_base)
if cc.has_header_symbol('sys/prctl.h', 'prctl')
cdata.set('HAVE_SYS_PRCTL', 1)
endif
have_xwayland_initfd = false
if have_wayland
xwayland_dep = dependency('xwayland', required: false)
xwayland_path = get_option('xwayland_path')
if xwayland_path == ''
if xwayland_dep.found()
xwayland_path = xwayland_dep.get_pkgconfig_variable('xwayland')
else
xwayland_path = find_program('Xwayland').full_path()
endif
endif
cdata.set_quoted('XWAYLAND_PATH', xwayland_path)
# For Xwayland authority file generation.
if cc.has_header_symbol('sys/random.h', 'getrandom')
cdata.set('HAVE_SYS_RANDOM', 1)
elif cc.has_header_symbol('linux/random.h', 'getrandom')
cdata.set('HAVE_LINUX_RANDOM', 1)
else
error('Required function getrandom not found')
endif
# For Xwayland -initfd usage
use_initfd = get_option('xwayland_initfd')
if xwayland_dep.found()
xwayland_supports_initfd = xwayland_dep.get_pkgconfig_variable('have_initfd') == 'true'
else
xwayland_options = run_command(xwayland_path, '-help')
xwayland_supports_initfd = xwayland_options.stderr().contains('-initfd')
endif
if use_initfd.auto()
have_xwayland_initfd = xwayland_supports_initfd
else
have_xwayland_initfd = use_initfd.enabled()
endif
if (have_xwayland_initfd)
cdata.set('HAVE_XWAYLAND_INITFD', 1)
endif
endif
#xwayland_grab_default_access_rules = get_option('xwayland_grab_default_access_rules')
xwayland_grab_default_access_rules = ''
cdata.set_quoted('XWAYLAND_GRAB_DEFAULT_ACCESS_RULES',
xwayland_grab_default_access_rules)
cdata.set_quoted('MUTTER_PLUGIN_DIR', join_paths(pkglibdir, 'plugins'))
cdata.set_quoted('MUTTER_LOCALEDIR', localedir)
cdata.set_quoted('MUTTER_LIBEXECDIR', libexecdir)
cdata.set_quoted('MUTTER_PKGDATADIR', pkgdatadir)
config_h = configure_file(
input: 'config.h.meson',
output: 'config.h',
configuration: cdata
)
top_includepath = include_directories('.')
subdir('cogl')
subdir('clutter')
subdir('data')
subdir('src')
subdir('po')
subdir('doc/man')
meson.add_install_script('meson/meson-postinstall.sh')
output = [
'',
'',
' Mutter ' + meson.project_version(),
' ===============',
'',
' Prefix....................... ' + prefix,
' libexecdir................... ' + libexecdir,
' pkgdatadir................... ' + pkgdatadir,
'',
' Rendering APIs:',
'',
' OpenGL................... ' + have_gl.to_string(),
' GLES2.................... ' + have_gles2.to_string(),
' EGL...................... ' + have_egl.to_string(),
' GLX...................... ' + have_glx.to_string(),
'',
' Options:',
'',
' Wayland.................. ' + have_wayland.to_string(),
' Wayland EGLStream........ ' + have_wayland_eglstream.to_string(),
' Native Backend........... ' + have_native_backend.to_string(),
' EGL Device............... ' + have_egl_device.to_string(),
' Default driver........... ' + default_driver,
' Remote desktop........... ' + have_remote_desktop.to_string(),
' gudev.................... ' + have_libgudev.to_string(),
' Wacom.................... ' + have_libwacom.to_string(),
' SM....................... ' + have_sm.to_string(),
' Startup notification..... ' + have_startup_notification.to_string(),
' Introspection............ ' + have_introspection.to_string(),
' Profiler................. ' + have_profiler.to_string(),
' Xwayland initfd.......... ' + have_xwayland_initfd.to_string(),
'',
' Tests:',
'',
' Enabled.................. ' + have_tests.to_string(),
' Core tests............... ' + have_core_tests.to_string(),
' Cogl tests............... ' + have_cogl_tests.to_string(),
' Clutter tests............ ' + have_clutter_tests.to_string(),
' Installed tests.......... ' + have_installed_tests.to_string(),
'',
' Now type \'ninja -C ' + meson.project_build_root() + '\' to build ' + meson.project_name(),
'',
'',
]
message('\n'.join(output))
muffin-6.4.1/.gitignore 0000664 0001750 0001750 00000000363 14723361714 013734 0 ustar fabio fabio debian/*.debhelper.log
debian/*.substvars
debian/.debhelper/
debian/debhelper-build-stamp
debian/files
debian/gir1.2-meta-muffin-0.0/
debian/libmuffin-dev/
debian/libmuffin0/
debian/muffin-common/
debian/muffin-dbg/
debian/muffin/
debian/tmp/
muffin-6.4.1/mutter.doap 0000664 0001750 0001750 00000005265 14723361714 014137 0 ustar fabio fabio
mutter
Window and compositing manager based on Clutter
Mutter is a window and compositing manager that displays and
manages your desktop via OpenGL. Mutter combines a sophisticated display engine
using the Clutter toolkit with solid window-management logic inherited from the
Metacity window manager.
While Mutter can be used stand-alone, it is primarily intended to be used as
the display core of a larger system such as GNOME Shell. For this reason,
Mutter is very extensible via plugins, which are used both to add fancy visual
effects and to rework the window management behaviors to meet the needs of the
environment.
C
Tomas Frydrych
tomasf
Owen Taylor
otaylor
Jonas Ådahl
jadahl
Carlos Garnacho
carlosg
Georges Basile Stavracas Neto
gbsneto
Florian Müllner
fmuellner
muffin-6.4.1/data/ 0000775 0001750 0001750 00000000000 14723361714 012653 5 ustar fabio fabio muffin-6.4.1/data/meson.build 0000664 0001750 0001750 00000002371 14723361714 015020 0 ustar fabio fabio msgfmt = find_program('msgfmt')
custom_target('muffin.desktop',
input: 'muffin.desktop.in',
output: 'muffin.desktop',
command: [
msgfmt,
'--desktop', '--template',
'@INPUT@',
'-d', join_paths(meson.project_source_root(), 'po'),
'-o', '@OUTPUT@'
],
install: true,
install_dir: join_paths(datadir, 'applications'),
)
#xwayland_grab_default_access_rules = get_option('xwayland_grab_default_access_rules')
xwayland_grab_default_access_rules = ''
gschema_config = configuration_data()
gschema_config.set('GETTEXT_DOMAIN', meson.project_name())
gschema_config.set('XWAYLAND_GRAB_DEFAULT_ACCESS_RULES',
xwayland_grab_default_access_rules)
schemadir = join_paths(datadir, 'glib-2.0', 'schemas')
configure_file(
input: 'org.cinnamon.muffin.gschema.xml.in',
output: 'org.cinnamon.muffin.gschema.xml',
configuration: gschema_config,
install_dir: schemadir
)
configure_file(
input: 'org.cinnamon.muffin.wayland.gschema.xml.in',
output: 'org.cinnamon.muffin.wayland.gschema.xml',
configuration: gschema_config,
install_dir: schemadir
)
configure_file(
input: 'org.cinnamon.muffin.x11.gschema.xml.in',
output: 'org.cinnamon.muffin.x11.gschema.xml',
configuration: gschema_config,
install_dir: schemadir
)
muffin-6.4.1/data/org.cinnamon.muffin.wayland.gschema.xml.in 0000664 0001750 0001750 00000010311 14723361714 022715 0 ustar fabio fabio
F1']]]>
Switch to VT 1
F2']]]>
Switch to VT 2
F3']]]>
Switch to VT 3
F4']]]>
Switch to VT 4
F5']]]>
Switch to VT 5
F6']]]>
Switch to VT 6
F7']]]>
Switch to VT 7
F8']]]>
Switch to VT 8
F9']]]>
Switch to VT 9
F10']]]>
Switch to VT 10
F11']]]>
Switch to VT 11
F12']]]>
Switch to VT 12
Escape']]]>
Re-enable shortcuts
false
Allow X11 grabs to lock keyboard focus with Xwayland
Allow all keyboard events to be routed to X11 “override redirect”
windows with a grab when running in Xwayland.
This option is to support X11 clients which map an “override redirect”
window (which do not receive keyboard focus) and issue a keyboard
grab to force all keyboard events to that window.
This option is seldom used and has no effect on regular X11 windows
which can receive keyboard focus under normal circumstances.
For a X11 grab to be taken into account under Wayland, the client must
also either send a specific X11 ClientMessage to the root window or be
among the applications white-listed in key “xwayland-grab-access-rules”.
[]
Xwayland applications allowed to issue keyboard grabs
List the resource names or resource class of X11 windows either
allowed or not allowed to issue X11 keyboard grabs under Xwayland.
The resource name or resource class of a given X11 window can be
obtained using the command “xprop WM_CLASS”.
Wildcards “*” and jokers “?” in the values are supported.
Values starting with “!” are blacklisted, which has precedence over
the whitelist, to revoke applications from the default system list.
The default system list includes the following applications:
“@XWAYLAND_GRAB_DEFAULT_ACCESS_RULES@”
Users can break an existing grab by using the specific keyboard
shortcut defined by the keybinding key “restore-shortcuts”.
muffin-6.4.1/data/default_icon.png 0000664 0001750 0001750 00000002240 14723361714 016013 0 ustar fabio fabio PNG
IHDR 0 0 W bKGD pHYs tIME -IDATxYKnA }Ĭ}`p '! $!!H1*lw0
R[QS>feYnR8r]6ߴH;k&8 ;<}|紾8ǓǏ Z^oӗ2ꛞ^/]S~ "p[3ڄBrvv>H H Կvl c:Nר(uAUx| xDP)fT
uq3͠4 1I"p{]66 <"Ƃ2jH/ Vi5=0&i*'IJ 0JVD<HCBLe'nw`95NOV=2v;{'H'bQ{Z}
8,\#VR0{"!w4Dbx-#;Q9^9J TF&>vt䏛w6Bؗ4:-_ lQqA38js=S:merbpQ+$QgawJ {l:
>|5&p/!OX^ q eYf7n>Ec6 IENDB` muffin-6.4.1/data/muffin.desktop.in 0000664 0001750 0001750 00000000717 14723361714 016144 0 ustar fabio fabio [Desktop Entry]
Type=Application
Name=Muffin
Exec=muffin
NoDisplay=true
# name of loadable control center module
X-GNOME-WMSettingsModule=metacity
# name we put on the WM spec check window
X-GNOME-WMName=Muffin
# back compat only
X-GnomeWMSettingsLibrary=metacity
X-GNOME-Bugzilla-Bugzilla=GNOME
X-GNOME-Bugzilla-Product=muffin
X-GNOME-Bugzilla-Component=general
X-GNOME-Autostart-Phase=WindowManager
X-GNOME-Provides=windowmanager
X-GNOME-Autostart-Notify=true
muffin-6.4.1/data/org.cinnamon.muffin.x11.gschema.xml.in 0000664 0001750 0001750 00000002163 14723361714 021675 0 ustar fabio fabio
"scale-ui-down"
Choose the scaling mode to be used under X11 via Randr extension.
Supported methods are:
• “scale-up” — Scale everything up to the requested scale, shrinking
the UI. The applications will look blurry when scaling
at higher values and the resolution will be lowered.
• “scale-ui-down — Scale up the UI toolkits to the closest integer
scaling value upwards, while scale down the display
to match the requested scaling level.
It increases the resolution of the logical display.
muffin-6.4.1/data/org.cinnamon.muffin.gschema.xml.in 0000664 0001750 0001750 00000020345 14723361714 021267 0 ustar fabio fabio
''
DO NOT USE
Use keybinding mechanisms in cinnamon instead.
false
Attach modal dialogs
When true, instead of having independent titlebars, modal dialogs
appear attached to the titlebar of the parent window and are moved
together with the parent window.
true
Enable edge tiling when dropping windows on screen edges
If enabled, dropping windows on vertical screen edges maximizes them
vertically and resizes them horizontally to cover half of the available
area. Dropping windows on the top screen edge maximizes them completely.
false
Sets maximize as the tile action for the top edge of the screen
Makes tiling to the top maximize the window
false
Inverts the direction the left and right arrows take you when
you switch workspaces during a window drag
Changes left-right arrow keys to window-centric directions rather than
workspace-centric
false
Workspaces are managed dynamically
Determines whether workspaces are managed dynamically or
whether there’s a static number of workspaces (determined
by the num-workspaces key in org.cinnamon.desktop.wm.preferences).
false
Allow cycling through workspaces
Allows cycling through workspaces, going to the workspace at the other end
if you are at the left-most or right-most one.
false
Fullscreen windows are unredirected (i.e. they bypass compositing)
Determines whether fullscreen windows bypass compositing. False is better for vsync/screen-tearing, True gives games and apps i
false
Workspaces only on primary
Determines whether workspace switching should happen for windows
on all monitors or only for windows on the primary monitor.
false
No tab popup
Determines whether the use of popup and highlight frame should
be disabled for window cycling.
false
Delay focus changes until the pointer stops moving
If set to true, and the focus mode is either “sloppy” or “mouse”
then the focus will not be changed immediately when entering a
window, but only after the pointer stops moving.
10
Draggable border width
The amount of total draggable borders. If the theme’s visible
borders are not enough, invisible borders will be added to meet
this value.
false
Auto maximize nearly monitor sized windows
If enabled, new windows that are initially the size of the monitor
automatically get maximized.
false
Obsolete — not used
'automatic'
Window placement mode
The window placement mode indicates how new windows are positioned.
• “automatic” — the system chooses a location automatically based on
the space available on the desktop, or by a simple
cascade if there is no space
• “pointer” — new windows are placed according to the mouse pointer
position
• “manual” — the user must manually place the new window with the
mouse or keyboard.
• “center” — new windows are always put in the center of the active
screen of the monitor
'blend'
Background transition
The type of animation performed when changing background.
"none" means no animation at all.
"fade-in" means the old background switches to black and the new background appears with a fade-in effect.
"blend" means the old background disappears as the new background appears with a fade-in effect.
[]
Enable experimental features
Currently only 'x11-randr-fractional-scaling' is useful in Cinnamon
• “x11-randr-fractional-scaling” — enable fractional scaling under X11
using xrandr scaling. It might reduce
performances.
Does not require a restart.
['Control_L']
Modifier to use to locate the pointer
This key will initiate the “locate pointer” action.
5000
Timeout for check-alive ping
Number of milliseconds a client has to respond to a ping request in
order to not be detected as frozen. Using 0 will disable the alive check
completely.
false
Brings windows requiring attention to the current workspace
When enabled, if a window requires attention, it is brought to the current workspace.
[]
Select window from tab popup
[]
Cancel tab popup
muffin-6.4.1/COPYING 0000664 0001750 0001750 00000043254 14723361714 013005 0 ustar fabio fabio GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License.
muffin-6.4.1/config.h.meson 0000664 0001750 0001750 00000003336 14723361714 014505 0 ustar fabio fabio /* The prefix for our gettext translation domains. */
#mesondefine GETTEXT_PACKAGE
/* Version number of package */
#mesondefine VERSION
/* Version number of package */
#mesondefine PACKAGE_VERSION
/* Search path for plugins */
#mesondefine MUTTER_PLUGIN_DIR
/* */
#mesondefine MUTTER_LOCALEDIR
/* */
#mesondefine MUTTER_LIBEXECDIR
/* */
#mesondefine MUTTER_PKGDATADIR
/* Defined if EGL support is enabled */
#mesondefine HAVE_EGL
/* Defined if EGLDevice support is enabled */
#mesondefine HAVE_EGL_DEVICE
/* Defined if EGLStream support is enabled */
#mesondefine HAVE_WAYLAND_EGLSTREAM
/* Building with gudev for device type detection */
#mesondefine HAVE_LIBGUDEV
/* Building with libwacom for advanced tablet management */
#mesondefine HAVE_LIBWACOM
/* Define if you want to enable the native (KMS) backend based on systemd */
#mesondefine HAVE_NATIVE_BACKEND
/* Define if you want to enable Wayland support */
#mesondefine HAVE_WAYLAND
/* Defined if screen cast and remote desktop support is enabled */
#mesondefine HAVE_REMOTE_DESKTOP
/* Building with SM support */
#mesondefine HAVE_SM
/* Building with startup notification support */
#mesondefine HAVE_STARTUP_NOTIFICATION
/* Building with Sysprof profiling suport */
#mesondefine HAVE_PROFILER
/* Path to Xwayland executable */
#mesondefine XWAYLAND_PATH
/* Xwayland applications allowed to issue keyboard grabs */
#mesondefine XWAYLAND_GRAB_DEFAULT_ACCESS_RULES
/* XKB base prefix */
#mesondefine XKB_BASE
/* Whether exists and it defines prctl() */
#mesondefine HAVE_SYS_PRCTL
/* Either or */
#mesondefine HAVE_SYS_RANDOM
#mesondefine HAVE_LINUX_RANDOM
/* Whether Xwayland has -initfd option */
#mesondefine HAVE_XWAYLAND_INITFD
muffin-6.4.1/clutter/ 0000775 0001750 0001750 00000000000 14723361714 013424 5 ustar fabio fabio muffin-6.4.1/clutter/meson.build 0000664 0001750 0001750 00000003152 14723361714 015567 0 ustar fabio fabio clutter_includesubdir = join_paths(pkgname, 'clutter')
clutter_includedir = join_paths(includedir, clutter_includesubdir)
clutter_includepath = include_directories('.', 'clutter')
clutter_includes = [clutter_includepath, cogl_includepath]
clutter_c_args = [
'-DCLUTTER_SYSCONFDIR="@0@"'.format(join_paths(prefix, sysconfdir)),
'-DCLUTTER_COMPILATION=1',
'-DCOGL_DISABLE_DEPRECATION_WARNINGS',
'-DG_LOG_DOMAIN="Clutter"',
]
clutter_debug_c_args = []
if get_option('debug')
clutter_debug_c_args += [
'-DCLUTTER_ENABLE_DEBUG',
'-fno-omit-frame-pointer'
]
elif buildtype != 'plain'
clutter_debug_c_args += [
'-DG_DISABLE_ASSERT',
'-DG_DISABLE_CHECKS',
'-DG_DISABLE_CAST_CHECKS',
]
endif
supported_clutter_debug_c_args = cc.get_supported_arguments(clutter_debug_c_args)
clutter_c_args += clutter_debug_c_args
clutter_pkg_deps = [
atk_dep,
cairo_gobject_dep,
glib_dep,
gobject_dep,
gio_dep,
json_glib_dep,
pango_dep,
]
clutter_pkg_private_deps = [
fribidi_dep,
gdk_pixbuf_dep,
gthread_dep,
gmodule_no_export_dep,
pangocairo_dep,
]
if have_pango_ft2
clutter_pkg_private_deps += [
pangoft2_dep,
]
endif
if have_wayland
clutter_pkg_private_deps += [
wayland_egl_dep,
wayland_server_dep,
]
endif
if have_x11
clutter_pkg_deps += [
x11_dep,
]
clutter_pkg_private_deps += [
xext_dep,
xdamage_dep,
xcomposite_dep,
xtst_dep,
xi_dep,
]
endif
if have_libwacom
clutter_pkg_private_deps += [
libwacom_dep,
]
endif
clutter_deps = [
clutter_pkg_deps,
clutter_pkg_private_deps,
libmutter_cogl_dep,
m_dep
]
subdir('clutter')
muffin-6.4.1/clutter/.gitignore 0000664 0001750 0001750 00000003074 14723361714 015420 0 ustar fabio fabio ABOUT-NLS
INSTALL
Makefile
Makefile.in
aclocal.m4
autom4te.cache
compile
*.pc
.deps
.libs
*.o
*.lo
*.la
*.gcov
.dirstamp
README
stamp-enum-types
stamp-marshal
tags
/ChangeLog*
clutter-build-config.h
clutter-build-config.h.in
clutter-config.h
clutter-enum-types.[ch]
clutter-marshal.[ch]
gcov-report.txt
clutter-json.h
clutter-lcov.info
clutter-lcov
!/build/autotools/introspection.m4
!/build/autotools/as-linguas.m4
!/build/autotools/as-compiler-flag.m4
!/build/autotools/glibtests.m4
/build/autotools/*.m4
/build/test-driver
*.gir
*.typelib
*.gcda
*.gcno
config.*
configure
depcomp
/doc/cookbook/*.pdf
/doc/cookbook/html
/doc/cookbook/*.stamp
/doc/cookbook/clutter-cookbook.xml
/doc/cookbook/clutter-cookbook.html
doc/reference/clutter-*.txt
!/doc/reference/clutter-sections.txt
doc/reference/html
doc/reference/tmpl
doc/reference/xml
doc/reference/clutter.args
doc/reference/clutter.hierarchy
doc/reference/clutter.interfaces
doc/reference/clutter.prerequisites
doc/reference/clutter.signals
doc/reference/clutter-docs.xml
doc/reference/*.stamp
doc/reference/*.bak
doc/reference/*.log
doc/reference/gtkdoc-check.*
gtk-doc.make
install-sh
libtool
ltmain.sh
missing
mkinstalldirs
stamp-h1
TAGS
/tests/tools/disable-npots.sh
/tests/conform/test-launcher.sh
/tests/interactive/wrapper.sh
/po/POTFILES
/po/clutter-1.0.pot
/po/*.gmo
/po/Makefile.in.in
/po/Makevars.template
/po/Rules-quot
/po/boldquot.sed
/po/en@boldquot.header
/po/en@quot.header
/po/insert-header.sin
/po/quot.sed
/po/remove-potcdate.sin
/po/remove-potcdate.sed
/po/stamp-po
*.swn
*.swo
*.swp
*~
*.orig
*.rej
.DS_Store
.testlogs-*
muffin-6.4.1/clutter/clutter/ 0000775 0001750 0001750 00000000000 14723361714 015106 5 ustar fabio fabio muffin-6.4.1/clutter/clutter/clutter-path.c 0000664 0001750 0001750 00000120476 14723361714 017700 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum
*
* Copyright (C) 2008 Intel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*/
/**
* SECTION:clutter-path
* @short_description: An object describing a path with straight lines
* and bezier curves.
*
* A #ClutterPath contains a description of a path consisting of
* straight lines and bezier curves.
*
* The path consists of a series of nodes. Each node is one of the
* following four types:
*
* - %CLUTTER_PATH_MOVE_TO, changes the position of the path to the
* given pair of coordinates. This is usually used as the first node
* of a path to mark the start position. If it is used in the middle
* of a path then the path will be disjoint and the actor will appear
* to jump to the new position when animated.
* - %CLUTTER_PATH_LINE_TO, creates a straight line from the previous
* point to the given point.
* - %CLUTTER_PATH_CURVE_TO, creates a bezier curve. The end of the
* last node is used as the first control point and the three
* subsequent coordinates given in the node as used as the other three.
* -%CLUTTER_PATH_CLOSE, creates a straight line from the last node to
* the last %CLUTTER_PATH_MOVE_TO node. This can be used to close a
* path so that it will appear as a loop when animated.
*
* The first three types have the corresponding relative versions
* %CLUTTER_PATH_REL_MOVE_TO, %CLUTTER_PATH_REL_LINE_TO and
* %CLUTTER_PATH_REL_CURVE_TO. These are exactly the same except the
* coordinates are given relative to the previous node instead of as
* direct screen positions.
*
* You can build a path using the node adding functions such as
* clutter_path_add_line_to(). Alternatively the path can be described
* in a string using a subset of the SVG path syntax. See
* clutter_path_add_string() for details.
*
* #ClutterPath is available since Clutter 1.0
*/
#include "clutter-build-config.h"
#include
#include
#include
#include
#include "clutter-path.h"
#include "clutter-types.h"
#include "clutter-bezier.h"
#include "clutter-private.h"
#define CLUTTER_PATH_NODE_TYPE_IS_VALID(t) \
((((t) & ~CLUTTER_PATH_RELATIVE) >= CLUTTER_PATH_MOVE_TO \
&& ((t) & ~CLUTTER_PATH_RELATIVE) <= CLUTTER_PATH_CURVE_TO) \
|| (t) == CLUTTER_PATH_CLOSE)
enum
{
PROP_0,
PROP_DESCRIPTION,
PROP_LENGTH,
PROP_LAST
};
static GParamSpec *obj_props[PROP_LAST];
typedef struct _ClutterPathNodeFull ClutterPathNodeFull;
struct _ClutterPathNodeFull
{
ClutterPathNode k;
ClutterBezier *bezier;
guint length;
};
struct _ClutterPathPrivate
{
GSList *nodes, *nodes_tail;
gboolean nodes_dirty;
guint total_length;
};
/* Character tests that don't pay attention to the locale */
#define clutter_path_isspace(ch) memchr (" \f\n\r\t\v", (ch), 6)
#define clutter_path_isdigit(ch) ((ch) >= '0' && (ch) <= '9')
static ClutterPathNodeFull *clutter_path_node_full_new (void);
static void clutter_path_node_full_free (ClutterPathNodeFull *node);
static void clutter_path_finalize (GObject *object);
static void clutter_value_transform_path_string (const GValue *src,
GValue *dest);
static void clutter_value_transform_string_path (const GValue *src,
GValue *dest);
G_DEFINE_BOXED_TYPE (ClutterPathNode, clutter_path_node,
clutter_path_node_copy,
clutter_path_node_free);
G_DEFINE_TYPE_WITH_CODE (ClutterPath,
clutter_path,
G_TYPE_INITIALLY_UNOWNED,
G_ADD_PRIVATE (ClutterPath)
CLUTTER_REGISTER_VALUE_TRANSFORM_TO (G_TYPE_STRING, clutter_value_transform_path_string)
CLUTTER_REGISTER_VALUE_TRANSFORM_FROM (G_TYPE_STRING, clutter_value_transform_string_path));
static void
clutter_path_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterPath *path = CLUTTER_PATH (gobject);
switch (prop_id)
{
case PROP_DESCRIPTION:
g_value_take_string (value, clutter_path_get_description (path));
break;
case PROP_LENGTH:
g_value_set_uint (value, clutter_path_get_length (path));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_path_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterPath *path = CLUTTER_PATH (gobject);
switch (prop_id)
{
case PROP_DESCRIPTION:
if (!clutter_path_set_description (path, g_value_get_string (value)))
g_warning ("Invalid path description");
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_path_class_init (ClutterPathClass *klass)
{
GObjectClass *gobject_class = (GObjectClass *) klass;
GParamSpec *pspec;
gobject_class->get_property = clutter_path_get_property;
gobject_class->set_property = clutter_path_set_property;
gobject_class->finalize = clutter_path_finalize;
pspec = g_param_spec_string ("description",
"Description",
"SVG-style description of the path",
"",
CLUTTER_PARAM_READWRITE);
obj_props[PROP_DESCRIPTION] = pspec;
g_object_class_install_property (gobject_class, PROP_DESCRIPTION, pspec);
pspec = g_param_spec_uint ("length",
"Length",
"An approximation of the total length "
"of the path.",
0, G_MAXUINT, 0,
CLUTTER_PARAM_READABLE);
obj_props[PROP_LENGTH] = pspec;
g_object_class_install_property (gobject_class, PROP_LENGTH, pspec);
}
static void
clutter_path_init (ClutterPath *self)
{
self->priv = clutter_path_get_instance_private (self);
}
static void
clutter_value_transform_path_string (const GValue *src,
GValue *dest)
{
gchar *string = clutter_path_get_description (src->data[0].v_pointer);
g_value_take_string (dest, string);
}
static void
clutter_value_transform_string_path (const GValue *src,
GValue *dest)
{
ClutterPath *new_path;
new_path = clutter_path_new_with_description (g_value_get_string (src));
g_value_take_object (dest, new_path);
}
static void
clutter_path_finalize (GObject *object)
{
ClutterPath *self = (ClutterPath *) object;
clutter_path_clear (self);
G_OBJECT_CLASS (clutter_path_parent_class)->finalize (object);
}
/**
* clutter_path_new:
*
* Creates a new #ClutterPath instance with no nodes.
*
* Return value: the newly created #ClutterPath
*
* Since: 1.0
*/
ClutterPath *
clutter_path_new (void)
{
ClutterPath *self = g_object_new (CLUTTER_TYPE_PATH, NULL);
return self;
}
/**
* clutter_path_new_with_description:
* @desc: a string describing the path
*
* Creates a new #ClutterPath instance with the nodes described in
* @desc. See clutter_path_add_string() for details of the format of
* the string.
*
* Return value: the newly created #ClutterPath
*
* Since: 1.0
*/
ClutterPath *
clutter_path_new_with_description (const gchar *desc)
{
return g_object_new (CLUTTER_TYPE_PATH,
"description", desc,
NULL);
}
/**
* clutter_path_clear:
* @path: a #ClutterPath
*
* Removes all nodes from the path.
*
* Since: 1.0
*/
void
clutter_path_clear (ClutterPath *path)
{
ClutterPathPrivate *priv = path->priv;
g_slist_free_full (priv->nodes, (GDestroyNotify) clutter_path_node_full_free);
priv->nodes = priv->nodes_tail = NULL;
priv->nodes_dirty = TRUE;
}
/* Takes ownership of the node */
static void
clutter_path_add_node_full (ClutterPath *path,
ClutterPathNodeFull *node)
{
ClutterPathPrivate *priv = path->priv;
GSList *new_node;
new_node = g_slist_prepend (NULL, node);
if (priv->nodes_tail == NULL)
priv->nodes = new_node;
else
priv->nodes_tail->next = new_node;
priv->nodes_tail = new_node;
priv->nodes_dirty = TRUE;
}
/* Helper function to make the rest of teh add_* functions shorter */
static void
clutter_path_add_node_helper (ClutterPath *path,
ClutterPathNodeType type,
int num_coords,
...)
{
ClutterPathNodeFull *node;
int i;
va_list ap;
node = clutter_path_node_full_new ();
node->k.type = type;
va_start (ap, num_coords);
for (i = 0; i < num_coords; i++)
{
node->k.points[i].x = va_arg (ap, gint);
node->k.points[i].y = va_arg (ap, gint);
}
va_end (ap);
clutter_path_add_node_full (path, node);
}
/**
* clutter_path_add_move_to:
* @path: a #ClutterPath
* @x: the x coordinate
* @y: the y coordinate
*
* Adds a %CLUTTER_PATH_MOVE_TO type node to the path. This is usually
* used as the first node in a path. It can also be used in the middle
* of the path to cause the actor to jump to the new coordinate.
*
* Since: 1.0
*/
void
clutter_path_add_move_to (ClutterPath *path,
gint x,
gint y)
{
g_return_if_fail (CLUTTER_IS_PATH (path));
clutter_path_add_node_helper (path, CLUTTER_PATH_MOVE_TO, 1, x, y);
}
/**
* clutter_path_add_rel_move_to:
* @path: a #ClutterPath
* @x: the x coordinate
* @y: the y coordinate
*
* Same as clutter_path_add_move_to() except the coordinates are
* relative to the previous node.
*
* Since: 1.0
*/
void
clutter_path_add_rel_move_to (ClutterPath *path,
gint x,
gint y)
{
g_return_if_fail (CLUTTER_IS_PATH (path));
clutter_path_add_node_helper (path, CLUTTER_PATH_REL_MOVE_TO, 1, x, y);
}
/**
* clutter_path_add_line_to:
* @path: a #ClutterPath
* @x: the x coordinate
* @y: the y coordinate
*
* Adds a %CLUTTER_PATH_LINE_TO type node to the path. This causes the
* actor to move to the new coordinates in a straight line.
*
* Since: 1.0
*/
void
clutter_path_add_line_to (ClutterPath *path,
gint x,
gint y)
{
g_return_if_fail (CLUTTER_IS_PATH (path));
clutter_path_add_node_helper (path, CLUTTER_PATH_LINE_TO, 1, x, y);
}
/**
* clutter_path_add_rel_line_to:
* @path: a #ClutterPath
* @x: the x coordinate
* @y: the y coordinate
*
* Same as clutter_path_add_line_to() except the coordinates are
* relative to the previous node.
*
* Since: 1.0
*/
void
clutter_path_add_rel_line_to (ClutterPath *path,
gint x,
gint y)
{
g_return_if_fail (CLUTTER_IS_PATH (path));
clutter_path_add_node_helper (path, CLUTTER_PATH_REL_LINE_TO, 1, x, y);
}
/**
* clutter_path_add_curve_to:
* @path: a #ClutterPath
* @x_1: the x coordinate of the first control point
* @y_1: the y coordinate of the first control point
* @x_2: the x coordinate of the second control point
* @y_2: the y coordinate of the second control point
* @x_3: the x coordinate of the third control point
* @y_3: the y coordinate of the third control point
*
* Adds a %CLUTTER_PATH_CURVE_TO type node to the path. This causes
* the actor to follow a bezier from the last node to (@x_3, @y_3) using
* (@x_1, @y_1) and (@x_2,@y_2) as control points.
*
* Since: 1.0
*/
void
clutter_path_add_curve_to (ClutterPath *path,
gint x_1,
gint y_1,
gint x_2,
gint y_2,
gint x_3,
gint y_3)
{
g_return_if_fail (CLUTTER_IS_PATH (path));
clutter_path_add_node_helper (path, CLUTTER_PATH_CURVE_TO, 3,
x_1, y_1,
x_2, y_2,
x_3, y_3);
}
/**
* clutter_path_add_rel_curve_to:
* @path: a #ClutterPath
* @x_1: the x coordinate of the first control point
* @y_1: the y coordinate of the first control point
* @x_2: the x coordinate of the second control point
* @y_2: the y coordinate of the second control point
* @x_3: the x coordinate of the third control point
* @y_3: the y coordinate of the third control point
*
* Same as clutter_path_add_curve_to() except the coordinates are
* relative to the previous node.
*
* Since: 1.0
*/
void
clutter_path_add_rel_curve_to (ClutterPath *path,
gint x_1,
gint y_1,
gint x_2,
gint y_2,
gint x_3,
gint y_3)
{
g_return_if_fail (CLUTTER_IS_PATH (path));
clutter_path_add_node_helper (path, CLUTTER_PATH_REL_CURVE_TO, 3,
x_1, y_1,
x_2, y_2,
x_3, y_3);
}
/**
* clutter_path_add_close:
* @path: a #ClutterPath
*
* Adds a %CLUTTER_PATH_CLOSE type node to the path. This creates a
* straight line from the last node to the last %CLUTTER_PATH_MOVE_TO
* type node.
*
* Since: 1.0
*/
void
clutter_path_add_close (ClutterPath *path)
{
g_return_if_fail (CLUTTER_IS_PATH (path));
clutter_path_add_node_helper (path, CLUTTER_PATH_CLOSE, 0);
}
static gboolean
clutter_path_parse_number (const gchar **pin,
gboolean allow_comma,
gint *ret)
{
gint val = 0;
gboolean negative = FALSE;
gint digit_count = 0;
const gchar *p = *pin;
/* Skip leading spaces */
while (clutter_path_isspace (*p))
p++;
/* Optional comma */
if (allow_comma && *p == ',')
{
p++;
while (clutter_path_isspace (*p))
p++;
}
/* Optional sign */
if (*p == '+')
p++;
else if (*p == '-')
{
negative = TRUE;
p++;
}
/* Some digits */
while (clutter_path_isdigit (*p))
{
val = val * 10 + *p - '0';
digit_count++;
p++;
}
/* We need at least one digit */
if (digit_count < 1)
return FALSE;
/* Optional fractional part which we ignore */
if (*p == '.')
{
p++;
digit_count = 0;
while (clutter_path_isdigit (*p))
{
digit_count++;
p++;
}
/* If there is a fractional part then it also needs at least one
digit */
if (digit_count < 1)
return FALSE;
}
*pin = p;
*ret = negative ? -val : val;
return TRUE;
}
static gboolean
clutter_path_parse_description (const gchar *p,
GSList **ret)
{
ClutterPathNodeFull *node;
GSList *nodes = NULL;
if (p == NULL || *p == '\0')
return FALSE;
while (TRUE)
{
/* Skip leading whitespace */
while (clutter_path_isspace (*p))
p++;
/* It is not an error to end now */
if (*p == '\0')
break;
switch (*p)
{
case 'M':
case 'm':
case 'L':
case 'l':
node = clutter_path_node_full_new ();
nodes = g_slist_prepend (nodes, node);
node->k.type = (*p == 'M' ? CLUTTER_PATH_MOVE_TO :
*p == 'm' ? CLUTTER_PATH_REL_MOVE_TO :
*p == 'L' ? CLUTTER_PATH_LINE_TO :
CLUTTER_PATH_REL_LINE_TO);
p++;
if (!clutter_path_parse_number (&p, FALSE, &node->k.points[0].x) ||
!clutter_path_parse_number (&p, TRUE, &node->k.points[0].y))
goto fail;
break;
case 'C':
case 'c':
node = clutter_path_node_full_new ();
nodes = g_slist_prepend (nodes, node);
node->k.type = (*p == 'C' ? CLUTTER_PATH_CURVE_TO :
CLUTTER_PATH_REL_CURVE_TO);
p++;
if (!clutter_path_parse_number (&p, FALSE, &node->k.points[0].x) ||
!clutter_path_parse_number (&p, TRUE, &node->k.points[0].y) ||
!clutter_path_parse_number (&p, TRUE, &node->k.points[1].x) ||
!clutter_path_parse_number (&p, TRUE, &node->k.points[1].y) ||
!clutter_path_parse_number (&p, TRUE, &node->k.points[2].x) ||
!clutter_path_parse_number (&p, TRUE, &node->k.points[2].y))
goto fail;
break;
case 'Z':
case 'z':
node = clutter_path_node_full_new ();
nodes = g_slist_prepend (nodes, node);
p++;
node->k.type = CLUTTER_PATH_CLOSE;
break;
default:
goto fail;
}
}
*ret = g_slist_reverse (nodes);
return TRUE;
fail:
g_slist_free_full (nodes, (GDestroyNotify) clutter_path_node_full_free);
return FALSE;
}
/* Takes ownership of the node list */
static void
clutter_path_add_nodes (ClutterPath *path,
GSList *nodes)
{
ClutterPathPrivate *priv = path->priv;
if (priv->nodes_tail == NULL)
priv->nodes = nodes;
else
priv->nodes_tail->next = nodes;
while (nodes)
{
priv->nodes_tail = nodes;
nodes = nodes->next;
}
priv->nodes_dirty = TRUE;
}
/**
* clutter_path_add_string:
* @path: a #ClutterPath
* @str: a string describing the new nodes
*
* Adds new nodes to the end of the path as described in @str. The
* format is a subset of the SVG path format. Each node is represented
* by a letter and is followed by zero, one or three pairs of
* coordinates. The coordinates can be separated by spaces or a
* comma. The types are:
*
* - `M`: Adds a %CLUTTER_PATH_MOVE_TO node. Takes one pair of coordinates.
* - `L`: Adds a %CLUTTER_PATH_LINE_TO node. Takes one pair of coordinates.
* - `C`: Adds a %CLUTTER_PATH_CURVE_TO node. Takes three pairs of coordinates.
* - `z`: Adds a %CLUTTER_PATH_CLOSE node. No coordinates are needed.
*
* The M, L and C commands can also be specified in lower case which
* means the coordinates are relative to the previous node.
*
* For example, to move an actor in a 100 by 100 pixel square centered
* on the point 300,300 you could use the following path:
*
* |[
* M 250,350 l 0 -100 L 350,250 l 0 100 z
* ]|
*
* If the path description isn't valid %FALSE will be returned and no
* nodes will be added.
*
* Return value: %TRUE is the path description was valid or %FALSE
* otherwise.
*
* Since: 1.0
*/
gboolean
clutter_path_add_string (ClutterPath *path,
const gchar *str)
{
GSList *nodes;
g_return_val_if_fail (CLUTTER_IS_PATH (path), FALSE);
g_return_val_if_fail (str != NULL, FALSE);
if (clutter_path_parse_description (str, &nodes))
{
clutter_path_add_nodes (path, nodes);
return TRUE;
}
else
return FALSE;
}
/**
* clutter_path_add_node:
* @path: a #ClutterPath
* @node: a #ClutterPathNode
*
* Adds @node to the end of the path.
*
* Since: 1.0
*/
void
clutter_path_add_node (ClutterPath *path,
const ClutterPathNode *node)
{
ClutterPathNodeFull *node_full;
g_return_if_fail (CLUTTER_IS_PATH (path));
g_return_if_fail (node != NULL);
g_return_if_fail (CLUTTER_PATH_NODE_TYPE_IS_VALID (node->type));
node_full = clutter_path_node_full_new ();
node_full->k = *node;
clutter_path_add_node_full (path, node_full);
}
/**
* clutter_path_add_cairo_path:
* @path: a #ClutterPath
* @cpath: a Cairo path
*
* Add the nodes of the Cairo path to the end of @path.
*
* Since: 1.0
*/
void
clutter_path_add_cairo_path (ClutterPath *path,
const cairo_path_t *cpath)
{
int num_data;
const cairo_path_data_t *p;
g_return_if_fail (CLUTTER_IS_PATH (path));
g_return_if_fail (cpath != NULL);
/* Iterate over each command in the cairo path */
for (num_data = cpath->num_data, p = cpath->data;
num_data > 0;
num_data -= p->header.length, p += p->header.length)
{
switch (p->header.type)
{
case CAIRO_PATH_MOVE_TO:
g_assert (p->header.length >= 2);
clutter_path_add_move_to (path, p[1].point.x, p[1].point.y);
break;
case CAIRO_PATH_LINE_TO:
g_assert (p->header.length >= 2);
clutter_path_add_line_to (path, p[1].point.x, p[1].point.y);
break;
case CAIRO_PATH_CURVE_TO:
g_assert (p->header.length >= 4);
clutter_path_add_curve_to (path,
p[1].point.x, p[1].point.y,
p[2].point.x, p[2].point.y,
p[3].point.x, p[3].point.y);
break;
case CAIRO_PATH_CLOSE_PATH:
clutter_path_add_close (path);
}
}
}
static void
clutter_path_add_node_to_cairo_path (const ClutterPathNode *node,
gpointer data)
{
cairo_t *cr = data;
switch (node->type)
{
case CLUTTER_PATH_MOVE_TO:
cairo_move_to (cr, node->points[0].x, node->points[0].y);
break;
case CLUTTER_PATH_LINE_TO:
cairo_line_to (cr, node->points[0].x, node->points[0].y);
break;
case CLUTTER_PATH_CURVE_TO:
cairo_curve_to (cr,
node->points[0].x, node->points[0].y,
node->points[1].x, node->points[1].y,
node->points[2].x, node->points[2].y);
break;
case CLUTTER_PATH_REL_MOVE_TO:
cairo_rel_move_to (cr, node->points[0].x, node->points[0].y);
break;
case CLUTTER_PATH_REL_LINE_TO:
cairo_rel_line_to (cr, node->points[0].x, node->points[0].y);
break;
case CLUTTER_PATH_REL_CURVE_TO:
cairo_rel_curve_to (cr,
node->points[0].x, node->points[0].y,
node->points[1].x, node->points[1].y,
node->points[2].x, node->points[2].y);
break;
case CLUTTER_PATH_CLOSE:
cairo_close_path (cr);
}
}
/**
* clutter_path_to_cairo_path:
* @path: a #ClutterPath
* @cr: a Cairo context
*
* Add the nodes of the ClutterPath to the path in the Cairo context.
*
* Since: 1.0
*/
void
clutter_path_to_cairo_path (ClutterPath *path,
cairo_t *cr)
{
g_return_if_fail (CLUTTER_IS_PATH (path));
g_return_if_fail (cr != NULL);
clutter_path_foreach (path, clutter_path_add_node_to_cairo_path, cr);
}
/**
* clutter_path_get_n_nodes:
* @path: a #ClutterPath
*
* Retrieves the number of nodes in the path.
*
* Return value: the number of nodes.
*
* Since: 1.0
*/
guint
clutter_path_get_n_nodes (ClutterPath *path)
{
ClutterPathPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_PATH (path), 0);
priv = path->priv;
return g_slist_length (priv->nodes);
}
/**
* clutter_path_get_node:
* @path: a #ClutterPath
* @index_: the node number to retrieve
* @node: (out): a location to store a copy of the node
*
* Retrieves the node of the path indexed by @index.
*
* Since: 1.0
*/
void
clutter_path_get_node (ClutterPath *path,
guint index_,
ClutterPathNode *node)
{
ClutterPathNodeFull *node_full;
ClutterPathPrivate *priv;
g_return_if_fail (CLUTTER_IS_PATH (path));
priv = path->priv;
node_full = g_slist_nth_data (priv->nodes, index_);
g_return_if_fail (node_full != NULL);
*node = node_full->k;
}
/**
* clutter_path_get_nodes:
* @path: a #ClutterPath
*
* Returns a #GSList of #ClutterPathNodes. The list should be
* freed with g_slist_free(). The nodes are owned by the path and
* should not be freed. Altering the path may cause the nodes in the
* list to become invalid so you should copy them if you want to keep
* the list.
*
* Return value: (transfer container) (element-type Clutter.PathNode): a
* list of nodes in the path.
*
* Since: 1.0
*/
GSList *
clutter_path_get_nodes (ClutterPath *path)
{
ClutterPathPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_PATH (path), NULL);
priv = path->priv;
return g_slist_copy (priv->nodes);
}
/**
* clutter_path_foreach:
* @path: a #ClutterPath
* @callback: (scope call): the function to call with each node
* @user_data: user data to pass to the function
*
* Calls a function for each node of the path.
*
* Since: 1.0
*/
void
clutter_path_foreach (ClutterPath *path,
ClutterPathCallback callback,
gpointer user_data)
{
ClutterPathPrivate *priv;
g_return_if_fail (CLUTTER_IS_PATH (path));
priv = path->priv;
g_slist_foreach (priv->nodes, (GFunc) callback, user_data);
}
/**
* clutter_path_insert_node:
* @path: a #ClutterPath
* @index_: offset of where to insert the node
* @node: the node to insert
*
* Inserts @node into the path before the node at the given offset. If
* @index_ is negative it will append the node to the end of the path.
*
* Since: 1.0
*/
void
clutter_path_insert_node (ClutterPath *path,
gint index_,
const ClutterPathNode *node)
{
ClutterPathPrivate *priv;
ClutterPathNodeFull *node_full;
g_return_if_fail (CLUTTER_IS_PATH (path));
g_return_if_fail (node != NULL);
g_return_if_fail (CLUTTER_PATH_NODE_TYPE_IS_VALID (node->type));
priv = path->priv;
node_full = clutter_path_node_full_new ();
node_full->k = *node;
priv->nodes = g_slist_insert (priv->nodes, node_full, index_);
if (priv->nodes_tail == NULL)
priv->nodes_tail = priv->nodes;
else if (priv->nodes_tail->next)
priv->nodes_tail = priv->nodes_tail->next;
priv->nodes_dirty = TRUE;
}
/**
* clutter_path_remove_node:
* @path: a #ClutterPath
* @index_: index of the node to remove
*
* Removes the node at the given offset from the path.
*
* Since: 1.0
*/
void
clutter_path_remove_node (ClutterPath *path,
guint index_)
{
ClutterPathPrivate *priv;
GSList *node, *prev = NULL;
g_return_if_fail (CLUTTER_IS_PATH (path));
priv = path->priv;
for (node = priv->nodes; node && index_--; node = node->next)
prev = node;
if (node)
{
clutter_path_node_full_free (node->data);
if (prev)
prev->next = node->next;
else
priv->nodes = node->next;
if (node == priv->nodes_tail)
priv->nodes_tail = prev;
g_slist_free_1 (node);
priv->nodes_dirty = TRUE;
}
}
/**
* clutter_path_replace_node:
* @path: a #ClutterPath
* @index_: index to the existing node
* @node: the replacement node
*
* Replaces the node at offset @index_ with @node.
*
* Since: 1.0
*/
void
clutter_path_replace_node (ClutterPath *path,
guint index_,
const ClutterPathNode *node)
{
ClutterPathPrivate *priv;
ClutterPathNodeFull *node_full;
g_return_if_fail (CLUTTER_IS_PATH (path));
g_return_if_fail (node != NULL);
g_return_if_fail (CLUTTER_PATH_NODE_TYPE_IS_VALID (node->type));
priv = path->priv;
if ((node_full = g_slist_nth_data (priv->nodes, index_)))
{
node_full->k = *node;
priv->nodes_dirty = TRUE;
}
}
/**
* clutter_path_set_description:
* @path: a #ClutterPath
* @str: a string describing the path
*
* Replaces all of the nodes in the path with nodes described by
* @str. See clutter_path_add_string() for details of the format.
*
* If the string is invalid then %FALSE is returned and the path is
* unaltered.
*
* Return value: %TRUE is the path was valid, %FALSE otherwise.
*
* Since: 1.0
*/
gboolean
clutter_path_set_description (ClutterPath *path,
const gchar *str)
{
GSList *nodes;
g_return_val_if_fail (CLUTTER_IS_PATH (path), FALSE);
g_return_val_if_fail (str != NULL, FALSE);
if (clutter_path_parse_description (str, &nodes))
{
clutter_path_clear (path);
clutter_path_add_nodes (path, nodes);
return TRUE;
}
else
return FALSE;
}
/**
* clutter_path_get_description:
* @path: a #ClutterPath
*
* Returns a newly allocated string describing the path in the same
* format as used by clutter_path_add_string().
*
* Return value: a string description of the path. Free with g_free().
*
* Since: 1.0
*/
gchar *
clutter_path_get_description (ClutterPath *path)
{
ClutterPathPrivate *priv;
GString *str;
GSList *l;
g_return_val_if_fail (CLUTTER_IS_PATH (path), NULL);
priv = path->priv;
str = g_string_new ("");
for (l = priv->nodes; l; l = l->next)
{
ClutterPathNodeFull *node = l->data;
gchar letter = '?';
gint params = 0;
gint i;
switch (node->k.type)
{
case CLUTTER_PATH_MOVE_TO:
letter = 'M';
params = 1;
break;
case CLUTTER_PATH_REL_MOVE_TO:
letter = 'm';
params = 1;
break;
case CLUTTER_PATH_LINE_TO:
letter = 'L';
params = 1;
break;
case CLUTTER_PATH_REL_LINE_TO:
letter = 'l';
params = 1;
break;
case CLUTTER_PATH_CURVE_TO:
letter = 'C';
params = 3;
break;
case CLUTTER_PATH_REL_CURVE_TO:
letter = 'c';
params = 3;
break;
case CLUTTER_PATH_CLOSE:
letter = 'z';
params = 0;
break;
}
if (str->len > 0)
g_string_append_c (str, ' ');
g_string_append_c (str, letter);
for (i = 0; i < params; i++)
g_string_append_printf (str, " %i %i",
node->k.points[i].x,
node->k.points[i].y);
}
return g_string_free (str, FALSE);
}
static guint
clutter_path_node_distance (const ClutterKnot *start,
const ClutterKnot *end)
{
gint64 x_d, y_d;
float t;
g_return_val_if_fail (start != NULL, 0);
g_return_val_if_fail (end != NULL, 0);
if (clutter_knot_equal (start, end))
return 0;
x_d = end->x - start->x;
y_d = end->y - start->y;
t = floorf (sqrtf ((x_d * x_d) + (y_d * y_d)));
return (guint) t;
}
static void
clutter_path_ensure_node_data (ClutterPath *path)
{
ClutterPathPrivate *priv = path->priv;
/* Recalculate the nodes data if has changed */
if (priv->nodes_dirty)
{
GSList *l;
ClutterKnot last_position = { 0, 0 };
ClutterKnot loop_start = { 0, 0 };
ClutterKnot points[3];
priv->total_length = 0;
for (l = priv->nodes; l; l = l->next)
{
ClutterPathNodeFull *node = l->data;
gboolean relative = (node->k.type & CLUTTER_PATH_RELATIVE) != 0;
switch (node->k.type & ~CLUTTER_PATH_RELATIVE)
{
case CLUTTER_PATH_MOVE_TO:
node->length = 0;
/* Store the actual position in point[1] */
if (relative)
{
node->k.points[1].x = last_position.x + node->k.points[0].x;
node->k.points[1].y = last_position.y + node->k.points[0].y;
}
else
node->k.points[1] = node->k.points[0];
last_position = node->k.points[1];
loop_start = node->k.points[1];
break;
case CLUTTER_PATH_LINE_TO:
/* Use point[1] as the start point and point[2] as the end
point */
node->k.points[1] = last_position;
if (relative)
{
node->k.points[2].x = (node->k.points[1].x
+ node->k.points[0].x);
node->k.points[2].y = (node->k.points[1].y
+ node->k.points[0].y);
}
else
node->k.points[2] = node->k.points[0];
last_position = node->k.points[2];
node->length = clutter_path_node_distance (node->k.points + 1,
node->k.points + 2);
break;
case CLUTTER_PATH_CURVE_TO:
/* Convert to a bezier curve */
if (node->bezier == NULL)
node->bezier = _clutter_bezier_new ();
if (relative)
{
int i;
for (i = 0; i < 3; i++)
{
points[i].x = last_position.x + node->k.points[i].x;
points[i].y = last_position.y + node->k.points[i].y;
}
}
else
memcpy (points, node->k.points, sizeof (ClutterKnot) * 3);
_clutter_bezier_init (node->bezier,
last_position.x, last_position.y,
points[0].x, points[0].y,
points[1].x, points[1].y,
points[2].x, points[2].y);
last_position = points[2];
node->length = _clutter_bezier_get_length (node->bezier);
break;
case CLUTTER_PATH_CLOSE:
/* Convert to a line to from last_point to loop_start */
node->k.points[1] = last_position;
node->k.points[2] = loop_start;
last_position = node->k.points[2];
node->length = clutter_path_node_distance (node->k.points + 1,
node->k.points + 2);
break;
}
priv->total_length += node->length;
}
priv->nodes_dirty = FALSE;
}
}
/**
* clutter_path_get_position:
* @path: a #ClutterPath
* @progress: a position along the path as a fraction of its length
* @position: (out): location to store the position
*
* The value in @progress represents a position along the path where
* 0.0 is the beginning and 1.0 is the end of the path. An
* interpolated position is then stored in @position.
*
* Return value: index of the node used to calculate the position.
*
* Since: 1.0
*/
guint
clutter_path_get_position (ClutterPath *path,
gdouble progress,
ClutterKnot *position)
{
ClutterPathPrivate *priv;
GSList *l;
guint point_distance, length = 0, node_num = 0;
ClutterPathNodeFull *node;
g_return_val_if_fail (CLUTTER_IS_PATH (path), 0);
g_return_val_if_fail (progress >= 0.0 && progress <= 1.0, 0);
priv = path->priv;
clutter_path_ensure_node_data (path);
/* Special case if the path is empty, just return 0,0 for want of
something better */
if (priv->nodes == NULL)
{
memset (position, 0, sizeof (ClutterKnot));
return 0;
}
/* Convert the progress to a length along the path */
point_distance = progress * priv->total_length;
/* Find the node that covers this point */
for (l = priv->nodes;
l->next && point_distance >= (((ClutterPathNodeFull *) l->data)->length
+ length);
l = l->next)
{
length += ((ClutterPathNodeFull *) l->data)->length;
node_num++;
}
node = l->data;
/* Convert the point distance to a distance along the node */
point_distance -= length;
if (point_distance > node->length)
point_distance = node->length;
switch (node->k.type & ~CLUTTER_PATH_RELATIVE)
{
case CLUTTER_PATH_MOVE_TO:
*position = node->k.points[1];
break;
case CLUTTER_PATH_LINE_TO:
case CLUTTER_PATH_CLOSE:
if (node->length == 0)
*position = node->k.points[1];
else
{
position->x = (node->k.points[1].x
+ ((node->k.points[2].x - node->k.points[1].x)
* (gint) point_distance / (gint) node->length));
position->y = (node->k.points[1].y
+ ((node->k.points[2].y - node->k.points[1].y)
* (gint) point_distance / (gint) node->length));
}
break;
case CLUTTER_PATH_CURVE_TO:
if (node->length == 0)
*position = node->k.points[2];
else
{
_clutter_bezier_advance (node->bezier,
point_distance * CLUTTER_BEZIER_MAX_LENGTH
/ node->length,
position);
}
break;
}
return node_num;
}
/**
* clutter_path_get_length:
* @path: a #ClutterPath
*
* Retrieves an approximation of the total length of the path.
*
* Return value: the length of the path.
*
* Since: 1.0
*/
guint
clutter_path_get_length (ClutterPath *path)
{
g_return_val_if_fail (CLUTTER_IS_PATH (path), 0);
clutter_path_ensure_node_data (path);
return path->priv->total_length;
}
static ClutterPathNodeFull *
clutter_path_node_full_new (void)
{
return g_slice_new0 (ClutterPathNodeFull);
}
static void
clutter_path_node_full_free (ClutterPathNodeFull *node)
{
if (node->bezier)
_clutter_bezier_free (node->bezier);
g_slice_free (ClutterPathNodeFull, node);
}
/**
* clutter_path_node_copy:
* @node: a #ClutterPathNode
*
* Makes an allocated copy of a node.
*
* Return value: the copied node.
*
* Since: 1.0
*/
ClutterPathNode *
clutter_path_node_copy (const ClutterPathNode *node)
{
return g_slice_dup (ClutterPathNode, node);
}
/**
* clutter_path_node_free:
* @node: a #ClutterPathNode
*
* Frees the memory of an allocated node.
*
* Since: 1.0
*/
void
clutter_path_node_free (ClutterPathNode *node)
{
if (G_LIKELY (node))
g_slice_free (ClutterPathNode, node);
}
/**
* clutter_path_node_equal:
* @node_a: First node
* @node_b: Second node
*
* Compares two nodes and checks if they are the same type with the
* same coordinates.
*
* Return value: %TRUE if the nodes are the same.
*
* Since: 1.0
*/
gboolean
clutter_path_node_equal (const ClutterPathNode *node_a,
const ClutterPathNode *node_b)
{
guint n_points, i;
g_return_val_if_fail (node_a != NULL, FALSE);
g_return_val_if_fail (node_b != NULL, FALSE);
if (node_a->type != node_b->type)
return FALSE;
switch (node_a->type & ~CLUTTER_PATH_RELATIVE)
{
case CLUTTER_PATH_MOVE_TO: n_points = 1; break;
case CLUTTER_PATH_LINE_TO: n_points = 1; break;
case CLUTTER_PATH_CURVE_TO: n_points = 3; break;
case CLUTTER_PATH_CLOSE: n_points = 0; break;
default: return FALSE;
}
for (i = 0; i < n_points; i++)
if (node_a->points[i].x != node_b->points[i].x
|| node_a->points[i].y != node_b->points[i].y)
return FALSE;
return TRUE;
}
G_DEFINE_BOXED_TYPE (ClutterKnot, clutter_knot,
clutter_knot_copy,
clutter_knot_free);
/**
* clutter_knot_copy:
* @knot: a #ClutterKnot
*
* Makes an allocated copy of a knot.
*
* Return value: the copied knot.
*
* Since: 0.2
*/
ClutterKnot *
clutter_knot_copy (const ClutterKnot *knot)
{
if (G_UNLIKELY (knot == NULL))
return NULL;
return g_slice_dup (ClutterKnot, knot);
}
/**
* clutter_knot_free:
* @knot: a #ClutterKnot
*
* Frees the memory of an allocated knot.
*
* Since: 0.2
*/
void
clutter_knot_free (ClutterKnot *knot)
{
if (G_LIKELY (knot != NULL))
g_slice_free (ClutterKnot, knot);
}
/**
* clutter_knot_equal:
* @knot_a: First knot
* @knot_b: Second knot
*
* Compares to knot and checks if the point to the same location.
*
* Return value: %TRUE if the knots point to the same location.
*
* Since: 0.2
*/
gboolean
clutter_knot_equal (const ClutterKnot *knot_a,
const ClutterKnot *knot_b)
{
g_return_val_if_fail (knot_a != NULL, FALSE);
g_return_val_if_fail (knot_b != NULL, FALSE);
if (knot_a == knot_b)
return TRUE;
return knot_a->x == knot_b->x && knot_a->y == knot_b->y;
}
muffin-6.4.1/clutter/clutter/clutter-pan-action.c 0000664 0001750 0001750 00000073122 14723361714 020770 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
* Copyright (C) 2011 Robert Bosch Car Multimedia GmbH.
* Copyright (C) 2012, 2014 Collabora Ltd.
*
* 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 .
*
* Author:
* Emanuele Aina
*
* Based on ClutterDragAction, ClutterSwipeAction, and MxKineticScrollView,
* written by:
* Emmanuele Bassi
* Tomeu Vizoso
* Chris Lord
*/
/**
* SECTION:clutter-pan-action
* @Title: ClutterPanAction
* @Short_Description: Action for pan gestures
*
* #ClutterPanAction is a sub-class of #ClutterGestureAction that implements
* the logic for recognizing pan gestures.
*
* The simplest usage of #ClutterPanAction consists in adding it to
* a #ClutterActor with a child and setting it as reactive; for instance,
* the following code:
*
* |[
* clutter_actor_add_action (actor, clutter_pan_action_new ());
* clutter_actor_set_reactive (actor, TRUE);
* ]|
*
* will automatically result in the actor children to be moved
* when dragging.
*
* Since: 1.12
*/
#include "clutter-build-config.h"
#include "clutter-pan-action.h"
#include "clutter-debug.h"
#include "clutter-enum-types.h"
#include "clutter-gesture-action-private.h"
#include "clutter-marshal.h"
#include "clutter-private.h"
#include
#define FLOAT_EPSILON (1e-15)
static const gfloat min_velocity = 0.1f; // measured in px/ms
static const gfloat reference_fps = 60.0f; // the fps assumed for the deceleration rate
static const gfloat default_deceleration_rate = 0.95f;
static const gfloat default_acceleration_factor = 1.0f;
typedef enum
{
PAN_STATE_INACTIVE,
PAN_STATE_PANNING,
PAN_STATE_INTERPOLATING
} PanState;
typedef enum
{
SCROLL_PINNED_UNKNOWN,
SCROLL_PINNED_NONE,
SCROLL_PINNED_HORIZONTAL,
SCROLL_PINNED_VERTICAL
} PinState;
struct _ClutterPanActionPrivate
{
ClutterPanAxis pan_axis;
PanState state;
/* Variables for storing acceleration information */
ClutterTimeline *deceleration_timeline;
gfloat target_x;
gfloat target_y;
gfloat dx;
gfloat dy;
gdouble deceleration_rate;
gdouble acceleration_factor;
/* Inertial motion tracking */
gfloat interpolated_x;
gfloat interpolated_y;
gfloat release_x;
gfloat release_y;
guint should_interpolate : 1;
PinState pin_state;
};
enum
{
PROP_0,
PROP_PAN_AXIS,
PROP_INTERPOLATE,
PROP_DECELERATION,
PROP_ACCELERATION_FACTOR,
PROP_LAST
};
static GParamSpec *pan_props[PROP_LAST] = { NULL, };
enum
{
PAN,
PAN_STOPPED,
LAST_SIGNAL
};
static guint pan_signals[LAST_SIGNAL] = { 0, };
G_DEFINE_TYPE_WITH_PRIVATE (ClutterPanAction, clutter_pan_action, CLUTTER_TYPE_GESTURE_ACTION)
static void
emit_pan (ClutterPanAction *self,
ClutterActor *actor,
gboolean is_interpolated)
{
ClutterPanActionPrivate *priv = self->priv;
gboolean retval;
if (priv->pin_state == SCROLL_PINNED_UNKNOWN)
{
priv->pin_state = SCROLL_PINNED_NONE;
if (priv->pan_axis == CLUTTER_PAN_AXIS_AUTO)
{
gfloat delta_x;
gfloat delta_y;
gfloat scroll_threshold = G_PI_4/2;
gfloat drag_angle;
clutter_gesture_action_get_motion_delta (CLUTTER_GESTURE_ACTION (self), 0, &delta_x, &delta_y);
if (delta_x != 0.0f)
drag_angle = atanf (delta_y / delta_x);
else
drag_angle = G_PI_2;
if ((drag_angle > -scroll_threshold) && (drag_angle < scroll_threshold))
priv->pin_state = SCROLL_PINNED_HORIZONTAL;
else if ((drag_angle > (G_PI_2 - scroll_threshold)) ||
(drag_angle < -(G_PI_2 - scroll_threshold)))
priv->pin_state = SCROLL_PINNED_VERTICAL;
}
}
g_signal_emit (self, pan_signals[PAN], 0, actor, is_interpolated, &retval);
}
static void
emit_pan_stopped (ClutterPanAction *self,
ClutterActor *actor)
{
ClutterPanActionPrivate *priv = self->priv;
g_signal_emit (self, pan_signals[PAN_STOPPED], 0, actor);
priv->state = PAN_STATE_INACTIVE;
}
static void
on_deceleration_stopped (ClutterTimeline *timeline,
gboolean is_finished,
ClutterPanAction *self)
{
ClutterPanActionPrivate *priv = self->priv;
ClutterActor *actor;
g_object_unref (timeline);
priv->deceleration_timeline = NULL;
actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (self));
emit_pan_stopped (self, actor);
}
static void
on_deceleration_new_frame (ClutterTimeline *timeline,
gint elapsed_time,
ClutterPanAction *self)
{
ClutterPanActionPrivate *priv = self->priv;
ClutterActor *actor;
gdouble progress;
gfloat interpolated_x, interpolated_y;
progress = clutter_timeline_get_progress (timeline);
interpolated_x = priv->target_x * progress;
interpolated_y = priv->target_y * progress;
priv->dx = interpolated_x - priv->interpolated_x;
priv->dy = interpolated_y - priv->interpolated_y;
priv->interpolated_x = interpolated_x;
priv->interpolated_y = interpolated_y;
actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (self));
emit_pan (self, actor, TRUE);
}
static gboolean
gesture_prepare (ClutterGestureAction *gesture,
ClutterActor *actor)
{
ClutterPanAction *self = CLUTTER_PAN_ACTION (gesture);
ClutterPanActionPrivate *priv = self->priv;
if (priv->state == PAN_STATE_INTERPOLATING && priv->deceleration_timeline)
clutter_timeline_stop (priv->deceleration_timeline);
return TRUE;
}
static gboolean
gesture_begin (ClutterGestureAction *gesture,
ClutterActor *actor)
{
ClutterPanAction *self = CLUTTER_PAN_ACTION (gesture);
ClutterPanActionPrivate *priv = self->priv;
priv->pin_state = SCROLL_PINNED_UNKNOWN;
priv->state = PAN_STATE_PANNING;
priv->interpolated_x = priv->interpolated_y = 0.0f;
priv->dx = priv->dy = 0.0f;
return TRUE;
}
static gboolean
gesture_progress (ClutterGestureAction *gesture,
ClutterActor *actor)
{
ClutterPanAction *self = CLUTTER_PAN_ACTION (gesture);
emit_pan (self, actor, FALSE);
return TRUE;
}
static void
gesture_cancel (ClutterGestureAction *gesture,
ClutterActor *actor)
{
ClutterPanAction *self = CLUTTER_PAN_ACTION (gesture);
ClutterPanActionPrivate *priv = self->priv;
priv->state = PAN_STATE_INACTIVE;
}
static void
gesture_end (ClutterGestureAction *gesture,
ClutterActor *actor)
{
ClutterPanAction *self = CLUTTER_PAN_ACTION (gesture);
ClutterPanActionPrivate *priv = self->priv;
gfloat velocity, velocity_x, velocity_y;
gfloat delta_x, delta_y;
gfloat tau;
gint duration;
clutter_gesture_action_get_release_coords (CLUTTER_GESTURE_ACTION (self), 0, &priv->release_x, &priv->release_y);
if (!priv->should_interpolate)
{
priv->state = PAN_STATE_INACTIVE;
return;
}
priv->state = PAN_STATE_INTERPOLATING;
clutter_gesture_action_get_motion_delta (gesture, 0, &delta_x, &delta_y);
velocity = clutter_gesture_action_get_velocity (gesture, 0, &velocity_x, &velocity_y);
/* Exponential timing constant v(t) = v(0) * exp(-t/tau)
* tau = 1000ms / (frame_per_second * - ln(decay_per_frame))
* with frame_per_second = 60 and decay_per_frame = 0.95, tau ~= 325ms
* see http://ariya.ofilabs.com/2011/10/flick-list-with-its-momentum-scrolling-and-deceleration.html */
tau = 1000.0f / (reference_fps * - logf (priv->deceleration_rate));
/* See where the decreasing velocity reaches $min_velocity px/ms
* v(t) = v(0) * exp(-t/tau) = min_velocity
* t = - tau * ln( min_velocity / |v(0)|) */
duration = - tau * logf (min_velocity / (ABS (velocity) * priv->acceleration_factor));
/* Target point: x(t) = v(0) * tau * [1 - exp(-t/tau)] */
priv->target_x = velocity_x * priv->acceleration_factor * tau * (1 - exp ((float)-duration / tau));
priv->target_y = velocity_y * priv->acceleration_factor * tau * (1 - exp ((float)-duration / tau));
if (ABS (velocity) * priv->acceleration_factor > min_velocity && duration > FLOAT_EPSILON)
{
priv->interpolated_x = priv->interpolated_y = 0.0f;
priv->deceleration_timeline = clutter_timeline_new (duration);
clutter_timeline_set_progress_mode (priv->deceleration_timeline, CLUTTER_EASE_OUT_EXPO);
g_signal_connect (priv->deceleration_timeline, "new_frame",
G_CALLBACK (on_deceleration_new_frame), self);
g_signal_connect (priv->deceleration_timeline, "stopped",
G_CALLBACK (on_deceleration_stopped), self);
clutter_timeline_start (priv->deceleration_timeline);
}
else
{
emit_pan_stopped (self, actor);
}
}
static gboolean
clutter_pan_action_real_pan (ClutterPanAction *self,
ClutterActor *actor,
gboolean is_interpolated)
{
gfloat dx, dy;
ClutterMatrix transform;
clutter_pan_action_get_constrained_motion_delta (self, 0, &dx, &dy);
clutter_actor_get_child_transform (actor, &transform);
cogl_matrix_translate (&transform, dx, dy, 0.0f);
clutter_actor_set_child_transform (actor, &transform);
return TRUE;
}
static void
clutter_pan_action_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterPanAction *self = CLUTTER_PAN_ACTION (gobject);
switch (prop_id)
{
case PROP_PAN_AXIS:
clutter_pan_action_set_pan_axis (self, g_value_get_enum (value));
break;
case PROP_INTERPOLATE :
clutter_pan_action_set_interpolate (self, g_value_get_boolean (value));
break;
case PROP_DECELERATION :
clutter_pan_action_set_deceleration (self, g_value_get_double (value));
break;
case PROP_ACCELERATION_FACTOR :
clutter_pan_action_set_acceleration_factor (self, g_value_get_double (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
}
}
static void
clutter_pan_action_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterPanAction *self = CLUTTER_PAN_ACTION (gobject);
ClutterPanActionPrivate *priv = self->priv;
switch (prop_id)
{
case PROP_PAN_AXIS:
g_value_set_enum (value, priv->pan_axis);
break;
case PROP_INTERPOLATE :
g_value_set_boolean (value, priv->should_interpolate);
break;
case PROP_DECELERATION :
g_value_set_double (value, priv->deceleration_rate);
break;
case PROP_ACCELERATION_FACTOR :
g_value_set_double (value, priv->acceleration_factor);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
}
}
static void
clutter_pan_action_constructed (GObject *gobject)
{
ClutterGestureAction *gesture;
gesture = CLUTTER_GESTURE_ACTION (gobject);
clutter_gesture_action_set_threshold_trigger_edge (gesture, CLUTTER_GESTURE_TRIGGER_EDGE_AFTER);
}
static void
clutter_pan_action_dispose (GObject *gobject)
{
ClutterPanActionPrivate *priv = CLUTTER_PAN_ACTION (gobject)->priv;
g_clear_object (&priv->deceleration_timeline);
G_OBJECT_CLASS (clutter_pan_action_parent_class)->dispose (gobject);
}
static void
clutter_pan_action_set_actor (ClutterActorMeta *meta,
ClutterActor *actor)
{
ClutterPanAction *self = CLUTTER_PAN_ACTION (meta);
ClutterPanActionPrivate *priv = self->priv;
ClutterActor *old_actor;
old_actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (self));
if (old_actor != actor)
{
/* make sure we reset the state */
if (priv->state == PAN_STATE_INTERPOLATING)
g_clear_object (&priv->deceleration_timeline);
}
CLUTTER_ACTOR_META_CLASS (clutter_pan_action_parent_class)->set_actor (meta, actor);
}
static void
clutter_pan_action_class_init (ClutterPanActionClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
ClutterGestureActionClass *gesture_class =
CLUTTER_GESTURE_ACTION_CLASS (klass);
klass->pan = clutter_pan_action_real_pan;
gesture_class->gesture_prepare = gesture_prepare;
gesture_class->gesture_begin = gesture_begin;
gesture_class->gesture_progress = gesture_progress;
gesture_class->gesture_cancel = gesture_cancel;
gesture_class->gesture_end = gesture_end;
meta_class->set_actor = clutter_pan_action_set_actor;
/**
* ClutterPanAction:pan-axis:
*
* Constraints the panning action to the specified axis
*
* Since: 1.12
*/
pan_props[PROP_PAN_AXIS] =
g_param_spec_enum ("pan-axis",
P_("Pan Axis"),
P_("Constraints the panning to an axis"),
CLUTTER_TYPE_PAN_AXIS,
CLUTTER_PAN_AXIS_NONE,
CLUTTER_PARAM_READWRITE);
/**
* ClutterPanAction:interpolate:
*
* Whether interpolated events emission is enabled.
*
* Since: 1.12
*/
pan_props[PROP_INTERPOLATE] =
g_param_spec_boolean ("interpolate",
P_("Interpolate"),
P_("Whether interpolated events emission is enabled."),
FALSE,
CLUTTER_PARAM_READWRITE);
/**
* ClutterPanAction:deceleration:
*
* The rate at which the interpolated panning will decelerate in
*
* #ClutterPanAction will emit interpolated ::pan events with decreasing
* scroll deltas, using the rate specified by this property.
*
* Since: 1.12
*/
pan_props[PROP_DECELERATION] =
g_param_spec_double ("deceleration",
P_("Deceleration"),
P_("Rate at which the interpolated panning will decelerate in"),
FLOAT_EPSILON, 1.0, default_deceleration_rate,
CLUTTER_PARAM_READWRITE);
/**
* ClutterPanAction:acceleration-factor:
*
* The initial acceleration factor
*
* The kinetic momentum measured at the time of releasing the pointer will
* be multiplied by the factor specified by this property before being used
* to generate interpolated ::pan events.
*
* Since: 1.12
*/
pan_props[PROP_ACCELERATION_FACTOR] =
g_param_spec_double ("acceleration-factor",
P_("Initial acceleration factor"),
P_("Factor applied to the momentum when starting the interpolated phase"),
1.0, G_MAXDOUBLE, default_acceleration_factor,
CLUTTER_PARAM_READWRITE);
gobject_class->constructed = clutter_pan_action_constructed;
gobject_class->set_property = clutter_pan_action_set_property;
gobject_class->get_property = clutter_pan_action_get_property;
gobject_class->dispose = clutter_pan_action_dispose;
g_object_class_install_properties (gobject_class,
PROP_LAST,
pan_props);
/**
* ClutterPanAction::pan:
* @action: the #ClutterPanAction that emitted the signal
* @actor: the #ClutterActor attached to the @action
* @is_interpolated: if the event is the result of interpolating
* the motion velocity at the end of the drag
*
* The ::pan signal is emitted to keep track of the motion during
* a pan gesture. @is_interpolated is set to %TRUE during the
* interpolation phase of the pan, after the drag has ended and
* the :interpolate property was set to %TRUE.
*
* Return value: %TRUE if the pan should continue, and %FALSE if
* the pan should be cancelled.
*
* Since: 1.12
*/
pan_signals[PAN] =
g_signal_new (I_("pan"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterPanActionClass, pan),
_clutter_boolean_continue_accumulator, NULL,
_clutter_marshal_BOOLEAN__OBJECT_BOOLEAN,
G_TYPE_BOOLEAN, 2,
CLUTTER_TYPE_ACTOR,
G_TYPE_BOOLEAN);
/**
* ClutterPanAction::pan-stopped:
* @action: the #ClutterPanAction that emitted the signal
* @actor: the #ClutterActor attached to the @action
*
* The ::pan-stopped signal is emitted at the end of the interpolation
* phase of the pan action, only when :interpolate is set to %TRUE.
*
* Since: 1.12
*/
pan_signals[PAN_STOPPED] =
g_signal_new (I_("pan-stopped"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterPanActionClass, pan_stopped),
NULL, NULL, NULL,
G_TYPE_NONE, 1,
CLUTTER_TYPE_ACTOR);
}
static void
clutter_pan_action_init (ClutterPanAction *self)
{
self->priv = clutter_pan_action_get_instance_private (self);
self->priv->deceleration_rate = default_deceleration_rate;
self->priv->acceleration_factor = default_acceleration_factor;
self->priv->state = PAN_STATE_INACTIVE;
}
/**
* clutter_pan_action_new:
*
* Creates a new #ClutterPanAction instance
*
* Return value: the newly created #ClutterPanAction
*
* Since: 1.12
*/
ClutterAction *
clutter_pan_action_new (void)
{
return g_object_new (CLUTTER_TYPE_PAN_ACTION, NULL);
}
/**
* clutter_pan_action_set_pan_axis:
* @self: a #ClutterPanAction
* @axis: the axis to constraint the panning to
*
* Restricts the panning action to a specific axis
*
* Since: 1.12
*/
void
clutter_pan_action_set_pan_axis (ClutterPanAction *self,
ClutterPanAxis axis)
{
ClutterPanActionPrivate *priv;
g_return_if_fail (CLUTTER_IS_PAN_ACTION (self));
g_return_if_fail (axis >= CLUTTER_PAN_AXIS_NONE &&
axis <= CLUTTER_PAN_AXIS_AUTO);
priv = self->priv;
if (priv->pan_axis == axis)
return;
priv->pan_axis = axis;
g_object_notify_by_pspec (G_OBJECT (self), pan_props[PROP_PAN_AXIS]);
}
/**
* clutter_pan_action_get_pan_axis:
* @self: a #ClutterPanAction
*
* Retrieves the axis constraint set by clutter_pan_action_set_pan_axis()
*
* Return value: the axis constraint
*
* Since: 1.12
*/
ClutterPanAxis
clutter_pan_action_get_pan_axis (ClutterPanAction *self)
{
g_return_val_if_fail (CLUTTER_IS_PAN_ACTION (self),
CLUTTER_PAN_AXIS_NONE);
return self->priv->pan_axis;
}
/**
* clutter_pan_action_set_interpolate:
* @self: a #ClutterPanAction
* @should_interpolate: whether to enable interpolated pan events
*
* Sets whether the action should emit interpolated ::pan events
* after the drag has ended, to emulate the gesture kinetic inertia.
*
* Since: 1.12
*/
void
clutter_pan_action_set_interpolate (ClutterPanAction *self,
gboolean should_interpolate)
{
ClutterPanActionPrivate *priv;
g_return_if_fail (CLUTTER_IS_PAN_ACTION (self));
priv = self->priv;
should_interpolate = !!should_interpolate;
if (priv->should_interpolate == should_interpolate)
return;
priv->should_interpolate = should_interpolate;
g_object_notify_by_pspec (G_OBJECT (self), pan_props[PROP_INTERPOLATE]);
}
/**
* clutter_pan_action_get_interpolate:
* @self: a #ClutterPanAction
*
* Checks if the action should emit ::pan events even after releasing
* the pointer during a panning gesture, to emulate some kind of
* kinetic inertia.
*
* Return value: %TRUE if interpolated events emission is active.
*
* Since: 1.12
*/
gboolean
clutter_pan_action_get_interpolate (ClutterPanAction *self)
{
g_return_val_if_fail (CLUTTER_IS_PAN_ACTION (self),
FALSE);
return self->priv->should_interpolate;
}
/**
* clutter_pan_action_set_deceleration:
* @self: A #ClutterPanAction
* @rate: The deceleration rate
*
* Sets the deceleration rate of the interpolated ::pan events generated
* after a pan gesture. This is approximately the value that the momentum
* at the time of releasing the pointer is divided by every 60th of a second.
*
* Since: 1.12
*/
void
clutter_pan_action_set_deceleration (ClutterPanAction *self,
gdouble rate)
{
g_return_if_fail (CLUTTER_IS_PAN_ACTION (self));
g_return_if_fail (rate <= 1.0);
g_return_if_fail (rate > 0.0);
self->priv->deceleration_rate = rate;
g_object_notify_by_pspec (G_OBJECT (self), pan_props[PROP_DECELERATION]);
}
/**
* clutter_pan_action_get_deceleration:
* @self: A #ClutterPanAction
*
* Retrieves the deceleration rate of interpolated ::pan events.
*
* Return value: The deceleration rate of the interpolated events.
*
* Since: 1.12
*/
gdouble
clutter_pan_action_get_deceleration (ClutterPanAction *self)
{
g_return_val_if_fail (CLUTTER_IS_PAN_ACTION (self), 0.95);
return self->priv->deceleration_rate;
}
/**
* clutter_pan_action_set_acceleration_factor:
* @self: A #ClutterPanAction
* @factor: The acceleration factor
*
* Factor applied to the momentum velocity at the time of releasing the
* pointer when generating interpolated ::pan events.
*
* Since: 1.12
*/
void
clutter_pan_action_set_acceleration_factor (ClutterPanAction *self,
gdouble factor)
{
g_return_if_fail (CLUTTER_IS_PAN_ACTION (self));
g_return_if_fail (factor >= 0.0);
self->priv->acceleration_factor = factor;
g_object_notify_by_pspec (G_OBJECT (self), pan_props[PROP_ACCELERATION_FACTOR]);
}
/**
* clutter_pan_action_get_acceleration_factor:
* @self: A #ClutterPanAction
*
* Retrieves the initial acceleration factor for interpolated ::pan events.
*
* Return value: The initial acceleration factor for interpolated events.
*
* Since: 1.12
*/
gdouble
clutter_pan_action_get_acceleration_factor (ClutterPanAction *self)
{
g_return_val_if_fail (CLUTTER_IS_PAN_ACTION (self), 1.0);
return self->priv->acceleration_factor;
}
/**
* clutter_pan_action_get_interpolated_coords:
* @self: A #ClutterPanAction
* @interpolated_x: (out) (allow-none): return location for the latest
* interpolated event's X coordinate
* @interpolated_y: (out) (allow-none): return location for the latest
* interpolated event's Y coordinate
*
* Retrieves the coordinates, in stage space, of the latest interpolated
* event, analogous to clutter_gesture_action_get_motion_coords().
*
* Since: 1.12
*/
void
clutter_pan_action_get_interpolated_coords (ClutterPanAction *self,
gfloat *interpolated_x,
gfloat *interpolated_y)
{
ClutterPanActionPrivate *priv;
g_return_if_fail (CLUTTER_IS_PAN_ACTION (self));
priv = self->priv;
if (interpolated_x)
*interpolated_x = priv->release_x + priv->interpolated_x;
if (interpolated_y)
*interpolated_y = priv->release_y + priv->interpolated_y;
}
/**
* clutter_pan_action_get_interpolated_delta:
* @self: A #ClutterPanAction
* @delta_x: (out) (allow-none): return location for the X delta since
* the latest interpolated event
* @delta_y: (out) (allow-none): return location for the Y delta since
* the latest interpolated event
*
* Retrieves the delta, in stage space, since the latest interpolated
* event, analogous to clutter_gesture_action_get_motion_delta().
*
* Return value: the distance since the latest interpolated event
*
* Since: 1.12
*/
gfloat
clutter_pan_action_get_interpolated_delta (ClutterPanAction *self,
gfloat *delta_x,
gfloat *delta_y)
{
ClutterPanActionPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_PAN_ACTION (self), 0.0f);
priv = self->priv;
if (delta_x)
*delta_x = priv->dx;
if (delta_y)
*delta_y = priv->dy;
return sqrt ((priv->dx * priv->dx) + (priv->dy * priv->dy));
}
/**
* clutter_pan_action_get_constrained_motion_delta:
* @self: A #ClutterPanAction
* @point: the touch point index, with 0 being the first touch
* point received by the action
* @delta_x: (out) (optional): return location for the X delta
* @delta_y: (out) (optional): return location for the Y delta
*
* Retrieves the delta, in stage space, dependent on the current state
* of the #ClutterPanAction, and respecting the constraint specified by the
* #ClutterPanAction:pan-axis property.
*
* Return value: the distance since last motion event
*
* Since: 1.24
*/
gfloat
clutter_pan_action_get_constrained_motion_delta (ClutterPanAction *self,
guint point,
gfloat *out_delta_x,
gfloat *out_delta_y)
{
ClutterPanActionPrivate *priv;
gfloat delta_x = 0.f, delta_y = 0.f, distance;
g_return_val_if_fail (CLUTTER_IS_PAN_ACTION (self), 0.0f);
priv = self->priv;
distance = clutter_pan_action_get_motion_delta (self, point, &delta_x, &delta_y);
switch (priv->pan_axis)
{
case CLUTTER_PAN_AXIS_NONE:
break;
case CLUTTER_PAN_AXIS_AUTO:
if (priv->pin_state == SCROLL_PINNED_VERTICAL)
delta_x = 0.0f;
else if (priv->pin_state == SCROLL_PINNED_HORIZONTAL)
delta_y = 0.0f;
break;
case CLUTTER_PAN_X_AXIS:
delta_y = 0.0f;
break;
case CLUTTER_PAN_Y_AXIS:
delta_x = 0.0f;
break;
}
if (out_delta_x)
*out_delta_x = delta_x;
if (out_delta_y)
*out_delta_y = delta_y;
return distance;
}
/**
* clutter_pan_action_get_motion_delta:
* @self: A #ClutterPanAction
* @point: the touch point index, with 0 being the first touch
* point received by the action
* @delta_x: (out) (allow-none): return location for the X delta
* @delta_y: (out) (allow-none): return location for the Y delta
*
* Retrieves the delta, in stage space, dependent on the current state
* of the #ClutterPanAction. If it is inactive, both fields will be
* set to 0. If it is panning by user action, the values will be equivalent
* to those returned by clutter_gesture_action_get_motion_delta().
* If it is interpolating with some form of kinetic scrolling, the values
* will be equivalent to those returned by
* clutter_pan_action_get_interpolated_delta(). This is a convenience
* method designed to be used in replacement "pan" signal handlers.
*
* Since: 1.14
*/
gfloat
clutter_pan_action_get_motion_delta (ClutterPanAction *self,
guint point,
gfloat *delta_x,
gfloat *delta_y)
{
ClutterPanActionPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_PAN_ACTION (self), 0.0f);
priv = self->priv;
switch (priv->state)
{
case PAN_STATE_INACTIVE:
if (delta_x)
*delta_x = 0;
if (delta_y)
*delta_y = 0;
return 0;
case PAN_STATE_PANNING:
return clutter_gesture_action_get_motion_delta (CLUTTER_GESTURE_ACTION (self),
point, delta_x, delta_y);
case PAN_STATE_INTERPOLATING:
return clutter_pan_action_get_interpolated_delta (self, delta_x, delta_y);
default:
g_assert_not_reached ();
return 0.0f;
}
}
/**
* clutter_pan_action_get_motion_coords:
* @self: A #ClutterPanAction
* @point: the touch point index, with 0 being the first touch
* point received by the action
* @motion_x: (out) (allow-none): return location for the X coordinate
* @motion_y: (out) (allow-none): return location for the Y coordinate
*
* Retrieves the coordinates, in stage space, dependent on the current state
* of the #ClutterPanAction. If it is inactive, both fields will be
* set to 0. If it is panning by user action, the values will be equivalent
* to those returned by clutter_gesture_action_get_motion_coords().
* If it is interpolating with some form of kinetic scrolling, the values
* will be equivalent to those returned by
* clutter_pan_action_get_interpolated_coords(). This is a convenience
* method designed to be used in replacement "pan" signal handlers.
*
* Since: 1.14
*/
void
clutter_pan_action_get_motion_coords (ClutterPanAction *self,
guint point,
gfloat *motion_x,
gfloat *motion_y)
{
ClutterPanActionPrivate *priv;
g_return_if_fail (CLUTTER_IS_PAN_ACTION (self));
priv = self->priv;
switch (priv->state)
{
case PAN_STATE_INACTIVE:
if (motion_x)
*motion_x = 0;
if (motion_y)
*motion_y = 0;
break;
case PAN_STATE_PANNING:
clutter_gesture_action_get_motion_coords (CLUTTER_GESTURE_ACTION (self),
point, motion_x, motion_y);
break;
case PAN_STATE_INTERPOLATING:
clutter_pan_action_get_interpolated_coords (self, motion_x, motion_y);
break;
default:
g_assert_not_reached ();
}
}
muffin-6.4.1/clutter/clutter/clutter-blur-effect.h 0000664 0001750 0001750 00000003476 14723361714 021147 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_BLUR_EFFECT_H__
#define __CLUTTER_BLUR_EFFECT_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_BLUR_EFFECT (clutter_blur_effect_get_type ())
#define CLUTTER_BLUR_EFFECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_BLUR_EFFECT, ClutterBlurEffect))
#define CLUTTER_IS_BLUR_EFFECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_BLUR_EFFECT))
/**
* ClutterBlurEffect:
*
* #ClutterBlurEffect is an opaque structure
* whose members cannot be accessed directly
*
* Since: 1.4
*/
typedef struct _ClutterBlurEffect ClutterBlurEffect;
typedef struct _ClutterBlurEffectClass ClutterBlurEffectClass;
CLUTTER_EXPORT
GType clutter_blur_effect_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterEffect *clutter_blur_effect_new (void);
G_END_DECLS
#endif /* __CLUTTER_BLUR_EFFECT_H__ */
muffin-6.4.1/clutter/clutter/clutter-paint-context-private.h 0000664 0001750 0001750 00000003126 14723361714 023206 0 ustar fabio fabio /*
* Copyright (C) 2019 Red Hat 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 .
*/
#ifndef CLUTTER_PAINT_CONTEXT_PRIVATE_H
#define CLUTTER_PAINT_CONTEXT_PRIVATE_H
#include "clutter-paint-context.h"
typedef enum _ClutterPaintFlag
{
CLUTTER_PAINT_FLAG_NONE = 0,
CLUTTER_PAINT_FLAG_NO_CURSORS = 1 << 0,
CLUTTER_PAINT_FLAG_NO_PAINT_SIGNAL = 1 << 1,
} ClutterPaintFlag;
ClutterPaintContext * clutter_paint_context_new_for_view (ClutterStageView *view,
const cairo_region_t *redraw_clip,
ClutterPaintFlag paint_flags);
gboolean clutter_paint_context_is_drawing_off_stage (ClutterPaintContext *paint_context);
CoglFramebuffer * clutter_paint_context_get_base_framebuffer (ClutterPaintContext *paint_context);
CLUTTER_EXPORT
ClutterPaintFlag clutter_paint_context_get_paint_flags (ClutterPaintContext *paint_context);
#endif /* CLUTTER_PAINT_CONTEXT_PRIVATE_H */
muffin-6.4.1/clutter/clutter/clutter-deprecated.h 0000664 0001750 0001750 00000001104 14723361714 021033 0 ustar fabio fabio #ifndef __CLUTTER_DEPRECATED_H__
#define __CLUTTER_DEPRECATED_H__
#define __CLUTTER_DEPRECATED_H_INSIDE__
#include "deprecated/clutter-actor.h"
#include "deprecated/clutter-alpha.h"
#include "deprecated/clutter-animation.h"
#include "deprecated/clutter-box.h"
#include "deprecated/clutter-container.h"
#include "deprecated/clutter-group.h"
#include "deprecated/clutter-rectangle.h"
#include "deprecated/clutter-stage.h"
#include "deprecated/clutter-state.h"
#include "deprecated/clutter-timeline.h"
#undef __CLUTTER_DEPRECATED_H_INSIDE__
#endif /* __CLUTTER_DEPRECATED_H__ */
muffin-6.4.1/clutter/clutter/clutter-click-action.h 0000664 0001750 0001750 00000010201 14723361714 021271 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*
* Inspired by the StClickable class in GNOME Shell, written by:
* Colin Walters
*/
#ifndef __CLUTTER_CLICK_ACTION_H__
#define __CLUTTER_CLICK_ACTION_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_CLICK_ACTION (clutter_click_action_get_type ())
#define CLUTTER_CLICK_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_CLICK_ACTION, ClutterClickAction))
#define CLUTTER_IS_CLICK_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_CLICK_ACTION))
#define CLUTTER_CLICK_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_CLICK_ACTION, ClutterClickActionClass))
#define CLUTTER_IS_CLICK_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_CLICK_ACTION))
#define CLUTTER_CLICK_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_CLICK_ACTION, ClutterClickActionClass))
typedef struct _ClutterClickAction ClutterClickAction;
typedef struct _ClutterClickActionPrivate ClutterClickActionPrivate;
typedef struct _ClutterClickActionClass ClutterClickActionClass;
/**
* ClutterClickAction:
*
* The #ClutterClickAction structure contains
* only private data and should be accessed using the provided API
*
* Since: 1.4
*/
struct _ClutterClickAction
{
/*< private >*/
ClutterAction parent_instance;
ClutterClickActionPrivate *priv;
};
/**
* ClutterClickActionClass:
* @clicked: class handler for the #ClutterClickAction::clicked signal
* @long_press: class handler for the #ClutterClickAction::long-press signal
*
* The #ClutterClickActionClass structure
* contains only private data
*
* Since: 1.4
*/
struct _ClutterClickActionClass
{
/*< private >*/
ClutterActionClass parent_class;
/*< public >*/
void (* clicked) (ClutterClickAction *action,
ClutterActor *actor);
gboolean (* long_press) (ClutterClickAction *action,
ClutterActor *actor,
ClutterLongPressState state);
/*< private >*/
void (* _clutter_click_action1) (void);
void (* _clutter_click_action2) (void);
void (* _clutter_click_action3) (void);
void (* _clutter_click_action4) (void);
void (* _clutter_click_action5) (void);
void (* _clutter_click_action6) (void);
void (* _clutter_click_action7) (void);
};
CLUTTER_EXPORT
GType clutter_click_action_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterAction * clutter_click_action_new (void);
CLUTTER_EXPORT
guint clutter_click_action_get_button (ClutterClickAction *action);
CLUTTER_EXPORT
ClutterModifierType clutter_click_action_get_state (ClutterClickAction *action);
CLUTTER_EXPORT
void clutter_click_action_get_coords (ClutterClickAction *action,
gfloat *press_x,
gfloat *press_y);
CLUTTER_EXPORT
void clutter_click_action_release (ClutterClickAction *action);
G_END_DECLS
#endif /* __CLUTTER_CLICK_ACTION_H__ */
muffin-6.4.1/clutter/clutter/clutter-config.h.in 0000664 0001750 0001750 00000000456 14723361714 020616 0 ustar fabio fabio #if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#ifndef __CLUTTER_CONFIG_H__
#define __CLUTTER_CONFIG_H__
#include
G_BEGIN_DECLS
@CLUTTER_CONFIG_DEFINES@
G_END_DECLS
#endif /* __CLUTTER_CONFIG_H__ */
muffin-6.4.1/clutter/clutter/clutter-stage.h 0000664 0001750 0001750 00000023631 14723361714 020047 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum
*
* Copyright (C) 2006 OpenedHand
*
* 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 .
*/
#ifndef __CLUTTER_STAGE_H__
#define __CLUTTER_STAGE_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_STAGE (clutter_stage_get_type())
#define CLUTTER_STAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_STAGE, ClutterStage))
#define CLUTTER_STAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_STAGE, ClutterStageClass))
#define CLUTTER_IS_STAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_STAGE))
#define CLUTTER_IS_STAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_STAGE))
#define CLUTTER_STAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_STAGE, ClutterStageClass))
typedef struct _ClutterStageClass ClutterStageClass;
typedef struct _ClutterStagePrivate ClutterStagePrivate;
/**
* ClutterStage:
*
* The #ClutterStage structure contains only private data
* and should be accessed using the provided API
*
* Since: 0.2
*/
struct _ClutterStage
{
/*< private >*/
ClutterGroup parent_instance;
ClutterStagePrivate *priv;
};
/**
* ClutterStageClass:
* @activate: handler for the #ClutterStage::activate signal
* @deactivate: handler for the #ClutterStage::deactivate signal
* @delete_event: handler for the #ClutterStage::delete-event signal
*
* The #ClutterStageClass structure contains only private data
*
* Since: 0.2
*/
struct _ClutterStageClass
{
/*< private >*/
ClutterGroupClass parent_class;
/*< public >*/
/* signals */
void (* activate) (ClutterStage *stage);
void (* deactivate) (ClutterStage *stage);
gboolean (* delete_event) (ClutterStage *stage,
ClutterEvent *event);
void (* paint_view) (ClutterStage *stage,
ClutterStageView *view,
const cairo_region_t *redraw_clip);
/*< private >*/
/* padding for future expansion */
gpointer _padding_dummy[30];
};
/**
* ClutterPerspective:
* @fovy: the field of view angle, in degrees, in the y direction
* @aspect: the aspect ratio that determines the field of view in the x
* direction. The aspect ratio is the ratio of x (width) to y (height)
* @z_near: the distance from the viewer to the near clipping
* plane (always positive)
* @z_far: the distance from the viewer to the far clipping
* plane (always positive)
*
* Stage perspective definition. #ClutterPerspective is only used by
* the fixed point version of clutter_stage_set_perspective().
*
* Since: 0.4
*/
struct _ClutterPerspective
{
gfloat fovy;
gfloat aspect;
gfloat z_near;
gfloat z_far;
};
/**
* ClutterFrameInfo: (skip)
*/
struct _ClutterFrameInfo
{
int64_t frame_counter;
int64_t presentation_time;
float refresh_rate;
};
typedef struct _ClutterCapture
{
cairo_surface_t *image;
cairo_rectangle_int_t rect;
} ClutterCapture;
CLUTTER_EXPORT
GType clutter_perspective_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
GType clutter_stage_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterActor * clutter_stage_new (void);
CLUTTER_EXPORT
void clutter_stage_set_perspective (ClutterStage *stage,
ClutterPerspective *perspective);
CLUTTER_EXPORT
void clutter_stage_get_perspective (ClutterStage *stage,
ClutterPerspective *perspective);
CLUTTER_EXPORT
void clutter_stage_show_cursor (ClutterStage *stage);
CLUTTER_EXPORT
void clutter_stage_hide_cursor (ClutterStage *stage);
CLUTTER_EXPORT
void clutter_stage_set_title (ClutterStage *stage,
const gchar *title);
CLUTTER_EXPORT
const gchar * clutter_stage_get_title (ClutterStage *stage);
CLUTTER_EXPORT
void clutter_stage_set_minimum_size (ClutterStage *stage,
guint width,
guint height);
CLUTTER_EXPORT
void clutter_stage_get_minimum_size (ClutterStage *stage,
guint *width,
guint *height);
CLUTTER_EXPORT
void clutter_stage_set_use_alpha (ClutterStage *stage,
gboolean use_alpha);
CLUTTER_EXPORT
gboolean clutter_stage_get_use_alpha (ClutterStage *stage);
CLUTTER_EXPORT
void clutter_stage_set_key_focus (ClutterStage *stage,
ClutterActor *actor);
CLUTTER_EXPORT
ClutterActor * clutter_stage_get_key_focus (ClutterStage *stage);
CLUTTER_EXPORT
void clutter_stage_set_throttle_motion_events (ClutterStage *stage,
gboolean throttle);
CLUTTER_EXPORT
gboolean clutter_stage_get_throttle_motion_events (ClutterStage *stage);
CLUTTER_EXPORT
void clutter_stage_set_motion_events_enabled (ClutterStage *stage,
gboolean enabled);
CLUTTER_EXPORT
gboolean clutter_stage_get_motion_events_enabled (ClutterStage *stage);
CLUTTER_EXPORT
void clutter_stage_set_accept_focus (ClutterStage *stage,
gboolean accept_focus);
CLUTTER_EXPORT
gboolean clutter_stage_get_accept_focus (ClutterStage *stage);
CLUTTER_EXPORT
gboolean clutter_stage_event (ClutterStage *stage,
ClutterEvent *event);
CLUTTER_EXPORT
ClutterActor * clutter_stage_get_actor_at_pos (ClutterStage *stage,
ClutterPickMode pick_mode,
float x,
float y);
CLUTTER_EXPORT
guchar * clutter_stage_read_pixels (ClutterStage *stage,
gint x,
gint y,
gint width,
gint height);
CLUTTER_EXPORT
void clutter_stage_ensure_viewport (ClutterStage *stage);
CLUTTER_EXPORT
void clutter_stage_ensure_redraw (ClutterStage *stage);
CLUTTER_EXPORT
gboolean clutter_stage_is_redraw_queued (ClutterStage *stage);
#ifdef CLUTTER_ENABLE_EXPERIMENTAL_API
CLUTTER_EXPORT
void clutter_stage_set_sync_delay (ClutterStage *stage,
gint sync_delay);
CLUTTER_EXPORT
void clutter_stage_skip_sync_delay (ClutterStage *stage);
#endif
CLUTTER_EXPORT
void clutter_stage_schedule_update (ClutterStage *stage);
CLUTTER_EXPORT
gboolean clutter_stage_get_capture_final_size (ClutterStage *stage,
cairo_rectangle_int_t *rect,
int *width,
int *height,
float *scale);
CLUTTER_EXPORT
gboolean clutter_stage_capture (ClutterStage *stage,
gboolean paint,
cairo_rectangle_int_t *rect,
ClutterCapture **out_captures,
int *out_n_captures);
CLUTTER_EXPORT
ClutterStageView * clutter_stage_get_view_at (ClutterStage *stage,
float x,
float y);
G_END_DECLS
#endif /* __CLUTTER_STAGE_H__ */
muffin-6.4.1/clutter/clutter/clutter-drag-action.h 0000664 0001750 0001750 00000014643 14723361714 021137 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_DRAG_ACTION_H__
#define __CLUTTER_DRAG_ACTION_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_DRAG_ACTION (clutter_drag_action_get_type ())
#define CLUTTER_DRAG_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_DRAG_ACTION, ClutterDragAction))
#define CLUTTER_IS_DRAG_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_DRAG_ACTION))
#define CLUTTER_DRAG_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_DRAG_ACTION, ClutterDragActionClass))
#define CLUTTER_IS_DRAG_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_DRAG_ACTION))
#define CLUTTER_DRAG_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_DRAG_ACTION, ClutterDragActionClass))
typedef struct _ClutterDragAction ClutterDragAction;
typedef struct _ClutterDragActionPrivate ClutterDragActionPrivate;
typedef struct _ClutterDragActionClass ClutterDragActionClass;
/**
* ClutterDragAction:
*
* The #ClutterDragAction structure contains only
* private data and should be accessed using the provided API
*
* Since: 1.4
*/
struct _ClutterDragAction
{
/*< private >*/
ClutterAction parent_instance;
ClutterDragActionPrivate *priv;
};
/**
* ClutterDragActionClass:
* @drag_begin: class handler of the #ClutterDragAction::drag-begin signal
* @drag_motion: class handler of the #ClutterDragAction::drag-motion signal
* @drag_end: class handler of the #ClutterDragAction::drag-end signal
* @drag_progress: class handler of the #ClutterDragAction::drag-progress signal
*
* The #ClutterDragActionClass structure contains
* only private data
*
* Since: 1.4
*/
struct _ClutterDragActionClass
{
/*< private >*/
ClutterActionClass parent_class;
/*< public >*/
void (* drag_begin) (ClutterDragAction *action,
ClutterActor *actor,
gfloat event_x,
gfloat event_y,
ClutterModifierType modifiers);
void (* drag_motion) (ClutterDragAction *action,
ClutterActor *actor,
gfloat delta_x,
gfloat delta_y);
void (* drag_end) (ClutterDragAction *action,
ClutterActor *actor,
gfloat event_x,
gfloat event_y,
ClutterModifierType modifiers);
gboolean (* drag_progress) (ClutterDragAction *action,
ClutterActor *actor,
gfloat delta_x,
gfloat delta_y);
/*< private >*/
void (* _clutter_drag_action1) (void);
void (* _clutter_drag_action2) (void);
void (* _clutter_drag_action3) (void);
void (* _clutter_drag_action4) (void);
};
CLUTTER_EXPORT
GType clutter_drag_action_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterAction * clutter_drag_action_new (void);
CLUTTER_EXPORT
void clutter_drag_action_set_drag_threshold (ClutterDragAction *action,
gint x_threshold,
gint y_threshold);
CLUTTER_EXPORT
void clutter_drag_action_get_drag_threshold (ClutterDragAction *action,
guint *x_threshold,
guint *y_threshold);
CLUTTER_EXPORT
void clutter_drag_action_set_drag_handle (ClutterDragAction *action,
ClutterActor *handle);
CLUTTER_EXPORT
ClutterActor * clutter_drag_action_get_drag_handle (ClutterDragAction *action);
CLUTTER_EXPORT
void clutter_drag_action_set_drag_axis (ClutterDragAction *action,
ClutterDragAxis axis);
CLUTTER_EXPORT
ClutterDragAxis clutter_drag_action_get_drag_axis (ClutterDragAction *action);
CLUTTER_EXPORT
void clutter_drag_action_get_press_coords (ClutterDragAction *action,
gfloat *press_x,
gfloat *press_y);
CLUTTER_EXPORT
void clutter_drag_action_get_motion_coords (ClutterDragAction *action,
gfloat *motion_x,
gfloat *motion_y);
CLUTTER_EXPORT
gboolean clutter_drag_action_get_drag_area (ClutterDragAction *action,
graphene_rect_t *drag_area);
CLUTTER_EXPORT
void clutter_drag_action_set_drag_area (ClutterDragAction *action,
const graphene_rect_t *drag_area);
G_END_DECLS
#endif /* __CLUTTER_DRAG_ACTION_H__ */
muffin-6.4.1/clutter/clutter/clutter-actor.c 0000664 0001750 0001750 00002402164 14723361714 020053 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum
*
* Copyright (C) 2006, 2007, 2008 OpenedHand Ltd
* Copyright (C) 2009, 2010, 2011, 2012 Intel Corp
*
* 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 .
*/
/**
* SECTION:clutter-actor
* @short_description: The basic element of the scene graph
*
* The ClutterActor class is the basic element of the scene graph in Clutter,
* and it encapsulates the position, size, and transformations of a node in
* the graph.
*
* ## Actor transformations ## {#clutter-actor-transformations}
*
* Each actor can be transformed using methods like clutter_actor_set_scale()
* or clutter_actor_set_rotation(). The order in which the transformations are
* applied is decided by Clutter and it is the following:
*
* 1. translation by the origin of the #ClutterActor:allocation property
* 2. translation by the actor's #ClutterActor:z-position property
* 3. translation by the actor's #ClutterActor:pivot-point property
* 4. scaling by the #ClutterActor:scale-x and #ClutterActor:scale-y factors
* 5. rotation around the #ClutterActor:rotation-angle-x and #ClutterActor:rotation-center-x
* 6. rotation around the #ClutterActor:rotation-angle-y and #ClutterActor:rotation-center-y
* 7. rotation around the #ClutterActor:rotation-angle-z and #ClutterActor:rotation-center-z
* 8. negative translation by the #ClutterActor:anchor-x and #ClutterActor:anchor-y point.
* 9. negative translation by the actor's #ClutterActor:pivot-point
*
* ## Modifying an actor's geometry ## {#clutter-actor-geometry}
*
* Each actor has a bounding box, called #ClutterActor:allocation
* which is either set by its parent or explicitly through the
* clutter_actor_set_position() and clutter_actor_set_size() methods.
* Each actor also has an implicit preferred size.
*
* An actor’s preferred size can be defined by any subclass by
* overriding the #ClutterActorClass.get_preferred_width() and the
* #ClutterActorClass.get_preferred_height() virtual functions, or it can
* be explicitly set by using clutter_actor_set_width() and
* clutter_actor_set_height().
*
* An actor’s position can be set explicitly by using
* clutter_actor_set_x() and clutter_actor_set_y(); the coordinates are
* relative to the origin of the actor’s parent.
*
* ## Managing actor children ## {#clutter-actor-children}
*
* Each actor can have multiple children, by calling
* clutter_actor_add_child() to add a new child actor, and
* clutter_actor_remove_child() to remove an existing child. #ClutterActor
* will hold a reference on each child actor, which will be released when
* the child is removed from its parent, or destroyed using
* clutter_actor_destroy().
*
* |[
* ClutterActor *actor = clutter_actor_new ();
*
* // set the bounding box of the actor
* clutter_actor_set_position (actor, 0, 0);
* clutter_actor_set_size (actor, 480, 640);
*
* // set the background color of the actor
* clutter_actor_set_background_color (actor, CLUTTER_COLOR_Orange);
*
* // set the bounding box of the child, relative to the parent
* ClutterActor *child = clutter_actor_new ();
* clutter_actor_set_position (child, 20, 20);
* clutter_actor_set_size (child, 80, 240);
*
* // set the background color of the child
* clutter_actor_set_background_color (child, CLUTTER_COLOR_Blue);
*
* // add the child to the actor
* clutter_actor_add_child (actor, child);
* ]|
*
* Children can be inserted at a given index, or above and below
* another child actor. The order of insertion determines the order of the
* children when iterating over them. Iterating over children is performed
* by using clutter_actor_get_first_child(), clutter_actor_get_previous_sibling(),
* clutter_actor_get_next_sibling(), and clutter_actor_get_last_child(). It is
* also possible to retrieve a list of children by using
* clutter_actor_get_children(), as well as retrieving a specific child at a
* given index by using clutter_actor_get_child_at_index().
*
* If you need to track additions of children to a #ClutterActor, use
* the #ClutterContainer::actor-added signal; similarly, to track removals
* of children from a ClutterActor, use the #ClutterContainer::actor-removed
* signal.
*
* See [basic-actor.c](https://git.gnome.org/browse/clutter/tree/examples/basic-actor.c?h=clutter-1.18).
*
* ## Painting an actor ## {#clutter-actor-painting}
*
* There are three ways to paint an actor:
*
* - set a delegate #ClutterContent as the value for the #ClutterActor:content property of the actor
* - subclass #ClutterActor and override the #ClutterActorClass.paint_node() virtual function
* - subclass #ClutterActor and override the #ClutterActorClass.paint() virtual function.
*
* A #ClutterContent is a delegate object that takes over the painting
* operations of one, or more actors. The #ClutterContent painting will
* be performed on top of the #ClutterActor:background-color of the actor,
* and before calling the actor's own implementation of the
* #ClutterActorClass.paint_node() virtual function.
*
* |[
* ClutterActor *actor = clutter_actor_new ();
*
* // set the bounding box
* clutter_actor_set_position (actor, 50, 50);
* clutter_actor_set_size (actor, 100, 100);
*
* // set the content; the image_content variable is set elsewhere
* clutter_actor_set_content (actor, image_content);
* ]|
*
* The #ClutterActorClass.paint_node() virtual function is invoked whenever
* an actor needs to be painted. The implementation of the virtual function
* must only paint the contents of the actor itself, and not the contents of
* its children, if the actor has any.
*
* The #ClutterPaintNode passed to the virtual function is the local root of
* the render tree; any node added to it will be rendered at the correct
* position, as defined by the actor's #ClutterActor:allocation.
*
* |[
* static void
* my_actor_paint_node (ClutterActor *actor,
* ClutterPaintNode *root)
* {
* ClutterPaintNode *node;
* ClutterActorBox box;
*
* // where the content of the actor should be painted
* clutter_actor_get_allocation_box (actor, &box);
*
* // the cogl_texture variable is set elsewhere
* node = clutter_texture_node_new (cogl_texture, CLUTTER_COLOR_White,
* CLUTTER_SCALING_FILTER_TRILINEAR,
* CLUTTER_SCALING_FILTER_LINEAR);
*
* // paint the content of the node using the allocation
* clutter_paint_node_add_rectangle (node, &box);
*
* // add the node, and transfer ownership
* clutter_paint_node_add_child (root, node);
* clutter_paint_node_unref (node);
* }
*
* The #ClutterActorClass.paint() virtual function is invoked when the
* #ClutterActor::paint signal is emitted, and after the other signal
* handlers have been invoked. Overriding the paint virtual function
* gives total control to the paint sequence of the actor itself,
* including the children of the actor, if any.
*
* It is strongly discouraged to override the #ClutterActorClass.paint()
* virtual function, as well as connecting to the #ClutterActor::paint
* signal. These hooks into the paint sequence are considered legacy, and
* will be removed when the Clutter API changes.
*
* ## Handling events on an actor ## {#clutter-actor-event-handling}
*
* A #ClutterActor can receive and handle input device events, for
* instance pointer events and key events, as long as its
* #ClutterActor:reactive property is set to %TRUE.
*
* Once an actor has been determined to be the source of an event,
* Clutter will traverse the scene graph from the top-level actor towards the
* event source, emitting the #ClutterActor::captured-event signal on each
* ancestor until it reaches the source; this phase is also called
* the "capture" phase. If the event propagation was not stopped, the graph
* is walked backwards, from the source actor to the top-level, and the
* #ClutterActor::event signal is emitted, alongside eventual event-specific
* signals like #ClutterActor::button-press-event or #ClutterActor::motion-event;
* this phase is also called the "bubble" phase.
*
* At any point of the signal emission, signal handlers can stop the propagation
* through the scene graph by returning %CLUTTER_EVENT_STOP; otherwise, they can
* continue the propagation by returning %CLUTTER_EVENT_PROPAGATE.
*
* ## Animation ## {#clutter-actor-animation}
*
* Animation is a core concept of modern user interfaces; Clutter provides a
* complete and powerful animation framework that automatically tweens the
* actor's state without requiring direct, frame by frame manipulation from
* your application code. You have two models at your disposal:
*
* - an implicit animation model
* - an explicit animation model
*
* The implicit animation model of Clutter assumes that all the
* changes in an actor state should be gradual and asynchronous; Clutter
* will automatically transition an actor's property change between the
* current state and the desired one without manual intervention, if the
* property is defined to be animatable in its documentation.
*
* By default, in the 1.0 API series, the transition happens with a duration
* of zero milliseconds, and the implicit animation is an opt in feature to
* retain backwards compatibility.
*
* Implicit animations depend on the current easing state; in order to use
* the default easing state for an actor you should call the
* clutter_actor_save_easing_state() function:
*
* |[
* // assume that the actor is currently positioned at (100, 100)
*
* // store the current easing state and reset the new easing state to
* // its default values
* clutter_actor_save_easing_state (actor);
*
* // change the actor's position
* clutter_actor_set_position (actor, 500, 500);
*
* // restore the previously saved easing state
* clutter_actor_restore_easing_state (actor);
* ]|
*
* The example above will trigger an implicit animation of the
* actor between its current position to a new position.
*
* Implicit animations use a default duration of 250 milliseconds,
* and a default easing mode of %CLUTTER_EASE_OUT_CUBIC, unless you call
* clutter_actor_set_easing_mode() and clutter_actor_set_easing_duration()
* after changing the easing state of the actor.
*
* It is possible to animate multiple properties of an actor
* at the same time, and you can animate multiple actors at the same
* time as well, for instance:
*
* |[
* clutter_actor_save_easing_state (actor);
*
* // animate the actor's opacity and depth
* clutter_actor_set_opacity (actor, 0);
* clutter_actor_set_depth (actor, -100);
*
* clutter_actor_restore_easing_state (actor);
*
* clutter_actor_save_easing_state (another_actor);
*
* // animate another actor's opacity
* clutter_actor_set_opacity (another_actor, 255);
* clutter_actor_set_depth (another_actor, 100);
*
* clutter_actor_restore_easing_state (another_actor);
* ]|
*
* Changing the easing state will affect all the following property
* transitions, but will not affect existing transitions.
*
* It is important to note that if you modify the state on an
* animatable property while a transition is in flight, the transition's
* final value will be updated, as well as its duration and progress
* mode by using the current easing state; for instance, in the following
* example:
*
* |[
* clutter_actor_save_easing_state (actor);
* clutter_actor_set_easing_duration (actor, 1000);
* clutter_actor_set_x (actor, 200);
* clutter_actor_restore_easing_state (actor);
*
* clutter_actor_save_easing_state (actor);
* clutter_actor_set_easing_duration (actor, 500);
* clutter_actor_set_x (actor, 100);
* clutter_actor_restore_easing_state (actor);
* ]|
*
* the first call to clutter_actor_set_x() will begin a transition
* of the #ClutterActor:x property from the current value to the value of
* 200 over a duration of one second; the second call to clutter_actor_set_x()
* will change the transition's final value to 100 and the duration to 500
* milliseconds.
*
* It is possible to receive a notification of the completion of an
* implicit transition by using the #ClutterActor::transition-stopped
* signal, decorated with the name of the property. In case you want to
* know when all the currently in flight transitions are complete, use
* the #ClutterActor::transitions-completed signal instead.
*
* It is possible to retrieve the #ClutterTransition used by the
* animatable properties by using clutter_actor_get_transition() and using
* the property name as the transition name.
*
* The explicit animation model supported by Clutter requires that
* you create a #ClutterTransition object, and optionally set the initial
* and final values. The transition will not start unless you add it to the
* #ClutterActor.
*
* |[
* ClutterTransition *transition;
*
* transition = clutter_property_transition_new ("opacity");
* clutter_timeline_set_duration (CLUTTER_TIMELINE (transition), 3000);
* clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (transition), 2);
* clutter_timeline_set_auto_reverse (CLUTTER_TIMELINE (transition), TRUE);
* clutter_transition_set_from (transition, G_TYPE_UINT, 255);
* clutter_transition_set_to (transition, G_TYPE_UINT, 0);
*
* clutter_actor_add_transition (actor, "animate-opacity", transition);
* ]|
*
* The example above will animate the #ClutterActor:opacity property
* of an actor between fully opaque and fully transparent, and back, over
* a span of 3 seconds. The animation does not begin until it is added to
* the actor.
*
* The explicit animation API applies to all #GObject properties,
* as well as the custom properties defined through the #ClutterAnimatable
* interface, regardless of whether they are defined as implicitly
* animatable or not.
*
* The explicit animation API should also be used when using custom
* animatable properties for #ClutterAction, #ClutterConstraint, and
* #ClutterEffect instances associated to an actor; see the section on
* custom animatable properties below for an example.
*
* Finally, explicit animations are useful for creating animations
* that run continuously, for instance:
*
* |[
* // this animation will pulse the actor's opacity continuously
* ClutterTransition *transition;
* ClutterInterval *interval;
*
* transition = clutter_property_transition_new ("opacity");
*
* // we want to animate the opacity between 0 and 255
* clutter_transition_set_from (transition, G_TYPE_UINT, 0);
* clutter_transition_set_to (transition, G_TYPE_UINT, 255);
*
* // over a one second duration, running an infinite amount of times
* clutter_timeline_set_duration (CLUTTER_TIMELINE (transition), 1000);
* clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (transition), -1);
*
* // we want to fade in and out, so we need to auto-reverse the transition
* clutter_timeline_set_auto_reverse (CLUTTER_TIMELINE (transition), TRUE);
*
* // and we want to use an easing function that eases both in and out
* clutter_timeline_set_progress_mode (CLUTTER_TIMELINE (transition),
* CLUTTER_EASE_IN_OUT_CUBIC);
*
* // add the transition to the desired actor to start it
* clutter_actor_add_transition (actor, "opacityAnimation", transition);
* ]|
*
* ## Implementing an actor ## {#clutter-actor-implementing}
*
* Careful consideration should be given when deciding to implement
* a #ClutterActor sub-class. It is generally recommended to implement a
* sub-class of #ClutterActor only for actors that should be used as leaf
* nodes of a scene graph.
*
* If your actor should be painted in a custom way, you should
* override the #ClutterActor::paint signal class handler. You can either
* opt to chain up to the parent class implementation or decide to fully
* override the default paint implementation; Clutter will set up the
* transformations and clip regions prior to emitting the #ClutterActor::paint
* signal.
*
* By overriding the #ClutterActorClass.get_preferred_width() and
* #ClutterActorClass.get_preferred_height() virtual functions it is
* possible to change or provide the preferred size of an actor; similarly,
* by overriding the #ClutterActorClass.allocate() virtual function it is
* possible to control the layout of the children of an actor. Make sure to
* always chain up to the parent implementation of the
* #ClutterActorClass.allocate() virtual function.
*
* In general, it is strongly encouraged to use delegation and composition
* instead of direct subclassing.
*
* ## ClutterActor custom properties for ClutterScript ## {#clutter-actor-custom-script}
*
* #ClutterActor defines a custom "rotation" property which allows a short-hand
* description of the rotations to be applied to an actor.
*
* The syntax of the "rotation" property is the following:
*
* |[
* "rotation" : [ { "" : [ , [ ] ] } ]
* ]|
*
* where:
*
* - axis is the name of an enumeration value of type #ClutterRotateAxis
* - angle is a floating point value representing the rotation angle on the given axis in degrees
* - center-point is an optional array, and if present it must contain the center of rotation as described by two coordinates:
* - Y and Z for "x-axis"
* - X and Z for "y-axis"
* - X and Y for "z-axis".
*
* #ClutterActor also defines a scriptable "margin" property which follows the CSS "margin" shorthand.
*
* |[
* // 4 values
* "margin" : [ top, right, bottom, left ]
* // 3 values
* "margin" : [ top, left/right, bottom ]
* // 2 values
* "margin" : [ top/bottom, left/right ]
* // 1 value
* "margin" : [ top/right/bottom/left ]
* ]|
*
* #ClutterActor will also parse every positional and dimensional
* property defined as a string through clutter_units_from_string(); you
* should read the documentation for the #ClutterUnits parser format for
* the valid units and syntax.
*
* ## Custom animatable properties
*
* #ClutterActor allows accessing properties of #ClutterAction,
* #ClutterEffect, and #ClutterConstraint instances associated to an actor
* instance for animation purposes, as well as its #ClutterLayoutManager.
*
* In order to access a specific #ClutterAction or a #ClutterConstraint
* property it is necessary to set the #ClutterActorMeta:name property on the
* given action or constraint.
*
* The property can be accessed using the following syntax:
*
* |[
* @..
* ]|
*
* - the initial `@` is mandatory
* - the `section` fragment can be one between "actions", "constraints" and "effects"
* - the `meta-name` fragment is the name of the action, effect, or constraint, as
* specified by the #ClutterActorMeta:name property of #ClutterActorMeta
* - the `property-name` fragment is the name of the action, effect, or constraint
* property to be animated.
*
* The example below animates a #ClutterBindConstraint applied to an actor
* using an explicit transition. The `rect` actor has a binding constraint
* on the `origin` actor, and in its initial state is overlapping the actor
* to which is bound to.
*
* As the actor has only one #ClutterLayoutManager, the syntax for accessing its
* properties is simpler:
*
* |[
* @layout.
* ]|
*
* |[
* constraint = clutter_bind_constraint_new (origin, CLUTTER_BIND_X, 0.0);
* clutter_actor_meta_set_name (CLUTTER_ACTOR_META (constraint), "bind-x");
* clutter_actor_add_constraint (rect, constraint);
*
* constraint = clutter_bind_constraint_new (origin, CLUTTER_BIND_Y, 0.0);
* clutter_actor_meta_set_name (CLUTTER_ACTOR_META (constraint), "bind-y");
* clutter_actor_add_constraint (rect, constraint);
*
* clutter_actor_set_reactive (origin, TRUE);
*
* g_signal_connect (origin, "button-press-event",
* G_CALLBACK (on_button_press),
* rect);
* ]|
*
* On button press, the rectangle "slides" from behind the actor to
* which is bound to, using the #ClutterBindConstraint:offset property to
* achieve the effect:
*
* |[
* gboolean
* on_button_press (ClutterActor *origin,
* ClutterEvent *event,
* ClutterActor *rect)
* {
* ClutterTransition *transition;
*
* // the offset that we want to apply; this will make the actor
* // slide in from behind the origin and rest at the right of
* // the origin, plus a padding value
* float new_offset = clutter_actor_get_width (origin) + h_padding;
*
* // the property we wish to animate; the "@constraints" section
* // tells Clutter to check inside the constraints associated
* // with the actor; the "bind-x" section is the name of the
* // constraint; and the "offset" is the name of the property
* // on the constraint
* const char *prop = "@constraints.bind-x.offset";
*
* // create a new transition for the given property
* transition = clutter_property_transition_new (prop);
*
* // set the easing mode and duration
* clutter_timeline_set_progress_mode (CLUTTER_TIMELINE (transition),
* CLUTTER_EASE_OUT_CUBIC);
* clutter_timeline_set_duration (CLUTTER_TIMELINE (transition), 500);
*
* // create the interval with the initial and final values
* clutter_transition_set_from (transition, G_TYPE_FLOAT, 0.f);
* clutter_transition_set_to (transition, G_TYPE_FLOAT, new_offset);
*
* // add the transition to the actor; this causes the animation
* // to start. the name "offsetAnimation" can be used to retrieve
* // the transition later
* clutter_actor_add_transition (rect, "offsetAnimation", transition);
*
* // we handled the event
* return CLUTTER_EVENT_STOP;
* }
* ]|
*/
/**
* CLUTTER_ACTOR_IS_MAPPED:
* @a: a #ClutterActor
*
* Evaluates to %TRUE if the %CLUTTER_ACTOR_MAPPED flag is set.
*
* The mapped state is set when the actor is visible and all its parents up
* to a top-level (e.g. a #ClutterStage) are visible, realized, and mapped.
*
* This check can be used to see if an actor is going to be painted, as only
* actors with the %CLUTTER_ACTOR_MAPPED flag set are going to be painted.
*
* The %CLUTTER_ACTOR_MAPPED flag is managed by Clutter itself, and it should
* not be checked directly; instead, the recommended usage is to connect a
* handler on the #GObject::notify signal for the #ClutterActor:mapped
* property of #ClutterActor, and check the presence of
* the %CLUTTER_ACTOR_MAPPED flag on state changes.
*
* It is also important to note that Clutter may delay the changes of
* the %CLUTTER_ACTOR_MAPPED flag on top-levels due to backend-specific
* limitations, or during the reparenting of an actor, to optimize
* unnecessary (and potentially expensive) state changes.
*
* Since: 0.2
*
* Deprecated: 1.24: Use clutter_actor_is_mapped() or the #ClutterActor:mapped
* property instead of this macro.
*/
/**
* CLUTTER_ACTOR_IS_REALIZED:
* @a: a #ClutterActor
*
* Evaluates to %TRUE if the %CLUTTER_ACTOR_REALIZED flag is set.
*
* The realized state has an actor-dependant interpretation. If an
* actor wants to delay allocating resources until it is attached to a
* stage, it may use the realize state to do so. However it is
* perfectly acceptable for an actor to allocate Cogl resources before
* being realized because there is only one drawing context used by Clutter
* so any resources will work on any stage. If an actor is mapped it
* must also be realized, but an actor can be realized and unmapped
* (this is so hiding an actor temporarily doesn't do an expensive
* unrealize/realize).
*
* To be realized an actor must be inside a stage, and all its parents
* must be realized.
*
* Since: 0.2
*
* Deprecated: 1.24: Use clutter_actor_is_realized() or the #ClutterActor:realized
* property instead of this macro.
*/
/**
* CLUTTER_ACTOR_IS_VISIBLE:
* @a: a #ClutterActor
*
* Evaluates to %TRUE if the actor has been shown, %FALSE if it's hidden.
* Equivalent to the ClutterActor::visible object property.
*
* Note that an actor is only painted onscreen if it's mapped, which
* means it's visible, and all its parents are visible, and one of the
* parents is a toplevel stage; see also %CLUTTER_ACTOR_IS_MAPPED.
*
* Since: 0.2
*
* Deprecated: 1.24: Use clutter_actor_is_visible() or the #ClutterActor:visible
* property instead of this macro.
*/
/**
* CLUTTER_ACTOR_IS_REACTIVE:
* @a: a #ClutterActor
*
* Evaluates to %TRUE if the %CLUTTER_ACTOR_REACTIVE flag is set.
*
* Only reactive actors will receive event-related signals.
*
* Since: 0.6
*
* Deprecated: 1.24: Use clutter_actor_get_reactive() or the
* #ClutterActor:reactive property instead of this macro.
*/
#include "clutter-build-config.h"
#include
#include
#include
#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
#define CLUTTER_ENABLE_EXPERIMENTAL_API
#include "clutter-actor-private.h"
#include "clutter-action.h"
#include "clutter-actor-meta-private.h"
#include "clutter-animatable.h"
#include "clutter-color-static.h"
#include "clutter-color.h"
#include "clutter-constraint-private.h"
#include "clutter-container-private.h"
#include "clutter-content-private.h"
#include "clutter-debug.h"
#include "clutter-easing.h"
#include "clutter-effect-private.h"
#include "clutter-enum-types.h"
#include "clutter-fixed-layout.h"
#include "clutter-flatten-effect.h"
#include "clutter-interval.h"
#include "clutter-main.h"
#include "clutter-marshal.h"
#include "clutter-mutter.h"
#include "clutter-paint-context-private.h"
#include "clutter-paint-nodes.h"
#include "clutter-paint-node-private.h"
#include "clutter-paint-volume-private.h"
#include "clutter-private.h"
#include "clutter-property-transition.h"
#include "clutter-scriptable.h"
#include "clutter-script-private.h"
#include "clutter-stage-private.h"
#include "clutter-timeline.h"
#include "clutter-transition.h"
#include "clutter-units.h"
#include "deprecated/clutter-actor.h"
#include "deprecated/clutter-container.h"
/* Internal enum used to control mapped state update. This is a hint
* which indicates when to do something other than just enforce
* invariants.
*/
typedef enum
{
MAP_STATE_CHECK, /* just enforce invariants. */
MAP_STATE_MAKE_UNREALIZED, /* force unrealize, ignoring invariants,
* used when about to unparent.
*/
MAP_STATE_MAKE_MAPPED, /* set mapped, error if invariants not met;
* used to set mapped on toplevels.
*/
MAP_STATE_MAKE_UNMAPPED /* set unmapped, even if parent is mapped,
* used just before unmapping parent.
*/
} MapStateChange;
/* 3 entries should be a good compromise, few layout managers
* will ask for 3 different preferred size in each allocation cycle */
#define N_CACHED_SIZE_REQUESTS 3
struct _ClutterActorPrivate
{
/* request mode */
ClutterRequestMode request_mode;
/* our cached size requests for different width / height */
SizeRequest width_requests[N_CACHED_SIZE_REQUESTS];
SizeRequest height_requests[N_CACHED_SIZE_REQUESTS];
/* An age of 0 means the entry is not set */
guint cached_height_age;
guint cached_width_age;
/* the bounding box of the actor, relative to the parent's
* allocation
*/
ClutterActorBox allocation;
ClutterAllocationFlags allocation_flags;
/* clip, in actor coordinates */
graphene_rect_t clip;
/* the cached transformation matrix; see apply_transform() */
CoglMatrix transform;
float resource_scale;
guint8 opacity;
gint opacity_override;
unsigned int inhibit_culling_counter;
ClutterOffscreenRedirect offscreen_redirect;
/* This is an internal effect used to implement the
offscreen-redirect property */
ClutterEffect *flatten_effect;
/* scene graph */
ClutterActor *parent;
ClutterActor *prev_sibling;
ClutterActor *next_sibling;
ClutterActor *first_child;
ClutterActor *last_child;
gint n_children;
/* tracks whenever the children of an actor are changed; the
* age is incremented by 1 whenever an actor is added or
* removed. the age is not incremented when the first or the
* last child pointers are changed, or when grandchildren of
* an actor are changed.
*/
gint age;
gchar *name; /* a non-unique name, used for debugging */
/* a back-pointer to the Pango context that we can use
* to create pre-configured PangoLayout
*/
PangoContext *pango_context;
/* the text direction configured for this child - either by
* application code, or by the actor's parent
*/
ClutterTextDirection text_direction;
/* meta classes */
ClutterMetaGroup *actions;
ClutterMetaGroup *constraints;
ClutterMetaGroup *effects;
/* delegate object used to allocate the children of this actor */
ClutterLayoutManager *layout_manager;
/* delegate object used to paint the contents of this actor */
ClutterContent *content;
ClutterActorBox content_box;
ClutterContentGravity content_gravity;
ClutterScalingFilter min_filter;
ClutterScalingFilter mag_filter;
ClutterContentRepeat content_repeat;
/* used when painting, to update the paint volume */
ClutterEffect *current_effect;
/* This is used to store an effect which needs to be redrawn. A
redraw can be queued to start from a particular effect. This is
used by parametrised effects that can cache an image of the
actor. If a parameter of the effect changes then it only needs to
redraw the cached image, not the actual actor. The pointer is
only valid if is_dirty == TRUE. If the pointer is NULL then the
whole actor is dirty. */
ClutterEffect *effect_to_redraw;
/* This is used when painting effects to implement the
clutter_actor_continue_paint() function. It points to the node in
the list of effects that is next in the chain */
const GList *next_effect_to_paint;
ClutterPaintVolume paint_volume;
/* NB: This volume isn't relative to this actor, it is in eye
* coordinates so that it can remain valid after the actor changes.
*/
ClutterPaintVolume last_paint_volume;
ClutterStageQueueRedrawEntry *queue_redraw_entry;
ClutterColor bg_color;
#ifdef CLUTTER_ENABLE_DEBUG
/* a string used for debugging messages */
gchar *debug_name;
#endif
/* a set of clones of the actor */
GHashTable *clones;
/* whether the actor is inside a cloned branch; this
* value is propagated to all the actor's children
*/
gulong in_cloned_branch;
GListModel *child_model;
ClutterActorCreateChildFunc create_child_func;
gpointer create_child_data;
GDestroyNotify create_child_notify;
gulong resolution_changed_id;
gulong font_changed_id;
/* bitfields: KEEP AT THE END */
/* fixed position and sizes */
guint position_set : 1;
guint min_width_set : 1;
guint min_height_set : 1;
guint natural_width_set : 1;
guint natural_height_set : 1;
/* cached request is invalid (implies allocation is too) */
guint needs_width_request : 1;
/* cached request is invalid (implies allocation is too) */
guint needs_height_request : 1;
/* cached allocation is invalid (request has changed, probably) */
guint needs_allocation : 1;
guint show_on_set_parent : 1;
guint has_clip : 1;
guint clip_to_allocation : 1;
guint enable_model_view_transform : 1;
guint enable_paint_unmapped : 1;
guint has_pointer : 1;
guint has_key_focus : 1;
guint propagated_one_redraw : 1;
guint paint_volume_valid : 1;
guint last_paint_volume_valid : 1;
guint in_clone_paint : 1;
guint transform_valid : 1;
/* This is TRUE if anything has queued a redraw since we were last
painted. In this case effect_to_redraw will point to an effect
the redraw was queued from or it will be NULL if the redraw was
queued without an effect. */
guint is_dirty : 1;
guint bg_color_set : 1;
guint content_box_valid : 1;
guint x_expand_set : 1;
guint y_expand_set : 1;
guint needs_compute_expand : 1;
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;
guint needs_compute_resource_scale : 1;
};
enum
{
PROP_0,
PROP_NAME,
/* X, Y, WIDTH, HEIGHT are "do what I mean" properties;
* when set they force a size request, when gotten they
* get the allocation if the allocation is valid, and the
* request otherwise
*/
PROP_X,
PROP_Y,
PROP_WIDTH,
PROP_HEIGHT,
PROP_POSITION,
PROP_SIZE,
/* Then the rest of these size-related properties are the "actual"
* underlying properties set or gotten by X, Y, WIDTH, HEIGHT
*/
PROP_FIXED_X,
PROP_FIXED_Y,
PROP_FIXED_POSITION_SET,
PROP_MIN_WIDTH,
PROP_MIN_WIDTH_SET,
PROP_MIN_HEIGHT,
PROP_MIN_HEIGHT_SET,
PROP_NATURAL_WIDTH,
PROP_NATURAL_WIDTH_SET,
PROP_NATURAL_HEIGHT,
PROP_NATURAL_HEIGHT_SET,
PROP_REQUEST_MODE,
/* Allocation properties are read-only */
PROP_ALLOCATION,
PROP_DEPTH, /* XXX:2.0 remove */
PROP_Z_POSITION,
PROP_CLIP_RECT,
PROP_HAS_CLIP,
PROP_CLIP_TO_ALLOCATION,
PROP_OPACITY,
PROP_OFFSCREEN_REDIRECT,
PROP_VISIBLE,
PROP_MAPPED,
PROP_REALIZED,
PROP_REACTIVE,
PROP_PIVOT_POINT,
PROP_PIVOT_POINT_Z,
PROP_SCALE_X,
PROP_SCALE_Y,
PROP_SCALE_Z,
PROP_SCALE_CENTER_X, /* XXX:2.0 remove */
PROP_SCALE_CENTER_Y, /* XXX:2.0 remove */
PROP_SCALE_GRAVITY, /* XXX:2.0 remove */
PROP_RESOURCE_SCALE,
PROP_ROTATION_ANGLE_X, /* XXX:2.0 rename to rotation-x */
PROP_ROTATION_ANGLE_Y, /* XXX:2.0 rename to rotation-y */
PROP_ROTATION_ANGLE_Z, /* XXX:2.0 rename to rotation-z */
PROP_ROTATION_CENTER_X, /* XXX:2.0 remove */
PROP_ROTATION_CENTER_Y, /* XXX:2.0 remove */
PROP_ROTATION_CENTER_Z, /* XXX:2.0 remove */
/* This property only makes sense for the z rotation because the
others would depend on the actor having a size along the
z-axis */
PROP_ROTATION_CENTER_Z_GRAVITY, /* XXX:2.0 remove */
PROP_ANCHOR_X, /* XXX:2.0 remove */
PROP_ANCHOR_Y, /* XXX:2.0 remove */
PROP_ANCHOR_GRAVITY, /*XXX:2.0 remove */
PROP_TRANSLATION_X,
PROP_TRANSLATION_Y,
PROP_TRANSLATION_Z,
PROP_TRANSFORM,
PROP_TRANSFORM_SET,
PROP_CHILD_TRANSFORM,
PROP_CHILD_TRANSFORM_SET,
PROP_SHOW_ON_SET_PARENT, /*XXX:2.0 remove */
PROP_TEXT_DIRECTION,
PROP_HAS_POINTER,
PROP_ACTIONS,
PROP_CONSTRAINTS,
PROP_EFFECT,
PROP_LAYOUT_MANAGER,
PROP_X_EXPAND,
PROP_Y_EXPAND,
PROP_X_ALIGN,
PROP_Y_ALIGN,
PROP_MARGIN_TOP,
PROP_MARGIN_BOTTOM,
PROP_MARGIN_LEFT,
PROP_MARGIN_RIGHT,
PROP_BACKGROUND_COLOR,
PROP_BACKGROUND_COLOR_SET,
PROP_FIRST_CHILD,
PROP_LAST_CHILD,
PROP_CONTENT,
PROP_CONTENT_GRAVITY,
PROP_CONTENT_BOX,
PROP_MINIFICATION_FILTER,
PROP_MAGNIFICATION_FILTER,
PROP_CONTENT_REPEAT,
PROP_LAST
};
static GParamSpec *obj_props[PROP_LAST];
enum
{
SHOW,
HIDE,
DESTROY,
PARENT_SET,
KEY_FOCUS_IN,
KEY_FOCUS_OUT,
PAINT,
PICK,
REALIZE,
UNREALIZE,
QUEUE_REDRAW,
QUEUE_RELAYOUT,
EVENT,
CAPTURED_EVENT,
BUTTON_PRESS_EVENT,
BUTTON_RELEASE_EVENT,
SCROLL_EVENT,
KEY_PRESS_EVENT,
KEY_RELEASE_EVENT,
MOTION_EVENT,
ENTER_EVENT,
LEAVE_EVENT,
ALLOCATION_CHANGED,
TRANSITIONS_COMPLETED,
TOUCH_EVENT,
TRANSITION_STOPPED,
LAST_SIGNAL
};
static guint actor_signals[LAST_SIGNAL] = { 0, };
typedef struct _TransitionClosure
{
ClutterActor *actor;
ClutterTransition *transition;
gchar *name;
gulong completed_id;
} TransitionClosure;
static void clutter_container_iface_init (ClutterContainerIface *iface);
static void clutter_scriptable_iface_init (ClutterScriptableIface *iface);
static void clutter_animatable_iface_init (ClutterAnimatableInterface *iface);
static void atk_implementor_iface_init (AtkImplementorIface *iface);
/* These setters are all static for now, maybe they should be in the
* public API, but they are perhaps obscure enough to leave only as
* properties
*/
static void clutter_actor_set_min_width (ClutterActor *self,
gfloat min_width);
static void clutter_actor_set_min_height (ClutterActor *self,
gfloat min_height);
static void clutter_actor_set_natural_width (ClutterActor *self,
gfloat natural_width);
static void clutter_actor_set_natural_height (ClutterActor *self,
gfloat natural_height);
static void clutter_actor_set_min_width_set (ClutterActor *self,
gboolean use_min_width);
static void clutter_actor_set_min_height_set (ClutterActor *self,
gboolean use_min_height);
static void clutter_actor_set_natural_width_set (ClutterActor *self,
gboolean use_natural_width);
static void clutter_actor_set_natural_height_set (ClutterActor *self,
gboolean use_natural_height);
static void clutter_actor_update_map_state (ClutterActor *self,
MapStateChange change);
static void clutter_actor_unrealize_not_hiding (ClutterActor *self);
/* Helper routines for managing anchor coords */
static void clutter_anchor_coord_get_units (ClutterActor *self,
const AnchorCoord *coord,
gfloat *x,
gfloat *y,
gfloat *z);
static void clutter_anchor_coord_set_units (AnchorCoord *coord,
gfloat x,
gfloat y,
gfloat z);
static ClutterGravity clutter_anchor_coord_get_gravity (const AnchorCoord *coord);
static void clutter_anchor_coord_set_gravity (AnchorCoord *coord,
ClutterGravity gravity);
static gboolean clutter_anchor_coord_is_zero (const AnchorCoord *coord);
static void _clutter_actor_get_relative_transformation_matrix (ClutterActor *self,
ClutterActor *ancestor,
CoglMatrix *matrix);
static ClutterPaintVolume *_clutter_actor_get_paint_volume_mutable (ClutterActor *self);
static guint8 clutter_actor_get_paint_opacity_internal (ClutterActor *self);
static inline void clutter_actor_set_background_color_internal (ClutterActor *self,
const ClutterColor *color);
static void on_layout_manager_changed (ClutterLayoutManager *manager,
ClutterActor *self);
static inline void clutter_actor_queue_compute_expand (ClutterActor *self);
static inline void clutter_actor_set_margin_internal (ClutterActor *self,
gfloat margin,
GParamSpec *pspec);
static void clutter_actor_set_transform_internal (ClutterActor *self,
const ClutterMatrix *transform);
static void clutter_actor_set_child_transform_internal (ClutterActor *self,
const ClutterMatrix *transform);
static void clutter_actor_realize_internal (ClutterActor *self);
static void clutter_actor_unrealize_internal (ClutterActor *self);
static gboolean clutter_actor_update_resource_scale (ClutterActor *self);
static void clutter_actor_ensure_resource_scale (ClutterActor *self);
static void clutter_actor_push_in_cloned_branch (ClutterActor *self,
gulong count);
static void clutter_actor_pop_in_cloned_branch (ClutterActor *self,
gulong count);
/* Helper macro which translates by the anchor coord, applies the
given transformation and then translates back */
#define TRANSFORM_ABOUT_ANCHOR_COORD(a,m,c,_transform) G_STMT_START { \
gfloat _tx, _ty, _tz; \
clutter_anchor_coord_get_units ((a), (c), &_tx, &_ty, &_tz); \
cogl_matrix_translate ((m), _tx, _ty, _tz); \
{ _transform; } \
cogl_matrix_translate ((m), -_tx, -_ty, -_tz); } G_STMT_END
static GQuark quark_actor_layout_info = 0;
static GQuark quark_actor_transform_info = 0;
static GQuark quark_actor_animation_info = 0;
static GQuark quark_key = 0;
static GQuark quark_motion = 0;
static GQuark quark_pointer_focus = 0;
static GQuark quark_button = 0;
static GQuark quark_scroll = 0;
static GQuark quark_stage = 0;
static GQuark quark_destroy = 0;
static GQuark quark_client = 0;
static GQuark quark_delete = 0;
static GQuark quark_touch = 0;
static GQuark quark_touchpad = 0;
static GQuark quark_proximity = 0;
static GQuark quark_pad = 0;
static GQuark quark_im = 0;
G_DEFINE_TYPE_WITH_CODE (ClutterActor,
clutter_actor,
G_TYPE_INITIALLY_UNOWNED,
G_ADD_PRIVATE (ClutterActor)
G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_CONTAINER,
clutter_container_iface_init)
G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_SCRIPTABLE,
clutter_scriptable_iface_init)
G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_ANIMATABLE,
clutter_animatable_iface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_IMPLEMENTOR,
atk_implementor_iface_init));
/*< private >
* clutter_actor_get_debug_name:
* @actor: a #ClutterActor
*
* Retrieves a printable name of @actor for debugging messages
*
* Return value: a string with a printable name
*/
const gchar *
_clutter_actor_get_debug_name (ClutterActor *actor)
{
ClutterActorPrivate *priv = actor->priv;
const gchar *retval;
#ifdef CLUTTER_ENABLE_DEBUG
if (G_UNLIKELY (priv->debug_name == NULL))
{
priv->debug_name = g_strdup_printf ("<%s>[<%s>:%p]",
priv->name != NULL ? priv->name
: "unnamed",
G_OBJECT_TYPE_NAME (actor),
actor);
}
retval = priv->debug_name;
#else
retval = priv->name != NULL
? priv->name
: G_OBJECT_TYPE_NAME (actor);
#endif
return retval;
}
#ifdef CLUTTER_ENABLE_DEBUG
/* XXX - this is for debugging only, remove once working (or leave
* in only in some debug mode). Should leave it for a little while
* until we're confident in the new map/realize/visible handling.
*/
static inline void
clutter_actor_verify_map_state (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
if (CLUTTER_ACTOR_IS_REALIZED (self))
{
/* all bets are off during reparent when we're potentially realized,
* but should not be according to invariants
*/
if (!CLUTTER_ACTOR_IN_REPARENT (self))
{
if (priv->parent == NULL)
{
if (CLUTTER_ACTOR_IS_TOPLEVEL (self))
{
}
else
g_warning ("Realized non-toplevel actor '%s' should "
"have a parent",
_clutter_actor_get_debug_name (self));
}
else if (!CLUTTER_ACTOR_IS_REALIZED (priv->parent))
{
g_warning ("Realized actor %s has an unrealized parent %s",
_clutter_actor_get_debug_name (self),
_clutter_actor_get_debug_name (priv->parent));
}
}
}
if (CLUTTER_ACTOR_IS_MAPPED (self))
{
if (!CLUTTER_ACTOR_IS_REALIZED (self))
g_warning ("Actor '%s' is mapped but not realized",
_clutter_actor_get_debug_name (self));
/* remaining bets are off during reparent when we're potentially
* mapped, but should not be according to invariants
*/
if (!CLUTTER_ACTOR_IN_REPARENT (self))
{
if (priv->parent == NULL)
{
if (CLUTTER_ACTOR_IS_TOPLEVEL (self))
{
if (!CLUTTER_ACTOR_IS_VISIBLE (self) &&
!CLUTTER_ACTOR_IN_DESTRUCTION (self))
{
g_warning ("Toplevel actor '%s' is mapped "
"but not visible",
_clutter_actor_get_debug_name (self));
}
}
else
{
g_warning ("Mapped actor '%s' should have a parent",
_clutter_actor_get_debug_name (self));
}
}
else
{
ClutterActor *iter = self;
/* check for the enable_paint_unmapped flag on the actor
* and parents; if the flag is enabled at any point of this
* branch of the scene graph then all the later checks
* become pointless
*/
while (iter != NULL)
{
if (iter->priv->enable_paint_unmapped)
return;
iter = iter->priv->parent;
}
if (!CLUTTER_ACTOR_IS_VISIBLE (priv->parent))
{
g_warning ("Actor '%s' should not be mapped if parent '%s'"
"is not visible",
_clutter_actor_get_debug_name (self),
_clutter_actor_get_debug_name (priv->parent));
}
if (!CLUTTER_ACTOR_IS_REALIZED (priv->parent))
{
g_warning ("Actor '%s' should not be mapped if parent '%s'"
"is not realized",
_clutter_actor_get_debug_name (self),
_clutter_actor_get_debug_name (priv->parent));
}
if (!CLUTTER_ACTOR_IS_TOPLEVEL (priv->parent))
{
if (!CLUTTER_ACTOR_IS_MAPPED (priv->parent))
g_warning ("Actor '%s' is mapped but its non-toplevel "
"parent '%s' is not mapped",
_clutter_actor_get_debug_name (self),
_clutter_actor_get_debug_name (priv->parent));
}
}
}
}
}
#endif /* CLUTTER_ENABLE_DEBUG */
static gboolean
_clutter_actor_transform_local_box_to_stage (ClutterActor *self,
ClutterStage *stage,
ClutterPickContext *pick_context,
const ClutterActorBox *box,
graphene_point_t vertices[4])
{
CoglFramebuffer *fb =
clutter_pick_context_get_framebuffer (pick_context);
CoglMatrix stage_transform, inv_stage_transform;
CoglMatrix modelview, transform_to_stage;
int v;
clutter_actor_get_transform (CLUTTER_ACTOR (stage), &stage_transform);
if (!cogl_matrix_get_inverse (&stage_transform, &inv_stage_transform))
return FALSE;
cogl_framebuffer_get_modelview_matrix (fb, &modelview);
cogl_matrix_multiply (&transform_to_stage, &inv_stage_transform, &modelview);
vertices[0].x = box->x1;
vertices[0].y = box->y1;
vertices[1].x = box->x2;
vertices[1].y = box->y1;
vertices[2].x = box->x2;
vertices[2].y = box->y2;
vertices[3].x = box->x1;
vertices[3].y = box->y2;
for (v = 0; v < 4; v++)
{
float z = 0.f;
float w = 1.f;
cogl_matrix_transform_point (&transform_to_stage,
&vertices[v].x,
&vertices[v].y,
&z,
&w);
}
return TRUE;
}
/**
* clutter_actor_pick_box:
* @self: The #ClutterActor being "pick" painted.
* @pick_context: The #ClutterPickContext
* @box: A rectangle in the actor's own local coordinates.
*
* Logs (does a virtual paint of) a rectangle for picking. Note that @box is
* in the actor's own local coordinates, so is usually {0,0,width,height}
* to include the whole actor. That is unless the actor has a shaped input
* region in which case you may wish to log the (multiple) smaller rectangles
* that make up the input region.
*/
void
clutter_actor_pick_box (ClutterActor *self,
ClutterPickContext *pick_context,
const ClutterActorBox *box)
{
ClutterStage *stage;
graphene_point_t vertices[4];
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (box != NULL);
if (box->x1 >= box->x2 || box->y1 >= box->y2)
return;
stage = CLUTTER_STAGE (_clutter_actor_get_stage_internal (self));
if (_clutter_actor_transform_local_box_to_stage (self, stage, pick_context,
box, vertices))
clutter_stage_log_pick (stage, vertices, self);
}
static gboolean
_clutter_actor_push_pick_clip (ClutterActor *self,
ClutterPickContext *pick_context,
const ClutterActorBox *clip)
{
ClutterStage *stage;
graphene_point_t vertices[4];
stage = CLUTTER_STAGE (_clutter_actor_get_stage_internal (self));
if (!_clutter_actor_transform_local_box_to_stage (self, stage, pick_context,
clip, vertices))
return FALSE;
clutter_stage_push_pick_clip (stage, vertices);
return TRUE;
}
static void
_clutter_actor_pop_pick_clip (ClutterActor *self)
{
ClutterActor *stage;
stage = _clutter_actor_get_stage_internal (self);
clutter_stage_pop_pick_clip (CLUTTER_STAGE (stage));
}
static void
clutter_actor_set_mapped (ClutterActor *self,
gboolean mapped)
{
if (CLUTTER_ACTOR_IS_MAPPED (self) == mapped)
return;
g_return_if_fail (!CLUTTER_ACTOR_IN_MAP_UNMAP (self));
CLUTTER_SET_PRIVATE_FLAGS (self, CLUTTER_IN_MAP_UNMAP);
if (mapped)
{
CLUTTER_ACTOR_GET_CLASS (self)->map (self);
g_assert (CLUTTER_ACTOR_IS_MAPPED (self));
}
else
{
CLUTTER_ACTOR_GET_CLASS (self)->unmap (self);
g_assert (!CLUTTER_ACTOR_IS_MAPPED (self));
}
CLUTTER_UNSET_PRIVATE_FLAGS (self, CLUTTER_IN_MAP_UNMAP);
}
/* this function updates the mapped and realized states according to
* invariants, in the appropriate order.
*/
static void
clutter_actor_update_map_state (ClutterActor *self,
MapStateChange change)
{
gboolean was_mapped;
was_mapped = CLUTTER_ACTOR_IS_MAPPED (self);
if (CLUTTER_ACTOR_IS_TOPLEVEL (self))
{
/* the mapped flag on top-level actors must be set by the
* per-backend implementation because it might be asynchronous.
*
* That is, the MAPPED flag on toplevels currently tracks the X
* server mapped-ness of the window, while the expected behavior
* (if used to GTK) may be to track WM_STATE!=WithdrawnState.
* This creates some weird complexity by breaking the invariant
* that if we're visible and all ancestors shown then we are
* also mapped - instead, we are mapped if all ancestors
* _possibly excepting_ the stage are mapped. The stage
* will map/unmap for example when it is minimized or
* moved to another workspace.
*
* So, the only invariant on the stage is that if visible it
* should be realized, and that it has to be visible to be
* mapped.
*/
if (CLUTTER_ACTOR_IS_VISIBLE (self))
clutter_actor_realize (self);
switch (change)
{
case MAP_STATE_CHECK:
break;
case MAP_STATE_MAKE_MAPPED:
g_assert (!was_mapped);
clutter_actor_set_mapped (self, TRUE);
break;
case MAP_STATE_MAKE_UNMAPPED:
g_assert (was_mapped);
clutter_actor_set_mapped (self, FALSE);
break;
case MAP_STATE_MAKE_UNREALIZED:
/* we only use MAKE_UNREALIZED in unparent,
* and unparenting a stage isn't possible.
* If someone wants to just unrealize a stage
* then clutter_actor_unrealize() doesn't
* go through this codepath.
*/
g_warning ("Trying to force unrealize stage is not allowed");
break;
}
if (CLUTTER_ACTOR_IS_MAPPED (self) &&
!CLUTTER_ACTOR_IS_VISIBLE (self) &&
!CLUTTER_ACTOR_IN_DESTRUCTION (self))
{
g_warning ("Clutter toplevel of type '%s' is not visible, but "
"it is somehow still mapped",
_clutter_actor_get_debug_name (self));
}
}
else
{
ClutterActorPrivate *priv = self->priv;
ClutterActor *parent = priv->parent;
gboolean should_be_mapped;
gboolean may_be_realized;
gboolean must_be_realized;
should_be_mapped = FALSE;
may_be_realized = TRUE;
must_be_realized = FALSE;
if (parent == NULL || change == MAP_STATE_MAKE_UNREALIZED)
{
may_be_realized = FALSE;
}
else
{
/* Maintain invariant that if parent is mapped, and we are
* visible, then we are mapped ... unless parent is a
* stage, in which case we map regardless of parent's map
* state but do require stage to be visible and realized.
*
* If parent is realized, that does not force us to be
* realized; but if parent is unrealized, that does force
* us to be unrealized.
*
* The reason we don't force children to realize with
* parents is _clutter_actor_rerealize(); if we require that
* a realized parent means children are realized, then to
* unrealize an actor we would have to unrealize its
* parents, which would end up meaning unrealizing and
* hiding the entire stage. So we allow unrealizing a
* child (as long as that child is not mapped) while that
* child still has a realized parent.
*
* Also, if we unrealize from leaf nodes to root, and
* realize from root to leaf, the invariants are never
* violated if we allow children to be unrealized
* while parents are realized.
*
* When unmapping, MAP_STATE_MAKE_UNMAPPED is specified
* to force us to unmap, even though parent is still
* mapped. This is because we're unmapping from leaf nodes
* up to root nodes.
*/
if (CLUTTER_ACTOR_IS_VISIBLE (self) &&
change != MAP_STATE_MAKE_UNMAPPED)
{
gboolean parent_is_visible_realized_toplevel;
parent_is_visible_realized_toplevel =
(CLUTTER_ACTOR_IS_TOPLEVEL (parent) &&
CLUTTER_ACTOR_IS_VISIBLE (parent) &&
CLUTTER_ACTOR_IS_REALIZED (parent));
if (CLUTTER_ACTOR_IS_MAPPED (parent) ||
parent_is_visible_realized_toplevel)
{
must_be_realized = TRUE;
should_be_mapped = TRUE;
}
}
/* if the actor has been set to be painted even if unmapped
* then we should map it and check for realization as well;
* this is an override for the branch of the scene graph
* which begins with this node
*/
if (priv->enable_paint_unmapped)
{
should_be_mapped = TRUE;
must_be_realized = TRUE;
}
if (!CLUTTER_ACTOR_IS_REALIZED (parent))
may_be_realized = FALSE;
}
if (change == MAP_STATE_MAKE_MAPPED && !should_be_mapped)
{
if (parent == NULL)
g_warning ("Attempting to map a child that does not "
"meet the necessary invariants: the actor '%s' "
"has no parent",
_clutter_actor_get_debug_name (self));
else
g_warning ("Attempting to map a child that does not "
"meet the necessary invariants: the actor '%s' "
"is parented to an unmapped actor '%s'",
_clutter_actor_get_debug_name (self),
_clutter_actor_get_debug_name (priv->parent));
}
/* If in reparent, we temporarily suspend unmap and unrealize.
*
* We want to go in the order "realize, map" and "unmap, unrealize"
*/
/* Unmap */
if (!should_be_mapped && !CLUTTER_ACTOR_IN_REPARENT (self))
clutter_actor_set_mapped (self, FALSE);
/* Realize */
if (must_be_realized)
clutter_actor_realize (self);
/* if we must be realized then we may be, presumably */
g_assert (!(must_be_realized && !may_be_realized));
/* Unrealize */
if (!may_be_realized && !CLUTTER_ACTOR_IN_REPARENT (self))
clutter_actor_unrealize_not_hiding (self);
/* Map */
if (should_be_mapped)
{
if (!must_be_realized)
g_warning ("Somehow we think actor '%s' should be mapped but "
"not realized, which isn't allowed",
_clutter_actor_get_debug_name (self));
/* realization is allowed to fail (though I don't know what
* an app is supposed to do about that - shouldn't it just
* be a g_error? anyway, we have to avoid mapping if this
* happens)
*/
if (CLUTTER_ACTOR_IS_REALIZED (self))
clutter_actor_set_mapped (self, TRUE);
}
}
#ifdef CLUTTER_ENABLE_DEBUG
/* check all invariants were kept */
clutter_actor_verify_map_state (self);
#endif
}
static void
clutter_actor_real_map (ClutterActor *self)
{
ClutterActor *iter;
g_assert (!CLUTTER_ACTOR_IS_MAPPED (self));
CLUTTER_NOTE (ACTOR, "Mapping actor '%s'",
_clutter_actor_get_debug_name (self));
CLUTTER_ACTOR_SET_FLAGS (self, CLUTTER_ACTOR_MAPPED);
self->priv->needs_paint_volume_update = TRUE;
clutter_actor_ensure_resource_scale (self);
/* notify on parent mapped before potentially mapping
* children, so apps see a top-down notification.
*/
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_MAPPED]);
for (iter = self->priv->first_child;
iter != NULL;
iter = iter->priv->next_sibling)
{
clutter_actor_map (iter);
}
}
/**
* clutter_actor_map:
* @self: A #ClutterActor
*
* Sets the %CLUTTER_ACTOR_MAPPED flag on the actor and possibly maps
* and realizes its children if they are visible. Does nothing if the
* actor is not visible.
*
* Calling this function is strongly disencouraged: the default
* implementation of #ClutterActorClass.map() will map all the children
* of an actor when mapping its parent.
*
* When overriding map, it is mandatory to chain up to the parent
* implementation.
*
* Since: 1.0
*/
void
clutter_actor_map (ClutterActor *self)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (CLUTTER_ACTOR_IS_MAPPED (self))
return;
if (!CLUTTER_ACTOR_IS_VISIBLE (self))
return;
clutter_actor_update_map_state (self, MAP_STATE_MAKE_MAPPED);
}
/**
* clutter_actor_is_mapped:
* @self: a #ClutterActor
*
* Checks whether a #ClutterActor has been set as mapped.
*
* See also %CLUTTER_ACTOR_IS_MAPPED and #ClutterActor:mapped
*
* Returns: %TRUE if the actor is mapped
*
* Since: 1.24
*/
gboolean
clutter_actor_is_mapped (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
return CLUTTER_ACTOR_IS_MAPPED (self);
}
static void
maybe_unset_key_focus (ClutterActor *self)
{
ClutterActor *stage;
if (!self->priv->has_key_focus)
return;
stage = _clutter_actor_get_stage_internal (self);
if (stage)
clutter_stage_set_key_focus (CLUTTER_STAGE (stage), NULL);
}
static void
clutter_actor_real_unmap (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
ClutterActor *iter;
g_assert (CLUTTER_ACTOR_IS_MAPPED (self));
CLUTTER_NOTE (ACTOR, "Unmapping actor '%s'",
_clutter_actor_get_debug_name (self));
for (iter = self->priv->first_child;
iter != NULL;
iter = iter->priv->next_sibling)
{
clutter_actor_unmap (iter);
}
CLUTTER_ACTOR_UNSET_FLAGS (self, CLUTTER_ACTOR_MAPPED);
/* clear the contents of the last paint volume, so that hiding + moving +
* showing will not result in the wrong area being repainted
*/
_clutter_paint_volume_init_static (&priv->last_paint_volume, NULL);
priv->last_paint_volume_valid = TRUE;
/* notify on parent mapped after potentially unmapping
* children, so apps see a bottom-up notification.
*/
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_MAPPED]);
/* relinquish keyboard focus if we were unmapped while owning it */
if (!CLUTTER_ACTOR_IS_TOPLEVEL (self))
maybe_unset_key_focus (self);
}
/**
* clutter_actor_unmap:
* @self: A #ClutterActor
*
* Unsets the %CLUTTER_ACTOR_MAPPED flag on the actor and possibly
* unmaps its children if they were mapped.
*
* Calling this function is not encouraged: the default #ClutterActor
* implementation of #ClutterActorClass.unmap() will also unmap any
* eventual children by default when their parent is unmapped.
*
* When overriding #ClutterActorClass.unmap(), it is mandatory to
* chain up to the parent implementation.
*
* It is important to note that the implementation of the
* #ClutterActorClass.unmap() virtual function may be called after
* the #ClutterActorClass.destroy() or the #GObjectClass.dispose()
* implementation, but it is guaranteed to be called before the
* #GObjectClass.finalize() implementation.
*
* Since: 1.0
*/
void
clutter_actor_unmap (ClutterActor *self)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (!CLUTTER_ACTOR_IS_MAPPED (self))
return;
clutter_actor_update_map_state (self, MAP_STATE_MAKE_UNMAPPED);
}
static void
clutter_actor_queue_shallow_relayout (ClutterActor *self)
{
ClutterActor *stage = _clutter_actor_get_stage_internal (self);
if (stage != NULL)
clutter_stage_queue_actor_relayout (CLUTTER_STAGE (stage), self);
}
static void
clutter_actor_real_show (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
if (CLUTTER_ACTOR_IS_VISIBLE (self))
return;
CLUTTER_ACTOR_SET_FLAGS (self, CLUTTER_ACTOR_VISIBLE);
/* we notify on the "visible" flag in the clutter_actor_show()
* wrapper so the entire show signal emission completes first,
* and the branch of the scene graph is in a stable state
*/
clutter_actor_update_map_state (self, MAP_STATE_CHECK);
/* we queue a relayout unless the actor is inside a
* container that explicitly told us not to
*/
if (priv->parent != NULL &&
(!(priv->parent->flags & CLUTTER_ACTOR_NO_LAYOUT)))
{
/* While an actor is hidden the parent may not have
* allocated/requested so we need to start from scratch
* and avoid the short-circuiting in
* clutter_actor_queue_relayout().
*/
priv->needs_width_request = FALSE;
priv->needs_height_request = FALSE;
priv->needs_allocation = FALSE;
clutter_actor_queue_relayout (self);
}
else /* but still don't leave the actor un-allocated before showing it */
{
clutter_actor_queue_shallow_relayout (self);
clutter_actor_queue_redraw (self);
}
}
static inline void
set_show_on_set_parent (ClutterActor *self,
gboolean set_show)
{
ClutterActorPrivate *priv = self->priv;
set_show = !!set_show;
if (priv->show_on_set_parent == set_show)
return;
if (priv->parent == NULL)
{
priv->show_on_set_parent = set_show;
g_object_notify_by_pspec (G_OBJECT (self),
obj_props[PROP_SHOW_ON_SET_PARENT]);
}
}
static void
clutter_actor_queue_redraw_on_parent (ClutterActor *self)
{
const ClutterPaintVolume *pv;
if (!self->priv->parent)
return;
/* A relayout/redraw is underway */
if (self->priv->needs_allocation)
return;
pv = clutter_actor_get_transformed_paint_volume (self, self->priv->parent);
_clutter_actor_queue_redraw_with_clip (self->priv->parent, 0, pv);
}
/**
* clutter_actor_show:
* @self: A #ClutterActor
*
* Flags an actor to be displayed. An actor that isn't shown will not
* be rendered on the stage.
*
* Actors are visible by default.
*
* If this function is called on an actor without a parent, the
* #ClutterActor:show-on-set-parent will be set to %TRUE as a side
* effect.
*/
void
clutter_actor_show (ClutterActor *self)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
/* simple optimization */
if (CLUTTER_ACTOR_IS_VISIBLE (self))
{
/* we still need to set the :show-on-set-parent property, in
* case show() is called on an unparented actor
*/
set_show_on_set_parent (self, TRUE);
return;
}
#ifdef CLUTTER_ENABLE_DEBUG
clutter_actor_verify_map_state (self);
#endif
priv = self->priv;
g_object_freeze_notify (G_OBJECT (self));
set_show_on_set_parent (self, TRUE);
/* if we're showing a child that needs to expand, or may
* expand, then we need to recompute the expand flags for
* its parent as well
*/
if (priv->needs_compute_expand ||
priv->needs_x_expand ||
priv->needs_y_expand)
{
clutter_actor_queue_compute_expand (self);
}
g_signal_emit (self, actor_signals[SHOW], 0);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_VISIBLE]);
if (priv->parent != NULL)
clutter_actor_queue_redraw (self);
g_object_thaw_notify (G_OBJECT (self));
}
/**
* clutter_actor_is_visible:
* @self: a #ClutterActor
*
* Checks whether an actor is marked as visible.
*
* See also %CLUTTER_ACTOR_IS_VISIBLE and #ClutterActor:visible.
*
* Returns: %TRUE if the actor visible
*
* Since: 1.24
*/
gboolean
clutter_actor_is_visible (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
return CLUTTER_ACTOR_IS_VISIBLE (self);
}
/**
* clutter_actor_show_all:
* @self: a #ClutterActor
*
* Calls clutter_actor_show() on all children of an actor (if any).
*
* Since: 0.2
*
* Deprecated: 1.10: Actors are visible by default
*/
void
clutter_actor_show_all (ClutterActor *self)
{
ClutterActorClass *klass;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
klass = CLUTTER_ACTOR_GET_CLASS (self);
if (klass->show_all)
klass->show_all (self);
}
static void
clutter_actor_real_hide (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
if (!CLUTTER_ACTOR_IS_VISIBLE (self))
return;
CLUTTER_ACTOR_UNSET_FLAGS (self, CLUTTER_ACTOR_VISIBLE);
/* we notify on the "visible" flag in the clutter_actor_hide()
* wrapper so the entire hide signal emission completes first,
* and the branch of the scene graph is in a stable state
*/
clutter_actor_update_map_state (self, MAP_STATE_CHECK);
/* we queue a relayout unless the actor is inside a
* container that explicitly told us not to
*/
if (priv->parent != NULL &&
(!(priv->parent->flags & CLUTTER_ACTOR_NO_LAYOUT)))
clutter_actor_queue_relayout (priv->parent);
}
/**
* clutter_actor_hide:
* @self: A #ClutterActor
*
* Flags an actor to be hidden. A hidden actor will not be
* rendered on the stage.
*
* Actors are visible by default.
*
* If this function is called on an actor without a parent, the
* #ClutterActor:show-on-set-parent property will be set to %FALSE
* as a side-effect.
*/
void
clutter_actor_hide (ClutterActor *self)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
/* simple optimization */
if (!CLUTTER_ACTOR_IS_VISIBLE (self))
{
/* we still need to set the :show-on-set-parent property, in
* case hide() is called on an unparented actor
*/
set_show_on_set_parent (self, FALSE);
return;
}
#ifdef CLUTTER_ENABLE_DEBUG
clutter_actor_verify_map_state (self);
#endif
priv = self->priv;
g_object_freeze_notify (G_OBJECT (self));
set_show_on_set_parent (self, FALSE);
/* if we're hiding a child that needs to expand, or may
* expand, then we need to recompute the expand flags for
* its parent as well
*/
if (priv->needs_compute_expand ||
priv->needs_x_expand ||
priv->needs_y_expand)
{
clutter_actor_queue_compute_expand (self);
}
g_signal_emit (self, actor_signals[HIDE], 0);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_VISIBLE]);
if (priv->parent != NULL && priv->needs_allocation)
clutter_actor_queue_redraw (priv->parent);
else
clutter_actor_queue_redraw_on_parent (self);
g_object_thaw_notify (G_OBJECT (self));
}
/**
* clutter_actor_realize:
* @self: A #ClutterActor
*
* Realization informs the actor that it is attached to a stage. It
* can use this to allocate resources if it wanted to delay allocation
* until it would be rendered. However it is perfectly acceptable for
* an actor to create resources before being realized because Clutter
* only ever has a single rendering context so that actor is free to
* be moved from one stage to another.
*
* This function does nothing if the actor is already realized.
*
* Because a realized actor must have realized parent actors, calling
* clutter_actor_realize() will also realize all parents of the actor.
*
* This function does not realize child actors, except in the special
* case that realizing the stage, when the stage is visible, will
* suddenly map (and thus realize) the children of the stage.
*
* Deprecated: 1.16: Actors are automatically realized, and nothing
* requires explicit realization.
*/
void
clutter_actor_realize (ClutterActor *self)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
clutter_actor_realize_internal (self);
}
/**
* clutter_actor_is_realized:
* @self: a #ClutterActor
*
* Checks whether a #ClutterActor is realized.
*
* See also %CLUTTER_ACTOR_IS_REALIZED and #ClutterActor:realized.
*
* Returns: %TRUE if the actor is realized
*
* Since: 1.24
*/
gboolean
clutter_actor_is_realized (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
return CLUTTER_ACTOR_IS_REALIZED (self);
}
static void
clutter_actor_realize_internal (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
#ifdef CLUTTER_ENABLE_DEBUG
clutter_actor_verify_map_state (self);
#endif
if (CLUTTER_ACTOR_IS_REALIZED (self))
return;
/* To be realized, our parent actors must be realized first.
* This will only succeed if we're inside a toplevel.
*/
if (priv->parent != NULL)
clutter_actor_realize (priv->parent);
if (CLUTTER_ACTOR_IS_TOPLEVEL (self))
{
/* toplevels can be realized at any time */
}
else
{
/* "Fail" the realization if parent is missing or unrealized;
* this should really be a g_warning() not some kind of runtime
* failure; how can an app possibly recover? Instead it's a bug
* in the app and the app should get an explanatory warning so
* someone can fix it. But for now it's too hard to fix this
* because e.g. ClutterTexture needs reworking.
*/
if (priv->parent == NULL ||
!CLUTTER_ACTOR_IS_REALIZED (priv->parent))
return;
}
CLUTTER_NOTE (ACTOR, "Realizing actor '%s'", _clutter_actor_get_debug_name (self));
CLUTTER_ACTOR_SET_FLAGS (self, CLUTTER_ACTOR_REALIZED);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_REALIZED]);
g_signal_emit (self, actor_signals[REALIZE], 0);
/* Stage actor is allowed to unset the realized flag again in its
* default signal handler, though that is a pathological situation.
*/
/* If realization "failed" we'll have to update child state. */
clutter_actor_update_map_state (self, MAP_STATE_CHECK);
}
static void
clutter_actor_real_unrealize (ClutterActor *self)
{
/* we must be unmapped (implying our children are also unmapped) */
g_assert (!CLUTTER_ACTOR_IS_MAPPED (self));
}
/**
* clutter_actor_unrealize:
* @self: A #ClutterActor
*
* Unrealization informs the actor that it may be being destroyed or
* moved to another stage. The actor may want to destroy any
* underlying graphics resources at this point. However it is
* perfectly acceptable for it to retain the resources until the actor
* is destroyed because Clutter only ever uses a single rendering
* context and all of the graphics resources are valid on any stage.
*
* Because mapped actors must be realized, actors may not be
* unrealized if they are mapped. This function hides the actor to be
* sure it isn't mapped, an application-visible side effect that you
* may not be expecting.
*
* This function should not be called by application code.
*
* This function should not really be in the public API, because
* there isn't a good reason to call it. ClutterActor will already
* unrealize things for you when it's important to do so.
*
* If you were using clutter_actor_unrealize() in a dispose
* implementation, then don't, just chain up to ClutterActor's
* dispose.
*
* If you were using clutter_actor_unrealize() to implement
* unrealizing children of your container, then don't, ClutterActor
* will already take care of that.
*
* Deprecated: 1.16: Actors are automatically unrealized, and nothing
* requires explicit realization.
*/
void
clutter_actor_unrealize (ClutterActor *self)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (!CLUTTER_ACTOR_IS_MAPPED (self));
clutter_actor_unrealize_internal (self);
}
/* If you were using clutter_actor_unrealize() to re-realize to
* create your resources in a different way, then use
* _clutter_actor_rerealize() (inside Clutter) or just call your
* code that recreates your resources directly (outside Clutter).
*/
static void
clutter_actor_unrealize_internal (ClutterActor *self)
{
#ifdef CLUTTER_ENABLE_DEBUG
clutter_actor_verify_map_state (self);
#endif
clutter_actor_hide (self);
clutter_actor_unrealize_not_hiding (self);
}
static ClutterActorTraverseVisitFlags
unrealize_actor_before_children_cb (ClutterActor *self,
int depth,
void *user_data)
{
/* If an actor is already unrealized we know its children have also
* already been unrealized... */
if (!CLUTTER_ACTOR_IS_REALIZED (self))
return CLUTTER_ACTOR_TRAVERSE_VISIT_SKIP_CHILDREN;
g_signal_emit (self, actor_signals[UNREALIZE], 0);
return CLUTTER_ACTOR_TRAVERSE_VISIT_CONTINUE;
}
static ClutterActorTraverseVisitFlags
unrealize_actor_after_children_cb (ClutterActor *self,
int depth,
void *user_data)
{
/* We want to unset the realized flag only _after_
* child actors are unrealized, to maintain invariants.
*/
CLUTTER_ACTOR_UNSET_FLAGS (self, CLUTTER_ACTOR_REALIZED);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_REALIZED]);
return CLUTTER_ACTOR_TRAVERSE_VISIT_CONTINUE;
}
/*
* clutter_actor_unrealize_not_hiding:
* @self: A #ClutterActor
*
* Unrealization informs the actor that it may be being destroyed or
* moved to another stage. The actor may want to destroy any
* underlying graphics resources at this point. However it is
* perfectly acceptable for it to retain the resources until the actor
* is destroyed because Clutter only ever uses a single rendering
* context and all of the graphics resources are valid on any stage.
*
* Because mapped actors must be realized, actors may not be
* unrealized if they are mapped. You must hide the actor or one of
* its parents before attempting to unrealize.
*
* This function is separate from clutter_actor_unrealize() because it
* does not automatically hide the actor.
* Actors need not be hidden to be unrealized, they just need to
* be unmapped. In fact we don't want to mess up the application's
* setting of the "visible" flag, so hiding is very undesirable.
*
* clutter_actor_unrealize() does a clutter_actor_hide() just for
* backward compatibility.
*/
static void
clutter_actor_unrealize_not_hiding (ClutterActor *self)
{
_clutter_actor_traverse (self,
CLUTTER_ACTOR_TRAVERSE_DEPTH_FIRST,
unrealize_actor_before_children_cb,
unrealize_actor_after_children_cb,
NULL);
}
/*
* _clutter_actor_rerealize:
* @self: A #ClutterActor
* @callback: Function to call while unrealized
* @data: data for callback
*
* If an actor is already unrealized, this just calls the callback.
*
* If it is realized, it unrealizes temporarily, calls the callback,
* and then re-realizes the actor.
*
* As a side effect, leaves all children of the actor unrealized if
* the actor was realized but not showing. This is because when we
* unrealize the actor temporarily we must unrealize its children
* (e.g. children of a stage can't be realized if stage window is
* gone). And we aren't clever enough to save the realization state of
* all children. In most cases this should not matter, because
* the children will automatically realize when they next become mapped.
*/
void
_clutter_actor_rerealize (ClutterActor *self,
ClutterCallback callback,
void *data)
{
gboolean was_mapped;
gboolean was_showing;
gboolean was_realized;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
#ifdef CLUTTER_ENABLE_DEBUG
clutter_actor_verify_map_state (self);
#endif
was_realized = CLUTTER_ACTOR_IS_REALIZED (self);
was_mapped = CLUTTER_ACTOR_IS_MAPPED (self);
was_showing = CLUTTER_ACTOR_IS_VISIBLE (self);
/* Must be unmapped to unrealize. Note we only have to hide this
* actor if it was mapped (if all parents were showing). If actor
* is merely visible (but not mapped), then that's fine, we can
* leave it visible.
*/
if (was_mapped)
clutter_actor_hide (self);
g_assert (!CLUTTER_ACTOR_IS_MAPPED (self));
/* unrealize self and all children */
clutter_actor_unrealize_not_hiding (self);
if (callback != NULL)
{
(* callback) (self, data);
}
if (was_showing)
clutter_actor_show (self); /* will realize only if mapping implies it */
else if (was_realized)
clutter_actor_realize (self); /* realize self and all parents */
}
static void
clutter_actor_real_pick (ClutterActor *self,
ClutterPickContext *pick_context)
{
if (clutter_actor_should_pick_paint (self))
{
ClutterActorBox box = {
.x1 = 0,
.y1 = 0,
.x2 = clutter_actor_get_width (self),
.y2 = clutter_actor_get_height (self),
};
clutter_actor_pick_box (self, pick_context, &box);
}
/* XXX - this thoroughly sucks, but we need to maintain compatibility
* with existing container classes that override the pick() virtual
* and chain up to the default implementation - otherwise we'll end up
* painting our children twice.
*
* this has to go away for 2.0; hopefully along the pick() itself.
*/
if (CLUTTER_ACTOR_GET_CLASS (self)->pick == clutter_actor_real_pick)
{
ClutterActor *iter;
for (iter = self->priv->first_child;
iter != NULL;
iter = iter->priv->next_sibling)
clutter_actor_pick (iter, pick_context);
}
}
/**
* clutter_actor_should_pick_paint:
* @self: A #ClutterActor
*
* Should be called inside the implementation of the
* #ClutterActor::pick virtual function in order to check whether
* the actor should paint itself in pick mode or not.
*
* This function should never be called directly by applications.
*
* Return value: %TRUE if the actor should paint its silhouette,
* %FALSE otherwise
*/
gboolean
clutter_actor_should_pick_paint (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
if (CLUTTER_ACTOR_IS_MAPPED (self) &&
clutter_actor_has_allocation (self) &&
(_clutter_context_get_pick_mode () == CLUTTER_PICK_ALL ||
CLUTTER_ACTOR_IS_REACTIVE (self)))
return TRUE;
return FALSE;
}
static void
clutter_actor_real_get_preferred_width (ClutterActor *self,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
ClutterActorPrivate *priv = self->priv;
if (priv->n_children != 0 &&
priv->layout_manager != NULL)
{
ClutterContainer *container = CLUTTER_CONTAINER (self);
CLUTTER_NOTE (LAYOUT, "Querying the layout manager '%s'[%p] "
"for the preferred width",
G_OBJECT_TYPE_NAME (priv->layout_manager),
priv->layout_manager);
clutter_layout_manager_get_preferred_width (priv->layout_manager,
container,
for_height,
min_width_p,
natural_width_p);
return;
}
/* Default implementation is always 0x0, usually an actor
* using this default is relying on someone to set the
* request manually
*/
CLUTTER_NOTE (LAYOUT, "Default preferred width: 0, 0");
if (min_width_p)
*min_width_p = 0;
if (natural_width_p)
*natural_width_p = 0;
}
static void
clutter_actor_real_get_preferred_height (ClutterActor *self,
gfloat for_width,
gfloat *min_height_p,
gfloat *natural_height_p)
{
ClutterActorPrivate *priv = self->priv;
if (priv->n_children != 0 &&
priv->layout_manager != NULL)
{
ClutterContainer *container = CLUTTER_CONTAINER (self);
CLUTTER_NOTE (LAYOUT, "Querying the layout manager '%s'[%p] "
"for the preferred height",
G_OBJECT_TYPE_NAME (priv->layout_manager),
priv->layout_manager);
clutter_layout_manager_get_preferred_height (priv->layout_manager,
container,
for_width,
min_height_p,
natural_height_p);
return;
}
/* Default implementation is always 0x0, usually an actor
* using this default is relying on someone to set the
* request manually
*/
CLUTTER_NOTE (LAYOUT, "Default preferred height: 0, 0");
if (min_height_p)
*min_height_p = 0;
if (natural_height_p)
*natural_height_p = 0;
}
static void
clutter_actor_store_old_geometry (ClutterActor *self,
ClutterActorBox *box)
{
*box = self->priv->allocation;
}
static inline void
clutter_actor_notify_if_geometry_changed (ClutterActor *self,
const ClutterActorBox *old)
{
ClutterActorPrivate *priv = self->priv;
GObject *obj = G_OBJECT (self);
g_object_freeze_notify (obj);
/* to avoid excessive requisition or allocation cycles we
* use the cached values.
*
* - if we don't have an allocation we assume that we need
* to notify anyway
* - if we don't have a width or a height request we notify
* width and height
* - if we have a valid allocation then we check the old
* bounding box with the current allocation and we notify
* the changes
*/
if (priv->needs_allocation)
{
g_object_notify_by_pspec (obj, obj_props[PROP_X]);
g_object_notify_by_pspec (obj, obj_props[PROP_Y]);
g_object_notify_by_pspec (obj, obj_props[PROP_POSITION]);
g_object_notify_by_pspec (obj, obj_props[PROP_WIDTH]);
g_object_notify_by_pspec (obj, obj_props[PROP_HEIGHT]);
g_object_notify_by_pspec (obj, obj_props[PROP_SIZE]);
}
else if (priv->needs_width_request || priv->needs_height_request)
{
g_object_notify_by_pspec (obj, obj_props[PROP_WIDTH]);
g_object_notify_by_pspec (obj, obj_props[PROP_HEIGHT]);
g_object_notify_by_pspec (obj, obj_props[PROP_SIZE]);
}
else
{
gfloat x, y;
gfloat width, height;
x = priv->allocation.x1;
y = priv->allocation.y1;
width = priv->allocation.x2 - priv->allocation.x1;
height = priv->allocation.y2 - priv->allocation.y1;
if (x != old->x1)
{
g_object_notify_by_pspec (obj, obj_props[PROP_X]);
g_object_notify_by_pspec (obj, obj_props[PROP_POSITION]);
}
if (y != old->y1)
{
g_object_notify_by_pspec (obj, obj_props[PROP_Y]);
g_object_notify_by_pspec (obj, obj_props[PROP_POSITION]);
}
if (width != (old->x2 - old->x1))
{
g_object_notify_by_pspec (obj, obj_props[PROP_WIDTH]);
g_object_notify_by_pspec (obj, obj_props[PROP_SIZE]);
}
if (height != (old->y2 - old->y1))
{
g_object_notify_by_pspec (obj, obj_props[PROP_HEIGHT]);
g_object_notify_by_pspec (obj, obj_props[PROP_SIZE]);
}
}
g_object_thaw_notify (obj);
}
/*< private >
* clutter_actor_set_allocation_internal:
* @self: a #ClutterActor
* @box: a #ClutterActorBox
* @flags: allocation flags
*
* Stores the allocation of @self.
*
* This function only performs basic storage and property notification.
*
* This function should be called by clutter_actor_set_allocation()
* and by the default implementation of #ClutterActorClass.allocate().
*
* Return value: %TRUE if the allocation of the #ClutterActor has been
* changed, and %FALSE otherwise
*/
static inline gboolean
clutter_actor_set_allocation_internal (ClutterActor *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
ClutterActorPrivate *priv = self->priv;
GObject *obj;
gboolean x1_changed, y1_changed, x2_changed, y2_changed;
gboolean retval;
ClutterActorBox old_alloc = { 0, };
g_return_val_if_fail (!isnan (box->x1) && !isnan (box->x2) &&
!isnan (box->y1) && !isnan (box->y2), FALSE);
obj = G_OBJECT (self);
g_object_freeze_notify (obj);
clutter_actor_store_old_geometry (self, &old_alloc);
x1_changed = priv->allocation.x1 != box->x1;
y1_changed = priv->allocation.y1 != box->y1;
x2_changed = priv->allocation.x2 != box->x2;
y2_changed = priv->allocation.y2 != box->y2;
priv->allocation = *box;
priv->allocation_flags = flags;
/* allocation is authoritative */
priv->needs_width_request = FALSE;
priv->needs_height_request = FALSE;
priv->needs_allocation = FALSE;
if (x1_changed ||
y1_changed ||
x2_changed ||
y2_changed)
{
CLUTTER_NOTE (LAYOUT, "Allocation for '%s' changed",
_clutter_actor_get_debug_name (self));
priv->transform_valid = FALSE;
g_object_notify_by_pspec (obj, obj_props[PROP_ALLOCATION]);
/* if the allocation changes, so does the content box */
if (priv->content != NULL)
{
priv->content_box_valid = FALSE;
g_object_notify_by_pspec (obj, obj_props[PROP_CONTENT_BOX]);
}
retval = TRUE;
}
else
retval = FALSE;
clutter_actor_notify_if_geometry_changed (self, &old_alloc);
g_object_thaw_notify (obj);
return retval;
}
static void clutter_actor_real_allocate (ClutterActor *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags);
static inline void
clutter_actor_maybe_layout_children (ClutterActor *self,
const ClutterActorBox *allocation,
ClutterAllocationFlags flags)
{
ClutterActorPrivate *priv = self->priv;
/* this is going to be a bit hard to follow, so let's put an explanation
* here.
*
* we want ClutterActor to have a default layout manager if the actor was
* created using "g_object_new (CLUTTER_TYPE_ACTOR, NULL)".
*
* we also want any subclass of ClutterActor that does not override the
* ::allocate() virtual function to delegate to a layout manager.
*
* finally, we want to allow people subclassing ClutterActor and overriding
* the ::allocate() vfunc to let Clutter delegate to the layout manager.
*
* on the other hand, we want existing actor subclasses overriding the
* ::allocate() virtual function and chaining up to the parent's
* implementation to continue working without allocating their children
* twice, or without entering an allocation loop.
*
* for the first two points, we check if the class of the actor is
* overridding the ::allocate() virtual function; if it isn't, then we
* follow through with checking whether we have children and a layout
* manager, and eventually calling clutter_layout_manager_allocate().
*
* for the third point, we check the CLUTTER_DELEGATE_LAYOUT flag in the
* allocation flags that we got passed, and if it is present, we continue
* with the check above.
*
* if neither of these two checks yields a positive result, we just
* assume that the ::allocate() virtual function that resulted in this
* function being called will also allocate the children of the actor.
*/
if (CLUTTER_ACTOR_GET_CLASS (self)->allocate == clutter_actor_real_allocate)
goto check_layout;
if ((flags & CLUTTER_DELEGATE_LAYOUT) != 0)
goto check_layout;
return;
check_layout:
if (priv->n_children != 0 &&
priv->layout_manager != NULL)
{
ClutterContainer *container = CLUTTER_CONTAINER (self);
ClutterAllocationFlags children_flags;
ClutterActorBox children_box;
/* normalize the box passed to the layout manager */
children_box.x1 = children_box.y1 = 0.f;
children_box.x2 = (allocation->x2 - allocation->x1);
children_box.y2 = (allocation->y2 - allocation->y1);
/* remove the DELEGATE_LAYOUT flag; this won't be passed to
* the actor's children, since it refers only to the current
* actor's allocation.
*/
children_flags = flags;
children_flags &= ~CLUTTER_DELEGATE_LAYOUT;
CLUTTER_NOTE (LAYOUT,
"Allocating %d children of %s "
"at { %.2f, %.2f - %.2f x %.2f } "
"using %s",
priv->n_children,
_clutter_actor_get_debug_name (self),
allocation->x1,
allocation->y1,
(allocation->x2 - allocation->x1),
(allocation->y2 - allocation->y1),
G_OBJECT_TYPE_NAME (priv->layout_manager));
clutter_layout_manager_allocate (priv->layout_manager,
container,
&children_box,
children_flags);
}
}
static void
clutter_actor_real_allocate (ClutterActor *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
ClutterActorPrivate *priv = self->priv;
gboolean changed;
g_object_freeze_notify (G_OBJECT (self));
changed = clutter_actor_set_allocation_internal (self, box, flags);
/* we allocate our children before we notify changes in our geometry,
* so that people connecting to properties will be able to get valid
* data out of the sub-tree of the scene graph that has this actor at
* the root.
*/
clutter_actor_maybe_layout_children (self, box, flags);
if (changed)
{
ClutterActorBox signal_box = priv->allocation;
ClutterAllocationFlags signal_flags = priv->allocation_flags;
g_signal_emit (self, actor_signals[ALLOCATION_CHANGED], 0,
&signal_box,
signal_flags);
}
g_object_thaw_notify (G_OBJECT (self));
}
static void
_clutter_actor_propagate_queue_redraw (ClutterActor *self,
ClutterActor *origin,
ClutterPaintVolume *pv)
{
gboolean stop = FALSE;
/* no point in queuing a redraw on a destroyed actor */
if (CLUTTER_ACTOR_IN_DESTRUCTION (self))
return;
/* NB: We can't bail out early here if the actor is hidden in case
* the actor bas been cloned. In this case the clone will need to
* receive the signal so it can queue its own redraw.
*/
while (self)
{
_clutter_actor_queue_redraw_on_clones (self);
/* calls klass->queue_redraw in default handler */
if (g_signal_has_handler_pending (self, actor_signals[QUEUE_REDRAW],
0, TRUE))
{
g_signal_emit (self, actor_signals[QUEUE_REDRAW], 0, origin, pv, &stop);
}
else
{
stop = CLUTTER_ACTOR_GET_CLASS (self)->queue_redraw (self, origin, pv);
}
if (stop)
break;
self = clutter_actor_get_parent (self);
}
}
static gboolean
clutter_actor_real_queue_redraw (ClutterActor *self,
ClutterActor *origin,
ClutterPaintVolume *paint_volume)
{
CLUTTER_NOTE (PAINT, "Redraw queued on '%s' (from: '%s')",
_clutter_actor_get_debug_name (self),
origin != NULL ? _clutter_actor_get_debug_name (origin)
: "same actor");
/* no point in queuing a redraw on a destroyed actor */
if (CLUTTER_ACTOR_IN_DESTRUCTION (self))
return TRUE;
/* If the queue redraw is coming from a child then the actor has
become dirty and any queued effect is no longer valid */
if (self != origin)
{
self->priv->is_dirty = TRUE;
self->priv->effect_to_redraw = NULL;
}
/* If the actor isn't visible, we still had to emit the signal
* to allow for a ClutterClone, but the appearance of the parent
* won't change so we don't have to propagate up the hierarchy.
*/
if (!CLUTTER_ACTOR_IS_VISIBLE (self))
return TRUE;
/* Although we could determine here that a full stage redraw
* has already been queued and immediately bail out, we actually
* guarantee that we will propagate a queue-redraw signal to our
* parent at least once so that it's possible to implement a
* container that tracks which of its children have queued a
* redraw.
*/
if (self->priv->propagated_one_redraw)
{
ClutterActor *stage = _clutter_actor_get_stage_internal (self);
if (stage != NULL &&
_clutter_stage_has_full_redraw_queued (CLUTTER_STAGE (stage)))
return TRUE;
}
self->priv->propagated_one_redraw = TRUE;
/* notify parents, if they are all visible eventually we'll
* queue redraw on the stage, which queues the redraw idle.
*/
return FALSE;
}
static inline gboolean
clutter_actor_needs_relayout (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
return (priv->needs_width_request ||
priv->needs_height_request ||
priv->needs_allocation);
}
static void
clutter_actor_real_queue_relayout (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
/* no point in queueing a redraw on a destroyed actor */
if (CLUTTER_ACTOR_IN_DESTRUCTION (self))
return;
priv->needs_width_request = TRUE;
priv->needs_height_request = TRUE;
priv->needs_allocation = TRUE;
priv->needs_paint_volume_update = TRUE;
/* reset the cached size requests */
memset (priv->width_requests, 0,
N_CACHED_SIZE_REQUESTS * sizeof (SizeRequest));
memset (priv->height_requests, 0,
N_CACHED_SIZE_REQUESTS * sizeof (SizeRequest));
/* We may need to go all the way up the hierarchy */
if (priv->parent != NULL)
{
if (priv->parent->flags & CLUTTER_ACTOR_NO_LAYOUT)
{
clutter_actor_queue_shallow_relayout (self);
/* The above might have invalidated the parent's paint volume if self
* has moved or resized. DnD seems to require this...
*/
priv->parent->priv->needs_paint_volume_update = TRUE;
}
else
{
_clutter_actor_queue_only_relayout (priv->parent);
}
}
}
/**
* clutter_actor_apply_relative_transform_to_point:
* @self: A #ClutterActor
* @ancestor: (allow-none): A #ClutterActor ancestor, or %NULL to use the
* default #ClutterStage
* @point: A point as #graphene_point3d_t
* @vertex: (out caller-allocates): The translated #graphene_point3d_t
*
* Transforms @point in coordinates relative to the actor into
* ancestor-relative coordinates using the relevant transform
* stack (i.e. scale, rotation, etc).
*
* If @ancestor is %NULL the ancestor will be the #ClutterStage. In
* this case, the coordinates returned will be the coordinates on
* the stage before the projection is applied. This is different from
* the behaviour of clutter_actor_apply_transform_to_point().
*
* Since: 0.6
*/
void
clutter_actor_apply_relative_transform_to_point (ClutterActor *self,
ClutterActor *ancestor,
const graphene_point3d_t *point,
graphene_point3d_t *vertex)
{
gfloat w;
CoglMatrix matrix;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (ancestor == NULL || CLUTTER_IS_ACTOR (ancestor));
g_return_if_fail (point != NULL);
g_return_if_fail (vertex != NULL);
*vertex = *point;
w = 1.0;
if (ancestor == NULL)
ancestor = _clutter_actor_get_stage_internal (self);
if (ancestor == NULL)
{
*vertex = *point;
return;
}
_clutter_actor_get_relative_transformation_matrix (self, ancestor, &matrix);
cogl_matrix_transform_point (&matrix, &vertex->x, &vertex->y, &vertex->z, &w);
}
static gboolean
_clutter_actor_fully_transform_vertices (ClutterActor *self,
const graphene_point3d_t *vertices_in,
graphene_point3d_t *vertices_out,
int n_vertices)
{
ClutterActor *stage;
CoglMatrix modelview;
CoglMatrix projection;
float viewport[4];
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
stage = _clutter_actor_get_stage_internal (self);
/* We really can't do anything meaningful in this case so don't try
* to do any transform */
if (stage == NULL)
return FALSE;
/* Note: we pass NULL as the ancestor because we don't just want the modelview
* that gets us to stage coordinates, we want to go all the way to eye
* coordinates */
_clutter_actor_get_relative_transformation_matrix (self, NULL, &modelview);
/* Fetch the projection and viewport */
_clutter_stage_get_projection_matrix (CLUTTER_STAGE (stage), &projection);
_clutter_stage_get_viewport (CLUTTER_STAGE (stage),
&viewport[0],
&viewport[1],
&viewport[2],
&viewport[3]);
_clutter_util_fully_transform_vertices (&modelview,
&projection,
viewport,
vertices_in,
vertices_out,
n_vertices);
return TRUE;
}
/**
* clutter_actor_apply_transform_to_point:
* @self: A #ClutterActor
* @point: A point as #graphene_point3d_t
* @vertex: (out caller-allocates): The translated #graphene_point3d_t
*
* Transforms @point in coordinates relative to the actor
* into screen-relative coordinates with the current actor
* transformation (i.e. scale, rotation, etc)
*
* Since: 0.4
**/
void
clutter_actor_apply_transform_to_point (ClutterActor *self,
const graphene_point3d_t *point,
graphene_point3d_t *vertex)
{
g_return_if_fail (point != NULL);
g_return_if_fail (vertex != NULL);
_clutter_actor_fully_transform_vertices (self, point, vertex, 1);
}
/*
* _clutter_actor_get_relative_transformation_matrix:
* @self: The actor whose coordinate space you want to transform from.
* @ancestor: The ancestor actor whose coordinate space you want to transform too
* or %NULL if you want to transform all the way to eye coordinates.
* @matrix: A #CoglMatrix to store the transformation
*
* This gets a transformation @matrix that will transform coordinates from the
* coordinate space of @self into the coordinate space of @ancestor.
*
* For example if you need a matrix that can transform the local actor
* coordinates of @self into stage coordinates you would pass the actor's stage
* pointer as the @ancestor.
*
* If you pass %NULL then the transformation will take you all the way through
* to eye coordinates. This can be useful if you want to extract the entire
* modelview transform that Clutter applies before applying the projection
* transformation. If you want to explicitly set a modelview on a CoglFramebuffer
* using cogl_set_modelview_matrix() for example then you would want a matrix
* that transforms into eye coordinates.
*
* Note: This function explicitly initializes the given @matrix. If you just
* want clutter to multiply a relative transformation with an existing matrix
* you can use clutter_actor_apply_relative_transformation_matrix()
* instead.
*
*/
/* XXX: We should consider caching the stage relative modelview along with
* the actor itself */
static void
_clutter_actor_get_relative_transformation_matrix (ClutterActor *self,
ClutterActor *ancestor,
CoglMatrix *matrix)
{
cogl_matrix_init_identity (matrix);
_clutter_actor_apply_relative_transformation_matrix (self, ancestor, matrix);
}
/* Project the given @box into stage window coordinates, writing the
* transformed vertices to @verts[]. */
static gboolean
_clutter_actor_transform_and_project_box (ClutterActor *self,
const ClutterActorBox *box,
graphene_point3d_t *verts)
{
graphene_point3d_t box_vertices[4];
box_vertices[0].x = box->x1;
box_vertices[0].y = box->y1;
box_vertices[0].z = 0;
box_vertices[1].x = box->x2;
box_vertices[1].y = box->y1;
box_vertices[1].z = 0;
box_vertices[2].x = box->x1;
box_vertices[2].y = box->y2;
box_vertices[2].z = 0;
box_vertices[3].x = box->x2;
box_vertices[3].y = box->y2;
box_vertices[3].z = 0;
return
_clutter_actor_fully_transform_vertices (self, box_vertices, verts, 4);
}
/**
* clutter_actor_get_allocation_vertices:
* @self: A #ClutterActor
* @ancestor: (allow-none): A #ClutterActor to calculate the vertices
* against, or %NULL to use the #ClutterStage
* @verts: (out) (array fixed-size=4): return
* location for an array of 4 #graphene_point3d_t in which to store the result
*
* Calculates the transformed coordinates of the four corners of the
* actor in the plane of @ancestor. The returned vertices relate to
* the #ClutterActorBox coordinates as follows:
*
* - @verts[0] contains (x1, y1)
* - @verts[1] contains (x2, y1)
* - @verts[2] contains (x1, y2)
* - @verts[3] contains (x2, y2)
*
* If @ancestor is %NULL the ancestor will be the #ClutterStage. In
* this case, the coordinates returned will be the coordinates on
* the stage before the projection is applied. This is different from
* the behaviour of clutter_actor_get_abs_allocation_vertices().
*
* Since: 0.6
*/
void
clutter_actor_get_allocation_vertices (ClutterActor *self,
ClutterActor *ancestor,
graphene_point3d_t *verts)
{
ClutterActorPrivate *priv;
ClutterActorBox box;
graphene_point3d_t vertices[4];
CoglMatrix modelview;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (ancestor == NULL || CLUTTER_IS_ACTOR (ancestor));
if (ancestor == NULL)
ancestor = _clutter_actor_get_stage_internal (self);
/* Fallback to a NOP transform if the actor isn't parented under a
* stage. */
if (ancestor == NULL)
ancestor = self;
priv = self->priv;
/* if the actor needs to be allocated we force a relayout, so that
* we will have valid values to use in the transformations */
if (priv->needs_allocation)
{
ClutterActor *stage = _clutter_actor_get_stage_internal (self);
if (stage)
_clutter_stage_maybe_relayout (stage);
else
{
box.x1 = box.y1 = 0;
/* The result isn't really meaningful in this case but at
* least try to do something *vaguely* reasonable... */
clutter_actor_get_size (self, &box.x2, &box.y2);
}
}
clutter_actor_get_allocation_box (self, &box);
vertices[0].x = box.x1;
vertices[0].y = box.y1;
vertices[0].z = 0;
vertices[1].x = box.x2;
vertices[1].y = box.y1;
vertices[1].z = 0;
vertices[2].x = box.x1;
vertices[2].y = box.y2;
vertices[2].z = 0;
vertices[3].x = box.x2;
vertices[3].y = box.y2;
vertices[3].z = 0;
_clutter_actor_get_relative_transformation_matrix (self, ancestor,
&modelview);
cogl_matrix_transform_points (&modelview,
3,
sizeof (graphene_point3d_t),
vertices,
sizeof (graphene_point3d_t),
vertices,
4);
}
/**
* clutter_actor_get_abs_allocation_vertices:
* @self: A #ClutterActor
* @verts: (out) (array fixed-size=4): Pointer to a location of an array
* of 4 #graphene_point3d_t where to store the result.
*
* Calculates the transformed screen coordinates of the four corners of
* the actor; the returned vertices relate to the #ClutterActorBox
* coordinates as follows:
*
* - v[0] contains (x1, y1)
* - v[1] contains (x2, y1)
* - v[2] contains (x1, y2)
* - v[3] contains (x2, y2)
*
* Since: 0.4
*/
void
clutter_actor_get_abs_allocation_vertices (ClutterActor *self,
graphene_point3d_t *verts)
{
ClutterActorPrivate *priv;
ClutterActorBox actor_space_allocation;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
/* if the actor needs to be allocated we force a relayout, so that
* the actor allocation box will be valid for
* _clutter_actor_transform_and_project_box()
*/
if (priv->needs_allocation)
{
ClutterActor *stage = _clutter_actor_get_stage_internal (self);
/* There's nothing meaningful we can do now */
if (!stage)
return;
_clutter_stage_maybe_relayout (stage);
}
/* NB: _clutter_actor_transform_and_project_box expects a box in the actor's
* own coordinate space... */
actor_space_allocation.x1 = 0;
actor_space_allocation.y1 = 0;
actor_space_allocation.x2 = priv->allocation.x2 - priv->allocation.x1;
actor_space_allocation.y2 = priv->allocation.y2 - priv->allocation.y1;
_clutter_actor_transform_and_project_box (self,
&actor_space_allocation,
verts);
}
static void
clutter_actor_real_apply_transform (ClutterActor *self,
ClutterMatrix *matrix)
{
ClutterActorPrivate *priv = self->priv;
CoglMatrix *transform = &priv->transform;
const ClutterTransformInfo *info;
float pivot_x = 0.f, pivot_y = 0.f;
/* we already have a cached transformation */
if (priv->transform_valid)
goto multiply_and_return;
info = _clutter_actor_get_transform_info_or_defaults (self);
/* compute the pivot point given the allocated size */
pivot_x = (priv->allocation.x2 - priv->allocation.x1)
* info->pivot.x;
pivot_y = (priv->allocation.y2 - priv->allocation.y1)
* info->pivot.y;
CLUTTER_NOTE (PAINT,
"Allocation: (%.2f, %2.f), "
"pivot: (%.2f, %.2f), "
"translation: (%.2f, %.2f) -> "
"new origin: (%.2f, %.2f)",
priv->allocation.x1, priv->allocation.y1,
info->pivot.x, info->pivot.y,
info->translation.x, info->translation.y,
priv->allocation.x1 + pivot_x + info->translation.x,
priv->allocation.y1 + pivot_y + info->translation.y);
/* we apply the :child-transform from the parent actor, if we have one */
if (priv->parent != NULL)
{
const ClutterTransformInfo *parent_info;
parent_info = _clutter_actor_get_transform_info_or_defaults (priv->parent);
clutter_matrix_init_from_matrix (transform, &(parent_info->child_transform));
}
else
clutter_matrix_init_identity (transform);
/* if we have an overriding transformation, we use that, and get out */
if (info->transform_set)
{
/* we still need to apply the :allocation's origin and :pivot-point
* translations, since :transform is relative to the actor's coordinate
* space, and to the pivot point
*/
cogl_matrix_translate (transform,
priv->allocation.x1 + pivot_x,
priv->allocation.y1 + pivot_y,
info->pivot_z);
cogl_matrix_multiply (transform, transform, &info->transform);
goto roll_back_pivot;
}
/* basic translation: :allocation's origin and :z-position; instead
* of decomposing the pivot and translation info separate operations,
* we just compose everything into a single translation
*/
cogl_matrix_translate (transform,
priv->allocation.x1 + pivot_x + info->translation.x,
priv->allocation.y1 + pivot_y + info->translation.y,
info->z_position + info->pivot_z + info->translation.z);
/* because the rotation involves translations, we must scale
* before applying the rotations (if we apply the scale after
* the rotations, the translations included in the rotation are
* not scaled and so the entire object will move on the screen
* as a result of rotating it).
*
* XXX:2.0 the comment has to be reworded once we remove the
* per-transformation centers; we also may want to apply rotation
* first and scaling after, to match the matrix decomposition
* code we use when interpolating transformations
*/
if (info->scale_x != 1.0 || info->scale_y != 1.0 || info->scale_z != 1.0)
{
/* XXX:2.0 remove anchor coord */
TRANSFORM_ABOUT_ANCHOR_COORD (self, transform,
&info->scale_center,
cogl_matrix_scale (transform,
info->scale_x,
info->scale_y,
info->scale_z));
}
if (info->rz_angle)
{
/* XXX:2.0 remove anchor coord */
TRANSFORM_ABOUT_ANCHOR_COORD (self, transform,
&info->rz_center,
cogl_matrix_rotate (transform,
info->rz_angle,
0, 0, 1.0));
}
if (info->ry_angle)
{
/* XXX:2.0 remove anchor coord */
TRANSFORM_ABOUT_ANCHOR_COORD (self, transform,
&info->ry_center,
cogl_matrix_rotate (transform,
info->ry_angle,
0, 1.0, 0));
}
if (info->rx_angle)
{
/* XXX:2.0 remove anchor coord */
TRANSFORM_ABOUT_ANCHOR_COORD (self, transform,
&info->rx_center,
cogl_matrix_rotate (transform,
info->rx_angle,
1.0, 0, 0));
}
/* XXX:2.0 remove anchor point translation */
if (!clutter_anchor_coord_is_zero (&info->anchor))
{
gfloat x, y, z;
clutter_anchor_coord_get_units (self, &info->anchor, &x, &y, &z);
cogl_matrix_translate (transform, -x, -y, -z);
}
roll_back_pivot:
/* roll back the pivot translation */
if (pivot_x != 0.f || pivot_y != 0.f || info->pivot_z != 0.f)
cogl_matrix_translate (transform, -pivot_x, -pivot_y, -info->pivot_z);
/* we have a valid modelview */
priv->transform_valid = TRUE;
multiply_and_return:
cogl_matrix_multiply (matrix, matrix, &priv->transform);
}
/* Applies the transforms associated with this actor to the given
* matrix. */
void
_clutter_actor_apply_modelview_transform (ClutterActor *self,
ClutterMatrix *matrix)
{
CLUTTER_ACTOR_GET_CLASS (self)->apply_transform (self, matrix);
}
/*
* clutter_actor_apply_relative_transformation_matrix:
* @self: The actor whose coordinate space you want to transform from.
* @ancestor: The ancestor actor whose coordinate space you want to transform too
* or %NULL if you want to transform all the way to eye coordinates.
* @matrix: A #ClutterMatrix to apply the transformation too.
*
* This multiplies a transform with @matrix that will transform coordinates
* from the coordinate space of @self into the coordinate space of @ancestor.
*
* For example if you need a matrix that can transform the local actor
* coordinates of @self into stage coordinates you would pass the actor's stage
* pointer as the @ancestor.
*
* If you pass %NULL then the transformation will take you all the way through
* to eye coordinates. This can be useful if you want to extract the entire
* modelview transform that Clutter applies before applying the projection
* transformation. If you want to explicitly set a modelview on a CoglFramebuffer
* using cogl_set_modelview_matrix() for example then you would want a matrix
* that transforms into eye coordinates.
*
* This function doesn't initialize the given @matrix, it simply
* multiplies the requested transformation matrix with the existing contents of
* @matrix. You can use cogl_matrix_init_identity() to initialize the @matrix
* before calling this function, or you can use
* clutter_actor_get_relative_transformation_matrix() instead.
*/
void
_clutter_actor_apply_relative_transformation_matrix (ClutterActor *self,
ClutterActor *ancestor,
CoglMatrix *matrix)
{
ClutterActor *parent;
/* Note we terminate before ever calling stage->apply_transform()
* since that would conceptually be relative to the underlying
* window OpenGL coordinates so we'd need a special @ancestor
* value to represent the fake parent of the stage. */
if (self == ancestor)
return;
parent = clutter_actor_get_parent (self);
if (parent != NULL)
_clutter_actor_apply_relative_transformation_matrix (parent, ancestor,
matrix);
_clutter_actor_apply_modelview_transform (self, matrix);
}
static void
_clutter_actor_draw_paint_volume_full (ClutterActor *self,
ClutterPaintVolume *pv,
const char *label,
const ClutterColor *color,
ClutterPaintNode *node)
{
g_autoptr (ClutterPaintNode) pipeline_node = NULL;
static CoglPipeline *outline = NULL;
CoglPrimitive *prim;
graphene_point3d_t line_ends[12 * 2];
int n_vertices;
CoglContext *ctx =
clutter_backend_get_cogl_context (clutter_get_default_backend ());
CoglColor cogl_color;
if (outline == NULL)
outline = cogl_pipeline_new (ctx);
_clutter_paint_volume_complete (pv);
n_vertices = pv->is_2d ? 4 * 2 : 12 * 2;
/* Front face */
line_ends[0] = pv->vertices[0]; line_ends[1] = pv->vertices[1];
line_ends[2] = pv->vertices[1]; line_ends[3] = pv->vertices[2];
line_ends[4] = pv->vertices[2]; line_ends[5] = pv->vertices[3];
line_ends[6] = pv->vertices[3]; line_ends[7] = pv->vertices[0];
if (!pv->is_2d)
{
/* Back face */
line_ends[8] = pv->vertices[4]; line_ends[9] = pv->vertices[5];
line_ends[10] = pv->vertices[5]; line_ends[11] = pv->vertices[6];
line_ends[12] = pv->vertices[6]; line_ends[13] = pv->vertices[7];
line_ends[14] = pv->vertices[7]; line_ends[15] = pv->vertices[4];
/* Lines connecting front face to back face */
line_ends[16] = pv->vertices[0]; line_ends[17] = pv->vertices[4];
line_ends[18] = pv->vertices[1]; line_ends[19] = pv->vertices[5];
line_ends[20] = pv->vertices[2]; line_ends[21] = pv->vertices[6];
line_ends[22] = pv->vertices[3]; line_ends[23] = pv->vertices[7];
}
prim = cogl_primitive_new_p3 (ctx, COGL_VERTICES_MODE_LINES,
n_vertices,
(CoglVertexP3 *)line_ends);
cogl_color_init_from_4ub (&cogl_color,
color->red,
color->green,
color->blue,
color->alpha);
cogl_pipeline_set_color (outline, &cogl_color);
pipeline_node = clutter_pipeline_node_new (outline);
clutter_paint_node_set_static_name (pipeline_node,
"ClutterActor (paint volume outline)");
clutter_paint_node_add_primitive (pipeline_node, prim);
clutter_paint_node_add_child (node, pipeline_node);
cogl_object_unref (prim);
if (label)
{
g_autoptr (ClutterPaintNode) text_node = NULL;
PangoLayout *layout;
layout = pango_layout_new (clutter_actor_get_pango_context (self));
pango_layout_set_text (layout, label, -1);
text_node = clutter_text_node_new (layout, color);
clutter_paint_node_set_static_name (text_node,
"ClutterActor (paint volume label)");
clutter_paint_node_add_rectangle (text_node,
&(ClutterActorBox) {
.x1 = pv->vertices[0].x,
.y1 = pv->vertices[0].y,
.x2 = pv->vertices[2].x,
.y2 = pv->vertices[2].y,
});
clutter_paint_node_add_child (node, text_node);
g_object_unref (layout);
}
}
static void
_clutter_actor_draw_paint_volume (ClutterActor *self,
ClutterPaintNode *node)
{
ClutterPaintVolume *pv;
ClutterColor color;
pv = _clutter_actor_get_paint_volume_mutable (self);
if (!pv)
{
gfloat width, height;
ClutterPaintVolume fake_pv;
ClutterActor *stage = _clutter_actor_get_stage_internal (self);
_clutter_paint_volume_init_static (&fake_pv, stage);
clutter_actor_get_size (self, &width, &height);
clutter_paint_volume_set_width (&fake_pv, width);
clutter_paint_volume_set_height (&fake_pv, height);
clutter_color_init (&color, 0, 0, 255, 255);
_clutter_actor_draw_paint_volume_full (self, &fake_pv,
_clutter_actor_get_debug_name (self),
&color,
node);
clutter_paint_volume_free (&fake_pv);
}
else
{
clutter_color_init (&color, 0, 255, 0, 255);
_clutter_actor_draw_paint_volume_full (self, pv,
_clutter_actor_get_debug_name (self),
&color,
node);
}
}
static void
_clutter_actor_paint_cull_result (ClutterActor *self,
gboolean success,
ClutterCullResult result,
ClutterPaintNode *node)
{
ClutterActorPrivate *priv = self->priv;
ClutterPaintVolume *pv;
ClutterColor color;
if (success)
{
if (result == CLUTTER_CULL_RESULT_IN)
clutter_color_init (&color, 0, 255, 0, 255);
else if (result == CLUTTER_CULL_RESULT_OUT)
clutter_color_init (&color, 0, 0, 255, 255);
else
clutter_color_init (&color, 0, 255, 255, 255);
}
else
clutter_color_init (&color, 255, 255, 255, 255);
if (success && (pv = _clutter_actor_get_paint_volume_mutable (self)))
_clutter_actor_draw_paint_volume_full (self, pv,
_clutter_actor_get_debug_name (self),
&color,
node);
else
{
g_autoptr (ClutterPaintNode) text_node = NULL;
PangoLayout *layout;
float width;
float height;
char *label =
g_strdup_printf ("CULL FAILURE: %s", _clutter_actor_get_debug_name (self));
clutter_color_init (&color, 255, 255, 255, 255);
width = clutter_actor_box_get_width (&priv->allocation);
height = clutter_actor_box_get_height (&priv->allocation);
layout = pango_layout_new (clutter_actor_get_pango_context (self));
pango_layout_set_text (layout, label, -1);
text_node = clutter_text_node_new (layout, &color);
clutter_paint_node_set_static_name (text_node,
"ClutterActor (paint volume text)");
clutter_paint_node_add_rectangle (text_node,
&(ClutterActorBox) {
.x1 = 0.f,
.y1 = 0.f,
.x2 = width,
.y2 = height,
});
clutter_paint_node_add_child (node, text_node);
g_free (label);
g_object_unref (layout);
}
}
static int clone_paint_level = 0;
void
_clutter_actor_push_clone_paint (void)
{
clone_paint_level++;
}
void
_clutter_actor_pop_clone_paint (void)
{
clone_paint_level--;
}
static gboolean
in_clone_paint (void)
{
return clone_paint_level > 0;
}
/* Returns TRUE if the actor can be ignored */
/* FIXME: we should return a ClutterCullResult, and
* clutter_actor_paint should understand that a CLUTTER_CULL_RESULT_IN
* means there's no point in trying to cull descendants of the current
* node. */
static gboolean
cull_actor (ClutterActor *self,
ClutterPaintContext *paint_context,
ClutterCullResult *result_out)
{
ClutterActorPrivate *priv = self->priv;
ClutterStage *stage;
const ClutterPlane *stage_clip;
if (!priv->last_paint_volume_valid)
{
CLUTTER_NOTE (CLIPPING, "Bail from cull_actor without culling (%s): "
"->last_paint_volume_valid == FALSE",
_clutter_actor_get_debug_name (self));
return FALSE;
}
if (G_UNLIKELY (clutter_paint_debug_flags & CLUTTER_DEBUG_DISABLE_CULLING))
return FALSE;
stage = (ClutterStage *) _clutter_actor_get_stage_internal (self);
stage_clip = _clutter_stage_get_clip (stage);
if (G_UNLIKELY (!stage_clip))
{
CLUTTER_NOTE (CLIPPING, "Bail from cull_actor without culling (%s): "
"No stage clip set",
_clutter_actor_get_debug_name (self));
return FALSE;
}
if (clutter_paint_context_is_drawing_off_stage (paint_context))
{
CLUTTER_NOTE (CLIPPING, "Bail from cull_actor without culling (%s): "
"Drawing off stage",
_clutter_actor_get_debug_name (self));
return FALSE;
}
*result_out =
_clutter_paint_volume_cull (&priv->last_paint_volume, stage_clip);
return TRUE;
}
static void
_clutter_actor_update_last_paint_volume (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
const ClutterPaintVolume *pv;
if (priv->last_paint_volume_valid)
{
clutter_paint_volume_free (&priv->last_paint_volume);
priv->last_paint_volume_valid = FALSE;
}
pv = clutter_actor_get_paint_volume (self);
if (!pv)
{
CLUTTER_NOTE (CLIPPING, "Bail from update_last_paint_volume (%s): "
"Actor failed to report a paint volume",
_clutter_actor_get_debug_name (self));
return;
}
_clutter_paint_volume_copy_static (pv, &priv->last_paint_volume);
_clutter_paint_volume_transform_relative (&priv->last_paint_volume,
NULL); /* eye coordinates */
priv->last_paint_volume_valid = TRUE;
}
/* This is the same as clutter_actor_add_effect except that it doesn't
queue a redraw and it doesn't notify on the effect property */
static void
_clutter_actor_add_effect_internal (ClutterActor *self,
ClutterEffect *effect)
{
ClutterActorPrivate *priv = self->priv;
if (priv->effects == NULL)
{
priv->effects = g_object_new (CLUTTER_TYPE_META_GROUP, NULL);
priv->effects->actor = self;
}
_clutter_meta_group_add_meta (priv->effects, CLUTTER_ACTOR_META (effect));
}
/* This is the same as clutter_actor_remove_effect except that it doesn't
queue a redraw and it doesn't notify on the effect property */
static void
_clutter_actor_remove_effect_internal (ClutterActor *self,
ClutterEffect *effect)
{
ClutterActorPrivate *priv = self->priv;
if (priv->effects == NULL)
return;
_clutter_meta_group_remove_meta (priv->effects, CLUTTER_ACTOR_META (effect));
if (_clutter_meta_group_peek_metas (priv->effects) == NULL)
g_clear_object (&priv->effects);
}
static gboolean
needs_flatten_effect (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
if (G_UNLIKELY (clutter_paint_debug_flags &
CLUTTER_DEBUG_DISABLE_OFFSCREEN_REDIRECT))
return FALSE;
/* We need to enable the effect immediately even in ON_IDLE because that can
* only be implemented efficiently within the effect itself.
* If it was implemented here using just priv->is_dirty then we would lose
* the ability to animate opacity without repaints.
*/
if ((priv->offscreen_redirect & CLUTTER_OFFSCREEN_REDIRECT_ALWAYS) ||
(priv->offscreen_redirect & CLUTTER_OFFSCREEN_REDIRECT_ON_IDLE))
return TRUE;
else if (priv->offscreen_redirect & CLUTTER_OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY)
{
if (clutter_actor_get_paint_opacity (self) < 255 &&
clutter_actor_has_overlaps (self))
return TRUE;
}
return FALSE;
}
static void
add_or_remove_flatten_effect (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
/* Add or remove the flatten effect depending on the
offscreen-redirect property. */
if (needs_flatten_effect (self))
{
if (priv->flatten_effect == NULL)
{
ClutterActorMeta *actor_meta;
gint priority;
priv->flatten_effect = _clutter_flatten_effect_new ();
/* Keep a reference to the effect so that we can queue
redraws from it */
g_object_ref_sink (priv->flatten_effect);
/* Set the priority of the effect to high so that it will
always be applied to the actor first. It uses an internal
priority so that it won't be visible to applications */
actor_meta = CLUTTER_ACTOR_META (priv->flatten_effect);
priority = CLUTTER_ACTOR_META_PRIORITY_INTERNAL_HIGH;
_clutter_actor_meta_set_priority (actor_meta, priority);
/* This will add the effect without queueing a redraw */
_clutter_actor_add_effect_internal (self, priv->flatten_effect);
}
}
else
{
if (priv->flatten_effect != NULL)
{
/* Destroy the effect so that it will lose its fbo cache of
the actor */
_clutter_actor_remove_effect_internal (self, priv->flatten_effect);
g_clear_object (&priv->flatten_effect);
}
}
}
static void
clutter_actor_real_paint (ClutterActor *actor,
ClutterPaintContext *paint_context)
{
ClutterActorPrivate *priv = actor->priv;
ClutterActor *iter;
for (iter = priv->first_child;
iter != NULL;
iter = iter->priv->next_sibling)
{
CLUTTER_NOTE (PAINT, "Painting %s, child of %s, at { %.2f, %.2f - %.2f x %.2f }",
_clutter_actor_get_debug_name (iter),
_clutter_actor_get_debug_name (actor),
iter->priv->allocation.x1,
iter->priv->allocation.y1,
iter->priv->allocation.x2 - iter->priv->allocation.x1,
iter->priv->allocation.y2 - iter->priv->allocation.y1);
clutter_actor_paint (iter, paint_context);
}
}
static gboolean
clutter_actor_paint_node (ClutterActor *actor,
ClutterPaintNode *root,
ClutterPaintContext *paint_context)
{
ClutterActorPrivate *priv = actor->priv;
ClutterActorBox box;
ClutterColor bg_color;
box.x1 = 0.f;
box.y1 = 0.f;
box.x2 = clutter_actor_box_get_width (&priv->allocation);
box.y2 = clutter_actor_box_get_height (&priv->allocation);
bg_color = priv->bg_color;
if (CLUTTER_ACTOR_IS_TOPLEVEL (actor))
{
ClutterPaintNode *node;
CoglFramebuffer *fb;
CoglBufferBit clear_flags;
fb = clutter_paint_context_get_base_framebuffer (paint_context);
if (clutter_stage_get_use_alpha (CLUTTER_STAGE (actor)))
{
bg_color.alpha = priv->opacity
* priv->bg_color.alpha
/ 255;
}
else
bg_color.alpha = 255;
CLUTTER_NOTE (PAINT, "Stage clear color: (%d, %d, %d, %d)",
bg_color.red,
bg_color.green,
bg_color.blue,
bg_color.alpha);
clear_flags = COGL_BUFFER_BIT_DEPTH;
node = clutter_root_node_new (fb, &bg_color, clear_flags);
clutter_paint_node_set_static_name (node, "stageClear");
clutter_paint_node_add_rectangle (node, &box);
clutter_paint_node_add_child (root, node);
clutter_paint_node_unref (node);
}
else if (priv->bg_color_set &&
!clutter_color_equal (&priv->bg_color, CLUTTER_COLOR_Transparent))
{
ClutterPaintNode *node;
bg_color.alpha = clutter_actor_get_paint_opacity_internal (actor)
* priv->bg_color.alpha
/ 255;
node = clutter_color_node_new (&bg_color);
clutter_paint_node_set_static_name (node, "backgroundColor");
clutter_paint_node_add_rectangle (node, &box);
clutter_paint_node_add_child (root, node);
clutter_paint_node_unref (node);
}
if (priv->content != NULL)
_clutter_content_paint_content (priv->content, actor, root, paint_context);
if (CLUTTER_ACTOR_GET_CLASS (actor)->paint_node != NULL)
CLUTTER_ACTOR_GET_CLASS (actor)->paint_node (actor, root);
if (clutter_paint_node_get_n_children (root) == 0)
return FALSE;
#ifdef CLUTTER_ENABLE_DEBUG
if (CLUTTER_HAS_DEBUG (PAINT))
{
/* dump the tree only if we have one */
_clutter_paint_node_dump_tree (root);
}
#endif /* CLUTTER_ENABLE_DEBUG */
clutter_paint_node_paint (root, paint_context);
return TRUE;
}
/**
* clutter_actor_paint:
* @self: A #ClutterActor
*
* Renders the actor to display.
*
* This function should not be called directly by applications.
* Call clutter_actor_queue_redraw() to queue paints, instead.
*
* This function is context-aware, and will either cause a
* regular paint or a pick paint.
*
* This function will emit the #ClutterActor::paint signal or
* the #ClutterActor::pick signal, depending on the context.
*
* This function does not paint the actor if the actor is set to 0,
* unless it is performing a pick paint.
*/
void
clutter_actor_paint (ClutterActor *self,
ClutterPaintContext *paint_context)
{
g_autoptr (ClutterPaintNode) actor_node = NULL;
g_autoptr (ClutterPaintNode) root_node = NULL;
ClutterActorPrivate *priv;
ClutterActorBox clip;
gboolean culling_inhibited;
gboolean clip_set = FALSE;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (CLUTTER_ACTOR_IN_DESTRUCTION (self))
return;
priv = self->priv;
priv->propagated_one_redraw = FALSE;
/* It's an important optimization that we consider painting of
* actors with 0 opacity to be a NOP... */
if (/* ignore top-levels, since they might be transparent */
!CLUTTER_ACTOR_IS_TOPLEVEL (self) &&
/* Use the override opacity if its been set */
((priv->opacity_override >= 0) ?
priv->opacity_override : priv->opacity) == 0)
return;
/* if we aren't paintable (not in a toplevel with all
* parents paintable) then do nothing.
*/
if (!CLUTTER_ACTOR_IS_MAPPED (self))
return;
clutter_actor_ensure_resource_scale (self);
actor_node = clutter_actor_node_new (self);
root_node = clutter_paint_node_ref (actor_node);
if (priv->has_clip)
{
clip.x1 = priv->clip.origin.x;
clip.y1 = priv->clip.origin.y;
clip.x2 = priv->clip.origin.x + priv->clip.size.width;
clip.y2 = priv->clip.origin.y + priv->clip.size.height;
clip_set = TRUE;
}
else if (priv->clip_to_allocation)
{
clip.x1 = 0.f;
clip.y1 = 0.f;
clip.x2 = priv->allocation.x2 - priv->allocation.x1;
clip.y2 = priv->allocation.y2 - priv->allocation.y1;
clip_set = TRUE;
}
if (clip_set)
{
ClutterPaintNode *clip_node;
clip_node = clutter_clip_node_new ();
clutter_paint_node_add_rectangle (clip_node, &clip);
clutter_paint_node_add_child (clip_node, root_node);
clutter_paint_node_unref (root_node);
root_node = g_steal_pointer (&clip_node);
}
if (priv->enable_model_view_transform)
{
ClutterPaintNode *transform_node;
CoglMatrix transform;
clutter_actor_get_transform (self, &transform);
if (!cogl_matrix_is_identity (&transform))
{
transform_node = clutter_transform_node_new (&transform);
clutter_paint_node_add_child (transform_node, root_node);
clutter_paint_node_unref (root_node);
root_node = g_steal_pointer (&transform_node);
}
#ifdef CLUTTER_ENABLE_DEBUG
/* Catch when out-of-band transforms have been made by actors not as part
* of an apply_transform vfunc... */
if (G_UNLIKELY (clutter_debug_flags & CLUTTER_DEBUG_OOB_TRANSFORMS))
{
CoglMatrix expected_matrix;
_clutter_actor_get_relative_transformation_matrix (self, NULL,
&expected_matrix);
if (!cogl_matrix_equal (&transform, &expected_matrix))
{
GString *buf = g_string_sized_new (1024);
ClutterActor *parent;
parent = self;
while (parent != NULL)
{
g_string_append (buf, _clutter_actor_get_debug_name (parent));
if (parent->priv->parent != NULL)
g_string_append (buf, "->");
parent = parent->priv->parent;
}
g_warning ("Unexpected transform found when painting actor "
"\"%s\". This will be caused by one of the actor's "
"ancestors (%s) using the Cogl API directly to transform "
"children instead of using ::apply_transform().",
_clutter_actor_get_debug_name (self),
buf->str);
g_string_free (buf, TRUE);
}
}
#endif /* CLUTTER_ENABLE_DEBUG */
}
/* We check whether we need to add the flatten effect before
* each paint so that we can avoid having a mechanism for
* applications to notify when the value of the
* has_overlaps virtual changes.
*/
add_or_remove_flatten_effect (self);
/* We save the current paint volume so that the next time the
* actor queues a redraw we can constrain the redraw to just
* cover the union of the new bounding box and the old.
*
* We also fetch the current paint volume to perform culling so
* we can avoid painting actors outside the current clip region.
*
* If we are painting inside a clone, we should neither update
* the paint volume or use it to cull painting, since the paint
* box represents the location of the source actor on the
* screen.
*
* XXX: We are starting to do a lot of vertex transforms on
* the CPU in a typical paint, so at some point we should
* audit these and consider caching some things.
*
* NB: We don't perform culling while picking at this point because
* clutter-stage.c doesn't setup the clipping planes appropriately.
*
* NB: We don't want to update the last-paint-volume during picking
* because the last-paint-volume is used to determine the old screen
* space location of an actor that has moved so we can know the
* minimal region to redraw to clear an old view of the actor. If we
* update this during picking then by the time we come around to
* paint then the last-paint-volume would likely represent the new
* actor position not the old.
*/
culling_inhibited = priv->inhibit_culling_counter > 0;
if (!culling_inhibited && !in_clone_paint ())
{
gboolean success;
/* annoyingly gcc warns if uninitialized even though
* the initialization is redundant :-( */
ClutterCullResult result = CLUTTER_CULL_RESULT_IN;
if (G_LIKELY ((clutter_paint_debug_flags &
(CLUTTER_DEBUG_DISABLE_CULLING |
CLUTTER_DEBUG_DISABLE_CLIPPED_REDRAWS)) !=
(CLUTTER_DEBUG_DISABLE_CULLING |
CLUTTER_DEBUG_DISABLE_CLIPPED_REDRAWS)))
_clutter_actor_update_last_paint_volume (self);
success = cull_actor (self, paint_context, &result);
if (G_UNLIKELY (clutter_paint_debug_flags & CLUTTER_DEBUG_REDRAWS))
_clutter_actor_paint_cull_result (self, success, result, actor_node);
else if (result == CLUTTER_CULL_RESULT_OUT && success)
return;
}
if (priv->effects == NULL)
priv->next_effect_to_paint = NULL;
else
priv->next_effect_to_paint =
_clutter_meta_group_peek_metas (priv->effects);
if (G_UNLIKELY (clutter_paint_debug_flags & CLUTTER_DEBUG_PAINT_VOLUMES))
_clutter_actor_draw_paint_volume (self, actor_node);
clutter_paint_node_paint (root_node, paint_context);
/* If we make it here then the actor has run through a complete
paint run including all the effects so it's no longer dirty */
priv->is_dirty = FALSE;
}
/**
* clutter_actor_continue_paint:
* @self: A #ClutterActor
*
* Run the next stage of the paint sequence. This function should only
* be called within the implementation of the ‘run’ virtual of a
* #ClutterEffect. It will cause the run method of the next effect to
* be applied, or it will paint the actual actor if the current effect
* is the last effect in the chain.
*
* Since: 1.8
*/
void
clutter_actor_continue_paint (ClutterActor *self,
ClutterPaintContext *paint_context)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
/* This should only be called from with in the ‘run’ implementation
of a ClutterEffect */
g_return_if_fail (CLUTTER_ACTOR_IN_PAINT (self));
priv = self->priv;
/* Skip any effects that are disabled */
while (priv->next_effect_to_paint &&
!clutter_actor_meta_get_enabled (priv->next_effect_to_paint->data))
priv->next_effect_to_paint = priv->next_effect_to_paint->next;
/* If this has come from the last effect then we'll just paint the
actual actor */
if (priv->next_effect_to_paint == NULL)
{
CoglFramebuffer *framebuffer;
ClutterPaintNode *dummy;
/* XXX - this will go away in 2.0, when we can get rid of this
* stuff and switch to a pure retained render tree of PaintNodes
* for the entire frame, starting from the Stage; the paint()
* virtual function can then be called directly.
*/
framebuffer = clutter_paint_context_get_base_framebuffer (paint_context);
dummy = _clutter_dummy_node_new (self, framebuffer);
clutter_paint_node_set_static_name (dummy, "Root");
/* XXX - for 1.12, we use the return value of paint_node() to
* decide whether we should emit the ::paint signal.
*/
clutter_actor_paint_node (self, dummy, paint_context);
clutter_paint_node_unref (dummy);
/* XXX:2.0 - Call the paint() virtual directly */
if (!(clutter_paint_context_get_paint_flags (paint_context) &
CLUTTER_PAINT_FLAG_NO_PAINT_SIGNAL) &&
g_signal_has_handler_pending (self, actor_signals[PAINT],
0, TRUE))
g_signal_emit (self, actor_signals[PAINT], 0, paint_context);
else
CLUTTER_ACTOR_GET_CLASS (self)->paint (self, paint_context);
}
else
{
ClutterEffect *old_current_effect;
ClutterEffectPaintFlags run_flags = 0;
/* Cache the current effect so that we can put it back before
returning */
old_current_effect = priv->current_effect;
priv->current_effect = priv->next_effect_to_paint->data;
priv->next_effect_to_paint = priv->next_effect_to_paint->next;
if (priv->is_dirty)
{
/* If there's an effect queued with this redraw then all
* effects up to that one will be considered dirty. It
* is expected the queued effect will paint the cached
* image and not call clutter_actor_continue_paint again
* (although it should work ok if it does)
*/
if (priv->effect_to_redraw == NULL ||
priv->current_effect != priv->effect_to_redraw)
run_flags |= CLUTTER_EFFECT_PAINT_ACTOR_DIRTY;
}
if (priv->current_effect == priv->flatten_effect &&
priv->offscreen_redirect & CLUTTER_OFFSCREEN_REDIRECT_ON_IDLE &&
run_flags & CLUTTER_EFFECT_PAINT_ACTOR_DIRTY)
run_flags |= CLUTTER_EFFECT_PAINT_BYPASS_EFFECT;
_clutter_effect_paint (priv->current_effect, paint_context, run_flags);
priv->current_effect = old_current_effect;
}
}
/**
* clutter_actor_pick:
* @actor: A #ClutterActor
*
* Asks @actor to perform a pick.
*/
void
clutter_actor_pick (ClutterActor *actor,
ClutterPickContext *pick_context)
{
ClutterActorPrivate *priv;
CoglFramebuffer *framebuffer;
ClutterActorBox clip;
gboolean clip_set = FALSE;
if (CLUTTER_ACTOR_IN_DESTRUCTION (actor))
return;
priv = actor->priv;
/* if we aren't paintable (not in a toplevel with all
* parents paintable) then do nothing.
*/
if (!CLUTTER_ACTOR_IS_MAPPED (actor))
return;
clutter_actor_ensure_resource_scale (actor);
/* mark that we are in the paint process */
CLUTTER_SET_PRIVATE_FLAGS (actor, CLUTTER_IN_PICK);
framebuffer = clutter_pick_context_get_framebuffer (pick_context);
cogl_framebuffer_push_matrix (framebuffer);
if (priv->enable_model_view_transform)
{
CoglMatrix matrix;
cogl_framebuffer_get_modelview_matrix (framebuffer, &matrix);
_clutter_actor_apply_modelview_transform (actor, &matrix);
cogl_framebuffer_set_modelview_matrix (framebuffer, &matrix);
}
if (priv->has_clip)
{
clip.x1 = priv->clip.origin.x;
clip.y1 = priv->clip.origin.y;
clip.x2 = priv->clip.origin.x + priv->clip.size.width;
clip.y2 = priv->clip.origin.y + priv->clip.size.height;
clip_set = TRUE;
}
else if (priv->clip_to_allocation)
{
clip.x1 = 0.f;
clip.y1 = 0.f;
clip.x2 = priv->allocation.x2 - priv->allocation.x1;
clip.y2 = priv->allocation.y2 - priv->allocation.y1;
clip_set = TRUE;
}
if (clip_set)
clip_set = _clutter_actor_push_pick_clip (actor, pick_context, &clip);
priv->next_effect_to_paint = NULL;
if (priv->effects)
{
priv->next_effect_to_paint =
_clutter_meta_group_peek_metas (priv->effects);
}
clutter_actor_continue_pick (actor, pick_context);
if (clip_set)
_clutter_actor_pop_pick_clip (actor);
cogl_framebuffer_pop_matrix (framebuffer);
/* paint sequence complete */
CLUTTER_UNSET_PRIVATE_FLAGS (actor, CLUTTER_IN_PICK);
}
/**
* clutter_actor_continue_pick:
* @actor: A #ClutterActor
*
* Run the next stage of the pick sequence. This function should only
* be called within the implementation of the ‘pick’ virtual of a
* #ClutterEffect. It will cause the run method of the next effect to
* be applied, or it will pick the actual actor if the current effect
* is the last effect in the chain.
*/
void
clutter_actor_continue_pick (ClutterActor *actor,
ClutterPickContext *pick_context)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
g_return_if_fail (CLUTTER_ACTOR_IN_PICK (actor));
priv = actor->priv;
/* Skip any effects that are disabled */
while (priv->next_effect_to_paint &&
!clutter_actor_meta_get_enabled (priv->next_effect_to_paint->data))
priv->next_effect_to_paint = priv->next_effect_to_paint->next;
/* If this has come from the last effect then we'll just pick the
* actual actor.
*/
if (priv->next_effect_to_paint == NULL)
{
/* The actor will log a silhouette of itself to the stage pick log.
*
* XXX:2.0 - Call the pick() virtual directly
*/
if (g_signal_has_handler_pending (actor, actor_signals[PICK],
0, TRUE))
g_signal_emit (actor, actor_signals[PICK], 0, pick_context);
else
CLUTTER_ACTOR_GET_CLASS (actor)->pick (actor, pick_context);
}
else
{
ClutterEffect *old_current_effect;
/* Cache the current effect so that we can put it back before
* returning.
*/
old_current_effect = priv->current_effect;
priv->current_effect = priv->next_effect_to_paint->data;
priv->next_effect_to_paint = priv->next_effect_to_paint->next;
_clutter_effect_pick (priv->current_effect, pick_context);
priv->current_effect = old_current_effect;
}
}
static void
_clutter_actor_stop_transitions (ClutterActor *self)
{
const ClutterAnimationInfo *info;
GHashTableIter iter;
gpointer value;
info = _clutter_actor_get_animation_info_or_defaults (self);
if (info->transitions == NULL)
return;
g_hash_table_iter_init (&iter, info->transitions);
while (g_hash_table_iter_next (&iter, NULL, &value))
{
TransitionClosure *closure = value;
if (clutter_transition_get_remove_on_complete (closure->transition))
{
g_hash_table_iter_remove (&iter);
}
else
{
/* otherwise we stop it, and the transition will be removed
* later, either by the actor's destruction or by explicit
* removal
*/
clutter_timeline_stop (CLUTTER_TIMELINE (closure->transition));
}
}
}
static ClutterActorTraverseVisitFlags
invalidate_queue_redraw_entry (ClutterActor *self,
int depth,
gpointer user_data)
{
ClutterActorPrivate *priv = self->priv;
if (priv->queue_redraw_entry != NULL)
{
_clutter_stage_queue_redraw_entry_invalidate (priv->queue_redraw_entry);
priv->queue_redraw_entry = NULL;
}
return CLUTTER_ACTOR_TRAVERSE_VISIT_CONTINUE;
}
static inline void
remove_child (ClutterActor *self,
ClutterActor *child)
{
ClutterActor *prev_sibling, *next_sibling;
prev_sibling = child->priv->prev_sibling;
next_sibling = child->priv->next_sibling;
if (prev_sibling != NULL)
prev_sibling->priv->next_sibling = next_sibling;
if (next_sibling != NULL)
next_sibling->priv->prev_sibling = prev_sibling;
if (self->priv->first_child == child)
self->priv->first_child = next_sibling;
if (self->priv->last_child == child)
self->priv->last_child = prev_sibling;
child->priv->parent = NULL;
child->priv->prev_sibling = NULL;
child->priv->next_sibling = NULL;
}
typedef enum
{
REMOVE_CHILD_DESTROY_META = 1 << 0,
REMOVE_CHILD_EMIT_PARENT_SET = 1 << 1,
REMOVE_CHILD_EMIT_ACTOR_REMOVED = 1 << 2,
REMOVE_CHILD_CHECK_STATE = 1 << 3,
REMOVE_CHILD_FLUSH_QUEUE = 1 << 4,
REMOVE_CHILD_NOTIFY_FIRST_LAST = 1 << 5,
REMOVE_CHILD_STOP_TRANSITIONS = 1 << 6,
/* default flags for public API */
REMOVE_CHILD_DEFAULT_FLAGS = REMOVE_CHILD_STOP_TRANSITIONS |
REMOVE_CHILD_DESTROY_META |
REMOVE_CHILD_EMIT_PARENT_SET |
REMOVE_CHILD_EMIT_ACTOR_REMOVED |
REMOVE_CHILD_CHECK_STATE |
REMOVE_CHILD_FLUSH_QUEUE |
REMOVE_CHILD_NOTIFY_FIRST_LAST,
/* flags for legacy/deprecated API */
REMOVE_CHILD_LEGACY_FLAGS = REMOVE_CHILD_STOP_TRANSITIONS |
REMOVE_CHILD_CHECK_STATE |
REMOVE_CHILD_FLUSH_QUEUE |
REMOVE_CHILD_EMIT_PARENT_SET |
REMOVE_CHILD_NOTIFY_FIRST_LAST
} ClutterActorRemoveChildFlags;
/*< private >
* clutter_actor_remove_child_internal:
* @self: a #ClutterActor
* @child: the child of @self that has to be removed
* @flags: control the removal operations
*
* Removes @child from the list of children of @self.
*/
static void
clutter_actor_remove_child_internal (ClutterActor *self,
ClutterActor *child,
ClutterActorRemoveChildFlags flags)
{
ClutterActor *old_first, *old_last;
gboolean destroy_meta, emit_parent_set, emit_actor_removed, check_state;
gboolean flush_queue;
gboolean notify_first_last;
gboolean was_mapped;
gboolean stop_transitions;
GObject *obj;
if (self == child)
{
g_warning ("Cannot remove actor '%s' from itself.",
_clutter_actor_get_debug_name (self));
return;
}
destroy_meta = (flags & REMOVE_CHILD_DESTROY_META) != 0;
emit_parent_set = (flags & REMOVE_CHILD_EMIT_PARENT_SET) != 0;
emit_actor_removed = (flags & REMOVE_CHILD_EMIT_ACTOR_REMOVED) != 0;
check_state = (flags & REMOVE_CHILD_CHECK_STATE) != 0;
flush_queue = (flags & REMOVE_CHILD_FLUSH_QUEUE) != 0;
notify_first_last = (flags & REMOVE_CHILD_NOTIFY_FIRST_LAST) != 0;
stop_transitions = (flags & REMOVE_CHILD_STOP_TRANSITIONS) != 0;
obj = G_OBJECT (self);
g_object_freeze_notify (obj);
if (stop_transitions)
_clutter_actor_stop_transitions (child);
if (destroy_meta)
clutter_container_destroy_child_meta (CLUTTER_CONTAINER (self), child);
if (check_state)
{
was_mapped = CLUTTER_ACTOR_IS_MAPPED (child);
/* we need to unrealize *before* we set parent_actor to NULL,
* because in an unrealize method actors are dissociating from the
* stage, which means they need to be able to
* clutter_actor_get_stage().
*
* yhis should unmap and unrealize, unless we're reparenting.
*/
clutter_actor_update_map_state (child, MAP_STATE_MAKE_UNREALIZED);
}
else
was_mapped = FALSE;
if (flush_queue)
{
/* We take this opportunity to invalidate any queue redraw entry
* associated with the actor and descendants since we won't be able to
* determine the appropriate stage after this.
*
* we do this after we updated the mapped state because actors might
* end up queueing redraws inside their mapped/unmapped virtual
* functions, and if we invalidate the redraw entry we could end up
* with an inconsistent state and weird memory corruption. see
* bugs:
*
* http://bugzilla.clutter-project.org/show_bug.cgi?id=2621
* https://bugzilla.gnome.org/show_bug.cgi?id=652036
*/
_clutter_actor_traverse (child,
0,
invalidate_queue_redraw_entry,
NULL,
NULL);
}
old_first = self->priv->first_child;
old_last = self->priv->last_child;
remove_child (self, child);
self->priv->n_children -= 1;
self->priv->age += 1;
if (self->priv->in_cloned_branch)
clutter_actor_pop_in_cloned_branch (child, self->priv->in_cloned_branch);
/* if the child that got removed was visible and set to
* expand then we want to reset the parent's state in
* case the child was the only thing that was making it
* expand.
*/
if (CLUTTER_ACTOR_IS_VISIBLE (child) &&
(child->priv->needs_compute_expand ||
child->priv->needs_x_expand ||
child->priv->needs_y_expand))
{
clutter_actor_queue_compute_expand (self);
}
if (emit_parent_set && !CLUTTER_ACTOR_IN_REPARENT (child) &&
!CLUTTER_ACTOR_IN_DESTRUCTION (child))
{
child->priv->needs_compute_resource_scale = TRUE;
g_signal_emit (child, actor_signals[PARENT_SET], 0, self);
}
/* if the child was mapped then we need to relayout ourselves to account
* for the removed child
*/
if (was_mapped)
clutter_actor_queue_relayout (self);
/* we need to emit the signal before dropping the reference */
if (emit_actor_removed)
_clutter_container_emit_actor_removed (CLUTTER_CONTAINER (self), child);
if (notify_first_last)
{
if (old_first != self->priv->first_child)
g_object_notify_by_pspec (obj, obj_props[PROP_FIRST_CHILD]);
if (old_last != self->priv->last_child)
g_object_notify_by_pspec (obj, obj_props[PROP_LAST_CHILD]);
}
g_object_thaw_notify (obj);
/* remove the reference we acquired in clutter_actor_add_child() */
g_object_unref (child);
}
static const ClutterTransformInfo default_transform_info = {
0.0, { 0, }, /* rotation-x */
0.0, { 0, }, /* rotation-y */
0.0, { 0, }, /* rotation-z */
1.0, 1.0, 1.0, { 0, }, /* scale */
{ 0, }, /* anchor XXX:2.0 - remove*/
GRAPHENE_POINT3D_INIT_ZERO, /* translation */
0.f, /* z-position */
GRAPHENE_POINT_INIT_ZERO, /* pivot */
0.f, /* pivot-z */
CLUTTER_MATRIX_INIT_IDENTITY,
FALSE, /* transform */
CLUTTER_MATRIX_INIT_IDENTITY,
FALSE, /* child-transform */
};
/*< private >
* _clutter_actor_get_transform_info_or_defaults:
* @self: a #ClutterActor
*
* Retrieves the ClutterTransformInfo structure associated to an actor.
*
* If the actor does not have a ClutterTransformInfo structure associated
* to it, then the default structure will be returned.
*
* This function should only be used for getters.
*
* Return value: a const pointer to the ClutterTransformInfo structure
*/
const ClutterTransformInfo *
_clutter_actor_get_transform_info_or_defaults (ClutterActor *self)
{
ClutterTransformInfo *info;
info = g_object_get_qdata (G_OBJECT (self), quark_actor_transform_info);
if (info != NULL)
return info;
return &default_transform_info;
}
static void
clutter_transform_info_free (gpointer data)
{
if (data != NULL)
g_slice_free (ClutterTransformInfo, data);
}
/*< private >
* _clutter_actor_get_transform_info:
* @self: a #ClutterActor
*
* Retrieves a pointer to the ClutterTransformInfo structure.
*
* If the actor does not have a ClutterTransformInfo associated to it, one
* will be created and initialized to the default values.
*
* This function should be used for setters.
*
* For getters, you should use _clutter_actor_get_transform_info_or_defaults()
* instead.
*
* Return value: (transfer none): a pointer to the ClutterTransformInfo
* structure
*/
ClutterTransformInfo *
_clutter_actor_get_transform_info (ClutterActor *self)
{
ClutterTransformInfo *info;
info = g_object_get_qdata (G_OBJECT (self), quark_actor_transform_info);
if (info == NULL)
{
info = g_slice_new (ClutterTransformInfo);
*info = default_transform_info;
g_object_set_qdata_full (G_OBJECT (self), quark_actor_transform_info,
info,
clutter_transform_info_free);
}
return info;
}
static inline void
clutter_actor_set_pivot_point_internal (ClutterActor *self,
const graphene_point_t *pivot)
{
ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info (self);
info->pivot = *pivot;
self->priv->transform_valid = FALSE;
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_PIVOT_POINT]);
clutter_actor_queue_redraw (self);
}
static inline void
clutter_actor_set_pivot_point_z_internal (ClutterActor *self,
float pivot_z)
{
ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info (self);
info->pivot_z = pivot_z;
self->priv->transform_valid = FALSE;
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_PIVOT_POINT_Z]);
clutter_actor_queue_redraw (self);
}
/*< private >
* clutter_actor_set_translation_internal:
* @self: a #ClutterActor
* @axis: the axis of the translation to change
* @angle: the translation as a value along @axis
*
* Sets the translation on the given @axis
*/
static void
clutter_actor_set_translation_internal (ClutterActor *self,
gfloat value,
GParamSpec *pspec)
{
GObject *obj = G_OBJECT (self);
ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info (self);
if (pspec == obj_props[PROP_TRANSLATION_X])
info->translation.x = value;
else if (pspec == obj_props[PROP_TRANSLATION_Y])
info->translation.y = value;
else if (pspec == obj_props[PROP_TRANSLATION_Z])
info->translation.z = value;
else
g_assert_not_reached ();
self->priv->transform_valid = FALSE;
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (obj, pspec);
}
static inline void
clutter_actor_set_translation_factor (ClutterActor *self,
ClutterRotateAxis axis,
gdouble value)
{
const ClutterTransformInfo *info;
const float *translate_p = NULL;
GParamSpec *pspec = NULL;
info = _clutter_actor_get_transform_info_or_defaults (self);
switch (axis)
{
case CLUTTER_X_AXIS:
pspec = obj_props[PROP_TRANSLATION_X];
translate_p = &info->translation.x;
break;
case CLUTTER_Y_AXIS:
pspec = obj_props[PROP_TRANSLATION_Y];
translate_p = &info->translation.y;
break;
case CLUTTER_Z_AXIS:
pspec = obj_props[PROP_TRANSLATION_Z];
translate_p = &info->translation.z;
break;
}
g_assert (pspec != NULL);
g_assert (translate_p != NULL);
_clutter_actor_create_transition (self, pspec, *translate_p, value);
}
/**
* clutter_actor_set_translation:
* @self: a #ClutterActor
* @translate_x: the translation along the X axis
* @translate_y: the translation along the Y axis
* @translate_z: the translation along the Z axis
*
* Sets an additional translation transformation on a #ClutterActor,
* relative to the #ClutterActor:pivot-point.
*
* Since: 1.12
*/
void
clutter_actor_set_translation (ClutterActor *self,
gfloat translate_x,
gfloat translate_y,
gfloat translate_z)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_object_freeze_notify (G_OBJECT (self));
clutter_actor_set_translation_factor (self, CLUTTER_X_AXIS, translate_x);
clutter_actor_set_translation_factor (self, CLUTTER_Y_AXIS, translate_y);
clutter_actor_set_translation_factor (self, CLUTTER_Z_AXIS, translate_z);
g_object_thaw_notify (G_OBJECT (self));
}
/**
* clutter_actor_get_translation:
* @self: a #ClutterActor
* @translate_x: (out) (allow-none): return location for the X component
* of the translation, or %NULL
* @translate_y: (out) (allow-none): return location for the Y component
* of the translation, or %NULL
* @translate_z: (out) (allow-none): return location for the Z component
* of the translation, or %NULL
*
* Retrieves the translation set using clutter_actor_set_translation().
*
* Since: 1.12
*/
void
clutter_actor_get_translation (ClutterActor *self,
gfloat *translate_x,
gfloat *translate_y,
gfloat *translate_z)
{
const ClutterTransformInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_transform_info_or_defaults (self);
if (translate_x != NULL)
*translate_x = info->translation.x;
if (translate_y != NULL)
*translate_y = info->translation.y;
if (translate_z != NULL)
*translate_z = info->translation.z;
}
/*< private >
* clutter_actor_set_rotation_angle_internal:
* @self: a #ClutterActor
* @angle: the angle of rotation
* @pspec: the #GParamSpec of the property
*
* Sets the rotation angle on the given axis without affecting the
* rotation center point.
*/
static inline void
clutter_actor_set_rotation_angle_internal (ClutterActor *self,
gdouble angle,
GParamSpec *pspec)
{
ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info (self);
if (pspec == obj_props[PROP_ROTATION_ANGLE_X])
info->rx_angle = angle;
else if (pspec == obj_props[PROP_ROTATION_ANGLE_Y])
info->ry_angle = angle;
else if (pspec == obj_props[PROP_ROTATION_ANGLE_Z])
info->rz_angle = angle;
else
g_assert_not_reached ();
self->priv->transform_valid = FALSE;
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (G_OBJECT (self), pspec);
}
/**
* clutter_actor_set_rotation_angle:
* @self: a #ClutterActor
* @axis: the axis to set the angle one
* @angle: the angle of rotation, in degrees
*
* Sets the @angle of rotation of a #ClutterActor on the given @axis.
*
* This function is a convenience for setting the rotation properties
* #ClutterActor:rotation-angle-x, #ClutterActor:rotation-angle-y,
* and #ClutterActor:rotation-angle-z.
*
* The center of rotation is established by the #ClutterActor:pivot-point
* property.
*
* Since: 1.12
*/
void
clutter_actor_set_rotation_angle (ClutterActor *self,
ClutterRotateAxis axis,
gdouble angle)
{
const ClutterTransformInfo *info;
const double *cur_angle_p = NULL;
GParamSpec *pspec = NULL;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_transform_info_or_defaults (self);
switch (axis)
{
case CLUTTER_X_AXIS:
cur_angle_p = &info->rx_angle;
pspec = obj_props[PROP_ROTATION_ANGLE_X];
break;
case CLUTTER_Y_AXIS:
cur_angle_p = &info->ry_angle;
pspec = obj_props[PROP_ROTATION_ANGLE_Y];
break;
case CLUTTER_Z_AXIS:
cur_angle_p = &info->rz_angle;
pspec = obj_props[PROP_ROTATION_ANGLE_Z];
break;
}
g_assert (pspec != NULL);
g_assert (cur_angle_p != NULL);
_clutter_actor_create_transition (self, pspec, *cur_angle_p, angle);
}
/**
* clutter_actor_get_rotation_angle:
* @self: a #ClutterActor
* @axis: the axis of the rotation
*
* Retrieves the angle of rotation set by clutter_actor_set_rotation_angle().
*
* Return value: the angle of rotation, in degrees
*
* Since: 1.12
*/
gdouble
clutter_actor_get_rotation_angle (ClutterActor *self,
ClutterRotateAxis axis)
{
const ClutterTransformInfo *info;
gdouble retval;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0.0);
info = _clutter_actor_get_transform_info_or_defaults (self);
switch (axis)
{
case CLUTTER_X_AXIS:
retval = info->rx_angle;
break;
case CLUTTER_Y_AXIS:
retval = info->ry_angle;
break;
case CLUTTER_Z_AXIS:
retval = info->rz_angle;
break;
default:
g_warn_if_reached ();
retval = 0.0;
break;
}
return retval;
}
/*< private >
* clutter_actor_set_rotation_center_internal:
* @self: a #ClutterActor
* @axis: the axis of the center to change
* @center: the coordinates of the rotation center
*
* Sets the rotation center on the given axis without affecting the
* rotation angle.
*/
static inline void
clutter_actor_set_rotation_center_internal (ClutterActor *self,
ClutterRotateAxis axis,
const graphene_point3d_t *center)
{
graphene_point3d_t v = GRAPHENE_POINT3D_INIT_ZERO;
GObject *obj = G_OBJECT (self);
ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info (self);
if (center != NULL)
v = *center;
g_object_freeze_notify (obj);
switch (axis)
{
case CLUTTER_X_AXIS:
clutter_anchor_coord_set_units (&info->rx_center, v.x, v.y, v.z);
g_object_notify_by_pspec (obj, obj_props[PROP_ROTATION_CENTER_X]);
break;
case CLUTTER_Y_AXIS:
clutter_anchor_coord_set_units (&info->ry_center, v.x, v.y, v.z);
g_object_notify_by_pspec (obj, obj_props[PROP_ROTATION_CENTER_Y]);
break;
case CLUTTER_Z_AXIS:
/* if the previously set rotation center was fractional, then
* setting explicit coordinates will have to notify the
* :rotation-center-z-gravity property as well
*/
if (info->rz_center.is_fractional)
g_object_notify_by_pspec (obj, obj_props[PROP_ROTATION_CENTER_Z_GRAVITY]);
clutter_anchor_coord_set_units (&info->rz_center, v.x, v.y, v.z);
g_object_notify_by_pspec (obj, obj_props[PROP_ROTATION_CENTER_Z]);
break;
}
self->priv->transform_valid = FALSE;
g_object_thaw_notify (obj);
clutter_actor_queue_redraw (self);
}
static void
clutter_actor_set_scale_factor_internal (ClutterActor *self,
double factor,
GParamSpec *pspec)
{
GObject *obj = G_OBJECT (self);
ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info (self);
if (pspec == obj_props[PROP_SCALE_X])
info->scale_x = factor;
else if (pspec == obj_props[PROP_SCALE_Y])
info->scale_y = factor;
else if (pspec == obj_props[PROP_SCALE_Z])
info->scale_z = factor;
else
g_assert_not_reached ();
self->priv->transform_valid = FALSE;
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (obj, pspec);
}
static inline void
clutter_actor_set_scale_factor (ClutterActor *self,
ClutterRotateAxis axis,
gdouble factor)
{
const ClutterTransformInfo *info;
const double *scale_p = NULL;
GParamSpec *pspec = NULL;
info = _clutter_actor_get_transform_info_or_defaults (self);
switch (axis)
{
case CLUTTER_X_AXIS:
pspec = obj_props[PROP_SCALE_X];
scale_p = &info->scale_x;
break;
case CLUTTER_Y_AXIS:
pspec = obj_props[PROP_SCALE_Y];
scale_p = &info->scale_y;
break;
case CLUTTER_Z_AXIS:
pspec = obj_props[PROP_SCALE_Z];
scale_p = &info->scale_z;
break;
}
g_assert (pspec != NULL);
g_assert (scale_p != NULL);
if (*scale_p != factor)
_clutter_actor_create_transition (self, pspec, *scale_p, factor);
}
static inline void
clutter_actor_set_scale_center (ClutterActor *self,
ClutterRotateAxis axis,
gfloat coord)
{
GObject *obj = G_OBJECT (self);
ClutterTransformInfo *info;
gfloat center_x, center_y;
info = _clutter_actor_get_transform_info (self);
g_object_freeze_notify (obj);
/* get the current scale center coordinates */
clutter_anchor_coord_get_units (self, &info->scale_center,
¢er_x,
¢er_y,
NULL);
/* we need to notify this too, because setting explicit coordinates will
* change the gravity as a side effect
*/
if (info->scale_center.is_fractional)
g_object_notify_by_pspec (obj, obj_props[PROP_SCALE_GRAVITY]);
switch (axis)
{
case CLUTTER_X_AXIS:
clutter_anchor_coord_set_units (&info->scale_center, coord, center_y, 0);
g_object_notify_by_pspec (obj, obj_props[PROP_SCALE_CENTER_X]);
break;
case CLUTTER_Y_AXIS:
clutter_anchor_coord_set_units (&info->scale_center, center_x, coord, 0);
g_object_notify_by_pspec (obj, obj_props[PROP_SCALE_CENTER_Y]);
break;
default:
g_assert_not_reached ();
}
self->priv->transform_valid = FALSE;
clutter_actor_queue_redraw (self);
g_object_thaw_notify (obj);
}
static inline void
clutter_actor_set_scale_gravity (ClutterActor *self,
ClutterGravity gravity)
{
ClutterTransformInfo *info;
GObject *obj;
info = _clutter_actor_get_transform_info (self);
obj = G_OBJECT (self);
if (gravity == CLUTTER_GRAVITY_NONE)
clutter_anchor_coord_set_units (&info->scale_center, 0, 0, 0);
else
clutter_anchor_coord_set_gravity (&info->scale_center, gravity);
self->priv->transform_valid = FALSE;
g_object_notify_by_pspec (obj, obj_props[PROP_SCALE_CENTER_X]);
g_object_notify_by_pspec (obj, obj_props[PROP_SCALE_CENTER_Y]);
g_object_notify_by_pspec (obj, obj_props[PROP_SCALE_GRAVITY]);
clutter_actor_queue_redraw (self);
}
/* XXX:2.0 - remove */
static inline void
clutter_actor_set_anchor_coord (ClutterActor *self,
ClutterRotateAxis axis,
gfloat coord)
{
GObject *obj = G_OBJECT (self);
ClutterTransformInfo *info;
gfloat anchor_x, anchor_y;
info = _clutter_actor_get_transform_info (self);
g_object_freeze_notify (obj);
clutter_anchor_coord_get_units (self, &info->anchor,
&anchor_x,
&anchor_y,
NULL);
if (info->anchor.is_fractional)
g_object_notify_by_pspec (obj, obj_props[PROP_ANCHOR_GRAVITY]);
switch (axis)
{
case CLUTTER_X_AXIS:
clutter_anchor_coord_set_units (&info->anchor,
coord,
anchor_y,
0.0);
g_object_notify_by_pspec (obj, obj_props[PROP_ANCHOR_X]);
break;
case CLUTTER_Y_AXIS:
clutter_anchor_coord_set_units (&info->anchor,
anchor_x,
coord,
0.0);
g_object_notify_by_pspec (obj, obj_props[PROP_ANCHOR_Y]);
break;
default:
g_assert_not_reached ();
}
self->priv->transform_valid = FALSE;
clutter_actor_queue_redraw (self);
g_object_thaw_notify (obj);
}
static void
clutter_actor_set_clip_rect (ClutterActor *self,
const graphene_rect_t *clip)
{
ClutterActorPrivate *priv = self->priv;
GObject *obj = G_OBJECT (self);
if (clip != NULL)
{
priv->clip = *clip;
priv->has_clip = TRUE;
}
else
priv->has_clip = FALSE;
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (obj, obj_props[PROP_CLIP_RECT]);
g_object_notify_by_pspec (obj, obj_props[PROP_HAS_CLIP]);
}
static void
clutter_actor_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterActor *actor = CLUTTER_ACTOR (object);
ClutterActorPrivate *priv = actor->priv;
switch (prop_id)
{
case PROP_X:
clutter_actor_set_x (actor, g_value_get_float (value));
break;
case PROP_Y:
clutter_actor_set_y (actor, g_value_get_float (value));
break;
case PROP_POSITION:
{
const graphene_point_t *pos = g_value_get_boxed (value);
if (pos != NULL)
clutter_actor_set_position (actor, pos->x, pos->y);
else
clutter_actor_set_fixed_position_set (actor, FALSE);
}
break;
case PROP_WIDTH:
clutter_actor_set_width (actor, g_value_get_float (value));
break;
case PROP_HEIGHT:
clutter_actor_set_height (actor, g_value_get_float (value));
break;
case PROP_SIZE:
{
const graphene_size_t *size = g_value_get_boxed (value);
if (size != NULL)
clutter_actor_set_size (actor, size->width, size->height);
else
clutter_actor_set_size (actor, -1, -1);
}
break;
case PROP_FIXED_X:
clutter_actor_set_x (actor, g_value_get_float (value));
break;
case PROP_FIXED_Y:
clutter_actor_set_y (actor, g_value_get_float (value));
break;
case PROP_FIXED_POSITION_SET:
clutter_actor_set_fixed_position_set (actor, g_value_get_boolean (value));
break;
case PROP_MIN_WIDTH:
clutter_actor_set_min_width (actor, g_value_get_float (value));
break;
case PROP_MIN_HEIGHT:
clutter_actor_set_min_height (actor, g_value_get_float (value));
break;
case PROP_NATURAL_WIDTH:
clutter_actor_set_natural_width (actor, g_value_get_float (value));
break;
case PROP_NATURAL_HEIGHT:
clutter_actor_set_natural_height (actor, g_value_get_float (value));
break;
case PROP_MIN_WIDTH_SET:
clutter_actor_set_min_width_set (actor, g_value_get_boolean (value));
break;
case PROP_MIN_HEIGHT_SET:
clutter_actor_set_min_height_set (actor, g_value_get_boolean (value));
break;
case PROP_NATURAL_WIDTH_SET:
clutter_actor_set_natural_width_set (actor, g_value_get_boolean (value));
break;
case PROP_NATURAL_HEIGHT_SET:
clutter_actor_set_natural_height_set (actor, g_value_get_boolean (value));
break;
case PROP_REQUEST_MODE:
clutter_actor_set_request_mode (actor, g_value_get_enum (value));
break;
case PROP_DEPTH: /* XXX:2.0 - remove */
clutter_actor_set_depth (actor, g_value_get_float (value));
break;
case PROP_Z_POSITION:
clutter_actor_set_z_position (actor, g_value_get_float (value));
break;
case PROP_OPACITY:
clutter_actor_set_opacity (actor, g_value_get_uint (value));
break;
case PROP_OFFSCREEN_REDIRECT:
clutter_actor_set_offscreen_redirect (actor, g_value_get_enum (value));
break;
case PROP_NAME:
clutter_actor_set_name (actor, g_value_get_string (value));
break;
case PROP_VISIBLE:
if (g_value_get_boolean (value) == TRUE)
clutter_actor_show (actor);
else
clutter_actor_hide (actor);
break;
case PROP_PIVOT_POINT:
{
const graphene_point_t *pivot = g_value_get_boxed (value);
if (pivot == NULL)
pivot = graphene_point_zero ();
clutter_actor_set_pivot_point (actor, pivot->x, pivot->y);
}
break;
case PROP_PIVOT_POINT_Z:
clutter_actor_set_pivot_point_z (actor, g_value_get_float (value));
break;
case PROP_TRANSLATION_X:
clutter_actor_set_translation_factor (actor, CLUTTER_X_AXIS,
g_value_get_float (value));
break;
case PROP_TRANSLATION_Y:
clutter_actor_set_translation_factor (actor, CLUTTER_Y_AXIS,
g_value_get_float (value));
break;
case PROP_TRANSLATION_Z:
clutter_actor_set_translation_factor (actor, CLUTTER_Z_AXIS,
g_value_get_float (value));
break;
case PROP_SCALE_X:
clutter_actor_set_scale_factor (actor, CLUTTER_X_AXIS,
g_value_get_double (value));
break;
case PROP_SCALE_Y:
clutter_actor_set_scale_factor (actor, CLUTTER_Y_AXIS,
g_value_get_double (value));
break;
case PROP_SCALE_Z:
clutter_actor_set_scale_factor (actor, CLUTTER_Z_AXIS,
g_value_get_double (value));
break;
case PROP_SCALE_CENTER_X: /* XXX:2.0 - remove */
clutter_actor_set_scale_center (actor, CLUTTER_X_AXIS,
g_value_get_float (value));
break;
case PROP_SCALE_CENTER_Y: /* XXX:2.0 - remove */
clutter_actor_set_scale_center (actor, CLUTTER_Y_AXIS,
g_value_get_float (value));
break;
case PROP_SCALE_GRAVITY: /* XXX:2.0 - remove */
clutter_actor_set_scale_gravity (actor, g_value_get_enum (value));
break;
case PROP_CLIP_RECT:
clutter_actor_set_clip_rect (actor, g_value_get_boxed (value));
break;
case PROP_CLIP_TO_ALLOCATION:
clutter_actor_set_clip_to_allocation (actor, g_value_get_boolean (value));
break;
case PROP_REACTIVE:
clutter_actor_set_reactive (actor, g_value_get_boolean (value));
break;
case PROP_ROTATION_ANGLE_X:
clutter_actor_set_rotation_angle (actor,
CLUTTER_X_AXIS,
g_value_get_double (value));
break;
case PROP_ROTATION_ANGLE_Y:
clutter_actor_set_rotation_angle (actor,
CLUTTER_Y_AXIS,
g_value_get_double (value));
break;
case PROP_ROTATION_ANGLE_Z:
clutter_actor_set_rotation_angle (actor,
CLUTTER_Z_AXIS,
g_value_get_double (value));
break;
case PROP_ROTATION_CENTER_X: /* XXX:2.0 - remove */
clutter_actor_set_rotation_center_internal (actor,
CLUTTER_X_AXIS,
g_value_get_boxed (value));
break;
case PROP_ROTATION_CENTER_Y: /* XXX:2.0 - remove */
clutter_actor_set_rotation_center_internal (actor,
CLUTTER_Y_AXIS,
g_value_get_boxed (value));
break;
case PROP_ROTATION_CENTER_Z: /* XXX:2.0 - remove */
clutter_actor_set_rotation_center_internal (actor,
CLUTTER_Z_AXIS,
g_value_get_boxed (value));
break;
case PROP_ROTATION_CENTER_Z_GRAVITY: /* XXX:2.0 - remove */
{
const ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info_or_defaults (actor);
clutter_actor_set_z_rotation_from_gravity (actor, info->rz_angle,
g_value_get_enum (value));
}
break;
case PROP_ANCHOR_X: /* XXX:2.0 - remove */
clutter_actor_set_anchor_coord (actor, CLUTTER_X_AXIS,
g_value_get_float (value));
break;
case PROP_ANCHOR_Y: /* XXX:2.0 - remove */
clutter_actor_set_anchor_coord (actor, CLUTTER_Y_AXIS,
g_value_get_float (value));
break;
case PROP_ANCHOR_GRAVITY: /* XXX:2.0 - remove */
clutter_actor_set_anchor_point_from_gravity (actor,
g_value_get_enum (value));
break;
case PROP_TRANSFORM:
clutter_actor_set_transform (actor, g_value_get_boxed (value));
break;
case PROP_CHILD_TRANSFORM:
clutter_actor_set_child_transform (actor, g_value_get_boxed (value));
break;
case PROP_SHOW_ON_SET_PARENT: /* XXX:2.0 - remove */
priv->show_on_set_parent = g_value_get_boolean (value);
break;
case PROP_TEXT_DIRECTION:
clutter_actor_set_text_direction (actor, g_value_get_enum (value));
break;
case PROP_ACTIONS:
clutter_actor_add_action (actor, g_value_get_object (value));
break;
case PROP_CONSTRAINTS:
clutter_actor_add_constraint (actor, g_value_get_object (value));
break;
case PROP_EFFECT:
clutter_actor_add_effect (actor, g_value_get_object (value));
break;
case PROP_LAYOUT_MANAGER:
clutter_actor_set_layout_manager (actor, g_value_get_object (value));
break;
case PROP_X_EXPAND:
clutter_actor_set_x_expand (actor, g_value_get_boolean (value));
break;
case PROP_Y_EXPAND:
clutter_actor_set_y_expand (actor, g_value_get_boolean (value));
break;
case PROP_X_ALIGN:
clutter_actor_set_x_align (actor, g_value_get_enum (value));
break;
case PROP_Y_ALIGN:
clutter_actor_set_y_align (actor, g_value_get_enum (value));
break;
case PROP_MARGIN_TOP:
clutter_actor_set_margin_top (actor, g_value_get_float (value));
break;
case PROP_MARGIN_BOTTOM:
clutter_actor_set_margin_bottom (actor, g_value_get_float (value));
break;
case PROP_MARGIN_LEFT:
clutter_actor_set_margin_left (actor, g_value_get_float (value));
break;
case PROP_MARGIN_RIGHT:
clutter_actor_set_margin_right (actor, g_value_get_float (value));
break;
case PROP_BACKGROUND_COLOR:
clutter_actor_set_background_color (actor, g_value_get_boxed (value));
break;
case PROP_CONTENT:
clutter_actor_set_content (actor, g_value_get_object (value));
break;
case PROP_CONTENT_GRAVITY:
clutter_actor_set_content_gravity (actor, g_value_get_enum (value));
break;
case PROP_MINIFICATION_FILTER:
clutter_actor_set_content_scaling_filters (actor,
g_value_get_enum (value),
actor->priv->mag_filter);
break;
case PROP_MAGNIFICATION_FILTER:
clutter_actor_set_content_scaling_filters (actor,
actor->priv->min_filter,
g_value_get_enum (value));
break;
case PROP_CONTENT_REPEAT:
clutter_actor_set_content_repeat (actor, g_value_get_flags (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
clutter_actor_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterActor *actor = CLUTTER_ACTOR (object);
ClutterActorPrivate *priv = actor->priv;
switch (prop_id)
{
case PROP_X:
g_value_set_float (value, clutter_actor_get_x (actor));
break;
case PROP_Y:
g_value_set_float (value, clutter_actor_get_y (actor));
break;
case PROP_POSITION:
{
graphene_point_t position;
graphene_point_init (&position,
clutter_actor_get_x (actor),
clutter_actor_get_y (actor));
g_value_set_boxed (value, &position);
}
break;
case PROP_WIDTH:
g_value_set_float (value, clutter_actor_get_width (actor));
break;
case PROP_HEIGHT:
g_value_set_float (value, clutter_actor_get_height (actor));
break;
case PROP_SIZE:
{
graphene_size_t size;
graphene_size_init (&size,
clutter_actor_get_width (actor),
clutter_actor_get_height (actor));
g_value_set_boxed (value, &size);
}
break;
case PROP_FIXED_X:
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (actor);
g_value_set_float (value, info->fixed_pos.x);
}
break;
case PROP_FIXED_Y:
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (actor);
g_value_set_float (value, info->fixed_pos.y);
}
break;
case PROP_FIXED_POSITION_SET:
g_value_set_boolean (value, priv->position_set);
break;
case PROP_MIN_WIDTH:
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (actor);
g_value_set_float (value, info->minimum.width);
}
break;
case PROP_MIN_HEIGHT:
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (actor);
g_value_set_float (value, info->minimum.height);
}
break;
case PROP_NATURAL_WIDTH:
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (actor);
g_value_set_float (value, info->natural.width);
}
break;
case PROP_NATURAL_HEIGHT:
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (actor);
g_value_set_float (value, info->natural.height);
}
break;
case PROP_MIN_WIDTH_SET:
g_value_set_boolean (value, priv->min_width_set);
break;
case PROP_MIN_HEIGHT_SET:
g_value_set_boolean (value, priv->min_height_set);
break;
case PROP_NATURAL_WIDTH_SET:
g_value_set_boolean (value, priv->natural_width_set);
break;
case PROP_NATURAL_HEIGHT_SET:
g_value_set_boolean (value, priv->natural_height_set);
break;
case PROP_REQUEST_MODE:
g_value_set_enum (value, priv->request_mode);
break;
case PROP_ALLOCATION:
g_value_set_boxed (value, &priv->allocation);
break;
case PROP_DEPTH: /* XXX:2.0 - remove */
g_value_set_float (value, clutter_actor_get_depth (actor));
break;
case PROP_Z_POSITION:
g_value_set_float (value, clutter_actor_get_z_position (actor));
break;
case PROP_OPACITY:
g_value_set_uint (value, priv->opacity);
break;
case PROP_OFFSCREEN_REDIRECT:
g_value_set_flags (value, priv->offscreen_redirect);
break;
case PROP_NAME:
g_value_set_string (value, priv->name);
break;
case PROP_VISIBLE:
g_value_set_boolean (value, CLUTTER_ACTOR_IS_VISIBLE (actor));
break;
case PROP_MAPPED:
g_value_set_boolean (value, CLUTTER_ACTOR_IS_MAPPED (actor));
break;
case PROP_REALIZED:
g_value_set_boolean (value, CLUTTER_ACTOR_IS_REALIZED (actor));
break;
case PROP_HAS_CLIP:
g_value_set_boolean (value, priv->has_clip);
break;
case PROP_CLIP_RECT:
g_value_set_boxed (value, &priv->clip);
break;
case PROP_CLIP_TO_ALLOCATION:
g_value_set_boolean (value, priv->clip_to_allocation);
break;
case PROP_PIVOT_POINT:
{
const ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info_or_defaults (actor);
g_value_set_boxed (value, &info->pivot);
}
break;
case PROP_PIVOT_POINT_Z:
{
const ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info_or_defaults (actor);
g_value_set_float (value, info->pivot_z);
}
break;
case PROP_TRANSLATION_X:
{
const ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info_or_defaults (actor);
g_value_set_float (value, info->translation.x);
}
break;
case PROP_TRANSLATION_Y:
{
const ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info_or_defaults (actor);
g_value_set_float (value, info->translation.y);
}
break;
case PROP_TRANSLATION_Z:
{
const ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info_or_defaults (actor);
g_value_set_float (value, info->translation.z);
}
break;
case PROP_SCALE_X:
{
const ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info_or_defaults (actor);
g_value_set_double (value, info->scale_x);
}
break;
case PROP_SCALE_Y:
{
const ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info_or_defaults (actor);
g_value_set_double (value, info->scale_y);
}
break;
case PROP_SCALE_Z:
{
const ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info_or_defaults (actor);
g_value_set_double (value, info->scale_z);
}
break;
case PROP_SCALE_CENTER_X: /* XXX:2.0 - remove */
{
gfloat center;
clutter_actor_get_scale_center (actor, ¢er, NULL);
g_value_set_float (value, center);
}
break;
case PROP_SCALE_CENTER_Y: /* XXX:2.0 - remove */
{
gfloat center;
clutter_actor_get_scale_center (actor, NULL, ¢er);
g_value_set_float (value, center);
}
break;
case PROP_SCALE_GRAVITY: /* XXX:2.0 - remove */
g_value_set_enum (value, clutter_actor_get_scale_gravity (actor));
break;
case PROP_RESOURCE_SCALE:
if (priv->needs_compute_resource_scale)
{
if (!clutter_actor_update_resource_scale (actor))
g_warning ("Getting invalid resource scale property");
}
g_value_set_float (value, priv->resource_scale);
break;
case PROP_REACTIVE:
g_value_set_boolean (value, clutter_actor_get_reactive (actor));
break;
case PROP_ROTATION_ANGLE_X:
{
const ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info_or_defaults (actor);
g_value_set_double (value, info->rx_angle);
}
break;
case PROP_ROTATION_ANGLE_Y:
{
const ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info_or_defaults (actor);
g_value_set_double (value, info->ry_angle);
}
break;
case PROP_ROTATION_ANGLE_Z:
{
const ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info_or_defaults (actor);
g_value_set_double (value, info->rz_angle);
}
break;
case PROP_ROTATION_CENTER_X: /* XXX:2.0 - remove */
{
graphene_point3d_t center;
clutter_actor_get_rotation (actor, CLUTTER_X_AXIS,
¢er.x,
¢er.y,
¢er.z);
g_value_set_boxed (value, ¢er);
}
break;
case PROP_ROTATION_CENTER_Y: /* XXX:2.0 - remove */
{
graphene_point3d_t center;
clutter_actor_get_rotation (actor, CLUTTER_Y_AXIS,
¢er.x,
¢er.y,
¢er.z);
g_value_set_boxed (value, ¢er);
}
break;
case PROP_ROTATION_CENTER_Z: /* XXX:2.0 - remove */
{
graphene_point3d_t center;
clutter_actor_get_rotation (actor, CLUTTER_Z_AXIS,
¢er.x,
¢er.y,
¢er.z);
g_value_set_boxed (value, ¢er);
}
break;
case PROP_ROTATION_CENTER_Z_GRAVITY: /* XXX:2.0 - remove */
g_value_set_enum (value, clutter_actor_get_z_rotation_gravity (actor));
break;
case PROP_ANCHOR_X: /* XXX:2.0 - remove */
{
const ClutterTransformInfo *info;
gfloat anchor_x;
info = _clutter_actor_get_transform_info_or_defaults (actor);
clutter_anchor_coord_get_units (actor, &info->anchor,
&anchor_x,
NULL,
NULL);
g_value_set_float (value, anchor_x);
}
break;
case PROP_ANCHOR_Y: /* XXX:2.0 - remove */
{
const ClutterTransformInfo *info;
gfloat anchor_y;
info = _clutter_actor_get_transform_info_or_defaults (actor);
clutter_anchor_coord_get_units (actor, &info->anchor,
NULL,
&anchor_y,
NULL);
g_value_set_float (value, anchor_y);
}
break;
case PROP_ANCHOR_GRAVITY: /* XXX:2.0 - remove */
g_value_set_enum (value, clutter_actor_get_anchor_point_gravity (actor));
break;
case PROP_TRANSFORM:
{
ClutterMatrix m;
clutter_actor_get_transform (actor, &m);
g_value_set_boxed (value, &m);
}
break;
case PROP_TRANSFORM_SET:
{
const ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info_or_defaults (actor);
g_value_set_boolean (value, info->transform_set);
}
break;
case PROP_CHILD_TRANSFORM:
{
ClutterMatrix m;
clutter_actor_get_child_transform (actor, &m);
g_value_set_boxed (value, &m);
}
break;
case PROP_CHILD_TRANSFORM_SET:
{
const ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info_or_defaults (actor);
g_value_set_boolean (value, info->child_transform_set);
}
break;
case PROP_SHOW_ON_SET_PARENT: /* XXX:2.0 - remove */
g_value_set_boolean (value, priv->show_on_set_parent);
break;
case PROP_TEXT_DIRECTION:
g_value_set_enum (value, priv->text_direction);
break;
case PROP_HAS_POINTER:
g_value_set_boolean (value, priv->has_pointer);
break;
case PROP_LAYOUT_MANAGER:
g_value_set_object (value, priv->layout_manager);
break;
case PROP_X_EXPAND:
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (actor);
g_value_set_boolean (value, info->x_expand);
}
break;
case PROP_Y_EXPAND:
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (actor);
g_value_set_boolean (value, info->y_expand);
}
break;
case PROP_X_ALIGN:
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (actor);
g_value_set_enum (value, info->x_align);
}
break;
case PROP_Y_ALIGN:
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (actor);
g_value_set_enum (value, info->y_align);
}
break;
case PROP_MARGIN_TOP:
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (actor);
g_value_set_float (value, info->margin.top);
}
break;
case PROP_MARGIN_BOTTOM:
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (actor);
g_value_set_float (value, info->margin.bottom);
}
break;
case PROP_MARGIN_LEFT:
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (actor);
g_value_set_float (value, info->margin.left);
}
break;
case PROP_MARGIN_RIGHT:
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (actor);
g_value_set_float (value, info->margin.right);
}
break;
case PROP_BACKGROUND_COLOR_SET:
g_value_set_boolean (value, priv->bg_color_set);
break;
case PROP_BACKGROUND_COLOR:
g_value_set_boxed (value, &priv->bg_color);
break;
case PROP_FIRST_CHILD:
g_value_set_object (value, priv->first_child);
break;
case PROP_LAST_CHILD:
g_value_set_object (value, priv->last_child);
break;
case PROP_CONTENT:
g_value_set_object (value, priv->content);
break;
case PROP_CONTENT_GRAVITY:
g_value_set_enum (value, priv->content_gravity);
break;
case PROP_CONTENT_BOX:
{
ClutterActorBox box = { 0, };
clutter_actor_get_content_box (actor, &box);
g_value_set_boxed (value, &box);
}
break;
case PROP_MINIFICATION_FILTER:
g_value_set_enum (value, priv->min_filter);
break;
case PROP_MAGNIFICATION_FILTER:
g_value_set_enum (value, priv->mag_filter);
break;
case PROP_CONTENT_REPEAT:
g_value_set_flags (value, priv->content_repeat);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
clutter_actor_dispose (GObject *object)
{
ClutterActor *self = CLUTTER_ACTOR (object);
ClutterActorPrivate *priv = self->priv;
ClutterBackend *backend = clutter_get_default_backend ();
CLUTTER_NOTE (MISC, "Dispose actor (name='%s', ref_count:%d) of type '%s'",
_clutter_actor_get_debug_name (self),
object->ref_count,
g_type_name (G_OBJECT_TYPE (self)));
maybe_unset_key_focus (self);
/* Stop the emission of any property change */
g_object_freeze_notify (object);
g_signal_emit (self, actor_signals[DESTROY], 0);
/* avoid recursing when called from clutter_actor_destroy() */
if (priv->parent != NULL)
{
ClutterActor *parent = priv->parent;
clutter_container_remove_actor (CLUTTER_CONTAINER (parent), self);
}
/* parent must be gone at this point */
g_assert (priv->parent == NULL);
if (!CLUTTER_ACTOR_IS_TOPLEVEL (self))
{
/* can't be mapped or realized with no parent */
g_assert (!CLUTTER_ACTOR_IS_MAPPED (self));
g_assert (!CLUTTER_ACTOR_IS_REALIZED (self));
}
g_clear_signal_handler (&priv->resolution_changed_id, backend);
g_clear_signal_handler (&priv->font_changed_id, backend);
g_clear_object (&priv->pango_context);
g_clear_object (&priv->actions);
g_clear_object (&priv->constraints);
g_clear_object (&priv->effects);
g_clear_object (&priv->flatten_effect);
if (priv->child_model != NULL)
{
if (priv->create_child_notify != NULL)
priv->create_child_notify (priv->create_child_data);
priv->create_child_func = NULL;
priv->create_child_data = NULL;
priv->create_child_notify = NULL;
g_clear_object (&priv->child_model);
}
if (priv->layout_manager != NULL)
{
clutter_layout_manager_set_container (priv->layout_manager, NULL);
g_clear_object (&priv->layout_manager);
}
if (priv->content != NULL)
{
_clutter_content_detached (priv->content, self);
g_clear_object (&priv->content);
}
if (priv->clones != NULL)
{
g_hash_table_unref (priv->clones);
priv->clones = NULL;
}
G_OBJECT_CLASS (clutter_actor_parent_class)->dispose (object);
}
static void
clutter_actor_finalize (GObject *object)
{
ClutterActorPrivate *priv = CLUTTER_ACTOR (object)->priv;
CLUTTER_NOTE (MISC, "Finalize actor (name='%s') of type '%s'",
_clutter_actor_get_debug_name ((ClutterActor *) object),
g_type_name (G_OBJECT_TYPE (object)));
g_free (priv->name);
#ifdef CLUTTER_ENABLE_DEBUG
g_free (priv->debug_name);
#endif
G_OBJECT_CLASS (clutter_actor_parent_class)->finalize (object);
}
/**
* clutter_actor_get_accessible:
* @self: a #ClutterActor
*
* Returns the accessible object that describes the actor to an
* assistive technology.
*
* If no class-specific #AtkObject implementation is available for the
* actor instance in question, it will inherit an #AtkObject
* implementation from the first ancestor class for which such an
* implementation is defined.
*
* The documentation of the ATK
* library contains more information about accessible objects and
* their uses.
*
* Returns: (transfer none): the #AtkObject associated with @actor
*/
AtkObject *
clutter_actor_get_accessible (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
return CLUTTER_ACTOR_GET_CLASS (self)->get_accessible (self);
}
static AtkObject *
clutter_actor_real_get_accessible (ClutterActor *actor)
{
return atk_gobject_accessible_for_object (G_OBJECT (actor));
}
static AtkObject *
_clutter_actor_ref_accessible (AtkImplementor *implementor)
{
AtkObject *accessible;
accessible = clutter_actor_get_accessible (CLUTTER_ACTOR (implementor));
if (accessible != NULL)
g_object_ref (accessible);
return accessible;
}
static void
atk_implementor_iface_init (AtkImplementorIface *iface)
{
iface->ref_accessible = _clutter_actor_ref_accessible;
}
static gboolean
clutter_actor_update_default_paint_volume (ClutterActor *self,
ClutterPaintVolume *volume)
{
ClutterActorPrivate *priv = self->priv;
gboolean res = TRUE;
/* this should be checked before we call this function, but it's a
* good idea to be explicit when it costs us nothing
*/
if (priv->needs_allocation)
return FALSE;
/* we start from the allocation */
clutter_paint_volume_set_width (volume,
priv->allocation.x2 - priv->allocation.x1);
clutter_paint_volume_set_height (volume,
priv->allocation.y2 - priv->allocation.y1);
/* if the actor has a clip set then we have a pretty definite
* size for the paint volume: the actor cannot possibly paint
* outside the clip region.
*/
if (priv->clip_to_allocation)
{
/* the allocation has already been set, so we just flip the
* return value
*/
res = TRUE;
}
else
{
ClutterActor *child;
if (priv->has_clip &&
priv->clip.size.width >= 0 &&
priv->clip.size.height >= 0)
{
graphene_point3d_t origin;
origin.x = priv->clip.origin.x;
origin.y = priv->clip.origin.y;
origin.z = 0;
clutter_paint_volume_set_origin (volume, &origin);
clutter_paint_volume_set_width (volume, priv->clip.size.width);
clutter_paint_volume_set_height (volume, priv->clip.size.height);
res = TRUE;
}
/* if we don't have children we just bail out here... */
if (priv->n_children == 0)
return res;
/* ...but if we have children then we ask for their paint volume in
* our coordinates. if any of our children replies that it doesn't
* have a paint volume, we bail out
*/
for (child = priv->first_child;
child != NULL;
child = child->priv->next_sibling)
{
const ClutterPaintVolume *child_volume;
/* we ignore unmapped children, since they won't be painted.
*
* XXX: we also have to ignore mapped children without a valid
* allocation, because apparently some code above Clutter allows
* them.
*/
if (!CLUTTER_ACTOR_IS_MAPPED (child) || !clutter_actor_has_allocation (child))
continue;
child_volume = clutter_actor_get_transformed_paint_volume (child, self);
if (child_volume == NULL)
{
res = FALSE;
break;
}
clutter_paint_volume_union (volume, child_volume);
res = TRUE;
}
}
return res;
}
static gboolean
clutter_actor_real_get_paint_volume (ClutterActor *self,
ClutterPaintVolume *volume)
{
ClutterActorClass *klass;
gboolean res;
klass = CLUTTER_ACTOR_GET_CLASS (self);
/* XXX - this thoroughly sucks, but we don't want to penalize users
* who use ClutterActor as a "new ClutterGroup" by forcing a full-stage
* redraw. This should go away in 2.0.
*/
if (klass->paint == clutter_actor_real_paint &&
klass->get_paint_volume == clutter_actor_real_get_paint_volume)
{
res = TRUE;
}
else
{
/* this is the default return value: we cannot know if a class
* is going to paint outside its allocation, so we take the
* conservative approach.
*/
res = FALSE;
}
/* update_default_paint_volume() should only fail if one of the children
* reported an invalid, or no, paint volume
*/
if (!clutter_actor_update_default_paint_volume (self, volume))
return FALSE;
return res;
}
/**
* clutter_actor_get_default_paint_volume:
* @self: a #ClutterActor
*
* Retrieves the default paint volume for @self.
*
* This function provides the same #ClutterPaintVolume that would be
* computed by the default implementation inside #ClutterActor of the
* #ClutterActorClass.get_paint_volume() virtual function.
*
* This function should only be used by #ClutterActor subclasses that
* cannot chain up to the parent implementation when computing their
* paint volume.
*
* Return value: (transfer none): a pointer to the default
* #ClutterPaintVolume, relative to the #ClutterActor, or %NULL if
* the actor could not compute a valid paint volume. The returned value
* is not guaranteed to be stable across multiple frames, so if you
* want to retain it, you will need to copy it using
* clutter_paint_volume_copy().
*
* Since: 1.10
*/
const ClutterPaintVolume *
clutter_actor_get_default_paint_volume (ClutterActor *self)
{
ClutterPaintVolume volume;
ClutterPaintVolume *res;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
res = NULL;
_clutter_paint_volume_init_static (&volume, self);
if (clutter_actor_update_default_paint_volume (self, &volume))
{
ClutterActor *stage = _clutter_actor_get_stage_internal (self);
if (stage != NULL)
{
res = _clutter_stage_paint_volume_stack_allocate (CLUTTER_STAGE (stage));
_clutter_paint_volume_copy_static (&volume, res);
}
}
clutter_paint_volume_free (&volume);
return res;
}
static gboolean
clutter_actor_real_has_overlaps (ClutterActor *self)
{
/* By default we'll assume that all actors need an offscreen redirect to get
* the correct opacity. Actors such as ClutterTexture that would never need
* an offscreen redirect can override this to return FALSE. */
return TRUE;
}
static void
clutter_actor_real_destroy (ClutterActor *actor)
{
ClutterActorIter iter;
g_object_freeze_notify (G_OBJECT (actor));
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, NULL))
clutter_actor_iter_destroy (&iter);
g_object_thaw_notify (G_OBJECT (actor));
}
static GObject *
clutter_actor_constructor (GType gtype,
guint n_props,
GObjectConstructParam *props)
{
GObjectClass *gobject_class;
ClutterActor *self;
GObject *retval;
gobject_class = G_OBJECT_CLASS (clutter_actor_parent_class);
retval = gobject_class->constructor (gtype, n_props, props);
self = CLUTTER_ACTOR (retval);
if (self->priv->layout_manager == NULL)
{
ClutterLayoutManager *default_layout;
CLUTTER_NOTE (LAYOUT, "Creating default layout manager");
default_layout = clutter_fixed_layout_new ();
clutter_actor_set_layout_manager (self, default_layout);
}
return retval;
}
static void
clutter_actor_class_init (ClutterActorClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
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");
quark_key = g_quark_from_static_string ("key");
quark_motion = g_quark_from_static_string ("motion");
quark_pointer_focus = g_quark_from_static_string ("pointer-focus");
quark_button = g_quark_from_static_string ("button");
quark_scroll = g_quark_from_static_string ("scroll");
quark_stage = g_quark_from_static_string ("stage");
quark_destroy = g_quark_from_static_string ("destroy");
quark_client = g_quark_from_static_string ("client");
quark_delete = g_quark_from_static_string ("delete");
quark_touch = g_quark_from_static_string ("touch");
quark_touchpad = g_quark_from_static_string ("touchpad");
quark_proximity = g_quark_from_static_string ("proximity");
quark_pad = g_quark_from_static_string ("pad");
quark_im = g_quark_from_static_string ("im");
object_class->constructor = clutter_actor_constructor;
object_class->set_property = clutter_actor_set_property;
object_class->get_property = clutter_actor_get_property;
object_class->dispose = clutter_actor_dispose;
object_class->finalize = clutter_actor_finalize;
klass->show = clutter_actor_real_show;
klass->show_all = clutter_actor_show;
klass->hide = clutter_actor_real_hide;
klass->hide_all = clutter_actor_hide;
klass->map = clutter_actor_real_map;
klass->unmap = clutter_actor_real_unmap;
klass->unrealize = clutter_actor_real_unrealize;
klass->pick = clutter_actor_real_pick;
klass->get_preferred_width = clutter_actor_real_get_preferred_width;
klass->get_preferred_height = clutter_actor_real_get_preferred_height;
klass->allocate = clutter_actor_real_allocate;
klass->queue_redraw = clutter_actor_real_queue_redraw;
klass->queue_relayout = clutter_actor_real_queue_relayout;
klass->apply_transform = clutter_actor_real_apply_transform;
klass->get_accessible = clutter_actor_real_get_accessible;
klass->get_paint_volume = clutter_actor_real_get_paint_volume;
klass->has_overlaps = clutter_actor_real_has_overlaps;
klass->paint = clutter_actor_real_paint;
klass->destroy = clutter_actor_real_destroy;
/**
* ClutterActor:x:
*
* X coordinate of the actor in pixels. If written, forces a fixed
* position for the actor. If read, returns the fixed position if any,
* otherwise the allocation if available, otherwise 0.
*
* The #ClutterActor:x property is animatable.
*/
obj_props[PROP_X] =
g_param_spec_float ("x",
P_("X coordinate"),
P_("X coordinate of the actor"),
-G_MAXFLOAT, G_MAXFLOAT,
0.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:y:
*
* Y coordinate of the actor in pixels. If written, forces a fixed
* position for the actor. If read, returns the fixed position if
* any, otherwise the allocation if available, otherwise 0.
*
* The #ClutterActor:y property is animatable.
*/
obj_props[PROP_Y] =
g_param_spec_float ("y",
P_("Y coordinate"),
P_("Y coordinate of the actor"),
-G_MAXFLOAT, G_MAXFLOAT,
0.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:position:
*
* The position of the origin of the actor.
*
* This property is a shorthand for setting and getting the
* #ClutterActor:x and #ClutterActor:y properties at the same
* time.
*
* The #ClutterActor:position property is animatable.
*
* Since: 1.12
*/
obj_props[PROP_POSITION] =
g_param_spec_boxed ("position",
P_("Position"),
P_("The position of the origin of the actor"),
GRAPHENE_TYPE_POINT,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:width:
*
* Width of the actor (in pixels). If written, forces the minimum and
* natural size request of the actor to the given width. If read, returns
* the allocated width if available, otherwise the width request.
*
* The #ClutterActor:width property is animatable.
*/
obj_props[PROP_WIDTH] =
g_param_spec_float ("width",
P_("Width"),
P_("Width of the actor"),
-1.0f, G_MAXFLOAT,
0.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:height:
*
* Height of the actor (in pixels). If written, forces the minimum and
* natural size request of the actor to the given height. If read, returns
* the allocated height if available, otherwise the height request.
*
* The #ClutterActor:height property is animatable.
*/
obj_props[PROP_HEIGHT] =
g_param_spec_float ("height",
P_("Height"),
P_("Height of the actor"),
-1.0f, G_MAXFLOAT,
0.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:size:
*
* The size of the actor.
*
* This property is a shorthand for setting and getting the
* #ClutterActor:width and #ClutterActor:height at the same time.
*
* The #ClutterActor:size property is animatable.
*
* Since: 1.12
*/
obj_props[PROP_SIZE] =
g_param_spec_boxed ("size",
P_("Size"),
P_("The size of the actor"),
GRAPHENE_TYPE_SIZE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:fixed-x:
*
* The fixed X position of the actor in pixels.
*
* Writing this property sets #ClutterActor:fixed-position-set
* property as well, as a side effect
*
* Since: 0.8
*/
obj_props[PROP_FIXED_X] =
g_param_spec_float ("fixed-x",
P_("Fixed X"),
P_("Forced X position of the actor"),
-G_MAXFLOAT, G_MAXFLOAT,
0.0,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:fixed-y:
*
* The fixed Y position of the actor in pixels.
*
* Writing this property sets the #ClutterActor:fixed-position-set
* property as well, as a side effect
*
* Since: 0.8
*/
obj_props[PROP_FIXED_Y] =
g_param_spec_float ("fixed-y",
P_("Fixed Y"),
P_("Forced Y position of the actor"),
-G_MAXFLOAT, G_MAXFLOAT,
0,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:fixed-position-set:
*
* This flag controls whether the #ClutterActor:fixed-x and
* #ClutterActor:fixed-y properties are used
*
* Since: 0.8
*/
obj_props[PROP_FIXED_POSITION_SET] =
g_param_spec_boolean ("fixed-position-set",
P_("Fixed position set"),
P_("Whether to use fixed positioning for the actor"),
FALSE,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:min-width:
*
* A forced minimum width request for the actor, in pixels
*
* Writing this property sets the #ClutterActor:min-width-set property
* as well, as a side effect.
*
*This property overrides the usual width request of the actor.
*
* Since: 0.8
*/
obj_props[PROP_MIN_WIDTH] =
g_param_spec_float ("min-width",
P_("Min Width"),
P_("Forced minimum width request for the actor"),
0.0, G_MAXFLOAT,
0.0,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:min-height:
*
* A forced minimum height request for the actor, in pixels
*
* Writing this property sets the #ClutterActor:min-height-set property
* as well, as a side effect. This property overrides the usual height
* request of the actor.
*
* Since: 0.8
*/
obj_props[PROP_MIN_HEIGHT] =
g_param_spec_float ("min-height",
P_("Min Height"),
P_("Forced minimum height request for the actor"),
0.0, G_MAXFLOAT,
0.0,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:natural-width:
*
* A forced natural width request for the actor, in pixels
*
* Writing this property sets the #ClutterActor:natural-width-set
* property as well, as a side effect. This property overrides the
* usual width request of the actor
*
* Since: 0.8
*/
obj_props[PROP_NATURAL_WIDTH] =
g_param_spec_float ("natural-width",
P_("Natural Width"),
P_("Forced natural width request for the actor"),
0.0, G_MAXFLOAT,
0.0,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:natural-height:
*
* A forced natural height request for the actor, in pixels
*
* Writing this property sets the #ClutterActor:natural-height-set
* property as well, as a side effect. This property overrides the
* usual height request of the actor
*
* Since: 0.8
*/
obj_props[PROP_NATURAL_HEIGHT] =
g_param_spec_float ("natural-height",
P_("Natural Height"),
P_("Forced natural height request for the actor"),
0.0, G_MAXFLOAT,
0.0,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:min-width-set:
*
* This flag controls whether the #ClutterActor:min-width property
* is used
*
* Since: 0.8
*/
obj_props[PROP_MIN_WIDTH_SET] =
g_param_spec_boolean ("min-width-set",
P_("Minimum width set"),
P_("Whether to use the min-width property"),
FALSE,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:min-height-set:
*
* This flag controls whether the #ClutterActor:min-height property
* is used
*
* Since: 0.8
*/
obj_props[PROP_MIN_HEIGHT_SET] =
g_param_spec_boolean ("min-height-set",
P_("Minimum height set"),
P_("Whether to use the min-height property"),
FALSE,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:natural-width-set:
*
* This flag controls whether the #ClutterActor:natural-width property
* is used
*
* Since: 0.8
*/
obj_props[PROP_NATURAL_WIDTH_SET] =
g_param_spec_boolean ("natural-width-set",
P_("Natural width set"),
P_("Whether to use the natural-width property"),
FALSE,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:natural-height-set:
*
* This flag controls whether the #ClutterActor:natural-height property
* is used
*
* Since: 0.8
*/
obj_props[PROP_NATURAL_HEIGHT_SET] =
g_param_spec_boolean ("natural-height-set",
P_("Natural height set"),
P_("Whether to use the natural-height property"),
FALSE,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:allocation:
*
* The allocation for the actor, in pixels
*
* This is property is read-only, but you might monitor it to know when an
* actor moves or resizes
*
* Since: 0.8
*/
obj_props[PROP_ALLOCATION] =
g_param_spec_boxed ("allocation",
P_("Allocation"),
P_("The actor's allocation"),
CLUTTER_TYPE_ACTOR_BOX,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:request-mode:
*
* Request mode for the #ClutterActor. The request mode determines the
* type of geometry management used by the actor, either height for width
* (the default) or width for height.
*
* For actors implementing height for width, the parent container should get
* the preferred width first, and then the preferred height for that width.
*
* For actors implementing width for height, the parent container should get
* the preferred height first, and then the preferred width for that height.
*
* For instance:
*
* |[
* ClutterRequestMode mode;
* gfloat natural_width, min_width;
* gfloat natural_height, min_height;
*
* mode = clutter_actor_get_request_mode (child);
* if (mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
* {
* clutter_actor_get_preferred_width (child, -1,
* &min_width,
* &natural_width);
* clutter_actor_get_preferred_height (child, natural_width,
* &min_height,
* &natural_height);
* }
* else if (mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT)
* {
* clutter_actor_get_preferred_height (child, -1,
* &min_height,
* &natural_height);
* clutter_actor_get_preferred_width (child, natural_height,
* &min_width,
* &natural_width);
* }
* else if (mode == CLUTTER_REQUEST_CONTENT_SIZE)
* {
* ClutterContent *content = clutter_actor_get_content (child);
*
* min_width, min_height = 0;
* natural_width = natural_height = 0;
*
* if (content != NULL)
* clutter_content_get_preferred_size (content, &natural_width, &natural_height);
* }
* ]|
*
* will retrieve the minimum and natural width and height depending on the
* preferred request mode of the #ClutterActor "child".
*
* The clutter_actor_get_preferred_size() function will implement this
* check for you.
*
* Since: 0.8
*/
obj_props[PROP_REQUEST_MODE] =
g_param_spec_enum ("request-mode",
P_("Request Mode"),
P_("The actor's request mode"),
CLUTTER_TYPE_REQUEST_MODE,
CLUTTER_REQUEST_HEIGHT_FOR_WIDTH,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:depth:
*
* The position of the actor on the Z axis.
*
* The #ClutterActor:depth property is relative to the parent's
* modelview matrix.
*
* Setting this property will call #ClutterContainerIface.sort_depth_order()
* which is usually a no-op, and it's most likely not what you want.
*
* The #ClutterActor:depth property is animatable.
*
* Since: 0.6
*
* Deprecated: 1.12: Use #ClutterActor:z-position instead.
*/
obj_props[PROP_DEPTH] =
g_param_spec_float ("depth",
P_("Depth"),
P_("Position on the Z axis"),
-G_MAXFLOAT, G_MAXFLOAT,
0.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
G_PARAM_DEPRECATED |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:z-position:
*
* The actor's position on the Z axis, relative to the parent's
* transformations.
*
* Positive values will bring the actor's position nearer to the user,
* whereas negative values will bring the actor's position farther from
* the user.
*
* The #ClutterActor:z-position does not affect the paint or allocation
* order.
*
* The #ClutterActor:z-position property is animatable.
*
* Since: 1.12
*/
obj_props[PROP_Z_POSITION] =
g_param_spec_float ("z-position",
P_("Z Position"),
P_("The actor's position on the Z axis"),
-G_MAXFLOAT, G_MAXFLOAT,
0.0f,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:opacity:
*
* Opacity of an actor, between 0 (fully transparent) and
* 255 (fully opaque)
*
* The #ClutterActor:opacity property is animatable.
*/
obj_props[PROP_OPACITY] =
g_param_spec_uint ("opacity",
P_("Opacity"),
P_("Opacity of an actor"),
0, 255,
255,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:offscreen-redirect:
*
* Determines the conditions in which the actor will be redirected
* to an offscreen framebuffer while being painted. For example this
* can be used to cache an actor in a framebuffer or for improved
* handling of transparent actors. See
* clutter_actor_set_offscreen_redirect() for details.
*
* Since: 1.8
*/
obj_props[PROP_OFFSCREEN_REDIRECT] =
g_param_spec_flags ("offscreen-redirect",
P_("Offscreen redirect"),
P_("Flags controlling when to flatten the actor into a single image"),
CLUTTER_TYPE_OFFSCREEN_REDIRECT,
0,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:visible:
*
* Whether the actor is set to be visible or not
*
* See also #ClutterActor:mapped
*/
obj_props[PROP_VISIBLE] =
g_param_spec_boolean ("visible",
P_("Visible"),
P_("Whether the actor is visible or not"),
FALSE,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:mapped:
*
* Whether the actor is mapped (will be painted when the stage
* to which it belongs is mapped)
*
* Since: 1.0
*/
obj_props[PROP_MAPPED] =
g_param_spec_boolean ("mapped",
P_("Mapped"),
P_("Whether the actor will be painted"),
FALSE,
CLUTTER_PARAM_READABLE);
/**
* ClutterActor:realized:
*
* Whether the actor has been realized
*
* Since: 1.0
*/
obj_props[PROP_REALIZED] =
g_param_spec_boolean ("realized",
P_("Realized"),
P_("Whether the actor has been realized"),
FALSE,
CLUTTER_PARAM_READABLE);
/**
* ClutterActor:reactive:
*
* Whether the actor is reactive to events or not
*
* Only reactive actors will emit event-related signals
*
* Since: 0.6
*/
obj_props[PROP_REACTIVE] =
g_param_spec_boolean ("reactive",
P_("Reactive"),
P_("Whether the actor is reactive to events"),
FALSE,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:has-clip:
*
* Whether the actor has the #ClutterActor:clip property set or not
*/
obj_props[PROP_HAS_CLIP] =
g_param_spec_boolean ("has-clip",
P_("Has Clip"),
P_("Whether the actor has a clip set"),
FALSE,
CLUTTER_PARAM_READABLE);
/**
* ClutterActor:clip-rect:
*
* The visible region of the actor, in actor-relative coordinates,
* expressed as a #graphene_rect_t.
*
* Setting this property to %NULL will unset the existing clip.
*
* Setting this property will change the #ClutterActor:has-clip
* property as a side effect.
*
* Since: 1.12
*/
obj_props[PROP_CLIP_RECT] =
g_param_spec_boxed ("clip-rect",
P_("Clip Rectangle"),
P_("The visible region of the actor"),
GRAPHENE_TYPE_RECT,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
/**
* ClutterActor:name:
*
* The name of the actor
*
* Since: 0.2
*/
obj_props[PROP_NAME] =
g_param_spec_string ("name",
P_("Name"),
P_("Name of the actor"),
NULL,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:pivot-point:
*
* The point around which the scaling and rotation transformations occur.
*
* The pivot point is expressed in normalized coordinates space, with (0, 0)
* being the top left corner of the actor and (1, 1) the bottom right corner
* of the actor.
*
* The default pivot point is located at (0, 0).
*
* The #ClutterActor:pivot-point property is animatable.
*
* Since: 1.12
*/
obj_props[PROP_PIVOT_POINT] =
g_param_spec_boxed ("pivot-point",
P_("Pivot Point"),
P_("The point around which the scaling and rotation occur"),
GRAPHENE_TYPE_POINT,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:pivot-point-z:
*
* The Z component of the #ClutterActor:pivot-point, expressed as a value
* along the Z axis.
*
* The #ClutterActor:pivot-point-z property is animatable.
*
* Since: 1.12
*/
obj_props[PROP_PIVOT_POINT_Z] =
g_param_spec_float ("pivot-point-z",
P_("Pivot Point Z"),
P_("Z component of the pivot point"),
-G_MAXFLOAT, G_MAXFLOAT,
0.f,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:scale-x:
*
* The horizontal scale of the actor.
*
* The #ClutterActor:scale-x property is animatable.
*
* Since: 0.6
*/
obj_props[PROP_SCALE_X] =
g_param_spec_double ("scale-x",
P_("Scale X"),
P_("Scale factor on the X axis"),
-G_MAXDOUBLE, G_MAXDOUBLE,
1.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:scale-y:
*
* The vertical scale of the actor.
*
* The #ClutterActor:scale-y property is animatable.
*
* Since: 0.6
*/
obj_props[PROP_SCALE_Y] =
g_param_spec_double ("scale-y",
P_("Scale Y"),
P_("Scale factor on the Y axis"),
-G_MAXDOUBLE, G_MAXDOUBLE,
1.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:scale-z:
*
* The scale factor of the actor along the Z axis.
*
* The #ClutterActor:scale-y property is animatable.
*
* Since: 1.12
*/
obj_props[PROP_SCALE_Z] =
g_param_spec_double ("scale-z",
P_("Scale Z"),
P_("Scale factor on the Z axis"),
-G_MAXDOUBLE, G_MAXDOUBLE,
1.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:scale-center-x:
*
* The horizontal center point for scaling
*
* Since: 1.0
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point instead
*/
obj_props[PROP_SCALE_CENTER_X] = /* XXX:2.0 - remove */
g_param_spec_float ("scale-center-x",
P_("Scale Center X"),
P_("Horizontal scale center"),
-G_MAXFLOAT, G_MAXFLOAT,
0.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
G_PARAM_DEPRECATED);
/**
* ClutterActor:scale-center-y:
*
* The vertical center point for scaling
*
* Since: 1.0
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point instead
*/
obj_props[PROP_SCALE_CENTER_Y] = /* XXX:2.0 - remove */
g_param_spec_float ("scale-center-y",
P_("Scale Center Y"),
P_("Vertical scale center"),
-G_MAXFLOAT, G_MAXFLOAT,
0.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
G_PARAM_DEPRECATED);
/**
* ClutterActor:scale-gravity:
*
* The center point for scaling expressed as a #ClutterGravity
*
* Since: 1.0
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point instead
*/
obj_props[PROP_SCALE_GRAVITY] = /* XXX:2.0 - remove */
g_param_spec_enum ("scale-gravity",
P_("Scale Gravity"),
P_("The center of scaling"),
CLUTTER_TYPE_GRAVITY,
CLUTTER_GRAVITY_NONE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
G_PARAM_DEPRECATED);
/**
* ClutterActor:resource-scale:
*
* The resource-scale of the #ClutterActor if any or -1 if not available
*/
obj_props[PROP_RESOURCE_SCALE] =
g_param_spec_float ("resource-scale",
P_("Resource Scale"),
P_("The Scaling factor for resources painting"),
-1.0f, G_MAXFLOAT,
1.0f,
CLUTTER_PARAM_READABLE);
/**
* ClutterActor:rotation-angle-x:
*
* The rotation angle on the X axis.
*
* The #ClutterActor:rotation-angle-x property is animatable.
*
* Since: 0.6
*/
obj_props[PROP_ROTATION_ANGLE_X] =
g_param_spec_double ("rotation-angle-x",
P_("Rotation Angle X"),
P_("The rotation angle on the X axis"),
-G_MAXDOUBLE, G_MAXDOUBLE,
0.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:rotation-angle-y:
*
* The rotation angle on the Y axis
*
* The #ClutterActor:rotation-angle-y property is animatable.
*
* Since: 0.6
*/
obj_props[PROP_ROTATION_ANGLE_Y] =
g_param_spec_double ("rotation-angle-y",
P_("Rotation Angle Y"),
P_("The rotation angle on the Y axis"),
-G_MAXDOUBLE, G_MAXDOUBLE,
0.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:rotation-angle-z:
*
* The rotation angle on the Z axis
*
* The #ClutterActor:rotation-angle-z property is animatable.
*
* Since: 0.6
*/
obj_props[PROP_ROTATION_ANGLE_Z] =
g_param_spec_double ("rotation-angle-z",
P_("Rotation Angle Z"),
P_("The rotation angle on the Z axis"),
-G_MAXDOUBLE, G_MAXDOUBLE,
0.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:rotation-center-x:
*
* The rotation center on the X axis.
*
* Since: 0.6
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point instead
*/
obj_props[PROP_ROTATION_CENTER_X] = /* XXX:2.0 - remove */
g_param_spec_boxed ("rotation-center-x",
P_("Rotation Center X"),
P_("The rotation center on the X axis"),
GRAPHENE_TYPE_POINT3D,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
G_PARAM_DEPRECATED);
/**
* ClutterActor:rotation-center-y:
*
* The rotation center on the Y axis.
*
* Since: 0.6
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point instead
*/
obj_props[PROP_ROTATION_CENTER_Y] = /* XXX:2.0 - remove */
g_param_spec_boxed ("rotation-center-y",
P_("Rotation Center Y"),
P_("The rotation center on the Y axis"),
GRAPHENE_TYPE_POINT3D,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
G_PARAM_DEPRECATED);
/**
* ClutterActor:rotation-center-z:
*
* The rotation center on the Z axis.
*
* Since: 0.6
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point instead
*/
obj_props[PROP_ROTATION_CENTER_Z] = /* XXX:2.0 - remove */
g_param_spec_boxed ("rotation-center-z",
P_("Rotation Center Z"),
P_("The rotation center on the Z axis"),
GRAPHENE_TYPE_POINT3D,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
G_PARAM_DEPRECATED);
/**
* ClutterActor:rotation-center-z-gravity:
*
* The rotation center on the Z axis expressed as a #ClutterGravity.
*
* Since: 1.0
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point instead
*/
obj_props[PROP_ROTATION_CENTER_Z_GRAVITY] = /* XXX:2.0 - remove */
g_param_spec_enum ("rotation-center-z-gravity",
P_("Rotation Center Z Gravity"),
P_("Center point for rotation around the Z axis"),
CLUTTER_TYPE_GRAVITY,
CLUTTER_GRAVITY_NONE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
G_PARAM_DEPRECATED);
/**
* ClutterActor:anchor-x:
*
* The X coordinate of an actor's anchor point, relative to
* the actor coordinate space, in pixels.
*
* It is highly recommended not to use #ClutterActor:anchor-x,
* #ClutterActor:anchor-y, and #ClutterActor:anchor-gravity in newly
* written code; the anchor point adds an additional translation that
* will affect the actor's relative position with regards to its
* parent, as well as the position of its children. This change needs
* to always be taken into account when positioning the actor. It is
* recommended to use the #ClutterActor:pivot-point property instead,
* as it will affect only the transformations.
*
* Since: 0.8
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point instead
*/
obj_props[PROP_ANCHOR_X] = /* XXX:2.0 - remove */
g_param_spec_float ("anchor-x",
P_("Anchor X"),
P_("X coordinate of the anchor point"),
-G_MAXFLOAT, G_MAXFLOAT,
0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
G_PARAM_DEPRECATED);
/**
* ClutterActor:anchor-y:
*
* The Y coordinate of an actor's anchor point, relative to
* the actor coordinate space, in pixels
*
* It is highly recommended not to use #ClutterActor:anchor-x,
* #ClutterActor:anchor-y, and #ClutterActor:anchor-gravity in newly
* written code; the anchor point adds an additional translation that
* will affect the actor's relative position with regards to its
* parent, as well as the position of its children. This change needs
* to always be taken into account when positioning the actor. It is
* recommended to use the #ClutterActor:pivot-point property instead,
* as it will affect only the transformations.
*
* Since: 0.8
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point instead
*/
obj_props[PROP_ANCHOR_Y] = /* XXX:2.0 - remove */
g_param_spec_float ("anchor-y",
P_("Anchor Y"),
P_("Y coordinate of the anchor point"),
-G_MAXFLOAT, G_MAXFLOAT,
0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
G_PARAM_DEPRECATED);
/**
* ClutterActor:anchor-gravity:
*
* The anchor point expressed as a #ClutterGravity
*
* It is highly recommended not to use #ClutterActor:anchor-x,
* #ClutterActor:anchor-y, and #ClutterActor:anchor-gravity in newly
* written code; the anchor point adds an additional translation that
* will affect the actor's relative position with regards to its
* parent, as well as the position of its children. This change needs
* to always be taken into account when positioning the actor. It is
* recommended to use the #ClutterActor:pivot-point property instead,
* as it will affect only the transformations.
*
* Since: 1.0
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point instead
*/
obj_props[PROP_ANCHOR_GRAVITY] = /* XXX:2.0 - remove */
g_param_spec_enum ("anchor-gravity",
P_("Anchor Gravity"),
P_("The anchor point as a ClutterGravity"),
CLUTTER_TYPE_GRAVITY,
CLUTTER_GRAVITY_NONE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
G_PARAM_DEPRECATED);
/**
* ClutterActor:translation-x:
*
* An additional translation applied along the X axis, relative
* to the actor's #ClutterActor:pivot-point.
*
* The #ClutterActor:translation-x property is animatable.
*
* Since: 1.12
*/
obj_props[PROP_TRANSLATION_X] =
g_param_spec_float ("translation-x",
P_("Translation X"),
P_("Translation along the X axis"),
-G_MAXFLOAT, G_MAXFLOAT,
0.f,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:translation-y:
*
* An additional translation applied along the Y axis, relative
* to the actor's #ClutterActor:pivot-point.
*
* The #ClutterActor:translation-y property is animatable.
*
* Since: 1.12
*/
obj_props[PROP_TRANSLATION_Y] =
g_param_spec_float ("translation-y",
P_("Translation Y"),
P_("Translation along the Y axis"),
-G_MAXFLOAT, G_MAXFLOAT,
0.f,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:translation-z:
*
* An additional translation applied along the Z axis, relative
* to the actor's #ClutterActor:pivot-point.
*
* The #ClutterActor:translation-z property is animatable.
*
* Since: 1.12
*/
obj_props[PROP_TRANSLATION_Z] =
g_param_spec_float ("translation-z",
P_("Translation Z"),
P_("Translation along the Z axis"),
-G_MAXFLOAT, G_MAXFLOAT,
0.f,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:transform:
*
* Overrides the transformations of a #ClutterActor with a custom
* matrix.
*
* The matrix specified by the #ClutterActor:transform property is
* applied to the actor and its children relative to the actor's
* #ClutterActor:allocation and #ClutterActor:pivot-point.
*
* Application code should rarely need to use this function directly.
*
* Setting this property with a #ClutterMatrix will set the
* #ClutterActor:transform-set property to %TRUE as a side effect;
* setting this property with %NULL will set the
* #ClutterActor:transform-set property to %FALSE.
*
* The #ClutterActor:transform property is animatable.
*
* Since: 1.12
*/
obj_props[PROP_TRANSFORM] =
g_param_spec_boxed ("transform",
P_("Transform"),
P_("Transformation matrix"),
CLUTTER_TYPE_MATRIX,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:transform-set:
*
* Whether the #ClutterActor:transform property is set.
*
* Since: 1.12
*/
obj_props[PROP_TRANSFORM_SET] =
g_param_spec_boolean ("transform-set",
P_("Transform Set"),
P_("Whether the transform property is set"),
FALSE,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS);
/**
* ClutterActor:child-transform:
*
* Applies a transformation matrix on each child of an actor.
*
* Setting this property with a #ClutterMatrix will set the
* #ClutterActor:child-transform-set property to %TRUE as a side effect;
* setting this property with %NULL will set the
* #ClutterActor:child-transform-set property to %FALSE.
*
* The #ClutterActor:child-transform property is animatable.
*
* Since: 1.12
*/
obj_props[PROP_CHILD_TRANSFORM] =
g_param_spec_boxed ("child-transform",
P_("Child Transform"),
P_("Children transformation matrix"),
CLUTTER_TYPE_MATRIX,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:child-transform-set:
*
* Whether the #ClutterActor:child-transform property is set.
*
* Since: 1.12
*/
obj_props[PROP_CHILD_TRANSFORM_SET] =
g_param_spec_boolean ("child-transform-set",
P_("Child Transform Set"),
P_("Whether the child-transform property is set"),
FALSE,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS);
/**
* ClutterActor:show-on-set-parent:
*
* If %TRUE, the actor is automatically shown when parented.
*
* Calling clutter_actor_hide() on an actor which has not been
* parented will set this property to %FALSE as a side effect.
*
* Since: 0.8
*/
obj_props[PROP_SHOW_ON_SET_PARENT] = /* XXX:2.0 - remove */
g_param_spec_boolean ("show-on-set-parent",
P_("Show on set parent"),
P_("Whether the actor is shown when parented"),
TRUE,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:clip-to-allocation:
*
* Whether the clip region should track the allocated area
* of the actor.
*
* This property is ignored if a clip area has been explicitly
* set using clutter_actor_set_clip().
*
* Since: 1.0
*/
obj_props[PROP_CLIP_TO_ALLOCATION] =
g_param_spec_boolean ("clip-to-allocation",
P_("Clip to Allocation"),
P_("Sets the clip region to track the actor's allocation"),
FALSE,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:text-direction:
*
* The direction of the text inside a #ClutterActor.
*
* Since: 1.0
*/
obj_props[PROP_TEXT_DIRECTION] =
g_param_spec_enum ("text-direction",
P_("Text Direction"),
P_("Direction of the text"),
CLUTTER_TYPE_TEXT_DIRECTION,
CLUTTER_TEXT_DIRECTION_LTR,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:has-pointer:
*
* Whether the actor contains the pointer of a #ClutterInputDevice
* or not.
*
* Since: 1.2
*/
obj_props[PROP_HAS_POINTER] =
g_param_spec_boolean ("has-pointer",
P_("Has Pointer"),
P_("Whether the actor contains the pointer of an input device"),
FALSE,
CLUTTER_PARAM_READABLE);
/**
* ClutterActor:actions:
*
* Adds a #ClutterAction to the actor
*
* Since: 1.4
*/
obj_props[PROP_ACTIONS] =
g_param_spec_object ("actions",
P_("Actions"),
P_("Adds an action to the actor"),
CLUTTER_TYPE_ACTION,
CLUTTER_PARAM_WRITABLE);
/**
* ClutterActor:constraints:
*
* Adds a #ClutterConstraint to the actor
*
* Since: 1.4
*/
obj_props[PROP_CONSTRAINTS] =
g_param_spec_object ("constraints",
P_("Constraints"),
P_("Adds a constraint to the actor"),
CLUTTER_TYPE_CONSTRAINT,
CLUTTER_PARAM_WRITABLE);
/**
* ClutterActor:effect:
*
* Adds #ClutterEffect to the list of effects be applied on a #ClutterActor
*
* Since: 1.4
*/
obj_props[PROP_EFFECT] =
g_param_spec_object ("effect",
P_("Effect"),
P_("Add an effect to be applied on the actor"),
CLUTTER_TYPE_EFFECT,
CLUTTER_PARAM_WRITABLE);
/**
* ClutterActor:layout-manager:
*
* A delegate object for controlling the layout of the children of
* an actor.
*
* Since: 1.10
*/
obj_props[PROP_LAYOUT_MANAGER] =
g_param_spec_object ("layout-manager",
P_("Layout Manager"),
P_("The object controlling the layout of an actor's children"),
CLUTTER_TYPE_LAYOUT_MANAGER,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:x-expand:
*
* Whether a layout manager should assign more space to the actor on
* the X axis.
*
* Since: 1.12
*/
obj_props[PROP_X_EXPAND] =
g_param_spec_boolean ("x-expand",
P_("X Expand"),
P_("Whether extra horizontal space should be assigned to the actor"),
FALSE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
/**
* ClutterActor:y-expand:
*
* Whether a layout manager should assign more space to the actor on
* the Y axis.
*
* Since: 1.12
*/
obj_props[PROP_Y_EXPAND] =
g_param_spec_boolean ("y-expand",
P_("Y Expand"),
P_("Whether extra vertical space should be assigned to the actor"),
FALSE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
/**
* ClutterActor:x-align:
*
* The alignment of an actor on the X axis, if the actor has been given
* extra space for its allocation. See also the #ClutterActor:x-expand
* property.
*
* Since: 1.10
*/
obj_props[PROP_X_ALIGN] =
g_param_spec_enum ("x-align",
P_("X Alignment"),
P_("The alignment of the actor on the X axis within its allocation"),
CLUTTER_TYPE_ACTOR_ALIGN,
CLUTTER_ACTOR_ALIGN_FILL,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:y-align:
*
* The alignment of an actor on the Y axis, if the actor has been given
* extra space for its allocation.
*
* Since: 1.10
*/
obj_props[PROP_Y_ALIGN] =
g_param_spec_enum ("y-align",
P_("Y Alignment"),
P_("The alignment of the actor on the Y axis within its allocation"),
CLUTTER_TYPE_ACTOR_ALIGN,
CLUTTER_ACTOR_ALIGN_FILL,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:margin-top:
*
* The margin (in pixels) from the top of the actor.
*
* This property adds a margin to the actor's preferred size; the margin
* will be automatically taken into account when allocating the actor.
*
* The #ClutterActor:margin-top property is animatable.
*
* Since: 1.10
*/
obj_props[PROP_MARGIN_TOP] =
g_param_spec_float ("margin-top",
P_("Margin Top"),
P_("Extra space at the top"),
0.0, G_MAXFLOAT,
0.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:margin-bottom:
*
* The margin (in pixels) from the bottom of the actor.
*
* This property adds a margin to the actor's preferred size; the margin
* will be automatically taken into account when allocating the actor.
*
* The #ClutterActor:margin-bottom property is animatable.
*
* Since: 1.10
*/
obj_props[PROP_MARGIN_BOTTOM] =
g_param_spec_float ("margin-bottom",
P_("Margin Bottom"),
P_("Extra space at the bottom"),
0.0, G_MAXFLOAT,
0.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:margin-left:
*
* The margin (in pixels) from the left of the actor.
*
* This property adds a margin to the actor's preferred size; the margin
* will be automatically taken into account when allocating the actor.
*
* The #ClutterActor:margin-left property is animatable.
*
* Since: 1.10
*/
obj_props[PROP_MARGIN_LEFT] =
g_param_spec_float ("margin-left",
P_("Margin Left"),
P_("Extra space at the left"),
0.0, G_MAXFLOAT,
0.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:margin-right:
*
* The margin (in pixels) from the right of the actor.
*
* This property adds a margin to the actor's preferred size; the margin
* will be automatically taken into account when allocating the actor.
*
* The #ClutterActor:margin-right property is animatable.
*
* Since: 1.10
*/
obj_props[PROP_MARGIN_RIGHT] =
g_param_spec_float ("margin-right",
P_("Margin Right"),
P_("Extra space at the right"),
0.0, G_MAXFLOAT,
0.0,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:background-color-set:
*
* Whether the #ClutterActor:background-color property has been set.
*
* Since: 1.10
*/
obj_props[PROP_BACKGROUND_COLOR_SET] =
g_param_spec_boolean ("background-color-set",
P_("Background Color Set"),
P_("Whether the background color is set"),
FALSE,
CLUTTER_PARAM_READABLE);
/**
* ClutterActor:background-color:
*
* Paints a solid fill of the actor's allocation using the specified
* color.
*
* The #ClutterActor:background-color property is animatable.
*
* Since: 1.10
*/
obj_props[PROP_BACKGROUND_COLOR] =
clutter_param_spec_color ("background-color",
P_("Background color"),
P_("The actor's background color"),
CLUTTER_COLOR_Transparent,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
/**
* ClutterActor:first-child:
*
* The actor's first child.
*
* Since: 1.10
*/
obj_props[PROP_FIRST_CHILD] =
g_param_spec_object ("first-child",
P_("First Child"),
P_("The actor's first child"),
CLUTTER_TYPE_ACTOR,
CLUTTER_PARAM_READABLE);
/**
* ClutterActor:last-child:
*
* The actor's last child.
*
* Since: 1.10
*/
obj_props[PROP_LAST_CHILD] =
g_param_spec_object ("last-child",
P_("Last Child"),
P_("The actor's last child"),
CLUTTER_TYPE_ACTOR,
CLUTTER_PARAM_READABLE);
/**
* ClutterActor:content:
*
* The #ClutterContent implementation that controls the content
* of the actor.
*
* Since: 1.10
*/
obj_props[PROP_CONTENT] =
g_param_spec_object ("content",
P_("Content"),
P_("Delegate object for painting the actor's content"),
CLUTTER_TYPE_CONTENT,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:content-gravity:
*
* The alignment that should be honoured by the #ClutterContent
* set with the #ClutterActor:content property.
*
* Changing the value of this property will change the bounding box of
* the content; you can use the #ClutterActor:content-box property to
* get the position and size of the content within the actor's
* allocation.
*
* This property is meaningful only for #ClutterContent implementations
* that have a preferred size, and if the preferred size is smaller than
* the actor's allocation.
*
* The #ClutterActor:content-gravity property is animatable.
*
* Since: 1.10
*/
obj_props[PROP_CONTENT_GRAVITY] =
g_param_spec_enum ("content-gravity",
P_("Content Gravity"),
P_("Alignment of the actor's content"),
CLUTTER_TYPE_CONTENT_GRAVITY,
CLUTTER_CONTENT_GRAVITY_RESIZE_FILL,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:content-box:
*
* The bounding box for the #ClutterContent used by the actor.
*
* The value of this property is controlled by the #ClutterActor:allocation
* and #ClutterActor:content-gravity properties of #ClutterActor.
*
* The bounding box for the content is guaranteed to never exceed the
* allocation's of the actor.
*
* Since: 1.10
*/
obj_props[PROP_CONTENT_BOX] =
g_param_spec_boxed ("content-box",
P_("Content Box"),
P_("The bounding box of the actor's content"),
CLUTTER_TYPE_ACTOR_BOX,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS |
CLUTTER_PARAM_ANIMATABLE);
obj_props[PROP_MINIFICATION_FILTER] =
g_param_spec_enum ("minification-filter",
P_("Minification Filter"),
P_("The filter used when reducing the size of the content"),
CLUTTER_TYPE_SCALING_FILTER,
CLUTTER_SCALING_FILTER_LINEAR,
CLUTTER_PARAM_READWRITE);
obj_props[PROP_MAGNIFICATION_FILTER] =
g_param_spec_enum ("magnification-filter",
P_("Magnification Filter"),
P_("The filter used when increasing the size of the content"),
CLUTTER_TYPE_SCALING_FILTER,
CLUTTER_SCALING_FILTER_LINEAR,
CLUTTER_PARAM_READWRITE);
/**
* ClutterActor:content-repeat:
*
* The repeat policy for the actor's #ClutterActor:content.
*
* Since: 1.12
*/
obj_props[PROP_CONTENT_REPEAT] =
g_param_spec_flags ("content-repeat",
P_("Content Repeat"),
P_("The repeat policy for the actor's content"),
CLUTTER_TYPE_CONTENT_REPEAT,
CLUTTER_REPEAT_NONE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
g_object_class_install_properties (object_class, PROP_LAST, obj_props);
/**
* ClutterActor::destroy:
* @actor: the #ClutterActor which emitted the signal
*
* The ::destroy signal notifies that all references held on the
* actor which emitted it should be released.
*
* The ::destroy signal should be used by all holders of a reference
* on @actor.
*
* This signal might result in the finalization of the #ClutterActor
* if all references are released.
*
* Composite actors and actors implementing the #ClutterContainer
* interface should override the default implementation of the
* class handler of this signal and call clutter_actor_destroy() on
* their children. When overriding the default class handler, it is
* required to chain up to the parent's implementation.
*
* Since: 0.2
*/
actor_signals[DESTROY] =
g_signal_new (I_("destroy"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_CLEANUP | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET (ClutterActorClass, destroy),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
/**
* ClutterActor::show:
* @actor: the object which received the signal
*
* The ::show signal is emitted when an actor is visible and
* rendered on the stage.
*
* Since: 0.2
*/
actor_signals[SHOW] =
g_signal_new (I_("show"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (ClutterActorClass, show),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
/**
* ClutterActor::hide:
* @actor: the object which received the signal
*
* The ::hide signal is emitted when an actor is no longer rendered
* on the stage.
*
* Since: 0.2
*/
actor_signals[HIDE] =
g_signal_new (I_("hide"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (ClutterActorClass, hide),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
/**
* ClutterActor::parent-set:
* @actor: the object which received the signal
* @old_parent: (allow-none): the previous parent of the actor, or %NULL
*
* This signal is emitted when the parent of the actor changes.
*
* Since: 0.2
*/
actor_signals[PARENT_SET] =
g_signal_new (I_("parent-set"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, parent_set),
NULL, NULL, NULL,
G_TYPE_NONE, 1,
CLUTTER_TYPE_ACTOR);
/**
* ClutterActor::queue-redraw:
* @actor: the actor we're bubbling the redraw request through
* @origin: the actor which initiated the redraw request
* @volume: paint volume to redraw
*
* The ::queue_redraw signal is emitted when clutter_actor_queue_redraw()
* is called on @origin.
*
* The default implementation for #ClutterActor chains up to the
* parent actor and queues a redraw on the parent, thus "bubbling"
* the redraw queue up through the actor graph. The default
* implementation for #ClutterStage queues a clutter_stage_ensure_redraw()
* in a main loop idle handler.
*
* Note that the @origin actor may be the stage, or a container; it
* does not have to be a leaf node in the actor graph.
*
* Toolkits embedding a #ClutterStage which require a redraw and
* relayout cycle can stop the emission of this signal using the
* GSignal API, redraw the UI and then call clutter_stage_ensure_redraw()
* themselves, like:
*
* |[
* static void
* on_redraw_complete (gpointer data)
* {
* ClutterStage *stage = data;
*
* // execute the Clutter drawing pipeline
* clutter_stage_ensure_redraw (stage);
* }
*
* static void
* on_stage_queue_redraw (ClutterStage *stage)
* {
* // this prevents the default handler to run
* g_signal_stop_emission_by_name (stage, "queue-redraw");
*
* // queue a redraw with the host toolkit and call
* // a function when the redraw has been completed
* queue_a_redraw (G_CALLBACK (on_redraw_complete), stage);
* }
* ]|
*
* Note: This signal is emitted before the Clutter paint
* pipeline is executed. If you want to know when the pipeline has
* been completed you should use clutter_threads_add_repaint_func()
* or clutter_threads_add_repaint_func_full().
*
* Since: 1.0
*/
actor_signals[QUEUE_REDRAW] =
g_signal_new (I_("queue-redraw"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST |
G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET (ClutterActorClass, queue_redraw),
g_signal_accumulator_true_handled,
NULL,
_clutter_marshal_BOOLEAN__OBJECT_BOXED,
G_TYPE_BOOLEAN, 2,
CLUTTER_TYPE_ACTOR,
CLUTTER_TYPE_PAINT_VOLUME);
g_signal_set_va_marshaller (actor_signals[QUEUE_REDRAW],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_BOOLEAN__OBJECT_BOXEDv);
/**
* ClutterActor::queue-relayout:
* @actor: the actor being queued for relayout
*
* The ::queue_layout signal is emitted when clutter_actor_queue_relayout()
* is called on an actor.
*
* The default implementation for #ClutterActor chains up to the
* parent actor and queues a relayout on the parent, thus "bubbling"
* the relayout queue up through the actor graph.
*
* The main purpose of this signal is to allow relayout to be propagated
* properly in the procense of #ClutterClone actors. Applications will
* not normally need to connect to this signal.
*
* Since: 1.2
*/
actor_signals[QUEUE_RELAYOUT] =
g_signal_new (I_("queue-relayout"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST |
G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET (ClutterActorClass, queue_relayout),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
/**
* ClutterActor::event:
* @actor: the actor which received the event
* @event: a #ClutterEvent
*
* The ::event signal is emitted each time an event is received
* by the @actor. This signal will be emitted on every actor,
* following the hierarchy chain, until it reaches the top-level
* container (the #ClutterStage).
*
* Return value: %TRUE if the event has been handled by the actor,
* or %FALSE to continue the emission.
*
* Since: 0.6
*/
actor_signals[EVENT] =
g_signal_new (I_("event"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, event),
_clutter_boolean_handled_accumulator, NULL,
_clutter_marshal_BOOLEAN__BOXED,
G_TYPE_BOOLEAN, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
g_signal_set_va_marshaller (actor_signals[EVENT],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_BOOLEAN__BOXEDv);
/**
* ClutterActor::button-press-event:
* @actor: the actor which received the event
* @event: (type ClutterButtonEvent): a #ClutterButtonEvent
*
* The ::button-press-event signal is emitted each time a mouse button
* is pressed on @actor.
*
* Return value: %TRUE if the event has been handled by the actor,
* or %FALSE to continue the emission.
*
* Since: 0.6
*/
actor_signals[BUTTON_PRESS_EVENT] =
g_signal_new (I_("button-press-event"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, button_press_event),
_clutter_boolean_handled_accumulator, NULL,
_clutter_marshal_BOOLEAN__BOXED,
G_TYPE_BOOLEAN, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
g_signal_set_va_marshaller (actor_signals[BUTTON_PRESS_EVENT],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_BOOLEAN__BOXEDv);
/**
* ClutterActor::button-release-event:
* @actor: the actor which received the event
* @event: (type ClutterButtonEvent): a #ClutterButtonEvent
*
* The ::button-release-event signal is emitted each time a mouse button
* is released on @actor.
*
* Return value: %TRUE if the event has been handled by the actor,
* or %FALSE to continue the emission.
*
* Since: 0.6
*/
actor_signals[BUTTON_RELEASE_EVENT] =
g_signal_new (I_("button-release-event"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, button_release_event),
_clutter_boolean_handled_accumulator, NULL,
_clutter_marshal_BOOLEAN__BOXED,
G_TYPE_BOOLEAN, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
g_signal_set_va_marshaller (actor_signals[BUTTON_RELEASE_EVENT],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_BOOLEAN__BOXEDv);
/**
* ClutterActor::scroll-event:
* @actor: the actor which received the event
* @event: (type ClutterScrollEvent): a #ClutterScrollEvent
*
* The ::scroll-event signal is emitted each time the mouse is
* scrolled on @actor
*
* Return value: %TRUE if the event has been handled by the actor,
* or %FALSE to continue the emission.
*
* Since: 0.6
*/
actor_signals[SCROLL_EVENT] =
g_signal_new (I_("scroll-event"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, scroll_event),
_clutter_boolean_handled_accumulator, NULL,
_clutter_marshal_BOOLEAN__BOXED,
G_TYPE_BOOLEAN, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
g_signal_set_va_marshaller (actor_signals[SCROLL_EVENT],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_BOOLEAN__BOXEDv);
/**
* ClutterActor::key-press-event:
* @actor: the actor which received the event
* @event: (type ClutterKeyEvent): a #ClutterKeyEvent
*
* The ::key-press-event signal is emitted each time a keyboard button
* is pressed while @actor has key focus (see clutter_stage_set_key_focus()).
*
* Return value: %TRUE if the event has been handled by the actor,
* or %FALSE to continue the emission.
*
* Since: 0.6
*/
actor_signals[KEY_PRESS_EVENT] =
g_signal_new (I_("key-press-event"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, key_press_event),
_clutter_boolean_handled_accumulator, NULL,
_clutter_marshal_BOOLEAN__BOXED,
G_TYPE_BOOLEAN, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
g_signal_set_va_marshaller (actor_signals[KEY_PRESS_EVENT],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_BOOLEAN__BOXEDv);
/**
* ClutterActor::key-release-event:
* @actor: the actor which received the event
* @event: (type ClutterKeyEvent): a #ClutterKeyEvent
*
* The ::key-release-event signal is emitted each time a keyboard button
* is released while @actor has key focus (see
* clutter_stage_set_key_focus()).
*
* Return value: %TRUE if the event has been handled by the actor,
* or %FALSE to continue the emission.
*
* Since: 0.6
*/
actor_signals[KEY_RELEASE_EVENT] =
g_signal_new (I_("key-release-event"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, key_release_event),
_clutter_boolean_handled_accumulator, NULL,
_clutter_marshal_BOOLEAN__BOXED,
G_TYPE_BOOLEAN, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
g_signal_set_va_marshaller (actor_signals[KEY_RELEASE_EVENT],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_BOOLEAN__BOXEDv);
/**
* ClutterActor::motion-event:
* @actor: the actor which received the event
* @event: (type ClutterMotionEvent): a #ClutterMotionEvent
*
* The ::motion-event signal is emitted each time the mouse pointer is
* moved over @actor.
*
* Return value: %TRUE if the event has been handled by the actor,
* or %FALSE to continue the emission.
*
* Since: 0.6
*/
actor_signals[MOTION_EVENT] =
g_signal_new (I_("motion-event"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, motion_event),
_clutter_boolean_handled_accumulator, NULL,
_clutter_marshal_BOOLEAN__BOXED,
G_TYPE_BOOLEAN, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
g_signal_set_va_marshaller (actor_signals[MOTION_EVENT],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_BOOLEAN__BOXEDv);
/**
* ClutterActor::key-focus-in:
* @actor: the actor which now has key focus
*
* The ::key-focus-in signal is emitted when @actor receives key focus.
*
* Since: 0.6
*/
actor_signals[KEY_FOCUS_IN] =
g_signal_new (I_("key-focus-in"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, key_focus_in),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
/**
* ClutterActor::key-focus-out:
* @actor: the actor which now has key focus
*
* The ::key-focus-out signal is emitted when @actor loses key focus.
*
* Since: 0.6
*/
actor_signals[KEY_FOCUS_OUT] =
g_signal_new (I_("key-focus-out"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, key_focus_out),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
/**
* ClutterActor::enter-event:
* @actor: the actor which the pointer has entered.
* @event: (type ClutterCrossingEvent): a #ClutterCrossingEvent
*
* The ::enter-event signal is emitted when the pointer enters the @actor
*
* Return value: %TRUE if the event has been handled by the actor,
* or %FALSE to continue the emission.
*
* Since: 0.6
*/
actor_signals[ENTER_EVENT] =
g_signal_new (I_("enter-event"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, enter_event),
_clutter_boolean_handled_accumulator, NULL,
_clutter_marshal_BOOLEAN__BOXED,
G_TYPE_BOOLEAN, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
g_signal_set_va_marshaller (actor_signals[ENTER_EVENT],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_BOOLEAN__BOXEDv);
/**
* ClutterActor::leave-event:
* @actor: the actor which the pointer has left
* @event: (type ClutterCrossingEvent): a #ClutterCrossingEvent
*
* The ::leave-event signal is emitted when the pointer leaves the @actor.
*
* Return value: %TRUE if the event has been handled by the actor,
* or %FALSE to continue the emission.
*
* Since: 0.6
*/
actor_signals[LEAVE_EVENT] =
g_signal_new (I_("leave-event"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, leave_event),
_clutter_boolean_handled_accumulator, NULL,
_clutter_marshal_BOOLEAN__BOXED,
G_TYPE_BOOLEAN, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
g_signal_set_va_marshaller (actor_signals[LEAVE_EVENT],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_BOOLEAN__BOXEDv);
/**
* ClutterActor::captured-event:
* @actor: the actor which received the signal
* @event: a #ClutterEvent
*
* The ::captured-event signal is emitted when an event is captured
* by Clutter. This signal will be emitted starting from the top-level
* container (the #ClutterStage) to the actor which received the event
* going down the hierarchy. This signal can be used to intercept every
* event before the specialized events (like
* ClutterActor::button-press-event or ::key-released-event) are
* emitted.
*
* Return value: %TRUE if the event has been handled by the actor,
* or %FALSE to continue the emission.
*
* Since: 0.6
*/
actor_signals[CAPTURED_EVENT] =
g_signal_new (I_("captured-event"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
G_STRUCT_OFFSET (ClutterActorClass, captured_event),
_clutter_boolean_handled_accumulator, NULL,
_clutter_marshal_BOOLEAN__BOXED,
G_TYPE_BOOLEAN, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
g_signal_set_va_marshaller (actor_signals[CAPTURED_EVENT],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_BOOLEAN__BOXEDv);
/**
* ClutterActor::paint:
* @actor: the #ClutterActor that received the signal
* @paint_context: a #ClutterPaintContext
*
* The ::paint signal is emitted each time an actor is being painted.
*
* Subclasses of #ClutterActor should override the #ClutterActorClass.paint
* virtual function paint themselves in that function.
*
* It is strongly discouraged to connect a signal handler to
* the #ClutterActor::paint signal; if you want to change the paint
* sequence of an existing #ClutterActor instance, either create a new
* #ClutterActor class and override the #ClutterActorClass.paint virtual
* function, or use a #ClutterEffect. The #ClutterActor::paint signal
* will be removed in a future version of Clutter.
*
* Since: 0.8
*
* Deprecated: 1.12: Override the #ClutterActorClass.paint virtual
* function, use a #ClutterContent implementation, or a #ClutterEffect
* instead of connecting to this signal.
*/
actor_signals[PAINT] =
g_signal_new (I_("paint"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST |
G_SIGNAL_NO_HOOKS |
G_SIGNAL_DEPRECATED,
G_STRUCT_OFFSET (ClutterActorClass, paint),
NULL, NULL, NULL,
G_TYPE_NONE, 1,
CLUTTER_TYPE_PAINT_CONTEXT);
/**
* ClutterActor::realize:
* @actor: the #ClutterActor that received the signal
*
* The ::realize signal is emitted each time an actor is being
* realized.
*
* Since: 0.8
*
* Deprecated: 1.16: The signal should not be used in newly
* written code
*/
actor_signals[REALIZE] =
g_signal_new (I_("realize"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_DEPRECATED,
G_STRUCT_OFFSET (ClutterActorClass, realize),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
/**
* ClutterActor::unrealize:
* @actor: the #ClutterActor that received the signal
*
* The ::unrealize signal is emitted each time an actor is being
* unrealized.
*
* Since: 0.8
*
* Deprecated: 1.16: The signal should not be used in newly
* written code
*/
actor_signals[UNREALIZE] =
g_signal_new (I_("unrealize"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_DEPRECATED,
G_STRUCT_OFFSET (ClutterActorClass, unrealize),
NULL, NULL, NULL,
G_TYPE_NONE, 0);
/**
* ClutterActor::pick:
* @actor: the #ClutterActor that received the signal
* @pick_context: a #ClutterPickContext
*
* The ::pick signal is emitted each time an actor is being painted
* in "pick mode". The pick mode is used to identify the actor during
* the event handling phase, or by clutter_stage_get_actor_at_pos().
*
* Subclasses of #ClutterActor should override the class signal handler
* and paint themselves in that function.
*
* It is possible to connect a handler to the ::pick signal in order
* to set up some custom aspect of a paint in pick mode.
*
* Since: 1.0
* Deprecated: 1.12: Override the #ClutterActorClass.pick virtual function
* instead.
*/
actor_signals[PICK] =
g_signal_new (I_("pick"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_DEPRECATED,
G_STRUCT_OFFSET (ClutterActorClass, pick),
NULL, NULL, NULL,
G_TYPE_NONE, 1,
CLUTTER_TYPE_PICK_CONTEXT);
/**
* ClutterActor::allocation-changed:
* @actor: the #ClutterActor that emitted the signal
* @box: a #ClutterActorBox with the new allocation
* @flags: #ClutterAllocationFlags for the allocation
*
* The ::allocation-changed signal is emitted when the
* #ClutterActor:allocation property changes. Usually, application
* code should just use the notifications for the :allocation property
* but if you want to track the allocation flags as well, for instance
* to know whether the absolute origin of @actor changed, then you might
* want use this signal instead.
*
* Since: 1.0
*/
actor_signals[ALLOCATION_CHANGED] =
g_signal_new (I_("allocation-changed"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
_clutter_marshal_VOID__BOXED_FLAGS,
G_TYPE_NONE, 2,
CLUTTER_TYPE_ACTOR_BOX | G_SIGNAL_TYPE_STATIC_SCOPE,
CLUTTER_TYPE_ALLOCATION_FLAGS);
g_signal_set_va_marshaller (actor_signals[ALLOCATION_CHANGED],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_VOID__BOXED_FLAGSv);
/**
* ClutterActor::transitions-completed:
* @actor: a #ClutterActor
*
* The ::transitions-completed signal is emitted once all transitions
* involving @actor are complete.
*
* Since: 1.10
*/
actor_signals[TRANSITIONS_COMPLETED] =
g_signal_new (I_("transitions-completed"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE, 0);
/**
* ClutterActor::transition-stopped:
* @actor: a #ClutterActor
* @name: the name of the transition
* @is_finished: whether the transition was finished, or stopped
*
* The ::transition-stopped signal is emitted once a transition
* is stopped; a transition is stopped once it reached its total
* duration (including eventual repeats), it has been stopped
* using clutter_timeline_stop(), or it has been removed from the
* transitions applied on @actor, using clutter_actor_remove_transition().
*
* Since: 1.12
*/
actor_signals[TRANSITION_STOPPED] =
g_signal_new (I_("transition-stopped"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE |
G_SIGNAL_NO_HOOKS | G_SIGNAL_DETAILED,
0,
NULL, NULL,
_clutter_marshal_VOID__STRING_BOOLEAN,
G_TYPE_NONE, 2,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
g_signal_set_va_marshaller (actor_signals[TRANSITION_STOPPED],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_VOID__STRING_BOOLEANv);
/**
* ClutterActor::touch-event:
* @actor: a #ClutterActor
* @event: a #ClutterEvent
*
* The ::touch-event signal is emitted each time a touch
* begin/end/update/cancel event.
*
* Return value: %CLUTTER_EVENT_STOP if the event has been handled by
* the actor, or %CLUTTER_EVENT_PROPAGATE to continue the emission.
*
* Since: 1.12
*/
actor_signals[TOUCH_EVENT] =
g_signal_new (I_("touch-event"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterActorClass, touch_event),
_clutter_boolean_handled_accumulator, NULL,
_clutter_marshal_BOOLEAN__BOXED,
G_TYPE_BOOLEAN, 1,
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
g_signal_set_va_marshaller (actor_signals[TOUCH_EVENT],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_BOOLEAN__BOXEDv);
}
static void
clutter_actor_init (ClutterActor *self)
{
ClutterActorPrivate *priv;
self->priv = priv = clutter_actor_get_instance_private (self);
priv->opacity = 0xff;
priv->show_on_set_parent = TRUE;
priv->resource_scale = -1.0f;
priv->needs_width_request = TRUE;
priv->needs_height_request = TRUE;
priv->needs_allocation = TRUE;
priv->needs_paint_volume_update = TRUE;
priv->needs_compute_resource_scale = TRUE;
priv->cached_width_age = 1;
priv->cached_height_age = 1;
priv->opacity_override = -1;
priv->enable_model_view_transform = TRUE;
/* Initialize an empty paint volume to start with */
_clutter_paint_volume_init_static (&priv->last_paint_volume, NULL);
priv->last_paint_volume_valid = TRUE;
priv->transform_valid = FALSE;
/* the default is to stretch the content, to match the
* current behaviour of basically all actors. also, it's
* the easiest thing to compute.
*/
priv->content_gravity = CLUTTER_CONTENT_GRAVITY_RESIZE_FILL;
priv->min_filter = CLUTTER_SCALING_FILTER_LINEAR;
priv->mag_filter = CLUTTER_SCALING_FILTER_LINEAR;
/* this flag will be set to TRUE if the actor gets a child
* or if the [xy]-expand flags are explicitly set; until
* then, the actor does not need to expand.
*
* this also allows us to avoid computing the expand flag
* when building up a scene.
*/
priv->needs_compute_expand = FALSE;
/* we start with an easing state with duration forcibly set
* to 0, for backward compatibility.
*/
clutter_actor_save_easing_state (self);
clutter_actor_set_easing_duration (self, 0);
}
/**
* clutter_actor_new:
*
* Creates a new #ClutterActor.
*
* A newly created actor has a floating reference, which will be sunk
* when it is added to another actor.
*
* Return value: the newly created #ClutterActor
*
* Since: 1.10
*/
ClutterActor *
clutter_actor_new (void)
{
return g_object_new (CLUTTER_TYPE_ACTOR, NULL);
}
/**
* clutter_actor_destroy:
* @self: a #ClutterActor
*
* Destroys an actor. When an actor is destroyed, it will break any
* references it holds to other objects. If the actor is inside a
* container, the actor will be removed.
*
* When you destroy a container, its children will be destroyed as well.
*
* Note: you cannot destroy the #ClutterStage returned by
* clutter_stage_get_default().
*/
void
clutter_actor_destroy (ClutterActor *self)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_object_ref (self);
/* avoid recursion while destroying */
if (!CLUTTER_ACTOR_IN_DESTRUCTION (self))
{
CLUTTER_SET_PRIVATE_FLAGS (self, CLUTTER_IN_DESTRUCTION);
g_object_run_dispose (G_OBJECT (self));
CLUTTER_UNSET_PRIVATE_FLAGS (self, CLUTTER_IN_DESTRUCTION);
}
g_object_unref (self);
}
void
_clutter_actor_finish_queue_redraw (ClutterActor *self,
ClutterPaintVolume *clip)
{
ClutterActorPrivate *priv = self->priv;
ClutterPaintVolume *pv = NULL;
/* Remove queue entry early in the process, otherwise a new
queue_redraw() during signal handling could put back this
object in the stage redraw list (but the entry is freed as
soon as we return from this function, causing a segfault
later)
*/
priv->queue_redraw_entry = NULL;
/* If we've been explicitly passed a clip volume then there's
* nothing more to calculate, but otherwise the only thing we know
* is that the change is constrained to the given actor.
*
* The idea is that if we know the paint volume for where the actor
* was last drawn (in eye coordinates) and we also have the paint
* volume for where it will be drawn next (in actor coordinates)
* then if we queue a redraw for both these volumes that will cover
* everything that needs to be redrawn to clear the old view and
* show the latest view of the actor.
*
* Don't clip this redraw if we don't know what position we had for
* the previous redraw since we don't know where to set the clip so
* it will clear the actor as it is currently.
*/
if (clip)
{
pv = clip;
}
else if (G_LIKELY (priv->last_paint_volume_valid))
{
pv = _clutter_actor_get_paint_volume_mutable (self);
if (pv)
{
ClutterActor *stage = _clutter_actor_get_stage_internal (self);
/* make sure we redraw the actors old position... */
_clutter_actor_propagate_queue_redraw (stage, stage,
&priv->last_paint_volume);
}
}
_clutter_actor_propagate_queue_redraw (self, self, pv);
}
static void
_clutter_actor_get_allocation_clip (ClutterActor *self,
ClutterActorBox *clip)
{
ClutterActorBox allocation;
/* XXX: we don't care if we get an out of date allocation here
* because clutter_actor_queue_redraw_with_clip knows to ignore
* the clip if the actor's allocation is invalid.
*
* This is noted because clutter_actor_get_allocation_box does some
* unnecessary work to support buggy code with a comment suggesting
* that it could be changed later which would be good for this use
* case!
*/
clutter_actor_get_allocation_box (self, &allocation);
/* NB: clutter_actor_queue_redraw_with_clip expects a box in the
* actor's own coordinate space but the allocation is in parent
* coordinates */
clip->x1 = 0;
clip->y1 = 0;
clip->x2 = allocation.x2 - allocation.x1;
clip->y2 = allocation.y2 - allocation.y1;
}
void
_clutter_actor_queue_redraw_full (ClutterActor *self,
ClutterRedrawFlags flags,
const ClutterPaintVolume *volume,
ClutterEffect *effect)
{
ClutterActorPrivate *priv = self->priv;
ClutterPaintVolume allocation_pv;
ClutterPaintVolume *pv = NULL;
ClutterActor *stage;
/* Here's an outline of the actor queue redraw mechanism:
*
* The process starts in one of the following two functions which
* are wrappers for this function:
*
* clutter_actor_queue_redraw()
* _clutter_actor_queue_redraw_with_clip()
*
* additionally, an effect can queue a redraw by wrapping this
* function in clutter_effect_queue_repaint().
*
* This functions queues an entry in a list associated with the
* stage which is a list of actors that queued a redraw while
* updating the timelines, performing layouting and processing other
* mainloop sources before the next paint starts.
*
* We aim to minimize the processing done at this point because
* there is a good chance other events will happen while updating
* the scenegraph that would invalidate any expensive work we might
* otherwise try to do here. For example we don't try and resolve
* the screen space bounding box of an actor at this stage so as to
* minimize how much of the screen redraw because it's possible
* something else will happen which will force a full redraw anyway.
*
* When all updates are complete and we come to paint the stage then
* we iterate this list and actually emit the "queue-redraw" signals
* for each of the listed actors which will bubble up to the stage
* for each actor and at that point we will transform the actors
* paint volume into screen coordinates to determine the clip region
* for what needs to be redrawn in the next paint.
*
* Besides minimizing redundant work another reason for this
* deferred design is that it's more likely we will be able to
* determine the paint volume of an actor once we've finished
* updating the scenegraph because its allocation should be up to
* date. NB: If we can't determine an actors paint volume then we
* can't automatically queue a clipped redraw which can make a big
* difference to performance.
*
* So the control flow goes like this:
* One of clutter_actor_queue_redraw(),
* _clutter_actor_queue_redraw_with_clip(),
* or clutter_effect_queue_repaint()
*
* then control moves to:
* _clutter_stage_queue_actor_redraw()
*
* later during _clutter_stage_do_update(), once relayouting is done
* and the scenegraph has been updated we will call:
* clutter_stage_maybe_finish_queue_redraws().
*
* clutter_stage_maybe_finish_queue_redraws() will call
* _clutter_actor_finish_queue_redraw() for each listed actor.
*
* Note: actors *are* allowed to queue further redraws during this
* process (considering clone actors or texture_new_from_actor which
* respond to their source queueing a redraw by queuing a redraw
* themselves). We repeat the process until the list is empty.
*
* This will result in the "queue-redraw" signal being fired for
* each actor which will pass control to the default signal handler:
* clutter_actor_real_queue_redraw()
*
* This will bubble up to the stages handler:
* clutter_stage_real_queue_redraw()
*
* clutter_stage_real_queue_redraw() will transform the actors paint
* volume into screen space and add it as a clip region for the next
* paint.
*/
/* ignore queueing a redraw for actors being destroyed */
if (CLUTTER_ACTOR_IN_DESTRUCTION (self))
return;
/* we can ignore unmapped actors, unless they have at least one
* mapped clone or they are inside a cloned branch of the scene
* graph, as unmapped actors will simply be left unpainted.
*
* this allows us to ignore redraws queued on leaf nodes when one
* of their parents has been hidden
*/
if (!CLUTTER_ACTOR_IS_MAPPED (self) &&
self->priv->in_cloned_branch == 0 &&
!clutter_actor_has_mapped_clones (self))
{
CLUTTER_NOTE (PAINT,
"Skipping queue_redraw('%s'): mapped=%s, "
"mapped_clones=%s, "
"in_cloned_branch=%s",
_clutter_actor_get_debug_name (self),
CLUTTER_ACTOR_IS_MAPPED (self) ? "yes" : "no",
clutter_actor_has_mapped_clones (self) ? "yes" : "no",
self->priv->in_cloned_branch != 0 ? "yes" : "no");
return;
}
/* given the check above we could end up queueing a redraw on an
* unmapped actor with mapped clones, so we cannot assume that
* get_stage() will return a Stage
*/
stage = _clutter_actor_get_stage_internal (self);
if (stage == NULL)
return;
/* ignore queueing a redraw on stages that are being destroyed */
if (CLUTTER_ACTOR_IN_DESTRUCTION (stage))
return;
if (flags & CLUTTER_REDRAW_CLIPPED_TO_ALLOCATION)
{
ClutterActorBox allocation_clip;
graphene_point3d_t origin;
/* If the actor doesn't have a valid allocation then we will
* queue a full stage redraw. */
if (priv->needs_allocation)
{
/* NB: NULL denotes an undefined clip which will result in a
* full redraw... */
_clutter_actor_propagate_queue_redraw (self, self, NULL);
return;
}
_clutter_paint_volume_init_static (&allocation_pv, self);
pv = &allocation_pv;
_clutter_actor_get_allocation_clip (self, &allocation_clip);
origin.x = allocation_clip.x1;
origin.y = allocation_clip.y1;
origin.z = 0;
clutter_paint_volume_set_origin (pv, &origin);
clutter_paint_volume_set_width (pv,
allocation_clip.x2 - allocation_clip.x1);
clutter_paint_volume_set_height (pv,
allocation_clip.y2 -
allocation_clip.y1);
}
self->priv->queue_redraw_entry =
_clutter_stage_queue_actor_redraw (CLUTTER_STAGE (stage),
priv->queue_redraw_entry,
self,
pv ? pv : volume);
if (pv)
clutter_paint_volume_free (pv);
/* If this is the first redraw queued then we can directly use the
effect parameter */
if (!priv->is_dirty)
priv->effect_to_redraw = effect;
/* Otherwise we need to merge it with the existing effect parameter */
else if (effect != NULL)
{
/* If there's already an effect then we need to use whichever is
later in the chain of actors. Otherwise a full redraw has
already been queued on the actor so we need to ignore the
effect parameter */
if (priv->effect_to_redraw != NULL)
{
if (priv->effects == NULL)
g_warning ("Redraw queued with an effect that is "
"not applied to the actor");
else
{
const GList *l;
for (l = _clutter_meta_group_peek_metas (priv->effects);
l != NULL;
l = l->next)
{
if (l->data == priv->effect_to_redraw ||
l->data == effect)
priv->effect_to_redraw = l->data;
}
}
}
}
else
{
/* If no effect is specified then we need to redraw the whole
actor */
priv->effect_to_redraw = NULL;
}
priv->is_dirty = TRUE;
}
/**
* clutter_actor_queue_redraw:
* @self: A #ClutterActor
*
* Queues up a redraw of an actor and any children. The redraw occurs
* once the main loop becomes idle (after the current batch of events
* has been processed, roughly).
*
* Applications rarely need to call this, as redraws are handled
* automatically by modification functions.
*
* This function will not do anything if @self is not visible, or
* if the actor is inside an invisible part of the scenegraph.
*
* Also be aware that painting is a NOP for actors with an opacity of
* 0
*
* When you are implementing a custom actor you must queue a redraw
* whenever some private state changes that will affect painting or
* picking of your actor.
*/
void
clutter_actor_queue_redraw (ClutterActor *self)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
_clutter_actor_queue_redraw_full (self,
0, /* flags */
NULL, /* clip volume */
NULL /* effect */);
}
/*< private >
* _clutter_actor_queue_redraw_with_clip:
* @self: A #ClutterActor
* @flags: A mask of #ClutterRedrawFlags controlling the behaviour of
* this queue redraw.
* @volume: A #ClutterPaintVolume describing the bounds of what needs to be
* redrawn or %NULL if you are just using a @flag to state your
* desired clipping.
*
* Queues up a clipped redraw of an actor and any children. The redraw
* occurs once the main loop becomes idle (after the current batch of
* events has been processed, roughly).
*
* If no flags are given the clip volume is defined by @volume
* specified in actor coordinates and tells Clutter that only content
* within this volume has been changed so Clutter can optionally
* optimize the redraw.
*
* If the %CLUTTER_REDRAW_CLIPPED_TO_ALLOCATION @flag is used, @volume
* should be %NULL and this tells Clutter to use the actor's current
* allocation as a clip box. This flag can only be used for 2D actors,
* because any actor with depth may be projected outside its
* allocation.
*
* Applications rarely need to call this, as redraws are handled
* automatically by modification functions.
*
* This function will not do anything if @self is not visible, or if
* the actor is inside an invisible part of the scenegraph.
*
* Also be aware that painting is a NOP for actors with an opacity of
* 0
*
* When you are implementing a custom actor you must queue a redraw
* whenever some private state changes that will affect painting or
* picking of your actor.
*/
void
_clutter_actor_queue_redraw_with_clip (ClutterActor *self,
ClutterRedrawFlags flags,
const ClutterPaintVolume *volume)
{
_clutter_actor_queue_redraw_full (self,
flags, /* flags */
volume, /* clip volume */
NULL /* effect */);
}
void
_clutter_actor_queue_only_relayout (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
if (CLUTTER_ACTOR_IN_DESTRUCTION (self))
return;
if (priv->needs_width_request &&
priv->needs_height_request &&
priv->needs_allocation)
return; /* save some cpu cycles */
#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 "
"cycle; calling clutter_actor_queue_relayout() is "
"not recommended",
_clutter_actor_get_debug_name (self));
}
#endif /* CLUTTER_ENABLE_DEBUG */
_clutter_actor_queue_relayout_on_clones (self);
g_signal_emit (self, actor_signals[QUEUE_RELAYOUT], 0);
}
/**
* clutter_actor_queue_redraw_with_clip:
* @self: a #ClutterActor
* @clip: (allow-none): a rectangular clip region, or %NULL
*
* Queues a redraw on @self limited to a specific, actor-relative
* rectangular area.
*
* If @clip is %NULL this function is equivalent to
* clutter_actor_queue_redraw().
*
* Since: 1.10
*/
void
clutter_actor_queue_redraw_with_clip (ClutterActor *self,
const cairo_rectangle_int_t *clip)
{
ClutterPaintVolume volume;
graphene_point3d_t origin;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (clip == NULL)
{
clutter_actor_queue_redraw (self);
return;
}
_clutter_paint_volume_init_static (&volume, self);
origin.x = clip->x;
origin.y = clip->y;
origin.z = 0.0f;
clutter_paint_volume_set_origin (&volume, &origin);
clutter_paint_volume_set_width (&volume, clip->width);
clutter_paint_volume_set_height (&volume, clip->height);
_clutter_actor_queue_redraw_full (self, 0, &volume, NULL);
clutter_paint_volume_free (&volume);
}
/**
* clutter_actor_queue_relayout:
* @self: A #ClutterActor
*
* Indicates that the actor's size request or other layout-affecting
* properties may have changed. This function is used inside #ClutterActor
* subclass implementations, not by applications directly.
*
* Queueing a new layout automatically queues a redraw as well.
*
* Since: 0.8
*/
void
clutter_actor_queue_relayout (ClutterActor *self)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
_clutter_actor_queue_only_relayout (self);
clutter_actor_queue_redraw (self);
}
/**
* clutter_actor_get_preferred_size:
* @self: a #ClutterActor
* @min_width_p: (out) (allow-none): return location for the minimum
* width, or %NULL
* @min_height_p: (out) (allow-none): return location for the minimum
* height, or %NULL
* @natural_width_p: (out) (allow-none): return location for the natural
* width, or %NULL
* @natural_height_p: (out) (allow-none): return location for the natural
* height, or %NULL
*
* Computes the preferred minimum and natural size of an actor, taking into
* account the actor's geometry management (either height-for-width
* or width-for-height).
*
* The width and height used to compute the preferred height and preferred
* width are the actor's natural ones.
*
* If you need to control the height for the preferred width, or the width for
* the preferred height, you should use clutter_actor_get_preferred_width()
* and clutter_actor_get_preferred_height(), and check the actor's preferred
* geometry management using the #ClutterActor:request-mode property.
*
* Since: 0.8
*/
void
clutter_actor_get_preferred_size (ClutterActor *self,
gfloat *min_width_p,
gfloat *min_height_p,
gfloat *natural_width_p,
gfloat *natural_height_p)
{
ClutterActorPrivate *priv;
gfloat min_width, min_height;
gfloat natural_width, natural_height;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
min_width = min_height = 0;
natural_width = natural_height = 0;
if (priv->request_mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
{
CLUTTER_NOTE (LAYOUT, "Preferred size (height-for-width)");
clutter_actor_get_preferred_width (self, -1,
&min_width,
&natural_width);
clutter_actor_get_preferred_height (self, natural_width,
&min_height,
&natural_height);
}
else if (priv->request_mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT)
{
CLUTTER_NOTE (LAYOUT, "Preferred size (width-for-height)");
clutter_actor_get_preferred_height (self, -1,
&min_height,
&natural_height);
clutter_actor_get_preferred_width (self, natural_height,
&min_width,
&natural_width);
}
else if (priv->request_mode == CLUTTER_REQUEST_CONTENT_SIZE)
{
CLUTTER_NOTE (LAYOUT, "Preferred size (content-size)");
if (priv->content != NULL)
clutter_content_get_preferred_size (priv->content, &natural_width, &natural_height);
}
else
{
CLUTTER_NOTE (LAYOUT, "Unknown request mode");
}
if (min_width_p)
*min_width_p = min_width;
if (min_height_p)
*min_height_p = min_height;
if (natural_width_p)
*natural_width_p = natural_width;
if (natural_height_p)
*natural_height_p = natural_height;
}
/*< private >
* effective_align:
* @align: a #ClutterActorAlign
* @direction: a #ClutterTextDirection
*
* Retrieves the correct alignment depending on the text direction
*
* Return value: the effective alignment
*/
static ClutterActorAlign
effective_align (ClutterActorAlign align,
ClutterTextDirection direction)
{
ClutterActorAlign res;
switch (align)
{
case CLUTTER_ACTOR_ALIGN_START:
res = (direction == CLUTTER_TEXT_DIRECTION_RTL)
? CLUTTER_ACTOR_ALIGN_END
: CLUTTER_ACTOR_ALIGN_START;
break;
case CLUTTER_ACTOR_ALIGN_END:
res = (direction == CLUTTER_TEXT_DIRECTION_RTL)
? CLUTTER_ACTOR_ALIGN_START
: CLUTTER_ACTOR_ALIGN_END;
break;
default:
res = align;
break;
}
return res;
}
/*< private >
* _clutter_actor_get_effective_x_align:
* @self: a #ClutterActor
*
* Retrieves the effective horizontal alignment, taking into
* consideration the text direction of @self.
*
* Return value: the effective horizontal alignment
*/
ClutterActorAlign
_clutter_actor_get_effective_x_align (ClutterActor *self)
{
return effective_align (clutter_actor_get_x_align (self),
clutter_actor_get_text_direction (self));
}
static inline void
adjust_for_margin (float margin_start,
float margin_end,
float *minimum_size,
float *natural_size,
float *allocated_start,
float *allocated_end)
{
float min_size = *minimum_size;
float nat_size = *natural_size;
float start = *allocated_start;
float end = *allocated_end;
min_size = MAX (min_size - (margin_start + margin_end), 0);
nat_size = MAX (nat_size - (margin_start + margin_end), 0);
*minimum_size = min_size;
*natural_size = nat_size;
start += margin_start;
end -= margin_end;
if (end - start >= 0)
{
*allocated_start = start;
*allocated_end = end;
}
}
static inline void
adjust_for_alignment (ClutterActorAlign alignment,
float natural_size,
float *allocated_start,
float *allocated_end)
{
float allocated_size = *allocated_end - *allocated_start;
if (allocated_size <= 0.f)
return;
switch (alignment)
{
case CLUTTER_ACTOR_ALIGN_FILL:
/* do nothing */
break;
case CLUTTER_ACTOR_ALIGN_START:
/* keep start */
*allocated_end = *allocated_start + MIN (natural_size, allocated_size);
break;
case CLUTTER_ACTOR_ALIGN_END:
if (allocated_size > natural_size)
{
*allocated_start += (allocated_size - natural_size);
*allocated_end = *allocated_start + natural_size;
}
break;
case CLUTTER_ACTOR_ALIGN_CENTER:
if (allocated_size > natural_size)
{
*allocated_start += floorf ((allocated_size - natural_size) / 2);
*allocated_end = *allocated_start + MIN (allocated_size, natural_size);
}
break;
}
}
/*< private >
* clutter_actor_adjust_width:
* @self: a #ClutterActor
* @minimum_width: (inout): the actor's preferred minimum width, which
* will be adjusted depending on the margin
* @natural_width: (inout): the actor's preferred natural width, which
* will be adjusted depending on the margin
* @adjusted_x1: (out): the adjusted x1 for the actor's bounding box
* @adjusted_x2: (out): the adjusted x2 for the actor's bounding box
*
* Adjusts the preferred and allocated position and size of an actor,
* depending on the margin and alignment properties.
*/
static void
clutter_actor_adjust_width (ClutterActor *self,
gfloat *minimum_width,
gfloat *natural_width,
gfloat *adjusted_x1,
gfloat *adjusted_x2)
{
ClutterTextDirection text_dir;
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (self);
text_dir = clutter_actor_get_text_direction (self);
CLUTTER_NOTE (LAYOUT, "Adjusting allocated X and width");
/* this will tweak natural_width to remove the margin, so that
* adjust_for_alignment() will use the correct size
*/
adjust_for_margin (info->margin.left, info->margin.right,
minimum_width, natural_width,
adjusted_x1, adjusted_x2);
adjust_for_alignment (effective_align (info->x_align, text_dir),
*natural_width,
adjusted_x1, adjusted_x2);
}
/*< private >
* clutter_actor_adjust_height:
* @self: a #ClutterActor
* @minimum_height: (inout): the actor's preferred minimum height, which
* will be adjusted depending on the margin
* @natural_height: (inout): the actor's preferred natural height, which
* will be adjusted depending on the margin
* @adjusted_y1: (out): the adjusted y1 for the actor's bounding box
* @adjusted_y2: (out): the adjusted y2 for the actor's bounding box
*
* Adjusts the preferred and allocated position and size of an actor,
* depending on the margin and alignment properties.
*/
static void
clutter_actor_adjust_height (ClutterActor *self,
gfloat *minimum_height,
gfloat *natural_height,
gfloat *adjusted_y1,
gfloat *adjusted_y2)
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (self);
CLUTTER_NOTE (LAYOUT, "Adjusting allocated Y and height");
/* this will tweak natural_height to remove the margin, so that
* adjust_for_alignment() will use the correct size
*/
adjust_for_margin (info->margin.top, info->margin.bottom,
minimum_height, natural_height,
adjusted_y1,
adjusted_y2);
/* we don't use effective_align() here, because text direction
* only affects the horizontal axis
*/
adjust_for_alignment (info->y_align,
*natural_height,
adjusted_y1,
adjusted_y2);
}
/* looks for a cached size request for this for_size. If not
* found, returns the oldest entry so it can be overwritten */
static gboolean
_clutter_actor_get_cached_size_request (gfloat for_size,
SizeRequest *cached_size_requests,
SizeRequest **result)
{
guint i;
*result = &cached_size_requests[0];
for (i = 0; i < N_CACHED_SIZE_REQUESTS; i++)
{
SizeRequest *sr;
sr = &cached_size_requests[i];
if (sr->age > 0 &&
sr->for_size == for_size)
{
CLUTTER_NOTE (LAYOUT, "Size cache hit for size: %.2f", for_size);
*result = sr;
return TRUE;
}
else if (sr->age < (*result)->age)
{
*result = sr;
}
}
CLUTTER_NOTE (LAYOUT, "Size cache miss for size: %.2f", for_size);
return FALSE;
}
static void
clutter_actor_update_preferred_size_for_constraints (ClutterActor *self,
ClutterOrientation direction,
float for_size,
float *minimum_size,
float *natural_size)
{
ClutterActorPrivate *priv = self->priv;
const GList *constraints, *l;
if (priv->constraints == NULL)
return;
constraints = _clutter_meta_group_peek_metas (priv->constraints);
for (l = constraints; l != NULL; l = l->next)
{
ClutterConstraint *constraint = l->data;
ClutterActorMeta *meta = l->data;
if (!clutter_actor_meta_get_enabled (meta))
continue;
clutter_constraint_update_preferred_size (constraint, self,
direction,
for_size,
minimum_size,
natural_size);
CLUTTER_NOTE (LAYOUT,
"Preferred %s of '%s' after constraint '%s': "
"{ min:%.2f, nat:%.2f }",
direction == CLUTTER_ORIENTATION_HORIZONTAL
? "width"
: "height",
_clutter_actor_get_debug_name (self),
_clutter_actor_meta_get_debug_name (meta),
*minimum_size, *natural_size);
}
}
/**
* clutter_actor_get_preferred_width:
* @self: A #ClutterActor
* @for_height: available height when computing the preferred width,
* or a negative value to indicate that no height is defined
* @min_width_p: (out) (allow-none): return location for minimum width,
* or %NULL
* @natural_width_p: (out) (allow-none): return location for the natural
* width, or %NULL
*
* Computes the requested minimum and natural widths for an actor,
* optionally depending on the specified height, or if they are
* already computed, returns the cached values.
*
* An actor may not get its request - depending on the layout
* manager that's in effect.
*
* A request should not incorporate the actor's scale or anchor point;
* those transformations do not affect layout, only rendering.
*
* Since: 0.8
*/
void
clutter_actor_get_preferred_width (ClutterActor *self,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
float request_min_width, request_natural_width;
SizeRequest *cached_size_request;
const ClutterLayoutInfo *info;
ClutterActorPrivate *priv;
gboolean found_in_cache;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
info = _clutter_actor_get_layout_info_or_defaults (self);
/* we shortcircuit the case of a fixed size set using set_width() */
if (priv->min_width_set && priv->natural_width_set)
{
if (min_width_p != NULL)
*min_width_p = info->minimum.width + (info->margin.left + info->margin.right);
if (natural_width_p != NULL)
*natural_width_p = info->natural.width + (info->margin.left + info->margin.right);
return;
}
/* if the request mode is CONTENT_SIZE we simply return the content width */
if (priv->request_mode == CLUTTER_REQUEST_CONTENT_SIZE)
{
float content_width = 0.f;
if (priv->content != NULL)
clutter_content_get_preferred_size (priv->content, &content_width, NULL);
if (min_width_p != NULL)
*min_width_p = content_width;
if (natural_width_p != NULL)
*natural_width_p = content_width;
return;
}
CLUTTER_SET_PRIVATE_FLAGS (self, CLUTTER_IN_PREF_WIDTH);
/* the remaining cases are:
*
* - either min_width or natural_width have been set
* - neither min_width or natural_width have been set
*
* in both cases, we go through the cache (and through the actor in case
* of cache misses) and determine the authoritative value depending on
* the *_set flags.
*/
if (!priv->needs_width_request)
{
found_in_cache =
_clutter_actor_get_cached_size_request (for_height,
priv->width_requests,
&cached_size_request);
}
else
{
/* if the actor needs a width request we use the first slot */
found_in_cache = FALSE;
cached_size_request = &priv->width_requests[0];
}
if (!found_in_cache)
{
gfloat minimum_width, natural_width;
ClutterActorClass *klass;
minimum_width = natural_width = 0;
/* adjust for the margin */
if (for_height >= 0)
{
for_height -= (info->margin.top + info->margin.bottom);
if (for_height < 0)
for_height = 0;
}
CLUTTER_NOTE (LAYOUT, "Width request for %.2f px", for_height);
klass = CLUTTER_ACTOR_GET_CLASS (self);
klass->get_preferred_width (self, for_height,
&minimum_width,
&natural_width);
/* adjust for constraints */
clutter_actor_update_preferred_size_for_constraints (self,
CLUTTER_ORIENTATION_HORIZONTAL,
for_height,
&minimum_width,
&natural_width);
/* adjust for the margin */
minimum_width += (info->margin.left + info->margin.right);
natural_width += (info->margin.left + info->margin.right);
/* Due to accumulated float errors, it's better not to warn
* on this, but just fix it.
*/
if (natural_width < minimum_width)
natural_width = minimum_width;
cached_size_request->min_size = minimum_width;
cached_size_request->natural_size = natural_width;
cached_size_request->for_size = for_height;
cached_size_request->age = priv->cached_width_age;
priv->cached_width_age += 1;
priv->needs_width_request = FALSE;
}
if (!priv->min_width_set)
request_min_width = cached_size_request->min_size;
else
request_min_width = info->margin.left
+ info->minimum.width
+ info->margin.right;
if (!priv->natural_width_set)
request_natural_width = cached_size_request->natural_size;
else
request_natural_width = info->margin.left
+ info->natural.width
+ info->margin.right;
if (min_width_p)
*min_width_p = request_min_width;
if (natural_width_p)
*natural_width_p = request_natural_width;
CLUTTER_UNSET_PRIVATE_FLAGS (self, CLUTTER_IN_PREF_WIDTH);
}
/**
* clutter_actor_get_preferred_height:
* @self: A #ClutterActor
* @for_width: available width to assume in computing desired height,
* or a negative value to indicate that no width is defined
* @min_height_p: (out) (allow-none): return location for minimum height,
* or %NULL
* @natural_height_p: (out) (allow-none): return location for natural
* height, or %NULL
*
* Computes the requested minimum and natural heights for an actor,
* or if they are already computed, returns the cached values.
*
* An actor may not get its request - depending on the layout
* manager that's in effect.
*
* A request should not incorporate the actor's scale or anchor point;
* those transformations do not affect layout, only rendering.
*
* Since: 0.8
*/
void
clutter_actor_get_preferred_height (ClutterActor *self,
gfloat for_width,
gfloat *min_height_p,
gfloat *natural_height_p)
{
float request_min_height, request_natural_height;
SizeRequest *cached_size_request;
const ClutterLayoutInfo *info;
ClutterActorPrivate *priv;
gboolean found_in_cache;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
info = _clutter_actor_get_layout_info_or_defaults (self);
/* we shortcircuit the case of a fixed size set using set_height() */
if (priv->min_height_set && priv->natural_height_set)
{
if (min_height_p != NULL)
*min_height_p = info->minimum.height + (info->margin.top + info->margin.bottom);
if (natural_height_p != NULL)
*natural_height_p = info->natural.height + (info->margin.top + info->margin.bottom);
return;
}
/* if the request mode is CONTENT_SIZE we simply return the content height */
if (priv->request_mode == CLUTTER_REQUEST_CONTENT_SIZE)
{
float content_height = 0.f;
if (priv->content != NULL)
clutter_content_get_preferred_size (priv->content, NULL, &content_height);
if (min_height_p != NULL)
*min_height_p = content_height;
if (natural_height_p != NULL)
*natural_height_p = content_height;
return;
}
CLUTTER_SET_PRIVATE_FLAGS (self, CLUTTER_IN_PREF_HEIGHT);
/* the remaining cases are:
*
* - either min_height or natural_height have been set
* - neither min_height or natural_height have been set
*
* in both cases, we go through the cache (and through the actor in case
* of cache misses) and determine the authoritative value depending on
* the *_set flags.
*/
if (!priv->needs_height_request)
{
found_in_cache =
_clutter_actor_get_cached_size_request (for_width,
priv->height_requests,
&cached_size_request);
}
else
{
found_in_cache = FALSE;
cached_size_request = &priv->height_requests[0];
}
if (!found_in_cache)
{
gfloat minimum_height, natural_height;
ClutterActorClass *klass;
minimum_height = natural_height = 0;
CLUTTER_NOTE (LAYOUT, "Height request for %.2f px", for_width);
/* adjust for margin */
if (for_width >= 0)
{
for_width -= (info->margin.left + info->margin.right);
if (for_width < 0)
for_width = 0;
}
klass = CLUTTER_ACTOR_GET_CLASS (self);
klass->get_preferred_height (self, for_width,
&minimum_height,
&natural_height);
/* adjust for constraints */
clutter_actor_update_preferred_size_for_constraints (self,
CLUTTER_ORIENTATION_VERTICAL,
for_width,
&minimum_height,
&natural_height);
/* adjust for margin */
minimum_height += (info->margin.top + info->margin.bottom);
natural_height += (info->margin.top + info->margin.bottom);
/* Due to accumulated float errors, it's better not to warn
* on this, but just fix it.
*/
if (natural_height < minimum_height)
natural_height = minimum_height;
cached_size_request->min_size = minimum_height;
cached_size_request->natural_size = natural_height;
cached_size_request->for_size = for_width;
cached_size_request->age = priv->cached_height_age;
priv->cached_height_age += 1;
priv->needs_height_request = FALSE;
}
if (!priv->min_height_set)
request_min_height = cached_size_request->min_size;
else
request_min_height = info->margin.top
+ info->minimum.height
+ info->margin.bottom;
if (!priv->natural_height_set)
request_natural_height = cached_size_request->natural_size;
else
request_natural_height = info->margin.top
+ info->natural.height
+ info->margin.bottom;
if (min_height_p)
*min_height_p = request_min_height;
if (natural_height_p)
*natural_height_p = request_natural_height;
CLUTTER_UNSET_PRIVATE_FLAGS (self, CLUTTER_IN_PREF_HEIGHT);
}
/**
* clutter_actor_get_allocation_box:
* @self: A #ClutterActor
* @box: (out): the function fills this in with the actor's allocation
*
* Gets the layout box an actor has been assigned. The allocation can
* only be assumed valid inside a paint() method; anywhere else, it
* may be out-of-date.
*
* An allocation does not incorporate the actor's scale or anchor point;
* those transformations do not affect layout, only rendering.
*
* Do not call any of the clutter_actor_get_allocation_*() family
* of functions inside the implementation of the get_preferred_width()
* or get_preferred_height() virtual functions.
*
* Since: 0.8
*/
void
clutter_actor_get_allocation_box (ClutterActor *self,
ClutterActorBox *box)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
/* XXX - if needs_allocation=TRUE, we can either 1) g_return_if_fail,
* which limits calling get_allocation to inside paint() basically; or
* we can 2) force a layout, which could be expensive if someone calls
* get_allocation somewhere silly; or we can 3) just return the latest
* value, allowing it to be out-of-date, and assume people know what
* they are doing.
*
* The least-surprises approach that keeps existing code working is
* likely to be 2). People can end up doing some inefficient things,
* though, and in general code that requires 2) is probably broken.
*/
/* this implements 2) */
if (G_UNLIKELY (self->priv->needs_allocation))
{
ClutterActor *stage = _clutter_actor_get_stage_internal (self);
/* do not queue a relayout on an unparented actor */
if (stage)
_clutter_stage_maybe_relayout (stage);
}
/* commenting out the code above and just keeping this assigment
* implements 3)
*/
*box = self->priv->allocation;
}
static void
clutter_actor_update_constraints (ClutterActor *self,
ClutterActorBox *allocation)
{
ClutterActorPrivate *priv = self->priv;
const GList *constraints, *l;
if (priv->constraints == NULL)
return;
constraints = _clutter_meta_group_peek_metas (priv->constraints);
for (l = constraints; l != NULL; l = l->next)
{
ClutterConstraint *constraint = l->data;
ClutterActorMeta *meta = l->data;
gboolean changed = FALSE;
if (clutter_actor_meta_get_enabled (meta))
{
changed |=
clutter_constraint_update_allocation (constraint,
self,
allocation);
CLUTTER_NOTE (LAYOUT,
"Allocation of '%s' after constraint '%s': "
"{ %.2f, %.2f, %.2f, %.2f } (changed:%s)",
_clutter_actor_get_debug_name (self),
_clutter_actor_meta_get_debug_name (meta),
allocation->x1,
allocation->y1,
allocation->x2,
allocation->y2,
changed ? "yes" : "no");
}
}
}
/*< private >
* clutter_actor_adjust_allocation:
* @self: a #ClutterActor
* @allocation: (inout): the allocation to adjust
*
* Adjusts the passed allocation box taking into account the actor's
* layout information, like alignment, expansion, and margin.
*/
static void
clutter_actor_adjust_allocation (ClutterActor *self,
ClutterActorBox *allocation)
{
ClutterActorBox adj_allocation;
float alloc_width, alloc_height;
float min_width, min_height;
float nat_width, nat_height;
ClutterRequestMode req_mode;
adj_allocation = *allocation;
clutter_actor_box_get_size (allocation, &alloc_width, &alloc_height);
/* There's no point in trying to adjust a zero-sized actor */
if (alloc_width == 0.f && alloc_height == 0.f)
return;
/* we want to hit the cache, so we use the public API */
req_mode = clutter_actor_get_request_mode (self);
if (req_mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
{
clutter_actor_get_preferred_width (self, -1,
&min_width,
&nat_width);
clutter_actor_get_preferred_height (self, alloc_width,
&min_height,
&nat_height);
}
else if (req_mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT)
{
clutter_actor_get_preferred_height (self, -1,
&min_height,
&nat_height);
clutter_actor_get_preferred_width (self, alloc_height,
&min_width,
&nat_width);
}
else if (req_mode == CLUTTER_REQUEST_CONTENT_SIZE)
{
min_width = min_height = 0;
nat_width = nat_height = 0;
if (self->priv->content != NULL)
clutter_content_get_preferred_size (self->priv->content, &nat_width, &nat_height);
}
#ifdef CLUTTER_ENABLE_DEBUG
/* warn about underallocations */
if (_clutter_diagnostic_enabled () &&
(floorf (min_width - alloc_width) > 0 ||
floorf (min_height - alloc_height) > 0))
{
ClutterActor *parent = clutter_actor_get_parent (self);
/* the only actors that are allowed to be underallocated are the Stage,
* as it doesn't have an implicit size, and Actors that specifically
* told us that they want to opt-out from layout control mechanisms
* through the NO_LAYOUT escape hatch.
*/
if (parent != NULL &&
!(self->flags & CLUTTER_ACTOR_NO_LAYOUT) != 0)
{
g_warning (G_STRLOC ": The actor '%s' is getting an allocation "
"of %.2f x %.2f from its parent actor '%s', but its "
"requested minimum size is of %.2f x %.2f",
_clutter_actor_get_debug_name (self),
alloc_width, alloc_height,
_clutter_actor_get_debug_name (parent),
min_width, min_height);
}
}
#endif
clutter_actor_adjust_width (self,
&min_width,
&nat_width,
&adj_allocation.x1,
&adj_allocation.x2);
clutter_actor_adjust_height (self,
&min_height,
&nat_height,
&adj_allocation.y1,
&adj_allocation.y2);
/* we maintain the invariant that an allocation cannot be adjusted
* to be outside the parent-given box
*/
if (adj_allocation.x1 < allocation->x1 ||
adj_allocation.y1 < allocation->y1 ||
adj_allocation.x2 > allocation->x2 ||
adj_allocation.y2 > allocation->y2)
{
g_warning (G_STRLOC ": The actor '%s' tried to adjust its allocation "
"to { %.2f, %.2f, %.2f, %.2f }, which is outside of its "
"original allocation of { %.2f, %.2f, %.2f, %.2f }",
_clutter_actor_get_debug_name (self),
adj_allocation.x1, adj_allocation.y1,
adj_allocation.x2 - adj_allocation.x1,
adj_allocation.y2 - adj_allocation.y1,
allocation->x1, allocation->y1,
allocation->x2 - allocation->x1,
allocation->y2 - allocation->y1);
return;
}
*allocation = adj_allocation;
}
static void
clutter_actor_allocate_internal (ClutterActor *self,
const ClutterActorBox *allocation,
ClutterAllocationFlags flags)
{
ClutterActorClass *klass;
CLUTTER_SET_PRIVATE_FLAGS (self, CLUTTER_IN_RELAYOUT);
CLUTTER_NOTE (LAYOUT, "Calling %s::allocate()",
_clutter_actor_get_debug_name (self));
klass = CLUTTER_ACTOR_GET_CLASS (self);
klass->allocate (self, allocation, flags);
CLUTTER_UNSET_PRIVATE_FLAGS (self, CLUTTER_IN_RELAYOUT);
/* Caller should call clutter_actor_queue_redraw() if needed
* for that particular case.
*/
}
/**
* clutter_actor_allocate:
* @self: A #ClutterActor
* @box: new allocation of the actor, in parent-relative coordinates
* @flags: flags that control the allocation
*
* Assigns the size of a #ClutterActor from the given @box.
*
* This function should only be called on the children of an actor when
* overriding the #ClutterActorClass.allocate() virtual function.
*
* This function will adjust the stored allocation to take into account
* the alignment flags set in the #ClutterActor:x-align and
* #ClutterActor:y-align properties, as well as the margin values set in
* the #ClutterActor:margin-top, #ClutterActor:margin-right,
* #ClutterActor:margin-bottom, and #ClutterActor:margin-left properties.
*
* This function will respect the easing state of the #ClutterActor and
* interpolate between the current allocation and the new one if the
* easing state duration is a positive value.
*
* Actors can know from their allocation box whether they have moved
* with respect to their parent actor. The @flags parameter describes
* additional information about the allocation, for instance whether
* the parent has moved with respect to the stage, for example because
* a grandparent's origin has moved.
*
* Since: 0.8
*/
void
clutter_actor_allocate (ClutterActor *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
ClutterActorBox old_allocation, real_allocation;
gboolean origin_changed, child_moved, size_changed;
gboolean stage_allocation_changed;
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (G_UNLIKELY (_clutter_actor_get_stage_internal (self) == NULL))
{
g_warning ("Spurious clutter_actor_allocate called for actor %p/%s "
"which isn't a descendent of the stage!\n",
self, _clutter_actor_get_debug_name (self));
return;
}
if (!clutter_actor_is_visible (self))
return;
priv = self->priv;
old_allocation = priv->allocation;
real_allocation = *box;
g_return_if_fail (!isnan (real_allocation.x1) &&
!isnan (real_allocation.x2) &&
!isnan (real_allocation.y1) &&
!isnan (real_allocation.y2));
/* constraints are allowed to modify the allocation only here; we do
* this prior to all the other checks so that we can bail out if the
* allocation did not change
*/
clutter_actor_update_constraints (self, &real_allocation);
/* adjust the allocation depending on the align/margin properties */
clutter_actor_adjust_allocation (self, &real_allocation);
if (real_allocation.x2 < real_allocation.x1 ||
real_allocation.y2 < real_allocation.y1)
{
g_warning (G_STRLOC ": Actor '%s' tried to allocate a size of %.2f x %.2f",
_clutter_actor_get_debug_name (self),
real_allocation.x2 - real_allocation.x1,
real_allocation.y2 - real_allocation.y1);
}
/* we allow 0-sized actors, but not negative-sized ones */
real_allocation.x2 = MAX (real_allocation.x2, real_allocation.x1);
real_allocation.y2 = MAX (real_allocation.y2, real_allocation.y1);
origin_changed = (flags & CLUTTER_ABSOLUTE_ORIGIN_CHANGED);
child_moved = (real_allocation.x1 != old_allocation.x1 ||
real_allocation.y1 != old_allocation.y1);
size_changed = (real_allocation.x2 != old_allocation.x2 ||
real_allocation.y2 != old_allocation.y2);
if (origin_changed || child_moved || size_changed)
stage_allocation_changed = TRUE;
else
stage_allocation_changed = FALSE;
/* If we get an allocation "out of the blue"
* (we did not queue relayout), then we want to
* ignore it. But if we have needs_allocation set,
* we want to guarantee that allocate() virtual
* method is always called, i.e. that queue_relayout()
* always results in an allocate() invocation on
* an actor.
*
* The optimization here is to avoid re-allocating
* actors that did not queue relayout and were
* not moved.
*/
if (!priv->needs_allocation && !stage_allocation_changed)
{
CLUTTER_NOTE (LAYOUT, "No allocation needed");
return;
}
if (CLUTTER_ACTOR_IS_MAPPED (self))
self->priv->needs_paint_volume_update = TRUE;
if (stage_allocation_changed)
priv->needs_compute_resource_scale = TRUE;
if (!stage_allocation_changed)
{
/* If the actor didn't move but needs_allocation is set, we just
* need to allocate the children */
clutter_actor_allocate_internal (self, &real_allocation, flags);
return;
}
/* When ABSOLUTE_ORIGIN_CHANGED is passed in to
* clutter_actor_allocate(), it indicates whether the parent has its
* absolute origin moved; when passed in to ClutterActor::allocate()
* virtual method though, it indicates whether the child has its
* absolute origin moved. So we set it when child_moved is TRUE
*/
if (child_moved)
flags |= CLUTTER_ABSOLUTE_ORIGIN_CHANGED;
/* store the flags here, so that they can be propagated by the
* transition code
*/
self->priv->allocation_flags = flags;
_clutter_actor_create_transition (self, obj_props[PROP_ALLOCATION],
&priv->allocation,
&real_allocation);
}
/**
* clutter_actor_set_allocation:
* @self: a #ClutterActor
* @box: a #ClutterActorBox
* @flags: allocation flags
*
* Stores the allocation of @self as defined by @box.
*
* This function can only be called from within the implementation of
* the #ClutterActorClass.allocate() virtual function.
*
* The allocation should have been adjusted to take into account constraints,
* alignment, and margin properties. If you are implementing a #ClutterActor
* subclass that provides its own layout management policy for its children
* instead of using a #ClutterLayoutManager delegate, you should not call
* this function on the children of @self; instead, you should call
* clutter_actor_allocate(), which will adjust the allocation box for
* you.
*
* This function should only be used by subclasses of #ClutterActor
* that wish to store their allocation but cannot chain up to the
* parent's implementation; the default implementation of the
* #ClutterActorClass.allocate() virtual function will call this
* function.
*
* It is important to note that, while chaining up was the recommended
* behaviour for #ClutterActor subclasses prior to the introduction of
* this function, it is recommended to call clutter_actor_set_allocation()
* instead.
*
* If the #ClutterActor is using a #ClutterLayoutManager delegate object
* to handle the allocation of its children, this function will call
* the clutter_layout_manager_allocate() function only if the
* %CLUTTER_DELEGATE_LAYOUT flag is set on @flags, otherwise it is
* expected that the subclass will call clutter_layout_manager_allocate()
* by itself. For instance, the following code:
*
* |[
* static void
* my_actor_allocate (ClutterActor *actor,
* const ClutterActorBox *allocation,
* ClutterAllocationFlags flags)
* {
* ClutterActorBox new_alloc;
* ClutterAllocationFlags new_flags;
*
* adjust_allocation (allocation, &new_alloc);
*
* new_flags = flags | CLUTTER_DELEGATE_LAYOUT;
*
* // this will use the layout manager set on the actor
* clutter_actor_set_allocation (actor, &new_alloc, new_flags);
* }
* ]|
*
* is equivalent to this:
*
* |[
* static void
* my_actor_allocate (ClutterActor *actor,
* const ClutterActorBox *allocation,
* ClutterAllocationFlags flags)
* {
* ClutterLayoutManager *layout;
* ClutterActorBox new_alloc;
*
* adjust_allocation (allocation, &new_alloc);
*
* clutter_actor_set_allocation (actor, &new_alloc, flags);
*
* layout = clutter_actor_get_layout_manager (actor);
* clutter_layout_manager_allocate (layout,
* CLUTTER_CONTAINER (actor),
* &new_alloc,
* flags);
* }
* ]|
*
* Since: 1.10
*/
void
clutter_actor_set_allocation (ClutterActor *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
ClutterActorPrivate *priv;
gboolean changed;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (box != NULL);
if (G_UNLIKELY (!CLUTTER_ACTOR_IN_RELAYOUT (self)))
{
g_critical (G_STRLOC ": The clutter_actor_set_allocation() function "
"can only be called from within the implementation of "
"the ClutterActor::allocate() virtual function.");
return;
}
priv = self->priv;
g_object_freeze_notify (G_OBJECT (self));
changed = clutter_actor_set_allocation_internal (self, box, flags);
/* we allocate our children before we notify changes in our geometry,
* so that people connecting to properties will be able to get valid
* data out of the sub-tree of the scene graph that has this actor at
* the root.
*/
clutter_actor_maybe_layout_children (self, box, flags);
if (changed)
{
ClutterActorBox signal_box = priv->allocation;
ClutterAllocationFlags signal_flags = priv->allocation_flags;
g_signal_emit (self, actor_signals[ALLOCATION_CHANGED], 0,
&signal_box,
signal_flags);
}
g_object_thaw_notify (G_OBJECT (self));
}
/**
* clutter_actor_set_position:
* @self: A #ClutterActor
* @x: New left position of actor in pixels.
* @y: New top position of actor in pixels.
*
* Sets the actor's fixed position in pixels relative to any parent
* actor.
*
* If a layout manager is in use, this position will override the
* layout manager and force a fixed position.
*/
void
clutter_actor_set_position (ClutterActor *self,
gfloat x,
gfloat y)
{
graphene_point_t new_position;
graphene_point_t cur_position;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
graphene_point_init (&new_position, x, y);
cur_position.x = clutter_actor_get_x (self);
cur_position.y = clutter_actor_get_y (self);
if (!graphene_point_equal (&cur_position, &new_position))
_clutter_actor_create_transition (self, obj_props[PROP_POSITION],
&cur_position,
&new_position);
}
/**
* clutter_actor_get_fixed_position_set:
* @self: A #ClutterActor
*
* Checks whether an actor has a fixed position set (and will thus be
* unaffected by any layout manager).
*
* Return value: %TRUE if the fixed position is set on the actor
*
* Since: 0.8
*/
gboolean
clutter_actor_get_fixed_position_set (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
return self->priv->position_set;
}
/**
* clutter_actor_set_fixed_position_set:
* @self: A #ClutterActor
* @is_set: whether to use fixed position
*
* Sets whether an actor has a fixed position set (and will thus be
* unaffected by any layout manager).
*
* Since: 0.8
*/
void
clutter_actor_set_fixed_position_set (ClutterActor *self,
gboolean is_set)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (self->priv->position_set == (is_set != FALSE))
return;
if (!is_set)
{
ClutterLayoutInfo *info;
/* Ensure we set back the default fixed position of 0,0 so that setting
just one of x/y always atomically gets 0 for the other */
info = _clutter_actor_peek_layout_info (self);
if (info != NULL)
{
info->fixed_pos.x = 0;
info->fixed_pos.y = 0;
}
}
self->priv->position_set = is_set != FALSE;
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_FIXED_POSITION_SET]);
clutter_actor_queue_relayout (self);
}
/**
* clutter_actor_move_by:
* @self: A #ClutterActor
* @dx: Distance to move Actor on X axis.
* @dy: Distance to move Actor on Y axis.
*
* Moves an actor by the specified distance relative to its current
* position in pixels.
*
* This function modifies the fixed position of an actor and thus removes
* it from any layout management. Another way to move an actor is with an
* anchor point, see clutter_actor_set_anchor_point(), or with an additional
* translation, using clutter_actor_set_translation().
*
* Since: 0.2
*/
void
clutter_actor_move_by (ClutterActor *self,
gfloat dx,
gfloat dy)
{
const ClutterLayoutInfo *info;
gfloat x, y;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_layout_info_or_defaults (self);
x = info->fixed_pos.x;
y = info->fixed_pos.y;
clutter_actor_set_position (self, x + dx, y + dy);
}
static void
clutter_actor_set_min_width (ClutterActor *self,
gfloat min_width)
{
ClutterActorPrivate *priv = self->priv;
ClutterActorBox old = { 0, };
ClutterLayoutInfo *info;
/* if we are setting the size on a top-level actor and the
* backend only supports static top-levels (e.g. framebuffers)
* then we ignore the passed value and we override it with
* the stage implementation's preferred size.
*/
if (CLUTTER_ACTOR_IS_TOPLEVEL (self) &&
clutter_feature_available (CLUTTER_FEATURE_STAGE_STATIC))
return;
info = _clutter_actor_get_layout_info (self);
if (priv->min_width_set && min_width == info->minimum.width)
return;
g_object_freeze_notify (G_OBJECT (self));
clutter_actor_store_old_geometry (self, &old);
info->minimum.width = min_width;
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_MIN_WIDTH]);
clutter_actor_set_min_width_set (self, TRUE);
clutter_actor_notify_if_geometry_changed (self, &old);
g_object_thaw_notify (G_OBJECT (self));
clutter_actor_queue_relayout (self);
}
static void
clutter_actor_set_min_height (ClutterActor *self,
gfloat min_height)
{
ClutterActorPrivate *priv = self->priv;
ClutterActorBox old = { 0, };
ClutterLayoutInfo *info;
/* if we are setting the size on a top-level actor and the
* backend only supports static top-levels (e.g. framebuffers)
* then we ignore the passed value and we override it with
* the stage implementation's preferred size.
*/
if (CLUTTER_ACTOR_IS_TOPLEVEL (self) &&
clutter_feature_available (CLUTTER_FEATURE_STAGE_STATIC))
return;
info = _clutter_actor_get_layout_info (self);
if (priv->min_height_set && min_height == info->minimum.height)
return;
g_object_freeze_notify (G_OBJECT (self));
clutter_actor_store_old_geometry (self, &old);
info->minimum.height = min_height;
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_MIN_HEIGHT]);
clutter_actor_set_min_height_set (self, TRUE);
clutter_actor_notify_if_geometry_changed (self, &old);
g_object_thaw_notify (G_OBJECT (self));
clutter_actor_queue_relayout (self);
}
static void
clutter_actor_set_natural_width (ClutterActor *self,
gfloat natural_width)
{
ClutterActorPrivate *priv = self->priv;
ClutterActorBox old = { 0, };
ClutterLayoutInfo *info;
/* if we are setting the size on a top-level actor and the
* backend only supports static top-levels (e.g. framebuffers)
* then we ignore the passed value and we override it with
* the stage implementation's preferred size.
*/
if (CLUTTER_ACTOR_IS_TOPLEVEL (self) &&
clutter_feature_available (CLUTTER_FEATURE_STAGE_STATIC))
return;
info = _clutter_actor_get_layout_info (self);
if (priv->natural_width_set && natural_width == info->natural.width)
return;
g_object_freeze_notify (G_OBJECT (self));
clutter_actor_store_old_geometry (self, &old);
info->natural.width = natural_width;
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_NATURAL_WIDTH]);
clutter_actor_set_natural_width_set (self, TRUE);
clutter_actor_notify_if_geometry_changed (self, &old);
g_object_thaw_notify (G_OBJECT (self));
clutter_actor_queue_relayout (self);
}
static void
clutter_actor_set_natural_height (ClutterActor *self,
gfloat natural_height)
{
ClutterActorPrivate *priv = self->priv;
ClutterActorBox old = { 0, };
ClutterLayoutInfo *info;
/* if we are setting the size on a top-level actor and the
* backend only supports static top-levels (e.g. framebuffers)
* then we ignore the passed value and we override it with
* the stage implementation's preferred size.
*/
if (CLUTTER_ACTOR_IS_TOPLEVEL (self) &&
clutter_feature_available (CLUTTER_FEATURE_STAGE_STATIC))
return;
info = _clutter_actor_get_layout_info (self);
if (priv->natural_height_set && natural_height == info->natural.height)
return;
g_object_freeze_notify (G_OBJECT (self));
clutter_actor_store_old_geometry (self, &old);
info->natural.height = natural_height;
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_NATURAL_HEIGHT]);
clutter_actor_set_natural_height_set (self, TRUE);
clutter_actor_notify_if_geometry_changed (self, &old);
g_object_thaw_notify (G_OBJECT (self));
clutter_actor_queue_relayout (self);
}
static void
clutter_actor_set_min_width_set (ClutterActor *self,
gboolean use_min_width)
{
ClutterActorPrivate *priv = self->priv;
ClutterActorBox old = { 0, };
if (priv->min_width_set == (use_min_width != FALSE))
return;
clutter_actor_store_old_geometry (self, &old);
priv->min_width_set = use_min_width != FALSE;
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_MIN_WIDTH_SET]);
clutter_actor_notify_if_geometry_changed (self, &old);
clutter_actor_queue_relayout (self);
}
static void
clutter_actor_set_min_height_set (ClutterActor *self,
gboolean use_min_height)
{
ClutterActorPrivate *priv = self->priv;
ClutterActorBox old = { 0, };
if (priv->min_height_set == (use_min_height != FALSE))
return;
clutter_actor_store_old_geometry (self, &old);
priv->min_height_set = use_min_height != FALSE;
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_MIN_HEIGHT_SET]);
clutter_actor_notify_if_geometry_changed (self, &old);
clutter_actor_queue_relayout (self);
}
static void
clutter_actor_set_natural_width_set (ClutterActor *self,
gboolean use_natural_width)
{
ClutterActorPrivate *priv = self->priv;
ClutterActorBox old = { 0, };
if (priv->natural_width_set == (use_natural_width != FALSE))
return;
clutter_actor_store_old_geometry (self, &old);
priv->natural_width_set = use_natural_width != FALSE;
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_NATURAL_WIDTH_SET]);
clutter_actor_notify_if_geometry_changed (self, &old);
clutter_actor_queue_relayout (self);
}
static void
clutter_actor_set_natural_height_set (ClutterActor *self,
gboolean use_natural_height)
{
ClutterActorPrivate *priv = self->priv;
ClutterActorBox old = { 0, };
if (priv->natural_height_set == (use_natural_height != FALSE))
return;
clutter_actor_store_old_geometry (self, &old);
priv->natural_height_set = use_natural_height != FALSE;
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_NATURAL_HEIGHT_SET]);
clutter_actor_notify_if_geometry_changed (self, &old);
clutter_actor_queue_relayout (self);
}
/**
* clutter_actor_set_request_mode:
* @self: a #ClutterActor
* @mode: the request mode
*
* Sets the geometry request mode of @self.
*
* The @mode determines the order for invoking
* clutter_actor_get_preferred_width() and
* clutter_actor_get_preferred_height()
*
* Since: 1.2
*/
void
clutter_actor_set_request_mode (ClutterActor *self,
ClutterRequestMode mode)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
if (priv->request_mode == mode)
return;
priv->request_mode = mode;
priv->needs_width_request = TRUE;
priv->needs_height_request = TRUE;
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_REQUEST_MODE]);
clutter_actor_queue_relayout (self);
}
/**
* clutter_actor_get_request_mode:
* @self: a #ClutterActor
*
* Retrieves the geometry request mode of @self
*
* Return value: the request mode for the actor
*
* Since: 1.2
*/
ClutterRequestMode
clutter_actor_get_request_mode (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self),
CLUTTER_REQUEST_HEIGHT_FOR_WIDTH);
return self->priv->request_mode;
}
/* variant of set_width() without checks and without notification
* freeze+thaw, for internal usage only
*/
static inline void
clutter_actor_set_width_internal (ClutterActor *self,
gfloat width)
{
if (width >= 0)
{
/* the Stage will use the :min-width to control the minimum
* width to be resized to, so we should not be setting it
* along with the :natural-width
*/
if (!CLUTTER_ACTOR_IS_TOPLEVEL (self))
clutter_actor_set_min_width (self, width);
clutter_actor_set_natural_width (self, width);
}
else
{
/* we only unset the :natural-width for the Stage */
if (!CLUTTER_ACTOR_IS_TOPLEVEL (self))
clutter_actor_set_min_width_set (self, FALSE);
clutter_actor_set_natural_width_set (self, FALSE);
}
}
/* variant of set_height() without checks and without notification
* freeze+thaw, for internal usage only
*/
static inline void
clutter_actor_set_height_internal (ClutterActor *self,
gfloat height)
{
if (height >= 0)
{
/* see the comment above in set_width_internal() */
if (!CLUTTER_ACTOR_IS_TOPLEVEL (self))
clutter_actor_set_min_height (self, height);
clutter_actor_set_natural_height (self, height);
}
else
{
/* see the comment above in set_width_internal() */
if (!CLUTTER_ACTOR_IS_TOPLEVEL (self))
clutter_actor_set_min_height_set (self, FALSE);
clutter_actor_set_natural_height_set (self, FALSE);
}
}
static void
clutter_actor_set_size_internal (ClutterActor *self,
const graphene_size_t *size)
{
if (size != NULL)
{
clutter_actor_set_width_internal (self, size->width);
clutter_actor_set_height_internal (self, size->height);
}
else
{
clutter_actor_set_width_internal (self, -1);
clutter_actor_set_height_internal (self, -1);
}
}
/**
* clutter_actor_set_size:
* @self: A #ClutterActor
* @width: New width of actor in pixels, or -1
* @height: New height of actor in pixels, or -1
*
* Sets the actor's size request in pixels. This overrides any
* "normal" size request the actor would have. For example
* a text actor might normally request the size of the text;
* this function would force a specific size instead.
*
* If @width and/or @height are -1 the actor will use its
* "normal" size request instead of overriding it, i.e.
* you can "unset" the size with -1.
*
* This function sets or unsets both the minimum and natural size.
*/
void
clutter_actor_set_size (ClutterActor *self,
gfloat width,
gfloat height)
{
graphene_size_t new_size;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
graphene_size_init (&new_size, width, height);
/* minor optimization: if we don't have a duration then we can
* skip the get_size() below, to avoid the chance of going through
* get_preferred_width() and get_preferred_height() just to jump to
* a new desired size
*/
if (clutter_actor_get_easing_duration (self) == 0)
{
g_object_freeze_notify (G_OBJECT (self));
clutter_actor_set_size_internal (self, &new_size);
g_object_thaw_notify (G_OBJECT (self));
return;
}
else
{
graphene_size_t cur_size;
graphene_size_init (&cur_size,
clutter_actor_get_width (self),
clutter_actor_get_height (self));
_clutter_actor_create_transition (self,
obj_props[PROP_SIZE],
&cur_size,
&new_size);
}
}
/**
* clutter_actor_get_size:
* @self: A #ClutterActor
* @width: (out) (allow-none): return location for the width, or %NULL.
* @height: (out) (allow-none): return location for the height, or %NULL.
*
* This function tries to "do what you mean" and return
* the size an actor will have. If the actor has a valid
* allocation, the allocation will be returned; otherwise,
* the actors natural size request will be returned.
*
* If you care whether you get the request vs. the allocation, you
* should probably call a different function like
* clutter_actor_get_allocation_box() or
* clutter_actor_get_preferred_width().
*
* Since: 0.2
*/
void
clutter_actor_get_size (ClutterActor *self,
gfloat *width,
gfloat *height)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (width)
*width = clutter_actor_get_width (self);
if (height)
*height = clutter_actor_get_height (self);
}
/**
* clutter_actor_get_position:
* @self: a #ClutterActor
* @x: (out) (allow-none): return location for the X coordinate, or %NULL
* @y: (out) (allow-none): return location for the Y coordinate, or %NULL
*
* This function tries to "do what you mean" and tell you where the
* actor is, prior to any transformations. Retrieves the fixed
* position of an actor in pixels, if one has been set; otherwise, if
* the allocation is valid, returns the actor's allocated position;
* otherwise, returns 0,0.
*
* The returned position is in pixels.
*
* Since: 0.6
*/
void
clutter_actor_get_position (ClutterActor *self,
gfloat *x,
gfloat *y)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (x)
*x = clutter_actor_get_x (self);
if (y)
*y = clutter_actor_get_y (self);
}
/**
* clutter_actor_get_transformed_position:
* @self: A #ClutterActor
* @x: (out) (allow-none): return location for the X coordinate, or %NULL
* @y: (out) (allow-none): return location for the Y coordinate, or %NULL
*
* Gets the absolute position of an actor, in pixels relative to the stage.
*
* Since: 0.8
*/
void
clutter_actor_get_transformed_position (ClutterActor *self,
gfloat *x,
gfloat *y)
{
graphene_point3d_t v1;
graphene_point3d_t v2;
v1.x = v1.y = v1.z = 0;
clutter_actor_apply_transform_to_point (self, &v1, &v2);
if (x)
*x = v2.x;
if (y)
*y = v2.y;
}
/**
* clutter_actor_get_transformed_size:
* @self: A #ClutterActor
* @width: (out) (allow-none): return location for the width, or %NULL
* @height: (out) (allow-none): return location for the height, or %NULL
*
* Gets the absolute size of an actor in pixels, taking into account the
* scaling factors.
*
* If the actor has a valid allocation, the allocated size will be used.
* If the actor has not a valid allocation then the preferred size will
* be transformed and returned.
*
* If you want the transformed allocation, see
* clutter_actor_get_abs_allocation_vertices() instead.
*
* When the actor (or one of its ancestors) is rotated around the
* X or Y axis, it no longer appears as on the stage as a rectangle, but
* as a generic quadrangle; in that case this function returns the size
* of the smallest rectangle that encapsulates the entire quad. Please
* note that in this case no assumptions can be made about the relative
* position of this envelope to the absolute position of the actor, as
* returned by clutter_actor_get_transformed_position(); if you need this
* information, you need to use clutter_actor_get_abs_allocation_vertices()
* to get the coords of the actual quadrangle.
*
* Since: 0.8
*/
void
clutter_actor_get_transformed_size (ClutterActor *self,
gfloat *width,
gfloat *height)
{
ClutterActorPrivate *priv;
graphene_point3d_t v[4];
gfloat x_min, x_max, y_min, y_max;
gint i;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
/* if the actor hasn't been allocated yet, get the preferred
* size and transform that
*/
if (priv->needs_allocation)
{
gfloat natural_width, natural_height;
ClutterActorBox box;
/* Make a fake allocation to transform.
*
* NB: _clutter_actor_transform_and_project_box expects a box in
* the actor's coordinate space... */
box.x1 = 0;
box.y1 = 0;
natural_width = natural_height = 0;
clutter_actor_get_preferred_size (self, NULL, NULL,
&natural_width,
&natural_height);
box.x2 = natural_width;
box.y2 = natural_height;
_clutter_actor_transform_and_project_box (self, &box, v);
}
else
clutter_actor_get_abs_allocation_vertices (self, v);
x_min = x_max = v[0].x;
y_min = y_max = v[0].y;
for (i = 1; i < G_N_ELEMENTS (v); ++i)
{
if (v[i].x < x_min)
x_min = v[i].x;
if (v[i].x > x_max)
x_max = v[i].x;
if (v[i].y < y_min)
y_min = v[i].y;
if (v[i].y > y_max)
y_max = v[i].y;
}
if (width)
*width = x_max - x_min;
if (height)
*height = y_max - y_min;
}
/**
* clutter_actor_get_width:
* @self: A #ClutterActor
*
* Retrieves the width of a #ClutterActor.
*
* If the actor has a valid allocation, this function will return the
* width of the allocated area given to the actor.
*
* If the actor does not have a valid allocation, this function will
* return the actor's natural width, that is the preferred width of
* the actor.
*
* If you care whether you get the preferred width or the width that
* has been assigned to the actor, you should probably call a different
* function like clutter_actor_get_allocation_box() to retrieve the
* allocated size or clutter_actor_get_preferred_width() to retrieve the
* preferred width.
*
* If an actor has a fixed width, for instance a width that has been
* assigned using clutter_actor_set_width(), the width returned will
* be the same value.
*
* Return value: the width of the actor, in pixels
*/
gfloat
clutter_actor_get_width (ClutterActor *self)
{
ClutterActorPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
priv = self->priv;
if (priv->needs_allocation)
{
gfloat natural_width = 0;
if (priv->request_mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
{
clutter_actor_get_preferred_width (self, -1, NULL, &natural_width);
}
else if (priv->request_mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT)
{
gfloat natural_height = 0;
clutter_actor_get_preferred_height (self, -1, NULL, &natural_height);
clutter_actor_get_preferred_width (self, natural_height,
NULL,
&natural_width);
}
else if (priv->request_mode == CLUTTER_REQUEST_CONTENT_SIZE && priv->content != NULL)
{
clutter_content_get_preferred_size (priv->content, &natural_width, NULL);
}
return natural_width;
}
else
return priv->allocation.x2 - priv->allocation.x1;
}
/**
* clutter_actor_get_height:
* @self: A #ClutterActor
*
* Retrieves the height of a #ClutterActor.
*
* If the actor has a valid allocation, this function will return the
* height of the allocated area given to the actor.
*
* If the actor does not have a valid allocation, this function will
* return the actor's natural height, that is the preferred height of
* the actor.
*
* If you care whether you get the preferred height or the height that
* has been assigned to the actor, you should probably call a different
* function like clutter_actor_get_allocation_box() to retrieve the
* allocated size or clutter_actor_get_preferred_height() to retrieve the
* preferred height.
*
* If an actor has a fixed height, for instance a height that has been
* assigned using clutter_actor_set_height(), the height returned will
* be the same value.
*
* Return value: the height of the actor, in pixels
*/
gfloat
clutter_actor_get_height (ClutterActor *self)
{
ClutterActorPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
priv = self->priv;
if (priv->needs_allocation)
{
gfloat natural_height = 0;
if (priv->request_mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
{
gfloat natural_width = 0;
clutter_actor_get_preferred_width (self, -1, NULL, &natural_width);
clutter_actor_get_preferred_height (self, natural_width,
NULL, &natural_height);
}
else if (priv->request_mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT)
{
clutter_actor_get_preferred_height (self, -1, NULL, &natural_height);
}
else if (priv->request_mode == CLUTTER_REQUEST_CONTENT_SIZE && priv->content != NULL)
{
clutter_content_get_preferred_size (priv->content, NULL, &natural_height);
}
return natural_height;
}
else
return priv->allocation.y2 - priv->allocation.y1;
}
/**
* clutter_actor_set_width:
* @self: A #ClutterActor
* @width: Requested new width for the actor, in pixels, or -1
*
* Forces a width on an actor, causing the actor's preferred width
* and height (if any) to be ignored.
*
* If @width is -1 the actor will use its preferred width request
* instead of overriding it, i.e. you can "unset" the width with -1.
*
* This function sets both the minimum and natural size of the actor.
*
* since: 0.2
*/
void
clutter_actor_set_width (ClutterActor *self,
gfloat width)
{
float cur_size;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
/* minor optimization: if we don't have a duration
* then we can skip the get_width() below, to avoid
* the chance of going through get_preferred_width()
* just to jump to a new desired width.
*/
if (clutter_actor_get_easing_duration (self) == 0)
{
g_object_freeze_notify (G_OBJECT (self));
clutter_actor_set_width_internal (self, width);
g_object_thaw_notify (G_OBJECT (self));
return;
}
else
cur_size = clutter_actor_get_width (self);
_clutter_actor_create_transition (self,
obj_props[PROP_WIDTH],
cur_size,
width);
}
/**
* clutter_actor_set_height:
* @self: A #ClutterActor
* @height: Requested new height for the actor, in pixels, or -1
*
* Forces a height on an actor, causing the actor's preferred width
* and height (if any) to be ignored.
*
* If @height is -1 the actor will use its preferred height instead of
* overriding it, i.e. you can "unset" the height with -1.
*
* This function sets both the minimum and natural size of the actor.
*
* since: 0.2
*/
void
clutter_actor_set_height (ClutterActor *self,
gfloat height)
{
float cur_size;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
/* see the comment in clutter_actor_set_width() above */
if (clutter_actor_get_easing_duration (self) == 0)
{
g_object_freeze_notify (G_OBJECT (self));
clutter_actor_set_height_internal (self, height);
g_object_thaw_notify (G_OBJECT (self));
return;
}
else
cur_size = clutter_actor_get_height (self);
_clutter_actor_create_transition (self,
obj_props[PROP_HEIGHT],
cur_size,
height);
}
static inline void
clutter_actor_set_x_internal (ClutterActor *self,
float x)
{
ClutterActorPrivate *priv = self->priv;
ClutterLayoutInfo *linfo;
ClutterActorBox old = { 0, };
linfo = _clutter_actor_get_layout_info (self);
if (priv->position_set && linfo->fixed_pos.x == x)
return;
clutter_actor_store_old_geometry (self, &old);
linfo->fixed_pos.x = x;
clutter_actor_set_fixed_position_set (self, TRUE);
clutter_actor_notify_if_geometry_changed (self, &old);
clutter_actor_queue_relayout (self);
}
static inline void
clutter_actor_set_y_internal (ClutterActor *self,
float y)
{
ClutterActorPrivate *priv = self->priv;
ClutterLayoutInfo *linfo;
ClutterActorBox old = { 0, };
linfo = _clutter_actor_get_layout_info (self);
if (priv->position_set && linfo->fixed_pos.y == y)
return;
clutter_actor_store_old_geometry (self, &old);
linfo->fixed_pos.y = y;
clutter_actor_set_fixed_position_set (self, TRUE);
clutter_actor_notify_if_geometry_changed (self, &old);
clutter_actor_queue_relayout (self);
}
static void
clutter_actor_set_position_internal (ClutterActor *self,
const graphene_point_t *position)
{
ClutterActorPrivate *priv = self->priv;
ClutterLayoutInfo *linfo;
ClutterActorBox old = { 0, };
linfo = _clutter_actor_get_layout_info (self);
if (priv->position_set &&
graphene_point_equal (position, &linfo->fixed_pos))
return;
clutter_actor_store_old_geometry (self, &old);
if (position != NULL)
{
linfo->fixed_pos = *position;
clutter_actor_set_fixed_position_set (self, TRUE);
}
else
clutter_actor_set_fixed_position_set (self, FALSE);
clutter_actor_notify_if_geometry_changed (self, &old);
clutter_actor_queue_relayout (self);
}
/**
* clutter_actor_set_x:
* @self: a #ClutterActor
* @x: the actor's position on the X axis
*
* Sets the actor's X coordinate, relative to its parent, in pixels.
*
* Overrides any layout manager and forces a fixed position for
* the actor.
*
* The #ClutterActor:x property is animatable.
*
* Since: 0.6
*/
void
clutter_actor_set_x (ClutterActor *self,
gfloat x)
{
float cur_position = clutter_actor_get_x (self);
g_return_if_fail (CLUTTER_IS_ACTOR (self));
_clutter_actor_create_transition (self, obj_props[PROP_X],
cur_position,
x);
}
/**
* clutter_actor_set_y:
* @self: a #ClutterActor
* @y: the actor's position on the Y axis
*
* Sets the actor's Y coordinate, relative to its parent, in pixels.#
*
* Overrides any layout manager and forces a fixed position for
* the actor.
*
* The #ClutterActor:y property is animatable.
*
* Since: 0.6
*/
void
clutter_actor_set_y (ClutterActor *self,
gfloat y)
{
float cur_position = clutter_actor_get_y (self);
g_return_if_fail (CLUTTER_IS_ACTOR (self));
_clutter_actor_create_transition (self, obj_props[PROP_Y],
cur_position,
y);
}
/**
* clutter_actor_get_x:
* @self: A #ClutterActor
*
* Retrieves the X coordinate of a #ClutterActor.
*
* This function tries to "do what you mean", by returning the
* correct value depending on the actor's state.
*
* If the actor has a valid allocation, this function will return
* the X coordinate of the origin of the allocation box.
*
* If the actor has any fixed coordinate set using clutter_actor_set_x(),
* clutter_actor_set_position(), this function will return that coordinate.
*
* If both the allocation and a fixed position are missing, this function
* will return 0.
*
* Return value: the X coordinate, in pixels, ignoring any
* transformation (i.e. scaling, rotation)
*/
gfloat
clutter_actor_get_x (ClutterActor *self)
{
ClutterActorPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
priv = self->priv;
if (priv->needs_allocation)
{
if (priv->position_set)
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (self);
return info->fixed_pos.x;
}
else
return 0;
}
else
return priv->allocation.x1;
}
/**
* clutter_actor_get_y:
* @self: A #ClutterActor
*
* Retrieves the Y coordinate of a #ClutterActor.
*
* This function tries to "do what you mean", by returning the
* correct value depending on the actor's state.
*
* If the actor has a valid allocation, this function will return
* the Y coordinate of the origin of the allocation box.
*
* If the actor has any fixed coordinate set using clutter_actor_set_y(),
* clutter_actor_set_position(), this function will return that coordinate.
*
* If both the allocation and a fixed position are missing, this function
* will return 0.
*
* Return value: the Y coordinate, in pixels, ignoring any
* transformation (i.e. scaling, rotation)
*/
gfloat
clutter_actor_get_y (ClutterActor *self)
{
ClutterActorPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
priv = self->priv;
if (priv->needs_allocation)
{
if (priv->position_set)
{
const ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info_or_defaults (self);
return info->fixed_pos.y;
}
else
return 0;
}
else
return priv->allocation.y1;
}
/**
* clutter_actor_set_scale:
* @self: A #ClutterActor
* @scale_x: double factor to scale actor by horizontally.
* @scale_y: double factor to scale actor by vertically.
*
* Scales an actor with the given factors.
*
* The scale transformation is relative the the #ClutterActor:pivot-point.
*
* The #ClutterActor:scale-x and #ClutterActor:scale-y properties are
* animatable.
*
* Since: 0.2
*/
void
clutter_actor_set_scale (ClutterActor *self,
gdouble scale_x,
gdouble scale_y)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_object_freeze_notify (G_OBJECT (self));
clutter_actor_set_scale_factor (self, CLUTTER_X_AXIS, scale_x);
clutter_actor_set_scale_factor (self, CLUTTER_Y_AXIS, scale_y);
g_object_thaw_notify (G_OBJECT (self));
}
/**
* clutter_actor_set_scale_z:
* @self: a #ClutterActor
* @scale_z: the scaling factor along the Z axis
*
* Scales an actor on the Z axis by the given @scale_z factor.
*
* The scale transformation is relative the the #ClutterActor:pivot-point.
*
* The #ClutterActor:scale-z property is animatable.
*
* Since: 1.12
*/
void
clutter_actor_set_scale_z (ClutterActor *self,
gdouble scale_z)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
clutter_actor_set_scale_factor (self, CLUTTER_Z_AXIS, scale_z);
}
/**
* clutter_actor_set_scale_full:
* @self: A #ClutterActor
* @scale_x: double factor to scale actor by horizontally.
* @scale_y: double factor to scale actor by vertically.
* @center_x: X coordinate of the center of the scaling
* @center_y: Y coordinate of the center of the scaling
*
* Scales an actor with the given factors around the given center
* point. The center point is specified in pixels relative to the
* anchor point (usually the top left corner of the actor).
*
* The #ClutterActor:scale-x and #ClutterActor:scale-y properties
* are animatable.
*
* Since: 1.0
*
* Deprecated: 1.12: Use clutter_actor_set_pivot_point() to control
* the scale center
*/
void
clutter_actor_set_scale_full (ClutterActor *self,
gdouble scale_x,
gdouble scale_y,
gfloat center_x,
gfloat center_y)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_object_freeze_notify (G_OBJECT (self));
clutter_actor_set_scale_factor (self, CLUTTER_X_AXIS, scale_x);
clutter_actor_set_scale_factor (self, CLUTTER_Y_AXIS, scale_y);
clutter_actor_set_scale_center (self, CLUTTER_X_AXIS, center_x);
clutter_actor_set_scale_center (self, CLUTTER_Y_AXIS, center_y);
g_object_thaw_notify (G_OBJECT (self));
}
/**
* clutter_actor_get_scale:
* @self: A #ClutterActor
* @scale_x: (out) (allow-none): Location to store horizonal
* scale factor, or %NULL.
* @scale_y: (out) (allow-none): Location to store vertical
* scale factor, or %NULL.
*
* Retrieves an actors scale factors.
*
* Since: 0.2
*/
void
clutter_actor_get_scale (ClutterActor *self,
gdouble *scale_x,
gdouble *scale_y)
{
const ClutterTransformInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_transform_info_or_defaults (self);
if (scale_x)
*scale_x = info->scale_x;
if (scale_y)
*scale_y = info->scale_y;
}
/**
* clutter_actor_get_scale_z:
* @self: A #ClutterActor
*
* Retrieves the scaling factor along the Z axis, as set using
* clutter_actor_set_scale_z().
*
* Return value: the scaling factor along the Z axis
*
* Since: 1.12
*/
gdouble
clutter_actor_get_scale_z (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 1.0);
return _clutter_actor_get_transform_info_or_defaults (self)->scale_z;
}
/**
* clutter_actor_get_scale_center:
* @self: A #ClutterActor
* @center_x: (out) (allow-none): Location to store the X position
* of the scale center, or %NULL.
* @center_y: (out) (allow-none): Location to store the Y position
* of the scale center, or %NULL.
*
* Retrieves the scale center coordinate in pixels relative to the top
* left corner of the actor. If the scale center was specified using a
* #ClutterGravity this will calculate the pixel offset using the
* current size of the actor.
*
* Since: 1.0
*
* Deprecated: 1.12: Use clutter_actor_get_pivot_point() instead.
*/
void
clutter_actor_get_scale_center (ClutterActor *self,
gfloat *center_x,
gfloat *center_y)
{
const ClutterTransformInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_transform_info_or_defaults (self);
clutter_anchor_coord_get_units (self, &info->scale_center,
center_x,
center_y,
NULL);
}
/**
* clutter_actor_get_scale_gravity:
* @self: A #ClutterActor
*
* Retrieves the scale center as a compass direction. If the scale
* center was specified in pixels or units this will return
* %CLUTTER_GRAVITY_NONE.
*
* Return value: the scale gravity
*
* Since: 1.0
*
* Deprecated: 1.12: Use clutter_actor_get_pivot_point() instead.
*/
ClutterGravity
clutter_actor_get_scale_gravity (ClutterActor *self)
{
const ClutterTransformInfo *info;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), CLUTTER_GRAVITY_NONE);
info = _clutter_actor_get_transform_info_or_defaults (self);
return clutter_anchor_coord_get_gravity (&info->scale_center);
}
static inline void
clutter_actor_set_opacity_internal (ClutterActor *self,
guint8 opacity)
{
ClutterActorPrivate *priv = self->priv;
if (priv->opacity != opacity)
{
priv->opacity = opacity;
/* Queue a redraw from the flatten effect so that it can use
its cached image if available instead of having to redraw the
actual actor. If it doesn't end up using the FBO then the
effect is still able to continue the paint anyway. If there
is no flatten effect yet then this is equivalent to queueing
a full redraw */
_clutter_actor_queue_redraw_full (self,
0, /* flags */
NULL, /* clip */
priv->flatten_effect);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_OPACITY]);
}
}
/**
* clutter_actor_set_opacity:
* @self: A #ClutterActor
* @opacity: New opacity value for the actor.
*
* Sets the actor's opacity, with zero being completely transparent and
* 255 (0xff) being fully opaque.
*
* The #ClutterActor:opacity property is animatable.
*/
void
clutter_actor_set_opacity (ClutterActor *self,
guint8 opacity)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
_clutter_actor_create_transition (self, obj_props[PROP_OPACITY],
self->priv->opacity,
opacity);
}
/*
* clutter_actor_get_paint_opacity_internal:
* @self: a #ClutterActor
*
* Retrieves the absolute opacity of the actor, as it appears on the stage
*
* This function does not do type checks
*
* Return value: the absolute opacity of the actor
*/
static guint8
clutter_actor_get_paint_opacity_internal (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
ClutterActor *parent;
/* override the top-level opacity to always be 255; even in
* case of ClutterStage:use-alpha being TRUE we want the rest
* of the scene to be painted
*/
if (CLUTTER_ACTOR_IS_TOPLEVEL (self))
return 255;
if (priv->opacity_override >= 0)
return priv->opacity_override;
parent = priv->parent;
/* Factor in the actual actors opacity with parents */
if (parent != NULL)
{
guint8 opacity = clutter_actor_get_paint_opacity_internal (parent);
if (opacity != 0xff)
return (opacity * priv->opacity) / 0xff;
}
return priv->opacity;
}
/**
* clutter_actor_get_paint_opacity:
* @self: A #ClutterActor
*
* Retrieves the absolute opacity of the actor, as it appears on the stage.
*
* This function traverses the hierarchy chain and composites the opacity of
* the actor with that of its parents.
*
* This function is intended for subclasses to use in the paint virtual
* function, to paint themselves with the correct opacity.
*
* Return value: The actor opacity value.
*
* Since: 0.8
*/
guint8
clutter_actor_get_paint_opacity (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
return clutter_actor_get_paint_opacity_internal (self);
}
/**
* clutter_actor_get_opacity:
* @self: a #ClutterActor
*
* Retrieves the opacity value of an actor, as set by
* clutter_actor_set_opacity().
*
* For retrieving the absolute opacity of the actor inside a paint
* virtual function, see clutter_actor_get_paint_opacity().
*
* Return value: the opacity of the actor
*/
guint8
clutter_actor_get_opacity (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
return self->priv->opacity;
}
/**
* clutter_actor_set_offscreen_redirect:
* @self: A #ClutterActor
* @redirect: New offscreen redirect flags for the actor.
*
* Defines the circumstances where the actor should be redirected into
* an offscreen image. The offscreen image is used to flatten the
* actor into a single image while painting for two main reasons.
* Firstly, when the actor is painted a second time without any of its
* contents changing it can simply repaint the cached image without
* descending further down the actor hierarchy. Secondly, it will make
* the opacity look correct even if there are overlapping primitives
* in the actor.
*
* Caching the actor could in some cases be a performance win and in
* some cases be a performance lose so it is important to determine
* which value is right for an actor before modifying this value. For
* example, there is never any reason to flatten an actor that is just
* a single texture (such as a #ClutterTexture) because it is
* effectively already cached in an image so the offscreen would be
* redundant. Also if the actor contains primitives that are far apart
* with a large transparent area in the middle (such as a large
* CluterGroup with a small actor in the top left and a small actor in
* the bottom right) then the cached image will contain the entire
* image of the large area and the paint will waste time blending all
* of the transparent pixels in the middle.
*
* The default method of implementing opacity on a container simply
* forwards on the opacity to all of the children. If the children are
* overlapping then it will appear as if they are two separate glassy
* objects and there will be a break in the color where they
* overlap. By redirecting to an offscreen buffer it will be as if the
* two opaque objects are combined into one and then made transparent
* which is usually what is expected.
*
* The image below demonstrates the difference between redirecting and
* not. The image shows two Clutter groups, each containing a red and
* a green rectangle which overlap. The opacity on the group is set to
* 128 (which is 50%). When the offscreen redirect is not used, the
* red rectangle can be seen through the blue rectangle as if the two
* rectangles were separately transparent. When the redirect is used
* the group as a whole is transparent instead so the red rectangle is
* not visible where they overlap.
*
*
* Sample of using an offscreen redirect for transparency
* ![]()
*
*
* The default value for this property is 0, so we effectively will
* never redirect an actor offscreen by default. This means that there
* are times that transparent actors may look glassy as described
* above. The reason this is the default is because there is a
* performance trade off between quality and performance here. In many
* cases the default form of glassy opacity looks good enough, but if
* it's not you will need to set the
* %CLUTTER_OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY flag to enable
* redirection for opacity.
*
* Custom actors that don't contain any overlapping primitives are
* recommended to override the has_overlaps() virtual to return %FALSE
* for maximum efficiency.
*
* Since: 1.8
*/
void
clutter_actor_set_offscreen_redirect (ClutterActor *self,
ClutterOffscreenRedirect redirect)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
if (priv->offscreen_redirect != redirect)
{
priv->offscreen_redirect = redirect;
/* Queue a redraw from the effect so that it can use its cached
image if available instead of having to redraw the actual
actor. If it doesn't end up using the FBO then the effect is
still able to continue the paint anyway. If there is no
effect then this is equivalent to queuing a full redraw */
_clutter_actor_queue_redraw_full (self,
0, /* flags */
NULL, /* clip */
priv->flatten_effect);
g_object_notify_by_pspec (G_OBJECT (self),
obj_props[PROP_OFFSCREEN_REDIRECT]);
}
}
/**
* clutter_actor_get_offscreen_redirect:
* @self: a #ClutterActor
*
* Retrieves whether to redirect the actor to an offscreen buffer, as
* set by clutter_actor_set_offscreen_redirect().
*
* Return value: the value of the offscreen-redirect property of the actor
*
* Since: 1.8
*/
ClutterOffscreenRedirect
clutter_actor_get_offscreen_redirect (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
return self->priv->offscreen_redirect;
}
/**
* clutter_actor_set_name:
* @self: A #ClutterActor
* @name: Textual tag to apply to actor
*
* Sets the given name to @self. The name can be used to identify
* a #ClutterActor.
*/
void
clutter_actor_set_name (ClutterActor *self,
const gchar *name)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_free (self->priv->name);
self->priv->name = g_strdup (name);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_NAME]);
}
/**
* clutter_actor_get_name:
* @self: A #ClutterActor
*
* Retrieves the name of @self.
*
* Return value: the name of the actor, or %NULL. The returned string is
* owned by the actor and should not be modified or freed.
*/
const gchar *
clutter_actor_get_name (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
return self->priv->name;
}
static inline void
clutter_actor_set_depth_internal (ClutterActor *self,
float depth)
{
ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info (self);
if (info->z_position != depth)
{
/* Sets Z value - XXX 2.0: should we invert? */
info->z_position = depth;
self->priv->transform_valid = FALSE;
/* FIXME - remove this crap; sadly, there are still containers
* in Clutter that depend on this utter brain damage
*/
clutter_container_sort_depth_order (CLUTTER_CONTAINER (self));
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_DEPTH]);
}
}
static inline void
clutter_actor_set_z_position_internal (ClutterActor *self,
float z_position)
{
ClutterTransformInfo *info;
info = _clutter_actor_get_transform_info (self);
if (memcmp (&info->z_position, &z_position, sizeof (float)) != 0)
{
info->z_position = z_position;
self->priv->transform_valid = FALSE;
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_Z_POSITION]);
}
}
/**
* clutter_actor_set_z_position:
* @self: a #ClutterActor
* @z_position: the position on the Z axis
*
* Sets the actor's position on the Z axis.
*
* See #ClutterActor:z-position.
*
* Since: 1.12
*/
void
clutter_actor_set_z_position (ClutterActor *self,
gfloat z_position)
{
const ClutterTransformInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_transform_info_or_defaults (self);
_clutter_actor_create_transition (self, obj_props[PROP_Z_POSITION],
info->z_position,
z_position);
}
/**
* clutter_actor_get_z_position:
* @self: a #ClutterActor
*
* Retrieves the actor's position on the Z axis.
*
* Return value: the position on the Z axis.
*
* Since: 1.12
*/
gfloat
clutter_actor_get_z_position (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0.f);
return _clutter_actor_get_transform_info_or_defaults (self)->z_position;
}
/**
* clutter_actor_set_pivot_point:
* @self: a #ClutterActor
* @pivot_x: the normalized X coordinate of the pivot point
* @pivot_y: the normalized Y coordinate of the pivot point
*
* Sets the position of the #ClutterActor:pivot-point around which the
* scaling and rotation transformations occur.
*
* The pivot point's coordinates are in normalized space, with the (0, 0)
* point being the top left corner of the actor, and the (1, 1) point being
* the bottom right corner.
*
* Since: 1.12
*/
void
clutter_actor_set_pivot_point (ClutterActor *self,
gfloat pivot_x,
gfloat pivot_y)
{
graphene_point_t pivot = GRAPHENE_POINT_INIT (pivot_x, pivot_y);
const ClutterTransformInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_transform_info_or_defaults (self);
_clutter_actor_create_transition (self, obj_props[PROP_PIVOT_POINT],
&info->pivot,
&pivot);
}
/**
* clutter_actor_get_pivot_point:
* @self: a #ClutterActor
* @pivot_x: (out) (allow-none): return location for the normalized X
* coordinate of the pivot point, or %NULL
* @pivot_y: (out) (allow-none): return location for the normalized Y
* coordinate of the pivot point, or %NULL
*
* Retrieves the coordinates of the #ClutterActor:pivot-point.
*
* Since: 1.12
*/
void
clutter_actor_get_pivot_point (ClutterActor *self,
gfloat *pivot_x,
gfloat *pivot_y)
{
const ClutterTransformInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_transform_info_or_defaults (self);
if (pivot_x != NULL)
*pivot_x = info->pivot.x;
if (pivot_y != NULL)
*pivot_y = info->pivot.y;
}
/**
* clutter_actor_set_pivot_point_z:
* @self: a #ClutterActor
* @pivot_z: the Z coordinate of the actor's pivot point
*
* Sets the component on the Z axis of the #ClutterActor:pivot-point around
* which the scaling and rotation transformations occur.
*
* The @pivot_z value is expressed as a distance along the Z axis.
*
* Since: 1.12
*/
void
clutter_actor_set_pivot_point_z (ClutterActor *self,
gfloat pivot_z)
{
const ClutterTransformInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_transform_info_or_defaults (self);
_clutter_actor_create_transition (self, obj_props[PROP_PIVOT_POINT_Z],
info->pivot_z,
pivot_z);
}
/**
* clutter_actor_get_pivot_point_z:
* @self: a #ClutterActor
*
* Retrieves the Z component of the #ClutterActor:pivot-point.
*
* Since: 1.12
*/
gfloat
clutter_actor_get_pivot_point_z (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0.f);
return _clutter_actor_get_transform_info_or_defaults (self)->pivot_z;
}
/**
* clutter_actor_set_depth:
* @self: a #ClutterActor
* @depth: Z co-ord
*
* Sets the Z coordinate of @self to @depth.
*
* The unit used by @depth is dependant on the perspective setup. See
* also clutter_stage_set_perspective().
*
* Deprecated: 1.12: Use clutter_actor_set_z_position() instead.
*/
void
clutter_actor_set_depth (ClutterActor *self,
gfloat depth)
{
const ClutterTransformInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_transform_info_or_defaults (self);
_clutter_actor_create_transition (self, obj_props[PROP_DEPTH],
info->z_position,
depth);
}
/**
* clutter_actor_get_depth:
* @self: a #ClutterActor
*
* Retrieves the depth of @self.
*
* Return value: the depth of the actor
*
* Deprecated: 1.12: Use clutter_actor_get_z_position() instead.
*/
gfloat
clutter_actor_get_depth (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0.0);
return _clutter_actor_get_transform_info_or_defaults (self)->z_position;
}
/**
* clutter_actor_set_rotation:
* @self: a #ClutterActor
* @axis: the axis of rotation
* @angle: the angle of rotation
* @x: X coordinate of the rotation center
* @y: Y coordinate of the rotation center
* @z: Z coordinate of the rotation center
*
* Sets the rotation angle of @self around the given axis.
*
* The rotation center coordinates used depend on the value of @axis:
*
* - %CLUTTER_X_AXIS requires @y and @z
* - %CLUTTER_Y_AXIS requires @x and @z
* - %CLUTTER_Z_AXIS requires @x and @y
*
* The rotation coordinates are relative to the anchor point of the
* actor, set using clutter_actor_set_anchor_point(). If no anchor
* point is set, the upper left corner is assumed as the origin.
*
* Since: 0.8
*
* Deprecated: 1.12: Use clutter_actor_set_rotation_angle() and
* clutter_actor_set_pivot_point() instead.
*/
void
clutter_actor_set_rotation (ClutterActor *self,
ClutterRotateAxis axis,
gdouble angle,
gfloat x,
gfloat y,
gfloat z)
{
graphene_point3d_t v;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
v.x = x;
v.y = y;
v.z = z;
g_object_freeze_notify (G_OBJECT (self));
clutter_actor_set_rotation_angle (self, axis, angle);
clutter_actor_set_rotation_center_internal (self, axis, &v);
g_object_thaw_notify (G_OBJECT (self));
}
/**
* clutter_actor_set_z_rotation_from_gravity:
* @self: a #ClutterActor
* @angle: the angle of rotation
* @gravity: the center point of the rotation
*
* Sets the rotation angle of @self around the Z axis using the center
* point specified as a compass point. For example to rotate such that
* the center of the actor remains static you can use
* %CLUTTER_GRAVITY_CENTER. If the actor changes size the center point
* will move accordingly.
*
* Since: 1.0
*
* Deprecated: 1.12: Use clutter_actor_set_rotation_angle() and
* clutter_actor_set_pivot_point() instead.
*/
void
clutter_actor_set_z_rotation_from_gravity (ClutterActor *self,
gdouble angle,
ClutterGravity gravity)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (gravity == CLUTTER_GRAVITY_NONE)
clutter_actor_set_rotation (self, CLUTTER_Z_AXIS, angle, 0, 0, 0);
else
{
GObject *obj = G_OBJECT (self);
ClutterTransformInfo *info;
GParamSpec *pspec;
pspec = obj_props[PROP_ROTATION_ANGLE_Z];
info = _clutter_actor_get_transform_info (self);
g_object_freeze_notify (obj);
clutter_actor_set_rotation_angle_internal (self, angle, pspec);
clutter_anchor_coord_set_gravity (&info->rz_center, gravity);
g_object_notify_by_pspec (obj, obj_props[PROP_ROTATION_CENTER_Z_GRAVITY]);
g_object_notify_by_pspec (obj, obj_props[PROP_ROTATION_CENTER_Z]);
g_object_thaw_notify (obj);
}
}
/**
* clutter_actor_get_rotation:
* @self: a #ClutterActor
* @axis: the axis of rotation
* @x: (out): return value for the X coordinate of the center of rotation
* @y: (out): return value for the Y coordinate of the center of rotation
* @z: (out): return value for the Z coordinate of the center of rotation
*
* Retrieves the angle and center of rotation on the given axis,
* set using clutter_actor_set_rotation().
*
* Return value: the angle of rotation
*
* Since: 0.8
*
* Deprecated: 1.12: Use clutter_actor_get_rotation_angle() and
* clutter_actor_get_pivot_point() instead.
*/
gdouble
clutter_actor_get_rotation (ClutterActor *self,
ClutterRotateAxis axis,
gfloat *x,
gfloat *y,
gfloat *z)
{
const ClutterTransformInfo *info;
const AnchorCoord *anchor_coord;
gdouble retval = 0;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
info = _clutter_actor_get_transform_info_or_defaults (self);
switch (axis)
{
case CLUTTER_X_AXIS:
anchor_coord = &info->rx_center;
retval = info->rx_angle;
break;
case CLUTTER_Y_AXIS:
anchor_coord = &info->ry_center;
retval = info->ry_angle;
break;
case CLUTTER_Z_AXIS:
anchor_coord = &info->rz_center;
retval = info->rz_angle;
break;
default:
anchor_coord = NULL;
retval = 0.0;
break;
}
clutter_anchor_coord_get_units (self, anchor_coord, x, y, z);
return retval;
}
/**
* clutter_actor_get_z_rotation_gravity:
* @self: A #ClutterActor
*
* Retrieves the center for the rotation around the Z axis as a
* compass direction. If the center was specified in pixels or units
* this will return %CLUTTER_GRAVITY_NONE.
*
* Return value: the Z rotation center
*
* Since: 1.0
*
* Deprecated: 1.12: Use the #ClutterActor:pivot-point instead of
* a #ClutterGravity
*/
ClutterGravity
clutter_actor_get_z_rotation_gravity (ClutterActor *self)
{
const ClutterTransformInfo *info;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), CLUTTER_GRAVITY_NONE);
info = _clutter_actor_get_transform_info_or_defaults (self);
return clutter_anchor_coord_get_gravity (&info->rz_center);
}
/**
* clutter_actor_set_clip:
* @self: A #ClutterActor
* @xoff: X offset of the clip rectangle
* @yoff: Y offset of the clip rectangle
* @width: Width of the clip rectangle
* @height: Height of the clip rectangle
*
* Sets clip area for @self. The clip area is always computed from the
* upper left corner of the actor, even if the anchor point is set
* otherwise.
*
* Since: 0.6
*/
void
clutter_actor_set_clip (ClutterActor *self,
gfloat xoff,
gfloat yoff,
gfloat width,
gfloat height)
{
ClutterActorPrivate *priv;
GObject *obj;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
if (priv->has_clip &&
priv->clip.origin.x == xoff &&
priv->clip.origin.y == yoff &&
priv->clip.size.width == width &&
priv->clip.size.height == height)
return;
obj = G_OBJECT (self);
priv->clip.origin.x = xoff;
priv->clip.origin.y = yoff;
priv->clip.size.width = width;
priv->clip.size.height = height;
priv->has_clip = TRUE;
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (obj, obj_props[PROP_CLIP_RECT]);
g_object_notify_by_pspec (obj, obj_props[PROP_HAS_CLIP]);
}
/**
* clutter_actor_remove_clip:
* @self: A #ClutterActor
*
* Removes clip area from @self.
*/
void
clutter_actor_remove_clip (ClutterActor *self)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (!self->priv->has_clip)
return;
self->priv->has_clip = FALSE;
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_HAS_CLIP]);
}
/**
* clutter_actor_has_clip:
* @self: a #ClutterActor
*
* Determines whether the actor has a clip area set or not.
*
* Return value: %TRUE if the actor has a clip area set.
*
* Since: 0.2
*/
gboolean
clutter_actor_has_clip (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
return self->priv->has_clip;
}
/**
* clutter_actor_get_clip:
* @self: a #ClutterActor
* @xoff: (out) (allow-none): return location for the X offset of
* the clip rectangle, or %NULL
* @yoff: (out) (allow-none): return location for the Y offset of
* the clip rectangle, or %NULL
* @width: (out) (allow-none): return location for the width of
* the clip rectangle, or %NULL
* @height: (out) (allow-none): return location for the height of
* the clip rectangle, or %NULL
*
* Gets the clip area for @self, if any is set.
*
* Since: 0.6
*/
void
clutter_actor_get_clip (ClutterActor *self,
gfloat *xoff,
gfloat *yoff,
gfloat *width,
gfloat *height)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
if (!priv->has_clip)
return;
if (xoff != NULL)
*xoff = priv->clip.origin.x;
if (yoff != NULL)
*yoff = priv->clip.origin.y;
if (width != NULL)
*width = priv->clip.size.width;
if (height != NULL)
*height = priv->clip.size.height;
}
/**
* clutter_actor_get_children:
* @self: a #ClutterActor
*
* Retrieves the list of children of @self.
*
* Return value: (transfer container) (element-type ClutterActor): A newly
* allocated #GList of #ClutterActors. Use g_list_free() when
* done.
*
* Since: 1.10
*/
GList *
clutter_actor_get_children (ClutterActor *self)
{
ClutterActor *iter;
GList *res;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
/* we walk the list backward so that we can use prepend(),
* which is O(1)
*/
for (iter = self->priv->last_child, res = NULL;
iter != NULL;
iter = iter->priv->prev_sibling)
{
res = g_list_prepend (res, iter);
}
return res;
}
/*< private >
* insert_child_at_depth:
* @self: a #ClutterActor
* @child: a #ClutterActor
*
* Inserts @child inside the list of children held by @self, using
* the depth as the insertion criteria.
*
* This sadly makes the insertion not O(1), but we can keep the
* list sorted so that the painters algorithm we use for painting
* the children will work correctly.
*/
static void
insert_child_at_depth (ClutterActor *self,
ClutterActor *child,
gpointer dummy G_GNUC_UNUSED)
{
ClutterActor *iter;
float child_depth;
child->priv->parent = self;
child_depth =
_clutter_actor_get_transform_info_or_defaults (child)->z_position;
/* special-case the first child */
if (self->priv->n_children == 0)
{
self->priv->first_child = child;
self->priv->last_child = child;
child->priv->next_sibling = NULL;
child->priv->prev_sibling = NULL;
return;
}
/* Find the right place to insert the child so that it will still be
sorted and the child will be after all of the actors at the same
dept */
for (iter = self->priv->first_child;
iter != NULL;
iter = iter->priv->next_sibling)
{
float iter_depth;
iter_depth =
_clutter_actor_get_transform_info_or_defaults (iter)->z_position;
if (iter_depth > child_depth)
break;
}
if (iter != NULL)
{
ClutterActor *tmp = iter->priv->prev_sibling;
if (tmp != NULL)
tmp->priv->next_sibling = child;
/* Insert the node before the found one */
child->priv->prev_sibling = iter->priv->prev_sibling;
child->priv->next_sibling = iter;
iter->priv->prev_sibling = child;
}
else
{
ClutterActor *tmp = self->priv->last_child;
if (tmp != NULL)
tmp->priv->next_sibling = child;
/* insert the node at the end of the list */
child->priv->prev_sibling = self->priv->last_child;
child->priv->next_sibling = NULL;
}
if (child->priv->prev_sibling == NULL)
self->priv->first_child = child;
if (child->priv->next_sibling == NULL)
self->priv->last_child = child;
}
static void
insert_child_at_index (ClutterActor *self,
ClutterActor *child,
gpointer data_)
{
gint index_ = GPOINTER_TO_INT (data_);
child->priv->parent = self;
if (index_ == 0)
{
ClutterActor *tmp = self->priv->first_child;
if (tmp != NULL)
tmp->priv->prev_sibling = child;
child->priv->prev_sibling = NULL;
child->priv->next_sibling = tmp;
}
else if (index_ < 0 || index_ >= self->priv->n_children)
{
ClutterActor *tmp = self->priv->last_child;
if (tmp != NULL)
tmp->priv->next_sibling = child;
child->priv->prev_sibling = tmp;
child->priv->next_sibling = NULL;
}
else
{
ClutterActor *iter;
int i;
for (iter = self->priv->first_child, i = 0;
iter != NULL;
iter = iter->priv->next_sibling, i += 1)
{
if (index_ == i)
{
ClutterActor *tmp = iter->priv->prev_sibling;
child->priv->prev_sibling = tmp;
child->priv->next_sibling = iter;
iter->priv->prev_sibling = child;
if (tmp != NULL)
tmp->priv->next_sibling = child;
break;
}
}
}
if (child->priv->prev_sibling == NULL)
self->priv->first_child = child;
if (child->priv->next_sibling == NULL)
self->priv->last_child = child;
}
static void
insert_child_above (ClutterActor *self,
ClutterActor *child,
gpointer data)
{
ClutterActor *sibling = data;
child->priv->parent = self;
if (sibling == NULL)
sibling = self->priv->last_child;
child->priv->prev_sibling = sibling;
if (sibling != NULL)
{
ClutterActor *tmp = sibling->priv->next_sibling;
child->priv->next_sibling = tmp;
if (tmp != NULL)
tmp->priv->prev_sibling = child;
sibling->priv->next_sibling = child;
}
else
child->priv->next_sibling = NULL;
if (child->priv->prev_sibling == NULL)
self->priv->first_child = child;
if (child->priv->next_sibling == NULL)
self->priv->last_child = child;
}
static void
insert_child_below (ClutterActor *self,
ClutterActor *child,
gpointer data)
{
ClutterActor *sibling = data;
child->priv->parent = self;
if (sibling == NULL)
sibling = self->priv->first_child;
child->priv->next_sibling = sibling;
if (sibling != NULL)
{
ClutterActor *tmp = sibling->priv->prev_sibling;
child->priv->prev_sibling = tmp;
if (tmp != NULL)
tmp->priv->next_sibling = child;
sibling->priv->prev_sibling = child;
}
else
child->priv->prev_sibling = NULL;
if (child->priv->prev_sibling == NULL)
self->priv->first_child = child;
if (child->priv->next_sibling == NULL)
self->priv->last_child = child;
}
typedef void (* ClutterActorAddChildFunc) (ClutterActor *parent,
ClutterActor *child,
gpointer data);
typedef enum
{
ADD_CHILD_CREATE_META = 1 << 0,
ADD_CHILD_EMIT_PARENT_SET = 1 << 1,
ADD_CHILD_EMIT_ACTOR_ADDED = 1 << 2,
ADD_CHILD_CHECK_STATE = 1 << 3,
ADD_CHILD_NOTIFY_FIRST_LAST = 1 << 4,
ADD_CHILD_SHOW_ON_SET_PARENT = 1 << 5,
/* default flags for public API */
ADD_CHILD_DEFAULT_FLAGS = ADD_CHILD_CREATE_META |
ADD_CHILD_EMIT_PARENT_SET |
ADD_CHILD_EMIT_ACTOR_ADDED |
ADD_CHILD_CHECK_STATE |
ADD_CHILD_NOTIFY_FIRST_LAST |
ADD_CHILD_SHOW_ON_SET_PARENT,
/* flags for legacy/deprecated API */
ADD_CHILD_LEGACY_FLAGS = ADD_CHILD_EMIT_PARENT_SET |
ADD_CHILD_CHECK_STATE |
ADD_CHILD_NOTIFY_FIRST_LAST |
ADD_CHILD_SHOW_ON_SET_PARENT
} ClutterActorAddChildFlags;
/*< private >
* clutter_actor_add_child_internal:
* @self: a #ClutterActor
* @child: a #ClutterActor
* @flags: control flags for actions
* @add_func (closure data): delegate function
* @data: data to pass to @add_func
*
* Adds @child to the list of children of @self.
*
* The actual insertion inside the list is delegated to @add_func: this
* function will just set up the state, perform basic checks, and emit
* signals.
*
* The @flags argument is used to perform additional operations.
*/
static inline void
clutter_actor_add_child_internal (ClutterActor *self,
ClutterActor *child,
ClutterActorAddChildFlags flags,
ClutterActorAddChildFunc add_func,
gpointer data)
{
ClutterTextDirection text_dir;
gboolean create_meta;
gboolean emit_parent_set, emit_actor_added;
gboolean check_state;
gboolean notify_first_last;
gboolean show_on_set_parent;
ClutterActor *old_first_child, *old_last_child;
GObject *obj;
if (self == child)
{
g_warning ("Cannot add the actor '%s' to itself.",
_clutter_actor_get_debug_name (self));
return;
}
if (child->priv->parent != NULL)
{
g_warning ("The actor '%s' already has a parent, '%s'. You must "
"use clutter_actor_remove_child() first.",
_clutter_actor_get_debug_name (child),
_clutter_actor_get_debug_name (child->priv->parent));
return;
}
if (CLUTTER_ACTOR_IS_TOPLEVEL (child))
{
g_warning ("The actor '%s' is a top-level actor, and cannot be "
"a child of another actor.",
_clutter_actor_get_debug_name (child));
return;
}
/* the following check disallows calling methods that change the stacking
* order within the destruction sequence, by triggering a critical
* warning first, and leaving the actor in an undefined state, which
* then ends up being caught by an assertion.
*
* the reproducible sequence is:
*
* - actor gets destroyed;
* - another actor, linked to the first, will try to change the
* stacking order of the first actor;
* - changing the stacking order is a composite operation composed
* by the following steps:
* 1. ref() the child;
* 2. remove_child_internal(), which removes the reference;
* 3. add_child_internal(), which adds a reference;
* - the state of the actor is not changed between (2) and (3), as
* it could be an expensive recomputation;
* - if (3) bails out, then the actor is in an undefined state, but
* still alive;
* - the destruction sequence terminates, but the actor is unparented
* while its state indicates being parented instead.
* - assertion failure.
*
* the obvious fix would be to decompose each set_child_*_sibling()
* method into proper remove_child()/add_child(), with state validation;
* this may cause excessive work, though, and trigger a cascade of other
* bugs in code that assumes that a change in the stacking order is an
* atomic operation.
*
* another potential fix is to just remove this check here, and let
* code doing stacking order changes inside the destruction sequence
* of an actor continue doing the stacking changes as before; this
* option still performs more work than necessary.
*
* the third fix is to silently bail out early from every
* set_child_*_sibling() and set_child_at_index() method, and avoid
* doing stack changes altogether; Clutter implements this last option.
*
* see bug: https://bugzilla.gnome.org/show_bug.cgi?id=670647
*/
if (CLUTTER_ACTOR_IN_DESTRUCTION (child))
{
g_warning ("The actor '%s' is currently being destroyed, and "
"cannot be added as a child of another actor.",
_clutter_actor_get_debug_name (child));
return;
}
create_meta = (flags & ADD_CHILD_CREATE_META) != 0;
emit_parent_set = (flags & ADD_CHILD_EMIT_PARENT_SET) != 0;
emit_actor_added = (flags & ADD_CHILD_EMIT_ACTOR_ADDED) != 0;
check_state = (flags & ADD_CHILD_CHECK_STATE) != 0;
notify_first_last = (flags & ADD_CHILD_NOTIFY_FIRST_LAST) != 0;
show_on_set_parent = (flags & ADD_CHILD_SHOW_ON_SET_PARENT) != 0;
old_first_child = self->priv->first_child;
old_last_child = self->priv->last_child;
obj = G_OBJECT (self);
g_object_freeze_notify (obj);
if (create_meta)
clutter_container_create_child_meta (CLUTTER_CONTAINER (self), child);
g_object_ref_sink (child);
child->priv->parent = NULL;
child->priv->next_sibling = NULL;
child->priv->prev_sibling = NULL;
/* delegate the actual insertion */
add_func (self, child, data);
g_assert (child->priv->parent == self);
self->priv->n_children += 1;
self->priv->age += 1;
if (self->priv->in_cloned_branch)
clutter_actor_push_in_cloned_branch (child, self->priv->in_cloned_branch);
/* children may cause their parent to expand, if they are set
* to expand; if a child is not expanded then it cannot change
* its parent's state. any further change later on will queue
* an expand state check.
*
* this check, with the initial state of the needs_compute_expand
* flag set to FALSE, should avoid recomputing the expand flags
* state while building the actor tree.
*/
if (CLUTTER_ACTOR_IS_VISIBLE (child) &&
(child->priv->needs_compute_expand ||
child->priv->needs_x_expand ||
child->priv->needs_y_expand))
{
clutter_actor_queue_compute_expand (self);
}
if (emit_parent_set && !CLUTTER_ACTOR_IN_REPARENT (child))
{
child->priv->needs_compute_resource_scale = TRUE;
g_signal_emit (child, actor_signals[PARENT_SET], 0, NULL);
}
if (check_state)
{
/* If parent is mapped or realized, we need to also be mapped or
* realized once we're inside the parent.
*/
clutter_actor_update_map_state (child, MAP_STATE_CHECK);
/* propagate the parent's text direction to the child */
text_dir = clutter_actor_get_text_direction (self);
clutter_actor_set_text_direction (child, text_dir);
}
/* this may end up queueing a redraw, in case the actor is
* not visible but the show-on-set-parent property is still
* set.
*
* XXX:2.0 - remove this check and unconditionally show() the
* actor once we remove the show-on-set-parent property
*/
if (show_on_set_parent && child->priv->show_on_set_parent)
clutter_actor_show (child);
/* on the other hand, this will catch any other case where
* the actor is supposed to be visible when it's added
*/
if (CLUTTER_ACTOR_IS_MAPPED (child))
clutter_actor_queue_redraw (child);
/* maintain the invariant that if an actor needs layout,
* its parents do as well
*/
if (clutter_actor_needs_relayout (child))
{
/* we work around the short-circuiting we do
* in clutter_actor_queue_relayout() since we
* want to force a relayout
*/
child->priv->needs_width_request = TRUE;
child->priv->needs_height_request = TRUE;
child->priv->needs_allocation = TRUE;
if (CLUTTER_ACTOR_IS_MAPPED (child))
child->priv->needs_paint_volume_update = TRUE;
/* we only queue a relayout here, because any possible
* redraw has already been queued either by show() or
* by our call to queue_redraw() above
*/
_clutter_actor_queue_only_relayout (child->priv->parent);
}
if (emit_actor_added)
_clutter_container_emit_actor_added (CLUTTER_CONTAINER (self), child);
if (notify_first_last)
{
if (old_first_child != self->priv->first_child)
g_object_notify_by_pspec (obj, obj_props[PROP_FIRST_CHILD]);
if (old_last_child != self->priv->last_child)
g_object_notify_by_pspec (obj, obj_props[PROP_LAST_CHILD]);
}
g_object_thaw_notify (obj);
}
/**
* clutter_actor_add_child:
* @self: a #ClutterActor
* @child: a #ClutterActor
*
* Adds @child to the children of @self.
*
* This function will acquire a reference on @child that will only
* be released when calling clutter_actor_remove_child().
*
* This function will take into consideration the #ClutterActor:depth
* of @child, and will keep the list of children sorted.
*
* This function will emit the #ClutterContainer::actor-added signal
* on @self.
*
* Since: 1.10
*/
void
clutter_actor_add_child (ClutterActor *self,
ClutterActor *child)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
g_return_if_fail (self != child);
g_return_if_fail (child->priv->parent == NULL);
clutter_actor_add_child_internal (self, child,
ADD_CHILD_DEFAULT_FLAGS,
insert_child_at_depth,
NULL);
}
/**
* clutter_actor_insert_child_at_index:
* @self: a #ClutterActor
* @child: a #ClutterActor
* @index_: the index
*
* Inserts @child into the list of children of @self, using the
* given @index_. If @index_ is greater than the number of children
* in @self, or is less than 0, then the new child is added at the end.
*
* This function will acquire a reference on @child that will only
* be released when calling clutter_actor_remove_child().
*
* This function will not take into consideration the #ClutterActor:depth
* of @child.
*
* This function will emit the #ClutterContainer::actor-added signal
* on @self.
*
* Since: 1.10
*/
void
clutter_actor_insert_child_at_index (ClutterActor *self,
ClutterActor *child,
gint index_)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
g_return_if_fail (self != child);
g_return_if_fail (child->priv->parent == NULL);
clutter_actor_add_child_internal (self, child,
ADD_CHILD_DEFAULT_FLAGS,
insert_child_at_index,
GINT_TO_POINTER (index_));
}
/**
* clutter_actor_insert_child_above:
* @self: a #ClutterActor
* @child: a #ClutterActor
* @sibling: (allow-none): a child of @self, or %NULL
*
* Inserts @child into the list of children of @self, above another
* child of @self or, if @sibling is %NULL, above all the children
* of @self.
*
* This function will acquire a reference on @child that will only
* be released when calling clutter_actor_remove_child().
*
* This function will not take into consideration the #ClutterActor:depth
* of @child.
*
* This function will emit the #ClutterContainer::actor-added signal
* on @self.
*
* Since: 1.10
*/
void
clutter_actor_insert_child_above (ClutterActor *self,
ClutterActor *child,
ClutterActor *sibling)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
g_return_if_fail (self != child);
g_return_if_fail (child != sibling);
g_return_if_fail (child->priv->parent == NULL);
g_return_if_fail (sibling == NULL ||
(CLUTTER_IS_ACTOR (sibling) &&
sibling->priv->parent == self));
clutter_actor_add_child_internal (self, child,
ADD_CHILD_DEFAULT_FLAGS,
insert_child_above,
sibling);
}
/**
* clutter_actor_insert_child_below:
* @self: a #ClutterActor
* @child: a #ClutterActor
* @sibling: (allow-none): a child of @self, or %NULL
*
* Inserts @child into the list of children of @self, below another
* child of @self or, if @sibling is %NULL, below all the children
* of @self.
*
* This function will acquire a reference on @child that will only
* be released when calling clutter_actor_remove_child().
*
* This function will not take into consideration the #ClutterActor:depth
* of @child.
*
* This function will emit the #ClutterContainer::actor-added signal
* on @self.
*
* Since: 1.10
*/
void
clutter_actor_insert_child_below (ClutterActor *self,
ClutterActor *child,
ClutterActor *sibling)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
g_return_if_fail (self != child);
g_return_if_fail (child != sibling);
g_return_if_fail (child->priv->parent == NULL);
g_return_if_fail (sibling == NULL ||
(CLUTTER_IS_ACTOR (sibling) &&
sibling->priv->parent == self));
clutter_actor_add_child_internal (self, child,
ADD_CHILD_DEFAULT_FLAGS,
insert_child_below,
sibling);
}
/**
* clutter_actor_set_parent:
* @self: A #ClutterActor
* @parent: A new #ClutterActor parent
*
* Sets the parent of @self to @parent.
*
* This function will result in @parent acquiring a reference on @self,
* eventually by sinking its floating reference first. The reference
* will be released by clutter_actor_unparent().
*
* This function should only be called by legacy #ClutterActors
* implementing the #ClutterContainer interface.
*
* Deprecated: 1.10: Use clutter_actor_add_child() instead.
*/
void
clutter_actor_set_parent (ClutterActor *self,
ClutterActor *parent)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_ACTOR (parent));
g_return_if_fail (self != parent);
g_return_if_fail (self->priv->parent == NULL);
/* as this function will be called inside ClutterContainer::add
* implementations or when building up a composite actor, we have
* to preserve the old behaviour, and not create child meta or
* emit the ::actor-added signal, to avoid recursion or double
* emissions
*/
clutter_actor_add_child_internal (parent, self,
ADD_CHILD_LEGACY_FLAGS,
insert_child_at_depth,
NULL);
}
/**
* clutter_actor_get_parent:
* @self: A #ClutterActor
*
* Retrieves the parent of @self.
*
* Return Value: (transfer none): The #ClutterActor parent, or %NULL
* if no parent is set
*/
ClutterActor *
clutter_actor_get_parent (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
return self->priv->parent;
}
/**
* clutter_actor_get_paint_visibility:
* @self: A #ClutterActor
*
* Retrieves the 'paint' visibility of an actor recursively checking for non
* visible parents.
*
* This is by definition the same as %CLUTTER_ACTOR_IS_MAPPED.
*
* Return Value: %TRUE if the actor is visibile and will be painted.
*
* Since: 0.8
*/
gboolean
clutter_actor_get_paint_visibility (ClutterActor *actor)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), FALSE);
return CLUTTER_ACTOR_IS_MAPPED (actor);
}
/**
* clutter_actor_remove_child:
* @self: a #ClutterActor
* @child: a #ClutterActor
*
* Removes @child from the children of @self.
*
* This function will release the reference added by
* clutter_actor_add_child(), so if you want to keep using @child
* you will have to acquire a referenced on it before calling this
* function.
*
* This function will emit the #ClutterContainer::actor-removed
* signal on @self.
*
* Since: 1.10
*/
void
clutter_actor_remove_child (ClutterActor *self,
ClutterActor *child)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
g_return_if_fail (self != child);
g_return_if_fail (child->priv->parent != NULL);
g_return_if_fail (child->priv->parent == self);
clutter_actor_remove_child_internal (self, child,
REMOVE_CHILD_DEFAULT_FLAGS);
}
/**
* clutter_actor_remove_all_children:
* @self: a #ClutterActor
*
* Removes all children of @self.
*
* This function releases the reference added by inserting a child actor
* in the list of children of @self.
*
* If the reference count of a child drops to zero, the child will be
* destroyed. If you want to ensure the destruction of all the children
* of @self, use clutter_actor_destroy_all_children().
*
* Since: 1.10
*/
void
clutter_actor_remove_all_children (ClutterActor *self)
{
ClutterActorIter iter;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (self->priv->n_children == 0)
return;
g_object_freeze_notify (G_OBJECT (self));
clutter_actor_iter_init (&iter, self);
while (clutter_actor_iter_next (&iter, NULL))
clutter_actor_iter_remove (&iter);
g_object_thaw_notify (G_OBJECT (self));
/* sanity check */
g_assert (self->priv->first_child == NULL);
g_assert (self->priv->last_child == NULL);
g_assert (self->priv->n_children == 0);
}
/**
* clutter_actor_destroy_all_children:
* @self: a #ClutterActor
*
* Destroys all children of @self.
*
* This function releases the reference added by inserting a child
* actor in the list of children of @self, and ensures that the
* #ClutterActor::destroy signal is emitted on each child of the
* actor.
*
* By default, #ClutterActor will emit the #ClutterActor::destroy signal
* when its reference count drops to 0; the default handler of the
* #ClutterActor::destroy signal will destroy all the children of an
* actor. This function ensures that all children are destroyed, instead
* of just removed from @self, unlike clutter_actor_remove_all_children()
* which will merely release the reference and remove each child.
*
* Unless you acquired an additional reference on each child of @self
* prior to calling clutter_actor_remove_all_children() and want to reuse
* the actors, you should use clutter_actor_destroy_all_children() in
* order to make sure that children are destroyed and signal handlers
* are disconnected even in cases where circular references prevent this
* from automatically happening through reference counting alone.
*
* Since: 1.10
*/
void
clutter_actor_destroy_all_children (ClutterActor *self)
{
ClutterActorIter iter;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (self->priv->n_children == 0)
return;
g_object_freeze_notify (G_OBJECT (self));
clutter_actor_iter_init (&iter, self);
while (clutter_actor_iter_next (&iter, NULL))
clutter_actor_iter_destroy (&iter);
g_object_thaw_notify (G_OBJECT (self));
/* sanity check */
g_assert (self->priv->first_child == NULL);
g_assert (self->priv->last_child == NULL);
g_assert (self->priv->n_children == 0);
}
typedef struct _InsertBetweenData {
ClutterActor *prev_sibling;
ClutterActor *next_sibling;
} InsertBetweenData;
static void
insert_child_between (ClutterActor *self,
ClutterActor *child,
gpointer data_)
{
InsertBetweenData *data = data_;
ClutterActor *prev_sibling = data->prev_sibling;
ClutterActor *next_sibling = data->next_sibling;
child->priv->parent = self;
child->priv->prev_sibling = prev_sibling;
child->priv->next_sibling = next_sibling;
if (prev_sibling != NULL)
prev_sibling->priv->next_sibling = child;
if (next_sibling != NULL)
next_sibling->priv->prev_sibling = child;
if (child->priv->prev_sibling == NULL)
self->priv->first_child = child;
if (child->priv->next_sibling == NULL)
self->priv->last_child = child;
}
/**
* clutter_actor_replace_child:
* @self: a #ClutterActor
* @old_child: the child of @self to replace
* @new_child: the #ClutterActor to replace @old_child
*
* Replaces @old_child with @new_child in the list of children of @self.
*
* Since: 1.10
*/
void
clutter_actor_replace_child (ClutterActor *self,
ClutterActor *old_child,
ClutterActor *new_child)
{
ClutterActor *prev_sibling, *next_sibling;
InsertBetweenData clos;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_ACTOR (old_child));
g_return_if_fail (old_child->priv->parent == self);
g_return_if_fail (CLUTTER_IS_ACTOR (new_child));
g_return_if_fail (old_child != new_child);
g_return_if_fail (new_child != self);
g_return_if_fail (new_child->priv->parent == NULL);
prev_sibling = old_child->priv->prev_sibling;
next_sibling = old_child->priv->next_sibling;
clutter_actor_remove_child_internal (self, old_child,
REMOVE_CHILD_DEFAULT_FLAGS);
clos.prev_sibling = prev_sibling;
clos.next_sibling = next_sibling;
clutter_actor_add_child_internal (self, new_child,
ADD_CHILD_DEFAULT_FLAGS,
insert_child_between,
&clos);
}
/**
* clutter_actor_unparent:
* @self: a #ClutterActor
*
* Removes the parent of @self.
*
* This will cause the parent of @self to release the reference
* acquired when calling clutter_actor_set_parent(), so if you
* want to keep @self you will have to acquire a reference of
* your own, through g_object_ref().
*
* This function should only be called by legacy #ClutterActors
* implementing the #ClutterContainer interface.
*
* Since: 0.2
*
* Deprecated: 1.10: Use clutter_actor_remove_child() instead.
*/
void
clutter_actor_unparent (ClutterActor *self)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (self->priv->parent == NULL)
return;
clutter_actor_remove_child_internal (self->priv->parent, self,
REMOVE_CHILD_LEGACY_FLAGS);
}
/**
* clutter_actor_contains:
* @self: A #ClutterActor
* @descendant: A #ClutterActor, possibly contained in @self
*
* Determines if @descendant is contained inside @self (either as an
* immediate child, or as a deeper descendant). If @self and
* @descendant point to the same actor then it will also return %TRUE.
*
* Return value: whether @descendent is contained within @self
*
* Since: 1.4
*/
gboolean
clutter_actor_contains (ClutterActor *self,
ClutterActor *descendant)
{
ClutterActor *actor;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
g_return_val_if_fail (CLUTTER_IS_ACTOR (descendant), FALSE);
for (actor = descendant; actor; actor = actor->priv->parent)
if (actor == self)
return TRUE;
return FALSE;
}
/**
* clutter_actor_set_child_above_sibling:
* @self: a #ClutterActor
* @child: a #ClutterActor child of @self
* @sibling: (allow-none): a #ClutterActor child of @self, or %NULL
*
* Sets @child to be above @sibling in the list of children of @self.
*
* If @sibling is %NULL, @child will be the new last child of @self.
*
* This function is logically equivalent to removing @child and using
* clutter_actor_insert_child_above(), but it will not emit signals
* or change state on @child.
*
* Since: 1.10
*/
void
clutter_actor_set_child_above_sibling (ClutterActor *self,
ClutterActor *child,
ClutterActor *sibling)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
g_return_if_fail (child->priv->parent == self);
g_return_if_fail (child != sibling);
g_return_if_fail (sibling == NULL || CLUTTER_IS_ACTOR (sibling));
if (sibling != NULL)
g_return_if_fail (sibling->priv->parent == self);
if (CLUTTER_ACTOR_IN_DESTRUCTION (self) ||
CLUTTER_ACTOR_IN_DESTRUCTION (child) ||
(sibling != NULL && CLUTTER_ACTOR_IN_DESTRUCTION (sibling)))
return;
/* we don't want to change the state of child, or emit signals, or
* regenerate ChildMeta instances here, but we still want to follow
* the correct sequence of steps encoded in remove_child() and
* add_child(), so that correctness is ensured, and we only go
* through one known code path.
*/
g_object_ref (child);
clutter_actor_remove_child_internal (self, child, 0);
clutter_actor_add_child_internal (self, child,
ADD_CHILD_NOTIFY_FIRST_LAST,
insert_child_above,
sibling);
g_object_unref(child);
clutter_actor_queue_redraw_on_parent (child);
}
/**
* clutter_actor_set_child_below_sibling:
* @self: a #ClutterActor
* @child: a #ClutterActor child of @self
* @sibling: (allow-none): a #ClutterActor child of @self, or %NULL
*
* Sets @child to be below @sibling in the list of children of @self.
*
* If @sibling is %NULL, @child will be the new first child of @self.
*
* This function is logically equivalent to removing @self and using
* clutter_actor_insert_child_below(), but it will not emit signals
* or change state on @child.
*
* Since: 1.10
*/
void
clutter_actor_set_child_below_sibling (ClutterActor *self,
ClutterActor *child,
ClutterActor *sibling)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
g_return_if_fail (child->priv->parent == self);
g_return_if_fail (child != sibling);
g_return_if_fail (sibling == NULL || CLUTTER_IS_ACTOR (sibling));
if (sibling != NULL)
g_return_if_fail (sibling->priv->parent == self);
if (CLUTTER_ACTOR_IN_DESTRUCTION (self) ||
CLUTTER_ACTOR_IN_DESTRUCTION (child) ||
(sibling != NULL && CLUTTER_ACTOR_IN_DESTRUCTION (sibling)))
return;
/* see the comment in set_child_above_sibling() */
g_object_ref (child);
clutter_actor_remove_child_internal (self, child, 0);
clutter_actor_add_child_internal (self, child,
ADD_CHILD_NOTIFY_FIRST_LAST,
insert_child_below,
sibling);
g_object_unref(child);
clutter_actor_queue_redraw_on_parent (child);
}
/**
* clutter_actor_set_child_at_index:
* @self: a #ClutterActor
* @child: a #ClutterActor child of @self
* @index_: the new index for @child
*
* Changes the index of @child in the list of children of @self.
*
* This function is logically equivalent to removing @child and
* calling clutter_actor_insert_child_at_index(), but it will not
* emit signals or change state on @child.
*
* Since: 1.10
*/
void
clutter_actor_set_child_at_index (ClutterActor *self,
ClutterActor *child,
gint index_)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_ACTOR (child));
g_return_if_fail (child->priv->parent == self);
g_return_if_fail (index_ <= self->priv->n_children);
if (CLUTTER_ACTOR_IN_DESTRUCTION (self) ||
CLUTTER_ACTOR_IN_DESTRUCTION (child))
return;
g_object_ref (child);
clutter_actor_remove_child_internal (self, child, 0);
clutter_actor_add_child_internal (self, child,
ADD_CHILD_NOTIFY_FIRST_LAST,
insert_child_at_index,
GINT_TO_POINTER (index_));
g_object_unref (child);
clutter_actor_queue_relayout (self);
}
/*
* Event handling
*/
/**
* clutter_actor_event:
* @actor: a #ClutterActor
* @event: a #ClutterEvent
* @capture: %TRUE if event in in capture phase, %FALSE otherwise.
*
* This function is used to emit an event on the main stage.
* You should rarely need to use this function, except for
* synthetising events.
*
* Return value: the return value from the signal emission: %TRUE
* if the actor handled the event, or %FALSE if the event was
* not handled
*
* Since: 0.6
*/
gboolean
clutter_actor_event (ClutterActor *actor,
const ClutterEvent *event,
gboolean capture)
{
gboolean retval = FALSE;
gint signal_num = -1;
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
g_object_ref (actor);
if (capture)
{
GQuark detail = 0;
switch (event->type)
{
case CLUTTER_NOTHING:
break;
case CLUTTER_KEY_PRESS:
case CLUTTER_KEY_RELEASE:
detail = quark_key;
break;
case CLUTTER_MOTION:
detail = quark_motion;
break;
case CLUTTER_ENTER:
case CLUTTER_LEAVE:
detail = quark_pointer_focus;
break;
case CLUTTER_BUTTON_PRESS:
case CLUTTER_BUTTON_RELEASE:
detail = quark_button;
break;
case CLUTTER_SCROLL:
detail = quark_scroll;
break;
case CLUTTER_STAGE_STATE:
detail = quark_stage;
break;
case CLUTTER_DESTROY_NOTIFY:
detail = quark_destroy;
break;
case CLUTTER_CLIENT_MESSAGE:
detail = quark_client;
break;
case CLUTTER_DELETE:
detail = quark_delete;
break;
case CLUTTER_TOUCH_BEGIN:
case CLUTTER_TOUCH_UPDATE:
case CLUTTER_TOUCH_END:
case CLUTTER_TOUCH_CANCEL:
detail = quark_touch;
break;
case CLUTTER_TOUCHPAD_PINCH:
case CLUTTER_TOUCHPAD_SWIPE:
detail = quark_touchpad;
break;
case CLUTTER_PROXIMITY_IN:
case CLUTTER_PROXIMITY_OUT:
detail = quark_proximity;
break;
case CLUTTER_PAD_BUTTON_PRESS:
case CLUTTER_PAD_BUTTON_RELEASE:
case CLUTTER_PAD_STRIP:
case CLUTTER_PAD_RING:
detail = quark_pad;
break;
case CLUTTER_IM_COMMIT:
case CLUTTER_IM_DELETE:
case CLUTTER_IM_PREEDIT:
detail = quark_im;
break;
case CLUTTER_DEVICE_ADDED:
case CLUTTER_DEVICE_REMOVED:
break;
case CLUTTER_EVENT_LAST: /* Just keep compiler warnings quiet */
break;
}
g_signal_emit (actor,
actor_signals[CAPTURED_EVENT],
detail,
event,
&retval);
goto out;
}
g_signal_emit (actor, actor_signals[EVENT], 0, event, &retval);
if (!retval)
{
switch (event->type)
{
case CLUTTER_NOTHING:
break;
case CLUTTER_BUTTON_PRESS:
signal_num = BUTTON_PRESS_EVENT;
break;
case CLUTTER_BUTTON_RELEASE:
signal_num = BUTTON_RELEASE_EVENT;
break;
case CLUTTER_SCROLL:
signal_num = SCROLL_EVENT;
break;
case CLUTTER_KEY_PRESS:
signal_num = KEY_PRESS_EVENT;
break;
case CLUTTER_KEY_RELEASE:
signal_num = KEY_RELEASE_EVENT;
break;
case CLUTTER_MOTION:
signal_num = MOTION_EVENT;
break;
case CLUTTER_ENTER:
signal_num = ENTER_EVENT;
break;
case CLUTTER_LEAVE:
signal_num = LEAVE_EVENT;
break;
case CLUTTER_TOUCH_BEGIN:
case CLUTTER_TOUCH_END:
case CLUTTER_TOUCH_UPDATE:
case CLUTTER_TOUCH_CANCEL:
signal_num = TOUCH_EVENT;
break;
case CLUTTER_DELETE:
case CLUTTER_DESTROY_NOTIFY:
case CLUTTER_CLIENT_MESSAGE:
case CLUTTER_IM_COMMIT:
case CLUTTER_IM_DELETE:
case CLUTTER_IM_PREEDIT:
default:
signal_num = -1;
break;
}
if (signal_num != -1)
g_signal_emit (actor, actor_signals[signal_num], 0,
event, &retval);
}
out:
g_object_unref (actor);
return retval;
}
/**
* clutter_actor_set_reactive:
* @actor: a #ClutterActor
* @reactive: whether the actor should be reactive to events
*
* Sets @actor as reactive. Reactive actors will receive events.
*
* Since: 0.6
*/
void
clutter_actor_set_reactive (ClutterActor *actor,
gboolean reactive)
{
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
if (reactive == CLUTTER_ACTOR_IS_REACTIVE (actor))
return;
if (reactive)
CLUTTER_ACTOR_SET_FLAGS (actor, CLUTTER_ACTOR_REACTIVE);
else
CLUTTER_ACTOR_UNSET_FLAGS (actor, CLUTTER_ACTOR_REACTIVE);
g_object_notify_by_pspec (G_OBJECT (actor), obj_props[PROP_REACTIVE]);
}
/**
* clutter_actor_get_reactive:
* @actor: a #ClutterActor
*
* Checks whether @actor is marked as reactive.
*
* Return value: %TRUE if the actor is reactive
*
* Since: 0.6
*/
gboolean
clutter_actor_get_reactive (ClutterActor *actor)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), FALSE);
return CLUTTER_ACTOR_IS_REACTIVE (actor) ? TRUE : FALSE;
}
/**
* clutter_actor_set_anchor_point:
* @self: a #ClutterActor
* @anchor_x: X coordinate of the anchor point
* @anchor_y: Y coordinate of the anchor point
*
* Sets an anchor point for @self. The anchor point is a point in the
* coordinate space of an actor to which the actor position within its
* parent is relative; the default is (0, 0), i.e. the top-left corner
* of the actor.
*
* Since: 0.6
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point instead.
*/
void
clutter_actor_set_anchor_point (ClutterActor *self,
gfloat anchor_x,
gfloat anchor_y)
{
ClutterTransformInfo *info;
ClutterActorPrivate *priv;
gboolean changed = FALSE;
gfloat old_anchor_x, old_anchor_y;
GObject *obj;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
obj = G_OBJECT (self);
priv = self->priv;
info = _clutter_actor_get_transform_info (self);
g_object_freeze_notify (obj);
clutter_anchor_coord_get_units (self, &info->anchor,
&old_anchor_x,
&old_anchor_y,
NULL);
if (info->anchor.is_fractional)
g_object_notify_by_pspec (obj, obj_props[PROP_ANCHOR_GRAVITY]);
if (old_anchor_x != anchor_x)
{
g_object_notify_by_pspec (obj, obj_props[PROP_ANCHOR_X]);
changed = TRUE;
}
if (old_anchor_y != anchor_y)
{
g_object_notify_by_pspec (obj, obj_props[PROP_ANCHOR_Y]);
changed = TRUE;
}
clutter_anchor_coord_set_units (&info->anchor, anchor_x, anchor_y, 0);
if (changed)
{
priv->transform_valid = FALSE;
clutter_actor_queue_redraw (self);
}
g_object_thaw_notify (obj);
}
/**
* clutter_actor_get_anchor_point_gravity:
* @self: a #ClutterActor
*
* Retrieves the anchor position expressed as a #ClutterGravity. If
* the anchor point was specified using pixels or units this will
* return %CLUTTER_GRAVITY_NONE.
*
* Return value: the #ClutterGravity used by the anchor point
*
* Since: 1.0
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point instead.
*/
ClutterGravity
clutter_actor_get_anchor_point_gravity (ClutterActor *self)
{
const ClutterTransformInfo *info;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), CLUTTER_GRAVITY_NONE);
info = _clutter_actor_get_transform_info_or_defaults (self);
return clutter_anchor_coord_get_gravity (&info->anchor);
}
/**
* clutter_actor_move_anchor_point:
* @self: a #ClutterActor
* @anchor_x: X coordinate of the anchor point
* @anchor_y: Y coordinate of the anchor point
*
* Sets an anchor point for the actor, and adjusts the actor postion so that
* the relative position of the actor toward its parent remains the same.
*
* Since: 0.6
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point and
* clutter_actor_set_translation() instead.
*/
void
clutter_actor_move_anchor_point (ClutterActor *self,
gfloat anchor_x,
gfloat anchor_y)
{
gfloat old_anchor_x, old_anchor_y;
const ClutterTransformInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_transform_info (self);
clutter_anchor_coord_get_units (self, &info->anchor,
&old_anchor_x,
&old_anchor_y,
NULL);
g_object_freeze_notify (G_OBJECT (self));
clutter_actor_set_anchor_point (self, anchor_x, anchor_y);
if (self->priv->position_set)
clutter_actor_move_by (self,
anchor_x - old_anchor_x,
anchor_y - old_anchor_y);
g_object_thaw_notify (G_OBJECT (self));
}
/**
* clutter_actor_move_anchor_point_from_gravity:
* @self: a #ClutterActor
* @gravity: #ClutterGravity.
*
* Sets an anchor point on the actor based on the given gravity, adjusting the
* actor postion so that its relative position within its parent remains
* unchanged.
*
* Since version 1.0 the anchor point will be stored as a gravity so
* that if the actor changes size then the anchor point will move. For
* example, if you set the anchor point to %CLUTTER_GRAVITY_SOUTH_EAST
* and later double the size of the actor, the anchor point will move
* to the bottom right.
*
* Since: 0.6
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point and
* clutter_actor_set_translation() instead.
*/
void
clutter_actor_move_anchor_point_from_gravity (ClutterActor *self,
ClutterGravity gravity)
{
gfloat old_anchor_x, old_anchor_y, new_anchor_x, new_anchor_y;
const ClutterTransformInfo *info;
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
info = _clutter_actor_get_transform_info (self);
g_object_freeze_notify (G_OBJECT (self));
clutter_anchor_coord_get_units (self, &info->anchor,
&old_anchor_x,
&old_anchor_y,
NULL);
clutter_actor_set_anchor_point_from_gravity (self, gravity);
clutter_anchor_coord_get_units (self, &info->anchor,
&new_anchor_x,
&new_anchor_y,
NULL);
if (priv->position_set)
clutter_actor_move_by (self,
new_anchor_x - old_anchor_x,
new_anchor_y - old_anchor_y);
g_object_thaw_notify (G_OBJECT (self));
}
/**
* clutter_actor_set_anchor_point_from_gravity:
* @self: a #ClutterActor
* @gravity: #ClutterGravity.
*
* Sets an anchor point on the actor, based on the given gravity (this is a
* convenience function wrapping clutter_actor_set_anchor_point()).
*
* Since version 1.0 the anchor point will be stored as a gravity so
* that if the actor changes size then the anchor point will move. For
* example, if you set the anchor point to %CLUTTER_GRAVITY_SOUTH_EAST
* and later double the size of the actor, the anchor point will move
* to the bottom right.
*
* Since: 0.6
*
* Deprecated: 1.12: Use #ClutterActor:pivot-point and
* clutter_actor_set_translation() instead. E.g. For %CLUTTER_GRAVITY_CENTER set
* pivot_point to (0.5,0.5) and the translation to (width/2,height/2).
*/
void
clutter_actor_set_anchor_point_from_gravity (ClutterActor *self,
ClutterGravity gravity)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (gravity == CLUTTER_GRAVITY_NONE)
clutter_actor_set_anchor_point (self, 0, 0);
else
{
GObject *obj = G_OBJECT (self);
ClutterTransformInfo *info;
g_object_freeze_notify (obj);
info = _clutter_actor_get_transform_info (self);
clutter_anchor_coord_set_gravity (&info->anchor, gravity);
g_object_notify_by_pspec (obj, obj_props[PROP_ANCHOR_GRAVITY]);
g_object_notify_by_pspec (obj, obj_props[PROP_ANCHOR_X]);
g_object_notify_by_pspec (obj, obj_props[PROP_ANCHOR_Y]);
self->priv->transform_valid = FALSE;
clutter_actor_queue_redraw (self);
g_object_thaw_notify (obj);
}
}
static void
clutter_actor_store_content_box (ClutterActor *self,
const ClutterActorBox *box)
{
if (box != NULL)
{
self->priv->content_box = *box;
self->priv->content_box_valid = TRUE;
}
else
self->priv->content_box_valid = FALSE;
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_CONTENT_BOX]);
}
static void
clutter_container_iface_init (ClutterContainerIface *iface)
{
/* we don't override anything, as ClutterContainer already has a default
* implementation that we can use, and which calls into our own API.
*/
}
typedef enum
{
PARSE_X,
PARSE_Y,
PARSE_WIDTH,
PARSE_HEIGHT,
PARSE_ANCHOR_X,
PARSE_ANCHOR_Y
} ParseDimension;
static gfloat
parse_units (ClutterActor *self,
ParseDimension dimension,
JsonNode *node)
{
GValue value = G_VALUE_INIT;
gfloat retval = 0;
if (JSON_NODE_TYPE (node) != JSON_NODE_VALUE)
return 0;
json_node_get_value (node, &value);
if (G_VALUE_HOLDS (&value, G_TYPE_INT64))
{
retval = (gfloat) g_value_get_int64 (&value);
}
else if (G_VALUE_HOLDS (&value, G_TYPE_DOUBLE))
{
retval = g_value_get_double (&value);
}
else if (G_VALUE_HOLDS (&value, G_TYPE_STRING))
{
ClutterUnits units;
gboolean res;
res = clutter_units_from_string (&units, g_value_get_string (&value));
if (res)
retval = clutter_units_to_pixels (&units);
else
{
g_warning ("Invalid value '%s': integers, strings or floating point "
"values can be used for the x, y, width and height "
"properties. Valid modifiers for strings are 'px', 'mm', "
"'pt' and 'em'.",
g_value_get_string (&value));
retval = 0;
}
}
else
{
g_warning ("Invalid value of type '%s': integers, strings of floating "
"point values can be used for the x, y, width, height "
"anchor-x and anchor-y properties.",
g_type_name (G_VALUE_TYPE (&value)));
}
g_value_unset (&value);
return retval;
}
typedef struct {
ClutterRotateAxis axis;
gdouble angle;
gfloat center_x;
gfloat center_y;
gfloat center_z;
} RotationInfo;
static inline gboolean
parse_rotation_array (ClutterActor *actor,
JsonArray *array,
RotationInfo *info)
{
JsonNode *element;
if (json_array_get_length (array) != 2)
return FALSE;
/* angle */
element = json_array_get_element (array, 0);
if (JSON_NODE_TYPE (element) == JSON_NODE_VALUE)
info->angle = json_node_get_double (element);
else
return FALSE;
/* center */
element = json_array_get_element (array, 1);
if (JSON_NODE_TYPE (element) == JSON_NODE_ARRAY)
{
JsonArray *center = json_node_get_array (element);
if (json_array_get_length (center) != 2)
return FALSE;
switch (info->axis)
{
case CLUTTER_X_AXIS:
info->center_y = parse_units (actor, PARSE_Y,
json_array_get_element (center, 0));
info->center_z = parse_units (actor, PARSE_Y,
json_array_get_element (center, 1));
return TRUE;
case CLUTTER_Y_AXIS:
info->center_x = parse_units (actor, PARSE_X,
json_array_get_element (center, 0));
info->center_z = parse_units (actor, PARSE_X,
json_array_get_element (center, 1));
return TRUE;
case CLUTTER_Z_AXIS:
info->center_x = parse_units (actor, PARSE_X,
json_array_get_element (center, 0));
info->center_y = parse_units (actor, PARSE_Y,
json_array_get_element (center, 1));
return TRUE;
}
}
return FALSE;
}
static gboolean
parse_rotation (ClutterActor *actor,
JsonNode *node,
RotationInfo *info)
{
JsonArray *array;
guint len, i;
gboolean retval = FALSE;
if (JSON_NODE_TYPE (node) != JSON_NODE_ARRAY)
{
g_warning ("Invalid node of type '%s' found, expecting an array",
json_node_type_name (node));
return FALSE;
}
array = json_node_get_array (node);
len = json_array_get_length (array);
for (i = 0; i < len; i++)
{
JsonNode *element = json_array_get_element (array, i);
JsonObject *object;
JsonNode *member;
if (JSON_NODE_TYPE (element) != JSON_NODE_OBJECT)
{
g_warning ("Invalid node of type '%s' found, expecting an object",
json_node_type_name (element));
return FALSE;
}
object = json_node_get_object (element);
if (json_object_has_member (object, "x-axis"))
{
member = json_object_get_member (object, "x-axis");
info->axis = CLUTTER_X_AXIS;
if (JSON_NODE_TYPE (member) == JSON_NODE_VALUE)
{
info->angle = json_node_get_double (member);
retval = TRUE;
}
else if (JSON_NODE_TYPE (member) == JSON_NODE_ARRAY)
retval = parse_rotation_array (actor,
json_node_get_array (member),
info);
else
retval = FALSE;
}
else if (json_object_has_member (object, "y-axis"))
{
member = json_object_get_member (object, "y-axis");
info->axis = CLUTTER_Y_AXIS;
if (JSON_NODE_TYPE (member) == JSON_NODE_VALUE)
{
info->angle = json_node_get_double (member);
retval = TRUE;
}
else if (JSON_NODE_TYPE (member) == JSON_NODE_ARRAY)
retval = parse_rotation_array (actor,
json_node_get_array (member),
info);
else
retval = FALSE;
}
else if (json_object_has_member (object, "z-axis"))
{
member = json_object_get_member (object, "z-axis");
info->axis = CLUTTER_Z_AXIS;
if (JSON_NODE_TYPE (member) == JSON_NODE_VALUE)
{
info->angle = json_node_get_double (member);
retval = TRUE;
}
else if (JSON_NODE_TYPE (member) == JSON_NODE_ARRAY)
retval = parse_rotation_array (actor,
json_node_get_array (member),
info);
else
retval = FALSE;
}
}
return retval;
}
static GSList *
parse_actor_metas (ClutterScript *script,
ClutterActor *actor,
JsonNode *node)
{
GList *elements, *l;
GSList *retval = NULL;
if (!JSON_NODE_HOLDS_ARRAY (node))
return NULL;
elements = json_array_get_elements (json_node_get_array (node));
for (l = elements; l != NULL; l = l->next)
{
JsonNode *element = l->data;
const gchar *id_ = _clutter_script_get_id_from_node (element);
GObject *meta;
if (id_ == NULL || *id_ == '\0')
continue;
meta = clutter_script_get_object (script, id_);
if (meta == NULL)
continue;
retval = g_slist_prepend (retval, meta);
}
g_list_free (elements);
return g_slist_reverse (retval);
}
static ClutterMargin *
parse_margin (ClutterActor *self,
JsonNode *node)
{
ClutterMargin *margin;
JsonArray *array;
if (!JSON_NODE_HOLDS_ARRAY (node))
{
g_warning ("The margin property must be an array of 1 to 4 elements");
return NULL;
}
margin = clutter_margin_new ();
array = json_node_get_array (node);
switch (json_array_get_length (array))
{
case 1:
margin->top = margin->right = margin->bottom = margin->left =
parse_units (self, 0, json_array_get_element (array, 0));
break;
case 2:
margin->top = margin->bottom =
parse_units (self, 0, json_array_get_element (array, 0));
margin->right = margin->left =
parse_units (self, 0, json_array_get_element (array, 1));
break;
case 3:
margin->top =
parse_units (self, 0, json_array_get_element (array, 0));
margin->right = margin->left =
parse_units (self, 0, json_array_get_element (array, 1));
margin->bottom =
parse_units (self, 0, json_array_get_element (array, 2));
break;
case 4:
margin->top =
parse_units (self, 0, json_array_get_element (array, 0));
margin->right =
parse_units (self, 0, json_array_get_element (array, 1));
margin->bottom =
parse_units (self, 0, json_array_get_element (array, 2));
margin->left =
parse_units (self, 0, json_array_get_element (array, 3));
break;
default:
g_warning ("The margin property must be an array of 1 to 4 elements");
clutter_margin_free (margin);
return NULL;
}
return margin;
}
static gboolean
clutter_actor_parse_custom_node (ClutterScriptable *scriptable,
ClutterScript *script,
GValue *value,
const gchar *name,
JsonNode *node)
{
ClutterActor *actor = CLUTTER_ACTOR (scriptable);
gboolean retval = FALSE;
if ((name[0] == 'x' && name[1] == '\0') ||
(name[0] == 'y' && name[1] == '\0') ||
(strcmp (name, "width") == 0) ||
(strcmp (name, "height") == 0) ||
(strcmp (name, "anchor_x") == 0) ||
(strcmp (name, "anchor_y") == 0))
{
ParseDimension dimension;
gfloat units;
if (name[0] == 'x')
dimension = PARSE_X;
else if (name[0] == 'y')
dimension = PARSE_Y;
else if (name[0] == 'w')
dimension = PARSE_WIDTH;
else if (name[0] == 'h')
dimension = PARSE_HEIGHT;
else if (name[0] == 'a' && name[7] == 'x')
dimension = PARSE_ANCHOR_X;
else if (name[0] == 'a' && name[7] == 'y')
dimension = PARSE_ANCHOR_Y;
else
return FALSE;
units = parse_units (actor, dimension, node);
/* convert back to pixels: all properties are pixel-based */
g_value_init (value, G_TYPE_FLOAT);
g_value_set_float (value, units);
retval = TRUE;
}
else if (strcmp (name, "rotation") == 0)
{
RotationInfo *info;
info = g_slice_new0 (RotationInfo);
retval = parse_rotation (actor, node, info);
if (retval)
{
g_value_init (value, G_TYPE_POINTER);
g_value_set_pointer (value, info);
}
else
g_slice_free (RotationInfo, info);
}
else if (strcmp (name, "actions") == 0 ||
strcmp (name, "constraints") == 0 ||
strcmp (name, "effects") == 0)
{
GSList *l;
l = parse_actor_metas (script, actor, node);
g_value_init (value, G_TYPE_POINTER);
g_value_set_pointer (value, l);
retval = TRUE;
}
else if (strcmp (name, "margin") == 0)
{
ClutterMargin *margin = parse_margin (actor, node);
if (margin)
{
g_value_init (value, CLUTTER_TYPE_MARGIN);
g_value_set_boxed (value, margin);
retval = TRUE;
}
}
return retval;
}
static void
clutter_actor_set_custom_property (ClutterScriptable *scriptable,
ClutterScript *script,
const gchar *name,
const GValue *value)
{
ClutterActor *actor = CLUTTER_ACTOR (scriptable);
#ifdef CLUTTER_ENABLE_DEBUG
if (G_UNLIKELY (CLUTTER_HAS_DEBUG (SCRIPT)))
{
gchar *tmp = g_strdup_value_contents (value);
CLUTTER_NOTE (SCRIPT,
"in ClutterActor::set_custom_property('%s') = %s",
name,
tmp);
g_free (tmp);
}
#endif /* CLUTTER_ENABLE_DEBUG */
if (strcmp (name, "rotation") == 0)
{
RotationInfo *info;
if (!G_VALUE_HOLDS (value, G_TYPE_POINTER))
return;
info = g_value_get_pointer (value);
clutter_actor_set_rotation (actor,
info->axis, info->angle,
info->center_x,
info->center_y,
info->center_z);
g_slice_free (RotationInfo, info);
return;
}
if (strcmp (name, "actions") == 0 ||
strcmp (name, "constraints") == 0 ||
strcmp (name, "effects") == 0)
{
GSList *metas, *l;
if (!G_VALUE_HOLDS (value, G_TYPE_POINTER))
return;
metas = g_value_get_pointer (value);
for (l = metas; l != NULL; l = l->next)
{
if (name[0] == 'a')
clutter_actor_add_action (actor, l->data);
if (name[0] == 'c')
clutter_actor_add_constraint (actor, l->data);
if (name[0] == 'e')
clutter_actor_add_effect (actor, l->data);
}
g_slist_free (metas);
return;
}
if (strcmp (name, "margin") == 0)
{
clutter_actor_set_margin (actor, g_value_get_boxed (value));
return;
}
g_object_set_property (G_OBJECT (scriptable), name, value);
}
static void
clutter_scriptable_iface_init (ClutterScriptableIface *iface)
{
iface->parse_custom_node = clutter_actor_parse_custom_node;
iface->set_custom_property = clutter_actor_set_custom_property;
}
static gboolean
get_layout_from_animation_property (ClutterActor *actor,
const gchar *name,
gchar **name_p)
{
g_auto (GStrv) tokens = NULL;
if (!g_str_has_prefix (name, "@layout"))
return FALSE;
tokens = g_strsplit (name, ".", -1);
if (tokens == NULL || g_strv_length (tokens) != 2)
{
CLUTTER_NOTE (ANIMATION, "Invalid property name '%s'",
name + 1);
return FALSE;
}
if (name_p != NULL)
*name_p = g_strdup (tokens[1]);
return TRUE;
}
static ClutterActorMeta *
get_meta_from_animation_property (ClutterActor *actor,
const gchar *name,
gchar **name_p)
{
ClutterActorPrivate *priv = actor->priv;
ClutterActorMeta *meta = NULL;
gchar **tokens;
/* if this is not a special property, fall through */
if (name[0] != '@')
return NULL;
/* detect the properties named using the following spec:
*
* @..
*
* where can be one of the following:
*
* - actions
* - constraints
* - effects
*
* and is the name set on a specific ActorMeta
*/
tokens = g_strsplit (name + 1, ".", -1);
if (tokens == NULL || g_strv_length (tokens) != 3)
{
CLUTTER_NOTE (ANIMATION, "Invalid property name '%s'",
name + 1);
g_strfreev (tokens);
return NULL;
}
if (strcmp (tokens[0], "actions") == 0)
meta = _clutter_meta_group_get_meta (priv->actions, tokens[1]);
if (strcmp (tokens[0], "constraints") == 0)
meta = _clutter_meta_group_get_meta (priv->constraints, tokens[1]);
if (strcmp (tokens[0], "effects") == 0)
meta = _clutter_meta_group_get_meta (priv->effects, tokens[1]);
if (name_p != NULL)
*name_p = g_strdup (tokens[2]);
CLUTTER_NOTE (ANIMATION,
"Looking for property '%s' of object '%s' in section '%s'",
tokens[2],
tokens[1],
tokens[0]);
g_strfreev (tokens);
return meta;
}
static GParamSpec *
clutter_actor_find_property (ClutterAnimatable *animatable,
const gchar *property_name)
{
ClutterActor *actor = CLUTTER_ACTOR (animatable);
ClutterActorMeta *meta = NULL;
GObjectClass *klass = NULL;
GParamSpec *pspec = NULL;
gchar *p_name = NULL;
gboolean use_layout;
use_layout = get_layout_from_animation_property (actor,
property_name,
&p_name);
if (!use_layout)
meta = get_meta_from_animation_property (actor,
property_name,
&p_name);
if (meta != NULL)
{
klass = G_OBJECT_GET_CLASS (meta);
pspec = g_object_class_find_property (klass, p_name);
}
else if (use_layout)
{
klass = G_OBJECT_GET_CLASS (actor->priv->layout_manager);
pspec = g_object_class_find_property (klass, p_name);
}
else
{
klass = G_OBJECT_GET_CLASS (animatable);
pspec = g_object_class_find_property (klass, property_name);
}
g_free (p_name);
return pspec;
}
static void
clutter_actor_get_initial_state (ClutterAnimatable *animatable,
const gchar *property_name,
GValue *initial)
{
ClutterActor *actor = CLUTTER_ACTOR (animatable);
ClutterActorMeta *meta = NULL;
gchar *p_name = NULL;
gboolean use_layout;
use_layout = get_layout_from_animation_property (actor,
property_name,
&p_name);
if (!use_layout)
meta = get_meta_from_animation_property (actor,
property_name,
&p_name);
if (meta != NULL)
g_object_get_property (G_OBJECT (meta), p_name, initial);
else if (use_layout)
g_object_get_property (G_OBJECT (actor->priv->layout_manager), p_name, initial);
else
g_object_get_property (G_OBJECT (animatable), property_name, initial);
g_free (p_name);
}
/*
* clutter_actor_set_animatable_property:
* @actor: a #ClutterActor
* @prop_id: the paramspec id
* @value: the value to set
* @pspec: the paramspec
*
* Sets values of animatable properties.
*
* This is a variant of clutter_actor_set_property() that gets called
* by the #ClutterAnimatable implementation of #ClutterActor for the
* properties with the %CLUTTER_PARAM_ANIMATABLE flag set on their
* #GParamSpec.
*
* Unlike the implementation of #GObjectClass.set_property(), this
* function will not update the interval if a transition involving an
* animatable property is in progress - this avoids cycles with the
* transition API calling the public API.
*/
static void
clutter_actor_set_animatable_property (ClutterActor *actor,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GObject *obj = G_OBJECT (actor);
g_object_freeze_notify (obj);
switch (prop_id)
{
case PROP_X:
clutter_actor_set_x_internal (actor, g_value_get_float (value));
break;
case PROP_Y:
clutter_actor_set_y_internal (actor, g_value_get_float (value));
break;
case PROP_POSITION:
clutter_actor_set_position_internal (actor, g_value_get_boxed (value));
break;
case PROP_WIDTH:
clutter_actor_set_width_internal (actor, g_value_get_float (value));
break;
case PROP_HEIGHT:
clutter_actor_set_height_internal (actor, g_value_get_float (value));
break;
case PROP_SIZE:
clutter_actor_set_size_internal (actor, g_value_get_boxed (value));
break;
case PROP_ALLOCATION:
clutter_actor_allocate_internal (actor,
g_value_get_boxed (value),
actor->priv->allocation_flags);
clutter_actor_queue_redraw (actor);
break;
case PROP_DEPTH:
clutter_actor_set_depth_internal (actor, g_value_get_float (value));
break;
case PROP_Z_POSITION:
clutter_actor_set_z_position_internal (actor, g_value_get_float (value));
break;
case PROP_OPACITY:
clutter_actor_set_opacity_internal (actor, g_value_get_uint (value));
break;
case PROP_BACKGROUND_COLOR:
clutter_actor_set_background_color_internal (actor, clutter_value_get_color (value));
break;
case PROP_PIVOT_POINT:
clutter_actor_set_pivot_point_internal (actor, g_value_get_boxed (value));
break;
case PROP_PIVOT_POINT_Z:
clutter_actor_set_pivot_point_z_internal (actor, g_value_get_float (value));
break;
case PROP_TRANSLATION_X:
case PROP_TRANSLATION_Y:
case PROP_TRANSLATION_Z:
clutter_actor_set_translation_internal (actor,
g_value_get_float (value),
pspec);
break;
case PROP_SCALE_X:
case PROP_SCALE_Y:
case PROP_SCALE_Z:
clutter_actor_set_scale_factor_internal (actor,
g_value_get_double (value),
pspec);
break;
case PROP_ROTATION_ANGLE_X:
case PROP_ROTATION_ANGLE_Y:
case PROP_ROTATION_ANGLE_Z:
clutter_actor_set_rotation_angle_internal (actor,
g_value_get_double (value),
pspec);
break;
case PROP_CONTENT_BOX:
clutter_actor_store_content_box (actor, g_value_get_boxed (value));
break;
case PROP_MARGIN_TOP:
case PROP_MARGIN_BOTTOM:
case PROP_MARGIN_LEFT:
case PROP_MARGIN_RIGHT:
clutter_actor_set_margin_internal (actor, g_value_get_float (value),
pspec);
break;
case PROP_TRANSFORM:
clutter_actor_set_transform_internal (actor, g_value_get_boxed (value));
break;
case PROP_CHILD_TRANSFORM:
clutter_actor_set_child_transform_internal (actor, g_value_get_boxed (value));
break;
default:
g_object_set_property (obj, pspec->name, value);
break;
}
g_object_thaw_notify (obj);
}
static void
clutter_actor_set_final_state (ClutterAnimatable *animatable,
const gchar *property_name,
const GValue *final)
{
ClutterActor *actor = CLUTTER_ACTOR (animatable);
ClutterActorMeta *meta = NULL;
gchar *p_name = NULL;
gboolean use_layout;
use_layout = get_layout_from_animation_property (actor,
property_name,
&p_name);
if (!use_layout)
meta = get_meta_from_animation_property (actor,
property_name,
&p_name);
if (meta != NULL)
g_object_set_property (G_OBJECT (meta), p_name, final);
else if (use_layout)
g_object_set_property (G_OBJECT (actor->priv->layout_manager), p_name, final);
else
{
GObjectClass *obj_class = G_OBJECT_GET_CLASS (animatable);
GParamSpec *pspec;
pspec = g_object_class_find_property (obj_class, property_name);
if (pspec != NULL)
{
if ((pspec->flags & CLUTTER_PARAM_ANIMATABLE) != 0)
{
/* XXX - I'm going to the special hell for this */
clutter_actor_set_animatable_property (actor, pspec->param_id, final, pspec);
}
else
g_object_set_property (G_OBJECT (animatable), pspec->name, final);
}
}
g_free (p_name);
}
static void
clutter_animatable_iface_init (ClutterAnimatableInterface *iface)
{
iface->find_property = clutter_actor_find_property;
iface->get_initial_state = clutter_actor_get_initial_state;
iface->set_final_state = clutter_actor_set_final_state;
}
/**
* clutter_actor_transform_stage_point:
* @self: A #ClutterActor
* @x: (in): x screen coordinate of the point to unproject
* @y: (in): y screen coordinate of the point to unproject
* @x_out: (out): return location for the unprojected x coordinance
* @y_out: (out): return location for the unprojected y coordinance
*
* This function translates screen coordinates (@x, @y) to
* coordinates relative to the actor. For example, it can be used to translate
* screen events from global screen coordinates into actor-local coordinates.
*
* The conversion can fail, notably if the transform stack results in the
* actor being projected on the screen as a mere line.
*
* The conversion should not be expected to be pixel-perfect due to the
* nature of the operation. In general the error grows when the skewing
* of the actor rectangle on screen increases.
*
* This function can be computationally intensive.
*
* This function only works when the allocation is up-to-date, i.e. inside of
* the #ClutterActorClass.paint() implementation
*
* Return value: %TRUE if conversion was successful.
*
* Since: 0.6
*/
gboolean
clutter_actor_transform_stage_point (ClutterActor *self,
gfloat x,
gfloat y,
gfloat *x_out,
gfloat *y_out)
{
graphene_point3d_t v[4];
double ST[3][3];
double RQ[3][3];
int du, dv;
double px, py;
double det;
float xf, yf, wf;
ClutterActorPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
priv = self->priv;
/* This implementation is based on the quad -> quad projection algorithm
* described by Paul Heckbert in:
*
* http://www.cs.cmu.edu/~ph/texfund/texfund.pdf
*
* and the sample implementation at:
*
* http://www.cs.cmu.edu/~ph/src/texfund/
*
* Our texture is a rectangle with origin [0, 0], so we are mapping from
* quad to rectangle only, which significantly simplifies things.
* Function calls have been unrolled.
*/
clutter_actor_get_abs_allocation_vertices (self, v);
/* Keeping these as ints simplifies the multiplication (no significant
* loss of precision here).
*/
du = ceilf (priv->allocation.x2 - priv->allocation.x1);
dv = ceilf (priv->allocation.y2 - priv->allocation.y1);
if (du == 0 || dv == 0)
return FALSE;
#define DET(a,b,c,d) (((a) * (d)) - ((b) * (c)))
/* First, find mapping from unit uv square to xy quadrilateral; this
* equivalent to the pmap_square_quad() functions in the sample
* implementation, which we can simplify, since our target is always
* a rectangle.
*/
px = v[0].x - v[1].x + v[3].x - v[2].x;
py = v[0].y - v[1].y + v[3].y - v[2].y;
if ((int) px == 0 && (int) py == 0)
{
/* affine transform */
RQ[0][0] = v[1].x - v[0].x;
RQ[1][0] = v[3].x - v[1].x;
RQ[2][0] = v[0].x;
RQ[0][1] = v[1].y - v[0].y;
RQ[1][1] = v[3].y - v[1].y;
RQ[2][1] = v[0].y;
RQ[0][2] = 0.0;
RQ[1][2] = 0.0;
RQ[2][2] = 1.0;
}
else
{
/* projective transform */
double dx1, dx2, dy1, dy2;
dx1 = v[1].x - v[3].x;
dx2 = v[2].x - v[3].x;
dy1 = v[1].y - v[3].y;
dy2 = v[2].y - v[3].y;
det = DET (dx1, dx2, dy1, dy2);
if (fabs (det) <= DBL_EPSILON)
return FALSE;
RQ[0][2] = DET (px, dx2, py, dy2) / det;
RQ[1][2] = DET (dx1, px, dy1, py) / det;
RQ[1][2] = DET (dx1, px, dy1, py) / det;
RQ[2][2] = 1.0;
RQ[0][0] = v[1].x - v[0].x + (RQ[0][2] * v[1].x);
RQ[1][0] = v[2].x - v[0].x + (RQ[1][2] * v[2].x);
RQ[2][0] = v[0].x;
RQ[0][1] = v[1].y - v[0].y + (RQ[0][2] * v[1].y);
RQ[1][1] = v[2].y - v[0].y + (RQ[1][2] * v[2].y);
RQ[2][1] = v[0].y;
}
/*
* Now combine with transform from our rectangle (u0,v0,u1,v1) to unit
* square. Since our rectangle is based at 0,0 we only need to scale.
*/
RQ[0][0] /= du;
RQ[1][0] /= dv;
RQ[0][1] /= du;
RQ[1][1] /= dv;
RQ[0][2] /= du;
RQ[1][2] /= dv;
/*
* Now RQ is transform from uv rectangle to xy quadrilateral; we need an
* inverse of that.
*/
ST[0][0] = DET (RQ[1][1], RQ[1][2], RQ[2][1], RQ[2][2]);
ST[1][0] = DET (RQ[1][2], RQ[1][0], RQ[2][2], RQ[2][0]);
ST[2][0] = DET (RQ[1][0], RQ[1][1], RQ[2][0], RQ[2][1]);
ST[0][1] = DET (RQ[2][1], RQ[2][2], RQ[0][1], RQ[0][2]);
ST[1][1] = DET (RQ[2][2], RQ[2][0], RQ[0][2], RQ[0][0]);
ST[2][1] = DET (RQ[2][0], RQ[2][1], RQ[0][0], RQ[0][1]);
ST[0][2] = DET (RQ[0][1], RQ[0][2], RQ[1][1], RQ[1][2]);
ST[1][2] = DET (RQ[0][2], RQ[0][0], RQ[1][2], RQ[1][0]);
ST[2][2] = DET (RQ[0][0], RQ[0][1], RQ[1][0], RQ[1][1]);
/*
* Check the resulting matrix is OK.
*/
det = (RQ[0][0] * ST[0][0])
+ (RQ[0][1] * ST[0][1])
+ (RQ[0][2] * ST[0][2]);
if (fabs (det) <= DBL_EPSILON)
return FALSE;
/*
* Now transform our point with the ST matrix; the notional w
* coordinate is 1, hence the last part is simply added.
*/
xf = x * ST[0][0] + y * ST[1][0] + ST[2][0];
yf = x * ST[0][1] + y * ST[1][1] + ST[2][1];
wf = x * ST[0][2] + y * ST[1][2] + ST[2][2];
if (x_out)
*x_out = xf / wf;
if (y_out)
*y_out = yf / wf;
#undef DET
return TRUE;
}
/**
* clutter_actor_is_rotated:
* @self: a #ClutterActor
*
* Checks whether any rotation is applied to the actor.
*
* Return value: %TRUE if the actor is rotated.
*
* Since: 0.6
*/
gboolean
clutter_actor_is_rotated (ClutterActor *self)
{
const ClutterTransformInfo *info;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
info = _clutter_actor_get_transform_info_or_defaults (self);
if (info->rx_angle || info->ry_angle || info->rz_angle)
return TRUE;
return FALSE;
}
/**
* clutter_actor_is_scaled:
* @self: a #ClutterActor
*
* Checks whether the actor is scaled in either dimension.
*
* Return value: %TRUE if the actor is scaled.
*
* Since: 0.6
*/
gboolean
clutter_actor_is_scaled (ClutterActor *self)
{
const ClutterTransformInfo *info;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
info = _clutter_actor_get_transform_info_or_defaults (self);
if (info->scale_x != 1.0 || info->scale_y != 1.0)
return TRUE;
return FALSE;
}
ClutterActor *
_clutter_actor_get_stage_internal (ClutterActor *actor)
{
while (actor && !CLUTTER_ACTOR_IS_TOPLEVEL (actor))
actor = actor->priv->parent;
return actor;
}
/**
* clutter_actor_get_stage:
* @actor: a #ClutterActor
*
* Retrieves the #ClutterStage where @actor is contained.
*
* Return value: (transfer none) (type Clutter.Stage): the stage
* containing the actor, or %NULL
*
* Since: 0.8
*/
ClutterActor *
clutter_actor_get_stage (ClutterActor *actor)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), NULL);
return _clutter_actor_get_stage_internal (actor);
}
/**
* clutter_actor_allocate_available_size:
* @self: a #ClutterActor
* @x: the actor's X coordinate
* @y: the actor's Y coordinate
* @available_width: the maximum available width, or -1 to use the
* actor's natural width
* @available_height: the maximum available height, or -1 to use the
* actor's natural height
* @flags: flags controlling the allocation
*
* Allocates @self taking into account the #ClutterActor's
* preferred size, but limiting it to the maximum available width
* and height provided.
*
* This function will do the right thing when dealing with the
* actor's request mode.
*
* The implementation of this function is equivalent to:
*
* |[
* if (request_mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
* {
* clutter_actor_get_preferred_width (self, available_height,
* &min_width,
* &natural_width);
* width = CLAMP (natural_width, min_width, available_width);
*
* clutter_actor_get_preferred_height (self, width,
* &min_height,
* &natural_height);
* height = CLAMP (natural_height, min_height, available_height);
* }
* else if (request_mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT)
* {
* clutter_actor_get_preferred_height (self, available_width,
* &min_height,
* &natural_height);
* height = CLAMP (natural_height, min_height, available_height);
*
* clutter_actor_get_preferred_width (self, height,
* &min_width,
* &natural_width);
* width = CLAMP (natural_width, min_width, available_width);
* }
* else if (request_mode == CLUTTER_REQUEST_CONTENT_SIZE)
* {
* clutter_content_get_preferred_size (content, &natural_width, &natural_height);
*
* width = CLAMP (natural_width, 0, available_width);
* height = CLAMP (natural_height, 0, available_height);
* }
*
* box.x1 = x; box.y1 = y;
* box.x2 = box.x1 + available_width;
* box.y2 = box.y1 + available_height;
* clutter_actor_allocate (self, &box, flags);
* ]|
*
* This function can be used by fluid layout managers to allocate
* an actor's preferred size without making it bigger than the area
* available for the container.
*
* Since: 1.0
*/
void
clutter_actor_allocate_available_size (ClutterActor *self,
gfloat x,
gfloat y,
gfloat available_width,
gfloat available_height,
ClutterAllocationFlags flags)
{
ClutterActorPrivate *priv;
gfloat width, height;
gfloat min_width, min_height;
gfloat natural_width, natural_height;
ClutterActorBox box;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
width = height = 0.0;
switch (priv->request_mode)
{
case CLUTTER_REQUEST_HEIGHT_FOR_WIDTH:
clutter_actor_get_preferred_width (self, available_height,
&min_width,
&natural_width);
width = CLAMP (natural_width, min_width, available_width);
clutter_actor_get_preferred_height (self, width,
&min_height,
&natural_height);
height = CLAMP (natural_height, min_height, available_height);
break;
case CLUTTER_REQUEST_WIDTH_FOR_HEIGHT:
clutter_actor_get_preferred_height (self, available_width,
&min_height,
&natural_height);
height = CLAMP (natural_height, min_height, available_height);
clutter_actor_get_preferred_width (self, height,
&min_width,
&natural_width);
width = CLAMP (natural_width, min_width, available_width);
break;
case CLUTTER_REQUEST_CONTENT_SIZE:
if (priv->content != NULL)
{
clutter_content_get_preferred_size (priv->content, &natural_width, &natural_height);
width = CLAMP (natural_width, 0, available_width);
height = CLAMP (natural_height, 0, available_height);
}
break;
}
box.x1 = x;
box.y1 = y;
box.x2 = box.x1 + width;
box.y2 = box.y1 + height;
clutter_actor_allocate (self, &box, flags);
}
/**
* clutter_actor_allocate_preferred_size:
* @self: a #ClutterActor
* @flags: flags controlling the allocation
*
* Allocates the natural size of @self.
*
* This function is a utility call for #ClutterActor implementations
* that allocates the actor's preferred natural size. It can be used
* by fixed layout managers (like #ClutterGroup or so called
* 'composite actors') inside the ClutterActor::allocate
* implementation to give each child exactly how much space it
* requires, regardless of the size of the parent.
*
* This function is not meant to be used by applications. It is also
* not meant to be used outside the implementation of the
* #ClutterActorClass.allocate virtual function.
*
* Since: 0.8
*/
void
clutter_actor_allocate_preferred_size (ClutterActor *self,
ClutterAllocationFlags flags)
{
gfloat actor_x, actor_y;
gfloat natural_width, natural_height;
ClutterActorBox actor_box;
ClutterActorPrivate *priv;
const ClutterLayoutInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
if (priv->position_set)
{
info = _clutter_actor_get_layout_info_or_defaults (self);
actor_x = info->fixed_pos.x;
actor_y = info->fixed_pos.y;
}
else
{
actor_x = 0;
actor_y = 0;
}
clutter_actor_get_preferred_size (self,
NULL, NULL,
&natural_width,
&natural_height);
actor_box.x1 = actor_x;
actor_box.y1 = actor_y;
actor_box.x2 = actor_box.x1 + natural_width;
actor_box.y2 = actor_box.y1 + natural_height;
clutter_actor_allocate (self, &actor_box, flags);
}
/**
* clutter_actor_allocate_align_fill:
* @self: a #ClutterActor
* @box: a #ClutterActorBox, containing the available width and height
* @x_align: the horizontal alignment, between 0 and 1
* @y_align: the vertical alignment, between 0 and 1
* @x_fill: whether the actor should fill horizontally
* @y_fill: whether the actor should fill vertically
* @flags: allocation flags to be passed to clutter_actor_allocate()
*
* Allocates @self by taking into consideration the available allocation
* area; an alignment factor on either axis; and whether the actor should
* fill the allocation on either axis.
*
* The @box should contain the available allocation width and height;
* if the x1 and y1 members of #ClutterActorBox are not set to 0, the
* allocation will be offset by their value.
*
* This function takes into consideration the geometry request specified by
* the #ClutterActor:request-mode property, and the text direction.
*
* This function is useful for fluid layout managers using legacy alignment
* flags. Newly written layout managers should use the #ClutterActor:x-align
* and #ClutterActor:y-align properties, instead, and just call
* clutter_actor_allocate() inside their #ClutterActorClass.allocate()
* implementation.
*
* Since: 1.4
*/
void
clutter_actor_allocate_align_fill (ClutterActor *self,
const ClutterActorBox *box,
gdouble x_align,
gdouble y_align,
gboolean x_fill,
gboolean y_fill,
ClutterAllocationFlags flags)
{
ClutterActorPrivate *priv;
ClutterActorBox allocation = CLUTTER_ACTOR_BOX_INIT_ZERO;
gfloat x_offset, y_offset;
gfloat available_width, available_height;
gfloat child_width = 0.f, child_height = 0.f;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (box != NULL);
g_return_if_fail (x_align >= 0.0 && x_align <= 1.0);
g_return_if_fail (y_align >= 0.0 && y_align <= 1.0);
priv = self->priv;
clutter_actor_box_get_origin (box, &x_offset, &y_offset);
clutter_actor_box_get_size (box, &available_width, &available_height);
if (available_width <= 0)
available_width = 0.f;
if (available_height <= 0)
available_height = 0.f;
allocation.x1 = x_offset;
allocation.y1 = y_offset;
if (available_width == 0.f && available_height == 0.f)
goto out;
if (x_fill)
child_width = available_width;
if (y_fill)
child_height = available_height;
/* if we are filling horizontally and vertically then we're done */
if (x_fill && y_fill)
goto out;
if (priv->request_mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
{
gfloat min_width, natural_width;
gfloat min_height, natural_height;
if (!x_fill)
{
clutter_actor_get_preferred_width (self, available_height,
&min_width,
&natural_width);
child_width = CLAMP (natural_width, min_width, available_width);
}
if (!y_fill)
{
clutter_actor_get_preferred_height (self, child_width,
&min_height,
&natural_height);
child_height = CLAMP (natural_height, min_height, available_height);
}
}
else if (priv->request_mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT)
{
gfloat min_width, natural_width;
gfloat min_height, natural_height;
if (!y_fill)
{
clutter_actor_get_preferred_height (self, available_width,
&min_height,
&natural_height);
child_height = CLAMP (natural_height, min_height, available_height);
}
if (!x_fill)
{
clutter_actor_get_preferred_width (self, child_height,
&min_width,
&natural_width);
child_width = CLAMP (natural_width, min_width, available_width);
}
}
else if (priv->request_mode == CLUTTER_REQUEST_CONTENT_SIZE && priv->content != NULL)
{
gfloat natural_width, natural_height;
clutter_content_get_preferred_size (priv->content, &natural_width, &natural_height);
if (!x_fill)
child_width = CLAMP (natural_width, 0, available_width);
if (!y_fill)
child_height = CLAMP (natural_height, 0, available_height);
}
/* invert the horizontal alignment for RTL languages */
if (priv->text_direction == CLUTTER_TEXT_DIRECTION_RTL)
x_align = 1.0 - x_align;
if (!x_fill)
allocation.x1 += ((available_width - child_width) * x_align);
if (!y_fill)
allocation.y1 += ((available_height - child_height) * y_align);
out:
allocation.x1 = floorf (allocation.x1);
allocation.y1 = floorf (allocation.y1);
allocation.x2 = ceilf (allocation.x1 + MAX (child_width, 0));
allocation.y2 = ceilf (allocation.y1 + MAX (child_height, 0));
clutter_actor_allocate (self, &allocation, flags);
}
/**
* clutter_actor_grab_key_focus:
* @self: a #ClutterActor
*
* Sets the key focus of the #ClutterStage including @self
* to this #ClutterActor.
*
* Since: 1.0
*/
void
clutter_actor_grab_key_focus (ClutterActor *self)
{
ClutterActor *stage;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (self->priv->has_key_focus)
return;
stage = _clutter_actor_get_stage_internal (self);
if (stage != NULL)
clutter_stage_set_key_focus (CLUTTER_STAGE (stage), self);
}
static void
update_pango_context (ClutterBackend *backend,
PangoContext *context)
{
ClutterSettings *settings;
PangoFontDescription *font_desc;
const cairo_font_options_t *font_options;
gchar *font_name;
PangoDirection pango_dir;
gdouble resolution;
settings = clutter_settings_get_default ();
/* update the text direction */
if (clutter_get_default_text_direction () == CLUTTER_TEXT_DIRECTION_RTL)
pango_dir = PANGO_DIRECTION_RTL;
else
pango_dir = PANGO_DIRECTION_LTR;
pango_context_set_base_dir (context, pango_dir);
g_object_get (settings, "font-name", &font_name, NULL);
/* get the configuration for the PangoContext from the backend */
font_options = clutter_backend_get_font_options (backend);
resolution = clutter_backend_get_resolution (backend);
font_desc = pango_font_description_from_string (font_name);
if (resolution < 0)
resolution = 96.0; /* fall back */
pango_context_set_font_description (context, font_desc);
pango_cairo_context_set_font_options (context, font_options);
pango_cairo_context_set_resolution (context, resolution);
pango_font_description_free (font_desc);
g_free (font_name);
}
/**
* clutter_actor_get_pango_context:
* @self: a #ClutterActor
*
* Retrieves the #PangoContext for @self. The actor's #PangoContext
* is already configured using the appropriate font map, resolution
* and font options.
*
* Unlike clutter_actor_create_pango_context(), this context is owend
* by the #ClutterActor and it will be updated each time the options
* stored by the #ClutterBackend change.
*
* You can use the returned #PangoContext to create a #PangoLayout
* and render text using cogl_pango_show_layout() to reuse the
* glyphs cache also used by Clutter.
*
* Return value: (transfer none): the #PangoContext for a #ClutterActor.
* The returned #PangoContext is owned by the actor and should not be
* unreferenced by the application code
*
* Since: 1.0
*/
PangoContext *
clutter_actor_get_pango_context (ClutterActor *self)
{
ClutterActorPrivate *priv;
ClutterBackend *backend = clutter_get_default_backend ();
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
priv = self->priv;
if (G_UNLIKELY (priv->pango_context == NULL))
{
priv->pango_context = clutter_actor_create_pango_context (self);
priv->resolution_changed_id =
g_signal_connect_object (backend, "resolution-changed",
G_CALLBACK (update_pango_context), priv->pango_context, 0);
priv->font_changed_id =
g_signal_connect_object (backend, "font-changed",
G_CALLBACK (update_pango_context), priv->pango_context, 0);
}
else
update_pango_context (backend, priv->pango_context);
return priv->pango_context;
}
/**
* clutter_actor_create_pango_context:
* @self: a #ClutterActor
*
* Creates a #PangoContext for the given actor. The #PangoContext
* is already configured using the appropriate font map, resolution
* and font options.
*
* See also clutter_actor_get_pango_context().
*
* Return value: (transfer full): the newly created #PangoContext.
* Use g_object_unref() on the returned value to deallocate its
* resources
*
* Since: 1.0
*/
PangoContext *
clutter_actor_create_pango_context (ClutterActor *self)
{
CoglPangoFontMap *font_map;
PangoContext *context;
font_map = COGL_PANGO_FONT_MAP (clutter_get_font_map ());
context = cogl_pango_font_map_create_context (font_map);
update_pango_context (clutter_get_default_backend (), context);
pango_context_set_language (context, pango_language_get_default ());
return context;
}
/**
* clutter_actor_create_pango_layout:
* @self: a #ClutterActor
* @text: (allow-none): the text to set on the #PangoLayout, or %NULL
*
* Creates a new #PangoLayout from the same #PangoContext used
* by the #ClutterActor. The #PangoLayout is already configured
* with the font map, resolution and font options, and the
* given @text.
*
* If you want to keep around a #PangoLayout created by this
* function you will have to connect to the #ClutterBackend::font-changed
* and #ClutterBackend::resolution-changed signals, and call
* pango_layout_context_changed() in response to them.
*
* Return value: (transfer full): the newly created #PangoLayout.
* Use g_object_unref() when done
*
* Since: 1.0
*/
PangoLayout *
clutter_actor_create_pango_layout (ClutterActor *self,
const gchar *text)
{
PangoContext *context;
PangoLayout *layout;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
context = clutter_actor_get_pango_context (self);
layout = pango_layout_new (context);
if (text)
pango_layout_set_text (layout, text, -1);
return layout;
}
/**
* clutter_actor_set_opacity_override:
* @self: a #ClutterActor
* @opacity: the override opacity value, or -1 to reset
*
* Allows overriding the calculated paint opacity (as returned by
* clutter_actor_get_paint_opacity()). This is used internally by
* ClutterClone and ClutterOffscreenEffect, and should be used by
* actors that need to mimick those.
*
* In almost all cases this should not used by applications.
*
* Stability: unstable
*/
void
clutter_actor_set_opacity_override (ClutterActor *self,
gint opacity)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
/* ensure bounds */
if (opacity >= 0)
opacity = CLAMP (opacity, 0, 255);
else
opacity = -1;
self->priv->opacity_override = opacity;
}
/**
* clutter_actor_get_opacity_override:
* @self: a #ClutterActor
*
* See clutter_actor_set_opacity_override()
*
* Returns: the override value for the actor's opacity, or -1 if no override
* is set.
*
* Since: 1.22
*
* Stability: unstable
*/
gint
clutter_actor_get_opacity_override (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), -1);
return self->priv->opacity_override;
}
/**
* clutter_actor_inhibit_culling:
* @actor: a #ClutterActor
*
* Increases the culling inhibitor counter. Inhibiting culling
* forces the actor to be painted even when outside the visible
* bounds of the stage view.
*
* This is usually necessary when an actor is being painted on
* another paint context.
*
* Pair with clutter_actor_uninhibit_culling() when the actor doesn't
* need to be painted anymore.
*/
void
clutter_actor_inhibit_culling (ClutterActor *actor)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
priv = actor->priv;
priv->inhibit_culling_counter++;
_clutter_actor_set_enable_paint_unmapped (actor, TRUE);
}
/**
* clutter_actor_uninhibit_culling:
* @actor: a #ClutterActor
*
* Decreases the culling inhibitor counter. See clutter_actor_inhibit_culling()
* for when inhibit culling is necessary.
*
* Calling this function without a matching call to
* clutter_actor_inhibit_culling() is a programming error.
*/
void
clutter_actor_uninhibit_culling (ClutterActor *actor)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
priv = actor->priv;
if (priv->inhibit_culling_counter == 0)
{
g_critical ("Unpaired call to clutter_actor_uninhibit_culling");
return;
}
priv->inhibit_culling_counter--;
if (priv->inhibit_culling_counter == 0)
_clutter_actor_set_enable_paint_unmapped (actor, FALSE);
}
/* Allows you to disable applying the actors model view transform during
* a paint. Used by ClutterClone. */
void
_clutter_actor_set_enable_model_view_transform (ClutterActor *self,
gboolean enable)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
self->priv->enable_model_view_transform = enable;
}
void
_clutter_actor_set_enable_paint_unmapped (ClutterActor *self,
gboolean enable)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
priv->enable_paint_unmapped = enable;
if (priv->enable_paint_unmapped)
{
/* Make sure that the parents of the widget are realized first;
* otherwise checks in clutter_actor_update_map_state() will
* fail.
*/
clutter_actor_realize (self);
/* If the actor isn't ultimately connected to a toplevel, it can't be
* realized or painted.
*/
if (CLUTTER_ACTOR_IS_REALIZED (self))
clutter_actor_update_map_state (self, MAP_STATE_MAKE_MAPPED);
}
else
{
clutter_actor_update_map_state (self, MAP_STATE_CHECK);
}
}
static void
clutter_anchor_coord_get_units (ClutterActor *self,
const AnchorCoord *coord,
gfloat *x,
gfloat *y,
gfloat *z)
{
if (coord->is_fractional)
{
gfloat actor_width, actor_height;
clutter_actor_get_size (self, &actor_width, &actor_height);
if (x)
*x = actor_width * coord->v.fraction.x;
if (y)
*y = actor_height * coord->v.fraction.y;
if (z)
*z = 0;
}
else
{
if (x)
*x = coord->v.units.x;
if (y)
*y = coord->v.units.y;
if (z)
*z = coord->v.units.z;
}
}
static void
clutter_anchor_coord_set_units (AnchorCoord *coord,
gfloat x,
gfloat y,
gfloat z)
{
coord->is_fractional = FALSE;
coord->v.units.x = x;
coord->v.units.y = y;
coord->v.units.z = z;
}
static ClutterGravity
clutter_anchor_coord_get_gravity (const AnchorCoord *coord)
{
if (coord->is_fractional)
{
if (coord->v.fraction.x == 0.0)
{
if (coord->v.fraction.y == 0.0)
return CLUTTER_GRAVITY_NORTH_WEST;
else if (coord->v.fraction.y == 0.5)
return CLUTTER_GRAVITY_WEST;
else if (coord->v.fraction.y == 1.0)
return CLUTTER_GRAVITY_SOUTH_WEST;
else
return CLUTTER_GRAVITY_NONE;
}
else if (coord->v.fraction.x == 0.5)
{
if (coord->v.fraction.y == 0.0)
return CLUTTER_GRAVITY_NORTH;
else if (coord->v.fraction.y == 0.5)
return CLUTTER_GRAVITY_CENTER;
else if (coord->v.fraction.y == 1.0)
return CLUTTER_GRAVITY_SOUTH;
else
return CLUTTER_GRAVITY_NONE;
}
else if (coord->v.fraction.x == 1.0)
{
if (coord->v.fraction.y == 0.0)
return CLUTTER_GRAVITY_NORTH_EAST;
else if (coord->v.fraction.y == 0.5)
return CLUTTER_GRAVITY_EAST;
else if (coord->v.fraction.y == 1.0)
return CLUTTER_GRAVITY_SOUTH_EAST;
else
return CLUTTER_GRAVITY_NONE;
}
else
return CLUTTER_GRAVITY_NONE;
}
else
return CLUTTER_GRAVITY_NONE;
}
static void
clutter_anchor_coord_set_gravity (AnchorCoord *coord,
ClutterGravity gravity)
{
switch (gravity)
{
case CLUTTER_GRAVITY_NORTH:
coord->v.fraction.x = 0.5;
coord->v.fraction.y = 0.0;
break;
case CLUTTER_GRAVITY_NORTH_EAST:
coord->v.fraction.x = 1.0;
coord->v.fraction.y = 0.0;
break;
case CLUTTER_GRAVITY_EAST:
coord->v.fraction.x = 1.0;
coord->v.fraction.y = 0.5;
break;
case CLUTTER_GRAVITY_SOUTH_EAST:
coord->v.fraction.x = 1.0;
coord->v.fraction.y = 1.0;
break;
case CLUTTER_GRAVITY_SOUTH:
coord->v.fraction.x = 0.5;
coord->v.fraction.y = 1.0;
break;
case CLUTTER_GRAVITY_SOUTH_WEST:
coord->v.fraction.x = 0.0;
coord->v.fraction.y = 1.0;
break;
case CLUTTER_GRAVITY_WEST:
coord->v.fraction.x = 0.0;
coord->v.fraction.y = 0.5;
break;
case CLUTTER_GRAVITY_NORTH_WEST:
coord->v.fraction.x = 0.0;
coord->v.fraction.y = 0.0;
break;
case CLUTTER_GRAVITY_CENTER:
coord->v.fraction.x = 0.5;
coord->v.fraction.y = 0.5;
break;
default:
coord->v.fraction.x = 0.0;
coord->v.fraction.y = 0.0;
break;
}
coord->is_fractional = TRUE;
}
static gboolean
clutter_anchor_coord_is_zero (const AnchorCoord *coord)
{
if (coord->is_fractional)
return coord->v.fraction.x == 0.0 && coord->v.fraction.y == 0.0;
else
return (coord->v.units.x == 0.0
&& coord->v.units.y == 0.0
&& coord->v.units.z == 0.0);
}
/**
* clutter_actor_get_flags:
* @self: a #ClutterActor
*
* Retrieves the flags set on @self
*
* Return value: a bitwise or of #ClutterActorFlags or 0
*
* Since: 1.0
*/
ClutterActorFlags
clutter_actor_get_flags (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
return self->flags;
}
/**
* clutter_actor_set_flags:
* @self: a #ClutterActor
* @flags: the flags to set
*
* Sets @flags on @self
*
* This function will emit notifications for the changed properties
*
* Since: 1.0
*/
void
clutter_actor_set_flags (ClutterActor *self,
ClutterActorFlags flags)
{
ClutterActorFlags old_flags;
GObject *obj;
gboolean was_reactive_set, reactive_set;
gboolean was_realized_set, realized_set;
gboolean was_mapped_set, mapped_set;
gboolean was_visible_set, visible_set;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (self->flags == flags)
return;
obj = G_OBJECT (self);
g_object_ref (obj);
g_object_freeze_notify (obj);
old_flags = self->flags;
was_reactive_set = ((old_flags & CLUTTER_ACTOR_REACTIVE) != 0);
was_realized_set = ((old_flags & CLUTTER_ACTOR_REALIZED) != 0);
was_mapped_set = ((old_flags & CLUTTER_ACTOR_MAPPED) != 0);
was_visible_set = ((old_flags & CLUTTER_ACTOR_VISIBLE) != 0);
self->flags |= flags;
reactive_set = ((self->flags & CLUTTER_ACTOR_REACTIVE) != 0);
realized_set = ((self->flags & CLUTTER_ACTOR_REALIZED) != 0);
mapped_set = ((self->flags & CLUTTER_ACTOR_MAPPED) != 0);
visible_set = ((self->flags & CLUTTER_ACTOR_VISIBLE) != 0);
if (reactive_set != was_reactive_set)
g_object_notify_by_pspec (obj, obj_props[PROP_REACTIVE]);
if (realized_set != was_realized_set)
g_object_notify_by_pspec (obj, obj_props[PROP_REALIZED]);
if (mapped_set != was_mapped_set)
g_object_notify_by_pspec (obj, obj_props[PROP_MAPPED]);
if (visible_set != was_visible_set)
g_object_notify_by_pspec (obj, obj_props[PROP_VISIBLE]);
g_object_thaw_notify (obj);
g_object_unref (obj);
}
/**
* clutter_actor_unset_flags:
* @self: a #ClutterActor
* @flags: the flags to unset
*
* Unsets @flags on @self
*
* This function will emit notifications for the changed properties
*
* Since: 1.0
*/
void
clutter_actor_unset_flags (ClutterActor *self,
ClutterActorFlags flags)
{
ClutterActorFlags old_flags;
GObject *obj;
gboolean was_reactive_set, reactive_set;
gboolean was_realized_set, realized_set;
gboolean was_mapped_set, mapped_set;
gboolean was_visible_set, visible_set;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
obj = G_OBJECT (self);
g_object_freeze_notify (obj);
old_flags = self->flags;
was_reactive_set = ((old_flags & CLUTTER_ACTOR_REACTIVE) != 0);
was_realized_set = ((old_flags & CLUTTER_ACTOR_REALIZED) != 0);
was_mapped_set = ((old_flags & CLUTTER_ACTOR_MAPPED) != 0);
was_visible_set = ((old_flags & CLUTTER_ACTOR_VISIBLE) != 0);
self->flags &= ~flags;
if (self->flags == old_flags)
return;
reactive_set = ((self->flags & CLUTTER_ACTOR_REACTIVE) != 0);
realized_set = ((self->flags & CLUTTER_ACTOR_REALIZED) != 0);
mapped_set = ((self->flags & CLUTTER_ACTOR_MAPPED) != 0);
visible_set = ((self->flags & CLUTTER_ACTOR_VISIBLE) != 0);
if (reactive_set != was_reactive_set)
g_object_notify_by_pspec (obj, obj_props[PROP_REACTIVE]);
if (realized_set != was_realized_set)
g_object_notify_by_pspec (obj, obj_props[PROP_REALIZED]);
if (mapped_set != was_mapped_set)
g_object_notify_by_pspec (obj, obj_props[PROP_MAPPED]);
if (visible_set != was_visible_set)
g_object_notify_by_pspec (obj, obj_props[PROP_VISIBLE]);
g_object_thaw_notify (obj);
}
static void
clutter_actor_set_transform_internal (ClutterActor *self,
const ClutterMatrix *transform)
{
ClutterTransformInfo *info;
gboolean was_set;
GObject *obj;
obj = G_OBJECT (self);
info = _clutter_actor_get_transform_info (self);
was_set = info->transform_set;
info->transform = *transform;
info->transform_set = !cogl_matrix_is_identity (&info->transform);
self->priv->transform_valid = FALSE;
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (obj, obj_props[PROP_TRANSFORM]);
if (was_set != info->transform_set)
g_object_notify_by_pspec (obj, obj_props[PROP_TRANSFORM_SET]);
}
/**
* clutter_actor_set_transform:
* @self: a #ClutterActor
* @transform: (allow-none): a #ClutterMatrix, or %NULL to
* unset a custom transformation
*
* Overrides the transformations of a #ClutterActor with a custom
* matrix, which will be applied relative to the origin of the
* actor's allocation and to the actor's pivot point.
*
* The #ClutterActor:transform property is animatable.
*
* Since: 1.12
*/
void
clutter_actor_set_transform (ClutterActor *self,
const ClutterMatrix *transform)
{
const ClutterTransformInfo *info;
ClutterMatrix new_transform;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_transform_info_or_defaults (self);
if (transform != NULL)
clutter_matrix_init_from_matrix (&new_transform, transform);
else
clutter_matrix_init_identity (&new_transform);
_clutter_actor_create_transition (self, obj_props[PROP_TRANSFORM],
&info->transform,
&new_transform);
}
/**
* clutter_actor_get_transform:
* @self: a #ClutterActor
* @transform: (out caller-allocates): a #ClutterMatrix
*
* Retrieves the current transformation matrix of a #ClutterActor.
*
* Since: 1.12
*/
void
clutter_actor_get_transform (ClutterActor *self,
ClutterMatrix *transform)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (transform != NULL);
cogl_matrix_init_identity (transform);
_clutter_actor_apply_modelview_transform (self, transform);
}
void
_clutter_actor_set_in_clone_paint (ClutterActor *self,
gboolean is_in_clone_paint)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
self->priv->in_clone_paint = is_in_clone_paint;
}
/**
* clutter_actor_is_in_clone_paint:
* @self: a #ClutterActor
*
* Checks whether @self is being currently painted by a #ClutterClone
*
* This function is useful only inside the ::paint virtual function
* implementations or within handlers for the #ClutterActor::paint
* signal
*
* This function should not be used by applications
*
* Return value: %TRUE if the #ClutterActor is currently being painted
* by a #ClutterClone, and %FALSE otherwise
*
* Since: 1.0
*/
gboolean
clutter_actor_is_in_clone_paint (ClutterActor *self)
{
ClutterActor *parent;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
if (self->priv->in_clone_paint)
return TRUE;
if (self->priv->in_cloned_branch == 0)
return FALSE;
parent = self->priv->parent;
while (parent != NULL)
{
if (parent->priv->in_cloned_branch == 0)
break;
if (parent->priv->in_clone_paint)
return TRUE;
parent = parent->priv->parent;
}
return FALSE;
}
gboolean
clutter_actor_has_damage (ClutterActor *actor)
{
return actor->priv->is_dirty;
}
static gboolean
set_direction_recursive (ClutterActor *actor,
gpointer user_data)
{
ClutterTextDirection text_dir = GPOINTER_TO_INT (user_data);
clutter_actor_set_text_direction (actor, text_dir);
return TRUE;
}
/**
* clutter_actor_set_text_direction:
* @self: a #ClutterActor
* @text_dir: the text direction for @self
*
* Sets the #ClutterTextDirection for an actor
*
* The passed text direction must not be %CLUTTER_TEXT_DIRECTION_DEFAULT
*
* If @self implements #ClutterContainer then this function will recurse
* inside all the children of @self (including the internal ones).
*
* Composite actors not implementing #ClutterContainer, or actors requiring
* special handling when the text direction changes, should connect to
* the #GObject::notify signal for the #ClutterActor:text-direction property
*
* Since: 1.2
*/
void
clutter_actor_set_text_direction (ClutterActor *self,
ClutterTextDirection text_dir)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (text_dir != CLUTTER_TEXT_DIRECTION_DEFAULT);
priv = self->priv;
if (priv->text_direction != text_dir)
{
priv->text_direction = text_dir;
/* we need to emit the notify::text-direction first, so that
* the sub-classes can catch that and do specific handling of
* the text direction; see clutter_text_direction_changed_cb()
* inside clutter-text.c
*/
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_TEXT_DIRECTION]);
_clutter_actor_foreach_child (self, set_direction_recursive,
GINT_TO_POINTER (text_dir));
clutter_actor_queue_relayout (self);
}
}
void
_clutter_actor_set_has_pointer (ClutterActor *self,
gboolean has_pointer)
{
ClutterActorPrivate *priv = self->priv;
if (priv->has_pointer != has_pointer)
{
priv->has_pointer = has_pointer;
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_HAS_POINTER]);
}
}
void
_clutter_actor_set_has_key_focus (ClutterActor *self,
gboolean has_key_focus)
{
ClutterActorPrivate *priv = self->priv;
if (priv->has_key_focus != has_key_focus)
{
priv->has_key_focus = has_key_focus;
if (has_key_focus)
g_signal_emit (self, actor_signals[KEY_FOCUS_IN], 0);
else
g_signal_emit (self, actor_signals[KEY_FOCUS_OUT], 0);
}
}
/**
* clutter_actor_get_text_direction:
* @self: a #ClutterActor
*
* Retrieves the value set using clutter_actor_set_text_direction()
*
* If no text direction has been previously set, the default text
* direction, as returned by clutter_get_default_text_direction(), will
* be returned instead
*
* Return value: the #ClutterTextDirection for the actor
*
* Since: 1.2
*/
ClutterTextDirection
clutter_actor_get_text_direction (ClutterActor *self)
{
ClutterActorPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self),
CLUTTER_TEXT_DIRECTION_LTR);
priv = self->priv;
/* if no direction has been set yet use the default */
if (priv->text_direction == CLUTTER_TEXT_DIRECTION_DEFAULT)
priv->text_direction = clutter_get_default_text_direction ();
return priv->text_direction;
}
/**
* clutter_actor_has_pointer:
* @self: a #ClutterActor
*
* Checks whether an actor contains the pointer of a
* #ClutterInputDevice
*
* Return value: %TRUE if the actor contains the pointer, and
* %FALSE otherwise
*
* Since: 1.2
*/
gboolean
clutter_actor_has_pointer (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
return self->priv->has_pointer;
}
/**
* clutter_actor_has_allocation:
* @self: a #ClutterActor
*
* Checks if the actor has an up-to-date allocation assigned to
* it. This means that the actor should have an allocation: it's
* visible and has a parent. It also means that there is no
* outstanding relayout request in progress for the actor or its
* children (There might be other outstanding layout requests in
* progress that will cause the actor to get a new allocation
* when the stage is laid out, however).
*
* If this function returns %FALSE, then the actor will normally
* be allocated before it is next drawn on the screen.
*
* Return value: %TRUE if the actor has an up-to-date allocation
*
* Since: 1.4
*/
gboolean
clutter_actor_has_allocation (ClutterActor *self)
{
ClutterActorPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
priv = self->priv;
return priv->parent != NULL &&
CLUTTER_ACTOR_IS_VISIBLE (self) &&
!priv->needs_allocation;
}
/**
* clutter_actor_add_action:
* @self: a #ClutterActor
* @action: a #ClutterAction
*
* Adds @action to the list of actions applied to @self
*
* A #ClutterAction can only belong to one actor at a time
*
* The #ClutterActor will hold a reference on @action until either
* clutter_actor_remove_action() or clutter_actor_clear_actions()
* is called
*
* Since: 1.4
*/
void
clutter_actor_add_action (ClutterActor *self,
ClutterAction *action)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_ACTION (action));
priv = self->priv;
if (priv->actions == NULL)
{
priv->actions = g_object_new (CLUTTER_TYPE_META_GROUP, NULL);
priv->actions->actor = self;
}
_clutter_meta_group_add_meta (priv->actions, CLUTTER_ACTOR_META (action));
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_ACTIONS]);
}
/**
* clutter_actor_add_action_with_name:
* @self: a #ClutterActor
* @name: the name to set on the action
* @action: a #ClutterAction
*
* A convenience function for setting the name of a #ClutterAction
* while adding it to the list of actions applied to @self
*
* This function is the logical equivalent of:
*
* |[
* clutter_actor_meta_set_name (CLUTTER_ACTOR_META (action), name);
* clutter_actor_add_action (self, action);
* ]|
*
* Since: 1.4
*/
void
clutter_actor_add_action_with_name (ClutterActor *self,
const gchar *name,
ClutterAction *action)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (name != NULL);
g_return_if_fail (CLUTTER_IS_ACTION (action));
clutter_actor_meta_set_name (CLUTTER_ACTOR_META (action), name);
clutter_actor_add_action (self, action);
}
/**
* clutter_actor_remove_action:
* @self: a #ClutterActor
* @action: a #ClutterAction
*
* Removes @action from the list of actions applied to @self
*
* The reference held by @self on the #ClutterAction will be released
*
* Since: 1.4
*/
void
clutter_actor_remove_action (ClutterActor *self,
ClutterAction *action)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_ACTION (action));
priv = self->priv;
if (priv->actions == NULL)
return;
_clutter_meta_group_remove_meta (priv->actions, CLUTTER_ACTOR_META (action));
if (_clutter_meta_group_peek_metas (priv->actions) == NULL)
g_clear_object (&priv->actions);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_ACTIONS]);
}
/**
* clutter_actor_remove_action_by_name:
* @self: a #ClutterActor
* @name: the name of the action to remove
*
* Removes the #ClutterAction with the given name from the list
* of actions applied to @self
*
* Since: 1.4
*/
void
clutter_actor_remove_action_by_name (ClutterActor *self,
const gchar *name)
{
ClutterActorPrivate *priv;
ClutterActorMeta *meta;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (name != NULL);
priv = self->priv;
if (priv->actions == NULL)
return;
meta = _clutter_meta_group_get_meta (priv->actions, name);
if (meta == NULL)
return;
_clutter_meta_group_remove_meta (priv->actions, meta);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_ACTIONS]);
}
/**
* clutter_actor_get_actions:
* @self: a #ClutterActor
*
* Retrieves the list of actions applied to @self
*
* Return value: (transfer container) (element-type Clutter.Action): a copy
* of the list of #ClutterActions. The contents of the list are
* owned by the #ClutterActor. Use g_list_free() to free the resources
* allocated by the returned #GList
*
* Since: 1.4
*/
GList *
clutter_actor_get_actions (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
if (self->priv->actions == NULL)
return NULL;
return _clutter_meta_group_get_metas_no_internal (self->priv->actions);
}
/**
* clutter_actor_get_action:
* @self: a #ClutterActor
* @name: the name of the action to retrieve
*
* Retrieves the #ClutterAction with the given name in the list
* of actions applied to @self
*
* Return value: (transfer none): a #ClutterAction for the given
* name, or %NULL. The returned #ClutterAction is owned by the
* actor and it should not be unreferenced directly
*
* Since: 1.4
*/
ClutterAction *
clutter_actor_get_action (ClutterActor *self,
const gchar *name)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
g_return_val_if_fail (name != NULL, NULL);
if (self->priv->actions == NULL)
return NULL;
return CLUTTER_ACTION (_clutter_meta_group_get_meta (self->priv->actions, name));
}
/**
* clutter_actor_clear_actions:
* @self: a #ClutterActor
*
* Clears the list of actions applied to @self
*
* Since: 1.4
*/
void
clutter_actor_clear_actions (ClutterActor *self)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (self->priv->actions == NULL)
return;
_clutter_meta_group_clear_metas_no_internal (self->priv->actions);
}
/**
* clutter_actor_add_constraint:
* @self: a #ClutterActor
* @constraint: a #ClutterConstraint
*
* Adds @constraint to the list of #ClutterConstraints applied
* to @self
*
* The #ClutterActor will hold a reference on the @constraint until
* either clutter_actor_remove_constraint() or
* clutter_actor_clear_constraints() is called.
*
* Since: 1.4
*/
void
clutter_actor_add_constraint (ClutterActor *self,
ClutterConstraint *constraint)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_CONSTRAINT (constraint));
priv = self->priv;
if (priv->constraints == NULL)
{
priv->constraints = g_object_new (CLUTTER_TYPE_META_GROUP, NULL);
priv->constraints->actor = self;
}
_clutter_meta_group_add_meta (priv->constraints,
CLUTTER_ACTOR_META (constraint));
clutter_actor_queue_relayout (self);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_CONSTRAINTS]);
}
/**
* clutter_actor_add_constraint_with_name:
* @self: a #ClutterActor
* @name: the name to set on the constraint
* @constraint: a #ClutterConstraint
*
* A convenience function for setting the name of a #ClutterConstraint
* while adding it to the list of constraints applied to @self
*
* This function is the logical equivalent of:
*
* |[
* clutter_actor_meta_set_name (CLUTTER_ACTOR_META (constraint), name);
* clutter_actor_add_constraint (self, constraint);
* ]|
*
* Since: 1.4
*/
void
clutter_actor_add_constraint_with_name (ClutterActor *self,
const gchar *name,
ClutterConstraint *constraint)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (name != NULL);
g_return_if_fail (CLUTTER_IS_CONSTRAINT (constraint));
clutter_actor_meta_set_name (CLUTTER_ACTOR_META (constraint), name);
clutter_actor_add_constraint (self, constraint);
}
/**
* clutter_actor_remove_constraint:
* @self: a #ClutterActor
* @constraint: a #ClutterConstraint
*
* Removes @constraint from the list of constraints applied to @self
*
* The reference held by @self on the #ClutterConstraint will be released
*
* Since: 1.4
*/
void
clutter_actor_remove_constraint (ClutterActor *self,
ClutterConstraint *constraint)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_CONSTRAINT (constraint));
priv = self->priv;
if (priv->constraints == NULL)
return;
_clutter_meta_group_remove_meta (priv->constraints,
CLUTTER_ACTOR_META (constraint));
if (_clutter_meta_group_peek_metas (priv->constraints) == NULL)
g_clear_object (&priv->constraints);
clutter_actor_queue_relayout (self);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_CONSTRAINTS]);
}
/**
* clutter_actor_remove_constraint_by_name:
* @self: a #ClutterActor
* @name: the name of the constraint to remove
*
* Removes the #ClutterConstraint with the given name from the list
* of constraints applied to @self
*
* Since: 1.4
*/
void
clutter_actor_remove_constraint_by_name (ClutterActor *self,
const gchar *name)
{
ClutterActorPrivate *priv;
ClutterActorMeta *meta;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (name != NULL);
priv = self->priv;
if (priv->constraints == NULL)
return;
meta = _clutter_meta_group_get_meta (priv->constraints, name);
if (meta == NULL)
return;
_clutter_meta_group_remove_meta (priv->constraints, meta);
clutter_actor_queue_relayout (self);
}
/**
* clutter_actor_get_constraints:
* @self: a #ClutterActor
*
* Retrieves the list of constraints applied to @self
*
* Return value: (transfer container) (element-type Clutter.Constraint): a copy
* of the list of #ClutterConstraints. The contents of the list are
* owned by the #ClutterActor. Use g_list_free() to free the resources
* allocated by the returned #GList
*
* Since: 1.4
*/
GList *
clutter_actor_get_constraints (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
if (self->priv->constraints == NULL)
return NULL;
return _clutter_meta_group_get_metas_no_internal (self->priv->constraints);
}
/**
* clutter_actor_get_constraint:
* @self: a #ClutterActor
* @name: the name of the constraint to retrieve
*
* Retrieves the #ClutterConstraint with the given name in the list
* of constraints applied to @self
*
* Return value: (transfer none): a #ClutterConstraint for the given
* name, or %NULL. The returned #ClutterConstraint is owned by the
* actor and it should not be unreferenced directly
*
* Since: 1.4
*/
ClutterConstraint *
clutter_actor_get_constraint (ClutterActor *self,
const gchar *name)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
g_return_val_if_fail (name != NULL, NULL);
if (self->priv->constraints == NULL)
return NULL;
return CLUTTER_CONSTRAINT (_clutter_meta_group_get_meta (self->priv->constraints, name));
}
/**
* clutter_actor_clear_constraints:
* @self: a #ClutterActor
*
* Clears the list of constraints applied to @self
*
* Since: 1.4
*/
void
clutter_actor_clear_constraints (ClutterActor *self)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (self->priv->constraints == NULL)
return;
_clutter_meta_group_clear_metas_no_internal (self->priv->constraints);
clutter_actor_queue_relayout (self);
}
/**
* clutter_actor_set_clip_to_allocation:
* @self: a #ClutterActor
* @clip_set: %TRUE to apply a clip tracking the allocation
*
* Sets whether @self should be clipped to the same size as its
* allocation
*
* Since: 1.4
*/
void
clutter_actor_set_clip_to_allocation (ClutterActor *self,
gboolean clip_set)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
clip_set = !!clip_set;
priv = self->priv;
if (priv->clip_to_allocation != clip_set)
{
priv->clip_to_allocation = clip_set;
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_CLIP_TO_ALLOCATION]);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_HAS_CLIP]);
}
}
/**
* clutter_actor_get_clip_to_allocation:
* @self: a #ClutterActor
*
* Retrieves the value set using clutter_actor_set_clip_to_allocation()
*
* Return value: %TRUE if the #ClutterActor is clipped to its allocation
*
* Since: 1.4
*/
gboolean
clutter_actor_get_clip_to_allocation (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
return self->priv->clip_to_allocation;
}
/**
* clutter_actor_add_effect:
* @self: a #ClutterActor
* @effect: a #ClutterEffect
*
* Adds @effect to the list of #ClutterEffects applied to @self
*
* The #ClutterActor will hold a reference on the @effect until either
* clutter_actor_remove_effect() or clutter_actor_clear_effects() is
* called.
*
* Since: 1.4
*/
void
clutter_actor_add_effect (ClutterActor *self,
ClutterEffect *effect)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_EFFECT (effect));
_clutter_actor_add_effect_internal (self, effect);
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_EFFECT]);
}
/**
* clutter_actor_add_effect_with_name:
* @self: a #ClutterActor
* @name: the name to set on the effect
* @effect: a #ClutterEffect
*
* A convenience function for setting the name of a #ClutterEffect
* while adding it to the list of effectss applied to @self
*
* This function is the logical equivalent of:
*
* |[
* clutter_actor_meta_set_name (CLUTTER_ACTOR_META (effect), name);
* clutter_actor_add_effect (self, effect);
* ]|
*
* Since: 1.4
*/
void
clutter_actor_add_effect_with_name (ClutterActor *self,
const gchar *name,
ClutterEffect *effect)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (name != NULL);
g_return_if_fail (CLUTTER_IS_EFFECT (effect));
clutter_actor_meta_set_name (CLUTTER_ACTOR_META (effect), name);
clutter_actor_add_effect (self, effect);
}
/**
* clutter_actor_remove_effect:
* @self: a #ClutterActor
* @effect: a #ClutterEffect
*
* Removes @effect from the list of effects applied to @self
*
* The reference held by @self on the #ClutterEffect will be released
*
* Since: 1.4
*/
void
clutter_actor_remove_effect (ClutterActor *self,
ClutterEffect *effect)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (CLUTTER_IS_EFFECT (effect));
_clutter_actor_remove_effect_internal (self, effect);
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_EFFECT]);
}
/**
* clutter_actor_remove_effect_by_name:
* @self: a #ClutterActor
* @name: the name of the effect to remove
*
* Removes the #ClutterEffect with the given name from the list
* of effects applied to @self
*
* Since: 1.4
*/
void
clutter_actor_remove_effect_by_name (ClutterActor *self,
const gchar *name)
{
ClutterActorPrivate *priv;
ClutterActorMeta *meta;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (name != NULL);
priv = self->priv;
if (priv->effects == NULL)
return;
meta = _clutter_meta_group_get_meta (priv->effects, name);
if (meta == NULL)
return;
clutter_actor_remove_effect (self, CLUTTER_EFFECT (meta));
}
/**
* clutter_actor_get_effects:
* @self: a #ClutterActor
*
* Retrieves the #ClutterEffects applied on @self, if any
*
* Return value: (transfer container) (element-type Clutter.Effect): a list
* of #ClutterEffects, or %NULL. The elements of the returned
* list are owned by Clutter and they should not be freed. You should
* free the returned list using g_list_free() when done
*
* Since: 1.4
*/
GList *
clutter_actor_get_effects (ClutterActor *self)
{
ClutterActorPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
priv = self->priv;
if (priv->effects == NULL)
return NULL;
return _clutter_meta_group_get_metas_no_internal (priv->effects);
}
/**
* clutter_actor_get_effect:
* @self: a #ClutterActor
* @name: the name of the effect to retrieve
*
* Retrieves the #ClutterEffect with the given name in the list
* of effects applied to @self
*
* Return value: (transfer none): a #ClutterEffect for the given
* name, or %NULL. The returned #ClutterEffect is owned by the
* actor and it should not be unreferenced directly
*
* Since: 1.4
*/
ClutterEffect *
clutter_actor_get_effect (ClutterActor *self,
const gchar *name)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
g_return_val_if_fail (name != NULL, NULL);
if (self->priv->effects == NULL)
return NULL;
return CLUTTER_EFFECT (_clutter_meta_group_get_meta (self->priv->effects, name));
}
/**
* clutter_actor_clear_effects:
* @self: a #ClutterActor
*
* Clears the list of effects applied to @self
*
* Since: 1.4
*/
void
clutter_actor_clear_effects (ClutterActor *self)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (self->priv->effects == NULL)
return;
_clutter_meta_group_clear_metas_no_internal (self->priv->effects);
clutter_actor_queue_redraw (self);
}
/**
* clutter_actor_has_key_focus:
* @self: a #ClutterActor
*
* Checks whether @self is the #ClutterActor that has key focus
*
* Return value: %TRUE if the actor has key focus, and %FALSE otherwise
*
* Since: 1.4
*/
gboolean
clutter_actor_has_key_focus (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
return self->priv->has_key_focus;
}
static gboolean
_clutter_actor_get_paint_volume_real (ClutterActor *self,
ClutterPaintVolume *pv)
{
ClutterActorPrivate *priv = self->priv;
/* Actors are only expected to report a valid paint volume
* while they have a valid allocation. */
if (G_UNLIKELY (priv->needs_allocation))
{
CLUTTER_NOTE (CLIPPING, "Bail from get_paint_volume (%s): "
"Actor needs allocation",
_clutter_actor_get_debug_name (self));
return FALSE;
}
/* Check if there are any handlers connected to the paint
* signal. If there are then all bets are off for what the paint
* volume for this actor might possibly be!
*
* XXX: It's expected that this is going to end up being quite a
* costly check to have to do here, but we haven't come up with
* another solution that can reliably catch paint signal handlers at
* the right time to either avoid artefacts due to invalid stage
* clipping or due to incorrect culling.
*
* Previously we checked in clutter_actor_paint(), but at that time
* we may already be using a stage clip that could be derived from
* an invalid paint-volume. We used to try and handle that by
* queuing a follow up, unclipped, redraw but still the previous
* checking wasn't enough to catch invalid volumes involved in
* culling (considering that containers may derive their volume from
* children that haven't yet been painted)
*
* Longer term, improved solutions could be:
* - Disallow painting in the paint signal, only allow using it
* for tracking when paints happen. We can add another API that
* allows monkey patching the paint of arbitrary actors but in a
* more controlled way and that also supports modifying the
* paint-volume.
* - If we could be notified somehow when signal handlers are
* connected we wouldn't have to poll for handlers like this.
*
* XXX:2.0 - Remove when we remove the paint signal
*/
if (g_signal_has_handler_pending (self,
actor_signals[PAINT],
0,
TRUE))
{
CLUTTER_NOTE (CLIPPING, "Bail from get_paint_volume (%s): "
"Actor has \"paint\" signal handlers",
_clutter_actor_get_debug_name (self));
return FALSE;
}
_clutter_paint_volume_init_static (pv, self);
if (!CLUTTER_ACTOR_GET_CLASS (self)->get_paint_volume (self, pv))
{
clutter_paint_volume_free (pv);
CLUTTER_NOTE (CLIPPING, "Bail from get_paint_volume (%s): "
"Actor failed to report a volume",
_clutter_actor_get_debug_name (self));
return FALSE;
}
/* since effects can modify the paint volume, we allow them to actually
* do this by making get_paint_volume() "context sensitive"
*/
if (priv->effects != NULL)
{
if (priv->current_effect != NULL)
{
const GList *effects, *l;
/* if we are being called from within the paint sequence of
* an actor, get the paint volume up to the current effect
*/
effects = _clutter_meta_group_peek_metas (priv->effects);
for (l = effects;
l != NULL && l->data != priv->current_effect;
l = l->next)
{
if (!_clutter_effect_modify_paint_volume (l->data, pv))
{
clutter_paint_volume_free (pv);
CLUTTER_NOTE (CLIPPING, "Bail from get_paint_volume (%s): "
"Effect (%s) failed to report a volume",
_clutter_actor_get_debug_name (self),
_clutter_actor_meta_get_debug_name (l->data));
return FALSE;
}
}
}
else
{
const GList *effects, *l;
/* otherwise, get the cumulative volume */
effects = _clutter_meta_group_peek_metas (priv->effects);
for (l = effects; l != NULL; l = l->next)
if (!_clutter_effect_modify_paint_volume (l->data, pv))
{
clutter_paint_volume_free (pv);
CLUTTER_NOTE (CLIPPING, "Bail from get_paint_volume (%s): "
"Effect (%s) failed to report a volume",
_clutter_actor_get_debug_name (self),
_clutter_actor_meta_get_debug_name (l->data));
return FALSE;
}
}
}
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
* inadvertently modify it, but for internal uses we sometimes need
* access to the same PaintVolume but need to apply some book-keeping
* modifications to it so we don't want a const pointer.
*/
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 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;
priv->needs_paint_volume_update = FALSE;
return &priv->paint_volume;
}
else
{
priv->paint_volume_valid = FALSE;
return NULL;
}
}
/**
* clutter_actor_get_paint_volume:
* @self: a #ClutterActor
*
* Retrieves the paint volume of the passed #ClutterActor, or %NULL
* when a paint volume can't be determined.
*
* The paint volume is defined as the 3D space occupied by an actor
* when being painted.
*
* This function will call the #ClutterActorClass.get_paint_volume()
* virtual function of the #ClutterActor class. Sub-classes of #ClutterActor
* should not usually care about overriding the default implementation,
* unless they are, for instance: painting outside their allocation, or
* actors with a depth factor (not in terms of #ClutterActor:depth but real
* 3D depth).
*
* Note: 2D actors overriding #ClutterActorClass.get_paint_volume()
* should ensure that their volume has a depth of 0. (This will be true
* as long as you don't call clutter_paint_volume_set_depth().)
*
* Return value: (transfer none): a pointer to a #ClutterPaintVolume,
* or %NULL if no volume could be determined. The returned pointer
* is not guaranteed to be valid across multiple frames; if you want
* to keep it, you will need to copy it using clutter_paint_volume_copy().
*
* Since: 1.6
*/
const ClutterPaintVolume *
clutter_actor_get_paint_volume (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
return _clutter_actor_get_paint_volume_mutable (self);
}
/**
* clutter_actor_get_transformed_paint_volume:
* @self: a #ClutterActor
* @relative_to_ancestor: A #ClutterActor that is an ancestor of @self
* (or %NULL for the stage)
*
* Retrieves the 3D paint volume of an actor like
* clutter_actor_get_paint_volume() does (Please refer to the
* documentation of clutter_actor_get_paint_volume() for more
* details.) and it additionally transforms the paint volume into the
* coordinate space of @relative_to_ancestor. (Or the stage if %NULL
* is passed for @relative_to_ancestor)
*
* This can be used by containers that base their paint volume on
* the volume of their children. Such containers can query the
* transformed paint volume of all of its children and union them
* together using clutter_paint_volume_union().
*
* Return value: (transfer none): a pointer to a #ClutterPaintVolume,
* or %NULL if no volume could be determined. The returned pointer is
* not guaranteed to be valid across multiple frames; if you wish to
* keep it, you will have to copy it using clutter_paint_volume_copy().
*
* Since: 1.6
*/
const ClutterPaintVolume *
clutter_actor_get_transformed_paint_volume (ClutterActor *self,
ClutterActor *relative_to_ancestor)
{
const ClutterPaintVolume *volume;
ClutterActor *stage;
ClutterPaintVolume *transformed_volume;
stage = _clutter_actor_get_stage_internal (self);
if (G_UNLIKELY (stage == NULL))
return NULL;
if (relative_to_ancestor == NULL)
relative_to_ancestor = stage;
volume = clutter_actor_get_paint_volume (self);
if (volume == NULL)
return NULL;
transformed_volume =
_clutter_stage_paint_volume_stack_allocate (CLUTTER_STAGE (stage));
_clutter_paint_volume_copy_static (volume, transformed_volume);
_clutter_paint_volume_transform_relative (transformed_volume,
relative_to_ancestor);
return transformed_volume;
}
/**
* clutter_actor_get_paint_box:
* @self: a #ClutterActor
* @box: (out): return location for a #ClutterActorBox
*
* Retrieves the paint volume of the passed #ClutterActor, and
* transforms it into a 2D bounding box in stage coordinates.
*
* This function is useful to determine the on screen area occupied by
* the actor. The box is only an approximation and may often be
* considerably larger due to the optimizations used to calculate the
* box. The box is never smaller though, so it can reliably be used
* for culling.
*
* There are times when a 2D paint box can't be determined, e.g.
* because the actor isn't yet parented under a stage or because
* the actor is unable to determine a paint volume.
*
* Return value: %TRUE if a 2D paint box could be determined, else
* %FALSE.
*
* Since: 1.6
*/
gboolean
clutter_actor_get_paint_box (ClutterActor *self,
ClutterActorBox *box)
{
ClutterActor *stage;
ClutterPaintVolume *pv;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
g_return_val_if_fail (box != NULL, FALSE);
stage = _clutter_actor_get_stage_internal (self);
if (G_UNLIKELY (!stage))
return FALSE;
pv = _clutter_actor_get_paint_volume_mutable (self);
if (G_UNLIKELY (!pv))
return FALSE;
_clutter_paint_volume_get_stage_paint_box (pv, CLUTTER_STAGE (stage), box);
return TRUE;
}
static gboolean
_clutter_actor_get_resource_scale_for_rect (ClutterActor *self,
graphene_rect_t *bounding_rect,
float *resource_scale)
{
ClutterActor *stage;
float max_scale = 0;
stage = _clutter_actor_get_stage_internal (self);
if (!stage)
return FALSE;
if (!_clutter_stage_get_max_view_scale_factor_for_rect (CLUTTER_STAGE (stage),
bounding_rect,
&max_scale))
return FALSE;
*resource_scale = max_scale;
return TRUE;
}
static gboolean
_clutter_actor_compute_resource_scale (ClutterActor *self,
float *resource_scale)
{
graphene_rect_t bounding_rect;
ClutterActorPrivate *priv = self->priv;
if (CLUTTER_ACTOR_IN_DESTRUCTION (self) ||
CLUTTER_ACTOR_IN_PREF_SIZE (self) ||
!clutter_actor_is_mapped (self))
{
return FALSE;
}
clutter_actor_get_transformed_position (self,
&bounding_rect.origin.x,
&bounding_rect.origin.y);
clutter_actor_get_transformed_size (self,
&bounding_rect.size.width,
&bounding_rect.size.height);
if (bounding_rect.size.width == 0.0 ||
bounding_rect.size.height == 0.0 ||
!_clutter_actor_get_resource_scale_for_rect (self,
&bounding_rect,
resource_scale))
{
if (priv->parent)
{
gboolean in_clone_paint;
gboolean was_parent_in_clone_paint;
gboolean was_parent_unmapped;
gboolean was_parent_paint_unmapped;
gboolean ret;
in_clone_paint = clutter_actor_is_in_clone_paint (self);
was_parent_unmapped = !clutter_actor_is_mapped (priv->parent);
was_parent_in_clone_paint =
clutter_actor_is_in_clone_paint (priv->parent);
was_parent_paint_unmapped = priv->parent->priv->enable_paint_unmapped;
if (in_clone_paint && was_parent_unmapped)
{
_clutter_actor_set_in_clone_paint (priv->parent, TRUE);
_clutter_actor_set_enable_paint_unmapped (priv->parent, TRUE);
}
ret = _clutter_actor_compute_resource_scale (priv->parent,
resource_scale);
if (in_clone_paint && was_parent_unmapped)
{
_clutter_actor_set_in_clone_paint (priv->parent,
was_parent_in_clone_paint);
_clutter_actor_set_enable_paint_unmapped (priv->parent,
was_parent_paint_unmapped);
}
return ret;
}
else
{
return FALSE;
}
}
return TRUE;
}
static ClutterActorTraverseVisitFlags
queue_update_resource_scale_cb (ClutterActor *actor,
int depth,
void *user_data)
{
actor->priv->needs_compute_resource_scale = TRUE;
return CLUTTER_ACTOR_TRAVERSE_VISIT_CONTINUE;
}
void
_clutter_actor_queue_update_resource_scale_recursive (ClutterActor *self)
{
_clutter_actor_traverse (self,
CLUTTER_ACTOR_TRAVERSE_DEPTH_FIRST,
queue_update_resource_scale_cb,
NULL,
NULL);
}
static gboolean
clutter_actor_update_resource_scale (ClutterActor *self)
{
ClutterActorPrivate *priv;
float resource_scale;
float old_resource_scale;
priv = self->priv;
g_return_val_if_fail (priv->needs_compute_resource_scale, FALSE);
old_resource_scale = priv->resource_scale;
priv->resource_scale = -1.0f;
if (_clutter_actor_compute_resource_scale (self, &resource_scale))
{
priv->resource_scale = resource_scale;
priv->needs_compute_resource_scale = FALSE;
return fabsf (old_resource_scale - resource_scale) > FLT_EPSILON;
}
return FALSE;
}
static void
clutter_actor_ensure_resource_scale (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
if (!priv->needs_compute_resource_scale)
return;
if (clutter_actor_update_resource_scale (self))
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_RESOURCE_SCALE]);
}
gboolean
_clutter_actor_get_real_resource_scale (ClutterActor *self,
gfloat *resource_scale)
{
ClutterActorPrivate *priv = self->priv;
clutter_actor_ensure_resource_scale (self);
if (!priv->needs_compute_resource_scale)
{
*resource_scale = priv->resource_scale;
return TRUE;
}
*resource_scale = -1.0f;
return FALSE;
}
/**
* clutter_actor_get_resource_scale:
* @self: A #ClutterActor
* @resource_scale: (out): return location for the resource scale
*
* Retrieves the resource scale for this actor, if available.
*
* The resource scale refers to the scale the actor should use for its resources.
* For example if an actor draws a a picture of size 100 x 100 in the stage
* coordinate space, it should use a texture of twice the size (i.e. 200 x 200)
* if the resource scale is 2.
*
* The resource scale is determined by calculating the highest #ClutterStageView
* scale the actor will get painted on.
*
* Returns: TRUE if resource scale is set for the actor, otherwise FALSE
*/
gboolean
clutter_actor_get_resource_scale (ClutterActor *self,
gfloat *resource_scale)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
g_return_val_if_fail (resource_scale != NULL, FALSE);
if (_clutter_actor_get_real_resource_scale (self, resource_scale))
{
*resource_scale = ceilf (*resource_scale);
return TRUE;
}
return FALSE;
}
/**
* clutter_actor_has_overlaps:
* @self: A #ClutterActor
*
* Asks the actor's implementation whether it may contain overlapping
* primitives.
*
* For example; Clutter may use this to determine whether the painting
* should be redirected to an offscreen buffer to correctly implement
* the opacity property.
*
* Custom actors can override the default response by implementing the
* #ClutterActorClass.has_overlaps() virtual function. See
* clutter_actor_set_offscreen_redirect() for more information.
*
* Return value: %TRUE if the actor may have overlapping primitives, and
* %FALSE otherwise
*
* Since: 1.8
*/
gboolean
clutter_actor_has_overlaps (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), TRUE);
return CLUTTER_ACTOR_GET_CLASS (self)->has_overlaps (self);
}
/**
* clutter_actor_has_effects:
* @self: A #ClutterActor
*
* Returns whether the actor has any effects applied.
*
* Return value: %TRUE if the actor has any effects,
* %FALSE otherwise
*
* Since: 1.10
*/
gboolean
clutter_actor_has_effects (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
if (self->priv->effects == NULL)
return FALSE;
return _clutter_meta_group_has_metas_no_internal (self->priv->effects);
}
/**
* clutter_actor_has_constraints:
* @self: A #ClutterActor
*
* Returns whether the actor has any constraints applied.
*
* Return value: %TRUE if the actor has any constraints,
* %FALSE otherwise
*
* Since: 1.10
*/
gboolean
clutter_actor_has_constraints (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
if (self->priv->constraints == NULL)
return FALSE;
return _clutter_meta_group_has_metas_no_internal (self->priv->constraints);
}
/**
* clutter_actor_has_actions:
* @self: A #ClutterActor
*
* Returns whether the actor has any actions applied.
*
* Return value: %TRUE if the actor has any actions,
* %FALSE otherwise
*
* Since: 1.10
*/
gboolean
clutter_actor_has_actions (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
if (self->priv->actions == NULL)
return FALSE;
return _clutter_meta_group_has_metas_no_internal (self->priv->actions);
}
/**
* clutter_actor_get_n_children:
* @self: a #ClutterActor
*
* Retrieves the number of children of @self.
*
* Return value: the number of children of an actor
*
* Since: 1.10
*/
gint
clutter_actor_get_n_children (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
return self->priv->n_children;
}
/**
* clutter_actor_get_child_at_index:
* @self: a #ClutterActor
* @index_: the position in the list of children
*
* Retrieves the actor at the given @index_ inside the list of
* children of @self.
*
* Return value: (transfer none): a pointer to a #ClutterActor, or %NULL
*
* Since: 1.10
*/
ClutterActor *
clutter_actor_get_child_at_index (ClutterActor *self,
gint index_)
{
ClutterActor *iter;
int i;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
g_return_val_if_fail (index_ <= self->priv->n_children, NULL);
for (iter = self->priv->first_child, i = 0;
iter != NULL && i < index_;
iter = iter->priv->next_sibling, i += 1)
;
return iter;
}
/*< private >
* _clutter_actor_foreach_child:
* @actor: The actor whos children you want to iterate
* @callback: The function to call for each child
* @user_data: Private data to pass to @callback
*
* Calls a given @callback once for each child of the specified @actor and
* passing the @user_data pointer each time.
*
* Return value: returns %TRUE if all children were iterated, else
* %FALSE if a callback broke out of iteration early.
*/
gboolean
_clutter_actor_foreach_child (ClutterActor *self,
ClutterForeachCallback callback,
gpointer user_data)
{
ClutterActor *iter;
gboolean cont;
if (self->priv->first_child == NULL)
return TRUE;
cont = TRUE;
iter = self->priv->first_child;
/* we use this form so that it's safe to change the children
* list while iterating it
*/
while (cont && iter != NULL)
{
ClutterActor *next = iter->priv->next_sibling;
cont = callback (iter, user_data);
iter = next;
}
return cont;
}
#if 0
/* For debugging purposes this gives us a simple way to print out
* the scenegraph e.g in gdb using:
* [|
* _clutter_actor_traverse (stage,
* 0,
* clutter_debug_print_actor_cb,
* NULL,
* NULL);
* |]
*/
static ClutterActorTraverseVisitFlags
clutter_debug_print_actor_cb (ClutterActor *actor,
int depth,
void *user_data)
{
g_print ("%*s%s:%p\n",
depth * 2, "",
_clutter_actor_get_debug_name (actor),
actor);
return CLUTTER_ACTOR_TRAVERSE_VISIT_CONTINUE;
}
#endif
static void
_clutter_actor_traverse_breadth (ClutterActor *actor,
ClutterTraverseCallback callback,
gpointer user_data)
{
GQueue *queue = g_queue_new ();
ClutterActor dummy;
int current_depth = 0;
g_queue_push_tail (queue, actor);
g_queue_push_tail (queue, &dummy); /* use to delimit depth changes */
while ((actor = g_queue_pop_head (queue)))
{
ClutterActorTraverseVisitFlags flags;
if (actor == &dummy)
{
current_depth++;
g_queue_push_tail (queue, &dummy);
continue;
}
flags = callback (actor, current_depth, user_data);
if (flags & CLUTTER_ACTOR_TRAVERSE_VISIT_BREAK)
break;
else if (!(flags & CLUTTER_ACTOR_TRAVERSE_VISIT_SKIP_CHILDREN))
{
ClutterActor *iter;
for (iter = actor->priv->first_child;
iter != NULL;
iter = iter->priv->next_sibling)
{
g_queue_push_tail (queue, iter);
}
}
}
g_queue_free (queue);
}
static ClutterActorTraverseVisitFlags
_clutter_actor_traverse_depth (ClutterActor *actor,
ClutterTraverseCallback before_children_callback,
ClutterTraverseCallback after_children_callback,
int current_depth,
gpointer user_data)
{
ClutterActorTraverseVisitFlags flags;
flags = before_children_callback (actor, current_depth, user_data);
if (flags & CLUTTER_ACTOR_TRAVERSE_VISIT_BREAK)
return CLUTTER_ACTOR_TRAVERSE_VISIT_BREAK;
if (!(flags & CLUTTER_ACTOR_TRAVERSE_VISIT_SKIP_CHILDREN))
{
ClutterActor *iter;
for (iter = actor->priv->first_child;
iter != NULL;
iter = iter->priv->next_sibling)
{
flags = _clutter_actor_traverse_depth (iter,
before_children_callback,
after_children_callback,
current_depth + 1,
user_data);
if (flags & CLUTTER_ACTOR_TRAVERSE_VISIT_BREAK)
return CLUTTER_ACTOR_TRAVERSE_VISIT_BREAK;
}
}
if (after_children_callback)
return after_children_callback (actor, current_depth, user_data);
else
return CLUTTER_ACTOR_TRAVERSE_VISIT_CONTINUE;
}
/* _clutter_actor_traverse:
* @actor: The actor to start traversing the graph from
* @flags: These flags may affect how the traversal is done
* @before_children_callback: A function to call before visiting the
* children of the current actor.
* @after_children_callback: A function to call after visiting the
* children of the current actor. (Ignored if
* %CLUTTER_ACTOR_TRAVERSE_BREADTH_FIRST is passed to @flags.)
* @user_data: The private data to pass to the callbacks
*
* Traverses the scenegraph starting at the specified @actor and
* descending through all its children and its children's children.
* For each actor traversed @before_children_callback and
* @after_children_callback are called with the specified
* @user_data, before and after visiting that actor's children.
*
* The callbacks can return flags that affect the ongoing traversal
* such as by skipping over an actors children or bailing out of
* any further traversing.
*/
void
_clutter_actor_traverse (ClutterActor *actor,
ClutterActorTraverseFlags flags,
ClutterTraverseCallback before_children_callback,
ClutterTraverseCallback after_children_callback,
gpointer user_data)
{
if (flags & CLUTTER_ACTOR_TRAVERSE_BREADTH_FIRST)
_clutter_actor_traverse_breadth (actor,
before_children_callback,
user_data);
else /* DEPTH_FIRST */
_clutter_actor_traverse_depth (actor,
before_children_callback,
after_children_callback,
0, /* start depth */
user_data);
}
static void
on_layout_manager_changed (ClutterLayoutManager *manager,
ClutterActor *self)
{
clutter_actor_queue_relayout (self);
}
/**
* clutter_actor_set_layout_manager:
* @self: a #ClutterActor
* @manager: (allow-none): a #ClutterLayoutManager, or %NULL to unset it
*
* Sets the #ClutterLayoutManager delegate object that will be used to
* lay out the children of @self.
*
* The #ClutterActor will take a reference on the passed @manager which
* will be released either when the layout manager is removed, or when
* the actor is destroyed.
*
* Since: 1.10
*/
void
clutter_actor_set_layout_manager (ClutterActor *self,
ClutterLayoutManager *manager)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (manager == NULL || CLUTTER_IS_LAYOUT_MANAGER (manager));
priv = self->priv;
if (priv->layout_manager != NULL)
{
g_signal_handlers_disconnect_by_func (priv->layout_manager,
G_CALLBACK (on_layout_manager_changed),
self);
clutter_layout_manager_set_container (priv->layout_manager, NULL);
g_clear_object (&priv->layout_manager);
}
priv->layout_manager = manager;
if (priv->layout_manager != NULL)
{
g_object_ref_sink (priv->layout_manager);
clutter_layout_manager_set_container (priv->layout_manager,
CLUTTER_CONTAINER (self));
g_signal_connect (priv->layout_manager, "layout-changed",
G_CALLBACK (on_layout_manager_changed),
self);
}
clutter_actor_queue_relayout (self);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_LAYOUT_MANAGER]);
}
/**
* clutter_actor_get_layout_manager:
* @self: a #ClutterActor
*
* Retrieves the #ClutterLayoutManager used by @self.
*
* Return value: (transfer none): a pointer to the #ClutterLayoutManager,
* or %NULL
*
* Since: 1.10
*/
ClutterLayoutManager *
clutter_actor_get_layout_manager (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
return self->priv->layout_manager;
}
static const ClutterLayoutInfo default_layout_info = {
GRAPHENE_POINT_INIT_ZERO, /* fixed-pos */
{ 0, 0, 0, 0 }, /* margin */
CLUTTER_ACTOR_ALIGN_FILL, /* x-align */
CLUTTER_ACTOR_ALIGN_FILL, /* y-align */
FALSE, FALSE, /* expand */
GRAPHENE_SIZE_INIT_ZERO, /* minimum */
GRAPHENE_SIZE_INIT_ZERO, /* natural */
};
static void
layout_info_free (gpointer data)
{
if (G_LIKELY (data != NULL))
g_slice_free (ClutterLayoutInfo, data);
}
/*< private >
* _clutter_actor_peek_layout_info:
* @self: a #ClutterActor
*
* Retrieves a pointer to the ClutterLayoutInfo structure.
*
* If the actor does not have a ClutterLayoutInfo associated to it, %NULL is returned.
*
* Return value: (transfer none): a pointer to the ClutterLayoutInfo structure
*/
ClutterLayoutInfo *
_clutter_actor_peek_layout_info (ClutterActor *self)
{
return g_object_get_qdata (G_OBJECT (self), quark_actor_layout_info);
}
/*< private >
* _clutter_actor_get_layout_info:
* @self: a #ClutterActor
*
* Retrieves a pointer to the ClutterLayoutInfo structure.
*
* If the actor does not have a ClutterLayoutInfo associated to it, one
* will be created and initialized to the default values.
*
* This function should be used for setters.
*
* For getters, you should use _clutter_actor_get_layout_info_or_defaults()
* instead.
*
* Return value: (transfer none): a pointer to the ClutterLayoutInfo structure
*/
ClutterLayoutInfo *
_clutter_actor_get_layout_info (ClutterActor *self)
{
ClutterLayoutInfo *retval;
retval = _clutter_actor_peek_layout_info (self);
if (retval == NULL)
{
retval = g_slice_new (ClutterLayoutInfo);
*retval = default_layout_info;
g_object_set_qdata_full (G_OBJECT (self), quark_actor_layout_info,
retval,
layout_info_free);
}
return retval;
}
/*< private >
* _clutter_actor_get_layout_info_or_defaults:
* @self: a #ClutterActor
*
* Retrieves the ClutterLayoutInfo structure associated to an actor.
*
* If the actor does not have a ClutterLayoutInfo structure associated to it,
* then the default structure will be returned.
*
* This function should only be used for getters.
*
* Return value: a const pointer to the ClutterLayoutInfo structure
*/
const ClutterLayoutInfo *
_clutter_actor_get_layout_info_or_defaults (ClutterActor *self)
{
const ClutterLayoutInfo *info;
info = _clutter_actor_peek_layout_info (self);
if (info == NULL)
return &default_layout_info;
return info;
}
/**
* clutter_actor_set_x_align:
* @self: a #ClutterActor
* @x_align: the horizontal alignment policy
*
* Sets the horizontal alignment policy of a #ClutterActor, in case the
* actor received extra horizontal space.
*
* See also the #ClutterActor:x-align property.
*
* Since: 1.10
*/
void
clutter_actor_set_x_align (ClutterActor *self,
ClutterActorAlign x_align)
{
ClutterLayoutInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_layout_info (self);
if (info->x_align != x_align)
{
info->x_align = x_align;
clutter_actor_queue_relayout (self);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_X_ALIGN]);
}
}
/**
* clutter_actor_get_x_align:
* @self: a #ClutterActor
*
* Retrieves the horizontal alignment policy set using
* clutter_actor_set_x_align().
*
* Return value: the horizontal alignment policy.
*
* Since: 1.10
*/
ClutterActorAlign
clutter_actor_get_x_align (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), CLUTTER_ACTOR_ALIGN_FILL);
return _clutter_actor_get_layout_info_or_defaults (self)->x_align;
}
/**
* clutter_actor_set_y_align:
* @self: a #ClutterActor
* @y_align: the vertical alignment policy
*
* Sets the vertical alignment policy of a #ClutterActor, in case the
* actor received extra vertical space.
*
* See also the #ClutterActor:y-align property.
*
* Since: 1.10
*/
void
clutter_actor_set_y_align (ClutterActor *self,
ClutterActorAlign y_align)
{
ClutterLayoutInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_layout_info (self);
if (info->y_align != y_align)
{
info->y_align = y_align;
clutter_actor_queue_relayout (self);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_Y_ALIGN]);
}
}
/**
* clutter_actor_get_y_align:
* @self: a #ClutterActor
*
* Retrieves the vertical alignment policy set using
* clutter_actor_set_y_align().
*
* Return value: the vertical alignment policy.
*
* Since: 1.10
*/
ClutterActorAlign
clutter_actor_get_y_align (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), CLUTTER_ACTOR_ALIGN_FILL);
return _clutter_actor_get_layout_info_or_defaults (self)->y_align;
}
static inline void
clutter_actor_set_margin_internal (ClutterActor *self,
gfloat margin,
GParamSpec *pspec)
{
ClutterLayoutInfo *info;
info = _clutter_actor_get_layout_info (self);
if (pspec == obj_props[PROP_MARGIN_TOP])
info->margin.top = margin;
else if (pspec == obj_props[PROP_MARGIN_RIGHT])
info->margin.right = margin;
else if (pspec == obj_props[PROP_MARGIN_BOTTOM])
info->margin.bottom = margin;
else
info->margin.left = margin;
clutter_actor_queue_relayout (self);
g_object_notify_by_pspec (G_OBJECT (self), pspec);
}
/**
* clutter_actor_set_margin:
* @self: a #ClutterActor
* @margin: a #ClutterMargin
*
* Sets all the components of the margin of a #ClutterActor.
*
* Since: 1.10
*/
void
clutter_actor_set_margin (ClutterActor *self,
const ClutterMargin *margin)
{
ClutterLayoutInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (margin != NULL);
info = _clutter_actor_get_layout_info (self);
if (info->margin.top != margin->top)
clutter_actor_set_margin_top (self, margin->top);
if (info->margin.right != margin->right)
clutter_actor_set_margin_right (self, margin->right);
if (info->margin.bottom != margin->bottom)
clutter_actor_set_margin_bottom (self, margin->bottom);
if (info->margin.left != margin->left)
clutter_actor_set_margin_left (self, margin->left);
}
/**
* clutter_actor_get_margin:
* @self: a #ClutterActor
* @margin: (out caller-allocates): return location for a #ClutterMargin
*
* Retrieves all the components of the margin of a #ClutterActor.
*
* Since: 1.10
*/
void
clutter_actor_get_margin (ClutterActor *self,
ClutterMargin *margin)
{
const ClutterLayoutInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (margin != NULL);
info = _clutter_actor_get_layout_info_or_defaults (self);
*margin = info->margin;
}
/**
* clutter_actor_set_margin_top:
* @self: a #ClutterActor
* @margin: the top margin
*
* Sets the margin from the top of a #ClutterActor.
*
* The #ClutterActor:margin-top property is animatable.
*
* Since: 1.10
*/
void
clutter_actor_set_margin_top (ClutterActor *self,
gfloat margin)
{
const ClutterLayoutInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (margin >= 0.f);
info = _clutter_actor_get_layout_info_or_defaults (self);
if (info->margin.top == margin)
return;
_clutter_actor_create_transition (self, obj_props[PROP_MARGIN_TOP],
info->margin.top,
margin);
}
/**
* clutter_actor_get_margin_top:
* @self: a #ClutterActor
*
* Retrieves the top margin of a #ClutterActor.
*
* Return value: the top margin
*
* Since: 1.10
*/
gfloat
clutter_actor_get_margin_top (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0.f);
return _clutter_actor_get_layout_info_or_defaults (self)->margin.top;
}
/**
* clutter_actor_set_margin_bottom:
* @self: a #ClutterActor
* @margin: the bottom margin
*
* Sets the margin from the bottom of a #ClutterActor.
*
* The #ClutterActor:margin-bottom property is animatable.
*
* Since: 1.10
*/
void
clutter_actor_set_margin_bottom (ClutterActor *self,
gfloat margin)
{
const ClutterLayoutInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (margin >= 0.f);
info = _clutter_actor_get_layout_info_or_defaults (self);
if (info->margin.bottom == margin)
return;
_clutter_actor_create_transition (self, obj_props[PROP_MARGIN_BOTTOM],
info->margin.bottom,
margin);
}
/**
* clutter_actor_get_margin_bottom:
* @self: a #ClutterActor
*
* Retrieves the bottom margin of a #ClutterActor.
*
* Return value: the bottom margin
*
* Since: 1.10
*/
gfloat
clutter_actor_get_margin_bottom (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0.f);
return _clutter_actor_get_layout_info_or_defaults (self)->margin.bottom;
}
/**
* clutter_actor_set_margin_left:
* @self: a #ClutterActor
* @margin: the left margin
*
* Sets the margin from the left of a #ClutterActor.
*
* The #ClutterActor:margin-left property is animatable.
*
* Since: 1.10
*/
void
clutter_actor_set_margin_left (ClutterActor *self,
gfloat margin)
{
const ClutterLayoutInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (margin >= 0.f);
info = _clutter_actor_get_layout_info_or_defaults (self);
if (info->margin.left == margin)
return;
_clutter_actor_create_transition (self, obj_props[PROP_MARGIN_LEFT],
info->margin.left,
margin);
}
/**
* clutter_actor_get_margin_left:
* @self: a #ClutterActor
*
* Retrieves the left margin of a #ClutterActor.
*
* Return value: the left margin
*
* Since: 1.10
*/
gfloat
clutter_actor_get_margin_left (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0.f);
return _clutter_actor_get_layout_info_or_defaults (self)->margin.left;
}
/**
* clutter_actor_set_margin_right:
* @self: a #ClutterActor
* @margin: the right margin
*
* Sets the margin from the right of a #ClutterActor.
*
* The #ClutterActor:margin-right property is animatable.
*
* Since: 1.10
*/
void
clutter_actor_set_margin_right (ClutterActor *self,
gfloat margin)
{
const ClutterLayoutInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (margin >= 0.f);
info = _clutter_actor_get_layout_info_or_defaults (self);
if (info->margin.right == margin)
return;
_clutter_actor_create_transition (self, obj_props[PROP_MARGIN_RIGHT],
info->margin.right,
margin);
}
/**
* clutter_actor_get_margin_right:
* @self: a #ClutterActor
*
* Retrieves the right margin of a #ClutterActor.
*
* Return value: the right margin
*
* Since: 1.10
*/
gfloat
clutter_actor_get_margin_right (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0.f);
return _clutter_actor_get_layout_info_or_defaults (self)->margin.right;
}
static inline void
clutter_actor_set_background_color_internal (ClutterActor *self,
const ClutterColor *color)
{
ClutterActorPrivate *priv = self->priv;
GObject *obj;
if (priv->bg_color_set && clutter_color_equal (color, &priv->bg_color))
return;
obj = G_OBJECT (self);
priv->bg_color = *color;
priv->bg_color_set = TRUE;
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (obj, obj_props[PROP_BACKGROUND_COLOR_SET]);
g_object_notify_by_pspec (obj, obj_props[PROP_BACKGROUND_COLOR]);
}
/**
* clutter_actor_set_background_color:
* @self: a #ClutterActor
* @color: (allow-none): a #ClutterColor, or %NULL to unset a previously
* set color
*
* Sets the background color of a #ClutterActor.
*
* The background color will be used to cover the whole allocation of the
* actor. The default background color of an actor is transparent.
*
* To check whether an actor has a background color, you can use the
* #ClutterActor:background-color-set actor property.
*
* The #ClutterActor:background-color property is animatable.
*
* Since: 1.10
*/
void
clutter_actor_set_background_color (ClutterActor *self,
const ClutterColor *color)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
if (color == NULL)
{
GObject *obj = G_OBJECT (self);
priv->bg_color_set = FALSE;
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (obj, obj_props[PROP_BACKGROUND_COLOR_SET]);
}
else
_clutter_actor_create_transition (self,
obj_props[PROP_BACKGROUND_COLOR],
&priv->bg_color,
color);
}
/**
* clutter_actor_get_background_color:
* @self: a #ClutterActor
* @color: (out caller-allocates): return location for a #ClutterColor
*
* Retrieves the color set using clutter_actor_set_background_color().
*
* Since: 1.10
*/
void
clutter_actor_get_background_color (ClutterActor *self,
ClutterColor *color)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (color != NULL);
*color = self->priv->bg_color;
}
/**
* clutter_actor_get_previous_sibling:
* @self: a #ClutterActor
*
* Retrieves the sibling of @self that comes before it in the list
* of children of @self's parent.
*
* The returned pointer is only valid until the scene graph changes; it
* is not safe to modify the list of children of @self while iterating
* it.
*
* Return value: (transfer none): a pointer to a #ClutterActor, or %NULL
*
* Since: 1.10
*/
ClutterActor *
clutter_actor_get_previous_sibling (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
return self->priv->prev_sibling;
}
/**
* clutter_actor_get_next_sibling:
* @self: a #ClutterActor
*
* Retrieves the sibling of @self that comes after it in the list
* of children of @self's parent.
*
* The returned pointer is only valid until the scene graph changes; it
* is not safe to modify the list of children of @self while iterating
* it.
*
* Return value: (transfer none): a pointer to a #ClutterActor, or %NULL
*
* Since: 1.10
*/
ClutterActor *
clutter_actor_get_next_sibling (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
return self->priv->next_sibling;
}
/**
* clutter_actor_get_first_child:
* @self: a #ClutterActor
*
* Retrieves the first child of @self.
*
* The returned pointer is only valid until the scene graph changes; it
* is not safe to modify the list of children of @self while iterating
* it.
*
* Return value: (transfer none): a pointer to a #ClutterActor, or %NULL
*
* Since: 1.10
*/
ClutterActor *
clutter_actor_get_first_child (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
return self->priv->first_child;
}
/**
* clutter_actor_get_last_child:
* @self: a #ClutterActor
*
* Retrieves the last child of @self.
*
* The returned pointer is only valid until the scene graph changes; it
* is not safe to modify the list of children of @self while iterating
* it.
*
* Return value: (transfer none): a pointer to a #ClutterActor, or %NULL
*
* Since: 1.10
*/
ClutterActor *
clutter_actor_get_last_child (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
return self->priv->last_child;
}
/* easy way to have properly named fields instead of the dummy ones
* we use in the public structure
*/
typedef struct _RealActorIter
{
ClutterActor *root; /* dummy1 */
ClutterActor *current; /* dummy2 */
gpointer padding_1; /* dummy3 */
gint age; /* dummy4 */
gpointer padding_2; /* dummy5 */
} RealActorIter;
/**
* clutter_actor_iter_init:
* @iter: a #ClutterActorIter
* @root: a #ClutterActor
*
* Initializes a #ClutterActorIter, which can then be used to iterate
* efficiently over a section of the scene graph, and associates it
* with @root.
*
* Modifying the scene graph section that contains @root will invalidate
* the iterator.
*
* |[
* ClutterActorIter iter;
* ClutterActor *child;
*
* clutter_actor_iter_init (&iter, container);
* while (clutter_actor_iter_next (&iter, &child))
* {
* // do something with child
* }
* ]|
*
* Since: 1.10
*/
void
clutter_actor_iter_init (ClutterActorIter *iter,
ClutterActor *root)
{
RealActorIter *ri = (RealActorIter *) iter;
g_return_if_fail (iter != NULL);
g_return_if_fail (CLUTTER_IS_ACTOR (root));
ri->root = root;
ri->current = NULL;
ri->age = root->priv->age;
}
/**
* clutter_actor_iter_is_valid:
* @iter: a #ClutterActorIter
*
* Checks whether a #ClutterActorIter is still valid.
*
* An iterator is considered valid if it has been initialized, and
* if the #ClutterActor that it refers to hasn't been modified after
* the initialization.
*
* Return value: %TRUE if the iterator is valid, and %FALSE otherwise
*
* Since: 1.12
*/
gboolean
clutter_actor_iter_is_valid (const ClutterActorIter *iter)
{
RealActorIter *ri = (RealActorIter *) iter;
g_return_val_if_fail (iter != NULL, FALSE);
if (ri->root == NULL)
return FALSE;
return ri->root->priv->age == ri->age;
}
/**
* clutter_actor_iter_next:
* @iter: a #ClutterActorIter
* @child: (out) (transfer none): return location for a #ClutterActor
*
* Advances the @iter and retrieves the next child of the root #ClutterActor
* that was used to initialize the #ClutterActorIterator.
*
* If the iterator can advance, this function returns %TRUE and sets the
* @child argument.
*
* If the iterator cannot advance, this function returns %FALSE, and
* the contents of @child are undefined.
*
* Return value: %TRUE if the iterator could advance, and %FALSE otherwise.
*
* Since: 1.10
*/
gboolean
clutter_actor_iter_next (ClutterActorIter *iter,
ClutterActor **child)
{
RealActorIter *ri = (RealActorIter *) iter;
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (ri->root != NULL, FALSE);
#ifndef G_DISABLE_ASSERT
g_return_val_if_fail (ri->age == ri->root->priv->age, FALSE);
#endif
if (ri->current == NULL)
ri->current = ri->root->priv->first_child;
else
ri->current = ri->current->priv->next_sibling;
if (child != NULL)
*child = ri->current;
return ri->current != NULL;
}
/**
* clutter_actor_iter_prev:
* @iter: a #ClutterActorIter
* @child: (out) (transfer none): return location for a #ClutterActor
*
* Advances the @iter and retrieves the previous child of the root
* #ClutterActor that was used to initialize the #ClutterActorIterator.
*
* If the iterator can advance, this function returns %TRUE and sets the
* @child argument.
*
* If the iterator cannot advance, this function returns %FALSE, and
* the contents of @child are undefined.
*
* Return value: %TRUE if the iterator could advance, and %FALSE otherwise.
*
* Since: 1.10
*/
gboolean
clutter_actor_iter_prev (ClutterActorIter *iter,
ClutterActor **child)
{
RealActorIter *ri = (RealActorIter *) iter;
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (ri->root != NULL, FALSE);
#ifndef G_DISABLE_ASSERT
g_return_val_if_fail (ri->age == ri->root->priv->age, FALSE);
#endif
if (ri->current == NULL)
ri->current = ri->root->priv->last_child;
else
ri->current = ri->current->priv->prev_sibling;
if (child != NULL)
*child = ri->current;
return ri->current != NULL;
}
/**
* clutter_actor_iter_remove:
* @iter: a #ClutterActorIter
*
* Safely removes the #ClutterActor currently pointer to by the iterator
* from its parent.
*
* This function can only be called after clutter_actor_iter_next() or
* clutter_actor_iter_prev() returned %TRUE, and cannot be called more
* than once for the same actor.
*
* This function will call clutter_actor_remove_child() internally.
*
* Since: 1.10
*/
void
clutter_actor_iter_remove (ClutterActorIter *iter)
{
RealActorIter *ri = (RealActorIter *) iter;
ClutterActor *cur;
g_return_if_fail (iter != NULL);
g_return_if_fail (ri->root != NULL);
#ifndef G_DISABLE_ASSERT
g_return_if_fail (ri->age == ri->root->priv->age);
#endif
g_return_if_fail (ri->current != NULL);
cur = ri->current;
if (cur != NULL)
{
ri->current = cur->priv->prev_sibling;
clutter_actor_remove_child_internal (ri->root, cur,
REMOVE_CHILD_DEFAULT_FLAGS);
ri->age += 1;
}
}
/**
* clutter_actor_iter_destroy:
* @iter: a #ClutterActorIter
*
* Safely destroys the #ClutterActor currently pointer to by the iterator
* from its parent.
*
* This function can only be called after clutter_actor_iter_next() or
* clutter_actor_iter_prev() returned %TRUE, and cannot be called more
* than once for the same actor.
*
* This function will call clutter_actor_destroy() internally.
*
* Since: 1.10
*/
void
clutter_actor_iter_destroy (ClutterActorIter *iter)
{
RealActorIter *ri = (RealActorIter *) iter;
ClutterActor *cur;
g_return_if_fail (iter != NULL);
g_return_if_fail (ri->root != NULL);
#ifndef G_DISABLE_ASSERT
g_return_if_fail (ri->age == ri->root->priv->age);
#endif
g_return_if_fail (ri->current != NULL);
cur = ri->current;
if (cur != NULL)
{
ri->current = cur->priv->prev_sibling;
clutter_actor_destroy (cur);
ri->age += 1;
}
}
static const ClutterAnimationInfo default_animation_info = {
NULL, /* states */
NULL, /* cur_state */
NULL, /* transitions */
};
static void
clutter_animation_info_free (gpointer data)
{
if (data != NULL)
{
ClutterAnimationInfo *info = data;
if (info->transitions != NULL)
g_hash_table_unref (info->transitions);
if (info->states != NULL)
g_array_unref (info->states);
g_slice_free (ClutterAnimationInfo, info);
}
}
const ClutterAnimationInfo *
_clutter_actor_get_animation_info_or_defaults (ClutterActor *self)
{
const ClutterAnimationInfo *res;
GObject *obj = G_OBJECT (self);
res = g_object_get_qdata (obj, quark_actor_animation_info);
if (res != NULL)
return res;
return &default_animation_info;
}
ClutterAnimationInfo *
_clutter_actor_get_animation_info (ClutterActor *self)
{
GObject *obj = G_OBJECT (self);
ClutterAnimationInfo *res;
res = g_object_get_qdata (obj, quark_actor_animation_info);
if (res == NULL)
{
res = g_slice_new (ClutterAnimationInfo);
*res = default_animation_info;
g_object_set_qdata_full (obj, quark_actor_animation_info,
res,
clutter_animation_info_free);
}
return res;
}
static void
transition_closure_free (gpointer data)
{
if (G_LIKELY (data != NULL))
{
TransitionClosure *clos = data;
ClutterTimeline *timeline;
timeline = CLUTTER_TIMELINE (clos->transition);
/* we disconnect the signal handler before stopping the timeline,
* so that we don't end up inside on_transition_stopped() from
* a call to g_hash_table_remove().
*/
g_clear_signal_handler (&clos->completed_id, clos->transition);
if (clutter_timeline_is_playing (timeline))
clutter_timeline_stop (timeline);
else if (clutter_timeline_get_delay (timeline) > 0)
clutter_timeline_cancel_delay (timeline);
/* remove the reference added in add_transition_internal() */
g_object_unref (clos->transition);
g_free (clos->name);
g_slice_free (TransitionClosure, clos);
}
}
static void
on_transition_stopped (ClutterTransition *transition,
gboolean is_finished,
TransitionClosure *clos)
{
ClutterActor *actor = clos->actor;
ClutterAnimationInfo *info;
GQuark t_quark;
gchar *t_name;
if (clos->name == NULL)
return;
/* reset the caches used by animations */
clutter_actor_store_content_box (actor, NULL);
info = _clutter_actor_get_animation_info (actor);
/* we need copies because we emit the signal after the
* TransitionClosure data structure has been freed
*/
t_quark = g_quark_from_string (clos->name);
t_name = g_strdup (clos->name);
if (clutter_transition_get_remove_on_complete (transition))
{
/* this is safe, because the timeline has now stopped,
* so we won't recurse; the reference on the Animatable
* will be dropped by the ::stopped signal closure in
* ClutterTransition, which is RUN_LAST, and thus will
* be called after this handler
*/
g_hash_table_remove (info->transitions, clos->name);
}
/* we emit the ::transition-stopped after removing the
* transition, so that we can chain up new transitions
* without interfering with the one that just finished
*/
g_signal_emit (actor, actor_signals[TRANSITION_STOPPED], t_quark,
t_name,
is_finished);
g_free (t_name);
/* if it's the last transition then we clean up */
if (g_hash_table_size (info->transitions) == 0)
{
g_hash_table_unref (info->transitions);
info->transitions = NULL;
CLUTTER_NOTE (ANIMATION, "Transitions for '%s' completed",
_clutter_actor_get_debug_name (actor));
g_signal_emit (actor, actor_signals[TRANSITIONS_COMPLETED], 0);
}
}
static void
clutter_actor_add_transition_internal (ClutterActor *self,
const gchar *name,
ClutterTransition *transition)
{
ClutterTimeline *timeline;
TransitionClosure *clos;
ClutterAnimationInfo *info;
info = _clutter_actor_get_animation_info (self);
if (info->transitions == NULL)
info->transitions = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL,
transition_closure_free);
if (g_hash_table_lookup (info->transitions, name) != NULL)
{
g_warning ("A transition with name '%s' already exists for "
"the actor '%s'",
name,
_clutter_actor_get_debug_name (self));
return;
}
clutter_transition_set_animatable (transition, CLUTTER_ANIMATABLE (self));
timeline = CLUTTER_TIMELINE (transition);
clos = g_slice_new (TransitionClosure);
clos->actor = self;
clos->transition = g_object_ref (transition);
clos->name = g_strdup (name);
clos->completed_id = g_signal_connect (timeline, "stopped",
G_CALLBACK (on_transition_stopped),
clos);
CLUTTER_NOTE (ANIMATION,
"Adding transition '%s' [%p] to actor '%s'",
clos->name,
clos->transition,
_clutter_actor_get_debug_name (self));
g_hash_table_insert (info->transitions, clos->name, clos);
clutter_timeline_start (timeline);
}
static gboolean
should_skip_implicit_transition (ClutterActor *self,
GParamSpec *pspec)
{
ClutterActorPrivate *priv = self->priv;
const ClutterAnimationInfo *info;
/* this function is called from _clutter_actor_create_transition() which
* calls _clutter_actor_get_animation_info() first, so we're guaranteed
* to have the correct ClutterAnimationInfo pointer
*/
info = _clutter_actor_get_animation_info_or_defaults (self);
/* if the easing state has a non-zero duration we always want an
* implicit transition to occur
*/
if (info->cur_state->easing_duration == 0)
return TRUE;
/* on the other hand, if the actor hasn't been allocated yet, we want to
* skip all transitions on the :allocation, to avoid actors "flying in"
* into their new position and size
*/
if (pspec == obj_props[PROP_ALLOCATION] && priv->needs_allocation)
return TRUE;
/* if the actor is not mapped and is not part of a branch of the scene
* graph that is being cloned, then we always skip implicit transitions
* on the account of the fact that the actor is not going to be visible
* when those transitions happen
*/
if (!CLUTTER_ACTOR_IS_MAPPED (self) &&
priv->in_cloned_branch == 0 &&
!clutter_actor_has_mapped_clones (self))
return TRUE;
return FALSE;
}
/*< private >*
* _clutter_actor_create_transition:
* @actor: a #ClutterActor
* @pspec: the property used for the transition
* @...: initial and final state
*
* Creates a #ClutterTransition for the property represented by @pspec.
*
* Return value: a #ClutterTransition
*/
ClutterTransition *
_clutter_actor_create_transition (ClutterActor *actor,
GParamSpec *pspec,
...)
{
ClutterTimeline *timeline;
ClutterInterval *interval;
ClutterAnimationInfo *info;
ClutterTransition *res = NULL;
gboolean call_restore = FALSE;
TransitionClosure *clos;
va_list var_args;
g_auto (GValue) initial = G_VALUE_INIT;
g_auto (GValue) final = G_VALUE_INIT;
GType ptype;
char *error;
g_assert (pspec != NULL);
g_assert ((pspec->flags & CLUTTER_PARAM_ANIMATABLE) != 0);
info = _clutter_actor_get_animation_info (actor);
/* XXX - this will go away in 2.0
*
* if no state has been pushed, we assume that the easing state is
* in "compatibility mode": all transitions have a duration of 0
* msecs, which means that they happen immediately. in Clutter 2.0
* this will turn into a g_assert(info->states != NULL), as every
* actor will start with a predefined easing state
*/
if (info->states == NULL)
{
clutter_actor_save_easing_state (actor);
clutter_actor_set_easing_duration (actor, 0);
call_restore = TRUE;
}
if (info->transitions == NULL)
info->transitions = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL,
transition_closure_free);
va_start (var_args, pspec);
ptype = G_PARAM_SPEC_VALUE_TYPE (pspec);
G_VALUE_COLLECT_INIT (&initial, ptype,
var_args, 0,
&error);
if (error != NULL)
{
g_critical ("%s: %s", G_STRLOC, error);
g_free (error);
goto out;
}
G_VALUE_COLLECT_INIT (&final, ptype,
var_args, 0,
&error);
if (error != NULL)
{
g_critical ("%s: %s", G_STRLOC, error);
g_free (error);
goto out;
}
if (should_skip_implicit_transition (actor, pspec))
{
CLUTTER_NOTE (ANIMATION, "Skipping implicit transition for '%s::%s'",
_clutter_actor_get_debug_name (actor),
pspec->name);
/* remove a transition, if one exists */
clutter_actor_remove_transition (actor, pspec->name);
/* we don't go through the Animatable interface because we
* already know we got here through an animatable property.
*/
clutter_actor_set_animatable_property (actor,
pspec->param_id,
&final,
pspec);
goto out;
}
clos = g_hash_table_lookup (info->transitions, pspec->name);
if (clos == NULL)
{
res = clutter_property_transition_new (pspec->name);
clutter_transition_set_remove_on_complete (res, TRUE);
interval = clutter_interval_new_with_values (ptype, &initial, &final);
clutter_transition_set_interval (res, interval);
timeline = CLUTTER_TIMELINE (res);
clutter_timeline_set_delay (timeline, info->cur_state->easing_delay);
clutter_timeline_set_duration (timeline, info->cur_state->easing_duration);
clutter_timeline_set_progress_mode (timeline, info->cur_state->easing_mode);
#ifdef CLUTTER_ENABLE_DEBUG
if (CLUTTER_HAS_DEBUG (ANIMATION))
{
gchar *initial_v, *final_v;
initial_v = g_strdup_value_contents (&initial);
final_v = g_strdup_value_contents (&final);
CLUTTER_NOTE (ANIMATION,
"Created transition for %s:%s "
"(len:%u, mode:%s, delay:%u) "
"initial:%s, final:%s",
_clutter_actor_get_debug_name (actor),
pspec->name,
info->cur_state->easing_duration,
clutter_get_easing_name_for_mode (info->cur_state->easing_mode),
info->cur_state->easing_delay,
initial_v, final_v);
g_free (initial_v);
g_free (final_v);
}
#endif /* CLUTTER_ENABLE_DEBUG */
/* this will start the transition as well */
clutter_actor_add_transition_internal (actor, pspec->name, res);
/* the actor now owns the transition */
g_object_unref (res);
}
else
{
ClutterAnimationMode cur_mode;
guint cur_duration;
CLUTTER_NOTE (ANIMATION, "Existing transition for %s:%s",
_clutter_actor_get_debug_name (actor),
pspec->name);
timeline = CLUTTER_TIMELINE (clos->transition);
cur_duration = clutter_timeline_get_duration (timeline);
if (cur_duration != info->cur_state->easing_duration)
clutter_timeline_set_duration (timeline, info->cur_state->easing_duration);
cur_mode = clutter_timeline_get_progress_mode (timeline);
if (cur_mode != info->cur_state->easing_mode)
clutter_timeline_set_progress_mode (timeline, info->cur_state->easing_mode);
clutter_timeline_rewind (timeline);
interval = clutter_transition_get_interval (clos->transition);
clutter_interval_set_initial_value (interval, &initial);
clutter_interval_set_final_value (interval, &final);
res = clos->transition;
}
out:
if (call_restore)
clutter_actor_restore_easing_state (actor);
va_end (var_args);
return res;
}
/**
* clutter_actor_add_transition:
* @self: a #ClutterActor
* @name: the name of the transition to add
* @transition: the #ClutterTransition to add
*
* Adds a @transition to the #ClutterActor's list of animations.
*
* The @name string is a per-actor unique identifier of the @transition: only
* one #ClutterTransition can be associated to the specified @name.
*
* The @transition will be started once added.
*
* This function will take a reference on the @transition.
*
* This function is usually called implicitly when modifying an animatable
* property.
*
* Since: 1.10
*/
void
clutter_actor_add_transition (ClutterActor *self,
const char *name,
ClutterTransition *transition)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (name != NULL);
g_return_if_fail (CLUTTER_IS_TRANSITION (transition));
clutter_actor_add_transition_internal (self, name, transition);
}
/**
* clutter_actor_remove_transition:
* @self: a #ClutterActor
* @name: the name of the transition to remove
*
* Removes the transition stored inside a #ClutterActor using @name
* identifier.
*
* If the transition is currently in progress, it will be stopped.
*
* This function releases the reference acquired when the transition
* was added to the #ClutterActor.
*
* Since: 1.10
*/
void
clutter_actor_remove_transition (ClutterActor *self,
const char *name)
{
const ClutterAnimationInfo *info;
TransitionClosure *clos;
gboolean was_playing;
GQuark t_quark;
gchar *t_name;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (name != NULL);
info = _clutter_actor_get_animation_info_or_defaults (self);
if (info->transitions == NULL)
return;
clos = g_hash_table_lookup (info->transitions, name);
if (clos == NULL)
return;
was_playing =
clutter_timeline_is_playing (CLUTTER_TIMELINE (clos->transition));
t_quark = g_quark_from_string (clos->name);
t_name = g_strdup (clos->name);
g_hash_table_remove (info->transitions, name);
/* we want to maintain the invariant that ::transition-stopped is
* emitted after the transition has been removed, to allow replacing
* or chaining; removing the transition from the hash table will
* stop it, but transition_closure_free() will disconnect the signal
* handler we install in add_transition_internal(), to avoid loops
* or segfaults.
*
* since we know already that a transition will stop once it's removed
* from an actor, we can simply emit the ::transition-stopped here
* ourselves, if the timeline was playing (if it wasn't, then the
* signal was already emitted at least once).
*/
if (was_playing)
{
g_signal_emit (self, actor_signals[TRANSITION_STOPPED],
t_quark,
t_name,
FALSE);
}
g_free (t_name);
}
/**
* clutter_actor_remove_all_transitions:
* @self: a #ClutterActor
*
* Removes all transitions associated to @self.
*
* Since: 1.10
*/
void
clutter_actor_remove_all_transitions (ClutterActor *self)
{
const ClutterAnimationInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_animation_info_or_defaults (self);
if (info->transitions == NULL)
return;
g_hash_table_remove_all (info->transitions);
}
/**
* clutter_actor_set_easing_duration:
* @self: a #ClutterActor
* @msecs: the duration of the easing, or %NULL
*
* Sets the duration of the tweening for animatable properties
* of @self for the current easing state.
*
* Since: 1.10
*/
void
clutter_actor_set_easing_duration (ClutterActor *self,
guint msecs)
{
ClutterAnimationInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_animation_info (self);
if (info->cur_state == NULL)
{
g_warning ("You must call clutter_actor_save_easing_state() prior "
"to calling clutter_actor_set_easing_duration().");
return;
}
if (info->cur_state->easing_duration != msecs)
info->cur_state->easing_duration = msecs;
}
/**
* clutter_actor_get_easing_duration:
* @self: a #ClutterActor
*
* Retrieves the duration of the tweening for animatable
* properties of @self for the current easing state.
*
* Return value: the duration of the tweening, in milliseconds
*
* Since: 1.10
*/
guint
clutter_actor_get_easing_duration (ClutterActor *self)
{
const ClutterAnimationInfo *info;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
info = _clutter_actor_get_animation_info_or_defaults (self);
if (info->cur_state != NULL)
return info->cur_state->easing_duration;
return 0;
}
/**
* clutter_actor_set_easing_mode:
* @self: a #ClutterActor
* @mode: an easing mode, excluding %CLUTTER_CUSTOM_MODE
*
* Sets the easing mode for the tweening of animatable properties
* of @self.
*
* Since: 1.10
*/
void
clutter_actor_set_easing_mode (ClutterActor *self,
ClutterAnimationMode mode)
{
ClutterAnimationInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (mode != CLUTTER_CUSTOM_MODE);
g_return_if_fail (mode < CLUTTER_ANIMATION_LAST);
info = _clutter_actor_get_animation_info (self);
if (info->cur_state == NULL)
{
g_warning ("You must call clutter_actor_save_easing_state() prior "
"to calling clutter_actor_set_easing_mode().");
return;
}
if (info->cur_state->easing_mode != mode)
info->cur_state->easing_mode = mode;
}
/**
* clutter_actor_get_easing_mode:
* @self: a #ClutterActor
*
* Retrieves the easing mode for the tweening of animatable properties
* of @self for the current easing state.
*
* Return value: an easing mode
*
* Since: 1.10
*/
ClutterAnimationMode
clutter_actor_get_easing_mode (ClutterActor *self)
{
const ClutterAnimationInfo *info;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), CLUTTER_EASE_OUT_CUBIC);
info = _clutter_actor_get_animation_info_or_defaults (self);
if (info->cur_state != NULL)
return info->cur_state->easing_mode;
return CLUTTER_EASE_OUT_CUBIC;
}
/**
* clutter_actor_set_easing_delay:
* @self: a #ClutterActor
* @msecs: the delay before the start of the tweening, in milliseconds
*
* Sets the delay that should be applied before tweening animatable
* properties.
*
* Since: 1.10
*/
void
clutter_actor_set_easing_delay (ClutterActor *self,
guint msecs)
{
ClutterAnimationInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_animation_info (self);
if (info->cur_state == NULL)
{
g_warning ("You must call clutter_actor_save_easing_state() prior "
"to calling clutter_actor_set_easing_delay().");
return;
}
if (info->cur_state->easing_delay != msecs)
info->cur_state->easing_delay = msecs;
}
/**
* clutter_actor_get_easing_delay:
* @self: a #ClutterActor
*
* Retrieves the delay that should be applied when tweening animatable
* properties.
*
* Return value: a delay, in milliseconds
*
* Since: 1.10
*/
guint
clutter_actor_get_easing_delay (ClutterActor *self)
{
const ClutterAnimationInfo *info;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
info = _clutter_actor_get_animation_info_or_defaults (self);
if (info->cur_state != NULL)
return info->cur_state->easing_delay;
return 0;
}
/**
* clutter_actor_get_transition:
* @self: a #ClutterActor
* @name: the name of the transition
*
* Retrieves the #ClutterTransition of a #ClutterActor by using the
* transition @name.
*
* Transitions created for animatable properties use the name of the
* property itself, for instance the code below:
*
* |[
* clutter_actor_set_easing_duration (actor, 1000);
* clutter_actor_set_rotation (actor, CLUTTER_Y_AXIS, 360.0, x, y, z);
*
* transition = clutter_actor_get_transition (actor, "rotation-angle-y");
* g_signal_connect (transition, "stopped",
* G_CALLBACK (on_transition_stopped),
* actor);
* ]|
*
* will call the `on_transition_stopped` callback when the transition
* is finished.
*
* If you just want to get notifications of the completion of a transition,
* you should use the #ClutterActor::transition-stopped signal, using the
* transition name as the signal detail.
*
* Return value: (transfer none): a #ClutterTransition, or %NULL is none
* was found to match the passed name; the returned instance is owned
* by Clutter and it should not be freed
*
* Since: 1.10
*/
ClutterTransition *
clutter_actor_get_transition (ClutterActor *self,
const char *name)
{
TransitionClosure *clos;
const ClutterAnimationInfo *info;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
g_return_val_if_fail (name != NULL, NULL);
info = _clutter_actor_get_animation_info_or_defaults (self);
if (info->transitions == NULL)
return NULL;
clos = g_hash_table_lookup (info->transitions, name);
if (clos == NULL)
return NULL;
return clos->transition;
}
/**
* clutter_actor_save_easing_state:
* @self: a #ClutterActor
*
* Saves the current easing state for animatable properties, and creates
* a new state with the default values for easing mode and duration.
*
* New transitions created after calling this function will inherit the
* duration, easing mode, and delay of the new easing state; this also
* applies to transitions modified in flight.
*
* Since: 1.10
*/
void
clutter_actor_save_easing_state (ClutterActor *self)
{
ClutterAnimationInfo *info;
AState new_state;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_animation_info (self);
if (info->states == NULL)
info->states = g_array_new (FALSE, FALSE, sizeof (AState));
new_state.easing_mode = CLUTTER_EASE_OUT_CUBIC;
new_state.easing_duration = 250;
new_state.easing_delay = 0;
g_array_append_val (info->states, new_state);
info->cur_state = &g_array_index (info->states, AState, info->states->len - 1);
}
/**
* clutter_actor_restore_easing_state:
* @self: a #ClutterActor
*
* Restores the easing state as it was prior to a call to
* clutter_actor_save_easing_state().
*
* Since: 1.10
*/
void
clutter_actor_restore_easing_state (ClutterActor *self)
{
ClutterAnimationInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_animation_info (self);
if (info->states == NULL)
{
g_critical ("The function clutter_actor_restore_easing_state() has "
"been called without a previous call to "
"clutter_actor_save_easing_state().");
return;
}
g_array_remove_index (info->states, info->states->len - 1);
if (info->states->len > 0)
info->cur_state = &g_array_index (info->states, AState, info->states->len - 1);
else
{
g_array_unref (info->states);
info->states = NULL;
info->cur_state = NULL;
}
}
/**
* clutter_actor_set_content:
* @self: a #ClutterActor
* @content: (allow-none): a #ClutterContent, or %NULL
*
* Sets the contents of a #ClutterActor.
*
* Since: 1.10
*/
void
clutter_actor_set_content (ClutterActor *self,
ClutterContent *content)
{
ClutterActorPrivate *priv;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (content == NULL || CLUTTER_IS_CONTENT (content));
priv = self->priv;
if (priv->content == content)
return;
if (priv->content != NULL)
{
_clutter_content_detached (priv->content, self);
g_clear_object (&priv->content);
}
priv->content = content;
if (priv->content != NULL)
{
g_object_ref (priv->content);
_clutter_content_attached (priv->content, self);
}
/* if the actor's preferred size is the content's preferred size,
* then we need to conditionally queue a relayout here...
*/
if (priv->request_mode == CLUTTER_REQUEST_CONTENT_SIZE)
_clutter_actor_queue_only_relayout (self);
clutter_actor_queue_redraw (self);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_CONTENT]);
/* if the content gravity is not resize-fill, and the new content has a
* different preferred size than the previous one, then the content box
* may have been changed. since we compute that lazily, we just notify
* here, and let whomever watches :content-box do whatever they need to
* do.
*/
if (priv->content_gravity != CLUTTER_CONTENT_GRAVITY_RESIZE_FILL)
{
if (priv->content_box_valid)
{
ClutterActorBox from_box, to_box;
clutter_actor_get_content_box (self, &from_box);
/* invalidate the cached content box */
priv->content_box_valid = FALSE;
clutter_actor_get_content_box (self, &to_box);
if (!clutter_actor_box_equal (&from_box, &to_box))
_clutter_actor_create_transition (self, obj_props[PROP_CONTENT_BOX],
&from_box,
&to_box);
}
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_CONTENT_BOX]);
}
}
/**
* clutter_actor_get_content:
* @self: a #ClutterActor
*
* Retrieves the contents of @self.
*
* Return value: (transfer none): a pointer to the #ClutterContent instance,
* or %NULL if none was set
*
* Since: 1.10
*/
ClutterContent *
clutter_actor_get_content (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
return self->priv->content;
}
/**
* clutter_actor_set_content_gravity:
* @self: a #ClutterActor
* @gravity: the #ClutterContentGravity
*
* Sets the gravity of the #ClutterContent used by @self.
*
* See the description of the #ClutterActor:content-gravity property for
* more information.
*
* The #ClutterActor:content-gravity property is animatable.
*
* Since: 1.10
*/
void
clutter_actor_set_content_gravity (ClutterActor *self,
ClutterContentGravity gravity)
{
ClutterActorPrivate *priv;
ClutterActorBox from_box, to_box;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
if (priv->content_gravity == gravity)
return;
priv->content_box_valid = FALSE;
clutter_actor_get_content_box (self, &from_box);
priv->content_gravity = gravity;
clutter_actor_get_content_box (self, &to_box);
_clutter_actor_create_transition (self, obj_props[PROP_CONTENT_BOX],
&from_box,
&to_box);
g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_CONTENT_GRAVITY]);
}
/**
* clutter_actor_get_content_gravity:
* @self: a #ClutterActor
*
* Retrieves the content gravity as set using
* clutter_actor_set_content_gravity().
*
* Return value: the content gravity
*
* Since: 1.10
*/
ClutterContentGravity
clutter_actor_get_content_gravity (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self),
CLUTTER_CONTENT_GRAVITY_RESIZE_FILL);
return self->priv->content_gravity;
}
/**
* clutter_actor_get_content_box:
* @self: a #ClutterActor
* @box: (out caller-allocates): the return location for the bounding
* box for the #ClutterContent
*
* Retrieves the bounding box for the #ClutterContent of @self.
*
* The bounding box is relative to the actor's allocation.
*
* If no #ClutterContent is set for @self, or if @self has not been
* allocated yet, then the result is undefined.
*
* The content box is guaranteed to be, at most, as big as the allocation
* of the #ClutterActor.
*
* If the #ClutterContent used by the actor has a preferred size, then
* it is possible to modify the content box by using the
* #ClutterActor:content-gravity property.
*
* Since: 1.10
*/
void
clutter_actor_get_content_box (ClutterActor *self,
ClutterActorBox *box)
{
ClutterActorPrivate *priv;
gfloat content_w, content_h;
gfloat alloc_w, alloc_h;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (box != NULL);
priv = self->priv;
box->x1 = 0.f;
box->y1 = 0.f;
box->x2 = priv->allocation.x2 - priv->allocation.x1;
box->y2 = priv->allocation.y2 - priv->allocation.y1;
if (priv->content_box_valid)
{
*box = priv->content_box;
return;
}
/* no need to do any more work */
if (priv->content_gravity == CLUTTER_CONTENT_GRAVITY_RESIZE_FILL)
return;
if (priv->content == NULL)
return;
/* if the content does not have a preferred size then there is
* no point in computing the content box
*/
if (!clutter_content_get_preferred_size (priv->content,
&content_w,
&content_h))
return;
alloc_w = box->x2;
alloc_h = box->y2;
switch (priv->content_gravity)
{
case CLUTTER_CONTENT_GRAVITY_TOP_LEFT:
box->x2 = box->x1 + MIN (content_w, alloc_w);
box->y2 = box->y1 + MIN (content_h, alloc_h);
break;
case CLUTTER_CONTENT_GRAVITY_TOP:
if (alloc_w > content_w)
{
box->x1 += ceilf ((alloc_w - content_w) / 2.0);
box->x2 = box->x1 + content_w;
}
box->y2 = box->y1 + MIN (content_h, alloc_h);
break;
case CLUTTER_CONTENT_GRAVITY_TOP_RIGHT:
if (alloc_w > content_w)
{
box->x1 += (alloc_w - content_w);
box->x2 = box->x1 + content_w;
}
box->y2 = box->y1 + MIN (content_h, alloc_h);
break;
case CLUTTER_CONTENT_GRAVITY_LEFT:
box->x2 = box->x1 + MIN (content_w, alloc_w);
if (alloc_h > content_h)
{
box->y1 += ceilf ((alloc_h - content_h) / 2.0);
box->y2 = box->y1 + content_h;
}
break;
case CLUTTER_CONTENT_GRAVITY_CENTER:
if (alloc_w > content_w)
{
box->x1 += ceilf ((alloc_w - content_w) / 2.0);
box->x2 = box->x1 + content_w;
}
if (alloc_h > content_h)
{
box->y1 += ceilf ((alloc_h - content_h) / 2.0);
box->y2 = box->y1 + content_h;
}
break;
case CLUTTER_CONTENT_GRAVITY_RIGHT:
if (alloc_w > content_w)
{
box->x1 += (alloc_w - content_w);
box->x2 = box->x1 + content_w;
}
if (alloc_h > content_h)
{
box->y1 += ceilf ((alloc_h - content_h) / 2.0);
box->y2 = box->y1 + content_h;
}
break;
case CLUTTER_CONTENT_GRAVITY_BOTTOM_LEFT:
box->x2 = box->x1 + MIN (content_w, alloc_w);
if (alloc_h > content_h)
{
box->y1 += (alloc_h - content_h);
box->y2 = box->y1 + content_h;
}
break;
case CLUTTER_CONTENT_GRAVITY_BOTTOM:
if (alloc_w > content_w)
{
box->x1 += ceilf ((alloc_w - content_w) / 2.0);
box->x2 = box->x1 + content_w;
}
if (alloc_h > content_h)
{
box->y1 += (alloc_h - content_h);
box->y2 = box->y1 + content_h;
}
break;
case CLUTTER_CONTENT_GRAVITY_BOTTOM_RIGHT:
if (alloc_w > content_w)
{
box->x1 += (alloc_w - content_w);
box->x2 = box->x1 + content_w;
}
if (alloc_h > content_h)
{
box->y1 += (alloc_h - content_h);
box->y2 = box->y1 + content_h;
}
break;
case CLUTTER_CONTENT_GRAVITY_RESIZE_FILL:
g_assert_not_reached ();
break;
case CLUTTER_CONTENT_GRAVITY_RESIZE_ASPECT:
{
double r_c = content_w / content_h;
if ((alloc_w / r_c) > alloc_h)
{
box->y1 = 0.f;
box->y2 = alloc_h;
box->x1 = (alloc_w - (alloc_h * r_c)) / 2.0f;
box->x2 = box->x1 + (alloc_h * r_c);
}
else
{
box->x1 = 0.f;
box->x2 = alloc_w;
box->y1 = (alloc_h - (alloc_w / r_c)) / 2.0f;
box->y2 = box->y1 + (alloc_w / r_c);
}
CLUTTER_NOTE (LAYOUT,
"r_c: %.3f, r_a: %.3f\t"
"a: [%.2fx%.2f], c: [%.2fx%.2f]\t"
"b: [%.2f, %.2f, %.2f, %.2f]",
r_c, alloc_w / alloc_h,
alloc_w, alloc_h,
content_w, content_h,
box->x1, box->y1, box->x2, box->y2);
}
break;
}
}
/**
* clutter_actor_set_content_scaling_filters:
* @self: a #ClutterActor
* @min_filter: the minification filter for the content
* @mag_filter: the magnification filter for the content
*
* Sets the minification and magnification filter to be applied when
* scaling the #ClutterActor:content of a #ClutterActor.
*
* The #ClutterActor:minification-filter will be used when reducing
* the size of the content; the #ClutterActor:magnification-filter
* will be used when increasing the size of the content.
*
* Since: 1.10
*/
void
clutter_actor_set_content_scaling_filters (ClutterActor *self,
ClutterScalingFilter min_filter,
ClutterScalingFilter mag_filter)
{
ClutterActorPrivate *priv;
gboolean changed;
GObject *obj;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
priv = self->priv;
obj = G_OBJECT (self);
g_object_freeze_notify (obj);
changed = FALSE;
if (priv->min_filter != min_filter)
{
priv->min_filter = min_filter;
changed = TRUE;
g_object_notify_by_pspec (obj, obj_props[PROP_MINIFICATION_FILTER]);
}
if (priv->mag_filter != mag_filter)
{
priv->mag_filter = mag_filter;
changed = TRUE;
g_object_notify_by_pspec (obj, obj_props[PROP_MAGNIFICATION_FILTER]);
}
if (changed)
clutter_actor_queue_redraw (self);
g_object_thaw_notify (obj);
}
/**
* clutter_actor_get_content_scaling_filters:
* @self: a #ClutterActor
* @min_filter: (out) (allow-none): return location for the minification
* filter, or %NULL
* @mag_filter: (out) (allow-none): return location for the magnification
* filter, or %NULL
*
* Retrieves the values set using clutter_actor_set_content_scaling_filters().
*
* Since: 1.10
*/
void
clutter_actor_get_content_scaling_filters (ClutterActor *self,
ClutterScalingFilter *min_filter,
ClutterScalingFilter *mag_filter)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (min_filter != NULL)
*min_filter = self->priv->min_filter;
if (mag_filter != NULL)
*mag_filter = self->priv->mag_filter;
}
/*
* clutter_actor_queue_compute_expand:
* @self: a #ClutterActor
*
* Invalidates the needs_x_expand and needs_y_expand flags on @self
* and its parents up to the top-level actor.
*
* This function also queues a relayout if anything changed.
*/
static inline void
clutter_actor_queue_compute_expand (ClutterActor *self)
{
ClutterActor *parent;
gboolean changed;
if (self->priv->needs_compute_expand)
return;
changed = FALSE;
parent = self;
while (parent != NULL)
{
if (!parent->priv->needs_compute_expand)
{
parent->priv->needs_compute_expand = TRUE;
changed = TRUE;
}
parent = parent->priv->parent;
}
if (changed)
clutter_actor_queue_relayout (self);
}
/**
* clutter_actor_set_x_expand:
* @self: a #ClutterActor
* @expand: whether the actor should expand horizontally
*
* Sets whether a #ClutterActor should expand horizontally; this means
* that layout manager should allocate extra space for the actor, if
* possible.
*
* Setting an actor to expand will also make all its parent expand, so
* that it's possible to build an actor tree and only set this flag on
* its leaves and not on every single actor.
*
* Since: 1.12
*/
void
clutter_actor_set_x_expand (ClutterActor *self,
gboolean expand)
{
ClutterLayoutInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
expand = !!expand;
info = _clutter_actor_get_layout_info (self);
if (info->x_expand != expand)
{
info->x_expand = expand;
self->priv->x_expand_set = TRUE;
clutter_actor_queue_compute_expand (self);
g_object_notify_by_pspec (G_OBJECT (self),
obj_props[PROP_X_EXPAND]);
}
}
/**
* clutter_actor_get_x_expand:
* @self: a #ClutterActor
*
* Retrieves the value set with clutter_actor_set_x_expand().
*
* See also: clutter_actor_needs_expand()
*
* Return value: %TRUE if the actor has been set to expand
*
* Since: 1.12
*/
gboolean
clutter_actor_get_x_expand (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
return _clutter_actor_get_layout_info_or_defaults (self)->x_expand;
}
/**
* clutter_actor_set_y_expand:
* @self: a #ClutterActor
* @expand: whether the actor should expand vertically
*
* Sets whether a #ClutterActor should expand horizontally; this means
* that layout manager should allocate extra space for the actor, if
* possible.
*
* Setting an actor to expand will also make all its parent expand, so
* that it's possible to build an actor tree and only set this flag on
* its leaves and not on every single actor.
*
* Since: 1.12
*/
void
clutter_actor_set_y_expand (ClutterActor *self,
gboolean expand)
{
ClutterLayoutInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
expand = !!expand;
info = _clutter_actor_get_layout_info (self);
if (info->y_expand != expand)
{
info->y_expand = expand;
self->priv->y_expand_set = TRUE;
clutter_actor_queue_compute_expand (self);
g_object_notify_by_pspec (G_OBJECT (self),
obj_props[PROP_Y_EXPAND]);
}
}
/**
* clutter_actor_get_y_expand:
* @self: a #ClutterActor
*
* Retrieves the value set with clutter_actor_set_y_expand().
*
* See also: clutter_actor_needs_expand()
*
* Return value: %TRUE if the actor has been set to expand
*
* Since: 1.12
*/
gboolean
clutter_actor_get_y_expand (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
return _clutter_actor_get_layout_info_or_defaults (self)->y_expand;
}
static void
clutter_actor_compute_expand_recursive (ClutterActor *self,
gboolean *x_expand_p,
gboolean *y_expand_p)
{
ClutterActorIter iter;
ClutterActor *child;
gboolean x_expand, y_expand;
x_expand = y_expand = FALSE;
/* note that we don't recurse into children if we're already set to expand;
* this avoids traversing the whole actor tree, even if it may lead to some
* child left with the needs_compute_expand flag set.
*/
clutter_actor_iter_init (&iter, self);
while (clutter_actor_iter_next (&iter, &child))
{
x_expand = x_expand ||
clutter_actor_needs_expand (child, CLUTTER_ORIENTATION_HORIZONTAL);
y_expand = y_expand ||
clutter_actor_needs_expand (child, CLUTTER_ORIENTATION_VERTICAL);
}
*x_expand_p = x_expand;
*y_expand_p = y_expand;
}
static void
clutter_actor_compute_expand (ClutterActor *self)
{
if (self->priv->needs_compute_expand)
{
const ClutterLayoutInfo *info;
gboolean x_expand, y_expand;
info = _clutter_actor_get_layout_info_or_defaults (self);
if (self->priv->x_expand_set)
x_expand = info->x_expand;
else
x_expand = FALSE;
if (self->priv->y_expand_set)
y_expand = info->y_expand;
else
y_expand = FALSE;
/* we don't need to recurse down to the children if the
* actor has been forcibly set to expand
*/
if (!(self->priv->x_expand_set && self->priv->y_expand_set))
{
if (self->priv->n_children != 0)
{
gboolean *x_expand_p, *y_expand_p;
gboolean ignored = FALSE;
x_expand_p = self->priv->x_expand_set ? &ignored : &x_expand;
y_expand_p = self->priv->y_expand_set ? &ignored : &y_expand;
clutter_actor_compute_expand_recursive (self,
x_expand_p,
y_expand_p);
}
}
self->priv->needs_compute_expand = FALSE;
self->priv->needs_x_expand = (x_expand != FALSE);
self->priv->needs_y_expand = (y_expand != FALSE);
}
}
/**
* clutter_actor_needs_expand:
* @self: a #ClutterActor
* @orientation: the direction of expansion
*
* Checks whether an actor, or any of its children, is set to expand
* horizontally or vertically.
*
* This function should only be called by layout managers that can
* assign extra space to their children.
*
* If you want to know whether the actor was explicitly set to expand,
* use clutter_actor_get_x_expand() or clutter_actor_get_y_expand().
*
* Return value: %TRUE if the actor should expand
*
* Since: 1.12
*/
gboolean
clutter_actor_needs_expand (ClutterActor *self,
ClutterOrientation orientation)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
if (!CLUTTER_ACTOR_IS_VISIBLE (self))
return FALSE;
if (CLUTTER_ACTOR_IN_DESTRUCTION (self))
return FALSE;
clutter_actor_compute_expand (self);
switch (orientation)
{
case CLUTTER_ORIENTATION_HORIZONTAL:
return self->priv->needs_x_expand;
case CLUTTER_ORIENTATION_VERTICAL:
return self->priv->needs_y_expand;
}
return FALSE;
}
/**
* clutter_actor_set_content_repeat:
* @self: a #ClutterActor
* @repeat: the repeat policy
*
* Sets the policy for repeating the #ClutterActor:content of a
* #ClutterActor. The behaviour is deferred to the #ClutterContent
* implementation.
*
* Since: 1.12
*/
void
clutter_actor_set_content_repeat (ClutterActor *self,
ClutterContentRepeat repeat)
{
g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (self->priv->content_repeat == repeat)
return;
self->priv->content_repeat = repeat;
clutter_actor_queue_redraw (self);
}
/**
* clutter_actor_get_content_repeat:
* @self: a #ClutterActor
*
* Retrieves the repeat policy for a #ClutterActor set by
* clutter_actor_set_content_repeat().
*
* Return value: the content repeat policy
*
* Since: 1.12
*/
ClutterContentRepeat
clutter_actor_get_content_repeat (ClutterActor *self)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), CLUTTER_REPEAT_NONE);
return self->priv->content_repeat;
}
void
_clutter_actor_handle_event (ClutterActor *self,
const ClutterEvent *event)
{
GPtrArray *event_tree;
ClutterActor *iter;
gboolean is_key_event;
gint i = 0;
/* XXX - for historical reasons that are now lost in the mists of time,
* key events are delivered regardless of whether an actor is set as
* reactive; this should be changed for 2.0.
*/
is_key_event = event->type == CLUTTER_KEY_PRESS ||
event->type == CLUTTER_KEY_RELEASE;
event_tree = g_ptr_array_sized_new (64);
g_ptr_array_set_free_func (event_tree, (GDestroyNotify) g_object_unref);
/* build the list of of emitters for the event */
iter = self;
while (iter != NULL)
{
ClutterActor *parent = iter->priv->parent;
if (CLUTTER_ACTOR_IS_REACTIVE (iter) || /* an actor must be reactive */
parent == NULL || /* unless it's the stage */
is_key_event) /* or this is a key event */
{
/* keep a reference on the actor, so that it remains valid
* for the duration of the signal emission
*/
g_ptr_array_add (event_tree, g_object_ref (iter));
}
iter = parent;
}
/* Capture: from top-level downwards */
for (i = event_tree->len - 1; i >= 0; i--)
if (clutter_actor_event (g_ptr_array_index (event_tree, i), event, TRUE))
goto done;
/* Bubble: from source upwards */
for (i = 0; i < event_tree->len; i++)
if (clutter_actor_event (g_ptr_array_index (event_tree, i), event, FALSE))
goto done;
done:
g_ptr_array_free (event_tree, TRUE);
}
static void
clutter_actor_set_child_transform_internal (ClutterActor *self,
const ClutterMatrix *transform)
{
ClutterTransformInfo *info = _clutter_actor_get_transform_info (self);
ClutterActorIter iter;
ClutterActor *child;
GObject *obj;
gboolean was_set = info->child_transform_set;
clutter_matrix_init_from_matrix (&info->child_transform, transform);
/* if it's the identity matrix, we need to toggle the boolean flag */
info->child_transform_set = !cogl_matrix_is_identity (transform);
/* we need to reset the transform_valid flag on each child */
clutter_actor_iter_init (&iter, self);
while (clutter_actor_iter_next (&iter, &child))
child->priv->transform_valid = FALSE;
clutter_actor_queue_redraw (self);
obj = G_OBJECT (self);
g_object_notify_by_pspec (obj, obj_props[PROP_CHILD_TRANSFORM]);
if (was_set != info->child_transform_set)
g_object_notify_by_pspec (obj, obj_props[PROP_CHILD_TRANSFORM_SET]);
}
/**
* clutter_actor_set_child_transform:
* @self: a #ClutterActor
* @transform: (allow-none): a #ClutterMatrix, or %NULL
*
* Sets the transformation matrix to be applied to all the children
* of @self prior to their own transformations. The default child
* transformation is the identity matrix.
*
* If @transform is %NULL, the child transform will be unset.
*
* The #ClutterActor:child-transform property is animatable.
*
* Since: 1.12
*/
void
clutter_actor_set_child_transform (ClutterActor *self,
const ClutterMatrix *transform)
{
const ClutterTransformInfo *info;
ClutterMatrix new_transform;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
info = _clutter_actor_get_transform_info_or_defaults (self);
if (transform != NULL)
clutter_matrix_init_from_matrix (&new_transform, transform);
else
clutter_matrix_init_identity (&new_transform);
_clutter_actor_create_transition (self, obj_props[PROP_CHILD_TRANSFORM],
&info->child_transform,
&new_transform);
}
/**
* clutter_actor_get_child_transform:
* @self: a #ClutterActor
* @transform: (out caller-allocates): a #ClutterMatrix
*
* Retrieves the child transformation matrix set using
* clutter_actor_set_child_transform(); if none is currently set,
* the @transform matrix will be initialized to the identity matrix.
*
* Since: 1.12
*/
void
clutter_actor_get_child_transform (ClutterActor *self,
ClutterMatrix *transform)
{
const ClutterTransformInfo *info;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (transform != NULL);
info = _clutter_actor_get_transform_info_or_defaults (self);
if (info->child_transform_set)
clutter_matrix_init_from_matrix (transform, &info->child_transform);
else
clutter_matrix_init_identity (transform);
}
static void
clutter_actor_push_in_cloned_branch (ClutterActor *self,
gulong count)
{
ClutterActor *iter;
for (iter = self->priv->first_child;
iter != NULL;
iter = iter->priv->next_sibling)
clutter_actor_push_in_cloned_branch (iter, count);
self->priv->in_cloned_branch += count;
}
static void
clutter_actor_pop_in_cloned_branch (ClutterActor *self,
gulong count)
{
ClutterActor *iter;
self->priv->in_cloned_branch -= count;
for (iter = self->priv->first_child;
iter != NULL;
iter = iter->priv->next_sibling)
clutter_actor_pop_in_cloned_branch (iter, count);
}
void
_clutter_actor_attach_clone (ClutterActor *actor,
ClutterActor *clone)
{
ClutterActorPrivate *priv = actor->priv;
g_assert (clone != NULL);
if (priv->clones == NULL)
priv->clones = g_hash_table_new (NULL, NULL);
g_hash_table_add (priv->clones, clone);
clutter_actor_push_in_cloned_branch (actor, 1);
}
void
_clutter_actor_detach_clone (ClutterActor *actor,
ClutterActor *clone)
{
ClutterActorPrivate *priv = actor->priv;
g_assert (clone != NULL);
if (priv->clones == NULL ||
g_hash_table_lookup (priv->clones, clone) == NULL)
return;
clutter_actor_pop_in_cloned_branch (actor, 1);
g_hash_table_remove (priv->clones, clone);
if (g_hash_table_size (priv->clones) == 0)
{
g_hash_table_unref (priv->clones);
priv->clones = NULL;
}
}
void
_clutter_actor_queue_redraw_on_clones (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
GHashTableIter iter;
gpointer key;
if (priv->clones == NULL)
return;
g_hash_table_iter_init (&iter, priv->clones);
while (g_hash_table_iter_next (&iter, &key, NULL))
clutter_actor_queue_redraw (key);
}
void
_clutter_actor_queue_relayout_on_clones (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
GHashTableIter iter;
gpointer key;
if (priv->clones == NULL)
return;
g_hash_table_iter_init (&iter, priv->clones);
while (g_hash_table_iter_next (&iter, &key, NULL))
clutter_actor_queue_relayout (key);
}
/**
* clutter_actor_has_mapped_clones:
* @self: a #ClutterActor
*
* Returns whether a #ClutterActor has any mapped clones.
*
* Return: %TRUE if the actor has mapped clones, and %FALSE otherwise
*
* Since: 1.16
*/
gboolean
clutter_actor_has_mapped_clones (ClutterActor *self)
{
ClutterActorPrivate *priv;
GHashTableIter iter;
gpointer key;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
priv = self->priv;
if (priv->clones == NULL)
return FALSE;
g_hash_table_iter_init (&iter, priv->clones);
while (g_hash_table_iter_next (&iter, &key, NULL))
{
if (CLUTTER_ACTOR_IS_MAPPED (key))
return TRUE;
}
return FALSE;
}
static void
clutter_actor_child_model__items_changed (GListModel *model,
guint position,
guint removed,
guint added,
gpointer user_data)
{
ClutterActor *parent = user_data;
ClutterActorPrivate *priv = parent->priv;
guint i;
while (removed--)
{
ClutterActor *child = clutter_actor_get_child_at_index (parent, position);
clutter_actor_destroy (child);
}
for (i = 0; i < added; i++)
{
GObject *item = g_list_model_get_item (model, position + i);
ClutterActor *child = priv->create_child_func (item, priv->create_child_data);
/* The actor returned by the function can have a floating reference,
* if the implementation is in pure C, or have a full reference, usually
* the case for language bindings. To avoid leaking references, we
* try to assume ownership of the instance, and release the reference
* at the end unconditionally, leaving the only reference to the actor
* itself.
*/
if (g_object_is_floating (child))
g_object_ref_sink (child);
clutter_actor_insert_child_at_index (parent, child, position + i);
g_object_unref (child);
g_object_unref (item);
}
}
/**
* clutter_actor_bind_model:
* @self: a #ClutterActor
* @model: (nullable): a #GListModel
* @create_child_func: a function that creates #ClutterActor instances
* from the contents of the @model
* @user_data: user data passed to @create_child_func
* @notify: function called when unsetting the @model
*
* Binds a #GListModel to a #ClutterActor.
*
* If the #ClutterActor was already bound to a #GListModel, the previous
* binding is destroyed.
*
* The existing children of #ClutterActor are destroyed when setting a
* model, and new children are created and added, representing the contents
* of the @model. The #ClutterActor is updated whenever the @model changes.
* If @model is %NULL, the #ClutterActor is left empty.
*
* When a #ClutterActor is bound to a model, adding and removing children
* directly is undefined behaviour.
*
* Since: 1.24
*/
void
clutter_actor_bind_model (ClutterActor *self,
GListModel *model,
ClutterActorCreateChildFunc create_child_func,
gpointer user_data,
GDestroyNotify notify)
{
ClutterActorPrivate *priv = clutter_actor_get_instance_private (self);
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (model == NULL || G_IS_LIST_MODEL (model));
g_return_if_fail (model == NULL || create_child_func != NULL);
if (priv->child_model != NULL)
{
if (priv->create_child_notify != NULL)
priv->create_child_notify (priv->create_child_data);
g_signal_handlers_disconnect_by_func (priv->child_model,
clutter_actor_child_model__items_changed,
self);
g_clear_object (&priv->child_model);
priv->create_child_func = NULL;
priv->create_child_data = NULL;
priv->create_child_notify = NULL;
}
clutter_actor_destroy_all_children (self);
if (model == NULL)
return;
priv->child_model = g_object_ref (model);
priv->create_child_func = create_child_func;
priv->create_child_data = user_data;
priv->create_child_notify = notify;
g_signal_connect (priv->child_model, "items-changed",
G_CALLBACK (clutter_actor_child_model__items_changed),
self);
clutter_actor_child_model__items_changed (priv->child_model,
0,
0,
g_list_model_get_n_items (priv->child_model),
self);
}
typedef struct {
GType child_type;
GArray *props;
} BindClosure;
typedef struct {
const char *model_property;
const char *child_property;
GBindingFlags flags;
} BindProperty;
static void
bind_closure_free (gpointer data_)
{
BindClosure *data = data_;
if (data == NULL)
return;
g_array_unref (data->props);
g_slice_free (BindClosure, data);
}
static ClutterActor *
bind_child_with_properties (gpointer item,
gpointer data_)
{
BindClosure *data = data_;
ClutterActor *res;
guint i;
res = g_object_new (data->child_type, NULL);
for (i = 0; i < data->props->len; i++)
{
const BindProperty *prop = &g_array_index (data->props, BindProperty, i);
g_object_bind_property (item, prop->model_property,
res, prop->child_property,
prop->flags);
}
return res;
}
/**
* clutter_actor_bind_model_with_properties:
* @self: a #ClutterActor
* @model: a #GListModel
* @child_type: the type of #ClutterActor to use when creating
* children mapping to items inside the @model
* @first_model_property: the first property of @model to bind
* @...: tuples of property names on the @model, on the child, and the
* #GBindingFlags used to bind them, terminated by %NULL
*
* Binds a #GListModel to a #ClutterActor.
*
* Unlike clutter_actor_bind_model(), this function automatically creates
* a child #ClutterActor of type @child_type, and binds properties on the
* items inside the @model to the corresponding properties on the child,
* for instance:
*
* |[
* clutter_actor_bind_model_with_properties (actor, model,
* MY_TYPE_CHILD_VIEW,
* "label", "text", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE,
* "icon", "image", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE,
* "selected", "selected", G_BINDING_BIDIRECTIONAL,
* "active", "active", G_BINDING_BIDIRECTIONAL,
* NULL);
* ]|
*
* is the equivalent of calling clutter_actor_bind_model() with a
* #ClutterActorCreateChildFunc of:
*
* |[
* ClutterActor *res = g_object_new (MY_TYPE_CHILD_VIEW, NULL);
*
* g_object_bind_property (item, "label", res, "text", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
* g_object_bind_property (item, "icon", res, "image", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
* g_object_bind_property (item, "selected", res, "selected", G_BINDING_BIDIRECTIONAL);
* g_object_bind_property (item, "active", res, "active", G_BINDING_BIDIRECTIONAL);
*
* return res;
* ]|
*
* If the #ClutterActor was already bound to a #GListModel, the previous
* binding is destroyed.
*
* When a #ClutterActor is bound to a model, adding and removing children
* directly is undefined behaviour.
*
* See also: clutter_actor_bind_model()
*
* Since: 1.24
*/
void
clutter_actor_bind_model_with_properties (ClutterActor *self,
GListModel *model,
GType child_type,
const char *first_model_property,
...)
{
va_list args;
BindClosure *clos;
const char *model_property;
g_return_if_fail (CLUTTER_IS_ACTOR (self));
g_return_if_fail (G_IS_LIST_MODEL (model));
g_return_if_fail (g_type_is_a (child_type, CLUTTER_TYPE_ACTOR));
clos = g_slice_new0 (BindClosure);
clos->child_type = child_type;
clos->props = g_array_new (FALSE, FALSE, sizeof (BindProperty));
va_start (args, first_model_property);
model_property = first_model_property;
while (model_property != NULL)
{
const char *child_property = va_arg (args, char *);
GBindingFlags binding_flags = va_arg (args, guint);
BindProperty bind;
bind.model_property = g_intern_string (model_property);
bind.child_property = g_intern_string (child_property);
bind.flags = binding_flags;
g_array_append_val (clos->props, bind);
model_property = va_arg (args, char *);
}
va_end (args);
clutter_actor_bind_model (self, model, bind_child_with_properties, clos, bind_closure_free);
}
/*< private >
* clutter_actor_create_texture_paint_node:
* @self: a #ClutterActor
* @texture: a #CoglTexture
*
* Creates a #ClutterPaintNode initialized using the state of the
* given #ClutterActor, ready to be used inside the implementation
* of the #ClutterActorClass.paint_node virtual function.
*
* The returned paint node has the geometry set to the size of the
* #ClutterActor:content-box property; it uses the filters specified
* in the #ClutterActor:minification-filter and #ClutterActor:magnification-filter
* properties; and respects the #ClutterActor:content-repeat property.
*
* Returns: (transfer full): The newly created #ClutterPaintNode
*
* Since: 1.24
*/
ClutterPaintNode *
clutter_actor_create_texture_paint_node (ClutterActor *self,
CoglTexture *texture)
{
ClutterActorPrivate *priv = clutter_actor_get_instance_private (self);
ClutterPaintNode *node;
ClutterActorBox box;
ClutterColor color;
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
g_return_val_if_fail (texture != NULL, NULL);
clutter_actor_get_content_box (self, &box);
/* ClutterTextureNode will premultiply the blend color, so we
* want it to be white with the paint opacity
*/
color.red = 255;
color.green = 255;
color.blue = 255;
color.alpha = clutter_actor_get_paint_opacity_internal (self);
node = clutter_texture_node_new (texture, &color, priv->min_filter, priv->mag_filter);
clutter_paint_node_set_static_name (node, "Texture");
if (priv->content_repeat == CLUTTER_REPEAT_NONE)
clutter_paint_node_add_rectangle (node, &box);
else
{
float t_w = 1.f, t_h = 1.f;
if ((priv->content_repeat & CLUTTER_REPEAT_X_AXIS) != FALSE)
t_w = (box.x2 - box.x1) / cogl_texture_get_width (texture);
if ((priv->content_repeat & CLUTTER_REPEAT_Y_AXIS) != FALSE)
t_h = (box.y2 - box.y1) / cogl_texture_get_height (texture);
clutter_paint_node_add_texture_rectangle (node, &box,
0.f, 0.f,
t_w, t_h);
}
return node;
}
gboolean
clutter_actor_has_accessible (ClutterActor *actor)
{
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), FALSE);
if (CLUTTER_ACTOR_GET_CLASS (actor)->has_accessible)
return CLUTTER_ACTOR_GET_CLASS (actor)->has_accessible (actor);
return TRUE;
}
muffin-6.4.1/clutter/clutter/clutter-swipe-action.h 0000664 0001750 0001750 00000007134 14723361714 021346 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
* Copyright (C) 2011 Robert Bosch Car Multimedia GmbH.
*
* 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 .
*
* Author:
* Tomeu Vizoso
*
* Based on ClutterDragAction, written by:
* Emmanuele Bassi
*/
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#ifndef __CLUTTER_SWIPE_ACTION_H__
#define __CLUTTER_SWIPE_ACTION_H__
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_SWIPE_ACTION (clutter_swipe_action_get_type ())
#define CLUTTER_SWIPE_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_SWIPE_ACTION, ClutterSwipeAction))
#define CLUTTER_IS_SWIPE_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_SWIPE_ACTION))
#define CLUTTER_SWIPE_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_SWIPE_ACTION, ClutterSwipeActionClass))
#define CLUTTER_IS_SWIPE_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_SWIPE_ACTION))
#define CLUTTER_SWIPE_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_SWIPE_ACTION, ClutterSwipeActionClass))
typedef struct _ClutterSwipeAction ClutterSwipeAction;
typedef struct _ClutterSwipeActionPrivate ClutterSwipeActionPrivate;
typedef struct _ClutterSwipeActionClass ClutterSwipeActionClass;
/**
* ClutterSwipeAction:
*
* The #ClutterSwipeAction structure contains
* only private data and should be accessed using the provided API
*
* Since: 1.8
*/
struct _ClutterSwipeAction
{
/*< private >*/
ClutterGestureAction parent_instance;
ClutterSwipeActionPrivate *priv;
};
/**
* ClutterSwipeActionClass:
* @swept: class handler for the #ClutterSwipeAction::swept signal;
* deprecated since 1.14
* @swipe: class handler for the #ClutterSwipeAction::swipe signal
*
* The #ClutterSwipeActionClass structure contains
* only private data.
*
* Since: 1.8
*/
struct _ClutterSwipeActionClass
{
/*< private >*/
ClutterGestureActionClass parent_class;
/*< public >*/
void (* swept) (ClutterSwipeAction *action,
ClutterActor *actor,
ClutterSwipeDirection direction);
gboolean (* swipe) (ClutterSwipeAction *action,
ClutterActor *actor,
ClutterSwipeDirection direction);
/*< private >*/
void (* _clutter_swipe_action1) (void);
void (* _clutter_swipe_action2) (void);
void (* _clutter_swipe_action3) (void);
void (* _clutter_swipe_action4) (void);
void (* _clutter_swipe_action5) (void);
void (* _clutter_swipe_action6) (void);
};
CLUTTER_EXPORT
GType clutter_swipe_action_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterAction * clutter_swipe_action_new (void);
G_END_DECLS
#endif /* __CLUTTER_SWIPE_ACTION_H__ */
muffin-6.4.1/clutter/clutter/clutter-transition-group.c 0000664 0001750 0001750 00000016037 14723361714 022265 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2012 Intel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author: Emmanuele Bassi
*/
/**
* SECTION:clutter-transition-group
* @Title: ClutterTransitionGroup
* @Short_Description: Group transitions together
*
* The #ClutterTransitionGroup allows running multiple #ClutterTransition
* instances concurrently.
*
* The transitions inside a group will run within the boundaries of the
* group; for instance, if a transition has a duration of 10 seconds, and
* the group that contains it has a duration of 5 seconds, only the first
* 5 seconds of the transition will be played.
*
* #ClutterTransitionGroup is available since Clutter 1.12
*/
#include "clutter-build-config.h"
#include "clutter-transition-group.h"
#include "clutter-debug.h"
#include "clutter-private.h"
struct _ClutterTransitionGroupPrivate
{
GHashTable *transitions;
};
G_DEFINE_TYPE_WITH_PRIVATE (ClutterTransitionGroup, clutter_transition_group, CLUTTER_TYPE_TRANSITION)
static void
clutter_transition_group_new_frame (ClutterTimeline *timeline,
gint elapsed)
{
ClutterTransitionGroupPrivate *priv;
GHashTableIter iter;
gpointer element;
gint64 msecs;
priv = CLUTTER_TRANSITION_GROUP (timeline)->priv;
/* get the time elapsed since the last ::new-frame... */
msecs = clutter_timeline_get_delta (timeline);
g_hash_table_iter_init (&iter, priv->transitions);
while (g_hash_table_iter_next (&iter, &element, NULL))
{
ClutterTimeline *t = element;
/* ... and advance every timeline */
clutter_timeline_set_direction (t, clutter_timeline_get_direction (timeline));
clutter_timeline_set_duration (t, clutter_timeline_get_duration (timeline));
_clutter_timeline_advance (t, msecs);
}
}
static void
clutter_transition_group_attached (ClutterTransition *transition,
ClutterAnimatable *animatable)
{
ClutterTransitionGroupPrivate *priv;
GHashTableIter iter;
gpointer element;
priv = CLUTTER_TRANSITION_GROUP (transition)->priv;
g_hash_table_iter_init (&iter, priv->transitions);
while (g_hash_table_iter_next (&iter, &element, NULL))
{
ClutterTransition *t = element;
clutter_transition_set_animatable (t, animatable);
}
}
static void
clutter_transition_group_detached (ClutterTransition *transition,
ClutterAnimatable *animatable)
{
ClutterTransitionGroupPrivate *priv;
GHashTableIter iter;
gpointer element;
priv = CLUTTER_TRANSITION_GROUP (transition)->priv;
g_hash_table_iter_init (&iter, priv->transitions);
while (g_hash_table_iter_next (&iter, &element, NULL))
{
ClutterTransition *t = element;
clutter_transition_set_animatable (t, NULL);
}
}
static void
clutter_transition_group_started (ClutterTimeline *timeline)
{
ClutterTransitionGroupPrivate *priv;
GHashTableIter iter;
gpointer element;
priv = CLUTTER_TRANSITION_GROUP (timeline)->priv;
g_hash_table_iter_init (&iter, priv->transitions);
while (g_hash_table_iter_next (&iter, &element, NULL))
{
ClutterTransition *t = element;
g_signal_emit_by_name (t, "started");
}
}
static void
clutter_transition_group_finalize (GObject *gobject)
{
ClutterTransitionGroupPrivate *priv;
priv = CLUTTER_TRANSITION_GROUP (gobject)->priv;
g_hash_table_unref (priv->transitions);
G_OBJECT_CLASS (clutter_transition_group_parent_class)->finalize (gobject);
}
static void
clutter_transition_group_class_init (ClutterTransitionGroupClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterTimelineClass *timeline_class = CLUTTER_TIMELINE_CLASS (klass);
ClutterTransitionClass *transition_class = CLUTTER_TRANSITION_CLASS (klass);
gobject_class->finalize = clutter_transition_group_finalize;
timeline_class->started = clutter_transition_group_started;
timeline_class->new_frame = clutter_transition_group_new_frame;
transition_class->attached = clutter_transition_group_attached;
transition_class->detached = clutter_transition_group_detached;
}
static void
clutter_transition_group_init (ClutterTransitionGroup *self)
{
self->priv = clutter_transition_group_get_instance_private (self);
self->priv->transitions =
g_hash_table_new_full (NULL, NULL, (GDestroyNotify) g_object_unref, NULL);
}
/**
* clutter_transition_group_new:
*
* Creates a new #ClutterTransitionGroup instance.
*
* Return value: the newly created #ClutterTransitionGroup. Use
* g_object_unref() when done to deallocate the resources it
* uses
*
* Since: 1.12
*/
ClutterTransition *
clutter_transition_group_new (void)
{
return g_object_new (CLUTTER_TYPE_TRANSITION_GROUP, NULL);
}
/**
* clutter_transition_group_add_transition:
* @group: a #ClutterTransitionGroup
* @transition: a #ClutterTransition
*
* Adds @transition to @group.
*
* This function acquires a reference on @transition that will be released
* when calling clutter_transition_group_remove_transition().
*
* Since: 1.12
*/
void
clutter_transition_group_add_transition (ClutterTransitionGroup *group,
ClutterTransition *transition)
{
g_return_if_fail (CLUTTER_IS_TRANSITION_GROUP (group));
g_return_if_fail (CLUTTER_IS_TRANSITION (transition));
g_hash_table_add (group->priv->transitions, g_object_ref (transition));
}
/**
* clutter_transition_group_remove_transition:
* @group: a #ClutterTransitionGroup
* @transition: a #ClutterTransition
*
* Removes @transition from @group.
*
* This function releases the reference acquired on @transition when
* calling clutter_transition_group_add_transition().
*
* Since: 1.12
*/
void
clutter_transition_group_remove_transition (ClutterTransitionGroup *group,
ClutterTransition *transition)
{
g_return_if_fail (CLUTTER_IS_TRANSITION_GROUP (group));
g_hash_table_remove (group->priv->transitions, transition);
}
/**
* clutter_transition_group_remove_all:
* @group: a #ClutterTransitionGroup
*
* Removes all transitions from @group.
*
* This function releases the reference acquired when calling
* clutter_transition_group_add_transition().
*
* Since: 1.12
*/
void
clutter_transition_group_remove_all (ClutterTransitionGroup *group)
{
g_return_if_fail (CLUTTER_IS_TRANSITION_GROUP (group));
g_hash_table_remove_all (group->priv->transitions);
}
muffin-6.4.1/clutter/clutter/clutter-stage-window.h 0000664 0001750 0001750 00000012550 14723361714 021352 0 ustar fabio fabio #ifndef __CLUTTER_STAGE_WINDOW_H__
#define __CLUTTER_STAGE_WINDOW_H__
#include
#include
#include "clutter/clutter-stage-view.h"
G_BEGIN_DECLS
#define CLUTTER_TYPE_STAGE_WINDOW (clutter_stage_window_get_type ())
CLUTTER_EXPORT
G_DECLARE_INTERFACE (ClutterStageWindow, clutter_stage_window,
CLUTTER, STAGE_WINDOW,
GObject)
/*
* ClutterStageWindowInterface: (skip)
*
* The interface implemented by backends for stage windows
*
* Since: 0.8
*/
struct _ClutterStageWindowInterface
{
/*< private >*/
GTypeInterface parent_iface;
ClutterActor *(* get_wrapper) (ClutterStageWindow *stage_window);
void (* set_title) (ClutterStageWindow *stage_window,
const gchar *title);
void (* set_cursor_visible) (ClutterStageWindow *stage_window,
gboolean cursor_visible);
gboolean (* realize) (ClutterStageWindow *stage_window);
void (* unrealize) (ClutterStageWindow *stage_window);
void (* show) (ClutterStageWindow *stage_window,
gboolean do_raise);
void (* hide) (ClutterStageWindow *stage_window);
void (* resize) (ClutterStageWindow *stage_window,
gint width,
gint height);
void (* get_geometry) (ClutterStageWindow *stage_window,
cairo_rectangle_int_t *geometry);
void (* schedule_update) (ClutterStageWindow *stage_window,
int sync_delay);
gint64 (* get_update_time) (ClutterStageWindow *stage_window);
void (* clear_update_time) (ClutterStageWindow *stage_window);
void (* set_accept_focus) (ClutterStageWindow *stage_window,
gboolean accept_focus);
void (* redraw) (ClutterStageWindow *stage_window);
gboolean (* can_clip_redraws) (ClutterStageWindow *stage_window);
GList *(* get_views) (ClutterStageWindow *stage_window);
int64_t (* get_frame_counter) (ClutterStageWindow *stage_window);
void (* finish_frame) (ClutterStageWindow *stage_window);
int64_t (* get_next_presentation_time) (ClutterStageWindow *stage_window);
};
ClutterActor * _clutter_stage_window_get_wrapper (ClutterStageWindow *window);
void _clutter_stage_window_set_title (ClutterStageWindow *window,
const gchar *title);
void _clutter_stage_window_set_cursor_visible (ClutterStageWindow *window,
gboolean is_visible);
gboolean _clutter_stage_window_realize (ClutterStageWindow *window);
void _clutter_stage_window_unrealize (ClutterStageWindow *window);
void _clutter_stage_window_show (ClutterStageWindow *window,
gboolean do_raise);
void _clutter_stage_window_hide (ClutterStageWindow *window);
void _clutter_stage_window_resize (ClutterStageWindow *window,
gint width,
gint height);
CLUTTER_EXPORT
void _clutter_stage_window_get_geometry (ClutterStageWindow *window,
cairo_rectangle_int_t *geometry);
void _clutter_stage_window_schedule_update (ClutterStageWindow *window,
int sync_delay);
gint64 _clutter_stage_window_get_update_time (ClutterStageWindow *window);
void _clutter_stage_window_clear_update_time (ClutterStageWindow *window);
void _clutter_stage_window_set_accept_focus (ClutterStageWindow *window,
gboolean accept_focus);
void _clutter_stage_window_redraw (ClutterStageWindow *window);
gboolean _clutter_stage_window_can_clip_redraws (ClutterStageWindow *window);
GList * _clutter_stage_window_get_views (ClutterStageWindow *window);
void _clutter_stage_window_finish_frame (ClutterStageWindow *window);
int64_t _clutter_stage_window_get_frame_counter (ClutterStageWindow *window);
int64_t _clutter_stage_window_get_next_presentation_time (ClutterStageWindow *window);
G_END_DECLS
#endif /* __CLUTTER_STAGE_WINDOW_H__ */
muffin-6.4.1/clutter/clutter/meson.build 0000664 0001750 0001750 00000035446 14723361714 017264 0 ustar fabio fabio clutter_clutter_includesubdir = join_paths(clutter_includesubdir, 'clutter')
clutter_clutter_includedir = join_paths(clutter_includedir, 'clutter')
clutter_headers = [
'clutter.h',
'clutter-action.h',
'clutter-actor-meta.h',
'clutter-actor.h',
'clutter-align-constraint.h',
'clutter-animatable.h',
'clutter-autocleanups.h',
'clutter-backend.h',
'clutter-bind-constraint.h',
'clutter-binding-pool.h',
'clutter-bin-layout.h',
'clutter-blur-effect.h',
'clutter-box-layout.h',
'clutter-brightness-contrast-effect.h',
'clutter-cairo.h',
'clutter-canvas.h',
'clutter-child-meta.h',
'clutter-click-action.h',
'clutter-clone.h',
'clutter-color-static.h',
'clutter-color.h',
'clutter-colorize-effect.h',
'clutter-constraint.h',
'clutter-container.h',
'clutter-content.h',
'clutter-deform-effect.h',
'clutter-deprecated.h',
'clutter-desaturate-effect.h',
'clutter-drag-action.h',
'clutter-drop-action.h',
'clutter-effect.h',
'clutter-enums.h',
'clutter-event.h',
'clutter-feature.h',
'clutter-fixed-layout.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',
'clutter-input-focus.h',
'clutter-input-method.h',
'clutter-interval.h',
'clutter-keyframe-transition.h',
'clutter-keymap.h',
'clutter-keysyms.h',
'clutter-layout-manager.h',
'clutter-layout-meta.h',
'clutter-macros.h',
'clutter-main.h',
'clutter-mutter.h',
'clutter-offscreen-effect.h',
'clutter-page-turn-effect.h',
'clutter-paint-context.h',
'clutter-paint-nodes.h',
'clutter-paint-node.h',
'clutter-pan-action.h',
'clutter-path-constraint.h',
'clutter-path.h',
'clutter-pick-context.h',
'clutter-property-transition.h',
'clutter-rotate-action.h',
'clutter-script.h',
'clutter-scriptable.h',
'clutter-scroll-actor.h',
'clutter-seat.h',
'clutter-settings.h',
'clutter-shader-effect.h',
'clutter-shader-types.h',
'clutter-swipe-action.h',
'clutter-snap-constraint.h',
'clutter-stage.h',
'clutter-stage-manager.h',
'clutter-stage-view.h',
'clutter-tap-action.h',
'clutter-text.h',
'clutter-text-buffer.h',
'clutter-texture-content.h',
'clutter-timeline.h',
'clutter-transition-group.h',
'clutter-transition.h',
'clutter-types.h',
'clutter-units.h',
'clutter-virtual-input-device.h',
'clutter-zoom-action.h',
]
clutter_sources = [
'clutter-action.c',
'clutter-actor-box.c',
'clutter-actor-meta.c',
'clutter-actor.c',
'clutter-align-constraint.c',
'clutter-animatable.c',
'clutter-backend.c',
'clutter-base-types.c',
'clutter-bezier.c',
'clutter-bind-constraint.c',
'clutter-binding-pool.c',
'clutter-bin-layout.c',
'clutter-blur-effect.c',
'clutter-box-layout.c',
'clutter-brightness-contrast-effect.c',
'clutter-cairo.c',
'clutter-canvas.c',
'clutter-child-meta.c',
'clutter-click-action.c',
'clutter-clone.c',
'clutter-color.c',
'clutter-colorize-effect.c',
'clutter-constraint.c',
'clutter-container.c',
'clutter-content.c',
'clutter-deform-effect.c',
'clutter-desaturate-effect.c',
'clutter-drag-action.c',
'clutter-drop-action.c',
'clutter-effect.c',
'clutter-event.c',
'clutter-feature.c',
'clutter-fixed-layout.c',
'clutter-flatten-effect.c',
'clutter-flow-layout.c',
'clutter-gesture-action.c',
'clutter-graphene.c',
'clutter-grid-layout.c',
'clutter-image.c',
'clutter-input-device.c',
'clutter-input-device-tool.c',
'clutter-input-focus.c',
'clutter-input-method.c',
'clutter-input-pointer-a11y.c',
'clutter-virtual-input-device.c',
'clutter-interval.c',
'clutter-keyframe-transition.c',
'clutter-keymap.c',
'clutter-keysyms-table.c',
'clutter-layout-manager.c',
'clutter-layout-meta.c',
'clutter-main.c',
'clutter-master-clock.c',
'clutter-master-clock-default.c',
'clutter-offscreen-effect.c',
'clutter-page-turn-effect.c',
'clutter-paint-context.c',
'clutter-paint-nodes.c',
'clutter-paint-node.c',
'clutter-pan-action.c',
'clutter-path-constraint.c',
'clutter-path.c',
'clutter-pick-context.c',
'clutter-property-transition.c',
'clutter-rotate-action.c',
'clutter-script.c',
'clutter-script-parser.c',
'clutter-scriptable.c',
'clutter-scroll-actor.c',
'clutter-seat.c',
'clutter-settings.c',
'clutter-shader-effect.c',
'clutter-shader-types.c',
'clutter-swipe-action.c',
'clutter-snap-constraint.c',
'clutter-stage.c',
'clutter-stage-manager.c',
'clutter-stage-view.c',
'clutter-stage-window.c',
'clutter-tap-action.c',
'clutter-text.c',
'clutter-text-buffer.c',
'clutter-texture-content.c',
'clutter-transition-group.c',
'clutter-transition.c',
'clutter-timeline.c',
'clutter-units.c',
'clutter-util.c',
'clutter-paint-volume.c',
'clutter-zoom-action.c',
]
clutter_private_headers = [
'clutter-actor-meta-private.h',
'clutter-actor-private.h',
'clutter-backend-private.h',
'clutter-bezier.h',
'clutter-constraint-private.h',
'clutter-content-private.h',
'clutter-debug.h',
'clutter-easing.h',
'clutter-effect-private.h',
'clutter-event-private.h',
'clutter-flatten-effect.h',
'clutter-graphene.h',
'clutter-gesture-action-private.h',
'clutter-id-pool.h',
'clutter-input-device-private.h',
'clutter-input-focus-private.h',
'clutter-input-method-private.h',
'clutter-input-pointer-a11y-private.h',
'clutter-master-clock.h',
'clutter-master-clock-default.h',
'clutter-offscreen-effect-private.h',
'clutter-paint-context-private.h',
'clutter-paint-node-private.h',
'clutter-paint-volume-private.h',
'clutter-private.h',
'clutter-script-private.h',
'clutter-settings-private.h',
'clutter-stage-manager-private.h',
'clutter-stage-private.h',
'clutter-stage-view-private.h',
'clutter-stage-window.h',
]
clutter_nonintrospected_sources = [
'clutter-easing.c',
'clutter-id-pool.c',
]
clutter_deprecated_headers = [
'deprecated/clutter-actor.h',
'deprecated/clutter-alpha.h',
'deprecated/clutter-animation.h',
'deprecated/clutter-box.h',
'deprecated/clutter-container.h',
'deprecated/clutter-group.h',
'deprecated/clutter-rectangle.h',
'deprecated/clutter-stage.h',
'deprecated/clutter-state.h',
'deprecated/clutter-timeline.h',
]
clutter_deprecated_sources = [
'deprecated/clutter-alpha.c',
'deprecated/clutter-animation.c',
'deprecated/clutter-box.c',
'deprecated/clutter-group.c',
'deprecated/clutter-rectangle.c',
'deprecated/clutter-state.c',
]
clutter_backend_sources = []
clutter_backend_nonintrospected_sources = [
'cogl/clutter-stage-cogl.c',
]
clutter_backend_headers = []
clutter_backend_private_headers = [
'cogl/clutter-stage-cogl.h',
]
if have_x11
clutter_x11_sources = [
'x11/clutter-backend-x11.c',
]
clutter_backend_sources += clutter_x11_sources
clutter_x11_headers = [
'x11/clutter-x11.h',
]
clutter_backend_headers += clutter_x11_headers
clutter_x11_private_headers = [
'x11/clutter-backend-x11.h',
'x11/clutter-settings-x11.h',
]
clutter_backend_private_headers += clutter_x11_private_headers
clutter_x11_nonintrospected_sources = [
'x11/xsettings/xsettings-client.c',
'x11/xsettings/xsettings-client.h',
'x11/xsettings/xsettings-common.c',
'x11/xsettings/xsettings-common.h',
]
clutter_backend_nonintrospected_sources += clutter_x11_nonintrospected_sources
endif
if have_native_backend
clutter_native_nonintrospected_sources = [
'egl/clutter-backend-eglnative.c',
]
clutter_backend_nonintrospected_sources += clutter_native_nonintrospected_sources
endif
if have_wayland
clutter_wayland_private_headers = [
'wayland/clutter-wayland-compositor.h',
]
clutter_backend_private_headers += clutter_wayland_private_headers
endif
cally_headers = [
'cally/cally-actor.h',
'cally/cally-clone.h',
'cally/cally-factory.h',
'cally/cally-group.h',
'cally/cally.h',
'cally/cally-main.h',
'cally/cally-rectangle.h',
'cally/cally-root.h',
'cally/cally-stage.h',
'cally/cally-text.h',
'cally/cally-util.h',
]
cally_sources = [
'cally/cally-actor.c',
'cally/cally.c',
'cally/cally-clone.c',
'cally/cally-group.c',
'cally/cally-rectangle.c',
'cally/cally-root.c',
'cally/cally-stage.c',
'cally/cally-text.c',
'cally/cally-util.c',
]
cally_private_headers = [
'cally/cally-actor-private.h',
]
clutter_built_sources = []
clutter_built_headers = []
clutter_built_private_headers = []
cdata = configuration_data()
cdata.set_quoted('MUTTER_VERSION', meson.project_version())
cdata.set('CLUTTER_DRIVERS', '"*"')
cdata.set('HAVE_EVDEV', have_native_backend)
cdata.set('HAVE_LIBWACOM', have_libwacom)
cdata.set('HAVE_PANGO_FT2', have_pango_ft2)
clutter_build_config_h = configure_file(
input: 'clutter-build-config.h.meson',
output: 'clutter-build-config.h',
configuration: cdata,
install: false,
)
clutter_built_private_headers += clutter_build_config_h
clutter_config_defines = []
if have_wayland
clutter_config_defines += [
'#define CLUTTER_HAS_WAYLAND_COMPOSITOR_SUPPORT 1',
]
endif
if have_x11
clutter_config_defines += [
'#define CLUTTER_WINDOWING_X11 "x11"',
'#define CLUTTER_INPUT_X11 "x11"',
'#define CLUTTER_WINDOWING_GLX "glx"',
]
endif
if have_native_backend
clutter_config_defines += [
'#define CLUTTER_WINDOWING_EGL "eglnative"',
'#define CLUTTER_INPUT_EVDEV "evdev"',
]
endif
clutter_config_defines += [
'#define CLUTTER_INPUT_NULL "null"',
]
clutter_config_defines_string = ''
foreach clutter_config_define : clutter_config_defines
clutter_config_defines_string += clutter_config_define + '\n'
endforeach
cdata = configuration_data()
cdata.set('CLUTTER_CONFIG_DEFINES', clutter_config_defines_string)
clutter_config_h = configure_file(
input: 'clutter-config.h.in',
output: 'clutter-config.h',
configuration: cdata,
install: true,
install_dir: clutter_clutter_includedir,
)
clutter_built_headers += clutter_config_h
clutter_enum_types = gnome.mkenums('clutter-enum-types',
sources: [clutter_headers, clutter_deprecated_headers],
c_template: 'clutter-enum-types.c.in',
h_template: 'clutter-enum-types.h.in',
install_dir: clutter_clutter_includedir,
install_header: true,
)
clutter_built_sources += clutter_enum_types[0]
clutter_built_headers += clutter_enum_types[1]
clutter_marshal = gnome.genmarshal('clutter-marshal',
prefix: '_clutter_marshal',
sources: 'clutter-marshal.list',
valist_marshallers: true,
extra_args: ['--quiet'],
install_dir: clutter_clutter_includedir,
install_header: true,
)
clutter_built_sources += clutter_marshal[0]
clutter_built_headers += clutter_marshal[1]
libmutter_clutter_name = 'muffin-clutter-' + libmutter_api_version
libmutter_clutter = shared_library(libmutter_clutter_name,
sources: [
clutter_sources,
clutter_headers,
clutter_private_headers,
clutter_nonintrospected_sources,
clutter_deprecated_sources,
clutter_deprecated_headers,
clutter_backend_sources,
clutter_backend_nonintrospected_sources,
clutter_backend_headers,
clutter_backend_private_headers,
clutter_built_sources,
clutter_built_headers,
cally_sources,
cally_headers,
cally_private_headers,
],
version: '0.0.0',
soversion: 0,
c_args: clutter_c_args,
include_directories: clutter_includes,
dependencies: [clutter_deps],
gnu_symbol_visibility: 'hidden',
link_with: [
libmutter_cogl,
libmutter_cogl_pango,
libmutter_cogl_path,
],
install_rpath: pkglibdir,
install_dir: pkglibdir,
install: true,
)
libmutter_clutter_dep = declare_dependency(
sources: [clutter_enum_types[1]],
link_with: libmutter_clutter,
dependencies: clutter_deps,
)
if have_introspection
clutter_introspection_args = introspection_args + [
'-DCLUTTER_SYSCONFDIR="@0@"'.format(join_paths(prefix, sysconfdir)),
'-DCLUTTER_COMPILATION=1',
'-DCOGL_DISABLE_DEPRECATION_WARNINGS',
'-DG_LOG_DOMAIN="Clutter"'
]
libmutter_clutter_gir = gnome.generate_gir(libmutter_clutter,
sources: [
clutter_built_sources,
clutter_built_headers,
clutter_sources,
clutter_headers,
clutter_deprecated_sources,
clutter_deprecated_headers,
],
nsversion: libmutter_api_version,
namespace: 'Clutter',
export_packages: [libmutter_clutter_name],
includes: [
libmutter_cogl_gir[0],
libmutter_cogl_pango_gir[0],
'GL-1.0',
'GObject-2.0',
'cairo-1.0',
'Atk-1.0',
'Json-1.0',
],
dependencies: [cogl_deps],
extra_args: clutter_introspection_args + ['--c-include=clutter/clutter.h'],
install_dir_gir: pkglibdir,
install_dir_typelib: pkglibdir,
install: true,
)
libmutter_cally_gir = gnome.generate_gir(libmutter_clutter,
sources: [
cally_sources,
cally_headers,
],
nsversion: libmutter_api_version,
namespace: 'Cally',
includes: [
libmutter_cogl_gir[0],
libmutter_cogl_pango_gir[0],
libmutter_clutter_gir[0],
],
dependencies: [cogl_deps],
extra_args: clutter_introspection_args,
install_dir_gir: pkglibdir,
install_dir_typelib: pkglibdir,
install: true
)
if have_x11
libmutter_clutter_x11_gir = gnome.generate_gir(libmutter_clutter,
sources: [
clutter_x11_sources,
clutter_x11_headers,
],
nsversion: libmutter_api_version,
namespace: 'ClutterX11',
export_packages: ['muffin-clutter-x11-' + libmutter_api_version],
includes: [
libmutter_cogl_gir[0],
libmutter_cogl_pango_gir[0],
libmutter_clutter_gir[0],
'xlib-2.0',
],
dependencies: [],
extra_args: clutter_introspection_args,
install_dir_gir: pkglibdir,
install_dir_typelib: pkglibdir,
install: true
)
endif
endif
install_headers(clutter_headers,
subdir: clutter_clutter_includesubdir)
install_headers(cally_headers,
subdir: join_paths(clutter_includesubdir, 'cally'))
install_headers(clutter_deprecated_headers,
subdir: join_paths(clutter_clutter_includesubdir, 'deprecated'))
install_headers(clutter_x11_headers,
subdir: join_paths(clutter_clutter_includesubdir, 'x11'))
pkg.generate(libmutter_clutter,
name: 'Muffins Clutter',
filebase: libmutter_clutter_name,
description: 'Muffinss Clutter Private Library',
libraries: [m_dep],
subdirs: join_paths(pkgname, 'clutter'),
requires: [clutter_pkg_deps, libmutter_cogl_name],
version: meson.project_version(),
variables: [
'apiversion=' + libmutter_api_version,
],
install_dir: pcdir,
)
pkg.generate(libmutter_clutter,
name: 'Muffins ClutterX11',
filebase: 'muffin-clutter-x11-' + libmutter_api_version,
description: 'Muffin ClutterX11 Private Library',
libraries: [m_dep],
subdirs: join_paths(pkgname, 'clutter'),
requires: [clutter_pkg_deps, libmutter_cogl_name],
version: meson.project_version(),
variables: [
'apiversion=' + libmutter_api_version,
],
install_dir: pcdir,
)
muffin-6.4.1/clutter/clutter/clutter-action.c 0000664 0001750 0001750 00000003557 14723361714 020221 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
/**
* SECTION:clutter-action
* @Title: ClutterAction
* @Short_Description: Abstract class for event-related logic
* @See_Also: #ClutterConstraint
*
* #ClutterAction is an abstract base class for event-related actions that
* modify the user interaction of a #ClutterActor, just like
* #ClutterConstraint is an abstract class for modifiers of an actor's
* position or size.
*
* Implementations of #ClutterAction are associated to an actor and can
* provide behavioral changes when dealing with user input - for instance
* drag and drop capabilities, or scrolling, or panning - by using the
* various event-related signals provided by #ClutterActor itself.
*
* #ClutterAction is available since Clutter 1.4
*/
#include "clutter-build-config.h"
#include "clutter-action.h"
#include "clutter-debug.h"
#include "clutter-private.h"
G_DEFINE_ABSTRACT_TYPE (ClutterAction, clutter_action, CLUTTER_TYPE_ACTOR_META);
static void
clutter_action_class_init (ClutterActionClass *klass)
{
}
static void
clutter_action_init (ClutterAction *self)
{
}
muffin-6.4.1/clutter/clutter/clutter-macros.h 0000664 0001750 0001750 00000010352 14723361714 020224 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2012 Intel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*/
#ifndef __CLUTTER_MACROS_H__
#define __CLUTTER_MACROS_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
/**
* CLUTTER_FLAVOUR:
*
* GL Windowing system used
*
* Since: 0.4
*
* Deprecated: 1.10: The macro evaluates to "deprecated" as Clutter can be
* compiled with multiple windowing system backends. Use the various
* CLUTTER_WINDOWING_* macros to detect the windowing system that Clutter
* is being compiled against, and the type check macros for the
* #ClutterBackend for a run-time check.
*/
#define CLUTTER_FLAVOUR "deprecated"
/**
* CLUTTER_COGL:
*
* Cogl (internal GL abstraction utility library) backend. Can be "gl" or
* "gles" currently
*
* Since: 0.4
*
* Deprecated: 1.10: The macro evaluates to "deprecated" as Cogl can be
* compiled against multiple GL implementations.
*/
#define CLUTTER_COGL "deprecated"
/**
* CLUTTER_STAGE_TYPE:
*
* The default GObject type for the Clutter stage.
*
* Since: 0.8
*
* Deprecated: 1.10: The macro evaluates to "deprecated" as Clutter can
* be compiled against multiple windowing systems. You can use the
* CLUTTER_WINDOWING_* macros for compile-time checks, and the type
* check macros for run-time checks.
*/
#define CLUTTER_STAGE_TYPE "deprecated"
/**
* CLUTTER_NO_FPU:
*
* Set to 1 if Clutter was built without FPU (i.e fixed math), 0 otherwise
*
* Deprecated: 0.6: This macro is no longer defined (identical code is used
* regardless the presence of FPU).
*/
#define CLUTTER_NO_FPU (0)
/* some structures are meant to be opaque and still be allocated on the stack;
* in order to avoid people poking at their internals, we use this macro to
* ensure that users don't accidentally access a struct private members.
*
* we use the CLUTTER_COMPILATION define to allow us easier access, though.
*/
#ifdef CLUTTER_COMPILATION
#define CLUTTER_PRIVATE_FIELD(x) x
#else
#define CLUTTER_PRIVATE_FIELD(x) clutter_private_ ## x
#endif
#define _CLUTTER_EXTERN __attribute__((visibility("default"))) extern
#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) || \
__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 4)
#define _CLUTTER_GNUC_DO_PRAGMA(x) _Pragma(G_STRINGIFY (x))
#define _CLUTTER_DEPRECATED_MACRO _CLUTTER_GNUC_DO_PRAGMA(GCC warning "Deprecated macro")
#define _CLUTTER_DEPRECATED_MACRO_FOR(f) _CLUTTER_GNUC_DO_PRAGMA(GCC warning #f)
#else
#define _CLUTTER_DEPRECATED_MACRO
#define _CLUTTER_DEPRECATED_MACRO_FOR(f)
#endif
/* these macros are used to mark deprecated functions, and thus have to be
* exposed in a public header.
*
* do *not* use them in other libraries depending on Clutter: use G_DEPRECATED
* and G_DEPRECATED_FOR, or use your own wrappers around them.
*/
#ifdef CLUTTER_DISABLE_DEPRECATION_WARNINGS
#define CLUTTER_DEPRECATED _CLUTTER_EXTERN
#define CLUTTER_DEPRECATED_FOR(f) _CLUTTER_EXTERN
#define CLUTTER_DEPRECATED_MACRO
#define CLUTTER_DEPRECATED_MACRO_FOR(f)
#else
#define CLUTTER_DEPRECATED G_DEPRECATED _CLUTTER_EXTERN
#define CLUTTER_DEPRECATED_FOR(f) G_DEPRECATED_FOR(f) _CLUTTER_EXTERN
#define CLUTTER_DEPRECATED_MACRO _CLUTTER_DEPRECATED_MACRO
#define CLUTTER_DEPRECATED_MACRO_FOR(f) _CLUTTER_DEPRECATED_MACRO_FOR(f)
#endif
#define CLUTTER_MACRO_DEPRECATED CLUTTER_DEPRECATED_MACRO
#define CLUTTER_MACRO_DEPRECATED_FOR(f) CLUTTER_DEPRECATED_MACRO_FOR(f)
#define CLUTTER_EXPORT _CLUTTER_EXTERN
#endif /* __CLUTTER_MACROS_H__ */
muffin-6.4.1/clutter/clutter/clutter-private.h 0000664 0001750 0001750 00000030444 14723361714 020416 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum
*
* Copyright (C) 2006 OpenedHand
*
* 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 .
*
*
*/
#ifndef __CLUTTER_PRIVATE_H__
#define __CLUTTER_PRIVATE_H__
#include
#include
#include
#include "clutter-backend.h"
#include "clutter-effect.h"
#include "clutter-event.h"
#include "clutter-feature.h"
#include "clutter-id-pool.h"
#include "clutter-layout-manager.h"
#include "clutter-master-clock.h"
#include "clutter-settings.h"
#include "clutter-stage-manager.h"
#include "clutter-stage.h"
G_BEGIN_DECLS
typedef struct _ClutterMainContext ClutterMainContext;
typedef struct _ClutterVertex4 ClutterVertex4;
#define CLUTTER_REGISTER_VALUE_TRANSFORM_TO(TYPE_TO,func) { \
g_value_register_transform_func (g_define_type_id, TYPE_TO, func); \
}
#define CLUTTER_REGISTER_VALUE_TRANSFORM_FROM(TYPE_FROM,func) { \
g_value_register_transform_func (TYPE_FROM, g_define_type_id, func); \
}
#define CLUTTER_REGISTER_INTERVAL_PROGRESS(func) { \
clutter_interval_register_progress_func (g_define_type_id, func); \
}
#define CLUTTER_PRIVATE_FLAGS(a) (((ClutterActor *) (a))->private_flags)
#define CLUTTER_SET_PRIVATE_FLAGS(a,f) (CLUTTER_PRIVATE_FLAGS (a) |= (f))
#define CLUTTER_UNSET_PRIVATE_FLAGS(a,f) (CLUTTER_PRIVATE_FLAGS (a) &= ~(f))
#define CLUTTER_ACTOR_IS_TOPLEVEL(a) ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IS_TOPLEVEL) != FALSE)
#define CLUTTER_ACTOR_IN_DESTRUCTION(a) ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_DESTRUCTION) != FALSE)
#define CLUTTER_ACTOR_IN_REPARENT(a) ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_REPARENT) != FALSE)
#define CLUTTER_ACTOR_IN_PAINT(a) ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_PAINT) != FALSE)
#define CLUTTER_ACTOR_IN_PICK(a) ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_PICK) != FALSE)
#define CLUTTER_ACTOR_IN_RELAYOUT(a) ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_RELAYOUT) != FALSE)
#define CLUTTER_ACTOR_IN_PREF_WIDTH(a) ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_PREF_WIDTH) != FALSE)
#define CLUTTER_ACTOR_IN_PREF_HEIGHT(a) ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_PREF_HEIGHT) != FALSE)
#define CLUTTER_ACTOR_IN_PREF_SIZE(a) ((CLUTTER_PRIVATE_FLAGS (a) & (CLUTTER_IN_PREF_HEIGHT|CLUTTER_IN_PREF_WIDTH)) != FALSE)
#define CLUTTER_ACTOR_IN_MAP_UNMAP(a) ((CLUTTER_PRIVATE_FLAGS (a) & CLUTTER_IN_MAP_UNMAP) != FALSE)
#define CLUTTER_PARAM_READABLE (G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)
#define CLUTTER_PARAM_WRITABLE (G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS)
#define CLUTTER_PARAM_READWRITE (G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS)
#define CLUTTER_PARAM_ANIMATABLE (1 << G_PARAM_USER_SHIFT)
/* automagic interning of a static string */
#define I_(str) (g_intern_static_string ((str)))
/* keep this for source compatibility with clutter */
#define P_(String) (String)
#define N_(String) (String)
/* This is a replacement for the nearbyint function which always rounds to the
* nearest integer. nearbyint is apparently a C99 function so it might not
* always be available but also it seems in glibc it is defined as a function
* call so this macro could end up faster anyway. We can't just add 0.5f
* because it will break for negative numbers. */
#define CLUTTER_NEARBYINT(x) ((int) ((x) < 0.0f ? (x) - 0.5f : (x) + 0.5f))
typedef enum
{
CLUTTER_ACTOR_UNUSED_FLAG = 0,
CLUTTER_IN_DESTRUCTION = 1 << 0,
CLUTTER_IS_TOPLEVEL = 1 << 1,
CLUTTER_IN_REPARENT = 1 << 2,
CLUTTER_IN_PREF_WIDTH = 1 << 3,
CLUTTER_IN_PREF_HEIGHT = 1 << 4,
/* Used to avoid recursion */
CLUTTER_IN_PAINT = 1 << 5,
CLUTTER_IN_PICK = 1 << 6,
/* Used to avoid recursion */
CLUTTER_IN_RELAYOUT = 1 << 7,
CLUTTER_IN_MAP_UNMAP = 1 << 8,
} ClutterPrivateFlags;
/*
* ClutterMainContext:
*
* The shared state of Clutter
*/
struct _ClutterMainContext
{
/* the main windowing system backend */
ClutterBackend *backend;
/* the object holding all the stage instances */
ClutterStageManager *stage_manager;
/* the clock driving all the frame operations */
ClutterMasterClock *master_clock;
/* the main event queue */
GQueue *events_queue;
/* the event filters added via clutter_event_add_filter. these are
* ordered from least recently added to most recently added */
GList *event_filters;
ClutterPickMode pick_mode;
/* default FPS; this is only used if we cannot sync to vblank */
guint frame_rate;
/* fb bit masks for col<->id mapping in picking */
gint fb_r_mask;
gint fb_g_mask;
gint fb_b_mask;
gint fb_r_mask_used;
gint fb_g_mask_used;
gint fb_b_mask_used;
CoglPangoFontMap *font_map; /* Global font map */
/* stack of #ClutterEvent */
GSList *current_event;
/* list of repaint functions installed through
* clutter_threads_add_repaint_func()
*/
GList *repaint_funcs;
guint last_repaint_id;
/* main settings singleton */
ClutterSettings *settings;
/* boolean flags */
guint is_initialized : 1;
guint defer_display_setup : 1;
guint options_parsed : 1;
guint show_fps : 1;
};
/* shared between clutter-main.c and clutter-frame-source.c */
typedef struct
{
GSourceFunc func;
gpointer data;
GDestroyNotify notify;
} ClutterThreadsDispatch;
gboolean _clutter_threads_dispatch (gpointer data);
void _clutter_threads_dispatch_free (gpointer data);
CLUTTER_EXPORT
void _clutter_threads_acquire_lock (void);
CLUTTER_EXPORT
void _clutter_threads_release_lock (void);
ClutterMainContext * _clutter_context_get_default (void);
void _clutter_context_lock (void);
void _clutter_context_unlock (void);
gboolean _clutter_context_is_initialized (void);
ClutterPickMode _clutter_context_get_pick_mode (void);
gboolean _clutter_context_get_show_fps (void);
gboolean _clutter_feature_init (GError **error);
/* Diagnostic mode */
gboolean _clutter_diagnostic_enabled (void);
void _clutter_diagnostic_message (const char *fmt, ...) G_GNUC_PRINTF (1, 2);
CLUTTER_EXPORT
void _clutter_set_sync_to_vblank (gboolean sync_to_vblank);
/* use this function as the accumulator if you have a signal with
* a G_TYPE_BOOLEAN return value; this will stop the emission as
* soon as one handler returns TRUE
*/
gboolean _clutter_boolean_handled_accumulator (GSignalInvocationHint *ihint,
GValue *return_accu,
const GValue *handler_return,
gpointer dummy);
/* use this function as the accumulator if you have a signal with
* a G_TYPE_BOOLEAN return value; this will stop the emission as
* soon as one handler returns FALSE
*/
gboolean _clutter_boolean_continue_accumulator (GSignalInvocationHint *ihint,
GValue *return_accu,
const GValue *handler_return,
gpointer dummy);
void _clutter_run_repaint_functions (ClutterRepaintFlags flags);
GType _clutter_layout_manager_get_child_meta_type (ClutterLayoutManager *manager);
void _clutter_util_fully_transform_vertices (const CoglMatrix *modelview,
const CoglMatrix *projection,
const float *viewport,
const graphene_point3d_t *vertices_in,
graphene_point3d_t *vertices_out,
int n_vertices);
void _clutter_util_rect_from_rectangle (const cairo_rectangle_int_t *src,
graphene_rect_t *dest);
void _clutter_util_rectangle_int_extents (const graphene_rect_t *src,
cairo_rectangle_int_t *dest);
void _clutter_util_rectangle_offset (const cairo_rectangle_int_t *src,
int x,
int y,
cairo_rectangle_int_t *dest);
void _clutter_util_rectangle_union (const cairo_rectangle_int_t *src1,
const cairo_rectangle_int_t *src2,
cairo_rectangle_int_t *dest);
gboolean _clutter_util_rectangle_intersection (const cairo_rectangle_int_t *src1,
const cairo_rectangle_int_t *src2,
cairo_rectangle_int_t *dest);
gboolean clutter_util_rectangle_equal (const cairo_rectangle_int_t *src1,
const cairo_rectangle_int_t *src2);
struct _ClutterVertex4
{
float x;
float y;
float z;
float w;
};
void
_clutter_util_vertex4_interpolate (const ClutterVertex4 *a,
const ClutterVertex4 *b,
double progress,
ClutterVertex4 *res);
#define CLUTTER_MATRIX_INIT_IDENTITY { \
1.0f, 0.0f, 0.0f, 0.0f, \
0.0f, 1.0f, 0.0f, 0.0f, \
0.0f, 0.0f, 1.0f, 0.0f, \
0.0f, 0.0f, 0.0f, 1.0f, \
}
float _clutter_util_matrix_determinant (const ClutterMatrix *matrix);
void _clutter_util_matrix_skew_xy (ClutterMatrix *matrix,
float factor);
void _clutter_util_matrix_skew_xz (ClutterMatrix *matrix,
float factor);
void _clutter_util_matrix_skew_yz (ClutterMatrix *matrix,
float factor);
gboolean _clutter_util_matrix_decompose (const ClutterMatrix *src,
graphene_point3d_t *scale_p,
float shear_p[3],
graphene_point3d_t *rotate_p,
graphene_point3d_t *translate_p,
ClutterVertex4 *perspective_p);
CLUTTER_EXPORT
PangoDirection _clutter_pango_unichar_direction (gunichar ch);
PangoDirection _clutter_pango_find_base_dir (const gchar *text,
gint length);
typedef struct _ClutterPlane
{
graphene_vec3_t v0;
graphene_vec3_t n;
} ClutterPlane;
typedef enum _ClutterCullResult
{
CLUTTER_CULL_RESULT_UNKNOWN,
CLUTTER_CULL_RESULT_IN,
CLUTTER_CULL_RESULT_OUT,
CLUTTER_CULL_RESULT_PARTIAL
} ClutterCullResult;
gboolean _clutter_has_progress_function (GType gtype);
gboolean _clutter_run_progress_function (GType gtype,
const GValue *initial,
const GValue *final,
gdouble progress,
GValue *retval);
void clutter_timeline_cancel_delay (ClutterTimeline *timeline);
G_END_DECLS
#endif /* __CLUTTER_PRIVATE_H__ */
muffin-6.4.1/clutter/clutter/clutter-transition.c 0000664 0001750 0001750 00000047540 14723361714 021136 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2012 Intel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author: Emmanuele Bassi
*/
/**
* SECTION:clutter-transition
* @Title: ClutterTransition
* @Short_Description: Transition between two values
*
* #ClutterTransition is an abstract subclass of #ClutterTimeline that
* computes the interpolation between two values, stored by a #ClutterInterval.
*/
#include "clutter-build-config.h"
#include "clutter-transition.h"
#include "clutter-animatable.h"
#include "clutter-debug.h"
#include "clutter-interval.h"
#include "clutter-private.h"
#include "clutter-timeline.h"
#include
struct _ClutterTransitionPrivate
{
ClutterInterval *interval;
ClutterAnimatable *animatable;
guint remove_on_complete : 1;
};
enum
{
PROP_0,
PROP_INTERVAL,
PROP_ANIMATABLE,
PROP_REMOVE_ON_COMPLETE,
PROP_LAST
};
static GParamSpec *obj_props[PROP_LAST] = { NULL, };
static GQuark quark_animatable_set = 0;
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (ClutterTransition, clutter_transition, CLUTTER_TYPE_TIMELINE)
static void
clutter_transition_attach (ClutterTransition *transition,
ClutterAnimatable *animatable)
{
CLUTTER_TRANSITION_GET_CLASS (transition)->attached (transition, animatable);
}
static void
clutter_transition_detach (ClutterTransition *transition,
ClutterAnimatable *animatable)
{
CLUTTER_TRANSITION_GET_CLASS (transition)->detached (transition, animatable);
}
static void
clutter_transition_real_compute_value (ClutterTransition *transition,
ClutterAnimatable *animatable,
ClutterInterval *interval,
gdouble progress)
{
}
static void
clutter_transition_real_attached (ClutterTransition *transition,
ClutterAnimatable *animatable)
{
}
static void
clutter_transition_real_detached (ClutterTransition *transition,
ClutterAnimatable *animatable)
{
}
static void
clutter_transition_new_frame (ClutterTimeline *timeline,
gint elapsed G_GNUC_UNUSED)
{
ClutterTransition *transition = CLUTTER_TRANSITION (timeline);
ClutterTransitionPrivate *priv = transition->priv;
gdouble progress;
if (priv->interval == NULL ||
priv->animatable == NULL)
return;
progress = clutter_timeline_get_progress (timeline);
CLUTTER_TRANSITION_GET_CLASS (timeline)->compute_value (transition,
priv->animatable,
priv->interval,
progress);
}
static void
clutter_transition_stopped (ClutterTimeline *timeline,
gboolean is_finished)
{
ClutterTransitionPrivate *priv = CLUTTER_TRANSITION (timeline)->priv;
if (is_finished &&
priv->animatable != NULL &&
priv->remove_on_complete)
{
clutter_transition_detach (CLUTTER_TRANSITION (timeline),
priv->animatable);
g_clear_object (&priv->animatable);
}
}
static void
clutter_transition_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterTransition *transition = CLUTTER_TRANSITION (gobject);
switch (prop_id)
{
case PROP_INTERVAL:
clutter_transition_set_interval (transition, g_value_get_object (value));
break;
case PROP_ANIMATABLE:
clutter_transition_set_animatable (transition, g_value_get_object (value));
break;
case PROP_REMOVE_ON_COMPLETE:
clutter_transition_set_remove_on_complete (transition, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_transition_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterTransitionPrivate *priv = CLUTTER_TRANSITION (gobject)->priv;
switch (prop_id)
{
case PROP_INTERVAL:
g_value_set_object (value, priv->interval);
break;
case PROP_ANIMATABLE:
g_value_set_object (value, priv->animatable);
break;
case PROP_REMOVE_ON_COMPLETE:
g_value_set_boolean (value, priv->remove_on_complete);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_transition_dispose (GObject *gobject)
{
ClutterTransitionPrivate *priv = CLUTTER_TRANSITION (gobject)->priv;
if (priv->animatable != NULL)
clutter_transition_detach (CLUTTER_TRANSITION (gobject),
priv->animatable);
g_clear_object (&priv->interval);
g_clear_object (&priv->animatable);
G_OBJECT_CLASS (clutter_transition_parent_class)->dispose (gobject);
}
static void
clutter_transition_class_init (ClutterTransitionClass *klass)
{
ClutterTimelineClass *timeline_class = CLUTTER_TIMELINE_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
quark_animatable_set =
g_quark_from_static_string ("-clutter-transition-animatable-set");
klass->compute_value = clutter_transition_real_compute_value;
klass->attached = clutter_transition_real_attached;
klass->detached = clutter_transition_real_detached;
timeline_class->new_frame = clutter_transition_new_frame;
timeline_class->stopped = clutter_transition_stopped;
gobject_class->set_property = clutter_transition_set_property;
gobject_class->get_property = clutter_transition_get_property;
gobject_class->dispose = clutter_transition_dispose;
/**
* ClutterTransition:interval:
*
* The #ClutterInterval used to describe the initial and final states
* of the transition.
*
* Since: 1.10
*/
obj_props[PROP_INTERVAL] =
g_param_spec_object ("interval",
P_("Interval"),
P_("The interval of values to transition"),
CLUTTER_TYPE_INTERVAL,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
/**
* ClutterTransition:animatable:
*
* The #ClutterAnimatable instance currently being animated.
*
* Since: 1.10
*/
obj_props[PROP_ANIMATABLE] =
g_param_spec_object ("animatable",
P_("Animatable"),
P_("The animatable object"),
CLUTTER_TYPE_ANIMATABLE,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS);
/**
* ClutterTransition:remove-on-complete:
*
* Whether the #ClutterTransition should be automatically detached
* from the #ClutterTransition:animatable instance whenever the
* #ClutterTimeline::stopped signal is emitted.
*
* The #ClutterTransition:remove-on-complete property takes into
* account the value of the #ClutterTimeline:repeat-count property,
* and it only detaches the transition if the transition is not
* repeating.
*
* Since: 1.10
*/
obj_props[PROP_REMOVE_ON_COMPLETE] =
g_param_spec_boolean ("remove-on-complete",
P_("Remove on Complete"),
P_("Detach the transition when completed"),
FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
g_object_class_install_properties (gobject_class, PROP_LAST, obj_props);
}
static void
clutter_transition_init (ClutterTransition *self)
{
self->priv = clutter_transition_get_instance_private (self);
}
/**
* clutter_transition_set_interval:
* @transition: a #ClutterTransition
* @interval: (allow-none): a #ClutterInterval, or %NULL
*
* Sets the #ClutterTransition:interval property using @interval.
*
* The @transition will acquire a reference on the @interval, sinking
* the floating flag on it if necessary.
*
* Since: 1.10
*/
void
clutter_transition_set_interval (ClutterTransition *transition,
ClutterInterval *interval)
{
ClutterTransitionPrivate *priv;
g_return_if_fail (CLUTTER_IS_TRANSITION (transition));
g_return_if_fail (interval == NULL || CLUTTER_IS_INTERVAL (interval));
priv = transition->priv;
if (priv->interval == interval)
return;
g_clear_object (&priv->interval);
if (interval != NULL)
priv->interval = g_object_ref_sink (interval);
g_object_notify_by_pspec (G_OBJECT (transition), obj_props[PROP_INTERVAL]);
}
/**
* clutter_transition_get_interval:
* @transition: a #ClutterTransition
*
* Retrieves the interval set using clutter_transition_set_interval()
*
* Return value: (transfer none): a #ClutterInterval, or %NULL; the returned
* interval is owned by the #ClutterTransition and it should not be freed
* directly
*
* Since: 1.10
*/
ClutterInterval *
clutter_transition_get_interval (ClutterTransition *transition)
{
g_return_val_if_fail (CLUTTER_IS_TRANSITION (transition), NULL);
return transition->priv->interval;
}
/**
* clutter_transition_set_animatable:
* @transition: a #ClutterTransition
* @animatable: (allow-none): a #ClutterAnimatable, or %NULL
*
* Sets the #ClutterTransition:animatable property.
*
* The @transition will acquire a reference to the @animatable instance,
* and will call the #ClutterTransitionClass.attached() virtual function.
*
* If an existing #ClutterAnimatable is attached to @transition, the
* reference will be released, and the #ClutterTransitionClass.detached()
* virtual function will be called.
*
* Since: 1.10
*/
void
clutter_transition_set_animatable (ClutterTransition *transition,
ClutterAnimatable *animatable)
{
ClutterTransitionPrivate *priv;
g_return_if_fail (CLUTTER_IS_TRANSITION (transition));
g_return_if_fail (animatable == NULL || CLUTTER_IS_ANIMATABLE (animatable));
priv = transition->priv;
if (priv->animatable == animatable)
return;
if (priv->animatable != NULL)
clutter_transition_detach (transition, priv->animatable);
g_clear_object (&priv->animatable);
if (animatable != NULL)
{
priv->animatable = g_object_ref (animatable);
clutter_transition_attach (transition, priv->animatable);
}
}
/**
* clutter_transition_get_animatable:
* @transition: a #ClutterTransition
*
* Retrieves the #ClutterAnimatable set using clutter_transition_set_animatable().
*
* Return value: (transfer none): a #ClutterAnimatable, or %NULL; the returned
* animatable is owned by the #ClutterTransition, and it should not be freed
* directly.
*
* Since: 1.10
*/
ClutterAnimatable *
clutter_transition_get_animatable (ClutterTransition *transition)
{
g_return_val_if_fail (CLUTTER_IS_TRANSITION (transition), NULL);
return transition->priv->animatable;
}
/**
* clutter_transition_set_remove_on_complete:
* @transition: a #ClutterTransition
* @remove_complete: whether to detach @transition when complete
*
* Sets whether @transition should be detached from the #ClutterAnimatable
* set using clutter_transition_set_animatable() when the
* #ClutterTimeline::completed signal is emitted.
*
* Since: 1.10
*/
void
clutter_transition_set_remove_on_complete (ClutterTransition *transition,
gboolean remove_complete)
{
g_return_if_fail (CLUTTER_IS_TRANSITION (transition));
remove_complete = !!remove_complete;
if (transition->priv->remove_on_complete == remove_complete)
return;
transition->priv->remove_on_complete = remove_complete;
g_object_notify_by_pspec (G_OBJECT (transition),
obj_props[PROP_REMOVE_ON_COMPLETE]);
}
/**
* clutter_transition_get_remove_on_complete:
* @transition: a #ClutterTransition
*
* Retrieves the value of the #ClutterTransition:remove-on-complete property.
*
* Return value: %TRUE if the @transition should be detached when complete,
* and %FALSE otherwise
*
* Since: 1.10
*/
gboolean
clutter_transition_get_remove_on_complete (ClutterTransition *transition)
{
g_return_val_if_fail (CLUTTER_IS_TRANSITION (transition), FALSE);
return transition->priv->remove_on_complete;
}
typedef void (* IntervalSetFunc) (ClutterInterval *interval,
const GValue *value);
static inline void
clutter_transition_set_value (ClutterTransition *transition,
IntervalSetFunc interval_set_func,
const GValue *value)
{
ClutterTransitionPrivate *priv = transition->priv;
GType interval_type;
if (priv->interval == NULL)
{
priv->interval = clutter_interval_new_with_values (G_VALUE_TYPE (value),
NULL,
NULL);
g_object_ref_sink (priv->interval);
}
interval_type = clutter_interval_get_value_type (priv->interval);
if (!g_type_is_a (G_VALUE_TYPE (value), interval_type))
{
if (g_value_type_compatible (G_VALUE_TYPE (value), interval_type))
{
interval_set_func (priv->interval, value);
return;
}
if (g_value_type_transformable (G_VALUE_TYPE (value), interval_type))
{
GValue transform = G_VALUE_INIT;
g_value_init (&transform, interval_type);
if (g_value_transform (value, &transform))
interval_set_func (priv->interval, &transform);
else
{
g_warning ("%s: Unable to convert a value of type '%s' into "
"the value type '%s' of the interval used by the "
"transition.",
G_STRLOC,
g_type_name (G_VALUE_TYPE (value)),
g_type_name (interval_type));
}
g_value_unset (&transform);
}
}
else
interval_set_func (priv->interval, value);
}
/**
* clutter_transition_set_from_value: (rename-to clutter_transition_set_from)
* @transition: a #ClutterTransition
* @value: a #GValue with the initial value of the transition
*
* Sets the initial value of the transition.
*
* This is a convenience function that will either create the
* #ClutterInterval used by @transition, or will update it if
* the #ClutterTransition:interval is already set.
*
* This function will copy the contents of @value, so it is
* safe to call g_value_unset() after it returns.
*
* If @transition already has a #ClutterTransition:interval set,
* then @value must hold the same type, or a transformable type,
* as the interval's #ClutterInterval:value-type property.
*
* This function is meant to be used by language bindings.
*
* Since: 1.12
*/
void
clutter_transition_set_from_value (ClutterTransition *transition,
const GValue *value)
{
g_return_if_fail (CLUTTER_IS_TRANSITION (transition));
g_return_if_fail (G_IS_VALUE (value));
clutter_transition_set_value (transition,
clutter_interval_set_initial_value,
value);
}
/**
* clutter_transition_set_to_value: (rename-to clutter_transition_set_to)
* @transition: a #ClutterTransition
* @value: a #GValue with the final value of the transition
*
* Sets the final value of the transition.
*
* This is a convenience function that will either create the
* #ClutterInterval used by @transition, or will update it if
* the #ClutterTransition:interval is already set.
*
* This function will copy the contents of @value, so it is
* safe to call g_value_unset() after it returns.
*
* If @transition already has a #ClutterTransition:interval set,
* then @value must hold the same type, or a transformable type,
* as the interval's #ClutterInterval:value-type property.
*
* This function is meant to be used by language bindings.
*
* Since: 1.12
*/
void
clutter_transition_set_to_value (ClutterTransition *transition,
const GValue *value)
{
g_return_if_fail (CLUTTER_IS_TRANSITION (transition));
g_return_if_fail (G_IS_VALUE (value));
clutter_transition_set_value (transition,
clutter_interval_set_final_value,
value);
}
/**
* clutter_transition_set_from: (skip)
* @transition: a #ClutterTransition
* @value_type: the type of the value to set
* @...: the initial value
*
* Sets the initial value of the transition.
*
* This is a convenience function that will either create the
* #ClutterInterval used by @transition, or will update it if
* the #ClutterTransition:interval is already set.
*
* If @transition already has a #ClutterTransition:interval set,
* then @value must hold the same type, or a transformable type,
* as the interval's #ClutterInterval:value-type property.
*
* This is a convenience function for the C API; language bindings
* should use clutter_transition_set_from_value() instead.
*
* Since: 1.12
*/
void
clutter_transition_set_from (ClutterTransition *transition,
GType value_type,
...)
{
GValue value = G_VALUE_INIT;
gchar *error = NULL;
va_list args;
g_return_if_fail (CLUTTER_IS_TRANSITION (transition));
g_return_if_fail (value_type != G_TYPE_INVALID);
va_start (args, value_type);
G_VALUE_COLLECT_INIT (&value, value_type, args, 0, &error);
va_end (args);
if (error != NULL)
{
g_warning ("%s: %s", G_STRLOC, error);
g_free (error);
return;
}
clutter_transition_set_value (transition,
clutter_interval_set_initial_value,
&value);
g_value_unset (&value);
}
/**
* clutter_transition_set_to: (skip)
* @transition: a #ClutterTransition
* @value_type: the type of the value to set
* @...: the final value
*
* Sets the final value of the transition.
*
* This is a convenience function that will either create the
* #ClutterInterval used by @transition, or will update it if
* the #ClutterTransition:interval is already set.
*
* If @transition already has a #ClutterTransition:interval set,
* then @value must hold the same type, or a transformable type,
* as the interval's #ClutterInterval:value-type property.
*
* This is a convenience function for the C API; language bindings
* should use clutter_transition_set_to_value() instead.
*
* Since: 1.12
*/
void
clutter_transition_set_to (ClutterTransition *transition,
GType value_type,
...)
{
GValue value = G_VALUE_INIT;
gchar *error = NULL;
va_list args;
g_return_if_fail (CLUTTER_IS_TRANSITION (transition));
g_return_if_fail (value_type != G_TYPE_INVALID);
va_start (args, value_type);
G_VALUE_COLLECT_INIT (&value, value_type, args, 0, &error);
va_end (args);
if (error != NULL)
{
g_warning ("%s: %s", G_STRLOC, error);
g_free (error);
return;
}
clutter_transition_set_value (transition,
clutter_interval_set_final_value,
&value);
g_value_unset (&value);
}
muffin-6.4.1/clutter/clutter/clutter-enum-types.h.in 0000664 0001750 0001750 00000001262 14723361714 021453 0 ustar fabio fabio /*** BEGIN file-header ***/
#ifndef __CLUTTER_ENUM_TYPES_H__
#define __CLUTTER_ENUM_TYPES_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
/*** END file-header ***/
/*** BEGIN file-production ***/
/* enumerations from "@basename@" */
/*** END file-production ***/
/*** BEGIN value-header ***/
CLUTTER_EXPORT GType @enum_name@_get_type (void) G_GNUC_CONST;
#define CLUTTER_TYPE_@ENUMSHORT@ (@enum_name@_get_type())
/*** END value-header ***/
/*** BEGIN file-tail ***/
G_END_DECLS
#endif /* !__CLUTTER_ENUM_TYPES_H__ */
/*** END file-tail ***/
muffin-6.4.1/clutter/clutter/clutter-rotate-action.c 0000664 0001750 0001750 00000016457 14723361714 021520 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2012 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Lionel Landwerlin
*/
/**
* SECTION:clutter-rotate-action
* @Title: ClutterRotateAction
* @Short_Description: Action to rotate an actor
*
* #ClutterRotateAction is a sub-class of #ClutterGestureAction that implements
* the logic for recognizing rotate gestures using two touch points.
*
* Since: 1.12
*/
#include "clutter-build-config.h"
#include
#include "clutter-rotate-action.h"
#include "clutter-debug.h"
#include "clutter-enum-types.h"
#include "clutter-gesture-action-private.h"
#include "clutter-marshal.h"
#include "clutter-private.h"
struct _ClutterRotateActionPrivate
{
gfloat initial_vector[2];
gdouble initial_vector_norm;
gdouble initial_rotation;
};
enum
{
ROTATE,
LAST_SIGNAL
};
static guint rotate_signals[LAST_SIGNAL] = { 0, };
G_DEFINE_TYPE_WITH_PRIVATE (ClutterRotateAction, clutter_rotate_action, CLUTTER_TYPE_GESTURE_ACTION)
static gboolean
clutter_rotate_action_real_rotate (ClutterRotateAction *action,
ClutterActor *actor,
gdouble angle)
{
clutter_actor_set_rotation_angle (actor,
CLUTTER_Z_AXIS,
action->priv->initial_rotation + angle);
return TRUE;
}
static gboolean
clutter_rotate_action_gesture_begin (ClutterGestureAction *action,
ClutterActor *actor)
{
ClutterRotateActionPrivate *priv = CLUTTER_ROTATE_ACTION (action)->priv;
gfloat p1[2], p2[2];
/* capture initial vector */
clutter_gesture_action_get_motion_coords (action, 0, &p1[0], &p1[1]);
clutter_gesture_action_get_motion_coords (action, 1, &p2[0], &p2[1]);
priv->initial_vector[0] = p2[0] - p1[0];
priv->initial_vector[1] = p2[1] - p1[1];
priv->initial_vector_norm =
sqrt (priv->initial_vector[0] * priv->initial_vector[0] +
priv->initial_vector[1] * priv->initial_vector[1]);
priv->initial_rotation = clutter_actor_get_rotation_angle (actor, CLUTTER_Z_AXIS);
return TRUE;
}
static gboolean
clutter_rotate_action_gesture_progress (ClutterGestureAction *action,
ClutterActor *actor)
{
ClutterRotateActionPrivate *priv = CLUTTER_ROTATE_ACTION (action)->priv;
gfloat p1[2], p2[2];
gfloat vector[2];
gboolean retval;
/* capture current vector */
clutter_gesture_action_get_motion_coords (action, 0, &p1[0], &p1[1]);
clutter_gesture_action_get_motion_coords (action, 1, &p2[0], &p2[1]);
vector[0] = p2[0] - p1[0];
vector[1] = p2[1] - p1[1];
if ((vector[0] == priv->initial_vector[0]) &&
(vector[1] == priv->initial_vector[1]))
{
g_signal_emit (action, rotate_signals[ROTATE], 0,
actor, (gdouble) 0.0,
&retval);
}
else
{
gfloat mult[2];
gfloat norm;
gdouble angle;
/* Computes angle between the 2 initial touch points and the
current position of the 2 touch points. */
norm = sqrt (vector[0] * vector[0] + vector[1] * vector[1]);
norm = (priv->initial_vector[0] * vector[0] +
priv->initial_vector[1] * vector[1]) / (priv->initial_vector_norm * norm);
if ((norm >= -1.0) && (norm <= 1.0))
angle = acos (norm);
else
angle = 0;
/* The angle given is comprise between 0 and 180 degrees, we
need some logic on top to get a value between 0 and 360. */
mult[0] = priv->initial_vector[0] * vector[1] -
priv->initial_vector[1] * vector[0];
mult[1] = priv->initial_vector[1] * vector[0] -
priv->initial_vector[0] * vector[1];
if (mult[0] < 0)
angle = -angle;
/* Convert radians to degrees */
angle = angle * 180.0 / G_PI;
g_signal_emit (action, rotate_signals[ROTATE], 0,
actor, angle,
&retval);
}
return TRUE;
}
static void
clutter_rotate_action_gesture_cancel (ClutterGestureAction *action,
ClutterActor *actor)
{
gboolean retval;
g_signal_emit (action, rotate_signals[ROTATE], 0,
actor, (gdouble) 0.0,
&retval);
}
static void
clutter_rotate_action_constructed (GObject *gobject)
{
ClutterGestureAction *gesture;
gesture = CLUTTER_GESTURE_ACTION (gobject);
clutter_gesture_action_set_threshold_trigger_edge (gesture, CLUTTER_GESTURE_TRIGGER_EDGE_NONE);
}
static void
clutter_rotate_action_class_init (ClutterRotateActionClass *klass)
{
ClutterGestureActionClass *gesture_class =
CLUTTER_GESTURE_ACTION_CLASS (klass);
GObjectClass *object_class =
G_OBJECT_CLASS (klass);
klass->rotate = clutter_rotate_action_real_rotate;
object_class->constructed = clutter_rotate_action_constructed;
gesture_class->gesture_begin = clutter_rotate_action_gesture_begin;
gesture_class->gesture_progress = clutter_rotate_action_gesture_progress;
gesture_class->gesture_cancel = clutter_rotate_action_gesture_cancel;
/**
* ClutterRotateAction::rotate:
* @action: the #ClutterRotateAction that emitted the signal
* @actor: the #ClutterActor attached to the @action
* @angle: the difference of angle of rotation between the initial
* rotation and the current rotation
*
* The ::rotate signal is emitted when a rotate gesture is
* recognized on the attached actor and when the gesture is
* cancelled (in this case with an angle value of 0).
*
* Return value: %TRUE if the rotation should continue, and %FALSE if
* the rotation should be cancelled.
*
* Since: 1.12
*/
rotate_signals[ROTATE] =
g_signal_new (I_("rotate"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterRotateActionClass, rotate),
_clutter_boolean_continue_accumulator, NULL,
_clutter_marshal_BOOLEAN__OBJECT_DOUBLE,
G_TYPE_BOOLEAN, 2,
CLUTTER_TYPE_ACTOR,
G_TYPE_DOUBLE);
}
static void
clutter_rotate_action_init (ClutterRotateAction *self)
{
ClutterGestureAction *gesture;
self->priv = clutter_rotate_action_get_instance_private (self);
gesture = CLUTTER_GESTURE_ACTION (self);
clutter_gesture_action_set_n_touch_points (gesture, 2);
}
/**
* clutter_rotate_action_new:
*
* Creates a new #ClutterRotateAction instance
*
* Return value: the newly created #ClutterRotateAction
*
* Since: 1.12
*/
ClutterAction *
clutter_rotate_action_new (void)
{
return g_object_new (CLUTTER_TYPE_ROTATE_ACTION, NULL);
}
muffin-6.4.1/clutter/clutter/clutter-enums.h 0000664 0001750 0001750 00000152425 14723361714 020077 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2011 Intel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*/
#ifndef __CLUTTER_ENUMS_H__
#define __CLUTTER_ENUMS_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
/**
* ClutterGravity:
* @CLUTTER_GRAVITY_NONE: Do not apply any gravity
* @CLUTTER_GRAVITY_NORTH: Scale from topmost downwards
* @CLUTTER_GRAVITY_NORTH_EAST: Scale from the top right corner
* @CLUTTER_GRAVITY_EAST: Scale from the right side
* @CLUTTER_GRAVITY_SOUTH_EAST: Scale from the bottom right corner
* @CLUTTER_GRAVITY_SOUTH: Scale from the bottom upwards
* @CLUTTER_GRAVITY_SOUTH_WEST: Scale from the bottom left corner
* @CLUTTER_GRAVITY_WEST: Scale from the left side
* @CLUTTER_GRAVITY_NORTH_WEST: Scale from the top left corner
* @CLUTTER_GRAVITY_CENTER: Scale from the center.
*
* Gravity of the scaling operations. When a gravity different than
* %CLUTTER_GRAVITY_NONE is used, an actor is scaled keeping the position
* of the specified portion at the same coordinates.
*
* Since: 0.2
*
* Deprecated: 1.22: Use the normalized #ClutterActor pivot point instead
*/
typedef enum /*< prefix=CLUTTER_GRAVITY >*/
{
CLUTTER_GRAVITY_NONE = 0,
CLUTTER_GRAVITY_NORTH,
CLUTTER_GRAVITY_NORTH_EAST,
CLUTTER_GRAVITY_EAST,
CLUTTER_GRAVITY_SOUTH_EAST,
CLUTTER_GRAVITY_SOUTH,
CLUTTER_GRAVITY_SOUTH_WEST,
CLUTTER_GRAVITY_WEST,
CLUTTER_GRAVITY_NORTH_WEST,
CLUTTER_GRAVITY_CENTER
} ClutterGravity;
/**
* ClutterRotateAxis:
* @CLUTTER_X_AXIS: Rotate around the X axis
* @CLUTTER_Y_AXIS: Rotate around the Y axis
* @CLUTTER_Z_AXIS: Rotate around the Z axis
*
* Axis of a rotation.
*
* Since: 0.4
*/
typedef enum /*< prefix=CLUTTER >*/
{
CLUTTER_X_AXIS,
CLUTTER_Y_AXIS,
CLUTTER_Z_AXIS
} ClutterRotateAxis;
/**
* ClutterRotateDirection:
* @CLUTTER_ROTATE_CW: Clockwise rotation
* @CLUTTER_ROTATE_CCW: Counter-clockwise rotation
*
* Direction of a rotation.
*
* Since: 0.4
*
* Deprecated: 1.22
*/
typedef enum /*< prefix=CLUTTER_ROTATE >*/
{
CLUTTER_ROTATE_CW,
CLUTTER_ROTATE_CCW
} ClutterRotateDirection;
/**
* ClutterRequestMode:
* @CLUTTER_REQUEST_HEIGHT_FOR_WIDTH: Height for width requests
* @CLUTTER_REQUEST_WIDTH_FOR_HEIGHT: Width for height requests
* @CLUTTER_REQUEST_CONTENT_SIZE: Use the preferred size of the
* #ClutterContent, if it has any (available since 1.22)
*
* Specifies the type of requests for a #ClutterActor.
*
* Since: 0.8
*/
typedef enum /*< prefix=CLUTTER_REQUEST >*/
{
CLUTTER_REQUEST_HEIGHT_FOR_WIDTH,
CLUTTER_REQUEST_WIDTH_FOR_HEIGHT,
CLUTTER_REQUEST_CONTENT_SIZE
} ClutterRequestMode;
/**
* ClutterAnimationMode:
* @CLUTTER_CUSTOM_MODE: custom progress function
* @CLUTTER_LINEAR: linear tweening
* @CLUTTER_EASE_IN_QUAD: quadratic tweening
* @CLUTTER_EASE_OUT_QUAD: quadratic tweening, inverse of
* %CLUTTER_EASE_IN_QUAD
* @CLUTTER_EASE_IN_OUT_QUAD: quadratic tweening, combininig
* %CLUTTER_EASE_IN_QUAD and %CLUTTER_EASE_OUT_QUAD
* @CLUTTER_EASE_IN_CUBIC: cubic tweening
* @CLUTTER_EASE_OUT_CUBIC: cubic tweening, invers of
* %CLUTTER_EASE_IN_CUBIC
* @CLUTTER_EASE_IN_OUT_CUBIC: cubic tweening, combining
* %CLUTTER_EASE_IN_CUBIC and %CLUTTER_EASE_OUT_CUBIC
* @CLUTTER_EASE_IN_QUART: quartic tweening
* @CLUTTER_EASE_OUT_QUART: quartic tweening, inverse of
* %CLUTTER_EASE_IN_QUART
* @CLUTTER_EASE_IN_OUT_QUART: quartic tweening, combining
* %CLUTTER_EASE_IN_QUART and %CLUTTER_EASE_OUT_QUART
* @CLUTTER_EASE_IN_QUINT: quintic tweening
* @CLUTTER_EASE_OUT_QUINT: quintic tweening, inverse of
* %CLUTTER_EASE_IN_QUINT
* @CLUTTER_EASE_IN_OUT_QUINT: fifth power tweening, combining
* %CLUTTER_EASE_IN_QUINT and %CLUTTER_EASE_OUT_QUINT
* @CLUTTER_EASE_IN_SINE: sinusoidal tweening
* @CLUTTER_EASE_OUT_SINE: sinusoidal tweening, inverse of
* %CLUTTER_EASE_IN_SINE
* @CLUTTER_EASE_IN_OUT_SINE: sine wave tweening, combining
* %CLUTTER_EASE_IN_SINE and %CLUTTER_EASE_OUT_SINE
* @CLUTTER_EASE_IN_EXPO: exponential tweening
* @CLUTTER_EASE_OUT_EXPO: exponential tweening, inverse of
* %CLUTTER_EASE_IN_EXPO
* @CLUTTER_EASE_IN_OUT_EXPO: exponential tweening, combining
* %CLUTTER_EASE_IN_EXPO and %CLUTTER_EASE_OUT_EXPO
* @CLUTTER_EASE_IN_CIRC: circular tweening
* @CLUTTER_EASE_OUT_CIRC: circular tweening, inverse of
* %CLUTTER_EASE_IN_CIRC
* @CLUTTER_EASE_IN_OUT_CIRC: circular tweening, combining
* %CLUTTER_EASE_IN_CIRC and %CLUTTER_EASE_OUT_CIRC
* @CLUTTER_EASE_IN_ELASTIC: elastic tweening, with offshoot on start
* @CLUTTER_EASE_OUT_ELASTIC: elastic tweening, with offshoot on end
* @CLUTTER_EASE_IN_OUT_ELASTIC: elastic tweening with offshoot on both ends
* @CLUTTER_EASE_IN_BACK: overshooting cubic tweening, with
* backtracking on start
* @CLUTTER_EASE_OUT_BACK: overshooting cubic tweening, with
* backtracking on end
* @CLUTTER_EASE_IN_OUT_BACK: overshooting cubic tweening, with
* backtracking on both ends
* @CLUTTER_EASE_IN_BOUNCE: exponentially decaying parabolic (bounce)
* tweening, with bounce on start
* @CLUTTER_EASE_OUT_BOUNCE: exponentially decaying parabolic (bounce)
* tweening, with bounce on end
* @CLUTTER_EASE_IN_OUT_BOUNCE: exponentially decaying parabolic (bounce)
* tweening, with bounce on both ends
* @CLUTTER_STEPS: parametrized step function; see clutter_timeline_set_step_progress()
* for further details. (Since 1.12)
* @CLUTTER_STEP_START: equivalent to %CLUTTER_STEPS with a number of steps
* equal to 1, and a step mode of %CLUTTER_STEP_MODE_START. (Since 1.12)
* @CLUTTER_STEP_END: equivalent to %CLUTTER_STEPS with a number of steps
* equal to 1, and a step mode of %CLUTTER_STEP_MODE_END. (Since 1.12)
* @CLUTTER_CUBIC_BEZIER: cubic bezier between (0, 0) and (1, 1) with two
* control points; see clutter_timeline_set_cubic_bezier_progress(). (Since 1.12)
* @CLUTTER_EASE: equivalent to %CLUTTER_CUBIC_BEZIER with control points
* in (0.25, 0.1) and (0.25, 1.0). (Since 1.12)
* @CLUTTER_EASE_IN: equivalent to %CLUTTER_CUBIC_BEZIER with control points
* in (0.42, 0) and (1.0, 1.0). (Since 1.12)
* @CLUTTER_EASE_OUT: equivalent to %CLUTTER_CUBIC_BEZIER with control points
* in (0, 0) and (0.58, 1.0). (Since 1.12)
* @CLUTTER_EASE_IN_OUT: equivalent to %CLUTTER_CUBIC_BEZIER with control points
* in (0.42, 0) and (0.58, 1.0). (Since 1.12)
* @CLUTTER_ANIMATION_LAST: last animation mode, used as a guard for
* registered global alpha functions
*
* The animation modes used by #ClutterAlpha and #ClutterAnimation. This
* enumeration can be expanded in later versions of Clutter.
*
*
* Easing modes provided by Clutter
* ![]()
*
*
* Every global alpha function registered using clutter_alpha_register_func()
* or clutter_alpha_register_closure() will have a logical id greater than
* %CLUTTER_ANIMATION_LAST.
*
* Since: 1.0
*/
typedef enum
{
CLUTTER_CUSTOM_MODE = 0,
/* linear */
CLUTTER_LINEAR,
/* quadratic */
CLUTTER_EASE_IN_QUAD,
CLUTTER_EASE_OUT_QUAD,
CLUTTER_EASE_IN_OUT_QUAD,
/* cubic */
CLUTTER_EASE_IN_CUBIC,
CLUTTER_EASE_OUT_CUBIC,
CLUTTER_EASE_IN_OUT_CUBIC,
/* quartic */
CLUTTER_EASE_IN_QUART,
CLUTTER_EASE_OUT_QUART,
CLUTTER_EASE_IN_OUT_QUART,
/* quintic */
CLUTTER_EASE_IN_QUINT,
CLUTTER_EASE_OUT_QUINT,
CLUTTER_EASE_IN_OUT_QUINT,
/* sinusoidal */
CLUTTER_EASE_IN_SINE,
CLUTTER_EASE_OUT_SINE,
CLUTTER_EASE_IN_OUT_SINE,
/* exponential */
CLUTTER_EASE_IN_EXPO,
CLUTTER_EASE_OUT_EXPO,
CLUTTER_EASE_IN_OUT_EXPO,
/* circular */
CLUTTER_EASE_IN_CIRC,
CLUTTER_EASE_OUT_CIRC,
CLUTTER_EASE_IN_OUT_CIRC,
/* elastic */
CLUTTER_EASE_IN_ELASTIC,
CLUTTER_EASE_OUT_ELASTIC,
CLUTTER_EASE_IN_OUT_ELASTIC,
/* overshooting cubic */
CLUTTER_EASE_IN_BACK,
CLUTTER_EASE_OUT_BACK,
CLUTTER_EASE_IN_OUT_BACK,
/* exponentially decaying parabolic */
CLUTTER_EASE_IN_BOUNCE,
CLUTTER_EASE_OUT_BOUNCE,
CLUTTER_EASE_IN_OUT_BOUNCE,
/* step functions (see css3-transitions) */
CLUTTER_STEPS,
CLUTTER_STEP_START, /* steps(1, start) */
CLUTTER_STEP_END, /* steps(1, end) */
/* cubic bezier (see css3-transitions) */
CLUTTER_CUBIC_BEZIER,
CLUTTER_EASE,
CLUTTER_EASE_IN,
CLUTTER_EASE_OUT,
CLUTTER_EASE_IN_OUT,
/* guard, before registered alpha functions */
CLUTTER_ANIMATION_LAST
} ClutterAnimationMode;
/**
* ClutterTextDirection:
* @CLUTTER_TEXT_DIRECTION_DEFAULT: Use the default setting, as returned
* by clutter_get_default_text_direction()
* @CLUTTER_TEXT_DIRECTION_LTR: Use left-to-right text direction
* @CLUTTER_TEXT_DIRECTION_RTL: Use right-to-left text direction
*
* The text direction to be used by #ClutterActors
*
* Since: 1.2
*/
typedef enum
{
CLUTTER_TEXT_DIRECTION_DEFAULT,
CLUTTER_TEXT_DIRECTION_LTR,
CLUTTER_TEXT_DIRECTION_RTL
} ClutterTextDirection;
/**
* ClutterShaderType:
* @CLUTTER_VERTEX_SHADER: a vertex shader
* @CLUTTER_FRAGMENT_SHADER: a fragment shader
*
* The type of GLSL shader program
*
* Since: 1.4
*/
typedef enum
{
CLUTTER_VERTEX_SHADER,
CLUTTER_FRAGMENT_SHADER
} ClutterShaderType;
/**
* ClutterModifierType:
* @CLUTTER_SHIFT_MASK: Mask applied by the Shift key
* @CLUTTER_LOCK_MASK: Mask applied by the Caps Lock key
* @CLUTTER_CONTROL_MASK: Mask applied by the Control key
* @CLUTTER_MOD1_MASK: Mask applied by the first Mod key
* @CLUTTER_MOD2_MASK: Mask applied by the second Mod key
* @CLUTTER_MOD3_MASK: Mask applied by the third Mod key
* @CLUTTER_MOD4_MASK: Mask applied by the fourth Mod key
* @CLUTTER_MOD5_MASK: Mask applied by the fifth Mod key
* @CLUTTER_BUTTON1_MASK: Mask applied by the first pointer button
* @CLUTTER_BUTTON2_MASK: Mask applied by the second pointer button
* @CLUTTER_BUTTON3_MASK: Mask applied by the third pointer button
* @CLUTTER_BUTTON4_MASK: Mask applied by the fourth pointer button
* @CLUTTER_BUTTON5_MASK: Mask applied by the fifth pointer button
* @CLUTTER_SUPER_MASK: Mask applied by the Super key
* @CLUTTER_HYPER_MASK: Mask applied by the Hyper key
* @CLUTTER_META_MASK: Mask applied by the Meta key
* @CLUTTER_RELEASE_MASK: Mask applied during release
* @CLUTTER_MODIFIER_MASK: A mask covering all modifier types
*
* Masks applied to a #ClutterEvent by modifiers.
*
* Note that Clutter may add internal values to events which include
* reserved values such as %CLUTTER_MODIFIER_RESERVED_13_MASK. Your code
* should preserve and ignore them. You can use %CLUTTER_MODIFIER_MASK to
* remove all reserved values.
*
* Since: 0.4
*/
typedef enum
{
CLUTTER_SHIFT_MASK = 1 << 0,
CLUTTER_LOCK_MASK = 1 << 1,
CLUTTER_CONTROL_MASK = 1 << 2,
CLUTTER_MOD1_MASK = 1 << 3,
CLUTTER_MOD2_MASK = 1 << 4,
CLUTTER_MOD3_MASK = 1 << 5,
CLUTTER_MOD4_MASK = 1 << 6,
CLUTTER_MOD5_MASK = 1 << 7,
CLUTTER_BUTTON1_MASK = 1 << 8,
CLUTTER_BUTTON2_MASK = 1 << 9,
CLUTTER_BUTTON3_MASK = 1 << 10,
CLUTTER_BUTTON4_MASK = 1 << 11,
CLUTTER_BUTTON5_MASK = 1 << 12,
#ifndef __GTK_DOC_IGNORE__
CLUTTER_MODIFIER_RESERVED_13_MASK = 1 << 13,
CLUTTER_MODIFIER_RESERVED_14_MASK = 1 << 14,
CLUTTER_MODIFIER_RESERVED_15_MASK = 1 << 15,
CLUTTER_MODIFIER_RESERVED_16_MASK = 1 << 16,
CLUTTER_MODIFIER_RESERVED_17_MASK = 1 << 17,
CLUTTER_MODIFIER_RESERVED_18_MASK = 1 << 18,
CLUTTER_MODIFIER_RESERVED_19_MASK = 1 << 19,
CLUTTER_MODIFIER_RESERVED_20_MASK = 1 << 20,
CLUTTER_MODIFIER_RESERVED_21_MASK = 1 << 21,
CLUTTER_MODIFIER_RESERVED_22_MASK = 1 << 22,
CLUTTER_MODIFIER_RESERVED_23_MASK = 1 << 23,
CLUTTER_MODIFIER_RESERVED_24_MASK = 1 << 24,
CLUTTER_MODIFIER_RESERVED_25_MASK = 1 << 25,
#endif
CLUTTER_SUPER_MASK = 1 << 26,
CLUTTER_HYPER_MASK = 1 << 27,
CLUTTER_META_MASK = 1 << 28,
#ifndef __GTK_DOC_IGNORE__
CLUTTER_MODIFIER_RESERVED_29_MASK = 1 << 29,
#endif
CLUTTER_RELEASE_MASK = 1 << 30,
/* Combination of CLUTTER_SHIFT_MASK..CLUTTER_BUTTON5_MASK + CLUTTER_SUPER_MASK
+ CLUTTER_HYPER_MASK + CLUTTER_META_MASK + CLUTTER_RELEASE_MASK */
CLUTTER_MODIFIER_MASK = 0x5c001fff
} ClutterModifierType;
/**
* ClutterKeyboardA11yFlags:
* @CLUTTER_A11Y_KEYBOARD_ENABLED:
* @CLUTTER_A11Y_TIMEOUT_ENABLED:
* @CLUTTER_A11Y_MOUSE_KEYS_ENABLED:
* @CLUTTER_A11Y_SLOW_KEYS_ENABLED:
* @CLUTTER_A11Y_SLOW_KEYS_BEEP_PRESS:
* @CLUTTER_A11Y_SLOW_KEYS_BEEP_ACCEPT:
* @CLUTTER_A11Y_SLOW_KEYS_BEEP_REJECT:
* @CLUTTER_A11Y_BOUNCE_KEYS_ENABLED:
* @CLUTTER_A11Y_BOUNCE_KEYS_BEEP_REJECT:
* @CLUTTER_A11Y_TOGGLE_KEYS_ENABLED:
* @CLUTTER_A11Y_STICKY_KEYS_ENABLED:
* @CLUTTER_A11Y_STICKY_KEYS_TWO_KEY_OFF:
* @CLUTTER_A11Y_STICKY_KEYS_BEEP:
* @CLUTTER_A11Y_FEATURE_STATE_CHANGE_BEEP:
*
* Keyboard accessibility features applied to a ClutterInputDevice keyboard.
*
*/
typedef enum
{
CLUTTER_A11Y_KEYBOARD_ENABLED = 1 << 0,
CLUTTER_A11Y_TIMEOUT_ENABLED = 1 << 1,
CLUTTER_A11Y_MOUSE_KEYS_ENABLED = 1 << 2,
CLUTTER_A11Y_SLOW_KEYS_ENABLED = 1 << 3,
CLUTTER_A11Y_SLOW_KEYS_BEEP_PRESS = 1 << 4,
CLUTTER_A11Y_SLOW_KEYS_BEEP_ACCEPT = 1 << 5,
CLUTTER_A11Y_SLOW_KEYS_BEEP_REJECT = 1 << 6,
CLUTTER_A11Y_BOUNCE_KEYS_ENABLED = 1 << 7,
CLUTTER_A11Y_BOUNCE_KEYS_BEEP_REJECT = 1 << 8,
CLUTTER_A11Y_TOGGLE_KEYS_ENABLED = 1 << 9,
CLUTTER_A11Y_STICKY_KEYS_ENABLED = 1 << 10,
CLUTTER_A11Y_STICKY_KEYS_TWO_KEY_OFF = 1 << 11,
CLUTTER_A11Y_STICKY_KEYS_BEEP = 1 << 12,
CLUTTER_A11Y_FEATURE_STATE_CHANGE_BEEP = 1 << 13,
} ClutterKeyboardA11yFlags;
/**
* ClutterPointerA11yFlags:
* @CLUTTER_A11Y_POINTER_ENABLED:
* @CLUTTER_A11Y_SECONDARY_CLICK_ENABLED:
* @CLUTTER_A11Y_DWELL_ENABLED:
*
* Pointer accessibility features applied to a ClutterInputDevice pointer.
*
*/
typedef enum {
CLUTTER_A11Y_SECONDARY_CLICK_ENABLED = 1 << 0,
CLUTTER_A11Y_DWELL_ENABLED = 1 << 1,
} ClutterPointerA11yFlags;
/**
* ClutterPointerA11yDwellClickType:
* @CLUTTER_A11Y_DWELL_CLICK_TYPE_NONE: Internal use only
* @CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY:
* @CLUTTER_A11Y_DWELL_CLICK_TYPE_SECONDARY:
* @CLUTTER_A11Y_DWELL_CLICK_TYPE_MIDDLE:
* @CLUTTER_A11Y_DWELL_CLICK_TYPE_DOUBLE:
* @CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG:
*
* Dwell click types.
*
*/
typedef enum {
CLUTTER_A11Y_DWELL_CLICK_TYPE_NONE,
CLUTTER_A11Y_DWELL_CLICK_TYPE_PRIMARY,
CLUTTER_A11Y_DWELL_CLICK_TYPE_SECONDARY,
CLUTTER_A11Y_DWELL_CLICK_TYPE_MIDDLE,
CLUTTER_A11Y_DWELL_CLICK_TYPE_DOUBLE,
CLUTTER_A11Y_DWELL_CLICK_TYPE_DRAG,
} ClutterPointerA11yDwellClickType;
/**
* ClutterPointerA11yDwellDirection:
* @CLUTTER_A11Y_DWELL_DIRECTION_NONE:
* @CLUTTER_A11Y_DWELL_DIRECTION_LEFT:
* @CLUTTER_A11Y_DWELL_DIRECTION_RIGHT:
* @CLUTTER_A11Y_DWELL_DIRECTION_UP:
* @CLUTTER_A11Y_DWELL_DIRECTION_DOWN:
*
* Dwell gesture directions.
*
*/
typedef enum {
CLUTTER_A11Y_DWELL_DIRECTION_NONE,
CLUTTER_A11Y_DWELL_DIRECTION_LEFT,
CLUTTER_A11Y_DWELL_DIRECTION_RIGHT,
CLUTTER_A11Y_DWELL_DIRECTION_UP,
CLUTTER_A11Y_DWELL_DIRECTION_DOWN,
} ClutterPointerA11yDwellDirection;
/**
* ClutterPointerA11yDwellMode:
* @CLUTTER_A11Y_DWELL_MODE_WINDOW:
* @CLUTTER_A11Y_DWELL_MODE_GESTURE:
*
* Dwell mode.
*
*/
typedef enum {
CLUTTER_A11Y_DWELL_MODE_WINDOW,
CLUTTER_A11Y_DWELL_MODE_GESTURE,
} ClutterPointerA11yDwellMode;
/**
* ClutterPointerA11yTimeoutType:
* @CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK:
* @CLUTTER_A11Y_TIMEOUT_TYPE_DWELL:
* @CLUTTER_A11Y_TIMEOUT_TYPE_GESTURE:
*
* Pointer accessibility timeout type.
*
*/
typedef enum {
CLUTTER_A11Y_TIMEOUT_TYPE_SECONDARY_CLICK,
CLUTTER_A11Y_TIMEOUT_TYPE_DWELL,
CLUTTER_A11Y_TIMEOUT_TYPE_GESTURE,
} ClutterPointerA11yTimeoutType;
/**
* ClutterActorFlags:
* @CLUTTER_ACTOR_MAPPED: the actor will be painted (is visible, and inside
* a toplevel, and all parents visible)
* @CLUTTER_ACTOR_REALIZED: the resources associated to the actor have been
* allocated
* @CLUTTER_ACTOR_REACTIVE: the actor 'reacts' to mouse events emmitting event
* signals
* @CLUTTER_ACTOR_VISIBLE: the actor has been shown by the application program
* @CLUTTER_ACTOR_NO_LAYOUT: the actor provides an explicit layout management
* policy for its children; this flag will prevent Clutter from automatic
* queueing of relayout and will defer all layouting to the actor itself
*
* Flags used to signal the state of an actor.
*/
typedef enum /*< prefix=CLUTTER_ACTOR >*/
{
CLUTTER_ACTOR_MAPPED = 1 << 1,
CLUTTER_ACTOR_REALIZED = 1 << 2,
CLUTTER_ACTOR_REACTIVE = 1 << 3,
CLUTTER_ACTOR_VISIBLE = 1 << 4,
CLUTTER_ACTOR_NO_LAYOUT = 1 << 5
} ClutterActorFlags;
/**
* ClutterOffscreenRedirect:
* @CLUTTER_OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY: Only redirect
* the actor if it is semi-transparent and its has_overlaps()
* virtual returns %TRUE.
* @CLUTTER_OFFSCREEN_REDIRECT_ALWAYS: Always redirect the actor to an
* offscreen buffer even if it is fully opaque.
* @CLUTTER_OFFSCREEN_REDIRECT_ON_IDLE: Only redirect the actor if it is the
* most efficient thing to do based on its recent repaint behaviour. That
* means when its contents are changing less frequently than it's being used
* on stage.
*
* Possible flags to pass to clutter_actor_set_offscreen_redirect().
*
* Since: 1.8
*/
typedef enum /*< prefix=CLUTTER_OFFSCREEN_REDIRECT >*/
{
CLUTTER_OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY = 1 << 0,
CLUTTER_OFFSCREEN_REDIRECT_ALWAYS = 1 << 1,
CLUTTER_OFFSCREEN_REDIRECT_ON_IDLE = 1 << 2
} ClutterOffscreenRedirect;
/**
* ClutterAllocationFlags:
* @CLUTTER_ALLOCATION_NONE: No flag set
* @CLUTTER_ABSOLUTE_ORIGIN_CHANGED: Whether the absolute origin of the
* actor has changed; this implies that any ancestor of the actor has
* been moved.
* @CLUTTER_DELEGATE_LAYOUT: Whether the allocation should be delegated
* to the #ClutterLayoutManager instance stored inside the
* #ClutterActor:layout-manager property of #ClutterActor. This flag
* should only be used if you are subclassing #ClutterActor and
* overriding the #ClutterActorClass.allocate() virtual function, but
* you wish to use the default implementation of the virtual function
* inside #ClutterActor. Added in Clutter 1.10.
*
* Flags passed to the #ClutterActorClass.allocate() virtual function
* and to the clutter_actor_allocate() function.
*
* Since: 1.0
*/
typedef enum
{
CLUTTER_ALLOCATION_NONE = 0,
CLUTTER_ABSOLUTE_ORIGIN_CHANGED = 1 << 1,
CLUTTER_DELEGATE_LAYOUT = 1 << 2
} ClutterAllocationFlags;
/**
* ClutterAlignAxis:
* @CLUTTER_ALIGN_X_AXIS: Maintain the alignment on the X axis
* @CLUTTER_ALIGN_Y_AXIS: Maintain the alignment on the Y axis
* @CLUTTER_ALIGN_BOTH: Maintain the alignment on both the X and Y axis
*
* Specifies the axis on which #ClutterAlignConstraint should maintain
* the alignment.
*
* Since: 1.4
*/
typedef enum /*< prefix=CLUTTER_ALIGN >*/
{
CLUTTER_ALIGN_X_AXIS,
CLUTTER_ALIGN_Y_AXIS,
CLUTTER_ALIGN_BOTH
} ClutterAlignAxis;
/**
* ClutterInterpolation:
* @CLUTTER_INTERPOLATION_LINEAR: linear interpolation
* @CLUTTER_INTERPOLATION_CUBIC: cubic interpolation
*
* The mode of interpolation between key frames
*
* Since: 1.2
*
* Deprecated: 1.22
*/
typedef enum
{
CLUTTER_INTERPOLATION_LINEAR,
CLUTTER_INTERPOLATION_CUBIC
} ClutterInterpolation;
/**
* ClutterBinAlignment:
* @CLUTTER_BIN_ALIGNMENT_FIXED: Fixed position alignment; the
* #ClutterBinLayout will honour the fixed position provided
* by the actors themselves when allocating them
* @CLUTTER_BIN_ALIGNMENT_FILL: Fill the allocation size
* @CLUTTER_BIN_ALIGNMENT_START: Position the actors at the top
* or left side of the container, depending on the axis
* @CLUTTER_BIN_ALIGNMENT_END: Position the actors at the bottom
* or right side of the container, depending on the axis
* @CLUTTER_BIN_ALIGNMENT_CENTER: Position the actors at the
* center of the container, depending on the axis
*
* The alignment policies available on each axis for #ClutterBinLayout
*
* Since: 1.2
*
* Deprecated: 1.12: Use #ClutterActorAlign and the #ClutterActor
* API instead
*/
typedef enum
{
CLUTTER_BIN_ALIGNMENT_FIXED,
CLUTTER_BIN_ALIGNMENT_FILL,
CLUTTER_BIN_ALIGNMENT_START,
CLUTTER_BIN_ALIGNMENT_END,
CLUTTER_BIN_ALIGNMENT_CENTER
} ClutterBinAlignment;
/**
* ClutterBindCoordinate:
* @CLUTTER_BIND_X: Bind the X coordinate
* @CLUTTER_BIND_Y: Bind the Y coordinate
* @CLUTTER_BIND_WIDTH: Bind the width
* @CLUTTER_BIND_HEIGHT: Bind the height
* @CLUTTER_BIND_POSITION: Equivalent to to %CLUTTER_BIND_X and
* %CLUTTER_BIND_Y (added in Clutter 1.6)
* @CLUTTER_BIND_SIZE: Equivalent to %CLUTTER_BIND_WIDTH and
* %CLUTTER_BIND_HEIGHT (added in Clutter 1.6)
* @CLUTTER_BIND_ALL: Equivalent to %CLUTTER_BIND_POSITION and
* %CLUTTER_BIND_SIZE (added in Clutter 1.10)
*
* Specifies which property should be used in a binding
*
* Since: 1.4
*/
typedef enum /*< prefix=CLUTTER_BIND >*/
{
CLUTTER_BIND_X,
CLUTTER_BIND_Y,
CLUTTER_BIND_WIDTH,
CLUTTER_BIND_HEIGHT,
CLUTTER_BIND_POSITION,
CLUTTER_BIND_SIZE,
CLUTTER_BIND_ALL
} ClutterBindCoordinate;
/**
* ClutterEffectPaintFlags:
* @CLUTTER_EFFECT_PAINT_ACTOR_DIRTY: The actor or one of its children
* has queued a redraw before this paint. This implies that the effect
* should call clutter_actor_continue_paint() to chain to the next
* effect and can not cache any results from a previous paint.
* @CLUTTER_EFFECT_PAINT_BYPASS_EFFECT: The effect should not be used
* on this frame, but it will be asked to paint the actor still.
*
* Flags passed to the ‘paint’ or ‘pick’ method of #ClutterEffect.
*/
typedef enum /*< prefix=CLUTTER_EFFECT_PAINT >*/
{
CLUTTER_EFFECT_PAINT_ACTOR_DIRTY = (1 << 0),
CLUTTER_EFFECT_PAINT_BYPASS_EFFECT = (1 << 1)
} ClutterEffectPaintFlags;
/**
* ClutterBoxAlignment:
* @CLUTTER_BOX_ALIGNMENT_START: Align the child to the top or to
* to the left, depending on the used axis
* @CLUTTER_BOX_ALIGNMENT_CENTER: Align the child to the center
* @CLUTTER_BOX_ALIGNMENT_END: Align the child to the bottom or to
* the right, depending on the used axis
*
* The alignment policies available on each axis of the #ClutterBoxLayout
*
* Since: 1.2
*/
typedef enum
{
CLUTTER_BOX_ALIGNMENT_START,
CLUTTER_BOX_ALIGNMENT_END,
CLUTTER_BOX_ALIGNMENT_CENTER
} ClutterBoxAlignment;
/**
* ClutterLongPressState:
* @CLUTTER_LONG_PRESS_QUERY: Queries the action whether it supports
* long presses
* @CLUTTER_LONG_PRESS_ACTIVATE: Activates the action on a long press
* @CLUTTER_LONG_PRESS_CANCEL: The long press was cancelled
*
* The states for the #ClutterClickAction::long-press signal.
*
* Since: 1.8
*/
typedef enum /*< prefix=CLUTTER_LONG_PRESS >*/
{
CLUTTER_LONG_PRESS_QUERY,
CLUTTER_LONG_PRESS_ACTIVATE,
CLUTTER_LONG_PRESS_CANCEL
} ClutterLongPressState;
/**
* ClutterStaticColor:
* @CLUTTER_COLOR_WHITE: White color (ffffffff)
* @CLUTTER_COLOR_BLACK: Black color (000000ff)
* @CLUTTER_COLOR_RED: Red color (ff0000ff)
* @CLUTTER_COLOR_DARK_RED: Dark red color (800000ff)
* @CLUTTER_COLOR_GREEN: Green color (00ff00ff)
* @CLUTTER_COLOR_DARK_GREEN: Dark green color (008000ff)
* @CLUTTER_COLOR_BLUE: Blue color (0000ffff)
* @CLUTTER_COLOR_DARK_BLUE: Dark blue color (000080ff)
* @CLUTTER_COLOR_CYAN: Cyan color (00ffffff)
* @CLUTTER_COLOR_DARK_CYAN: Dark cyan color (008080ff)
* @CLUTTER_COLOR_MAGENTA: Magenta color (ff00ffff)
* @CLUTTER_COLOR_DARK_MAGENTA: Dark magenta color (800080ff)
* @CLUTTER_COLOR_YELLOW: Yellow color (ffff00ff)
* @CLUTTER_COLOR_DARK_YELLOW: Dark yellow color (808000ff)
* @CLUTTER_COLOR_GRAY: Gray color (a0a0a4ff)
* @CLUTTER_COLOR_DARK_GRAY: Dark Gray color (808080ff)
* @CLUTTER_COLOR_LIGHT_GRAY: Light gray color (c0c0c0ff)
* @CLUTTER_COLOR_BUTTER: Butter color (edd400ff)
* @CLUTTER_COLOR_BUTTER_LIGHT: Light butter color (fce94fff)
* @CLUTTER_COLOR_BUTTER_DARK: Dark butter color (c4a000ff)
* @CLUTTER_COLOR_ORANGE: Orange color (f57900ff)
* @CLUTTER_COLOR_ORANGE_LIGHT: Light orange color (fcaf3fff)
* @CLUTTER_COLOR_ORANGE_DARK: Dark orange color (ce5c00ff)
* @CLUTTER_COLOR_CHOCOLATE: Chocolate color (c17d11ff)
* @CLUTTER_COLOR_CHOCOLATE_LIGHT: Light chocolate color (e9b96eff)
* @CLUTTER_COLOR_CHOCOLATE_DARK: Dark chocolate color (8f5902ff)
* @CLUTTER_COLOR_CHAMELEON: Chameleon color (73d216ff)
* @CLUTTER_COLOR_CHAMELEON_LIGHT: Light chameleon color (8ae234ff)
* @CLUTTER_COLOR_CHAMELEON_DARK: Dark chameleon color (4e9a06ff)
* @CLUTTER_COLOR_SKY_BLUE: Sky color (3465a4ff)
* @CLUTTER_COLOR_SKY_BLUE_LIGHT: Light sky color (729fcfff)
* @CLUTTER_COLOR_SKY_BLUE_DARK: Dark sky color (204a87ff)
* @CLUTTER_COLOR_PLUM: Plum color (75507bff)
* @CLUTTER_COLOR_PLUM_LIGHT: Light plum color (ad7fa8ff)
* @CLUTTER_COLOR_PLUM_DARK: Dark plum color (5c3566ff)
* @CLUTTER_COLOR_SCARLET_RED: Scarlet red color (cc0000ff)
* @CLUTTER_COLOR_SCARLET_RED_LIGHT: Light scarlet red color (ef2929ff)
* @CLUTTER_COLOR_SCARLET_RED_DARK: Dark scarlet red color (a40000ff)
* @CLUTTER_COLOR_ALUMINIUM_1: Aluminium, first variant (eeeeecff)
* @CLUTTER_COLOR_ALUMINIUM_2: Aluminium, second variant (d3d7cfff)
* @CLUTTER_COLOR_ALUMINIUM_3: Aluminium, third variant (babdb6ff)
* @CLUTTER_COLOR_ALUMINIUM_4: Aluminium, fourth variant (888a85ff)
* @CLUTTER_COLOR_ALUMINIUM_5: Aluminium, fifth variant (555753ff)
* @CLUTTER_COLOR_ALUMINIUM_6: Aluminium, sixth variant (2e3436ff)
* @CLUTTER_COLOR_TRANSPARENT: Transparent color (00000000)
*
* Named colors, for accessing global colors defined by Clutter
*
* Since: 1.6
*/
typedef enum /*< prefix=CLUTTER_COLOR >*/
{
/* CGA/EGA-like palette */
CLUTTER_COLOR_WHITE = 0,
CLUTTER_COLOR_BLACK,
CLUTTER_COLOR_RED,
CLUTTER_COLOR_DARK_RED,
CLUTTER_COLOR_GREEN,
CLUTTER_COLOR_DARK_GREEN,
CLUTTER_COLOR_BLUE,
CLUTTER_COLOR_DARK_BLUE,
CLUTTER_COLOR_CYAN,
CLUTTER_COLOR_DARK_CYAN,
CLUTTER_COLOR_MAGENTA,
CLUTTER_COLOR_DARK_MAGENTA,
CLUTTER_COLOR_YELLOW,
CLUTTER_COLOR_DARK_YELLOW,
CLUTTER_COLOR_GRAY,
CLUTTER_COLOR_DARK_GRAY,
CLUTTER_COLOR_LIGHT_GRAY,
/* Tango icon palette */
CLUTTER_COLOR_BUTTER,
CLUTTER_COLOR_BUTTER_LIGHT,
CLUTTER_COLOR_BUTTER_DARK,
CLUTTER_COLOR_ORANGE,
CLUTTER_COLOR_ORANGE_LIGHT,
CLUTTER_COLOR_ORANGE_DARK,
CLUTTER_COLOR_CHOCOLATE,
CLUTTER_COLOR_CHOCOLATE_LIGHT,
CLUTTER_COLOR_CHOCOLATE_DARK,
CLUTTER_COLOR_CHAMELEON,
CLUTTER_COLOR_CHAMELEON_LIGHT,
CLUTTER_COLOR_CHAMELEON_DARK,
CLUTTER_COLOR_SKY_BLUE,
CLUTTER_COLOR_SKY_BLUE_LIGHT,
CLUTTER_COLOR_SKY_BLUE_DARK,
CLUTTER_COLOR_PLUM,
CLUTTER_COLOR_PLUM_LIGHT,
CLUTTER_COLOR_PLUM_DARK,
CLUTTER_COLOR_SCARLET_RED,
CLUTTER_COLOR_SCARLET_RED_LIGHT,
CLUTTER_COLOR_SCARLET_RED_DARK,
CLUTTER_COLOR_ALUMINIUM_1,
CLUTTER_COLOR_ALUMINIUM_2,
CLUTTER_COLOR_ALUMINIUM_3,
CLUTTER_COLOR_ALUMINIUM_4,
CLUTTER_COLOR_ALUMINIUM_5,
CLUTTER_COLOR_ALUMINIUM_6,
/* Fully transparent black */
CLUTTER_COLOR_TRANSPARENT
} ClutterStaticColor;
/**
* ClutterDragAxis:
* @CLUTTER_DRAG_AXIS_NONE: No constraint
* @CLUTTER_DRAG_X_AXIS: Set a constraint on the X axis
* @CLUTTER_DRAG_Y_AXIS: Set a constraint on the Y axis
*
* The axis of the constraint that should be applied on the
* dragging action
*
* Since: 1.4
*/
typedef enum /*< prefix=CLUTTER_DRAG >*/
{
CLUTTER_DRAG_AXIS_NONE = 0,
CLUTTER_DRAG_X_AXIS,
CLUTTER_DRAG_Y_AXIS
} ClutterDragAxis;
/**
* ClutterEventFlags:
* @CLUTTER_EVENT_NONE: No flag set
* @CLUTTER_EVENT_FLAG_SYNTHETIC: Synthetic event
* @CLUTTER_EVENT_FLAG_REPEATED: Auto-repeated event
*
* Flags for the #ClutterEvent
*
* Since: 0.6
*/
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_REPEATED = 1 << 2
} ClutterEventFlags;
/**
* ClutterEventType:
* @CLUTTER_NOTHING: Empty event
* @CLUTTER_KEY_PRESS: Key press event
* @CLUTTER_KEY_RELEASE: Key release event
* @CLUTTER_MOTION: Pointer motion event
* @CLUTTER_ENTER: Actor enter event
* @CLUTTER_LEAVE: Actor leave event
* @CLUTTER_BUTTON_PRESS: Pointer button press event
* @CLUTTER_BUTTON_RELEASE: Pointer button release event
* @CLUTTER_SCROLL: Pointer scroll event
* @CLUTTER_STAGE_STATE: Stage state change event
* @CLUTTER_DESTROY_NOTIFY: Destroy notification event
* @CLUTTER_CLIENT_MESSAGE: Client message event
* @CLUTTER_DELETE: Stage delete event
* @CLUTTER_TOUCH_BEGIN: A new touch event sequence has started;
* event added in 1.10
* @CLUTTER_TOUCH_UPDATE: A touch event sequence has been updated;
* event added in 1.10
* @CLUTTER_TOUCH_END: A touch event sequence has finished;
* event added in 1.10
* @CLUTTER_TOUCH_CANCEL: A touch event sequence has been canceled;
* event added in 1.10
* @CLUTTER_TOUCHPAD_PINCH: A pinch gesture event, the current state is
* determined by its phase field; event added in 1.24
* @CLUTTER_TOUCHPAD_SWIPE: A swipe gesture event, the current state is
* determined by its phase field; event added in 1.24
* @CLUTTER_PROXIMITY_IN: A tool entered in proximity to a tablet;
* event added in 1.28
* @CLUTTER_PROXIMITY_OUT: A tool left from the proximity area of a tablet;
* event added in 1.28
* @CLUTTER_EVENT_LAST: Marks the end of the #ClutterEventType enumeration;
* added in 1.10
*
* Types of events.
*
* Since: 0.4
*/
typedef enum /*< prefix=CLUTTER >*/
{
CLUTTER_NOTHING = 0,
CLUTTER_KEY_PRESS,
CLUTTER_KEY_RELEASE,
CLUTTER_MOTION,
CLUTTER_ENTER,
CLUTTER_LEAVE,
CLUTTER_BUTTON_PRESS,
CLUTTER_BUTTON_RELEASE,
CLUTTER_SCROLL,
CLUTTER_STAGE_STATE,
CLUTTER_DESTROY_NOTIFY,
CLUTTER_CLIENT_MESSAGE,
CLUTTER_DELETE,
CLUTTER_TOUCH_BEGIN,
CLUTTER_TOUCH_UPDATE,
CLUTTER_TOUCH_END,
CLUTTER_TOUCH_CANCEL,
CLUTTER_TOUCHPAD_PINCH,
CLUTTER_TOUCHPAD_SWIPE,
CLUTTER_PROXIMITY_IN,
CLUTTER_PROXIMITY_OUT,
CLUTTER_PAD_BUTTON_PRESS,
CLUTTER_PAD_BUTTON_RELEASE,
CLUTTER_PAD_STRIP,
CLUTTER_PAD_RING,
CLUTTER_IM_COMMIT,
CLUTTER_IM_DELETE,
CLUTTER_IM_PREEDIT,
CLUTTER_DEVICE_ADDED,
CLUTTER_DEVICE_REMOVED,
CLUTTER_EVENT_LAST /* helper */
} ClutterEventType;
/**
* ClutterScrollDirection:
* @CLUTTER_SCROLL_UP: Scroll up
* @CLUTTER_SCROLL_DOWN: Scroll down
* @CLUTTER_SCROLL_LEFT: Scroll left
* @CLUTTER_SCROLL_RIGHT: Scroll right
* @CLUTTER_SCROLL_SMOOTH: Precise scrolling delta (available in 1.10)
*
* Direction of a pointer scroll event.
*
* The %CLUTTER_SCROLL_SMOOTH value implies that the #ClutterScrollEvent
* has precise scrolling delta information.
*
* Since: 0.4
*/
typedef enum /*< prefix=CLUTTER_SCROLL >*/
{
CLUTTER_SCROLL_UP,
CLUTTER_SCROLL_DOWN,
CLUTTER_SCROLL_LEFT,
CLUTTER_SCROLL_RIGHT,
CLUTTER_SCROLL_SMOOTH
} ClutterScrollDirection;
/**
* ClutterStageState:
* @CLUTTER_STAGE_STATE_ACTIVATED: Activated mask
*
* Stage state masks, used by the #ClutterEvent of type %CLUTTER_STAGE_STATE.
*
* Since: 0.4
*/
typedef enum
{
CLUTTER_STAGE_STATE_ACTIVATED = (1 << 3)
} ClutterStageState;
/**
* ClutterFeatureFlags:
* @CLUTTER_FEATURE_SWAP_THROTTLE: Set if backend throttles buffer swaps.
* @CLUTTER_FEATURE_STAGE_STATIC: Set if stage size if fixed (i.e framebuffer)
* @CLUTTER_FEATURE_STAGE_CURSOR: Set if stage has a graphical cursor.
* @CLUTTER_FEATURE_SHADERS_GLSL: Set if the backend supports GLSL shaders.
* @CLUTTER_FEATURE_OFFSCREEN: Set if the backend supports offscreen rendering.
* @CLUTTER_FEATURE_STAGE_MULTIPLE: Set if multiple stages are supported.
* @CLUTTER_FEATURE_SWAP_EVENTS: Set if the GLX_INTEL_swap_event is supported.
*
* Runtime flags indicating specific features available via Clutter window
* system and graphics backend.
*
* Since: 0.4
*/
typedef enum
{
CLUTTER_FEATURE_SWAP_THROTTLE = (1 << 3),
CLUTTER_FEATURE_STAGE_STATIC = (1 << 6),
CLUTTER_FEATURE_STAGE_CURSOR = (1 << 8),
CLUTTER_FEATURE_SHADERS_GLSL = (1 << 9),
CLUTTER_FEATURE_OFFSCREEN = (1 << 10),
CLUTTER_FEATURE_STAGE_MULTIPLE = (1 << 11),
CLUTTER_FEATURE_SWAP_EVENTS = (1 << 12)
} ClutterFeatureFlags;
/**
* ClutterFlowOrientation:
* @CLUTTER_FLOW_HORIZONTAL: Arrange the children of the flow layout
* horizontally first
* @CLUTTER_FLOW_VERTICAL: Arrange the children of the flow layout
* vertically first
*
* The direction of the arrangement of the children inside
* a #ClutterFlowLayout
*
* Since: 1.2
*/
typedef enum /*< prefix=CLUTTER_FLOW >*/
{
CLUTTER_FLOW_HORIZONTAL,
CLUTTER_FLOW_VERTICAL
} ClutterFlowOrientation;
/**
* ClutterInputDeviceType:
* @CLUTTER_POINTER_DEVICE: A pointer device
* @CLUTTER_KEYBOARD_DEVICE: A keyboard device
* @CLUTTER_EXTENSION_DEVICE: A generic extension device
* @CLUTTER_JOYSTICK_DEVICE: A joystick device
* @CLUTTER_TABLET_DEVICE: A tablet device
* @CLUTTER_TOUCHPAD_DEVICE: A touchpad device
* @CLUTTER_TOUCHSCREEN_DEVICE: A touch screen device
* @CLUTTER_PEN_DEVICE: A pen device
* @CLUTTER_ERASER_DEVICE: An eraser device
* @CLUTTER_CURSOR_DEVICE: A cursor device
* @CLUTTER_PAD_DEVICE: A tablet pad
* @CLUTTER_N_DEVICE_TYPES: The number of device types
*
* The types of input devices available.
*
* The #ClutterInputDeviceType enumeration can be extended at later
* date; not every platform supports every input device type.
*
* Since: 1.0
*/
typedef enum
{
CLUTTER_POINTER_DEVICE,
CLUTTER_KEYBOARD_DEVICE,
CLUTTER_EXTENSION_DEVICE,
CLUTTER_JOYSTICK_DEVICE,
CLUTTER_TABLET_DEVICE,
CLUTTER_TOUCHPAD_DEVICE,
CLUTTER_TOUCHSCREEN_DEVICE,
CLUTTER_PEN_DEVICE,
CLUTTER_ERASER_DEVICE,
CLUTTER_CURSOR_DEVICE,
CLUTTER_PAD_DEVICE,
CLUTTER_N_DEVICE_TYPES
} ClutterInputDeviceType;
/**
* ClutterInputMode:
* @CLUTTER_INPUT_MODE_MASTER: A master, virtual device
* @CLUTTER_INPUT_MODE_SLAVE: A slave, physical device, attached to
* a master device
* @CLUTTER_INPUT_MODE_FLOATING: A slave, physical device, not attached
* to a master device
*
* The mode for input devices available.
*
* Since: 1.6
*/
typedef enum
{
CLUTTER_INPUT_MODE_MASTER,
CLUTTER_INPUT_MODE_SLAVE,
CLUTTER_INPUT_MODE_FLOATING
} ClutterInputMode;
/**
* ClutterInputAxis:
* @CLUTTER_INPUT_AXIS_IGNORE: Unused axis
* @CLUTTER_INPUT_AXIS_X: The position on the X axis
* @CLUTTER_INPUT_AXIS_Y: The position of the Y axis
* @CLUTTER_INPUT_AXIS_PRESSURE: The pressure information
* @CLUTTER_INPUT_AXIS_XTILT: The tilt on the X axis
* @CLUTTER_INPUT_AXIS_YTILT: The tile on the Y axis
* @CLUTTER_INPUT_AXIS_WHEEL: A wheel
* @CLUTTER_INPUT_AXIS_DISTANCE: Distance (Since 1.12)
* @CLUTTER_INPUT_AXIS_ROTATION: Rotation along the z-axis (Since 1.28)
* @CLUTTER_INPUT_AXIS_SLIDER: A slider (Since 1.28)
* @CLUTTER_INPUT_AXIS_LAST: Last value of the enumeration; this value is
* useful when iterating over the enumeration values (Since 1.12)
*
* The type of axes Clutter recognizes on a #ClutterInputDevice
*
* Since: 1.6
*/
typedef enum
{
CLUTTER_INPUT_AXIS_IGNORE,
CLUTTER_INPUT_AXIS_X,
CLUTTER_INPUT_AXIS_Y,
CLUTTER_INPUT_AXIS_PRESSURE,
CLUTTER_INPUT_AXIS_XTILT,
CLUTTER_INPUT_AXIS_YTILT,
CLUTTER_INPUT_AXIS_WHEEL,
CLUTTER_INPUT_AXIS_DISTANCE,
CLUTTER_INPUT_AXIS_ROTATION,
CLUTTER_INPUT_AXIS_SLIDER,
CLUTTER_INPUT_AXIS_LAST
} ClutterInputAxis;
/**
* ClutterSnapEdge:
* @CLUTTER_SNAP_EDGE_TOP: the top edge
* @CLUTTER_SNAP_EDGE_RIGHT: the right edge
* @CLUTTER_SNAP_EDGE_BOTTOM: the bottom edge
* @CLUTTER_SNAP_EDGE_LEFT: the left edge
*
* The edge to snap
*
* Since: 1.6
*/
typedef enum
{
CLUTTER_SNAP_EDGE_TOP,
CLUTTER_SNAP_EDGE_RIGHT,
CLUTTER_SNAP_EDGE_BOTTOM,
CLUTTER_SNAP_EDGE_LEFT
} ClutterSnapEdge;
/**
* ClutterPickMode:
* @CLUTTER_PICK_NONE: Do not paint any actor
* @CLUTTER_PICK_REACTIVE: Paint only the reactive actors
* @CLUTTER_PICK_ALL: Paint all actors
*
* Controls the paint cycle of the scene graph when in pick mode
*
* Since: 1.0
*/
typedef enum
{
CLUTTER_PICK_NONE = 0,
CLUTTER_PICK_REACTIVE,
CLUTTER_PICK_ALL
} ClutterPickMode;
/**
* ClutterSwipeDirection:
* @CLUTTER_SWIPE_DIRECTION_UP: Upwards swipe gesture
* @CLUTTER_SWIPE_DIRECTION_DOWN: Downwards swipe gesture
* @CLUTTER_SWIPE_DIRECTION_LEFT: Leftwards swipe gesture
* @CLUTTER_SWIPE_DIRECTION_RIGHT: Rightwards swipe gesture
*
* The main direction of the swipe gesture
*
* Since: 1.8
*/
typedef enum /*< prefix=CLUTTER_SWIPE_DIRECTION >*/
{
CLUTTER_SWIPE_DIRECTION_UP = 1 << 0,
CLUTTER_SWIPE_DIRECTION_DOWN = 1 << 1,
CLUTTER_SWIPE_DIRECTION_LEFT = 1 << 2,
CLUTTER_SWIPE_DIRECTION_RIGHT = 1 << 3
} ClutterSwipeDirection;
/**
* ClutterPanAxis:
* @CLUTTER_PAN_AXIS_NONE: No constraint
* @CLUTTER_PAN_X_AXIS: Set a constraint on the X axis
* @CLUTTER_PAN_Y_AXIS: Set a constraint on the Y axis
* @CLUTTER_PAN_AXIS_AUTO: Constrain panning automatically based on initial
* movement (available since 1.24)
*
* The axis of the constraint that should be applied on the
* panning action
*
* Since: 1.12
*/
typedef enum /*< prefix=CLUTTER_PAN >*/
{
CLUTTER_PAN_AXIS_NONE = 0,
CLUTTER_PAN_X_AXIS,
CLUTTER_PAN_Y_AXIS,
CLUTTER_PAN_AXIS_AUTO
} ClutterPanAxis;
/**
* ClutterTextureFlags:
* @CLUTTER_TEXTURE_NONE: No flags
* @CLUTTER_TEXTURE_RGB_FLAG_BGR: Unused flag
* @CLUTTER_TEXTURE_RGB_FLAG_PREMULT: Unused flag
* @CLUTTER_TEXTURE_YUV_FLAG_YUV2: Unused flag
*
* Flags for clutter_texture_set_from_rgb_data().
*
* Since: 0.4
*
* Deprecated: 1.22: The #ClutterTexture class was the only user of
* this API
*/
typedef enum /*< prefix=CLUTTER_TEXTURE >*/
{
CLUTTER_TEXTURE_NONE = 0,
CLUTTER_TEXTURE_RGB_FLAG_BGR = 1 << 1,
CLUTTER_TEXTURE_RGB_FLAG_PREMULT = 1 << 2, /* FIXME: not handled */
CLUTTER_TEXTURE_YUV_FLAG_YUV2 = 1 << 3
} ClutterTextureFlags;
/**
* ClutterTextureQuality:
* @CLUTTER_TEXTURE_QUALITY_LOW: fastest rendering will use nearest neighbour
* interpolation when rendering. good setting.
* @CLUTTER_TEXTURE_QUALITY_MEDIUM: higher quality rendering without using
* extra resources.
* @CLUTTER_TEXTURE_QUALITY_HIGH: render the texture with the best quality
* available using extra memory.
*
* Enumaration controlling the texture quality.
*
* Since: 0.8
*
* Deprecated: 1.22: The #ClutterTexture class was the only used ot
* this API; use #ClutterImage and clutter_actor_set_content_scaling_filters()
* instead.
*/
typedef enum /*< prefix=CLUTTER_TEXTURE_QUALITY >*/
{
CLUTTER_TEXTURE_QUALITY_LOW,
CLUTTER_TEXTURE_QUALITY_MEDIUM,
CLUTTER_TEXTURE_QUALITY_HIGH
} ClutterTextureQuality;
/**
* ClutterTimelineDirection:
* @CLUTTER_TIMELINE_FORWARD: forward direction for a timeline
* @CLUTTER_TIMELINE_BACKWARD: backward direction for a timeline
*
* The direction of a #ClutterTimeline
*
* Since: 0.6
*/
typedef enum
{
CLUTTER_TIMELINE_FORWARD,
CLUTTER_TIMELINE_BACKWARD
} ClutterTimelineDirection;
/**
* ClutterUnitType:
* @CLUTTER_UNIT_PIXEL: Unit expressed in pixels (with subpixel precision)
* @CLUTTER_UNIT_EM: Unit expressed in em
* @CLUTTER_UNIT_MM: Unit expressed in millimeters
* @CLUTTER_UNIT_POINT: Unit expressed in points
* @CLUTTER_UNIT_CM: Unit expressed in centimeters
*
* The type of unit in which a value is expressed
*
* This enumeration might be expanded at later date
*
* Since: 1.0
*/
typedef enum /*< prefix=CLUTTER_UNIT >*/
{
CLUTTER_UNIT_PIXEL,
CLUTTER_UNIT_EM,
CLUTTER_UNIT_MM,
CLUTTER_UNIT_POINT,
CLUTTER_UNIT_CM
} ClutterUnitType;
#define CLUTTER_PATH_RELATIVE (32)
/**
* ClutterPathNodeType:
* @CLUTTER_PATH_MOVE_TO: jump to the given position
* @CLUTTER_PATH_LINE_TO: create a line from the last node to the
* given position
* @CLUTTER_PATH_CURVE_TO: bezier curve using the last position and
* three control points.
* @CLUTTER_PATH_CLOSE: create a line from the last node to the last
* %CLUTTER_PATH_MOVE_TO node.
* @CLUTTER_PATH_REL_MOVE_TO: same as %CLUTTER_PATH_MOVE_TO but with
* coordinates relative to the last node.
* @CLUTTER_PATH_REL_LINE_TO: same as %CLUTTER_PATH_LINE_TO but with
* coordinates relative to the last node.
* @CLUTTER_PATH_REL_CURVE_TO: same as %CLUTTER_PATH_CURVE_TO but with
* coordinates relative to the last node.
*
* Types of nodes in a #ClutterPath.
*
* Since: 1.0
*/
typedef enum
{
CLUTTER_PATH_MOVE_TO = 0,
CLUTTER_PATH_LINE_TO = 1,
CLUTTER_PATH_CURVE_TO = 2,
CLUTTER_PATH_CLOSE = 3,
CLUTTER_PATH_REL_MOVE_TO = CLUTTER_PATH_MOVE_TO | CLUTTER_PATH_RELATIVE,
CLUTTER_PATH_REL_LINE_TO = CLUTTER_PATH_LINE_TO | CLUTTER_PATH_RELATIVE,
CLUTTER_PATH_REL_CURVE_TO = CLUTTER_PATH_CURVE_TO | CLUTTER_PATH_RELATIVE
} ClutterPathNodeType;
/**
* ClutterActorAlign:
* @CLUTTER_ACTOR_ALIGN_FILL: Stretch to cover the whole allocated space
* @CLUTTER_ACTOR_ALIGN_START: Snap to left or top side, leaving space
* to the right or bottom. For horizontal layouts, in right-to-left
* locales this should be reversed.
* @CLUTTER_ACTOR_ALIGN_CENTER: Center the actor inside the allocation
* @CLUTTER_ACTOR_ALIGN_END: Snap to right or bottom side, leaving space
* to the left or top. For horizontal layouts, in right-to-left locales
* this should be reversed.
*
* Controls how a #ClutterActor should align itself inside the extra space
* assigned to it during the allocation.
*
* Alignment only matters if the allocated space given to an actor is
* bigger than its natural size; for example, when the #ClutterActor:x-expand
* or the #ClutterActor:y-expand properties of #ClutterActor are set to %TRUE.
*
* Since: 1.10
*/
typedef enum
{
CLUTTER_ACTOR_ALIGN_FILL,
CLUTTER_ACTOR_ALIGN_START,
CLUTTER_ACTOR_ALIGN_CENTER,
CLUTTER_ACTOR_ALIGN_END
} ClutterActorAlign;
/**
* ClutterRepaintFlags:
* @CLUTTER_REPAINT_FLAGS_PRE_PAINT: Run the repaint function prior to
* painting the stages
* @CLUTTER_REPAINT_FLAGS_POST_PAINT: Run the repaint function after
* painting the stages
* @CLUTTER_REPAINT_FLAGS_QUEUE_REDRAW_ON_ADD: Ensure that a new frame
* is queued after adding the repaint function
*
* Flags to pass to clutter_threads_add_repaint_func_full().
*
* Since: 1.10
*/
typedef enum
{
CLUTTER_REPAINT_FLAGS_PRE_PAINT = 1 << 0,
CLUTTER_REPAINT_FLAGS_POST_PAINT = 1 << 1,
CLUTTER_REPAINT_FLAGS_QUEUE_REDRAW_ON_ADD = 1 << 2
} ClutterRepaintFlags;
/**
* ClutterContentGravity:
* @CLUTTER_CONTENT_GRAVITY_TOP_LEFT: Align the content to the top left corner
* @CLUTTER_CONTENT_GRAVITY_TOP: Align the content to the top edge
* @CLUTTER_CONTENT_GRAVITY_TOP_RIGHT: Align the content to the top right corner
* @CLUTTER_CONTENT_GRAVITY_LEFT: Align the content to the left edge
* @CLUTTER_CONTENT_GRAVITY_CENTER: Align the content to the center
* @CLUTTER_CONTENT_GRAVITY_RIGHT: Align the content to the right edge
* @CLUTTER_CONTENT_GRAVITY_BOTTOM_LEFT: Align the content to the bottom left corner
* @CLUTTER_CONTENT_GRAVITY_BOTTOM: Align the content to the bottom edge
* @CLUTTER_CONTENT_GRAVITY_BOTTOM_RIGHT: Align the content to the bottom right corner
* @CLUTTER_CONTENT_GRAVITY_RESIZE_FILL: Resize the content to fill the allocation
* @CLUTTER_CONTENT_GRAVITY_RESIZE_ASPECT: Resize the content to remain within the
* allocation, while maintaining the aspect ratio
*
* Controls the alignment of the #ClutterContent inside a #ClutterActor.
*
* Since: 1.10
*/
typedef enum
{
CLUTTER_CONTENT_GRAVITY_TOP_LEFT,
CLUTTER_CONTENT_GRAVITY_TOP,
CLUTTER_CONTENT_GRAVITY_TOP_RIGHT,
CLUTTER_CONTENT_GRAVITY_LEFT,
CLUTTER_CONTENT_GRAVITY_CENTER,
CLUTTER_CONTENT_GRAVITY_RIGHT,
CLUTTER_CONTENT_GRAVITY_BOTTOM_LEFT,
CLUTTER_CONTENT_GRAVITY_BOTTOM,
CLUTTER_CONTENT_GRAVITY_BOTTOM_RIGHT,
CLUTTER_CONTENT_GRAVITY_RESIZE_FILL,
CLUTTER_CONTENT_GRAVITY_RESIZE_ASPECT
} ClutterContentGravity;
/**
* ClutterScalingFilter:
* @CLUTTER_SCALING_FILTER_LINEAR: Linear interpolation filter
* @CLUTTER_SCALING_FILTER_NEAREST: Nearest neighbor interpolation filter
* @CLUTTER_SCALING_FILTER_TRILINEAR: Trilinear minification filter, with
* mipmap generation; this filter linearly interpolates on every axis,
* as well as between mipmap levels.
*
* The scaling filters to be used with the #ClutterActor:minification-filter
* and #ClutterActor:magnification-filter properties.
*
* Since: 1.10
*/
typedef enum
{
CLUTTER_SCALING_FILTER_LINEAR,
CLUTTER_SCALING_FILTER_NEAREST,
CLUTTER_SCALING_FILTER_TRILINEAR
} ClutterScalingFilter;
/**
* ClutterOrientation:
* @CLUTTER_ORIENTATION_HORIZONTAL: An horizontal orientation
* @CLUTTER_ORIENTATION_VERTICAL: A vertical orientation
*
* Represents the orientation of actors or layout managers.
*
* Since: 1.12
*/
typedef enum
{
CLUTTER_ORIENTATION_HORIZONTAL,
CLUTTER_ORIENTATION_VERTICAL
} ClutterOrientation;
/**
* ClutterScrollMode:
* @CLUTTER_SCROLL_NONE: Ignore scrolling
* @CLUTTER_SCROLL_HORIZONTALLY: Scroll only horizontally
* @CLUTTER_SCROLL_VERTICALLY: Scroll only vertically
* @CLUTTER_SCROLL_BOTH: Scroll in both directions
*
* Scroll modes.
*
* Since: 1.12
*/
typedef enum /*< prefix=CLUTTER_SCROLL >*/
{
CLUTTER_SCROLL_NONE = 0,
CLUTTER_SCROLL_HORIZONTALLY = 1 << 0,
CLUTTER_SCROLL_VERTICALLY = 1 << 1,
CLUTTER_SCROLL_BOTH = CLUTTER_SCROLL_HORIZONTALLY | CLUTTER_SCROLL_VERTICALLY
} ClutterScrollMode;
/**
* ClutterGridPosition:
* @CLUTTER_GRID_POSITION_LEFT: left position
* @CLUTTER_GRID_POSITION_RIGHT: right position
* @CLUTTER_GRID_POSITION_TOP: top position
* @CLUTTER_GRID_POSITION_BOTTOM: bottom position
*
* Grid position modes.
*
* Since: 1.12
*/
typedef enum
{
CLUTTER_GRID_POSITION_LEFT,
CLUTTER_GRID_POSITION_RIGHT,
CLUTTER_GRID_POSITION_TOP,
CLUTTER_GRID_POSITION_BOTTOM
} ClutterGridPosition;
/**
* ClutterContentRepeat:
* @CLUTTER_REPEAT_NONE: No repeat
* @CLUTTER_REPEAT_X_AXIS: Repeat the content on the X axis
* @CLUTTER_REPEAT_Y_AXIS: Repeat the content on the Y axis
* @CLUTTER_REPEAT_BOTH: Repeat the content on both axis
*
* Content repeat modes.
*
* Since: 1.12
*/
typedef enum
{
CLUTTER_REPEAT_NONE = 0,
CLUTTER_REPEAT_X_AXIS = 1 << 0,
CLUTTER_REPEAT_Y_AXIS = 1 << 1,
CLUTTER_REPEAT_BOTH = CLUTTER_REPEAT_X_AXIS | CLUTTER_REPEAT_Y_AXIS
} ClutterContentRepeat;
/**
* ClutterStepMode:
* @CLUTTER_STEP_MODE_START: The change in the value of a
* %CLUTTER_STEP progress mode should occur at the start of
* the transition
* @CLUTTER_STEP_MODE_END: The change in the value of a
* %CLUTTER_STEP progress mode should occur at the end of
* the transition
*
* Change the value transition of a step function.
*
* See clutter_timeline_set_step_progress().
*
* Since: 1.12
*/
typedef enum
{
CLUTTER_STEP_MODE_START,
CLUTTER_STEP_MODE_END
} ClutterStepMode;
/**
* ClutterZoomAxis:
* @CLUTTER_ZOOM_X_AXIS: Scale only on the X axis
* @CLUTTER_ZOOM_Y_AXIS: Scale only on the Y axis
* @CLUTTER_ZOOM_BOTH: Scale on both axis
*
* The axis of the constraint that should be applied by the
* zooming action.
*
* Since: 1.12
*/
typedef enum /*< prefix=CLUTTER_ZOOM >*/
{
CLUTTER_ZOOM_X_AXIS,
CLUTTER_ZOOM_Y_AXIS,
CLUTTER_ZOOM_BOTH
} ClutterZoomAxis;
/**
* ClutterGestureTriggerEdge:
* @CLUTTER_GESTURE_TRIGGER_EDGE_NONE: Tell #ClutterGestureAction that
* the gesture must begin immediately and there's no drag limit that
* will cause its cancellation;
* @CLUTTER_GESTURE_TRIGGER_EDGE_AFTER: Tell #ClutterGestureAction that
* it needs to wait until the drag threshold has been exceeded before
* considering that the gesture has begun;
* @CLUTTER_GESTURE_TRIGGER_EDGE_BEFORE: Tell #ClutterGestureAction that
* the gesture must begin immediately and that it must be cancelled
* once the drag exceed the configured threshold.
*
* Enum passed to the clutter_gesture_action_set_threshold_trigger_edge()
* function.
*
* Since: 1.18
*/
typedef enum
{
CLUTTER_GESTURE_TRIGGER_EDGE_NONE = 0,
CLUTTER_GESTURE_TRIGGER_EDGE_AFTER,
CLUTTER_GESTURE_TRIGGER_EDGE_BEFORE
} ClutterGestureTriggerEdge;
/**
* ClutterTouchpadGesturePhase:
* @CLUTTER_TOUCHPAD_GESTURE_PHASE_BEGIN: The gesture has begun.
* @CLUTTER_TOUCHPAD_GESTURE_PHASE_UPDATE: The gesture has been updated.
* @CLUTTER_TOUCHPAD_GESTURE_PHASE_END: The gesture was finished, changes
* should be permanently applied.
* @CLUTTER_TOUCHPAD_GESTURE_PHASE_CANCEL: The gesture was cancelled, all
* changes should be undone.
*
* The phase of a touchpad gesture event. All gestures are guaranteed to
* begin with an event of type %CLUTTER_TOUCHPAD_GESTURE_PHASE_BEGIN,
* followed by a number of %CLUTTER_TOUCHPAD_GESTURE_PHASE_UPDATE (possibly 0).
*
* A finished gesture may have 2 possible outcomes, an event with phase
* %CLUTTER_TOUCHPAD_GESTURE_PHASE_END will be emitted when the gesture is
* considered successful, this should be used as the hint to perform any
* permanent changes.
* Cancelled gestures may be so for a variety of reasons, due to hardware,
* or due to the gesture recognition layers hinting the gesture did not
* finish resolutely (eg. a 3rd finger being added during a pinch gesture).
* In these cases, the last event with report the phase
* %CLUTTER_TOUCHPAD_GESTURE_PHASE_CANCEL, this should be used as a hint
* to undo any visible/permanent changes that were done throughout the
* progress of the gesture.
*
* See also #ClutterTouchpadPinchEvent and #ClutterTouchpadPinchEvent.
*
* Since: 1.24
*/
typedef enum
{
CLUTTER_TOUCHPAD_GESTURE_PHASE_BEGIN,
CLUTTER_TOUCHPAD_GESTURE_PHASE_UPDATE,
CLUTTER_TOUCHPAD_GESTURE_PHASE_END,
CLUTTER_TOUCHPAD_GESTURE_PHASE_CANCEL
} ClutterTouchpadGesturePhase;
/**
* ClutterScrollSource:
* @CLUTTER_SCROLL_SOURCE_UNKNOWN: Source of scroll events is unknown.
* @CLUTTER_SCROLL_SOURCE_WHEEL: The scroll event is originated by a mouse wheel.
* @CLUTTER_SCROLL_SOURCE_FINGER: The scroll event is originated by one or more
* fingers on the device (eg. touchpads).
* @CLUTTER_SCROLL_SOURCE_CONTINUOUS: The scroll event is originated by the
* motion of some device (eg. a scroll button is set).
*
* The scroll source determines the source of the scroll event. Keep in mind
* that the source device #ClutterInputDeviceType is not enough to infer
* the scroll source.
*
* Since: 1.26
*/
typedef enum
{
CLUTTER_SCROLL_SOURCE_UNKNOWN,
CLUTTER_SCROLL_SOURCE_WHEEL,
CLUTTER_SCROLL_SOURCE_FINGER,
CLUTTER_SCROLL_SOURCE_CONTINUOUS
} ClutterScrollSource;
/**
* ClutterScrollFinishFlags:
* @CLUTTER_SCROLL_FINISHED_NONE: no axis was stopped.
* @CLUTTER_SCROLL_FINISHED_HORIZONTAL: The horizontal axis stopped.
* @CLUTTER_SCROLL_FINISHED_VERTICAL: The vertical axis stopped.
*
* Flags used to notify the axes that were stopped in a #ClutterScrollEvent.
* These can be used to trigger post-scroll effects like kinetic scrolling.
*
* Since: 1.26
*/
typedef enum
{
CLUTTER_SCROLL_FINISHED_NONE = 0,
CLUTTER_SCROLL_FINISHED_HORIZONTAL = 1 << 0,
CLUTTER_SCROLL_FINISHED_VERTICAL = 1 << 1
} ClutterScrollFinishFlags;
/**
* ClutterInputDeviceToolType:
* @CLUTTER_INPUT_DEVICE_TOOL_NONE: No tool
* @CLUTTER_INPUT_DEVICE_TOOL_PEN: The tool is a pen
* @CLUTTER_INPUT_DEVICE_TOOL_ERASER: The tool is an eraser
* @CLUTTER_INPUT_DEVICE_TOOL_BRUSH: The tool is a brush
* @CLUTTER_INPUT_DEVICE_TOOL_PENCIL: The tool is a pencil
* @CLUTTER_INPUT_DEVICE_TOOL_AIRBRUSH: The tool is an airbrush
* @CLUTTER_INPUT_DEVICE_TOOL_MOUSE: The tool is a mouse
* @CLUTTER_INPUT_DEVICE_TOOL_LENS: The tool is a lens
*
* Defines the type of tool that a #ClutterInputDeviceTool represents.
*
* Since: 1.28
*/
typedef enum
{
CLUTTER_INPUT_DEVICE_TOOL_NONE,
CLUTTER_INPUT_DEVICE_TOOL_PEN,
CLUTTER_INPUT_DEVICE_TOOL_ERASER,
CLUTTER_INPUT_DEVICE_TOOL_BRUSH,
CLUTTER_INPUT_DEVICE_TOOL_PENCIL,
CLUTTER_INPUT_DEVICE_TOOL_AIRBRUSH,
CLUTTER_INPUT_DEVICE_TOOL_MOUSE,
CLUTTER_INPUT_DEVICE_TOOL_LENS
} ClutterInputDeviceToolType;
typedef enum
{
CLUTTER_INPUT_DEVICE_PAD_SOURCE_UNKNOWN,
CLUTTER_INPUT_DEVICE_PAD_SOURCE_FINGER,
} ClutterInputDevicePadSource;
typedef enum
{
CLUTTER_INPUT_DEVICE_MAPPING_ABSOLUTE,
CLUTTER_INPUT_DEVICE_MAPPING_RELATIVE,
} ClutterInputDeviceMapping;
typedef enum
{
CLUTTER_INPUT_CONTENT_HINT_COMPLETION = 1 << 0,
CLUTTER_INPUT_CONTENT_HINT_SPELLCHECK = 1 << 1,
CLUTTER_INPUT_CONTENT_HINT_AUTO_CAPITALIZATION = 1 << 2,
CLUTTER_INPUT_CONTENT_HINT_LOWERCASE = 1 << 3,
CLUTTER_INPUT_CONTENT_HINT_UPPERCASE = 1 << 4,
CLUTTER_INPUT_CONTENT_HINT_TITLECASE = 1 << 5,
CLUTTER_INPUT_CONTENT_HINT_HIDDEN_TEXT = 1 << 6,
CLUTTER_INPUT_CONTENT_HINT_SENSITIVE_DATA = 1 << 7,
CLUTTER_INPUT_CONTENT_HINT_LATIN = 1 << 8,
CLUTTER_INPUT_CONTENT_HINT_MULTILINE = 1 << 9,
} ClutterInputContentHintFlags;
typedef enum
{
CLUTTER_INPUT_CONTENT_PURPOSE_NORMAL,
CLUTTER_INPUT_CONTENT_PURPOSE_ALPHA,
CLUTTER_INPUT_CONTENT_PURPOSE_DIGITS,
CLUTTER_INPUT_CONTENT_PURPOSE_NUMBER,
CLUTTER_INPUT_CONTENT_PURPOSE_PHONE,
CLUTTER_INPUT_CONTENT_PURPOSE_URL,
CLUTTER_INPUT_CONTENT_PURPOSE_EMAIL,
CLUTTER_INPUT_CONTENT_PURPOSE_NAME,
CLUTTER_INPUT_CONTENT_PURPOSE_PASSWORD,
CLUTTER_INPUT_CONTENT_PURPOSE_DATE,
CLUTTER_INPUT_CONTENT_PURPOSE_TIME,
CLUTTER_INPUT_CONTENT_PURPOSE_DATETIME,
CLUTTER_INPUT_CONTENT_PURPOSE_TERMINAL,
} ClutterInputContentPurpose;
typedef enum
{
CLUTTER_INPUT_PANEL_STATE_OFF,
CLUTTER_INPUT_PANEL_STATE_ON,
CLUTTER_INPUT_PANEL_STATE_TOGGLE,
} ClutterInputPanelState;
G_END_DECLS
#endif /* __CLUTTER_ENUMS_H__ */
muffin-6.4.1/clutter/clutter/clutter-path-constraint.c 0000664 0001750 0001750 00000025576 14723361714 022067 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
/**
* SECTION:clutter-path-constraint
* @Title: ClutterPathConstraint
* @Short_Description: A constraint that follows a path
*
* #ClutterPathConstraint is a simple constraint that modifies the allocation
* of the #ClutterActor to which it has been applied using a #ClutterPath.
*
* By setting the #ClutterPathConstraint:offset property it is possible to
* control how far along the path the #ClutterActor should be.
*
* ClutterPathConstraint is available since Clutter 1.6.
*/
#include "clutter-build-config.h"
#include "clutter-path-constraint.h"
#include "clutter-debug.h"
#include "clutter-marshal.h"
#include "clutter-private.h"
#define CLUTTER_PATH_CONSTRAINT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_PATH_CONSTRAINT, ClutterPathConstraintClass))
#define CLUTTER_IS_PATH_CONSTRAINT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_PATH_CONSTRAINT))
#define CLUTTER_PATH_CONSTRAINT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_PATH_CONSTRAINT, ClutterPathConstraintClass))
struct _ClutterPathConstraint
{
ClutterConstraint parent_instance;
ClutterPath *path;
gfloat offset;
ClutterActor *actor;
guint current_node;
};
struct _ClutterPathConstraintClass
{
ClutterConstraintClass parent_class;
};
enum
{
PROP_0,
PROP_PATH,
PROP_OFFSET,
LAST_PROPERTY
};
enum
{
NODE_REACHED,
LAST_SIGNAL
};
G_DEFINE_TYPE (ClutterPathConstraint, clutter_path_constraint, CLUTTER_TYPE_CONSTRAINT);
static GParamSpec *path_properties[LAST_PROPERTY] = { NULL, };
static guint path_signals[LAST_SIGNAL] = { 0, };
static void
clutter_path_constraint_update_allocation (ClutterConstraint *constraint,
ClutterActor *actor,
ClutterActorBox *allocation)
{
ClutterPathConstraint *self = CLUTTER_PATH_CONSTRAINT (constraint);
gfloat width, height;
ClutterKnot position;
guint knot_id;
if (self->path == NULL)
return;
knot_id = clutter_path_get_position (self->path, self->offset, &position);
clutter_actor_box_get_size (allocation, &width, &height);
allocation->x1 = position.x;
allocation->y1 = position.y;
allocation->x2 = allocation->x1 + width;
allocation->y2 = allocation->y1 + height;
if (knot_id != self->current_node)
{
self->current_node = knot_id;
g_signal_emit (self, path_signals[NODE_REACHED], 0,
self->actor,
self->current_node);
}
}
static void
clutter_path_constraint_set_actor (ClutterActorMeta *meta,
ClutterActor *new_actor)
{
ClutterPathConstraint *path = CLUTTER_PATH_CONSTRAINT (meta);
ClutterActorMetaClass *parent;
/* store the pointer to the actor, for later use */
path->actor = new_actor;
parent = CLUTTER_ACTOR_META_CLASS (clutter_path_constraint_parent_class);
parent->set_actor (meta, new_actor);
}
static void
clutter_path_constraint_dispose (GObject *gobject)
{
ClutterPathConstraint *self = CLUTTER_PATH_CONSTRAINT (gobject);
if (self->path != NULL)
{
g_object_unref (self->path);
self->path = NULL;
}
G_OBJECT_CLASS (clutter_path_constraint_parent_class)->dispose (gobject);
}
static void
clutter_path_constraint_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterPathConstraint *self = CLUTTER_PATH_CONSTRAINT (gobject);
switch (prop_id)
{
case PROP_PATH:
clutter_path_constraint_set_path (self, g_value_get_object (value));
break;
case PROP_OFFSET:
clutter_path_constraint_set_offset (self, g_value_get_float (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
}
}
static void
clutter_path_constraint_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterPathConstraint *self = CLUTTER_PATH_CONSTRAINT (gobject);
switch (prop_id)
{
case PROP_PATH:
g_value_set_object (value, self->path);
break;
case PROP_OFFSET:
g_value_set_float (value, self->offset);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
}
}
static void
clutter_path_constraint_class_init (ClutterPathConstraintClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
ClutterConstraintClass *constraint_class = CLUTTER_CONSTRAINT_CLASS (klass);
/**
* ClutterPathConstraint:path:
*
* The #ClutterPath used to constrain the position of an actor.
*
* Since: 1.6
*/
path_properties[PROP_PATH] =
g_param_spec_object ("path",
P_("Path"),
P_("The path used to constrain an actor"),
CLUTTER_TYPE_PATH,
CLUTTER_PARAM_READWRITE);
/**
* ClutterPathConstraint:offset:
*
* The offset along the #ClutterPathConstraint:path, between -1.0 and 2.0.
*
* Since: 1.6
*/
path_properties[PROP_OFFSET] =
g_param_spec_float ("offset",
P_("Offset"),
P_("The offset along the path, between -1.0 and 2.0"),
-1.0, 2.0,
0.0,
CLUTTER_PARAM_READWRITE);
gobject_class->set_property = clutter_path_constraint_set_property;
gobject_class->get_property = clutter_path_constraint_get_property;
gobject_class->dispose = clutter_path_constraint_dispose;
g_object_class_install_properties (gobject_class,
LAST_PROPERTY,
path_properties);
meta_class->set_actor = clutter_path_constraint_set_actor;
constraint_class->update_allocation = clutter_path_constraint_update_allocation;
/**
* ClutterPathConstraint::node-reached:
* @constraint: the #ClutterPathConstraint that emitted the signal
* @actor: the #ClutterActor using the @constraint
* @index: the index of the node that has been reached
*
* The ::node-reached signal is emitted each time a
* #ClutterPathConstraint:offset value results in the actor
* passing a #ClutterPathNode
*
* Since: 1.6
*/
path_signals[NODE_REACHED] =
g_signal_new (I_("node-reached"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
_clutter_marshal_VOID__OBJECT_UINT,
G_TYPE_NONE, 2,
CLUTTER_TYPE_ACTOR,
G_TYPE_UINT);
}
static void
clutter_path_constraint_init (ClutterPathConstraint *self)
{
self->offset = 0.0f;
self->current_node = G_MAXUINT;
}
/**
* clutter_path_constraint_new:
* @path: (allow-none): a #ClutterPath, or %NULL
* @offset: the offset along the #ClutterPath
*
* Creates a new #ClutterPathConstraint with the given @path and @offset
*
* Return value: the newly created #ClutterPathConstraint
*
* Since: 1.6
*/
ClutterConstraint *
clutter_path_constraint_new (ClutterPath *path,
gfloat offset)
{
g_return_val_if_fail (path == NULL || CLUTTER_IS_PATH (path), NULL);
return g_object_new (CLUTTER_TYPE_PATH_CONSTRAINT,
"path", path,
"offset", offset,
NULL);
}
/**
* clutter_path_constraint_set_path:
* @constraint: a #ClutterPathConstraint
* @path: (allow-none): a #ClutterPath
*
* Sets the @path to be followed by the #ClutterPathConstraint.
*
* The @constraint will take ownership of the #ClutterPath passed to this
* function.
*
* Since: 1.6
*/
void
clutter_path_constraint_set_path (ClutterPathConstraint *constraint,
ClutterPath *path)
{
g_return_if_fail (CLUTTER_IS_PATH_CONSTRAINT (constraint));
g_return_if_fail (path == NULL || CLUTTER_IS_PATH (path));
if (constraint->path == path)
return;
if (constraint->path != NULL)
{
g_object_unref (constraint->path);
constraint->path = NULL;
}
if (path != NULL)
constraint->path = g_object_ref_sink (path);
if (constraint->actor != NULL)
clutter_actor_queue_relayout (constraint->actor);
g_object_notify_by_pspec (G_OBJECT (constraint), path_properties[PROP_PATH]);
}
/**
* clutter_path_constraint_get_path:
* @constraint: a #ClutterPathConstraint
*
* Retrieves a pointer to the #ClutterPath used by @constraint.
*
* Return value: (transfer none): the #ClutterPath used by the
* #ClutterPathConstraint, or %NULL. The returned #ClutterPath is owned
* by the constraint and it should not be unreferenced
*
* Since: 1.6
*/
ClutterPath *
clutter_path_constraint_get_path (ClutterPathConstraint *constraint)
{
g_return_val_if_fail (CLUTTER_IS_PATH_CONSTRAINT (constraint), NULL);
return constraint->path;
}
/**
* clutter_path_constraint_set_offset:
* @constraint: a #ClutterPathConstraint
* @offset: the offset along the path
*
* Sets the offset along the #ClutterPath used by @constraint.
*
* Since: 1.6
*/
void
clutter_path_constraint_set_offset (ClutterPathConstraint *constraint,
gfloat offset)
{
g_return_if_fail (CLUTTER_IS_PATH_CONSTRAINT (constraint));
if (constraint->offset == offset)
return;
constraint->offset = offset;
if (constraint->actor != NULL)
clutter_actor_queue_relayout (constraint->actor);
g_object_notify_by_pspec (G_OBJECT (constraint), path_properties[PROP_OFFSET]);
}
/**
* clutter_path_constraint_get_offset:
* @constraint: a #ClutterPathConstraint
*
* Retrieves the offset along the #ClutterPath used by @constraint.
*
* Return value: the offset
*
* Since: 1.6
*/
gfloat
clutter_path_constraint_get_offset (ClutterPathConstraint *constraint)
{
g_return_val_if_fail (CLUTTER_IS_PATH_CONSTRAINT (constraint), 0.0);
return constraint->offset;
}
muffin-6.4.1/clutter/clutter/clutter-swipe-action.c 0000664 0001750 0001750 00000020232 14723361714 021333 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
* Copyright (C) 2011 Robert Bosch Car Multimedia GmbH.
*
* 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 .
*
* Author:
* Tomeu Vizoso
*
* Based on ClutterDragAction, written by:
* Emmanuele Bassi
*/
/**
* SECTION:clutter-swipe-action
* @Title: ClutterSwipeAction
* @Short_Description: Action for swipe gestures
*
* #ClutterSwipeAction is a sub-class of #ClutterGestureAction that implements
* the logic for recognizing swipe gestures.
*
* Since: 1.8
*/
#include "clutter-build-config.h"
#include "clutter-swipe-action.h"
#include "clutter-debug.h"
#include "clutter-enum-types.h"
#include "clutter-gesture-action-private.h"
#include "clutter-marshal.h"
#include "clutter-private.h"
struct _ClutterSwipeActionPrivate
{
ClutterSwipeDirection h_direction;
ClutterSwipeDirection v_direction;
float distance_x, distance_y;
};
enum
{
SWEPT,
SWIPE,
LAST_SIGNAL
};
static guint swipe_signals[LAST_SIGNAL] = { 0, };
G_DEFINE_TYPE_WITH_PRIVATE (ClutterSwipeAction, clutter_swipe_action, CLUTTER_TYPE_GESTURE_ACTION)
static gboolean
gesture_begin (ClutterGestureAction *action,
ClutterActor *actor)
{
ClutterSwipeActionPrivate *priv = CLUTTER_SWIPE_ACTION (action)->priv;
/* reset the state at the beginning of a new gesture */
priv->h_direction = 0;
priv->v_direction = 0;
g_object_get (action,
"threshold-trigger-distance-x", &priv->distance_x,
"threshold-trigger-distance-y", &priv->distance_y,
NULL);
return TRUE;
}
static gboolean
gesture_progress (ClutterGestureAction *action,
ClutterActor *actor)
{
ClutterSwipeActionPrivate *priv = CLUTTER_SWIPE_ACTION (action)->priv;
gfloat press_x, press_y;
gfloat motion_x, motion_y;
gfloat delta_x, delta_y;
ClutterSwipeDirection h_direction = 0, v_direction = 0;
clutter_gesture_action_get_press_coords (action,
0,
&press_x,
&press_y);
clutter_gesture_action_get_motion_coords (action,
0,
&motion_x,
&motion_y);
delta_x = press_x - motion_x;
delta_y = press_y - motion_y;
if (delta_x >= priv->distance_x)
h_direction = CLUTTER_SWIPE_DIRECTION_RIGHT;
else if (delta_x < -priv->distance_x)
h_direction = CLUTTER_SWIPE_DIRECTION_LEFT;
if (delta_y >= priv->distance_y)
v_direction = CLUTTER_SWIPE_DIRECTION_DOWN;
else if (delta_y < -priv->distance_y)
v_direction = CLUTTER_SWIPE_DIRECTION_UP;
/* cancel gesture on direction reversal */
if (priv->h_direction == 0)
priv->h_direction = h_direction;
if (priv->v_direction == 0)
priv->v_direction = v_direction;
if (priv->h_direction != h_direction)
return FALSE;
if (priv->v_direction != v_direction)
return FALSE;
return TRUE;
}
static void
gesture_end (ClutterGestureAction *action,
ClutterActor *actor)
{
ClutterSwipeActionPrivate *priv = CLUTTER_SWIPE_ACTION (action)->priv;
gfloat press_x, press_y;
gfloat release_x, release_y;
ClutterSwipeDirection direction = 0;
gboolean can_emit_swipe;
const ClutterEvent *last_event;
clutter_gesture_action_get_press_coords (action,
0,
&press_x, &press_y);
/* Check the last event instead of get_release_coords(), this
* might not be the sequence that finished on multi-finger swipes.
*/
last_event = clutter_gesture_action_get_last_event (action, 0);
clutter_event_get_coords (last_event, &release_x, &release_y);
if (release_x - press_x > priv->distance_x)
direction |= CLUTTER_SWIPE_DIRECTION_RIGHT;
else if (press_x - release_x > priv->distance_x)
direction |= CLUTTER_SWIPE_DIRECTION_LEFT;
if (release_y - press_y > priv->distance_y)
direction |= CLUTTER_SWIPE_DIRECTION_DOWN;
else if (press_y - release_y > priv->distance_y)
direction |= CLUTTER_SWIPE_DIRECTION_UP;
/* XXX:2.0 remove */
g_signal_emit (action, swipe_signals[SWIPE], 0, actor, direction,
&can_emit_swipe);
if (can_emit_swipe)
g_signal_emit (action, swipe_signals[SWEPT], 0, actor, direction);
}
/* XXX:2.0 remove */
static gboolean
clutter_swipe_action_real_swipe (ClutterSwipeAction *action,
ClutterActor *actor,
ClutterSwipeDirection direction)
{
return TRUE;
}
static void
clutter_swipe_action_constructed (GObject *object)
{
clutter_gesture_action_set_threshold_trigger_edge (CLUTTER_GESTURE_ACTION (object),
CLUTTER_GESTURE_TRIGGER_EDGE_AFTER);
}
static void
clutter_swipe_action_class_init (ClutterSwipeActionClass *klass)
{
ClutterGestureActionClass *gesture_class =
CLUTTER_GESTURE_ACTION_CLASS (klass);
GObjectClass *object_class =
G_OBJECT_CLASS (klass);
object_class->constructed = clutter_swipe_action_constructed;
gesture_class->gesture_begin = gesture_begin;
gesture_class->gesture_progress = gesture_progress;
gesture_class->gesture_end = gesture_end;
/* XXX:2.0 remove */
klass->swipe = clutter_swipe_action_real_swipe;
/**
* ClutterSwipeAction::swept:
* @action: the #ClutterSwipeAction that emitted the signal
* @actor: the #ClutterActor attached to the @action
* @direction: the main direction of the swipe gesture
*
* The ::swept signal is emitted when a swipe gesture is recognized on the
* attached actor.
*
* Deprecated: 1.14: Use the ::swipe signal instead.
*
* Since: 1.8
*/
swipe_signals[SWEPT] =
g_signal_new (I_("swept"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST |
G_SIGNAL_DEPRECATED,
G_STRUCT_OFFSET (ClutterSwipeActionClass, swept),
NULL, NULL,
_clutter_marshal_VOID__OBJECT_FLAGS,
G_TYPE_NONE, 2,
CLUTTER_TYPE_ACTOR,
CLUTTER_TYPE_SWIPE_DIRECTION);
/**
* ClutterSwipeAction::swipe:
* @action: the #ClutterSwipeAction that emitted the signal
* @actor: the #ClutterActor attached to the @action
* @direction: the main direction of the swipe gesture
*
* The ::swipe signal is emitted when a swipe gesture is recognized on the
* attached actor.
*
* Return value: %TRUE if the swipe should continue, and %FALSE if
* the swipe should be cancelled.
*
* Since: 1.14
*/
swipe_signals[SWIPE] =
g_signal_new (I_("swipe"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterSwipeActionClass, swipe),
_clutter_boolean_continue_accumulator, NULL,
_clutter_marshal_BOOLEAN__OBJECT_FLAGS,
G_TYPE_BOOLEAN, 2,
CLUTTER_TYPE_ACTOR,
CLUTTER_TYPE_SWIPE_DIRECTION);
}
static void
clutter_swipe_action_init (ClutterSwipeAction *self)
{
self->priv = clutter_swipe_action_get_instance_private (self);
}
/**
* clutter_swipe_action_new:
*
* Creates a new #ClutterSwipeAction instance
*
* Return value: the newly created #ClutterSwipeAction
*
* Since: 1.8
*/
ClutterAction *
clutter_swipe_action_new (void)
{
return g_object_new (CLUTTER_TYPE_SWIPE_ACTION, NULL);
}
muffin-6.4.1/clutter/clutter/clutter-bind-constraint.h 0000664 0001750 0001750 00000006061 14723361714 022040 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_BIND_CONSTRAINT_H__
#define __CLUTTER_BIND_CONSTRAINT_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_BIND_CONSTRAINT (clutter_bind_constraint_get_type ())
#define CLUTTER_BIND_CONSTRAINT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_BIND_CONSTRAINT, ClutterBindConstraint))
#define CLUTTER_IS_BIND_CONSTRAINT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_BIND_CONSTRAINT))
/**
* ClutterBindConstraint:
*
* #ClutterBindConstraint is an opaque structure
* whose members cannot be directly accessed
*
* Since: 1.4
*/
typedef struct _ClutterBindConstraint ClutterBindConstraint;
typedef struct _ClutterBindConstraintClass ClutterBindConstraintClass;
CLUTTER_EXPORT
GType clutter_bind_constraint_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterConstraint * clutter_bind_constraint_new (ClutterActor *source,
ClutterBindCoordinate coordinate,
gfloat offset);
CLUTTER_EXPORT
void clutter_bind_constraint_set_source (ClutterBindConstraint *constraint,
ClutterActor *source);
CLUTTER_EXPORT
ClutterActor * clutter_bind_constraint_get_source (ClutterBindConstraint *constraint);
CLUTTER_EXPORT
void clutter_bind_constraint_set_coordinate (ClutterBindConstraint *constraint,
ClutterBindCoordinate coordinate);
CLUTTER_EXPORT
ClutterBindCoordinate clutter_bind_constraint_get_coordinate (ClutterBindConstraint *constraint);
CLUTTER_EXPORT
void clutter_bind_constraint_set_offset (ClutterBindConstraint *constraint,
gfloat offset);
CLUTTER_EXPORT
gfloat clutter_bind_constraint_get_offset (ClutterBindConstraint *constraint);
G_END_DECLS
#endif /* __CLUTTER_BIND_CONSTRAINT_H__ */
muffin-6.4.1/clutter/clutter/clutter-keysyms-update.pl 0000775 0001750 0001750 00000012057 14723361714 022117 0 ustar fabio fabio #!/usr/bin/env perl
# Author : Simos Xenitellis .
# Authos : Bastien Nocera
# Version : 1.2
#
# Notes : It downloads keysymdef.h from the Internet, if not found locally,
# Notes : and creates an updated clutter-keysyms.h
use strict;
my $update_url = 'http://git.clutter-project.org/clutter/plain/clutter/clutter-keysyms-update.pl';
# Used for reading the keysymdef symbols.
my @keysymelements;
my $keysymdef_url = 'http://cgit.freedesktop.org/xorg/proto/x11proto/plain/keysymdef.h';
if ( ! -f "keysymdef.h" )
{
print "Trying to download keysymdef.h from\n", $keysymdef_url, "\n";
die "Unable to download keysymdef.h: $!"
unless system("wget -c -O keysymdef.h \"$keysymdef_url\"") == 0;
print " done.\n\n";
}
else
{
print "We are using existing keysymdef.h found in this directory.\n";
print "It is assumed that you took care and it is a recent version\n";
}
my $XF86keysym_url = 'http://cgit.freedesktop.org/xorg/proto/x11proto/plain/XF86keysym.h';
if ( ! -f "XF86keysym.h" )
{
print "Trying to download XF86keysym.h from\n", $XF86keysym_url, "\n";
die "Unable to download keysymdef.h: $!\n"
unless system("wget -c -O XF86keysym.h \"$XF86keysym_url\"") == 0;
print " done.\n\n";
}
else
{
print "We are using existing XF86keysym.h found in this directory.\n";
print "It is assumed that you took care and it is a recent version\n";
}
if ( -f "clutter-keysyms.h" )
{
print "There is already a clutter-keysyms.h file in this directory. We are not overwriting it.\n";
print "Please move it somewhere else in order to run this script.\n";
die "Exiting...\n\n";
}
die "Could not open file keysymdef.h: $!\n"
unless open(IN_KEYSYMDEF, "<:utf8", "keysymdef.h");
# Output: clutter/clutter/clutter-keysyms.h
die "Could not open file clutter-keysyms.h: $!\n"
unless open(OUT_KEYSYMS, ">:utf8", "clutter-keysyms.h");
my $LICENSE_HEADER= <.
*/
EOF
print OUT_KEYSYMS $LICENSE_HEADER;
print OUT_KEYSYMS<)
{
next if ( ! /^#define / );
@keysymelements = split(/\s+/);
die "Internal error, no \@keysymelements: $_\n" unless @keysymelements;
$_ = $keysymelements[1];
die "Internal error, was expecting \"XC_*\", found: $_\n" if ( ! /^XK_/ );
$_ = $keysymelements[2];
die "Internal error, was expecting \"0x*\", found: $_\n" if ( ! /^0x/ );
my $element = $keysymelements[1];
my $binding = $element;
$binding =~ s/^XK_/CLUTTER_KEY_/g;
printf OUT_KEYSYMS "#define %s 0x%03x\n", $binding, hex($keysymelements[2]);
}
close IN_KEYSYMDEF;
#$cluttersyms{"0"} = "0000";
# Source: http://gitweb.freedesktop.org/?p=xorg/proto/x11proto.git;a=blob;f=XF86keysym.h
die "Could not open file XF86keysym.h: $!\n" unless open(IN_XF86KEYSYM, "<:utf8", "XF86keysym.h");
while ()
{
next if ( ! /^#define / );
@keysymelements = split(/\s+/);
die "Internal error, no \@keysymelements: $_\n" unless @keysymelements;
$_ = $keysymelements[1];
die "Internal error, was expecting \"XF86XK_*\", found: $_\n" if ( ! /^XF86XK_/ );
# Work-around https://bugs.freedesktop.org/show_bug.cgi?id=11193
if ($_ eq "XF86XK_XF86BackForward") {
$keysymelements[1] = "XF86XK_AudioForward";
}
# XF86XK_Clear could end up a dupe of XK_Clear
# XF86XK_Select could end up a dupe of XK_Select
if ($_ eq "XF86XK_Clear") {
$keysymelements[1] = "XF86XK_WindowClear";
}
if ($_ eq "XF86XK_Select") {
$keysymelements[1] = "XF86XK_SelectButton";
}
# Ignore XF86XK_Q
next if ( $_ eq "XF86XK_Q");
# XF86XK_Calculater is misspelled, and a dupe
next if ( $_ eq "XF86XK_Calculater");
$_ = $keysymelements[2];
die "Internal error, was expecting \"0x*\", found: $_\n" if ( ! /^0x/ );
my $element = $keysymelements[1];
my $binding = $element;
$binding =~ s/^XF86XK_/CLUTTER_KEY_/g;
printf OUT_KEYSYMS "#define %s 0x%03x\n", $binding, hex($keysymelements[2]);
}
close IN_XF86KEYSYM;
print OUT_KEYSYMS<
* Emmanuele Bassi
*
* Copyright (C) 2006 OpenedHand
*
* 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 .
*/
#ifndef __CLUTTER_SCRIPTABLE_H__
#define __CLUTTER_SCRIPTABLE_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_SCRIPTABLE (clutter_scriptable_get_type ())
#define CLUTTER_SCRIPTABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_SCRIPTABLE, ClutterScriptable))
#define CLUTTER_IS_SCRIPTABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_SCRIPTABLE))
#define CLUTTER_SCRIPTABLE_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), CLUTTER_TYPE_SCRIPTABLE, ClutterScriptableIface))
typedef struct _ClutterScriptable ClutterScriptable;
typedef struct _ClutterScriptableIface ClutterScriptableIface;
/**
* ClutterScriptable:
*
* #ClutterScriptable is an opaque structure whose members cannot be directly
* accessed
*
* Since: 0.6
*/
/**
* ClutterScriptableIface:
* @set_id: virtual function for setting the id of a scriptable object
* @get_id: virtual function for getting the id of a scriptable object
* @parse_custom_node: virtual function for parsing complex data containers
* into GObject properties
* @set_custom_property: virtual function for setting a custom property
*
* Interface for implementing "scriptable" objects. An object implementing
* this interface can override the parsing and properties setting sequence
* when loading a UI definition data with #ClutterScript
*
* Since: 0.6
*/
struct _ClutterScriptableIface
{
/*< private >*/
GTypeInterface g_iface;
/*< public >*/
void (* set_id) (ClutterScriptable *scriptable,
const gchar *id_);
const gchar *(* get_id) (ClutterScriptable *scriptable);
gboolean (* parse_custom_node) (ClutterScriptable *scriptable,
ClutterScript *script,
GValue *value,
const gchar *name,
JsonNode *node);
void (* set_custom_property) (ClutterScriptable *scriptable,
ClutterScript *script,
const gchar *name,
const GValue *value);
};
CLUTTER_EXPORT
GType clutter_scriptable_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
void clutter_scriptable_set_id (ClutterScriptable *scriptable,
const gchar *id_);
CLUTTER_EXPORT
const gchar * clutter_scriptable_get_id (ClutterScriptable *scriptable);
CLUTTER_EXPORT
gboolean clutter_scriptable_parse_custom_node (ClutterScriptable *scriptable,
ClutterScript *script,
GValue *value,
const gchar *name,
JsonNode *node);
CLUTTER_EXPORT
void clutter_scriptable_set_custom_property (ClutterScriptable *scriptable,
ClutterScript *script,
const gchar *name,
const GValue *value);
G_END_DECLS
#endif /* __CLUTTER_SCRIPTABLE_H__ */
muffin-6.4.1/clutter/clutter/clutter-deform-effect.c 0000664 0001750 0001750 00000060536 14723361714 021452 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*
* Based on the MxDeformTexture class, written by:
* Chris Lord
*/
/**
* SECTION:clutter-deform-effect
* @Title: ClutterDeformEffect
* @Short_Description: A base class for effects deforming the geometry
* of an actor
*
* #ClutterDeformEffect is an abstract class providing all the plumbing
* for creating effects that result in the deformation of an actor's
* geometry.
*
* #ClutterDeformEffect uses offscreen buffers to render the contents of
* a #ClutterActor and then the Cogl vertex buffers API to submit the
* geometry to the GPU.
*
* #ClutterDeformEffect is available since Clutter 1.4
*
* ## Implementing ClutterDeformEffect
*
* Sub-classes of #ClutterDeformEffect should override the
* #ClutterDeformEffectClass.deform_vertex() virtual function; this function
* is called on every vertex that needs to be deformed by the effect.
* Each passed vertex is an in-out parameter that initially contains the
* position of the vertex and should be modified according to a specific
* deformation algorithm.
*/
#include "clutter-build-config.h"
#define CLUTTER_ENABLE_EXPERIMENTAL_API
#include "clutter-deform-effect.h"
#include
#include "clutter-debug.h"
#include "clutter-enum-types.h"
#include "clutter-offscreen-effect-private.h"
#include "clutter-private.h"
#define DEFAULT_N_TILES 32
struct _ClutterDeformEffectPrivate
{
CoglPipeline *back_pipeline;
gint x_tiles;
gint y_tiles;
CoglAttributeBuffer *buffer;
CoglPrimitive *primitive;
CoglPrimitive *lines_primitive;
gint n_vertices;
gulong allocation_id;
guint is_dirty : 1;
};
enum
{
PROP_0,
PROP_X_TILES,
PROP_Y_TILES,
PROP_BACK_MATERIAL,
PROP_LAST
};
static GParamSpec *obj_props[PROP_LAST];
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (ClutterDeformEffect,
clutter_deform_effect,
CLUTTER_TYPE_OFFSCREEN_EFFECT)
static void
clutter_deform_effect_real_deform_vertex (ClutterDeformEffect *effect,
gfloat width,
gfloat height,
CoglTextureVertex *vertex)
{
g_warning ("%s: Deformation effect of type '%s' does not implement "
"the required ClutterDeformEffect::deform_vertex virtual "
"function.",
G_STRLOC,
G_OBJECT_TYPE_NAME (effect));
}
static void
clutter_deform_effect_deform_vertex (ClutterDeformEffect *effect,
gfloat width,
gfloat height,
CoglTextureVertex *vertex)
{
CLUTTER_DEFORM_EFFECT_GET_CLASS (effect)->deform_vertex (effect,
width, height,
vertex);
}
static void
vbo_invalidate (ClutterActor *actor,
const ClutterActorBox *allocation,
ClutterAllocationFlags flags,
ClutterDeformEffect *effect)
{
effect->priv->is_dirty = TRUE;
}
static void
clutter_deform_effect_set_actor (ClutterActorMeta *meta,
ClutterActor *actor)
{
ClutterDeformEffectPrivate *priv = CLUTTER_DEFORM_EFFECT (meta)->priv;
if (priv->allocation_id != 0)
{
ClutterActor *old_actor = clutter_actor_meta_get_actor (meta);
if (old_actor != NULL)
g_clear_signal_handler (&priv->allocation_id, old_actor);
priv->allocation_id = 0;
}
/* we need to invalidate the VBO whenever the allocation of the actor
* changes
*/
if (actor != NULL)
priv->allocation_id = g_signal_connect (actor, "allocation-changed",
G_CALLBACK (vbo_invalidate),
meta);
priv->is_dirty = TRUE;
CLUTTER_ACTOR_META_CLASS (clutter_deform_effect_parent_class)->set_actor (meta, actor);
}
static void
clutter_deform_effect_paint_target (ClutterOffscreenEffect *effect,
ClutterPaintContext *paint_context)
{
ClutterDeformEffect *self= CLUTTER_DEFORM_EFFECT (effect);
ClutterDeformEffectPrivate *priv = self->priv;
CoglHandle material;
CoglPipeline *pipeline;
CoglDepthState depth_state;
CoglFramebuffer *fb =
clutter_paint_context_get_framebuffer (paint_context);
if (priv->is_dirty)
{
graphene_rect_t rect;
gboolean mapped_buffer;
CoglVertexP3T2C4 *verts;
ClutterActor *actor;
gfloat width, height;
guint opacity;
gint i, j;
actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
opacity = clutter_actor_get_paint_opacity (actor);
/* if we don't have a target size, fall back to the actor's
* allocation, though wrong it might be
*/
if (clutter_offscreen_effect_get_target_rect (effect, &rect))
{
width = graphene_rect_get_width (&rect);
height = graphene_rect_get_height (&rect);
}
else
clutter_actor_get_size (actor, &width, &height);
/* XXX ideally, the sub-classes should tell us what they
* changed in the texture vertices; we then would be able to
* avoid resubmitting the same data, if it did not change. for
* the time being, we resubmit everything
*/
verts = cogl_buffer_map (COGL_BUFFER (priv->buffer),
COGL_BUFFER_ACCESS_WRITE,
COGL_BUFFER_MAP_HINT_DISCARD);
/* If the map failed then we'll resort to allocating a temporary
buffer */
if (verts == NULL)
{
mapped_buffer = FALSE;
verts = g_malloc (sizeof (*verts) * priv->n_vertices);
}
else
mapped_buffer = TRUE;
for (i = 0; i < priv->y_tiles + 1; i++)
{
for (j = 0; j < priv->x_tiles + 1; j++)
{
CoglVertexP3T2C4 *vertex_out;
CoglTextureVertex vertex;
/* CoglTextureVertex isn't an ideal structure to use for
this because it contains a CoglColor. The internal
layout of CoglColor is mean to be private so Clutter
can not pass a pointer to it as a vertex
attribute. Also it contains padding so we end up
storing more data in the vertex buffer than we need
to. Instead we let the application modify a dummy
vertex and then copy the details back out to a more
well-defined struct */
vertex.tx = (float) j / priv->x_tiles;
vertex.ty = (float) i / priv->y_tiles;
vertex.x = width * vertex.tx;
vertex.y = height * vertex.ty;
vertex.z = 0.0f;
cogl_color_init_from_4ub (&vertex.color, 255, 255, 255, opacity);
clutter_deform_effect_deform_vertex (self,
width, height,
&vertex);
vertex_out = verts + i * (priv->x_tiles + 1) + j;
vertex_out->x = vertex.x;
vertex_out->y = vertex.y;
vertex_out->z = vertex.z;
vertex_out->s = vertex.tx;
vertex_out->t = vertex.ty;
vertex_out->r = cogl_color_get_red_byte (&vertex.color);
vertex_out->g = cogl_color_get_green_byte (&vertex.color);
vertex_out->b = cogl_color_get_blue_byte (&vertex.color);
vertex_out->a = cogl_color_get_alpha_byte (&vertex.color);
}
}
if (mapped_buffer)
cogl_buffer_unmap (COGL_BUFFER (priv->buffer));
else
{
cogl_buffer_set_data (COGL_BUFFER (priv->buffer),
0, /* offset */
verts,
sizeof (*verts) * priv->n_vertices);
g_free (verts);
}
priv->is_dirty = FALSE;
}
material = clutter_offscreen_effect_get_target (effect);
pipeline = COGL_PIPELINE (material);
/* enable depth testing */
cogl_depth_state_init (&depth_state);
cogl_depth_state_set_test_enabled (&depth_state, TRUE);
cogl_depth_state_set_test_function (&depth_state, COGL_DEPTH_TEST_FUNCTION_LEQUAL);
cogl_pipeline_set_depth_state (pipeline, &depth_state, NULL);
/* enable backface culling if we have a back material */
if (priv->back_pipeline != NULL)
cogl_pipeline_set_cull_face_mode (pipeline,
COGL_PIPELINE_CULL_FACE_MODE_BACK);
/* draw the front */
if (material != NULL)
cogl_framebuffer_draw_primitive (fb, pipeline, priv->primitive);
/* draw the back */
if (priv->back_pipeline != NULL)
{
CoglPipeline *back_pipeline;
/* We probably shouldn't be modifying the user's material so
instead we make a temporary copy */
back_pipeline = cogl_pipeline_copy (priv->back_pipeline);
cogl_pipeline_set_depth_state (back_pipeline, &depth_state, NULL);
cogl_pipeline_set_cull_face_mode (back_pipeline,
COGL_PIPELINE_CULL_FACE_MODE_FRONT);
cogl_framebuffer_draw_primitive (fb, back_pipeline, priv->primitive);
cogl_object_unref (back_pipeline);
}
if (G_UNLIKELY (priv->lines_primitive != NULL))
{
CoglContext *ctx =
clutter_backend_get_cogl_context (clutter_get_default_backend ());
CoglPipeline *lines_pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_color4f (lines_pipeline, 1.0, 0, 0, 1.0);
cogl_framebuffer_draw_primitive (fb, lines_pipeline,
priv->lines_primitive);
cogl_object_unref (lines_pipeline);
}
}
static inline void
clutter_deform_effect_free_arrays (ClutterDeformEffect *self)
{
ClutterDeformEffectPrivate *priv = self->priv;
if (priv->buffer)
{
cogl_object_unref (priv->buffer);
priv->buffer = NULL;
}
if (priv->primitive)
{
cogl_object_unref (priv->primitive);
priv->primitive = NULL;
}
if (priv->lines_primitive)
{
cogl_object_unref (priv->lines_primitive);
priv->lines_primitive = NULL;
}
}
static void
clutter_deform_effect_init_arrays (ClutterDeformEffect *self)
{
ClutterDeformEffectPrivate *priv = self->priv;
gint x, y, direction, n_indices;
CoglAttribute *attributes[3];
guint16 *static_indices;
CoglContext *ctx =
clutter_backend_get_cogl_context (clutter_get_default_backend ());
CoglIndices *indices;
guint16 *idx;
int i;
clutter_deform_effect_free_arrays (self);
n_indices = ((2 + 2 * priv->x_tiles)
* priv->y_tiles
+ (priv->y_tiles - 1));
static_indices = g_new (guint16, n_indices);
#define MESH_INDEX(x,y) ((y) * (priv->x_tiles + 1) + (x))
/* compute all the triangles from the various tiles */
direction = 1;
idx = static_indices;
idx[0] = MESH_INDEX (0, 0);
idx[1] = MESH_INDEX (0, 1);
idx += 2;
for (y = 0; y < priv->y_tiles; y++)
{
for (x = 0; x < priv->x_tiles; x++)
{
if (direction)
{
idx[0] = MESH_INDEX (x + 1, y);
idx[1] = MESH_INDEX (x + 1, y + 1);
}
else
{
idx[0] = MESH_INDEX (priv->x_tiles - x - 1, y);
idx[1] = MESH_INDEX (priv->x_tiles - x - 1, y + 1);
}
idx += 2;
}
if (y == (priv->y_tiles - 1))
break;
if (direction)
{
idx[0] = MESH_INDEX (priv->x_tiles, y + 1);
idx[1] = MESH_INDEX (priv->x_tiles, y + 1);
idx[2] = MESH_INDEX (priv->x_tiles, y + 2);
}
else
{
idx[0] = MESH_INDEX (0, y + 1);
idx[1] = MESH_INDEX (0, y + 1);
idx[2] = MESH_INDEX (0, y + 2);
}
idx += 3;
direction = !direction;
}
#undef MESH_INDEX
indices = cogl_indices_new (ctx,
COGL_INDICES_TYPE_UNSIGNED_SHORT,
static_indices,
n_indices);
g_free (static_indices);
priv->n_vertices = (priv->x_tiles + 1) * (priv->y_tiles + 1);
priv->buffer =
cogl_attribute_buffer_new (ctx,
sizeof (CoglVertexP3T2C4) *
priv->n_vertices,
NULL);
/* The application is expected to continuously modify the vertices
so we should give a hint to Cogl about that */
cogl_buffer_set_update_hint (COGL_BUFFER (priv->buffer),
COGL_BUFFER_UPDATE_HINT_DYNAMIC);
attributes[0] = cogl_attribute_new (priv->buffer,
"cogl_position_in",
sizeof (CoglVertexP3T2C4),
G_STRUCT_OFFSET (CoglVertexP3T2C4, x),
3, /* n_components */
COGL_ATTRIBUTE_TYPE_FLOAT);
attributes[1] = cogl_attribute_new (priv->buffer,
"cogl_tex_coord0_in",
sizeof (CoglVertexP3T2C4),
G_STRUCT_OFFSET (CoglVertexP3T2C4, s),
2, /* n_components */
COGL_ATTRIBUTE_TYPE_FLOAT);
attributes[2] = cogl_attribute_new (priv->buffer,
"cogl_color_in",
sizeof (CoglVertexP3T2C4),
G_STRUCT_OFFSET (CoglVertexP3T2C4, r),
4, /* n_components */
COGL_ATTRIBUTE_TYPE_UNSIGNED_BYTE);
priv->primitive =
cogl_primitive_new_with_attributes (COGL_VERTICES_MODE_TRIANGLE_STRIP,
priv->n_vertices,
attributes,
3 /* n_attributes */);
cogl_primitive_set_indices (priv->primitive,
indices,
n_indices);
if (G_UNLIKELY (clutter_paint_debug_flags & CLUTTER_DEBUG_PAINT_DEFORM_TILES))
{
priv->lines_primitive =
cogl_primitive_new_with_attributes (COGL_VERTICES_MODE_LINE_STRIP,
priv->n_vertices,
attributes,
2 /* n_attributes */);
cogl_primitive_set_indices (priv->lines_primitive,
indices,
n_indices);
}
cogl_object_unref (indices);
for (i = 0; i < 3; i++)
cogl_object_unref (attributes[i]);
priv->is_dirty = TRUE;
}
static inline void
clutter_deform_effect_free_back_pipeline (ClutterDeformEffect *self)
{
ClutterDeformEffectPrivate *priv = self->priv;
if (priv->back_pipeline != NULL)
{
cogl_object_unref (priv->back_pipeline);
priv->back_pipeline = NULL;
}
}
static void
clutter_deform_effect_finalize (GObject *gobject)
{
ClutterDeformEffect *self = CLUTTER_DEFORM_EFFECT (gobject);
clutter_deform_effect_free_arrays (self);
clutter_deform_effect_free_back_pipeline (self);
G_OBJECT_CLASS (clutter_deform_effect_parent_class)->finalize (gobject);
}
static void
clutter_deform_effect_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterDeformEffect *self = CLUTTER_DEFORM_EFFECT (gobject);
switch (prop_id)
{
case PROP_X_TILES:
clutter_deform_effect_set_n_tiles (self, g_value_get_uint (value),
self->priv->y_tiles);
break;
case PROP_Y_TILES:
clutter_deform_effect_set_n_tiles (self, self->priv->x_tiles,
g_value_get_uint (value));
break;
case PROP_BACK_MATERIAL:
clutter_deform_effect_set_back_material (self, g_value_get_boxed (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_deform_effect_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterDeformEffectPrivate *priv = CLUTTER_DEFORM_EFFECT (gobject)->priv;
switch (prop_id)
{
case PROP_X_TILES:
g_value_set_uint (value, priv->x_tiles);
break;
case PROP_Y_TILES:
g_value_set_uint (value, priv->y_tiles);
break;
case PROP_BACK_MATERIAL:
g_value_set_boxed (value, priv->back_pipeline);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_deform_effect_class_init (ClutterDeformEffectClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
ClutterOffscreenEffectClass *offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
klass->deform_vertex = clutter_deform_effect_real_deform_vertex;
/**
* ClutterDeformEffect:x-tiles:
*
* The number of horizontal tiles. The bigger the number, the
* smaller the tiles
*
* Since: 1.4
*/
obj_props[PROP_X_TILES] =
g_param_spec_uint ("x-tiles",
P_("Horizontal Tiles"),
P_("The number of horizontal tiles"),
1, G_MAXUINT,
DEFAULT_N_TILES,
CLUTTER_PARAM_READWRITE);
/**
* ClutterDeformEffect:y-tiles:
*
* The number of vertical tiles. The bigger the number, the
* smaller the tiles
*
* Since: 1.4
*/
obj_props[PROP_Y_TILES] =
g_param_spec_uint ("y-tiles",
P_("Vertical Tiles"),
P_("The number of vertical tiles"),
1, G_MAXUINT,
DEFAULT_N_TILES,
CLUTTER_PARAM_READWRITE);
/**
* ClutterDeformEffect:back-material:
*
* A material to be used when painting the back of the actor
* to which this effect has been applied
*
* By default, no material will be used
*
* Since: 1.4
*/
obj_props[PROP_BACK_MATERIAL] =
g_param_spec_boxed ("back-material",
P_("Back Material"),
P_("The material to be used when painting the back of the actor"),
COGL_TYPE_HANDLE,
CLUTTER_PARAM_READWRITE);
gobject_class->finalize = clutter_deform_effect_finalize;
gobject_class->set_property = clutter_deform_effect_set_property;
gobject_class->get_property = clutter_deform_effect_get_property;
g_object_class_install_properties (gobject_class,
PROP_LAST,
obj_props);
meta_class->set_actor = clutter_deform_effect_set_actor;
offscreen_class->paint_target = clutter_deform_effect_paint_target;
}
static void
clutter_deform_effect_init (ClutterDeformEffect *self)
{
self->priv = clutter_deform_effect_get_instance_private (self);
self->priv->x_tiles = self->priv->y_tiles = DEFAULT_N_TILES;
self->priv->back_pipeline = NULL;
clutter_deform_effect_init_arrays (self);
}
/**
* clutter_deform_effect_set_back_material:
* @effect: a #ClutterDeformEffect
* @material: (allow-none): a handle to a Cogl material
*
* Sets the material that should be used when drawing the back face
* of the actor during a deformation
*
* The #ClutterDeformEffect will take a reference on the material's
* handle
*
* Since: 1.4
*/
void
clutter_deform_effect_set_back_material (ClutterDeformEffect *effect,
CoglHandle material)
{
ClutterDeformEffectPrivate *priv;
CoglPipeline *pipeline = COGL_PIPELINE (material);
g_return_if_fail (CLUTTER_IS_DEFORM_EFFECT (effect));
g_return_if_fail (pipeline == NULL || cogl_is_pipeline (pipeline));
priv = effect->priv;
clutter_deform_effect_free_back_pipeline (effect);
priv->back_pipeline = material;
if (priv->back_pipeline != NULL)
cogl_object_ref (priv->back_pipeline);
clutter_deform_effect_invalidate (effect);
}
/**
* clutter_deform_effect_get_back_material:
* @effect: a #ClutterDeformEffect
*
* Retrieves the handle to the back face material used by @effect
*
* Return value: (transfer none): a handle for the material, or %NULL.
* The returned material is owned by the #ClutterDeformEffect and it
* should not be freed directly
*
* Since: 1.4
*/
CoglHandle
clutter_deform_effect_get_back_material (ClutterDeformEffect *effect)
{
g_return_val_if_fail (CLUTTER_IS_DEFORM_EFFECT (effect), NULL);
return effect->priv->back_pipeline;
}
/**
* clutter_deform_effect_set_n_tiles:
* @effect: a #ClutterDeformEffect
* @x_tiles: number of horizontal tiles
* @y_tiles: number of vertical tiles
*
* Sets the number of horizontal and vertical tiles to be used
* when applying the effect
*
* More tiles allow a finer grained deformation at the expenses
* of computation
*
* Since: 1.4
*/
void
clutter_deform_effect_set_n_tiles (ClutterDeformEffect *effect,
guint x_tiles,
guint y_tiles)
{
ClutterDeformEffectPrivate *priv;
gboolean tiles_changed = FALSE;
g_return_if_fail (CLUTTER_IS_DEFORM_EFFECT (effect));
g_return_if_fail (x_tiles > 0 && y_tiles > 0);
priv = effect->priv;
g_object_freeze_notify (G_OBJECT (effect));
if (priv->x_tiles != x_tiles)
{
priv->x_tiles = x_tiles;
g_object_notify_by_pspec (G_OBJECT (effect), obj_props[PROP_X_TILES]);
tiles_changed = TRUE;
}
if (priv->y_tiles != y_tiles)
{
priv->y_tiles = y_tiles;
g_object_notify_by_pspec (G_OBJECT (effect), obj_props[PROP_Y_TILES]);
tiles_changed = TRUE;
}
if (tiles_changed)
{
clutter_deform_effect_init_arrays (effect);
clutter_deform_effect_invalidate (effect);
}
g_object_thaw_notify (G_OBJECT (effect));
}
/**
* clutter_deform_effect_get_n_tiles:
* @effect: a #ClutterDeformEffect
* @x_tiles: (out): return location for the number of horizontal tiles,
* or %NULL
* @y_tiles: (out): return location for the number of vertical tiles,
* or %NULL
*
* Retrieves the number of horizontal and vertical tiles used to sub-divide
* the actor's geometry during the effect
*
* Since: 1.4
*/
void
clutter_deform_effect_get_n_tiles (ClutterDeformEffect *effect,
guint *x_tiles,
guint *y_tiles)
{
g_return_if_fail (CLUTTER_IS_DEFORM_EFFECT (effect));
if (x_tiles != NULL)
*x_tiles = effect->priv->x_tiles;
if (y_tiles != NULL)
*y_tiles = effect->priv->y_tiles;
}
/**
* clutter_deform_effect_invalidate:
* @effect: a #ClutterDeformEffect
*
* Invalidates the @effect's vertices and, if it is associated
* to an actor, it will queue a redraw
*
* Since: 1.4
*/
void
clutter_deform_effect_invalidate (ClutterDeformEffect *effect)
{
ClutterActor *actor;
g_return_if_fail (CLUTTER_IS_DEFORM_EFFECT (effect));
if (effect->priv->is_dirty)
return;
effect->priv->is_dirty = TRUE;
actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect));
if (actor != NULL)
clutter_effect_queue_repaint (CLUTTER_EFFECT (effect));
}
muffin-6.4.1/clutter/clutter/clutter-scriptable.c 0000664 0001750 0001750 00000013072 14723361714 021065 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum
* Emmanuele Bassi
*
* Copyright (C) 2006 OpenedHand
*
* 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 .
*
*
*/
/**
* SECTION:clutter-scriptable
* @short_description: Override the UI definition parsing
*
* The #ClutterScriptableIface interface exposes the UI definition parsing
* process to external classes. By implementing this interface, a class can
* override the UI definition parsing and transform complex data types into
* GObject properties, or allow custom properties.
*
* #ClutterScriptable is available since Clutter 0.6
*/
#include "clutter-build-config.h"
#include
#include
#include
#include "clutter-scriptable.h"
#include "clutter-script-private.h"
#include "clutter-private.h"
#include "clutter-debug.h"
typedef ClutterScriptableIface ClutterScriptableInterface;
G_DEFINE_INTERFACE (ClutterScriptable, clutter_scriptable, G_TYPE_OBJECT);
static void
clutter_scriptable_default_init (ClutterScriptableInterface *iface)
{
}
/**
* clutter_scriptable_set_id:
* @scriptable: a #ClutterScriptable
* @id_: the #ClutterScript id of the object
*
* Sets @id_ as the unique Clutter script it for this instance of
* #ClutterScriptableIface.
*
* This name can be used by user interface designer applications to
* define a unique name for an object constructable using the UI
* definition language parsed by #ClutterScript.
*
* Since: 0.6
*/
void
clutter_scriptable_set_id (ClutterScriptable *scriptable,
const gchar *id_)
{
ClutterScriptableIface *iface;
g_return_if_fail (CLUTTER_IS_SCRIPTABLE (scriptable));
g_return_if_fail (id_ != NULL);
iface = CLUTTER_SCRIPTABLE_GET_IFACE (scriptable);
if (iface->set_id)
iface->set_id (scriptable, id_);
else
g_object_set_data_full (G_OBJECT (scriptable),
"clutter-script-id",
g_strdup (id_),
g_free);
}
/**
* clutter_scriptable_get_id:
* @scriptable: a #ClutterScriptable
*
* Retrieves the id of @scriptable set using clutter_scriptable_set_id().
*
* Return value: the id of the object. The returned string is owned by
* the scriptable object and should never be modified of freed
*
* Since: 0.6
*/
const gchar *
clutter_scriptable_get_id (ClutterScriptable *scriptable)
{
ClutterScriptableIface *iface;
g_return_val_if_fail (CLUTTER_IS_SCRIPTABLE (scriptable), NULL);
iface = CLUTTER_SCRIPTABLE_GET_IFACE (scriptable);
if (iface->get_id)
return iface->get_id (scriptable);
else
return g_object_get_data (G_OBJECT (scriptable), "clutter-script-id");
}
/**
* clutter_scriptable_parse_custom_node:
* @scriptable: a #ClutterScriptable
* @script: the #ClutterScript creating the scriptable instance
* @value: the generic value to be set
* @name: the name of the node
* @node: the JSON node to be parsed
*
* Parses the passed JSON node. The implementation must set the type
* of the passed #GValue pointer using g_value_init().
*
* Return value: %TRUE if the node was successfully parsed, %FALSE otherwise.
*
* Since: 0.6
*/
gboolean
clutter_scriptable_parse_custom_node (ClutterScriptable *scriptable,
ClutterScript *script,
GValue *value,
const gchar *name,
JsonNode *node)
{
ClutterScriptableIface *iface;
g_return_val_if_fail (CLUTTER_IS_SCRIPTABLE (scriptable), FALSE);
g_return_val_if_fail (CLUTTER_IS_SCRIPT (script), FALSE);
g_return_val_if_fail (name != NULL, FALSE);
g_return_val_if_fail (node != NULL, FALSE);
iface = CLUTTER_SCRIPTABLE_GET_IFACE (scriptable);
if (iface->parse_custom_node)
return iface->parse_custom_node (scriptable, script, value, name, node);
return FALSE;
}
/**
* clutter_scriptable_set_custom_property:
* @scriptable: a #ClutterScriptable
* @script: the #ClutterScript creating the scriptable instance
* @name: the name of the property
* @value: the value of the property
*
* Overrides the common properties setting. The underlying virtual
* function should be used when implementing custom properties.
*
* Since: 0.6
*/
void
clutter_scriptable_set_custom_property (ClutterScriptable *scriptable,
ClutterScript *script,
const gchar *name,
const GValue *value)
{
ClutterScriptableIface *iface;
g_return_if_fail (CLUTTER_IS_SCRIPTABLE (scriptable));
g_return_if_fail (CLUTTER_IS_SCRIPT (script));
g_return_if_fail (name != NULL);
g_return_if_fail (value != NULL);
iface = CLUTTER_SCRIPTABLE_GET_IFACE (scriptable);
if (iface->set_custom_property)
iface->set_custom_property (scriptable, script, name, value);
}
muffin-6.4.1/clutter/clutter/clutter-grid-layout.h 0000664 0001750 0001750 00000015167 14723361714 021211 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Red Hat, Inc.
* Copyright (C) 2012 Bastian Winkler
*
* 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 .
*
* Author:
* Bastian Winkler
*
* Based on GtkGrid widget by:
* Matthias Clasen
*/
#ifndef __CLUTTER_GRID_LAYOUT_H__
#define __CLUTTER_GRID_LAYOUT_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_GRID_LAYOUT (clutter_grid_layout_get_type ())
#define CLUTTER_GRID_LAYOUT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_GRID_LAYOUT, ClutterGridLayout))
#define CLUTTER_IS_GRID_LAYOUT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_GRID_LAYOUT))
#define CLUTTER_GRID_LAYOUT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_GRID_LAYOUT, ClutterGridLayoutClass))
#define CLUTTER_IS_GRID_LAYOUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_GRID_LAYOUT))
#define CLUTTER_GRID_LAYOUT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_GRID_LAYOUT, ClutterGridLayoutClass))
typedef struct _ClutterGridLayout ClutterGridLayout;
typedef struct _ClutterGridLayoutPrivate ClutterGridLayoutPrivate;
typedef struct _ClutterGridLayoutClass ClutterGridLayoutClass;
/**
* ClutterGridLayout:
*
* The #ClutterGridLayout structure contains only private data
* and should be accessed using the provided API
*
* Since: 1.12
*/
struct _ClutterGridLayout
{
/*< private >*/
ClutterLayoutManager parent_instance;
ClutterGridLayoutPrivate *priv;
};
/**
* ClutterGridLayoutClass:
*
* The #ClutterGridLayoutClass structure contains only private
* data and should be accessed using the provided API
*
* Since: 1.12
*/
struct _ClutterGridLayoutClass
{
/*< private >*/
ClutterLayoutManagerClass parent_class;
gpointer _padding[8];
};
CLUTTER_EXPORT
GType clutter_grid_layout_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterLayoutManager * clutter_grid_layout_new (void);
CLUTTER_EXPORT
void clutter_grid_layout_attach (ClutterGridLayout *layout,
ClutterActor *child,
gint left,
gint top,
gint width,
gint height);
CLUTTER_EXPORT
void clutter_grid_layout_attach_next_to (ClutterGridLayout *layout,
ClutterActor *child,
ClutterActor *sibling,
ClutterGridPosition side,
gint width,
gint height);
CLUTTER_EXPORT
ClutterActor * clutter_grid_layout_get_child_at (ClutterGridLayout *layout,
gint left,
gint top);
CLUTTER_EXPORT
void clutter_grid_layout_insert_row (ClutterGridLayout *layout,
gint position);
CLUTTER_EXPORT
void clutter_grid_layout_insert_column (ClutterGridLayout *layout,
gint position);
CLUTTER_EXPORT
void clutter_grid_layout_insert_next_to (ClutterGridLayout *layout,
ClutterActor *sibling,
ClutterGridPosition side);
CLUTTER_EXPORT
void clutter_grid_layout_set_orientation (ClutterGridLayout *layout,
ClutterOrientation orientation);
CLUTTER_EXPORT
ClutterOrientation clutter_grid_layout_get_orientation (ClutterGridLayout *layout);
CLUTTER_EXPORT
void clutter_grid_layout_set_column_spacing (ClutterGridLayout *layout,
guint spacing);
CLUTTER_EXPORT
guint clutter_grid_layout_get_column_spacing (ClutterGridLayout *layout);
CLUTTER_EXPORT
void clutter_grid_layout_set_row_spacing (ClutterGridLayout *layout,
guint spacing);
CLUTTER_EXPORT
guint clutter_grid_layout_get_row_spacing (ClutterGridLayout *layout);
CLUTTER_EXPORT
void clutter_grid_layout_set_column_homogeneous (ClutterGridLayout *layout,
gboolean homogeneous);
CLUTTER_EXPORT
gboolean clutter_grid_layout_get_column_homogeneous (ClutterGridLayout *layout);
CLUTTER_EXPORT
void clutter_grid_layout_set_row_homogeneous (ClutterGridLayout *layout,
gboolean homogeneous);
CLUTTER_EXPORT
gboolean clutter_grid_layout_get_row_homogeneous (ClutterGridLayout *layout);
G_END_DECLS
#endif /* __CLUTTER_GRID_LAYOUT_H__ */
muffin-6.4.1/clutter/clutter/clutter-paint-node.h 0000664 0001750 0001750 00000012775 14723361714 021011 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2011 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_PAINT_NODE_H__
#define __CLUTTER_PAINT_NODE_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_PAINT_NODE (clutter_paint_node_get_type ())
#define CLUTTER_PAINT_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_PAINT_NODE, ClutterPaintNode))
#define CLUTTER_IS_PAINT_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_PAINT_NODE))
typedef struct _ClutterPaintNodePrivate ClutterPaintNodePrivate;
typedef struct _ClutterPaintNodeClass ClutterPaintNodeClass;
CLUTTER_EXPORT
GType clutter_paint_node_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterPaintNode * clutter_paint_node_ref (ClutterPaintNode *node);
CLUTTER_EXPORT
void clutter_paint_node_unref (ClutterPaintNode *node);
CLUTTER_EXPORT
void clutter_paint_node_paint (ClutterPaintNode *node,
ClutterPaintContext *paint_context);
CLUTTER_EXPORT
void clutter_paint_node_set_name (ClutterPaintNode *node,
const char *name);
CLUTTER_EXPORT
void clutter_paint_node_set_static_name (ClutterPaintNode *node,
const char *name);
CLUTTER_EXPORT
CoglFramebuffer * clutter_paint_node_get_framebuffer (ClutterPaintNode *node);
CLUTTER_EXPORT
void clutter_paint_node_add_child (ClutterPaintNode *node,
ClutterPaintNode *child);
CLUTTER_EXPORT
void clutter_paint_node_add_rectangle (ClutterPaintNode *node,
const ClutterActorBox *rect);
CLUTTER_EXPORT
void clutter_paint_node_add_texture_rectangle (ClutterPaintNode *node,
const ClutterActorBox *rect,
float x_1,
float y_1,
float x_2,
float y_2);
CLUTTER_EXPORT
void clutter_paint_node_add_multitexture_rectangle (ClutterPaintNode *node,
const ClutterActorBox *rect,
const float *text_coords,
unsigned int text_coords_len);
CLUTTER_EXPORT
void clutter_paint_node_add_path (ClutterPaintNode *node,
CoglPath *path);
CLUTTER_EXPORT
void clutter_paint_node_add_primitive (ClutterPaintNode *node,
CoglPrimitive *primitive);
/**
* CLUTTER_VALUE_HOLDS_PAINT_NODE:
* @value: a #GValue
*
* Evaluates to %TRUE if the @value has been initialized to hold
* a #ClutterPaintNode.
*
* Since: 1.10
*/
#define CLUTTER_VALUE_HOLDS_PAINT_NODE(value) (G_VALUE_HOLDS (value, CLUTTER_TYPE_PAINT_NODE))
CLUTTER_EXPORT
void clutter_value_set_paint_node (GValue *value,
gpointer node);
CLUTTER_EXPORT
void clutter_value_take_paint_node (GValue *value,
gpointer node);
CLUTTER_EXPORT
gpointer clutter_value_get_paint_node (const GValue *value);
CLUTTER_EXPORT
gpointer clutter_value_dup_paint_node (const GValue *value);
G_END_DECLS
#endif /* __CLUTTER_PAINT_NODE_H__ */
muffin-6.4.1/clutter/clutter/clutter-input-device-private.h 0000664 0001750 0001750 00000017755 14723361714 023022 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright © 2009, 2010, 2011 Intel Corp.
*
* 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 .
*
* Author: Emmanuele Bassi
*/
#ifndef CLUTTER_INPUT_DEVICE_PRIVATE_H
#define CLUTTER_INPUT_DEVICE_PRIVATE_H
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
typedef struct _ClutterAxisInfo
{
ClutterInputAxis axis;
double min_axis;
double max_axis;
double min_value;
double max_value;
double resolution;
} ClutterAxisInfo;
typedef struct _ClutterKeyInfo
{
guint keyval;
ClutterModifierType modifiers;
} ClutterKeyInfo;
typedef struct _ClutterScrollInfo
{
guint axis_id;
ClutterScrollDirection direction;
double increment;
double last_value;
guint last_value_valid : 1;
} ClutterScrollInfo;
typedef struct _ClutterTouchInfo
{
ClutterEventSequence *sequence;
ClutterActor *actor;
float current_x;
float current_y;
} ClutterTouchInfo;
typedef struct _ClutterPtrA11yData
{
int n_btn_pressed;
float current_x;
float current_y;
float dwell_x;
float dwell_y;
gboolean dwell_drag_started;
gboolean dwell_gesture_started;
guint dwell_timer;
guint dwell_position_timer;
guint secondary_click_timer;
gboolean secondary_click_triggered;
} ClutterPtrA11yData;
struct _ClutterInputDevice
{
GObject parent_instance;
int id;
ClutterInputDeviceType device_type;
ClutterInputMode device_mode;
char *device_name;
ClutterSeat *seat;
ClutterBackend *backend;
/* the associated device */
ClutterInputDevice *associated;
GList *slaves;
/* the actor underneath the pointer */
ClutterActor *cursor_actor;
GHashTable *inv_touch_sequence_actors;
/* the actor that has a grab in place for the device */
ClutterActor *pointer_grab_actor;
ClutterActor *keyboard_grab_actor;
GHashTable *sequence_grab_actors;
GHashTable *inv_sequence_grab_actors;
/* the current click count */
int click_count;
/* the stage the device is on */
ClutterStage *stage;
/* the current state */
float current_x;
float current_y;
uint32_t current_time;
int current_button_number;
ClutterModifierType current_state;
/* the current touch points states */
GHashTable *touch_sequences_info;
/* the previous state, used for click count generation */
int previous_x;
int previous_y;
uint32_t previous_time;
int previous_button_number;
ClutterModifierType previous_state;
GArray *axes;
guint n_keys;
GArray *keys;
GArray *scroll_info;
char *vendor_id;
char *product_id;
char *node_path;
GPtrArray *tools;
int n_rings;
int n_strips;
int n_mode_groups;
ClutterInputDeviceMapping mapping_mode;
guint has_cursor : 1;
guint is_enabled : 1;
/* Accessiblity */
ClutterVirtualInputDevice *accessibility_virtual_device;
ClutterPtrA11yData *ptr_a11y_data;
};
CLUTTER_EXPORT
void _clutter_input_device_set_associated_device (ClutterInputDevice *device,
ClutterInputDevice *associated);
CLUTTER_EXPORT
void _clutter_input_device_add_slave (ClutterInputDevice *master,
ClutterInputDevice *slave);
CLUTTER_EXPORT
void _clutter_input_device_remove_slave (ClutterInputDevice *master,
ClutterInputDevice *slave);
CLUTTER_EXPORT
void clutter_input_device_update_from_tool (ClutterInputDevice *device,
ClutterInputDeviceTool *tool);
CLUTTER_EXPORT
ClutterStage * _clutter_input_device_get_stage (ClutterInputDevice *device);
CLUTTER_EXPORT
void _clutter_input_device_set_stage (ClutterInputDevice *device,
ClutterStage *stage);
CLUTTER_EXPORT
void _clutter_input_device_set_coords (ClutterInputDevice *device,
ClutterEventSequence *sequence,
gfloat x,
gfloat y,
ClutterStage *stage);
CLUTTER_EXPORT
void _clutter_input_device_set_state (ClutterInputDevice *device,
ClutterModifierType state);
CLUTTER_EXPORT
void _clutter_input_device_set_time (ClutterInputDevice *device,
guint32 time_);
void _clutter_input_device_set_actor (ClutterInputDevice *device,
ClutterEventSequence *sequence,
ClutterActor *actor,
gboolean emit_crossing);
CLUTTER_EXPORT
ClutterActor * clutter_input_device_update (ClutterInputDevice *device,
ClutterEventSequence *sequence,
gboolean emit_crossing);
CLUTTER_EXPORT
void _clutter_input_device_add_event_sequence (ClutterInputDevice *device,
ClutterEvent *event);
CLUTTER_EXPORT
void _clutter_input_device_remove_event_sequence (ClutterInputDevice *device,
ClutterEvent *event);
CLUTTER_EXPORT
void _clutter_input_device_set_n_keys (ClutterInputDevice *device,
guint n_keys);
CLUTTER_EXPORT
gboolean _clutter_input_device_translate_axis (ClutterInputDevice *device,
guint index_,
gdouble value,
gdouble *axis_value);
CLUTTER_EXPORT
guint _clutter_input_device_add_axis (ClutterInputDevice *device,
ClutterInputAxis axis,
gdouble minimum,
gdouble maximum,
gdouble resolution);
CLUTTER_EXPORT
void _clutter_input_device_reset_axes (ClutterInputDevice *device);
CLUTTER_EXPORT
void _clutter_input_device_add_scroll_info (ClutterInputDevice *device,
guint index_,
ClutterScrollDirection direction,
gdouble increment);
CLUTTER_EXPORT
gboolean _clutter_input_device_get_scroll_delta (ClutterInputDevice *device,
guint index_,
gdouble value,
ClutterScrollDirection *direction_p,
gdouble *delta_p);
CLUTTER_EXPORT
void _clutter_input_device_reset_scroll_info (ClutterInputDevice *device);
CLUTTER_EXPORT
void clutter_input_device_add_tool (ClutterInputDevice *device,
ClutterInputDeviceTool *tool);
CLUTTER_EXPORT
ClutterInputDeviceTool *
clutter_input_device_lookup_tool (ClutterInputDevice *device,
guint64 serial,
ClutterInputDeviceToolType type);
#endif /* CLUTTER_INPUT_DEVICE_PRIVATE_H */
muffin-6.4.1/clutter/clutter/clutter-backend.h 0000664 0001750 0001750 00000006051 14723361714 020330 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum
*
* Copyright (C) 2006 OpenedHand
*
* 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 .
*/
#ifndef __CLUTTER_BACKEND_H__
#define __CLUTTER_BACKEND_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
#include
#include
#include
#include
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_BACKEND (clutter_backend_get_type ())
#define CLUTTER_BACKEND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_BACKEND, ClutterBackend))
#define CLUTTER_IS_BACKEND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_BACKEND))
/**
* ClutterBackend:
*
* #ClutterBackend is an opaque structure whose
* members cannot be directly accessed.
*
* Since: 0.4
*/
typedef struct _ClutterBackend ClutterBackend;
typedef struct _ClutterBackendClass ClutterBackendClass;
CLUTTER_EXPORT
GType clutter_backend_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterBackend * clutter_get_default_backend (void);
CLUTTER_EXPORT
gdouble clutter_backend_get_resolution (ClutterBackend *backend);
CLUTTER_EXPORT
void clutter_backend_set_font_options (ClutterBackend *backend,
const cairo_font_options_t *options);
CLUTTER_EXPORT
const cairo_font_options_t * clutter_backend_get_font_options (ClutterBackend *backend);
CLUTTER_EXPORT
CoglContext * clutter_backend_get_cogl_context (ClutterBackend *backend);
CLUTTER_EXPORT
ClutterInputMethod * clutter_backend_get_input_method (ClutterBackend *backend);
CLUTTER_EXPORT
void clutter_backend_set_input_method (ClutterBackend *backend,
ClutterInputMethod *method);
CLUTTER_EXPORT
ClutterSeat * clutter_backend_get_default_seat (ClutterBackend *backend);
G_END_DECLS
#endif /* __CLUTTER_BACKEND_H__ */
muffin-6.4.1/clutter/clutter/clutter-color.c 0000664 0001750 0001750 00000073460 14723361714 020062 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum
*
* Copyright (C) 2006 OpenedHand
*
* 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 .
*/
/**
* SECTION:clutter-color
* @short_description: Color management and manipulation.
*
* #ClutterColor is a simple type for representing colors in Clutter.
*
* A #ClutterColor is expressed as a 4-tuple of values ranging from
* zero to 255, one for each color channel plus one for the alpha.
*
* The alpha channel is fully opaque at 255 and fully transparent at 0.
*/
#include "clutter-build-config.h"
#include
#include
#include "clutter-interval.h"
#include "clutter-main.h"
#include "clutter-color.h"
#include "clutter-private.h"
#include "clutter-debug.h"
/* XXX - keep in sync with the ClutterStaticColor enumeration order */
static const ClutterColor static_colors[] = {
/* CGA/EGA color palette */
{ 0xff, 0xff, 0xff, 0xff }, /* white */
{ 0x00, 0x00, 0x00, 0xff }, /* black */
{ 0xff, 0x00, 0x00, 0xff }, /* red */
{ 0x80, 0x00, 0x00, 0xff }, /* dark red */
{ 0x00, 0xff, 0x00, 0xff }, /* green */
{ 0x00, 0x80, 0x00, 0xff }, /* dark green */
{ 0x00, 0x00, 0xff, 0xff }, /* blue */
{ 0x00, 0x00, 0x80, 0xff }, /* dark blue */
{ 0x00, 0xff, 0xff, 0xff }, /* cyan */
{ 0x00, 0x80, 0x80, 0xff }, /* dark cyan */
{ 0xff, 0x00, 0xff, 0xff }, /* magenta */
{ 0x80, 0x00, 0x80, 0xff }, /* dark magenta */
{ 0xff, 0xff, 0x00, 0xff }, /* yellow */
{ 0x80, 0x80, 0x00, 0xff }, /* dark yellow */
{ 0xa0, 0xa0, 0xa4, 0xff }, /* gray */
{ 0x80, 0x80, 0x80, 0xff }, /* dark gray */
{ 0xc0, 0xc0, 0xc0, 0xff }, /* light gray */
/* Tango Icon color palette */
{ 0xed, 0xd4, 0x00, 0xff }, /* butter */
{ 0xfc, 0xe9, 0x4f, 0xff }, /* butter light */
{ 0xc4, 0xa0, 0x00, 0xff }, /* butter dark */
{ 0xf5, 0x79, 0x00, 0xff }, /* orange */
{ 0xfc, 0xaf, 0x3e, 0xff }, /* orange light */
{ 0xce, 0x5c, 0x00, 0xff }, /* orange dark */
{ 0xc1, 0x7d, 0x11, 0xff }, /* chocolate */
{ 0xe9, 0xb9, 0x6e, 0xff }, /* chocolate light */
{ 0x8f, 0x59, 0x02, 0xff }, /* chocolate dark */
{ 0x73, 0xd2, 0x16, 0xff }, /* chameleon */
{ 0x8a, 0xe2, 0x34, 0xff }, /* chameleon light */
{ 0x4e, 0x9a, 0x06, 0xff }, /* chameleon dark */
{ 0x34, 0x65, 0xa4, 0xff }, /* sky blue */
{ 0x72, 0x9f, 0xcf, 0xff }, /* sky blue light */
{ 0x20, 0x4a, 0x87, 0xff }, /* sky blue dark */
{ 0x75, 0x50, 0x7b, 0xff }, /* plum */
{ 0xad, 0x7f, 0xa8, 0xff }, /* plum light */
{ 0x5c, 0x35, 0x66, 0xff }, /* plum dark */
{ 0xcc, 0x00, 0x00, 0xff }, /* scarlet red */
{ 0xef, 0x29, 0x29, 0xff }, /* scarlet red light */
{ 0xa4, 0x00, 0x00, 0xff }, /* scarlet red dark */
{ 0xee, 0xee, 0xec, 0xff }, /* aluminium 1 */
{ 0xd3, 0xd7, 0xcf, 0xff }, /* aluminium 2 */
{ 0xba, 0xbd, 0xb6, 0xff }, /* aluminium 3 */
{ 0x88, 0x8a, 0x85, 0xff }, /* aluminium 4 */
{ 0x55, 0x57, 0x53, 0xff }, /* aluminium 5 */
{ 0x2e, 0x34, 0x36, 0xff }, /* aluminium 6 */
/* last color */
{ 0x00, 0x00, 0x00, 0x00 } /* transparent */
};
/**
* clutter_color_get_static:
* @color: the named global color
*
* Retrieves a static color for the given @color name
*
* Static colors are created by Clutter and are guaranteed to always be
* available and valid
*
* Return value: a pointer to a static color; the returned pointer
* is owned by Clutter and it should never be modified or freed
*
* Since: 1.6
*/
const ClutterColor *
clutter_color_get_static (ClutterStaticColor color)
{
g_return_val_if_fail (color >= CLUTTER_COLOR_WHITE &&
color <= CLUTTER_COLOR_TRANSPARENT, NULL);
return &static_colors[color];
}
/**
* clutter_color_add:
* @a: a #ClutterColor
* @b: a #ClutterColor
* @result: (out caller-allocates): return location for the result
*
* Adds @a to @b and saves the resulting color inside @result.
*
* The alpha channel of @result is set as as the maximum value
* between the alpha channels of @a and @b.
*/
void
clutter_color_add (const ClutterColor *a,
const ClutterColor *b,
ClutterColor *result)
{
g_return_if_fail (a != NULL);
g_return_if_fail (b != NULL);
g_return_if_fail (result != NULL);
result->red = CLAMP (a->red + b->red, 0, 255);
result->green = CLAMP (a->green + b->green, 0, 255);
result->blue = CLAMP (a->blue + b->blue, 0, 255);
result->alpha = MAX (a->alpha, b->alpha);
}
/**
* clutter_color_subtract:
* @a: a #ClutterColor
* @b: a #ClutterColor
* @result: (out caller-allocates): return location for the result
*
* Subtracts @b from @a and saves the resulting color inside @result.
*
* This function assumes that the components of @a are greater than the
* components of @b; the result is, otherwise, undefined.
*
* The alpha channel of @result is set as the minimum value
* between the alpha channels of @a and @b.
*/
void
clutter_color_subtract (const ClutterColor *a,
const ClutterColor *b,
ClutterColor *result)
{
g_return_if_fail (a != NULL);
g_return_if_fail (b != NULL);
g_return_if_fail (result != NULL);
result->red = CLAMP (a->red - b->red, 0, 255);
result->green = CLAMP (a->green - b->green, 0, 255);
result->blue = CLAMP (a->blue - b->blue, 0, 255);
result->alpha = MIN (a->alpha, b->alpha);
}
/**
* clutter_color_lighten:
* @color: a #ClutterColor
* @result: (out caller-allocates): return location for the lighter color
*
* Lightens @color by a fixed amount, and saves the changed color
* in @result.
*/
void
clutter_color_lighten (const ClutterColor *color,
ClutterColor *result)
{
clutter_color_shade (color, 1.3, result);
}
/**
* clutter_color_darken:
* @color: a #ClutterColor
* @result: (out caller-allocates): return location for the darker color
*
* Darkens @color by a fixed amount, and saves the changed color
* in @result.
*/
void
clutter_color_darken (const ClutterColor *color,
ClutterColor *result)
{
clutter_color_shade (color, 0.7, result);
}
/**
* clutter_color_to_hls:
* @color: a #ClutterColor
* @hue: (out): return location for the hue value or %NULL
* @luminance: (out): return location for the luminance value or %NULL
* @saturation: (out): return location for the saturation value or %NULL
*
* Converts @color to the HLS format.
*
* The @hue value is in the 0 .. 360 range. The @luminance and
* @saturation values are in the 0 .. 1 range.
*/
void
clutter_color_to_hls (const ClutterColor *color,
float *hue,
float *luminance,
float *saturation)
{
float red, green, blue;
float min, max, delta;
float h, l, s;
g_return_if_fail (color != NULL);
red = color->red / 255.0;
green = color->green / 255.0;
blue = color->blue / 255.0;
if (red > green)
{
if (red > blue)
max = red;
else
max = blue;
if (green < blue)
min = green;
else
min = blue;
}
else
{
if (green > blue)
max = green;
else
max = blue;
if (red < blue)
min = red;
else
min = blue;
}
l = (max + min) / 2;
s = 0;
h = 0;
if (max != min)
{
if (l <= 0.5)
s = (max - min) / (max + min);
else
s = (max - min) / (2.0 - max - min);
delta = max - min;
if (red == max)
h = (green - blue) / delta;
else if (green == max)
h = 2.0 + (blue - red) / delta;
else if (blue == max)
h = 4.0 + (red - green) / delta;
h *= 60;
if (h < 0)
h += 360.0;
}
if (hue)
*hue = h;
if (luminance)
*luminance = l;
if (saturation)
*saturation = s;
}
/**
* clutter_color_from_hls:
* @color: (out): return location for a #ClutterColor
* @hue: hue value, in the 0 .. 360 range
* @luminance: luminance value, in the 0 .. 1 range
* @saturation: saturation value, in the 0 .. 1 range
*
* Converts a color expressed in HLS (hue, luminance and saturation)
* values into a #ClutterColor.
*/
void
clutter_color_from_hls (ClutterColor *color,
float hue,
float luminance,
float saturation)
{
float tmp1, tmp2;
float tmp3[3];
float clr[3];
int i;
hue /= 360.0;
if (saturation == 0)
{
color->red = color->green = color->blue = (luminance * 255);
return;
}
if (luminance <= 0.5)
tmp2 = luminance * (1.0 + saturation);
else
tmp2 = luminance + saturation - (luminance * saturation);
tmp1 = 2.0 * luminance - tmp2;
tmp3[0] = hue + 1.0 / 3.0;
tmp3[1] = hue;
tmp3[2] = hue - 1.0 / 3.0;
for (i = 0; i < 3; i++)
{
if (tmp3[i] < 0)
tmp3[i] += 1.0;
if (tmp3[i] > 1)
tmp3[i] -= 1.0;
if (6.0 * tmp3[i] < 1.0)
clr[i] = tmp1 + (tmp2 - tmp1) * tmp3[i] * 6.0;
else if (2.0 * tmp3[i] < 1.0)
clr[i] = tmp2;
else if (3.0 * tmp3[i] < 2.0)
clr[i] = (tmp1 + (tmp2 - tmp1) * ((2.0 / 3.0) - tmp3[i]) * 6.0);
else
clr[i] = tmp1;
}
color->red = floorf (clr[0] * 255.0 + 0.5);
color->green = floorf (clr[1] * 255.0 + 0.5);
color->blue = floorf (clr[2] * 255.0 + 0.5);
}
/**
* clutter_color_shade:
* @color: a #ClutterColor
* @factor: the shade factor to apply
* @result: (out caller-allocates): return location for the shaded color
*
* Shades @color by @factor and saves the modified color into @result.
*/
void
clutter_color_shade (const ClutterColor *color,
gdouble factor,
ClutterColor *result)
{
float h, l, s;
g_return_if_fail (color != NULL);
g_return_if_fail (result != NULL);
clutter_color_to_hls (color, &h, &l, &s);
l = CLAMP (l * factor, 0.0, 1.0);
s = CLAMP (s * factor, 0.0, 1.0);
clutter_color_from_hls (result, h, l, s);
result->alpha = color->alpha;
}
/**
* clutter_color_to_pixel:
* @color: a #ClutterColor
*
* Converts @color into a packed 32 bit integer, containing
* all the four 8 bit channels used by #ClutterColor.
*
* Return value: a packed color
*/
guint32
clutter_color_to_pixel (const ClutterColor *color)
{
g_return_val_if_fail (color != NULL, 0);
return (color->alpha |
color->blue << 8 |
color->green << 16 |
color->red << 24);
}
/**
* clutter_color_from_pixel:
* @color: (out caller-allocates): return location for a #ClutterColor
* @pixel: a 32 bit packed integer containing a color
*
* Converts @pixel from the packed representation of a four 8 bit channel
* color to a #ClutterColor.
*/
void
clutter_color_from_pixel (ClutterColor *color,
guint32 pixel)
{
g_return_if_fail (color != NULL);
color->red = pixel >> 24;
color->green = (pixel >> 16) & 0xff;
color->blue = (pixel >> 8) & 0xff;
color->alpha = pixel & 0xff;
}
static inline void
skip_whitespace (gchar **str)
{
while (g_ascii_isspace (**str))
*str += 1;
}
static inline void
parse_rgb_value (gchar *str,
guint8 *color,
gchar **endp)
{
gdouble number;
gchar *p;
skip_whitespace (&str);
number = g_ascii_strtod (str, endp);
p = *endp;
skip_whitespace (&p);
if (*p == '%')
{
*endp = (gchar *) (p + 1);
*color = CLAMP (number / 100.0, 0.0, 1.0) * 255;
}
else
*color = CLAMP (number, 0, 255);
}
static gboolean
parse_rgba (ClutterColor *color,
gchar *str,
gboolean has_alpha)
{
skip_whitespace (&str);
if (*str != '(')
return FALSE;
str += 1;
/* red */
parse_rgb_value (str, &color->red, &str);
skip_whitespace (&str);
if (*str != ',')
return FALSE;
str += 1;
/* green */
parse_rgb_value (str, &color->green, &str);
skip_whitespace (&str);
if (*str != ',')
return FALSE;
str += 1;
/* blue */
parse_rgb_value (str, &color->blue, &str);
skip_whitespace (&str);
/* alpha (optional); since the alpha channel value can only
* be between 0 and 1 we don't use the parse_rgb_value()
* function
*/
if (has_alpha)
{
gdouble number;
if (*str != ',')
return FALSE;
str += 1;
skip_whitespace (&str);
number = g_ascii_strtod (str, &str);
color->alpha = CLAMP (number * 255.0, 0, 255);
}
else
color->alpha = 255;
skip_whitespace (&str);
if (*str != ')')
return FALSE;
return TRUE;
}
static gboolean
parse_hsla (ClutterColor *color,
gchar *str,
gboolean has_alpha)
{
gdouble number;
gdouble h, l, s;
skip_whitespace (&str);
if (*str != '(')
return FALSE;
str += 1;
/* hue */
skip_whitespace (&str);
/* we don't do any angle normalization here because
* clutter_color_from_hls() will do it for us
*/
number = g_ascii_strtod (str, &str);
skip_whitespace (&str);
if (*str != ',')
return FALSE;
h = number;
str += 1;
/* saturation */
skip_whitespace (&str);
number = g_ascii_strtod (str, &str);
skip_whitespace (&str);
if (*str != '%')
return FALSE;
str += 1;
s = CLAMP (number / 100.0, 0.0, 1.0);
skip_whitespace (&str);
if (*str != ',')
return FALSE;
str += 1;
/* luminance */
skip_whitespace (&str);
number = g_ascii_strtod (str, &str);
skip_whitespace (&str);
if (*str != '%')
return FALSE;
str += 1;
l = CLAMP (number / 100.0, 0.0, 1.0);
skip_whitespace (&str);
/* alpha (optional); since the alpha channel value can only
* be between 0 and 1 we don't use the parse_rgb_value()
* function
*/
if (has_alpha)
{
if (*str != ',')
return FALSE;
str += 1;
skip_whitespace (&str);
number = g_ascii_strtod (str, &str);
color->alpha = CLAMP (number * 255.0, 0, 255);
}
else
color->alpha = 255;
skip_whitespace (&str);
if (*str != ')')
return FALSE;
clutter_color_from_hls (color, h, l, s);
return TRUE;
}
/**
* clutter_color_from_string:
* @color: (out caller-allocates): return location for a #ClutterColor
* @str: a string specifiying a color
*
* Parses a string definition of a color, filling the #ClutterColor.red,
* #ClutterColor.green, #ClutterColor.blue and #ClutterColor.alpha fields
* of @color.
*
* The @color is not allocated.
*
* The format of @str can be either one of:
*
* - a standard name (as taken from the X11 rgb.txt file)
* - an hexadecimal value in the form: `#rgb`, `#rrggbb`, `#rgba`, or `#rrggbbaa`
* - a RGB color in the form: `rgb(r, g, b)`
* - a RGB color in the form: `rgba(r, g, b, a)`
* - a HSL color in the form: `hsl(h, s, l)`
* -a HSL color in the form: `hsla(h, s, l, a)`
*
* where 'r', 'g', 'b' and 'a' are (respectively) the red, green, blue color
* intensities and the opacity. The 'h', 's' and 'l' are (respectively) the
* hue, saturation and luminance values.
*
* In the rgb() and rgba() formats, the 'r', 'g', and 'b' values are either
* integers between 0 and 255, or percentage values in the range between 0%
* and 100%; the percentages require the '%' character. The 'a' value, if
* specified, can only be a floating point value between 0.0 and 1.0.
*
* In the hls() and hlsa() formats, the 'h' value (hue) is an angle between
* 0 and 360.0 degrees; the 'l' and 's' values (luminance and saturation) are
* percentage values in the range between 0% and 100%. The 'a' value, if specified,
* can only be a floating point value between 0.0 and 1.0.
*
* Whitespace inside the definitions is ignored; no leading whitespace
* is allowed.
*
* If the alpha component is not specified then it is assumed to be set to
* be fully opaque.
*
* Return value: %TRUE if parsing succeeded, and %FALSE otherwise
*
* Since: 1.0
*/
gboolean
clutter_color_from_string (ClutterColor *color,
const gchar *str)
{
PangoColor pango_color = { 0, };
g_return_val_if_fail (color != NULL, FALSE);
g_return_val_if_fail (str != NULL, FALSE);
if (strncmp (str, "rgb", 3) == 0)
{
gchar *s = (gchar *) str;
gboolean res;
if (strncmp (str, "rgba", 4) == 0)
res = parse_rgba (color, s + 4, TRUE);
else
res = parse_rgba (color, s + 3, FALSE);
return res;
}
if (strncmp (str, "hsl", 3) == 0)
{
gchar *s = (gchar *) str;
gboolean res;
if (strncmp (str, "hsla", 4) == 0)
res = parse_hsla (color, s + 4, TRUE);
else
res = parse_hsla (color, s + 3, FALSE);
return res;
}
/* if the string contains a color encoded using the hexadecimal
* notations (#rrggbbaa or #rgba) we attempt a rough pass at
* parsing the color ourselves, as we need the alpha channel that
* Pango can't retrieve.
*/
if (str[0] == '#' && str[1] != '\0')
{
gsize length = strlen (str + 1);
gint32 result;
if (sscanf (str + 1, "%x", &result) == 1)
{
switch (length)
{
case 8: /* rrggbbaa */
color->red = (result >> 24) & 0xff;
color->green = (result >> 16) & 0xff;
color->blue = (result >> 8) & 0xff;
color->alpha = result & 0xff;
return TRUE;
case 6: /* #rrggbb */
color->red = (result >> 16) & 0xff;
color->green = (result >> 8) & 0xff;
color->blue = result & 0xff;
color->alpha = 0xff;
return TRUE;
case 4: /* #rgba */
color->red = ((result >> 12) & 0xf);
color->green = ((result >> 8) & 0xf);
color->blue = ((result >> 4) & 0xf);
color->alpha = result & 0xf;
color->red = (color->red << 4) | color->red;
color->green = (color->green << 4) | color->green;
color->blue = (color->blue << 4) | color->blue;
color->alpha = (color->alpha << 4) | color->alpha;
return TRUE;
case 3: /* #rgb */
color->red = ((result >> 8) & 0xf);
color->green = ((result >> 4) & 0xf);
color->blue = result & 0xf;
color->red = (color->red << 4) | color->red;
color->green = (color->green << 4) | color->green;
color->blue = (color->blue << 4) | color->blue;
color->alpha = 0xff;
return TRUE;
default:
return FALSE;
}
}
}
/* fall back to pango for X11-style named colors; see:
*
* http://en.wikipedia.org/wiki/X11_color_names
*
* for a list. at some point we might even ship with our own list generated
* from X11/rgb.txt, like we generate the key symbols.
*/
if (pango_color_parse (&pango_color, str))
{
color->red = pango_color.red;
color->green = pango_color.green;
color->blue = pango_color.blue;
color->alpha = 0xff;
return TRUE;
}
return FALSE;
}
/**
* clutter_color_to_string:
* @color: a #ClutterColor
*
* Returns a textual specification of @color in the hexadecimal form
* #rrggbbaa, where r,
* g, b and a are
* hexadecimal digits representing the red, green, blue and alpha components
* respectively.
*
* Return value: (transfer full): a newly-allocated text string
*
* Since: 0.2
*/
gchar *
clutter_color_to_string (const ClutterColor *color)
{
g_return_val_if_fail (color != NULL, NULL);
return g_strdup_printf ("#%02x%02x%02x%02x",
color->red,
color->green,
color->blue,
color->alpha);
}
/**
* clutter_color_equal:
* @v1: (type Clutter.Color): a #ClutterColor
* @v2: (type Clutter.Color): a #ClutterColor
*
* Compares two #ClutterColors and checks if they are the same.
*
* This function can be passed to g_hash_table_new() as the @key_equal_func
* parameter, when using #ClutterColors as keys in a #GHashTable.
*
* Return value: %TRUE if the two colors are the same.
*
* Since: 0.2
*/
gboolean
clutter_color_equal (gconstpointer v1,
gconstpointer v2)
{
const ClutterColor *a, *b;
g_return_val_if_fail (v1 != NULL, FALSE);
g_return_val_if_fail (v2 != NULL, FALSE);
if (v1 == v2)
return TRUE;
a = v1;
b = v2;
return (a->red == b->red &&
a->green == b->green &&
a->blue == b->blue &&
a->alpha == b->alpha);
}
/**
* clutter_color_hash:
* @v: (type Clutter.Color): a #ClutterColor
*
* Converts a #ClutterColor to a hash value.
*
* This function can be passed to g_hash_table_new() as the @hash_func
* parameter, when using #ClutterColors as keys in a #GHashTable.
*
* Return value: a hash value corresponding to the color
*
* Since: 1.0
*/
guint
clutter_color_hash (gconstpointer v)
{
return clutter_color_to_pixel ((const ClutterColor *) v);
}
/**
* clutter_color_interpolate:
* @initial: the initial #ClutterColor
* @final: the final #ClutterColor
* @progress: the interpolation progress
* @result: (out): return location for the interpolation
*
* Interpolates between @initial and @final #ClutterColors
* using @progress
*
* Since: 1.6
*/
void
clutter_color_interpolate (const ClutterColor *initial,
const ClutterColor *final,
gdouble progress,
ClutterColor *result)
{
g_return_if_fail (initial != NULL);
g_return_if_fail (final != NULL);
g_return_if_fail (result != NULL);
result->red = initial->red + (final->red - initial->red) * progress;
result->green = initial->green + (final->green - initial->green) * progress;
result->blue = initial->blue + (final->blue - initial->blue) * progress;
result->alpha = initial->alpha + (final->alpha - initial->alpha) * progress;
}
static gboolean
clutter_color_progress (const GValue *a,
const GValue *b,
gdouble progress,
GValue *retval)
{
const ClutterColor *a_color = clutter_value_get_color (a);
const ClutterColor *b_color = clutter_value_get_color (b);
ClutterColor res = { 0, };
clutter_color_interpolate (a_color, b_color, progress, &res);
clutter_value_set_color (retval, &res);
return TRUE;
}
/**
* clutter_color_copy:
* @color: a #ClutterColor
*
* Makes a copy of the color structure. The result must be
* freed using clutter_color_free().
*
* Return value: (transfer full): an allocated copy of @color.
*
* Since: 0.2
*/
ClutterColor *
clutter_color_copy (const ClutterColor *color)
{
if (G_LIKELY (color != NULL))
return g_slice_dup (ClutterColor, color);
return NULL;
}
/**
* clutter_color_free:
* @color: a #ClutterColor
*
* Frees a color structure created with clutter_color_copy().
*
* Since: 0.2
*/
void
clutter_color_free (ClutterColor *color)
{
if (G_LIKELY (color != NULL))
g_slice_free (ClutterColor, color);
}
/**
* clutter_color_new:
* @red: red component of the color, between 0 and 255
* @green: green component of the color, between 0 and 255
* @blue: blue component of the color, between 0 and 255
* @alpha: alpha component of the color, between 0 and 255
*
* Creates a new #ClutterColor with the given values.
*
* This function is the equivalent of:
*
* |[
* clutter_color_init (clutter_color_alloc (), red, green, blue, alpha);
* ]|
*
* Return value: (transfer full): the newly allocated color.
* Use clutter_color_free() when done
*
* Since: 0.8
*/
ClutterColor *
clutter_color_new (guint8 red,
guint8 green,
guint8 blue,
guint8 alpha)
{
return clutter_color_init (clutter_color_alloc (),
red,
green,
blue,
alpha);
}
/**
* clutter_color_alloc: (constructor)
*
* Allocates a new, transparent black #ClutterColor.
*
* Return value: (transfer full): the newly allocated #ClutterColor; use
* clutter_color_free() to free its resources
*
* Since: 1.12
*/
ClutterColor *
clutter_color_alloc (void)
{
return g_slice_new0 (ClutterColor);
}
/**
* clutter_color_init:
* @color: a #ClutterColor
* @red: red component of the color, between 0 and 255
* @green: green component of the color, between 0 and 255
* @blue: blue component of the color, between 0 and 255
* @alpha: alpha component of the color, between 0 and 255
*
* Initializes @color with the given values.
*
* Return value: (transfer none): the initialized #ClutterColor
*
* Since: 1.12
*/
ClutterColor *
clutter_color_init (ClutterColor *color,
guint8 red,
guint8 green,
guint8 blue,
guint8 alpha)
{
g_return_val_if_fail (color != NULL, NULL);
color->red = red;
color->green = green;
color->blue = blue;
color->alpha = alpha;
return color;
}
static void
clutter_value_transform_color_string (const GValue *src,
GValue *dest)
{
const ClutterColor *color = g_value_get_boxed (src);
if (color)
{
gchar *string = clutter_color_to_string (color);
g_value_take_string (dest, string);
}
else
g_value_set_string (dest, NULL);
}
static void
clutter_value_transform_string_color (const GValue *src,
GValue *dest)
{
const char *str = g_value_get_string (src);
if (str)
{
ClutterColor color = { 0, };
clutter_color_from_string (&color, str);
clutter_value_set_color (dest, &color);
}
else
clutter_value_set_color (dest, NULL);
}
G_DEFINE_BOXED_TYPE_WITH_CODE (ClutterColor, clutter_color,
clutter_color_copy,
clutter_color_free,
CLUTTER_REGISTER_VALUE_TRANSFORM_TO (G_TYPE_STRING, clutter_value_transform_color_string)
CLUTTER_REGISTER_VALUE_TRANSFORM_FROM (G_TYPE_STRING, clutter_value_transform_string_color)
CLUTTER_REGISTER_INTERVAL_PROGRESS (clutter_color_progress));
/**
* clutter_value_set_color:
* @value: a #GValue initialized to #CLUTTER_TYPE_COLOR
* @color: the color to set
*
* Sets @value to @color.
*
* Since: 0.8
*/
void
clutter_value_set_color (GValue *value,
const ClutterColor *color)
{
g_return_if_fail (CLUTTER_VALUE_HOLDS_COLOR (value));
g_value_set_boxed (value, color);
}
/**
* clutter_value_get_color:
* @value: a #GValue initialized to #CLUTTER_TYPE_COLOR
*
* Gets the #ClutterColor contained in @value.
*
* Return value: (transfer none): the color inside the passed #GValue
*
* Since: 0.8
*/
const ClutterColor *
clutter_value_get_color (const GValue *value)
{
g_return_val_if_fail (CLUTTER_VALUE_HOLDS_COLOR (value), NULL);
return g_value_get_boxed (value);
}
static void
param_color_init (GParamSpec *pspec)
{
ClutterParamSpecColor *cspec = CLUTTER_PARAM_SPEC_COLOR (pspec);
cspec->default_value = NULL;
}
static void
param_color_finalize (GParamSpec *pspec)
{
ClutterParamSpecColor *cspec = CLUTTER_PARAM_SPEC_COLOR (pspec);
clutter_color_free (cspec->default_value);
}
static void
param_color_set_default (GParamSpec *pspec,
GValue *value)
{
const ClutterColor *default_value =
CLUTTER_PARAM_SPEC_COLOR (pspec)->default_value;
clutter_value_set_color (value, default_value);
}
static gint
param_color_values_cmp (GParamSpec *pspec,
const GValue *value1,
const GValue *value2)
{
const ClutterColor *color1 = g_value_get_boxed (value1);
const ClutterColor *color2 = g_value_get_boxed (value2);
int pixel1, pixel2;
if (color1 == NULL)
return color2 == NULL ? 0 : -1;
pixel1 = clutter_color_to_pixel (color1);
pixel2 = clutter_color_to_pixel (color2);
if (pixel1 < pixel2)
return -1;
else if (pixel1 == pixel2)
return 0;
else
return 1;
}
GType
clutter_param_color_get_type (void)
{
static GType pspec_type = 0;
if (G_UNLIKELY (pspec_type == 0))
{
const GParamSpecTypeInfo pspec_info = {
sizeof (ClutterParamSpecColor),
16,
param_color_init,
CLUTTER_TYPE_COLOR,
param_color_finalize,
param_color_set_default,
NULL,
param_color_values_cmp,
};
pspec_type = g_param_type_register_static (I_("ClutterParamSpecColor"),
&pspec_info);
}
return pspec_type;
}
/**
* clutter_param_spec_color: (skip)
* @name: name of the property
* @nick: short name
* @blurb: description (can be translatable)
* @default_value: default value
* @flags: flags for the param spec
*
* Creates a #GParamSpec for properties using #ClutterColor.
*
* Return value: the newly created #GParamSpec
*
* Since: 0.8
*/
GParamSpec *
clutter_param_spec_color (const gchar *name,
const gchar *nick,
const gchar *blurb,
const ClutterColor *default_value,
GParamFlags flags)
{
ClutterParamSpecColor *cspec;
cspec = g_param_spec_internal (CLUTTER_TYPE_PARAM_COLOR,
name, nick, blurb, flags);
cspec->default_value = clutter_color_copy (default_value);
return G_PARAM_SPEC (cspec);
}
muffin-6.4.1/clutter/clutter/clutter-layout-manager.h 0000664 0001750 0001750 00000026735 14723361714 021701 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2009 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_LAYOUT_MANAGER_H__
#define __CLUTTER_LAYOUT_MANAGER_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_LAYOUT_MANAGER (clutter_layout_manager_get_type ())
#define CLUTTER_LAYOUT_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_LAYOUT_MANAGER, ClutterLayoutManager))
#define CLUTTER_IS_LAYOUT_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_LAYOUT_MANAGER))
#define CLUTTER_LAYOUT_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_LAYOUT_MANAGER, ClutterLayoutManagerClass))
#define CLUTTER_IS_LAYOUT_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_LAYOUT_MANAGER))
#define CLUTTER_LAYOUT_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_LAYOUT_MANAGER, ClutterLayoutManagerClass))
typedef struct _ClutterLayoutManagerClass ClutterLayoutManagerClass;
/**
* ClutterLayoutManager:
*
* The #ClutterLayoutManager structure contains only private data
* and should be accessed using the provided API
*
* Since: 1.2
*/
struct _ClutterLayoutManager
{
/*< private >*/
GInitiallyUnowned parent_instance;
gpointer CLUTTER_PRIVATE_FIELD (dummy);
};
/**
* ClutterLayoutManagerClass:
* @get_preferred_width: virtual function; override to provide a preferred
* width for the layout manager. See also the get_preferred_width()
* virtual function in #ClutterActor
* @get_preferred_height: virtual function; override to provide a preferred
* height for the layout manager. See also the get_preferred_height()
* virtual function in #ClutterActor
* @allocate: virtual function; override to allocate the children of the
* layout manager. See also the allocate() virtual function in
* #ClutterActor
* @set_container: virtual function; override to set a back pointer
* on the #ClutterContainer using the layout manager. The implementation
* should not take a reference on the container, but just take a weak
* reference, to avoid potential leaks due to reference cycles
* @get_child_meta_type: virtual function; override to return the #GType
* of the #ClutterLayoutMeta sub-class used by the #ClutterLayoutManager
* @create_child_meta: virtual function; override to create a
* #ClutterLayoutMeta instance associated to a #ClutterContainer and a
* child #ClutterActor, used to maintain layout manager specific properties
* @begin_animation: virtual function; override to control the animation
* of a #ClutterLayoutManager with the given duration and easing mode.
* This virtual function is deprecated, and it should not be overridden
* in newly written code.
* @end_animation: virtual function; override to end an animation started
* by clutter_layout_manager_begin_animation(). This virtual function is
* deprecated, and it should not be overriden in newly written code.
* @get_animation_progress: virtual function; override to control the
* progress of the animation of a #ClutterLayoutManager. This virtual
* function is deprecated, and it should not be overridden in newly written
* code.
* @layout_changed: class handler for the #ClutterLayoutManager::layout-changed
* signal
*
* The #ClutterLayoutManagerClass structure contains only private
* data and should be accessed using the provided API
*
* Since: 1.2
*/
struct _ClutterLayoutManagerClass
{
/*< private >*/
GInitiallyUnownedClass parent_class;
/*< public >*/
void (* get_preferred_width) (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p);
void (* get_preferred_height) (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_width,
gfloat *min_height_p,
gfloat *nat_height_p);
void (* allocate) (ClutterLayoutManager *manager,
ClutterContainer *container,
const ClutterActorBox *allocation,
ClutterAllocationFlags flags);
void (* set_container) (ClutterLayoutManager *manager,
ClutterContainer *container);
GType (* get_child_meta_type) (ClutterLayoutManager *manager);
ClutterLayoutMeta *(* create_child_meta) (ClutterLayoutManager *manager,
ClutterContainer *container,
ClutterActor *actor);
/* deprecated */
ClutterAlpha * (* begin_animation) (ClutterLayoutManager *manager,
guint duration,
gulong mode);
/* deprecated */
gdouble (* get_animation_progress) (ClutterLayoutManager *manager);
/* deprecated */
void (* end_animation) (ClutterLayoutManager *manager);
void (* layout_changed) (ClutterLayoutManager *manager);
/*< private >*/
/* padding for future expansion */
void (* _clutter_padding_1) (void);
void (* _clutter_padding_2) (void);
void (* _clutter_padding_3) (void);
void (* _clutter_padding_4) (void);
void (* _clutter_padding_5) (void);
void (* _clutter_padding_6) (void);
void (* _clutter_padding_7) (void);
void (* _clutter_padding_8) (void);
};
CLUTTER_EXPORT
GType clutter_layout_manager_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
void clutter_layout_manager_get_preferred_width (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p);
CLUTTER_EXPORT
void clutter_layout_manager_get_preferred_height (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_width,
gfloat *min_height_p,
gfloat *nat_height_p);
CLUTTER_EXPORT
void clutter_layout_manager_allocate (ClutterLayoutManager *manager,
ClutterContainer *container,
const ClutterActorBox *allocation,
ClutterAllocationFlags flags);
CLUTTER_EXPORT
void clutter_layout_manager_set_container (ClutterLayoutManager *manager,
ClutterContainer *container);
CLUTTER_EXPORT
void clutter_layout_manager_layout_changed (ClutterLayoutManager *manager);
CLUTTER_EXPORT
GParamSpec * clutter_layout_manager_find_child_property (ClutterLayoutManager *manager,
const gchar *name);
CLUTTER_EXPORT
GParamSpec ** clutter_layout_manager_list_child_properties (ClutterLayoutManager *manager,
guint *n_pspecs);
CLUTTER_EXPORT
ClutterLayoutMeta *clutter_layout_manager_get_child_meta (ClutterLayoutManager *manager,
ClutterContainer *container,
ClutterActor *actor);
CLUTTER_EXPORT
void clutter_layout_manager_child_set (ClutterLayoutManager *manager,
ClutterContainer *container,
ClutterActor *actor,
const gchar *first_property,
...) G_GNUC_NULL_TERMINATED;
CLUTTER_EXPORT
void clutter_layout_manager_child_get (ClutterLayoutManager *manager,
ClutterContainer *container,
ClutterActor *actor,
const gchar *first_property,
...) G_GNUC_NULL_TERMINATED;
CLUTTER_EXPORT
void clutter_layout_manager_child_set_property (ClutterLayoutManager *manager,
ClutterContainer *container,
ClutterActor *actor,
const gchar *property_name,
const GValue *value);
CLUTTER_EXPORT
void clutter_layout_manager_child_get_property (ClutterLayoutManager *manager,
ClutterContainer *container,
ClutterActor *actor,
const gchar *property_name,
GValue *value);
G_END_DECLS
#endif /* __CLUTTER_LAYOUT_MANAGER_H__ */
muffin-6.4.1/clutter/clutter/clutter-settings-private.h 0000664 0001750 0001750 00000001357 14723361714 022255 0 ustar fabio fabio #ifndef __CLUTTER_SETTINGS_PRIVATE_H__
#define __CLUTTER_SETTINGS_PRIVATE_H__
#include
#include
G_BEGIN_DECLS
void _clutter_settings_set_backend (ClutterSettings *settings,
ClutterBackend *backend);
void _clutter_settings_read_from_key_file (ClutterSettings *settings,
GKeyFile *key_file);
void clutter_settings_set_property_internal (ClutterSettings *settings,
const char *property,
GValue *value);
G_END_DECLS
#endif /* __CLUTTER_SETTINGS_PRIVATE_H__ */
muffin-6.4.1/clutter/clutter/clutter-image.h 0000664 0001750 0001750 00000012016 14723361714 020021 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive image' library.
*
* Copyright (C) 2012 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_IMAGE_H__
#define __CLUTTER_IMAGE_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_IMAGE (clutter_image_get_type ())
#define CLUTTER_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_IMAGE, ClutterImage))
#define CLUTTER_IS_IMAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_IMAGE))
#define CLUTTER_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_IMAGE, ClutterImageClass))
#define CLUTTER_IS_IMAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_IMAGE))
#define CLUTTER_IMAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_IMAGE, ClutterImageClass))
/**
* CLUTTER_IMAGE_ERROR:
*
* Error domain for the #ClutterImageError enumeration.
*
* Since: 1.10
*/
#define CLUTTER_IMAGE_ERROR (clutter_image_error_quark ())
typedef struct _ClutterImage ClutterImage;
typedef struct _ClutterImagePrivate ClutterImagePrivate;
typedef struct _ClutterImageClass ClutterImageClass;
/**
* ClutterImageError:
* @CLUTTER_IMAGE_ERROR_INVALID_DATA: Invalid data passed to the
* clutter_image_set_data() function.
*
* Error enumeration for #ClutterImage.
*
* Since: 1.10
*/
typedef enum
{
CLUTTER_IMAGE_ERROR_INVALID_DATA
} ClutterImageError;
/**
* ClutterImage:
*
* The #ClutterImage structure contains
* private data and should only be accessed using the provided
* API.
*
* Since: 1.10
*/
struct _ClutterImage
{
/*< private >*/
GObject parent_instance;
ClutterImagePrivate *priv;
};
/**
* ClutterImageClass:
*
* The #ClutterImageClass structure contains
* private data.
*
* Since: 1.10
*/
struct _ClutterImageClass
{
/*< private >*/
GObjectClass parent_class;
gpointer _padding[16];
};
CLUTTER_EXPORT
GQuark clutter_image_error_quark (void);
CLUTTER_EXPORT
GType clutter_image_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterContent * clutter_image_new (void);
CLUTTER_EXPORT
gboolean clutter_image_set_data (ClutterImage *image,
const guint8 *data,
CoglPixelFormat pixel_format,
guint width,
guint height,
guint row_stride,
GError **error);
CLUTTER_EXPORT
gboolean clutter_image_set_area (ClutterImage *image,
const guint8 *data,
CoglPixelFormat pixel_format,
const cairo_rectangle_int_t *rect,
guint row_stride,
GError **error);
CLUTTER_EXPORT
gboolean clutter_image_set_bytes (ClutterImage *image,
GBytes *data,
CoglPixelFormat pixel_format,
guint width,
guint height,
guint row_stride,
GError **error);
CLUTTER_EXPORT
CoglTexture * clutter_image_get_texture (ClutterImage *image);
G_END_DECLS
#endif /* __CLUTTER_IMAGE_H__ */
muffin-6.4.1/clutter/clutter/clutter-main.h 0000664 0001750 0001750 00000020524 14723361714 017666 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum
*
* Copyright (C) 2006 OpenedHand
*
* 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 .
*/
#ifndef __CLUTTER_MAIN_H__
#define __CLUTTER_MAIN_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
#include
G_BEGIN_DECLS
typedef enum
{
CLUTTER_DEBUG_MISC = 1 << 0,
CLUTTER_DEBUG_ACTOR = 1 << 1,
CLUTTER_DEBUG_TEXTURE = 1 << 2,
CLUTTER_DEBUG_EVENT = 1 << 3,
CLUTTER_DEBUG_PAINT = 1 << 4,
CLUTTER_DEBUG_PANGO = 1 << 5,
CLUTTER_DEBUG_BACKEND = 1 << 6,
CLUTTER_DEBUG_SCHEDULER = 1 << 7,
CLUTTER_DEBUG_SCRIPT = 1 << 8,
CLUTTER_DEBUG_SHADER = 1 << 9,
CLUTTER_DEBUG_MULTISTAGE = 1 << 10,
CLUTTER_DEBUG_ANIMATION = 1 << 11,
CLUTTER_DEBUG_LAYOUT = 1 << 12,
CLUTTER_DEBUG_PICK = 1 << 13,
CLUTTER_DEBUG_EVENTLOOP = 1 << 14,
CLUTTER_DEBUG_CLIPPING = 1 << 15,
CLUTTER_DEBUG_OOB_TRANSFORMS = 1 << 16,
} ClutterDebugFlag;
typedef enum
{
CLUTTER_DEBUG_NOP_PICKING = 1 << 0,
} ClutterPickDebugFlag;
typedef enum
{
CLUTTER_DEBUG_DISABLE_SWAP_EVENTS = 1 << 0,
CLUTTER_DEBUG_DISABLE_CLIPPED_REDRAWS = 1 << 1,
CLUTTER_DEBUG_REDRAWS = 1 << 2,
CLUTTER_DEBUG_PAINT_VOLUMES = 1 << 3,
CLUTTER_DEBUG_DISABLE_CULLING = 1 << 4,
CLUTTER_DEBUG_DISABLE_OFFSCREEN_REDIRECT = 1 << 5,
CLUTTER_DEBUG_CONTINUOUS_REDRAW = 1 << 6,
CLUTTER_DEBUG_PAINT_DEFORM_TILES = 1 << 7,
CLUTTER_DEBUG_PAINT_DAMAGE_REGION = 1 << 8,
} ClutterDrawDebugFlag;
/**
* CLUTTER_INIT_ERROR:
*
* #GError domain for #ClutterInitError
*/
#define CLUTTER_INIT_ERROR (clutter_init_error_quark ())
/**
* ClutterInitError:
* @CLUTTER_INIT_SUCCESS: Initialisation successful
* @CLUTTER_INIT_ERROR_UNKNOWN: Unknown error
* @CLUTTER_INIT_ERROR_THREADS: Thread initialisation failed
* @CLUTTER_INIT_ERROR_BACKEND: Backend initialisation failed
* @CLUTTER_INIT_ERROR_INTERNAL: Internal error
*
* Error conditions returned by clutter_init() and clutter_init_with_args().
*
* Since: 0.2
*/
typedef enum
{
CLUTTER_INIT_SUCCESS = 1,
CLUTTER_INIT_ERROR_UNKNOWN = 0,
CLUTTER_INIT_ERROR_THREADS = -1,
CLUTTER_INIT_ERROR_BACKEND = -2,
CLUTTER_INIT_ERROR_INTERNAL = -3
} ClutterInitError;
CLUTTER_EXPORT
GQuark clutter_init_error_quark (void);
/**
* CLUTTER_PRIORITY_REDRAW:
*
* Priority of the redraws. This is chosen to be lower than the GTK+
* redraw and resize priorities, because in application with both
* GTK+ and Clutter it's more likely that the Clutter part will be
* continually animating (and thus able to starve GTK+) than
* vice-versa.
*
* Since: 0.8
*/
#define CLUTTER_PRIORITY_REDRAW (G_PRIORITY_HIGH_IDLE + 50)
/* Initialisation */
CLUTTER_EXPORT
void clutter_base_init (void);
CLUTTER_EXPORT
ClutterInitError clutter_init (int *argc,
char ***argv) G_GNUC_WARN_UNUSED_RESULT;
CLUTTER_EXPORT
ClutterInitError clutter_init_with_args (int *argc,
char ***argv,
const char *parameter_string,
GOptionEntry *entries,
const char *translation_domain,
GError **error) G_GNUC_WARN_UNUSED_RESULT;
CLUTTER_EXPORT
GOptionGroup * clutter_get_option_group (void);
CLUTTER_EXPORT
GOptionGroup * clutter_get_option_group_without_init (void);
/* Mainloop */
CLUTTER_EXPORT
void clutter_main (void);
CLUTTER_EXPORT
void clutter_main_quit (void);
CLUTTER_EXPORT
gint clutter_main_level (void);
CLUTTER_EXPORT
void clutter_do_event (ClutterEvent *event);
/* Debug utility functions */
CLUTTER_EXPORT
gboolean clutter_get_accessibility_enabled (void);
CLUTTER_EXPORT
void clutter_disable_accessibility (void);
/* Threading functions */
CLUTTER_EXPORT
guint clutter_threads_add_idle (GSourceFunc func,
gpointer data);
CLUTTER_EXPORT
guint clutter_threads_add_idle_full (gint priority,
GSourceFunc func,
gpointer data,
GDestroyNotify notify);
CLUTTER_EXPORT
guint clutter_threads_add_timeout (guint interval,
GSourceFunc func,
gpointer data);
CLUTTER_EXPORT
guint clutter_threads_add_timeout_full (gint priority,
guint interval,
GSourceFunc func,
gpointer data,
GDestroyNotify notify);
CLUTTER_EXPORT
guint clutter_threads_add_repaint_func (GSourceFunc func,
gpointer data,
GDestroyNotify notify);
CLUTTER_EXPORT
guint clutter_threads_add_repaint_func_full (ClutterRepaintFlags flags,
GSourceFunc func,
gpointer data,
GDestroyNotify notify);
CLUTTER_EXPORT
void clutter_threads_remove_repaint_func (guint handle_id);
CLUTTER_EXPORT
PangoFontMap * clutter_get_font_map (void);
CLUTTER_EXPORT
ClutterTextDirection clutter_get_default_text_direction (void);
CLUTTER_EXPORT
guint clutter_get_default_frame_rate (void);
CLUTTER_EXPORT
gboolean clutter_check_windowing_backend (const char *backend_type);
CLUTTER_EXPORT
void clutter_add_debug_flags (ClutterDebugFlag debug_flags,
ClutterDrawDebugFlag draw_flags,
ClutterPickDebugFlag pick_flags);
CLUTTER_EXPORT
void clutter_remove_debug_flags (ClutterDebugFlag debug_flags,
ClutterDrawDebugFlag draw_flags,
ClutterPickDebugFlag pick_flags);
G_END_DECLS
#endif /* _CLUTTER_MAIN_H__ */
muffin-6.4.1/clutter/clutter/clutter-input-method.h 0000664 0001750 0001750 00000007542 14723361714 021364 0 ustar fabio fabio /*
* Copyright (C) 2017,2018 Red Hat
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program 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
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
* Author: Carlos Garnacho
*/
#ifndef __CLUTTER_INPUT_METHOD_H__
#define __CLUTTER_INPUT_METHOD_H__
#include
#define CLUTTER_TYPE_INPUT_METHOD (clutter_input_method_get_type ())
CLUTTER_EXPORT
G_DECLARE_DERIVABLE_TYPE (ClutterInputMethod, clutter_input_method,
CLUTTER, INPUT_METHOD, GObject)
typedef struct _ClutterInputMethodClass ClutterInputMethodClass;
struct _ClutterInputMethodClass
{
GObjectClass parent_class;
void (* focus_in) (ClutterInputMethod *im,
ClutterInputFocus *actor);
void (* focus_out) (ClutterInputMethod *im);
void (* reset) (ClutterInputMethod *im);
void (* set_cursor_location) (ClutterInputMethod *im,
const graphene_rect_t *rect);
void (* set_surrounding) (ClutterInputMethod *im,
const gchar *text,
guint cursor,
guint anchor);
void (* update_content_hints) (ClutterInputMethod *im,
ClutterInputContentHintFlags hint);
void (* update_content_purpose) (ClutterInputMethod *im,
ClutterInputContentPurpose purpose);
gboolean (* filter_key_event) (ClutterInputMethod *im,
const ClutterEvent *key);
};
CLUTTER_EXPORT
void clutter_input_method_focus_in (ClutterInputMethod *im,
ClutterInputFocus *focus);
CLUTTER_EXPORT
void clutter_input_method_focus_out (ClutterInputMethod *im);
CLUTTER_EXPORT
void clutter_input_method_commit (ClutterInputMethod *im,
const gchar *text);
CLUTTER_EXPORT
void clutter_input_method_delete_surrounding (ClutterInputMethod *im,
int offset,
guint len);
CLUTTER_EXPORT
void clutter_input_method_request_surrounding (ClutterInputMethod *im);
CLUTTER_EXPORT
void clutter_input_method_set_preedit_text (ClutterInputMethod *im,
const gchar *preedit,
guint cursor);
CLUTTER_EXPORT
void clutter_input_method_notify_key_event (ClutterInputMethod *im,
const ClutterEvent *event,
gboolean filtered);
CLUTTER_EXPORT
void clutter_input_method_set_input_panel_state (ClutterInputMethod *im,
ClutterInputPanelState state);
CLUTTER_EXPORT
void clutter_input_method_forward_key (ClutterInputMethod *im,
uint32_t keyval,
uint32_t keycode,
uint32_t state,
uint64_t time_,
gboolean press);
#endif /* __CLUTTER_INPUT_METHOD_H__ */
muffin-6.4.1/clutter/clutter/clutter-path-constraint.h 0000664 0001750 0001750 00000005163 14723361714 022062 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_PATH_CONSTRAINT_H__
#define __CLUTTER_PATH_CONSTRAINT_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_PATH_CONSTRAINT (clutter_path_constraint_get_type ())
#define CLUTTER_PATH_CONSTRAINT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_PATH_CONSTRAINT, ClutterPathConstraint))
#define CLUTTER_IS_PATH_CONSTRAINT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_PATH_CONSTRAINT))
/**
* ClutterPathConstraint:
*
* #ClutterPathConstraint is an opaque structure
* whose members cannot be directly accessed
*
* Since: 1.6
*/
typedef struct _ClutterPathConstraint ClutterPathConstraint;
typedef struct _ClutterPathConstraintClass ClutterPathConstraintClass;
CLUTTER_EXPORT
GType clutter_path_constraint_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterConstraint *clutter_path_constraint_new (ClutterPath *path,
gfloat offset);
CLUTTER_EXPORT
void clutter_path_constraint_set_path (ClutterPathConstraint *constraint,
ClutterPath *path);
CLUTTER_EXPORT
ClutterPath * clutter_path_constraint_get_path (ClutterPathConstraint *constraint);
CLUTTER_EXPORT
void clutter_path_constraint_set_offset (ClutterPathConstraint *constraint,
gfloat offset);
CLUTTER_EXPORT
gfloat clutter_path_constraint_get_offset (ClutterPathConstraint *constraint);
G_END_DECLS
#endif /* __CLUTTER_PATH_CONSTRAINT_H__ */
muffin-6.4.1/clutter/clutter/clutter-id-pool.h 0000664 0001750 0001750 00000003207 14723361714 020304 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum
*
* Copyright (C) 2008 OpenedHand
*
* 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 .
*
* ClutterIDPool: pool of reusable integer ids associated with pointers.
*
* Author: Øyvind Kolås
*/
#ifndef __CLUTTER_ID_POOL_H__
#define __CLUTTER_ID_POOL_H__
#include
G_BEGIN_DECLS
typedef struct _ClutterIDPool ClutterIDPool;
ClutterIDPool * _clutter_id_pool_new (guint initial_size);
void _clutter_id_pool_free (ClutterIDPool *id_pool);
guint32 _clutter_id_pool_add (ClutterIDPool *id_pool,
gpointer ptr);
void _clutter_id_pool_remove (ClutterIDPool *id_pool,
guint32 id_);
gpointer _clutter_id_pool_lookup (ClutterIDPool *id_pool,
guint32 id_);
G_END_DECLS
#endif /* __CLUTTER_ID_POOL_H__ */
muffin-6.4.1/clutter/clutter/clutter-tap-action.h 0000664 0001750 0001750 00000006577 14723361714 021015 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
* Copyright (C) 2011 Robert Bosch Car Multimedia GmbH.
* Copyright (C) 2012 Collabora Ltd.
*
* 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 .
*
* Author:
* Emanuele Aina
*
* Based on ClutterPanAction
* Based on ClutterDragAction, ClutterSwipeAction, and MxKineticScrollView,
* written by:
* Emmanuele Bassi
* Tomeu Vizoso
* Chris Lord
*/
#ifndef __CLUTTER_TAP_ACTION_H__
#define __CLUTTER_TAP_ACTION_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_TAP_ACTION (clutter_tap_action_get_type ())
#define CLUTTER_TAP_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_TAP_ACTION, ClutterTapAction))
#define CLUTTER_IS_TAP_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_TAP_ACTION))
#define CLUTTER_TAP_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_TAP_ACTION, ClutterTapActionClass))
#define CLUTTER_IS_TAP_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_TAP_ACTION))
#define CLUTTER_TAP_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_TAP_ACTION, ClutterTapActionClass))
typedef struct _ClutterTapAction ClutterTapAction;
typedef struct _ClutterTapActionPrivate ClutterTapActionPrivate;
typedef struct _ClutterTapActionClass ClutterTapActionClass;
/**
* ClutterTapAction:
*
* The #ClutterTapAction structure contains
* only private data and should be accessed using the provided API
*
* Since: 1.14
*/
struct _ClutterTapAction
{
/*< private >*/
ClutterGestureAction parent_instance;
};
/**
* ClutterTapActionClass:
* @tap: class handler for the #ClutterTapAction::tap signal
*
* The #ClutterTapActionClass structure contains
* only private data.
*/
struct _ClutterTapActionClass
{
/*< private >*/
ClutterGestureActionClass parent_class;
/*< public >*/
gboolean (* tap) (ClutterTapAction *action,
ClutterActor *actor);
/*< private >*/
void (* _clutter_tap_action1) (void);
void (* _clutter_tap_action2) (void);
void (* _clutter_tap_action3) (void);
void (* _clutter_tap_action4) (void);
void (* _clutter_tap_action5) (void);
void (* _clutter_tap_action6) (void);
};
CLUTTER_EXPORT
GType clutter_tap_action_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterAction * clutter_tap_action_new (void);
G_END_DECLS
#endif /* __CLUTTER_TAP_ACTION_H__ */
muffin-6.4.1/clutter/clutter/clutter-graphene.c 0000664 0001750 0001750 00000006455 14723361714 020535 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Georges Basile Stavracas Neto
*
* Copyright (C) 2019 Endless, Inc
* Copyright (C) 2009, 2010 Intel Corp
*
* 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 .
*/
#include "clutter-build-config.h"
#include "clutter-graphene.h"
#include "clutter-private.h"
#include "clutter-types.h"
static gboolean
graphene_point_progress (const GValue *a,
const GValue *b,
double progress,
GValue *retval)
{
const graphene_point_t *ap = g_value_get_boxed (a);
const graphene_point_t *bp = g_value_get_boxed (b);
graphene_point_t res;
graphene_point_interpolate (ap, bp, progress, &res);
g_value_set_boxed (retval, &res);
return TRUE;
}
static gboolean
graphene_point3d_progress (const GValue *a,
const GValue *b,
double progress,
GValue *retval)
{
const graphene_point3d_t *av = g_value_get_boxed (a);
const graphene_point3d_t *bv = g_value_get_boxed (b);
graphene_point3d_t res;
graphene_point3d_interpolate (av, bv, progress, &res);
g_value_set_boxed (retval, &res);
return TRUE;
}
static gboolean
graphene_rect_progress (const GValue *a,
const GValue *b,
double progress,
GValue *retval)
{
const graphene_rect_t *rect_a = g_value_get_boxed (a);
const graphene_rect_t *rect_b = g_value_get_boxed (b);
graphene_rect_t res;
graphene_rect_interpolate (rect_a, rect_b, progress, &res);
g_value_set_boxed (retval, &res);
return TRUE;
}
static gboolean
graphene_size_progress (const GValue *a,
const GValue *b,
double progress,
GValue *retval)
{
const graphene_size_t *as = g_value_get_boxed (a);
const graphene_size_t *bs = g_value_get_boxed (b);
graphene_size_t res;
graphene_size_interpolate (as, bs, progress, &res);
g_value_set_boxed (retval, &res);
return TRUE;
}
void
clutter_graphene_init (void)
{
clutter_interval_register_progress_func (GRAPHENE_TYPE_POINT,
graphene_point_progress);
clutter_interval_register_progress_func (GRAPHENE_TYPE_POINT3D,
graphene_point3d_progress);
clutter_interval_register_progress_func (GRAPHENE_TYPE_RECT,
graphene_rect_progress);
clutter_interval_register_progress_func (GRAPHENE_TYPE_SIZE,
graphene_size_progress);
}
muffin-6.4.1/clutter/clutter/clutter-constraint.h 0000664 0001750 0001750 00000012556 14723361714 021134 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_CONSTRAINT_H__
#define __CLUTTER_CONSTRAINT_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_CONSTRAINT (clutter_constraint_get_type ())
#define CLUTTER_CONSTRAINT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_CONSTRAINT, ClutterConstraint))
#define CLUTTER_IS_CONSTRAINT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_CONSTRAINT))
#define CLUTTER_CONSTRAINT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_CONSTRAINT, ClutterConstraintClass))
#define CLUTTER_IS_CONSTRAINT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_CONSTRAINT))
#define CLUTTER_CONSTRAINT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_CONSTRAINT, ClutterConstraintClass))
typedef struct _ClutterConstraintClass ClutterConstraintClass;
/**
* ClutterConstraint:
*
* The #ClutterConstraint structure contains only
* private data and should be accessed using the provided API
*
* Since: 1.4
*/
struct _ClutterConstraint
{
/*< private >*/
ClutterActorMeta parent_instance;
};
/**
* ClutterConstraintClass:
* @update_allocation: virtual function used to update the allocation
* of the #ClutterActor using the #ClutterConstraint
* @update_preferred_size: virtual function used to update the preferred
* size of the #ClutterActor using the #ClutterConstraint; optional,
* since 1.22
*
* The #ClutterConstraintClass structure contains
* only private data
*
* Since: 1.4
*/
struct _ClutterConstraintClass
{
/*< private >*/
ClutterActorMetaClass parent_class;
/*< public >*/
void (* update_allocation) (ClutterConstraint *constraint,
ClutterActor *actor,
ClutterActorBox *allocation);
void (* update_preferred_size) (ClutterConstraint *constraint,
ClutterActor *actor,
ClutterOrientation direction,
float for_size,
float *minimum_size,
float *natural_size);
/*< private >*/
void (* _clutter_constraint1) (void);
void (* _clutter_constraint2) (void);
void (* _clutter_constraint3) (void);
void (* _clutter_constraint4) (void);
void (* _clutter_constraint5) (void);
void (* _clutter_constraint6) (void);
void (* _clutter_constraint7) (void);
};
CLUTTER_EXPORT
GType clutter_constraint_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
void clutter_constraint_update_preferred_size (ClutterConstraint *constraint,
ClutterActor *actor,
ClutterOrientation direction,
float for_size,
float *minimum_size,
float *natural_size);
/* ClutterActor API */
CLUTTER_EXPORT
void clutter_actor_add_constraint (ClutterActor *self,
ClutterConstraint *constraint);
CLUTTER_EXPORT
void clutter_actor_add_constraint_with_name (ClutterActor *self,
const gchar *name,
ClutterConstraint *constraint);
CLUTTER_EXPORT
void clutter_actor_remove_constraint (ClutterActor *self,
ClutterConstraint *constraint);
CLUTTER_EXPORT
void clutter_actor_remove_constraint_by_name (ClutterActor *self,
const gchar *name);
CLUTTER_EXPORT
GList * clutter_actor_get_constraints (ClutterActor *self);
CLUTTER_EXPORT
ClutterConstraint *clutter_actor_get_constraint (ClutterActor *self,
const gchar *name);
CLUTTER_EXPORT
void clutter_actor_clear_constraints (ClutterActor *self);
CLUTTER_EXPORT
gboolean clutter_actor_has_constraints (ClutterActor *self);
G_END_DECLS
#endif /* __CLUTTER_CONSTRAINT_H__ */
muffin-6.4.1/clutter/clutter/clutter-shader-effect.c 0000664 0001750 0001750 00000065320 14723361714 021440 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
/**
* SECTION:clutter-shader-effect
* @short_description: Base class for shader effects
* @See_Also: #ClutterEffect, #ClutterOffscreenEffect
*
* #ClutterShaderEffect is a class that implements all the plumbing for
* creating #ClutterEffects using GLSL shaders.
*
* #ClutterShaderEffect creates an offscreen buffer and then applies the
* GLSL shader (after checking whether the compilation and linking were
* successfull) to the buffer before painting it on screen.
*
* #ClutterShaderEffect is available since Clutter 1.4
*
* ## Implementing a ClutterShaderEffect
*
* Creating a sub-class of #ClutterShaderEffect requires the
* overriding of the #ClutterOffscreenEffectClass.paint_target() virtual
* function from the #ClutterOffscreenEffect class. It is also convenient
* to implement the #ClutterShaderEffectClass.get_static_shader_source()
* virtual function in case you are planning to create more than one
* instance of the effect.
*
* The #ClutterShaderEffectClass.get_static_shader_source()
* function should return a copy of the shader source to use. This
* function is only called once per subclass of #ClutterShaderEffect
* regardless of how many instances of the effect are created. The
* source for the shader is typically stored in a static const
* string which is returned from this function via
* g_strdup().
*
* The #ClutterOffscreenEffectClass.paint_target() should set the
* shader's uniforms if any. This is done by calling
* clutter_shader_effect_set_uniform_value() or
* clutter_shader_effect_set_uniform(). The sub-class should then
* chain up to the #ClutterShaderEffect implementation.
*
* ## Setting uniforms on a ClutterShaderEffect
*
* The example below shows a typical implementation of the
* #ClutterShaderEffectClass.get_static_shader_source() and
* #ClutterOffscreenEffectClass.paint_target() virtual functions
* for a #ClutterShaderEffect subclass.
*
* |[
* static gchar *
* my_effect_get_static_shader_source (ClutterShaderEffect *effect)
* {
* // shader_source is set elsewhere
* return g_strdup (shader_source);
* }
*
* static gboolean
* my_effect_paint_target (ClutterOffscreenEffect *effect)
* {
* MyEffect *self = MY_EFFECT (effect);
* ClutterShaderEffect *shader = CLUTTER_SHADER_EFFECT (effect);
* ClutterEffectClass *parent_class;
* gfloat component_r, component_g, component_b;
*
* // the "tex" uniform is declared in the shader as:
* //
* // uniform int tex;
* //
* // and it is passed a constant value of 0
* clutter_shader_effect_set_uniform (shader, "tex", G_TYPE_INT, 1, 0);
*
* // the "component" uniform is declared in the shader as:
* //
* // uniform vec3 component;
* //
* // and it's defined to contain the normalized components
* // of a #ClutterColor
* component_r = self->color.red / 255.0f;
* component_g = self->color.green / 255.0f;
* component_b = self->color.blue / 255.0f;
* clutter_shader_effect_set_uniform (shader, "component",
* G_TYPE_FLOAT, 3,
* component_r,
* component_g,
* component_b);
*
* // chain up to the parent's implementation
* parent_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (my_effect_parent_class);
* return parent_class->paint_target (effect);
* }
* ]|
*/
#include "clutter-build-config.h"
#include "cogl/cogl.h"
#include "clutter-shader-effect.h"
#include "clutter-debug.h"
#include "clutter-enum-types.h"
#include "clutter-feature.h"
#include "clutter-private.h"
#include "clutter-shader-types.h"
typedef struct _ShaderUniform
{
gchar *name;
GType type;
GValue value;
int location;
} ShaderUniform;
struct _ClutterShaderEffectPrivate
{
ClutterActor *actor;
ClutterShaderType shader_type;
CoglHandle program;
CoglHandle shader;
GHashTable *uniforms;
};
typedef struct _ClutterShaderEffectClassPrivate
{
/* These are the per-class pre-compiled shader and program which is
used when the class implements get_static_shader_source without
calling set_shader_source. They will be shared by all instances
of this class */
CoglHandle program;
CoglHandle shader;
} ClutterShaderEffectClassPrivate;
enum
{
PROP_0,
PROP_SHADER_TYPE,
PROP_LAST
};
static GParamSpec *obj_props[PROP_LAST];
G_DEFINE_TYPE_WITH_CODE (ClutterShaderEffect,
clutter_shader_effect,
CLUTTER_TYPE_OFFSCREEN_EFFECT,
G_ADD_PRIVATE (ClutterShaderEffect)
g_type_add_class_private (g_define_type_id,
sizeof (ClutterShaderEffectClassPrivate)))
static inline void
clutter_shader_effect_clear (ClutterShaderEffect *self,
gboolean reset_uniforms)
{
ClutterShaderEffectPrivate *priv = self->priv;
if (priv->shader != NULL)
{
cogl_object_unref (priv->shader);
priv->shader = NULL;
}
if (priv->program != NULL)
{
cogl_object_unref (priv->program);
priv->program = NULL;
}
if (reset_uniforms && priv->uniforms != NULL)
{
g_hash_table_destroy (priv->uniforms);
priv->uniforms = NULL;
}
priv->actor = NULL;
}
static void
clutter_shader_effect_update_uniforms (ClutterShaderEffect *effect)
{
ClutterShaderEffectPrivate *priv = effect->priv;
GHashTableIter iter;
gpointer key, value;
gsize size;
if (priv->program == NULL)
return;
if (priv->uniforms == NULL)
return;
key = value = NULL;
g_hash_table_iter_init (&iter, priv->uniforms);
while (g_hash_table_iter_next (&iter, &key, &value))
{
ShaderUniform *uniform = value;
if (uniform->location == -1)
uniform->location = cogl_program_get_uniform_location (priv->program,
uniform->name);
if (CLUTTER_VALUE_HOLDS_SHADER_FLOAT (&uniform->value))
{
const float *floats;
floats = clutter_value_get_shader_float (&uniform->value, &size);
cogl_program_set_uniform_float (priv->program, uniform->location,
size, 1,
floats);
}
else if (CLUTTER_VALUE_HOLDS_SHADER_INT (&uniform->value))
{
const int *ints;
ints = clutter_value_get_shader_int (&uniform->value, &size);
cogl_program_set_uniform_int (priv->program, uniform->location,
size, 1,
ints);
}
else if (CLUTTER_VALUE_HOLDS_SHADER_MATRIX (&uniform->value))
{
const float *matrix;
matrix = clutter_value_get_shader_matrix (&uniform->value, &size);
cogl_program_set_uniform_matrix (priv->program, uniform->location,
size, 1,
FALSE,
matrix);
}
else if (G_VALUE_HOLDS_FLOAT (&uniform->value))
{
const float float_val = g_value_get_float (&uniform->value);
cogl_program_set_uniform_float (priv->program, uniform->location,
1, 1,
&float_val);
}
else if (G_VALUE_HOLDS_DOUBLE (&uniform->value))
{
const float float_val =
(float) g_value_get_double (&uniform->value);
cogl_program_set_uniform_float (priv->program, uniform->location,
1, 1,
&float_val);
}
else if (G_VALUE_HOLDS_INT (&uniform->value))
{
const int int_val = g_value_get_int (&uniform->value);
cogl_program_set_uniform_int (priv->program, uniform->location,
1, 1,
&int_val);
}
else
g_warning ("Invalid uniform of type '%s' for name '%s'",
g_type_name (G_VALUE_TYPE (&uniform->value)),
uniform->name);
}
}
static void
clutter_shader_effect_set_actor (ClutterActorMeta *meta,
ClutterActor *actor)
{
ClutterShaderEffect *self = CLUTTER_SHADER_EFFECT (meta);
ClutterShaderEffectPrivate *priv = self->priv;
ClutterActorMetaClass *parent;
if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL))
{
/* if we don't have support for GLSL shaders then we
* forcibly disable the ActorMeta
*/
g_warning ("Unable to use the ShaderEffect: the graphics hardware "
"or the current GL driver does not implement support "
"for the GLSL shading language.");
clutter_actor_meta_set_enabled (meta, FALSE);
return;
}
parent = CLUTTER_ACTOR_META_CLASS (clutter_shader_effect_parent_class);
parent->set_actor (meta, actor);
/* we keep a back pointer here */
priv->actor = clutter_actor_meta_get_actor (meta);
if (priv->actor == NULL)
return;
CLUTTER_NOTE (SHADER, "Preparing shader effect of type '%s'",
G_OBJECT_TYPE_NAME (meta));
}
static CoglHandle
clutter_shader_effect_create_shader (ClutterShaderEffect *self)
{
ClutterShaderEffectPrivate *priv = self->priv;
switch (priv->shader_type)
{
case CLUTTER_FRAGMENT_SHADER:
return cogl_create_shader (COGL_SHADER_TYPE_FRAGMENT);
break;
case CLUTTER_VERTEX_SHADER:
return cogl_create_shader (COGL_SHADER_TYPE_VERTEX);
break;
default:
g_assert_not_reached ();
return NULL;
}
}
static void
clutter_shader_effect_try_static_source (ClutterShaderEffect *self)
{
ClutterShaderEffectPrivate *priv = self->priv;
ClutterShaderEffectClass *shader_effect_class =
CLUTTER_SHADER_EFFECT_GET_CLASS (self);
if (shader_effect_class->get_static_shader_source != NULL)
{
ClutterShaderEffectClassPrivate *class_priv;
class_priv =
G_TYPE_CLASS_GET_PRIVATE (shader_effect_class,
CLUTTER_TYPE_SHADER_EFFECT,
ClutterShaderEffectClassPrivate);
if (class_priv->shader == NULL)
{
gchar *source;
class_priv->shader = clutter_shader_effect_create_shader (self);
source = shader_effect_class->get_static_shader_source (self);
cogl_shader_source (class_priv->shader, source);
g_free (source);
CLUTTER_NOTE (SHADER, "Compiling shader effect");
class_priv->program = cogl_create_program ();
cogl_program_attach_shader (class_priv->program,
class_priv->shader);
cogl_program_link (class_priv->program);
}
priv->shader = cogl_object_ref (class_priv->shader);
if (class_priv->program != NULL)
priv->program = cogl_object_ref (class_priv->program);
}
}
static void
clutter_shader_effect_paint_target (ClutterOffscreenEffect *effect,
ClutterPaintContext *paint_context)
{
ClutterShaderEffect *self = CLUTTER_SHADER_EFFECT (effect);
ClutterShaderEffectPrivate *priv = self->priv;
ClutterOffscreenEffectClass *parent;
CoglHandle material;
/* If the source hasn't been set then we'll try to get it from the
static source instead */
if (priv->shader == NULL)
clutter_shader_effect_try_static_source (self);
/* we haven't been prepared or we don't have support for
* GLSL shaders in Clutter
*/
if (priv->program == NULL)
goto out;
CLUTTER_NOTE (SHADER, "Applying the shader effect of type '%s'",
G_OBJECT_TYPE_NAME (effect));
clutter_shader_effect_update_uniforms (CLUTTER_SHADER_EFFECT (effect));
/* associate the program to the offscreen target material */
material = clutter_offscreen_effect_get_target (effect);
cogl_pipeline_set_user_program (material, priv->program);
out:
/* paint the offscreen buffer */
parent = CLUTTER_OFFSCREEN_EFFECT_CLASS (clutter_shader_effect_parent_class);
parent->paint_target (effect, paint_context);
}
static void
clutter_shader_effect_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterShaderEffectPrivate *priv = CLUTTER_SHADER_EFFECT (gobject)->priv;
switch (prop_id)
{
case PROP_SHADER_TYPE:
priv->shader_type = g_value_get_enum (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_shader_effect_finalize (GObject *gobject)
{
ClutterShaderEffect *effect = CLUTTER_SHADER_EFFECT (gobject);
clutter_shader_effect_clear (effect, TRUE);
G_OBJECT_CLASS (clutter_shader_effect_parent_class)->finalize (gobject);
}
static void
clutter_shader_effect_class_init (ClutterShaderEffectClass *klass)
{
ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterOffscreenEffectClass *offscreen_class;
offscreen_class = CLUTTER_OFFSCREEN_EFFECT_CLASS (klass);
/**
* ClutterShaderEffect:shader-type:
*
* The type of shader that is used by the effect. This property
* should be set by the constructor of #ClutterShaderEffect
* sub-classes.
*
* Since: 1.4
*/
obj_props[PROP_SHADER_TYPE] =
g_param_spec_enum ("shader-type",
P_("Shader Type"),
P_("The type of shader used"),
CLUTTER_TYPE_SHADER_TYPE,
CLUTTER_FRAGMENT_SHADER,
CLUTTER_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);
gobject_class->set_property = clutter_shader_effect_set_property;
gobject_class->finalize = clutter_shader_effect_finalize;
g_object_class_install_properties (gobject_class,
PROP_LAST,
obj_props);
meta_class->set_actor = clutter_shader_effect_set_actor;
offscreen_class->paint_target = clutter_shader_effect_paint_target;
}
static void
clutter_shader_effect_init (ClutterShaderEffect *effect)
{
effect->priv = clutter_shader_effect_get_instance_private (effect);
effect->priv->shader_type = CLUTTER_FRAGMENT_SHADER;
}
/**
* clutter_shader_effect_new:
* @shader_type: the type of the shader, either %CLUTTER_FRAGMENT_SHADER,
* or %CLUTTER_VERTEX_SHADER
*
* Creates a new #ClutterShaderEffect, to be applied to an actor using
* clutter_actor_add_effect().
*
* The effect will be empty until clutter_shader_effect_set_shader_source()
* is called.
*
* Return value: the newly created #ClutterShaderEffect.
* Use g_object_unref() when done.
*
* Since: 1.8
*/
ClutterEffect *
clutter_shader_effect_new (ClutterShaderType shader_type)
{
return g_object_new (CLUTTER_TYPE_SHADER_EFFECT,
"shader-type", shader_type,
NULL);
}
/**
* clutter_shader_effect_get_shader:
* @effect: a #ClutterShaderEffect
*
* Retrieves a pointer to the shader's handle
*
* Return value: (transfer none): a pointer to the shader's handle,
* or %NULL
*
* Since: 1.4
*/
CoglHandle
clutter_shader_effect_get_shader (ClutterShaderEffect *effect)
{
g_return_val_if_fail (CLUTTER_IS_SHADER_EFFECT (effect),
NULL);
return effect->priv->shader;
}
/**
* clutter_shader_effect_get_program:
* @effect: a #ClutterShaderEffect
*
* Retrieves a pointer to the program's handle
*
* Return value: (transfer none): a pointer to the program's handle,
* or %NULL
*
* Since: 1.4
*/
CoglHandle
clutter_shader_effect_get_program (ClutterShaderEffect *effect)
{
g_return_val_if_fail (CLUTTER_IS_SHADER_EFFECT (effect),
NULL);
return effect->priv->program;
}
static void
shader_uniform_free (gpointer data)
{
if (data != NULL)
{
ShaderUniform *uniform = data;
g_value_unset (&uniform->value);
g_free (uniform->name);
g_slice_free (ShaderUniform, uniform);
}
}
static ShaderUniform *
shader_uniform_new (const gchar *name,
const GValue *value)
{
ShaderUniform *retval;
retval = g_slice_new0 (ShaderUniform);
retval->name = g_strdup (name);
retval->type = G_VALUE_TYPE (value);
retval->location = -1;
g_value_init (&retval->value, retval->type);
g_value_copy (value, &retval->value);
return retval;
}
static void
shader_uniform_update (ShaderUniform *uniform,
const GValue *value)
{
g_value_unset (&uniform->value);
g_value_init (&uniform->value, G_VALUE_TYPE (value));
g_value_copy (value, &uniform->value);
}
static inline void
clutter_shader_effect_add_uniform (ClutterShaderEffect *effect,
const gchar *name,
const GValue *value)
{
ClutterShaderEffectPrivate *priv = effect->priv;
ShaderUniform *uniform;
if (priv->uniforms == NULL)
{
priv->uniforms = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL,
shader_uniform_free);
}
uniform = g_hash_table_lookup (priv->uniforms, name);
if (uniform == NULL)
{
uniform = shader_uniform_new (name, value);
g_hash_table_insert (priv->uniforms, uniform->name, uniform);
}
else
shader_uniform_update (uniform, value);
if (priv->actor != NULL && !CLUTTER_ACTOR_IN_PAINT (priv->actor))
clutter_effect_queue_repaint (CLUTTER_EFFECT (effect));
}
/**
* clutter_shader_effect_set_uniform_value:
* @effect: a #ClutterShaderEffect
* @name: the name of the uniform to set
* @value: a #GValue with the value of the uniform to set
*
* Sets @value as the payload for the uniform @name inside the shader
* effect
*
* The #GType of the @value must be one of: %G_TYPE_INT, for a single
* integer value; %G_TYPE_FLOAT, for a single floating point value;
* %CLUTTER_TYPE_SHADER_INT, for an array of integer values;
* %CLUTTER_TYPE_SHADER_FLOAT, for an array of floating point values;
* and %CLUTTER_TYPE_SHADER_MATRIX, for a matrix of floating point
* values. It also accepts %G_TYPE_DOUBLE for compatibility with other
* languages than C.
*
* Since: 1.4
*/
void
clutter_shader_effect_set_uniform_value (ClutterShaderEffect *effect,
const gchar *name,
const GValue *value)
{
g_return_if_fail (CLUTTER_IS_SHADER_EFFECT (effect));
g_return_if_fail (name != NULL);
g_return_if_fail (value != NULL);
clutter_shader_effect_add_uniform (effect, name, value);
}
static void
clutter_shader_effect_set_uniform_valist (ClutterShaderEffect *effect,
const gchar *name,
GType value_type,
gsize n_values,
va_list *args)
{
GValue value = G_VALUE_INIT;
if (value_type == CLUTTER_TYPE_SHADER_INT)
{
gint *int_values = va_arg (*args, gint*);
g_value_init (&value, CLUTTER_TYPE_SHADER_INT);
clutter_value_set_shader_int (&value, n_values, int_values);
goto add_uniform;
}
if (value_type == CLUTTER_TYPE_SHADER_FLOAT)
{
gfloat *float_values = va_arg (*args, gfloat*);
g_value_init (&value, CLUTTER_TYPE_SHADER_FLOAT);
clutter_value_set_shader_float (&value, n_values, float_values);
goto add_uniform;
}
if (value_type == CLUTTER_TYPE_SHADER_MATRIX)
{
gfloat *float_values = va_arg (*args, gfloat*);
g_value_init (&value, CLUTTER_TYPE_SHADER_MATRIX);
clutter_value_set_shader_matrix (&value, n_values, float_values);
goto add_uniform;
}
if (value_type == G_TYPE_INT)
{
g_return_if_fail (n_values <= 4);
/* if we only have one value we can go through the fast path
* of using G_TYPE_INT, otherwise we create a vector of integers
* from the passed values
*/
if (n_values == 1)
{
gint int_val = va_arg (*args, gint);
g_value_init (&value, G_TYPE_INT);
g_value_set_int (&value, int_val);
}
else
{
gint *int_values = g_new (gint, n_values);
gint i;
for (i = 0; i < n_values; i++)
int_values[i] = va_arg (*args, gint);
g_value_init (&value, CLUTTER_TYPE_SHADER_INT);
clutter_value_set_shader_int (&value, n_values, int_values);
g_free (int_values);
}
goto add_uniform;
}
if (value_type == G_TYPE_FLOAT)
{
g_return_if_fail (n_values <= 4);
/* if we only have one value we can go through the fast path
* of using G_TYPE_FLOAT, otherwise we create a vector of floats
* from the passed values
*/
if (n_values == 1)
{
gfloat float_val = (gfloat) va_arg (*args, gdouble);
g_value_init (&value, G_TYPE_FLOAT);
g_value_set_float (&value, float_val);
}
else
{
gfloat *float_values = g_new (gfloat, n_values);
gint i;
for (i = 0; i < n_values; i++)
float_values[i] = (gfloat) va_arg (*args, double);
g_value_init (&value, CLUTTER_TYPE_SHADER_FLOAT);
clutter_value_set_shader_float (&value, n_values, float_values);
g_free (float_values);
}
goto add_uniform;
}
g_warning ("Unrecognized type '%s' (values: %d) for uniform name '%s'",
g_type_name (value_type),
(int) n_values,
name);
return;
add_uniform:
clutter_shader_effect_add_uniform (effect, name, &value);
g_value_unset (&value);
}
/**
* clutter_shader_effect_set_uniform:
* @effect: a #ClutterShaderEffect
* @name: the name of the uniform to set
* @gtype: the type of the uniform to set
* @n_values: the number of values
* @...: a list of values
*
* Sets a list of values as the payload for the uniform @name inside
* the shader effect
*
* The @gtype must be one of: %G_TYPE_INT, for 1 or more integer values;
* %G_TYPE_FLOAT, for 1 or more floating point values;
* %CLUTTER_TYPE_SHADER_INT, for a pointer to an array of integer values;
* %CLUTTER_TYPE_SHADER_FLOAT, for a pointer to an array of floating point
* values; and %CLUTTER_TYPE_SHADER_MATRIX, for a pointer to an array of
* floating point values mapping a matrix
*
* The number of values interepreted is defined by the @n_value
* argument, and by the @gtype argument. For instance, a uniform named
* "sampler0" and containing a single integer value is set using:
*
* |[
* clutter_shader_effect_set_uniform (effect, "sampler0",
* G_TYPE_INT, 1,
* 0);
* ]|
*
* While a uniform named "components" and containing a 3-elements vector
* of floating point values (a "vec3") can be set using:
*
* |[
* gfloat component_r, component_g, component_b;
*
* clutter_shader_effect_set_uniform (effect, "components",
* G_TYPE_FLOAT, 3,
* component_r,
* component_g,
* component_b);
* ]|
*
* or can be set using:
*
* |[
* gfloat component_vec[3];
*
* clutter_shader_effect_set_uniform (effect, "components",
* CLUTTER_TYPE_SHADER_FLOAT, 3,
* component_vec);
* ]|
*
* Finally, a uniform named "map" and containing a matrix can be set using:
*
* |[
* clutter_shader_effect_set_uniform (effect, "map",
* CLUTTER_TYPE_SHADER_MATRIX, 1,
* cogl_matrix_get_array (&matrix));
* ]|
*
* Since: 1.4
*/
void
clutter_shader_effect_set_uniform (ClutterShaderEffect *effect,
const gchar *name,
GType gtype,
gsize n_values,
...)
{
va_list args;
g_return_if_fail (CLUTTER_IS_SHADER_EFFECT (effect));
g_return_if_fail (name != NULL);
g_return_if_fail (gtype != G_TYPE_INVALID);
g_return_if_fail (n_values > 0);
va_start (args, n_values);
clutter_shader_effect_set_uniform_valist (effect, name,
gtype,
n_values,
&args);
va_end (args);
}
/**
* clutter_shader_effect_set_shader_source:
* @effect: a #ClutterShaderEffect
* @source: the source of a GLSL shader
*
* Sets the source of the GLSL shader used by @effect
*
* This function should only be called by implementations of
* the #ClutterShaderEffect class, and not by application code.
*
* This function can only be called once; subsequent calls will
* yield no result.
*
* Return value: %TRUE if the source was set
*
* Since: 1.4
*/
gboolean
clutter_shader_effect_set_shader_source (ClutterShaderEffect *effect,
const gchar *source)
{
ClutterShaderEffectPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_SHADER_EFFECT (effect), FALSE);
g_return_val_if_fail (source != NULL && *source != '\0', FALSE);
priv = effect->priv;
if (priv->shader != NULL)
return TRUE;
priv->shader = clutter_shader_effect_create_shader (effect);
cogl_shader_source (priv->shader, source);
CLUTTER_NOTE (SHADER, "Compiling shader effect");
priv->program = cogl_create_program ();
cogl_program_attach_shader (priv->program, priv->shader);
cogl_program_link (priv->program);
return TRUE;
}
muffin-6.4.1/clutter/clutter/clutter-animatable.h 0000664 0001750 0001750 00000010761 14723361714 021041 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2009 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_ANIMATABLE_H__
#define __CLUTTER_ANIMATABLE_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_ANIMATABLE (clutter_animatable_get_type ())
CLUTTER_EXPORT
G_DECLARE_INTERFACE (ClutterAnimatable, clutter_animatable,
CLUTTER, ANIMATABLE,
GObject)
/**
* ClutterAnimatableInterface:
* @animate_property: virtual function for custom interpolation of a
* property. This virtual function is deprecated
* @find_property: virtual function for retrieving the #GParamSpec of
* an animatable property
* @get_initial_state: virtual function for retrieving the initial
* state of an animatable property
* @set_final_state: virtual function for setting the state of an
* animatable property
* @interpolate_value: virtual function for interpolating the progress
* of a property
*
* Base interface for #GObjects that can be animated by a
* a #ClutterAnimation.
*
* Since: 1.0
*/
struct _ClutterAnimatableInterface
{
/*< private >*/
GTypeInterface parent_iface;
/*< public >*/
gboolean (* animate_property) (ClutterAnimatable *animatable,
ClutterAnimation *animation,
const gchar *property_name,
const GValue *initial_value,
const GValue *final_value,
gdouble progress,
GValue *value);
GParamSpec *(* find_property) (ClutterAnimatable *animatable,
const gchar *property_name);
void (* get_initial_state) (ClutterAnimatable *animatable,
const gchar *property_name,
GValue *value);
void (* set_final_state) (ClutterAnimatable *animatable,
const gchar *property_name,
const GValue *value);
gboolean (* interpolate_value) (ClutterAnimatable *animatable,
const gchar *property_name,
ClutterInterval *interval,
gdouble progress,
GValue *value);
};
CLUTTER_EXPORT
GParamSpec *clutter_animatable_find_property (ClutterAnimatable *animatable,
const gchar *property_name);
CLUTTER_EXPORT
void clutter_animatable_get_initial_state (ClutterAnimatable *animatable,
const gchar *property_name,
GValue *value);
CLUTTER_EXPORT
void clutter_animatable_set_final_state (ClutterAnimatable *animatable,
const gchar *property_name,
const GValue *value);
CLUTTER_EXPORT
gboolean clutter_animatable_interpolate_value (ClutterAnimatable *animatable,
const gchar *property_name,
ClutterInterval *interval,
gdouble progress,
GValue *value);
G_END_DECLS
#endif /* __CLUTTER_ANIMATABLE_H__ */
muffin-6.4.1/clutter/clutter/clutter-effect-private.h 0000664 0001750 0001750 00000002417 14723361714 021647 0 ustar fabio fabio #ifndef __CLUTTER_EFFECT_PRIVATE_H__
#define __CLUTTER_EFFECT_PRIVATE_H__
#include
G_BEGIN_DECLS
gboolean _clutter_effect_pre_paint (ClutterEffect *effect,
ClutterPaintContext *paint_context);
void _clutter_effect_post_paint (ClutterEffect *effect,
ClutterPaintContext *paint_context);
gboolean _clutter_effect_modify_paint_volume (ClutterEffect *effect,
ClutterPaintVolume *volume);
gboolean _clutter_effect_has_custom_paint_volume (ClutterEffect *effect);
void _clutter_effect_paint (ClutterEffect *effect,
ClutterPaintContext *paint_context,
ClutterEffectPaintFlags flags);
void _clutter_effect_pick (ClutterEffect *effect,
ClutterPickContext *pick_context);
G_END_DECLS
#endif /* __CLUTTER_EFFECT_PRIVATE_H__ */
muffin-6.4.1/clutter/clutter/clutter-keyframe-transition.h 0000664 0001750 0001750 00000013377 14723361714 022745 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2012 Intel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author: Emmanuele Bassi
*/
#ifndef __CLUTTER_KEYFRAME_TRANSITION_H__
#define __CLUTTER_KEYFRAME_TRANSITION_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_KEYFRAME_TRANSITION (clutter_keyframe_transition_get_type ())
#define CLUTTER_KEYFRAME_TRANSITION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_KEYFRAME_TRANSITION, ClutterKeyframeTransition))
#define CLUTTER_IS_KEYFRAME_TRANSITION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_KEYFRAME_TRANSITION))
#define CLUTTER_KEYFRAME_TRANSITION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_KEYFRAME_TRANSITION, ClutterKeyframeTransitionClass))
#define CLUTTER_IS_KEYFRAME_TRANSITION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_KEYFRAME_TRANSITION))
#define CLUTTER_KEYFRAME_TRANSITION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_KEYFRAME_TRANSITION, ClutterKeyframeTransitionClass))
typedef struct _ClutterKeyframeTransitionPrivate ClutterKeyframeTransitionPrivate;
typedef struct _ClutterKeyframeTransitionClass ClutterKeyframeTransitionClass;
/**
* ClutterKeyframeTransition:
*
* The `ClutterKeyframeTransition` structure contains only private
* data and should be accessed using the provided API.
*
* Since: 1.12
*/
struct _ClutterKeyframeTransition
{
/*< private >*/
ClutterPropertyTransition parent_instance;
ClutterKeyframeTransitionPrivate *priv;
};
/**
* ClutterKeyframeTransitionClass:
*
* The `ClutterKeyframeTransitionClass` structure contains only
* private data.
*
* Since: 1.12
*/
struct _ClutterKeyframeTransitionClass
{
/*< private >*/
ClutterPropertyTransitionClass parent_class;
gpointer _padding[8];
};
CLUTTER_EXPORT
GType clutter_keyframe_transition_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterTransition * clutter_keyframe_transition_new (const char *property_name);
CLUTTER_EXPORT
void clutter_keyframe_transition_set_key_frames (ClutterKeyframeTransition *transition,
guint n_key_frames,
const double *key_frames);
CLUTTER_EXPORT
void clutter_keyframe_transition_set_values (ClutterKeyframeTransition *transition,
guint n_values,
const GValue *values);
CLUTTER_EXPORT
void clutter_keyframe_transition_set_modes (ClutterKeyframeTransition *transition,
guint n_modes,
const ClutterAnimationMode *modes);
CLUTTER_EXPORT
void clutter_keyframe_transition_set (ClutterKeyframeTransition *transition,
GType gtype,
guint n_key_frames,
...);
CLUTTER_EXPORT
void clutter_keyframe_transition_set_key_frame (ClutterKeyframeTransition *transition,
guint index_,
double key,
ClutterAnimationMode mode,
const GValue *value);
CLUTTER_EXPORT
void clutter_keyframe_transition_get_key_frame (ClutterKeyframeTransition *transition,
guint index_,
double *key,
ClutterAnimationMode *mode,
GValue *value);
CLUTTER_EXPORT
guint clutter_keyframe_transition_get_n_key_frames (ClutterKeyframeTransition *transition);
CLUTTER_EXPORT
void clutter_keyframe_transition_clear (ClutterKeyframeTransition *transition);
G_END_DECLS
#endif /* __CLUTTER_KEYFRAME_TRANSITION_H__ */
muffin-6.4.1/clutter/clutter/clutter.h 0000664 0001750 0001750 00000007123 14723361714 016744 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum
*
* Copyright (C) 2006 OpenedHand
*
* 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 .
*
*
*/
#ifndef __CLUTTER_H__
#define __CLUTTER_H__
#define __CLUTTER_H_INSIDE__
#include "clutter-config.h"
#include "clutter-types.h"
#include "clutter-action.h"
#include "clutter-actor.h"
#include "clutter-actor-meta.h"
#include "clutter-align-constraint.h"
#include "clutter-animatable.h"
#include "clutter-backend.h"
#include "clutter-bind-constraint.h"
#include "clutter-binding-pool.h"
#include "clutter-bin-layout.h"
#include "clutter-blur-effect.h"
#include "clutter-box-layout.h"
#include "clutter-brightness-contrast-effect.h"
#include "clutter-cairo.h"
#include "clutter-canvas.h"
#include "clutter-child-meta.h"
#include "clutter-click-action.h"
#include "clutter-clone.h"
#include "clutter-color.h"
#include "clutter-color-static.h"
#include "clutter-colorize-effect.h"
#include "clutter-constraint.h"
#include "clutter-container.h"
#include "clutter-content.h"
#include "clutter-deform-effect.h"
#include "clutter-desaturate-effect.h"
#include "clutter-drag-action.h"
#include "clutter-drop-action.h"
#include "clutter-effect.h"
#include "clutter-enums.h"
#include "clutter-enum-types.h"
#include "clutter-event.h"
#include "clutter-feature.h"
#include "clutter-fixed-layout.h"
#include "clutter-flow-layout.h"
#include "clutter-gesture-action.h"
#include "clutter-grid-layout.h"
#include "clutter-group.h"
#include "clutter-image.h"
#include "clutter-input-device.h"
#include "clutter-input-device-tool.h"
#include "clutter-input-method.h"
#include "clutter-input-focus.h"
#include "clutter-interval.h"
#include "clutter-keyframe-transition.h"
#include "clutter-keymap.h"
#include "clutter-keysyms.h"
#include "clutter-layout-manager.h"
#include "clutter-layout-meta.h"
#include "clutter-macros.h"
#include "clutter-main.h"
#include "clutter-offscreen-effect.h"
#include "clutter-page-turn-effect.h"
#include "clutter-paint-nodes.h"
#include "clutter-paint-node.h"
#include "clutter-pan-action.h"
#include "clutter-path-constraint.h"
#include "clutter-path.h"
#include "clutter-property-transition.h"
#include "clutter-rotate-action.h"
#include "clutter-scriptable.h"
#include "clutter-script.h"
#include "clutter-scroll-actor.h"
#include "clutter-settings.h"
#include "clutter-shader-effect.h"
#include "clutter-shader-types.h"
#include "clutter-swipe-action.h"
#include "clutter-snap-constraint.h"
#include "clutter-stage.h"
#include "clutter-stage-manager.h"
#include "clutter-stage-view.h"
#include "clutter-tap-action.h"
#include "clutter-text.h"
#include "clutter-texture-content.h"
#include "clutter-timeline.h"
#include "clutter-transition-group.h"
#include "clutter-transition.h"
#include "clutter-units.h"
#include "clutter-virtual-input-device.h"
#include "clutter-zoom-action.h"
#include "clutter-deprecated.h"
#include "clutter-autocleanups.h"
#undef __CLUTTER_H_INSIDE__
#endif /* __CLUTTER_H__ */
muffin-6.4.1/clutter/clutter/clutter-color-static.h 0000664 0001750 0001750 00000010603 14723361714 021342 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*/
#ifndef __CLUTTER_COLOR_STATIC_H__
#define __CLUTTER_COLOR_STATIC_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#define __CLUTTER_COLOR_SYM(x) (clutter_color_get_static (CLUTTER_COLOR_##x))
#define CLUTTER_COLOR_White (__CLUTTER_COLOR_SYM (WHITE))
#define CLUTTER_COLOR_Black (__CLUTTER_COLOR_SYM (BLACK))
#define CLUTTER_COLOR_Red (__CLUTTER_COLOR_SYM (RED))
#define CLUTTER_COLOR_DarkRed (__CLUTTER_COLOR_SYM (DARK_RED))
#define CLUTTER_COLOR_Green (__CLUTTER_COLOR_SYM (GREEN))
#define CLUTTER_COLOR_DarkGreen (__CLUTTER_COLOR_SYM (DARK_GREEN))
#define CLUTTER_COLOR_Blue (__CLUTTER_COLOR_SYM (BLUE))
#define CLUTTER_COLOR_DarkBlue (__CLUTTER_COLOR_SYM (DARK_BLUE))
#define CLUTTER_COLOR_Cyan (__CLUTTER_COLOR_SYM (CYAN))
#define CLUTTER_COLOR_DarkCyan (__CLUTTER_COLOR_SYM (DARK_CYAN))
#define CLUTTER_COLOR_Magenta (__CLUTTER_COLOR_SYM (MAGENTA))
#define CLUTTER_COLOR_DarkMagenta (__CLUTTER_COLOR_SYM (DARK_MAGENTA))
#define CLUTTER_COLOR_Yellow (__CLUTTER_COLOR_SYM (YELLOW))
#define CLUTTER_COLOR_DarkYellow (__CLUTTER_COLOR_SYM (DARK_YELLOW))
#define CLUTTER_COLOR_Gray (__CLUTTER_COLOR_SYM (GRAY))
#define CLUTTER_COLOR_DarkGray (__CLUTTER_COLOR_SYM (DARK_GRAY))
#define CLUTTER_COLOR_LightGray (__CLUTTER_COLOR_SYM (LIGHT_GRAY))
#define CLUTTER_COLOR_Butter (__CLUTTER_COLOR_SYM (BUTTER))
#define CLUTTER_COLOR_LightButter (__CLUTTER_COLOR_SYM (BUTTER_LIGHT))
#define CLUTTER_COLOR_DarkButter (__CLUTTER_COLOR_SYM (BUTTER_DARK))
#define CLUTTER_COLOR_Orange (__CLUTTER_COLOR_SYM (ORANGE))
#define CLUTTER_COLOR_LightOrange (__CLUTTER_COLOR_SYM (ORANGE_LIGHT))
#define CLUTTER_COLOR_DarkOrange (__CLUTTER_COLOR_SYM (ORANGE_DARK))
#define CLUTTER_COLOR_Chocolate (__CLUTTER_COLOR_SYM (CHOCOLATE))
#define CLUTTER_COLOR_LightChocolate (__CLUTTER_COLOR_SYM (CHOCOLATE_LIGHT))
#define CLUTTER_COLOR_DarkChocolate (__CLUTTER_COLOR_SYM (CHOCOLATE_DARK))
#define CLUTTER_COLOR_Chameleon (__CLUTTER_COLOR_SYM (CHAMELEON))
#define CLUTTER_COLOR_LightChameleon (__CLUTTER_COLOR_SYM (CHAMELEON_LIGHT))
#define CLUTTER_COLOR_DarkChameleon (__CLUTTER_COLOR_SYM (CHAMELEON_DARK))
#define CLUTTER_COLOR_SkyBlue (__CLUTTER_COLOR_SYM (SKY_BLUE))
#define CLUTTER_COLOR_LightSkyBlue (__CLUTTER_COLOR_SYM (SKY_BLUE_LIGHT))
#define CLUTTER_COLOR_DarkSkyBlue (__CLUTTER_COLOR_SYM (SKY_BLUE_DARK))
#define CLUTTER_COLOR_Plum (__CLUTTER_COLOR_SYM (PLUM))
#define CLUTTER_COLOR_LightPlum (__CLUTTER_COLOR_SYM (PLUM_LIGHT))
#define CLUTTER_COLOR_DarkPlum (__CLUTTER_COLOR_SYM (PLUM_DARK))
#define CLUTTER_COLOR_ScarletRed (__CLUTTER_COLOR_SYM (SCARLET_RED))
#define CLUTTER_COLOR_LightScarletRed (__CLUTTER_COLOR_SYM (SCARLET_RED_LIGHT))
#define CLUTTER_COLOR_DarkScarletRed (__CLUTTER_COLOR_SYM (SCARLET_RED_DARK))
#define CLUTTER_COLOR_Aluminium1 (__CLUTTER_COLOR_SYM (ALUMINIUM_1))
#define CLUTTER_COLOR_Aluminium2 (__CLUTTER_COLOR_SYM (ALUMINIUM_2))
#define CLUTTER_COLOR_Aluminium3 (__CLUTTER_COLOR_SYM (ALUMINIUM_3))
#define CLUTTER_COLOR_Aluminium4 (__CLUTTER_COLOR_SYM (ALUMINIUM_4))
#define CLUTTER_COLOR_Aluminium5 (__CLUTTER_COLOR_SYM (ALUMINIUM_5))
#define CLUTTER_COLOR_Aluminium6 (__CLUTTER_COLOR_SYM (ALUMINIUM_6))
#define CLUTTER_COLOR_Transparent (__CLUTTER_COLOR_SYM (TRANSPARENT))
#endif /* __CLUTTER_COLOR_STATIC_H__ */
muffin-6.4.1/clutter/clutter/clutter-text.h 0000664 0001750 0001750 00000037134 14723361714 017733 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2008 Intel Corporation.
*
* Authored By: Øyvind Kolås
* Emmanuele Bassi
*
* 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 .
*/
#ifndef __CLUTTER_TEXT_H__
#define __CLUTTER_TEXT_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_TEXT (clutter_text_get_type ())
#define CLUTTER_TEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_TEXT, ClutterText))
#define CLUTTER_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_TEXT, ClutterTextClass))
#define CLUTTER_IS_TEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_TEXT))
#define CLUTTER_IS_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_TEXT))
#define CLUTTER_TEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_TEXT, ClutterTextClass))
typedef struct _ClutterText ClutterText;
typedef struct _ClutterTextPrivate ClutterTextPrivate;
typedef struct _ClutterTextClass ClutterTextClass;
/**
* ClutterText:
*
* The #ClutterText struct contains only private data.
*
* Since: 1.0
*/
struct _ClutterText
{
/*< private >*/
ClutterActor parent_instance;
ClutterTextPrivate *priv;
};
/**
* ClutterTextClass:
* @text_changed: class handler for the #ClutterText::text-changed signal
* @activate: class handler for the #ClutterText::activate signal
* @cursor_event: class handler for the #ClutterText::cursor-event signal
* @cursor_changed: class handler for the #ClutterText::cursor-changed signal
*
* The #ClutterTextClass struct contains only private data.
*
* Since: 1.0
*/
struct _ClutterTextClass
{
/*< private >*/
ClutterActorClass parent_class;
/*< public >*/
/* signals, not vfuncs */
void (* text_changed) (ClutterText *self);
void (* activate) (ClutterText *self);
void (* cursor_event) (ClutterText *self,
const graphene_rect_t *rect);
void (* cursor_changed) (ClutterText *self);
/*< private >*/
/* padding for future expansion */
void (* _clutter_reserved1) (void);
void (* _clutter_reserved2) (void);
void (* _clutter_reserved3) (void);
void (* _clutter_reserved4) (void);
void (* _clutter_reserved5) (void);
void (* _clutter_reserved6) (void);
void (* _clutter_reserved7) (void);
};
CLUTTER_EXPORT
GType clutter_text_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterActor * clutter_text_new (void);
CLUTTER_EXPORT
ClutterActor * clutter_text_new_full (const gchar *font_name,
const gchar *text,
const ClutterColor *color);
CLUTTER_EXPORT
ClutterActor * clutter_text_new_with_text (const gchar *font_name,
const gchar *text);
CLUTTER_EXPORT
ClutterActor * clutter_text_new_with_buffer (ClutterTextBuffer *buffer);
CLUTTER_EXPORT
ClutterTextBuffer * clutter_text_get_buffer (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_buffer (ClutterText *self,
ClutterTextBuffer *buffer);
CLUTTER_EXPORT
const gchar * clutter_text_get_text (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_text (ClutterText *self,
const gchar *text);
CLUTTER_EXPORT
void clutter_text_set_markup (ClutterText *self,
const gchar *markup);
CLUTTER_EXPORT
void clutter_text_set_color (ClutterText *self,
const ClutterColor *color);
CLUTTER_EXPORT
void clutter_text_get_color (ClutterText *self,
ClutterColor *color);
CLUTTER_EXPORT
void clutter_text_set_font_name (ClutterText *self,
const gchar *font_name);
CLUTTER_EXPORT
const gchar * clutter_text_get_font_name (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_font_description (ClutterText *self,
PangoFontDescription *font_desc);
CLUTTER_EXPORT
PangoFontDescription *clutter_text_get_font_description (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_ellipsize (ClutterText *self,
PangoEllipsizeMode mode);
CLUTTER_EXPORT
PangoEllipsizeMode clutter_text_get_ellipsize (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_line_wrap (ClutterText *self,
gboolean line_wrap);
CLUTTER_EXPORT
gboolean clutter_text_get_line_wrap (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_line_wrap_mode (ClutterText *self,
PangoWrapMode wrap_mode);
CLUTTER_EXPORT
PangoWrapMode clutter_text_get_line_wrap_mode (ClutterText *self);
CLUTTER_EXPORT
PangoLayout * clutter_text_get_layout (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_attributes (ClutterText *self,
PangoAttrList *attrs);
CLUTTER_EXPORT
PangoAttrList * clutter_text_get_attributes (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_use_markup (ClutterText *self,
gboolean setting);
CLUTTER_EXPORT
gboolean clutter_text_get_use_markup (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_line_alignment (ClutterText *self,
PangoAlignment alignment);
CLUTTER_EXPORT
PangoAlignment clutter_text_get_line_alignment (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_justify (ClutterText *self,
gboolean justify);
CLUTTER_EXPORT
gboolean clutter_text_get_justify (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_insert_unichar (ClutterText *self,
gunichar wc);
CLUTTER_EXPORT
void clutter_text_delete_chars (ClutterText *self,
guint n_chars);
CLUTTER_EXPORT
void clutter_text_insert_text (ClutterText *self,
const gchar *text,
gssize position);
CLUTTER_EXPORT
void clutter_text_delete_text (ClutterText *self,
gssize start_pos,
gssize end_pos);
CLUTTER_EXPORT
gchar * clutter_text_get_chars (ClutterText *self,
gssize start_pos,
gssize end_pos);
CLUTTER_EXPORT
void clutter_text_set_editable (ClutterText *self,
gboolean editable);
CLUTTER_EXPORT
gboolean clutter_text_get_editable (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_activatable (ClutterText *self,
gboolean activatable);
CLUTTER_EXPORT
gboolean clutter_text_get_activatable (ClutterText *self);
CLUTTER_EXPORT
gint clutter_text_get_cursor_position (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_cursor_position (ClutterText *self,
gint position);
CLUTTER_EXPORT
void clutter_text_set_cursor_visible (ClutterText *self,
gboolean cursor_visible);
CLUTTER_EXPORT
gboolean clutter_text_get_cursor_visible (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_cursor_color (ClutterText *self,
const ClutterColor *color);
CLUTTER_EXPORT
void clutter_text_get_cursor_color (ClutterText *self,
ClutterColor *color);
CLUTTER_EXPORT
void clutter_text_set_cursor_size (ClutterText *self,
gint size);
CLUTTER_EXPORT
guint clutter_text_get_cursor_size (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_get_cursor_rect (ClutterText *self,
graphene_rect_t *rect);
CLUTTER_EXPORT
void clutter_text_set_selectable (ClutterText *self,
gboolean selectable);
CLUTTER_EXPORT
gboolean clutter_text_get_selectable (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_selection_bound (ClutterText *self,
gint selection_bound);
CLUTTER_EXPORT
gint clutter_text_get_selection_bound (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_selection (ClutterText *self,
gssize start_pos,
gssize end_pos);
CLUTTER_EXPORT
gchar * clutter_text_get_selection (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_selection_color (ClutterText *self,
const ClutterColor *color);
CLUTTER_EXPORT
void clutter_text_get_selection_color (ClutterText *self,
ClutterColor *color);
CLUTTER_EXPORT
gboolean clutter_text_delete_selection (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_password_char (ClutterText *self,
gunichar wc);
CLUTTER_EXPORT
gunichar clutter_text_get_password_char (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_max_length (ClutterText *self,
gint max);
CLUTTER_EXPORT
gint clutter_text_get_max_length (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_single_line_mode (ClutterText *self,
gboolean single_line);
CLUTTER_EXPORT
gboolean clutter_text_get_single_line_mode (ClutterText *self);
CLUTTER_EXPORT
void clutter_text_set_selected_text_color (ClutterText *self,
const ClutterColor *color);
CLUTTER_EXPORT
void clutter_text_get_selected_text_color (ClutterText *self,
ClutterColor *color);
CLUTTER_EXPORT
gboolean clutter_text_activate (ClutterText *self);
CLUTTER_EXPORT
gint clutter_text_coords_to_position (ClutterText *self,
gfloat x,
gfloat y);
CLUTTER_EXPORT
gboolean clutter_text_position_to_coords (ClutterText *self,
gint position,
gfloat *x,
gfloat *y,
gfloat *line_height);
CLUTTER_EXPORT
void clutter_text_set_preedit_string (ClutterText *self,
const gchar *preedit_str,
PangoAttrList *preedit_attrs,
guint cursor_pos);
CLUTTER_EXPORT
void clutter_text_get_layout_offsets (ClutterText *self,
gint *x,
gint *y);
CLUTTER_EXPORT
void clutter_text_set_input_hints (ClutterText *self,
ClutterInputContentHintFlags hints);
CLUTTER_EXPORT
void clutter_text_set_input_purpose (ClutterText *self,
ClutterInputContentPurpose purpose);
CLUTTER_EXPORT
ClutterInputContentHintFlags clutter_text_get_input_hints (ClutterText *self);
CLUTTER_EXPORT
ClutterInputContentPurpose clutter_text_get_input_purpose (ClutterText *self);
CLUTTER_EXPORT
gboolean clutter_text_has_preedit (ClutterText *self);
G_END_DECLS
#endif /* __CLUTTER_TEXT_H__ */
muffin-6.4.1/clutter/clutter/clutter-content-private.h 0000664 0001750 0001750 00000003266 14723361714 022070 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2011 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_CONTENT_PRIVATE_H__
#define __CLUTTER_CONTENT_PRIVATE_H__
#include
G_BEGIN_DECLS
void _clutter_content_attached (ClutterContent *content,
ClutterActor *actor);
void _clutter_content_detached (ClutterContent *content,
ClutterActor *actor);
void _clutter_content_paint_content (ClutterContent *content,
ClutterActor *actor,
ClutterPaintNode *node,
ClutterPaintContext *paint_context);
G_END_DECLS
#endif /* __CLUTTER_CONTENT_PRIVATE_H__ */
muffin-6.4.1/clutter/clutter/clutter-gesture-action.h 0000664 0001750 0001750 00000021252 14723361714 021672 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
* Copyright (C) 2011 Robert Bosch Car Multimedia GmbH.
*
* 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 .
*
* Author:
* Tomeu Vizoso
*/
#ifndef __CLUTTER_GESTURE_ACTION_H__
#define __CLUTTER_GESTURE_ACTION_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_GESTURE_ACTION (clutter_gesture_action_get_type ())
#define CLUTTER_GESTURE_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_GESTURE_ACTION, ClutterGestureAction))
#define CLUTTER_IS_GESTURE_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_GESTURE_ACTION))
#define CLUTTER_GESTURE_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_GESTURE_ACTION, ClutterGestureActionClass))
#define CLUTTER_IS_GESTURE_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_GESTURE_ACTION))
#define CLUTTER_GESTURE_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_GESTURE_ACTION, ClutterGestureActionClass))
typedef struct _ClutterGestureAction ClutterGestureAction;
typedef struct _ClutterGestureActionPrivate ClutterGestureActionPrivate;
typedef struct _ClutterGestureActionClass ClutterGestureActionClass;
/**
* ClutterGestureAction:
*
* The #ClutterGestureAction structure contains
* only private data and should be accessed using the provided API
*
* Since: 1.8
*/
struct _ClutterGestureAction
{
/*< private >*/
ClutterAction parent_instance;
ClutterGestureActionPrivate *priv;
};
/**
* ClutterGestureActionClass:
* @gesture_begin: class handler for the #ClutterGestureAction::gesture-begin signal
* @gesture_progress: class handler for the #ClutterGestureAction::gesture-progress signal
* @gesture_end: class handler for the #ClutterGestureAction::gesture-end signal
* @gesture_cancel: class handler for the #ClutterGestureAction::gesture-cancel signal
* @gesture_prepare: virtual function called before emitting the
* #ClutterGestureAction::gesture-cancel signal
*
* The #ClutterGestureClass structure contains only
* private data.
*
* Since: 1.8
*/
struct _ClutterGestureActionClass
{
/*< private >*/
ClutterActionClass parent_class;
/*< public >*/
gboolean (* gesture_begin) (ClutterGestureAction *action,
ClutterActor *actor);
gboolean (* gesture_progress) (ClutterGestureAction *action,
ClutterActor *actor);
void (* gesture_end) (ClutterGestureAction *action,
ClutterActor *actor);
void (* gesture_cancel) (ClutterGestureAction *action,
ClutterActor *actor);
gboolean (* gesture_prepare) (ClutterGestureAction *action,
ClutterActor *actor);
/*< private >*/
void (* _clutter_gesture_action1) (void);
void (* _clutter_gesture_action2) (void);
void (* _clutter_gesture_action3) (void);
void (* _clutter_gesture_action4) (void);
void (* _clutter_gesture_action5) (void);
void (* _clutter_gesture_action6) (void);
};
CLUTTER_EXPORT
GType clutter_gesture_action_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterAction * clutter_gesture_action_new (void);
CLUTTER_EXPORT
gint clutter_gesture_action_get_n_touch_points (ClutterGestureAction *action);
CLUTTER_EXPORT
void clutter_gesture_action_set_n_touch_points (ClutterGestureAction *action,
gint nb_points);
CLUTTER_EXPORT
void clutter_gesture_action_get_press_coords (ClutterGestureAction *action,
guint point,
gfloat *press_x,
gfloat *press_y);
CLUTTER_EXPORT
void clutter_gesture_action_get_motion_coords (ClutterGestureAction *action,
guint point,
gfloat *motion_x,
gfloat *motion_y);
CLUTTER_EXPORT
gfloat clutter_gesture_action_get_motion_delta (ClutterGestureAction *action,
guint point,
gfloat *delta_x,
gfloat *delta_y);
CLUTTER_EXPORT
void clutter_gesture_action_get_release_coords (ClutterGestureAction *action,
guint point,
gfloat *release_x,
gfloat *release_y);
CLUTTER_EXPORT
gfloat clutter_gesture_action_get_velocity (ClutterGestureAction *action,
guint point,
gfloat *velocity_x,
gfloat *velocity_y);
CLUTTER_EXPORT
guint clutter_gesture_action_get_n_current_points (ClutterGestureAction *action);
CLUTTER_EXPORT
ClutterEventSequence * clutter_gesture_action_get_sequence (ClutterGestureAction *action,
guint point);
CLUTTER_EXPORT
ClutterInputDevice * clutter_gesture_action_get_device (ClutterGestureAction *action,
guint point);
CLUTTER_EXPORT
const ClutterEvent * clutter_gesture_action_get_last_event (ClutterGestureAction *action,
guint point);
CLUTTER_EXPORT
void clutter_gesture_action_cancel (ClutterGestureAction *action);
CLUTTER_EXPORT
void clutter_gesture_action_set_threshold_trigger_edge (ClutterGestureAction *action,
ClutterGestureTriggerEdge edge);
CLUTTER_DEPRECATED_FOR(clutter_gesture_action_get_threshold_trigger_edge)
ClutterGestureTriggerEdge clutter_gesture_action_get_threshold_trigger_egde (ClutterGestureAction *action);
CLUTTER_EXPORT
ClutterGestureTriggerEdge clutter_gesture_action_get_threshold_trigger_edge (ClutterGestureAction *action);
CLUTTER_EXPORT
void clutter_gesture_action_set_threshold_trigger_distance (ClutterGestureAction *action,
float x,
float y);
CLUTTER_EXPORT
void clutter_gesture_action_get_threshold_trigger_distance (ClutterGestureAction *action,
float *x,
float *y);
G_END_DECLS
#endif /* __CLUTTER_GESTURE_ACTION_H__ */
muffin-6.4.1/clutter/clutter/clutter-pick-context.h 0000664 0001750 0001750 00000003073 14723361714 021352 0 ustar fabio fabio /*
* Copyright (C) 2019 Red Hat 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 .
*/
#ifndef CLUTTER_PICK_CONTEXT_H
#define CLUTTER_PICK_CONTEXT_H
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include "clutter-macros.h"
#include "clutter-stage-view.h"
typedef struct _ClutterPickContext ClutterPickContext;
#define CLUTTER_TYPE_PICK_CONTEXT (clutter_pick_context_get_type ())
CLUTTER_EXPORT
GType clutter_pick_context_get_type (void);
CLUTTER_EXPORT
ClutterPickContext * clutter_pick_context_ref (ClutterPickContext *pick_context);
CLUTTER_EXPORT
void clutter_pick_context_unref (ClutterPickContext *pick_context);
CLUTTER_EXPORT
void clutter_pick_context_destroy (ClutterPickContext *pick_context);
CLUTTER_EXPORT
CoglFramebuffer * clutter_pick_context_get_framebuffer (ClutterPickContext *pick_context);
#endif /* CLUTTER_PICK_CONTEXT_H */
muffin-6.4.1/clutter/clutter/clutter-bin-layout.c 0000664 0001750 0001750 00000046740 14723361714 021030 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2009 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
/**
* SECTION:clutter-bin-layout
* @short_description: A simple layout manager
*
* #ClutterBinLayout is a layout manager which implements the following
* policy:
*
* - the preferred size is the maximum preferred size
* between all the children of the container using the
* layout;
* - each child is allocated in "layers", on on top
* of the other;
* - for each layer there are horizontal and vertical
* alignment policies.
*
* The [bin-layout example](https://git.gnome.org/browse/clutter/tree/examples/bin-layout.c?h=clutter-1.18)
* shows how to pack actors inside a #ClutterBinLayout.
*
* #ClutterBinLayout is available since Clutter 1.2
*/
#include "clutter-build-config.h"
#include
#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
#include "deprecated/clutter-container.h"
#include "clutter-actor-private.h"
#include "clutter-animatable.h"
#include "clutter-bin-layout.h"
#include "clutter-child-meta.h"
#include "clutter-debug.h"
#include "clutter-enum-types.h"
#include "clutter-layout-meta.h"
#include "clutter-private.h"
#define CLUTTER_TYPE_BIN_LAYER (clutter_bin_layer_get_type ())
#define CLUTTER_BIN_LAYER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_BIN_LAYER, ClutterBinLayer))
#define CLUTTER_IS_BIN_LAYER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_BIN_LAYER))
typedef struct _ClutterBinLayer ClutterBinLayer;
typedef struct _ClutterLayoutMetaClass ClutterBinLayerClass;
struct _ClutterBinLayoutPrivate
{
ClutterBinAlignment x_align;
ClutterBinAlignment y_align;
ClutterContainer *container;
};
struct _ClutterBinLayer
{
ClutterLayoutMeta parent_instance;
ClutterBinAlignment x_align;
ClutterBinAlignment y_align;
};
enum
{
PROP_LAYER_0,
PROP_LAYER_X_ALIGN,
PROP_LAYER_Y_ALIGN,
PROP_LAYER_LAST
};
enum
{
PROP_0,
PROP_X_ALIGN,
PROP_Y_ALIGN,
PROP_LAST
};
static GParamSpec *layer_props[PROP_LAYER_LAST] = { NULL, };
static GParamSpec *bin_props[PROP_LAST] = { NULL, };
GType clutter_bin_layer_get_type (void);
G_DEFINE_TYPE (ClutterBinLayer,
clutter_bin_layer,
CLUTTER_TYPE_LAYOUT_META)
G_DEFINE_TYPE_WITH_PRIVATE (ClutterBinLayout,
clutter_bin_layout,
CLUTTER_TYPE_LAYOUT_MANAGER)
/*
* ClutterBinLayer
*/
static void
set_layer_x_align (ClutterBinLayer *self,
ClutterBinAlignment alignment)
{
ClutterLayoutManager *manager;
ClutterLayoutMeta *meta;
if (self->x_align == alignment)
return;
self->x_align = alignment;
meta = CLUTTER_LAYOUT_META (self);
manager = clutter_layout_meta_get_manager (meta);
clutter_layout_manager_layout_changed (manager);
g_object_notify_by_pspec (G_OBJECT (self), layer_props[PROP_LAYER_X_ALIGN]);
}
static void
set_layer_y_align (ClutterBinLayer *self,
ClutterBinAlignment alignment)
{
ClutterLayoutManager *manager;
ClutterLayoutMeta *meta;
if (self->y_align == alignment)
return;
self->y_align = alignment;
meta = CLUTTER_LAYOUT_META (self);
manager = clutter_layout_meta_get_manager (meta);
clutter_layout_manager_layout_changed (manager);
g_object_notify_by_pspec (G_OBJECT (self), layer_props[PROP_LAYER_Y_ALIGN]);
}
static void
clutter_bin_layer_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterBinLayer *layer = CLUTTER_BIN_LAYER (gobject);
switch (prop_id)
{
case PROP_LAYER_X_ALIGN:
set_layer_x_align (layer, g_value_get_enum (value));
break;
case PROP_LAYER_Y_ALIGN:
set_layer_y_align (layer, g_value_get_enum (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_bin_layer_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterBinLayer *layer = CLUTTER_BIN_LAYER (gobject);
switch (prop_id)
{
case PROP_LAYER_X_ALIGN:
g_value_set_enum (value, layer->x_align);
break;
case PROP_LAYER_Y_ALIGN:
g_value_set_enum (value, layer->y_align);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_bin_layer_class_init (ClutterBinLayerClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->set_property = clutter_bin_layer_set_property;
gobject_class->get_property = clutter_bin_layer_get_property;
layer_props[PROP_LAYER_X_ALIGN] =
g_param_spec_enum ("x-align",
P_("Horizontal Alignment"),
P_("Horizontal alignment for the actor "
"inside the layout manager"),
CLUTTER_TYPE_BIN_ALIGNMENT,
CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_PARAM_READWRITE);
layer_props[PROP_LAYER_Y_ALIGN] =
g_param_spec_enum ("y-align",
P_("Vertical Alignment"),
P_("Vertical alignment for the actor "
"inside the layout manager"),
CLUTTER_TYPE_BIN_ALIGNMENT,
CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_PARAM_READWRITE);
g_object_class_install_properties (gobject_class,
PROP_LAYER_LAST,
layer_props);
}
static void
clutter_bin_layer_init (ClutterBinLayer *layer)
{
layer->x_align = CLUTTER_BIN_ALIGNMENT_CENTER;
layer->y_align = CLUTTER_BIN_ALIGNMENT_CENTER;
}
/*
* ClutterBinLayout
*/
static void
set_x_align (ClutterBinLayout *self,
ClutterBinAlignment alignment)
{
ClutterBinLayoutPrivate *priv = self->priv;
if (priv->x_align != alignment)
{
ClutterLayoutManager *manager;
priv->x_align = alignment;
manager = CLUTTER_LAYOUT_MANAGER (self);
clutter_layout_manager_layout_changed (manager);
g_object_notify_by_pspec (G_OBJECT (self), bin_props[PROP_X_ALIGN]);
}
}
static void
set_y_align (ClutterBinLayout *self,
ClutterBinAlignment alignment)
{
ClutterBinLayoutPrivate *priv = self->priv;
if (priv->y_align != alignment)
{
ClutterLayoutManager *manager;
priv->y_align = alignment;
manager = CLUTTER_LAYOUT_MANAGER (self);
clutter_layout_manager_layout_changed (manager);
g_object_notify_by_pspec (G_OBJECT (self), bin_props[PROP_Y_ALIGN]);
}
}
static void
clutter_bin_layout_get_preferred_width (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
ClutterActor *actor = CLUTTER_ACTOR (container);
ClutterActorIter iter;
ClutterActor *child;
gfloat min_width, nat_width;
min_width = nat_width = 0.0;
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, &child))
{
gfloat minimum, natural;
if (!clutter_actor_is_visible (child))
continue;
clutter_actor_get_preferred_width (child, for_height,
&minimum,
&natural);
min_width = MAX (min_width, minimum);
nat_width = MAX (nat_width, natural);
}
if (min_width_p)
*min_width_p = min_width;
if (nat_width_p)
*nat_width_p = nat_width;
}
static void
clutter_bin_layout_get_preferred_height (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_width,
gfloat *min_height_p,
gfloat *nat_height_p)
{
ClutterActor *actor = CLUTTER_ACTOR (container);
ClutterActorIter iter;
ClutterActor *child;
gfloat min_height, nat_height;
min_height = nat_height = 0.0;
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, &child))
{
gfloat minimum, natural;
if (!clutter_actor_is_visible (child))
continue;
clutter_actor_get_preferred_height (child, for_width,
&minimum,
&natural);
min_height = MAX (min_height, minimum);
nat_height = MAX (nat_height, natural);
}
if (min_height_p)
*min_height_p = min_height;
if (nat_height_p)
*nat_height_p = nat_height;
}
static gdouble
get_bin_alignment_factor (ClutterBinAlignment alignment,
ClutterTextDirection text_dir)
{
switch (alignment)
{
case CLUTTER_BIN_ALIGNMENT_CENTER:
return 0.5;
case CLUTTER_BIN_ALIGNMENT_START:
return text_dir == CLUTTER_TEXT_DIRECTION_LTR ? 0.0 : 1.0;
case CLUTTER_BIN_ALIGNMENT_END:
return text_dir == CLUTTER_TEXT_DIRECTION_LTR ? 1.0 : 0.0;
case CLUTTER_BIN_ALIGNMENT_FIXED:
case CLUTTER_BIN_ALIGNMENT_FILL:
return 0.0;
}
return 0.0;
}
static gdouble
get_actor_align_factor (ClutterActorAlign alignment)
{
switch (alignment)
{
case CLUTTER_ACTOR_ALIGN_CENTER:
return 0.5;
case CLUTTER_ACTOR_ALIGN_START:
return 0.0;
case CLUTTER_ACTOR_ALIGN_END:
return 1.0;
case CLUTTER_ACTOR_ALIGN_FILL:
return 0.0;
}
return 0.0;
}
static void
clutter_bin_layout_allocate (ClutterLayoutManager *manager,
ClutterContainer *container,
const ClutterActorBox *allocation,
ClutterAllocationFlags flags)
{
gfloat allocation_x, allocation_y;
gfloat available_w, available_h;
ClutterActor *actor, *child;
ClutterActorIter iter;
clutter_actor_box_get_origin (allocation, &allocation_x, &allocation_y);
clutter_actor_box_get_size (allocation, &available_w, &available_h);
actor = CLUTTER_ACTOR (container);
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, &child))
{
ClutterLayoutMeta *meta;
ClutterBinLayer *layer;
ClutterActorBox child_alloc = { 0, };
gdouble x_align, y_align;
gboolean x_fill, y_fill, is_fixed_position_set;
float fixed_x, fixed_y;
if (!clutter_actor_is_visible (child))
continue;
meta = clutter_layout_manager_get_child_meta (manager,
container,
child);
layer = CLUTTER_BIN_LAYER (meta);
fixed_x = fixed_y = 0.f;
g_object_get (child,
"fixed-position-set", &is_fixed_position_set,
"fixed-x", &fixed_x,
"fixed-y", &fixed_y,
NULL);
/* XXX:2.0 - remove the FIXED alignment, and just use the fixed position
* of the actor if one is set
*/
if (is_fixed_position_set ||
layer->x_align == CLUTTER_BIN_ALIGNMENT_FIXED)
{
if (is_fixed_position_set)
child_alloc.x1 = fixed_x;
else
child_alloc.x1 = clutter_actor_get_x (child);
}
else
child_alloc.x1 = allocation_x;
if (is_fixed_position_set ||
layer->y_align == CLUTTER_BIN_ALIGNMENT_FIXED)
{
if (is_fixed_position_set)
child_alloc.y1 = fixed_y;
else
child_alloc.y1 = clutter_actor_get_y (child);
}
else
child_alloc.y1 = allocation_y;
child_alloc.x2 = allocation_x + available_w;
child_alloc.y2 = allocation_y + available_h;
if (clutter_actor_needs_expand (child, CLUTTER_ORIENTATION_HORIZONTAL))
{
ClutterActorAlign align;
align = clutter_actor_get_x_align (child);
x_fill = align == CLUTTER_ACTOR_ALIGN_FILL;
x_align = get_actor_align_factor (align);
}
else
{
ClutterTextDirection text_dir;
x_fill = (layer->x_align == CLUTTER_BIN_ALIGNMENT_FILL);
text_dir = clutter_actor_get_text_direction (child);
if (!is_fixed_position_set)
x_align = get_bin_alignment_factor (layer->x_align, text_dir);
else
x_align = 0.0;
}
if (clutter_actor_needs_expand (child, CLUTTER_ORIENTATION_VERTICAL))
{
ClutterActorAlign align;
align = clutter_actor_get_y_align (child);
y_fill = align == CLUTTER_ACTOR_ALIGN_FILL;
y_align = get_actor_align_factor (align);
}
else
{
y_fill = (layer->y_align == CLUTTER_BIN_ALIGNMENT_FILL);
if (!is_fixed_position_set)
y_align = get_bin_alignment_factor (layer->y_align,
CLUTTER_TEXT_DIRECTION_LTR);
else
y_align = 0.0;
}
clutter_actor_allocate_align_fill (child, &child_alloc,
x_align, y_align,
x_fill, y_fill,
flags);
}
}
static GType
clutter_bin_layout_get_child_meta_type (ClutterLayoutManager *manager)
{
return CLUTTER_TYPE_BIN_LAYER;
}
static ClutterLayoutMeta *
clutter_bin_layout_create_child_meta (ClutterLayoutManager *manager,
ClutterContainer *container,
ClutterActor *actor)
{
ClutterBinLayoutPrivate *priv;
priv = CLUTTER_BIN_LAYOUT (manager)->priv;
return g_object_new (CLUTTER_TYPE_BIN_LAYER,
"container", container,
"actor", actor,
"manager", manager,
"x-align", priv->x_align,
"y_align", priv->y_align,
NULL);
}
static void
clutter_bin_layout_set_container (ClutterLayoutManager *manager,
ClutterContainer *container)
{
ClutterBinLayoutPrivate *priv;
ClutterLayoutManagerClass *parent_class;
priv = CLUTTER_BIN_LAYOUT (manager)->priv;
priv->container = container;
parent_class = CLUTTER_LAYOUT_MANAGER_CLASS (clutter_bin_layout_parent_class);
parent_class->set_container (manager, container);
}
static void
clutter_bin_layout_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterBinLayout *layout = CLUTTER_BIN_LAYOUT (gobject);
switch (prop_id)
{
case PROP_X_ALIGN:
set_x_align (layout, g_value_get_enum (value));
break;
case PROP_Y_ALIGN:
set_y_align (layout, g_value_get_enum (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_bin_layout_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterBinLayoutPrivate *priv;
priv = CLUTTER_BIN_LAYOUT (gobject)->priv;
switch (prop_id)
{
case PROP_X_ALIGN:
g_value_set_enum (value, priv->x_align);
break;
case PROP_Y_ALIGN:
g_value_set_enum (value, priv->y_align);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_bin_layout_class_init (ClutterBinLayoutClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterLayoutManagerClass *layout_class =
CLUTTER_LAYOUT_MANAGER_CLASS (klass);
/**
* ClutterBinLayout:x-align:
*
* The default horizontal alignment policy for actors managed
* by the #ClutterBinLayout
*
* Since: 1.2
*
* Deprecated: 1.12: Use the #ClutterActor:x-expand and the
* #ClutterActor:x-align properties on #ClutterActor instead.
*/
bin_props[PROP_X_ALIGN] =
g_param_spec_enum ("x-align",
P_("Horizontal Alignment"),
P_("Default horizontal alignment for the actors "
"inside the layout manager"),
CLUTTER_TYPE_BIN_ALIGNMENT,
CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_PARAM_READWRITE);
/**
* ClutterBinLayout:y-align:
*
* The default vertical alignment policy for actors managed
* by the #ClutterBinLayout
*
* Since: 1.2
*
* Deprecated: 1.12: Use the #ClutterActor:y-expand and the
* #ClutterActor:y-align properties on #ClutterActor instead.
*/
bin_props[PROP_Y_ALIGN] =
g_param_spec_enum ("y-align",
P_("Vertical Alignment"),
P_("Default vertical alignment for the actors "
"inside the layout manager"),
CLUTTER_TYPE_BIN_ALIGNMENT,
CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_PARAM_READWRITE);
gobject_class->set_property = clutter_bin_layout_set_property;
gobject_class->get_property = clutter_bin_layout_get_property;
g_object_class_install_properties (gobject_class, PROP_LAST, bin_props);
layout_class->get_preferred_width = clutter_bin_layout_get_preferred_width;
layout_class->get_preferred_height = clutter_bin_layout_get_preferred_height;
layout_class->allocate = clutter_bin_layout_allocate;
layout_class->create_child_meta = clutter_bin_layout_create_child_meta;
layout_class->get_child_meta_type = clutter_bin_layout_get_child_meta_type;
layout_class->set_container = clutter_bin_layout_set_container;
}
static void
clutter_bin_layout_init (ClutterBinLayout *self)
{
self->priv = clutter_bin_layout_get_instance_private (self);
self->priv->x_align = CLUTTER_BIN_ALIGNMENT_CENTER;
self->priv->y_align = CLUTTER_BIN_ALIGNMENT_CENTER;
}
/**
* clutter_bin_layout_new:
* @x_align: the default alignment policy to be used on the
* horizontal axis
* @y_align: the default alignment policy to be used on the
* vertical axis
*
* Creates a new #ClutterBinLayout layout manager
*
* Return value: the newly created layout manager
*
* Since: 1.2
*/
ClutterLayoutManager *
clutter_bin_layout_new (ClutterBinAlignment x_align,
ClutterBinAlignment y_align)
{
return g_object_new (CLUTTER_TYPE_BIN_LAYOUT,
"x-align", x_align,
"y-align", y_align,
NULL);
}
muffin-6.4.1/clutter/clutter/clutter-graphene.h 0000664 0001750 0001750 00000001742 14723361714 020534 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Georges Basile Stavracas Neto
*
* Copyright (C) 2019 Endless, Inc
* Copyright (C) 2009, 2010 Intel Corp
*
* 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 .
*/
#ifndef CLUTTER_GRAPHENE_H
#define CLUTTER_GRAPHENE_H
void clutter_graphene_init (void);
#endif
muffin-6.4.1/clutter/clutter/clutter-input-device-tool.h 0000664 0001750 0001750 00000005070 14723361714 022310 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright © 2009, 2010, 2011 Intel Corp.
*
* 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 .
*
* Author: Carlos Garnacho
*/
#ifndef __CLUTTER_INPUT_DEVICE_TOOL_H__
#define __CLUTTER_INPUT_DEVICE_TOOL_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include "clutter-enum-types.h"
G_BEGIN_DECLS
#define CLUTTER_TYPE_INPUT_DEVICE_TOOL (clutter_input_device_tool_get_type ())
#define CLUTTER_INPUT_DEVICE_TOOL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_INPUT_DEVICE_TOOL, ClutterInputDeviceTool))
#define CLUTTER_IS_INPUT_DEVICE_TOOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_INPUT_DEVICE_TOOL))
#define CLUTTER_INPUT_DEVICE_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_INPUT_DEVICE_TOOL, ClutterInputDeviceToolClass))
#define CLUTTER_IS_INPUT_DEVICE_TOOL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_INPUT_DEVICE_TOOL))
#define CLUTTER_INPUT_DEVICE_TOOL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_INPUT_DEVICE_TOOL, ClutterInputDeviceToolClass))
typedef struct _ClutterInputDeviceToolClass ClutterInputDeviceToolClass;
struct _ClutterInputDeviceTool
{
GObject parent_instance;
};
struct _ClutterInputDeviceToolClass
{
GObjectClass parent_class;
};
CLUTTER_EXPORT
GType clutter_input_device_tool_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
guint64 clutter_input_device_tool_get_serial (ClutterInputDeviceTool *tool);
CLUTTER_EXPORT
ClutterInputDeviceToolType clutter_input_device_tool_get_tool_type (ClutterInputDeviceTool *tool);
CLUTTER_EXPORT
guint64 clutter_input_device_tool_get_id (ClutterInputDeviceTool *tool);
G_END_DECLS
#endif /* __CLUTTER_INPUT_DEVICE_TOOL_H__ */
muffin-6.4.1/clutter/clutter/clutter-input-device.h 0000664 0001750 0001750 00000024431 14723361714 021337 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright © 2009, 2010, 2011 Intel Corp.
*
* 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 .
*
* Author: Emmanuele Bassi
*/
#ifndef __CLUTTER_INPUT_DEVICE_H__
#define __CLUTTER_INPUT_DEVICE_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
#include
G_BEGIN_DECLS
typedef void (*ClutterEmitInputDeviceEvent) (ClutterEvent *event,
ClutterInputDevice *device);
struct _ClutterInputDeviceClass
{
GObjectClass parent_class;
gboolean (* keycode_to_evdev) (ClutterInputDevice *device,
guint hardware_keycode,
guint *evdev_keycode);
void (* update_from_tool) (ClutterInputDevice *device,
ClutterInputDeviceTool *tool);
gboolean (* is_mode_switch_button) (ClutterInputDevice *device,
guint group,
guint button);
gint (* get_group_n_modes) (ClutterInputDevice *device,
gint group);
gboolean (* is_grouped) (ClutterInputDevice *device,
ClutterInputDevice *other_device);
/* Keyboard accessbility */
void (* process_kbd_a11y_event) (ClutterEvent *event,
ClutterInputDevice *device,
ClutterEmitInputDeviceEvent emit_event_func);
};
#define CLUTTER_TYPE_INPUT_DEVICE (clutter_input_device_get_type ())
#define CLUTTER_INPUT_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_INPUT_DEVICE, ClutterInputDevice))
#define CLUTTER_IS_INPUT_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_INPUT_DEVICE))
#define CLUTTER_INPUT_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_INPUT_DEVICE, ClutterInputDeviceClass))
#define CLUTTER_IS_INPUT_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_INPUT_DEVICE))
#define CLUTTER_INPUT_DEVICE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_INPUT_DEVICE, ClutterInputDeviceClass))
/**
* ClutterInputDevice:
*
* Generic representation of an input device. The actual contents of this
* structure depend on the backend used.
*/
typedef struct _ClutterInputDeviceClass ClutterInputDeviceClass;
CLUTTER_EXPORT
GType clutter_input_device_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterInputDeviceType clutter_input_device_get_device_type (ClutterInputDevice *device);
CLUTTER_EXPORT
gint clutter_input_device_get_device_id (ClutterInputDevice *device);
CLUTTER_EXPORT
gboolean clutter_input_device_get_coords (ClutterInputDevice *device,
ClutterEventSequence *sequence,
graphene_point_t *point);
CLUTTER_EXPORT
ClutterModifierType clutter_input_device_get_modifier_state (ClutterInputDevice *device);
CLUTTER_EXPORT
ClutterActor * clutter_input_device_get_pointer_actor (ClutterInputDevice *device);
CLUTTER_EXPORT
ClutterStage * clutter_input_device_get_pointer_stage (ClutterInputDevice *device);
CLUTTER_EXPORT
const gchar * clutter_input_device_get_device_name (ClutterInputDevice *device);
CLUTTER_EXPORT
ClutterInputMode clutter_input_device_get_device_mode (ClutterInputDevice *device);
CLUTTER_EXPORT
gboolean clutter_input_device_get_has_cursor (ClutterInputDevice *device);
CLUTTER_EXPORT
void clutter_input_device_set_enabled (ClutterInputDevice *device,
gboolean enabled);
CLUTTER_EXPORT
gboolean clutter_input_device_get_enabled (ClutterInputDevice *device);
CLUTTER_EXPORT
guint clutter_input_device_get_n_axes (ClutterInputDevice *device);
CLUTTER_EXPORT
ClutterInputAxis clutter_input_device_get_axis (ClutterInputDevice *device,
guint index_);
CLUTTER_EXPORT
gboolean clutter_input_device_get_axis_value (ClutterInputDevice *device,
gdouble *axes,
ClutterInputAxis axis,
gdouble *value);
CLUTTER_EXPORT
guint clutter_input_device_get_n_keys (ClutterInputDevice *device);
CLUTTER_EXPORT
void clutter_input_device_set_key (ClutterInputDevice *device,
guint index_,
guint keyval,
ClutterModifierType modifiers);
CLUTTER_EXPORT
gboolean clutter_input_device_get_key (ClutterInputDevice *device,
guint index_,
guint *keyval,
ClutterModifierType *modifiers);
CLUTTER_EXPORT
ClutterInputDevice * clutter_input_device_get_associated_device (ClutterInputDevice *device);
CLUTTER_EXPORT
GList * clutter_input_device_get_slave_devices (ClutterInputDevice *device);
CLUTTER_EXPORT
void clutter_input_device_update_from_event (ClutterInputDevice *device,
ClutterEvent *event,
gboolean update_stage);
CLUTTER_EXPORT
void clutter_input_device_grab (ClutterInputDevice *device,
ClutterActor *actor);
CLUTTER_EXPORT
void clutter_input_device_ungrab (ClutterInputDevice *device);
CLUTTER_EXPORT
ClutterActor * clutter_input_device_get_grabbed_actor (ClutterInputDevice *device);
CLUTTER_EXPORT
void clutter_input_device_sequence_grab (ClutterInputDevice *device,
ClutterEventSequence *sequence,
ClutterActor *actor);
CLUTTER_EXPORT
void clutter_input_device_sequence_ungrab (ClutterInputDevice *device,
ClutterEventSequence *sequence);
CLUTTER_EXPORT
ClutterActor * clutter_input_device_sequence_get_grabbed_actor (ClutterInputDevice *device,
ClutterEventSequence *sequence);
CLUTTER_EXPORT
gboolean clutter_input_device_keycode_to_evdev (ClutterInputDevice *device,
guint hardware_keycode,
guint *evdev_keycode);
CLUTTER_EXPORT
const gchar * clutter_input_device_get_vendor_id (ClutterInputDevice *device);
CLUTTER_EXPORT
const gchar * clutter_input_device_get_product_id (ClutterInputDevice *device);
CLUTTER_EXPORT
gint clutter_input_device_get_n_rings (ClutterInputDevice *device);
CLUTTER_EXPORT
gint clutter_input_device_get_n_strips (ClutterInputDevice *device);
CLUTTER_EXPORT
gint clutter_input_device_get_n_mode_groups (ClutterInputDevice *device);
CLUTTER_EXPORT
gint clutter_input_device_get_group_n_modes (ClutterInputDevice *device,
gint group);
CLUTTER_EXPORT
gboolean clutter_input_device_is_mode_switch_button (ClutterInputDevice *device,
guint group,
guint button);
CLUTTER_EXPORT
gint clutter_input_device_get_mode_switch_button_group (ClutterInputDevice *device,
guint button);
CLUTTER_EXPORT
const gchar * clutter_input_device_get_device_node (ClutterInputDevice *device);
CLUTTER_EXPORT
ClutterInputDeviceMapping clutter_input_device_get_mapping_mode (ClutterInputDevice *device);
CLUTTER_EXPORT
void clutter_input_device_set_mapping_mode (ClutterInputDevice *device,
ClutterInputDeviceMapping mapping);
CLUTTER_EXPORT
gboolean clutter_input_device_is_grouped (ClutterInputDevice *device,
ClutterInputDevice *other_device);
CLUTTER_EXPORT
ClutterSeat * clutter_input_device_get_seat (ClutterInputDevice *device);
G_END_DECLS
#endif /* __CLUTTER_INPUT_DEVICE_H__ */
muffin-6.4.1/clutter/clutter/clutter-align-constraint.h 0000664 0001750 0001750 00000006037 14723361714 022221 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_ALIGN_CONSTRAINT_H__
#define __CLUTTER_ALIGN_CONSTRAINT_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_ALIGN_CONSTRAINT (clutter_align_constraint_get_type ())
#define CLUTTER_ALIGN_CONSTRAINT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ALIGN_CONSTRAINT, ClutterAlignConstraint))
#define CLUTTER_IS_ALIGN_CONSTRAINT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ALIGN_CONSTRAINT))
/**
* ClutterAlignConstraint:
*
* #ClutterAlignConstraint is an opaque structure
* whose members cannot be directly accesses
*
* Since: 1.4
*/
typedef struct _ClutterAlignConstraint ClutterAlignConstraint;
typedef struct _ClutterAlignConstraintClass ClutterAlignConstraintClass;
CLUTTER_EXPORT
GType clutter_align_constraint_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterConstraint *clutter_align_constraint_new (ClutterActor *source,
ClutterAlignAxis axis,
gfloat factor);
CLUTTER_EXPORT
void clutter_align_constraint_set_source (ClutterAlignConstraint *align,
ClutterActor *source);
CLUTTER_EXPORT
ClutterActor * clutter_align_constraint_get_source (ClutterAlignConstraint *align);
CLUTTER_EXPORT
void clutter_align_constraint_set_align_axis (ClutterAlignConstraint *align,
ClutterAlignAxis axis);
CLUTTER_EXPORT
ClutterAlignAxis clutter_align_constraint_get_align_axis (ClutterAlignConstraint *align);
CLUTTER_EXPORT
void clutter_align_constraint_set_factor (ClutterAlignConstraint *align,
gfloat factor);
CLUTTER_EXPORT
gfloat clutter_align_constraint_get_factor (ClutterAlignConstraint *align);
G_END_DECLS
#endif /* __CLUTTER_ALIGN_CONSTRAINT_H__ */
muffin-6.4.1/clutter/clutter/clutter-paint-context.h 0000664 0001750 0001750 00000004263 14723361714 021541 0 ustar fabio fabio /*
* Copyright (C) 2019 Red Hat 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 .
*/
#ifndef CLUTTER_PAINT_CONTEXT_H
#define CLUTTER_PAINT_CONTEXT_H
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include "clutter-macros.h"
#include "clutter-stage-view.h"
typedef struct _ClutterPaintContext ClutterPaintContext;
#define CLUTTER_TYPE_PAINT_CONTEXT (clutter_paint_context_get_type ())
CLUTTER_EXPORT
GType clutter_paint_context_get_type (void);
CLUTTER_EXPORT
ClutterPaintContext * clutter_paint_context_new_for_framebuffer (CoglFramebuffer *framebuffer);
CLUTTER_EXPORT
ClutterPaintContext * clutter_paint_context_ref (ClutterPaintContext *paint_context);
CLUTTER_EXPORT
void clutter_paint_context_unref (ClutterPaintContext *paint_context);
CLUTTER_EXPORT
void clutter_paint_context_destroy (ClutterPaintContext *paint_context);
CLUTTER_EXPORT
CoglFramebuffer * clutter_paint_context_get_framebuffer (ClutterPaintContext *paint_context);
CLUTTER_EXPORT
ClutterStageView * clutter_paint_context_get_stage_view (ClutterPaintContext *paint_context);
CLUTTER_EXPORT
void clutter_paint_context_push_framebuffer (ClutterPaintContext *paint_context,
CoglFramebuffer *framebuffer);
CLUTTER_EXPORT
void clutter_paint_context_pop_framebuffer (ClutterPaintContext *paint_context);
CLUTTER_EXPORT
const cairo_region_t * clutter_paint_context_get_redraw_clip (ClutterPaintContext *paint_context);
#endif /* CLUTTER_PAINT_CONTEXT_H */
muffin-6.4.1/clutter/clutter/clutter-paint-context.c 0000664 0001750 0001750 00000012313 14723361714 021527 0 ustar fabio fabio /*
* Copyright (C) 2019 Red Hat 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 .
*/
#include "clutter-build-config.h"
#include "clutter-paint-context-private.h"
struct _ClutterPaintContext
{
grefcount ref_count;
ClutterPaintFlag paint_flags;
GList *framebuffers;
ClutterStageView *view;
cairo_region_t *redraw_clip;
};
G_DEFINE_BOXED_TYPE (ClutterPaintContext, clutter_paint_context,
clutter_paint_context_ref,
clutter_paint_context_unref)
ClutterPaintContext *
clutter_paint_context_new_for_view (ClutterStageView *view,
const cairo_region_t *redraw_clip,
ClutterPaintFlag paint_flags)
{
ClutterPaintContext *paint_context;
CoglFramebuffer *framebuffer;
paint_context = g_new0 (ClutterPaintContext, 1);
g_ref_count_init (&paint_context->ref_count);
paint_context->view = view;
paint_context->redraw_clip = cairo_region_copy (redraw_clip);
paint_context->paint_flags = paint_flags;
framebuffer = clutter_stage_view_get_framebuffer (view);
clutter_paint_context_push_framebuffer (paint_context, framebuffer);
return paint_context;
}
/**
* clutter_paint_context_new_for_framebuffer: (skip)
*/
ClutterPaintContext *
clutter_paint_context_new_for_framebuffer (CoglFramebuffer *framebuffer)
{
ClutterPaintContext *paint_context;
paint_context = g_new0 (ClutterPaintContext, 1);
g_ref_count_init (&paint_context->ref_count);
paint_context->paint_flags = (CLUTTER_PAINT_FLAG_NO_CURSORS |
CLUTTER_PAINT_FLAG_NO_PAINT_SIGNAL);
clutter_paint_context_push_framebuffer (paint_context, framebuffer);
return paint_context;
}
ClutterPaintContext *
clutter_paint_context_ref (ClutterPaintContext *paint_context)
{
g_ref_count_inc (&paint_context->ref_count);
return paint_context;
}
static void
clutter_paint_context_dispose (ClutterPaintContext *paint_context)
{
g_list_free_full (paint_context->framebuffers,
cogl_object_unref);
paint_context->framebuffers = NULL;
g_clear_pointer (&paint_context->redraw_clip, cairo_region_destroy);
}
void
clutter_paint_context_unref (ClutterPaintContext *paint_context)
{
if (g_ref_count_dec (&paint_context->ref_count))
{
clutter_paint_context_dispose (paint_context);
g_free (paint_context);
}
}
void
clutter_paint_context_destroy (ClutterPaintContext *paint_context)
{
clutter_paint_context_dispose (paint_context);
clutter_paint_context_unref (paint_context);
}
void
clutter_paint_context_push_framebuffer (ClutterPaintContext *paint_context,
CoglFramebuffer *framebuffer)
{
paint_context->framebuffers = g_list_prepend (paint_context->framebuffers,
cogl_object_ref (framebuffer));
}
void
clutter_paint_context_pop_framebuffer (ClutterPaintContext *paint_context)
{
g_return_if_fail (paint_context->framebuffers);
cogl_object_unref (paint_context->framebuffers->data);
paint_context->framebuffers =
g_list_delete_link (paint_context->framebuffers,
paint_context->framebuffers);
}
const cairo_region_t *
clutter_paint_context_get_redraw_clip (ClutterPaintContext *paint_context)
{
return paint_context->redraw_clip;
}
/**
* clutter_paint_context_get_framebuffer:
* @paint_context: The #ClutterPaintContext
*
* Returns: (transfer none): The #CoglFramebuffer used for drawing
*/
CoglFramebuffer *
clutter_paint_context_get_framebuffer (ClutterPaintContext *paint_context)
{
g_return_val_if_fail (paint_context->framebuffers, NULL);
return paint_context->framebuffers->data;
}
CoglFramebuffer *
clutter_paint_context_get_base_framebuffer (ClutterPaintContext *paint_context)
{
return g_list_last (paint_context->framebuffers)->data;
}
/**
* clutter_paint_context_get_stage_view: (skip)
*/
ClutterStageView *
clutter_paint_context_get_stage_view (ClutterPaintContext *paint_context)
{
return paint_context->view;
}
/**
* clutter_paint_context_is_drawing_off_stage: (skip)
*
* Return %TRUE if the paint context is currently drawing off stage.
* This happens if there are any framebuffers pushed, and the base framebuffer
* comes from the stage view.
*/
gboolean
clutter_paint_context_is_drawing_off_stage (ClutterPaintContext *paint_context)
{
if (g_list_length (paint_context->framebuffers) > 1)
return TRUE;
return !paint_context->view;
}
/**
* clutter_paint_context_get_paint_flags: (skip)
*/
ClutterPaintFlag
clutter_paint_context_get_paint_flags (ClutterPaintContext *paint_context)
{
return paint_context->paint_flags;
}
muffin-6.4.1/clutter/clutter/clutter-enum-types.c.in 0000664 0001750 0001750 00000001533 14723361714 021447 0 ustar fabio fabio /*** BEGIN file-header ***/
#include "clutter-build-config.h"
#include "clutter-enum-types.h"
/*** END file-header ***/
/*** BEGIN file-production ***/
/* enumerations from "@filename@" */
#include "@filename@"
/*** END file-production ***/
/*** BEGIN value-header ***/
GType
@enum_name@_get_type (void)
{
static gsize g_enum_type_id = 0;
if (g_once_init_enter (&g_enum_type_id))
{
static const G@Type@Value values[] = {
/*** END value-header ***/
/*** BEGIN value-production ***/
{ @VALUENAME@, "@VALUENAME@", "@valuenick@" },
/*** END value-production ***/
/*** BEGIN value-tail ***/
{ 0, NULL, NULL }
};
GType id;
id = g_@type@_register_static (g_intern_static_string ("@EnumName@"), values);
g_once_init_leave (&g_enum_type_id, id);
}
return g_enum_type_id;
}
/*** END value-tail ***/
muffin-6.4.1/clutter/clutter/clutter-snap-constraint.h 0000664 0001750 0001750 00000006731 14723361714 022071 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_SNAP_CONSTRAINT_H__
#define __CLUTTER_SNAP_CONSTRAINT_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_SNAP_CONSTRAINT (clutter_snap_constraint_get_type ())
#define CLUTTER_SNAP_CONSTRAINT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_SNAP_CONSTRAINT, ClutterSnapConstraint))
#define CLUTTER_IS_SNAP_CONSTRAINT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_SNAP_CONSTRAINT))
/**
* ClutterSnapConstraint:
*
* #ClutterSnapConstraint is an opaque structure
* whose members cannot be directly accesses
*
* Since: 1.6
*/
typedef struct _ClutterSnapConstraint ClutterSnapConstraint;
typedef struct _ClutterSnapConstraintClass ClutterSnapConstraintClass;
CLUTTER_EXPORT
GType clutter_snap_constraint_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterConstraint * clutter_snap_constraint_new (ClutterActor *source,
ClutterSnapEdge from_edge,
ClutterSnapEdge to_edge,
gfloat offset);
CLUTTER_EXPORT
void clutter_snap_constraint_set_source (ClutterSnapConstraint *constraint,
ClutterActor *source);
CLUTTER_EXPORT
ClutterActor * clutter_snap_constraint_get_source (ClutterSnapConstraint *constraint);
CLUTTER_EXPORT
void clutter_snap_constraint_set_edges (ClutterSnapConstraint *constraint,
ClutterSnapEdge from_edge,
ClutterSnapEdge to_edge);
CLUTTER_EXPORT
void clutter_snap_constraint_get_edges (ClutterSnapConstraint *constraint,
ClutterSnapEdge *from_edge,
ClutterSnapEdge *to_edge);
CLUTTER_EXPORT
void clutter_snap_constraint_set_offset (ClutterSnapConstraint *constraint,
gfloat offset);
CLUTTER_EXPORT
gfloat clutter_snap_constraint_get_offset (ClutterSnapConstraint *constraint);
G_END_DECLS
#endif /* __CLUTTER_SNAP_CONSTRAINT_H__ */
muffin-6.4.1/clutter/clutter/clutter-drop-action.c 0000664 0001750 0001750 00000037015 14723361714 021157 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright © 2011 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
/**
* SECTION:clutter-drop-action
* @Title: ClutterDropAction
* @short_description: An action for drop targets
*
* #ClutterDropAction is a #ClutterAction that allows a #ClutterActor
* implementation to control what happens when an actor dragged using
* a #ClutterDragAction crosses the target area or when a dragged actor
* is released (or "dropped") on the target area.
*
* A trivial use of #ClutterDropAction consists in connecting to the
* #ClutterDropAction::drop signal and handling the drop from there,
* for instance:
*
* |[
* ClutterAction *action = clutter_drop_action ();
*
* g_signal_connect (action, "drop", G_CALLBACK (on_drop), NULL);
* clutter_actor_add_action (an_actor, action);
* ]|
*
* The #ClutterDropAction::can-drop can be used to control whether the
* #ClutterDropAction::drop signal is going to be emitted; returning %FALSE
* from a handler connected to the #ClutterDropAction::can-drop signal will
* cause the #ClutterDropAction::drop signal to be skipped when the input
* device button is released.
*
* It's important to note that #ClutterDropAction will only work with
* actors dragged using #ClutterDragAction.
*
* See [drop-action.c](https://git.gnome.org/browse/clutter/tree/examples/drop-action.c?h=clutter-1.18)
* for an example of how to use #ClutterDropAction.
*
* #ClutterDropAction is available since Clutter 1.8
*/
#include "clutter-build-config.h"
#include "clutter-drop-action.h"
#include "clutter-actor-meta-private.h"
#include "clutter-actor-private.h"
#include "clutter-drag-action.h"
#include "clutter-main.h"
#include "clutter-marshal.h"
#include "clutter-stage-private.h"
struct _ClutterDropActionPrivate
{
ClutterActor *actor;
ClutterActor *stage;
gulong mapped_id;
};
typedef struct _DropTarget {
ClutterActor *stage;
gulong capture_id;
GHashTable *actions;
ClutterDropAction *last_action;
} DropTarget;
enum
{
CAN_DROP,
OVER_IN,
OVER_OUT,
DROP,
DROP_CANCEL,
LAST_SIGNAL
};
static guint drop_signals[LAST_SIGNAL] = { 0, };
G_DEFINE_TYPE_WITH_PRIVATE (ClutterDropAction, clutter_drop_action, CLUTTER_TYPE_ACTION)
static void
drop_target_free (gpointer _data)
{
DropTarget *data = _data;
g_clear_signal_handler (&data->capture_id, data->stage);
g_hash_table_destroy (data->actions);
g_free (data);
}
static gboolean
on_stage_capture (ClutterStage *stage,
ClutterEvent *event,
gpointer user_data)
{
DropTarget *data = user_data;
gfloat event_x, event_y;
ClutterActor *actor, *drag_actor;
ClutterDropAction *drop_action;
ClutterInputDevice *device;
gboolean was_reactive;
switch (clutter_event_type (event))
{
case CLUTTER_MOTION:
case CLUTTER_BUTTON_RELEASE:
if (clutter_event_type (event) == CLUTTER_MOTION &&
!(clutter_event_get_state (event) & CLUTTER_BUTTON1_MASK))
return CLUTTER_EVENT_PROPAGATE;
if (clutter_event_type (event) == CLUTTER_BUTTON_RELEASE &&
clutter_event_get_button (event) != CLUTTER_BUTTON_PRIMARY)
return CLUTTER_EVENT_PROPAGATE;
device = clutter_event_get_device (event);
drag_actor = _clutter_stage_get_pointer_drag_actor (stage, device);
if (drag_actor == NULL)
return CLUTTER_EVENT_PROPAGATE;
break;
case CLUTTER_TOUCH_UPDATE:
case CLUTTER_TOUCH_END:
drag_actor = _clutter_stage_get_touch_drag_actor (stage,
clutter_event_get_event_sequence (event));
if (drag_actor == NULL)
return CLUTTER_EVENT_PROPAGATE;
break;
default:
return CLUTTER_EVENT_PROPAGATE;
}
clutter_event_get_coords (event, &event_x, &event_y);
/* get the actor under the cursor, excluding the dragged actor; we
* use reactivity because it won't cause any scene invalidation
*/
was_reactive = clutter_actor_get_reactive (drag_actor);
clutter_actor_set_reactive (drag_actor, FALSE);
actor = clutter_stage_get_actor_at_pos (stage, CLUTTER_PICK_REACTIVE,
event_x,
event_y);
if (actor == NULL || actor == CLUTTER_ACTOR (stage))
{
if (data->last_action != NULL)
{
ClutterActorMeta *meta = CLUTTER_ACTOR_META (data->last_action);
g_signal_emit (data->last_action, drop_signals[OVER_OUT], 0,
clutter_actor_meta_get_actor (meta));
data->last_action = NULL;
}
goto out;
}
drop_action = g_hash_table_lookup (data->actions, actor);
if (drop_action == NULL)
{
if (data->last_action != NULL)
{
ClutterActorMeta *meta = CLUTTER_ACTOR_META (data->last_action);
g_signal_emit (data->last_action, drop_signals[OVER_OUT], 0,
clutter_actor_meta_get_actor (meta));
data->last_action = NULL;
}
goto out;
}
else
{
if (data->last_action != drop_action)
{
ClutterActorMeta *meta;
if (data->last_action != NULL)
{
meta = CLUTTER_ACTOR_META (data->last_action);
g_signal_emit (data->last_action, drop_signals[OVER_OUT], 0,
clutter_actor_meta_get_actor (meta));
}
meta = CLUTTER_ACTOR_META (drop_action);
g_signal_emit (drop_action, drop_signals[OVER_IN], 0,
clutter_actor_meta_get_actor (meta));
}
data->last_action = drop_action;
}
out:
if (clutter_event_type (event) == CLUTTER_BUTTON_RELEASE ||
clutter_event_type (event) == CLUTTER_TOUCH_END)
{
if (data->last_action != NULL)
{
ClutterActorMeta *meta = CLUTTER_ACTOR_META (data->last_action);
gboolean can_drop = FALSE;
g_signal_emit (data->last_action, drop_signals[CAN_DROP], 0,
clutter_actor_meta_get_actor (meta),
event_x, event_y,
&can_drop);
if (can_drop)
{
g_signal_emit (data->last_action, drop_signals[DROP], 0,
clutter_actor_meta_get_actor (meta),
event_x, event_y);
}
else
{
g_signal_emit (data->last_action, drop_signals[DROP_CANCEL], 0,
clutter_actor_meta_get_actor (meta),
event_x, event_y);
}
}
data->last_action = NULL;
}
if (drag_actor != NULL)
clutter_actor_set_reactive (drag_actor, was_reactive);
return CLUTTER_EVENT_PROPAGATE;
}
static void
drop_action_register (ClutterDropAction *self)
{
ClutterDropActionPrivate *priv = self->priv;
DropTarget *data;
g_assert (priv->stage != NULL);
data = g_object_get_data (G_OBJECT (priv->stage), "__clutter_drop_targets");
if (data == NULL)
{
data = g_new0 (DropTarget, 1);
data->stage = priv->stage;
data->actions = g_hash_table_new (NULL, NULL);
data->capture_id = g_signal_connect (priv->stage, "captured-event",
G_CALLBACK (on_stage_capture),
data);
g_object_set_data_full (G_OBJECT (priv->stage), "__clutter_drop_targets",
data,
drop_target_free);
}
g_hash_table_replace (data->actions, priv->actor, self);
}
static void
drop_action_unregister (ClutterDropAction *self)
{
ClutterDropActionPrivate *priv = self->priv;
DropTarget *data = NULL;
if (priv->stage != NULL)
data = g_object_get_data (G_OBJECT (priv->stage), "__clutter_drop_targets");
if (data == NULL)
return;
g_hash_table_remove (data->actions, priv->actor);
if (g_hash_table_size (data->actions) == 0)
g_object_set_data (G_OBJECT (data->stage), "__clutter_drop_targets", NULL);
}
static void
on_actor_mapped (ClutterActor *actor,
GParamSpec *pspec,
ClutterDropAction *self)
{
if (clutter_actor_is_mapped (actor))
{
if (self->priv->stage == NULL)
self->priv->stage = clutter_actor_get_stage (actor);
drop_action_register (self);
}
else
drop_action_unregister (self);
}
static void
clutter_drop_action_set_actor (ClutterActorMeta *meta,
ClutterActor *actor)
{
ClutterDropActionPrivate *priv = CLUTTER_DROP_ACTION (meta)->priv;
if (priv->actor != NULL)
{
drop_action_unregister (CLUTTER_DROP_ACTION (meta));
g_clear_signal_handler (&priv->mapped_id, priv->actor);
priv->stage = NULL;
priv->actor = NULL;
}
priv->actor = actor;
if (priv->actor != NULL)
{
priv->stage = clutter_actor_get_stage (actor);
priv->mapped_id = g_signal_connect (actor, "notify::mapped",
G_CALLBACK (on_actor_mapped),
meta);
if (priv->stage != NULL)
drop_action_register (CLUTTER_DROP_ACTION (meta));
}
CLUTTER_ACTOR_META_CLASS (clutter_drop_action_parent_class)->set_actor (meta, actor);
}
static gboolean
signal_accumulator (GSignalInvocationHint *ihint,
GValue *return_accu,
const GValue *handler_return,
gpointer user_data)
{
gboolean continue_emission;
continue_emission = g_value_get_boolean (handler_return);
g_value_set_boolean (return_accu, continue_emission);
return continue_emission;
}
static gboolean
clutter_drop_action_real_can_drop (ClutterDropAction *action,
ClutterActor *actor,
gfloat event_x,
gfloat event_y)
{
return TRUE;
}
static void
clutter_drop_action_class_init (ClutterDropActionClass *klass)
{
ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
meta_class->set_actor = clutter_drop_action_set_actor;
klass->can_drop = clutter_drop_action_real_can_drop;
/**
* ClutterDropAction::can-drop:
* @action: the #ClutterDropAction that emitted the signal
* @actor: the #ClutterActor attached to the @action
* @event_x: the X coordinate (in stage space) of the drop event
* @event_y: the Y coordinate (in stage space) of the drop event
*
* The ::can-drop signal is emitted when the dragged actor is dropped
* on @actor. The return value of the ::can-drop signal will determine
* whether or not the #ClutterDropAction::drop signal is going to be
* emitted on @action.
*
* The default implementation of #ClutterDropAction returns %TRUE for
* this signal.
*
* Return value: %TRUE if the drop is accepted, and %FALSE otherwise
*
* Since: 1.8
*/
drop_signals[CAN_DROP] =
g_signal_new (I_("can-drop"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterDropActionClass, can_drop),
signal_accumulator, NULL,
_clutter_marshal_BOOLEAN__OBJECT_FLOAT_FLOAT,
G_TYPE_BOOLEAN, 3,
CLUTTER_TYPE_ACTOR,
G_TYPE_FLOAT,
G_TYPE_FLOAT);
/**
* ClutterDropAction::over-in:
* @action: the #ClutterDropAction that emitted the signal
* @actor: the #ClutterActor attached to the @action
*
* The ::over-in signal is emitted when the dragged actor crosses
* into @actor.
*
* Since: 1.8
*/
drop_signals[OVER_IN] =
g_signal_new (I_("over-in"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterDropActionClass, over_in),
NULL, NULL, NULL,
G_TYPE_NONE, 1,
CLUTTER_TYPE_ACTOR);
/**
* ClutterDropAction::over-out:
* @action: the #ClutterDropAction that emitted the signal
* @actor: the #ClutterActor attached to the @action
*
* The ::over-out signal is emitted when the dragged actor crosses
* outside @actor.
*
* Since: 1.8
*/
drop_signals[OVER_OUT] =
g_signal_new (I_("over-out"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterDropActionClass, over_out),
NULL, NULL, NULL,
G_TYPE_NONE, 1,
CLUTTER_TYPE_ACTOR);
/**
* ClutterDropAction::drop:
* @action: the #ClutterDropAction that emitted the signal
* @actor: the #ClutterActor attached to the @action
* @event_x: the X coordinate (in stage space) of the drop event
* @event_y: the Y coordinate (in stage space) of the drop event
*
* The ::drop signal is emitted when the dragged actor is dropped
* on @actor. This signal is only emitted if at least an handler of
* #ClutterDropAction::can-drop returns %TRUE.
*
* Since: 1.8
*/
drop_signals[DROP] =
g_signal_new (I_("drop"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterDropActionClass, drop),
NULL, NULL,
_clutter_marshal_VOID__OBJECT_FLOAT_FLOAT,
G_TYPE_NONE, 3,
CLUTTER_TYPE_ACTOR,
G_TYPE_FLOAT,
G_TYPE_FLOAT);
/**
* ClutterDropAction::drop-cancel:
* @action: the #ClutterDropAction that emitted the signal
* @actor: the #ClutterActor attached to the @action
* @event_x: the X coordinate (in stage space) of the drop event
* @event_y: the Y coordinate (in stage space) of the drop event
*
* The ::drop-cancel signal is emitted when the drop is refused
* by an emission of the #ClutterDropAction::can-drop signal.
*
* After the ::drop-cancel signal is fired the active drag is
* terminated.
*
* Since: 1.12
*/
drop_signals[DROP_CANCEL] =
g_signal_new (I_("drop-cancel"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (ClutterDropActionClass, drop),
NULL, NULL,
_clutter_marshal_VOID__OBJECT_FLOAT_FLOAT,
G_TYPE_NONE, 3,
CLUTTER_TYPE_ACTOR,
G_TYPE_FLOAT,
G_TYPE_FLOAT);
}
static void
clutter_drop_action_init (ClutterDropAction *self)
{
self->priv = clutter_drop_action_get_instance_private (self);
}
/**
* clutter_drop_action_new:
*
* Creates a new #ClutterDropAction.
*
* Use clutter_actor_add_action() to add the action to a #ClutterActor.
*
* Return value: the newly created #ClutterDropAction
*
* Since: 1.8
*/
ClutterAction *
clutter_drop_action_new (void)
{
return g_object_new (CLUTTER_TYPE_DROP_ACTION, NULL);
}
muffin-6.4.1/clutter/clutter/clutter-input-device-tool.c 0000664 0001750 0001750 00000013204 14723361714 022301 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright © 2009, 2010, 2011 Intel Corp.
*
* 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 .
*
* Author: Carlos Garnacho
*/
#include "clutter-build-config.h"
#include "clutter-input-device-tool.h"
#include "clutter-private.h"
typedef struct _ClutterInputDeviceToolPrivate ClutterInputDeviceToolPrivate;
struct _ClutterInputDeviceToolPrivate
{
ClutterInputDeviceToolType type;
guint64 serial;
guint64 id;
};
enum
{
PROP_0,
PROP_TYPE,
PROP_SERIAL,
PROP_ID,
PROP_LAST
};
static GParamSpec *props[PROP_LAST] = { NULL, };
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (ClutterInputDeviceTool, clutter_input_device_tool, G_TYPE_OBJECT)
static void
clutter_input_device_tool_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterInputDeviceTool *tool = CLUTTER_INPUT_DEVICE_TOOL (object);
ClutterInputDeviceToolPrivate *priv;
priv = clutter_input_device_tool_get_instance_private (tool);
switch (prop_id)
{
case PROP_TYPE:
priv->type = g_value_get_enum (value);
break;
case PROP_SERIAL:
priv->serial = g_value_get_uint64 (value);
break;
case PROP_ID:
priv->id = g_value_get_uint64 (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
clutter_input_device_tool_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterInputDeviceTool *tool = CLUTTER_INPUT_DEVICE_TOOL (object);
ClutterInputDeviceToolPrivate *priv;
priv = clutter_input_device_tool_get_instance_private (tool);
switch (prop_id)
{
case PROP_TYPE:
g_value_set_enum (value, priv->type);
break;
case PROP_SERIAL:
g_value_set_uint64 (value, priv->serial);
break;
case PROP_ID:
g_value_set_uint64 (value, priv->id);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
clutter_input_device_tool_class_init (ClutterInputDeviceToolClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->set_property = clutter_input_device_tool_set_property;
gobject_class->get_property = clutter_input_device_tool_get_property;
props[PROP_TYPE] =
g_param_spec_enum ("type",
P_("Tool type"),
P_("Tool type"),
CLUTTER_TYPE_INPUT_DEVICE_TOOL_TYPE,
CLUTTER_INPUT_DEVICE_TOOL_NONE,
CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
props[PROP_SERIAL] =
g_param_spec_uint64 ("serial",
P_("Tool serial"),
P_("Tool serial"),
0, G_MAXUINT64, 0,
CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
props[PROP_ID] =
g_param_spec_uint64 ("id",
P_("Tool ID"),
P_("Tool ID"),
0, G_MAXUINT64, 0,
CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
g_object_class_install_properties (gobject_class, PROP_LAST, props);
}
static void
clutter_input_device_tool_init (ClutterInputDeviceTool *tool)
{
}
/**
* clutter_input_device_tool_get_serial:
* @tool: a #ClutterInputDeviceTool
*
* Gets the serial of this tool, this value can be used to identify a
* physical tool (eg. a tablet pen) across program executions.
*
* Returns: The serial ID for this tool
*
* Since: 1.28
**/
guint64
clutter_input_device_tool_get_serial (ClutterInputDeviceTool *tool)
{
ClutterInputDeviceToolPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE_TOOL (tool), 0);
priv = clutter_input_device_tool_get_instance_private (tool);
return priv->serial;
}
/**
* clutter_input_device_tool_get_tool_type:
* @tool: a #ClutterInputDeviceTool
*
* Gets the tool type of this tool.
*
* Returns: The tool type of this tool
*
* Since: 1.28
**/
ClutterInputDeviceToolType
clutter_input_device_tool_get_tool_type (ClutterInputDeviceTool *tool)
{
ClutterInputDeviceToolPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE_TOOL (tool), 0);
priv = clutter_input_device_tool_get_instance_private (tool);
return priv->type;
}
/**
* clutter_input_device_tool_get_id:
* @tool: a #ClutterInputDeviceTool
*
* Gets the ID of this tool, this value can be used to identify a
* physical tool (eg. a tablet pen) across program executions.
*
* Returns: The tool ID for this tool
**/
guint64
clutter_input_device_tool_get_id (ClutterInputDeviceTool *tool)
{
ClutterInputDeviceToolPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_INPUT_DEVICE_TOOL (tool), 0);
priv = clutter_input_device_tool_get_instance_private (tool);
return priv->id;
}
muffin-6.4.1/clutter/clutter/clutter-backend-private.h 0000664 0001750 0001750 00000015205 14723361714 022001 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*/
#ifndef __CLUTTER_BACKEND_PRIVATE_H__
#define __CLUTTER_BACKEND_PRIVATE_H__
#include
#include
#include
#define CLUTTER_BACKEND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_BACKEND, ClutterBackendClass))
#define CLUTTER_IS_BACKEND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_BACKEND))
#define CLUTTER_BACKEND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_BACKEND, ClutterBackendClass))
G_BEGIN_DECLS
typedef struct _ClutterBackendPrivate ClutterBackendPrivate;
struct _ClutterBackend
{
/*< private >*/
GObject parent_instance;
CoglRenderer *cogl_renderer;
CoglDisplay *cogl_display;
CoglContext *cogl_context;
GSource *cogl_source;
CoglOnscreen *dummy_onscreen;
cairo_font_options_t *font_options;
gchar *font_name;
gfloat units_per_em;
gint32 units_serial;
ClutterStageWindow *stage_window;
ClutterInputMethod *input_method;
};
struct _ClutterBackendClass
{
/*< private >*/
GObjectClass parent_class;
/* vfuncs */
gboolean (* pre_parse) (ClutterBackend *backend,
GError **error);
gboolean (* post_parse) (ClutterBackend *backend,
GError **error);
ClutterStageWindow * (* create_stage) (ClutterBackend *backend,
ClutterStage *wrapper,
GError **error);
void (* init_events) (ClutterBackend *backend);
void (* init_features) (ClutterBackend *backend);
void (* add_options) (ClutterBackend *backend,
GOptionGroup *group);
ClutterFeatureFlags (* get_features) (ClutterBackend *backend);
CoglRenderer * (* get_renderer) (ClutterBackend *backend,
GError **error);
CoglDisplay * (* get_display) (ClutterBackend *backend,
CoglRenderer *renderer,
CoglSwapChain *swap_chain,
GError **error);
gboolean (* create_context) (ClutterBackend *backend,
GError **error);
gboolean (* translate_event) (ClutterBackend *backend,
gpointer native,
ClutterEvent *event);
ClutterSeat * (* get_default_seat) (ClutterBackend *backend);
/* signals */
void (* resolution_changed) (ClutterBackend *backend);
void (* font_changed) (ClutterBackend *backend);
void (* settings_changed) (ClutterBackend *backend);
};
ClutterBackend * _clutter_create_backend (void);
ClutterStageWindow * _clutter_backend_create_stage (ClutterBackend *backend,
ClutterStage *wrapper,
GError **error);
gboolean _clutter_backend_create_context (ClutterBackend *backend,
GError **error);
void _clutter_backend_add_options (ClutterBackend *backend,
GOptionGroup *group);
gboolean _clutter_backend_pre_parse (ClutterBackend *backend,
GError **error);
gboolean _clutter_backend_post_parse (ClutterBackend *backend,
GError **error);
void _clutter_backend_init_events (ClutterBackend *backend);
void _clutter_backend_copy_event_data (ClutterBackend *backend,
const ClutterEvent *src,
ClutterEvent *dest);
void _clutter_backend_free_event_data (ClutterBackend *backend,
ClutterEvent *event);
CLUTTER_EXPORT
gboolean _clutter_backend_translate_event (ClutterBackend *backend,
gpointer native,
ClutterEvent *event);
ClutterFeatureFlags _clutter_backend_get_features (ClutterBackend *backend);
gfloat _clutter_backend_get_units_per_em (ClutterBackend *backend,
PangoFontDescription *font_desc);
gint32 _clutter_backend_get_units_serial (ClutterBackend *backend);
void clutter_set_allowed_drivers (const char *drivers);
CLUTTER_EXPORT
ClutterStageWindow * clutter_backend_get_stage_window (ClutterBackend *backend);
G_END_DECLS
#endif /* __CLUTTER_BACKEND_PRIVATE_H__ */
muffin-6.4.1/clutter/clutter/clutter-seat.c 0000664 0001750 0001750 00000053144 14723361714 017675 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2019 Red Hat 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 .
*
* Author: Carlos Garnacho
*/
#include "clutter-build-config.h"
#include "clutter-backend-private.h"
#include "clutter-input-device-tool.h"
#include "clutter-input-pointer-a11y-private.h"
#include "clutter-marshal.h"
#include "clutter-private.h"
#include "clutter-seat.h"
#include "clutter-virtual-input-device.h"
enum
{
DEVICE_ADDED,
DEVICE_REMOVED,
TOOL_CHANGED,
KBD_A11Y_MASK_CHANGED,
KBD_A11Y_FLAGS_CHANGED,
PTR_A11Y_DWELL_CLICK_TYPE_CHANGED,
PTR_A11Y_TIMEOUT_STARTED,
PTR_A11Y_TIMEOUT_STOPPED,
IS_UNFOCUS_INHIBITED_CHANGED,
N_SIGNALS,
};
static guint signals[N_SIGNALS] = { 0 };
enum
{
PROP_0,
PROP_BACKEND,
PROP_TOUCH_MODE,
N_PROPS
};
static GParamSpec *props[N_PROPS];
typedef struct _ClutterSeatPrivate ClutterSeatPrivate;
struct _ClutterSeatPrivate
{
ClutterBackend *backend;
unsigned int inhibit_unfocus_count;
/* Keyboard a11y */
ClutterKbdA11ySettings kbd_a11y_settings;
/* Pointer a11y */
ClutterPointerA11ySettings pointer_a11y_settings;
};
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (ClutterSeat, clutter_seat, G_TYPE_OBJECT)
static void
clutter_seat_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterSeat *seat = CLUTTER_SEAT (object);
ClutterSeatPrivate *priv = clutter_seat_get_instance_private (seat);
switch (prop_id)
{
case PROP_BACKEND:
priv->backend = g_value_get_object (value);
break;
case PROP_TOUCH_MODE:
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
clutter_seat_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterSeat *seat = CLUTTER_SEAT (object);
ClutterSeatPrivate *priv = clutter_seat_get_instance_private (seat);
switch (prop_id)
{
case PROP_BACKEND:
g_value_set_object (value, priv->backend);
break;
case PROP_TOUCH_MODE:
g_value_set_boolean (value, FALSE);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
clutter_seat_finalize (GObject *object)
{
ClutterSeat *seat = CLUTTER_SEAT (object);
ClutterSeatPrivate *priv = clutter_seat_get_instance_private (seat);
g_clear_object (&priv->backend);
G_OBJECT_CLASS (clutter_seat_parent_class)->finalize (object);
}
static void
clutter_seat_class_init (ClutterSeatClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->set_property = clutter_seat_set_property;
object_class->get_property = clutter_seat_get_property;
object_class->finalize = clutter_seat_finalize;
signals[DEVICE_ADDED] =
g_signal_new (I_("device-added"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 1,
CLUTTER_TYPE_INPUT_DEVICE);
signals[DEVICE_REMOVED] =
g_signal_new (I_("device-removed"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 1,
CLUTTER_TYPE_INPUT_DEVICE);
signals[TOOL_CHANGED] =
g_signal_new (I_("tool-changed"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0, NULL, NULL,
_clutter_marshal_VOID__OBJECT_OBJECT,
G_TYPE_NONE, 2,
CLUTTER_TYPE_INPUT_DEVICE,
CLUTTER_TYPE_INPUT_DEVICE_TOOL);
g_signal_set_va_marshaller (signals[TOOL_CHANGED],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_VOID__OBJECT_OBJECTv);
/**
* ClutterSeat::kbd-a11y-mods-state-changed:
* @seat: the #ClutterSeat that emitted the signal
* @latched_mask: the latched modifier mask from stickykeys
* @locked_mask: the locked modifier mask from stickykeys
*
* The ::kbd-a11y-mods-state-changed signal is emitted each time either the
* latched modifiers mask or locked modifiers mask are changed as the
* result of keyboard accessibilty's sticky keys operations.
*/
signals[KBD_A11Y_MASK_CHANGED] =
g_signal_new (I_("kbd-a11y-mods-state-changed"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0, NULL, NULL,
_clutter_marshal_VOID__UINT_UINT,
G_TYPE_NONE, 2,
G_TYPE_UINT,
G_TYPE_UINT);
g_signal_set_va_marshaller (signals[KBD_A11Y_MASK_CHANGED],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_VOID__UINT_UINTv);
/**
* ClutterSeat::kbd-a11y-flags-changed:
* @seat: the #ClutterSeat that emitted the signal
* @settings_flags: the new ClutterKeyboardA11yFlags configuration
* @changed_mask: the ClutterKeyboardA11yFlags changed
*
* The ::kbd-a11y-flags-changed signal is emitted each time the
* ClutterKeyboardA11yFlags configuration is changed as the result of
* keyboard accessibility operations.
*/
signals[KBD_A11Y_FLAGS_CHANGED] =
g_signal_new (I_("kbd-a11y-flags-changed"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0, NULL, NULL,
_clutter_marshal_VOID__UINT_UINT,
G_TYPE_NONE, 2,
G_TYPE_UINT,
G_TYPE_UINT);
g_signal_set_va_marshaller (signals[KBD_A11Y_FLAGS_CHANGED],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_VOID__UINT_UINTv);
/**
* ClutterSeat::ptr-a11y-dwell-click-type-changed:
* @seat: the #ClutterSeat that emitted the signal
* @click_type: the new #ClutterPointerA11yDwellClickType mode
*
* The ::ptr-a11y-dwell-click-type-changed signal is emitted each time
* the ClutterPointerA11yDwellClickType mode is changed as the result
* of pointer accessibility operations.
*/
signals[PTR_A11Y_DWELL_CLICK_TYPE_CHANGED] =
g_signal_new (I_("ptr-a11y-dwell-click-type-changed"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 1,
CLUTTER_TYPE_POINTER_A11Y_DWELL_CLICK_TYPE);
/**
* ClutterSeat::ptr-a11y-timeout-started:
* @seat: the #ClutterSeat that emitted the signal
* @device: the core pointer #ClutterInputDevice
* @timeout_type: the type of timeout #ClutterPointerA11yTimeoutType
* @delay: the delay in ms before secondary-click is triggered.
*
* The ::ptr-a11y-timeout-started signal is emitted when a
* pointer accessibility timeout delay is started, so that upper
* layers can notify the user with some visual feedback.
*/
signals[PTR_A11Y_TIMEOUT_STARTED] =
g_signal_new (I_("ptr-a11y-timeout-started"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0, NULL, NULL,
_clutter_marshal_VOID__OBJECT_FLAGS_UINT,
G_TYPE_NONE, 3,
CLUTTER_TYPE_INPUT_DEVICE,
CLUTTER_TYPE_POINTER_A11Y_TIMEOUT_TYPE,
G_TYPE_UINT);
g_signal_set_va_marshaller (signals[PTR_A11Y_TIMEOUT_STARTED],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_VOID__OBJECT_FLAGS_UINTv);
/**
* ClutterSeat::ptr-a11y-timeout-stopped:
* @seat: the #ClutterSeat that emitted the signal
* @device: the core pointer #ClutterInputDevice
* @timeout_type: the type of timeout #ClutterPointerA11yTimeoutType
* @clicked: %TRUE if the timeout finished and triggered a click
*
* The ::ptr-a11y-timeout-stopped signal is emitted when a running
* pointer accessibility timeout delay is stopped, either because
* it's triggered at the end of the delay or cancelled, so that
* upper layers can notify the user with some visual feedback.
*/
signals[PTR_A11Y_TIMEOUT_STOPPED] =
g_signal_new (I_("ptr-a11y-timeout-stopped"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0, NULL, NULL,
_clutter_marshal_VOID__OBJECT_FLAGS_BOOLEAN,
G_TYPE_NONE, 3,
CLUTTER_TYPE_INPUT_DEVICE,
CLUTTER_TYPE_POINTER_A11Y_TIMEOUT_TYPE,
G_TYPE_BOOLEAN);
g_signal_set_va_marshaller (signals[PTR_A11Y_TIMEOUT_STOPPED],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_VOID__OBJECT_FLAGS_BOOLEANv);
/**
* ClutterSeat::is-unfocus-inhibited-changed:
* @seat: the #ClutterSeat that emitted the signal
*
* The ::is-unfocus-inhibited-changed signal is emitted when the
* property to inhibit the unsetting of the focus-surface of the
* #ClutterSeat changed. To get the current state of this property,
* use clutter_seat_is_unfocus_inhibited().
*/
signals[IS_UNFOCUS_INHIBITED_CHANGED] =
g_signal_new (I_("is-unfocus-inhibited-changed"),
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 0);
props[PROP_BACKEND] =
g_param_spec_object ("backend",
P_("Backend"),
P_("Backend"),
CLUTTER_TYPE_BACKEND,
CLUTTER_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
/**
* ClutterSeat:touch-mode:
*
* The current touch-mode of the #ClutterSeat, it is set to %TRUE if the
* requirements documented in clutter_seat_get_touch_mode() are fulfilled.
**/
props[PROP_TOUCH_MODE] =
g_param_spec_boolean ("touch-mode",
P_("Touch mode"),
P_("Touch mode"),
FALSE,
CLUTTER_PARAM_READABLE);
g_object_class_install_properties (object_class, N_PROPS, props);
}
static void
clutter_seat_init (ClutterSeat *seat)
{
}
/**
* clutter_seat_get_pointer:
* @seat: a #ClutterSeat
*
* Returns the master pointer
*
* Returns: (transfer none): the master pointer
**/
ClutterInputDevice *
clutter_seat_get_pointer (ClutterSeat *seat)
{
g_return_val_if_fail (CLUTTER_IS_SEAT (seat), NULL);
return CLUTTER_SEAT_GET_CLASS (seat)->get_pointer (seat);
}
/**
* clutter_seat_get_keyboard:
* @seat: a #ClutterSeat
*
* Returns the master keyboard
*
* Returns: (transfer none): the master keyboard
**/
ClutterInputDevice *
clutter_seat_get_keyboard (ClutterSeat *seat)
{
g_return_val_if_fail (CLUTTER_IS_SEAT (seat), NULL);
return CLUTTER_SEAT_GET_CLASS (seat)->get_keyboard (seat);
}
/**
* clutter_seat_list_devices:
* @seat: a #ClutterSeat
*
* Returns the list of HW devices
*
* Returns: (transfer container) (element-type Clutter.InputDevice): A list
* of #ClutterInputDevice. The elements of the returned list are owned by
* Clutter and may not be freed, the returned list should be freed using
* g_list_free() when done.
**/
GList *
clutter_seat_list_devices (ClutterSeat *seat)
{
g_return_val_if_fail (CLUTTER_IS_SEAT (seat), NULL);
return CLUTTER_SEAT_GET_CLASS (seat)->list_devices (seat);
}
void
clutter_seat_bell_notify (ClutterSeat *seat)
{
CLUTTER_SEAT_GET_CLASS (seat)->bell_notify (seat);
}
/**
* clutter_seat_get_keymap:
* @seat: a #ClutterSeat
*
* Returns the seat keymap
*
* Returns: (transfer none): the seat keymap
**/
ClutterKeymap *
clutter_seat_get_keymap (ClutterSeat *seat)
{
return CLUTTER_SEAT_GET_CLASS (seat)->get_keymap (seat);
}
static gboolean
are_kbd_a11y_settings_equal (ClutterKbdA11ySettings *a,
ClutterKbdA11ySettings *b)
{
return (memcmp (a, b, sizeof (ClutterKbdA11ySettings)) == 0);
}
void
clutter_seat_set_kbd_a11y_settings (ClutterSeat *seat,
ClutterKbdA11ySettings *settings)
{
ClutterSeatClass *seat_class;
ClutterSeatPrivate *priv = clutter_seat_get_instance_private (seat);
g_return_if_fail (CLUTTER_IS_SEAT (seat));
if (are_kbd_a11y_settings_equal (&priv->kbd_a11y_settings, settings))
return;
priv->kbd_a11y_settings = *settings;
seat_class = CLUTTER_SEAT_GET_CLASS (seat);
if (seat_class->apply_kbd_a11y_settings)
seat_class->apply_kbd_a11y_settings (seat, settings);
}
void
clutter_seat_get_kbd_a11y_settings (ClutterSeat *seat,
ClutterKbdA11ySettings *settings)
{
ClutterSeatPrivate *priv = clutter_seat_get_instance_private (seat);
g_return_if_fail (CLUTTER_IS_SEAT (seat));
*settings = priv->kbd_a11y_settings;
}
void
clutter_seat_ensure_a11y_state (ClutterSeat *seat)
{
ClutterInputDevice *core_pointer;
core_pointer = clutter_seat_get_pointer (seat);
if (core_pointer)
{
if (_clutter_is_input_pointer_a11y_enabled (core_pointer))
_clutter_input_pointer_a11y_add_device (core_pointer);
}
}
static gboolean
are_pointer_a11y_settings_equal (ClutterPointerA11ySettings *a,
ClutterPointerA11ySettings *b)
{
return (memcmp (a, b, sizeof (ClutterPointerA11ySettings)) == 0);
}
static void
clutter_seat_enable_pointer_a11y (ClutterSeat *seat)
{
ClutterInputDevice *core_pointer;
core_pointer = clutter_seat_get_pointer (seat);
_clutter_input_pointer_a11y_add_device (core_pointer);
}
static void
clutter_seat_disable_pointer_a11y (ClutterSeat *seat)
{
ClutterInputDevice *core_pointer;
core_pointer = clutter_seat_get_pointer (seat);
_clutter_input_pointer_a11y_remove_device (core_pointer);
}
/**
* clutter_seat_set_pointer_a11y_settings:
* @seat: a #ClutterSeat
* @settings: a pointer to a #ClutterPointerA11ySettings
*
* Sets the pointer accessibility settings
**/
void
clutter_seat_set_pointer_a11y_settings (ClutterSeat *seat,
ClutterPointerA11ySettings *settings)
{
ClutterSeatPrivate *priv = clutter_seat_get_instance_private (seat);
g_return_if_fail (CLUTTER_IS_SEAT (seat));
if (are_pointer_a11y_settings_equal (&priv->pointer_a11y_settings, settings))
return;
if (priv->pointer_a11y_settings.controls == 0 && settings->controls != 0)
clutter_seat_enable_pointer_a11y (seat);
else if (priv->pointer_a11y_settings.controls != 0 && settings->controls == 0)
clutter_seat_disable_pointer_a11y (seat);
priv->pointer_a11y_settings = *settings;
}
/**
* clutter_seat_get_pointer_a11y_settings:
* @seat: a #ClutterSeat
* @settings: a pointer to a #ClutterPointerA11ySettings
*
* Gets the current pointer accessibility settings
**/
void
clutter_seat_get_pointer_a11y_settings (ClutterSeat *seat,
ClutterPointerA11ySettings *settings)
{
ClutterSeatPrivate *priv = clutter_seat_get_instance_private (seat);
g_return_if_fail (CLUTTER_IS_SEAT (seat));
*settings = priv->pointer_a11y_settings;
}
/**
* clutter_seat_set_pointer_a11y_dwell_click_type:
* @seat: a #ClutterSeat
* @click_type: type of click as #ClutterPointerA11yDwellClickType
*
* Sets the dwell click type
**/
void
clutter_seat_set_pointer_a11y_dwell_click_type (ClutterSeat *seat,
ClutterPointerA11yDwellClickType click_type)
{
ClutterSeatPrivate *priv = clutter_seat_get_instance_private (seat);
g_return_if_fail (CLUTTER_IS_SEAT (seat));
priv->pointer_a11y_settings.dwell_click_type = click_type;
}
/**
* clutter_seat_inhibit_unfocus:
* @seat: a #ClutterSeat
*
* Inhibits unsetting of the pointer focus-surface for the #ClutterSeat @seat,
* this allows to keep using the pointer even when it's hidden.
*
* This property is refcounted, so clutter_seat_uninhibit_unfocus() must be
* called the exact same number of times as clutter_seat_inhibit_unfocus()
* was called before.
**/
void
clutter_seat_inhibit_unfocus (ClutterSeat *seat)
{
ClutterSeatPrivate *priv;
g_return_if_fail (CLUTTER_IS_SEAT (seat));
priv = clutter_seat_get_instance_private (seat);
priv->inhibit_unfocus_count++;
if (priv->inhibit_unfocus_count == 1)
g_signal_emit (G_OBJECT (seat), signals[IS_UNFOCUS_INHIBITED_CHANGED], 0);
}
/**
* clutter_seat_uninhibit_unfocus:
* @seat: a #ClutterSeat
*
* Disables the inhibiting of unsetting of the pointer focus-surface
* previously enabled by calling clutter_seat_inhibit_unfocus().
*
* This property is refcounted, so clutter_seat_uninhibit_unfocus() must be
* called the exact same number of times as clutter_seat_inhibit_unfocus()
* was called before.
**/
void
clutter_seat_uninhibit_unfocus (ClutterSeat *seat)
{
ClutterSeatPrivate *priv;
g_return_if_fail (CLUTTER_IS_SEAT (seat));
priv = clutter_seat_get_instance_private (seat);
if (priv->inhibit_unfocus_count == 0)
{
g_warning ("Called clutter_seat_uninhibit_unfocus without inhibiting before");
return;
}
priv->inhibit_unfocus_count--;
if (priv->inhibit_unfocus_count == 0)
g_signal_emit (G_OBJECT (seat), signals[IS_UNFOCUS_INHIBITED_CHANGED], 0);
}
/**
* clutter_seat_is_unfocus_inhibited:
* @seat: a #ClutterSeat
*
* Gets whether unsetting of the pointer focus-surface is inhibited
* for the #ClutterSeat @seat.
*
* Returns: %TRUE if unsetting is inhibited, %FALSE otherwise
**/
gboolean
clutter_seat_is_unfocus_inhibited (ClutterSeat *seat)
{
ClutterSeatPrivate *priv;
g_return_val_if_fail (CLUTTER_IS_SEAT (seat), FALSE);
priv = clutter_seat_get_instance_private (seat);
return priv->inhibit_unfocus_count > 0;
}
/**
* clutter_seat_create_virtual_device:
* @seat: a #ClutterSeat
* @device_type: the type of the virtual device
*
* Creates a virtual input device.
*
* Returns: (transfer full): a newly created virtual device
**/
ClutterVirtualInputDevice *
clutter_seat_create_virtual_device (ClutterSeat *seat,
ClutterInputDeviceType device_type)
{
ClutterSeatClass *seat_class;
g_return_val_if_fail (CLUTTER_IS_SEAT (seat), NULL);
seat_class = CLUTTER_SEAT_GET_CLASS (seat);
return seat_class->create_virtual_device (seat, device_type);
}
/**
* clutter_seat_supported_virtual_device_types: (skip)
*/
ClutterVirtualDeviceType
clutter_seat_get_supported_virtual_device_types (ClutterSeat *seat)
{
ClutterSeatClass *seat_class;
g_return_val_if_fail (CLUTTER_IS_SEAT (seat),
CLUTTER_VIRTUAL_DEVICE_TYPE_NONE);
seat_class = CLUTTER_SEAT_GET_CLASS (seat);
return seat_class->get_supported_virtual_device_types (seat);
}
void
clutter_seat_compress_motion (ClutterSeat *seat,
ClutterEvent *event,
const ClutterEvent *to_discard)
{
ClutterSeatClass *seat_class;
g_return_if_fail (CLUTTER_IS_SEAT (seat));
seat_class = CLUTTER_SEAT_GET_CLASS (seat);
if (seat_class->compress_motion)
seat_class->compress_motion (seat, event, to_discard);
}
gboolean
clutter_seat_handle_device_event (ClutterSeat *seat,
ClutterEvent *event)
{
ClutterSeatClass *seat_class;
ClutterInputDevice *device;
g_return_val_if_fail (CLUTTER_IS_SEAT (seat), FALSE);
g_return_val_if_fail (event, FALSE);
g_assert (event->type == CLUTTER_DEVICE_ADDED ||
event->type == CLUTTER_DEVICE_REMOVED);
seat_class = CLUTTER_SEAT_GET_CLASS (seat);
if (seat_class->handle_device_event)
{
if (!seat_class->handle_device_event (seat, event))
return FALSE;
}
device = clutter_event_get_source_device (event);
g_assert_true (CLUTTER_IS_INPUT_DEVICE (device));
switch (event->type)
{
case CLUTTER_DEVICE_ADDED:
g_signal_emit (seat, signals[DEVICE_ADDED], 0, device);
break;
case CLUTTER_DEVICE_REMOVED:
g_signal_emit (seat, signals[DEVICE_REMOVED], 0, device);
g_object_run_dispose (G_OBJECT (device));
break;
default:
break;
}
return TRUE;
}
void
clutter_seat_warp_pointer (ClutterSeat *seat,
int x,
int y)
{
g_return_if_fail (CLUTTER_IS_SEAT (seat));
CLUTTER_SEAT_GET_CLASS (seat)->warp_pointer (seat, x, y);
}
/**
* clutter_seat_get_touch_mode:
* @seat: a #ClutterSeat
*
* Gets the current touch-mode state of the #ClutterSeat @seat.
* The #ClutterSeat:touch-mode property is set to %TRUE if the following
* requirements are fulfilled:
*
* - A touchscreen is available
* - A tablet mode switch, if present, is enabled
*
* Returns: %TRUE if the device is a tablet that doesn't have an external
* keyboard attached, %FALSE otherwise.
**/
gboolean
clutter_seat_get_touch_mode (ClutterSeat *seat)
{
gboolean touch_mode;
g_return_val_if_fail (CLUTTER_IS_SEAT (seat), FALSE);
g_object_get (G_OBJECT (seat), "touch-mode", &touch_mode, NULL);
return touch_mode;
}
muffin-6.4.1/clutter/clutter/clutter-paint-nodes.h 0000664 0001750 0001750 00000021530 14723361714 021161 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2011 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_PAINT_NODES_H__
#define __CLUTTER_PAINT_NODES_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_COLOR_NODE (clutter_color_node_get_type ())
#define CLUTTER_COLOR_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_COLOR_NODE, ClutterColorNode))
#define CLUTTER_IS_COLOR_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_COLOR_NODE))
/**
* ClutterColorNode:
*
* The #ClutterTextNode structure is an opaque
* type whose members cannot be directly accessed.
*
* Since: 1.10
*/
typedef struct _ClutterColorNode ClutterColorNode;
typedef struct _ClutterColorNodeClass ClutterColorNodeClass;
CLUTTER_EXPORT
GType clutter_color_node_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterPaintNode * clutter_color_node_new (const ClutterColor *color);
#define CLUTTER_TYPE_TEXTURE_NODE (clutter_texture_node_get_type ())
#define CLUTTER_TEXTURE_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_TEXTURE_NODE, ClutterTextureNode))
#define CLUTTER_IS_TEXTURE_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_TEXTURE_NODE))
/**
* ClutterTextureNode:
*
* The #ClutterTextNode structure is an opaque
* type whose members cannot be directly accessed.
*
* Since: 1.10
*/
typedef struct _ClutterTextureNode ClutterTextureNode;
typedef struct _ClutterTextureNodeClass ClutterTextureNodeClass;
CLUTTER_EXPORT
GType clutter_texture_node_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterPaintNode * clutter_texture_node_new (CoglTexture *texture,
const ClutterColor *color,
ClutterScalingFilter min_filter,
ClutterScalingFilter mag_filter);
#define CLUTTER_TYPE_CLIP_NODE (clutter_clip_node_get_type ())
#define CLUTTER_CLIP_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_CLIP_NODE, ClutterClipNode))
#define CLUTTER_IS_CLIP_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_CLIP_NODE))
/**
* ClutterClipNode:
*
* The #ClutterTextNode structure is an opaque
* type whose members cannot be directly accessed.
*
* Since: 1.10
*/
typedef struct _ClutterClipNode ClutterClipNode;
typedef struct _ClutterClipNodeClass ClutterClipNodeClass;
CLUTTER_EXPORT
GType clutter_clip_node_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterPaintNode * clutter_clip_node_new (void);
#define CLUTTER_TYPE_PIPELINE_NODE (clutter_pipeline_node_get_type ())
#define CLUTTER_PIPELINE_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_PIPELINE_NODE, ClutterPipelineNode))
#define CLUTTER_IS_PIPELINE_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_PIPELINE_NODE))
/**
* ClutterPipelineNode:
*
* The #ClutterTextNode structure is an opaque
* type whose members cannot be directly accessed.
*
* Since: 1.10
*/
typedef struct _ClutterPipelineNode ClutterPipelineNode;
typedef struct _ClutterPipelineNodeClass ClutterPipelineNodeClass;
CLUTTER_EXPORT
GType clutter_pipeline_node_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterPaintNode * clutter_pipeline_node_new (CoglPipeline *pipeline);
#define CLUTTER_TYPE_TEXT_NODE (clutter_text_node_get_type ())
#define CLUTTER_TEXT_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_TEXT_NODE, ClutterTextNode))
#define CLUTTER_IS_TEXT_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_TEXT_NODE))
/**
* ClutterTextNode:
*
* The #ClutterTextNode structure is an opaque
* type whose members cannot be directly accessed.
*
* Since: 1.10
*/
typedef struct _ClutterTextNode ClutterTextNode;
typedef struct _ClutterTextNodeClass ClutterTextNodeClass;
CLUTTER_EXPORT
GType clutter_text_node_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterPaintNode * clutter_text_node_new (PangoLayout *layout,
const ClutterColor *color);
#define CLUTTER_TYPE_ACTOR_NODE (clutter_actor_node_get_type ())
#define CLUTTER_ACTOR_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ACTOR_NODE, ClutterActorNode))
#define CLUTTER_IS_ACTOR_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ACTOR_NODE))
/**
* ClutterActorNode:
*
* The #ClutterActorNode structure is an opaque
* type whose members cannot be directly accessed.
*/
typedef struct _ClutterActorNode ClutterActorNode;
typedef struct _ClutterActorNode ClutterActorNodeClass;
CLUTTER_EXPORT
GType clutter_actor_node_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterPaintNode * clutter_actor_node_new (ClutterActor *actor);
#define CLUTTER_TYPE_ROOT_NODE (clutter_root_node_get_type ())
#define CLUTTER_ROOT_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ROOT_NODE, ClutterRootNode))
#define CLUTTER_IS_ROOT_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ROOT_NODE))
/**
* ClutterRootNode:
*
* The #ClutterRootNode structure is an opaque
* type whose members cannot be directly accessed.
*/
typedef struct _ClutterRootNode ClutterRootNode;
typedef struct _ClutterPaintNodeClass ClutterRootNodeClass;
CLUTTER_EXPORT
GType clutter_root_node_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterPaintNode * clutter_root_node_new (CoglFramebuffer *framebuffer,
const ClutterColor *clear_color,
CoglBufferBit clear_flags);
#define CLUTTER_TYPE_LAYER_NODE (clutter_layer_node_get_type ())
#define CLUTTER_LAYER_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_LAYER_NODE, ClutterLayerNode))
#define CLUTTER_IS_LAYER_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_LAYER_NODE))
/*
* ClutterLayerNode:
*
* The #ClutterLayerNode structure is an opaque
* type whose members cannot be directly accessed.
*
* Since: 1.10
*/
typedef struct _ClutterLayerNode ClutterLayerNode;
typedef struct _ClutterLayerNodeClass ClutterLayerNodeClass;
CLUTTER_EXPORT
GType clutter_layer_node_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterPaintNode * clutter_layer_node_new (const CoglMatrix *projection,
const cairo_rectangle_t *viewport,
float width,
float height,
guint8 opacity);
#define CLUTTER_TYPE_TRANSFORM_NODE (clutter_transform_node_get_type ())
#define CLUTTER_TRANSFORM_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_TRANSFORM_NODE, ClutterTransformNode))
#define CLUTTER_IS_TRANSFORM_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_TRANSFORM_NODE))
/*
* ClutterTransformNode:
*
* The #ClutterLayerNode structure is an opaque
* type whose members cannot be directly accessed.
*
* Since: 1.10
*/
typedef struct _ClutterTransformNode ClutterTransformNode;
typedef struct _ClutterPaintNodeClass ClutterTransformNodeClass;
CLUTTER_EXPORT
GType clutter_transform_node_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterPaintNode * clutter_transform_node_new (const CoglMatrix *projection);
G_END_DECLS
#endif /* __CLUTTER_PAINT_NODES_H__ */
muffin-6.4.1/clutter/clutter/clutter-feature.c 0000664 0001750 0001750 00000006764 14723361714 020402 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum
*
* Copyright (C) 2006 OpenedHand
*
* 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 .
*
*
*/
/**
* SECTION:clutter-feature
* @short_description: Run-time detection of Clutter features
*
* Parts of Clutter depend on the underlying platform, including the
* capabilities of the backend used and the OpenGL features exposed through the
* Clutter and COGL API.
*
* It is possible to ask whether Clutter has support for specific features at
* run-time.
*/
#include "clutter-build-config.h"
#include
#include
#include
#include "clutter-backend-private.h"
#include "clutter-feature.h"
#include "clutter-main.h"
#include "clutter-private.h"
#include "clutter-debug.h"
#include "cogl/cogl.h"
typedef struct ClutterFeatures
{
ClutterFeatureFlags flags;
guint features_set : 1;
} ClutterFeatures;
static ClutterFeatures* __features = NULL;
static ClutterFeatureFlags
clutter_features_from_cogl (void)
{
ClutterFeatureFlags clutter_flags = 0;
clutter_flags |= CLUTTER_FEATURE_SHADERS_GLSL;
clutter_flags |= CLUTTER_FEATURE_OFFSCREEN;
return clutter_flags;
}
gboolean
_clutter_feature_init (GError **error)
{
ClutterMainContext *context;
CLUTTER_NOTE (MISC, "checking features");
if (!__features)
{
CLUTTER_NOTE (MISC, "allocating features data");
__features = g_new0 (ClutterFeatures, 1);
__features->features_set = FALSE; /* don't rely on zero-ing */
}
if (__features->features_set)
return TRUE;
context = _clutter_context_get_default ();
/* makes sure we have a GL context; if we have, this is a no-op */
if (!_clutter_backend_create_context (context->backend, error))
return FALSE;
__features->flags = (clutter_features_from_cogl ()
| _clutter_backend_get_features (context->backend));
__features->features_set = TRUE;
CLUTTER_NOTE (MISC, "features checked");
return TRUE;
}
/**
* clutter_feature_available:
* @feature: a #ClutterFeatureFlags
*
* Checks whether @feature is available. @feature can be a logical
* OR of #ClutterFeatureFlags.
*
* Return value: %TRUE if a feature is available
*
* Since: 0.2
*/
gboolean
clutter_feature_available (ClutterFeatureFlags feature)
{
if (G_UNLIKELY (!__features))
{
g_critical ("Unable to check features. Have you initialized Clutter?");
return FALSE;
}
return (__features->flags & feature);
}
/**
* clutter_feature_get_all:
*
* Returns all the supported features.
*
* Return value: a logical OR of all the supported features.
*
* Since: 0.2
*/
ClutterFeatureFlags
clutter_feature_get_all (void)
{
if (G_UNLIKELY (!__features))
{
g_critical ("Unable to check features. Have you initialized Clutter?");
return FALSE;
}
return __features->flags;
}
muffin-6.4.1/clutter/clutter/clutter-mutter.h 0000664 0001750 0001750 00000006523 14723361714 020265 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2016 Red Hat 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 .
*
*/
#ifndef __CLUTTER_MUTTER_H__
#define __CLUTTER_MUTTER_H__
#define __CLUTTER_H_INSIDE__
#include "clutter-backend.h"
#include "clutter-event-private.h"
#include "clutter-input-device-private.h"
#include "clutter-input-pointer-a11y-private.h"
#include "clutter-macros.h"
#include "clutter-paint-context-private.h"
#include "clutter-private.h"
#include "clutter-stage-private.h"
#include "clutter-stage-view.h"
#include "cogl/clutter-stage-cogl.h"
#include "clutter/x11/clutter-backend-x11.h"
CLUTTER_EXPORT
void clutter_set_custom_backend_func (ClutterBackend *(* func) (void));
CLUTTER_EXPORT
int64_t clutter_stage_get_frame_counter (ClutterStage *stage);
CLUTTER_EXPORT
void clutter_stage_capture_into (ClutterStage *stage,
gboolean paint,
cairo_rectangle_int_t *rect,
uint8_t *data);
CLUTTER_EXPORT
void clutter_stage_paint_to_framebuffer (ClutterStage *stage,
CoglFramebuffer *framebuffer,
const cairo_rectangle_int_t *rect,
float scale,
ClutterPaintFlag paint_flags);
CLUTTER_EXPORT
gboolean clutter_stage_paint_to_buffer (ClutterStage *stage,
const cairo_rectangle_int_t *rect,
float scale,
uint8_t *data,
int stride,
CoglPixelFormat format,
ClutterPaintFlag paint_flags,
GError **error);
CLUTTER_EXPORT
void clutter_stage_freeze_updates (ClutterStage *stage);
CLUTTER_EXPORT
void clutter_stage_thaw_updates (ClutterStage *stage);
CLUTTER_EXPORT
void clutter_stage_update_resource_scales (ClutterStage *stage);
CLUTTER_EXPORT
gboolean clutter_actor_has_damage (ClutterActor *actor);
CLUTTER_EXPORT
void clutter_stage_get_device_coords (ClutterStage *stage,
ClutterInputDevice *device,
ClutterEventSequence *sequence,
graphene_point_t *coords);
#undef __CLUTTER_H_INSIDE__
#endif /* __CLUTTER_MUTTER_H__ */
muffin-6.4.1/clutter/clutter/clutter-input-focus-private.h 0000664 0001750 0001750 00000003333 14723361714 022665 0 ustar fabio fabio /*
* Copyright (C) 2017,2018 Red Hat
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program 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
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
* Author: Carlos Garnacho
*/
#ifndef __CLUTTER_INPUT_FOCUS_PRIVATE_H__
#define __CLUTTER_INPUT_FOCUS_PRIVATE_H__
void clutter_input_focus_focus_in (ClutterInputFocus *focus,
ClutterInputMethod *method);
void clutter_input_focus_focus_out (ClutterInputFocus *focus);
void clutter_input_focus_commit (ClutterInputFocus *focus,
const gchar *text);
void clutter_input_focus_delete_surrounding (ClutterInputFocus *focus,
int offset,
guint len);
void clutter_input_focus_request_surrounding (ClutterInputFocus *focus);
void clutter_input_focus_set_preedit_text (ClutterInputFocus *focus,
const gchar *preedit,
guint cursor);
#endif /* __CLUTTER_INPUT_FOCUS_PRIVATE_H__ */
muffin-6.4.1/clutter/clutter/clutter-text-buffer.h 0000664 0001750 0001750 00000016015 14723361714 021175 0 ustar fabio fabio /* clutter-text-buffer.h
* Copyright (C) 2011 Collabora Ltd.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library 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.
*
* Author: Stef Walter
*/
#ifndef __CLUTTER_TEXT_BUFFER_H__
#define __CLUTTER_TEXT_BUFFER_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_TEXT_BUFFER (clutter_text_buffer_get_type ())
#define CLUTTER_TEXT_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_TEXT_BUFFER, ClutterTextBuffer))
#define CLUTTER_TEXT_BUFFER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_TEXT_BUFFER, ClutterTextBufferClass))
#define CLUTTER_IS_TEXT_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_TEXT_BUFFER))
#define CLUTTER_IS_TEXT_BUFFER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_TEXT_BUFFER))
#define CLUTTER_TEXT_BUFFER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_TEXT_BUFFER, ClutterTextBufferClass))
/**
* CLUTTER_TEXT_BUFFER_MAX_SIZE:
*
* Maximum size of text buffer, in bytes.
*
* Since: 1.10
*/
#define CLUTTER_TEXT_BUFFER_MAX_SIZE G_MAXUSHORT
typedef struct _ClutterTextBuffer ClutterTextBuffer;
typedef struct _ClutterTextBufferClass ClutterTextBufferClass;
typedef struct _ClutterTextBufferPrivate ClutterTextBufferPrivate;
/**
* ClutterTextBuffer:
*
* The #ClutterTextBuffer structure contains private
* data and it should only be accessed using the provided API.
*
* Since: 1.10
*/
struct _ClutterTextBuffer
{
/*< private >*/
GObject parent_instance;
ClutterTextBufferPrivate *priv;
};
/**
* ClutterTextBufferClass:
* @inserted_text: default handler for the #ClutterTextBuffer::inserted-text signal
* @deleted_text: default hanlder for the #ClutterTextBuffer::deleted-text signal
* @get_text: virtual function
* @get_length: virtual function
* @insert_text: virtual function
* @delete_text: virtual function
*
* The #ClutterTextBufferClass structure contains
* only private data.
*
* Since: 1.10
*/
struct _ClutterTextBufferClass
{
/*< private >*/
GObjectClass parent_class;
/*< public >*/
/* Signals */
void (*inserted_text) (ClutterTextBuffer *buffer,
guint position,
const gchar *chars,
guint n_chars);
void (*deleted_text) (ClutterTextBuffer *buffer,
guint position,
guint n_chars);
/* Virtual Methods */
const gchar* (*get_text) (ClutterTextBuffer *buffer,
gsize *n_bytes);
guint (*get_length) (ClutterTextBuffer *buffer);
guint (*insert_text) (ClutterTextBuffer *buffer,
guint position,
const gchar *chars,
guint n_chars);
guint (*delete_text) (ClutterTextBuffer *buffer,
guint position,
guint n_chars);
/*< private >*/
/* Padding for future expansion */
void (*_clutter_reserved1) (void);
void (*_clutter_reserved2) (void);
void (*_clutter_reserved3) (void);
void (*_clutter_reserved4) (void);
void (*_clutter_reserved5) (void);
void (*_clutter_reserved6) (void);
void (*_clutter_reserved7) (void);
void (*_clutter_reserved8) (void);
};
CLUTTER_EXPORT
GType clutter_text_buffer_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterTextBuffer* clutter_text_buffer_new (void);
CLUTTER_EXPORT
ClutterTextBuffer* clutter_text_buffer_new_with_text (const gchar *text,
gssize text_len);
CLUTTER_EXPORT
gsize clutter_text_buffer_get_bytes (ClutterTextBuffer *buffer);
CLUTTER_EXPORT
guint clutter_text_buffer_get_length (ClutterTextBuffer *buffer);
CLUTTER_EXPORT
const gchar* clutter_text_buffer_get_text (ClutterTextBuffer *buffer);
CLUTTER_EXPORT
void clutter_text_buffer_set_text (ClutterTextBuffer *buffer,
const gchar *chars,
gint n_chars);
CLUTTER_EXPORT
void clutter_text_buffer_set_max_length (ClutterTextBuffer *buffer,
gint max_length);
CLUTTER_EXPORT
gint clutter_text_buffer_get_max_length (ClutterTextBuffer *buffer);
CLUTTER_EXPORT
guint clutter_text_buffer_insert_text (ClutterTextBuffer *buffer,
guint position,
const gchar *chars,
gint n_chars);
CLUTTER_EXPORT
guint clutter_text_buffer_delete_text (ClutterTextBuffer *buffer,
guint position,
gint n_chars);
CLUTTER_EXPORT
void clutter_text_buffer_emit_inserted_text (ClutterTextBuffer *buffer,
guint position,
const gchar *chars,
guint n_chars);
CLUTTER_EXPORT
void clutter_text_buffer_emit_deleted_text (ClutterTextBuffer *buffer,
guint position,
guint n_chars);
G_END_DECLS
#endif /* __CLUTTER_TEXT_BUFFER_H__ */
muffin-6.4.1/clutter/clutter/clutter-drop-action.h 0000664 0001750 0001750 00000007621 14723361714 021164 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright © 2011 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_DROP_ACTION_H__
#define __CLUTTER_DROP_ACTION_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be directly included."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_DROP_ACTION (clutter_drop_action_get_type ())
#define CLUTTER_DROP_ACTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_DROP_ACTION, ClutterDropAction))
#define CLUTTER_IS_DROP_ACTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_DROP_ACTION))
#define CLUTTER_DROP_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_DROP_ACTION, ClutterDropActionClass))
#define CLUTTER_IS_DROP_ACTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_DROP_ACTION))
#define CLUTTER_DROP_ACTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_DROP_ACTION, ClutterDropActionClass))
typedef struct _ClutterDropAction ClutterDropAction;
typedef struct _ClutterDropActionPrivate ClutterDropActionPrivate;
typedef struct _ClutterDropActionClass ClutterDropActionClass;
/**
* ClutterDropAction:
*
* The #ClutterDropAction structure contains only
* private data and should be accessed using the provided API.
*
* Since: 1.8
*/
struct _ClutterDropAction
{
/*< private >*/
ClutterAction parent_instance;
ClutterDropActionPrivate *priv;
};
/**
* ClutterDropActionClass:
* @can_drop: class handler for the #ClutterDropAction::can-drop signal
* @over_in: class handler for the #ClutterDropAction::over-in signal
* @over_out: class handler for the #ClutterDropAction::over-out signal
* @drop: class handler for the #ClutterDropAction::drop signal
*
* The #ClutterDropActionClass structure contains
* only private data.
*
* Since: 1.8
*/
struct _ClutterDropActionClass
{
/*< private >*/
ClutterActionClass parent_class;
/*< public >*/
gboolean (* can_drop) (ClutterDropAction *action,
ClutterActor *actor,
gfloat event_x,
gfloat event_y);
void (* over_in) (ClutterDropAction *action,
ClutterActor *actor);
void (* over_out) (ClutterDropAction *action,
ClutterActor *actor);
void (* drop) (ClutterDropAction *action,
ClutterActor *actor,
gfloat event_x,
gfloat event_y);
/*< private >*/
void (*_clutter_drop_action1) (void);
void (*_clutter_drop_action2) (void);
void (*_clutter_drop_action3) (void);
void (*_clutter_drop_action4) (void);
void (*_clutter_drop_action5) (void);
void (*_clutter_drop_action6) (void);
void (*_clutter_drop_action7) (void);
void (*_clutter_drop_action8) (void);
};
CLUTTER_EXPORT
GType clutter_drop_action_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterAction * clutter_drop_action_new (void);
G_END_DECLS
#endif /* __CLUTTER_DROP_ACTION_H__ */
muffin-6.4.1/clutter/clutter/clutter-master-clock-default.h 0000664 0001750 0001750 00000003541 14723361714 022750 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By: Lionel Landwerlin
*
* Copyright (C) 2015 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*/
#ifndef __CLUTTER_MASTER_CLOCK_DEFAULT_H__
#define __CLUTTER_MASTER_CLOCK_DEFAULT_H__
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_MASTER_CLOCK_DEFAULT (_clutter_master_clock_default_get_type ())
#define CLUTTER_MASTER_CLOCK_DEFAULT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_MASTER_CLOCK_DEFAULT, ClutterMasterClockDefault))
#define CLUTTER_IS_MASTER_CLOCK_DEFAULT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_MASTER_CLOCK_DEFAULT))
#define CLUTTER_MASTER_CLOCK_DEFAULT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_MASTER_CLOCK_DEFAULT, ClutterMasterClockDefaultClass))
typedef struct _ClutterMasterClockDefault ClutterMasterClockDefault;
typedef struct _ClutterMasterClockDefaultClass ClutterMasterClockDefaultClass;
struct _ClutterMasterClockDefaultClass
{
GObjectClass parent_class;
};
GType _clutter_master_clock_default_get_type (void) G_GNUC_CONST;
G_END_DECLS
#endif /* __CLUTTER_MASTER_CLOCK_DEFAULT_H__ */
muffin-6.4.1/clutter/clutter/clutter-actor-meta.h 0000664 0001750 0001750 00000007466 14723361714 021010 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_ACTOR_META_H__
#define __CLUTTER_ACTOR_META_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_ACTOR_META (clutter_actor_meta_get_type ())
#define CLUTTER_ACTOR_META(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_ACTOR_META, ClutterActorMeta))
#define CLUTTER_IS_ACTOR_META(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_ACTOR_META))
#define CLUTTER_ACTOR_META_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_ACTOR_META, ClutterActorMetaClass))
#define CLUTTER_IS_ACTOR_META_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_ACTOR_META))
#define CLUTTER_ACTOR_META_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_ACTOR_META, ClutterActorMetaClass))
typedef struct _ClutterActorMetaPrivate ClutterActorMetaPrivate;
typedef struct _ClutterActorMetaClass ClutterActorMetaClass;
/**
* ClutterActorMeta:
*
* The #ClutterActorMeta structure contains only
* private data and should be accessed using the provided API
*
* Since: 1.4
*/
struct _ClutterActorMeta
{
/*< private >*/
GInitiallyUnowned parent_instance;
ClutterActorMetaPrivate *priv;
};
/**
* ClutterActorMetaClass:
* @set_actor: virtual function, invoked when attaching and detaching
* a #ClutterActorMeta instance to a #ClutterActor
*
* The #ClutterActorMetaClass structure contains
* only private data
*
* Since: 1.4
*/
struct _ClutterActorMetaClass
{
/*< private >*/
GInitiallyUnownedClass parent_class;
/*< public >*/
/**
* ClutterActorMetaClass::set_actor:
* @meta: a #ClutterActorMeta
* @actor: (allow-none): the actor attached to @meta, or %NULL
*
* Virtual function, called when @meta is attached or detached
* from a #ClutterActor.
*/
void (* set_actor) (ClutterActorMeta *meta,
ClutterActor *actor);
/*< private >*/
void (* _clutter_meta1) (void);
void (* _clutter_meta2) (void);
void (* _clutter_meta3) (void);
void (* _clutter_meta4) (void);
void (* _clutter_meta5) (void);
void (* _clutter_meta6) (void);
void (* _clutter_meta7) (void);
};
CLUTTER_EXPORT
GType clutter_actor_meta_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
void clutter_actor_meta_set_name (ClutterActorMeta *meta,
const gchar *name);
CLUTTER_EXPORT
const gchar * clutter_actor_meta_get_name (ClutterActorMeta *meta);
CLUTTER_EXPORT
void clutter_actor_meta_set_enabled (ClutterActorMeta *meta,
gboolean is_enabled);
CLUTTER_EXPORT
gboolean clutter_actor_meta_get_enabled (ClutterActorMeta *meta);
CLUTTER_EXPORT
ClutterActor * clutter_actor_meta_get_actor (ClutterActorMeta *meta);
G_END_DECLS
#endif /* __CLUTTER_ACTOR_META_H__ */
muffin-6.4.1/clutter/clutter/clutter-base-types.c 0000664 0001750 0001750 00000017420 14723361714 021012 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By Matthew Allum
*
* Copyright (C) 2006 OpenedHand
*
* 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 .
*/
/**
* SECTION:clutter-geometric-types
* @Title: Base geometric types
* @Short_Description: Common geometric data types used by Clutter
*
* Clutter defines a set of geometric data structures that are commonly used
* across the whole API.
*/
#include "clutter-build-config.h"
#include "clutter-types.h"
#include "clutter-private.h"
#include
#define FLOAT_EPSILON (1e-15)
/*
* ClutterMargin
*/
/**
* clutter_margin_new:
*
* Creates a new #ClutterMargin.
*
* Return value: (transfer full): a newly allocated #ClutterMargin. Use
* clutter_margin_free() to free the resources associated with it when
* done.
*
* Since: 1.10
*/
ClutterMargin *
clutter_margin_new (void)
{
return g_slice_new0 (ClutterMargin);
}
/**
* clutter_margin_copy:
* @margin_: a #ClutterMargin
*
* Creates a new #ClutterMargin and copies the contents of @margin_ into
* the newly created structure.
*
* Return value: (transfer full): a copy of the #ClutterMargin.
*
* Since: 1.10
*/
ClutterMargin *
clutter_margin_copy (const ClutterMargin *margin_)
{
if (G_LIKELY (margin_ != NULL))
return g_slice_dup (ClutterMargin, margin_);
return NULL;
}
/**
* clutter_margin_free:
* @margin_: a #ClutterMargin
*
* Frees the resources allocated by clutter_margin_new() and
* clutter_margin_copy().
*
* Since: 1.10
*/
void
clutter_margin_free (ClutterMargin *margin_)
{
if (G_LIKELY (margin_ != NULL))
g_slice_free (ClutterMargin, margin_);
}
G_DEFINE_BOXED_TYPE (ClutterMargin, clutter_margin,
clutter_margin_copy,
clutter_margin_free)
/**
* ClutterMatrix:
*
* A type representing a 4x4 matrix.
*
* It is identicaly to #CoglMatrix.
*
* Since: 1.12
*/
static gpointer
clutter_matrix_copy (gpointer data)
{
return cogl_matrix_copy (data);
}
static gboolean
clutter_matrix_progress (const GValue *a,
const GValue *b,
gdouble progress,
GValue *retval)
{
const ClutterMatrix *matrix1 = g_value_get_boxed (a);
const ClutterMatrix *matrix2 = g_value_get_boxed (b);
graphene_point3d_t scale1 = GRAPHENE_POINT3D_INIT (1.f, 1.f, 1.f);
float shear1[3] = { 0.f, 0.f, 0.f };
graphene_point3d_t rotate1 = GRAPHENE_POINT3D_INIT_ZERO;
graphene_point3d_t translate1 = GRAPHENE_POINT3D_INIT_ZERO;
ClutterVertex4 perspective1 = { 0.f, 0.f, 0.f, 0.f };
graphene_point3d_t scale2 = GRAPHENE_POINT3D_INIT (1.f, 1.f, 1.f);
float shear2[3] = { 0.f, 0.f, 0.f };
graphene_point3d_t rotate2 = GRAPHENE_POINT3D_INIT_ZERO;
graphene_point3d_t translate2 = GRAPHENE_POINT3D_INIT_ZERO;
ClutterVertex4 perspective2 = { 0.f, 0.f, 0.f, 0.f };
graphene_point3d_t scale_res = GRAPHENE_POINT3D_INIT (1.f, 1.f, 1.f);
float shear_res = 0.f;
graphene_point3d_t rotate_res = GRAPHENE_POINT3D_INIT_ZERO;
graphene_point3d_t translate_res = GRAPHENE_POINT3D_INIT_ZERO;
ClutterVertex4 perspective_res = { 0.f, 0.f, 0.f, 0.f };
ClutterMatrix res;
clutter_matrix_init_identity (&res);
_clutter_util_matrix_decompose (matrix1,
&scale1, shear1, &rotate1, &translate1,
&perspective1);
_clutter_util_matrix_decompose (matrix2,
&scale2, shear2, &rotate2, &translate2,
&perspective2);
/* perspective */
_clutter_util_vertex4_interpolate (&perspective1, &perspective2, progress, &perspective_res);
res.wx = perspective_res.x;
res.wy = perspective_res.y;
res.wz = perspective_res.z;
res.ww = perspective_res.w;
/* translation */
graphene_point3d_interpolate (&translate1, &translate2, progress, &translate_res);
cogl_matrix_translate (&res, translate_res.x, translate_res.y, translate_res.z);
/* rotation */
graphene_point3d_interpolate (&rotate1, &rotate2, progress, &rotate_res);
cogl_matrix_rotate (&res, rotate_res.x, 1.0f, 0.0f, 0.0f);
cogl_matrix_rotate (&res, rotate_res.y, 0.0f, 1.0f, 0.0f);
cogl_matrix_rotate (&res, rotate_res.z, 0.0f, 0.0f, 1.0f);
/* skew */
shear_res = shear1[2] + (shear2[2] - shear1[2]) * progress; /* YZ */
if (shear_res != 0.f)
_clutter_util_matrix_skew_yz (&res, shear_res);
shear_res = shear1[1] + (shear2[1] - shear1[1]) * progress; /* XZ */
if (shear_res != 0.f)
_clutter_util_matrix_skew_xz (&res, shear_res);
shear_res = shear1[0] + (shear2[0] - shear1[0]) * progress; /* XY */
if (shear_res != 0.f)
_clutter_util_matrix_skew_xy (&res, shear_res);
/* scale */
graphene_point3d_interpolate (&scale1, &scale2, progress, &scale_res);
cogl_matrix_scale (&res, scale_res.x, scale_res.y, scale_res.z);
g_value_set_boxed (retval, &res);
return TRUE;
}
G_DEFINE_BOXED_TYPE_WITH_CODE (ClutterMatrix, clutter_matrix,
clutter_matrix_copy,
clutter_matrix_free,
CLUTTER_REGISTER_INTERVAL_PROGRESS (clutter_matrix_progress))
/**
* clutter_matrix_alloc:
*
* Allocates enough memory to hold a #ClutterMatrix.
*
* Return value: (transfer full): the newly allocated #ClutterMatrix
*
* Since: 1.12
*/
ClutterMatrix *
clutter_matrix_alloc (void)
{
return g_new0 (ClutterMatrix, 1);
}
/**
* clutter_matrix_free:
* @matrix: (allow-none): a #ClutterMatrix
*
* Frees the memory allocated by clutter_matrix_alloc().
*
* Since: 1.12
*/
void
clutter_matrix_free (ClutterMatrix *matrix)
{
cogl_matrix_free (matrix);
}
/**
* clutter_matrix_init_identity:
* @matrix: a #ClutterMatrix
*
* Initializes @matrix with the identity matrix, i.e.:
*
* |[
* .xx = 1.0, .xy = 0.0, .xz = 0.0, .xw = 0.0
* .yx = 0.0, .yy = 1.0, .yz = 0.0, .yw = 0.0
* .zx = 0.0, .zy = 0.0, .zz = 1.0, .zw = 0.0
* .wx = 0.0, .wy = 0.0, .wz = 0.0, .ww = 1.0
* ]|
*
* Return value: (transfer none): the initialized #ClutterMatrix
*
* Since: 1.12
*/
ClutterMatrix *
clutter_matrix_init_identity (ClutterMatrix *matrix)
{
cogl_matrix_init_identity (matrix);
return matrix;
}
/**
* clutter_matrix_init_from_array:
* @matrix: a #ClutterMatrix
* @values: (array fixed-size=16): a C array of 16 floating point values,
* representing a 4x4 matrix, with column-major order
*
* Initializes @matrix with the contents of a C array of floating point
* values.
*
* Return value: (transfer none): the initialzed #ClutterMatrix
*
* Since: 1.12
*/
ClutterMatrix *
clutter_matrix_init_from_array (ClutterMatrix *matrix,
const float values[16])
{
cogl_matrix_init_from_array (matrix, values);
return matrix;
}
/**
* clutter_matrix_init_from_matrix:
* @a: the #ClutterMatrix to initialize
* @b: the #ClutterMatrix to copy
*
* Initializes the #ClutterMatrix @a with the contents of the
* #ClutterMatrix @b.
*
* Return value: (transfer none): the initialized #ClutterMatrix
*
* Since: 1.12
*/
ClutterMatrix *
clutter_matrix_init_from_matrix (ClutterMatrix *a,
const ClutterMatrix *b)
{
return memcpy (a, b, sizeof (ClutterMatrix));
}
muffin-6.4.1/clutter/clutter/clutter-texture-content.h 0000664 0001750 0001750 00000003362 14723361714 022113 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive image' library.
*
* Copyright (C) 2012 Intel Corporation.
* Copyright (C) 2021 Robert Mader.
*
* 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 .
*
* Author:
* Emmanuele Bassi
* Robert Mader
*/
#ifndef CLUTTER_TEXTURE_CONTENT_H
#define CLUTTER_TEXTURE_CONTENT_H
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_TEXTURE_CONTENT (clutter_texture_content_get_type ())
CLUTTER_EXPORT
G_DECLARE_FINAL_TYPE (ClutterTextureContent, clutter_texture_content,
CLUTTER, TEXTURE_CONTENT, GObject)
CLUTTER_EXPORT
ClutterContent * clutter_texture_content_new_from_texture (CoglTexture *texture,
cairo_rectangle_int_t *clip);
CLUTTER_EXPORT
CoglTexture * clutter_texture_content_get_texture (ClutterTextureContent *texture_content);
G_END_DECLS
#endif /* CLUTTER_TEXTURE_CONTENT_H */
muffin-6.4.1/clutter/clutter/clutter-clone.h 0000664 0001750 0001750 00000005617 14723361714 020050 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2008 Intel Corporation.
*
* Authored By: Robert Bragg
*
* 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 .
*/
#ifndef __CLUTTER_CLONE_H__
#define __CLUTTER_CLONE_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_CLONE (clutter_clone_get_type())
#define CLUTTER_CLONE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_CLONE, ClutterClone))
#define CLUTTER_CLONE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_CLONE, ClutterCloneClass))
#define CLUTTER_IS_CLONE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_CLONE))
#define CLUTTER_IS_CLONE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_CLONE))
#define CLUTTER_CLONE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_CLONE, ClutterCloneClass))
typedef struct _ClutterClone ClutterClone;
typedef struct _ClutterCloneClass ClutterCloneClass;
typedef struct _ClutterClonePrivate ClutterClonePrivate;
/**
* ClutterClone:
*
* The #ClutterClone structure contains only private data
* and should be accessed using the provided API
*
* Since: 1.0
*/
struct _ClutterClone
{
/*< private >*/
ClutterActor parent_instance;
ClutterClonePrivate *priv;
};
/**
* ClutterCloneClass:
*
* The #ClutterCloneClass structure contains only private data
*
* Since: 1.0
*/
struct _ClutterCloneClass
{
/*< private >*/
ClutterActorClass parent_class;
/* padding for future expansion */
void (*_clutter_actor_clone1) (void);
void (*_clutter_actor_clone2) (void);
void (*_clutter_actor_clone3) (void);
void (*_clutter_actor_clone4) (void);
};
CLUTTER_EXPORT
GType clutter_clone_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterActor * clutter_clone_new (ClutterActor *source);
CLUTTER_EXPORT
void clutter_clone_set_source (ClutterClone *self,
ClutterActor *source);
CLUTTER_EXPORT
ClutterActor * clutter_clone_get_source (ClutterClone *self);
G_END_DECLS
#endif /* __CLUTTER_CLONE_H__ */
muffin-6.4.1/clutter/clutter/clutter-layout-meta.h 0000664 0001750 0001750 00000006202 14723361714 021200 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2009 Intel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_LAYOUT_META_H__
#define __CLUTTER_LAYOUT_META_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_LAYOUT_META (clutter_layout_meta_get_type ())
#define CLUTTER_LAYOUT_META(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_LAYOUT_META, ClutterLayoutMeta))
#define CLUTTER_IS_LAYOUT_META(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_LAYOUT_META))
#define CLUTTER_LAYOUT_META_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_LAYOUT_META, ClutterLayoutMetaClass))
#define CLUTTER_IS_LAYOUT_META_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_LAYOUT_META))
#define CLUTTER_LAYOUT_META_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_LAYOUT_META, ClutterLayoutMetaClass))
/* ClutterLayoutMeta is defined in clutter-types.h */
typedef struct _ClutterLayoutMetaClass ClutterLayoutMetaClass;
/**
* ClutterLayoutMeta:
* @manager: the layout manager handling this data
*
* Sub-class of #ClutterChildMeta specific for layout managers
*
* A #ClutterLayoutManager sub-class should create a #ClutterLayoutMeta
* instance by overriding the #ClutterLayoutManager::create_child_meta()
* virtual function
*
* Since: 1.2
*/
struct _ClutterLayoutMeta
{
/*< private >*/
ClutterChildMeta parent_instance;
/*< public >*/
ClutterLayoutManager *manager;
/*< private >*/
/* padding */
gint32 dummy0;
gpointer dummy1;
};
/**
* ClutterLayoutMetaClass:
*
* The #ClutterLayoutMetaClass contains only private data and
* should never be accessed directly
*
* Since: 1.2
*/
struct _ClutterLayoutMetaClass
{
/*< private >*/
ClutterChildMetaClass parent_class;
/* padding, for expansion */
void (*_clutter_padding1) (void);
void (*_clutter_padding2) (void);
void (*_clutter_padding3) (void);
void (*_clutter_padding4) (void);
};
CLUTTER_EXPORT
GType clutter_layout_meta_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterLayoutManager *clutter_layout_meta_get_manager (ClutterLayoutMeta *data);
G_END_DECLS
#endif /* __CLUTTER_LAYOUT_META_H__ */
muffin-6.4.1/clutter/clutter/clutter-canvas.h 0000664 0001750 0001750 00000006523 14723361714 020220 0 ustar fabio fabio /*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2012 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*
* Author:
* Emmanuele Bassi
*/
#ifndef __CLUTTER_CANVAS_H__
#define __CLUTTER_CANVAS_H__
#if !defined(__CLUTTER_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
G_BEGIN_DECLS
#define CLUTTER_TYPE_CANVAS (clutter_canvas_get_type ())
#define CLUTTER_CANVAS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_CANVAS, ClutterCanvas))
#define CLUTTER_IS_CANVAS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_CANVAS))
#define CLUTTER_CANVAS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_CANVAS, ClutterCanvasClass))
#define CLUTTER_IS_CANVAS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_CANVAS))
#define CLUTTER_CANVAS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_CANVAS, ClutterCanvasClass))
typedef struct _ClutterCanvas ClutterCanvas;
typedef struct _ClutterCanvasPrivate ClutterCanvasPrivate;
typedef struct _ClutterCanvasClass ClutterCanvasClass;
/**
* ClutterCanvas:
*
* The #ClutterCanvas structure contains
* private data and should only be accessed using the provided
* API.
*
* Since: 1.10
*/
struct _ClutterCanvas
{
/*< private >*/
GObject parent_instance;
ClutterCanvasPrivate *priv;
};
/**
* ClutterCanvasClass:
* @draw: class handler for the #ClutterCanvas::draw signal
*
* The #ClutterCanvasClass structure contains
* private data.
*
* Since: 1.10
*/
struct _ClutterCanvasClass
{
/*< private >*/
GObjectClass parent_class;
/*< public >*/
gboolean (* draw) (ClutterCanvas *canvas,
cairo_t *cr,
int width,
int height);
/*< private >*/
gpointer _padding[16];
};
CLUTTER_EXPORT
GType clutter_canvas_get_type (void) G_GNUC_CONST;
CLUTTER_EXPORT
ClutterContent * clutter_canvas_new (void);
CLUTTER_EXPORT
gboolean clutter_canvas_set_size (ClutterCanvas *canvas,
int width,
int height);
CLUTTER_EXPORT
void clutter_canvas_set_scale_factor (ClutterCanvas *canvas,
float scale);
CLUTTER_EXPORT
float clutter_canvas_get_scale_factor (ClutterCanvas *canvas);
G_END_DECLS
#endif /* __CLUTTER_CANVAS_H__ */
muffin-6.4.1/clutter/clutter/cally/ 0000775 0001750 0001750 00000000000 14723361714 016212 5 ustar fabio fabio muffin-6.4.1/clutter/clutter/cally/cally-actor-private.h 0000664 0001750 0001750 00000003032 14723361714 022243 0 ustar fabio fabio /* CALLY - The Clutter Accessibility Implementation Library
*
* Copyright (C) 2008 Igalia, S.L.
*
* Author: Alejandro Piñeiro Iglesias
*
* Some parts are based on GailWidget from GAIL
* GAIL - The GNOME Accessibility Implementation Library
* 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 .
*/
#ifndef __CALLY_ACTOR_PRIVATE_H__
#define __CALLY_ACTOR_PRIVATE_H__
#include "cally-actor.h"
/*
* Auxiliar define, in order to get the clutter actor from the AtkObject using
* AtkGObject methods
*
*/
#define CALLY_GET_CLUTTER_ACTOR(cally_object) \
(CLUTTER_ACTOR (atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (cally_object))))
void _cally_actor_get_top_level_origin (ClutterActor *actor,
gint *x,
gint *y);
#endif /* __CALLY_ACTOR_PRIVATE_H__ */
muffin-6.4.1/clutter/clutter/cally/cally-clone.c 0000664 0001750 0001750 00000010364 14723361714 020564 0 ustar fabio fabio /* CALLY - The Clutter Accessibility Implementation Library
*
* Copyright (C) 2010 Igalia, S.L.
*
* Author: Alejandro Piñeiro Iglesias
*
* 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-clone
* @Title: CallyClone
* @short_description: Implementation of the ATK interfaces for a #ClutterClone
* @see_also: #ClutterClone
*
* #CallyClone implements the required ATK interfaces of #ClutterClone
*
* In particular it sets a proper role for the clone, as just a image,
* as it is the sanest and simplest approach.
*/
/* Design rationale for CallyClone:
*
* In the old times, it was just ClutterCloneTexture. So, from a a11y POV
* CallyCloneTexture was just another image, like ClutterTexture, and if
* it was a clone was irrevelant. So on cally-0.8, CallyCloneTexture
* expose a object with role ATK_ROLE_IMAGE. But now, ClutterClone is more
* general. You can clone any object, including groups, and made things
* like have one text entry, and a clone with different properties in the
* same window, updated both at once.
*
* The question is if the idea is have a ClutterClone as a "first-class"
* citizen inside the stage hierarchy (full clone), or it is just supposed
* to be a mirror image of the original object.
*
* In the case of the a11y POV this would mean that if the text changes on
* the source, the clone should emit as well the text-changing signals.
*
* As ClutterClone smartly just paint the same object with different
* parameters, this would mean that it should be the cally object the one
* that should replicate the source clutter hierarchy to do that,
* something that just sound crazy.
*
* Taking into account that:
*
* - ClutterClone doesn't re-emit mirrored signals from the source
* I think that likely the answer would be "yes, it is just a
* mirrored image, not a real full clone".
*
* - You can't interact directly with the clone (ie: focus, and so on).
* Its basic usage (right now) is clone textures.
*
* Any other solution could be overwhelming.
*
* I think that the final solution would be that ClutterClone from the
* a11y POV should still be managed as a image (with the proper properties,
* position, size, etc.).
*/
#include "clutter-build-config.h"
#include "cally-clone.h"
#include "cally-actor-private.h"
/* AtkObject */
static void cally_clone_real_initialize (AtkObject *obj,
gpointer data);
G_DEFINE_TYPE (CallyClone, cally_clone, CALLY_TYPE_ACTOR)
static void
cally_clone_class_init (CallyCloneClass *klass)
{
/* GObjectClass *gobject_class = G_OBJECT_CLASS (klass); */
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
class->initialize = cally_clone_real_initialize;
}
static void
cally_clone_init (CallyClone *clone)
{
/* nothing to do yet */
}
/**
* cally_clone_new:
* @actor: a #ClutterActor
*
* Creates a new #CallyClone for the given @actor. @actor must be a
* #ClutterClone.
*
* Return value: the newly created #AtkObject
*
* Since: 1.4
*/
AtkObject*
cally_clone_new (ClutterActor *actor)
{
GObject *object = NULL;
AtkObject *accessible = NULL;
g_return_val_if_fail (CLUTTER_IS_CLONE (actor), NULL);
object = g_object_new (CALLY_TYPE_CLONE, NULL);
accessible = ATK_OBJECT (object);
atk_object_initialize (accessible, actor);
return accessible;
}
static void
cally_clone_real_initialize (AtkObject *obj,
gpointer data)
{
ATK_OBJECT_CLASS (cally_clone_parent_class)->initialize (obj, data);
obj->role = ATK_ROLE_IMAGE;
}
muffin-6.4.1/clutter/clutter/cally/cally-actor.c 0000664 0001750 0001750 00000105021 14723361714 020567 0 ustar fabio fabio /* CALLY - The Clutter Accessibility Implementation Library
*
* Copyright (C) 2008 Igalia, S.L.
*
* Author: Alejandro Piñeiro Iglesias
*
* Some parts are based on GailWidget from GAIL
* GAIL - The GNOME Accessibility Implementation Library
* 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 .
*/
/**
* SECTION:cally-actor
* @Title: CallyActor
* @short_description: Implementation of the ATK interfaces for #ClutterActor
* @see_also: #ClutterActor
*
* #CallyActor implements the required ATK interfaces of #ClutterActor
* exposing the common elements on each actor (position, extents, etc).
*/
/*
*
* IMPLEMENTATION NOTES:
*
* ####
*
* Focus: clutter hasn't got the focus concept in the same way that GTK, but it
* has a key focus managed by the stage. Basically any actor can be focused using
* clutter_stage_set_key_focus. So, we will use this approach: all actors are
* focusable, and we get the currently focused using clutter_stage_get_key_focus
* This affects focus related stateset and some atk_componenet focus methods (like
* grab focus).
*
* In the same way, we will manage the focus state change management
* on the cally-stage object. The reason is avoid missing a focus
* state change event if the object is focused just before the
* accessibility object being created.
*
* #AtkAction implementation: on previous releases ClutterActor added
* the actions "press", "release" and "click", as at that time some
* general-purpose actors like textures were directly used as buttons.
*
* But now, new toolkits appeared, providing high-level widgets, like
* buttons. So in this environment, it doesn't make sense to keep
* adding them as default.
*
* Anyway, current implementation of AtkAction is done at CallyActor
* providing methods to add and remove actions. This is based on the
* one used at gailcell, and proposed as a change on #AtkAction
* interface:
*
* https://bugzilla.gnome.org/show_bug.cgi?id=649804
*
*/
#include "clutter-build-config.h"
#include
#include
#ifdef CLUTTER_WINDOWING_X11
#include
#endif
#include
#include "cally-actor.h"
#include "cally-actor-private.h"
typedef struct _CallyActorActionInfo CallyActorActionInfo;
/*< private >
* CallyActorActionInfo:
* @name: name of the action
* @description: description of the action
* @keybinding: keybinding related to the action
* @do_action_func: callback
* @user_data: data to be passed to @do_action_func
* @notify: function to be called when removing the action
*
* Utility structure to maintain the different actions added to the
* #CallyActor
*/
struct _CallyActorActionInfo
{
gchar *name;
gchar *description;
gchar *keybinding;
CallyActionCallback do_action_func;
gpointer user_data;
GDestroyNotify notify;
};
static void cally_actor_initialize (AtkObject *obj,
gpointer data);
static void cally_actor_finalize (GObject *obj);
/* AtkObject.h */
static AtkObject* cally_actor_get_parent (AtkObject *obj);
static gint cally_actor_get_index_in_parent (AtkObject *obj);
static AtkStateSet* cally_actor_ref_state_set (AtkObject *obj);
static gint cally_actor_get_n_children (AtkObject *obj);
static AtkObject* cally_actor_ref_child (AtkObject *obj,
gint i);
static AtkAttributeSet * cally_actor_get_attributes (AtkObject *obj);
/* ClutterContainer */
static gint cally_actor_add_actor (ClutterActor *container,
ClutterActor *actor,
gpointer data);
static gint cally_actor_remove_actor (ClutterActor *container,
ClutterActor *actor,
gpointer data);
static gint cally_actor_real_add_actor (ClutterActor *container,
ClutterActor *actor,
gpointer data);
static gint cally_actor_real_remove_actor (ClutterActor *container,
ClutterActor *actor,
gpointer data);
/* AtkComponent.h */
static void cally_actor_component_interface_init (AtkComponentIface *iface);
static void cally_actor_get_extents (AtkComponent *component,
gint *x,
gint *y,
gint *width,
gint *height,
AtkCoordType coord_type);
static gint cally_actor_get_mdi_zorder (AtkComponent *component);
static gboolean cally_actor_grab_focus (AtkComponent *component);
/* AtkAction.h */
static void cally_actor_action_interface_init (AtkActionIface *iface);
static gboolean cally_actor_action_do_action (AtkAction *action,
gint i);
static gboolean idle_do_action (gpointer data);
static gint cally_actor_action_get_n_actions (AtkAction *action);
static const gchar* cally_actor_action_get_description (AtkAction *action,
gint i);
static const gchar* cally_actor_action_get_keybinding (AtkAction *action,
gint i);
static const gchar* cally_actor_action_get_name (AtkAction *action,
gint i);
static gboolean cally_actor_action_set_description (AtkAction *action,
gint i,
const gchar *desc);
static void _cally_actor_destroy_action_info (gpointer action_info,
gpointer user_data);
static void _cally_actor_clean_action_list (CallyActor *cally_actor);
static CallyActorActionInfo* _cally_actor_get_action_info (CallyActor *cally_actor,
gint index);
/* Misc functions */
static void cally_actor_notify_clutter (GObject *obj,
GParamSpec *pspec);
static void cally_actor_real_notify_clutter (GObject *obj,
GParamSpec *pspec);
struct _CallyActorPrivate
{
GQueue *action_queue;
guint action_idle_handler;
GList *action_list;
GList *children;
};
G_DEFINE_TYPE_WITH_CODE (CallyActor,
cally_actor,
ATK_TYPE_GOBJECT_ACCESSIBLE,
G_ADD_PRIVATE (CallyActor)
G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT,
cally_actor_component_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_ACTION,
cally_actor_action_interface_init));
/**
* cally_actor_new:
* @actor: a #ClutterActor
*
* Creates a new #CallyActor for the given @actor
*
* Return value: the newly created #AtkObject
*
* Since: 1.4
*/
AtkObject *
cally_actor_new (ClutterActor *actor)
{
gpointer object;
AtkObject *atk_object;
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), NULL);
object = g_object_new (CALLY_TYPE_ACTOR, NULL);
atk_object = ATK_OBJECT (object);
atk_object_initialize (atk_object, actor);
return atk_object;
}
static void
cally_actor_initialize (AtkObject *obj,
gpointer data)
{
CallyActor *self = NULL;
CallyActorPrivate *priv = NULL;
ClutterActor *actor = NULL;
guint handler_id;
ATK_OBJECT_CLASS (cally_actor_parent_class)->initialize (obj, data);
self = CALLY_ACTOR(obj);
priv = self->priv;
actor = CLUTTER_ACTOR (data);
g_signal_connect (actor,
"notify",
G_CALLBACK (cally_actor_notify_clutter),
NULL);
g_object_set_data (G_OBJECT (obj), "atk-component-layer",
GINT_TO_POINTER (ATK_LAYER_MDI));
priv->children = clutter_actor_get_children (actor);
/*
* We store the handler ids for these signals in case some objects
* need to remove these handlers.
*/
handler_id = g_signal_connect (actor,
"actor-added",
G_CALLBACK (cally_actor_add_actor),
obj);
g_object_set_data (G_OBJECT (obj), "cally-add-handler-id",
GUINT_TO_POINTER (handler_id));
handler_id = g_signal_connect (actor,
"actor-removed",
G_CALLBACK (cally_actor_remove_actor),
obj);
g_object_set_data (G_OBJECT (obj), "cally-remove-handler-id",
GUINT_TO_POINTER (handler_id));
obj->role = ATK_ROLE_PANEL; /* typically objects implementing ClutterContainer
interface would be a panel */
}
static void
cally_actor_class_init (CallyActorClass *klass)
{
AtkObjectClass *class = ATK_OBJECT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
klass->notify_clutter = cally_actor_real_notify_clutter;
klass->add_actor = cally_actor_real_add_actor;
klass->remove_actor = cally_actor_real_remove_actor;
/* GObject */
gobject_class->finalize = cally_actor_finalize;
/* AtkObject */
class->get_parent = cally_actor_get_parent;
class->get_index_in_parent = cally_actor_get_index_in_parent;
class->ref_state_set = cally_actor_ref_state_set;
class->initialize = cally_actor_initialize;
class->get_n_children = cally_actor_get_n_children;
class->ref_child = cally_actor_ref_child;
class->get_attributes = cally_actor_get_attributes;
}
static void
cally_actor_init (CallyActor *cally_actor)
{
CallyActorPrivate *priv = cally_actor_get_instance_private (cally_actor);
cally_actor->priv = priv;
priv->action_queue = NULL;
priv->action_idle_handler = 0;
priv->action_list = NULL;
priv->children = NULL;
}
static void
cally_actor_finalize (GObject *obj)
{
CallyActor *cally_actor = NULL;
CallyActorPrivate *priv = NULL;
cally_actor = CALLY_ACTOR (obj);
priv = cally_actor->priv;
_cally_actor_clean_action_list (cally_actor);
g_clear_handle_id (&priv->action_idle_handler, g_source_remove);
if (priv->action_queue)
{
g_queue_free (priv->action_queue);
}
if (priv->children)
{
g_list_free (priv->children);
priv->children = NULL;
}
G_OBJECT_CLASS (cally_actor_parent_class)->finalize (obj);
}
/* AtkObject */
static AtkObject *
cally_actor_get_parent (AtkObject *obj)
{
ClutterActor *parent_actor = NULL;
AtkObject *parent = NULL;
ClutterActor *actor = NULL;
CallyActor *cally_actor = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (obj), NULL);
/* Check if we have and assigned parent */
if (obj->accessible_parent)
return obj->accessible_parent;
/* Try to get it from the clutter parent */
cally_actor = CALLY_ACTOR (obj);
actor = CALLY_GET_CLUTTER_ACTOR (cally_actor);
if (actor == NULL) /* Object is defunct */
return NULL;
parent_actor = clutter_actor_get_parent (actor);
if (parent_actor == NULL)
return NULL;
parent = clutter_actor_get_accessible (parent_actor);
/* FIXME: I need to review the clutter-embed, to check if in this case I
* should get the widget accessible
*/
return parent;
}
static gint
cally_actor_get_index_in_parent (AtkObject *obj)
{
CallyActor *cally_actor = NULL;
ClutterActor *actor = NULL;
ClutterActor *parent_actor = NULL;
ClutterActor *iter;
gint index = -1;
g_return_val_if_fail (CALLY_IS_ACTOR (obj), -1);
if (obj->accessible_parent)
{
gint n_children, i;
gboolean found = FALSE;
n_children = atk_object_get_n_accessible_children (obj->accessible_parent);
for (i = 0; i < n_children; i++)
{
AtkObject *child;
child = atk_object_ref_accessible_child (obj->accessible_parent, i);
if (child == obj)
found = TRUE;
g_object_unref (child);
if (found)
return i;
}
return -1;
}
cally_actor = CALLY_ACTOR (obj);
actor = CALLY_GET_CLUTTER_ACTOR (cally_actor);
if (actor == NULL) /* Object is defunct */
return -1;
index = 0;
parent_actor = clutter_actor_get_parent (actor);
if (parent_actor == NULL)
return -1;
for (iter = clutter_actor_get_first_child (parent_actor);
iter != NULL && iter != actor;
iter = clutter_actor_get_next_sibling (iter))
{
index += 1;
}
return index;
}
static AtkStateSet*
cally_actor_ref_state_set (AtkObject *obj)
{
ClutterActor *actor = NULL;
AtkStateSet *state_set = NULL;
ClutterStage *stage = NULL;
ClutterActor *focus_actor = NULL;
CallyActor *cally_actor = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (obj), NULL);
cally_actor = CALLY_ACTOR (obj);
state_set = ATK_OBJECT_CLASS (cally_actor_parent_class)->ref_state_set (obj);
actor = CALLY_GET_CLUTTER_ACTOR (cally_actor);
if (actor == NULL) /* Object is defunct */
{
atk_state_set_add_state (state_set, ATK_STATE_DEFUNCT);
}
else
{
if (clutter_actor_get_reactive (actor))
{
atk_state_set_add_state (state_set, ATK_STATE_SENSITIVE);
atk_state_set_add_state (state_set, ATK_STATE_ENABLED);
}
if (clutter_actor_is_visible (actor))
{
atk_state_set_add_state (state_set, ATK_STATE_VISIBLE);
/* It would be good to also check if the actor is on screen,
like the old and removed clutter_actor_is_on_stage*/
if (clutter_actor_get_paint_visibility (actor))
atk_state_set_add_state (state_set, ATK_STATE_SHOWING);
}
/* See focus section on implementation notes */
atk_state_set_add_state (state_set, ATK_STATE_FOCUSABLE);
stage = CLUTTER_STAGE (clutter_actor_get_stage (actor));
if (stage != NULL)
{
focus_actor = clutter_stage_get_key_focus (stage);
if (focus_actor == actor)
atk_state_set_add_state (state_set, ATK_STATE_FOCUSED);
}
}
return state_set;
}
static gint
cally_actor_get_n_children (AtkObject *obj)
{
ClutterActor *actor = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (obj), 0);
actor = CALLY_GET_CLUTTER_ACTOR (obj);
if (actor == NULL) /* State is defunct */
return 0;
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), 0);
return clutter_actor_get_n_children (actor);
}
static AtkObject*
cally_actor_ref_child (AtkObject *obj,
gint i)
{
ClutterActor *actor = NULL;
ClutterActor *child = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (obj), NULL);
actor = CALLY_GET_CLUTTER_ACTOR (obj);
if (actor == NULL) /* State is defunct */
return NULL;
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), NULL);
if (i >= clutter_actor_get_n_children (actor))
return NULL;
child = clutter_actor_get_child_at_index (actor, i);
if (child == NULL)
return NULL;
return g_object_ref (clutter_actor_get_accessible (child));
}
static AtkAttributeSet *
cally_actor_get_attributes (AtkObject *obj)
{
AtkAttributeSet *attributes;
AtkAttribute *toolkit;
toolkit = g_new (AtkAttribute, 1);
toolkit->name = g_strdup ("toolkit");
toolkit->value = g_strdup ("clutter");
attributes = g_slist_append (NULL, toolkit);
return attributes;
}
/* ClutterContainer */
static gint
cally_actor_add_actor (ClutterActor *container,
ClutterActor *actor,
gpointer data)
{
CallyActor *cally_actor = CALLY_ACTOR (data);
CallyActorClass *klass = NULL;
klass = CALLY_ACTOR_GET_CLASS (cally_actor);
if (klass->add_actor)
return klass->add_actor (container, actor, data);
else
return 1;
}
static gint
cally_actor_remove_actor (ClutterActor *container,
ClutterActor *actor,
gpointer data)
{
CallyActor *cally_actor = CALLY_ACTOR (data);
CallyActorClass *klass = NULL;
klass = CALLY_ACTOR_GET_CLASS (cally_actor);
if (klass->remove_actor)
return klass->remove_actor (container, actor, data);
else
return 1;
}
static gint
cally_actor_real_add_actor (ClutterActor *container,
ClutterActor *actor,
gpointer data)
{
AtkObject *atk_parent = ATK_OBJECT (data);
AtkObject *atk_child = clutter_actor_get_accessible (actor);
CallyActor *cally_actor = CALLY_ACTOR (atk_parent);
CallyActorPrivate *priv = cally_actor->priv;
gint index;
g_return_val_if_fail (CLUTTER_IS_CONTAINER (container), 0);
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), 0);
g_object_notify (G_OBJECT (atk_child), "accessible_parent");
g_list_free (priv->children);
priv->children = clutter_actor_get_children (CLUTTER_ACTOR (container));
index = g_list_index (priv->children, actor);
g_signal_emit_by_name (atk_parent, "children_changed::add",
index, atk_child, NULL);
return 1;
}
static gint
cally_actor_real_remove_actor (ClutterActor *container,
ClutterActor *actor,
gpointer data)
{
AtkPropertyValues values = { NULL };
AtkObject* atk_parent = NULL;
AtkObject *atk_child = NULL;
CallyActorPrivate *priv = NULL;
gint index;
g_return_val_if_fail (CLUTTER_IS_CONTAINER (container), 0);
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), 0);
atk_parent = ATK_OBJECT (data);
if (clutter_actor_has_accessible (actor))
{
atk_child = clutter_actor_get_accessible (actor);
g_value_init (&values.old_value, G_TYPE_POINTER);
g_value_set_pointer (&values.old_value, atk_parent);
values.property_name = "accessible-parent";
g_object_ref (atk_child);
g_signal_emit_by_name (atk_child,
"property_change::accessible-parent", &values, NULL);
g_object_unref (atk_child);
}
priv = CALLY_ACTOR (atk_parent)->priv;
index = g_list_index (priv->children, actor);
g_list_free (priv->children);
priv->children = clutter_actor_get_children (CLUTTER_ACTOR (container));
if (index >= 0 && index <= g_list_length (priv->children))
g_signal_emit_by_name (atk_parent, "children_changed::remove",
index, atk_child, NULL);
return 1;
}
/* AtkComponent implementation */
static void
cally_actor_component_interface_init (AtkComponentIface *iface)
{
g_return_if_fail (iface != NULL);
iface->get_extents = cally_actor_get_extents;
iface->get_mdi_zorder = cally_actor_get_mdi_zorder;
/* focus management */
iface->grab_focus = cally_actor_grab_focus;
}
static void
cally_actor_get_extents (AtkComponent *component,
gint *x,
gint *y,
gint *width,
gint *height,
AtkCoordType coord_type)
{
CallyActor *cally_actor = NULL;
ClutterActor *actor = NULL;
gint top_level_x, top_level_y;
gfloat f_width, f_height;
graphene_point3d_t verts[4];
ClutterActor *stage = NULL;
g_return_if_fail (CALLY_IS_ACTOR (component));
cally_actor = CALLY_ACTOR (component);
actor = CALLY_GET_CLUTTER_ACTOR (cally_actor);
if (actor == NULL) /* actor is defunct */
return;
/* If the actor is not placed in any stage, we can't compute the
* extents */
stage = clutter_actor_get_stage (actor);
if (stage == NULL)
return;
clutter_actor_get_abs_allocation_vertices (actor, verts);
clutter_actor_get_transformed_size (actor, &f_width, &f_height);
*x = verts[0].x;
*y = verts[0].y;
*width = ceilf (f_width);
*height = ceilf (f_height);
/* In the ATK_XY_WINDOW case, we consider the stage as the
* "top-level-window"
*
* http://library.gnome.org/devel/atk/stable/AtkUtil.html#AtkCoordType
*/
if (coord_type == ATK_XY_SCREEN)
{
_cally_actor_get_top_level_origin (actor, &top_level_x, &top_level_y);
*x += top_level_x;
*y += top_level_y;
}
return;
}
static gint
cally_actor_get_mdi_zorder (AtkComponent *component)
{
CallyActor *cally_actor = NULL;
ClutterActor *actor = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (component), G_MININT);
cally_actor = CALLY_ACTOR(component);
actor = CALLY_GET_CLUTTER_ACTOR (cally_actor);
return clutter_actor_get_z_position (actor);
}
static gboolean
cally_actor_grab_focus (AtkComponent *component)
{
ClutterActor *actor = NULL;
ClutterActor *stage = NULL;
CallyActor *cally_actor = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (component), FALSE);
/* See focus section on implementation notes */
cally_actor = CALLY_ACTOR(component);
actor = CALLY_GET_CLUTTER_ACTOR (cally_actor);
stage = clutter_actor_get_stage (actor);
clutter_stage_set_key_focus (CLUTTER_STAGE (stage),
actor);
return TRUE;
}
/*
*
* This gets the top level origin, it is, the position of the stage in
* the global screen. You can see it as the absolute display position
* of the stage. This is 0,0 for a compositor.
*/
void
_cally_actor_get_top_level_origin (ClutterActor *actor,
gint *xp,
gint *yp)
{
/* default values */
if (xp)
*xp = 0;
if (yp)
*yp = 0;
}
/* AtkAction implementation */
static void
cally_actor_action_interface_init (AtkActionIface *iface)
{
g_return_if_fail (iface != NULL);
iface->do_action = cally_actor_action_do_action;
iface->get_n_actions = cally_actor_action_get_n_actions;
iface->get_description = cally_actor_action_get_description;
iface->get_keybinding = cally_actor_action_get_keybinding;
iface->get_name = cally_actor_action_get_name;
iface->set_description = cally_actor_action_set_description;
}
static gboolean
cally_actor_action_do_action (AtkAction *action,
gint index)
{
CallyActor *cally_actor = NULL;
AtkStateSet *set = NULL;
CallyActorPrivate *priv = NULL;
CallyActorActionInfo *info = NULL;
gboolean did_action = FALSE;
cally_actor = CALLY_ACTOR (action);
priv = cally_actor->priv;
set = atk_object_ref_state_set (ATK_OBJECT (cally_actor));
if (atk_state_set_contains_state (set, ATK_STATE_DEFUNCT))
goto out;
if (!atk_state_set_contains_state (set, ATK_STATE_SENSITIVE) ||
!atk_state_set_contains_state (set, ATK_STATE_SHOWING))
goto out;
info = _cally_actor_get_action_info (cally_actor, index);
if (info == NULL)
goto out;
if (info->do_action_func == NULL)
goto out;
if (!priv->action_queue)
priv->action_queue = g_queue_new ();
g_queue_push_head (priv->action_queue, info);
if (!priv->action_idle_handler)
priv->action_idle_handler = g_idle_add (idle_do_action, cally_actor);
did_action = TRUE;
out:
g_clear_object (&set);
return did_action;
}
static gboolean
idle_do_action (gpointer data)
{
CallyActor *cally_actor = NULL;
CallyActorPrivate *priv = NULL;
ClutterActor *actor = NULL;
cally_actor = CALLY_ACTOR (data);
priv = cally_actor->priv;
actor = CALLY_GET_CLUTTER_ACTOR (cally_actor);
priv->action_idle_handler = 0;
if (actor == NULL) /* state is defunct*/
return FALSE;
while (!g_queue_is_empty (priv->action_queue))
{
CallyActorActionInfo *info = NULL;
info = (CallyActorActionInfo *) g_queue_pop_head (priv->action_queue);
info->do_action_func (cally_actor, info->user_data);
}
return FALSE;
}
static gint
cally_actor_action_get_n_actions (AtkAction *action)
{
CallyActor *cally_actor = NULL;
CallyActorPrivate *priv = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (action), 0);
cally_actor = CALLY_ACTOR (action);
priv = cally_actor->priv;
return g_list_length (priv->action_list);
}
static const gchar*
cally_actor_action_get_name (AtkAction *action,
gint i)
{
CallyActor *cally_actor = NULL;
CallyActorActionInfo *info = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (action), NULL);
cally_actor = CALLY_ACTOR (action);
info = _cally_actor_get_action_info (cally_actor, i);
if (info == NULL)
return NULL;
return info->name;
}
static const gchar*
cally_actor_action_get_description (AtkAction *action,
gint i)
{
CallyActor *cally_actor = NULL;
CallyActorActionInfo *info = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (action), NULL);
cally_actor = CALLY_ACTOR (action);
info = _cally_actor_get_action_info (cally_actor, i);
if (info == NULL)
return NULL;
return info->description;
}
static gboolean
cally_actor_action_set_description (AtkAction *action,
gint i,
const gchar *desc)
{
CallyActor *cally_actor = NULL;
CallyActorActionInfo *info = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (action), FALSE);
cally_actor = CALLY_ACTOR (action);
info = _cally_actor_get_action_info (cally_actor, i);
if (info == NULL)
return FALSE;
g_free (info->description);
info->description = g_strdup (desc);
return TRUE;
}
static const gchar*
cally_actor_action_get_keybinding (AtkAction *action,
gint i)
{
CallyActor *cally_actor = NULL;
CallyActorActionInfo *info = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (action), NULL);
cally_actor = CALLY_ACTOR (action);
info = _cally_actor_get_action_info (cally_actor, i);
if (info == NULL)
return NULL;
return info->keybinding;
}
/* Misc functions */
/*
* This function is a signal handler for notify signal which gets emitted
* when a property changes value on the ClutterActor associated with the object.
*
* It calls a function for the CallyActor type
*/
static void
cally_actor_notify_clutter (GObject *obj,
GParamSpec *pspec)
{
CallyActor *cally_actor = NULL;
CallyActorClass *klass = NULL;
cally_actor = CALLY_ACTOR (clutter_actor_get_accessible (CLUTTER_ACTOR (obj)));
klass = CALLY_ACTOR_GET_CLASS (cally_actor);
if (klass->notify_clutter)
klass->notify_clutter (obj, pspec);
}
/*
* This function is a signal handler for notify signal which gets emitted
* when a property changes value on the ClutterActor associated with a CallyActor
*
* It constructs an AtkPropertyValues structure and emits a "property_changed"
* signal which causes the user specified AtkPropertyChangeHandler
* to be called.
*/
static void
cally_actor_real_notify_clutter (GObject *obj,
GParamSpec *pspec)
{
ClutterActor* actor = CLUTTER_ACTOR (obj);
AtkObject* atk_obj = clutter_actor_get_accessible (CLUTTER_ACTOR(obj));
AtkState state;
gboolean value;
if (g_strcmp0 (pspec->name, "visible") == 0)
{
state = ATK_STATE_VISIBLE;
value = clutter_actor_is_visible (actor);
}
else if (g_strcmp0 (pspec->name, "mapped") == 0)
{
/* Clones may temporarily map an actor in order to
* paint it; we don't want this to generate an ATK
* state change
*/
if (clutter_actor_is_in_clone_paint (actor))
return;
state = ATK_STATE_SHOWING;
value = clutter_actor_is_mapped (actor);
}
else if (g_strcmp0 (pspec->name, "reactive") == 0)
{
state = ATK_STATE_SENSITIVE;
value = clutter_actor_get_reactive (actor);
}
else
return;
atk_object_notify_state_change (atk_obj, state, value);
}
static void
_cally_actor_clean_action_list (CallyActor *cally_actor)
{
CallyActorPrivate *priv = NULL;
priv = cally_actor->priv;
if (priv->action_list)
{
g_list_free_full (priv->action_list,
(GDestroyNotify) _cally_actor_destroy_action_info);
priv->action_list = NULL;
}
}
static CallyActorActionInfo *
_cally_actor_get_action_info (CallyActor *cally_actor,
gint index)
{
CallyActorPrivate *priv = NULL;
GList *node = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (cally_actor), NULL);
priv = cally_actor->priv;
if (priv->action_list == NULL)
return NULL;
node = g_list_nth (priv->action_list, index);
if (node == NULL)
return NULL;
return (CallyActorActionInfo *)(node->data);
}
/**
* cally_actor_add_action: (skip)
* @cally_actor: a #CallyActor
* @action_name: the action name
* @action_description: the action description
* @action_keybinding: the action keybinding
* @action_func: the callback of the action, to be executed with do_action
*
* Adds a new action to be accessed with the #AtkAction interface.
*
* Return value: added action id, or -1 if failure
*
* Since: 1.4
*/
guint
cally_actor_add_action (CallyActor *cally_actor,
const gchar *action_name,
const gchar *action_description,
const gchar *action_keybinding,
CallyActionFunc action_func)
{
return cally_actor_add_action_full (cally_actor,
action_name,
action_description,
action_keybinding,
(CallyActionCallback) action_func,
NULL, NULL);
}
/**
* cally_actor_add_action_full: (rename-to cally_actor_add_action)
* @cally_actor: a #CallyActor
* @action_name: the action name
* @action_description: the action description
* @action_keybinding: the action keybinding
* @callback: (scope notified): the callback of the action
* @user_data: (closure): data to be passed to @callback
* @notify: function to be called when removing the action
*
* Adds a new action to be accessed with the #AtkAction interface.
*
* Return value: added action id, or -1 if failure
*
* Since: 1.6
*/
guint
cally_actor_add_action_full (CallyActor *cally_actor,
const gchar *action_name,
const gchar *action_description,
const gchar *action_keybinding,
CallyActionCallback callback,
gpointer user_data,
GDestroyNotify notify)
{
CallyActorActionInfo *info = NULL;
CallyActorPrivate *priv = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (cally_actor), -1);
g_return_val_if_fail (callback != NULL, -1);
priv = cally_actor->priv;
info = g_slice_new (CallyActorActionInfo);
info->name = g_strdup (action_name);
info->description = g_strdup (action_description);
info->keybinding = g_strdup (action_keybinding);
info->do_action_func = callback;
info->user_data = user_data;
info->notify = notify;
priv->action_list = g_list_append (priv->action_list, info);
return g_list_length (priv->action_list);
}
/**
* cally_actor_remove_action:
* @cally_actor: a #CallyActor
* @action_id: the action id
*
* Removes a action, using the @action_id returned by cally_actor_add_action()
*
* Return value: %TRUE if the operation was succesful, %FALSE otherwise
*
* Since: 1.4
*/
gboolean
cally_actor_remove_action (CallyActor *cally_actor,
gint action_id)
{
GList *list_node = NULL;
CallyActorPrivate *priv = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (cally_actor), FALSE);
priv = cally_actor->priv;
list_node = g_list_nth (priv->action_list, action_id - 1);
if (!list_node)
return FALSE;
_cally_actor_destroy_action_info (list_node->data, NULL);
priv->action_list = g_list_remove_link (priv->action_list, list_node);
return TRUE;
}
/**
* cally_actor_remove_action_by_name:
* @cally_actor: a #CallyActor
* @action_name: the name of the action to remove
*
* Removes an action, using the @action_name used when the action was added
* with cally_actor_add_action()
*
* Return value: %TRUE if the operation was succesful, %FALSE otherwise
*
* Since: 1.4
*/
gboolean
cally_actor_remove_action_by_name (CallyActor *cally_actor,
const gchar *action_name)
{
GList *node = NULL;
gboolean action_found = FALSE;
CallyActorPrivate *priv = NULL;
g_return_val_if_fail (CALLY_IS_ACTOR (cally_actor), FALSE);
priv = CALLY_ACTOR (cally_actor)->priv;
for (node = priv->action_list; node && !action_found;
node = node->next)
{
CallyActorActionInfo *ainfo = node->data;
if (!g_ascii_strcasecmp (ainfo->name, action_name))
{
action_found = TRUE;
break;
}
}
if (!action_found)
return FALSE;
_cally_actor_destroy_action_info (node->data, NULL);
priv->action_list = g_list_remove_link (priv->action_list, node);
return TRUE;
}
static void
_cally_actor_destroy_action_info (gpointer action_info,
gpointer user_data)
{
CallyActorActionInfo *info = action_info;
g_assert (info != NULL);
g_free (info->name);
g_free (info->description);
g_free (info->keybinding);
if (info->notify)
info->notify (info->user_data);
g_slice_free (CallyActorActionInfo, info);
}
muffin-6.4.1/clutter/clutter/cally/cally-main.h 0000664 0001750 0001750 00000002565 14723361714 020421 0 ustar fabio fabio /* CALLY - The Clutter Accessibility Implementation Library
*
* Copyright (C) 2008 Igalia, S.L.
*
* Author: Alejandro Piñeiro Iglesias
*
* Some parts are based on GailWidget from GAIL
* GAIL - The GNOME Accessibility Implementation Library
* 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 .
*/
#ifndef __CALLY_MAIN_H__
#define __CALLY_MAIN_H__
#if !defined(__CALLY_H_INSIDE__) && !defined(CLUTTER_COMPILATION)
#error "Only can be included directly."
#endif
#include
#include
G_BEGIN_DECLS
CLUTTER_EXPORT
gboolean cally_get_cally_initialized (void);
CLUTTER_EXPORT
gboolean cally_accessibility_init (void);
G_END_DECLS
#endif /* __CALLY_MAIN_H__ */
muffin-6.4.1/clutter/clutter/cally/ChangeLog.pre-cally-merge 0000664 0001750 0001750 00000074143 14723361714 022761 0 ustar fabio fabio # DO NOT MODIFY THIS FILE
#
# Clutter uses the Git commit log to generate the ChangeLog files when
# creating the tarball for releases and snapshots. This file is maintained
# only for historical reasons.
2010-07-05 Alejandro Pieiro