#include <X11/IntrinsicP.h>
#include <X11/Xmu/Misc.h>
#include <X11/Xmu/Xmu.h>
#include <X11/StringDefs.h>

#include "drawingp.h"

#define START_CIRCLE 0
#define FULL_CIRCLE  (360*64)

/* Drawing Widget Resources */
static XtResource resources[] = {
#define Offset(field) XtOffset(DrawingWidget, field)
    /* {name, class, type, size, offset, default_type, default_addr}, */
    { XtNkeyCallback, XtCCallback, XtRCallback, sizeof(caddr_t),
          Offset(drawing.key_callback), XtRCallback, (caddr_t) NULL },

    { XtNbutton1Callback, XtCCallback, XtRCallback, sizeof(caddr_t),
          Offset(drawing.button1_callback), XtRCallback, (caddr_t) NULL },
    { XtNbutton2Callback, XtCCallback, XtRCallback, sizeof(caddr_t),
          Offset(drawing.button2_callback), XtRCallback, (caddr_t) NULL },
    { XtNbutton3Callback, XtCCallback, XtRCallback, sizeof(caddr_t),
          Offset(drawing.button3_callback), XtRCallback, (caddr_t) NULL },

    { XtNrelease1Callback, XtCCallback, XtRCallback, sizeof(caddr_t),
          Offset(drawing.release1_callback), XtRCallback, (caddr_t) NULL },
    { XtNrelease2Callback, XtCCallback, XtRCallback, sizeof(caddr_t),
          Offset(drawing.release2_callback), XtRCallback, (caddr_t) NULL },
    { XtNrelease3Callback, XtCCallback, XtRCallback, sizeof(caddr_t),
          Offset(drawing.release3_callback), XtRCallback, (caddr_t) NULL },

    { XtNmotion1Callback, XtCCallback, XtRCallback, sizeof(caddr_t),
          Offset(drawing.motion1_callback), XtRCallback, (caddr_t) NULL },
    { XtNmotion2Callback, XtCCallback, XtRCallback, sizeof(caddr_t),
          Offset(drawing.motion2_callback), XtRCallback, (caddr_t) NULL },
    { XtNmotion3Callback, XtCCallback, XtRCallback, sizeof(caddr_t),
          Offset(drawing.motion3_callback), XtRCallback, (caddr_t) NULL },

    { XtNdrawAllCallback, XtCCallback, XtRCallback, sizeof(caddr_t),
          Offset(drawing.drawAll_callback), XtRCallback, (caddr_t) NULL },

    { XtNfont, XtCFont, XtRFontStruct, sizeof(XFontStruct*),
          Offset(drawing.font), XtRString, "9x15" },

	{ XtNlineWidth, XtCWidth, XtRDimension, sizeof(Dimension),
		  Offset(drawing.line_width), XtRString, "1" },

	{ XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
	      Offset(drawing.foreground), XtRString, "black" },

#undef Offset
};

static void KeyAction(/* Widget, XEvent*, String*, Cardinal* */);

static void Button1Action(/* Widget, XEvent*, String*, Cardinal* */);
static void Button2Action(/* Widget, XEvent*, String*, Cardinal* */);
static void Button3Action(/* Widget, XEvent*, String*, Cardinal* */);

static void Release1Action(/* Widget, XEvent*, String*, Cardinal* */);
static void Release2Action(/* Widget, XEvent*, String*, Cardinal* */);
static void Release3Action(/* Widget, XEvent*, String*, Cardinal* */);

static void Motion1Action(/* Widget, XEvent*, String*, Cardinal* */);
static void Motion2Action(/* Widget, XEvent*, String*, Cardinal* */);
static void Motion3Action(/* Widget, XEvent*, String*, Cardinal* */);

static void Redisplay(/* Widget, XEvent*, Region */);
static void Initialize(/* Widget, Widget */);

static XtActionsRec actions[] =
{
  /* {name, procedure}, */
    {"keypress",         KeyAction},
    {"button1press",     Button1Action},
    {"button2press",     Button2Action},
    {"button3press",     Button3Action},
    {"button1release",   Release1Action},
    {"button2release",   Release2Action},
    {"button3release",   Release3Action},
    {"button1motion",    Motion1Action},
    {"button2motion",    Motion2Action},
    {"button3motion",    Motion3Action},
};

static char translations[] =
       "    <Key>:         keypress()        \n\
            <Btn1Down>:    button1press()    \n\
            <Btn2Down>:    button2press()    \n\
            <Btn3Down>:    button3press()    \n\
            <Btn1Up>:      button1release()  \n\
            <Btn2Up>:      button2release()  \n\
            <Btn3Up>:      button3release()  \n\
            <Btn1Motion>:  button1motion()   \n\
            <Btn2Motion>:  button2motion()   \n\
            <Btn3Motion>:  button3motion()   \n\
       ";

#define superclass      (&widgetClassRec)

DrawingClassRec drawingClassRec = {
  { /* core fields */
    /* superclass               */      (WidgetClass) superclass,
    /* class_name               */      "Drawing",
    /* widget_size              */      sizeof(DrawingRec),
    /* class_initialize         */      NULL,
    /* class_part_initialize    */      NULL,
    /* class_inited             */      FALSE,
    /* initialize               */      Initialize,
    /* initialize_hook          */      NULL,
    /* realize                  */      XtInheritRealize,
    /* actions                  */      actions,
    /* num_actions              */      XtNumber(actions),
    /* resources                */      resources,
    /* num_resources            */      XtNumber(resources),
    /* xrm_class                */      NULLQUARK,
    /* compress_motion          */      TRUE,
    /* compress_exposure        */      TRUE,
    /* compress_enterleave      */      TRUE,
    /* visible_interest         */      FALSE,
    /* destroy                  */      NULL,
    /* resize                   */      NULL,
    /* expose                   */      Redisplay,
    /* set_values               */      NULL,
    /* set_values_hook          */      NULL,
    /* set_values_almost        */      XtInheritSetValuesAlmost,
    /* get_values_hook          */      NULL,
    /* accept_focus             */      NULL,
    /* version                  */      XtVersion,
    /* callback_private         */      NULL,
    /* tm_table                 */      translations,
    /* query_geometry           */      XtInheritQueryGeometry,
    /* display_accelerator      */      XtInheritDisplayAccelerator,
    /* extension                */      NULL
  },
  { /* drawing fields */
    /* empty                    */      0
  }
};

WidgetClass drawingWidgetClass = (WidgetClass)&drawingClassRec;

void DrawingUpdate ( DrawingWidget w )
{
        if (DefaultDepthOfScreen(XtScreen(w)) == 1)
        XCopyArea(     XtDisplay(w),
                                w->drawing.offscreen_pixmap,
                                XtWindow(w),
                                w->drawing.normal_context,
                                0,
                                0,
                                w->core.width,
                                w->core.height,
                                0,
                                0 );
else
	XCopyPlane(	XtDisplay(w),
				w->drawing.offscreen_pixmap,
				XtWindow(w),
				w->drawing.normal_context,
				0,
				0,
				w->core.width,
				w->core.height,
				0,
				0,
				1 );
}

static void GetDrawingGC(w)
           DrawingWidget        w;
{
XGCValues   values;
 
                values.foreground = 1;
                values.background = 0;
                values.line_width = 1;
 
        /* Create a shared GC for Drawing widget */
    w->drawing.draw_gc = XCreateGC(XtDisplay(w),w->drawing.offscreen_pixmap,
           GCForeground | GCBackground | GCLineWidth,
           &values);
}

static GC GetCopyGC(w,width,invert)
	   DrawingWidget	w;
	   int				width;
	   int				invert;
{
XGCValues   values;

	if (invert) {
		values.background = w->drawing.foreground;
		values.foreground = w->core.background_pixel;
		}
	else {
		values.foreground = w->drawing.foreground;
		values.background = w->core.background_pixel;
		}
	if (width < 0)
		values.line_width = w->drawing.line_width;
	else
		values.line_width = width;

	/* Create a shared GC for Drawing widget */
    return XCreateGC(XtDisplay(w),w->drawing.offscreen_pixmap,
           GCForeground | GCBackground | GCLineWidth,
           &values);
}

static void ReleaseDrawingGC(w, gc)
	   DrawingWidget	w;
	   GC			gc;
{
	/* Just call XtReleaseWidget */
	/* This call is supplied for othogonality */
	XFreeGC(XtDisplay(w),gc);
}

static void Initialize(request, new)
		DrawingWidget request, new;
{
Display *dis;
Drawable d;
unsigned int dep;

	dis = XtDisplay(new);
	d = DefaultRootWindow(XtDisplay(new));
	dep = DefaultDepth(dis, DefaultScreen(XtDisplay(new)));

        new->drawing.offscreen_pixmap = XCreatePixmap(dis, d,
		new->core.width, new->core.height, dep);
/*
	new->drawing.offscreen_pixmap = XCreatePixmap( XtDisplay(new),
			DefaultRootWindow(XtDisplay(new)), new->core.width, new->core.height, 1 );

	new->drawing.offscreen_pixmap = XCreatePixmap( XtDisplay(new),
		RootWindow(XtDisplay(new), DefaultScreen(XtDisplay(new))),
		 new->core.width, new->core.height, 
		DefaultDepth();
	if (new->drawing.offscreen_pixmap == (Pixmap) 0) {
		printf("Not create a Pixmap\n");
		exit(0);
	} printf("Pixmap OK\n");
	

	GetDrawingGC(new);
*/
	new->drawing.normal_context = GetCopyGC(new,1,FALSE);
	new->drawing.invert_context = GetCopyGC(new,1,TRUE);
	
        XFillRectangle( XtDisplay(new), 
                                new->drawing.offscreen_pixmap, 
                                new->drawing.invert_context, 
                                0, 0, 
                                new->core.width, new->core.height ); 
}

static void Redisplay(w, event, region)
       DrawingWidget   w;
	   XEvent   *event;
	   Region	region;
{
	if (!XtIsRealized(w))
		return;
printf("Enter XCopy...\n");
	if (DefaultDepthOfScreen(XtScreen(w)) == 1)
        XCopyArea(     XtDisplay(w),
                                w->drawing.offscreen_pixmap,
                                XtWindow(w),
                                w->drawing.normal_context,
                                0,
                                0,
                                w->core.width,
                                w->core.height,
                                0,
                                0 );
else
	XCopyPlane(	XtDisplay(w),
				w->drawing.offscreen_pixmap,
				XtWindow(w),
				w->drawing.normal_context,
				0,
				0,
				w->core.width,
				w->core.height,
				0,
				0,
				1 );
}


static void KeyAction(w, event, params, num_params)
       Widget   w;
	   XEvent   *event;
	   String   *params;
	   Cardinal *num_params;
{
	XtCallCallbacks(w, XtNkeyCallback, (caddr_t) event);
}

static void Button1Action(w, event, params, num_params)
       Widget   w;
	   XEvent   *event;
	   String   *params;
	   Cardinal *num_params;
{
	XtCallCallbacks(w, XtNbutton1Callback, (caddr_t) event);
}

static void Button2Action(w, event, params, num_params)
       Widget   w;
	   XEvent   *event;
	   String   *params;
	   Cardinal *num_params;
{
	XtCallCallbacks(w, XtNbutton2Callback, (caddr_t) event);
}

static void Button3Action(w, event, params, num_params)
       Widget   w;
	   XEvent   *event;
	   String   *params;
	   Cardinal *num_params;
{
	XtCallCallbacks(w, XtNbutton3Callback, (caddr_t) event);
}

static void Release1Action(w, event, params, num_params)
       Widget   w;
	   XEvent   *event;
	   String   *params;
	   Cardinal *num_params;
{
	XtCallCallbacks(w, XtNrelease1Callback, (caddr_t) event);
}

static void Release2Action(w, event, params, num_params)
       Widget   w;
	   XEvent   *event;
	   String   *params;
	   Cardinal *num_params;
{
	XtCallCallbacks(w, XtNrelease2Callback, (caddr_t) event);
}

static void Release3Action(w, event, params, num_params)
       Widget   w;
	   XEvent   *event;
	   String   *params;
	   Cardinal *num_params;
{
	XtCallCallbacks(w, XtNrelease3Callback, (caddr_t) event);
}

static void Motion1Action(w, event, params, num_params)
       Widget   w;
	   XEvent   *event;
	   String   *params;
	   Cardinal *num_params;
{
	XtCallCallbacks(w, XtNmotion1Callback, (caddr_t) event);
}

static void Motion2Action(w, event, params, num_params)
       Widget   w;
	   XEvent   *event;
	   String   *params;
	   Cardinal *num_params;
{
	XtCallCallbacks(w, XtNmotion2Callback, (caddr_t) event);
}

static void Motion3Action(w, event, params, num_params)
       Widget   w;
	   XEvent   *event;
	   String   *params;
	   Cardinal *num_params;
{
	XtCallCallbacks(w, XtNmotion3Callback, (caddr_t) event);
}


void DrawingDrawLine(w, fromx, fromy, tox, toy, invert)
	   DrawingWidget		w;
	   int			fromx, fromy, tox, toy;
	   int			invert;
{
	XDrawLine(	XtDisplay(w),
				w->drawing.offscreen_pixmap,
				invert ? w->drawing.invert_context : w->drawing.normal_context,
				fromx, fromy,
				tox, toy );
}

void DrawingDrawOval(w, centrex, centrey, width, height, invert)
           DrawingWidget                w;
           int                  centrex, centrey;
           int                  width, height;
           int                  invert;
{
        XDrawArc(       XtDisplay(w),
                                w->drawing.offscreen_pixmap,
                                invert ? w->drawing.invert_context : w->drawing.normal_context,
                                centrex, centrey,
                                width, height,
                                START_CIRCLE,
                                FULL_CIRCLE );
}
 
void DrawingFillOval(w, centrex, centrey, width, height, invert)
       DrawingWidget       w;
       int          centrex, centrey;
       int          width, height;
           int                  invert;
{
    XFillArc(   XtDisplay(w),
                                w->drawing.offscreen_pixmap,
                                invert ? w->drawing.invert_context : w->drawing.normal_context,
                centrex, centrey,
                width, height,
                START_CIRCLE,
                FULL_CIRCLE );
}

void DrawingDrawBox(w, centrex, centrey, width, height, invert)
	   DrawingWidget		w;
	   int			centrex, centrey;
	   int			width, height;
	   int			invert;
{
XDrawRectangle(   XtDisplay(w),
                                w->drawing.offscreen_pixmap,
                                invert ? w->drawing.invert_context : w->drawing.normal_context,
                centrex, centrey,
                width, height);
}

void DrawingFillBox(w, centrex, centrey, width, height, invert)
       DrawingWidget       w;
       int          centrex, centrey;
       int          width, height;
	   int			invert;
{
    XFillRectangle(   XtDisplay(w),
				w->drawing.offscreen_pixmap,
				invert ? w->drawing.invert_context : w->drawing.normal_context,
                centrex, centrey,
                width, height);
}

void DrawingClear(w)
	DrawingWidget w;
{
	XFillRectangle(	XtDisplay(w),
				w->drawing.offscreen_pixmap,
				w->drawing.invert_context,
				0, 0,
				w->core.width, w->core.height );
}


void DrawingWriteText(w, xco, yco, txt )
	DrawingWidget	w;
	int		xco, yco;
	char	*txt;
{
	XDrawImageString(	XtDisplay(w),
						w->drawing.offscreen_pixmap,
						w->drawing.normal_context,
						xco, yco,
						txt,
						strlen( txt ) );
}