This is just a simple example of a system that can be used to run presentations on Firefox. By utilising a combination of standards such as CSS, XBL, SVG and others, a javascript package transforms a web page into a dynamical screen presentation with lots of eye candy. By using a MozRepl the browser is able to transform formulas in TeX syntax on the fly scalable vector graphics!

If you should be interested in the content of this presentation, please have a look at the publications in the Physics section.

Sometimes, the precise coordinates of some markers from a Google Maps layer are to be obtained. One way is to look them up in the source code of the map generation. But the information should also be in the map after construction, right? For example, all the marker items on the map contain this information. The following brief script extracts the coordinates and the title of the markers and writes them into a plain text file in a new browser window.

 
  var out = '';
  var i   = 0;
  while ( x = document.getElementById( 'mtgt_unnamed_' + i ) )
    {
    out += ( [x.__marker__.C.x, x.__marker__.C.y, x.__marker__.ca.title] ).join( ', ' ) + "\n";
    i ++;
    }
  window.open( 'data:text/plain;charset=UTF-8,' + encodeURIComponent( out ) );
 

For ease of use, the whole script can be put into a bookmark. By clicking it, it will be executed on the currently shown page. So if interested, bookmark this link: GMaps point extractor.

If more information, such as content of popup windows, is needed, a script more specific to the implementation of the map generation has to be used.

Xournal is a great notebook application to be used on Tablet PCs. It allows for annotation of PDF documents, with the drawing/writing exported directly to the PDF. While there is vector-drawing on top, the underlying PDF is not changed (making use of PDFs updating mechanism), giving rise to a rather high quality result.

Sometimes it turns out to be inconvenient that one ends up with three files — the original PDF, the Xournal file, and the annotated PDF. Because the annotations are just stored as an update, the original PDF can always be recovered by removing the most recent update. Also, PDF allows for embedding files within the document. So in principle, a single file can be sufficient: it appears to be the fully annotated version as exported by Xournal to any PDF viewer. Additionally, the Xournal file is included which allows for editing those annotations after removing the Xournal's PDF attachments.

By making a little script out of this, annotating a PDF (and also editing an already annotated one) is as easy as

xournalpdf document.pdf

and only a single file has to be kept.

The script makes use of PDF::API2 along with PDF:API2::Names. By giving it a non-existent file name, an empty Xournal file is generated in contrast to PDF annotation. Passing an existent Xournal filename will start Xournal and embed the source in the resulting PDF.

What might be most interesting is the code to append some file attachment to a PDF: The Root-object is cloned and the name-tree of embedded files extended by an entry describing the Xournal file and also containing its encoded content.

sub append( $$$ )
  {
  my ( $pdfname, $filename, $description ) = ( shift, shift, shift );
  my $spdf = PDF::API2::Basic::PDF::File->open( $pdfname, 1 );
  $description = $filename unless $description;
 
  $spdf->{Root}->realise;
  $spdf->{Root} = $spdf->new_obj( $spdf->{Root} );
 
  if ( defined $spdf->{Root}->{Names} )
    {
    $spdf->{Root}->{Names}->realise;
    $spdf->{Root}->{Names} = $spdf->new_obj( $spdf->{Root}->{Names} );
    }
  else
    { $spdf->{Root}->{Names} = PDF::API2::Basic::PDF::Dict->new; }
  $spdf->{Root}->{Names}->{' parent'} = $spdf;
  bless $spdf->{Root}->{Names}, 'PDF::API2::Names';
 
  my $file = PDF::API2::Basic::PDF::Dict->new;
  @$file{'Type', ' streamfile', 'Filter'} = (
    PDFName( 'EmbeddedFile' ),
    $filename,
    PDFArray( PDFName( 'FlateDecode' ) )
  ); 
 
  my $descr = PDF::API2::Basic::PDF::Dict->new;
  @$descr{qw/Type F EF/} = (
    PDFName( 'Filespec' ),
    PDFStr( $filename ),
    PDF::API2::Basic::PDF::Dict->new
  );
  $descr->{EF}->{F} = $file;
 
  $spdf->{Root}->{Names}->set( 'EmbeddedFiles', $description, $descr );
  $spdf->new_obj( $descr );
  $spdf->new_obj( $file );
  $spdf->append_file;
  $spdf->release;
  }

Download: xournalpdf

Having tried all different kinds of combinations of PDF tools to simply merge files, I have been pretty disappointed. So I took the pdf-optimize.pl example from the great (but sparsely documented) PDF::API2 and wrote my own little version that has the following features:

• Links between merged files will be converted into internal links.
• The same is true for outlines that point to external files.
• Trees of outlines are merged rather than just concatenated.
• Further outlines to external files will be removed.

Links will be preserved also when using named destinations. However, other named object might become broken. For the files I encountered so far that was not a problem at all. Changing this as well should be straight-forward.

Download: pdf-merge-links.pl

Sometimes it appears to be useful to have more detailed knowledge of point data than just the plot of it – taking a ruler and measuring out coordinates of points within a diagram is simply not an option. If this plot is available in a suitable vector format such as PostScript, then it is in principle possible to read out the original data again (up to the accuracy of the plot itself).

In the case of diagrams generated with MATLAB, I can offer a little Perl-script to do this job. Appart from extracting the point sets (one CSV file is generated for each point set, PS point coordinates sit in the first two columns) it also tries to read the axes and offer a transformation from the PS coordinate system to the original one (column three and four, if available).

Keep in mind, that this is just a 15-minutes quick-and-dirty hack which works for the plots I was interested in. If you encounter any problems, write me a note. In principle, the same technique would also work for other programs such as gnuplot.

Download: matlab_extract.pl

In order to access Skype with shell scripts or Perl, I decided to use a single interface suitable for all possible uses: read/write from STDIN/STDOUT. This also allows for playing with the Skype API interactively by typing in the commands. Be careful not to enter empty lines – this may cause Skype to crash.

The program skype_dbus_client.c can be compiled with

gcc skype_dbus_client.c -o skype_dbus_client \
      `pkg-config --cflags --libs glib-2.0` \
      `pkg-config --cflags --libs dbus-glib-1`

Of course, libraries and headers of GLib and the GLib DBus bindings have to be installed.

/* skype_dbus_client.c: a simple command line client to Skype's DBus interface
                        read from STDIN and write to STDOUT */
 
#include <stdio.h>
#include <glib.h>
#include <stdlib.h>
#include <string.h>
 
#define DBUS_API_SUBJECT_TO_CHANGE
#include <dbus/dbus.h>
 
DBusConnection *connection;
 
/* iterate through DBus messages and print the string components */
static void print_iter( DBusMessageIter *iter )
  {
  do
    {
    int type = dbus_message_iter_get_arg_type( iter );
    const char *str;
 
    if ( type == DBUS_TYPE_INVALID ) break;
 
    switch ( type )
      {
      case DBUS_TYPE_STRING:          // it is a string message
        dbus_message_iter_get_basic( iter, &str );
        g_print( "%s\n", str );
        break;
 
      case DBUS_TYPE_VARIANT:          // another set of items
        {
        DBusMessageIter subiter;
 
        dbus_message_iter_recurse( iter, &subiter );
        print_iter( &subiter );
        break;
        }
 
      default:
        break;
      }
    }
  while ( dbus_message_iter_next( iter ) );
  }
 
/* the handler gets called if the DBus connection receives any data */
static DBusHandlerResult notify_handler( DBusConnection *bus, DBusMessage *msg, void *user_data )
  {
  DBusMessageIter iter;
  dbus_message_iter_init( msg, &iter );
  print_iter( &iter );
 
  return TRUE;
  }
 
/* send a string to skype */
void sendToSkype( char *msg )
  {
  DBusMessageIter iter;
  const int reply_timeout = -1;          // do not timeout -- block
  DBusMessage *reply;
  DBusMessage *message;
  DBusError error;
 
  dbus_error_init( &error );
  message = dbus_message_new_method_call(
    "com.Skype.API",
    "/com/Skype",
    "com.Skype.API",
    "Invoke"
  ); 
 
  if( !dbus_message_append_args( message, DBUS_TYPE_STRING, &msg, DBUS_TYPE_INVALID ) )
    {
    fprintf( stderr, "Error: reply is not except format\n" );
    exit( 1 );
    }
 
  reply = dbus_connection_send_with_reply_and_block( connection, message, reply_timeout, &error );
 
  if ( dbus_error_is_set( &error ) )
    {
    fprintf ( stderr, "Error: %s\n", error.message );
    dbus_error_free( &error );
    exit( 1 );
    }
 
  dbus_message_iter_init( reply, &iter );
  print_iter( &iter );
 
  if( dbus_error_is_set( &error ) )
    {
    fprintf( stderr, "Error: %s\n", error.message );
    dbus_error_free( &error );
    exit( 1 );
    }
  }
 
/* if the input is disconnected: exit the program */
gboolean hangup_handler( GIOChannel *source, GIOCondition condition, gpointer data )
  { exit( 0 ); }
 
/* input waiting: read and forward to skype */
gboolean input_handler( GIOChannel *source, GIOCondition condition, gpointer data )
  {
  char *b;
 
  g_io_channel_read_line( source, &b, NULL, NULL, NULL );
  if ( b == NULL ) { exit( 0 ); }
 
  sendToSkype( b );
  g_free( b );
 
  return TRUE;
  }
 
int main( int argc, char **argv )
  {
  DBusObjectPathVTable vtable;
  GMainLoop *loop;
  GIOChannel *in;
  DBusError error;
 
  dbus_error_init( &error );
  connection = dbus_bus_get( DBUS_BUS_SESSION, &error );
  if ( connection == NULL )
    {
    fprintf( stderr, "Failed to open connection to bus: %s\n", error.message );
    dbus_error_free( &error );
    exit( 1 );
    }
 
  loop = g_main_loop_new( NULL, FALSE );
 
  in = g_io_channel_unix_new( 0 );        // open STDIN for reading
  g_io_add_watch( in, G_IO_IN, input_handler, NULL );    // watch for input on STDIN
  g_io_add_watch( in, G_IO_HUP, hangup_handler, NULL );    // watch for hangup of STDIN
 
  dbus_connection_setup_with_g_main( connection, NULL );  // set up te DBus connection
 
  vtable.message_function = notify_handler;      // register handler for incoming data on DBus
  dbus_connection_register_object_path( connection, "/com/Skype/Client", &vtable, 0 );
 
  g_main_loop_run( loop );          // the main loop
 
  return 0;
  }

Ordnance Survey (the UK mapping agency) as well as IGN (the french pendant) opened their topographic maps to the public. The two services called OS OpenSpace and API Geoportail allow for integration of high-quality up-to-date topographic maps of the UK and France into private web-sites.

This integration is in both cases based on modified versions of OpenLayers which use an authenticated WMS layer (a registration key has to be used to validate the access from a specific location) as base images. Therefore it is quite easy to build special OS and GP layers to integrate these public services into standard OpenLayers projects.

For the OpenSpace layer have a look at an example of OS integration or OpenLayers sandbox.

I have implemented an IGN Geoportail layer for OpenLayers, to be downloaded here. At the moment only the maps for the french main land are included and no satellite photos. A new new layer is created by

var layer = new OpenLayers.Layer.Geoportail( "Geoportail Main Land", key );

where key contains the API key for the web page you want to access the API from. The key is transmitted on a regular basis to ensure that subsequent requests are all authenticated.

For the last years Sony stocks suffered a bit from the huge replacement calls for defect battery cells. Also Toshiba uses Sony cells for its laptop batteries. From time to time they renew the information on the website of the programme (US | Europe), appending additional models and serial numbers.

When one of my batteries (for the Portégé M400) decided not to stop loading and overheated a lot (I am glad that I was home), I discovered that this type of batteries for the M400 was actually affected as well.

Having read this on a US Toshiba site, bought from Toshiba UK and because I am residing in Germany at the moment, I had a lot of fun with three different support services on the phone:

• The US division confirmed that these batteries should be replaced and their program identified one of them to be affected. However, shipment to Europe was not possible, this is entirely the territory of Toshiba Europe.
• Although the european identification program did not recognise my batteries, that they are affected was confirmed by the UK support center. However – again – shipment to Germany can only be triggered by the german support.
• In dozens of calls and emails the German support service always told me the same: The batteries are not affected and will not be replaced.
• Finally, after quoting the statements of the other divisions in a new request, the German support center sent the batteries – without a further comment.

Just like with X11 sessions which can be suspended by using Xvfb and xmove, suspending terminal sessions without stopping the running processes is of interest when using interactive programs where scripting is not an option.

To setup the environment all that has to be done is to run

screen

When the programs are running, the session can be put into suspend (note, that the processes continue to run and the output is buffered) by hitting ctrl-a d.

To resume the session (which could be after closing the ssh connection and re-establishing it later) simply run

screen -r

x2x is a brilliant little remote control for X11. For example when you are working at different computers simultaneously it can make life much easier. Mouse and keyboard commands are sent to other xservers as well as it copies the clipboard. The standard X11 protocol is used, so the usual tricks and ssh tunnels work fine.

I have a shortcut on my laptop to “invite” the keyboard and mouse of my desktop at work. To avoid exposing the xserver, a bit of ssh tunneling is done:

ssh -f -n -X desktop.at.work
  'export DISPLAY=:0.0;ssh -n -f -X cap@`echo $SSH_CLIENT | cut -d" " -f1` x2x -west -to :1.0';
echo "connecting X server ..." |
  osd_cat -A right -s 2 -f -*-helvetica-bold-r-*-*-20-*-*-*-*-*-*-*

After that, the mouse pointer can leave the desktop screen on the left (west) and will enter the laptop screen on the right. Whichever screen the mouse is residing in will receive the keyboard events from the desktop keyboard. osd_cat is merely used to print a notification of what is happening on the display.