Plot.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream 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.

   GTK+ IOStream 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 have received a copy of the GNU General Public License
   along with GTK+ IOStream
 */

#ifndef PLOT_H_
#define PLOT_H_

#ifdef _MSC_VER
typedef unsigned int uint;
#pragma warning( disable : 4554)
#endif

#include "ColourLineSpec.H"
#include "Table.H"
#include "Labels.H"

#include <iostream>
#include <glib-object.h>
#include <gtk/gtk.h>
#include <gtkdatabox.h>
#include <gtkdatabox_points.h>
#include <gtkdatabox_lines.h>
#include <gtkdatabox_regions.h>
#include <gtkdatabox_ruler.h>
#include <gtkdatabox_grid.h>
#include <gtkdatabox_markers.h>
#include <gtkdatabox_offset_bars.h>

#include <typeinfo>
#include <stdint.h>
//#include <vector>
//#include <stdlib.h>
//#include <string.h>

using namespace std;

class Plot : public Table {
    template<typename TYPE>
    GType findType(TYPE val) {
        if (strcmp(typeid(val).name(), typeid(float).name())==0)
            return G_TYPE_FLOAT;
        if (strcmp(typeid(val).name(), typeid(double).name())==0)
            return G_TYPE_DOUBLE;
        if (strcmp(typeid(val).name(), typeid(int).name())==0)
            return G_TYPE_INT;
        if (strcmp(typeid(val).name(), typeid(unsigned int).name())==0)
            return G_TYPE_UINT;
        if (strcmp(typeid(val).name(), typeid(long).name())==0)
            return G_TYPE_LONG;
        if (strcmp(typeid(val).name(), typeid(unsigned long).name())==0)
            return G_TYPE_ULONG;
        if (strcmp(typeid(val).name(), typeid(int64_t).name())==0)
            return G_TYPE_INT64;
        if (strcmp(typeid(val).name(), typeid(uint64_t).name())==0)
            return G_TYPE_UINT64;
        if (strcmp(typeid(val).name(), typeid(char).name())==0)
            return G_TYPE_CHAR;
        if (strcmp(typeid(val).name(), typeid(unsigned char).name())==0)
            return G_TYPE_UCHAR;
        return G_TYPE_INVALID;
    }
protected:
    GtkWidget *axis; 
    GtkDataboxGraph *gridGraph; 
    bool holdOn; 
    bool gridOn; 
public:

    Plot(void) {
        // We are going to manually place everything
        setHomogeneous(false);
        resize(5,4); // setup the default table to be x dimension : ylabel, yruler, plot, yruler, ylabel
        //                               y dimension : title, plot, xruler, xlabel

        axis=gtk_databox_new ();
        setOptions((GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK));
        setRegion(2,3,1,2); // put the plot in the middle
        *this<<axis; // put the plot in the middle

        GtkWidget *xRuler = gtk_databox_ruler_new (GTK_ORIENTATION_HORIZONTAL);
        //gtk_databox_ruler_set_scale_type (GTK_DATABOX_RULER (xRuler), GTK_DATABOX(axis)->priv->scale_type_x);
        gtk_databox_set_ruler_x (GTK_DATABOX(axis), GTK_DATABOX_RULER (xRuler));
        GtkWidget *yRuler = gtk_databox_ruler_new (GTK_ORIENTATION_VERTICAL);
        //gtk_databox_ruler_set_scale_type (GTK_DATABOX_RULER (yRuler), GTK_DATABOX(axis)->priv->scale_type_y);
        gtk_databox_set_ruler_y (GTK_DATABOX(axis), GTK_DATABOX_RULER (yRuler));

        setOptions((GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_FILL));
        setRegion(2,3,2,3);  // put the x axis on the bottom
        *this<<xRuler;
        setOptions((GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK));
        setRegion(1, 2, 1, 2); // put the y axis on the left
        *this<<yRuler;

        show();

        setBackground("w"); // default white colour

        gridGraph=NULL;
    }

    void setBackground(const char *clsStr) {
        setBackground(ColourLineSpec(clsStr));
    }

    void setBackground(ColourLineSpec cls) {
#if GTK_MAJOR_VERSION>2
        GdkRGBA gdkC=cls.getColour();
#else
        GdkColor gdkC=cls.getColour();
#endif
        setBackground(gdkC);
    }

#if GTK_MAJOR_VERSION>2
    void setBackground(const GdkRGBA gdkC) {
        gtk_widget_override_background_color(axis, GTK_STATE_FLAG_NORMAL, &gdkC);
#else
    void setBackground(const GdkColor gdkC) {
        gtk_widget_modify_bg(axis, GTK_STATE_NORMAL, &gdkC); // set the background
#endif
    }

    GtkWidget *gca(void) {
        return getCurrentAxis();
    }

    GtkWidget *getCurrentAxis(void) {
        return axis;
    }

    void show(void) {
        gtk_widget_show_all(axis);
        gtk_widget_show_all(getWidget());
    }
    void hide(void) {
        gtk_widget_hide(axis);
        gtk_widget_hide(getWidget());
    }

//#if GTK_MAJOR_VERSION>2
//    /* Plots the cnt y values at x to the axis, with a default blue colour
//        \param x The ordinates for plotting
//        \param y The co-ordinates for plotting
//        \param cnt The number of elements to plot
//        \return the graph which was just added.
//        \tparam XTYPE The type of the ordinate
//        \tparam YTYPE The type of the co-ordinate
//    */
//    template<typename XTYPE, typename YTYPE>
//    GtkDataboxGraph *plot(XTYPE *x, YTYPE *y, int cnt) {
//#else
    GtkDataboxGraph * plot(gfloat *x, gfloat *y, int cnt) {
//#endif
        ColourLineSpec cls;
        return plot(x, y, cnt, cls);
    }

//#if GTK_MAJOR_VERSION>2
//    /* Plots the cnt y values at x to the axis, with a specified colour and line type
//        \param x The ordinates for plotting
//        \param y The co-ordinates for plotting
//        \param cnt The number of elements to plot
//        \param clsChar The specification to be used with the ColourLineSpec class
//        \return the graph which was just added.
//        \tparam XTYPE The type of the ordinate
//        \tparam YTYPE The type of the co-ordinate
//    */
//    template<typename XTYPE, typename YTYPE>
//    GtkDataboxGraph *plot(XTYPE *x, YTYPE *y, int cnt, const char *clsChar) {
//#else
    GtkDataboxGraph *plot(gfloat *x, gfloat *y, int cnt, const char *clsChar) {
//#endif
        ColourLineSpec cls(clsChar);
        return plot(x, y, cnt, cls);
    }

//#if GTK_MAJOR_VERSION<3
    /* Plots the cnt y values at x to the axis
        \param x The ordinates for plotting
        \param y The co-ordinates for plotting
        \param cnt The number of elements to plot
        \param cls The ColourLineSpec class which determines the colour line type and size
        \return the graph which was just added.
    */
    GtkDataboxGraph *plot(gfloat *x, gfloat *y, int cnt, ColourLineSpec &cls) {
        if (!holdOn) {
            clf();
            if (gridOn)
                grid(gridOn);
        }

        //if (gtk_widget_get_realized (axis)){
        GtkDataboxGraph *graph=NULL;
#if GTK_MAJOR_VERSION>2
        GdkRGBA gdkC=cls.getColour();
#else
        GdkColor gdkC=cls.getColour();
#endif
        int size=cls.getSize();
        if (cls.linePlot)
            graph = gtk_databox_lines_new (cnt, x, y, &gdkC, size);
        else
            graph = gtk_databox_points_new (cnt, x, y, &gdkC, size);
        gtk_databox_graph_add_front (GTK_DATABOX (axis), graph);
        //}
        return graph;
    }
//#else
//    /* Plots the cnt y values at x to the axis
//        \param x The ordinates for plotting
//        \param y The co-ordinates for plotting
//        \param cnt The number of elements to plot
//        \param cls The ColourLineSpec class which determines the colour line type and size
//        \return the graph which was just added.
//        \tparam XTYPE The type of the ordinate
//        \tparam YTYPE The type of the co-ordinate
//    */
//    template<typename XTYPE, typename YTYPE>
//    GtkDataboxGraph *plot(XTYPE *x, YTYPE *y, int cnt, const ColourLineSpec &cls) {
//        if (cnt<=0)
//            return NULL;
//        GType xType, yType;
//        if ((xType=findType(x[0]))==G_TYPE_INVALID)
//            return NULL;
//        if ((yType=findType(y[0]))==G_TYPE_INVALID)
//            return NULL;
//
//        if (!holdOn) {
//            clf();
//            if (gridOn)
//                grid(gridOn);
//        }
//
//        GtkDataboxGraph *graph=NULL;
//#if GTK_MAJOR_VERSION>2
//        GdkRGBA gdkC=cls.getColour();
//#else
//        GdkColor gdkC=cls.getColour();
//#endif
//        int size=cls.getSize();
//        if (cls.linePlot)
//            graph = gtk_databox_lines_new_full (cnt, cnt, x, 0, 1, xType, y, 0, 1, yType, &gdkC, size);
//        else
//            graph = gtk_databox_points_new_full (cnt, cnt, x, 0, 1, xType, y, 0, 1, yType, &gdkC, size);
//        gtk_databox_graph_add_front (GTK_DATABOX (axis), graph);
//        return graph;
//    }
//#endif

    GtkDataboxGraph *plot(gfloat *x, gfloat *y1, gfloat *y2, int cnt) {
        ColourLineSpec cls;
        return plot(x, y1, y2, cnt, cls);
    }

    GtkDataboxGraph *plot(gfloat *x, gfloat *y1, gfloat *y2, int cnt, const char *clsChar) {
        ColourLineSpec cls(clsChar);
        return plot(x, y1, y2, cnt, cls);
    }

    GtkDataboxGraph *plot(gfloat *x, gfloat *y1,  gfloat *y2, int cnt, ColourLineSpec &cls) {
        if (!holdOn) {
            clf();
            if (gridOn)
                grid(gridOn);
        }

        //if (gtk_widget_get_realized (axis)) {
        GtkDataboxGraph *graph=NULL;
#if GTK_MAJOR_VERSION>2
        GdkRGBA gdkC=cls.getColour();
#else
        GdkColor gdkC=cls.getColour();
#endif
        int size=cls.getSize();
        if (cls.linePlot)
            graph = gtk_databox_regions_new (cnt, x, y1, y2, &gdkC);
        else
            graph = gtk_databox_offset_bars_new(cnt, x, y1, y2, &gdkC, size);
        gtk_databox_graph_add_front (GTK_DATABOX (axis), graph);
        //}
        return graph;
    }

    GtkDataboxGraph * semilogx(gfloat *x, gfloat *y, int cnt) {
        ColourLineSpec cls;
        return semilogx(x, y, cnt, cls);
    }

    GtkDataboxGraph * semilogx(gfloat *x, gfloat *y, int cnt, const char *clsChar) {
        ColourLineSpec cls(clsChar);
        return semilogx(x, y, cnt, cls);
    }

    GtkDataboxGraph *semilogx(gfloat *x, gfloat *y, int cnt, ColourLineSpec &cls) {
        GtkDataboxGraph *graph=plot(x, y, cnt, cls);
        gtk_databox_set_scale_type_x (GTK_DATABOX (axis), GTK_DATABOX_SCALE_LOG);
        return graph;
    }

    GtkDataboxGraph *semilogx(gfloat *x, gfloat *y1, gfloat *y2, int cnt) {
        ColourLineSpec cls;
        return semilogx(x, y1, y2, cnt, cls);
    }

    GtkDataboxGraph *semilogx(gfloat *x, gfloat *y1, gfloat *y2, int cnt, const char *clsChar) {
        ColourLineSpec cls(clsChar);
        return semilogx(x, y1, y2, cnt, cls);
    }

    GtkDataboxGraph *semilogx(gfloat *x, gfloat *y1, gfloat *y2, int cnt, ColourLineSpec &cls) {
        GtkDataboxGraph *graph=plot(x, y1, y2, cnt, cls);
        //if (gtk_widget_get_realized (axis))
        if (gtk_databox_get_scale_type_x(GTK_DATABOX (axis))!=GTK_DATABOX_SCALE_LOG)
            gtk_databox_set_scale_type_x (GTK_DATABOX (axis), GTK_DATABOX_SCALE_LOG);
        return graph;
    }

    GtkDataboxGraph *semilogy(gfloat *x, gfloat *y, int cnt) {
        ColourLineSpec cls;
        return semilogy(x, y, cnt, cls);
    }

    GtkDataboxGraph *semilogy(gfloat *x, gfloat *y, int cnt, const char *clsChar) {
        ColourLineSpec cls(clsChar);
        return semilogy(x, y, cnt, cls);
    }

    GtkDataboxGraph *semilogy(gfloat *x, gfloat *y, int cnt, ColourLineSpec &cls) {
        GtkDataboxGraph *graph=plot(x, y, cnt, cls);
        //if (gtk_widget_get_realized (axis))

        if (gtk_databox_get_scale_type_y(GTK_DATABOX (axis))!=GTK_DATABOX_SCALE_LOG)
            gtk_databox_set_scale_type_y (GTK_DATABOX (axis), GTK_DATABOX_SCALE_LOG);
        return graph;
    }

    GtkDataboxGraph *loglog(gfloat *x, gfloat *y, int cnt) {
        ColourLineSpec cls;
        return loglog(x, y, cnt, cls);
    }

    GtkDataboxGraph *loglog(gfloat *x, gfloat *y, int cnt, const char *clsChar) {
        ColourLineSpec cls(clsChar);
        return loglog(x, y, cnt, cls);
    }
    GtkDataboxGraph *loglog(gfloat *x, gfloat *y, int cnt, ColourLineSpec &cls) {
        GtkDataboxGraph *graph=plot(x, y, cnt, cls);
        if (gtk_databox_get_scale_type_x(GTK_DATABOX (axis))!=GTK_DATABOX_SCALE_LOG)
            gtk_databox_set_scale_type_x (GTK_DATABOX (axis), GTK_DATABOX_SCALE_LOG);
        if (gtk_databox_get_scale_type_y(GTK_DATABOX (axis))!=GTK_DATABOX_SCALE_LOG)
            gtk_databox_set_scale_type_y (GTK_DATABOX (axis), GTK_DATABOX_SCALE_LOG);
        return graph;
    }

    GtkDataboxGraph * text(gfloat *x, gfloat *y, const char *textDisp, const char *clsChar) {
        ColourLineSpec cls(clsChar);
        return text(x, y, textDisp, cls);
    }

    GtkDataboxGraph *text(gfloat *x, gfloat *y, const char *textDisp, ColourLineSpec &cls) {
#if GTK_MAJOR_VERSION>2
        GdkRGBA gdkC=cls.getColour();
#else
        GdkColor gdkC=cls.getColour();
#endif
        GtkDataboxGraph *graph = gtk_databox_markers_new (1, x, y, &gdkC, 1, GTK_DATABOX_MARKERS_NONE);
        bool boxed=false;
        gtk_databox_markers_set_label (GTK_DATABOX_MARKERS (graph), 0, GTK_DATABOX_MARKERS_TEXT_CENTER, (gchar*)textDisp, boxed);
        gtk_databox_graph_add_front (GTK_DATABOX (axis), graph);
        return graph;
    }

    void clear(void) {
        clf();
    }

    void clf(void) {
        //if (gtk_widget_get_realized (axis))
        gtk_databox_graph_remove_all(GTK_DATABOX (axis));
    }

    void hold(bool on) {
        holdOn=on;
    }

    void grid(bool on) {
        if (gridGraph) {
            GtkDataboxGrid *gridG=GTK_DATABOX_GRID(gridGraph);
            if (gtk_databox_grid_get_hline_vals(gridG)) { // reuse previously stored graph
                grid(on, gtk_databox_grid_get_hlines(gridG), gtk_databox_grid_get_hline_vals(gridG), gtk_databox_grid_get_vlines(gridG), gtk_databox_grid_get_vline_vals(gridG));
                return;
            }
        }
        grid(on, 5, NULL, 5, NULL);
    }

    void grid(bool on, int hCnt, gfloat *hLines, int vCnt, gfloat *vLines) {
        //if (gtk_widget_get_realized (axis))
        if (on) {
            if (gridGraph!=NULL) {
                gtk_databox_graph_remove(GTK_DATABOX (axis), gridGraph);
                gridGraph=NULL;
            }
            ColourLineSpec cls("a1"); // gray line of size 1
#if GTK_MAJOR_VERSION>2
            GdkRGBA gdkC=cls.getColour();
#else
            GdkColor gdkC=cls.getColour();
#endif
            int size=cls.getSize();
            if ((hLines!=NULL) & (vLines!=NULL))
                gridGraph=gtk_databox_grid_array_new(hCnt, vCnt, hLines, vLines, &gdkC, size);
            else
                gridGraph=gtk_databox_grid_new(hCnt, vCnt, &gdkC, size);
            gtk_databox_graph_add_front (GTK_DATABOX (axis), gridGraph);
        } else {
            if (gridGraph!=NULL) {
                gtk_databox_graph_remove(GTK_DATABOX (axis), gridGraph);
            }
        }
        gridOn=on;
    }

    void limits(float min_x, float max_x, float min_y, float max_y) {
        if (min_y==max_y) // fix if min and max y are the same
            if (min_y==0.)
                max_y=-(min_y=-1.);
            else
                max_y=(min_y=max_y*.9)/.9*1.1;
        if (min_x==max_x) // fix if max and min y are the same
            if (min_x==0.)
                max_x=-(min_x=-1.);
            else
                max_x=(min_x=max_x*.9)/.9*1.1;
        gtk_databox_set_total_limits (GTK_DATABOX (axis), min_x, max_x, max_y, min_y);
    }

    void limits(gfloat border=0.) {
        // guard against a plot with no real limits in either or both axes.
        gfloat min_x, max_x, min_y, max_y;
        gint extrema_success = gtk_databox_calculate_extrema (GTK_DATABOX (axis), &min_x, &max_x, &min_y, &max_y);
        if (min_x==max_x==0.)
            if (min_y==max_y==0.)
                limits(0.,1.,0.,1.);
            else
                limits(min_x-(max_y-min_y)*.1, max_x-(max_y-min_y)*.1,min_y,max_y);
        else if (min_y==max_y==0.)
            limits(min_x, max_x, min_y-(max_x-min_x)*.1, max_y-(max_x-min_x)*.1);

        gtk_databox_auto_rescale(GTK_DATABOX (axis), border);
    }

    void replot(void) {
        if (gtk_widget_is_drawable (GTK_WIDGET (axis)))
            gtk_widget_queue_draw (GTK_WIDGET (axis));
    }

    void set(GtkWidget *widget, ...) {
        va_list args;
        va_start(args, widget);
        //cout<<"starting"<<endl;
        while (1) { // terminates when a null is read
            char *token=va_arg(args, char *);
            if ((token==NULL) | (token==(char *)'\0'))
                break;

            // first attempt to process non-axis (box) settings
            if ((strcmp(&token[1],"oxShadow")==0) | (strcmp(&token[1],"oxshadow")==0))
                gtk_databox_set_box_shadow(GTK_DATABOX(widget), (GtkShadowType)va_arg(args, int));
            else if ((strcmp(&token[1],"Scale")==0) | (strcmp(&token[1],"scale")==0)) {
                char *linearOrLog=va_arg(args, char*);
                if (tolower(token[0])=='x') {
                    if (strcmp(&linearOrLog[1],"og")==0) // check for the right keyword
                        gtk_databox_set_scale_type_x (GTK_DATABOX (axis), GTK_DATABOX_SCALE_LOG);
                    else
                        gtk_databox_set_scale_type_x (GTK_DATABOX (axis), GTK_DATABOX_SCALE_LINEAR);
                }
                if (tolower(token[0])=='y') {
                    if (strcmp(&linearOrLog[1],"og")==0) // check for the right keyword
                        gtk_databox_set_scale_type_y (GTK_DATABOX (axis), GTK_DATABOX_SCALE_LOG);
                    else
                        gtk_databox_set_scale_type_y (GTK_DATABOX (axis), GTK_DATABOX_SCALE_LINEAR);
                }
            } else {
                // process axis (ruler) settings
                GtkDataboxRuler *ruler;
                bool xRuler=1;
                if (tolower(token[0])=='x')
                    ruler=gtk_databox_get_ruler_x(GTK_DATABOX (widget));
                else {
                    ruler=gtk_databox_get_ruler_y(GTK_DATABOX (widget));
                    xRuler=0;
                }

                if ((strcmp(&token[1],"MinorTick")==0) | (strcmp(&token[1],"minortick")==0)) {

                    int draw_ticks=va_arg(args, int);
                    gtk_databox_ruler_set_draw_subticks(ruler,draw_ticks);

                } else if ((strcmp(&token[1],"Tick")==0) | (strcmp(&token[1],"tick")==0)) {
                    uint manual_tick_cnt=va_arg(args, int);
                    if (manual_tick_cnt==0)
                        gtk_databox_ruler_set_draw_ticks(ruler,manual_tick_cnt);
                    else {
                        gtk_databox_ruler_set_manual_tick_cnt(ruler, manual_tick_cnt);
                        gtk_databox_ruler_set_manual_ticks(ruler, va_arg(args, gfloat*));
                    }
                } else if ((strcmp(&token[1],"LabelFormat")==0) | (strcmp(&token[1],"labelformat")==0)) {
                    int scaleType;
                    if (xRuler)
                        scaleType=gtk_databox_get_scale_type_x(GTK_DATABOX (widget));
                    else
                        scaleType=gtk_databox_get_scale_type_y(GTK_DATABOX (widget));

                    if (scaleType==GTK_DATABOX_SCALE_LINEAR) // set the label format
                        gtk_databox_ruler_set_linear_label_format(ruler, va_arg(args, char*));
                    else
                        gtk_databox_ruler_set_log_label_format(ruler, va_arg(args, char*));

                } else if ((strcmp(&token[1],"LabelLength")==0) | (strcmp(&token[1],"labellength")==0)) {
                    int scaleType;
                    if (xRuler)
                        scaleType=gtk_databox_get_scale_type_x(GTK_DATABOX (widget));
                    else
                        scaleType=gtk_databox_get_scale_type_y(GTK_DATABOX (widget));

                    gtk_databox_ruler_set_max_length(ruler, va_arg(args, int));
                } else if ((strcmp(&token[1],"LabelLength")==0) | (strcmp(&token[1],"labellength")==0)) {
                    gtk_databox_ruler_set_max_length(ruler, va_arg(args, int));
                } else if ((strcmp(&token[1],"TickLabel")==0) | (strcmp(&token[1],"ticklabel")==0)) {
                    gtk_databox_ruler_set_manual_tick_labels(ruler, (gchar**)va_arg(args, gchar**));
                } else if ((strcmp(&token[1],"TickXOffset")==0) | (strcmp(&token[1],"tickxoffset")==0)) {
                    gtk_databox_ruler_set_text_hoffset(ruler, va_arg(args, int));
                } else if ((strcmp(&token[1],"Position")==0) | (strcmp(&token[1],"position")==0)) {
                    gtk_databox_ruler_set_draw_position(ruler, va_arg(args, int));
                } else if ((strcmp(&token[1],"Shadow")==0) | (strcmp(&token[1],"shadow")==0)) {
                    gtk_databox_ruler_set_box_shadow(ruler, (GtkShadowType)va_arg(args, int));
                } else if ((strcmp(&token[1],"LabelAlignment")==0) | (strcmp(&token[1],"labelalignment")==0)) {
                    char *which=va_arg(args, char*);
                    if (strcmp(&which[1],"ight")==0) // check for the right keyword
                        gtk_databox_ruler_set_text_alignment(ruler, PANGO_ALIGN_RIGHT);
                    else if (strcmp(&which[1],"enter")==0) // check for the center keyword
                        gtk_databox_ruler_set_text_alignment(ruler, PANGO_ALIGN_CENTER);
                    else // left aligned which is standard
                        gtk_databox_ruler_set_text_alignment(ruler, PANGO_ALIGN_LEFT);
                } else if ((strcmp(&token[1],"LabelRotate")==0) | (strcmp(&token[1],"labelrotate")==0)) {
                    char *which=va_arg(args, char*);
                    if (strcmp(&which[1],"ertical")==0) // check for the vertical keyword
                        gtk_databox_ruler_set_text_orientation(ruler, GTK_ORIENTATION_VERTICAL);
                    else
                        gtk_databox_ruler_set_text_orientation(ruler, GTK_ORIENTATION_HORIZONTAL);
                }

                if (tolower(token[0])=='x')
                    gtk_databox_set_ruler_x(GTK_DATABOX (widget), ruler);
                else
                    gtk_databox_set_ruler_y(GTK_DATABOX (widget), ruler);
            }
        }
        va_end(args);
    }

    void connectAfter(const char *event, GCallback callback, gpointer data) {
        g_signal_connect_after(axis, event, callback, data);
    }

    void xLabel(const char* label, int *indexes=NULL) {
        if (indexes==NULL) {
            setRegion(2, 3, 3, 4);
            setOptions((GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_FILL));
        } else
            *this<<indexes;
        *this<<(Labels()<<label).setAlignment(0.5, 0.5);
    }

    void xLabelBL(const char* label) {
        setOptions((GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL | GTK_SHRINK));
        int indexes[]= {1,2,2,3};
        xLabel(label,indexes);
    }

    void yLabel(const char* label, int *indexes=NULL) {
        Labels ylabel;
        ylabel<<label;
        if (indexes==NULL) {
            setRegion(0, 1, 1, 2);
            setOptions((GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK));
            ylabel.setAngle(90.0);
        } else
            *this<<indexes;
        ylabel.setAlignment(0.5, 0.5);
        *this<<ylabel.current();
    }

    void yLabelTL(const char* label) {
        setOptions((GtkAttachOptions)(GTK_FILL | GTK_SHRINK), (GtkAttachOptions)(GTK_FILL));
        int indexes[]= {1,2,0,1};
        yLabel(label,indexes);
    }

    void title(const char* titleStr, int *indexes=NULL) {
        Labels labels;
        labels<<titleStr;
        labels.setAlignment(0.5, 0.5);
        title(labels.getWidget(), indexes);
    }

    void title(GtkWidget *widget, int *indexes=NULL) {
        if (indexes==NULL) {
            setRegion(2, 3, 0, 1);
            setOptions((GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_FILL));
        } else
            *this<<indexes;
        *this<<widget;
    }
//static bool expose(GtkWidget *widget, GdkEventExpose *event, gpointer data){
//    Plot*p=static_cast<Plot*>(data);
//    p->replot();
//    return false;
//}
//    cout<<"Plot::expose"<<endl;
//    if (gtk_widget_get_realized (axis))
//        return false;
//        else
//        return true;
//}
    void remove(GtkDataboxGraph *toRemove) {
        gtk_databox_graph_remove (GTK_DATABOX (axis), toRemove);
    }

    Plot &operator>>(GtkDataboxGraph *toRemove) {
        remove(toRemove);
        return *this;
    }

    gfloat pixelToX(gint16 pixel) {
        return gtk_databox_pixel_to_value_x(GTK_DATABOX (axis), pixel);
    }

    gfloat pixelToY(gint16 pixel) {
        return gtk_databox_pixel_to_value_y(GTK_DATABOX (axis), pixel);
    }
};
#endif //PLOT_H_