I never really understand why public mailing lists never implement the reply-to munging feature to always overwrite the Reply-To fields back to the mailing list address instead of the user address. Erlang’s questions list is one such example.

The mailman software’s doc page on the topic of munging “reply-to” mentions that this is a pretty sensitive issue but I fail to see why. When I get onto a mailing list with a question, I would like to have the best responses – even if that meant it had to come from multiple people. If everyone posted to the list itself, the ensuing email “conversation” can be more effective than if everyone were to reply to only the author. In the former case, people who’ve offered solutions or suggestions can still have their answers improved upon by other people who’ve read it – thereby proving more helpful than the latter case.

There is this page which asserts the RFC’s statements on what the Reply-To really stands for, and I disagree to its views since a user getting on a mailing list does not know what they want their Reply-To to be. They are posting to a public mailing list and it would be very disappointing if the mailing list does not serve the public’s interest in sharing and improving knowledge. Following standards is a good thing when it is constructive, not destructive.

Let us get a little off-track here. Have a look at Stack Overflow, or even the newer Quora – They never hide any answers from the public when a question is replied to. The answers do not privately go to the author, nor do the comments upon it. Everything is pretty much public. As a result, people have enjoyed very good answers with edits and comments; and using web search has proven to be more effective in problem-solving at work or else ever since these sites got popular. Why can’t the same ideals, then, be applied to the archaic-yet-effective mailing lists?

I’d like to state my opinions only here (in personal spaces). I do not wish to engage in “flame wars”, which is claimed to happen in discussions on these topics and thereby refuse to bring up this topic on the mailing lists that follow no reply-to overriding.

in:sent from:me term -Re

Now am wondering why it didn’t strike me immediately to look for the “Re” keyword that makes a mail a reply de-facto. Of course, there’s a much more neater, more RFC-5322 compliant way of searching such mails, but I’m unsure if GMail supports such querying.

Spider-Man: Shattered Dimensions Box Cover showing all four playable Spider-Men -- 2099, Amazing, Noir and Ultimate (The Ultimate character comes with a Venom suit)

After playing Batman: Arkham Asylum, my bar that sets the definition of a good RPG action game just took a shot towards the sky. The game-play in it was the most involving for a comic character based RPG, based on a comic character who’s at human heights. The fights were great, the moving around the area fluid and just like how the character would do, etc.. I’m sure you’ll appreciate the game if you play it, cause the story doesn’t disappoint you either.

Along came the Spider-Man game, and brought in perhaps for the first time ever, the Spider-Man 2099 and the Spider-Man Noir characters into video games! I think they’re great characterizations. The former imposing the role upon himself to get rid of a drug addiction, and the latter just facing a twisted history with his timeless humor. Their comics are great too.

Spider-Man Noir -- Incapacitating a henchman. All in total silence. Way cool.

Now case-in-point: Spider-Man Noir. The Noir Spider-Man levels in Shattered Dimensions is very similar to what much of Arkham Asylum had to offer. Only, it has much more pace. Any Spider-Man game worth its salt would offer deadly combos and faster-than-eye-can-follow agility during battles, and Shattered Dimensions doesn’t disappoint. The way you could incapacitate a henchman in Arkham Asylum, you can do it with Spider-Man Noir using webbing. Sneak up on them in the darkness, and web yank them to blackouts. Its Arkham Asylum all over, but with webs and sticking on walls! I’m not getting enough of this, so am going and playing more of it now. What’s more is that it offers a great bunch of classic rogues from Spider-Man gallery, across different timelines; yet you don’t get lost!

You should try this game out, its good fun with not too repetitive themes. For Spider-Man fans, it is an imperative. Stan Lee has himself voiced over a few narrations. This one is surely a timeless classic.

For those who don’t know yet, you can start a fresh chrome window with a custom UA using the –user-agent command-line parameter while launching it:

# Using chrome, or chromium -- as you like it.
chrome --user-agent="My User Agent String. Bow to it, statisticians. Kidding."

You can then visit http://whatsmyuseragent.com/ to verify the results of the user-agent property change in Chrome/Chromium.

The command-line parameter, –user-agent, is (not very) surprisingly not documented under the supplied manual page.

wget https://beta.swype.com/android/get/?download_NOW=androidBeta -U "Mozilla/5.0 (Linux; U; Android 2.2; en-us; Nexus One Build/FRF91) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1" -O Swype.apk

There, nice and easy?

Sorry Swype, to make you count a N1 download instead of an SGS.

Never has a modal dialog made you read itself to understand. It has always been about pressing the right button, to get back to whatever it was you wanted to do. As far as intentions of the developers, and to some extent the libraries go, they only want you to do whatever it is you wanted to do in the software’s right way. Press the right button, and maybe the software will do good to you. Press the wrong button and you’re probably doomed. Press the only button and you know you’re back to square one. If there are no buttons, then thank god for the display manager. If there is no display manager, you’re free of all annoyances.

There have been enough criticisms of modal dialogs that the Wikipedia page for the same has a section discussing it. But one hardly finds an application that does not throw a modal dialog on your face for whatever it is you did wrong or it did wrong (oh the horror).

Then there came the web, claiming to do away with most modal stuff as the web GUI programming model is hardly similar to the desktop model. Designers had a great chance to rid all the flaws of ancient desktop models and implement the best usability ways there could ever be, with support of some very powerful languages and associated libraries. What got popular instead, are things similar to Lightbox.

Such elegant are the looks of a lightbox implementation (an example of modal-ness), that it makes you feel all warm inside when you see it working on your own website, the feeling you get about never having to, or having your visitors to, leave the page they are on in order to see content associated to it; and to certain extent, browse horizontally across all other associated content than just one. It began okay first, click a media and it begins a modal environment that looks like Apple’s keynote events with a spinner. People could also open the link in a new tab to view the image in their browser’s image viewer (or other). Then, people couldn’t. Someone exclaimed with great delight that their JavaScript Kung-Fu was better than others.

Its one thing to pop a modal window and darken out all other content to let it have focus. It is another thing to add a spinning animation with absolutely no information, percentage wise or other, to indicate progress. Nobody cared if the spinner were enough to let the user know content’s actually loading or not because hey, they developed it in environments where the network was blazing fast and you hardly ever saw it. Progress. They just don’t get its meaning right. Space and time are measurable quantities and with content, progress is finite and must be calculated to be called as a progress animation. Fancy circular spinning darkness is anything but fancy. Even the Flash developers of the past, present and the future understood this mostly. But not the web developers, never ever.

Has no one ever noticed how a browser or image viewers worth their salt render images? Has nobody seen the progressive rendering of image data on the screen as it gets downloaded? It might make your network feel slow, but it never lets it feel non-functional.

Plague like the Lightbox (and associated beautiful modals) must be scrubbed out of the WWW. Let my clicks pass me to another page, I don’t mind. Nobody ever minded it until someone suspected they did.

RSIBreak - Repetitive Strain Injury prevention software for KDE

It isn’t a full fledged timer feature but I think it will get your needs covered with its offerings easily enough. One of the amazing utilities I’ve used, built with KDE Libraries. It should be available in your Linux distribution’s software repository too.

Note: If you’re new to using PyQt but are interested in great cross-platform GUI application development please read the PyQt Introduction article.

Designing a graphical interface for an application could be a tiresome task. There are guidelines to keep track of, layouts to maintain and more of such stuff. In the PyQt code samples you’ve seen so far we’ve written our interfaces in pure code. While this is fun and easy to do for little applications that consist of about 5 to 10 widgets, it’s not worth spending the time upon in creating fully blown up interfaces for complete applications.

The Qt Designer

Fortunately, Qt provides us a tool to design interfaces and to port it to usable code automatically. This tool is called the Qt Designer, and it comes with the Qt library bundle you installed. Additionally we would require a converter for processing the XML .ui files Designer produces into a python module .py file; also installed with the PyQt4 bundle.

Thus, to design in PyQt we need the two following tools:

• Qt Designer from Nokia’s Qt Software
• The pyuic4 script from Riverbank’s PyQt

Once you have Designer and PyQt4 tools installed, let’s fire it up and get started.

The initial interface might look familiar to those who have used Visual Studio, or Glade and such tools. For the rest, it’s intuitive enough to learn smoothly. Read the Qt Designer guide for more elaborate help if you still don’t find it usable.

The Qt Designer

In this article, we’ll be using Designer to design and create a simple Image Viewer application.

References: Qt Designer, The PyQt + Qt Designer Documentation

Image Viewer

Our Image Viewer application would be a very simple one, with options to Open an image file of major types (JPEG, PNG, GIF, etc.) and another to Quit. Upon opening of an image, we shall also set the status bar to show the dimensions of the image.

Designing the GUI

Open Qt Designer (‘designer’ command if on Linux) and choose File | New | “Main Window” under templates/forms expansion. This creates a new QMainWindow widget for us to work upon. The QMainWindow is basically a composition of a main-area widget, a menu-bar and a status-bar at the bottom, the very usual stuff an application consists of.

Design of the Image Viewer UI

From the Widget Box, drag a Label onto the main window’s area. Right-Click at any of the free space available on the same area, choose the “Lay out” sub-menu and then hit the “Lay out Horizontally” option. Designer will automatically stretch your Label across the area available this way. We need this layout (any layout will do here, actually) since we want the image to show in the entire window area.

Now on to menus, Add a File menu and under it add an Open and a Quit option, as shown below. To add these just click where it says “Type here” and get typing; Hit Enter/Return key to get to the next element in the menu after you’ve typed.

Under the Property Editor, select and set the Label’s text property to blank, and its alignment property to AlignHCenter and AlignVCenter. This completes our UI design in Qt Designer. But don’t quit already, do explore the other properties of the widgets used and figure out their possible uses; get used to the interface and available tools like Form Previews, etc.

The imageLabel (QLabel) object Properties

For instance, check out the properties like geometry (Height and Width), font, tooltip, etc. If you’re in a good reading mood, also checkout the amazing Style Sheet documentation in Qt Assistant, as it explains a lot about each Widget’s construct and how to go about customizing it till your heart’s content.

Finally, renaming the widget elements’ variables would be a good idea, since it will help us code our application in a much more readable manner. This is how I’ve named these widgets but feel free to follow whatever naming conventions you would like to use:

Image Viewer object names

Just double-click on the Object Name items and edit them in-line after that. Note and remember your QMainWindow class’s object name. Once you’re done, save the file as ‘ImageViewerUI.ui‘.

References: QLabel, QAction, QMenuBar, Layouts Guide

Using PyQt’s pyuic4 script

Our next step requires the use of the aforementioned pyuic4 tool. It’s usage syntax is as follows:

pyuic4 input_file.ui -o output_file.py
# Optionally takes -x parameter to make the generated code executable.

Thus we should run, for our UI file:

pyuic4 ImageViewerUI.ui -o ImageViewerUI.py

This will create a file ImageViewerUI.py that we can now use. Looking into the file will show you that its just a long list of widget constructs and of applying property settings. There is no need to edit this file, and is advised not to since pyuic4 will over-write all changes in it if you run it once again after some changes you wanted to do.

Whenever you edit your .ui files, make sure to run the pyuic4 tool to convert it into its Python equivalent (or to update existing Python code such that it reflects the new changes).

Additional info: Try `pyuic4 –help` for more fine-tuning options.

Running the basic GUI

Create a new file ImageViewer.py to finally add the application logic. Before we get to the code part, let me explain how the Qt’s subclass approach works. A Qt Designer file is inherited by the QMainWindow-derived class, and then the interface is setup using the setupUi() call with an instance. This creates all the objects/widgets for the interface as attributes of the derived QMainWindow class so that it’s ready to show. Next, we need to add the application-level logic to this derived class as normal methods. Since we have access to all the widgets used in the interface via our class, we can do as we like with their available features. The following diagram explains the hierarchy we ought to follow each time we need to implement a UI class for use:

Image Viewer Inheritance Diagram

Thus, a basic class that can be run would look like:

#!/usr/bin/python

from PyQt4 import QtGui, QtCore
import sys

# Import the interface class
import ImageViewerUI

class ImageViewer(QtGui.QMainWindow, ImageViewerUI.Ui_mainWindow):
    """ The second parent must be 'Ui_<obj. name of main widget class>'.
        If confusing, simply open up ImageViewer.py and get the class
        name used. I'd named mine as mainWindow, hence Ui_mainWindow. """

    def __init__(self, parent=None):
        super(ImageViewer, self).__init__(parent)
        # This is because Python does not automatically
        # call the parent's constructor.
        self.setupUi(self)
        # Pass this "self" for building widgets and
        # keeping a reference.

    def main(self):
        self.show()

if __name__=='__main__':
    app = QtGui.QApplication(sys.argv)
    imageViewer = ImageViewer()
    imageViewer.main()
    app.exec_()
    # This shows the interface we just created. No logic has been added, yet.

Run this class and you can see the window you just created.

Basic GUI of Image Viewer during Runtime

You MUST call self.setupUi(self) to make the UI file run the setup statements and build the GUI interface for use by our class.

References: QMainWindow

Adding Application Logic and other Code

Now to add the opening-an-image feature, let’s define a few methods in the class as:

#!/usr/bin/python
# -*- coding: utf-8 -*-

from PyQt4 import QtGui, QtCore
import sys

# Import the interface class
import ImageViewerUI

class ImageViewer(QtGui.QMainWindow, ImageViewerUI.Ui_mainWindow):
    """ The second parent must be Ui_<obj. name of main widget class>. \
      If confusing, simply open up ImageViewer.py and get the class \
      name used. I'd named mine as mainWindow and hence the use. """

    def __init__(self, parent=None):
        super(ImageViewer, self).__init__(parent)
        # This is because Python does not automatically
        # call the parent's constructor.
        self.setupUi(self)
        # Pass this "self" for building widgets and
        # keeping a reference.
        self.connectActions()

    def connectActions(self):
        self.actionQuit.triggered.connect(QtGui.qApp.quit)
        # Connect the Quit action's triggered signal
        # to a proper Quit method
        # given by qApp (which points to your QApplication
        # object).
        self.actionOpen.triggered.connect(self.openImage)
        # Connect the Open action's triggered signal
        # to load an image onto the image label.

    def openImage(self):
        # Lets get a user-provided file to open
        # using PyQt's QFileDialog class.
        fileName = QtGui.QFileDialog.getOpenFileName(
                        self,
                        "Open Image File",
                        QtCore.QDir.homePath(),
                        "Image Files (*.jpg *.jpeg *.gif *.png)"
                    )
        # Don't attempt to open if open dialog
        # was cancelled away.
        if fileName:
            self.imageLabel.setPixmap(QtGui.QPixmap(fileName))
            # Load the image file as a pixmap onto the
            # labelImage QLabel GUI object.

    def main(self):
        self.show()

if __name__=='__main__':
    app = QtGui.QApplication(sys.argv)
    imageViewer = ImageViewer()
    imageViewer.main()
    app.exec_()

Note the two new method additions connectActions() and openImage(). They complete the application logic that’s involved for our image viewing application example. Try to understand them better by seeing the PyQt classes used in them and referring them up in Qt Assistant for much more detailed information.

Now the application can open images via File | Open and can also be quit via File | Quit.

This is the final result of our work:

Image Viewer in Action

References: QPixmap, QFileDialog, qApp

Exercise

Try to build a simple text-based evaluator application that contains of two things:

• A text input box that allows for mathematical expressions input.
• An output label or text area (non-editable) for showing results of these expressions.

Classes you could use are QLabel, QLineEdit and QTextEdit. Another hint is to use Python’s ‘eval‘ function. As a bonus try to make the evaluation via Python safe.

• The QtCurve Style for KDE Applications
• The darkPearl QtCurve theme for QtCurve and its KDE Color Scheme

Having acquired those, I went on to install and select them via System Settings’s Appearance applet and all my Qt4+KDE4 applications looked neat in their dark avatars. Next I had to make Chromium reflect and respect the native theme settings and found an option for it to “Use GTK Theme” under Settings – Options – Personal Stuff.

However upon switching that on I realized that GTK themes were indeed showing the coloring of darkPearl right but not the widget styling that the darkPearl + QtCurve provide together, despite placing a proper QtCurve .gtkrc and its other known aliases at all key positions. Sometimes it’d work after doing the last action, but only for the current KDE session and it would all go back to simple-coloring hell post a re-logon.

The solution to this was apparently under System Settings’s Appearance – Colors applet itself. I’d missed an option under the Options tab of Colors that said “Apply color to non-KDE4 Applications“. Un-check this and the custom .gtkrc you place sticks like its supposed to. Chromium looks great now! So does GIMP, the second of the two GTK-using applications I use.

Violet was the UML modelling tool I had to use to save me some fun-later-time and make the whole process quick and painless. It also supports exporting to an image format and all in all it is a lovable, simple and just-works tool. But do note that it uses Java to do all that magic.

The other alternative I had was Umbrello which sadly isn’t in a very usable state yet. Perhaps this summer its GSoC fix may make it better. Wish I knew enough of QGraphicsView stuff to try it myself