//--------------------------------------------------------------------------
// Copyright (C) 2004  Andrew Ross
// Copyright (C) 2004  Alan W. Irwin
//
// This file is part of PLplot.
//
// PLplot is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; version 2 of the License.
//
// PLplot 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 Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with PLplot; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
//--------------------------------------------------------------------------
//
//--------------------------------------------------------------------------
// Implementation of PLplot example 1 in C++.
//--------------------------------------------------------------------------

#include "plc++demos.h"

#include "plevent.h"
#include <cctype>

#ifdef PL_HAVE_NANOSLEEP
#include <time.h>
#endif

#ifdef PL_HAVE_UNISTD_H
#include <unistd.h>
#endif

#ifdef PL_USE_NAMESPACE
using namespace std;
#endif

static PLGraphicsIn gin;

static int          locate_mode;
static int          test_xor;
static int          fontset;
static char* f_name;

static const char* notes[] = { "Make sure you get it right!", "" };

// Options data structure definition.
static PLOptionTable options[] = {
    {
        "locate",               // Turns on test of API locate function
        NULL,
        NULL,
        &locate_mode,
        PL_OPT_BOOL,
        "-locate",
        "Turns on test of API locate function"
    },
    {
        "xor",                  // Turns on test of xor function
        NULL,
        NULL,
        &test_xor,
        PL_OPT_BOOL,
        "-xor",
        "Turns on test of XOR"
    },
    {
        "font",                 // For switching between font set 1 & 2
        NULL,
        NULL,
        &fontset,
        PL_OPT_INT,
        "-font number",
        "Selects stroke font set (0 or 1, def:1)"
    },
    {
        "save",                 // For saving in postscript
        NULL,
        NULL,
        &f_name,
        PL_OPT_STRING,
        "-save filename",
        "Save plot in color postscript `file'"
    },
    {
        NULL,                   // option
        NULL,                   // handler
        NULL,                   // client data
        NULL,                   // address of variable to set
        0,                      // mode flag
        NULL,                   // short syntax
        NULL
    }                           // long syntax
};


class x01 {
public:
    x01(int, char**);

    void plot1(int);
    

private:
    // Class data
    PLFLT    xscale, yscale, xoff, yoff;
    plstream* pls;
};


x01::x01(int argc, char** argv)
{
    char ver[80];

    fontset = 1;
    f_name = NULL;


    // plplot initialization
    // Divide page into 2x2 plots unless user overrides.

    pls = new plstream();

    // Parse and process command line arguments.
    pls->MergeOpts(options, "x01c options", notes);
    pls->parseopts(&argc, argv, PL_PARSE_FULL);

    // Print out version number, just for kicks.
    pls->gver(ver);

    cout << "PLplot library version: " << ver << endl;


    // Initialize PLplot.
    pls->star(2, 2);

    // Select the multi-stroke font.
    pls->fontld(1);

    // Set up the data
    // Original case

    xscale = 6.;
    yscale = 1.;
    xoff = 0.;
    yoff = 0.;

    // Do a plot
    while (1)
    {
        plot1(0);
    }

    
    delete pls;
}

void x01::plot1(int do_test)
{
    int   i;
    PLFLT xmin, xmax, ymin, ymax;
    PLFLT* x = new PLFLT[60];
    PLFLT* y = new PLFLT[60];
    PLFLT* xs = new PLFLT[6];
    PLFLT* ys = new PLFLT[6];

    for (i = 0; i < 60; i++)
    {
        x[i] = xoff + xscale * (i + 1) / 60.0;
        y[i] = yoff + yscale * pow(x[i], 2.);
    }

    xmin = x[0];
    xmax = x[59];
    ymin = y[0];
    ymax = y[59];

    for (i = 0; i < 6; i++)
    {
        xs[i] = x[i * 10 + 3];
        ys[i] = y[i * 10 + 3];
    }

    // Set up the viewport and window using PLENV. The range in X is 0.0 to
    // 6.0, and the range in Y is 0.0 to 30.0. The axes are scaled separately
    // (just = 0), and we just draw a labelled box (axis = 0).
    
    pls->adv(1);
    pls->clear();
    pls->vpor(0.12, 0.98, 0.15, 0.88);
    pls->col0(1);
    //pls->env(xmin, xmax, ymin, ymax, 0, 0);
    pls->wind(xmin, 2 * xmax, ymin - (ymax - ymin) * 0.4, ymax + (ymax - ymin) * 0.4);
    pls->box("bcfnst", 0.0, 0, "bcnstv", 0.0, 0);
    pls->col0(2);
    pls->lab("(x)", "(y)", "#frPLplot Example 1 - y=x#u2");

    // Plot the data points.

    pls->col0(4);
    pls->poin(6, xs, ys, 9);

    // Draw the line through the data.

    pls->col0(3);
    pls->line(60, x, y);

    // xor mode enable erasing a line/point/text by replotting it again
    // it does not work in double buffering mode, however

    if (do_test && test_xor)
    {
#ifdef PL_HAVE_NANOLEEP
        bool            st;
        struct timespec ts;
        ts.tv_sec = 0;
        ts.tv_nsec = 50000000;
        pls->xormod(true, &st); // enter xor mode
        if (st)
        {
            for (i = 0; i < 60; i++)
            {
                pls->poin(1, x + i, y + i, 9);   // draw a point
                nanosleep(&ts, NULL);            // wait a little
                pls->flush();                      // force an update of the tk driver
                pls->poin(1, x + i, y + i, 9);   // erase point
            }
            pls->xormod(false, &st);             // leave xor mode
        }
#else
        cout << "The -xor command line option can only be exercised if your system has nanosleep(), which does not seems to happen." << endl;
#endif
    }

    delete[] x;
    delete[] y;
    delete[] xs;
    delete[] ys;
}


int main(int argc, char** argv)
{
    x01* x = new x01(argc, argv);
    delete x;
}


//--------------------------------------------------------------------------
//                              End of x01.cc
//--------------------------------------------------------------------------