gtktscal/main.c

Go to the documentation of this file.

/*
 * File Name: main.c
 */

/*
 * This file is part of gtktscal.
 *
 * gtktscal is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * gtktscal is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * This code is originally from xtscal:
 *
 * Copyright (C) 2003, 2004 Philip Blundell <philb@gnu.org>
 *
 * Modifications:
 *
 * Copyright (C) 2008 iRex Technologies B.V.
 */

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <math.h>
#include <string.h>
#include <sys/ioctl.h>

#include <glib.h>
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <gdk/gdkx.h>

#include <X11/extensions/xcalibrate.h>
#include <X11/extensions/Xrandr.h>

#include "h3600_ts.h"
#include "calibrate.h"
#include "i18n.h"
#include "ts.h"

Display *dpy;
int screen_x = 768;
int screen_y = 1024;
int flag_debug = 0;
int flag_sanityCheck = 1;
int flag_firstBoot = 0;
int rotation = 0;
int xcal_error_base;
int xcal_event_base;
int calibration_done = 0;
GtkWidget *da;
char* g_defaultcalfile = "/home/root/.pointercal";
char* g_calfile = NULL;
GdkGC* gc = NULL;

/**
  * Show usage
  */ 
void usage (const char *name)
{
    fprintf (stderr, "usage: %s -view\n", name);
    fprintf (stderr, "       %s [-rotate <0 | 90 | 180 | 270>]\n", name);
    fprintf (stderr, "       %s -cal <xs> <xt> <ys> <yt> <xyswap>\n", name);
    fprintf (stderr, "       %s [-nocheck]\n", name);
    fprintf (stderr, "       %s [-firstboot]\n", name);
    fprintf (stderr, "       %s [-debug]\n", name);
    
    exit (1);
}

/**
  * Parse commandline args
  */ 
void parse_args(int argc, char *argv[])
{
    int i;
    for (i = 1; i < argc; i++)
    {
        if (!strcmp (argv[i], "-view"))
        {
            ts_show_calibration();
            exit (0);
        }
        else if (!strcmp (argv[i], "-debug"))
        {
            flag_debug = 1;
        }
        else if (!strcmp (argv[i], "-firstboot"))
        {
            flag_firstBoot = 1;
        }
        else if (!strcmp (argv[i], "-nocheck"))
        {
            flag_sanityCheck = 0;
        }
        else if (!strcmp (argv[i], "-cal"))
        {
            if (argc > (i + 5))
            {
                ts_set_calibration(argv + i + 1);
                exit(0); 
            }
            else
            {
                usage (argv[0]);
            }
        }
        else if (!strcmp (argv[i], "-rotate"))
        {
            if (argc > (i + 1))
                rotation = atoi (argv[++i]);
            else
                usage (argv[0]);
        }
        else
        {
            usage(argv[0]);
        }
    }
}

/**
  * Check for XRandR
  */
int xrandr_supported()
{
    int xrr_event_base, xrr_error_base;
    int xrr_major, xrr_minor;
    
    if (XRRQueryExtension (dpy, &xrr_event_base, &xrr_error_base) == False
        || XRRQueryVersion (dpy, &xrr_major, &xrr_minor) == 0
        || xrr_major != 1
        || xrr_minor < 1)
        return 0;
    
    return 1;
}

/**
  * Update the drawing area when we move to a new target (the crosshair needs
  * to be moved)
  */
void next_target()
{
    gtk_widget_queue_draw(da);    
    gdk_flush();
}


/**
  * Quit application on timeout 
  */ 
gboolean on_delayed_quit(gpointer data)
{ 
    gtk_main_quit();
    return FALSE;
}

/**
  * Handle a XCalibrate event
  */ 
GdkFilterReturn evt_filter(GdkXEvent *xevent, GdkEvent *event, gpointer data)
{
    XEvent *xev = (XEvent*)xevent;
    int ret;
    // check if this is a xcalibrate event
    if (xev->type==xcal_event_base && (!calibration_done)) 
    {
        XCalibrateRawTouchscreenEvent *tev = (XCalibrateRawTouchscreenEvent*)xev;
        ret = ts_handle_event (tev->x, tev->y, tev->pressure);
        // if we're done, save, disable xcalibrate, and quit
        if (ret==TS_CALIBRATION_DONE)
        {
            calibration_done = 1;
            ts_write_calibration (g_calfile);
            XCalibrateSetRawMode (dpy, False);
            // Show confirmation message
            next_target();
            g_timeout_add_seconds(flag_firstBoot ? 1 : 2, on_delayed_quit, NULL);
        }
    }
    return GDK_FILTER_CONTINUE;  
}

/**
  * Draw a cross icon on a widget
  */ 
static void draw_cross(GtkWidget *widget, gdouble x, gdouble y)
{
    int size = 8;

    if (!gc)
    {
        gc = gdk_gc_new(widget->window);
        gdk_gc_copy(gc, widget->style->black_gc);
        gdk_gc_set_line_attributes (gc, 2, GDK_LINE_SOLID, GDK_CAP_BUTT, GDK_JOIN_MITER);
    }
    gdk_draw_line(widget->window, gc, 
                  x-size, y-size, x+size, y+size);
    gdk_draw_line(widget->window, gc, 
                  x-size, y+size, x+size, y-size);
}

/**
  * Handle the drawing area expose event. Draw crosshair and text.
  */ 
static gboolean da_expose (GtkWidget *da, GdkEventExpose *evt, gpointer data)
{
    char *msg = NULL;
    
    if (calibration_done) 
    {
        msg = g_strdup(_("The stylus is now calibrated with this device."));
    }
    else
    {
        char *tip = NULL; 
        tip = _("Touch the center of each cross with the stylus as they appear on the screen.\n\n"
                "For the most accurate result, hold the stylus comfortably in your hand and "
                "touch the screen at the same angle as you would when you write with a regular "
                "pen on paper.");

        if (flag_firstBoot)
        {
            msg = g_strconcat(_("Before you continue, you need to calibrate the stylus. After this short "
                                "calibration, you will be able to work more accurately with the device.\n\n"), tip, NULL);
        }
        else
        {
            msg = g_strdup(tip);
        }
    }

    // draw text
    PangoLayout *layout = gtk_widget_create_pango_layout(da, msg);
    pango_layout_set_width(layout, pango_units_from_double(screen_x)*2/3);
    int x, y;
    int lw, lh;
    ts_get_target(0, &x, &y);
    pango_layout_get_pixel_size(layout, &lw, &lh);
    // top of text box = 
    //    centre point between top cross and middle cross ((screen_y/2)+y)/2
    //    -
    //    half height of text box (lh/2)
    int ypos = (((screen_y/2)+y)/2) - (lh/2); 
    pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
    gdk_draw_layout(da->window, da->style->black_gc, screen_x/6, ypos, layout);
    g_object_unref(layout);
    if (!calibration_done) 
    {
        // get crosshair locations and draw
        int x,y;
        ts_get_current_target(&x, &y);
        draw_cross(da, x, y);
    }
    g_free(msg);
    gdk_flush();
    return TRUE;
}


static gboolean my_gdk_flush(gpointer data)
{
    gdk_flush();
    return FALSE;
}

/**
  * Main
  */ 
int main (int argc, char *argv[])
{
    GtkWidget *window;
    int screen;

    // init domain for translations
    textdomain(GETTEXT_PACKAGE);

    // Initialise
    gtk_init(&argc, &argv);
    parse_args(argc, argv);
    if ((g_calfile = getenv("TSLIB_CALIBFILE")) == NULL)
    {
        g_calfile = g_defaultcalfile;
    }
    // read current calibration settings
    ts_read_current_settings(g_calfile);
    // create window
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window), PACKAGE " " VERSION);
    gtk_window_maximize(GTK_WINDOW(window));
    gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
    gtk_container_set_border_width(GTK_CONTAINER(window), 0);
    gtk_window_set_modal(GTK_WINDOW(window), TRUE);
    gtk_window_fullscreen(GTK_WINDOW(window));
    // add listener for XCalibrate events
    gdk_window_add_filter(NULL, evt_filter, NULL);
    // Get X Display
    GdkDisplay *gdpy = gdk_display_get_default();
    dpy = gdk_x11_display_get_xdisplay(gdpy);
    screen = DefaultScreen(dpy);
    // Create drawing area    
    da = gtk_drawing_area_new ();
    gtk_widget_set_size_request (da, screen_x, screen_y);
    gtk_container_add (GTK_CONTAINER (window), da);
    g_signal_connect (da, "expose_event", G_CALLBACK (da_expose), NULL);
    // Setup XCalibrate
    if (XCalibrateQueryExtension (dpy, &xcal_event_base, &xcal_error_base))
    {
        int r;   
        r = XCalibrateSetRawMode (dpy, True);
        if (r)
        {
            fprintf (stderr, "failed to set raw mode: error %d\n", r);
            exit (1);
        }
    } else {
        fprintf (stderr, "XCalibrate extension not available, unable to calibrate\n");
        exit (1);
    }
    // Setup XRandR
    if (xrandr_supported())
    {
        // read screen info
        XRRScreenConfiguration *rr_screen;
        XRRScreenSize *rr_sizes;
        int rr_num_sizes;
        Rotation current_rotation;
        rr_screen = XRRGetScreenInfo (dpy, RootWindow (dpy, screen));
        XRRRotations (dpy, screen, &current_rotation);
        rr_sizes = XRRSizes(dpy, screen, &rr_num_sizes);
        XRRFreeScreenConfigInfo (rr_screen);
        // set rotation
        switch (current_rotation)
        {
            case RR_Rotate_0:   rotation = 0; break;
            case RR_Rotate_90:  rotation = 90; break;
            case RR_Rotate_180: rotation = 180; break;
            case RR_Rotate_270: rotation = 270; break;
        }
        // set width/height if rotated
        if (rotation==90 || rotation==270)
        {
            screen_x = rr_sizes->height;
            screen_y = rr_sizes->width;
        }
        else
        {
            screen_x = rr_sizes->width;
            screen_y = rr_sizes->height;
        }
    }
    if (flag_debug)
    {
        fprintf (stderr, "Screen %dx%d rotated %d\n", screen_x, screen_y, rotation);
    }
    
    // initialise calibration structure
    ts_init(screen_x, screen_y, rotation);
    // show it
    gtk_widget_show_all(window);
    g_idle_add(my_gdk_flush, NULL);
    
    gtk_main();
    
    return 0;
}