isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-27 02:20:43 -05:00
Code Issues Packages Projects Releases Wiki Activity
15a2ccd21b
mutter/src/meson.build

925 lines
27 KiB
Meson
Raw Normal View History

build: Don't use absolute paths with subdir keyword Meson 0.50.0 made passing an absolute path to install_headers()' subdir keyword a fatal error. This means we have to track both relative (to includedir) paths for header subdirs and absolute paths for generated headers now :-( https://gitlab.gnome.org/GNOME/mutter/merge_requests/492
2019-03-11 20:35:13 -04:00
mutter_includesubdir = join_paths(pkgname, 'meta')
mutter_includedir = join_paths(includedir, mutter_includesubdir)
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
mutter_includes = [
include_directories('.'),
top_includepath,
clutter_includepath,
cogl_includepath,
]
mutter_lib_deps = [
m_dep,
]
mutter_pkg_deps = [
cairo_dep,
gio_unix_dep,
glib_dep,
meson: Don't list libraries private dependencies in pc files pkg-config files for mutter are generated using *_pkg_deps as requires, but programs linked with libmutter doesn't need most of these private dependencies which are only needed for building and linking mutter and its subprojects. So list packages needed only by mutter itself inside *_pkg_private_deps and don't expose such packages to pkg-config, but only use them at build time. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-21 06:13:48 -05:00
gsettings_desktop_schemas_dep,
gtk3_dep,
pango_dep,
]
mutter_pkg_private_deps = [
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
gmodule_no_export_dep,
gnome_desktop_dep,
gnome_settings_daemon_dep,
json_glib_dep,
build: Use plain libcanberra instead of libcanberra-gtk3 We no longer use the gtk-aware ca_context, the dependency can be lowered now.
2019-01-08 09:59:57 -05:00
libcanberra_dep,
meson: Don't list libraries private dependencies in pc files pkg-config files for mutter are generated using *_pkg_deps as requires, but programs linked with libmutter doesn't need most of these private dependencies which are only needed for building and linking mutter and its subprojects. So list packages needed only by mutter itself inside *_pkg_private_deps and don't expose such packages to pkg-config, but only use them at build time. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-21 06:13:48 -05:00
xkbcommon_dep,
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
]
if have_gl
mutter_pkg_deps += [
gl_dep,
]
endif
if have_gles2
meson: Don't list libraries private dependencies in pc files pkg-config files for mutter are generated using *_pkg_deps as requires, but programs linked with libmutter doesn't need most of these private dependencies which are only needed for building and linking mutter and its subprojects. So list packages needed only by mutter itself inside *_pkg_private_deps and don't expose such packages to pkg-config, but only use them at build time. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-21 06:13:48 -05:00
mutter_pkg_private_deps += [
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
gles2_dep,
]
endif
if have_egl
mutter_pkg_deps += [
egl_dep,
]
endif
if have_libgudev
meson: Don't list libraries private dependencies in pc files pkg-config files for mutter are generated using *_pkg_deps as requires, but programs linked with libmutter doesn't need most of these private dependencies which are only needed for building and linking mutter and its subprojects. So list packages needed only by mutter itself inside *_pkg_private_deps and don't expose such packages to pkg-config, but only use them at build time. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-21 06:13:48 -05:00
mutter_pkg_private_deps += [
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
gudev_dep,
libudev_dep,
]
endif
if have_startup_notification
meson: Don't list libraries private dependencies in pc files pkg-config files for mutter are generated using *_pkg_deps as requires, but programs linked with libmutter doesn't need most of these private dependencies which are only needed for building and linking mutter and its subprojects. So list packages needed only by mutter itself inside *_pkg_private_deps and don't expose such packages to pkg-config, but only use them at build time. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-21 06:13:48 -05:00
mutter_pkg_private_deps += [
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
libstartup_notification_dep,
]
endif
if have_libwacom
meson: Don't list libraries private dependencies in pc files pkg-config files for mutter are generated using *_pkg_deps as requires, but programs linked with libmutter doesn't need most of these private dependencies which are only needed for building and linking mutter and its subprojects. So list packages needed only by mutter itself inside *_pkg_private_deps and don't expose such packages to pkg-config, but only use them at build time. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-21 06:13:48 -05:00
mutter_pkg_private_deps += [
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
libwacom_dep,
]
endif
if have_remote_desktop
meson: Don't list libraries private dependencies in pc files pkg-config files for mutter are generated using *_pkg_deps as requires, but programs linked with libmutter doesn't need most of these private dependencies which are only needed for building and linking mutter and its subprojects. So list packages needed only by mutter itself inside *_pkg_private_deps and don't expose such packages to pkg-config, but only use them at build time. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-21 06:13:48 -05:00
mutter_pkg_private_deps += [
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
libpipewire_dep,
]
endif
if have_introspection
meson: Don't list libraries private dependencies in pc files pkg-config files for mutter are generated using *_pkg_deps as requires, but programs linked with libmutter doesn't need most of these private dependencies which are only needed for building and linking mutter and its subprojects. So list packages needed only by mutter itself inside *_pkg_private_deps and don't expose such packages to pkg-config, but only use them at build time. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-21 06:13:48 -05:00
mutter_pkg_private_deps += [
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
gobject_introspection_dep,
]
endif
if have_x11
mutter_pkg_deps += [
meson: Don't list libraries private dependencies in pc files pkg-config files for mutter are generated using *_pkg_deps as requires, but programs linked with libmutter doesn't need most of these private dependencies which are only needed for building and linking mutter and its subprojects. So list packages needed only by mutter itself inside *_pkg_private_deps and don't expose such packages to pkg-config, but only use them at build time. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-21 06:13:48 -05:00
xfixes_dep,
xi_dep,
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
x11_dep,
meson: Don't list libraries private dependencies in pc files pkg-config files for mutter are generated using *_pkg_deps as requires, but programs linked with libmutter doesn't need most of these private dependencies which are only needed for building and linking mutter and its subprojects. So list packages needed only by mutter itself inside *_pkg_private_deps and don't expose such packages to pkg-config, but only use them at build time. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-21 06:13:48 -05:00
]
mutter_pkg_private_deps += [
xrandr_dep,
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
xinerama_dep,
xext_dep,
ice_dep,
xcomposite_dep,
xcursor_dep,
xdamage_dep,
xkbfile_dep,
xkeyboard_config_dep,
xkbcommon_x11_dep,
xrender_dep,
x11_xcb_dep,
xcb_randr_dep,
xcb_res_dep,
xwayland: Generate a Xauth file and pass this to Xwayland when starting it Before this commit, sudo x11-app, e.g. sudo gvim /etc/some-file, fails when running a Wayland session. Where as doing this under a "GNOME on Xorg" session works fine. For a user switching from the Xorg session to the Wayland session, this is regression, which we want to avoid. This commit fixes this by creating and passing an xauth file to Xwayland when mutter starts it. Just like gdm or startx pass a xauth file to Xorg when they start Xorg. Fixes #643 https://gitlab.gnome.org/GNOME/mutter/issues/643
2019-06-18 10:12:46 -04:00
xau_dep,
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
]
if have_sm
meson: Don't list libraries private dependencies in pc files pkg-config files for mutter are generated using *_pkg_deps as requires, but programs linked with libmutter doesn't need most of these private dependencies which are only needed for building and linking mutter and its subprojects. So list packages needed only by mutter itself inside *_pkg_private_deps and don't expose such packages to pkg-config, but only use them at build time. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-21 06:13:48 -05:00
mutter_pkg_private_deps += [
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
sm_dep,
]
endif
endif
if have_wayland
mutter_pkg_deps += [
wayland_server_dep,
]
endif
if have_native_backend
meson: Don't list libraries private dependencies in pc files pkg-config files for mutter are generated using *_pkg_deps as requires, but programs linked with libmutter doesn't need most of these private dependencies which are only needed for building and linking mutter and its subprojects. So list packages needed only by mutter itself inside *_pkg_private_deps and don't expose such packages to pkg-config, but only use them at build time. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-21 06:13:48 -05:00
mutter_pkg_private_deps += [
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
libdrm_dep,
libinput_dep,
gudev_dep,
libgbm_dep,
logind_provider_dep,
]
endif
if have_wayland_eglstream
mutter_lib_deps += [
dl_dep,
]
meson: Don't list libraries private dependencies in pc files pkg-config files for mutter are generated using *_pkg_deps as requires, but programs linked with libmutter doesn't need most of these private dependencies which are only needed for building and linking mutter and its subprojects. So list packages needed only by mutter itself inside *_pkg_private_deps and don't expose such packages to pkg-config, but only use them at build time. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-21 06:13:48 -05:00
mutter_pkg_private_deps += [
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
wayland_eglstream_protocols_dep,
]
endif
mutter_deps = [
mutter_pkg_deps,
meson: Don't list libraries private dependencies in pc files pkg-config files for mutter are generated using *_pkg_deps as requires, but programs linked with libmutter doesn't need most of these private dependencies which are only needed for building and linking mutter and its subprojects. So list packages needed only by mutter itself inside *_pkg_private_deps and don't expose such packages to pkg-config, but only use them at build time. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-21 06:13:48 -05:00
mutter_pkg_private_deps,
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
mutter_lib_deps,
]
mutter_c_args = [
'-DCLUTTER_ENABLE_COMPOSITOR_API',
'-DCLUTTER_ENABLE_EXPERIMENTAL_API',
'-DCOGL_ENABLE_EXPERIMENTAL_API',
'-DCOGL_ENABLE_EXPERIMENTAL_2_0_API',
'-DCOGL_ENABLE_MUTTER_API',
'-DCLUTTER_DISABLE_DEPRECATION_WARNINGS',
'-DCOGL_DISABLE_DEPRECATION_WARNINGS',
'-DG_LOG_DOMAIN="mutter"',
'-DSN_API_NOT_YET_FROZEN=1',
'-DGETTEXT_PACKAGE="@0@"'.format(meson.project_name()),
]
if get_option('verbose')
mutter_c_args += [
'-DWITH_VERBOSE_MODE'
]
endif
mutter_sources = [
'backends/edid.h',
'backends/edid-parse.c',
'backends/gsm-inhibitor-flag.h',
'backends/meta-backend.c',
'backends/meta-backend-private.h',
'backends/meta-barrier.c',
'backends/meta-barrier-private.h',
'backends/meta-crtc.c',
'backends/meta-crtc.h',
'backends/meta-cursor.c',
'backends/meta-cursor.h',
'backends/meta-cursor-renderer.c',
'backends/meta-cursor-renderer.h',
'backends/meta-cursor-sprite-xcursor.c',
'backends/meta-cursor-sprite-xcursor.h',
'backends/meta-cursor-tracker.c',
'backends/meta-cursor-tracker-private.h',
'backends/meta-display-config-shared.h',
'backends/meta-dnd-private.h',
'backends/meta-gpu.c',
'backends/meta-gpu.h',
'backends/meta-idle-monitor.c',
'backends/meta-idle-monitor-dbus.c',
'backends/meta-idle-monitor-dbus.h',
'backends/meta-idle-monitor-private.h',
backends: Add MetaInputMapper This object takes care of mapping absolute devices to monitors, to do so it uses 3 heuristics, in this order of preference: - If a device is known to be builtin, it's assigned to the builtin monitor. - If input device and monitor match sizes (with an error margin of 5%) - If input device name and monitor vendor/product in EDID match somehow (from "full", through "partial", to just "vendor") The most favorable outputs are then assigned to each device, making sure not to assign two devices of the same kind to the same output. This object replaces (and is mostly 1:1 with) GsdDeviceMapper in g-s-d. That object would perform these same heuristics, and let mutter indirectly know through settings changes. This object allows doing the same in-process.
2018-04-20 10:34:32 -04:00
'backends/meta-input-mapper.c',
'backends/meta-input-mapper-private.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'backends/meta-input-settings.c',
'backends/meta-input-settings-private.h',
'backends/meta-logical-monitor.c',
'backends/meta-logical-monitor.h',
'backends/meta-monitor.c',
'backends/meta-monitor-config-manager.c',
'backends/meta-monitor-config-manager.h',
'backends/meta-monitor-config-migration.c',
'backends/meta-monitor-config-migration.h',
'backends/meta-monitor-config-store.c',
'backends/meta-monitor-config-store.h',
'backends/meta-monitor.h',
'backends/meta-monitor-manager.c',
'backends/meta-monitor-manager-dummy.c',
'backends/meta-monitor-manager-dummy.h',
'backends/meta-monitor-manager-private.h',
monitor-transform: Add helper function transform_invert() It returns the inverted transform, which is always the same as the input, besides for TRANSFORM_90 and TRANSFORM_270. https://gitlab.gnome.org/GNOME/mutter/merge_requests/366
2019-01-05 08:18:02 -05:00
'backends/meta-monitor-transform.c',
monitor-transform: Move helper functions into their own file The existing ones are statically inlined, so there is no .c file right now. https://gitlab.gnome.org/GNOME/mutter/merge_requests/366
2019-01-05 08:15:23 -05:00
'backends/meta-monitor-transform.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'backends/meta-orientation-manager.c',
'backends/meta-orientation-manager.h',
'backends/meta-output.c',
'backends/meta-output.h',
'backends/meta-pointer-constraint.c',
'backends/meta-pointer-constraint.h',
'backends/meta-remote-access-controller-private.h',
'backends/meta-remote-access-controller.c',
'backends/meta-renderer.c',
'backends/meta-renderer.h',
'backends/meta-renderer-view.c',
'backends/meta-renderer-view.h',
screen-cast: Add screen-cast-window interface Typically, to stream the content of a window, we need a way to copy the content of its window-actor into a buffer, transform relative input coordinates to relative position within the window-actor and a mean to get the window bounds within the buffer. For this purpose, add a new GType interface `MetaScreenCastWindow` with the methods needed for screen-cast window mode: * meta_screen_cast_window_get_buffer_bounds() * meta_screen_cast_window_get_frame_bounds() * meta_screen_cast_window_transform_relative_position() * meta_screen_cast_window_capture_into() This interface is meant to be implemented by `MetaWindowActor` which has access to all the necessary bits to implement them. https://gitlab.gnome.org/GNOME/mutter/merge_requests/306
2018-12-05 02:48:41 -05:00
'backends/meta-screen-cast-window.c',
'backends/meta-screen-cast-window.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'backends/meta-settings.c',
'backends/meta-settings-private.h',
'backends/meta-stage.c',
'backends/meta-stage-private.h',
'backends/x11/cm/meta-backend-x11-cm.c',
'backends/x11/cm/meta-backend-x11-cm.h',
'backends/x11/cm/meta-cursor-sprite-xfixes.c',
'backends/x11/cm/meta-cursor-sprite-xfixes.h',
'backends/x11/cm/meta-renderer-x11-cm.c',
'backends/x11/cm/meta-renderer-x11-cm.h',
'backends/x11/meta-backend-x11.c',
'backends/x11/meta-backend-x11.h',
'backends/x11/meta-barrier-x11.c',
'backends/x11/meta-barrier-x11.h',
'backends/x11/meta-clutter-backend-x11.c',
'backends/x11/meta-clutter-backend-x11.h',
'backends/x11/meta-crtc-xrandr.c',
'backends/x11/meta-crtc-xrandr.h',
'backends/x11/meta-cursor-renderer-x11.c',
'backends/x11/meta-cursor-renderer-x11.h',
'backends/x11/meta-gpu-xrandr.c',
'backends/x11/meta-gpu-xrandr.h',
'backends/x11/meta-input-settings-x11.c',
'backends/x11/meta-input-settings-x11.h',
'backends/x11/meta-monitor-manager-xrandr.c',
'backends/x11/meta-monitor-manager-xrandr.h',
'backends/x11/meta-output-xrandr.c',
'backends/x11/meta-output-xrandr.h',
'backends/x11/meta-renderer-x11.c',
'backends/x11/meta-renderer-x11.h',
'backends/x11/meta-stage-x11-nested.c',
'backends/x11/meta-stage-x11-nested.h',
'backends/x11/nested/meta-backend-x11-nested.c',
'backends/x11/nested/meta-backend-x11-nested.h',
'backends/x11/nested/meta-cursor-renderer-x11-nested.c',
'backends/x11/nested/meta-cursor-renderer-x11-nested.h',
'backends/x11/nested/meta-renderer-x11-nested.c',
'backends/x11/nested/meta-renderer-x11-nested.h',
'compositor/clutter-utils.c',
'compositor/clutter-utils.h',
'compositor/cogl-utils.c',
'compositor/cogl-utils.h',
'compositor/compositor.c',
'compositor/compositor-private.h',
'compositor/meta-background-actor.c',
'compositor/meta-background-actor-private.h',
'compositor/meta-background.c',
'compositor/meta-background-group.c',
'compositor/meta-background-image.c',
'compositor/meta-background-private.h',
'compositor/meta-cullable.c',
'compositor/meta-cullable.h',
'compositor/meta-dnd-actor.c',
'compositor/meta-dnd-actor-private.h',
'compositor/meta-dnd.c',
'compositor/meta-feedback-actor.c',
'compositor/meta-feedback-actor-private.h',
'compositor/meta-module.c',
'compositor/meta-module.h',
'compositor/meta-plugin.c',
'compositor/meta-plugin-manager.c',
'compositor/meta-plugin-manager.h',
'compositor/meta-shadow-factory.c',
'compositor/meta-shaped-texture.c',
'compositor/meta-shaped-texture-private.h',
'compositor/meta-surface-actor.c',
'compositor/meta-surface-actor.h',
'compositor/meta-surface-actor-x11.c',
'compositor/meta-surface-actor-x11.h',
'compositor/meta-sync-ring.c',
'compositor/meta-sync-ring.h',
'compositor/meta-texture-tower.c',
'compositor/meta-texture-tower.h',
'compositor/meta-window-actor.c',
'compositor/meta-window-actor-private.h',
Add MetaWindowActorX11 and MetaWindowActorWayland Those are stub specialized classes for MetaWindowActor. This will help ensuring that we do not execute X11-specific code paths on pure Wayland clients. The relationship between the window actor and the surface is the following: * Wayland: MetaWindowActorWayland + MetaSurfaceActorWayland * X11: MetaWindowActorX11 + MetaSurfaceActorX11 * Xwayland: MetaWindowActorX11 + MetaSurfaceActorWayland It is not possible to have MetaWindowActorWayland backed by a MetaSurfaceActorX11 surface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/368
2018-12-21 15:35:18 -05:00
'compositor/meta-window-actor-wayland.c',
'compositor/meta-window-actor-wayland.h',
'compositor/meta-window-actor-x11.c',
'compositor/meta-window-actor-x11.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'compositor/meta-window-group.c',
'compositor/meta-window-group-private.h',
'compositor/meta-window-shape.c',
'compositor/region-utils.c',
'compositor/region-utils.h',
'core/bell.c',
'core/bell.h',
'core/boxes.c',
'core/boxes-private.h',
'core/constraints.c',
'core/constraints.h',
'core/core.c',
'core/core.h',
'core/delete.c',
'core/display.c',
'core/display-private.h',
'core/edge-resistance.c',
'core/edge-resistance.h',
'core/events.c',
'core/events.h',
'core/frame.c',
'core/frame.h',
'core/keybindings.c',
'core/keybindings-private.h',
'core/main.c',
'core/main-private.h',
'core/meta-accel-parse.c',
'core/meta-accel-parse.h',
'core/meta-border.c',
'core/meta-border.h',
core: Add clipboard manager This is a simple clipboard manager implementation on top of MetaSelection. It will inspect the clipboard content for UTF-8 text and image data whenever any other selection source claims ownership, and claim it for itself whenever the clipboard goes unowned. The stored text has a maximum size of 4MB and images 200MB, to prevent the compositor from allocating indefinite amounts of memory. This is not quite a X11 clipboard manager, but also works there. https://gitlab.gnome.org/GNOME/mutter/merge_requests/320
2018-11-19 13:57:15 -05:00
'core/meta-clipboard-manager.c',
'core/meta-clipboard-manager.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'core/meta-close-dialog.c',
'core/meta-close-dialog-default.c',
'core/meta-close-dialog-default-private.h',
'core/meta-fraction.c',
'core/meta-fraction.h',
'core/meta-gesture-tracker.c',
'core/meta-gesture-tracker-private.h',
'core/meta-inhibit-shortcuts-dialog.c',
'core/meta-inhibit-shortcuts-dialog-default.c',
'core/meta-inhibit-shortcuts-dialog-default-private.h',
core: Add MetaLaunchContext This is a GAppLaunchContext subclass meant to replace usage of GdkAppLaunchContext in gnome-shell. Launch contexts get created from the MetaStartupNotification as they are closely related. The messaging underneath depends on the availability of a X11 display, if there is one we go through it (and libsn). If there is none, we still create startup sequences manually for wayland clients.
2018-12-13 13:02:19 -05:00
'core/meta-launch-context.c',
core: Add MetaSelection and MetaSelectionSource MetaSelectionSource represents a primary/clipboard/dnd selection owner, it is an abstract type so wayland/x11/etc implementations can be provided. These 3 selections are managed by the MetaSelection object, the current selection owners will be set there, and signals will be emitted so the previous selection owner can clean itself up. The actual data transfer is done through the meta_selection_transfer_async() call, which will take a GOutputStream and create a corresponding GInputStream from the MetaSelectionSource in order to splice them. https://gitlab.gnome.org/GNOME/mutter/merge_requests/320
2018-11-19 10:45:20 -05:00
'core/meta-selection.c',
'core/meta-selection-source.c',
core: Add memory-based selection source This is a simple implementation of a MetaSelectionSource, able to hold a single mimetype, provided as GBytes. https://gitlab.gnome.org/GNOME/mutter/merge_requests/320
2018-11-19 13:50:21 -05:00
'core/meta-selection-source-memory.c',
core: Add MetaSoundPlayer abstraction This is a simple libcanberra abstraction object, so we are able to play file/theme sounds without poking into GTK+/X11. Play requests are delegated to a separate thread, so we don't block UI on cards that are slow to wake up from power saving.
2018-12-09 06:44:20 -05:00
'core/meta-sound-player.c',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'core/meta-workspace-manager.c',
'core/meta-workspace-manager-private.h',
'core/place.c',
'core/place.h',
'core/prefs.c',
'core/restart.c',
'core/stack.c',
'core/stack.h',
'core/stack-tracker.c',
'core/stack-tracker.h',
'core/startup-notification.c',
'core/startup-notification-private.h',
'core/util.c',
'core/util-private.h',
'core/window.c',
'core/window-private.h',
'core/workspace.c',
'core/workspace-private.h',
'ui/frames.c',
'ui/frames.h',
'ui/theme.c',
'ui/theme-private.h',
'ui/ui.c',
'ui/ui.h',
'x11/atomnames.h',
'x11/events.c',
'x11/events.h',
'x11/group.c',
'x11/group-private.h',
'x11/group-props.c',
'x11/group-props.h',
'x11/iconcache.c',
'x11/iconcache.h',
x11: Add X11 MetaSelectionSource implementation This object represents the selection ownership from an X11 client. The list of supported targets is queried upfront, so its initialization is asynchronous. Requests to read contents from the selection will hand a MetaX11SelectionInputStream. https://gitlab.gnome.org/GNOME/mutter/merge_requests/320
2018-11-19 11:16:37 -05:00
'x11/meta-selection-source-x11.c',
'x11/meta-selection-source-x11-private.h',
x11: Refactor the X11 startup notification bits into src/x11 Only one little bit left in MetaDisplay, because SnStartupSequence is exposed in API there. These bits will be removed in future commits.
2018-08-22 14:57:04 -04:00
'x11/meta-startup-notification-x11.c',
'x11/meta-startup-notification-x11.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'x11/meta-x11-display.c',
'x11/meta-x11-display-private.h',
'x11/meta-x11-errors.c',
x11: Add X11 selection management This code takes care of both setting up X11 selection sources whenever X11 clients claim selection ownership, and claiming selection ownership on a mutter X11 window whenever other selection sources claim ownership. https://gitlab.gnome.org/GNOME/mutter/merge_requests/320
2018-11-19 12:17:25 -05:00
'x11/meta-x11-selection.c',
'x11/meta-x11-selection-private.h',
x11: Add X11 selection input/output streams These are rip off of GTK+ ones, with some adaptions to integrate them in mutter event dispatching code and make them easier to use in future commits. https://gitlab.gnome.org/GNOME/mutter/merge_requests/320
2018-11-18 04:49:36 -05:00
'x11/meta-x11-selection-input-stream.c',
'x11/meta-x11-selection-input-stream-private.h',
'x11/meta-x11-selection-output-stream.c',
'x11/meta-x11-selection-output-stream-private.h',
x11: Add MetaX11Stack object This object takes care of the X11 representation of the window stack, namely the _NET_CLIENT_LIST and _NET_CLIENT_LIST_STACKING root window properties. This code has been lifted from src/core/stack.c into src/x11 as it's dependent on the X11 display availability. This also leaves MetaStack squeaky clean of x11 specifics. https://gitlab.gnome.org/GNOME/mutter/merge_requests/420
2019-05-07 06:59:50 -04:00
'x11/meta-x11-stack.c',
'x11/meta-x11-stack-private.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'x11/mutter-Xatomtype.h',
'x11/session.c',
'x11/session.h',
'x11/window-props.c',
'x11/window-props.h',
'x11/window-x11.c',
'x11/window-x11.h',
'x11/window-x11-private.h',
'x11/xprops.c',
'x11/xprops.h',
]
if have_egl
mutter_sources += [
'backends/meta-egl.c',
'backends/meta-egl-ext.h',
'backends/meta-egl.h',
]
endif
if have_gles2
mutter_sources += [
'backends/meta-gles3.c',
'backends/meta-gles3.h',
'backends/meta-gles3-table.h',
]
endif
if have_remote_desktop
mutter_sources += [
'backends/meta-dbus-session-watcher.c',
'backends/meta-dbus-session-watcher.h',
'backends/meta-remote-desktop.c',
'backends/meta-remote-desktop.h',
'backends/meta-remote-desktop-session.c',
'backends/meta-remote-desktop-session.h',
'backends/meta-screen-cast.c',
'backends/meta-screen-cast.h',
'backends/meta-screen-cast-monitor-stream.c',
'backends/meta-screen-cast-monitor-stream.h',
'backends/meta-screen-cast-monitor-stream-src.c',
'backends/meta-screen-cast-monitor-stream-src.h',
screen-cast-session: Add screen-cast window mode Window mode will cast the content of a single window using the `MetaScreenCastWindow` interface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/306
2018-10-09 09:35:14 -04:00
'backends/meta-screen-cast-window-stream-src.c',
'backends/meta-screen-cast-window-stream-src.h',
'backends/meta-screen-cast-window-stream.c',
'backends/meta-screen-cast-window-stream.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'backends/meta-screen-cast-session.c',
'backends/meta-screen-cast-session.h',
'backends/meta-screen-cast-stream.c',
'backends/meta-screen-cast-stream.h',
'backends/meta-screen-cast-stream-src.c',
'backends/meta-screen-cast-stream-src.h',
]
endif
if have_wayland
mutter_sources += [
'compositor/meta-surface-actor-wayland.c',
'compositor/meta-surface-actor-wayland.h',
'wayland/meta-cursor-sprite-wayland.c',
'wayland/meta-cursor-sprite-wayland.h',
'wayland/meta-pointer-confinement-wayland.c',
'wayland/meta-pointer-confinement-wayland.h',
'wayland/meta-pointer-lock-wayland.c',
'wayland/meta-pointer-lock-wayland.h',
wayland: Add wayland MetaSelectionSource implementation This object represents a Wayland selection owner. In order to invert the FD direction (we hand an output fd, but want an inpu fd), create an intermediate pipe so we can then create a GInputStream on top of it. https://gitlab.gnome.org/GNOME/mutter/merge_requests/320
2018-11-19 11:34:18 -05:00
'wayland/meta-selection-source-wayland.c',
'wayland/meta-selection-source-wayland-private.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'wayland/meta-wayland-actor-surface.c',
'wayland/meta-wayland-actor-surface.h',
'wayland/meta-wayland-buffer.c',
'wayland/meta-wayland-buffer.h',
'wayland/meta-wayland.c',
'wayland/meta-wayland-cursor-surface.c',
'wayland/meta-wayland-cursor-surface.h',
'wayland/meta-wayland-data-device.c',
'wayland/meta-wayland-data-device.h',
'wayland/meta-wayland-data-device-private.h',
'wayland/meta-wayland-dma-buf.c',
'wayland/meta-wayland-dma-buf.h',
wayland: Move DND surface role into its own file This avoids a -Wredundand-decls warning about the get_type() function.
2019-01-20 11:34:50 -05:00
'wayland/meta-wayland-dnd-surface.c',
'wayland/meta-wayland-dnd-surface.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'wayland/meta-wayland-gtk-shell.c',
'wayland/meta-wayland-gtk-shell.h',
'wayland/meta-wayland.h',
'wayland/meta-wayland-inhibit-shortcuts.c',
'wayland/meta-wayland-inhibit-shortcuts-dialog.c',
'wayland/meta-wayland-inhibit-shortcuts-dialog.h',
'wayland/meta-wayland-inhibit-shortcuts.h',
'wayland/meta-wayland-input-device.c',
'wayland/meta-wayland-input-device.h',
'wayland/meta-wayland-keyboard.c',
'wayland/meta-wayland-keyboard.h',
'wayland/meta-wayland-legacy-xdg-shell.c',
'wayland/meta-wayland-legacy-xdg-shell.h',
'wayland/meta-wayland-outputs.c',
'wayland/meta-wayland-outputs.h',
'wayland/meta-wayland-pointer.c',
'wayland/meta-wayland-pointer-constraints.c',
'wayland/meta-wayland-pointer-constraints.h',
'wayland/meta-wayland-pointer-gesture-pinch.c',
'wayland/meta-wayland-pointer-gesture-pinch.h',
'wayland/meta-wayland-pointer-gestures.c',
'wayland/meta-wayland-pointer-gestures.h',
'wayland/meta-wayland-pointer-gesture-swipe.c',
'wayland/meta-wayland-pointer-gesture-swipe.h',
'wayland/meta-wayland-pointer.h',
'wayland/meta-wayland-popup.c',
'wayland/meta-wayland-popup.h',
'wayland/meta-wayland-private.h',
'wayland/meta-wayland-region.c',
'wayland/meta-wayland-region.h',
'wayland/meta-wayland-seat.c',
'wayland/meta-wayland-seat.h',
'wayland/meta-wayland-shell-surface.c',
'wayland/meta-wayland-shell-surface.h',
'wayland/meta-wayland-subsurface.c',
'wayland/meta-wayland-subsurface.h',
'wayland/meta-wayland-surface.c',
'wayland/meta-wayland-surface.h',
'wayland/meta-wayland-tablet.c',
'wayland/meta-wayland-tablet-cursor-surface.c',
'wayland/meta-wayland-tablet-cursor-surface.h',
'wayland/meta-wayland-tablet.h',
'wayland/meta-wayland-tablet-manager.c',
'wayland/meta-wayland-tablet-manager.h',
'wayland/meta-wayland-tablet-pad.c',
'wayland/meta-wayland-tablet-pad-group.c',
'wayland/meta-wayland-tablet-pad-group.h',
'wayland/meta-wayland-tablet-pad.h',
'wayland/meta-wayland-tablet-pad-ring.c',
'wayland/meta-wayland-tablet-pad-ring.h',
'wayland/meta-wayland-tablet-pad-strip.c',
'wayland/meta-wayland-tablet-pad-strip.h',
'wayland/meta-wayland-tablet-seat.c',
'wayland/meta-wayland-tablet-seat.h',
'wayland/meta-wayland-tablet-tool.c',
'wayland/meta-wayland-tablet-tool.h',
'wayland/meta-wayland-text-input.c',
'wayland/meta-wayland-text-input.h',
'wayland/meta-wayland-text-input-legacy.c',
'wayland/meta-wayland-text-input-legacy.h',
'wayland/meta-wayland-touch.c',
'wayland/meta-wayland-touch.h',
'wayland/meta-wayland-types.h',
'wayland/meta-wayland-versions.h',
wayland/surface: Add support for wp_viewporter This adds the required bits to wayland surfaces and ties them up to the compositor parts. It is based on and very similar in nature to buffer transforms. From the specification: > The global interface exposing surface cropping and scaling > capabilities is used to instantiate an interface extension for a > wl_surface object. This extended interface will then allow cropping > and scaling the surface contents, effectively disconnecting the > direct relationship between the buffer and the surface size. https://gitlab.gnome.org/GNOME/mutter/merge_requests/323
2018-11-24 14:25:38 -05:00
'wayland/meta-wayland-viewporter.c',
'wayland/meta-wayland-viewporter.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'wayland/meta-wayland-wl-shell.c',
'wayland/meta-wayland-wl-shell.h',
'wayland/meta-wayland-xdg-foreign.c',
'wayland/meta-wayland-xdg-foreign.h',
'wayland/meta-wayland-xdg-shell.c',
'wayland/meta-wayland-xdg-shell.h',
'wayland/meta-window-wayland.c',
'wayland/meta-window-wayland.h',
'wayland/meta-window-xwayland.c',
'wayland/meta-window-xwayland.h',
'wayland/meta-xwayland.c',
'wayland/meta-xwayland-grab-keyboard.c',
'wayland/meta-xwayland-grab-keyboard.h',
'wayland/meta-xwayland.h',
'wayland/meta-xwayland-private.h',
wayland: Reduce MetaXWaylandSelection to just DnD All the actual selection management functionality is superseded by MetaSelection. Reduce it to just handling the XDND messaging and leave selections to MetaSelection. https://gitlab.gnome.org/GNOME/mutter/merge_requests/320
2018-11-21 19:33:13 -05:00
'wayland/meta-xwayland-dnd.c',
'wayland/meta-xwayland-dnd-private.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
]
endif
if have_native_backend
mutter_sources += [
'backends/native/dbus-utils.c',
'backends/native/dbus-utils.h',
'backends/native/meta-backend-native.c',
'backends/native/meta-backend-native.h',
'backends/native/meta-backend-native-private.h',
udev: Add helpers to list DRM devices Will be used to move out some udev related logic when adding GPUs. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-01-10 12:07:12 -05:00
'backends/native/meta-backend-native-types.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'backends/native/meta-barrier-native.c',
'backends/native/meta-barrier-native.h',
'backends/native/meta-clutter-backend-native.c',
'backends/native/meta-clutter-backend-native.h',
'backends/native/meta-crtc-kms.c',
'backends/native/meta-crtc-kms.h',
'backends/native/meta-cursor-renderer-native.c',
'backends/native/meta-cursor-renderer-native.h',
drm-buffer: Make the "types" actual types There is no reason why we should have an internal type enum when we have all the infrastructure to just use multiple GObject types. Also there was no code sharing between the old "types", the only common API was getting the framebuffer ID, so lets make that a vfunc. https://gitlab.gnome.org/GNOME/mutter/merge_requests/584
2019-05-20 16:08:35 -04:00
'backends/native/meta-drm-buffer-dumb.c',
'backends/native/meta-drm-buffer-dumb.h',
'backends/native/meta-drm-buffer-gbm.c',
'backends/native/meta-drm-buffer-gbm.h',
kms-buffer: Rename to MetaDrmBuffer MetaKms* will be a dedicated namespace, which MetaKmsBuffer doesn't fit under. https://gitlab.gnome.org/GNOME/mutter/merge_requests/584
2019-05-20 15:20:17 -04:00
'backends/native/meta-drm-buffer.c',
'backends/native/meta-drm-buffer.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'backends/native/meta-gpu-kms.c',
'backends/native/meta-gpu-kms.h',
'backends/native/meta-input-settings-native.c',
'backends/native/meta-input-settings-native.h',
'backends/native/meta-launcher.c',
'backends/native/meta-launcher.h',
'backends/native/meta-monitor-manager-kms.c',
'backends/native/meta-monitor-manager-kms.h',
'backends/native/meta-output-kms.c',
'backends/native/meta-output-kms.h',
'backends/native/meta-renderer-native.c',
kms: Add CRTC representation Add MetaKmsCrtc to represent a CRTC on the associated device. Change MetaCrtcKms to use the ones discovered by the KMS abstraction. It still reads the resources handed over by MetaGpuKms, but eventually it will use only MetaKmsCrtc. MetaKmsCrtc is a type of object that is usable both from an impl task and from outside. All the API exposed via the non-private header is expected to be accessible from outside of the meta-kms namespace. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-01-29 12:33:00 -05:00
'backends/native/meta-kms-crtc-private.h',
'backends/native/meta-kms-crtc.c',
'backends/native/meta-kms-crtc.h',
backends/native: Add basic KMS abstraction building blocks The intention with KMS abstraction is to hide away accessing the drm functions behind an API that allows us to have different kind of KMS implementations, including legacy non-atomic and atomic. The intention is also that the code interacting with the drm device should be able to be run in a different thread than the main thread. This means that we need to make sure that all drm*() API usage must only occur from within tasks that eventually can be run in the dedicated thread. The idea here is that MetaKms provides a outward facing API other places of mutter can use (e.g. MetaGpuKms and friends), while MetaKmsImpl is an internal implementation that only gets interacted with via "tasks" posted via the MetaKms object. These tasks will in the future potentially be run on the dedicated KMS thread. Initially, we don't create any new threads. Likewise, MetaKmsDevice is a outward facing representation of a KMS device, while MetaKmsImplDevice is the corresponding implementation, which only runs from within the MetaKmsImpl tasks. This commit only moves opening and closing the device to this new API, while leaking the fd outside of the impl enclosure, effectively making the isolation for drm*() calls pointless. This, however, is necessary to allow gradual porting of drm interaction, and eventually the file descriptor in MetaGpuKms will be removed. For now, it's harmless, since everything still run in the main thread. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-01-29 04:24:44 -05:00
'backends/native/meta-kms-device.c',
'backends/native/meta-kms-device.h',
'backends/native/meta-kms-impl-device.c',
'backends/native/meta-kms-impl-device.h',
'backends/native/meta-kms-impl-simple.c',
'backends/native/meta-kms-impl-simple.h',
'backends/native/meta-kms-impl.c',
'backends/native/meta-kms-impl.h',
'backends/native/meta-kms-private.h',
'backends/native/meta-kms-types.h',
'backends/native/meta-kms.c',
'backends/native/meta-kms.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'backends/native/meta-renderer-native-gles3.c',
'backends/native/meta-renderer-native-gles3.h',
'backends/native/meta-renderer-native.h',
'backends/native/meta-stage-native.c',
'backends/native/meta-stage-native.h',
backends/native: Add udev abstraction layer To be used to signal devices added, hotplugs and other udev events. Currently the only event emitted is when a device is added. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-01-10 05:30:02 -05:00
'backends/native/meta-udev.c',
'backends/native/meta-udev.h',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
]
endif
if have_wayland_eglstream
mutter_sources += [
'wayland/meta-wayland-egl-stream.c',
'wayland/meta-wayland-egl-stream.h',
]
endif
mutter_built_sources = []
dbus_display_config_built_sources = gnome.gdbus_codegen('meta-dbus-display-config',
'org.gnome.Mutter.DisplayConfig.xml',
interface_prefix: 'org.gnome.Mutter.',
namespace: 'MetaDBus',
)
mutter_built_sources += dbus_display_config_built_sources
dbus_idle_monitor_built_sources = gnome.gdbus_codegen('meta-dbus-idle-monitor',
'org.gnome.Mutter.IdleMonitor.xml',
interface_prefix: 'org.gnome.Mutter.',
namespace: 'MetaDBus',
object_manager: true,
)
mutter_built_sources += dbus_idle_monitor_built_sources
profile: Add a Sysprof-based profiler This exposes the /org/gnome/Sysprof3/Profiler object inside Mutter to allow initiating a Sysprof capture. https://gitlab.gnome.org/GNOME/mutter/merge_requests/197
2018-08-10 16:42:12 -04:00
if have_profiler
mutter_sources += [
'backends/meta-profiler.c',
'backends/meta-profiler.h',
]
dbus_interfaces_dir = join_paths(datadir, 'dbus-1', 'interfaces')
sysprof3_dbus_file = join_paths(dbus_interfaces_dir, 'org.gnome.Sysprof3.Profiler.xml')
dbus_sysprof3_profiler_built_sources = gnome.gdbus_codegen('meta-dbus-sysprof3-profiler',
sysprof3_dbus_file,
interface_prefix: 'org.gnome.',
namespace: 'MetaDBus',
)
mutter_built_sources += dbus_sysprof3_profiler_built_sources
endif
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
if have_native_backend
build: check for cvt only when building the native backend Also error out properly when cvt is not found on Autotools.
2018-11-10 03:25:57 -05:00
cvt = find_program('cvt')
gen_default_modes = find_program('backends/native/gen-default-modes.py')
default_modes_h = custom_target('meta-default-modes',
output: 'meta-default-modes.h',
command: [gen_default_modes, '@OUTPUT@']
)
mutter_built_sources += default_modes_h
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
gdbus_codegen = find_program('gdbus-codegen')
dbus_login1_built_sources = custom_target('meta-dbus-login1',
input: 'org.freedesktop.login1.xml',
output: [
'meta-dbus-login1.c',
'meta-dbus-login1.h',
],
command: [
gdbus_codegen,
'--interface-prefix', 'org.freedesktop.login1',
'--c-namespace', 'Login1',
'--generate-c-code', 'meta-dbus-login1',
meson: Define srcdir and builddir using meson functions No need to redefine paths starting from top src/build dirs, as meson can give us this information for free using its functions. https://gitlab.gnome.org/GNOME/mutter/merge_requests/442
2019-04-04 22:35:44 -04:00
'--output-directory', meson.current_build_dir(),
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
'--c-generate-autocleanup', 'all',
'@INPUT@',
]
)
mutter_built_sources += dbus_login1_built_sources
endif
if have_remote_desktop
dbus_remote_desktop_built_sources = gnome.gdbus_codegen('meta-dbus-remote-desktop',
'org.gnome.Mutter.RemoteDesktop.xml',
interface_prefix: 'org.gnome.Mutter.',
namespace: 'MetaDBus',
)
mutter_built_sources += dbus_remote_desktop_built_sources
dbus_screen_cast_built_sources = gnome.gdbus_codegen('meta-dbus-screen-cast',
'org.gnome.Mutter.ScreenCast.xml',
interface_prefix: 'org.gnome.Mutter.',
namespace: 'MetaDBus',
)
mutter_built_sources += dbus_screen_cast_built_sources
endif
if have_wayland
# Format:
# - protocol name
# - protocol stability ('private', 'stable' or 'unstable')
# - protocol version (if stability is 'unstable')
wayland_protocols = [
['gtk-primary-selection', 'private', ],
['gtk-shell', 'private', ],
['gtk-text-input', 'private', ],
['keyboard-shortcuts-inhibit', 'unstable', 'v1', ],
['linux-dmabuf', 'unstable', 'v1', ],
['pointer-constraints', 'unstable', 'v1', ],
['pointer-gestures', 'unstable', 'v1', ],
['relative-pointer', 'unstable', 'v1', ],
['tablet', 'unstable', 'v2', ],
['text-input', 'unstable', 'v3', ],
wayland/surface: Add support for wp_viewporter This adds the required bits to wayland surfaces and ties them up to the compositor parts. It is based on and very similar in nature to buffer transforms. From the specification: > The global interface exposing surface cropping and scaling > capabilities is used to instantiate an interface extension for a > wl_surface object. This extended interface will then allow cropping > and scaling the surface contents, effectively disconnecting the > direct relationship between the buffer and the surface size. https://gitlab.gnome.org/GNOME/mutter/merge_requests/323
2018-11-24 14:25:38 -05:00
['viewporter', 'stable', ],
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
['xdg-foreign', 'unstable', 'v1', ],
['xdg-output', 'unstable', 'v1', ],
['xdg-shell', 'unstable', 'v6', ],
['xdg-shell', 'stable', ],
['xwayland-keyboard-grab', 'unstable', 'v1', ],
]
if have_wayland_eglstream
wayland_eglstream_protocols_dir = wayland_eglstream_protocols_dep.get_pkgconfig_variable('pkgdatadir')
wayland_protocols += [
['wayland-eglstream-controller', 'third-party', wayland_eglstream_protocols_dir],
]
endif
wayland_scanner = find_program('wayland-scanner')
protocols_dir = wayland_protocols_dep.get_pkgconfig_variable('pkgdatadir')
assert(protocols_dir != '', 'Could not get pkgdatadir from wayland-protocols.pc')
foreach p: wayland_protocols
protocol_name = p.get(0)
protocol_type = p.get(1)
if protocol_type == 'stable'
output_base = protocol_name
input = join_paths(protocols_dir,
'@0@/@1@/@2@.xml'.format(protocol_type,
protocol_name,
output_base))
elif protocol_type == 'private'
output_base = protocol_name
input = 'wayland/protocol/@0@.xml'.format(protocol_name)
elif protocol_type == 'third-party'
output_base = protocol_name
protocol_dir = p.get(2)
input = join_paths(protocol_dir, '@0@.xml'.format(protocol_name))
else
protocol_version = p.get(2)
output_base = '@0@-@1@-@2@'.format(protocol_name,
protocol_type,
protocol_version)
input = join_paths(protocols_dir,
'@0@/@1@/@2@.xml'.format(protocol_type,
protocol_name,
output_base))
endif
mutter_built_sources += custom_target('@0@ server header'.format(output_base),
input: input,
output: '@0@-server-protocol.h'.format(output_base),
command: [
wayland_scanner,
'server-header',
'@INPUT@', '@OUTPUT@',
]
)
mutter_built_sources += custom_target('@0@ source'.format(output_base),
input: input,
output: '@0@-protocol.c'.format(output_base),
command: [
wayland_scanner,
'private-code',
'@INPUT@', '@OUTPUT@',
]
)
endforeach
endif
subdir('meta')
renderer-native: Add hardware presentation timing Add support for getting hardware presentation times from KMS (Wayland sessions). Also implement cogl_get_clock_time which is required to compare and judge the age of presentation timestamps. For single monitor systems this is straightforward. For multi-monitor systems though we have to choose a display to sync to. The compositor already partially solves this for us in the case of only one display updating because it will only use the subset of monitors that are changing. In the case of multiple monitors consuming the same frame concurrently however, we choose the fastest one (in use at the time). Note however that we also need !73 to land in order to fully realize multiple monitors running at full speed.
2018-06-27 05:19:27 -04:00
mutter_marshal = gnome.genmarshal('meta-marshal',
sources: ['meta-marshal.list'],
prefix: 'meta_marshal',
build: Pass --quiet to glib-genmarshal We don't need to know it read the input file really.
2019-01-13 05:53:09 -05:00
extra_args: ['--quiet'],
renderer-native: Add hardware presentation timing Add support for getting hardware presentation times from KMS (Wayland sessions). Also implement cogl_get_clock_time which is required to compare and judge the age of presentation timestamps. For single monitor systems this is straightforward. For multi-monitor systems though we have to choose a display to sync to. The compositor already partially solves this for us in the case of only one display updating because it will only use the subset of monitors that are changing. In the case of multiple monitors consuming the same frame concurrently however, we choose the fastest one (in use at the time). Note however that we also need !73 to land in order to fully realize multiple monitors running at full speed.
2018-06-27 05:19:27 -04:00
internal: true,
)
mutter_built_sources += mutter_marshal
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
mutter_built_sources += mutter_enum_types
mutter_built_sources += mutter_version
libmutter = shared_library(libmutter_name,
sources: [
mutter_sources,
mutter_built_sources,
],
meson: Set proper soversion and version to libraries Soname of the libraries should be the major version number, while the version triplet is currently used: objdump -p libmutter-4.so.0.0.0 | grep SONAME SONAME libmutter-4.so.0.0.0 While is expected to be only libmutter-4.so.0 Fix all shared libraries by setting valid version and soversion. https://gitlab.gnome.org/GNOME/mutter/merge_requests/3955
2019-01-17 17:21:37 -05:00
version: '0.0.0',
soversion: 0,
meta: Hide libmutter symbols by default and selectively export them Make meson link libmutter using -fvisibility=hidden, and introduce META_EXPORT and META_EXPORT_TEST defines to mark a symbols as visible. The TEST version is meant to be used to flag symbols that are only used internally by mutter tests, but that should not be considered public API. This allows us to be more precise in selecting what is exported and what is not, without the need of a version-script file that would be more complicated to maintain. https://gitlab.gnome.org/GNOME/mutter/merge_requests/395
2019-01-22 21:25:35 -05:00
gnu_symbol_visibility: 'hidden',
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
include_directories: mutter_includes,
c_args: mutter_c_args,
dependencies: [
libmutter_cogl_dep,
libmutter_clutter_dep,
mutter_deps,
],
install_rpath: pkglibdir,
install_dir: libdir,
install: true,
)
libmutter_dep = declare_dependency(
link_with: libmutter,
include_directories: mutter_includes,
meson: Add mutter_built_sources to libmutter declared dependency If meson tries to get ahead and generate object files for tests at the same time than building libmutter, those may randomly fail if meson did not create the libmutter generated headers yet. Add those to the declared dependency, so the files are ensured to be created before anything gets to use it. Closes: https://gitlab.gnome.org/GNOME/mutter/issues/404
2018-11-27 10:28:16 -05:00
sources: mutter_built_sources,
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
dependencies: [
libmutter_cogl_dep,
libmutter_clutter_dep,
mutter_deps,
],
)
executable('mutter',
sources: [
files('core/mutter.c'),
],
include_directories: mutter_includes,
c_args: mutter_c_args,
dependencies: [libmutter_dep],
install_dir: bindir,
install: true,
)
build: Also build mutter-restart-helper executable Was left out by mistake. Lets add it.
2018-11-07 06:28:57 -05:00
executable('mutter-restart-helper',
sources: [
files('core/restart-helper.c'),
],
include_directories: [
top_includepath,
],
c_args: mutter_c_args,
dependencies: [
x11_dep,
xcomposite_dep,
],
install_dir: libexecdir,
install: true,
)
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
if have_introspection
mutter_introspected_sources = []
foreach source : mutter_sources
if source.endswith('.c')
mutter_introspected_sources += source
endif
endforeach
libmutter_gir = gnome.generate_gir(libmutter,
sources: [
mutter_version,
mutter_enum_types[1],
mutter_introspected_sources,
mutter_public_header_files
],
nsversion: libmutter_api_version,
namespace: 'Meta',
symbol_prefix: 'meta',
includes: [
'GObject-2.0',
'GDesktopEnums-3.0',
'Gdk-3.0',
'Gtk-3.0',
'xlib-2.0',
'xfixes-4.0',
libmutter_cogl_gir[0],
libmutter_cogl_pango_gir[0],
libmutter_clutter_gir[0],
],
build: Prefer dependencies instead of link_with Meson uses the 'dependencies' field to determine and parallelize build steps, but that isn't entirely true with 'link_with'; this might cause a race condition when generating header files while trying to build them. Fix that by only using 'dependencies' instead of 'link_with'.
2018-11-06 14:50:24 -05:00
dependencies: [
mutter_deps,
libmutter_dep,
],
build: Always pass --quiet to g-ir-scanner This makes the build less verbose, as all .gir generation except for clutters didn't pass --quiet to g-ir-scanner, making it output long linking commands. Do this by adding a common introspection_args variable. While at it, put -U_GNU_SOURCE in there too, as it was always passed everywhere as without it the scanner would log warnings.
2018-12-22 05:28:46 -05:00
extra_args: mutter_c_args + introspection_args,
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
install_dir_gir: pkglibdir,
install_dir_typelib: pkglibdir,
install: true
)
endif
build: Pass library as first argument to pkg.generate() Dependencies are added automatically, and we no longer get warnings like: clutter/clutter/meson.build:628: DEPRECATION: Library mutter-clutter-4 was passed to the "libraries" keyword argument of a previous call to generate() method instead of first positional argument. Adding mutter-clutter-4 to "Requires" field, but this is a deprecated behaviour that will change in a future version of Meson. Please report the issue if this warning cannot be avoided in your case.
2019-01-08 03:05:08 -05:00
pkg.generate(libmutter,
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
name: 'Meta',
filebase: 'libmutter-' + libmutter_api_version,
description: 'Mutter compositor and window manager library',
subdirs: pkgname,
requires: [mutter_pkg_deps, libmutter_clutter_name],
version: meson.project_version(),
variables: [
'apiversion=' + libmutter_api_version,
'girdir=${libdir}/mutter-' + libmutter_api_version,
'typelibdir=${libdir}/mutter-' + libmutter_api_version,
],
build: Install .pc files in correct location If a library is provided in the positional arguments, then meson defaults to installing the .pc file in a 'pkgconfig' subdirectory in the library's install location. We want the files in the regular $libdir/pkgconfig rather than $libdir/mutter-$api/pkgconfig, so specify the location explicitly in the parameters. https://gitlab.gnome.org/GNOME/mutter/merge_requests/382
2019-01-08 16:28:18 -05:00
install_dir: pcdir,
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
)
subdir('compositor/plugins')
meson: Add option flags to control test suites building Now the `tests` meson option controls weather we should build all the test suites while `core_tests` controls mutter tests. https://gitlab.gnome.org/GNOME/mutter/merge_requests/442
2019-02-13 12:51:21 -05:00
if have_core_tests
Add meson build support This commit adds meson build support to mutter. It takes a step away from the three separate code bases with three different autotools setups into a single meson build system. There are still places that can be unified better, for example by removing various "config.h" style files from cogl and clutter, centralizing debug C flags and other configurable macros, and similar artifacts that are there only because they were once separate code bases. There are some differences between the autotools setup and the new meson. Here are a few: The meson setup doesn't generate wrapper scripts for various cogl and clutter test cases. What these tests did was more or less generate a tiny script that called an executable with a test name as the argument. To run particular tests, just run the test executable with the name of the test as the argument. The meson setup doesn't install test files anymore. The autotools test suite was designed towards working with installed tests, but it didn't really still, and now with meson, it doesn't install anything at all, but instead makes sure that everything runs with the uninstalled input files, binaries and libraries when running the test suite. Installable tests may come later. Tests from cogl, clutter and mutter are run on 'meson test'. In autotools, only cogl and clutter tests were run on 'make check'.
2018-05-22 09:55:35 -04:00
subdir('tests')
endif
Reference in New Issue Copy Permalink