(So far only final year results are out – 8th semester)

Here’s a list of potential websites you can check for your results. Comment if you know some other ones!

(I shall keep updating the links once results are out)

1. Anna University Official Website (Results Page) for 2009 Even Semester (B.E./B.Tech)
2. Anna University Official Website Links (Site I, II)
3. Webdunia Anna University results for UG 2009
4. Chennai Online Results for Anna University UG 09
6. WinEntrance Online Results for Anna University UG 09
7. India Results results page for Anna University UG 09 May June
8. WorldColleges results page for Anna Univ. UG 2009
9. Sivaji TV results for Anna Univ UG 2009

More will be added once results get out.

The solution is to switch the video driver (Preferences – Video tab) to x11, which supports zoom.

To do so, one must first create the local site-packages directory, and then place the required package or module file or folder under it. The following commands are all for UNIX. ~/ expands to the user’s $HOME automatically.

# To create the required directory
mkdir -p ~/.local/lib/python2.6/site-packages

Now place the module or package folder under this directory, or link to it for achieving the same installation effect as you would with a global site-packages directory. For example, for my django copy from svn I’d do:

ln -s ~/.django-svn/django-trunk/django ~/.local/lib/python2.6/site-packages/django

Running the Python interpreter (in the same user account) will show this working:

Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import django
>>> 

So there you have it, when you want a package just for your user account while developing just put it under the local site-packages directory. Python automatically adds this to its path (PYTHONPATH).

References: PEP 370 (Has notes for OS X and Windows users)

cd /var/log
for file in `find .`
do
	if [ -f $file ];
	then
		cat /dev/null > $file
	fi
done

Suggest better methods if known, and thank you!

Optionally, get in there and delete those now-stagnant .gz files with the following:

find /var/log -name "*.gz" | xargs rm

P.s. So much for BS code highlight plugins printing angled brackets in HTML notations when asked to do bash.

Open Sound System - Much better!

The answer, as I learnt, was both yes and no. It did die, only to be revived later by 4Front Technologies who developed it under a commercial license for quite sometime. It went GPL only recently, although with a paid premium-support and on certain platforms only. The improvements made in it are simply amazing. I’ll leave the rest of the mystery to be covered by 4Front’s own blog post. It’s a nice read

The following guide on how to shift to OSS from PulseAudio/ALSA is for Ubuntu (Jaunty Jackalope, 9.04*) users alone. A proper guide to ArchLinux’s solution might be found here.

Getting OSSv4

Download OSSv4 from 4Front’s website directly. Click here for the current DEB package. This one package is enough for installing the whole of OSS 4.x.

Now to prepare for our installation, issue the following commands:

sudo apt-get install build-essential binutils linux-headers-`uname -r` gawk
sudo apt-get install libtool libgtk2.0-dev libesd0 libsdl1.2debian-oss

These packages are necessary for installing the downloaded DEB package. Next, issue these to disable ALSA from loading next time.

sudo cat /lib/linux-sound-base/noALSA.modprobe.conf >> /etc/modprobe.d/blacklist.conf

And,

sudo echo "blacklist snd_hda_intel
blacklist snd_mixer_oss
blacklist snd_pcm
blacklist snd_timer
blacklist snd_page_alloc
blacklist snd_hwdep
blacklist snd
blacklist soundcore" >> /etc/modprobe.d/blacklist.conf # One whole command

Finally,

sudo dpkg-reconfigure linux-sound-base # Choose OSS in the list shown.

Now reboot your PC so we can stop ALSA from loading. This ensures it doesn’t interfere with the OSS installation.

Installing the Open Sound System

Since double-clicking the DEB (GDebi) won’t work with our downloaded file, go to the Terminal, and in the directory of your downloaded .deb issue:

sudo dpkg -i oss-linux*.deb

That’s it, let the installation complete and you would have an OSS-enabled environment ready. Test it out with various applications, games and even Flash in the browser! MPlayer has an option in its preferences to set its audio system to OSS, so do some other applications in case they don’t seem to work.

Flash issues, if present, might be cleared if you purge and re-install libflashsupport.
No more PulseAudio server issues, sound stuttering, connection errors, etc.!

Finishing Up

In your System – Preferences – Sounds, ensure all the settings are set to OSSv4 as shown via this screen-shot.

Go to your GNOME-Volume-Control (via the volume applet) and from the Preferences list there, tick on all the settings you need and also vmix0-src. Then get back to the main dialog and in the Options tab set vmix0-src as Production for the best quality of sound (Might be a tad too loud, you can also play around to see which is best for you).

Bonus: Run the ossxmix application after you’re done for a lovely control panel!

References: Kalpik | Ubuntu Wiki

* Might work with Intrepid Ibex too. Earlier versions would require certain ESD libraries.

The PyQt Class Hierarchy

PyQt is completely built upon the Object-Oriented concepts, so it is important to understand how all classes are related to each other in it.

Almost all GUI classes extend upon their Abstract class which defines common behaviour for similar widgets. These abstract classes, or any widget class, inherit QWidget, the base class of all drawable GUI components. QWidget inherits QObject, a class that has nothing to do with GUI but forms the base class of every PyQt class and helps provide the framework-related features.

The following hierarchy diagram depicts this clearly for the QPushButton class:

The QPushButton Class Hierarchy

The QPaintDevice class helps draw (or paint) things on the screen, thus its also used with anything that’s drawable – We’ll learn more about Painting in a later article.

References: QWidget

Signals and Slots

All user-interaction with widgets can be performed using the concept of Signals and Slots. When a user performs an action over the widget, be it a click, a key press or even a mouse hover, an event is generated each time. These common events can be handled using the concept of signals and slots.

Basically a signal is something that’s generated each time an event occurs. The signal is ‘emitted’ by PyQt’s classes internally. To handle such signals we use the concept of slots. Each signal is given a slot to connect to. Once connected to a slot, whenever the signals are generated the slot captures it and executes a pre-specified function to process the event.

So in short words signal is something the framework emits each time an event occurs and a slot is something that receives this signal with its arguments and executes a routine.

To demonstrate the concept of signals and slots in PyQt, lets use a QPushButton along with a QWidget for the window.

The following code runs an application with a button, which when clicked upon will quit the application.

This is done by connecting the “clicked” signal of the button to the application’s “quit” slot.

Signals and Slots Example

# Program 02 - Signals
from PyQt4 import QtGui, QtCore
import sys

if __name__=='__main__':

	app = QtGui.QApplication(sys.argv)

	window = QtGui.QWidget()
	# Create our main window using a plain QWidget.
	window.setWindowTitle("Signals")
	# Set our window's title as "Signals".
	button = QtGui.QPushButton("Press", window)
	# Create, with "Press" as its caption,
	# a child button in the window.
	# By specifying a parent object,
	# this new widget is automatically added to the same.
	button.resize(200, 40)
	# Resize our button to (200, 40) -> (X, Y)
	button.connect(button, QtCore.SIGNAL("clicked()"),\
		app, QtCore.SLOT("quit()"))
	# Connect the button's click signal to the QApplication's quit() slot.
	window.show()
	# Show our window.

	app.exec_()

Connecting a Signal to a Slot

Connection is performed to enable particular events call their respective slots. All QObject derived classes support connections of signals and slots.

Simple syntax of the connect() method:

object.connect(Signal_Widget, Signal, Slot_Widget, Slot)

The connect() function makes a connection using two sets of parameters:

1. “signal” set
   • Consists of the signalling object and the type of signal you wish to handle (Given by SIGNAL(QString)).
   • Every widget emits a signal upon an event like a user interaction or timer generated.
   • These signals are not to be confused with POSIX/UNIX signals, that’s a wholly different OS-level concept.
2. “slot” set
   • The receiving object, and the slot it must execute upon the signal (Given by SLOT(QString)).
   • Every emitted signal can be handled by a function, called in PyQt-lingo as a “slot”.
   • A slot is executed each time the signal connected to it is emitted by the signalling class.

QtCore.QObject is the class that provides us the connect function you used. Since our class is derived from QObject, we can also use it from it’s instance. This means that the 20th line can be replaced with:

QtCore.QObject.connect(button, QtCore.SIGNAL("clicked()"),\
	app, QtCore.SLOT("quit()"))

A PyQt widget has many signals and slots. For example a QAbstractButton has clicked(), pressed(), released() and toggled() signals and click(), setChecked(Bool), toggle() slots. PyQt pre-provides most of the GUI functionality needs one can think of.

References: QObject | Signals and Slots | QPushButton | QApplication

Layouts

If you tried stretching the previous example’s window a bit, you would feel that the button is more pasted onto the window than placed. It does not move from its position, the window contents don’t mutate based on the user’s screen. Layouts help in this aspect and more.

As the word means, Layouts help lay out your widgets on the form/window in a proper manner. QLayout forms the most basic Layout class and has four major layout sub-classes. The types of those are Box, Grid, Form and Stacked layouts. The following depicts the hierarchy of these layouts, and how some of these look.

PyQt Layouts Hierarchy

Using a Layout is simple in PyQt. One only has to attach the preferred layout to a window/widget and then adding the components to it (the layout) will automatically lay them out. The following topic’s example makes use of the QHBoxLayout.

Various PyQt Layouts - Each square can contain an item.

References: QLayout | Layout Classes

Passing Arguments to Slots

Signals and Slots can also carry parameters. This is useful when there’s an input involved, or when there needs to be some data sent automatically each time an event occurs.

Let me demonstrate another example, one with parameters. In this example I shall connect a line editor to a label, and as one enters text into the line editor events are generated that make a slot of the label execute and change its display text to the one you’ve typed. For this we need to use a QLabel for the label and a QLineEdit for the line editor.

List of steps to write the code below:

1. Import necessary classes and functions from PyQt4 (QtGui and QtCore).
2. Create the QApplication instance.
3. Create a Window (QWidget).
4. Attach a QHBoxLayout to it (By setting Window as its parent).
5. Create a Line input widget and add it to the layout.
6. Create a Label widget and add it to the layout.
7. Connect the textChanged(QString) signal of the QLineEdit to the setText(QString) slot of QLabel.
8. Show the Window.
9. Begin the Application loop.

Signals and Slots with Arguments Example

# Program 03 - Signals and Slots with Arguments
from PyQt4.QtCore import SIGNAL, SLOT
from PyQt4.QtGui import QApplication, QWidget,\
	QLineEdit, QLabel, QHBoxLayout
import sys

if __name__=='__main__':
	App = QApplication(sys.argv)
	Window = QWidget()
	Window.setWindowTitle("Arguments")
	Layout = QHBoxLayout(Window)
	# Create a Layout Object, attached to the Window.
	Line = QLineEdit()
	# Create a Line-Editor / Text-Box.
	Layout.addWidget(Line)
	# Add it to the HBox Layout.
	Label = QLabel()
	Layout.addWidget(Label)
	Line.connect(Line, SIGNAL("textChanged(QString)"),\
		Label, SLOT("setText(QString)"))
	# Connect the required signal and slot.
	Window.show()
	App.exec_()

When the user enters/modifies the text of the QLineEdit widget a textChanged(QString) signal is emitted with the new modified string loaded into it. We intercept this and connect it to the QLabel’s setText(QString) function/slot. Thus the changed QString travels from the QLineEdit to QLabel and is set for display, all upon a single character modification!

The Layout part (Lines 11, 15, 18) has an interesting function addWidget() that takes a widget and adds it to the layout geometry. The addWidget method also takes a stretch-factor and an alignment factor as its parameters, along with a QWidget/derivative. The layout automatically adjusts the widget sizes based on the text input in this example. If you increase the window size, the layout makes it adapt to the same – try it out to understand!

If the signal/slot concept still sounds confusing, the following graphic will clear it up a little more.

Signals and Slots in the Arguments example

So that’s it about Signals, Slots and Layouts!

References: QLineEdit | QLabel | QHBoxLayout

Exercise

Use a QPushButton in a QWidget window and toggle its text each time its clicked. Also, add a layout to the window with the button in it.

Each time the button is clicked, its text must toggle. For example, if the Button’s text is Hello, after a click it changes to PyQt and another click makes it Hello back again. Ensure that the button gets expanded as the window it is in grows.

Footnotes:

• You can pass a function directly to the connect() too, for slot-purposes. It needn’t be a PyQt-provided slot always.
• We can also write custom signals and slots for certain events, how awesome is that? I will cover it when we begin to write our own PyQt Classes.
• Not all GUI components have an Abstract class. They exist only for a widget or an item that can be extended in more ways than one.

P.s. While commenting on this article, do nest the code in <pre> and </pre> tags.

So to place a package or a link to one, simply do so in the /usr/local/lib/python2.6/dist-packages/ directory.

Footnotes:

• The best way to learn and use Qt is to follow the Qt Documentation (via the Qt Assistant that comes along with the installation). Though it is C++ centric, its not much different when you use it in Python. Qt is Qt everywhere, across platforms and across languages too. Ruby, Python, C++ or Java.
• Books you can refer to, if you really want to, are Mark Summerfield’s Rapid GUI Programming with Python and Qt and Boudewijn Rempt’s GUI Programming with Python: Qt Edition.
• My personal favourite, however, is C++ GUI Programming with Qt by Jasmin Blanchette and Mark Summerfield. Though it’s in C++, the book has a very good approach.

Here’s one solution – PyQt! With it you can create complete working applications that look like the following:

Nokia’s Qt is a free (LGPL) cross-platform C++/Java based application-framework, with GUI being its most prominent feature.

PyQt is simply a python-binding to the C++ libraries that Qt provides. Using PyQt one can write neat looking GUI applications that do a lot, and do so easily.

A series of articles, starting with this one will aim to tutor interested programmers into using this wonderful library, and developing applications with it.

Prerequisites:

• Basic Python knowledge.
• A little know-how about GUI and the event-based-programming concepts.

Two primary resources where we start from:

1. Nokia’s Qt
2. Riverbank Computing’s PyQt

Downloading and installing PyQt is fairly easy on Linux thanks to the various package managers. Do check out the download links at each of the above-mentioned links to get them on other platforms as well. Installation help is also provided by Riverbank Computing to help you set-up the PyQt4 library.

Code:

So let’s start off in the same style as almost everything do in a programmer’s perspective:

Hello World!

Below is a well documented program for you to start with:

import sys

# Importing the necessary Qt classes.

from PyQt4.QtGui import QLabel, QApplication

# We use the from foo import * syntax here because
# all of Qt's objects begin with a Q
# and thus we shouldn't run into namespace problems.

if __name__=='__main__':

	App = QApplication(sys.argv)

	# All Qt programs need an
	# QApplication instance.

	# We pass the sys.argv as its arguments
	# because Qt is adept at handling some
	# of the default command-line options
	# like style, size, etc by itself.

	Label = QLabel( "Hello World!" )

	# QLabel is the class providing a
	# simple label

	Label.show()

	# Like in most GUI toolkits, we have
	# to manually set it to show

	App.exec_()

	# Notice the _ after exec, this is to
	# avoid the confusion with Python's
	# exec() built-in-function

	# exec_() starts the main application
	# loop. Something like main() of other
	# toolkits.

This is how it looks when run, a simple application that displays some popular text:

Breaking it down:

The first thing we have initialized under our ‘__main__’ is the QApplication instance, App. Every GUI application needs this instance to be present. It handles the look and feel of the application and is the main thread of the same. Without it Qt will error out and not run any GUI.

Next we create a label. A label is a simple text-displaying widget used in many forms to describe the input fields and other things. In Qt, its called the QLabel and resides under the QtGui namespace. We create one with a simple Hello World text under the object name Label.

Now we call the show() method of the label so that it appears on the screen. This method is applicable to all QWidget-class children, and QLabel is one among them. Calling show() draws the label widget’s window on the screen.

Finally, we start the application loop, the one responsible for making an application run as an infinite loop waiting for user-interaction. Its done by the exec_() method of QApplication (App is the instance name). Note the _underscore_ in the function name, this is to avoid confusion between Python’s own exec() built-in-function.

More soon, hope you liked the intro. Do follow the PyQt tag

Footnotes:

• Am running this Qt application in a GNOME environment and thus you see the GTK style being used. Qt can adapt to your environment and can use the native style of any platform it runs on. Also, you can try out the -style option to change it too. More on this as we progress.
• This program is just a quick start for the impatient, a dose for the hyperactive. I shall take a slow, but smooth, approach to the finer details of PyQt as the tutorials progress.

With the model exams over, I have about a month’s holidays to prepare for the 6th semester exams. Too much time, probably cause I listen in the classes. This semester was pretty good compared to the five before since it had two programming and one cryptography topic accompanied with some mathematics to keep the dullness taking over. I don’t know what they’ve chosen as electives for the next semester, but I do know that learning Compilers and related topics at college has nil possibility now. I can learn things myself but I don’t always have that discipline required, hence the sadness of not being taught.

I’ve decided to merge here, the PyQt blog I have running over at WordPress.com. I’ve not posted much there, and think that it will be better off at my own blog. Will be posting the existing posts one at a time. Qt 4.5 brings in quite a lot of performance boosts and their blog is very active these days with new concepts/features being put up almost every week. Thank you Nokia!

I also upgraded my Ubuntu from 8.10 to 9.04 flawlessly. The updater’s config-file diff warning notices need to have more options since it blocks the update process; an editor should do well. Jaunty Jackalope, as it is called this time, has good updates like OpenOffice.org 3 (Took long enough), Qt 4.5 (Wonder how KDE4 would perform on this one), Python 2.6 (Deprecation warnings, yum). A lot of other updates are present too, I just mentioned the ones I cared about.

One of my cabinet fans started making very loud droning noises and it made my temper flare quite a few times. I literally punched it, hard. The everlasting dust issue also started to seek attention again and I had no choice but to sit down, yet again, and clean the CPU off its dust. The graphic card had quite a lot of dust collected upon it this time, and that was the reason why the computer whined when I played a graphic-intensive game. After cleaning off the cabinet using an air-blower, I detached the side fans and after discovering that they had a secret compartment beneath the sticker I gave it some oiling.

It does not make much noises now, except for a few audible scratches when my Prescott is really hot trying to run the VisualBoy Advance at 400% throttle. Peace in my small room, at last. I’m losing patience on this 4 year old machine and I have probably mentioned that a hundred times. Yet I can’t seem to take a decision and buy a newer PC, and I don’t know why. The only things am sure about right now is on getting a 22-inch monitor and half a terabyte of secondary storage with two or four gigabytes of primary memory thrown in. The processor and the motherboard, however, are still delaying my decision with new ones coming in every other month. I’m dying to dive into the upgrade pool.

Having, at least, three weeks of free time I decided to get myself the Spider-Man’s Web of Shadows game. It does lack in performance but has some cool moves, like the last movie game did. I also want to play the Broken Sword series again but I don’t think I’ll find time to do that. For now, let’s just swing with the symbiotic.

Anyway, that’s all I’ve done in the past three days. More as they come.