Notification Manager Documentation

Notification Manager RC

Pardus Notification Manager 1.0 Release Candidate is ready. To try it checkout the code from SVN repo and do the usual "./setup.py build" and the "sudo ./setup.py install".

To use the sample client program for sending notifications execute the client.py script. It will wait for a command, you can send a sample notification by issueing the following: notify "c00L notification" "whazup dude?"

In addition, you can use the installed config.py to configure the notification manager.

Apart from bugfixing and writing some documentation, my GSOC 2008 project is over :)

Pardus Notification Manager Configuration Tool

Configuration tool of the notification manager is ready! The tool lets the user change the PNM config file in a user friendly environment, and saves the XML file back. The tool also validates XML files using an XSD and hence does not permit a 'wrong' configuration to be saved. This program uses the lxml library instead of the default pyxml, as the latter does not offer any XSD validation support.

Now the only remaining task is to have the PNM read the XML config file and behave accordingly. Then, we're all done :)

Cheers,

ozan

PNM now supports notification replies

Notification senders can now add buttons to the window that shows their notification. When this interactive mode is selected, the SendNotification() procedure of the PNM becomes a blocking procedure which waits until the user presses one of the supplied buttons or the notification times out. For applications involving a main event loop, the notification sender can make the SendNotification() call non-blocking by providing two callbacks to it. When the user presses one of the supplied buttons or a timeout happens, these callbacks are called. Both GLib and Qt main loops are supported. A screenshot is given above.

PNM GUI is now skinnable

I made major changes in the GUI code structure: The GUI is now skinnable and the default GUI is not hardcoded. The program loads the ui file dynamically when the program first starts. There are still some restrictions though: The ui file needs to have some compulsory elements for the mechanism to work (e.g. an exit button). I will write some documentation on how to create a compatible ui file sooner or later :)

Cheers,

ozan

New GUI for PNM

PNM now has a completely redesigned GUI. It allows multiple notifications to be displayed on the screen. Each notification can be closed independently and positioning of the notification windows are automatic. The GUI has some animation too: When a notification window is closed, the notification windows on top of it slide down :)

 I tried to write the GUI as configurable as possible. I will try to get the program read its configuration from a file in the near future.

PNM now has gettext support

Simple GUI module of PNM

It turns out that learning Qt4 is much easier than I anticipated. So here it comes: I just finished coding a skeletal GUI module and it is working :) I tested the program with a simple command line client (notification generator) and it seems to be working fine. Soon I'll upload the sources to SVN and you'll get to see the thing.

Some Changes in PNM

Edited: Gokmen just informed me that a documentation of GLib (GObject in particular) python bindings is available, so we are back to GLib for the listener program. So the dbus-listener will be completely free of any Qt dependency. All of the stuff that I have written before does not apply now.

Cheers,

ozan

First Prototype of the Pardus Notification Manager

Edited: I made some minor changes to the overall architecture after consulting Gokmen.

I have written a quick and dirty (~140 lines) notification manager that listens the session bus, gets the notifications and adds them to its queue. It right now doesn't do anything else and does not have any GUI to display its results. I am gonna need to learn some QT4 to add display capabilities to it. Unfortunately finals will begin in one week so this may take some time.

Simply stated, I organized the software into four main classes:

1. Notification class: This class contains the data related to notifications. Right now it only contains the "message" property :) When one wants to send a notification, he/she will create an instance of this class and fill in its properties.
2. Notifier class: This encapsulates the whole IPC-dbus related stuff in it. The good thing about it is the following: When someone writes a program that needs a notification to be displayed, he/she won't even need to know anything about dbus. Just create an instance of Notifier, give it the Notification instance that contains your message, and kaboom! Your notification is sent to the notification manager.
3. NotificationManager class: There is only one instance of this class: the actual notification manager. This instance runs in a GLib Main loop and maintains a notification queue. Whenever a notification arrives, it gets added to the aforementioned queue and a QT4 based small GUI application is spawned to handle the notification.
4. NotXFace class: This class has only one instance as well. This instance is the actual dbus object that gets exported on the session bus. Instances of Notifier call methods on this instance, which then relays relevant information to the NotificationManager instance.

Note that users of the notification manager software does not even see the third and the fourth classes. They only use Notifier instances and Notification instances. Another important design decision was to separate the GUI part and the dbus-listener part completely. I initially thought of integrating both, but after talking to Gokmen I realized having a completely independent (and replacable) GUI (a seperate python module to be loaded) was a better design.

I implemented everything mentioned above except for the GUI spawned by the NotificationManager.

After getting over with finals, I plan to learn some PyQT and continue developing the thing.

Cheers,