brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
bad1a7fd0c
mutter/src/meson.build

1032 lines
31 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-12 00:35:13 +00: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 13:55:35 +00: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 11:13:48 +00: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 13:55:35 +00: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 14:59:57 +00: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 11:13:48 +00: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 13:55:35 +00: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 11:13:48 +00: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 13:55:35 +00: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 11:13:48 +00: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 13:55:35 +00: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 11:13:48 +00: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 13:55:35 +00: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 11:13:48 +00: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 13:55:35 +00: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 11:13:48 +00: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 13:55:35 +00: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 11:13:48 +00: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 13:55:35 +00: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 11:13:48 +00: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 13:55:35 +00: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 11:13:48 +00: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 13:55:35 +00: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 14:12:46 +00:00
xau_dep,
clutter: Move X11 input to src/backends/x11 The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendX11, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-22 12:53:00 +00:00
xtst_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 13:55:35 +00: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 11:13:48 +00: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 13:55:35 +00: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 11:13:48 +00: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 13:55:35 +00:00
libdrm_dep,
libinput_dep,
gudev_dep,
libgbm_dep,
logind_provider_dep,
clutter: Move evdev input to src/backends/native The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendNative, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-29 21:03:27 +00:00
libudev_dep,
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 13:55:35 +00:00
]
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 11:13:48 +00: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 13:55:35 +00: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 11:13:48 +00: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 13:55:35 +00: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',
crtc: Move out MetaCrtcMode into its own file It's somewhat annoying to have two very closely named types in the same file. It's also about to grow some, so better move it to its own file. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1287
2020-02-26 20:46:58 +00:00
'backends/meta-crtc-mode.c',
'backends/meta-crtc-mode.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 13:55:35 +00:00
'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 MetaInputDevice derivable class This class sits between ClutterInputDevice and the backend implementations, it will be the despositary of features we need across both backends, but don't need to offer through Clutter's API. As a first thing to have there, add a getter for a WacomDevice. This is something scattered across and somewhat inconsistent (eg. different places of the code create wacom devices for different device types). Just make it here for all devices, so users can pick. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1109
2020-03-06 13:12:59 +00:00
'backends/meta-input-device.c',
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 14:34:32 +00: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 13:55:35 +00:00
'backends/meta-input-settings.c',
'backends/meta-input-settings-private.h',
compositor: use XDG_CONFIG_HOME as initial lookup path for xkb Using XDG_CONFIG_HOME allows users to place their keyboard configuration into their home directory and have them loaded automatically. libxkbcommon now defaults to XDG_CONFIG_HOME/xkb/ first, see https://github.com/xkbcommon/libxkbcommon/pull/117 However - libxkbcommon uses secure_getenv() to obtain XDG_CONFIG_HOME and thus fails to load this for the mutter context which has cap_sys_nice. We need to manually add that search path as lookup path. As we can only append paths to libxkbcommon's context, we need to start with an empty search path set, add our custom path, then append the default search paths. The net effect is nil where a user doesn't have XDG_CONFIG_HOME/xkb/. https://gitlab.gnome.org/GNOME/mutter/merge_requests/936
2019-11-14 02:59:25 +00:00
'backends/meta-keymap-utils.c',
'backends/meta-keymap-utils.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 13:55:35 +00:00
'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 13:18:02 +00: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 13:15:23 +00: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 13:55:35 +00: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 07:48:41 +00: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 13:55:35 +00: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',
clutter: Move X11 input to src/backends/x11 The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendX11, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-22 12:53:00 +00:00
'backends/x11/meta-event-x11.c',
'backends/x11/meta-event-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 13:55:35 +00:00
'backends/x11/meta-gpu-xrandr.c',
'backends/x11/meta-gpu-xrandr.h',
clutter: Move X11 input to src/backends/x11 The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendX11, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-22 12:53:00 +00:00
'backends/x11/meta-input-device-x11.c',
'backends/x11/meta-input-device-x11.h',
'backends/x11/meta-input-device-tool-x11.c',
'backends/x11/meta-input-device-tool-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 13:55:35 +00:00
'backends/x11/meta-input-settings-x11.c',
'backends/x11/meta-input-settings-x11.h',
x11: Implement ClutterSeat The ClutterDeviceManager signaling becomes implemented on top of this. https://gitlab.gnome.org/GNOME/mutter/merge_requests/852
2019-09-24 09:24:48 +00:00
'backends/x11/meta-seat-x11.c',
'backends/x11/meta-seat-x11.h',
clutter: Move X11 input to src/backends/x11 The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendX11, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-22 12:53:00 +00:00
'backends/x11/meta-keymap-x11.c',
'backends/x11/meta-keymap-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 13:55:35 +00:00
'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',
clutter: Move X11 input to src/backends/x11 The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendX11, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-22 12:53:00 +00:00
'backends/x11/meta-stage-x11.c',
'backends/x11/meta-stage-x11.h',
'backends/x11/meta-virtual-input-device-x11.c',
'backends/x11/meta-virtual-input-device-x11.h',
'backends/x11/meta-xkb-a11y-x11.c',
'backends/x11/meta-xkb-a11y-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 13:55:35 +00:00
'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: Move nested stage to src/backends/x11/nested We now have a MetaStageX11, so it's extra confusing to have both in the same directory. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-29 20:18:07 +00:00
'backends/x11/nested/meta-stage-x11-nested.c',
'backends/x11/nested/meta-stage-x11-nested.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 13:55:35 +00:00
'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',
Introduce MetaBackgroundContent MetaBackgroundContent is a ClutterContent implementation that can render a background to any attached actor. Right now, it preserves all the properties and the rendering model of MetaBackgroundActor. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1302
2020-06-09 00:49:55 +00:00
'compositor/meta-background-content.c',
'compositor/meta-background-content-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 13:55:35 +00:00
'compositor/meta-background.c',
'compositor/meta-background-group.c',
'compositor/meta-background-image.c',
'compositor/meta-background-private.h',
compositor: Add support for direct scanout of Wayland surfaces Try to bypass compositing if there is a fullscreen toplevel window with a buffer compatible with the primary plane of the monitor it is fullscreen on. Only non-mirrored is currently supported; as well as fullscreened on a single monitor. It should be possible to extend with more cases, but this starts small. It does this by introducing a new MetaCompositor sub type MetaCompositorNative specific to the native backend, which derives from MetaCompositorServer, containing functionality only relevant for when running on top of the native backend. https://gitlab.gnome.org/GNOME/mutter/merge_requests/798
2019-09-12 20:07:20 +00:00
'compositor/meta-compositor-server.c',
'compositor/meta-compositor-server.h',
compositor: Move out X11 compositing code into sub type Introduce MetaCompositorX11, dealing with being a X11 compositor, and MetaCompositorServer, being a compositor while also being the display server itself, e.g. a Wayland display server. https://gitlab.gnome.org/GNOME/mutter/merge_requests/727
2019-08-14 21:25:54 +00:00
'compositor/meta-compositor-x11.c',
'compositor/meta-compositor-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 13:55:35 +00:00
'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',
util: Move MetaLater to its own file While at it, fix some style inconsistencies, for now use a single singleton struct instead of multiple static variables, and other non-functional cleanups. Semantically, there is no changes introduced. https://gitlab.gnome.org/GNOME/mutter/merge_requests/798
2020-03-03 07:46:11 +00:00
'compositor/meta-later.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 13:55:35 +00:00
'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 20:35:18 +00:00
'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 13:55:35 +00: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/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',
Add read-only anonymous file abstraction MetaAnonymousFile Add MetaAnonymousFile, an abstraction around anonymous read-only files. Files can be created by calling meta_anonymous_file_new(), passing the data of the file. Subsequent calls to meta_anonymous_file_open_fd() return a fd that's ready to be sent over the socket. When mapmode is META_ANONYMOUS_FILE_MAPMODE_PRIVATE the fd is only guaranteed to be mmap-able readonly with MAP_PRIVATE but does not require duplicating the file for each resource when memfd_create is available. META_ANONYMOUS_FILE_MAPMODE_SHARED may be used when the client must be able to map the file with MAP_SHARED but it also means that the file has to be duplicated even when memfd_create is available. Pretty much all of this code was written for weston by Sebastian Wick, see https://gitlab.freedesktop.org/wayland/weston/merge_requests/240. Co-authored-by: Sebastian Wick <sebastian@sebastianwick.net> https://gitlab.gnome.org/GNOME/mutter/merge_requests/1012
2020-01-17 22:43:24 +00:00
'core/meta-anonymous-file.c',
'core/meta-anonymous-file.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 13:55:35 +00:00
'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 18:57:15 +00: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 13:55:35 +00: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 18:02:19 +00: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 15:45:20 +00: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 18:50:21 +00: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 11:44:20 +00: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 13:55:35 +00: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 16:16:37 +00: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 18:57:04 +00: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 13:55:35 +00: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 17:17:25 +00: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 09:49:36 +00: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 10:59:50 +00:00
'x11/meta-x11-stack.c',
'x11/meta-x11-stack-private.h',
core/core: Rename and move to x11/meta-x11-window-control The functionality core/core.c and core/core.h provides are helpers for the window decorations. This was not possible to derive from the name itself, thus rename it and put it in the right place. https://gitlab.gnome.org/GNOME/mutter/merge_requests/854
2019-10-13 14:47:47 +00:00
'x11/meta-x11-window-control.c',
'x11/meta-x11-window-control.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 13:55:35 +00: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',
screen-cast: Add RecordArea for screen cast arbitrary area It takes coordinates in stage coordinate space, and will result in a screen cast stream consisting of that area, but scaled up by the scale factor of the view that overlaps with the area and has the highest scale factor. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1207
2020-03-04 20:42:52 +00:00
'backends/meta-screen-cast-area-stream.c',
'backends/meta-screen-cast-area-stream.h',
'backends/meta-screen-cast-area-stream-src.c',
'backends/meta-screen-cast-area-stream-src.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 13:55:35 +00:00
'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 13:35:14 +00: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 13:55:35 +00: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',
build: Fix build when wayland is disabled https://gitlab.gnome.org/GNOME/mutter/merge_requests/817
2019-09-28 08:26:21 +00:00
'compositor/meta-window-actor-wayland.c',
'compositor/meta-window-actor-wayland.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 13:55:35 +00:00
'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 16:34:18 +00: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 13:55:35 +00: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: Add support for wayland-protocols primary selection protocol This protocol was added some time ago. Supporting it fell through the cracks. Add new data device/source/offer implementations for it, interoperation between primary selection protocols (and X11 primary selection for that matter) comes for free. Closes: https://gitlab.gnome.org/GNOME/mutter/-/issues/943 https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1255
2020-05-13 16:07:27 +00:00
'wayland/meta-wayland-data-device-primary.c',
'wayland/meta-wayland-data-device-primary.h',
wayland: Rename gtk primary protocol files to "legacy" We want to make room for the wayland-protocols primary selection protocol. Rename our private protocol as "legacy". https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1255
2020-05-13 16:04:04 +00:00
'wayland/meta-wayland-data-device-primary-legacy.c',
'wayland/meta-wayland-data-device-primary-legacy.h',
wayland: Move MetaWaylandDataOffer to its own file This is still an openly defined struct, as we will need accessed by "subclasses". Same principle applies than with the MetaWaylandDataSource refactor, this is not meant to introduce functional changes, so just go with it. On the bright side, the interactions are now clearer, so it could be made saner in the future. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1193
2020-04-09 14:22:21 +00:00
'wayland/meta-wayland-data-offer.c',
'wayland/meta-wayland-data-offer.h',
wayland: Add support for wayland-protocols primary selection protocol This protocol was added some time ago. Supporting it fell through the cracks. Add new data device/source/offer implementations for it, interoperation between primary selection protocols (and X11 primary selection for that matter) comes for free. Closes: https://gitlab.gnome.org/GNOME/mutter/-/issues/943 https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1255
2020-05-13 16:07:27 +00:00
'wayland/meta-wayland-data-offer-primary.c',
'wayland/meta-wayland-data-offer-primary.h',
wayland: Rename gtk primary protocol files to "legacy" We want to make room for the wayland-protocols primary selection protocol. Rename our private protocol as "legacy". https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1255
2020-05-13 16:04:04 +00:00
'wayland/meta-wayland-data-offer-primary-legacy.c',
'wayland/meta-wayland-data-offer-primary-legacy.h',
wayland: Split MetaWaylandDataSource into a separate file The split wasn't 100% clean, and some extra private API had to be added for it (but well, looking at the API, it's already evident there's a cleanup/streamlining task due). This is meant to be a refactor with no functional changes, so just go with it. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1193
2020-04-09 12:05:51 +00:00
'wayland/meta-wayland-data-source.c',
'wayland/meta-wayland-data-source.h',
wayland: Add support for wayland-protocols primary selection protocol This protocol was added some time ago. Supporting it fell through the cracks. Add new data device/source/offer implementations for it, interoperation between primary selection protocols (and X11 primary selection for that matter) comes for free. Closes: https://gitlab.gnome.org/GNOME/mutter/-/issues/943 https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1255
2020-05-13 16:07:27 +00:00
'wayland/meta-wayland-data-source-primary.c',
'wayland/meta-wayland-data-source-primary.h',
wayland: Rename gtk primary protocol files to "legacy" We want to make room for the wayland-protocols primary selection protocol. Rename our private protocol as "legacy". https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1255
2020-05-13 16:04:04 +00:00
'wayland/meta-wayland-data-source-primary-legacy.c',
'wayland/meta-wayland-data-source-primary-legacy.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 13:55:35 +00:00
'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 16:34:50 +00: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 13:55:35 +00: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 19:25:38 +00:00
'wayland/meta-wayland-viewporter.c',
'wayland/meta-wayland-viewporter.h',
wayland: Rework asynchronous window configuration This changes how asynchronous window configuration works. Prior to this commit, it worked by MetaWindowWayland remembering the last configuration it sent, then when the Wayland client got back to it, it tried to figure out whether it was a acknowledgment of the configuration or not, and finish the move. This failed if the client had acknowledged a configuration older than the last one sent, and it had hacks to somewhat deal with wl_shell's lack of configuration serial numbers. This commits scraps that and makes the MetaWindowWayland take ownership of sent configurations, including generating serial numbers. The wl_shell implementation is changed to emulate serial numbers (assuming each commit acknowledges the last sent configure event). Each configuration sent to the client is kept around until the client one. At this point, the position used for that particular configuration is used when applying the acknowledged state, meaning cases where we have already sent a new configuration when the client acknowledges a previous one, we'll still use the correct position for the window. https://gitlab.gnome.org/GNOME/mutter/merge_requests/907
2019-07-05 16:10:14 +00:00
'wayland/meta-wayland-window-configuration.c',
'wayland/meta-wayland-window-configuration.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 13:55:35 +00: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-22 00:33:13 +00:00
'wayland/meta-xwayland-dnd.c',
'wayland/meta-xwayland-dnd-private.h',
xwayland: Move out surface role related logic Does some needed naming cleanup while at it, to be more similar to other role types. In short, MetaWaylandSurfaceRoleXwayland was changed to MetaXwaylandSurface. https://gitlab.gnome.org/GNOME/mutter/merge_requests/835
2019-10-07 19:21:48 +00:00
'wayland/meta-xwayland-surface.c',
'wayland/meta-xwayland-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 13:55:35 +00: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 17:07:12 +00: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 13:55:35 +00: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 20:08:35 +00: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',
renderer/native: Import primary buffer to 2nd GPU Where possible, try to export the buffer rendered by the primary GPU as a dmabuf and import it to the secondary GPU and turn it into a DRM FB for scanout. If this works, we get a zero-copy path to secondary GPU outputs. This is especially useful on virtual drivers like EVDI (used for DisplayLink devices) which are not picky at all about what kind of FBs they can handle. The zero-copy path is prioritised after the secondary GPU copy path, which should avoid regressions for existing working systems. Attempting zero-copy would have the risk of being less performant than doing the copy on the secondary GPU. This does not affect the DisplayLink use case, because there is no GPU in a DisplayLink device. The zero-copy path is prioritised before the primary GPU and CPU copy paths. It will be tried on the first frame of an output and the copy path is executed too. If zero-copy fails, the result from the copy path will take over on that frame. Furthermore, zero-copy will not be attemped again on that output. If zero-copy succeeds, the copy path is de-initialized. Zero-copy is assumed to be always preferable over the primary GPU and CPU copy paths. Whether this is universally true remains to be seen. This patch has one unhandled failure mode: if zero-copy path first succeeds and then fails later, there is no fallback and the output is left frozen or black. https://gitlab.gnome.org/GNOME/mutter/merge_requests/810
2019-05-24 14:07:14 +00:00
'backends/native/meta-drm-buffer-import.c',
'backends/native/meta-drm-buffer-import.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 19:20:17 +00:00
'backends/native/meta-drm-buffer.c',
'backends/native/meta-drm-buffer.h',
clutter: Move evdev input to src/backends/native The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendNative, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-29 21:03:27 +00:00
'backends/native/meta-event-native.c',
'backends/native/meta-event-native.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 13:55:35 +00:00
'backends/native/meta-gpu-kms.c',
'backends/native/meta-gpu-kms.h',
clutter: Move evdev input to src/backends/native The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendNative, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-29 21:03:27 +00:00
'backends/native/meta-input-device-native.c',
'backends/native/meta-input-device-native.h',
'backends/native/meta-input-device-tool-native.c',
'backends/native/meta-input-device-tool-native.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 13:55:35 +00:00
'backends/native/meta-input-settings-native.c',
'backends/native/meta-input-settings-native.h',
clutter: Move evdev input to src/backends/native The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendNative, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-29 21:03:27 +00:00
'backends/native/meta-keymap-native.c',
'backends/native/meta-keymap-native.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 13:55:35 +00:00
'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 connector representation Represents drmModeConnector; both connected and disconnected. Currently only provides non-changing meta data. MetaOutputKms is changed to use MetaKmsConnector to get basic metadata, but variable metadata, those changing depending on what is connected (e.g. physical dimension, EDID, etc), are still manually retrieved by MetaOutputKms. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-03-08 15:23:15 +00:00
'backends/native/meta-kms-connector-private.h',
'backends/native/meta-kms-connector.c',
'backends/native/meta-kms-connector.h',
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 17:33:00 +00:00
'backends/native/meta-kms-crtc-private.h',
'backends/native/meta-kms-crtc.c',
'backends/native/meta-kms-crtc.h',
crtc/kms: Outsource CRTC state fetching to MetaKmsCrtc Move reading state into a struct for MetaCrtcKms to use instead of querying KMS itself. The state is fetched in the impl context, but consists of only simple data types, so is made accessible publicly. As of this, MetaCrtcKms construction does not involve any manual KMS interaction outside of the MetaKms abstraction. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-03-08 18:19:18 +00:00
'backends/native/meta-kms-device-private.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 09:24:44 +00: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',
backend/native: Add and use transactional KMS API This commit introduces, and makes use of, a transactional API used for setting up KMS state, later to be applied, potentially atomically. From an API point of view, so is always the case, but in the current implementation, it still uses legacy drmMode* API to apply the state non-atomically. The API consists of various buliding blocks: * MetaKmsUpdate - a set of configuration changes, the higher level handle for handing over configuration to the impl backend. It's used to set mode, assign framebuffers to planes, queue page flips and set connector properties. * MetaKmsPlaneAssignment - the assignment of a framebuffer to a plane. Currently used to map a framebuffer to the primary plane of a CRTC. In the legacy KMS implementation, the plane assignment is used to derive the framebuffer used for mode setting and page flipping. This also means various high level changes: State, excluding configuring the cursor plane and creating/destroying DRM framebuffer handles, are applied in the end of a clutter frame, in one go. From an API point of view, this is done atomically, but as mentioned, only the non-atomic implementation exists so far. From MetaRendererNative's point of view, a page flip now initially always succeeds; the handling of EBUSY errors are done asynchronously in the MetaKmsImpl backend (still by retrying at refresh rate, but postponing flip callbacks instead of manipulating the frame clock). Handling of falling back to mode setting instead of page flipping is notified after the fact by a more precise page flip feedback API. EGLStream based page flipping relies on the impl backend not being atomic, as the page flipping is done in the EGLStream backend (e.g. nvidia driver). It uses a 'custom' page flip queueing method, keeping the EGLStream logic inside meta-renderer-native.c. Page flip handling is moved to meta-kms-impl-device.c from meta-gpu-kms.c. It goes via an extra idle callback before reaching meta-renderer-native.c to make sure callbacks are invoked outside of the impl context. While dummy power save page flipping is kept in meta-renderer-native.c, the EBUSY handling is moved to meta-kms-impl-simple.c. Instead of freezing the frame clock, actual page flip callbacks are postponed until all EBUSY retries have either succeeded or failed due to some other error than EBUSY. This effectively inhibits new frames to be drawn, meaning we won't stall waiting on the file descriptor for pending page flips. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-04-04 20:36:41 +00:00
'backends/native/meta-kms-page-flip.c',
'backends/native/meta-kms-page-flip-private.h',
kms: Add plane representation A plane is one of three possible: primary, overlay and cursor. Each plane can have various properties, such as possible rotations, formats etc. Each plane can also be used with a set of CRTCs. A primary plane is the "backdrop" of a CRTC, i.e. the primary output for the composited frame that covers the whole CRTC. In general, mutter composites to a stage view frame onto a framebuffer that is then put on the primary plane. An overlay plane is a rectangular area that can be displayed on top of the primary plane. Eventually it will be used to place non-fullscreen surfaces, potentially avoiding stage redraws. A cursor plane is a plane placed on top of all the other planes, usually used to put the mouse cursor sprite. Initially, we only fetch the rotation properties, and we so far blacklist all rotations except ones that ends up with the same dimensions as with no rotations. This is because non-180° rotations doesn't work yet due to incorrect buffer modifiers. To make it possible to use non-180° rotations, changes necessary include among other things finding compatible modifiers using atomic modesetting. Until then, simply blacklist the ones we know doesn't work. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-01-31 17:48:19 +00:00
'backends/native/meta-kms-plane.c',
kms/plane: Move _new() function to private header Code outside of the MetaKms namespace is not expected to create plane objects, so move it to a private header. More things will be added to this header later. https://gitlab.gnome.org/GNOME/mutter/merge_requests/930
2019-10-31 09:38:19 +00:00
'backends/native/meta-kms-plane-private.h',
kms: Add plane representation A plane is one of three possible: primary, overlay and cursor. Each plane can have various properties, such as possible rotations, formats etc. Each plane can also be used with a set of CRTCs. A primary plane is the "backdrop" of a CRTC, i.e. the primary output for the composited frame that covers the whole CRTC. In general, mutter composites to a stage view frame onto a framebuffer that is then put on the primary plane. An overlay plane is a rectangular area that can be displayed on top of the primary plane. Eventually it will be used to place non-fullscreen surfaces, potentially avoiding stage redraws. A cursor plane is a plane placed on top of all the other planes, usually used to put the mouse cursor sprite. Initially, we only fetch the rotation properties, and we so far blacklist all rotations except ones that ends up with the same dimensions as with no rotations. This is because non-180° rotations doesn't work yet due to incorrect buffer modifiers. To make it possible to use non-180° rotations, changes necessary include among other things finding compatible modifiers using atomic modesetting. Until then, simply blacklist the ones we know doesn't work. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-01-31 17:48:19 +00:00
'backends/native/meta-kms-plane.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 09:24:44 +00:00
'backends/native/meta-kms-private.h',
'backends/native/meta-kms-types.h',
backend/native: Add and use transactional KMS API This commit introduces, and makes use of, a transactional API used for setting up KMS state, later to be applied, potentially atomically. From an API point of view, so is always the case, but in the current implementation, it still uses legacy drmMode* API to apply the state non-atomically. The API consists of various buliding blocks: * MetaKmsUpdate - a set of configuration changes, the higher level handle for handing over configuration to the impl backend. It's used to set mode, assign framebuffers to planes, queue page flips and set connector properties. * MetaKmsPlaneAssignment - the assignment of a framebuffer to a plane. Currently used to map a framebuffer to the primary plane of a CRTC. In the legacy KMS implementation, the plane assignment is used to derive the framebuffer used for mode setting and page flipping. This also means various high level changes: State, excluding configuring the cursor plane and creating/destroying DRM framebuffer handles, are applied in the end of a clutter frame, in one go. From an API point of view, this is done atomically, but as mentioned, only the non-atomic implementation exists so far. From MetaRendererNative's point of view, a page flip now initially always succeeds; the handling of EBUSY errors are done asynchronously in the MetaKmsImpl backend (still by retrying at refresh rate, but postponing flip callbacks instead of manipulating the frame clock). Handling of falling back to mode setting instead of page flipping is notified after the fact by a more precise page flip feedback API. EGLStream based page flipping relies on the impl backend not being atomic, as the page flipping is done in the EGLStream backend (e.g. nvidia driver). It uses a 'custom' page flip queueing method, keeping the EGLStream logic inside meta-renderer-native.c. Page flip handling is moved to meta-kms-impl-device.c from meta-gpu-kms.c. It goes via an extra idle callback before reaching meta-renderer-native.c to make sure callbacks are invoked outside of the impl context. While dummy power save page flipping is kept in meta-renderer-native.c, the EBUSY handling is moved to meta-kms-impl-simple.c. Instead of freezing the frame clock, actual page flip callbacks are postponed until all EBUSY retries have either succeeded or failed due to some other error than EBUSY. This effectively inhibits new frames to be drawn, meaning we won't stall waiting on the file descriptor for pending page flips. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-04-04 20:36:41 +00:00
'backends/native/meta-kms-update-private.h',
'backends/native/meta-kms-update.c',
'backends/native/meta-kms-update.h',
backend/native: Move some KMS utilities to its own file They are not strictly related to any of the KMS objects, and should be reusable without adding a dependency on the non-meta-kms-* files in meta-kms-*. https://gitlab.gnome.org/GNOME/mutter/issues/548 https://gitlab.gnome.org/GNOME/mutter/merge_requests/525
2019-03-11 10:13:01 +00:00
'backends/native/meta-kms-utils.c',
'backends/native/meta-kms-utils.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 09:24:44 +00:00
'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 13:55:35 +00:00
'backends/native/meta-renderer-native-gles3.c',
'backends/native/meta-renderer-native-gles3.h',
'backends/native/meta-renderer-native.h',
clutter: Move evdev input to src/backends/native The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendNative, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-29 21:03:27 +00:00
'backends/native/meta-seat-native.c',
'backends/native/meta-seat-native.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 13:55:35 +00:00
'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 10:30:02 +00:00
'backends/native/meta-udev.c',
'backends/native/meta-udev.h',
clutter: Move evdev input to src/backends/native The end goal is to have all clutter backend code in src/backends. Input is the larger chunk of it, which is now part of our specific MutterClutterBackendNative, this extends to device manager, input devices, tools and keymap. This was supposed to be nice and incremental, but there's no sane way to cut this through. As a result of the refactor, a number of private Clutter functions are now exported for external backends to be possible. https://gitlab.gnome.org/GNOME/mutter/merge_requests/672
2019-03-29 21:03:27 +00:00
'backends/native/meta-virtual-input-device-native.c',
'backends/native/meta-virtual-input-device-native.h',
'backends/native/meta-xkb-utils.c',
'backends/native/meta-xkb-utils.h',
compositor: Add support for direct scanout of Wayland surfaces Try to bypass compositing if there is a fullscreen toplevel window with a buffer compatible with the primary plane of the monitor it is fullscreen on. Only non-mirrored is currently supported; as well as fullscreened on a single monitor. It should be possible to extend with more cases, but this starts small. It does this by introducing a new MetaCompositor sub type MetaCompositorNative specific to the native backend, which derives from MetaCompositorServer, containing functionality only relevant for when running on top of the native backend. https://gitlab.gnome.org/GNOME/mutter/merge_requests/798
2019-09-12 20:07:20 +00:00
'compositor/meta-compositor-native.c',
'compositor/meta-compositor-native.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 13:55:35 +00: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
cursor-tracker: Use our own marshal for cursor-moved By putting `NULL` as the C marshaller in `g_signal_new`, you automatically get `g_cclosure_marshaller_generic`, which will try to process its arguments and return value with the help of libffi and GValue. Using `glib-genmarshal` and valist_marshallers, we can prevent this so that we need less instructions for each signal emission. https://gitlab.gnome.org/GNOME/mutter/merge_requests/697
2019-07-24 05:42:07 +00:00
mutter_marshal = gnome.genmarshal('meta-marshal',
sources: ['meta-marshal.list'],
prefix: 'meta_marshal',
internal: true,
valist_marshallers: true,
)
mutter_built_sources += mutter_marshal
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 20:42:12 +00:00
if have_profiler
mutter_sources += [
'backends/meta-profiler.c',
'backends/meta-profiler.h',
]
build: ensure absolute path to sysprof dbus interface dir We want sysprof's exact datadir for compatability with platforms where software is installed into their own individual immutable prefix's. Such that, mutter's prefix will never equate to sysprof's. This depends on a MR in sysprof [0] which adds datadir to its pkgconfig files, as these files will always have the proper path we want. This adds version a constraint on sysprof_dep, as datadir was added to the .pc in this version. [0]: https://gitlab.gnome.org/GNOME/sysprof/merge_requests/19 https://gitlab.gnome.org/GNOME/mutter/merge_requests/957
2019-12-04 22:25:41 +00:00
sysprof_dbus_interfaces_dir = join_paths(sysprof_dep.get_pkgconfig_variable('datadir'), 'dbus-1', 'interfaces')
sysprof3_dbus_file = join_paths(sysprof_dbus_interfaces_dir, 'org.gnome.Sysprof3.Profiler.xml')
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 20:42:12 +00:00
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 13:55:35 +00: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 08:25:57 +00: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 13:55:35 +00: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-05 02:35:44 +00: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 13:55:35 +00: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
tests/wayland: Test subsurface commits after parent was reset Without 'wayland/surface-actor: Reset and sync subsurface state when resetting' this test would fail. This also adds a simple framework for testing lower level Wayland semantics. In contrast to the test-client and test-driver framework, which uses gtk and tests mostly window management related things, this framework is aimed to run Wayland clients made to test a particular protocol flow, thus will likely consist of manual lower level Wayland mechanics. A private protocol is added in order to help out clients do things they cannot do by themself. The protocol currently only consists of a request meant to be used for getting a callback when the actor of a given surface is eventually destroyed. This is different from the wl_surface being destroyed due to window destroy animations taking an arbitrary amount of time. It'll be used by the first test added in the next commit. https://gitlab.gnome.org/GNOME/mutter/merge_requests/961
2019-12-06 18:05:32 +00:00
wayland_protocol_server_headers = []
wayland_protocol_client_headers = []
wayland_protocol_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 13:55:35 +00:00
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', ],
build: Build scaffolding for primary-selection wayland protocol https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1255
2020-05-13 16:06:10 +00:00
['primary-selection', 'unstable', 'v1', ],
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 13:55:35 +00:00
['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 19:25:38 +00: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 13:55:35 +00: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
tests/wayland: Test subsurface commits after parent was reset Without 'wayland/surface-actor: Reset and sync subsurface state when resetting' this test would fail. This also adds a simple framework for testing lower level Wayland semantics. In contrast to the test-client and test-driver framework, which uses gtk and tests mostly window management related things, this framework is aimed to run Wayland clients made to test a particular protocol flow, thus will likely consist of manual lower level Wayland mechanics. A private protocol is added in order to help out clients do things they cannot do by themself. The protocol currently only consists of a request meant to be used for getting a callback when the actor of a given surface is eventually destroyed. This is different from the wl_surface being destroyed due to window destroy animations taking an arbitrary amount of time. It'll be used by the first test added in the next commit. https://gitlab.gnome.org/GNOME/mutter/merge_requests/961
2019-12-06 18:05:32 +00:00
wayland_protocol_server_headers += custom_target('@0@ server header'.format(output_base),
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 13:55:35 +00:00
input: input,
output: '@0@-server-protocol.h'.format(output_base),
command: [
wayland_scanner,
'server-header',
'@INPUT@', '@OUTPUT@',
]
)
tests/wayland: Test subsurface commits after parent was reset Without 'wayland/surface-actor: Reset and sync subsurface state when resetting' this test would fail. This also adds a simple framework for testing lower level Wayland semantics. In contrast to the test-client and test-driver framework, which uses gtk and tests mostly window management related things, this framework is aimed to run Wayland clients made to test a particular protocol flow, thus will likely consist of manual lower level Wayland mechanics. A private protocol is added in order to help out clients do things they cannot do by themself. The protocol currently only consists of a request meant to be used for getting a callback when the actor of a given surface is eventually destroyed. This is different from the wl_surface being destroyed due to window destroy animations taking an arbitrary amount of time. It'll be used by the first test added in the next commit. https://gitlab.gnome.org/GNOME/mutter/merge_requests/961
2019-12-06 18:05:32 +00:00
# used by tests
wayland_protocol_client_headers += custom_target('@0@ client header'.format(output_base),
input: input,
output: '@0@-client-protocol.h'.format(output_base),
command: [
wayland_scanner,
'client-header',
'@INPUT@', '@OUTPUT@',
]
)
wayland_protocol_sources += custom_target('@0@ source'.format(output_base),
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 13:55:35 +00:00
input: input,
output: '@0@-protocol.c'.format(output_base),
command: [
wayland_scanner,
'private-code',
'@INPUT@', '@OUTPUT@',
]
)
endforeach
endif
tests/wayland: Test subsurface commits after parent was reset Without 'wayland/surface-actor: Reset and sync subsurface state when resetting' this test would fail. This also adds a simple framework for testing lower level Wayland semantics. In contrast to the test-client and test-driver framework, which uses gtk and tests mostly window management related things, this framework is aimed to run Wayland clients made to test a particular protocol flow, thus will likely consist of manual lower level Wayland mechanics. A private protocol is added in order to help out clients do things they cannot do by themself. The protocol currently only consists of a request meant to be used for getting a callback when the actor of a given surface is eventually destroyed. This is different from the wl_surface being destroyed due to window destroy animations taking an arbitrary amount of time. It'll be used by the first test added in the next commit. https://gitlab.gnome.org/GNOME/mutter/merge_requests/961
2019-12-06 18:05:32 +00:00
mutter_built_sources += wayland_protocol_server_headers
mutter_built_sources += wayland_protocol_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 13:55:35 +00:00
subdir('meta')
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 22:21:37 +00: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-23 02:25:35 +00: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 13:55:35 +00: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 15:28:16 +00: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 13:55:35 +00: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 11:28:57 +00: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 13:55:35 +00: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 19:50:24 +00: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 10:28:46 +00: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 13:55:35 +00: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 08:05:08 +00: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 13:55:35 +00: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 21:28:18 +00: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 13:55:35 +00: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 17:51:21 +00: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 13:55:35 +00:00
subdir('tests')
endif
Reference in New Issue Copy Permalink