Planet KDE

Syndicate content
Planet KDE - http://planetKDE.org/
Updated: 2 hours 9 min ago

Gardening Recipes

Wed, 2014-11-26 21:02

You thought this would have something to do with working outside and/or cooking something. You were wrong.

As Albert blogged previously the KDE gardening team's love project this time is KRecipes.
The mailing list has been moved.
The website content has been added to userbase.
The 2.0 release is on upload.kde.org, soon to be moved into place (a new place since download.kde.org hasn't done a krecipes release before).

Anyone that would like a relatively small way to quickly help KRecipes out it could use some patches on reviewboard (group added, sending to the new mailing list already) to port away from Qt3support classes. Some other ideas off the top of my head also:

1. Make it use kunitconversion to convert metric units to imperial units for those of us stuck in countries that use imperial measuring systems.
2. Freshen up the ui a bit so it looks less like a database viewer and more like a recipe viewer/editor.

Categories: FLOSS Project Planets

Reminder: Desktops DevRoom @ FOSDEM 2015

Wed, 2014-11-26 19:14

We are less than 10 days away from the deadline for the Desktops DevRoom at FOSDEM 2015, the largest Free and Open Source event in Europe.

Do you think you can fill a room with 200+ people out of 6,000+ geeks? Prove it!

Check the Call for Talks for details on how to submit your talk proposal about anything related to the desktop:

  • Development
  • Deployment
  • Community
  • SCM
  • Software distribution / package managers
  • Why a particular default desktop on a prominent Linux distribution
  • etc

http://www.elpauer.org/2014/10/fosdem-2015-desktops-devroom-call-for-talks/

Categories: FLOSS Project Planets

Colorpick

Wed, 2014-11-26 12:36

Recently I wrote about my so-called "lightweight project management policy". I am going to start slowly and present a small side-project: Colorpick.

Colorpick is a color picker and contrast checker. I originally wrote it to help me check and fix the background and foreground colors of the Oxygen palette to ensure text was readable. Since then I have been using it to steal colors from various places and as a magnifier to inspect tiny details.

The main window looks like this:

Admittedly, it's a bit ugly, especially the RGB gradients (KGradientSelector and the Oxygen style do not play well together). Nevertheless, it does the job, which is what side-projects are all about.

Here is an annotated image of the window:

  1. The current color: clicking it brings the standard KDE color dialog. The main reason it's here is because it can be dragged: drag the color and drop on any application which supports color.

  2. The color in hexadecimal.

  3. Luminance buttons: click them to adjust the luminance of the color.

  4. Color picker: brings the magnifier to pick a color from the screen. One nice thing about this magnifier is that it can be controlled from the keyboard: roughly move the mouse to the area where you want to pick a color then position the picker precisely using the arrow keys. When the position is OK: press Enter to pick the color. Pressing Escape or right-clicking closes the magnifier.

    Picking the color of the 1-pixel door knob from the home icon. The little inverted-color square in the center shows which pixel is being picked.

  5. Copy button: clicking this button brings a menu with the color expressed in different formats. Selecting one entry copies the color to the clipboard, ready to be pasted.

  6. RGB sliders: not much to say here. Drag the cursors or enter values, your choice.

  7. Contrast test text: shows some demo text using the selected background and foreground colors, together with the current contrast value. It lets you know if your contrast is good enough according to http://www.w3.org/TR/WCAG20/#visual-audio-contrast.

Interested? The project is on GitHub at https://github.com/agateau/colorpick. Get it with git clone https://github.com/agateau/colorpick then follow the instructions from the INSTALL.md file.

Categories: FLOSS Project Planets

QImage and QPixmap in a Qt Quick item

Tue, 2014-11-25 16:50

For reasons I don’t know, apparantly a Qt Quick Item that can show a QImage or a QPixmap is kind of missing. The current Image QML item only works with data that can be represented by a URL.

So I wrote one that kind of works. Comments most welcome.

It is found on git.kde.org: http://quickgit.kde.org/?p=scratch/sune/imageitem.git

Oh, and the KDE End of Year fundraiser is still running. https://www.kde.org/fundraisers/yearend2014/. Go support it if you haven’t already.

Categories: FLOSS Project Planets

Qt on Android Episode 5

Tue, 2014-11-25 08:06

After we’ve seen how to set up the development environment, how to use Qt on Android and what deployment systems are available and how to sign the final package, it’s time to move forward. In this article we are going to learn about JNI.

Why do we need JNI?

Because it is impossible for Qt to implement all Android features. To use any of them we’ll need to use JNI to access them. JNI the only way to do calls to/from Java world from/to native (C/C++) world.

JNI intro In this article we’ll learn the basics of the JNI, in the next article(s) we’re going to learn how to use this knowledge to correctly extend Qt on Android apps.

There is tons and tons of information on this matter on the net, in this article I’m focusing only on how to do JNI on Android using Qt. Starting with 5.2, Qt ships Qt Android Extras module. This module makes our life much more pleasant when we’ll have to do JNI.

There are two use cases:

  • Call a Java function from C/C++
  • Callback a C/C++ function from Java
Call a Java function from C/C++

Calling a Java function from C/C++ using Qt Android Extras module is quite easy.

First let’s create a Java static method:

// java file android/src/com/kdab/training/MyJavaClass.java package com.kdab.training; public class MyJavaClass { // this method will be called from C/C++ public static int fibonacci(int n) { if (n < 2) return n; return fibonacci(n-1) + fibonacci(n-2); } }

So, we defined fibonacci static method into MyJavaClass class into com.kdab.training package. This method returns the computed fibonacci number.

Now let’s see how to call it from Qt. The first step is to make sure we are using the android extras, so we need to add it to our .pro file.

# Changes to your .pro file # .... QT += androidextras # ....

Then do the actual call:

// C++ code #include <QAndroidJniObject> int fibonacci(int n) { return QAndroidJniObject::callStaticMethod<jint> ("com/kdab/training/MyJavaClass" // class name , "fibonacci" // method name , "(I)I" // signature , n); }

Yes, that’s all folks!

Let’s take a closer look to this code and see what we have here:

  • we are using QAndroidJniObject::callStaticMethod to call a Java static method.
  • first argument is the fully-qualified class name. The fully-qualified name for a class (or interface) is the package name (com/kdab/training) followed by the class/interface name(MyJavaClass), separated by a slash (/) (NOT by a period, the period is used only in Java world not in C/C++ world!)
  • the next argument is the method name
  • the next is the method signature
  • the next arguments are the arguments that will be passed to the java function

Please check QAndroidJniObject documentation for more information about method signature and the arguments types.

Callback a C/C++ function from Java

In order to callback a C/C++ function from Java you need to do the follow steps:

  • declare the native method(s) in Java, using native keyword
  • register native method(s) in C/C++
  • do the actual call
Declare the native method(s) in Java, using native keyword.

Let’s change the previous java code a little bit:

// java file android/src/com/kdab/training/MyJavaClass.java package com.kdab.training; class MyJavaNatives { // declare the native method public static native void sendFibonaciResult(int n); } public class MyJavaClass { // this method will be called from C/C++ public static int fibonacci(int n) { if (n < 2) return n; return fibonacci(n-1) + fibonacci(n-2); } // the second method that will be called from C/C++ public static void compute_fibonacci(int n) { // callback the native method with the computed result. MyJavaNatives.sendFibonaciResult(fibonacci(n)); } }

Let’s take a closer look to this code and see what we have here:

  • personally, I prefer to keep all my native method(s) in a separate class, so, I declared sendFibonaciResult native method into MyJavaNatives class into com.kdab.taining package. This native method will be used by compute_fibonacci static method to callback the C/C++ world to send the computed result instead to return it as fibonacci method does.
  • compute_fibonacci, this method will be called from C/C++, but instead to return the result as fibonacci method does, it uses sendFibonaciResult native method to callback the C/C++ world to end the result.

If you try only this code it will fail, because sendFibonaciResult is not registered, and Java VM doesn’t know it yet.

C/C++ register native methods

Now let’s see how to register the function in C/C++.

First thing you need to know is that you can register only function(s). You can NOT register C++ class (non-static) members!

There are two ways to register native methods, we are going to check both ot them:

Registering functions using Java_Fully_Qualified_ClassName_MethodName #include <jni.h> #include <QDebug> #ifdef __cplusplus extern "C" { #endif JNIEXPORT void JNICALL Java_com_kdab_training_MyJavaNatives_sendFibonaciResult(JNIEnv *env, jobject obj, jint n) { qDebug() << "Computed fibonacci is:" << n; } #ifdef __cplusplus } #endif

Let’s take a closer look to this code and see what we have here:

  • First thing we’ve seen, is that all the functions must be exported as C functions and NOT as C++ functions!
  • The function name MUST follow the next template: Java word, followed by the package name, then followed by the class name, then followed by the method name,separated by an underscore (_)
  • When JavaVM loads the .so file, it will search for this template and it will automatically register all your functions for you
  • the first argument (env) of the function is a pointer to JNIEnv object.
  • the second argument (obj) is a reference to the Java object inside which this native method has been declared.
  • the first and second arguments are mandatory for every function that you’ll register.
  • the next arguments must match the java native method arguments. So, our third argument is actually our first (and only) java native method argument. This is the argument that compute_fibonacci will pass to sendFibonaciResult native method when it calls it.

Using this method to register is quite easy to declare and register, but it has a few disadvantages:

  • the function names are huge:

    Java_com_kdab_training_MyJavaNatives_sendFibonaciResult

  • the library must to export all functions
  • unsafer, there is no way for the JavaVM to check the function signature, because the functions are exported as C functions and NOT as C++ functions!
Use JNIEnv::RegisterNatives to register native functions

In order to use JNIEnv::RegisterNatives to register native functions, we need to do the following 4 steps to use it:

  • step 1: we need get access to an JNIEnv pointer. The easiest way is to define and and export JNI_OnLoad function, (once per .so file) in any .cpp file we like.
  • step 2: create a vector with all C/C++ methods that we want to register.
  • step 3: find the ID of java class that declares these methods using JniEnv::FindClass
  • step 4: call JNIEnv::RegisterNatives(java_class_ID, methods_vector, n_methods)
// C++ code #include <jni.h> #include <QDebug> // define our native method static void fibonaciResult(JNIEnv */*env*/, jobject /*obj*/, jint n) { qDebug() << "Computed fibonacci is:" << n; } // step 2 // create a vector with all our JNINativeMethod(s) static JNINativeMethod methods[] = { { "sendFibonaciResult", // const char* function name; "(I)V", // const char* function signature (void *)fibonaciResult // function pointer } }; // step 1 // this method is called automatically by Java VM // after the .so file is loaded JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* /*reserved*/) { JNIEnv* env; // get the JNIEnv pointer. if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) { return JNI_ERR; } // step 3 // search for Java class which declares the native methods jclass javaClass = env->FindClass("com/kdab/training/MyJavaNatives"); if (!javaClass) return JNI_ERR; // step 4 // register our native methods if (env->RegisterNatives(javaClass, methods, sizeof(methods) / sizeof(methods[0])) < 0) { return JNI_ERR; } return JNI_VERSION_1_6; }

Let’s check the code for a better understanding:

  • static void fibonaciResult(JNIEnv */*env*/, jobject /*obj*/, jint n) it is the method that we’re registering and which Java VM will call.
  • the first argument (env) of the function is a pointer to JNIEnv object.
  • the second argument (obj) is a reference to the Java object inside which this native method has been declared.
  • the first and second arguments are mandatory for every function that you’ll register.
  • the next arguments must match the java native method arguments. So, our third argument is actually our first (and only) java native method argument. This is the argument that compute_fibonacci will pass to sendFibonaciResult native method when it calls it.
  • we add the method to a vector (methods) of JNINativeMethod structures.
  • JNINativeMethod structure has the following fields:
    • const char* name – it is the function name, it has to be exactly as the native function name that we’ve declared in Java
    • const char* signature – it is the function signature, it has to match the native function arguments that we’ve declared in Java
    • void* fnPtr – it is the C/C++ function pointer. In our case it’s a pointer to static void fibonaciResult(JNIEnv */*env*/, jobject /*obj*/, jint n) function. As you can see the C/C++ function name doesn’t matter, the Java VM needs only a pointer to it.
  • the rest of the code is clear and easy and I don’t think it needs any explanations than the comments.

Even if it looks a little bit complicated to use it, this method has the following advantages:

  • the C/C++ function can have any name you want
  • the library needs to export only one function (JNI_OnLoad)
  • safer, because the Java VM checks the declared signature

It’s just a matter of taste which method you decide to use to register your native functions. I do recommend you to use JNIEnv::RegisterNatives as it offers you extra protection because the Java VM checks the functions signature and it throws an exception if it doesn’t match.

Conclusion In this article we’ve learned the basics of the JNI, in the next article(s) we’re going to learn how to use this knowledge to correctly extend Qt on Android apps. We’ll talk more about Qt on Android apps architecture, how to extend the Java part of your application and we’ll take a real life example to show how to correctly do safe calls from Qt thread to Android UI thread and vice-versa.

Thank you for your time!

The post Qt on Android Episode 5 appeared first on KDAB.

Categories: FLOSS Project Planets

Paris Coders Night and Liam Boogar’s complete dismissal of women’s Issues

Tue, 2014-11-25 07:16

Hi! I’m Etiene, 26, female, Brazilian, computer engineering student in France.

It all began when I found out about this Paris Coders Night event. I was very excited. I’m an exchange student in Britanny and I’m not often tuned on what’s going on near me and I don’t often have money to attend to conferences and events in another country. So finding this event so close to me (few hours in a train) this weekend seemed really cool. It’s supposed to be a programmer’s party. You drink, you code, you meet people. Cool.

But then I got a bit hesitant. I’ve been to tech / geek events before. You all know it’s a male dominant environment. Sometimes I am called by “the girl” instead of my real name. I was already asked what the hell was I doing there or if I was someone else’s girlfriend. Both these situations happened at Campus Party Brasil. It’s often awkward for women to participate in such events and, unfortunately, things seem to be getting worse and not better for us in there.

 

 

 

I have all of this in mind, plus the fact that I’m currently trying to deal with a case in my university where two douches sent an email to all university students making a “””joke””” about collective raping a cheerleader and so far nothing happened to them. Sometimes I don’t even have words to describe this situation.

So, I started taking a look at Paris Coders Night website to see what was their position on this kind of incident. Unfortunately I found no information. There was no Code of Conduct, nor an anti-harassment policy.  And I don’t want to spend my money to buy train tickets and the entrance fee only to arrive there and find lap dancers and condoms being distributed. As I’m not interested in being rubbed or fucked in some event but actually coding and meeting people, I got concerned about the total lack of information on which behaviors are welcome or not according to the organizers. As besides Deezer, mobiskill, PayPal, mailjet and HumanCoders they have Girls in Tech Paris as a partner,  I thought it was a possibility that they did care but they overlooked the importance of this issue, which is very clearly explained by Ada Initiative. They provided twitter as a contact method, so I decided to tweet them.


So far so good, I thought they would go for “thanks for the suggestions, we’ll take a look into it.” but no. Not in my wildest dreams. Instead, what I got as response was:

At this moment I was speechless. What did they want? A golden medal for not having reports of women harassed in one of their events? I’m really glad that as I far as I know everyone is fine. But this is called reassuring and prevention. Then the organizer of .concat(), a conference yet to take place in Austria, intervened:

Which was then followed by a series of incredibly misplaced tweets from @LiamBoogar, editor of RudeBaguette, the event’s organizer, including:

Let’s just sit on this: “I’ve only just heard of this CoC today”. I mean, does he really call himself an event organizer? What the hell? Ok, let’s suppose he’s “learning” (even though he later claimed to participating in the organization of events that gathered 5000+ attendees in 2014), he could just read the text by Ada Initiative and put a little thought on it before dismissing my suggestion entirely. This worries me a lot, because if the organization of an event doesn’t want to take the time to copy paste one paragraph into their website, I do wonder, what could possibly happen if a real issue was to be solved by their hands? Probably with the same dismissal! I mean, this is the simplest thing they could do! Why won’t they? And as if this was not enough, he goes on:

So after I tell him that now I’m afraid to attend to his event and I’ve settled for not going anymore, he decides the best to do is to keep on denial acting like a douche and send me a bot-like reply. I mean, who the fuck cares if a woman is afraid to attend to your event, right? Classy.

 

I tried to organize all tweets involved in this convo in chronological order: FULL CONVERSATION HERE. For this compilation I used Lua, Sailor and Ignacio’s LuaOAuth module to communicate with Twitter API.

For an inspiring insight about diversity in technology, I recommend watching this video by Lena Reinhard on diversity in open source.

This is a Guest Post from Etiene, a very good friend of mine, amazing hacker. And this needs to be on PlanetKDE even if it’s not directly related on KDE. Original Post Here: http://etiene.net/paris-coders-night-incident/


Categories: FLOSS Project Planets

What's Holding ownCloud Back?

Tue, 2014-11-25 05:19
In the recent article about the ownCloud event program, I pointed out that while ownCloud has 2.5 million users, it is a drop in the ocean looking at the number of Internet users (a little over 4 billion today). The announcement of the "Let's Encrypt" initiative from the Electronic Frontier Foundation, Mozilla and others prompted me to write this: it is one step in the direction of removing the limitations holding back wider ownCloud adoption. What does the future hold?

Easy ownCloudAs Frank pointed out in his blog on the future of PHP, ownCloud has ease of use as an explicit and very important goal. And while the technological choices made aren't always so exciting and bleeding edge, they do result in ownCloud being very easy to deploy on a very wide range of devices. Plenty of tutorials exist showing it running on everything from Rasberry Pi devices to big iron at organizations like CERN, where physicists looking for the origins of the universe are routing hundreds of terrabytes of data through their CernBOX build on ownCloud, sharing and collaborating on the data analysis.

LimitationsUnfortunately, there are limitations outside of what ownCloud can directly control.

In the database area, SQLite is default because it requires no manual setup whatsoever. But performance suffers when an installation has more than a trivial amount of data. When sharing with more than 15 users or indexing your mp3 connection, SQLite usage leads to frequent time-outs and other issues!

Another, more serious issue, is the architecture of the current internet. Most users are set up at home behind a firewall provided by their internet router. While this provides some additional security, it is mainly because the limited number of unique addresses available in the still widely-used 'IPv4' protocol. It simply is impossible to assign a unique address to each device connected to your internet at home. But this means your server will not be reachable when you're not home, unless you adjust some settings on your router. While we can configure some routers automatically, most we can't and as every router is different, an easy 'generic' how-to can't be provided either.

A third issue is that an ideal ownCloud platform would be small and cheap devices like the Raspberry Pi, but these are almost all based on 32bit CPU's. Due to technical limitations in the platform ownCloud builds on, this means you won't be able to have it handle files bigger than about 4 gigabyte! That is a big limitation if you'd like to store your virtual machine or Blue Ray collection on your ownCloud.

The fourth issue I see is security. While not the biggest problem of the three, setting up a server to be secure, including a decent SSL certificate, is not easy. I personally couldn't figure it out and while I'm new to server things, I am not a technology hater by any means. My parents wouldn't ever be able to figure it out and more importantly, they wouldn't want to!
SolutionsThese four issues to wider ownCloud adoption aren't the only ones, but as far as I can tell, the biggest. So how do we deal with it?

There are several routes to an even easier ownCloud installation. Having a pre-setup operating system in the form of a container (Docker?) or a virtual machine can take care of much of the trouble around database setup and help a lot with the security issue. However, it can't run on light hardware like a Raspberry Pi and doesn't deal with the file size problem.

When it comes to the address limitations, the internet is slowly transitioning to IPv6 which will provide more unique addresses for each person than IPv4 offered in total (see here how Google explains IPv6). So, essentially, we just have to wait for this problem to be solved.

The hardware problem is also working on solving itself: the upcoming new swath of ARM CPU's (and Intel CPU's targeting the embedded market) are fully 64 capable so while current-gen Raspberry Pi devices (and other embedded devices like routers!) aren't perfect for ownCloud, a year from now many new devices will be perfectly capable of providing a great ownCloud experience.

The Electronic Frontier Foundation's "Let's Encrypt" initiative offers a (partial) solution for the security issue. Without it, a pre-configured ownCloud system will most likely be set up to use a self-signed certificate. While secure in principle, it always warns visitors of the self-signed state and thus isn't ideal. Let's Encrypt provides an automated and more importantly free (in terms of cost) solution for this.
And nowWhile I'd love for all these changes to be implemented yesterday, in reality we simply have to wait for the transitioning to IPv6 and 64bit CPU's. In the mean time, we can already start working on integrating Let's Encrypt into virtual machine and Docker images with a pre-configured MySQL (or MariaDB) and perhaps recommend people to run them on a 64bit capable system like a modern NAS or a NUC. The ownCloud-in-a-Box image on SUSE Studio is a great start!

Meanwhile, getting ownCloud ready to run on a wider range of devices and perform a wider range of 'cloudy' functions like running as backend of the Chromebook devices (see this page and ping me if you want to get involved) should be on the agenda as well. I personally look forward to more 'social' integration in ownCloud, like the ability to comment on images or other data and share these with the people you share files with. We're on it, tags sharing is integrated for ownCloud 8 and a generic metadata repo was created (empty still). Get involved if you can!

Obviously, telling people about ownCloud is still important - which is what the ownCloud event program is all about - and help is welcome. Go to owncloud.org/promote and share the love!
Categories: FLOSS Project Planets

ODFAutoTests gearing up towards the 10th ODF Plugfest in London

Mon, 2014-11-24 18:07
KDE Project:

In two weeks time, users and developers of OpenDocument Format software will meet up for a two day ODF plugfest in London. In preparation of the plugfest, I have spent last weekend, refreshing ODFAutoTests. ODFAutoTests is a tool for creating test documents for ODF software and running these documents through the different implementations. If you want to help out with improving OpenDocument Format, please come to the plugfest, or participate online. Writing tests with ODFAutoTests is a great way to help make the 10th ODF Plugfest a success.

Image: 
Categories: FLOSS Project Planets

Cutelyst 0.5.0

Mon, 2014-11-24 13:51

A bit more than one year after the initial commit, Cutelyst makes it’s 5th release.

It’s now powering 3 commercial applications, the last one recently got into production and is the most complex of them, making heavy use of Grantlee and Cutelyst capabilities.

Speaking of Grantlee if you use it on Qt5 you will get hit by QTBUG-41469 which sadly doesn’t seems to get fixed in time for 5.4, but uWSGI can constrain your application resources so your server doesn’t go out of memory (worth the leak due to it’s usefulness).

Here is an overview since 0.4.0 release:

  • Remove hardcode build setting to “Debug”, so that one can build with “Release” increasing performance up to 20% – https://gitorious.org/cutelyst/pages/CutelystPerformance
  • Request::uploads() API was changed to be useful in real world, filling a QMap with the form field name as a key and in the proper order sent by the client
  • Introduced a new C_ATTR macro which allows to have the same Perl attributs syntax like C_ATTR(method_name, :Path(/foo/bar) :Args)
  • Added an Action class RoleACL which allows for doing authorization on control lists, making it easy to deny access to some resources if a user doesn’t match the needed role
  • Added a RenderView class to make it easier to delegate the rendering to a view such as Grantlee
  • Request class is now QObject class so that we can use it on Grantlee as ctx.request.something
  • Make use of uWSGI ini (–init) configuration file to also configure the Cutelyst application
  • Better docs
  • As always some bugs were fixed

I’m very happy with the results, all those site performance tools like webpagetest give great scores for the apps, and I have started to work on translating Catalyst tutorial to Cutelyst, but I realize that I need Chained dispatcher working before that…

If you want to try it, I’ve made a hello-world app available today at https://gitorious.org/cutelyst/hello-world

Download here!


Categories: FLOSS Project Planets

Season of KDE

Mon, 2014-11-24 07:19

Season of KDE is an outreach program hosted by KDE community. It is a similar program like “Google Summer of Code”. The current round of Season of Code started in October and hope to go until January.

I am selected for Season of KDE with the project “Theme Designing for Pairs”. My mentor is Heena Mahour. Pairs is a KDE educational project focused on preschool children. It helps stimulating memory and logic skills of children. My project will cover the following aspects of “Pairs”.

  • Creating and adding new themes
  • Improve documentation
  • Re factor code base

When I found about SoK, I was looking for opportunities to contribute to open source community. My skills in creativity, technical documentation will help me to achieve the expected results very easily.


Filed under: KDE Tagged: KDE, KDE edu, Open Source Student Opportunities, Pairs, Season of KDE, SoK
Categories: FLOSS Project Planets

Hello world post

Mon, 2014-11-24 06:05

This blog was created by force :)

I thought a long time before doing this. I had several personal pages before, but all ended with the failure. I cannot say that I’m very good programmer, but my writing skill is many times worse than my programming.

Okay, from the next month The Season of KDE will start. Previously I have made a patch that port Python 2 backend for Cantor to Python 3. After a brief review Filipe Saraiva proposed me to continue working on it and port it to KDE Frameworks 5 as a part of the SoK. Therefore, I have to write at least one post a month about it according to the rules (Otherwise I will not receive a fashionable T-Shirt! :) ).

That’s all.

Categories: FLOSS Project Planets

SoK : UPnP Support in PMC progress report

Mon, 2014-11-24 01:14
Well, it's been a great experience working on an awesome project Plasma Media Center. Till now I have learnt a lot of things, from which using C library in C++ using wrappers is the one I really like the most.
As PMC is being ported to Plasma 5, it would be worthless merging it in qt4 based branch of PMC. So, I am making standalone app based on Qt5 and would merge it later on once it gets ported completely.

I have used GUPnP library for this as it is the best and most stable library available to implement UPnP. I have used gupnp-tools as the reference. Till Now I have successfully finished the very first step of my project, i.e. show up the files of the MediaServer. I am able to browse the files on the Media Server successfully and that media is accessible over HTTP protocol using the URLs which is terminal output.
Here's the screen shots of the working application :



In the root of the tree in application, there's Device name being shown up in the first column and respective IDs in the other column. So, we can expand it down and browse the files further present on the media server. As we keep expanding it down, we will be getting URLs of all the audio, video, image and text files of those directories as the output on the terminal.

As I have got the URLs of the media, now I just have to pass those URLs to the existing PMC backend which would automatically be opening up the media file over the HTTP protocol, process up the metadata and shows all the controls like play, pause etc. But as I have said previously, I would be doing that integrating in PMC stuff later on.
If you wanna try it out, you can get the sources from here.

What's Next :
Now I am gonna work on implementation of Media Server in PMC using the same library. Using that, the user would be able to play the media files from PMC to any other device. I am using some boilerplate code from here which includes some of the examples of UPnP Standard Services like ContentDirectory, ConnectionManager and AVTransport.

Season of KDE participants are required to blog about the work progress report but I am really kinda lazy in that and this is my first blog post I have ever made in my life :p

At last I would like to thank my mentors Shantanu and Bhushan, who helped me in each and every problem where I got stuck.
Categories: FLOSS Project Planets

Awesome BSP in München

Sun, 2014-11-23 13:10

An awesome BSP just took place in München where teams from Kubuntu, Kolab, KDE PIM, Debian and LibreOffice came and planned the future and fixed bugs. This is my second year participating at this BSP and I must say it was an awesome experience. I got to see again my colleagues from Kubuntu and got to […]

Categories: FLOSS Project Planets

Junior Job: Breeze Icon theme for LibreOffice

Sun, 2014-11-23 09:23

Here’s a nice project if you’re bored and wanting to help make a very visual difference to KDE, port the Breeze icon theme to LibreOffice.

Wiki page up at https://community.kde.org/KDE_Visual_Design_Group/LibreOffice_Breeze

All help welcome

Open, Save and PDF icons are breeze, all the rest still to go

 

by
Categories: FLOSS Project Planets

KDE Promo Idea

Sun, 2014-11-23 07:11

New seasonal KDE marketing campaign.  Use Kubuntu to get off the naughty list.

 

by
Categories: FLOSS Project Planets

Is linux about choice?

Sat, 2014-11-22 16:10

Occasionally, various quotes from people having an opinion if linux is about choice or not. Even pages like http://www.islinuxaboutchoice.com/ has shown up.

My short answer is “YES”. Linux is about choice. And you get all your choices directly from your f/loss definition of choice (FSF’s 4 freedoms / OSI’s opensource definition / Debian Free Software Guidelines)

It doesn’t mean that you get all the gui configuration bits that you want. It doesn’t mean that you without any problems can switch out any component. But it does mean that you can get it exactly your way. But it might require you to edit some source code and compile some stuff.

Categories: FLOSS Project Planets

Your chance to contribute to KDE in non-C++ – or the first KDE-CI IRC meeting

Sat, 2014-11-22 15:29

This blog post is about another possibility to contribute to KDE. It’s about taking work off Ben’s shoulders and about fixing the bus factor for our great CI (Continuous Integration) system.

I’d like to start a series of weekly or bi-weekly (to be decided) IRC meetings to coordinate the work to understand, change and enhance our CI system and therefore we need a first date. So if you’re interested please add yourself to this Doodle (think about different timezones!).

Prospective agenda for the IRC meeting:

  • Ben: Short introduction to KDE CI
  • Everybody: Short introduction incl. their skills and wishes for KDE CI
  • Ben: What needs to be changed
  • Everybody: Work on a roadmap and distribute work till next meeting
  • Everybody: Determine date for the next IRC meeting

This is your chance to help KDE to enhance the code quality and spread to even more platforms and thus bring our great software to even more computers and people. But if you prefer to support us in another way their is our ongoing fundraiser. Thanks for considering to help us!

And one last thing about the KDE CI system: we’ve a page about CI on the Frameworks wiki too.

Short Personal note: My diploma thesis was finally accepted (and thus again thanks to everybody who wished me all the best for my thesis!) and thus I’ve a bit more time (to coordinate some stuff in KDE . But I still need to learn and pass the exams (and there is some other big private change in my life soon to come .

Categories: FLOSS Project Planets

Blog Moved

Sat, 2014-11-22 10:21
KDE Project:

I've moved my developer blog to my vanity domain jriddell.org, which has hosted my personal blog since 1999 (before the word existed). Tags used are Planet KDE and Planet Ubuntu for the developer feeds.

Sorry no DCOP news on jriddell.org.

Categories: FLOSS Project Planets

Blog Move, Bug Squashing Party in Munich

Sat, 2014-11-22 07:26

Welcome to my blog on the updated jriddell.org, now featuring my personal blog (which has existed for about 15 years or at least before the word blog existed) together with my developer blog previously on blogs.kde.org.

I’m at the Bug Squashing Party in Munich, the home of KDE and Plasma and Kubuntu rollouts in the public sector. There’s a bunch of Kubuntu people here too as well as folks from Debian, KDE PIM and LibreOffice.

So far Christian and Aaron (yes that Aaron) have presented their idea for re-writing Akonadi.

And I’ve sat down with the guys from LibreOffice and worked out why Qt4 themeing isn’t working under Plasma 5, I’m about to submit my first bugfix to Libreoffice! Next step Breeze icon theme then Qt 5 support, scary.

Kubuntu People
It can only be Harald
Akonadi: Lots of Bad
Let’s re-write Akonadi!

by
Categories: FLOSS Project Planets

Only Tangentially Related To The Stars

Sat, 2014-11-22 06:47

It's a scary moment, that time when you reach the conclusion of something which has taken up a considerable chunk of your life for months. Not a bad kind of scary, really, more a sort of exciting, i-wonder-what-others-think kind of scary. For me, this is a moment i've reached now that Calligra Gemini has been merged into the master branch of Calligra, and is scheduled to be shipped with Calligra 2.9. Another reason it's scary is that, given this is sort of my baby, and have found it's something i use actively pretty much every day now, i am now also the official maintainer of that application, which is kind of a new thing for me. If you're wondering what this whole thing is about, there's a rundown of the news over on the Dot.

At the beginning of this project it was a fairly straight forward thing for me, very similar to the Krita Gemini project in which i was sort of a code monkey, with some marketing thrown in for good measure (i produced the videos used to show off Krita Gemini for the Steam Greenlight campaign, which culminated in Krita Gemini being, to our knowledge, the first piece of free/libre software launched on the platform). I had a manager, who did the majority of the liaising with our customer, Intel, and i provided technical commentary and timelining for the features which were suggested for the application.

As the project progressed, however, the manager in charge of the project ended up taking long term ill (the background story for which is all long and sad and not really relevant here), which essentially landed me with his responsibilities as well. This is not to say it was a bad thing, really - the illness obviously was, but me ending up with those responsibilities wasn't. It meant that i became the client liaison, and the person responsible for packaging Calligra Gemini for Windows, using the same WiX based system created by Stuart Dickson and used for Krita Gemini, and for generally just keeping the project running. In short, everything to do with it bar billing the customer for the work. This was also the time during which i decided we needed to tell more people about the project, and so came the idea to OBS our way to that, and produce some packages for openSuse at least - since, well, that is what i've packaged for in the past, and OBS is just so pleasant to work with that it'd be silly not to.

And now, we stand at the point of concluding the project itself. Not completing, not finishing by a long way, this really is just the start of the journey for Calligra Gemini, and but a small step on the journey of the whole Gemini thing. Really, what Gemini is is just an interpretation of the responsive design concept, which describes how your application should fit the device you're on. What we're doing here is implementing, in the real world, applications which don't simply look and feel right, but which will adapt at runtime to changing device conditions.
Where do we go from here?This is what my interpretation of responsive design is. Not something which looks sort of ok everywhere, but something which adapts the entire experience to give you the options which make sense where you are. For Calligra Gemini that means the three-tiered approach of Create (desktop and laptops), Edit (all touch) and View (minimally interactive devices like televisions and other infotainment style devices), or indeed any of these when the user specifically requests it.

As the world fills with all sorts of strange device form factors, we have to be able to work well on them. Laptops and desktops, phones, tablets, televisions, cars, airplanes, even fridges and all sorts of other places. Another piece of software created by KDE which takes this head on is Plasma. The people behind it have, since some time now, been working on creating a variety of frontends for it which scale to various form factors, and a chat with one developer there a short while ago made me think that well, it would be brilliant to see that adaptability happen at runtime, the way Krita and Calligra Gemini do it.

What he could tell me was that, technically speaking, it was possible to do it, but that the code path had been untested and such. This is something nobody else has done. Other shells have tried to create one thing which fits everything (calling it convergence), where KDE has realised, as a community, that the way forward is to adapt to each, not to work with the assumption that a single size fits everybody.

So, what stars is it this is tangentially related to? Easy, the ones we're shooting for ;)

The word of the day is: writing
(as in, in bed, the way i do the majority of it ;) )

Categories: FLOSS Project Planets