/*****************************************************************************
*   "Irit" - the 3d polygonal solid modeller.				     *
*									     *
* Written by:  Gershon Elber		               Ver 0.1, Mar. 1990    *
******************************************************************************
* MSDOS graphical interface for IRIT. Based on intr_lib windowing library.   *
*****************************************************************************/

#include <time.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#ifndef DJGCC
#include <conio.h>
#endif /* DJGCC */
#include "graphgen.h"
#include "intr_lib.h"
#include "intr_gr.h"

int ViewWindowID, InputWindowID, StatusWindowID, TransWindowID;

#ifdef DJGCC
#define NUM_OF_TEXT_LINES 200
#else
#define NUM_OF_TEXT_LINES 50
#endif /* DJGCC */

/* Interactive menu setup structure: */
#define INTERACT_NUM_OF_STRINGS		3
#define INTERACT_NUM_OF_SUB_WNDWS_FULL	16
#define INTERACT_NUM_OF_SUB_WNDWS_PART	13
#define INTERACT_SUB_WINDOW_HEIGHT	0.04  /* Actually half Height/Width. */
#define INTERACT_SUB_WINDOW_WIDTH	0.8
#define INTERACT_X_CENTER		((SW_MAX_X + SW_MIN_X) / 2.0 + 0.02)

typedef struct InteractString {
    IntrRType X, Y;
    int Color;
    char *Str;
} InteractString;

typedef struct InteractSubWindow {
    IntrRType X, Y;					   /* Center points. */
    GraphicEventType InteractCode;
    int Color,
	TextInside; /* If TRUE, Str will be in window, otherwise left to it. */
    char *Str;
} InteractSubWindow;

typedef struct InteractWindowStruct {	 /* The interactive menu structures. */
    /* Rotate, Translate, Scale strings: */
    InteractString Strings[INTERACT_NUM_OF_STRINGS];
    InteractSubWindow SubWindows[INTERACT_NUM_OF_SUB_WNDWS_FULL];
} InteractWindowStruct;

static IntrBType
    HasStatusWindow = FALSE,
    HasInputWindow = FALSE;

static int
    InteractNumOfSubWndws = INTERACT_NUM_OF_SUB_WNDWS_FULL;
    
/* Interactive mode menu set up structure is define below: */
static InteractWindowStruct InteractMenuFull = {
    { { 0.0, -0.60, RED,   "Rotate" },
      { 0.0, -0.28, GREEN, "Translate" },
      { 0.0,  0.04, CYAN,  "Scale" },
    },
    { { 0.0, -0.9,  EVENT_SCR_OBJ_TGL,    CYAN,  TRUE,  "Screen Coords." },
      { 0.0, -0.78, EVENT_PERS_ORTHO_TGL, BLUE,   TRUE,  "Perspectiv" },
      { 0.0, -0.7,  EVENT_PERS_ORTHO_Z,   BLUE,   FALSE, "Z" },
      { 0.0, -0.54, EVENT_ROTATE_X,       RED,    FALSE, "X" }, /* Rot */
      { 0.0, -0.46, EVENT_ROTATE_Y,       RED,    FALSE, "Y" },
      { 0.0, -0.38, EVENT_ROTATE_Z,       RED,    FALSE, "Z" },
      { 0.0, -0.22, EVENT_TRANSLATE_X,    GREEN,  FALSE, "X" }, /* Trans */
      { 0.0, -0.14, EVENT_TRANSLATE_Y,    GREEN,  FALSE, "Y" },
      { 0.0, -0.06, EVENT_TRANSLATE_Z,    GREEN,  FALSE, "Z" },
      { 0.0,  0.1,  EVENT_SCALE,          CYAN,   FALSE, "" },  /* Scale */
      { 0.0,  0.26, EVENT_DEPTH_CUE,      MAGENTA,TRUE,  "Depth cue" },
      { 0.0,  0.42, EVENT_SAVE_GIF,       YELLOW, TRUE,  "Save GIF" },
      { 0.0,  0.5,  EVENT_SAVE_PS,        YELLOW, TRUE,  "Save PS" },
      { 0.0,  0.62, EVENT_SAVE_MATRIX,    YELLOW, TRUE,  "Save Matrix" },
      { 0.0,  0.7,  EVENT_RESET_MATRIX,   YELLOW, TRUE,  "Reset Matrix" },
      { 0.0,  0.85, EVENT_QUIT,           WHITE,  TRUE,  "Quit" },
    }
};
static InteractWindowStruct InteractMenuPartial = {
    { { 0.0, -0.60, RED,   "Rotate" },
      { 0.0, -0.28, GREEN, "Translate" },
      { 0.0,  0.04, CYAN,  "Scale" },
    },
    { { 0.0, -0.9,  EVENT_SCR_OBJ_TGL,    CYAN,  TRUE,  "Screen Coords." },
      { 0.0, -0.78, EVENT_PERS_ORTHO_TGL, BLUE,   TRUE,  "Perspectiv" },
      { 0.0, -0.7,  EVENT_PERS_ORTHO_Z,   BLUE,   FALSE, "Z" },
      { 0.0, -0.54, EVENT_ROTATE_X,       RED,    FALSE, "X" }, /* Rot */
      { 0.0, -0.46, EVENT_ROTATE_Y,       RED,    FALSE, "Y" },
      { 0.0, -0.38, EVENT_ROTATE_Z,       RED,    FALSE, "Z" },
      { 0.0, -0.22, EVENT_TRANSLATE_X,    GREEN,  FALSE, "X" }, /* Trans */
      { 0.0, -0.14, EVENT_TRANSLATE_Y,    GREEN,  FALSE, "Y" },
      { 0.0, -0.06, EVENT_TRANSLATE_Z,    GREEN,  FALSE, "Z" },
      { 0.0,  0.1,  EVENT_SCALE,          CYAN,   FALSE, "" },  /* Scale */
      { 0.0,  0.26, EVENT_DEPTH_CUE,      MAGENTA,TRUE,  "Depth cue" },
      { 0.0,  0.42, EVENT_RESET_MATRIX,   YELLOW, TRUE,  "Reset Matrix" },
      { 0.0,  0.58, EVENT_QUIT,           WHITE,  TRUE,  "Quit" },
    }
};
static InteractWindowStruct *InteractMenu = &InteractMenuFull;
	
static IntrPopUpMenuStruct *PUWndwMenu;
static char *PopUpMenuStrs[] = {
    "Redraw All",
    "Move",
    "Resize",
    "Pop",
    "Push",
    "Zoom",
    "Reset",
    "Headers",
};
#define POP_UP_MENU_SIZE (sizeof(PopUpMenuStrs) / sizeof(char *))

static void SetViewWindowFBBox(int WindowID);
static IntrEventType LclGetChar(int *x, int *y);
static void SetBBoxSize(IntrBBoxStruct *BBox, char *GlblTextWindowPos);
static void TransWndwRefreshFunction(int WindowID);
static void TransWndwRefreshFunctionAux(void);
static void StatusWndwRefreshFunction(int WindowID);
static void InteractUpdateMenu(char *Str, int Entry);
static void InputWndwRefreshFunction(int WindowID);
static void SetMaximumBBoxSize(int WindowID);
static void PopUpMenuFunc(int KeyStroke);

/******************************************************************************
* A simple test for the Intr_lib library.				      *
******************************************************************************/
void GGInitIntrLibWindows(int GraphDriver, int FullTransMode)
{
    IntrCursorShapeStruct Cursor;
    IntrBBoxStruct BBox;
    IntrFBBoxStruct FBBox;

    IntrSetSaveBackPath(GlblIntrSaveDisk);
    IntrSetSaveBackMethod(GlblIntrSaveMethod);
    IntrSetHandleInternalEvents(TRUE, FALSE);

#ifdef __MSDOS__
    GRSetDefaultDriver(GraphDriver);
#endif /* __MSDOS */

    if (FullTransMode) {
    	InteractNumOfSubWndws = INTERACT_NUM_OF_SUB_WNDWS_FULL;
	InteractMenu = &InteractMenuFull;
    }
    else {
    	InteractNumOfSubWndws = INTERACT_NUM_OF_SUB_WNDWS_PART;
	InteractMenu = &InteractMenuPartial;
    }

    IntrInit();

    IntrSetMouseSensitivity(GlblMouseSensitivity);
    IntrSetInputDevice((GlblMouseExists ? INTR_INPT_DEVICE_MOUSE : 0) |
		       (GlblJoystickExists ? INTR_INPT_DEVICE_JOYSTICK : 0) |
		       INTR_INPT_DEVICE_KEYBOARD);

    IntrRegisterKeyStroke(0x13B /* F1 */, PopUpMenuFunc);

    /* Set the default cursor to arrow. */
    Cursor.CursorType = INTR_CURSOR_ARROW;
    IntrSetCursorType(&Cursor);

    /* Prepare the pop up menu. */
    PUWndwMenu = IntrPopUpMenuCreate("Windows", PopUpMenuStrs, 0,
				  POP_UP_MENU_SIZE,
				  INTR_COLOR_GREEN, INTR_COLOR_CYAN,
				  INTR_COLOR_YELLOW, INTR_COLOR_MAGENTA,
                                  16, &Cursor);

    SetBBoxSize(&BBox, GlblViewWndwPos);
    ViewWindowID = IntrWndwCreate("View",
				  GlblWindowFrameWidth,
				  &BBox,
				  GlblViewFrameColor,
				  GlblViewBackColor,
				  &Cursor,
				  NULL,
				  NULL);
    IntrWndwSetDrawHeader(ViewWindowID, GlblDrawHeader);
    IntrWndwPop(ViewWindowID, TRUE, FALSE);
    SetViewWindowFBBox(ViewWindowID);
    
    SetBBoxSize(&BBox, GlblTransWndwPos);
    TransWindowID = IntrWndwCreate("Transformations",
				   GlblWindowFrameWidth,
				   &BBox,
				   GlblTransFrameColor,
				   GlblTransBackColor,
				   &Cursor,
				   NULL,
				   TransWndwRefreshFunction);
    FBBox.FXmin = FBBox.FYmin = -1.0;
    FBBox.FXmax = FBBox.FYmax =  1.0;
    if (!FullTransMode) FBBox.FYmax =  0.7;
    IntrWndwSetFBBox(TransWindowID, &FBBox);
    IntrWndwSetDrawHeader(TransWindowID, GlblDrawHeader);
    IntrWndwPop(TransWindowID, TRUE, TRUE);

    if (HasStatusWindow) {
	SetBBoxSize(&BBox, GlblStatusWndwPos);
	StatusWindowID = IntrWndwCreate("Status",
					GlblWindowFrameWidth,
					&BBox,
					GlblStatusFrameColor,
					GlblStatusBackColor,
					&Cursor,
					NULL,
					StatusWndwRefreshFunction);
	IntrWndwSetDrawHeader(StatusWindowID, GlblDrawHeader);
	IntrWndwPop(StatusWindowID, TRUE, TRUE);
    }

    if (HasInputWindow) {
	SetBBoxSize(&BBox, GlblInputWndwPos);
	InputWindowID = IntrWndwCreate("Input",
				       GlblWindowFrameWidth,
				       &BBox,
				       GlblInputFrameColor,
				       GlblInputBackColor,
				       &Cursor,
				       NULL,
				       InputWndwRefreshFunction);
	IntrTextInitWindow(InputWindowID, TRUE, INTR_COLOR_YELLOW,
			   INTR_COLOR_RED, INTR_SCRLBAR_NONE,
			   INTR_SCRLBAR_LEFT, NUM_OF_TEXT_LINES, 90);
	IntrWndwSetDrawHeader(InputWindowID, GlblDrawHeader);
	IntrTextSetSmoothScroll(GlblSmoothTextScroll);
	IntrWndwPop(InputWindowID, TRUE, TRUE);
    }

    /* Make the get line intr_lib routine use this routine to get chars. */
    GRSetGetKeyFunc(LclGetChar);
}

/******************************************************************************
* A function bounded to a quit key.					      *
******************************************************************************/
void GGClosIntrLibWindows(void)
{
    IntrPopUpMenuDelete(PUWndwMenu);
    IntrWndwDelete(ViewWindowID, FALSE);
    IntrWndwDelete(TransWindowID, FALSE);
    if (HasStatusWindow)
	IntrWndwDelete(StatusWindowID, FALSE);
    if (HasInputWindow)
	IntrWndwDelete(InputWindowID, FALSE);

    IntrClose();
}

/******************************************************************************
* Wait for events. Basically waits for an event in the Transformation (Menu)  *
* window and returns its interaction code.		                      *
******************************************************************************/
GraphicEventType GGGetGraphicEvent(RealType *ChangeFactor)
{
    int i, x, y;
    GraphicEventType InteractCode;

    while (TRUE) {
	IntrRType Wx, Wy;

	switch (IntrGetEventWait(&x, &y)) {
	    case INTR_EVNT_SELECT:
		if (IntrMapEventToRWindow(TransWindowID, x, y, &Wx, &Wy)) {
		    if (Wx < -INTERACT_SUB_WINDOW_WIDTH ||
			Wx > INTERACT_SUB_WINDOW_WIDTH)
			break;
		    for (i = 0; i < InteractNumOfSubWndws; i++)
			if (Wy < InteractMenu -> SubWindows[i].Y +
						INTERACT_SUB_WINDOW_HEIGHT &&
			    Wy > InteractMenu -> SubWindows[i].Y -
						INTERACT_SUB_WINDOW_HEIGHT) {
			    InteractCode = InteractMenu -> SubWindows[i].InteractCode;

			    switch (InteractCode) {
				case EVENT_SCR_OBJ_TGL:
				    switch (GlblTransformMode) {
					case TRANS_SCREEN:
					    InteractUpdateMenu("Object Coords.", 0);
					    GlblTransformMode = TRANS_OBJECT;
					    break;
					case TRANS_OBJECT:
					    InteractUpdateMenu("Screen Coords.", 0);
					    GlblTransformMode = TRANS_SCREEN;
					    break;
				    }
				    break;
				case EVENT_PERS_ORTHO_TGL:
				    switch (GlblViewMode) {
					case VIEW_PERSPECTIVE:
					    InteractUpdateMenu("Orthographic", 1);
					    GlblViewMode = VIEW_ORTHOGRAPHIC;
					    break;
					case VIEW_ORTHOGRAPHIC:
					    InteractUpdateMenu("Perspective", 1);
					    GlblViewMode = VIEW_PERSPECTIVE;
					    break;
				    }
				    break;
				case EVENT_DEPTH_CUE:
				    GlblDepthCue = !GlblDepthCue;
				    InteractUpdateMenu(
					GlblDepthCue ? "Depth Cue" : "No Depth Cue",
					10);
				    break;
				default:
				    break;
			    }

			    *ChangeFactor = Wx / INTERACT_SUB_WINDOW_WIDTH;
			    return InteractCode;
			}
		}
		else {
		    PopUpMenuFunc(0);               /* Pop up the main menu. */
		}
		break;
	    case INTR_EVNT_ABORT:
		break;
	}
    }
}

/******************************************************************************
* Similar to GGGetGraphicEvent above but for intr_lib get graphic line        *
* routine GGGetGraphicLine, so it may activate the pop up menu async.         *
******************************************************************************/
static IntrEventType LclGetChar(int *x, int *y)
{
    IntrRType Wx, Wy;
    IntrEventType Event;

    switch (Event = IntrGetEventWait(x, y)) {
	case INTR_EVNT_SELECT:
	    if (!IntrMapEventToRWindow(TransWindowID, *x, *y, &Wx, &Wy)) {
		PopUpMenuFunc(0);                   /* Pop up the main menu. */
	    }
	    break;
    }

    return Event;
}

/******************************************************************************
* Enables/Disables (default) the existance of Input and Status windows.       *
* This function should be called BEFORE InitIntrLibWindows above.	      *
******************************************************************************/
void GGSetStatusInputWindows(IntrBType HasStatusWndw, IntrBType HasInputWndw)
{
    HasStatusWindow = HasStatusWndw;
    HasInputWindow = HasInputWndw;
}

/*****************************************************************************
*  Routine to test if quit display event - occured - SPACE was hit on	     *
* keyboard or right button was clicked on mouse.			     *
*****************************************************************************/
int GGIsAbortKeyPressed(void)
{
    int x, y;

    return IntrGetEventNoWait(&x, &y) == INTR_EVNT_ABORT;
}

/******************************************************************************
* Parse the position string and set the BBox location.			      *
******************************************************************************/
static void SetBBoxSize(IntrBBoxStruct *BBox, char *GlblTextWindowPos)
{
    int i;
    IntrRType XYLoc[4];

    if (sscanf(GlblTextWindowPos, "%f, %f, %f, %f",
	       &XYLoc[0], &XYLoc[1], &XYLoc[2], &XYLoc[3]) != 4) {
	XYLoc[0] = XYLoc[1] = 0.1;
	XYLoc[2] = XYLoc[3] = 0.9;
    }

    for (i = 0; i < 4; i++) {
	if (XYLoc[i] < 0.0) XYLoc[i] = 0.0;
	if (XYLoc[i] > 1.0) XYLoc[i] = 1.0;
    }

    BBox -> Xmin = (int) (XYLoc[0] * GRScreenMaxX);
    BBox -> Ymin = (int) (XYLoc[1] * GRScreenMaxY);
    BBox -> Xmax = (int) (XYLoc[2] * GRScreenMaxX);
    BBox -> Ymax = (int) (XYLoc[3] * GRScreenMaxY);
}


/******************************************************************************
* A routine to compute the normalized floating bbox for the provided window.  *
******************************************************************************/
static void SetViewWindowFBBox(int WindowID)
{
    IntrBBoxStruct *BBox;
    IntrFBBoxStruct FBBox;
    
    /* Compute the aspect ratio of this window and save it so we can match   */
    /* it if the window is resized or zoomed etc.			     */
    BBox = IntrWndwGetBBox(WindowID);
    if (BBox -> _Dy > BBox -> _Dx) {
	/* Normalize the X axis to hold -1 to 1 domain. */
	FBBox.FYmin = 			      /* Note the Y axis is flipped. */
	     (1.0 / GRScreenAspect) * (((IntrRType) BBox -> _Dy) / BBox -> _Dx);
	FBBox.FYmax = -FBBox.FYmin;
	FBBox.FXmin = -1.0;
	FBBox.FXmax = 1.0;
    }
    else {
	/* Normalize the Y axis to hold -1 to 1 domain. */
	FBBox.FYmin = 1.0;		      /* Note the Y axis is flipped. */
        FBBox.FYmax = -1.0;
	FBBox.FXmax =
		     GRScreenAspect * (((IntrRType) BBox -> _Dx) / BBox -> _Dy);
	FBBox.FXmin = -FBBox.FXmax;
    }
    IntrWndwSetFBBox(WindowID, &FBBox);
}

/******************************************************************************
* A routine invoked when ever the Trans window needs to be refreshed.	      *
******************************************************************************/
static void TransWndwRefreshFunction(int WindowID)
{
    switch (GlblTransformMode) {
	case TRANS_SCREEN:
	    InteractMenu -> SubWindows[0].Str = "Screen Coords.";
	    break;
	case TRANS_OBJECT:
	    InteractMenu -> SubWindows[0].Str = "Object Coords.";
	    break;
    }

    switch (GlblViewMode) {
	case VIEW_PERSPECTIVE:
	    InteractMenu -> SubWindows[1].Str = "Perspective";
	    break;
	case VIEW_ORTHOGRAPHIC:
	    InteractMenu -> SubWindows[1].Str = "Orthographic";
	    break;
    }

    if (GlblDepthCue)
	InteractMenu -> SubWindows[10].Str = "Depth Cue";
    else
	InteractMenu -> SubWindows[10].Str = "No Depth Cue";

    TransWndwRefreshFunctionAux();	    /* Draw the transformation menu. */
}

/******************************************************************************
*  Routine to draw the Transformationnu in the Menu window, using the         *
* InteractiveMenu structure defined above.				      *
*  It is assumed that string not inside of SubWindow will be of length 1.     *
******************************************************************************/
static void TransWndwRefreshFunctionAux(void)
{
    int i;

    GRPushTextSetting();
    GRSetTextJustify(GR_TEXT_HJUSTIFY_CENTER,
		     GR_TEXT_VJUSTIFY_CENTER);	   /* Draw strings centered. */

    GRSetLineStyle(GR_SOLID_LINE, 0, GR_NORM_WIDTH);

    for (i = 0; i < INTERACT_NUM_OF_STRINGS; i++) {/* Draw strings of struct.*/
	GRSetColor(InteractMenu -> Strings[i].Color);
	IntrWndwRText(InteractMenu -> Strings[i].X,
		      InteractMenu -> Strings[i].Y,
		      InteractMenu -> Strings[i].Str);
    }

    for (i = 0; i < InteractNumOfSubWndws; i++) {
	/* Draw struct sub windows. */
	GRSetColor(InteractMenu -> SubWindows[i].Color);
	/* Draw the frame of the SubWindow: */
	IntrWndwRMoveTo(
	    InteractMenu -> SubWindows[i].X - INTERACT_SUB_WINDOW_WIDTH,
	    InteractMenu -> SubWindows[i].Y - INTERACT_SUB_WINDOW_HEIGHT);
	IntrWndwRLineTo(
	    InteractMenu -> SubWindows[i].X + INTERACT_SUB_WINDOW_WIDTH,
	    InteractMenu -> SubWindows[i].Y - INTERACT_SUB_WINDOW_HEIGHT);
	IntrWndwRLineTo(
	    InteractMenu -> SubWindows[i].X + INTERACT_SUB_WINDOW_WIDTH,
	    InteractMenu -> SubWindows[i].Y + INTERACT_SUB_WINDOW_HEIGHT);
	IntrWndwRLineTo(
	    InteractMenu -> SubWindows[i].X - INTERACT_SUB_WINDOW_WIDTH,
	    InteractMenu -> SubWindows[i].Y + INTERACT_SUB_WINDOW_HEIGHT);
	IntrWndwRLineTo(
	    InteractMenu -> SubWindows[i].X - INTERACT_SUB_WINDOW_WIDTH,
	    InteractMenu -> SubWindows[i].Y - INTERACT_SUB_WINDOW_HEIGHT);

	/* Now the strings inside (and if outside, a middle vertical line): */
	if (InteractMenu -> SubWindows[i].TextInside)
	    IntrWndwRText(InteractMenu -> SubWindows[i].X,
			  InteractMenu -> SubWindows[i].Y,
			  InteractMenu -> SubWindows[i].Str);
	else {
	    IntrWndwRText(InteractMenu -> SubWindows[i].X -
				INTERACT_SUB_WINDOW_WIDTH - 0.1,
			  InteractMenu -> SubWindows[i].Y,
			  InteractMenu -> SubWindows[i].Str);
	    IntrWndwRLine(InteractMenu -> SubWindows[i].X,
			  InteractMenu -> SubWindows[i].Y -
				INTERACT_SUB_WINDOW_HEIGHT,
			  InteractMenu -> SubWindows[i].X,
			  InteractMenu -> SubWindows[i].Y +
				INTERACT_SUB_WINDOW_HEIGHT);
	}
    }

    GRPopTextSetting();
}

/******************************************************************************
* A routine invoked when ever the Status window needs to be refreshed.	      *
******************************************************************************/
static void StatusWndwRefreshFunction(int WindowID)
{
    GRPushTextSetting();
    GRSetTextJustify(GR_TEXT_HJUSTIFY_CENTER,
		     GR_TEXT_VJUSTIFY_CENTER);	   /* Draw strings centered. */

    GRSetLineStyle(GR_SOLID_LINE, 0, GR_NORM_WIDTH);

    GGMySetColor(GREEN);
    IntrWndwRText(0.0, -0.6, "Irit");

    GGMySetColor(GREEN);
    IntrWndwRText(0.0, -0.2, VERSION);
    
    GGMySetColor(RED);
    IntrWndwRText(0.0, 0.2, "Core Left");

    GRPopTextSetting();
}

/*****************************************************************************
*  Routine to update entry Entry with a new string Str.			     *
*****************************************************************************/
static void InteractUpdateMenu(char *Str, int Entry)
{
    GRPushTextSetting();

    GRSetTextJustify(GR_TEXT_HJUSTIFY_CENTER,
		     GR_TEXT_VJUSTIFY_CENTER);	   /* Draw strings centered. */

    GRPushViewPort();
    IntrWndwPop(TransWindowID, FALSE, FALSE);
    GGViewPortTransArea();

    GRSetColor(BLACK);				    /* Erase the old string. */
    IntrWndwRText(InteractMenu -> SubWindows[Entry].X,
		  InteractMenu -> SubWindows[Entry].Y,
		  InteractMenu -> SubWindows[Entry].Str);

    InteractMenu -> SubWindows[Entry].Str = Str;       /* Update to new one. */

    GRSetColor(InteractMenu -> SubWindows[Entry].Color);/* And draw the new. */
    IntrWndwRText(InteractMenu -> SubWindows[Entry].X,
		  InteractMenu -> SubWindows[Entry].Y,
		  InteractMenu -> SubWindows[Entry].Str);

    GRPopViewPort();

    GRPopTextSetting();
}

/******************************************************************************
* A routine invoked when ever the Input window needs to be refreshed.	      *
******************************************************************************/
static void InputWndwRefreshFunction(int WindowID)
{
    IntrTextWndwRefresh(WindowID);
}

/******************************************************************************
* A function bounded to a window handling key.				      *
******************************************************************************/
static void SetMaximumBBoxSize(int WindowID)
{
   IntrBBoxStruct BBox;

   BBox.Xmin = BBox.Ymin = GlblWindowFrameWidth;
   BBox.Xmax = GRScreenMaxX - GlblWindowFrameWidth;
   BBox.Ymax = GRScreenMaxY - GlblWindowFrameWidth;

   if (WindowID == InputWindowID)
	BBox.Xmin += IntrWndwScrollBarWidth();

   IntrWndwSetResizeBBox(&BBox);
}

/******************************************************************************
* A function bounded to a window handling key.				      *
******************************************************************************/
static void PopUpMenuFunc(int KeyStroke)
{
    int WindowID;
    IntrIntFunc ViewRefreshFunc;
    IntrBBoxStruct BBox;

    if (IntrPopUpMenu(PUWndwMenu, 0)) {
	switch (PUWndwMenu -> SelectedIndex) {
	    case 0: /* Redraw all windows. */
		IntrWndwRedrawAll();
		break;
	    case 1: /* Move window. */
		if (IntrPopUpActive() == 0 &&
		    (WindowID = IntrWndwPick()) > 0)
		    IntrWndwMove(WindowID, TRUE);
		break;
	    case 2: /* Resize window. */
		if (IntrPopUpActive() == 0 &&
		    (WindowID = IntrWndwPick()) > 0) {
		    SetMaximumBBoxSize(WindowID);
		    if (WindowID == ViewWindowID) {
			/* DIsable refresh function since we change aspect. */
			ViewRefreshFunc = IntrWndwGetRefreshFunc(ViewWindowID);
			IntrWndwSetRefreshFunc(ViewWindowID, NULL);
		    }
		    IntrWndwResize(WindowID, TRUE);
		    if (WindowID == ViewWindowID) {
			SetViewWindowFBBox(WindowID);
			IntrWndwSetRefreshFunc(ViewWindowID, ViewRefreshFunc);
			IntrWndwPop(WindowID, TRUE, TRUE);
		    }
		}
		break;
	    case 3: /* Pop window. */
		if (IntrPopUpActive() == 0 &&
		    (WindowID = IntrWndwPick()) > 0)
		    IntrWndwPop(WindowID, TRUE, FALSE);
		break;
	    case 4: /* Push window. */
		if (IntrPopUpActive() == 0 &&
		    (WindowID = IntrWndwPick()) > 0)
		    IntrWndwPush(WindowID, TRUE);
		break;
	    case 5: /* Zoom window. */
		if (IntrPopUpActive() == 0 &&
		    (WindowID = IntrWndwPick()) > 0) {
    		    SetMaximumBBoxSize(WindowID);
		    if (WindowID == ViewWindowID) {
			/* DIsable refresh function since we change aspect. */
			ViewRefreshFunc = IntrWndwGetRefreshFunc(ViewWindowID);
			IntrWndwSetRefreshFunc(ViewWindowID, NULL);
		    }
		    IntrWndwFullSize(WindowID, TRUE);
		    if (WindowID == ViewWindowID) {
			SetViewWindowFBBox(WindowID);
			IntrWndwSetRefreshFunc(ViewWindowID, ViewRefreshFunc);
			IntrWndwPop(WindowID, TRUE, TRUE);
		    }
		}
		break;
	    case 6: /* Reset window sizes. */
		SetBBoxSize(&BBox, GlblViewWndwPos);
		IntrWndwSetBBox(ViewWindowID, &BBox);
		SetBBoxSize(&BBox, GlblTransWndwPos);
		IntrWndwSetBBox(TransWindowID, &BBox);
		if (HasStatusWindow) {
		    SetBBoxSize(&BBox, GlblStatusWndwPos);
		    IntrWndwSetBBox(StatusWindowID, &BBox);
		}
		if (HasInputWindow) {
		    SetBBoxSize(&BBox, GlblInputWndwPos);
    		    IntrWndwSetBBox(InputWindowID, &BBox);
		}
		IntrWndwRedrawAll();
	        break;
	    case 7: /* Headers. */
		GlblDrawHeader = !GlblDrawHeader;
		IntrWndwSetDrawHeader(ViewWindowID, GlblDrawHeader);
		IntrWndwSetDrawHeader(TransWindowID, GlblDrawHeader);
		if (HasStatusWindow)
		    IntrWndwSetDrawHeader(StatusWindowID, GlblDrawHeader);
		if (HasInputWindow)
		    IntrWndwSetDrawHeader(InputWindowID, GlblDrawHeader);
		IntrWndwRedrawAll();
		break;
	}
    }
}