I have already posted my ideas for this GSoC and a little bit about me
I looked at the Smolt code more closely and have submitted the proposal
on GSoC site. I want to repeat my proposal to discuss it here.
I'll be very happy to your suggestions and comments!
Br, Max Usachev
GTK+ client for smolt
The goal of this GSoC project is to create program architecture which
supports two or more independent UIs and redesign current codebase using
this architecture. Implement GTK UI for Smolt and adapt current QT-based
UI for new architecture. It's necessary to refactor and improve current
codebase to get better perfomance and code style. I'm also going to
implement some important and necessary wishes from Smolt wish list. The
proposal is based on
Smolt is a project for gathering hardware information from computers
running Linux. Currently smolt-gui is written in PyQt and it's difficult
to add this client to GNOME installation of openSUSE. So it's definitely
important to have a GNOME integration to ship on the default install.
It's also important to bring new features, which users proposed (Smolt
wishlist). There is a separate request in openFATE for implementing GTK
smolt client: https://features.opensuse.org/310490
Use graphical version of Smolt client with native GNOME UI.
The biggest advantage of this project is that openSUSE will get native
Smolt client for GNOME desktop environment.Users, who use Gnome
environment will get native Smolt client. Smolt client will be
redesigned and will get good program architecture, clean code and new
features (from Smolt wish list).
The most difficult task from my point of view will be to design support
of multiple UI toolkits. Smolt was designed and developed as QT
application, so some work will be required to make it to support QT and
GTK UIs. However I have skills in adapting Qt-based UI to multi UI
architecture and I'm sure that I can do this task.
The project tasks can be devided into 4 parts:
1) Analizing current codebase and choose the best solution for new
program architecture. The first ideas that come to my mind is use
factory pattern to generate UI instances and maybe modified MVC pattern
as program architecture. We can use factory pattern for all widgets or
factory only for general UI. For example:
from factory import ui_factory
ui = ui_factory(args)
All logic about creating necessary UI placed in factory module and
returns suitable UI depending on desktop environment. The good idea it
to move each UI to separate module, as I did in 'Mnemosyne for Maemo':
qt_ui, gtk_ui. My proposals about starting the program: smolt-gui -u
gtk|qt, something like that.
2) Adapting current QT-based UI to new program architecture. It's very
important task, because while implementing some new features we must not
forget about old features. I think it will not take much time, because
current codebase looks very clear and understandable. It's necessary to
move all Qt related code to qt_ui package and some helpful UI functions
in qt_ui/utils.py module.
3) Writing tests. It's necessary part of the task, because these test
will help while implementing GTK UI and also cover most part of
exisiting code. I'm going to refactor some modules and add new features,
so, the test are vital to prevent code breaking.
4) Implementing GTK-based UI. It's very important and the biggest part
of the task. We should decide, will new UI be looks the same as Qt UI or
not. If we decide to change UI, we should also take time for UI design
process. Anyway, I think we should take as a basis current Qt UI.
5) Refactoring the code and add new features accroding to wish list.
There are many parts of the code, which we can improve. For example, the
gate.py module. It't better to implement the _Gate class as singleton
(there are some ideas about it:
and remove Gate function. It's necessary to use Pylint and pep8 checker
to catch invisible errors and clean the code and make it beautiful and
I've been programming in Python for 4 years already. I have developed
many applications - scripts, services, parsers, web applications, but
most of them are GUI programs based on PyGTK. Also I have good skills in
UI designing and vast knowledge in architecture of GUI programs. I've
learnt a lot about porting Qt-based applications to PyGTK, when I was
porting PyQt application to Maemo platform, during my previous GSoC
project. I use Linux and know it very well. I am sure that I am the best
candidate for this project, because my skills very suitable for this
project and I have good theoretical and practical knowledges and strong
To unsubscribe, e-mail: opensuse-project+unsubscribe(a)opensuse.org
For additional commands, e-mail: opensuse-project+help(a)opensuse.org