plot_gtk.c

/*
 * @(#)plot_gtk.c       07/04/14
 * 
 * Description  : used to plot points
 * License      : GNU GPL v.2
 * Author       : Tran Duy Khanh (www.tran.cz)
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <laser-nav.h>
#include "plot_gtk.h"

struct pln_point positions[FWIDTH*FHEIGHT];
int poscount = 0;

void print_usage()
{
        fprintf(file_err, "Used to plot points in GTK. GNU GPL v.2.\n"
                        "CTU FEE in Prague - Department of "
                        "Control Engineering\n\n");
        fprintf(file_err, "Usage :  [options]\n\n");
        fprintf(file_err, "    -g\t\tTest the GTK graphic part\n");
        fprintf(file_err, "    -h\t\tThis help\n");
        fprintf(file_err, "    -t\t\tText mode only\n");
        fprintf(file_err, "\n");

        exit(0);
}

int parseopt(int argc, char **argv)
{
        int ch;
        
        file_out = stdout;
        file_err = stderr;

        optind = 0;
        /* parse the program arguments */
        while ((ch = getopt(argc, argv, "ght")) != -1) {
                switch(ch) {
                        /* test GTK graphic part */
                        case 'g':       option.opt_flag |= OPT_GTK_TEST;
                                        test_animation(argc, argv);
                                        break;
                        /* print program usage */
                        case 'h':       print_usage(); break;
                        /* text output only. No GTK. */
                        case 't':       option.opt_flag |= OPT_TEXT_MODE;
                                        break;
                        default:        print_usage(); break;
                }
        }
        
        return 0;
}

/****************************************************************************
 * GTK Graphic stuffs.
 ****************************************************************************
 */

/* Get out of the aplication */
void quit ()
{
        gtk_exit (0);
}

/*void get_size (GdkPixmap *xpm, unsigned int *width, unsigned int *height)
{
}*/

void load_pixmaps (GtkWidget *widget, struct moveable_obj *moveable, 
                                    struct pixmap_obj *pixmaps)
{
        int i = 0;
        
        /* Get every sequence */
        while (pixmaps[i].xpm_filename) {
                /* Convert xpm data to pixmap & mask */
                pixmaps[i].pixmap = gdk_pixmap_create_from_xpm(widget->window, 
                                        NULL, NULL, pixmaps[i].xpm_filename);
                i++;
        }

        /* Get sprite height and width */
        /* get_size(pixmaps[0].pixmap, &pixmaps[0].width, &pixmaps[0].height); */
        
        /* Initialize sprite information */
        pixmaps->seq_count = i;
}

void load_scene_pixmap(GtkWidget *widget)
{
        /* load background, sample pixmaps */
        load_pixmaps(widget, moveable, xpm_background);
        load_pixmaps(widget, moveable, xpm_sample);
}

static gboolean key_event(GtkWidget *widget, GdkEventKey *event)
{
        GdkModifierType state;

        switch (event->keyval) {
                /* left */
                case 65361:
                        break;
                /* right */
                case 65363:
                        break;
                /* up */
                case 65362:
                        break;
                /* down */
                case 65364:
                        break;
                /* enter */
                case 65293:
                        break;
                /* quit */
                case 'q':
                case 'Q':
                case 65307:
                        quit();
        }
        
        return TRUE;
}

static gboolean button_event(GtkWidget *widget, GdkEventMotion *event)
{
        int x, y;
        GdkModifierType state;

        /* get the position mouse state */
        if (event->is_hint) 
                gdk_window_get_pointer (event->window, &x, &y, &state);
        else {
                x = event->x;
                y = event->y;
                state = event->state;
        }

        return TRUE;
}

static gboolean motion_notify_event( GtkWidget *widget, GdkEventMotion *event)
{
        int x, y;
        GdkModifierType state;

        if (event->is_hint) 
                gdk_window_get_pointer (event->window, &x, &y, &state);
        else {
                x = event->x;
                y = event->y;
                state = event->state;
        }
  
        return TRUE;
}

static gint configure_event (GtkWidget *widget, GdkEventConfigure *event)
{
        /* Free background if we created it */
        if (xpm_scene) {
                gdk_pixmap_unref (xpm_scene);
        } 

        /* Create a new pixmap with new size */
        xpm_scene = gdk_pixmap_new (widget->window,
                        widget->allocation.width,
                        widget->allocation.height,
                        -1);
        
        return TRUE;
}

gint expose_event (GtkWidget *widget, GdkEventExpose *event)
{
        int i;
        
        /* Copy pixmap to the window */
        gdk_draw_pixmap (widget->window,
                widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
                xpm_scene,
                event->area.x, event->area.y,
                event->area.x, event->area.y,
                event->area.width, event->area.height);
        
        return FALSE;
}

void (*repaint_objects)();

gint repaint (gpointer data)
{
        GtkWidget  *drawing_area = (GtkWidget *)data;
        GdkRectangle update_rect;
        
        /*test_repaint();*/
        (*repaint_objects)();
        
        /* The whole screen needs to be updated */
        update_rect.x = 0;
        update_rect.y = 0;
        update_rect.width = drawing_area->allocation.width;
        update_rect.height = drawing_area->allocation.height;
        
        /* So update it */
        gtk_widget_draw (drawing_area, &update_rect);
}

void test_repaint()
{
        int i;
        
        /* clear pixmap (background image) */
        gdk_draw_drawable (xpm_scene,
                drawing_area->style->fg_gc[GTK_WIDGET_STATE (drawing_area)],
                xpm_background[0].pixmap,
                0, 0,
                0, 0,
                drawing_area->allocation.width,
                drawing_area->allocation.height);
}

void init_animation(int argc, char *argv[], void (*repaint_func)())
{
        /* Initialize GTK */
        gtk_init (&argc, &argv);
        
        /* Create the top level window */
        window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
        
        gtk_signal_connect (GTK_OBJECT (window), "destroy",
                                GTK_SIGNAL_FUNC (quit), NULL);
        
        /* Create the drawing area */
        drawing_area = gtk_drawing_area_new ();
        gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 
                                xpm_background[0].width, 
                                xpm_background[0].height);
        gtk_container_add (GTK_CONTAINER (window), drawing_area);

        gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
                                (GtkSignalFunc) expose_event, NULL);
        gtk_signal_connect (GTK_OBJECT(drawing_area),"configure_event",
                                (GtkSignalFunc) configure_event, NULL);
        gtk_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event",
                                (GtkSignalFunc) motion_notify_event, NULL);
        gtk_signal_connect (GTK_OBJECT(drawing_area),"button_press_event",
                                (GtkSignalFunc) button_event, NULL);
        gtk_signal_connect (GTK_OBJECT(drawing_area),"button_release_event",
                                (GtkSignalFunc) button_event, NULL);
        gtk_signal_connect (GTK_OBJECT(window),"key_press_event",
                                (GtkSignalFunc) key_event, NULL);


        gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
                                | GDK_LEAVE_NOTIFY_MASK
                                | GDK_BUTTON_PRESS_MASK
                                | GDK_POINTER_MOTION_MASK
                                | GDK_POINTER_MOTION_HINT_MASK);

        gtk_widget_show(drawing_area);
        gtk_widget_show(window);

        /* Repaint every so often */
        gtk_timeout_add (SCENE_REFRESH, repaint, drawing_area);
        repaint_objects = repaint_func;
        
        /* Load all scene pixmaps */
        load_scene_pixmap(window);
        
        /* Call gtk-main loop */
        gtk_main();
}

void test_animation(int argc, char *argv[])
{
        init_animation(argc, argv, test_repaint);
}

void scene_repaint()
{
        int i;
        int x;
        
        /* clear pixmap (background image) */
        gdk_draw_drawable (xpm_scene,
                drawing_area->style->fg_gc[GTK_WIDGET_STATE (drawing_area)],
                xpm_background[0].pixmap,
                0, 0,
                0, 0,
                drawing_area->allocation.width,
                drawing_area->allocation.height);

        /* draw the points */
        for (i=0; i<poscount; i++) {
                gdk_draw_drawable (xpm_scene,
                        drawing_area->style->fg_gc[GTK_WIDGET_STATE (drawing_area)],
                        xpm_sample[4].pixmap,
                        0, 0,
                        (int)(positions[i].x/FWIDTH*(632-2*BORDER)+BORDER) 
                                                - xpm_sample[0].height/2,
                        (int)((FHEIGHT-positions[i].y)/FHEIGHT*(452-2*BORDER)+BORDER) 
                                                - xpm_sample[0].width/2, 
                        drawing_area->allocation.width,
                        drawing_area->allocation.height);
        }                                
}

/* end of the GTK stuffs.
 ****************************************************************************/

void initdata()
{
        double a=(double)0.287430, b=(double)0.1, c;
        /* init mutex */
        pthread_mutex_init(&plot_mutex, NULL);

//      test_angles(positions, &poscount);
//      printf("(poscount=%d)\n", poscount);
//      test_coordination();
//      test_sel_angles();
        test_cal_position(positions, &poscount);

        /*pthread_mutex_lock(&plot_mutex);
        pthread_mutex_unlock(&plot_mutex);*/
}

void destroydata()
{
        pthread_mutex_destroy(&plot_mutex);
}

int main(int _argc, char **_argv)
{
        argc = _argc;
        argv = _argv;
        
        /* parse program options */
        parseopt(argc, argv);
        
        /* data initialization */
        initdata();

        if (!(option.opt_flag & OPT_TEXT_MODE)) {
                /* run animation initialization */
                init_animation(argc, argv, scene_repaint);
        }
        
        /* destroy data (mutex, ...) */
        destroydata();
        
        return 0;
}

---