Minimalia

I wanted to try Skia, the 2D graphic library from Google. The problem is: there's still no mature build script for linux and the samples are not compiled at all. So I patched some sources and wrote a simple build script for Waf, which in the end will build the skia library (as shared object) and the demo executable.

What is Waf? It is a python based framework that allows you to write "configure" like scripts, without the hassle of learning autotools and m4. I will show you the basics and what it takes to write from scratch a project build script. I assume you will be using Ubuntu 9.04.

So, first off: check out the skia sources, using the following command:

svn checkout http://skia.googlecode.com/svn/trunk/ skia-read-only -r 501

The revision 501 (on which I generated my patch file) will be downloaded.

Next, download this patch: skia.patch.gz and save somewhere on your system. It contains the modifications (hacks, actually) I did to have the demo compiled. After that, enter the directory skia-read-only and issue the command

zcat /path/to/skia.patch.gz | patch -p1

The patches will be applied and the waf build script, wscript, will be added. Open it and take a look. It starts like this:

Well, I just defined few lists. The first three: ports, opts and xml are the files I would like to be compiled in addition to all the other files sitting in few other subdirectories. With waf several approachs are possible: you can list all of your files to compile, or you can specify just the directories and let waf pick all the sources, or you can mix and match (as I did). Or you can put a wscript in each sub dir and create a hierarchy of wscript files, each one taking care of one piece of the build. This is what I like of waf: it does not enforce you doing only in a certain way - supposedly for your own sake - but let you decide. You may make a mess but we are adults and we don't like the maven approach. But I digress... So, take a look at the second part of the script:

In waf if you want to check for libraries, tools, headers and so, you define a function called configure. It takes one parameter, which is a sort of context constructed by waf, exposing some functions. You call them to have waf doing the checks for you. For example, at line 4, I check if the c++ compiler is installed. At line 7, I check for the freetype library writing

conf.check_cfg(package='freetype2',
               atleast_version='6.3',
               args='--cflags --libs',
               uselib_store='freetype',
               mandatory=1)

The check_cfg checks the libraries using the pkg-config tool, so basically it instructs waf to look into the PKG_CONFIG_PATH list of directories, searching in this case for freetype2.pc. Waf will check the version of the library to see if it equal or greater than 6.3. It stores the values for --cflags and --libs in the waf cache under the key 'freetype' (the key will allow you to reference the library somewhere else in the script) and, finally, waf will abort if the library is not found, because I've marked it as mandatory.

In the same way I check for other libraries at the lines 10, 13, 16. At line 19 and 22 I don't use the check_cfg but simply check because the libraries gif and jpeg are not shipped with a pkg-config file. Finally, at line 25 I just set up the compilation flags for both the skia and the executable. There are other ways to do so, and you can check the waf manual and its samples if you're curious.

For the build phase we have to define the function build. As for the configure fuction, the parameter passed by waf is the context. Now, in this function you should declare how your targets should be built. To do so you have to create a task generator. The task generator is able to generate the task (d'oh!) that will be performed by waf. In creating the task generator, you can specify everything about your target. Let's take a look

At line 6 I create the task generator using the shortcut offered by the context (in this case named bld). At line 7 I set the task generator to generate the target as shared library (cshlib) using c++ compiler to build it (cxx). At line 8 I want the library to be called "skia". At line 9 I specify the defines to use, in this case I use the list "defines" declared previously. At line 10 I set up the list of include dirs and at line 11 I instruct waf to export the same includes list. At line 12 I simply list the prerequisite libraries needed by skia. In listing the prerequisite I just use the keys chosen in the configure phase. The task generator is still not completed. At line 15 I set the generator to look into a set of directories for the sources. At line 18-21 I removed certain files from the set of sources. Finally, at line 24, 27, 30 I add other sources file to the list. Well, that's all. The generator will create a task able to compile the library.

For the demo executable, also within the build fuction, I create another task generator:

It works more or less like the first generator. At line 7 I use the uselib_local instead of uselib because skia is generated by the same script and not found on the system as external dependency. Again, I add all the sources found in the samplecode directory and then I adjust the list cherry-picking and removing few more files.

Time to run the script

To run the script you need the waf engine, which is a singular file named waf you have to store in your project directory. So, let's grab waf here

http://waf.googlecode.com/files/waf-1.5.11.tar.bz2

Explode the tar somewhere and fire the ./configure script. If all goes well the waf script is generated. So, copy it into the skia-read-only directory.

Now we are ready to configure and compile skia! Enter the skia-read-only dir and issue the command

./waf configure

The project will be configured. Probably you will get some warnings due to the missing requirements. Here's the command to install them in one shot:

sudo apt-get install libgl1-mesa-dev libfreetype6-dev libsdl1.2-dev libpng12-dev libgif-dev libjpeg62-dev ttf-mscorefonts-installer

Now, again ./waf configure and this time you should get something like that:

Time to compile skia library and the demo application. You just issue the following command

./waf

If you want, you can specify the number of parallel jobs to spawn. And you can enable the progress bar too:

./waf -j3 -p

You will see the compilation process rolling out.

If all goes well you will find in skia-read-only/build/default the libskia.so shared library and the demo executable.

To run the demo application, first set

export LD_LIBRARY_PATH=/path/to/skia-read-only/build/default


Then run the demo. Once it started you can switch from a view to the other using the right-arrow. Hereafter some samples

Some demos don't work perfectly, like the ones that should show a picture. The pictures are not there and the paths are hardcoded. But you can hack your way around and do some experiments. Enjoy!

This is the sixth part of the tutorial Cover letter with style. You can find the fifth part here.

In this part I will show you how to add a barcode in the destination address. It's a kind of nerdy, but it will serve to illustrate how to do graphics stuff easily with XeLaTex. For the purpose, you have to install pstricks and let Xe(La)Tex know about it.

Installing pstricks is very easy on ubuntu: just open a terminal and issue the command:

sudo apt-get install texlive-pstricks

Then, we need to inform Xe(La)Tex where to find the pstricks configuration file for the xdvipdfmx driver (this is the driver XeLaTex uses to output your pdf). To do so, first create a couple of directories

mkdir -p /usr/share/texmf-texlive/tex/xetex/xetex-pstricks/
mkdir -p /usr/share/texmf-texlive/tex/xelatex/xetex-pstricks/

Then you need to copy this pstricks.con file in those directories. You need also to copy this xdvipdfmx.con file in

/usr/share/texmf-texlive/tex/generic/pstricks

To finish, run

sudo texhash

All this, to have graphics in your pdf's in just one go, through XeLaTex. For those who are not fully aware of the problem, I just saved you from this mess:

Consider also that the above instructions are done once for all. After this setup, we are ready to use pstricks packages.

So, for drawing a barcode we can use pst-barcode. It is pretty easy to use and its documentation says it all.

This time, instead of changing the template file (standard.lco, remember?) I will change the letter itself, because the destination address is in there. So here it is the letter with the barcode added

At line 3 I import the package and at line 11 I specify a royalmail barcode, coding the number 1234567 (just an example). If you typeset the document, you will obtain this

Cool, isnt' it? Further, we can adjust the barcode position, specifing the optional parameters, transx and transy

\psbarcode[transy=-0.2cm,transx=0.1cm]{1234567}{}{royalmail}

The result now is

The entire cover letter, finally, appears like that

Well, it was a long journey but now we got a stylish cover letter to show off. I hope you like it.

I am still not done! I have to show one thing more: an alternative template you can use to completely change the look and feel of your cover letter. Keeping the template separated from the content permits us to easily swap style as changing one line only.

First of all, I will provide you a new template.

I won't explain the details. Moreover, this template was not created by me: I just copied (and somewhat simplified) the template shown in this document [Replacing LATEX2# standard classes with KOMA-Script by Yuri Robbers, Markus Kohm and Rasmus Pank Roulund].

Save the above template in alternate.lco file. Also, check the line 22, where the name of your logo should be specified. Now take your cover letter and in the first line specifiy you want to use this alternative template, like this

That's all. I just changed the first line, instructing KOMA-Script to load the alternate file (no need to specify the .lco extension). If you typeset the document, your cover letter now will look like this

Mind that the logo was not the one I used in the previous part. I edited it to have the outlines in stronger colors (it has to be in the foreground, this time)

So, I hope you enjoyed the tutorial. And I hope you can sport those cover letters in the next job application; maybe they will give you more points, who knows....

See you in seven years

This is the fifth part of the tutorial Cover letter with style. You can find the fourth part here.

In this part I will show you how to add your logo as a watermark to your cover letter¹

Ok, ready to go. Well...almost: you need a logo. For this time, I will provide one (Save link as...) so you can proceed with the tutorial. It is a simple vectorial image, edited with Inkscape. If you don't have Inkscape installed, you already know what to do:

sudo apt-get install inkscape

Actually, if you are able to, I suggest to compile and install Inkscape from the svn sources, but it is not mandatory.

Another thing you need is to install a couple of fonts in a way the logo will look like as I designed. The fonts are: Diavlo and Fontin. Designed by Jos Buivenga, they are free to use. I already explained how to install new fonts in linux, so I won't bother you further.

Once the fonts and Inkscape are installed, grab the svg sample logo I made for you. Launch Inkscape, open the file and customize a little bit. For example, you could select the name

replace it and then adjust the its displacement with ALT+(arrows up/down/left/right) which are the keys to adjust the font tracking and kerning in Inkscape. There's a plenty of Inkscape tutorials out there, so I am confident you will come up with a decent logo for yourself.

For the moment, I suggest you to do just little changes and save the file as Encapsulated Postscript (.eps). Before saving, Inkscape shows you this dialog:

There's only one option you should change: enable the "Convert texts to paths". What it does is converting... well, text into vectorial outlines (so font informations are then discarded) If you don't check that option, acrobat reader will consider text as text in your final pdf document. In brief, it will make the text selectable, like this

And, in general, you don't want that happening for a background image, don't you?

Anyway, now you should have your beautiful logo, says sample_logo_transparent.eps. A little digression: for the name of my logo I used the word transparent, but the eps's don't really support transparency. If you go back to Inkscape and look carefully at the fill properties:

you will notice that the opacity is 100% and the color of the outlines is just a light gray, giving the impression, in the final document, of transparency. At first one could think to use indeed opacity parameter and save the logo as pdf (which supports transparency) but the final result is awful.

The above picture is not a screenshot gone bad, it is the actual result if you try to import the image as pdf (supporting transparency) instead of an encapsulated postscript (which doesn't support transparency, so you are forced to fake using light colors). If someone obtains better results in importing images as pdf's, let me know, please. End of digression.

Ok, time is come to add our picture as the page background. For the purpose I will use a tiny package called eso-pic.

At line 6 I imported the package and at line 62 I added the background picture, which is defined in lines 51-59. The command \BackgroundPicture will put a box big as the entire page. Inside the box, the image, centered orizontally (with \centering) and vertically (with a pair of enclosing \vfill)

Finally! Let's run xelatex and see the result:

Our mighty page came to life. Hope you like it. Happy experimenting.

Click here for the last part of the tutorial.

1. Note that in this part of the tutorial there is nothing specific to XeLaTex, so ideally you can use these instructions to add a watermark also to plain Latex documents. [↩]

This is the fourth part of the tutorial Cover letter with style. You can find the third part here.

After the header, I will take care of the footer. To change the default I will use the \firstfoot command. Basically it works like \firsthead, so I have nothing special to add. I will update the template with:

At line 39 I've declared my new footer. I wanted the material in the footer to be centered (line 40) and I've read the content of the variable fromaddress and used it as the first line, then the break line (\\) and then the email and phone (also read from the corresponding variables). The result is the following:

There's a problem with the way I declared the fromaddress: to have KOMA-Script rendering my address on three lines, I used the break line command (\\) but now I would like a one-liner address in the footer. I could declare yet another variable, this time avoiding to put the line breaks, but it will be an ugly duplication. Instead, I will use \renewcommand{}{}. As first parameter it takes the command to be redefined and as second parameter you declare the new material to use instead. Well, let's proceed:

First of all, I enclose the first line in curly braces (line 41 and 44). In this way the effect of \renewcommand will remain local and will not affect the entire document. At line 42 I redefine the meaning of the \\ command, specifying it has to be replaced by a dot. That's all. Let's look at the result

So, only for the first line in the footer, the line breaks in my address were replaced by a dot. Now just enlarge the dots and add some space before and after them:

Look carefully at line 42. First of all, I used the escaped space (a backslash followed by a white space) to instruct TeX to put literally two spaces around the dot. Without escaping the spaces, TeX will happily swallow them. Secondly, I applied the \large modifier to the dot character and I enclosed in curly braces (otherwise the trailing space would be enlarged too). The result will be the following

Nice, we have our address on one line now. It's time to take care of the second line. For the email and the phone contacts, I will use a couple of symbols from the marvosym package. The template so becomes:

At line 5 I included the marvosym package; the rest is happening at line 46. Nothing special: I used the enlarged version of the symbols \Letter and \Telefon. I also used an escaped space to keep the email address separated from the telephone number.

Now, the final touch: I will letterspace the entire footer and use the small caps. So, here it is:

Basically I just added the line 42. The result?

Quite a long journey for a fucking footer, but we're done and I hope you will like the final result so far. Please mind that the above screenshot was made smaller in respect of the others. To see the footer in respect of the entire page, here it is the last picture

I think it is already quite a good letter, but in the next part we will watermark our logo.

This is the third part of the tutorial Cover letter with style. You can find the second part here.

It's time to setup a custom header for our cover letter. I usually put my name and my current job title in the header, accordingly to my big ego. In KOMA-Script, there are several ways to define your own header; each one offers an increasing degree of freedom but also an increasing complication in use. Luckily enough, for our purposes, we can use the easiest.

So, the simplest way to change your header is by the \firsthead command. That will set the custom header just for the first page of the document. But we're talking about a cover letter: don't even think to make it longer than a page. Enough said, I will modify the template now

So, I have specified the following: the header shall be centered and will be comprised of two lines (the \\ is the latex command to break the line). The first line will be our name. I didn't write it directly because it is already set at line 9. Instead, I used \usekomavar to lookup the fromname variable. Here I am adhering to the D-FRY principle: don't fucking repeat yourself. The second line is the job title. You can choose to define a variable as well, if you plan to use the job title more than once in your letter.

Now, render the letter again, to see the result

Well, it sucks. I will increase the font size, and use the small caps version.

Now the header looks like this

Much better. But I'm still not quite happy. So, I will increase the letter spacing, just for the first line. I will change the so called "feature" LetterSpace.

I used the command \addfontfeature to set the LetterSpace feature equal to 20. To find the right factor, I just did some experiments. Mind the use of a pair of {} to enclose the entire first line. In this way the change of letter spacing is local to the first line and don't apply to the second line. I also set up half centimeter of space between the lines, with the command \\[put your vertical distance here]

So, render again the letter and see the result:

Well, now take a look at the entire page so far

Perfect. In the next part I will show how to setup up the footer and then we will be ready for the watermarks, logo and barcode...

This is the second part of the tutorial Cover letter with style. You can find the first part here.

In this second part, we will change the default fonts using fontspec. Forget importing Postscript fonts, classifying them under the NFSS¹ and other crazy stuff: fontspec is able to load opentype fonts and select them very easily. You have just to install the fonts on your system. For example, I bought Garamond e Gill Sans fonts from Adobe and I'm using Ubuntu, so I copied the *.otf files somewhere under the

/usr/share/fonts

and then I updated the font cache with this command

sudo fc-cache -fv

Last thing you will need is to take note of the exact name of the font family, to be able to select it. For that, after having installed the lcdf-typetools ubuntu package, you can do something like

otfinfo -i /usr/share/fonts/AGaramondPro-Regular.otf | grep Family

Ok, after those few steps I have installed the fonts and discovered their family name, say, "Adobe Garamond Pro" and "Gill Sans Std". Now just change the template (remember, standard.lco) as this:

At line 4 I just imported the fontspec package. At line 24 I am instructing fontspec to add the ligatures TeX needs.² At line 25 I set the main font and at line 26 I set the font to be used in case a sans serif one if needed.

Another important thing to set up, usually, is the font size and the lead. To do so, just add one more line:

I just added the line 29, plain old Latex directive, to redefine the \normalsize macro³. In this way I can specify the height of the font and the space in point between the lines. The values one should use really depend on so many factors... but this is not a course on basic typography.

Ok, time to generate our cover letter again. To appreciate the differences, I first show the old version:

And now with the professional fonts

Can you see the difference? I hope so. Note also the sender address: it has to be rendered in a smaller size, so KOMA-Script used the sans serif font because more legible; that's why we also specified a suitable family for sans serif font in our template.

For more information, examples and so on, I urge you to read the fontspec documentation, to get ready for the third part of the tutorial.

That's all folks. Now you can proceed to the third part.

1. New Font Selection Scheme [↩]
2. Commercial fonts usually lacks ligatures like "--" (n-dash) and "---" (m-dash) but with this line TeX will still find them [↩]
3. There are other methods [↩]

Time flies and almost one year went by without me writing the 5th part of Your Curriculum in LaTeX series. You know what? I grew tired of the tutorial: you can figure out the rest¹

Instead, I decided to start a new tutorial, this time illustrating a way to obtain a stylish cover letter with XeTeX (and XeLaTeX), which enables the easy use of OpenType fonts (through the fontspec package) and support for Unicode text (no need of escape extended characters anymore). Also, as in the other tutorial, KOMA-Script will be used.

The cover letter is the first thing they will read; possibly its form is as much important as its content. Even if you don't agree, a fancy letter doesn't do any harm, doesn't it? For example, what about a letter like this²

Strong header, contact data in footer, logo as watermark. Even a barcode to pimp the destination address! Ok, the barcode is a little bit too nerdy, but it will give me the chance to show how easy is to use PSTricks from inside XeLaTex.

In this tutorial I will also show how to separate the content of your letters from the style, so you can swap the latter really easily, to obtain something completely different, like this for example:

Ok, let's start. I assume you dutifully installed XeTeX, XeLaTeX, KOMA-Script and you are ready to follow me. Ready?

Create a .tex file and past the skeleton of the cover letter into it:

At line 1 you are instructing XeLaTeX to load the letter class from KOMA-Script, which will format a nice letter for you. At lines 6,7,8 the destination address is specified. At line 13 the body of the letter. The other parts should be trivial to understand. Basically this is a template for any kind of letter you will write. Nothing difficult indeed. If you process this with XeLaTeX you will get:

Effortlessly we obtained a nice formatted letter. KOMA-Script even added three little dashes on the left border: they are guides to fold the letter with precision. The only thing is missing is the sender address. I could have added the KOMA instructions to set the sender address directly into the tex file, but there's a better method.

The letter document class defined by KOMA-Script support the loading of a setting/style file. In this file, with extension .lco, you can store things like your data (used to compose the sender address) or whatever latex instruction, to change the style for example. In this way the .tex will contain just the letter text and nothing else. This is handy for two reason: 1) you don't have to type your data for each letter you write; 2) you may have more .lco files that you can use to change altogether the look & feel.

So, create a file and call it standard.lco. Stick your data in it, like this:

Change accordingly your .tex file (containing the text of the letter) to instruct KOMA-Script to load the standard.lco file:

I've changed just the first line. Urge yourself to run XeLaTeX to see the results:

The sender address now appears where it is supposed to be. You will notice that KOMA-Script will also add the one-liner version, meant to pop up from the transparent window of the envelope - if any - together with the destination address.

Well, that's all for the first part. There's still lot to explain so please proceed to the second part.

1. Oh, gentlemen, do you know, perhaps I consider myself an intelligent man, only because all my life I have been able neither to begin nor to finish anything [Dostoevskij - Notes From The Underground] [↩]
2. The content is completely fictitious and doesn't necessarily reflect my views [↩]

This is the fourth part of the tutorial. You can find here the third part.

In the first part we took care of the title of the resume; in the second part we organized the sections, using an appropriate style; finally, in the third part, we formatted the footer, as a container for our contact data. Now it's time to tackle the Experiences entries, the place where to display infos about our past and current employments. The entries will look like the following

For more clarity, the following picture shows the used grid

It is basically a table, with two columns. The first one is 2cm wide and the second spans for the remaining space of the table. The total width of the table is slightly less than the width of the page body width (i.e. the page width minus the margins width.)
To achieve this, we will use the tabularx environment, which is able calculate automatically the column size depending on the total width of the table. The general form of the environment is the following:

\begin{tabularx}{width}{preamble}
[... table data ...]
\end{tabularx}

The width parameter is the total length of the table, whereas the preamble is used for the column specifications. For each column in the table we can use a symbol in the preamble to specify which kind of column we want. For example, to indicate that a column should have the width automatically calculated, we have to use the “X” symbol in the preamble. So, the code

\begin{tabularx}{5cm}{XX}
[... table data ...]
\end{tabularx}

will define a table 5cm wide featuring two columns, both with an automatic width (in this case each column will be 2.5cm wide.) Among the preamble options, we can use the “p” symbol, followed by a width specification, to force a column to that width. So we could write something like that

\begin{tabularx}{5cm}{p{2cm}X}
[... table data ...]
\end{tabularx}

In this case the table will be 5cm wide, with the first column spanning for 2cm and the second column automatically adjusted. There's a lot of options one could specify in the preamble, so I suggest to read the tabularx document to become aware of all the possibilities.
The data enclosed in the environment will be formatted as a table. To specify rows and columns the symbols & and \\ has to be used. For example the following

\begin{tabularx}{5cm}{p{2cm}X}
Name & Stefano \\
Surname & Kindoblue \\
City & Amsterdam
\end{tabularx}


will generate this table:

Back to our requirements: we need to define a table wide, say, 97% of the page body width. To calculate that length we can use the latex command \linewidth, which represents the length of a line of text in the document (nota a \textwidth) I think we are pretty much done. The following code will create the desired table

\begin{tabularx}{0.97\linewidth}{p{2cm}X}
[... table data ...]
\end{tabularx}

Finally we can write our first entry in the Experiences section.

Note the use of \hfill command, to push the “Amsterdam, The Netherlands” apart from the company name. The result will be this:

Nice. Now we need to format the first column, which should be ragged left and in small caps. To do so, we need to modify the preamble. Remember the symbols used to specify the column type? If we prefix those symbols with something like that

>{decl}

Then the decl will be put directly in front of the entry of the column. The decl can be a sequence of Latex commands, that will act on the column matter. We can write something like that:

\begin{tabularx}{0.97\linewidth}{>{\raggedleft\scshape}p{2cm}X}
[... table data ...]
\end{tabularx}

What we just did is to declare the text ragged left and small caps enabled for the first column. Let's go back to our curriculum and modify accordingly. I will also make bold some parts:

The result is the following:

To highlight the salient data of the employment entry in respect of the job description, we can use a gray background for the first four rows of the table. The colortbl package provides several commands to colorize backgrounds in tables. For example, the command

\rowcolor[gray]{.90}

set the background color to 90% gray for a given row. We can define a custom command to be used as a shortcut, in this way

\newcommand{\gray}{\rowcolor[gray]{.90}}

Now in our resume, for the first four rows of the table we can use the command \gray. But don't forget to include the colortbl package!

Finally we obtain something like this:

Sweet, isn't it? We are able to define a table for our job entries, with style (at least, in my humble opinion). Only problem is there's a lot of boilerplate code to repeat for each job entry we would like to add to our document. So in the next part of the tutorial I will show how to define a custom environment that will format once for all of our job entries, regardless their number. Along the road there will be room also for some refinements.

See you in 7 seven years, then.

This is the third part of the tutorial. You can find here the second part.

In the first part of the tutorial we took care of the title of the resume; in the second part we organized the sections, using an appropriate style. Now it's time to properly format the pages and add a decent footer. To do so, I installed and used KOMA-Script. It is a powerful bundle of LaTeX classes and packages and, as stated in its guide: its primary purpose is to provide more-flexible alternatives to the standard classes. It includes the scrpage2 package to customise the document page header and footer, improved and enhanced successor of scrpage.

So, let's change the \documentclass to use KOMA. Also, include the package scrpage2:

As you can see from the result page, the are some adjustments regarding the margins.

Still, no big differences. So, we proceed to set the footer to replace the page numbers in the bottom of the page with something more appropriate for a resume: the contact data. To do so, we will use the commands \pagestyle{scrheadings} and \cofoot. In this way:

Take a look at the result page:

Let's focus on the footer, because the default appearance is not enough.

The first thing to do is to change the font shape of the footer, redefining the command \headfont, so the latex code becomes:

The footer now looks like the following:

As we did with other important pieces of this document, we can use the command \so from the Soul package, in this way:

The result is now much better:

And now, the final touch! Go, grab and install the Marvosym package. It contains fonts with a lot of symbols¹. The idea is to specify the symbols for email and phone contact data, to provide visual hints.
To do so, we will use the command \Letter and \Telefon. Also, to increase the size of the symbols, we will use the \Large modifier, all enclosed in curly brakets (to limit the scope of the command, otherwise also the text will be enlarged.)
So, the latex code becomes:

The result is the following:

To recap, in this part of the tutorial we adjusted the page format using KOMA-Script, then we added and customized the footer. The following picture shows the steps we took in the customization:

That's all folks. See you in seven years for the fourth part.

1. Take a look at the Marvosym documentation to discover which symbols are available and how to specify them in your document [↩]

This is the second part of the tutorial. You can find here the first part.

Now it's time to add the section headers. We will use the command \section, in this way:

The result is like this:

The section headers can be improved with a little bit of personality. So, instead of living with the standard format for the section header, we will customize it. The package titlesec is offering several macro to cope with personalization of titles and headers. Install it and load in the preamble, so we can use the \titleformat command

\titleformat{command}[shape]{format}{label}{sep}{before}[after]

It takes 7 parameters. The ones in curly braces are mandatory; the others, optional.

• The first parameter, command, is used to specify which sectioning command has to be redefined. In our case, we want to change the format of the sections, so we will use the value \section
• The second parameter is to specify the shape of the sectioning command. For the possible values, see the titlesec manual. In our case, we are happy with the default shape.
• The third parameter is the most important. Here we can specify the format for the entire title.
• The fourth parameter is the label. It is some text that appears in the title. In the previous image, the labels for the section are the running numbers.
• The fifth parameter is the separator between the label and the title.
• The last two parameters can contains LaTeX code that will appears before and after the title material.

So, to begin with, let's eliminate the numbers in front of the section titles, by using the following declaration

\titleformat{\section}{}{}{0em}{}

As first parameter, we specify the sectioning command whose format has to be redefined; in our case: \section. The shape parameter is not passed, because we are happy with the default value and it is not mandatory. The third parameter, the format, we leave empty for the moment. Now the forth parameter, the label. We said we want to get rid of the numbers, so we leave the parameter out. Regarding the fifth parameter, we have to specify a length for the separation between label (null) and the title. The sixth parameter also will be left empty. The seventh parameter is not specified because is not mandatory.

So our code will look like the following:

The section titles now become like this:

Now it's time to play with the format parameter. To begin with, I would say to increase the font size and use the small caps. After all, those strings are the labels of the sections, so we have to add some emphasis. It's easy to do, just use the commands \large\scshape in the format. So our declaration will be

\titleformat{\section}{\large\scshape}{}{0em}{}

The result is the following:

You may notice something strange: the title "Personal Info" is typeset as justified. Whatever is the reason, we can specify our titles has to be ragged on the right. So we can change the format to:

\titleformat{\section}{\large\scshape\raggedright}{}{0em}{}

Let's take a look now:

As final touch, we can add a separator line. To do so we should add the command \titlerule after each title. If you remember, the last two parameters of the \titleformat are meant to specify materials that goes before and after, respectively, the titles. The definition now becomes:

\titleformat{\section}{\large\scshape\raggedright}{}{0em}{}[\titlerule]

We just specified the last parameter, in a way that a title rule will be appended (after) the titles. The parameter is not mandatory, so when it appears, has to be wrapped in square braces and not in curly ones. The result is the following:

I think we are pretty much done with the section titles. Hereafter I show how their look changed along the tutorial:

For the third part, see you in seven years.