LG L1730SF touch screen display in Ubuntu Linux 8.04 Hardy Heron, part 3

In the 1st part we set up the drivers for the touch feature, and in the 2nd part we solved the weird jumpiness issue. Now we are ready to proceed to calibrating the display, and fine tuning the system for touch based usage in general.

Calibrating the touch input

The idea of the touch screen is that the user interface objects presented on the screen can be directly pointed at, using a pen or a finger. Ideally, when user sees even a single pixel at, say coordinates 100, 150 and then pushes the screen with a pen at this point exactly, the touch screen / mouse driver should register exactly the same coordinates and report them to the windowing engine.

However, in practice things are a bit different. For example, the resistive touch panel used e.g. in LG L1730SF is placed on top of the display panel. In real life things are not perfect, so there will be some offset in the display component framing, in the touch panel component framing, and in their relative placement on top of each other. Every manufactured device ends up being slightly different.

The result is that there will be some offset between the actual/perceived location of the touch, and the location reported to the windowing system that draws the mouse cursor and processes points and clicks. This is bad. For example, it can be very annoying if you are trying to hit a link on a web page, but always seem to miss it just a little!

Fortunately, this error can be fixed fairly well with a proper calibration. Calibration is a procedure based on showing a known location to be touched on the screen e.g. with an X mark, and then sampling the actual location that was touched. The difference between screen coordinates and mouse coordinates tells what kind of offset the particular display has. For example, when the user thinks he has touched precisely coordinates 100, 150 we may have received 108, 145 as mouse coordinates. Thus the difference is +8, -5. In order to correct the error, the offset can be removed by manipulating the mouse coordinates with the offset values found via calibration. This will be done already at the driver level, e.g. (+8, -5) could be subtracted from all input reported by the touch panel. The X windowing system would then get slightly different mouse coordinates that should match much better with the screen coordinates and perceived touch location.

Note that proper calibration is always somewhat user dependent, as there is a small distance between the touch panel and the surface of the image in the display device. Depending on the way the display is mounted (e.g. on a wall or table), the taller the person is the more angled is her view to the display. As a result, the farther away she actually touches from the location that she thinks she touches. It is like with shadows: if the sun shines right on top of an object there will be no shadow at all (precise touch), but from another angle a shadow will be cast (offset). In addition, when fingers are used for touching, users may have different preference on which part of the finger is the “center” point that should be registered as the touch location. E.g. is it the center of the area of the finger that touches the display (finger tip touch), or perhaps the location at the top boundary of the touch (fingernail touch). Nevertheless, the touch control cannot be very precise without personal calibration.

For proper calibration, one pair of sample values (x offset, y offset) is not enough – these correction factors must be taken separately for different areas of the display. In small devices, such as PDAs and mobile phones, it is very common to use 5 samples: 4 corners and the center of the screen. However, Evtouch uses nine calibration samples, as also centers of the edges of the screen are sampled. Based on the samples it then calculates the proper correction factor (i.e. the actual x,y offset to be subtracted from touch input is some kind of approximation based on the distance to a few nearest sampled calibration points).

Next, we will begin to figure out how to apply proper calibration value pairs (the 9 samples) to the xorg.conf file. They will be eventually listed as Options in our touch screen section.

There are basically two methods. One is naturally manual trial and error based, where one tries to adjust a value and then tests whether it helped. However, due to large number of adjustable values (9 samples with two values = 18) and the approximation in the algorithm, this is laborious. The other method involves using a calibration tool, which is a simple software aimed for making the calibration as simple as touching a few spots on the screen. We’ll of course try the latter first and see whether it works for us.

Let’s first activate the calibration mode in Evtouch. In console, type

sudo nano /etc/X11/xorg.conf

Find the touchscreen section, and uncomment/write this:

Option   "Calibrate" "1"

This will turn calibration support on from evtouch driver module. You might want to remove “CorePointer” from touchscreen, and make sure that “Configured mouse” is enabled to allow mouse usage during calibration. Save and exit.

Next, we need to stop X:

sudo /etc/init.d/gdm stop

Continue in one of the consoles by pressing e.g. CTRL+ALT+F2. To begin calibration, first go here:

cd /usr/lib/xf86-input-evtouch

Before starting the calibration tool, we need to copy a bitmap file for empty cursor to file system root (!):

sudo cp /usr/share/xf86-input-evtouch/empty_cursor.xbm /

Then start the calibration tool as follows:

sudo ./calibrate.sh

A white screen with nine black crosses should appear. They are in the corners, middle of border lines, and in the center. Basic idea is that when you press the Enter key, one of the crosses turns red and you should click it as precisely as you can. Then the next one will turn red, and so on until all 9 have been tapped. Then the proper offset values will be printed, to be copied to your xorg.conf file.

However, as LG L1730SF has the touch panel mounted in rotated and swapped direction with respect to what is expected by Evtouch, the input data will not be what the calibration script expects. This is because our xorg.conf options Rotate and SwapX/SwapY do not seem to have effect here. As a result, when the calibration application marks left top X as red, and then you tap that position on the screen, the raw touch panel output will be very faw away from those screen coordinates. Thus, you cannot actually click the X mark that turns red, or you’ll get insanely large values that will never work.

One workaround is to simply click them in a different order. This is ok, as the calibration application only reports a list of offset values, which can be put to correct places in the xorg.conf file later. The expected tap order is this (i.e. left top corner first, right bottom corner last):

1    2    3
4    5    6
7    8    9

But you should instead click the crosses like this (i.e. right bottom corner first):

9    6    3
8    5    2
7    4    1

As you can see, this order is first Y swapped and then clockwise 90 degree rotated (which matches with Rotate cw, SwapY On, SwapX Off settings that we had to put in xorg.conf file for this display model).

Now you should get values that are close to zero, something like +-20 or lower. Just observe that when you tap, the red color moves to the next cross, but follow the order described above. It is a little confusing, I know! When you’re done, the calibration software shuts down and you can see the calibration values printed on the screen. You may need to do this a couple of times before you get it right. Now write down the values on a piece of paper or something.

After you’re done with the calibration tool, you can delete the cursor file:

sudo rm /empty_cursor.xbm

NOTE: In the calibration tool, you might have problems pressing the X marks because you cannot see them properly. You may need to adjust your display’s settings (to stretch the image) and setup the display configuration properly before calibration. In X, open terminal and write:

sudo displayconfig-gtk

Select Model list and find LG L1730SF. Check that the resolution is ok, then save to file by clicking the disk icon above, e.g. /etc/X11/xorg.conf.new. Then open the file in console, and check that everything seems to be fine – you might want to comment out some modes and modelines for resolutions that are not supported by this display, i.e. higher than 1280×1024, and uncomment Virtual resolutions, if any. Then make a backup copy and replace your current xorg.conf:

sudo cp /etc/X11/xorg.conf /etc/X11/xorg.conf.bak
sudo cp /etc/X11/xorg.conf.new /etc/X11/xorg.conf

Restart computer (or just X), and the display should be better configured and calibration now possible to do with the calibration tool.

You can copy the calibration values to your xorg.conf file to the touchscreen section as options, if they are reasonable they should look something like this:

Option          "x0"    "+15"
Option          "y0"    "-3"
Option          "x1"    "+6"
Option          "y1"    "-3"
Option          "x2"    "-12"
Option          "y2"    "-6"
Option          "x3"    "+12"
Option          "y3"    "-15"
Option          "x4"    "+6"
Option          "y4"    "-10"
Option          "x5"    "-8"
Option          "y5"    "-6"
Option          "x6"    "+6"
Option          "y6"    "0"
Option          "x7"    "0"
Option          "y7"    "-3"
Option          "x8"    "-6"
Option          "y8"    "-3"

Then change Calibration setting to 0 and restart the computer. Unfortunately, when you start to use X again you’ll likely notice that Rotate and SwapX/SwapY now work again and the calibration values got from the calibration script do not actually apply to the correct spots on the screen anymore (well, we expected that this would happen). With trial and error, I found this order to work with Rotate cw, SwapY On, SwapX Off settings (Y swapped with respect to how they were collected?):

2    5    8
1    4    7
0    3    6

Here o means x0, y0, 1 means x1, y1, and so on.

However, now that we have some pretty reasonable values and also know which of the nine calibration samples matches with which location on LG L1730SF’s screen, we can fine tune each spot separately via trial and error, as described next. Note that it is also possible to start from scratch with zero calibration by setting all calibration values in xorg.conf (x0-x8, y0-y8) to zero.

Begin with the corner marked 0 above (bottom left), and respective values x0, y0. Tap to center of the screen and then to corner 0 (left bottom corner) and observe where the cursor jumps. If the cursor is above the place you touched, you need to decrease x0 value (Rotate option swaps X and Y axels!). If the cursor is left to the place you touched, you need to decrease y0 value. The distance between the actual screen and the touch sensor is something like 5 mm, so you should try to look the screen as straight 90 degree angle as possible.

So in practise you open a console with CTRL+ALT+F2, login, load your xorg.conf file and then adjust one calibration value, and save the file. Then switch to GUI with CTRL+ALT+F7 and restart X with CTRL+ALT+BACKSPACE. Now you can test the new value. Then switch back to console, change the value, and test again in GUI. Repeat this until you are satisfied.

Hmm, it shouldn’t be too hard to make at least a simple Gnome/KDE based tool that would get these swaps and rotations correctly, and record the offsets so that they could be directly copied to xorg.conf. Of course even better would be a possibility to try them out “live” without hopping between console and X.

Nevertheless, with these instructions you should get the touch feature’s offsets calibrated, and the good news is that you only need to do it once.

Virtual keyboard

After calibration is done, basically the system should be pretty usable. However, it is very common that setups with touch screen do not include a keyboard. Instead, a virtual keyboard is used. We will setup that next.

The default virtual keyboard for Gnome is GOK, but in fact it is quite complicated and … downright ugly. It is intended to support people with many kinds of  disabilities, and here all we want is some buttons on the screen to touch to write letters etc. A much nicer option is Florence (http://florence.sourceforge.net/english.html). Unfortunately, there are no binaries available for Ubuntu, so we need to install it from source. First we need to satisfy some dependencies:

sudo apt-get install build-essential libxml2-dev libgconf2-dev libglade2-dev libatspi-dev libcairo2-dev libgnome2-dev librsvg2-dev

Now, let’s get the source code:

cd ~\Source
mkdir florence
cd florence
wget http://downloads.sourceforge.net/florence/florence-0.3.0.tar.bz2?modtime=1221508202&big_mirror=0

Extract, build and install:

tar -xjvf florence-0.3.0.tar.bz2
cd florence-0.3.0
./configure --prefix=/usr
make
sudo make install

To start it, click Applications->Universal Access->Florence Virtual Keyboard. Or, in X open console and write florence. Click OK to enable accessibility and restart Gnome. When Gnome loads, restart Florence. Virtual keyboard now appears.

Florence manual also describes autostart option:
“If you prefer that Florence is launched at GNOME startup, choose the menu item System->Preferences->Sessions, click on the Startup programs tab, then click Add and enter /usr/bin/florence so Florence is launched with GNOME at next boot.”

To enable mouse as well, in xorg.conf uncomment Configured Mouse and comment Core pointer from touch screen.

In the desktop’s notificators area, a new icon appears for Florence (blue smiley). Click it with mouse’s right key and select Preferences. Edit the virtual keyboard settings as you wish. I disabled Arrows keypad, Numpad and Function keys, then zoomed to 36.0. Note that you should zoom only to integer values, decimals will make the graphics distorted for mouse over effect. Leave Auto click to 0, or you will get doule clicks. Note: if you keep the virtual key pressed (not lift your finger), it will be repeated, as with physical keyboards.

You can also open console and run gconf-editor, then look for apps->florence, and edit settings. These are partially duplicate to what you can do from Florence’s Preferences dialog, but there’s more options! I set them as follows:

Behaviour:
- always_on_screen = selected
- auto_click = 0
Colours:
- activated = #F87F18
- key = #000000
- label = #D9C8A0
- mouseover = #E6A43F
- outline = #000000
Layout:
- extensions = Arrows
- file = empty, although it can be found from /usr/share/florence/florence.layout
Window:
- decorated = not selected
- shaped = selected
- zoom = 34

These settings remove the window frame and keyboard background, resulting to keyboard keys only floating on top of the desktop, which is nice. The only problem is that whenever you reboot, Florence relocates the virtual keyboard to top part of the desktop, and since you don’t have window frame to grab, it is impossible to move it. As Gnome does not support remembering window locations (and they consider it application’s task to do – which I strongly disagree), currently the only option is to modify Florence to relocate it to a suitable position on the desktop. Unfortunately, it does not have a setting for this, so the only option is to modify source code:

cd ~\Source\florence\florence-0.3.0\src
cp florence.c florence.c.bak
sudo nano florence.c

Go to the end of the file, look for main function and the following line:

 flo_screen_changed(GTK_WIDGET(florence->window), NULL, florence);

Then add these lines below it:

 // Set initial position of the window to the bottom of the screen:

 int screen_height=gdk_screen_get_height(gdk_screen_get_default());

 int screen_width=gdk_screen_get_width(gdk_screen_get_default());

 gtk_window_move(florence->window, (screen_width-florence->width)/2, screen_height-florence->height);

So these come just before this line:

gtk_widget_show(GTK_WIDGET(florence->window));

Now save and exit, then compile and install:

cd ..
./configure --prefix=/usr
make
sudo make install

Restart Florence, now the keyboard appears initially in the bottom of the screen. As holding your arm up makes your muscles ache rather quickly, I believe it is much better to organize the desktop so that user can keep her hand down in rest for most of the time, and even when typing with virtual keyboard the hand will not block the view to the other parts of the screen that are not covered by the virtual keyboard. Therefore, I prefer to have the keyboard located at the bottom of the screen.

Note: in case you don’t like that blue smiley icon, it is located in /usr/share/icons/florence.svg, you can create a new one with the same name. For example, in /usr/share/icons/Human/scalable/devices/input-keyboard.svg is a nice keyboard icon which you can take into use as follows:

cd /usr/share/icons/
cp florence.svg florence.svg.bak
sudo cp /usr/share/icons/Human/scalable/devices/input-keyboard.svg .
sudo mv input-keyboard.svg florence.svg

Tuning the timings

Modern desktops have been designed to be used with a keyboard and a mouse. A touch screen based setup typically has neither, as the keyboard can be replaced with a virtual keyboard (like we just did), and also the mouse can be emulated with touch. Well, almost! While a typical mouse nowadays has 2-dimensional pointing and at least 2 buttons and a scroll wheel, with touch there’s basically only a binary type input (pressure/no pressure) and its coordinates. This maps pretty well with a one-button mouse. How about the second mouse button? Scrolling? Dragging? These are all pretty much required capabilities, otherwise desktop usage becomes  somewhat handicapped.

The solution? Well, actually there isn’t any really good solution. Touch is touch, not a mouse, and you can’t get around that. The desktop should be designed again so that it can be easily used with touch, at finger tip level precision (not everyone likes the pen). In mobile phone size terminals this is already happening, but on Linux desktop we still need to wait a while to see what comes out of the netbook boom. Meanwhile, we have to manage somehow. One thing that we can utilize is time. An example: short press is left mouse click, long press is right mouse click. Or, long press enables dragging. Unfortunately, humans are not very good at timing at this level, so there really cannot be that much precision put into it. Forget multiple different length “buttons”, dealing with “short press” and “long press” is pretty much all you can get out of it.

This leads to an important decision: while the touch cannot properly emulate a mouse, we need to choose which features will be emulated and which will not be supported at all. Can your use case manage without the second mouse button? Without dragging? Does it still require scrolling, although not dragging? These can be pretty hard to decide some times.

Let’s take an example. Using a touch screen for drawing is quite obvious idea. And it can be fun, indeed – much more than drawing with a mouse. However, to be able to draw you must have a possibility to 1) move the pen without leaving a trail, and 2) move the pen leaving a trail. With touch screen, pretty much the only option is to emphasize dragging  type usage so that even very short presses quickly turn to dragging (=moving the pen leaving a trail). Then again, writing is almost always needed – you do want to save the picture and give it a name, don’t you? So you need to be able to use a virtual keyboard as well. When you press virtual keys, writing becomes difficult if the touch gestures are easily interpreted as dragging. When you need to write, you’d prefer that only very long presses turn dragging mode on. But these settings must be configured in xorg.conf, so you cannot change them for example whenever the virtual keyboard is brought visible (which would otherwise be a very good solution, by the way).

For typing with virtual keyboard, you could also consider high MoveLimit value in xorg.conf. For example, with ’100′, typing is easy as the touch feature’s mouse emulation mode will not easily switch from tap to drag even if the finger does not stay precisely still, because it takes a fairly big movement until the mouse coordinates will change (remember the jumpiness problem, caused by two large value in this setting).

But on the other hand, clicking links on a web page may become more difficult this way: if you don’t hit the link straight at the first try, you have to tap elsewhere first to go beyond the move limit so that coordinates change enough, then you can try again at the original spot (otherwise you’ll just be tapping inside the move limit area and no movement appears). Value ’50′ is a nice compromise, and allows also dragging more precisely, as MoveLimit is applied also during dragging! (I think the driver should be improved so that it applies only when you are beginning a drag gesture; then it should be immediately disabled to allow smooth movement and precise “drop”.

Evtouch supports timing based differentation in touch gestures. In xorg.conf you can define option LongTouchTimer. When it is set fairly long, such as ’200′, drag mode will not be easily activated even if the finger rests on the virtual key a bit long. For beginner users it can be even longer, as they get easily confused of different modes. Another xorg.conf option, TapTimer should be set to a small value, so that clicks come quickly after tapping, e.g. ’10′ ms  will make virtual keyboards seem very responsive. For beginners, a slightly longer value may be justified.

In addition to short vs. long presses, there’s another trick for creating additional input mechanism: one-and-a-half tap. This is like a double click with a mouse, except that you do not release the finger after the second tap. While long press activates dragging, one-and-a-half tap is mainly used as the right mouse button click. However, you cannot simulate right button clicks with one-and-a-half style tap if the TapTimer value is too small, as you don’t have time for that “half” tap before the first gets reported as single (left) mouse click. Value ’50′ makes a noticeable lag when writing with virtual keyboards, still it is not enough for that second tap. Value ’150′ allows second mouse button emulation with one-and-a-half tap, but you still have to be quick and on the other hand, writing becomes somewhat slow. Therefore, if you can manage without that second button, I suggest keeping TapTimer value very short and forgetting the one-and-a-half tap completely. It is also difficult for beginner users, who do not expect that such a thing even exists.

The settings presented above emphasize click style behaviour, and are quite nice for beginners. They are also suitable for normal desktop use, although if you need the second mouse button you have to sacrifice responsiveness via adjusting TapTimer to a longer value.

If you primarily use the touch feature with fingers, you have to keep MoveLimit rather high. If you primarily use a pen for touch, try to set it lower as pen is much more precise and easier to keep steady.

For drawing etc. analog style control, MoveLimit must be small (even down to ’1′) and you may need to set LongTouchTimer to a very small value, too – e.g. ’20′. TapTimer should be set to very low, e.g. ’10′. Clicking is still possible, but you’ll miss some of them quite often as they are interpreted as dragging. However, drawing with a painting program is quite nice, as you don’t have to first touch, then wait, then begin moving the finger/pen, but now you can pretty much draw like with a normal pen. However, although resistive touch panel like LG L1730 SF is quite precise and thus suitable for drawing, it requires some pressure and you need to learn to “keep the pen on the paper” steadily while drawing lines and curves, otherwise you’ll get dotted lines. These settings emphasize mouse drag style behaviour. The cursor follows the finger very rapidly and precisely, but clicking and typing is more difficult because you’ll miss some clicks much more often.

Note: I have set “Emulate3Buttons” option to “False”, as I don’t have any use for that and I believe that simplicity works better with touch feature; one should not try to emulate the mouse completely but focus on the benefit of direct pointing, with as little errors as possible, and with good preciseness and responsiveness.

As an example of some kind of compromize of the settings mentioned above, see my xorg.conf file, which is attached into the end of the text.

Automatic event channel mapping

When you reboot the computer, or change the touch screen’s USB cable from one USB port to another, the event channel that gets mapped to touch feature may change. As the event channel must be fixed in your xorg.conf file, at random boots the touch feature may or may not work.

This can be fixed by adding a udev rule, which will automatically map the touch input to a certain virtual event channel.

sudo nano /etc/udev/rules.d/69-touchscreen.rules

Add this content if it isn’t already there:

# udev.rules for touchscreens

# ITM Touchscreens

SUBSYSTEMS=="usb" ATTRS{idVendor}=="0403" ATTRS{idProduct}=="f9e9", SYMLINK+="input/touch"

Save and exit. Then edit xorg.conf and replace fixed event channel with this new automatically mapped event channel:

Option          "Device"        "/dev/input/touch"

Save and exit. Reboot, and the touchscreen should still work. Also, when you type ls /dev/input, you should see touch somewhere in the output.

Note: you can find out the vendor and product id for example via cat /proc/bus/input/devices, which should output something like this:

I: Bus=0003 Vendor=0403 Product=f9e9 Version=0100

N: Name="ITM Inc USB Touch Panel"

P: Phys=usb-0000:00:0f.4-1/input0

S: Sysfs=/devices/pci0000:00/0000:00:0f.4/usb1/1-1/1-1:1.0/input/input9

U: Uniq=

H: Handlers=mouse2 event9

B: EV=b

B: KEY=400 0 0 0 0 0 0 0 0 0 0

B: ABS=1000003

Another, more verbose source is udevinfo -a -p /class/input/input9, where input9 comes from the output of the previous command. Here is part of the output:

looking at parent device '/devices/pci0000:00/0000:00:0f.4/usb1/1-1':

    KERNELS=="1-1"

    SUBSYSTEMS=="usb"

    DRIVERS=="usb"

    ATTRS{dev}=="189:1"

    ATTRS{configuration}==""

    ATTRS{bNumInterfaces}==" 1"

    ATTRS{bConfigurationValue}=="1"

    ATTRS{bmAttributes}=="80"

    ATTRS{bMaxPower}=="100mA"

    ATTRS{urbnum}=="216"

    ATTRS{idVendor}=="0403"

    ATTRS{idProduct}=="f9e9"

    ATTRS{bcdDevice}=="0100"

    ATTRS{bDeviceClass}=="00"

    ATTRS{bDeviceSubClass}=="00"

    ATTRS{bDeviceProtocol}=="00"

    ATTRS{bNumConfigurations}=="1"

    ATTRS{bMaxPacketSize0}=="8"

    ATTRS{speed}=="12"

    ATTRS{busnum}=="1"

    ATTRS{devnum}=="2"

    ATTRS{version}==" 1.10"

    ATTRS{maxchild}=="0"

    ATTRS{quirks}=="0x0"

    ATTRS{authorized}=="1"

    ATTRS{manufacturer}=="ITM Inc"

    ATTRS{product}=="USB Touch Panel"

Tuning Firefox for touch based browsing

When you type text to Firefox’s address bar, it automatically (v. 3.0 onwards) shows a drop down list of possible matches. Unfortunately, this removes focus from virtual keyboard, and basically you need to type every letter twice to regain focus. Fix it as follows:

Write about:config into the address bar, press Enter. Press “I’ll be carefull. I promise!” button. Enter browser.urlbar in the Filter field. Change browser.urlbar.maxRichResults to 0. Change browser.urlbar.search.timeout to 3000. Restart firefox.

Other good firefox tweaks:

• Turn browser.urlbar.clickSelectsAll to True
• Turn general.smoothscroll to True

In addition to about:config properties, you can create two configuration files:

cd ~/.mozilla/firefox
ls

From list of files, check the one that ends .default and cd there. Then continue:

cd chrome
ls

This shows examples of configuration files.

cp userChrome-example.css userChrome.css
nano userChrome.css

Now edit the file, save, exit, restart Firefox and settings are enabled.

E.g. some possible settings for touch screen usage:

  /*

   * Make page URL font monospaced and bigger.

   */

  #urlbar{

      font-family: verdana !important;

      font-size: 15pt !important;

  }

  /*

   * Make bookmark sidebar font Verdana and bigger.

   */

  tree {

      font-family: verdana !important;

      font-size: 13pt !important;

  }

With these settings, it is easier to type new URL with virtual keyboard, and click existing bookmarks in the sidebar.

Gnome scrollbars

Scrollbars are much easier to use if you make them wider.

Create file .gtkrc-2.0 into your home directory, then add these lines:

style "wide-scrollbars"
{
    GtkRange       ::slider_width      = 30
    GtkRange       ::stepper_size      = 30
}
class "GtkRange"  style "wide-scrollbars"

Save. Log out, log in and all scrollbars should be wider now.

Miscellaneous tips

• In Gnome’s file manager, change to “Single click to open items”.
• Custom mouse pointer theme? Blank, except when you click -> blinks once, and
  when you drag -> visible hand.
• When you boot the computer, Ubuntu will show the login screen. How to log in, if there is no keyboard? Virtual keyboard is not started and available yet. The   easiest way is to create an unprivileged, common user and make it auto-login. To add/remove/modify users, select System->Administration->Users and Groups, and create a user with low privileges. To enable auto-login: System->Administration->Login Window, then select Security tab, and select Enable Automatic Login, select user to log in. Close, and reboot. The user you selected should be automatically logged in.

My xorg.conf file

Just for reference, this is my xorg.conf file:

# xorg.conf (X.Org X Window System server configuration file)
#
# This file was generated by dexconf, the Debian X Configuration tool, using
# values from the debconf database.
#
# Edit this file with caution, and see the xorg.conf manual page.
# (Type "man xorg.conf" at the shell prompt.)
#
# This file is automatically updated on xserver-xorg package upgrades *only*
# if it has not been modified since the last upgrade of the xserver-xorg
# package.
#
# If you have edited this file but would like it to be automatically updated
# again, run the following command:
#   sudo dpkg-reconfigure -phigh xserver-xorg

Section "InputDevice"
        Identifier      "Generic Keyboard"
        Driver          "kbd"
        Option          "XkbRules"      "xorg"
        Option          "XkbModel"      "pc105"
        Option          "XkbLayout"     "fi"
EndSection

Section "InputDevice"
        Identifier      "Configured Mouse"
        Driver          "mouse"
        Option          "CorePointer"
EndSection

Section "InputDevice"
        Identifier      "TouchScreen"
        Driver          "evtouch"
        Option          "Device"        "/dev/input/touch"
        Option          "DeviceName"    "TouchScreen"
        Option          "MinX"  "340"
        Option          "MinY"  "200"
        Option          "MaxX"  "3850"
        Option          "MaxY"  "3950"
        Option          "x0"    "+15"
        Option          "y0"    "-3"
        Option          "x1"    "+6"
        Option          "y1"    "-3"
        Option          "x2"    "-12"
        Option          "y2"    "-6"
        Option          "x3"    "+12"
        Option          "y3"    "-15"
        Option          "x4"    "+6"
        Option          "y4"    "-10"
        Option          "x5"    "-8"
        Option          "y5"    "-6"
        Option          "x6"    "+6"
        Option          "y6"    "0"
        Option          "x7"    "0"
        Option          "y7"    "-3"
        Option          "x8"    "-6"
        Option          "y8"    "-3"
        Option          "ButtonNumber"  "2"
        Option          "ReportingMode" "Raw"
        Option          "Emulate3Buttons"       "False"
        Option          "Emulate3Timeout"       "50" #50
        Option          "DebugLevel"    "0"
        Option          "TapTimer"      "5"
        Option          "LongTouchTimer"        "200"
        Option          "MoveLimit"     "50"
        Option          "SendCoreEvents"        "On"
        Option          "Rotate"        "cw"
        Option          "SwapX" "Off"
        Option          "SwapY" "On"
        #Option         "ScreenNumber"  "0"
        #Option         "Calibrate"     "1"
EndSection

Section "InputDevice"
        Identifier      "dummy"
        Driver          "void"
        Option          "Device"        "/dev/input/mice"
EndSection

Section "Device"
        Identifier      "Configured Video Device"
        Boardname       "geode"
        Busid           "PCI:0:1:1"
        Driver          "geode"
        Screen  0
EndSection

Section "Monitor"
        Identifier      "Configured Monitor"
        Vendorname      "LG Electronics Inc."
        Modelname       "LG L1730SF"
        Horizsync       30.0-83.0
        Vertrefresh     56.0-75.0
  modeline  "640x480@60" 25.2 640 656 752 800 480 490 492 525 -vsync -hsync
  modeline  "640x480@72" 31.5 640 664 704 832 480 489 491 520 -vsync -hsync
  modeline  "640x480@75" 31.5 640 656 720 840 480 481 484 500 -vsync -hsync
  modeline  "800x600@56" 36.0 800 824 896 1024 600 601 603 625 +hsync +vsync
  modeline  "800x600@72" 50.0 800 856 976 1040 600 637 643 666 +hsync +vsync
  modeline  "800x600@75" 49.5 800 816 896 1056 600 601 604 625 +hsync +vsync
  modeline  "800x600@60" 40.0 800 840 968 1056 600 601 605 628 +hsync +vsync
  modeline  "832x624@75" 57.284 832 864 928 1152 624 625 628 667 -vsync -hsync
  modeline  "1024x768@75" 78.8 1024 1040 1136 1312 768 769 772 800 +hsync +vsync
  modeline  "1024x768@70" 75.0 1024 1048 1184 1328 768 771 777 806 -vsync -hsync
  modeline  "1024x768@60" 65.0 1024 1048 1184 1344 768 771 777 806 -vsync -hsync
  modeline  "1152x864@75" 108.0 1152 1216 1344 1600 864 865 868 900 +hsync +vsync
  modeline  "1280x1024@75" 135.0 1280 1296 1440 1688 1024 1025 1028 1066 +hsync +vsync
  modeline  "1280x960@60" 102.1 1280 1360 1496 1712 960 961 964 994 -hsync +vsync
  modeline  "1280x1024@60" 108.0 1280 1328 1440 1688 1024 1025 1028 1066 +hsync +vsync
  modeline  "1280x960@75" 129.86 1280 1368 1504 1728 960 961 964 1002 -hsync +vsync
#  modeline  "1400x1050@60" 122.61 1400 1488 1640 1880 1050 1051 1054 1087 -hsync +vsync
#  modeline  "1400x1050@75" 155.85 1400 1496 1648 1896 1050 1051 1054 1096 -hsync +vsync
#  modeline  "1600x1200@65" 175.5 1600 1664 1856 2160 1200 1201 1204 1250 +hsync +vsync
#  modeline  "1600x1200@60" 162.0 1600 1664 1856 2160 1200 1201 1204 1250 +hsync +vsync
#  modeline  "1792x1344@60" 204.8 1792 1920 2120 2448 1344 1345 1348 1394 -hsync +vsync
        Gamma   1.0
EndSection

Section "Screen"
        Identifier      "Default Screen"
        Monitor         "Configured Monitor"
        Device          "Configured Video Device"
        Defaultdepth    16
        SubSection "Display"
                Depth   16
                #Virtual        1792    1344
                Modes           "1280x1024@60"  "1280x960@75"   "1280x960@60"   "1280x1024@75"  "1152x864@75"   "1024x768@60"   "1024x768@70"   "1024x768@75$
        EndSubSection
EndSection

Section "ServerLayout"
        Identifier      "Default Layout"
  screen 0 "Default Screen" 0 0
        Inputdevice     "TouchScreen"   #"CorePointer"
        Inputdevice     "Configured mouse"
        #InputDevice    "dummy"
EndSection

Section "Module"
        Load            "glx"
        Load            "GLcore"
        Load            "v4l"
EndSection

Section "ServerFlags"
EndSection