IMPORTANT DISCLAIMER: Currently this page is not exactly nice to edit. If you have an idea you would like to add to one of the categories below don't bother about the formatting of the table. Just follow the following pattern and add it below the table.
This feature is present in both boost::shared_ptr and in std::shared_ptr (C++0x) and allows an object to return a QSharedPointer from itself, if one exists.
For Qt, this would also need to integrate with QObject without breaking binary compatibility.
See QTBUG-7287
Write an QAbstractEventDispatcher implementation using epoll(2)
Qt's event dispatcher is a pluggable mechanism. The current Unix dispatchers are either a select(2)-based one and a glib-based one (which uses poll(2)). It would be nice to have one using epoll(2) on Linux which has the potential for being even more performant.
Bonus: a kqueue implementation for the BSD-based OSes (including Mac OS X)
QDBusServer doesn't work. It's an empty implementation. It would be nice if it were made to work. See QTBUG-186.
It may require refactoring the current event-processing code out of QDBusConnectionPrivate into a separate base class that could be shared with the server.
Write a plugin for Lighthouse to port Qt to something cool. Possible ideas
* Lighthouse on OpenGL?
* Lighthouse on Wayland
-
@nokia.com
QML
Presentation Tool using QML
Write a demo application using QML for a presentation tool that has the basic features of competitors (PowerPoint?, KeyNote?, Open Office Impress), as for example: master slides for defining the theme, presentation mode with a special view for the presenter (time counter and snapshot of next slide). The slides can be qml or wiki-style format text files (don't need a visual editor).
Propose a way of defining a schema for QML, so you can specify what elements, states, signals and properties a qml file has to contain to conform to the scheme.
This is useful when your application's UI is defined in qml and you want to change the qml file dynamically (for theming purposes).
The currents demos of QtWebkit? are designed toward desktop computers.
This project is about writing a demo browser designed for embedded devices with touch screen (Maemo or Symbian).
This includes the research on touch interactions and performance problems.
Create a way to simplify the creation of multiprocess application drawing in a single window.
For example, in an instance of Kate, each document could be a separate process.
The rendering of the document is delegated to the other process, and shared with the process that is managing the Window (by QImages in shared memory for example). The events need to be forwarded from the window to the rendering process.
A mechanism should also exist to deal with special windows like menus and tooltips.
Google currently provides client libraries for using the Google Data API from many programming languages, such as .NET, Python, Java, JavaScript? and Objective C. Write a C++ client library for Qt applications. Try to design a nice Qt-like API.
C++, Qt
QML
Quick Designer Integration
Build on existing work for GIMP (jens) to extend the formats and tools supported that can import graphic assets directly into the Quick Designer
C++, Qt, Qt Cretaor
QML
Extending Language Semantics
Work on extending the QML semantics with new types such as tweenable shapes - while allowing use on Embedded platforms (i.e. retain performance characteristics)
Devising a functionality that would enable memory profiling on Symbian. Code should be based on Symbian native calls. Later, this should be used to instrument existing Qt code.
UDT is a reliable UDP based application level data transport protocol for distributed data intensive applications over wide area high-speed networks.Often used with HPC. Qt should support the protocol.
In some cases, the raster engine has to be used even when accelerating hardware is available. One of those cases is the threaded rendering (http://labs.trolltech.com/blogs/2010/01/21/qt-graphics-and-performance-generating-content-in-threads/ )
Writing the painting primitives (like blending functions) with OpenCL? might be a solution to get even better performance in those cases.
This task is about writing the painting primitives with OpenCL?, while still having thread safety.
The accelerator used with OpenCL? have to be a graphic card (N900 or ATI or Nvidia).
Put creator on a par with eclipse for refactoring.
Modifying existing code should be easy with any IDE.
Add features to
add getters and setters in two clics
keep the signatures of functions in sync between the .h and .cpp files
finding all the uses a function/method. (by checking the type, not only based on the name like today)
renaming classes (and renaming the file accordingly)
move a class to another project
etc
C++, QtCreator
Add a command line to QtCreator
One of the strength of Emacs is the small plugins you can write and execute easily.
The task is about creating a way to write small plugins with Javascript directly in creator, and adding a command line to execute those plugins if they have no bindings.
For example:
You write a javascript directly inside creator to change a binary representation of a number into hexadecimal
you save the file as "binToHexa"
in the C++ editor, you write 00001111
you select this text
you type Alt+x, then type binToHexa, enter
the text is changed to 0x0F
In a sense, this is also similar to what Mozilla Ubiquity does.
C++, QtCreator
Ideas for Libqxt
LibQxt is an extension library for Qt providing a suite of cross-platform utility classes to add functionality not readily available in the Qt toolkit by Trolltech, a Nokia company. It aims to support the same platforms as Qt does, and the same users. Traditionally the core developers contribute as part of their professional work, and collaborate in that way with other professionals. Qxt also receives contributions from the open source community in the same time. As a result, Qxts licensing has always been more relaxed then Qts open source license. We pride ourself on an excellent team of professional Qt developers and on being always a step ahead of Qt with implementing new technology.
Title
Description
Requirements
Message Framework
Qxt already contains utils to send mail messages. The task is to implement classes to receive mail, such as pop3 and/or imap and additional connect options. In the tradition of Qxt, all of those classes would be self containing without external dependencies.
Knowledge in common network protocols such as smtp,pop3,imap, and experience in reading RFCs.
Web Service Framework
Qxt provides a library to build webapps in Qt. The task is to build a release quality website in qxtweb to test it in the field, and gather the results to make it better. The website would contain elements of modern web applications, such as ajax forms and an api for the "cloud". One possible idea for a webapp would be a quassel webclient. A solution should be found for secure session persistence.
You have an interest in web applications, and have gathered some experience with elements of "web 2.0". An intermediate level of Qt is required, but a good knowledge of how http servers work.
Service Discovery Framework
Qxt contains facilities for configure free service discovery. However, they are abondoned. ResurectQxtZeroconf?, first by documententing the existing code, then by completing the implementation on windows,mac, and linux.
Some platform specific Knowledge on all Linux,Mac,and Windows. Experience with networking.
Inter-Process Communication
Qxt Rpc Objects is an implementation that makes is possible to remote QObjects and use them in other processes. It can be compared to .NET remote objects. The task is to extend the existing project by implementing a remoting protocol and finalizing its API.
Qt's metaobject system, and IPCs
Software Update Framework
Multimedia Extensions
Extend QAudioInput? and QAudioOutput? with volume control and change notification support. Furthermore, a style aware volume level bar widget could be implemented. Some prototype code available at: http://bitbucket.org/jpnurmi/mikki/
Some experience in Gui and Api design. Intermediate knowledge of digital audio processing.
Port Qxt to Symbian
Libqxt is interesting to more platforms then there are currently supported. One of the most popular requests is a port to symbian.
An extensive knowledge of the symbian platform.
Crash Handler
Design and implement a cross-platform crash handler that hooks to the underlying platform as tightly as possible. Add possibility to send backtraces and any other meaningful crash related information to the author when client application has been built with support for that. Use QSegfaultHandler (private) as a starting point for Unixes, catch SEH exceptions on Windows and SetExceptionHandler() on Symbian. Furthermore, implement a crash handler/report dialog for platforms that don't provide native one.
Implement several Widgets for presenting Charts in a Qt Application. They should range from simple bars and curves to pseudo-3d pies. They should fit well into the Qt Itemview system. Some mookup code can be found here: http://bitbucket.org/aep/qt-charts/
Qt, Gui, Painting, Itemviews.
Ideas for Quassel IRC
Quassel IRC is a modern, cross-platform, distributed IRC client, meaning that one (or multiple) client(s) can attach to and detach from a central core -- much like the popular combination of screen and a text-based IRC client such as WeeChat?, but graphical. It is based on Qt and supports most platforms Qt runs on, namely Linux, BSD, Solaris, Windows and Mac OS X.
Summary: Mobile UI for Quassel Client
Description: We'd like to bring the Quassel client to mobile devices. This is a feature that has been requested often, as many use it on the desktop and would love to connect to their core on the road. We had a proof of concept for Qtopia devices before. As Qt is now available on several widespread mobile platforms, namely Symbian S60v5, Maemo/Moblin and soon MeeGo?, and hopefully also on Android at some point, porting the client is feasible (i.e. recompiling it is mostly sufficient). In fact, proof-of-concept packages for Maemo already exist.
However, the current UI is desktop-oriented and does not fit well on small formfactors. It is also somewhat resource hungry. Hence, an alternative UI is needed for mobile devices. We have designed the Quassel client with this in mind; most of the client logic is neatly separated from the UI code. This means that e.g. the network and message handling can easily be reused. More technically speaking, the client lib provides a set of QAbstractItemModels? and appropriate signals/slots, and the UI provides views on those data models.
Additionally, generic UI features and widgets are already separated from the main UI. Providing a different UI would involve size- and resource-optimized specializations of generic widgets (or writing new ones where appropriate), and finding an overall design that makes using IRC on a small (touch-)screen device a pleasure.
Naali is a client application for virtual worlds, developed in the realXtend project. It can be used to make networked games and other applications, like architectural design, in shared 3d environments. Naali uses Ogre3d for graphics, and Qt for the 2d UI and much of the internals.
Summary: Make a 2d map view that shows nearby people and the environment.
Description:An essential part of 3d virtual worlds is having 2d from-to-top views to the scene. A radar like tool that shows e.g. nearby buildings, objects and people relative to self -- this is sometimes called a minimap in other systems.
Making the own map widgets is normal Qt development. Other modules in Naali can be queried for information about the scene, such as positions of nearby people (avatars) and images of the surroundings.
We currently support modules written in C++ or Python (using PythonQt), with Javascript (QtScript) possibly added soon. The student can propose which language to use and why, and we can also discuss it as a part of detailing the design.
Project Ideas
logo.png
|
