- QImage needs Qt5::Gui, so this isn't a guiless-test; it can use
the offscreen QPA, though.
- Check that the images are all the same size
- Debugging / check code removed from timezonewidget
- The idea is to check all the TZ images for consistency, like
TimeZoneWidget::setCurrentLocation() does when DEBUG_TIMEZONES is
on; a zone-pixel should be set in only **one** image.
The test so far is just a stub.
- Make all four DEBUG_ flags actual CMake options, rather than
stuffing some of them in the rather-peculiar _enable_debug_flags.
Each debug option turns on suitable compile flags in the module(s)
that are affected.
- When writing YAML, given a float **always** write
some decimal digits (e.g. "1.0" rather than "1")
so that the type of the written-out thing stays
float.
- Avoids test failure with the sample `welcome.conf`
file which reads 1.0 and would write out 1, which then
led to type differences.
- Handle qlonglong explicitly
- Add a fallbackfor things that convert to qulonglong, to
avoid these remaining integer types from hitting the
very end of the if-chain, and being written out as
the **string** "<typename>"
When one of these common names for the netinstall page is used,
it gets pulled out of the standard translations, so that it
doesn't have to be translated in the per-distro config file.
These labels are common enough that they make sense for
everyone to have lying around.
FIXES#1367
(I say "fixed" but of course it's going to depend on the translation
workflow to make these available)
- In production, cDebug() might not show up, so the log will not
contain the lines saying what program is being run;
- Errors should at least mention the program name, but "env" or
"chroot" is not useful, so pull that from *args*, which is
the command we actually want to run.
- an empty command isn't going to work (although it might successfully
run chroot or env in the target system, that's not useful)
- while here, move variable declarations closer to their use.
- Slice overall progress into chunks, with each chunk of equal size
(as long as we have no overall count information) and place
the progress of the current chunk into its own slice.
- The entry knows where it should be mounted, and can remember that
- mount_entry() didn't use self, so made no sense as a method
of the Operation class
probably due to dynamically loading items
regionModel now lists, zonesModel only lists one delegate, but
working on QML modules can now continue without crashing cala
This doesn't actually **work** though, the QML uses older Calamares-internal
APIs and uses a ResponsiveBase that we don't have. Merge it mostly for
the Config and model changes.
FIXES#1355
- Add some extra checks for validity of m_currentStep (an index)
- Start off with explicitly invalid index, and keep it so until
loading is complete; this prevents the situation where quit-at-end
gets triggered after loading the very first module.
- io.calamares.modules doesn't exist
- ResponsiveBase doesn't exist
The module is now non-functional, but at least it loads and renders
a list of regions and zones.
- name default / example QML conventionally
- copy QRC from keyboard -- the QML needs to be included in the QRC --
since we don't want to have the QML in the keyboard module.
- follow branding settings, taking the panel-sides into account
- drop fixed width and height for QML parts
- give panels a minimum appropriate-dimension if they don't have one
This allows, for instance, putting both Widget sidebar and QML navigation
on the left-hand side of the window.
- Introduce an enum for panel-side
- Expose this to QML -- I can imagine that QML panels need to know
which side of the Calamares window they're on.
- Refactor loading the setting into a method that handles both
flavor and side
- There's no real reason to force the sidebar left and nav at the bottom,
certainly with QML supporting more layouts and being more flexible,
so document a mechanism to place the sidebar and navigation along
"edges" of the Calamares window.
- With an empty list, the question is meaningless
- .. and we called this with an empty list while constructing the
ViewManager; if quit-at-end is true, then this would terminate
Calamares immediately because the list was at the end.
- put signals in conventional place
- remove const int& parameter, that can just be int
- drop oddly-guarded code (that leaks memory); if the index (row)
being passed in, it's probably best to just crash
- remove unused signal warningMessageChanged
- Now the back button should be done by clients as well
- Refactor in CalamaresWindow to avoid leaking local button pointers
to surrounding code.
- Add macro UPDATE_BUTTON_PROPERTY for convenience in ViewManager
(ugh, macro) to change a value and emit corresponding update signal.
- add properties for the next button (enabled, label, icon...)
- update those properties as normal
- connect to the properties in the UI implementation
using Loader, can be reused for other widgets conversion
leave onClick example with full path, commneted out
title text for About is hardcoded, discuss option to make this configurable in welcome.conf
background color hardcoded, tested to work well in dark themes too
- since we've got two blocks of code copy-pasted, which both
decide to call one or the other of two member functions based
on a flavor value, turn that into a templated function.
- passing member functions looks a bit weird, and calling them
is syntactically surprising, but it cuts down the code a lot.
- the checker only collects and calls requirements; it has no
UI component, and only manages data (and a thread to do the
checking). Move it out of the UI library.
- this function lives in Module -- and is the only thing typing
Module to the ViewSteps and JobTypes. Split it out into its
own funciton. Nothing else in Module needs to befriend the
ViewSteps, so we move the friend declaration around a bit
as well.
- while here, apply coding style.
This is prep-work for moving module to libcalamares.
- drop the current and completed roles, and expose only
the currentIndex. QML can use the QObject property on
the model, while QWidgets can call internally through
the model's data() function.
- we don't need to provide role names for this, so drop that bit.
- simplify the delegate code while here.
- Groups inherit slightly differently: if a subgroup **explicitly**
configures criticalness, use that. It would be weird, but possibly,
to have a non-critical subgroup of a critical group.
- An unselected group with (some) selected subgroups was not
displayed as (semi)checked -- it was unchecked, because
its checked-ness was not updated based on the children.
- the `parent` when installing a translator was not used, so drop it
from the API. Chase some uses of the API, but leave welcome-modules
broken: there's a merge of those coming.
- isEfi only used meaningfully once
- if (isEfi) followed by if (!isEfi) can be simpler
- create bios-but-not-GPT strings in one go
- mark TODO that this should warn only if needed
- use weird * notation for branding-strings
- In some cases, it makes sense to close Calamares automatically
when it is done. Set *quit-at-end* to do so -- although this
probably also means you should remove the *finished* page.
- It's annoying to have 100% progress reported (from the processing
of list items) and then have another 3 seconds delay.
Unrelated to the issue-at-hand, but spotted in testing.
- while the queue is executing (the thread is running jobs) the
isRunning() method returns true.
- re-work some internals to reset isRunning() before emitting
finished() signal.
- Instead of loading all in the constructor, provide a public
setupModelData().
- This allows creating the model and setting it for UI, before
the load completes.
- Add initial definition of Config object, which will extract the model-
setting and loading code from the page, and which is also prep-work
for a QML version of this module.
- While here, remove superfluous code
- For a static list of selectable packages (e.g. what you might otherwise
use file:/// for with a static file on the ISO) you can now stick the
list in the config file itself, simplifying some setups.
- Also saves faffing about with network.
SEE #1319
- `local` is supposed to read from the config-file, rather than
externally; this simplifies examples, makes it easier to have
multiple netinstalls, and condenses the documentation.
- Check groups
- Check whole treemodels recursively (this is not in PackageTreeItem,
because that explicitly ignores the tree structure).
- Also a stub of checking example files (from the src dir)
- Just some simple tests for the Items
- Test creation of package group from variant
- This needs Qt5::Gui to link because QStandardItem is a GUI class,
although we can run the tests without a GUI.
- This doesn't compile right now.
- The nested class ItemData doesn't do anything useful or
meaningful that having model items with the right data wouldn't.
- If we're converting a YAML map to a QVariant (Map), may as well
express that in the types. This makes the return from, say,
`yamlMapToVariant()` cheaper, but incurs conversion in
`yamlToVariant()` .. previously the place for costs was
swapped around.
- For those cases that want-and-expect a Map, or List, this makes
the calls slightly cheaper. For the generic case, the costs move
around internally.
Pull in the instance-weight changes and type-improvements,
but not the part where special-casing of unsquash is dropped:
weights are still per-job, not per-module.
- can't convert lambda-with-captures to a function pointer (Clang 9)
- instead, use a context property .. QmlViewStep already sets a
"config" property with the Config object, but WelcomeQ wants it
as another name as well.
- this avoids registering the Welcome object across all QML pages,
as well.
NOTE: needs to have the QML adjusted for this change.
- Replace a map-of-strings with a class type.
- For now, doesn't compile.
- Intention is to construct from a YAML / QVariant from the
*instances* list in `settings.conf`.
- Refactor into a support method and two API points
- Use std::transform for doing-things-to-a-list
- Add searchQmlFile that only takes a name, for
non-modules to use.
- Registration of QML modules may need to be done
for more parts of Calamares. Move into the library,
out of the model.
- Register for QML when using the QML sidebar.
- This is utility code, so it can be in the QML "service"
from Calamares, rather than in the QmlViewStep itself.
That makes it usable for other QML bits as well.
- The name is just the module identifier, and now we
search for *m@i* and also *m* from that identifier,
the name becomes much less important -- and it
can be set from the config key *qmlFilename* as well.
- To avoid name-collisions in otherwise well-behaved
modules and configurations, make the QML settings
more specific:
search -> qmlSearch
filename -> qmlFilename
- Having a ProgressTreeModel that does nothing but
proxy to ViewManager methods is kind of useless.
- Move the relevant code from ProgressTreeModel to
ViewManager.
- Remove now-unused ProgressTreeModel.
- The model is a simple list, not a tree (it may have been in the
distant past).
- All the information needed comes from the ViewSteps held by the
ViewManager.
- The delegate and fake-step handling was never used.
- Introduce convenience methods getString(), getBool() to pick
out an entry from item definitions in YAML format.
- Apply coding style.
- Pick up the "expanded" property as well.
- Use normal translation framework. The EncryptWidget was the one place
not using the "usual" translation framework, but rolled its own.
- Emphasize that the checkbox-state (checked-ness) is the parameter,
not a state of the EncryptWidget.
- All other instances of UI classes from Designer use a pointer-to-UI,
not multiple inheritance.
- Convenience method for setting the pixmap in response to
changes in the passphrase
- Tighten up types: enum -> enum class
- Reduce the scope for int-confusion by using an enum-class for
the encryption state of the widget
- Include UI implementation header only in .cpp
- Apply coding style
- Update copyright
- the strange construction of Helper and treating it as a singleton
can be factored out into a separate singleton-handling instance()
function. The Helper should never be destroyed.
- when a single function does more logging, it generally marks
those as subsequent debug-messages (with Continuation, or SubEntry)
and we don't need to print funcinfo for those, since it was already
printed the first time.
- there's no string representation for a QVariantMap, so it
won't be converted; in *debug* output it looks like there's a
string there.
- off-by-one when diving into compound selectors, spotted by
test, now fixed.
In order to test some of the internals, split them into Binding.h.
This makes the interface visible for tests. The implementation
still lives in the same place.
While here, adjust the test to the changed **example** which
now lists an additional variable.
- When a Python module calls utils.debug(), there's no point
in logging the C++ funcinfo that passes the parameters on;
don't use cDebug() with its attendant magic.
- Warnings, errors, don't get funcinfo, but regular cDebug()
calls do. Other special-cases, like calling Logger::CDebug()
constructor explicitly, don't get funcinfo either.
FIXES#1328
- Allow logging any QList type (needs explicit call in usage).
- Add a DebugList inheriting from DebugListT to keep existing
code that logs QStringLists.
- For Calamares 3.3, consider using C++17 and class template deduction.
- This bug has been here since f233cac7a1,
where a check for isSet() (of the -D option) was dropped. So since then,
Calamares has always been running with full logging (-D8) on.
- The recently-added "easter egg" of showing the debug-button when
log-level is 8 (to allow debugging-in-production) trips over the
default-log-level of 8, so the debug-button is always visible.
So, minor bugs in the debugging-setup, combine to show a debug-button
when there shouldn't be one.
FIXES#1329
- The manpage for umount says that -R can only be used with
a mount point (e.g. /usr/local) and not a device name;
this makes sense because a device might be mounted in multiple
locations, but the mountpoint (and things mounted under it) lives
in the filesystem tree.
- Existing code tried to unmount -R the device, not the mount point,
and so always failed; leaving things mounted that shouldn't.
Unset GRUB_SAVEDEFAULT if / or /boot is in btrfs or f2fs partition. This avoids the error "sparse file not allowed" at boot time. Btrfs and f2fs do not support saving default entry in grub.
- because mount() returns an exit code, and 0 is "success",
the if (!code) was backwards: when mounting succeeded, the
TemporaryMount object thought it failed.
- This leads to temp-mounts being left *all over* the place
from os-prober and fstab-handling.
- See editorial in the code-comment. Still need to test that
chroot(8) doesn't need a full path, otherwise this will
go to /usr/bin/env udevadm to force lookup (redundantly
if not in a chroot)
- !failed() also means "didn't write the file because it already
exists", which is sometimes acceptable -- but not here.
Use the more-strict bool() conversion, which is only when
the file was actually written.
- Unconditionally **not** overwriting the target file isn't an option:
writing hostname, for instance, expects that to be done even
if `/etc/hostname` already exists on the target filesystem.
- Make tests more resilient: do them in a temp-dir, and clean it
up after successful tests. This was prompted by tests failing
because of things hanging around in /tmp.
- Follow original patch from Gabriel Craciunescu: just drop
the *bufsize* parameter and stick to binary reads.
Text mode was associated in my testing with multiple hangs,
which didn't show up during binary-reads.
- By the time the GS is actually written, new (for partition state)
is always false. So "new" is the wrong thing to track. It should
have had a better name anyway,
- We store custom properties on the partition objects to indicate
what happens to them; use those properties (instead of state,
as done originally), call it "claimed" to indicate that the partition
is part of this installation.
For now, only new (as in, formatted, created-by-us) partitions are
claimed.
- The effect here is that only "new" swap will be added to the system,
so in erase-disk installations, or manual partitioning.
- Install-alongside and replace will now **not** claim the swap already
on the disk; I think we'll need another UI knob for that one.
FIXES#1316
- `createPartitionList()` is called for the summary widget (via
`prettyDescription()`), and from `exec()`. Only the latter
actually *writes* to Global Storage, so it's misleading to
think that the pretty-printed version ends up in GS.
- This makes the "new" key useless, since by the time `exec()` is called
the partitoons are no longer new.
- These tests don't actually test anything in this specific module,
they do test CalamaresUtils::System.
- Wrangling System and JobQueue and GlobalStorage instances is fraught
- Allow TranslatedString to get a context parameter; if it has
one, it will try to use the regular tr()-infrastructure
**as fallback** for the translations from the config file itself.
- This makes it possible to offer -- and translate -- some "standard"
phrases in the module, while allowing the config file the knob
to change strings. Using one of the standard strings gets translations
for "free", while introducing something entirely new means sourcing
translations for it as well.
- The model always has two columns, and the column names are always
the same. We don't need to specially set headers for that.
- Use QCoreApplication::translation() to re-use the existing
translations and avoid creating "new" strings (in a new context).
- Now that multiple netinstall pages may be supported, it's annoying
that they all have the same name. Copy the approach from other
modules (e.g. notesQML) of having the sidebar and other labels
configured in the config file.
- Since operations are added each time you leave this page,
the existing operations (from a previous visit) need to be
cleaned up. With the old setup of only **one** possible
set of operations, this wasn't a problem. Now, merging
in operations is necessary. Implement that by looking for
the *source* property in an operation.
FIXES#1303
- Different libraries should have different EXPORTs, so that
you can IMPORT one while building the other. Reported (and
kindly explained) by Kevin Kofler.
- Stick to one header file, though.
While here, update copyright on file.
- Having the widget do creation ties the step heavily to that UI;
start moving towards a state where we have a Config object (not
here yet; it still queries the UI part) that moves data around
between UI and ViewStep.
- This makes linking easier,
- Adds the right includes (needed on FreeBSD),
- Lets us drop silly GUI setting for non-GUI tests (I think this was
a side-effect of compiling on FreeBSD, where UI would pull in
/usr/local/include).
- Let's just have one header definining export- and visibility-
macros for Calamares. They are still selected based on the
export flags (*_PRO), just defined in one header instead of two.
- The scattering of DLL export macro's is kind of useless;
there are several headers, and then the export macro isn't
even applied consistently. Just drop the one for UI exports,
which was only used in libcalamaresui.
- If the test failed, you'd get a cryptic message like
FAIL! : NetworkTests::testPing() 'r' returned FALSE. ()
So rename the variable so the failure mode is more obvious.
(Could have used QVERIFY2() instead, this is simpler)
- Use the createTargetFile() convenience functions to do the
actual work.
- This probably involves more copying around of buffers, since it's
creating one big QString and sending that off, rather than writing
little chunks to a file, but I feel this is worth the code simplification.
- Drops all the error checking for creation, though, because the API for
createTargetFile() lousy.
Introduces a "partitioning service" into libcalamares,
shuffles a bunch of things into it, tries to help out
with settling the system between partitioning actions.
- explicit use of user-visible names in EditExistingPartitionDialog
- consistent conversion of config-values to FS names (user-visible).
The GS value comes from the ViewStep, and should always match
something -- it's already converted to the canonical un-translated
so the type should be good.
Because getting the untranslated name of a FileSystem is something
that needs doing consistently, add some functions for that;
it makes it easier to spot places where that isn't done.
Probably doesn't compile, and needs extra documentation.
- The config context object should be set earlier, otherwise
QML code will try binding to a non-existent config already
- Document that QMLViewStep::setConfigurationMap() parent implementation
should be called **last**, at the end of the subclass implementation.
- Using Branding::ImageEntry, when ImageEntry is an enum class
defined *in* Branding, is superfluous, and it also confuses
moc; the enum type isn't recognized from QML.
- Take the Python wrapper for GlobalStorage out of the GlobalStorage.h
header and add it to PythonHelper instead, saving some work in
all the cases that only GS is interesting, not the Python bits.
- Physical memory can't be negative, so it is reported as
an unsigned long, but the bytes-to-MiB functions do accept
negative amounts. As long as no machine has more than 2**62
bytes of memory, we're good though.
- don't have a NOTIFY CONSTANT property
- the data is constant, so drop NOTIFY
- remove redundant signals
- remove setLabels() now it's only needed from one constructor
- Create a job and ask it to create dbus files -- either directly,
or as a symlink. Since the target chroot isn't viable, this will
fail but we can at least see that directories are created, etc.
- Since these tests all want a system object, and a GS
with a sensible setup, give them one with its own initTestCase().
This could have been done with one executable, running tests from
multiple classes, but there's not much overall benefit there.
- Used to ensure that the directories leading up to a given path
exist. Implementation is incomplete and broken for now.
- While here, avoid removing an empty pathname in removeTargetFile()
(the empty pathname indicates a broken configuration).
- add a Settings::init() to do actual work
- remove the same kind of code from CalamaresApplication
- make constructor of Settings private
- initialize settings before the application
- There's a multi-stage setup for debug-mode, where the application
object also knows that debugging is set. Remove it.
- Break debug mode (because now the settings don't get debug-mode set).
- Refactor so that parameter handing is only done if this Calamares
is the unique (first) Calamares.
- To support translation testing, without needing to recompile
Calamares, load files from the local directory when debugging,
or from /usr/share/calamares/lang/ in general.
- This allows updating translations and testing them with just
lrelease (a translation build tool) installed, without rebuilding
Calamares.
- This allows distro's to ship updated or modified translations without
rebuilding Calamares.
- Most of the code was error-checking, just replace the open-read
with a call to the service instead.
- It's not an error if /dev/urandom doesn't exist in the source system
(there may be other good random sources, and otherwise we have the
low-quality random fallback).
- the list is already filtered for UTF-8, so this is redundant
- this *incidentally* fixes the problem with Assamese and Asturian,
since Assamese (as_IN) was having its only entry removed,
after which it would match Asturian (ast_ES)
- these were empty, so the widgets were hidden in the details
dialog of the requirements check; which looks really strange
if the reason the check fails is because root is required,
and you can't see that in the details.
This commit is on a branch because it changes strings, and I want
to do a release Real Soon and not annoy the translators.
- instead of counting and needing to keep track of the predicate
applied while creating the widgets, push nullptrs to the widget
list instead reflecting "this entry did not satisfy the predicate
for widget creation".
- for the list, the code can be the same as for the dialog,
only the predicate is different.
- while here, implement retranslate() since there's no text on
the list widgets otherwise.
- Create the label once, and it's ok for it to respond to links
even if there's none in the code.
- Turn into a member variable in preparation for retranslation-refactor.
- lift it out of the loop that creates the widgets
- some lambda-wankery, but the compiler hammers this down to
simple loops and you can read the resulting code as
none_of [the list] isUnSatisfied
none_of [the list] isMandatoryAndUnSatisfied
- no point in having init() called immediately after the constructor,
if it only makes sense to have one call to init() ever to create
the widget.
- while here, give it the same kind of structure as the dialog,
holding on to a reference to the list.
This is an ugly hack, using Bill Auger's support for Job weights.
The unpackfs job is arbitrarily awarded a weight of 12. That makes it
(in a Netrunner install) use progress from 12% to 40% or so, overall,
as all the files are unpacked.
Also fixes bug reported by Kevin Kofler that unpackfs was only reporting
progress when it hit an exact multiple of 100 (instead of over 100).
SEE #1176
- this is currently just an alias for QVariantMap, which is
the type already in use.
- future plan is to tighten this up and have an actual
Descriptor class that carries only the information
actually needed for the module descriptor.
- 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)
sidebar entry can be configured and translated
adding a more elaborate qml example
keeping this in dummyqml for now, another commit will follow with
continuation of dummyqml in a more aptly named module
- 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.
- start of a class to hold configuration information; this can
later be substituted into the WelcomeViewStep and filled from
setConfigurationMap()
In the example application:
- register the Config type
- test application to display the QML (this will be extended
with adding the locale model to it)
- sample QML that does nothing useful yet (will display the locale
model once it's there)
- all the TZ location information now lives in the Calamares
locale service and the TZ list
- replace the Location class that was local to the timezone
widget by the TZZone class
- chase a bunch of small API changes that this needs
- Split the actual loading of translations into classes
to encapsulate the loading logic,
- Build a collection of classes to do the different kinds
of translation loading,
- Build a generic function to load something and update a
static pointer to the translation.
This makes installTranslator() much easier to read, and encapsulates
the type-specific loading somewhere else. While here, add a timezone-
translations loader so that the split-out TZ translations also work.
- Hide the one file from lupdate by giving it a weird suffix
- Call lupdate a second time for the timezone translations
- While here, adjust so that the options precede the directories
they are supposed to affect
I don't want to give the translation teams 444 new strings all
at once (about 90% of which don't need translation).
- Used in only one place, move to .cpp
- Drop useless scaling all the images *are* that size already
- Add debugging check that the images match expected size
