Dominik Seichter's blog: KRename, KBarcode, PoDoFo

Directory Management with KRename

2011-02-06T02:12:00.000-08:00

Yesterday, I got a very interesting e-mail from Todd about using KRename. His request required one new feature which was added to KRename SVN and makes KRename even more powerful. So, I think his usecase is interesting enough to be shown here.

First of all, he has several files which he wants to sort into different directories based on parts of their names. If the filename contains the word "essay" it is supposed to go into a subdirectory called "essay/" and the same should be done for the memo's. His example list of files looks like this:


Work Essay for fred.txt
Work Essay for bob.odt
Work Essay for alice.doc
Work Memo for mary.odt
Work Memo for ben.txt
Work Memo for carey.doc

At the end, we want a directory and file structure like this:


Essay/Work Essay for fred.txt
Essay/Work Essay for bob.odt
Essay/Work Essay for alice.doc
Memo/Work Memo for mary.odt
Memo/Work Memo for ben.txt
Memo/Work Memo for carey.doc

You can create directories in KRename during renaming of files using the [dirsep] operator or by simply using a / (slash) in the template. So, the template newdir[dirsep]$ will create a new directory called newdir and move all files to this directory. The token $ is KRename' way of saying, "insert the original filename here".

Now, one can combine this feature with the powerful regular expressions. Just go to the "Search and Replace ..." dialog and enter the regular expression Work ([\w]+) for and replace it with \1[direp]Work \1 for. The backreference \1 inserts a matched string from the regular expression into the results. Thereby, we can include either "memo" or "essay" in the new directory name. The matched part is indicated by brackets in the regular expression.

To make this work, one new feature was added to KRename. The dialog contains a new checkbox which allows to enable processing of KRename tokens in the replacement string of find and replace. We need this feature to process the [dirsep] token correctly and create a new directory
See the screenshots below.

If you have similar interesting usecases for KRename or questions on how to do thinks, do not hesitate to write a mail to our mailinglist!

Modifying and analyzing colors in PDF files using podofocolor

2011-01-30T03:58:00.000-08:00

What is podofocolor?

Podofocolor is the newest addition to the podofo-tools package. It is a command-line tool to analyze and/or modify all colors in a PDF file. This can be done using predefined rules or based on a custom Lua script.

Basically, podofocolor opens a PDF file and goes through every page or vector graphics object (e.g. an XObject) and looks at every PDF command. Whenever it encounters a colorspace definition or a PDF command, which sets a color for a following PDF operation like “draw a line” or “fill area with color”, an action can be performed. These actions are either predefined actions or can be defined by implementing a C++ interface or more likely by providing a Lua script. Predefined actions are “convert this color to grayspace” or “print color name to stdout”; however more complicated actions can be easily created as well. As can be seen by the “grayscale”-action, the most powerful feature of the tool is to replace colors in a PDF file. Custom color conversion algorithms can be implemented in Lua and be immediately applied to any PDF file.

How is it useful?

There are different use-cases for such a tool and I assume users will come up with even more options. Possible usage scenarios that come to my mind can be categorized in two areas: analyzing colors and modifying colors.

Analyzing colors
- Find out, which colorspaces or colors are used in a PDF
- Verify that certain colors are not used in a PDF
- Verify that only CMYK or ICC-based colors are used in a PDF

Modifying colors
- Convert colorspace of a PDF (e.g. convert it to grayscale or CMYK)
- Convert colors in a PDF to certain corporate colors
- Split one PDF file into four different PDF files, where each file represents one component of the CMYK colors used in the PDF. As a result, you will receive one PDF containing only the cyan color channel, one containing the yellow one, etc..

Usage

The usage of the command-line tools is simple:


 ./podofocolor [converter] input.pdf output.pdf

Different values are possible to be used as a converter. The table below lists all converters which are currently available:

Converter		Description
dummy		This is an example implementation of a converter in C++, which will convert all colors in a PDF to RGB red.
grayscale		The grayscale converter changes all colors to its grayscale equivalents in a grayscale colorspace.
lua `planfile`		The Lua converter is the most powerful one. It takes a lua file as another parameter. This Lua file provides the color conversion descriptions implemented as Lua functions.

For example, to convert the colors in a PDF file using the included example.lua file, you would use the following command:


 ./podofocolor lua example.lua input.pdf output.pdf

Writing own converters

For the tool to be really useful, you will have to create your own converter. This can either be done by implementing the C++ interface IConverter or by creating a small and simple Lua script. If you consider creating a C++ implementation of the interface, the included Doxygen comments will be enough to get you started (Yes, it is that simple! For example, the grayscale converter consists of only 44 lines of source code and most other conversions will be the same size), so we will skip the C++ part and go straight to Lua.

Lua is a very simple, yet powerful, scripting language. To get started, it is best to download the example.lua file included in PoDoFo. It contains all the necessary function definitions, which you can adapt to your needs.

We will start with a short example: whenever podofocolor finds a definition of a stroking color on a PDF page (i.e. a color which is used when drawing lines or curves), it will call one function in the Lua script. The function called depends on the colorspace of the color definition. Currently, there are three different functions that can be called. set_stroking_color_gray will be called when a grayscale color is defined. Similarly, set_stroking_color_rgb or set_stroking_cmyk are called.
The example below shows an implementation of set_stroking_color_rgb with a rather simple implementation. The function gets the three parameters r, g, and b, which refer to the values of the red, green, and blue color components. The values are in the range of 0.0 to 1.0 as it is common in PDF files, where (0.0, 0.0, 0.0) is black and (1.0, 0.0, 0.0) is red. Now to the concrete function implementation: It checks if the passed color is black, if yes it returns a tuple with four values – which is a CMYK color – and thereby converts any occurrence of RGB black to CMYK black. For all other color values a tuple with three values is returned and the RGB color is not changed. Another option would have been to return a tuple with a single value and thereby convert the color to a gray value.


function set_stroking_color_rgb (r,g,b)
   -- convert all black rgb values to cmyk,
   -- leave other as they are
   if r == 0 and
      g == 0 and
      b == 0 then
      return { 0.0, 0.0, 0.0, 1.0 }
   else
      return { r,g,b }
   end
end

Other functions in the script provide information about pages, objects, etc...

Limitations

Currently this tool does not convert images embedded in the PDF file. First of all, the focus of the tools is on modifying colors in PDF files and secondly, there are other tools, which can modify colors in images and/or work with images embedded in PDF files. If there is demand for such a feature, it can be easily added. Podofoimgextract, another PoDoFo-tool, is a good example of how easy it is to work with images using the PoDoFo API.

Download

Podofocolor is currently available in SVN trunk. Instructions on how to get and build PoDoFo trunk can be found on our website. It works on all supported platforms, including Windows and Unix systems. We are interested in your feedback! Feel free to drop a mail containing your feedback, comments, or suggestions to our mailing-list podofo-users@lists.sourceforge.net.

New sort modes in KRename

2010-09-15T07:00:00.000-07:00

An often requested feature in KRename was to have more possibilities to sort the files before renaming. This was indeed a major limitation, as it is often eligible to sort files by date or some other criteria.

Some time ago, I found finally time to add sorting by date and today I finished a new powerful custom sorting feature, which allows to use any token to be used for sorting, which is supported by one of the plugins provided by KRename. This means sorting is now possible by almost any criteria, like [filesize], [creationdate], [user] or even [##tagTrack]. Of course, you can choose whether you want to sort ascending, descending or by numbers.

The screenshot below shows the new selection of sorting options in KRename.

If you click on "Custom...", you get a dialog like the one below, to specify what sorting criteria you want to use.

The final result might look like this, see the screenshot of Dolphin as a proof that we really sort by [filesize]:

This feature is currently only available in KRename SVN trunk. Still, I would be interested in your feedback.

KBarcode4-light released

2010-08-17T09:43:00.001-07:00

Where is KBarcode for KDE4? Well, there are porting efforts under way in SVN, but these are sadly far from completion.

If you just want to create barcodes easily and save them as image or a PDF, rescue might be near in the form of KBarcode4-light. KBarcode4-light is a simple barcode generator for KDE4. It supports many 1D and 2D barcode formats and can export them as images or PDF files.

It is similar to KBarcode for KDE3, but less powerful. KBarcode4-light allows only to create single barcodes. As the port for KBarcode is not yet ready and no one knows when it will be ready, KBarcode4-light provides basic barcode generation for KDE. An additional benefit is that it provides an easy to use interface for Barcode Writer in Pure Postscript.

It is written in Python using the amazing PyQt4 Qt bindings and based on Barcode Writer in Pure Postscript by Terry Burton.

KBarcode4-light downloads are available. It requires Python and PyQt bindings for Qt4, as well as Ghostscript in your PATH. Please submit any feedback to the KBarcode mailing list.

UPDATE: Due to a small bug, a new fixed version 0.2 is available for downloads.

podofocrop: PDF cropping in 10 lines of code

2010-08-07T07:53:00.000-07:00

The PoDoFo tools family got a new member during the last week: podofocrop. This little tool crops the white margins of pages in PDF files.

I use tools like these a lot, for example when writing scientific papers or the like, because I try to include all figures as PDF files to have better quality in the final PDF. To do so, it is often necessary to remove the margin around the figure before including it. This is exactly what podofocrop is doing.

The figure below illustrates what podofocrop is doing. Figure (a) shows the input PDF file, we can see a page with a little bit of text and a big white margin. In the next step, Figure (b), podofocrop calculates the bounding box for the final PDF, i.e. the area on the page that has content and the size to which we want to crop the PDF. Ghostscript is used for this step and has to be in your PATH. Finally, the PDF is cropped and the new page is much smaller without any disturbing margins.

If you are interested, get podofocrop from the PoDoFo SVN. In case of questions, please contact the mailing list.

Please note: Windows support is still experimental and untested so far. It will compile but there are no guarantees that it will work. Help with the Windows port would be greatly appreciated.

At the end, let we give you one little detail on the implementation, because it is so amazingly simple using PoDoFo. If you remove the code for parsing command line arguments, communication with Ghostscript and error handling, you see that the tool has only a few lines:


  std::vector cropBoxes = get_crop_boxes_from_gs( pszInput );
  PdfVariant var;
  PdfMemDocument doc;
  doc.Load( pszInput );

  for( int i=0;i  {
    PdfPage* pPage = doc.GetPage( i ); 
    cropBoxes[i].ToVariant( var );
    pPage->GetObject()->GetDictionary().AddKey( PdfName("MediaBox"), var );
  }

  doc.Write( pszOutput );

KRename post on SourceForge.net Blog

2010-07-21T04:00:00.000-07:00

The SourceForge.net Developers Blog has a nice little post about KRename.

Take a look!

Organising publications using KRename

2010-05-29T08:37:00.000-07:00

I have to work with lot's of scientific publications at the moment. That means, I have a large directory with many PDFs that are related to my work. Sometimes, it is cumbersome to find the right PDF or publication to look something up. Of course, I could rename every PDF after I downloaded it by hand, but - you might guess it - I am to lazy for this.

But help is in sight! I added a plugin to KRename, which can rename files based on meta-data included in PDF files. Organising a large set of publications is now a matter of adding the PDF files to KRename and using the template "[pdfAuthor] - [pdfTitle]". Convenient, isn't it? The screenshot below shows KRename while renaming a few PDF files.

The supported tags are [pdfPages] (number of pages), [pdfProducer], [pdfTitle], [pdfSubject], [pdfKeyword], [pdfCreator] and, [pdfAuthor]. If you have an idea for further meta-tags, do not hesitate to contact me. It should be quite easy to add more information, the current implementation is a matter of 10 lines thanks to the PoDoFo library used.

A pity is that many PDF authors do not add proper meta-data to their PDF files. So, if you are writing on a publication at the moment, please make sure you add your information to the PDF metatags.

This feature is currently only available in KRename SVN trunk.

PoDoFo Base 14 Font support

2010-04-29T15:33:00.000-07:00

Today has seen a major contribution to the PoDoFo PDF library.

I integrated a patch by Ian Curington and his developers, which brings support for using the base 14 fonts in PDF files. What are the base 14 fonts, you might ask?

Every PDF viewer has to ship with these 14 fonts, therefore one can achieve much smaller file sizes, as these particular 14 fonts do not have to be embedded into the PDF. Still, the PDF is displayed the same on every system (should be displayed ...), as every PDF viewer has the same font metrics for these fonts. Among the base 14 fonts are Helvetica, Times, Courier and Symbol.

This contribution makes the base 14 fonts available to everyone creating PDFs using PoDoFo. As the base 14 fonts are automatically used, whenever you request a PdfFont like Helvetica, this should result in much smaller file sizes for PDFs created with PoDoFo, which only use these fonts. An example which does also compare one of the base 14 fonts (Helvetica) to a TrueType font (Arial) is also provided. Okular has some problem displaying the symbol fonts, which I have yet to investigate.

If you would like to try the change, please grab the latest PoDoFo from SVN. The change is not included in the latest 0.8.0 release.

A web-radio plasmoid for your desktop

2010-04-06T12:32:00.000-07:00

Since I am in Limerick, Ireland, I started to listen quite a lot to RTÉ 2XM, which is a great web-radio station of the public broadcasting service in Ireland (Click for webstream).

RTÉ has a quite nice applet for the Windows Vista or Windows 7 sidebar. Unfortunately, the do not yet offer one for KDE and Plasma. Instead of waiting for the applet, I wrote a little web-radio applet by myself yesterday.

The plamoid has a simple list of radio stations and a play and a stop button. Easy, isn't it? Of course you can configure the list of stations. If you download and install it, it comes preconfigured with all the RTÉ stations and my favourite Austrian station FM4.

You can download the plasmoid from here: http://krename.sourceforge.net/data/plasmaradio-0.1.tar.gz.

To install the plasmoid, follow the following steps after downloading it:


tar xvfz plasmaradio-0.1.tar.gz
cd plasmaradio-0.1
mkdir build
cd build
cmake -DCMAKE_INSTALL_PREFIX=$KDEDIRS ..
make
make install

I would be happy to receive some feedback on this little piece of code. By the way, I think it really shows what great stuff can be done in so little time using the KDE4 API.

Detection of architecture violations in C/C++ applications

2010-02-24T09:09:00.000-08:00

In a small project, I am experimenting with a cleaner and in this case layered architecture for certain parts of PoDoFo. I think it is a quite usual problem, to have an architecture and a grown application and you would like to check whether the sources adhere to the previously defined architecture. Therefore, it is important to have tools to check for architecture violations. These can be used to validate the architecture at certain points of time or even after each commit to the source repository on a continuous integration server.

I did not know any tool which can easily do this kind of validations for C/C++ source code, so I came up with a small bash script that does exactly this. The only configuration needed are some rules that define the architecture. Architecture is in this case a layered architecture where certain modules are only allowed to include certain other modules. See image 1 for a small UML diagram of the architecture.

These rules can be edited at the top of the script:


RULES="content->structure  \
    content->datatype  \
    content->io \
    content->util \
    structure->datatype \
    structure->io \
    structure->util \
    datatype->io \
    datatype->util \
    io->util \
    content->fontconfig \
    content->Carbon \
    util->\.\. \
    src->.* \
    .*->tr1 \
    .*->sys"

As you can see, it is also possible to use regular expressions. Also, I had to add some rules for includes like fontconfig (external libraries) that are not available in the UML diagram above.

The script produces quite a lot of output, but grepping for "violation" shows only the important results:

If you are interested you can get the bash script from here: check_architecture.sh The script should be self-explaining and pretty easy to adapt to your needs.

Building KRename trunk from SVN

2010-02-14T06:31:00.000-08:00

I just noticed that there is no up to date documentation on how to build KRename trunk from SVN on our website. Well, everyone who is interested in getting the latest version of KRename and does not want to wait for the next release - these are the steps to get KRename trunk from SVN and build it.


svn co https://krename.svn.sourceforge.net/svnroot/krename/trunk krename
cd krename
mkdir build
cd build
cmake -DCMAKE_INSTALL_PREFIX=$KDEDIR ../
make
sudo make install

This assumes that $KDEDIR is an environment variable pointing to your KDE installation. You can set $KDEDIR using the following bash command:


export KDEDIR=/usr

Most other KDE applications can be built the same way.

Generic web-service queries on your desktop using Plasma

2010-02-06T07:02:00.000-08:00

Some days ago, I applied for a new passport. In Munich, where I currently live, you apply for the passport at the city hall and usually can pick the passport up there 3 weeks later. I was surprised to see that they have a new service: You get an ID number with which you can check the status of your passport via a web-service. So, if you check regularly, the web-service will tell you when your
passport is ready to pick it up.

What is the usual you do in cases like that? Of course, you write a Plasmoid that checks the web-service periodically and informs you when your passport is ready. This plasmoid - PersonalKwery - can be seen in screenshot 1.

Thinking further about this quick hack, I came to the conclusion that with only a little bit of work, I could create a generic plasmoid that can query webservices and display the result on your desktop. I managed to create a plasmoid that takes the following configuration:

Base URL of the web-service

Attributes to the URL (like the ID number of my passport, or arguments to a Google query)

An optional XSLT to transform the results

An interval, how often the query should be performed

With this little configuration you can easily query many web-services. Of course, most users won't be in the mood to create their own XSLT transformations! Therefore it is possible to store the configurations as XML and share them - for example over "get hot new stuff". In this case, users can
download predefined web-service queries and only have to enter a few necessary attribute values. The screenshot below shows the configuration dialog for a query:

Another small example is a simple query, that get's your current internet IP address.

Of course, the tool is not perfect yet and can be made more user friendly. If you are interested, you can get the tarball here: personalkwery-0.1.tar.gz.

"Modifiers" in KRename

2009-11-29T01:35:00.002-08:00

Andi Clemens did some amazing work on the batch renamer included and integrated into digiKam. I really like the simple UI and some of the features he included. I think I can get some inspiration from him for KRename (e.g. syntax highlighting).

Lately he posted over the topic of "Modifiers" in the digiKam rename tool, which he added to digiKams renamer and was not able to find in KRename. Modifiers are a way to convert a token, let's say the name of a directory or the artist of a mp3 in some way before inserting it. For example if you insert the name of the directory into the new filename and the directory name is in all uppercase and to match the look of the new filename, you want it to be inserted in lowercase. In digiKam's renamer it is achieved by the token:
[dir.]{lower}

In KRename you would use:
[%dirname.]

So contrary to Andi's post, KRename has modifiers, too. You can add a modifier before any token (after the opening bracket and before the actual name of the token). The modifierst are those used to insert filename's and convert there case. To list the most important ones:

$	No conversion, insert the token as it is
%	Convert to lowercase
&	Convert to uppercase
*	Convert every first letter in a word to uppercase
##	Format a number with leading zeros

So you can even use modifierst to format numbers for tokens that return number. For example [##tagTrack] will insert the track number of a MP3 formatted with one leading zero if the track number is less than 10.

It is true that KRename does not have a really readable syntax for modifiers here, I think appending {upper} or {lower} like digiKam does it, is a good idea. But there are several other places, too, where the KRename syntax could be improved. I hope that this post will help a few people that also did not know about this feature.

Modifiers in action

KRename on Windows

2008-11-11T10:47:00.001-08:00

Some time ago - during a longer trip by train - I booted the Windows XP installed on my Eee PC and tried to port KRename to Windows. Thanks to the efforts of the KDE on Windows team it was only a matter of about 1-2 hours.

You don't believe it? Well see the screenshots:

I am really impressed how easy it is to get KDE on Windows installed and start compiling using Visual Studio. The only changes necessary were related to some Unix syscalls in the Permissions and Date&Time plugin. To try KRename out, it is best to get a current snapshot from SVN (I justed checked in the changes necessary for compilation on Win32).
A pre-compiled binary can be found here. It requires a working installation of KDE 4.1 for Windows. Simply copy it to %KDEDIR%/bin and it should work. If there is interest I might try to provide a real setup for Windows or create more regularly SVN builds.

PoDoFoBrowser updates

2008-10-04T05:45:00.000-07:00

I had finally sometime to work on PoDoFoBrowser again.

Most notably, I added finally a hex widget so that binary streams can be viewed directly from within PoDoFoBrowser:

Credits for the QHexView widget goes to Evan Teran.

Other changes include an implementation for Find and Replace in text streams and a new Goto Page feature. Both will safe you a lot of time when you have to work with content streams.

To try the changes, get PoDoFoBrowser from SVN.

KRename Video

2008-02-26T12:28:00.000-08:00

Peter Upfold from fosswire.com has posted a great video on how to use KRename.

I think this video is great to show how KRename (or any other application) is working. I love the way he made the video: easy to understand and very well commented! Great work Peter!

You can find his article including the links to the video here. The video is available as flash for viewing online or as OGG for download.

Visualize dependencies of binaries and libraries on Linux

2008-02-21T07:21:00.000-08:00

Update2: pfee made some more fixes. The script parses now the dependcies tree correctly using readelf and ldd so that only direct dependencies apear in the graph. The updated version can also be found at dependencies.sh

Update: Thanks to the feedback from pfee, I made some fixes to the script. The script is now also available for direct download dependencies.sh

Sometimes it is useful to know the library dependencies of an application or a library on Linux (or Unix). Especially OpenSource applications depend on lot's of libraries which in turn depend on other libraries again. So it is not always quite clear which dependencies your software has.

Imagine you want to package up your software for a customer and need to know on which libraries your software depends. Usually you know which libraries were used during development, but what are the dependencies of these libraries? You have to package all dependencies so that the customer can use and/or install your software.

I created a bash-script which uses ldd to find the dependencies of a binary on Linux and Graphviz to create a dependency graph out of this information. Benedikt Hauptmann had the idea to show dependencies as a graph - so I cannot take credits for that. Using this script I created the depency graph of TFORMer, the report generator we are developing at TEC-IT. The result is a nice graph showing all the dependencies a user has to have installed before using TFORMer.

Another beautiful graph is the one of PoDoFo. See below the graph of PoDoFo.

The dependencies of Firefox are way more complex than the examples shown above...

If you want to create a graph of your favorite application or library your self, get the script from here. I pulished the simple source code below. Graphviz is the only requirement. Usage is very simple, just pass an application or library as first parameter and the output image as second argument. The script will always create a PNG image:


./dependencies.sh /usr/bin/emacs emacs.png
./dependencies.sh /usr/local/lib/libpodofo.so \
                  podofo.png

The code of the script is as follows: (Warning: the style sheet cuts of some lines, so better download the script from dependencies.sh)


#!/bin/bash
 
# This is the maximum depth to which dependencies are resolved
MAXDEPTH=14
 
# analyze a given file on its
# dependecies using ldd and write
# the results to a given temporary file
#
# Usage: analyze [OUTPUTFILE] [INPUTFILE]
function analyze
{
    local OUT=$1
    local IN=$2
    local NAME=$(basename $IN)
 
    for i in $LIST
    do
        if [ "$i" == "$NAME" ];
        then
            # This file was already parsed
            return
        fi
    done
    # Put the file in the list of all files
    LIST="$LIST $NAME"
 
    DEPTH=$[$DEPTH + 1]
    if [ $DEPTH -ge $MAXDEPTH ];
        then
        echo "MAXDEPTH of $MAXDEPTH reached at file $IN."
        echo "Continuing with next file..."
        return
    fi
 
    echo "Parsing file:              $IN"
 
    $READELF $IN &> $READELFTMPFILE
    ELFRET=$?
 
    if [ $ELFRET != 0 ];
        then
        echo "ERROR: ELF reader returned error code $RET"
        echo "ERROR:"
        cat $TMPFILE
        echo "Aborting..."
        rm $TMPFILE
        rm $READELFTMPFILE
        rm $LDDTMPFILE
        exit 1
    fi
 
    DEPENDENCIES=$(cat $READELFTMPFILE | grep NEEDED | awk '{if (substr($NF,1,1) == "[") print substr($NF, 2, length($NF) - 2); else print $NF}')
 
    for DEP in $DEPENDENCIES;
    do
        if [ -n "$DEP" ];
        then
 
            ldd $IN &> $LDDTMPFILE
            LDDRET=$?
 
            if [ $LDDRET != 0 ];
                then
                echo "ERROR: ldd returned error code $RET"
                echo "ERROR:"
                cat $TMPFILE
                echo "Aborting..."
                rm $TMPFILE
                rm $READELFTMPFILE
                rm $LDDTMPFILE
                exit 1
            fi
 
            DEPPATH=$(grep $DEP $LDDTMPFILE | awk '{print $3}')
            if [ -n "$DEPPATH" ];
            then
                echo -e "  \"$NAME\" -> \"$DEP\";" >> $OUT
                analyze $OUT $DEPPATH
            fi
        fi
    done
 
    DEPTH=$[$DEPTH - 1]
}
 
########################################
# main                                 #
########################################
 
if [ $# != 2 ];
    then
    echo "Usage:"
    echo "  $0 [filename] [outputimage]"
    echo ""
    echo "This tools analyses a shared library or an executable"
    echo "and generates a dependency graph as an image."
    echo ""
    echo "GraphViz must be installed for this tool to work."
    echo ""
    exit 1
fi
 
DEPTH=0
INPUT=$1
OUTPUT=$2
TMPFILE=$(mktemp -t)
LDDTMPFILE=$(mktemp -t)
READELFTMPFILE=$(mktemp -t)
LIST=""
 
if [ ! -e $INPUT ];
    then
    echo "ERROR: File not found: $INPUT"
    echo "Aborting..."
    exit 2
fi
 
# Use either readelf or dump
# Linux has readelf, Solaris has dump
READELF=$(type readelf 2> /dev/null)
if [ $? != 0 ]; then
  READELF=$(type dump 2> /dev/null)
  if [ $? != 0 ]; then
    echo Unable to find ELF reader
    exit 1
  fi
  READELF="dump -Lv"
else
  READELF="readelf -d"
fi
 
 
 
echo "Analyzing dependencies of: $INPUT"
echo "Creating output as:        $OUTPUT"
echo ""
 
echo "digraph DependencyTree {" > $TMPFILE
echo "  \"$(basename $INPUT)\" [shape=box];" >> $TMPFILE
analyze $TMPFILE "$INPUT"
echo "}" >> $TMPFILE
 
#cat $TMPFILE # output generated dotfile for debugging purposses
dot -Tpng $TMPFILE -o$OUTPUT
 
rm $LDDTMPFILE
rm $TMPFILE
 
exit 0

Encrypting PDF documents and setting document permissions

2007-08-14T05:21:00.001-07:00

Nowadays many applications are able to create PDF files. Most of them do not support advanced PDF features like encrypting PDF files or setting document permissions.

Document permissions are settings that configure what the user is allowed to do with a PDF file (let's say you can forbid the user to print the PDF file or to extract images from the PDF).

PoDoFo includes now a nice commandline utility in its SVN version (and in the next relase 0.6.0) called podofoencrypt.

podofoencrypt can be used to encrypt any existing PDF file and set document permissions on the file. You can select between weak rc4v1 encryption and strong rc4v2 encryption. An owner password has always to be set. The owner password is only used internally by PDF processing applications. The optional user password can be used if you want the user to have to enter a password before he can view the PDF in a user application.

Let's see a small example on howto use podofoencrypt to encrypt a PDF file with a user password which allows the user to print the PDF but not to extract text or images from it.


./podofoencrypt -o dominik -u user --print example.pdf output.pdf

A quick look at the document properties dialog in Adobe Reader shows that you are allowed to print the PDF but do nothing else with it.

I would like to get some feedback on the new encryption feature of PoDoFo and especially on the new podofoencrypt tool. So please get it from svn and try it out.

Dom

TFORMer 5.0.0 released

2007-07-04T11:31:00.000-07:00

Besides developing OpenSourceSoftware I do also work for TEC-IT Datenverarbeitung GmbH. Last week we finally released TFORMer 5.0.0. A cross platform, easy to use and very powerful report printing framework.

I worked over the last 3 years on this version and we all put a lot of work into this release. Most importantly, the source is completely portable over a broad range of platforms and architectures. The Linux version is relased for several RPM based distributions and as deb for Ubuntu. AIX, HPUX and Solaris builds are available on request. Please note that the same source is also compiled on Windows (from which we ported it to all these platforms).

TFORMer can print to PDF, PostScript and HTML files and of course to any system printer using CUPS. More output formats will be available with TFORMer 5.1 :) The PDF and PostScript output are really highquality and were the two projects you got me to learn both output formats.

I am proud of the quality of the Linux version. We ship with an easy to use installer, which installs either an RPM or a DEB. The software is installed, with documentation (PDF format and man page), several templates, demo reports, sample code for C and .Net and of course development libraries for C and C#. After the software has been installed and report is printed automatically (if the users agrees to do so) and everything works - I can't imagine reporting has ever been easier on Linux.

The C API is great and powerful, but the new .Net API is sexy! First of all, the wrapper is portable between Mono on Linux and .Net on Windows. We load the TFORMer.dll when run on Windows and we load libTFORMer.so on Linux when we are executed on Unix.

Have you ever created a PDF report so easy?


  // Create a TFORMer Job
  Job job = new Job();

  // Load a predefined form layout
  job.RepositoryName = "MyForm.tff"M

  // create an in-memory data-source
  DataSourceRecordSet datasource = new DataSourceRecordSet();

  // Set some datafields
  job.DataSource = datasource;
  Record record = new Record();
  record.Data.Add("Email", "support@tec-it.com");
  record.Data.Add("JobTitle", "Support Engineer");
  record.Data.Add("Name", "Mr. Harald Backoffice");
  datasource.Records.Add(record);

  // Set the output file name and type
  job.OutputName = "out.pdf";
  job.PrinterType = PrinterType.PdfFile;

  // Print 
  job.Print();

Easy - Ja??!

A free demo version is available (for Windows and several Linux versions). So give it a try.

The future of SchafKopf

2007-05-28T09:50:00.000-07:00

Someday SchafKopf has to be ported to KDE4. We all know that, but as of now, no one in the team has volunteered to do so (and no one else either).

One reason might be that we (Benni, Christian, Lenz and I) all agree that SchafKopf in its current state is not really maintainable. We hacked together a nice Card Game which is fun to play - but it is far away from the perfect Schafkopf implementation!

While driving home today, after I talked to Lenz over Schafkopf and Python I think it is time to start the discussion about what should be done with SchafKopf for KDE4.

My idea on how it should look - well this is most likely not even my idea but our idea that arose sometime - is the following.

We need a Schafkopf server process

Players can connect to this server

Human and AI players are implemented

The GUI connects to the server too

This has the following advantages. We can support different GUIs (Qt4, GTK, console and a web front end similar to all these online poker rooms - just for your favorite Bavarian card game). So we could write a simple Qt4 GUI (should go pretty fast because all logic is in the server) and have a KDE4 port.

The server can be implemented in another language than the GUI. As a reason we can choose a language that is maybe better suited for AI stuff than C++. My first idea was: Use Common Lisp! Two reasons: Firstly I wanted to learn Common Lisp and secondly it is famous for its usage in AI research. I even hacked together a small server in LISP. It understands the basic Schafkopf rules. You can look at the source if you want. It went pretty fast using Lisp, but it would need some work.

Well, talked to Lenz today and - even if he is a great Lisp fan - he thinks a server in Lisp has two big disadvantages:

Lisp is not very common on users systems. Users will have a hard time compiling SchafKopf

Only few developers know Common Lisp, so we won't get much code contributions

He suggested Python to be used for the server. Python is well known by many developers. We can code in a functional way where necessary, so we should be as fast as when developing in Lisp and python is available on almost every system.

What can I say? The guy in the black clothes is right! If we want to get a SchafKopf version for KDE4 with a clean source that is maintainable we should

write a SchafKopf server in Python

write a Qt4 GUI that connects to the server

Who wants to join me in this project? Any other ideas?

KRename4 - the porting has begun

2007-05-21T10:49:00.001-07:00

Porting KRename to KDE4 has started and slowly it is getting into shape. Porting is the wrong word though.... KRename4 will be a rewrite most parts. I think KDE4 is a good point to make a clean application out of KRename.

KRename 4 will....

... have the GUI created with designer instead of a hardcoded GUI
... be covered by unit tests: Unit tests are essential to make sure no regressions are introduced. Currently the testing framework is a hand written set of macros, but I might switch to Qt TestLib
... be good designed code: separation between GUI and renaming core
... have comments in the source where appropriate

All these changes will hopefully lead to a very clean KRename4. A KRename4 where others can easily contribute code! The first version will be a functional identical port of the current KDE3 version and the following version will include some nice features, mostlikely an optional JavaScript interpreter so that you can write custom functions for renaming files.

Above you can see how it currently looks, not very different from the KRename 3.0.14 and counters do not work at all.... but it's getting along.

If you want to give it a try get it from svn and compile it (requires KDE4 alpha installed and cmake):

svn co https://krename.svn.sourceforge.net/svnroot/krename/trunk krename
mkdir krename-build
cd krename-build

cmake ../krename
make

Here you go :)

domseichter's blog

2007-05-21T10:45:00.000-07:00

So ... I started a blog.

The reason is that I am currently porting KRename (a batch renamer for KDE) to KDE4 and it is going to become great. I want to give some status report here in my blog and hopefully I can show some nice stuff about KRename4 and KDE4 in general.

Additionally you will find here news on another project I am working on right now: PoDoFo. PoDoFo is a portable PDF generation and parsing library in C++. So if you are interested in PDF: check it out.