/**************************** menu.c++ ***************************/
/*                                                               */
/*  Part of the ming program.  This part contains the motif      */
/*  codes used to create the control board and menus of the      */
/*  program.                                                     */
/*                                                               */
/********************** Ying-Qing Wu, 12/95 **********************/


#include <X11/Intrinsic.h>
#include <Xm/Xm.h>
#include <Xm/CascadeBG.h>
#include <Xm/Form.h>
#include <Xm/RowColumn.h>
#include <Xm/LabelG.h>
#include <Xm/Text.h>
#include <Xm/Frame.h>
#include <Xm/PushB.h>
#include <Xm/PushBG.h>
#include <Xm/Separator.h>
#include <Xm/SeparatoG.h>
#include <Xm/ToggleB.h>
#include <Xm/ToggleBG.h>
#include <Xm/FileSB.h>
#include <Xm/MessageB.h>

#include <Inventor/So.h>
#include <Inventor/Xt/SoXt.h>
#include <Inventor/SoType.h>
#include <Inventor/Xt/SoXtMaterialEditor.h>
#include <Inventor/Xt/viewers/SoXtExaminerViewer.h>
#include <Inventor/nodes/SoDirectionalLight.h>
#include <Inventor/nodes/SoPerspectiveCamera.h>
#include <Inventor/nodes/SoOrthographicCamera.h>
#include <Inventor/nodes/SoSeparator.h>
#include "help.h"

const  int                  size = 1000;
int                         drawFlag = 0;
int                         helpStatus = 0;
extern int                  vnum;
extern double               EdgeRadius;
extern int                  Sides;
extern Widget               myWindow;
extern SoXtExaminerViewer  *myViewer;
extern float                turnpoint;
extern int                  pinchStatus, pinchEdge;
extern int                  PixPerInch;
extern SoMaterial          *editedMaterial;
extern SoMaterial          *BGMaterial;
SoXtMaterialEditor         *myEditor;
SoXtMaterialEditor         *BGEditor;

int    getfile(char *);
void   render();
void   printfile(char *);
void   run(int);
void   add_vertex(int);
void   showData();

Widget text_w;
Widget textWidgets[4];
float  BGDefault[] = {0, 0.6, 0.9};
int    colorStatus=0, renderStatus=1, colorPeriod=1;
int    singleColorStatus = 0;
extern void error(Widget, XtPointer, XtPointer);


typedef struct MenuItems {
    Widget *items;  
    int	   which; 
} MenuItems;


void LoadKnot(Widget w, XtPointer, XtPointer call_data)
{
   char *file;
   XmFileSelectionBoxCallbackStruct* cbs =
       (XmFileSelectionBoxCallbackStruct*)call_data;

   if (vnum==0) 
        BGMaterial->diffuseColor.setValue(BGDefault);
   if (cbs) 
    {  if (!XmStringGetLtoR(cbs->value, XmSTRING_DEFAULT_CHARSET, &file)) 
        { error(w, "Error:  Can not load file.", NULL);
          return;
        }
       if (!getfile(file))
        {  error(w, "ERROR:  Can not read knot file.", NULL);
           return;
	 }
    }
}

void Cancel_CB(Widget w, XtPointer, XtPointer)
{
    XtDestroyWidget(w);
    w=NULL;
}

void SaveKnot(Widget menu_item , XtPointer, XtPointer call_data )
{
    char *file;

    XmFileSelectionBoxCallbackStruct* cbs =
       (XmFileSelectionBoxCallbackStruct*) call_data;

    if (cbs)
    {  if (!XmStringGetLtoR(cbs->value, XmSTRING_DEFAULT_CHARSET, &file)) 
       {  error(menu_item, "Error:  Can not save knot.\n", NULL);
          return;
       }
       printfile(file);
       Cancel_CB (menu_item , NULL , NULL );
    }
}


void Antialiasing (int k)
{  
   if (k<2)
       myViewer->setAntialiasing (FALSE, 1);
   else 
       myViewer->setAntialiasing (TRUE, (k>255) ? 255 : k);
}


void newKnot()
{
   drawFlag = 1;
   vnum = 0;

   SoCamera *myCamera = 
                (SoCamera *) myViewer->getCamera();
   myViewer->setCameraType(SoOrthographicCamera::getClassTypeId());

   myCamera->position.setValue(0, 0, 100);
   myCamera->nearDistance.setValue(25.0);
   myCamera->farDistance.setValue(175.0);
   render();
}

void fileMenuPick (Widget, void *userData, void *)
{
    void WriteEPS(Widget, XtPointer, XtPointer);
    int	 k = (int) userData;

    if (k > 3)
        exit(0);

    if (k == 3) 
    {   newKnot(); 
        return; 
    }

    static  Widget dialogs[3] = {NULL, NULL, NULL};
    char   *labels[] = {"New...", "Load Knot...", "Save Knot As...", 
                        "Save PostScript File As..."};

    Arg     args[10];
    int     n = 0;
    XtSetArg(args[n], XmNwidth, 350); n++;
    XtSetArg(args[n], XmNheight, 400); n++;
    XmString ex = XmStringCreateLocalized("exit");
    XtSetArg(args[n], XmNcancelLabelString, ex); n++;
    XmString ok;
    if (k==0)
        ok = XmStringCreateLocalized("open");
    else if (k==1)
        ok = XmStringCreateLocalized("save");
    else if (k==2)
        ok = XmStringCreateLocalized("save PS");
    XtSetArg(args[n], XmNokLabelString, ok); n++;
    dialogs[k] = XmCreateFileSelectionDialog (myWindow, labels[k], args, n);
    XtUnmanageChild (XmFileSelectionBoxGetChild 
                      (dialogs[k], XmDIALOG_APPLY_BUTTON));
    XtUnmanageChild (XmFileSelectionBoxGetChild 
                      (dialogs[k], XmDIALOG_HELP_BUTTON));
    if (k==0)
         XtAddCallback(dialogs[k], XmNokCallback, LoadKnot, NULL);
    else if (k==1)
         XtAddCallback(dialogs[k], XmNokCallback, SaveKnot, NULL);
    else 
         XtAddCallback(dialogs[k], XmNokCallback, WriteEPS, NULL);
    XtAddCallback(dialogs[k], XmNcancelCallback, Cancel_CB, NULL);
    XtManageChild(dialogs[k]);
    XmStringFree (ok);
    XmStringFree (ex);

    XtPopup (myWindow, XtGrabNone);
}

void sizeMenuPick(Widget w, void *userData, void *)
{
    int which = (int) userData;

    Arg     args[1];
    MenuItems *myMenuItems;
    XtSetArg(args[0], XmNuserData, &myMenuItems);
    XtGetValues(w, args, 1);
    myMenuItems->which = which;

    if (which == 3)
         XmTextSetString (textWidgets[0], "edge_radius: ");
    else 
         EdgeRadius = which + 1;
    render();
}

void initEditor()
{
     SoMaterial *mtl = new SoMaterial;
     mtl->shininess.setValue(0.18);
     mtl->specularColor.setValue(1, 0.67, 0);
     mtl->ambientColor.setValue(0, 0, 0);
     mtl->diffuseColor.setValue(0.9, 0.4, 0);

     myEditor = new SoXtMaterialEditor;
     myEditor->attach(editedMaterial);
     myEditor->setMaterial(*mtl);
}

void initBGEditor()
{
     SoMaterial *mtl = new SoMaterial;
     mtl->shininess.setValue(0);
     mtl->ambientColor.setValue(0, 0, 0);
     mtl->diffuseColor.setValue(BGDefault);

     BGEditor = new SoXtMaterialEditor;
     BGEditor->attach(BGMaterial);
     BGEditor->setMaterial(*mtl);
     BGEditor->addMaterialChangedCallback
                   ((SoXtMaterialEditorCB *)render, NULL);
}

void singleColorPick (Widget, void *userData, void *)
{
    int k = singleColorStatus = int(userData);
    
    colorStatus = 2;

    float color[5][4][3] = 
        {{{0.18, 0, 0}, {0.3,1,0}, {0,0.5,0}, {0.92, 0.74, 0.91}},
         {{0.18, 0, 0}, {0.41, 1.0, 0.75}, {0, 0.31, 0.7}, {0.85,0.6, 0.52}}, 
	 {{0.3, 0, 0}, {1, 0,0}, {0.5,0,0}, {0.53,0.78,1}},
         {{0.14, 0, 0}, {1,0.64,0}, {1,0.5,0}, {0.62,0.78,0.7}},
         {{1, 1, 1}, {0.3, 0.3,0.3}, {0.7,0.7,0.7}, {1, 1, 1}} };

    editedMaterial->shininess.setValue(color[k][0][0]);
    editedMaterial->specularColor.setValue(color[k][1]);
    editedMaterial->diffuseColor.setValue(color[k][2]);
    BGMaterial->diffuseColor.setValue(color[k][3]);
    if (k==4) {
        editedMaterial->ambientColor.setValue(1,1,1);
        editedMaterial->shininess.setValue(1);
        editedMaterial->emissiveColor.setValue(0.1, 0.1, 0.1);
        BGMaterial->specularColor.setValue(1,1,1);
        BGMaterial->ambientColor.setValue(1,1,1);
    }
    render();
}


void colorMenuPick (Widget, void *userData, void *)
{
    int k = (int) userData;

    switch(k) {
	case 0: case 1: 
            BGMaterial->diffuseColor.setValue(BGDefault);
            colorStatus = k; break;
	case 2:
            singleColorPick(NULL, (XtPointer) singleColorStatus, NULL);
	    break;
	case 4:
            colorStatus = k;
            myEditor->setMaterial(*editedMaterial);
            myEditor->show(); break;
	case 5:
            BGEditor->setMaterial(*BGMaterial);
            BGEditor->show(); break;
	case 6:
            XmTextSetString (textWidgets[0], "color_period: ");
            break;
        default:
            break;
      }

    render();
}

void renderMenuPick (Widget, void *userData, void *)
{
    if (int(userData) < 3)
      { renderStatus = (int) userData;
        render();
      }
    else 
     { char *command = "tube_sides: ";
       XmTextSetString (textWidgets[0], command);
     }    
}


void optionMenuPick (Widget w, void *userData, void *)
{
    int state, k = (int) userData;

    if (k<3)
        state = XmToggleButtonGetState(w);
    switch (k)
     { case 0: Antialiasing (10*state); break;
       case 1: turnpoint = state; break;
       case 2: pinchStatus = state; break;
       case 3: XmTextSetString (textWidgets[0], "Antialiasing: ");
               break;
       case 4: XmTextSetString (textWidgets[0], "pinch_edge: ");
               break;
       default: break;
     }
}


/*
void readHelpFile(int which)
{
    char *filename[4] = {"README.help", "commands.help",
                         "menus.help","edit.help"}; 
    char text[4000];
    FILE *fp;
    int length;

    if (!(fp = fopen(filename[which], "r"))) 
     {  fprintf (stderr, "%s: not a regular file\n", filename[which]);
        return;
     }

    if (!(length=fread (text, sizeof (char), 4000, fp)))
        fprintf (stderr, "Warning: may not have read entire file!\n");
    text[length] = 0;

    XmTextSetString (text_w, text);
    fclose (fp);
}
*/

void readHelpFile(int which)
{
    XmTextSetString (text_w, helpf[which]);
}


void setHelpStatus(Widget dialog, XtPointer client_data, XtPointer)
{
   if ((int) client_data ==0)
          helpStatus -=1;
   else   helpStatus +=1;
   readHelpFile (helpStatus);
   XtSetSensitive (
        XmMessageBoxGetChild (dialog,XmDIALOG_CANCEL_BUTTON), helpStatus > 0);
   XtSetSensitive (XmMessageBoxGetChild (
        dialog, XmDIALOG_HELP_BUTTON), helpStatus < 3);
}
  


void helpMenuPick (Widget, XtPointer client_data, XtPointer)
{
    char        *Msg = {"HELP MANUAL"};
    Widget       dialog;
    XmString     text = XmStringCreateLtoR (Msg, XmFONTLIST_DEFAULT_TAG);
    XmString     previous = XmStringCreateLocalized ("previous");
    XmString     next = XmStringCreateLocalized ("next");
    extern void  Cancel_CB(Widget, XtPointer, XtPointer);
    Arg          args[5];
    int          n;

    helpStatus = (int) client_data;

    n = 0;
    XtSetArg (args[n], XmNmessageString, text); n++;
    XtSetArg (args[n], XmNautoUnmanage, False); n++;
    XtSetArg (args[n], XmNcancelLabelString, previous); n++;
    XtSetArg (args[n], XmNhelpLabelString, next); n++;
    dialog = XmCreateMessageDialog (myWindow, "help", args, n);
    XtAddCallback (dialog, XmNokCallback, Cancel_CB, NULL);
    
    XtAddCallback (dialog, XmNcancelCallback, setHelpStatus, (XtPointer) 0);
    XtAddCallback (dialog, XmNhelpCallback, setHelpStatus, (XtPointer) 1);
    XmStringFree (text);
    XmStringFree (previous);
    XmStringFree (next);
    XtSetSensitive (
        XmMessageBoxGetChild (dialog,XmDIALOG_CANCEL_BUTTON), helpStatus > 0);
    XtSetSensitive (XmMessageBoxGetChild (
        dialog, XmDIALOG_HELP_BUTTON), helpStatus < 5);

    n = 0;
    XtSetArg(args[n], XmNrows,      40); n++;
    XtSetArg(args[n], XmNcolumns,   70); n++;
    XtSetArg(args[n], XmNeditable,  False); n++;
    XtSetArg(args[n], XmNeditMode,  XmMULTI_LINE_EDIT); n++;
    XtSetArg(args[n], XmNcursorPositionVisible,  False); n++;
    text_w = XmCreateScrolledText (dialog, "text_w", args, n);
    XtManageChild (text_w);

    readHelpFile(helpStatus);

    XtManageChild (dialog);
    XtPopup (XtParent (dialog), XtGrabNone);
}


void sizeMenuDisplay(Widget, void *userData, XtPointer)
{
    MenuItems *myMenuItems = (MenuItems *) userData;
    for (int i=0; i<4; i++)
     { if (i==myMenuItems->which)
           XmToggleButtonSetState(myMenuItems->items[i], TRUE, FALSE);
       else     
           XmToggleButtonSetState(myMenuItems->items[i], FALSE, FALSE);
     }
}

Widget buildFileMenu(Widget menubar)
{
    Widget  items[5], pulldown;
    Arg     args[5];
    int	    n=0;
    
    SoXt::getPopupArgs(XtDisplay(menubar), NULL, args, &n);
    pulldown = XmCreatePulldownMenu(menubar, "fileMenu", args, n);
    SoXt::registerColormapLoad(pulldown, SoXt::getShellWidget(menubar));

    char * accel[] = {"Alt <Key> o", "Alt <Key> s", "Alt <Key> p", 
                      "Alt <Key> n", "Alt <Key> q"};
    char * text[] = {"Open...", "Save...", "Save PS...", "New...", "Quit"};
    char * accelTx[] = {"Alt+o", "Alt+s", "Alt+p", "Alt+n", "Alt+q"};
    XmString accelText[5];
    for (int i=0; i<5; i++) 
         accelText[i] = XmStringCreate(accelTx[i], XmSTRING_DEFAULT_CHARSET);

    for (i=0; i<5; i++) 
     {   n=0;
         XtSetArg(args[n], XmNaccelerator, accel[i]); n++;
         XtSetArg(args[n], XmNacceleratorText, accelText[i]); n++;
         items[i] = XtCreateManagedWidget(text[i],
             xmPushButtonGadgetClass, pulldown, args, n); 
         XtAddCallback(items[i], XmNactivateCallback,
             fileMenuPick, (XtPointer) i);
         if (i==3) 
             (void) XtCreateManagedWidget("separator", 
                  xmSeparatorGadgetClass, pulldown, NULL, 0);
     }
    return pulldown;
}


Widget buildSizeMenu(Widget menubar)
{
    Widget  pulldown;
    Arg     args[4];
    int	    n=0;
    
    MenuItems *myMenuItems = new MenuItems;
    myMenuItems->items = new Widget[4];
    myMenuItems->which = 1;
    

    n=0;
    XtSetArg(args[n], XmNradioBehavior, TRUE); n++;

    SoXt::getPopupArgs(XtDisplay(menubar), NULL, args, &n);
    pulldown = XmCreatePulldownMenu(menubar, "sizeMenu", args, n);
    SoXt::registerColormapLoad(pulldown, SoXt::getShellWidget(menubar));
    XtAddCallback(pulldown, XmNmapCallback,
	(XtCallbackProc) sizeMenuDisplay, (XtPointer) myMenuItems);

    n = 0;
    XtSetArg(args[n], XmNuserData, myMenuItems); n++;
    XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;

    char *label[] = {"1", "2", "3", "Specify"};
    for (int i=0; i<4; i++)
     {  myMenuItems->items[i] = XtCreateManagedWidget(label[i],
             xmToggleButtonGadgetClass, pulldown, args, n);
        XtAddCallback(myMenuItems->items[i], XmNvalueChangedCallback,
             sizeMenuPick, (XtPointer) i);
        if (i==2) 
             (void) XtCreateManagedWidget("separator", 
                 xmSeparatorGadgetClass, pulldown, NULL, 0);
     }
    return pulldown;
}


Widget buildSingleColorMenu(Widget menubar)
{
    Widget  items[5], pulldown;
    Arg     args[5];
    int	    n=0;
    
    SoXt::getPopupArgs(XtDisplay(menubar), NULL, args, &n);
    pulldown = XmCreatePulldownMenu(menubar, "singleColorMenu", args, n);
    SoXt::registerColormapLoad(pulldown, SoXt::getShellWidget(menubar));

    char *labels[] = {"Green", "Blue", "Read", "Gold", "Grey"};
    for (int i=0; i<5; i++) 
     {   items[i] = XtCreateManagedWidget(labels[i],
             xmPushButtonGadgetClass, pulldown, args, n); 
         XtAddCallback(items[i], XmNactivateCallback,
             singleColorPick, (XtPointer) i);
     }
    return pulldown;
}


Widget buildColorMenu(Widget menubar)
{
    Widget  items[7], pulldown;
    Arg     args[7];
    int	    n=0;
    
    n=0;
    XtSetArg(args[n], XmNradioBehavior, TRUE); n++;

    SoXt::getPopupArgs(XtDisplay(menubar), NULL, args, &n);
    pulldown = XmCreatePulldownMenu(menubar, "colorMenu", args, n);
    SoXt::registerColormapLoad(pulldown, SoXt::getShellWidget(menubar));

    char *labels[] = {"periodic", "depth", "single", "choose knot color",
           "knot color editor", "background editor", "set color period"};

    n=0;
    XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;

    for (int i=0; i<7; i++) 
     { if (i==3)
          items[i] = XtVaCreateManagedWidget(labels[i],
              xmCascadeButtonGadgetClass, pulldown, 
              XmNsubMenuId, buildSingleColorMenu(pulldown), NULL);
       else 
        { items[i] = XtCreateManagedWidget(labels[i],
             (i<3) ? xmToggleButtonGadgetClass :
             xmPushButtonGadgetClass, pulldown, args, n); 
          XtAddCallback(items[i], (i<3) ? XmNvalueChangedCallback :
             XmNactivateCallback, colorMenuPick, (XtPointer) i);
          if (i==2 || i==5) 
             (void) XtCreateManagedWidget("separator", 
                  xmSeparatorGadgetClass, pulldown, NULL, 0);
        }
     }
    XmToggleButtonSetState(items[0], TRUE, FALSE);
    initEditor();
    initBGEditor();
    return pulldown;
}


Widget buildRenderMenu(Widget menubar)
{
    Widget  items[4], pulldown;
    Arg     args[4];
    int	    n=0;
    
    n=0;
    XtSetArg(args[n], XmNradioBehavior, TRUE); n++;

    SoXt::getPopupArgs(XtDisplay(menubar), NULL, args, &n);
    pulldown = XmCreatePulldownMenu(menubar, "renderMenu", args, n);
    SoXt::registerColormapLoad(pulldown, SoXt::getShellWidget(menubar));

    char *labels[] = {"line", "tube", "cylinder-ball", "set tube sides"};
    for (int i=0; i<4; i++) 
     {   items[i] = XtCreateManagedWidget(labels[i],
             (i<3) ? xmToggleButtonGadgetClass :
             xmPushButtonGadgetClass, pulldown, args, n); 
         XtAddCallback(items[i], (i<3) ? XmNvalueChangedCallback :
             XmNactivateCallback, renderMenuPick, (XtPointer) i);
         if (i==2) (void) XtCreateManagedWidget("separator", 
             xmSeparatorGadgetClass, pulldown, NULL, 0);
     }
    XmToggleButtonSetState(items[1], TRUE, FALSE);
    return pulldown;
}

Widget buildOptionMenu(Widget menubar)
{
    Widget  items[5], pulldown;
    Arg     args[5];
    int	    n=0;
    
    SoXt::getPopupArgs(XtDisplay(menubar), NULL, args, &n);
    pulldown = XmCreatePulldownMenu(menubar, "optionMenu", args, n);
    SoXt::registerColormapLoad(pulldown, SoXt::getShellWidget(menubar));

    char *labels[] = {"antialiasing", "rough run", "add pinch force", 
                      "set Antialiasing level", "set pinch edge"};
    for (int i=0; i<5; i++) 
     {   items[i] = XtCreateManagedWidget(labels[i],
             (i<3) ? xmToggleButtonGadgetClass :
             xmPushButtonGadgetClass, pulldown, args, n); 
         XtAddCallback(items[i], (i<3) ? XmNvalueChangedCallback :
             XmNactivateCallback, optionMenuPick, (XtPointer) i);
         if (i==2) (void) XtCreateManagedWidget("separator", 
             xmSeparatorGadgetClass, pulldown, NULL, 0);
     }
    XmToggleButtonSetState(items[1], TRUE, FALSE);
    return pulldown;
}


Widget buildHelpMenu(Widget menubar)
{
    Widget  items[4], pulldown;
    Arg     args[4];
    int	    n=0;
    
    SoXt::getPopupArgs(XtDisplay(menubar), NULL, args, &n);
    pulldown = XmCreatePulldownMenu(menubar, "helpMenu", args, n);
    SoXt::registerColormapLoad(pulldown, SoXt::getShellWidget(menubar));

    char *labels[]={"README.help", "On Commands", "On Menu items", "On Edit"};
    for (int i=0; i<4; i++) 
     {   items[i] = XtCreateManagedWidget(labels[i],
             xmPushButtonGadgetClass, pulldown, args, n); 
         XtAddCallback(items[i], XmNactivateCallback,
             helpMenuPick, (XtPointer) i);
     }
    return pulldown;
}


Widget buildPulldownMenu(Widget parent)
{
    Widget  menuButtons[6], pulldown[6];
    Arg     args[8];
    int	    n;
    char   *title[] = {"file", "size", "color", "render", "options", "help"};

    Widget menubar = XmCreateMenuBar(parent, "menuBar", NULL, 0);
    pulldown[0] = buildFileMenu(menubar);
    pulldown[1] = buildSizeMenu(menubar);
    pulldown[2] = buildColorMenu(menubar);
    pulldown[3] = buildRenderMenu(menubar);
    pulldown[4] = buildOptionMenu(menubar);
    pulldown[5] = buildHelpMenu(menubar);

    for (int i=0; i<6; i++)
     {  n = 0;
        XtSetArg(args[n], XmNsubMenuId, pulldown[i]); n++;
        menuButtons[i] = XtCreateManagedWidget(title[i],
            xmCascadeButtonGadgetClass, menubar, args, n);
     }
    XtVaSetValues (menubar, XmNmenuHelpWidget, menuButtons[5], NULL);

    return menubar;
}

void   deleting(int);
// void   smoothing(int);
// extern int step;
extern char outfile[];
char   Vfile[80];
int    videoFlag = 0, Vstep = 1;
int    smoothFlag = 0;                  // draw smooth/polygonal knot
int    smoothVnum = 150;
void   videoPlay(char *, float);
void   render3(int);
void   toggleTriangle();

void text_CB (Widget text_w, XtPointer, XtPointer)
{
    char   file[80], vfile[80], cmd[80], *input = XmTextGetString (text_w);; 
    float  value;
//    char   opt[10];
    int    k =  sscanf (input, "%s %f", cmd, &value);
    if (k<2) value = 0;
    extern int selectedFlag;
    selectedFlag = 0;

    switch (cmd[0]) {  
      case 'a': 
           add_vertex(int(value));
           break;
      case 'A': 
           Antialiasing(int(value));
           break;
      case 'c':
           if (value != 0) colorPeriod = value;
           render();
           break;
      case 'd':
           deleting(int(value));
           break;
      case 'e':
           if (value != 0) EdgeRadius = value;
           render();
           break;
/*
      case 'k':
           drawFlag = (drawFlag) ? 0 : 2;
           render();
           break;
*/


      case 'O':
           if (vnum==0) 
               BGMaterial->diffuseColor.setValue(BGDefault);
           if (sscanf(input, "%s %s", cmd, file)<2 || !getfile(file))
               error (myWindow, "Can not read knot file", NULL);
           break;
      case 'P':
           if (value != 0) PixPerInch = value;
           break;
      case 'p':
           pinchEdge = value;
           printf("pinchEdge: %d\n", pinchEdge);
           break;
      case 'r':
           run(int(value));
           break;
/*
      case 'R':
           if (sscanf(input, "%s %f %d %s", cmd, &value, &step, outfile)==4)
            { run(int(value));
              step = 0;
            }
           break;
*/
      case 's': 
           if (k==1) smoothFlag ^=1;
           else      smoothFlag = 1;
           smoothVnum = (k==1) ? 150 : (value < size/2) ? value : size/2;
           render();
           break; 
/*
      case 's':
           smoothing(value);
           break;
*/
      case 'S':
           if (sscanf(input, "%s %s", cmd, file)<2 )
               error (myWindow, "Can not read knot file", NULL);
           else printfile(file);
           break;
      case 't':
           if (cmd[1] == 'r' && drawFlag)
              toggleTriangle();
           else
            {
              if (value != 0) Sides = int(value);
              if (Sides > 32) Sides = 32;
              if (Sides < 1)  Sides = 1;
              render();
            }
           break;
      case 'T':
           turnpoint = value;
           printf("  Set turning point to %1.2f\n",turnpoint);
           break;
      case 'V':
           
           k = sscanf(input, "%s %s %d", cmd, Vfile, &Vstep);
           if (k > 1 || !videoFlag)
             { videoFlag = 1;
               if (k < 2) 
                   strcpy(Vfile, "video.f");
               if (k<3 || Vstep<1)
                   Vstep = 1;
               printf("Recording output to file %s.\n", Vfile);
             }
           else
             { 
               videoFlag = 0;
               printf("Recording turned off.\n");
             }
           break;
      case 'v':
           k = sscanf(input, "%s %s %f", cmd, vfile, &value);
           if (k < 2) 
                   strcpy(vfile, "video.f");
           if (k<3 || value<=0)
                   value = 1;
           videoPlay(vfile, value);
           break;
      default:
           printf("Wrong command.  Please try again.\n");
           break;
      }
   XmTextSetString (text_w, "");
}

void button_CB (Widget, XtPointer client_data, XtPointer)
{   
    char *command[] = {"", "", "add: ", "delete: "};
    int  n = (int) client_data;
    extern int drawFlag, selectedFlag, index;
    extern void addSelectedVertex(int);
    extern void removeSelectedVertex(int);

    switch (n) {  
	case 0:     
		drawFlag = (drawFlag) ? 0 : 2;
		selectedFlag = 0;
		render();
		break;
 	case 1:     
		smoothFlag ^= 1;
		smoothVnum = 150;
		selectedFlag = 0;
   		render();
                break;
	case 2: 
		if (drawFlag && selectedFlag && index%2)  // edge selected
                 {    addSelectedVertex(index/2);
                      selectedFlag = 0;
                  }
                else 
                     XmTextSetString (textWidgets[0], command[n]);
                break;
	case 3: 
		if (drawFlag && selectedFlag && index%2==0)  // vertex selected
                 {   removeSelectedVertex (index/2);
                     selectedFlag = 0;
                  }
                else 
                     XmTextSetString (textWidgets[0], command[n]);
                break;
        default:
                break;
      }
}


Widget buildControl(Widget parent)
{
    Widget  frame1 = XtVaCreateManagedWidget("controlFrame1",
                xmFrameWidgetClass,  parent, 
                XmNshadowType,  XmSHADOW_ETCHED_IN, NULL, 0);

    Widget form = XtCreateWidget("form", xmFormWidgetClass, frame1, NULL, 0);
    Widget  frame = XtVaCreateManagedWidget("controlFrame",
                xmFrameWidgetClass,  form,
                XmNshadowType,  XmSHADOW_OUT, NULL, 0);

    Arg                 args[8];
    int n = 0;
    XtSetArg(args[n], XmNtopAttachment,     XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNrightAttachment,   XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNbottomAttachment,  XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNleftOffset,  10); n++;
    XtSetArg(args[n], XmNrightOffset,  10); n++;
    XtSetArg(args[n], XmNtopOffset,  10); n++;
    XtSetArg(args[n], XmNbottomOffset,  10); n++;
    XtSetValues(frame, args, n);
    XtManageChild(form);

    Widget  rowcol = XtVaCreateWidget ("rowcolumn", 
                xmRowColumnWidgetClass,  frame,  XmNspacing, 5, NULL);

    Widget  rowcol2 = XtVaCreateWidget ("rowcolumn2", 
                xmRowColumnWidgetClass,  rowcol,  XmNspacing, 20, 
                XmNpacking, XmPACK_COLUMN, 
                XmNnumColumns, 2,
                XmNorientation, XmHORIZONTAL, 
                XmNalignment, XmALIGNMENT_CENTER,
                XmNisAligned,  True, NULL);

    char *bLabels[4] = {"edit", "smooth", "add", "delete"};
    Widget  button[4];
    for (int i=0; i<4; i++)
      { button[i] = XtVaCreateManagedWidget (bLabels[i],
             xmPushButtonGadgetClass, rowcol2, NULL);
        XtAddCallback (button[i], XmNactivateCallback, 
             button_CB, (XtPointer) i);
      }

    (void) XtVaCreateManagedWidget("separator", 
             xmSeparatorGadgetClass, rowcol, XmNheight, 6, NULL);

    XtVaCreateManagedWidget ("         COMMAND", 
             xmLabelGadgetClass, rowcol, NULL);
    textWidgets[0] = XtVaCreateManagedWidget (NULL, 
             xmTextWidgetClass, rowcol, XmNcolumns, 18, NULL);
    (void) XtVaCreateManagedWidget("separator", 
                xmSeparatorGadgetClass, rowcol, XmNheight, 6, NULL);
    XtAddCallback (textWidgets[0], XmNactivateCallback, text_CB, NULL);

    XtVaCreateManagedWidget ("           ENERGY", 
             xmLabelGadgetClass, rowcol, 
             XmNrightAttachment, XmATTACH_FORM, NULL);
    textWidgets[1] =  XtVaCreateManagedWidget (NULL, 
             xmTextWidgetClass, rowcol, 
             XmNcolumns, 18, XmNeditable, False, NULL);
    (void) XtVaCreateManagedWidget("separator", 
                xmSeparatorGadgetClass, rowcol, XmNheight, 16, NULL);

    Widget  rowcol3 = XtVaCreateWidget ("rowcolumn3", 
                xmRowColumnWidgetClass,  rowcol,  //XmNspacing, 20, 
                XmNpacking, XmPACK_COLUMN, 
                XmNnumColumns, 2,
                XmNorientation, XmVERTICAL,
                XmNalignment, XmALIGNMENT_BEGINNING,
                XmNisAligned,  True, NULL);


    char *labels[] = {"Step: ", "Edge: "};
    for (i=0; i<2; i++)
       XtVaCreateManagedWidget (labels[i], 
             xmLabelGadgetClass, rowcol3, NULL);
    for (i=0; i<2; i++)
        textWidgets[2+i] = XtVaCreateManagedWidget (NULL, 
                xmTextWidgetClass, rowcol3, XmNcolumns, 1, NULL);

/*
    char    *labels[] = {"COMMAND", "Number of edges", "Step", "Energy"};
    for (i=0; i<XtNumber (labels); i++)
      { XtVaCreateManagedWidget (labels[i], 
             xmLabelGadgetClass, rowcol, NULL);
        textWidgets[i] = (i==0) ? 
           XtVaCreateManagedWidget (NULL, xmTextWidgetClass, rowcol, 
                XmNcolumns, 18, NULL)
         : XtVaCreateManagedWidget (NULL, xmTextWidgetClass, rowcol, 
                XmNcolumns, 18,
                XmNeditable, False, NULL);
      }
    XtAddCallback (textWidgets[0], XmNactivateCallback, text_CB, NULL);
*/

    XtManageChild (rowcol);
    XtManageChild (rowcol2);
    XtManageChild (rowcol3);
    return frame1;
}        

SbBool myAppEventHandler(void *userData, XAnyEvent *anyevent);


SoXtExaminerViewer *buildMainWindow(Widget parent, SoNode *sceneGraph)
{
    Widget              form, menubar, control;
    SoXtExaminerViewer *myViewer;
    Arg                 args[8];
    int	                n;
    
    form     = XtCreateWidget("form", xmFormWidgetClass, parent, NULL, 0);
//XmChangeColor(parent, 10);

    menubar  = buildPulldownMenu(form);
//XtVaSetValues(menubar, XmNbackground, 10, NULL);
//XmChangeColor(menubar, 10);
    control  = buildControl(form);
    myViewer = new SoXtExaminerViewer(form);
    myViewer->setSceneGraph(sceneGraph);

    myViewer->setEventCallback(myAppEventHandler, myViewer);

    n = 0;
    XtSetArg(args[n], XmNtopAttachment,     XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNrightAttachment,   XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNbottomAttachment,  XmATTACH_NONE); n++;
    XtSetValues(menubar, args, n);

    n = 0;
    XtSetArg(args[n], XmNtopAttachment,     XmATTACH_WIDGET); n++;
    XtSetArg(args[n], XmNtopWidget,         menubar); n++;
    XtSetArg(args[n], XmNleftAttachment,    XmATTACH_NONE); n++;
    XtSetArg(args[n], XmNrightAttachment,   XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNbottomAttachment,  XmATTACH_FORM); n++;
    XtSetValues(control, args, n);

    n = 0;
    XtSetArg(args[n], XmNtopAttachment,     XmATTACH_WIDGET); n++;
    XtSetArg(args[n], XmNtopWidget,         menubar); n++;
    XtSetArg(args[n], XmNleftAttachment,    XmATTACH_FORM); n++;
    XtSetArg(args[n], XmNrightAttachment,   XmATTACH_WIDGET); n++;
    XtSetArg(args[n], XmNrightWidget,       control); n++;
    XtSetArg(args[n], XmNbottomAttachment,  XmATTACH_FORM); n++;
    XtSetValues(myViewer->getWidget(), args, n);

    XtManageChild(menubar);
    myViewer->show();

    XtManageChild(form);
    return myViewer;
}