Language Selection

English French German Italian Portuguese Spanish

Kde Planet

Syndicate content
Planet KDE - http://planetKDE.org/
Updated: 2 hours 9 min ago

Kate - Initial Rust LSP support landed!

Wednesday 7th of August 2019 07:02:00 PM

Initial support for the rls Rust LSP server has landed in kate.git master. The matching rls issue about this can be found here.

Given I am no Rust expert, I can only verify that at least some operations seem to work for me if the Rust toolchain is setup correctly ;=)

The current experience isn’t that nice as with clangd, for example I get no symbols outline here. What is possible with clangd can be seen in one of my previous posts, video included.

Any help to improve this is welcome. The patch that landed can be viewed here, lend a hand if you know how to fix up stuff!

Technical vision for Qt 6

Wednesday 7th of August 2019 12:05:46 PM

7 years ago, Qt 5 was released. Since then, a lot of things have changed in the world around us, and it is now time to define a vision for a new major version. This blog post captures the most important points that can and should define Qt 6.

Qt 6 will be a continuation of what we have been doing in the Qt 5 series and should as such not be disruptive to our users. But a new major version will give us a higher degree of freedom to implement new features, functionality and better support the requirements of today and tomorrow than we currently can within the Qt 5 series. As described in more detail below, Qt 6 will aim for a large degree of compatibility with the Qt 5 series. We are also still working on new versions of Qt 5, and we’re aiming to bring some of the features that will define Qt 6 in a slightly reduced form to Qt 5.14 and Qt 5.15 LTS. With the feature freeze of Qt 5.14, more R&D focus will shift towards Qt 6, and we’re aiming to have Qt 6.0 ready for a first release by the end of 2020. Before we dive into all the things that will be new, let’s also remember some of the core values of Qt for our users, to define the things we don’t want to change.

What makes Qt valuable to our users?

Qt is a horizontal product that is being used in many different markets. The core values Qt has for our customers and users are:

  1. Its cross-platform nature, allowing users to deploy their applications to all desktop, mobile and embedded platforms using one technology and from a single code base
  2. Its scalability from low-end, single-purpose devices to high-end complex desktop applications or connected system
  3. World-class APIs and tools and documentation, simplifying the creation of applications and devices
  4. Maintainability, stability, and compatibility, allowing to maintain large code bases with minimal effort
  5. A large developer ecosystem with more than 1 million users

A new version of Qt needs to adjust our product to new market demands while keeping the 5 items above at the heart of what we’re doing.

The desktop market is at the root of our offering and is a strong and important market for Qt. It is where most of our users get the first contact with Qt and forms the basis of our tooling. Keeping it healthy and growing is a pre-requirement to be able to grow also in other markets.

Embedded and connected devices are where we have our biggest growth. Touch screens are coming to an exponentially increasing number of devices, but there is strong pressure on the price point of the hardware for these devices. Low-end chipsets, microcontrollers, combined with small to medium-sized touch screens will be used everywhere. Most of those devices will have relatively simple functionality but require polished and smooth user interfaces. Large volumes of such devices will be created, and we need to ensure we can target that space with our offering to be able to live up our scalability promise.

At the same time, user interfaces at the high end of the device spectrum will continue to increase in complexity, containing thousands of different screens and many applications. Merging 2D and 3D elements into one user interface will be common, as will be the usage of augmented and virtual reality.

Elements of artificial intelligence will be more commonly used in applications and devices, and we will need to have easy ways to integrate with those.

The strong growth in the number of connected devices being created as well as much higher requirements on user experience makes it more important for us to focus on world-class tooling to simplify the creation of applications and devices. Integrating UX designers into the development workflow is one of our goals, but there will be many other areas where we need to try to simplify the lives of our users.

Qt 6 will be a new major version for Qt. The main goal with such a new major version is to prepare Qt for the requirements coming in 2020 and beyond, clean up our codebase and make it easier to maintain. As such the focus will be on those items that require architectural changes within Qt and cannot be done without breaking some level of compatibility with Qt 5.x.

Below are some of the key changes we need to make in Qt to make it fit for the next years to come.

Next-generation QML

QML and Qt Quick have been the main technologies fueling our growth over the last years. The intuitive ways of creating User Interfaces using those technologies are a unique selling point of our offering.

But QML, as it was created for Qt 5, has some quirks and limitations. This, in turn, means that there is the potential for significant enhancements, that we are planning to implement with Qt 6. The main changes planned here are:

Introduce strong typing. Weak typing makes it hard for our users to apply large changes to their codebases. A strong type system allows for IDEs and other tools to support our users in this task and dramatically ease the maintenance. Also, we will be able to generate much better-performing code and reduce overhead.

Make JavaScript an optional feature of QML. Having a full JavaScript engine when using QML can complicate things and is an overhead especially when targeting low-end hardware such as microcontrollers. It is however extremely useful in many use cases.

Remove QML versioning. By simplifying certain lookup rules in QML and changing the way context properties work, we can remove the need for versioning in QML. This, in turn, will lead to large simplifications in the QML engine, greatly simplify our workload of maintaining Qt Quick and simplify usage of QML and Qt Quick for our users

Remove the duplication of data structures between QObject and QML
Currently, quite some data structures are duplicated between our meta-object system and QML, degrading startup performance and increasing memory usage. By unifying those data structures, we will be able to cut away most of that overhead.

Avoid runtime generated data structures. This relates to the point before, where many of those duplicated data structures are currently being generated at runtime. It should be perfectly possible to generate most of them at compile time.

Support compiling QML to efficient C++ and native code. With strong typing and simpler lookup rules we can convert QML to efficient C++ and native code, significantly increasing runtime performance

Support hiding implementation details. ‘Private’ methods and properties have been a long-time requirement to be able to hide data and functionality in QML components

Better tooling integration. Our current code model for QML is often incomplete, making refactoring, and detection of errors at compile time difficult to impossible. With the above changes, it should be possible to offer compile-time diagnostics that can compete with C++, as well as much improved refactoring support.

Next-generation graphics

A lot of things have changed in the graphics area since we did Qt 5.0, leading to us having to do significant changes to our graphics stack to stay competitive.

With Qt 5, we used OpenGL as the unified API for 3D graphics. Since then a host of new APIs have been defined. Vulkan is the designated successor of OpenGL on Linux, Apple is pushing for Metal, and Microsoft has Direct 3D. This means that Qt will in the future have to seamlessly work with all those APIs. To make that possible a new layer abstracting the graphics APIs (like QPA for the platform integration) called the Rendering Hardware Interface (RHI) has to be defined. We will need to base all our rendering infrastructure (QPainter, the Qt Quick Scenegraph, and our 3D support) on top of that layer.

The set of different graphics APIs also leads to us having to support different shading languages. The Qt Shader Tools module will help us to cross-compile shaders both at compile and at runtime.

3D is playing a more and more important role, and our current offering doesn’t have a unified solution for creating UIs that contain both 2D and 3D elements. Integrating QML with content from Qt 3D or 3D Studio is currently cumbersome and causes some performance overhead. In addition, it is impossible to sync animations and transitions on a frame by frame level between 2D and 3D content.

The new integration of 3D content with Qt Quick is aiming to solve this problem. In this case, a full new renderer will allow rendering 2D and 3D content together and support arbitrary nesting between the two. This will turn QML into our UI definition language for 3D UIs and remove the need for the UIP format. We will provide a technology preview of the ‘new’ Qt Quick with 3D support already with Qt 5.14, more information will come in a separate blog post.

Finally, the new graphics stack needs to be supported by a decent pipeline for graphical assets, that allows preparing those at compile time for the target hardware and use cases in question. Convert PNG files to compressed textures, compile many of them into texture atlases, convert shaders and meshes into optimized binary formats and more.

We also aim to bring a unified theming/styling engine to Qt 6, which will allow us to get a native look & feel on Desktop and mobile platforms to both Qt Widgets and Qt Quick.

Unified and consistent tooling

Our graphical tooling to create User interfaces has been split into two with Qt 3D Studio and Qt Design Studio. Additionally, Qt 3D Studio is slightly disconnected from the rest of Qt leading to quite some duplicated efforts.

We will unify those by merging the required functionality from Qt 3D Studio back into Design Studio. Design Studio shares a lot of code and the application/plugin framework with Qt Creator allowing for a great design experience and giving us the tools to bridge the gap between designers and developers.

The Design tooling also needs good integration with content creation tools such as Photoshop, Sketch, Illustrator, Maya, 3D Max, and others.

The developer tooling needs a lot of focus and attention so that we can offer the best in class support for C++, QML, and Python. A unified tooling offering also implies that developers can easily use the design functionality from within Qt Creator and that UX designers can benefit from features of the developer tooling such as compiling a project or on-device testing.

QMake as the build system used in Qt 5 has lots of quirks and limitations. For Qt 6, we aim to use CMake as a standard 3rd party build system to build Qt itself. CMake is by far the most widely used build system in the C++ world, and better integration with it is sorely needed. We will continue to support our users on QMake, but not develop it further or use it to build the Qt framework itself.

Enhancing our C++ APIs

C++ has changed a lot over the last years. While we had to base Qt 5.0 on C++98, we can now rely on C++17 for Qt 6. This implies that C++ offers a lot more functionality out of the box that wasn’t available when we did Qt 5. Our goal with Qt 6 has to be to better integrate with this functionality, without losing backward compatibility.

For Qt 6, we aim to make some of the functionality introduced with QML and Qt Quick available from C++. We work towards introducing a new property system for QObject and related classes, integrate the binding engine from QML into the core of Qt and make it available from C++. The new property system and the binding engine will lead to a significant reduction in runtime overhead and memory consumption for bindings and make them accessible for all parts of Qt, not only Qt Quick.

Language support

With Qt 5.12, we introduced support for Python, and we also added the browser as a new platform through Qt for WebAssembly. Keeping and further extending that cross-platform focus will be an important part of the Qt 6 series after 6.0 has been released.

Compatibility with Qt 5 and incremental improvements

Compatibility with older versions is extremely important and is a major requirement when we develop Qt 6. There are billions of lines of code written using our framework and any incompatible change we do will thus have a cost for our users. Furthermore, the more work the change to Qt 6 requires from our users the slower the adoption will be, which leads to more cost on our side to maintain the last version of Qt 5.

As such, we should aim to avoid breaking Qt in a way that triggers compile-time or runtime errors in our users’ codebase. If we must break compatibility, a compile-time error is preferable over a silent breakage at runtime (as those are much harder to detect).

While we do need to remove certain deprecated parts of Qt, we need to ensure that our users have the functionality they require. That implies that key functionality, such as Qt Widgets and other parts used by a large portion of our users, will, of course, stay available.

We are planning for many incremental improvements to our core classes and functionality that we could not do in the Qt 5 series. The aim is to keep full source compatibility, but as we can break binary compatibility with Qt 6, we can do quite a lot of cleanups and improvements that couldn’t be done within Qt 5.

Nevertheless, we need to move forward, and some house cleaning is required with Qt 6. We will remove most functionality (functions, classes or modules) that have been deprecated in Qt 5. This house cleaning will help free up our developers’ time in the longer term and allow us to have more focus on the maintained and current codebase.

Porting away from those deprecated parts does however need to be as simple as possible and our users can ideally do this incrementally using Qt 5.15 LTS. Our goal should be that Qt 6 is compatible enough with Qt 5.15 LTS so that one can easily maintain a large code base that can compile against both versions at the same time.

Marketplace & technical product structure

In addition to improving the Qt framework and tools, we aim to create a new marketplace for components and development tools. The marketplace will be focused on our direct users developing and designing applications and embedded devices, not targeted at consumers. As such it will be a central rallying point for the Qt ecosystem. It will give 3rd parties a place to publish their additions to Qt, allowing for both free and paid content.

Qt has been growing a lot over the last years, to the point where delivering a new version of it is a major undertaking. With Qt 6 there is an opportunity to restructure our product offering and have a smaller core product that contains the essential frameworks and tooling. We will use the market place to deliver our add-on frameworks and tools, not as a tightly coupled bundle with the core Qt product. This will give us additional flexibility on when and how we deliver things and allows us to decouple release schedules for some add-ons.

Give us your feedback and get involved

The technical vision will evolve further until the first release of Qt 6. While I believe that this document captures many of the most important points for the next version of Qt it is certainly not complete. If you have any further ideas, please get involved in the development of Qt 6 and discussions around it through Qt’s open governance model.

The post Technical vision for Qt 6 appeared first on Qt Blog.

KDevelop 5.4 released

Tuesday 6th of August 2019 10:00:00 AM

KDevelop 5.4 released

We are happy to announce the availability of KDevelop 5.4 today featuring support for a new build system, a new scratchpad feature, analyzer support from Clang-Tidy plus a bunch of bug fixes and wee improvements.

Meson

Projects using the new rising star in the build system scene, Meson, can now also be managed with KDevelop, thanks to the work of Daniel Mensinger.

Current features are:

  1. Native support for Meson projects (configuring, compiling, installing)

  2. Support for KDevelop code autocompletion (plugin reads Meson introspection information)

  3. Initial support for the Meson rewriter: modifying basic aspects of the project (version, license, etc.)

Support for adding / removing files from a build target will follow in future releases of KDevelop.

Scratchpad

Thanks to the work of Amish Naidu there is now a tool to keep "scratches" of code or text to experiment or quickly run something without the need to create a full project.

The plugin adds a new tool view, which maintains a list of your scratches which you can compile and run. The data from scratches is managed and stored by KDevelop internally but is presented as regular documents in the editor giving all the editing convenience of e.g. code-completion and diagnostics. Commands used to run the scratches are saved for each scratch, while new scratches are pre-set with the last command used for that file type.

Clang-Tidy

The plugin for Clang-Tidy had been developed and released independently so far, but starting with version 5.4 is now part of KDevelop's default plugins. Learn more about the plugin on Friedrich Kossebau's blog.

C++

More work was done on stabilizing and improving our C++ language support, which uses a Clang based backend. Notable fixes include:

  • Add working directory to clang parser. (commit. code review D22197)

  • Clang Plugin: Report some problems from included files. (commit. code review D18224)

  • Make it possible to select -std=c++2a for our language support. (commit)

  • Rename c++1z to C++17. (commit)

  • Clang CodeCompletion: No auto-completion for numbers. (commit. code review D17915)

  • Add assistant to generate header guards. (commit. code review D17370)

PHP
  • Always set maximum file size for internal parse job. (commit)

  • Bypass the 5 MB maximum file size limit for the phpfunctions.php internal file. (commit)

  • Fix linking with ld.lld. (commit)

Python

The developers have been concentrating on fixing bugs, which already have been added into the 5.3 series.

There are no new features compared to 5.3.

Other Changes
  • [Documentation] Set size policy of providers combobox to AdjustToContents (commit)

  • Contextbrowser: Remove 'separated by only whitespace' possibility for showing the problem tooltip. (commit)

  • Contextbrowser: Minor improvement to tooltip showing behavior. (commit)

  • CMake plugin: Also show an error message if the CMake configuration becomes invalid due to a change, and add an instruction to reload the project manually. (commit)

  • CMake plugin: Show a message box if configuration fails. (commit)

  • Projectfilter: Include .clang-format by default. (commit)

  • Add a predefined clang-format custom script formater. (commit)

  • Fix code completion for nameless structs/unions with the same member. (commit. fixes bug #409041. code review D22455)

  • Support newer kdebugsettings .categories file format. (commit)

  • Show session name in the Delete Session confirmation dialog. (commit. code review D22456)

  • Remove invalid check from test_projectload test. (commit. code review D22350)

  • Document tree view close on middle button. (commit. code review D22160)

  • Follow KTextEditor changes for hidpi rendering of icon border. (commit)

  • Note visibilty tag also with signature of friend-declared method. (commit)

  • Guard against crashes when IStatus object gets destroyed at bad times. (commit)

  • Attempt to fix a crash on shutdown. (commit)

  • Astyle: support the system astyle library. (commit. code review D17760)

  • Renovate kdevelop bash completion file. (commit)

  • Fix deadlock exception in FileManagerListJob. (commit)

  • DVCS Branch Manager with filtering and sorting proposal. (commit. code review D20142)

  • Also find clang include path based on runtime libclang library path. (commit)

  • TestFile: On destruction, close associated document if open and stop the background parser. (commit. code review D18567)

  • CMake: discover more unit tests. (commit. fixes bug #405225. code review D19673)

  • Be less restrictive with failures while searching for LLVM. (commit)

  • Allow the maximum file size of parse jobs to be configurable. (commit)

  • Optimize CMakeBuildDirChooser::buildDirSettings(). (commit. code review D18857)

  • [Sessions Runner] Use icon name. (commit. code review D19159)

  • Don't eat the backspace event when no alt modifier is set. (commit)

  • "Reparse Entire Project" action for the ProjectController. (commit. code review D11934)

  • Introduce QuickOpenEmbeddedWidgetCombiner. (commit)

  • Add 'back' to QuickOpenEmbeddedWidgetInterface. (commit)

  • Update documentation: the keyboard shortcuts use ALT not SHIFT. (commit)

  • Fix up/down keyboard navigation for 'Show documentation' links. (commit)

  • Lock duchain in AbstractIncludeNavigationContext::html. (commit)

  • Don't crash when background listing outlasts file manager list job. (commit)

  • Don't crash when project is closed before it was fully opened. (commit)

  • Make sure we use the same compiler settings as the project is by default. (commit. code review D11136)

  • Debugger plugin fixes. (commit. code review D18325)

  • Kdevelop-msvc.bat finds VS-2017 based on a registry key on Windows. (commit. code review D17908)

  • CMakeBuildDirChooser: avoid calling deprecated KUrlRequester::setPath(). (commit. code review D18856)

  • Flatpak+cmake: put the cmake build directories into .flatpak-builder. (commit)

  • Allow KDEV_DEFAULT_INSTALL_PREFIX specify a default install prefix. (commit)

  • Flatpak: Improve runtime title. (commit)

  • Adapt indentation mode after a new project was opened. (commit)

  • Flatpak: Fix listing runtimes. (commit)

  • Workaround the bug found by ASan, which can be seen on FreeBSD CI. (commit. code review D18463)

  • Properly cleanup FileManagerListJob when folder items are deleted. (commit. fixes bug #260741)

  • Provide debugger name and pid when registering a debugger to DrKonqi. (commit. code review D18511)

  • Support for indent-after-parens astyle option. (commit. code review D18371)

  • Fix bug 389060 (Heaptrack analysis keeps firing /usr/bin/plasmoidviewer). (commit. fixes bug #389060. code review D15565)

  • Contextbrowser: Ability to show combined problems and decl tooltip. (commit. code review D18229)

  • Properly display argument names of template functions. (commit. code review D18218)

  • Show size and alignment information in tooltips for typedef or alias. (commit. code review D18097)

  • GrepView: Extend default file extensions to search. (commit. Implements feature #402207. code review D17892)

  • Fix crash in documentation view. (commit. fixes bug #402026)

  • [clang-tidy] Fix context-menu crash for files not in a project. (commit. fixes bug #401917)

  • Polish Flatpak integration. (commit)

  • Don't add 'override' specifier for non-modern project settings. (commit. fixes bug #372280. code review D16773)

  • [clang-tidy] Disable/Block Run actions in projects without buildsystem manager. (commit)

  • Add VcsAnnotationItemDelegate, for control of rendering and tooltip. (commit. code review D8709)

  • Qmljs: Update qmljs from QtCreator v4.7.2. (commit)

  • LoadedPluginsDialog: Fix initial size. (commit)

  • Place cursor after opening brace for function implementation. (commit. code review D16386)

  • Replace leading typed text when completing function implementation. (commit. fixes bug #384710. code review D16326)

  • Fix crashes when document gets destroyed directly after load. (commit)

  • Prevent QWebEngine from overriding signal handlers. (commit. code review D16188)

  • Add missing break in QmlJs code completion. (commit)

  • CMake: fix missing addition of policies to documentation index. (commit. code review D15882)

  • Create action to jump to the current execution line in debug mode. (commit. Implements feature #361411. code review D14618)

  • Fix segfaults in OutputWidget. (commit. fixes bug #398615. code review D15326)

  • Fix double delete bug in OutputWidget. (commit. code review D15241)

  • Cleanup Perforce test case, and thereby its output a little. (commit. code review D14959)

Get it

Together with the source code, we again provide a pre-built one-file-executable for 64-bit Linux as an AppImage. You can find it on our download page.

The 5.4.0 source code and signatures can be downloaded from download.kde.org.

Should you find any issues in KDevelop 5.4, please let us know on the bug tracker.

kossebau Tue, 2019/08/06 - 12:00 Category News Tags release

Interview with Ray Waysider

Tuesday 6th of August 2019 09:09:49 AM
Could you tell us something about yourself?

I’m uncomfortable with this question from which you may surmise that I’m quite introverted or that I’m conscious of my tendency to overshare. Both are true. I’m a white, heterosexual male but I do keep bees, so…

Do you paint professionally, as a hobby artist, or both?

Mostly as a hobby unfortunately. My day job is graphic design so I can only paint in the evenings and at weekends but I’d love to spend more time doing illustration. One day I’d like to illustrate a children’s book.

What genre(s) do you work in?

I don’t consciously work within genres. I guess I’m influenced by fantasy, cartoons, horror…I’m not over serious or precious about art. Most of what I do is rather light-hearted (though I do put a serious amount of work into it). I do enjoy dark humour which may be evident in some of my work. I did work as an artist in the games industry for a few years but that was a long time ago when game characters were sixteen by thirty two pixel sprites so really before game art had the chance to develop into what it is today but I do enjoy looking at all the game art on Artstation… check it out if you’re into elfies.

Perhaps If I’d been fanatical about a particular genre I’d have devoted the work and effort into developing a style that would fit that genre and been more successful but I have more of a generalist approach, taking influences in an eclectic way from anything that grabs my attention.

I’m not snobby or judgemental about art. I find pleasure in all genres, in fine art and popular culture though I do find the animé/manga style of depicting highly sexualised bodies with prepubescent looking faces morally troubling to say the least..

Whose work inspires you most — who are your role models as an artist?

Earliest influences were definitely cartoons, Disney, Warner Bros etc. Then comic books Marvel, DC then album art of the seventies and eighties – people like Roger Dean and Hypgnosis. This sparked an interest in surrealism – Dali, Magritte, Khalo. From there a general interest in art from the Renaissance to Dada. I’m as happy studying Goya’s etchings as I am getting into Tracy Emin’s bed.

Lately I’m into the pulp fiction novel cover art of the 50s but I also admire Illustrators Norman Rockwell, Frazetta, Vallejo and going really old school, Sir John Tenniel, Arthur Rackham and Aubrey Beardsley.

How and when did you get to try digital painting for the first time?

In the 90s, when I bought my first computer but the lack of a tablet was rather limiting. I remember I’d scan pencil drawings and paint over them using the mouse. Drawing with a mouse is like trying to roll a cigarette wearing oily boxing gloves.

What makes you choose digital over traditional painting?

The freedom to adjust just about anything at any stage. Digital painting allows you to be experimental on a piece you’ve invested a lot of time in without fear of ruining it by making mistakes. Also no need to clean the brushes.

How did you find out about Krita?

Through a YouTube review by the excellent Mr Borodante. https://www.youtube.com/user/dante88s

What was your first impression?

JACKPOT!!!!

What do you love about Krita?

The brush engines and interface makes it easy to edit the brushes. The perspective tools (assistants) are really well designed for artists. I also like how customisable the colour selector is. The multibrush tool is great for rotational symmetry and the wrap-around mode is perfect for creating tiling patterns. Honestly I like pretty much everything!

What do you think needs improvement in Krita? Is there anything that really annoys you?

I’d love it if you could specify which perspective guide the brush follows more easily. Sometimes if I have guides running at similar angles it snaps to the wrong one. I can disable the one I don’t want, but not as easily as I’d like.

What sets Krita apart from the other tools that you use?

It’s free (obviously) but apart from that it’s also a very intuitive program. So rich in features and it’s easy to set it up to your own personal taste. I have Photoshop installed on my PC as well as Krita but I just find Krita so comfortable to use and so capable of doing anything I want that I’ve hardly used Photoshop since I installed Krita.

If you had to pick one favourite of all your work done in Krita so far, what would it be, and why?

It’s usually my last piece, which right now is a painting of a character called Ambrose because on this occasion the finished result is something like what I was originally aiming at when I first conceived the piece. Also people have commented saying it made them feel uncomfortable which pleased me immensely.

What techniques and brushes did you use in it?

I don’t use many brushes. Mostly I use a basic brush with pressure sensitive opacity, varying the size with a button on my tablet (I use a GAOMON PD1560 screen monitor). I use the blending brush sparingly and sometimes the soft round airbrush particularly for atmospheric effects. I got the initial reference for the pose in this painting using an android app called easy poser but this was supplemented by quite a few reference images from online and some taken on my phone of my own hands and feet. I do mess around with the filter masks a lot. Particularly the colour
adjustment and levels. I also often use a layer set either to multiply or burn to enhance shadows or a layer set to screen or dodge for highlights. I sometimes use a layer set to colour mode to correct or change hues.

Where can people see more of your work?

https://www.artstation.com/rayw

https://www.facebook.com/ray.waysider.5

https://www.instagram.com/raywaysider/

Anything else you’d like to share?

They say you should do one thing everyday that frightens you so I clean my toothbrush in the toilet.

About deprecation of QFontMetrics::width()

Monday 5th of August 2019 09:54:40 PM

With any new version of the Qt toolkit comes some clean-up of its APIs to keep it clean, consistent, and future-proof. Part of this clean-up is to rename API functions to make it more clear what they actually do.

Starting with Qt 5.11, the QFontMetrics::width() function was deprecated. You could still compile code that uses this function, but since it is marked obsolete, you were encouraged to port away from it.

So what is unclear or not consistent about it? The function name and signature suggest that you can retrieve the width of a text string (or single character) taking into account the metrics of a specific font. Such metrics are needed to create widget layouts that automatically adapt to user specified fonts or different system display DPIs.

Reading the API description, the result is actually not the width. The graphics shown at https://doc.qt.io/qt-5/qfontmetrics-obsolete.html#width illustrates that there is a difference between the horizontal advance, i.e. the number of pixels from one character to the next character, and the bounding rectangle width, which is needed to encompass all pixels including so called bearings that can overlap the next or the previous character.

Since it was not clear from the confusingly named function QFontMetrics::width() that it actually returned the horizontal advance, instead of the bounding width, this method is now obsolete. You must port to either QFontMetrics::horizontalAdvance() or QFontMetrics::boundingRect().width().

Please make sure you are aware of the difference, and do not port blindly. I am pretty sure that in most cases QFontMetrics::boundingRect() is what you want, unless you are writing custom text shaping/layouting code. Using the wrong function can cause clipped text or text that suddenly wraps to the next line despite calculating the width that it needs.

Latte bug fix release v0.9.1

Monday 5th of August 2019 07:16:45 AM

Latte Dock v0.9.1   has been released containing important fixes and improvements!


Go get  v0.9.1   from, download.kde.orgor  store.kde.org*
-----* archive has been signed with gpg key: 325E 97C3 2E60 1F5D 4EAD CF3A 5599 9050 A2D9 110E
Fixes:
  • improve: when preview windows left click action is used then for single windows is just activating them without triggering the preview window
  • improve: consider the case when a horizontal and a vertical Latte dock/panel are touching each other and the vertical one is in "isBusy" desktop background case, in such case the horizontal view is also changing to "isBusy" state
  • fix: blurred icons for items size that should not be blurred e.g. 48px and >=64px
  • fix: geometries calculation under !compositing environment
  • fix: forward pressed/released event to applets even when parabolic effect is enabled. The issue was pretty obvious with lock/logout plasma applet
  • fix: update progress badge properly
  • fix: tasks icons pixelization when are dragged
  • fix: wayland, show preview window for grouped tasks when clicked

In Latte horizontal and vertical panels when both are using Smart Coloring mechanism are informed if the vertical panels are in Busy state (when the underlying desktop background is busy enough to require the panel background to be shown because with full transparency the contrast is not enough). In such case the horizontals panels are also changing to isBusy state. You can observe the result:

    Before / After
    v0.9.0 / v0.9.1




    Donations:

    You can find Latte at Liberapay if you want to support,    

    or you can split your donation between my active projects in kde store.

    Generating generic questions for calendar activity.

    Sunday 4th of August 2019 10:39:52 AM
    Overview

    One of the tasks for GSoC 2019, was adding multiple datasets to calendar activities, but along with the task I also planned on adding another inprovement to the activity. The activity initially used hardcoded questions and answesr regarding calenders. The dataset for which looked like

    data: [
    {
    "navigationBarVisible" : true,
    "minimumDate": "2018-01-01",
    "maximumDate": "2018-12-31",
    "visibleMonth": 1,
    "visibleYear": 2018,
    "mode": "findMonthOnly",
    "questionsExplicitlyGiven": true,
    "questionAnswers": [
    {
    "question": qsTr("Find the month starting a Thursday and having 28 days"),
    "answer": {"month": [1]}
    },
    {
    "question": qsTr("Find a month starting a Monday and having 31 days"),
    "answer": {"month": [0, 9]}
    },
    {
    "question": qsTr("Find the month between June and August"),
    "answer": {"month": [6]}
    },
    {
    "question": qsTr("Find a month starting a Saturday"),
    "answer": {"month": [8, 11]}
    },
    {
    "question": qsTr("Find a month having 30 days"),
    "answer": {"month": [3, 5, 8, 10]}
    }
    ]
    }, ... and more levels so on
    ]

    So I planned on creating an algorithm that could generate some template questions and answers. The activity has four type of questions depending in the mode. The available modes are

    // findMonthOnly --> For questions based on finding month only.
    // findYearMonthDay --> For questions based on finding year, month and day.
    // findDayOfWeek --> For questions based on finding day of week only.
    // findDay --> For questions based on finding day of a given month and year.

    So, I the algorithm should generate different questions for each type.

    Function to generate date in Range

    The first task is to create a function that would generate a random date within the given range i.e minDate and maxDate.

    function generateRandomYearMonthDay(minimumDate, maximumDate) {
    var minYear = Number(minimumDate.slice(0, 4))
    var maxYear = Number(maximumDate.slice(0, 4))
    var minMonth = Number(minimumDate.slice(5, 7))
    var maxMonth = Number(maximumDate.slice(5, 7))
    var minDate = Number(minimumDate.slice(8, 10))
    var currentYear = minYear + Math.floor(Math.random() * Math.floor((maxYear - minYear + 1)))
    var currentMonth = minMonth + Math.floor(Math.random() * Math.floor((maxMonth - minMonth + 1)))
    var currentDate
    daysInMonths[1] = (isLeapYear(currentYear)) ? 29 : 28;
    currentDate = minDate + Math.floor(Math.random() * Math.floor((daysInMonths[currentMonth - 1] - minDate + 1)))
    return { year: currentYear, month: currentMonth - 1, day: currentDate }
    }
    Function to add offset

    There are some questions which require the user to find a date, a given number of days ahead of the current date. So I created a function to calculate that date.

    function addOffsetToCurrentDate(currentDate) {
    var maxOffset = currentLevelConfig.questionAnswers.maxOffset
    var offset = Math.floor(maxOffset / 2) + Math.floor(Math.random() * Math.floor(maxOffset))
    daysInMonths[1] = (isLeapYear(currentDate.year)) ? 29 : 28;
    offset += currentDate.day
    var answerDate = 1;
    var answerMonth = currentDate.month
    var answerYear = currentDate.year
    while(offset > 0) {
    if(offset - daysInMonths[answerMonth] > 0) {
    offset -= daysInMonths[answerMonth]
    answerMonth++;
    } else {
    answerDate = offset;
    offset = 0
    }
    if(answerMonth > 12) {
    answerYear++;
    daysInMonths[1] = (isLeapYear(answerYear)) ? 29 : 28;
    answerMonth = 0;
    }
    }
    return { year: answerYear, month: answerMonth, day: answerDate, offset: offset }
    }
    Function to generate template questions

    Now there has to be a function that would return the correct question text template as per the mode of the question. So I created a function for that.

    function getTemplateQuestionText(mode, date) {
    var questionText
    if(mode == "findDayOfWeek") {
    questionText = qsTr("What day of the week is on %1?").arg(getDateInLongFormat(date))
    } else if(mode == "findDay") {
    questionText = qsTr("Select day %1?").arg(date.day)
    } else if(mode == "findMonthOnly") {
    questionText = qsTr("Find month number %1").arg(date.month + 1)
    } else {
    if(date.offset) {
    //: The second argument represents the given date in complete format(with complete month name) and the first argument represents the difference in days between given date and answer date.
    questionText = qsTr("Find the date %1 days after %2").arg(date.offset).arg(getDateInLongFormat(date))
    } else
    //: The argument represents the answer date in complete format(with complete month name)
    questionText = qsTr("Find the date %1").arg(getDateInLongFormat(date))
    }
    return questionText
    }
    Function to set question and answer values

    Finally I created a function that would set the correct values of the question and answer variables as per the selected mode.

    if(!currentLevelConfig.questionsExplicitlyGiven) {
    var randomDate = generateRandomYearMonthDay(currentLevelConfig.minimumDate, currentLevelConfig.maximumDate)
    items.score.currentSubLevel = currentSubLevel
    if(currentLevelConfig.mode == "findDayOfWeek") {
    var selectedDate = new Date(randomDate.year, randomDate.month - 1, randomDate.day)
    correctAnswer.dayOfWeek = Number(selectedDate.getDay())
    } else if(currentLevelConfig.mode == "findYearMonthDay" && currentLevelConfig.questionAnswers.maxOffset) {
    correctAnswer = addOffsetToCurrentDate(randomDate)
    randomDate.offset = correctAnswer.offset
    } else {
    correctAnswer = randomDate
    }
    items.questionItem.text = getTemplateQuestionText(currentLevelConfig.mode, randomDate)
    }

    The part of code is executed only if the questions are not explicitly given.

    Dataset contents for template questions

    If the dataset creater wants to use template function then he can define then like

    {
    "navigationBarVisible" : true,
    "minimumDate": "2018-01-01",
    "maximumDate": "2019-12-31",
    "visibleMonth": 10,
    "visibleYear": 2018,
    "mode": "findYearMonthDay",
    "questionsExplicitlyGiven": false,
    "questionAnswers": {
    "length": 5,
    "maxOffset": 90
    }
    },

    where the variable length defines the length of questionSet or the number of questions.

    KDE Usability & Productivity: Week 82

    Sunday 4th of August 2019 04:00:31 AM

    I know I say this a lot… but it’s been yet another big week for KDE’s Usability & Productivity initiative! We also have major features in development–one of which I think will be very popular and I hope to be able to announce it next week. Until then, enjoy this week’s assortment:

    New Features Bugfixes & Performance Improvements User Interface Improvements

    Next week, your name could be in this list! Not sure how? Just ask! I’ve helped mentor a number of new contributors recently and I’d love to help you, too! You can also check out https://community.kde.org/Get_Involved, and find out how you can help be a part of something that really matters. You don’t have to already be a programmer. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

    If you find KDE software useful, consider making a tax-deductible donation to the KDE e.V. foundation.

    digiKam 6.2.0 is released

    Sunday 4th of August 2019 12:00:00 AM

    Dear digiKam fans and users, after the second digiKam 6 release published in April 2019, we received lots of user feedback to consolidate this important stage of this project started 2 years ago. We are proud to quickly announce the new digiKam 6.2.0, as maintenance version. New Camera Supported by Raw Files Engine digiKam try to be the most powerful with all files provided by digital camera. Raw files support is a big challenge.

    kate-editor.org Update

    Saturday 3rd of August 2019 06:48:00 PM

    Like my personal homepage cullmann.io, I ported the kate-editor.org website to the Hugo framework.

    The new website uses zero cookies (yes, no stupid cookie question) and no kind of analytic software. It should be self-contained, too. No external resources that will leak your data to e.g. Google are requested.

    But more important: unlike before, the website content will be fully hosted in a git repository on KDE infrastructure.

    The current intermediate location is on invent.kde.org/websites/kate-editor-org.

    Before, the KDE sysadmin team just got access to a backup of the WordPress instance.

    The new website contains an import of all old pages & posts. I hopefully preserved the old URLs, but there might be some minor glitches for some older posts that still need fixing.

    Some pages still have broken markup, that needs some fixes, too.

    But all-in-all the import of the WordPress content did work really well.

    Some nice step-by-step description how to do such a port can be found in the “Moving 18 years of this personal blog from Wordpress to Hugo” post.

    If you want to contribute, feel free to send me some patch or merge request ;=)

    As a simple template for a new post, take a look at the sources of this one:

    --- title: kate-editor.org Update author: Christoph Cullmann date: 2019-08-03T20:48:00+02:00 --- Like my personal homepage [cullmann.io](https://cullmann.io), I ported the [kate-editor.org](https://kate-editor.org) website to the [Hugo framework](https://gohugo.io/). ...

    The date is important, no stuff in the future is visible on the real web server. You can hide stuff from publishing by adding draft: true to the header information. The server.sh script will still show such things on your local machine.

    Sprint ahoy

    Friday 2nd of August 2019 03:28:38 PM

    Well, I did manage to get some work done during the start of the week cause after that it was just dripping nose and back to back headaches along with a sore throat for around the next 3 days, and I also had to prepare for Krita sprints happening next week.

    Krita 4.2.5 Released

    Friday 2nd of August 2019 11:43:32 AM

    We found that Krita 4.2.4 still had a bug handling shortcuts when certain tools were active. We’ve worked hard to fix that bug as quickly as possible, and as a consequence, we’re releasing Krita 4.2.5 today. Everyone is urged to update to this new release.

    Bugs Fixed
    • Fix an assert in the transform tool when working with a tablet and touch
    • Fix continued transformation in the transform tool
    • Fix updates in the transform tool
    • Show the publication time in the welcome page news ticker in the user’s preferred short date/time format
    • Fix using the tangent-normal brush when the canvas is rotated or mirrored (BUG:404408)
    • Make it possible again to create new palettes and save them in the resource folder, instead of the current document (BUG:410137)
    • Make Krita not gobble up all available memory when loading a JPG file with specific metadata (BUG:410242)
    • Constrain assistant editors to the viewport, so they can always be manipulated
    • Make sure Krita stores changes to brush presets in the current session by default (BUG:410463)
    • Remove an assert that could be triggered when opening the first image in a session
    • Update the version of the default input settings profile, so the rotate/zoom action will be activated even if the user already had a local kritadefault.profile file
    • Fix a crash on using the move tool while the image is being opened (BUG:398968)
    • Make sure the painting tools don’t block anymore (BUG:409968,408826,409275)
    • Make the shortcut handling system more tolerant when shortcuts overlap (BUG:409968)
    • Fix a crash in the transform tool
    • Make the transform tool and the move tool more responsive
    Download Windows

    Note for Windows users: if you encounter crashes, please follow these instructions to use the debug symbols so we can figure out where Krita crashes.

    Linux

    (If, for some reason, Firefox thinks it needs to load this as text: to download, right-click on the link.)

    OSX

    Note: the gmic-qt is not available on OSX.

    Source code md5sum

    For all downloads:

    Key

    The Linux appimage and the source .tar.gz tarball are signed. You can retrieve the public key over https here: 0x58b9596c722ea3bd.asc. The signatures are here (filenames ending in .sig).

    Support Krita

    Krita is a free and open source project. Please consider supporting the project with donations or by buying training videos or the artbook! With your support, we can keep the core team working on Krita full-time.

    Qt Creator 4.10 RC released

    Friday 2nd of August 2019 09:12:14 AM

    We are happy to announce the release of Qt Creator 4.10 RC !

    The prebuilt binaries for this release are based on a Qt 5.13.1 snapshot, which should take care of regular crashes that some of you experienced with the earlier Beta releases.
    For more details on the 4.10 release, please have a look at the blog post for Beta1 and our change log.

    Get Qt Creator 4.10 RC

    The opensource version is available on the Qt download page under “Pre-releases”, and you find commercially licensed packages on the Qt Account Portal. Qt Creator 4.10 RC is also available under Preview > Qt Creator 4.10.0-rc1 in the online installer. Please post issues in our bug tracker. You can also find us on IRC on #qt-creator on chat.freenode.net, and on the Qt Creator mailing list.

    The post Qt Creator 4.10 RC released appeared first on Qt Blog.

    The Inside View: How Krita is Developed

    Friday 2nd of August 2019 08:20:47 AM

    In this post, I want to share with you how we’re developing Krita. Of course, the post’s title is already nonsense, since there’s no “inside” and “outside” when it comes to Krita. Krita is a free software project, and as open as it can be. If you use Krita, report issues, help people who are using Krita, show off your work, well, you’re already part of this community that makes life better for everyone who uses Krita.

    That said, you might’ve been using Krita for years, and still being a bit vague on who develops this application, how that’s organized, why people are spending time on it and what resources we have for developing Krita.

    Who are the developers

    Until 2005, all Krita development was done by volunteers, in their spare time. That year, Google started the Google Summer of Code program. Then we had students working full-time on Krita for three months; mentored by the existing volunteer team.

    For me, Krita maintainer since 2003, there was nothing more satisfying than working on Krita. In contrast with my day jobs, we actually started releasing in 2004!

    But it was clear that there was only so much that could be done by a purely volunteer, unsponsored team. Time is money, money buys development time, so since 2009, we’ve tried to sponsor development beyond Google Summer of Code. Some argued that this would kill the volunteer element in the community, but we’ve never seen a trace of that.

    So, these days, there are four people working full-time on Krita. There is Dmitry, since 2012, sponsored by the Krita Foundation through donations and fund raisers.

    Me, Boudewijn, has been funded working on Krita through a combination of donations, special projects for third-party organizations and, since 2017, the income from the Windows Store. I don’t do just coding, but pretty much all project management.

    Agata and Ivan started working full-time on Krita this year, and are funded through the income from the Steam Store. Agata is well-known as Tiar and has been supporting other Krita users for ages. Ivan has been around in the Krita community for more than ten years, first producing things like shortcut cheat sheets, and completing a Google Summer of Code project successfully in 2018.

    This year, there are four Google Summer of Code students working on Krita: Sharaf, Tusooa, Kuntal and Alberto.

    Any given week, there are a dozen people committing to Krita, so only a small part of the development community is funded. There are volunteers from many places in the world, some developing just one feature they need and asking for it to be included in Krita, others providing smaller and bigger features, bug fixes and UX improvements.

    The group of volunteers is more or less fleeting: people often come and go, but there are people who have been around for a long time. Wolthera manages our manual, with help from Raghukamath. Scott maintains the website and helps out with UX design and GUI polish. Anna codes complicated stuff, like the gamut mask feature or more recently, the hardening of the saving code.   Ahabgraybeard helps other users on the forum, Timothee designs icons, Maria makes release videos, Irina handles the bi-weekly artist interviews.

    Of course, this is who were are… Developers, manual writers, artists. It’s also important to realize what there isn’t: there isn’t a quality assurance team, so we’re counting on our users to test the nightlies and the beta releases to find issues. There isn’t a user support team, so we’re again counting  on our users to help each other out. We don’t have customer support or a marketing department. There isn’t an office, and there isn’t a legal department.

    How’s development organized

    Our main communication channel is irc, internet relay chat. Yes, it’s old-fashioned compared to something like Matrix, but it works in a timely and dependable way.

    We have a weekly meeting at 14:00 CE(S)T every Monday. The meeting doesn’t take more than an hour, and we’ll discuss various topics and make a report. The reports are archived on files.kde.org.

    New code can be put up for review on KDE’s gitlab instance, invent. Everyone with a KDE identity account can fork Krita on gitlab and create pull requests.

    Right now, all full-time developers are working on fixing bugs for Krita 4.3, but volunteers can choose what they work on to a very large extent. The only limitation is that it must fit within Krita’s vision.

    And next week we’ll have our 2019 Krita Sprint. We try to get together at least once a year. Not just the Krita contributors, but we also invite artists to our sprints. The only way to learn how people use our application is by watching them work! Sprints are intense, but also lots of fun.

    What are Krita’s resources

    Financially, we’ve got several sources of income and support. The donation page you see after downloading Krita brings in about 2000 to 2700 euros a month; the median donation is 10 euros. This goes to the Krita Foundation. The yearly fundraiser brings in between 20,000 and 40,000 euros, and this also goes to the Krita Foundation. The income from the special projects, like the HDR project, is variable, but that, like the income from the Windows Store and the Steam Store, goes to a separate company for tax reasons. All of this is around 6,000 to 10,000 euros a month, and growing.

    As you can see, nobody who is working full-time on Krita is getting filthy rich, but it does make it possible for the four full-time developers to work on a project that’s really worth it

    Our non-financial resources are provided by the wider KDE community:

    • continuous integration system (Jenkins)
    • the binary factory that creates nightly builds for Windows, Linux and macOS and releases for Windows and Linux
    • these websites krita.org and our documentation site docs.krita.org
    • mailing list (which doesn’t see so much usage anymore, but if you go back to 2003, you’ll find many interesting discussions)
    • the forum
    • bug tracker

    And of course a broad community full of people who are experts on C++, CMake, Qt and community management. And a big translator community.

    Future development

    While the developers and volunteers communicate mostly online, we occasionally get together in person with sprints. We discuss Krita of course, but we also socialize and just have a fun time! Next week we are meeting in the Netherlands for one of these sprints. We are going to be discussing many topics such as the future of Krita as well as taking a side trip to a local museum. Many of our developers are artists as well, so there is sure to be a lot of sketch pads and painting flying around.

    if this sounds something you might want to be a part of, we are always welcoming new contributors. There are a lot of different areas that we have people volunteering and developing, not just hardcore programmers. We have a getting involved section that outlines some of the areas such as testing and creating brush resources. We also have a lot of documentation on building krita and being involved with our updated contributor’s manual.

    June/July in KDE Itinerary

    Thursday 1st of August 2019 05:00:00 PM

    Another two busy months have passed since the last bi-monthly summary on KDE Itinerary’s progress. Here are the highlights.

    New Features
    • The alternative journey selection for unbound or delayed train reservations finally works for the whole journey rather than just one the selected journey segment, and is now also able to properly save a new journey with more or less segments than the previously selected one. It is now also possible to search for earlier or later journeys if the corresponding backends support that.

    • In order to know when you have to look for an alternative journey, about to be missed connections are now highlighted in the timeline, based on available real-time data.

    Real-time delay information with highlighting about to missed connections.
    • The navigation options offered per location also got a bit smarter. The “navigate to” action now uses the assumed location from the itinerary as a starting point for future elements, rather than the current location. This means that you can look at how to get to your hotel from the train station, rather than getting a route from your home to the hotel directly, for example. (On Android, this is only available with OsmAnd, not with the system map.)

    • At arrival locations, the navigation actions now also offer a real-time departure schedule for local public transport. This allows you to check how much you need to hurry to catch the next bus or train home from the airport for example, as a stop-gap measure until the app is smart enough to know where “home” is and offer the appropriate journey directly.

    • Back fields of Apple Wallet passes are now also viewable in the app, not just in KMail.

    Infrastructure Work

    There’s quite a few interesting changes in the data extractor engine and its tooling too:

    • One of the biggest changes is the newly added support for vector barcodes in PDF files, see the post on this subject for details.

    • The airport disambiguation got improved for cases of very short distances and for ambiguities on both ends of the journey. The recent Plasma sprint in València provided the following example: A flight from “Frankfurt” to “Valencia” ends up with FRA and HHN as candidates for the departure airport, and VLC and PPN for arrival. Based on the duration of the flight we can exclude PPN, as it wouldn’t be a viable option for either departure location candidate. We also know that FRA and HHN are in the same timezone, so that we can ultimately determine the timezones for the entire flight.

    • The UIC 918.3 train ticket parser now supports ticket layouts other than the European standard ones (RCT2). That’s a somewhat ASCII-art like representations of tickets that can be present in the large UIC 918.3 Aztec barcodes. The local transport operator in Nürnberg is using such barcodes for example, as encountered during the recent multi-sprint there. To support this, KItinerary Workbench is now also able to visualize UIC 918.3 ticket layouts.

    KItinerary Workbench showing the RCT2 ticket layout found inside a UIC 918.3 barcode on an ÖBB ticket.
    • Custom extractor scripts got new convenience API to reduce the amount of boilerplate code needed to create new reservation objects, as well as access to more properties of iCalendar input objects.

    • KItinerary Workbench now has a XPath evaluator with result highlighting in its DOM view, to help debugging XPath queries in custom extractor scripts. HTML to plain text conversion in the extractor now correctly skips stylesheet elements.

    KItinerary Workbench highlighting the nodes selected by a given XPath query in the DOM tree.

    KPublicTransport, the frameworks providing access to real-time public transport data received several improvements as well:

    • There is now support for handling license and attribution information. While probably one of the more boring features, it’s crucial to be compliant with the Open Data licenses of the source data, and access to that source data is ultimately what enables all the exciting things we build on top. The app will show these information now in the about page, and under the journey and departure views.
    KDE Itinerary showing a list of data sources used for the public transport information.
    • There is ongoing work to make query results accessible incrementally, even if not all backends have responded yet. Initial results are available quicker with this, but it can lead to results changing or reordering as more information come in. The new real-time departure view in the app is already using this.

    • KPublicTransport can now carry address information in its Location data type. Those are not provided by all backends, and hardly ever complete, but it allows the app to augment its knowledge about a station if address information are available.

    • Backends can now have two different location identifier types, typically one backend-specific one and one standardized one (e.g. UIC station codes or IBNRs). This addresses the fact that not every stop or station has one of the standardized identifiers, but we still want to get the standardized identifiers whenever present (as those allow augmentation with Wikidata information, and robust location comparison).

    Fixes & Improvements

    There are also plenty of smaller changes that are noteworthy:

    • Trip grouping in the app now also considers layover time as an additional criteria. A very short time between two elements likely indicates they belong to the same trip.
    • Importing data from Nextcloud/DavDroid works again with recent DavDroid versions. DavDroid changed the way they store custom iCal properties, which we rely on. The new way however is much easier to handle for us, eventually avoiding the dependency on the iCal4j library even.
    • The alternative journey view now shows the number of changes correctly.
    • Day changes on overnight flights are now automatically fixed in post-processing in many cases, as this turns out to be often wrong in the input data.
    • Calendar events generated from restaurant reservations no longer contain empty fields for optional information.
    • New or improved extractors for simplebooking.it, booking.com, easyJet, Travelport Galileo and VGN, based on booking information from the Plasma and KDE Connect sprints, and for Akademy.
    Contribute

    As usual a big thanks to everyone who donated test data, the samples from participants of the Plasma sprint in València resulted in the most extractor engine improvements this time I think :)

    If you want to help in other ways than donating test samples too, see our Phabricator workboard for what’s on the todo list, for coordinating work and for collecting ideas. For questions and suggestions, please feel free to join us on the KDE PIM mailing list or in the #kontact channel on Freenode.

    KDE Connect SMS: Nuremberg Megasprint Part 3

    Thursday 1st of August 2019 03:17:32 PM

    When interacting with other users of KDE Connect, I often notice something funny. People will often talk about how nice it is that they can control their computer from their phone (using the media controls, the mousepad plugin, or several of the others). For me, this has always been a secondary benefit. I use KDE Connect’s presentation plugin for all of my presentations but my primary goal has always been to be able to control my phone from my computer. I hate the phone keyboard, I hate the tiny screen, and I hate having to pull the thing out of my pocket.

    On a daily basis, the number 1 thing I need to do with my phone is send or read SMS. In the United States, SMS is the de facto default communication system. In Europe, I basically assume that anyone I want to communicate with uses WhatsApp. In the US, with one friend I use WhatsApp, with another one friend I use Telegram, and with my family and other friends I use SMS. (Many people use Facebook Messenger but that is still not as widespread).

    Those who have been very carefully following the KDE Connect channels might already know that we have been working on a desktop application which uses KDE Connect to load SMS conversation history and send SMS using the phone. (I have been keeping this under wraps because I know it is our #1 requested feature and I don’t want to tease anyone with a stream of “Oh yes, it’s almost there” half-promises)

    The SMS app started March 2018 at the previous KDE Connect sprint. I arrived in Barcelona with a half-written contacts synchronization plugin and the goal to never touch my phone again. In only a few days, we had the contacts plugin in its current form and the skeleton of an SMS app (based on Qt’s QML chat app tutorial). It could read the display names and avatars from the synchronized contacts and you could use the compose message box to send SMS. There was no message history yet, just some statically-created items in the QML, but everything starts somewhere!

    KDE Connect SMS v0.0

    Around May, Aleix Pol and I were talking about what the interface should look like. We agreed that it should be very “normal”, like every other chat app, so I came up with this fabulous drawing.

    Special thanks to PhotoScan for only being able to export photos with a watermark

    The history of the SMS app has more details than we need for this post. Along the way, the KDE Connect Android app was updated with many content resolvers (and many StackOverflow references) to handle getting the SMS (and MMS) history. Several GUI elements have been “borrowed” from Kaidan. High on my soon-to-do list is move the Kaidan GUI elements which could be used by any other project looking to make a chat interface.

    I am very happy with the current version of the app. I use it regularly and I find it very useful. Though it only has a few features, I have focused on fewer, more-stable features for the initial release. It can:

    • Show a list of conversation currently existing on the phone
    • Show conversation history
    • Send and display SMS
    • Display (not send) plain-text MMS including group messages
    • Understand non-text MMS
    • Update in real-time as more messages are received

    I have left several thing for future releases:

    • Start a new conversation
      • I consider this a less-common usecase than replying to an existing conversation, so I focused on other things
    • Show MMS attachments
      • This requires upgrading the Android interface to read arbritrary attachments and upgrading the GUI to do something with those (like display pictures and offer downloads for everything else)
    • Send MMS
      • The current SMS-sending interface is very basic, so it will probably be significantly modified or even replaced.

    Here is the current version of the SMS app:

    And the corresponding conversation on the phone:

    The SMS app now builds by default when you build KDE Connect so it will be officially released with the next release of KDE Connect. Hopefully I have time to iron out one or two more bugs before then!

    Check out Krita’s Youtube Channel

    Thursday 1st of August 2019 01:55:13 PM

    Even though there is a ton of Krita videos on Youtube, Krita’s own youtube channel was neglected. Until recently! Working together with Ramon Miranda of Muses and Digital Atelier fame, we’re going to publish new videos about Krita regularly. Here’s the first one!

    foss-north call for papers

    Thursday 1st of August 2019 10:13:16 AM

    The summer is flying by and it is already August. The call for papers for foss-north IoT and Security Day is still open for a few more days, so make sure to get your talk in. We are looking for talks touching on connected embedded devices and how to do them securely.

    The foss-north IoT and Security Day will be a one day event, October 21st, in central Stockholm. The venue, WTC, is located right by the central train station, so it is very easy to get there. Tickets will be made available soon. Make sure to save the date!

    Agile On The Beach: my first time

    Wednesday 31st of July 2019 06:41:29 PM

    During 2017 and 2018 I got several interesting references at events like Scale Summit and pipelineconf about an interesting event in the south-west of England about lean, agile and continuous delivery that got my attention. I decided that I could not miss it in 2019.

    2019 edition of Agile On The Beach was the 9th one. The event has gain a good reputation among agilists for being a good mix of great content and relaxed atmosphere in a beautiful environment. This is not surprising for somebody coming from the Open Source space but is not a so common combination within the lean/agile/CD world.

    I bought the tickets and reserved the accommodation on time (months before the event). As you know, I started in MBition in June. My employer was kind enough to make it easy for me to attend. So on July 10th I headed to Falmouth, Cornwall, UK to participate in Agile On The Beach during the following two days, coming back to Málaga on Saturday July 13th.

    I liked the event. I felt like home. Like if I was at Akademy, for instance. There were some outstanding talks, a great atmosphere, talented and experienced attendees, reputed speakers, good organization and nice social activities.  Yes, the trip to get there was long but I had no delays in any of the several planes and trains I had to take (who said British trains are awful?) which allowed me to invest a few hours working on each way.

    The videos has not been published yet. I will add as comments those I recommend you to check.

    Next year the event celebrates the 10th edition. They promised to do something special. If you are in the UK or are willing to invest several hours traveling to a good Lean/Agile/CD event, Agile On The Beach is a great one. But stay tuned, the number of tickets is limited and they are gone several months before the event starts.

    Krita 4.2.4 Released

    Wednesday 31st of July 2019 09:42:15 AM

    We’re releasing Krita 4.2.4 today. The most important fixes are to the shortcut input system and the saving system. Krita 4.2.3 had a bug where a message window would often pop up complaining about a shortcut not being finished properly; this should no longer happen. Anna Medonosova has hardened the saving system even more, especially when closing Krita after initiating a save operation.

    There are some more bug fixes coming soon, and we will release 4.2.5 with those fixes in about two weeks, after the coming Krita sprint.

    Additionally, we implemented a new blending mode inspired by Easy Painttool SAI’s Luminosity/Shine, please help us to test its behavior (BUG:409627).

    Known Issue

    If touch zoom and rotation doesn’t work anymore, please remove your local default.inputrc file. Go to Settings/Manage Resources and press the Open Resource Folder button. Enter the input folder and remove all files in that folder.

    Bugs Fixed
    • Make it possible to use dots in filenames (note that that still might confuse your OS) (BUG:409765)
    • Fix regression on softness sensor on Default Circle autobrush tip (BUG:409758)
    • Clear any leftover points in the line tool on each use so there are no false starts (BUG:408439)
    • Do not reset the opacity to zero when moving more than one shape at a time (BUG:409131)
    • Do not ignore rotation in the bristle brush engine (BUG:384231)
    • Fix cursor drift when using pan/zoom/rotate (BUG:409460)
    • Fix a crash when creating an RGB image after the last used color model was CMYK (BUG:409916)
    • Use Qt’s QImageIO image import/export filter for PPM files instead of our own, broken implementation. (BUG:409714)
    • Fix updating the brush size in the toolbar using shortcuts or drag (BUG:408331)
    • Make generated gradient names translatable (BUG:410034)
    • Fix a crash that could happen when closing Krita after deleting a session (BUG:409909)
    • Fix a bug in the color picker that made it possible for the active foreground color to be transparent
    • Fix a logic error in the Separate Image plugin (BUG:410308)
    • Update the notes for the LargeRGB color profile (BUG:410023)
    • Fix the filename reference for Rec.709 profiles
    • Add a workaround for the KisShortcutsMatcher assert (BUG:408826)
    Download Windows

    Note for Windows users: if you encounter crashes, please follow these instructions to use the debug symbols so we can figure out where Krita crashes.

    Linux

    (If, for some reason, Firefox thinks it needs to load this as text: to download, right-click on the link.)

    OSX

    Note: the gmic-qt is not available on OSX.

    Source code md5sum

    For all downloads:

    Key

    The Linux appimage and the source .tar.gz tarball are signed. You can retrieve the public key over https here: 0x58b9596c722ea3bd.asc. The signatures are here (filenames ending in .sig).

    Support Krita

    Krita is a free and open source project. Please consider supporting the project with donations or by buying training videos or the artbook! With your support, we can keep the core team working on Krita full-time.

    More in Tux Machines

    LWN: Spectre, Linux and Debian Development

    • Grand Schemozzle: Spectre continues to haunt

      The Spectre v1 hardware vulnerability is often characterized as allowing array bounds checks to be bypassed via speculative execution. While that is true, it is not the full extent of the shenanigans allowed by this particular class of vulnerabilities. For a demonstration of that fact, one need look no further than the "SWAPGS vulnerability" known as CVE-2019-1125 to the wider world or as "Grand Schemozzle" to the select group of developers who addressed it in the Linux kernel. Segments are mostly an architectural relic from the earliest days of x86; to a great extent, they did not survive into the 64-bit era. That said, a few segments still exist for specific tasks; these include FS and GS. The most common use for GS in current Linux systems is for thread-local or CPU-local storage; in the kernel, the GS segment points into the per-CPU data area. User space is allowed to make its own use of GS; the arch_prctl() system call can be used to change its value. As one might expect, the kernel needs to take care to use its own GS pointer rather than something that user space came up with. The x86 architecture obligingly provides an instruction, SWAPGS, to make that relatively easy. On entry into the kernel, a SWAPGS instruction will exchange the current GS segment pointer with a known value (which is kept in a model-specific register); executing SWAPGS again before returning to user space will restore the user-space value. Some carefully placed SWAPGS instructions will thus prevent the kernel from ever running with anything other than its own GS pointer. Or so one would think.

    • Long-term get_user_pages() and truncate(): solved at last?

      Technologies like RDMA benefit from the ability to map file-backed pages into memory. This benefit extends to persistent-memory devices, where the backing store for the file can be mapped directly without the need to go through the kernel's page cache. There is a fundamental conflict, though, between mapping a file's backing store directly and letting the filesystem code modify that file's on-disk layout, especially when the mapping is held in place for a long time (as RDMA is wont to do). The problem seems intractable, but there may yet be a solution in the form of this patch set (marked "V1,000,002") from Ira Weiny. The problems raised by the intersection of mapping a file (via get_user_pages()), persistent memory, and layout changes by the filesystem were the topic of a contentious session at the 2019 Linux Storage, Filesystem, and Memory-Management Summit. The core question can be reduced to this: what should happen if one process calls truncate() while another has an active get_user_pages() mapping that pins some or all of that file's pages? If the filesystem actually truncates the file while leaving the pages mapped, data corruption will certainly ensue. The options discussed in the session were to either fail the truncate() call or to revoke the mapping, causing the process that mapped the pages to receive a SIGBUS signal if it tries to access them afterward. There were passionate proponents for both options, and no conclusion was reached. Weiny's new patch set resolves the question by causing an operation like truncate() to fail if long-term mappings exist on the file in question. But it also requires user space to jump through some hoops before such mappings can be created in the first place. This approach comes from the conclusion that, in the real world, there is no rational use case where somebody might want to truncate a file that has been pinned into place for use with RDMA, so there is no reason to make that operation work. There is ample reason, though, for preventing filesystem corruption and for informing an application that gets into such a situation that it has done something wrong.

    • Hardening the "file" utility for Debian

      In addition, he had already encountered problems with file running in environments with non-standard libraries that were loaded using the LD_PRELOAD environment variable. Those libraries can (and do) make system calls that the regular file binary does not make; the system calls were disallowed by the seccomp() filter. Building a Debian package often uses FakeRoot (or fakeroot) to run commands in a way that appears that they have root privileges for filesystem operations—without actually granting any extra privileges. That is done so that tarballs and the like can be created containing files with owners other than the user ID running the Debian packaging tools, for example. Fakeroot maintains a mapping of the "changes" made to owners, groups, and permissions for files so that it can report those to other tools that access them. It does so by interposing a library ahead of the GNU C library (glibc) to intercept file operations. In order to do its job, fakeroot spawns a daemon (faked) that is used to maintain the state of the changes that programs make inside of the fakeroot. The libfakeroot library that is loaded with LD_PRELOAD will then communicate to the daemon via either System V (sysv) interprocess communication (IPC) calls or by using TCP/IP. Biedl referred to a bug report in his message, where Helmut Grohne had reported a problem with running file inside a fakeroot.

    Flameshot is a brilliant screenshot tool for Linux

    The default screenshot tool in Ubuntu is alright for basic snips but if you want a really good one you need to install a third-party screenshot app. Shutter is probably my favorite, but I decided to give Flameshot a try. Packages are available for various distributions including Ubuntu, Arch, openSuse and Debian. You find installation instructions on the official project website. Read more

    Android Leftovers

    IBM/Red Hat and Intel Leftovers

    • Troubleshooting Red Hat OpenShift applications with throwaway containers

      Imagine this scenario: Your cool microservice works fine from your local machine but fails when deployed into your Red Hat OpenShift cluster. You cannot see anything wrong with the code or anything wrong in your services, configuration maps, secrets, and other resources. But, you know something is not right. How do you look at things from the same perspective as your containerized application? How do you compare the runtime environment from your local application with the one from your container? If you performed your due diligence, you wrote unit tests. There are no hard-coded configurations or hidden assumptions about the runtime environment. The cause should be related to the configuration your application receives inside OpenShift. Is it time to run your app under a step-by-step debugger or add tons of logging statements to your code? We’ll show how two features of the OpenShift command-line client can help: the oc run and oc debug commands.

    • What piece of advice had the greatest impact on your career?

      I love learning the what, why, and how of new open source projects, especially when they gain popularity in the DevOps space. Classification as a "DevOps technology" tends to mean scalable, collaborative systems that go across a broad range of challenges—from message bus to monitoring and back again. There is always something new to explore, install, spin up, and explore.

    • How DevOps is like auto racing

      When I talk about desired outcomes or answer a question about where to get started with any part of a DevOps initiative, I like to mention NASCAR or Formula 1 racing. Crew chiefs for these race teams have a goal: finish in the best place possible with the resources available while overcoming the adversity thrown at you. If the team feels capable, the goal gets moved up a series of levels to holding a trophy at the end of the race. To achieve their goals, race teams don’t think from start to finish; they flip the table to look at the race from the end goal to the beginning. They set a goal, a stretch goal, and then work backward from that goal to determine how to get there. Work is delegated to team members to push toward the objectives that will get the team to the desired outcome. [...] Race teams practice pit stops all week before the race. They do weight training and cardio programs to stay physically ready for the grueling conditions of race day. They are continually collaborating to address any issue that comes up. Software teams should also practice software releases often. If safety systems are in place and practice runs have been going well, they can release to production more frequently. Speed makes things safer in this mindset. It’s not about doing the “right” thing; it’s about addressing as many blockers to the desired outcome (goal) as possible and then collaborating and adjusting based on the real-time feedback that’s observed. Expecting anomalies and working to improve quality and minimize the impact of those anomalies is the expectation of everyone in a DevOps world.

    • Deep Learning Reference Stack v4.0 Now Available

      Artificial Intelligence (AI) continues to represent one of the biggest transformations underway, promising to impact everything from the devices we use to cloud technologies, and reshape infrastructure, even entire industries. Intel is committed to advancing the Deep Learning (DL) workloads that power AI by accelerating enterprise and ecosystem development. From our extensive work developing AI solutions, Intel understands how complex it is to create and deploy applications for deep learning workloads. That?s why we developed an integrated Deep Learning Reference Stack, optimized for Intel Xeon Scalable processor and released the companion Data Analytics Reference Stack. Today, we?re proud to announce the next Deep Learning Reference Stack release, incorporating customer feedback and delivering an enhanced user experience with support for expanded use cases.

    • Clear Linux Releases Deep Learning Reference Stack 4.0 For Better AI Performance

      Intel's Clear Linux team on Wednesday announced their Deep Learning Reference Stack 4.0 during the Linux Foundation's Open-Source Summit North America event taking place in San Diego. Clear Linux's Deep Learning Reference Stack continues to be engineered for showing off the most features and maximum performance for those interested in AI / deep learning and running on Intel Xeon Scalable CPUs. This optimized stack allows developers to more easily get going with a tuned deep learning stack that should already be offering near optimal performance.