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

Open Source Conference in Oslo – May 8 – 10

Mon, 04/27/2015 - 17:53

In just a few days we’ll have an open source conference in Oslo. I’m happy that we’ll have a Qt and KDE track, so I’d like to invite everyone to join for the weekend May 8-10 at the University of Oslo.

If you’re involved with KDE or Qt and would like a promo code, just send me a message.

Just head over to osdc.no and join!

The program can be found here: http://act.osdc.no/osdc2015no/talks

Swapnil Bhartiya Finds a Totally Different Kubuntu

Mon, 04/27/2015 - 17:52

kubuntu-non-kde

Swapnil Bhartiya writes:

Kubuntu 15.04, aka Vivid Vervet, was released last week. With this release it has become the first major distro to ship Plasma 5 as the default desktop environment.

 

Fast forward to 2014 and Kubuntu turned out to be a totally different OS. I have been running it on one of my production systems since 14.04. It’s extremely stable, polished and offers a great experience.

 

Kubuntu features one of the best notification systems in the Linux world.

 

Kubuntu 15.04 is undoubtedly the best Plasma 5 desktop so far, for the simple fact that this is the first distro to ship with it. Since Kubuntu offers a vanilla Plasma experience, you can enjoy what KDE developers originally developed without it being heavily patched or modified. Well, modification can be good in some cases where a particular may not gel very well with the distro.

 

In a nutshell, I found Kubuntu 15.04 to move consistently on the path of improvement, getting better with each release. If you are hesitant about Kubuntu due to a previous release, let me tell you that a lot of water has flowed under the bridge since. It’s a totally different Kubuntu.

 

Try it out and you will be surprised with what you have been missing until now.

And that is even before Plasma 5.3

Spring break for the KDE system monitor

Mon, 04/27/2015 - 12:44

KSysGuard underperformes in both visual as well as functional respect. Unfortunately it is not actively maintained yet so we are looking for developers first before starting with ideas about the redesign.

Keep on reading: Spring break for the KDE system monitor

kreenshot-editor is incubating

Sun, 04/26/2015 - 21: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.

kreenshot-editor is incubating

Sun, 04/26/2015 - 21: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.

Incubating kreenshot-editor

Sun, 04/26/2015 - 21: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.

KActivities powered recent media in Plasma Media Center

Sun, 04/26/2015 - 16: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.

Recent videos in Plasma Media Center

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!

newsFish news client for ownCloud

Sun, 04/26/2015 - 13: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

Blog tags: QtkdeownCloudAndroid

Cantor in KDE Applications 15.04

Sun, 04/26/2015 - 09: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-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!

cantor-backends

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.

Ícone do Cantor

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.

Building on new pillars: Activities and KPeople in Plasma 5.3

Sat, 04/25/2015 - 16: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
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
    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

Application Menu's Recent Contacts category in Plasma 5.3
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!

Cross Platformity

Sat, 04/25/2015 - 10: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...

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

Fri, 04/24/2015 - 15: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

Turning the world upside down

Fri, 04/24/2015 - 11: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.

Use Geofix to Geotag Photos in digiKam

Fri, 04/24/2015 - 11: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

My experiences at conf.kde.in 2015

Fri, 04/24/2015 - 05: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.

metalk

metalkside

melisten

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.

group

groupbeach

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.

last2

last3

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


Dusting KMouth

Fri, 04/24/2015 - 02: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.

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

Thu, 04/23/2015 - 19: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.

repositories view

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!

conf.kde.in ’15 – My views

Thu, 04/23/2015 - 18: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 […]

And, it is official

Thu, 04/23/2015 - 15: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.

full-screen-wee

Kubuntu 15.04 – the most beautiful desktop alive

Thu, 04/23/2015 - 15: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.

facebooktwittergoogle_pluslinkedinby feather

Pages