I Use This!
Activity Not Available

News

Analyzed 2 months ago. based on code collected 6 months ago.
Posted 2 days ago by Kdenlive
We are happy to announce the latest Kdenlive version, part of the KDE Applications 17.12 release, making it the last major release using the current code base. This is a maintenance release focused on ... [More] stability, while feature development is going in next year’s 18.04 version. Proxy clips were given some attention and should give you better seeking experience as well as reduced memory usage for images. Other fixes include fixes in timeline preview, a crash when using a Library clip and smoother seeking on rewind playback. Packaging We have been pushing the AppImage packages lately because it allow us to put all required dependencies inside one file that can easily be downloaded and run on all linux distros. Today, we can also announce the immediate availability of the Kdenlive 17.12 AppImage, downloadable here : https://files.kde.org/kdenlive/release/kdenlive-17.12-x86_64.AppImage.mirrorlist AppImage related fixes: Fix audio distortion affecting the 17.08.3 AppImage Include Breeze style Vincent Pinon is also continuing the support for the Windows version, and you can get Kdenlive 17.12 for Windows here: https://files.kde.org/kdenlive/release/Kdenlive-17.12.0-w64.7z.mirrorlist Next We are also making available the first usable “preview” AppImage of the refactoring branch which will receive all development focus from now and will be released as 18.04. It is not ready for production but allows you to have a look at Kdenlive’s future. You may follow the development progress here. Kdenlive 18.04 alpha 2 release: https://files.kde.org/kdenlive/unstable/kdenlive-18.04-alpha2.AppImage.mirrorlist Meet us: Next Kdenlive Café is tonight on #kdenlive at 21PM (CET), so feel free to join us for some feedback!   Important Packagers must take note that libsamplerate is now a dependency due to recent changes in FFMPEG. It is recommended for Ubuntu (and derivatives) users to use the AppImage version until further notice.   Full list of changes Remove useless audio bitrate on pcm proxy encoding. Commit. Update proxy profiles. Commit. Make sure playlist proxies have an even height. Commit. Fix crash on playlists concurrent jobs using library clips. Commit. See bug #386616 Timeline preview fixes: Don’t invalidate on expand/collapse effect, invalidate on master clip edit. Commit. Don’t restart clip if trying to play backwards from clip monitor end. Commit. Use smaller size for image proxies. Commit. Fixes bug #353577 Fix playing backwards forwards one second. Commit. Fixes bug #375634 Fix extension in transcode file dialog. Commit. Sort clip zones by position instead of name. Commit. Set a proper desktop file name to fix an icon under Wayland. Commit. FreeBSD does not have sys/asm.h — for what is this include needed on linux?. Commit. Doc: fix option (qwindowtitle instead of caption). Commit. Fix terminology: mimetype(s) -> MIME type(s). Commit. Fix UI string: Control Center -> System Settings. Commit. Const’ify code. Commit. Fix import image sequence. Commit. [Less]
Posted 2 days ago by Andrius Štikonas
KDE Partition Manager 3.3 is now ready. It includes some improvements for Btrfs, F2FS, NTFS file systems. I even landed the first bits of new LUKS2 on-disk format support, now KDE Partition Manager can display LUKS2 labels. More LUKS2 work will ... [More] follow in KPM 3.4. There were changes in how LVM devices are detected. So now Calamares installer should be able to see LVM logical volumes. Once my pull request lands, Calamares should also support partitioning operations on LVM logical volumes (although Calamares would need more work before installation and booting from root file system on LVM works). KPMcore library now only depends on Tier 1 Frameworks instead of Tier 3 (although, we will later require Tier 2). Most of the work is now done in sfdisk branch.  Currently, the only functional KDE Partition Manager backend uses libparted but sfdisk backend is now fully working (I would say RC quality). I would have merged in already but it requires util-linux 2.32 which is not yet released. Yet another branch on top of sfdisk is KAuth branch which allows KPM to run as unprivileged user and uses Polkit when necessary to gain root rights. Everything except SMART support is working. To get SMART working too we would have to port away from (unmaintained) libatasmart to calling smartctl. Feel free to help! It should be fairly easy task but somebody has to do the work. Other than that you can already perform all partitioning operations using KAuth with one caveat. Right now KPM calls KAuth helper many times while performing partitioning operations. It can happen that KAuth authorization will expire in the meantime (KAuth remembers it for about 5 minutes) and KAuth will request a user to enter root password. If the user enters correct password, operation would finish. However, if authorization is not granted we may end up with half completed operation. And of course we don’t want to leave partition half moved, the data will almost surely be lost (half-resized partition is probably okay…). I suppose we can fix this by refactoring KPM operation runner, so that it calls KAuth helper just once with a list of all commands that have to be run. Unfortunately, this KPM Operation Runner refactoring might be bigger than what I would like, as significant changes would be necessary in partition data copying code. Maybe GSoC project then… Or ar there any better ideas on how to prevent KAuth authorization dialog in the middle of partitioning operations? You can grab tarballs from standard locations on download.kde.org server. [Less]
Posted 3 days ago by Matthieu Gallien (mgallien)
Elisa is a music player designed to be simple and nice to use. It allows to browse music by album, artist or all tracks. You can build and play your own playlist. We aim to build a fluid interface that is easy to use. Alexander has made yet another ... [More] round of improvements to the UI and especially improved a lot the playlist by making it more fluid. It really feels much better now (at least for me). I have added the possibility to load or save playlists. It is currently restricted to tracks already known to Elisa. More work is needed to support any audio files. Current state of the interface. The following things have been integrated in Elisa git repository: delete outdated todo list by Alexander Stippich ; fix player being stuck when same track is played in random mode by Matthieu Gallien ; enhance content view navigation by Alexander Stippich: The backspace key is now also accepted for back navigation in e.g. the artist album view ; A mouse area is added to MediaBrowser to allow back navigation with the mouse backbutton ; Focus is forced on the stackview when arist or album is opened. Without this, the back key navigation is only working when it is actively focused by the user, e.g. by a mouse click ; deduplicate code for the content view and adjust visual appearance by Alexander Stippich ; merge MediaPlayList and PlayListControler to reduce size of code by Matthieu Gallien ; make margins consistent and remove horizontal separator in playlist by Alexander Stippich ; show passive notification when a track fail to play by Matthieu Gallien ; remove context menus by Alexander Stippich ; overhaul RatingStar by Alexander Stippich ; add possibility to load and save a playlist at format m3u from two buttons at bottom of playlist by Matthieu Gallien ; fix problems with dependencies and make some optional ones be required. Require all tier1 dependencies if they are also supported on Windows and Android by Matthieu Gallien ; more improvements to playlist by Alexander Stippich: Some more improvements to the playlist. First of all, adds more animations and fixes T6295. Fixes some scaling issues and makes Show Current Track also select the item to highlight it better. Converts actions to use signals shorten the play now and replace play list button text by Alexander Stippich; add a readme for packagers following some feedback in #kde-devel by Matthieu Gallien ; [Less]
Posted 3 days ago by Andreas Kainz (Andreas_k)
Two months ago I start to finalize the existing Elementary icon theme for LibreOffice. It’s about 2.000 icons and now they are available in LibreOffice 6.0 beta. In addition all icons are available as svg file so it can be used and edit in an easy ... [More] way. Please download and test LibreOffice 6.0 beta to give feedback. You switch the icon theme with Tools -> Options -> View -> Icon Style. We talk about a lot icons not all are perfect. Feedback is always welcome. Test LibreOffice 6.0 beta Mary Christmas and an shiny new year with LibreOffice 6.0.     [Less]
Posted 4 days ago by KDAB on Qt
Introduction In the previous article we gave an overview of the process for creating a custom aspect and showed how to create (most of) the front end functionality. In this article we shall continue building our custom aspect by implementing the ... [More] corresponding backend types, registering the types and setting up communication from the frontend to the backend objects. This will get us most of the way there. The next article will wrap up by showing how to implement jobs to process our aspect's components. As a reminder of what we are dealing with, here's the architecture diagram from part 1: Creating the Backend One of the nice things about Qt 3D is that it is capable of very high throughput. This is achieved by way of using jobs executed on a threadpool in the backend. To be able to do this without introducing a tangled web of synchronisation points (which would limit the parallelism), we make a classic computer science trade-off and sacrifice memory for the benefit of speed. By having each aspect work on its own copy of the data, it can schedule jobs safe in the knowledge that nothing else will be trampling all over its data. This is not as costly as it sounds. The backend nodes are not derived from QObject. The base class for backend nodes is Qt3DCore::QBackendNode, which is a pretty lightweight class. Also, note that aspects only store the data that they specifically care about in the backend. For example, the animation aspect does not care about which Material component an Entity has, so no need to store any data from it. Conversely, the render aspect doesn't care about Animation clips or Animator components. In our little custom aspect, we only have one type of frontend component, FpsMonitor. Logically, we will only have a single corresponding backend type, which we will imaginatively call FpsMonitorBackend: [sourcecode lang="cpp" title="fpsmonitorbackend.h"] class FpsMonitorBackend : public Qt3DCore::QBackendNode { public: FpsMonitorBackend() : Qt3DCore::QBackendNode(Qt3DCore::QBackendNode::ReadWrite) , m_rollingMeanFrameCount(5) {} private: void initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) override { // TODO: Implement me! } int m_rollingMeanFrameCount; }; [/sourcecode] The class declaration is very simple. We subclass Qt3DCore::QBackendNode as you would expect; add a data member to mirror the information from the frontend FpsMonitor component; and override the initializeFromPeer() virtual function. This function will be called just after Qt 3D creates an instance of our backend type. The argument allows us to get at the data sent from the corresponding frontend object as we will see shortly. Registering the Types We now have simple implementations of the frontend and backend components. The next step is to register these with the aspect so that it knows to instantiate the backend node whenever a frontend node is created. Similarly for destruction. We do this by way of an intermediary helper known as a node mapper. To create a node mapper, just subclass Qt3DCore::QNodeMapper and override the virtuals to create, lookup and destroy the backend objects on demand. The manner in which you create, store, lookup and destroy the objects is entirely up to you as a developer. Qt 3D does not impose any particular management scheme upon you. The render aspect does some fairly fancy things with bucketed memory managers and aligning memory for SIMD types, but here we can do something much simpler. We will store pointers to the backend nodes in a QHash within the CustomAspect and index them by the node's Qt3DCore::QNodeId. The node id is used to uniquely identify a given node, even between the frontend and all available aspect backends. On Qt3DCore::QNode the id is available via the id() function, whereas for QBackendNode you access it via the peerId() function. For the two corresponding objects representing the component, the id() and peerId() functions return the same QNodeId value. Let's get to it and add some storage for the backend nodes to the CustomAspect along with some helper functions: [sourcecode lang="cpp" title="customaspect.h"] class CustomAspect : public Qt3DCore::QAbstractAspect { Q_OBJECT public: ... void addFpsMonitor(Qt3DCore::QNodeId id, FpsMonitorBackend *fpsMonitor) { m_fpsMonitors.insert(id, fpsMonitor); } FpsMonitorBackend *fpsMonitor(Qt3DCore::QNodeId id) { return m_fpsMonitors.value(id, nullptr); } FpsMonitorBackend *takeFpsMonitor(Qt3DCore::QNodeId id) { return m_fpsMonitors.take(id); } ... private: QHash m_fpsMonitors; }; [/sourcecode] Now we can implement a simple node mapper as: [sourcecode lang="cpp" title="fpsmonitorbackend.h"] class FpsMonitorMapper : public Qt3DCore::QBackendNodeMapper { public: explicit FpsMonitorMapper(CustomAspect *aspect); Qt3DCore::QBackendNode *create(const Qt3DCore::QNodeCreatedChangeBasePtr &change) const override { auto fpsMonitor = new FpsMonitorBackend; m_aspect->addFpsMonitor(change->subjectId(), fpsMonitor); return fpsMonitor; } Qt3DCore::QBackendNode *get(Qt3DCore::QNodeId id) const override { return m_aspect->fpsMonitor(id); } void destroy(Qt3DCore::QNodeId id) const override { auto fpsMonitor = m_aspect->takeFpsMonitor(id); delete fpsMonitor; } private: CustomAspect *m_aspect; }; [/sourcecode] To finish this piece of the puzzle, we now need to tell the aspect about how these types and the mapper relate to each other. We do this by calling QAbstractAspect::registerBackendType() template function, passing in a shared pointer to the mapper that will create, find, and destroy the corresponding backend nodes. The template argument is the type of the frontend node for which this mapper should be called. A convenient place to do this is in the constructor of the CustomAspect. In our case it looks like this: [sourcecode lang="cpp" title="customaspect.cpp"] CustomAspect::CustomAspect(QObject *parent) : Qt3DCore::QAbstractAspect(parent) { // Register the mapper to handle creation, lookup, and destruction of backend nodes auto mapper = QSharedPointer::create(this); registerBackendType(mapper); } [/sourcecode] And that's it! With that registration in place, any time an FpsMonitor component is added to the frontend object tree (the scene), the aspect will lookup the node mapper for that type of object. Here, it will find our registered FpsMonitorMapper object and it will call its create() function to create the backend node and manage its storage. A similar story holds for the destruction (technically, it's the removal from the scene) of the frontend node. The mapper's get() function is used internally to be able to call virtuals on the backend node at appropriate points in time (e.g. when properties notify that they have been changed). The Frontend-Backend Communications Now that we are able to create, access and destroy the backend node for any frontend node, let's see how we can let them talk to each other. There are 3 main times the frontend and backend nodes communicate with each other: Initialisation — When our backend node is first created we get an opportunity to initialise it with data sent from the frontend node. Frontend to Backend — Typically when properties on the frontend node get changed we want to send the new property value to the backend node so that it is operating on up to date information. Backend to Frontend — When our jobs process the data stored in the backend nodes, sometimes this will result in updated values that should be sent to the frontend node. Here we will cover the first two cases. The third case will be deferred until the next article when we introduce jobs. Backend Node Initialisation All communication between frontend and backend objects operates by sending sub-classed Qt3DCore::QSceneChanges. These are similar in nature and concept to QEvent but the change arbiter that processes the changes has the opportunity to manipulate them in the case of conflicts from multiple aspects, re-order them into priority, or any other manipulations that may be needed in the future. For the purpose of initialising the backend node upon creation, we use a Qt3DCore::QNodeCreatedChange which is a templated type that we can use to wrap up our type-specific data. When Qt 3D wants to notify the backend about your frontend node's initial state, it calls the private virtual function QNode::createNodeCreationChange(). This function returns a node created change containing any information that we wish to access in the backend node. We have to do it by copying the data rather than just dereferencing a pointer to the frontend object because by the time the backend processes the request, the frontend object may have been deleted - i.e. a classic data race. For our simple component our implementation looks like this: [sourcecode lang="cpp" title="fpsmonitor.h"] struct FpsMonitorData { int rollingMeanFrameCount; }; [/sourcecode] [sourcecode lang="cpp" title="fpsmonitor.cpp"] Qt3DCore::QNodeCreatedChangeBasePtr FpsMonitor::createNodeCreationChange() const { auto creationChange = Qt3DCore::QNodeCreatedChangePtr::create(this); auto &data = creationChange->data; data.rollingMeanFrameCount = m_rollingMeanFrameCount; return creationChange; } [/sourcecode] The change created by our frontend node is passed to the backend node (via the change arbiter) and gets processed by the initializeFromPeer() virtual function: [sourcecode lang="cpp" title="fpsmonitorbackend.cpp"] void FpsMonitorBackend::initializeFromPeer(const Qt3DCore::QNodeCreatedChangeBasePtr &change) { const auto typedChange = qSharedPointerCast>(change); const auto &data = typedChange->data; m_rollingMeanFrameCount = data.rollingMeanFrameCount; } [/sourcecode] Frontend to Backend Communication At this point, the backend node mirrors the initial state of the frontend node. But what if the user changes a property on the frontend node? When that happens, our backend node will hold stale data. The good news is that this is easy to handle. The implementation of Qt3DCore::QNode takes care of the first half of the problem for us. Internally it listens to the Q_PROPERTY notification signals and when it sees that a property has changed, it creates a QPropertyUpdatedChange for us and dispatches it to the change arbiter which in turn delivers it to the backend node's sceneChangeEvent() function. So all we need to do as authors of the backend node is to override this function, extract the data from the change object and update our internal state. Often you will then want to mark the backend node as dirty in some way so that the aspect knows it needs to be processed next frame. Here though, we will just update the state to reflect the latest value from the frontend: [sourcecode lang="cpp" title="fpsmonitorbackend.cpp"] void FpsMonitorBackend::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) { if (e->type() == Qt3DCore::PropertyUpdated) { const auto change = qSharedPointerCast(e); if (change->propertyName() == QByteArrayLiteral("rollingMeanFrameCount")) { const auto newValue = change->value().toInt(); if (newValue != m_rollingMeanFrameCount) { m_rollingMeanFrameCount = newValue; // TODO: Update fps calculations } return; } } QBackendNode::sceneChangeEvent(e); } [/sourcecode] If you don't want to use the built in automatic property change dispatch of Qt3DCore::QNode then you can disable it by wrapping the property notification signal emission in a call to QNode::blockNotifications(). This works in exactly the same manner as QObject::blockSignals() except that it only blocks sending the notifications to the backend node, not the signal itself. This means that other connections or property bindings that rely upon your signals will still work. If you block the default notifications in this way, then you need to send your own to ensure that the backend node has up to date information. Feel free to subclass any class in the Qt3DCore::QSceneChange hierarchy and bend it to your needs. A common approach is to subclass Qt3DCore::QStaticPropertyUpdatedChangeBase, which handles the property name and in the subclass add a strongly typed member for the property value payload. The advantage of this over the built-in mechanism is that it avoids using QVariant which does suffer a little in highly threaded contexts in terms of performance. Usually though, the frontend properties don't change too frequently and the default is fine. Summary In this article we have shown how to implement most of the backend node; how to register the node mapper with the aspect to create, lookup and destroy backend nodes; how to initialise the backend node from the frontend node in a safe way and also how to keep its data in sync with the frontend. In the next article we will finally make our custom aspect actually do some real (if simple) work, and learn how to get the backend node to send updates to the frontend node (the mean fps value). We will ensure that the heavy lifting parts get executed in the context of the Qt 3D threadpool so that you get an idea of how it can scale. Until next time. continue reading The post Writing a Custom Qt 3D Aspect – part 2 appeared first on KDAB. [Less]
Posted 5 days ago by Timothee Giet (Animtim)
This is a little blog post from India. I’ve been invited to give not one, but two talks at Swatantra 2017, the triennial conference organised by ICFOSS in Thiruvananthapuram (also known by its shorter old name, Trivandrum), Kerala. I’ll have the ... [More] pleasure to give a talk about GCompris, and another one about Synfig studio. It’s been a long time since I didn’t talk about the latter, but since Konstantin Dmitriev and the Morevna team were not available, I’ll do my best to represent Synfig there. (little teaser animation of the event banner, done with Synfig studio) I’ll also meet some friends from Krita, David Revoy and Raghavendra Kamath, so even if there is no talk dedicated to Krita, it should be well represented. The event will happen the 20th and 21st of December, and my talks will be on the second day. Until then, I’m spending a week visiting and enjoying the south of India. You can find more info on the official website of the event: swatantra.net.in. Many thanks again to the nice organization team at ICFOSS for the invitation ! [Less]
Posted 6 days ago by Filipe Saraiva (filipesaraiva)
Two months ago I attended to KDE Edu Sprint 2017 at Berlin. It was my first KDE sprint (really, I send code to KDE software since 2010 and never went to a sprint!) so I was really excited for the event. KDE Edu is the an umbrella for specific ... [More] educational software of KDE. There are a lot of them and it is the main educational software suite in free software world. Despite it, KDE Edu has received little attention in organization side, for instance the previous KDE Edu sprint occurred several years ago, our website has some problems, and more. Therefore, this sprint was an opportunity not only for developers work in software development, but for works in organization side as well. In organization work side, we discuss about the rebranding of some software more related to university work than for “education” itself, like Cantor and Labplot. There was a wish to create something like a KDE Research/Science in order to put software like them and others like Kile and KBibTex in a same umbrella. There is a discussion about this theme. Other topic in this point was the discussions about a new website, more oriented to teach how to use KDE software in educational context than present a set of software. In fact, I think we need to do it and strengthen the “KDE Edu brand” in order to have a specific icon+link in KDE products page. Follow, the developers in the sprint agreed with the multi operating system policy for KDE Edu. KDE software can be built and distributed to users of several OS, not only Linux. During the sprint some developers worked to bring installers for Windows, Mac OS, porting applications to Android, and creating independent installers for Linux distributions using flatpak. Besides the discussions in this point, I worked to bring a rule to send e-mail to KDE Edu mailing list for each new Differential Revisions of KDE Edu software in Phabricator. Sorry devs, our mailboxes are full of e-mails because me. Now in development work side, my focus was work hard on Cantor. First, I made some task triage in our workboard, closing, opening, and putting more information in some tasks. Secondly, I reviewed some works made by Rishabh Gupta, my student during GSoC 2017. He ported the Lua and R backend to QProcess and it will be available soon. After it I worked to port Python 3 backend to Python/C API. This work is in progress and I expect to finish it to release in 18.04. Of course, besides this amount of work we have fun with some beers and German food (and some American food and Chinese food and Arab food and Italian food as well)! I was happy because my 31 years birthday was in the first day of the sprint, so thank you KDE for coming to my birthday party full of code and good beers and pork dishes. To finish, it is always a pleasure to meet the gearheads like my Spanish friends Albert and Aleix, the only other Mageia user I found personally in my life Timothée, my GSoC student Rishabh, my irmão brasileiro Sandro, and the new friends Sanjiban and David. Thank you KDE e.V for provide resources to the sprint and thank you Endocode for hosting the sprint. [Less]
Posted 6 days ago by skadinna
A software developer's life can get lonely. Developers spend a lot of time immersed in their code, and often don't get to see the direct impact of their work on the users. That is why events like Randa Meetings are necessary. They help build bonds ... [More] within the community and show the developers that their work is appreciated. Randa Meetings are crucial to the KDE community for developer interaction, brainstorming, and bringing great new things to KDE. --- Scarlett Clark Randa Meetings are a yearly collection of KDE Community contributor sprints that take place in Randa, Switzerland. With origins dating back to a Plasma meeting in 2009, Randa is one of the most important developer-related events in the community. View from Randa. Photo by Gilles Caulier, CC BY 2.0 This year, Randa Meetings were held from September 10 to September 16, and were centered around a meaningful theme - accessibility. Accessibility in Free and Open Source Software Accessibility is incredibly important, yet so often neglected in the process of software development, and implemented almost as an afterthought. Users with disabilities and impairments often find themselves excluded from using the software, and prevented from participating in activities that the rest of us take for granted. Essentially, the software makes them feel as if they don't matter. To remedy this, many governments enforce laws requiring software to be accessible. There are also accessibility standards, guidelines, and checklists to help developers make their software accessible to all. FOSS communities and projects have the potential to play a major role in driving software accessibility efforts because of their open nature. People with disabilities can communicate directly with developers, report issues, and request features that they need. Proprietary products are rarely this open to feedback, not to mention the fact they are often very expensive. Accessibility Settings module in Plasma 5 Assistive technology covers a wide range of products and solutions: from screen magnifiers, screen readers, and text prediction methods to text-to-speech interfaces, speech recognition software, and simplified computer interfaces. There are also advanced solutions like 3D-printed prosthetic limbs, and those that allow controlling the mouse by moving the head or just the eyes. The best thing about all this technology is that it benefits everyone. Although people usually associate the word "accessibility" with hearing or visually impaired people, assistive technology can make life easier for many other groups: dyslexic or illiterate people, cognitively disabled people, the elderly, anyone with limited mobility or just bad eyesight. The analogy is clear with wheelchair-accessible spaces, which are useful to parents with baby strollers, people with bicycles and shopping carts, and delivery drivers. Likewise, improving keyboard navigation, image and color contrast, and text-to-speech tools results in satisfaction among non-disabled users. Making software accessible means making software better. Making KDE Software More Accessible Generally speaking, there are two ways to make software accessible: either by building special accessibility-focused tools from scratch, or by implementing accessibility features and improvements into existing applications. The latter is what the Randa Meetings 2017 were all about. digiKam with David Edmundson from Plasma in the background. Photo by Gilles Caulier, CC BY 2.0 The developers created a useful KWin plugin that can simulate different types of color blindness. This will help in all future accessibility efforts, as it helps developers understand what their color schemes will look like to visually impaired users. KMyMoney was made more accessible via improvements to keyboard navigation. New keyboard shortcuts were added, and others simplified to make them easier to use. Randa Meetings 2017 were made special by Manuel, a visitor from Italy who stayed at the Randa house during the sprint. Manuel is a deaf user, and he took the time to explain the problems that hearing-impaired users encounter with KDE software, and software in general. His feedback was extremely valuable in the context of the sprint's theme, and helped developers come up with accessibility-oriented solutions. Meeting in Randa with other participants makes you aware of deficiencies, possibilities, and needs. For a newcomer, like myself, it was also a chance to meet some community members, see what kind of people build KDE software, and take a look behind the scenes. --- Lukasz Wojnilowicz Apart from fixing individual applications, a lot of work was done on the Plasma desktop environment itself. Accessibility-related improvements include the ability to navigate the Plasma panel using voice feedback and the keyboard. The following video demonstrates this feature in action: KRunner was made completely accessible, and this change is visible in Plasma 5.11. The Orca Screen Reader works well with KRunner, and can read the entered query, as well as let the user know which element of the interface is currently focused. There was also a round of discussions on best practices for accessibility in KDE software. When testing software, the developers should try to use it only with their keyboard, and then only with the mouse. Too much customization is not a good idea, so it should be avoided, especially when it comes to colors, fonts, and focus handling. Another good practice is to test the application with a screen reader. This experience should highlight potential issues for disabled users. In the end, it all comes down to empathy - being able to put yourself in the user's shoes, and the willingness to make your software available to as many people as possible, without excluding anyone. More Plans and Achievements from the Randa Meetings 2017 Of course, the developers worked on so much more than just accessibility. The KDE PIM team discussed the results of their KMail User Survey, and tackled the most pressing issue reported by the uses - broken and unreliable search. They also ported the entire Kontact codebase away from the obsolete KDateTime component. Lukasz Wojnilowicz from KMyMoney and Volker Krause from KDE PIM. Photo by Gilles Caulier, CC BY 2.0 KMyMoney saw some important changes. All plugin KCM modules were ported to KF5. The backup feature is, well, back up and available to use, and database loading was improved so as to prevent the incompatibility between new and old KMyMoney files. After successfully participating in Google Summer of Code, the digiKam team gathered in Randa to further polish the new code contributed by students. They also worked on the media server functionality, which allows users to share their photo collections across different devices (smartphones, tablets, TVs...) using DLNA. Scarlett Clark (KDE CI), Emmanuel LePage (Ring), Simon Frei (digiKam) and David Edmundson discussing Plasma Accessibility. Photo by Gilles Caulier, CC BY 2.0 Marble Maps now has a new splash screen, and the entire interface of the Bookmarks dialog is responsive to touch. There are plans to implement a better text-to-speech module for navigation. The Public Transport Plasma applet has been completely rewritten as a Kirigami application. The applet's UI is now much more flexible and easier to adapt to mobile devices. The developers of Kube worked on resolving an annoying issue with live queries which slows down email synchronization, especially when there are thousands of emails. They also discussed the possibility of implementing an HTML composer to edit emails in Kube, and made plans for GPG implementation. In collaboration with developers from other KDE projects, they explored the options for making Kube cross-platform, and looked for the best way to build Kube on macOS and Windows. Finally, they implemented a visualization in the configuration dialog which indicates when the user input is invalid in configuration fields. Last but not least, Kdenlive received color correction improvements, and the developers worked on bringing back the popular TypeWriter effect. They also fixed the import of image sequences, worked on porting Kdenlive to Windows and macOS, and removed the warning about missing DVD tools that used to appear when starting Kdenlive for the first time. Looking Forward to the Next Randa Meetings With another successful Randa Meetings behind us, we can start planning for the next session. If you like the work our developers are doing, you can directly support it by donating to KDE. You can also contribute to KDE and make an impact on the users by joining our mentored project called Season of KDE. Who knows, maybe in the future you too will attend the Randa Meetings! [Less]
Posted 6 days ago by Krita News
Could you tell us something about yourself? I’m Rytelier, a digital artist. I’ve had an interest in creating art for a few years, I mainly want to visualize my original world. Do you paint professionally, as a hobby artist, or both? Currently I do ... [More] only personal work, but I will look for some freelance job in the future. What genre(s) do you work in? I work mainly in science fiction – I’m creating an original world. I like to try various things, from creatures to landscapes and architecture. There are so many things to design in this world. Whose work inspires you most — who are your role models as an artist? It’s hard to point out certain artists, there are so many. Mainly I get inspired by fantasy art from the internet, I explore various websites to find interesting art. I recommend looking at my favourites gallery, there are many works that inspire me. How and when did you get to try digital painting for the first time? It was years ago, I’ve got interested in the subject after I saw other people’s work. It was obviously confusing, how to place strokes, how to mix colors, and I had to get used to not looking at my hand when doing something on the tablet. What makes you choose digital over traditional painting? I like the freedom and flexibility that digital art gives. I can create a variety of textures, find colors more easily and fix mistakes. How did you find out about Krita? I saw a news item about Krita on some website related to digital art and decided to try it. What was your first impression? I liked how many interesting brushes there were. As time went on I discovered more useful features. It was surprising to find out that some functions aren’t available in Photoshop. What do you love about Krita? It has many useful functions and very high user convenience. I love the brush editor – it’s clean and simple to understand, but powerful. The dynamics curve adjustment is useful, the size dependent brush with sunken curve allows me to paint fur and grass more easily. Also different functional brush engines. Color smudge is nice for more traditional work, like mixing wet paint. Shape brush is like a lasso, but better because it shows the shape instantly, without having to use the fill tool. Filter brush is nice too, I mainly use it as sharpen and customizable burn/dodge. There are also ways to color line art quickly. For a free program that functionality is amazing — it would be amazing even for a paid program! I like this software much more than Photoshop. What do you think needs improvement in Krita? Is there anything that really annoys you? The performance is the thing I most want to see improved for painting and filters. I’m happy to see multi-threaded brushes in the 4.0 version. Also I would like more dynamic preview on applying filters like the gradient map, where it updates instantly when moving the color on the color wheel. It annoys me that large brush files (brushes with big textures) don’t load, I have to optimize my textures by reducing the size so the brush can load. What sets Krita apart from the other tools that you use? The amount of convenience is very high compared to other programs. The amount of “this one should be designed in a better way, it annoys me” things is the smallest of all the programs I use, and if something is broken, then most of these functions are announced to improve in 4.0. If you had to pick one favourite of all your work done in Krita so far,  what would it be, and why? It’s hard to pick a favourite. I think this, because I challenged myself in this picture and they are my original character, which I like a lot. What techniques and brushes did you use in it? I use brushes that I’ve created myself from resources found on the internet and pictures scanned by myself. I like to use slightly different ways of painting in every artwork, still looking for techniques that suit me best. Generally I start from sketch, then paint splatter going all over the canvas, then adding blurry forms, then adding details. Starting from soft edges allows me to find good colors more easily. Where can people see more of your work? https://rytelierart.deviantart.com/ I will open galleries in other sites in the future. Anything else you’d like to share? I hope that Krita will get more exposure and more people, including professionals, will use it and will donate to its development team instead of buying expensive digital art programs. Open source software is having a great time, more and more tools are being created that replace these expensive ones in various categories. [Less]
Posted 6 days ago by KDE neon Blog
Frameworks 5.41.0 has been released! https://www.kde.org/announcements/kde-frameworks-5.41.0.php And now available in Neon. Enjoy!