gtktscal/main.c File Reference

#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"

Include dependency graph for gtktscal/main.c:

Go to the source code of this file.

Functions
void	usage (const char *name)
void	parse_args (int argc, char *argv[])
int	xrandr_supported ()
void	next_target ()
gboolean	on_delayed_quit (gpointer data)
GdkFilterReturn	evt_filter (GdkXEvent *xevent, GdkEvent *event, gpointer data)
static void	draw_cross (GtkWidget *widget, gdouble x, gdouble y)
static gboolean	da_expose (GtkWidget *da, GdkEventExpose *evt, gpointer data)
static gboolean	my_gdk_flush (gpointer data)
int	main (int argc, char *argv[])
Variables
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

---

Function Documentation

static gboolean da_expose	(	GtkWidget *	da,
		GdkEventExpose *	evt,
		gpointer	data
	)			[static]

Handle the drawing area expose event. Draw crosshair and text.

Definition at line 219 of file gtktscal/main.c.

References calibration_done, draw_cross(), flag_firstBoot, msg, screen_x, screen_y, ts_get_current_target(), and ts_get_target().

Referenced by main().

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void draw_cross	(	GtkWidget *	widget,
		gdouble	x,
		gdouble	y
	)			[static]

Draw a cross icon on a widget

Definition at line 200 of file gtktscal/main.c.

References gc.

Referenced by da_expose().

{
    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);
}

Here is the caller graph for this function:

GdkFilterReturn evt_filter	(	GdkXEvent *	xevent,
		GdkEvent *	event,
		gpointer	data
	)

Handle a XCalibrate event

Definition at line 174 of file gtktscal/main.c.

References calibration_done, dpy, flag_firstBoot, g_calfile, next_target(), on_delayed_quit(), TS_CALIBRATION_DONE, ts_handle_event(), ts_write_calibration(), and xcal_event_base.

Referenced by main().

{
    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;  
}

Here is the call graph for this function:

Here is the caller graph for this function:

int main	(	int	argc,
		char *	argv[]
	)

Main

Definition at line 283 of file gtktscal/main.c.

References da, da_expose(), dpy, evt_filter(), flag_debug, g_calfile, g_defaultcalfile, GETTEXT_PACKAGE, my_gdk_flush(), parse_args(), rotation, screen_x, screen_y, ts_init(), ts_read_current_settings(), xcal_error_base, xcal_event_base, and xrandr_supported().

{
    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;
}

Here is the call graph for this function:

static gboolean my_gdk_flush

(

gpointer

data

)

[static]

Definition at line 274 of file gtktscal/main.c.

Referenced by main().

{
    gdk_flush();
    return FALSE;
}

Here is the caller graph for this function:

void next_target

(

)

Update the drawing area when we move to a new target (the crosshair needs to be moved)

Definition at line 155 of file gtktscal/main.c.

References da.

Referenced by evt_filter(), and ts_handle_event().

{
    gtk_widget_queue_draw(da);    
    gdk_flush();
}

Here is the caller graph for this function:

gboolean on_delayed_quit

(

gpointer

data

)

Quit application on timeout

Definition at line 165 of file gtktscal/main.c.

Referenced by evt_filter().

{ 
    gtk_main_quit();
    return FALSE;
}

Here is the caller graph for this function:

void parse_args	(	int	argc,
		char *	argv[]
	)

Parse commandline args

Definition at line 86 of file gtktscal/main.c.

References flag_debug, flag_firstBoot, flag_sanityCheck, rotation, ts_set_calibration(), ts_show_calibration(), and usage().

Referenced by main().

{
    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]);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void usage

(

const char *

name

)

Show usage

Definition at line 71 of file gtktscal/main.c.

Referenced by main(), parse_args(), parse_arguments(), and update_sd_widgets().

{
    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);
}

Here is the caller graph for this function:

int xrandr_supported

(

)

Check for XRandR

Definition at line 137 of file gtktscal/main.c.

References dpy.

Referenced by main().

{
    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;
}

Here is the caller graph for this function:

---

Variable Documentation

int calibration_done = 0

Definition at line 62 of file gtktscal/main.c.

Referenced by da_expose(), and evt_filter().

GtkWidget* da

Definition at line 63 of file gtktscal/main.c.

Referenced by main(), and next_target().

Display* dpy

Definition at line 53 of file gtktscal/main.c.

Referenced by evt_filter(), main(), and xrandr_supported().

int flag_debug = 0

Definition at line 56 of file gtktscal/main.c.

Referenced by main(), parse_args(), perform_calibration(), ts_handle_event(), ts_set_calibration(), ts_write_calibration(), and validate_input().

int flag_firstBoot = 0

Definition at line 58 of file gtktscal/main.c.

Referenced by da_expose(), evt_filter(), and parse_args().

int flag_sanityCheck = 1

Definition at line 57 of file gtktscal/main.c.

Referenced by parse_args(), and ts_handle_event().

char* g_calfile = NULL

Definition at line 65 of file gtktscal/main.c.

Referenced by evt_filter(), and main().

char* g_defaultcalfile = "/home/root/.pointercal"

Definition at line 64 of file gtktscal/main.c.

Referenced by main().

GdkGC* gc = NULL

Definition at line 66 of file gtktscal/main.c.

Referenced by draw_cross(), my_expose(), pagebar_draw_cpi_overview(), and pagebar_draw_details().

int rotation = 0

Definition at line 59 of file gtktscal/main.c.

Referenced by images::ImagePage::calc_desired_dimension(), event_gconf_value_changed(), pdf::PDFController::get_page_crop_height(), pdf::PDFController::get_page_crop_width(), pdf::PDFController::get_page_original_rotation(), notepad::ipc_get_rotation(), load_rotation_settings(), main(), parse_args(), and set_startup_defaults().

int screen_x = 768

Definition at line 54 of file gtktscal/main.c.

Referenced by da_expose(), and main().

int screen_y = 1024

Definition at line 55 of file gtktscal/main.c.

Referenced by da_expose(), and main().

int xcal_error_base

Definition at line 60 of file gtktscal/main.c.

Referenced by main().

int xcal_event_base

Definition at line 61 of file gtktscal/main.c.

Referenced by evt_filter(), and main().