// x_plot_d.cc

#include "x_plot_d.h"
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <cstring>

//float my_scale = 6.0;
extern float my_scale;

int XCenter = 320;
int YCenter = 200;
int Yflip; /* make Y = 0.0 at bottom */
/***************** global variables **************************/
Display *dpy;
Window window1;
GC gc, gc_clear;
Screen *screen;

static void doInitialize(void);          /* function prototypes used below */
static void doCreateWindows(void);
static void doCreateGraphicsContext(void);
static void doHandleEvents(void);
static void redraw(void);


/***************** doInitialize **************************/
static void doInitialize(void)
{
    XEvent event;

    dpy = XOpenDisplay(0);	
    if (!dpy){
        // printf("Display not opened!\n");
        exit(-1);
    }
    screen = XDefaultScreenOfDisplay(dpy);

    doCreateWindows();

    doCreateGraphicsContext();

    XStoreName(dpy, window1, "X_Plot Demo");

    XMapWindow(dpy, window1);

    for ( ; ; ) {
        XNextEvent(dpy, &event);
        switch (event.type) {
            case Expose:       /* must wait for Expose to draw */
	         // printf("Expose in init \n");
                 return;
        } /* end switch */
    }
} 

/******* doCreateWindows *********/
static void doCreateWindows(void)
{   
    int window1X = 100;
    int window1Y = 100;
    int window1W = 2*XCenter;
    int window1H = 2*YCenter;
    XSetWindowAttributes xswa;
                   
    Yflip = window1H;

    /* Create the window1 window */
    xswa.event_mask = ExposureMask | ButtonPressMask | 
                      Button1MotionMask | ButtonReleaseMask;

    xswa.background_pixel = XWhitePixelOfScreen(screen);

    window1 = XCreateWindow(dpy,
                            XRootWindowOfScreen(screen),
	                    window1X, 
                            window1Y,
                            window1W,
                            window1H,
                            0,
                            XDefaultDepthOfScreen(screen),
                            InputOutput,
                            XDefaultVisualOfScreen(screen),
                            CWEventMask | CWBackPixel,
                            &xswa);
}
    

/******** Create the graphics context *********/    
static void doCreateGraphicsContext(void)
{                                                
    XGCValues xgcv;
    
    /* Create graphics context. */
    xgcv.foreground = XBlackPixelOfScreen(screen);
    xgcv.background = XWhitePixelOfScreen(screen);
    gc = XCreateGC(dpy, window1, GCForeground | GCBackground, &xgcv);   
    xgcv.background = XBlackPixelOfScreen(screen);
    xgcv.foreground = XWhitePixelOfScreen(screen);
    gc_clear = XCreateGC(dpy, window1, GCForeground | GCBackground, &xgcv);   
}


/****************** doHandleEvents ***********************/
static void doHandleEvents(void)
{
    XEvent event;
    unsigned int mask, dummy;
    int count;

    for ( ; ; ) {
        count = XPending(dpy);
        if(count==0)break;
	XNextEvent(dpy, &event);
	switch (event.type) { 
            case ButtonPress:
              exit(0);
        } /* end switch */
    }                                           
}

static void redraw(void)
{
}

void INITIALIZE(void)
{
  doInitialize();
} 

void DRAW_CIRCLE ( float X, float Y, float R, show KIND )
{
  if(KIND==OUTLINE)
  XDrawArc(dpy, window1, gc, (int)((X-R)*my_scale)+XCenter,
                             Yflip-((int)((Y+R)*my_scale)+YCenter),
                             (int)(2.0*R*my_scale),
                             (int)(2.0*R*my_scale),
                             (int)(0*64),
                             (int)(360*64));
  else if(KIND==CLEAR_OUTLINE)
  XDrawArc(dpy, window1, gc_clear, (int)((X-R)*my_scale)+XCenter,
                             Yflip-((int)((Y+R)*my_scale)+YCenter),
                             (int)(2.0*R*my_scale),
                             (int)(2.0*R*my_scale),
                             (int)(0*64),
                             (int)(360*64));
  else if(KIND==FILL)
  XFillArc(dpy, window1, gc, (int)((X-R)*my_scale)+XCenter,
                             Yflip-((int)((Y+R)*my_scale)+YCenter),
                             (int)(2.0*R*my_scale),
                             (int)(2.0*R*my_scale),
                             (int)(0*64),
                             (int)(360*64));
  else if(KIND==CLEAR_FILL)
  XFillArc(dpy, window1, gc_clear, (int)((X-R)*my_scale)+XCenter,
                             Yflip-((int)((Y+R)*my_scale)+YCenter),
                             (int)(2.0*R*my_scale),
                             (int)(2.0*R*my_scale),
                             (int)(0*64),
                             (int)(360*64));
}

void DRAW_ELIPSE ( float X, float Y, float XR, float YR, show KIND )
{
  if(KIND==OUTLINE)
  XDrawArc(dpy, window1, gc, (int)((X-XR)*my_scale)+XCenter,
                             Yflip-((int)((Y+YR)*my_scale)+YCenter),
                             (int)(2.0*XR*my_scale),
                             (int)(2.0*YR*my_scale),
                             (int)(0*64),
                             (int)(360*64));
  else if(KIND==CLEAR_OUTLINE)
  XDrawArc(dpy, window1, gc_clear, (int)((X-XR)*my_scale)+XCenter,
                             Yflip-((int)((Y+YR)*my_scale)+YCenter),
                             (int)(2.0*XR*my_scale),
                             (int)(2.0*YR*my_scale),
                             (int)(0*64),
                             (int)(360*64));
  else if(KIND==FILL)
  XFillArc(dpy, window1, gc, (int)((X-XR)*my_scale)+XCenter,
                             Yflip-((int)((Y+YR)*my_scale)+YCenter),
                             (int)(2.0*XR*my_scale),
                             (int)(2.0*YR*my_scale),
                             (int)(0*64),
                             (int)(360*64));
  else if(KIND==CLEAR_FILL)
  XFillArc(dpy, window1, gc_clear, (int)((X-XR)*my_scale)+XCenter,
                             Yflip-((int)((Y+YR)*my_scale)+YCenter),
                             (int)(2.0*XR*my_scale),
                             (int)(2.0*YR*my_scale),
                             (int)(0*64),
                             (int)(360*64));
}

void DRAW_RECTANGLE ( float X, float Y, float W, float H, show KIND )
{
  if(KIND==OUTLINE)
  XDrawRectangle(dpy, window1, gc, (int)((X-W/2.0)*my_scale)+XCenter,
                                   Yflip-((int)((Y+H/2.0)*my_scale)+YCenter),
                                   (int)(W*my_scale),
                                   (int)(H*my_scale));
  else if(KIND==CLEAR_OUTLINE)
  XDrawRectangle(dpy, window1, gc_clear, (int)((X-W/2.0)*my_scale)+XCenter,
                                   Yflip-((int)((Y+H/2.0)*my_scale)+YCenter),
                                   (int)(W*my_scale),
                                   (int)(H*my_scale));
  else if(KIND==FILL)
  XFillRectangle(dpy, window1, gc, (int)((X-W/2.0)*my_scale)+XCenter,
                                   Yflip-((int)((Y+H/2.0)*my_scale)+YCenter),
                                   (int)(W*my_scale),
                                   (int)(H*my_scale));
  else if(KIND==CLEAR_FILL)
  XFillRectangle(dpy, window1, gc_clear, (int)((X-W/2.0)*my_scale)+XCenter,
                                   Yflip-((int)((Y+H/2.0)*my_scale)+YCenter),
                                   (int)(W*my_scale),
                                   (int)(H*my_scale));
}

void DRAW_LINE ( float X1, float Y1, float X2, float Y2, show KIND )
{
  if(KIND==OUTLINE || KIND==FILL)
  XDrawLine(dpy, window1, gc, (int)(X1*my_scale)+XCenter,
                              Yflip-((int)(Y1*my_scale)+YCenter),
                              (int)(X2*my_scale)+XCenter,
                              Yflip-((int)(Y2*my_scale)+YCenter));
  else if(KIND==CLEAR_OUTLINE || KIND==CLEAR_FILL)
  XDrawLine(dpy, window1, gc_clear, (int)(X1*my_scale)+XCenter,
                              Yflip-((int)(Y1*my_scale)+YCenter),
                              (int)(X2*my_scale)+XCenter,
                              Yflip-((int)(Y2*my_scale)+YCenter));
}

void WRITE_TEXT ( float X, float Y, char *TEXT, show KIND )
{
  static char BLNK[41] = "                                       ";
  if(KIND==OUTLINE || KIND==FILL || KIND==BOLD)
  XDrawImageString(dpy, window1, gc,
                  (int)(X*my_scale)+XCenter,
                  Yflip-((int)(Y*my_scale)+YCenter),
                  TEXT, strlen(TEXT));
  else if(KIND==CLEAR_OUTLINE || KIND==CLEAR_FILL)
  XDrawImageString(dpy, window1, gc,
                  (int)(X*my_scale)+XCenter,
                  Yflip-((int)(Y*my_scale)+YCenter),
                  BLNK, strlen(TEXT));
}

void PRINT(void)
{
  doHandleEvents(); /* flush event buffer */
}


void CLOSE(void)
{
  // nothing to do, let user kill it
}

// end  x_plot_d.cc