GSoC/2014/Ideas - KDE Community Wiki

Guidelines

Information for Students

These ideas were contributed by our developers and users. They are sometimes vague or incomplete. If you wish to submit a proposal based on these ideas, you may wish to contact the developers and find out more about the particular suggestion you're looking at.

Being accepted as a Google Summer of Code student is quite competitive. Accepted students typically have thoroughly researched the technologies of their proposed project and have been in frequent contact with potential mentors. Simply copying and pasting an idea here will not work. On the other hand, creating a completely new idea without first consulting potential mentors is unlikely to work out.

When writing your proposal or asking for help from the general KDE community don't assume people are familiar with the ideas here. KDE is really big!

If there is no specific contact given you can ask questions on the general KDE development list [email protected]. See the KDE mailing lists page for information on available mailing lists and how to subscribe.

Adding a Proposal

Note

Follow the template of other proposals!

Project:

Brief explanation:

Expected results:

Knowledge Prerequisite:

Mentor:

When adding an idea to this section, please try to include the following data:

if the application is not widely known, a description of what it does and where its code lives
a brief explanation
the expected results
pre-requisites for working on your project
if applicable, links to more information or discussions
mailing list or IRC channel for your application/library/module
your name and email address for contact (if you're willing to be a mentor)

If you are not a developer but have a good idea for a proposal, get in contact with relevant developers first.

Ideas

Your Own Idea

Project: Something that you're totally excited about

Brief explanation: Do you have an awesome idea you want to work on with KDE but that is not among the ideas below? That's cool. We love that! But please do us a favor: Get in touch with a mentor early on and make sure your project is realistic and within the scope of KDE. That will spare you and us a lot of frustration.

Expected results: Something you and KDE loves

Knowledge Prerequisite: Probably C++ and Qt but depends on your project

Mentor: Try to see who in KDE is interested in what you want to work on and approach them. If you are unsure you can always ask in #kde-soc on Freenode IRC.

Amarok

Project: Lyric support improvements

Brief explanation: Amarok's support for fetching and displaying of lyrics is very limited. It just fetches from a single provider and many times no results are fetched, sometimes due to minor errors in track/album/artist name. Add some more providers of online lyrics databases. If no results are found this can be coupled with the better tagguessing feature (and even if the tags are not saved), the the lyrics providers can be searched with these guessed tags. Then, improve the lyrics display. Currently it just scrolls at a constant rate, generally that's inconsistent with the actual playback of the song. All .lrc files have timestamps, that can be followed: probably by highlighting the line playing.

Expected results: Greatly increase the probability of fetching of the lyrics for any song. In the lyrics display, a highlighted line will display the current line being played.

Knowledge Prerequisite: Knowledge of the Amarok code base (hence of Qt, C++). Basic knowledge of webservices.

Mentor: Mark Kretschmann

digiKam

digiKam is an advanced digital photo management application for Linux, Windows, and Mac-OSX.

Project: Integrate KIPI Export Plugins directly in the GUI of KIPI host applications

Brief explanation: It would be nice to be able to encapsulate the Export/Import KIPI plugins directly in the GUI of the host application without opening a dedicated window. For the Export Plugins the place to load the plugins will be BQM and for the Import Plugins this can be in the digiKam import tool or in the main view. For this one must factorize the export/import kipi plugin interface and to group the common calls into a virtual interface, to implement tree and list view for the plugins.

Dependencies: : digiKam KIPI interface, libkipi, KIPI Plugins

Bugzilla entries: 235572, 221704 ,143978

Knowledge Prerequisite: C/C++, Qt/KDE, GUI

Expected results: KIPI host apps that are compatible with the project will load KIPI Plugins in the BQM, the others will load the plugins as it's done right now without breaking any compatibility.

Difficulty: high

Lead Mentor: Gilles Caulier <caulier dot gilles at gmail dot com>

Project: Port Greystoration CImg interface to GMic

Brief explanation: digiKam include CImg library to be able to use Greystoration algorithm which give nice fix to image based on Vortex theory, as Restoration tools. Since CImg > 1.3.0, Greystoration algorithm have been moved in a new library named GMic with a completely different API. The goal of this project is to adapt digiKam Greystoration interface to GMic library.

Dependencies: digiKam core, Restauration and Inpaint editor tools, and Restauration tool from Batch Queue Manager

Knowledge Prerequisite: C/C++, math, Qt,

Expected results: port image restoration algorithm from CImg to GMic API

Difficulty: high

Lead Mentor: Gilles Caulier <caulier dot gilles at gmail dot com>

Project: Add a quick access to Labels in dedicated tree-view

Brief explanation: It would be nice to be able show all items from collections in icon-view which has Rating, Pick Labels, and Color Labels attributed, as it's already do with Tags. The goal is to build a tree-view with all Labels available on digiKam and process database query to show items relevant. This view must include No rating, All Rating values, No Pick Label, All Pick Label values, No Color Label, all Color Labels, which must be selected individually or grouped. This Labels tree-view must be available in KIPI album selector widget, as it's done currently for Tags, to be able to export these virtual albums with kipi-plugins. Also, in this project a way to select No Tagged items must be add to current Tags tree-view, to be homogenous with new Labels tree-view feature.

Dependencies: : digiKam Database

Bugzilla entries: 160363,

Knowledge Prerequisite: C/C++, Qt/KDE, GUI, Database

Expected results: To have a quick acess tree-view in all relevant gui where Labels can be selected for photo workflow.

Screenshots: Microsoft Live Photo Rating tree-view, Apple Aperture Labels tree-view

Difficulty: medium

Lead Mentor: Gilles Caulier <caulier dot gilles at gmail dot com>

Marble

Marble is a virtual globe and world atlas — your swiss army knife for maps. Find your way and explore the world!

Project: Interactive Tours

Brief explanation: A Tour is a set of related places along with supporting media (text, images, audio, video). Tours can be viewed (playback): The invididual places are visited in a defined timeline. They're useful for a wide range of tasks, like showing an interesting hike along with panorama pictures, highlighting places of interest for sightseeing or showing historic events and political changes happening over decades. The Marble library has been designed to support these use cases, but the user interface does not reveal all the features yet. This project is about changing that.

Expected results:

Extend the existing Tour widget for animated tour playback
Improve the usability of the Tour widget
Support interactive elements in tour playback
Implement time support for tours for different time ranges (from eras to years to days to minutes to milliseconds)
Add support for recording tours
Enhance the screencast feature to generate videos from tours.

Optional:

Extend Marble's owncloud synchronization feature for uploading tours to owncloud
Add tour viewing support to the Marble owncloud app
Implement tour viewing in the QML version of Marble
Provide tours for existing map themes to highlight features of them

Knowledge Prerequisite: C++ and Qt. Would-be applicants are expected to work on junior jobs (possibly related to the project). Try to find your way into http://marble.kde.org/dashboard.php#contributors and solve as many tasks and bugfixes as possible.

Mentor: Dennis Nienhüser and other Marble developers.

Project: Marble Game

Brief explanation: The latest introduction of a recent vector map inside Marble ("Natural Earth dataset") allows for interesting features: With recent and detailed political borders it's also possible to create a game based on Marble similar in spirit to KGeography. In terms of user-featureset the goal is to create an entertaining and educational game-application or game-plugin using Marble. Technically the goal is to extend Marble's framework to allow for this (there surely will be roadblocks).

Expected results:

An application that is based on the MarbleWidget which teaches Geography in a style similar to KGeography.
OR/AND a plugin that extends Marble with a menu entry that invokes a Quiz-style educational game.
Extend Marble's framework to allow for the features required
Improve the Marble framework so that it provides a better experience for 3rd-party developers (by providing missing tutorials, documentation or even better APIs)

Mentor: Torsten Rahn and other Marble developers.

Project: Marble Editing mode: Polygons

Brief explanation: During last GSoC a mode for editing ground overlays was added to the experimental editing Mode for Marble. During this GSoC the editing mode should be extended with polygon editing. The resulting editor should allow to create polygons and edit nodes of existing files in a way similar to inkscape. If there is enough time then the editing mode for Marble should be polished so that it can be included with the next release.

Expected results:

An editing mode for polygons inside Marble.
Adding, moving and removing nodes.
Possibly merging nodes and other features that tools like inkscape provide for node interaction
Assignment of lables, outline color and fill color.
Possibly editing of "holes" inside the Polygon.

Mentor: Torsten Rahn and other Marble developers.

KDE Edu

Project: Sound Visualization and Sound Effects in Artikulate

Brief explanation: Artikulate is a language learning application that focus on improving a learner's pronunciation skills by repeating native speaker recordings, recording that try and comparing boths. By repeating these trials, a learner can continuously improve his/her language skills. There are areas for this project:

native speaker recordings are recorded (either by GStreamer or QtMultimedia), converted to an OGG file and saved. What is missing is an application of noise cleanup filters, removing of no-sound intervals, and normalization (possibly combined with a very basic sound editor)
when playing and comparing sounds, there is no visual feedback about how much the soundwaves differ: plotting the soundwaves in a reasonable format

Goals: The goal is to extend the sound processing in Artikulate to

Implement simple sound filters for normalization, noise removal, removal of white noise and integrate sound postprocessing into the editor workflow
Implement plotter for soundwaves and integrate this in the training mode

Yet for both it is important to research which libraries already exist and possibly could be reused. Also, research is needed about which techniques for comparing the soundwaves is appropriate. A proposal should already contain verbose information about these questions.

Knowledge Prerequisite: a must is knowledge of C++ and Qt, a plus is knowledge of sound processing libraries (e.g. GStreamer) or experience in sound processing

Mentor: Andreas Cord-Landwehr and/or other people from KDE Edu

Project: Semi-Automatic Generation of Language Lessons for Parley

Brief explanation: Parley is an advanced vocabulary trainer with features like 8 different learning modes, including flashcards, genders of nouns, conjugation of verbs and several more. A lesson for Parley is encoded in kvtml, KDE Vocabulary Training Markup Language which is an XML format for vocabulary lessons of many different types.

But it is a relatively demanding task to create good lessons for Parley. You need to manually edit a list of words in several different languages, add images and/or sound clips to them all, word class, pronounciation, etc.

We would like to create a semi-automatic generator for lessons using the Kexi database in the Calligra suite. The workflow will be something like this.

You use an import script to import a selected part of the word list in wiktionary.org, an online wiki dictionary, into Kexi. This will then form the basis for the work on the lessons.
You define a list of words in the so called primary language, which is the language that the lesson is supposed to teach. This list will be the words only and could be created either using the editor inside Parley or a standard text editor and then import it into Parley.
You define which secondary languages you want in your lesson. These languages are the ones that the student is already familiar with. The training session will then consist of translations from one of the secondary languages (most often the native language of the student) and the primary language. At this point you also define which other parameters you want to include in the lesson, like image, sound clip, phonetic text, explanation, etc.
You invoke the automatic lesson generator which will search for the words you have defined in the database, look up suitable translations and add the other fields that you asked for.
If necessary, patch up the newly generated lesson with missing data that wasn't present in the database or add the information to the database and redo the generation.

Goals: The goal is to create software that supports the workflow above. It will at least comprise the following tasks:

Define an efficient database schema for the words and translations. Wiktionary.org has 3.6 million entries and even a subset of that can take significant amounts of storage.
Implement a script that reads from wiktionary.org and enters the data into the Kexi database using the calligradb library. There is already a script for downloading and parsing the contents of Wiktionary at [1] but you will have to adapt it to Kexi.
Implement the code that searches the database and populates the lesson with the data found.
(If time permits) Implement a more advanced lesson editor than is currently present in Parley or a stand-alone editor.

Knowledge Prerequisite: Good knowledge of C++ and Qt, a plus is knowledge of of kvtml and the related C++ classes in the kde edu libraries. Also some knowledge of databases and database searches.

Mentor: Jaroslaw Staniek, the maintainer of Calligra Kexi, with help from Inge Wallin

[1] http://en.wiktionary.org/wiki/Help:FAQ#Downloading_Wiktionary

Project: Kig - Geogebra Support

Kig is an application for interactive geometry.

Goals: The overall goal is to support Geogebra files in KDE Edu. Because Geogebra is both a plotting tool and a tool for interactive geometry, the stated goal is very broad. For this particular project, we are interested in supporting interactive geometry in Kig. The current progress towards this goal is in the geogebra branch of Kig's repository. Since there is some progress towards that goal, the particular goal of supporting these files in Kig may or may not be smaller than a GSoC project, in which case we can move forward to implement support for these files in the many plotting tools we have in KDE Edu.

Knowledge Prerequisite: By the start of GSoC you should

Be familiar with Kig as a user
Be familiar with Geogebra as a user
Be familiar with Git, you will have to work with branches
Be able to build Kig
Be familiar with Kig's filter code: Kig is a large code base, so you are not expected to know everything about it, but you should at least be familiar with how filters are created and be able to modify filters since this will be the part of the code that you will be working with.

Mentor: David Narvaez (IRC: dMaggot, please read this before applying)

Project: Kig - Analitza Integration (Experimental)

Kig is an application for interactive geometry.

Goals: Kig's core is full of code to deal with finding solutions to linear or quadratic equations which are the bulk of interactive geometry. While this code works, in many cases it does so by approximations and it is, in general, very convoluted. The goal of this project is to implement all of this code in terms of a CAS to address both of the disadvantages mentioned before. Analitza is an "in-house" library that deals with mathematical expressions, and is thus a good candidate for a CAS provider in Kig. This project is experimental because:

Implementing everything in terms of a CAS may or may not improve code quality in terms of readability. If it doesn't (and we would only know this at the end of the project), the implementation of this project will not make it to the master branch.
Analitza may or may not be up for all of the tasks we need to do in Kig, in which case improving Analitza is an option.

Knowledge Prerequisite: By the start of GSoC you should

Be familiar with Kig as a user
Be familiar with Analitza as a consumer (it is a library, so you would not be a "user")
Be able to build Kig
Be able to build Analitza
Be familiar with Kig
Be familiar with Kig's object hierarchy and the mathematics behind that

Mentor: David Narvaez (IRC: dMaggot, please read this before applying)

Project: Integrate Cantor into LabPlot

LabPlot is a KDE-application for interactive graphing and analysis of scientific data.

Brief explanation: The integration is twofold:

currently, for the created plots LabPlot uses either the data provided by hand in a spreadseet or by using data imported from external ascii-files. By having Cantor within LabPlot it should be possible to access the data sets created in a computer algebra session (say Maxima) provided by Cantor. Cantor's session have to be integrated into LabPlot's model-view framework and have to be put onto the same foot as all the other objects managable in LabPlot (spreadsheet, worksheets etc.).
By calling a CAS-specific command for creating a 2D-plot in Cantor, Cantor creates an external process that renders the plot and embeds the result as a pixmap. Instead of such a static pixmap, LabPlot's plots should be embeded. This would provide high degree of control of the plot appearance as provided by LabPlot.

Mentor: Alexander Semke

Project: Integrate VTK into LabPlot, investigate Tulip

LabPlot is a KDE-application for interactive graphing and analysis of scientific data.

Brief explanation:

LabPlot lacks 3D-functionality. In the old KDE3-based LabPlot qwt3D was used for this that is not an option anymore. The task consists of the integration of VTK -libs. Also, the relevant widgets for 3D-plot editting should be created in a manner similar for all the other objects available in LabPlot now.
Investigate whether it's reasonable to use LabPlot as a frontend (or to extend it to be a frontend) to the functionality provided by Tulip yes, how?

Mentor: Alexander Semke

Krita

We welcome students who want to work on Krita for Google Summer of Code. If you want to work on Krita, keep in mind that we would like you to stay with the project, also outside Summer of Code. Summer of Code isn't just a summer job with some mentoring added -- it's a way of becoming part of the team.

If you haven't worked on Krita before, we want you to demonstrate your skill beforehand by fixing bugs or implementing some features. It's a good idea to start on that in January. Here is a list of pre-gsoc ideas:

Project: Painting and Separation of 3D Textures

As one of it’s use cases, Krita’s vision statement includes painting textures for 3D. 3D textures are typically comprised of a number of separate black and white, RGB or RGBA images. Thus painting for textures typically requires painting on more than one single layer / channel at a time. For example painting a scratch into a metal surface may require painting black onto the bump channel, another colour on the diffuse channel, and another to the specularity channel (as well as possibly some others such as the displacement channel). All of these are affected simultaneously.

Currently Krita’s painting system is only able to paint onto single layers at a time and brushes have not been designed in such a way as to allow adjusting multiple channels simultaneously as would be needed. This topic would require looking at how Krita’s current painting system could be extended to paint the necessary adjustments to the channels used in 3D rendering, show the textures created in OpenGL and then export those channels for use in 3D applications.

Project: 3D Material Image Maps

3D materials are made up of a bunch of images called image maps. If the user could associate layers as image maps in Krita, and paint on all of them at the same time, artists could paint whole 3D materials - something currently only available in high end 3d apps like zBrush (not even Photoshop / Corel Painter). The trick is that the position of what's painted needs to match on every map/layer, but the colours vary. For example, a scratch on a human characters skin would have a red colour map, a white (=raised) bump map, a light grey (=semi-shiny) specularity map etc, all in the exact same location on the each image map. Traditional methods of trying to create each image from scratch or by manipulating the colour map are very, very slow and painful. A simple version of this could be done as follows:

Each layer has a toggle in the layers docker called "texture map" or similar. This is turned off by default. When active, the brush paints on *all* layers that currently have "texture map" active.

When picking a colour, a dropdown lets the user pick "Default" or any active texture map layer. "Default" is just the current behaviour. If the user selects a layer in the dropdown, then the selected colour will be applied to that layer when painting on *any* layer.
In the file or layer menu is an option "Export texture maps" which saves each texture map layer as an image. The layer name and extension appended automatically to the file name. For example, on a file called character.kra, the layer titled "colour" would be saved as "character-colour.jpg" (or whatever format was selected).

For step 3, a simple, one click / shortcut, method is vital, as artists often have to check their material in their 3d app every few minutes, and wading through saving 10 layers individually, each with manual file naming and confirming file format settings each time is unacceptably slow. For any artist who requires this level of control, they can use Layers menu -> "Save Layer as Image" already in krita.

Allowing artists to paint a single material rather than creating multiple separate image maps by hand, would make Krita formidable for painting 3D textures, and the most advanced open source application for 3D texturing.

Project: Matte painting

One of Krita's main use cases is as a professional tool for painting textures and mattes in digital film. Mattes are primarily made of sequences of images generated by a combination of two methods, first by animatable spline based shapes, which currently exists and is being developed in blender, and then after that, by hand painting frames for detailed areas and corrections. The trouble is that no currently maintained FOSS application currently tries to provide the ability to create hand painted mattes. This project is to extend Krita for this purpose. What's needed here is the following:

The ability for Krita to load manually selected sequences of color managed images as frames to be represented as a single layer in Krita. Optionally would be the ability to display playback at reduced resolutions to increase performance and to offset the time at which sequences were inserted.
A “Timeline” docker which would display the current frame displayed, and allow clicking and dragging to different points in time, updating the image displayed in the canvas to match. Optional would be the ability to zoom and scroll the timeline, mark modified frames on the timeline, playback the image sequence, forwards and backwards as video (most likely only in the openGL mode of Krita or with an external tool like ffplay) and display times in a range of formate EG SMTP, PAL, NTSC, Secam etc.
Updating the paint and transparency layer types, so that when Krita is using a frame sequence and one of these layer types is created, they also represent a series of frames rather than just a single image. This could possibly be a toggle switch on layers, much as visibility, alpha lock etc. are now.
The ability to save layers that are displaying frame sequences out as frame sequences also, giving them user definable names (eg where to insert the frame number, how many digits to pad).
Keyboard shortcuts to move forwards and backwards 1/10/100 frames, to jump to the start and end of the timeline and forward / backwards play if video playback is supported.

Project: Cartoon Text Balloon System

Krita already has two text tools, but neither is suited for creating cartoon balloons. The system should allow the creation of vector-based balloons in different styles. The balloons can contain styled text. The text and balloons should be translatable and a system to select the current language should be created. It should be possible to save the balloon text to a separate file that can be used as input for translations. Finally, care must be taken to support right-left languages.

Project: Substrate simulation

Brief explanation: Substrates for painting and drawing have a direct influence on the result of the art. The goal of this project is bringing this richness of these effects to Krita. There is an existing body of literature and academic projects on this topic, with Bill Baxter and Tom van Laerhoven being among the best known researchers. For the right effect, we need to take care of the 3d structure of the substrate, it’s effect on paint tools -- smoothness, absorbency and other parameters. An interesting option is to make it possible to apply different substrates to existing paintings. Expected results: an optional substrate simulation that works with all current Krita tools

Project: Real Paint Emulation

We already did some research on the emulation of real-world paint and we do already have some essential pieces of it: Hairy Brush and Bumpmap filter. Now we need to bring this all together and allow a painter to use it easily, so that he could paint images like that: TODO. This project would involve creation of a special type of layer and a new colorspace, so the student should already be familiar with our layer stack and pigment code.

Research Project: layer stack optimizations

Right now when one layer got changed our merger should walk through all the layers of the current group and compose all of them into projection one by one. But this doesn't take into account that COMPOSITE_OVER (which is the most popular composition mode) has an associativity property, which means we can merge all the layers below and all the layers above dirty one into two groups, and calculate a group of any size with only two composition operations, which would give huge speed advantages.

Unoptimized group:

layer 6
layer 5
layer 4
layer 3 <-- active layer (becomes dirty quite often)
layer 2
layer 1

Optimized group:

<flattened 4-6>
layer 3 <-- active layer (becomes dirty quite often)
<flattened 1-2>

After this project is done, we can start implementing layer composition on the GPU using openGL.

Project: Improved Animation Brush System

This should result in animation brushes being more readily available and adjustable. The current way of doing this is not as userfriendly as it could be.

Dedicated "Animation Brush GROUP"-> everything in group is a frame of the animation. (for use in current file,instead of in another instance of krita)
Convert group to animation group ->Normal group becomes animation brush reference.
Save as animation brush PRESET
options to set animation brush continuity to custom, random, incremental, pressure,angular,loop...
animation brush presets (in settings) need a timeslider to flip through the available frames

https://bugs.kde.org/show_bug.cgi?id=322159

Project: seamless textures by using UV layout as self-wrapping paint mask

This is a tool that should help in creating seamless (or as close as possible) textures for organic models. It will help in painting creases and other details across seams.

Convert intersections on uvlayout to seam transfer points.
use those points to transfer painted strokes to connected points on other side (set by user)
create userfriendly way to add,manage those seam transfer points. (multiple should be active at once)

https://bugs.kde.org/show_bug.cgi?id=324072

ALTERNATIVE

Similar to previous idea,but with movable curves/grid with adjustable seam transfer points in stead of converting a whole UV layout automaticly

https://bugs.kde.org/show_bug.cgi?id=321547

More ideas for projects can be found here: https://bugs.kde.org/buglist.cgi?cmdtype=runnamed&namedcmd=Wishlist%20count&list_id=884686

Kexi

Kexi is a visual database creator. It can be used for designing database applications, inserting and editing data, performing queries, and processing data.

More info: Developers' wiki, web site for users, mailing list, IRC channel: #kexi and #calligra on Freenode.

Project: Add support for importing tables from LibreOffice Base to Kexi

Brief explanation: Add support for importing (Kexi calls it data/design migration) tables from LibreOffice (or OpenOffice) Base (ODB format) to Kexi. This task involves research on ODB format (it's relatively openly defined). Qt/C++ shall be used for the task, not any Java engine (HSQL db). This could be introduction to later development of complete database import from ODB to a Kexi database.

Expected results: In the GUI the feature shall be put in the same place as the import from MDB: External Data -> Import Tables -> Table Importing Wizard. Then user would see .odb support in the open file dialog, just like it has access to importing CSV or MDB.

Knowledge Prerequisite: C++, some Qt, some databases, some XML, software architecture

Mentor: Jarosław Staniek (Kexi maintainer)

First steps:

See [1] for a start.
Sample .odb databases are available for this tutorial.
Studying kexi/migration/importtablewizard.cpp which is a GUI taking an instance of implementation of a migrate driver derived from KexiMigration::KexiMigrate (in your case - the ODB driver). It's the m_migrateDriver attribute.
Implementing plugin (needed methods of the driver) in migration/odb/ by looking how it was performed for other cases, e.g. for mysql (see kexi/migration/mysql/ dir) or other cases such as pqxx, txt, xbase, sybase or mdb
In the actual C++ implementation, KoOdfReadStore class from calligra libs can be used to read contents of the .odb.

Calligra Plugins

Calligra is an office suite with lots of different applications with an user interface that is easy to use, highly customizable and extensible.

More info: web site for users, mailing list, IRC channel: #calligra on Freenode.

Project: Variable thickness lines

Brief explanation: One of the most fundamental basics of drawing is varying the width of your lines to show shape, form and perspective. Almost every line tapers at either end, and often gets thicker and thinner in different places as needed. For purely technical and histrorical reasons though, every vector program (Illustrator, Inkscape, Karbon etc) make curves all one hard width. This proposal is to create a variable width path shape / tool, much like the path tool, would allow drawing curves, but where each node could have its width set so that the line width changed smoothly from node to node. As a plugin for the Calligra suite, this would clearly benefit apps as Karbon and also Krita.

Expected results: variable width path tool is able to change the width of any path node to an arbitary percentage (say 155%) of the stroke width. See http://bugsfiles.kde.org/attachment.cgi?id=56995 for mockup. The shape needs to be able to save and load in svg/odf.

Knowledge Prerequisite: C++, Qt, SVG?

Mentor: Thorsten Zachmann < zachmann @ kde dot org >

Keyboard Layouts

Keyboard layouts in KDE allow user to use multiple keyboard layouts and switch between them. It consists of keyboard configuration module (in System Settings), keyboard layout widget/applet, and keyboard layout daemon.

Project: Integrating Input Methods with keyboard layout configuration

Brief explanation: Input method and keyboard layout configuration are serving the same purpose - to allow users to type text in non-default language. Currently KDE has integrated system to configure keyboard layouts but IM need to be configured somewhere else. Also when IM is configured it takes over some functions of keyboard layout configuration. So it would be nice if we could have IM and keyboard layout configuration in one place. It seems that IBus has already gained community acceptance so this will be the target for integration into KDE keyboard module.

Expected results: Keyboard configuration module in System settings will include IM configuration and it will be integrated with existing keyboard layout options.

Knowledge Prerequisite: good knowledge of C++, development experience with Qt and KDE, understanding of Input Methods (IBus)

Mentor: Andriy Rysin <[email protected]>

KDevelop

Project: Clang Integration

Brief explanation: Finish the kdev-clang plugin to make it a usable replacement for the existing C++ plugin.

Expected results: All advanced features of the KDevelop C++ are ported to the kdev-clang plugin. This includes code completion helpers, as well as basic refactoring and assistant integration.

Knowledge Prerequisite: C++, Qt. Knowledge about Clang is helpful

Mentor: Milian Wolff

Project: Checker Framework

Brief explanation: A generic framework should be created which provides the foundation for other plugins to report errors.

Expected results: Right now we have the problems toolview but it is tightly coupled to the DUChain. This should be changed to use a separate item repository which stores the problems for a given path. The data stored would be: Path and range of where the issue is found, a short error message and optionally a long description. Furthermore, plugins might want to store additional info from which the problem could be fixed (compare to the 'add include path' or similar wizards we have already in the language framework).

This framework should then be used to integrate various tools.

First of all the existing language plugins should show the problems they find there. The existing playground plugins for krazy and cppcheck integration should reuse that framework any other linters could be integrated, such as jslint, pylint etc. pp. runtime checkers could be integrated, such as valgrind's memcheck, ptrcheck, helgrind, drd, ...

Knowledge Prerequisite: C++, Qt. Knowledge of linters such as Valgrind etc. is helpful.

Mentor: Milian Wolff

Project: SVN Plugin Rewrite

Brief explanation: Rewrite the SVN plugin to use the C-API directly.

Expected results: The existing SVN plugin uses an outdated kdevsvncpp checkout internally which causes troubles, warnings and licensing issues. Port the plugin to either the C-API of svn or alternatively try to reuse code from current kdevsvn. The result should be a tested, working plugin for SVN integration without licensing issues nor compile time warnings about usage of deprecated API.

Knowledge Prerequisite: C, C++, Qt, SVN

Mentor: Milian Wolff

KDE PIM

The KDE PIM community work on a set of libraries and applications for Personal Information Management, including email, calendaring, contacts, and feed aggregation.

Project: OpenHolidays

Brief explanation: The KHolidays library provides KDE applications with information on public holidays around the world, however the file format is very hard to use and maintain and the library features are very limited and restricted to Qt users. The goal of the OpenHolidays project is to develop a new open standard and data repository that can be used by any project that needs the data. See http://community.kde.org/KDE_PIM/KHolidays for more details.

Expected results: Define the new JSON file format and port the existing data files to the new format. Develop a shared Qt-only library to parse the holiday files and provide access to them with a iCal style event-based api. Implement an Akonadi resource to access the data. Extended goals: Develop a JavaScript library to use the files. Develop a web site and web service at openholidays.org to provide online access to the data files.

Knowledge Prerequisite: C++ and Qt for core goals, JavaScript and web services for extended goals.

Mentor: John Layt and other KDE PIM community members.

Project: Enhanced Searching in KMail

Brief explanation: KMail is the defacto email client in KDE. It currently has a complex search dialog which allows the users to configure many different parts of the search. While it is very powerful, it is not very usable. A better search dialog is required which allows the user to modify the initial search and filter the data appropriately. A good example of this would be the Thunderbird search dialog -

Expected results: Implementing the new search dialog and updating the backend search code to include whatever new features are required. Implementing this search dialog will require messing around with Akonadi, Baloo and KPeople.

Knowledge Prerequisite: C++ and Qt. A basic understanding of Information Retrieval would be nice.

Mentor: Vishesh Handa and other KDE PIM community members.

Project: Active Mail

Brief explanation: Active Mail is a QtQuick based mail application, a touch input friendly version of KMail so to speak. Currently it still depends on QtWidget based user interfaces for certain tasks which will have to be replaced before Active Mail can live up to its promise. Such missing pieces are the email composer and the email viewer.

Expected results: Define and implement a general QtQuick API for composing emails. Rework the Active Mail composer UI/UX with the help of our usability expert and make it shine.

Knowledge Prerequisite: C++, Qt, QtQuick

Possible Mentors: Thomas Pfeiffer, Michael Bohlender, Kevin Krammer

Project: QtQuick ToDo API / Plasmoid

Brief explanation: KDE PIM wants to make it's data accessible for applications which use QML to declare their user interfaces, e.g. applications using QtQuick. For that they need data handling objects that are accessible through QML, e.g. item models that have a mapping of string based role names to enum value based roles in C++, etc.

Expected results: Define and implement a general QML API for accessing and creating Akonadis ToDo data. Write / Port a ToDo Plasmoid for Plasma Desktop or Plasma Active to show off the new API. Bonus: Port Kontact Touch Task to the new API instead of, or in addition to the Plasmoid.

Knowledge Prerequisite: C++, Qt, QtQuick

Possible Mentors: Kevin Krammer, Michael Bohlender and other KDE PIM community members

Project: KPeople / Kontact Touch People

Brief explanation: KPeople is a KDE framework for aggregating contact information of people from various data sources, e.g. the user's addressbook and instant messaging programs. For the future KDE would like this to be the main source of data for its address book application.

Expected results: Define and implement a QML API for accessing kPeoples features. Create a pretty QtQuick example App/Plasmoid to show off and prove the API. Bonus: Bonus: Port Kontact Touch Addressbook to the new API instead of, or in addition to the Example.

Knowledge Prerequisite: C++, Qt, QtQuick

Possible Mentors: Martin Klapetek, Thomas Pfeiffer and other KDE PIM community members

Project: Akonadi Commandline/Shellscripting Interface

Brief explanation: Akonadi is a system that enables uniform access to various data formats across a wide range of data sources. Its main clients are graphics end user applications such as KMail. However, in some cases it is advantageous if data manipulation can be automated. Power users or system administrators often employ the multitudes of Unix/Linux commandline tools to achieve such automation tasks. The idea is to provide a tool or set of tools that allow Akonadi operations to be used in such scripts.

Expected results: A non-GUI program able to perform useful tasks on Akonadi provided data, like creating folders, adding/deleting/copying/moving data such as contacts or emails, etc.

Knowledge Prerequisite: C++, Shell scripting

Mentor: Jonathan Marten, Kevin Krammer and other KDE PIM community members

Resources: An early prototype can be found here https://projects.kde.org/projects/playground/pim/akonadiclient and there are two, non-Akonadi, clients which are part of KDE PIM: kabbclient (contacts), konsolecalendar (calendar) Contact the kde-pim mailinglist for discussions: https://mail.kde.org/mailman/listinfo/kde-pim

Simon

Simon is a speech recognition suite.

Website - Mailing list - IRC channel: #kde-speech on Freenode.

Project: Streamline handling of various resources

Brief explanation: Simon uses a multitude of different components: Scenarios, Base models, Shadow vocabulary, Language profiles, etc.

While many of these components can be downloaded from within Simon, some can't and even for those that are better integrated, end-users still have to read additional documentation to know which components work together and which don't.

The aim of this project is to bring the handling of these resources under a uniform and user-friendly interface. Specifically, the interface should resolve conflicts automatically and deduce an optimal default setup by itself (e.g. based on the system language and installed programs).

Expected results: Much more user friendly setup.

Knowledge Prerequisite: C++/Qt

Mentor: Peter Grasch <peter {+at+} grasch.net>

Resources: Some work (mostly brainstorming and UI design) was already conducted during Season of KDE 2013. Please contact me for details. This does not mean that this project is already assigned!

KDE Telepathy

Project: Conference Video Call Support

Brief explanation: Our current IM client can handle a 1-1 video call reasonably well. It currently does not support conference calls (>2 people). Our backend Telepathy should support this, but we do not make use of it in our client. This project will involve

some UI design
some low level GStreamer work
fixing parts of the Telepathy stack.

Current code is inside the repository ktp-call-ui.

Expected results: Working multi conference video calls.

Knowledge Prerequisite:

C++, Qt
Ideally; QML, GStreamer and Telepathy

Mentor: David Edmundson and Diane Trout

Project: Telegram Network Support

Brief explanation: Telegram is an upcoming network that aims to replace WhatsApp. Unlike whatsapp it has an open protocol (https://telegram.org/) and is gaining popularity.

We want support in our IM client. This should be done by creating a connection manager using TelepathyQt service bindings.

When this is complete, not only will we get Telegram support, but due to the distributed nature of Telepathy it will also work for Jolla, Ubuntu Phone and Empathy.

Expected results: Working single and group chats using KDE Telepathy over the Telegram network

Knowledge Prerequisite: C++, Qt, Reading Protocol Documentation

Mentor: David Edmundson

Solid

Project: iOS Integration

Brief explanation: Integrate the iOS platform with the Plasma desktop using libraries like libimobiledevice and kdeconnect.

Expected results: Have an iOS application that is able to talk to KDE Connect and desktop integration using libimobiledevices.

Knowledge Prerequisite: C++/Qt, Objective C

Mentor: Àlex Fiestas <afiestas {+at+} kde.org>

Resources: libimobiledevice, kdeconnect, plasma

Project: Make Libbluedevil Async

Brief explanation: Extend libbluedevil to have an asynchronous api, and port bluedevil to it.

Expected results: libbluedevil should have an asynchronous api, and bluedevil should be ported to them.

Knowledge Prerequisite: basic Qt and DBus

Mentor: Àlex Fiestas <afiestas {+at+} kde.org>

Resources: libbluedevil, bluedevil, afiestas

Project: Improve sharing experience

Brief explanation: Improve the content sharing experience in Plasma by extending and improving Samba share, implementing other ways of sharing and write new ways of discovering other people's shares.

Expected results: It should be possible to discover "shares" using dolphin (possibly via a new kioslave?) and it should be possible to share a folder between two Plasma computers really fast and easy (possibly implementing an http server plus discovery via avahi).

Knowledge Prerequisite: C++/Qt, extra points for KIO experience.

Mentor: Àlex Fiestas <afiestas {+at+} kde.org>

Resources: avahi, http, kdenetwork-fileshare

Plasma Media Center

KDE's Plasma Media Center (PMC) is aimed towards a unified media experience on PCs, Tablets, Netbooks, TVs and any other device that is capable of running KDE software. PMC can be used to view images, play music or watch videos. Media files can be on the local filesystem or accessed with KDE’s Desktop Search.

Project: Integrate with Simon

Brief explanation: Simon is an open source speech recognition program that can replace your mouse and keyboard. The system is designed to be as flexible as possible and will work with any language or dialect. This project aims at integrating it with Plasma Media Center to control it.

Expected results: Using Simon, the user should at least be able to use voice to -

Control playback of media (images, music, videos)
Navigate in the media browser (next page, previous page, "goto the 3rd item")
Home Screen navigation
Ability to switch to the player, image viewer, or playlist
Play a media file in the browser (or the playlist, when its shown) using its name

Knowledge Prerequisite: Basic C++, Qt and QML

Mentor: Shantanu Tushar <shantanu {+at+} kde.org> and Peter Grasch <peter {+at+} grasch.net>