/* INCLUDES */
# include <X11/Intrinsic.h>
# include <X11/StringDefs.h>
# include <Xm/Xm.h>
# include <Xm/PushB.h>
# include <Xm/MainW.h>
# include <Xm/RowColumn.h>
# include <Xm/ToggleB.h>
# include <Xm/List.h>
# include <Xm/Text.h>
# include <Xm/SelectioB.h>
# include <Xm/DialogS.h>
# include <Xm/MessageB.h>
# include <Xm/Form.h>
# include <Xm/Label.h>
# include <Xm/LabelG.h>
# include <Xm/Command.h>
# include <Xm/Separator.h>
# include <Xm/SeparatoG.h>
# include <Xm/BulletinB.h>
# include <Xm/TextF.h>


# include "winlib.h"
# include <fcntl.h>
# include <sys/stat.h>
# include "t_list.c"

/* DECLARATIONS */

/* PROTOTYPES */
void main(int argc, char **argv);
static void Application();
static void getFileInput(XtPointer client_data, int *fid,XtInputId *id);
static void ErrSys(char *msg);
Widget CreateCommandWindow(Widget parent);
void send_to_agent(term_ptr agent_term, term_ptr term);

void inform_ok(Widget w,
	       XtPointer client_data,
	       XmPushButtonCallbackStruct *call_data);
void x_window_inform(term_ptr term);
void handle_interpreter_term(term_ptr term);
extern void write_pipe(int pipe_id,term_ptr term);
extern term_ptr read_pipe(int pipe_id);
extern struct term *copy_term(struct term *t);
static void CommandApplyCB(Widget w, XtPointer client_data,
                             XmCommandCallbackStruct *call_data);
static Widget CreateMenu(Widget parent);
static char **readTextFile(char *file_name, int *counter);
static void QuitMenuCallback(Widget w,caddr_t client_data,
                             XmPushButtonCallbackStruct *call_data);
static void selection(term_ptr term);

void dialog_box(term_ptr term);
void dialog_done(Widget w,
                 XtPointer client_data,
                 XmAnyCallbackStruct *call_data);

static void SelectionOkCB(Widget w, XtPointer client_data,
                             XmPushButtonCallbackStruct *call_data);

static void SelectionCancelCB(Widget w, XtPointer client_data,
                             XmPushButtonCallbackStruct *call_data);
void inspect(term_ptr term);
void x_manager_message(char *text);
void query(term_ptr term);

/* End prototypes */


extern int	errno;
static Widget top_level;   /* Top level window */

static int input_pipe, output_pipe;
void quit_request(void);

typedef struct {
   term_ptr term;
   void *slot1;
   void *slot2;
} internal_struct;
/*
============================================================
|                         ErrSys()                         |
|----------------------------------------------------------|
|==========================================================|
*/
static void ErrSys(char *msg)
{
   printf("Error: %s\n", msg);
   quit_request();
}


/*
============================================================
|                      InterfaceExit()                     |
|----------------------------------------------------------|
|==========================================================|
*/
static void InterfaceExit()
{
   /* CloseV the pipes. */
   close(input_pipe);
   close(output_pipe);
   XtCloseDisplay(XtDisplay(top_level));
   exit(0);

}

/*
============================================================
|                          main()                          |
|----------------------------------------------------------|
|==========================================================|
*/
void main(int argc, char **argv)
{

   XtAppContext app_context;
   Arg  args[20];
   
   /* Called from interpreter */
   /* Initilize the pipes. */
   input_pipe = atoi(argv[1]);
   fcntl(input_pipe, F_SETFL, O_NDELAY);
   output_pipe = atoi(argv[2]);

   /* Create the top level window */
   argc = 1;
   top_level = XtAppInitialize(&app_context,
                               "Main",
                               NULL,
                               0,
                               (Cardinal *)&argc,
                               argv,
                               NULL,
                               args,
                               0);
   Application();

   /* Add the pipe as an input event for the window loop. */
   XtAppAddInput(app_context, input_pipe, XtInputReadMask,
                 getFileInput, NULL);
   XtRealizeWidget(top_level);
   XtAppMainLoop(app_context);
}


/*
============================================================
|                       Application()                      |
|----------------------------------------------------------|
|==========================================================|
*/
static void Application()
{


   Widget main_window; /* Main window */
   Widget menu_bar;    /* Menu bar */
   Widget command_w; /* Message area */
   
   Arg  args[20];
   
   /* Create the main window */
   XtSetArg(args[0], XmNmainWindowMarginHeight, 3 );
   XtSetArg(args[1], XmNmainWindowMarginWidth, 3 );
   XtSetArg(args[2], XmNshowSeparator, True );
   XtSetArg(args[3], XmNwidth, 400 );
   XtSetArg(args[4], XmNheight, 300 );
   main_window = XmCreateMainWindow(top_level, "main", args, 5);
   XtManageChild(main_window);
   
   
   /* Create the menu */   
   menu_bar = CreateMenu(main_window);
   command_w = CreateCommandWindow(main_window);
   XmMainWindowSetAreas(main_window, menu_bar, command_w, NULL, NULL, NULL);

}


/*
============================================================
|                      getFileInput()                      |
|----------------------------------------------------------|
|==========================================================|
*/
static void getFileInput(XtPointer client_data, int *fid,XtInputId *id)
{
  term_ptr i_term=read_pipe(*fid);
  handle_interpreter_term(i_term);
}

/* the structure of the terms transmitted from the interpreter to the
   window system is as follows: <agent,term> where agent is the agent id,
   and term is the message transmitted by the agent. the structure of the
   term is exactly as it appears in the agent program e.g.
   x_window(inform,Message,Reference).  */

void handle_interpreter_term(term_ptr term)
{
  /* all term handlers eventually garbage-collect the term (on the
     relevant call-back, if appropritate). So the term should not
     be used after the call to handle_interpreter_term */
  switch (term->argument_array[1]->argument_array[0]->functor)
  {
  case INFORM:
     x_window_inform(term);
     break;
  case QUIT_REQUEST:
     if (term->argument_array[0]->functor==X_MANAGER)
        InterfaceExit();
     break;
  case DIALOG:dialog_box(term);
     break;
  case SELECTION:selection(term);
     break;
  case INSPECT:inspect(term);
     break;
  case QUERY:query(term);
     break;
  }
}

void x_window_inform(term_ptr term)
{
  term_ptr x_message=term->argument_array[1];
  char *message_text=x_message->argument_array[1]->const_string;
  char title[]="inform message";
  Widget inform, butt, sep, msg;
  Arg  args[20];
  int counter;
  XmString xm_string;
  
  /* Create the shell widget */
  counter = 0;
  XtSetArg(args[counter], XmNnoResize,True);counter++;
  inform = XmCreateFormDialog(top_level,title,args,counter);
  
  /* Create the information message widget */
  xm_string = XmStringCreateLtoR(message_text, XmSTRING_DEFAULT_CHARSET);
  counter = 0;
  XtSetArg(args[counter], XmNlabelString, xm_string);counter++;
  XtSetArg(args[counter], XmNalignment, XmALIGNMENT_BEGINNING);counter++;
  XtSetArg(args[counter], XmNtopAttachment,XmATTACH_FORM);counter++;
  XtSetArg(args[counter], XmNtopOffset,10);counter++;
  XtSetArg(args[counter], XmNleftAttachment,XmATTACH_FORM);counter++;
  XtSetArg(args[counter], XmNleftOffset, 10);counter++;
  XtSetArg(args[counter], XmNbottomAttachment,XmATTACH_NONE);counter++;
  XtSetArg(args[counter], XmNrightAttachment,XmATTACH_FORM);counter++;
  XtSetArg(args[counter], XmNrightOffset, 10);counter++;
  msg = XmCreateLabelGadget(inform,"message",args,counter);
  XmStringFree(xm_string);
  XtManageChild(msg);
  
  /* Create the seperator widget */
  counter = 0;
  XtSetArg(args[counter], XmNheight,10);counter++;
  XtSetArg(args[counter], XmNseparatorType, XmSINGLE_LINE);counter++;
  XtSetArg(args[counter], XmNtopAttachment,XmATTACH_WIDGET);counter++;
  XtSetArg(args[counter], XmNtopWidget,msg);counter++;
  XtSetArg(args[counter], XmNtopOffset,10);counter++;
  XtSetArg(args[counter], XmNleftAttachment,XmATTACH_POSITION);counter++;
  XtSetArg(args[counter], XmNleftPosition, 0);counter++;
  XtSetArg(args[counter], XmNrightAttachment,XmATTACH_POSITION);counter++;
  XtSetArg(args[counter], XmNrightPosition, 100);counter++;
  sep = XmCreateSeparatorGadget(inform,"separator",args,counter);
  XtManageChild(sep);
  
   /* Create the dismiss button */
  xm_string = XmStringCreateLtoR("Dismissed", XmSTRING_DEFAULT_CHARSET);
  counter = 0;
  XtSetArg(args[counter], XmNlabelString, xm_string);counter++;
  XtSetArg(args[counter], XmNtopAttachment,XmATTACH_WIDGET);counter++;
  XtSetArg(args[counter], XmNtopWidget,sep);counter++;
  XtSetArg(args[counter], XmNtopOffset,10);counter++;
  XtSetArg(args[counter], XmNleftAttachment,XmATTACH_POSITION);counter++;
  XtSetArg(args[counter], XmNleftPosition, 10);counter++;
  XtSetArg(args[counter], XmNbottomAttachment,XmATTACH_FORM);counter++;
  XtSetArg(args[counter], XmNbottomOffset,10);counter++;
  XtSetArg(args[counter], XmNrightAttachment,XmATTACH_POSITION);counter++;
  XtSetArg(args[counter], XmNrightPosition, 90);counter++;
  butt = XmCreatePushButton(inform,"controlB",args,counter);
  free(xm_string);
  XtAddCallback(butt, XmNactivateCallback,
		(XtCallbackProc) inform_ok, (XtPointer) term);
  XtManageChild(butt);
  
  XtManageChild(inform);
}

/* messages from the window system to the interpreter
   have the following format:
   <agent,term> where agent is the identifier for the
   agent to whom the message is
   being sent, and term is exactly the same as
   the term that occurs as the content in
   the assimilate message */

void inform_ok(Widget w,
	       XtPointer client_data,
	       XmPushButtonCallbackStruct *call_data)


{
   term_ptr call_term=(term_ptr)(client_data);
   term_ptr agent=call_term->argument_array[0];
   term_ptr reference=call_term->argument_array[1]->argument_array[2];
   send_to_agent(agent,reference);
   free_term(call_term);
   XtDestroyWidget(XtParent(w)); 
}


/*
============================================================
|                   CreateCommandWindow()                  |
|----------------------------------------------------------|
| Params : 1)                                              |
|          2)                                              |
|          3)                                              |
| Desc   :                                                 |
|                                                          |
| Returns:                                                 |
|==========================================================|
*/
Widget CreateCommandWindow(Widget parent)
{
   Widget command_w;
   Arg  args[20];
   int counter,i;
   XmString xm_string = XmStringCreateLtoR("Enter message:", XmSTRING_DEFAULT_CHARSET);
   XtCallbackRec null_rec = {(XtCallbackProc) NULL, (caddr_t) NULL};
   XtCallbackRec apply_rec;
   XtCallbackRec apply_callback_list[2];
   char **agent_file_list;
   XmString *agent_list;
   int agent_list_counter;
   
   /* Get the agents file name. */
   agent_file_list = readTextFile(COMMAND_FILE, &agent_list_counter);
   /* Convert to X strings. */
   agent_list = (XmString *)malloc(agent_list_counter * sizeof(XmString));
   for(i=0;i<agent_list_counter;i++) {
      agent_list[i] = XmStringCreateLtoR(agent_file_list[i],
                                         XmSTRING_DEFAULT_CHARSET);
      free(agent_file_list[i]);
   }
   free(agent_file_list);
   
   apply_rec.callback = (XtCallbackProc) CommandApplyCB;
   apply_rec.closure  = (XtPointer) NULL;
   apply_callback_list[1] = null_rec;
      apply_callback_list[0]  = apply_rec;


   /* Create the command widget */
   counter = 0;
      XtSetArg(args[counter],XmNcommandEnteredCallback, apply_callback_list); counter++;
   XtSetArg(args[counter],XmNpromptString, xm_string);counter++;
   XtSetArg(args[counter],XmNx, 0);counter++;
   XtSetArg(args[counter],XmNy,50);counter++;
   XtSetArg(args[counter],XmNtextColumns,50);counter++;
   XtSetArg(args[counter],XmNhistoryItems, agent_list);counter++;
   XtSetArg(args[counter],XmNhistoryItemCount,agent_list_counter);counter++;
   command_w = XmCreateCommand(parent, "command", args, counter);

   
   XtManageChild(command_w);
   XmStringFree(xm_string);
   for(i=0;i<agent_list_counter;i++)
      XmStringFree(agent_list[i]);
   free(agent_list);
   return(command_w);
}

/*
============================================================
|                       CreateMenu()                       |
|----------------------------------------------------------|
| Params : 1)                                              |
|          2)                                              |
|          3)                                              |
| Desc   :                                                 |
|                                                          |
| Returns:                                                 |
|==========================================================|
*/
static Widget CreateMenu(Widget parent)
{
   void spy_callback(Widget w,caddr_t client_data, void *call_data);
                     
   Widget menu_bar;
   Widget schedule_menu, quit_menu;
   Arg args[20];
   XmString bar_items[5], schedule_items[6], quit_items[1];
   XmButtonType bar_items_type[5], schedule_items_type[6], quit_items_type[1];
   XmString bar_accelerator[5];

   /* Create the bar items labels*/
   bar_items[0] = XmStringCreateLtoR("Spy", XmSTRING_DEFAULT_CHARSET);
   /*
   bar_items[1] = XmStringCreateLtoR("Send mesage to agent", XmSTRING_DEFAULT_CHARSET);
   bar_items[2] = XmStringCreateLtoR("Mail", XmSTRING_DEFAULT_CHARSET);
   bar_items[3] = XmStringCreateLtoR("Options", XmSTRING_DEFAULT_CHARSET);
   */
   bar_items[1] = XmStringCreateLtoR("Quit", XmSTRING_DEFAULT_CHARSET);
   /* Bar items type */
   bar_items_type[0] = XmCASCADEBUTTON;
   bar_items_type[1] = XmCASCADEBUTTON;
   /*
   bar_items_type[2] = XmCASCADEBUTTON;
   bar_items_type[3] = XmCASCADEBUTTON;
   bar_items_type[4] = XmCASCADEBUTTON;
   */
   /* Bar items quick keys */
   bar_accelerator[0] = XmStringCreateLtoR("Alt-S", XmSTRING_DEFAULT_CHARSET);
   /*
   bar_accelerator[1] = XmStringCreateLtoR("Alt-E", XmSTRING_DEFAULT_CHARSET);
   bar_accelerator[2] = XmStringCreateLtoR("Alt-M", XmSTRING_DEFAULT_CHARSET);
   bar_accelerator[3] = XmStringCreateLtoR("Alt-O", XmSTRING_DEFAULT_CHARSET);
   */
   bar_accelerator[1] = XmStringCreateLtoR("Alt-Q", XmSTRING_DEFAULT_CHARSET);
   /* Set the arguments */
   XtSetArg(args[0], XmNbuttonCount, 2);
   XtSetArg(args[1], XmNbuttons, bar_items);
   XtSetArg(args[2], XmNbuttonType, bar_items_type);
   XtSetArg(args[3], XmNbuttonAcceleratorText, bar_accelerator);
   XtSetArg(args[4], XmNadjustLast, False);
   /* Create the menu bar widget */
   menu_bar = XmCreateSimpleMenuBar(parent, "MenuBar", args, 5);
   XtManageChild(menu_bar);


   /* Create the pull-down menus */

   /* Agents menu */
   schedule_items[0] = XmStringCreateLtoR("State", XmSTRING_DEFAULT_CHARSET);
/*   schedule_items[1] = XmStringCreateLtoR("Interval", XmSTRING_DEFAULT_CHARSET);
   schedule_items[2] = XmStringCreateLtoR("Inform", XmSTRING_DEFAULT_CHARSET);
   schedule_items[3] = XmStringCreateLtoR("Question", XmSTRING_DEFAULT_CHARSET);
   schedule_items[4] = XmStringCreateLtoR("", XmSTRING_DEFAULT_CHARSET);
   schedule_items[5] = XmStringCreateLtoR("Compile", XmSTRING_DEFAULT_CHARSET);*/
   /* Agents items type */
   schedule_items_type[0] = XmPUSHBUTTON;
/*   schedule_items_type[1] = XmPUSHBUTTON;
   schedule_items_type[2] = XmPUSHBUTTON;
   schedule_items_type[3] = XmPUSHBUTTON;
   schedule_items_type[4] = XmSEPARATOR;
   schedule_items_type[5] = XmPUSHBUTTON;*/
   /* Set the arguments */
   XtSetArg(args[0], XmNbuttonCount, 1);
   XtSetArg(args[1], XmNbuttons, schedule_items);
   XtSetArg(args[2], XmNbuttonType, schedule_items_type);
   XtSetArg(args[3], XmNpostFromButton, 0);
   XtSetArg(args[4], XmNsimpleCallback, (XtCallbackProc)spy_callback);
   schedule_menu = XmCreateSimplePulldownMenu(menu_bar, "Control", args, 5);

   /* Quit menu */
   quit_items[0] = XmStringCreateLtoR("Exit", XmSTRING_DEFAULT_CHARSET);
   /* Quit items type */
   quit_items_type[0] = XmPUSHBUTTON;
   XtSetArg(args[0], XmNbuttonCount, 1);
   XtSetArg(args[1], XmNbuttons, quit_items);
   XtSetArg(args[2], XmNbuttonType, quit_items_type);
   XtSetArg(args[3], XmNpostFromButton, 1);
   XtSetArg(args[4], XmNsimpleCallback, (XtCallbackProc)QuitMenuCallback);
   quit_menu = XmCreateSimplePulldownMenu(menu_bar, "QuitMenu", args, 5);
   
   return(menu_bar);
}


/*
============================================================
|                     CommandApplyCB()                     |
|----------------------------------------------------------|
| Params : 1)                                              |
|          2)                                              |
|          3)                                              |
| Desc   :                                                 |
|                                                          |
| Returns:                                                 |
|==========================================================|
*/
static void CommandApplyCB(Widget w, XtPointer client_data,
                             XmCommandCallbackStruct *call_data)
{
   char *buffer;
   term_ptr command_term;
   term_ptr agent_term=maketerm(NONVAR,X_MANAGER,0,NULL,NULL);
   XmStringGetLtoR(call_data->value, XmSTRING_DEFAULT_CHARSET, &buffer);
   command_term=maketerm(STRING,0,0,buffer,NULL);
   send_to_agent(agent_term,command_term);
   free(agent_term);
   free_term(command_term);
}


/*
============================================================
|                      readTextFile()                      |
|----------------------------------------------------------|
| Params : 1)                                              |
|          2)                                              |
|          3)                                              |
| Desc   :                                                 |
|                                                          |
| Returns:                                                 |
| Created by: avrami tzur                                  |
| At: Fri Sep  4 14:02:00 1992                             |
|==========================================================|
*/
static char **readTextFile(char *file_name, int *counter)
{
   char **agent_file = NULL;
   FILE *stream;
   struct stat dir_status;
   char temp[100];

   *counter = 0;
   
   if(stat(file_name,&dir_status) == -1){
      /* No agent file. */
   }
   else {
      
      agent_file = (char **)malloc(100*sizeof(char *));
      /* Open the file. */
      if ((stream = fopen(file_name, "r")) == NULL) {
         ErrSys("Unable to open file");
      }
      while ( fgets(temp, 100, stream) ) {
         /* Trim the new-line charecter. */
         temp[strlen(temp)-1] = '\0';
         agent_file[*counter] = (char *)malloc(strlen(temp)+1);
         strcpy(agent_file[*counter], temp);
         *counter = *counter +1;
      }
      fclose(stream);
   }
   return(agent_file);
}

/*
============================================================
|                    QuitMenuCallback()                    |
|----------------------------------------------------------|
| Params : 1)                                              |
|          2)                                              |
|          3)                                              |
| Desc   :                                                 |
|                                                          |
| Returns:                                                 |
|==========================================================|
*/
static void QuitMenuCallback(Widget w,caddr_t client_data,
                             XmPushButtonCallbackStruct *call_data)
{
   quit_request();
}

void quit_request()
{
   term_ptr quit_term=maketerm(NONVAR,QUIT_REQUEST,0,NULL,NULL);
   term_ptr agent_term=maketerm(NONVAR,X_MANAGER,0,NULL,NULL);
   send_to_agent(agent_term,quit_term);
   free(quit_term);
   free(agent_term);
}


/*
============================================================
|                      spy_callback()                      |
|----------------------------------------------------------|
| Params : 1)                                              |
|          2)                                              |
|          3)                                              |
| Desc   :                                                 |
|                                                          |
| Returns:                                                 |
|==========================================================|
*/
void spy_callback(Widget w,caddr_t client_data, void *call_data)
{
   switch ((int)client_data)
   {
   case 0:
      x_manager_message("request(tms_spy,create)");
      break;
   }
}

/*
============================================================
|                      send_to_agent()                     |
|----------------------------------------------------------|
| Params : 1) an integer representing an agent             |
|          2) a term                                       |
| Desc   : creates a tuple <agent,term> and sends it down
           the pipe to the agent.
|==========================================================|
*/
void send_to_agent(term_ptr agent_term, term_ptr term)
{
   term_ptr *args=maketermarray(2);
   term_ptr send_term=maketerm(TUPLE,0,2,NULL,args);
   args[0]=agent_term;
   args[1]=term;
   write_pipe(output_pipe,send_term);
   free(args);
   free(send_term);
}

/* the structure of the dialog_box call is:
   x_window(dialog,Message,Reference)
   and the message sent in response is:
   */
void dialog_box(term_ptr term)
{
   char new_string1[200];
   char title[]="dialog box";
   Widget dialog;
   Widget Text2;
   Widget msg;
   Widget sep;
   Arg args[20];
   int n;
   XFontStruct *newfont;
   XmString dialog_string;
   XmFontList newfontlist;

   term_ptr agent=term->argument_array[0];
   
   new_string1[0]=0;
   /* create the shell widget */
   n=0;
   XtSetArg(args[n], XmNnoResize,True);n++;
   dialog = XmCreateFormDialog(top_level,"dialog",args,n);
   XtManageChild(dialog);
   newfont=XLoadQueryFont(XtDisplay(top_level),"8x13");
   newfontlist=XmFontListCreate(newfont, XmSTRING_DEFAULT_CHARSET);
   
   /* Create the dialog  message widget */
   dialog_string=XmStringCreate(term->argument_array[1]->
                                     argument_array[1]->const_string,
                                XmSTRING_DEFAULT_CHARSET);
   n = 0;
   XtSetArg(args[n], XmNlabelString, dialog_string);n++;
   XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING);n++;
   XtSetArg(args[n], XmNtopAttachment,XmATTACH_FORM);n++;
   XtSetArg(args[n], XmNtopOffset,10);n++;
   XtSetArg(args[n], XmNleftAttachment,XmATTACH_FORM);n++;
   XtSetArg(args[n], XmNleftOffset, 10);n++;
   XtSetArg(args[n], XmNbottomAttachment,XmATTACH_NONE);n++;
   XtSetArg(args[n], XmNrightAttachment,XmATTACH_FORM);n++;
   XtSetArg(args[n], XmNrightOffset, 10);n++;
   msg=XmCreateLabel(dialog,"msg",args,n);
   XtManageChild(msg);
   XmStringFree(dialog_string);

   /* now create the single line text widget */
   n=0;
   XtSetArg(args[n],XmNy,40);n++;
   XtSetArg(args[n],XmNcolumns, 25);n++;
   XtSetArg(args[n],XmNrows,1);n++;
   XtSetArg(args[n],XmNeditMode, XmSINGLE_LINE_EDIT); n++;
   XtSetArg(args[n],XmNvalue,new_string1);n++;
   XtSetArg(args[n],XmNfontList, newfontlist);n++;
   Text2=XmCreateText(dialog,"Text2",args,n);
   XtAddCallback(Text2, XmNactivateCallback,
		(XtCallbackProc) dialog_done, (XtPointer) term);
   XtManageChild(Text2);
}

void dialog_done(Widget w,
                 XtPointer client_data,
                 XmAnyCallbackStruct *call_data)
{
   term_ptr call_term=(term_ptr)(client_data);
   term_ptr agent=call_term->argument_array[0];
   term_ptr reference=call_term->argument_array[1]->argument_array[2];
   term_ptr *response_arg=maketermarray(2);
   char *message=XmTextGetString(w);
   term_ptr message_term=maketerm(STRING,0,0,message,NULL);
   term_ptr response_term=maketerm(TUPLE,0,2,NULL,response_arg);
   response_arg[0]=reference;
   response_arg[1]=message_term;
   send_to_agent(agent,response_term);
   free(response_term);
   free(message_term);
   free(response_arg);
   free_term(call_term);
   XtFree(message);
   XtDestroyWidget(XtParent(w));
}

static void selection(term_ptr term)
{
   int counter, i;
   XmString xstring;
   term_ptr option_list=term->argument_array[1]->argument_array[2];
   term_ptr default_list=term->argument_array[1]->argument_array[3];
   int option_count=t_length(option_list);
   char *message=term->argument_array[1]->argument_array[1]->const_string;
   Widget board_w, rowcol_w, label_w,butt_done,butt_cancel;
   Widget *button_w = (Widget *)malloc(option_count*sizeof(Widget));
   internal_struct *data =
      (internal_struct *)malloc(sizeof(internal_struct));
   Arg  args[20];
   
   /* Create the shell window. */
   counter = 0;
   XtSetArg(args[counter],XmNnoResize, True);counter++;
   xstring = XmStringCreateLtoR("selection",
                                XmSTRING_DEFAULT_CHARSET);
   XtSetArg(args[counter],XmNdialogTitle, xstring);counter++;
   board_w = XmCreateFormDialog(top_level,"interval",args,counter);
   XmStringFree(xstring);

   /* Create the label widget. */
   xstring = XmStringCreateLtoR(message, XmSTRING_DEFAULT_CHARSET);
   counter = 0;
   XtSetArg(args[counter], XmNlabelString, xstring);counter++;
   XtSetArg(args[counter], XmNalignment, XmALIGNMENT_BEGINNING);counter++;
   XtSetArg(args[counter], XmNtopAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter], XmNtopOffset,10);counter++;
   XtSetArg(args[counter], XmNleftAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter], XmNleftOffset, 10);counter++;
   XtSetArg(args[counter], XmNbottomAttachment,XmATTACH_NONE);counter++;
   XtSetArg(args[counter], XmNrightAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter], XmNrightOffset, 10);counter++;
   label_w = XmCreateLabelGadget(board_w,"message",args,counter);
   XmStringFree(xstring);
   XtManageChild(label_w);
   
   /* Create the RowCol container window. */
   counter = 0;
   XtSetArg(args[counter], XmNtopAttachment,XmATTACH_WIDGET);counter++;
   XtSetArg(args[counter], XmNtopWidget,label_w);counter++;
   XtSetArg(args[counter], XmNtopOffset,10);counter++;
   XtSetArg(args[counter], XmNrightAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter], XmNrightOffset, 10);counter++;
   XtSetArg(args[counter], XmNbottomAttachment,XmATTACH_NONE);counter++;
   XtSetArg(args[counter], XmNleftAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter], XmNleftOffset, 10);counter++;
   XtSetArg(args[counter],XmNspacing, 5);counter++;
   XtSetArg(args[counter],XmNnumColumns, 3);counter++;
   XtSetArg(args[counter],XmNpacking, XmPACK_COLUMN);counter++;
   XtSetArg(args[counter],XmNadjustLast, False);counter++;
   XtSetArg(args[counter],XmNorientation, XmHORIZONTAL);counter++;
   rowcol_w = XmCreateRowColumn(board_w,"rowcol",args,counter);
   XtManageChild(rowcol_w);
   
   /* Create the buttons window */
   for (i=0; i<option_count; i++){
      char *option_string=NULL;
      term_ptr option=t_nth(option_list,i);
      counter = 0;
      if (option!=NULL) option_string=option->const_string;
      if (t_f_member(i+1,default_list))
          {
             XtSetArg(args[counter], XmNset, True);counter++;
          }
      XtSetArg(args[counter], XmNindicatorOn, True);counter++;
      xstring = XmStringCreateLtoR(option_string,XmSTRING_DEFAULT_CHARSET);
      XtSetArg(args[counter], XmNlabelString, xstring);counter++;
      button_w[i]= XmCreateToggleButton(rowcol_w, "radio", args, counter);
      XmStringFree(xstring);
   }
   XtManageChildren(button_w,option_count);
   
   data->term = term;
   data->slot1 = (void *)option_count;
   data->slot2 = (void *)button_w;

   /* Create the Done button */
   xstring = XmStringCreateLtoR("Done", XmSTRING_DEFAULT_CHARSET);
   counter = 0;
   XtSetArg(args[counter], XmNlabelString, xstring);counter++;
   XtSetArg(args[counter], XmNtopAttachment,XmATTACH_WIDGET);counter++;
   XtSetArg(args[counter], XmNtopWidget,rowcol_w);counter++;
   XtSetArg(args[counter], XmNtopOffset,10);counter++;
   XtSetArg(args[counter], XmNleftAttachment,XmATTACH_POSITION);counter++;
   XtSetArg(args[counter], XmNleftPosition, 10);counter++;
   XtSetArg(args[counter], XmNbottomAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter], XmNbottomOffset,10);counter++;
   XtSetArg(args[counter], XmNrightAttachment,XmATTACH_NONE);counter++;
   butt_done = XmCreatePushButton(board_w,"controlB",args,counter);
   XmStringFree(xstring);
   
   XtAddCallback(butt_done, XmNactivateCallback,
                 (XtCallbackProc)&SelectionOkCB , (XtPointer) data);
   XtManageChild(butt_done);

   /* Create the Cancel button */
   xstring = XmStringCreateLtoR("Cancel", XmSTRING_DEFAULT_CHARSET);
   counter = 0;
   XtSetArg(args[counter], XmNlabelString, xstring);counter++;
   XtSetArg(args[counter], XmNleftAttachment,XmATTACH_WIDGET);counter++;
   XtSetArg(args[counter], XmNleftWidget,butt_done);counter++;
   XtSetArg(args[counter], XmNleftOffset,10);counter++;
   XtSetArg(args[counter], XmNtopAttachment,XmATTACH_WIDGET);counter++;
   XtSetArg(args[counter], XmNtopWidget,rowcol_w);counter++;
   XtSetArg(args[counter], XmNtopOffset,10);counter++;
   XtSetArg(args[counter], XmNbottomAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter], XmNbottomOffset,10);counter++;
   butt_cancel = XmCreatePushButton(board_w,"controlB",args,counter);
   XmStringFree(xstring);
   XtAddCallback(butt_cancel, XmNactivateCallback,
                 (XtCallbackProc)&SelectionCancelCB , (XtPointer) data);
   XtManageChild(butt_cancel);
   XtManageChild(board_w);
}

static void SelectionOkCB(Widget w, XtPointer client_data,
                             XmPushButtonCallbackStruct *call_data)
{
   internal_struct *data = (internal_struct *)client_data;
   term_ptr term=data->term;
   term_ptr agent=term->argument_array[0];
   int i,option_count=(int)(data->slot1);
   Widget *button_w = (Widget *)data->slot2;
   term_ptr result=t_null();
   term_ptr *args=maketermarray(2);
   term_ptr tuple=maketerm(TUPLE,0,2,NULL,args);
   /* Find out which buttons are set. */
   for (i=0; i< option_count; i++)
      if(XmToggleButtonGetState(button_w[i]))
         result=t_cons(maketerm(INTEGER,i+1,0,NULL,NULL),result);
   args[0]=term->argument_array[1]->argument_array[4];
   args[1]=result;
   send_to_agent(agent,tuple);
   free(args);
   free(tuple);
   free_term(result);
   free_term(term);
   free(data);
   XtDestroyWidget(XtParent(w));
}

   
/*
============================================================
|                    IntervalCancelCB()                    |
|----------------------------------------------------------|
| Params : 1)                                              |
|          2)                                              |
|          3)                                              |
| Desc   :                                                 |
|                                                          |
| Returns:                                                 |
|==========================================================|
*/
static void SelectionCancelCB(Widget w, XtPointer client_data,
                             XmPushButtonCallbackStruct *call_data)
{
   internal_struct *data = (internal_struct *)client_data;
   term_ptr term=data->term;
   term_ptr agent=term->argument_array[0];
   term_ptr *args=maketermarray(2);
   term_ptr tuple=maketerm(TUPLE,0,2,NULL,args);
   args[0]=term->argument_array[1]->argument_array[4];
   args[1]=maketerm(NONVAR,CANCEL,0,NULL,NULL);
   send_to_agent(agent,tuple);
   free(args[1]);
   free(args);
   free(tuple);
   free_term(term);
   free(data);
   XtDestroyWidget(XtParent(w));
}

typedef struct {
   term_ptr call_term;
   Widget shell;
   Widget text;
   Widget agent;
   Widget state;
   Widget goal;
} inspect_complex;

/*
============================================================
|                         inspect_create()                 |
|----------------------------------------------------------|
| Desc   : creates a window for inspecting TMS nodes       |

| returns the address of the created inspect_complex       |
|==========================================================|
*/
void inspect_create(term_ptr term)
{
   inspect_complex *w=(inspect_complex *)malloc(sizeof(inspect_complex));
   int i, counter =0;
   int min_width=100;
   int temp_width;
   XmString x_string;
   Arg args[20];
   void create_done(inspect_complex *w);
   void inspect_state(Widget w,
                  XtPointer client_data,
                  void *call_data);
   void inspect_goal(Widget w,
                  XtPointer client_data,
                  void *call_data);
   
   void inspect_text(Widget w,
                     XtPointer client_data,
                     void *call_data);

   void inspect_agent(Widget w,
                     XtPointer client_data,
                     void *call_data);
   void inspect_dismiss(Widget dw,
                     XtPointer client_data,
                     void *call_data);
   Widget dismiss;
   Widget separator;
   w->call_term=term;
   
   /* create the shell widget */
   counter=0;
   x_string=XmStringCreateLtoR("inspect",XmSTRING_DEFAULT_CHARSET);
   XtSetArg(args[counter], XmNdialogTitle, x_string);counter++;
   w->shell=XmCreateFormDialog(top_level,"inspect",args,counter);
   XtManageChild(w->shell);
   XmStringFree(x_string);

   /* create the agent label widget */
   x_string=XmStringCreate(term->argument_array[1]->
                           argument_array[2]->const_string,
                           XmSTRING_DEFAULT_CHARSET);
   counter=0;
   XtSetArg(args[counter], XmNlabelString, x_string);counter++;
   XtSetArg(args[counter],XmNtopAttachment,XmATTACH_FORM);counter++;
   w->agent=XmCreateLabel(w->shell,"agent",args,counter);
   XtManageChild(w->agent);
   XmStringFree(x_string);
   
   /* create the text label widgeth */
   x_string=XmStringCreate(term->argument_array[1]->
                           argument_array[3]->const_string,
                           XmSTRING_DEFAULT_CHARSET);
   counter=0;
   XtSetArg(args[counter], XmNlabelString, x_string);counter++;
   XtSetArg(args[counter],XmNtopAttachment,XmATTACH_WIDGET);counter++;
   XtSetArg(args[counter],XmNtopWidget,w->agent);counter++;
   w->text=XmCreateLabel(w->shell,"text",args,counter);
   XtManageChild(w->text);
   XmStringFree(x_string);

   /* create the separator widget */
   counter=0;
   XtSetArg(args[counter],XmNwidth,100);counter++;
   XtSetArg(args[counter],XmNorientation,XmHORIZONTAL);counter++;
   XtSetArg(args[counter],XmNleftAttachment,XmATTACH_FORM);counter++;
/*   XtSetArg(args[counter],XmNrightAttachment,XmATTACH_FORM);counter++;*/
   XtSetArg(args[counter],XmNtopAttachment,XmATTACH_WIDGET);counter++;
   XtSetArg(args[counter],XmNtopWidget,w->text);counter++;
   separator=XmCreateSeparator(w->shell,"separator",args,counter);
   XtManageChild(separator);
   
   /* create the state button */
   counter=0;
   XtSetArg(args[counter],XmNleftAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter],XmNtopAttachment,XmATTACH_WIDGET);counter++;
   XtSetArg(args[counter], XmNtopWidget,separator);counter++;
   w->state=XmCreateToggleButton(w->shell,"state",args,counter);
   XtAddCallback(w->state,XmNvalueChangedCallback,
                 (XtCallbackProc)inspect_state,(XtPointer)w);
   XtManageChild(w->state);

   /* create the goal button */
   counter=0;
   XtSetArg(args[counter],XmNleftAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter],XmNtopAttachment,XmATTACH_WIDGET);counter++;
   XtSetArg(args[counter], XmNtopWidget,w->state);counter++;
   w->goal=XmCreateToggleButton(w->shell,"goal",args,counter);
   XtAddCallback(w->goal,XmNvalueChangedCallback,
                 (XtCallbackProc)inspect_goal,(XtPointer)w);
   XtManageChild(w->goal);
 
   /* create the dismiss button */
   counter=0;
   XtSetArg(args[counter],XmNrightAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter],XmNbottomAttachment,XmATTACH_FORM);counter++;
   dismiss=XmCreatePushButton(w->shell,"dismiss",args,counter);
   XtAddCallback(dismiss,XmNactivateCallback,
                 (XtCallbackProc)inspect_dismiss,(XtPointer)w);
   XtManageChild(dismiss);
   create_done(w);
}

void inspect_state(Widget wg,
                  XtPointer client_data,
                  void *call_data)
{
   inspect_complex *w=(inspect_complex *)client_data;
   term_ptr call_term=w->call_term;
   term_ptr agent=call_term->argument_array[0];
   term_ptr state_term=maketerm(NONVAR,STATE,0,NULL,NULL);
   term_ptr reference=maketerm(INTEGER, (int)w, 0,NULL,NULL);
   term_ptr *response_arg=maketermarray(3);
   int value= XmToggleButtonGetState(wg);
   term_ptr message_term=maketerm(INTEGER,value,0,NULL,NULL);
   term_ptr response_term=maketerm(TUPLE,0,3,NULL,response_arg);
   response_arg[0]=reference;
   response_arg[1]=state_term;
   response_arg[2]=message_term;
   send_to_agent(agent,response_term);
   free(state_term);
   free(reference);
   free(response_term);
   free(message_term);
   free(response_arg);
}
   

void inspect_goal(Widget wg,
                   XtPointer client_data,
                   void *call_data)
{
   inspect_complex *w=(inspect_complex *)client_data;
   term_ptr call_term=w->call_term;
   term_ptr agent=call_term->argument_array[0];
   term_ptr goal_term=maketerm(NONVAR,GOAL,0,NULL,NULL);
   term_ptr reference=maketerm(INTEGER, (int)w, 0,NULL,NULL);
   term_ptr *response_arg=maketermarray(3);
   int value= XmToggleButtonGetState(wg);
   term_ptr message_term=maketerm(INTEGER,value,0,NULL,NULL);
   term_ptr response_term=maketerm(TUPLE,0,3,NULL,response_arg);
   response_arg[0]=reference;
   response_arg[1]=goal_term;
   response_arg[2]=message_term;
   send_to_agent(agent,response_term);
   free(goal_term);
   free(reference);
   free(response_term);
   free(message_term);
   free(response_arg);
}
void inspect_dismiss(Widget dw,
                     XtPointer client_data,
                     void *call_data)
{
   inspect_complex *w= (inspect_complex *)client_data;
   term_ptr call_term=w->call_term;
   term_ptr agent=call_term->argument_array[0];
   term_ptr dismiss_term=maketerm(NONVAR,DISMISS,0,NULL,NULL);
   term_ptr reference=maketerm(INTEGER, (int)w, 0,NULL,NULL);
   term_ptr *response_arg=maketermarray(2);
   term_ptr response_term=maketerm(TUPLE,0,2,NULL,response_arg);
   response_arg[0]=reference;
   response_arg[1]=dismiss_term;
   send_to_agent(agent,response_term);
   free(reference);
   free(dismiss_term);
   free(response_term);
   free(response_arg);
   free_term(call_term);
   free(w);
   XtDestroyWidget(XtParent(dw));
}
void inspect_text(Widget wg,
                   XtPointer client_data,
                   void *call_data)
{
   inspect_complex *w=(inspect_complex *)client_data;
   term_ptr call_term=w->call_term;
   term_ptr agent=call_term->argument_array[0];
   term_ptr text_term=maketerm(NONVAR,TEXT,0,NULL,NULL);
   term_ptr reference=maketerm(INTEGER, (int)w, 0,NULL,NULL);
   term_ptr *response_arg=maketermarray(3);
   char *value= XmTextGetString(wg);
   term_ptr message_term=maketerm(STRING,0,0,value,NULL);
   term_ptr response_term=maketerm(TUPLE,0,3,NULL,response_arg);
   response_arg[0]=reference;
   response_arg[1]=text_term;
   response_arg[2]=message_term;
   send_to_agent(agent,response_term);
   XtFree(value);
   free(text_term);
   free(reference);
   free(response_term);
   free(message_term);
   free(response_arg);
}
void inspect_agent(Widget wg,
                   XtPointer client_data,
                   void *call_data)
{
   inspect_complex *w=(inspect_complex *)client_data;
   term_ptr call_term=w->call_term;
   term_ptr agent=call_term->argument_array[0];
   term_ptr text_term=maketerm(NONVAR,AGENT,0,NULL,NULL);
   term_ptr reference=maketerm(INTEGER, (int)w, 0,NULL,NULL);
   term_ptr *response_arg=maketermarray(3);
   char *value= XmTextGetString(wg);
   term_ptr message_term=maketerm(STRING,0,0,value,NULL);
   term_ptr response_term=maketerm(TUPLE,0,3,NULL,response_arg);
   response_arg[0]=reference;
   response_arg[1]=text_term;
   response_arg[2]=message_term;
   send_to_agent(agent,response_term);
   XtFree(value);
   free(reference);
   free(text_term);
   free(response_term);
   free(message_term);
   free(response_arg);
}
/*
============================================================
|                       create_done()                      |
|----------------------------------------------------------|
| Params : 
|          1) the address of the inspect complex created   |
| Desc   : sends the appropriate message to the initiating
           agent
|                                                          |
|==========================================================|
*/
void create_done(inspect_complex *w)
{
   term_ptr call_term=w->call_term;
   term_ptr agent=call_term->argument_array[0];
   term_ptr reference=call_term->argument_array[1]->argument_array[4];
   term_ptr *response_arg=maketermarray(2);
   int address= (int)w;
   term_ptr value=maketerm(INTEGER,address,0,NULL,NULL);
   term_ptr response_term=maketerm(TUPLE,0,2,NULL,response_arg);
   response_arg[0]=reference;
   response_arg[1]=value;
   send_to_agent(agent,response_term);
   free(response_term);
   free(value);
   free(response_arg);
}

void inspect_goal_value(term_ptr term)
{
   inspect_complex *w=(inspect_complex *)
         (term->argument_array[1]->argument_array[3]->functor);
   int value=term->argument_array[1]->argument_array[2]->functor;
   Arg args[3];
   int counter=0;
   Widget goal=w->goal;
   XtSetArg(args[counter], XmNset, value);counter++;
   XtSetValues(goal,args,1);
}
void inspect_state_value(term_ptr term)
{
   inspect_complex *w=(inspect_complex *)
         (term->argument_array[1]->argument_array[3]->functor);
   int value=term->argument_array[1]->argument_array[2]->functor;
   Arg args[3];
   int counter=0;
   Widget state=w->state;
   XtSetArg(args[counter], XmNset, value);counter++;
   XtSetValues(state,args,1);
}
/*
============================================================
|                         inspect()                        |
|----------------------------------------------------------|
| Params : 1) a term                                       |
| Desc   :handles an inspection window term
|                                                          |
|==========================================================|
*/
void inspect(term_ptr term)
{
   int message_type=term->argument_array[1]->argument_array[1]->functor;
   switch (message_type)
   {
   case CREATE:inspect_create(term);
      break;
   case GOAL:inspect_goal_value(term);
      break;
   case STATE:inspect_state_value(term);
      break;
   }
}

void x_manager_message(char *text)
{
   term_ptr term_template(char *template);
   
   term_ptr agent=term_template("n");
   term_ptr message=term_template("s");
   
   agent->functor=X_MANAGER;
   message->const_string=text;
   send_to_agent(agent,message);
   free(agent);
   free(message);
}

void query(term_ptr term)
{
   void query_yes(Widget w,
                 XtPointer client_data,
                 XmAnyCallbackStruct *call_data);
   void query_no(Widget w,
                 XtPointer client_data,
                 XmAnyCallbackStruct *call_data);
   
   term_ptr x_message=term->argument_array[1];
   char *message=x_message->argument_array[1]->const_string;
   Widget question, butt_yes, butt_no, sep, msg;
   Arg  args[20];
   int counter;
   XmString xm_string;
   
   /* Create the shell widget */
   counter = 0;
   XtSetArg(args[counter], XmNnoResize,True);counter++;
   question = XmCreateFormDialog(top_level,"question",args,counter);

   /* Create the questionation message widget */
   xm_string = XmStringCreateLtoR(message, XmSTRING_DEFAULT_CHARSET);
   counter = 0;
   XtSetArg(args[counter],XmNlabelString, xm_string);counter++;
   XtSetArg(args[counter],XmNalignment, XmALIGNMENT_BEGINNING);counter++;
   XtSetArg(args[counter], XmNtopAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter], XmNtopOffset,10);counter++;
   XtSetArg(args[counter], XmNleftAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter], XmNleftOffset, 10);counter++;
   XtSetArg(args[counter], XmNbottomAttachment,XmATTACH_NONE);counter++;
   XtSetArg(args[counter], XmNrightAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter], XmNrightOffset, 10);counter++;
   msg = XmCreateLabelGadget(question,"message",args,counter);
   XmStringFree(xm_string);
   XtManageChild(msg);
   
   /* Create the seperator widget */
   counter = 0;
   XtSetArg(args[counter], XmNheight,10);counter++;
   XtSetArg(args[counter], XmNseparatorType, XmSINGLE_LINE);counter++;
   XtSetArg(args[counter], XmNtopAttachment,XmATTACH_WIDGET);counter++;
   XtSetArg(args[counter], XmNtopOffset,10);counter++;
   XtSetArg(args[counter], XmNtopWidget,msg);counter++;
   XtSetArg(args[counter], XmNleftAttachment,XmATTACH_POSITION);counter++;
   XtSetArg(args[counter], XmNleftPosition, 0);counter++;
   XtSetArg(args[counter], XmNrightAttachment,XmATTACH_POSITION);counter++;
   XtSetArg(args[counter], XmNrightPosition, 100);counter++;
   XtSetArg(args[counter], XmNbottomAttachment,XmATTACH_NONE);counter++;
   sep = XmCreateSeparatorGadget(question,"separator",args,counter);
   XtManageChild(sep);
   
   /* Create the yes button */
   xm_string = XmStringCreateLtoR("Yes", XmSTRING_DEFAULT_CHARSET);
   counter = 0;
   XtSetArg(args[counter], XmNlabelString, xm_string);counter++;
   XtSetArg(args[counter], XmNtopAttachment,XmATTACH_WIDGET);counter++;
   XtSetArg(args[counter], XmNtopWidget,sep);counter++;
   XtSetArg(args[counter], XmNtopOffset,10);counter++;
   XtSetArg(args[counter], XmNleftAttachment,XmATTACH_POSITION);counter++;
   XtSetArg(args[counter], XmNleftPosition, 20);counter++;
   XtSetArg(args[counter], XmNbottomAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter], XmNbottomOffset,10);counter++;
   XtSetArg(args[counter], XmNrightAttachment,XmATTACH_NONE);counter++;
   butt_yes = XmCreatePushButton(question,"controlB",args,counter);
   free(xm_string);
   XtAddCallback(butt_yes, XmNactivateCallback,
                 (XtCallbackProc) query_yes, (XtPointer) term);
   XtManageChild(butt_yes);

   /* Create the no button */
   xm_string = XmStringCreateLtoR("No", XmSTRING_DEFAULT_CHARSET);
   counter = 0;
   XtSetArg(args[counter], XmNlabelString, xm_string);counter++;
   XtSetArg(args[counter], XmNtopAttachment,XmATTACH_WIDGET);counter++;
   XtSetArg(args[counter], XmNtopWidget,sep);counter++;
   XtSetArg(args[counter], XmNtopOffset,10);counter++;
   XtSetArg(args[counter], XmNrightAttachment,XmATTACH_POSITION);counter++;
   XtSetArg(args[counter], XmNrightPosition, 80);counter++;
   XtSetArg(args[counter], XmNbottomAttachment,XmATTACH_FORM);counter++;
   XtSetArg(args[counter], XmNbottomOffset,10);counter++;
   XtSetArg(args[counter], XmNleftAttachment,XmATTACH_NONE);counter++;
   butt_no = XmCreatePushButton(question,"controlB",args,counter);
   free(xm_string);
   XtAddCallback(butt_no, XmNactivateCallback,
                 (XtCallbackProc) query_no, (XtPointer) term);
   XtManageChild(butt_no);
   
   XtManageChild(question);
   XtAddGrab(question, True, False);
}

void query_yes(Widget w,
                 XtPointer client_data,
                 XmAnyCallbackStruct *call_data)
{
   term_ptr call_term=(term_ptr)(client_data);
   term_ptr agent=call_term->argument_array[0];
   term_ptr reference=call_term->argument_array[1]->argument_array[2];
   term_ptr *response_arg=maketermarray(2);
   term_ptr message_term=maketerm(NONVAR,YES,0,NULL,NULL);
   term_ptr response_term=maketerm(TUPLE,0,2,NULL,response_arg);
   response_arg[0]=reference;
   response_arg[1]=message_term;
   send_to_agent(agent,response_term);
   free(response_term);
   free(message_term);
   free(response_arg);
   free_term(call_term);
   XtDestroyWidget(XtParent(w));
}
void query_no(Widget w,
                 XtPointer client_data,
                 XmAnyCallbackStruct *call_data)
{
   term_ptr call_term=(term_ptr)(client_data);
   term_ptr agent=call_term->argument_array[0];
   term_ptr reference=call_term->argument_array[1]->argument_array[2];
   term_ptr *response_arg=maketermarray(2);
   term_ptr message_term=maketerm(NONVAR,NO,0,NULL,NULL);
   term_ptr response_term=maketerm(TUPLE,0,2,NULL,response_arg);
   response_arg[0]=reference;
   response_arg[1]=message_term;
   send_to_agent(agent,response_term);
   free(response_term);
   free(message_term);
   free(response_arg);
   free_term(call_term);
   XtDestroyWidget(XtParent(w));
}