Allowing aliases and not using a canonical name for
them (e.g. mapping "view" to "viewmodule") is annoying
since the target name depends on which alias is passed
in to the function. Drop one of the two aliases.
with 2588d1e796
KPMCore is Qt6 only, so any version from 24.01.75 on is Qt6, no need to check for Qt version this way
add missing NO_CONFIG to summaryq
make kpmcorehelper usable for both kf5 & 6, though no section added yet dealing with set to NOT for Qt6
adjust CalamaresConfig to not be hardcoded to kf5
one more var needed in Variant.h, used in PartitionInfo.cpp
adjust QVariant & QtConcurrent use
- On FreeBSD, no KF6 was available
- On KDE Neon Unstable, there are somewhat wonky KF6 packages available
- Adjust CMake to find the KDE Neon versions, then fix the C++ code
This works around older CMakes that refuse to set arbitrary
properties on a target. Instead, use calamares::kpmcore
as the specific indicator that kpmcore was found.
Breaks build of libcalamares, since that needs **something**
regardless of whether KPMcore was found.
- the alias libraries calapmcore and calamares::kpmcore
are always created; if there is no KPMcore, they handle
definitions to signal that.
- upstream kpmcore target is the one we should be testing
to see if KPMcore itself is there (or, use KPMcore_FOUND).
- kpmcore (when used as target "kpmcore") has an interface
include directory that does not contain the "kpmcore/"
subdirectory. But the headers it has installed, assume it
is there (e.g. kpmcore internals use #include <fs/filesystem.h>).
- add an alias at Calamares level that sticks in some more
includes, adds the relevant WITHOUT_kpmcore when it's
not there, etc.
Nothing beyond the example module was ever built with the
PythonQt bindings, as far as I can tell. They have been
deprecated, defaulting OFF for over two years now.
QML modules fill the gap with customizable, run-time
interpreted UI and stronger support from the C++ side
of Calamares.
This introduces a stub-implementation (fake) that mimics the
API offered by libcalamares (the library is actually exposed
to Python via Boost::Python, so it doesn't act like a C-extension).
Using that stub-implementation, we can check Python modules for
validity as part of the test-suite.
The stub-implementation is needed, because otherwise every
Python module already fails at `import libcalamares`.
- stub-implement the API that is actually used by the Python modules
- in globalstorage, be slightly smart about what keys are being
requested (so that e.g. all the modules that handle partitions
information get an empty list and can manipulate that, instead of
erroring out when they get a string)
- Modules and plugins don't need to mention libcalamares themselves
for linking -- we can do that automatically. Use the IMPORTED names
so that it works in Calamares main repo and external repositories.
- Complain about unknown module types.
- merge the (not-installed) date-stamp and git-version
files into ExtendedVersion, turn things into functions
- drop support for CVS (wut?)
- don't mention the branch, in git-versioning, because the
hash is enough to find whatever
- don't need external program to find date, use `string(TIMESTAMP...)`
The check for skipping a subdirectory was applied to Python subdirs,
not to C++ subdirs. This meant that a skipped module would notice
only in calamares_add_plugin() that it should be skipped. The **rest**
of the CMakeLists.txt in the to-be-skipped modules' subdirectory
was not skipped, and so a test might be added for a module that
was skipped. Depending on how the test consumes the code/module
under test, that might fail to link.
Example module is *initramfs*. Reported by yonggan.
The skip-checking is now in the functions for adding plugins and
subdirectories, so that third-party building should get it
as well, for free. Since AddModuleSubdirectory and AddPlugin
use the newly split-out module, handling SKIP_MODULES and USE_*
consistently across module repositories is now easier.
While here, make accumulating-the-skipped-modules explicit.
There are two ways to skip building a module:
- SKIP_MODULES (individually listed)
- USE_* (pick one from a collection)
Move the handling for those ways to a separate function, so that it
can be re-used in the calamares-extensions module too, or other
external module repositories.
I think we had this (kind of) module a long time ago and it was
removed for over-complicating things; re-introduce one now that
KPMcore is used in 3 different places and all would benefit
from consistent API handling / defines.
Some tests -- notably the keyboard module -- need to have the
QRC for the module loaded as well (e.g. because of data in the
QRC). Add a RESOURCES parameter to calamares_add_test()
like calamares_add_plugin() already has, to build the
resources into the test.
Keyboard test now passes, since it was missing the data for
lookups before.
- *secretly* this is already done in the KF5 i18n modules,
so the resizefs was already requiring FindGettext.
- we don't actually use the gettext modules' CMake macros,
so explain why in the module.
- there's no need for a macro that is going to be used once,
especially if there's only one place it can be called.
- expand it in place and remove it from the installed CMake
module
- point to main Calamares site in the 'part of' headers instead
of to github (this is the "this file is part of Calamares"
opening line for most files).
- remove boilerplate from all source files, CMake modules and completions,
this is the 3-paragraph summary of the GPL-3.0-or-later, which has
a meaning entirely covered by the SPDX tag.
The intended license for the CMake modules is BSD-2-Clause;
there's no desire to restrict what can be done with these,
and CMake modules are generally 2-clause licensed.
