Subscribe to Planet KDE feed
Planet KDE - http://planetKDE.org/
Updated: 35 min 21 sec ago

AtCore officialy moved to KDE Extragear

5 hours 20 min ago

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 [...]


Kate is now translated also on Windows!

Thu, 2017/07/20 - 7:04pm

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.

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

Stop writing code like we're in the '90s: a practical approach (PART I)

Thu, 2017/07/20 - 3:28pm

When I released Brooklyn v0.1 complaints arises 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);

Jonathan Riddell (riddell)

Thu, 2017/07/20 - 11:11am

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

Qt Creator 4.4 Beta released

Thu, 2017/07/20 - 9:52am

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

qtc_inline_annotations

Editing

This version of Qt Creator features inline annotations for warnings and errors from the code model and for bookmark comments. 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.

Oware - Single player

Thu, 2017/07/20 - 7:00am

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

Akademy 2017

Wed, 2017/07/19 - 8:47pm

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

Minuet – plugin architecture

Wed, 2017/07/19 - 5:01pm

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!

 


Gsoc Week 5 , 6 , 7

Wed, 2017/07/19 - 4:55pm
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

Family - Implementing Grid layout

Wed, 2017/07/19 - 12:01pm

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_1: 0.1 readonly property real left_2: 0.3 readonly property real right_1: 0.5 readonly property real right_2: 0.7
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.

Relevant links

New in Qt 5.10: recursive filtering for QSortFilterProxyModel

Wed, 2017/07/19 - 8:00am

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.

No Qt4/KDE4libs version of LabPlot anymore

Tue, 2017/07/18 - 8:53pm

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!

Keep calm, don't panic and [Ctrl+Space]

Tue, 2017/07/18 - 6:00pm
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...

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.


Very basic code completion
In the spirit of short recordings, here's another one.


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

opendev: OpenStack Foundation failed to learn the lesson

Tue, 2017/07/18 - 11:41am
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.

Progressive Web App for WikiToLearn - Updates on my GSoC project

Tue, 2017/07/18 - 11:05am

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!

Krita 3.2 beta 1 Released

Tue, 2017/07/18 - 7:19am

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.

KWin requires C++14

Mon, 2017/07/17 - 2:59pm

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.

Go support in KDevelop. GSoC week 6 & 7. Launching!

Sun, 2017/07/16 - 5:11pm
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.

digiKam GSoC Students in Egypt

Sat, 2017/07/15 - 4:12pm
20049194_10209549565355868_878047986_o

Me, Shaza, and Ahmed

It was nice meeting Ahmed and Shaza @ faculty of Engineering, Ain Shams University in Cairo.

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.


Best be precise

Sat, 2017/07/15 - 2:24pm

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.

Pages