July 22, 2017

We’re releasing the second beta for Krita 3.2.0 today! These beta builds contain the following fixes, compared to the first 3.2.0 beta release. Keep in mind that this is a beta: you’re supposed to help the development team out by testing it, and reporting issues on bugs.kde.org.

  • There are still problems on Windows with the integration with the gmic-qt plugin, but several lockups have been fixed.
  • The smart patch tool merge was botched: this is fixed now.
  • It wasn’t possible anymore to move vector objects with the mouse (finger and tablet worked fine). This is fixed now.
  • Fixed the size and flow sliders
  • Fixes to saving jpg or png images without a transparency channel

Download

The KDE download site has been updated to support https now.

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.)

A snap image for the Ubuntu App Store will be available from the Ubuntu application store. When it is updated, you can also use the Krita Lime PPA to install Krita 3.2.0-beta.2 on Ubuntu and derivatives.

OSX

Source code

md5sums

For all downloads:

Key

The Linux appimage and the source tarball are signed. You can retrieve the public key over https here:
0x58b9596c722ea3bd.asc
. The signatures are here.

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.

Hey Community!

Long time no see, huh? Yes, I neglected my blog and as such didn't post anything since Akademy 2014... Interestingly this is the last one where my dear Paul Adams held a famous talk. Talk he is referring to in his latest piece. Since his blog aggregation to Planet KDE is broken, I thought it would be a good idea to relay it on my own blog to give it more exposure. It is reproduced below, if you want to read it in its original form, click through the title.

Paul, the mic is yours now!

Retired From KDE, by Paul Adams

Many of you reading this are probably already aware, long-time maintainer of glibc Roland McGrath has recently retired from maintaining that project. Inspired by his words, I wanted to say a few things about why I no longer contribute to KDE; a project I “retired” from some time ago now.

Recently two very good friends of mine, both long-term KDE contributors, inquired if I was going to be attending this year’s Akademy (the annual KDE conference). Neither were particularly surprised when I said I wasn’t.

I was surprised that they asked.

Getting Into KDE

My first experiences of KDE were many moons ago; sometime in the very early 00s I guess. I had installed Linux on an old machine and was not particularly enjoying the desktop experience.

There wasn’t a desktop.

I cannot remember which distro this was. It had come off some magazine’s cover CD. There was X. And the tiling window manager which allowed me to fill my screen with x-term. This, for a long time, was just how I got stuff done. Emacs, Mutt, Lynx and some weird terminal-based MP3 player were my jam.

Some time later I was reading another magazine (Linux Format?) and it had a review of a recent beta of KDE 2. The sources were included on the cover CD. KDE looked kinda nice. Less boxy and purple than the only other *nix desktop I had seen, CDE. Until I finished my undergraduate degree KDE was my go-to desktop.

Getting Deeper

For a while I had reverted to using a tiling window manager and a screenful of x-term. This was just a convenient way for me to get through my PhD and my day job.

During my PhD I was studying Free Software community productivity metrics. I was also working on research into software quality funded by the European Commission. KDE eV (the governance body1 for KDE) was also taking part in that project. At this time KDE was almost ready to release KDE 4. It was an exciting time to get involved.

So I installed whatever the Debian stable KDE desktop (3.1021933933923932) of the time and really enjoyed the experience. Having rediscovered my love for KDE and having met some of the active community, I dived in deeper.

KDE became high on my list of projects to study during my PhD. The community was going through major changes: not only was KDE 4 on its way in, but KDE SVN was on its way out.

Gitting Ready For Change

Around 2006 I discovered Ade de Groot’s tool for visualising contributions to SVN; it was part of the English Breakfast Network3. His version of this tool utilised Python’s SVN bindings to read the repo data. Git instinct told me this tool would work faster if it parsed SVN logs rather than read the repo data through a library. I turned out to be right and this was a formative moment in my career.

I created a generic SVN log parser for use by this visualisation tool and used the same parser for other purposes; mostly other visualisations and data plotting. The ultimate aim was to expose to the KDE community what we could learn about social interactions within the community from, arguably, its most important communication tool: the version control system.

KDE SVN was4 truly enormous. It was pretty much the largest SVN repo in the wild. One very large central repo which represented the entire body of KDE code/artefacts. Around this time the strains of using such a repo with such a huge (and growing) community were prompting discussion about distributed VCS.

These were remarkably mature and structured discussions. Git was, by no means, a foregone conclusion. Other distributed VCS were given headroom and this was the first (and, basically, last) time I played with Mercurial and Bazaar. The discussions were, for the most part, very technical. I raised my voice to talk about the potential social impacts of switching from SVN to distributed VCS. Any distributed VCS.

Joining KDE eV

I spoke at Akademy and other KDE events (including the KDE 4 launch at the Googleplex) about the research I was doing; either my PhD or the EC-funded stuff. I blogged. I dented5. My work was positively received and gearheads would actively reach out to me for more-detailed analysis of their corner of KDE.

I was encouraged to join KDE eV and I did. Given that I had made precisely 0 code contributions6 to KDE this, to me, felt like an achievement.

Since day one of my involvement, KDE eV had somewhat of an identity crisis. It was really not 100% clear what it did… but anyone who had been involved with KDE for more than 6 months was highly encouraged to join. Before long it had become bloated; lots of members contributing almost nothing and the few people wanting to do something not getting enough support to do it.

KDE has switched to Git and the social changes were a-happenin’. The KDE project was starting to lose its social cohesion. Post KDE 4.0-release blues, the switch to GIT and a lack of care from KDE eV all contributed here. Other things, too. No one thing started the KDE community’s cohesion degradation. But we felt it. We even went though a rebranding… KDE was not a desktop project, it had become a suite of projects and the desktop was just one of them.

KDE had evolved and I had not.

Cohesion Degredation?

One of the metrics I worked on during my PhD was a simple use of graph theory to measure how well-connected a community is. The contribution I made here was intriguing: as project get bigger they become less cohesive, but through careful community management, luck and clever structure, KDE avoided this.

The last time I properly attended Akademy (the KDE community conference) was back in 2014. I’d been frustrated for some time with my inability to drive home the message that the switch to GIT had o be managed properly. I’d been frustrated that nobody seemed to have noticed that my warnings were coming true.

So I gave a talk that year.

Deep down, I knew this was my last public outing on behalf of KDE. It was. After my talk a lot of people came up to discuss the mic I had just dropped. But as the days and weeks passed after the event, the message disappeared. And so did I.

So Why Are You Telling Us This Now?

This year’s KDE conference starts tomorrow. Two of my all-time best buddy KDE community members reached out to see if I was turning up.

They knew I wasn’t.

While we briefly reminisced by email, one of them pointed out that my talk from 2014 had recently come up in conversation on a KDE mailing list. That, 3 years later, the talk was being used as part of a great discussion about change in the project.

I’m really not sure what my emotion about that was. But, I did not feel compelled to join the discussion. I did not feel a need to remind people about what I was trying to achieve all that time ago. Nope. Instead, I went and pushed some changes to a core plan I had been working on for Habitat, the new home for my free time.

The Thanks

To all my friends in KDE:

Enjoy Akademy. Enjoy the opportunity to do some navel gazing. Enjoy the food, the drinks, the sun. Hack. Break shit and put it back together again. Remind yourselves of why KDE is special. Remind yourselves of why it is important. Very important.

I thank you all for the time we spent together.

We were all part of the solution.

Footnotes

  1. Countdown to flamewar… 3… 2… 1… I know many will object to me calling KDE eV a “governance body” but, no matter how you cut it, that is what it is. At least it should be, imo. 

  2. There were approximately this number of KDE 3 releases. 

  3. Is the EBN still a thing? 

  4. Is? 

  5. Is identi.ca still a thing? 

  6. Thanks to the EBN, I did actually fix a spelling error in a comment in a .h file for Marble7

  7. This makes me a true C++ h4xX0r, right? 

  • otherwise throw away no feature branches needed when:
  • focused team
  • effort predictability

experiments and collaboration implies quantum effect branches

in any case lifetime upper bound

July 21, 2017

I planned on writing about the Present extension this week, but I’ll postpone this since I’m currently strongly absorbed into finding the last rough edges of a first patch I can show off. I then hope to get some feedback on this from other developers in the xorg-devel mailing list.

Another reason is that I stalled my work on the Present extension for now and try to get first my Xwayland code working. My mentor Daniel recommended that to me since the approach I pursued in my work on Present might be more difficult than I first assessed. At least it is something similar to what other way more experienced developers than myself tried in the past and weren’t able to do according to Daniel. My idea was to make Present flip per CRTC only, but this would clash with Pixmaps being linked to the whole screen only. There are no Pixmaps only for CRTCs in X.

On the other hand when accepting the restriction of only being able to flip one window at a time my code already works quite good. The flipping is smooth and at least in a short test also improved the frame rate. But the main problem I had and still to some degree have, is that stopping the flipping can fail. The reason seems to be that the Present extension sets always the Screen Pixmap on flips. But when I test my work with KWin, it drives Xwayland in rootless mode, i.e. without a Screen Pixmap and only the Window Pixmaps. I’m currently looking into how to circumvent this in Xwayland. I think it’s possible, but I need to look very carefully on how to change the process in order to not forget necessary cleanups on the flipped Pixmaps. I hope though that I’m able to solve these issues already this weekend and then get some feedback on the xorg-devel mailing list.

As always you can find my latest work on my working branch on GitHub.


KDE Chartered Flight to Almería

We have travelled from across the globe to meet for our annual gathering where we plan and discuss the next year's activities creating free software to share with the world. Almería is in the south east of Spain, a country which has long been a supporter of free software and collaboration with its creators. The sun here is hot but the water is also warm for those who make it to the beach to discuss their work with a pina colada and a swim. Over the last year KDE has run conferences in Brazil, India, Spain, Germany and sprints in Randa in Switzerland, Krita in the Netherlands, Marble in Germany, GSoC in the US, WikiToLearn in India, Plasma in Germany, Kontact in France, and sent representatives to OSCAL in Albania, FOSSASIA in Singapore, FUDCON in Cambodia, HKOSCon in Hong Kong and more.


Tapas y Sangria

Today we meet from around the globe, KDE contributors have flown in from Taiwan, US, all over Europe and British Isles, India, Brazil, Canada.

We have completed Akademy España, talks in Spanish to the community.

We also met for the formality of KDE e.V. Annual General Meeting.

The Community Working Group reviewed issues they had to deal with and were pleased there were fewer firefighting issues than in previous years and they could concentrate on gardening community.


We are KDE

Our outgoing treasurer Marta reported on the year's finances which were pleasingly balanced and with ample reserves. The Financial Working Group reported how they had supported this and that their main task is to support the incoming new treasurer.

The Sysadmin Working Group reported on the pleasing developments retiring old machines, old software such as Drupal 6 and old operating systems. They are moving towards Ansible for system deployment and were pleased at the new multi-platform CI system which is now running.

We heard from the Advisory Board Working Group who now have regular meetings with representatives from supporting companies and large deployments of KDE software.

The KDE Free Qt Foundation controls the licencing of Qt with representatives from both KDE and Qt company. In the last year they have concluded the relicensing of all Qt parts as Free Software. All parts of Qt are available under the GPLv3 or under a compatible license. Most parts are also available under the LGPLv3 and under the GPLv2. The last remaining code to be relicensed was the Qt Quick Compiler. This is now deprecated and replaced with an open source solution since the release of Qt 5.9.


Your new KDE e.V. board

Finally we voted on replacement board members for the three who's terms came to an end. Marta the treasurer did not renew her term. Holding one of the most important but least thanked tasks in KDE we owe her much gratitude for keeping out books balanced and our payments prompt. Lydia Pintcher and Aleix Pol i Gonzàlez both stood for the board again and were re-elected for another three years. And long term KDE developer Eike Hein was elected as a new board member, hoping to bring in more representation to the community from Korea where he lives. We thanked the outgoing and new board members with the traditional thanks of a fancy dinner.

Tonight we drink sangria and wine under the stars at a welcome party meeting old friends and new, eating tapas of salmorejo, croquetas, tortillas and rice, looking forward to the week ahead.

It's with all the joy in my heart that I share with you this amazing notice: AtCore was officially moved today to KDE Extragear by my favorite sysadmin Ben Cooksley after more than a month on KDE Review. This is the first huge milestone that we achieve on this 11 months of team work made [...]


July 20, 2017

This release includes all the feature-enhancements the Linux version has received (frameworks announcements for 5.36.0)

– Actually working spell-checking.
– Possibility to switch interface language.

EDIT: Adding an extra fall-back UI language does not wok properly yet.

Kate in SweedishKate in Sweedish

Grab it now at download.kde.org:  Kate-setup-17.04.3-KF5.36-32bit or Kate-setup-17.04.3-KF5.36-64bit

When I released Brooklyn v0.1 complaints arose from the fact that it is written in Java.
A lot of criticisms come from users that probably wrote Java code when it was born.
The language is constantly changing and I decided to use Java 8 as the primary language for Brooklyn.
I'm writing this blog post because while I was learning new features I realized that there is an enormous difference between studying something and applying what you have studied in a practical scenario.
I'll keep writing posts like that, and I want to write much more if I receive a good feedback!

Avoid null pointer exceptions
Imagine that you've a Bot interface with a method sendMessage and three classes that implements that: IrcBot, TelegramBot and RocketChatBot.
sendMessage returns a string which contains the messageId returned from the bot; the main problem is that there are bots like IrcBot which can send messages to IRC, but the protocol doesn't support messages identification.

What should you do? The first thing you can come to your mind is to return a null:

public interface Bot {
String sendMessage(...);
}

public final class TelegramBot implements Bot {
@Override
public String sendMessage(...) {
// Message is sent here

return msgId;
}
}

public final class IrcBot implements Bot {
@Override
public String sendMessage(...) {
// Message is sent here

return null;
}
}
The main problem is that if your code somewhere stores the string and use it without checking if it is null, the application will crash because of a NullPointerException.

A good solution is to use the class Optional. Let's see how to use it:
public interface Bot {
Optional<String> sendMessage(...);
}

public final class TelegramBot implements Bot {
@Override
public String sendMessage(...) {
// Message is sent here

return Optional.of(msgId);
}
}

public final class IrcBot implements Bot {
@Override
public String sendMessage(...) {
// Message is sent here

return Optional.empty();
}
}
Imagine now that you've sent a message with a Bot bot = new ...(); and you want to use the result of Optional<String> result = bot.sendMessage(...).
First of all, you can check if it is empty or not, and then you can do something (in this case, print the message id):

if(result.isPresent()) {
String msgId = result.get();
System.out.println(msgId);
}
You can also rewrite it with Lambda Expressions:
result.ifPresent(msgId -> System.out.println(msgId));
or more simply with Method References:
result.ifPresent(System.out::println);

There are cases when you don't know if a function returns a null or not.
Let's imagine that you've a static method from a library x called getFile() which returns a File object or null.
Instead of checking if it is null, you can simply write Optional<File> file = Optional.ofNullable(x.getFile());which is the equivalent of:

Optional<File> file;
File fileNull = x.getFile();
if(null == fileNull)
file = Optional.empty();
else
file = Optional.of(fileNull);

Time to fly off to the sun to meet KDE friends old and new and plan out the next year of freedom fighting. See you in Almería!

 

Facebooktwittergoogle_pluslinkedinby feather

We are happy to announce the release of Qt Creator 4.4 Beta!

qtc_inline_annotations

Editing

This version of Qt Creator features optional inline annotations for warnings and errors from the Clang code model and for bookmark comments (Options > Text Editor > Display > Display annotation behind lines). This way, you can easily see the details of issues while you type, without the need to hover your mouse over underlined text or the marker on the left side.

C++

When you rename a symbol, you are now offered to also rename files with the same name. Just trigger the renaming and check “Rename N files” (where “N” will be the number of files with the same base name) in the search results panel before pressing the actual “Replace” button.

If you have the Clang code model enabled, this is now also used for the highlighting of the identifier at the text cursor, which was previously still using the built-in model in any case.

There have been many bug fixes as well. C++ and Qt keywords are no longer wrongly considered keywords in C files, the function signature hint will now work when completing constructors with the Clang code model, and many more.

CMake

We were pretty busy fixing issues already in the 4.3 line of Qt Creator, but there are some improvements in 4.4 as well. We added a filter to the CMake variables setting in build configurations, fixed that headers from the top level directory were not shown in the project tree when using server-mode and improved the handling of CMAKE_RUNTIME_OUTPUT_DIRECTORY in CMake project files.

Other changes

We removed the non-maintained support for Window CE, and changed the ClearCase integration to be disabled by default.

This is just a small selection of the changes and improvements done in 4.4. Please have a look at our change log for a more detailed overview.

Known Issues

QML Profiler can currently get into invalid state. Stopping the application before stopping profiling currently does not work.

Get Qt Creator 4.4 Beta

The opensource version is available on the Qt download page, and you find commercially licensed packages on the Qt Account Portal. 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.4 Beta released appeared first on Qt Blog.

I completed the Oware two player mode as described in my previous blog post GSoC-First month analysis. This month was the time for the single player mode. So well it started well, I implemented the alpha beta pruning for the AI mode.

The levels are structured in the following way:

  1. For the initial levels the AI is random which sows randomly from its houses. But if the computer gets in a bad position or is losing badly then it switches to AI mode. A maxDiff is maintained for each level, for example level 1 has maxDiff = 20, level 2 has maxDiff = 15 and so on. So as soon as the computer/AI is behind the player by maxDiff it switches to AI mode.
  2. For the last levels there is no random selection so basically maxDiff = 0.

I also had been working on the animation of seeds which involves movement of the seeds from one house to another. It still has some issues left involving the animation being triggered at each step.

There are also some changes in my GSoC plan. I thought of working on computer activity after oware earlier when I made my proposal but with discussions with my mentors we came to a conclusion that musical activities are more important for a child. So I would be working on musical activities now which includes play piano and note names activity which were started in the branch Play piano and were earlier to be done in my last month. My aim would be to complete both these activities.

I planned to go to Akademy this week and meet everyone but well my visa got refused :( I will try to be a part next year and I hope I get the chance of meeting everyone (especially my mentors soon). I will cover more about the musical activities and my progress in my next blog post :)

July 19, 2017

I’m currently in my final preparations for this year’s Akademy.

For people unaware of this conference, it is the annual conference of KDE contributors.

We tend to have a few dozen of high quality talks on various topics ranging from art and community building, to hard-core Qt and C++ talks.

This year, I’m going to have two talks. One on (obviously :) ) functional programming in C++, and one on C++17 and 20. The later one will be a bit self-serving because I’d like us to raise the compiler requirements for our software so that we could enjoy working in KDE even more.

The only thing more important than talks is the period after where the different teams within KDE meet-up to discuss the future plans. While we do it all the time on IRC and on the mailing lists, having face-to-face meetings is irreplaceable.

If you are near Almeria, join us – the conference is free for attendance!

Going to Akademy


Read more...

Hi everyone!
As the title of this blog post suggests, the first evaluation has been successfully passed, the project accomplishing all the proposed goals. Thus, let me present you the progress I’ve done for the first evaluation.

  • The very first thing I’ve took care was allowing multiple-instrument visualization framework, by modifying the old core architecture of Minuet. Instead of the one and only keyboard instrument, Minuet is now providing an instrument tab bar, enabling the end user select the desired instrument. The tab bar is currently loading the instrument within the first tab as default. After I’ve discussed with my mentor, Sandro, I decided to keep the piano keyboard as the default instrument contained by the first tab. In order to keep all the functionalities available and a simple architecture at the same time, I’ve created an InstrumentView wrapper above all the instruments. Its methods are called by the core ExerciseView, calling in turn the methods that each instrument should implement.

2.gif

  • After changing the Minuet’s core in order to provide a multi-instrument framework, I started refactoring the piano keyboard view as a separate plug-in. Basically, for Minuet, a plug-in is nothing more than a bunch of QML files and a simple JSON file parsed in order to learn about the QML files’ location and load them dynamically in the instrument tab bar.

pi.PNG

The next goal was to install each instrument separately as a plug-in, besides all other Minuet’s plug-ins. Like any other KDE application, Minuet, keeps its data files into /usr/share/ file-system directory. Thus, this was the place where our plug-ins had to be installed; actually, the exact path is /usr/share/minuet/plugins/. Installing a plug-in is simply done by using a CMakeLists.txt file telling the build system where the plug-in files should be installed.

Plug-ins are loaded as follows: firstly Minuet searches for plug-ins location and if the search succeeds, it will iterate through each instrument’s JSON file, building a QJsonArray containing the plugin name and path. This QJsonArray is passed to the InstrumentView, setting the contents of the Instrument Tab Bar. Having all the tabs ready, the TabBar will just wait for a tab to be selected and a QML file to be loaded.

  • Having the multiple instruments framework and piano plug-in ready, the next step was to test and analyze the code for possible technical issues or bugs. Also, a general clean-up was required before submitting the code for the review and first Google Summer of Code evaluation.

 

These are the achievements I’ve met for the first evaluation. Let’s discuss now about the current progress for the next evaluation:

  • I wrote a proper and comprehensive documentation for the piano plug-in, enabling anyone to create his/her own instruments plug-ins and loading them dynamically into Minuet.
  • I started implementing a new instrument from scratch. As I am very passionate about guitar, I chose to integrate it into Minuet’s instruments suite. Thus, I have already designed the visuals for the Guitar plug-in and added it into Minuet’s instrument tab bar. Now, I need to link the GUI to the core, work on the guitar’s specifics and make the plug-in fully functional.

dupa.gif

In conclusion, GSoC proves to be a great experience thus far, being a pleasure to work on a project focused mainly on a subject I’m in love with: music. For further cool news, stay tuned!

 


A lot of implementation changes were introduced

  • Selection highlights depends upon the items selected in the model.
    • Previously, the selection higlights toggled when the SelectionButton for an image was clicked
    • Now the higlighted images are shown according to the items selected and stored in the selection model

  • Completely removed baloo dependency

  • For “By Folder” filter KIO based model is used for folder representation of images.
    • It shows the mixed images and folders in the AlbumView.
    • It shows the images in hierarchical structure, as they are represented in the memory. Just like a file manager would represent, but just the images and folders.

      Folder Structure

  • Adds a new ImageListModel
    • This model would just store the image list irrespective of whether they are from ImageLocationModel or ImageTimeModel.
    • This made the representation of images in the GridView and the ImageViewer a lot more easier

  • Better implementation of ImageViewer done by Marco Martin
    • Better animations for ImageViewer to appear and disappear.
    • Pinch zoom for the single Image appearing in the ImageViewer.
    • Zoom animations for the images in ImageViewer. Zoom on double clicking the image as well as on Ctrl + wheel action

      Normal Image Zero Zoom

      Zoom on Double Click Double Click Zoom

      Ctrl + wheel Zoom Ctrl + Wheel Zoom

  • Automatic updation of the currentIndex for the GridView if the index changes in the ImageViewer.

  • Makes the thumbnailer code common to all the models.
    • Faster loading of thumbnails for the GridView.

  • Totally removed the old code base qml implementation.

  • Adds KDirNotify and KDirWatch to support live updates of the data in the time and location collections as well.
    • We don’t need to add KDirNotify and KDirWatch to the ImageFolderModel since it subclasses KDirModel which already takes care of the changes.
    • KDirWatch uses the concept of singleton object ie we can use just a single instance of the KDirWatch class for the entire application.

  • Makes the enums common for all the models.

  • i18n’z all the text elements.

  • Creates a different SortModel for the ImageViewer to apply sort as well as the filter to show just the images.

  • Adds contextualActions to the AlbumView.
    • For now three actions are added Select all, Deselect all and Delete selections.
    • These actions can just be applied on the images and not on the collections or folders.

  • Selectively loads desktop and mobile user interface depending upon whether the environment variable QT_QUICK_CONTROLS_MOBILE is set or not.

    • There is just single difference between mobile UI and desktop UI, that is of the contextualActions. For desktop version these appear on the toolbar and for mobile version these appear in the contextDrawer.
    • Rest of the changes are handled brilliantly by the Kirigami.

      Desktop UI Desktop UI

      Mobile UI Mobile UI

  • Adds a selection mode for mobiles that is activated on pressAndHold.

    On PressAndHold Tap and Hold

  • Opens a specific image via the commandline.
    • That allows us to open the image from the file manager also.
    • It takes you directly to the single image in the ImageViewer
    • It also pushes the intermediate folders into the pageStack(that contains AlbumView) starting from the standard Pictures location to the folder containing the image, for the “By Folder” filter.
    • If the image is not in the Pictures location then it just pushes the folder into the pageStack(that contains AlbumView).
    • Though this is not perfect yet. The problem is that the SortModel(QSortFilterProxyModel) in the ImageViewer is populating in pieces that is first when the sourceModel for the model in ImageViewer is set to specific ImageFolderModel with empty data (I think) and then again the rowsInserted signal is emitted and the model is populated again and thus making the rowCount to double of the actual number of images, which then makes the currentIndex in the ImageViewer invalid(-1) at the beginning and hence the navigation starts from the first image in the list instead of the selected image. Searching for the alternatives :)

  • PS: The background shown in the application is theme dependent. This is Breeze-dark theme

header

In my last post, I talked about adding a grid layout to the activity. The inspiration of this layout was to remove the trial and error method of selecting (x,y) positions of a node and to implement a more efficient method of positioning the nodes. Along with that, the distance between two generations and nodes could also be maintained in a homogeneous manner, keeping the layout similar throughout the activity.

As it also turned out, the grid layout along with knowing the width and height of the node also helped in accurately positioning the edges, the effect of which will be shown in a few before-after screenshots later in this post

Implementation

Vertically, the screen is divided into three equal parts (representing three generations), represented as:

readonly property real gen_1: 0.10
readonly property real gen_2: 0.40
readonly property real gen_3: 0.70

Here, gen_1, gen_2 and gen_3 represent 1st, 2nd and 3rd generation.

Horizontally, the area was originally divided into three parts:

readonly property real left: 0.2
readonly property real center: 0.4
readonly property real right: 0.6

grid

Aside from this, we also divided the horizontal area into four other slots, which will be necessary as it turned out later:

readonly property real left_ext: 0.1
readonly property real left_int: 0.3
readonly property real right_int: 0.5
readonly property real right_ext: 0.7

Here, left_int and right_int represent left and right on the interior side compared to left and right respectively. Similarly, right_ext and left_ext represent left and right exterior, compared to left and right respectively.

The nodes

The arrangement of the nodes are very simple, in which we are avoiding the problem of arranging the nodes via trial and error of the (x,y) position. The x-coordinate can be determined by selecting the best among left, right and center or among left_x or right_x (where x = 1, 2) as mentioned above and the y-coordinate can be determined via selecting the best among gen_1, gen_2 or gen_3, depending on the generation of the node.

As an example, for level 11, we define the nodePositions as follow:

nodePositions: [
        [center, gen_1],
        [left, gen_2],
        [right, gen_2],
        [left, gen_3]
]

As we can see from the level, it can be seen that it is very intuitive to determine the node positions for a given level, once we know the type of the node.

The edges

The start-end position of the edges can also be determined via the properties mentioned above along with the nodeWidth and nodeHeight properties mentioned in the previous blog post. For level 11, we calculate the edge positions as:

edgeList: [
        [center + nodeWidth / 2, gen_1 + nodeHeight, center + nodeWidth / 2, gen_2 + nodeHeight / 2],
        [rightXEdge(left), nodeMidPointY(gen_2), right, nodeMidPointY(gen_2)],
        [left + nodeWidth / 2, gen_2 + nodeHeight, left + nodeWidth / 2, gen_3]
]

As a result of these, level 11 turned out to be like this:

level_11_screenshot

How it all turned up

The layout has come a long way since it was started from the beginning of the second phase of GSoC, and here are the before and after screenshots of the family activity

level_18_before Initial layout of level 18

level_18_after Current layout of level 18

level_6_before Initial layout of level 6

level_6_after Current layout of level 6

What’s Next

I have started working on the extension of the Family activity, the goal of which is: given a relation, the user will have to find the pair that demonstrate the given relation. I will be documenting the progress of the activity once that is near completion, hopefully by the end of this week.

When using Qt’s model/view framework, filtering has always been very easy with QSortFilterProxyModel. To filter a list using text typed by the user in a line-edit, you have certainly been applying the standard recipe:

  1. instantiate the proxy;
  2. insert it between view and source model;
  3. connect the lineedit’s textChanged signal to the proxy’s setFilterFixedString slot; done!

But what if the model is a tree rather than a flat list?

Let’s use the tree below as an example. As you can …

The post New in Qt 5.10: recursive filtering for QSortFilterProxyModel appeared first on KDAB.

July 18, 2017

In the past there were two versions of LabPlot. The first one was based on Qt4 and KDE4 libraries. The second one uses Qt 5 and KDE frameworks 5. The development was done mainly in the Qt4-based branch which was merged from time to time to the Qt5/frameworks branch where the porting to Qt5/frameworks, if required, was done after the merge. Clearly, this caused a lot of additional work, was very time consuming sometimes and distracted us too often from the actual development – the development mostly done in our very limited spare time.

After long internal discussions we decided to stop developing and releasing the Qt4-version of LabPlot. It should be an exception nowadays to find a distribution without a reasonable support for Qt5 and KDE frameworks. So, starting from the next release, LabPlot 2.5, there will only be the Qt5/kf5-based release. We still can decide to provide fixes to the Qt4-based version, but there definitely won’t be any new features for this release anymore.

Working on one release only will allow us to concentrate more on the application itself and to increase the development speed. Our master branch is now on Qt5/frameworks since couple of weeks already with a lot of great new stuff being developed for the next release.

Having mentioned the next release, couple of words more about this. We plan to release closer to the end of this year. A lot of new features are already developed for the next release. Among them we want to mention the import of data from SQL databases as well as the import of Origin’s project files. Data fitting has got a lot of attention recently and the next release will allow the user to do more advanced fitting and to obtain much better representation of the results of the fitting procedure. Also, we improved a lot the user experience – the creation of multiple plots and data curves as well as performing of data analisis can be carried out more comfortable now and we’ll improve more in this direction soon. More on the new features will come in the next couple of blogs.

LabPlot’s GSoC2017 project makes also good progress and if everything goes well and as expected, the next release of LabPlot will provide support for live data coming from usual files, pipes, sockets and serial port.

Still, a lot of polishment has to be done until the release. Everybody who is interested in testing the new features, please don’t hesitate to build the current version of LabPlot from sources and to provide some feedback!

I'M SO SORRY FOR THESE AWFUL PUNS I CAN'T HELP IT.

TIL the Rust compiler panics. A lot. Okay, it wasn't today, it was last week. Still. At this point I feel bad because I feel like I'm constantly coming out with something bad to say about Rust. I swear, I love the language. So I'm just going to point it out and move on: libsyntax panics on a lot of lexing and parsing errors. There. Moving on...

I have to admit, I spent too much time thinking of something interesting and engaging to write in this blog post but unfortunately it's just going to be a small progress report. You know the famous saying, a gif is worth a thousand words...

Highlighting

In my last post I showed highlighting done for declarations, but uses were not highlighted. Lo and behold...

Video should appear here; if it doesn't click here

This also means that go-to-declaration works as well. You might notice the uses aren't highlighted the same color as the declarations. That's a mistake on my part and I'm working to fix that.

Renaming

As I've said before, KDevelop does a lot of things out-of-the-box if it has the Declaration-Use chain for a project. Renaming declarations is one of them.

Video should appear here; if it doesn't click here

Very basic code completion

In the spirit of short recordings, here's another one.

Video should appear here; if it doesn't click here

(yes, the cursor is slightly off in all of these; blame the recording software)
(((also if the videos aren't loading, you can view them here, here and here)))

Up next

Some more interesting things for code completion are coming up. Also, the Rust compiler has amazing error messages and I'm currently looking into getting the diagnostics out of libsyntax and show them in KDevelop. I'm looking into parsing imported modules as well, starting with libstd. All exciting stuff.

I'll also be speaking at KDE's Akademy this weekend, so if you're there, please feel free to drop by and say hi. I won't bite. :)


I'm going to Akademy

There's less than a week until the beginning of Akademy 2017 (if you still haven’t registered, do so now) and this is what you can expect from your first day at the event:

Keynotes and Master Talks

Akademy opens on Saturday, July 22 at 10 am with Robert Kaye, the brains behind Musicbrainz. We talked with Robert a few days ago, and he will tell us all about his projects and how he managed to marry FLOSS activism with the pragmatism of having to make money in order to keep them alive.

Sebastian Kügler will follow with an overview of the most important things that happened over the last year in the development of Plasma. He will talk about current features, future plans and goals, what to expect on your desktop over the next year, and how to help and get involved.

Meanwhile, in the next room, Jos van den Oever will examine Calligra and its native support for ODF. He'll look at a number of areas of ODF and see how well they are supported compared to other office suites.

At 11:50, Mirko Boehm will review the governance norms applied in FSFE, KDE and Wikimedia in his talk Why we Fight. He will examine how the norms developed over time and how current debates reflect their evolution.


Kdenlive, KDE's video editor, now comes with a new, re-vamped user interface.

At the same time, Volker Krause will present the UserFeedback framework, which provides ways to engage users from inside the application itself, including the collection of system or usage statistics, as well as asking an interested set of users that match a specific set of criteria to participate in an online survey.

Continuing on with a similar topic, at 12:30 Aleix Pol will talk about the challenge of developing for users employing bundled systems. We'll see what impact shortening the path between the development and users being able to run the software will have.

At the same time, Emma Gospodinova will tell us how she plans to add support for Rust, the promisingly popular programming language, to KDevelop during her Google Summer of Code project. Emma plans to include standard features any IDE should support for a language, such as semantic highlighting, code completion, refactoring, debugging and project management.

From there, we will move onto the light entertainment, which is movies. Or more like movie-editing. In Kdenlive, rewriting the timeline, Jean-Baptiste Mardelle will show us the new, polished Kdenlive 17.08, which now uses QML for many parts of the UI.

On a more technical note, Ivan Čukić will talk about how functional programming can improve our day-to-day work, make our code safer, cleaner and more correct.

Lightning Talks

After lunch, at 15:30, we'll have a bunch of lightning talks. The first one will be about Mycroft, the Alexa-like AI, and Aditya Mehra will explain how you can turn it into a Plasma widget and really enhance your life by having something you can boss about.

Volker Krause will then take the stage and tell us all about KF5::SyntaxHighlighting, a syntax highlighting engine that was originally tied to Kate, but can now be used anywhere.

Then Albert Astals Cid is up, and he will explain the work being carried out on Clazy, a compiler plugin which allows Clang to understand Qt semantics.

Marco Martin will then have ten minutes to explain how the feedback generated from the design and implementation of applications significantly improved the quality of Kirigami, KDE's user interface framework for developing applications that work both on mobile and desktop computers.

Finally, Vasudha Mathur will talk about Ruqola, the first generic chat application based on Rocket.Chat. Ruqola is a Qt/QML/C++ app and provides multi-platform portability. Ruqola will currently run on both desktop and mobile (Android) platforms.

... Back to Regular Talks

At 16:30, Sandro Andrade will be talking about preliminary implementation of a modular and flexible framework for building Qt mobile applications. He will also explain how you can use code generators and a plugin-based architecture to automate the implementation of recurrent tasks.


Babe allows you to add music from multiple sources, including YouTube.

At the same time and next door, Camilo Higuita will be introducing Babe, a contextual multimedia desktop app. Babe uses online resources and AI to find relationships between the music metadata and its context in order to generate personalized queries and suggestions.

Lydia Pintscher and the rest of the KDE e.V. Board will then sit down for an Ask Us Anything session with the audience at 17:10. If you want to find out what the board really gets up to and hear the plans for KDE as a community moving forward, here's your chance.

Meanwhile, Dmitri Popov will be teaching you how to take your digiKam skills to the next level by mastering its advanced functionality. Dmitri's talk will introduce several useful features and tools, such as filtering, batch processing, and curve presets.

At 17:55, John Samuel will be talking about Wikidata and how it can play an important role for the visibility of KDE applications. He will show how developers can build tools to integrate their applications with Wikidata to present an up-to-date view of their applications and their cool features.

At the same time, Arnav Dhamija will introduce you to the KIO (KDE Input Output) library. KIO is what allows your KDE apps to access data from a number of different protocols, such as local file systems, ssh, https, samba shares, ftp, and network file systems. Arnav will explain the need for KIO, how KIO works, KIO slaves, and how to develop for the same.

At 18:35 Timothée Giet will be taking us down the long road to GCompris-qt 1.0. GCompris, the collection of educational games and activities for children, has finally officially released the new Qt-based version. Timothée will show us the progress the team has made to get there, as well as some shiny new activities.

In the next room, David Edmundson will be explaining the Binding loop detected for property "title"" error, an annoying and cryptic error everyone developing QML has experienced at some point or another. He will talk about what this warning really means and how you can tackle even the most complicated loops.

... And a last Blast of Lightning Talks

At 19:15 we'll have the last three Lightning talks of the day. First up will be Agustín Benito with his Opening new doors presentation, in which Agustín will explain why he thinks KDE should jump into the embedded-for-automotive fray. Should he have called his talk Opening car doors? Definitely.

Then Annu Mittal will talk about all the application domains and various programs currently running in KDE, namely: Season of KDE, Summer of Code, and Outreach Program for Women. She will follow up by explaining the various ways you can get involved with KDE, both from the technical and non-technical point of view.

Finally, yours truly will help you look for love (for your projects) by explaining in ten minutes flat three simple steps that will improve your communication and increase your audience's appreciation for your project.

... And that is just day one.

Register here and don't miss Akademy 2017, one of the most important Free Software conferences this year.

Dot Categories:

Yesterday I got an invitation to the opendev conference (September 7-8, 2017) from the OpenStack foundation. The conference is about edge computing. 

While the topic itself is very interesting I was surprised that the opendev will be held in the U.S. (San Francisco, CA). I thought the foundation would have learned a lesson from the Boston summit this year. And as far as I understood it they decided to have currently no summits in the U.S. anymore until the political climate changed to allow risk free travel for all community members (see Kurt Garloff's talk at DOST around 8:45min). But it seems this applies only to the summits, very inconsistent! Some people would call it slightly duplicitous.

In light of the OpenStack Foundation's decision I'm still proud about the Ceph community. They decided with a clear statement to not held any event in the U.S. that requires travel for community members from foreign countries while there is the risk to potentially suffer harassment, digital privacy violations, or rejection at the border.

This is the third post in my GSoC series. You can read the second one here.

Hey there, a few weeks has passed since my last blog post. I promised to make a new post as soon as I had something cool to show off. Well, after working hard for a lot of time, I can finally show you how the project is taking shape.

First of all let me say that everything I am going to show you is still in heavy development and, as of right now, it does look a bit ugly. But don’t worry, it will start looking better in the next weeks.

The code for the frontend is available here.

Browsing courses

The first thing I am going to present you are the basic browsing functionalities. The user is able to browse departments (the top level categories of the website), courses and read pages.

The home page. Ugly but functional
A course index. The Lorem Ipsum is just there as a placeholder

The pages are fetching the data from a backend server that I am also developing during this GSoC. This server acts a compatibility layer between the current backend and this new frontend. I will write a blog post in the future about this service because it is based on an interesting architectural pattern: backend-for-frontend.

Ui Library

Together with the browsing functionalities I started developing a simple UI library to use with the new WebApp.

Ui Library

The UI Elements are customizable and will be used in the rest of the project.

For example take a look at this confirm dialog

Ui Library

or at this Edit Page button

Ui Library

Building an UI Library is a very long process, that’s why another WikiToLearn developer (Demetrio Carrara) is helping me in the development of this UI Library, he designed and built input boxes and added a few styles to the buttons.

This way I can concetrate in the development of the main functionalities.

Async operations

Another interesting feature I worked on, is the support for polling operations. Right now on the website when downloading a PDF for a course you have to stare at a loading bar for a few seconds (sometimes even a minute or two), this is not ideal. That’s why with this new Web App we are going to execute these long operations in the background, without having the user look at a loading bar.

Take a look at this video. I am clicking a button to start a long operations (which as of right now does nothing) and while the operation is in progress (you can see it in the lower right part of the screen) I am still able to browse the website.

There is still some work to do, for example adding some kind of notification once the operation is complete, or letting the user close the browser without losing the operations, but the basics are already implemented.

Other details

As you can see on the video above there are transitions and loading bars when switching between pages, this is very helpful for the user, the browsing experience is much smoother.

The Web App is also quite lightweight, the external libraries and the code are less than 70KB to download, and once they are cached (this means from the second refresh of the page) they load in no time.

The Web App also supports full HTTP codes when responding to the browser: not many Web Apps do this, but after a few days experimenting and developing various solutions I found the best one and decided to use it.

What’s next?

Right now I am experimenting with user authentication. The available solutions (actually the only solution) for authenticating users that is compatible with Vue does not support Server Side Rendering, which is a must for my web application. This probably means I will have to fork the library and implement support for our use case. This could slow down the development of the web app but at the same time it will be great to contribute to an external project.

I am also working on deploying the Web App on a real and public server, making it available for everyone. It is far from usable by common users but it is a nice way to keep track of progress.


As always thanks for reading and don’t be afraid to leave comments!

We’re releasing the first beta for Krita 3.2.0 today! Compared to Krita 3.1.4, released 26th of May, there are numerous bug fixes and some very cool new features. Please test this release, so we can fix bugs before the final release!

Known bugs

It’s a beta, so there are bugs. One of them is that the size and flow sliders are disabled. We promise faithfully we won’t release until that’s fixed, but in the meantime, no need to report it!

Features

  • Krita 3.2 will use the gmic-qt plugin created and maintained by the authors of G’Mic We’re still working with them to create binary builds that can run on Windows, OSX and most versions of Linux. This plugin replaces completely the older gmic plugin.
  • We added Radian’s brush set to Krita’s default brushes.

These brushes are good for create a strong painterly look:

  • There are now shortcuts for changing layer states like visibility and lock.
  • There have been many fixes to the clone brush
  • There is a new dialog from where you can copy and paste relevant information about your system for bug reports.
  • We’ve integrated the Smart Patch tool that was previously only in the 4.0 pre-alpha builds!

  • The Gaussian Blur filter now can use kernels up to 1000 pixels in diameter

Bug Fixes

Among the bigger bug fixes:

  • Painting with your finger on touch screens is back. You can enable or disable this in the settings dialog.
  • If previously you suffered from the “green brush outline” syndrome, that should be fixed now, too. Though we cannot guarantee the fix works on all OpenGL systems.
  • There have been a number of performance improvements as well
  • The interaction with the file dialog has been improved: it should be better at guessing which folder you want to open, which filename to suggest and which file type to use.

And of course, there were dozens of smaller bug fixes.

Download

The KDE download site has been updated to support https now.

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

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

A snap image for the Ubuntu App Store will be available from the Ubuntu application store. When it is updated, you can also use the Krita Lime PPA to install Krita 3.2.0-beta.1 on Ubuntu and derivatives.

OSX

Source code

md5sums

For all downloads:

Key

The Linux appimage and the source tarball are signed. You can retrieve the public key over https here:
0x58b9596c722ea3bd.asc
. The signatures are here.

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.

July 17, 2017

This is a short public service announcement: KWin master as of today requires a compiler which supports C++14. This means at least gcc 5 or clang 3.4. All major distributions support at least one of the two.

July 16, 2017

Hello!

Sidenote: I'm working on Go language support in KDevelop. KDevelop is a cross-platform IDE with awesome plugins support and possibility to implement support for various build systems and languages. The Go language is an cross-platform open-source compiled statically-typed languages which tends to be simple and readable, and mainly targets console apps and network services.

During last 2 weeks I finished my work on code completion from embedded structs feature I mentioned in previous posts. Also, I improved correctness of methods handling - now they are placed in correct context of DU-Chain. The biggest complexity was the fact that in Go language struct definitions doesn't have any declarations of methods - methods are declared separately, outside the struct context.

Aside from DU-Chain improvements I was working on adding support of launching project within KDevelop. I have researched different ways of handling project building and launching it and I didn't found one which would be "recommended one". So, I took a look on existing IDEs, especially on Gogland and LiteIDE. LiteIDE builds project inside source directory and launches resulting binaries while Gogland builds project into executable placed into /tmp folder. I think that keeping binaries inside sources directory can be not very handy, because they should be added to .gitignore (or similar settings in other VCS). So, I decided to build binaries in separate directory but provide ability to choose that build directory, like in CMake project manager in KDevelop.

For better overview of implemented feature I recorded a small screencast which shows a process of creating and launching Go project: https://www.youtube.com/watch?v=KxIy53i0RK0.

July 15, 2017

20049194_10209549565355868_878047986_o

Me, Shaza, and Ahmed

It was nice meeting Ahmed and Shaza @ faculty of Engineering, Ain Shams University in Cairo. I am proud to mentor them in Google Summer of Code.

Ahmed is working on implementing a DLNA server in digiKam core to export photo and video hosted in physical and virtual collections. The server is ready and he working on the configuration panel UI. See more here.

Shaza is working on a tool for image editor to be used for healing image stains with the use of another part of the image by coloring by the use of one part over the other, mainly testing on dust spots, but can be used for other particles hiding as well. See more here.


Screenshot with memory use KSysGuard — the system monitor — on FreeBSD seems oddly precise. This machine with FreeBSD 10.3 and KDE Applications 17.04.2 installed, tells me that I have 3,274,960.000000 KiB memory in use. That is, three million, two hundred seventy four thousand, nine hundred and sixty kibibytes. I’m willing to believe that, since notionally the machine has 4GB installed and FreeBSD uses up memory until it’s full and so memory use rarely reports much unused. What I’m less inclined to believe is the .000000 part of the measure: and zero millionths of a kibibyte. So that’s a .. um .. more than a millibyte, and a smidgen less than one one-hundred-twenty-secondth of a bit.

So, dragging in some information theory and plugging in some values,  using the binary entropy function, Wolfram Alpha tells me that

p ≈ 0.999314653604933

so we can be ninety-nine point nine percent sure that that is my actual memory use.

Sometimes it’s good to be precise.

As you might know Qt 5.8 created challenging problems for our Wayland session and threw our efforts back quite a bit. In this post I want to discuss the actual problems it created, how we are addressing them and looking into the future.

How our integration used to work

Our integration uses additional Wayland protocols. We have a protocol for server side window decorations which we use in our Plasma integration plugin to inform KWin whether the window should have a decoration or not. We have a protocol for client provided shadows which is e.g. used by our widget style Breeze to add shadows to the context menus. We have a protocol for the desktop shell, so that it can mark windows as desktop, panel, auto hiding panel, position the window, etc. Also we have a few protocols for interacting with our effect system, e.g. sliding popups, blur behind.

To use these protocols we need to interact with Qt in a low level way. We use the native interface in the Qt Platform Abstraction to get a wl_surface pointer for the QWindow. In order to not have to keep this simple for our applications our KWayland::Client API provides an API point for it: Surface::fromWindow(QWindow*) -> Surface*.

But when exactly to inject our own integration? We found a very handy way which worked much better than what we had used in the past for X11 (and based on that also transitioned X11 code to use it). Qt emits an event once it has created the native platform surface (in case of Wayland the wl_surface*) for a QWindow. Verbatim quote of the documentation:

The QPlatformSurfaceEvent class is used to notify about native platform surface events.

Platform window events are synchronously sent to windows and offscreen surfaces when their underlying native surfaces are created or are about to be destroyed.

Applications can respond to these events to know when the underlying platform surface exists.

Awesome! We get an event when the surface is created and when it gets destroyed. This made it very simple to create the integration and what is really important for us is that we get this event before the window is shown. So we can prepare everything so that KWin gets a good state.

And the KWin side was to a large part implemented on assumptions on how the sequence will work. We first get the surface, then the (xdg) shell surface, then the integration bits. Sure it would be nice if KWin handled also other sequences, but as the only implementation of this is Qt it doesn’t make sense to really care about it. We know that it was not perfect, we even had the test cases for it, which expect failed.

What broke with Qt 5.8?

In Qt 5.8 our complete integration broke. When the platform surface created event was emitted the wl_surface was not created, see QTBUG 58423. This is in my humble opinion a clear violation of the documented behavior and thus a breakage of the stability guarantees Qt provides, but others might disagree. After some discussion, trying out patches by those who had a Qt 5.8 build we had a patch for Qt which made things mostly work together with a patch to KWin. But at the time we had the patch ready Qt 5.8 was already declared end of life with no prospect of a Qt 5.8.1 bug fix release. For our Wayland session it was just impossible to get Qt 5.8 compatible again. All we could do was to advise distributions to not combine Qt 5.8 with the Wayland session. From our side it was fine for distros to ship Qt 5.8, but if they do they should make it impossible to install the Wayland session. The state was just too broken.

Qt 5.9

With Qt 5.9 the situation looks better. The required patch is merged, it’s an LTS release and we already had the first bug fix release. Qt wants to create more bug fix releases for it and this allows us to use it as a new target for integration. But still the situation is not as good as it used to be. If you currently use our Wayland session with Qt 5.9 you will still see quite some rough corners compared to where we were with Qt 5.7.

The main problem for us is that the platform surface regression was not the only change affecting us. Pre Qt 5.7 a wl_surface lived as long as a QWindow. Now the wl_surface gets destroyed whenever the window gets hidden and a new one created on every show. Unfortunately without a platform surface created event. This means our integration breaks as soon as a window gets hidden. E.g. after closing KRunner the integration for KRunner is broken.

We tried to address this problem in various places, but it is challenging. On the show event we don’t have the wl_surface yet (too early), on the expose event the window is already mapped (too late). This creates problems for KWin which is not prepared for the integration bits to hit when the window is mapped. Our protocols were designed with the platform surface created event semantics. For example in KRunner we face an issue with the integration. KRunner is a panel, which accepts focus and allows windows to go below, also it positions manually. Now when it gets re-shown KWin doesn’t know that this window is supposed to position itself and positions it. Now we get the request to put it as panel, KWin adjusts and moves maximized windows around. And then we get the request that the panel allows windows to go below. KWin shuffles the windows again as the maximized area changed again.

This is a rather tricky situation as we cannot really do something about it. If the window is mapped it’s too late. Even if we improve our API to handle the situation better it will be too late.

There are two possibilities to handle this: Qt stops to destroy the surface or sends a platform surface created event when it recreates the surface. The latter would be my personally preferred solution as this would match the documentation again and allow us to just use the one event handler.

Other regression

The situation around the changed behavior in Qt 5.8 caused a few steps back. Our code needed to be adjusted and that sometimes caused issues. We had a few regressions which also affected the compositor, so the stability of the whole system suffered. These issues are luckily investigated and fixed. But there are still bugs lurking in the system.

For me personally the most annoying bug is a crash in Qt which affects the auto completion of kdevelop. This makes hacking in a Wayland session rather difficult. I’m running currently a patched KWin which disables the virtual keyboard integration to not hit this issue.

A huge problem is that context menus are not marked as transient windows. This means that the Wayland compositor does not know that it is a menu and positions the menu anywhere on the screen. It gives the system a very unfinished touch.

If KRunner is closed through the escape key, the key starts to repeat on the window constantly and due to that it is not possible to open KRunner again. Similar if you start an application in Kickoff through the enter key, when opening Kickoff again it automatically launches the currently selected item. This again makes it very difficult to use the session and gives the whole system an unfinished look. We are working on a workaround for this issue in the server.

Towards the future

Qt 5.9 is here to stay and that’s what we have to use as integration target. Given that Qt 5.9 and Qt 5.7 behave very differently it will become difficult for us to maintain support for both. My suggestion is that we drop support for Qt 5.7 and require Qt 5.9 for the Wayland session. In addition there is hope that we can improve the integration. Marco and David have been working on adding support for XDG Shell unstable v6 which is already supported by Qt and makes it easier to integrate with. Once this landed in KWin Qt will be switched from wl_shell to xdg shell. This will improve the situation for us quite a bit as we then have one code path for both Qt and GTK applications.

How to prevent such regressions in the future

The change of behavior in Qt 5.8 threw our Wayland efforts back a few months. This is something we communicated to Qt quite early and it’s something which worries me a lot. We cannot spend time on changing our integration every time Qt releases a new version. Given that we need to look into how to prevent that such a situation happens again.

I hope that we can improve the integration on the testing front between Qt and KDE. We have a huge test suite which can find regressions in Qt. If Qt would run KDE’s tests during the integration phase Qt would notice regressions before they hit the code base. Given that all our tests are free software it should be possible for Qt to integrate them.

But also the other side would be interesting: if we could get the latest Qt into our CI system we could also discover breakages early. We have now a new docker based CI system which allows running multiple builds of the same change (e.g. Plasma gets build on openSUSE tumbleweed and on FreeBSD) – an image with a daily or weekly Qt snapshot could help us and Qt a lot to detect breakages early.

I also hope in openQA which allows to test the full operating system. This would spot regressions like the misplaced context menus even if KWin’s own auto tests would not spot them (KWin doesn’t care about Qt there, only about the Wayland and X11 protocols). There we might need to invest some work to make sure that KWin/Wayland can be properly run in the openQA tests.

I hope that our Plasma devs can discuss this in more detail with Qt devs during Akademy in person. Unfortunately I cannot be at Akademy this year �� so I cannot discuss in person.

Last but not least it is important that developers test. It would help a lot if the developers working on QtWayland test their changes in a running Plasma Wayland session. We are now overall in a state that the session is suited for hacking on. I do all my Wayland hacking in a Wayland session, experiencing all the glitches like kdevelop crashing.

Of course you might wonder what about us? Shouldn’t we KDE devs also test against the latest Qt? For me personally that is not the case. I’m working on the server side and not on the client side. I’m also not testing the latest GTK for example. Nevertheless I tried to use Qt 5.9 before it got released. Used the installer, spent a day to compile everything on top of it it, just to notice that it doesn’t have QtWayland and won’t get it. I didn’t give up that easily. So I tried to compile QtWayland myself. But when I tried to use it, it turned out to not have any keyboard support, because qtbase was compiled without support for xbkcommon. At that point I gave up. Not having QtWayland is one thing, but not being able to use keyboard is another, it’s rather pointless. The only other option is to compile Qt, but that is hardly an option as it’s really difficult to compile an actually working Qt with all components. The last times I tried, I failed, wasting days compiling. If there were usable weekly images for Qt I would be happy to try it, but of course only with a properly compiled and included QtWayland.

July 14, 2017

I provided in the past few weeks some general information about my project and hopefully helpful documentation for the multiple components I’m working with, but I have not yet talked about the work I’m doing on the code itself. Let’s change this today.

You can find my work branch on GitHub. It’s basically just a personal repository so I can sync my work between my devices, so be warned: The commits are messy as nothing is cleaned up and debug lines as well as temporary TODOs are all over the place. And to be honest up until yesterday my changes didn’t accumulate to much. For some reason no picture was displayed in my two test applications, which are Neverball and VLC.

Then on the weekend suddenly the KWin Wayland session wouldn’t even launch anymore. Well, at least this issue I was able to fix pretty quickly. But there was still no picture, it seemed the presenting just halted after the first buffer was sent to KWin and without any further messages. Neither the Xwayland server nor the client were unresponsive though. Only today I finally could solve the problem thanks to Daniel’s help. The reason for the halt was that I waited on a frame callback from KWin in order to present the next frame. But this never arrived since I hadn’t set any damage in the previous frame and KWin then wouldn’t signal a new frame. I fixed it by adding a generic damage request for now. After that the picture was depicted and moving nicely.

This is definitively the first big milestone with this project. Until now all I achieved was increasing my own knowledge by reading documentation and poking into the code with debug lines. Ok, I also added some code I hoped would make sense, but besides the compilation there was no feedback through a working prototype to see if my code was going in the right direction or if it was utter bollocks. But after today I can say that my buffer flipping and committing code at least produces a picture. And when looking at the FPS counter in Neverball I would even say, that the buffer flipping replacing all the buffer copies already improved the frame rate.

But to test this I first had to solve another problem: The frame rate was always limited to the 60 Hz of my display. The reason was simple: I called present_event_notify only on the frame callback, but in the Xwayland case we can call it directly after the buffer has been sent to the compositor. The only problem I see with this is that the Present extension assumes, that after a new Pixmap has been flipped the old one can be instantly set ready to be used again for new rendering content. But if the last Pixmap’s buffer is still used by the compositor in some way this can lead to tearing.

This hints to a fundamental issue with our approach of using the Present extension in Xwayland. The extension was written with hardware in mind. It assumes a flip happens directly on a screen. There is no intermediate link like a Wayland compositor and if a flip has happened the old buffer is not on the screen anymore. Why do we still try to leverage the Present extension support in Xwayland then? There are two important features of a Wayland compositor we want to have with Xwayland: A tear-free experience for the user and the ability to output a buffer rendered by a direct rendering client on a hardware plane without any copies in between. Every frame is perfect should also remain valid when using some legacy application and that we want no unnecessary copies is simply a question of performance improvements. This is especially important for many of the more demanding games out there, which won’t be Wayland native in the short term and some of them maybe never. Both features need the the full Present extension support in the Xwayland DDX. Without it a direct rendering application would still use the Present extension but only with its fallback code path of copying the Pixmap’s content. And for a tear-free experience we would at least need to sync these copies to the frame events sent by the Wayland compositor or better directly allow multiple buffers, otherwise we would limit our frame rate. In both cases this means again to increase the Present extension support.

I plan on writing about the Present extension in detail in the next week. So if you didn’t fully understand some of the concepts I talked about in this post it could be a good idea to check back.

Next week, KDE developers will release the beta of KDE Applications 17.08. This release will again have more applications and nearly all games ported to Qt5/KF5. While Qt4 is already no longer supported for over a year, KDE has decided to support Qt4/kdelibs4-based applications a bit longer.

The 17.08 release, however, will be the last to include Qt4/kdelibs4-based applications. This means, 17.12 will only include applications that are based on Qt5/KF5. See this mailing list discussion.

We hope to find more contributors who help porting the remaining applications. Instructions are on community.kde.org. Ask for help in our developer forum, mailing list, or IRC channel. You do not need git commit rights; you can add a patch/diff via Phabricator.

Porting Status

There used to be an automatically updated porting status page. Sadly the machine that created it stopped working because of a hardware failure; its DIMM simply died.

This week, I had the chance to run its script over a checkout of nearly all KDE repositories from cgit.kde.org. Unfortunately, the repository layout is not nicely structured into directories, and includes many unmaintained and playground repositories, but maybe it is still useful.

See http://imagezero.maxiom.de/files/portingstatus.html.

For contributors helping to get it more green, there is also a shorter version that omits all-green repositories, see portingstatus-todo.html.


Hello Folks,

This is the week after the first review phase and let me tell you, the coding process hasn’t gone smoother than this before. As my older blog posts suggest and as I have told, I was thinking of fixing the UI glitches in the content downloader GUI for this week. Since I was facing an issue in making the list view of the contents that could be downloaded, I discussed it with my mentor and he suggested that we could make the UI cleanups and other small fixes at the end. He added that these kinda fixes are only done after implementing the major features into the project. So I followed as he suggested and started to work on the main features that were required to be added into the project.

I have added a progress bar feature which will help, the user to get notified what the content downloader is doing at the moment. And implemented a details section which will give the user the large description of the content that they are going to download.

I will write done a detail description on what I did and learned from doing both of these feature implementation.

From the earlier posts, you might have seen what has happened to the UI after changing it to the mock-up design that we plan to implement. It became much worse that the test UI we created �� Literally, It was an epic fail when we started to re-arrange things because it wasn’t getting much space to fit in and it was getting cranky for space.

boom-week4This happened in my mind after re-compilation of the content downloader’s UI. ��

Depicting the progress using Progressbar

At first, I thought of creating a progress indicator widget as that KNewStuff actually used. But my mind, again and again, asked me that, is it the right way to implement it? Won’t there be a better way to do that? Well, in that dilemma I asked Leinir about it and he told that the progress indicator in the KnewStuff was just an old hacky way to print out the progress to the user. And hence suggested me to use the QProgressBar.

As usual :P, I started to over think that we could get the real-time information about the progress of the content through the progress bar using the SIGNAL’s emitted by KNSCore::Engine which is busy(), idle() and error(). I thought of depicting the real time progress into the progress bar using this, but I went wrong and again Leinir to the rescue, telling me that it isn’t possible at the moment, we have to revise a new method to get the real time progress of the object.

Before getting to know this, I was like stuck at it, not getting why it wasn’t showing the result. Damn! I was stuck at there and University classes also started and were in a tough state that I had to spend time in doing college works too in between while doing the GSoC project as well. Also, for the progress bar thinking it will be showing real-time progress, I tried all possible possibilities to get it running.

 

jim_carrey-week4Me throughout the whole week. ��

But at last, after getting to know we cannot show the real-time progress but we can only show the instance of what it is happening, then the rest was smooth. Created some functions to make the QProgressbar visible and set the range from (0, 0) and made them slots and connected to the signals emitted from KNSCore::Engine which gives the busy. idle and error signals.

q->connect(engine, SIGNAL(signalBusy(QString)), this, SLOT(progressBarBusy(QString)));
q->connect(engine, SIGNAL(signalIdle(QString)), this, SLOT(progressBarIdle(QString)));
q->connect(engine, SIGNAL(signalError(QString)), this, SLOT(progressBarError(QString)));

And voila!! There it is, working as expected.

 

Screenshot_20170714_152926Loading bar alone.

 

Screenshot_20170714_152834

Since the SIGNAL’s emitted by the KNSCore::Engine does not only sends the progress instance of the data item getting downloaded but also sends a QString message telling the user after implementation that what the downloader is doing. Hence, that was shown in the dialog just using a QLabel to print out the QString message from the SIGNAL.

Summary Description for the data item.

Actually, in the list view, where the content’s which could be downloaded are listed, there exists a short description about what the data item is. But we decided to create a details area mostly details grid viewer to show the description. It will be visible to the user only when the user clicks the details button, then it pops up at the right of the content list. Implemented using MVC architecture as always ��

Here are some of the screenshots of the content downloader with the summary description added into it, There is a visual glitch to the GUI but will re-touch it after the whole implementation of features and bugs are fixed.

We just used QLabel to represent the description summary of the data into the GUI.

Work planned for the next week.

  • Still, some documentation is left – complete it.
  • Start the second part of the project, ie, making the UI of Bundle manager/Resource manager much more appealing and user-friendly.
  • Start identifying some of its bugs and fix it.
  • Try to get the UI of content downloader fixed, even though these are only needed to be done at the last.

Will discuss with my Krita team and my mentors and also some artists to look at it and give some inputs if there needs something more else and I could see if that could be done.

Here is my branch were all the work I am done is going to.

https://cgit.kde.org/krita.git/?h=Aniketh%2FT6108-Integrate-with-share.krita.org

Will be back with more updates later next week.

Cheers ��





Hi all,

This blog is to assist participants attending the Conference Akademy 2017 at Almeria, Spain.
There will be a workshop titled "Playing with the amalgam of QML and JavaScript" conducted by me.
Timings: 10:30 - 12:15 on 24th July 2017.

                                  


Instructions for the participants:
  • The tutorial will only assume a basic knowledge of using Qt Creator [http://doc.qt.io/qtcreator/index.html].
  • No prior knowledge of QML is required, although it is suggested that attendees be familiar with the Objects and JavaScript.
  • We recommend that the attendees install the Qt Creator which includes Qt libraries and compatible compiler. Make sure you are able to build your first "Hello World" project successfully.
On a side note, please keep in mind of the following advise:
  • Although we do have access to the internet for all participants, it is always advised to carry a Data Card or Mobile Internet as a Backup.
  • Do carry power strip and bring your Laptop Fully charged.


Hope this workshop helps all the participants to get started with building their own QML-JS applications.

Older blog entries


Planet KDE is made from the blogs of KDE's contributors. The opinions it contains are those of the contributor. This site is powered by Rawdog and Rawdog RSS. Feed readers can read Planet KDE with RSS, FOAF or OPML.