Planet KDE

Syndicate content
Planet KDE - http://planetKDE.org/
Updated: 4 hours 23 min ago

kreenshot-editor is incubating

Sun, 2015-04-26 17:45

With this post I would like to introduce a new project: kreenshot-editor.

Those of you who often do screenshots under MS Windows will probably know Greenshot which is - as they say on their website - “a free screenshot tool optimized for productivity”. It is GPL licensed and written in C#.

The built-in image editor of Greenshot is specifically designed to edit screenshot images. You can draw basic shapes like rectangles, ellipses, and arrows, add text and also apply a pixelizing or blurring rectangluar areas. Each of these objects is movable, resizable and deletable and there is undo/redo.

Noteably, the mouse cursor is (optionally) captured as separate object which then can be moved or deleted after taking the screenshot.

Now, kreenshot-editor is a new Qt-based project that was inspired by Greenshot’s image editor. It is hosted on KDE playground. It focuses on the image editing task, can be invoked from command line and should also provide a resuable editor component which could be integrated into other screencapture tools. The current code is already separated into an image editor widget and the main application.

Kreenshot-editor is still experimental, only basic features are implemented and there are currently some non-functional UI elements. Yet, it is already usable - if you don’t care that the color of objects is fixed to red ;-). Currently, you can create new objects, move them around, delete them, do undo/redo, load/save image, configure output filename pattern etc.

Categories: FLOSS Project Planets

KActivities powered recent media in Plasma Media Center

Sun, 2015-04-26 12:30

Hello Planet!

As you may have already read the blog post from Eike Hein about Building on new pillars: Activities and KPeople in Plasma 5.3, activities can provide the useful information about the recent applications and resources used by them.

Plasma Media Center is going to use this awesome functionality of activities and will show recently opened media files from current activity in the Home screen of Plasma Media Center. This feature will be available in The Plasma 5.4 release.

Also Plasma Media Center will report the information about recently played media to activities so, task manager and kicker application menu will be able to map recent media files to Plasma Media Center. Main advantage of this activities storing information about recently used resources is applications will not have to do extra wiring to keep the track of the recent files. This information is shared between the different applications so other applications can reuse it.

Thanks!

Categories: FLOSS Project Planets

newsFish news client for ownCloud

Sun, 2015-04-26 09:27

Ages ago I started working on a news client for ownCloud.

It got released for Blackberry 10 and SailfishOS, and I started an Android version but never finished it.

While I was using my Nexus 7, I missed the convenience of my news client, so I polished up the code a bit and ported it to Qt5/QtQuick2. Due to the excellent cross platform support of Qt, testing was done on the desktop, and it seems like it wouldnt be completely unusable as a desktop application, so, when I post the code to Github later, feel free to build yourself a desktop version!

When I get APKs built, I will post links to the Play store. in the mean time, enjoy this video:
View on Youtube

UPDATE:
Play Store

Blog tags: QtkdeownCloudAndroid
Categories: FLOSS Project Planets

Cantor in KDE Applications 15.04

Sun, 2015-04-26 05:37

KDE Applications 15.04 release brings a new version of the scientific programming software Cantor, with a lot of news. I am specially happy with this release because I worked in several parts of these new features. =)

Come with me™ and let’s see what is new in Cantor.

Cantor ported to Qt5/KF5

Cantor Qt5/KF5 + Breeze theme. In the image it is possible to see the terminal/worksheet, variable management panel, syntax highlighting, code completion, and the standard interface

I started the Cantor port to Qt5/KF5 during previous LaKademy and I continued the development along the year. Maybe I had pushed code from 5 different countries since the beginning of this work.

The change for this new technology was successfully completed, and for the moment we don’t notice any feature missed or new critical bug. All the backends and plugins were ported, and some new bugs created during this work were fixed.

We would like to ask for Cantor users to report any problem or bug in bugzilla. Anyway, the software is really very stable.

When you run Cantor Qt5/KF5 version on the first time, the software will look for Cantor Qt4 configurations and, if it exists, the configurations will be automagically migrated to Cantor Qt5/KF5.

Backend for Python 3

In Season of KDE 2014 I was the mentor of Minh Ngo in the project to create a backend for Python 3, increasing the number of backends in Cantor to 10!

Backend selection screen: Python 3 and their 9 brothers

The backend developed by Minh uses D-Bus protocol to allow communication between Cantor and Python 3. This architecture is different of Python 2, but it is present in others backends, as in the backend for R.

The cool thing is Cantor can be interesting for pythonistas using Python 2 and/or Python 3 now. We would like to get feedback from you, guys!

Icon!

Cantor first release was originally in 2009, with KDE SC 4.4. Since that date the software did not have an icon.

The Cantor Qt5/KF5 release marks a substantial change in the development of the application, then it is also a good time to release an icon to the software.

Cantor icon

The art is excellent! It presents the idea of Cantor: a blackboard to you write and develop your equations and formulas while scratches his head and think “and now, what I need to do to solve it?”. =)

Thank you Andreas Kainz and Uri Herrera, members of VDG team and authors of Cantor icon!

Other changes and bug fixes

Most bugs added in the Qt5/KF5 port were fixed before the release.

There are some small changes to be cited: in KNewStuff categories world, “Python2″ category was changed to “Python 2″ and “Python 3″ category was added; the automatic loading of pylab module in Python backends was dropped; now it is possible to run Python commands mixed with comments in the worksheet; and more.

You can see a complete log of commits, bugfixes, and new features added in this release in this page.

Future works

As future work maybe the high-priority for this moment is to drop KDELibs4Support from Cantor. Lucas developed part of this work and we would like to finish it for the next release.

I intend to test if D-Bus communication can be a good solution for Scilab backend. Another task is to redesign the graphical generation assistants of Python backends. A long-term work is to follow the creation of Jupyter project, the future of IPython notebooks. If Cantor can to be compatible with Jupyter, it will be really nice for users and to encourage the collaboration between different communities interested in scientific programming and open science.

I will take advantage of the Cantor Qt5/KF5 release to write about how to use Cantor in two different ways: the Matlab way and the IPython notebooks way. Keep your eyes in the updates from this blog! =)

If you would like to help in Cantor development, please contact me or mail kde-edu maillist and let’s talk about bug fixes, development of new features, and more.

Donations to KDE Brasil – LaKademy 2015!

If you would like to support my work, please make a donation to KDE Brasil. We will host the KDE Latin-American Summit – LaKademy and we need some money to put some latin-american contributors to work together face-to-face. I will focus my LaKademy work in the previously mentioned future works.

You can read more about LaKademy in this dot.KDE history. This page in English explain how to donate. There is other page with the same content in Spanish.

Categories: FLOSS Project Planets

Building on new pillars: Activities and KPeople in Plasma 5.3

Sat, 2015-04-25 12:40
KDE Project:

With the release of Plasma 5.3 only days away, it's time to start talking about some of the new features users of Plasma Desktop will get their hands on in the new version.

Activities

Many Plasma Desktop users are already familiar with Activities as a toolbox to divide and organize their personal computing environment into shards: You can set up and name activities, distribute application windows across them, associate relevant files with them, switch between, start and stop them to your heart's content.

A previously less explored side to the Activities story is what the technology can offer while working inside any one of your activities - thus even if you don't bother with setting up more than one and just stick to the default activity created for you the first time you log into Plasma.

This changes with Plasma 5.3! New work to make it easier for applications to enter useful data into the activity's knowledge store, as well as run smart queries against it, enable some new and improved functionality in both the Application Menu and Task Manager widgets in this release.

In Application Menu, all of the Recent categories (one of which is new) are now powered by Activities. One immediate advantage of this is that their contents now change with the activity you're in, but as promised it also provides several other inherent benefits:


The three Recent categories in Application Menu 5.3

  • Recent Applications used to be only aware of applications launched through Application Menu itself. With launch info now retrieved from the Activities knowledge store and all other launchers (for example KRunner, but also just opening a document from Dolphin is a launch) free to enter data there, this submenu can now gather much more recent system activity in one place. Furthermore, new data sources can be added as time goes on without having to touch Application Menu itself.
     
  • Recent Documents benefits in a similar way. Over the older KRecentDocument framework used before, the Activities backend offers access to a longer, richer backlog of document use data. User control over the data is also enhanced - it's now possible to forget about individual documents from the context menu, instead of being forced into a complete wipe.
     
    But that's not all on the documents front! Activities enable both Application Menu and Task Manager to easily query for recent documents by the application they were opened in, leading to lists of recent docs in the context menus of various types of application launcher buttons:


    Per-application recent documents in Application Menu and Task Manager 5.3
     
  • Recent Contacts is a brand new addition to Application Menu 5.3 showing the people you've been in touch with recently, along with their realtime status information. The first part of this is handled through Activities; dealing in people data, however, is facilitated by a recent addition to KDE Frameworks 5: KPeople.
     

KPeople


Recent Contacts in Application Menu 5.3: Powered by Activities and KPeople

The KPeople framework allows applications (including the shell) to retrieve lists of people and information about them (status, contact metadata), as well as perform actions on them - e.g. initiate a chat, as used by Application Menu when you click on an entry in the Recent Contacts category.

The data backing this interface is provided by backend plugins. The first implementer of a fully-featured KPeople backend is of course our very own Telepathy instant messenging suite. In the future, other KDE communication apps will integrate with KPeople, making conversations had e.g. in KDE's IRC client Konversation pop up in Application Menu as well.

Closing thoughts

Both the enhanced Activities backend and KPeople are very fresh. While we work hard to line up everything behind them (implement additional data sources and optimize those implementations, for example), they are still exposed somewhat carefully in Plasma Desktop 5.3. The Recent Contacts category in Application Menu, for example, is disabled in this release by default, because a Telepathy release entering conversation data into the Activities knowledge store is still pending. It can be enabled from the widget's config dialog.

In future releases you can expect us to make more of these pillars as our confidence grows, with additional UI functionality built on them and more prominent placements of it in various areas of the shell. Lots of work ahead!

Categories: FLOSS Project Planets

Cross Platformity

Sat, 2015-04-25 06:48

Several years ago we started porting Calligra to Windows. Supported by NLNet. Some time later, Intel also supported KO to create two Windows versions of Krita, one for tablets, one for convertible ultrabooks and later still, a new version of Calligra Words, Stage and Sheets for convertible ultrabooks. Meanwhile, the Krita Foundation has been publishing Krita on Windows and OSX for some time now. That's a fair amount of experience in puslishing software originally written on Linux on other platforms.

Let's take a look at the starting position.

Calligra, or rather KOffice, as it was called when it started out, was created to be a native KDE application. Integrated with the KDE desktop environment, using all the features that KDE offers, ranging from inter-process communication to system-tray notifications, shared plugin loading, mimetype handling, and other resource icon locating. These applications are KDE applications through-and-through.

There are also some hidden assumptions in the way KDE works on Linux: for instance, that reading thousands of small files on startup isn't a big deal. We Linux users are fortunate in having a choice of really good, really fast file systems, compared to Windows or OSX users.

So, on Linux, it's not that big a deal if people aren't running the KDE Plasma Desktop, since installing the libraries, the icons, maybe some system settings kcms will mean Krita will run just as well in Gnome as in KDE. It's a pity that some distributions don't make Krita depend on the oxygen icon set, and that others think that installing Krita means users need marble, but that's the way Linux packaging works, or doesn't work.

Now, there are two reasons for bringing a Linux application to another platform, two ways of going about it and two ways of implementing the port.

You can port an application to Windows or OSX because you want to use it yourself, as a Linux user in exile, or you can port an application to Windows because you want to gain a user-base on Windows.

And you can port an application to Windows or OSX by bringing the whole Linux and KDE environment with you, or by making the application as native as possible.

And finally, you can build on the target platform, with the target platform's native compilers, or you can cross-compile from Linux.

If you're porting for Linux exiles, the first approach is fine. It's what on Windows is done by cygwin, msys, KDE's emerge tool or KDE's windows installer. It's what FINK or MacPorts provide on OSX: a package manager, all the tools you're used to, all the platform services the application depends on. It's a big undertaking to maintain ports of so many components, and the porting system will often have temporary failures. I'm not saying that it's wasted work: I use KDE's windows installer to get Kate on Windows myself.

But it's not going to work when you want to build a user base for your application on Windows or OSX. The package managers, the installers are too complicated, too alien and drag in too many unfamiliar things. Even using something as Emerge to build, and then package up the built bits into an installer is problematical, because those bits will still expect the full KDE environment to be available.

And a Windows user is going to freak out when starting an application starts daemons that keep running. No kded, therefore. Their "protection" software (snake oil, but scary snake oil) will yammer when there's weird inter-process network communication. Bye-bye dbus. For a single application like Krita, a mimetype database is overkill. Loading icons by the hundred-weight, individually gives a bad hit on startup time. And yes, we're getting nastygrams about the number of files we package with Krita versus the number of files Photoshop packs.

It's really clear to keep in mind what the goal is. Because if you're working together with someone else, and they're of the linuxer-in-exile persuasion, and you're of the native-user persuasion, conflicts will happen all the time. The first crowd won't mind using glib in update-mime-database because, what's the problem? While you'll hate that requirement because building glib on windows and osx ain't easy, and it's a big dependency with a lot of other dependencies that come with it, and all just to be able to figure out that a .jpg file is a jpeg file.

Most 'native' Windows applications that use 3rd party libraries includes those libraries in their own source tree, either as dll's or as source code. It's easy, you never have to deal with newer versions of libraries breaking your code, you can build everything in one go. For some libraries, it's even the only way: you cannot build the breakpad library outside the source tree of the application that uses it. But for a cross-platform application that also targets Linux distributions, this cannot be done. You cannot include all dependencies in your source tree.

So, we need to find a way to build all dependencies without dragging in a fake Linux or fake KDE environment. Without dragging in a package manager. One that creates applications that behave as natively as possible.

What we're currently trying to do is this: build a cmake system that builds Krita's dependencies and then builds krita. CMake's external project system works pretty well for this. It's not as complicated as the Emerge system, though there are similarities, and we're even re-using patches from Emerge for our dependencies.

Here's the list of all dependencies we currently build:

  • automoc: needed for kdelibs-stripped
  • boost: needed for Krita
  • bzip2: needed for kdelibs-stripped
  • eigen3: needed for Krita
  • exiv2: needed for kdelibs-stripped and Krita
  • expat: needed for exiv2
  • ffi: needed for glib (only on OSX)
  • gettext: needed for glib (only on OSX)
  • giflib: needed for kdelibs-stripped and qt
  • glew: needed for Krita
  • glib: needed for shared_mime_info (only on OSX)
  • gsl: needed for Krita
  • iconv: needed for gettext and exiv2
  • ilmbase: needed for openexr
  • intltool: for glib (only on OSX)
  • jpeg: needed for kdelibs-stripped, qt and krita
  • kdelibs-stripped: specially hacked up version of kdelibs4 that doesn't need openssl, dbus and a whole lot of other things.
  • lcms2: needed for krita
  • libxml2: needed for kdelibs-stripped
  • libxslt2: needed for kdelibs-stripped
  • opencolorio: needed for krita, has it's own 3rd party external projects: tinyxml, yaml
  • openexr: needed for Krita
  • patch: needed on windows only, creates a myptch.exe because patch.exe is banned on Windows...
  • pcre: needed for shared-mime-info
  • perl: needed on Windows to build Qt
  • pkgconfig: needed on OSX to build glib
  • png: needed for Krita and Qt
  • qt: we need to build this ourselves to strip out openssl, qtscript, the database stuff and more, and because we build with a version of Visual C++ that Qt4 doesn't support out of the box
  • shared_mime_info: needed for kdelibs-stripped
  • tiff: needed for Qt and Krita
  • vc: needed for Krita
  • krita: what we finally want...

And this is what's still missing:

  • kdcraw: would provide camera RAW import
  • poppler: would provide PDF import and export
  • openjpeg: would provide jpeg2000 import and export.

All this is described here for OSX and here for Windows. My goal is to make a CMake based project that can build everything on OSX and Windows, and on Linux, for Windows in one go. It needs much more work, in fact more time than I actually have... Anything that can slim the number of dependencies would be very welcome!

And now it's coming full-circle: I actually would like to have installers for Krita that work on Linux, too. Just like Blender or Qt Creator have, a 32 and 64 bits installer that people can download, run and get the latest build of Krita, without weird extra dependencies, without waiting for distributions to pick up the next version of Krita. The system we're building should be able to provide that...

Categories: FLOSS Project Planets

こんにちは日本! Krita Launches Japanese Site

Fri, 2015-04-24 11:23

We are happy to announce that we have launched a Krita site in Japanese! Over the coming months, this website will be evolving to help the Japanese community stay current with all things Krita. Currently, almost everything online is in English, so it can be difficult for other countries to learn about and use Krita. With this Japanese site, we can provide specialized instructions and resources to help them get started. We are still finishing up translations, but are far enough along that we want to release it in the wild.

Check it out
https://jp.krita.org

Categories: FLOSS Project Planets

Turning the world upside down

Fri, 2015-04-24 07:22

This blog post is a rather important one for me. Not only is it the first blog post which I write in a nearby cafe sitting in the sun and enjoying spring, it is also the first blog post written in a Plasma session running inside kwin_wayland.

This marks an important step in the process of getting Plasma and KWin ready for Wayland as we have reached a state where I can dogfood kwin_wayland on one of my systems. It means that I’m confident enough to write a blog post without having to fear that the session crashes every few seconds (granted I press save a lot nevertheless).

So what do I mean when saying that I’m running a kwin_wayland session? Does it mean that everything is already using Wayland? No, unfortunately not, rather the opposite: all running applications are still using X11, but we use a rootless Xwayland server. The only Wayland application in this setup is Xwayland and KWin itself.

Nevertheless it’s a noteworthy achievement as we now have the architecture pulled upside down. No longer does KWin connect to either an X-server or a Wayland-server which does the rendering to the screen, it does it now all by itself. Over the last week I worked on the DRM (Direct Rendering Manager) backend for kwin_wayland. The DRM backend will become the primary backend for KWin, doing mode-setting, creating buffers for rendering and performing page flips of those buffers on the connected outputs and rendering the mouse cursor on the outputs. In the current state it’s able to get all connected outputs and perform mode setting on them. In addition it can power both compositors: OpenGL and QPainter. The QPainter one is the rather trivial: all we need are two buffers which we map into a QImage to render on. With each rendered frame the buffers are swapped and the last rendering buffer gets presented.

The OpenGL compositor is slightly more difficult. Here we need to introduce another component: GBM (generic buffer management). Gbm allows us to create an EGLDisplay for our DRM device, create an EGLSurface for each of the outputs and get the buffer from the surface to be passed to DRM for presenting. Unfortunately GBM is currently only available on Mesa and given NVIDIA’s presentation at last years XDC it looks like NVIDIA will come up with a different solution. My hope was that this would have settled at the time when we start implementing the solution, but unfortunately that’s not the case yet. So for the foreseeable future it looks like we will first have a Mesa specific backend, then later on can add a new NVIDIA-specific backend and hope that at some future point in time Mesa also supports NVIDIA’s solution (after all it was presented as a generic solution) and we can drop the GBM backend. The situation is none I like, but at the moment we can only ignore the proprietary drivers.

Another noteworthy detail is how KWin opens the DRM device. KWin runs as the normal non-privileged user – thus is not allowed to open the device. Just like libinput integration the DRM backend uses logind to open the device file. Given that we already have support for that in KWin it was a straight forward, elegant and secure way to implement it. I know, that not everybody will agree with this solution. But of course it’s just a DBus interface and anybody can implement it.

There is still quite some work needed before this backend, which got merged into master today, will be fully functional. For example all outputs are set to (0/0) that is render overlapped sections. Here we will in one way or another integrate with kscreen to get sane defaults from the start. I’m so looking forward to being responsible for screen layouts. If I look at all the terrible things one has to do to keep properly updated on XRandR… Now we won’t render with a wrong viewport because different parts of the stack are stuck in different states and no, we won’t freeze just because applications start and call an XRandR call. There are so many things which “just work” and which have been painful on X11. From my first tests on hardware I’m confident that we will finally have working multi-screen handling which is adequate for 2015.

Of course this is a wonderful time to start working on KWin. There are lots of small tasks to work on. I am constantly adding new tasks to our todo list. And if you ask, I can always provide some more small tasks.

Categories: FLOSS Project Planets

Use Geofix to Geotag Photos in digiKam

Fri, 2015-04-24 07:09

Geofix is a simple Python script that lets you use an Android device to record the geographical coordinates of your current position. The clever part is that the script stores the obtained latitude and longitude values in the digiKam-compatible format, so you can copy the saved coordinates and use them to geotag photos in digiKam's Geo-location module.

Continue reading

Categories: FLOSS Project Planets

My experiences at conf.kde.in 2015

Fri, 2015-04-24 01:29

Last year I really wanted to attend conf.kde.in but couldn’t because my train tickets were not confirmed by the time it started. So, I had made up my mind right then, that I will definitely attend it the next year by all means. So, this year I applied and was accepted as a speaker too. But tragedy struck again, when some college issues clashed with the date of my flight, so I had to reschedule it once, and then one more time due to one more clash, after which I could finally reach Amritapuri in the evening of Day 1 of conference when it was already over. So, yes I was sad as I had missed the first day, but that also meant that I should make the best of the second day for sure.

The second day of conference started with some great south-Indian breakfast, where I met up with some of the important people like Shantanu, Sinny, Pradeepto and others. The first talk for that day was supposed to start from around 10:00 am, and I was the one to speak in it. I spoke on the ‘Interactive Tours’ feature that I had implemented in Marble last year, and it was pretty well received (I hope). My talk was followed by the rest of the other talks of the day, which were all pretty awesome, and very interesting as well. I got to meet Devaja, Rishab, Pinak, and the rest of the speakers during the talks, and I loved to interact with each one of them.

After a couple of talks after mine, I was asked by Sinny Kumari whether I would like to volunteer in a qml workshop which was being held in one of the labs. I didn’t wanna miss this opportunity, so I said “yes”, and went to the lab with her. The workshop started in a few moments, after everyone settled down. It was Shantanu who was explaining most of the stuff, using his computer screen as a projection, with me, Sinny, Pradeepto and Pinak helping the attendees in their computers in case they needed help or had some query. It was a very productive session, amazingly led by Shantanu, and I loved every moment that was spent in it.

Well, the day ended with an awesome lunch, and a few more talks for the day. We were often approached by students from their college, asking us about our experiences with KDE, and how to start contributing. I answered them with my personal experience with Marble, and it went really well, with some good feedback from both parties. People were very enthusiastic and I loved spending time and exchanging information with them. After the end of all the talks, we went out for some sightseeing, rode a boat :P , saw some awesome views from a high building rooftop, went to the beach, had lots and lots of fun.

and then finally came back, where we were invited to a lab, where each of the speakers and the students were saying their last viewpoints about the conference, what they liked about it, what could be improved. We told them about our awesome experience and that we would love to come back here again. Speakers who were still in college were asked how they keep open-source contributions alive in their respective institutions, I told them about our the GNU/Linux users’ group of my college and the events that are organized by it. Pradeepto told us some really interesting and funny stories about KDE, which were really both fun and motivational to listen to.

After all was said and done, all the speakers were given a certificate of appreciation, along with some books, and we walked back to the guesthouse. We had our very final celebration at night after returning back, with an awesome chicken and beer party in one of the rooms, till 1:30 am in the night. I think it would be fair to say that this was the best day of my life, and I am very glad to have bunked Durgapur for my flight the previous day, otherwise I would have missed out on all of these amazing moments, which have now turned into memories for life. Thanks to KDE, and especially to Dennis, without whom I wouldn’t even be in this position right now. Thanks to the organizers of conf.kde.in and everyone else associated with it, for making my day special. I would love to come back to the next conf.kde.in and the next and the next. Thanks a lot! :)


Categories: FLOSS Project Planets

Dusting KMouth

Thu, 2015-04-23 22:03

Besides gardening lately (more on that next time) lately I've been looking into what needs and used to use KSpeech/KTTS/Jovie. As QtSpeech will replace the functionality Jovie provided I thought I'd look at what needs doing to get stuff using QtSpeech.
Okular's frameworks branch (or maybe it's been merged to master by now, not sure) is optionally using QtSpeech.KNotifyConfig and KNotification are optionally using QtSpeech as of the last frameworks release already.KHangMan and KAnagram have been using QtSpeech optionally since December of last year or so.
This leaves the big one, KMouth. Unfortunately KMouth has been bitrotting since about 2006 or so. All commits since have been minor or bug fixes. Many because KFoo classes changed and were used in KMouth. It's master branch still uses Qt3Support and K3ListItem, etc.
I started a couple of months ago to start porting it away from Qt3Support and K3* so it can be ported to Qt5 and QtSpeech, but it's been a long slow process. Current progress can be seen on the noqt3support branch, but even the last commit there is from a couple of months ago. Part of the trouble has been getting the PhraseBookDialog with it's accompanying model and treeview to work as it used to including drag and drop, copy/paste, import, export, save/load, etc.. Many bug fixes are also in the works, and I am positive it will be better than before once it's done, but it's taking time since I don't want to break loading phrasebook files of any existing users (If there are any out there, please shout, I'd love to hear from you about how you use KMouth).
Once KMouth is ported to QtSpeech I believe most/all users of the old KSpeech dbus api will be safely using the new QtSpeech library.
P.S. Once it's ported to Qt5/KF5 and QtSpeech KMouth could use some updating. A couple of years ago I saw a fancy speech application on the evening news that enabled a young man to speak with his family by tapping icons on an ipad which then spoke for him. KMouth could be useful in the same way with a bit of polish in my opinion.

Categories: FLOSS Project Planets

Introducing Portus: An Authorization Service and Front-end for Docker Registry

Thu, 2015-04-23 15:43

One of the perks of working at SUSE is hackweek, an entire week you can dedicate working on whatever project you want. Last week the 12th edition of hackweek took place. So I decided to spend it working on solving one of the problems many users have when running an on-premise instance of a Docker registry.

The Docker registry works like a charm, but it’s hard to have full control over the images you push to it. Also there’s no web interface that can provide a quick overview of registry’s contents.

So Artem, Federica and I created the Portus project (BTW “portus” is the Latin name for harbour).

Portus as an authorization service

The first goal of Portus is to allow users to have a better control over the contents of their private registries. It makes possible to write policies like:

  • everybody can push and pull images to a certain namespace,
  • everybody can pull images from a certain namespace but only certain users can push images to it,
  • only certain users can pull and push to a certain namespace; making all the images inside of it invisible to unauthorzied users.

This is done implementing the token based authentication system supported by the latest version of the Docker registry.

Docker login and Portus authentication in action Portus as a front-end for Docker registry

Portus listens to the notifications sent by the Docker registry and uses them to populate its own database.

Using this data Portus can be used to navigate through all the namespaces and the repositories that have been pushed to the registry.

We also worked on a client library that can be used to fetch extra information from the registry (i.e. repositories’ manifests) to extend Portus’ knowledge.

The current status of development

Right now Portus has just the concept of users. When you sign up into Portus a private namespace with your username will be created. You are the only one with push and pull rights over it; nobody else will be able to mess with it. Also pushing and pulling to the “global” namespace is currently not allowed.

The user interface is still a work in progress. Right now you can browse all the namespaces and the repositories available on your registry. However user’s permissions are not taken into account while doing that.

If you want to play with Portus you can use the development environment managed by Vagrant. In the near future we are going to publish a Portus appliance and obviously a Docker image.

Please keep in mind that Portus is just the result of one week of work. A lot of things are missing but the foundations are solid.

Portus can be found on this repository on GitHub. Contributions (not only code, also proposals, bugs,…) are welcome!

Categories: FLOSS Project Planets

conf.kde.in ’15 – My views

Thu, 2015-04-23 14:40

This year’s conf.kde.in – KDE India’s annual conference on KDE/Qt technologies, was hosted in Amrita University’s Amritapuri campus and it still feels kinda surreal indeed. Thankfully, it all unfolded well enough. It was the first time a KDE conference was being hosted in Southern India or at least in Kerala to the best of my […]

Categories: FLOSS Project Planets

And, it is official

Thu, 2015-04-23 11:58

Softpedia was one of the first to break the news, with the headline, “Kubuntu 15.04 Officially Released, Based on Beautiful Plasma 5 Desktop”. They write:

Kubuntu developers don’t usually integrate a custom KDE experience, so Kubuntu is the perfect opportunity to test and see what the developers want to achieve with latest and best of KDE. This is close to what the makers of this great desktop environment are really trying to achieve, so you can easily use Kubuntu as a standard by which any other KDE-powered OS can be judged.

Categories: FLOSS Project Planets

Kubuntu 15.04 – the most beautiful desktop alive

Thu, 2015-04-23 11:48

We’ve released Kubuntu 15.04, thanks to all who helped.

And thanks to Lucas from the VDG we have a pretty video to introduce the world to the new desktop – Plasma 5.

by
Categories: FLOSS Project Planets

Identities, I usually don’t stop being myself

Thu, 2015-04-23 11:19

One of the most interesting developments I’ve seen recently inside KDE is KAccounts (or Web Accounts, as it used to be called). It’s not even a KDE project, but a project Nokia started some years ago, I’m guessing that on MeeGo days.

Why do I care?

As a developer it’s always very important to know what resources you have available. The more you have, the richer the users’ experience will be. Resources are not only hardware but often just semantically-structured information. For example, KPeople helps us tell apart the contact list and offers us people instead or Solid, that turns the different ways of exposing the hardware information into something easily consumable by front-end applications.

Now we’re talking about identities. We don’t exclusively rely on local data anymore, I think that’s a fact nowadays (and even 5 years ago). Our disks are just another place where we store some of our data. KDE projects must be prepared to easily offer such workflows. One of the important parts to do it properly is authentication:

  • We need a list of available services we can use.
  • We don’t want our users requested identity authentication all the time.
  • We don’t want each application to implement the N authentications algorithms of the N different providers our users will eventually have.
Why do you care? (as a KDE software user)

First of all, you want your developers to have the best tools (GOTO: “Why do I care?”).

board meeting of @kdecommunity in progress pic.twitter.com/rIVojmuyFB

— Lydia Pintscher (@nightrose) April 12, 2015

There’s a more important issue to figure out, more ideological than technical: We ask service and software providers to use standard specifications to improve interoperability, but then in practice we are seldom leveraging it. The case-by-case set up burden makes it hard for users to have everything configured properly. An example for this is ownCloud integration. I know a couple of people running an instance, but they seldom integrate it in Dolphin, but even if they did they’d still need to integrate the rest of provided services, such as calendar, contacts, etc.
We want to tell our software what providers we have available, those providers will provide different services. The software should integrate as much as possible with those services.

How can I help?
  • Testing: There’s a lot going on, thorough testing and ideas is important. Both when it comes to making sure everything works as expected as well as what software should adopt KAccounts. It will already be available with KDE Applications 14.04.
  • Developing: Make sure your application of choice uses KAccounts to figure out the configured services. Here’s a good place to find documentation: API, and an example use-case.
  • Promotion: It’s important to reach out to service providers, make sure they know there’s such possibility and hopefully they can help us work better with their services (hey! by the book example of a win-win situation!).

Nowadays our computation experience is spread among different services and we need to be smart enough to understand how our users will adopt them and make it as transparent as possible.
AccountsSSO and KAccounts are a solid step forward in this direction, let’s get back in control of our data!

Categories: FLOSS Project Planets

[Howto] LDAP schema for Postfix

Thu, 2015-04-23 07:27

The official Postfix documentation to use LDAP for user and alias lookup mentions certain LDAP attributes which are not part of the default OpenLDAP. In this article I will shortly explain a basic theme providing these attributes and the corresponding object class.

Postfix can easily be connected to LDAP to lookup addresses and aliases. The Postfix LDAP documentation covers all the details. As mentioned there the default configuration of Postfix expects two LDAP attributes in the LDAP schema: mailacceptinggeneralid and maildrop. This also shows in the code in src/global/dict_ldap.c:

dict_ldap->query = cfg_get_str(dict_ldap->parser, "query_filter", "(mailacceptinggeneralid=%s)", 0, 0);

However, these attributes are not part of the default OpenLDAP installation, and the Postfix documentation does not mention how exactly that has to look like and where to get it. For that reason we at my employee credativ provide such a schema at Github: github.com/credativ/postfix-ldap-schema. The github repository contains the schema, the corresponding licence and a short documentation. A German introduction to the schema can also be found at credativ’s blog: LDAP-Schema für Postfix-Abfragen

The provided schema defines the necessary attribute types mailacceptinggeneralid and maildrop as well as the object class postfixUser. Please note that in this schema the used OIDs are of the type Experimental OpenLDAP, see also the OID database.

To use the schema it must be used by OpenLDAP, for example by including in in slapd.conf. A corresponding LDAP entry could look like:

dn: uid=mmu,ou=accounts,dc=example,dc=net objectclass: top objectclass: person objectclass: posixAccount objectclass: postfixUser cn: Max Mustermann sn: Mustermann uid: mmu uidNumber: 5001 gidNumber: 5000 homeDirectory: /home/vmail mailacceptinggeneralid: mmu mailacceptinggeneralid: max.mustermann mailacceptinggeneralid: m.mustermann mailacceptinggeneralid: bugs maildrop: mmu

As you see the example covers multiple aliases. Also, the final mailbox is a domain less entity: maildrop: mmu does not mention any domain name. This only works if your mail boxes actually do not require (or even allow) domain names – in this case this was true since the mail is finally transported to a Dovecot server which does not know about the various domains.

Please note that this schema can only be the foundation for a more sophisticated, more complex schema which need to be tailored to fit the individual needs of the corresponding setup.


Filed under: Business, E-Mail, HowTo, Linux, Technology, Thoughts
Categories: FLOSS Project Planets

Calligra @ conf.kde.in

Thu, 2015-04-23 07:26
Reading maketh a full man ; conference a ready man ; and writing an exact man. -Francis Bacon
It feels great to learn that KDE conf India has grown bigger and bigger every year and so has the KDE India community. A lot of new open source enthusiasts can be seen around who are willing to contribute as much as they can. Our aim of hosting KDE conf in India is to provide a platform for the enthusiasts to begin their journey in open source and know more about KDE, its awesome applications, features and how one can contribute.
This year the conference was hosted in the "God's Own Country" Kerala. Amritapuri University, known for its active involvement in various FOSS activities, hosted the conference. They had a beautiful campus situated right beside the beach and an island at a 5 min walk. 

Beach & the island!Noufal Ibrahim, founder of Pycon India, opened the conference with keynote talk on the power of Command Line. His interests were not totally aligned with those of KDE but still he managed to motivate the students to chose Linux over other proprietary OS. This talk was followed by Shantanu and Pradeepto's talk where they explained the philosophy behind KDE, its applications and how beautifully it is designed for users and developers. This talk set the right mood for the audience to pick up KDE and gave them a background for the talks to follow. There were various talks where speakers explained the products they have been working on and motivated the enthusiasts to contribute. Day 1 ended with Qt Workshop which allowed the attendees to get a taste of Qt and gain confidence by working on real world software.
Day 2 began with a talk on Marble where Sanjiban Bairagya took us through a virtual tour of Earth and Moon and showed us the beauty of Marble. This talk was followed by Sinny Kumari showing us how to build applications on Qt and port it for Android and how to release the app on Google Play Stores. 
This talk was followed by my talk on Calligra. The aim of delivering this talk was to make the audience aware of Calligra Suite. I began the talk by asking the audience if they had used Calligra before and surprisingly majority of the audience were hearing the name for the first time. So, giving a talk on Calligra was perfect as at the end of the talk listerners would be curious to use the new software. The talk began with introducing them to Calligra and giving them a brief idea of the history behind building the application. Once the audience got a hang of what Calligra is , I went ahead and showcased the applications and asked the audience to guess the alternative applications they had used in place of Calligra (eg. Libreoffice Writer in place of Calligra Words) and they judged it all correctly. So, I was happy that Calligra Applications have perfect self-explanatory names. Then I went ahead and gave them a demo of Calligra Flow, showed them beautiful art work possible in Krita (by David Revoy) and introduced them to Calligra Author ( whose concept seems very interesting to me). Then I introduced them to Sheets, Words, Kexi, Braindump, Stage, Plan & Karbon. I suggested them to use Plan, Flow , Krita and Words for their everyday use and for Univerisity projects.
Talk on CalligraNow the audience seemed pretty enthusiastic to know more, so I went deep and explained them Calligra Architecture and how sharing libraries helps us build and maintain huge code with optimum effort. The perfect example here was that Calligra built 10 application with 4.1MLoc and Libreoffice built 6 applications with 7.16 MLoc. It clearly shows how good & powerful Qt is which allows new developers to start working straight away. As the story goes, its not just developers who can contribute to the project, I explained them how they can also contribute by bug reporting, translating and documenting. In the end I showed them Calligra Sprint group photos to show how developers from round the globe come together with a common vision to develop Calligra. 
My talk was followed by a talk on Qt little games by Rishab arora where he explained game theory and demonstrated a game which he built using Qt. Post lunch on Day 2, Devaja Shah spoke about KDE Galaxy, Ashish talked about MPRIS support for multimedia applications and Karan introduced Trojita. 
All the talks got good response and there were a lot of enthusiastic students who wanted to contribute straight away by writing code & committing patches.
I would like to thank Boudewijn Rempt, Inge Wallin, Shantanu Tushar for giving me tips on making the presentation. Inge spent a lot of time explaining me the concept and vision behind Calligra Author which I had never used before myself. It is still developing but has an amazing concept. 
I would also like to thank KDE & Red Hat for making this talk possible. 
 

It is always awesome for me to meet KDE folks from all over the country. Every year I see some new faces and some old faces and it is satisfying to realize that it has been years since my journey started with KDE and the energy level hasn't gone down. 
KDE India Group & Volunteers

Categories: FLOSS Project Planets

Another amazing conf.kde.in !

Wed, 2015-04-22 17:07

Conf.kde.in 2015 –  KDE conference organized by passionate KDE India team. This year it took place in Amrita college, Kerala from 17th to 18th April.  Schedule of these two days conference included talks on various KDE applications, Qt tutorial,  how to contribute to KDE, etc. We also organized Qt workshop to give a hands-on feeling to attendees.  Slides and pictures from conference are available.

 

Compared to past conf.kde.in, I felt venue of this year pretty different because this college had very cultural touch as it was near to Ahsram, it also had beautiful beach around 10 minutes walking distance from venue, beautiful backwater flowing very near to Guest house we were staying, also teachers of college were interested and involved as well throughout conference and were personally taking care whether everything is fine or not.

    

Day1

After registration, first day of conference started with opening ceremony where college teachers involved in FOSS community, Pradeepto Bhattacharya and Noufal Ibrahim addressed it by lighting lamp and traditional college prayer.

    

This year we did something different and as a result we had a keynote speaker Noufal Ibrahim who is Kerala based and is founder of PyCon India and PSF board member since 2012. It was pleasure in listening to his talk Reusable software – the UNIX way. In his talk he showed how easily you can come to know what exactly a book is about by using few UNIX command – sort, ls, wc, grep, awk, tail, uniq. It was good to see the power of UNIX commands and people appreciating it.

Further Pradeepto gave brief introduction to what KDE is, its aim and objective. In addition to that Shantanu gave a glimpse of different awesome KDE applications and showed how beautiful KDE software and helpful community is.  To keep conference interactive, Shantanu announced among audience that whoever will ask or answer question will get Qt/KDE stickers and goodies and it really worked :D

In order to keep audience curious and interested, next talk was on Krita– Awesome digital Painting Software by Somsubhra Bair who is contributing to Krita from around 2 years.  He showed couple of beautiful videos about painting in Krita and talked what other powerful and amazing work you can do using krita.

        

Later Pinak Ahuja talked about his SoK experience and how he started contributing to KDE. This talk was quite motivating to attendees in order to getting started with KDE. To add more motivation and building confidence in attendees,  Shantanu gave Qt/QML basic tutorial and showed how easily you can create basic elements like Rectangle, images, etc in QML and how easily you can add animation to it. To give a hands-on experience we also added workshop for students in college lab where Qt creator and needed libraries were already set-up by local volunteers. Everyone enjoyed building basic application themselves and few of them were also able to do what Shantanu gave task. We all speakers were helping out attendees with problem and queries.

 

     

Day 2

Second day started with A tour to Marble project  by Sanjiban Bairagya where he talked about  different features of Marble like virtual tour from one place to another comprises of earth and also other planets like Mars. He also demonstrated how easily you can navigate from one place to another over globe.

Next was my talk where I talked this time on a different topic – Qt on Android.  I opted this topic because I knew there is lot of craze among students for creating android apps. So, I thought let me learn how to make Android app using Qt and talk on same. I demonstrated how easily you can run your Qt application on android and distribute generated .apk file to others and also how to publish app to Google play store. Android app which I created was Imgs and somehow I managed to publish it to Google play store. Attendees were very much interested in listening to this talks and it seems more than  50% of them had android phone and most of them were interested in creating their own Android application.

 

   

Further, talks were going on in conference room and in parallel we also conducted Qt/QtQuick workshop for few first year students who missed out in Day1. I was helping students with their doubts, issues and monitoring ensuring if everyone is on track. It was good to see that all first year college students were able to grasp whatever Shantanu demonstrated and were able to do it by own.

Interesting talk from Ashish Madeti on MPRIS support for multimedia applications. Ashish started his KDE journey from conf.kde.in 2014 and in one year he did really great work in KDE and especially in Plasma Media Center and Simon project in order to add MRIS support and enabling voice command in PMC. It was very good to see a student  giving talk who started his KDE journey from same conference, it felt rewarding and worth doing KDE conference in India :)

   

Last talk of the day and conference was by Karan Luthra on Trojitá project. Karan talked about what all features Trojitá provides and why to use it and how  to contribute into it. It was good to see a fast and lightweight  email client. Looking forward to try it out in my system and will see whether it fits my need or I should continue using Kmail.

        

At the end of conference, attendees and speakers were talking to each other and having discussion on  KDE projects they were interested on. I also distributed Fedora stickers sheets among attendees which I got from my Fedora friends and talked to few attendees/teachers regarding attending upcoming FudCon APAC conference.

Another conf.kde.in ended with the help of hard work involved by Organizers, volunteers and local college authorities. I was so excited to know how Harish who took initiation for organizing this year conf.kde.in met Pradeepto and rest all happened.  Many thanks to KDE eV for sponsoring me as well as other speakers to make this event successful. I am proud to be a KDE contributor and being a part of such an awesome and loving community. I hope with this year conf.kde.in we will get another few new member in our KDE family :)

Cheers!


Categories: FLOSS Project Planets