LateX users everywhere cheer.

Specifics are described in the pdf in the package. Using it on Ubuntu/Debian

apt-get install texlive-latex-recommended texlive-latex-recommended-doc
evince /usr/share/doc/texlive-doc/latex/float/float.pdf

Building the whole document might be a bit tricky, because of all the packages you may need.

Assuming you already installed TexLive on your system, you will further need to apt-get install:

• texlive-xetex
• ttf-droid
• latex-cjk-common
• latex-cjk-japanese-wadalab
• latex-cjk-xcjk
• latex-xft-fonts
• latex-fonts-recommended
• ttf-sazanami-gothic
• inkscape (for .svg to .pdf conversion)

Which should make it build. If not, please let me know.

Also, but completely unrelated

precise float placing

... they said it was impossible

Check out the float package. And it's H placement modifier. I'm already loving it!

There are two ways you can do this. The easy way is to write a few macros which create numbered bullets in the code and then use these numbers manually after the code to add your explanation. There are however problems with this approach; You need to manually keep the numbers in sync and thus it distracts you from focussing on the text.

This is not the way.

In you want your remark to be typed right away and remembered, so that later it can just be rendered. This means must somehow remember your text. This is what I came up with.

%% Code Remarks -- Miek Gieben
% define 2 commands
% \longremark[1] where you can say something about the code/whatever
% \showremarks - displays all remarks in a list after the code or where
%            you put the command
\usepackage{ifthen}
\usepackage{tikz}

Some counters we will be needing

\newcounter{coderemarks}
\setcounter{coderemarks}{1}
\newcounter{codevar}
\setcounter{codevar}{1}

And now the crux of the code. With \global and \def you define a global new command. This command has to be global otherwise it is only visible inside the environment where you defined it and you can not use it later on when the explanation is to be rendered. With csname codebox\the\value{coderemarks}\endcsname I generate a string for to interpret. The string will become something like codebox1 or codebox2. Those will be the names of the commands to are to be defined and hold the text.

The tikz stuff is a very nice picture environment which draws a black circle with a number rendered in white in it.

\newcommand{\longremark}[1]{%
\tikz\node[text=white,font=\sffamily\bfseries,inner sep=0.2mm,draw,circle,fill=black]{\arabic{coderemarks}};%
\global \expandafter\def \csname codebox\the\value{coderemarks}\endcsname{#1}%
\stepcounter{coderemarks}%
}

And now the code to display your remarks later on. Basically this is a while-loop that renders an item list. In the body of the loop the command names are also constructed in the same way as in \longremark, but now they are not defined, but called. The bullets used are drawn in the same way with \tikz.

\newcommand{\showremarks}{%
\begin{list}{%
\tikz\node[text=white,font=\sffamily\bfseries,inner sep=0.2mm,draw,
circle,fill=black]% 
{\arabic{codevar}};}{\setlength{\labelsep}{2.0\labelsep}}
\whiledo{\value{codevar} < \value{coderemarks}}{
\item \expandafter\csname codebox\the\value{codevar}\endcsname
\stepcounter{codevar}%
}
\end{list}
\setcounter{coderemarks}{1}%
\setcounter{codevar}{1}%
}

The usage of these commands in your code should be quite transparent. (I could turn this into a proper package -- and maybe something like this already exists — don't know).

The following is an example of how to use it. We define a code listing using the lstlisting package. At interesting spots in the listing we use \longremark and give our remark.

\begin{lstlisting}
type stack struct { |\longremark{\emph{stack} is not exported}|
i    int 
data [10]int  |\longremark{Meer gezeur wat in dit geval ook %
            djskdjkd sjd skjfk fjdkf jdkf jfk dfj d TODO %
            djskdjkd sjd skjfk fjdkf jdkf jfk dfj d TODO %
            \newline %
            djskdjkd sjd skjfk fjdkf jdkf jfk dfj d TODO %
over meerdere regels heen gaat, oh waar moet dat }|
}
\end{lstlisting}

And when we want to see our remarks we just give

\showremarks

to render it.

But for really nice looking output I wanted the following:

• Fonts in images/graphics should match the font of the main document
• TrueType fonts, instead of the standard TeX fonts. To avoid the "Heeh, that looks like a LaTeX document"-reactions;
• UTF-8 support and international character support;
• Easy integration of images (SVG based);
• Automatic building.

I'm using the following tools for this:

• Inkscape and pdfcrop for graphics generation;
• make for building;
• VI for editing (with syntax highlighting);
• evince as PDF viewer;
• xelatex for building the pdf.

General setup

As said earlier, I'm a fan of the memoir class as a replacement of the standard LaTeX classes. So I'm using it here again. When you are using xelatex (better UTF-8 support) you should also include the package xltxtra and xunicode.

Fonts

The package for TrueType font support is fontspec, to keep the math fonts working I had to include the package as \usepackage[cm-default]{fontspec}.

Note: fontspec mandates xelatex.

To use special characters I also found the pifont package. In my current working document I use the Liberation Fonts and Courier New:

\defaultfontfeatures{Scale=MatchLowercase}
\setmainfont[SmallCapsFont={* Caps}]{Liberation Serif}
\setsansfont{Liberation Sans}
\setmonofont[SmallCapsFont={Courier New}]{Courier New}
\fontsize{10}{10}

LaTeX will make TrueType fonts slightly larger than its core fonts, the Scale=MatchLowercase tries to remedy that.

Graphics

I'm using Inkspace to draw my graphics, an added bonus for using TrueType fonts in my LaTeX documents is that I can use the same fonts in the Inkspace drawings. So any text I add will be of the font Liberation Serif at 10 points.

Further more Inkscape has the nice feature that it can be used on the command line

$ inkscape --export-pdf=drawing.pdf drawing.svg

generates the pdf file. To make it fit in the document we need to crop the resulting pdf

$ pdfcrop drawing.pdf output.pdf && mv output.pdf drawing.pdf

And now we are left with a nice, cropped, pdf. See this link on how to include graphics in your LaTeX document, I just use:

\begin{figure}[h!b]
\includegraphics{drawing.pdf}
\caption{Fake caption line.}
\end{figure

Which will probably be extended somewhat to allow for cross references (search for \label and \ref).

Building

To help in the sometimes tedious building of LaTeX documents, I use make. For instance creating the pdf graphic files from the svg source files is done with the following Makefile:

pdfs := $(patsubst %.svg,%.pdf,$(wildcard *.svg))

%.pdf: %.svg
    inkscape --export-pdf=$@ $<
    pdfcrop $@ output.pdf && mv output.pdf $@

all: ${pdfs}

clean:  
    rm -f *.pdf

The only thing I need to do is to create a file with Inkscape, save it and run make.

For the document itself I'm using a similar, small Makefile.

.PHONY: fig

all:    fig go.pdf

go.pdf: go.tex go-setup.tex chapter*.tex ex*.tex src/*.go 
    xelatex go.tex && xelatex go.tex

fig:    fig/*.svg
    ( cd fig; make all )

clean:
    rm -f go.lol go.aux go.log map.log go.pdf
    ( cd fig; make clean )

Putting it all together

Next to the above Makefiles I have the following in the preamble:

\documentclass[a4paper,openany]{memoir}
\usepackage[cm-default]{fontspec}% provides font selecting commands
\usepackage{xunicode}% provides unicode character macros
\usepackage{xltxtra} % provides some fixes/extras
\usepackage[answerdelayed,lastexercise]{exercise}
\usepackage{pifont}
\usepackage{caption}
\usepackage{alltt}
\usepackage{url}
\usepackage{listings}
\usepackage{color}
\usepackage{graphicx}

\defaultfontfeatures{Scale=MatchLowercase}
\setmainfont[SmallCapsFont={* Caps}]{Liberation Serif}
\setsansfont{Liberation Sans}
\setmonofont[SmallCapsFont={Courier New}]{Courier New}
\fontsize{10}{10}
\graphicspath{{fig/}} % set default import pat

% among other \newcommands the follow environment for
% indented alltt (verbatim) text
\newenvironment{display}{%
  \def\FrameCommand{\hskip\parindent}%
  \MakeFramed {\advance\hsize-\width \FrameRestore}%
  \small
  \begin{alltt}
  }%
{\end{alltt}\endMakeFramed}

My master text go.tex used \input to include all other pieces of text, so there I have:

\chapter{Intro}
\input{chapter-intro.tex}

This keeps the main document file nice and clean and you can easily re-arrange entire chapters. After any significant change I just run make and view the resulting pdf file with evince, which is an awesome pdf viewer btw. It looks something like this:

The very-much-work-in-progress pdf can be seen here.

But there a some extra things that must be done before you can call yourself a complete librarian.

1. ID-ing the books you have
2. Storing the information
3. Marking the books
4. Sorting and shelving the books
5. Remembering who borrowed what

ID-ing books

For this I bought a barcode reader that reads the ISBN number of the book's backcover. With book_get (Perl code) I can retrieve the author, title, genre and year published from Google.

% book_get 9789024546497
Cryptonomicon
Neal Stephenson
none
2005
#Cryptonomicon‎by Neal Stephenson, Irene Ketman - 2005

Getting the genre right is a bit of a problem as Google will not always report the correct genre (or just slightly different, i.e. sometimes 'science' and sometimes 'computer science'). I solved this by explicitly asking for the genre in the next step.

Also the html returned is awful, so sometimes this script looses its way.

Storing the information

Getting the information is the first step, now it needs to be stored somewhere. In a SQLite database for instance. I've made a minimal database with only one table which holds all information: title, genre, author, isbn, and a few more items.

With book_sql (perl code) the information retrieved with book_get is normalized (correct the genre) and put into the SQLite db.

Marking the books

To help with this I needed a label writer to print the author, genre and title on a small label. Currently I am not confident enough to automate the printing of the labels so I manually query the database and feed the rows to labelfmt (Perl code). This little scripts uses LaTeX to format the labels and will print the resulting pdf on the labelwriter.

% sqlite3 biblio.db
sqlite> select * from books where title like '%crypto%';
146|9789024546497|Cryptonomicon|Neal Stephenson, Irene Ketman|science fiction|2005|1201339561|

Now I give this text to labelfmt and it will print the label

% ./labelfmt
146|9789024546497|Cryptonomicon|Neal Stephenson, Irene Ketman|science fiction|2005|1201339561|
....

And the labels gets printed:

Next you will needed:

• little pieces of thick paper/carton; this is where you sticker the labels on. Like this:

• little (120 x 120 mm) plastic triangles; which can be glued in each book, so that the book's label can be put inside.

And insert the label:

And another one is ready :-)

Sorting and storing

We decided to catalog our books based on genre. So I made a map to tell which genres are placed where. Sorta like

• COMPUTER - left shelve in the living room
• SCIENCE - middle shelve in the living room
• ... - somewhere else

So there you have it a full blown library setup for you books at home.

Borrowing

Now if somebody want to read one of our book it is simply a matter of: locating the book, getting the label out, writing the person's name on the label and storing the label in a safe place until the book is returned.

This last step could also be automated by using the barcode reader, but the desktop computer in our living room is not powered on 100% of the time. Booting the machine takes too long and makes it too cumbersome if someone just wants to borrow a book.

My labels are 36mm X 89 mm (Dymo part #99012) after some trial and error and four misprinted labels I came to the following LaTeX code which fits the text on the labels:

\documentclass{memoir}
\setstocksize{36mm}{89mm} %% dymo 99012 paper
\setlength{\headheight}{0mm}
\setlength{\headsep}{-28mm}
\setlength{\textwidth}{72mm} %% -17 mm
\setlength{\textheight}{28mm} %% -8 mm
\setlength{\oddsidemargin}{-16mm}
\setlength{\parindent}{0mm}

\begin{document}
...
\end{document}

For the actual text on the labels I use the following code (this should be placed at the dots (...) in the code above.

\sffamily
\textbf{My title}

\qquad The Author \\

\qquad\textbf{Genre} \\

ISBN: \textbf{9-785170-271955}\hfill2008

This LaTeX code is created by a little Perl script:

#!/usr/bin/perl
# labelfmt
# format bib db so that we can print labels
# gets standard sqlite text input:
# 663|9785170271955|Wat 3a Warom (russisch)|B. Barhep|computer|1998|1221413368|

use strict;
use warnings;
my $labelfile = "/tmp/label";

$_ = <>;  # only read one label at the time

my ($id, $i, $tit, $a, $g, $y) = split /\|/, $_;

# format the isbn number a bit
my @i = split //, $i;
local $"="";
$i = $i[0] . "-" . "@i[1..6]" . "-" . "@i[7..12]";

open TEX, ">", $labelfile . ".tex"; # yes, unsafe
select TEX;

print <<'EOF';
\documentclass{memoir}
\setstocksize{36mm}{89mm} %% dymo 99012 paper
\setlength{\headheight}{0mm}
\setlength{\headsep}{-28mm}
\setlength{\textwidth}{72mm} %% -6 mm
\setlength{\textheight}{28mm} %% -6 mm
\setlength{\oddsidemargin}{-16mm}
\setlength{\parindent}{0mm}

\begin{document}
\pagestyle{empty}
\sffamily
EOF

printf "\\textbf{%.30s}\n\n", $tit;
printf "\\qquad %.30s \\\\\n\n", $a;
printf "\\qquad\\textbf{%.30s} \\\\\n\n", uc $g;
printf "ISBN: \\textbf{%s}\\hfill%d\n", $i, $y;

print '\end{document}', "\n";
close TEX;

# now we make the pdf - after we clean up, the mess
if (system("pdflatex $labelfile") != 0) {
warn "Er ging iets falikant verkeerd";
} else {
unlink $labelfile . ".log", $labelfile . ".aux";
}

This will yield the following result

So I just wanted to share my "new" way of writing LaTeX docs.

First read the memoir class documentation. And the fontspec doc.

preamble

This now looks like

\documentclass{memoir}
\usepackage{eurosym}    %% for the EURO
\usepackage{fontspec}   
\usepackage{xltrxta}    %% \XeTeX if you need it

Usually this is hidden in one of my class files which implement a new look for a document. See the following articles for some examples

• atroff style
• blocksbook style

example

This is a small example on how to use XeTeX

\documentclass{article}
\usepackage{fontspec}
\begin{document}
Testing XeLaTeX!

\fontspec[Scale=0.9]{Trebuchet MS}
Something in trebuchet, but too large

\fontspec[Scale=MatchLowercase]{Trebuchet MS}
Size adjusted to the rest of the text!

\LaTeX rules

\rmfamily
\LaTeX in the normal font
\end{document}

Generate the pdf with

xelatex example.tex

xelatex is my new friend now :)

1. Read: How to use nice fonts in LaTeX

2. Install the software:

   sudo apt-get install texlive-xetex

   sudo apt-get install lcdf-typetools

   The latter one is needed for otfinfo to determine the font family name.

3. Read /usr/share/doc/texlive-doc/xetex/XeTeX-reference.pdf

4. Use xelatex to create the pdf of your LaTeX documents

If you get the following error install the package lmodern

 LaTeX Error: File `lmodern.sty' not found.

Finally I can use truetype fonts in my LaTeX documentation. Sweet!