- Replace stringlist with a stronger-typed list of InstanceKey objects
- Move smashing-that-to-stringlist into consumers of the list
(just one, the debug window)
- introduce NamedEnum lookup tables for interface and type
- drop "final" and "virtual" from methods that don't make
sense as virtual
- shuffle declaration order so the virtual API for modules
sits together
- Trying to get away from untyped strings with special meaning.
- The "split identifier" branch tried the same thing, but
was duplicating the existing InstanceKey.h work.
- need a configuration before we can start loading (to support
the variable search paths)
- refactor showing a failure in the spinner widget. On failure,
the spinner will never go away, so a message for the user is good.
- stop clang-format from messing up the table of names.
- The "convenience" method was no longer convenient, since
we now place strings on the buttons by default.
- While here, **name** the buttons so they can be themed.
- if the welcome module wasn't loaded (or loading otherwise failed)
then no text was set, leading to confusing screens with
buttons with icons but no label.
- If a module exists, and has unmet dependencies, then
that is only a problem if the module itself is *used*.
Merely existing is ok.
This triggers on FreeBSD, where partition isn't built, but
bootloader depends on partition -- so you can never start
Calamares on FreeBSD, because bootloader depends on something
non-existent.
Relax the check: just warn, and only fail if a non-existent
module is used (all those with unmet dependencies are considered
non-existent).
- Calamares scans **all** subdirs of the module-directory
for a module.desc and complains about those that don't have
a module.desc.
- For ./calamares -d runs from the build-directory, this
leads to a few complaints when some plugins have been
ignored (and so no module.desc is generated for them).
- Things in libcalamares/ subdirectories are namespaced
according to that subdirectory (sometimes in namespace
Calamares, sometimes CalamaresUtils). Do that in modulesystem/ too.
- since we also need to *disable* the shortcuts, and should tell a
V1 slideshow that it no longer is running,
- use existing function to set the property to true / false depending.
- instead of changeState( true ) or changeStage( false ), use
meaningful enum names so that the code at the call site
becomes readable; make the boolean part internal to the
state-changing method.
- this is not entirely straightfoward, since we need
different constructor arguments for the objects
Calamares creates (no QVariantList& args, in particular).
Implement our own registerPlugin() and createInstance()
for that.
- work around a bug in K_PLUGIN_FACTORY_DECLARATION_WITH_BASEFACTORY
- do static initialization more carefully
- float -> qreal (double) because that's what the Qt API expects,
to reduce type-conversion warnings
- apply current coding style
- This is a fairly specialized class, for use only in the
whole-application where it ties in with the module system.
Move it to the application directory and slim down the UI library.
- Include it from the new location.
- Add UIC to Calamares (the application) because there's now
a designer-based widget in it.
- Change to std::chrono::seconds wasn't tried against the (optional)
PythonQt bindings, leading to build failure. Reported by Phil (Manjaro).
FIXES#1210
- While called from the ViewManager (to post the debug log)
this isn't really part of the ViewManager itself, so factor
out the pasting code into its own file.
- Give each check a name (based on the module it runs for, so
there might be overlaps when there are multiple module instances).
- Log the remaining checks each time the timeout fires, to help
figure out which one is hanging.
- updateButtonLabels() knows all the special cases for
buttons, so use it when the language changes instead
of setting up some possibly-wrong values.
- One edge case that this fixes is: have **just** the welcome
page before the first exec section in sequence. Then the
*next* button label was *next* instead of *install*.
- The component isn't ready immediately, so instatiate
once it is fully loaded and ready
- Edge case if the execution view step is already visible, then
start the show (because a previous call to onActivate() will
have missed it).
- By instantiating only on activation, an ugly "white" gap
appears where there is no widget at all. So instantiate
earlier so that the widget already exists and is painting
by the time the slideshow part is visible.
- This makes the net effect of this branch so far zero:
the slideshow is still loaded and started when Calamares starts.
- From an exec section, next() is called automatically when
all the jobs in that section are done.
- If there **is** no next section (e.g. there's no finished
page to show after the exec), then m_steps.at() would assert
on an out-of-range index.
- Introdcuce a helper predicate isAtVeryEnd() which handles both
out-of-range and normal at-the-end scenarios.
- If there's no page following the exec section, stay with the
slideshow but update buttons to match the normal last-page
behavior, and don't ask about cancel (since we're done).
- The not-publicly documented setContent() method does all the
parenting and resizing needed; some of this isn't available
from outside of the widget either.
The QML slideshow now sizes and re-sizes correctly.
- Load QML on startup, compile async
- Create QML component when the page is reached.
- On leave, stop the slideshow (otherwise, e.g. timers will keep running)
This should move some of the delay from loading a large
slideshow forward as the engine is already initialized when
we reach the install / slideshow page.
- d78bc0c5 added an early `return false` when cancel is disabled,
before checking if we were at the last step; so last-step
didn't get any special handling.
- refactor so that last-step now gets special handling first,
**then** disable-cancel handling, and then the usual case.
- Avoid races which might double-delete the timer, or enter
the if twice (which would lead to duplicate emissions of
requirementsComplete and the associated UI glitches).
If the requirements checking is **really fast**, e.g. you don't
have a check for internet connectivity, then the checks
might be done as fast as the 0-timeout single-shot timer,
which means that finished() is called once by the QFutureWatcher,
and then after that by the QTimer .. leading to two messages
"All requirements have been checked", but also twice
requirementsComplete being emitted, so you end up with two
results lists being added by the CheckerContainer.
Stop that by using the results-progress timer as an additional
flag: the first time everything is complete, delete that timer
and set the pointer back to nullptr.
- In debug mode, hitting assert(false) is meaningless,
- In release mode, the assert is optimized out.
- So assert the condition we're actually testing, for better messages.
- It's ok to use path / filenames in images, but you can also
use icon names according to the FDO icon spec. This makes
sense for at least *productLogo*, possibly *productIcon*, but
not really for *productWelcome*.
- Branding images might want to use os-release data as well.
- Refactor a little to keep the number of #ifdefs the same;
an intermediate expand() lambda handles expansion (or not,
if it's not enabled).
FIXES#1153
- From the debug-window, clicking *reload stylesheet* does just
that, and applies the new stylesheet to the Calamares window.
- Remove stylesheet caching from the Branding class; we only
need the sheet once (on Calamares startup) or when updating
the stylesheet, which is seldom-enough that we don't need
to keep an extra copy around.
- To use, start Calamares, open the debug window, open stylesheet.qss
in an editor. Make changes, save, then click *reload stylesheet*.
SEE #1149
- Adds another tool to the debug window, which dumps (to the debug
log) a tree-like view of all the widgets in the application.
This can be used when writing stylesheets.
- allows you to use -- at runtime -- values from os-release in the
branding file.
- WIP because the only machine I have with sufficiently new KF5
is the FreeBSD box.
- Do the checking for IsMap inside loadStrings() and use
YAML::Exception to get to bail() (since we're already dealing
with exceptions here, no extra costs). This tidies up the code
somewhat.
- Checking if the **next** step is an execute-step is a little
weird, so make the API more general (and add the +1 to indexes
where it was using NextWillExecute before).
In the sidebar, the "Install" step should be named "Set Up" when in
setup mode, which will be more consistent with the other UI texts,
including button labels.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
- This small header file contained a few unrelated typedefs.
Move those typedefs to the classes they relate to. This
**does** mean that some consumers need to #include something
else instead.
- Use type names more consistently.
Editorial: why are **pages** responsible for creating the jobs?
- Currently just moves a single enum, but this is prep-work for
moving the non-GUI parts of the module system into libcalamares,
to better support GUI-less operation.
- The only remaining functions in the file are string-related, so
rename to match their purpose.
- Drop this include file from most places, since they don't actually
use the string functionality at all.
- Even when Cancel is hidden, also disable it (prevents DBUS
triggers, for instance),
- Re-enable it when exec is over, if it's disabled then.
- simplify code a little.
- Use only utils/YamlUtils.h to pull in yaml-cpp and supporting code.
- When compiling with clang, turn off warnings that the system header
for yaml-cpp would generate.
- Using project() to set up the version is idiomatic for CMake
and more standardised than doing it by hand. Do retain the
RC flag, because that's used in other parts of versioning.
- Avoid crash due to invalid iterator, when modules
are removed due to missing requirements.
- Simplify code, factor out the determination of
which required modules are missing.
- These methods are used for multi-page view-steps, which are rare.
For all the others, just drop the empty implementation and defer
to the base class.
- Move the actual checking into a separate object with some lifecycle-
management signals.
- Right now this is still single-threaded and blocking, so no net gain.
In some cases, e.g. when calamares is used as an "initial setup" tool,
we may want to user to go through all the configuration steps in order
to end up with a usable system.
Therefore, disabling the "Cancel" button can be useful in this case.
This commit adds an option to settings.conf which disables this button
when set to "true". If the option is not present in the settings file,
the default behavior ("Cancel" button enabled & visible) is enforced.
Signed-off-by: Arnaud Ferraris <arnaud.ferraris@collabora.com>
- A size of 64em has a value less than 1024, which is the minimum
size **in pixels**. The check doesn't make sense as-is and would
have to take the unit into account. Leave that to clients of
branding (e.g. CalamaresWindow, which already does this).
- Use DATA for the qml and branding directories (looks for qml/
and branding/<name>/ in those directories).
- Use CONFIG for the global settings and module settings (looks
for settings.conf and module/<name>/ in those directories).
FIXES#941
- Be more verbose when things go wrong while loading module-
configuration files.
- Allow more forms of paths to be specified. In debug mode, this
is mostyle helpful for the module test-loader.
- document new variable from the CMake module
- use it in libcalamaresui to simplify #include'ing the
header for the "all" extension.
Suggested by Denis Proskurin.
- Similar to the refactorings in Calamares proper, just split out
collecting the search paths into a static function. This makes
it a little easier to find places that will need expansion for
more-than-one-config-directory.
- There is more to failing out of loadModules() than just
emitting modulesFailed, so instead share the failure
code with the code after loading modules -- but don't load any.
- Module dependency-checking is done in two phases:
first, catch any unknown modules that are listed
in *requiredModules* and bail out before loading
anything. Second, check that the modules required
by X occur before X in the sequence.
- The value set in module.desc was never stored for use,
but isn't an attribute of the instance, either. It belongs
with the descriptor, in ModuleManager.
Introduce the notion of emergency modules and emergency jobs.
Initial use will probably center around the preservefiles module,
and possibly umount.
FIXES#928
Any job can be an emergency job; emergency modules spawn
emergency jobs (but conversely, a non-emergency module
can spawn an emergency job explicitly).
A potentially emergency module is one that has EMERGENCY
(in CMake) or emergency: true (in module.desc) set.
Any such module must also set emergency: true in the
configuration of the module. This is to allow for
instances of a module that **don't** run as emergency
modules, alongside actual emergency ones.
- Add a TODO for allowing modules to come from somewhere other
than the module loader (this would allow "internal" modules
that are always present)
- Warnings are warnings
- Collect the failed modules, instead of bailing out on the first one
(this also prevents crashes caused by quit() called from a timer).
- Introduce a slot to report on failed module loading (no UI yet).
- document accessors
- put all path and directory accessors together
- make simple accessors inline
- rename "pathprefix" to "directory" to be consistent with others
