This time I'm about to talk about lazy object, I called like that because they are more or less similar to what we use in lazy treeviews (In Gtk) where the Tree shows expanders but didn't load the child nodes until you expand the node). What I want to do is create objects and count them, but don't load any data until I need it.

Why would I need this?. Well. I'm currently writing a program for my employer, this program load a list of customers and shows how many accounts it has. As this accounts are kind of complex I create an object for them. This object is responsible for load/save the data for it, and any data you need is accessed via properties.

In my first approach, the object was loading the data as soon as the constructor was called, but sometimes I never access to any info in that object, remember, a customer may have many (and I mean really many) accounts, then why load all the data if there is a chance that I'll never use it?. Well, that is because there is a chance that I have to use that data.

Then how could I create the object and then load the data when somebody require it?. That may be easy, may not. :-). One approach is making use of python properties. Just create the object and when someone want to use a "value" from the object use the property to retrieve the data, process it and then return a value. A simple property may be defined like this:

I just create a class "demo" and the property "some_property", everytime you use this:

Python will call the method get_some_property allowing you to do your trick. But if you have an object with more and more properties is better to get all data at one time and then just use properties to return a piece of it. You could call a method on every property if the data container is empty but for me it is not the best.

What you could do, is get the data the first time you need it. But, how could I know when a property/variable is requested on my object?

Well, Python classes have several reserved methods, and one of them is __getattribute__. This method let you handle every request to any property/class variable in your object.

With this you can digg in your object to know if the container is empty, and if it is empty fill it with data before returning the property value :-).

Lets say that the demo object have a __data dictionary containing the data. and propeties look into it for the right value, it also have a reference to the storage layer called storage.

Pay attention that I used object.__getattribute__ instead self.property, if I use self.property will call self.__getattribute__ and will cause a recursion exception.

With this, we can create a great number of objects quickly and reducing the memory footprint.

This night I have been working on the Win32 build of christine. It seems to be working fine. This version is just a test, for those that wanted to use christine on Microsoft Windows.

Altough that I have made some tests on a clean Windows XP installation cannot guarantee that the Win32 will work on your computer.

Anyway, if you are brave enough, download the win32 binary and report any bug you found on it.

If you want to compile it, you will need this:

• Python 2.6 (I built Christine with it, but python >= 2.5 should work too)
• Gstreamer Winbuild (http://www.gstreamer-winbuild.ylatuya.es/doku.php)
• Microsoft Visual C++
• py2exe (http://py2exe.org/)

The build script is in win32resources/christine_setup.py, just copy it to the source root and run python christine_setup.py -q py2exe to build it.

You can download the win32 binary from here: http://downloads.sourceforge.net/project/christine/christine/0.6.0-pre1/Christine-0.06.00-pre1.exe

I forgot to mention that you have to install Microsoft Visual C++ 2008 redistributable in order to work.

This time I'm going to talk about putting an image as the application background in Gtk. In Gtk we are used to leave the colors of the application to the theme, but sometimes we will need to use an image as background. I already wrote how to draw a pixbuf in a gtk.DrawingArea (Esp), we could use that, but we will "draw" directly on the widget window instead.

Yes, I said the widget's window instead the widget itself. You should know that every widget that has been packed in a container has a gtk.gdk.window object and is the responsible for containing your widget. Well, we can draw on that object.

What we need is to create a simple gtk.gdk.Pixbuf and call the gtk.gdk.window.draw_pixbuf method using your widget.window object on the expose-event.

The code should look like this:

This time I'm going to write how to make the Nokia Internet Stick CS-10 work on Linux. Two years ago I wrote about the Franklin CDU-680 which was a very good way to get online, until 5 days ago when we stop paying 800 Mexican Pesos (about $59 USD) to Iusacell.

Anyway, in the office bought this pretty "Internet Stick", and with a small googling I found that it was possible to make it run on Linux. In some blogs I read that you just need to umount the device using "eject", This is because this stick identifies itself as a "CD-ROM" and when you use "eject" it changes its behaviour and start acting like a modem.

But I have one problem, when I insert this device in my computer's usb port dmesg shows errors while reading the device. Then, it never gets mounted (the first step for umounting it :-)) and then it can't change the way it worked.

Googling a bit more, I found that we can use udev to avoid this connect-wait_for_recognition-umount-dial procedure. You just need to create this rule in /etc/udev/rules.d/90-nokia-zerocd.rules

As you can see, it depends on a program "nokia-testcd", it is just a simple bash script with this code:

Finally!!!, Christine, my beloved media player is running on Windows, this is something that I really wanted to do for the next release. I had spend the last nights trying to compile it, first I tried to compile GStreamer, then I realized that there are binaries in the GStreamer WinBuilds project, with a little less work, I tried to compile Christine using cygwin, but it didn't worked. Then using the Python's distutils I compiled the C modules and I created a binary with Py2exe

There it is, running. I still have a lot of work to do, because Christine is written for UNIX and several technologies like Dbus are not in win32, although it seems to be in progress.

I'm running it on a virtual machine and I haven't tested if it really plays something, I'll give a try tomorrow.

For tonight I'm happy :-)

Trying to

Originally uploaded by markuz

Last night I was trying to compile christine on windows using cygwin, I didn't made it but I think I know why, I will try to make it work this tonight.

Christine playing videos

Originally uploaded by markuz

I was playing with gstreamer video sinks, I found that using cacasink and aasink you can play videos in ascii mode ;-) funny even when (for me) has no good use.

Christine without menu

Originally uploaded by markuz

This is christine without the menubar and the side bar. It look pretty clean don't you think?

Christine small mode

Originally uploaded by markuz

This is Christine in small mode (Ctrl+d).