/*----------------------------------------------------------------------*/
/*  X-Windows subroutines         					*/
/*----------------------------------------------------------------------*/

#include <stdio.h>
#include "function_exp.h"
#include "graph_exp.h"
#include "net_exp.h"
#include "menu_exp.h"

XtActionsRec actionTable[] = {
        {"Ok",  Ok}
};

/*******Function Wprintf
	    print a formatted string to the message widget   */

Wprintf()
{
   Arg		wargs[1];

   XtSetArg(wargs[0], XtNstring, msgstring);
   XtSetValues(message, wargs, 1);
}

/*******Function ToggleExcl
	    marks a menu item	*/

ToggleExcl(widget, menu, first_item, last_item)
Widget 		widget;
menu_struct	*menu;
int		first_item, last_item;
{
   Arg		args[1];
   Widget	parent = XtParent(widget);
   Widget       sibling;
   int		i;

   for (i = first_item; i <= last_item; i++) {
      sibling = XtNameToWidget(parent, menu[i].name);
      XtSetArg(args[0], XtNsetMark, FALSE);
      XtSetValues(sibling, args, 1);
   }

   XtSetArg(args[0], XtNsetMark, TRUE);
   XtSetValues(widget, args, 1);
}

/*******Function Toggle
            marks or unmarks a menu item   */

Toggle(widget)
Widget		widget;
{
   Arg		args[1];
   Boolean	type;

   XtSetArg(args[0], XtNsetMark, &type);
   XtGetValues(widget, args, 1);
   if (type == TRUE) XtSetArg(args[0], XtNsetMark, FALSE);
   else XtSetArg(args[0], XtNsetMark, TRUE);
   XtSetValues(widget, args, 1);
}

/*******Function create_pane
	    responsible for hierarchical sub-menus */

create_pane(mgr, mgrname, name, menulist, nitems)
   Widget       mgr;
   char         *name,  *mgrname;
   menu_struct  *menulist;
   int          nitems;
{
   Arg          wargs[1];
   Widget       menupane, pane_shell;
   int          i, n;
   WidgetList   buttons;

   buttons = (WidgetList) XtMalloc (nitems * sizeof (Widget));
   pane_shell = XtCreatePopupShell ("pane_shell",
        transientShellWidgetClass, mgr, NULL, ZERO);
   XtSetArg (wargs[0], XtNattachTo, (XtArgVal) mgrname);
   menupane = XtCreateManagedWidget (name, XwcascadeWidgetClass,
        pane_shell, wargs, 1);
   for (i = 0; i < nitems; i++) {
      n = 0;
      if (menulist[i].size < 0) {   /* Denotes a marked entry */
	 XtSetArg(wargs[0], XtNsetMark, TRUE);
         n++;
      }
      buttons[i] = XtCreateWidget(menulist[i].name,
         XwmenubuttonWidgetClass, menupane, wargs, n);
      if (strcmp (menulist[i].name, "recurrent net") == 0) recnet = 
	 buttons[i];
      if (menulist[i].size <= 0)
         XtAddCallback (buttons[i], XtNselect, menulist[i].func,
            NULL);
   }
   XtManageChildren (buttons, nitems);
}

/*******Function GetText
	   puts result of dialog entry into a global string variable  */

void GetText(w, textwidget, call_data)
Widget w;
XtPointer textwidget, call_data;
{

   Widget text = (Widget) textwidget;
   Arg args[1];
   String str;

   str = XawDialogGetValueString(text);
   if (str[strlen(str) - 1] == ' ') str[strlen(str) - 1] = '\0';
   (*function)(str);

   DestroyPopupPrompt(NULL, (XtPointer)textwidget, (XtPointer)NULL);
}

/*******Function Ok
           alternative to pressing "ok" dialog button--called on a <return> */

void Ok(widget, event, params, num_params)
Widget widget;
XEvent *event;
String *params;
Cardinal *num_params;
{
    Widget dialog = XtParent(widget);

    GetText(widget, (XtPointer) dialog, (XtPointer) NULL);
}

/*******Function QuitSelect
	   exits the program when "quit" button is pushed.    */

void QuitSelect(w, junk, garbage)
Widget w;
XtPointer junk, garbage;
{
    XtDestroyWidget(w);
    fprintf (stderr, "\nQuitting xtdnn. . .\n\n");
    exit (0);
}

/*******Function Syntax
 	   prints the calling syntax for this function to stdout.    */

Syntax(w, call)
Widget w;
char *call;
{
    XtDestroyWidget(w);
    fprintf (stderr, "Usage: %s [-label <label name>]\n", call);
    exit (1);
}

/*******Function PopupPrompt
	   creates a Dialog box in response to a menu selection.    */

PopupPrompt(button, request, current)
Widget  button;
char *request, *current;
{
    Arg         args[5];
    Widget      popup, dialog;
    Dimension	width, height;
    Position	x, y;
 
    XtAddActions(actionTable, XtNumber(actionTable));

    XtSetArg(args[0], XtNwidth, &width); 
    XtSetArg(args[1], XtNheight, &height);
    XtGetValues(form, args, 2);
    XtTranslateCoords(form, (Position) (width / 2), 
		(Position) (height / 2), &x, &y);

    XtSetArg(args[0], XtNx, x);
    XtSetArg(args[1], XtNy, y);
    popup = XtCreatePopupShell("prompt", transientShellWidgetClass, 
	form, args, 2);

    XtSetArg(args[0], XtNlabel, (XtArgVal) request);
    XtSetArg(args[1], XtNvalue, (XtArgVal) current);
    dialog = XtCreateManagedWidget("dialog", dialogWidgetClass,
	popup, args, 2);

    XawDialogAddButton(dialog, "ok", GetText, (XtPointer)dialog);
    XawDialogAddButton(dialog, "cancel", DestroyPopupPrompt, 
	(XtPointer)dialog);

    XtPopup(popup, XtGrabNone);
}

/*******Function DestroyPopupPrompt
	    removes popup box from the screen  */

DestroyPopupPrompt(widget, client_data, call_data)
Widget widget;
XtPointer client_data, call_data;
{
   Widget popup = XtParent( (Widget) client_data);
   XtDestroyWidget(popup);
}

/*******Function MenuSelect
 	   declares a selected menu item invalid.    */

void MenuSelect(w, client_data, call_data)
Widget w;
XtPointer client_data, call_data;
{
   sprintf(msgstring,"This function is not yet implemented.");
   Wprintf();
}

/******Function create_gc
           initializes the graphics context.        */

create_gc()
{
   Window	win =  DefaultRootWindow(XtDisplay(pix));
   int		scr  = DefaultScreen(dpy);
   XColor	color, bgcolor;
   int		cells[48], fgcolorcell; 
   int		i, k;

   XGCValues 	values;
   Arg		wargs[5];

   /*  Set up symbol font */

   symbfont = XLoadFont(dpy, "*symbol-medium-r-normal--18*");
   textstruct = XLoadQueryFont(dpy, "*helvetica-medium-r-normal--18*");
   graphtext = XLoadQueryFont(dpy, "*times-medium-i-normal--14*");
   
   /*  Get background color values */

   cmap = DefaultColormap (dpy, scr);
   XtSetArg(wargs[0], XtNbackground, &bgcolor.pixel);
   XtSetArg(wargs[1], XtNforeground, &fgcolorcell);
   XtGetValues(pix, wargs, 2);

   XQueryColor(dpy, cmap, &bgcolor);
   color.flags = DoRed | DoGreen | DoBlue;

   /*  Allocate colors in the colormap */

   if (XAllocColorCells (dpy, cmap, TRUE, NULL, 0, cells, 48)) {
      for (k = 0; k < 3; k++) {
	 for (i = 0; i < 8; i++) {
	    color.red = (int) (redpixcolorneg[k] + i * 
		(((long)bgcolor.red - redpixcolorneg[k]) / 8));
            color.green = (int)(greenpixcolorneg[k] + i * 
		(((long)bgcolor.green - greenpixcolorneg[k]) / 8));
            color.blue = (int)(bluepixcolorneg[k] + i * 
		(((long)bgcolor.blue - bluepixcolorneg[k]) /8));
	    colorvals[k*17 + i] = color.pixel = cells[k*16 + i];
            XStoreColor(dpy, cmap, &color);
         }
         for (i = 1; i < 9; i++) {
	    color.red = (int)((long)bgcolor.red + i * 
		((redpixcolorpos[k] - (long)bgcolor.red) / 8));
            color.green = (int)((long)bgcolor.green + i * 
		((greenpixcolorpos[k] - (long)bgcolor.green)/8));
	    color.blue = (int)((long)bgcolor.blue + i * 
		((bluepixcolorpos[k] - (long)bgcolor.blue) /8));
            colorvals[k*17 + i + 8] = color.pixel = cells[k*16 + i + 7];
	    XStoreColor(dpy, cmap, &color);
         }
      }
      colorvals[8] = colorvals[25] = colorvals[42] = bgcolor.pixel;
      colorvals[51] = BlackPixel(dpy, scr);
      colorvals[52] = WhitePixel(dpy, scr);
      
      XSetWindowColormap (dpy, win, cmap);
      XInstallColormap (dpy, cmap);

   }
   else {
      sprintf(msgstring,"Could not allocate colors");
      Wprintf();
   }

   /*   Generate GCs   */
   
   values.foreground = fgcolorcell;
   values.background = bgcolor.pixel;
   values.fill_style = FillSolid;
   values.line_width = 0;

   gc = XCreateGC (dpy, win, GCForeground | GCBackground | 
		GCFillStyle | GCLineWidth, &values); 

   values.foreground = BlackPixel(dpy, scr);
   values.font	     = symbfont;
   values.line_width = 2;

   linegc = XCreateGC (dpy, win, GCForeground | GCBackground |
		GCLineWidth | GCFont, &values);

   values.foreground  = WhitePixel(dpy, scr);
   values.font	     = textstruct->fid;

   textgc = XCreateGC (dpy, win, GCForeground | GCBackground |
		GCFont, &values);

   values.line_style = LineOnOffDash;
   values.foreground = colorvals[16];
   values.font	= graphtext->fid;

   graphgc = XCreateGC (dpy, win, GCForeground | 
		GCBackground | GCFont | GCLineStyle, &values);
}