What makes a great team? One important factor is that you have a balanced set of skills and personalities in the team. A team which only consists of leaders won't get much work done. A team which only consists of workers will not work into the right direction. So how can you identify the right balance and combination of people?
One answer is the Team Member Profile Test. It's a set of questions which team members answer. They are evaluated to give a result indicating which type of team member the person is and where it lies in the spectrum of possible types.
There are two dimension which are considered there, how much team members are oriented towards tasks and how much they are oriented towards people. This can be visualized in a Results Chart.
Here is an example:
You can see five segments:
The center (5,5) is the "worker" who has a set of balanced of attributes, no extremes. These team members are extremely important because they tend to just get stuff done.
The top left (9,1) is the "expert" who is focused on the task and its details but doesn't consider people that much. You need these to get the depth of work which is necessary to create great results.
The bottom right (1,9) is the "facilitator" who is something like the soul of the team, focused on social interactions and supports the team in creating great results.
The top right (9,9) is the "leader" who is strong on task and people and is giving direction to the team. You need these but you don't want to have more than one or two in a team otherwise there are conflicts of leadership.
The bottom left (1,1) is the "submarine" who floats along and tries to stay invisible. Not strong on any account. You don't want these in your team.
The test can provide some insight into the balance of the team. You want to have all but the submarine covered with an emphasis on the workers.
disable GtkFrameExtents for docks and panels that ByPassWindowManager ("CanBeAboveFullscreenWindows" option) under X11
draw always a contrasted border for latte indicator
simplify latte indicator implementation
enforce RoundToIconSize for all applets always and as such the Items Size is always respected. If the user has blur issues with its icons, he should specify an item size which is present at the icon theme. For example, 16px., 24px., 36px., 48px.
identify kickofflegacy applet properly
fix popup positioning for plasma-style popups when the dock background is using very big corner roundness
prevent session manager from restoring latte just like Spectacle is already doing
respect virtual desktops navigation wrapping around option
expose translations for default dock and panel templates
Corner Margin
- corner margin is drawn in purple -
With Latte 0.10.3 indicators gained the ability to specify the background corner margin. This is totally on indicator responsibility to expose or adjust properly and that is the case for Latte and Plasma Indicators that expose it from their settings. With this setting the user is now able to move tasks and applets inside the corner of backgrounds with very big roundness.
- corner margin option in latte indicator -
It was decided that the option should be part of the indicators api because it is on indicators responsibility to specify how much of the area provided to them, it is actually painted. If an indicator is not touching corner margin at all then default latte behavior is used which is playing safe by taking as granted that indicator is painting the entire area provided to it all the time.
Donations
You can find Latte at Liberapay,
or you can split your donation between my active projects in kde store.
QML is a nice technology but it sometimes feels that some parts of
KDE Frameworks aren’t neatly integrated with it. For example, until
recently KNotification didn’t have QML bindings,
which was the same for KSyntaxHighlighting.
Thankfully Volker Krause took care of both.
Another part of the often-used KDE Frameworks but had missing
QML bindings was Sonnet. Sonnet is a very nice KDE framework powering
KDE text areas with spell checking.
The good news, Sonnet will, in the next KF5 release, supports QML apps too!
Spell checking in NeoChat
There are two ways to add Sonnet supports in your application.
The easy way: Kirigami and qqc2-desktop-theme integration
If you use Kirigami and are fine with the default behavior, this
only needs one single line in your QtQuick.Controls.TextArea.
This line is just a hint for the QtQuick Controls 2 theme to enable
spell checking for this TextArea. Currently, only the qqc2-desktop-theme
uses this hint. For other themes, like qqc2-breeze-style or custom themes,
this will unfortunately do nothing.
This hint is required since we decided to disable spell checking by default.
This is because of multiple reasons: this might cause some breakage for
apps that are already doing its own TextArea modification.
The hard but powerful way
The second way to add spellchecking with Sonnet is to use the bindings
directly. This makes it possible to configure the exact behavior of the spellchecking
in your app. This is the API that qqc2-desktop-theme is using internally.
For that, you will then need to add the SpellcheckHighlighter directly to your
TextArea.
Sonnet.SpellcheckHighlighter exposes a few interesting methods that
make it possible to get the spellchecker’s suggestions, add words to the dictionary, ignore some words
and more. For those interested, I would recommend looking inside
qqc2-desktop-theme
and see how Sonnet is used.
Settings
Sonnet now also exports the spell-checking options to QML. You can find an
example of how to use the exposed config object in NeoChat.
I hope to move this code at some point in Kirigami Addons, so that not
every app will need to implement its own setting config page.
NeoChat spellchecking options
This change opens the way to also port the global spell-checking options in Plasma
System Settings to QML in the future.
Next plans
My next plan to make QML powerful in KDE is to figure out a way to
upstream the nice KXMLGui/KConfigWidgets that I build for Kalendar into
a separate component/library. This would make it possible to use a command bar, global
menu bar, normal menu bar, configurable shortcuts and possibly more in a QML/Kirigami app.
This one is a bit tricky since dependency wise. Since all these features depends on QAction
that depends directly on QtWidgets in Qt5. In Qt6 this now only depends on QtGUI but is
is sill annoying that QAction can’t be used in QML but instead we have a QQuickAction that
is part of the private QtQuick Controls 2 API.
Linux Application Ecosystem Salon 2021 Changsha This weekend I traveled to Changsha for the Linux Application Ecosystem Salon 2021 Changsha, which is held by Ubuntu Kylin in the campus of Central South University. The journey itself is uneventful. I’ve never been to any offline Linux events before, I wanted to go to FOSDEM, but then the COVID hit. So anyway, it’s a first time for me. You can view the full news in Ubuntu Kylin’s post
In our last week of KDE Review, we have been focused on fixing as many bugs — big and small — as we have been able to. Thank you to everyone who has reported bugs, and thank you even more if you have helped in fixing them! Besides bug-fixes, we also have some pretty nifty …
Since decades KDE’s translation and localization framework KI18n
provides a mechanism for marking strings for message extraction and deferred translation,
the I18N_NOOP prepprocessor macros. Those can be very error prone though, so
for KDE Frameworks 5.89 there is now a proposed replacement.
Translation macros
The I18N_NOOP macro differs from the more widely used i18n() function calls in that it
only causes a message to be extracted for translation, but it doesn’t actually perform the
translation. This is useful when the translation isn’t possible yet at this point or when
there are many possible messages of which only very few are actually needed at runtime.
Therefore those macros often appear in static message tables.
This isn’t unique to KI18n, Qt’s translation system has similar macros for example (QT_TR_NOOP etc).
And while this isn’t too bad for a single message, there are many more cases to consider, such as any possible combinations of:
Quantified messages, ie. singular/plural support.
Messages needing a translation context for disambiguation.
Messages containing Kuit markup.
That’s where the macros hit their limits. There we have more than one argument to pass
to the runtime translation call, so what would a macro map to? And do we trust the developer to manually
carry the context string? (see e.g. I18NC_NOOP vs. I18N_NOOP2)
It gets harder and harder to use this correctly the more variants we need to consider, so Albert rightfully wasn’t too happy when I
recently proposed plural variants of those macros.
So what can we do instead?
KLocalizedString
KI18n has another mechanism for deferred translation, KLocalizedString and the various ki18n()
construction functions for it. Unlike the macro approach you cannot accidentally disassociate the
various strings making up a message with this, it’s all tied together by a single object. Still
you can control the time when the actual translation happens, so creating KLocalizedStringinstances
can happen very early in the program flow.
There’s a downside though, creating a KLocalizedString isn’t exactly cheap, it involves memory allocations
and deep copies of the strings. That isn’t a big problem for individual messages, but it does hurt
if you are dealing with larger message tables, with many entries that might never actually be needed
during a program run. The macros avoided those costs.
KLazyLocalizedString
We can have the best of both worlds though! The macro solution goes back to the C++98 days,
and might have been the best we could do at the time, but things have changed.
And that’s where the new KLazyLocalizedString comes in. It’s a simple constexpr container for string literals
needed for translations, and as such can be stored in static data tables. At runtime there’s only one
meaningful thing to do with it, converting it to a KLocalizedString when needed.
Similar to KLocalizedString, KLazyLocalizedString has its own set of construction functions, kli18n().
Unlike their runtime counter-parts those enforce the use of string literals. That is necessary anyway for
message extraction to work, and it avoids having to deal with runtime memory issues at all here.
Migrating away from I18N_NOOP
Let’s look at the following example which illustrates a typical use-case for the I18N_NOOP macro,
a static table containing among other things a message that should be translated at runtime.
This is now no longer constrained to using the same kli18n() variant in every entry though, we could change the second entry
to include a context for example, without having to worry about this when consuming the table entries later:
{MyClass::Bus,kli18nc("the vehicle, not the USB one","Bus")},
It’s also possible to have plural texts in a static message table, the API docs in the
merge request contains an example illustrating that.
Outlook
At this point this is still in review and scheduled for KDE Frameworks 5.89 which is due to be released early January.
The old macros would be deprecated at the same time, so we’ll have a bit of porting ahead of us there.
Two big features landed this week: support for fingerprint readers and the NVIDIA driver’s GBM backend!
Fingerprint support has been in progress for quite some time thanks to Devin Lin, and this week, it was merged for Plasma 5.24! So far we let you enroll and de-enroll fingers, and any of those fingers can be used to to unlock the screen, provide authentication when an app asks for your password, and also authenticate sudo on the command line! It’s really cool stuff.
In addition, a truly titanic number of bugfixes were made this week. We have now addressed most of the issues people have found with Plasma 5.23! Here are the remaining ones which are confirmed and don’t have active work to fix them. Working on these would be a great way for any developers reading along to make a big difference quickly!
When the Desktop context menu is showing both the “Delete” and “Add to Trash” actions (because both are enabled in Dolphin, as it context menu gets synced with the desktop context menu), both once again work (Fabio Bas, Plasma 5.23.2)
The Shift+Delete shortcut to permanently delete items on the desktop once again works (Alexander Lohnau, Plasma 5.23.2)
In the Plasma Wayland session, idle time detection (e.g for determining when to lock the screen to put the computer to sleep) now works more properly (Vlad Zahorodnii, Plasma 5.24)
Keep in mind that this blog only covers the tip of the iceberg! This week it was quite a big tip, but the whole iceberg is still much bigger. Tons of KDE apps whose development I don’t have time to follow aren’t represented here, and I also don’t mention backend refactoring, improved test coverage, and other changes that are generally not user-facing. If you’re hungry for more, check out https://planet.kde.org/, where you can find blog posts by other KDE contributors detailing the work they’re doing.
How You Can Help
Have a look at https://community.kde.org/Get_Involved to discover ways to be part of a project that really matters. Each contributor makes a huge difference in KDE; you are not a number or a cog in a machine! You don’t have to already be a programmer, either. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!
With the amount of time I spent with this particular beast I have to agree. It can be used well of course, but it’s designed in a way that makes it very hard to use properly at all.
Stay in the loop: https://t.me/veggeroblog
If you want to help me make these videos:
Patreon: https://www.patreon.com/niccolove
Youtube: https://www.youtube.com/channel/UCONH73CdRXUjlh3-DdLGCPw/join
Paypal: https://paypal.me/niccolove
My website is https://niccolo.venerandi.com and if you want to contact me, my telegram handle is [at] veggero.
Found in koffice/filters/kocrypt/kocryptimport.cc, not really code, but still funny
// OK. Get this. I'm not going to add 4 lines of code to this thing and
// nest it in another [infinite] loop just so someone can feel warm and
// fuzzy because they found a complicated way to avoid using a perfectly
// fine goto. This is my code and I like the goto just the way it is.
// Deal with it.
Found in qt/src/gui/kernel/qlayoutengine.cpp – also “just” a comment
/*
Do a trial distribution and calculate how much it is off.
If there are more deficit pixels than surplus pixels, give
the minimum size items what they need, and repeat.
Otherwise give to the maximum size items, and repeat.
I have a wonderful mathematical proof for the correctness
of this principle, but unfortunately this comment is too
small to contain it.
*/
From qt/plugins/src/imageformats/jpeg (3.0 beta 4)
if ( name.lower() != "JPEG" )
From kdebase/kate/view/kateviewdialog.cpp (KDE 2.2) (m_search is a QComboBox)
void QLabel::buddyDied() // I can't remember if I cried.
From kdepim/messageviewer/objecttreeparser.h until the end of KDE 4
/**
* The origin and purpose of this function is unknown, the ancient wisdom about it got lost during
* the centuries.
*
* Historicans believe that the intent of the function is to return the raw body of the mail,
* i.e. no charset decoding has been done yet. Sometimes CTE decoding has been done, sometimes
* not. For encrypted parts, this returns the content of the decrypted part. For a mail with
* multiple MIME parts, the results are conecated together. Not all parts are included in this.
*
* Although conecating multiple undecoded body parts with potentially different CTEs together might
* not seem to make any sense in these modern times, it is assumed that initially this function
* performed quite well, but the ancient scrolls got damaged with the ravages of time
* and were re-written multiple times.
*
* Do not use. Use plainTextContent() and htmlContent() instead.
*/
MESSAGEVIEWER_DEPRECATED_EXPORT QByteArray rawDecryptedBody() const<br>
And finally, found in KDAB’s very own GammaRay (from https://github.com/KDAB/GammaRay/blob/master/probe/entry_unix.cpp#L44)
static HitMeBabyOneMoreTime britney;
Happy Halloween, folks.
About KDAB
If you like this article and want to read similar material, consider subscribing via our RSS feed.
Subscribe to KDAB TV for similar informative short video content.
KDAB provides market leading software consulting and development services and training in Qt, C++ and 3D/OpenGL. Contact us.
psifidotos
These are some really cool or obfuscated code snippets for your amusement. We didn’t want to rate them, so the order doesn’t mean anything at all 🙂