Cairo here, there, and everywhere

Welcome to the latest and greatest edition of Linux.Ars! We have some nifty stuff for you this week. I have cooked up a batch of tasty tidbits about Cairo, a cutting-edge vector art library for Linux. Command line wizard Kris Kowal will evoke the arcane art of perl scripting and bewitch you with his tome of Linux tips and tricks. Ian Smith-Heisters will give us the goods on MPD, an innovative, modular, digital audio player that supports a number of interfaces.

Linux.Ars is all about you, so don’t be afraid to get involved! Want to do a section for a future edition? Have a suggestion for a topic that you want us to write about? I would love some feedback. Feel free to send me comments, complaints, suggestions, requests, free hardware, death threats, or disparaging remarks about my assorted deficiencies.

Developer’s corner

Cairo here, there and everywhere

On August 13, Matthias Clasen announced the release of GTK 2.8, the first GTK release to render a majority of its interface widgets with Cairo, a powerful vector graphics library that provides support for features like antialiased shape rendering, alpha blending, gradient drawing, OpenGL acceleration via Glitz, and PDF output.

Cairo is valuable because it is portable, consistent, and comprehensive. It consolidates a lot of extremely useful functionality into a cohesive library that will enable developers to leverage the rendering power of modern hardware in their own applications. The availability of Cairo bindings for a number of popular programming languages makes it easy for developers to use Cairo in a wide variety of contexts.

In the past few months, Cairo has managed to sneak into a number of cutting-edge development projects. Mozilla hacker Robert O’Callahan managed to produce a Mozilla build that does all of its rendering with Cairo and Glitz. Although he has had a number of problems with text rendering and GTK integration, the project is a compelling illustration of Cairo’s power and versatility. Michael Meeks added experimental Cairo rendering support to OpenOffice. Seth Nickell of Red Hat posted some images of dynamically rendered GTK themes that utilize Cairo enhancements. In a blog entry about next generation Linux rendering technologies, he talks about the potential value of dynamic themes:

By writing algorithmic renders rather than fixed pixbuf based widgets, we can increase how dramatic the visual effects are without driving people nuts. For example, the tiger stripe buttons have proved very reasonable for long term use. However, any single rendering of a tiger stripe button would get old very quickly when repeated all over the screen ad nauseum.

You can take advantage of Cairo too! The Python bindings provide developers with an ideal environment in which to learn the API. The following example demonstrates a few of Cairo’s notable features:

import cairo, cairo.svg, math

class Canvas(cairo.Context):
  def __init__(self, fn, w, h):
    cairo.Context.__init__(self)
    self.set_target_png(fn, cairo.FORMAT_ARGB32, w, h)
    self.identity_matrix()
    self._pattern = self.pattern
    self.width, self.height = w, h

  def resetPattern(self):
    self.set_pattern(self._pattern)

# create a new file to draw the image to
f = open("test-1.png", "wb")
# create a new 400x400px canvas context
c = Canvas(f, 400, 400)

# create a gradient color pattern
p = cairo.Pattern(0.0, 0.0, 0, c.height)
p.add_color_stop(1,0,0,0,1)
p.add_color_stop(0,1,1,1,1)

# draw the background rectangle
c.rectangle(0,0,400,400);
# make the gradient the active pattern
c.set_pattern(p)
# fill the rectangle with the gradient
c.fill()

# create an SVG rendering context
svg = cairo.svg.Context()
# load an svg image from a file
svg.parse("penguin.svg")
# render the svg image to the canvas
svg.render(c)

# reset the pattern to the default
c.resetPattern();
# set the default line width to 15px
c.set_line_width(15)

# move to the position where the triangle starts
c.move_to(200, 100)
# draw the line on the right side of the triangle
c.line_to(300, 300)
# draw the bottom line of the triangle
c.rel_line_to(-200, 0)
# draw the line on the left side of the triangle
c.close_path()
# render the trinagle to the canvas
c.stroke()

# set the default font and font size for the canvas
c.select_font("Sans"); c.scale_font(80)
# move to the place where the text should be drawn
c.move_to(100,100)
# render text at the current position
c.show_text("test")

# set the current pattern to render with 50% opacity
c.set_alpha(0.5)
# set the current pattern color to red
c.set_rgb_color(1,0,0)
# draw a circle of the given size at the given position
c.arc(150, 100, 80, 0, 2 * math.pi)
# render the circle to the canvas
c.fill()

# set the current pattern color to green
c.set_rgb_color(0,1,0)
# draw another circle
c.arc(250,250,40, 0, 2*math.pi)
# render the circle to the canvas
c.fill()

# set the current pattern to render with 60% opacity
c.set_alpha(.60)
# create angled gradient
p = cairo.Pattern(0.0, 0.0, 350, 80)
# add the gradient color stops
p.add_color_stop(1,1,0,0,1); p.add_color_stop(0,0,1,0,1)

# render some text with the gradient pattern
c.set_pattern(p); c.move_to(100,200); c.show_text("blah"); c.stroke()

# render the whole image to the file
c.show_page()

Tools, Tips, and Tricks

Command line wizardry

Astounding and numerous are the parallels between shell hacking and wizardry. It seems, wizard’s day-to-day affairs are studying, practicing, and creating spells. When need arises, they may with a snap of their finger set a cascade of commands in motion, albeit the winged monkeys to take out the garbage, or the Gnomebots to harass unwelcome solicitors at the gate. Just so are the affairs of a shell hacker; the measure of their powers are in their study, creation, and creative application of scripts. Here follows an account of my personal tome.

The wizard Vetch declares in Ursula LeGuin’s A Wizard of Earthsea, “Every land has its own powers, and the farther one goes…, the less one can guess about those powers.” To ensure that their prowess is undiminished on a remote system, a good shell wizard studies the standard tools. The strongest wizards have wandered lost when they teleported to a system far from their familiar tilde. Fortunately, we can count on a few, good tricks.

The first chapter of my tome is entitled cat. The tool itself is entirely unimpressive. The command “concatenates” the files given as arguments. So, cat foo bar would output the content of a file foo followed immediately by the lines of bar. However, Wizards seldom use cat for such a task. cat is a versatile tool for gluing pipelines in visual order. I typically use cat to introduce a file at the beginning of a pipeline.

cat foo | sort > bar

Explicitly typing out cat is a stylistic preference. In Bash (and possibly other shells), an < can be used in place of cat:

< foo sort > bar

Many innocent magi have been lost to illness when they tried to pump salt water from a bucket, through a filter, back into the bucket. This doesn’t work much better with redirection than it does with water. For example, the command, cat foo | sort > foo, nor its catless equivalent, sort < foo > foo, work. The trouble with both of these commands is that the shell immediately opens foo for write with nothing inside, so that the initial contents of foo are lots, never to be read by sort. This fails silently. Oops. This wizard’s solution to this problem was to add a tome to my library. I created a script called dog which for all purposes is the exact opposite of cat. Rather than write a file’s content to the pipeline, dog reads from the pipeline into a file. However, unlike a redirect, this script reads the entirety of the pipeline before writing the file. A wizard armed with this script can execute the following…spell:

cat foo | sort | dog foo

dog

#!/usr/bin/env perl
my @buffer = <STDIN>;
open STDOUT, '>', shift or die;
print @buffer;

I was initially remiss that Linux nor Unix supplied me a reverse command. Then an older wizard pointed out an irony. GNU/Linux, provides a tac command. tac is a reversal of the letters of the command cat and analogously reverses the lines of a given file.

cat foo | tac | dog foo

I have not decided whether I believe that the humor is worth the confusion. Of course, this leaves open the philosophical question of whether god is the opposite of dog or tac. Pilgrim wizards need be wary; tac is not inherently available on Solaris.

find, contrary to any impression rendered by its name, is not a search engine. find accommodates for the weaknesses of ls by providing lists of files that match a variety of criteria in a deeply nested directory structure. So, to ‘find’ all of the HTML files in your current directory, you would use the following command:

find . -name '*.html'

The quotes around *.html prevent the shell from expanding it to a list of all the HTML files in the current directory.

xargs is a handy tool that lets you perform a command with all the terms from an input stream transformed to arguments. For example, the following command deletes all HTML files.

find . -name '*.html' | xargs rm -f

xargs also accepts a -l or numbered arguments to tell it how many lines should be used at once each time it invokes the command in the argument. This is handy for commands that only accept one argument at a time, like a command line music player.

There is a weakness to xargs. If the input is a list of files as supplied by find, those files may contain spaces. If these files were supplied literally to the command line, the thorough wizard would need to bind them in quotes. My arcanum of spells includes a Python script, enquote. So, for reliable html file deletion, the intrepid wizard commands:

find . -name '*.html' | enquote | xargs rm -f

enquote

#!/usr/bin/env python
import sys
for line in sys.stdin:
			print '"%s"' % line.replace('"', '\"')

I use a lot of lists to manage in Linux and Solaris. One prime example of such a list is my ~/.ssh/known_hosts file, which contains the names of all the systems I log into, delimited by commas and spaces. It is handy to be able to log into each of these machines in rapid succession to discover how long each of them has run since its last boot, for example. cut is a script that lets you pry a single column out of a table. cut accepts arguments for how the columns are delimited, and which field number you would like to extract. So, this command reveals all of the hosts I log into.

cat ~/.ssh/known_hosts | cut -d' ' -f1 | cut -d, -f1

Appending this will give me the uptimes of each machine

... | while read host; do echo $host;

			  ssh $host uptime; echo; done

Sometimes I brew my own files with lists of hosts, user names, and numbers. Since I enjoy documenting these files with comments and empty lines for emphasis, I keep an uncomment script in my arsenal. In this case, I use sed, the stream editor. This script permits me to dump the uncluttered data of foo to a stream. This sends a short email to all my fellow wizards.

cat foo | uncomment | sort | while read

			  friend; do echo "Hi" | mail -s "Hi" $friend; done

foo

# Fellow Wizards

kkowal # that's me
rpaul
rwitt

uncomment

#!/bin/sed -f
s/^W*#.*|#.*$//g
/^W*$/d

Of course, the most wizened of wizards reach a point in their career where most of the books in their library are volumes of their own notes. Here are a few of mine.

and allows me to filter a stream for only the entries that exist in another file. For example, if I happened to be removing the accounts for unwelcome users on a system, I would need to find out which ones still have accounts. I would do this by extracting all the user names from the accounts listed in the system password file, and comparing them to a list of unwelcome users.

cat /etc/passwd | cut -d: -f1 | and unwelcome-users |

			  dog delete-these-users

and

#!/usr/bin/env perl
open FILE, shift or die;
my @b = ;
open STDIN, shift;
while (my $a = <>) {
			if (grep {$a eq $_} @b) {
							print;
			}
}

not allows me to filter a stream for those that do not occur in another file. This is handy for making sure that I don’t delete accounts for my fellow administrators.

cat delete-these-users | not admin-users |

			  dog delete-these-users

not

#!/usr/bin/env perl
open FILE, shift or die;
my @b = <FILE>;
open STDIN, shift;
while (my $a = <>) {
			if (!grep {$a eq $_} @b) {
							print;
			}
}

A wizard’s library is a personal place, filled with dusty tomes accumulated over long years spanning their growth and style. We all have uniq solutions to these problems, many of which are interesting, possibly convoluted, and each exciting in their own right. Each wizard builds their own tower; I hope my craft inspires yours as so many have inspired mine.

Cool App of the Week

MPD: my milkshake music player brings all the boys to the yard

MPD takes a refreshing look at how a music player should work. By decoupling the player from the interface, a great degree of flexibility is afforded, which is largely unavailable in other music players. (One notable exception is the not-yet-released XMMS2.) MPD’s client-server model provides the ability to remotely manage your music and to choose from a bevy of user interfaces.

The basic MPD installation is to XMMS, what XMMS is to RealPlayer: lean and mean. This efficiency and elegance may only appeal to geeks, but, well, if you’re reading Linux.Ars, survey says: you’re probably a geek. In the true spirit of hardcore Linux, MPD doesn’t have a preferences wizard asking where your music is kept, just a lonely configuration file in your home directory. The conf file is well documented and easy to work with. You tell it where your music files are, set your audio output device, and you’re good to go.

During the audio output configuration process I noticed that there doesn’t appear to be support for any audio daemons, which kind of flies in the face of MPD’s modularity. However, looking at the wiki reveals that there is the possibility of outputting to daemons like ESD and Polypaudio, but not Jack. From the readily available resources, there doesn’t appear to be any IO plugin architecture like XMMS has, which probably makes third-party development more difficult, and results in fewer features.

Anyway. So now you have MPD installed and configured. When you first run it, it sifts through your music directory looking for songs it can play and creates a database of the files. Currently it plays MP3, Ogg, MP4, AAC, FLAC, wav, and musepack (.mpc), though some of those may require custom compilation. The database creation doesn’t take too long; much less time than Rhythmbox did when I tried it a while back. Once done creating the database, MPD is running as a daemon. Unless you want to manually send it commands over tcp/ip, you’ll need to get a client to control it.

The ability to use separate clients is what MPD was really created for. The most basic client, mpc, lets you play tracks by using commands like mpc search artist Oval | mpc add, which would search for every track by Oval and add it to the playlist. A simple mpc play gets the party bumping. If you’re looking for some real GUI smoovness you can use ncmpc, which is an N-Curses interface. For those that want a more-than ASCII interface (though I can’t fathom why) there is a range X based clients for Gnome, KDE, and others.

Any of these clients can be configured to access an MPD process anywhere on the web, as well as at home-sweet-localhost. You can even install Apache and a PHP based client to allow anyone browsing the web to control MPD. This opens up possibilities for all sorts of hijinks with Croatian hackers controlling your listening pleasure. More interestingly, it opens up possibilities for a central home media server. You can load MPD on a headless cheapo-rig, attach it to your stereo system, and control it from your PDA in the bathroom. Just what you’ve always needed!